<!-- This file automatically generated by ParseAutoconfTexinfo utility -->
<!-- cvs -d:pserver:anonymous@sources.redhat.com:/cvs/eclipse \        -->
<!--   co autotools/ParseTexinfo                                       -->
<!DOCTYPE macros [

  <!ELEMENT macros (macro)*>

  <!ELEMENT macro (prototype*,synopsis)>
  <!ATTLIST macro
    id ID #REQUIRED
  >

  <!ELEMENT synopsis     (#PCDATA)*>

  <!ELEMENT prototype    (parameter+)?>

  <!ELEMENT parameter (#PCDATA)*>
  <!ATTLIST parameter
    content CDATA #REQUIRED
  >

]>

<macros>
  <macro id="AC_INIT">
      <prototype>
        <parameter content="package"/>
        <parameter content="version"/>
        <parameter content="[bug-report]"/>
        <parameter content="[tarname]"/>
      </prototype>
        <synopsis>
          Process any command-line arguments and perform various
         initializations and verifications.&lt;/P&gt;&lt;P&gt;

         Set the name of the &lt;VAR&gt;package&lt;/VAR&gt; and its
         &lt;VAR&gt;version&lt;/VAR&gt;.  These are typically used in
         &lt;samp&gt;--version&lt;/samp&gt; support, including that of
         &lt;CODE&gt;configure&lt;/CODE&gt;.  The optional argument
         &lt;VAR&gt;bug-report&lt;/VAR&gt; should be the email to which
         users should send bug reports.  The package
         &lt;VAR&gt;tarname&lt;/VAR&gt; differs from
         &lt;VAR&gt;package&lt;/VAR&gt;: the latter designates the full
         package name (e.g., &lt;samp&gt;GNU Autoconf&lt;/samp&gt;),
         while the former is meant for distribution tar ball names (e.g.,
         &lt;samp&gt;autoconf&lt;/samp&gt;).  It defaults to
         &lt;VAR&gt;package&lt;/VAR&gt; with &lt;samp&gt;GNU
         &lt;/samp&gt; stripped, lower-cased, and all characters other
         than alphanumerics and underscores are changed to
         &lt;samp&gt;-&lt;/samp&gt;.&lt;/P&gt;&lt;P&gt;

         It is preferable that the arguments of
         &lt;CODE&gt;AC_INIT&lt;/CODE&gt; be static, i.e., there should
         not be any shell computation, but they can be computed by M4.&lt;/P&gt;&lt;P&gt;

         The following M4 macros (e.g.,
         &lt;CODE&gt;AC_PACKAGE_NAME&lt;/CODE&gt;), output variables
         (e.g., &lt;CODE&gt;PACKAGE_NAME&lt;/CODE&gt;), and preprocessor
         symbols (e.g., &lt;CODE&gt;PACKAGE_NAME&lt;/CODE&gt;) are
         defined by &lt;CODE&gt;AC_INIT&lt;/CODE&gt;:&lt;/P&gt;&lt;P&gt;

         &lt;DL&gt;  &lt;DT&gt;&lt;CODE&gt;AC_PACKAGE_NAME&lt;/CODE&gt;,
         &lt;CODE&gt;PACKAGE_NAME&lt;/CODE&gt; &lt;DD&gt;    Exactly
         &lt;VAR&gt;package&lt;/VAR&gt;.&lt;/P&gt;&lt;P&gt;

         &lt;DT&gt;&lt;CODE&gt;AC_PACKAGE_TARNAME&lt;/CODE&gt;,
         &lt;CODE&gt;PACKAGE_TARNAME&lt;/CODE&gt; &lt;DD&gt;    Exactly
         &lt;VAR&gt;tarname&lt;/VAR&gt;.&lt;/P&gt;&lt;P&gt;

         &lt;DT&gt;&lt;CODE&gt;AC_PACKAGE_VERSION&lt;/CODE&gt;,
         &lt;CODE&gt;PACKAGE_VERSION&lt;/CODE&gt; &lt;DD&gt;    Exactly
         &lt;VAR&gt;version&lt;/VAR&gt;.&lt;/P&gt;&lt;P&gt;

         &lt;DT&gt;&lt;CODE&gt;AC_PACKAGE_STRING&lt;/CODE&gt;,
         &lt;CODE&gt;PACKAGE_STRING&lt;/CODE&gt; &lt;DD&gt;    Exactly
         &lt;samp&gt;&lt;VAR&gt;package&lt;/VAR&gt;
         &lt;VAR&gt;version&lt;/VAR&gt;&lt;/samp&gt;.&lt;/P&gt;&lt;P&gt;

         &lt;DT&gt;&lt;CODE&gt;AC_PACKAGE_BUGREPORT&lt;/CODE&gt;,
         &lt;CODE&gt;PACKAGE_BUGREPORT&lt;/CODE&gt; &lt;DD&gt;    Exactly
         &lt;VAR&gt;bug-report&lt;/VAR&gt;. &lt;/DL&gt;
        </synopsis>
  </macro>
  <macro id="AC_PREREQ">
      <prototype>
        <parameter content="version"/>
      </prototype>
        <synopsis>
           Ensure that a recent enough version of Autoconf is being used.
          If the version of Autoconf being used to create
         &lt;CODE&gt;configure&lt;/CODE&gt; is earlier than
         &lt;VAR&gt;version&lt;/VAR&gt;, print an error message to the
         standard error output and exit with failure (exit status is 63).
          For example:&lt;/P&gt;&lt;P&gt;

         &lt;TABLE&gt;&lt;tr&gt;&lt;td&gt;&amp;nbsp;&lt;/td&gt;&lt;td
         class=example&gt;&lt;pre&gt; AC_PREREQ(VERSION)
         &lt;/pre&gt;&lt;/td&gt;&lt;/tr&gt;&lt;/table&gt;&lt;/P&gt;&lt;P&gt;

         This macro is the only macro that may be used before
         &lt;CODE&gt;AC_INIT&lt;/CODE&gt;, but for consistency, you are
         invited not to do so.
        </synopsis>
  </macro>
  <macro id="AC_COPYRIGHT">
      <prototype>
        <parameter content="copyright-notice"/>
      </prototype>
        <synopsis>
           Notice State that, in addition to the Free Software
         Foundation's copyright on the Autoconf macros, parts of your
         &lt;CODE&gt;configure&lt;/CODE&gt; are covered by the
         &lt;VAR&gt;copyright-notice&lt;/VAR&gt;.&lt;/P&gt;&lt;P&gt;

         The &lt;VAR&gt;copyright-notice&lt;/VAR&gt; will show up in both
         the head of &lt;CODE&gt;configure&lt;/CODE&gt; and in
         &lt;samp&gt;configure --version&lt;/samp&gt;.
        </synopsis>
  </macro>
  <macro id="AC_REVISION">
      <prototype>
        <parameter content="revision-info"/>
      </prototype>
        <synopsis>
           Copy revision stamp &lt;VAR&gt;revision-info&lt;/VAR&gt; into
         the &lt;CODE&gt;configure&lt;/CODE&gt; script, with any dollar
         signs or double-quotes removed.  This macro lets you put a
         revision stamp from &lt;TT&gt;configure.ac&lt;/TT&gt; into
         &lt;CODE&gt;configure&lt;/CODE&gt; without RCS or CVS changing
         it when you check in &lt;CODE&gt;configure&lt;/CODE&gt;.  That
         way, you can determine easily which revision of
         &lt;TT&gt;configure.ac&lt;/TT&gt; a particular
         &lt;CODE&gt;configure&lt;/CODE&gt; corresponds to.&lt;/P&gt;&lt;P&gt;

         For example, this line in &lt;TT&gt;configure.ac&lt;/TT&gt;:&lt;/P&gt;&lt;P&gt;

         &lt;TABLE&gt;&lt;tr&gt;&lt;td&gt;&amp;nbsp;&lt;/td&gt;&lt;td
         class=example&gt;&lt;pre&gt; AC_REVISION($Revision: 1.1 $)
         &lt;/pre&gt;&lt;/td&gt;&lt;/tr&gt;&lt;/table&gt;&lt;/P&gt;&lt;P&gt;

          produces this in &lt;CODE&gt;configure&lt;/CODE&gt;:&lt;/P&gt;&lt;P&gt;

         &lt;TABLE&gt;&lt;tr&gt;&lt;td&gt;&amp;nbsp;&lt;/td&gt;&lt;td
         class=example&gt;&lt;pre&gt; #! /bin/sh # From configure.ac
         Revision: 1.30 &lt;/pre&gt;&lt;/td&gt;&lt;/tr&gt;&lt;/table&gt;
        </synopsis>
  </macro>
  <macro id="AC_CONFIG_SRCDIR">
      <prototype>
        <parameter content="unique-file-in-source-dir"/>
      </prototype>
        <synopsis>
          &lt;VAR&gt;unique-file-in-source-dir&lt;/VAR&gt; is some file
         that is in the package's source directory;
         &lt;CODE&gt;configure&lt;/CODE&gt; checks for this file's
         existence to make sure that the directory that it is told
         contains the source code in fact does.  Occasionally people
         accidentally specify the wrong directory with
         &lt;samp&gt;--srcdir&lt;/samp&gt;; this is a safety check.  ,
         for more information.
        </synopsis>
  </macro>
  <macro id="AC_CONFIG_AUX_DIR">
      <prototype>
        <parameter content="dir"/>
      </prototype>
        <synopsis>
          Use the auxiliary build tools (e.g.,
         &lt;TT&gt;install-sh&lt;/TT&gt;,
         &lt;TT&gt;config.sub&lt;/TT&gt;,
         &lt;TT&gt;config.guess&lt;/TT&gt;, Cygnus
         &lt;CODE&gt;configure&lt;/CODE&gt;, Automake and Libtool scripts
         etc.) that are in directory &lt;VAR&gt;dir&lt;/VAR&gt;. These
         are auxiliary files used in configuration. 
         &lt;VAR&gt;dir&lt;/VAR&gt; can be either absolute or relative to
         &lt;TT&gt;&lt;VAR&gt;srcdir&lt;/VAR&gt;&lt;/TT&gt;.  The default
         is &lt;TT&gt;&lt;VAR&gt;srcdir&lt;/VAR&gt;&lt;/TT&gt; or
         &lt;TT&gt;&lt;VAR&gt;srcdir&lt;/VAR&gt;/..&lt;/TT&gt; or
         &lt;TT&gt;&lt;VAR&gt;srcdir&lt;/VAR&gt;/../..&lt;/TT&gt;,
         whichever is the first that contains
         &lt;TT&gt;install-sh&lt;/TT&gt;.  The other files are not
         checked for, so that using
         &lt;CODE&gt;AC_PROG_INSTALL&lt;/CODE&gt; does not automatically
         require distributing the other auxiliary files.  It checks for
         &lt;TT&gt;install.sh&lt;/TT&gt; also, but that name is obsolete
         because some &lt;CODE&gt;make&lt;/CODE&gt; have a rule that
         creates &lt;TT&gt;install&lt;/TT&gt; from it if there is no
         &lt;TT&gt;Makefile&lt;/TT&gt;.
        </synopsis>
  </macro>
  <macro id="AC_CONFIG_MACRO_DIR">
      <prototype>
        <parameter content="dir"/>
      </prototype>
        <synopsis>
          Future versions of &lt;CODE&gt;autopoint&lt;/CODE&gt;,
         &lt;CODE&gt;libtoolize&lt;/CODE&gt;,
         &lt;CODE&gt;aclocal&lt;/CODE&gt; and
         &lt;CODE&gt;autoreconf&lt;/CODE&gt; will use directory
         &lt;VAR&gt;dir&lt;/VAR&gt; as the location of additional local
         Autoconf macros.  Be sure to call this macro directly from
         &lt;TT&gt;configure.ac&lt;/TT&gt; so that tools that install
         macros for &lt;CODE&gt;aclocal&lt;/CODE&gt; can find the
         declaration before &lt;samp&gt;--trace&lt;/samp&gt; can be
         called safely.
        </synopsis>
  </macro>
  <macro id="AC_OUTPUT">
      <prototype>
      </prototype>
        <synopsis>
           Generate &lt;TT&gt;config.status&lt;/TT&gt; and launch it. 
         Call this macro once, at the end of
         &lt;TT&gt;configure.ac&lt;/TT&gt;.&lt;/P&gt;&lt;P&gt;

         &lt;TT&gt;config.status&lt;/TT&gt; will perform all the
         configuration actions: all the output files (see Configuration
         Files, macro &lt;CODE&gt;AC_CONFIG_FILES&lt;/CODE&gt;), header
         files (see Configuration Headers, macro
         &lt;CODE&gt;AC_CONFIG_HEADERS&lt;/CODE&gt;), commands (see
         Configuration Commands, macro
         &lt;CODE&gt;AC_CONFIG_COMMANDS&lt;/CODE&gt;), links (see
         Configuration Links, macro
         &lt;CODE&gt;AC_CONFIG_LINKS&lt;/CODE&gt;), subdirectories to
         configure (see Subdirectories, macro
         &lt;CODE&gt;AC_CONFIG_SUBDIRS&lt;/CODE&gt;) are honored.&lt;/P&gt;&lt;P&gt;

         The location of your &lt;CODE&gt;AC_OUTPUT&lt;/CODE&gt;
         invocation is the exact point where configuration actions are
         taken: any code afterwards will be executed by
         &lt;CODE&gt;configure&lt;/CODE&gt; once
         &lt;CODE&gt;config.status&lt;/CODE&gt; was run.  If you want to
         bind actions to &lt;CODE&gt;config.status&lt;/CODE&gt; itself
         (independently of whether &lt;CODE&gt;configure&lt;/CODE&gt; is
         being run), see Configuration Commands, , Running Arbitrary
         Configuration Commands.
        </synopsis>
  </macro>
  <macro id="AC_PROG_MAKE_SET">
      <prototype>
      </prototype>
        <synopsis>
           If &lt;CODE&gt;make&lt;/CODE&gt; predefines the Make variable
         &lt;CODE&gt;MAKE&lt;/CODE&gt;, define output variable
         &lt;CODE&gt;SET_MAKE&lt;/CODE&gt; to be empty.  Otherwise,
         define &lt;CODE&gt;SET_MAKE&lt;/CODE&gt; to contain
         &lt;samp&gt;MAKE=make&lt;/samp&gt;.  Calls
         &lt;CODE&gt;AC_SUBST&lt;/CODE&gt; for
         &lt;CODE&gt;SET_MAKE&lt;/CODE&gt;.
        </synopsis>
  </macro>
  <macro id="AC_CONFIG_FILES">
      <prototype>
        <parameter content="file..."/>
        <parameter content="[cmds]"/>
        <parameter content="[init-cmds]"/>
      </prototype>
        <synopsis>
          Make &lt;CODE&gt;AC_OUTPUT&lt;/CODE&gt; create each
         &lt;TT&gt;&lt;VAR&gt;file&lt;/VAR&gt;&lt;/TT&gt; by copying an
         input file (by default
         &lt;TT&gt;&lt;VAR&gt;file&lt;/VAR&gt;.in&lt;/TT&gt;),
         substituting the output variable values. This macro is one of
         the instantiating macros; see Configuration Actions.  , for more
         information on using output variables.  , for more information
         on creating them.  This macro creates the directory that the
         file is in if it doesn't exist.  Usually,
         &lt;TT&gt;Makefile&lt;/TT&gt;s are created this way, but other
         files, such as &lt;TT&gt;.gdbinit&lt;/TT&gt;, can be specified
         as well.&lt;/P&gt;&lt;P&gt;

         Typical calls to &lt;CODE&gt;AC_CONFIG_FILES&lt;/CODE&gt; look
         like this:&lt;/P&gt;&lt;P&gt;

         &lt;TABLE&gt;&lt;tr&gt;&lt;td&gt;&amp;nbsp;&lt;/td&gt;&lt;td
         class=example&gt;&lt;pre&gt; AC_CONFIG_FILES([Makefile
         src/Makefile man/Makefile X/Imakefile])
         AC_CONFIG_FILES([autoconf], [chmod +x autoconf])
         &lt;/pre&gt;&lt;/td&gt;&lt;/tr&gt;&lt;/table&gt;&lt;/P&gt;&lt;P&gt;

         You can override an input file name by appending to
         &lt;VAR&gt;file&lt;/VAR&gt; a colon-separated list of input
         files.  Examples:&lt;/P&gt;&lt;P&gt;

         &lt;TABLE&gt;&lt;tr&gt;&lt;td&gt;&amp;nbsp;&lt;/td&gt;&lt;td
         class=example&gt;&lt;pre&gt;
         AC_CONFIG_FILES([Makefile:boiler/top.mk:boiler/bot.mk]          
               [lib/Makefile:boiler/lib.mk])
         &lt;/pre&gt;&lt;/td&gt;&lt;/tr&gt;&lt;/table&gt;&lt;/P&gt;&lt;P&gt;

          Doing this allows you to keep your file names acceptable to
         MS-DOS, or to prepend and/or append boilerplate to the file.
        </synopsis>
  </macro>
  <macro id="AC_CONFIG_HEADERS">
      <prototype>
        <parameter content="header ..."/>
        <parameter content="[cmds]"/>
        <parameter content="[init-cmds]"/>
      </prototype>
        <synopsis>
           This macro is one of the instantiating macros; see
         Configuration Actions.  Make &lt;CODE&gt;AC_OUTPUT&lt;/CODE&gt;
         create the file(s) in the whitespace-separated list
         &lt;VAR&gt;header&lt;/VAR&gt; containing C preprocessor
         &lt;CODE&gt;#define&lt;/CODE&gt; statements, and replace
         &lt;samp&gt;@@DEFS@@&lt;/samp&gt; in generated files with
         &lt;samp&gt;-DHAVE_CONFIG_H&lt;/samp&gt; instead of the value of
         &lt;CODE&gt;DEFS&lt;/CODE&gt;. The usual name for
         &lt;VAR&gt;header&lt;/VAR&gt; is &lt;TT&gt;config.h&lt;/TT&gt;.&lt;/P&gt;&lt;P&gt;

         If &lt;VAR&gt;header&lt;/VAR&gt; already exists and its contents
         are identical to what &lt;CODE&gt;AC_OUTPUT&lt;/CODE&gt; would
         put in it, it is left alone.  Doing this allows making some
         changes in the configuration without needlessly causing object
         files that depend on the header file to be recompiled.&lt;/P&gt;&lt;P&gt;

         Usually the input file is named
         &lt;TT&gt;&lt;VAR&gt;header&lt;/VAR&gt;.in&lt;/TT&gt;; however,
         you can override the input file name by appending to
         &lt;VAR&gt;header&lt;/VAR&gt; a colon-separated list of input
         files.  Examples:&lt;/P&gt;&lt;P&gt;

         &lt;TABLE&gt;&lt;tr&gt;&lt;td&gt;&amp;nbsp;&lt;/td&gt;&lt;td
         class=example&gt;&lt;pre&gt;
         AC_CONFIG_HEADERS([config.h:config.hin])
         AC_CONFIG_HEADERS([defines.h:defs.pre:defines.h.in:defs.post])
         &lt;/pre&gt;&lt;/td&gt;&lt;/tr&gt;&lt;/table&gt;&lt;/P&gt;&lt;P&gt;

          Doing this allows you to keep your file names acceptable to
         MS-DOS, or to prepend and/or append boilerplate to the file.
        </synopsis>
  </macro>
  <macro id="AH_VERBATIM">
      <prototype>
        <parameter content="key"/>
        <parameter content="template"/>
      </prototype>
        <synopsis>
          Tell &lt;CODE&gt;autoheader&lt;/CODE&gt; to include the
         &lt;VAR&gt;template&lt;/VAR&gt; as-is in the header template
         file.  This &lt;VAR&gt;template&lt;/VAR&gt; is associated with
         the &lt;VAR&gt;key&lt;/VAR&gt;, which is used to sort all the
         different templates and guarantee their uniqueness.  It should
         be a symbol that can be &lt;CODE&gt;AC_DEFINE&lt;/CODE&gt;'d.&lt;/P&gt;&lt;P&gt;

         For example:&lt;/P&gt;&lt;P&gt;

         &lt;TABLE&gt;&lt;tr&gt;&lt;td&gt;&amp;nbsp;&lt;/td&gt;&lt;td
         class=example&gt;&lt;pre&gt; AH_VERBATIM([_GNU_SOURCE], [/*
         Enable GNU extensions on systems that have them.  */ #ifndef
         _GNU_SOURCE # define _GNU_SOURCE #endif])
         &lt;/pre&gt;&lt;/td&gt;&lt;/tr&gt;&lt;/table&gt;
        </synopsis>
  </macro>
  <macro id="AH_TEMPLATE">
      <prototype>
        <parameter content="key"/>
        <parameter content="description"/>
      </prototype>
        <synopsis>
          Tell &lt;CODE&gt;autoheader&lt;/CODE&gt; to generate a template
         for &lt;VAR&gt;key&lt;/VAR&gt;.  This macro generates standard
         templates just like &lt;CODE&gt;AC_DEFINE&lt;/CODE&gt; when a
         &lt;VAR&gt;description&lt;/VAR&gt; is given.&lt;/P&gt;&lt;P&gt;

         For example:&lt;/P&gt;&lt;P&gt;

         &lt;TABLE&gt;&lt;tr&gt;&lt;td&gt;&amp;nbsp;&lt;/td&gt;&lt;td
         class=example&gt;&lt;pre&gt; AH_TEMPLATE([CRAY_STACKSEG_END],   
                  [Define to one of _getb67, GETB67, getb67             
         for Cray-2 and Cray-YMP systems.  This              function is
         required for alloca.c support              on those systems.])
         &lt;/pre&gt;&lt;/td&gt;&lt;/tr&gt;&lt;/table&gt;&lt;/P&gt;&lt;P&gt;

          will generate the following template, with the description
         properly justified.&lt;/P&gt;&lt;P&gt;

         &lt;TABLE&gt;&lt;tr&gt;&lt;td&gt;&amp;nbsp;&lt;/td&gt;&lt;td
         class=example&gt;&lt;pre&gt; /* Define to one of _getb67,
         GETB67, getb67 for Cray-2 and    Cray-YMP systems.  This
         function is required for alloca.c    support on those systems. 
         */ #undef CRAY_STACKSEG_END
         &lt;/pre&gt;&lt;/td&gt;&lt;/tr&gt;&lt;/table&gt;
        </synopsis>
  </macro>
  <macro id="AH_TOP">
      <prototype>
        <parameter content="text"/>
      </prototype>
        <synopsis>
          Include &lt;VAR&gt;text&lt;/VAR&gt; at the top of the header
         template file.
        </synopsis>
  </macro>
  <macro id="AH_BOTTOM">
      <prototype>
        <parameter content="text"/>
      </prototype>
        <synopsis>
          Include &lt;VAR&gt;text&lt;/VAR&gt; at the bottom of the header
         template file.
        </synopsis>
  </macro>
  <macro id="AC_CONFIG_COMMANDS">
      <prototype>
        <parameter content="tag..."/>
        <parameter content="[cmds]"/>
        <parameter content="[init-cmds]"/>
      </prototype>
        <synopsis>
          Specify additional shell commands to run at the end of
         &lt;TT&gt;config.status&lt;/TT&gt;, and shell commands to
         initialize any variables from
         &lt;CODE&gt;configure&lt;/CODE&gt;.  Associate the commands with
         &lt;VAR&gt;tag&lt;/VAR&gt;. Since typically the
         &lt;VAR&gt;cmds&lt;/VAR&gt; create a file,
         &lt;VAR&gt;tag&lt;/VAR&gt; should naturally be the name of that
         file.  If needed, the directory hosting
         &lt;VAR&gt;tag&lt;/VAR&gt; is created. This macro is one of the
         instantiating macros; see Configuration Actions.&lt;/P&gt;&lt;P&gt;

         Here is an unrealistic example:
         &lt;TABLE&gt;&lt;tr&gt;&lt;td&gt;&amp;nbsp;&lt;/td&gt;&lt;td
         class=example&gt;&lt;pre&gt; fubar=42
         AC_CONFIG_COMMANDS([fubar],                    [echo this is
         extra $fubar, and so on.],                    [fubar=$fubar])
         &lt;/pre&gt;&lt;/td&gt;&lt;/tr&gt;&lt;/table&gt;&lt;/P&gt;&lt;P&gt;

         Here is a better one:
         &lt;TABLE&gt;&lt;tr&gt;&lt;td&gt;&amp;nbsp;&lt;/td&gt;&lt;td
         class=example&gt;&lt;pre&gt; AC_CONFIG_COMMANDS([time-stamp],
         [date &gt;time-stamp])
         &lt;/pre&gt;&lt;/td&gt;&lt;/tr&gt;&lt;/table&gt;
        </synopsis>
  </macro>
  <macro id="AC_CONFIG_COMMANDS_PRE">
      <prototype>
        <parameter content="cmds"/>
      </prototype>
        <synopsis>
          Execute the &lt;VAR&gt;cmds&lt;/VAR&gt; right before creating
         &lt;TT&gt;config.status&lt;/TT&gt;.
        </synopsis>
  </macro>
  <macro id="AC_CONFIG_COMMANDS_POST">
      <prototype>
        <parameter content="cmds"/>
      </prototype>
        <synopsis>
          Execute the &lt;VAR&gt;cmds&lt;/VAR&gt; right after creating
         &lt;TT&gt;config.status&lt;/TT&gt;.
        </synopsis>
  </macro>
  <macro id="AC_CONFIG_LINKS">
      <prototype>
        <parameter content="dest:source..."/>
        <parameter content="[cmds]"/>
        <parameter content="[init-cmds]"/>
      </prototype>
        <synopsis>
           Make &lt;CODE&gt;AC_OUTPUT&lt;/CODE&gt; link each of the
         existing files &lt;VAR&gt;source&lt;/VAR&gt; to the
         corresponding link name &lt;VAR&gt;dest&lt;/VAR&gt;.  Makes a
         symbolic link if possible, otherwise a hard link if possible,
         otherwise a copy.  The &lt;VAR&gt;dest&lt;/VAR&gt; and
         &lt;VAR&gt;source&lt;/VAR&gt; names should be relative to the
         top level source or build directory.  This macro is one of the
         instantiating macros; see Configuration Actions.&lt;/P&gt;&lt;P&gt;

         For example, this call:&lt;/P&gt;&lt;P&gt;

         &lt;TABLE&gt;&lt;tr&gt;&lt;td&gt;&amp;nbsp;&lt;/td&gt;&lt;td
         class=example&gt;&lt;pre&gt;
         AC_CONFIG_LINKS(host.h:config/$machine.h                
         object.h:config/$obj_format.h)
         &lt;/pre&gt;&lt;/td&gt;&lt;/tr&gt;&lt;/table&gt;&lt;/P&gt;&lt;P&gt;

          creates in the current directory &lt;TT&gt;host.h&lt;/TT&gt; as
         a link to
         &lt;TT&gt;&lt;VAR&gt;srcdir&lt;/VAR&gt;/config/$machine.h&lt;/TT&gt;,
         and &lt;TT&gt;object.h&lt;/TT&gt; as a link to
         &lt;TT&gt;&lt;VAR&gt;srcdir&lt;/VAR&gt;/config/$obj_format.h&lt;/TT&gt;.&lt;/P&gt;&lt;P&gt;

         The tempting value &lt;samp&gt;.&lt;/samp&gt; for
         &lt;VAR&gt;dest&lt;/VAR&gt; is invalid: it makes it impossible
         for &lt;samp&gt;config.status&lt;/samp&gt; to guess the links to
         establish.&lt;/P&gt;&lt;P&gt;

         One can then run:
         &lt;TABLE&gt;&lt;tr&gt;&lt;td&gt;&amp;nbsp;&lt;/td&gt;&lt;td
         class=example&gt;&lt;pre&gt; ./config.status host.h object.h
         &lt;/pre&gt;&lt;/td&gt;&lt;/tr&gt;&lt;/table&gt;  to create the
         links.
        </synopsis>
  </macro>
  <macro id="AC_CONFIG_SUBDIRS">
      <prototype>
        <parameter content="dir ..."/>
      </prototype>
        <synopsis>
           Make &lt;CODE&gt;AC_OUTPUT&lt;/CODE&gt; run
         &lt;CODE&gt;configure&lt;/CODE&gt; in each subdirectory
         &lt;VAR&gt;dir&lt;/VAR&gt; in the given whitespace-separated
         list.  Each &lt;VAR&gt;dir&lt;/VAR&gt; should be a literal,
         i.e., please do not use:&lt;/P&gt;&lt;P&gt;

         &lt;TABLE&gt;&lt;tr&gt;&lt;td&gt;&amp;nbsp;&lt;/td&gt;&lt;td
         class=example&gt;&lt;pre&gt; if test "$package_foo_enabled" =
         yes; then   $my_subdirs="$my_subdirs foo" fi
         AC_CONFIG_SUBDIRS($my_subdirs)
         &lt;/pre&gt;&lt;/td&gt;&lt;/tr&gt;&lt;/table&gt;&lt;/P&gt;&lt;P&gt;

          because this prevents &lt;samp&gt;./configure
         --help=recursive&lt;/samp&gt; from displaying the options of the
         package &lt;CODE&gt;foo&lt;/CODE&gt;.  Rather, you should write:&lt;/P&gt;&lt;P&gt;

         &lt;TABLE&gt;&lt;tr&gt;&lt;td&gt;&amp;nbsp;&lt;/td&gt;&lt;td
         class=example&gt;&lt;pre&gt; if test "$package_foo_enabled" =
         yes; then   AC_CONFIG_SUBDIRS(foo) fi
         &lt;/pre&gt;&lt;/td&gt;&lt;/tr&gt;&lt;/table&gt;&lt;/P&gt;&lt;P&gt;

         If a given &lt;VAR&gt;dir&lt;/VAR&gt; is not found, an error is
         reported: if the subdirectory is optional, write:&lt;/P&gt;&lt;P&gt;

         &lt;TABLE&gt;&lt;tr&gt;&lt;td&gt;&amp;nbsp;&lt;/td&gt;&lt;td
         class=example&gt;&lt;pre&gt; if test -d $srcdir/foo; then  
         AC_CONFIG_SUBDIRS(foo) fi
         &lt;/pre&gt;&lt;/td&gt;&lt;/tr&gt;&lt;/table&gt;&lt;/P&gt;&lt;P&gt;

         If a given &lt;VAR&gt;dir&lt;/VAR&gt; contains
         &lt;CODE&gt;configure.gnu&lt;/CODE&gt;, it is run instead of
         &lt;CODE&gt;configure&lt;/CODE&gt;.  This is for packages that
         might use a non-Autoconf script
         &lt;CODE&gt;Configure&lt;/CODE&gt;, which can't be called
         through a wrapper &lt;CODE&gt;configure&lt;/CODE&gt; since it
         would be the same file on case-insensitive filesystems. 
         Likewise, if a &lt;VAR&gt;dir&lt;/VAR&gt; contains
         &lt;TT&gt;configure.in&lt;/TT&gt; but no
         &lt;CODE&gt;configure&lt;/CODE&gt;, the Cygnus
         &lt;CODE&gt;configure&lt;/CODE&gt; script found by
         &lt;CODE&gt;AC_CONFIG_AUX_DIR&lt;/CODE&gt; is used.&lt;/P&gt;&lt;P&gt;

         The subdirectory &lt;CODE&gt;configure&lt;/CODE&gt; scripts are
         given the same command line options that were given to this
         &lt;CODE&gt;configure&lt;/CODE&gt; script, with minor changes if
         needed, which include:&lt;/P&gt;&lt;P&gt;

         &lt;UL&gt; &lt;LI&gt; adjusting a relative path for the cache
         file;&lt;/P&gt;&lt;P&gt;

         &lt;LI&gt; adjusting a relative path for the source directory;&lt;/P&gt;&lt;P&gt;

         &lt;LI&gt; propagating the current value of
         &lt;CODE&gt;$prefix&lt;/CODE&gt;, including if it was defaulted,
         and if the default values of the top level and of the
         subdirectory &lt;TT&gt;configure&lt;/TT&gt; differ. &lt;/UL&gt;&lt;/P&gt;&lt;P&gt;

         This macro also sets the output variable
         &lt;CODE&gt;subdirs&lt;/CODE&gt; to the list of directories
         &lt;samp&gt;&lt;VAR&gt;dir&lt;/VAR&gt;
         &lt;small&gt;...&lt;/small&gt;&lt;/samp&gt;. 
         &lt;TT&gt;Makefile&lt;/TT&gt; rules can use this variable to
         determine which subdirectories to recurse into.&lt;/P&gt;&lt;P&gt;

         This macro may be called multiple times.
        </synopsis>
  </macro>
  <macro id="AC_PREFIX_DEFAULT">
      <prototype>
        <parameter content="prefix"/>
      </prototype>
        <synopsis>
          Set the default installation prefix to
         &lt;VAR&gt;prefix&lt;/VAR&gt; instead of
         &lt;TT&gt;/usr/local&lt;/TT&gt;.
        </synopsis>
  </macro>
  <macro id="AC_PREFIX_PROGRAM">
      <prototype>
        <parameter content="program"/>
      </prototype>
        <synopsis>
          If the user did not specify an installation prefix (using the
         &lt;samp&gt;--prefix&lt;/samp&gt; option), guess a value for it
         by looking for &lt;VAR&gt;program&lt;/VAR&gt; in
         &lt;CODE&gt;PATH&lt;/CODE&gt;, the way the shell does.  If
         &lt;VAR&gt;program&lt;/VAR&gt; is found, set the prefix to the
         parent of the directory containing
         &lt;VAR&gt;program&lt;/VAR&gt;, else default the prefix as
         described above (&lt;TT&gt;/usr/local&lt;/TT&gt; or
         &lt;CODE&gt;AC_PREFIX_DEFAULT&lt;/CODE&gt;).  For example, if
         &lt;VAR&gt;program&lt;/VAR&gt; is &lt;CODE&gt;gcc&lt;/CODE&gt;
         and the &lt;CODE&gt;PATH&lt;/CODE&gt; contains
         &lt;TT&gt;/usr/local/gnu/bin/gcc&lt;/TT&gt;, set the prefix to
         &lt;TT&gt;/usr/local/gnu&lt;/TT&gt;.
        </synopsis>
  </macro>
  <macro id="AC_DEFAULT_INCLUDES">
      <prototype>
        <parameter content="[include-directives]"/>
      </prototype>
        <synopsis>
          Expand to &lt;VAR&gt;include-directives&lt;/VAR&gt; if defined,
         otherwise to:&lt;/P&gt;&lt;P&gt;

         &lt;TABLE&gt;&lt;tr&gt;&lt;td&gt;&amp;nbsp;&lt;/td&gt;&lt;td
         class=example&gt;&lt;pre&gt; @group #include &lt;stdio.h&gt; #if
         HAVE_SYS_TYPES_H # include &lt;sys/types.h&gt; #endif #if
         HAVE_SYS_STAT_H # include &lt;sys/stat.h&gt; #endif #if
         STDC_HEADERS # include &lt;stdlib.h&gt; # include
         &lt;stddef.h&gt; #else # if HAVE_STDLIB_H #  include
         &lt;stdlib.h&gt; # endif #endif #if HAVE_STRING_H # if
         !STDC_HEADERS &amp;&amp; HAVE_MEMORY_H #  include
         &lt;memory.h&gt; # endif # include &lt;string.h&gt; #endif #if
         HAVE_STRINGS_H # include &lt;strings.h&gt; #endif #if
         HAVE_INTTYPES_H # include &lt;inttypes.h&gt; #else # if
         HAVE_STDINT_H #  include &lt;stdint.h&gt; # endif #endif #if
         HAVE_UNISTD_H # include &lt;unistd.h&gt; #endif @end group
         &lt;/pre&gt;&lt;/td&gt;&lt;/tr&gt;&lt;/table&gt;&lt;/P&gt;&lt;P&gt;

         If the default includes are used, then check for the presence of
         these headers and their compatibility, i.e., you don't need to
         run &lt;CODE&gt;AC_HEADERS_STDC&lt;/CODE&gt;, nor check for
         &lt;TT&gt;stdlib.h&lt;/TT&gt; etc.&lt;/P&gt;&lt;P&gt;

         These headers are checked for in the same order as they are
         included. For instance, on some systems
         &lt;TT&gt;string.h&lt;/TT&gt; and &lt;TT&gt;strings.h&lt;/TT&gt;
         both exist, but conflict.  Then
         &lt;CODE&gt;HAVE_STRING_H&lt;/CODE&gt; will be defined, but
         &lt;CODE&gt;HAVE_STRINGS_H&lt;/CODE&gt; won't.
        </synopsis>
  </macro>
  <macro id="AC_PROG_AWK">
      <prototype>
      </prototype>
        <synopsis>
           Check for &lt;CODE&gt;gawk&lt;/CODE&gt;,
         &lt;CODE&gt;mawk&lt;/CODE&gt;, &lt;CODE&gt;nawk&lt;/CODE&gt;,
         and &lt;CODE&gt;awk&lt;/CODE&gt;, in that order, and set output
         variable &lt;CODE&gt;AWK&lt;/CODE&gt; to the first one that is
         found. It tries &lt;CODE&gt;gawk&lt;/CODE&gt; first because that
         is reported to be the best implementation.
        </synopsis>
  </macro>
  <macro id="AC_PROG_EGREP">
      <prototype>
      </prototype>
        <synopsis>
           Check for &lt;CODE&gt;grep -E&lt;/CODE&gt; and
         &lt;CODE&gt;egrep&lt;/CODE&gt;, in that order, and set output
         variable &lt;CODE&gt;EGREP&lt;/CODE&gt; to the first one that is
         found.
        </synopsis>
  </macro>
  <macro id="AC_PROG_FGREP">
      <prototype>
      </prototype>
        <synopsis>
           Check for &lt;CODE&gt;grep -F&lt;/CODE&gt; and
         &lt;CODE&gt;fgrep&lt;/CODE&gt;, in that order, and set output
         variable &lt;CODE&gt;FGREP&lt;/CODE&gt; to the first one that is
         found.
        </synopsis>
  </macro>
  <macro id="AC_PROG_INSTALL">
      <prototype>
      </prototype>
        <synopsis>
              Set output variable &lt;CODE&gt;INSTALL&lt;/CODE&gt; to the
         path of a BSD-compatible &lt;CODE&gt;install&lt;/CODE&gt;
         program, if one is found in the current
         &lt;CODE&gt;PATH&lt;/CODE&gt;. Otherwise, set
         &lt;CODE&gt;INSTALL&lt;/CODE&gt; to
         &lt;samp&gt;&lt;VAR&gt;dir&lt;/VAR&gt;/install-sh
         -c&lt;/samp&gt;, checking the directories specified to
         &lt;CODE&gt;AC_CONFIG_AUX_DIR&lt;/CODE&gt; (or its default
         directories) to determine &lt;VAR&gt;dir&lt;/VAR&gt; (Output). 
         Also set the variables &lt;CODE&gt;INSTALL_PROGRAM&lt;/CODE&gt;
         and &lt;CODE&gt;INSTALL_SCRIPT&lt;/CODE&gt; to
         &lt;samp&gt;$INSTALL@&lt;/samp&gt; and
         &lt;CODE&gt;INSTALL_DATA&lt;/CODE&gt; to
         &lt;samp&gt;$INSTALL@&lt;/samp&gt; -m 644.&lt;/P&gt;&lt;P&gt;

         This macro screens out various instances of
         &lt;CODE&gt;install&lt;/CODE&gt; known not to work.  It prefers
         to find a C program rather than a shell script, for speed. 
         Instead of &lt;TT&gt;install-sh&lt;/TT&gt;, it can also use
         &lt;TT&gt;install.sh&lt;/TT&gt;, but that name is obsolete
         because some &lt;CODE&gt;make&lt;/CODE&gt; programs have a rule
         that creates &lt;TT&gt;install&lt;/TT&gt; from it if there is no
         &lt;TT&gt;Makefile&lt;/TT&gt;.&lt;/P&gt;&lt;P&gt;

         Autoconf comes with a copy of &lt;TT&gt;install-sh&lt;/TT&gt;
         that you can use.  If you use
         &lt;CODE&gt;AC_PROG_INSTALL&lt;/CODE&gt;, you must include
         either &lt;TT&gt;install-sh&lt;/TT&gt; or
         &lt;TT&gt;install.sh&lt;/TT&gt; in your distribution, or
         &lt;CODE&gt;configure&lt;/CODE&gt; will produce an error message
         saying it can't find them---even if the system you're on has a
         good &lt;CODE&gt;install&lt;/CODE&gt; program. This check is a
         safety measure to prevent you from accidentally leaving that
         file out, which would prevent your package from installing on
         systems that don't have a BSD-compatible
         &lt;CODE&gt;install&lt;/CODE&gt; program.&lt;/P&gt;&lt;P&gt;

         If you need to use your own installation program because it has
         features not found in standard &lt;CODE&gt;install&lt;/CODE&gt;
         programs, there is no reason to use
         &lt;CODE&gt;AC_PROG_INSTALL&lt;/CODE&gt;; just put the file name
         of your program into your &lt;TT&gt;Makefile.in&lt;/TT&gt;
         files.
        </synopsis>
  </macro>
  <macro id="AC_PROG_LEX">
      <prototype>
      </prototype>
        <synopsis>
              If &lt;CODE&gt;flex&lt;/CODE&gt; is found, set output
         variable &lt;CODE&gt;LEX&lt;/CODE&gt; to
         &lt;samp&gt;flex&lt;/samp&gt; and
         &lt;CODE&gt;LEXLIB&lt;/CODE&gt; to
         &lt;samp&gt;-lfl&lt;/samp&gt;, if that library is in a standard
         place.  Otherwise set &lt;CODE&gt;LEX&lt;/CODE&gt; to
         &lt;samp&gt;lex&lt;/samp&gt; and &lt;CODE&gt;LEXLIB&lt;/CODE&gt;
         to &lt;samp&gt;-ll&lt;/samp&gt;.&lt;/P&gt;&lt;P&gt;

         Define &lt;CODE&gt;YYTEXT_POINTER&lt;/CODE&gt; if
         &lt;CODE&gt;yytext&lt;/CODE&gt; is a &lt;samp&gt;char
         *&lt;/samp&gt; instead of a &lt;samp&gt;char []&lt;/samp&gt;. 
         Also set output variable
         &lt;CODE&gt;LEX_OUTPUT_ROOT&lt;/CODE&gt; to the base of the file
         name that the lexer generates; usually
         &lt;TT&gt;lex.yy&lt;/TT&gt;, but sometimes something else. 
         These results vary according to whether
         &lt;CODE&gt;lex&lt;/CODE&gt; or &lt;CODE&gt;flex&lt;/CODE&gt; is
         being used.&lt;/P&gt;&lt;P&gt;

         You are encouraged to use Flex in your sources, since it is both
         more pleasant to use than plain Lex and the C source it produces
         is portable. In order to ensure portability, however, you must
         either provide a function &lt;CODE&gt;yywrap&lt;/CODE&gt; or, if
         you don't use it (e.g., your scanner has no
         &lt;samp&gt;#include&lt;/samp&gt;-like feature), simply include
         a &lt;samp&gt;%noyywrap&lt;/samp&gt; statement in the scanner's
         source.  Once this done, the scanner is portable (unless
         &lt;EM&gt;you&lt;/EM&gt; felt free to use nonportable
         constructs) and does not depend on any library.  In this case,
         and in this case only, it is suggested that you use this
         Autoconf snippet:&lt;/P&gt;&lt;P&gt;

         &lt;TABLE&gt;&lt;tr&gt;&lt;td&gt;&amp;nbsp;&lt;/td&gt;&lt;td
         class=example&gt;&lt;pre&gt; AC_PROG_LEX if test "$LEX" != flex;
         then   LEX="$SHELL $missing_dir/missing flex"  
         AC_SUBST(LEX_OUTPUT_ROOT, lex.yy)   AC_SUBST(LEXLIB, '') fi
         &lt;/pre&gt;&lt;/td&gt;&lt;/tr&gt;&lt;/table&gt;&lt;/P&gt;&lt;P&gt;

         The shell script &lt;CODE&gt;missing&lt;/CODE&gt; can be found
         in the Automake distribution.&lt;/P&gt;&lt;P&gt;

         To ensure backward compatibility, Automake's
         &lt;CODE&gt;AM_PROG_LEX&lt;/CODE&gt; invokes (indirectly) this
         macro twice, which will cause an annoying but benign
         ``&lt;CODE&gt;AC_PROG_LEX&lt;/CODE&gt; invoked multiple times''
         warning.  Future versions of Automake will fix this issue;
         meanwhile, just ignore this message.
        </synopsis>
  </macro>
  <macro id="AC_PROG_LN_S">
      <prototype>
      </prototype>
        <synopsis>
           If &lt;samp&gt;ln -s&lt;/samp&gt; works on the current file
         system (the operating system and file system support symbolic
         links), set the output variable &lt;CODE&gt;LN_S&lt;/CODE&gt; to
         &lt;samp&gt;ln -s&lt;/samp&gt;; otherwise, if
         &lt;samp&gt;ln&lt;/samp&gt; works, set
         &lt;CODE&gt;LN_S&lt;/CODE&gt; to &lt;samp&gt;ln&lt;/samp&gt;,
         and otherwise set it to &lt;samp&gt;cp -p&lt;/samp&gt;.&lt;/P&gt;&lt;P&gt;

         If you make a link in a directory other than the current
         directory, its meaning depends on whether
         &lt;samp&gt;ln&lt;/samp&gt; or &lt;samp&gt;ln -s&lt;/samp&gt; is
         used.  To safely create links using
         &lt;samp&gt;$(LN_S)&lt;/samp&gt;, either find out which form is
         used and adjust the arguments, or always invoke
         &lt;CODE&gt;ln&lt;/CODE&gt; in the directory where the link is
         to be created.&lt;/P&gt;&lt;P&gt;

         In other words, it does not work to do:
         &lt;TABLE&gt;&lt;tr&gt;&lt;td&gt;&amp;nbsp;&lt;/td&gt;&lt;td
         class=example&gt;&lt;pre&gt; $(LN_S) foo /x/bar
         &lt;/pre&gt;&lt;/td&gt;&lt;/tr&gt;&lt;/table&gt;&lt;/P&gt;&lt;P&gt;

         Instead, do:&lt;/P&gt;&lt;P&gt;

         &lt;TABLE&gt;&lt;tr&gt;&lt;td&gt;&amp;nbsp;&lt;/td&gt;&lt;td
         class=example&gt;&lt;pre&gt; (cd /x &amp;&amp; $(LN_S) foo bar)
         &lt;/pre&gt;&lt;/td&gt;&lt;/tr&gt;&lt;/table&gt;
        </synopsis>
  </macro>
  <macro id="AC_PROG_RANLIB">
      <prototype>
      </prototype>
        <synopsis>
           Set output variable &lt;CODE&gt;RANLIB&lt;/CODE&gt; to
         &lt;samp&gt;ranlib&lt;/samp&gt; if
         &lt;CODE&gt;ranlib&lt;/CODE&gt; is found, and otherwise to
         &lt;samp&gt;:&lt;/samp&gt; (do nothing).
        </synopsis>
  </macro>
  <macro id="AC_PROG_YACC">
      <prototype>
      </prototype>
        <synopsis>
           If &lt;CODE&gt;bison&lt;/CODE&gt; is found, set output
         variable &lt;CODE&gt;YACC&lt;/CODE&gt; to &lt;samp&gt;bison
         -y&lt;/samp&gt;.  Otherwise, if &lt;CODE&gt;byacc&lt;/CODE&gt;
         is found, set &lt;CODE&gt;YACC&lt;/CODE&gt; to
         &lt;samp&gt;byacc&lt;/samp&gt;.  Otherwise set
         &lt;CODE&gt;YACC&lt;/CODE&gt; to &lt;samp&gt;yacc&lt;/samp&gt;.
        </synopsis>
  </macro>
  <macro id="AC_CHECK_PROG">
      <prototype>
        <parameter content="variable"/>
        <parameter content="prog-to-check-for"/>
        <parameter content="value-if-found"/>
        <parameter content="[value-if-not-found]"/>
        <parameter content="[path]"/>
        <parameter content=" [reject]"/>
      </prototype>
        <synopsis>
          Check whether program &lt;VAR&gt;prog-to-check-for&lt;/VAR&gt;
         exists in &lt;CODE&gt;PATH&lt;/CODE&gt;.  If it is found, set
         &lt;VAR&gt;variable&lt;/VAR&gt; to
         &lt;VAR&gt;value-if-found&lt;/VAR&gt;, otherwise to
         &lt;VAR&gt;value-if-not-found&lt;/VAR&gt;, if given.  Always
         pass over &lt;VAR&gt;reject&lt;/VAR&gt; (an absolute file name)
         even if it is the first found in the search path; in that case,
         set &lt;VAR&gt;variable&lt;/VAR&gt; using the absolute file name
         of the &lt;VAR&gt;prog-to-check-for&lt;/VAR&gt; found that is
         not &lt;VAR&gt;reject&lt;/VAR&gt;.  If
         &lt;VAR&gt;variable&lt;/VAR&gt; was already set, do nothing. 
         Calls &lt;CODE&gt;AC_SUBST&lt;/CODE&gt; for
         &lt;VAR&gt;variable&lt;/VAR&gt;.
        </synopsis>
  </macro>
  <macro id="AC_CHECK_PROGS">
      <prototype>
        <parameter content="variable"/>
        <parameter content="progs-to-check-for"/>
        <parameter content="[value-if-not-found]"/>
        <parameter content="[path]"/>
      </prototype>
        <synopsis>
          Check for each program in the whitespace-separated list
         &lt;VAR&gt;progs-to-check-for&lt;/VAR&gt; existing in the
         &lt;CODE&gt;PATH&lt;/CODE&gt;.  If one is found, set
         &lt;VAR&gt;variable&lt;/VAR&gt; to the name of that program. 
         Otherwise, continue checking the next program in the list.  If
         none of the programs in the list are found, set
         &lt;VAR&gt;variable&lt;/VAR&gt; to
         &lt;VAR&gt;value-if-not-found&lt;/VAR&gt;; if
         &lt;VAR&gt;value-if-not-found&lt;/VAR&gt; is not specified, the
         value of &lt;VAR&gt;variable&lt;/VAR&gt; is not changed.  Calls
         &lt;CODE&gt;AC_SUBST&lt;/CODE&gt; for
         &lt;VAR&gt;variable&lt;/VAR&gt;.
        </synopsis>
  </macro>
  <macro id="AC_CHECK_TOOL">
      <prototype>
        <parameter content="variable"/>
        <parameter content="prog-to-check-for"/>
        <parameter content="[value-if-not-found]"/>
        <parameter content="[path]"/>
      </prototype>
        <synopsis>
          Like &lt;CODE&gt;AC_CHECK_PROG&lt;/CODE&gt;, but first looks
         for &lt;VAR&gt;prog-to-check-for&lt;/VAR&gt; with a prefix of
         the host type as determined by
         &lt;CODE&gt;AC_CANONICAL_HOST&lt;/CODE&gt;, followed by a dash
         (Canonicalizing). For example, if the user runs
         &lt;samp&gt;configure --host=i386-gnu&lt;/samp&gt;, then this
         call:
         &lt;TABLE&gt;&lt;tr&gt;&lt;td&gt;&amp;nbsp;&lt;/td&gt;&lt;td
         class=example&gt;&lt;pre&gt; AC_CHECK_TOOL(RANLIB, ranlib, :)
         &lt;/pre&gt;&lt;/td&gt;&lt;/tr&gt;&lt;/table&gt;  sets
         &lt;CODE&gt;RANLIB&lt;/CODE&gt; to
         &lt;TT&gt;i386-gnu-ranlib&lt;/TT&gt; if that program exists in
         &lt;CODE&gt;PATH&lt;/CODE&gt;, or otherwise to
         &lt;samp&gt;ranlib&lt;/samp&gt; if that program exists in
         &lt;CODE&gt;PATH&lt;/CODE&gt;, or to &lt;samp&gt;:&lt;/samp&gt;
         if neither program exists.
        </synopsis>
  </macro>
  <macro id="AC_CHECK_TOOLS">
      <prototype>
        <parameter content="variable"/>
        <parameter content="progs-to-check-for"/>
        <parameter content="[value-if-not-found]"/>
        <parameter content="[path]"/>
      </prototype>
        <synopsis>
          Like &lt;CODE&gt;AC_CHECK_TOOL&lt;/CODE&gt;, each of the tools
         in the list &lt;VAR&gt;progs-to-check-for&lt;/VAR&gt; are
         checked with a prefix of the host type as determined by
         &lt;CODE&gt;AC_CANONICAL_HOST&lt;/CODE&gt;, followed by a dash
         (Canonicalizing).  If none of the tools can be found with a
         prefix, then the first one without a prefix is used.  If a tool
         is found, set &lt;VAR&gt;variable&lt;/VAR&gt; to the name of
         that program.  If none of the tools in the list are found, set
         &lt;VAR&gt;variable&lt;/VAR&gt; to
         &lt;VAR&gt;value-if-not-found&lt;/VAR&gt;; if
         &lt;VAR&gt;value-if-not-found&lt;/VAR&gt; is not specified, the
         value of &lt;VAR&gt;variable&lt;/VAR&gt; is not changed.  Calls
         &lt;CODE&gt;AC_SUBST&lt;/CODE&gt; for
         &lt;VAR&gt;variable&lt;/VAR&gt;.
        </synopsis>
  </macro>
  <macro id="AC_PATH_PROG">
      <prototype>
        <parameter content="variable"/>
        <parameter content="prog-to-check-for"/>
        <parameter content="[value-if-not-found]"/>
        <parameter content="[path]"/>
      </prototype>
        <synopsis>
          Like &lt;CODE&gt;AC_CHECK_PROG&lt;/CODE&gt;, but set
         &lt;VAR&gt;variable&lt;/VAR&gt; to the entire path of
         &lt;VAR&gt;prog-to-check-for&lt;/VAR&gt; if found.
        </synopsis>
  </macro>
  <macro id="AC_PATH_PROGS">
      <prototype>
        <parameter content="variable"/>
        <parameter content="progs-to-check-for"/>
        <parameter content="[value-if-not-found]"/>
        <parameter content="[path]"/>
      </prototype>
        <synopsis>
          Like &lt;CODE&gt;AC_CHECK_PROGS&lt;/CODE&gt;, but if any of
         &lt;VAR&gt;progs-to-check-for&lt;/VAR&gt; are found, set
         &lt;VAR&gt;variable&lt;/VAR&gt; to the entire path of the
         program found.
        </synopsis>
  </macro>
  <macro id="AC_PATH_TOOL">
      <prototype>
        <parameter content="variable"/>
        <parameter content="prog-to-check-for"/>
        <parameter content="[value-if-not-found]"/>
        <parameter content="[path]"/>
      </prototype>
        <synopsis>
          Like &lt;CODE&gt;AC_CHECK_TOOL&lt;/CODE&gt;, but set
         &lt;VAR&gt;variable&lt;/VAR&gt; to the entire path of the
         program if it is found.
        </synopsis>
  </macro>
  <macro id="AC_CHECK_FILE">
      <prototype>
        <parameter content="file"/>
        <parameter content="[action-if-found]"/>
        <parameter content="[action-if-not-found]"/>
      </prototype>
        <synopsis>
          Check whether file &lt;VAR&gt;file&lt;/VAR&gt; exists on the
         native system.  If it is found, execute
         &lt;VAR&gt;action-if-found&lt;/VAR&gt;, otherwise do
         &lt;VAR&gt;action-if-not-found&lt;/VAR&gt;, if given.
        </synopsis>
  </macro>
  <macro id="AC_CHECK_FILES">
      <prototype>
        <parameter content="files"/>
        <parameter content="[action-if-found]"/>
        <parameter content="[action-if-not-found]"/>
      </prototype>
        <synopsis>
          Executes &lt;CODE&gt;AC_CHECK_FILE&lt;/CODE&gt; once for each
         file listed in &lt;VAR&gt;files&lt;/VAR&gt;. Additionally,
         defines
         &lt;samp&gt;HAVE_&lt;VAR&gt;file&lt;/VAR&gt;&lt;/samp&gt;
         (Standard Symbols) for each file found.
        </synopsis>
  </macro>
  <macro id="AC_CHECK_LIB">
      <prototype>
        <parameter content="library"/>
        <parameter content="function"/>
        <parameter content="[action-if-found]"/>
        <parameter content="[action-if-not-found]"/>
        <parameter content="[other-libraries]"/>
      </prototype>
        <synopsis>
          Depending on the current language(Language Choice), try to
         ensure that the C, C++, or Fortran function
         &lt;VAR&gt;function&lt;/VAR&gt; is available by checking whether
         a test program can be linked with the library
         &lt;VAR&gt;library&lt;/VAR&gt; to get the function. 
         &lt;VAR&gt;library&lt;/VAR&gt; is the base name of the library;
         e.g., to check for &lt;samp&gt;-lmp&lt;/samp&gt;, use
         &lt;samp&gt;mp&lt;/samp&gt; as the
         &lt;VAR&gt;library&lt;/VAR&gt; argument.&lt;/P&gt;&lt;P&gt;

         &lt;VAR&gt;action-if-found&lt;/VAR&gt; is a list of shell
         commands to run if the link with the library succeeds;
         &lt;VAR&gt;action-if-not-found&lt;/VAR&gt; is a list of shell
         commands to run if the link fails.  If
         &lt;VAR&gt;action-if-found&lt;/VAR&gt; is not specified, the
         default action will prepend
         &lt;samp&gt;-l&lt;VAR&gt;library&lt;/VAR&gt;&lt;/samp&gt; to
         &lt;CODE&gt;LIBS&lt;/CODE&gt; and define
         &lt;samp&gt;HAVE_LIB&lt;VAR&gt;library&lt;/VAR&gt;&lt;/samp&gt;
         (in all capitals).  This macro is intended to support building
         &lt;CODE&gt;LIBS&lt;/CODE&gt; in a right-to-left
         (least-dependent to most-dependent) fashion such that library
         dependencies are satisfied as a natural side-effect of
         consecutive tests.  Some linkers are very sensitive to library
         ordering so the order in which &lt;CODE&gt;LIBS&lt;/CODE&gt; is
         generated is important to reliable detection of libraries.&lt;/P&gt;&lt;P&gt;

         If linking with &lt;VAR&gt;library&lt;/VAR&gt; results in
         unresolved symbols that would be resolved by linking with
         additional libraries, give those libraries as the
         &lt;VAR&gt;other-libraries&lt;/VAR&gt; argument, separated by
         spaces: e.g., &lt;samp&gt;-lXt -lX11&lt;/samp&gt;.  Otherwise,
         this macro will fail to detect that
         &lt;VAR&gt;library&lt;/VAR&gt; is present, because linking the
         test program will always fail with unresolved symbols.  The
         &lt;VAR&gt;other-libraries&lt;/VAR&gt; argument should be
         limited to cases where it is desirable to test for one library
         in the presence of another that is not already in
         &lt;CODE&gt;LIBS&lt;/CODE&gt;.
        </synopsis>
  </macro>
  <macro id="AC_SEARCH_LIBS">
      <prototype>
        <parameter content="function"/>
        <parameter content="search-libs"/>
        <parameter content="[action-if-found]"/>
        <parameter content="[action-if-not-found]"/>
        <parameter content="[other-libraries]"/>
      </prototype>
        <synopsis>
          Search for a library defining &lt;VAR&gt;function&lt;/VAR&gt;
         if it's not already available.  This equates to calling
         &lt;samp&gt;AC_LINK_IFELSE([AC_LANG_CALL([],
         [&lt;VAR&gt;function&lt;/VAR&gt;])])&lt;/samp&gt; first with no
         libraries, then for each library listed in
         &lt;VAR&gt;search-libs&lt;/VAR&gt;.&lt;/P&gt;&lt;P&gt;

         Add &lt;samp&gt;-l&lt;VAR&gt;library&lt;/VAR&gt;&lt;/samp&gt; to
         &lt;CODE&gt;LIBS&lt;/CODE&gt; for the first library found to
         contain &lt;VAR&gt;function&lt;/VAR&gt;, and run
         &lt;VAR&gt;action-if-found&lt;/VAR&gt;.  If the function is not
         found, run &lt;VAR&gt;action-if-not-found&lt;/VAR&gt;.&lt;/P&gt;&lt;P&gt;

         If linking with &lt;VAR&gt;library&lt;/VAR&gt; results in
         unresolved symbols that would be resolved by linking with
         additional libraries, give those libraries as the
         &lt;VAR&gt;other-libraries&lt;/VAR&gt; argument, separated by
         spaces: e.g., &lt;samp&gt;-lXt -lX11&lt;/samp&gt;.  Otherwise,
         this macro will fail to detect that
         &lt;VAR&gt;function&lt;/VAR&gt; is present, because linking the
         test program will always fail with unresolved symbols.
        </synopsis>
  </macro>
  <macro id="AC_FUNC_ALLOCA">
      <prototype>
      </prototype>
        <synopsis>
              .h Check how to get &lt;CODE&gt;alloca&lt;/CODE&gt;.  Tries
         to get a builtin version by checking for
         &lt;TT&gt;alloca.h&lt;/TT&gt; or the predefined C preprocessor
         macros &lt;CODE&gt;__GNUC__&lt;/CODE&gt; and
         &lt;CODE&gt;_AIX&lt;/CODE&gt;.  If this macro finds
         &lt;TT&gt;alloca.h&lt;/TT&gt;, it defines
         &lt;CODE&gt;HAVE_ALLOCA_H&lt;/CODE&gt;.&lt;/P&gt;&lt;P&gt;

         If those attempts fail, it looks for the function in the
         standard C library.  If any of those methods succeed, it defines
         &lt;CODE&gt;HAVE_ALLOCA&lt;/CODE&gt;.  Otherwise, it sets the
         output variable &lt;CODE&gt;ALLOCA&lt;/CODE&gt; to
         &lt;samp&gt;alloca.o&lt;/samp&gt; and defines
         &lt;CODE&gt;C_ALLOCA&lt;/CODE&gt; (so programs can periodically
         call &lt;samp&gt;alloca(0)&lt;/samp&gt; to garbage collect).
         This variable is separate from &lt;CODE&gt;LIBOBJS&lt;/CODE&gt;
         so multiple programs can share the value of
         &lt;CODE&gt;ALLOCA&lt;/CODE&gt; without needing to create an
         actual library, in case only some of them use the code in
         &lt;CODE&gt;LIBOBJS&lt;/CODE&gt;.&lt;/P&gt;&lt;P&gt;

         This macro does not try to get &lt;CODE&gt;alloca&lt;/CODE&gt;
         from the System V R3 &lt;TT&gt;libPW&lt;/TT&gt; or the System V
         R4 &lt;TT&gt;libucb&lt;/TT&gt; because those libraries contain
         some incompatible functions that cause trouble.  Some versions
         do not even contain &lt;CODE&gt;alloca&lt;/CODE&gt; or contain a
         buggy version.  If you still want to use their
         &lt;CODE&gt;alloca&lt;/CODE&gt;, use &lt;CODE&gt;ar&lt;/CODE&gt;
         to extract &lt;TT&gt;alloca.o&lt;/TT&gt; from them instead of
         compiling &lt;TT&gt;alloca.c&lt;/TT&gt;.&lt;/P&gt;&lt;P&gt;

         Source files that use &lt;CODE&gt;alloca&lt;/CODE&gt; should
         start with a piece of code like the following, to declare it
         properly.  In some versions of AIX, the declaration of
         &lt;CODE&gt;alloca&lt;/CODE&gt; must precede everything else
         except for comments and preprocessor directives.  The
         &lt;CODE&gt;#pragma&lt;/CODE&gt; directive is indented so that
         pre-ANSI C compilers will ignore it, rather than choke on it.&lt;/P&gt;&lt;P&gt;

         &lt;TABLE&gt;&lt;tr&gt;&lt;td&gt;&amp;nbsp;&lt;/td&gt;&lt;td
         class=example&gt;&lt;pre&gt; @group /* AIX requires this to be
         the first thing in the file.  */ #ifndef __GNUC__ # if
         HAVE_ALLOCA_H #  include &lt;alloca.h&gt; # else #  ifdef _AIX 
         #pragma alloca #  else #   ifndef alloca /* predefined by HP cc
         +Olibcalls */ char *alloca (); #   endif #  endif # endif #endif
         @end group &lt;/pre&gt;&lt;/td&gt;&lt;/tr&gt;&lt;/table&gt;
        </synopsis>
  </macro>
  <macro id="AC_FUNC_CHOWN">
      <prototype>
      </prototype>
        <synopsis>
           If the &lt;CODE&gt;chown&lt;/CODE&gt; function is available
         and works (in particular, it should accept
         &lt;samp&gt;-1&lt;/samp&gt; for &lt;CODE&gt;uid&lt;/CODE&gt; and
         &lt;CODE&gt;gid&lt;/CODE&gt;), define
         &lt;CODE&gt;HAVE_CHOWN&lt;/CODE&gt;.
        </synopsis>
  </macro>
  <macro id="AC_FUNC_CLOSEDIR_VOID">
      <prototype>
      </prototype>
        <synopsis>
            If the &lt;CODE&gt;closedir&lt;/CODE&gt; function does not
         return a meaningful value, define
         &lt;CODE&gt;CLOSEDIR_VOID&lt;/CODE&gt;.  Otherwise, callers
         ought to check its return value for an error indicator.
        </synopsis>
  </macro>
  <macro id="AC_FUNC_ERROR_AT_LINE">
      <prototype>
      </prototype>
        <synopsis>
           If the &lt;CODE&gt;error_at_line&lt;/CODE&gt; function is not
         found, require an &lt;CODE&gt;AC_LIBOBJ&lt;/CODE&gt; replacement
         of &lt;samp&gt;error&lt;/samp&gt;.
        </synopsis>
  </macro>
  <macro id="AC_FUNC_FNMATCH">
      <prototype>
      </prototype>
        <synopsis>
           If the &lt;CODE&gt;fnmatch&lt;/CODE&gt; function conforms to
         POSIX, define &lt;CODE&gt;HAVE_FNMATCH&lt;/CODE&gt;.  Detect
         common implementation bugs, for example, the bugs in Solaris
         2.4.&lt;/P&gt;&lt;P&gt;

         Note that for historical reasons, contrary to the other specific
         &lt;CODE&gt;AC_FUNC&lt;/CODE&gt; macros,
         &lt;CODE&gt;AC_FUNC_FNMATCH&lt;/CODE&gt; does not replace a
         broken/missing &lt;CODE&gt;fnmatch&lt;/CODE&gt;.  See
         &lt;CODE&gt;AC_REPLACE_FNMATCH&lt;/CODE&gt; below.
        </synopsis>
  </macro>
  <macro id="AC_FUNC_FNMATCH_GNU">
      <prototype>
      </prototype>
        <synopsis>
           Behave like &lt;CODE&gt;AC_REPLACE_FNMATCH&lt;/CODE&gt;
         (&lt;EM&gt;replace&lt;/EM&gt;) but also test whether
         &lt;CODE&gt;fnmatch&lt;/CODE&gt; supports GNU extensions. 
         Detect common implementation bugs, for example, the bugs in the
         GNU C Library 2.1.
        </synopsis>
  </macro>
  <macro id="AC_FUNC_FORK">
      <prototype>
      </prototype>
        <synopsis>
                .h This macro checks for the
         &lt;CODE&gt;fork&lt;/CODE&gt; and &lt;CODE&gt;vfork&lt;/CODE&gt;
         functions.  If a working &lt;CODE&gt;fork&lt;/CODE&gt; is found,
         define &lt;CODE&gt;HAVE_WORKING_FORK&lt;/CODE&gt;.  This macro
         checks whether &lt;CODE&gt;fork&lt;/CODE&gt; is just a stub by
         trying to run it.&lt;/P&gt;&lt;P&gt;

         If &lt;TT&gt;vfork.h&lt;/TT&gt; is found, define
         &lt;CODE&gt;HAVE_VFORK_H&lt;/CODE&gt;.  If a working
         &lt;CODE&gt;vfork&lt;/CODE&gt; is found, define
         &lt;CODE&gt;HAVE_WORKING_VFORK&lt;/CODE&gt;.  Otherwise, define
         &lt;CODE&gt;vfork&lt;/CODE&gt; to be
         &lt;CODE&gt;fork&lt;/CODE&gt; for backward compatibility with
         previous versions of &lt;CODE&gt;autoconf&lt;/CODE&gt;.  This
         macro checks for several known errors in implementations of
         &lt;CODE&gt;vfork&lt;/CODE&gt; and considers the system to not
         have a working &lt;CODE&gt;vfork&lt;/CODE&gt; if it detects any
         of them.  It is not considered to be an implementation error if
         a child's invocation of &lt;CODE&gt;signal&lt;/CODE&gt; modifies
         the parent's signal handler, since child processes rarely change
         their signal handlers.&lt;/P&gt;&lt;P&gt;

         Since this macro defines &lt;CODE&gt;vfork&lt;/CODE&gt; only for
         backward compatibility with previous versions of
         &lt;CODE&gt;autoconf&lt;/CODE&gt; you're encouraged to define it
         yourself in new code:
         &lt;TABLE&gt;&lt;tr&gt;&lt;td&gt;&amp;nbsp;&lt;/td&gt;&lt;td
         class=example&gt;&lt;pre&gt; @group #if !HAVE_WORKING_VFORK #
         define vfork fork #endif @end group
         &lt;/pre&gt;&lt;/td&gt;&lt;/tr&gt;&lt;/table&gt;
        </synopsis>
  </macro>
  <macro id="AC_FUNC_FSEEKO">
      <prototype>
      </prototype>
        <synopsis>
            If the &lt;CODE&gt;fseeko&lt;/CODE&gt; function is available,
         define &lt;CODE&gt;HAVE_FSEEKO&lt;/CODE&gt;. Define
         &lt;CODE&gt;_LARGEFILE_SOURCE&lt;/CODE&gt; if necessary to make
         the prototype visible on some systems (e.g. glibc 2.2).
         Otherwise linkage problems may occur when compiling with
         &lt;CODE&gt;AC_SYS_LARGEFILE&lt;/CODE&gt; on largefile-sensitive
         systems where &lt;CODE&gt;off_t&lt;/CODE&gt; does not default to
         a 64bit entity.
        </synopsis>
  </macro>
  <macro id="AC_FUNC_GETGROUPS">
      <prototype>
      </prototype>
        <synopsis>
            If the &lt;CODE&gt;getgroups&lt;/CODE&gt; function is
         available and works (unlike on Ultrix 4.3, where
         &lt;samp&gt;getgroups (0, 0)&lt;/samp&gt; always fails), define
         &lt;CODE&gt;HAVE_GETGROUPS&lt;/CODE&gt;.  Set
         &lt;CODE&gt;GETGROUPS_LIBS&lt;/CODE&gt; to any libraries needed
         to get that function.  This macro runs
         &lt;CODE&gt;AC_TYPE_GETGROUPS&lt;/CODE&gt;.
        </synopsis>
  </macro>
  <macro id="AC_FUNC_GETLOADAVG">
      <prototype>
      </prototype>
        <synopsis>
                        Check how to get the system load averages.  To
         perform its tests properly, this macro needs the file
         &lt;TT&gt;getloadavg.c&lt;/TT&gt;; therefore, be sure to set the
         &lt;CODE&gt;AC_LIBOBJ&lt;/CODE&gt; replacement directory
         properly (see Generic Functions,
         &lt;CODE&gt;AC_CONFIG_LIBOBJ_DIR&lt;/CODE&gt;).&lt;/P&gt;&lt;P&gt;

         If the system has the &lt;CODE&gt;getloadavg&lt;/CODE&gt;
         function, define &lt;CODE&gt;HAVE_GETLOADAVG&lt;/CODE&gt;, and
         set &lt;CODE&gt;GETLOADAVG_LIBS&lt;/CODE&gt; to any libraries
         needed to get that function.  Also add
         &lt;CODE&gt;GETLOADAVG_LIBS&lt;/CODE&gt; to
         &lt;CODE&gt;LIBS&lt;/CODE&gt;.  Otherwise, require an
         &lt;CODE&gt;AC_LIBOBJ&lt;/CODE&gt; replacement for
         &lt;samp&gt;getloadavg&lt;/samp&gt; with source code in
         &lt;TT&gt;&lt;VAR&gt;dir&lt;/VAR&gt;/getloadavg.c&lt;/TT&gt;,
         and possibly define several other C preprocessor macros and
         output variables:&lt;/P&gt;&lt;P&gt;

         &lt;OL&gt; &lt;LI&gt; Define
         &lt;CODE&gt;C_GETLOADAVG&lt;/CODE&gt;.&lt;/P&gt;&lt;P&gt;

         &lt;LI&gt; Define &lt;CODE&gt;SVR4&lt;/CODE&gt;,
         &lt;CODE&gt;DGUX&lt;/CODE&gt;, &lt;CODE&gt;UMAX&lt;/CODE&gt;, or
         &lt;CODE&gt;UMAX4_3&lt;/CODE&gt; if on those systems.&lt;/P&gt;&lt;P&gt;

         &lt;LI&gt; .h If &lt;TT&gt;nlist.h&lt;/TT&gt; is found, define
         &lt;CODE&gt;HAVE_NLIST_H&lt;/CODE&gt;.&lt;/P&gt;&lt;P&gt;

         &lt;LI&gt; If &lt;samp&gt;struct nlist&lt;/samp&gt; has an
         &lt;samp&gt;n_un.n_name&lt;/samp&gt; member, define
         &lt;CODE&gt;HAVE_STRUCT_NLIST_N_UN_N_NAME&lt;/CODE&gt;.  The
         obsolete symbol &lt;CODE&gt;NLIST_NAME_UNION&lt;/CODE&gt; is
         still defined, but do not depend upon it.&lt;/P&gt;&lt;P&gt;

         &lt;LI&gt; Programs may need to be installed setgid (or setuid)
         for &lt;CODE&gt;getloadavg&lt;/CODE&gt; to work.  In this case,
         define &lt;CODE&gt;GETLOADAVG_PRIVILEGED&lt;/CODE&gt;, set the
         output variable &lt;CODE&gt;NEED_SETGID&lt;/CODE&gt; to
         &lt;samp&gt;true&lt;/samp&gt; (and otherwise to
         &lt;samp&gt;false&lt;/samp&gt;), and set
         &lt;CODE&gt;KMEM_GROUP&lt;/CODE&gt; to the name of the group
         that should own the installed program. &lt;/OL&gt;
        </synopsis>
  </macro>
  <macro id="AC_FUNC_GETMNTENT">
      <prototype>
      </prototype>
        <synopsis>
            Check for &lt;CODE&gt;getmntent&lt;/CODE&gt; in the
         &lt;TT&gt;sun&lt;/TT&gt;, &lt;TT&gt;seq&lt;/TT&gt;, and
         &lt;TT&gt;gen&lt;/TT&gt; libraries, for irix 4, PTX, and
         Unixware, respectively.  Then, if
         &lt;CODE&gt;getmntent&lt;/CODE&gt; is available, define
         &lt;CODE&gt;HAVE_GETMNTENT&lt;/CODE&gt;.
        </synopsis>
  </macro>
  <macro id="AC_FUNC_GETPGRP">
      <prototype>
      </prototype>
        <synopsis>
             Define &lt;CODE&gt;GETPGRP_VOID&lt;/CODE&gt; if it is an
         error to pass 0 to &lt;CODE&gt;getpgrp&lt;/CODE&gt;; this is the
         POSIX behavior.  On older BSD systems, you must pass 0 to
         &lt;CODE&gt;getpgrp&lt;/CODE&gt;, as it takes an argument and
         behaves like POSIX's &lt;CODE&gt;getpgid&lt;/CODE&gt;.&lt;/P&gt;&lt;P&gt;

         &lt;TABLE&gt;&lt;tr&gt;&lt;td&gt;&amp;nbsp;&lt;/td&gt;&lt;td
         class=example&gt;&lt;pre&gt; #if GETPGRP_VOID   pid = getpgrp
         (); #else   pid = getpgrp (0); #endif
         &lt;/pre&gt;&lt;/td&gt;&lt;/tr&gt;&lt;/table&gt;&lt;/P&gt;&lt;P&gt;

         This macro does not check whether
         &lt;CODE&gt;getpgrp&lt;/CODE&gt; exists at all; if you need to
         work in that situation, first call
         &lt;CODE&gt;AC_CHECK_FUNC&lt;/CODE&gt; for
         &lt;CODE&gt;getpgrp&lt;/CODE&gt;.
        </synopsis>
  </macro>
  <macro id="AC_FUNC_LSTAT_FOLLOWS_SLASHED_SYMLINK">
      <prototype>
      </prototype>
        <synopsis>
            If &lt;TT&gt;link&lt;/TT&gt; is a symbolic link, then
         &lt;CODE&gt;lstat&lt;/CODE&gt; should treat
         &lt;TT&gt;link/&lt;/TT&gt; the same as
         &lt;TT&gt;link/.&lt;/TT&gt;.  However, many older
         &lt;CODE&gt;lstat&lt;/CODE&gt; implementations incorrectly
         ignore trailing slashes.&lt;/P&gt;&lt;P&gt;

         It is safe to assume that if &lt;CODE&gt;lstat&lt;/CODE&gt;
         incorrectly ignores trailing slashes, then other
         symbolic-link-aware functions like
         &lt;CODE&gt;unlink&lt;/CODE&gt; also incorrectly ignore trailing
         slashes.&lt;/P&gt;&lt;P&gt;

         If &lt;CODE&gt;lstat&lt;/CODE&gt; behaves properly, define
         &lt;CODE&gt;LSTAT_FOLLOWS_SLASHED_SYMLINK&lt;/CODE&gt;,
         otherwise require an &lt;CODE&gt;AC_LIBOBJ&lt;/CODE&gt;
         replacement of &lt;CODE&gt;lstat&lt;/CODE&gt;.
        </synopsis>
  </macro>
  <macro id="AC_FUNC_MALLOC">
      <prototype>
      </prototype>
        <synopsis>
             If the &lt;CODE&gt;malloc&lt;/CODE&gt; function is
         compatible with the GNU C library
         &lt;CODE&gt;malloc&lt;/CODE&gt; (i.e., &lt;samp&gt;malloc
         (0)&lt;/samp&gt; returns a valid pointer), define
         &lt;CODE&gt;HAVE_MALLOC&lt;/CODE&gt; to 1.  Otherwise define
         &lt;CODE&gt;HAVE_MALLOC&lt;/CODE&gt; to 0, ask for an
         &lt;CODE&gt;AC_LIBOBJ&lt;/CODE&gt; replacement for
         &lt;samp&gt;malloc&lt;/samp&gt;, and define
         &lt;CODE&gt;malloc&lt;/CODE&gt; to
         &lt;CODE&gt;rpl_malloc&lt;/CODE&gt; so that the native
         &lt;CODE&gt;malloc&lt;/CODE&gt; is not used in the main project.&lt;/P&gt;&lt;P&gt;

         Typically, the replacement file &lt;TT&gt;malloc.c&lt;/TT&gt;
         should look like (note the &lt;samp&gt;#undef
         malloc&lt;/samp&gt;):&lt;/P&gt;&lt;P&gt;

         &lt;CODE&gt; #if HAVE_CONFIG_H # include &lt;config.h&gt; #endif
         #undef malloc&lt;/P&gt;&lt;P&gt;

         #include &lt;sys/types.h&gt;&lt;/P&gt;&lt;P&gt;

         void *malloc ();&lt;/P&gt;&lt;P&gt;

         /* Allocate an N-byte block of memory from the heap.    If N is
         zero, allocate a 1-byte block.  */&lt;/P&gt;&lt;P&gt;

         void * rpl_malloc (size_t n) {   if (n == 0)     n = 1;   return
         malloc (n); } &lt;/CODE&gt;
        </synopsis>
  </macro>
  <macro id="AC_FUNC_MEMCMP">
      <prototype>
      </prototype>
        <synopsis>
            If the &lt;CODE&gt;memcmp&lt;/CODE&gt; function is not
         available, or does not work on 8-bit data (like the one on SunOS
         4.1.3), or fails when comparing 16 bytes or more and with at
         least one buffer not starting on a 4-byte boundary (such as the
         one on NeXT x86 OpenStep), require an
         &lt;CODE&gt;AC_LIBOBJ&lt;/CODE&gt; replacement for
         &lt;samp&gt;memcmp&lt;/samp&gt;.
        </synopsis>
  </macro>
  <macro id="AC_FUNC_MBRTOWC">
      <prototype>
      </prototype>
        <synopsis>
            Define &lt;CODE&gt;HAVE_MBRTOWC&lt;/CODE&gt; to 1 if the
         function &lt;CODE&gt;mbrtowc&lt;/CODE&gt; and the type
         &lt;CODE&gt;mbstate_t&lt;/CODE&gt; are properly declared.
        </synopsis>
  </macro>
  <macro id="AC_FUNC_MKTIME">
      <prototype>
      </prototype>
        <synopsis>
            If the &lt;CODE&gt;mktime&lt;/CODE&gt; function is not
         available, or does not work correctly, require an
         &lt;CODE&gt;AC_LIBOBJ&lt;/CODE&gt; replacement for
         &lt;samp&gt;mktime&lt;/samp&gt;. For the purposes of this test,
         &lt;CODE&gt;mktime&lt;/CODE&gt; should conform to the POSIX
         standard and should be the inverse of
         &lt;CODE&gt;localtime&lt;/CODE&gt;.
        </synopsis>
  </macro>
  <macro id="AC_FUNC_MMAP">
      <prototype>
      </prototype>
        <synopsis>
            If the &lt;CODE&gt;mmap&lt;/CODE&gt; function exists and
         works correctly, define &lt;CODE&gt;HAVE_MMAP&lt;/CODE&gt;. 
         Only checks private fixed mapping of already-mapped memory.
        </synopsis>
  </macro>
  <macro id="AC_FUNC_OBSTACK">
      <prototype>
      </prototype>
        <synopsis>
            If the obstacks are found, define
         &lt;CODE&gt;HAVE_OBSTACK&lt;/CODE&gt;, else require an
         &lt;CODE&gt;AC_LIBOBJ&lt;/CODE&gt; replacement for
         &lt;samp&gt;obstack&lt;/samp&gt;.
        </synopsis>
  </macro>
  <macro id="AC_FUNC_REALLOC">
      <prototype>
      </prototype>
        <synopsis>
             If the &lt;CODE&gt;realloc&lt;/CODE&gt; function is
         compatible with the GNU C library
         &lt;CODE&gt;realloc&lt;/CODE&gt; (i.e., &lt;samp&gt;realloc (0,
         0)&lt;/samp&gt; returns a valid pointer), define
         &lt;CODE&gt;HAVE_REALLOC&lt;/CODE&gt; to 1.  Otherwise define
         &lt;CODE&gt;HAVE_REALLOC&lt;/CODE&gt; to 0, ask for an
         &lt;CODE&gt;AC_LIBOBJ&lt;/CODE&gt; replacement for
         &lt;samp&gt;realloc&lt;/samp&gt;, and define
         &lt;CODE&gt;realloc&lt;/CODE&gt; to
         &lt;CODE&gt;rpl_realloc&lt;/CODE&gt; so that the native
         &lt;CODE&gt;realloc&lt;/CODE&gt; is not used in the main
         project.  See &lt;CODE&gt;AC_FUNC_MALLOC&lt;/CODE&gt; for
         details.
        </synopsis>
  </macro>
  <macro id="AC_FUNC_SELECT_ARGTYPES">
      <prototype>
      </prototype>
        <synopsis>
              Determines the correct type to be passed for each of the
         &lt;CODE&gt;select&lt;/CODE&gt; function's arguments, and
         defines those types in
         &lt;CODE&gt;SELECT_TYPE_ARG1&lt;/CODE&gt;,
         &lt;CODE&gt;SELECT_TYPE_ARG234&lt;/CODE&gt;, and
         &lt;CODE&gt;SELECT_TYPE_ARG5&lt;/CODE&gt; respectively. 
         &lt;CODE&gt;SELECT_TYPE_ARG1&lt;/CODE&gt; defaults to
         &lt;samp&gt;int&lt;/samp&gt;,
         &lt;CODE&gt;SELECT_TYPE_ARG234&lt;/CODE&gt; defaults to
         &lt;samp&gt;int *&lt;/samp&gt;, and
         &lt;CODE&gt;SELECT_TYPE_ARG5&lt;/CODE&gt; defaults to
         &lt;samp&gt;struct timeval *&lt;/samp&gt;.
        </synopsis>
  </macro>
  <macro id="AC_FUNC_SETPGRP">
      <prototype>
      </prototype>
        <synopsis>
            If &lt;CODE&gt;setpgrp&lt;/CODE&gt; takes no argument (the
         POSIX version), define &lt;CODE&gt;SETPGRP_VOID&lt;/CODE&gt;. 
         Otherwise, it is the BSD version, which takes two process IDs as
         arguments.  This macro does not check whether
         &lt;CODE&gt;setpgrp&lt;/CODE&gt; exists at all; if you need to
         work in that situation, first call
         &lt;CODE&gt;AC_CHECK_FUNC&lt;/CODE&gt; for
         &lt;CODE&gt;setpgrp&lt;/CODE&gt;.
        </synopsis>
  </macro>
  <macro id="AC_FUNC_STAT">
      <prototype>
      </prototype>
      <prototype>
      </prototype>
        <synopsis>
               Determine whether &lt;CODE&gt;stat&lt;/CODE&gt; or
         &lt;CODE&gt;lstat&lt;/CODE&gt; have the bug that it succeeds
         when given the zero-length file name as argument.  The
         &lt;CODE&gt;stat&lt;/CODE&gt; and &lt;CODE&gt;lstat&lt;/CODE&gt;
         from SunOS 4.1.4 and the Hurd (as of 1998-11-01) do this.&lt;/P&gt;&lt;P&gt;

         If it does, then define
         &lt;CODE&gt;HAVE_STAT_EMPTY_STRING_BUG&lt;/CODE&gt; (or
         &lt;CODE&gt;HAVE_LSTAT_EMPTY_STRING_BUG&lt;/CODE&gt;) and ask
         for an &lt;CODE&gt;AC_LIBOBJ&lt;/CODE&gt; replacement of it.
        </synopsis>
  </macro>
  <macro id="AC_FUNC_SETVBUF_REVERSED">
      <prototype>
      </prototype>
        <synopsis>
            If &lt;CODE&gt;setvbuf&lt;/CODE&gt; takes the buffering type
         as its second argument and the buffer pointer as the third,
         instead of the other way around, define
         &lt;CODE&gt;SETVBUF_REVERSED&lt;/CODE&gt;.
        </synopsis>
  </macro>
  <macro id="AC_FUNC_STRCOLL">
      <prototype>
      </prototype>
        <synopsis>
            If the &lt;CODE&gt;strcoll&lt;/CODE&gt; function exists and
         works correctly, define &lt;CODE&gt;HAVE_STRCOLL&lt;/CODE&gt;. 
         This does a bit more than
         &lt;samp&gt;AC_CHECK_FUNCS(strcoll)&lt;/samp&gt;, because some
         systems have incorrect definitions of
         &lt;CODE&gt;strcoll&lt;/CODE&gt; that should not be used.
        </synopsis>
  </macro>
  <macro id="AC_FUNC_STRTOD">
      <prototype>
      </prototype>
        <synopsis>
            If the &lt;CODE&gt;strtod&lt;/CODE&gt; function does not
         exist or doesn't work correctly, ask for an
         &lt;CODE&gt;AC_LIBOBJ&lt;/CODE&gt; replacement of
         &lt;samp&gt;strtod&lt;/samp&gt;.  In this case, because
         &lt;TT&gt;strtod.c&lt;/TT&gt; is likely to need
         &lt;samp&gt;pow&lt;/samp&gt;, set the output variable
         &lt;CODE&gt;POW_LIB&lt;/CODE&gt; to the extra library needed.
        </synopsis>
  </macro>
  <macro id="AC_FUNC_STRERROR_R">
      <prototype>
      </prototype>
        <synopsis>
              If &lt;CODE&gt;strerror_r&lt;/CODE&gt; is available, define
         &lt;CODE&gt;HAVE_STRERROR_R&lt;/CODE&gt;, and if it is declared,
         define &lt;CODE&gt;HAVE_DECL_STRERROR_R&lt;/CODE&gt;.  If it
         returns a &lt;CODE&gt;char *&lt;/CODE&gt; message, define
         &lt;CODE&gt;STRERROR_R_CHAR_P&lt;/CODE&gt;; otherwise it returns
         an &lt;CODE&gt;int&lt;/CODE&gt; error number.  The Thread-Safe
         Functions option of POSIX requires
         &lt;CODE&gt;strerror_r&lt;/CODE&gt; to return
         &lt;CODE&gt;int&lt;/CODE&gt;, but many systems (including, for
         example, version 2.2.4 of the GNU C Library) return a
         &lt;CODE&gt;char *&lt;/CODE&gt; value that is not necessarily
         equal to the buffer argument.
        </synopsis>
  </macro>
  <macro id="AC_FUNC_STRFTIME">
      <prototype>
      </prototype>
        <synopsis>
            Check for &lt;CODE&gt;strftime&lt;/CODE&gt; in the
         &lt;TT&gt;intl&lt;/TT&gt; library, for SCO unix. Then, if
         &lt;CODE&gt;strftime&lt;/CODE&gt; is available, define
         &lt;CODE&gt;HAVE_STRFTIME&lt;/CODE&gt;.
        </synopsis>
  </macro>
  <macro id="AC_FUNC_STRNLEN">
      <prototype>
      </prototype>
        <synopsis>
            If the &lt;CODE&gt;strnlen&lt;/CODE&gt; function is not
         available, or is buggy (like the one from AIX 4.3), require an
         &lt;CODE&gt;AC_LIBOBJ&lt;/CODE&gt; replacement for it.
        </synopsis>
  </macro>
  <macro id="AC_FUNC_UTIME_NULL">
      <prototype>
      </prototype>
        <synopsis>
            If &lt;samp&gt;utime(&lt;VAR&gt;file&lt;/VAR&gt;,
         NULL)&lt;/samp&gt; sets &lt;VAR&gt;file&lt;/VAR&gt;'s timestamp
         to the present, define &lt;CODE&gt;HAVE_UTIME_NULL&lt;/CODE&gt;.
        </synopsis>
  </macro>
  <macro id="AC_FUNC_VPRINTF">
      <prototype>
      </prototype>
        <synopsis>
             If &lt;CODE&gt;vprintf&lt;/CODE&gt; is found, define
         &lt;CODE&gt;HAVE_VPRINTF&lt;/CODE&gt;.  Otherwise, if
         &lt;CODE&gt;_doprnt&lt;/CODE&gt; is found, define
         &lt;CODE&gt;HAVE_DOPRNT&lt;/CODE&gt;.  (If
         &lt;CODE&gt;vprintf&lt;/CODE&gt; is available, you may assume
         that &lt;CODE&gt;vfprintf&lt;/CODE&gt; and
         &lt;CODE&gt;vsprintf&lt;/CODE&gt; are also available.)
        </synopsis>
  </macro>
  <macro id="AC_REPLACE_FNMATCH">
      <prototype>
      </prototype>
        <synopsis>
           .h If the &lt;CODE&gt;fnmatch&lt;/CODE&gt; function does not
         conform to POSIX (see &lt;CODE&gt;AC_FUNC_FNMATCH&lt;/CODE&gt;),
         ask for its &lt;CODE&gt;AC_LIBOBJ&lt;/CODE&gt; replacement.&lt;/P&gt;&lt;P&gt;

         The files &lt;TT&gt;fnmatch.c&lt;/TT&gt;,
         &lt;TT&gt;fnmatch_loop.c&lt;/TT&gt;, and
         &lt;TT&gt;fnmatch_.h&lt;/TT&gt; in the
         &lt;CODE&gt;AC_LIBOBJ&lt;/CODE&gt; replacement directory are
         assumed to contain a copy of the source code of GNU
         &lt;CODE&gt;fnmatch&lt;/CODE&gt;.  If necessary, this source
         code is compiled as an &lt;CODE&gt;AC_LIBOBJ&lt;/CODE&gt;
         replacement, and the &lt;TT&gt;fnmatch_.h&lt;/TT&gt; file is
         linked to &lt;TT&gt;fnmatch.h&lt;/TT&gt; so that it can be
         included in place of the system
         &lt;CODE&gt;&lt;fnmatch.h&gt;&lt;/CODE&gt;.
        </synopsis>
  </macro>
  <macro id="AC_CHECK_FUNC">
      <prototype>
        <parameter content="function"/>
        <parameter content="[action-if-found]"/>
        <parameter content="[action-if-not-found]"/>
      </prototype>
        <synopsis>
          If C function &lt;VAR&gt;function&lt;/VAR&gt; is available, run
         shell commands &lt;VAR&gt;action-if-found&lt;/VAR&gt;, otherwise
         &lt;VAR&gt;action-if-not-found&lt;/VAR&gt;.  If you just want to
         define a symbol if the function is available, consider using
         &lt;CODE&gt;AC_CHECK_FUNCS&lt;/CODE&gt; instead.  This macro
         checks for functions with C linkage even when
         &lt;CODE&gt;AC_LANG(C++)&lt;/CODE&gt; has been called, since C
         is more standardized than C++.  (Language Choice, for more
         information about selecting the language for checks.)
        </synopsis>
  </macro>
  <macro id="AC_CHECK_FUNCS">
      <prototype>
        <parameter content="function..."/>
        <parameter content="[action-if-found]"/>
        <parameter content="[action-if-not-found]"/>
      </prototype>
        <synopsis>
           For each &lt;VAR&gt;function&lt;/VAR&gt; in the
         whitespace-separated argument list, define
         &lt;CODE&gt;HAVE_&lt;VAR&gt;function&lt;/VAR&gt;&lt;/CODE&gt;
         (in all capitals) if it is available. If
         &lt;VAR&gt;action-if-found&lt;/VAR&gt; is given, it is
         additional shell code to execute when one of the functions is
         found.  You can give it a value of
         &lt;samp&gt;break&lt;/samp&gt; to break out of the loop on the
         first match.  If &lt;VAR&gt;action-if-not-found&lt;/VAR&gt; is
         given, it is executed when one of the functions is not found.
        </synopsis>
  </macro>
  <macro id="AC_LIBOBJ">
      <prototype>
        <parameter content="function"/>
      </prototype>
        <synopsis>
           Specify that
         &lt;samp&gt;&lt;VAR&gt;function&lt;/VAR&gt;.c&lt;/samp&gt; must
         be included in the executables to replace a missing or broken
         implementation of &lt;VAR&gt;function&lt;/VAR&gt;.&lt;/P&gt;&lt;P&gt;

         Technically, it adds
         &lt;samp&gt;&lt;VAR&gt;function&lt;/VAR&gt;.$ac_objext&lt;/samp&gt;
         to the output variable &lt;CODE&gt;LIBOBJS&lt;/CODE&gt; if it is
         not already in, and calls &lt;CODE&gt;AC_LIBSOURCE&lt;/CODE&gt;
         for &lt;samp&gt;&lt;VAR&gt;function&lt;/VAR&gt;.c&lt;/samp&gt;. 
         You should not directly change &lt;CODE&gt;LIBOBJS&lt;/CODE&gt;,
         since this is not traceable.
        </synopsis>
  </macro>
  <macro id="AC_LIBSOURCE">
      <prototype>
        <parameter content="file"/>
      </prototype>
        <synopsis>
          Specify that &lt;VAR&gt;file&lt;/VAR&gt; might be needed to
         compile the project.  If you need to know what files might be
         needed by a &lt;TT&gt;configure.ac&lt;/TT&gt;, you should trace
         &lt;CODE&gt;AC_LIBSOURCE&lt;/CODE&gt;. 
         &lt;VAR&gt;file&lt;/VAR&gt; must be a literal.&lt;/P&gt;&lt;P&gt;

         This macro is called automatically from
         &lt;CODE&gt;AC_LIBOBJ&lt;/CODE&gt;, but you must call it
         explicitly if you pass a shell variable to
         &lt;CODE&gt;AC_LIBOBJ&lt;/CODE&gt;.  In that case, since shell
         variables cannot be traced statically, you must pass to
         &lt;CODE&gt;AC_LIBSOURCE&lt;/CODE&gt; any possible files that
         the shell variable might cause
         &lt;CODE&gt;AC_LIBOBJ&lt;/CODE&gt; to need.  For example, if you
         want to pass a variable &lt;CODE&gt;$foo_or_bar&lt;/CODE&gt; to
         &lt;CODE&gt;AC_LIBOBJ&lt;/CODE&gt; that holds either
         &lt;CODE&gt;"foo"&lt;/CODE&gt; or
         &lt;CODE&gt;"bar"&lt;/CODE&gt;, you should do:&lt;/P&gt;&lt;P&gt;

         &lt;TABLE&gt;&lt;tr&gt;&lt;td&gt;&amp;nbsp;&lt;/td&gt;&lt;td
         class=example&gt;&lt;pre&gt; AC_LIBSOURCE(foo.c)
         AC_LIBSOURCE(bar.c) AC_LIBOBJ($foo_or_bar)
         &lt;/pre&gt;&lt;/td&gt;&lt;/tr&gt;&lt;/table&gt;&lt;/P&gt;&lt;P&gt;

          There is usually a way to avoid this, however, and you are
         encouraged to simply call &lt;CODE&gt;AC_LIBOBJ&lt;/CODE&gt;
         with literal arguments.&lt;/P&gt;&lt;P&gt;

         Note that this macro replaces the obsolete
         &lt;CODE&gt;AC_LIBOBJ_DECL&lt;/CODE&gt;, with slightly different
         semantics: the old macro took the function name, e.g.,
         &lt;CODE&gt;foo&lt;/CODE&gt;, as its argument rather than the
         file name.
        </synopsis>
  </macro>
  <macro id="AC_LIBSOURCES">
      <prototype>
        <parameter content="files"/>
      </prototype>
        <synopsis>
          Like &lt;CODE&gt;AC_LIBSOURCE&lt;/CODE&gt;, but accepts one or
         more &lt;VAR&gt;files&lt;/VAR&gt; in a comma-separated M4 list. 
         Thus, the above example might be rewritten:&lt;/P&gt;&lt;P&gt;

         &lt;TABLE&gt;&lt;tr&gt;&lt;td&gt;&amp;nbsp;&lt;/td&gt;&lt;td
         class=example&gt;&lt;pre&gt; AC_LIBSOURCES([foo.c, bar.c])
         AC_LIBOBJ($foo_or_bar)
         &lt;/pre&gt;&lt;/td&gt;&lt;/tr&gt;&lt;/table&gt;
        </synopsis>
  </macro>
  <macro id="AC_CONFIG_LIBOBJ_DIR">
      <prototype>
        <parameter content="directory"/>
      </prototype>
        <synopsis>
          Specify that &lt;CODE&gt;AC_LIBOBJ&lt;/CODE&gt; replacement
         files are to be found in &lt;VAR&gt;directory&lt;/VAR&gt;, a
         relative path starting from the top level of the source tree. 
         The replacement directory defaults to &lt;TT&gt;.&lt;/TT&gt;,
         the top level directory, and the most typical value is
         &lt;TT&gt;lib&lt;/TT&gt;, corresponding to
         &lt;samp&gt;AC_CONFIG_LIBOBJ_DIR(lib)&lt;/samp&gt;.&lt;/P&gt;&lt;P&gt;

         &lt;CODE&gt;configure&lt;/CODE&gt; might need to know the
         replacement directory for the following reasons: (i) some checks
         use the replacement files, (ii) some macros bypass broken system
         headers by installing links to the replacement headers, etc.
        </synopsis>
  </macro>
  <macro id="AC_REPLACE_FUNCS">
      <prototype>
        <parameter content="function..."/>
      </prototype>
        <synopsis>
           Like &lt;CODE&gt;AC_CHECK_FUNCS&lt;/CODE&gt;, but uses
         &lt;samp&gt;AC_LIBOBJ(&lt;VAR&gt;function&lt;/VAR&gt;)&lt;/samp&gt;
         as &lt;VAR&gt;action-if-not-found&lt;/VAR&gt;.  You can declare
         your replacement function by enclosing the prototype in
         &lt;samp&gt;#if
         !HAVE_&lt;VAR&gt;function&lt;/VAR&gt;&lt;/samp&gt;.  If the
         system has the function, it probably declares it in a header
         file you should be including, so you shouldn't redeclare it lest
         your declaration conflict.
        </synopsis>
  </macro>
  <macro id="AC_HEADER_DIRENT">
      <prototype>
      </prototype>
        <synopsis>
              .h /ndir.h /dir.h .h Check for the following header files. 
         For the first one that is found and defines
         &lt;samp&gt;DIR&lt;/samp&gt;, define the listed C preprocessor
         macro:&lt;/P&gt;&lt;P&gt;

         @multitable {&lt;TT&gt;sys/ndir.h&lt;/TT&gt;}
         {&lt;CODE&gt;HAVE_SYS_NDIR_H&lt;/CODE&gt;} &lt;LI&gt;
         &lt;TT&gt;dirent.h&lt;/TT&gt;   @tab
         &lt;CODE&gt;HAVE_DIRENT_H&lt;/CODE&gt; &lt;LI&gt;
         &lt;TT&gt;sys/ndir.h&lt;/TT&gt; @tab
         &lt;CODE&gt;HAVE_SYS_NDIR_H&lt;/CODE&gt; &lt;LI&gt;
         &lt;TT&gt;sys/dir.h&lt;/TT&gt;  @tab
         &lt;CODE&gt;HAVE_SYS_DIR_H&lt;/CODE&gt; &lt;LI&gt;
         &lt;TT&gt;ndir.h&lt;/TT&gt;     @tab
         &lt;CODE&gt;HAVE_NDIR_H&lt;/CODE&gt; @end multitable&lt;/P&gt;&lt;P&gt;

         The directory-library declarations in your source code should
         look something like the following:&lt;/P&gt;&lt;P&gt;

         &lt;TABLE&gt;&lt;tr&gt;&lt;td&gt;&amp;nbsp;&lt;/td&gt;&lt;td
         class=example&gt;&lt;pre&gt; @group #if HAVE_DIRENT_H # include
         &lt;dirent.h&gt; # define NAMLEN(dirent)
         strlen((dirent)-&gt;d_name) #else # define dirent direct #
         define NAMLEN(dirent) (dirent)-&gt;d_namlen # if HAVE_SYS_NDIR_H
         #  include &lt;sys/ndir.h&gt; # endif # if HAVE_SYS_DIR_H # 
         include &lt;sys/dir.h&gt; # endif # if HAVE_NDIR_H #  include
         &lt;ndir.h&gt; # endif #endif @end group
         &lt;/pre&gt;&lt;/td&gt;&lt;/tr&gt;&lt;/table&gt;&lt;/P&gt;&lt;P&gt;

         Using the above declarations, the program would declare
         variables to be of type &lt;CODE&gt;struct dirent&lt;/CODE&gt;,
         not &lt;CODE&gt;struct direct&lt;/CODE&gt;, and would access the
         length of a directory entry name by passing a pointer to a
         &lt;CODE&gt;struct dirent&lt;/CODE&gt; to the
         &lt;CODE&gt;NAMLEN&lt;/CODE&gt; macro.&lt;/P&gt;&lt;P&gt;

         This macro also checks for the SCO Xenix
         &lt;TT&gt;dir&lt;/TT&gt; and &lt;TT&gt;x&lt;/TT&gt; libraries.
        </synopsis>
  </macro>
  <macro id="AC_HEADER_MAJOR">
      <prototype>
      </prototype>
        <synopsis>
            /mkdev.h /sysmacros.h If &lt;TT&gt;sys/types.h&lt;/TT&gt;
         does not define &lt;CODE&gt;major&lt;/CODE&gt;,
         &lt;CODE&gt;minor&lt;/CODE&gt;, and
         &lt;CODE&gt;makedev&lt;/CODE&gt;, but
         &lt;TT&gt;sys/mkdev.h&lt;/TT&gt; does, define
         &lt;CODE&gt;MAJOR_IN_MKDEV&lt;/CODE&gt;; otherwise, if
         &lt;TT&gt;sys/sysmacros.h&lt;/TT&gt; does, define
         &lt;CODE&gt;MAJOR_IN_SYSMACROS&lt;/CODE&gt;.
        </synopsis>
  </macro>
  <macro id="AC_HEADER_STAT">
      <prototype>
      </prototype>
        <synopsis>
           /stat.h If the macros &lt;CODE&gt;S_ISDIR&lt;/CODE&gt;,
         &lt;CODE&gt;S_ISREG&lt;/CODE&gt;, etc.@: defined in
         &lt;TT&gt;sys/stat.h&lt;/TT&gt; do not work properly (returning
         false positives), define
         &lt;CODE&gt;STAT_MACROS_BROKEN&lt;/CODE&gt;.  This is the case
         on Tektronix UTekV, Amdahl UTS and Motorola System V/88.
        </synopsis>
  </macro>
  <macro id="AC_HEADER_STDBOOL">
      <prototype>
      </prototype>
        <synopsis>
            .h .h If &lt;TT&gt;stdbool.h&lt;/TT&gt; exists and is
         conformant to C99, define
         &lt;CODE&gt;HAVE_STDBOOL_H&lt;/CODE&gt; to 1; if the type
         &lt;CODE&gt;_Bool&lt;/CODE&gt; is defined, define
         &lt;CODE&gt;HAVE__BOOL&lt;/CODE&gt; to 1.  To fulfill the C99
         requirements, your &lt;TT&gt;system.h&lt;/TT&gt; should contain
         the following code:&lt;/P&gt;&lt;P&gt;

         &lt;CODE&gt; #if HAVE_STDBOOL_H # include &lt;stdbool.h&gt;
         #else # if ! HAVE__BOOL #  ifdef __cplusplus typedef bool _Bool;
         #  else typedef unsigned char _Bool; #  endif # endif # define
         bool _Bool # define false 0 # define true 1 # define
         __bool_true_false_are_defined 1 #endif &lt;/CODE&gt;
        </synopsis>
  </macro>
  <macro id="AC_HEADER_STDC">
      <prototype>
      </prototype>
        <synopsis>
           .h .h .h .h .h Define &lt;CODE&gt;STDC_HEADERS&lt;/CODE&gt; if
         the system has ANSI C header files. Specifically, this macro
         checks for &lt;TT&gt;stdlib.h&lt;/TT&gt;,
         &lt;TT&gt;stdarg.h&lt;/TT&gt;, &lt;TT&gt;string.h&lt;/TT&gt;,
         and &lt;TT&gt;float.h&lt;/TT&gt;; if the system has those, it
         probably has the rest of the ANSI C header files.  This macro
         also checks whether &lt;TT&gt;string.h&lt;/TT&gt; declares
         &lt;CODE&gt;memchr&lt;/CODE&gt; (and thus presumably the other
         &lt;CODE&gt;mem&lt;/CODE&gt; functions), whether
         &lt;TT&gt;stdlib.h&lt;/TT&gt; declare
         &lt;CODE&gt;free&lt;/CODE&gt; (and thus presumably
         &lt;CODE&gt;malloc&lt;/CODE&gt; and other related functions),
         and whether the &lt;TT&gt;ctype.h&lt;/TT&gt; macros work on
         characters with the high bit set, as ANSI C requires.&lt;/P&gt;&lt;P&gt;

         Use &lt;CODE&gt;STDC_HEADERS&lt;/CODE&gt; instead of
         &lt;CODE&gt;__STDC__&lt;/CODE&gt; to determine whether the
         system has ANSI-compliant header files (and probably C library
         functions) because many systems that have GCC do not have ANSI C
         header files.&lt;/P&gt;&lt;P&gt;

         .h .h On systems without ANSI C headers, there is so much
         variation that it is probably easier to declare the functions
         you use than to figure out exactly what the system header files
         declare.  Some systems contain a mix of functions from ANSI and
         BSD; some are mostly ANSI but lack
         &lt;samp&gt;memmove&lt;/samp&gt;; some define the BSD functions
         as macros in &lt;TT&gt;string.h&lt;/TT&gt; or
         &lt;TT&gt;strings.h&lt;/TT&gt;; some have only the BSD functions
         but &lt;TT&gt;string.h&lt;/TT&gt;; some declare the memory
         functions in &lt;TT&gt;memory.h&lt;/TT&gt;, some in
         &lt;TT&gt;string.h&lt;/TT&gt;; etc.  It is probably sufficient
         to check for one string function and one memory function; if the
         library has the ANSI versions of those then it probably has most
         of the others. If you put the following in
         &lt;TT&gt;configure.ac&lt;/TT&gt;:&lt;/P&gt;&lt;P&gt;

         &lt;TABLE&gt;&lt;tr&gt;&lt;td&gt;&amp;nbsp;&lt;/td&gt;&lt;td
         class=example&gt;&lt;pre&gt; AC_HEADER_STDC
         AC_CHECK_FUNCS(strchr memcpy)
         &lt;/pre&gt;&lt;/td&gt;&lt;/tr&gt;&lt;/table&gt;&lt;/P&gt;&lt;P&gt;

          then, in your code, you can use declarations like this:&lt;/P&gt;&lt;P&gt;

         &lt;TABLE&gt;&lt;tr&gt;&lt;td&gt;&amp;nbsp;&lt;/td&gt;&lt;td
         class=example&gt;&lt;pre&gt; @group #if STDC_HEADERS # include
         &lt;string.h&gt; #else # if !HAVE_STRCHR #  define strchr index
         #  define strrchr rindex # endif char *strchr (), *strrchr (); #
         if !HAVE_MEMCPY #  define memcpy(d, s, n) bcopy ((s), (d), (n))
         #  define memmove(d, s, n) bcopy ((s), (d), (n)) # endif #endif
         @end group &lt;/pre&gt;&lt;/td&gt;&lt;/tr&gt;&lt;/table&gt;&lt;/P&gt;&lt;P&gt;

          If you use a function like &lt;CODE&gt;memchr&lt;/CODE&gt;,
         &lt;CODE&gt;memset&lt;/CODE&gt;,
         &lt;CODE&gt;strtok&lt;/CODE&gt;, or
         &lt;CODE&gt;strspn&lt;/CODE&gt;, which have no BSD equivalent,
         then macros won't suffice; you must provide an implementation of
         each function.  An easy way to incorporate your implementations
         only when needed (since the ones in system C libraries may be
         hand optimized) is to, taking &lt;CODE&gt;memchr&lt;/CODE&gt;
         for example, put it in &lt;TT&gt;memchr.c&lt;/TT&gt; and use
         &lt;samp&gt;AC_REPLACE_FUNCS(memchr)&lt;/samp&gt;.
        </synopsis>
  </macro>
  <macro id="AC_HEADER_SYS_WAIT">
      <prototype>
      </prototype>
        <synopsis>
           /wait.h If &lt;TT&gt;sys/wait.h&lt;/TT&gt; exists and is
         compatible with POSIX, define
         &lt;CODE&gt;HAVE_SYS_WAIT_H&lt;/CODE&gt;.  Incompatibility can
         occur if &lt;TT&gt;sys/wait.h&lt;/TT&gt; does not exist, or if
         it uses the old BSD &lt;CODE&gt;union wait&lt;/CODE&gt; instead
         of &lt;CODE&gt;int&lt;/CODE&gt; to store a status value.  If
         &lt;TT&gt;sys/wait.h&lt;/TT&gt; is not POSIX compatible, then
         instead of including it, define the POSIX macros with their
         usual interpretations.  Here is an example:&lt;/P&gt;&lt;P&gt;

         &lt;TABLE&gt;&lt;tr&gt;&lt;td&gt;&amp;nbsp;&lt;/td&gt;&lt;td
         class=example&gt;&lt;pre&gt; @group #include &lt;sys/types.h&gt;
         #if HAVE_SYS_WAIT_H # include &lt;sys/wait.h&gt; #endif #ifndef
         WEXITSTATUS # define WEXITSTATUS(stat_val) ((unsigned)(stat_val)
         &gt;&gt; 8) #endif #ifndef WIFEXITED # define
         WIFEXITED(stat_val) (((stat_val) &amp; 255) == 0) #endif @end
         group &lt;/pre&gt;&lt;/td&gt;&lt;/tr&gt;&lt;/table&gt;
        </synopsis>
  </macro>
  <macro id="AC_HEADER_TIME">
      <prototype>
      </prototype>
        <synopsis>
           .h /time.h If a program may include both
         &lt;TT&gt;time.h&lt;/TT&gt; and &lt;TT&gt;sys/time.h&lt;/TT&gt;,
         define &lt;CODE&gt;TIME_WITH_SYS_TIME&lt;/CODE&gt;.  On some
         older systems, &lt;TT&gt;sys/time.h&lt;/TT&gt; includes
         &lt;TT&gt;time.h&lt;/TT&gt;, but &lt;TT&gt;time.h&lt;/TT&gt; is
         not protected against multiple inclusion, so programs should not
         explicitly include both files.  This macro is useful in programs
         that use, for example, &lt;CODE&gt;struct timeval&lt;/CODE&gt;
         as well as &lt;CODE&gt;struct tm&lt;/CODE&gt;.  It is best used
         in conjunction with &lt;CODE&gt;HAVE_SYS_TIME_H&lt;/CODE&gt;,
         which can be checked for using
         &lt;CODE&gt;AC_CHECK_HEADERS(sys/time.h)&lt;/CODE&gt;.&lt;/P&gt;&lt;P&gt;

         &lt;TABLE&gt;&lt;tr&gt;&lt;td&gt;&amp;nbsp;&lt;/td&gt;&lt;td
         class=example&gt;&lt;pre&gt; @group #if TIME_WITH_SYS_TIME #
         include &lt;sys/time.h&gt; # include &lt;time.h&gt; #else # if
         HAVE_SYS_TIME_H #  include &lt;sys/time.h&gt; # else #  include
         &lt;time.h&gt; # endif #endif @end group
         &lt;/pre&gt;&lt;/td&gt;&lt;/tr&gt;&lt;/table&gt;
        </synopsis>
  </macro>
  <macro id="AC_HEADER_TIOCGWINSZ">
      <prototype>
      </prototype>
        <synopsis>
           /ioctl.h .h If the use of &lt;CODE&gt;TIOCGWINSZ&lt;/CODE&gt;
         requires &lt;TT&gt;&lt;sys/ioctl.h&gt;&lt;/TT&gt;, then define
         &lt;CODE&gt;GWINSZ_IN_SYS_IOCTL&lt;/CODE&gt;.  Otherwise
         &lt;CODE&gt;TIOCGWINSZ&lt;/CODE&gt; can be found in
         &lt;TT&gt;&lt;termios.h&gt;&lt;/TT&gt;.&lt;/P&gt;&lt;P&gt;

         Use:&lt;/P&gt;&lt;P&gt;

         &lt;TABLE&gt;&lt;tr&gt;&lt;td&gt;&amp;nbsp;&lt;/td&gt;&lt;td
         class=example&gt;&lt;pre&gt; @group #if HAVE_TERMIOS_H # include
         &lt;termios.h&gt; #endif&lt;/P&gt;&lt;P&gt;

         #if GWINSZ_IN_SYS_IOCTL # include &lt;sys/ioctl.h&gt; #endif
         @end group &lt;/pre&gt;&lt;/td&gt;&lt;/tr&gt;&lt;/table&gt;
        </synopsis>
  </macro>
  <macro id="AC_CHECK_HEADER">
      <prototype>
        <parameter content="header-file"/>
        <parameter content="[action-if-found]"/>
        <parameter content="[action-if-not-found]"/>
        <parameter content="[includes= default-includes]"/>
      </prototype>
        <synopsis>
          If the system header file &lt;VAR&gt;header-file&lt;/VAR&gt; is
         compilable, execute shell commands
         &lt;VAR&gt;action-if-found&lt;/VAR&gt;, otherwise execute
         &lt;VAR&gt;action-if-not-found&lt;/VAR&gt;.  If you just want to
         define a symbol if the header file is available, consider using
         &lt;CODE&gt;AC_CHECK_HEADERS&lt;/CODE&gt; instead.&lt;/P&gt;&lt;P&gt;

         For compatibility issues with older versions of Autoconf, please
         read below.
        </synopsis>
  </macro>
  <macro id="AC_CHECK_HEADERS">
      <prototype>
        <parameter content="header-file..."/>
        <parameter content="[action-if-found]"/>
        <parameter content="[action-if-not-found]"/>
        <parameter content="[includes= default-includes]"/>
      </prototype>
        <synopsis>
           For each given system header file
         &lt;VAR&gt;header-file&lt;/VAR&gt; in the whitespace-separated
         argument list that exists, define
         &lt;CODE&gt;HAVE_&lt;VAR&gt;header-file&lt;/VAR&gt;&lt;/CODE&gt;
         (in all capitals).  If &lt;VAR&gt;action-if-found&lt;/VAR&gt; is
         given, it is additional shell code to execute when one of the
         header files is found.  You can give it a value of
         &lt;samp&gt;break&lt;/samp&gt; to break out of the loop on the
         first match.  If &lt;VAR&gt;action-if-not-found&lt;/VAR&gt; is
         given, it is executed when one of the header files is not found.&lt;/P&gt;&lt;P&gt;

         For compatibility issues with older versions of Autoconf, please
         read below.
        </synopsis>
  </macro>
  <macro id="AC_CHECK_DECL">
      <prototype>
        <parameter content="symbol"/>
        <parameter content="[action-if-found]"/>
        <parameter content="[action-if-not-found]"/>
        <parameter content="[includes= default-includes]"/>
      </prototype>
        <synopsis>
          If &lt;VAR&gt;symbol&lt;/VAR&gt; (a function or a variable) is
         not declared in &lt;VAR&gt;includes&lt;/VAR&gt; and a
         declaration is needed, run the shell commands
         &lt;VAR&gt;action-if-not-found&lt;/VAR&gt;, otherwise
         &lt;VAR&gt;action-if-found&lt;/VAR&gt;.  If no
         &lt;VAR&gt;includes&lt;/VAR&gt; are specified, the default
         includes are used (Default Includes).&lt;/P&gt;&lt;P&gt;

         This macro actually tests whether it is valid to use
         &lt;VAR&gt;symbol&lt;/VAR&gt; as an r-value, not if it is really
         declared, because it is much safer to avoid introducing extra
         declarations when they are not needed.
        </synopsis>
  </macro>
  <macro id="AC_CHECK_DECLS">
      <prototype>
        <parameter content="symbols"/>
        <parameter content="[action-if-found]"/>
        <parameter content="[action-if-not-found]"/>
        <parameter content="[includes= default-includes]"/>
      </prototype>
        <synopsis>
           For each of the &lt;VAR&gt;symbols&lt;/VAR&gt;
         (&lt;EM&gt;comma&lt;/EM&gt;-separated list), define
         &lt;CODE&gt;HAVE_DECL_&lt;VAR&gt;symbol&lt;/VAR&gt;&lt;/CODE&gt;
         (in all capitals) to &lt;samp&gt;1&lt;/samp&gt; if
         &lt;VAR&gt;symbol&lt;/VAR&gt; is declared, otherwise to
         &lt;samp&gt;0&lt;/samp&gt;.  If
         &lt;VAR&gt;action-if-not-found&lt;/VAR&gt; is given, it is
         additional shell code to execute when one of the function
         declarations is needed, otherwise
         &lt;VAR&gt;action-if-found&lt;/VAR&gt; is executed.&lt;/P&gt;&lt;P&gt;

         This macro uses an m4 list as first argument:
         &lt;TABLE&gt;&lt;tr&gt;&lt;td&gt;&amp;nbsp;&lt;/td&gt;&lt;td
         class=example&gt;&lt;pre&gt; AC_CHECK_DECLS(strdup)
         AC_CHECK_DECLS([strlen]) AC_CHECK_DECLS([malloc, realloc,
         calloc, free]) &lt;/pre&gt;&lt;/td&gt;&lt;/tr&gt;&lt;/table&gt;&lt;/P&gt;&lt;P&gt;

         Unlike the other &lt;samp&gt;AC_CHECK_*S&lt;/samp&gt; macros,
         when a &lt;VAR&gt;symbol&lt;/VAR&gt; is not declared,
         &lt;CODE&gt;HAVE_DECL_&lt;VAR&gt;symbol&lt;/VAR&gt;&lt;/CODE&gt;
         is defined to &lt;samp&gt;0&lt;/samp&gt; instead of leaving
         &lt;CODE&gt;HAVE_DECL_&lt;VAR&gt;symbol&lt;/VAR&gt;&lt;/CODE&gt;
         undeclared.  When you are &lt;EM&gt;sure&lt;/EM&gt; that the
         check was performed, use
         &lt;CODE&gt;HAVE_DECL_&lt;VAR&gt;symbol&lt;/VAR&gt;&lt;/CODE&gt;
         just like any other result of Autoconf:&lt;/P&gt;&lt;P&gt;

         &lt;TABLE&gt;&lt;tr&gt;&lt;td&gt;&amp;nbsp;&lt;/td&gt;&lt;td
         class=example&gt;&lt;pre&gt; #if !HAVE_DECL_SYMBOL extern char
         *symbol; #endif &lt;/pre&gt;&lt;/td&gt;&lt;/tr&gt;&lt;/table&gt;&lt;/P&gt;&lt;P&gt;

          If the test may have not been performed, however, because it is
         safer &lt;EM&gt;not&lt;/EM&gt; to declare a symbol than to use a
         declaration that conflicts with the system's one, you should
         use:&lt;/P&gt;&lt;P&gt;

         &lt;TABLE&gt;&lt;tr&gt;&lt;td&gt;&amp;nbsp;&lt;/td&gt;&lt;td
         class=example&gt;&lt;pre&gt; #if defined HAVE_DECL_MALLOC
         &amp;&amp; !HAVE_DECL_MALLOC void *malloc (size_t *s); #endif
         &lt;/pre&gt;&lt;/td&gt;&lt;/tr&gt;&lt;/table&gt;&lt;/P&gt;&lt;P&gt;

          You fall into the second category only in extreme situations:
         either your files may be used without being configured, or they
         are used during the configuration.  In most cases the
         traditional approach is enough.
        </synopsis>
  </macro>
  <macro id="AC_STRUCT_ST_BLKSIZE">
      <prototype>
      </prototype>
        <synopsis>
            If &lt;CODE&gt;struct stat&lt;/CODE&gt; contains an
         &lt;CODE&gt;st_blksize&lt;/CODE&gt; member, define
         &lt;CODE&gt;HAVE_STRUCT_STAT_ST_BLKSIZE&lt;/CODE&gt;.  The
         former name, &lt;CODE&gt;HAVE_ST_BLKSIZE&lt;/CODE&gt; is to be
         avoided, as its support will cease in the future.  This macro is
         obsoleted, and should be replaced by&lt;/P&gt;&lt;P&gt;

         &lt;TABLE&gt;&lt;tr&gt;&lt;td&gt;&amp;nbsp;&lt;/td&gt;&lt;td
         class=example&gt;&lt;pre&gt; AC_CHECK_MEMBERS([struct
         stat.st_blksize])
         &lt;/pre&gt;&lt;/td&gt;&lt;/tr&gt;&lt;/table&gt;
        </synopsis>
  </macro>
  <macro id="AC_STRUCT_ST_BLOCKS">
      <prototype>
      </prototype>
        <synopsis>
             If &lt;CODE&gt;struct stat&lt;/CODE&gt; contains an
         &lt;CODE&gt;st_blocks&lt;/CODE&gt; member, define
         &lt;CODE&gt;HAVE_STRUCT_STAT_ST_BLOCKS&lt;/CODE&gt;.  Otherwise,
         require an &lt;CODE&gt;AC_LIBOBJ&lt;/CODE&gt; replacement of
         &lt;samp&gt;fileblocks&lt;/samp&gt;.  The former name,
         &lt;CODE&gt;HAVE_ST_BLOCKS&lt;/CODE&gt; is to be avoided, as its
         support will cease in the future.
        </synopsis>
  </macro>
  <macro id="AC_STRUCT_ST_RDEV">
      <prototype>
      </prototype>
        <synopsis>
            If &lt;CODE&gt;struct stat&lt;/CODE&gt; contains an
         &lt;CODE&gt;st_rdev&lt;/CODE&gt; member, define
         &lt;CODE&gt;HAVE_STRUCT_STAT_ST_RDEV&lt;/CODE&gt;.  The former
         name for this macro, &lt;CODE&gt;HAVE_ST_RDEV&lt;/CODE&gt;, is
         to be avoided as it will cease to be supported in the future. 
         Actually, even the new macro is obsolete and should be replaced
         by: &lt;TABLE&gt;&lt;tr&gt;&lt;td&gt;&amp;nbsp;&lt;/td&gt;&lt;td
         class=example&gt;&lt;pre&gt; AC_CHECK_MEMBERS([struct
         stat.st_rdev]) &lt;/pre&gt;&lt;/td&gt;&lt;/tr&gt;&lt;/table&gt;
        </synopsis>
  </macro>
  <macro id="AC_STRUCT_TM">
      <prototype>
      </prototype>
        <synopsis>
           .h /time.h If &lt;TT&gt;time.h&lt;/TT&gt; does not define
         &lt;CODE&gt;struct tm&lt;/CODE&gt;, define
         &lt;CODE&gt;TM_IN_SYS_TIME&lt;/CODE&gt;, which means that
         including &lt;TT&gt;sys/time.h&lt;/TT&gt; had better define
         &lt;CODE&gt;struct tm&lt;/CODE&gt;.
        </synopsis>
  </macro>
  <macro id="AC_STRUCT_TIMEZONE">
      <prototype>
      </prototype>
        <synopsis>
            Figure out how to get the current timezone.  If
         &lt;CODE&gt;struct tm&lt;/CODE&gt; has a
         &lt;CODE&gt;tm_zone&lt;/CODE&gt; member, define
         &lt;CODE&gt;HAVE_STRUCT_TM_TM_ZONE&lt;/CODE&gt; (and the
         obsoleted &lt;CODE&gt;HAVE_TM_ZONE&lt;/CODE&gt;).  Otherwise, if
         the external array &lt;CODE&gt;tzname&lt;/CODE&gt; is found,
         define &lt;CODE&gt;HAVE_TZNAME&lt;/CODE&gt;.
        </synopsis>
  </macro>
  <macro id="AC_CHECK_MEMBER">
      <prototype>
        <parameter content="aggregate.member"/>
        <parameter content="[action-if-found]"/>
        <parameter content="[action-if-not-found]"/>
        <parameter content="[includes= default-includes]"/>
      </prototype>
        <synopsis>
          Check whether &lt;VAR&gt;member&lt;/VAR&gt; is a member of the
         aggregate &lt;VAR&gt;aggregate&lt;/VAR&gt;. If no
         &lt;VAR&gt;includes&lt;/VAR&gt; are specified, the default
         includes are used (Default Includes).&lt;/P&gt;&lt;P&gt;

         &lt;TABLE&gt;&lt;tr&gt;&lt;td&gt;&amp;nbsp;&lt;/td&gt;&lt;td
         class=example&gt;&lt;pre&gt; AC_CHECK_MEMBER(struct
         passwd.pw_gecos,,                 [AC_MSG_ERROR([We need
         `passwd.pw_gecos'!])],                 [#include &lt;pwd.h&gt;])
         &lt;/pre&gt;&lt;/td&gt;&lt;/tr&gt;&lt;/table&gt;&lt;/P&gt;&lt;P&gt;

         You can use this macro for sub-members:&lt;/P&gt;&lt;P&gt;

         &lt;TABLE&gt;&lt;tr&gt;&lt;td&gt;&amp;nbsp;&lt;/td&gt;&lt;td
         class=example&gt;&lt;pre&gt; AC_CHECK_MEMBER(struct
         top.middle.bot) &lt;/pre&gt;&lt;/td&gt;&lt;/tr&gt;&lt;/table&gt;
        </synopsis>
  </macro>
  <macro id="AC_CHECK_MEMBERS">
      <prototype>
        <parameter content="members"/>
        <parameter content="[action-if-found]"/>
        <parameter content="[action-if-not-found]"/>
        <parameter content="[includes= default-includes]"/>
      </prototype>
        <synopsis>
          Check for the existence of each
         &lt;samp&gt;&lt;VAR&gt;aggregate&lt;/VAR&gt;.&lt;VAR&gt;member&lt;/VAR&gt;&lt;/samp&gt;
         of &lt;VAR&gt;members&lt;/VAR&gt; using the previous macro. 
         When &lt;VAR&gt;member&lt;/VAR&gt; belongs to
         &lt;VAR&gt;aggregate&lt;/VAR&gt;, define
         &lt;CODE&gt;HAVE_&lt;VAR&gt;aggregate&lt;/VAR&gt;_&lt;VAR&gt;member&lt;/VAR&gt;&lt;/CODE&gt;
         (in all capitals, with spaces and dots replaced by underscores).
          If &lt;VAR&gt;action-if-found&lt;/VAR&gt; is given, it is
         executed for each of the found members.  If
         &lt;VAR&gt;action-if-not-found&lt;/VAR&gt; is given, it is
         executed for each of the members that could not be found.&lt;/P&gt;&lt;P&gt;

         This macro uses m4 lists:
         &lt;TABLE&gt;&lt;tr&gt;&lt;td&gt;&amp;nbsp;&lt;/td&gt;&lt;td
         class=example&gt;&lt;pre&gt; AC_CHECK_MEMBERS([struct
         stat.st_rdev, struct stat.st_blksize])
         &lt;/pre&gt;&lt;/td&gt;&lt;/tr&gt;&lt;/table&gt;
        </synopsis>
  </macro>
  <macro id="AC_TYPE_GETGROUPS">
      <prototype>
      </prototype>
        <synopsis>
           Define &lt;CODE&gt;GETGROUPS_T&lt;/CODE&gt; to be whichever of
         &lt;CODE&gt;gid_t&lt;/CODE&gt; or &lt;CODE&gt;int&lt;/CODE&gt;
         is the base type of the array argument to
         &lt;CODE&gt;getgroups&lt;/CODE&gt;.
        </synopsis>
  </macro>
  <macro id="AC_TYPE_MBSTATE_T">
      <prototype>
      </prototype>
        <synopsis>
           .h Define &lt;CODE&gt;HAVE_MBSTATE_T&lt;/CODE&gt; if
         &lt;CODE&gt;&lt;wchar.h&gt;&lt;/CODE&gt; declares the
         &lt;CODE&gt;mbstate_t&lt;/CODE&gt; type.  Also, define
         &lt;CODE&gt;mbstate_t&lt;/CODE&gt; to be a type if
         &lt;CODE&gt;&lt;wchar.h&gt;&lt;/CODE&gt; does not declare it.
        </synopsis>
  </macro>
  <macro id="AC_TYPE_MODE_T">
      <prototype>
      </prototype>
        <synopsis>
           Equivalent to &lt;samp&gt;AC_CHECK_TYPE(mode_t,
         int)&lt;/samp&gt;.
        </synopsis>
  </macro>
  <macro id="AC_TYPE_OFF_T">
      <prototype>
      </prototype>
        <synopsis>
           Equivalent to &lt;samp&gt;AC_CHECK_TYPE(off_t,
         long)&lt;/samp&gt;.
        </synopsis>
  </macro>
  <macro id="AC_TYPE_PID_T">
      <prototype>
      </prototype>
        <synopsis>
           Equivalent to &lt;samp&gt;AC_CHECK_TYPE(pid_t,
         int)&lt;/samp&gt;.
        </synopsis>
  </macro>
  <macro id="AC_TYPE_SIGNAL">
      <prototype>
      </prototype>
        <synopsis>
           .h If &lt;TT&gt;signal.h&lt;/TT&gt; declares
         &lt;CODE&gt;signal&lt;/CODE&gt; as returning a pointer to a
         function returning &lt;CODE&gt;void&lt;/CODE&gt;, define
         &lt;CODE&gt;RETSIGTYPE&lt;/CODE&gt; to be
         &lt;CODE&gt;void&lt;/CODE&gt;; otherwise, define it to be
         &lt;CODE&gt;int&lt;/CODE&gt;.&lt;/P&gt;&lt;P&gt;

         Define signal handlers as returning type
         &lt;CODE&gt;RETSIGTYPE&lt;/CODE&gt;:&lt;/P&gt;&lt;P&gt;

         &lt;TABLE&gt;&lt;tr&gt;&lt;td&gt;&amp;nbsp;&lt;/td&gt;&lt;td
         class=example&gt;&lt;pre&gt; @group RETSIGTYPE hup_handler () 
         &lt;small&gt;...&lt;/small&gt; @ @end group
         &lt;/pre&gt;&lt;/td&gt;&lt;/tr&gt;&lt;/table&gt;
        </synopsis>
  </macro>
  <macro id="AC_TYPE_SIZE_T">
      <prototype>
      </prototype>
        <synopsis>
           Equivalent to &lt;samp&gt;AC_CHECK_TYPE(size_t,
         unsigned)&lt;/samp&gt;.
        </synopsis>
  </macro>
  <macro id="AC_TYPE_UID_T">
      <prototype>
      </prototype>
        <synopsis>
            If &lt;CODE&gt;uid_t&lt;/CODE&gt; is not defined, define
         &lt;CODE&gt;uid_t&lt;/CODE&gt; to be
         &lt;CODE&gt;int&lt;/CODE&gt; and &lt;CODE&gt;gid_t&lt;/CODE&gt;
         to be &lt;CODE&gt;int&lt;/CODE&gt;.
        </synopsis>
  </macro>
  <macro id="AC_CHECK_TYPE">
      <prototype>
        <parameter content="type"/>
        <parameter content="[action-if-found]"/>
        <parameter content="[action-if-not-found]"/>
        <parameter content="[includes= default-includes]"/>
      </prototype>
        <synopsis>
          Check whether &lt;VAR&gt;type&lt;/VAR&gt; is defined.  It may
         be a compiler builtin type or defined by the
         &lt;VAR&gt;includes&lt;/VAR&gt; (Default Includes).
        </synopsis>
  </macro>
  <macro id="AC_CHECK_TYPES">
      <prototype>
        <parameter content="types"/>
        <parameter content="[action-if-found]"/>
        <parameter content="[action-if-not-found]"/>
        <parameter content="[includes= default-includes]"/>
      </prototype>
        <synopsis>
          For each &lt;VAR&gt;type&lt;/VAR&gt; of the
         &lt;VAR&gt;types&lt;/VAR&gt; that is defined, define
         &lt;CODE&gt;HAVE_&lt;VAR&gt;type&lt;/VAR&gt;&lt;/CODE&gt; (in
         all capitals).  If no &lt;VAR&gt;includes&lt;/VAR&gt; are
         specified, the default includes are used (Default Includes).  If
         &lt;VAR&gt;action-if-found&lt;/VAR&gt; is given, it is
         additional shell code to execute when one of the types is found.
          If &lt;VAR&gt;action-if-not-found&lt;/VAR&gt; is given, it is
         executed when one of the types is not found.&lt;/P&gt;&lt;P&gt;

         This macro uses m4 lists:
         &lt;TABLE&gt;&lt;tr&gt;&lt;td&gt;&amp;nbsp;&lt;/td&gt;&lt;td
         class=example&gt;&lt;pre&gt; AC_CHECK_TYPES(ptrdiff_t)
         AC_CHECK_TYPES([unsigned long long, uintmax_t])
         &lt;/pre&gt;&lt;/td&gt;&lt;/tr&gt;&lt;/table&gt;&lt;/P&gt;&lt;P&gt;

        </synopsis>
  </macro>
  <macro id="AC_CHECK_SIZEOF">
      <prototype>
        <parameter content="type"/>
        <parameter content="[unused]"/>
        <parameter content="[includes= default-includes]"/>
      </prototype>
        <synopsis>
          Define
         &lt;CODE&gt;SIZEOF_&lt;VAR&gt;type&lt;/VAR&gt;&lt;/CODE&gt;
         (Standard Symbols) to be the size in bytes of
         &lt;VAR&gt;type&lt;/VAR&gt;.  If &lt;samp&gt;type&lt;/samp&gt;
         is unknown, it gets a size of 0.  If no
         &lt;VAR&gt;includes&lt;/VAR&gt; are specified, the default
         includes are used (Default Includes).  If you provide
         &lt;VAR&gt;include&lt;/VAR&gt;, be sure to include
         &lt;TT&gt;stdio.h&lt;/TT&gt; which is required for this macro to
         run.&lt;/P&gt;&lt;P&gt;

         This macro now works even when cross-compiling.  The
         &lt;VAR&gt;unused&lt;/VAR&gt; argument was used when
         cross-compiling.&lt;/P&gt;&lt;P&gt;

         For example, the call&lt;/P&gt;&lt;P&gt;

         &lt;TABLE&gt;&lt;tr&gt;&lt;td&gt;&amp;nbsp;&lt;/td&gt;&lt;td
         class=example&gt;&lt;pre&gt; AC_CHECK_SIZEOF(int *)
         &lt;/pre&gt;&lt;/td&gt;&lt;/tr&gt;&lt;/table&gt;&lt;/P&gt;&lt;P&gt;

          defines &lt;CODE&gt;SIZEOF_INT_P&lt;/CODE&gt; to be 8 on DEC
         Alpha AXP systems.
        </synopsis>
  </macro>
  <macro id="AC_LANG_WERROR">
      <prototype>
      </prototype>
        <synopsis>
          Normally Autoconf ignores warnings generated by the compiler,
         linker, and preprocessor.  If this macro is used, warnings will
         be treated as fatal errors instead for the current language. 
         This macro is useful when the results of configuration will be
         used where warnings are unacceptable; for instance, if parts of
         a program are built with the GCC
         &lt;samp&gt;-Werror&lt;/samp&gt; option.  If the whole program
         will be built using &lt;samp&gt;-Werror&lt;/samp&gt; it is often
         simpler to put &lt;samp&gt;-Werror&lt;/samp&gt; in the compiler
         flags (&lt;CODE&gt;CFLAGS&lt;/CODE&gt; etc.).
        </synopsis>
  </macro>
  <macro id="AC_PROG_CC">
      <prototype>
        <parameter content="[compiler-search-list]"/>
      </prototype>
        <synopsis>
            Determine a C compiler to use.  If
         &lt;CODE&gt;CC&lt;/CODE&gt; is not already set in the
         environment, check for &lt;CODE&gt;gcc&lt;/CODE&gt; and
         &lt;CODE&gt;cc&lt;/CODE&gt;, then for other C compilers.  Set
         output variable &lt;CODE&gt;CC&lt;/CODE&gt; to the name of the
         compiler found.&lt;/P&gt;&lt;P&gt;

         This macro may, however, be invoked with an optional first
         argument which, if specified, must be a space separated list of
         C compilers to search for.  This just gives the user an
         opportunity to specify an alternative search list for the C
         compiler.  For example, if you didn't like the default order,
         then you could invoke &lt;CODE&gt;AC_PROG_CC&lt;/CODE&gt; like
         this:&lt;/P&gt;&lt;P&gt;

         &lt;TABLE&gt;&lt;tr&gt;&lt;td&gt;&amp;nbsp;&lt;/td&gt;&lt;td
         class=example&gt;&lt;pre&gt; AC_PROG_CC(cl egcs gcc cc)
         &lt;/pre&gt;&lt;/td&gt;&lt;/tr&gt;&lt;/table&gt;&lt;/P&gt;&lt;P&gt;

         If the C compiler is not in ANSI C mode by default, try to add
         an option to output variable &lt;CODE&gt;CC&lt;/CODE&gt; to make
         it so.  This macro tries various options that select ANSI C on
         some system or another.  It considers the compiler to be in ANSI
         C mode if it handles function prototypes correctly.&lt;/P&gt;&lt;P&gt;

         After calling this macro you can check whether the C compiler
         has been set to accept ANSI C; if not, the shell variable
         &lt;CODE&gt;ac_cv_prog_cc_stdc&lt;/CODE&gt; is set to
         &lt;samp&gt;no&lt;/samp&gt;.  If you wrote your source code in
         ANSI C, you can make an un-ANSIfied copy of it by using the
         program &lt;CODE&gt;ansi2knr&lt;/CODE&gt;, which comes with
         Automake.  See also under
         &lt;CODE&gt;AC_C_PROTOTYPES&lt;/CODE&gt; below.&lt;/P&gt;&lt;P&gt;

         If using the GNU C compiler, set shell variable
         &lt;CODE&gt;GCC&lt;/CODE&gt; to &lt;samp&gt;yes&lt;/samp&gt;. 
         If output variable &lt;CODE&gt;CFLAGS&lt;/CODE&gt; was not
         already set, set it to &lt;samp&gt;-g -O2&lt;/samp&gt; for the
         GNU C compiler (&lt;samp&gt;-O2&lt;/samp&gt; on systems where
         GCC does not accept &lt;samp&gt;-g&lt;/samp&gt;), or
         &lt;samp&gt;-g&lt;/samp&gt; for other compilers.
        </synopsis>
  </macro>
  <macro id="AC_PROG_CC_C_O">
      <prototype>
      </prototype>
        <synopsis>
           If the C compiler does not accept the
         &lt;samp&gt;-c&lt;/samp&gt; and &lt;samp&gt;-o&lt;/samp&gt;
         options simultaneously, define
         &lt;CODE&gt;NO_MINUS_C_MINUS_O&lt;/CODE&gt;.  This macro
         actually tests both the compiler found by
         &lt;CODE&gt;AC_PROG_CC&lt;/CODE&gt;, and, if different, the
         first &lt;CODE&gt;cc&lt;/CODE&gt; in the path.  The test fails
         if one fails.  This macro was created for GNU Make to choose the
         default C compilation rule.
        </synopsis>
  </macro>
  <macro id="AC_PROG_CPP">
      <prototype>
      </prototype>
        <synopsis>
           Set output variable &lt;CODE&gt;CPP&lt;/CODE&gt; to a command
         that runs the C preprocessor.  If &lt;samp&gt;$CC
         -E&lt;/samp&gt; doesn't work, &lt;TT&gt;/lib/cpp&lt;/TT&gt; is
         used. It is only portable to run &lt;CODE&gt;CPP&lt;/CODE&gt; on
         files with a &lt;TT&gt;.c&lt;/TT&gt; extension.&lt;/P&gt;&lt;P&gt;

         Some preprocessors don't indicate missing include files by the
         error status.  For such preprocessors an internal variable is
         set that causes other macros to check the standard error from
         the preprocessor and consider the test failed if any warnings
         have been reported. For most preprocessors, though, warnings do
         not cause include-file tests to fail unless
         &lt;CODE&gt;AC_PROG_CPP_WERROR&lt;/CODE&gt; is also specified.
        </synopsis>
  </macro>
  <macro id="AC_PROG_CPP_WERROR">
      <prototype>
      </prototype>
        <synopsis>
           This acts like &lt;CODE&gt;AC_PROG_CPP&lt;/CODE&gt;, except it
         treats warnings from the preprocessor as errors even if the
         preprocessor exit status indicates success.  This is useful for
         avoiding headers that generate mandatory warnings, such as
         deprecation notices.
        </synopsis>
  </macro>
  <macro id="AC_C_BACKSLASH_A">
      <prototype>
      </prototype>
        <synopsis>
          Define &lt;samp&gt;HAVE_C_BACKSLASH_A&lt;/samp&gt; to 1 if the
         C compiler understands &lt;samp&gt;\a&lt;/samp&gt;.
        </synopsis>
  </macro>
  <macro id="AC_C_BIGENDIAN">
      <prototype>
        <parameter content="[action-if-true]"/>
        <parameter content="[action-if-false]"/>
        <parameter content="[action-if-unknown]"/>
      </prototype>
        <synopsis>
            If words are stored with the most significant byte first
         (like Motorola and SPARC CPUs), execute
         &lt;VAR&gt;action-if-true&lt;/VAR&gt;.  If words are stored with
         the least significant byte first (like Intel and VAX CPUs),
         execute &lt;VAR&gt;action-if-false&lt;/VAR&gt;.&lt;/P&gt;&lt;P&gt;

         This macro runs a test-case if endianness cannot be determined
         from the system header files.  When cross-compiling, the
         test-case is not run but grep'ed for some magic values. 
         &lt;VAR&gt;action-if-unknown&lt;/VAR&gt; is executed if the
         latter case fails to determine the byte sex of the host system.&lt;/P&gt;&lt;P&gt;

         The default for &lt;VAR&gt;action-if-true&lt;/VAR&gt; is to
         define &lt;samp&gt;WORDS_BIGENDIAN&lt;/samp&gt;.  The default
         for &lt;VAR&gt;action-if-false&lt;/VAR&gt; is to do nothing. 
         And finally, the default for
         &lt;VAR&gt;action-if-unknown&lt;/VAR&gt; is to abort configure
         and tell the installer which variable he should preset to bypass
         this test.
        </synopsis>
  </macro>
  <macro id="AC_C_CONST">
      <prototype>
      </prototype>
        <synopsis>
           If the C compiler does not fully support the ANSI C qualifier
         &lt;CODE&gt;const&lt;/CODE&gt;, define
         &lt;CODE&gt;const&lt;/CODE&gt; to be empty.  Some C compilers
         that do not define &lt;CODE&gt;__STDC__&lt;/CODE&gt; do support
         &lt;CODE&gt;const&lt;/CODE&gt;; some compilers that define
         &lt;CODE&gt;__STDC__&lt;/CODE&gt; do not completely support
         &lt;CODE&gt;const&lt;/CODE&gt;.  Programs can simply use
         &lt;CODE&gt;const&lt;/CODE&gt; as if every C compiler supported
         it; for those that don't, the &lt;TT&gt;Makefile&lt;/TT&gt; or
         configuration header file will define it as empty.&lt;/P&gt;&lt;P&gt;

         Occasionally installers use a C++ compiler to compile C code,
         typically because they lack a C compiler.  This causes problems
         with &lt;CODE&gt;const&lt;/CODE&gt;, because C and C++ treat
         &lt;CODE&gt;const&lt;/CODE&gt; differently.  For example:&lt;/P&gt;&lt;P&gt;

         &lt;TABLE&gt;&lt;tr&gt;&lt;td&gt;&amp;nbsp;&lt;/td&gt;&lt;td
         class=example&gt;&lt;pre&gt; const int foo;
         &lt;/pre&gt;&lt;/td&gt;&lt;/tr&gt;&lt;/table&gt;&lt;/P&gt;&lt;P&gt;

          is valid in C but not in C++.  These differences unfortunately
         cannot be papered over by defining
         &lt;CODE&gt;const&lt;/CODE&gt; to be empty.&lt;/P&gt;&lt;P&gt;

         If &lt;CODE&gt;autoconf&lt;/CODE&gt; detects this situation, it
         leaves &lt;CODE&gt;const&lt;/CODE&gt; alone, as this generally
         yields better results in practice.  However, using a C++
         compiler to compile C code is not recommended or supported, and
         installers who run into trouble in this area should get a C
         compiler like GCC to compile their C code.
        </synopsis>
  </macro>
  <macro id="AC_C_RESTRICT">
      <prototype>
      </prototype>
        <synopsis>
           If the C compiler recognizes the
         &lt;CODE&gt;restrict&lt;/CODE&gt; keyword, don't do anything. If
         it recognizes only a variant spelling
         (&lt;CODE&gt;__restrict&lt;/CODE&gt;,
         &lt;CODE&gt;__restrict__&lt;/CODE&gt;, or
         &lt;CODE&gt;_Restrict&lt;/CODE&gt;), then define
         &lt;CODE&gt;restrict&lt;/CODE&gt; to that. Otherwise, define
         &lt;CODE&gt;restrict&lt;/CODE&gt; to be empty. Thus, programs
         may simply use &lt;CODE&gt;restrict&lt;/CODE&gt; as if every C
         compiler supported it; for those that do not, the
         &lt;TT&gt;Makefile&lt;/TT&gt; or configuration header defines it
         away.&lt;/P&gt;&lt;P&gt;

         Although support in C++ for the
         &lt;CODE&gt;restrict&lt;/CODE&gt; keyword is not required,
         several C++ compilers do accept the keyword. This macro works
         for them, too.
        </synopsis>
  </macro>
  <macro id="AC_C_VOLATILE">
      <prototype>
      </prototype>
        <synopsis>
           If the C compiler does not understand the keyword
         &lt;CODE&gt;volatile&lt;/CODE&gt;, define
         &lt;CODE&gt;volatile&lt;/CODE&gt; to be empty.  Programs can
         simply use &lt;CODE&gt;volatile&lt;/CODE&gt; as if every C
         compiler supported it; for those that do not, the
         &lt;TT&gt;Makefile&lt;/TT&gt; or configuration header will
         define it as empty.&lt;/P&gt;&lt;P&gt;

         If the correctness of your program depends on the semantics of
         &lt;CODE&gt;volatile&lt;/CODE&gt;, simply defining it to be
         empty does, in a sense, break your code.  However, given that
         the compiler does not support &lt;CODE&gt;volatile&lt;/CODE&gt;,
         you are at its mercy anyway.  At least your program will
         compile, when it wouldn't before.&lt;/P&gt;&lt;P&gt;

         In general, the &lt;CODE&gt;volatile&lt;/CODE&gt; keyword is a
         feature of ANSI C, so you might expect that
         &lt;CODE&gt;volatile&lt;/CODE&gt; is available only when
         &lt;CODE&gt;__STDC__&lt;/CODE&gt; is defined.  However, Ultrix
         4.3's native compiler does support volatile, but does not define
         &lt;CODE&gt;__STDC__&lt;/CODE&gt;.
        </synopsis>
  </macro>
  <macro id="AC_C_INLINE">
      <prototype>
      </prototype>
        <synopsis>
           If the C compiler supports the keyword
         &lt;CODE&gt;inline&lt;/CODE&gt;, do nothing. Otherwise define
         &lt;CODE&gt;inline&lt;/CODE&gt; to
         &lt;CODE&gt;__inline__&lt;/CODE&gt; or
         &lt;CODE&gt;__inline&lt;/CODE&gt; if it accepts one of those,
         otherwise define &lt;CODE&gt;inline&lt;/CODE&gt; to be empty.
        </synopsis>
  </macro>
  <macro id="AC_C_CHAR_UNSIGNED">
      <prototype>
      </prototype>
        <synopsis>
           If the C type &lt;CODE&gt;char&lt;/CODE&gt; is unsigned,
         define &lt;CODE&gt;__CHAR_UNSIGNED__&lt;/CODE&gt;, unless the C
         compiler predefines it.
        </synopsis>
  </macro>
  <macro id="AC_C_LONG_DOUBLE">
      <prototype>
      </prototype>
        <synopsis>
           If the C compiler supports a working &lt;CODE&gt;long
         double&lt;/CODE&gt; type with more range or precision than the
         &lt;CODE&gt;double&lt;/CODE&gt; type, define
         &lt;CODE&gt;HAVE_LONG_DOUBLE&lt;/CODE&gt;.
        </synopsis>
  </macro>
  <macro id="AC_C_STRINGIZE">
      <prototype>
      </prototype>
        <synopsis>
           If the C preprocessor supports the stringizing operator,
         define &lt;CODE&gt;HAVE_STRINGIZE&lt;/CODE&gt;.  The stringizing
         operator is &lt;samp&gt;#&lt;/samp&gt; and is found in macros
         such as this:&lt;/P&gt;&lt;P&gt;

         &lt;TABLE&gt;&lt;tr&gt;&lt;td&gt;&amp;nbsp;&lt;/td&gt;&lt;td
         class=example&gt;&lt;pre&gt; #define x(y) #y
         &lt;/pre&gt;&lt;/td&gt;&lt;/tr&gt;&lt;/table&gt;
        </synopsis>
  </macro>
  <macro id="AC_C_PROTOTYPES">
      <prototype>
      </prototype>
        <synopsis>
             If function prototypes are understood by the compiler (as
         determined by &lt;CODE&gt;AC_PROG_CC&lt;/CODE&gt;), define
         &lt;CODE&gt;PROTOTYPES&lt;/CODE&gt; and
         &lt;CODE&gt;__PROTOTYPES&lt;/CODE&gt;. In the case the compiler
         does not handle prototypes, you should use
         &lt;CODE&gt;ansi2knr&lt;/CODE&gt;, which comes with the Automake
         distribution, to unprotoize function definitions.  For function
         prototypes, you should first define
         &lt;CODE&gt;PARAMS&lt;/CODE&gt;:&lt;/P&gt;&lt;P&gt;

         &lt;TABLE&gt;&lt;tr&gt;&lt;td&gt;&amp;nbsp;&lt;/td&gt;&lt;td
         class=example&gt;&lt;pre&gt; #ifndef PARAMS # if PROTOTYPES # 
         define PARAMS(protos) protos # else /* no PROTOTYPES */ # 
         define PARAMS(protos) () # endif /* no PROTOTYPES */ #endif
         &lt;/pre&gt;&lt;/td&gt;&lt;/tr&gt;&lt;/table&gt;&lt;/P&gt;&lt;P&gt;

          then use it this way:&lt;/P&gt;&lt;P&gt;

         &lt;TABLE&gt;&lt;tr&gt;&lt;td&gt;&amp;nbsp;&lt;/td&gt;&lt;td
         class=example&gt;&lt;pre&gt; size_t my_strlen PARAMS ((const
         char *)); &lt;/pre&gt;&lt;/td&gt;&lt;/tr&gt;&lt;/table&gt;
        </synopsis>
  </macro>
  <macro id="AC_PROG_GCC_TRADITIONAL">
      <prototype>
      </prototype>
        <synopsis>
           Add &lt;samp&gt;-traditional&lt;/samp&gt; to output variable
         &lt;CODE&gt;CC&lt;/CODE&gt; if using the GNU C compiler and
         &lt;CODE&gt;ioctl&lt;/CODE&gt; does not work properly without
         &lt;samp&gt;-traditional&lt;/samp&gt;.  That usually happens
         when the fixed header files have not been installed on an old
         system.  Since recent versions of the GNU C compiler fix the
         header files automatically when installed, this is becoming a
         less prevalent problem.
        </synopsis>
  </macro>
  <macro id="AC_PROG_CXX">
      <prototype>
        <parameter content="[compiler-search-list]"/>
      </prototype>
        <synopsis>
            Determine a C++ compiler to use.  Check if the environment
         variable &lt;CODE&gt;CXX&lt;/CODE&gt; or
         &lt;CODE&gt;CCC&lt;/CODE&gt; (in that order) is set; if so, then
         set output variable &lt;CODE&gt;CXX&lt;/CODE&gt; to its value.&lt;/P&gt;&lt;P&gt;

         Otherwise, if the macro is invoked without an argument, then
         search for a C++ compiler under the likely names (first
         &lt;CODE&gt;g++&lt;/CODE&gt; and &lt;CODE&gt;c++&lt;/CODE&gt;
         then other names).  If none of those checks succeed, then as a
         last resort set &lt;CODE&gt;CXX&lt;/CODE&gt; to
         &lt;CODE&gt;g++&lt;/CODE&gt;.&lt;/P&gt;&lt;P&gt;

         This macro may, however, be invoked with an optional first
         argument which, if specified, must be a space separated list of
         C++ compilers to search for.  This just gives the user an
         opportunity to specify an alternative search list for the C++
         compiler.  For example, if you didn't like the default order,
         then you could invoke &lt;CODE&gt;AC_PROG_CXX&lt;/CODE&gt; like
         this:&lt;/P&gt;&lt;P&gt;

         &lt;TABLE&gt;&lt;tr&gt;&lt;td&gt;&amp;nbsp;&lt;/td&gt;&lt;td
         class=example&gt;&lt;pre&gt; AC_PROG_CXX(cl KCC CC cxx cc++ xlC
         aCC c++ g++ egcs gcc)
         &lt;/pre&gt;&lt;/td&gt;&lt;/tr&gt;&lt;/table&gt;&lt;/P&gt;&lt;P&gt;

         If using the GNU C++ compiler, set shell variable
         &lt;CODE&gt;GXX&lt;/CODE&gt; to &lt;samp&gt;yes&lt;/samp&gt;. 
         If output variable &lt;CODE&gt;CXXFLAGS&lt;/CODE&gt; was not
         already set, set it to &lt;samp&gt;-g -O2&lt;/samp&gt; for the
         GNU C++ compiler (&lt;samp&gt;-O2&lt;/samp&gt; on systems where
         G++ does not accept &lt;samp&gt;-g&lt;/samp&gt;), or
         &lt;samp&gt;-g&lt;/samp&gt; for other compilers.
        </synopsis>
  </macro>
  <macro id="AC_PROG_CXXCPP">
      <prototype>
      </prototype>
        <synopsis>
           Set output variable &lt;CODE&gt;CXXCPP&lt;/CODE&gt; to a
         command that runs the C++ preprocessor.  If &lt;samp&gt;$CXX
         -E&lt;/samp&gt; doesn't work, &lt;TT&gt;/lib/cpp&lt;/TT&gt; is
         used. It is only portable to run &lt;CODE&gt;CXXCPP&lt;/CODE&gt;
         on files with a &lt;TT&gt;.c&lt;/TT&gt;,
         &lt;TT&gt;.C&lt;/TT&gt;, or &lt;TT&gt;.cc&lt;/TT&gt; extension.&lt;/P&gt;&lt;P&gt;

         Some preprocessors don't indicate missing include files by the
         error status.  For such preprocessors an internal variable is
         set that causes other macros to check the standard error from
         the preprocessor and consider the test failed if any warnings
         have been reported.  However, it is not known whether such
         broken preprocessors exist for C++.
        </synopsis>
  </macro>
  <macro id="AC_PROG_F77">
      <prototype>
        <parameter content="[compiler-search-list]"/>
      </prototype>
        <synopsis>
            Determine a Fortran 77 compiler to use.  If
         &lt;CODE&gt;F77&lt;/CODE&gt; is not already set in the
         environment, then check for &lt;CODE&gt;g77&lt;/CODE&gt; and
         &lt;CODE&gt;f77&lt;/CODE&gt;, and then some other names.  Set
         the output variable &lt;CODE&gt;F77&lt;/CODE&gt; to the name of
         the compiler found.&lt;/P&gt;&lt;P&gt;

         This macro may, however, be invoked with an optional first
         argument which, if specified, must be a space separated list of
         Fortran 77 compilers to search for.  This just gives the user an
         opportunity to specify an alternative search list for the
         Fortran 77 compiler.  For example, if you didn't like the
         default order, then you could invoke
         &lt;CODE&gt;AC_PROG_F77&lt;/CODE&gt; like this:&lt;/P&gt;&lt;P&gt;

         &lt;TABLE&gt;&lt;tr&gt;&lt;td&gt;&amp;nbsp;&lt;/td&gt;&lt;td
         class=example&gt;&lt;pre&gt; AC_PROG_F77(fl32 f77 fort77 xlf g77
         f90 xlf90) &lt;/pre&gt;&lt;/td&gt;&lt;/tr&gt;&lt;/table&gt;&lt;/P&gt;&lt;P&gt;

         If using &lt;CODE&gt;g77&lt;/CODE&gt; (the GNU Fortran 77
         compiler), then &lt;CODE&gt;AC_PROG_F77&lt;/CODE&gt; will set
         the shell variable &lt;CODE&gt;G77&lt;/CODE&gt; to
         &lt;samp&gt;yes&lt;/samp&gt;. If the output variable
         &lt;CODE&gt;FFLAGS&lt;/CODE&gt; was not already set in the
         environment, then set it to &lt;samp&gt;-g -02&lt;/samp&gt; for
         &lt;CODE&gt;g77&lt;/CODE&gt; (or &lt;samp&gt;-O2&lt;/samp&gt;
         where &lt;CODE&gt;g77&lt;/CODE&gt; does not accept
         &lt;samp&gt;-g&lt;/samp&gt;).  Otherwise, set
         &lt;CODE&gt;FFLAGS&lt;/CODE&gt; to &lt;samp&gt;-g&lt;/samp&gt;
         for all other Fortran 77 compilers.
        </synopsis>
  </macro>
  <macro id="AC_PROG_FC">
      <prototype>
        <parameter content="[compiler-search-list]"/>
        <parameter content="[dialect]"/>
      </prototype>
        <synopsis>
            Determine a Fortran compiler to use.  If
         &lt;CODE&gt;FC&lt;/CODE&gt; is not already set in the
         environment, then &lt;CODE&gt;dialect&lt;/CODE&gt; is a hint to
         indicate what Fortran dialect to search for; the default is to
         search for the newest available dialect.  Set the output
         variable &lt;CODE&gt;FC&lt;/CODE&gt; to the name of the compiler
         found.&lt;/P&gt;&lt;P&gt;

         By default, newer dialects are preferred over older dialects,
         but if &lt;CODE&gt;dialect&lt;/CODE&gt; is specified then older
         dialects are preferred starting with the specified dialect.
         &lt;CODE&gt;dialect&lt;/CODE&gt; can currently be one of Fortran
         77, Fortran 90, or Fortran 95.  However, this is only a hint of
         which compiler &lt;EM&gt;name&lt;/EM&gt; to prefer (e.g.
         &lt;CODE&gt;f90&lt;/CODE&gt; or &lt;CODE&gt;f95&lt;/CODE&gt;),
         and no attempt is made to guarantee that a particular language
         standard is actually supported.  Thus, it is preferable that you
         avoid the &lt;CODE&gt;dialect&lt;/CODE&gt; option, and use
         AC_PROG_FC only for code compatible with the latest Fortran
         standard.&lt;/P&gt;&lt;P&gt;

         This macro may, alternatively, be invoked with an optional first
         argument which, if specified, must be a space separated list of
         Fortran compilers to search for, just as in
         &lt;CODE&gt;AC_PROG_F77&lt;/CODE&gt;.&lt;/P&gt;&lt;P&gt;

         If the output variable &lt;CODE&gt;FCFLAGS&lt;/CODE&gt; was not
         already set in the environment, then set it to &lt;samp&gt;-g
         -02&lt;/samp&gt; for GNU &lt;CODE&gt;g77&lt;/CODE&gt; (or
         &lt;samp&gt;-O2&lt;/samp&gt; where &lt;CODE&gt;g77&lt;/CODE&gt;
         does not accept &lt;samp&gt;-g&lt;/samp&gt;).  Otherwise, set
         &lt;CODE&gt;FCFLAGS&lt;/CODE&gt; to &lt;samp&gt;-g&lt;/samp&gt;
         for all other Fortran compilers.
        </synopsis>
  </macro>
  <macro id="AC_PROG_F77_C_O">
      <prototype>
      </prototype>
      <prototype>
      </prototype>
        <synopsis>
             Test if the Fortran compiler accepts the options
         &lt;samp&gt;-c&lt;/samp&gt; and &lt;samp&gt;-o&lt;/samp&gt;
         simultaneously, and define
         &lt;CODE&gt;F77_NO_MINUS_C_MINUS_O&lt;/CODE&gt; or
         &lt;CODE&gt;FC_NO_MINUS_C_MINUS_O&lt;/CODE&gt;, respectively, if
         it does not.
        </synopsis>
  </macro>
  <macro id="AC_F77_LIBRARY_LDFLAGS">
      <prototype>
      </prototype>
      <prototype>
      </prototype>
        <synopsis>
             Determine the linker flags (e.g.,
         &lt;samp&gt;-L&lt;/samp&gt; and &lt;samp&gt;-l&lt;/samp&gt;) for
         the Fortran intrinsic and run-time libraries that are required
         to successfully link a Fortran program or shared library.  The
         output variable &lt;CODE&gt;FLIBS&lt;/CODE&gt; or
         &lt;CODE&gt;FCLIBS&lt;/CODE&gt; is set to these flags (which
         should be include after &lt;CODE&gt;LIBS&lt;/CODE&gt; when
         linking).&lt;/P&gt;&lt;P&gt;

         This macro is intended to be used in those situations when it is
         necessary to mix, e.g., C++ and Fortran source code in a single
         program or shared library (Mixing Fortran 77 With C and C++,,,
         automake, GNU Automake).&lt;/P&gt;&lt;P&gt;

         For example, if object files from a C++ and Fortran compiler
         must be linked together, then the C++ compiler/linker must be
         used for linking (since special C++-ish things need to happen at
         link time like calling global constructors, instantiating
         templates, enabling exception support, etc.).&lt;/P&gt;&lt;P&gt;

         However, the Fortran intrinsic and run-time libraries must be
         linked in as well, but the C++ compiler/linker doesn't know by
         default how to add these Fortran 77 libraries.  Hence, this
         macro was created to determine these Fortran libraries.&lt;/P&gt;&lt;P&gt;

         The macros
         &lt;CODE&gt;AC_F77_DUMMY_MAIN&lt;/CODE&gt;/&lt;CODE&gt;AC_FC_DUMMY_MAIN&lt;/CODE&gt;
         or
         &lt;CODE&gt;AC_F77_MAIN&lt;/CODE&gt;/&lt;CODE&gt;AC_FC_MAIN&lt;/CODE&gt;
         will probably also be necessary to link C/C++ with Fortran; see
         below.
        </synopsis>
  </macro>
  <macro id="AC_F77_DUMMY_MAIN">
      <prototype>
        <parameter content="[action-if-found]"/>
        <parameter content="[action-if-not-found]"/>
      </prototype>
      <prototype>
        <parameter content="[action-if-found]"/>
        <parameter content="[action-if-not-found]"/>
      </prototype>
        <synopsis>
           With many compilers, the Fortran libraries detected by
         &lt;CODE&gt;AC_F77_LIBRARY_LDFLAGS&lt;/CODE&gt; or
         &lt;CODE&gt;AC_FC_LIBRARY_LDFLAGS&lt;/CODE&gt; provide their own
         &lt;CODE&gt;main&lt;/CODE&gt; entry function that initializes
         things like Fortran I/O, and which then calls a user-provided
         entry function named (say) &lt;CODE&gt;MAIN__&lt;/CODE&gt; to
         run the user's program.  The
         &lt;CODE&gt;AC_F77_DUMMY_MAIN&lt;/CODE&gt;/&lt;CODE&gt;AC_FC_DUMMY_MAIN&lt;/CODE&gt;
         or
         &lt;CODE&gt;AC_F77_MAIN&lt;/CODE&gt;/&lt;CODE&gt;AC_FC_MAIN&lt;/CODE&gt;
         macro figures out how to deal with this interaction.&lt;/P&gt;&lt;P&gt;

         When using Fortran for purely numerical functions (no I/O,
         etc.)@: often one prefers to provide one's own
         &lt;CODE&gt;main&lt;/CODE&gt; and skip the Fortran library
         initializations.  In this case, however, one may still need to
         provide a dummy &lt;CODE&gt;MAIN__&lt;/CODE&gt; routine in order
         to prevent linking errors on some systems. 
         &lt;CODE&gt;AC_F77_DUMMY_MAIN&lt;/CODE&gt; or
         &lt;CODE&gt;AC_FC_DUMMY_MAIN&lt;/CODE&gt; detects whether any
         such routine is &lt;EM&gt;required&lt;/EM&gt; for linking, and
         what its name is; the shell variable
         &lt;CODE&gt;F77_DUMMY_MAIN&lt;/CODE&gt; or
         &lt;CODE&gt;FC_DUMMY_MAIN&lt;/CODE&gt; holds this name,
         &lt;CODE&gt;unknown&lt;/CODE&gt; when no solution was found, and
         &lt;CODE&gt;none&lt;/CODE&gt; when no such dummy main is needed.&lt;/P&gt;&lt;P&gt;

         By default, &lt;VAR&gt;action-if-found&lt;/VAR&gt; defines
         &lt;CODE&gt;F77_DUMMY_MAIN&lt;/CODE&gt; or
         &lt;CODE&gt;FC_DUMMY_MAIN&lt;/CODE&gt; to the name of this
         routine (e.g., &lt;CODE&gt;MAIN__&lt;/CODE&gt;)
         &lt;EM&gt;if&lt;/EM&gt; it is required.  action-if-not-found
         defaults to exiting with an error.&lt;/P&gt;&lt;P&gt;

         In order to link with Fortran routines, the user's C/C++ program
         should then include the following code to define the dummy main
         if it is needed:&lt;/P&gt;&lt;P&gt;

         &lt;TABLE&gt;&lt;tr&gt;&lt;td&gt;&amp;nbsp;&lt;/td&gt;&lt;td
         class=example&gt;&lt;pre&gt; #ifdef F77_DUMMY_MAIN #  ifdef
         __cplusplus      extern "C" #  endif    int F77_DUMMY_MAIN() 
         return 1; @ #endif
         &lt;/pre&gt;&lt;/td&gt;&lt;/tr&gt;&lt;/table&gt;&lt;/P&gt;&lt;P&gt;

         (Replace &lt;CODE&gt;F77&lt;/CODE&gt; with
         &lt;CODE&gt;FC&lt;/CODE&gt; for Fortran instead of Fortran 77.)&lt;/P&gt;&lt;P&gt;

         Note that this macro is called automatically from
         &lt;CODE&gt;AC_F77_WRAPPERS&lt;/CODE&gt; or
         &lt;CODE&gt;AC_FC_WRAPPERS&lt;/CODE&gt;; there is generally no
         need to call it explicitly unless one wants to change the
         default actions.
        </synopsis>
  </macro>
  <macro id="AC_F77_MAIN">
      <prototype>
      </prototype>
      <prototype>
      </prototype>
        <synopsis>
             As discussed above, many Fortran libraries allow you to
         provide an entry point called (say)
         &lt;CODE&gt;MAIN__&lt;/CODE&gt; instead of the usual
         &lt;CODE&gt;main&lt;/CODE&gt;, which is then called by a
         &lt;CODE&gt;main&lt;/CODE&gt; function in the Fortran libraries
         that initializes things like Fortran I/O@.  The
         &lt;CODE&gt;AC_F77_MAIN&lt;/CODE&gt;/&lt;CODE&gt;AC_FC_MAIN&lt;/CODE&gt;
         macro detects whether it is &lt;EM&gt;possible&lt;/EM&gt; to
         utilize such an alternate main function, and defines
         &lt;CODE&gt;F77_MAIN&lt;/CODE&gt;/&lt;CODE&gt;FC_MAIN&lt;/CODE&gt;
         to the name of the function.  (If no alternate main function
         name is found,
         &lt;CODE&gt;F77_MAIN&lt;/CODE&gt;/&lt;CODE&gt;FC_MAIN&lt;/CODE&gt;
         is simply defined to &lt;CODE&gt;main&lt;/CODE&gt;.)&lt;/P&gt;&lt;P&gt;

         Thus, when calling Fortran routines from C that perform things
         like I/O, one should use this macro and name the "main" function
         &lt;CODE&gt;F77_MAIN&lt;/CODE&gt;/&lt;CODE&gt;FC_MAIN&lt;/CODE&gt;
         instead of &lt;CODE&gt;main&lt;/CODE&gt;.
        </synopsis>
  </macro>
  <macro id="AC_F77_WRAPPERS">
      <prototype>
      </prototype>
      <prototype>
      </prototype>
        <synopsis>
               Defines C macros
         &lt;CODE&gt;F77_FUNC(name,NAME)&lt;/CODE&gt;/&lt;CODE&gt;FC_FUNC(name,NAME)&lt;/CODE&gt;
         and
         &lt;CODE&gt;F77_FUNC_(name,NAME)&lt;/CODE&gt;/&lt;CODE&gt;FC_FUNC_(name,NAME)&lt;/CODE&gt;
         to properly mangle the names of C/C++ identifiers, and
         identifiers with underscores, respectively, so that they match
         the name-mangling scheme used by the Fortran compiler.&lt;/P&gt;&lt;P&gt;

         Fortran is case-insensitive, and in order to achieve this the
         Fortran compiler converts all identifiers into a canonical case
         and format.  To call a Fortran subroutine from C or to write a C
         function that is callable from Fortran, the C program must
         explicitly use identifiers in the format expected by the Fortran
         compiler.  In order to do this, one simply wraps all C
         identifiers in one of the macros provided by
         &lt;CODE&gt;AC_F77_WRAPPERS&lt;/CODE&gt; or
         &lt;CODE&gt;AC_FC_WRAPPERS&lt;/CODE&gt;.  For example, suppose
         you have the following Fortran 77 subroutine:&lt;/P&gt;&lt;P&gt;

         &lt;TABLE&gt;&lt;tr&gt;&lt;td&gt;&amp;nbsp;&lt;/td&gt;&lt;td
         class=example&gt;&lt;pre&gt;       subroutine foobar(x,y)      
         double precision x, y       y = 3.14159 * x       return      
         end &lt;/pre&gt;&lt;/td&gt;&lt;/tr&gt;&lt;/table&gt;&lt;/P&gt;&lt;P&gt;

         You would then declare its prototype in C or C++ as:&lt;/P&gt;&lt;P&gt;

         &lt;TABLE&gt;&lt;tr&gt;&lt;td&gt;&amp;nbsp;&lt;/td&gt;&lt;td
         class=example&gt;&lt;pre&gt; #define FOOBAR_F77
         F77_FUNC(foobar,FOOBAR) #ifdef __cplusplus extern "C"  /*
         prevent C++ name mangling */ #endif void FOOBAR_F77(double *x,
         double *y); &lt;/pre&gt;&lt;/td&gt;&lt;/tr&gt;&lt;/table&gt;&lt;/P&gt;&lt;P&gt;

         Note that we pass both the lowercase and uppercase versions of
         the function name to &lt;CODE&gt;F77_FUNC&lt;/CODE&gt; so that
         it can select the right one. Note also that all parameters to
         Fortran 77 routines are passed as pointers (Mixing Fortran 77
         With C and C++,,, automake, GNU Automake).&lt;/P&gt;&lt;P&gt;

         (Replace &lt;CODE&gt;F77&lt;/CODE&gt; with
         &lt;CODE&gt;FC&lt;/CODE&gt; for Fortran instead of Fortran 77.)&lt;/P&gt;&lt;P&gt;

         Although Autoconf tries to be intelligent about detecting the
         name-mangling scheme of the Fortran compiler, there may be
         Fortran compilers that it doesn't support yet.  In this case,
         the above code will generate a compile-time error, but some
         other behavior (e.g., disabling Fortran-related features) can be
         induced by checking whether the
         &lt;CODE&gt;F77_FUNC&lt;/CODE&gt;/&lt;CODE&gt;FC_FUNC&lt;/CODE&gt;
         macro is defined.&lt;/P&gt;&lt;P&gt;

         Now, to call that routine from a C program, we would do
         something like:&lt;/P&gt;&lt;P&gt;

         &lt;TABLE&gt;&lt;tr&gt;&lt;td&gt;&amp;nbsp;&lt;/td&gt;&lt;td
         class=example&gt;&lt;pre&gt;      double x = 2.7183, y;    
         FOOBAR_F77(&amp;x, &amp;y); @
         &lt;/pre&gt;&lt;/td&gt;&lt;/tr&gt;&lt;/table&gt;&lt;/P&gt;&lt;P&gt;

         If the Fortran identifier contains an underscore (e.g.,
         &lt;CODE&gt;foo_bar&lt;/CODE&gt;), you should use
         &lt;CODE&gt;F77_FUNC_&lt;/CODE&gt;/&lt;CODE&gt;FC_FUNC_&lt;/CODE&gt;
         instead of
         &lt;CODE&gt;F77_FUNC&lt;/CODE&gt;/&lt;CODE&gt;FC_FUNC&lt;/CODE&gt;
         (with the same arguments).  This is because some Fortran
         compilers mangle names differently if they contain an
         underscore.
        </synopsis>
  </macro>
  <macro id="AC_F77_FUNC">
      <prototype>
        <parameter content="name"/>
        <parameter content="[shellvar]"/>
      </prototype>
      <prototype>
        <parameter content="name"/>
        <parameter content="[shellvar]"/>
      </prototype>
        <synopsis>
           Given an identifier &lt;VAR&gt;name&lt;/VAR&gt;, set the shell
         variable &lt;VAR&gt;shellvar&lt;/VAR&gt; to hold the mangled
         version &lt;VAR&gt;name&lt;/VAR&gt; according to the rules of
         the Fortran linker (see also
         &lt;CODE&gt;AC_F77_WRAPPERS&lt;/CODE&gt; or
         &lt;CODE&gt;AC_FC_WRAPPERS&lt;/CODE&gt;). 
         &lt;VAR&gt;shellvar&lt;/VAR&gt; is optional; if it is not
         supplied, the shell variable will be simply
         &lt;VAR&gt;name&lt;/VAR&gt;.  The purpose of this macro is to
         give the caller a way to access the name-mangling information
         other than through the C preprocessor as above, for example, to
         call Fortran routines from some language other than C/C++.
        </synopsis>
  </macro>
  <macro id="AC_FC_SRCEXT">
      <prototype>
        <parameter content="ext"/>
        <parameter content="[action-if-success]"/>
        <parameter content="[action-if-failure]"/>
      </prototype>
        <synopsis>
          By default, the &lt;CODE&gt;FC&lt;/CODE&gt; macros perform
         their tests using a &lt;TT&gt;.f&lt;/TT&gt; extension for
         source-code files.  Some compilers, however, only enable newer
         language features for appropriately named files, e.g. Fortran 90
         features only for &lt;TT&gt;.f90&lt;/TT&gt; files.  On the other
         hand, some other compilers expect all source files to end in
         &lt;TT&gt;.f&lt;/TT&gt; and require special flags to support
         other filename extensions.  The
         &lt;CODE&gt;AC_FC_SRCEXT&lt;/CODE&gt; macro deals with both of
         these issues.&lt;/P&gt;&lt;P&gt;

         The &lt;CODE&gt;AC_FC_SRCEXT&lt;/CODE&gt; tries to get the
         &lt;CODE&gt;FC&lt;/CODE&gt; compiler to accept files ending with
         the extension .&lt;VAR&gt;ext&lt;/VAR&gt; (i.e.
         &lt;VAR&gt;ext&lt;/VAR&gt; does &lt;EM&gt;not&lt;/EM&gt; contain
         the dot).  If any special compiler flags are needed for this, it
         stores them in the output variable
         &lt;CODE&gt;FCFLAGS_&lt;/CODE&gt;&lt;VAR&gt;ext&lt;/VAR&gt;. 
         This extension and these flags are then used for all subsequent
         &lt;CODE&gt;FC&lt;/CODE&gt; tests (until
         &lt;CODE&gt;AC_FC_SRCEXT&lt;/CODE&gt; is called again).&lt;/P&gt;&lt;P&gt;

         For example, you would use
         &lt;CODE&gt;AC_FC_SRCEXT(f90)&lt;/CODE&gt; to employ the
         &lt;TT&gt;.f90&lt;/TT&gt; extension in future tests, and it
         would set a &lt;CODE&gt;FCFLAGS_f90&lt;/CODE&gt; output variable
         with any extra flags that are needed to compile such files.&lt;/P&gt;&lt;P&gt;

         The &lt;CODE&gt;FCFLAGS_&lt;/CODE&gt;&lt;VAR&gt;ext&lt;/VAR&gt;
         can &lt;EM&gt;not&lt;/EM&gt; be simply absorbed into
         &lt;CODE&gt;FCFLAGS&lt;/CODE&gt;, for two reasons based on the
         limitations of some compilers.  First, only one
         &lt;CODE&gt;FCFLAGS_&lt;/CODE&gt;&lt;VAR&gt;ext&lt;/VAR&gt; can
         be used at a time, so files with different extensions must be
         compiled separately. Second,
         &lt;CODE&gt;FCFLAGS_&lt;/CODE&gt;&lt;VAR&gt;ext&lt;/VAR&gt; must
         appear &lt;EM&gt;immediately&lt;/EM&gt; before the source-code
         filename when compiling.  So, continuing the example above, you
         might compile a &lt;TT&gt;foo.f90&lt;/TT&gt; file in your
         Makefile with the command:&lt;/P&gt;&lt;P&gt;

         &lt;TABLE&gt;&lt;tr&gt;&lt;td&gt;&amp;nbsp;&lt;/td&gt;&lt;td
         class=example&gt;&lt;pre&gt; foo.o: foo.f90      $(FC) -c
         $(FCFLAGS) $(FCFLAGS_f90) foo.f90
         &lt;/pre&gt;&lt;/td&gt;&lt;/tr&gt;&lt;/table&gt;&lt;/P&gt;&lt;P&gt;

         If &lt;CODE&gt;AC_FC_SRCEXT&lt;/CODE&gt; succeeds in compiling
         files with the &lt;VAR&gt;ext&lt;/VAR&gt; extension, it calls
         action-if-success (defaults to nothing).  If it fails, and
         cannot find a way to make the &lt;CODE&gt;FC&lt;/CODE&gt;
         compiler accept such files, it calls action-if-failure (defaults
         to exiting with an error message).&lt;/P&gt;&lt;P&gt;

        </synopsis>
  </macro>
  <macro id="AC_FC_FREEFORM">
      <prototype>
        <parameter content="[action-if-success]"/>
        <parameter content="[action-if-failure]"/>
      </prototype>
        <synopsis>
         &lt;/P&gt;&lt;P&gt;

         The &lt;CODE&gt;AC_FC_FREEFORM&lt;/CODE&gt; tries to ensure that
         the Fortran compiler (&lt;CODE&gt;$FC&lt;/CODE&gt;) allows
         free-format source code (as opposed to the older fixed-format
         style from Fortran 77).  If necessary, it may add some
         additional flags to &lt;CODE&gt;FCFLAGS&lt;/CODE&gt;.&lt;/P&gt;&lt;P&gt;

         This macro is most important if you are using the default
         &lt;TT&gt;.f&lt;/TT&gt; extension, since many compilers
         interpret this extension as indicating fixed-format source
         unless an additional flag is supplied.  If you specify a
         different extension with &lt;CODE&gt;AC_FC_SRCEXT&lt;/CODE&gt;,
         such as &lt;TT&gt;.f90&lt;/TT&gt; or &lt;TT&gt;.f95&lt;/TT&gt;,
         then &lt;CODE&gt;AC_FC_FREEFORM&lt;/CODE&gt; will ordinarily
         succeed without modifying &lt;CODE&gt;FCFLAGS&lt;/CODE&gt;.&lt;/P&gt;&lt;P&gt;

         If &lt;CODE&gt;AC_FC_FREEFORM&lt;/CODE&gt; succeeds in compiling
         free-form source, it calls action-if-success (defaults to
         nothing). If it fails, it calls action-if-failure (defaults to
         exiting with an error message).
        </synopsis>
  </macro>
  <macro id="AC_PATH_X">
      <prototype>
      </prototype>
        <synopsis>
          Try to locate the X Window System include files and libraries. 
         If the user gave the command line options
         &lt;samp&gt;--x-includes=&lt;VAR&gt;dir&lt;/VAR&gt;&lt;/samp&gt;
         and
         &lt;samp&gt;--x-libraries=&lt;VAR&gt;dir&lt;/VAR&gt;&lt;/samp&gt;,
         use those directories.  If either or both were not given, get
         the missing values by running &lt;CODE&gt;xmkmf&lt;/CODE&gt; on
         a trivial &lt;TT&gt;Imakefile&lt;/TT&gt; and examining the
         &lt;TT&gt;Makefile&lt;/TT&gt; that it produces.  If that fails
         (such as if &lt;CODE&gt;xmkmf&lt;/CODE&gt; is not present), look
         for the files in several directories where they often reside. 
         If either method is successful, set the shell variables
         &lt;CODE&gt;x_includes&lt;/CODE&gt; and
         &lt;CODE&gt;x_libraries&lt;/CODE&gt; to their locations, unless
         they are in directories the compiler searches by default.&lt;/P&gt;&lt;P&gt;

         If both methods fail, or the user gave the command line option
         &lt;samp&gt;--without-x&lt;/samp&gt;, set the shell variable
         &lt;CODE&gt;no_x&lt;/CODE&gt; to &lt;samp&gt;yes&lt;/samp&gt;;
         otherwise set it to the empty string.
        </synopsis>
  </macro>
  <macro id="AC_PATH_XTRA">
      <prototype>
      </prototype>
        <synopsis>
               An enhanced version of &lt;CODE&gt;AC_PATH_X&lt;/CODE&gt;.
          It adds the C compiler flags that X needs to output variable
         &lt;CODE&gt;X_CFLAGS&lt;/CODE&gt;, and the X linker flags to
         &lt;CODE&gt;X_LIBS&lt;/CODE&gt;.  Define
         &lt;CODE&gt;X_DISPLAY_MISSING&lt;/CODE&gt; if X is not
         available.&lt;/P&gt;&lt;P&gt;

         This macro also checks for special libraries that some systems
         need in order to compile X programs.  It adds any that the
         system needs to output variable
         &lt;CODE&gt;X_EXTRA_LIBS&lt;/CODE&gt;.  And it checks for
         special X11R6 libraries that need to be linked with before
         &lt;samp&gt;-lX11&lt;/samp&gt;, and adds any found to the output
         variable &lt;CODE&gt;X_PRE_LIBS&lt;/CODE&gt;.&lt;/P&gt;&lt;P&gt;

        </synopsis>
  </macro>
  <macro id="AC_SYS_INTERPRETER">
      <prototype>
      </prototype>
        <synopsis>
          Check whether the system supports starting scripts with a line
         of the form &lt;samp&gt;#! /bin/csh&lt;/samp&gt; to select the
         interpreter to use for the script. After running this macro,
         shell code in &lt;TT&gt;configure.ac&lt;/TT&gt; can check the
         shell variable &lt;CODE&gt;interpval&lt;/CODE&gt;; it will be
         set to &lt;samp&gt;yes&lt;/samp&gt; if the system supports
         &lt;samp&gt;#!&lt;/samp&gt;, &lt;samp&gt;no&lt;/samp&gt; if not.
        </synopsis>
  </macro>
  <macro id="AC_SYS_LARGEFILE">
      <prototype>
      </prototype>
        <synopsis>
             Arrange for
         http://www.unix-systems.org/version2/whatsnew/lfs20mar.html,
         large-file support.  On some hosts, one must use special
         compiler options to build programs that can access large files. 
         Append any such options to the output variable
         &lt;CODE&gt;CC&lt;/CODE&gt;.  Define
         &lt;CODE&gt;_FILE_OFFSET_BITS&lt;/CODE&gt; and
         &lt;CODE&gt;_LARGE_FILES&lt;/CODE&gt; if necessary.&lt;/P&gt;&lt;P&gt;

         Large-file support can be disabled by configuring with the
         &lt;samp&gt;--disable-largefile&lt;/samp&gt; option.&lt;/P&gt;&lt;P&gt;

         If you use this macro, check that your program works even when
         &lt;CODE&gt;off_t&lt;/CODE&gt; is longer than
         &lt;CODE&gt;long&lt;/CODE&gt;, since this is common when
         large-file support is enabled.  For example, it is not correct
         to print an arbitrary &lt;CODE&gt;off_t&lt;/CODE&gt; value
         &lt;CODE&gt;X&lt;/CODE&gt; with &lt;CODE&gt;printf ("%ld",
         (long) X)&lt;/CODE&gt;.&lt;/P&gt;&lt;P&gt;

         The LFS introduced the &lt;CODE&gt;fseeko&lt;/CODE&gt; and
         &lt;CODE&gt;ftello&lt;/CODE&gt; functions to replace their C
         counterparts &lt;CODE&gt;fseek&lt;/CODE&gt; and
         &lt;CODE&gt;ftell&lt;/CODE&gt; that do not use
         &lt;CODE&gt;off_t&lt;/CODE&gt;. Take care to use
         &lt;CODE&gt;AC_FUNC_FSEEKO&lt;/CODE&gt; to make their prototypes
         available when using them and large-file support is enabled.
        </synopsis>
  </macro>
  <macro id="AC_SYS_LONG_FILE_NAMES">
      <prototype>
      </prototype>
        <synopsis>
           If the system supports file names longer than 14 characters,
         define &lt;CODE&gt;HAVE_LONG_FILE_NAMES&lt;/CODE&gt;.
        </synopsis>
  </macro>
  <macro id="AC_SYS_POSIX_TERMIOS">
      <prototype>
      </prototype>
        <synopsis>
           termios headers  POSIX headers Check to see if the POSIX
         termios headers and functions are available on the system.  If
         so, set the shell variable
         &lt;CODE&gt;ac_cv_sys_posix_termios&lt;/CODE&gt; to
         &lt;samp&gt;yes&lt;/samp&gt;.  If not, set the variable to
         &lt;samp&gt;no&lt;/samp&gt;.
        </synopsis>
  </macro>
  <macro id="AC_AIX">
      <prototype>
      </prototype>
        <synopsis>
           If on AIX, define &lt;CODE&gt;_ALL_SOURCE&lt;/CODE&gt;. 
         Allows the use of some BSD functions.  Should be called before
         any macros that run the C compiler.
        </synopsis>
  </macro>
  <macro id="AC_GNU_SOURCE">
      <prototype>
      </prototype>
        <synopsis>
           If using the GNU C library, define
         &lt;CODE&gt;_GNU_SOURCE&lt;/CODE&gt;. Allows the use of some GNU
         functions.  Should be called before any macros that run the C
         compiler.
        </synopsis>
  </macro>
  <macro id="AC_ISC_POSIX">
      <prototype>
      </prototype>
        <synopsis>
           For interactive unix (ISC), add
         &lt;samp&gt;-lcposix&lt;/samp&gt; to output variable
         &lt;CODE&gt;LIBS&lt;/CODE&gt; if necessary for POSIX facilities.
          Call this after &lt;CODE&gt;AC_PROG_CC&lt;/CODE&gt; and before
         any other macros that use POSIX interfaces.  interactive unix is
         no longer sold, and Sun says that they will drop support for it
         on 2006-07-23, so this macro is becoming obsolescent.
        </synopsis>
  </macro>
  <macro id="AC_MINIX">
      <prototype>
      </prototype>
        <synopsis>
             If on Minix, define &lt;CODE&gt;_MINIX&lt;/CODE&gt; and
         &lt;CODE&gt;_POSIX_SOURCE&lt;/CODE&gt; and define
         &lt;CODE&gt;_POSIX_1_SOURCE&lt;/CODE&gt; to be 2.  This allows
         the use of POSIX facilities.  Should be called before any macros
         that run the C compiler.
        </synopsis>
  </macro>
  <macro id="AC_LANG">
      <prototype>
        <parameter content="language"/>
      </prototype>
        <synopsis>
         Do compilation tests using the compiler, preprocessor, and file
         extensions for the specified &lt;VAR&gt;language&lt;/VAR&gt;.&lt;/P&gt;&lt;P&gt;

         Supported languages are:&lt;/P&gt;&lt;P&gt;

         &lt;DL&gt;  &lt;DT&gt;'&lt;SAMP&gt;C&lt;/SAMP&gt;' &lt;DD&gt; Do
         compilation tests using &lt;CODE&gt;CC&lt;/CODE&gt; and
         &lt;CODE&gt;CPP&lt;/CODE&gt; and use extension
         &lt;TT&gt;.c&lt;/TT&gt; for test programs.  Use compilation
         flags: &lt;CODE&gt;CPPFLAGS&lt;/CODE&gt; with
         &lt;CODE&gt;CPP&lt;/CODE&gt;, and both
         &lt;CODE&gt;CPPFLAGS&lt;/CODE&gt; and
         &lt;CODE&gt;CFLAGS&lt;/CODE&gt; with
         &lt;CODE&gt;CC&lt;/CODE&gt;.&lt;/P&gt;&lt;P&gt;

         &lt;DT&gt;'&lt;SAMP&gt;C++&lt;/SAMP&gt;' &lt;DD&gt; Do
         compilation tests using &lt;CODE&gt;CXX&lt;/CODE&gt; and
         &lt;CODE&gt;CXXCPP&lt;/CODE&gt; and use extension
         &lt;TT&gt;.C&lt;/TT&gt; for test programs.  Use compilation
         flags: &lt;CODE&gt;CPPFLAGS&lt;/CODE&gt; with
         &lt;CODE&gt;CXXPP&lt;/CODE&gt;, and both
         &lt;CODE&gt;CPPFLAGS&lt;/CODE&gt; and
         &lt;CODE&gt;CXXFLAGS&lt;/CODE&gt; with
         &lt;CODE&gt;CXX&lt;/CODE&gt;.&lt;/P&gt;&lt;P&gt;

         &lt;DT&gt;'&lt;SAMP&gt;Fortran 77&lt;/SAMP&gt;' &lt;DD&gt; Do
         compilation tests using &lt;CODE&gt;F77&lt;/CODE&gt; and use
         extension &lt;TT&gt;.f&lt;/TT&gt; for test programs.  Use
         compilation flags: &lt;CODE&gt;FFLAGS&lt;/CODE&gt;.&lt;/P&gt;&lt;P&gt;

         &lt;DT&gt;'&lt;SAMP&gt;Fortran&lt;/SAMP&gt;' &lt;DD&gt; Do
         compilation tests using &lt;CODE&gt;FC&lt;/CODE&gt; and use
         extension &lt;TT&gt;.f&lt;/TT&gt; (or whatever has been set by
         &lt;CODE&gt;AC_FC_SRCEXT&lt;/CODE&gt;) for test programs.  Use
         compilation flags: &lt;CODE&gt;FCFLAGS&lt;/CODE&gt;. &lt;/DL&gt;
        </synopsis>
  </macro>
  <macro id="AC_LANG_PUSH">
      <prototype>
        <parameter content="language"/>
      </prototype>
        <synopsis>
          Remember the current language (as set by
         &lt;CODE&gt;AC_LANG&lt;/CODE&gt;) on a stack, and then select
         the &lt;VAR&gt;language&lt;/VAR&gt;.  Use this macro and
         &lt;CODE&gt;AC_LANG_POP&lt;/CODE&gt; in macros that need to
         temporarily switch to a particular language.
        </synopsis>
  </macro>
  <macro id="AC_LANG_POP">
      <prototype>
        <parameter content="[language]"/>
      </prototype>
        <synopsis>
          Select the language that is saved on the top of the stack, as
         set by &lt;CODE&gt;AC_LANG_PUSH&lt;/CODE&gt;, and remove it from
         the stack.&lt;/P&gt;&lt;P&gt;

         If given, &lt;VAR&gt;language&lt;/VAR&gt; specifies the language
         we just &lt;EM&gt;quit&lt;/EM&gt;.  It is a good idea to specify
         it when it's known (which should be the
         case&lt;small&gt;...&lt;/small&gt;), since Autoconf will detect
         inconsistencies.&lt;/P&gt;&lt;P&gt;

         &lt;TABLE&gt;&lt;tr&gt;&lt;td&gt;&amp;nbsp;&lt;/td&gt;&lt;td
         class=example&gt;&lt;pre&gt; AC_LANG_PUSH(Fortran 77) # Perform
         some tests on Fortran 77. # &lt;small&gt;...&lt;/small&gt;
         AC_LANG_POP(Fortran 77)
         &lt;/pre&gt;&lt;/td&gt;&lt;/tr&gt;&lt;/table&gt;
        </synopsis>
  </macro>
  <macro id="AC_LANG_ASSERT">
      <prototype>
        <parameter content="language"/>
      </prototype>
        <synopsis>
          Check statically that the current language is
         &lt;VAR&gt;language&lt;/VAR&gt;.  You should use this in your
         language specific macros to avoid that they be called with an
         inappropriate language.&lt;/P&gt;&lt;P&gt;

         This macro runs only at &lt;CODE&gt;autoconf&lt;/CODE&gt; time,
         and incurs no cost at &lt;CODE&gt;configure&lt;/CODE&gt; time. 
         Sadly enough and because Autoconf is a two layer language
         Because M4 is not aware of Sh code, especially conditionals,
         some optimizations that look nice statically may produce
         incorrect results at runtime., the macros
         &lt;CODE&gt;AC_LANG_PUSH&lt;/CODE&gt;/&lt;CODE&gt;AC_LANG_POP&lt;/CODE&gt;
         cannot be ``optimizing'', therefore as much as possible you
         ought to avoid using them to wrap your code, rather, require
         from the user to run the macro with a correct current language,
         and check it with &lt;CODE&gt;AC_LANG_ASSERT&lt;/CODE&gt;. And
         anyway, that may help the user understand she is running a
         Fortran macro while expecting a result about her Fortran 77
         compiler...
        </synopsis>
  </macro>
  <macro id="AC_REQUIRE_CPP">
      <prototype>
      </prototype>
        <synopsis>
          Ensure that whichever preprocessor would currently be used for
         tests has been found.  Calls &lt;CODE&gt;AC_REQUIRE&lt;/CODE&gt;
         (Prerequisite Macros) with an argument of either
         &lt;CODE&gt;AC_PROG_CPP&lt;/CODE&gt; or
         &lt;CODE&gt;AC_PROG_CXXCPP&lt;/CODE&gt;, depending on which
         language is current.
        </synopsis>
  </macro>
  <macro id="AC_LANG_CONFTEST">
      <prototype>
        <parameter content="source"/>
      </prototype>
        <synopsis>
          Save the &lt;VAR&gt;source&lt;/VAR&gt; text in the current test
         source file:
         &lt;TT&gt;conftest.&lt;VAR&gt;extension&lt;/VAR&gt;&lt;/TT&gt;
         where the &lt;VAR&gt;extension&lt;/VAR&gt; depends on the
         current language.&lt;/P&gt;&lt;P&gt;

         Note that the &lt;VAR&gt;source&lt;/VAR&gt; is evaluated exactly
         once, like regular Autoconf macro arguments, and therefore (i)
         you may pass a macro invocation, (ii) if not, be sure to double
         quote if needed.
        </synopsis>
  </macro>
  <macro id="AC_LANG_SOURCE">
      <prototype>
        <parameter content="source"/>
      </prototype>
        <synopsis>
          Expands into the &lt;VAR&gt;source&lt;/VAR&gt;, with the
         definition of all the &lt;CODE&gt;AC_DEFINE&lt;/CODE&gt;
         performed so far.
        </synopsis>
  </macro>
  <macro id="AC_LANG_PROGRAM">
      <prototype>
        <parameter content="prologue"/>
        <parameter content="body"/>
      </prototype>
        <synopsis>
          Expands into a source file which consists of the
         &lt;VAR&gt;prologue&lt;/VAR&gt;, and then
         &lt;VAR&gt;body&lt;/VAR&gt; as body of the main function (e.g.,
         &lt;CODE&gt;main&lt;/CODE&gt; in C).  Since it uses
         &lt;CODE&gt;AC_LANG_SOURCE&lt;/CODE&gt;, the feature of the
         latter are available.
        </synopsis>
  </macro>
  <macro id="AC_LANG_CALL">
      <prototype>
        <parameter content="prologue"/>
        <parameter content="function"/>
      </prototype>
        <synopsis>
          Expands into a source file which consists of the
         &lt;VAR&gt;prologue&lt;/VAR&gt;, and then a call to the
         &lt;VAR&gt;function&lt;/VAR&gt; as body of the main function
         (e.g., &lt;CODE&gt;main&lt;/CODE&gt; in C).  Since it uses
         &lt;CODE&gt;AC_LANG_PROGRAMS&lt;/CODE&gt;, the feature of the
         latter are available.&lt;/P&gt;&lt;P&gt;

         This function will probably be replaced in the future by a
         version which would enable specifying the arguments.  The use of
         this macro is not encouraged, as it violates strongly the typing
         system.
        </synopsis>
  </macro>
  <macro id="AC_LANG_FUNC_LINK_TRY">
      <prototype>
        <parameter content="function"/>
      </prototype>
        <synopsis>
          Expands into a source file which consists of a pseudo use of
         the &lt;VAR&gt;function&lt;/VAR&gt; as body of the main function
         (e.g., &lt;CODE&gt;main&lt;/CODE&gt; in C): a simple (function
         pointer) assignment.  Since it uses
         &lt;CODE&gt;AC_LANG_PROGRAMS&lt;/CODE&gt;, the feature of the
         latter are available.&lt;/P&gt;&lt;P&gt;

         As &lt;CODE&gt;AC_LANG_CALL&lt;/CODE&gt;, this macro is
         documented only for completeness. It is considered to be
         severely broken, and in the future will be removed in favor of
         actual function calls (with properly typed arguments).
        </synopsis>
  </macro>
  <macro id="AC_PREPROC_IFELSE">
      <prototype>
        <parameter content="input"/>
        <parameter content="[action-if-true]"/>
        <parameter content="[action-if-false]"/>
      </prototype>
        <synopsis>
          Run the preprocessor of the current language (Language Choice)
         on the &lt;VAR&gt;input&lt;/VAR&gt;, run the shell commands
         &lt;VAR&gt;action-if-true&lt;/VAR&gt; on success,
         &lt;VAR&gt;action-if-false&lt;/VAR&gt; otherwise.  The
         &lt;VAR&gt;input&lt;/VAR&gt; can be made by
         &lt;CODE&gt;AC_LANG_PROGRAM&lt;/CODE&gt; and friends.&lt;/P&gt;&lt;P&gt;

         This macro uses &lt;CODE&gt;CPPFLAGS&lt;/CODE&gt;, but not
         &lt;CODE&gt;CFLAGS&lt;/CODE&gt;, because
         &lt;samp&gt;-g&lt;/samp&gt;, &lt;samp&gt;-O&lt;/samp&gt;, etc.@:
         are not valid options to many C preprocessors.&lt;/P&gt;&lt;P&gt;

         It is customary to report unexpected failures with
         &lt;CODE&gt;AC_MSG_FAILURE&lt;/CODE&gt;.
        </synopsis>
  </macro>
  <macro id="AC_EGREP_HEADER">
      <prototype>
        <parameter content="pattern"/>
        <parameter content="header-file"/>
        <parameter content="action-if-found"/>
        <parameter content="[action-if-not-found]"/>
      </prototype>
        <synopsis>
          If the output of running the preprocessor on the system header
         file &lt;VAR&gt;header-file&lt;/VAR&gt; matches the extended
         regular expression &lt;VAR&gt;pattern&lt;/VAR&gt;, execute shell
         commands &lt;VAR&gt;action-if-found&lt;/VAR&gt;, otherwise
         execute &lt;VAR&gt;action-if-not-found&lt;/VAR&gt;.
        </synopsis>
  </macro>
  <macro id="AC_EGREP_CPP">
      <prototype>
        <parameter content="pattern"/>
        <parameter content="program"/>
        <parameter content="[action-if-found]"/>
        <parameter content="[action-if-not-found]"/>
      </prototype>
        <synopsis>
          &lt;VAR&gt;program&lt;/VAR&gt; is the text of a C or C++
         program, on which shell variable, back quote, and backslash
         substitutions are performed.  If the output of running the
         preprocessor on &lt;VAR&gt;program&lt;/VAR&gt; matches the
         extended regular expression &lt;VAR&gt;pattern&lt;/VAR&gt;,
         execute shell commands &lt;VAR&gt;action-if-found&lt;/VAR&gt;,
         otherwise execute &lt;VAR&gt;action-if-not-found&lt;/VAR&gt;.
        </synopsis>
  </macro>
  <macro id="AC_COMPILE_IFELSE">
      <prototype>
        <parameter content="input"/>
        <parameter content="[action-if-found]"/>
        <parameter content="[action-if-not-found]"/>
      </prototype>
        <synopsis>
          Run the compiler and compilation flags of the current language
         (Language Choice) on the &lt;VAR&gt;input&lt;/VAR&gt;, run the
         shell commands &lt;VAR&gt;action-if-true&lt;/VAR&gt; on success,
         &lt;VAR&gt;action-if-false&lt;/VAR&gt; otherwise.  The
         &lt;VAR&gt;input&lt;/VAR&gt; can be made by
         &lt;CODE&gt;AC_LANG_PROGRAM&lt;/CODE&gt; and friends.&lt;/P&gt;&lt;P&gt;

         It is customary to report unexpected failures with
         &lt;CODE&gt;AC_MSG_FAILURE&lt;/CODE&gt;.  This macro does not
         try to link; use &lt;CODE&gt;AC_LINK_IFELSE&lt;/CODE&gt; if you
         need to do that (Running the Linker).
        </synopsis>
  </macro>
  <macro id="AC_LINK_IFELSE">
      <prototype>
        <parameter content="input"/>
        <parameter content="[action-if-found]"/>
        <parameter content="[action-if-not-found]"/>
      </prototype>
        <synopsis>
          Run the compiler (and compilation flags) and the linker of the
         current language (Language Choice) on the
         &lt;VAR&gt;input&lt;/VAR&gt;, run the shell commands
         &lt;VAR&gt;action-if-true&lt;/VAR&gt; on success,
         &lt;VAR&gt;action-if-false&lt;/VAR&gt; otherwise.  The
         &lt;VAR&gt;input&lt;/VAR&gt; can be made by
         &lt;CODE&gt;AC_LANG_PROGRAM&lt;/CODE&gt; and friends.&lt;/P&gt;&lt;P&gt;

         &lt;CODE&gt;LDFLAGS&lt;/CODE&gt; and
         &lt;CODE&gt;LIBS&lt;/CODE&gt; are used for linking, in addition
         to the current compilation flags.&lt;/P&gt;&lt;P&gt;

         It is customary to report unexpected failures with
         &lt;CODE&gt;AC_MSG_FAILURE&lt;/CODE&gt;.  This macro does not
         try to execute the program; use
         &lt;CODE&gt;AC_RUN_IFELSE&lt;/CODE&gt; if you need to do that
         (Run Time).
        </synopsis>
  </macro>
  <macro id="AC_RUN_IFELSE">
      <prototype>
        <parameter content="input"/>
        <parameter content="[action-if-found]"/>
        <parameter content="[action-if-not-found]"/>
        <parameter content="[action-if-cross-compiling]"/>
      </prototype>
        <synopsis>
          If &lt;VAR&gt;program&lt;/VAR&gt; compiles and links
         successfully and returns an exit status of 0 when executed, run
         shell commands &lt;VAR&gt;action-if-true&lt;/VAR&gt;. Otherwise,
         run shell commands &lt;VAR&gt;action-if-false&lt;/VAR&gt;.&lt;/P&gt;&lt;P&gt;

         The &lt;VAR&gt;input&lt;/VAR&gt; can be made by
         &lt;CODE&gt;AC_LANG_PROGRAM&lt;/CODE&gt; and friends.
         &lt;CODE&gt;LDFLAGS&lt;/CODE&gt; and
         &lt;CODE&gt;LIBS&lt;/CODE&gt; are used for linking, in addition
         to the compilation flags of the current language (Language
         Choice).&lt;/P&gt;&lt;P&gt;

         If the compiler being used does not produce executables that run
         on the system where &lt;CODE&gt;configure&lt;/CODE&gt; is being
         run, then the test program is not run.  If the optional shell
         commands &lt;VAR&gt;action-if-cross-compiling&lt;/VAR&gt; are
         given, they are run instead.  Otherwise,
         &lt;CODE&gt;configure&lt;/CODE&gt; prints an error message and
         exits.&lt;/P&gt;&lt;P&gt;

         In the &lt;VAR&gt;action-if-false&lt;/VAR&gt; section, the exit
         status of the program is available in the shell variable
         &lt;samp&gt;$?&lt;/samp&gt;, but be very careful to limit
         yourself to positive values smaller than 127; bigger values
         should be saved into a file by the
         &lt;VAR&gt;program&lt;/VAR&gt;.  Note also that you have simply
         no guarantee that this exit status is issued by the
         &lt;VAR&gt;program&lt;/VAR&gt;, or by the failure of its
         compilation.  In other words, use this feature if sadist only,
         it was reestablished because the Autoconf maintainers grew tired
         of receiving ``bug reports''.&lt;/P&gt;&lt;P&gt;

         It is customary to report unexpected failures with
         &lt;CODE&gt;AC_MSG_FAILURE&lt;/CODE&gt;.
        </synopsis>
  </macro>
  <macro id="AC_DEFINE">
      <prototype>
        <parameter content="variable"/>
        <parameter content="value"/>
        <parameter content="[description]"/>
      </prototype>
      <prototype>
        <parameter content="variable"/>
      </prototype>
        <synopsis>
          Define the C preprocessor variable
         &lt;VAR&gt;variable&lt;/VAR&gt; to &lt;VAR&gt;value&lt;/VAR&gt;
         (verbatim). &lt;VAR&gt;value&lt;/VAR&gt; should not contain
         literal newlines, and if you are not using
         &lt;CODE&gt;AC_CONFIG_HEADERS&lt;/CODE&gt; it should not contain
         any &lt;samp&gt;#&lt;/samp&gt; characters, as
         &lt;CODE&gt;make&lt;/CODE&gt; tends to eat them.  To use a shell
         variable (which you need to do in order to define a value
         containing the M4 quote characters &lt;samp&gt;[&lt;/samp&gt; or
         &lt;samp&gt;]&lt;/samp&gt;), use
         &lt;CODE&gt;AC_DEFINE_UNQUOTED&lt;/CODE&gt; instead.
         &lt;VAR&gt;description&lt;/VAR&gt; is only useful if you are
         using &lt;CODE&gt;AC_CONFIG_HEADERS&lt;/CODE&gt;.  In this case,
         &lt;VAR&gt;description&lt;/VAR&gt; is put into the generated
         &lt;TT&gt;config.h.in&lt;/TT&gt; as the comment before the macro
         define. The following example defines the C preprocessor
         variable &lt;CODE&gt;EQUATION&lt;/CODE&gt; to be the string
         constant &lt;samp&gt;"$a &gt; $b"&lt;/samp&gt;:&lt;/P&gt;&lt;P&gt;

         &lt;TABLE&gt;&lt;tr&gt;&lt;td&gt;&amp;nbsp;&lt;/td&gt;&lt;td
         class=example&gt;&lt;pre&gt; AC_DEFINE(EQUATION, "$a &gt; $b")
         &lt;/pre&gt;&lt;/td&gt;&lt;/tr&gt;&lt;/table&gt;&lt;/P&gt;&lt;P&gt;

         If neither &lt;VAR&gt;value&lt;/VAR&gt; nor
         &lt;VAR&gt;description&lt;/VAR&gt; are given, then
         &lt;VAR&gt;value&lt;/VAR&gt; defaults to 1 instead of to the
         empty string.  This is for backwards compatibility with older
         versions of Autoconf, but this usage is obsolescent and may be
         withdrawn in future versions of Autoconf.
        </synopsis>
  </macro>
  <macro id="AC_DEFINE_UNQUOTED">
      <prototype>
        <parameter content="variable"/>
        <parameter content="value"/>
        <parameter content="[description]"/>
      </prototype>
      <prototype>
        <parameter content="variable"/>
      </prototype>
        <synopsis>
          Like &lt;CODE&gt;AC_DEFINE&lt;/CODE&gt;, but three shell
         expansions are performed---once---on
         &lt;VAR&gt;variable&lt;/VAR&gt; and
         &lt;VAR&gt;value&lt;/VAR&gt;: variable expansion
         (&lt;samp&gt;$&lt;/samp&gt;), command substitution
         (&lt;samp&gt;`&lt;/samp&gt;), and backslash escaping
         (&lt;samp&gt;\&lt;/samp&gt;).  Single and double quote
         characters in the value have no special meaning.  Use this macro
         instead of &lt;CODE&gt;AC_DEFINE&lt;/CODE&gt; when
         &lt;VAR&gt;variable&lt;/VAR&gt; or &lt;VAR&gt;value&lt;/VAR&gt;
         is a shell variable.  Examples:&lt;/P&gt;&lt;P&gt;

         &lt;TABLE&gt;&lt;tr&gt;&lt;td&gt;&amp;nbsp;&lt;/td&gt;&lt;td
         class=example&gt;&lt;pre&gt; AC_DEFINE_UNQUOTED(config_machfile,
         "$machfile") AC_DEFINE_UNQUOTED(GETGROUPS_T,
         $ac_cv_type_getgroups) AC_DEFINE_UNQUOTED($ac_tr_hdr)
         &lt;/pre&gt;&lt;/td&gt;&lt;/tr&gt;&lt;/table&gt;
        </synopsis>
  </macro>
  <macro id="AC_SUBST">
      <prototype>
        <parameter content="variable"/>
        <parameter content="[value]"/>
      </prototype>
        <synopsis>
          Create an output variable from a shell variable.  Make
         &lt;CODE&gt;AC_OUTPUT&lt;/CODE&gt; substitute the variable
         &lt;VAR&gt;variable&lt;/VAR&gt; into output files (typically one
         or more &lt;TT&gt;Makefile&lt;/TT&gt;s).  This means that
         &lt;CODE&gt;AC_OUTPUT&lt;/CODE&gt; will replace instances of
         &lt;samp&gt;@@&lt;VAR&gt;variable&lt;/VAR&gt;@@&lt;/samp&gt; in
         input files with the value that the shell variable
         &lt;VAR&gt;variable&lt;/VAR&gt; has when
         &lt;CODE&gt;AC_OUTPUT&lt;/CODE&gt; is called.  This value of
         &lt;VAR&gt;variable&lt;/VAR&gt; should not contain literal
         newlines.&lt;/P&gt;&lt;P&gt;

         If &lt;VAR&gt;value&lt;/VAR&gt; is given, in addition assign it
         to &lt;VAR&gt;variable&lt;/VAR&gt;.
        </synopsis>
  </macro>
  <macro id="AC_SUBST_FILE">
      <prototype>
        <parameter content="variable"/>
      </prototype>
        <synopsis>
          Another way to create an output variable from a shell variable.
          Make &lt;CODE&gt;AC_OUTPUT&lt;/CODE&gt; insert (without
         substitutions) the contents of the file named by shell variable
         &lt;VAR&gt;variable&lt;/VAR&gt; into output files.  This means
         that &lt;CODE&gt;AC_OUTPUT&lt;/CODE&gt; will replace instances
         of &lt;samp&gt;@@&lt;VAR&gt;variable&lt;/VAR&gt;@@&lt;/samp&gt;
         in output files (such as &lt;TT&gt;Makefile.in&lt;/TT&gt;) with
         the contents of the file that the shell variable
         &lt;VAR&gt;variable&lt;/VAR&gt; names when
         &lt;CODE&gt;AC_OUTPUT&lt;/CODE&gt; is called.  Set the variable
         to &lt;TT&gt;/dev/null&lt;/TT&gt; for cases that do not have a
         file to insert.&lt;/P&gt;&lt;P&gt;

         This macro is useful for inserting &lt;TT&gt;Makefile&lt;/TT&gt;
         fragments containing special dependencies or other
         &lt;CODE&gt;make&lt;/CODE&gt; directives for particular host or
         target types into &lt;TT&gt;Makefile&lt;/TT&gt;s.  For example,
         &lt;TT&gt;configure.ac&lt;/TT&gt; could contain:&lt;/P&gt;&lt;P&gt;

         &lt;TABLE&gt;&lt;tr&gt;&lt;td&gt;&amp;nbsp;&lt;/td&gt;&lt;td
         class=example&gt;&lt;pre&gt; AC_SUBST_FILE(host_frag)
         host_frag=$srcdir/conf/sun4.mh
         &lt;/pre&gt;&lt;/td&gt;&lt;/tr&gt;&lt;/table&gt;&lt;/P&gt;&lt;P&gt;

          and then a &lt;TT&gt;Makefile.in&lt;/TT&gt; could contain:&lt;/P&gt;&lt;P&gt;

         &lt;TABLE&gt;&lt;tr&gt;&lt;td&gt;&amp;nbsp;&lt;/td&gt;&lt;td
         class=example&gt;&lt;pre&gt; @@host_frag@@
         &lt;/pre&gt;&lt;/td&gt;&lt;/tr&gt;&lt;/table&gt;
        </synopsis>
  </macro>
  <macro id="AC_ARG_VAR">
      <prototype>
        <parameter content="variable"/>
        <parameter content="description"/>
      </prototype>
        <synopsis>
          Declare &lt;VAR&gt;variable&lt;/VAR&gt; is a precious variable,
         and include its &lt;VAR&gt;description&lt;/VAR&gt; in the
         variable section of &lt;samp&gt;./configure --help&lt;/samp&gt;.&lt;/P&gt;&lt;P&gt;

         Being precious means that &lt;UL&gt; &lt;LI&gt;
         &lt;VAR&gt;variable&lt;/VAR&gt; is
         &lt;CODE&gt;AC_SUBST&lt;/CODE&gt;'d.&lt;/P&gt;&lt;P&gt;

         &lt;LI&gt; The value of &lt;VAR&gt;variable&lt;/VAR&gt; when
         &lt;CODE&gt;configure&lt;/CODE&gt; was launched is saved in the
         cache, including if it was not specified on the command line but
         via the environment.  Indeed, while
         &lt;CODE&gt;configure&lt;/CODE&gt; can notice the definition of
         &lt;CODE&gt;CC&lt;/CODE&gt; in &lt;samp&gt;./configure
         CC=bizarre-cc&lt;/samp&gt;, it is impossible to notice it in
         &lt;samp&gt;CC=bizarre-cc ./configure&lt;/samp&gt;, which,
         unfortunately, is what most users do.&lt;/P&gt;&lt;P&gt;

         We emphasize that it is the &lt;EM&gt;initial&lt;/EM&gt; value
         of &lt;VAR&gt;variable&lt;/VAR&gt; which is saved, not that
         found during the execution of
         &lt;CODE&gt;configure&lt;/CODE&gt;. Indeed, specifying
         &lt;samp&gt;./configure FOO=foo&lt;/samp&gt; and letting
         &lt;samp&gt;./configure&lt;/samp&gt; guess that
         &lt;CODE&gt;FOO&lt;/CODE&gt; is &lt;CODE&gt;foo&lt;/CODE&gt; can
         be two very different runs.&lt;/P&gt;&lt;P&gt;

         &lt;LI&gt; &lt;VAR&gt;variable&lt;/VAR&gt; is checked for
         consistency between two &lt;CODE&gt;configure&lt;/CODE&gt; runs.
          For instance:&lt;/P&gt;&lt;P&gt;

         &lt;TABLE&gt;&lt;tr&gt;&lt;td&gt;&amp;nbsp;&lt;/td&gt;&lt;td
         class=example&gt;&lt;pre&gt; $ &lt;KBD&gt;./configure --silent
         --config-cache&lt;/KBD&gt; $ &lt;KBD&gt;CC=cc ./configure
         --silent --config-cache&lt;/KBD&gt; configure: error: `CC' was
         not set in the previous run configure: error: changes in the
         environment can compromise \ the build configure: error: run
         `make distclean' and/or \ `rm config.cache' and start over
         &lt;/pre&gt;&lt;/td&gt;&lt;/tr&gt;&lt;/table&gt;&lt;/P&gt;&lt;P&gt;

          and similarly if the variable is unset, or if its content is
         changed.&lt;/P&gt;&lt;P&gt;

        &lt;/P&gt;&lt;P&gt;

         &lt;LI&gt; &lt;VAR&gt;variable&lt;/VAR&gt; is kept during
         automatic reconfiguration (config.status Invocation) as if it
         had been passed as a command line argument, including when no
         cache is used:&lt;/P&gt;&lt;P&gt;

         &lt;TABLE&gt;&lt;tr&gt;&lt;td&gt;&amp;nbsp;&lt;/td&gt;&lt;td
         class=example&gt;&lt;pre&gt; $ &lt;KBD&gt;CC=/usr/bin/cc
         ./configure undeclared_var=raboof --silent&lt;/KBD&gt; $
         &lt;KBD&gt;./config.status --recheck&lt;/KBD&gt; running /bin/sh
         ./configure undeclared_var=raboof --silent \   CC=/usr/bin/cc 
         --no-create --no-recursion
         &lt;/pre&gt;&lt;/td&gt;&lt;/tr&gt;&lt;/table&gt; &lt;/UL&gt;
        </synopsis>
  </macro>
  <macro id="AC_CACHE_VAL">
      <prototype>
        <parameter content="cache-id"/>
        <parameter content="commands-to-set-it"/>
      </prototype>
        <synopsis>
          Ensure that the results of the check identified by
         &lt;VAR&gt;cache-id&lt;/VAR&gt; are available.  If the results
         of the check were in the cache file that was read, and
         &lt;CODE&gt;configure&lt;/CODE&gt; was not given the
         &lt;samp&gt;--quiet&lt;/samp&gt; or
         &lt;samp&gt;--silent&lt;/samp&gt; option, print a message saying
         that the result was cached; otherwise, run the shell commands
         &lt;VAR&gt;commands-to-set-it&lt;/VAR&gt;.  If the shell
         commands are run to determine the value, the value will be saved
         in the cache file just before &lt;CODE&gt;configure&lt;/CODE&gt;
         creates its output files.  , for how to choose the name of the
         &lt;VAR&gt;cache-id&lt;/VAR&gt; variable.&lt;/P&gt;&lt;P&gt;

         The &lt;VAR&gt;commands-to-set-it&lt;/VAR&gt; &lt;EM&gt;must
         have no side effects&lt;/EM&gt; except for setting the variable
         &lt;VAR&gt;cache-id&lt;/VAR&gt;, see below.
        </synopsis>
  </macro>
  <macro id="AC_CACHE_CHECK">
      <prototype>
        <parameter content="message"/>
        <parameter content="cache-id"/>
        <parameter content="commands-to-set-it"/>
      </prototype>
        <synopsis>
          A wrapper for &lt;CODE&gt;AC_CACHE_VAL&lt;/CODE&gt; that takes
         care of printing the messages.  This macro provides a convenient
         shorthand for the most common way to use these macros.  It calls
         &lt;CODE&gt;AC_MSG_CHECKING&lt;/CODE&gt; for
         &lt;VAR&gt;message&lt;/VAR&gt;, then
         &lt;CODE&gt;AC_CACHE_VAL&lt;/CODE&gt; with the
         &lt;VAR&gt;cache-id&lt;/VAR&gt; and
         &lt;VAR&gt;commands&lt;/VAR&gt; arguments, and
         &lt;CODE&gt;AC_MSG_RESULT&lt;/CODE&gt; with
         &lt;VAR&gt;cache-id&lt;/VAR&gt;.&lt;/P&gt;&lt;P&gt;

         The &lt;VAR&gt;commands-to-set-it&lt;/VAR&gt; &lt;EM&gt;must
         have no side effects&lt;/EM&gt; except for setting the variable
         &lt;VAR&gt;cache-id&lt;/VAR&gt;, see below.
        </synopsis>
  </macro>
  <macro id="AC_CACHE_LOAD">
      <prototype>
      </prototype>
        <synopsis>
          Loads values from existing cache file, or creates a new cache
         file if a cache file is not found.  Called automatically from
         &lt;CODE&gt;AC_INIT&lt;/CODE&gt;.
        </synopsis>
  </macro>
  <macro id="AC_CACHE_SAVE">
      <prototype>
      </prototype>
        <synopsis>
          Flushes all cached values to the cache file.  Called
         automatically from &lt;CODE&gt;AC_OUTPUT&lt;/CODE&gt;, but it
         can be quite useful to call
         &lt;CODE&gt;AC_CACHE_SAVE&lt;/CODE&gt; at key points in
         &lt;TT&gt;configure.ac&lt;/TT&gt;.
        </synopsis>
  </macro>
  <macro id="AC_MSG_CHECKING">
      <prototype>
        <parameter content="feature-description"/>
      </prototype>
        <synopsis>
          Notify the user that &lt;CODE&gt;configure&lt;/CODE&gt; is
         checking for a particular feature.  This macro prints a message
         that starts with &lt;samp&gt;checking &lt;/samp&gt; and ends
         with &lt;samp&gt;...&lt;/samp&gt; and no newline.  It must be
         followed by a call to &lt;CODE&gt;AC_MSG_RESULT&lt;/CODE&gt; to
         print the result of the check and the newline.  The
         &lt;VAR&gt;feature-description&lt;/VAR&gt; should be something
         like &lt;samp&gt;whether the Fortran compiler accepts C++
         comments&lt;/samp&gt; or &lt;samp&gt;for c89&lt;/samp&gt;.&lt;/P&gt;&lt;P&gt;

         This macro prints nothing if &lt;CODE&gt;configure&lt;/CODE&gt;
         is run with the &lt;samp&gt;--quiet&lt;/samp&gt; or
         &lt;samp&gt;--silent&lt;/samp&gt; option.
        </synopsis>
  </macro>
  <macro id="AC_MSG_RESULT">
      <prototype>
        <parameter content="result-description"/>
      </prototype>
        <synopsis>
          Notify the user of the results of a check. 
         &lt;VAR&gt;result-description&lt;/VAR&gt; is almost always the
         value of the cache variable for the check, typically
         &lt;samp&gt;yes&lt;/samp&gt;, &lt;samp&gt;no&lt;/samp&gt;, or a
         file name.  This macro should follow a call to
         &lt;CODE&gt;AC_MSG_CHECKING&lt;/CODE&gt;, and the
         &lt;VAR&gt;result-description&lt;/VAR&gt; should be the
         completion of the message printed by the call to
         &lt;CODE&gt;AC_MSG_CHECKING&lt;/CODE&gt;.&lt;/P&gt;&lt;P&gt;

         This macro prints nothing if &lt;CODE&gt;configure&lt;/CODE&gt;
         is run with the &lt;samp&gt;--quiet&lt;/samp&gt; or
         &lt;samp&gt;--silent&lt;/samp&gt; option.
        </synopsis>
  </macro>
  <macro id="AC_MSG_NOTICE">
      <prototype>
        <parameter content="message"/>
      </prototype>
        <synopsis>
          Deliver the &lt;VAR&gt;message&lt;/VAR&gt; to the user.  It is
         useful mainly to print a general description of the overall
         purpose of a group of feature checks, e.g.,&lt;/P&gt;&lt;P&gt;

         &lt;TABLE&gt;&lt;tr&gt;&lt;td&gt;&amp;nbsp;&lt;/td&gt;&lt;td
         class=example&gt;&lt;pre&gt; AC_MSG_NOTICE([checking if stack
         overflow is detectable])
         &lt;/pre&gt;&lt;/td&gt;&lt;/tr&gt;&lt;/table&gt;&lt;/P&gt;&lt;P&gt;

         This macro prints nothing if &lt;CODE&gt;configure&lt;/CODE&gt;
         is run with the &lt;samp&gt;--quiet&lt;/samp&gt; or
         &lt;samp&gt;--silent&lt;/samp&gt; option.
        </synopsis>
  </macro>
  <macro id="AC_MSG_ERROR">
      <prototype>
        <parameter content="error-description"/>
        <parameter content="[exit-status]"/>
      </prototype>
        <synopsis>
          Notify the user of an error that prevents
         &lt;CODE&gt;configure&lt;/CODE&gt; from completing.  This macro
         prints an error message to the standard error output and exits
         &lt;CODE&gt;configure&lt;/CODE&gt; with
         &lt;VAR&gt;exit-status&lt;/VAR&gt; (1 by default).
         &lt;VAR&gt;error-description&lt;/VAR&gt; should be something
         like &lt;samp&gt;invalid value $HOME for \$HOME&lt;/samp&gt;.&lt;/P&gt;&lt;P&gt;

         The &lt;VAR&gt;error-description&lt;/VAR&gt; should start with a
         lower-case letter, and ``cannot'' is preferred to ``can't''.
        </synopsis>
  </macro>
  <macro id="AC_MSG_FAILURE">
      <prototype>
        <parameter content="error-description"/>
        <parameter content="[exit-status]"/>
      </prototype>
        <synopsis>
          This &lt;CODE&gt;AC_MSG_ERROR&lt;/CODE&gt; wrapper notifies the
         user of an error that prevents
         &lt;CODE&gt;configure&lt;/CODE&gt; from completing
         &lt;EM&gt;and&lt;/EM&gt; that additional details are provided in
         &lt;TT&gt;config.log&lt;/TT&gt;.  This is typically used when
         abnormal results are found during a compilation.
        </synopsis>
  </macro>
  <macro id="AC_MSG_WARN">
      <prototype>
        <parameter content="problem-description"/>
      </prototype>
        <synopsis>
          Notify the &lt;CODE&gt;configure&lt;/CODE&gt; user of a
         possible problem.  This macro prints the message to the standard
         error output; &lt;CODE&gt;configure&lt;/CODE&gt; continues
         running afterward, so macros that call
         &lt;CODE&gt;AC_MSG_WARN&lt;/CODE&gt; should provide a default
         (back-up) behavior for the situations they warn about.
         &lt;VAR&gt;problem-description&lt;/VAR&gt; should be something
         like &lt;samp&gt;ln -s seems to make hard links&lt;/samp&gt;.
        </synopsis>
  </macro>
  <macro id="dnl">
      <prototype>
      </prototype>
        <synopsis>
          This macro kept its original name: no
         &lt;CODE&gt;m4_dnl&lt;/CODE&gt; is defined.
        </synopsis>
  </macro>
  <macro id="m4_defn">
      <prototype>
        <parameter content="macro"/>
      </prototype>
        <synopsis>
          Contrary to the M4 builtin, this macro fails if
         &lt;VAR&gt;macro&lt;/VAR&gt; is not defined.  See
         &lt;CODE&gt;m4_undefine&lt;/CODE&gt;.
        </synopsis>
  </macro>
  <macro id="m4_exit">
      <prototype>
        <parameter content="exit-status"/>
      </prototype>
        <synopsis>
          This macro corresponds to &lt;CODE&gt;m4exit&lt;/CODE&gt;.
        </synopsis>
  </macro>
  <macro id="m4_if">
      <prototype>
        <parameter content="comment"/>
      </prototype>
      <prototype>
        <parameter content="string-1"/>
        <parameter content="string-2"/>
        <parameter content="equal"/>
        <parameter content="[not-equal]"/>
      </prototype>
      <prototype>
        <parameter content="string-1"/>
        <parameter content="string-2"/>
        <parameter content="equal"/>
        <parameter content="..."/>
      </prototype>
        <synopsis>
          This macro corresponds to &lt;CODE&gt;ifelse&lt;/CODE&gt;.
        </synopsis>
  </macro>
  <macro id="m4_undefine">
      <prototype>
        <parameter content="macro"/>
      </prototype>
        <synopsis>
          Contrary to the M4 builtin, this macro fails if
         &lt;VAR&gt;macro&lt;/VAR&gt; is not defined.  Use&lt;/P&gt;&lt;P&gt;

         &lt;TABLE&gt;&lt;tr&gt;&lt;td&gt;&amp;nbsp;&lt;/td&gt;&lt;td
         class=example&gt;&lt;pre&gt;
         m4_ifdef([&lt;VAR&gt;macro&lt;/VAR&gt;],
         [m4_undefine([&lt;VAR&gt;macro&lt;/VAR&gt;])])
         &lt;/pre&gt;&lt;/td&gt;&lt;/tr&gt;&lt;/table&gt;&lt;/P&gt;&lt;P&gt;

          to recover the behavior of the builtin.
        </synopsis>
  </macro>
  <macro id="m4_bpatsubst">
      <prototype>
        <parameter content="string"/>
        <parameter content="regexp"/>
        <parameter content="[replacement]"/>
      </prototype>
        <synopsis>
          This macro corresponds to &lt;CODE&gt;patsubst&lt;/CODE&gt;. 
         The name &lt;CODE&gt;m4_patsubst&lt;/CODE&gt; is kept for future
         versions of M4sh, on top of GNU M4 which will provide extended
         regular expression syntax via
         &lt;CODE&gt;epatsubst&lt;/CODE&gt;.
        </synopsis>
  </macro>
  <macro id="m4_popdef">
      <prototype>
        <parameter content="macro"/>
      </prototype>
        <synopsis>
          Contrary to the M4 builtin, this macro fails if
         &lt;VAR&gt;macro&lt;/VAR&gt; is not defined.  See
         &lt;CODE&gt;m4_undefine&lt;/CODE&gt;.
        </synopsis>
  </macro>
  <macro id="m4_bregexp">
      <prototype>
        <parameter content="string"/>
        <parameter content="regexp"/>
        <parameter content="[replacement]"/>
      </prototype>
        <synopsis>
          This macro corresponds to &lt;CODE&gt;regexp&lt;/CODE&gt;.  The
         name &lt;CODE&gt;m4_regexp&lt;/CODE&gt; is kept for future
         versions of M4sh, on top of GNU M4 which will provide extended
         regular expression syntax via &lt;CODE&gt;eregexp&lt;/CODE&gt;.
        </synopsis>
  </macro>
  <macro id="m4_wrap">
      <prototype>
        <parameter content="text"/>
      </prototype>
        <synopsis>
          This macro corresponds to &lt;CODE&gt;m4wrap&lt;/CODE&gt;.&lt;/P&gt;&lt;P&gt;

         You are encouraged to end &lt;VAR&gt;text&lt;/VAR&gt; with
         &lt;samp&gt;[]&lt;/samp&gt;, so that there are no risks that two
         consecutive invocations of &lt;CODE&gt;m4_wrap&lt;/CODE&gt;
         result in an unexpected pasting of tokens, as in&lt;/P&gt;&lt;P&gt;

         &lt;TABLE&gt;&lt;tr&gt;&lt;td&gt;&amp;nbsp;&lt;/td&gt;&lt;td
         class=example&gt;&lt;pre&gt; m4_define([foo], [Foo])
         m4_define([bar], [Bar]) m4_define([foobar], [FOOBAR])
         m4_wrap([bar]) m4_wrap([foo]) FOOBAR
         &lt;/pre&gt;&lt;/td&gt;&lt;/tr&gt;&lt;/table&gt;
        </synopsis>
  </macro>
  <macro id="m4_dquote">
      <prototype>
        <parameter content="arg1"/>
        <parameter content="..."/>
      </prototype>
        <synopsis>
          Return the arguments as a quoted list of quoted arguments.
        </synopsis>
  </macro>
  <macro id="m4_quote">
      <prototype>
        <parameter content="arg1"/>
        <parameter content="..."/>
      </prototype>
        <synopsis>
          Return the arguments as a single entity, i.e., wrap them into a
         pair of quotes.
        </synopsis>
  </macro>
  <macro id="m4_pattern_forbid">
      <prototype>
        <parameter content="pattern"/>
      </prototype>
        <synopsis>
          Declare that no token matching &lt;VAR&gt;pattern&lt;/VAR&gt;
         must be found in the output. Comments are not checked; this can
         be a problem if, for instance, you have some macro left
         unexpanded after an &lt;samp&gt;#include&lt;/samp&gt;.  No
         consensus is currently found in the Autoconf community, as some
         people consider it should be valid to name macros in comments
         (which doesn't makes sense to the author of this documentation,
         as &lt;samp&gt;#&lt;/samp&gt;-comments should document the
         output, not the input, documented by
         &lt;samp&gt;dnl&lt;/samp&gt; comments).
        </synopsis>
  </macro>
  <macro id="m4_pattern_allow">
      <prototype>
        <parameter content="pattern"/>
      </prototype>
        <synopsis>
          Any token matching &lt;VAR&gt;pattern&lt;/VAR&gt; is allowed,
         including if it matches an
         &lt;CODE&gt;m4_pattern_forbid&lt;/CODE&gt; pattern.
        </synopsis>
  </macro>
  <macro id="AS_DIRNAME">
      <prototype>
        <parameter content="pathname"/>
      </prototype>
        <synopsis>
          Return the directory portion of
         &lt;VAR&gt;pathname&lt;/VAR&gt;, using the algorithm required by
         POSIX.  , for more details about what this returns and why it is
         more portable than the &lt;CODE&gt;dirname&lt;/CODE&gt; command.
        </synopsis>
  </macro>
  <macro id="AS_IF">
      <prototype>
        <parameter content="test"/>
        <parameter content="[RUN-IF-TRUE]"/>
        <parameter content="[RUN-IF-FALSE]"/>
      </prototype>
        <synopsis>
          Run shell code TEST.  If TEST exits with a zero status then run
         shell code RUN-IF-TRUE, else run shell code RUN-IF-FALSE, with
         simplifications if either RUN-IF-TRUE or RUN-IF-FALSE is empty.
        </synopsis>
  </macro>
  <macro id="AS_MKDIR_P">
      <prototype>
        <parameter content="filename"/>
      </prototype>
        <synopsis>
          Make the directory &lt;VAR&gt;filename&lt;/VAR&gt;, including
         intervening directories as necessary.  This is equivalent to
         &lt;samp&gt;mkdir -p
         &lt;VAR&gt;filename&lt;/VAR&gt;&lt;/samp&gt;, except that it is
         portable to older versions of &lt;CODE&gt;mkdir&lt;/CODE&gt;
         that lack support for the &lt;samp&gt;-p&lt;/samp&gt; option.
        </synopsis>
  </macro>
  <macro id="AS_SET_CATFILE">
      <prototype>
        <parameter content="var"/>
        <parameter content="dir"/>
        <parameter content="file"/>
      </prototype>
        <synopsis>
          Set the shell variable &lt;VAR&gt;var&lt;/VAR&gt; to
         &lt;VAR&gt;dir&lt;/VAR&gt;/&lt;VAR&gt;file&lt;/VAR&gt;, but
         optimizing the common cases (&lt;VAR&gt;dir&lt;/VAR&gt; or
         &lt;VAR&gt;file&lt;/VAR&gt; is &lt;samp&gt;.&lt;/samp&gt;,
         &lt;VAR&gt;file&lt;/VAR&gt; is absolute etc.).
        </synopsis>
  </macro>
  <macro id="AC_DIAGNOSE">
      <prototype>
        <parameter content="category"/>
        <parameter content="message"/>
      </prototype>
        <synopsis>
          Report &lt;VAR&gt;message&lt;/VAR&gt; as a warning (or as an
         error if requested by the user) if warnings of the
         &lt;VAR&gt;category&lt;/VAR&gt; are turned on.  You are
         encouraged to use standard categories, which currently include:&lt;/P&gt;&lt;P&gt;

         &lt;DL&gt;  &lt;DT&gt;'&lt;SAMP&gt;all&lt;/SAMP&gt;' &lt;DD&gt;
         messages that don't fall into one of the following categories. 
         Use of an empty &lt;VAR&gt;category&lt;/VAR&gt; is equivalent.&lt;/P&gt;&lt;P&gt;

         &lt;DT&gt;'&lt;SAMP&gt;cross&lt;/SAMP&gt;' &lt;DD&gt; related to
         cross compilation issues.&lt;/P&gt;&lt;P&gt;

         &lt;DT&gt;'&lt;SAMP&gt;obsolete&lt;/SAMP&gt;' &lt;DD&gt; use of
         an obsolete construct.&lt;/P&gt;&lt;P&gt;

         &lt;DT&gt;'&lt;SAMP&gt;syntax&lt;/SAMP&gt;' &lt;DD&gt; dubious
         syntactic constructs, incorrectly ordered macro calls.
         &lt;/DL&gt;
        </synopsis>
  </macro>
  <macro id="AC_WARNING">
      <prototype>
        <parameter content="message"/>
      </prototype>
        <synopsis>
          Equivalent to &lt;samp&gt;AC_DIAGNOSE([syntax],
         &lt;VAR&gt;message&lt;/VAR&gt;)&lt;/samp&gt;, but you are
         strongly encouraged to use a finer grained category.
        </synopsis>
  </macro>
  <macro id="AC_FATAL">
      <prototype>
        <parameter content="message"/>
      </prototype>
        <synopsis>
          Report a severe error &lt;VAR&gt;message&lt;/VAR&gt;, and have
         &lt;CODE&gt;autoconf&lt;/CODE&gt; die.
        </synopsis>
  </macro>
  <macro id="AC_REQUIRE">
      <prototype>
        <parameter content="macro-name"/>
      </prototype>
        <synopsis>
          If the M4 macro &lt;VAR&gt;macro-name&lt;/VAR&gt; has not
         already been called, call it (without any arguments).  Make sure
         to quote &lt;VAR&gt;macro-name&lt;/VAR&gt; with square brackets.
          &lt;VAR&gt;macro-name&lt;/VAR&gt; must have been defined using
         &lt;CODE&gt;AC_DEFUN&lt;/CODE&gt; or else contain a call to
         &lt;CODE&gt;AC_PROVIDE&lt;/CODE&gt; to indicate that it has been
         called.&lt;/P&gt;&lt;P&gt;

         &lt;CODE&gt;AC_REQUIRE&lt;/CODE&gt; must be used inside an
         &lt;CODE&gt;AC_DEFUN&lt;/CODE&gt;'d macro; it must not be called
         from the top level.
        </synopsis>
  </macro>
  <macro id="AC_BEFORE">
      <prototype>
        <parameter content="this-macro-name"/>
        <parameter content="called-macro-name"/>
      </prototype>
        <synopsis>
          Make M4 print a warning message to the standard error output if
         &lt;VAR&gt;called-macro-name&lt;/VAR&gt; has already been
         called.  &lt;VAR&gt;this-macro-name&lt;/VAR&gt; should be the
         name of the macro that is calling
         &lt;CODE&gt;AC_BEFORE&lt;/CODE&gt;.  The macro
         &lt;VAR&gt;called-macro-name&lt;/VAR&gt; must have been defined
         using &lt;CODE&gt;AC_DEFUN&lt;/CODE&gt; or else contain a call
         to &lt;CODE&gt;AC_PROVIDE&lt;/CODE&gt; to indicate that it has
         been called.
        </synopsis>
  </macro>
  <macro id="AU_DEFUN">
      <prototype>
        <parameter content="old-macro"/>
        <parameter content="implementation"/>
        <parameter content="[message]"/>
      </prototype>
        <synopsis>
           Define &lt;VAR&gt;old-macro&lt;/VAR&gt; as
         &lt;VAR&gt;implementation&lt;/VAR&gt;.  The only difference with
         &lt;CODE&gt;AC_DEFUN&lt;/CODE&gt; is that the user will be
         warned that &lt;VAR&gt;old-macro&lt;/VAR&gt; is now obsolete.&lt;/P&gt;&lt;P&gt;

         If she then uses &lt;CODE&gt;autoupdate&lt;/CODE&gt;, the call
         to &lt;VAR&gt;old-macro&lt;/VAR&gt; will be replaced by the
         modern &lt;VAR&gt;implementation&lt;/VAR&gt;.  The additional
         &lt;VAR&gt;message&lt;/VAR&gt; is then printed.
        </synopsis>
  </macro>
  <macro id="AC_CANONICAL_BUILD">
      <prototype>
      </prototype>
        <synopsis>
              Compute the canonical build-system type variable,
         &lt;CODE&gt;build&lt;/CODE&gt;, and its three individual parts
         &lt;CODE&gt;build_cpu&lt;/CODE&gt;,
         &lt;CODE&gt;build_vendor&lt;/CODE&gt;, and
         &lt;CODE&gt;build_os&lt;/CODE&gt;.&lt;/P&gt;&lt;P&gt;

         If &lt;samp&gt;--build&lt;/samp&gt; was specified, then
         &lt;CODE&gt;build&lt;/CODE&gt; is the canonicalization of
         &lt;CODE&gt;build_alias&lt;/CODE&gt; by
         &lt;CODE&gt;config.sub&lt;/CODE&gt;, otherwise it is determined
         by the shell script &lt;CODE&gt;config.guess&lt;/CODE&gt;.
        </synopsis>
  </macro>
  <macro id="AC_CANONICAL_HOST">
      <prototype>
      </prototype>
        <synopsis>
              Compute the canonical host-system type variable,
         &lt;CODE&gt;host&lt;/CODE&gt;, and its three individual parts
         &lt;CODE&gt;host_cpu&lt;/CODE&gt;,
         &lt;CODE&gt;host_vendor&lt;/CODE&gt;, and
         &lt;CODE&gt;host_os&lt;/CODE&gt;.&lt;/P&gt;&lt;P&gt;

         If &lt;samp&gt;--host&lt;/samp&gt; was specified, then
         &lt;CODE&gt;host&lt;/CODE&gt; is the canonicalization of
         &lt;CODE&gt;host_alias&lt;/CODE&gt; by
         &lt;CODE&gt;config.sub&lt;/CODE&gt;, otherwise it defaults to
         &lt;CODE&gt;build&lt;/CODE&gt;.
        </synopsis>
  </macro>
  <macro id="AC_CANONICAL_TARGET">
      <prototype>
      </prototype>
        <synopsis>
              Compute the canonical target-system type variable,
         &lt;CODE&gt;target&lt;/CODE&gt;, and its three individual parts
         &lt;CODE&gt;target_cpu&lt;/CODE&gt;,
         &lt;CODE&gt;target_vendor&lt;/CODE&gt;, and
         &lt;CODE&gt;target_os&lt;/CODE&gt;.&lt;/P&gt;&lt;P&gt;

         If &lt;samp&gt;--target&lt;/samp&gt; was specified, then
         &lt;CODE&gt;target&lt;/CODE&gt; is the canonicalization of
         &lt;CODE&gt;target_alias&lt;/CODE&gt; by
         &lt;CODE&gt;config.sub&lt;/CODE&gt;, otherwise it defaults to
         &lt;CODE&gt;host&lt;/CODE&gt;.
        </synopsis>
  </macro>
  <macro id="AC_ARG_WITH">
      <prototype>
        <parameter content="package"/>
        <parameter content="help-string"/>
        <parameter content="[action-if-given]"/>
        <parameter content="[action-if-not-given]"/>
      </prototype>
        <synopsis>
          If the user gave &lt;CODE&gt;configure&lt;/CODE&gt; the option
         &lt;samp&gt;--with-&lt;VAR&gt;package&lt;/VAR&gt;&lt;/samp&gt;
         or
         &lt;samp&gt;--without-&lt;VAR&gt;package&lt;/VAR&gt;&lt;/samp&gt;,
         run shell commands &lt;VAR&gt;action-if-given&lt;/VAR&gt;.  If
         neither option was given, run shell commands
         &lt;VAR&gt;action-if-not-given&lt;/VAR&gt;.  The name
         &lt;VAR&gt;package&lt;/VAR&gt; indicates another software
         package that this program should work with.  It should consist
         only of alphanumeric characters and dashes.&lt;/P&gt;&lt;P&gt;

         The option's argument is available to the shell commands
         &lt;VAR&gt;action-if-given&lt;/VAR&gt; in the shell variable
         &lt;CODE&gt;withval&lt;/CODE&gt;, which is actually just the
         value of the shell variable
         &lt;CODE&gt;with_&lt;VAR&gt;package&lt;/VAR&gt;&lt;/CODE&gt;,
         with any &lt;samp&gt;-&lt;/samp&gt; characters changed into
         &lt;samp&gt;_&lt;/samp&gt;.  You may use that variable instead,
         if you wish.&lt;/P&gt;&lt;P&gt;

         The argument &lt;VAR&gt;help-string&lt;/VAR&gt; is a description
         of the option that looks like this:
         &lt;TABLE&gt;&lt;tr&gt;&lt;td&gt;&amp;nbsp;&lt;/td&gt;&lt;td
         class=example&gt;&lt;pre&gt;   --with-readline         support
         fancy command line editing
         &lt;/pre&gt;&lt;/td&gt;&lt;/tr&gt;&lt;/table&gt;&lt;/P&gt;&lt;P&gt;

          &lt;VAR&gt;help-string&lt;/VAR&gt; may be more than one line
         long, if more detail is needed.  Just make sure the columns line
         up in &lt;samp&gt;configure --help&lt;/samp&gt;.  Avoid tabs in
         the help string.  You'll need to enclose the help string in
         &lt;samp&gt;[&lt;/samp&gt; and &lt;samp&gt;]&lt;/samp&gt; in
         order to produce the leading spaces.&lt;/P&gt;&lt;P&gt;

         You should format your &lt;VAR&gt;help-string&lt;/VAR&gt; with
         the macro &lt;CODE&gt;AS_HELP_STRING&lt;/CODE&gt; (Pretty Help
         Strings).
        </synopsis>
  </macro>
  <macro id="AC_WITH">
      <prototype>
        <parameter content="package"/>
        <parameter content="action-if-given"/>
        <parameter content="[action-if-not-given]"/>
      </prototype>
        <synopsis>
          This is an obsolete version of
         &lt;CODE&gt;AC_ARG_WITH&lt;/CODE&gt; that does not support
         providing a help string.
        </synopsis>
  </macro>
  <macro id="AC_ARG_ENABLE">
      <prototype>
        <parameter content="feature"/>
        <parameter content="help-string"/>
        <parameter content="[action-if-given]"/>
        <parameter content="[action-if-not-given]"/>
      </prototype>
        <synopsis>
          If the user gave &lt;CODE&gt;configure&lt;/CODE&gt; the option
         &lt;samp&gt;--enable-&lt;VAR&gt;feature&lt;/VAR&gt;&lt;/samp&gt;
         or
         &lt;samp&gt;--disable-&lt;VAR&gt;feature&lt;/VAR&gt;&lt;/samp&gt;,
         run shell commands &lt;VAR&gt;action-if-given&lt;/VAR&gt;.  If
         neither option was given, run shell commands
         &lt;VAR&gt;action-if-not-given&lt;/VAR&gt;.  The name
         &lt;VAR&gt;feature&lt;/VAR&gt; indicates an optional user-level
         facility.  It should consist only of alphanumeric characters and
         dashes.&lt;/P&gt;&lt;P&gt;

         The option's argument is available to the shell commands
         &lt;VAR&gt;action-if-given&lt;/VAR&gt; in the shell variable
         &lt;CODE&gt;enableval&lt;/CODE&gt;, which is actually just the
         value of the shell variable
         &lt;CODE&gt;enable_&lt;VAR&gt;feature&lt;/VAR&gt;&lt;/CODE&gt;,
         with any &lt;samp&gt;-&lt;/samp&gt; characters changed into
         &lt;samp&gt;_&lt;/samp&gt;.  You may use that variable instead,
         if you wish.  The &lt;VAR&gt;help-string&lt;/VAR&gt; argument is
         like that of &lt;CODE&gt;AC_ARG_WITH&lt;/CODE&gt; (External
         Software).&lt;/P&gt;&lt;P&gt;

         You should format your &lt;VAR&gt;help-string&lt;/VAR&gt; with
         the macro &lt;CODE&gt;AS_HELP_STRING&lt;/CODE&gt; (Pretty Help
         Strings).
        </synopsis>
  </macro>
  <macro id="AC_ENABLE">
      <prototype>
        <parameter content="feature"/>
        <parameter content="action-if-given"/>
        <parameter content="[action-if-not-given]"/>
      </prototype>
        <synopsis>
          This is an obsolete version of
         &lt;CODE&gt;AC_ARG_ENABLE&lt;/CODE&gt; that does not support
         providing a help string.
        </synopsis>
  </macro>
  <macro id="AS_HELP_STRING">
      <prototype>
        <parameter content="left-hand-side"/>
        <parameter content="right-hand-side"/>
      </prototype>
        <synopsis>
         &lt;/P&gt;&lt;P&gt;

         Expands into an help string that looks pretty when the user
         executes &lt;samp&gt;configure --help&lt;/samp&gt;.  It is
         typically used in &lt;CODE&gt;AC_ARG_WITH&lt;/CODE&gt; (External
         Software) or &lt;CODE&gt;AC_ARG_ENABLE&lt;/CODE&gt; (Package
         Options).  The following example will make this clearer.&lt;/P&gt;&lt;P&gt;

         &lt;TABLE&gt;&lt;tr&gt;&lt;td&gt;&amp;nbsp;&lt;/td&gt;&lt;td
         class=example&gt;&lt;pre&gt; AC_DEFUN([TEST_MACRO],
         [AC_ARG_WITH([foo],              AS_HELP_STRING([--with-foo],   
                                  [use foo (default is NO)]),            
          [ac_cv_use_foo=$withval], [ac_cv_use_foo=no])
         AC_CACHE_CHECK([whether to use foo],               
         [ac_cv_use_foo], [ac_cv_use_foo=no])])
         &lt;/pre&gt;&lt;/td&gt;&lt;/tr&gt;&lt;/table&gt;&lt;/P&gt;&lt;P&gt;

         Please note that the call to
         &lt;CODE&gt;AS_HELP_STRING&lt;/CODE&gt; is unquoted. Then the
         last few lines of &lt;samp&gt;configure --help&lt;/samp&gt; will
         appear like this:&lt;/P&gt;&lt;P&gt;

         &lt;TABLE&gt;&lt;tr&gt;&lt;td&gt;&amp;nbsp;&lt;/td&gt;&lt;td
         class=example&gt;&lt;pre&gt; --enable and --with options
         recognized:   --with-foo              use foo (default is NO)
         &lt;/pre&gt;&lt;/td&gt;&lt;/tr&gt;&lt;/table&gt;&lt;/P&gt;&lt;P&gt;

         The &lt;CODE&gt;AS_HELP_STRING&lt;/CODE&gt; macro is
         particularly helpful when the
         &lt;VAR&gt;left-hand-side&lt;/VAR&gt; and/or
         &lt;VAR&gt;right-hand-side&lt;/VAR&gt; are composed of macro
         arguments, as shown in the following example.&lt;/P&gt;&lt;P&gt;

         &lt;TABLE&gt;&lt;tr&gt;&lt;td&gt;&amp;nbsp;&lt;/td&gt;&lt;td
         class=example&gt;&lt;pre&gt; AC_DEFUN(MY_ARG_WITH,
         [AC_ARG_WITH([$1],              AS_HELP_STRING([--with-$1], [use
         $1 (default is $2)]),              ac_cv_use_$1=$withval,
         ac_cv_use_$1=no), AC_CACHE_CHECK(whether to use $1,
         ac_cv_use_$1, ac_cv_use_$1=$2)])
         &lt;/pre&gt;&lt;/td&gt;&lt;/tr&gt;&lt;/table&gt;
        </synopsis>
  </macro>
  <macro id="AC_ARG_PROGRAM">
      <prototype>
      </prototype>
        <synopsis>
           Place in output variable
         &lt;CODE&gt;program_transform_name&lt;/CODE&gt; a sequence of
         &lt;CODE&gt;sed&lt;/CODE&gt; commands for changing the names of
         installed programs.&lt;/P&gt;&lt;P&gt;

         If any of the options described below are given to
         &lt;CODE&gt;configure&lt;/CODE&gt;, program names are
         transformed accordingly.  Otherwise, if
         &lt;CODE&gt;AC_CANONICAL_TARGET&lt;/CODE&gt; has been called and
         a &lt;samp&gt;--target&lt;/samp&gt; value is given, the target
         type followed by a dash is used as a prefix. Otherwise, no
         program name transformation is done.
        </synopsis>
  </macro>
  <macro id="AC_ALLOCA">
      <prototype>
      </prototype>
        <synopsis>
          &lt;CODE&gt;AC_FUNC_ALLOCA&lt;/CODE&gt;
        </synopsis>
  </macro>
  <macro id="AC_ARG_ARRAY">
      <prototype>
      </prototype>
        <synopsis>
          removed because of limited usefulness
        </synopsis>
  </macro>
  <macro id="AC_C_CROSS">
      <prototype>
      </prototype>
        <synopsis>
          This macro is obsolete; it does nothing.
        </synopsis>
  </macro>
  <macro id="AC_CANONICAL_SYSTEM">
      <prototype>
      </prototype>
        <synopsis>
          Determine the system type and set output variables to the names
         of the canonical system types.  , for details about the
         variables this macro sets.&lt;/P&gt;&lt;P&gt;

         The user is encouraged to use either
         &lt;CODE&gt;AC_CANONICAL_BUILD&lt;/CODE&gt;, or
         &lt;CODE&gt;AC_CANONICAL_HOST&lt;/CODE&gt;, or
         &lt;CODE&gt;AC_CANONICAL_TARGET&lt;/CODE&gt;, depending on the
         needs.  Using &lt;CODE&gt;AC_CANONICAL_TARGET&lt;/CODE&gt; is
         enough to run the two other macros.
        </synopsis>
  </macro>
  <macro id="AC_CHAR_UNSIGNED">
      <prototype>
      </prototype>
        <synopsis>
          &lt;CODE&gt;AC_C_CHAR_UNSIGNED&lt;/CODE&gt;
        </synopsis>
  </macro>
  <macro id="AC_CHECKING">
      <prototype>
        <parameter content="feature-description"/>
      </prototype>
        <synopsis>
          Same as &lt;samp&gt;AC_MSG_NOTICE([checking
         &lt;VAR&gt;feature-description&lt;/VAR&gt;&lt;small&gt;...&lt;/small&gt;]&lt;/samp&gt;.
        </synopsis>
  </macro>
  <macro id="AC_COMPILE_CHECK">
      <prototype>
        <parameter content="echo-text"/>
        <parameter content="includes"/>
        <parameter content="function-body"/>
        <parameter content="action-if-found"/>
        <parameter content="[action-if-not-found]"/>
      </prototype>
        <synopsis>
          This is an obsolete version of
         &lt;CODE&gt;AC_TRY_COMPILE&lt;/CODE&gt; itself replaced by
         &lt;CODE&gt;AC_COMPILE_IFELSE&lt;/CODE&gt; (Running the
         Compiler), with the addition that it prints &lt;samp&gt;checking
         for &lt;VAR&gt;echo-text&lt;/VAR&gt;&lt;/samp&gt; to the
         standard output first, if &lt;VAR&gt;echo-text&lt;/VAR&gt; is
         non-empty.  Use &lt;CODE&gt;AC_MSG_CHECKING&lt;/CODE&gt; and
         &lt;CODE&gt;AC_MSG_RESULT&lt;/CODE&gt; instead to print messages
         (Printing Messages).
        </synopsis>
  </macro>
  <macro id="AC_CONST">
      <prototype>
      </prototype>
        <synopsis>
          &lt;CODE&gt;AC_C_CONST&lt;/CODE&gt;
        </synopsis>
  </macro>
  <macro id="AC_CROSS_CHECK">
      <prototype>
      </prototype>
        <synopsis>
          Same as &lt;CODE&gt;AC_C_CROSS&lt;/CODE&gt;, which is obsolete
         too, and does nothing &lt;CODE&gt;:-)&lt;/CODE&gt;.
        </synopsis>
  </macro>
  <macro id="AC_CYGWIN">
      <prototype>
      </prototype>
        <synopsis>
          Check for the Cygwin environment in which case the shell
         variable &lt;CODE&gt;CYGWIN&lt;/CODE&gt; is set to
         &lt;samp&gt;yes&lt;/samp&gt;.  Don't use this macro, the
         dignified means to check the nature of the host is using
         &lt;CODE&gt;AC_CANONICAL_HOST&lt;/CODE&gt;.  As a matter of fact
         this macro is defined as:&lt;/P&gt;&lt;P&gt;

         &lt;TABLE&gt;&lt;tr&gt;&lt;td&gt;&amp;nbsp;&lt;/td&gt;&lt;td
         class=example&gt;&lt;pre&gt;
         AC_REQUIRE([AC_CANONICAL_HOST])[]dnl case $host_os in   *cygwin*
         ) CYGWIN=yes;;          * ) CYGWIN=no;; esac
         &lt;/pre&gt;&lt;/td&gt;&lt;/tr&gt;&lt;/table&gt;&lt;/P&gt;&lt;P&gt;

         Beware that the variable &lt;CODE&gt;CYGWIN&lt;/CODE&gt; has a
         very special meaning when running CygWin32, and should not be
         changed.  That's yet another reason not to use this macro.
        </synopsis>
  </macro>
  <macro id="AC_DECL_SYS_SIGLIST">
      <prototype>
      </prototype>
        <synopsis>
           Same as:&lt;/P&gt;&lt;P&gt;

         &lt;TABLE&gt;&lt;tr&gt;&lt;td&gt;&amp;nbsp;&lt;/td&gt;&lt;td
         class=example&gt;&lt;pre&gt; AC_CHECK_DECLS([sys_siglist],,,
         [#include &lt;signal.h&gt; /* NetBSD declares sys_siglist in
         unistd.h.  */ #if HAVE_UNISTD_H # include &lt;unistd.h&gt;
         #endif ]) &lt;/pre&gt;&lt;/td&gt;&lt;/tr&gt;&lt;/table&gt;
        </synopsis>
  </macro>
  <macro id="AC_DECL_YYTEXT">
      <prototype>
      </prototype>
        <synopsis>
          Does nothing, now integrated in
         &lt;CODE&gt;AC_PROG_LEX&lt;/CODE&gt;.
        </synopsis>
  </macro>
  <macro id="AC_DIR_HEADER">
      <prototype>
      </prototype>
        <synopsis>
              Like calling &lt;CODE&gt;AC_FUNC_CLOSEDIR_VOID&lt;/CODE&gt;
         and&lt;CODE&gt;AC_HEADER_DIRENT&lt;/CODE&gt;, but defines a
         different set of C preprocessor macros to indicate which header
         file is found:&lt;/P&gt;&lt;P&gt;

         @multitable {&lt;TT&gt;sys/ndir.h&lt;/TT&gt;} {Old Symbol}
         {&lt;CODE&gt;HAVE_SYS_NDIR_H&lt;/CODE&gt;} &lt;LI&gt; Header    
                @tab Old Symbol     @tab New Symbol &lt;LI&gt;
         &lt;TT&gt;dirent.h&lt;/TT&gt;   @tab
         &lt;CODE&gt;DIRENT&lt;/CODE&gt;  @tab
         &lt;CODE&gt;HAVE_DIRENT_H&lt;/CODE&gt; &lt;LI&gt;
         &lt;TT&gt;sys/ndir.h&lt;/TT&gt; @tab
         &lt;CODE&gt;SYSNDIR&lt;/CODE&gt; @tab
         &lt;CODE&gt;HAVE_SYS_NDIR_H&lt;/CODE&gt; &lt;LI&gt;
         &lt;TT&gt;sys/dir.h&lt;/TT&gt;  @tab
         &lt;CODE&gt;SYSDIR&lt;/CODE&gt;  @tab
         &lt;CODE&gt;HAVE_SYS_DIR_H&lt;/CODE&gt; &lt;LI&gt;
         &lt;TT&gt;ndir.h&lt;/TT&gt;     @tab
         &lt;CODE&gt;NDIR&lt;/CODE&gt;    @tab
         &lt;CODE&gt;HAVE_NDIR_H&lt;/CODE&gt; @end multitable
        </synopsis>
  </macro>
  <macro id="AC_DYNIX_SEQ">
      <prototype>
      </prototype>
        <synopsis>
          If on DYNIX/ptx, add &lt;samp&gt;-lseq&lt;/samp&gt; to output
         variable &lt;CODE&gt;LIBS&lt;/CODE&gt;.  This macro used to be
         defined as&lt;/P&gt;&lt;P&gt;

         &lt;TABLE&gt;&lt;tr&gt;&lt;td&gt;&amp;nbsp;&lt;/td&gt;&lt;td
         class=example&gt;&lt;pre&gt; AC_CHECK_LIB(seq, getmntent,
         LIBS="-lseq $LIBS")
         &lt;/pre&gt;&lt;/td&gt;&lt;/tr&gt;&lt;/table&gt;&lt;/P&gt;&lt;P&gt;

          now it is just &lt;CODE&gt;AC_FUNC_GETMNTENT&lt;/CODE&gt;.
        </synopsis>
  </macro>
  <macro id="AC_EXEEXT">
      <prototype>
      </prototype>
        <synopsis>
           Defined the output variable &lt;CODE&gt;EXEEXT&lt;/CODE&gt;
         based on the output of the compiler, which is now done
         automatically.  Typically set to empty string if Unix and
         &lt;samp&gt;.exe&lt;/samp&gt; if Win32 or OS/2.
        </synopsis>
  </macro>
  <macro id="AC_EMXOS2">
      <prototype>
      </prototype>
        <synopsis>
          Similar to &lt;CODE&gt;AC_CYGWIN&lt;/CODE&gt; but checks for
         the EMX environment on OS/2 and sets
         &lt;CODE&gt;EMXOS2&lt;/CODE&gt;.
        </synopsis>
  </macro>
  <macro id="AC_ERROR">
      <prototype>
      </prototype>
        <synopsis>
          &lt;CODE&gt;AC_MSG_ERROR&lt;/CODE&gt;
        </synopsis>
  </macro>
  <macro id="AC_FIND_X">
      <prototype>
      </prototype>
        <synopsis>
          &lt;CODE&gt;AC_PATH_X&lt;/CODE&gt;
        </synopsis>
  </macro>
  <macro id="AC_FIND_XTRA">
      <prototype>
      </prototype>
        <synopsis>
          &lt;CODE&gt;AC_PATH_XTRA&lt;/CODE&gt;
        </synopsis>
  </macro>
  <macro id="AC_FUNC_CHECK">
      <prototype>
      </prototype>
        <synopsis>
          &lt;CODE&gt;AC_CHECK_FUNC&lt;/CODE&gt;
        </synopsis>
  </macro>
  <macro id="AC_FUNC_WAIT3">
      <prototype>
      </prototype>
        <synopsis>
           If &lt;CODE&gt;wait3&lt;/CODE&gt; is found and fills in the
         contents of its third argument (a &lt;samp&gt;struct rusage
         *&lt;/samp&gt;), which HP-UX does not do, define
         &lt;CODE&gt;HAVE_WAIT3&lt;/CODE&gt;.&lt;/P&gt;&lt;P&gt;

         These days portable programs should use
         &lt;CODE&gt;waitpid&lt;/CODE&gt;, not
         &lt;CODE&gt;wait3&lt;/CODE&gt;, as
         &lt;CODE&gt;wait3&lt;/CODE&gt; is being removed from the Open
         Group standards, and will not appear in the next revision of
         POSIX@.
        </synopsis>
  </macro>
  <macro id="AC_GCC_TRADITIONAL">
      <prototype>
      </prototype>
        <synopsis>
          &lt;CODE&gt;AC_PROG_GCC_TRADITIONAL&lt;/CODE&gt;
        </synopsis>
  </macro>
  <macro id="AC_GETGROUPS_T">
      <prototype>
      </prototype>
        <synopsis>
          &lt;CODE&gt;AC_TYPE_GETGROUPS&lt;/CODE&gt;
        </synopsis>
  </macro>
  <macro id="AC_GETLOADAVG">
      <prototype>
      </prototype>
        <synopsis>
          &lt;CODE&gt;AC_FUNC_GETLOADAVG&lt;/CODE&gt;
        </synopsis>
  </macro>
  <macro id="AC_HAVE_FUNCS">
      <prototype>
      </prototype>
        <synopsis>
          &lt;CODE&gt;AC_CHECK_FUNCS&lt;/CODE&gt;
        </synopsis>
  </macro>
  <macro id="AC_HAVE_HEADERS">
      <prototype>
      </prototype>
        <synopsis>
          &lt;CODE&gt;AC_CHECK_HEADERS&lt;/CODE&gt;
        </synopsis>
  </macro>
  <macro id="AC_HAVE_LIBRARY">
      <prototype>
        <parameter content="library"/>
        <parameter content="[action-if-found]"/>
        <parameter content="[action-if-not-found]"/>
        <parameter content="[other-libraries]"/>
      </prototype>
        <synopsis>
          This macro is equivalent to calling
         &lt;CODE&gt;AC_CHECK_LIB&lt;/CODE&gt; with a
         &lt;VAR&gt;function&lt;/VAR&gt; argument of
         &lt;CODE&gt;main&lt;/CODE&gt;.  In addition,
         &lt;VAR&gt;library&lt;/VAR&gt; can be written as any of
         &lt;samp&gt;foo&lt;/samp&gt;, &lt;samp&gt;-lfoo&lt;/samp&gt;, or
         &lt;samp&gt;libfoo.a&lt;/samp&gt;.  In all of those cases, the
         compiler is passed &lt;samp&gt;-lfoo&lt;/samp&gt;.  However,
         &lt;VAR&gt;library&lt;/VAR&gt; cannot be a shell variable; it
         must be a literal name.
        </synopsis>
  </macro>
  <macro id="AC_HAVE_POUNDBANG">
      <prototype>
      </prototype>
        <synopsis>
          &lt;CODE&gt;AC_SYS_INTERPRETER&lt;/CODE&gt; (different calling
         convention)
        </synopsis>
  </macro>
  <macro id="AC_HEADER_CHECK">
      <prototype>
      </prototype>
        <synopsis>
          &lt;CODE&gt;AC_CHECK_HEADER&lt;/CODE&gt;
        </synopsis>
  </macro>
  <macro id="AC_HEADER_EGREP">
      <prototype>
      </prototype>
        <synopsis>
          &lt;CODE&gt;AC_EGREP_HEADER&lt;/CODE&gt;
        </synopsis>
  </macro>
  <macro id="AC_HELP_STRING">
      <prototype>
      </prototype>
        <synopsis>
          &lt;CODE&gt;AS_HELP_STRING&lt;/CODE&gt;
        </synopsis>
  </macro>
  <macro id="AC_INLINE">
      <prototype>
      </prototype>
        <synopsis>
          &lt;CODE&gt;AC_C_INLINE&lt;/CODE&gt;
        </synopsis>
  </macro>
  <macro id="AC_INT_16_BITS">
      <prototype>
      </prototype>
        <synopsis>
           If the C type &lt;CODE&gt;int&lt;/CODE&gt; is 16 bits wide,
         define &lt;CODE&gt;INT_16_BITS&lt;/CODE&gt;. Use
         &lt;samp&gt;AC_CHECK_SIZEOF(int)&lt;/samp&gt; instead.
        </synopsis>
  </macro>
  <macro id="AC_IRIX_SUN">
      <prototype>
      </prototype>
        <synopsis>
          If on irix (Silicon Graphics unix), add
         &lt;samp&gt;-lsun&lt;/samp&gt; to output
         &lt;CODE&gt;LIBS&lt;/CODE&gt;.  If you were using it to get
         &lt;CODE&gt;getmntent&lt;/CODE&gt;, use
         &lt;CODE&gt;AC_FUNC_GETMNTENT&lt;/CODE&gt; instead.  If you used
         it for the NIS versions of the password and group functions, use
         &lt;samp&gt;AC_CHECK_LIB(sun, getpwnam)&lt;/samp&gt;.  Up to
         Autoconf 2.13, it used to be&lt;/P&gt;&lt;P&gt;

         &lt;TABLE&gt;&lt;tr&gt;&lt;td&gt;&amp;nbsp;&lt;/td&gt;&lt;td
         class=example&gt;&lt;pre&gt; AC_CHECK_LIB(sun, getmntent,
         LIBS="-lsun $LIBS")
         &lt;/pre&gt;&lt;/td&gt;&lt;/tr&gt;&lt;/table&gt;&lt;/P&gt;&lt;P&gt;

          now it is defined as&lt;/P&gt;&lt;P&gt;

         &lt;TABLE&gt;&lt;tr&gt;&lt;td&gt;&amp;nbsp;&lt;/td&gt;&lt;td
         class=example&gt;&lt;pre&gt; AC_FUNC_GETMNTENT AC_CHECK_LIB(sun,
         getpwnam) &lt;/pre&gt;&lt;/td&gt;&lt;/tr&gt;&lt;/table&gt;
        </synopsis>
  </macro>
  <macro id="AC_LANG_C">
      <prototype>
      </prototype>
        <synopsis>
          Same as &lt;samp&gt;AC_LANG(C)&lt;/samp&gt;.
        </synopsis>
  </macro>
  <macro id="AC_LANG_CPLUSPLUS">
      <prototype>
      </prototype>
        <synopsis>
          Same as &lt;samp&gt;AC_LANG(C++)&lt;/samp&gt;.
        </synopsis>
  </macro>
  <macro id="AC_LANG_FORTRAN77">
      <prototype>
      </prototype>
        <synopsis>
          Same as &lt;samp&gt;AC_LANG(Fortran 77)&lt;/samp&gt;.
        </synopsis>
  </macro>
  <macro id="AC_LANG_RESTORE">
      <prototype>
      </prototype>
        <synopsis>
          Select the &lt;VAR&gt;language&lt;/VAR&gt; that is saved on the
         top of the stack, as set by
         &lt;CODE&gt;AC_LANG_SAVE&lt;/CODE&gt;, remove it from the stack,
         and call
         &lt;CODE&gt;AC_LANG(&lt;VAR&gt;language&lt;/VAR&gt;)&lt;/CODE&gt;.
        </synopsis>
  </macro>
  <macro id="AC_LANG_SAVE">
      <prototype>
      </prototype>
        <synopsis>
          Remember the current language (as set by
         &lt;CODE&gt;AC_LANG&lt;/CODE&gt;) on a stack. The current
         language does not change.  &lt;CODE&gt;AC_LANG_PUSH&lt;/CODE&gt;
         is preferred.
        </synopsis>
  </macro>
  <macro id="AC_LINK_FILES">
      <prototype>
        <parameter content="source..."/>
        <parameter content="dest..."/>
      </prototype>
        <synopsis>
          This is an obsolete version of
         &lt;CODE&gt;AC_CONFIG_LINKS&lt;/CODE&gt;.  An updated version
         of:&lt;/P&gt;&lt;P&gt;

         &lt;TABLE&gt;&lt;tr&gt;&lt;td&gt;&amp;nbsp;&lt;/td&gt;&lt;td
         class=example&gt;&lt;pre&gt; AC_LINK_FILES(config/$machine.h
         config/$obj_format.h,               host.h            object.h)
         &lt;/pre&gt;&lt;/td&gt;&lt;/tr&gt;&lt;/table&gt;&lt;/P&gt;&lt;P&gt;

          is:&lt;/P&gt;&lt;P&gt;

         &lt;TABLE&gt;&lt;tr&gt;&lt;td&gt;&amp;nbsp;&lt;/td&gt;&lt;td
         class=example&gt;&lt;pre&gt;
         AC_CONFIG_LINKS(host.h:config/$machine.h                
         object.h:config/$obj_format.h)
         &lt;/pre&gt;&lt;/td&gt;&lt;/tr&gt;&lt;/table&gt;
        </synopsis>
  </macro>
  <macro id="AC_LN_S">
      <prototype>
      </prototype>
        <synopsis>
          &lt;CODE&gt;AC_PROG_LN_S&lt;/CODE&gt;
        </synopsis>
  </macro>
  <macro id="AC_LONG_64_BITS">
      <prototype>
      </prototype>
        <synopsis>
           Define &lt;CODE&gt;LONG_64_BITS&lt;/CODE&gt; if the C type
         &lt;CODE&gt;long int&lt;/CODE&gt; is 64 bits wide. Use the
         generic macro &lt;samp&gt;AC_CHECK_SIZEOF([long
         int])&lt;/samp&gt; instead.
        </synopsis>
  </macro>
  <macro id="AC_LONG_DOUBLE">
      <prototype>
      </prototype>
        <synopsis>
          &lt;CODE&gt;AC_C_LONG_DOUBLE&lt;/CODE&gt;
        </synopsis>
  </macro>
  <macro id="AC_LONG_FILE_NAMES">
      <prototype>
      </prototype>
        <synopsis>
          &lt;CODE&gt;AC_SYS_LONG_FILE_NAMES&lt;/CODE&gt;
        </synopsis>
  </macro>
  <macro id="AC_MAJOR_HEADER">
      <prototype>
      </prototype>
        <synopsis>
          &lt;CODE&gt;AC_HEADER_MAJOR&lt;/CODE&gt;
        </synopsis>
  </macro>
  <macro id="AC_MEMORY_H">
      <prototype>
      </prototype>
        <synopsis>
           Used to define &lt;CODE&gt;NEED_MEMORY_H&lt;/CODE&gt; if the
         &lt;CODE&gt;mem&lt;/CODE&gt; functions were defined in
         &lt;TT&gt;memory.h&lt;/TT&gt;.  Today it is equivalent to
         &lt;samp&gt;AC_CHECK_HEADERS(memory.h)&lt;/samp&gt;.  Adjust
         your code to depend upon &lt;CODE&gt;HAVE_MEMORY_H&lt;/CODE&gt;,
         not &lt;CODE&gt;NEED_MEMORY_H&lt;/CODE&gt;; see Standard
         Symbols.
        </synopsis>
  </macro>
  <macro id="AC_MINGW32">
      <prototype>
      </prototype>
        <synopsis>
          Similar to &lt;CODE&gt;AC_CYGWIN&lt;/CODE&gt; but checks for
         the MingW32 compiler environment and sets
         &lt;CODE&gt;MINGW32&lt;/CODE&gt;.
        </synopsis>
  </macro>
  <macro id="AC_MINUS_C_MINUS_O">
      <prototype>
      </prototype>
        <synopsis>
          &lt;CODE&gt;AC_PROG_CC_C_O&lt;/CODE&gt;
        </synopsis>
  </macro>
  <macro id="AC_MMAP">
      <prototype>
      </prototype>
        <synopsis>
          &lt;CODE&gt;AC_FUNC_MMAP&lt;/CODE&gt;
        </synopsis>
  </macro>
  <macro id="AC_MODE_T">
      <prototype>
      </prototype>
        <synopsis>
          &lt;CODE&gt;AC_TYPE_MODE_T&lt;/CODE&gt;
        </synopsis>
  </macro>
  <macro id="AC_OBJEXT">
      <prototype>
      </prototype>
        <synopsis>
           Defined the output variable &lt;CODE&gt;OBJEXT&lt;/CODE&gt;
         based on the output of the compiler, after .c files have been
         excluded.  Typically set to &lt;samp&gt;o&lt;/samp&gt; if Unix,
         &lt;samp&gt;obj&lt;/samp&gt; if Win32.  Now the compiler
         checking macros handle this automatically.
        </synopsis>
  </macro>
  <macro id="AC_OBSOLETE">
      <prototype>
        <parameter content="this-macro-name"/>
        <parameter content="[suggestion]"/>
      </prototype>
        <synopsis>
          Make M4 print a message to the standard error output warning
         that &lt;VAR&gt;this-macro-name&lt;/VAR&gt; is obsolete, and
         giving the file and line number where it was called. 
         &lt;VAR&gt;this-macro-name&lt;/VAR&gt; should be the name of the
         macro that is calling &lt;CODE&gt;AC_OBSOLETE&lt;/CODE&gt;.  If
         &lt;VAR&gt;suggestion&lt;/VAR&gt; is given, it is printed at the
         end of the warning message; for example, it can be a suggestion
         for what to use instead of
         &lt;VAR&gt;this-macro-name&lt;/VAR&gt;.&lt;/P&gt;&lt;P&gt;

         For instance&lt;/P&gt;&lt;P&gt;

         &lt;TABLE&gt;&lt;tr&gt;&lt;td&gt;&amp;nbsp;&lt;/td&gt;&lt;td
         class=example&gt;&lt;pre&gt; AC_OBSOLETE([$0], [; use
         AC_CHECK_HEADERS(unistd.h) instead])dnl
         &lt;/pre&gt;&lt;/td&gt;&lt;/tr&gt;&lt;/table&gt;&lt;/P&gt;&lt;P&gt;

         You are encouraged to use &lt;CODE&gt;AU_DEFUN&lt;/CODE&gt;
         instead, since it gives better services to the user.
        </synopsis>
  </macro>
  <macro id="AC_OFF_T">
      <prototype>
      </prototype>
        <synopsis>
          &lt;CODE&gt;AC_TYPE_OFF_T&lt;/CODE&gt;
        </synopsis>
  </macro>
  <macro id="AC_OUTPUT_COMMANDS">
      <prototype>
        <parameter content="extra-cmds"/>
        <parameter content="[init-cmds]"/>
      </prototype>
        <synopsis>
          Specify additional shell commands to run at the end of
         &lt;TT&gt;config.status&lt;/TT&gt;, and shell commands to
         initialize any variables from
         &lt;CODE&gt;configure&lt;/CODE&gt;.  This macro may be called
         multiple times.  It is obsolete, replaced by
         &lt;CODE&gt;AC_CONFIG_COMMANDS&lt;/CODE&gt;.&lt;/P&gt;&lt;P&gt;

         Here is an unrealistic example:&lt;/P&gt;&lt;P&gt;

         &lt;TABLE&gt;&lt;tr&gt;&lt;td&gt;&amp;nbsp;&lt;/td&gt;&lt;td
         class=example&gt;&lt;pre&gt; fubar=27 AC_OUTPUT_COMMANDS([echo
         this is extra $fubar, and so on.],                   
         [fubar=$fubar]) AC_OUTPUT_COMMANDS([echo this is another, extra,
         bit],                    [echo init bit])
         &lt;/pre&gt;&lt;/td&gt;&lt;/tr&gt;&lt;/table&gt;&lt;/P&gt;&lt;P&gt;

         Aside from the fact that
         &lt;CODE&gt;AC_CONFIG_COMMANDS&lt;/CODE&gt; requires an
         additional key, an important difference is that
         &lt;CODE&gt;AC_OUTPUT_COMMANDS&lt;/CODE&gt; is quoting its
         arguments twice, unlike
         &lt;CODE&gt;AC_CONFIG_COMMANDS&lt;/CODE&gt;.  This means that
         &lt;CODE&gt;AC_CONFIG_COMMANDS&lt;/CODE&gt; can safely be given
         macro calls as arguments:&lt;/P&gt;&lt;P&gt;

         &lt;TABLE&gt;&lt;tr&gt;&lt;td&gt;&amp;nbsp;&lt;/td&gt;&lt;td
         class=example&gt;&lt;pre&gt; AC_CONFIG_COMMANDS(foo, [my_FOO()])
         &lt;/pre&gt;&lt;/td&gt;&lt;/tr&gt;&lt;/table&gt;&lt;/P&gt;&lt;P&gt;

          Conversely, where one level of quoting was enough for literal
         strings with &lt;CODE&gt;AC_OUTPUT_COMMANDS&lt;/CODE&gt;, you
         need two with &lt;CODE&gt;AC_CONFIG_COMMANDS&lt;/CODE&gt;.  The
         following lines are equivalent:&lt;/P&gt;&lt;P&gt;

         &lt;TABLE&gt;&lt;tr&gt;&lt;td&gt;&amp;nbsp;&lt;/td&gt;&lt;td
         class=example&gt;&lt;pre&gt; @group AC_OUTPUT_COMMANDS([echo
         "Square brackets: []"]) AC_CONFIG_COMMANDS([default], [[echo
         "Square brackets: []"]]) @end group
         &lt;/pre&gt;&lt;/td&gt;&lt;/tr&gt;&lt;/table&gt;
        </synopsis>
  </macro>
  <macro id="AC_PID_T">
      <prototype>
      </prototype>
        <synopsis>
          &lt;CODE&gt;AC_TYPE_PID_T&lt;/CODE&gt;
        </synopsis>
  </macro>
  <macro id="AC_PREFIX">
      <prototype>
      </prototype>
        <synopsis>
          &lt;CODE&gt;AC_PREFIX_PROGRAM&lt;/CODE&gt;
        </synopsis>
  </macro>
  <macro id="AC_PROG_CC_STDC">
      <prototype>
      </prototype>
        <synopsis>
          This macro has been integrated into
         &lt;CODE&gt;AC_PROG_CC&lt;/CODE&gt;.
        </synopsis>
  </macro>
  <macro id="AC_PROGRAMS_CHECK">
      <prototype>
      </prototype>
        <synopsis>
          &lt;CODE&gt;AC_CHECK_PROGS&lt;/CODE&gt;
        </synopsis>
  </macro>
  <macro id="AC_PROGRAMS_PATH">
      <prototype>
      </prototype>
        <synopsis>
          &lt;CODE&gt;AC_PATH_PROGS&lt;/CODE&gt;
        </synopsis>
  </macro>
  <macro id="AC_PROGRAM_CHECK">
      <prototype>
      </prototype>
        <synopsis>
          &lt;CODE&gt;AC_CHECK_PROG&lt;/CODE&gt;
        </synopsis>
  </macro>
  <macro id="AC_PROGRAM_EGREP">
      <prototype>
      </prototype>
        <synopsis>
          &lt;CODE&gt;AC_EGREP_CPP&lt;/CODE&gt;
        </synopsis>
  </macro>
  <macro id="AC_PROGRAM_PATH">
      <prototype>
      </prototype>
        <synopsis>
          &lt;CODE&gt;AC_PATH_PROG&lt;/CODE&gt;
        </synopsis>
  </macro>
  <macro id="AC_REMOTE_TAPE">
      <prototype>
      </prototype>
        <synopsis>
          removed because of limited usefulness
        </synopsis>
  </macro>
  <macro id="AC_RESTARTABLE_SYSCALLS">
      <prototype>
      </prototype>
        <synopsis>
          &lt;CODE&gt;AC_SYS_RESTARTABLE_SYSCALLS&lt;/CODE&gt;
        </synopsis>
  </macro>
  <macro id="AC_RETSIGTYPE">
      <prototype>
      </prototype>
        <synopsis>
          &lt;CODE&gt;AC_TYPE_SIGNAL&lt;/CODE&gt;
        </synopsis>
  </macro>
  <macro id="AC_RSH">
      <prototype>
      </prototype>
        <synopsis>
          removed because of limited usefulness
        </synopsis>
  </macro>
  <macro id="AC_SCO_INTL">
      <prototype>
      </prototype>
        <synopsis>
           If on SCO UNIX, add &lt;samp&gt;-lintl&lt;/samp&gt; to output
         variable &lt;CODE&gt;LIBS&lt;/CODE&gt;.  This macro used to&lt;/P&gt;&lt;P&gt;

         &lt;TABLE&gt;&lt;tr&gt;&lt;td&gt;&amp;nbsp;&lt;/td&gt;&lt;td
         class=example&gt;&lt;pre&gt; AC_CHECK_LIB(intl, strftime,
         LIBS="-lintl $LIBS")
         &lt;/pre&gt;&lt;/td&gt;&lt;/tr&gt;&lt;/table&gt;&lt;/P&gt;&lt;P&gt;

          Now it just calls &lt;CODE&gt;AC_FUNC_STRFTIME&lt;/CODE&gt;
         instead.
        </synopsis>
  </macro>
  <macro id="AC_SETVBUF_REVERSED">
      <prototype>
      </prototype>
        <synopsis>
          &lt;CODE&gt;AC_FUNC_SETVBUF_REVERSED&lt;/CODE&gt;
        </synopsis>
  </macro>
  <macro id="AC_SET_MAKE">
      <prototype>
      </prototype>
        <synopsis>
          &lt;CODE&gt;AC_PROG_MAKE_SET&lt;/CODE&gt;
        </synopsis>
  </macro>
  <macro id="AC_SIZEOF_TYPE">
      <prototype>
      </prototype>
        <synopsis>
          &lt;CODE&gt;AC_CHECK_SIZEOF&lt;/CODE&gt;
        </synopsis>
  </macro>
  <macro id="AC_SIZE_T">
      <prototype>
      </prototype>
        <synopsis>
          &lt;CODE&gt;AC_TYPE_SIZE_T&lt;/CODE&gt;
        </synopsis>
  </macro>
  <macro id="AC_STAT_MACROS_BROKEN">
      <prototype>
      </prototype>
        <synopsis>
          &lt;CODE&gt;AC_HEADER_STAT&lt;/CODE&gt;
        </synopsis>
  </macro>
  <macro id="AC_STDC_HEADERS">
      <prototype>
      </prototype>
        <synopsis>
          &lt;CODE&gt;AC_HEADER_STDC&lt;/CODE&gt;
        </synopsis>
  </macro>
  <macro id="AC_STRCOLL">
      <prototype>
      </prototype>
        <synopsis>
          &lt;CODE&gt;AC_FUNC_STRCOLL&lt;/CODE&gt;
        </synopsis>
  </macro>
  <macro id="AC_ST_BLKSIZE">
      <prototype>
      </prototype>
        <synopsis>
          &lt;CODE&gt;AC_CHECK_MEMBERS&lt;/CODE&gt;
        </synopsis>
  </macro>
  <macro id="AC_ST_BLOCKS">
      <prototype>
      </prototype>
        <synopsis>
          &lt;CODE&gt;AC_STRUCT_ST_BLOCKS&lt;/CODE&gt;
        </synopsis>
  </macro>
  <macro id="AC_ST_RDEV">
      <prototype>
      </prototype>
        <synopsis>
          &lt;CODE&gt;AC_CHECK_MEMBERS&lt;/CODE&gt;
        </synopsis>
  </macro>
  <macro id="AC_SYS_RESTARTABLE_SYSCALLS">
      <prototype>
      </prototype>
        <synopsis>
           If the system automatically restarts a system call that is
         interrupted by a signal, define
         &lt;CODE&gt;HAVE_RESTARTABLE_SYSCALLS&lt;/CODE&gt;.  This macro
         does not check if system calls are restarted in general--it
         tests whether a signal handler installed with
         &lt;CODE&gt;signal&lt;/CODE&gt; (but not
         &lt;CODE&gt;sigaction&lt;/CODE&gt;) causes system calls to be
         restarted.  It does not test if system calls can be restarted
         when interrupted by signals that have no handler.&lt;/P&gt;&lt;P&gt;

         These days portable programs should use
         &lt;CODE&gt;sigaction&lt;/CODE&gt; with
         &lt;CODE&gt;SA_RESTART&lt;/CODE&gt; if they want restartable
         system calls.  They should not rely on
         &lt;CODE&gt;HAVE_RESTARTABLE_SYSCALLS&lt;/CODE&gt;, since
         nowadays whether a system call is restartable is a dynamic
         issue, not a configuration-time issue.
        </synopsis>
  </macro>
  <macro id="AC_SYS_SIGLIST_DECLARED">
      <prototype>
      </prototype>
        <synopsis>
          &lt;CODE&gt;AC_DECL_SYS_SIGLIST&lt;/CODE&gt;
        </synopsis>
  </macro>
  <macro id="AC_TEST_CPP">
      <prototype>
      </prototype>
        <synopsis>
          &lt;CODE&gt;AC_TRY_CPP&lt;/CODE&gt;, replaced by
         &lt;CODE&gt;AC_PREPROC_IFELSE&lt;/CODE&gt;.
        </synopsis>
  </macro>
  <macro id="AC_TEST_PROGRAM">
      <prototype>
      </prototype>
        <synopsis>
          &lt;CODE&gt;AC_TRY_RUN&lt;/CODE&gt;, replaced by
         &lt;CODE&gt;AC_RUN_IFELSE&lt;/CODE&gt;.
        </synopsis>
  </macro>
  <macro id="AC_TIMEZONE">
      <prototype>
      </prototype>
        <synopsis>
          &lt;CODE&gt;AC_STRUCT_TIMEZONE&lt;/CODE&gt;
        </synopsis>
  </macro>
  <macro id="AC_TIME_WITH_SYS_TIME">
      <prototype>
      </prototype>
        <synopsis>
          &lt;CODE&gt;AC_HEADER_TIME&lt;/CODE&gt;
        </synopsis>
  </macro>
  <macro id="AC_TRY_COMPILE">
      <prototype>
        <parameter content="includes"/>
        <parameter content="function-body"/>
        <parameter content="[action-if-found]"/>
        <parameter content="[action-if-not-found]"/>
      </prototype>
        <synopsis>
          Same as
         &lt;samp&gt;AC_COMPILE_IFELSE([AC_LANG_SOURCE([[&lt;VAR&gt;includes&lt;/VAR&gt;]],
         [[&lt;VAR&gt;function-body&lt;/VAR&gt;]])],
         [&lt;VAR&gt;action-if-true&lt;/VAR&gt;],
         [&lt;VAR&gt;action-if-false&lt;/VAR&gt;])&lt;/samp&gt; (Running
         the Compiler).&lt;/P&gt;&lt;P&gt;

         This macro double quotes both &lt;VAR&gt;includes&lt;/VAR&gt;
         and &lt;VAR&gt;function-body&lt;/VAR&gt;.&lt;/P&gt;&lt;P&gt;

         For C and C++, &lt;VAR&gt;includes&lt;/VAR&gt; is any
         &lt;CODE&gt;#include&lt;/CODE&gt; statements needed by the code
         in &lt;VAR&gt;function-body&lt;/VAR&gt;
         (&lt;VAR&gt;includes&lt;/VAR&gt; will be ignored if the
         currently selected language is Fortran or Fortran 77).  The
         compiler and compilation flags are determined by the current
         language (Language Choice).
        </synopsis>
  </macro>
  <macro id="AC_TRY_CPP">
      <prototype>
        <parameter content="input"/>
        <parameter content="[action-if-true]"/>
        <parameter content="[action-if-false]"/>
      </prototype>
        <synopsis>
          Same as
         &lt;samp&gt;AC_PREPROC_IFELSE([AC_LANG_SOURCE([[&lt;VAR&gt;input&lt;/VAR&gt;]])],
         [&lt;VAR&gt;action-if-true&lt;/VAR&gt;],
         [&lt;VAR&gt;action-if-false&lt;/VAR&gt;])&lt;/samp&gt; (Running
         the Preprocessor).&lt;/P&gt;&lt;P&gt;

         This macro double quotes the &lt;VAR&gt;input&lt;/VAR&gt;.
        </synopsis>
  </macro>
  <macro id="AC_TRY_LINK">
      <prototype>
        <parameter content="includes"/>
        <parameter content="function-body"/>
        <parameter content="[action-if-found]"/>
        <parameter content="[action-if-not-found]"/>
      </prototype>
        <synopsis>
          Same as
         &lt;samp&gt;AC_LINK_IFELSE([AC_LANG_SOURCE([[&lt;VAR&gt;includes&lt;/VAR&gt;]],
         [[&lt;VAR&gt;function-body&lt;/VAR&gt;]])],
         [&lt;VAR&gt;action-if-true&lt;/VAR&gt;],
         [&lt;VAR&gt;action-if-false&lt;/VAR&gt;])&lt;/samp&gt; (Running
         the Compiler).&lt;/P&gt;&lt;P&gt;

         This macro double quotes both &lt;VAR&gt;includes&lt;/VAR&gt;
         and &lt;VAR&gt;function-body&lt;/VAR&gt;.&lt;/P&gt;&lt;P&gt;

         Depending on the current language (Language Choice), create a
         test program to see whether a function whose body consists of
         &lt;VAR&gt;function-body&lt;/VAR&gt; can be compiled and linked.
          If the file compiles and links successfully, run shell commands
         &lt;VAR&gt;action-if-found&lt;/VAR&gt;, otherwise run
         &lt;VAR&gt;action-if-not-found&lt;/VAR&gt;.&lt;/P&gt;&lt;P&gt;

         This macro double quotes both &lt;VAR&gt;includes&lt;/VAR&gt;
         and &lt;VAR&gt;function-body&lt;/VAR&gt;.&lt;/P&gt;&lt;P&gt;

         For C and C++, &lt;VAR&gt;includes&lt;/VAR&gt; is any
         &lt;CODE&gt;#include&lt;/CODE&gt; statements needed by the code
         in &lt;VAR&gt;function-body&lt;/VAR&gt;
         (&lt;VAR&gt;includes&lt;/VAR&gt; will be ignored if the
         currently selected language is Fortran or Fortran 77).  The
         compiler and compilation flags are determined by the current
         language (Language Choice), and in addition
         &lt;CODE&gt;LDFLAGS&lt;/CODE&gt; and
         &lt;CODE&gt;LIBS&lt;/CODE&gt; are used for linking.
        </synopsis>
  </macro>
  <macro id="AC_TRY_LINK_FUNC">
      <prototype>
        <parameter content="function"/>
        <parameter content="[action-if-found]"/>
        <parameter content="[action-if-not-found]"/>
      </prototype>
        <synopsis>
          This macro is equivalent to
         &lt;samp&gt;AC_LINK_IFELSE([AC_LANG_CALL([[&lt;VAR&gt;includes&lt;/VAR&gt;]],
         [[&lt;VAR&gt;function-body&lt;/VAR&gt;]])],
         [&lt;VAR&gt;action-if-true&lt;/VAR&gt;],
         [&lt;VAR&gt;action-if-false&lt;/VAR&gt;])&lt;/samp&gt;.
        </synopsis>
  </macro>
  <macro id="AC_TRY_RUN">
      <prototype>
        <parameter content="program"/>
        <parameter content="[action-if-true]"/>
        <parameter content="[action-if-false]"/>
        <parameter content="[action-if-cross-compiling]"/>
      </prototype>
        <synopsis>
          Same as
         &lt;samp&gt;AC_RUN_IFELSE([AC_LANG_SOURCE([[&lt;VAR&gt;program&lt;/VAR&gt;]],
         [&lt;VAR&gt;action-if-true&lt;/VAR&gt;],
         [&lt;VAR&gt;action-if-false&lt;/VAR&gt;],
         [&lt;VAR&gt;action-if-cross-compiling&lt;/VAR&gt;])&lt;/samp&gt;
         (Run Time).
        </synopsis>
  </macro>
  <macro id="AC_UID_T">
      <prototype>
      </prototype>
        <synopsis>
          &lt;CODE&gt;AC_TYPE_UID_T&lt;/CODE&gt;
        </synopsis>
  </macro>
  <macro id="AC_UNISTD_H">
      <prototype>
      </prototype>
        <synopsis>
          Same as &lt;samp&gt;AC_CHECK_HEADERS(unistd.h)&lt;/samp&gt;.
        </synopsis>
  </macro>
  <macro id="AC_USG">
      <prototype>
      </prototype>
        <synopsis>
           Define &lt;CODE&gt;USG&lt;/CODE&gt; if the BSD string
         functions are defined in &lt;TT&gt;strings.h&lt;/TT&gt;.  You
         should no longer depend upon &lt;CODE&gt;USG&lt;/CODE&gt;, but
         on &lt;CODE&gt;HAVE_STRING_H&lt;/CODE&gt;; see Standard Symbols.
        </synopsis>
  </macro>
  <macro id="AC_UTIME_NULL">
      <prototype>
      </prototype>
        <synopsis>
          &lt;CODE&gt;AC_FUNC_UTIME_NULL&lt;/CODE&gt;
        </synopsis>
  </macro>
  <macro id="AC_VALIDATE_CACHED_SYSTEM_TUPLE">
      <prototype>
        <parameter content="[cmd]"/>
      </prototype>
        <synopsis>
          If the cache file is inconsistent with the current host, target
         and build system types, it used to execute
         &lt;VAR&gt;cmd&lt;/VAR&gt; or print a default error message. 
         This is now handled by default.
        </synopsis>
  </macro>
  <macro id="AC_VERBOSE">
      <prototype>
        <parameter content="result-description"/>
      </prototype>
        <synopsis>
          &lt;CODE&gt;AC_MSG_RESULT&lt;/CODE&gt;.
        </synopsis>
  </macro>
  <macro id="AC_VFORK">
      <prototype>
      </prototype>
        <synopsis>
          &lt;CODE&gt;AC_FUNC_VFORK&lt;/CODE&gt;
        </synopsis>
  </macro>
  <macro id="AC_VPRINTF">
      <prototype>
      </prototype>
        <synopsis>
          &lt;CODE&gt;AC_FUNC_VPRINTF&lt;/CODE&gt;
        </synopsis>
  </macro>
  <macro id="AC_WAIT3">
      <prototype>
      </prototype>
        <synopsis>
          &lt;CODE&gt;AC_FUNC_WAIT3&lt;/CODE&gt;
        </synopsis>
  </macro>
  <macro id="AC_WARN">
      <prototype>
      </prototype>
        <synopsis>
          &lt;CODE&gt;AC_MSG_WARN&lt;/CODE&gt;
        </synopsis>
  </macro>
  <macro id="AC_WORDS_BIGENDIAN">
      <prototype>
      </prototype>
        <synopsis>
          &lt;CODE&gt;AC_C_BIGENDIAN&lt;/CODE&gt;
        </synopsis>
  </macro>
  <macro id="AC_XENIX_DIR">
      <prototype>
      </prototype>
        <synopsis>
           This macro used to add &lt;samp&gt;-lx&lt;/samp&gt; to output
         variable &lt;CODE&gt;LIBS&lt;/CODE&gt; if on Xenix.  Also, if
         &lt;TT&gt;dirent.h&lt;/TT&gt; is being checked for, added
         &lt;samp&gt;-ldir&lt;/samp&gt; to &lt;CODE&gt;LIBS&lt;/CODE&gt;.
          Now it is merely an alias of
         &lt;CODE&gt;AC_HEADER_DIRENT&lt;/CODE&gt; instead, plus some
         code to detect whether running xenix on which you should not
         depend:&lt;/P&gt;&lt;P&gt;

         &lt;TABLE&gt;&lt;tr&gt;&lt;td&gt;&amp;nbsp;&lt;/td&gt;&lt;td
         class=example&gt;&lt;pre&gt; AC_MSG_CHECKING([for Xenix])
         AC_EGREP_CPP(yes, [#if defined M_XENIX &amp;&amp; !defined
         M_UNIX   yes #endif],              [AC_MSG_RESULT([yes]);
         XENIX=yes],              [AC_MSG_RESULT([no]); XENIX=])
         &lt;/pre&gt;&lt;/td&gt;&lt;/tr&gt;&lt;/table&gt;
        </synopsis>
  </macro>
  <macro id="AC_YYTEXT_POINTER">
      <prototype>
      </prototype>
        <synopsis>
          &lt;CODE&gt;AC_DECL_YYTEXT&lt;/CODE&gt;
        </synopsis>
  </macro>
  <macro id="AT_INIT">
      <prototype>
        <parameter content="[name]"/>
      </prototype>
        <synopsis>
          Initialize Autotest.  Giving a &lt;VAR&gt;name&lt;/VAR&gt; to
         the test suite is encouraged if your package includes several
         test suites.  In any case, the test suite always displays the
         package name and version.  It also inherits the package bug
         report address.
        </synopsis>
  </macro>
  <macro id="AT_TESTED">
      <prototype>
        <parameter content="executables"/>
      </prototype>
        <synopsis>
          Log the path and answer to &lt;samp&gt;--version&lt;/samp&gt;
         of each program in space-separated list
         &lt;VAR&gt;executables&lt;/VAR&gt;.  Several invocations
         register new executables, in other words, don't fear registering
         one program several times.
        </synopsis>
  </macro>
  <macro id="AT_SETUP">
      <prototype>
        <parameter content="test-group-name"/>
      </prototype>
        <synopsis>
          This macro starts a group of related tests, all to be executed
         in the same subshell.  It accepts a single argument, which holds
         a few words (no more than about 30 or 40 characters) quickly
         describing the purpose of the test group being started.
        </synopsis>
  </macro>
  <macro id="AT_KEYWORDS">
      <prototype>
        <parameter content="keywords"/>
      </prototype>
        <synopsis>
          Associate the space-separated list of
         &lt;VAR&gt;keywords&lt;/VAR&gt; to the enclosing test group. 
         This makes it possible to run ``slices'' of the test suite. For
         instance if some of your test groups exercise some
         &lt;samp&gt;foo&lt;/samp&gt; feature, then using
         &lt;samp&gt;AT_KEYWORDS(foo)&lt;/samp&gt; lets you run
         &lt;samp&gt;./testsuite -k foo&lt;/samp&gt; to run exclusively
         these test groups.  The &lt;VAR&gt;title&lt;/VAR&gt; of the test
         group is automatically recorded to
         &lt;CODE&gt;AT_KEYWORDS&lt;/CODE&gt;.&lt;/P&gt;&lt;P&gt;

         Several invocations within a test group accumulate new keywords.
          In other words, don't fear registering several times the same
         keyword in a test group.
        </synopsis>
  </macro>
  <macro id="AT_XFAIL_IF">
      <prototype>
        <parameter content="shell-condition"/>
      </prototype>
        <synopsis>
          Determine whether the test is expected to fail because it is a
         known bug (for unsupported features, you should skip the test).
         &lt;VAR&gt;shell-condition&lt;/VAR&gt; is a shell expression
         such as a &lt;CODE&gt;test&lt;/CODE&gt; command; you can
         instantiate this macro many times from within the same test
         group, and one of the conditions will be enough to turn the test
         into an expected failure.
        </synopsis>
  </macro>
  <macro id="AT_CLEANUP">
      <prototype>
      </prototype>
        <synopsis>
          End the current test group.
        </synopsis>
  </macro>
  <macro id="AT_DATA">
      <prototype>
        <parameter content="file"/>
        <parameter content="contents"/>
      </prototype>
        <synopsis>
          Initialize an input data &lt;VAR&gt;file&lt;/VAR&gt; with given
         &lt;VAR&gt;contents&lt;/VAR&gt;.  Of course, the
         &lt;VAR&gt;contents&lt;/VAR&gt; have to be properly quoted
         between square brackets to protect against included commas or
         spurious M4 expansion.  The contents ought to end with an end of
         line.
        </synopsis>
  </macro>
  <macro id="AT_CHECK">
      <prototype>
        <parameter content="commands"/>
        <parameter content="[status= @samp{0]}"/>
        <parameter content="[stdout= @samp{]}"/>
        <parameter content="[stderr= @samp{]}"/>
        <parameter content="[run-if-fail]"/>
        <parameter content="[run-if-pass]"/>
      </prototype>
        <synopsis>
          Execute a test by performing given shell
         &lt;VAR&gt;commands&lt;/VAR&gt;.  These commands should normally
         exit with &lt;VAR&gt;status&lt;/VAR&gt;, while producing
         expected &lt;VAR&gt;stdout&lt;/VAR&gt; and
         &lt;VAR&gt;stderr&lt;/VAR&gt; contents.  If
         &lt;VAR&gt;commands&lt;/VAR&gt; exit with status 77, then the
         whole test group is skipped.  Otherwise, if this test fails, run
         shell commands &lt;VAR&gt;run-if-fail&lt;/VAR&gt; or, if this
         test passes, run shell commands
         &lt;VAR&gt;run-if-pass&lt;/VAR&gt;.&lt;/P&gt;&lt;P&gt;

         The &lt;VAR&gt;commands&lt;/VAR&gt; &lt;EM&gt;must
         not&lt;/EM&gt; redirect the standard output, nor the standard
         error.&lt;/P&gt;&lt;P&gt;

         If &lt;VAR&gt;status&lt;/VAR&gt;, or
         &lt;VAR&gt;stdout&lt;/VAR&gt;, or &lt;VAR&gt;stderr&lt;/VAR&gt;
         is &lt;samp&gt;ignore&lt;/samp&gt;, then the corresponding value
         is not checked.&lt;/P&gt;&lt;P&gt;

         The special value &lt;samp&gt;expout&lt;/samp&gt; for
         &lt;VAR&gt;stdout&lt;/VAR&gt; means the expected output of the
         &lt;VAR&gt;commands&lt;/VAR&gt; is the content of the file
         &lt;TT&gt;expout&lt;/TT&gt;. If &lt;VAR&gt;stdout&lt;/VAR&gt; is
         &lt;samp&gt;stdout&lt;/samp&gt;, then the standard output of the
         &lt;VAR&gt;commands&lt;/VAR&gt; is available for further tests
         in the file &lt;TT&gt;stdout&lt;/TT&gt;. Similarly for
         &lt;VAR&gt;stderr&lt;/VAR&gt; with
         &lt;samp&gt;expout&lt;/samp&gt; and
         &lt;samp&gt;stderr&lt;/samp&gt;.
        </synopsis>
  </macro>
  <macro id="AC_CONFIG_TESTDIR">
      <prototype>
        <parameter content="directory"/>
        <parameter content="[test-path= directory]"/>
      </prototype>
        <synopsis>
          An Autotest test suite is to be configured in
         &lt;VAR&gt;directory&lt;/VAR&gt;.  This macro requires the
         instantiation of
         &lt;TT&gt;&lt;VAR&gt;directory&lt;/VAR&gt;/atconfig&lt;/TT&gt;
         from
         &lt;TT&gt;&lt;VAR&gt;directory&lt;/VAR&gt;/atconfig.in&lt;/TT&gt;,
         and sets the default &lt;CODE&gt;AUTOTEST_PATH&lt;/CODE&gt; to
         &lt;VAR&gt;test-path&lt;/VAR&gt; (testsuite Invocation).
        </synopsis>
  </macro>
</macros>