AC_DEFUN([_LT_AC_LOCK],[AC_ARG_ENABLE([libtool-lock],    [AC_HELP_STRING([--disable-libtool-lock],	[avoid locking (might break parallel builds)])])test "x$enable_libtool_lock" != xno && enable_libtool_lock=yes# Some flags need to be propagated to the compiler or linker for good# libtool support.case $host inia64-*-hpux*)  # Find out which ABI we are using.  echo 'int i;' > conftest.$ac_ext  if AC_TRY_EVAL(ac_compile); then    case `/usr/bin/file conftest.$ac_objext` in    *ELF-32*)      HPUX_IA64_MODE="32"      ;;    *ELF-64*)      HPUX_IA64_MODE="64"      ;;    esac  fi  rm -rf conftest*  ;;*-*-irix6*)  # Find out which ABI we are using.  echo '[#]line __oline__ "configure"' > conftest.$ac_ext  if AC_TRY_EVAL(ac_compile); then   if test "$lt_cv_prog_gnu_ld" = yes; then    case `/usr/bin/file conftest.$ac_objext` in    *32-bit*)      LD="${LD-ld} -melf32bsmip"      ;;    *N32*)      LD="${LD-ld} -melf32bmipn32"      ;;    *64-bit*)      LD="${LD-ld} -melf64bmip"      ;;    esac   else    case `/usr/bin/file conftest.$ac_objext` in    *32-bit*)      LD="${LD-ld} -32"      ;;    *N32*)      LD="${LD-ld} -n32"      ;;    *64-bit*)      LD="${LD-ld} -64"      ;;    esac   fi  fi  rm -rf conftest*  ;;x86_64-*kfreebsd*-gnu|x86_64-*linux*|ppc*-*linux*|powerpc*-*linux*| \s390*-*linux*|sparc*-*linux*)  # Find out which ABI we are using.  echo 'int i;' > conftest.$ac_ext  if AC_TRY_EVAL(ac_compile); then    case `/usr/bin/file conftest.o` in    *32-bit*)      case $host in        x86_64-*kfreebsd*-gnu)          LD="${LD-ld} -m elf_i386_fbsd"          ;;        x86_64-*linux*)          LD="${LD-ld} -m elf_i386"          ;;        ppc64-*linux*|powerpc64-*linux*)          LD="${LD-ld} -m elf32ppclinux"          ;;        s390x-*linux*)          LD="${LD-ld} -m elf_s390"          ;;        sparc64-*linux*)          LD="${LD-ld} -m elf32_sparc"          ;;      esac      ;;    *64-bit*)      case $host in        x86_64-*kfreebsd*-gnu)          LD="${LD-ld} -m elf_x86_64_fbsd"          ;;        x86_64-*linux*)          LD="${LD-ld} -m elf_x86_64"          ;;        ppc*-*linux*|powerpc*-*linux*)          LD="${LD-ld} -m elf64ppc"          ;;        s390*-*linux*)          LD="${LD-ld} -m elf64_s390"          ;;        sparc*-*linux*)          LD="${LD-ld} -m elf64_sparc"          ;;      esac      ;;    esac  fi  rm -rf conftest*  ;;*-*-sco3.2v5*)  # On SCO OpenServer 5, we need -belf to get full-featured binaries.  SAVE_CFLAGS="$CFLAGS"  CFLAGS="$CFLAGS -belf"  AC_CACHE_CHECK([whether the C compiler needs -belf], lt_cv_cc_needs_belf,    [AC_LANG_PUSH(C)     AC_TRY_LINK([],[],[lt_cv_cc_needs_belf=yes],[lt_cv_cc_needs_belf=no])     AC_LANG_POP])  if test x"$lt_cv_cc_needs_belf" != x"yes"; then    # this is probably gcc 2.8.0, egcs 1.0 or newer; no need for -belf    CFLAGS="$SAVE_CFLAGS"  fi  ;;sparc*-*solaris*)  # Find out which ABI we are using.  echo 'int i;' > conftest.$ac_ext  if AC_TRY_EVAL(ac_compile); then    case `/usr/bin/file conftest.o` in    *64-bit*)      case $lt_cv_prog_gnu_ld in      yes*) LD="${LD-ld} -m elf64_sparc" ;;      *)        if ${LD-ld} -64 -r -o conftest2.o conftest.o >/dev/null 2>&1; then	  LD="${LD-ld} -64"	fi	;;      esac      ;;    esac  fi  rm -rf conftest*  ;;AC_PROVIDE_IFELSE([AC_LIBTOOL_WIN32_DLL],[*-*-cygwin* | *-*-mingw* | *-*-pw32*)  AC_CHECK_TOOL(DLLTOOL, dlltool, false)  AC_CHECK_TOOL(AS, as, false)  AC_CHECK_TOOL(OBJDUMP, objdump, false)  ;;  ])esacneed_locks="$enable_libtool_lock"])# _LT_AC_LOCK# AC_LIBTOOL_COMPILER_OPTION(MESSAGE, VARIABLE-NAME, FLAGS,#		[OUTPUT-FILE], [ACTION-SUCCESS], [ACTION-FAILURE])# ----------------------------------------------------------------# Check whether the given compiler option worksAC_DEFUN([AC_LIBTOOL_COMPILER_OPTION],[AC_REQUIRE([LT_AC_PROG_SED])AC_CACHE_CHECK([$1], [$2],  [$2=no  ifelse([$4], , [ac_outfile=conftest.$ac_objext], [ac_outfile=$4])   echo "$lt_simple_compile_test_code" > conftest.$ac_ext   lt_compiler_flag="$3"   # Insert the option either (1) after the last *FLAGS variable, or   # (2) before a word containing "conftest.", or (3) at the end.   # Note that $ac_compile itself does not contain backslashes and begins   # with a dollar sign (not a hyphen), so the echo should work correctly.   # The option is referenced via a variable to avoid confusing sed.   lt_compile=`echo "$ac_compile" | $SED \   -e 's:.*FLAGS}\{0,1\} :&$lt_compiler_flag :; t' \   -e 's: [[^ ]]*conftest\.: $lt_compiler_flag&:; t' \   -e 's:$: $lt_compiler_flag:'`   (eval echo "\"\$as_me:__oline__: $lt_compile\"" >&AS_MESSAGE_LOG_FD)   (eval "$lt_compile" 2>conftest.err)   ac_status=$?   cat conftest.err >&AS_MESSAGE_LOG_FD   echo "$as_me:__oline__: \$? = $ac_status" >&AS_MESSAGE_LOG_FD   if (exit $ac_status) && test -s "$ac_outfile"; then     # The compiler can only warn and ignore the option if not recognized     # So say no if there are warnings other than the usual output.     $echo "X$_lt_compiler_boilerplate" | $Xsed -e '/^$/d' >conftest.exp     $SED '/^$/d; /^ *+/d' conftest.err >conftest.er2     if test ! -s conftest.er2 || diff conftest.exp conftest.er2 >/dev/null; then       $2=yes     fi   fi   $rm conftest*])if test x"[$]$2" = xyes; then    ifelse([$5], , :, [$5])else    ifelse([$6], , :, [$6])fi])# AC_LIBTOOL_COMPILER_OPTION# AC_LIBTOOL_LINKER_OPTION(MESSAGE, VARIABLE-NAME, FLAGS,#                          [ACTION-SUCCESS], [ACTION-FAILURE])# ------------------------------------------------------------# Check whether the given compiler option worksAC_DEFUN([AC_LIBTOOL_LINKER_OPTION],[AC_REQUIRE([LT_AC_PROG_SED])dnlAC_CACHE_CHECK([$1], [$2],  [$2=no   save_LDFLAGS="$LDFLAGS"   LDFLAGS="$LDFLAGS $3"   echo "$lt_simple_link_test_code" > conftest.$ac_ext   if (eval $ac_link 2>conftest.err) && test -s conftest$ac_exeext; then     # The linker can only warn and ignore the option if not recognized     # So say no if there are warnings     if test -s conftest.err; then       # Append any errors to the config.log.       cat conftest.err 1>&AS_MESSAGE_LOG_FD       $echo "X$_lt_linker_boilerplate" | $Xsed -e '/^$/d' > conftest.exp       $SED '/^$/d; /^ *+/d' conftest.err >conftest.er2       if diff conftest.exp conftest.er2 >/dev/null; then         $2=yes       fi     else       $2=yes     fi   fi   $rm -r conftest*   LDFLAGS="$save_LDFLAGS"])if test x"[$]$2" = xyes; then    ifelse([$4], , :, [$4])else    ifelse([$5], , :, [$5])fi])# AC_LIBTOOL_LINKER_OPTION# AC_LIBTOOL_SYS_MAX_CMD_LEN# --------------------------AC_DEFUN([AC_LIBTOOL_SYS_MAX_CMD_LEN],[# find the maximum length of command line argumentsAC_MSG_CHECKING([the maximum length of command line arguments])AC_CACHE_VAL([lt_cv_sys_max_cmd_len], [dnl  i=0  teststring="ABCD"  case $build_os in  msdosdjgpp*)    # On DJGPP, this test can blow up pretty badly due to problems in libc    # (any single argument exceeding 2000 bytes causes a buffer overrun    # during glob expansion).  Even if it were fixed, the result of this    # check would be larger than it should be.    lt_cv_sys_max_cmd_len=12288;    # 12K is about right    ;;  gnu*)    # Under GNU Hurd, this test is not required because there is    # no limit to the length of command line arguments.    # Libtool will interpret -1 as no limit whatsoever    lt_cv_sys_max_cmd_len=-1;    ;;  cygwin* | mingw*)    # On Win9x/ME, this test blows up -- it succeeds, but takes    # about 5 minutes as the teststring grows exponentially.    # Worse, since 9x/ME are not pre-emptively multitasking,    # you end up with a "frozen" computer, even though with patience    # the test eventually succeeds (with a max line length of 256k).    # Instead, let's just punt: use the minimum linelength reported by    # all of the supported platforms: 8192 (on NT/2K/XP).    lt_cv_sys_max_cmd_len=8192;    ;;  amigaos*)    # On AmigaOS with pdksh, this test takes hours, literally.    # So we just punt and use a minimum line length of 8192.    lt_cv_sys_max_cmd_len=8192;    ;;  netbsd* | freebsd* | openbsd* | darwin* | dragonfly*)    # This has been around since 386BSD, at least.  Likely further.    if test -x /sbin/sysctl; then      lt_cv_sys_max_cmd_len=`/sbin/sysctl -n kern.argmax`    elif test -x /usr/sbin/sysctl; then      lt_cv_sys_max_cmd_len=`/usr/sbin/sysctl -n kern.argmax`    else      lt_cv_sys_max_cmd_len=65536	# usable default for all BSDs    fi    # And add a safety zone    lt_cv_sys_max_cmd_len=`expr $lt_cv_sys_max_cmd_len \/ 4`    lt_cv_sys_max_cmd_len=`expr $lt_cv_sys_max_cmd_len \* 3`    ;;  interix*)    # We know the value 262144 and hardcode it with a safety zone (like BSD)    lt_cv_sys_max_cmd_len=196608    ;;  osf*)    # Dr. Hans Ekkehard Plesser reports seeing a kernel panic running configure    # due to this test when exec_disable_arg_limit is 1 on Tru64. It is not    # nice to cause kernel panics so lets avoid the loop below.    # First set a reasonable default.    lt_cv_sys_max_cmd_len=16384    #    if test -x /sbin/sysconfig; then      case `/sbin/sysconfig -q proc exec_disable_arg_limit` in        *1*) lt_cv_sys_max_cmd_len=-1 ;;      esac    fi    ;;  sco3.2v5*)    lt_cv_sys_max_cmd_len=102400    ;;  sysv5* | sco5v6* | sysv4.2uw2*)    kargmax=`grep ARG_MAX /etc/conf/cf.d/stune 2>/dev/null`    if test -n "$kargmax"; then      lt_cv_sys_max_cmd_len=`echo $kargmax | sed 's/.*[[ 	]]//'`    else      lt_cv_sys_max_cmd_len=32768    fi    ;;  *)    lt_cv_sys_max_cmd_len=`(getconf ARG_MAX) 2> /dev/null`    if test -n "$lt_cv_sys_max_cmd_len"; then      lt_cv_sys_max_cmd_len=`expr $lt_cv_sys_max_cmd_len \/ 4`      lt_cv_sys_max_cmd_len=`expr $lt_cv_sys_max_cmd_len \* 3`    else      SHELL=${SHELL-${CONFIG_SHELL-/bin/sh}}      while (test "X"`$SHELL [$]0 --fallback-echo "X$teststring" 2>/dev/null` \	       = "XX$teststring") >/dev/null 2>&1 &&	      new_result=`expr "X$teststring" : ".*" 2>&1` &&	      lt_cv_sys_max_cmd_len=$new_result &&	      test $i != 17 # 1/2 MB should be enough      do        i=`expr $i + 1`        teststring=$teststring$teststring      done      teststring=      # Add a significant safety factor because C++ compilers can tack on massive      # amounts of additional arguments before passing them to the linker.      # It appears as though 1/2 is a usable value.      lt_cv_sys_max_cmd_len=`expr $lt_cv_sys_max_cmd_len \/ 2`    fi    ;;  esac])if test -n $lt_cv_sys_max_cmd_len ; then  AC_MSG_RESULT($lt_cv_sys_max_cmd_len)else  AC_MSG_RESULT(none)fi])# AC_LIBTOOL_SYS_MAX_CMD_LEN# _LT_AC_CHECK_DLFCN# ------------------AC_DEFUN([_LT_AC_CHECK_DLFCN],[AC_CHECK_HEADERS(dlfcn.h)dnl])# _LT_AC_CHECK_DLFCN# _LT_AC_TRY_DLOPEN_SELF (ACTION-IF-TRUE, ACTION-IF-TRUE-W-USCORE,#                           ACTION-IF-FALSE, ACTION-IF-CROSS-COMPILING)# ---------------------------------------------------------------------AC_DEFUN([_LT_AC_TRY_DLOPEN_SELF],[AC_REQUIRE([_LT_AC_CHECK_DLFCN])dnlif test "$cross_compiling" = yes; then :  [$4]else  lt_dlunknown=0; lt_dlno_uscore=1; lt_dlneed_uscore=2  lt_status=$lt_dlunknown  cat > conftest.$ac_ext <<EOF[#line __oline__ "configure"#include "confdefs.h"#if HAVE_DLFCN_H#include <dlfcn.h>#endif#include <stdio.h>#ifdef RTLD_GLOBAL#  define LT_DLGLOBAL		RTLD_GLOBAL#else#  ifdef DL_GLOBAL#    define LT_DLGLOBAL		DL_GLOBAL#  else#    define LT_DLGLOBAL		0#  endif#endif/* We may have to define LT_DLLAZY_OR_NOW in the command line if we   find out it does not work in some platform. */#ifndef LT_DLLAZY_OR_NOW#  ifdef RTLD_LAZY#    define LT_DLLAZY_OR_NOW		RTLD_LAZY#  else#    ifdef DL_LAZY#      define LT_DLLAZY_OR_NOW		DL_LAZY#    else#      ifdef RTLD_NOW#        define LT_DLLAZY_OR_NOW	RTLD_NOW#      else