~ubuntu-branches/ubuntu/quantal/memcached/quantal

« back to all changes in this revision

Viewing changes to configure

  • Committer: Bazaar Package Importer
  • Author(s): David Martínez Moreno
  • Date: 2009-10-16 15:09:43 UTC
  • mfrom: (1.1.6 upstream) (3.1.7 sid)
  • Revision ID: james.westby@ubuntu.com-20091016150943-0rhh8x206ebgwzeu
Tags: 1.4.2-1
* New upstream release, primarily bugfixes, some of them critical, hence
  the urgency:
  - Reject keys larger than 250 bytes in the binary protocol.
  - Bounds checking on stats cachedump.
  - Binary protocol set+cas wasn't returning a new cas ID.
  - Binary quitq didn't actually close the connection
  - Slab boundary checking cleanup (bad logic in unreachable code)
  - Get hit memory optimizations
  - Disallow -t options that cause the server to not work
  - Killed off incomplete slab rebalance feature.
* debian/patches:
  - 01_init_script_compliant_with_LSB.patch: Remade as upstream applied a
    whitespace cleanup script that broke the patch.
  - 02_manpage_additions.patch: Added missing parameters to the memcached
    manpage.
* Removed TODO from debian/docs.

Show diffs side-by-side

added added

removed removed

Lines of Context:
1
1
#! /bin/sh
2
2
# Guess values for system-dependent variables and create Makefiles.
3
 
# Generated by GNU Autoconf 2.63 for memcached 1.2.8.
 
3
# Generated by GNU Autoconf 2.63 for memcached 1.4.2.
4
4
#
5
5
# Report bugs to <brad@danga.com>.
6
6
#
596
596
# Identity of this package.
597
597
PACKAGE_NAME='memcached'
598
598
PACKAGE_TARNAME='memcached'
599
 
PACKAGE_VERSION='1.2.8'
600
 
PACKAGE_STRING='memcached 1.2.8'
 
599
PACKAGE_VERSION='1.4.2'
 
600
PACKAGE_STRING='memcached 1.4.2'
601
601
PACKAGE_BUGREPORT='brad@danga.com'
602
602
 
603
603
ac_unique_file="memcached.c"
639
639
 
640
640
ac_subst_vars='LTLIBOBJS
641
641
LIBOBJS
 
642
BUILD_SPECIFICATIONS_FALSE
 
643
BUILD_SPECIFICATIONS_TRUE
 
644
XSLTPROC
 
645
XML2RFC
 
646
BUILD_CACHE_FALSE
 
647
BUILD_CACHE_TRUE
 
648
BUILD_SOLARIS_PRIVS_FALSE
 
649
BUILD_SOLARIS_PRIVS_TRUE
 
650
PROFILER_FLAGS
 
651
PROFILER
 
652
PROFILER_LDFLAGS
 
653
DTRACEFLAGS
 
654
DTRACE_INSTRUMENT_OBJ_FALSE
 
655
DTRACE_INSTRUMENT_OBJ_TRUE
 
656
BUILD_DTRACE_FALSE
 
657
BUILD_DTRACE_TRUE
 
658
DTRACE
642
659
EGREP
643
660
GREP
644
661
CPP
645
 
DAEMON_OBJ
646
 
DTRACEFLAGS
647
 
DTRACE_DEBUG_OBJ
648
 
DTRACE_OBJ
649
 
DTRACE
650
662
am__fastdepCC_FALSE
651
663
am__fastdepCC_TRUE
652
664
CCDEPMODE
740
752
enable_option_checking
741
753
enable_dependency_tracking
742
754
enable_dtrace
 
755
enable_coverage
743
756
enable_64bit
744
757
with_libevent
745
 
enable_threads
 
758
enable_docs
746
759
'
747
760
      ac_precious_vars='build_alias
748
761
host_alias
1305
1318
  # Omit some internal or obsolete options to make the list less imposing.
1306
1319
  # This message is too long to be a string in the A/UX 3.1 sh.
1307
1320
  cat <<_ACEOF
1308
 
\`configure' configures memcached 1.2.8 to adapt to many kinds of systems.
 
1321
\`configure' configures memcached 1.4.2 to adapt to many kinds of systems.
1309
1322
 
1310
1323
Usage: $0 [OPTION]... [VAR=VALUE]...
1311
1324
 
1376
1389
 
1377
1390
if test -n "$ac_init_help"; then
1378
1391
  case $ac_init_help in
1379
 
     short | recursive ) echo "Configuration of memcached 1.2.8:";;
 
1392
     short | recursive ) echo "Configuration of memcached 1.4.2:";;
1380
1393
   esac
1381
1394
  cat <<\_ACEOF
1382
1395
 
1387
1400
  --disable-dependency-tracking  speeds up one-time build
1388
1401
  --enable-dependency-tracking   do not reject slow dependency extractors
1389
1402
  --enable-dtrace         Enable dtrace probes
 
1403
  --disable-coverage      Disable code coverage
1390
1404
  --enable-64bit          build 64bit version
1391
 
  --enable-threads        support multithreaded execution
 
1405
  --disable-docs          Disable documentation generation
1392
1406
 
1393
1407
Optional Packages:
1394
1408
  --with-PACKAGE[=ARG]    use PACKAGE [ARG=yes]
1471
1485
test -n "$ac_init_help" && exit $ac_status
1472
1486
if $ac_init_version; then
1473
1487
  cat <<\_ACEOF
1474
 
memcached configure 1.2.8
 
1488
memcached configure 1.4.2
1475
1489
generated by GNU Autoconf 2.63
1476
1490
 
1477
1491
Copyright (C) 1992, 1993, 1994, 1995, 1996, 1998, 1999, 2000, 2001,
1485
1499
This file contains any messages produced by compilers while
1486
1500
running configure, to aid debugging if configure makes a mistake.
1487
1501
 
1488
 
It was created by memcached $as_me 1.2.8, which was
 
1502
It was created by memcached $as_me 1.4.2, which was
1489
1503
generated by GNU Autoconf 2.63.  Invocation command line was
1490
1504
 
1491
1505
  $ $0 $@
2328
2342
 
2329
2343
# Define the identity of the package.
2330
2344
 PACKAGE=memcached
2331
 
 VERSION=1.2.8
 
2345
 VERSION=1.4.2
2332
2346
 
2333
2347
 
2334
2348
cat >>confdefs.h <<_ACEOF
3576
3590
fi
3577
3591
 
3578
3592
 
 
3593
 
 
3594
 
 
3595
 
 
3596
 
 
3597
ac_ext=c
 
3598
ac_cpp='$CPP $CPPFLAGS'
 
3599
ac_compile='$CC -c $CFLAGS $CPPFLAGS conftest.$ac_ext >&5'
 
3600
ac_link='$CC -o conftest$ac_exeext $CFLAGS $CPPFLAGS $LDFLAGS conftest.$ac_ext $LIBS >&5'
 
3601
ac_compiler_gnu=$ac_cv_c_compiler_gnu
 
3602
{ $as_echo "$as_me:$LINENO: checking how to run the C preprocessor" >&5
 
3603
$as_echo_n "checking how to run the C preprocessor... " >&6; }
 
3604
# On Suns, sometimes $CPP names a directory.
 
3605
if test -n "$CPP" && test -d "$CPP"; then
 
3606
  CPP=
 
3607
fi
 
3608
if test -z "$CPP"; then
 
3609
  if test "${ac_cv_prog_CPP+set}" = set; then
 
3610
  $as_echo_n "(cached) " >&6
 
3611
else
 
3612
      # Double quotes because CPP needs to be expanded
 
3613
    for CPP in "$CC -E" "$CC -E -traditional-cpp" "/lib/cpp"
 
3614
    do
 
3615
      ac_preproc_ok=false
 
3616
for ac_c_preproc_warn_flag in '' yes
 
3617
do
 
3618
  # Use a header file that comes with gcc, so configuring glibc
 
3619
  # with a fresh cross-compiler works.
 
3620
  # Prefer <limits.h> to <assert.h> if __STDC__ is defined, since
 
3621
  # <limits.h> exists even on freestanding compilers.
 
3622
  # On the NeXT, cc -E runs the code through the compiler's parser,
 
3623
  # not just through cpp. "Syntax error" is here to catch this case.
 
3624
  cat >conftest.$ac_ext <<_ACEOF
 
3625
/* confdefs.h.  */
 
3626
_ACEOF
 
3627
cat confdefs.h >>conftest.$ac_ext
 
3628
cat >>conftest.$ac_ext <<_ACEOF
 
3629
/* end confdefs.h.  */
 
3630
#ifdef __STDC__
 
3631
# include <limits.h>
 
3632
#else
 
3633
# include <assert.h>
 
3634
#endif
 
3635
                     Syntax error
 
3636
_ACEOF
 
3637
if { (ac_try="$ac_cpp conftest.$ac_ext"
 
3638
case "(($ac_try" in
 
3639
  *\"* | *\`* | *\\*) ac_try_echo=\$ac_try;;
 
3640
  *) ac_try_echo=$ac_try;;
 
3641
esac
 
3642
eval ac_try_echo="\"\$as_me:$LINENO: $ac_try_echo\""
 
3643
$as_echo "$ac_try_echo") >&5
 
3644
  (eval "$ac_cpp conftest.$ac_ext") 2>conftest.er1
 
3645
  ac_status=$?
 
3646
  grep -v '^ *+' conftest.er1 >conftest.err
 
3647
  rm -f conftest.er1
 
3648
  cat conftest.err >&5
 
3649
  $as_echo "$as_me:$LINENO: \$? = $ac_status" >&5
 
3650
  (exit $ac_status); } >/dev/null && {
 
3651
         test -z "$ac_c_preproc_warn_flag$ac_c_werror_flag" ||
 
3652
         test ! -s conftest.err
 
3653
       }; then
 
3654
  :
 
3655
else
 
3656
  $as_echo "$as_me: failed program was:" >&5
 
3657
sed 's/^/| /' conftest.$ac_ext >&5
 
3658
 
 
3659
  # Broken: fails on valid input.
 
3660
continue
 
3661
fi
 
3662
 
 
3663
rm -f conftest.err conftest.$ac_ext
 
3664
 
 
3665
  # OK, works on sane cases.  Now check whether nonexistent headers
 
3666
  # can be detected and how.
 
3667
  cat >conftest.$ac_ext <<_ACEOF
 
3668
/* confdefs.h.  */
 
3669
_ACEOF
 
3670
cat confdefs.h >>conftest.$ac_ext
 
3671
cat >>conftest.$ac_ext <<_ACEOF
 
3672
/* end confdefs.h.  */
 
3673
#include <ac_nonexistent.h>
 
3674
_ACEOF
 
3675
if { (ac_try="$ac_cpp conftest.$ac_ext"
 
3676
case "(($ac_try" in
 
3677
  *\"* | *\`* | *\\*) ac_try_echo=\$ac_try;;
 
3678
  *) ac_try_echo=$ac_try;;
 
3679
esac
 
3680
eval ac_try_echo="\"\$as_me:$LINENO: $ac_try_echo\""
 
3681
$as_echo "$ac_try_echo") >&5
 
3682
  (eval "$ac_cpp conftest.$ac_ext") 2>conftest.er1
 
3683
  ac_status=$?
 
3684
  grep -v '^ *+' conftest.er1 >conftest.err
 
3685
  rm -f conftest.er1
 
3686
  cat conftest.err >&5
 
3687
  $as_echo "$as_me:$LINENO: \$? = $ac_status" >&5
 
3688
  (exit $ac_status); } >/dev/null && {
 
3689
         test -z "$ac_c_preproc_warn_flag$ac_c_werror_flag" ||
 
3690
         test ! -s conftest.err
 
3691
       }; then
 
3692
  # Broken: success on invalid input.
 
3693
continue
 
3694
else
 
3695
  $as_echo "$as_me: failed program was:" >&5
 
3696
sed 's/^/| /' conftest.$ac_ext >&5
 
3697
 
 
3698
  # Passes both tests.
 
3699
ac_preproc_ok=:
 
3700
break
 
3701
fi
 
3702
 
 
3703
rm -f conftest.err conftest.$ac_ext
 
3704
 
 
3705
done
 
3706
# Because of `break', _AC_PREPROC_IFELSE's cleaning code was skipped.
 
3707
rm -f conftest.err conftest.$ac_ext
 
3708
if $ac_preproc_ok; then
 
3709
  break
 
3710
fi
 
3711
 
 
3712
    done
 
3713
    ac_cv_prog_CPP=$CPP
 
3714
 
 
3715
fi
 
3716
  CPP=$ac_cv_prog_CPP
 
3717
else
 
3718
  ac_cv_prog_CPP=$CPP
 
3719
fi
 
3720
{ $as_echo "$as_me:$LINENO: result: $CPP" >&5
 
3721
$as_echo "$CPP" >&6; }
 
3722
ac_preproc_ok=false
 
3723
for ac_c_preproc_warn_flag in '' yes
 
3724
do
 
3725
  # Use a header file that comes with gcc, so configuring glibc
 
3726
  # with a fresh cross-compiler works.
 
3727
  # Prefer <limits.h> to <assert.h> if __STDC__ is defined, since
 
3728
  # <limits.h> exists even on freestanding compilers.
 
3729
  # On the NeXT, cc -E runs the code through the compiler's parser,
 
3730
  # not just through cpp. "Syntax error" is here to catch this case.
 
3731
  cat >conftest.$ac_ext <<_ACEOF
 
3732
/* confdefs.h.  */
 
3733
_ACEOF
 
3734
cat confdefs.h >>conftest.$ac_ext
 
3735
cat >>conftest.$ac_ext <<_ACEOF
 
3736
/* end confdefs.h.  */
 
3737
#ifdef __STDC__
 
3738
# include <limits.h>
 
3739
#else
 
3740
# include <assert.h>
 
3741
#endif
 
3742
                     Syntax error
 
3743
_ACEOF
 
3744
if { (ac_try="$ac_cpp conftest.$ac_ext"
 
3745
case "(($ac_try" in
 
3746
  *\"* | *\`* | *\\*) ac_try_echo=\$ac_try;;
 
3747
  *) ac_try_echo=$ac_try;;
 
3748
esac
 
3749
eval ac_try_echo="\"\$as_me:$LINENO: $ac_try_echo\""
 
3750
$as_echo "$ac_try_echo") >&5
 
3751
  (eval "$ac_cpp conftest.$ac_ext") 2>conftest.er1
 
3752
  ac_status=$?
 
3753
  grep -v '^ *+' conftest.er1 >conftest.err
 
3754
  rm -f conftest.er1
 
3755
  cat conftest.err >&5
 
3756
  $as_echo "$as_me:$LINENO: \$? = $ac_status" >&5
 
3757
  (exit $ac_status); } >/dev/null && {
 
3758
         test -z "$ac_c_preproc_warn_flag$ac_c_werror_flag" ||
 
3759
         test ! -s conftest.err
 
3760
       }; then
 
3761
  :
 
3762
else
 
3763
  $as_echo "$as_me: failed program was:" >&5
 
3764
sed 's/^/| /' conftest.$ac_ext >&5
 
3765
 
 
3766
  # Broken: fails on valid input.
 
3767
continue
 
3768
fi
 
3769
 
 
3770
rm -f conftest.err conftest.$ac_ext
 
3771
 
 
3772
  # OK, works on sane cases.  Now check whether nonexistent headers
 
3773
  # can be detected and how.
 
3774
  cat >conftest.$ac_ext <<_ACEOF
 
3775
/* confdefs.h.  */
 
3776
_ACEOF
 
3777
cat confdefs.h >>conftest.$ac_ext
 
3778
cat >>conftest.$ac_ext <<_ACEOF
 
3779
/* end confdefs.h.  */
 
3780
#include <ac_nonexistent.h>
 
3781
_ACEOF
 
3782
if { (ac_try="$ac_cpp conftest.$ac_ext"
 
3783
case "(($ac_try" in
 
3784
  *\"* | *\`* | *\\*) ac_try_echo=\$ac_try;;
 
3785
  *) ac_try_echo=$ac_try;;
 
3786
esac
 
3787
eval ac_try_echo="\"\$as_me:$LINENO: $ac_try_echo\""
 
3788
$as_echo "$ac_try_echo") >&5
 
3789
  (eval "$ac_cpp conftest.$ac_ext") 2>conftest.er1
 
3790
  ac_status=$?
 
3791
  grep -v '^ *+' conftest.er1 >conftest.err
 
3792
  rm -f conftest.er1
 
3793
  cat conftest.err >&5
 
3794
  $as_echo "$as_me:$LINENO: \$? = $ac_status" >&5
 
3795
  (exit $ac_status); } >/dev/null && {
 
3796
         test -z "$ac_c_preproc_warn_flag$ac_c_werror_flag" ||
 
3797
         test ! -s conftest.err
 
3798
       }; then
 
3799
  # Broken: success on invalid input.
 
3800
continue
 
3801
else
 
3802
  $as_echo "$as_me: failed program was:" >&5
 
3803
sed 's/^/| /' conftest.$ac_ext >&5
 
3804
 
 
3805
  # Passes both tests.
 
3806
ac_preproc_ok=:
 
3807
break
 
3808
fi
 
3809
 
 
3810
rm -f conftest.err conftest.$ac_ext
 
3811
 
 
3812
done
 
3813
# Because of `break', _AC_PREPROC_IFELSE's cleaning code was skipped.
 
3814
rm -f conftest.err conftest.$ac_ext
 
3815
if $ac_preproc_ok; then
 
3816
  :
 
3817
else
 
3818
  { { $as_echo "$as_me:$LINENO: error: in \`$ac_pwd':" >&5
 
3819
$as_echo "$as_me: error: in \`$ac_pwd':" >&2;}
 
3820
{ { $as_echo "$as_me:$LINENO: error: C preprocessor \"$CPP\" fails sanity check
 
3821
See \`config.log' for more details." >&5
 
3822
$as_echo "$as_me: error: C preprocessor \"$CPP\" fails sanity check
 
3823
See \`config.log' for more details." >&2;}
 
3824
   { (exit 1); exit 1; }; }; }
 
3825
fi
 
3826
 
 
3827
ac_ext=c
 
3828
ac_cpp='$CPP $CPPFLAGS'
 
3829
ac_compile='$CC -c $CFLAGS $CPPFLAGS conftest.$ac_ext >&5'
 
3830
ac_link='$CC -o conftest$ac_exeext $CFLAGS $CPPFLAGS $LDFLAGS conftest.$ac_ext $LIBS >&5'
 
3831
ac_compiler_gnu=$ac_cv_c_compiler_gnu
 
3832
 
 
3833
 
 
3834
{ $as_echo "$as_me:$LINENO: checking for grep that handles long lines and -e" >&5
 
3835
$as_echo_n "checking for grep that handles long lines and -e... " >&6; }
 
3836
if test "${ac_cv_path_GREP+set}" = set; then
 
3837
  $as_echo_n "(cached) " >&6
 
3838
else
 
3839
  if test -z "$GREP"; then
 
3840
  ac_path_GREP_found=false
 
3841
  # Loop through the user's path and test for each of PROGNAME-LIST
 
3842
  as_save_IFS=$IFS; IFS=$PATH_SEPARATOR
 
3843
for as_dir in $PATH$PATH_SEPARATOR/usr/xpg4/bin
 
3844
do
 
3845
  IFS=$as_save_IFS
 
3846
  test -z "$as_dir" && as_dir=.
 
3847
  for ac_prog in grep ggrep; do
 
3848
    for ac_exec_ext in '' $ac_executable_extensions; do
 
3849
      ac_path_GREP="$as_dir/$ac_prog$ac_exec_ext"
 
3850
      { test -f "$ac_path_GREP" && $as_test_x "$ac_path_GREP"; } || continue
 
3851
# Check for GNU ac_path_GREP and select it if it is found.
 
3852
  # Check for GNU $ac_path_GREP
 
3853
case `"$ac_path_GREP" --version 2>&1` in
 
3854
*GNU*)
 
3855
  ac_cv_path_GREP="$ac_path_GREP" ac_path_GREP_found=:;;
 
3856
*)
 
3857
  ac_count=0
 
3858
  $as_echo_n 0123456789 >"conftest.in"
 
3859
  while :
 
3860
  do
 
3861
    cat "conftest.in" "conftest.in" >"conftest.tmp"
 
3862
    mv "conftest.tmp" "conftest.in"
 
3863
    cp "conftest.in" "conftest.nl"
 
3864
    $as_echo 'GREP' >> "conftest.nl"
 
3865
    "$ac_path_GREP" -e 'GREP$' -e '-(cannot match)-' < "conftest.nl" >"conftest.out" 2>/dev/null || break
 
3866
    diff "conftest.out" "conftest.nl" >/dev/null 2>&1 || break
 
3867
    ac_count=`expr $ac_count + 1`
 
3868
    if test $ac_count -gt ${ac_path_GREP_max-0}; then
 
3869
      # Best one so far, save it but keep looking for a better one
 
3870
      ac_cv_path_GREP="$ac_path_GREP"
 
3871
      ac_path_GREP_max=$ac_count
 
3872
    fi
 
3873
    # 10*(2^10) chars as input seems more than enough
 
3874
    test $ac_count -gt 10 && break
 
3875
  done
 
3876
  rm -f conftest.in conftest.tmp conftest.nl conftest.out;;
 
3877
esac
 
3878
 
 
3879
      $ac_path_GREP_found && break 3
 
3880
    done
 
3881
  done
 
3882
done
 
3883
IFS=$as_save_IFS
 
3884
  if test -z "$ac_cv_path_GREP"; then
 
3885
    { { $as_echo "$as_me:$LINENO: error: no acceptable grep could be found in $PATH$PATH_SEPARATOR/usr/xpg4/bin" >&5
 
3886
$as_echo "$as_me: error: no acceptable grep could be found in $PATH$PATH_SEPARATOR/usr/xpg4/bin" >&2;}
 
3887
   { (exit 1); exit 1; }; }
 
3888
  fi
 
3889
else
 
3890
  ac_cv_path_GREP=$GREP
 
3891
fi
 
3892
 
 
3893
fi
 
3894
{ $as_echo "$as_me:$LINENO: result: $ac_cv_path_GREP" >&5
 
3895
$as_echo "$ac_cv_path_GREP" >&6; }
 
3896
 GREP="$ac_cv_path_GREP"
 
3897
 
 
3898
 
 
3899
{ $as_echo "$as_me:$LINENO: checking for egrep" >&5
 
3900
$as_echo_n "checking for egrep... " >&6; }
 
3901
if test "${ac_cv_path_EGREP+set}" = set; then
 
3902
  $as_echo_n "(cached) " >&6
 
3903
else
 
3904
  if echo a | $GREP -E '(a|b)' >/dev/null 2>&1
 
3905
   then ac_cv_path_EGREP="$GREP -E"
 
3906
   else
 
3907
     if test -z "$EGREP"; then
 
3908
  ac_path_EGREP_found=false
 
3909
  # Loop through the user's path and test for each of PROGNAME-LIST
 
3910
  as_save_IFS=$IFS; IFS=$PATH_SEPARATOR
 
3911
for as_dir in $PATH$PATH_SEPARATOR/usr/xpg4/bin
 
3912
do
 
3913
  IFS=$as_save_IFS
 
3914
  test -z "$as_dir" && as_dir=.
 
3915
  for ac_prog in egrep; do
 
3916
    for ac_exec_ext in '' $ac_executable_extensions; do
 
3917
      ac_path_EGREP="$as_dir/$ac_prog$ac_exec_ext"
 
3918
      { test -f "$ac_path_EGREP" && $as_test_x "$ac_path_EGREP"; } || continue
 
3919
# Check for GNU ac_path_EGREP and select it if it is found.
 
3920
  # Check for GNU $ac_path_EGREP
 
3921
case `"$ac_path_EGREP" --version 2>&1` in
 
3922
*GNU*)
 
3923
  ac_cv_path_EGREP="$ac_path_EGREP" ac_path_EGREP_found=:;;
 
3924
*)
 
3925
  ac_count=0
 
3926
  $as_echo_n 0123456789 >"conftest.in"
 
3927
  while :
 
3928
  do
 
3929
    cat "conftest.in" "conftest.in" >"conftest.tmp"
 
3930
    mv "conftest.tmp" "conftest.in"
 
3931
    cp "conftest.in" "conftest.nl"
 
3932
    $as_echo 'EGREP' >> "conftest.nl"
 
3933
    "$ac_path_EGREP" 'EGREP$' < "conftest.nl" >"conftest.out" 2>/dev/null || break
 
3934
    diff "conftest.out" "conftest.nl" >/dev/null 2>&1 || break
 
3935
    ac_count=`expr $ac_count + 1`
 
3936
    if test $ac_count -gt ${ac_path_EGREP_max-0}; then
 
3937
      # Best one so far, save it but keep looking for a better one
 
3938
      ac_cv_path_EGREP="$ac_path_EGREP"
 
3939
      ac_path_EGREP_max=$ac_count
 
3940
    fi
 
3941
    # 10*(2^10) chars as input seems more than enough
 
3942
    test $ac_count -gt 10 && break
 
3943
  done
 
3944
  rm -f conftest.in conftest.tmp conftest.nl conftest.out;;
 
3945
esac
 
3946
 
 
3947
      $ac_path_EGREP_found && break 3
 
3948
    done
 
3949
  done
 
3950
done
 
3951
IFS=$as_save_IFS
 
3952
  if test -z "$ac_cv_path_EGREP"; then
 
3953
    { { $as_echo "$as_me:$LINENO: error: no acceptable egrep could be found in $PATH$PATH_SEPARATOR/usr/xpg4/bin" >&5
 
3954
$as_echo "$as_me: error: no acceptable egrep could be found in $PATH$PATH_SEPARATOR/usr/xpg4/bin" >&2;}
 
3955
   { (exit 1); exit 1; }; }
 
3956
  fi
 
3957
else
 
3958
  ac_cv_path_EGREP=$EGREP
 
3959
fi
 
3960
 
 
3961
   fi
 
3962
fi
 
3963
{ $as_echo "$as_me:$LINENO: result: $ac_cv_path_EGREP" >&5
 
3964
$as_echo "$ac_cv_path_EGREP" >&6; }
 
3965
 EGREP="$ac_cv_path_EGREP"
 
3966
 
 
3967
 
 
3968
 
 
3969
    ICC="no"
 
3970
    { $as_echo "$as_me:$LINENO: checking for icc in use" >&5
 
3971
$as_echo_n "checking for icc in use... " >&6; }
 
3972
    if test "$GCC" = "yes"; then
 
3973
              cat >conftest.$ac_ext <<_ACEOF
 
3974
/* confdefs.h.  */
 
3975
_ACEOF
 
3976
cat confdefs.h >>conftest.$ac_ext
 
3977
cat >>conftest.$ac_ext <<_ACEOF
 
3978
/* end confdefs.h.  */
 
3979
__INTEL_COMPILER
 
3980
_ACEOF
 
3981
if (eval "$ac_cpp conftest.$ac_ext") 2>&5 |
 
3982
  $EGREP "^__INTEL_COMPILER" >/dev/null 2>&1; then
 
3983
  { $as_echo "$as_me:$LINENO: result: no" >&5
 
3984
$as_echo "no" >&6; }
 
3985
 
 
3986
else
 
3987
  { $as_echo "$as_me:$LINENO: result: yes" >&5
 
3988
$as_echo "yes" >&6; }
 
3989
 
 
3990
         ICC="yes"
 
3991
fi
 
3992
rm -f conftest*
 
3993
 
 
3994
    else
 
3995
       { $as_echo "$as_me:$LINENO: result: no" >&5
 
3996
$as_echo "no" >&6; }
 
3997
 
 
3998
    fi
 
3999
 
 
4000
 
 
4001
 
 
4002
 
 
4003
 
 
4004
    SUNCC="no"
 
4005
    { $as_echo "$as_me:$LINENO: checking for Sun cc in use" >&5
 
4006
$as_echo_n "checking for Sun cc in use... " >&6; }
 
4007
    if test "$cross_compiling" = yes; then
 
4008
  { { $as_echo "$as_me:$LINENO: error: in \`$ac_pwd':" >&5
 
4009
$as_echo "$as_me: error: in \`$ac_pwd':" >&2;}
 
4010
{ { $as_echo "$as_me:$LINENO: error: cannot run test program while cross compiling
 
4011
See \`config.log' for more details." >&5
 
4012
$as_echo "$as_me: error: cannot run test program while cross compiling
 
4013
See \`config.log' for more details." >&2;}
 
4014
   { (exit 1); exit 1; }; }; }
 
4015
else
 
4016
  cat >conftest.$ac_ext <<_ACEOF
 
4017
/* confdefs.h.  */
 
4018
_ACEOF
 
4019
cat confdefs.h >>conftest.$ac_ext
 
4020
cat >>conftest.$ac_ext <<_ACEOF
 
4021
/* end confdefs.h.  */
 
4022
 
 
4023
int
 
4024
main ()
 
4025
{
 
4026
#ifdef __SUNPRO_C
 
4027
   return 0;
 
4028
#else
 
4029
   return 1;
 
4030
#endif
 
4031
 
 
4032
  ;
 
4033
  return 0;
 
4034
}
 
4035
 
 
4036
_ACEOF
 
4037
rm -f conftest$ac_exeext
 
4038
if { (ac_try="$ac_link"
 
4039
case "(($ac_try" in
 
4040
  *\"* | *\`* | *\\*) ac_try_echo=\$ac_try;;
 
4041
  *) ac_try_echo=$ac_try;;
 
4042
esac
 
4043
eval ac_try_echo="\"\$as_me:$LINENO: $ac_try_echo\""
 
4044
$as_echo "$ac_try_echo") >&5
 
4045
  (eval "$ac_link") 2>&5
 
4046
  ac_status=$?
 
4047
  $as_echo "$as_me:$LINENO: \$? = $ac_status" >&5
 
4048
  (exit $ac_status); } && { ac_try='./conftest$ac_exeext'
 
4049
  { (case "(($ac_try" in
 
4050
  *\"* | *\`* | *\\*) ac_try_echo=\$ac_try;;
 
4051
  *) ac_try_echo=$ac_try;;
 
4052
esac
 
4053
eval ac_try_echo="\"\$as_me:$LINENO: $ac_try_echo\""
 
4054
$as_echo "$ac_try_echo") >&5
 
4055
  (eval "$ac_try") 2>&5
 
4056
  ac_status=$?
 
4057
  $as_echo "$as_me:$LINENO: \$? = $ac_status" >&5
 
4058
  (exit $ac_status); }; }; then
 
4059
 
 
4060
       { $as_echo "$as_me:$LINENO: result: yes" >&5
 
4061
$as_echo "yes" >&6; }
 
4062
       CFLAGS="-mt $CFLAGS"
 
4063
       SUNCC="yes"
 
4064
 
 
4065
else
 
4066
  $as_echo "$as_me: program exited with status $ac_status" >&5
 
4067
$as_echo "$as_me: failed program was:" >&5
 
4068
sed 's/^/| /' conftest.$ac_ext >&5
 
4069
 
 
4070
( exit $ac_status )
 
4071
 
 
4072
       { $as_echo "$as_me:$LINENO: result: no" >&5
 
4073
$as_echo "no" >&6; }
 
4074
 
 
4075
 
 
4076
fi
 
4077
rm -rf conftest.dSYM
 
4078
rm -f core *.core core.conftest.* gmon.out bb.out conftest$ac_exeext conftest.$ac_objext conftest.$ac_ext
 
4079
fi
 
4080
 
 
4081
 
 
4082
 
 
4083
 
 
4084
if test "$ICC" = "no"; then
 
4085
      { $as_echo "$as_me:$LINENO: checking for $CC option to accept ISO C99" >&5
 
4086
$as_echo_n "checking for $CC option to accept ISO C99... " >&6; }
 
4087
if test "${ac_cv_prog_cc_c99+set}" = set; then
 
4088
  $as_echo_n "(cached) " >&6
 
4089
else
 
4090
  ac_cv_prog_cc_c99=no
 
4091
ac_save_CC=$CC
 
4092
cat >conftest.$ac_ext <<_ACEOF
 
4093
/* confdefs.h.  */
 
4094
_ACEOF
 
4095
cat confdefs.h >>conftest.$ac_ext
 
4096
cat >>conftest.$ac_ext <<_ACEOF
 
4097
/* end confdefs.h.  */
 
4098
#include <stdarg.h>
 
4099
#include <stdbool.h>
 
4100
#include <stdlib.h>
 
4101
#include <wchar.h>
 
4102
#include <stdio.h>
 
4103
 
 
4104
// Check varargs macros.  These examples are taken from C99 6.10.3.5.
 
4105
#define debug(...) fprintf (stderr, __VA_ARGS__)
 
4106
#define showlist(...) puts (#__VA_ARGS__)
 
4107
#define report(test,...) ((test) ? puts (#test) : printf (__VA_ARGS__))
 
4108
static void
 
4109
test_varargs_macros (void)
 
4110
{
 
4111
  int x = 1234;
 
4112
  int y = 5678;
 
4113
  debug ("Flag");
 
4114
  debug ("X = %d\n", x);
 
4115
  showlist (The first, second, and third items.);
 
4116
  report (x>y, "x is %d but y is %d", x, y);
 
4117
}
 
4118
 
 
4119
// Check long long types.
 
4120
#define BIG64 18446744073709551615ull
 
4121
#define BIG32 4294967295ul
 
4122
#define BIG_OK (BIG64 / BIG32 == 4294967297ull && BIG64 % BIG32 == 0)
 
4123
#if !BIG_OK
 
4124
  your preprocessor is broken;
 
4125
#endif
 
4126
#if BIG_OK
 
4127
#else
 
4128
  your preprocessor is broken;
 
4129
#endif
 
4130
static long long int bignum = -9223372036854775807LL;
 
4131
static unsigned long long int ubignum = BIG64;
 
4132
 
 
4133
struct incomplete_array
 
4134
{
 
4135
  int datasize;
 
4136
  double data[];
 
4137
};
 
4138
 
 
4139
struct named_init {
 
4140
  int number;
 
4141
  const wchar_t *name;
 
4142
  double average;
 
4143
};
 
4144
 
 
4145
typedef const char *ccp;
 
4146
 
 
4147
static inline int
 
4148
test_restrict (ccp restrict text)
 
4149
{
 
4150
  // See if C++-style comments work.
 
4151
  // Iterate through items via the restricted pointer.
 
4152
  // Also check for declarations in for loops.
 
4153
  for (unsigned int i = 0; *(text+i) != '\0'; ++i)
 
4154
    continue;
 
4155
  return 0;
 
4156
}
 
4157
 
 
4158
// Check varargs and va_copy.
 
4159
static void
 
4160
test_varargs (const char *format, ...)
 
4161
{
 
4162
  va_list args;
 
4163
  va_start (args, format);
 
4164
  va_list args_copy;
 
4165
  va_copy (args_copy, args);
 
4166
 
 
4167
  const char *str;
 
4168
  int number;
 
4169
  float fnumber;
 
4170
 
 
4171
  while (*format)
 
4172
    {
 
4173
      switch (*format++)
 
4174
        {
 
4175
        case 's': // string
 
4176
          str = va_arg (args_copy, const char *);
 
4177
          break;
 
4178
        case 'd': // int
 
4179
          number = va_arg (args_copy, int);
 
4180
          break;
 
4181
        case 'f': // float
 
4182
          fnumber = va_arg (args_copy, double);
 
4183
          break;
 
4184
        default:
 
4185
          break;
 
4186
        }
 
4187
    }
 
4188
  va_end (args_copy);
 
4189
  va_end (args);
 
4190
}
 
4191
 
 
4192
int
 
4193
main ()
 
4194
{
 
4195
 
 
4196
  // Check bool.
 
4197
  _Bool success = false;
 
4198
 
 
4199
  // Check restrict.
 
4200
  if (test_restrict ("String literal") == 0)
 
4201
    success = true;
 
4202
  char *restrict newvar = "Another string";
 
4203
 
 
4204
  // Check varargs.
 
4205
  test_varargs ("s, d' f .", "string", 65, 34.234);
 
4206
  test_varargs_macros ();
 
4207
 
 
4208
  // Check flexible array members.
 
4209
  struct incomplete_array *ia =
 
4210
    malloc (sizeof (struct incomplete_array) + (sizeof (double) * 10));
 
4211
  ia->datasize = 10;
 
4212
  for (int i = 0; i < ia->datasize; ++i)
 
4213
    ia->data[i] = i * 1.234;
 
4214
 
 
4215
  // Check named initializers.
 
4216
  struct named_init ni = {
 
4217
    .number = 34,
 
4218
    .name = L"Test wide string",
 
4219
    .average = 543.34343,
 
4220
  };
 
4221
 
 
4222
  ni.number = 58;
 
4223
 
 
4224
  int dynamic_array[ni.number];
 
4225
  dynamic_array[ni.number - 1] = 543;
 
4226
 
 
4227
  // work around unused variable warnings
 
4228
  return (!success || bignum == 0LL || ubignum == 0uLL || newvar[0] == 'x'
 
4229
          || dynamic_array[ni.number - 1] != 543);
 
4230
 
 
4231
  ;
 
4232
  return 0;
 
4233
}
 
4234
_ACEOF
 
4235
for ac_arg in '' -std=gnu99 -std=c99 -c99 -AC99 -xc99=all -qlanglvl=extc99
 
4236
do
 
4237
  CC="$ac_save_CC $ac_arg"
 
4238
  rm -f conftest.$ac_objext
 
4239
if { (ac_try="$ac_compile"
 
4240
case "(($ac_try" in
 
4241
  *\"* | *\`* | *\\*) ac_try_echo=\$ac_try;;
 
4242
  *) ac_try_echo=$ac_try;;
 
4243
esac
 
4244
eval ac_try_echo="\"\$as_me:$LINENO: $ac_try_echo\""
 
4245
$as_echo "$ac_try_echo") >&5
 
4246
  (eval "$ac_compile") 2>conftest.er1
 
4247
  ac_status=$?
 
4248
  grep -v '^ *+' conftest.er1 >conftest.err
 
4249
  rm -f conftest.er1
 
4250
  cat conftest.err >&5
 
4251
  $as_echo "$as_me:$LINENO: \$? = $ac_status" >&5
 
4252
  (exit $ac_status); } && {
 
4253
         test -z "$ac_c_werror_flag" ||
 
4254
         test ! -s conftest.err
 
4255
       } && test -s conftest.$ac_objext; then
 
4256
  ac_cv_prog_cc_c99=$ac_arg
 
4257
else
 
4258
  $as_echo "$as_me: failed program was:" >&5
 
4259
sed 's/^/| /' conftest.$ac_ext >&5
 
4260
 
 
4261
 
 
4262
fi
 
4263
 
 
4264
rm -f core conftest.err conftest.$ac_objext
 
4265
  test "x$ac_cv_prog_cc_c99" != "xno" && break
 
4266
done
 
4267
rm -f conftest.$ac_ext
 
4268
CC=$ac_save_CC
 
4269
 
 
4270
fi
 
4271
# AC_CACHE_VAL
 
4272
case "x$ac_cv_prog_cc_c99" in
 
4273
  x)
 
4274
    { $as_echo "$as_me:$LINENO: result: none needed" >&5
 
4275
$as_echo "none needed" >&6; } ;;
 
4276
  xno)
 
4277
    { $as_echo "$as_me:$LINENO: result: unsupported" >&5
 
4278
$as_echo "unsupported" >&6; } ;;
 
4279
  *)
 
4280
    CC="$CC $ac_cv_prog_cc_c99"
 
4281
    { $as_echo "$as_me:$LINENO: result: $ac_cv_prog_cc_c99" >&5
 
4282
$as_echo "$ac_cv_prog_cc_c99" >&6; } ;;
 
4283
esac
 
4284
 
 
4285
 
 
4286
 
 
4287
fi
 
4288
 
3579
4289
if test "x$CC" != xcc; then
3580
4290
  { $as_echo "$as_me:$LINENO: checking whether $CC and cc understand -c and -o together" >&5
3581
4291
$as_echo_n "checking whether $CC and cc understand -c and -o together... " >&6; }
3856
4566
#define ENABLE_DTRACE 1
3857
4567
_ACEOF
3858
4568
 
3859
 
    DTRACE_OBJ=memcached_dtrace.o
3860
 
    DTRACE_DEBUG_OBJ=memcached_debug_dtrace.o
 
4569
    build_dtrace=yes
 
4570
    # DTrace on MacOSX does not use -G option
 
4571
    $DTRACE -G -o conftest.$$ -s memcached_dtrace.d 2>/dev/zero
 
4572
    if test $? -eq 0
 
4573
    then
 
4574
        dtrace_instrument_obj=yes
 
4575
        rm conftest.$$
 
4576
    fi
 
4577
 
 
4578
    if test "`which tr`" = "/usr/ucb/tr"; then
 
4579
        { { $as_echo "$as_me:$LINENO: error: Please remove /usr/ucb from your path. See man standards for more info" >&5
 
4580
$as_echo "$as_me: error: Please remove /usr/ucb from your path. See man standards for more info" >&2;}
 
4581
   { (exit 1); exit 1; }; }
 
4582
    fi
3861
4583
  else
3862
4584
    { { $as_echo "$as_me:$LINENO: error: Need dtrace binary and OS support." >&5
3863
4585
$as_echo "$as_me: error: Need dtrace binary and OS support." >&2;}
3864
4586
   { (exit 1); exit 1; }; }
3865
4587
  fi
3866
 
else
3867
 
 
3868
 
cat >>confdefs.h <<\_ACEOF
3869
 
#define ENABLE_DTRACE 0
3870
 
_ACEOF
3871
 
 
3872
 
fi
3873
 
 
3874
 
 
 
4588
fi
 
4589
 
 
4590
 if test "$build_dtrace" = "yes"; then
 
4591
  BUILD_DTRACE_TRUE=
 
4592
  BUILD_DTRACE_FALSE='#'
 
4593
else
 
4594
  BUILD_DTRACE_TRUE='#'
 
4595
  BUILD_DTRACE_FALSE=
 
4596
fi
 
4597
 
 
4598
 if test "$dtrace_instrument_obj" = "yes"; then
 
4599
  DTRACE_INSTRUMENT_OBJ_TRUE=
 
4600
  DTRACE_INSTRUMENT_OBJ_FALSE='#'
 
4601
else
 
4602
  DTRACE_INSTRUMENT_OBJ_TRUE='#'
 
4603
  DTRACE_INSTRUMENT_OBJ_FALSE=
 
4604
fi
 
4605
 
 
4606
 
 
4607
 
 
4608
 
 
4609
 
 
4610
 
 
4611
# Check whether --enable-coverage was given.
 
4612
if test "${enable_coverage+set}" = set; then
 
4613
  enableval=$enable_coverage;
 
4614
fi
 
4615
 
 
4616
 
 
4617
if test "x$enable_coverage" != "xno"; then
 
4618
   if test "$ICC" = "yes"
 
4619
   then
 
4620
            CFLAGS="$CFLAGS -pthread"
 
4621
   elif test "$GCC" = "yes"
 
4622
   then
 
4623
      CFLAGS="$CFLAGS -pthread"
 
4624
      # Extract the first word of "gcov", so it can be a program name with args.
 
4625
set dummy gcov; ac_word=$2
 
4626
{ $as_echo "$as_me:$LINENO: checking for $ac_word" >&5
 
4627
$as_echo_n "checking for $ac_word... " >&6; }
 
4628
if test "${ac_cv_path_PROFILER+set}" = set; then
 
4629
  $as_echo_n "(cached) " >&6
 
4630
else
 
4631
  case $PROFILER in
 
4632
  [\\/]* | ?:[\\/]*)
 
4633
  ac_cv_path_PROFILER="$PROFILER" # Let the user override the test with a path.
 
4634
  ;;
 
4635
  *)
 
4636
  as_save_IFS=$IFS; IFS=$PATH_SEPARATOR
 
4637
for as_dir in $PATH
 
4638
do
 
4639
  IFS=$as_save_IFS
 
4640
  test -z "$as_dir" && as_dir=.
 
4641
  for ac_exec_ext in '' $ac_executable_extensions; do
 
4642
  if { test -f "$as_dir/$ac_word$ac_exec_ext" && $as_test_x "$as_dir/$ac_word$ac_exec_ext"; }; then
 
4643
    ac_cv_path_PROFILER="$as_dir/$ac_word$ac_exec_ext"
 
4644
    $as_echo "$as_me:$LINENO: found $as_dir/$ac_word$ac_exec_ext" >&5
 
4645
    break 2
 
4646
  fi
 
4647
done
 
4648
done
 
4649
IFS=$as_save_IFS
 
4650
 
 
4651
  test -z "$ac_cv_path_PROFILER" && ac_cv_path_PROFILER=""no""
 
4652
  ;;
 
4653
esac
 
4654
fi
 
4655
PROFILER=$ac_cv_path_PROFILER
 
4656
if test -n "$PROFILER"; then
 
4657
  { $as_echo "$as_me:$LINENO: result: $PROFILER" >&5
 
4658
$as_echo "$PROFILER" >&6; }
 
4659
else
 
4660
  { $as_echo "$as_me:$LINENO: result: no" >&5
 
4661
$as_echo "no" >&6; }
 
4662
fi
 
4663
 
 
4664
 
 
4665
      if test "x$PROFILER" != "xno"; then
 
4666
         PROFILER_FLAGS="-fprofile-arcs -ftest-coverage"
 
4667
         PROFILER_LDFLAGS="-lgcov"
 
4668
      fi
 
4669
   elif test "$SUNCC" = "yes"
 
4670
   then
 
4671
      # Extract the first word of "tcov", so it can be a program name with args.
 
4672
set dummy tcov; ac_word=$2
 
4673
{ $as_echo "$as_me:$LINENO: checking for $ac_word" >&5
 
4674
$as_echo_n "checking for $ac_word... " >&6; }
 
4675
if test "${ac_cv_path_PROFILER+set}" = set; then
 
4676
  $as_echo_n "(cached) " >&6
 
4677
else
 
4678
  case $PROFILER in
 
4679
  [\\/]* | ?:[\\/]*)
 
4680
  ac_cv_path_PROFILER="$PROFILER" # Let the user override the test with a path.
 
4681
  ;;
 
4682
  *)
 
4683
  as_save_IFS=$IFS; IFS=$PATH_SEPARATOR
 
4684
for as_dir in $PATH
 
4685
do
 
4686
  IFS=$as_save_IFS
 
4687
  test -z "$as_dir" && as_dir=.
 
4688
  for ac_exec_ext in '' $ac_executable_extensions; do
 
4689
  if { test -f "$as_dir/$ac_word$ac_exec_ext" && $as_test_x "$as_dir/$ac_word$ac_exec_ext"; }; then
 
4690
    ac_cv_path_PROFILER="$as_dir/$ac_word$ac_exec_ext"
 
4691
    $as_echo "$as_me:$LINENO: found $as_dir/$ac_word$ac_exec_ext" >&5
 
4692
    break 2
 
4693
  fi
 
4694
done
 
4695
done
 
4696
IFS=$as_save_IFS
 
4697
 
 
4698
  test -z "$ac_cv_path_PROFILER" && ac_cv_path_PROFILER=""no""
 
4699
  ;;
 
4700
esac
 
4701
fi
 
4702
PROFILER=$ac_cv_path_PROFILER
 
4703
if test -n "$PROFILER"; then
 
4704
  { $as_echo "$as_me:$LINENO: result: $PROFILER" >&5
 
4705
$as_echo "$PROFILER" >&6; }
 
4706
else
 
4707
  { $as_echo "$as_me:$LINENO: result: no" >&5
 
4708
$as_echo "no" >&6; }
 
4709
fi
 
4710
 
 
4711
 
 
4712
      if test "x$PROFILER" != "xno"; then
 
4713
         PROFILER_FLAGS=-xprofile=tcov
 
4714
      fi
 
4715
   fi
 
4716
fi
3875
4717
 
3876
4718
 
3877
4719
 
3884
4726
then
3885
4727
    org_cflags=$CFLAGS
3886
4728
    CFLAGS=-m64
3887
 
 
3888
 
if test "$cross_compiling" = yes; then
 
4729
    if test "$cross_compiling" = yes; then
3889
4730
  { { $as_echo "$as_me:$LINENO: error: in \`$ac_pwd':" >&5
3890
4731
$as_echo "$as_me: error: in \`$ac_pwd':" >&2;}
3891
4732
{ { $as_echo "$as_me:$LINENO: error: cannot run test program while cross compiling
4270
5111
 
4271
5112
fi
4272
5113
 
4273
 
{ $as_echo "$as_me:$LINENO: checking for library containing mallinfo" >&5
4274
 
$as_echo_n "checking for library containing mallinfo... " >&6; }
4275
 
if test "${ac_cv_search_mallinfo+set}" = set; then
4276
 
  $as_echo_n "(cached) " >&6
4277
 
else
4278
 
  ac_func_search_save_LIBS=$LIBS
4279
 
cat >conftest.$ac_ext <<_ACEOF
4280
 
/* confdefs.h.  */
4281
 
_ACEOF
4282
 
cat confdefs.h >>conftest.$ac_ext
4283
 
cat >>conftest.$ac_ext <<_ACEOF
4284
 
/* end confdefs.h.  */
4285
 
 
4286
 
/* Override any GCC internal prototype to avoid an error.
4287
 
   Use char because int might match the return type of a GCC
4288
 
   builtin and then its argument prototype would still apply.  */
4289
 
#ifdef __cplusplus
4290
 
extern "C"
4291
 
#endif
4292
 
char mallinfo ();
4293
 
int
4294
 
main ()
4295
 
{
4296
 
return mallinfo ();
4297
 
  ;
4298
 
  return 0;
4299
 
}
4300
 
_ACEOF
4301
 
for ac_lib in '' malloc; do
4302
 
  if test -z "$ac_lib"; then
4303
 
    ac_res="none required"
4304
 
  else
4305
 
    ac_res=-l$ac_lib
4306
 
    LIBS="-l$ac_lib  $ac_func_search_save_LIBS"
4307
 
  fi
4308
 
  rm -f conftest.$ac_objext conftest$ac_exeext
4309
 
if { (ac_try="$ac_link"
4310
 
case "(($ac_try" in
4311
 
  *\"* | *\`* | *\\*) ac_try_echo=\$ac_try;;
4312
 
  *) ac_try_echo=$ac_try;;
4313
 
esac
4314
 
eval ac_try_echo="\"\$as_me:$LINENO: $ac_try_echo\""
4315
 
$as_echo "$ac_try_echo") >&5
4316
 
  (eval "$ac_link") 2>conftest.er1
4317
 
  ac_status=$?
4318
 
  grep -v '^ *+' conftest.er1 >conftest.err
4319
 
  rm -f conftest.er1
4320
 
  cat conftest.err >&5
4321
 
  $as_echo "$as_me:$LINENO: \$? = $ac_status" >&5
4322
 
  (exit $ac_status); } && {
4323
 
         test -z "$ac_c_werror_flag" ||
4324
 
         test ! -s conftest.err
4325
 
       } && test -s conftest$ac_exeext && {
4326
 
         test "$cross_compiling" = yes ||
4327
 
         $as_test_x conftest$ac_exeext
4328
 
       }; then
4329
 
  ac_cv_search_mallinfo=$ac_res
4330
 
else
4331
 
  $as_echo "$as_me: failed program was:" >&5
4332
 
sed 's/^/| /' conftest.$ac_ext >&5
4333
 
 
4334
 
 
4335
 
fi
4336
 
 
4337
 
rm -rf conftest.dSYM
4338
 
rm -f core conftest.err conftest.$ac_objext conftest_ipa8_conftest.oo \
4339
 
      conftest$ac_exeext
4340
 
  if test "${ac_cv_search_mallinfo+set}" = set; then
4341
 
  break
4342
 
fi
4343
 
done
4344
 
if test "${ac_cv_search_mallinfo+set}" = set; then
4345
 
  :
4346
 
else
4347
 
  ac_cv_search_mallinfo=no
4348
 
fi
4349
 
rm conftest.$ac_ext
4350
 
LIBS=$ac_func_search_save_LIBS
4351
 
fi
4352
 
{ $as_echo "$as_me:$LINENO: result: $ac_cv_search_mallinfo" >&5
4353
 
$as_echo "$ac_cv_search_mallinfo" >&6; }
4354
 
ac_res=$ac_cv_search_mallinfo
4355
 
if test "$ac_res" != no; then
4356
 
  test "$ac_res" = "none required" || LIBS="$ac_res $LIBS"
4357
 
 
4358
 
fi
4359
 
 
4360
 
 
4361
 
{ $as_echo "$as_me:$LINENO: checking for daemon" >&5
4362
 
$as_echo_n "checking for daemon... " >&6; }
4363
 
if test "${ac_cv_func_daemon+set}" = set; then
4364
 
  $as_echo_n "(cached) " >&6
4365
 
else
4366
 
  cat >conftest.$ac_ext <<_ACEOF
4367
 
/* confdefs.h.  */
4368
 
_ACEOF
4369
 
cat confdefs.h >>conftest.$ac_ext
4370
 
cat >>conftest.$ac_ext <<_ACEOF
4371
 
/* end confdefs.h.  */
4372
 
/* Define daemon to an innocuous variant, in case <limits.h> declares daemon.
4373
 
   For example, HP-UX 11i <limits.h> declares gettimeofday.  */
4374
 
#define daemon innocuous_daemon
4375
 
 
4376
 
/* System header to define __stub macros and hopefully few prototypes,
4377
 
    which can conflict with char daemon (); below.
4378
 
    Prefer <limits.h> to <assert.h> if __STDC__ is defined, since
4379
 
    <limits.h> exists even on freestanding compilers.  */
4380
 
 
4381
 
#ifdef __STDC__
4382
 
# include <limits.h>
4383
 
#else
4384
 
# include <assert.h>
4385
 
#endif
4386
 
 
4387
 
#undef daemon
4388
 
 
4389
 
/* Override any GCC internal prototype to avoid an error.
4390
 
   Use char because int might match the return type of a GCC
4391
 
   builtin and then its argument prototype would still apply.  */
4392
 
#ifdef __cplusplus
4393
 
extern "C"
4394
 
#endif
4395
 
char daemon ();
4396
 
/* The GNU C library defines this for functions which it implements
4397
 
    to always fail with ENOSYS.  Some functions are actually named
4398
 
    something starting with __ and the normal name is an alias.  */
4399
 
#if defined __stub_daemon || defined __stub___daemon
4400
 
choke me
4401
 
#endif
4402
 
 
4403
 
int
4404
 
main ()
4405
 
{
4406
 
return daemon ();
4407
 
  ;
4408
 
  return 0;
4409
 
}
4410
 
_ACEOF
4411
 
rm -f conftest.$ac_objext conftest$ac_exeext
4412
 
if { (ac_try="$ac_link"
4413
 
case "(($ac_try" in
4414
 
  *\"* | *\`* | *\\*) ac_try_echo=\$ac_try;;
4415
 
  *) ac_try_echo=$ac_try;;
4416
 
esac
4417
 
eval ac_try_echo="\"\$as_me:$LINENO: $ac_try_echo\""
4418
 
$as_echo "$ac_try_echo") >&5
4419
 
  (eval "$ac_link") 2>conftest.er1
4420
 
  ac_status=$?
4421
 
  grep -v '^ *+' conftest.er1 >conftest.err
4422
 
  rm -f conftest.er1
4423
 
  cat conftest.err >&5
4424
 
  $as_echo "$as_me:$LINENO: \$? = $ac_status" >&5
4425
 
  (exit $ac_status); } && {
4426
 
         test -z "$ac_c_werror_flag" ||
4427
 
         test ! -s conftest.err
4428
 
       } && test -s conftest$ac_exeext && {
4429
 
         test "$cross_compiling" = yes ||
4430
 
         $as_test_x conftest$ac_exeext
4431
 
       }; then
4432
 
  ac_cv_func_daemon=yes
4433
 
else
4434
 
  $as_echo "$as_me: failed program was:" >&5
4435
 
sed 's/^/| /' conftest.$ac_ext >&5
4436
 
 
4437
 
        ac_cv_func_daemon=no
4438
 
fi
4439
 
 
4440
 
rm -rf conftest.dSYM
4441
 
rm -f core conftest.err conftest.$ac_objext conftest_ipa8_conftest.oo \
4442
 
      conftest$ac_exeext conftest.$ac_ext
4443
 
fi
4444
 
{ $as_echo "$as_me:$LINENO: result: $ac_cv_func_daemon" >&5
4445
 
$as_echo "$ac_cv_func_daemon" >&6; }
4446
 
if test "x$ac_cv_func_daemon" = x""yes; then
4447
 
 
4448
 
cat >>confdefs.h <<\_ACEOF
4449
 
#define HAVE_DAEMON /**/
4450
 
_ACEOF
4451
 
 
4452
 
else
4453
 
  DAEMON_OBJ=daemon.o
4454
 
fi
4455
 
 
4456
 
 
4457
 
 
4458
 
ac_ext=c
4459
 
ac_cpp='$CPP $CPPFLAGS'
4460
 
ac_compile='$CC -c $CFLAGS $CPPFLAGS conftest.$ac_ext >&5'
4461
 
ac_link='$CC -o conftest$ac_exeext $CFLAGS $CPPFLAGS $LDFLAGS conftest.$ac_ext $LIBS >&5'
4462
 
ac_compiler_gnu=$ac_cv_c_compiler_gnu
4463
 
{ $as_echo "$as_me:$LINENO: checking how to run the C preprocessor" >&5
4464
 
$as_echo_n "checking how to run the C preprocessor... " >&6; }
4465
 
# On Suns, sometimes $CPP names a directory.
4466
 
if test -n "$CPP" && test -d "$CPP"; then
4467
 
  CPP=
4468
 
fi
4469
 
if test -z "$CPP"; then
4470
 
  if test "${ac_cv_prog_CPP+set}" = set; then
4471
 
  $as_echo_n "(cached) " >&6
4472
 
else
4473
 
      # Double quotes because CPP needs to be expanded
4474
 
    for CPP in "$CC -E" "$CC -E -traditional-cpp" "/lib/cpp"
4475
 
    do
4476
 
      ac_preproc_ok=false
4477
 
for ac_c_preproc_warn_flag in '' yes
4478
 
do
4479
 
  # Use a header file that comes with gcc, so configuring glibc
4480
 
  # with a fresh cross-compiler works.
4481
 
  # Prefer <limits.h> to <assert.h> if __STDC__ is defined, since
4482
 
  # <limits.h> exists even on freestanding compilers.
4483
 
  # On the NeXT, cc -E runs the code through the compiler's parser,
4484
 
  # not just through cpp. "Syntax error" is here to catch this case.
4485
 
  cat >conftest.$ac_ext <<_ACEOF
4486
 
/* confdefs.h.  */
4487
 
_ACEOF
4488
 
cat confdefs.h >>conftest.$ac_ext
4489
 
cat >>conftest.$ac_ext <<_ACEOF
4490
 
/* end confdefs.h.  */
4491
 
#ifdef __STDC__
4492
 
# include <limits.h>
4493
 
#else
4494
 
# include <assert.h>
4495
 
#endif
4496
 
                     Syntax error
4497
 
_ACEOF
4498
 
if { (ac_try="$ac_cpp conftest.$ac_ext"
4499
 
case "(($ac_try" in
4500
 
  *\"* | *\`* | *\\*) ac_try_echo=\$ac_try;;
4501
 
  *) ac_try_echo=$ac_try;;
4502
 
esac
4503
 
eval ac_try_echo="\"\$as_me:$LINENO: $ac_try_echo\""
4504
 
$as_echo "$ac_try_echo") >&5
4505
 
  (eval "$ac_cpp conftest.$ac_ext") 2>conftest.er1
4506
 
  ac_status=$?
4507
 
  grep -v '^ *+' conftest.er1 >conftest.err
4508
 
  rm -f conftest.er1
4509
 
  cat conftest.err >&5
4510
 
  $as_echo "$as_me:$LINENO: \$? = $ac_status" >&5
4511
 
  (exit $ac_status); } >/dev/null && {
4512
 
         test -z "$ac_c_preproc_warn_flag$ac_c_werror_flag" ||
4513
 
         test ! -s conftest.err
4514
 
       }; then
4515
 
  :
4516
 
else
4517
 
  $as_echo "$as_me: failed program was:" >&5
4518
 
sed 's/^/| /' conftest.$ac_ext >&5
4519
 
 
4520
 
  # Broken: fails on valid input.
4521
 
continue
4522
 
fi
4523
 
 
4524
 
rm -f conftest.err conftest.$ac_ext
4525
 
 
4526
 
  # OK, works on sane cases.  Now check whether nonexistent headers
4527
 
  # can be detected and how.
4528
 
  cat >conftest.$ac_ext <<_ACEOF
4529
 
/* confdefs.h.  */
4530
 
_ACEOF
4531
 
cat confdefs.h >>conftest.$ac_ext
4532
 
cat >>conftest.$ac_ext <<_ACEOF
4533
 
/* end confdefs.h.  */
4534
 
#include <ac_nonexistent.h>
4535
 
_ACEOF
4536
 
if { (ac_try="$ac_cpp conftest.$ac_ext"
4537
 
case "(($ac_try" in
4538
 
  *\"* | *\`* | *\\*) ac_try_echo=\$ac_try;;
4539
 
  *) ac_try_echo=$ac_try;;
4540
 
esac
4541
 
eval ac_try_echo="\"\$as_me:$LINENO: $ac_try_echo\""
4542
 
$as_echo "$ac_try_echo") >&5
4543
 
  (eval "$ac_cpp conftest.$ac_ext") 2>conftest.er1
4544
 
  ac_status=$?
4545
 
  grep -v '^ *+' conftest.er1 >conftest.err
4546
 
  rm -f conftest.er1
4547
 
  cat conftest.err >&5
4548
 
  $as_echo "$as_me:$LINENO: \$? = $ac_status" >&5
4549
 
  (exit $ac_status); } >/dev/null && {
4550
 
         test -z "$ac_c_preproc_warn_flag$ac_c_werror_flag" ||
4551
 
         test ! -s conftest.err
4552
 
       }; then
4553
 
  # Broken: success on invalid input.
4554
 
continue
4555
 
else
4556
 
  $as_echo "$as_me: failed program was:" >&5
4557
 
sed 's/^/| /' conftest.$ac_ext >&5
4558
 
 
4559
 
  # Passes both tests.
4560
 
ac_preproc_ok=:
4561
 
break
4562
 
fi
4563
 
 
4564
 
rm -f conftest.err conftest.$ac_ext
4565
 
 
4566
 
done
4567
 
# Because of `break', _AC_PREPROC_IFELSE's cleaning code was skipped.
4568
 
rm -f conftest.err conftest.$ac_ext
4569
 
if $ac_preproc_ok; then
4570
 
  break
4571
 
fi
4572
 
 
4573
 
    done
4574
 
    ac_cv_prog_CPP=$CPP
4575
 
 
4576
 
fi
4577
 
  CPP=$ac_cv_prog_CPP
4578
 
else
4579
 
  ac_cv_prog_CPP=$CPP
4580
 
fi
4581
 
{ $as_echo "$as_me:$LINENO: result: $CPP" >&5
4582
 
$as_echo "$CPP" >&6; }
4583
 
ac_preproc_ok=false
4584
 
for ac_c_preproc_warn_flag in '' yes
4585
 
do
4586
 
  # Use a header file that comes with gcc, so configuring glibc
4587
 
  # with a fresh cross-compiler works.
4588
 
  # Prefer <limits.h> to <assert.h> if __STDC__ is defined, since
4589
 
  # <limits.h> exists even on freestanding compilers.
4590
 
  # On the NeXT, cc -E runs the code through the compiler's parser,
4591
 
  # not just through cpp. "Syntax error" is here to catch this case.
4592
 
  cat >conftest.$ac_ext <<_ACEOF
4593
 
/* confdefs.h.  */
4594
 
_ACEOF
4595
 
cat confdefs.h >>conftest.$ac_ext
4596
 
cat >>conftest.$ac_ext <<_ACEOF
4597
 
/* end confdefs.h.  */
4598
 
#ifdef __STDC__
4599
 
# include <limits.h>
4600
 
#else
4601
 
# include <assert.h>
4602
 
#endif
4603
 
                     Syntax error
4604
 
_ACEOF
4605
 
if { (ac_try="$ac_cpp conftest.$ac_ext"
4606
 
case "(($ac_try" in
4607
 
  *\"* | *\`* | *\\*) ac_try_echo=\$ac_try;;
4608
 
  *) ac_try_echo=$ac_try;;
4609
 
esac
4610
 
eval ac_try_echo="\"\$as_me:$LINENO: $ac_try_echo\""
4611
 
$as_echo "$ac_try_echo") >&5
4612
 
  (eval "$ac_cpp conftest.$ac_ext") 2>conftest.er1
4613
 
  ac_status=$?
4614
 
  grep -v '^ *+' conftest.er1 >conftest.err
4615
 
  rm -f conftest.er1
4616
 
  cat conftest.err >&5
4617
 
  $as_echo "$as_me:$LINENO: \$? = $ac_status" >&5
4618
 
  (exit $ac_status); } >/dev/null && {
4619
 
         test -z "$ac_c_preproc_warn_flag$ac_c_werror_flag" ||
4620
 
         test ! -s conftest.err
4621
 
       }; then
4622
 
  :
4623
 
else
4624
 
  $as_echo "$as_me: failed program was:" >&5
4625
 
sed 's/^/| /' conftest.$ac_ext >&5
4626
 
 
4627
 
  # Broken: fails on valid input.
4628
 
continue
4629
 
fi
4630
 
 
4631
 
rm -f conftest.err conftest.$ac_ext
4632
 
 
4633
 
  # OK, works on sane cases.  Now check whether nonexistent headers
4634
 
  # can be detected and how.
4635
 
  cat >conftest.$ac_ext <<_ACEOF
4636
 
/* confdefs.h.  */
4637
 
_ACEOF
4638
 
cat confdefs.h >>conftest.$ac_ext
4639
 
cat >>conftest.$ac_ext <<_ACEOF
4640
 
/* end confdefs.h.  */
4641
 
#include <ac_nonexistent.h>
4642
 
_ACEOF
4643
 
if { (ac_try="$ac_cpp conftest.$ac_ext"
4644
 
case "(($ac_try" in
4645
 
  *\"* | *\`* | *\\*) ac_try_echo=\$ac_try;;
4646
 
  *) ac_try_echo=$ac_try;;
4647
 
esac
4648
 
eval ac_try_echo="\"\$as_me:$LINENO: $ac_try_echo\""
4649
 
$as_echo "$ac_try_echo") >&5
4650
 
  (eval "$ac_cpp conftest.$ac_ext") 2>conftest.er1
4651
 
  ac_status=$?
4652
 
  grep -v '^ *+' conftest.er1 >conftest.err
4653
 
  rm -f conftest.er1
4654
 
  cat conftest.err >&5
4655
 
  $as_echo "$as_me:$LINENO: \$? = $ac_status" >&5
4656
 
  (exit $ac_status); } >/dev/null && {
4657
 
         test -z "$ac_c_preproc_warn_flag$ac_c_werror_flag" ||
4658
 
         test ! -s conftest.err
4659
 
       }; then
4660
 
  # Broken: success on invalid input.
4661
 
continue
4662
 
else
4663
 
  $as_echo "$as_me: failed program was:" >&5
4664
 
sed 's/^/| /' conftest.$ac_ext >&5
4665
 
 
4666
 
  # Passes both tests.
4667
 
ac_preproc_ok=:
4668
 
break
4669
 
fi
4670
 
 
4671
 
rm -f conftest.err conftest.$ac_ext
4672
 
 
4673
 
done
4674
 
# Because of `break', _AC_PREPROC_IFELSE's cleaning code was skipped.
4675
 
rm -f conftest.err conftest.$ac_ext
4676
 
if $ac_preproc_ok; then
4677
 
  :
4678
 
else
4679
 
  { { $as_echo "$as_me:$LINENO: error: in \`$ac_pwd':" >&5
4680
 
$as_echo "$as_me: error: in \`$ac_pwd':" >&2;}
4681
 
{ { $as_echo "$as_me:$LINENO: error: C preprocessor \"$CPP\" fails sanity check
4682
 
See \`config.log' for more details." >&5
4683
 
$as_echo "$as_me: error: C preprocessor \"$CPP\" fails sanity check
4684
 
See \`config.log' for more details." >&2;}
4685
 
   { (exit 1); exit 1; }; }; }
4686
 
fi
4687
 
 
4688
 
ac_ext=c
4689
 
ac_cpp='$CPP $CPPFLAGS'
4690
 
ac_compile='$CC -c $CFLAGS $CPPFLAGS conftest.$ac_ext >&5'
4691
 
ac_link='$CC -o conftest$ac_exeext $CFLAGS $CPPFLAGS $LDFLAGS conftest.$ac_ext $LIBS >&5'
4692
 
ac_compiler_gnu=$ac_cv_c_compiler_gnu
4693
 
 
4694
 
 
4695
 
{ $as_echo "$as_me:$LINENO: checking for grep that handles long lines and -e" >&5
4696
 
$as_echo_n "checking for grep that handles long lines and -e... " >&6; }
4697
 
if test "${ac_cv_path_GREP+set}" = set; then
4698
 
  $as_echo_n "(cached) " >&6
4699
 
else
4700
 
  if test -z "$GREP"; then
4701
 
  ac_path_GREP_found=false
4702
 
  # Loop through the user's path and test for each of PROGNAME-LIST
4703
 
  as_save_IFS=$IFS; IFS=$PATH_SEPARATOR
4704
 
for as_dir in $PATH$PATH_SEPARATOR/usr/xpg4/bin
4705
 
do
4706
 
  IFS=$as_save_IFS
4707
 
  test -z "$as_dir" && as_dir=.
4708
 
  for ac_prog in grep ggrep; do
4709
 
    for ac_exec_ext in '' $ac_executable_extensions; do
4710
 
      ac_path_GREP="$as_dir/$ac_prog$ac_exec_ext"
4711
 
      { test -f "$ac_path_GREP" && $as_test_x "$ac_path_GREP"; } || continue
4712
 
# Check for GNU ac_path_GREP and select it if it is found.
4713
 
  # Check for GNU $ac_path_GREP
4714
 
case `"$ac_path_GREP" --version 2>&1` in
4715
 
*GNU*)
4716
 
  ac_cv_path_GREP="$ac_path_GREP" ac_path_GREP_found=:;;
4717
 
*)
4718
 
  ac_count=0
4719
 
  $as_echo_n 0123456789 >"conftest.in"
4720
 
  while :
4721
 
  do
4722
 
    cat "conftest.in" "conftest.in" >"conftest.tmp"
4723
 
    mv "conftest.tmp" "conftest.in"
4724
 
    cp "conftest.in" "conftest.nl"
4725
 
    $as_echo 'GREP' >> "conftest.nl"
4726
 
    "$ac_path_GREP" -e 'GREP$' -e '-(cannot match)-' < "conftest.nl" >"conftest.out" 2>/dev/null || break
4727
 
    diff "conftest.out" "conftest.nl" >/dev/null 2>&1 || break
4728
 
    ac_count=`expr $ac_count + 1`
4729
 
    if test $ac_count -gt ${ac_path_GREP_max-0}; then
4730
 
      # Best one so far, save it but keep looking for a better one
4731
 
      ac_cv_path_GREP="$ac_path_GREP"
4732
 
      ac_path_GREP_max=$ac_count
4733
 
    fi
4734
 
    # 10*(2^10) chars as input seems more than enough
4735
 
    test $ac_count -gt 10 && break
4736
 
  done
4737
 
  rm -f conftest.in conftest.tmp conftest.nl conftest.out;;
4738
 
esac
4739
 
 
4740
 
      $ac_path_GREP_found && break 3
4741
 
    done
4742
 
  done
4743
 
done
4744
 
IFS=$as_save_IFS
4745
 
  if test -z "$ac_cv_path_GREP"; then
4746
 
    { { $as_echo "$as_me:$LINENO: error: no acceptable grep could be found in $PATH$PATH_SEPARATOR/usr/xpg4/bin" >&5
4747
 
$as_echo "$as_me: error: no acceptable grep could be found in $PATH$PATH_SEPARATOR/usr/xpg4/bin" >&2;}
4748
 
   { (exit 1); exit 1; }; }
4749
 
  fi
4750
 
else
4751
 
  ac_cv_path_GREP=$GREP
4752
 
fi
4753
 
 
4754
 
fi
4755
 
{ $as_echo "$as_me:$LINENO: result: $ac_cv_path_GREP" >&5
4756
 
$as_echo "$ac_cv_path_GREP" >&6; }
4757
 
 GREP="$ac_cv_path_GREP"
4758
 
 
4759
 
 
4760
 
{ $as_echo "$as_me:$LINENO: checking for egrep" >&5
4761
 
$as_echo_n "checking for egrep... " >&6; }
4762
 
if test "${ac_cv_path_EGREP+set}" = set; then
4763
 
  $as_echo_n "(cached) " >&6
4764
 
else
4765
 
  if echo a | $GREP -E '(a|b)' >/dev/null 2>&1
4766
 
   then ac_cv_path_EGREP="$GREP -E"
4767
 
   else
4768
 
     if test -z "$EGREP"; then
4769
 
  ac_path_EGREP_found=false
4770
 
  # Loop through the user's path and test for each of PROGNAME-LIST
4771
 
  as_save_IFS=$IFS; IFS=$PATH_SEPARATOR
4772
 
for as_dir in $PATH$PATH_SEPARATOR/usr/xpg4/bin
4773
 
do
4774
 
  IFS=$as_save_IFS
4775
 
  test -z "$as_dir" && as_dir=.
4776
 
  for ac_prog in egrep; do
4777
 
    for ac_exec_ext in '' $ac_executable_extensions; do
4778
 
      ac_path_EGREP="$as_dir/$ac_prog$ac_exec_ext"
4779
 
      { test -f "$ac_path_EGREP" && $as_test_x "$ac_path_EGREP"; } || continue
4780
 
# Check for GNU ac_path_EGREP and select it if it is found.
4781
 
  # Check for GNU $ac_path_EGREP
4782
 
case `"$ac_path_EGREP" --version 2>&1` in
4783
 
*GNU*)
4784
 
  ac_cv_path_EGREP="$ac_path_EGREP" ac_path_EGREP_found=:;;
4785
 
*)
4786
 
  ac_count=0
4787
 
  $as_echo_n 0123456789 >"conftest.in"
4788
 
  while :
4789
 
  do
4790
 
    cat "conftest.in" "conftest.in" >"conftest.tmp"
4791
 
    mv "conftest.tmp" "conftest.in"
4792
 
    cp "conftest.in" "conftest.nl"
4793
 
    $as_echo 'EGREP' >> "conftest.nl"
4794
 
    "$ac_path_EGREP" 'EGREP$' < "conftest.nl" >"conftest.out" 2>/dev/null || break
4795
 
    diff "conftest.out" "conftest.nl" >/dev/null 2>&1 || break
4796
 
    ac_count=`expr $ac_count + 1`
4797
 
    if test $ac_count -gt ${ac_path_EGREP_max-0}; then
4798
 
      # Best one so far, save it but keep looking for a better one
4799
 
      ac_cv_path_EGREP="$ac_path_EGREP"
4800
 
      ac_path_EGREP_max=$ac_count
4801
 
    fi
4802
 
    # 10*(2^10) chars as input seems more than enough
4803
 
    test $ac_count -gt 10 && break
4804
 
  done
4805
 
  rm -f conftest.in conftest.tmp conftest.nl conftest.out;;
4806
 
esac
4807
 
 
4808
 
      $ac_path_EGREP_found && break 3
4809
 
    done
4810
 
  done
4811
 
done
4812
 
IFS=$as_save_IFS
4813
 
  if test -z "$ac_cv_path_EGREP"; then
4814
 
    { { $as_echo "$as_me:$LINENO: error: no acceptable egrep could be found in $PATH$PATH_SEPARATOR/usr/xpg4/bin" >&5
4815
 
$as_echo "$as_me: error: no acceptable egrep could be found in $PATH$PATH_SEPARATOR/usr/xpg4/bin" >&2;}
4816
 
   { (exit 1); exit 1; }; }
4817
 
  fi
4818
 
else
4819
 
  ac_cv_path_EGREP=$EGREP
4820
 
fi
4821
 
 
4822
 
   fi
4823
 
fi
4824
 
{ $as_echo "$as_me:$LINENO: result: $ac_cv_path_EGREP" >&5
4825
 
$as_echo "$ac_cv_path_EGREP" >&6; }
4826
 
 EGREP="$ac_cv_path_EGREP"
4827
 
 
 
5114
{ $as_echo "$as_me:$LINENO: checking for library containing umem_cache_create" >&5
 
5115
$as_echo_n "checking for library containing umem_cache_create... " >&6; }
 
5116
if test "${ac_cv_search_umem_cache_create+set}" = set; then
 
5117
  $as_echo_n "(cached) " >&6
 
5118
else
 
5119
  ac_func_search_save_LIBS=$LIBS
 
5120
cat >conftest.$ac_ext <<_ACEOF
 
5121
/* confdefs.h.  */
 
5122
_ACEOF
 
5123
cat confdefs.h >>conftest.$ac_ext
 
5124
cat >>conftest.$ac_ext <<_ACEOF
 
5125
/* end confdefs.h.  */
 
5126
 
 
5127
/* Override any GCC internal prototype to avoid an error.
 
5128
   Use char because int might match the return type of a GCC
 
5129
   builtin and then its argument prototype would still apply.  */
 
5130
#ifdef __cplusplus
 
5131
extern "C"
 
5132
#endif
 
5133
char umem_cache_create ();
 
5134
int
 
5135
main ()
 
5136
{
 
5137
return umem_cache_create ();
 
5138
  ;
 
5139
  return 0;
 
5140
}
 
5141
_ACEOF
 
5142
for ac_lib in '' umem; do
 
5143
  if test -z "$ac_lib"; then
 
5144
    ac_res="none required"
 
5145
  else
 
5146
    ac_res=-l$ac_lib
 
5147
    LIBS="-l$ac_lib  $ac_func_search_save_LIBS"
 
5148
  fi
 
5149
  rm -f conftest.$ac_objext conftest$ac_exeext
 
5150
if { (ac_try="$ac_link"
 
5151
case "(($ac_try" in
 
5152
  *\"* | *\`* | *\\*) ac_try_echo=\$ac_try;;
 
5153
  *) ac_try_echo=$ac_try;;
 
5154
esac
 
5155
eval ac_try_echo="\"\$as_me:$LINENO: $ac_try_echo\""
 
5156
$as_echo "$ac_try_echo") >&5
 
5157
  (eval "$ac_link") 2>conftest.er1
 
5158
  ac_status=$?
 
5159
  grep -v '^ *+' conftest.er1 >conftest.err
 
5160
  rm -f conftest.er1
 
5161
  cat conftest.err >&5
 
5162
  $as_echo "$as_me:$LINENO: \$? = $ac_status" >&5
 
5163
  (exit $ac_status); } && {
 
5164
         test -z "$ac_c_werror_flag" ||
 
5165
         test ! -s conftest.err
 
5166
       } && test -s conftest$ac_exeext && {
 
5167
         test "$cross_compiling" = yes ||
 
5168
         $as_test_x conftest$ac_exeext
 
5169
       }; then
 
5170
  ac_cv_search_umem_cache_create=$ac_res
 
5171
else
 
5172
  $as_echo "$as_me: failed program was:" >&5
 
5173
sed 's/^/| /' conftest.$ac_ext >&5
 
5174
 
 
5175
 
 
5176
fi
 
5177
 
 
5178
rm -rf conftest.dSYM
 
5179
rm -f core conftest.err conftest.$ac_objext conftest_ipa8_conftest.oo \
 
5180
      conftest$ac_exeext
 
5181
  if test "${ac_cv_search_umem_cache_create+set}" = set; then
 
5182
  break
 
5183
fi
 
5184
done
 
5185
if test "${ac_cv_search_umem_cache_create+set}" = set; then
 
5186
  :
 
5187
else
 
5188
  ac_cv_search_umem_cache_create=no
 
5189
fi
 
5190
rm conftest.$ac_ext
 
5191
LIBS=$ac_func_search_save_LIBS
 
5192
fi
 
5193
{ $as_echo "$as_me:$LINENO: result: $ac_cv_search_umem_cache_create" >&5
 
5194
$as_echo "$ac_cv_search_umem_cache_create" >&6; }
 
5195
ac_res=$ac_cv_search_umem_cache_create
 
5196
if test "$ac_res" != no; then
 
5197
  test "$ac_res" = "none required" || LIBS="$ac_res $LIBS"
 
5198
 
 
5199
fi
 
5200
 
 
5201
{ $as_echo "$as_me:$LINENO: checking for library containing gethugepagesizes" >&5
 
5202
$as_echo_n "checking for library containing gethugepagesizes... " >&6; }
 
5203
if test "${ac_cv_search_gethugepagesizes+set}" = set; then
 
5204
  $as_echo_n "(cached) " >&6
 
5205
else
 
5206
  ac_func_search_save_LIBS=$LIBS
 
5207
cat >conftest.$ac_ext <<_ACEOF
 
5208
/* confdefs.h.  */
 
5209
_ACEOF
 
5210
cat confdefs.h >>conftest.$ac_ext
 
5211
cat >>conftest.$ac_ext <<_ACEOF
 
5212
/* end confdefs.h.  */
 
5213
 
 
5214
/* Override any GCC internal prototype to avoid an error.
 
5215
   Use char because int might match the return type of a GCC
 
5216
   builtin and then its argument prototype would still apply.  */
 
5217
#ifdef __cplusplus
 
5218
extern "C"
 
5219
#endif
 
5220
char gethugepagesizes ();
 
5221
int
 
5222
main ()
 
5223
{
 
5224
return gethugepagesizes ();
 
5225
  ;
 
5226
  return 0;
 
5227
}
 
5228
_ACEOF
 
5229
for ac_lib in '' hugetlbfs; do
 
5230
  if test -z "$ac_lib"; then
 
5231
    ac_res="none required"
 
5232
  else
 
5233
    ac_res=-l$ac_lib
 
5234
    LIBS="-l$ac_lib  $ac_func_search_save_LIBS"
 
5235
  fi
 
5236
  rm -f conftest.$ac_objext conftest$ac_exeext
 
5237
if { (ac_try="$ac_link"
 
5238
case "(($ac_try" in
 
5239
  *\"* | *\`* | *\\*) ac_try_echo=\$ac_try;;
 
5240
  *) ac_try_echo=$ac_try;;
 
5241
esac
 
5242
eval ac_try_echo="\"\$as_me:$LINENO: $ac_try_echo\""
 
5243
$as_echo "$ac_try_echo") >&5
 
5244
  (eval "$ac_link") 2>conftest.er1
 
5245
  ac_status=$?
 
5246
  grep -v '^ *+' conftest.er1 >conftest.err
 
5247
  rm -f conftest.er1
 
5248
  cat conftest.err >&5
 
5249
  $as_echo "$as_me:$LINENO: \$? = $ac_status" >&5
 
5250
  (exit $ac_status); } && {
 
5251
         test -z "$ac_c_werror_flag" ||
 
5252
         test ! -s conftest.err
 
5253
       } && test -s conftest$ac_exeext && {
 
5254
         test "$cross_compiling" = yes ||
 
5255
         $as_test_x conftest$ac_exeext
 
5256
       }; then
 
5257
  ac_cv_search_gethugepagesizes=$ac_res
 
5258
else
 
5259
  $as_echo "$as_me: failed program was:" >&5
 
5260
sed 's/^/| /' conftest.$ac_ext >&5
 
5261
 
 
5262
 
 
5263
fi
 
5264
 
 
5265
rm -rf conftest.dSYM
 
5266
rm -f core conftest.err conftest.$ac_objext conftest_ipa8_conftest.oo \
 
5267
      conftest$ac_exeext
 
5268
  if test "${ac_cv_search_gethugepagesizes+set}" = set; then
 
5269
  break
 
5270
fi
 
5271
done
 
5272
if test "${ac_cv_search_gethugepagesizes+set}" = set; then
 
5273
  :
 
5274
else
 
5275
  ac_cv_search_gethugepagesizes=no
 
5276
fi
 
5277
rm conftest.$ac_ext
 
5278
LIBS=$ac_func_search_save_LIBS
 
5279
fi
 
5280
{ $as_echo "$as_me:$LINENO: result: $ac_cv_search_gethugepagesizes" >&5
 
5281
$as_echo "$ac_cv_search_gethugepagesizes" >&6; }
 
5282
ac_res=$ac_cv_search_gethugepagesizes
 
5283
if test "$ac_res" != no; then
 
5284
  test "$ac_res" = "none required" || LIBS="$ac_res $LIBS"
 
5285
 
 
5286
fi
4828
5287
 
4829
5288
{ $as_echo "$as_me:$LINENO: checking for ANSI C header files" >&5
4830
5289
$as_echo_n "checking for ANSI C header files... " >&6; }
5414
5873
 
5415
5874
fi
5416
5875
 
5417
 
if test "${ac_cv_header_malloc_h+set}" = set; then
5418
 
  { $as_echo "$as_me:$LINENO: checking for malloc.h" >&5
5419
 
$as_echo_n "checking for malloc.h... " >&6; }
5420
 
if test "${ac_cv_header_malloc_h+set}" = set; then
5421
 
  $as_echo_n "(cached) " >&6
5422
 
fi
5423
 
{ $as_echo "$as_me:$LINENO: result: $ac_cv_header_malloc_h" >&5
5424
 
$as_echo "$ac_cv_header_malloc_h" >&6; }
5425
 
else
5426
 
  # Is the header compilable?
5427
 
{ $as_echo "$as_me:$LINENO: checking malloc.h usability" >&5
5428
 
$as_echo_n "checking malloc.h usability... " >&6; }
5429
 
cat >conftest.$ac_ext <<_ACEOF
5430
 
/* confdefs.h.  */
5431
 
_ACEOF
5432
 
cat confdefs.h >>conftest.$ac_ext
5433
 
cat >>conftest.$ac_ext <<_ACEOF
5434
 
/* end confdefs.h.  */
5435
 
$ac_includes_default
5436
 
#include <malloc.h>
5437
 
_ACEOF
5438
 
rm -f conftest.$ac_objext
5439
 
if { (ac_try="$ac_compile"
5440
 
case "(($ac_try" in
5441
 
  *\"* | *\`* | *\\*) ac_try_echo=\$ac_try;;
5442
 
  *) ac_try_echo=$ac_try;;
5443
 
esac
5444
 
eval ac_try_echo="\"\$as_me:$LINENO: $ac_try_echo\""
5445
 
$as_echo "$ac_try_echo") >&5
5446
 
  (eval "$ac_compile") 2>conftest.er1
5447
 
  ac_status=$?
5448
 
  grep -v '^ *+' conftest.er1 >conftest.err
5449
 
  rm -f conftest.er1
5450
 
  cat conftest.err >&5
5451
 
  $as_echo "$as_me:$LINENO: \$? = $ac_status" >&5
5452
 
  (exit $ac_status); } && {
5453
 
         test -z "$ac_c_werror_flag" ||
5454
 
         test ! -s conftest.err
5455
 
       } && test -s conftest.$ac_objext; then
5456
 
  ac_header_compiler=yes
5457
 
else
5458
 
  $as_echo "$as_me: failed program was:" >&5
5459
 
sed 's/^/| /' conftest.$ac_ext >&5
5460
 
 
5461
 
        ac_header_compiler=no
5462
 
fi
5463
 
 
5464
 
rm -f core conftest.err conftest.$ac_objext conftest.$ac_ext
5465
 
{ $as_echo "$as_me:$LINENO: result: $ac_header_compiler" >&5
5466
 
$as_echo "$ac_header_compiler" >&6; }
5467
 
 
5468
 
# Is the header present?
5469
 
{ $as_echo "$as_me:$LINENO: checking malloc.h presence" >&5
5470
 
$as_echo_n "checking malloc.h presence... " >&6; }
5471
 
cat >conftest.$ac_ext <<_ACEOF
5472
 
/* confdefs.h.  */
5473
 
_ACEOF
5474
 
cat confdefs.h >>conftest.$ac_ext
5475
 
cat >>conftest.$ac_ext <<_ACEOF
5476
 
/* end confdefs.h.  */
5477
 
#include <malloc.h>
5478
 
_ACEOF
5479
 
if { (ac_try="$ac_cpp conftest.$ac_ext"
5480
 
case "(($ac_try" in
5481
 
  *\"* | *\`* | *\\*) ac_try_echo=\$ac_try;;
5482
 
  *) ac_try_echo=$ac_try;;
5483
 
esac
5484
 
eval ac_try_echo="\"\$as_me:$LINENO: $ac_try_echo\""
5485
 
$as_echo "$ac_try_echo") >&5
5486
 
  (eval "$ac_cpp conftest.$ac_ext") 2>conftest.er1
5487
 
  ac_status=$?
5488
 
  grep -v '^ *+' conftest.er1 >conftest.err
5489
 
  rm -f conftest.er1
5490
 
  cat conftest.err >&5
5491
 
  $as_echo "$as_me:$LINENO: \$? = $ac_status" >&5
5492
 
  (exit $ac_status); } >/dev/null && {
5493
 
         test -z "$ac_c_preproc_warn_flag$ac_c_werror_flag" ||
5494
 
         test ! -s conftest.err
5495
 
       }; then
5496
 
  ac_header_preproc=yes
5497
 
else
5498
 
  $as_echo "$as_me: failed program was:" >&5
5499
 
sed 's/^/| /' conftest.$ac_ext >&5
5500
 
 
5501
 
  ac_header_preproc=no
5502
 
fi
5503
 
 
5504
 
rm -f conftest.err conftest.$ac_ext
5505
 
{ $as_echo "$as_me:$LINENO: result: $ac_header_preproc" >&5
5506
 
$as_echo "$ac_header_preproc" >&6; }
5507
 
 
5508
 
# So?  What about this header?
5509
 
case $ac_header_compiler:$ac_header_preproc:$ac_c_preproc_warn_flag in
5510
 
  yes:no: )
5511
 
    { $as_echo "$as_me:$LINENO: WARNING: malloc.h: accepted by the compiler, rejected by the preprocessor!" >&5
5512
 
$as_echo "$as_me: WARNING: malloc.h: accepted by the compiler, rejected by the preprocessor!" >&2;}
5513
 
    { $as_echo "$as_me:$LINENO: WARNING: malloc.h: proceeding with the compiler's result" >&5
5514
 
$as_echo "$as_me: WARNING: malloc.h: proceeding with the compiler's result" >&2;}
5515
 
    ac_header_preproc=yes
5516
 
    ;;
5517
 
  no:yes:* )
5518
 
    { $as_echo "$as_me:$LINENO: WARNING: malloc.h: present but cannot be compiled" >&5
5519
 
$as_echo "$as_me: WARNING: malloc.h: present but cannot be compiled" >&2;}
5520
 
    { $as_echo "$as_me:$LINENO: WARNING: malloc.h:     check for missing prerequisite headers?" >&5
5521
 
$as_echo "$as_me: WARNING: malloc.h:     check for missing prerequisite headers?" >&2;}
5522
 
    { $as_echo "$as_me:$LINENO: WARNING: malloc.h: see the Autoconf documentation" >&5
5523
 
$as_echo "$as_me: WARNING: malloc.h: see the Autoconf documentation" >&2;}
5524
 
    { $as_echo "$as_me:$LINENO: WARNING: malloc.h:     section \"Present But Cannot Be Compiled\"" >&5
5525
 
$as_echo "$as_me: WARNING: malloc.h:     section \"Present But Cannot Be Compiled\"" >&2;}
5526
 
    { $as_echo "$as_me:$LINENO: WARNING: malloc.h: proceeding with the preprocessor's result" >&5
5527
 
$as_echo "$as_me: WARNING: malloc.h: proceeding with the preprocessor's result" >&2;}
5528
 
    { $as_echo "$as_me:$LINENO: WARNING: malloc.h: in the future, the compiler will take precedence" >&5
5529
 
$as_echo "$as_me: WARNING: malloc.h: in the future, the compiler will take precedence" >&2;}
5530
 
    ( cat <<\_ASBOX
5531
 
## ----------------------------- ##
5532
 
## Report this to brad@danga.com ##
5533
 
## ----------------------------- ##
5534
 
_ASBOX
5535
 
     ) | sed "s/^/$as_me: WARNING:     /" >&2
5536
 
    ;;
5537
 
esac
5538
 
{ $as_echo "$as_me:$LINENO: checking for malloc.h" >&5
5539
 
$as_echo_n "checking for malloc.h... " >&6; }
5540
 
if test "${ac_cv_header_malloc_h+set}" = set; then
5541
 
  $as_echo_n "(cached) " >&6
5542
 
else
5543
 
  ac_cv_header_malloc_h=$ac_header_preproc
5544
 
fi
5545
 
{ $as_echo "$as_me:$LINENO: result: $ac_cv_header_malloc_h" >&5
5546
 
$as_echo "$ac_cv_header_malloc_h" >&6; }
5547
 
 
5548
 
fi
5549
 
if test "x$ac_cv_header_malloc_h" = x""yes; then
5550
 
 
5551
 
cat >>confdefs.h <<\_ACEOF
5552
 
#define HAVE_MALLOC_H /**/
5553
 
_ACEOF
5554
 
 
5555
 
fi
5556
 
 
5557
 
 
5558
 
{ $as_echo "$as_me:$LINENO: checking for struct mallinfo.arena" >&5
5559
 
$as_echo_n "checking for struct mallinfo.arena... " >&6; }
5560
 
if test "${ac_cv_member_struct_mallinfo_arena+set}" = set; then
5561
 
  $as_echo_n "(cached) " >&6
5562
 
else
5563
 
  cat >conftest.$ac_ext <<_ACEOF
5564
 
/* confdefs.h.  */
5565
 
_ACEOF
5566
 
cat confdefs.h >>conftest.$ac_ext
5567
 
cat >>conftest.$ac_ext <<_ACEOF
5568
 
/* end confdefs.h.  */
5569
 
 
5570
 
#    include <malloc.h>
5571
 
 
5572
 
 
5573
 
 
5574
 
int
5575
 
main ()
5576
 
{
5577
 
static struct mallinfo ac_aggr;
5578
 
if (ac_aggr.arena)
5579
 
return 0;
5580
 
  ;
5581
 
  return 0;
5582
 
}
5583
 
_ACEOF
5584
 
rm -f conftest.$ac_objext
5585
 
if { (ac_try="$ac_compile"
5586
 
case "(($ac_try" in
5587
 
  *\"* | *\`* | *\\*) ac_try_echo=\$ac_try;;
5588
 
  *) ac_try_echo=$ac_try;;
5589
 
esac
5590
 
eval ac_try_echo="\"\$as_me:$LINENO: $ac_try_echo\""
5591
 
$as_echo "$ac_try_echo") >&5
5592
 
  (eval "$ac_compile") 2>conftest.er1
5593
 
  ac_status=$?
5594
 
  grep -v '^ *+' conftest.er1 >conftest.err
5595
 
  rm -f conftest.er1
5596
 
  cat conftest.err >&5
5597
 
  $as_echo "$as_me:$LINENO: \$? = $ac_status" >&5
5598
 
  (exit $ac_status); } && {
5599
 
         test -z "$ac_c_werror_flag" ||
5600
 
         test ! -s conftest.err
5601
 
       } && test -s conftest.$ac_objext; then
5602
 
  ac_cv_member_struct_mallinfo_arena=yes
5603
 
else
5604
 
  $as_echo "$as_me: failed program was:" >&5
5605
 
sed 's/^/| /' conftest.$ac_ext >&5
5606
 
 
5607
 
        cat >conftest.$ac_ext <<_ACEOF
5608
 
/* confdefs.h.  */
5609
 
_ACEOF
5610
 
cat confdefs.h >>conftest.$ac_ext
5611
 
cat >>conftest.$ac_ext <<_ACEOF
5612
 
/* end confdefs.h.  */
5613
 
 
5614
 
#    include <malloc.h>
5615
 
 
5616
 
 
5617
 
 
5618
 
int
5619
 
main ()
5620
 
{
5621
 
static struct mallinfo ac_aggr;
5622
 
if (sizeof ac_aggr.arena)
5623
 
return 0;
5624
 
  ;
5625
 
  return 0;
5626
 
}
5627
 
_ACEOF
5628
 
rm -f conftest.$ac_objext
5629
 
if { (ac_try="$ac_compile"
5630
 
case "(($ac_try" in
5631
 
  *\"* | *\`* | *\\*) ac_try_echo=\$ac_try;;
5632
 
  *) ac_try_echo=$ac_try;;
5633
 
esac
5634
 
eval ac_try_echo="\"\$as_me:$LINENO: $ac_try_echo\""
5635
 
$as_echo "$ac_try_echo") >&5
5636
 
  (eval "$ac_compile") 2>conftest.er1
5637
 
  ac_status=$?
5638
 
  grep -v '^ *+' conftest.er1 >conftest.err
5639
 
  rm -f conftest.er1
5640
 
  cat conftest.err >&5
5641
 
  $as_echo "$as_me:$LINENO: \$? = $ac_status" >&5
5642
 
  (exit $ac_status); } && {
5643
 
         test -z "$ac_c_werror_flag" ||
5644
 
         test ! -s conftest.err
5645
 
       } && test -s conftest.$ac_objext; then
5646
 
  ac_cv_member_struct_mallinfo_arena=yes
5647
 
else
5648
 
  $as_echo "$as_me: failed program was:" >&5
5649
 
sed 's/^/| /' conftest.$ac_ext >&5
5650
 
 
5651
 
        ac_cv_member_struct_mallinfo_arena=no
5652
 
fi
5653
 
 
5654
 
rm -f core conftest.err conftest.$ac_objext conftest.$ac_ext
5655
 
fi
5656
 
 
5657
 
rm -f core conftest.err conftest.$ac_objext conftest.$ac_ext
5658
 
fi
5659
 
{ $as_echo "$as_me:$LINENO: result: $ac_cv_member_struct_mallinfo_arena" >&5
5660
 
$as_echo "$ac_cv_member_struct_mallinfo_arena" >&6; }
5661
 
if test "x$ac_cv_member_struct_mallinfo_arena" = x""yes; then
5662
 
 
5663
 
 
5664
 
cat >>confdefs.h <<\_ACEOF
5665
 
#define HAVE_STRUCT_MALLINFO /**/
5666
 
_ACEOF
5667
 
 
5668
 
 
5669
 
fi
5670
 
 
5671
5876
 
5672
5877
 
5673
5878
 
5837
6042
fi
5838
6043
 
5839
6044
 
5840
 
# Check whether --enable-threads was given.
5841
 
if test "${enable_threads+set}" = set; then
5842
 
  enableval=$enable_threads;
5843
 
fi
5844
 
 
5845
 
if test "x$enable_threads" == "xyes"; then
5846
 
  { $as_echo "$as_me:$LINENO: checking for library containing pthread_create" >&5
 
6045
 
 
6046
 
 
6047
 
 
6048
    { $as_echo "$as_me:$LINENO: checking for htonll" >&5
 
6049
$as_echo_n "checking for htonll... " >&6; }
 
6050
    have_htoll="no"
 
6051
    if test "$cross_compiling" = yes; then
 
6052
  { { $as_echo "$as_me:$LINENO: error: in \`$ac_pwd':" >&5
 
6053
$as_echo "$as_me: error: in \`$ac_pwd':" >&2;}
 
6054
{ { $as_echo "$as_me:$LINENO: error: cannot run test program while cross compiling
 
6055
See \`config.log' for more details." >&5
 
6056
$as_echo "$as_me: error: cannot run test program while cross compiling
 
6057
See \`config.log' for more details." >&2;}
 
6058
   { (exit 1); exit 1; }; }; }
 
6059
else
 
6060
  cat >conftest.$ac_ext <<_ACEOF
 
6061
 
 
6062
       /* confdefs.h.  */
 
6063
_ACEOF
 
6064
cat confdefs.h >>conftest.$ac_ext
 
6065
cat >>conftest.$ac_ext <<_ACEOF
 
6066
/* end confdefs.h.  */
 
6067
 
 
6068
#include <sys/types.h>
 
6069
#include <netinet/in.h>
 
6070
#include <inttypes.h>
 
6071
 
 
6072
int
 
6073
main ()
 
6074
{
 
6075
 
 
6076
          return htonll(0);
 
6077
 
 
6078
  ;
 
6079
  return 0;
 
6080
}
 
6081
 
 
6082
_ACEOF
 
6083
rm -f conftest$ac_exeext
 
6084
if { (ac_try="$ac_link"
 
6085
case "(($ac_try" in
 
6086
  *\"* | *\`* | *\\*) ac_try_echo=\$ac_try;;
 
6087
  *) ac_try_echo=$ac_try;;
 
6088
esac
 
6089
eval ac_try_echo="\"\$as_me:$LINENO: $ac_try_echo\""
 
6090
$as_echo "$ac_try_echo") >&5
 
6091
  (eval "$ac_link") 2>&5
 
6092
  ac_status=$?
 
6093
  $as_echo "$as_me:$LINENO: \$? = $ac_status" >&5
 
6094
  (exit $ac_status); } && { ac_try='./conftest$ac_exeext'
 
6095
  { (case "(($ac_try" in
 
6096
  *\"* | *\`* | *\\*) ac_try_echo=\$ac_try;;
 
6097
  *) ac_try_echo=$ac_try;;
 
6098
esac
 
6099
eval ac_try_echo="\"\$as_me:$LINENO: $ac_try_echo\""
 
6100
$as_echo "$ac_try_echo") >&5
 
6101
  (eval "$ac_try") 2>&5
 
6102
  ac_status=$?
 
6103
  $as_echo "$as_me:$LINENO: \$? = $ac_status" >&5
 
6104
  (exit $ac_status); }; }; then
 
6105
 
 
6106
      have_htoll="yes"
 
6107
 
 
6108
cat >>confdefs.h <<\_ACEOF
 
6109
#define HAVE_HTONLL 1
 
6110
_ACEOF
 
6111
 
 
6112
 
 
6113
else
 
6114
  $as_echo "$as_me: program exited with status $ac_status" >&5
 
6115
$as_echo "$as_me: failed program was:" >&5
 
6116
sed 's/^/| /' conftest.$ac_ext >&5
 
6117
 
 
6118
fi
 
6119
rm -rf conftest.dSYM
 
6120
rm -f core *.core core.conftest.* gmon.out bb.out conftest$ac_exeext conftest.$ac_objext conftest.$ac_ext
 
6121
fi
 
6122
 
 
6123
 
 
6124
 
 
6125
    { $as_echo "$as_me:$LINENO: result: $have_htoll" >&5
 
6126
$as_echo "$have_htoll" >&6; }
 
6127
 
 
6128
 
 
6129
{ $as_echo "$as_me:$LINENO: checking for library containing pthread_create" >&5
5847
6130
$as_echo_n "checking for library containing pthread_create... " >&6; }
5848
6131
if test "${ac_cv_search_pthread_create+set}" = set; then
5849
6132
  $as_echo_n "(cached) " >&6
5930
6213
 
5931
6214
fi
5932
6215
 
5933
 
  if test "x$ac_cv_search_pthread_create" != "xno"; then
5934
 
 
5935
 
cat >>confdefs.h <<\_ACEOF
5936
 
#define USE_THREADS /**/
5937
 
_ACEOF
5938
 
 
5939
 
        if test "$cross_compiling" = yes; then
5940
 
  { { $as_echo "$as_me:$LINENO: error: in \`$ac_pwd':" >&5
5941
 
$as_echo "$as_me: error: in \`$ac_pwd':" >&2;}
5942
 
{ { $as_echo "$as_me:$LINENO: error: cannot run test program while cross compiling
5943
 
See \`config.log' for more details." >&5
5944
 
$as_echo "$as_me: error: cannot run test program while cross compiling
5945
 
See \`config.log' for more details." >&2;}
5946
 
   { (exit 1); exit 1; }; }; }
5947
 
else
5948
 
  cat >conftest.$ac_ext <<_ACEOF
5949
 
/* confdefs.h.  */
5950
 
_ACEOF
5951
 
cat confdefs.h >>conftest.$ac_ext
5952
 
cat >>conftest.$ac_ext <<_ACEOF
5953
 
/* end confdefs.h.  */
5954
 
 
5955
 
int
5956
 
main ()
5957
 
{
5958
 
#ifdef __SUNPRO_C
5959
 
   return 0;
5960
 
#else
5961
 
   return 1;
5962
 
#endif
5963
 
 
5964
 
  ;
5965
 
  return 0;
5966
 
}
5967
 
 
5968
 
_ACEOF
5969
 
rm -f conftest$ac_exeext
5970
 
if { (ac_try="$ac_link"
5971
 
case "(($ac_try" in
5972
 
  *\"* | *\`* | *\\*) ac_try_echo=\$ac_try;;
5973
 
  *) ac_try_echo=$ac_try;;
5974
 
esac
5975
 
eval ac_try_echo="\"\$as_me:$LINENO: $ac_try_echo\""
5976
 
$as_echo "$ac_try_echo") >&5
5977
 
  (eval "$ac_link") 2>&5
5978
 
  ac_status=$?
5979
 
  $as_echo "$as_me:$LINENO: \$? = $ac_status" >&5
5980
 
  (exit $ac_status); } && { ac_try='./conftest$ac_exeext'
5981
 
  { (case "(($ac_try" in
5982
 
  *\"* | *\`* | *\\*) ac_try_echo=\$ac_try;;
5983
 
  *) ac_try_echo=$ac_try;;
5984
 
esac
5985
 
eval ac_try_echo="\"\$as_me:$LINENO: $ac_try_echo\""
5986
 
$as_echo "$ac_try_echo") >&5
5987
 
  (eval "$ac_try") 2>&5
5988
 
  ac_status=$?
5989
 
  $as_echo "$as_me:$LINENO: \$? = $ac_status" >&5
5990
 
  (exit $ac_status); }; }; then
5991
 
 
5992
 
      CFLAGS="-mt $CFLAGS"
5993
 
 
5994
 
else
5995
 
  $as_echo "$as_me: program exited with status $ac_status" >&5
5996
 
$as_echo "$as_me: failed program was:" >&5
5997
 
sed 's/^/| /' conftest.$ac_ext >&5
5998
 
 
5999
 
fi
6000
 
rm -rf conftest.dSYM
6001
 
rm -f core *.core core.conftest.* gmon.out bb.out conftest$ac_exeext conftest.$ac_objext conftest.$ac_ext
6002
 
fi
6003
 
 
6004
 
 
6005
 
  else
6006
 
    { { $as_echo "$as_me:$LINENO: error: Can't enable threads without the POSIX thread library." >&5
 
6216
if test "x$ac_cv_search_pthread_create" == "xno"; then
 
6217
  { { $as_echo "$as_me:$LINENO: error: Can't enable threads without the POSIX thread library." >&5
6007
6218
$as_echo "$as_me: error: Can't enable threads without the POSIX thread library." >&2;}
6008
6219
   { (exit 1); exit 1; }; }
6009
 
  fi
6010
6220
fi
6011
6221
 
6012
6222
 
6313
6523
done
6314
6524
 
6315
6525
 
 
6526
for ac_func in sigignore
 
6527
do
 
6528
as_ac_var=`$as_echo "ac_cv_func_$ac_func" | $as_tr_sh`
 
6529
{ $as_echo "$as_me:$LINENO: checking for $ac_func" >&5
 
6530
$as_echo_n "checking for $ac_func... " >&6; }
 
6531
if { as_var=$as_ac_var; eval "test \"\${$as_var+set}\" = set"; }; then
 
6532
  $as_echo_n "(cached) " >&6
 
6533
else
 
6534
  cat >conftest.$ac_ext <<_ACEOF
 
6535
/* confdefs.h.  */
 
6536
_ACEOF
 
6537
cat confdefs.h >>conftest.$ac_ext
 
6538
cat >>conftest.$ac_ext <<_ACEOF
 
6539
/* end confdefs.h.  */
 
6540
/* Define $ac_func to an innocuous variant, in case <limits.h> declares $ac_func.
 
6541
   For example, HP-UX 11i <limits.h> declares gettimeofday.  */
 
6542
#define $ac_func innocuous_$ac_func
 
6543
 
 
6544
/* System header to define __stub macros and hopefully few prototypes,
 
6545
    which can conflict with char $ac_func (); below.
 
6546
    Prefer <limits.h> to <assert.h> if __STDC__ is defined, since
 
6547
    <limits.h> exists even on freestanding compilers.  */
 
6548
 
 
6549
#ifdef __STDC__
 
6550
# include <limits.h>
 
6551
#else
 
6552
# include <assert.h>
 
6553
#endif
 
6554
 
 
6555
#undef $ac_func
 
6556
 
 
6557
/* Override any GCC internal prototype to avoid an error.
 
6558
   Use char because int might match the return type of a GCC
 
6559
   builtin and then its argument prototype would still apply.  */
 
6560
#ifdef __cplusplus
 
6561
extern "C"
 
6562
#endif
 
6563
char $ac_func ();
 
6564
/* The GNU C library defines this for functions which it implements
 
6565
    to always fail with ENOSYS.  Some functions are actually named
 
6566
    something starting with __ and the normal name is an alias.  */
 
6567
#if defined __stub_$ac_func || defined __stub___$ac_func
 
6568
choke me
 
6569
#endif
 
6570
 
 
6571
int
 
6572
main ()
 
6573
{
 
6574
return $ac_func ();
 
6575
  ;
 
6576
  return 0;
 
6577
}
 
6578
_ACEOF
 
6579
rm -f conftest.$ac_objext conftest$ac_exeext
 
6580
if { (ac_try="$ac_link"
 
6581
case "(($ac_try" in
 
6582
  *\"* | *\`* | *\\*) ac_try_echo=\$ac_try;;
 
6583
  *) ac_try_echo=$ac_try;;
 
6584
esac
 
6585
eval ac_try_echo="\"\$as_me:$LINENO: $ac_try_echo\""
 
6586
$as_echo "$ac_try_echo") >&5
 
6587
  (eval "$ac_link") 2>conftest.er1
 
6588
  ac_status=$?
 
6589
  grep -v '^ *+' conftest.er1 >conftest.err
 
6590
  rm -f conftest.er1
 
6591
  cat conftest.err >&5
 
6592
  $as_echo "$as_me:$LINENO: \$? = $ac_status" >&5
 
6593
  (exit $ac_status); } && {
 
6594
         test -z "$ac_c_werror_flag" ||
 
6595
         test ! -s conftest.err
 
6596
       } && test -s conftest$ac_exeext && {
 
6597
         test "$cross_compiling" = yes ||
 
6598
         $as_test_x conftest$ac_exeext
 
6599
       }; then
 
6600
  eval "$as_ac_var=yes"
 
6601
else
 
6602
  $as_echo "$as_me: failed program was:" >&5
 
6603
sed 's/^/| /' conftest.$ac_ext >&5
 
6604
 
 
6605
        eval "$as_ac_var=no"
 
6606
fi
 
6607
 
 
6608
rm -rf conftest.dSYM
 
6609
rm -f core conftest.err conftest.$ac_objext conftest_ipa8_conftest.oo \
 
6610
      conftest$ac_exeext conftest.$ac_ext
 
6611
fi
 
6612
ac_res=`eval 'as_val=${'$as_ac_var'}
 
6613
                 $as_echo "$as_val"'`
 
6614
               { $as_echo "$as_me:$LINENO: result: $ac_res" >&5
 
6615
$as_echo "$ac_res" >&6; }
 
6616
as_val=`eval 'as_val=${'$as_ac_var'}
 
6617
                 $as_echo "$as_val"'`
 
6618
   if test "x$as_val" = x""yes; then
 
6619
  cat >>confdefs.h <<_ACEOF
 
6620
#define `$as_echo "HAVE_$ac_func" | $as_tr_cpp` 1
 
6621
_ACEOF
 
6622
 
 
6623
fi
 
6624
done
 
6625
 
 
6626
 
 
6627
 
 
6628
 
 
6629
{ $as_echo "$as_me:$LINENO: checking for alignment" >&5
 
6630
$as_echo_n "checking for alignment... " >&6; }
 
6631
if test "${ac_cv_c_alignment+set}" = set; then
 
6632
  $as_echo_n "(cached) " >&6
 
6633
else
 
6634
 
 
6635
  if test "$cross_compiling" = yes; then
 
6636
  { { $as_echo "$as_me:$LINENO: error: in \`$ac_pwd':" >&5
 
6637
$as_echo "$as_me: error: in \`$ac_pwd':" >&2;}
 
6638
{ { $as_echo "$as_me:$LINENO: error: cannot run test program while cross compiling
 
6639
See \`config.log' for more details." >&5
 
6640
$as_echo "$as_me: error: cannot run test program while cross compiling
 
6641
See \`config.log' for more details." >&2;}
 
6642
   { (exit 1); exit 1; }; }; }
 
6643
else
 
6644
  cat >conftest.$ac_ext <<_ACEOF
 
6645
/* confdefs.h.  */
 
6646
_ACEOF
 
6647
cat confdefs.h >>conftest.$ac_ext
 
6648
cat >>conftest.$ac_ext <<_ACEOF
 
6649
/* end confdefs.h.  */
 
6650
 
 
6651
#include <stdlib.h>
 
6652
#include <inttypes.h>
 
6653
 
 
6654
int
 
6655
main ()
 
6656
{
 
6657
 
 
6658
       char *buf = malloc(32);
 
6659
       uint64_t *ptr = (uint64_t*)(buf+2);
 
6660
       *ptr = 0x1;
 
6661
       return 0;
 
6662
 
 
6663
  ;
 
6664
  return 0;
 
6665
}
 
6666
 
 
6667
_ACEOF
 
6668
rm -f conftest$ac_exeext
 
6669
if { (ac_try="$ac_link"
 
6670
case "(($ac_try" in
 
6671
  *\"* | *\`* | *\\*) ac_try_echo=\$ac_try;;
 
6672
  *) ac_try_echo=$ac_try;;
 
6673
esac
 
6674
eval ac_try_echo="\"\$as_me:$LINENO: $ac_try_echo\""
 
6675
$as_echo "$ac_try_echo") >&5
 
6676
  (eval "$ac_link") 2>&5
 
6677
  ac_status=$?
 
6678
  $as_echo "$as_me:$LINENO: \$? = $ac_status" >&5
 
6679
  (exit $ac_status); } && { ac_try='./conftest$ac_exeext'
 
6680
  { (case "(($ac_try" in
 
6681
  *\"* | *\`* | *\\*) ac_try_echo=\$ac_try;;
 
6682
  *) ac_try_echo=$ac_try;;
 
6683
esac
 
6684
eval ac_try_echo="\"\$as_me:$LINENO: $ac_try_echo\""
 
6685
$as_echo "$ac_try_echo") >&5
 
6686
  (eval "$ac_try") 2>&5
 
6687
  ac_status=$?
 
6688
  $as_echo "$as_me:$LINENO: \$? = $ac_status" >&5
 
6689
  (exit $ac_status); }; }; then
 
6690
 
 
6691
    ac_cv_c_alignment=none
 
6692
 
 
6693
else
 
6694
  $as_echo "$as_me: program exited with status $ac_status" >&5
 
6695
$as_echo "$as_me: failed program was:" >&5
 
6696
sed 's/^/| /' conftest.$ac_ext >&5
 
6697
 
 
6698
( exit $ac_status )
 
6699
 
 
6700
    ac_cv_c_alignment=need
 
6701
 
 
6702
fi
 
6703
rm -rf conftest.dSYM
 
6704
rm -f core *.core core.conftest.* gmon.out bb.out conftest$ac_exeext conftest.$ac_objext conftest.$ac_ext
 
6705
fi
 
6706
 
 
6707
 
 
6708
 
 
6709
fi
 
6710
{ $as_echo "$as_me:$LINENO: result: $ac_cv_c_alignment" >&5
 
6711
$as_echo "$ac_cv_c_alignment" >&6; }
 
6712
if test $ac_cv_c_alignment = need; then
 
6713
 
 
6714
cat >>confdefs.h <<\_ACEOF
 
6715
#define NEED_ALIGN 1
 
6716
_ACEOF
 
6717
 
 
6718
fi
 
6719
 
 
6720
 
 
6721
 
 
6722
for ac_func in setppriv
 
6723
do
 
6724
as_ac_var=`$as_echo "ac_cv_func_$ac_func" | $as_tr_sh`
 
6725
{ $as_echo "$as_me:$LINENO: checking for $ac_func" >&5
 
6726
$as_echo_n "checking for $ac_func... " >&6; }
 
6727
if { as_var=$as_ac_var; eval "test \"\${$as_var+set}\" = set"; }; then
 
6728
  $as_echo_n "(cached) " >&6
 
6729
else
 
6730
  cat >conftest.$ac_ext <<_ACEOF
 
6731
/* confdefs.h.  */
 
6732
_ACEOF
 
6733
cat confdefs.h >>conftest.$ac_ext
 
6734
cat >>conftest.$ac_ext <<_ACEOF
 
6735
/* end confdefs.h.  */
 
6736
/* Define $ac_func to an innocuous variant, in case <limits.h> declares $ac_func.
 
6737
   For example, HP-UX 11i <limits.h> declares gettimeofday.  */
 
6738
#define $ac_func innocuous_$ac_func
 
6739
 
 
6740
/* System header to define __stub macros and hopefully few prototypes,
 
6741
    which can conflict with char $ac_func (); below.
 
6742
    Prefer <limits.h> to <assert.h> if __STDC__ is defined, since
 
6743
    <limits.h> exists even on freestanding compilers.  */
 
6744
 
 
6745
#ifdef __STDC__
 
6746
# include <limits.h>
 
6747
#else
 
6748
# include <assert.h>
 
6749
#endif
 
6750
 
 
6751
#undef $ac_func
 
6752
 
 
6753
/* Override any GCC internal prototype to avoid an error.
 
6754
   Use char because int might match the return type of a GCC
 
6755
   builtin and then its argument prototype would still apply.  */
 
6756
#ifdef __cplusplus
 
6757
extern "C"
 
6758
#endif
 
6759
char $ac_func ();
 
6760
/* The GNU C library defines this for functions which it implements
 
6761
    to always fail with ENOSYS.  Some functions are actually named
 
6762
    something starting with __ and the normal name is an alias.  */
 
6763
#if defined __stub_$ac_func || defined __stub___$ac_func
 
6764
choke me
 
6765
#endif
 
6766
 
 
6767
int
 
6768
main ()
 
6769
{
 
6770
return $ac_func ();
 
6771
  ;
 
6772
  return 0;
 
6773
}
 
6774
_ACEOF
 
6775
rm -f conftest.$ac_objext conftest$ac_exeext
 
6776
if { (ac_try="$ac_link"
 
6777
case "(($ac_try" in
 
6778
  *\"* | *\`* | *\\*) ac_try_echo=\$ac_try;;
 
6779
  *) ac_try_echo=$ac_try;;
 
6780
esac
 
6781
eval ac_try_echo="\"\$as_me:$LINENO: $ac_try_echo\""
 
6782
$as_echo "$ac_try_echo") >&5
 
6783
  (eval "$ac_link") 2>conftest.er1
 
6784
  ac_status=$?
 
6785
  grep -v '^ *+' conftest.er1 >conftest.err
 
6786
  rm -f conftest.er1
 
6787
  cat conftest.err >&5
 
6788
  $as_echo "$as_me:$LINENO: \$? = $ac_status" >&5
 
6789
  (exit $ac_status); } && {
 
6790
         test -z "$ac_c_werror_flag" ||
 
6791
         test ! -s conftest.err
 
6792
       } && test -s conftest$ac_exeext && {
 
6793
         test "$cross_compiling" = yes ||
 
6794
         $as_test_x conftest$ac_exeext
 
6795
       }; then
 
6796
  eval "$as_ac_var=yes"
 
6797
else
 
6798
  $as_echo "$as_me: failed program was:" >&5
 
6799
sed 's/^/| /' conftest.$ac_ext >&5
 
6800
 
 
6801
        eval "$as_ac_var=no"
 
6802
fi
 
6803
 
 
6804
rm -rf conftest.dSYM
 
6805
rm -f core conftest.err conftest.$ac_objext conftest_ipa8_conftest.oo \
 
6806
      conftest$ac_exeext conftest.$ac_ext
 
6807
fi
 
6808
ac_res=`eval 'as_val=${'$as_ac_var'}
 
6809
                 $as_echo "$as_val"'`
 
6810
               { $as_echo "$as_me:$LINENO: result: $ac_res" >&5
 
6811
$as_echo "$ac_res" >&6; }
 
6812
as_val=`eval 'as_val=${'$as_ac_var'}
 
6813
                 $as_echo "$as_val"'`
 
6814
   if test "x$as_val" = x""yes; then
 
6815
  cat >>confdefs.h <<_ACEOF
 
6816
#define `$as_echo "HAVE_$ac_func" | $as_tr_cpp` 1
 
6817
_ACEOF
 
6818
 
 
6819
   if test "${ac_cv_header_priv_h+set}" = set; then
 
6820
  { $as_echo "$as_me:$LINENO: checking for priv.h" >&5
 
6821
$as_echo_n "checking for priv.h... " >&6; }
 
6822
if test "${ac_cv_header_priv_h+set}" = set; then
 
6823
  $as_echo_n "(cached) " >&6
 
6824
fi
 
6825
{ $as_echo "$as_me:$LINENO: result: $ac_cv_header_priv_h" >&5
 
6826
$as_echo "$ac_cv_header_priv_h" >&6; }
 
6827
else
 
6828
  # Is the header compilable?
 
6829
{ $as_echo "$as_me:$LINENO: checking priv.h usability" >&5
 
6830
$as_echo_n "checking priv.h usability... " >&6; }
 
6831
cat >conftest.$ac_ext <<_ACEOF
 
6832
/* confdefs.h.  */
 
6833
_ACEOF
 
6834
cat confdefs.h >>conftest.$ac_ext
 
6835
cat >>conftest.$ac_ext <<_ACEOF
 
6836
/* end confdefs.h.  */
 
6837
$ac_includes_default
 
6838
#include <priv.h>
 
6839
_ACEOF
 
6840
rm -f conftest.$ac_objext
 
6841
if { (ac_try="$ac_compile"
 
6842
case "(($ac_try" in
 
6843
  *\"* | *\`* | *\\*) ac_try_echo=\$ac_try;;
 
6844
  *) ac_try_echo=$ac_try;;
 
6845
esac
 
6846
eval ac_try_echo="\"\$as_me:$LINENO: $ac_try_echo\""
 
6847
$as_echo "$ac_try_echo") >&5
 
6848
  (eval "$ac_compile") 2>conftest.er1
 
6849
  ac_status=$?
 
6850
  grep -v '^ *+' conftest.er1 >conftest.err
 
6851
  rm -f conftest.er1
 
6852
  cat conftest.err >&5
 
6853
  $as_echo "$as_me:$LINENO: \$? = $ac_status" >&5
 
6854
  (exit $ac_status); } && {
 
6855
         test -z "$ac_c_werror_flag" ||
 
6856
         test ! -s conftest.err
 
6857
       } && test -s conftest.$ac_objext; then
 
6858
  ac_header_compiler=yes
 
6859
else
 
6860
  $as_echo "$as_me: failed program was:" >&5
 
6861
sed 's/^/| /' conftest.$ac_ext >&5
 
6862
 
 
6863
        ac_header_compiler=no
 
6864
fi
 
6865
 
 
6866
rm -f core conftest.err conftest.$ac_objext conftest.$ac_ext
 
6867
{ $as_echo "$as_me:$LINENO: result: $ac_header_compiler" >&5
 
6868
$as_echo "$ac_header_compiler" >&6; }
 
6869
 
 
6870
# Is the header present?
 
6871
{ $as_echo "$as_me:$LINENO: checking priv.h presence" >&5
 
6872
$as_echo_n "checking priv.h presence... " >&6; }
 
6873
cat >conftest.$ac_ext <<_ACEOF
 
6874
/* confdefs.h.  */
 
6875
_ACEOF
 
6876
cat confdefs.h >>conftest.$ac_ext
 
6877
cat >>conftest.$ac_ext <<_ACEOF
 
6878
/* end confdefs.h.  */
 
6879
#include <priv.h>
 
6880
_ACEOF
 
6881
if { (ac_try="$ac_cpp conftest.$ac_ext"
 
6882
case "(($ac_try" in
 
6883
  *\"* | *\`* | *\\*) ac_try_echo=\$ac_try;;
 
6884
  *) ac_try_echo=$ac_try;;
 
6885
esac
 
6886
eval ac_try_echo="\"\$as_me:$LINENO: $ac_try_echo\""
 
6887
$as_echo "$ac_try_echo") >&5
 
6888
  (eval "$ac_cpp conftest.$ac_ext") 2>conftest.er1
 
6889
  ac_status=$?
 
6890
  grep -v '^ *+' conftest.er1 >conftest.err
 
6891
  rm -f conftest.er1
 
6892
  cat conftest.err >&5
 
6893
  $as_echo "$as_me:$LINENO: \$? = $ac_status" >&5
 
6894
  (exit $ac_status); } >/dev/null && {
 
6895
         test -z "$ac_c_preproc_warn_flag$ac_c_werror_flag" ||
 
6896
         test ! -s conftest.err
 
6897
       }; then
 
6898
  ac_header_preproc=yes
 
6899
else
 
6900
  $as_echo "$as_me: failed program was:" >&5
 
6901
sed 's/^/| /' conftest.$ac_ext >&5
 
6902
 
 
6903
  ac_header_preproc=no
 
6904
fi
 
6905
 
 
6906
rm -f conftest.err conftest.$ac_ext
 
6907
{ $as_echo "$as_me:$LINENO: result: $ac_header_preproc" >&5
 
6908
$as_echo "$ac_header_preproc" >&6; }
 
6909
 
 
6910
# So?  What about this header?
 
6911
case $ac_header_compiler:$ac_header_preproc:$ac_c_preproc_warn_flag in
 
6912
  yes:no: )
 
6913
    { $as_echo "$as_me:$LINENO: WARNING: priv.h: accepted by the compiler, rejected by the preprocessor!" >&5
 
6914
$as_echo "$as_me: WARNING: priv.h: accepted by the compiler, rejected by the preprocessor!" >&2;}
 
6915
    { $as_echo "$as_me:$LINENO: WARNING: priv.h: proceeding with the compiler's result" >&5
 
6916
$as_echo "$as_me: WARNING: priv.h: proceeding with the compiler's result" >&2;}
 
6917
    ac_header_preproc=yes
 
6918
    ;;
 
6919
  no:yes:* )
 
6920
    { $as_echo "$as_me:$LINENO: WARNING: priv.h: present but cannot be compiled" >&5
 
6921
$as_echo "$as_me: WARNING: priv.h: present but cannot be compiled" >&2;}
 
6922
    { $as_echo "$as_me:$LINENO: WARNING: priv.h:     check for missing prerequisite headers?" >&5
 
6923
$as_echo "$as_me: WARNING: priv.h:     check for missing prerequisite headers?" >&2;}
 
6924
    { $as_echo "$as_me:$LINENO: WARNING: priv.h: see the Autoconf documentation" >&5
 
6925
$as_echo "$as_me: WARNING: priv.h: see the Autoconf documentation" >&2;}
 
6926
    { $as_echo "$as_me:$LINENO: WARNING: priv.h:     section \"Present But Cannot Be Compiled\"" >&5
 
6927
$as_echo "$as_me: WARNING: priv.h:     section \"Present But Cannot Be Compiled\"" >&2;}
 
6928
    { $as_echo "$as_me:$LINENO: WARNING: priv.h: proceeding with the preprocessor's result" >&5
 
6929
$as_echo "$as_me: WARNING: priv.h: proceeding with the preprocessor's result" >&2;}
 
6930
    { $as_echo "$as_me:$LINENO: WARNING: priv.h: in the future, the compiler will take precedence" >&5
 
6931
$as_echo "$as_me: WARNING: priv.h: in the future, the compiler will take precedence" >&2;}
 
6932
    ( cat <<\_ASBOX
 
6933
## ----------------------------- ##
 
6934
## Report this to brad@danga.com ##
 
6935
## ----------------------------- ##
 
6936
_ASBOX
 
6937
     ) | sed "s/^/$as_me: WARNING:     /" >&2
 
6938
    ;;
 
6939
esac
 
6940
{ $as_echo "$as_me:$LINENO: checking for priv.h" >&5
 
6941
$as_echo_n "checking for priv.h... " >&6; }
 
6942
if test "${ac_cv_header_priv_h+set}" = set; then
 
6943
  $as_echo_n "(cached) " >&6
 
6944
else
 
6945
  ac_cv_header_priv_h=$ac_header_preproc
 
6946
fi
 
6947
{ $as_echo "$as_me:$LINENO: result: $ac_cv_header_priv_h" >&5
 
6948
$as_echo "$ac_cv_header_priv_h" >&6; }
 
6949
 
 
6950
fi
 
6951
if test "x$ac_cv_header_priv_h" = x""yes; then
 
6952
 
 
6953
 
 
6954
cat >>confdefs.h <<\_ACEOF
 
6955
#define HAVE_DROP_PRIVILEGES 1
 
6956
_ACEOF
 
6957
 
 
6958
      build_solaris_privs=yes
 
6959
 
 
6960
fi
 
6961
 
 
6962
 
 
6963
 
 
6964
fi
 
6965
done
 
6966
 
 
6967
 
 
6968
 if test "$build_solaris_privs" = "yes"; then
 
6969
  BUILD_SOLARIS_PRIVS_TRUE=
 
6970
  BUILD_SOLARIS_PRIVS_FALSE='#'
 
6971
else
 
6972
  BUILD_SOLARIS_PRIVS_TRUE='#'
 
6973
  BUILD_SOLARIS_PRIVS_FALSE=
 
6974
fi
 
6975
 
 
6976
 
 
6977
if test "${ac_cv_header_umem_h+set}" = set; then
 
6978
  { $as_echo "$as_me:$LINENO: checking for umem.h" >&5
 
6979
$as_echo_n "checking for umem.h... " >&6; }
 
6980
if test "${ac_cv_header_umem_h+set}" = set; then
 
6981
  $as_echo_n "(cached) " >&6
 
6982
fi
 
6983
{ $as_echo "$as_me:$LINENO: result: $ac_cv_header_umem_h" >&5
 
6984
$as_echo "$ac_cv_header_umem_h" >&6; }
 
6985
else
 
6986
  # Is the header compilable?
 
6987
{ $as_echo "$as_me:$LINENO: checking umem.h usability" >&5
 
6988
$as_echo_n "checking umem.h usability... " >&6; }
 
6989
cat >conftest.$ac_ext <<_ACEOF
 
6990
/* confdefs.h.  */
 
6991
_ACEOF
 
6992
cat confdefs.h >>conftest.$ac_ext
 
6993
cat >>conftest.$ac_ext <<_ACEOF
 
6994
/* end confdefs.h.  */
 
6995
$ac_includes_default
 
6996
#include <umem.h>
 
6997
_ACEOF
 
6998
rm -f conftest.$ac_objext
 
6999
if { (ac_try="$ac_compile"
 
7000
case "(($ac_try" in
 
7001
  *\"* | *\`* | *\\*) ac_try_echo=\$ac_try;;
 
7002
  *) ac_try_echo=$ac_try;;
 
7003
esac
 
7004
eval ac_try_echo="\"\$as_me:$LINENO: $ac_try_echo\""
 
7005
$as_echo "$ac_try_echo") >&5
 
7006
  (eval "$ac_compile") 2>conftest.er1
 
7007
  ac_status=$?
 
7008
  grep -v '^ *+' conftest.er1 >conftest.err
 
7009
  rm -f conftest.er1
 
7010
  cat conftest.err >&5
 
7011
  $as_echo "$as_me:$LINENO: \$? = $ac_status" >&5
 
7012
  (exit $ac_status); } && {
 
7013
         test -z "$ac_c_werror_flag" ||
 
7014
         test ! -s conftest.err
 
7015
       } && test -s conftest.$ac_objext; then
 
7016
  ac_header_compiler=yes
 
7017
else
 
7018
  $as_echo "$as_me: failed program was:" >&5
 
7019
sed 's/^/| /' conftest.$ac_ext >&5
 
7020
 
 
7021
        ac_header_compiler=no
 
7022
fi
 
7023
 
 
7024
rm -f core conftest.err conftest.$ac_objext conftest.$ac_ext
 
7025
{ $as_echo "$as_me:$LINENO: result: $ac_header_compiler" >&5
 
7026
$as_echo "$ac_header_compiler" >&6; }
 
7027
 
 
7028
# Is the header present?
 
7029
{ $as_echo "$as_me:$LINENO: checking umem.h presence" >&5
 
7030
$as_echo_n "checking umem.h presence... " >&6; }
 
7031
cat >conftest.$ac_ext <<_ACEOF
 
7032
/* confdefs.h.  */
 
7033
_ACEOF
 
7034
cat confdefs.h >>conftest.$ac_ext
 
7035
cat >>conftest.$ac_ext <<_ACEOF
 
7036
/* end confdefs.h.  */
 
7037
#include <umem.h>
 
7038
_ACEOF
 
7039
if { (ac_try="$ac_cpp conftest.$ac_ext"
 
7040
case "(($ac_try" in
 
7041
  *\"* | *\`* | *\\*) ac_try_echo=\$ac_try;;
 
7042
  *) ac_try_echo=$ac_try;;
 
7043
esac
 
7044
eval ac_try_echo="\"\$as_me:$LINENO: $ac_try_echo\""
 
7045
$as_echo "$ac_try_echo") >&5
 
7046
  (eval "$ac_cpp conftest.$ac_ext") 2>conftest.er1
 
7047
  ac_status=$?
 
7048
  grep -v '^ *+' conftest.er1 >conftest.err
 
7049
  rm -f conftest.er1
 
7050
  cat conftest.err >&5
 
7051
  $as_echo "$as_me:$LINENO: \$? = $ac_status" >&5
 
7052
  (exit $ac_status); } >/dev/null && {
 
7053
         test -z "$ac_c_preproc_warn_flag$ac_c_werror_flag" ||
 
7054
         test ! -s conftest.err
 
7055
       }; then
 
7056
  ac_header_preproc=yes
 
7057
else
 
7058
  $as_echo "$as_me: failed program was:" >&5
 
7059
sed 's/^/| /' conftest.$ac_ext >&5
 
7060
 
 
7061
  ac_header_preproc=no
 
7062
fi
 
7063
 
 
7064
rm -f conftest.err conftest.$ac_ext
 
7065
{ $as_echo "$as_me:$LINENO: result: $ac_header_preproc" >&5
 
7066
$as_echo "$ac_header_preproc" >&6; }
 
7067
 
 
7068
# So?  What about this header?
 
7069
case $ac_header_compiler:$ac_header_preproc:$ac_c_preproc_warn_flag in
 
7070
  yes:no: )
 
7071
    { $as_echo "$as_me:$LINENO: WARNING: umem.h: accepted by the compiler, rejected by the preprocessor!" >&5
 
7072
$as_echo "$as_me: WARNING: umem.h: accepted by the compiler, rejected by the preprocessor!" >&2;}
 
7073
    { $as_echo "$as_me:$LINENO: WARNING: umem.h: proceeding with the compiler's result" >&5
 
7074
$as_echo "$as_me: WARNING: umem.h: proceeding with the compiler's result" >&2;}
 
7075
    ac_header_preproc=yes
 
7076
    ;;
 
7077
  no:yes:* )
 
7078
    { $as_echo "$as_me:$LINENO: WARNING: umem.h: present but cannot be compiled" >&5
 
7079
$as_echo "$as_me: WARNING: umem.h: present but cannot be compiled" >&2;}
 
7080
    { $as_echo "$as_me:$LINENO: WARNING: umem.h:     check for missing prerequisite headers?" >&5
 
7081
$as_echo "$as_me: WARNING: umem.h:     check for missing prerequisite headers?" >&2;}
 
7082
    { $as_echo "$as_me:$LINENO: WARNING: umem.h: see the Autoconf documentation" >&5
 
7083
$as_echo "$as_me: WARNING: umem.h: see the Autoconf documentation" >&2;}
 
7084
    { $as_echo "$as_me:$LINENO: WARNING: umem.h:     section \"Present But Cannot Be Compiled\"" >&5
 
7085
$as_echo "$as_me: WARNING: umem.h:     section \"Present But Cannot Be Compiled\"" >&2;}
 
7086
    { $as_echo "$as_me:$LINENO: WARNING: umem.h: proceeding with the preprocessor's result" >&5
 
7087
$as_echo "$as_me: WARNING: umem.h: proceeding with the preprocessor's result" >&2;}
 
7088
    { $as_echo "$as_me:$LINENO: WARNING: umem.h: in the future, the compiler will take precedence" >&5
 
7089
$as_echo "$as_me: WARNING: umem.h: in the future, the compiler will take precedence" >&2;}
 
7090
    ( cat <<\_ASBOX
 
7091
## ----------------------------- ##
 
7092
## Report this to brad@danga.com ##
 
7093
## ----------------------------- ##
 
7094
_ASBOX
 
7095
     ) | sed "s/^/$as_me: WARNING:     /" >&2
 
7096
    ;;
 
7097
esac
 
7098
{ $as_echo "$as_me:$LINENO: checking for umem.h" >&5
 
7099
$as_echo_n "checking for umem.h... " >&6; }
 
7100
if test "${ac_cv_header_umem_h+set}" = set; then
 
7101
  $as_echo_n "(cached) " >&6
 
7102
else
 
7103
  ac_cv_header_umem_h=$ac_header_preproc
 
7104
fi
 
7105
{ $as_echo "$as_me:$LINENO: result: $ac_cv_header_umem_h" >&5
 
7106
$as_echo "$ac_cv_header_umem_h" >&6; }
 
7107
 
 
7108
fi
 
7109
if test "x$ac_cv_header_umem_h" = x""yes; then
 
7110
 
 
7111
 
 
7112
cat >>confdefs.h <<\_ACEOF
 
7113
#define HAVE_UMEM_H 1
 
7114
_ACEOF
 
7115
 
 
7116
   build_cache=no
 
7117
 
 
7118
else
 
7119
  build_cache=yes
 
7120
fi
 
7121
 
 
7122
 
 
7123
 
 
7124
 if test "x$build_cache" = "xyes"; then
 
7125
  BUILD_CACHE_TRUE=
 
7126
  BUILD_CACHE_FALSE='#'
 
7127
else
 
7128
  BUILD_CACHE_TRUE='#'
 
7129
  BUILD_CACHE_FALSE=
 
7130
fi
 
7131
 
 
7132
 
 
7133
# Check whether --enable-docs was given.
 
7134
if test "${enable_docs+set}" = set; then
 
7135
  enableval=$enable_docs;
 
7136
fi
 
7137
 
 
7138
 
 
7139
# Extract the first word of "xml2rfc", so it can be a program name with args.
 
7140
set dummy xml2rfc; ac_word=$2
 
7141
{ $as_echo "$as_me:$LINENO: checking for $ac_word" >&5
 
7142
$as_echo_n "checking for $ac_word... " >&6; }
 
7143
if test "${ac_cv_path_XML2RFC+set}" = set; then
 
7144
  $as_echo_n "(cached) " >&6
 
7145
else
 
7146
  case $XML2RFC in
 
7147
  [\\/]* | ?:[\\/]*)
 
7148
  ac_cv_path_XML2RFC="$XML2RFC" # Let the user override the test with a path.
 
7149
  ;;
 
7150
  *)
 
7151
  as_save_IFS=$IFS; IFS=$PATH_SEPARATOR
 
7152
for as_dir in $PATH
 
7153
do
 
7154
  IFS=$as_save_IFS
 
7155
  test -z "$as_dir" && as_dir=.
 
7156
  for ac_exec_ext in '' $ac_executable_extensions; do
 
7157
  if { test -f "$as_dir/$ac_word$ac_exec_ext" && $as_test_x "$as_dir/$ac_word$ac_exec_ext"; }; then
 
7158
    ac_cv_path_XML2RFC="$as_dir/$ac_word$ac_exec_ext"
 
7159
    $as_echo "$as_me:$LINENO: found $as_dir/$ac_word$ac_exec_ext" >&5
 
7160
    break 2
 
7161
  fi
 
7162
done
 
7163
done
 
7164
IFS=$as_save_IFS
 
7165
 
 
7166
  test -z "$ac_cv_path_XML2RFC" && ac_cv_path_XML2RFC=""no""
 
7167
  ;;
 
7168
esac
 
7169
fi
 
7170
XML2RFC=$ac_cv_path_XML2RFC
 
7171
if test -n "$XML2RFC"; then
 
7172
  { $as_echo "$as_me:$LINENO: result: $XML2RFC" >&5
 
7173
$as_echo "$XML2RFC" >&6; }
 
7174
else
 
7175
  { $as_echo "$as_me:$LINENO: result: no" >&5
 
7176
$as_echo "no" >&6; }
 
7177
fi
 
7178
 
 
7179
 
 
7180
# Extract the first word of "xsltproc", so it can be a program name with args.
 
7181
set dummy xsltproc; ac_word=$2
 
7182
{ $as_echo "$as_me:$LINENO: checking for $ac_word" >&5
 
7183
$as_echo_n "checking for $ac_word... " >&6; }
 
7184
if test "${ac_cv_path_XSLTPROC+set}" = set; then
 
7185
  $as_echo_n "(cached) " >&6
 
7186
else
 
7187
  case $XSLTPROC in
 
7188
  [\\/]* | ?:[\\/]*)
 
7189
  ac_cv_path_XSLTPROC="$XSLTPROC" # Let the user override the test with a path.
 
7190
  ;;
 
7191
  *)
 
7192
  as_save_IFS=$IFS; IFS=$PATH_SEPARATOR
 
7193
for as_dir in $PATH
 
7194
do
 
7195
  IFS=$as_save_IFS
 
7196
  test -z "$as_dir" && as_dir=.
 
7197
  for ac_exec_ext in '' $ac_executable_extensions; do
 
7198
  if { test -f "$as_dir/$ac_word$ac_exec_ext" && $as_test_x "$as_dir/$ac_word$ac_exec_ext"; }; then
 
7199
    ac_cv_path_XSLTPROC="$as_dir/$ac_word$ac_exec_ext"
 
7200
    $as_echo "$as_me:$LINENO: found $as_dir/$ac_word$ac_exec_ext" >&5
 
7201
    break 2
 
7202
  fi
 
7203
done
 
7204
done
 
7205
IFS=$as_save_IFS
 
7206
 
 
7207
  test -z "$ac_cv_path_XSLTPROC" && ac_cv_path_XSLTPROC=""no""
 
7208
  ;;
 
7209
esac
 
7210
fi
 
7211
XSLTPROC=$ac_cv_path_XSLTPROC
 
7212
if test -n "$XSLTPROC"; then
 
7213
  { $as_echo "$as_me:$LINENO: result: $XSLTPROC" >&5
 
7214
$as_echo "$XSLTPROC" >&6; }
 
7215
else
 
7216
  { $as_echo "$as_me:$LINENO: result: no" >&5
 
7217
$as_echo "no" >&6; }
 
7218
fi
 
7219
 
 
7220
 
 
7221
 
 
7222
 if test "x$enable_docs" != "xno" -a "x$XML2RFC" != "xno" -a "x$XSLTPROC" != "xno"; then
 
7223
  BUILD_SPECIFICATIONS_TRUE=
 
7224
  BUILD_SPECIFICATIONS_FALSE='#'
 
7225
else
 
7226
  BUILD_SPECIFICATIONS_TRUE='#'
 
7227
  BUILD_SPECIFICATIONS_FALSE=
 
7228
fi
 
7229
 
 
7230
 
 
7231
 
 
7232
if test "$ICC" = "yes"
 
7233
then
 
7234
      CFLAGS="$CFLAGS -diag-disable 187 -Wall -Werror"
 
7235
 
 
7236
cat >>confdefs.h <<\_ACEOF
 
7237
#define _GNU_SOURCE 1
 
7238
_ACEOF
 
7239
 
 
7240
elif test "$GCC" = "yes"
 
7241
then
 
7242
  GCC_VERSION=`$CC -dumpversion`
 
7243
  CFLAGS="$CFLAGS -Wall -Werror -pedantic -Wstrict-prototypes -Wmissing-prototypes -Wmissing-declarations -Wredundant-decls"
 
7244
  case $GCC_VERSION in
 
7245
    4.4.*)
 
7246
    CFLAGS="$CFLAGS -fno-strict-aliasing"
 
7247
    ;;
 
7248
  esac
 
7249
 
 
7250
cat >>confdefs.h <<\_ACEOF
 
7251
#define _GNU_SOURCE 1
 
7252
_ACEOF
 
7253
 
 
7254
elif test "$SUNCC" = "yes"
 
7255
then
 
7256
  CFLAGS="$CFLAGS -errfmt=error -errwarn -errshort=tags"
 
7257
fi
 
7258
 
6316
7259
ac_config_files="$ac_config_files Makefile doc/Makefile"
6317
7260
 
6318
7261
cat >confcache <<\_ACEOF
6426
7369
Usually this means the macro was only invoked conditionally." >&2;}
6427
7370
   { (exit 1); exit 1; }; }
6428
7371
fi
 
7372
if test -z "${BUILD_DTRACE_TRUE}" && test -z "${BUILD_DTRACE_FALSE}"; then
 
7373
  { { $as_echo "$as_me:$LINENO: error: conditional \"BUILD_DTRACE\" was never defined.
 
7374
Usually this means the macro was only invoked conditionally." >&5
 
7375
$as_echo "$as_me: error: conditional \"BUILD_DTRACE\" was never defined.
 
7376
Usually this means the macro was only invoked conditionally." >&2;}
 
7377
   { (exit 1); exit 1; }; }
 
7378
fi
 
7379
if test -z "${DTRACE_INSTRUMENT_OBJ_TRUE}" && test -z "${DTRACE_INSTRUMENT_OBJ_FALSE}"; then
 
7380
  { { $as_echo "$as_me:$LINENO: error: conditional \"DTRACE_INSTRUMENT_OBJ\" was never defined.
 
7381
Usually this means the macro was only invoked conditionally." >&5
 
7382
$as_echo "$as_me: error: conditional \"DTRACE_INSTRUMENT_OBJ\" was never defined.
 
7383
Usually this means the macro was only invoked conditionally." >&2;}
 
7384
   { (exit 1); exit 1; }; }
 
7385
fi
 
7386
if test -z "${BUILD_SOLARIS_PRIVS_TRUE}" && test -z "${BUILD_SOLARIS_PRIVS_FALSE}"; then
 
7387
  { { $as_echo "$as_me:$LINENO: error: conditional \"BUILD_SOLARIS_PRIVS\" was never defined.
 
7388
Usually this means the macro was only invoked conditionally." >&5
 
7389
$as_echo "$as_me: error: conditional \"BUILD_SOLARIS_PRIVS\" was never defined.
 
7390
Usually this means the macro was only invoked conditionally." >&2;}
 
7391
   { (exit 1); exit 1; }; }
 
7392
fi
 
7393
if test -z "${BUILD_CACHE_TRUE}" && test -z "${BUILD_CACHE_FALSE}"; then
 
7394
  { { $as_echo "$as_me:$LINENO: error: conditional \"BUILD_CACHE\" was never defined.
 
7395
Usually this means the macro was only invoked conditionally." >&5
 
7396
$as_echo "$as_me: error: conditional \"BUILD_CACHE\" was never defined.
 
7397
Usually this means the macro was only invoked conditionally." >&2;}
 
7398
   { (exit 1); exit 1; }; }
 
7399
fi
 
7400
if test -z "${BUILD_SPECIFICATIONS_TRUE}" && test -z "${BUILD_SPECIFICATIONS_FALSE}"; then
 
7401
  { { $as_echo "$as_me:$LINENO: error: conditional \"BUILD_SPECIFICATIONS\" was never defined.
 
7402
Usually this means the macro was only invoked conditionally." >&5
 
7403
$as_echo "$as_me: error: conditional \"BUILD_SPECIFICATIONS\" was never defined.
 
7404
Usually this means the macro was only invoked conditionally." >&2;}
 
7405
   { (exit 1); exit 1; }; }
 
7406
fi
6429
7407
 
6430
7408
: ${CONFIG_STATUS=./config.status}
6431
7409
ac_write_fail=0
6748
7726
# report actual input values of CONFIG_FILES etc. instead of their
6749
7727
# values after options handling.
6750
7728
ac_log="
6751
 
This file was extended by memcached $as_me 1.2.8, which was
 
7729
This file was extended by memcached $as_me 1.4.2, which was
6752
7730
generated by GNU Autoconf 2.63.  Invocation command line was
6753
7731
 
6754
7732
  CONFIG_FILES    = $CONFIG_FILES
6811
7789
_ACEOF
6812
7790
cat >>$CONFIG_STATUS <<_ACEOF || ac_write_fail=1
6813
7791
ac_cs_version="\\
6814
 
memcached config.status 1.2.8
 
7792
memcached config.status 1.4.2
6815
7793
configured by $0, generated by GNU Autoconf 2.63,
6816
7794
  with options \\"`$as_echo "$ac_configure_args" | sed 's/^ //; s/[\\""\`\$]/\\\\&/g'`\\"
6817
7795