~ubuntu-branches/ubuntu/vivid/man-db/vivid-proposed

« back to all changes in this revision

Viewing changes to configure

  • Committer: Package Import Robot
  • Author(s): Colin Watson
  • Date: 2014-09-24 02:23:08 UTC
  • mfrom: (1.2.18)
  • Revision ID: package-import@ubuntu.com-20140924022308-th7xg9sasywkc15s
Tags: 2.7.0.1-1
* New upstream release:
  - Fix test suite in the case where the system supports high-precision
    timestamps but the file system containing the build directory does
    not.
* Ensure that /var/cache/man exists when triggered (LP: #1351795).

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.69 for man-db 2.7.0.
 
3
# Generated by GNU Autoconf 2.69 for man-db 2.7.0.1.
4
4
#
5
5
# Report bugs to <cjwatson@debian.org>.
6
6
#
590
590
# Identity of this package.
591
591
PACKAGE_NAME='man-db'
592
592
PACKAGE_TARNAME='man-db'
593
 
PACKAGE_VERSION='2.7.0'
594
 
PACKAGE_STRING='man-db 2.7.0'
 
593
PACKAGE_VERSION='2.7.0.1'
 
594
PACKAGE_STRING='man-db 2.7.0.1'
595
595
PACKAGE_BUGREPORT='cjwatson@debian.org'
596
596
PACKAGE_URL=''
597
597
 
674
674
PKG_CONFIG_LIBDIR
675
675
PKG_CONFIG_PATH
676
676
PKG_CONFIG
677
 
STAT_HAS_NSEC
678
677
MAN_SUBDIRS
679
678
PO4A_FALSE
680
679
PO4A_TRUE
723
722
TIME_H_DEFINES_STRUCT_TIMESPEC
724
723
NEXT_AS_FIRST_DIRECTIVE_TIME_H
725
724
NEXT_TIME_H
726
 
REPLACE_LOCALTIME
727
 
REPLACE_GMTIME
728
 
REPLACE_TIMEGM
729
 
REPLACE_NANOSLEEP
730
 
REPLACE_MKTIME
731
 
REPLACE_LOCALTIME_R
732
 
HAVE_TIMEGM
733
 
HAVE_STRPTIME
734
 
HAVE_NANOSLEEP
735
 
HAVE_DECL_LOCALTIME_R
736
 
GNULIB_TIME_R
737
 
GNULIB_TIMEGM
738
 
GNULIB_STRPTIME
739
 
GNULIB_NANOSLEEP
740
 
GNULIB_MKTIME
741
725
GL_GENERATE_SYSEXITS_H_FALSE
742
726
GL_GENERATE_SYSEXITS_H_TRUE
743
727
SYSEXITS_H
826
810
GNULIB_RAISE
827
811
GNULIB_PTHREAD_SIGMASK
828
812
ASM_SYMBOL_PREFIX
 
813
LIB_NANOSLEEP
 
814
LIB_SELECT
 
815
LIBSOCKET
 
816
HAVE_SYS_SELECT_H
 
817
NEXT_AS_FIRST_DIRECTIVE_SYS_SELECT_H
 
818
NEXT_SYS_SELECT_H
 
819
REPLACE_SELECT
 
820
REPLACE_PSELECT
 
821
HAVE_PSELECT
 
822
GNULIB_SELECT
 
823
GNULIB_PSELECT
 
824
REPLACE_LOCALTIME
 
825
REPLACE_GMTIME
 
826
REPLACE_TIMEGM
 
827
REPLACE_NANOSLEEP
 
828
REPLACE_MKTIME
 
829
REPLACE_LOCALTIME_R
 
830
HAVE_TIMEGM
 
831
HAVE_STRPTIME
 
832
HAVE_NANOSLEEP
 
833
HAVE_DECL_LOCALTIME_R
 
834
GNULIB_TIME_R
 
835
GNULIB_TIMEGM
 
836
GNULIB_STRPTIME
 
837
GNULIB_NANOSLEEP
 
838
GNULIB_MKTIME
829
839
APPLE_UNIVERSAL_BUILD
830
840
UNDEFINE_STRTOK_R
831
841
REPLACE_STRTOK_R
2256
2266
  # Omit some internal or obsolete options to make the list less imposing.
2257
2267
  # This message is too long to be a string in the A/UX 3.1 sh.
2258
2268
  cat <<_ACEOF
2259
 
\`configure' configures man-db 2.7.0 to adapt to many kinds of systems.
 
2269
\`configure' configures man-db 2.7.0.1 to adapt to many kinds of systems.
2260
2270
 
2261
2271
Usage: $0 [OPTION]... [VAR=VALUE]...
2262
2272
 
2326
2336
 
2327
2337
if test -n "$ac_init_help"; then
2328
2338
  case $ac_init_help in
2329
 
     short | recursive ) echo "Configuration of man-db 2.7.0:";;
 
2339
     short | recursive ) echo "Configuration of man-db 2.7.0.1:";;
2330
2340
   esac
2331
2341
  cat <<\_ACEOF
2332
2342
 
2507
2517
test -n "$ac_init_help" && exit $ac_status
2508
2518
if $ac_init_version; then
2509
2519
  cat <<\_ACEOF
2510
 
man-db configure 2.7.0
 
2520
man-db configure 2.7.0.1
2511
2521
generated by GNU Autoconf 2.69
2512
2522
 
2513
2523
Copyright (C) 2012 Free Software Foundation, Inc.
3216
3226
This file contains any messages produced by compilers while
3217
3227
running configure, to aid debugging if configure makes a mistake.
3218
3228
 
3219
 
It was created by man-db $as_me 2.7.0, which was
 
3229
It was created by man-db $as_me 2.7.0.1, which was
3220
3230
generated by GNU Autoconf 2.69.  Invocation command line was
3221
3231
 
3222
3232
  $ $0 $@
3557
3567
gl_header_list="$gl_header_list sys/mman.h"
3558
3568
gl_func_list="$gl_func_list mprotect"
3559
3569
gl_func_list="$gl_func_list mkstemp"
 
3570
gl_header_list="$gl_header_list sys/select.h"
3560
3571
gl_func_list="$gl_func_list nl_langinfo"
3561
3572
gl_func_list="$gl_func_list openat"
3562
3573
gl_header_list="$gl_header_list malloc.h"
4171
4182
 
4172
4183
# Define the identity of the package.
4173
4184
 PACKAGE='man-db'
4174
 
 VERSION='2.7.0'
 
4185
 VERSION='2.7.0.1'
4175
4186
 
4176
4187
 
4177
4188
cat >>confdefs.h <<_ACEOF
13259
13270
 
13260
13271
 
13261
13272
# Define below date and version information to be put into man pages etc.
13262
 
date=2014-09-22
13263
 
roff_version=`echo 2.7.0 | sed 's/-/\\-/g'`
 
13273
date=2014-09-24
 
13274
roff_version=`echo 2.7.0.1 | sed 's/-/\\-/g'`
13264
13275
 
13265
13276
# We have to be a bit naughty here and supply options.
13266
13277
# The autoconf literature states that only features that can be separately
15133
15144
  # Code from module msvc-inval:
15134
15145
  # Code from module msvc-nothrow:
15135
15146
  # Code from module multiarch:
 
15147
  # Code from module nanosleep:
15136
15148
  # Code from module nl_langinfo:
15137
15149
  # Code from module nocrash:
15138
15150
  # Code from module nonblocking:
15155
15167
  # Code from module same-inode:
15156
15168
  # Code from module save-cwd:
15157
15169
  # Code from module secure_getenv:
 
15170
  # Code from module select:
15158
15171
  # Code from module setenv:
15159
15172
  # Code from module sigaction:
15160
15173
  # Code from module signal:
15166
15179
  # Code from module snippet/arg-nonnull:
15167
15180
  # Code from module snippet/c++defs:
15168
15181
  # Code from module snippet/warn-on-use:
 
15182
  # Code from module socketlib:
 
15183
  # Code from module sockets:
15169
15184
  # Code from module socklen:
15170
15185
  # Code from module ssize_t:
15171
15186
  # Code from module stat:
15194
15209
  # Code from module strsep:
15195
15210
  # Code from module sys_file:
15196
15211
  # Code from module sys_ioctl:
 
15212
  # Code from module sys_select:
15197
15213
  # Code from module sys_socket:
15198
15214
  # Code from module sys_stat:
15199
15215
  # Code from module sys_time:
24431
24447
 
24432
24448
 
24433
24449
 
 
24450
  GNULIB_MKTIME=0;
 
24451
  GNULIB_NANOSLEEP=0;
 
24452
  GNULIB_STRPTIME=0;
 
24453
  GNULIB_TIMEGM=0;
 
24454
  GNULIB_TIME_R=0;
 
24455
    HAVE_DECL_LOCALTIME_R=1;
 
24456
  HAVE_NANOSLEEP=1;
 
24457
  HAVE_STRPTIME=1;
 
24458
  HAVE_TIMEGM=1;
 
24459
        REPLACE_LOCALTIME_R=GNULIB_PORTCHECK;
 
24460
  REPLACE_MKTIME=GNULIB_PORTCHECK;
 
24461
  REPLACE_NANOSLEEP=GNULIB_PORTCHECK;
 
24462
  REPLACE_TIMEGM=GNULIB_PORTCHECK;
 
24463
 
 
24464
      : ${GNULIB_GETTIMEOFDAY=0};
 
24465
        REPLACE_GMTIME=0;
 
24466
  REPLACE_LOCALTIME=0;
 
24467
 
 
24468
 
 
24469
  GNULIB_PSELECT=0;
 
24470
  GNULIB_SELECT=0;
 
24471
    HAVE_PSELECT=1;
 
24472
  REPLACE_PSELECT=0;
 
24473
  REPLACE_SELECT=0;
 
24474
 
 
24475
 
 
24476
 
 
24477
 
 
24478
 
 
24479
 
 
24480
 
 
24481
 
 
24482
 
 
24483
  { $as_echo "$as_me:${as_lineno-$LINENO}: checking whether <sys/select.h> is self-contained" >&5
 
24484
$as_echo_n "checking whether <sys/select.h> is self-contained... " >&6; }
 
24485
if ${gl_cv_header_sys_select_h_selfcontained+:} false; then :
 
24486
  $as_echo_n "(cached) " >&6
 
24487
else
 
24488
 
 
24489
                                    cat confdefs.h - <<_ACEOF >conftest.$ac_ext
 
24490
/* end confdefs.h.  */
 
24491
#include <sys/select.h>
 
24492
int
 
24493
main ()
 
24494
{
 
24495
struct timeval b;
 
24496
  ;
 
24497
  return 0;
 
24498
}
 
24499
_ACEOF
 
24500
if ac_fn_c_try_compile "$LINENO"; then :
 
24501
  gl_cv_header_sys_select_h_selfcontained=yes
 
24502
else
 
24503
  gl_cv_header_sys_select_h_selfcontained=no
 
24504
fi
 
24505
rm -f core conftest.err conftest.$ac_objext conftest.$ac_ext
 
24506
                        if test $gl_cv_header_sys_select_h_selfcontained = yes; then
 
24507
        cat confdefs.h - <<_ACEOF >conftest.$ac_ext
 
24508
/* end confdefs.h.  */
 
24509
#include <sys/select.h>
 
24510
int
 
24511
main ()
 
24512
{
 
24513
int memset; int bzero;
 
24514
  ;
 
24515
  return 0;
 
24516
}
 
24517
 
 
24518
_ACEOF
 
24519
if ac_fn_c_try_compile "$LINENO"; then :
 
24520
  cat confdefs.h - <<_ACEOF >conftest.$ac_ext
 
24521
/* end confdefs.h.  */
 
24522
#include <sys/select.h>
 
24523
int
 
24524
main ()
 
24525
{
 
24526
 
 
24527
                  #undef memset
 
24528
                  #define memset nonexistent_memset
 
24529
                  extern
 
24530
                  #ifdef __cplusplus
 
24531
                  "C"
 
24532
                  #endif
 
24533
                  void *memset (void *, int, unsigned long);
 
24534
                  #undef bzero
 
24535
                  #define bzero nonexistent_bzero
 
24536
                  extern
 
24537
                  #ifdef __cplusplus
 
24538
                  "C"
 
24539
                  #endif
 
24540
                  void bzero (void *, unsigned long);
 
24541
                  fd_set fds;
 
24542
                  FD_ZERO (&fds);
 
24543
 
 
24544
  ;
 
24545
  return 0;
 
24546
}
 
24547
 
 
24548
_ACEOF
 
24549
if ac_fn_c_try_link "$LINENO"; then :
 
24550
 
 
24551
else
 
24552
  gl_cv_header_sys_select_h_selfcontained=no
 
24553
fi
 
24554
rm -f core conftest.err conftest.$ac_objext \
 
24555
    conftest$ac_exeext conftest.$ac_ext
 
24556
 
 
24557
fi
 
24558
rm -f core conftest.err conftest.$ac_objext conftest.$ac_ext
 
24559
      fi
 
24560
 
 
24561
fi
 
24562
{ $as_echo "$as_me:${as_lineno-$LINENO}: result: $gl_cv_header_sys_select_h_selfcontained" >&5
 
24563
$as_echo "$gl_cv_header_sys_select_h_selfcontained" >&6; }
 
24564
 
 
24565
 
 
24566
 
 
24567
 
 
24568
 
 
24569
 
 
24570
  :
 
24571
 
 
24572
 
 
24573
 
 
24574
 
 
24575
 
 
24576
 
 
24577
 
 
24578
 
 
24579
     if test $gl_cv_have_include_next = yes; then
 
24580
       gl_cv_next_sys_select_h='<'sys/select.h'>'
 
24581
     else
 
24582
       { $as_echo "$as_me:${as_lineno-$LINENO}: checking absolute name of <sys/select.h>" >&5
 
24583
$as_echo_n "checking absolute name of <sys/select.h>... " >&6; }
 
24584
if ${gl_cv_next_sys_select_h+:} false; then :
 
24585
  $as_echo_n "(cached) " >&6
 
24586
else
 
24587
 
 
24588
             if test $ac_cv_header_sys_select_h = yes; then
 
24589
 
 
24590
 
 
24591
 
 
24592
 
 
24593
  cat confdefs.h - <<_ACEOF >conftest.$ac_ext
 
24594
/* end confdefs.h.  */
 
24595
#include <sys/select.h>
 
24596
_ACEOF
 
24597
                case "$host_os" in
 
24598
    aix*) gl_absname_cpp="$ac_cpp -C" ;;
 
24599
    *)    gl_absname_cpp="$ac_cpp" ;;
 
24600
  esac
 
24601
 
 
24602
  case "$host_os" in
 
24603
    mingw*)
 
24604
                                          gl_dirsep_regex='[/\\]'
 
24605
      ;;
 
24606
    *)
 
24607
      gl_dirsep_regex='\/'
 
24608
      ;;
 
24609
  esac
 
24610
      gl_make_literal_regex_sed='s,[]$^\\.*/[],\\&,g'
 
24611
  gl_header_literal_regex=`echo 'sys/select.h' \
 
24612
                           | sed -e "$gl_make_literal_regex_sed"`
 
24613
  gl_absolute_header_sed="/${gl_dirsep_regex}${gl_header_literal_regex}/"'{
 
24614
      s/.*"\(.*'"${gl_dirsep_regex}${gl_header_literal_regex}"'\)".*/\1/
 
24615
      s|^/[^/]|//&|
 
24616
      p
 
24617
      q
 
24618
    }'
 
24619
 
 
24620
        gl_cv_absolute_sys_select_h=`(eval "$gl_absname_cpp conftest.$ac_ext") 2>&5 |
 
24621
  sed -n "$gl_absolute_header_sed"`
 
24622
 
 
24623
           gl_header=$gl_cv_absolute_sys_select_h
 
24624
           gl_cv_next_sys_select_h='"'$gl_header'"'
 
24625
          else
 
24626
               gl_cv_next_sys_select_h='<'sys/select.h'>'
 
24627
             fi
 
24628
 
 
24629
 
 
24630
fi
 
24631
{ $as_echo "$as_me:${as_lineno-$LINENO}: result: $gl_cv_next_sys_select_h" >&5
 
24632
$as_echo "$gl_cv_next_sys_select_h" >&6; }
 
24633
     fi
 
24634
     NEXT_SYS_SELECT_H=$gl_cv_next_sys_select_h
 
24635
 
 
24636
     if test $gl_cv_have_include_next = yes || test $gl_cv_have_include_next = buggy; then
 
24637
       # INCLUDE_NEXT_AS_FIRST_DIRECTIVE='include_next'
 
24638
       gl_next_as_first_directive='<'sys/select.h'>'
 
24639
     else
 
24640
       # INCLUDE_NEXT_AS_FIRST_DIRECTIVE='include'
 
24641
       gl_next_as_first_directive=$gl_cv_next_sys_select_h
 
24642
     fi
 
24643
     NEXT_AS_FIRST_DIRECTIVE_SYS_SELECT_H=$gl_next_as_first_directive
 
24644
 
 
24645
 
 
24646
 
 
24647
 
 
24648
  if test $ac_cv_header_sys_select_h = yes; then
 
24649
    HAVE_SYS_SELECT_H=1
 
24650
  else
 
24651
    HAVE_SYS_SELECT_H=0
 
24652
  fi
 
24653
 
 
24654
 
 
24655
 
 
24656
 
 
24657
 
 
24658
  :
 
24659
 
 
24660
 
 
24661
 
 
24662
 
 
24663
 
 
24664
  if test $ac_cv_header_sys_socket_h != yes; then
 
24665
                    for ac_header in winsock2.h
 
24666
do :
 
24667
  ac_fn_c_check_header_mongrel "$LINENO" "winsock2.h" "ac_cv_header_winsock2_h" "$ac_includes_default"
 
24668
if test "x$ac_cv_header_winsock2_h" = xyes; then :
 
24669
  cat >>confdefs.h <<_ACEOF
 
24670
#define HAVE_WINSOCK2_H 1
 
24671
_ACEOF
 
24672
 
 
24673
fi
 
24674
 
 
24675
done
 
24676
 
 
24677
  fi
 
24678
  if test "$ac_cv_header_winsock2_h" = yes; then
 
24679
    HAVE_WINSOCK2_H=1
 
24680
    UNISTD_H_HAVE_WINSOCK2_H=1
 
24681
    SYS_IOCTL_H_HAVE_WINSOCK2_H=1
 
24682
  else
 
24683
    HAVE_WINSOCK2_H=0
 
24684
  fi
 
24685
 
 
24686
 
 
24687
 
 
24688
 
 
24689
    for gl_func in pselect select; do
 
24690
    as_gl_Symbol=`$as_echo "gl_cv_have_raw_decl_$gl_func" | $as_tr_sh`
 
24691
    { $as_echo "$as_me:${as_lineno-$LINENO}: checking whether $gl_func is declared without a macro" >&5
 
24692
$as_echo_n "checking whether $gl_func is declared without a macro... " >&6; }
 
24693
if eval \${$as_gl_Symbol+:} false; then :
 
24694
  $as_echo_n "(cached) " >&6
 
24695
else
 
24696
  cat confdefs.h - <<_ACEOF >conftest.$ac_ext
 
24697
/* end confdefs.h.  */
 
24698
 
 
24699
/* Some systems require prerequisite headers.  */
 
24700
#include <sys/types.h>
 
24701
#if !(defined __GLIBC__ && !defined __UCLIBC__) && HAVE_SYS_TIME_H
 
24702
# include <sys/time.h>
 
24703
#endif
 
24704
#include <sys/select.h>
 
24705
 
 
24706
int
 
24707
main ()
 
24708
{
 
24709
#undef $gl_func
 
24710
  (void) $gl_func;
 
24711
  ;
 
24712
  return 0;
 
24713
}
 
24714
_ACEOF
 
24715
if ac_fn_c_try_compile "$LINENO"; then :
 
24716
  eval "$as_gl_Symbol=yes"
 
24717
else
 
24718
  eval "$as_gl_Symbol=no"
 
24719
fi
 
24720
rm -f core conftest.err conftest.$ac_objext conftest.$ac_ext
 
24721
fi
 
24722
eval ac_res=\$$as_gl_Symbol
 
24723
               { $as_echo "$as_me:${as_lineno-$LINENO}: result: $ac_res" >&5
 
24724
$as_echo "$ac_res" >&6; }
 
24725
    if eval test \"x\$"$as_gl_Symbol"\" = x"yes"; then :
 
24726
  cat >>confdefs.h <<_ACEOF
 
24727
#define `$as_echo "HAVE_RAW_DECL_$gl_func" | $as_tr_cpp` 1
 
24728
_ACEOF
 
24729
 
 
24730
                     eval ac_cv_have_decl_$gl_func=yes
 
24731
fi
 
24732
      done
 
24733
 
 
24734
 
 
24735
 
 
24736
 
 
24737
 
 
24738
 
 
24739
 
 
24740
  :
 
24741
 
 
24742
 
 
24743
 
 
24744
 
 
24745
 
 
24746
  if test $ac_cv_header_sys_socket_h != yes; then
 
24747
                    for ac_header in winsock2.h
 
24748
do :
 
24749
  ac_fn_c_check_header_mongrel "$LINENO" "winsock2.h" "ac_cv_header_winsock2_h" "$ac_includes_default"
 
24750
if test "x$ac_cv_header_winsock2_h" = xyes; then :
 
24751
  cat >>confdefs.h <<_ACEOF
 
24752
#define HAVE_WINSOCK2_H 1
 
24753
_ACEOF
 
24754
 
 
24755
fi
 
24756
 
 
24757
done
 
24758
 
 
24759
  fi
 
24760
  if test "$ac_cv_header_winsock2_h" = yes; then
 
24761
    HAVE_WINSOCK2_H=1
 
24762
    UNISTD_H_HAVE_WINSOCK2_H=1
 
24763
    SYS_IOCTL_H_HAVE_WINSOCK2_H=1
 
24764
  else
 
24765
    HAVE_WINSOCK2_H=0
 
24766
  fi
 
24767
 
 
24768
   LIBSOCKET=
 
24769
  if test $HAVE_WINSOCK2_H = 1; then
 
24770
        { $as_echo "$as_me:${as_lineno-$LINENO}: checking if we need to call WSAStartup in winsock2.h and -lws2_32" >&5
 
24771
$as_echo_n "checking if we need to call WSAStartup in winsock2.h and -lws2_32... " >&6; }
 
24772
if ${gl_cv_func_wsastartup+:} false; then :
 
24773
  $as_echo_n "(cached) " >&6
 
24774
else
 
24775
 
 
24776
      gl_save_LIBS="$LIBS"
 
24777
      LIBS="$LIBS -lws2_32"
 
24778
      cat confdefs.h - <<_ACEOF >conftest.$ac_ext
 
24779
/* end confdefs.h.  */
 
24780
 
 
24781
#ifdef HAVE_WINSOCK2_H
 
24782
# include <winsock2.h>
 
24783
#endif
 
24784
int
 
24785
main ()
 
24786
{
 
24787
 
 
24788
          WORD wVersionRequested = MAKEWORD(1, 1);
 
24789
          WSADATA wsaData;
 
24790
          int err = WSAStartup(wVersionRequested, &wsaData);
 
24791
          WSACleanup ();
 
24792
  ;
 
24793
  return 0;
 
24794
}
 
24795
_ACEOF
 
24796
if ac_fn_c_try_link "$LINENO"; then :
 
24797
  gl_cv_func_wsastartup=yes
 
24798
else
 
24799
  gl_cv_func_wsastartup=no
 
24800
fi
 
24801
rm -f core conftest.err conftest.$ac_objext \
 
24802
    conftest$ac_exeext conftest.$ac_ext
 
24803
      LIBS="$gl_save_LIBS"
 
24804
 
 
24805
fi
 
24806
{ $as_echo "$as_me:${as_lineno-$LINENO}: result: $gl_cv_func_wsastartup" >&5
 
24807
$as_echo "$gl_cv_func_wsastartup" >&6; }
 
24808
    if test "$gl_cv_func_wsastartup" = "yes"; then
 
24809
 
 
24810
$as_echo "#define WINDOWS_SOCKETS 1" >>confdefs.h
 
24811
 
 
24812
      LIBSOCKET='-lws2_32'
 
24813
    fi
 
24814
  else
 
24815
                    { $as_echo "$as_me:${as_lineno-$LINENO}: checking for library containing setsockopt" >&5
 
24816
$as_echo_n "checking for library containing setsockopt... " >&6; }
 
24817
if ${gl_cv_lib_socket+:} false; then :
 
24818
  $as_echo_n "(cached) " >&6
 
24819
else
 
24820
 
 
24821
      gl_cv_lib_socket=
 
24822
      cat confdefs.h - <<_ACEOF >conftest.$ac_ext
 
24823
/* end confdefs.h.  */
 
24824
extern
 
24825
#ifdef __cplusplus
 
24826
"C"
 
24827
#endif
 
24828
char setsockopt();
 
24829
int
 
24830
main ()
 
24831
{
 
24832
setsockopt();
 
24833
  ;
 
24834
  return 0;
 
24835
}
 
24836
_ACEOF
 
24837
if ac_fn_c_try_link "$LINENO"; then :
 
24838
 
 
24839
else
 
24840
  gl_save_LIBS="$LIBS"
 
24841
         LIBS="$gl_save_LIBS -lsocket"
 
24842
         cat confdefs.h - <<_ACEOF >conftest.$ac_ext
 
24843
/* end confdefs.h.  */
 
24844
extern
 
24845
#ifdef __cplusplus
 
24846
"C"
 
24847
#endif
 
24848
char setsockopt();
 
24849
int
 
24850
main ()
 
24851
{
 
24852
setsockopt();
 
24853
  ;
 
24854
  return 0;
 
24855
}
 
24856
_ACEOF
 
24857
if ac_fn_c_try_link "$LINENO"; then :
 
24858
  gl_cv_lib_socket="-lsocket"
 
24859
fi
 
24860
rm -f core conftest.err conftest.$ac_objext \
 
24861
    conftest$ac_exeext conftest.$ac_ext
 
24862
         if test -z "$gl_cv_lib_socket"; then
 
24863
           LIBS="$gl_save_LIBS -lnetwork"
 
24864
           cat confdefs.h - <<_ACEOF >conftest.$ac_ext
 
24865
/* end confdefs.h.  */
 
24866
extern
 
24867
#ifdef __cplusplus
 
24868
"C"
 
24869
#endif
 
24870
char setsockopt();
 
24871
int
 
24872
main ()
 
24873
{
 
24874
setsockopt();
 
24875
  ;
 
24876
  return 0;
 
24877
}
 
24878
_ACEOF
 
24879
if ac_fn_c_try_link "$LINENO"; then :
 
24880
  gl_cv_lib_socket="-lnetwork"
 
24881
fi
 
24882
rm -f core conftest.err conftest.$ac_objext \
 
24883
    conftest$ac_exeext conftest.$ac_ext
 
24884
           if test -z "$gl_cv_lib_socket"; then
 
24885
             LIBS="$gl_save_LIBS -lnet"
 
24886
             cat confdefs.h - <<_ACEOF >conftest.$ac_ext
 
24887
/* end confdefs.h.  */
 
24888
extern
 
24889
#ifdef __cplusplus
 
24890
"C"
 
24891
#endif
 
24892
char setsockopt();
 
24893
int
 
24894
main ()
 
24895
{
 
24896
setsockopt();
 
24897
  ;
 
24898
  return 0;
 
24899
}
 
24900
_ACEOF
 
24901
if ac_fn_c_try_link "$LINENO"; then :
 
24902
  gl_cv_lib_socket="-lnet"
 
24903
fi
 
24904
rm -f core conftest.err conftest.$ac_objext \
 
24905
    conftest$ac_exeext conftest.$ac_ext
 
24906
           fi
 
24907
         fi
 
24908
         LIBS="$gl_save_LIBS"
 
24909
 
 
24910
fi
 
24911
rm -f core conftest.err conftest.$ac_objext \
 
24912
    conftest$ac_exeext conftest.$ac_ext
 
24913
      if test -z "$gl_cv_lib_socket"; then
 
24914
        gl_cv_lib_socket="none needed"
 
24915
      fi
 
24916
 
 
24917
fi
 
24918
{ $as_echo "$as_me:${as_lineno-$LINENO}: result: $gl_cv_lib_socket" >&5
 
24919
$as_echo "$gl_cv_lib_socket" >&6; }
 
24920
    if test "$gl_cv_lib_socket" != "none needed"; then
 
24921
      LIBSOCKET="$gl_cv_lib_socket"
 
24922
    fi
 
24923
  fi
 
24924
 
 
24925
 
 
24926
 
 
24927
 
 
24928
 
 
24929
 
 
24930
  :
 
24931
 
 
24932
 
 
24933
 
 
24934
 
 
24935
 
 
24936
  if test "$ac_cv_header_winsock2_h" = yes; then
 
24937
    REPLACE_SELECT=1
 
24938
  else
 
24939
 
 
24940
  :
 
24941
 
 
24942
 
 
24943
 
 
24944
 
 
24945
 
 
24946
    { $as_echo "$as_me:${as_lineno-$LINENO}: checking whether select supports a 0 argument" >&5
 
24947
$as_echo_n "checking whether select supports a 0 argument... " >&6; }
 
24948
if ${gl_cv_func_select_supports0+:} false; then :
 
24949
  $as_echo_n "(cached) " >&6
 
24950
else
 
24951
 
 
24952
        if test "$cross_compiling" = yes; then :
 
24953
 
 
24954
           case "$host_os" in
 
24955
                       # Guess no on Interix.
 
24956
             interix*) gl_cv_func_select_supports0="guessing no";;
 
24957
                       # Guess yes otherwise.
 
24958
             *)        gl_cv_func_select_supports0="guessing yes";;
 
24959
           esac
 
24960
 
 
24961
else
 
24962
  cat confdefs.h - <<_ACEOF >conftest.$ac_ext
 
24963
/* end confdefs.h.  */
 
24964
 
 
24965
#include <sys/types.h>
 
24966
#include <sys/time.h>
 
24967
#if HAVE_SYS_SELECT_H
 
24968
#include <sys/select.h>
 
24969
#endif
 
24970
int main ()
 
24971
{
 
24972
  struct timeval timeout;
 
24973
  timeout.tv_sec = 0;
 
24974
  timeout.tv_usec = 5;
 
24975
  return select (0, (fd_set *)0, (fd_set *)0, (fd_set *)0, &timeout) < 0;
 
24976
}
 
24977
_ACEOF
 
24978
if ac_fn_c_try_run "$LINENO"; then :
 
24979
  gl_cv_func_select_supports0=yes
 
24980
else
 
24981
  gl_cv_func_select_supports0=no
 
24982
fi
 
24983
rm -f core *.core core.conftest.* gmon.out bb.out conftest$ac_exeext \
 
24984
  conftest.$ac_objext conftest.beam conftest.$ac_ext
 
24985
fi
 
24986
 
 
24987
 
 
24988
fi
 
24989
{ $as_echo "$as_me:${as_lineno-$LINENO}: result: $gl_cv_func_select_supports0" >&5
 
24990
$as_echo "$gl_cv_func_select_supports0" >&6; }
 
24991
    case "$gl_cv_func_select_supports0" in
 
24992
      *yes) ;;
 
24993
      *) REPLACE_SELECT=1 ;;
 
24994
    esac
 
24995
 
 
24996
        { $as_echo "$as_me:${as_lineno-$LINENO}: checking whether select detects invalid fds" >&5
 
24997
$as_echo_n "checking whether select detects invalid fds... " >&6; }
 
24998
if ${gl_cv_func_select_detects_ebadf+:} false; then :
 
24999
  $as_echo_n "(cached) " >&6
 
25000
else
 
25001
 
 
25002
        if test "$cross_compiling" = yes; then :
 
25003
 
 
25004
           case "$host_os" in
 
25005
                    # Guess yes on glibc systems.
 
25006
            *-gnu*) gl_cv_func_select_detects_ebadf="guessing yes" ;;
 
25007
                    # If we don't know, assume the worst.
 
25008
            *)      gl_cv_func_select_detects_ebadf="guessing no" ;;
 
25009
           esac
 
25010
 
 
25011
else
 
25012
  cat confdefs.h - <<_ACEOF >conftest.$ac_ext
 
25013
/* end confdefs.h.  */
 
25014
 
 
25015
#include <sys/types.h>
 
25016
#include <sys/time.h>
 
25017
#if HAVE_SYS_SELECT_H
 
25018
# include <sys/select.h>
 
25019
#endif
 
25020
#include <unistd.h>
 
25021
#include <errno.h>
 
25022
 
 
25023
int
 
25024
main ()
 
25025
{
 
25026
 
 
25027
  fd_set set;
 
25028
  dup2(0, 16);
 
25029
  FD_ZERO(&set);
 
25030
  FD_SET(16, &set);
 
25031
  close(16);
 
25032
  struct timeval timeout;
 
25033
  timeout.tv_sec = 0;
 
25034
  timeout.tv_usec = 5;
 
25035
  return select (17, &set, NULL, NULL, &timeout) != -1 || errno != EBADF;
 
25036
 
 
25037
  ;
 
25038
  return 0;
 
25039
}
 
25040
_ACEOF
 
25041
if ac_fn_c_try_run "$LINENO"; then :
 
25042
  gl_cv_func_select_detects_ebadf=yes
 
25043
else
 
25044
  gl_cv_func_select_detects_ebadf=no
 
25045
fi
 
25046
rm -f core *.core core.conftest.* gmon.out bb.out conftest$ac_exeext \
 
25047
  conftest.$ac_objext conftest.beam conftest.$ac_ext
 
25048
fi
 
25049
 
 
25050
 
 
25051
fi
 
25052
{ $as_echo "$as_me:${as_lineno-$LINENO}: result: $gl_cv_func_select_detects_ebadf" >&5
 
25053
$as_echo "$gl_cv_func_select_detects_ebadf" >&6; }
 
25054
    case $gl_cv_func_select_detects_ebadf in
 
25055
      *yes) ;;
 
25056
      *) REPLACE_SELECT=1 ;;
 
25057
    esac
 
25058
  fi
 
25059
 
 
25060
    LIB_SELECT="$LIBSOCKET"
 
25061
  if test $REPLACE_SELECT = 1; then
 
25062
    case "$host_os" in
 
25063
      mingw*)
 
25064
                                cat confdefs.h - <<_ACEOF >conftest.$ac_ext
 
25065
/* end confdefs.h.  */
 
25066
 
 
25067
#define WIN32_LEAN_AND_MEAN
 
25068
#include <windows.h>
 
25069
int
 
25070
main ()
 
25071
{
 
25072
  MsgWaitForMultipleObjects (0, NULL, 0, 0, 0);
 
25073
  return 0;
 
25074
}
 
25075
_ACEOF
 
25076
if ac_fn_c_try_link "$LINENO"; then :
 
25077
 
 
25078
else
 
25079
  LIB_SELECT="$LIB_SELECT -luser32"
 
25080
fi
 
25081
rm -f core conftest.err conftest.$ac_objext \
 
25082
    conftest$ac_exeext conftest.$ac_ext
 
25083
        ;;
 
25084
    esac
 
25085
  fi
 
25086
 
 
25087
 
 
25088
 
24434
25089
 
24435
25090
 
24436
25091
 
24773
25428
 
24774
25429
fi
24775
25430
 
24776
 
:
24777
25431
 
24778
25432
 
24779
25433
 
26113
26767
 
26114
26768
 
26115
26769
 
26116
 
  GNULIB_MKTIME=0;
26117
 
  GNULIB_NANOSLEEP=0;
26118
 
  GNULIB_STRPTIME=0;
26119
 
  GNULIB_TIMEGM=0;
26120
 
  GNULIB_TIME_R=0;
26121
 
    HAVE_DECL_LOCALTIME_R=1;
26122
 
  HAVE_NANOSLEEP=1;
26123
 
  HAVE_STRPTIME=1;
26124
 
  HAVE_TIMEGM=1;
26125
 
        REPLACE_LOCALTIME_R=GNULIB_PORTCHECK;
26126
 
  REPLACE_MKTIME=GNULIB_PORTCHECK;
26127
 
  REPLACE_NANOSLEEP=GNULIB_PORTCHECK;
26128
 
  REPLACE_TIMEGM=GNULIB_PORTCHECK;
26129
 
 
26130
 
      : ${GNULIB_GETTIMEOFDAY=0};
26131
 
        REPLACE_GMTIME=0;
26132
 
  REPLACE_LOCALTIME=0;
26133
 
 
26134
 
 
26135
26770
 
26136
26771
  :
26137
26772
 
34490
35125
 
34491
35126
 
34492
35127
 
 
35128
 
 
35129
 
 
35130
  :
 
35131
 
 
35132
 
 
35133
 
 
35134
 
 
35135
 
 
35136
 
 
35137
 
 
35138
 nanosleep_save_libs=$LIBS
 
35139
 
 
35140
 # Solaris 2.5.1 needs -lposix4 to get the nanosleep function.
 
35141
 # Solaris 7 prefers the library name -lrt to the obsolescent name -lposix4.
 
35142
 LIB_NANOSLEEP=
 
35143
 
 
35144
 { $as_echo "$as_me:${as_lineno-$LINENO}: checking for library containing nanosleep" >&5
 
35145
$as_echo_n "checking for library containing nanosleep... " >&6; }
 
35146
if ${ac_cv_search_nanosleep+:} false; then :
 
35147
  $as_echo_n "(cached) " >&6
 
35148
else
 
35149
  ac_func_search_save_LIBS=$LIBS
 
35150
cat confdefs.h - <<_ACEOF >conftest.$ac_ext
 
35151
/* end confdefs.h.  */
 
35152
 
 
35153
/* Override any GCC internal prototype to avoid an error.
 
35154
   Use char because int might match the return type of a GCC
 
35155
   builtin and then its argument prototype would still apply.  */
 
35156
#ifdef __cplusplus
 
35157
extern "C"
 
35158
#endif
 
35159
char nanosleep ();
 
35160
int
 
35161
main ()
 
35162
{
 
35163
return nanosleep ();
 
35164
  ;
 
35165
  return 0;
 
35166
}
 
35167
_ACEOF
 
35168
for ac_lib in '' rt posix4; do
 
35169
  if test -z "$ac_lib"; then
 
35170
    ac_res="none required"
 
35171
  else
 
35172
    ac_res=-l$ac_lib
 
35173
    LIBS="-l$ac_lib  $ac_func_search_save_LIBS"
 
35174
  fi
 
35175
  if ac_fn_c_try_link "$LINENO"; then :
 
35176
  ac_cv_search_nanosleep=$ac_res
 
35177
fi
 
35178
rm -f core conftest.err conftest.$ac_objext \
 
35179
    conftest$ac_exeext
 
35180
  if ${ac_cv_search_nanosleep+:} false; then :
 
35181
  break
 
35182
fi
 
35183
done
 
35184
if ${ac_cv_search_nanosleep+:} false; then :
 
35185
 
 
35186
else
 
35187
  ac_cv_search_nanosleep=no
 
35188
fi
 
35189
rm conftest.$ac_ext
 
35190
LIBS=$ac_func_search_save_LIBS
 
35191
fi
 
35192
{ $as_echo "$as_me:${as_lineno-$LINENO}: result: $ac_cv_search_nanosleep" >&5
 
35193
$as_echo "$ac_cv_search_nanosleep" >&6; }
 
35194
ac_res=$ac_cv_search_nanosleep
 
35195
if test "$ac_res" != no; then :
 
35196
  test "$ac_res" = "none required" || LIBS="$ac_res $LIBS"
 
35197
  test "$ac_cv_search_nanosleep" = "none required" ||
 
35198
                 LIB_NANOSLEEP=$ac_cv_search_nanosleep
 
35199
fi
 
35200
 
 
35201
 if test "x$ac_cv_search_nanosleep" != xno; then
 
35202
 
 
35203
 
 
35204
   if test $APPLE_UNIVERSAL_BUILD = 1; then
 
35205
     # A universal build on Apple Mac OS X platforms.
 
35206
     # The test result would be 'no (mishandles large arguments)' in 64-bit
 
35207
     # mode but 'yes' in 32-bit mode. But we need a configuration result that
 
35208
     # is valid in both modes.
 
35209
     gl_cv_func_nanosleep='no (mishandles large arguments)'
 
35210
   fi
 
35211
 
 
35212
   { $as_echo "$as_me:${as_lineno-$LINENO}: checking for working nanosleep" >&5
 
35213
$as_echo_n "checking for working nanosleep... " >&6; }
 
35214
if ${gl_cv_func_nanosleep+:} false; then :
 
35215
  $as_echo_n "(cached) " >&6
 
35216
else
 
35217
 
 
35218
     if test "$cross_compiling" = yes; then :
 
35219
  case "$host_os" in           linux*) # Guess it halfway works when the kernel is Linux.
 
35220
            gl_cv_func_nanosleep='guessing no (mishandles large arguments)' ;;
 
35221
          *)      # If we don't know, assume the worst.
 
35222
            gl_cv_func_nanosleep='guessing no' ;;
 
35223
        esac
 
35224
 
 
35225
else
 
35226
  cat confdefs.h - <<_ACEOF >conftest.$ac_ext
 
35227
/* end confdefs.h.  */
 
35228
 
 
35229
          #include <errno.h>
 
35230
          #include <limits.h>
 
35231
          #include <signal.h>
 
35232
          #if HAVE_SYS_TIME_H
 
35233
           #include <sys/time.h>
 
35234
          #endif
 
35235
          #include <time.h>
 
35236
          #include <unistd.h>
 
35237
          #define TYPE_SIGNED(t) (! ((t) 0 < (t) -1))
 
35238
          #define TYPE_MAXIMUM(t) \
 
35239
            ((t) (! TYPE_SIGNED (t) \
 
35240
                  ? (t) -1 \
 
35241
                  : ((((t) 1 << (sizeof (t) * CHAR_BIT - 2)) - 1) * 2 + 1)))
 
35242
 
 
35243
          static void
 
35244
          check_for_SIGALRM (int sig)
 
35245
          {
 
35246
            if (sig != SIGALRM)
 
35247
              _exit (1);
 
35248
          }
 
35249
 
 
35250
          int
 
35251
          main ()
 
35252
          {
 
35253
            static struct timespec ts_sleep;
 
35254
            static struct timespec ts_remaining;
 
35255
            static struct sigaction act;
 
35256
            /* Test for major problems first.  */
 
35257
            if (! nanosleep)
 
35258
              return 2;
 
35259
            act.sa_handler = check_for_SIGALRM;
 
35260
            sigemptyset (&act.sa_mask);
 
35261
            sigaction (SIGALRM, &act, NULL);
 
35262
            ts_sleep.tv_sec = 0;
 
35263
            ts_sleep.tv_nsec = 1;
 
35264
            alarm (1);
 
35265
            if (nanosleep (&ts_sleep, NULL) != 0)
 
35266
              return 3;
 
35267
            /* Test for a minor problem: the handling of large arguments.  */
 
35268
            ts_sleep.tv_sec = TYPE_MAXIMUM (time_t);
 
35269
            ts_sleep.tv_nsec = 999999999;
 
35270
            alarm (1);
 
35271
            if (nanosleep (&ts_sleep, &ts_remaining) != -1)
 
35272
              return 4;
 
35273
            if (errno != EINTR)
 
35274
              return 5;
 
35275
            if (ts_remaining.tv_sec <= TYPE_MAXIMUM (time_t) - 10)
 
35276
              return 6;
 
35277
            return 0;
 
35278
          }
 
35279
_ACEOF
 
35280
if ac_fn_c_try_run "$LINENO"; then :
 
35281
  gl_cv_func_nanosleep=yes
 
35282
else
 
35283
  case $? in         4|5|6) gl_cv_func_nanosleep='no (mishandles large arguments)';;         *)   gl_cv_func_nanosleep=no;;
 
35284
        esac
 
35285
fi
 
35286
rm -f core *.core core.conftest.* gmon.out bb.out conftest$ac_exeext \
 
35287
  conftest.$ac_objext conftest.beam conftest.$ac_ext
 
35288
fi
 
35289
 
 
35290
 
 
35291
fi
 
35292
{ $as_echo "$as_me:${as_lineno-$LINENO}: result: $gl_cv_func_nanosleep" >&5
 
35293
$as_echo "$gl_cv_func_nanosleep" >&6; }
 
35294
   case "$gl_cv_func_nanosleep" in
 
35295
     *yes)
 
35296
       REPLACE_NANOSLEEP=0
 
35297
       ;;
 
35298
     *)
 
35299
       REPLACE_NANOSLEEP=1
 
35300
       case "$gl_cv_func_nanosleep" in
 
35301
         *"mishandles large arguments"*)
 
35302
 
 
35303
$as_echo "#define HAVE_BUG_BIG_NANOSLEEP 1" >>confdefs.h
 
35304
 
 
35305
           ;;
 
35306
         *)
 
35307
           # The replacement uses select(). Add $LIBSOCKET to $LIB_NANOSLEEP.
 
35308
           for ac_lib in $LIBSOCKET; do
 
35309
             case " $LIB_NANOSLEEP " in
 
35310
               *" $ac_lib "*) ;;
 
35311
               *) LIB_NANOSLEEP="$LIB_NANOSLEEP $ac_lib";;
 
35312
             esac
 
35313
           done
 
35314
           ;;
 
35315
       esac
 
35316
       ;;
 
35317
   esac
 
35318
 else
 
35319
   HAVE_NANOSLEEP=0
 
35320
 fi
 
35321
 LIBS=$nanosleep_save_libs
 
35322
 
 
35323
  if test $HAVE_NANOSLEEP = 0 || test $REPLACE_NANOSLEEP = 1; then
 
35324
 
 
35325
 
 
35326
 
 
35327
 
 
35328
 
 
35329
 
 
35330
 
 
35331
 
 
35332
  gl_LIBOBJS="$gl_LIBOBJS nanosleep.$ac_objext"
 
35333
 
 
35334
 
 
35335
 
 
35336
  :
 
35337
 
 
35338
 
 
35339
 
 
35340
 
 
35341
 
 
35342
  :
 
35343
 
 
35344
  fi
 
35345
 
 
35346
 
 
35347
 
 
35348
 
 
35349
 
 
35350
          GNULIB_NANOSLEEP=1
 
35351
 
 
35352
 
 
35353
 
 
35354
 
 
35355
 
 
35356
$as_echo "#define GNULIB_TEST_NANOSLEEP 1" >>confdefs.h
 
35357
 
 
35358
 
 
35359
 
 
35360
 
 
35361
 
 
35362
 
 
35363
 
34493
35364
  :
34494
35365
 
34495
35366
 
36135
37006
 
36136
37007
 
36137
37008
 
 
37009
 
 
37010
  if test "$ac_cv_header_winsock2_h" = yes; then
 
37011
    REPLACE_SELECT=1
 
37012
  else
 
37013
 
 
37014
  :
 
37015
 
 
37016
 
 
37017
 
 
37018
 
 
37019
 
 
37020
    { $as_echo "$as_me:${as_lineno-$LINENO}: checking whether select supports a 0 argument" >&5
 
37021
$as_echo_n "checking whether select supports a 0 argument... " >&6; }
 
37022
if ${gl_cv_func_select_supports0+:} false; then :
 
37023
  $as_echo_n "(cached) " >&6
 
37024
else
 
37025
 
 
37026
        if test "$cross_compiling" = yes; then :
 
37027
 
 
37028
           case "$host_os" in
 
37029
                       # Guess no on Interix.
 
37030
             interix*) gl_cv_func_select_supports0="guessing no";;
 
37031
                       # Guess yes otherwise.
 
37032
             *)        gl_cv_func_select_supports0="guessing yes";;
 
37033
           esac
 
37034
 
 
37035
else
 
37036
  cat confdefs.h - <<_ACEOF >conftest.$ac_ext
 
37037
/* end confdefs.h.  */
 
37038
 
 
37039
#include <sys/types.h>
 
37040
#include <sys/time.h>
 
37041
#if HAVE_SYS_SELECT_H
 
37042
#include <sys/select.h>
 
37043
#endif
 
37044
int main ()
 
37045
{
 
37046
  struct timeval timeout;
 
37047
  timeout.tv_sec = 0;
 
37048
  timeout.tv_usec = 5;
 
37049
  return select (0, (fd_set *)0, (fd_set *)0, (fd_set *)0, &timeout) < 0;
 
37050
}
 
37051
_ACEOF
 
37052
if ac_fn_c_try_run "$LINENO"; then :
 
37053
  gl_cv_func_select_supports0=yes
 
37054
else
 
37055
  gl_cv_func_select_supports0=no
 
37056
fi
 
37057
rm -f core *.core core.conftest.* gmon.out bb.out conftest$ac_exeext \
 
37058
  conftest.$ac_objext conftest.beam conftest.$ac_ext
 
37059
fi
 
37060
 
 
37061
 
 
37062
fi
 
37063
{ $as_echo "$as_me:${as_lineno-$LINENO}: result: $gl_cv_func_select_supports0" >&5
 
37064
$as_echo "$gl_cv_func_select_supports0" >&6; }
 
37065
    case "$gl_cv_func_select_supports0" in
 
37066
      *yes) ;;
 
37067
      *) REPLACE_SELECT=1 ;;
 
37068
    esac
 
37069
 
 
37070
        { $as_echo "$as_me:${as_lineno-$LINENO}: checking whether select detects invalid fds" >&5
 
37071
$as_echo_n "checking whether select detects invalid fds... " >&6; }
 
37072
if ${gl_cv_func_select_detects_ebadf+:} false; then :
 
37073
  $as_echo_n "(cached) " >&6
 
37074
else
 
37075
 
 
37076
        if test "$cross_compiling" = yes; then :
 
37077
 
 
37078
           case "$host_os" in
 
37079
                    # Guess yes on glibc systems.
 
37080
            *-gnu*) gl_cv_func_select_detects_ebadf="guessing yes" ;;
 
37081
                    # If we don't know, assume the worst.
 
37082
            *)      gl_cv_func_select_detects_ebadf="guessing no" ;;
 
37083
           esac
 
37084
 
 
37085
else
 
37086
  cat confdefs.h - <<_ACEOF >conftest.$ac_ext
 
37087
/* end confdefs.h.  */
 
37088
 
 
37089
#include <sys/types.h>
 
37090
#include <sys/time.h>
 
37091
#if HAVE_SYS_SELECT_H
 
37092
# include <sys/select.h>
 
37093
#endif
 
37094
#include <unistd.h>
 
37095
#include <errno.h>
 
37096
 
 
37097
int
 
37098
main ()
 
37099
{
 
37100
 
 
37101
  fd_set set;
 
37102
  dup2(0, 16);
 
37103
  FD_ZERO(&set);
 
37104
  FD_SET(16, &set);
 
37105
  close(16);
 
37106
  struct timeval timeout;
 
37107
  timeout.tv_sec = 0;
 
37108
  timeout.tv_usec = 5;
 
37109
  return select (17, &set, NULL, NULL, &timeout) != -1 || errno != EBADF;
 
37110
 
 
37111
  ;
 
37112
  return 0;
 
37113
}
 
37114
_ACEOF
 
37115
if ac_fn_c_try_run "$LINENO"; then :
 
37116
  gl_cv_func_select_detects_ebadf=yes
 
37117
else
 
37118
  gl_cv_func_select_detects_ebadf=no
 
37119
fi
 
37120
rm -f core *.core core.conftest.* gmon.out bb.out conftest$ac_exeext \
 
37121
  conftest.$ac_objext conftest.beam conftest.$ac_ext
 
37122
fi
 
37123
 
 
37124
 
 
37125
fi
 
37126
{ $as_echo "$as_me:${as_lineno-$LINENO}: result: $gl_cv_func_select_detects_ebadf" >&5
 
37127
$as_echo "$gl_cv_func_select_detects_ebadf" >&6; }
 
37128
    case $gl_cv_func_select_detects_ebadf in
 
37129
      *yes) ;;
 
37130
      *) REPLACE_SELECT=1 ;;
 
37131
    esac
 
37132
  fi
 
37133
 
 
37134
    LIB_SELECT="$LIBSOCKET"
 
37135
  if test $REPLACE_SELECT = 1; then
 
37136
    case "$host_os" in
 
37137
      mingw*)
 
37138
                                cat confdefs.h - <<_ACEOF >conftest.$ac_ext
 
37139
/* end confdefs.h.  */
 
37140
 
 
37141
#define WIN32_LEAN_AND_MEAN
 
37142
#include <windows.h>
 
37143
int
 
37144
main ()
 
37145
{
 
37146
  MsgWaitForMultipleObjects (0, NULL, 0, 0, 0);
 
37147
  return 0;
 
37148
}
 
37149
_ACEOF
 
37150
if ac_fn_c_try_link "$LINENO"; then :
 
37151
 
 
37152
else
 
37153
  LIB_SELECT="$LIB_SELECT -luser32"
 
37154
fi
 
37155
rm -f core conftest.err conftest.$ac_objext \
 
37156
    conftest$ac_exeext conftest.$ac_ext
 
37157
        ;;
 
37158
    esac
 
37159
  fi
 
37160
 
 
37161
 
 
37162
  if test $REPLACE_SELECT = 1; then
 
37163
 
 
37164
 
 
37165
 
 
37166
 
 
37167
 
 
37168
 
 
37169
 
 
37170
 
 
37171
  gl_LIBOBJS="$gl_LIBOBJS select.$ac_objext"
 
37172
 
 
37173
  fi
 
37174
 
 
37175
 
 
37176
 
 
37177
 
 
37178
 
 
37179
          GNULIB_SELECT=1
 
37180
 
 
37181
 
 
37182
 
 
37183
 
 
37184
 
 
37185
$as_echo "#define GNULIB_TEST_SELECT 1" >>confdefs.h
 
37186
 
 
37187
 
 
37188
 
 
37189
 
 
37190
 
36138
37191
     if test $ac_cv_func_setenv = no; then
36139
37192
    HAVE_SETENV=0
36140
37193
  else
36717
37770
 
36718
37771
 
36719
37772
 
 
37773
 
 
37774
 
 
37775
 
 
37776
 
 
37777
 
 
37778
  :
 
37779
 
 
37780
 
 
37781
 
 
37782
 
 
37783
 
 
37784
  if test $ac_cv_header_sys_socket_h != yes; then
 
37785
                    for ac_header in winsock2.h
 
37786
do :
 
37787
  ac_fn_c_check_header_mongrel "$LINENO" "winsock2.h" "ac_cv_header_winsock2_h" "$ac_includes_default"
 
37788
if test "x$ac_cv_header_winsock2_h" = xyes; then :
 
37789
  cat >>confdefs.h <<_ACEOF
 
37790
#define HAVE_WINSOCK2_H 1
 
37791
_ACEOF
 
37792
 
 
37793
fi
 
37794
 
 
37795
done
 
37796
 
 
37797
  fi
 
37798
  if test "$ac_cv_header_winsock2_h" = yes; then
 
37799
    HAVE_WINSOCK2_H=1
 
37800
    UNISTD_H_HAVE_WINSOCK2_H=1
 
37801
    SYS_IOCTL_H_HAVE_WINSOCK2_H=1
 
37802
  else
 
37803
    HAVE_WINSOCK2_H=0
 
37804
  fi
 
37805
 
 
37806
   LIBSOCKET=
 
37807
  if test $HAVE_WINSOCK2_H = 1; then
 
37808
        { $as_echo "$as_me:${as_lineno-$LINENO}: checking if we need to call WSAStartup in winsock2.h and -lws2_32" >&5
 
37809
$as_echo_n "checking if we need to call WSAStartup in winsock2.h and -lws2_32... " >&6; }
 
37810
if ${gl_cv_func_wsastartup+:} false; then :
 
37811
  $as_echo_n "(cached) " >&6
 
37812
else
 
37813
 
 
37814
      gl_save_LIBS="$LIBS"
 
37815
      LIBS="$LIBS -lws2_32"
 
37816
      cat confdefs.h - <<_ACEOF >conftest.$ac_ext
 
37817
/* end confdefs.h.  */
 
37818
 
 
37819
#ifdef HAVE_WINSOCK2_H
 
37820
# include <winsock2.h>
 
37821
#endif
 
37822
int
 
37823
main ()
 
37824
{
 
37825
 
 
37826
          WORD wVersionRequested = MAKEWORD(1, 1);
 
37827
          WSADATA wsaData;
 
37828
          int err = WSAStartup(wVersionRequested, &wsaData);
 
37829
          WSACleanup ();
 
37830
  ;
 
37831
  return 0;
 
37832
}
 
37833
_ACEOF
 
37834
if ac_fn_c_try_link "$LINENO"; then :
 
37835
  gl_cv_func_wsastartup=yes
 
37836
else
 
37837
  gl_cv_func_wsastartup=no
 
37838
fi
 
37839
rm -f core conftest.err conftest.$ac_objext \
 
37840
    conftest$ac_exeext conftest.$ac_ext
 
37841
      LIBS="$gl_save_LIBS"
 
37842
 
 
37843
fi
 
37844
{ $as_echo "$as_me:${as_lineno-$LINENO}: result: $gl_cv_func_wsastartup" >&5
 
37845
$as_echo "$gl_cv_func_wsastartup" >&6; }
 
37846
    if test "$gl_cv_func_wsastartup" = "yes"; then
 
37847
 
 
37848
$as_echo "#define WINDOWS_SOCKETS 1" >>confdefs.h
 
37849
 
 
37850
      LIBSOCKET='-lws2_32'
 
37851
    fi
 
37852
  else
 
37853
                    { $as_echo "$as_me:${as_lineno-$LINENO}: checking for library containing setsockopt" >&5
 
37854
$as_echo_n "checking for library containing setsockopt... " >&6; }
 
37855
if ${gl_cv_lib_socket+:} false; then :
 
37856
  $as_echo_n "(cached) " >&6
 
37857
else
 
37858
 
 
37859
      gl_cv_lib_socket=
 
37860
      cat confdefs.h - <<_ACEOF >conftest.$ac_ext
 
37861
/* end confdefs.h.  */
 
37862
extern
 
37863
#ifdef __cplusplus
 
37864
"C"
 
37865
#endif
 
37866
char setsockopt();
 
37867
int
 
37868
main ()
 
37869
{
 
37870
setsockopt();
 
37871
  ;
 
37872
  return 0;
 
37873
}
 
37874
_ACEOF
 
37875
if ac_fn_c_try_link "$LINENO"; then :
 
37876
 
 
37877
else
 
37878
  gl_save_LIBS="$LIBS"
 
37879
         LIBS="$gl_save_LIBS -lsocket"
 
37880
         cat confdefs.h - <<_ACEOF >conftest.$ac_ext
 
37881
/* end confdefs.h.  */
 
37882
extern
 
37883
#ifdef __cplusplus
 
37884
"C"
 
37885
#endif
 
37886
char setsockopt();
 
37887
int
 
37888
main ()
 
37889
{
 
37890
setsockopt();
 
37891
  ;
 
37892
  return 0;
 
37893
}
 
37894
_ACEOF
 
37895
if ac_fn_c_try_link "$LINENO"; then :
 
37896
  gl_cv_lib_socket="-lsocket"
 
37897
fi
 
37898
rm -f core conftest.err conftest.$ac_objext \
 
37899
    conftest$ac_exeext conftest.$ac_ext
 
37900
         if test -z "$gl_cv_lib_socket"; then
 
37901
           LIBS="$gl_save_LIBS -lnetwork"
 
37902
           cat confdefs.h - <<_ACEOF >conftest.$ac_ext
 
37903
/* end confdefs.h.  */
 
37904
extern
 
37905
#ifdef __cplusplus
 
37906
"C"
 
37907
#endif
 
37908
char setsockopt();
 
37909
int
 
37910
main ()
 
37911
{
 
37912
setsockopt();
 
37913
  ;
 
37914
  return 0;
 
37915
}
 
37916
_ACEOF
 
37917
if ac_fn_c_try_link "$LINENO"; then :
 
37918
  gl_cv_lib_socket="-lnetwork"
 
37919
fi
 
37920
rm -f core conftest.err conftest.$ac_objext \
 
37921
    conftest$ac_exeext conftest.$ac_ext
 
37922
           if test -z "$gl_cv_lib_socket"; then
 
37923
             LIBS="$gl_save_LIBS -lnet"
 
37924
             cat confdefs.h - <<_ACEOF >conftest.$ac_ext
 
37925
/* end confdefs.h.  */
 
37926
extern
 
37927
#ifdef __cplusplus
 
37928
"C"
 
37929
#endif
 
37930
char setsockopt();
 
37931
int
 
37932
main ()
 
37933
{
 
37934
setsockopt();
 
37935
  ;
 
37936
  return 0;
 
37937
}
 
37938
_ACEOF
 
37939
if ac_fn_c_try_link "$LINENO"; then :
 
37940
  gl_cv_lib_socket="-lnet"
 
37941
fi
 
37942
rm -f core conftest.err conftest.$ac_objext \
 
37943
    conftest$ac_exeext conftest.$ac_ext
 
37944
           fi
 
37945
         fi
 
37946
         LIBS="$gl_save_LIBS"
 
37947
 
 
37948
fi
 
37949
rm -f core conftest.err conftest.$ac_objext \
 
37950
    conftest$ac_exeext conftest.$ac_ext
 
37951
      if test -z "$gl_cv_lib_socket"; then
 
37952
        gl_cv_lib_socket="none needed"
 
37953
      fi
 
37954
 
 
37955
fi
 
37956
{ $as_echo "$as_me:${as_lineno-$LINENO}: result: $gl_cv_lib_socket" >&5
 
37957
$as_echo "$gl_cv_lib_socket" >&6; }
 
37958
    if test "$gl_cv_lib_socket" != "none needed"; then
 
37959
      LIBSOCKET="$gl_cv_lib_socket"
 
37960
    fi
 
37961
  fi
 
37962
 
 
37963
 
 
37964
 
 
37965
 
 
37966
 
 
37967
 
 
37968
  :
 
37969
 
 
37970
 
36720
37971
     ac_fn_c_check_type "$LINENO" "socklen_t" "ac_cv_type_socklen_t" "
36721
37972
/* <sys/types.h> is not needed according to POSIX, but the
36722
37973
   <sys/socket.h> in i386-unknown-freebsd4.10 and
38770
40021
 
38771
40022
 
38772
40023
 
 
40024
  { $as_echo "$as_me:${as_lineno-$LINENO}: checking whether <sys/select.h> is self-contained" >&5
 
40025
$as_echo_n "checking whether <sys/select.h> is self-contained... " >&6; }
 
40026
if ${gl_cv_header_sys_select_h_selfcontained+:} false; then :
 
40027
  $as_echo_n "(cached) " >&6
 
40028
else
 
40029
 
 
40030
                                    cat confdefs.h - <<_ACEOF >conftest.$ac_ext
 
40031
/* end confdefs.h.  */
 
40032
#include <sys/select.h>
 
40033
int
 
40034
main ()
 
40035
{
 
40036
struct timeval b;
 
40037
  ;
 
40038
  return 0;
 
40039
}
 
40040
_ACEOF
 
40041
if ac_fn_c_try_compile "$LINENO"; then :
 
40042
  gl_cv_header_sys_select_h_selfcontained=yes
 
40043
else
 
40044
  gl_cv_header_sys_select_h_selfcontained=no
 
40045
fi
 
40046
rm -f core conftest.err conftest.$ac_objext conftest.$ac_ext
 
40047
                        if test $gl_cv_header_sys_select_h_selfcontained = yes; then
 
40048
        cat confdefs.h - <<_ACEOF >conftest.$ac_ext
 
40049
/* end confdefs.h.  */
 
40050
#include <sys/select.h>
 
40051
int
 
40052
main ()
 
40053
{
 
40054
int memset; int bzero;
 
40055
  ;
 
40056
  return 0;
 
40057
}
 
40058
 
 
40059
_ACEOF
 
40060
if ac_fn_c_try_compile "$LINENO"; then :
 
40061
  cat confdefs.h - <<_ACEOF >conftest.$ac_ext
 
40062
/* end confdefs.h.  */
 
40063
#include <sys/select.h>
 
40064
int
 
40065
main ()
 
40066
{
 
40067
 
 
40068
                  #undef memset
 
40069
                  #define memset nonexistent_memset
 
40070
                  extern
 
40071
                  #ifdef __cplusplus
 
40072
                  "C"
 
40073
                  #endif
 
40074
                  void *memset (void *, int, unsigned long);
 
40075
                  #undef bzero
 
40076
                  #define bzero nonexistent_bzero
 
40077
                  extern
 
40078
                  #ifdef __cplusplus
 
40079
                  "C"
 
40080
                  #endif
 
40081
                  void bzero (void *, unsigned long);
 
40082
                  fd_set fds;
 
40083
                  FD_ZERO (&fds);
 
40084
 
 
40085
  ;
 
40086
  return 0;
 
40087
}
 
40088
 
 
40089
_ACEOF
 
40090
if ac_fn_c_try_link "$LINENO"; then :
 
40091
 
 
40092
else
 
40093
  gl_cv_header_sys_select_h_selfcontained=no
 
40094
fi
 
40095
rm -f core conftest.err conftest.$ac_objext \
 
40096
    conftest$ac_exeext conftest.$ac_ext
 
40097
 
 
40098
fi
 
40099
rm -f core conftest.err conftest.$ac_objext conftest.$ac_ext
 
40100
      fi
 
40101
 
 
40102
fi
 
40103
{ $as_echo "$as_me:${as_lineno-$LINENO}: result: $gl_cv_header_sys_select_h_selfcontained" >&5
 
40104
$as_echo "$gl_cv_header_sys_select_h_selfcontained" >&6; }
 
40105
 
 
40106
 
 
40107
 
 
40108
 
 
40109
 
 
40110
 
 
40111
  :
 
40112
 
 
40113
 
 
40114
 
 
40115
 
 
40116
 
 
40117
 
 
40118
 
 
40119
 
 
40120
     if test $gl_cv_have_include_next = yes; then
 
40121
       gl_cv_next_sys_select_h='<'sys/select.h'>'
 
40122
     else
 
40123
       { $as_echo "$as_me:${as_lineno-$LINENO}: checking absolute name of <sys/select.h>" >&5
 
40124
$as_echo_n "checking absolute name of <sys/select.h>... " >&6; }
 
40125
if ${gl_cv_next_sys_select_h+:} false; then :
 
40126
  $as_echo_n "(cached) " >&6
 
40127
else
 
40128
 
 
40129
             if test $ac_cv_header_sys_select_h = yes; then
 
40130
 
 
40131
 
 
40132
 
 
40133
 
 
40134
  cat confdefs.h - <<_ACEOF >conftest.$ac_ext
 
40135
/* end confdefs.h.  */
 
40136
#include <sys/select.h>
 
40137
_ACEOF
 
40138
                case "$host_os" in
 
40139
    aix*) gl_absname_cpp="$ac_cpp -C" ;;
 
40140
    *)    gl_absname_cpp="$ac_cpp" ;;
 
40141
  esac
 
40142
 
 
40143
  case "$host_os" in
 
40144
    mingw*)
 
40145
                                          gl_dirsep_regex='[/\\]'
 
40146
      ;;
 
40147
    *)
 
40148
      gl_dirsep_regex='\/'
 
40149
      ;;
 
40150
  esac
 
40151
      gl_make_literal_regex_sed='s,[]$^\\.*/[],\\&,g'
 
40152
  gl_header_literal_regex=`echo 'sys/select.h' \
 
40153
                           | sed -e "$gl_make_literal_regex_sed"`
 
40154
  gl_absolute_header_sed="/${gl_dirsep_regex}${gl_header_literal_regex}/"'{
 
40155
      s/.*"\(.*'"${gl_dirsep_regex}${gl_header_literal_regex}"'\)".*/\1/
 
40156
      s|^/[^/]|//&|
 
40157
      p
 
40158
      q
 
40159
    }'
 
40160
 
 
40161
        gl_cv_absolute_sys_select_h=`(eval "$gl_absname_cpp conftest.$ac_ext") 2>&5 |
 
40162
  sed -n "$gl_absolute_header_sed"`
 
40163
 
 
40164
           gl_header=$gl_cv_absolute_sys_select_h
 
40165
           gl_cv_next_sys_select_h='"'$gl_header'"'
 
40166
          else
 
40167
               gl_cv_next_sys_select_h='<'sys/select.h'>'
 
40168
             fi
 
40169
 
 
40170
 
 
40171
fi
 
40172
{ $as_echo "$as_me:${as_lineno-$LINENO}: result: $gl_cv_next_sys_select_h" >&5
 
40173
$as_echo "$gl_cv_next_sys_select_h" >&6; }
 
40174
     fi
 
40175
     NEXT_SYS_SELECT_H=$gl_cv_next_sys_select_h
 
40176
 
 
40177
     if test $gl_cv_have_include_next = yes || test $gl_cv_have_include_next = buggy; then
 
40178
       # INCLUDE_NEXT_AS_FIRST_DIRECTIVE='include_next'
 
40179
       gl_next_as_first_directive='<'sys/select.h'>'
 
40180
     else
 
40181
       # INCLUDE_NEXT_AS_FIRST_DIRECTIVE='include'
 
40182
       gl_next_as_first_directive=$gl_cv_next_sys_select_h
 
40183
     fi
 
40184
     NEXT_AS_FIRST_DIRECTIVE_SYS_SELECT_H=$gl_next_as_first_directive
 
40185
 
 
40186
 
 
40187
 
 
40188
 
 
40189
  if test $ac_cv_header_sys_select_h = yes; then
 
40190
    HAVE_SYS_SELECT_H=1
 
40191
  else
 
40192
    HAVE_SYS_SELECT_H=0
 
40193
  fi
 
40194
 
 
40195
 
 
40196
 
 
40197
 
 
40198
 
 
40199
  :
 
40200
 
 
40201
 
 
40202
 
 
40203
 
 
40204
 
 
40205
  if test $ac_cv_header_sys_socket_h != yes; then
 
40206
                    for ac_header in winsock2.h
 
40207
do :
 
40208
  ac_fn_c_check_header_mongrel "$LINENO" "winsock2.h" "ac_cv_header_winsock2_h" "$ac_includes_default"
 
40209
if test "x$ac_cv_header_winsock2_h" = xyes; then :
 
40210
  cat >>confdefs.h <<_ACEOF
 
40211
#define HAVE_WINSOCK2_H 1
 
40212
_ACEOF
 
40213
 
 
40214
fi
 
40215
 
 
40216
done
 
40217
 
 
40218
  fi
 
40219
  if test "$ac_cv_header_winsock2_h" = yes; then
 
40220
    HAVE_WINSOCK2_H=1
 
40221
    UNISTD_H_HAVE_WINSOCK2_H=1
 
40222
    SYS_IOCTL_H_HAVE_WINSOCK2_H=1
 
40223
  else
 
40224
    HAVE_WINSOCK2_H=0
 
40225
  fi
 
40226
 
 
40227
 
 
40228
 
 
40229
 
 
40230
    for gl_func in pselect select; do
 
40231
    as_gl_Symbol=`$as_echo "gl_cv_have_raw_decl_$gl_func" | $as_tr_sh`
 
40232
    { $as_echo "$as_me:${as_lineno-$LINENO}: checking whether $gl_func is declared without a macro" >&5
 
40233
$as_echo_n "checking whether $gl_func is declared without a macro... " >&6; }
 
40234
if eval \${$as_gl_Symbol+:} false; then :
 
40235
  $as_echo_n "(cached) " >&6
 
40236
else
 
40237
  cat confdefs.h - <<_ACEOF >conftest.$ac_ext
 
40238
/* end confdefs.h.  */
 
40239
 
 
40240
/* Some systems require prerequisite headers.  */
 
40241
#include <sys/types.h>
 
40242
#if !(defined __GLIBC__ && !defined __UCLIBC__) && HAVE_SYS_TIME_H
 
40243
# include <sys/time.h>
 
40244
#endif
 
40245
#include <sys/select.h>
 
40246
 
 
40247
int
 
40248
main ()
 
40249
{
 
40250
#undef $gl_func
 
40251
  (void) $gl_func;
 
40252
  ;
 
40253
  return 0;
 
40254
}
 
40255
_ACEOF
 
40256
if ac_fn_c_try_compile "$LINENO"; then :
 
40257
  eval "$as_gl_Symbol=yes"
 
40258
else
 
40259
  eval "$as_gl_Symbol=no"
 
40260
fi
 
40261
rm -f core conftest.err conftest.$ac_objext conftest.$ac_ext
 
40262
fi
 
40263
eval ac_res=\$$as_gl_Symbol
 
40264
               { $as_echo "$as_me:${as_lineno-$LINENO}: result: $ac_res" >&5
 
40265
$as_echo "$ac_res" >&6; }
 
40266
    if eval test \"x\$"$as_gl_Symbol"\" = x"yes"; then :
 
40267
  cat >>confdefs.h <<_ACEOF
 
40268
#define `$as_echo "HAVE_RAW_DECL_$gl_func" | $as_tr_cpp` 1
 
40269
_ACEOF
 
40270
 
 
40271
                     eval ac_cv_have_decl_$gl_func=yes
 
40272
fi
 
40273
      done
 
40274
 
 
40275
 
 
40276
 
 
40277
 
 
40278
 
 
40279
 
38773
40280
 
38774
40281
        case "$host_os" in
38775
40282
    osf*)
43611
45118
fi
43612
45119
 
43613
45120
 
43614
 
# Do we have any kind of high-precision file timestamps?
43615
 
if test "x$ac_cv_member_struct_stat_st_atim_tv_nsec" = xyes || \
43616
 
   test "x$ac_cv_member_struct_stat_st_atimespec_tv_nsec" = xyes || \
43617
 
   test "x$ac_cv_member_struct_stat_st_atimensec" = xyes || \
43618
 
   test "x$ac_cv_member_struct_stat_st_atim_st__tim_tv_nsec" = xyes; then
43619
 
        STAT_HAS_NSEC=yes
43620
 
else
43621
 
        STAT_HAS_NSEC=no
43622
 
fi
43623
 
 
43624
 
 
43625
45121
# Check for pipeline library.
43626
45122
 
43627
45123
 
45156
46652
# report actual input values of CONFIG_FILES etc. instead of their
45157
46653
# values after options handling.
45158
46654
ac_log="
45159
 
This file was extended by man-db $as_me 2.7.0, which was
 
46655
This file was extended by man-db $as_me 2.7.0.1, which was
45160
46656
generated by GNU Autoconf 2.69.  Invocation command line was
45161
46657
 
45162
46658
  CONFIG_FILES    = $CONFIG_FILES
45222
46718
cat >>$CONFIG_STATUS <<_ACEOF || ac_write_fail=1
45223
46719
ac_cs_config="`$as_echo "$ac_configure_args" | sed 's/^ //; s/[\\""\`\$]/\\\\&/g'`"
45224
46720
ac_cs_version="\\
45225
 
man-db config.status 2.7.0
 
46721
man-db config.status 2.7.0.1
45226
46722
configured by $0, generated by GNU Autoconf 2.69,
45227
46723
  with options \\"\$ac_cs_config\\"
45228
46724