build backports mostly

comm-release/patches/9999999-wikiico-25320.patch

@@ -0,0 +1,33 @@
+# HG changeset patch
+# User Frank-Rainer Grahl <frgrahl@gmx.net>
+# Date 1726159723 -7200
+# Parent  977092b0948ce214739cc84ecbffecaacf6cf08f
+Bug 9999999 - Update wikipedia search icon. r=mIanN a=IanN
+
+Adds an 48x48 image.
+
+diff --git a/suite/components/search/searchplugins/images/wikipedia.ico b/suite/components/search/searchplugins/images/wikipedia.ico
+index 4314071e24c026048339d5b466f4929db1f9ffc0..e70021849bdf154b79a9eb6fd1621e5c51571d40
+GIT binary patch
+literal 2734
+zc%1E4O-x)>6#gDRL#Z@x)C9x`GqDCpYTF4BH`qD`5<+62?jVhp4M8?z<AOjmWlRjP
+zFe7b3A{$yaD4U^`M0Pm35ElfP79?yY0y8jw??}-^G=}FnZ|3#QJZEBRjBY&1yXT&7
+z&bdG5p8MSa6qLf_ak4JM+YaDm0B(22j+X#4j5(bdyGa4YDuE{U@$lEjpWuc#@JO6l
+zttbj=YHE0V4>~$J(9_d{fq?-G4Gm#@d>m6#Q<$5Z!{Xv1mY0{YwY7zKJdTr-6C+;N
+z^%JtmkGhB*6)EJMjVJ_jKtXp7cwD?NY{|Dv(rQ=j_-&uGafc1oJkN^SP*(Ht6v{<S
+zB9M=706~uG*3akTYx<Lyh>}o#&BxzShbxITaq9W}X<ZMOnj>@<=dUm2;s=LibUQ#^
+z1j3hd@g236_Uh6&T8&lZ;vegmDODcTD=1x-i#ruww|5e+aGSHUB#yWZ0Y0Ly-m>sr
+zwSwCiO4xU=&cg3Oj3^{)iC-+-3keRXhU-%i6HYrJ{cb!bmOo(P`|8i~t4lF*8oprS
+z_x0b6X&tWxW$%?H?uTstYqjof7weR{GwoGflGTSBF>%$5C|Q|Hc9p)UL{d-7{PVsH
+zzN!Bvlj9W8=nVHBoXg;!9?Ic;A$z;`BKP8%ooQakbbUI9Z#a0MM5ZXdKNQb|3pa?q
+zk$N})A2ogH=1ccp@(T3wneROK=_Bqc?-MnjZEtUG*p>F&t+VZI(rtTz{ww*X?p?8a
+zU6cok@kSAzF<596I25e{KZvdXLZV9nzd>?;*8fYs_@yb3r;zAUE3amr&AiJy<L1u`
+z>z(nJSmWltGu74AXl!gmOG}IK*7WxFqQAc%!^6Xvn3%xy^fZFOAXZjZjCUrHNaVaT
+zwtBD?h^;v6^;nqyxA?ZE1D4&#^t5~Wk*R@6bKWAz10i>hx@y|tqxsb&KJ=OPWaX|e
+z`Y?IMw4L?Is<mT!CTk`S1JrP>o<7LhdrE}vFfpvpWb8Z4Cp(PoXDPg!2U=$eO=VV;
+z7V;bwN`1+&V^}54d4*RqZ>(s&OjdZGopy{BjWUacE0RwzDtxQCc-ZS_h$%&5W}~<s
+zBu(|ve30l3&O=z`nVBfpnA)zrNqeeZP8apsxJ#e8rRzDQ|M%pt&c}Y9_VebtQ@IvP
+zxh@s|zi@-id1OwRyD3}C?wmRg<@nqGPf4A(wzi_PvlD}ZgBTeZ!PwZC@qcP|b`}c@
+z3r3x9Z*OCNf8VO}?1r=X;kr!|8878dAl4;%vTMCnbi?QGZn8>NMQda15bcW9r+oZA
+xFYR6+c5I`YpV23zoz|M7kv&>Cjvha_bo2Eh=VInx50ygoD{{jh?~@pb{R8uC6lDMa
+

comm-release/patches/series

@@ -2189,3 +2189,4 @@ TOP-1906540-mozdevice-removal-comm-25320.patch
 1913633-mar-channel-ids-25320.patch
 1897801-2-about-seamonkey-25320.patch
 1656564-fix-themes-browseURL-25320.patch
+9999999-wikiico-25320.patch

mozilla-release/patches/1541792_PARTIAL-68a1.patch

@@ -0,0 +1,70 @@
+# HG changeset patch
+# User Mike Hommey <mh+mozilla@glandium.org>
+# Date 1554431456 0
+# Node ID 60669a841a87644ba9b2f4d9f17f225e2eca0980
+# Parent  c4bbbe847264a06d65632ec40dca84c9e4bde656
+Bug 1541792 - Replace linker magic with manual component registration. r=froydnj
+
+Before bug 938437, we had a rather large and error-prone
+nsStaticXULComponents.cpp used to register all modules. That was
+replaced with clever use of the linker, which allowed to avoid the mess
+that maintaining that file was.
+
+Fast forward to now, where after bug 1524687 and other work that
+preceded it, we have a much smaller number of remaining static xpcom
+components, registered via this linker hack, and don't expect to add
+any new ones. The list should eventually go down to zero.
+
+Within that context, it seems to be the right time to get rid of the
+magic, and with it the problems it causes on its own.
+
+Some of those components could probably be trivially be converted to
+static registration via .conf files, but I didn't want to deal with the
+possible need to increase the number of dummy modules in XPCOMInit.cpp.
+They can still be converted as a followup.
+
+Differential Revision: https://phabricator.services.mozilla.com/D26076
+
+diff --git a/toolkit/library/StaticXULComponents.ld b/toolkit/library/StaticXULComponents.ld
+deleted file mode 100644
+--- a/toolkit/library/StaticXULComponents.ld
++++ /dev/null
+@@ -1,7 +0,0 @@
+-SECTIONS {
+-  .data.rel.ro : {
+-    PROVIDE_HIDDEN(__start_kPStaticModules = .);
+-    *(kPStaticModules)
+-    PROVIDE_HIDDEN(__stop_kPStaticModules = .);
+-  }
+-}
+diff --git a/toolkit/library/moz.build b/toolkit/library/moz.build
+--- a/toolkit/library/moz.build
++++ b/toolkit/library/moz.build
+@@ -47,27 +47,16 @@ def Libxul(name, output_category=None):
+ 
+     if CONFIG['OS_ARCH'] == 'WINNT' and CONFIG['CC_TYPE'] not in ('clang', 'gcc'):
+         LOCAL_INCLUDES += [
+             '/widget/windows',
+             '/xpcom/base',
+         ]
+         RCINCLUDE = '/toolkit/library/xulrunner.rc'
+ 
+-    # BFD ld doesn't create multiple PT_LOADs as usual when an unknown section
+-    # exists. Using an implicit linker script to make it fold that section in
+-    # .data.rel.ro makes it create multiple PT_LOADs. That implicit linker
+-    # script however makes gold misbehave, first because it doesn't like that
+-    # the linker script is given after crtbegin.o, and even past that, replaces
+-    # the default section rules with those from the script instead of
+-    # supplementing them. Which leads to a lib with a huge load of sections.
+-    if CONFIG['OS_TARGET'] not in ('OpenBSD', 'WINNT') and \
+-            CONFIG['LINKER_KIND'] == 'bfd':
+-        LDFLAGS += [TOPSRCDIR + '/toolkit/library/StaticXULComponents.ld']
+-
+     Libxul_defines()
+ 
+     if CONFIG['MOZ_NEEDS_LIBATOMIC']:
+         OS_LIBS += ['atomic']
+ 
+     # This option should go away in bug 1290972, but we need to wait until
+     # Rust 1.12 has been released.
+     # We're also linking against libresolv to solve bug 1367932.

mozilla-release/patches/1663863-82a1.patch

@@ -0,0 +1,5834 @@
+# HG changeset patch
+# User Mike Hommey <mh+mozilla@glandium.org>
+# Date 1599695438 0
+# Node ID b9222eba403fdf6482ccc1132ae047da61a989ab
+# Parent  3318872835958dea4cbe2d14e302c399ee4cc68b
+Bug 1663863 - Vendor autoconf 2.13. r=firefox-build-system-reviewers,rstewart
+
+The files are copied verbatim from upstream autoconf 2.13 (but only the
+files we need) and old.configure is adapted to use the vendored version.
+
+Differential Revision: https://phabricator.services.mozilla.com/D89554
+
+diff --git a/build/autoconf/acgeneral.m4 b/build/autoconf/acgeneral.m4
+new file mode 100644
+--- /dev/null
++++ b/build/autoconf/acgeneral.m4
+@@ -0,0 +1,2607 @@
++dnl Parameterized macros.
++dnl Requires GNU m4.
++dnl This file is part of Autoconf.
++dnl Copyright (C) 1992, 93, 94, 95, 96, 1998 Free Software Foundation, Inc.
++dnl
++dnl This program is free software; you can redistribute it and/or modify
++dnl it under the terms of the GNU General Public License as published by
++dnl the Free Software Foundation; either version 2, or (at your option)
++dnl any later version.
++dnl
++dnl This program is distributed in the hope that it will be useful,
++dnl but WITHOUT ANY WARRANTY; without even the implied warranty of
++dnl MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
++dnl GNU General Public License for more details.
++dnl
++dnl You should have received a copy of the GNU General Public License
++dnl along with this program; if not, write to the Free Software
++dnl Foundation, Inc., 59 Temple Place - Suite 330, Boston, MA
++dnl 02111-1307, USA.
++dnl
++dnl As a special exception, the Free Software Foundation gives unlimited
++dnl permission to copy, distribute and modify the configure scripts that
++dnl are the output of Autoconf.  You need not follow the terms of the GNU
++dnl General Public License when using or distributing such scripts, even
++dnl though portions of the text of Autoconf appear in them.  The GNU
++dnl General Public License (GPL) does govern all other use of the material
++dnl that constitutes the Autoconf program.
++dnl
++dnl Certain portions of the Autoconf source text are designed to be copied
++dnl (in certain cases, depending on the input) into the output of
++dnl Autoconf.  We call these the "data" portions.  The rest of the Autoconf
++dnl source text consists of comments plus executable code that decides which
++dnl of the data portions to output in any given case.  We call these
++dnl comments and executable code the "non-data" portions.  Autoconf never
++dnl copies any of the non-data portions into its output.
++dnl
++dnl This special exception to the GPL applies to versions of Autoconf
++dnl released by the Free Software Foundation.  When you make and
++dnl distribute a modified version of Autoconf, you may extend this special
++dnl exception to the GPL to apply to your modified version as well, *unless*
++dnl your modified version has the potential to copy into its output some
++dnl of the text that was the non-data portion of the version that you started
++dnl with.  (In other words, unless your change moves or copies text from
++dnl the non-data portions to the data portions.)  If your modification has
++dnl such potential, you must delete any notice of this special exception
++dnl to the GPL from your modified version.
++dnl
++dnl Written by David MacKenzie, with help from
++dnl Franc,ois Pinard, Karl Berry, Richard Pixley, Ian Lance Taylor,
++dnl Roland McGrath, Noah Friedman, david d zuhn, and many others.
++dnl
++divert(-1)dnl Throw away output until AC_INIT is called.
++changequote([, ])
++
++define(AC_ACVERSION, 2.13)
++
++dnl Some old m4's don't support m4exit.  But they provide
++dnl equivalent functionality by core dumping because of the
++dnl long macros we define.
++ifdef([__gnu__], , [errprint(Autoconf requires GNU m4.
++Install it before installing Autoconf or set the
++M4 environment variable to its path name.
++)m4exit(2)])
++
++undefine([eval])
++undefine([include])
++undefine([shift])
++undefine([format])
++
++
++dnl ### Defining macros
++
++
++dnl m4 output diversions.  We let m4 output them all in order at the end,
++dnl except that we explicitly undivert AC_DIVERSION_SED, AC_DIVERSION_CMDS,
++dnl and AC_DIVERSION_ICMDS.
++
++dnl AC_DIVERSION_NOTICE - 1 (= 0)	AC_REQUIRE'd #! /bin/sh line
++define(AC_DIVERSION_NOTICE, 1)dnl	copyright notice & option help strings
++define(AC_DIVERSION_INIT, 2)dnl		initialization code
++define(AC_DIVERSION_NORMAL_4, 3)dnl	AC_REQUIRE'd code, 4 level deep
++define(AC_DIVERSION_NORMAL_3, 4)dnl	AC_REQUIRE'd code, 3 level deep
++define(AC_DIVERSION_NORMAL_2, 5)dnl	AC_REQUIRE'd code, 2 level deep
++define(AC_DIVERSION_NORMAL_1, 6)dnl	AC_REQUIRE'd code, 1 level deep
++define(AC_DIVERSION_NORMAL, 7)dnl	the tests and output code
++define(AC_DIVERSION_SED, 8)dnl		variable substitutions in config.status
++define(AC_DIVERSION_CMDS, 9)dnl		extra shell commands in config.status
++define(AC_DIVERSION_ICMDS, 10)dnl	extra initialization in config.status
++
++dnl Change the diversion stream to STREAM, while stacking old values.
++dnl AC_DIVERT_PUSH(STREAM)
++define(AC_DIVERT_PUSH,
++[pushdef([AC_DIVERSION_CURRENT], $1)dnl
++divert(AC_DIVERSION_CURRENT)dnl
++])
++
++dnl Change the diversion stream to its previous value, unstacking it.
++dnl AC_DIVERT_POP()
++define(AC_DIVERT_POP,
++[popdef([AC_DIVERSION_CURRENT])dnl
++divert(AC_DIVERSION_CURRENT)dnl
++])
++
++dnl Initialize the diversion setup.
++define([AC_DIVERSION_CURRENT], AC_DIVERSION_NORMAL)
++dnl This will be popped by AC_REQUIRE in AC_INIT.
++pushdef([AC_DIVERSION_CURRENT], AC_DIVERSION_NOTICE)
++
++dnl The prologue for Autoconf macros.
++dnl AC_PRO(MACRO-NAME)
++define(AC_PRO,
++[define([AC_PROVIDE_$1], )dnl
++ifelse(AC_DIVERSION_CURRENT, AC_DIVERSION_NORMAL,
++[AC_DIVERT_PUSH(builtin(eval, AC_DIVERSION_CURRENT - 1))],
++[pushdef([AC_DIVERSION_CURRENT], AC_DIVERSION_CURRENT)])dnl
++])
++
++dnl The Epilogue for Autoconf macros.
++dnl AC_EPI()
++define(AC_EPI,
++[AC_DIVERT_POP()dnl
++ifelse(AC_DIVERSION_CURRENT, AC_DIVERSION_NORMAL,
++[undivert(AC_DIVERSION_NORMAL_4)dnl
++undivert(AC_DIVERSION_NORMAL_3)dnl
++undivert(AC_DIVERSION_NORMAL_2)dnl
++undivert(AC_DIVERSION_NORMAL_1)dnl
++])dnl
++])
++
++dnl Define a macro which automatically provides itself.  Add machinery
++dnl so the macro automatically switches expansion to the diversion
++dnl stack if it is not already using it.  In this case, once finished,
++dnl it will bring back all the code accumulated in the diversion stack.
++dnl This, combined with AC_REQUIRE, achieves the topological ordering of
++dnl macros.  We don't use this macro to define some frequently called
++dnl macros that are not involved in ordering constraints, to save m4
++dnl processing.
++dnl AC_DEFUN(NAME, EXPANSION)
++define([AC_DEFUN],
++[define($1, [AC_PRO([$1])$2[]AC_EPI()])])
++
++
++dnl ### Initialization
++
++
++dnl AC_INIT_NOTICE()
++AC_DEFUN(AC_INIT_NOTICE,
++[# Guess values for system-dependent variables and create Makefiles.
++# Generated automatically using autoconf version] AC_ACVERSION [
++# Copyright (C) 1992, 93, 94, 95, 96 Free Software Foundation, Inc.
++#
++# This configure script is free software; the Free Software Foundation
++# gives unlimited permission to copy, distribute and modify it.
++
++# Defaults:
++ac_help=
++ac_default_prefix=/usr/local
++[#] Any additions from configure.in:])
++
++dnl AC_PREFIX_DEFAULT(PREFIX)
++AC_DEFUN(AC_PREFIX_DEFAULT,
++[AC_DIVERT_PUSH(AC_DIVERSION_NOTICE)dnl
++ac_default_prefix=$1
++AC_DIVERT_POP()])
++
++dnl AC_INIT_PARSE_ARGS()
++AC_DEFUN(AC_INIT_PARSE_ARGS,
++[
++# Initialize some variables set by options.
++# The variables have the same names as the options, with
++# dashes changed to underlines.
++build=NONE
++cache_file=./config.cache
++exec_prefix=NONE
++host=NONE
++no_create=
++nonopt=NONE
++no_recursion=
++prefix=NONE
++program_prefix=NONE
++program_suffix=NONE
++program_transform_name=s,x,x,
++silent=
++site=
++srcdir=
++target=NONE
++verbose=
++x_includes=NONE
++x_libraries=NONE
++dnl Installation directory options.
++dnl These are left unexpanded so users can "make install exec_prefix=/foo"
++dnl and all the variables that are supposed to be based on exec_prefix
++dnl by default will actually change.
++dnl Use braces instead of parens because sh, perl, etc. also accept them.
++bindir='${exec_prefix}/bin'
++sbindir='${exec_prefix}/sbin'
++libexecdir='${exec_prefix}/libexec'
++datadir='${prefix}/share'
++sysconfdir='${prefix}/etc'
++sharedstatedir='${prefix}/com'
++localstatedir='${prefix}/var'
++libdir='${exec_prefix}/lib'
++includedir='${prefix}/include'
++oldincludedir='/usr/include'
++infodir='${prefix}/info'
++mandir='${prefix}/man'
++
++# Initialize some other variables.
++subdirs=
++MFLAGS= MAKEFLAGS=
++SHELL=${CONFIG_SHELL-/bin/sh}
++# Maximum number of lines to put in a shell here document.
++ac_max_here_lines=12
++
++ac_prev=
++for ac_option
++do
++
++  # If the previous option needs an argument, assign it.
++  if test -n "$ac_prev"; then
++    eval "$ac_prev=\$ac_option"
++    ac_prev=
++    continue
++  fi
++
++  case "$ac_option" in
++changequote(, )dnl
++  -*=*) ac_optarg=`echo "$ac_option" | sed 's/[-_a-zA-Z0-9]*=//'` ;;
++changequote([, ])dnl
++  *) ac_optarg= ;;
++  esac
++
++  # Accept the important Cygnus configure options, so we can diagnose typos.
++
++  case "$ac_option" in
++
++  -bindir | --bindir | --bindi | --bind | --bin | --bi)
++    ac_prev=bindir ;;
++  -bindir=* | --bindir=* | --bindi=* | --bind=* | --bin=* | --bi=*)
++    bindir="$ac_optarg" ;;
++
++  -build | --build | --buil | --bui | --bu)
++    ac_prev=build ;;
++  -build=* | --build=* | --buil=* | --bui=* | --bu=*)
++    build="$ac_optarg" ;;
++
++  -cache-file | --cache-file | --cache-fil | --cache-fi \
++  | --cache-f | --cache- | --cache | --cach | --cac | --ca | --c)
++    ac_prev=cache_file ;;
++  -cache-file=* | --cache-file=* | --cache-fil=* | --cache-fi=* \
++  | --cache-f=* | --cache-=* | --cache=* | --cach=* | --cac=* | --ca=* | --c=*)
++    cache_file="$ac_optarg" ;;
++
++  -datadir | --datadir | --datadi | --datad | --data | --dat | --da)
++    ac_prev=datadir ;;
++  -datadir=* | --datadir=* | --datadi=* | --datad=* | --data=* | --dat=* \
++  | --da=*)
++    datadir="$ac_optarg" ;;
++
++  -disable-* | --disable-*)
++    ac_feature=`echo $ac_option|sed -e 's/-*disable-//'`
++    # Reject names that are not valid shell variable names.
++changequote(, )dnl
++    if test -n "`echo $ac_feature| sed 's/[-a-zA-Z0-9_]//g'`"; then
++changequote([, ])dnl
++      AC_MSG_ERROR($ac_feature: invalid feature name)
++    fi
++    ac_feature=`echo $ac_feature| sed 's/-/_/g'`
++    eval "enable_${ac_feature}=no" ;;
++
++  -enable-* | --enable-*)
++    ac_feature=`echo $ac_option|sed -e 's/-*enable-//' -e 's/=.*//'`
++    # Reject names that are not valid shell variable names.
++changequote(, )dnl
++    if test -n "`echo $ac_feature| sed 's/[-_a-zA-Z0-9]//g'`"; then
++changequote([, ])dnl
++      AC_MSG_ERROR($ac_feature: invalid feature name)
++    fi
++    ac_feature=`echo $ac_feature| sed 's/-/_/g'`
++    case "$ac_option" in
++      *=*) ;;
++      *) ac_optarg=yes ;;
++    esac
++    eval "enable_${ac_feature}='$ac_optarg'" ;;
++
++  -exec-prefix | --exec_prefix | --exec-prefix | --exec-prefi \
++  | --exec-pref | --exec-pre | --exec-pr | --exec-p | --exec- \
++  | --exec | --exe | --ex)
++    ac_prev=exec_prefix ;;
++  -exec-prefix=* | --exec_prefix=* | --exec-prefix=* | --exec-prefi=* \
++  | --exec-pref=* | --exec-pre=* | --exec-pr=* | --exec-p=* | --exec-=* \
++  | --exec=* | --exe=* | --ex=*)
++    exec_prefix="$ac_optarg" ;;
++
++  -gas | --gas | --ga | --g)
++    # Obsolete; use --with-gas.
++    with_gas=yes ;;
++
++  -help | --help | --hel | --he)
++    # Omit some internal or obsolete options to make the list less imposing.
++    # This message is too long to be a string in the A/UX 3.1 sh.
++    cat << EOF
++changequote(, )dnl
++Usage: configure [options] [host]
++Options: [defaults in brackets after descriptions]
++Configuration:
++  --cache-file=FILE       cache test results in FILE
++  --help                  print this message
++  --no-create             do not create output files
++  --quiet, --silent       do not print \`checking...' messages
++  --version               print the version of autoconf that created configure
++Directory and file names:
++  --prefix=PREFIX         install architecture-independent files in PREFIX
++                          [$ac_default_prefix]
++  --exec-prefix=EPREFIX   install architecture-dependent files in EPREFIX
++                          [same as prefix]
++  --bindir=DIR            user executables in DIR [EPREFIX/bin]
++  --sbindir=DIR           system admin executables in DIR [EPREFIX/sbin]
++  --libexecdir=DIR        program executables in DIR [EPREFIX/libexec]
++  --datadir=DIR           read-only architecture-independent data in DIR
++                          [PREFIX/share]
++  --sysconfdir=DIR        read-only single-machine data in DIR [PREFIX/etc]
++  --sharedstatedir=DIR    modifiable architecture-independent data in DIR
++                          [PREFIX/com]
++  --localstatedir=DIR     modifiable single-machine data in DIR [PREFIX/var]
++  --libdir=DIR            object code libraries in DIR [EPREFIX/lib]
++  --includedir=DIR        C header files in DIR [PREFIX/include]
++  --oldincludedir=DIR     C header files for non-gcc in DIR [/usr/include]
++  --infodir=DIR           info documentation in DIR [PREFIX/info]
++  --mandir=DIR            man documentation in DIR [PREFIX/man]
++  --srcdir=DIR            find the sources in DIR [configure dir or ..]
++  --program-prefix=PREFIX prepend PREFIX to installed program names
++  --program-suffix=SUFFIX append SUFFIX to installed program names
++  --program-transform-name=PROGRAM
++                          run sed PROGRAM on installed program names
++EOF
++    cat << EOF
++Host type:
++  --build=BUILD           configure for building on BUILD [BUILD=HOST]
++  --host=HOST             configure for HOST [guessed]
++  --target=TARGET         configure for TARGET [TARGET=HOST]
++Features and packages:
++  --disable-FEATURE       do not include FEATURE (same as --enable-FEATURE=no)
++  --enable-FEATURE[=ARG]  include FEATURE [ARG=yes]
++  --with-PACKAGE[=ARG]    use PACKAGE [ARG=yes]
++  --without-PACKAGE       do not use PACKAGE (same as --with-PACKAGE=no)
++  --x-includes=DIR        X include files are in DIR
++  --x-libraries=DIR       X library files are in DIR
++changequote([, ])dnl
++EOF
++    if test -n "$ac_help"; then
++      echo "--enable and --with options recognized:$ac_help"
++    fi
++    exit 0 ;;
++
++  -host | --host | --hos | --ho)
++    ac_prev=host ;;
++  -host=* | --host=* | --hos=* | --ho=*)
++    host="$ac_optarg" ;;
++
++  -includedir | --includedir | --includedi | --included | --include \
++  | --includ | --inclu | --incl | --inc)
++    ac_prev=includedir ;;
++  -includedir=* | --includedir=* | --includedi=* | --included=* | --include=* \
++  | --includ=* | --inclu=* | --incl=* | --inc=*)
++    includedir="$ac_optarg" ;;
++
++  -infodir | --infodir | --infodi | --infod | --info | --inf)
++    ac_prev=infodir ;;
++  -infodir=* | --infodir=* | --infodi=* | --infod=* | --info=* | --inf=*)
++    infodir="$ac_optarg" ;;
++
++  -libdir | --libdir | --libdi | --libd)
++    ac_prev=libdir ;;
++  -libdir=* | --libdir=* | --libdi=* | --libd=*)
++    libdir="$ac_optarg" ;;
++
++  -libexecdir | --libexecdir | --libexecdi | --libexecd | --libexec \
++  | --libexe | --libex | --libe)
++    ac_prev=libexecdir ;;
++  -libexecdir=* | --libexecdir=* | --libexecdi=* | --libexecd=* | --libexec=* \
++  | --libexe=* | --libex=* | --libe=*)
++    libexecdir="$ac_optarg" ;;
++
++  -localstatedir | --localstatedir | --localstatedi | --localstated \
++  | --localstate | --localstat | --localsta | --localst \
++  | --locals | --local | --loca | --loc | --lo)
++    ac_prev=localstatedir ;;
++  -localstatedir=* | --localstatedir=* | --localstatedi=* | --localstated=* \
++  | --localstate=* | --localstat=* | --localsta=* | --localst=* \
++  | --locals=* | --local=* | --loca=* | --loc=* | --lo=*)
++    localstatedir="$ac_optarg" ;;
++
++  -mandir | --mandir | --mandi | --mand | --man | --ma | --m)
++    ac_prev=mandir ;;
++  -mandir=* | --mandir=* | --mandi=* | --mand=* | --man=* | --ma=* | --m=*)
++    mandir="$ac_optarg" ;;
++
++  -nfp | --nfp | --nf)
++    # Obsolete; use --without-fp.
++    with_fp=no ;;
++
++  -no-create | --no-create | --no-creat | --no-crea | --no-cre \
++  | --no-cr | --no-c)
++    no_create=yes ;;
++
++  -no-recursion | --no-recursion | --no-recursio | --no-recursi \
++  | --no-recurs | --no-recur | --no-recu | --no-rec | --no-re | --no-r)
++    no_recursion=yes ;;
++
++  -oldincludedir | --oldincludedir | --oldincludedi | --oldincluded \
++  | --oldinclude | --oldinclud | --oldinclu | --oldincl | --oldinc \
++  | --oldin | --oldi | --old | --ol | --o)
++    ac_prev=oldincludedir ;;
++  -oldincludedir=* | --oldincludedir=* | --oldincludedi=* | --oldincluded=* \
++  | --oldinclude=* | --oldinclud=* | --oldinclu=* | --oldincl=* | --oldinc=* \
++  | --oldin=* | --oldi=* | --old=* | --ol=* | --o=*)
++    oldincludedir="$ac_optarg" ;;
++
++  -prefix | --prefix | --prefi | --pref | --pre | --pr | --p)
++    ac_prev=prefix ;;
++  -prefix=* | --prefix=* | --prefi=* | --pref=* | --pre=* | --pr=* | --p=*)
++    prefix="$ac_optarg" ;;
++
++  -program-prefix | --program-prefix | --program-prefi | --program-pref \
++  | --program-pre | --program-pr | --program-p)
++    ac_prev=program_prefix ;;
++  -program-prefix=* | --program-prefix=* | --program-prefi=* \
++  | --program-pref=* | --program-pre=* | --program-pr=* | --program-p=*)
++    program_prefix="$ac_optarg" ;;
++
++  -program-suffix | --program-suffix | --program-suffi | --program-suff \
++  | --program-suf | --program-su | --program-s)
++    ac_prev=program_suffix ;;
++  -program-suffix=* | --program-suffix=* | --program-suffi=* \
++  | --program-suff=* | --program-suf=* | --program-su=* | --program-s=*)
++    program_suffix="$ac_optarg" ;;
++
++  -program-transform-name | --program-transform-name \
++  | --program-transform-nam | --program-transform-na \
++  | --program-transform-n | --program-transform- \
++  | --program-transform | --program-transfor \
++  | --program-transfo | --program-transf \
++  | --program-trans | --program-tran \
++  | --progr-tra | --program-tr | --program-t)
++    ac_prev=program_transform_name ;;
++  -program-transform-name=* | --program-transform-name=* \
++  | --program-transform-nam=* | --program-transform-na=* \
++  | --program-transform-n=* | --program-transform-=* \
++  | --program-transform=* | --program-transfor=* \
++  | --program-transfo=* | --program-transf=* \
++  | --program-trans=* | --program-tran=* \
++  | --progr-tra=* | --program-tr=* | --program-t=*)
++    program_transform_name="$ac_optarg" ;;
++
++  -q | -quiet | --quiet | --quie | --qui | --qu | --q \
++  | -silent | --silent | --silen | --sile | --sil)
++    silent=yes ;;
++
++  -sbindir | --sbindir | --sbindi | --sbind | --sbin | --sbi | --sb)
++    ac_prev=sbindir ;;
++  -sbindir=* | --sbindir=* | --sbindi=* | --sbind=* | --sbin=* \
++  | --sbi=* | --sb=*)
++    sbindir="$ac_optarg" ;;
++
++  -sharedstatedir | --sharedstatedir | --sharedstatedi \
++  | --sharedstated | --sharedstate | --sharedstat | --sharedsta \
++  | --sharedst | --shareds | --shared | --share | --shar \
++  | --sha | --sh)
++    ac_prev=sharedstatedir ;;
++  -sharedstatedir=* | --sharedstatedir=* | --sharedstatedi=* \
++  | --sharedstated=* | --sharedstate=* | --sharedstat=* | --sharedsta=* \
++  | --sharedst=* | --shareds=* | --shared=* | --share=* | --shar=* \
++  | --sha=* | --sh=*)
++    sharedstatedir="$ac_optarg" ;;
++
++  -site | --site | --sit)
++    ac_prev=site ;;
++  -site=* | --site=* | --sit=*)
++    site="$ac_optarg" ;;
++
++  -srcdir | --srcdir | --srcdi | --srcd | --src | --sr)
++    ac_prev=srcdir ;;
++  -srcdir=* | --srcdir=* | --srcdi=* | --srcd=* | --src=* | --sr=*)
++    srcdir="$ac_optarg" ;;
++
++  -sysconfdir | --sysconfdir | --sysconfdi | --sysconfd | --sysconf \
++  | --syscon | --sysco | --sysc | --sys | --sy)
++    ac_prev=sysconfdir ;;
++  -sysconfdir=* | --sysconfdir=* | --sysconfdi=* | --sysconfd=* | --sysconf=* \
++  | --syscon=* | --sysco=* | --sysc=* | --sys=* | --sy=*)
++    sysconfdir="$ac_optarg" ;;
++
++  -target | --target | --targe | --targ | --tar | --ta | --t)
++    ac_prev=target ;;
++  -target=* | --target=* | --targe=* | --targ=* | --tar=* | --ta=* | --t=*)
++    target="$ac_optarg" ;;
++
++  -v | -verbose | --verbose | --verbos | --verbo | --verb)
++    verbose=yes ;;
++
++  -version | --version | --versio | --versi | --vers)
++    echo "configure generated by autoconf version AC_ACVERSION"
++    exit 0 ;;
++
++  -with-* | --with-*)
++    ac_package=`echo $ac_option|sed -e 's/-*with-//' -e 's/=.*//'`
++    # Reject names that are not valid shell variable names.
++changequote(, )dnl
++    if test -n "`echo $ac_package| sed 's/[-_a-zA-Z0-9]//g'`"; then
++changequote([, ])dnl
++      AC_MSG_ERROR($ac_package: invalid package name)
++    fi
++    ac_package=`echo $ac_package| sed 's/-/_/g'`
++    case "$ac_option" in
++      *=*) ;;
++      *) ac_optarg=yes ;;
++    esac
++    eval "with_${ac_package}='$ac_optarg'" ;;
++
++  -without-* | --without-*)
++    ac_package=`echo $ac_option|sed -e 's/-*without-//'`
++    # Reject names that are not valid shell variable names.
++changequote(, )dnl
++    if test -n "`echo $ac_package| sed 's/[-a-zA-Z0-9_]//g'`"; then
++changequote([, ])dnl
++      AC_MSG_ERROR($ac_package: invalid package name)
++    fi
++    ac_package=`echo $ac_package| sed 's/-/_/g'`
++    eval "with_${ac_package}=no" ;;
++
++  --x)
++    # Obsolete; use --with-x.
++    with_x=yes ;;
++
++  -x-includes | --x-includes | --x-include | --x-includ | --x-inclu \
++  | --x-incl | --x-inc | --x-in | --x-i)
++    ac_prev=x_includes ;;
++  -x-includes=* | --x-includes=* | --x-include=* | --x-includ=* | --x-inclu=* \
++  | --x-incl=* | --x-inc=* | --x-in=* | --x-i=*)
++    x_includes="$ac_optarg" ;;
++
++  -x-libraries | --x-libraries | --x-librarie | --x-librari \
++  | --x-librar | --x-libra | --x-libr | --x-lib | --x-li | --x-l)
++    ac_prev=x_libraries ;;
++  -x-libraries=* | --x-libraries=* | --x-librarie=* | --x-librari=* \
++  | --x-librar=* | --x-libra=* | --x-libr=* | --x-lib=* | --x-li=* | --x-l=*)
++    x_libraries="$ac_optarg" ;;
++
++  -*) AC_MSG_ERROR([$ac_option: invalid option; use --help to show usage])
++    ;;
++
++  *)
++changequote(, )dnl
++    if test -n "`echo $ac_option| sed 's/[-a-z0-9.]//g'`"; then
++changequote([, ])dnl
++      AC_MSG_WARN($ac_option: invalid host type)
++    fi
++    if test "x$nonopt" != xNONE; then
++      AC_MSG_ERROR(can only configure for one host and one target at a time)
++    fi
++    nonopt="$ac_option"
++    ;;
++
++  esac
++done
++
++if test -n "$ac_prev"; then
++  AC_MSG_ERROR(missing argument to --`echo $ac_prev | sed 's/_/-/g'`)
++fi
++])
++
++dnl Try to have only one #! line, so the script doesn't look funny
++dnl for users of AC_REVISION.
++dnl AC_INIT_BINSH()
++AC_DEFUN(AC_INIT_BINSH,
++[#! /bin/sh
++])
++
++dnl AC_INIT(UNIQUE-FILE-IN-SOURCE-DIR)
++AC_DEFUN(AC_INIT,
++[sinclude(acsite.m4)dnl
++sinclude(./aclocal.m4)dnl
++AC_REQUIRE([AC_INIT_BINSH])dnl
++AC_INIT_NOTICE
++AC_DIVERT_POP()dnl to NORMAL
++AC_DIVERT_PUSH(AC_DIVERSION_INIT)dnl
++AC_INIT_PARSE_ARGS
++AC_INIT_PREPARE($1)dnl
++AC_DIVERT_POP()dnl to NORMAL
++])
++
++dnl AC_INIT_PREPARE(UNIQUE-FILE-IN-SOURCE-DIR)
++AC_DEFUN(AC_INIT_PREPARE,
++[trap 'rm -fr conftest* confdefs* core core.* *.core $ac_clean_files; exit 1' 1 2 15
++
++# File descriptor usage:
++# 0 standard input
++# 1 file creation
++# 2 errors and warnings
++# 3 some systems may open it to /dev/tty
++# 4 used on the Kubota Titan
++define(AC_FD_MSG, 6)dnl
++[#] AC_FD_MSG checking for... messages and results
++define(AC_FD_CC, 5)dnl
++[#] AC_FD_CC compiler messages saved in config.log
++if test "$silent" = yes; then
++  exec AC_FD_MSG>/dev/null
++else
++  exec AC_FD_MSG>&1
++fi
++exec AC_FD_CC>./config.log
++
++echo "\
++This file contains any messages produced by compilers while
++running configure, to aid debugging if configure makes a mistake.
++" 1>&AC_FD_CC
++
++# Strip out --no-create and --no-recursion so they do not pile up.
++# Also quote any args containing shell metacharacters.
++ac_configure_args=
++for ac_arg
++do
++  case "$ac_arg" in
++  -no-create | --no-create | --no-creat | --no-crea | --no-cre \
++  | --no-cr | --no-c) ;;
++  -no-recursion | --no-recursion | --no-recursio | --no-recursi \
++  | --no-recurs | --no-recur | --no-recu | --no-rec | --no-re | --no-r) ;;
++changequote(<<, >>)dnl
++dnl If you change this globbing pattern, test it on an old shell --
++dnl it's sensitive.  Putting any kind of quote in it causes syntax errors.
++  *" "*|*"	"*|*[\[\]\~\<<#>>\$\^\&\*\(\)\{\}\\\|\;\<\>\?]*)
++  ac_configure_args="$ac_configure_args '$ac_arg'" ;;
++changequote([, ])dnl
++  *) ac_configure_args="$ac_configure_args $ac_arg" ;;
++  esac
++done
++
++# NLS nuisances.
++# Only set these to C if already set.  These must not be set unconditionally
++# because not all systems understand e.g. LANG=C (notably SCO).
++# Fixing LC_MESSAGES prevents Solaris sh from translating var values in `set'!
++# Non-C LC_CTYPE values break the ctype check.
++if test "${LANG+set}"   = set; then LANG=C;   export LANG;   fi
++if test "${LC_ALL+set}" = set; then LC_ALL=C; export LC_ALL; fi
++if test "${LC_MESSAGES+set}" = set; then LC_MESSAGES=C; export LC_MESSAGES; fi
++if test "${LC_CTYPE+set}"    = set; then LC_CTYPE=C;    export LC_CTYPE;    fi
++
++# confdefs.h avoids OS command line length limits that DEFS can exceed.
++rm -rf conftest* confdefs.h
++# AIX cpp loses on an empty file, so make sure it contains at least a newline.
++echo > confdefs.h
++
++# A filename unique to this package, relative to the directory that
++# configure is in, which we can look for to find out if srcdir is correct.
++ac_unique_file=$1
++
++# Find the source files, if location was not specified.
++if test -z "$srcdir"; then
++  ac_srcdir_defaulted=yes
++  # Try the directory containing this script, then its parent.
++  ac_prog=[$]0
++changequote(, )dnl
++  ac_confdir=`echo $ac_prog|sed 's%/[^/][^/]*$%%'`
++changequote([, ])dnl
++  test "x$ac_confdir" = "x$ac_prog" && ac_confdir=.
++  srcdir=$ac_confdir
++  if test ! -r $srcdir/$ac_unique_file; then
++    srcdir=..
++  fi
++else
++  ac_srcdir_defaulted=no
++fi
++if test ! -r $srcdir/$ac_unique_file; then
++  if test "$ac_srcdir_defaulted" = yes; then
++    AC_MSG_ERROR(can not find sources in $ac_confdir or ..)
++  else
++    AC_MSG_ERROR(can not find sources in $srcdir)
++  fi
++fi
++dnl Double slashes in pathnames in object file debugging info
++dnl mess up M-x gdb in Emacs.
++changequote(, )dnl
++srcdir=`echo "${srcdir}" | sed 's%\([^/]\)/*$%\1%'`
++changequote([, ])dnl
++
++dnl Let the site file select an alternate cache file if it wants to.
++AC_SITE_LOAD
++AC_CACHE_LOAD
++AC_LANG_C
++dnl By default always use an empty string as the executable
++dnl extension.  Only change it if the script calls AC_EXEEXT.
++ac_exeext=
++dnl By default assume that objects files use an extension of .o.  Only
++dnl change it if the script calls AC_OBJEXT.
++ac_objext=o
++AC_PROG_ECHO_N
++dnl Substitute for predefined variables.
++AC_SUBST(SHELL)dnl
++AC_SUBST(CFLAGS)dnl
++AC_SUBST(CPPFLAGS)dnl
++AC_SUBST(CXXFLAGS)dnl
++AC_SUBST(FFLAGS)dnl
++AC_SUBST(DEFS)dnl
++AC_SUBST(LDFLAGS)dnl
++AC_SUBST(LIBS)dnl
++AC_SUBST(exec_prefix)dnl
++AC_SUBST(prefix)dnl
++AC_SUBST(program_transform_name)dnl
++dnl Installation directory options.
++AC_SUBST(bindir)dnl
++AC_SUBST(sbindir)dnl
++AC_SUBST(libexecdir)dnl
++AC_SUBST(datadir)dnl
++AC_SUBST(sysconfdir)dnl
++AC_SUBST(sharedstatedir)dnl
++AC_SUBST(localstatedir)dnl
++AC_SUBST(libdir)dnl
++AC_SUBST(includedir)dnl
++AC_SUBST(oldincludedir)dnl
++AC_SUBST(infodir)dnl
++AC_SUBST(mandir)dnl
++])
++
++
++dnl ### Selecting optional features
++
++
++dnl AC_ARG_ENABLE(FEATURE, HELP-STRING, ACTION-IF-TRUE [, ACTION-IF-FALSE])
++AC_DEFUN(AC_ARG_ENABLE,
++[AC_DIVERT_PUSH(AC_DIVERSION_NOTICE)dnl
++ac_help="$ac_help
++[$2]"
++AC_DIVERT_POP()dnl
++[#] Check whether --enable-[$1] or --disable-[$1] was given.
++if test "[${enable_]patsubst([$1], -, _)+set}" = set; then
++  enableval="[$enable_]patsubst([$1], -, _)"
++  ifelse([$3], , :, [$3])
++ifelse([$4], , , [else
++  $4
++])dnl
++fi
++])
++
++AC_DEFUN(AC_ENABLE,
++[AC_OBSOLETE([$0], [; instead use AC_ARG_ENABLE])dnl
++AC_ARG_ENABLE([$1], [  --enable-$1], [$2], [$3])dnl
++])
++
++
++dnl ### Working with optional software
++
++
++dnl AC_ARG_WITH(PACKAGE, HELP-STRING, ACTION-IF-TRUE [, ACTION-IF-FALSE])
++AC_DEFUN(AC_ARG_WITH,
++[AC_DIVERT_PUSH(AC_DIVERSION_NOTICE)dnl
++ac_help="$ac_help
++[$2]"
++AC_DIVERT_POP()dnl
++[#] Check whether --with-[$1] or --without-[$1] was given.
++if test "[${with_]patsubst([$1], -, _)+set}" = set; then
++  withval="[$with_]patsubst([$1], -, _)"
++  ifelse([$3], , :, [$3])
++ifelse([$4], , , [else
++  $4
++])dnl
++fi
++])
++
++AC_DEFUN(AC_WITH,
++[AC_OBSOLETE([$0], [; instead use AC_ARG_WITH])dnl
++AC_ARG_WITH([$1], [  --with-$1], [$2], [$3])dnl
++])
++
++
++dnl ### Transforming program names.
++
++
++dnl AC_ARG_PROGRAM()
++AC_DEFUN(AC_ARG_PROGRAM,
++[if test "$program_transform_name" = s,x,x,; then
++  program_transform_name=
++else
++  # Double any \ or $.  echo might interpret backslashes.
++  cat <<\EOF_SED > conftestsed
++s,\\,\\\\,g; s,\$,$$,g
++EOF_SED
++  program_transform_name="`echo $program_transform_name|sed -f conftestsed`"
++  rm -f conftestsed
++fi
++test "$program_prefix" != NONE &&
++  program_transform_name="s,^,${program_prefix},; $program_transform_name"
++# Use a double $ so make ignores it.
++test "$program_suffix" != NONE &&
++  program_transform_name="s,\$\$,${program_suffix},; $program_transform_name"
++
++# sed with no file args requires a program.
++test "$program_transform_name" = "" && program_transform_name="s,x,x,"
++])
++
++
++dnl ### Version numbers
++
++
++dnl AC_REVISION(REVISION-INFO)
++AC_DEFUN(AC_REVISION,
++[AC_REQUIRE([AC_INIT_BINSH])dnl
++[# From configure.in] translit([$1], $")])
++
++dnl Subroutines of AC_PREREQ.
++
++dnl Change the dots in NUMBER into commas.
++dnl AC_PREREQ_SPLIT(NUMBER)
++define(AC_PREREQ_SPLIT,
++[translit($1, ., [, ])])
++
++dnl Default the ternary version number to 0 (e.g., 1, 7 -> 1, 7, 0).
++dnl AC_PREREQ_CANON(MAJOR, MINOR [,TERNARY])
++define(AC_PREREQ_CANON,
++[$1, $2, ifelse([$3], , 0, [$3])])
++
++dnl Complain and exit if version number 1 is less than version number 2.
++dnl PRINTABLE2 is the printable version of version number 2.
++dnl AC_PREREQ_COMPARE(MAJOR1, MINOR1, TERNARY1, MAJOR2, MINOR2, TERNARY2,
++dnl                   PRINTABLE2)
++define(AC_PREREQ_COMPARE,
++[ifelse(builtin([eval],
++[$3 + $2 * 1000 + $1 * 1000000 < $6 + $5 * 1000 + $4 * 1000000]), 1,
++[errprint(dnl
++FATAL ERROR: Autoconf version $7 or higher is required for this script
++)m4exit(3)])])
++
++dnl Complain and exit if the Autoconf version is less than VERSION.
++dnl AC_PREREQ(VERSION)
++define(AC_PREREQ,
++[AC_PREREQ_COMPARE(AC_PREREQ_CANON(AC_PREREQ_SPLIT(AC_ACVERSION)),
++AC_PREREQ_CANON(AC_PREREQ_SPLIT([$1])), [$1])])
++
++
++dnl ### Getting the canonical system type
++
++
++dnl Find install-sh, config.sub, config.guess, and Cygnus configure
++dnl in directory DIR.  These are auxiliary files used in configuration.
++dnl DIR can be either absolute or relative to $srcdir.
++dnl AC_CONFIG_AUX_DIR(DIR)
++AC_DEFUN(AC_CONFIG_AUX_DIR,
++[AC_CONFIG_AUX_DIRS($1 $srcdir/$1)])
++
++dnl The default is `$srcdir' or `$srcdir/..' or `$srcdir/../..'.
++dnl There's no need to call this macro explicitly; just AC_REQUIRE it.
++AC_DEFUN(AC_CONFIG_AUX_DIR_DEFAULT,
++[AC_CONFIG_AUX_DIRS($srcdir $srcdir/.. $srcdir/../..)])
++
++dnl Internal subroutine.
++dnl Search for the configuration auxiliary files in directory list $1.
++dnl We look only for install-sh, so users of AC_PROG_INSTALL
++dnl do not automatically need to distribute the other auxiliary files.
++dnl AC_CONFIG_AUX_DIRS(DIR ...)
++AC_DEFUN(AC_CONFIG_AUX_DIRS,
++[ac_aux_dir=
++for ac_dir in $1; do
++  if test -f $ac_dir/install-sh; then
++    ac_aux_dir=$ac_dir
++    ac_install_sh="$ac_aux_dir/install-sh -c"
++    break
++  elif test -f $ac_dir/install.sh; then
++    ac_aux_dir=$ac_dir
++    ac_install_sh="$ac_aux_dir/install.sh -c"
++    break
++  fi
++done
++if test -z "$ac_aux_dir"; then
++  AC_MSG_ERROR([can not find install-sh or install.sh in $1])
++fi
++ac_config_guess=$ac_aux_dir/config.guess
++ac_config_sub=$ac_aux_dir/config.sub
++ac_configure=$ac_aux_dir/configure # This should be Cygnus configure.
++AC_PROVIDE([AC_CONFIG_AUX_DIR_DEFAULT])dnl
++])
++
++dnl Canonicalize the host, target, and build system types.
++AC_DEFUN(AC_CANONICAL_SYSTEM,
++[AC_REQUIRE([AC_CONFIG_AUX_DIR_DEFAULT])dnl
++AC_BEFORE([$0], [AC_ARG_PROGRAM])
++# Do some error checking and defaulting for the host and target type.
++# The inputs are:
++#    configure --host=HOST --target=TARGET --build=BUILD NONOPT
++#
++# The rules are:
++# 1. You are not allowed to specify --host, --target, and nonopt at the
++#    same time.
++# 2. Host defaults to nonopt.
++# 3. If nonopt is not specified, then host defaults to the current host,
++#    as determined by config.guess.
++# 4. Target and build default to nonopt.
++# 5. If nonopt is not specified, then target and build default to host.
++
++# The aliases save the names the user supplied, while $host etc.
++# will get canonicalized.
++case $host---$target---$nonopt in
++NONE---*---* | *---NONE---* | *---*---NONE) ;;
++*) AC_MSG_ERROR(can only configure for one host and one target at a time) ;;
++esac
++
++AC_CANONICAL_HOST
++AC_CANONICAL_TARGET
++AC_CANONICAL_BUILD
++test "$host_alias" != "$target_alias" &&
++  test "$program_prefix$program_suffix$program_transform_name" = \
++    NONENONEs,x,x, &&
++  program_prefix=${target_alias}-
++])
++
++dnl Subroutines of AC_CANONICAL_SYSTEM.
++
++AC_DEFUN(AC_CANONICAL_HOST,
++[AC_REQUIRE([AC_CONFIG_AUX_DIR_DEFAULT])dnl
++
++# Make sure we can run config.sub.
++if ${CONFIG_SHELL-/bin/sh} $ac_config_sub sun4 >/dev/null 2>&1; then :
++else AC_MSG_ERROR(can not run $ac_config_sub)
++fi
++
++AC_MSG_CHECKING(host system type)
++
++dnl Set host_alias.
++host_alias=$host
++case "$host_alias" in
++NONE)
++  case $nonopt in
++  NONE)
++    if host_alias=`${CONFIG_SHELL-/bin/sh} $ac_config_guess`; then :
++    else AC_MSG_ERROR(can not guess host type; you must specify one)
++    fi ;;
++  *) host_alias=$nonopt ;;
++  esac ;;
++esac
++
++dnl Set the other host vars.
++changequote(<<, >>)dnl
++host=`${CONFIG_SHELL-/bin/sh} $ac_config_sub $host_alias`
++host_cpu=`echo $host | sed 's/^\([^-]*\)-\([^-]*\)-\(.*\)$/\1/'`
++host_vendor=`echo $host | sed 's/^\([^-]*\)-\([^-]*\)-\(.*\)$/\2/'`
++host_os=`echo $host | sed 's/^\([^-]*\)-\([^-]*\)-\(.*\)$/\3/'`
++changequote([, ])dnl
++AC_MSG_RESULT($host)
++AC_SUBST(host)dnl
++AC_SUBST(host_alias)dnl
++AC_SUBST(host_cpu)dnl
++AC_SUBST(host_vendor)dnl
++AC_SUBST(host_os)dnl
++])
++
++dnl Internal use only.
++AC_DEFUN(AC_CANONICAL_TARGET,
++[AC_REQUIRE([AC_CONFIG_AUX_DIR_DEFAULT])dnl
++AC_MSG_CHECKING(target system type)
++
++dnl Set target_alias.
++target_alias=$target
++case "$target_alias" in
++NONE)
++  case $nonopt in
++  NONE) target_alias=$host_alias ;;
++  *) target_alias=$nonopt ;;
++  esac ;;
++esac
++
++dnl Set the other target vars.
++changequote(<<, >>)dnl
++target=`${CONFIG_SHELL-/bin/sh} $ac_config_sub $target_alias`
++target_cpu=`echo $target | sed 's/^\([^-]*\)-\([^-]*\)-\(.*\)$/\1/'`
++target_vendor=`echo $target | sed 's/^\([^-]*\)-\([^-]*\)-\(.*\)$/\2/'`
++target_os=`echo $target | sed 's/^\([^-]*\)-\([^-]*\)-\(.*\)$/\3/'`
++changequote([, ])dnl
++AC_MSG_RESULT($target)
++AC_SUBST(target)dnl
++AC_SUBST(target_alias)dnl
++AC_SUBST(target_cpu)dnl
++AC_SUBST(target_vendor)dnl
++AC_SUBST(target_os)dnl
++])
++
++dnl Internal use only.
++AC_DEFUN(AC_CANONICAL_BUILD,
++[AC_REQUIRE([AC_CONFIG_AUX_DIR_DEFAULT])dnl
++AC_MSG_CHECKING(build system type)
++
++dnl Set build_alias.
++build_alias=$build
++case "$build_alias" in
++NONE)
++  case $nonopt in
++  NONE) build_alias=$host_alias ;;
++  *) build_alias=$nonopt ;;
++  esac ;;
++esac
++
++dnl Set the other build vars.
++changequote(<<, >>)dnl
++build=`${CONFIG_SHELL-/bin/sh} $ac_config_sub $build_alias`
++build_cpu=`echo $build | sed 's/^\([^-]*\)-\([^-]*\)-\(.*\)$/\1/'`
++build_vendor=`echo $build | sed 's/^\([^-]*\)-\([^-]*\)-\(.*\)$/\2/'`
++build_os=`echo $build | sed 's/^\([^-]*\)-\([^-]*\)-\(.*\)$/\3/'`
++changequote([, ])dnl
++AC_MSG_RESULT($build)
++AC_SUBST(build)dnl
++AC_SUBST(build_alias)dnl
++AC_SUBST(build_cpu)dnl
++AC_SUBST(build_vendor)dnl
++AC_SUBST(build_os)dnl
++])
++
++
++dnl AC_VALIDATE_CACHED_SYSTEM_TUPLE[(cmd)]
++dnl if the cache file is inconsistent with the current host,
++dnl target and build system types, execute CMD or print a default
++dnl error message.
++AC_DEFUN(AC_VALIDATE_CACHED_SYSTEM_TUPLE, [
++  AC_REQUIRE([AC_CANONICAL_SYSTEM])
++  AC_MSG_CHECKING([cached system tuple])
++  if { test x"${ac_cv_host_system_type+set}" = x"set" &&
++       test x"$ac_cv_host_system_type" != x"$host"; } ||
++     { test x"${ac_cv_build_system_type+set}" = x"set" &&
++       test x"$ac_cv_build_system_type" != x"$build"; } ||
++     { test x"${ac_cv_target_system_type+set}" = x"set" &&
++       test x"$ac_cv_target_system_type" != x"$target"; }; then
++      AC_MSG_RESULT([different])
++      ifelse($#, 1, [$1],
++        [AC_MSG_ERROR([remove config.cache and re-run configure])])
++  else
++    AC_MSG_RESULT(ok)
++  fi
++  ac_cv_host_system_type="$host"
++  ac_cv_build_system_type="$build"
++  ac_cv_target_system_type="$target"
++])
++
++
++dnl ### Caching test results
++
++
++dnl Look for site or system specific initialization scripts.
++dnl AC_SITE_LOAD()
++define(AC_SITE_LOAD,
++[# Prefer explicitly selected file to automatically selected ones.
++if test -z "$CONFIG_SITE"; then
++  if test "x$prefix" != xNONE; then
++    CONFIG_SITE="$prefix/share/config.site $prefix/etc/config.site"
++  else
++    CONFIG_SITE="$ac_default_prefix/share/config.site $ac_default_prefix/etc/config.site"
++  fi
++fi
++for ac_site_file in $CONFIG_SITE; do
++  if test -r "$ac_site_file"; then
++    echo "loading site script $ac_site_file"
++    . "$ac_site_file"
++  fi
++done
++])
++
++dnl AC_CACHE_LOAD()
++define(AC_CACHE_LOAD,
++[if test -r "$cache_file"; then
++  echo "loading cache $cache_file"
++  . $cache_file
++else
++  echo "creating cache $cache_file"
++  > $cache_file
++fi
++])
++
++dnl AC_CACHE_SAVE()
++define(AC_CACHE_SAVE,
++[cat > confcache <<\EOF
++# This file is a shell script that caches the results of configure
++# tests run on this system so they can be shared between configure
++# scripts and configure runs.  It is not useful on other systems.
++# If it contains results you don't want to keep, you may remove or edit it.
++#
++# By default, configure uses ./config.cache as the cache file,
++# creating it if it does not exist already.  You can give configure
++# the --cache-file=FILE option to use a different cache file; that is
++# what configure does when it calls configure scripts in
++# subdirectories, so they share the cache.
++# Giving --cache-file=/dev/null disables caching, for debugging configure.
++# config.status only pays attention to the cache file if you give it the
++# --recheck option to rerun configure.
++#
++EOF
++dnl Allow a site initialization script to override cache values.
++# The following way of writing the cache mishandles newlines in values,
++# but we know of no workaround that is simple, portable, and efficient.
++# So, don't put newlines in cache variables' values.
++# Ultrix sh set writes to stderr and can't be redirected directly,
++# and sets the high bit in the cache file unless we assign to the vars.
++changequote(, )dnl
++(set) 2>&1 |
++  case `(ac_space=' '; set | grep ac_space) 2>&1` in
++  *ac_space=\ *)
++    # `set' does not quote correctly, so add quotes (double-quote substitution
++    # turns \\\\ into \\, and sed turns \\ into \).
++    sed -n \
++      -e "s/'/'\\\\''/g" \
++      -e "s/^\\([a-zA-Z0-9_]*_cv_[a-zA-Z0-9_]*\\)=\\(.*\\)/\\1=\${\\1='\\2'}/p"
++    ;;
++  *)
++    # `set' quotes correctly as required by POSIX, so do not add quotes.
++    sed -n -e 's/^\([a-zA-Z0-9_]*_cv_[a-zA-Z0-9_]*\)=\(.*\)/\1=${\1=\2}/p'
++    ;;
++  esac >> confcache
++changequote([, ])dnl
++if cmp -s $cache_file confcache; then
++  :
++else
++  if test -w $cache_file; then
++    echo "updating cache $cache_file"
++    cat confcache > $cache_file
++  else
++    echo "not updating unwritable cache $cache_file"
++  fi
++fi
++rm -f confcache
++])
++
++dnl The name of shell var CACHE-ID must contain `_cv_' in order to get saved.
++dnl AC_CACHE_VAL(CACHE-ID, COMMANDS-TO-SET-IT)
++define(AC_CACHE_VAL,
++[dnl We used to use the below line, but it fails if the 1st arg is a
++dnl shell variable, so we need the eval.
++dnl if test "${$1+set}" = set; then
++dnl the '' avoids an AIX 4.1 sh bug ("invalid expansion").
++if eval "test \"`echo '$''{'$1'+set}'`\" = set"; then
++  echo $ac_n "(cached) $ac_c" 1>&AC_FD_MSG
++else
++  $2
++fi
++])
++
++dnl AC_CACHE_CHECK(MESSAGE, CACHE-ID, COMMANDS)
++define(AC_CACHE_CHECK,
++[AC_MSG_CHECKING([$1])
++AC_CACHE_VAL([$2], [$3])
++AC_MSG_RESULT([$]$2)])
++
++
++dnl ### Defining symbols
++
++
++dnl Set VARIABLE to VALUE, verbatim, or 1.
++dnl AC_DEFINE(VARIABLE [, VALUE])
++define(AC_DEFINE,
++[cat >> confdefs.h <<\EOF
++[#define] $1 ifelse($#, 2, [$2], $#, 3, [$2], 1)
++EOF
++])
++
++dnl Similar, but perform shell substitutions $ ` \ once on VALUE.
++define(AC_DEFINE_UNQUOTED,
++[cat >> confdefs.h <<EOF
++[#define] $1 ifelse($#, 2, [$2], $#, 3, [$2], 1)
++EOF
++])
++
++
++dnl ### Setting output variables
++
++
++dnl This macro protects VARIABLE from being diverted twice
++dnl if this macro is called twice for it.
++dnl AC_SUBST(VARIABLE)
++define(AC_SUBST,
++[ifdef([AC_SUBST_$1], ,
++[define([AC_SUBST_$1], )dnl
++AC_DIVERT_PUSH(AC_DIVERSION_SED)dnl
++s%@$1@%[$]$1%g
++AC_DIVERT_POP()dnl
++])])
++
++dnl AC_SUBST_FILE(VARIABLE)
++define(AC_SUBST_FILE,
++[ifdef([AC_SUBST_$1], ,
++[define([AC_SUBST_$1], )dnl
++AC_DIVERT_PUSH(AC_DIVERSION_SED)dnl
++/@$1@/r [$]$1
++s%@$1@%%g
++AC_DIVERT_POP()dnl
++])])
++
++
++dnl ### Printing messages
++
++
++dnl AC_MSG_CHECKING(FEATURE-DESCRIPTION)
++define(AC_MSG_CHECKING,
++[echo $ac_n "checking $1""... $ac_c" 1>&AC_FD_MSG
++echo "configure:__oline__: checking $1" >&AC_FD_CC])
++
++dnl AC_CHECKING(FEATURE-DESCRIPTION)
++define(AC_CHECKING,
++[echo "checking $1" 1>&AC_FD_MSG
++echo "configure:__oline__: checking $1" >&AC_FD_CC])
++
++dnl AC_MSG_RESULT(RESULT-DESCRIPTION)
++define(AC_MSG_RESULT,
++[echo "$ac_t""$1" 1>&AC_FD_MSG])
++
++dnl AC_VERBOSE(RESULT-DESCRIPTION)
++define(AC_VERBOSE,
++[AC_OBSOLETE([$0], [; instead use AC_MSG_RESULT])dnl
++echo "	$1" 1>&AC_FD_MSG])
++
++dnl AC_MSG_WARN(PROBLEM-DESCRIPTION)
++define(AC_MSG_WARN,
++[echo "configure: warning: $1" 1>&2])
++
++dnl AC_MSG_ERROR(ERROR-DESCRIPTION)
++define(AC_MSG_ERROR,
++[{ echo "configure: error: $1" 1>&2; exit 1; }])
++
++
++dnl ### Selecting which language to use for testing
++
++
++dnl AC_LANG_C()
++AC_DEFUN(AC_LANG_C,
++[define([AC_LANG], [C])dnl
++ac_ext=c
++# CFLAGS is not in ac_cpp because -g, -O, etc. are not valid cpp options.
++ac_cpp='$CPP $CPPFLAGS'
++ac_compile='${CC-cc} -c $CFLAGS $CPPFLAGS conftest.$ac_ext 1>&AC_FD_CC'
++ac_link='${CC-cc} -o conftest${ac_exeext} $CFLAGS $CPPFLAGS $LDFLAGS conftest.$ac_ext $LIBS 1>&AC_FD_CC'
++cross_compiling=$ac_cv_prog_cc_cross
++])
++
++dnl AC_LANG_CPLUSPLUS()
++AC_DEFUN(AC_LANG_CPLUSPLUS,
++[define([AC_LANG], [CPLUSPLUS])dnl
++ac_ext=C
++# CXXFLAGS is not in ac_cpp because -g, -O, etc. are not valid cpp options.
++ac_cpp='$CXXCPP $CPPFLAGS'
++ac_compile='${CXX-g++} -c $CXXFLAGS $CPPFLAGS conftest.$ac_ext 1>&AC_FD_CC'
++ac_link='${CXX-g++} -o conftest${ac_exeext} $CXXFLAGS $CPPFLAGS $LDFLAGS conftest.$ac_ext $LIBS 1>&AC_FD_CC'
++cross_compiling=$ac_cv_prog_cxx_cross
++])
++
++dnl AC_LANG_FORTRAN77()
++AC_DEFUN(AC_LANG_FORTRAN77,
++[define([AC_LANG], [FORTRAN77])dnl
++ac_ext=f
++ac_compile='${F77-f77} -c $FFLAGS conftest.$ac_ext 1>&AC_FD_CC'
++ac_link='${F77-f77} -o conftest${ac_exeext} $FFLAGS $LDFLAGS conftest.$ac_ext $LIBS 1>&AC_FD_CC'
++cross_compiling=$ac_cv_prog_f77_cross
++])
++
++dnl Push the current language on a stack.
++dnl AC_LANG_SAVE()
++define(AC_LANG_SAVE,
++[pushdef([AC_LANG_STACK], AC_LANG)])
++
++dnl Restore the current language from the stack.
++dnl AC_LANG_RESTORE()
++pushdef([AC_LANG_RESTORE],
++[ifelse(AC_LANG_STACK, [C], [AC_LANG_C],dnl
++AC_LANG_STACK, [CPLUSPLUS], [AC_LANG_CPLUSPLUS],dnl
++AC_LANG_STACK, [FORTRAN77], [AC_LANG_FORTRAN77])[]popdef([AC_LANG_STACK])])
++
++
++dnl ### Compiler-running mechanics
++
++
++dnl The purpose of this macro is to "configure:123: command line"
++dnl written into config.log for every test run.
++dnl AC_TRY_EVAL(VARIABLE)
++AC_DEFUN(AC_TRY_EVAL,
++[{ (eval echo configure:__oline__: \"[$]$1\") 1>&AC_FD_CC; dnl
++(eval [$]$1) 2>&AC_FD_CC; }])
++
++dnl AC_TRY_COMMAND(COMMAND)
++AC_DEFUN(AC_TRY_COMMAND,
++[{ ac_try='$1'; AC_TRY_EVAL(ac_try); }])
++
++
++dnl ### Dependencies between macros
++
++
++dnl AC_BEFORE(THIS-MACRO-NAME, CALLED-MACRO-NAME)
++define(AC_BEFORE,
++[ifdef([AC_PROVIDE_$2], [errprint(__file__:__line__: [$2 was called before $1
++])])])
++
++dnl AC_REQUIRE(MACRO-NAME)
++define(AC_REQUIRE,
++[ifdef([AC_PROVIDE_$1], ,
++[AC_DIVERT_PUSH(builtin(eval, AC_DIVERSION_CURRENT - 1))dnl
++indir([$1])
++AC_DIVERT_POP()dnl
++])])
++
++dnl AC_PROVIDE(MACRO-NAME)
++define(AC_PROVIDE,
++[define([AC_PROVIDE_$1], )])
++
++dnl AC_OBSOLETE(THIS-MACRO-NAME [, SUGGESTION])
++define(AC_OBSOLETE,
++[errprint(__file__:__line__: warning: [$1] is obsolete[$2]
++)])
++
++
++dnl ### Checking for programs
++
++
++dnl AC_CHECK_PROG(VARIABLE, PROG-TO-CHECK-FOR, VALUE-IF-FOUND
++dnl               [, [VALUE-IF-NOT-FOUND] [, [PATH] [, [REJECT]]]])
++AC_DEFUN(AC_CHECK_PROG,
++[# Extract the first word of "$2", so it can be a program name with args.
++set dummy $2; ac_word=[$]2
++AC_MSG_CHECKING([for $ac_word])
++AC_CACHE_VAL(ac_cv_prog_$1,
++[if test -n "[$]$1"; then
++  ac_cv_prog_$1="[$]$1" # Let the user override the test.
++else
++  IFS="${IFS= 	}"; ac_save_ifs="$IFS"; IFS=":"
++ifelse([$6], , , [  ac_prog_rejected=no
++])dnl
++dnl $ac_dummy forces splitting on constant user-supplied paths.
++dnl POSIX.2 word splitting is done only on the output of word expansions,
++dnl not every word.  This closes a longstanding sh security hole.
++  ac_dummy="ifelse([$5], , $PATH, [$5])"
++  for ac_dir in $ac_dummy; do
++    test -z "$ac_dir" && ac_dir=.
++    if test -f $ac_dir/$ac_word; then
++ifelse([$6], , , dnl
++[      if test "[$ac_dir/$ac_word]" = "$6"; then
++        ac_prog_rejected=yes
++	continue
++      fi
++])dnl
++      ac_cv_prog_$1="$3"
++      break
++    fi
++  done
++  IFS="$ac_save_ifs"
++ifelse([$6], , , [if test $ac_prog_rejected = yes; then
++  # We found a bogon in the path, so make sure we never use it.
++  set dummy [$]ac_cv_prog_$1
++  shift
++  if test [$]# -gt 0; then
++    # We chose a different compiler from the bogus one.
++    # However, it has the same basename, so the bogon will be chosen
++    # first if we set $1 to just the basename; use the full file name.
++    shift
++    set dummy "$ac_dir/$ac_word" "[$]@"
++    shift
++    ac_cv_prog_$1="[$]@"
++ifelse([$2], [$4], dnl
++[  else
++    # Default is a loser.
++    AC_MSG_ERROR([$1=$6 unacceptable, but no other $4 found in dnl
++ifelse([$5], , [\$]PATH, [$5])])
++])dnl
++  fi
++fi
++])dnl
++dnl If no 4th arg is given, leave the cache variable unset,
++dnl so AC_CHECK_PROGS will keep looking.
++ifelse([$4], , , [  test -z "[$]ac_cv_prog_$1" && ac_cv_prog_$1="$4"
++])dnl
++fi])dnl
++$1="$ac_cv_prog_$1"
++if test -n "[$]$1"; then
++  AC_MSG_RESULT([$]$1)
++else
++  AC_MSG_RESULT(no)
++fi
++AC_SUBST($1)dnl
++])
++
++dnl AC_PATH_PROG(VARIABLE, PROG-TO-CHECK-FOR [, VALUE-IF-NOT-FOUND [, PATH]])
++AC_DEFUN(AC_PATH_PROG,
++[# Extract the first word of "$2", so it can be a program name with args.
++set dummy $2; ac_word=[$]2
++AC_MSG_CHECKING([for $ac_word])
++AC_CACHE_VAL(ac_cv_path_$1,
++[case "[$]$1" in
++  /*)
++  ac_cv_path_$1="[$]$1" # Let the user override the test with a path.
++  ;;
++  ?:/*)			 
++  ac_cv_path_$1="[$]$1" # Let the user override the test with a dos path.
++  ;;
++  *)
++  IFS="${IFS= 	}"; ac_save_ifs="$IFS"; IFS=":"
++dnl $ac_dummy forces splitting on constant user-supplied paths.
++dnl POSIX.2 word splitting is done only on the output of word expansions,
++dnl not every word.  This closes a longstanding sh security hole.
++  ac_dummy="ifelse([$4], , $PATH, [$4])"
++  for ac_dir in $ac_dummy; do 
++    test -z "$ac_dir" && ac_dir=.
++    if test -f $ac_dir/$ac_word; then
++      ac_cv_path_$1="$ac_dir/$ac_word"
++      break
++    fi
++  done
++  IFS="$ac_save_ifs"
++dnl If no 3rd arg is given, leave the cache variable unset,
++dnl so AC_PATH_PROGS will keep looking.
++ifelse([$3], , , [  test -z "[$]ac_cv_path_$1" && ac_cv_path_$1="$3"
++])dnl
++  ;;
++esac])dnl
++$1="$ac_cv_path_$1"
++if test -n "[$]$1"; then
++  AC_MSG_RESULT([$]$1)
++else
++  AC_MSG_RESULT(no)
++fi
++AC_SUBST($1)dnl
++])
++
++dnl AC_CHECK_PROGS(VARIABLE, PROGS-TO-CHECK-FOR [, VALUE-IF-NOT-FOUND
++dnl                [, PATH]])
++AC_DEFUN(AC_CHECK_PROGS,
++[for ac_prog in $2
++do
++AC_CHECK_PROG($1, [$]ac_prog, [$]ac_prog, , $4)
++test -n "[$]$1" && break
++done
++ifelse([$3], , , [test -n "[$]$1" || $1="$3"
++])])
++
++dnl AC_PATH_PROGS(VARIABLE, PROGS-TO-CHECK-FOR [, VALUE-IF-NOT-FOUND
++dnl               [, PATH]])
++AC_DEFUN(AC_PATH_PROGS,
++[for ac_prog in $2
++do
++AC_PATH_PROG($1, [$]ac_prog, , $4)
++test -n "[$]$1" && break
++done
++ifelse([$3], , , [test -n "[$]$1" || $1="$3"
++])])
++
++dnl Internal subroutine.
++AC_DEFUN(AC_CHECK_TOOL_PREFIX,
++[AC_REQUIRE([AC_CANONICAL_HOST])AC_REQUIRE([AC_CANONICAL_BUILD])dnl
++if test $host != $build; then
++  ac_tool_prefix=${host_alias}-
++else
++  ac_tool_prefix=
++fi
++])
++
++dnl AC_CHECK_TOOL(VARIABLE, PROG-TO-CHECK-FOR[, VALUE-IF-NOT-FOUND [, PATH]])
++AC_DEFUN(AC_CHECK_TOOL,
++[AC_REQUIRE([AC_CHECK_TOOL_PREFIX])dnl
++AC_CHECK_PROG($1, ${ac_tool_prefix}$2, ${ac_tool_prefix}$2,
++	      ifelse([$3], , [$2], ), $4)
++ifelse([$3], , , [
++if test -z "$ac_cv_prog_$1"; then
++if test -n "$ac_tool_prefix"; then
++  AC_CHECK_PROG($1, $2, $2, $3)
++else
++  $1="$3"
++fi
++fi])
++])
++
++dnl Guess the value for the `prefix' variable by looking for
++dnl the argument program along PATH and taking its parent.
++dnl Example: if the argument is `gcc' and we find /usr/local/gnu/bin/gcc,
++dnl set `prefix' to /usr/local/gnu.
++dnl This comes too late to find a site file based on the prefix,
++dnl and it might use a cached value for the path.
++dnl No big loss, I think, since most configures don't use this macro anyway.
++dnl AC_PREFIX_PROGRAM(PROGRAM)
++AC_DEFUN(AC_PREFIX_PROGRAM,
++[if test "x$prefix" = xNONE; then
++changequote(<<, >>)dnl
++define(<<AC_VAR_NAME>>, translit($1, [a-z], [A-Z]))dnl
++changequote([, ])dnl
++dnl We reimplement AC_MSG_CHECKING (mostly) to avoid the ... in the middle.
++echo $ac_n "checking for prefix by $ac_c" 1>&AC_FD_MSG
++AC_PATH_PROG(AC_VAR_NAME, $1)
++changequote(<<, >>)dnl
++  if test -n "$ac_cv_path_<<>>AC_VAR_NAME"; then
++    prefix=`echo $ac_cv_path_<<>>AC_VAR_NAME|sed 's%/[^/][^/]*//*[^/][^/]*$%%'`
++changequote([, ])dnl
++  fi
++fi
++undefine([AC_VAR_NAME])dnl
++])
++
++dnl Try to compile, link and execute TEST-PROGRAM.  Set WORKING-VAR to
++dnl `yes' if the current compiler works, otherwise set it ti `no'.  Set
++dnl CROSS-VAR to `yes' if the compiler and linker produce non-native
++dnl executables, otherwise set it to `no'.  Before calling
++dnl `AC_TRY_COMPILER()', call `AC_LANG_*' to set-up for the right
++dnl language.
++dnl 
++dnl AC_TRY_COMPILER(TEST-PROGRAM, WORKING-VAR, CROSS-VAR)
++AC_DEFUN(AC_TRY_COMPILER,
++[cat > conftest.$ac_ext << EOF
++ifelse(AC_LANG, [FORTRAN77], ,
++[
++[#]line __oline__ "configure"
++#include "confdefs.h"
++])
++[$1]
++EOF
++if AC_TRY_EVAL(ac_link) && test -s conftest${ac_exeext}; then
++  [$2]=yes
++  # If we can't run a trivial program, we are probably using a cross compiler.
++  if (./conftest; exit) 2>/dev/null; then
++    [$3]=no
++  else
++    [$3]=yes
++  fi
++else
++  echo "configure: failed program was:" >&AC_FD_CC
++  cat conftest.$ac_ext >&AC_FD_CC
++  [$2]=no
++fi
++rm -fr conftest*])
++
++
++dnl ### Checking for libraries
++
++
++dnl AC_TRY_LINK_FUNC(func, action-if-found, action-if-not-found)
++dnl Try to link a program that calls FUNC, handling GCC builtins.  If
++dnl the link succeeds, execute ACTION-IF-FOUND; otherwise, execute
++dnl ACTION-IF-NOT-FOUND.
++
++AC_DEFUN(AC_TRY_LINK_FUNC,
++AC_TRY_LINK(dnl
++ifelse([$1], [main], , dnl Avoid conflicting decl of main.
++[/* Override any gcc2 internal prototype to avoid an error.  */
++]ifelse(AC_LANG, CPLUSPLUS, [#ifdef __cplusplus
++extern "C"
++#endif
++])dnl
++[/* We use char because int might match the return type of a gcc2
++    builtin and then its argument prototype would still apply.  */
++char $1();
++]),
++[$1()],
++[$2],
++[$3]))
++
++
++dnl AC_SEARCH_LIBS(FUNCTION, SEARCH-LIBS [, ACTION-IF-FOUND
++dnl            [, ACTION-IF-NOT-FOUND [, OTHER-LIBRARIES]]])
++dnl Search for a library defining FUNC, if it's not already available.
++
++AC_DEFUN(AC_SEARCH_LIBS,
++[AC_PREREQ([2.13])
++AC_CACHE_CHECK([for library containing $1], [ac_cv_search_$1],
++[ac_func_search_save_LIBS="$LIBS"
++ac_cv_search_$1="no"
++AC_TRY_LINK_FUNC([$1], [ac_cv_search_$1="none required"])
++test "$ac_cv_search_$1" = "no" && for i in $2; do
++LIBS="-l$i $5 $ac_func_search_save_LIBS"
++AC_TRY_LINK_FUNC([$1],
++[ac_cv_search_$1="-l$i"
++break])
++done
++LIBS="$ac_func_search_save_LIBS"])
++if test "$ac_cv_search_$1" != "no"; then
++  test "$ac_cv_search_$1" = "none required" || LIBS="$ac_cv_search_$1 $LIBS"
++  $3
++else :
++  $4
++fi])
++
++
++
++dnl AC_CHECK_LIB(LIBRARY, FUNCTION [, ACTION-IF-FOUND [, ACTION-IF-NOT-FOUND
++dnl              [, OTHER-LIBRARIES]]])
++AC_DEFUN(AC_CHECK_LIB,
++[AC_MSG_CHECKING([for $2 in -l$1])
++dnl Use a cache variable name containing both the library and function name,
++dnl because the test really is for library $1 defining function $2, not
++dnl just for library $1.  Separate tests with the same $1 and different $2s
++dnl may have different results.
++ac_lib_var=`echo $1['_']$2 | sed 'y%./+-%__p_%'`
++AC_CACHE_VAL(ac_cv_lib_$ac_lib_var,
++[ac_save_LIBS="$LIBS"
++LIBS="-l$1 $5 $LIBS"
++AC_TRY_LINK(dnl
++ifelse(AC_LANG, [FORTRAN77], ,
++ifelse([$2], [main], , dnl Avoid conflicting decl of main.
++[/* Override any gcc2 internal prototype to avoid an error.  */
++]ifelse(AC_LANG, CPLUSPLUS, [#ifdef __cplusplus
++extern "C"
++#endif
++])dnl
++[/* We use char because int might match the return type of a gcc2
++    builtin and then its argument prototype would still apply.  */
++char $2();
++])),
++	    [$2()],
++	    eval "ac_cv_lib_$ac_lib_var=yes",
++	    eval "ac_cv_lib_$ac_lib_var=no")
++LIBS="$ac_save_LIBS"
++])dnl
++if eval "test \"`echo '$ac_cv_lib_'$ac_lib_var`\" = yes"; then
++  AC_MSG_RESULT(yes)
++  ifelse([$3], ,
++[changequote(, )dnl
++  ac_tr_lib=HAVE_LIB`echo $1 | sed -e 's/[^a-zA-Z0-9_]/_/g' \
++    -e 'y/abcdefghijklmnopqrstuvwxyz/ABCDEFGHIJKLMNOPQRSTUVWXYZ/'`
++changequote([, ])dnl
++  AC_DEFINE_UNQUOTED($ac_tr_lib)
++  LIBS="-l$1 $LIBS"
++], [$3])
++else
++  AC_MSG_RESULT(no)
++ifelse([$4], , , [$4
++])dnl
++fi
++])
++
++dnl AC_HAVE_LIBRARY(LIBRARY, [, ACTION-IF-FOUND [, ACTION-IF-NOT-FOUND
++dnl                 [, OTHER-LIBRARIES]]])
++AC_DEFUN(AC_HAVE_LIBRARY,
++[AC_OBSOLETE([$0], [; instead use AC_CHECK_LIB])dnl
++changequote(<<, >>)dnl
++define(<<AC_LIB_NAME>>, dnl
++patsubst(patsubst($1, <<lib\([^\.]*\)\.a>>, <<\1>>), <<-l>>, <<>>))dnl
++define(<<AC_CV_NAME>>, ac_cv_lib_<<>>AC_LIB_NAME)dnl
++changequote([, ])dnl
++AC_MSG_CHECKING([for -l[]AC_LIB_NAME])
++AC_CACHE_VAL(AC_CV_NAME,
++[ac_save_LIBS="$LIBS"
++LIBS="-l[]AC_LIB_NAME[] $4 $LIBS"
++AC_TRY_LINK( , [main()], AC_CV_NAME=yes, AC_CV_NAME=no)
++LIBS="$ac_save_LIBS"
++])dnl
++AC_MSG_RESULT($AC_CV_NAME)
++if test "$AC_CV_NAME" = yes; then
++  ifelse([$2], ,
++[AC_DEFINE([HAVE_LIB]translit(AC_LIB_NAME, [a-z], [A-Z]))
++  LIBS="-l[]AC_LIB_NAME[] $LIBS"
++], [$2])
++ifelse([$3], , , [else
++  $3
++])dnl
++fi
++undefine([AC_LIB_NAME])dnl
++undefine([AC_CV_NAME])dnl
++])
++
++
++dnl ### Examining declarations
++
++
++dnl AC_TRY_CPP(INCLUDES, [ACTION-IF-TRUE [, ACTION-IF-FALSE]])
++AC_DEFUN(AC_TRY_CPP,
++[AC_REQUIRE_CPP()dnl
++cat > conftest.$ac_ext <<EOF
++[#]line __oline__ "configure"
++#include "confdefs.h"
++[$1]
++EOF
++dnl Capture the stderr of cpp.  eval is necessary to expand ac_cpp.
++dnl We used to copy stderr to stdout and capture it in a variable, but
++dnl that breaks under sh -x, which writes compile commands starting
++dnl with ` +' to stderr in eval and subshells.
++ac_try="$ac_cpp conftest.$ac_ext >/dev/null 2>conftest.out"
++AC_TRY_EVAL(ac_try)
++ac_err=`grep -v '^ *+' conftest.out | grep -v "^conftest.${ac_ext}\$"`
++if test -z "$ac_err"; then
++  ifelse([$2], , :, [rm -rf conftest*
++  $2])
++else
++  echo "$ac_err" >&AC_FD_CC
++  echo "configure: failed program was:" >&AC_FD_CC
++  cat conftest.$ac_ext >&AC_FD_CC
++ifelse([$3], , , [  rm -rf conftest*
++  $3
++])dnl
++fi
++rm -f conftest*])
++
++dnl AC_EGREP_HEADER(PATTERN, HEADER-FILE, ACTION-IF-FOUND [,
++dnl                 ACTION-IF-NOT-FOUND])
++AC_DEFUN(AC_EGREP_HEADER,
++[AC_EGREP_CPP([$1], [#include <$2>], [$3], [$4])])
++
++dnl Because this macro is used by AC_PROG_GCC_TRADITIONAL, which must
++dnl come early, it is not included in AC_BEFORE checks.
++dnl AC_EGREP_CPP(PATTERN, PROGRAM, [ACTION-IF-FOUND [,
++dnl              ACTION-IF-NOT-FOUND]])
++AC_DEFUN(AC_EGREP_CPP,
++[AC_REQUIRE_CPP()dnl
++cat > conftest.$ac_ext <<EOF
++[#]line __oline__ "configure"
++#include "confdefs.h"
++[$2]
++EOF
++dnl eval is necessary to expand ac_cpp.
++dnl Ultrix and Pyramid sh refuse to redirect output of eval, so use subshell.
++if (eval "$ac_cpp conftest.$ac_ext") 2>&AC_FD_CC |
++dnl Prevent m4 from eating character classes:
++changequote(, )dnl
++  egrep "$1" >/dev/null 2>&1; then
++changequote([, ])dnl
++  ifelse([$3], , :, [rm -rf conftest*
++  $3])
++ifelse([$4], , , [else
++  rm -rf conftest*
++  $4
++])dnl
++fi
++rm -f conftest*
++])
++
++
++dnl ### Examining syntax
++
++
++dnl AC_TRY_COMPILE(INCLUDES, FUNCTION-BODY,
++dnl             [ACTION-IF-FOUND [, ACTION-IF-NOT-FOUND]])
++AC_DEFUN(AC_TRY_COMPILE,
++[cat > conftest.$ac_ext <<EOF
++ifelse(AC_LANG, [FORTRAN77],
++[      program main
++[$2]
++      end],
++[dnl This sometimes fails to find confdefs.h, for some reason.
++dnl [#]line __oline__ "[$]0"
++[#]line __oline__ "configure"
++#include "confdefs.h"
++[$1]
++int main() {
++[$2]
++; return 0; }
++])EOF
++if AC_TRY_EVAL(ac_compile); then
++  ifelse([$3], , :, [rm -rf conftest*
++  $3])
++else
++  echo "configure: failed program was:" >&AC_FD_CC
++  cat conftest.$ac_ext >&AC_FD_CC
++ifelse([$4], , , [  rm -rf conftest*
++  $4
++])dnl
++fi
++rm -f conftest*])
++
++
++dnl ### Examining libraries
++
++
++dnl AC_COMPILE_CHECK(ECHO-TEXT, INCLUDES, FUNCTION-BODY,
++dnl                  ACTION-IF-FOUND [, ACTION-IF-NOT-FOUND])
++AC_DEFUN(AC_COMPILE_CHECK,
++[AC_OBSOLETE([$0], [; instead use AC_TRY_COMPILE or AC_TRY_LINK, and AC_MSG_CHECKING and AC_MSG_RESULT])dnl
++ifelse([$1], , , [AC_CHECKING([for $1])
++])dnl
++AC_TRY_LINK([$2], [$3], [$4], [$5])
++])
++
++dnl AC_TRY_LINK(INCLUDES, FUNCTION-BODY,
++dnl             [ACTION-IF-FOUND [, ACTION-IF-NOT-FOUND]])
++AC_DEFUN(AC_TRY_LINK,
++[cat > conftest.$ac_ext <<EOF
++ifelse(AC_LANG, [FORTRAN77],
++[
++      program main
++      call [$2]
++      end
++],
++[dnl This sometimes fails to find confdefs.h, for some reason.
++dnl [#]line __oline__ "[$]0"
++[#]line __oline__ "configure"
++#include "confdefs.h"
++[$1]
++int main() {
++[$2]
++; return 0; }
++])EOF
++if AC_TRY_EVAL(ac_link) && test -s conftest${ac_exeext}; then
++  ifelse([$3], , :, [rm -rf conftest*
++  $3])
++else
++  echo "configure: failed program was:" >&AC_FD_CC
++  cat conftest.$ac_ext >&AC_FD_CC
++ifelse([$4], , , [  rm -rf conftest*
++  $4
++])dnl
++fi
++rm -f conftest*])
++
++
++dnl ### Checking for run-time features
++
++
++dnl AC_TRY_RUN(PROGRAM, [ACTION-IF-TRUE [, ACTION-IF-FALSE
++dnl            [, ACTION-IF-CROSS-COMPILING]]])
++AC_DEFUN(AC_TRY_RUN,
++[if test "$cross_compiling" = yes; then
++  ifelse([$4], ,
++    [errprint(__file__:__line__: warning: [AC_TRY_RUN] called without default to allow cross compiling
++)dnl
++  AC_MSG_ERROR(can not run test program while cross compiling)],
++  [$4])
++else
++  AC_TRY_RUN_NATIVE([$1], [$2], [$3])
++fi
++])
++
++dnl Like AC_TRY_RUN but assumes a native-environment (non-cross) compiler.
++dnl AC_TRY_RUN_NATIVE(PROGRAM, [ACTION-IF-TRUE [, ACTION-IF-FALSE]])
++AC_DEFUN(AC_TRY_RUN_NATIVE,
++[cat > conftest.$ac_ext <<EOF
++[#]line __oline__ "configure"
++#include "confdefs.h"
++ifelse(AC_LANG, CPLUSPLUS, [#ifdef __cplusplus
++extern "C" void exit(int);
++#endif
++])dnl
++[$1]
++EOF
++if AC_TRY_EVAL(ac_link) && test -s conftest${ac_exeext} && (./conftest; exit) 2>/dev/null
++then
++dnl Don't remove the temporary files here, so they can be examined.
++  ifelse([$2], , :, [$2])
++else
++  echo "configure: failed program was:" >&AC_FD_CC
++  cat conftest.$ac_ext >&AC_FD_CC
++ifelse([$3], , , [  rm -fr conftest*
++  $3
++])dnl
++fi
++rm -fr conftest*])
++
++
++dnl ### Checking for header files
++
++
++dnl AC_CHECK_HEADER(HEADER-FILE, [ACTION-IF-FOUND [, ACTION-IF-NOT-FOUND]])
++AC_DEFUN(AC_CHECK_HEADER,
++[dnl Do the transliteration at runtime so arg 1 can be a shell variable.
++ac_safe=`echo "$1" | sed 'y%./+-%__p_%'`
++AC_MSG_CHECKING([for $1])
++AC_CACHE_VAL(ac_cv_header_$ac_safe,
++[AC_TRY_CPP([#include <$1>], eval "ac_cv_header_$ac_safe=yes",
++  eval "ac_cv_header_$ac_safe=no")])dnl
++if eval "test \"`echo '$ac_cv_header_'$ac_safe`\" = yes"; then
++  AC_MSG_RESULT(yes)
++  ifelse([$2], , :, [$2])
++else
++  AC_MSG_RESULT(no)
++ifelse([$3], , , [$3
++])dnl
++fi
++])
++
++dnl AC_CHECK_HEADERS(HEADER-FILE... [, ACTION-IF-FOUND [, ACTION-IF-NOT-FOUND]])
++AC_DEFUN(AC_CHECK_HEADERS,
++[for ac_hdr in $1
++do
++AC_CHECK_HEADER($ac_hdr,
++[changequote(, )dnl
++  ac_tr_hdr=HAVE_`echo $ac_hdr | sed 'y%abcdefghijklmnopqrstuvwxyz./-%ABCDEFGHIJKLMNOPQRSTUVWXYZ___%'`
++changequote([, ])dnl
++  AC_DEFINE_UNQUOTED($ac_tr_hdr) $2], $3)dnl
++done
++])
++
++
++dnl ### Checking for the existence of files
++
++dnl AC_CHECK_FILE(FILE, [ACTION-IF-FOUND [, ACTION-IF-NOT-FOUND]])
++AC_DEFUN(AC_CHECK_FILE,
++[AC_REQUIRE([AC_PROG_CC])
++dnl Do the transliteration at runtime so arg 1 can be a shell variable.
++ac_safe=`echo "$1" | sed 'y%./+-%__p_%'`
++AC_MSG_CHECKING([for $1])
++AC_CACHE_VAL(ac_cv_file_$ac_safe,
++[if test "$cross_compiling" = yes; then
++  errprint(__file__:__line__: warning: Cannot check for file existence when cross compiling
++)dnl
++  AC_MSG_ERROR(Cannot check for file existence when cross compiling)
++else
++  if test -r $1; then
++    eval "ac_cv_file_$ac_safe=yes"
++  else
++    eval "ac_cv_file_$ac_safe=no"
++  fi
++fi])dnl
++if eval "test \"`echo '$ac_cv_file_'$ac_safe`\" = yes"; then
++  AC_MSG_RESULT(yes)
++  ifelse([$2], , :, [$2])
++else
++  AC_MSG_RESULT(no)
++ifelse([$3], , , [$3])
++fi
++])
++
++dnl AC_CHECK_FILES(FILE... [, ACTION-IF-FOUND [, ACTION-IF-NOT-FOUND]])
++AC_DEFUN(AC_CHECK_FILES,
++[for ac_file in $1
++do
++AC_CHECK_FILE($ac_file,
++[changequote(, )dnl
++  ac_tr_file=HAVE_`echo $ac_file | sed 'y%abcdefghijklmnopqrstuvwxyz./-%ABCDEFGHIJKLMNOPQRSTUVWXYZ___%'`
++changequote([, ])dnl
++  AC_DEFINE_UNQUOTED($ac_tr_file) $2], $3)dnl
++done
++])
++
++
++dnl ### Checking for library functions
++
++
++dnl AC_CHECK_FUNC(FUNCTION, [ACTION-IF-FOUND [, ACTION-IF-NOT-FOUND]])
++AC_DEFUN(AC_CHECK_FUNC,
++[AC_MSG_CHECKING([for $1])
++AC_CACHE_VAL(ac_cv_func_$1,
++[AC_TRY_LINK(
++dnl Don't include <ctype.h> because on OSF/1 3.0 it includes <sys/types.h>
++dnl which includes <sys/select.h> which contains a prototype for
++dnl select.  Similarly for bzero.
++[/* System header to define __stub macros and hopefully few prototypes,
++    which can conflict with char $1(); below.  */
++#include <assert.h>
++/* Override any gcc2 internal prototype to avoid an error.  */
++]ifelse(AC_LANG, CPLUSPLUS, [#ifdef __cplusplus
++extern "C"
++#endif
++])dnl
++[/* We use char because int might match the return type of a gcc2
++    builtin and then its argument prototype would still apply.  */
++char $1();
++], [
++/* The GNU C library defines this for functions which it implements
++    to always fail with ENOSYS.  Some functions are actually named
++    something starting with __ and the normal name is an alias.  */
++#if defined (__stub_$1) || defined (__stub___$1)
++choke me
++#else
++$1();
++#endif
++], eval "ac_cv_func_$1=yes", eval "ac_cv_func_$1=no")])
++if eval "test \"`echo '$ac_cv_func_'$1`\" = yes"; then
++  AC_MSG_RESULT(yes)
++  ifelse([$2], , :, [$2])
++else
++  AC_MSG_RESULT(no)
++ifelse([$3], , , [$3
++])dnl
++fi
++])
++
++dnl AC_CHECK_FUNCS(FUNCTION... [, ACTION-IF-FOUND [, ACTION-IF-NOT-FOUND]])
++AC_DEFUN(AC_CHECK_FUNCS,
++[for ac_func in $1
++do
++AC_CHECK_FUNC($ac_func,
++[changequote(, )dnl
++  ac_tr_func=HAVE_`echo $ac_func | tr 'abcdefghijklmnopqrstuvwxyz' 'ABCDEFGHIJKLMNOPQRSTUVWXYZ'`
++changequote([, ])dnl
++  AC_DEFINE_UNQUOTED($ac_tr_func) $2], $3)dnl
++done
++])
++
++dnl AC_REPLACE_FUNCS(FUNCTION...)
++AC_DEFUN(AC_REPLACE_FUNCS,
++[AC_CHECK_FUNCS([$1], , [LIBOBJS="$LIBOBJS ${ac_func}.${ac_objext}"])
++AC_SUBST(LIBOBJS)dnl
++])
++
++
++dnl ### Checking compiler characteristics
++
++
++dnl AC_CHECK_SIZEOF(TYPE [, CROSS-SIZE])
++AC_DEFUN(AC_CHECK_SIZEOF,
++[changequote(<<, >>)dnl
++dnl The name to #define.
++define(<<AC_TYPE_NAME>>, translit(sizeof_$1, [a-z *], [A-Z_P]))dnl
++dnl The cache variable name.
++define(<<AC_CV_NAME>>, translit(ac_cv_sizeof_$1, [ *], [_p]))dnl
++changequote([, ])dnl
++AC_MSG_CHECKING(size of $1)
++AC_CACHE_VAL(AC_CV_NAME,
++[AC_TRY_RUN([#include <stdio.h>
++main()
++{
++  FILE *f=fopen("conftestval", "w");
++  if (!f) exit(1);
++  fprintf(f, "%d\n", sizeof($1));
++  exit(0);
++}], AC_CV_NAME=`cat conftestval`, AC_CV_NAME=0, ifelse([$2], , , AC_CV_NAME=$2))])dnl
++AC_MSG_RESULT($AC_CV_NAME)
++AC_DEFINE_UNQUOTED(AC_TYPE_NAME, $AC_CV_NAME)
++undefine([AC_TYPE_NAME])dnl
++undefine([AC_CV_NAME])dnl
++])
++
++
++dnl ### Checking for typedefs
++
++
++dnl AC_CHECK_TYPE(TYPE, DEFAULT)
++AC_DEFUN(AC_CHECK_TYPE,
++[AC_REQUIRE([AC_HEADER_STDC])dnl
++AC_MSG_CHECKING(for $1)
++AC_CACHE_VAL(ac_cv_type_$1,
++[AC_EGREP_CPP(dnl
++changequote(<<,>>)dnl
++<<(^|[^a-zA-Z_0-9])$1[^a-zA-Z_0-9]>>dnl
++changequote([,]), [#include <sys/types.h>
++#if STDC_HEADERS
++#include <stdlib.h>
++#include <stddef.h>
++#endif], ac_cv_type_$1=yes, ac_cv_type_$1=no)])dnl
++AC_MSG_RESULT($ac_cv_type_$1)
++if test $ac_cv_type_$1 = no; then
++  AC_DEFINE($1, $2)
++fi
++])
++
++
++dnl ### Creating output files
++
++
++dnl AC_CONFIG_HEADER(HEADER-TO-CREATE ...)
++AC_DEFUN(AC_CONFIG_HEADER,
++[define(AC_LIST_HEADER, $1)])
++
++dnl Link each of the existing files SOURCE... to the corresponding
++dnl link name in DEST...
++dnl AC_LINK_FILES(SOURCE..., DEST...)
++AC_DEFUN(AC_LINK_FILES,
++[dnl
++define([AC_LIST_FILES], ifdef([AC_LIST_FILES], [AC_LIST_FILES ],)[$1])dnl
++define([AC_LIST_LINKS], ifdef([AC_LIST_LINKS], [AC_LIST_LINKS ],)[$2])])
++
++dnl Add additional commands for AC_OUTPUT to put into config.status.
++dnl Use diversions instead of macros so we can be robust in the
++dnl presence of commas in $1 and/or $2.
++dnl AC_OUTPUT_COMMANDS(EXTRA-CMDS, INIT-CMDS)
++AC_DEFUN(AC_OUTPUT_COMMANDS,
++[AC_DIVERT_PUSH(AC_DIVERSION_CMDS)dnl
++[$1]
++AC_DIVERT_POP()dnl
++AC_DIVERT_PUSH(AC_DIVERSION_ICMDS)dnl
++[$2]
++AC_DIVERT_POP()])
++
++dnl AC_CONFIG_SUBDIRS(DIR ...)
++AC_DEFUN(AC_CONFIG_SUBDIRS,
++[AC_REQUIRE([AC_CONFIG_AUX_DIR_DEFAULT])dnl
++define([AC_LIST_SUBDIRS], ifdef([AC_LIST_SUBDIRS], [AC_LIST_SUBDIRS ],)[$1])dnl
++subdirs="AC_LIST_SUBDIRS"
++AC_SUBST(subdirs)dnl
++])
++
++dnl The big finish.
++dnl Produce config.status, config.h, and links; and configure subdirs.
++dnl AC_OUTPUT([FILE...] [, EXTRA-CMDS] [, INIT-CMDS])
++define(AC_OUTPUT,
++[trap '' 1 2 15
++AC_CACHE_SAVE
++trap 'rm -fr conftest* confdefs* core core.* *.core $ac_clean_files; exit 1' 1 2 15
++
++test "x$prefix" = xNONE && prefix=$ac_default_prefix
++# Let make expand exec_prefix.
++test "x$exec_prefix" = xNONE && exec_prefix='${prefix}'
++
++# Any assignment to VPATH causes Sun make to only execute
++# the first set of double-colon rules, so remove it if not needed.
++# If there is a colon in the path, we need to keep it.
++if test "x$srcdir" = x.; then
++changequote(, )dnl
++  ac_vpsub='/^[ 	]*VPATH[ 	]*=[^:]*$/d'
++changequote([, ])dnl
++fi
++
++trap 'rm -f $CONFIG_STATUS conftest*; exit 1' 1 2 15
++
++ifdef([AC_LIST_HEADER], [DEFS=-DHAVE_CONFIG_H], [AC_OUTPUT_MAKE_DEFS()])
++
++# Without the "./", some shells look in PATH for config.status.
++: ${CONFIG_STATUS=./config.status}
++
++echo creating $CONFIG_STATUS
++rm -f $CONFIG_STATUS
++cat > $CONFIG_STATUS <<EOF
++#! /bin/sh
++# Generated automatically by configure.
++# Run this file to recreate the current configuration.
++# This directory was configured as follows,
++dnl hostname on some systems (SVR3.2, Linux) returns a bogus exit status,
++dnl so uname gets run too.
++# on host `(hostname || uname -n) 2>/dev/null | sed 1q`:
++#
++[#] [$]0 [$]ac_configure_args
++#
++# Compiler output produced by configure, useful for debugging
++# configure, is in ./config.log if it exists.
++
++changequote(, )dnl
++ac_cs_usage="Usage: $CONFIG_STATUS [--recheck] [--version] [--help]"
++changequote([, ])dnl
++for ac_option
++do
++  case "[\$]ac_option" in
++  -recheck | --recheck | --rechec | --reche | --rech | --rec | --re | --r)
++    echo "running [\$]{CONFIG_SHELL-/bin/sh} [$]0 [$]ac_configure_args --no-create --no-recursion"
++    exec [\$]{CONFIG_SHELL-/bin/sh} [$]0 [$]ac_configure_args --no-create --no-recursion ;;
++  -version | --version | --versio | --versi | --vers | --ver | --ve | --v)
++    echo "$CONFIG_STATUS generated by autoconf version AC_ACVERSION"
++    exit 0 ;;
++  -help | --help | --hel | --he | --h)
++    echo "[\$]ac_cs_usage"; exit 0 ;;
++  *) echo "[\$]ac_cs_usage"; exit 1 ;;
++  esac
++done
++
++ac_given_srcdir=$srcdir
++ifdef([AC_PROVIDE_AC_PROG_INSTALL], [ac_given_INSTALL="$INSTALL"
++])dnl
++
++changequote(<<, >>)dnl
++ifdef(<<AC_LIST_HEADER>>,
++<<trap 'rm -fr `echo "$1 AC_LIST_HEADER" | sed "s/:[^ ]*//g"` conftest*; exit 1' 1 2 15>>,
++<<trap 'rm -fr `echo "$1" | sed "s/:[^ ]*//g"` conftest*; exit 1' 1 2 15>>)
++changequote([, ])dnl
++EOF
++cat >> $CONFIG_STATUS <<EOF
++
++AC_OUTPUT_FILES($1)
++ifdef([AC_LIST_HEADER], [AC_OUTPUT_HEADER(AC_LIST_HEADER)])dnl
++ifdef([AC_LIST_LINKS], [AC_OUTPUT_LINKS(AC_LIST_FILES, AC_LIST_LINKS)])dnl
++EOF
++cat >> $CONFIG_STATUS <<EOF
++undivert(AC_DIVERSION_ICMDS)dnl
++$3
++EOF
++cat >> $CONFIG_STATUS <<\EOF
++undivert(AC_DIVERSION_CMDS)dnl
++$2
++exit 0
++EOF
++chmod +x $CONFIG_STATUS
++rm -fr confdefs* $ac_clean_files
++test "$no_create" = yes || ${CONFIG_SHELL-/bin/sh} $CONFIG_STATUS || exit 1
++dnl config.status should not do recursion.
++ifdef([AC_LIST_SUBDIRS], [AC_OUTPUT_SUBDIRS(AC_LIST_SUBDIRS)])dnl
++])dnl
++
++dnl Set the DEFS variable to the -D options determined earlier.
++dnl This is a subroutine of AC_OUTPUT.
++dnl It is called inside configure, outside of config.status.
++dnl AC_OUTPUT_MAKE_DEFS()
++define(AC_OUTPUT_MAKE_DEFS,
++[# Transform confdefs.h into DEFS.
++dnl Using a here document instead of a string reduces the quoting nightmare.
++# Protect against shell expansion while executing Makefile rules.
++# Protect against Makefile macro expansion.
++cat > conftest.defs <<\EOF
++changequote(<<, >>)dnl
++s%<<#define>> \([A-Za-z_][A-Za-z0-9_]*\) *\(.*\)%-D\1=\2%g
++s%[ 	`~<<#>>$^&*(){}\\|;'"<>?]%\\&%g
++s%\[%\\&%g
++s%\]%\\&%g
++s%\$%$$%g
++changequote([, ])dnl
++EOF
++DEFS=`sed -f conftest.defs confdefs.h | tr '\012' ' '`
++rm -f conftest.defs
++])
++
++dnl Do the variable substitutions to create the Makefiles or whatever.
++dnl This is a subroutine of AC_OUTPUT.  It is called inside an unquoted
++dnl here document whose contents are going into config.status, but
++dnl upon returning, the here document is being quoted.
++dnl AC_OUTPUT_FILES(FILE...)
++define(AC_OUTPUT_FILES,
++[# Protect against being on the right side of a sed subst in config.status.
++changequote(, )dnl
++sed 's/%@/@@/; s/@%/@@/; s/%g\$/@g/; /@g\$/s/[\\\\&%]/\\\\&/g;
++ s/@@/%@/; s/@@/@%/; s/@g\$/%g/' > conftest.subs <<\\CEOF
++changequote([, ])dnl
++dnl These here document variables are unquoted when configure runs
++dnl but quoted when config.status runs, so variables are expanded once.
++$ac_vpsub
++dnl Shell code in configure.in might set extrasub.
++$extrasub
++dnl Insert the sed substitutions of variables.
++undivert(AC_DIVERSION_SED)
++CEOF
++EOF
++
++cat >> $CONFIG_STATUS <<\EOF
++
++# Split the substitutions into bite-sized pieces for seds with
++# small command number limits, like on Digital OSF/1 and HP-UX.
++ac_max_sed_cmds=90 # Maximum number of lines to put in a sed script.
++ac_file=1 # Number of current file.
++ac_beg=1 # First line for current file.
++ac_end=$ac_max_sed_cmds # Line after last line for current file.
++ac_more_lines=:
++ac_sed_cmds=""
++while $ac_more_lines; do
++  if test $ac_beg -gt 1; then
++    sed "1,${ac_beg}d; ${ac_end}q" conftest.subs > conftest.s$ac_file
++  else
++    sed "${ac_end}q" conftest.subs > conftest.s$ac_file
++  fi
++  if test ! -s conftest.s$ac_file; then
++    ac_more_lines=false
++    rm -f conftest.s$ac_file
++  else
++    if test -z "$ac_sed_cmds"; then
++      ac_sed_cmds="sed -f conftest.s$ac_file"
++    else
++      ac_sed_cmds="$ac_sed_cmds | sed -f conftest.s$ac_file"
++    fi
++    ac_file=`expr $ac_file + 1`
++    ac_beg=$ac_end
++    ac_end=`expr $ac_end + $ac_max_sed_cmds`
++  fi
++done
++if test -z "$ac_sed_cmds"; then
++  ac_sed_cmds=cat
++fi
++EOF
++
++cat >> $CONFIG_STATUS <<EOF
++
++CONFIG_FILES=\${CONFIG_FILES-"$1"}
++EOF
++cat >> $CONFIG_STATUS <<\EOF
++for ac_file in .. $CONFIG_FILES; do if test "x$ac_file" != x..; then
++changequote(, )dnl
++  # Support "outfile[:infile[:infile...]]", defaulting infile="outfile.in".
++  case "$ac_file" in
++  *:*) ac_file_in=`echo "$ac_file"|sed 's%[^:]*:%%'`
++       ac_file=`echo "$ac_file"|sed 's%:.*%%'` ;;
++  *) ac_file_in="${ac_file}.in" ;;
++  esac
++
++  # Adjust a relative srcdir, top_srcdir, and INSTALL for subdirectories.
++
++  # Remove last slash and all that follows it.  Not all systems have dirname.
++  ac_dir=`echo $ac_file|sed 's%/[^/][^/]*$%%'`
++changequote([, ])dnl
++  if test "$ac_dir" != "$ac_file" && test "$ac_dir" != .; then
++    # The file is in a subdirectory.
++    test ! -d "$ac_dir" && mkdir "$ac_dir"
++    ac_dir_suffix="/`echo $ac_dir|sed 's%^\./%%'`"
++    # A "../" for each directory in $ac_dir_suffix.
++changequote(, )dnl
++    ac_dots=`echo $ac_dir_suffix|sed 's%/[^/]*%../%g'`
++changequote([, ])dnl
++  else
++    ac_dir_suffix= ac_dots=
++  fi
++
++  case "$ac_given_srcdir" in
++  .)  srcdir=.
++      if test -z "$ac_dots"; then top_srcdir=.
++      else top_srcdir=`echo $ac_dots|sed 's%/$%%'`; fi ;;
++  /*) srcdir="$ac_given_srcdir$ac_dir_suffix"; top_srcdir="$ac_given_srcdir" ;;
++  *) # Relative path.
++    srcdir="$ac_dots$ac_given_srcdir$ac_dir_suffix"
++    top_srcdir="$ac_dots$ac_given_srcdir" ;;
++  esac
++
++ifdef([AC_PROVIDE_AC_PROG_INSTALL],
++[  case "$ac_given_INSTALL" in
++changequote(, )dnl
++  [/$]*) INSTALL="$ac_given_INSTALL" ;;
++changequote([, ])dnl
++  *) INSTALL="$ac_dots$ac_given_INSTALL" ;;
++  esac
++])dnl
++
++  echo creating "$ac_file"
++  rm -f "$ac_file"
++  configure_input="Generated automatically from `echo $ac_file_in|sed 's%.*/%%'` by configure."
++  case "$ac_file" in
++  *Makefile*) ac_comsub="1i\\
++# $configure_input" ;;
++  *) ac_comsub= ;;
++  esac
++
++  ac_file_inputs=`echo $ac_file_in|sed -e "s%^%$ac_given_srcdir/%" -e "s%:% $ac_given_srcdir/%g"`
++  sed -e "$ac_comsub
++s%@configure_input@%$configure_input%g
++s%@srcdir@%$srcdir%g
++s%@top_srcdir@%$top_srcdir%g
++ifdef([AC_PROVIDE_AC_PROG_INSTALL], [s%@INSTALL@%$INSTALL%g
++])dnl
++dnl The parens around the eval prevent an "illegal io" in Ultrix sh.
++" $ac_file_inputs | (eval "$ac_sed_cmds") > $ac_file
++dnl This would break Makefile dependencies.
++dnl  if cmp -s $ac_file conftest.out 2>/dev/null; then
++dnl    echo "$ac_file is unchanged"
++dnl    rm -f conftest.out
++dnl   else
++dnl     rm -f $ac_file
++dnl    mv conftest.out $ac_file
++dnl  fi
++fi; done
++rm -f conftest.s*
++])
++
++dnl Create the config.h files from the config.h.in files.
++dnl This is a subroutine of AC_OUTPUT.  It is called inside a quoted
++dnl here document whose contents are going into config.status.
++dnl AC_OUTPUT_HEADER(HEADER-FILE...)
++define(AC_OUTPUT_HEADER,
++[changequote(<<, >>)dnl
++# These sed commands are passed to sed as "A NAME B NAME C VALUE D", where
++# NAME is the cpp macro being defined and VALUE is the value it is being given.
++#
++# ac_d sets the value in "#define NAME VALUE" lines.
++ac_dA='s%^\([ 	]*\)#\([ 	]*define[ 	][ 	]*\)'
++ac_dB='\([ 	][ 	]*\)[^ 	]*%\1#\2'
++ac_dC='\3'
++ac_dD='%g'
++# ac_u turns "#undef NAME" with trailing blanks into "#define NAME VALUE".
++ac_uA='s%^\([ 	]*\)#\([ 	]*\)undef\([ 	][ 	]*\)'
++ac_uB='\([ 	]\)%\1#\2define\3'
++ac_uC=' '
++ac_uD='\4%g'
++# ac_e turns "#undef NAME" without trailing blanks into "#define NAME VALUE".
++ac_eA='s%^\([ 	]*\)#\([ 	]*\)undef\([ 	][ 	]*\)'
++ac_eB='<<$>>%\1#\2define\3'
++ac_eC=' '
++ac_eD='%g'
++changequote([, ])dnl
++
++if test "${CONFIG_HEADERS+set}" != set; then
++EOF
++dnl Support passing AC_CONFIG_HEADER a value containing shell variables.
++cat >> $CONFIG_STATUS <<EOF
++  CONFIG_HEADERS="$1"
++EOF
++cat >> $CONFIG_STATUS <<\EOF
++fi
++for ac_file in .. $CONFIG_HEADERS; do if test "x$ac_file" != x..; then
++changequote(, )dnl
++  # Support "outfile[:infile[:infile...]]", defaulting infile="outfile.in".
++  case "$ac_file" in
++  *:*) ac_file_in=`echo "$ac_file"|sed 's%[^:]*:%%'`
++       ac_file=`echo "$ac_file"|sed 's%:.*%%'` ;;
++  *) ac_file_in="${ac_file}.in" ;;
++  esac
++changequote([, ])dnl
++
++  echo creating $ac_file
++
++  rm -f conftest.frag conftest.in conftest.out
++  ac_file_inputs=`echo $ac_file_in|sed -e "s%^%$ac_given_srcdir/%" -e "s%:% $ac_given_srcdir/%g"`
++  cat $ac_file_inputs > conftest.in
++
++EOF
++
++# Transform confdefs.h into a sed script conftest.vals that substitutes
++# the proper values into config.h.in to produce config.h.  And first:
++# Protect against being on the right side of a sed subst in config.status.
++# Protect against being in an unquoted here document in config.status.
++rm -f conftest.vals
++dnl Using a here document instead of a string reduces the quoting nightmare.
++dnl Putting comments in sed scripts is not portable.
++cat > conftest.hdr <<\EOF
++changequote(<<, >>)dnl
++s/[\\&%]/\\&/g
++s%[\\$`]%\\&%g
++s%<<#define>> \([A-Za-z_][A-Za-z0-9_]*\) *\(.*\)%${ac_dA}\1${ac_dB}\1${ac_dC}\2${ac_dD}%gp
++s%ac_d%ac_u%gp
++s%ac_u%ac_e%gp
++changequote([, ])dnl
++EOF
++sed -n -f conftest.hdr confdefs.h > conftest.vals
++rm -f conftest.hdr
++
++# This sed command replaces #undef with comments.  This is necessary, for
++# example, in the case of _POSIX_SOURCE, which is predefined and required
++# on some systems where configure will not decide to define it.
++cat >> conftest.vals <<\EOF
++changequote(, )dnl
++s%^[ 	]*#[ 	]*undef[ 	][ 	]*[a-zA-Z_][a-zA-Z_0-9]*%/* & */%
++changequote([, ])dnl
++EOF
++
++# Break up conftest.vals because some shells have a limit on
++# the size of here documents, and old seds have small limits too.
++
++rm -f conftest.tail
++while :
++do
++  ac_lines=`grep -c . conftest.vals`
++  # grep -c gives empty output for an empty file on some AIX systems.
++  if test -z "$ac_lines" || test "$ac_lines" -eq 0; then break; fi
++  # Write a limited-size here document to conftest.frag.
++  echo '  cat > conftest.frag <<CEOF' >> $CONFIG_STATUS
++  sed ${ac_max_here_lines}q conftest.vals >> $CONFIG_STATUS
++  echo 'CEOF
++  sed -f conftest.frag conftest.in > conftest.out
++  rm -f conftest.in
++  mv conftest.out conftest.in
++' >> $CONFIG_STATUS
++  sed 1,${ac_max_here_lines}d conftest.vals > conftest.tail
++  rm -f conftest.vals
++  mv conftest.tail conftest.vals
++done
++rm -f conftest.vals
++
++dnl Now back to your regularly scheduled config.status.
++cat >> $CONFIG_STATUS <<\EOF
++  rm -f conftest.frag conftest.h
++  echo "/* $ac_file.  Generated automatically by configure.  */" > conftest.h
++  cat conftest.in >> conftest.h
++  rm -f conftest.in
++  if cmp -s $ac_file conftest.h 2>/dev/null; then
++    echo "$ac_file is unchanged"
++    rm -f conftest.h
++  else
++    # Remove last slash and all that follows it.  Not all systems have dirname.
++  changequote(, )dnl
++    ac_dir=`echo $ac_file|sed 's%/[^/][^/]*$%%'`
++  changequote([, ])dnl
++    if test "$ac_dir" != "$ac_file" && test "$ac_dir" != .; then
++      # The file is in a subdirectory.
++      test ! -d "$ac_dir" && mkdir "$ac_dir"
++    fi
++    rm -f $ac_file
++    mv conftest.h $ac_file
++  fi
++fi; done
++
++])
++
++dnl This is a subroutine of AC_OUTPUT.  It is called inside a quoted
++dnl here document whose contents are going into config.status.
++dnl AC_OUTPUT_LINKS(SOURCE..., DEST...)
++define(AC_OUTPUT_LINKS,
++[EOF
++
++cat >> $CONFIG_STATUS <<EOF
++ac_sources="$1"
++ac_dests="$2"
++EOF
++
++cat >> $CONFIG_STATUS <<\EOF
++srcdir=$ac_given_srcdir
++while test -n "$ac_sources"; do
++  set $ac_dests; ac_dest=[$]1; shift; ac_dests=[$]*
++  set $ac_sources; ac_source=[$]1; shift; ac_sources=[$]*
++
++  echo "linking $srcdir/$ac_source to $ac_dest"
++
++  if test ! -r $srcdir/$ac_source; then
++    AC_MSG_ERROR($srcdir/$ac_source: File not found)
++  fi
++  rm -f $ac_dest
++
++  # Make relative symlinks.
++  # Remove last slash and all that follows it.  Not all systems have dirname.
++changequote(, )dnl
++  ac_dest_dir=`echo $ac_dest|sed 's%/[^/][^/]*$%%'`
++changequote([, ])dnl
++  if test "$ac_dest_dir" != "$ac_dest" && test "$ac_dest_dir" != .; then
++    # The dest file is in a subdirectory.
++    test ! -d "$ac_dest_dir" && mkdir "$ac_dest_dir"
++    ac_dest_dir_suffix="/`echo $ac_dest_dir|sed 's%^\./%%'`"
++    # A "../" for each directory in $ac_dest_dir_suffix.
++changequote(, )dnl
++    ac_dots=`echo $ac_dest_dir_suffix|sed 's%/[^/]*%../%g'`
++changequote([, ])dnl
++  else
++    ac_dest_dir_suffix= ac_dots=
++  fi
++
++  case "$srcdir" in
++changequote(, )dnl
++  [/$]*) ac_rel_source="$srcdir/$ac_source" ;;
++changequote([, ])dnl
++  *) ac_rel_source="$ac_dots$srcdir/$ac_source" ;;
++  esac
++
++  # Make a symlink if possible; otherwise try a hard link.
++  if ln -s $ac_rel_source $ac_dest 2>/dev/null ||
++    ln $srcdir/$ac_source $ac_dest; then :
++  else
++    AC_MSG_ERROR(can not link $ac_dest to $srcdir/$ac_source)
++  fi
++done
++])
++
++dnl This is a subroutine of AC_OUTPUT.
++dnl It is called after running config.status.
++dnl AC_OUTPUT_SUBDIRS(DIRECTORY...)
++define(AC_OUTPUT_SUBDIRS,
++[
++if test "$no_recursion" != yes; then
++
++  # Remove --cache-file and --srcdir arguments so they do not pile up.
++  ac_sub_configure_args=
++  ac_prev=
++  for ac_arg in $ac_configure_args; do
++    if test -n "$ac_prev"; then
++      ac_prev=
++      continue
++    fi
++    case "$ac_arg" in
++    -cache-file | --cache-file | --cache-fil | --cache-fi \
++    | --cache-f | --cache- | --cache | --cach | --cac | --ca | --c)
++      ac_prev=cache_file ;;
++    -cache-file=* | --cache-file=* | --cache-fil=* | --cache-fi=* \
++    | --cache-f=* | --cache-=* | --cache=* | --cach=* | --cac=* | --ca=* | --c=*)
++      ;;
++    -srcdir | --srcdir | --srcdi | --srcd | --src | --sr)
++      ac_prev=srcdir ;;
++    -srcdir=* | --srcdir=* | --srcdi=* | --srcd=* | --src=* | --sr=*)
++      ;;
++    *) ac_sub_configure_args="$ac_sub_configure_args $ac_arg" ;;
++    esac
++  done
++
++  for ac_config_dir in $1; do
++
++    # Do not complain, so a configure script can configure whichever
++    # parts of a large source tree are present.
++    if test ! -d $srcdir/$ac_config_dir; then
++      continue
++    fi
++
++    echo configuring in $ac_config_dir
++
++    case "$srcdir" in
++    .) ;;
++    *)
++      if test -d ./$ac_config_dir || mkdir ./$ac_config_dir; then :;
++      else
++        AC_MSG_ERROR(can not create `pwd`/$ac_config_dir)
++      fi
++      ;;
++    esac
++
++    ac_popdir=`pwd`
++    cd $ac_config_dir
++
++changequote(, )dnl
++      # A "../" for each directory in /$ac_config_dir.
++      ac_dots=`echo $ac_config_dir|sed -e 's%^\./%%' -e 's%[^/]$%&/%' -e 's%[^/]*/%../%g'`
++changequote([, ])dnl
++
++    case "$srcdir" in
++    .) # No --srcdir option.  We are building in place.
++      ac_sub_srcdir=$srcdir ;;
++    /*) # Absolute path.
++      ac_sub_srcdir=$srcdir/$ac_config_dir ;;
++    *) # Relative path.
++      ac_sub_srcdir=$ac_dots$srcdir/$ac_config_dir ;;
++    esac
++
++    # Check for guested configure; otherwise get Cygnus style configure.
++    if test -f $ac_sub_srcdir/configure; then
++      ac_sub_configure=$ac_sub_srcdir/configure
++    elif test -f $ac_sub_srcdir/configure.in; then
++      ac_sub_configure=$ac_configure
++    else
++      AC_MSG_WARN(no configuration information is in $ac_config_dir)
++      ac_sub_configure=
++    fi
++
++    # The recursion is here.
++    if test -n "$ac_sub_configure"; then
++
++      # Make the cache file name correct relative to the subdirectory.
++      case "$cache_file" in
++      /*) ac_sub_cache_file=$cache_file ;;
++      *) # Relative path.
++        ac_sub_cache_file="$ac_dots$cache_file" ;;
++      esac
++ifdef([AC_PROVIDE_AC_PROG_INSTALL],
++      [  case "$ac_given_INSTALL" in
++changequote(, )dnl
++        [/$]*) INSTALL="$ac_given_INSTALL" ;;
++changequote([, ])dnl
++        *) INSTALL="$ac_dots$ac_given_INSTALL" ;;
++        esac
++])dnl
++
++      echo "[running ${CONFIG_SHELL-/bin/sh} $ac_sub_configure $ac_sub_configure_args --cache-file=$ac_sub_cache_file] --srcdir=$ac_sub_srcdir"
++      # The eval makes quoting arguments work.
++      if eval ${CONFIG_SHELL-/bin/sh} $ac_sub_configure $ac_sub_configure_args --cache-file=$ac_sub_cache_file --srcdir=$ac_sub_srcdir
++      then :
++      else
++        AC_MSG_ERROR($ac_sub_configure failed for $ac_config_dir)
++      fi
++    fi
++
++    cd $ac_popdir
++  done
++fi
++])
+diff --git a/build/autoconf/acoldnames.m4 b/build/autoconf/acoldnames.m4
+new file mode 100644
+--- /dev/null
++++ b/build/autoconf/acoldnames.m4
+@@ -0,0 +1,80 @@
++dnl Map old names of Autoconf macros to new regularized names.
++dnl This file is part of Autoconf.
++dnl Copyright (C) 1994 Free Software Foundation, Inc.
++dnl
++dnl This program is free software; you can redistribute it and/or modify
++dnl it under the terms of the GNU General Public License as published by
++dnl the Free Software Foundation; either version 2, or (at your option)
++dnl any later version.
++dnl
++dnl This program is distributed in the hope that it will be useful,
++dnl but WITHOUT ANY WARRANTY; without even the implied warranty of
++dnl MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
++dnl GNU General Public License for more details.
++dnl
++dnl You should have received a copy of the GNU General Public License
++dnl along with this program; if not, write to the Free Software
++dnl Foundation, Inc., 59 Temple Place - Suite 330, Boston, MA
++dnl 02111-1307, USA.
++dnl
++dnl General macros.
++dnl
++define(AC_WARN, [indir([AC_MSG_WARN], $@)])dnl
++define(AC_ERROR, [indir([AC_MSG_ERROR], $@)])dnl
++AC_DEFUN(AC_PROGRAM_CHECK, [indir([AC_CHECK_PROG], $@)])dnl
++AC_DEFUN(AC_PROGRAM_PATH, [indir([AC_PATH_PROG], $@)])dnl
++AC_DEFUN(AC_PROGRAMS_CHECK, [indir([AC_CHECK_PROGS], $@)])dnl
++AC_DEFUN(AC_PROGRAMS_PATH, [indir([AC_PATH_PROGS], $@)])dnl
++AC_DEFUN(AC_PREFIX, [indir([AC_PREFIX_PROGRAM], $@)])dnl
++AC_DEFUN(AC_HEADER_EGREP, [indir([AC_EGREP_HEADER], $@)])dnl
++AC_DEFUN(AC_PROGRAM_EGREP, [indir([AC_EGREP_CPP], $@)])dnl
++AC_DEFUN(AC_TEST_PROGRAM, [indir([AC_TRY_RUN], $@)])dnl
++AC_DEFUN(AC_TEST_CPP, [indir([AC_TRY_CPP], $@)])dnl
++AC_DEFUN(AC_HEADER_CHECK, [indir([AC_CHECK_HEADER], $@)])dnl
++AC_DEFUN(AC_FUNC_CHECK, [indir([AC_CHECK_FUNC], $@)])dnl
++AC_DEFUN(AC_HAVE_FUNCS, [indir([AC_CHECK_FUNCS], $@)])dnl
++AC_DEFUN(AC_HAVE_HEADERS, [indir([AC_CHECK_HEADERS], $@)])dnl
++AC_DEFUN(AC_SIZEOF_TYPE, [indir([AC_CHECK_SIZEOF], $@)])dnl
++dnl
++dnl Specific macros.
++dnl
++AC_DEFUN(AC_GCC_TRADITIONAL, [indir([AC_PROG_GCC_TRADITIONAL])])dnl
++AC_DEFUN(AC_MINUS_C_MINUS_O, [indir([AC_PROG_CC_C_O])])dnl
++AC_DEFUN(AC_SET_MAKE, [indir([AC_PROG_MAKE_SET])])dnl
++AC_DEFUN(AC_YYTEXT_POINTER, [indir([AC_DECL_YYTEXT])])dnl
++AC_DEFUN(AC_LN_S, [indir([AC_PROG_LN_S])])dnl
++AC_DEFUN(AC_STDC_HEADERS, [indir([AC_HEADER_STDC])])dnl
++AC_DEFUN(AC_MAJOR_HEADER, [indir([AC_HEADER_MAJOR])])dnl
++AC_DEFUN(AC_STAT_MACROS_BROKEN, [indir([AC_HEADER_STAT])])dnl
++AC_DEFUN(AC_SYS_SIGLIST_DECLARED, [indir([AC_DECL_SYS_SIGLIST])])dnl
++AC_DEFUN(AC_GETGROUPS_T, [indir([AC_TYPE_GETGROUPS])])dnl
++AC_DEFUN(AC_UID_T, [indir([AC_TYPE_UID_T])])dnl
++AC_DEFUN(AC_SIZE_T, [indir([AC_TYPE_SIZE_T])])dnl
++AC_DEFUN(AC_PID_T, [indir([AC_TYPE_PID_T])])dnl
++AC_DEFUN(AC_OFF_T, [indir([AC_TYPE_OFF_T])])dnl
++AC_DEFUN(AC_MODE_T, [indir([AC_TYPE_MODE_T])])dnl
++AC_DEFUN(AC_RETSIGTYPE, [indir([AC_TYPE_SIGNAL])])dnl
++AC_DEFUN(AC_MMAP, [indir([AC_FUNC_MMAP])])dnl
++AC_DEFUN(AC_VPRINTF, [indir([AC_FUNC_VPRINTF])])dnl
++AC_DEFUN(AC_VFORK, [indir([AC_FUNC_VFORK])])dnl
++AC_DEFUN(AC_WAIT3, [indir([AC_FUNC_WAIT3])])dnl
++AC_DEFUN(AC_ALLOCA, [indir([AC_FUNC_ALLOCA])])dnl
++AC_DEFUN(AC_GETLOADAVG, [indir([AC_FUNC_GETLOADAVG])])dnl
++AC_DEFUN(AC_UTIME_NULL, [indir([AC_FUNC_UTIME_NULL])])dnl
++AC_DEFUN(AC_STRCOLL, [indir([AC_FUNC_STRCOLL])])dnl
++AC_DEFUN(AC_SETVBUF_REVERSED, [indir([AC_FUNC_SETVBUF_REVERSED])])dnl
++AC_DEFUN(AC_TIME_WITH_SYS_TIME, [indir([AC_HEADER_TIME])])dnl
++AC_DEFUN(AC_TIMEZONE, [indir([AC_STRUCT_TIMEZONE])])dnl
++AC_DEFUN(AC_ST_BLOCKS, [indir([AC_STRUCT_ST_BLOCKS])])dnl
++AC_DEFUN(AC_ST_BLKSIZE, [indir([AC_STRUCT_ST_BLKSIZE])])dnl
++AC_DEFUN(AC_ST_RDEV, [indir([AC_STRUCT_ST_RDEV])])dnl
++AC_DEFUN(AC_CROSS_CHECK, [indir([AC_C_CROSS])])dnl
++AC_DEFUN(AC_CHAR_UNSIGNED, [indir([AC_C_CHAR_UNSIGNED])])dnl
++AC_DEFUN(AC_LONG_DOUBLE, [indir([AC_C_LONG_DOUBLE])])dnl
++AC_DEFUN(AC_WORDS_BIGENDIAN, [indir([AC_C_BIGENDIAN])])dnl
++AC_DEFUN(AC_INLINE, [indir([AC_C_INLINE])])dnl
++AC_DEFUN(AC_CONST, [indir([AC_C_CONST])])dnl
++AC_DEFUN(AC_LONG_FILE_NAMES, [indir([AC_SYS_LONG_FILE_NAMES])])dnl
++AC_DEFUN(AC_RESTARTABLE_SYSCALLS, [indir([AC_SYS_RESTARTABLE_SYSCALLS])])dnl
++AC_DEFUN(AC_FIND_X, [indir([AC_PATH_X])])dnl
++AC_DEFUN(AC_FIND_XTRA, [indir([AC_PATH_XTRA])])dnl
+diff --git a/build/autoconf/acspecific.m4 b/build/autoconf/acspecific.m4
+new file mode 100644
+--- /dev/null
++++ b/build/autoconf/acspecific.m4
+@@ -0,0 +1,2758 @@
++dnl Macros that test for specific features.
++dnl This file is part of Autoconf.
++dnl Copyright (C) 1992, 93, 94, 95, 96, 1998 Free Software Foundation, Inc.
++dnl
++dnl This program is free software; you can redistribute it and/or modify
++dnl it under the terms of the GNU General Public License as published by
++dnl the Free Software Foundation; either version 2, or (at your option)
++dnl any later version.
++dnl
++dnl This program is distributed in the hope that it will be useful,
++dnl but WITHOUT ANY WARRANTY; without even the implied warranty of
++dnl MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
++dnl GNU General Public License for more details.
++dnl
++dnl You should have received a copy of the GNU General Public License
++dnl along with this program; if not, write to the Free Software
++dnl Foundation, Inc., 59 Temple Place - Suite 330, Boston, MA
++dnl 02111-1307, USA.
++dnl
++dnl As a special exception, the Free Software Foundation gives unlimited
++dnl permission to copy, distribute and modify the configure scripts that
++dnl are the output of Autoconf.  You need not follow the terms of the GNU
++dnl General Public License when using or distributing such scripts, even
++dnl though portions of the text of Autoconf appear in them.  The GNU
++dnl General Public License (GPL) does govern all other use of the material
++dnl that constitutes the Autoconf program.
++dnl
++dnl Certain portions of the Autoconf source text are designed to be copied
++dnl (in certain cases, depending on the input) into the output of
++dnl Autoconf.  We call these the "data" portions.  The rest of the Autoconf
++dnl source text consists of comments plus executable code that decides which
++dnl of the data portions to output in any given case.  We call these
++dnl comments and executable code the "non-data" portions.  Autoconf never
++dnl copies any of the non-data portions into its output.
++dnl
++dnl This special exception to the GPL applies to versions of Autoconf
++dnl released by the Free Software Foundation.  When you make and
++dnl distribute a modified version of Autoconf, you may extend this special
++dnl exception to the GPL to apply to your modified version as well, *unless*
++dnl your modified version has the potential to copy into its output some
++dnl of the text that was the non-data portion of the version that you started
++dnl with.  (In other words, unless your change moves or copies text from
++dnl the non-data portions to the data portions.)  If your modification has
++dnl such potential, you must delete any notice of this special exception
++dnl to the GPL from your modified version.
++dnl
++dnl Written by David MacKenzie, with help from
++dnl Franc,ois Pinard, Karl Berry, Richard Pixley, Ian Lance Taylor,
++dnl Roland McGrath, Noah Friedman, david d zuhn, and many others.
++
++
++dnl ### Checks for programs
++
++
++dnl Check whether to use -n, \c, or newline-tab to separate
++dnl checking messages from result messages.
++dnl Idea borrowed from dist 3.0.
++dnl Internal use only.
++AC_DEFUN(AC_PROG_ECHO_N,
++[if (echo "testing\c"; echo 1,2,3) | grep c >/dev/null; then
++  # Stardent Vistra SVR4 grep lacks -e, says ghazi@caip.rutgers.edu.
++  if (echo -n testing; echo 1,2,3) | sed s/-n/xn/ | grep xn >/dev/null; then
++    ac_n= ac_c='
++' ac_t='	'
++  else
++    ac_n=-n ac_c= ac_t=
++  fi
++else
++  ac_n= ac_c='\c' ac_t=
++fi
++])
++
++AC_DEFUN(AC_PROG_CC,
++[AC_BEFORE([$0], [AC_PROG_CPP])dnl
++AC_CHECK_PROG(CC, gcc, gcc)
++if test -z "$CC"; then
++  AC_CHECK_PROG(CC, cc, cc, , , /usr/ucb/cc)
++  if test -z "$CC"; then
++    case "`uname -s`" in
++    *win32* | *WIN32*)
++      AC_CHECK_PROG(CC, cl, cl) ;;
++    esac
++  fi
++  test -z "$CC" && AC_MSG_ERROR([no acceptable cc found in \$PATH])
++fi
++
++AC_PROG_CC_WORKS
++AC_PROG_CC_GNU
++
++if test $ac_cv_prog_gcc = yes; then
++  GCC=yes
++else
++  GCC=
++fi
++
++dnl Check whether -g works, even if CFLAGS is set, in case the package
++dnl plays around with CFLAGS (such as to build both debugging and
++dnl normal versions of a library), tasteless as that idea is.
++ac_test_CFLAGS="${CFLAGS+set}"
++ac_save_CFLAGS="$CFLAGS"
++CFLAGS=
++AC_PROG_CC_G
++if test "$ac_test_CFLAGS" = set; then
++  CFLAGS="$ac_save_CFLAGS"
++elif test $ac_cv_prog_cc_g = yes; then
++  if test "$GCC" = yes; then
++    CFLAGS="-g -O2"
++  else
++    CFLAGS="-g"
++  fi
++else
++  if test "$GCC" = yes; then
++    CFLAGS="-O2"
++  else
++    CFLAGS=
++  fi
++fi
++])
++
++AC_DEFUN(AC_PROG_CXX,
++[AC_BEFORE([$0], [AC_PROG_CXXCPP])dnl
++AC_CHECK_PROGS(CXX, $CCC c++ g++ gcc CC cxx cc++ cl, gcc)
++
++AC_PROG_CXX_WORKS
++AC_PROG_CXX_GNU
++
++if test $ac_cv_prog_gxx = yes; then
++  GXX=yes
++else
++  GXX=
++fi
++
++dnl Check whether -g works, even if CXXFLAGS is set, in case the package
++dnl plays around with CXXFLAGS (such as to build both debugging and
++dnl normal versions of a library), tasteless as that idea is.
++ac_test_CXXFLAGS="${CXXFLAGS+set}"
++ac_save_CXXFLAGS="$CXXFLAGS"
++CXXFLAGS=
++AC_PROG_CXX_G
++if test "$ac_test_CXXFLAGS" = set; then
++  CXXFLAGS="$ac_save_CXXFLAGS"
++elif test $ac_cv_prog_cxx_g = yes; then
++  if test "$GXX" = yes; then
++    CXXFLAGS="-g -O2"
++  else
++    CXXFLAGS="-g"
++  fi
++else
++  if test "$GXX" = yes; then
++    CXXFLAGS="-O2"
++  else
++    CXXFLAGS=
++  fi
++fi
++])
++
++dnl Determine a Fortran 77 compiler to use.  If `F77' is not already set
++dnl in the environment, check for `g77', `f77' and `f2c', in that order.
++dnl Set the output variable `F77' to the name of the compiler found.
++dnl 
++dnl If using `g77' (the GNU Fortran 77 compiler), then `AC_PROG_F77'
++dnl will set the shell variable `G77' to `yes', and empty otherwise.  If
++dnl the output variable `FFLAGS' was not already set in the environment,
++dnl then set it to `-g -02' for `g77' (or `-O2' where `g77' does not
++dnl accept `-g').  Otherwise, set `FFLAGS' to `-g' for all other Fortran
++dnl 77 compilers.
++dnl 
++dnl AC_PROG_F77()
++AC_DEFUN(AC_PROG_F77,
++[AC_BEFORE([$0], [AC_PROG_CPP])dnl
++if test -z "$F77"; then
++  AC_CHECK_PROGS(F77, g77 f77 f2c)
++    test -z "$F77" && AC_MSG_ERROR([no acceptable Fortran 77 compiler found in \$PATH])
++fi
++
++AC_PROG_F77_WORKS
++AC_PROG_F77_GNU
++
++if test $ac_cv_prog_g77 = yes; then
++  G77=yes
++dnl Check whether -g works, even if FFLAGS is set, in case the package
++dnl plays around with FFLAGS (such as to build both debugging and
++dnl normal versions of a library), tasteless as that idea is.
++  ac_test_FFLAGS="${FFLAGS+set}"
++  ac_save_FFLAGS="$FFLAGS"
++  FFLAGS=
++  AC_PROG_F77_G
++  if test "$ac_test_FFLAGS" = set; then
++    FFLAGS="$ac_save_FFLAGS"
++  elif test $ac_cv_prog_f77_g = yes; then
++    FFLAGS="-g -O2"
++  else
++    FFLAGS="-O2"
++  fi
++else
++  G77=
++  test "${FFLAGS+set}" = set || FFLAGS="-g"
++fi
++])
++
++AC_DEFUN(AC_PROG_CC_WORKS,
++[AC_MSG_CHECKING([whether the C compiler ($CC $CFLAGS $LDFLAGS) works])
++AC_LANG_SAVE
++AC_LANG_C
++AC_TRY_COMPILER([main(){return(0);}], ac_cv_prog_cc_works, ac_cv_prog_cc_cross)
++AC_LANG_RESTORE
++AC_MSG_RESULT($ac_cv_prog_cc_works)
++if test $ac_cv_prog_cc_works = no; then
++  AC_MSG_ERROR([installation or configuration problem: C compiler cannot create executables.])
++fi
++AC_MSG_CHECKING([whether the C compiler ($CC $CFLAGS $LDFLAGS) is a cross-compiler])
++AC_MSG_RESULT($ac_cv_prog_cc_cross)
++cross_compiling=$ac_cv_prog_cc_cross
++])
++
++AC_DEFUN(AC_PROG_CXX_WORKS,
++[AC_MSG_CHECKING([whether the C++ compiler ($CXX $CXXFLAGS $LDFLAGS) works])
++AC_LANG_SAVE
++AC_LANG_CPLUSPLUS
++AC_TRY_COMPILER([int main(){return(0);}], ac_cv_prog_cxx_works, ac_cv_prog_cxx_cross)
++AC_LANG_RESTORE
++AC_MSG_RESULT($ac_cv_prog_cxx_works)
++if test $ac_cv_prog_cxx_works = no; then
++  AC_MSG_ERROR([installation or configuration problem: C++ compiler cannot create executables.])
++fi
++AC_MSG_CHECKING([whether the C++ compiler ($CXX $CXXFLAGS $LDFLAGS) is a cross-compiler])
++AC_MSG_RESULT($ac_cv_prog_cxx_cross)
++cross_compiling=$ac_cv_prog_cxx_cross
++])
++
++dnl Test whether the Fortran 77 compiler can compile and link a trivial
++dnl Fortran program.  Also, test whether the Fortran 77 compiler is a
++dnl cross-compiler (which may realistically be the case if the Fortran
++dnl compiler is `g77').
++dnl 
++dnl AC_PROG_F77_WORKS()
++AC_DEFUN(AC_PROG_F77_WORKS,
++[AC_MSG_CHECKING([whether the Fortran 77 compiler ($F77 $FFLAGS $LDFLAGS) works])
++AC_LANG_SAVE
++AC_LANG_FORTRAN77
++AC_TRY_COMPILER(dnl
++[      program conftest
++      end
++], ac_cv_prog_f77_works, ac_cv_prog_f77_cross)
++AC_LANG_RESTORE
++AC_MSG_RESULT($ac_cv_prog_f77_works)
++if test $ac_cv_prog_f77_works = no; then
++  AC_MSG_ERROR([installation or configuration problem: Fortran 77 compiler cannot create executables.])
++fi
++AC_MSG_CHECKING([whether the Fortran 77 compiler ($F77 $FFLAGS $LDFLAGS) is a cross-compiler])
++AC_MSG_RESULT($ac_cv_prog_f77_cross)
++cross_compiling=$ac_cv_prog_f77_cross
++])
++
++AC_DEFUN(AC_PROG_CC_GNU,
++[AC_CACHE_CHECK(whether we are using GNU C, ac_cv_prog_gcc,
++[dnl The semicolon is to pacify NeXT's syntax-checking cpp.
++cat > conftest.c <<EOF
++#ifdef __GNUC__
++  yes;
++#endif
++EOF
++if AC_TRY_COMMAND(${CC-cc} -E conftest.c) | egrep yes >/dev/null 2>&1; then
++  ac_cv_prog_gcc=yes
++else
++  ac_cv_prog_gcc=no
++fi])])
++
++AC_DEFUN(AC_PROG_CXX_GNU,
++[AC_CACHE_CHECK(whether we are using GNU C++, ac_cv_prog_gxx,
++[dnl The semicolon is to pacify NeXT's syntax-checking cpp.
++cat > conftest.C <<EOF
++#ifdef __GNUC__
++  yes;
++#endif
++EOF
++if AC_TRY_COMMAND(${CXX-g++} -E conftest.C) | egrep yes >/dev/null 2>&1; then
++  ac_cv_prog_gxx=yes
++else
++  ac_cv_prog_gxx=no
++fi])])
++
++dnl Test whether for Fortran 77 compiler is `g77' (the GNU Fortran 77
++dnl Compiler).  This test depends on whether the Fortran 77 compiler can
++dnl do CPP pre-processing.
++dnl 
++dnl AC_PROG_F77_GNU()
++AC_DEFUN(AC_PROG_F77_GNU,
++[AC_CACHE_CHECK(whether we are using GNU Fortran 77, ac_cv_prog_g77,
++[cat > conftest.fpp <<EOF
++#ifdef __GNUC__
++  yes
++#endif
++EOF
++if AC_TRY_COMMAND($F77 -E conftest.fpp) | egrep yes >/dev/null 2>&1; then
++  ac_cv_prog_g77=yes
++else
++  ac_cv_prog_g77=no
++fi])])
++
++AC_DEFUN(AC_PROG_CC_G,
++[AC_CACHE_CHECK(whether ${CC-cc} accepts -g, ac_cv_prog_cc_g,
++[echo 'void f(){}' > conftest.c
++if test -z "`${CC-cc} -g -c conftest.c 2>&1`"; then
++  ac_cv_prog_cc_g=yes
++else
++  ac_cv_prog_cc_g=no
++fi
++rm -f conftest*
++])])
++
++AC_DEFUN(AC_PROG_CXX_G,
++[AC_CACHE_CHECK(whether ${CXX-g++} accepts -g, ac_cv_prog_cxx_g,
++[echo 'void f(){}' > conftest.cc
++if test -z "`${CXX-g++} -g -c conftest.cc 2>&1`"; then
++  ac_cv_prog_cxx_g=yes
++else
++  ac_cv_prog_cxx_g=no
++fi
++rm -f conftest*
++])])
++
++dnl Test whether the Fortran 77 compiler can accept the `-g' option to
++dnl enable debugging.
++dnl 
++dnl AC_PROG_F77_G()
++AC_DEFUN(AC_PROG_F77_G,
++[AC_CACHE_CHECK(whether $F77 accepts -g, ac_cv_prog_f77_g,
++[cat > conftest.f << EOF
++       program conftest
++       end
++EOF
++if test -z "`$F77 -g -c conftest.f 2>&1`"; then
++  ac_cv_prog_f77_g=yes
++else
++  ac_cv_prog_f77_g=no
++fi
++rm -f conftest*
++])])
++
++AC_DEFUN(AC_PROG_GCC_TRADITIONAL,
++[AC_REQUIRE([AC_PROG_CC])dnl
++AC_REQUIRE([AC_PROG_CPP])dnl
++if test $ac_cv_prog_gcc = yes; then
++    AC_CACHE_CHECK(whether ${CC-cc} needs -traditional,
++      ac_cv_prog_gcc_traditional,
++[  ac_pattern="Autoconf.*'x'"
++  AC_EGREP_CPP($ac_pattern, [#include <sgtty.h>
++Autoconf TIOCGETP],
++  ac_cv_prog_gcc_traditional=yes, ac_cv_prog_gcc_traditional=no)
++
++  if test $ac_cv_prog_gcc_traditional = no; then
++    AC_EGREP_CPP($ac_pattern, [#include <termio.h>
++Autoconf TCGETA],
++    ac_cv_prog_gcc_traditional=yes)
++  fi])
++  if test $ac_cv_prog_gcc_traditional = yes; then
++    CC="$CC -traditional"
++  fi
++fi
++])
++
++AC_DEFUN(AC_PROG_CC_C_O,
++[if test "x$CC" != xcc; then
++  AC_MSG_CHECKING(whether $CC and cc understand -c and -o together)
++else
++  AC_MSG_CHECKING(whether cc understands -c and -o together)
++fi
++set dummy $CC; ac_cc="`echo [$]2 |
++changequote(, )dnl
++		       sed -e 's/[^a-zA-Z0-9_]/_/g' -e 's/^[0-9]/_/'`"
++changequote([, ])dnl
++AC_CACHE_VAL(ac_cv_prog_cc_${ac_cc}_c_o,
++[echo 'foo(){}' > conftest.c
++# Make sure it works both with $CC and with simple cc.
++# We do the test twice because some compilers refuse to overwrite an
++# existing .o file with -o, though they will create one.
++ac_try='${CC-cc} -c conftest.c -o conftest.o 1>&AC_FD_CC'
++if AC_TRY_EVAL(ac_try) &&
++   test -f conftest.o && AC_TRY_EVAL(ac_try);
++then
++  eval ac_cv_prog_cc_${ac_cc}_c_o=yes
++  if test "x$CC" != xcc; then
++    # Test first that cc exists at all.
++    if AC_TRY_COMMAND(cc -c conftest.c 1>&AC_FD_CC); then
++      ac_try='cc -c conftest.c -o conftest.o 1>&AC_FD_CC'
++      if AC_TRY_EVAL(ac_try) &&
++	 test -f conftest.o && AC_TRY_EVAL(ac_try);
++      then
++        # cc works too.
++        :
++      else
++        # cc exists but doesn't like -o.
++        eval ac_cv_prog_cc_${ac_cc}_c_o=no
++      fi
++    fi
++  fi
++else
++  eval ac_cv_prog_cc_${ac_cc}_c_o=no
++fi
++rm -f conftest*
++])dnl
++if eval "test \"`echo '$ac_cv_prog_cc_'${ac_cc}_c_o`\" = yes"; then
++  AC_MSG_RESULT(yes)
++else
++  AC_MSG_RESULT(no)
++  AC_DEFINE(NO_MINUS_C_MINUS_O)
++fi
++])
++
++dnl Test if the Fortran 77 compiler accepts the options `-c' and `-o'
++dnl simultaneously, and define `F77_NO_MINUS_C_MINUS_O' if it does not.
++dnl
++dnl The usefulness of this macro is questionable, as I can't really see
++dnl why anyone would use it.  The only reason I include it is for
++dnl completeness, since a similar test exists for the C compiler.
++dnl 
++dnl AC_PROG_F77_C_O
++AC_DEFUN(AC_PROG_F77_C_O,
++[AC_BEFORE([$0], [AC_PROG_F77])dnl
++AC_MSG_CHECKING(whether $F77 understand -c and -o together)
++set dummy $F77; ac_f77="`echo [$]2 |
++changequote(, )dnl
++sed -e 's/[^a-zA-Z0-9_]/_/g' -e 's/^[0-9]/_/'`"
++changequote([, ])dnl
++AC_CACHE_VAL(ac_cv_prog_f77_${ac_f77}_c_o,
++[cat > conftest.f << EOF
++       program conftest
++       end
++EOF
++# We do the `AC_TRY_EVAL' test twice because some compilers refuse to
++# overwrite an existing `.o' file with `-o', although they will create
++# one.
++ac_try='$F77 $FFLAGS -c conftest.f -o conftest.o 1>&AC_FD_CC'
++if AC_TRY_EVAL(ac_try) && test -f conftest.o && AC_TRY_EVAL(ac_try); then
++  eval ac_cv_prog_f77_${ac_f77}_c_o=yes
++else
++  eval ac_cv_prog_f77_${ac_f77}_c_o=no
++fi
++rm -f conftest*
++])dnl
++if eval "test \"`echo '$ac_cv_prog_f77_'${ac_f77}_c_o`\" = yes"; then
++  AC_MSG_RESULT(yes)
++else
++  AC_MSG_RESULT(no)
++  AC_DEFINE(F77_NO_MINUS_C_MINUS_O)
++fi
++])
++
++dnl Define SET_MAKE to set ${MAKE} if make doesn't.
++AC_DEFUN(AC_PROG_MAKE_SET,
++[AC_MSG_CHECKING(whether ${MAKE-make} sets \${MAKE})
++set dummy ${MAKE-make}; ac_make=`echo "[$]2" | sed 'y%./+-%__p_%'`
++AC_CACHE_VAL(ac_cv_prog_make_${ac_make}_set,
++[cat > conftestmake <<\EOF
++all:
++	@echo 'ac_maketemp="${MAKE}"'
++EOF
++changequote(, )dnl
++# GNU make sometimes prints "make[1]: Entering...", which would confuse us.
++eval `${MAKE-make} -f conftestmake 2>/dev/null | grep temp=`
++changequote([, ])dnl
++if test -n "$ac_maketemp"; then
++  eval ac_cv_prog_make_${ac_make}_set=yes
++else
++  eval ac_cv_prog_make_${ac_make}_set=no
++fi
++rm -f conftestmake])dnl
++if eval "test \"`echo '$ac_cv_prog_make_'${ac_make}_set`\" = yes"; then
++  AC_MSG_RESULT(yes)
++  SET_MAKE=
++else
++  AC_MSG_RESULT(no)
++  SET_MAKE="MAKE=${MAKE-make}"
++fi
++AC_SUBST([SET_MAKE])dnl
++])
++
++AC_DEFUN(AC_PROG_RANLIB,
++[AC_CHECK_PROG(RANLIB, ranlib, ranlib, :)])
++
++dnl Check for mawk first since it's generally faster.
++AC_DEFUN(AC_PROG_AWK,
++[AC_CHECK_PROGS(AWK, mawk gawk nawk awk, )])
++
++AC_DEFUN(AC_PROG_YACC,
++[AC_CHECK_PROGS(YACC, 'bison -y' byacc, yacc)])
++
++AC_DEFUN(AC_PROG_CPP,
++[AC_MSG_CHECKING(how to run the C preprocessor)
++# On Suns, sometimes $CPP names a directory.
++if test -n "$CPP" && test -d "$CPP"; then
++  CPP=
++fi
++if test -z "$CPP"; then
++AC_CACHE_VAL(ac_cv_prog_CPP,
++[  # This must be in double quotes, not single quotes, because CPP may get
++  # substituted into the Makefile and "${CC-cc}" will confuse make.
++  CPP="${CC-cc} -E"
++  # On the NeXT, cc -E runs the code through the compiler's parser,
++  # not just through cpp.
++dnl Use a header file that comes with gcc, so configuring glibc
++dnl with a fresh cross-compiler works.
++  AC_TRY_CPP([#include <assert.h>
++Syntax Error], ,
++  CPP="${CC-cc} -E -traditional-cpp"
++  AC_TRY_CPP([#include <assert.h>
++Syntax Error], ,
++  CPP="${CC-cc} -nologo -E"
++  AC_TRY_CPP([#include <assert.h>
++Syntax Error], , CPP=/lib/cpp)))
++  ac_cv_prog_CPP="$CPP"])dnl
++  CPP="$ac_cv_prog_CPP"
++else
++  ac_cv_prog_CPP="$CPP"
++fi
++AC_MSG_RESULT($CPP)
++AC_SUBST(CPP)dnl
++])
++
++AC_DEFUN(AC_PROG_CXXCPP,
++[AC_MSG_CHECKING(how to run the C++ preprocessor)
++if test -z "$CXXCPP"; then
++AC_CACHE_VAL(ac_cv_prog_CXXCPP,
++[AC_LANG_SAVE[]dnl
++AC_LANG_CPLUSPLUS[]dnl
++  CXXCPP="${CXX-g++} -E"
++  AC_TRY_CPP([#include <stdlib.h>], , CXXCPP=/lib/cpp)
++  ac_cv_prog_CXXCPP="$CXXCPP"
++AC_LANG_RESTORE[]dnl
++fi])dnl
++CXXCPP="$ac_cv_prog_CXXCPP"
++AC_MSG_RESULT($CXXCPP)
++AC_SUBST(CXXCPP)dnl
++])
++
++dnl Require finding the C or C++ preprocessor, whichever is the
++dnl current language.
++AC_DEFUN(AC_REQUIRE_CPP,
++[ifelse(AC_LANG, C, [AC_REQUIRE([AC_PROG_CPP])], [AC_REQUIRE([AC_PROG_CXXCPP])])])
++
++AC_DEFUN(AC_PROG_LEX,
++[AC_CHECK_PROG(LEX, flex, flex, lex)
++if test -z "$LEXLIB"
++then
++  case "$LEX" in
++  flex*) ac_lib=fl ;;
++  *) ac_lib=l ;;
++  esac
++  AC_CHECK_LIB($ac_lib, yywrap, LEXLIB="-l$ac_lib")
++fi
++AC_SUBST(LEXLIB)])
++
++dnl Check if lex declares yytext as a char * by default, not a char[].
++undefine([AC_DECL_YYTEXT])
++AC_DEFUN(AC_DECL_YYTEXT,
++[AC_REQUIRE_CPP()dnl
++AC_REQUIRE([AC_PROG_LEX])dnl
++AC_CACHE_CHECK(lex output file root, ac_cv_prog_lex_root,
++[# The minimal lex program is just a single line: %%.  But some broken lexes
++# (Solaris, I think it was) want two %% lines, so accommodate them.
++echo '%%
++%%' | $LEX
++if test -f lex.yy.c; then
++  ac_cv_prog_lex_root=lex.yy
++elif test -f lexyy.c; then
++  ac_cv_prog_lex_root=lexyy
++else
++  AC_MSG_ERROR(cannot find output from $LEX; giving up)
++fi])
++LEX_OUTPUT_ROOT=$ac_cv_prog_lex_root
++AC_SUBST(LEX_OUTPUT_ROOT)dnl
++
++AC_CACHE_CHECK(whether yytext is a pointer, ac_cv_prog_lex_yytext_pointer,
++[# POSIX says lex can declare yytext either as a pointer or an array; the
++# default is implementation-dependent. Figure out which it is, since
++# not all implementations provide the %pointer and %array declarations.
++ac_cv_prog_lex_yytext_pointer=no
++echo 'extern char *yytext;' >>$LEX_OUTPUT_ROOT.c
++ac_save_LIBS="$LIBS"
++LIBS="$LIBS $LEXLIB"
++AC_TRY_LINK(`cat $LEX_OUTPUT_ROOT.c`, , ac_cv_prog_lex_yytext_pointer=yes)
++LIBS="$ac_save_LIBS"
++rm -f "${LEX_OUTPUT_ROOT}.c"
++])
++dnl
++if test $ac_cv_prog_lex_yytext_pointer = yes; then
++  AC_DEFINE(YYTEXT_POINTER)
++fi
++])
++
++AC_DEFUN(AC_PROG_INSTALL,
++[AC_REQUIRE([AC_CONFIG_AUX_DIR_DEFAULT])dnl
++# Find a good install program.  We prefer a C program (faster),
++# so one script is as good as another.  But avoid the broken or
++# incompatible versions:
++# SysV /etc/install, /usr/sbin/install
++# SunOS /usr/etc/install
++# IRIX /sbin/install
++# AIX /bin/install
++# AIX 4 /usr/bin/installbsd, which doesn't work without a -g flag
++# AFS /usr/afsws/bin/install, which mishandles nonexistent args
++# SVR4 /usr/ucb/install, which tries to use the nonexistent group "staff"
++# ./install, which can be erroneously created by make from ./install.sh.
++AC_MSG_CHECKING(for a BSD compatible install)
++if test -z "$INSTALL"; then
++AC_CACHE_VAL(ac_cv_path_install,
++[  IFS="${IFS= 	}"; ac_save_IFS="$IFS"; IFS=":"
++  for ac_dir in $PATH; do
++    # Account for people who put trailing slashes in PATH elements.
++    case "$ac_dir/" in
++    /|./|.//|/etc/*|/usr/sbin/*|/usr/etc/*|/sbin/*|/usr/afsws/bin/*|/usr/ucb/*) ;;
++    *)
++      # OSF1 and SCO ODT 3.0 have their own names for install.
++      # Don't use installbsd from OSF since it installs stuff as root
++      # by default.
++      for ac_prog in ginstall scoinst install; do
++        if test -f $ac_dir/$ac_prog; then
++	  if test $ac_prog = install &&
++            grep dspmsg $ac_dir/$ac_prog >/dev/null 2>&1; then
++	    # AIX install.  It has an incompatible calling convention.
++	    :
++	  else
++	    ac_cv_path_install="$ac_dir/$ac_prog -c"
++	    break 2
++	  fi
++	fi
++      done
++      ;;
++    esac
++  done
++  IFS="$ac_save_IFS"
++])dnl
++  if test "${ac_cv_path_install+set}" = set; then
++    INSTALL="$ac_cv_path_install"
++  else
++    # As a last resort, use the slow shell script.  We don't cache a
++    # path for INSTALL within a source directory, because that will
++    # break other packages using the cache if that directory is
++    # removed, or if the path is relative.
++    INSTALL="$ac_install_sh"
++  fi
++fi
++dnl We do special magic for INSTALL instead of AC_SUBST, to get
++dnl relative paths right.
++AC_MSG_RESULT($INSTALL)
++
++# Use test -z because SunOS4 sh mishandles braces in ${var-val}.
++# It thinks the first close brace ends the variable substitution.
++test -z "$INSTALL_PROGRAM" && INSTALL_PROGRAM='${INSTALL}'
++AC_SUBST(INSTALL_PROGRAM)dnl
++
++test -z "$INSTALL_SCRIPT" && INSTALL_SCRIPT='${INSTALL_PROGRAM}'
++AC_SUBST(INSTALL_SCRIPT)dnl
++
++test -z "$INSTALL_DATA" && INSTALL_DATA='${INSTALL} -m 644'
++AC_SUBST(INSTALL_DATA)dnl
++])
++
++AC_DEFUN(AC_PROG_LN_S,
++[AC_MSG_CHECKING(whether ln -s works)
++AC_CACHE_VAL(ac_cv_prog_LN_S,
++[rm -f conftestdata
++if ln -s X conftestdata 2>/dev/null
++then
++  rm -f conftestdata
++  ac_cv_prog_LN_S="ln -s"
++else
++  ac_cv_prog_LN_S=ln
++fi])dnl
++LN_S="$ac_cv_prog_LN_S"
++if test "$ac_cv_prog_LN_S" = "ln -s"; then
++  AC_MSG_RESULT(yes)
++else
++  AC_MSG_RESULT(no)
++fi
++AC_SUBST(LN_S)dnl
++])
++
++define(AC_RSH,
++[errprint(__file__:__line__: [$0] has been removed; replace it with equivalent code
++)m4exit(4)])
++
++
++dnl ### Checks for header files
++
++
++AC_DEFUN(AC_HEADER_STDC,
++[AC_REQUIRE_CPP()dnl
++AC_CACHE_CHECK(for ANSI C header files, ac_cv_header_stdc,
++[AC_TRY_CPP([#include <stdlib.h>
++#include <stdarg.h>
++#include <string.h>
++#include <float.h>], ac_cv_header_stdc=yes, ac_cv_header_stdc=no)
++
++if test $ac_cv_header_stdc = yes; then
++  # SunOS 4.x string.h does not declare mem*, contrary to ANSI.
++AC_EGREP_HEADER(memchr, string.h, , ac_cv_header_stdc=no)
++fi
++
++if test $ac_cv_header_stdc = yes; then
++  # ISC 2.0.2 stdlib.h does not declare free, contrary to ANSI.
++AC_EGREP_HEADER(free, stdlib.h, , ac_cv_header_stdc=no)
++fi
++
++if test $ac_cv_header_stdc = yes; then
++  # /bin/cc in Irix-4.0.5 gets non-ANSI ctype macros unless using -ansi.
++AC_TRY_RUN([#include <ctype.h>
++#define ISLOWER(c) ('a' <= (c) && (c) <= 'z')
++#define TOUPPER(c) (ISLOWER(c) ? 'A' + ((c) - 'a') : (c))
++#define XOR(e, f) (((e) && !(f)) || (!(e) && (f)))
++int main () { int i; for (i = 0; i < 256; i++)
++if (XOR (islower (i), ISLOWER (i)) || toupper (i) != TOUPPER (i)) exit(2);
++exit (0); }
++], , ac_cv_header_stdc=no, :)
++fi])
++if test $ac_cv_header_stdc = yes; then
++  AC_DEFINE(STDC_HEADERS)
++fi
++])
++
++AC_DEFUN(AC_UNISTD_H,
++[AC_OBSOLETE([$0], [; instead use AC_CHECK_HEADERS(unistd.h)])dnl
++AC_CHECK_HEADER(unistd.h, AC_DEFINE(HAVE_UNISTD_H))])
++
++AC_DEFUN(AC_USG,
++[AC_OBSOLETE([$0],
++  [; instead use AC_CHECK_HEADERS(string.h) and HAVE_STRING_H])dnl
++AC_MSG_CHECKING([for BSD string and memory functions])
++AC_TRY_LINK([#include <strings.h>], [rindex(0, 0); bzero(0, 0);],
++  [AC_MSG_RESULT(yes)], [AC_MSG_RESULT(no); AC_DEFINE(USG)])])
++
++
++dnl If memchr and the like aren't declared in <string.h>, include <memory.h>.
++dnl To avoid problems, don't check for gcc2 built-ins.
++AC_DEFUN(AC_MEMORY_H,
++[AC_OBSOLETE([$0], [; instead use AC_CHECK_HEADERS(memory.h) and HAVE_MEMORY_H])dnl
++AC_MSG_CHECKING(whether string.h declares mem functions)
++AC_EGREP_HEADER(memchr, string.h, ac_found=yes, ac_found=no)
++AC_MSG_RESULT($ac_found)
++if test $ac_found = no; then
++  AC_CHECK_HEADER(memory.h, [AC_DEFINE(NEED_MEMORY_H)])
++fi
++])
++
++AC_DEFUN(AC_HEADER_MAJOR,
++[AC_CACHE_CHECK(whether sys/types.h defines makedev,
++  ac_cv_header_sys_types_h_makedev,
++[AC_TRY_LINK([#include <sys/types.h>], [return makedev(0, 0);],
++  ac_cv_header_sys_types_h_makedev=yes, ac_cv_header_sys_types_h_makedev=no)
++])
++
++if test $ac_cv_header_sys_types_h_makedev = no; then
++AC_CHECK_HEADER(sys/mkdev.h, [AC_DEFINE(MAJOR_IN_MKDEV)])
++
++  if test $ac_cv_header_sys_mkdev_h = no; then
++AC_CHECK_HEADER(sys/sysmacros.h, [AC_DEFINE(MAJOR_IN_SYSMACROS)])
++  fi
++fi
++])
++
++AC_DEFUN(AC_HEADER_DIRENT,
++[ac_header_dirent=no
++AC_CHECK_HEADERS_DIRENT(dirent.h sys/ndir.h sys/dir.h ndir.h,
++  [ac_header_dirent=$ac_hdr; break])
++# Two versions of opendir et al. are in -ldir and -lx on SCO Xenix.
++if test $ac_header_dirent = dirent.h; then
++AC_CHECK_LIB(dir, opendir, LIBS="$LIBS -ldir")
++else
++AC_CHECK_LIB(x, opendir, LIBS="$LIBS -lx")
++fi
++])
++
++dnl Like AC_CHECK_HEADER, except also make sure that HEADER-FILE
++dnl defines the type `DIR'.  dirent.h on NextStep 3.2 doesn't.
++dnl AC_CHECK_HEADER_DIRENT(HEADER-FILE, ACTION-IF-FOUND)
++AC_DEFUN(AC_CHECK_HEADER_DIRENT,
++[ac_safe=`echo "$1" | sed 'y%./+-%__p_%'`
++AC_MSG_CHECKING([for $1 that defines DIR])
++AC_CACHE_VAL(ac_cv_header_dirent_$ac_safe,
++[AC_TRY_COMPILE([#include <sys/types.h>
++#include <$1>], [DIR *dirp = 0;],
++  eval "ac_cv_header_dirent_$ac_safe=yes",
++  eval "ac_cv_header_dirent_$ac_safe=no")])dnl
++if eval "test \"`echo '$ac_cv_header_dirent_'$ac_safe`\" = yes"; then
++  AC_MSG_RESULT(yes)
++  $2
++else
++  AC_MSG_RESULT(no)
++fi
++])
++
++dnl Like AC_CHECK_HEADERS, except succeed only for a HEADER-FILE that
++dnl defines `DIR'.
++dnl AC_CHECK_HEADERS_DIRENT(HEADER-FILE... [, ACTION])
++define(AC_CHECK_HEADERS_DIRENT,
++[for ac_hdr in $1
++do
++AC_CHECK_HEADER_DIRENT($ac_hdr,
++[changequote(, )dnl
++  ac_tr_hdr=HAVE_`echo $ac_hdr | sed 'y%abcdefghijklmnopqrstuvwxyz./-%ABCDEFGHIJKLMNOPQRSTUVWXYZ___%'`
++changequote([, ])dnl
++  AC_DEFINE_UNQUOTED($ac_tr_hdr) $2])dnl
++done])
++
++AC_DEFUN(AC_DIR_HEADER,
++[AC_OBSOLETE([$0], [; instead use AC_HEADER_DIRENT])dnl
++ac_header_dirent=no
++for ac_hdr in dirent.h sys/ndir.h sys/dir.h ndir.h; do
++  AC_CHECK_HEADER_DIRENT($ac_hdr, [ac_header_dirent=$ac_hdr; break])
++done
++
++case "$ac_header_dirent" in
++dirent.h) AC_DEFINE(DIRENT) ;;
++sys/ndir.h) AC_DEFINE(SYSNDIR) ;;
++sys/dir.h) AC_DEFINE(SYSDIR) ;;
++ndir.h) AC_DEFINE(NDIR) ;;
++esac
++
++AC_CACHE_CHECK(whether closedir returns void, ac_cv_func_closedir_void,
++[AC_TRY_RUN([#include <sys/types.h>
++#include <$ac_header_dirent>
++int closedir(); main() { exit(closedir(opendir(".")) != 0); }],
++  ac_cv_func_closedir_void=no, ac_cv_func_closedir_void=yes, ac_cv_func_closedir_void=yes)])
++if test $ac_cv_func_closedir_void = yes; then
++  AC_DEFINE(VOID_CLOSEDIR)
++fi
++])
++
++AC_DEFUN(AC_HEADER_STAT,
++[AC_CACHE_CHECK(whether stat file-mode macros are broken,
++  ac_cv_header_stat_broken,
++[AC_EGREP_CPP([You lose], [#include <sys/types.h>
++#include <sys/stat.h>
++
++#if defined(S_ISBLK) && defined(S_IFDIR)
++# if S_ISBLK (S_IFDIR)
++You lose.
++# endif
++#endif
++
++#if defined(S_ISBLK) && defined(S_IFCHR)
++# if S_ISBLK (S_IFCHR)
++You lose.
++# endif
++#endif
++
++#if defined(S_ISLNK) && defined(S_IFREG)
++# if S_ISLNK (S_IFREG)
++You lose.
++# endif
++#endif
++
++#if defined(S_ISSOCK) && defined(S_IFREG)
++# if S_ISSOCK (S_IFREG)
++You lose.
++# endif
++#endif
++], ac_cv_header_stat_broken=yes, ac_cv_header_stat_broken=no)])
++if test $ac_cv_header_stat_broken = yes; then
++  AC_DEFINE(STAT_MACROS_BROKEN)
++fi
++])
++
++AC_DEFUN(AC_DECL_SYS_SIGLIST,
++[AC_CACHE_CHECK([for sys_siglist declaration in signal.h or unistd.h],
++  ac_cv_decl_sys_siglist,
++[AC_TRY_COMPILE([#include <sys/types.h>
++#include <signal.h>
++/* NetBSD declares sys_siglist in unistd.h.  */
++#ifdef HAVE_UNISTD_H
++#include <unistd.h>
++#endif], [char *msg = *(sys_siglist + 1);],
++  ac_cv_decl_sys_siglist=yes, ac_cv_decl_sys_siglist=no)])
++if test $ac_cv_decl_sys_siglist = yes; then
++  AC_DEFINE(SYS_SIGLIST_DECLARED)
++fi
++])
++
++AC_DEFUN(AC_HEADER_SYS_WAIT,
++[AC_CACHE_CHECK([for sys/wait.h that is POSIX.1 compatible],
++  ac_cv_header_sys_wait_h,
++[AC_TRY_COMPILE([#include <sys/types.h>
++#include <sys/wait.h>
++#ifndef WEXITSTATUS
++#define WEXITSTATUS(stat_val) ((unsigned)(stat_val) >> 8)
++#endif
++#ifndef WIFEXITED
++#define WIFEXITED(stat_val) (((stat_val) & 255) == 0)
++#endif], [int s;
++wait (&s);
++s = WIFEXITED (s) ? WEXITSTATUS (s) : 1;],
++ac_cv_header_sys_wait_h=yes, ac_cv_header_sys_wait_h=no)])
++if test $ac_cv_header_sys_wait_h = yes; then
++  AC_DEFINE(HAVE_SYS_WAIT_H)
++fi
++])
++
++
++dnl ### Checks for typedefs
++
++
++AC_DEFUN(AC_TYPE_GETGROUPS,
++[AC_REQUIRE([AC_TYPE_UID_T])dnl
++AC_CACHE_CHECK(type of array argument to getgroups, ac_cv_type_getgroups,
++[AC_TRY_RUN(
++changequote(<<, >>)dnl
++<<
++/* Thanks to Mike Rendell for this test.  */
++#include <sys/types.h>
++#define NGID 256
++#undef MAX
++#define MAX(x, y) ((x) > (y) ? (x) : (y))
++main()
++{
++  gid_t gidset[NGID];
++  int i, n;
++  union { gid_t gval; long lval; }  val;
++
++  val.lval = -1;
++  for (i = 0; i < NGID; i++)
++    gidset[i] = val.gval;
++  n = getgroups (sizeof (gidset) / MAX (sizeof (int), sizeof (gid_t)) - 1,
++                 gidset);
++  /* Exit non-zero if getgroups seems to require an array of ints.  This
++     happens when gid_t is short but getgroups modifies an array of ints.  */
++  exit ((n > 0 && gidset[n] != val.gval) ? 1 : 0);
++}
++>>,
++changequote([, ])dnl
++  ac_cv_type_getgroups=gid_t, ac_cv_type_getgroups=int,
++  ac_cv_type_getgroups=cross)
++if test $ac_cv_type_getgroups = cross; then
++  dnl When we can't run the test program (we are cross compiling), presume
++  dnl that <unistd.h> has either an accurate prototype for getgroups or none.
++  dnl Old systems without prototypes probably use int.
++  AC_EGREP_HEADER([getgroups.*int.*gid_t], unistd.h,
++		  ac_cv_type_getgroups=gid_t, ac_cv_type_getgroups=int)
++fi])
++AC_DEFINE_UNQUOTED(GETGROUPS_T, $ac_cv_type_getgroups)
++])
++
++AC_DEFUN(AC_TYPE_UID_T,
++[AC_CACHE_CHECK(for uid_t in sys/types.h, ac_cv_type_uid_t,
++[AC_EGREP_HEADER(uid_t, sys/types.h,
++  ac_cv_type_uid_t=yes, ac_cv_type_uid_t=no)])
++if test $ac_cv_type_uid_t = no; then
++  AC_DEFINE(uid_t, int)
++  AC_DEFINE(gid_t, int)
++fi
++])
++
++AC_DEFUN(AC_TYPE_SIZE_T,
++[AC_CHECK_TYPE(size_t, unsigned)])
++
++AC_DEFUN(AC_TYPE_PID_T,
++[AC_CHECK_TYPE(pid_t, int)])
++
++AC_DEFUN(AC_TYPE_OFF_T,
++[AC_CHECK_TYPE(off_t, long)])
++
++AC_DEFUN(AC_TYPE_MODE_T,
++[AC_CHECK_TYPE(mode_t, int)])
++
++dnl Note that identifiers starting with SIG are reserved by ANSI C.
++AC_DEFUN(AC_TYPE_SIGNAL,
++[AC_CACHE_CHECK([return type of signal handlers], ac_cv_type_signal,
++[AC_TRY_COMPILE([#include <sys/types.h>
++#include <signal.h>
++#ifdef signal
++#undef signal
++#endif
++#ifdef __cplusplus
++extern "C" void (*signal (int, void (*)(int)))(int);
++#else
++void (*signal ()) ();
++#endif
++],
++[int i;], ac_cv_type_signal=void, ac_cv_type_signal=int)])
++AC_DEFINE_UNQUOTED(RETSIGTYPE, $ac_cv_type_signal)
++])
++
++
++dnl ### Checks for functions
++
++
++AC_DEFUN(AC_FUNC_CLOSEDIR_VOID,
++[AC_REQUIRE([AC_HEADER_DIRENT])dnl
++AC_CACHE_CHECK(whether closedir returns void, ac_cv_func_closedir_void,
++[AC_TRY_RUN([#include <sys/types.h>
++#include <$ac_header_dirent>
++int closedir(); main() { exit(closedir(opendir(".")) != 0); }],
++  ac_cv_func_closedir_void=no, ac_cv_func_closedir_void=yes, ac_cv_func_closedir_void=yes)])
++if test $ac_cv_func_closedir_void = yes; then
++  AC_DEFINE(CLOSEDIR_VOID)
++fi
++])
++
++AC_DEFUN(AC_FUNC_FNMATCH,
++[AC_CACHE_CHECK(for working fnmatch, ac_cv_func_fnmatch_works,
++# Some versions of Solaris or SCO have a broken fnmatch function.
++# So we run a test program.  If we are cross-compiling, take no chance.
++# Thanks to John Oleynick and Franc,ois Pinard for this test.
++[AC_TRY_RUN([main() { exit (fnmatch ("a*", "abc", 0) != 0); }],
++ac_cv_func_fnmatch_works=yes, ac_cv_func_fnmatch_works=no,
++ac_cv_func_fnmatch_works=no)])
++if test $ac_cv_func_fnmatch_works = yes; then
++  AC_DEFINE(HAVE_FNMATCH)
++fi
++])
++
++AC_DEFUN(AC_FUNC_MMAP,
++[AC_CHECK_HEADERS(unistd.h)
++AC_CHECK_FUNCS(getpagesize)
++AC_CACHE_CHECK(for working mmap, ac_cv_func_mmap_fixed_mapped,
++[AC_TRY_RUN([
++/* Thanks to Mike Haertel and Jim Avera for this test.
++   Here is a matrix of mmap possibilities:
++	mmap private not fixed
++	mmap private fixed at somewhere currently unmapped
++	mmap private fixed at somewhere already mapped
++	mmap shared not fixed
++	mmap shared fixed at somewhere currently unmapped
++	mmap shared fixed at somewhere already mapped
++   For private mappings, we should verify that changes cannot be read()
++   back from the file, nor mmap's back from the file at a different
++   address.  (There have been systems where private was not correctly
++   implemented like the infamous i386 svr4.0, and systems where the
++   VM page cache was not coherent with the filesystem buffer cache
++   like early versions of FreeBSD and possibly contemporary NetBSD.)
++   For shared mappings, we should conversely verify that changes get
++   propogated back to all the places they're supposed to be.
++
++   Grep wants private fixed already mapped.
++   The main things grep needs to know about mmap are:
++   * does it exist and is it safe to write into the mmap'd area
++   * how to use it (BSD variants)  */
++#include <sys/types.h>
++#include <fcntl.h>
++#include <sys/mman.h>
++
++/* This mess was copied from the GNU getpagesize.h.  */
++#ifndef HAVE_GETPAGESIZE
++# ifdef HAVE_UNISTD_H
++#  include <unistd.h>
++# endif
++
++/* Assume that all systems that can run configure have sys/param.h.  */
++# ifndef HAVE_SYS_PARAM_H
++#  define HAVE_SYS_PARAM_H 1
++# endif
++
++# ifdef _SC_PAGESIZE
++#  define getpagesize() sysconf(_SC_PAGESIZE)
++# else /* no _SC_PAGESIZE */
++#  ifdef HAVE_SYS_PARAM_H
++#   include <sys/param.h>
++#   ifdef EXEC_PAGESIZE
++#    define getpagesize() EXEC_PAGESIZE
++#   else /* no EXEC_PAGESIZE */
++#    ifdef NBPG
++#     define getpagesize() NBPG * CLSIZE
++#     ifndef CLSIZE
++#      define CLSIZE 1
++#     endif /* no CLSIZE */
++#    else /* no NBPG */
++#     ifdef NBPC
++#      define getpagesize() NBPC
++#     else /* no NBPC */
++#      ifdef PAGESIZE
++#       define getpagesize() PAGESIZE
++#      endif /* PAGESIZE */
++#     endif /* no NBPC */
++#    endif /* no NBPG */
++#   endif /* no EXEC_PAGESIZE */
++#  else /* no HAVE_SYS_PARAM_H */
++#   define getpagesize() 8192	/* punt totally */
++#  endif /* no HAVE_SYS_PARAM_H */
++# endif /* no _SC_PAGESIZE */
++
++#endif /* no HAVE_GETPAGESIZE */
++
++#ifdef __cplusplus
++extern "C" { void *malloc(unsigned); }
++#else
++char *malloc();
++#endif
++
++int
++main()
++{
++	char *data, *data2, *data3;
++	int i, pagesize;
++	int fd;
++
++	pagesize = getpagesize();
++
++	/*
++	 * First, make a file with some known garbage in it.
++	 */
++	data = malloc(pagesize);
++	if (!data)
++		exit(1);
++	for (i = 0; i < pagesize; ++i)
++		*(data + i) = rand();
++	umask(0);
++	fd = creat("conftestmmap", 0600);
++	if (fd < 0)
++		exit(1);
++	if (write(fd, data, pagesize) != pagesize)
++		exit(1);
++	close(fd);
++
++	/*
++	 * Next, try to mmap the file at a fixed address which
++	 * already has something else allocated at it.  If we can,
++	 * also make sure that we see the same garbage.
++	 */
++	fd = open("conftestmmap", O_RDWR);
++	if (fd < 0)
++		exit(1);
++	data2 = malloc(2 * pagesize);
++	if (!data2)
++		exit(1);
++	data2 += (pagesize - ((int) data2 & (pagesize - 1))) & (pagesize - 1);
++	if (data2 != mmap(data2, pagesize, PROT_READ | PROT_WRITE,
++	    MAP_PRIVATE | MAP_FIXED, fd, 0L))
++		exit(1);
++	for (i = 0; i < pagesize; ++i)
++		if (*(data + i) != *(data2 + i))
++			exit(1);
++
++	/*
++	 * Finally, make sure that changes to the mapped area
++	 * do not percolate back to the file as seen by read().
++	 * (This is a bug on some variants of i386 svr4.0.)
++	 */
++	for (i = 0; i < pagesize; ++i)
++		*(data2 + i) = *(data2 + i) + 1;
++	data3 = malloc(pagesize);
++	if (!data3)
++		exit(1);
++	if (read(fd, data3, pagesize) != pagesize)
++		exit(1);
++	for (i = 0; i < pagesize; ++i)
++		if (*(data + i) != *(data3 + i))
++			exit(1);
++	close(fd);
++	unlink("conftestmmap");
++	exit(0);
++}
++], ac_cv_func_mmap_fixed_mapped=yes, ac_cv_func_mmap_fixed_mapped=no,
++ac_cv_func_mmap_fixed_mapped=no)])
++if test $ac_cv_func_mmap_fixed_mapped = yes; then
++  AC_DEFINE(HAVE_MMAP)
++fi
++])
++
++AC_DEFUN(AC_FUNC_GETPGRP,
++[AC_CACHE_CHECK(whether getpgrp takes no argument, ac_cv_func_getpgrp_void,
++[AC_TRY_RUN([
++/*
++ * If this system has a BSD-style getpgrp(),
++ * which takes a pid argument, exit unsuccessfully.
++ *
++ * Snarfed from Chet Ramey's bash pgrp.c test program
++ */
++#include <stdio.h>
++#include <sys/types.h>
++
++int     pid;
++int     pg1, pg2, pg3, pg4;
++int     ng, np, s, child;
++
++main()
++{
++        pid = getpid();
++        pg1 = getpgrp(0);
++        pg2 = getpgrp();
++        pg3 = getpgrp(pid);
++        pg4 = getpgrp(1);
++
++        /*
++         * If all of these values are the same, it's pretty sure that
++         * we're on a system that ignores getpgrp's first argument.
++         */
++        if (pg2 == pg4 && pg1 == pg3 && pg2 == pg3)
++                exit(0);
++
++        child = fork();
++        if (child < 0)
++                exit(1);
++        else if (child == 0) {
++                np = getpid();
++                /*
++                 * If this is Sys V, this will not work; pgrp will be
++                 * set to np because setpgrp just changes a pgrp to be
++                 * the same as the pid.
++                 */
++                setpgrp(np, pg1);
++                ng = getpgrp(0);        /* Same result for Sys V and BSD */
++                if (ng == pg1) {
++                        exit(1);
++                } else {
++                        exit(0);
++                }
++        } else {
++                wait(&s);
++                exit(s>>8);
++        }
++}
++], ac_cv_func_getpgrp_void=yes, ac_cv_func_getpgrp_void=no,
++   AC_MSG_ERROR(cannot check getpgrp if cross compiling))
++])
++if test $ac_cv_func_getpgrp_void = yes; then
++  AC_DEFINE(GETPGRP_VOID)
++fi
++])
++
++AC_DEFUN(AC_FUNC_SETPGRP,
++[AC_CACHE_CHECK(whether setpgrp takes no argument, ac_cv_func_setpgrp_void,
++AC_TRY_RUN([
++#ifdef HAVE_UNISTD_H
++#include <unistd.h>
++#endif
++
++/*
++ * If this system has a BSD-style setpgrp, which takes arguments, exit
++ * successfully.
++ */
++main()
++{
++    if (setpgrp(1,1) == -1)
++	exit(0);
++    else
++	exit(1);
++}
++], ac_cv_func_setpgrp_void=no, ac_cv_func_setpgrp_void=yes,
++   AC_MSG_ERROR(cannot check setpgrp if cross compiling))
++)
++if test $ac_cv_func_setpgrp_void = yes; then
++  AC_DEFINE(SETPGRP_VOID)
++fi
++])
++
++AC_DEFUN(AC_FUNC_VPRINTF,
++[AC_CHECK_FUNC(vprintf, AC_DEFINE(HAVE_VPRINTF))
++if test "$ac_cv_func_vprintf" != yes; then
++AC_CHECK_FUNC(_doprnt, AC_DEFINE(HAVE_DOPRNT))
++fi
++])
++
++AC_DEFUN(AC_FUNC_VFORK,
++[AC_REQUIRE([AC_TYPE_PID_T])dnl
++AC_CHECK_HEADER(vfork.h, AC_DEFINE(HAVE_VFORK_H))
++AC_CACHE_CHECK(for working vfork, ac_cv_func_vfork_works,
++[AC_TRY_RUN([/* Thanks to Paul Eggert for this test.  */
++#include <stdio.h>
++#include <sys/types.h>
++#include <sys/stat.h>
++#ifdef HAVE_UNISTD_H
++#include <unistd.h>
++#endif
++#ifdef HAVE_VFORK_H
++#include <vfork.h>
++#endif
++/* On some sparc systems, changes by the child to local and incoming
++   argument registers are propagated back to the parent.
++   The compiler is told about this with #include <vfork.h>,
++   but some compilers (e.g. gcc -O) don't grok <vfork.h>.
++   Test for this by using a static variable whose address
++   is put into a register that is clobbered by the vfork.  */
++static
++#ifdef __cplusplus
++sparc_address_test (int arg)
++#else
++sparc_address_test (arg) int arg;
++#endif
++{
++  static pid_t child;
++  if (!child) {
++    child = vfork ();
++    if (child < 0) {
++      perror ("vfork");
++      _exit(2);
++    }
++    if (!child) {
++      arg = getpid();
++      write(-1, "", 0);
++      _exit (arg);
++    }
++  }
++}
++main() {
++  pid_t parent = getpid ();
++  pid_t child;
++
++  sparc_address_test ();
++
++  child = vfork ();
++
++  if (child == 0) {
++    /* Here is another test for sparc vfork register problems.
++       This test uses lots of local variables, at least
++       as many local variables as main has allocated so far
++       including compiler temporaries.  4 locals are enough for
++       gcc 1.40.3 on a Solaris 4.1.3 sparc, but we use 8 to be safe.
++       A buggy compiler should reuse the register of parent
++       for one of the local variables, since it will think that
++       parent can't possibly be used any more in this routine.
++       Assigning to the local variable will thus munge parent
++       in the parent process.  */
++    pid_t
++      p = getpid(), p1 = getpid(), p2 = getpid(), p3 = getpid(),
++      p4 = getpid(), p5 = getpid(), p6 = getpid(), p7 = getpid();
++    /* Convince the compiler that p..p7 are live; otherwise, it might
++       use the same hardware register for all 8 local variables.  */
++    if (p != p1 || p != p2 || p != p3 || p != p4
++	|| p != p5 || p != p6 || p != p7)
++      _exit(1);
++
++    /* On some systems (e.g. IRIX 3.3),
++       vfork doesn't separate parent from child file descriptors.
++       If the child closes a descriptor before it execs or exits,
++       this munges the parent's descriptor as well.
++       Test for this by closing stdout in the child.  */
++    _exit(close(fileno(stdout)) != 0);
++  } else {
++    int status;
++    struct stat st;
++
++    while (wait(&status) != child)
++      ;
++    exit(
++	 /* Was there some problem with vforking?  */
++	 child < 0
++
++	 /* Did the child fail?  (This shouldn't happen.)  */
++	 || status
++
++	 /* Did the vfork/compiler bug occur?  */
++	 || parent != getpid()
++
++	 /* Did the file descriptor bug occur?  */
++	 || fstat(fileno(stdout), &st) != 0
++	 );
++  }
++}],
++ac_cv_func_vfork_works=yes, ac_cv_func_vfork_works=no, AC_CHECK_FUNC(vfork)
++ac_cv_func_vfork_works=$ac_cv_func_vfork)])
++if test $ac_cv_func_vfork_works = no; then
++  AC_DEFINE(vfork, fork)
++fi
++])
++
++AC_DEFUN(AC_FUNC_WAIT3,
++[AC_CACHE_CHECK(for wait3 that fills in rusage, ac_cv_func_wait3_rusage,
++[AC_TRY_RUN([#include <sys/types.h>
++#include <sys/time.h>
++#include <sys/resource.h>
++#include <stdio.h>
++/* HP-UX has wait3 but does not fill in rusage at all.  */
++main() {
++  struct rusage r;
++  int i;
++  /* Use a field that we can force nonzero --
++     voluntary context switches.
++     For systems like NeXT and OSF/1 that don't set it,
++     also use the system CPU time.  And page faults (I/O) for Linux.  */
++  r.ru_nvcsw = 0;
++  r.ru_stime.tv_sec = 0;
++  r.ru_stime.tv_usec = 0;
++  r.ru_majflt = r.ru_minflt = 0;
++  switch (fork()) {
++  case 0: /* Child.  */
++    sleep(1); /* Give up the CPU.  */
++    _exit(0);
++  case -1: _exit(0); /* What can we do?  */
++  default: /* Parent.  */
++    wait3(&i, 0, &r);
++    sleep(2); /* Avoid "text file busy" from rm on fast HP-UX machines.  */
++    exit(r.ru_nvcsw == 0 && r.ru_majflt == 0 && r.ru_minflt == 0
++	 && r.ru_stime.tv_sec == 0 && r.ru_stime.tv_usec == 0);
++  }
++}], ac_cv_func_wait3_rusage=yes, ac_cv_func_wait3_rusage=no,
++ac_cv_func_wait3_rusage=no)])
++if test $ac_cv_func_wait3_rusage = yes; then
++  AC_DEFINE(HAVE_WAIT3)
++fi
++])
++
++AC_DEFUN(AC_FUNC_ALLOCA,
++[AC_REQUIRE_CPP()dnl Set CPP; we run AC_EGREP_CPP conditionally.
++# The Ultrix 4.2 mips builtin alloca declared by alloca.h only works
++# for constant arguments.  Useless!
++AC_CACHE_CHECK([for working alloca.h], ac_cv_header_alloca_h,
++[AC_TRY_LINK([#include <alloca.h>], [char *p = alloca(2 * sizeof(int));],
++  ac_cv_header_alloca_h=yes, ac_cv_header_alloca_h=no)])
++if test $ac_cv_header_alloca_h = yes; then
++  AC_DEFINE(HAVE_ALLOCA_H)
++fi
++
++AC_CACHE_CHECK([for alloca], ac_cv_func_alloca_works,
++[AC_TRY_LINK([
++#ifdef __GNUC__
++# define alloca __builtin_alloca
++#else
++# ifdef _MSC_VER
++#  include <malloc.h>
++#  define alloca _alloca
++# else
++#  if HAVE_ALLOCA_H
++#   include <alloca.h>
++#  else
++#   ifdef _AIX
++ #pragma alloca
++#   else
++#    ifndef alloca /* predefined by HP cc +Olibcalls */
++char *alloca ();
++#    endif
++#   endif
++#  endif
++# endif
++#endif
++], [char *p = (char *) alloca(1);],
++  ac_cv_func_alloca_works=yes, ac_cv_func_alloca_works=no)])
++if test $ac_cv_func_alloca_works = yes; then
++  AC_DEFINE(HAVE_ALLOCA)
++fi
++
++if test $ac_cv_func_alloca_works = no; then
++  # The SVR3 libPW and SVR4 libucb both contain incompatible functions
++  # that cause trouble.  Some versions do not even contain alloca or
++  # contain a buggy version.  If you still want to use their alloca,
++  # use ar to extract alloca.o from them instead of compiling alloca.c.
++  ALLOCA=alloca.${ac_objext}
++  AC_DEFINE(C_ALLOCA)
++
++AC_CACHE_CHECK(whether alloca needs Cray hooks, ac_cv_os_cray,
++[AC_EGREP_CPP(webecray,
++[#if defined(CRAY) && ! defined(CRAY2)
++webecray
++#else
++wenotbecray
++#endif
++], ac_cv_os_cray=yes, ac_cv_os_cray=no)])
++if test $ac_cv_os_cray = yes; then
++for ac_func in _getb67 GETB67 getb67; do
++  AC_CHECK_FUNC($ac_func, [AC_DEFINE_UNQUOTED(CRAY_STACKSEG_END, $ac_func)
++  break])
++done
++fi
++
++AC_CACHE_CHECK(stack direction for C alloca, ac_cv_c_stack_direction,
++[AC_TRY_RUN([find_stack_direction ()
++{
++  static char *addr = 0;
++  auto char dummy;
++  if (addr == 0)
++    {
++      addr = &dummy;
++      return find_stack_direction ();
++    }
++  else
++    return (&dummy > addr) ? 1 : -1;
++}
++main ()
++{
++  exit (find_stack_direction() < 0);
++}], ac_cv_c_stack_direction=1, ac_cv_c_stack_direction=-1,
++  ac_cv_c_stack_direction=0)])
++AC_DEFINE_UNQUOTED(STACK_DIRECTION, $ac_cv_c_stack_direction)
++fi
++AC_SUBST(ALLOCA)dnl
++])
++
++AC_DEFUN(AC_FUNC_GETLOADAVG,
++[ac_have_func=no # yes means we've found a way to get the load average.
++
++# Some systems with -lutil have (and need) -lkvm as well, some do not.
++# On Solaris, -lkvm requires nlist from -lelf, so check that first
++# to get the right answer into the cache.
++AC_CHECK_LIB(elf, elf_begin, LIBS="-lelf $LIBS")
++AC_CHECK_LIB(kvm, kvm_open, LIBS="-lkvm $LIBS")
++# Check for the 4.4BSD definition of getloadavg.
++AC_CHECK_LIB(util, getloadavg,
++  [LIBS="-lutil $LIBS" ac_have_func=yes ac_cv_func_getloadavg_setgid=yes])
++
++if test $ac_have_func = no; then
++  # There is a commonly available library for RS/6000 AIX.
++  # Since it is not a standard part of AIX, it might be installed locally.
++  ac_getloadavg_LIBS="$LIBS"; LIBS="-L/usr/local/lib $LIBS"
++  AC_CHECK_LIB(getloadavg, getloadavg,
++    LIBS="-lgetloadavg $LIBS", LIBS="$ac_getloadavg_LIBS")
++fi
++
++# Make sure it is really in the library, if we think we found it.
++AC_REPLACE_FUNCS(getloadavg)
++
++if test $ac_cv_func_getloadavg = yes; then
++  AC_DEFINE(HAVE_GETLOADAVG)
++  ac_have_func=yes
++else
++  # Figure out what our getloadavg.c needs.
++  ac_have_func=no
++  AC_CHECK_HEADER(sys/dg_sys_info.h,
++  [ac_have_func=yes; AC_DEFINE(DGUX)
++  AC_CHECK_LIB(dgc, dg_sys_info)])
++
++  # We cannot check for <dwarf.h>, because Solaris 2 does not use dwarf (it
++  # uses stabs), but it is still SVR4.  We cannot check for <elf.h> because
++  # Irix 4.0.5F has the header but not the library.
++  if test $ac_have_func = no && test $ac_cv_lib_elf_elf_begin = yes; then
++    ac_have_func=yes; AC_DEFINE(SVR4)
++  fi
++
++  if test $ac_have_func = no; then
++    AC_CHECK_HEADER(inq_stats/cpustats.h,
++    [ac_have_func=yes; AC_DEFINE(UMAX)
++    AC_DEFINE(UMAX4_3)])
++  fi
++
++  if test $ac_have_func = no; then
++    AC_CHECK_HEADER(sys/cpustats.h,
++    [ac_have_func=yes; AC_DEFINE(UMAX)])
++  fi
++
++  if test $ac_have_func = no; then
++    AC_CHECK_HEADERS(mach/mach.h)
++  fi
++
++  AC_CHECK_HEADER(nlist.h,
++  [AC_DEFINE(NLIST_STRUCT)
++  AC_CACHE_CHECK([for n_un in struct nlist], ac_cv_struct_nlist_n_un,
++  [AC_TRY_COMPILE([#include <nlist.h>],
++  [struct nlist n; n.n_un.n_name = 0;],
++  ac_cv_struct_nlist_n_un=yes, ac_cv_struct_nlist_n_un=no)])
++  if test $ac_cv_struct_nlist_n_un = yes; then
++    AC_DEFINE(NLIST_NAME_UNION)
++  fi
++  ])dnl
++fi # Do not have getloadavg in system libraries.
++
++# Some definitions of getloadavg require that the program be installed setgid.
++dnl FIXME Don't hardwire the path of getloadavg.c in the top-level directory.
++AC_CACHE_CHECK(whether getloadavg requires setgid,
++  ac_cv_func_getloadavg_setgid,
++[AC_EGREP_CPP([Yowza Am I SETGID yet],
++[#include "$srcdir/getloadavg.c"
++#ifdef LDAV_PRIVILEGED
++Yowza Am I SETGID yet
++#endif],
++  ac_cv_func_getloadavg_setgid=yes, ac_cv_func_getloadavg_setgid=no)])
++if test $ac_cv_func_getloadavg_setgid = yes; then
++  NEED_SETGID=true; AC_DEFINE(GETLOADAVG_PRIVILEGED)
++else
++  NEED_SETGID=false
++fi
++AC_SUBST(NEED_SETGID)dnl
++
++if test $ac_cv_func_getloadavg_setgid = yes; then
++  AC_CACHE_CHECK(group of /dev/kmem, ac_cv_group_kmem,
++[changequote(, )dnl
++  # On Solaris, /dev/kmem is a symlink.  Get info on the real file.
++  ac_ls_output=`ls -lgL /dev/kmem 2>/dev/null`
++  # If we got an error (system does not support symlinks), try without -L.
++  test -z "$ac_ls_output" && ac_ls_output=`ls -lg /dev/kmem`
++  ac_cv_group_kmem=`echo $ac_ls_output \
++    | sed -ne 's/[ 	][ 	]*/ /g;
++	       s/^.[sSrwx-]* *[0-9]* *\([^0-9]*\)  *.*/\1/;
++	       / /s/.* //;p;'`
++changequote([, ])dnl
++])
++  KMEM_GROUP=$ac_cv_group_kmem
++fi
++AC_SUBST(KMEM_GROUP)dnl
++])
++
++AC_DEFUN(AC_FUNC_UTIME_NULL,
++[AC_CACHE_CHECK(whether utime accepts a null argument, ac_cv_func_utime_null,
++[rm -f conftestdata; > conftestdata
++# Sequent interprets utime(file, 0) to mean use start of epoch.  Wrong.
++AC_TRY_RUN([#include <sys/types.h>
++#include <sys/stat.h>
++main() {
++struct stat s, t;
++exit(!(stat ("conftestdata", &s) == 0 && utime("conftestdata", (long *)0) == 0
++&& stat("conftestdata", &t) == 0 && t.st_mtime >= s.st_mtime
++&& t.st_mtime - s.st_mtime < 120));
++}], ac_cv_func_utime_null=yes, ac_cv_func_utime_null=no,
++  ac_cv_func_utime_null=no)
++rm -f core core.* *.core])
++if test $ac_cv_func_utime_null = yes; then
++  AC_DEFINE(HAVE_UTIME_NULL)
++fi
++])
++
++AC_DEFUN(AC_FUNC_STRCOLL,
++[AC_CACHE_CHECK(for working strcoll, ac_cv_func_strcoll_works,
++[AC_TRY_RUN([#include <string.h>
++main ()
++{
++  exit (strcoll ("abc", "def") >= 0 ||
++	strcoll ("ABC", "DEF") >= 0 ||
++	strcoll ("123", "456") >= 0);
++}], ac_cv_func_strcoll_works=yes, ac_cv_func_strcoll_works=no,
++ac_cv_func_strcoll_works=no)])
++if test $ac_cv_func_strcoll_works = yes; then
++  AC_DEFINE(HAVE_STRCOLL)
++fi
++])
++
++AC_DEFUN(AC_FUNC_SETVBUF_REVERSED,
++[AC_CACHE_CHECK(whether setvbuf arguments are reversed,
++  ac_cv_func_setvbuf_reversed,
++[AC_TRY_RUN([#include <stdio.h>
++/* If setvbuf has the reversed format, exit 0. */
++main () {
++  /* This call has the arguments reversed.
++     A reversed system may check and see that the address of main
++     is not _IOLBF, _IONBF, or _IOFBF, and return nonzero.  */
++  if (setvbuf(stdout, _IOLBF, (char *) main, BUFSIZ) != 0)
++    exit(1);
++  putc('\r', stdout);
++  exit(0);			/* Non-reversed systems segv here.  */
++}], ac_cv_func_setvbuf_reversed=yes, ac_cv_func_setvbuf_reversed=no)
++rm -f core core.* *.core])
++if test $ac_cv_func_setvbuf_reversed = yes; then
++  AC_DEFINE(SETVBUF_REVERSED)
++fi
++])
++
++AC_DEFUN(AC_FUNC_GETMNTENT,
++[# getmntent is in -lsun on Irix 4, -lseq on Dynix/PTX, -lgen on Unixware.
++AC_CHECK_LIB(sun, getmntent, LIBS="-lsun $LIBS",
++  [AC_CHECK_LIB(seq, getmntent, LIBS="-lseq $LIBS",
++    [AC_CHECK_LIB(gen, getmntent, LIBS="-lgen $LIBS")])])
++AC_CHECK_FUNC(getmntent, [AC_DEFINE(HAVE_GETMNTENT)])])
++
++AC_DEFUN(AC_FUNC_STRFTIME,
++[AC_CHECK_FUNC(strftime, [AC_DEFINE(HAVE_STRFTIME)],
++[# strftime is in -lintl on SCO UNIX.
++AC_CHECK_LIB(intl, strftime, 
++[AC_DEFINE(HAVE_STRFTIME)
++LIBS="-lintl $LIBS"])])])
++
++AC_DEFUN(AC_FUNC_MEMCMP,
++[AC_CACHE_CHECK(for 8-bit clean memcmp, ac_cv_func_memcmp_clean,
++[AC_TRY_RUN([
++main()
++{
++  char c0 = 0x40, c1 = 0x80, c2 = 0x81;
++  exit(memcmp(&c0, &c2, 1) < 0 && memcmp(&c1, &c2, 1) < 0 ? 0 : 1);
++}
++], ac_cv_func_memcmp_clean=yes, ac_cv_func_memcmp_clean=no,
++ac_cv_func_memcmp_clean=no)])
++test $ac_cv_func_memcmp_clean = no && LIBOBJS="$LIBOBJS memcmp.${ac_objext}"
++AC_SUBST(LIBOBJS)dnl
++])
++
++AC_DEFUN(AC_FUNC_SELECT_ARGTYPES,
++[AC_MSG_CHECKING([types of arguments for select()])
++ AC_CACHE_VAL(ac_cv_func_select_arg234,dnl
++ [AC_CACHE_VAL(ac_cv_func_select_arg1,dnl
++  [AC_CACHE_VAL(ac_cv_func_select_arg5,dnl
++   [for ac_cv_func_select_arg234 in 'fd_set *' 'int *' 'void *'; do
++     for ac_cv_func_select_arg1 in 'int' 'size_t' 'unsigned long' 'unsigned'; do
++      for ac_cv_func_select_arg5 in 'struct timeval *' 'const struct timeval *'; do
++       AC_TRY_COMPILE(dnl
++[#ifdef HAVE_SYS_TYPES_H
++#include <sys/types.h>
++#endif
++#ifdef HAVE_SYS_TIME_H
++#include <sys/time.h>
++#endif
++#ifdef HAVE_SYS_SELECT_H
++#include <sys/select.h>
++#endif
++#ifdef HAVE_SYS_SOCKET_H
++#include <sys/socket.h>
++#endif
++extern select ($ac_cv_func_select_arg1,$ac_cv_func_select_arg234,$ac_cv_func_select_arg234,$ac_cv_func_select_arg234,$ac_cv_func_select_arg5);],,dnl
++        [ac_not_found=no ; break 3],ac_not_found=yes)
++      done
++     done
++    done
++   ])dnl AC_CACHE_VAL
++  ])dnl AC_CACHE_VAL
++ ])dnl AC_CACHE_VAL
++ if test "$ac_not_found" = yes; then
++  ac_cv_func_select_arg1=int 
++  ac_cv_func_select_arg234='int *' 
++  ac_cv_func_select_arg5='struct timeval *'
++ fi
++ AC_MSG_RESULT([$ac_cv_func_select_arg1,$ac_cv_func_select_arg234,$ac_cv_func_select_arg5])
++ AC_DEFINE_UNQUOTED(SELECT_TYPE_ARG1,$ac_cv_func_select_arg1)
++ AC_DEFINE_UNQUOTED(SELECT_TYPE_ARG234,($ac_cv_func_select_arg234))
++ AC_DEFINE_UNQUOTED(SELECT_TYPE_ARG5,($ac_cv_func_select_arg5))
++])
++
++
++dnl ### Checks for structure members
++
++
++AC_DEFUN(AC_HEADER_TIME,
++[AC_CACHE_CHECK([whether time.h and sys/time.h may both be included],
++  ac_cv_header_time,
++[AC_TRY_COMPILE([#include <sys/types.h>
++#include <sys/time.h>
++#include <time.h>],
++[struct tm *tp;], ac_cv_header_time=yes, ac_cv_header_time=no)])
++if test $ac_cv_header_time = yes; then
++  AC_DEFINE(TIME_WITH_SYS_TIME)
++fi
++])
++
++AC_DEFUN(AC_STRUCT_TM,
++[AC_CACHE_CHECK([whether struct tm is in sys/time.h or time.h],
++  ac_cv_struct_tm,
++[AC_TRY_COMPILE([#include <sys/types.h>
++#include <time.h>],
++[struct tm *tp; tp->tm_sec;],
++  ac_cv_struct_tm=time.h, ac_cv_struct_tm=sys/time.h)])
++if test $ac_cv_struct_tm = sys/time.h; then
++  AC_DEFINE(TM_IN_SYS_TIME)
++fi
++])
++
++AC_DEFUN(AC_STRUCT_TIMEZONE,
++[AC_REQUIRE([AC_STRUCT_TM])dnl
++AC_CACHE_CHECK([for tm_zone in struct tm], ac_cv_struct_tm_zone,
++[AC_TRY_COMPILE([#include <sys/types.h>
++#include <$ac_cv_struct_tm>], [struct tm tm; tm.tm_zone;],
++  ac_cv_struct_tm_zone=yes, ac_cv_struct_tm_zone=no)])
++if test "$ac_cv_struct_tm_zone" = yes; then
++  AC_DEFINE(HAVE_TM_ZONE)
++else
++  AC_CACHE_CHECK(for tzname, ac_cv_var_tzname,
++[AC_TRY_LINK(
++changequote(<<, >>)dnl
++<<#include <time.h>
++#ifndef tzname /* For SGI.  */
++extern char *tzname[]; /* RS6000 and others reject char **tzname.  */
++#endif>>,
++changequote([, ])dnl
++[atoi(*tzname);], ac_cv_var_tzname=yes, ac_cv_var_tzname=no)])
++  if test $ac_cv_var_tzname = yes; then
++    AC_DEFINE(HAVE_TZNAME)
++  fi
++fi
++])
++
++AC_DEFUN(AC_STRUCT_ST_BLOCKS,
++[AC_CACHE_CHECK([for st_blocks in struct stat], ac_cv_struct_st_blocks,
++[AC_TRY_COMPILE([#include <sys/types.h>
++#include <sys/stat.h>], [struct stat s; s.st_blocks;],
++ac_cv_struct_st_blocks=yes, ac_cv_struct_st_blocks=no)])
++if test $ac_cv_struct_st_blocks = yes; then
++  AC_DEFINE(HAVE_ST_BLOCKS)
++else
++  LIBOBJS="$LIBOBJS fileblocks.${ac_objext}"
++fi
++AC_SUBST(LIBOBJS)dnl
++])
++
++AC_DEFUN(AC_STRUCT_ST_BLKSIZE,
++[AC_CACHE_CHECK([for st_blksize in struct stat], ac_cv_struct_st_blksize,
++[AC_TRY_COMPILE([#include <sys/types.h>
++#include <sys/stat.h>], [struct stat s; s.st_blksize;],
++ac_cv_struct_st_blksize=yes, ac_cv_struct_st_blksize=no)])
++if test $ac_cv_struct_st_blksize = yes; then
++  AC_DEFINE(HAVE_ST_BLKSIZE)
++fi
++])
++
++AC_DEFUN(AC_STRUCT_ST_RDEV,
++[AC_CACHE_CHECK([for st_rdev in struct stat], ac_cv_struct_st_rdev,
++[AC_TRY_COMPILE([#include <sys/types.h>
++#include <sys/stat.h>], [struct stat s; s.st_rdev;],
++ac_cv_struct_st_rdev=yes, ac_cv_struct_st_rdev=no)])
++if test $ac_cv_struct_st_rdev = yes; then
++  AC_DEFINE(HAVE_ST_RDEV)
++fi
++])
++
++
++dnl ### Checks for compiler characteristics
++
++
++AC_DEFUN(AC_C_CROSS,
++[AC_OBSOLETE([$0], [; it has been merged into AC_PROG_CC])])
++
++AC_DEFUN(AC_C_CHAR_UNSIGNED,
++[AC_CACHE_CHECK(whether char is unsigned, ac_cv_c_char_unsigned,
++[if test "$GCC" = yes; then
++  # GCC predefines this symbol on systems where it applies.
++AC_EGREP_CPP(yes,
++[#ifdef __CHAR_UNSIGNED__
++  yes
++#endif
++], ac_cv_c_char_unsigned=yes, ac_cv_c_char_unsigned=no)
++else
++AC_TRY_RUN(
++[/* volatile prevents gcc2 from optimizing the test away on sparcs.  */
++#if !defined(__STDC__) || __STDC__ != 1
++#define volatile
++#endif
++main() {
++  volatile char c = 255; exit(c < 0);
++}], ac_cv_c_char_unsigned=yes, ac_cv_c_char_unsigned=no)
++fi])
++if test $ac_cv_c_char_unsigned = yes && test "$GCC" != yes; then
++  AC_DEFINE(__CHAR_UNSIGNED__)
++fi
++])
++
++AC_DEFUN(AC_C_LONG_DOUBLE,
++[AC_CACHE_CHECK(for long double, ac_cv_c_long_double,
++[if test "$GCC" = yes; then
++  ac_cv_c_long_double=yes
++else
++AC_TRY_RUN([int main() {
++/* The Stardent Vistra knows sizeof(long double), but does not support it.  */
++long double foo = 0.0;
++/* On Ultrix 4.3 cc, long double is 4 and double is 8.  */
++exit(sizeof(long double) < sizeof(double)); }],
++ac_cv_c_long_double=yes, ac_cv_c_long_double=no)
++fi])
++if test $ac_cv_c_long_double = yes; then
++  AC_DEFINE(HAVE_LONG_DOUBLE)
++fi
++])
++
++AC_DEFUN(AC_INT_16_BITS,
++[AC_OBSOLETE([$0], [; instead use AC_CHECK_SIZEOF(int)])dnl
++AC_MSG_CHECKING(whether int is 16 bits)
++AC_TRY_RUN([main() { exit(sizeof(int) != 2); }],
++ [AC_MSG_RESULT(yes)
++ AC_DEFINE(INT_16_BITS)], AC_MSG_RESULT(no))
++])
++
++AC_DEFUN(AC_LONG_64_BITS,
++[AC_OBSOLETE([$0], [; instead use AC_CHECK_SIZEOF(long)])dnl
++AC_MSG_CHECKING(whether long int is 64 bits)
++AC_TRY_RUN([main() { exit(sizeof(long int) != 8); }],
++ [AC_MSG_RESULT(yes)
++ AC_DEFINE(LONG_64_BITS)], AC_MSG_RESULT(no))
++])
++
++AC_DEFUN(AC_C_BIGENDIAN,
++[AC_CACHE_CHECK(whether byte ordering is bigendian, ac_cv_c_bigendian,
++[ac_cv_c_bigendian=unknown
++# See if sys/param.h defines the BYTE_ORDER macro.
++AC_TRY_COMPILE([#include <sys/types.h>
++#include <sys/param.h>], [
++#if !BYTE_ORDER || !BIG_ENDIAN || !LITTLE_ENDIAN
++ bogus endian macros
++#endif], [# It does; now see whether it defined to BIG_ENDIAN or not.
++AC_TRY_COMPILE([#include <sys/types.h>
++#include <sys/param.h>], [
++#if BYTE_ORDER != BIG_ENDIAN
++ not big endian
++#endif], ac_cv_c_bigendian=yes, ac_cv_c_bigendian=no)])
++if test $ac_cv_c_bigendian = unknown; then
++AC_TRY_RUN([main () {
++  /* Are we little or big endian?  From Harbison&Steele.  */
++  union
++  {
++    long l;
++    char c[sizeof (long)];
++  } u;
++  u.l = 1;
++  exit (u.c[sizeof (long) - 1] == 1);
++}], ac_cv_c_bigendian=no, ac_cv_c_bigendian=yes)
++fi])
++if test $ac_cv_c_bigendian = yes; then
++  AC_DEFINE(WORDS_BIGENDIAN)
++fi
++])
++
++dnl Do nothing if the compiler accepts the inline keyword.
++dnl Otherwise define inline to __inline__ or __inline if one of those work,
++dnl otherwise define inline to be empty.
++AC_DEFUN(AC_C_INLINE,
++[AC_CACHE_CHECK([for inline], ac_cv_c_inline,
++[ac_cv_c_inline=no
++for ac_kw in inline __inline__ __inline; do
++  AC_TRY_COMPILE(, [} $ac_kw foo() {], [ac_cv_c_inline=$ac_kw; break])
++done
++])
++case "$ac_cv_c_inline" in
++  inline | yes) ;;
++  no) AC_DEFINE(inline, ) ;;
++  *)  AC_DEFINE_UNQUOTED(inline, $ac_cv_c_inline) ;;
++esac
++])
++
++AC_DEFUN(AC_C_CONST,
++[dnl This message is consistent in form with the other checking messages,
++dnl and with the result message.
++AC_CACHE_CHECK([for working const], ac_cv_c_const,
++[AC_TRY_COMPILE(,
++changequote(<<, >>)dnl
++<<
++/* Ultrix mips cc rejects this.  */
++typedef int charset[2]; const charset x;
++/* SunOS 4.1.1 cc rejects this.  */
++char const *const *ccp;
++char **p;
++/* NEC SVR4.0.2 mips cc rejects this.  */
++struct point {int x, y;};
++static struct point const zero = {0,0};
++/* AIX XL C 1.02.0.0 rejects this.
++   It does not let you subtract one const X* pointer from another in an arm
++   of an if-expression whose if-part is not a constant expression */
++const char *g = "string";
++ccp = &g + (g ? g-g : 0);
++/* HPUX 7.0 cc rejects these. */
++++ccp;
++p = (char**) ccp;
++ccp = (char const *const *) p;
++{ /* SCO 3.2v4 cc rejects this.  */
++  char *t;
++  char const *s = 0 ? (char *) 0 : (char const *) 0;
++
++  *t++ = 0;
++}
++{ /* Someone thinks the Sun supposedly-ANSI compiler will reject this.  */
++  int x[] = {25, 17};
++  const int *foo = &x[0];
++  ++foo;
++}
++{ /* Sun SC1.0 ANSI compiler rejects this -- but not the above. */
++  typedef const int *iptr;
++  iptr p = 0;
++  ++p;
++}
++{ /* AIX XL C 1.02.0.0 rejects this saying
++     "k.c", line 2.27: 1506-025 (S) Operand must be a modifiable lvalue. */
++  struct s { int j; const int *ap[3]; };
++  struct s *b; b->j = 5;
++}
++{ /* ULTRIX-32 V3.1 (Rev 9) vcc rejects this */
++  const int foo = 10;
++}
++>>,
++changequote([, ])dnl
++ac_cv_c_const=yes, ac_cv_c_const=no)])
++if test $ac_cv_c_const = no; then
++  AC_DEFINE(const, )
++fi
++])
++
++AC_DEFUN(AC_C_STRINGIZE, [
++AC_REQUIRE([AC_PROG_CPP])
++AC_MSG_CHECKING([for preprocessor stringizing operator])
++AC_CACHE_VAL(ac_cv_c_stringize,
++AC_EGREP_CPP([#teststring],[
++#define x(y) #y
++
++char *s = x(teststring);
++], ac_cv_c_stringize=no, ac_cv_c_stringize=yes))
++if test "${ac_cv_c_stringize}" = yes
++then
++        AC_DEFINE(HAVE_STRINGIZE)
++fi
++AC_MSG_RESULT([${ac_cv_c_stringize}])
++])dnl
++
++define(AC_ARG_ARRAY,
++[errprint(__file__:__line__: [$0] has been removed; don't do unportable things with arguments
++)m4exit(4)])
++
++dnl Check the object extension used by the compiler: typically .o or
++dnl .obj.  If this is called, some other behaviour will change,
++dnl determined by ac_objext.
++AC_DEFUN(AC_OBJEXT,
++[AC_MSG_CHECKING([for object suffix])
++AC_CACHE_VAL(ac_cv_objext,
++[rm -f conftest*
++echo 'int i = 1;' > conftest.$ac_ext
++if AC_TRY_EVAL(ac_compile); then
++  for ac_file in conftest.*; do
++    case $ac_file in
++    *.c) ;;
++    *) ac_cv_objext=`echo $ac_file | sed -e s/conftest.//` ;;
++    esac
++  done
++else
++  AC_MSG_ERROR([installation or configuration problem; compiler does not work])
++fi
++rm -f conftest*])
++AC_MSG_RESULT($ac_cv_objext)
++OBJEXT=$ac_cv_objext
++ac_objext=$ac_cv_objext
++AC_SUBST(OBJEXT)])
++
++dnl Determine the linker flags (e.g. `-L' and `-l') for the Fortran 77
++dnl intrinsic and run-time libraries that are required to successfully
++dnl link a Fortran 77 program or shared library.  The output variable
++dnl FLIBS is set to these flags.
++dnl 
++dnl This macro is intended to be used in those situations when it is
++dnl necessary to mix, e.g. C++ and Fortran 77, source code into a single
++dnl program or shared library.
++dnl 
++dnl For example, if object files from a C++ and Fortran 77 compiler must
++dnl be linked together, then the C++ compiler/linker must be used for
++dnl linking (since special C++-ish things need to happen at link time
++dnl like calling global constructors, instantiating templates, enabling
++dnl exception support, etc.).
++dnl 
++dnl However, the Fortran 77 intrinsic and run-time libraries must be
++dnl linked in as well, but the C++ compiler/linker doesn't know how to
++dnl add these Fortran 77 libraries.  Hence, the macro
++dnl `AC_F77_LIBRARY_LDFLAGS' was created to determine these Fortran 77
++dnl libraries.
++dnl
++dnl This macro was packaged in its current form by Matthew D. Langston
++dnl <langston@SLAC.Stanford.EDU>.  However, nearly all of this macro
++dnl came from the `OCTAVE_FLIBS' macro in `octave-2.0.13/aclocal.m4',
++dnl and full credit should go to John W. Eaton for writing this
++dnl extremely useful macro.  Thank you John.
++dnl
++dnl AC_F77_LIBRARY_LDFLAGS()
++AC_DEFUN(AC_F77_LIBRARY_LDFLAGS,
++[AC_MSG_CHECKING([for Fortran 77 libraries])
++AC_REQUIRE([AC_PROG_F77])
++AC_REQUIRE([AC_CANONICAL_HOST])
++AC_CACHE_VAL(ac_cv_flibs,
++[changequote(, )dnl
++dnl Write a minimal program and compile it with -v.  I don't know what
++dnl to do if your compiler doesn't have -v...
++echo "      END" > conftest.f
++foutput=`${F77} -v -o conftest conftest.f 2>&1`
++dnl
++dnl The easiest thing to do for xlf output is to replace all the commas
++dnl with spaces.  Try to only do that if the output is really from xlf,
++dnl since doing that causes problems on other systems.
++dnl
++xlf_p=`echo $foutput | grep xlfentry`
++if test -n "$xlf_p"; then
++  foutput=`echo $foutput | sed 's/,/ /g'`
++fi
++dnl
++ld_run_path=`echo $foutput | \
++  sed -n -e 's/^.*LD_RUN_PATH *= *\([^ ]*\).*/\1/p'`
++dnl
++dnl We are only supposed to find this on Solaris systems...
++dnl Uh, the run path should be absolute, shouldn't it?
++dnl
++case "$ld_run_path" in
++  /*)
++    if test "$ac_cv_prog_gcc" = yes; then
++      ld_run_path="-Xlinker -R -Xlinker $ld_run_path"
++    else
++      ld_run_path="-R $ld_run_path"
++    fi
++  ;;
++  *)
++    ld_run_path=
++  ;;
++esac
++dnl
++flibs=
++lflags=
++dnl
++dnl If want_arg is set, we know we want the arg to be added to the list,
++dnl so we don't have to examine it.
++dnl
++want_arg=
++dnl
++for arg in $foutput; do
++  old_want_arg=$want_arg
++  want_arg=
++dnl
++dnl None of the options that take arguments expect the argument to
++dnl start with a -, so pretend we didn't see anything special.
++dnl
++  if test -n "$old_want_arg"; then
++    case "$arg" in
++      -*)
++        old_want_arg=
++      ;;
++    esac
++  fi
++  case "$old_want_arg" in
++    '')
++      case $arg in
++        /*.a)
++          exists=false
++          for f in $lflags; do
++            if test x$arg = x$f; then
++              exists=true
++            fi
++          done
++          if $exists; then
++            arg=
++          else
++            lflags="$lflags $arg"
++          fi
++        ;;
++        -bI:*)
++          exists=false
++          for f in $lflags; do
++            if test x$arg = x$f; then
++              exists=true
++            fi
++          done
++          if $exists; then
++            arg=
++          else
++            if test "$ac_cv_prog_gcc" = yes; then
++              lflags="$lflags -Xlinker $arg"
++            else
++              lflags="$lflags $arg"
++            fi
++          fi
++        ;;
++        -lang* | -lcrt0.o | -lc | -lgcc)
++          arg=
++        ;;
++        -[lLR])
++          want_arg=$arg
++          arg=
++        ;;
++        -[lLR]*)
++          exists=false
++          for f in $lflags; do
++            if test x$arg = x$f; then
++              exists=true
++            fi
++          done
++          if $exists; then
++            arg=
++          else
++            case "$arg" in
++              -lkernel32)
++                case "$canonical_host_type" in
++                  *-*-cygwin*)
++                    arg=
++                  ;;
++                  *)
++                    lflags="$lflags $arg"
++                  ;;
++                esac
++              ;;
++              -lm)
++              ;;
++              *)
++                lflags="$lflags $arg"
++              ;;
++            esac
++          fi
++        ;;
++        -u)
++          want_arg=$arg
++          arg=
++        ;;
++        -Y)
++          want_arg=$arg
++          arg=
++        ;;
++        *)
++          arg=
++        ;;
++      esac
++    ;;
++    -[lLR])
++      arg="$old_want_arg $arg"
++    ;;
++    -u)
++      arg="-u $arg"
++    ;;
++    -Y)
++dnl
++dnl Should probably try to ensure unique directory options here too.
++dnl This probably only applies to Solaris systems, and then will only
++dnl work with gcc...
++dnl
++      arg=`echo $arg | sed -e 's%^P,%%'`
++      SAVE_IFS=$IFS
++      IFS=:
++      list=
++      for elt in $arg; do
++        list="$list -L$elt"
++      done
++      IFS=$SAVE_IFS
++      arg="$list"
++    ;;
++  esac
++dnl
++  if test -n "$arg"; then
++    flibs="$flibs $arg"
++  fi
++done
++if test -n "$ld_run_path"; then
++  flibs_result="$ld_run_path $flibs"
++else
++  flibs_result="$flibs"
++fi
++changequote([, ])dnl
++ac_cv_flibs="$flibs_result"])
++FLIBS="$ac_cv_flibs"
++AC_SUBST(FLIBS)dnl
++AC_MSG_RESULT($FLIBS)
++])
++
++
++dnl ### Checks for operating system services
++
++
++AC_DEFUN(AC_SYS_INTERPRETER,
++[# Pull the hash mark out of the macro call to avoid m4 problems.
++ac_msg="whether #! works in shell scripts"
++AC_CACHE_CHECK($ac_msg, ac_cv_sys_interpreter,
++[echo '#! /bin/cat
++exit 69
++' > conftest
++chmod u+x conftest
++(SHELL=/bin/sh; export SHELL; ./conftest >/dev/null)
++if test $? -ne 69; then
++   ac_cv_sys_interpreter=yes
++else
++   ac_cv_sys_interpreter=no
++fi
++rm -f conftest])
++interpval="$ac_cv_sys_interpreter"
++])
++
++define(AC_HAVE_POUNDBANG,
++[errprint(__file__:__line__: [$0 has been replaced by AC_SYS_INTERPRETER, taking no arguments
++])m4exit(4)])
++
++AC_DEFUN(AC_SYS_LONG_FILE_NAMES,
++[AC_CACHE_CHECK(for long file names, ac_cv_sys_long_file_names,
++[ac_cv_sys_long_file_names=yes
++# Test for long file names in all the places we know might matter:
++#      .		the current directory, where building will happen
++#      $prefix/lib	where we will be installing things
++#      $exec_prefix/lib	likewise
++# eval it to expand exec_prefix.
++#      $TMPDIR		if set, where it might want to write temporary files
++# if $TMPDIR is not set:
++#      /tmp		where it might want to write temporary files
++#      /var/tmp		likewise
++#      /usr/tmp		likewise
++if test -n "$TMPDIR" && test -d "$TMPDIR" && test -w "$TMPDIR"; then
++  ac_tmpdirs="$TMPDIR"
++else
++  ac_tmpdirs='/tmp /var/tmp /usr/tmp'
++fi
++for ac_dir in  . $ac_tmpdirs `eval echo $prefix/lib $exec_prefix/lib` ; do
++  test -d $ac_dir || continue
++  test -w $ac_dir || continue # It is less confusing to not echo anything here.
++  (echo 1 > $ac_dir/conftest9012345) 2>/dev/null
++  (echo 2 > $ac_dir/conftest9012346) 2>/dev/null
++  val=`cat $ac_dir/conftest9012345 2>/dev/null`
++  if test ! -f $ac_dir/conftest9012345 || test "$val" != 1; then
++    ac_cv_sys_long_file_names=no
++    rm -f $ac_dir/conftest9012345 $ac_dir/conftest9012346 2>/dev/null
++    break
++  fi
++  rm -f $ac_dir/conftest9012345 $ac_dir/conftest9012346 2>/dev/null
++done])
++if test $ac_cv_sys_long_file_names = yes; then
++  AC_DEFINE(HAVE_LONG_FILE_NAMES)
++fi
++])
++
++AC_DEFUN(AC_SYS_RESTARTABLE_SYSCALLS,
++[AC_CACHE_CHECK(for restartable system calls, ac_cv_sys_restartable_syscalls,
++[AC_TRY_RUN(
++[/* Exit 0 (true) if wait returns something other than -1,
++   i.e. the pid of the child, which means that wait was restarted
++   after getting the signal.  */
++#include <sys/types.h>
++#include <signal.h>
++ucatch (isig) { }
++main () {
++  int i = fork (), status;
++  if (i == 0) { sleep (3); kill (getppid (), SIGINT); sleep (3); exit (0); }
++  signal (SIGINT, ucatch);
++  status = wait(&i);
++  if (status == -1) wait(&i);
++  exit (status == -1);
++}
++], ac_cv_sys_restartable_syscalls=yes, ac_cv_sys_restartable_syscalls=no)])
++if test $ac_cv_sys_restartable_syscalls = yes; then
++  AC_DEFINE(HAVE_RESTARTABLE_SYSCALLS)
++fi
++])
++
++AC_DEFUN(AC_PATH_X,
++[AC_REQUIRE_CPP()dnl Set CPP; we run AC_PATH_X_DIRECT conditionally.
++# If we find X, set shell vars x_includes and x_libraries to the
++# paths, otherwise set no_x=yes.
++# Uses ac_ vars as temps to allow command line to override cache and checks.
++# --without-x overrides everything else, but does not touch the cache.
++AC_MSG_CHECKING(for X)
++
++AC_ARG_WITH(x, [  --with-x                use the X Window System])
++# $have_x is `yes', `no', `disabled', or empty when we do not yet know.
++if test "x$with_x" = xno; then
++  # The user explicitly disabled X.
++  have_x=disabled
++else
++  if test "x$x_includes" != xNONE && test "x$x_libraries" != xNONE; then
++    # Both variables are already set.
++    have_x=yes
++  else
++AC_CACHE_VAL(ac_cv_have_x,
++[# One or both of the vars are not set, and there is no cached value.
++ac_x_includes=NO ac_x_libraries=NO
++AC_PATH_X_XMKMF
++AC_PATH_X_DIRECT
++if test "$ac_x_includes" = NO || test "$ac_x_libraries" = NO; then
++  # Didn't find X anywhere.  Cache the known absence of X.
++  ac_cv_have_x="have_x=no"
++else
++  # Record where we found X for the cache.
++  ac_cv_have_x="have_x=yes \
++	        ac_x_includes=$ac_x_includes ac_x_libraries=$ac_x_libraries"
++fi])dnl
++  fi
++  eval "$ac_cv_have_x"
++fi # $with_x != no
++
++if test "$have_x" != yes; then
++  AC_MSG_RESULT($have_x)
++  no_x=yes
++else
++  # If each of the values was on the command line, it overrides each guess.
++  test "x$x_includes" = xNONE && x_includes=$ac_x_includes
++  test "x$x_libraries" = xNONE && x_libraries=$ac_x_libraries
++  # Update the cache value to reflect the command line values.
++  ac_cv_have_x="have_x=yes \
++		ac_x_includes=$x_includes ac_x_libraries=$x_libraries"
++  AC_MSG_RESULT([libraries $x_libraries, headers $x_includes])
++fi
++])
++
++dnl Internal subroutine of AC_PATH_X.
++dnl Set ac_x_includes and/or ac_x_libraries.
++AC_DEFUN(AC_PATH_X_XMKMF,
++[rm -fr conftestdir
++if mkdir conftestdir; then
++  cd conftestdir
++  # Make sure to not put "make" in the Imakefile rules, since we grep it out.
++  cat > Imakefile <<'EOF'
++acfindx:
++	@echo 'ac_im_incroot="${INCROOT}"; ac_im_usrlibdir="${USRLIBDIR}"; ac_im_libdir="${LIBDIR}"'
++EOF
++  if (xmkmf) >/dev/null 2>/dev/null && test -f Makefile; then
++    # GNU make sometimes prints "make[1]: Entering...", which would confuse us.
++    eval `${MAKE-make} acfindx 2>/dev/null | grep -v make`
++    # Open Windows xmkmf reportedly sets LIBDIR instead of USRLIBDIR.
++    for ac_extension in a so sl; do
++      if test ! -f $ac_im_usrlibdir/libX11.$ac_extension &&
++        test -f $ac_im_libdir/libX11.$ac_extension; then
++        ac_im_usrlibdir=$ac_im_libdir; break
++      fi
++    done
++    # Screen out bogus values from the imake configuration.  They are
++    # bogus both because they are the default anyway, and because
++    # using them would break gcc on systems where it needs fixed includes.
++    case "$ac_im_incroot" in
++	/usr/include) ;;
++	*) test -f "$ac_im_incroot/X11/Xos.h" && ac_x_includes="$ac_im_incroot" ;;
++    esac
++    case "$ac_im_usrlibdir" in
++	/usr/lib | /lib) ;;
++	*) test -d "$ac_im_usrlibdir" && ac_x_libraries="$ac_im_usrlibdir" ;;
++    esac
++  fi
++  cd ..
++  rm -fr conftestdir
++fi
++])
++
++dnl Internal subroutine of AC_PATH_X.
++dnl Set ac_x_includes and/or ac_x_libraries.
++AC_DEFUN(AC_PATH_X_DIRECT,
++[if test "$ac_x_includes" = NO; then
++  # Guess where to find include files, by looking for this one X11 .h file.
++  test -z "$x_direct_test_include" && x_direct_test_include=X11/Intrinsic.h
++
++  # First, try using that file with no special directory specified.
++AC_TRY_CPP([#include <$x_direct_test_include>],
++[# We can compile using X headers with no special include directory.
++ac_x_includes=],
++[# Look for the header file in a standard set of common directories.
++# Check X11 before X11Rn because it is often a symlink to the current release.
++  for ac_dir in               \
++    /usr/X11/include          \
++    /usr/X11R6/include        \
++    /usr/X11R5/include        \
++    /usr/X11R4/include        \
++                              \
++    /usr/include/X11          \
++    /usr/include/X11R6        \
++    /usr/include/X11R5        \
++    /usr/include/X11R4        \
++                              \
++    /usr/local/X11/include    \
++    /usr/local/X11R6/include  \
++    /usr/local/X11R5/include  \
++    /usr/local/X11R4/include  \
++                              \
++    /usr/local/include/X11    \
++    /usr/local/include/X11R6  \
++    /usr/local/include/X11R5  \
++    /usr/local/include/X11R4  \
++                              \
++    /usr/X386/include         \
++    /usr/x386/include         \
++    /usr/XFree86/include/X11  \
++                              \
++    /usr/include              \
++    /usr/local/include        \
++    /usr/unsupported/include  \
++    /usr/athena/include       \
++    /usr/local/x11r5/include  \
++    /usr/lpp/Xamples/include  \
++                              \
++    /usr/openwin/include      \
++    /usr/openwin/share/include \
++    ; \
++  do
++    if test -r "$ac_dir/$x_direct_test_include"; then
++      ac_x_includes=$ac_dir
++      break
++    fi
++  done])
++fi # $ac_x_includes = NO
++
++if test "$ac_x_libraries" = NO; then
++  # Check for the libraries.
++
++  test -z "$x_direct_test_library" && x_direct_test_library=Xt
++  test -z "$x_direct_test_function" && x_direct_test_function=XtMalloc
++
++  # See if we find them without any special options.
++  # Don't add to $LIBS permanently.
++  ac_save_LIBS="$LIBS"
++  LIBS="-l$x_direct_test_library $LIBS"
++AC_TRY_LINK(, [${x_direct_test_function}()],
++[LIBS="$ac_save_LIBS"
++# We can link X programs with no special library path.
++ac_x_libraries=],
++[LIBS="$ac_save_LIBS"
++# First see if replacing the include by lib works.
++# Check X11 before X11Rn because it is often a symlink to the current release.
++for ac_dir in `echo "$ac_x_includes" | sed s/include/lib/` \
++    /usr/X11/lib          \
++    /usr/X11R6/lib        \
++    /usr/X11R5/lib        \
++    /usr/X11R4/lib        \
++                          \
++    /usr/lib/X11          \
++    /usr/lib/X11R6        \
++    /usr/lib/X11R5        \
++    /usr/lib/X11R4        \
++                          \
++    /usr/local/X11/lib    \
++    /usr/local/X11R6/lib  \
++    /usr/local/X11R5/lib  \
++    /usr/local/X11R4/lib  \
++                          \
++    /usr/local/lib/X11    \
++    /usr/local/lib/X11R6  \
++    /usr/local/lib/X11R5  \
++    /usr/local/lib/X11R4  \
++                          \
++    /usr/X386/lib         \
++    /usr/x386/lib         \
++    /usr/XFree86/lib/X11  \
++                          \
++    /usr/lib              \
++    /usr/local/lib        \
++    /usr/unsupported/lib  \
++    /usr/athena/lib       \
++    /usr/local/x11r5/lib  \
++    /usr/lpp/Xamples/lib  \
++    /lib/usr/lib/X11	  \
++                          \
++    /usr/openwin/lib      \
++    /usr/openwin/share/lib \
++    ; \
++do
++dnl Don't even attempt the hair of trying to link an X program!
++  for ac_extension in a so sl; do
++    if test -r $ac_dir/lib${x_direct_test_library}.$ac_extension; then
++      ac_x_libraries=$ac_dir
++      break 2
++    fi
++  done
++done])
++fi # $ac_x_libraries = NO
++])
++
++dnl Find additional X libraries, magic flags, etc.
++AC_DEFUN(AC_PATH_XTRA,
++[AC_REQUIRE([AC_PATH_X])dnl
++if test "$no_x" = yes; then
++  # Not all programs may use this symbol, but it does not hurt to define it.
++  AC_DEFINE(X_DISPLAY_MISSING)
++  X_CFLAGS= X_PRE_LIBS= X_LIBS= X_EXTRA_LIBS=
++else
++  if test -n "$x_includes"; then
++    X_CFLAGS="$X_CFLAGS -I$x_includes"
++  fi
++
++  # It would also be nice to do this for all -L options, not just this one.
++  if test -n "$x_libraries"; then
++    X_LIBS="$X_LIBS -L$x_libraries"
++dnl FIXME banish uname from this macro!
++    # For Solaris; some versions of Sun CC require a space after -R and
++    # others require no space.  Words are not sufficient . . . .
++    case "`(uname -sr) 2>/dev/null`" in
++    "SunOS 5"*)
++      AC_MSG_CHECKING(whether -R must be followed by a space)
++      ac_xsave_LIBS="$LIBS"; LIBS="$LIBS -R$x_libraries"
++      AC_TRY_LINK(, , ac_R_nospace=yes, ac_R_nospace=no)
++      if test $ac_R_nospace = yes; then
++	AC_MSG_RESULT(no)
++	X_LIBS="$X_LIBS -R$x_libraries"
++      else
++	LIBS="$ac_xsave_LIBS -R $x_libraries"
++	AC_TRY_LINK(, , ac_R_space=yes, ac_R_space=no)
++	if test $ac_R_space = yes; then
++	  AC_MSG_RESULT(yes)
++	  X_LIBS="$X_LIBS -R $x_libraries"
++	else
++	  AC_MSG_RESULT(neither works)
++	fi
++      fi
++      LIBS="$ac_xsave_LIBS"
++    esac
++  fi
++
++  # Check for system-dependent libraries X programs must link with.
++  # Do this before checking for the system-independent R6 libraries
++  # (-lICE), since we may need -lsocket or whatever for X linking.
++
++  if test "$ISC" = yes; then
++    X_EXTRA_LIBS="$X_EXTRA_LIBS -lnsl_s -linet"
++  else
++    # Martyn.Johnson@cl.cam.ac.uk says this is needed for Ultrix, if the X
++    # libraries were built with DECnet support.  And karl@cs.umb.edu says
++    # the Alpha needs dnet_stub (dnet does not exist).
++    AC_CHECK_LIB(dnet, dnet_ntoa, [X_EXTRA_LIBS="$X_EXTRA_LIBS -ldnet"])
++    if test $ac_cv_lib_dnet_dnet_ntoa = no; then
++      AC_CHECK_LIB(dnet_stub, dnet_ntoa,
++	[X_EXTRA_LIBS="$X_EXTRA_LIBS -ldnet_stub"])
++    fi
++
++    # msh@cis.ufl.edu says -lnsl (and -lsocket) are needed for his 386/AT,
++    # to get the SysV transport functions.
++    # chad@anasazi.com says the Pyramis MIS-ES running DC/OSx (SVR4)
++    # needs -lnsl.
++    # The nsl library prevents programs from opening the X display
++    # on Irix 5.2, according to dickey@clark.net.
++    AC_CHECK_FUNC(gethostbyname)
++    if test $ac_cv_func_gethostbyname = no; then
++      AC_CHECK_LIB(nsl, gethostbyname, X_EXTRA_LIBS="$X_EXTRA_LIBS -lnsl")
++    fi
++
++    # lieder@skyler.mavd.honeywell.com says without -lsocket,
++    # socket/setsockopt and other routines are undefined under SCO ODT
++    # 2.0.  But -lsocket is broken on IRIX 5.2 (and is not necessary
++    # on later versions), says simon@lia.di.epfl.ch: it contains
++    # gethostby* variants that don't use the nameserver (or something).
++    # -lsocket must be given before -lnsl if both are needed.
++    # We assume that if connect needs -lnsl, so does gethostbyname.
++    AC_CHECK_FUNC(connect)
++    if test $ac_cv_func_connect = no; then
++      AC_CHECK_LIB(socket, connect, X_EXTRA_LIBS="-lsocket $X_EXTRA_LIBS", ,
++	$X_EXTRA_LIBS)
++    fi
++
++    # gomez@mi.uni-erlangen.de says -lposix is necessary on A/UX.
++    AC_CHECK_FUNC(remove)
++    if test $ac_cv_func_remove = no; then
++      AC_CHECK_LIB(posix, remove, X_EXTRA_LIBS="$X_EXTRA_LIBS -lposix")
++    fi
++
++    # BSDI BSD/OS 2.1 needs -lipc for XOpenDisplay.
++    AC_CHECK_FUNC(shmat)
++    if test $ac_cv_func_shmat = no; then
++      AC_CHECK_LIB(ipc, shmat, X_EXTRA_LIBS="$X_EXTRA_LIBS -lipc")
++    fi
++  fi
++
++  # Check for libraries that X11R6 Xt/Xaw programs need.
++  ac_save_LDFLAGS="$LDFLAGS"
++  test -n "$x_libraries" && LDFLAGS="$LDFLAGS -L$x_libraries"
++  # SM needs ICE to (dynamically) link under SunOS 4.x (so we have to
++  # check for ICE first), but we must link in the order -lSM -lICE or
++  # we get undefined symbols.  So assume we have SM if we have ICE.
++  # These have to be linked with before -lX11, unlike the other
++  # libraries we check for below, so use a different variable.
++  #  --interran@uluru.Stanford.EDU, kb@cs.umb.edu.
++  AC_CHECK_LIB(ICE, IceConnectionNumber,
++    [X_PRE_LIBS="$X_PRE_LIBS -lSM -lICE"], , $X_EXTRA_LIBS)
++  LDFLAGS="$ac_save_LDFLAGS"
++
++fi
++AC_SUBST(X_CFLAGS)dnl
++AC_SUBST(X_PRE_LIBS)dnl
++AC_SUBST(X_LIBS)dnl
++AC_SUBST(X_EXTRA_LIBS)dnl
++])
++
++dnl The old Cygwin32 macro is deprecated.
++AC_DEFUN(AC_CYGWIN32,
++[AC_OBSOLETE([$0], [; instead use AC_CYGWIN])dnl
++AC_CYGWIN])
++
++dnl Check for Cygwin.  This is a way to set the right value for
++dnl EXEEXT.
++AC_DEFUN(AC_CYGWIN,
++[AC_CACHE_CHECK(for Cygwin environment, ac_cv_cygwin,
++[AC_TRY_COMPILE(,[
++#ifndef __CYGWIN__
++#define __CYGWIN__ __CYGWIN32__
++#endif
++return __CYGWIN__;],
++ac_cv_cygwin=yes, ac_cv_cygwin=no)
++rm -f conftest*])
++CYGWIN=
++test "$ac_cv_cygwin" = yes && CYGWIN=yes])
++
++dnl Check for mingw32.  This is another way to set the right value for
++dnl EXEEXT.
++AC_DEFUN(AC_MINGW32,
++[AC_CACHE_CHECK(for mingw32 environment, ac_cv_mingw32,
++[AC_TRY_COMPILE(,[return __MINGW32__;],
++ac_cv_mingw32=yes, ac_cv_mingw32=no)
++rm -f conftest*])
++MINGW32=
++test "$ac_cv_mingw32" = yes && MINGW32=yes])
++
++dnl Check for the extension used for executables.  This knows that we
++dnl add .exe for Cygwin or mingw32.  Otherwise, it compiles a test
++dnl executable.  If this is called, the executable extensions will be
++dnl automatically used by link commands run by the configure script.
++AC_DEFUN(AC_EXEEXT,
++[AC_REQUIRE([AC_CYGWIN])
++AC_REQUIRE([AC_MINGW32])
++AC_MSG_CHECKING([for executable suffix])
++AC_CACHE_VAL(ac_cv_exeext,
++[if test "$CYGWIN" = yes || test "$MINGW32" = yes; then
++  ac_cv_exeext=.exe
++else
++  rm -f conftest*
++  echo 'int main () { return 0; }' > conftest.$ac_ext
++  ac_cv_exeext=
++  if AC_TRY_EVAL(ac_link); then
++    for file in conftest.*; do
++      case $file in
++      *.c | *.o | *.obj) ;;
++      *) ac_cv_exeext=`echo $file | sed -e s/conftest//` ;;
++      esac
++    done
++  else
++    AC_MSG_ERROR([installation or configuration problem: compiler cannot create executables.])
++  fi
++  rm -f conftest*
++  test x"${ac_cv_exeext}" = x && ac_cv_exeext=no
++fi])
++EXEEXT=""
++test x"${ac_cv_exeext}" != xno && EXEEXT=${ac_cv_exeext}
++AC_MSG_RESULT(${ac_cv_exeext})
++dnl Setting ac_exeext will implicitly change the ac_link command.
++ac_exeext=$EXEEXT
++AC_SUBST(EXEEXT)])
++
++
++dnl ### Checks for UNIX variants
++dnl These are kludges which should be replaced by a single POSIX check.
++dnl They aren't cached, to discourage their use.
++
++
++AC_DEFUN(AC_AIX,
++[AC_BEFORE([$0], [AC_TRY_COMPILE])dnl
++AC_BEFORE([$0], [AC_TRY_RUN])dnl
++AC_MSG_CHECKING(for AIX)
++AC_EGREP_CPP(yes,
++[#ifdef _AIX
++  yes
++#endif
++], [AC_MSG_RESULT(yes); AC_DEFINE(_ALL_SOURCE)], AC_MSG_RESULT(no))
++])
++
++AC_DEFUN(AC_MINIX,
++[AC_BEFORE([$0], [AC_TRY_COMPILE])dnl
++AC_BEFORE([$0], [AC_TRY_RUN])dnl
++AC_CHECK_HEADER(minix/config.h, MINIX=yes, MINIX=)
++if test "$MINIX" = yes; then
++  AC_DEFINE(_POSIX_SOURCE)
++  AC_DEFINE(_POSIX_1_SOURCE, 2)
++  AC_DEFINE(_MINIX)
++fi
++])
++
++AC_DEFUN(AC_ISC_POSIX,
++[AC_REQUIRE([AC_PROG_CC])dnl
++AC_BEFORE([$0], [AC_TRY_COMPILE])dnl
++AC_BEFORE([$0], [AC_TRY_RUN])dnl
++AC_MSG_CHECKING(for POSIXized ISC)
++if test -d /etc/conf/kconfig.d &&
++  grep _POSIX_VERSION [/usr/include/sys/unistd.h] >/dev/null 2>&1
++then
++  AC_MSG_RESULT(yes)
++  ISC=yes # If later tests want to check for ISC.
++  AC_DEFINE(_POSIX_SOURCE)
++  if test "$GCC" = yes; then
++    CC="$CC -posix"
++  else
++    CC="$CC -Xp"
++  fi
++else
++  AC_MSG_RESULT(no)
++  ISC=
++fi
++])
++
++AC_DEFUN(AC_XENIX_DIR,
++[AC_OBSOLETE([$0], [; instead use AC_HEADER_DIRENT])dnl
++AC_REQUIRE([AC_DIR_HEADER])dnl
++AC_MSG_CHECKING(for Xenix)
++AC_EGREP_CPP(yes,
++[#if defined(M_XENIX) && !defined(M_UNIX)
++  yes
++#endif
++], [AC_MSG_RESULT(yes); XENIX=yes], [AC_MSG_RESULT(no); XENIX=])
++if test "$XENIX" = yes; then
++  # Make sure -ldir precedes -lx.
++  test $ac_header_dirent = dirent.h && LIBS="-ldir $LIBS"
++  LIBS="$LIBS -lx"
++fi
++])
++
++AC_DEFUN(AC_DYNIX_SEQ,
++[AC_OBSOLETE([$0], [; instead use AC_FUNC_GETMNTENT])dnl
++AC_CHECK_LIB(seq, getmntent, LIBS="-lseq $LIBS")
++])
++
++AC_DEFUN(AC_IRIX_SUN,
++[AC_OBSOLETE([$0], [; instead use AC_FUNC_GETMNTENT or AC_CHECK_LIB(sun, getpwnam)])dnl
++AC_CHECK_LIB(sun, getmntent, LIBS="-lsun $LIBS")
++])
++
++AC_DEFUN(AC_SCO_INTL,
++[AC_OBSOLETE([$0], [; instead use AC_FUNC_STRFTIME])dnl
++AC_CHECK_LIB(intl, strftime, LIBS="-lintl $LIBS")
++])
+diff --git a/build/autoconf/autoconf.m4 b/build/autoconf/autoconf.m4
+new file mode 100644
+--- /dev/null
++++ b/build/autoconf/autoconf.m4
+@@ -0,0 +1,28 @@
++dnl Driver that loads the Autoconf macro files.
++dnl Requires GNU m4.
++dnl This file is part of Autoconf.
++dnl Copyright (C) 1994 Free Software Foundation, Inc.
++dnl
++dnl This program is free software; you can redistribute it and/or modify
++dnl it under the terms of the GNU General Public License as published by
++dnl the Free Software Foundation; either version 2, or (at your option)
++dnl any later version.
++dnl
++dnl This program is distributed in the hope that it will be useful,
++dnl but WITHOUT ANY WARRANTY; without even the implied warranty of
++dnl MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
++dnl GNU General Public License for more details.
++dnl
++dnl You should have received a copy of the GNU General Public License
++dnl along with this program; if not, write to the Free Software
++dnl Foundation, Inc., 59 Temple Place - Suite 330, Boston, MA
++dnl 02111-1307, USA.
++dnl
++dnl Written by David MacKenzie.
++dnl
++include(acgeneral.m4)dnl
++builtin(include, acspecific.m4)dnl
++builtin(include, acoldnames.m4)dnl
++dnl Do not sinclude acsite.m4 here, because it may not be installed
++dnl yet when Autoconf is frozen.
++dnl Do not sinclude ./aclocal.m4 here, to prevent it from being frozen.
+diff --git a/build/autoconf/autoconf.sh b/build/autoconf/autoconf.sh
+new file mode 100644
+--- /dev/null
++++ b/build/autoconf/autoconf.sh
+@@ -0,0 +1,159 @@
++#! @SHELL@
++# autoconf -- create `configure' using m4 macros
++# Copyright (C) 1992, 1993, 1994, 1996 Free Software Foundation, Inc.
++
++# This program is free software; you can redistribute it and/or modify
++# it under the terms of the GNU General Public License as published by
++# the Free Software Foundation; either version 2, or (at your option)
++# any later version.
++
++# This program is distributed in the hope that it will be useful,
++# but WITHOUT ANY WARRANTY; without even the implied warranty of
++# MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
++# GNU General Public License for more details.
++
++# You should have received a copy of the GNU General Public License
++# along with this program; if not, write to the Free Software
++# Foundation, Inc., 59 Temple Place - Suite 330, Boston, MA
++# 02111-1307, USA.
++
++# If given no args, create `configure' from template file `configure.in'.
++# With one arg, create a configure script on standard output from
++# the given template file.
++
++usage="\
++Usage: autoconf [-h] [--help] [-m dir] [--macrodir=dir]
++       [-l dir] [--localdir=dir] [--version] [template-file]"
++
++# NLS nuisances.
++# Only set these to C if already set.  These must not be set unconditionally
++# because not all systems understand e.g. LANG=C (notably SCO).
++# Fixing LC_MESSAGES prevents Solaris sh from translating var values in `set'!
++# Non-C LC_CTYPE values break the ctype check.
++if test "${LANG+set}"   = set; then LANG=C;   export LANG;   fi
++if test "${LC_ALL+set}" = set; then LC_ALL=C; export LC_ALL; fi
++if test "${LC_MESSAGES+set}" = set; then LC_MESSAGES=C; export LC_MESSAGES; fi
++if test "${LC_CTYPE+set}"    = set; then LC_CTYPE=C;    export LC_CTYPE;    fi
++
++: ${AC_MACRODIR=@datadir@}
++: ${M4=@M4@}
++: ${AWK=@AWK@}
++case "${M4}" in
++/*) # Handle the case that m4 has moved since we were configured.
++    # It may have been found originally in a build directory.
++    test -f "${M4}" || M4=m4 ;;
++esac
++
++: ${TMPDIR=/tmp}
++tmpout=${TMPDIR}/acout.$$
++localdir=
++show_version=no
++
++while test $# -gt 0 ; do
++   case "${1}" in
++      -h | --help | --h* )
++         echo "${usage}" 1>&2; exit 0 ;;
++      --localdir=* | --l*=* )
++         localdir="`echo \"${1}\" | sed -e 's/^[^=]*=//'`"
++         shift ;;
++      -l | --localdir | --l*)
++         shift
++         test $# -eq 0 && { echo "${usage}" 1>&2; exit 1; }
++         localdir="${1}"
++         shift ;;
++      --macrodir=* | --m*=* )
++         AC_MACRODIR="`echo \"${1}\" | sed -e 's/^[^=]*=//'`"
++         shift ;;
++      -m | --macrodir | --m* )
++         shift
++         test $# -eq 0 && { echo "${usage}" 1>&2; exit 1; }
++         AC_MACRODIR="${1}"
++         shift ;;
++      --version | --v* )
++         show_version=yes; shift ;;
++      -- )     # Stop option processing
++        shift; break ;;
++      - )	# Use stdin as input.
++        break ;;
++      -* )
++        echo "${usage}" 1>&2; exit 1 ;;
++      * )
++        break ;;
++   esac
++done
++
++if test $show_version = yes; then
++  version=`sed -n 's/define.AC_ACVERSION.[ 	]*\([0-9.]*\).*/\1/p' \
++    $AC_MACRODIR/acgeneral.m4`
++  echo "Autoconf version $version"
++  exit 0
++fi
++
++case $# in
++  0) infile=configure.in ;;
++  1) infile="$1" ;;
++  *) echo "$usage" >&2; exit 1 ;;
++esac
++
++trap 'rm -f $tmpin $tmpout; exit 1' 1 2 15
++
++tmpin=${TMPDIR}/acin.$$ # Always set this, to avoid bogus errors from some rm's.
++if test z$infile = z-; then
++  infile=$tmpin
++  cat > $infile
++elif test ! -r "$infile"; then
++  echo "autoconf: ${infile}: No such file or directory" >&2
++  exit 1
++fi
++
++if test -n "$localdir"; then
++  use_localdir="-I$localdir -DAC_LOCALDIR=$localdir"
++else
++  use_localdir=
++fi
++
++# Use the frozen version of Autoconf if available.
++r= f=
++# Some non-GNU m4's don't reject the --help option, so give them /dev/null.
++case `$M4 --help < /dev/null 2>&1` in
++*reload-state*) test -r $AC_MACRODIR/autoconf.m4f && { r=--reload f=f; } ;;
++*traditional*) ;;
++*) echo Autoconf requires GNU m4 1.1 or later >&2; rm -f $tmpin; exit 1 ;;
++esac
++
++$M4 -I$AC_MACRODIR $use_localdir $r autoconf.m4$f $infile > $tmpout ||
++  { rm -f $tmpin $tmpout; exit 2; }
++
++# You could add your own prefixes to pattern if you wanted to check for
++# them too, e.g. pattern='\(AC_\|ILT_\)', except that UNIX sed doesn't do
++# alternation.
++pattern="AC_"
++
++status=0
++if grep "^[^#]*${pattern}" $tmpout > /dev/null 2>&1; then
++  echo "autoconf: Undefined macros:" >&2
++  sed -n "s/^[^#]*\\(${pattern}[_A-Za-z0-9]*\\).*/\\1/p" $tmpout |
++    while read macro; do
++      grep -n "^[^#]*$macro" $infile /dev/null
++      test $? -eq 1 && echo >&2 "***BUG in Autoconf--please report*** $macro"
++    done | sort -u >&2
++  status=1
++fi
++
++if test $# -eq 0; then
++  exec 4> configure; chmod +x configure
++else
++  exec 4>&1
++fi
++
++# Put the real line numbers into configure to make config.log more helpful.
++$AWK '
++/__oline__/ { printf "%d:", NR + 1 }
++           { print }
++' $tmpout | sed '
++/__oline__/s/^\([0-9][0-9]*\):\(.*\)__oline__/\2\1/
++' >&4
++
++rm -f $tmpout
++
++exit $status
+diff --git a/build/moz.configure/old.configure b/build/moz.configure/old.configure
+--- a/build/moz.configure/old.configure
++++ b/build/moz.configure/old.configure
+@@ -1,89 +1,33 @@
+ # -*- Mode: python; indent-tabs-mode: nil; tab-width: 40 -*-
+ # vim: set filetype=python:
+ # This Source Code Form is subject to the terms of the Mozilla Public
+ # License, v. 2.0. If a copy of the MPL was not distributed with this
+ # file, You can obtain one at http://mozilla.org/MPL/2.0/.
+ 
+ 
+-option(env='AUTOCONF', nargs=1, help='Path to autoconf 2.13')
+-
+-
+-@depends(mozconfig, 'AUTOCONF')
+-@checking('for autoconf')
+-@imports(_from='os.path', _import='exists')
+-@imports('re')
+-def autoconf(mozconfig, autoconf):
+-    mozconfig_autoconf = None
+-    if mozconfig['path']:
+-        make_extra = mozconfig['make_extra']
+-        if make_extra:
+-            for assignment in make_extra:
+-                m = re.match('(?:export\s+)?AUTOCONF\s*:?=\s*(.+)$',
+-                             assignment)
+-                if m:
+-                    mozconfig_autoconf = m.group(1)
+-                # Check whether we've exported any known-broken variables.
+-                m = re.match('(?:export\s+)?(?:CC|CXX)\s*:?=\s*(?:.+)$',
+-                             assignment)
+-                if m:
+-                    die('Setting the value of CC or CXX with "mk_add_options" '
+-                        'can cause the build to fail unexpectedly. Please '
+-                        'change your mozconfig to instead use '
+-                        '"ac_add_options", e.g. ac_add_options '
+-                        'CC=my-custom-cc".')
+-
+-    autoconf = autoconf[0] if autoconf else None
+-
+-    for ac in (mozconfig_autoconf, autoconf, 'autoconf-2.13', 'autoconf2.13',
+-               'autoconf213'):
+-        if ac:
+-            autoconf = find_program(ac)
+-            if autoconf:
+-                break
+-    else:
+-        fink = find_program('fink')
+-        if fink:
+-            autoconf = os.path.normpath(os.path.join(
+-                fink, '..', '..', 'lib', 'autoconf2.13', 'bin', 'autoconf'))
+-        else:
+-            brew = find_program('brew')
+-            if brew:
+-                autoconf = os.path.normpath(os.path.join(
+-                    brew, '..', '..', 'Cellar', 'autoconf213', '2.13', 'bin',
+-                    'autoconf213'))
+-
+-    if not autoconf:
+-        die('Could not find autoconf 2.13')
+-
+-    if not exists(autoconf):
+-        die('Could not find autoconf 2.13 at %s', autoconf)
+-
+-    return autoconf
+-
+-
+-set_config('AUTOCONF', autoconf)
++m4 = check_prog('M4', ('m4',))
+ 
+ 
+ @depends(mozconfig)
+ def prepare_mozconfig(mozconfig):
+     if mozconfig['path']:
+         items = {}
+         for key, value in mozconfig['vars']['added'].items():
+             items[key] = (value, 'added')
+         for key, (old, value) in mozconfig['vars']['modified'].items():
+             items[key] = (value, 'modified')
+         for t in ('env', 'vars'):
+             for key in mozconfig[t]['removed'].keys():
+                 items[key] = (None, 'removed ' + t)
+         return items
+ 
+ 
+-@depends('OLD_CONFIGURE', 'MOZILLABUILD', prepare_mozconfig, autoconf, check_build_environment,
++@depends('OLD_CONFIGURE', 'MOZILLABUILD', prepare_mozconfig, awk, m4, check_build_environment,
+          shell, old_configure_assignments, build_project)
+ @imports(_from='__builtin__', _import='open')
+ @imports(_from='__builtin__', _import='print')
+ @imports(_from='__builtin__', _import='sorted')
+ @imports('glob')
+ @imports('itertools')
+ @imports('subprocess')
+ # Import getmtime without overwriting the sandbox os.path.
+@@ -91,17 +35,17 @@ def prepare_mozconfig(mozconfig):
+ @imports(_from='os.path', _import='exists')
+ @imports(_from='mozbuild.shellutil', _import='quote')
+ @imports(_from='tempfile', _import='NamedTemporaryFile')
+ @imports(_from='os', _import='environ')
+ @imports(_from='os', _import='remove')
+ @imports(_from='os', _import='rename')
+ @imports(_from='subprocess', _import='CalledProcessError')
+ @imports(_from='__builtin__', _import='OSError')
+-def prepare_configure(old_configure, mozillabuild, mozconfig, autoconf, build_env, shell,
++def prepare_configure(old_configure, mozillabuild, mozconfig, awk, m4, build_env, shell,
+                       old_configure_assignments, build_project):
+     # os.path.abspath in the sandbox will ensure forward slashes on Windows,
+     # which is actually necessary because this path actually ends up literally
+     # as $0, and backslashes there breaks autoconf's detection of the source
+     # directory.
+     old_configure = os.path.abspath(old_configure[0])
+     if build_project == 'js':
+         old_configure_dir = os.path.dirname(old_configure)
+@@ -120,23 +64,28 @@ def prepare_configure(old_configure, moz
+             glob.iglob(aclocal),
+         ):
+             if getmtime(input) > mtime:
+                 break
+         else:
+             refresh = False
+ 
+     if refresh:
++        autoconf = os.path.join(build_env.topsrcdir, 'build', 'autoconf', 'autoconf.sh')
+         log.info('Refreshing %s with %s', old_configure, autoconf)
++        env = dict(environ)
++        env['M4'] = m4
++        env['AWK'] = awk
++        env['AC_MACRODIR'] = os.path.join(build_env.topsrcdir, 'build', 'autoconf')
+ 
+         try:
+             script = subprocess.check_output([
+                 shell, autoconf,
+                 '--localdir=%s' % os.path.dirname(old_configure),
+-                old_configure + '.in'])
++                old_configure + '.in'], env=env)
+         except CalledProcessError as exc:
+             # Autoconf on win32 may break due to a bad $PATH.  Let the user know
+             # their $PATH is suspect.
+             if mozillabuild:
+                 mozillabuild_path = normsep(mozillabuild[0])
+                 sh_path = normsep(find_program('sh'))
+                 if mozillabuild_path not in sh_path:
+                     log.warning("The '{}msys/bin' directory is not first in $PATH. "
+@@ -180,20 +129,16 @@ def prepare_configure(old_configure, moz
+                 if action.startswith('removed '):
+                     inject("unset %s # from %s" % (
+                         key, action[len('removed '):]))
+                 else:
+                     inject("%s=%s # %s" % (key, quote(value), action))
+ 
+             inject('# end of mozconfig values')
+ 
+-        # Autoconf is special, because it might be passed from
+-        # mozconfig['make_extra'], which we don't pass automatically above.
+-        inject('export AUTOCONF=%s' % quote(autoconf))
+-
+         for k, v in old_configure_assignments:
+             inject('%s=%s' % (k, quote(v)))
+ 
+     return cmd
+ 
+ 
+ @template
+ def old_configure_options(*options):

mozilla-release/patches/1670807-84a1.patch

@@ -0,0 +1,36 @@
+# HG changeset patch
+# User Sylvestre Ledru <sledru@mozilla.com>
+# Date 1605035971 0
+# Node ID 7a15a7dfb7a2d5f821356a8b7142f6add3ffb693
+# Parent  f01190fa9e321e17e72ed8c1d1a4331323c501dc
+Bug 1670807 - Look for gm4 in addition to m4 r=firefox-build-system-reviewers,rstewart
+
+Differential Revision: https://phabricator.services.mozilla.com/D94305
+
+diff --git a/build/moz.configure/old.configure b/build/moz.configure/old.configure
+--- a/build/moz.configure/old.configure
++++ b/build/moz.configure/old.configure
+@@ -1,16 +1,22 @@
+ # -*- Mode: python; indent-tabs-mode: nil; tab-width: 40 -*-
+ # vim: set filetype=python:
+ # This Source Code Form is subject to the terms of the Mozilla Public
+ # License, v. 2.0. If a copy of the MPL was not distributed with this
+ # file, You can obtain one at http://mozilla.org/MPL/2.0/.
+ 
+ 
+-m4 = check_prog('M4', ('m4',))
++m4 = check_prog(
++    "M4",
++    (
++        "gm4",
++        "m4",
++    ),
++)
+ 
+ 
+ @depends(mozconfig)
+ def prepare_mozconfig(mozconfig):
+     if mozconfig['path']:
+         items = {}
+         for key, value in mozconfig['vars']['added'].items():
+             items[key] = (value, 'added')

mozilla-release/patches/1672894-84a1.patch

@@ -0,0 +1,265 @@
+# HG changeset patch
+# User Mike Hommey <mh+mozilla@glandium.org>
+# Date 1603461248 0
+# Node ID 484f408e18dd25bbb2e51f7f2cc34d6453bcf4d7
+# Parent  c71dcd59611f4290da0d59f60887207ccd318c92
+Bug 1672894 - Don't bootstrap autoconf 2.13. r=firefox-build-system-reviewers,rstewart DONTBUILD
+
+We've vendored it in bug 1663863 so we don't need it installed on the
+system anymore.
+
+Differential Revision: https://phabricator.services.mozilla.com/D94538
+
+diff --git a/python/mozboot/mozboot/archlinux.py b/python/mozboot/mozboot/archlinux.py
+--- a/python/mozboot/mozboot/archlinux.py
++++ b/python/mozboot/mozboot/archlinux.py
+@@ -21,17 +21,16 @@ if sys.version_info < (3,):
+ 
+ 
+ class ArchlinuxBootstrapper(
+         LinuxBootstrapper,
+         BaseBootstrapper):
+     '''Archlinux experimental bootstrapper.'''
+ 
+     SYSTEM_PACKAGES = [
+-        'autoconf2.13',
+         'base-devel',
+         'nodejs',
+         'python2',
+         'python2-setuptools',
+         'python',  # This is Python 3 on Arch.
+         'python-pip',
+         'unzip',
+         'zip',
+diff --git a/python/mozboot/mozboot/centosfedora.py b/python/mozboot/mozboot/centosfedora.py
+--- a/python/mozboot/mozboot/centosfedora.py
++++ b/python/mozboot/mozboot/centosfedora.py
+@@ -18,17 +18,16 @@ class CentOSFedoraBootstrapper(
+ 
+         self.distro = distro
+         self.version = int(version.split('.')[0])
+         self.dist_id = dist_id
+ 
+         self.group_packages = []
+ 
+         self.packages = [
+-            'autoconf213',
+             'nodejs',
+             'npm',
+             'which',
+         ]
+ 
+         self.browser_group_packages = [
+             'GNOME Software Development',
+         ]
+diff --git a/python/mozboot/mozboot/debian.py b/python/mozboot/mozboot/debian.py
+--- a/python/mozboot/mozboot/debian.py
++++ b/python/mozboot/mozboot/debian.py
+@@ -26,17 +26,16 @@ Your choice: '''
+ 
+ 
+ class DebianBootstrapper(
+         LinuxBootstrapper,
+         BaseBootstrapper):
+     # These are common packages for all Debian-derived distros (such as
+     # Ubuntu).
+     COMMON_PACKAGES = [
+-        'autoconf2.13',
+         'build-essential',
+         'nodejs',
+         'python-dev',
+         'python-pip',
+         'python-setuptools',
+         'unzip',
+         'uuid',
+         'zip',
+diff --git a/python/mozboot/mozboot/freebsd.py b/python/mozboot/mozboot/freebsd.py
+--- a/python/mozboot/mozboot/freebsd.py
++++ b/python/mozboot/mozboot/freebsd.py
+@@ -9,17 +9,16 @@ from mozboot.base import BaseBootstrappe
+ 
+ class FreeBSDBootstrapper(BaseBootstrapper):
+     def __init__(self, version, flavor, **kwargs):
+         BaseBootstrapper.__init__(self, **kwargs)
+         self.version = int(version.split('.')[0])
+         self.flavor = flavor.lower()
+ 
+         self.packages = [
+-            'autoconf213',
+             'gmake',
+             'gtar',
+             'pkgconf',
+             'py%s%s-sqlite3' % sys.version_info[0:2],
+             'python3',
+             'rust',
+             'watchman',
+             'zip',
+diff --git a/python/mozboot/mozboot/gentoo.py.1672894.later b/python/mozboot/mozboot/gentoo.py.1672894.later
+new file mode 100644
+--- /dev/null
++++ b/python/mozboot/mozboot/gentoo.py.1672894.later
+@@ -0,0 +1,20 @@
++--- gentoo.py
+++++ gentoo.py
++@@ -31,17 +31,16 @@ class GentooBootstrapper(
++         self.ensure_mobile_android_packages(mozconfig_builder, artifact_mode=False)
++ 
++     def install_mobile_android_artifact_mode_packages(self, mozconfig_builder):
++         self.ensure_mobile_android_packages(mozconfig_builder, artifact_mode=True)
++ 
++     def ensure_system_packages(self):
++         self.run_as_root(['emerge', '--noreplace', '--quiet',
++                           'app-arch/zip',
++-                          'sys-devel/autoconf:2.1'
++                           ])
++ 
++     def ensure_browser_packages(self, artifact_mode=False):
++         # TODO: Figure out what not to install for artifact mode
++         self.run_as_root(['emerge',
++                           '--oneshot', '--noreplace', '--quiet', '--newuse',
++                           'dev-lang/yasm',
++                           'dev-libs/dbus-glib',
+diff --git a/python/mozboot/mozboot/openbsd.py b/python/mozboot/mozboot/openbsd.py
+--- a/python/mozboot/mozboot/openbsd.py
++++ b/python/mozboot/mozboot/openbsd.py
+@@ -7,17 +7,16 @@ from __future__ import absolute_import, 
+ from mozboot.base import BaseBootstrapper
+ 
+ 
+ class OpenBSDBootstrapper(BaseBootstrapper):
+     def __init__(self, version, **kwargs):
+         BaseBootstrapper.__init__(self, **kwargs)
+ 
+         self.packages = [
+-            'autoconf-2.13',
+             'gmake',
+             'gtar',
+             'rust',
+             'wget',
+             'unzip',
+             'zip',
+         ]
+ 
+diff --git a/python/mozboot/mozboot/opensuse.py b/python/mozboot/mozboot/opensuse.py
+--- a/python/mozboot/mozboot/opensuse.py
++++ b/python/mozboot/mozboot/opensuse.py
+@@ -8,17 +8,16 @@ from mozboot.base import BaseBootstrappe
+ from mozboot.linux_common import LinuxBootstrapper
+ 
+ 
+ class OpenSUSEBootstrapper(
+         LinuxBootstrapper, BaseBootstrapper):
+     '''openSUSE experimental bootstrapper.'''
+ 
+     SYSTEM_PACKAGES = [
+-        'autoconf213',
+         'nodejs',
+         'npm',
+         'which',
+         'python3-devel',
+         'rpmconf',
+         'libcurl-devel',
+         'libpulse-devel',
+     ]
+diff --git a/python/mozboot/mozboot/osx.py b/python/mozboot/mozboot/osx.py
+--- a/python/mozboot/mozboot/osx.py
++++ b/python/mozboot/mozboot/osx.py
+@@ -328,17 +328,16 @@ class OSXBootstrapper(BaseBootstrapper):
+         return self._ensure_homebrew_packages(casks, extra_brew_args=['cask'])
+ 
+     def ensure_homebrew_system_packages(self):
+         # We need to install Python because Mercurial requires the
+         # Python development headers which are missing from OS X (at
+         # least on 10.8) and because the build system wants a version
+         # newer than what Apple ships.
+         packages = [
+-            'autoconf@2.13',
+             'git',
+             'gnu-tar',
+             'llvm',
+             'mercurial',
+             'node',
+             'python',
+             'python@2',
+             'terminal-notifier',
+@@ -403,17 +402,16 @@ class OSXBootstrapper(BaseBootstrapper):
+             self.run_as_root([self.port, '-v', 'install'] + missing)
+ 
+     def ensure_macports_system_packages(self):
+         packages = [
+             'python27',
+             'python36',
+             'py27-gnureadline',
+             'mercurial',
+-            'autoconf213',
+             'gnutar',
+             'watchman',
+             'nodejs8'
+         ]
+ 
+         self._ensure_macports_packages(packages)
+ 
+         pythons = set(self.check_output([self.port, 'select', '--list', 'python']).split('\n'))
+diff --git a/python/mozboot/mozboot/solus.py b/python/mozboot/mozboot/solus.py
+--- a/python/mozboot/mozboot/solus.py
++++ b/python/mozboot/mozboot/solus.py
+@@ -18,17 +18,16 @@ if sys.version_info < (3,):
+ 
+ 
+ class SolusBootstrapper(
+         LinuxBootstrapper,
+         BaseBootstrapper):
+     '''Solus experimental bootstrapper.'''
+ 
+     SYSTEM_PACKAGES = [
+-        'autoconf213',
+         'nodejs',
+         'python',
+         'python3',
+         'unzip',
+         'zip',
+     ]
+     SYSTEM_COMPONENTS = [
+         'system.devel',
+diff --git a/python/mozboot/mozboot/void.py b/python/mozboot/mozboot/void.py
+--- a/python/mozboot/mozboot/void.py
++++ b/python/mozboot/mozboot/void.py
+@@ -12,17 +12,16 @@ from mozboot.base import BaseBootstrappe
+ from mozboot.linux_common import LinuxBootstrapper
+ 
+ 
+ class VoidBootstrapper(
+         LinuxBootstrapper,
+         BaseBootstrapper):
+ 
+     PACKAGES = [
+-        'autoconf213',
+         'clang',
+         'make',
+         'mercurial',
+         'nodejs',
+         'unzip',
+         'zip',
+     ]
+ 
+diff --git a/python/mozboot/mozboot/windows.py b/python/mozboot/mozboot/windows.py
+--- a/python/mozboot/mozboot/windows.py
++++ b/python/mozboot/mozboot/windows.py
+@@ -43,17 +43,16 @@ class WindowsBootstrapper(BaseBootstrapp
+ 
+     SYSTEM_PACKAGES = [
+         'mingw-w64-x86_64-make',
+         'mingw-w64-x86_64-python2-pip',
+         'mingw-w64-x86_64-perl',
+         'patch',
+         'patchutils',
+         'diffutils',
+-        'autoconf2.13',
+         'tar',
+         'zip',
+         'unzip',
+         'mingw-w64-x86_64-toolchain',  # TODO: Remove when Mercurial is installable from a wheel.
+         'mingw-w64-i686-toolchain'
+     ]
+ 
+     BROWSER_PACKAGES = [

mozilla-release/patches/series

@@ -7354,3 +7354,7 @@ TOP-NOBUG-blockquad0-25319.patch
 1903254-129a1.patch
 1903021-129a1.patch
 1519636-xx-elfhack-130a1.patch
+1541792_PARTIAL-68a1.patch
+1663863-82a1.patch
+1672894-84a1.patch
+1670807-84a1.patch