configure

	# Check whether --enable-dmalloc or --disable-dmalloc was given.
if test "${enable_dmalloc+set}" = set; then
  enableval="$enable_dmalloc"
  
	ol_arg=invalid
	for ol_val in auto yes no ; do
		if test "$enableval" = "$ol_val" ; then
			ol_arg="$ol_val"
		fi
	done
	if test "$ol_arg" = "invalid" ; then
		{ echo "configure: error: bad value $enableval for --enable-dmalloc" 1>&2; exit 1; }
	fi
	ol_enable_dmalloc="$ol_arg"

else
  	ol_enable_dmalloc="no"
fi
# end --enable-dmalloc

# OpenLDAP --with-kerberos
	# Check whether --with-kerberos or --without-kerberos was given.
if test "${with_kerberos+set}" = set; then
  withval="$with_kerberos"
  
	ol_arg=invalid
	for ol_val in auto k5 k4 afs yes no ; do
		if test "$withval" = "$ol_val" ; then
			ol_arg="$ol_val"
		fi
	done
	if test "$ol_arg" = "invalid" ; then
		{ echo "configure: error: bad value $withval for --with-kerberos" 1>&2; exit 1; }
	fi
	ol_with_kerberos="$ol_arg"

else
  	ol_with_kerberos="auto"
fi
# end --with-kerberos

# OpenLDAP --with-threads
	# Check whether --with-threads or --without-threads was given.
if test "${with_threads+set}" = set; then
  withval="$with_threads"
  
	ol_arg=invalid
	for ol_val in auto posix mach lwp yes no manual  ; do
		if test "$withval" = "$ol_val" ; then
			ol_arg="$ol_val"
		fi
	done
	if test "$ol_arg" = "invalid" ; then
		{ echo "configure: error: bad value $withval for --with-threads" 1>&2; exit 1; }
	fi
	ol_with_threads="$ol_arg"

else
  	ol_with_threads="auto"
fi
# end --with-threads

# OpenLDAP --with-yielding_select
	# Check whether --with-yielding_select or --without-yielding_select was given.
if test "${with_yielding_select+set}" = set; then
  withval="$with_yielding_select"
  
	ol_arg=invalid
	for ol_val in auto yes no manual  ; do
		if test "$withval" = "$ol_val" ; then
			ol_arg="$ol_val"
		fi
	done
	if test "$ol_arg" = "invalid" ; then
		{ echo "configure: error: bad value $withval for --with-yielding_select" 1>&2; exit 1; }
	fi
	ol_with_yielding_select="$ol_arg"

else
  	ol_with_yielding_select="auto"
fi
# end --with-yielding_select



# Check whether --with-xxldapdoptions or --without-xxldapdoptions was given.
if test "${with_xxldapdoptions+set}" = set; then
  withval="$with_xxldapdoptions"
  :
fi

# OpenLDAP --enable-ldapd
	# Check whether --enable-ldapd or --disable-ldapd was given.
if test "${enable_ldapd+set}" = set; then
  enableval="$enable_ldapd"
  
	ol_arg=invalid
	for ol_val in auto yes no ; do
		if test "$enableval" = "$ol_val" ; then
			ol_arg="$ol_val"
		fi
	done
	if test "$ol_arg" = "invalid" ; then
		{ echo "configure: error: bad value $enableval for --enable-ldapd" 1>&2; exit 1; }
	fi
	ol_enable_ldapd="$ol_arg"

else
  	ol_enable_ldapd="no"
fi
# end --enable-ldapd

# Check whether --with-xxslapdoptions or --without-xxslapdoptions was given.
if test "${with_xxslapdoptions+set}" = set; then
  withval="$with_xxslapdoptions"
  :
fi

# OpenLDAP --enable-slapd
	# Check whether --enable-slapd or --disable-slapd was given.
if test "${enable_slapd+set}" = set; then
  enableval="$enable_slapd"
  
	ol_arg=invalid
	for ol_val in auto yes no ; do
		if test "$enableval" = "$ol_val" ; then
			ol_arg="$ol_val"
		fi
	done
	if test "$ol_arg" = "invalid" ; then
		{ echo "configure: error: bad value $enableval for --enable-slapd" 1>&2; exit 1; }
	fi
	ol_enable_slapd="$ol_arg"

else
  	ol_enable_slapd="yes"
fi
# end --enable-slapd
# OpenLDAP --enable-aclgroups
	# Check whether --enable-aclgroups or --disable-aclgroups was given.
if test "${enable_aclgroups+set}" = set; then
  enableval="$enable_aclgroups"
  
	ol_arg=invalid
	for ol_val in auto yes no ; do
		if test "$enableval" = "$ol_val" ; then
			ol_arg="$ol_val"
		fi
	done
	if test "$ol_arg" = "invalid" ; then
		{ echo "configure: error: bad value $enableval for --enable-aclgroups" 1>&2; exit 1; }
	fi
	ol_enable_aclgroups="$ol_arg"

else
  	ol_enable_aclgroups="auto"
fi
# end --enable-aclgroups
# OpenLDAP --enable-cleartext
	# Check whether --enable-cleartext or --disable-cleartext was given.
if test "${enable_cleartext+set}" = set; then
  enableval="$enable_cleartext"
  
	ol_arg=invalid
	for ol_val in auto yes no ; do
		if test "$enableval" = "$ol_val" ; then
			ol_arg="$ol_val"
		fi
	done
	if test "$ol_arg" = "invalid" ; then
		{ echo "configure: error: bad value $enableval for --enable-cleartext" 1>&2; exit 1; }
	fi
	ol_enable_cleartext="$ol_arg"

else
  	ol_enable_cleartext="yes"
fi
# end --enable-cleartext
# OpenLDAP --enable-crypt
	# Check whether --enable-crypt or --disable-crypt was given.
if test "${enable_crypt+set}" = set; then
  enableval="$enable_crypt"
  
	ol_arg=invalid
	for ol_val in auto yes no ; do
		if test "$enableval" = "$ol_val" ; then
			ol_arg="$ol_val"
		fi
	done
	if test "$ol_arg" = "invalid" ; then
		{ echo "configure: error: bad value $enableval for --enable-crypt" 1>&2; exit 1; }
	fi
	ol_enable_crypt="$ol_arg"

else
  	ol_enable_crypt="auto"
fi
# end --enable-crypt
# OpenLDAP --enable-wrappers
	# Check whether --enable-wrappers or --disable-wrappers was given.
if test "${enable_wrappers+set}" = set; then
  enableval="$enable_wrappers"
  
	ol_arg=invalid
	for ol_val in auto yes no ; do
		if test "$enableval" = "$ol_val" ; then
			ol_arg="$ol_val"
		fi
	done
	if test "$ol_arg" = "invalid" ; then
		{ echo "configure: error: bad value $enableval for --enable-wrappers" 1>&2; exit 1; }
	fi
	ol_enable_wrappers="$ol_arg"

else
  	ol_enable_wrappers="no"
fi
# end --enable-wrappers
# OpenLDAP --enable-phonetic
	# Check whether --enable-phonetic or --disable-phonetic was given.
if test "${enable_phonetic+set}" = set; then
  enableval="$enable_phonetic"
  
	ol_arg=invalid
	for ol_val in auto yes no ; do
		if test "$enableval" = "$ol_val" ; then
			ol_arg="$ol_val"
		fi
	done
	if test "$ol_arg" = "invalid" ; then
		{ echo "configure: error: bad value $enableval for --enable-phonetic" 1>&2; exit 1; }
	fi
	ol_enable_phonetic="$ol_arg"

else
  	ol_enable_phonetic="no"
fi
# end --enable-phonetic
# OpenLDAP --enable-rlookups
	# Check whether --enable-rlookups or --disable-rlookups was given.
if test "${enable_rlookups+set}" = set; then
  enableval="$enable_rlookups"
  
	ol_arg=invalid
	for ol_val in auto yes no ; do
		if test "$enableval" = "$ol_val" ; then
			ol_arg="$ol_val"
		fi
	done
	if test "$ol_arg" = "invalid" ; then
		{ echo "configure: error: bad value $enableval for --enable-rlookups" 1>&2; exit 1; }
	fi
	ol_enable_rlookups="$ol_arg"

else
  	ol_enable_rlookups="auto"
fi
# end --enable-rlookups

# OpenLDAP --enable-ldbm
	# Check whether --enable-ldbm or --disable-ldbm was given.
if test "${enable_ldbm+set}" = set; then
  enableval="$enable_ldbm"
  
	ol_arg=invalid
	for ol_val in auto yes no ; do
		if test "$enableval" = "$ol_val" ; then
			ol_arg="$ol_val"
		fi
	done
	if test "$ol_arg" = "invalid" ; then
		{ echo "configure: error: bad value $enableval for --enable-ldbm" 1>&2; exit 1; }
	fi
	ol_enable_ldbm="$ol_arg"

else
  	ol_enable_ldbm="yes"
fi
# end --enable-ldbm
# OpenLDAP --with-ldbm_api
	# Check whether --with-ldbm_api or --without-ldbm_api was given.
if test "${with_ldbm_api+set}" = set; then
  withval="$with_ldbm_api"
  
	ol_arg=invalid
	for ol_val in auto db2 db gdbm ndbm manual ; do
		if test "$withval" = "$ol_val" ; then
			ol_arg="$ol_val"
		fi
	done
	if test "$ol_arg" = "invalid" ; then
		{ echo "configure: error: bad value $withval for --with-ldbm_api" 1>&2; exit 1; }
	fi
	ol_with_ldbm_api="$ol_arg"

else
  	ol_with_ldbm_api="auto"
fi
# end --with-ldbm_api

# OpenLDAP --with-ldbm_type
	# Check whether --with-ldbm_type or --without-ldbm_type was given.
if test "${with_ldbm_type+set}" = set; then
  withval="$with_ldbm_type"
  
	ol_arg=invalid
	for ol_val in auto btree hash ; do
		if test "$withval" = "$ol_val" ; then
			ol_arg="$ol_val"
		fi
	done
	if test "$ol_arg" = "invalid" ; then
		{ echo "configure: error: bad value $withval for --with-ldbm_type" 1>&2; exit 1; }
	fi
	ol_with_ldbm_type="$ol_arg"

else
  	ol_with_ldbm_type="auto"
fi
# end --with-ldbm_type


# OpenLDAP --enable-passwd
	# Check whether --enable-passwd or --disable-passwd was given.
if test "${enable_passwd+set}" = set; then
  enableval="$enable_passwd"
  
	ol_arg=invalid
	for ol_val in auto yes no ; do
		if test "$enableval" = "$ol_val" ; then
			ol_arg="$ol_val"
		fi
	done
	if test "$ol_arg" = "invalid" ; then
		{ echo "configure: error: bad value $enableval for --enable-passwd" 1>&2; exit 1; }
	fi
	ol_enable_passwd="$ol_arg"

else
  	ol_enable_passwd="no"
fi
# end --enable-passwd
# OpenLDAP --enable-shell
	# Check whether --enable-shell or --disable-shell was given.
if test "${enable_shell+set}" = set; then
  enableval="$enable_shell"
  
	ol_arg=invalid
	for ol_val in auto yes no ; do
		if test "$enableval" = "$ol_val" ; then
			ol_arg="$ol_val"
		fi
	done
	if test "$ol_arg" = "invalid" ; then
		{ echo "configure: error: bad value $enableval for --enable-shell" 1>&2; exit 1; }
	fi
	ol_enable_shell="$ol_arg"

else
  	ol_enable_shell="no"
fi
# end --enable-shell

# Check whether --with-xxslurpdoptions or --without-xxslurpdoptions was given.
if test "${with_xxslurpdoptions+set}" = set; then
  withval="$with_xxslurpdoptions"
  :
fi

# OpenLDAP --enable-slurpd
	# Check whether --enable-slurpd or --disable-slurpd was given.
if test "${enable_slurpd+set}" = set; then
  enableval="$enable_slurpd"
  
	ol_arg=invalid
	for ol_val in auto yes no ; do
		if test "$enableval" = "$ol_val" ; then
			ol_arg="$ol_val"
		fi
	done
	if test "$ol_arg" = "invalid" ; then
		{ echo "configure: error: bad value $enableval for --enable-slurpd" 1>&2; exit 1; }
	fi
	ol_enable_slurpd="$ol_arg"

else
  	ol_enable_slurpd="auto"
fi
# end --enable-slurpd

# Check whether --with-xxliboptions or --without-xxliboptions was given.
if test "${with_xxliboptions+set}" = set; then
  withval="$with_xxliboptions"
  :
fi

# Check whether --enable-static or --disable-static was given.
if test "${enable_static+set}" = set; then
  enableval="$enable_static"
  p=${PACKAGE-default}
case "$enableval" in
yes) enable_static=yes ;;
no) enable_static=no ;;
*)
  enable_static=no
  # Look at the argument we got.  We use all the common list separators.
  IFS="${IFS= 	}"; ac_save_ifs="$IFS"; IFS="${IFS}:,"
  for pkg in $enableval; do
    if test "X$pkg" = "X$p"; then
      enable_static=yes
    fi
  done
  IFS="$ac_save_ifs"
  ;;
esac
else
  enable_static=yes
fi

# Check whether --enable-shared or --disable-shared was given.
if test "${enable_shared+set}" = set; then
  enableval="$enable_shared"
  p=${PACKAGE-default}
case "$enableval" in
yes) enable_shared=yes ;;
no) enable_shared=no ;;
*)
  enable_shared=no
  # Look at the argument we got.  We use all the common list separators.
  IFS="${IFS= 	}"; ac_save_ifs="$IFS"; IFS="${IFS}:,"
  for pkg in $enableval; do
    if test "X$pkg" = "X$p"; then
      enable_shared=yes
    fi
  done
  IFS="$ac_save_ifs"
  ;;
esac
else
  enable_shared=yes
fi


# validate options
if test $ol_enable_referrals = no ; then
	if test $ol_enable_dns = yes ; then
		echo "configure: warning: dns disabled, ignoring --enable-dns argument" 1>&2
	fi
	ol_enable_dns=no
fi

if test $ol_enable_slapd = no ; then
		if test $ol_enable_ldbm = yes ; then
		echo "configure: warning: slapd disabled, ignoring --enable_ldbm argument" 1>&2
	fi
	if test $ol_enable_passwd = yes ; then
		echo "configure: warning: slapd disabled, ignoring --enable_passwd argument" 1>&2
	fi
	if test $ol_enable_shell = yes ; then
		echo "configure: warning: slapd disabled, ignoring --enable_shell argument" 1>&2
	fi
	if test $ol_enable_aclgroups = yes ; then
		echo "configure: warning: slapd disabled, ignoring --enable_aclgroups argument" 1>&2
	fi
	if test $ol_enable_wrappers = yes ; then
		echo "configure: warning: slapd disabled, ignoring --enable_wrappers argument" 1>&2
	fi
	if test $ol_enable_phonetic = yes ; then
		echo "configure: warning: slapd disabled, ignoring --enable_phonetic argument" 1>&2
	fi
	if test $ol_enable_rlookups = yes ; then
		echo "configure: warning: slapd disabled, ignoring --enable_rlookups argument" 1>&2
	fi
	if test $ol_with_ldbm_api != auto ; then
		echo "configure: warning: slapd disabled, ignoring --with_ldbm_api argument" 1>&2
	fi
	if test $ol_with_ldbm_type != auto ; then
		echo "configure: warning: slapd disabled, ignoring --with_ldbm_type argument" 1>&2
	fi
	if test $ol_enable_slurpd = yes ; then
		{ echo "configure: error: slurpd requires slapd" 1>&2; exit 1; }
	fi

	# force settings to no
	ol_enable_ldbm=no
	ol_enable_shell=no
	ol_enable_passwd=no
	ol_enable_aclgroups=no
	ol_enable_wrappers=no
	ol_enable_phonetic=no
	ol_enable_rlookups=no
	ol_with_ldbm_api=no
	ol_with_ldbm_type=no
	ol_enable_slurpd=no

elif test $ol_enable_ldbm = no ; then
	
	if test $ol_with_ldbm_api != auto ; then
		echo "configure: warning: LDBM disabled, ignoring --with_ldbm_api argument" 1>&2
	fi

	if test $ol_with_ldbm_type != auto ; then
		echo "configure: warning: LDBM disabled, ignoring --with_ldbm_type argument" 1>&2
	fi

	if test $ol_enable_passwd = no -a $ol_enable_shell = no ; then
		{ echo "configure: error: slapd requires a backend" 1>&2; exit 1; }
	fi

	ol_with_ldbm_api=no
	ol_with_ldbm_type=no

else
	
	if test $ol_with_ldbm_api = gdbm -a \
		$ol_with_ldbm_type = btree ; then
		{ echo "configure: error: GDBM only supports LDBM type hash" 1>&2; exit 1; }
	fi
	if test $ol_with_ldbm_api = ndbm -a \
		$ol_with_ldbm_type = btree ; then
		{ echo "configure: error: NDBM only supports LDBM type hash" 1>&2; exit 1; }
	fi
fi

if test $ol_enable_slurpd = yes ; then
		if test $ol_with_threads = no ; then
		{ echo "configure: error: slurpd requires threads" 1>&2; exit 1; }
	fi
fi

echo "$ac_t""done" 1>&6


# Make sure we can run config.sub.
if $ac_config_sub sun4 >/dev/null 2>&1; then :
else { echo "configure: error: can not run $ac_config_sub" 1>&2; exit 1; }
fi

echo $ac_n "checking host system type""... $ac_c" 1>&6
echo "configure:1541: checking host system type" >&5

host_alias=$host
case "$host_alias" in
NONE)
  case $nonopt in
  NONE)
    if host_alias=`$ac_config_guess`; then :
    else { echo "configure: error: can not guess host type; you must specify one" 1>&2; exit 1; }
    fi ;;
  *) host_alias=$nonopt ;;
  esac ;;
esac

host=`$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/'`
echo "$ac_t""$host" 1>&6


## Initialize vars
LDAP_LIBS=
LDBM_LIBS=
LTHREAD_LIBS=
LUTIL_LIBS=

LDAPD_LIBS=
SLAPD_LIBS=
SLURPD_LIBS=

BUILD_LDAPD=no
BUILD_SLAPD=no
BUILD_SLURPD=no

BUILD_LDBM=no
BUILD_PASSWD=no
BUILD_SHELL=no
BUILD_THREAD=no

KRB_LIBS=
TERMCAP_LIBS=


# 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
# 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.
echo $ac_n "checking for a BSD compatible install""... $ac_c" 1>&6
echo "configure:1596: checking for a BSD compatible install" >&5
if test -z "$INSTALL"; then
if eval "test \"`echo '$''{'ac_cv_path_install'+set}'`\" = set"; then
  echo $ac_n "(cached) $ac_c" 1>&6
else
    IFS="${IFS= 	}"; ac_save_IFS="$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.
      for ac_prog in ginstall installbsd 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.
	    # OSF/1 installbsd also uses dspmsg, but is usable.
	    :
	  else
	    ac_cv_path_install="$ac_dir/$ac_prog -c"
	    break 2
	  fi
	fi
      done
      ;;
    esac
  done
  IFS="$ac_save_IFS"

fi
  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
echo "$ac_t""$INSTALL" 1>&6

# 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}'

test -z "$INSTALL_DATA" && INSTALL_DATA='${INSTALL} -m 644'

# Extract the first word of "ranlib", so it can be a program name with args.
set dummy ranlib; ac_word=$2
echo $ac_n "checking for $ac_word""... $ac_c" 1>&6
echo "configure:1648: checking for $ac_word" >&5
if eval "test \"`echo '$''{'ac_cv_prog_RANLIB'+set}'`\" = set"; then
  echo $ac_n "(cached) $ac_c" 1>&6
else
  if test -n "$RANLIB"; then
  ac_cv_prog_RANLIB="$RANLIB" # Let the user override the test.
else
  IFS="${IFS= 	}"; ac_save_ifs="$IFS"; IFS="${IFS}:"
  for ac_dir in $PATH; do
    test -z "$ac_dir" && ac_dir=.
    if test -f $ac_dir/$ac_word; then
      ac_cv_prog_RANLIB="ranlib"
      break
    fi
  done
  IFS="$ac_save_ifs"
  test -z "$ac_cv_prog_RANLIB" && ac_cv_prog_RANLIB=":"
fi
fi
RANLIB="$ac_cv_prog_RANLIB"
if test -n "$RANLIB"; then
  echo "$ac_t""$RANLIB" 1>&6
else
  echo "$ac_t""no" 1>&6
fi

# Extract the first word of "gcc", so it can be a program name with args.
set dummy gcc; ac_word=$2
echo $ac_n "checking for $ac_word""... $ac_c" 1>&6
echo "configure:1677: checking for $ac_word" >&5
if eval "test \"`echo '$''{'ac_cv_prog_CC'+set}'`\" = set"; then
  echo $ac_n "(cached) $ac_c" 1>&6
else
  if test -n "$CC"; then
  ac_cv_prog_CC="$CC" # Let the user override the test.
else
  IFS="${IFS= 	}"; ac_save_ifs="$IFS"; IFS="${IFS}:"
  for ac_dir in $PATH; do
    test -z "$ac_dir" && ac_dir=.
    if test -f $ac_dir/$ac_word; then
      ac_cv_prog_CC="gcc"
      break
    fi
  done
  IFS="$ac_save_ifs"
fi
fi
CC="$ac_cv_prog_CC"
if test -n "$CC"; then
  echo "$ac_t""$CC" 1>&6
else
  echo "$ac_t""no" 1>&6
fi

if test -z "$CC"; then
  # Extract the first word of "cc", so it can be a program name with args.
set dummy cc; ac_word=$2
echo $ac_n "checking for $ac_word""... $ac_c" 1>&6
echo "configure:1706: checking for $ac_word" >&5
if eval "test \"`echo '$''{'ac_cv_prog_CC'+set}'`\" = set"; then
  echo $ac_n "(cached) $ac_c" 1>&6
else
  if test -n "$CC"; then
  ac_cv_prog_CC="$CC" # Let the user override the test.
else
  IFS="${IFS= 	}"; ac_save_ifs="$IFS"; IFS="${IFS}:"
  ac_prog_rejected=no
  for ac_dir in $PATH; do
    test -z "$ac_dir" && ac_dir=.
    if test -f $ac_dir/$ac_word; then
      if test "$ac_dir/$ac_word" = "/usr/ucb/cc"; then
        ac_prog_rejected=yes
	continue
      fi
      ac_cv_prog_CC="cc"
      break
    fi
  done
  IFS="$ac_save_ifs"
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_CC
  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 CC to just the basename; use the full file name.
    shift
    set dummy "$ac_dir/$ac_word" "$@"
    shift
    ac_cv_prog_CC="$@"
  fi
fi
fi
fi
CC="$ac_cv_prog_CC"
if test -n "$CC"; then
  echo "$ac_t""$CC" 1>&6
else
  echo "$ac_t""no" 1>&6
fi

  test -z "$CC" && { echo "configure: error: no acceptable cc found in \$PATH" 1>&2; exit 1; }
fi

echo $ac_n "checking whether the C compiler ($CC $CFLAGS $LDFLAGS) works""... $ac_c" 1>&6
echo "configure:1754: checking whether the C compiler ($CC $CFLAGS $LDFLAGS) works" >&5

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>&5'
ac_link='${CC-cc} -o conftest $CFLAGS $CPPFLAGS $LDFLAGS conftest.$ac_ext $LIBS 1>&5'
cross_compiling=$ac_cv_prog_cc_cross

cat > conftest.$ac_ext <<EOF
#line 1764 "configure"
#include "confdefs.h"
main(){return(0);}
EOF
if { (eval echo configure:1768: \"$ac_link\") 1>&5; (eval $ac_link) 2>&5; } && test -s conftest; then
  ac_cv_prog_cc_works=yes
  # If we can't run a trivial program, we are probably using a cross compiler.
  if (./conftest; exit) 2>/dev/null; then
    ac_cv_prog_cc_cross=no
  else
    ac_cv_prog_cc_cross=yes
  fi
else
  echo "configure: failed program was:" >&5
  cat conftest.$ac_ext >&5
  ac_cv_prog_cc_works=no
fi
rm -fr conftest*

echo "$ac_t""$ac_cv_prog_cc_works" 1>&6
if test $ac_cv_prog_cc_works = no; then
  { echo "configure: error: installation or configuration problem: C compiler cannot create executables." 1>&2; exit 1; }
fi
echo $ac_n "checking whether the C compiler ($CC $CFLAGS $LDFLAGS) is a cross-compiler""... $ac_c" 1>&6
echo "configure:1788: checking whether the C compiler ($CC $CFLAGS $LDFLAGS) is a cross-compiler" >&5
echo "$ac_t""$ac_cv_prog_cc_cross" 1>&6
cross_compiling=$ac_cv_prog_cc_cross

echo $ac_n "checking whether we are using GNU C""... $ac_c" 1>&6
echo "configure:1793: checking whether we are using GNU C" >&5
if eval "test \"`echo '$''{'ac_cv_prog_gcc'+set}'`\" = set"; then
  echo $ac_n "(cached) $ac_c" 1>&6
else
  cat > conftest.c <<EOF
#ifdef __GNUC__
  yes;
#endif
EOF
if { ac_try='${CC-cc} -E conftest.c'; { (eval echo configure:1802: \"$ac_try\") 1>&5; (eval $ac_try) 2>&5; }; } | egrep yes >/dev/null 2>&1; then
  ac_cv_prog_gcc=yes
else
  ac_cv_prog_gcc=no
fi
fi

echo "$ac_t""$ac_cv_prog_gcc" 1>&6

if test $ac_cv_prog_gcc = yes; then
  GCC=yes
  ac_test_CFLAGS="${CFLAGS+set}"
  ac_save_CFLAGS="$CFLAGS"
  CFLAGS=
  echo $ac_n "checking whether ${CC-cc} accepts -g""... $ac_c" 1>&6
echo "configure:1817: checking whether ${CC-cc} accepts -g" >&5
if eval "test \"`echo '$''{'ac_cv_prog_cc_g'+set}'`\" = set"; then
  echo $ac_n "(cached) $ac_c" 1>&6
else
  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*

fi

echo "$ac_t""$ac_cv_prog_cc_g" 1>&6
  if test "$ac_test_CFLAGS" = set; then
    CFLAGS="$ac_save_CFLAGS"
  elif test $ac_cv_prog_cc_g = yes; then
    CFLAGS="-g -O2"
  else
    CFLAGS="-O2"
  fi
else
  GCC=
  test "${CFLAGS+set}" = set || CFLAGS="-g"
fi

# Check whether --with-gnu-ld or --without-gnu-ld was given.
if test "${with_gnu_ld+set}" = set; then
  withval="$with_gnu_ld"
  test "$withval" = no || with_gnu_ld=yes
else
  with_gnu_ld=no
fi


ac_prog=ld
if test "$ac_cv_prog_gcc" = yes; then
  # Check if gcc -print-prog-name=ld gives a path.
  echo $ac_n "checking for ld used by GCC""... $ac_c" 1>&6
echo "configure:1857: checking for ld used by GCC" >&5
  ac_prog=`($CC -print-prog-name=ld) 2>&5`
  case "$ac_prog" in
  # Accept absolute paths.
  /* | A-Za-z:\\*)
    test -z "$LD" && LD="$ac_prog"
    ;;
  "")
    # If it fails, then pretend we aren't using GCC.
    ac_prog=ld
    ;;
  *)
    # If it is relative, then search for the first ld in PATH.
    with_gnu_ld=unknown
    ;;
  esac
elif test "$with_gnu_ld" = yes; then
  echo $ac_n "checking for GNU ld""... $ac_c" 1>&6
echo "configure:1875: checking for GNU ld" >&5
else
  echo $ac_n "checking for non-GNU ld""... $ac_c" 1>&6
echo "configure:1878: checking for non-GNU ld" >&5
fi
if eval "test \"`echo '$''{'ac_cv_path_LD'+set}'`\" = set"; then
  echo $ac_n "(cached) $ac_c" 1>&6
else
  if test -z "$LD"; then
  IFS="${IFS= 	}"; ac_save_ifs="$IFS"; IFS="${IFS}:"
  for ac_dir in $PATH; do
    test -z "$ac_dir" && ac_dir=.
    if test -f "$ac_dir/$ac_prog"; then
      ac_cv_path_LD="$ac_dir/$ac_prog"
      # Check to see if the program is GNU ld.  I'd rather use --version,
      # but apparently some GNU ld's only accept -v.
      # Break only if it was the GNU/non-GNU ld that we prefer.
      if "$ac_cv_path_LD" -v 2>&1 < /dev/null | egrep '(GNU|with BFD)' > /dev/null; then
	test "$with_gnu_ld" != no && break
      else
        test "$with_gnu_ld" != yes && break
      fi
    fi
  done
  IFS="$ac_save_ifs"
else
  ac_cv_path_LD="$LD" # Let the user override the test with a path.
fi
fi

LD="$ac_cv_path_LD"
if test -n "$LD"; then
  echo "$ac_t""$LD" 1>&6
else
  echo "$ac_t""no" 1>&6
fi
test -z "$LD" && { echo "configure: error: no acceptable ld found in \$PATH" 1>&2; exit 1; }

echo $ac_n "checking if the linker ($LD) is GNU ld""... $ac_c" 1>&6
echo "configure:1914: checking if the linker ($LD) is GNU ld" >&5
if eval "test \"`echo '$''{'ac_cv_prog_gnu_ld'+set}'`\" = set"; then
  echo $ac_n "(cached) $ac_c" 1>&6
else
  # I'd rather use --version here, but apparently some GNU ld's only accept -v.
if $LD -v 2>&1 </dev/null | egrep '(GNU|with BFD)' 1>&5; then
  ac_cv_prog_gnu_ld=yes
else
  ac_cv_prog_gnu_ld=no
fi
fi

echo "$ac_t""$ac_cv_prog_gnu_ld" 1>&6


echo $ac_n "checking for BSD-compatible nm""... $ac_c" 1>&6
echo "configure:1930: checking for BSD-compatible nm" >&5
if eval "test \"`echo '$''{'ac_cv_path_NM'+set}'`\" = set"; then
  echo $ac_n "(cached) $ac_c" 1>&6
else
  case "$NM" in
/* | A-Za-z:\\*)
  ac_cv_path_NM="$NM" # Let the user override the test with a path.
  ;;
*)
  IFS="${IFS= 	}"; ac_save_ifs="$IFS"; IFS="${IFS}:"
  for ac_dir in /usr/ucb /usr/ccs/bin $PATH /bin; do
    test -z "$ac_dir" && ac_dir=.
    if test -f $ac_dir/nm; then
      # Check to see if the nm accepts a BSD-compat flag.
      # Adding the `sed 1q' prevents false positives on HP-UX, which says:
      #   nm: unknown option "B" ignored
      if ($ac_dir/nm -B /dev/null 2>&1 | sed '1q'; exit 0) | egrep /dev/null >/dev/null; then
        ac_cv_path_NM="$ac_dir/nm -B"
      elif ($ac_dir/nm -p /dev/null 2>&1 | sed '1q'; exit 0) | egrep /dev/null >/dev/null; then
        ac_cv_path_NM="$ac_dir/nm -p"
      else
        ac_cv_path_NM="$ac_dir/nm"
      fi
      break
    fi
  done
  IFS="$ac_save_ifs"
  test -z "$ac_cv_path_NM" && ac_cv_path_NM=nm
  ;;
esac
fi

NM="$ac_cv_path_NM"
echo "$ac_t""$NM" 1>&6


echo $ac_n "checking whether ln -s works""... $ac_c" 1>&6
echo "configure:1967: checking whether ln -s works" >&5
if eval "test \"`echo '$''{'ac_cv_prog_LN_S'+set}'`\" = set"; then
  echo $ac_n "(cached) $ac_c" 1>&6
else
  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
fi
LN_S="$ac_cv_prog_LN_S"
if test "$ac_cv_prog_LN_S" = "ln -s"; then
  echo "$ac_t""yes" 1>&6
else
  echo "$ac_t""no" 1>&6
fi

# Always use our own libtool.
LIBTOOL='$(SHELL) $(top_builddir)/libtool'

# Check for any special flags to pass to ltconfig.
libtool_flags=
test "$enable_shared" = no && libtool_flags="$libtool_flags --disable-shared"
test "$enable_static" = no && libtool_flags="$libtool_flags --disable-static"
test "$silent" = yes && libtool_flags="$libtool_flags --silent"
test "$ac_cv_prog_gcc" = yes && libtool_flags="$libtool_flags --with-gcc"
test "$ac_cv_prog_gnu_ld" = yes && libtool_flags="$libtool_flags --with-gnu-ld"

# Some flags need to be propagated to the compiler or linker for good
# libtool support.
case "$host" in
*-*-irix6*)