<!-- 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="unique-file-in-source-dir"/>
      </prototype>
        <synopsis>
          Process any command-line arguments and find the source code
         directory. &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 &lt;TT&gt;install-sh&lt;/TT&gt;,
         &lt;TT&gt;config.sub&lt;/TT&gt;,
         &lt;TT&gt;config.guess&lt;/TT&gt;, and Cygnus
         &lt;CODE&gt;configure&lt;/CODE&gt; scripts 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; 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;.
        </synopsis>
  </macro>
  <macro id="AC_OUTPUT">
      <prototype>
        <parameter content="[file... ["/>
        <parameter content="extra-cmds ["/>
        <parameter content="init-cmds]]]"/>
      </prototype>
        <synopsis>
          Create output files.  Call this macro once, at the end of
         &lt;TT&gt;configure.in&lt;/TT&gt;. The
         &lt;VAR&gt;file&lt;/VAR&gt;&lt;small&gt;...&lt;/small&gt;
         argument is a whitespace-separated list of output files; it may
         be empty.  This macro creates each file
         &lt;TT&gt;&lt;VAR&gt;file&lt;/VAR&gt;&lt;/TT&gt; by copying an
         input file (by default named
         &lt;TT&gt;&lt;VAR&gt;file&lt;/VAR&gt;.in&lt;/TT&gt;),
         substituting the output variable values. , 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 (but not the parents of that directory). 
         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;

         If &lt;CODE&gt;AC_CONFIG_HEADER&lt;/CODE&gt;,
         &lt;CODE&gt;AC_LINK_FILES&lt;/CODE&gt;, or
         &lt;CODE&gt;AC_CONFIG_SUBDIRS&lt;/CODE&gt; has been called, this
         macro also creates the files named as their arguments.&lt;/P&gt;&lt;P&gt;

         A typical call to &lt;CODE&gt;AC_OUTPUT&lt;/CODE&gt; 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; AC_OUTPUT(Makefile src/Makefile
         man/Makefile X/Imakefile)
         &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;TABLE&gt;&lt;tr&gt;&lt;td&gt;&amp;nbsp;&lt;/td&gt;&lt;td
         class=example&gt;&lt;pre&gt; AC_OUTPUT(Makefile:templates/top.mk
         lib/Makefile:templates/lib.mk)
         AC_OUTPUT(Makefile:templates/vars.mk:Makefile.in:templates/rules.mk)
         &lt;/pre&gt;&lt;/td&gt;&lt;/tr&gt;&lt;/table&gt; Doing this
         allows you to keep your file names acceptable to MS-DOS, or to
         prepend and/or append boilerplate to the file.&lt;/P&gt;&lt;P&gt;

         If you pass &lt;VAR&gt;extra-cmds&lt;/VAR&gt;, those commands
         will be inserted into &lt;TT&gt;config.status&lt;/TT&gt; to be
         run after all its other processing.  If
         &lt;VAR&gt;init-cmds&lt;/VAR&gt; are given, they are inserted
         just before &lt;VAR&gt;extra-cmds&lt;/VAR&gt;, with shell
         variable, command, and backslash substitutions performed on them
         in &lt;CODE&gt;configure&lt;/CODE&gt;.  You can use
         &lt;VAR&gt;init-cmds&lt;/VAR&gt; to pass variables from
         &lt;CODE&gt;configure&lt;/CODE&gt; to the
         &lt;VAR&gt;extra-cmds&lt;/VAR&gt;.  If
         &lt;CODE&gt;AC_OUTPUT_COMMANDS&lt;/CODE&gt; has been called, the
         commands given to it are run just before the commands passed to
         this macro.
        </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. 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;
        </synopsis>
  </macro>
  <macro id="AC_PROG_MAKE_SET">
      <prototype>
      </prototype>
        <synopsis>
           If &lt;CODE&gt;make&lt;/CODE&gt; predefines the 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_HEADER">
      <prototype>
        <parameter content="header-to-create ..."/>
      </prototype>
        <synopsis>
           Make &lt;CODE&gt;AC_OUTPUT&lt;/CODE&gt; create the file(s) in
         the whitespace-separated list
         &lt;VAR&gt;header-to-create&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-to-create&lt;/VAR&gt; is
         &lt;TT&gt;config.h&lt;/TT&gt;.&lt;/P&gt;&lt;P&gt;

         If &lt;VAR&gt;header-to-create&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 some changes in 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-to-create&lt;/VAR&gt;.in&lt;/TT&gt;;
         however, you can override the input file name by appending to
         &lt;VAR&gt;header-to-create&lt;/VAR&gt;, a colon-separated list
         of input files. Examples:
         &lt;TABLE&gt;&lt;tr&gt;&lt;td&gt;&amp;nbsp;&lt;/td&gt;&lt;td
         class=example&gt;&lt;pre&gt;
         AC_CONFIG_HEADER(defines.h:defines.hin)
         AC_CONFIG_HEADER(defines.h:defs.pre:defines.h.in:defs.post)
         &lt;/pre&gt;&lt;/td&gt;&lt;/tr&gt;&lt;/table&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_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.  If a given &lt;VAR&gt;dir&lt;/VAR&gt; is not found, no
         error is reported, so a &lt;CODE&gt;configure&lt;/CODE&gt;
         script can configure whichever parts of a large source tree are
         present.  If a given &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_AUXDIR&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 (e.g., to adjust a relative path for the cache file or
         source directory).  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.  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;; otherwise leave the prefix
         specified in &lt;TT&gt;Makefile.in&lt;/TT&gt; unchanged.  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_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 on the
         standard error output and do not create
         &lt;CODE&gt;configure&lt;/CODE&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; AC_PREREQ(1.8)
         &lt;/pre&gt;&lt;/td&gt;&lt;/tr&gt;&lt;/table&gt;&lt;/P&gt;&lt;P&gt;

         This macro is useful if your &lt;TT&gt;configure.in&lt;/TT&gt;
         relies on non-obvious behavior that changed between Autoconf
         releases.  If it merely needs recently added macros, then
         &lt;CODE&gt;AC_PREREQ&lt;/CODE&gt; is less useful, because the
         &lt;CODE&gt;autoconf&lt;/CODE&gt; program already tells the user
         which macros are not found.  The same thing happens if
         &lt;TT&gt;configure.in&lt;/TT&gt; is processed by a version of
         Autoconf older than when &lt;CODE&gt;AC_PREREQ&lt;/CODE&gt; was
         added.
        </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.in&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.in&lt;/TT&gt; a particular
         &lt;CODE&gt;configure&lt;/CODE&gt; corresponds to.&lt;/P&gt;&lt;P&gt;

         It is a good idea to call this macro before
         &lt;CODE&gt;AC_INIT&lt;/CODE&gt; so that the revision number is
         near the top of both &lt;TT&gt;configure.in&lt;/TT&gt; and
         &lt;CODE&gt;configure&lt;/CODE&gt;.  To support doing that, the
         &lt;CODE&gt;AC_REVISION&lt;/CODE&gt; output begins with
         &lt;samp&gt;#! /bin/sh&lt;/samp&gt;, like the normal start of a
         &lt;CODE&gt;configure&lt;/CODE&gt; script does.&lt;/P&gt;&lt;P&gt;

         For example, this line in &lt;TT&gt;configure.in&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 $)dnl
         &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.in
         Revision: 1.30 &lt;/pre&gt;&lt;/td&gt;&lt;/tr&gt;&lt;/table&gt;
        </synopsis>
  </macro>
  <macro id="AC_DECL_YYTEXT">
      <prototype>
      </prototype>
        <synopsis>
            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.
        </synopsis>
  </macro>
  <macro id="AC_PROG_AWK">
      <prototype>
      </prototype>
        <synopsis>
           Check for &lt;CODE&gt;mawk&lt;/CODE&gt;,
         &lt;CODE&gt;gawk&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 it
         finds.  It tries &lt;CODE&gt;mawk&lt;/CODE&gt; first because
         that is reported to be the fastest implementation.
        </synopsis>
  </macro>
  <macro id="AC_PROG_CC">
      <prototype>
      </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 use
         &lt;CODE&gt;cc&lt;/CODE&gt; if that's not found. Set output
         variable &lt;CODE&gt;CC&lt;/CODE&gt; to the name of the compiler
         found.&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;,
         empty otherwise.  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.&lt;/P&gt;&lt;P&gt;

         If the C compiler being used does not produce executables that
         can run on the system where &lt;CODE&gt;configure&lt;/CODE&gt;
         is being run, set the shell variable
         &lt;CODE&gt;cross_compiling&lt;/CODE&gt; to
         &lt;samp&gt;yes&lt;/samp&gt;, otherwise
         &lt;samp&gt;no&lt;/samp&gt;. In other words, this tests whether
         the build system type is different from the host system type
         (the target system type is irrelevant to this test).  , for more
         on support for cross compiling.
        </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;.
        </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, it uses
         &lt;TT&gt;/lib/cpp&lt;/TT&gt;. 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;

         If the current language is C (Language Choice), many of the
         specific test macros use the value of
         &lt;CODE&gt;CPP&lt;/CODE&gt; indirectly by calling
         &lt;CODE&gt;AC_TRY_CPP&lt;/CODE&gt;,
         &lt;CODE&gt;AC_CHECK_HEADER&lt;/CODE&gt;,
         &lt;CODE&gt;AC_EGREP_HEADER&lt;/CODE&gt;, or
         &lt;CODE&gt;AC_EGREP_CPP&lt;/CODE&gt;.
        </synopsis>
  </macro>
  <macro id="AC_PROG_CXX">
      <prototype>
      </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, set
         output variable &lt;CODE&gt;CXX&lt;/CODE&gt; to its value. 
         Otherwise search for a C++ compiler under likely names
         (&lt;CODE&gt;c++&lt;/CODE&gt;, &lt;CODE&gt;g++&lt;/CODE&gt;,
         &lt;CODE&gt;gcc&lt;/CODE&gt;, &lt;CODE&gt;CC&lt;/CODE&gt;,
         &lt;CODE&gt;cxx&lt;/CODE&gt;, and
         &lt;CODE&gt;cc++&lt;/CODE&gt;).  If none of those checks
         succeed, as a last resort set &lt;CODE&gt;CXX&lt;/CODE&gt; to
         &lt;CODE&gt;gcc&lt;/CODE&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;,
         empty otherwise.  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.&lt;/P&gt;&lt;P&gt;

         If the C++ compiler being used does not produce executables that
         can run on the system where &lt;CODE&gt;configure&lt;/CODE&gt;
         is being run, set the shell variable
         &lt;CODE&gt;cross_compiling&lt;/CODE&gt; to
         &lt;samp&gt;yes&lt;/samp&gt;, otherwise
         &lt;samp&gt;no&lt;/samp&gt;. In other words, this tests whether
         the build system type is different from the host system type
         (the target system type is irrelevant to this test).  , for more
         on support for cross compiling.
        </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, it uses
         &lt;TT&gt;/lib/cpp&lt;/TT&gt;. 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;

         If the current language is C++ (Language Choice), many of the
         specific test macros use the value of
         &lt;CODE&gt;CXXCPP&lt;/CODE&gt; indirectly by calling
         &lt;CODE&gt;AC_TRY_CPP&lt;/CODE&gt;,
         &lt;CODE&gt;AC_CHECK_HEADER&lt;/CODE&gt;,
         &lt;CODE&gt;AC_EGREP_HEADER&lt;/CODE&gt;, or
         &lt;CODE&gt;AC_EGREP_CPP&lt;/CODE&gt;.
        </synopsis>
  </macro>
  <macro id="AC_PROG_F77">
      <prototype>
      </prototype>
        <synopsis>
            Determine a Fortran 77 compiler to use.  If
         &lt;CODE&gt;F77&lt;/CODE&gt; is not already set in the
         environment, check for &lt;CODE&gt;g77&lt;/CODE&gt;,
         &lt;CODE&gt;f77&lt;/CODE&gt; and &lt;CODE&gt;f2c&lt;/CODE&gt;,
         in that order.  Set the output variable
         &lt;CODE&gt;F77&lt;/CODE&gt; to the name of the compiler found.&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;, and empty otherwise.  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_F77_C_O">
      <prototype>
      </prototype>
        <synopsis>
           Test if the Fortran 77 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; if it does not.
        </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_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 to not 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;

         A copy of &lt;TT&gt;install-sh&lt;/TT&gt; which you may use
         comes with Autoconf.  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 pathname
         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;.
        </synopsis>
  </macro>
  <macro id="AC_PROG_LN_S">
      <prototype>
      </prototype>
        <synopsis>
           If &lt;samp&gt;ln -s&lt;/samp&gt; works on the current
         filesystem (the operating system and filesystem support symbolic
         links), set output variable &lt;CODE&gt;LN_S&lt;/CODE&gt; to
         &lt;samp&gt;ln -s&lt;/samp&gt;, otherwise set it to
         &lt;samp&gt;ln&lt;/samp&gt;.&lt;/P&gt;&lt;P&gt;

         If the link is put 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, 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_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;
         for each file found, set to 1.
        </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; exists in
         &lt;CODE&gt;PATH&lt;/CODE&gt;.  If it 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 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_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_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 77 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 add
         &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).&lt;/P&gt;&lt;P&gt;

         If linking with &lt;VAR&gt;library&lt;/VAR&gt; results in
         unresolved symbols, which 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: &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.
        </synopsis>
  </macro>
  <macro id="AC_HAVE_LIBRARY">
      <prototype>
        <parameter content="library"/>
        <parameter content="["/>
        <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; can not be a shell variable; it
         must be a literal name. This macro is considered obsolete.
        </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;CODE&gt;AC_TRY_LINK_FUNC&lt;/CODE&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;

         If the function is found, run
         &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;

         If linking with &lt;VAR&gt;library&lt;/VAR&gt; results in
         unresolved symbols, which 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: &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>
             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_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_FNMATCH">
      <prototype>
      </prototype>
        <synopsis>
           If the &lt;CODE&gt;fnmatch&lt;/CODE&gt; function is available
         and works (unlike the one on SunOS 5.4), define
         &lt;CODE&gt;HAVE_FNMATCH&lt;/CODE&gt;.
        </synopsis>
  </macro>
  <macro id="AC_FUNC_GETLOADAVG">
      <prototype>
      </prototype>
        <synopsis>
                     Check how to get the system load averages.  If the
         system has the &lt;CODE&gt;getloadavg&lt;/CODE&gt; function,
         this macro defines &lt;CODE&gt;HAVE_GETLOADAVG&lt;/CODE&gt;, and
         adds to &lt;CODE&gt;LIBS&lt;/CODE&gt; any libraries needed to
         get that function.&lt;/P&gt;&lt;P&gt;

         Otherwise, it adds &lt;samp&gt;getloadavg.o&lt;/samp&gt; to the
         output variable &lt;CODE&gt;LIBOBJS&lt;/CODE&gt;, and possibly
         defines several other C preprocessor macros and output
         variables:&lt;/P&gt;&lt;P&gt;

         &lt;OL&gt; &lt;LI&gt; It defines &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; If it finds &lt;TT&gt;nlist.h&lt;/TT&gt;, it defines
         &lt;CODE&gt;NLIST_STRUCT&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&lt;/samp&gt; member, it defines
         &lt;CODE&gt;NLIST_NAME_UNION&lt;/CODE&gt;.&lt;/P&gt;&lt;P&gt;

         &lt;LI&gt; If compiling &lt;TT&gt;getloadavg.c&lt;/TT&gt;
         defines &lt;CODE&gt;LDAV_PRIVILEGED&lt;/CODE&gt;, programs need
         to be installed specially on this system for
         &lt;CODE&gt;getloadavg&lt;/CODE&gt; to work, and this macro
         defines &lt;CODE&gt;GETLOADAVG_PRIVILEGED&lt;/CODE&gt;.&lt;/P&gt;&lt;P&gt;

         &lt;LI&gt; This macro sets the output variable
         &lt;CODE&gt;NEED_SETGID&lt;/CODE&gt;.  The value is
         &lt;samp&gt;true&lt;/samp&gt; if special installation is
         required, &lt;samp&gt;false&lt;/samp&gt; if not. If
         &lt;CODE&gt;NEED_SETGID&lt;/CODE&gt; is
         &lt;samp&gt;true&lt;/samp&gt;, this macro sets
         &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>
           If &lt;CODE&gt;getpgrp&lt;/CODE&gt; takes no argument (the
         POSIX.1 version), define &lt;CODE&gt;GETPGRP_VOID&lt;/CODE&gt;. 
         Otherwise, it is the BSD version, which takes a process ID as an
         argument.  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_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), add &lt;samp&gt;memcmp.o&lt;/samp&gt; to output variable
         &lt;CODE&gt;LIBOBJS&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_SELECT_ARGTYPES">
      <prototype>
      </prototype>
        <synopsis>
             Determines the correct type to be passed to 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.1 version), define &lt;CODE&gt;SETPGRP_VOID&lt;/CODE&gt;. 
         Otherwise, it is the BSD version, which takes two process ID 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_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;.  This is the case on
         System V before release 3.
        </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;, which should not be used.
        </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_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_VFORK">
      <prototype>
      </prototype>
        <synopsis>
            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 not found, define
         &lt;CODE&gt;vfork&lt;/CODE&gt; to be
         &lt;CODE&gt;fork&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.
        </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_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;.
        </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_CPLUSPLUS&lt;/CODE&gt; has been called,
         since C++ is more standardized than C is.  (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 given &lt;VAR&gt;function&lt;/VAR&gt; in the
         whitespace-separated argument list that is available, define
         &lt;CODE&gt;HAVE_&lt;VAR&gt;function&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
         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_REPLACE_FUNCS">
      <prototype>
        <parameter content="function..."/>
      </prototype>
        <synopsis>
           Like calling &lt;CODE&gt;AC_CHECK_FUNCS&lt;/CODE&gt; using an
         &lt;VAR&gt;action-if-not-found&lt;/VAR&gt; that adds
         &lt;samp&gt;&lt;VAR&gt;function&lt;/VAR&gt;.o&lt;/samp&gt; to
         the value of the output variable
         &lt;CODE&gt;LIBOBJS&lt;/CODE&gt;.  You can declare a function
         for which your replacement version is used by enclosing the
         prototype in &lt;samp&gt;#ifndef
         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_DECL_SYS_SIGLIST">
      <prototype>
      </prototype>
        <synopsis>
           Define &lt;CODE&gt;SYS_SIGLIST_DECLARED&lt;/CODE&gt; if the
         variable &lt;CODE&gt;sys_siglist&lt;/CODE&gt; is declared in a
         system header file, either &lt;TT&gt;signal.h&lt;/TT&gt; or
         &lt;TT&gt;unistd.h&lt;/TT&gt;.
        </synopsis>
  </macro>
  <macro id="AC_DIR_HEADER">
      <prototype>
      </prototype>
        <synopsis>
               Like calling &lt;CODE&gt;AC_HEADER_DIRENT&lt;/CODE&gt; and
         &lt;CODE&gt;AC_FUNC_CLOSEDIR_VOID&lt;/CODE&gt;, but defines a
         different set of C preprocessor macros to indicate which header
         file is found.  This macro and the names it defines are
         considered obsolete.  The names it defines are:&lt;/P&gt;&lt;P&gt;

         @table @file &lt;LI&gt; dirent.h &lt;CODE&gt;DIRENT&lt;/CODE&gt;
         &lt;LI&gt; sys/ndir.h &lt;CODE&gt;SYSNDIR&lt;/CODE&gt;
         &lt;LI&gt; sys/dir.h &lt;CODE&gt;SYSDIR&lt;/CODE&gt; &lt;LI&gt;
         ndir.h &lt;CODE&gt;NDIR&lt;/CODE&gt; &lt;/DL&gt;&lt;/P&gt;&lt;P&gt;

         In addition, if the &lt;CODE&gt;closedir&lt;/CODE&gt; function
         does not return a meaningful value, define
         &lt;CODE&gt;VOID_CLOSEDIR&lt;/CODE&gt;.
        </synopsis>
  </macro>
  <macro id="AC_HEADER_DIRENT">
      <prototype>
      </prototype>
        <synopsis>
              Check for the following header files, and 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;

         @table @file &lt;LI&gt; dirent.h
         &lt;CODE&gt;HAVE_DIRENT_H&lt;/CODE&gt; &lt;LI&gt; sys/ndir.h
         &lt;CODE&gt;HAVE_SYS_NDIR_H&lt;/CODE&gt; &lt;LI&gt; sys/dir.h
         &lt;CODE&gt;HAVE_SYS_DIR_H&lt;/CODE&gt; &lt;LI&gt; ndir.h
         &lt;CODE&gt;HAVE_NDIR_H&lt;/CODE&gt; &lt;/DL&gt;&lt;/P&gt;&lt;P&gt;

         The directory library declarations in the 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 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>
            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_STDC">
      <prototype>
      </prototype>
        <synopsis>
           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;

         On systems without ANSI C headers, there is so much variation
         that it is probably easier to declare the functions you use than
         to figure out exactly what the system header files declare. 
         Some systems contain a mix of functions ANSI and BSD; some are
         mostly ANSI but lack &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.in&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 put 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 # ifndef HAVE_STRCHR #  define strchr
         index #  define strrchr rindex # endif char *strchr (), *strrchr
         (); # ifndef HAVE_MEMCPY #  define memcpy(d, s, n) bcopy ((s),
         (d), (n)) #  define memmove(d, s, n) bcopy ((s), (d), (n)) #
         endif #endif @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>
           If &lt;TT&gt;sys/wait.h&lt;/TT&gt; exists and is compatible
         with POSIX.1, 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.1 compatible, then instead of including it, define the
         POSIX.1 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_MEMORY_H">
      <prototype>
      </prototype>
        <synopsis>
           Define &lt;CODE&gt;NEED_MEMORY_H&lt;/CODE&gt; if
         &lt;CODE&gt;memcpy&lt;/CODE&gt;,
         &lt;CODE&gt;memcmp&lt;/CODE&gt;, etc. are not declared in
         &lt;TT&gt;string.h&lt;/TT&gt; and &lt;TT&gt;memory.h&lt;/TT&gt;
         exists.  This macro is obsolete; instead, use
         &lt;CODE&gt;AC_CHECK_HEADERS(memory.h)&lt;/CODE&gt;.  See the
         example for &lt;CODE&gt;AC_HEADER_STDC&lt;/CODE&gt;.
        </synopsis>
  </macro>
  <macro id="AC_UNISTD_H">
      <prototype>
      </prototype>
        <synopsis>
           Define &lt;CODE&gt;HAVE_UNISTD_H&lt;/CODE&gt; if the system
         has &lt;TT&gt;unistd.h&lt;/TT&gt;.  This macro is obsolete;
         instead, use
         &lt;samp&gt;AC_CHECK_HEADERS(unistd.h)&lt;/samp&gt;.&lt;/P&gt;&lt;P&gt;

         The way to check if the system supports POSIX.1 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; @group #if HAVE_UNISTD_H # include
         &lt;sys/types.h&gt; # include &lt;unistd.h&gt; #endif&lt;/P&gt;&lt;P&gt;

         #ifdef _POSIX_VERSION /* Code for POSIX.1 systems.  */ #endif
         @end group &lt;/pre&gt;&lt;/td&gt;&lt;/tr&gt;&lt;/table&gt;&lt;/P&gt;&lt;P&gt;

          &lt;CODE&gt;_POSIX_VERSION&lt;/CODE&gt; is defined when
         &lt;TT&gt;unistd.h&lt;/TT&gt; is included on POSIX.1 systems. 
         If there is no &lt;TT&gt;unistd.h&lt;/TT&gt;, it is definitely
         not a POSIX.1 system.  However, some non-POSIX.1 systems do have
         &lt;TT&gt;unistd.h&lt;/TT&gt;.
        </synopsis>
  </macro>
  <macro id="AC_USG">
      <prototype>
      </prototype>
        <synopsis>
           Define &lt;CODE&gt;USG&lt;/CODE&gt; if the system does not
         have &lt;TT&gt;strings.h&lt;/TT&gt;,
         &lt;CODE&gt;rindex&lt;/CODE&gt;, &lt;CODE&gt;bzero&lt;/CODE&gt;,
         etc.  This implies that it has &lt;TT&gt;string.h&lt;/TT&gt;,
         &lt;CODE&gt;strrchr&lt;/CODE&gt;,
         &lt;CODE&gt;memset&lt;/CODE&gt;, etc.&lt;/P&gt;&lt;P&gt;

         The symbol &lt;CODE&gt;USG&lt;/CODE&gt; is obsolete.  Instead of
         this macro, see the example for
         &lt;CODE&gt;AC_HEADER_STDC&lt;/CODE&gt;.
        </synopsis>
  </macro>
  <macro id="AC_CHECK_HEADER">
      <prototype>
        <parameter content="header-file"/>
        <parameter content="[action-if-found ["/>
        <parameter content="action-if-not-found]]"/>
      </prototype>
        <synopsis>
          If the system header file &lt;VAR&gt;header-file&lt;/VAR&gt;
         exists, 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.
        </synopsis>
  </macro>
  <macro id="AC_CHECK_HEADERS">
      <prototype>
        <parameter content="header-file... ["/>
        <parameter content="action-if-found ["/>
        <parameter content="action-if-not-found]]"/>
      </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.
        </synopsis>
  </macro>
  <macro id="AC_HEADER_STAT">
      <prototype>
      </prototype>
        <synopsis>
           If the macros &lt;CODE&gt;S_ISDIR&lt;/CODE&gt;,
         &lt;CODE&gt;S_ISREG&lt;/CODE&gt; et al. 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_TIME">
      <prototype>
      </prototype>
        <synopsis>
           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;
         or &lt;CODE&gt;struct timezone&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_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_ST_BLKSIZE&lt;/CODE&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_ST_BLOCKS&lt;/CODE&gt;.  Otherwise, add
         &lt;samp&gt;fileblocks.o&lt;/samp&gt; to the output variable
         &lt;CODE&gt;LIBOBJS&lt;/CODE&gt;.
        </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_ST_RDEV&lt;/CODE&gt;.
        </synopsis>
  </macro>
  <macro id="AC_STRUCT_TM">
      <prototype>
      </prototype>
        <synopsis>
           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_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_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_MODE_T">
      <prototype>
      </prototype>
        <synopsis>
           If &lt;CODE&gt;mode_t&lt;/CODE&gt; is not defined, define
         &lt;CODE&gt;mode_t&lt;/CODE&gt; to be
         &lt;CODE&gt;int&lt;/CODE&gt;.
        </synopsis>
  </macro>
  <macro id="AC_TYPE_OFF_T">
      <prototype>
      </prototype>
        <synopsis>
           If &lt;CODE&gt;off_t&lt;/CODE&gt; is not defined, define
         &lt;CODE&gt;off_t&lt;/CODE&gt; to be
         &lt;CODE&gt;long&lt;/CODE&gt;.
        </synopsis>
  </macro>
  <macro id="AC_TYPE_PID_T">
      <prototype>
      </prototype>
        <synopsis>
           If &lt;CODE&gt;pid_t&lt;/CODE&gt; is not defined, define
         &lt;CODE&gt;pid_t&lt;/CODE&gt; to be
         &lt;CODE&gt;int&lt;/CODE&gt;.
        </synopsis>
  </macro>
  <macro id="AC_TYPE_SIGNAL">
      <prototype>
      </prototype>
        <synopsis>
           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>
           If &lt;CODE&gt;size_t&lt;/CODE&gt; is not defined, define
         &lt;CODE&gt;size_t&lt;/CODE&gt; to be
         &lt;CODE&gt;unsigned&lt;/CODE&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="default"/>
      </prototype>
        <synopsis>
          If the type &lt;VAR&gt;type&lt;/VAR&gt; is not defined in
         &lt;TT&gt;sys/types.h&lt;/TT&gt;, or
         &lt;TT&gt;stdlib.h&lt;/TT&gt; or &lt;TT&gt;stddef.h&lt;/TT&gt;
         if they exist, define it to be the C (or C++) builtin type
         &lt;VAR&gt;default&lt;/VAR&gt;; e.g.,
         &lt;samp&gt;short&lt;/samp&gt; or
         &lt;samp&gt;unsigned&lt;/samp&gt;.
        </synopsis>
  </macro>
  <macro id="AC_C_BIGENDIAN">
      <prototype>
      </prototype>
        <synopsis>
           If words are stored with the most significant byte first (like
         Motorola and SPARC, but not Intel and VAX, CPUs), define
         &lt;CODE&gt;WORDS_BIGENDIAN&lt;/CODE&gt;.
        </synopsis>
  </macro>
  <macro id="AC_C_CONST">
      <prototype>
      </prototype>
        <synopsis>
           If the C compiler does not fully support the keyword
         &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.
        </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 the &lt;CODE&gt;long
         double&lt;/CODE&gt; type, define
         &lt;CODE&gt;HAVE_LONG_DOUBLE&lt;/CODE&gt;.  Some C compilers
         that do not define &lt;CODE&gt;__STDC__&lt;/CODE&gt; do support
         the &lt;CODE&gt;long double&lt;/CODE&gt; type; some compilers
         that define &lt;CODE&gt;__STDC__&lt;/CODE&gt; do not support
         &lt;CODE&gt;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_CHECK_SIZEOF">
      <prototype>
        <parameter content="type ["/>
        <parameter content="cross-size]"/>
      </prototype>
        <synopsis>
          Define
         &lt;CODE&gt;SIZEOF_&lt;VAR&gt;uctype&lt;/VAR&gt;&lt;/CODE&gt; to
         be the size in bytes of the C (or C++) builtin type
         &lt;VAR&gt;type&lt;/VAR&gt;, e.g. &lt;samp&gt;int&lt;/samp&gt;
         or &lt;samp&gt;char *&lt;/samp&gt;.  If
         &lt;samp&gt;type&lt;/samp&gt; is unknown to the compiler, it
         gets a size of 0.  &lt;VAR&gt;uctype&lt;/VAR&gt; is
         &lt;VAR&gt;type&lt;/VAR&gt;, with lowercase converted to
         uppercase, spaces changed to underscores, and asterisks changed
         to &lt;samp&gt;P&lt;/samp&gt;.  If cross-compiling, the value
         &lt;VAR&gt;cross-size&lt;/VAR&gt; is used if given, otherwise
         &lt;CODE&gt;configure&lt;/CODE&gt; exits with an error message.&lt;/P&gt;&lt;P&gt;

         For example, the 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_SIZEOF(int *)
         &lt;/pre&gt;&lt;/td&gt;&lt;/tr&gt;&lt;/table&gt;  defines
         &lt;CODE&gt;SIZEOF_INT_P&lt;/CODE&gt; to be 8 on DEC Alpha AXP
         systems.
        </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;. This macro is
         obsolete; it is more general to use
         &lt;samp&gt;AC_CHECK_SIZEOF(int)&lt;/samp&gt; instead.
        </synopsis>
  </macro>
  <macro id="AC_LONG_64_BITS">
      <prototype>
      </prototype>
        <synopsis>
           If the C type &lt;CODE&gt;long int&lt;/CODE&gt; is 64 bits
         wide, define &lt;CODE&gt;LONG_64_BITS&lt;/CODE&gt;.  This macro
         is obsolete; it is more general to use
         &lt;samp&gt;AC_CHECK_SIZEOF(long)&lt;/samp&gt; instead.
        </synopsis>
  </macro>
  <macro id="AC_F77_LIBRARY_LDFLAGS">
      <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 77 intrinsic
         and run-time libraries that are required to successfully link a
         Fortran 77 program or shared library.  The output variable
         &lt;CODE&gt;FLIBS&lt;/CODE&gt; is set to these flags.&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 77 source code into 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 77 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 77 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, the macro
         &lt;CODE&gt;AC_F77_LIBRARY_LDFLAGS&lt;/CODE&gt; was created to
         determine these Fortran 77 libraries.
        </synopsis>
  </macro>
  <macro id="AC_CYGWIN">
      <prototype>
      </prototype>
        <synopsis>
          Checks for the Cygwin environment.  If present, sets shell
         variable &lt;CODE&gt;CYGWIN&lt;/CODE&gt; to
         &lt;samp&gt;yes&lt;/samp&gt;.  If not present, sets
         &lt;CODE&gt;CYGWIN&lt;/CODE&gt; to the empty string.
        </synopsis>
  </macro>
  <macro id="AC_EXEEXT">
      <prototype>
      </prototype>
        <synopsis>
           Defines substitute variable &lt;CODE&gt;EXEEXT&lt;/CODE&gt;
         based on the output of the compiler, after .c, .o, and .obj
         files have been excluded.  Typically set to empty string if
         Unix, &lt;samp&gt;.exe&lt;/samp&gt; or
         &lt;samp&gt;.EXE&lt;/samp&gt; if Win32.
        </synopsis>
  </macro>
  <macro id="AC_OBJEXT">
      <prototype>
      </prototype>
        <synopsis>
           Defines substitute 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.
        </synopsis>
  </macro>
  <macro id="AC_MINGW32">
      <prototype>
      </prototype>
        <synopsis>
          Checks for the MingW32 compiler environment.  If present, sets
         shell variable &lt;CODE&gt;MINGW32&lt;/CODE&gt; to
         &lt;samp&gt;yes&lt;/samp&gt;.  If not present, sets
         &lt;CODE&gt;MINGW32&lt;/CODE&gt; to the empty string.
        </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 them 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;.  If X is not available, adds
         &lt;samp&gt;-DX_DISPLAY_MISSING&lt;/samp&gt; to
         &lt;CODE&gt;X_CFLAGS&lt;/CODE&gt;.&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;CODE&gt;configure.in&lt;/CODE&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_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_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;.
        </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_DYNIX_SEQ">
      <prototype>
      </prototype>
        <synopsis>
          If on Dynix/PTX (Sequent UNIX), add
         &lt;samp&gt;-lseq&lt;/samp&gt; to output variable
         &lt;CODE&gt;LIBS&lt;/CODE&gt;.  This macro is obsolete; instead,
         use &lt;CODE&gt;AC_FUNC_GETMNTENT&lt;/CODE&gt;.
        </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 variable
         &lt;CODE&gt;LIBS&lt;/CODE&gt;.  This macro is obsolete.  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;.
        </synopsis>
  </macro>
  <macro id="AC_ISC_POSIX">
      <prototype>
      </prototype>
        <synopsis>
            If on a POSIXized ISC UNIX, define
         &lt;CODE&gt;_POSIX_SOURCE&lt;/CODE&gt; and add
         &lt;samp&gt;-posix&lt;/samp&gt; (for the GNU C compiler) or
         &lt;samp&gt;-Xp&lt;/samp&gt; (for other C compilers) to output
         variable &lt;CODE&gt;CC&lt;/CODE&gt;.  This allows the use of
         POSIX facilities.  Must be called after
         &lt;CODE&gt;AC_PROG_CC&lt;/CODE&gt; and before any other macros
         that run the C compiler.
        </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_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 is obsolete;
         instead, use &lt;CODE&gt;AC_FUNC_STRFTIME&lt;/CODE&gt;.
        </synopsis>
  </macro>
  <macro id="AC_XENIX_DIR">
      <prototype>
      </prototype>
        <synopsis>
           If on Xenix, add &lt;samp&gt;-lx&lt;/samp&gt; to output
         variable &lt;CODE&gt;LIBS&lt;/CODE&gt;.  Also, if
         &lt;TT&gt;dirent.h&lt;/TT&gt; is being used, add
         &lt;samp&gt;-ldir&lt;/samp&gt; to &lt;CODE&gt;LIBS&lt;/CODE&gt;.
          This macro is obsolete; use
         &lt;CODE&gt;AC_HEADER_DIRENT&lt;/CODE&gt; instead.
        </synopsis>
  </macro>
  <macro id="AC_TRY_CPP">
      <prototype>
        <parameter content="includes"/>
        <parameter content="[action-if-true ["/>
        <parameter content="action-if-false]]"/>
      </prototype>
        <synopsis>
          &lt;VAR&gt;includes&lt;/VAR&gt; is C or C++
         &lt;CODE&gt;#include&lt;/CODE&gt; statements and declarations,
         on which shell variable, backquote, and backslash substitutions
         are performed.  (Actually, it can be any C program, but other
         statements are probably not useful.)  If the preprocessor
         produces no error messages while processing it, run shell
         commands &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;

         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.
        </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
         &lt;CODE&gt;egrep&lt;/CODE&gt; 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, backquote, and backslash
         substitutions are performed.  If the output of running the
         preprocessor on &lt;VAR&gt;program&lt;/VAR&gt; matches the
         &lt;CODE&gt;egrep&lt;/CODE&gt; 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;.&lt;/P&gt;&lt;P&gt;

         This macro calls &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, Language Choice), if it hasn't been called
         already.
        </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>
          Create a C, C++ or Fortran 77 test program (depending on which
         language is current, Language Choice), to see whether a function
         whose body consists of &lt;VAR&gt;function-body&lt;/VAR&gt; can
         be compiled.&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 77).  This macro also
         uses &lt;CODE&gt;CFLAGS&lt;/CODE&gt; or
         &lt;CODE&gt;CXXFLAGS&lt;/CODE&gt; if either C or C++ is the
         currently selected language, as well as
         &lt;CODE&gt;CPPFLAGS&lt;/CODE&gt;, when compiling.  If Fortran
         77 is the currently selected language then
         &lt;CODE&gt;FFLAGS&lt;/CODE&gt; will be used when compiling.&lt;/P&gt;&lt;P&gt;

         If the file compiles 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 does not try to link; use
         &lt;CODE&gt;AC_TRY_LINK&lt;/CODE&gt; if you need to do that
         (Examining Libraries).
        </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>
          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.&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 77).  This macro also
         uses &lt;CODE&gt;CFLAGS&lt;/CODE&gt; or
         &lt;CODE&gt;CXXFLAGS&lt;/CODE&gt; if either C or C++ is the
         currently selected language, as well as
         &lt;CODE&gt;CPPFLAGS&lt;/CODE&gt;, when compiling.  If Fortran
         77 is the currently selected language then
         &lt;CODE&gt;FFLAGS&lt;/CODE&gt; will be used when compiling. 
         However, both &lt;CODE&gt;LDFLAGS&lt;/CODE&gt; and
         &lt;CODE&gt;LIBS&lt;/CODE&gt; will be used during linking in all
         cases.&lt;/P&gt;&lt;P&gt;

         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;.
        </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>
          Depending on the current language (Language Choice), create a
         test program to see whether a program whose body consists of a
         prototype of and a call to &lt;VAR&gt;function&lt;/VAR&gt; can
         be compiled and linked.&lt;/P&gt;&lt;P&gt;

         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;.
        </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_LINK&lt;/CODE&gt;, 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_TRY_RUN">
      <prototype>
        <parameter content="program"/>
        <parameter content="[action-if-true ["/>
        <parameter content="action-if-false ["/>
        <parameter content="action-if-cross-compiling]]]"/>
      </prototype>
        <synopsis>
          &lt;VAR&gt;program&lt;/VAR&gt; is the text of a C program, on
         which shell variable and backquote substitutions are performed. 
         If it 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;; the exit status
         of the program is available in the shell variable
         &lt;samp&gt;$?&lt;/samp&gt;.  This macro uses
         &lt;CODE&gt;CFLAGS&lt;/CODE&gt; or
         &lt;CODE&gt;CXXFLAGS&lt;/CODE&gt;,
         &lt;CODE&gt;CPPFLAGS&lt;/CODE&gt;,
         &lt;CODE&gt;LDFLAGS&lt;/CODE&gt;, and
         &lt;CODE&gt;LIBS&lt;/CODE&gt; when compiling.&lt;/P&gt;&lt;P&gt;

         If the C 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.
        </synopsis>
  </macro>
  <macro id="AC_C_CROSS">
      <prototype>
      </prototype>
        <synopsis>
          This macro is obsolete; it does nothing.
        </synopsis>
  </macro>
  <macro id="AC_LANG_C">
      <prototype>
      </prototype>
        <synopsis>
          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.  Set the shell
         variable &lt;CODE&gt;cross_compiling&lt;/CODE&gt; to the value
         computed by &lt;CODE&gt;AC_PROG_CC&lt;/CODE&gt; if it has been
         run, empty otherwise.
        </synopsis>
  </macro>
  <macro id="AC_LANG_CPLUSPLUS">
      <prototype>
      </prototype>
        <synopsis>
          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.  Set the shell
         variable &lt;CODE&gt;cross_compiling&lt;/CODE&gt; to the value
         computed by &lt;CODE&gt;AC_PROG_CXX&lt;/CODE&gt; if it has been
         run, empty otherwise.
        </synopsis>
  </macro>
  <macro id="AC_LANG_FORTRAN77">
      <prototype>
      </prototype>
        <synopsis>
          Do compilation tests using &lt;CODE&gt;F77&lt;/CODE&gt; and use
         extension &lt;TT&gt;.f&lt;/TT&gt; for test programs.  Set the
         shell variable &lt;CODE&gt;cross_compiling&lt;/CODE&gt; to the
         value computed by &lt;CODE&gt;AC_PROG_F77&lt;/CODE&gt; if it has
         been run, empty otherwise.
        </synopsis>
  </macro>
  <macro id="AC_LANG_SAVE">
      <prototype>
      </prototype>
        <synopsis>
          Remember the current language (as set by
         &lt;CODE&gt;AC_LANG_C&lt;/CODE&gt;,
         &lt;CODE&gt;AC_LANG_CPLUSPLUS&lt;/CODE&gt; or
         &lt;CODE&gt;AC_LANG_FORTRAN77&lt;/CODE&gt;) on a stack.  Does
         not change which language is current.  Use this macro and
         &lt;CODE&gt;AC_LANG_RESTORE&lt;/CODE&gt; in macros that need to
         temporarily switch to a particular language.
        </synopsis>
  </macro>
  <macro id="AC_LANG_RESTORE">
      <prototype>
      </prototype>
        <synopsis>
          Select the language that is saved on the top of the stack, as
         set by &lt;CODE&gt;AC_LANG_SAVE&lt;/CODE&gt;, and remove it from
         the stack.  This macro is equivalent to either
         &lt;CODE&gt;AC_LANG_C&lt;/CODE&gt;,
         &lt;CODE&gt;AC_LANG_CPLUSPLUS&lt;/CODE&gt; or
         &lt;CODE&gt;AC_LANG_FORTRAN77&lt;/CODE&gt;, whichever had been
         run most recently when &lt;CODE&gt;AC_LANG_SAVE&lt;/CODE&gt; was
         last called.&lt;/P&gt;&lt;P&gt;

         Do not call this macro more times than
         &lt;CODE&gt;AC_LANG_SAVE&lt;/CODE&gt;.
        </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_DEFINE">
      <prototype>
        <parameter content="variable ["/>
        <parameter content="value ["/>
        <parameter content="description]]"/>
      </prototype>
        <synopsis>
          Define C preprocessor variable &lt;VAR&gt;variable&lt;/VAR&gt;.
          If &lt;VAR&gt;value&lt;/VAR&gt; is given, set
         &lt;VAR&gt;variable&lt;/VAR&gt; to that value (verbatim),
         otherwise set it to 1. &lt;VAR&gt;value&lt;/VAR&gt; should not
         contain literal newlines, and if you are not using
         &lt;CODE&gt;AC_CONFIG_HEADER&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 &lt;CODE&gt;m4&lt;/CODE&gt; 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_HEADER&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 macro need not be mentioned in
         &lt;TT&gt;acconfig.h&lt;/TT&gt;.  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;
        </synopsis>
  </macro>
  <macro id="AC_DEFINE_UNQUOTED">
      <prototype>
        <parameter content="variable ["/>
        <parameter content="value ["/>
        <parameter content="description]]"/>
      </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"/>
      </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.  The value of
         &lt;VAR&gt;variable&lt;/VAR&gt; should not contain literal
         newlines.
        </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.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; AC_SUBST_FILE(host_frag)dnl
         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_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;. Those commands should
         have no side effects except for setting the variable
         &lt;VAR&gt;cache-id&lt;/VAR&gt;.  In particular, they should not
         call &lt;CODE&gt;AC_DEFINE&lt;/CODE&gt;; the code that follows
         the call to &lt;CODE&gt;AC_CACHE_VAL&lt;/CODE&gt; should do
         that, based on the cached value.  Also, they should not print
         any messages, for example with
         &lt;CODE&gt;AC_MSG_CHECKING&lt;/CODE&gt;; do that before calling
         &lt;CODE&gt;AC_CACHE_VAL&lt;/CODE&gt;, so the messages are
         printed regardless of whether the results of the check are
         retrieved from the cache or determined by running the shell
         commands.  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.
        </synopsis>
  </macro>
  <macro id="AC_CACHE_CHECK">
      <prototype>
        <parameter content="message"/>
        <parameter content="cache-id"/>
        <parameter content="commands"/>
      </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;.
        </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
         configure.in.  Doing so checkpoints the cache in case of an
         early configure script abort.
        </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_ERROR">
      <prototype>
        <parameter content="error-description"/>
      </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 on the standard error output and exits
         &lt;CODE&gt;configure&lt;/CODE&gt; with a nonzero status.
         &lt;VAR&gt;error-description&lt;/VAR&gt; should be something
         like &lt;samp&gt;invalid value $HOME for \$HOME&lt;/samp&gt;.
        </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 on 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="AC_CHECKING">
      <prototype>
        <parameter content="feature-description"/>
      </prototype>
        <synopsis>
          This macro is similar to
         &lt;CODE&gt;AC_MSG_CHECKING&lt;/CODE&gt;, except that it prints
         a newline after the &lt;VAR&gt;feature-description&lt;/VAR&gt;. 
         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_CHECKING(if stack overflow is
         detectable) &lt;/pre&gt;&lt;/td&gt;&lt;/tr&gt;&lt;/table&gt;
        </synopsis>
  </macro>
  <macro id="AC_VERBOSE">
      <prototype>
        <parameter content="result-description"/>
      </prototype>
        <synopsis>
          This macro is similar to
         &lt;CODE&gt;AC_MSG_RESULT&lt;/CODE&gt;, except that it is meant
         to follow a call to &lt;CODE&gt;AC_CHECKING&lt;/CODE&gt; instead
         of &lt;CODE&gt;AC_MSG_CHECKING&lt;/CODE&gt;; it starts the
         message it prints with a tab.  It is considered obsolete.
        </synopsis>
  </macro>
  <macro id="AC_REQUIRE">
      <prototype>
        <parameter content="macro-name"/>
      </prototype>
        <synopsis>
          If the &lt;CODE&gt;m4&lt;/CODE&gt; 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.
        </synopsis>
  </macro>
  <macro id="AC_PROVIDE">
      <prototype>
        <parameter content="this-macro-name"/>
      </prototype>
        <synopsis>
          Record the fact that &lt;VAR&gt;this-macro-name&lt;/VAR&gt; has
         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_PROVIDE&lt;/CODE&gt;.  An easy way to get it is
         from the &lt;CODE&gt;m4&lt;/CODE&gt; builtin variable
         &lt;CODE&gt;$0&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_PROVIDE([$0])
         &lt;/pre&gt;&lt;/td&gt;&lt;/tr&gt;&lt;/table&gt;
        </synopsis>
  </macro>
  <macro id="AC_BEFORE">
      <prototype>
        <parameter content="this-macro-name"/>
        <parameter content="called-macro-name"/>
      </prototype>
        <synopsis>
          Make &lt;CODE&gt;m4&lt;/CODE&gt; print a warning message on 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="AC_OBSOLETE">
      <prototype>
        <parameter content="this-macro-name ["/>
        <parameter content="suggestion]"/>
      </prototype>
        <synopsis>
          Make &lt;CODE&gt;m4&lt;/CODE&gt; print a message on 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;.
        </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.
        </synopsis>
  </macro>
  <macro id="AC_CANONICAL_HOST">
      <prototype>
      </prototype>
        <synopsis>
          Perform only the subset of
         &lt;CODE&gt;AC_CANONICAL_SYSTEM&lt;/CODE&gt; relevant to the
         host type.  This is all that is needed for programs that are not
         part of a compiler toolchain.
        </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, execute &lt;VAR&gt;cmd&lt;/VAR&gt; or
         print a default error message.
        </synopsis>
  </macro>
  <macro id="AC_LINK_FILES">
      <prototype>
        <parameter content="source..."/>
        <parameter content="dest..."/>
      </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.  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 may be called multiple times.&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_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;

          creates in the current directory &lt;TT&gt;host.h&lt;/TT&gt;,
         which is a link to
         &lt;TT&gt;&lt;VAR&gt;srcdir&lt;/VAR&gt;/config/$machine@&lt;/TT&gt;.h,
         and &lt;TT&gt;object.h&lt;/TT&gt;, which is a link to
         &lt;TT&gt;&lt;VAR&gt;srcdir&lt;/VAR&gt;/config/$obj_format@&lt;/TT&gt;.h.
        </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 which 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;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 it in
         &lt;samp&gt;[&lt;/samp&gt; and &lt;samp&gt;]&lt;/samp&gt; in
         order to produce the leading spaces.
        </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).
        </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="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_SYSTEM&lt;/CODE&gt; has been called and
         a &lt;samp&gt;--target&lt;/samp&gt; value is given that differs
         from the host type (specified with
         &lt;samp&gt;--host&lt;/samp&gt; or defaulted by
         &lt;CODE&gt;config.sub&lt;/CODE&gt;), the target type followed
         by a dash is used as a prefix.  Otherwise, no program name
         transformation is done.
        </synopsis>
  </macro>
</macros>