~ubuntu-branches/ubuntu/trusty/psqlodbc/trusty-proposed

« back to all changes in this revision

Viewing changes to configure

  • Committer: Bazaar Package Importer
  • Author(s): Christoph Berg
  • Date: 2011-04-05 14:48:23 UTC
  • mfrom: (1.1.6 upstream)
  • Revision ID: james.westby@ubuntu.com-20110405144823-n77supsa1hjj0ik6
Tags: 1:09.00.0200-1
* New upstream release.
* Fix installing {A,W}/usr/lib/odbc.  Closes: #618210.
* Convert to 3.0 (quilt).
* Remove psqlodbc-580878.diff: implemented upstream.
* Remove psqlodbc-585476.diff: was caused by #519006 which is now closed.
* Update description, suggested by Martin Eberhard Schauer.
  Closes: #565611.
* New maintainer.  Closes: #472818.

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.60 for psqlodbc 08.03.0200.
 
3
# Generated by GNU Autoconf 2.60 for psqlodbc 09.00.0200.
4
4
#
5
5
# Report bugs to <pgsql-odbc@postgresql.org>.
6
6
#
713
713
# Identity of this package.
714
714
PACKAGE_NAME='psqlodbc'
715
715
PACKAGE_TARNAME='psqlodbc'
716
 
PACKAGE_VERSION='08.03.0200'
717
 
PACKAGE_STRING='psqlodbc 08.03.0200'
 
716
PACKAGE_VERSION='09.00.0200'
 
717
PACKAGE_STRING='psqlodbc 09.00.0200'
718
718
PACKAGE_BUGREPORT='pgsql-odbc@postgresql.org'
719
719
 
720
720
ac_unique_file="bind.c"
816
816
MAINTAINER_MODE_FALSE
817
817
MAINT
818
818
ODBC_CONFIG
819
 
enable_unicode_TRUE
820
 
enable_unicode_FALSE
821
 
enable_openssl_TRUE
822
 
enable_openssl_FALSE
823
 
PG_CONFIG
824
819
CC
825
820
CFLAGS
826
821
LDFLAGS
837
832
CCDEPMODE
838
833
am__fastdepCC_TRUE
839
834
am__fastdepCC_FALSE
 
835
enable_unicode_TRUE
 
836
enable_unicode_FALSE
 
837
enable_openssl_TRUE
 
838
enable_openssl_FALSE
 
839
enable_gss_TRUE
 
840
enable_gss_FALSE
 
841
enable_krb5_TRUE
 
842
enable_krb5_FALSE
 
843
PG_CONFIG
 
844
GCC_TRUE
 
845
GCC_FALSE
840
846
build
841
847
build_cpu
842
848
build_vendor
1385
1391
  # Omit some internal or obsolete options to make the list less imposing.
1386
1392
  # This message is too long to be a string in the A/UX 3.1 sh.
1387
1393
  cat <<_ACEOF
1388
 
\`configure' configures psqlodbc 08.03.0200 to adapt to many kinds of systems.
 
1394
\`configure' configures psqlodbc 09.00.0200 to adapt to many kinds of systems.
1389
1395
 
1390
1396
Usage: $0 [OPTION]... [VAR=VALUE]...
1391
1397
 
1455
1461
 
1456
1462
if test -n "$ac_init_help"; then
1457
1463
  case $ac_init_help in
1458
 
     short | recursive ) echo "Configuration of psqlodbc 08.03.0200:";;
 
1464
     short | recursive ) echo "Configuration of psqlodbc 09.00.0200:";;
1459
1465
   esac
1460
1466
  cat <<\_ACEOF
1461
1467
 
1464
1470
  --enable-FEATURE[=ARG]  include FEATURE [ARG=yes]
1465
1471
  --enable-maintainer-mode  enable make rules and dependencies not useful
1466
1472
                          (and sometimes confusing) to the casual installer
 
1473
  --disable-dependency-tracking  speeds up one-time build
 
1474
  --enable-dependency-tracking   do not reject slow dependency extractors
1467
1475
  --disable-unicode       do not build Unicode support
1468
1476
  --disable-openssl       do not build OpenSSL support
 
1477
  --disable-gss       do not build GSSAPI support
 
1478
  --disable-krb5       do not build Kerberos5 support
1469
1479
  --disable-pthreads      do not build with POSIX threads
1470
 
  --disable-dependency-tracking  speeds up one-time build
1471
 
  --enable-dependency-tracking   do not reject slow dependency extractors
1472
1480
  --enable-static[=PKGS]  build static libraries [default=no]
1473
1481
  --enable-shared[=PKGS]  build shared libraries [default=yes]
1474
1482
  --enable-fast-install[=PKGS]
1480
1488
  --without-PACKAGE       do not use PACKAGE (same as --with-PACKAGE=no)
1481
1489
  --with-unixodbc=DIR     odbc_config installation of unixODBC (default)
1482
1490
  --with-iodbc=DIR        iodbc_config installation of iODBC
 
1491
  --with-libpq[=DIR]      [default=yes] DIR is the PostgreSQL base install
 
1492
                          directory or the path to pg_config
 
1493
  --without-libpq         specify when PostgreSQL package isn't installed
1483
1494
  --with-odbcver=VERSION  change default ODBC version number [0x0351]
1484
1495
  --with-gnu-ld           assume the C compiler uses GNU ld [default=no]
1485
1496
  --with-pic              try to use only PIC/non-PIC objects [default=use
1564
1575
test -n "$ac_init_help" && exit $ac_status
1565
1576
if $ac_init_version; then
1566
1577
  cat <<\_ACEOF
1567
 
psqlodbc configure 08.03.0200
 
1578
psqlodbc configure 09.00.0200
1568
1579
generated by GNU Autoconf 2.60
1569
1580
 
1570
1581
Copyright (C) 1992, 1993, 1994, 1995, 1996, 1998, 1999, 2000, 2001,
1578
1589
This file contains any messages produced by compilers while
1579
1590
running configure, to aid debugging if configure makes a mistake.
1580
1591
 
1581
 
It was created by psqlodbc $as_me 08.03.0200, which was
 
1592
It was created by psqlodbc $as_me 09.00.0200, which was
1582
1593
generated by GNU Autoconf 2.60.  Invocation command line was
1583
1594
 
1584
1595
  $ $0 $@
2249
2260
 
2250
2261
# Define the identity of the package.
2251
2262
 PACKAGE='psqlodbc'
2252
 
 VERSION='08.03.0200'
 
2263
 VERSION='09.00.0200'
2253
2264
 
2254
2265
 
2255
2266
cat >>confdefs.h <<_ACEOF
2428
2439
 
2429
2440
 
2430
2441
#
2431
 
# Decide which unixODBC driver manager to use
 
2442
# Whether unixODBC driver manager is used
2432
2443
#
2433
2444
 
2434
2445
# Check whether --with-unixodbc was given.
2493
2504
                else
2494
2505
                        ODBC_CONFIG=${ODBC_CONFIG}/bin/odbc_config
2495
2506
                fi
 
2507
                with_unixodbc=yes
2496
2508
        fi
2497
2509
 
2498
 
        with_unixodbc=yes
2499
2510
else
2500
2511
  with_unixodbc=yes
2501
2512
fi
2503
2514
 
2504
2515
 
2505
2516
#
2506
 
# Decide which iODBC driver manager to use
 
2517
# Whether iODBC driver manager is used
2507
2518
#
2508
2519
 
2509
2520
# Check whether --with-iodbc was given.
2568
2579
                else
2569
2580
                        ODBC_CONFIG=${ODBC_CONFIG}/bin/iodbc-config
2570
2581
                fi
 
2582
                with_iodbc=yes
2571
2583
        fi
2572
2584
 
2573
 
        with_iodbc=yes
2574
2585
else
2575
2586
  with_iodbc=no
2576
2587
fi
2592
2603
#define WITH_UNIXODBC 1
2593
2604
_ACEOF
2594
2605
 
2595
 
 
2596
 
cat >>confdefs.h <<\_ACEOF
2597
 
#define SQL_WCHART_CONVERT
2598
 
_ACEOF
2599
 
 
2600
2606
fi
2601
2607
 
2602
 
 
2603
2608
#
2604
2609
# ODBC include and library
2605
2610
#
2620
2625
echo "$as_me: using $ODBC_INCLUDE $ODBC_LIBS" >&6;}
2621
2626
fi
2622
2627
 
2623
 
 
2624
 
#
2625
 
# Default odbc version number (--with-odbcver), default 0x0351
2626
 
#
2627
 
 
2628
 
 
2629
 
pgac_args="$pgac_args with_odbcver"
2630
 
 
2631
 
 
2632
 
# Check whether --with-odbcver was given.
2633
 
if test "${with_odbcver+set}" = set; then
2634
 
  withval=$with_odbcver;
2635
 
  case $withval in
2636
 
    yes)
2637
 
      { { echo "$as_me:$LINENO: error: argument required for --with-odbcver option" >&5
2638
 
echo "$as_me: error: argument required for --with-odbcver option" >&2;}
2639
 
   { (exit 1); exit 1; }; }
2640
 
      ;;
2641
 
    no)
2642
 
      { { echo "$as_me:$LINENO: error: argument required for --with-odbcver option" >&5
2643
 
echo "$as_me: error: argument required for --with-odbcver option" >&2;}
2644
 
   { (exit 1); exit 1; }; }
2645
 
      ;;
2646
 
    *)
2647
 
 
2648
 
      ;;
2649
 
  esac
2650
 
 
2651
 
else
2652
 
  with_odbcver=0x0351
2653
 
fi
2654
 
 
2655
 
 
2656
 
 
2657
 
cat >>confdefs.h <<_ACEOF
2658
 
#define ODBCVER $with_odbcver
2659
 
_ACEOF
2660
 
 
2661
 
 
2662
 
 
2663
 
#
2664
 
# Unicode support
2665
 
#
2666
 
 
2667
 
 
2668
 
pgac_args="$pgac_args enable_unicode"
2669
 
 
2670
 
# Check whether --enable-unicode was given.
2671
 
if test "${enable_unicode+set}" = set; then
2672
 
  enableval=$enable_unicode;
2673
 
  case $enableval in
2674
 
    yes)
2675
 
 
2676
 
cat >>confdefs.h <<\_ACEOF
2677
 
#define UNICODE_SUPPORT 1
2678
 
_ACEOF
2679
 
 
2680
 
      ;;
2681
 
    no)
2682
 
      :
2683
 
      ;;
2684
 
    *)
2685
 
      { { echo "$as_me:$LINENO: error: no argument expected for --enable-unicode option" >&5
2686
 
echo "$as_me: error: no argument expected for --enable-unicode option" >&2;}
2687
 
   { (exit 1); exit 1; }; }
2688
 
      ;;
2689
 
  esac
2690
 
 
2691
 
else
2692
 
  enable_unicode=yes
2693
 
 
2694
 
cat >>confdefs.h <<\_ACEOF
2695
 
#define UNICODE_SUPPORT 1
2696
 
_ACEOF
2697
 
 
2698
 
fi
2699
 
 
2700
 
 
2701
 
 
2702
 
 
2703
 
 
2704
 
if test x"$enable_unicode" = xyes; then
2705
 
  enable_unicode_TRUE=
2706
 
  enable_unicode_FALSE='#'
2707
 
else
2708
 
  enable_unicode_TRUE='#'
2709
 
  enable_unicode_FALSE=
2710
 
fi
2711
 
 
2712
 
 
2713
 
 
2714
 
#
2715
 
# SSL support
2716
 
#
2717
 
 
2718
 
 
2719
 
pgac_args="$pgac_args enable_openssl"
2720
 
 
2721
 
# Check whether --enable-openssl was given.
2722
 
if test "${enable_openssl+set}" = set; then
2723
 
  enableval=$enable_openssl;
2724
 
  case $enableval in
2725
 
    yes)
2726
 
 
2727
 
cat >>confdefs.h <<\_ACEOF
2728
 
#define USE_SSL 1
2729
 
_ACEOF
2730
 
 
2731
 
      ;;
2732
 
    no)
2733
 
      :
2734
 
      ;;
2735
 
    *)
2736
 
      { { echo "$as_me:$LINENO: error: no argument expected for --enable-openssl option" >&5
2737
 
echo "$as_me: error: no argument expected for --enable-openssl option" >&2;}
2738
 
   { (exit 1); exit 1; }; }
2739
 
      ;;
2740
 
  esac
2741
 
 
2742
 
else
2743
 
  enable_openssl=yes
2744
 
 
2745
 
cat >>confdefs.h <<\_ACEOF
2746
 
#define USE_SSL 1
2747
 
_ACEOF
2748
 
 
2749
 
fi
2750
 
 
2751
 
 
2752
 
 
2753
 
 
2754
 
 
2755
 
if test x"$enable_openssl" = xyes; then
2756
 
  enable_openssl_TRUE=
2757
 
  enable_openssl_FALSE='#'
2758
 
else
2759
 
  enable_openssl_TRUE='#'
2760
 
  enable_openssl_FALSE=
2761
 
fi
2762
 
 
2763
 
 
2764
 
#
2765
 
# Pthreads
2766
 
#
2767
 
 
2768
 
 
2769
 
pgac_args="$pgac_args enable_pthreads"
2770
 
 
2771
 
# Check whether --enable-pthreads was given.
2772
 
if test "${enable_pthreads+set}" = set; then
2773
 
  enableval=$enable_pthreads;
2774
 
  case $enableval in
2775
 
    yes)
2776
 
 
2777
 
cat >>confdefs.h <<\_ACEOF
2778
 
#define POSIX_MULTITHREAD_SUPPORT 1
2779
 
_ACEOF
2780
 
 
2781
 
 
2782
 
cat >>confdefs.h <<\_ACEOF
2783
 
#define _REENTRANT 1
2784
 
_ACEOF
2785
 
 
2786
 
      ;;
2787
 
    no)
2788
 
      :
2789
 
      ;;
2790
 
    *)
2791
 
      { { echo "$as_me:$LINENO: error: no argument expected for --enable-pthreads option" >&5
2792
 
echo "$as_me: error: no argument expected for --enable-pthreads option" >&2;}
2793
 
   { (exit 1); exit 1; }; }
2794
 
      ;;
2795
 
  esac
2796
 
 
2797
 
else
2798
 
  enable_pthreads=yes
2799
 
 
2800
 
cat >>confdefs.h <<\_ACEOF
2801
 
#define POSIX_MULTITHREAD_SUPPORT 1
2802
 
_ACEOF
2803
 
 
2804
 
 
2805
 
cat >>confdefs.h <<\_ACEOF
2806
 
#define _REENTRANT 1
2807
 
_ACEOF
2808
 
 
2809
 
fi
2810
 
 
2811
 
 
2812
 
 
2813
 
 
2814
 
#
2815
 
# Find libpq headers and libraries
2816
 
#
2817
 
 
2818
 
for ac_prog in pg_config
2819
 
do
2820
 
  # Extract the first word of "$ac_prog", so it can be a program name with args.
2821
 
set dummy $ac_prog; ac_word=$2
2822
 
{ echo "$as_me:$LINENO: checking for $ac_word" >&5
2823
 
echo $ECHO_N "checking for $ac_word... $ECHO_C" >&6; }
2824
 
if test "${ac_cv_path_PG_CONFIG+set}" = set; then
2825
 
  echo $ECHO_N "(cached) $ECHO_C" >&6
2826
 
else
2827
 
  case $PG_CONFIG in
2828
 
  [\\/]* | ?:[\\/]*)
2829
 
  ac_cv_path_PG_CONFIG="$PG_CONFIG" # Let the user override the test with a path.
2830
 
  ;;
2831
 
  *)
2832
 
  as_save_IFS=$IFS; IFS=$PATH_SEPARATOR
2833
 
for as_dir in $PATH
2834
 
do
2835
 
  IFS=$as_save_IFS
2836
 
  test -z "$as_dir" && as_dir=.
2837
 
  for ac_exec_ext in '' $ac_executable_extensions; do
2838
 
  if { test -f "$as_dir/$ac_word$ac_exec_ext" && $as_executable_p "$as_dir/$ac_word$ac_exec_ext"; }; then
2839
 
    ac_cv_path_PG_CONFIG="$as_dir/$ac_word$ac_exec_ext"
2840
 
    echo "$as_me:$LINENO: found $as_dir/$ac_word$ac_exec_ext" >&5
2841
 
    break 2
2842
 
  fi
2843
 
done
2844
 
done
2845
 
IFS=$as_save_IFS
2846
 
 
2847
 
  ;;
2848
 
esac
2849
 
fi
2850
 
PG_CONFIG=$ac_cv_path_PG_CONFIG
2851
 
if test -n "$PG_CONFIG"; then
2852
 
  { echo "$as_me:$LINENO: result: $PG_CONFIG" >&5
2853
 
echo "${ECHO_T}$PG_CONFIG" >&6; }
2854
 
else
2855
 
  { echo "$as_me:$LINENO: result: no" >&5
2856
 
echo "${ECHO_T}no" >&6; }
2857
 
fi
2858
 
 
2859
 
 
2860
 
  test -n "$PG_CONFIG" && break
2861
 
done
2862
 
 
2863
 
 
2864
 
if test -z "$PG_CONFIG"; then
2865
 
  { { echo "$as_me:$LINENO: error: pg_config not found (set PG_CONFIG environment variable)" >&5
2866
 
echo "$as_me: error: pg_config not found (set PG_CONFIG environment variable)" >&2;}
2867
 
   { (exit 1); exit 1; }; }
2868
 
fi
2869
 
 
2870
 
pg_includedir=`$PG_CONFIG --includedir`
2871
 
pg_libdir=`$PG_CONFIG --libdir`
2872
 
CPPFLAGS="$CPPFLAGS -I$pg_includedir"
2873
 
LDFLAGS="$LDFLAGS -L$pg_libdir"
2874
 
 
2875
 
 
2876
 
 
2877
 
# 1. Programs
 
2628
#
 
2629
# SQLCOLATTRIBUTE_SQLLEN check
 
2630
#
 
2631
DEPDIR="${am__leading_dot}deps"
 
2632
 
 
2633
ac_config_commands="$ac_config_commands depfiles"
 
2634
 
 
2635
 
 
2636
am_make=${MAKE-make}
 
2637
cat > confinc << 'END'
 
2638
am__doit:
 
2639
        @echo done
 
2640
.PHONY: am__doit
 
2641
END
 
2642
# If we don't find an include directive, just comment out the code.
 
2643
{ echo "$as_me:$LINENO: checking for style of include used by $am_make" >&5
 
2644
echo $ECHO_N "checking for style of include used by $am_make... $ECHO_C" >&6; }
 
2645
am__include="#"
 
2646
am__quote=
 
2647
_am_result=none
 
2648
# First try GNU make style include.
 
2649
echo "include confinc" > confmf
 
2650
# We grep out `Entering directory' and `Leaving directory'
 
2651
# messages which can occur if `w' ends up in MAKEFLAGS.
 
2652
# In particular we don't look at `^make:' because GNU make might
 
2653
# be invoked under some other name (usually "gmake"), in which
 
2654
# case it prints its new name instead of `make'.
 
2655
if test "`$am_make -s -f confmf 2> /dev/null | grep -v 'ing directory'`" = "done"; then
 
2656
   am__include=include
 
2657
   am__quote=
 
2658
   _am_result=GNU
 
2659
fi
 
2660
# Now try BSD make style include.
 
2661
if test "$am__include" = "#"; then
 
2662
   echo '.include "confinc"' > confmf
 
2663
   if test "`$am_make -s -f confmf 2> /dev/null`" = "done"; then
 
2664
      am__include=.include
 
2665
      am__quote="\""
 
2666
      _am_result=BSD
 
2667
   fi
 
2668
fi
 
2669
 
 
2670
 
 
2671
{ echo "$as_me:$LINENO: result: $_am_result" >&5
 
2672
echo "${ECHO_T}$_am_result" >&6; }
 
2673
rm -f confinc confmf
 
2674
 
 
2675
# Check whether --enable-dependency-tracking was given.
 
2676
if test "${enable_dependency_tracking+set}" = set; then
 
2677
  enableval=$enable_dependency_tracking;
 
2678
fi
 
2679
 
 
2680
if test "x$enable_dependency_tracking" != xno; then
 
2681
  am_depcomp="$ac_aux_dir/depcomp"
 
2682
  AMDEPBACKSLASH='\'
 
2683
fi
 
2684
 
 
2685
 
 
2686
if test "x$enable_dependency_tracking" != xno; then
 
2687
  AMDEP_TRUE=
 
2688
  AMDEP_FALSE='#'
 
2689
else
 
2690
  AMDEP_TRUE='#'
 
2691
  AMDEP_FALSE=
 
2692
fi
 
2693
 
 
2694
 
2878
2695
 
2879
2696
ac_ext=c
2880
2697
ac_cpp='$CPP $CPPFLAGS'
3875
3692
ac_compile='$CC -c $CFLAGS $CPPFLAGS conftest.$ac_ext >&5'
3876
3693
ac_link='$CC -o conftest$ac_exeext $CFLAGS $CPPFLAGS $LDFLAGS conftest.$ac_ext $LIBS >&5'
3877
3694
ac_compiler_gnu=$ac_cv_c_compiler_gnu
3878
 
DEPDIR="${am__leading_dot}deps"
3879
 
 
3880
 
ac_config_commands="$ac_config_commands depfiles"
3881
 
 
3882
 
 
3883
 
am_make=${MAKE-make}
3884
 
cat > confinc << 'END'
3885
 
am__doit:
3886
 
        @echo done
3887
 
.PHONY: am__doit
3888
 
END
3889
 
# If we don't find an include directive, just comment out the code.
3890
 
{ echo "$as_me:$LINENO: checking for style of include used by $am_make" >&5
3891
 
echo $ECHO_N "checking for style of include used by $am_make... $ECHO_C" >&6; }
3892
 
am__include="#"
3893
 
am__quote=
3894
 
_am_result=none
3895
 
# First try GNU make style include.
3896
 
echo "include confinc" > confmf
3897
 
# We grep out `Entering directory' and `Leaving directory'
3898
 
# messages which can occur if `w' ends up in MAKEFLAGS.
3899
 
# In particular we don't look at `^make:' because GNU make might
3900
 
# be invoked under some other name (usually "gmake"), in which
3901
 
# case it prints its new name instead of `make'.
3902
 
if test "`$am_make -s -f confmf 2> /dev/null | grep -v 'ing directory'`" = "done"; then
3903
 
   am__include=include
3904
 
   am__quote=
3905
 
   _am_result=GNU
3906
 
fi
3907
 
# Now try BSD make style include.
3908
 
if test "$am__include" = "#"; then
3909
 
   echo '.include "confinc"' > confmf
3910
 
   if test "`$am_make -s -f confmf 2> /dev/null`" = "done"; then
3911
 
      am__include=.include
3912
 
      am__quote="\""
3913
 
      _am_result=BSD
3914
 
   fi
3915
 
fi
3916
 
 
3917
 
 
3918
 
{ echo "$as_me:$LINENO: result: $_am_result" >&5
3919
 
echo "${ECHO_T}$_am_result" >&6; }
3920
 
rm -f confinc confmf
3921
 
 
3922
 
# Check whether --enable-dependency-tracking was given.
3923
 
if test "${enable_dependency_tracking+set}" = set; then
3924
 
  enableval=$enable_dependency_tracking;
3925
 
fi
3926
 
 
3927
 
if test "x$enable_dependency_tracking" != xno; then
3928
 
  am_depcomp="$ac_aux_dir/depcomp"
3929
 
  AMDEPBACKSLASH='\'
3930
 
fi
3931
 
 
3932
 
 
3933
 
if test "x$enable_dependency_tracking" != xno; then
3934
 
  AMDEP_TRUE=
3935
 
  AMDEP_FALSE='#'
3936
 
else
3937
 
  AMDEP_TRUE='#'
3938
 
  AMDEP_FALSE=
3939
 
fi
3940
 
 
3941
 
 
3942
 
 
3943
 
 
3944
 
depcc="$CC"   am_compiler_list=
3945
 
 
3946
 
{ echo "$as_me:$LINENO: checking dependency style of $depcc" >&5
3947
 
echo $ECHO_N "checking dependency style of $depcc... $ECHO_C" >&6; }
3948
 
if test "${am_cv_CC_dependencies_compiler_type+set}" = set; then
3949
 
  echo $ECHO_N "(cached) $ECHO_C" >&6
3950
 
else
3951
 
  if test -z "$AMDEP_TRUE" && test -f "$am_depcomp"; then
3952
 
  # We make a subdir and do the tests there.  Otherwise we can end up
3953
 
  # making bogus files that we don't know about and never remove.  For
3954
 
  # instance it was reported that on HP-UX the gcc test will end up
3955
 
  # making a dummy file named `D' -- because `-MD' means `put the output
3956
 
  # in D'.
3957
 
  mkdir conftest.dir
3958
 
  # Copy depcomp to subdir because otherwise we won't find it if we're
3959
 
  # using a relative directory.
3960
 
  cp "$am_depcomp" conftest.dir
3961
 
  cd conftest.dir
3962
 
  # We will build objects and dependencies in a subdirectory because
3963
 
  # it helps to detect inapplicable dependency modes.  For instance
3964
 
  # both Tru64's cc and ICC support -MD to output dependencies as a
3965
 
  # side effect of compilation, but ICC will put the dependencies in
3966
 
  # the current directory while Tru64 will put them in the object
3967
 
  # directory.
3968
 
  mkdir sub
3969
 
 
3970
 
  am_cv_CC_dependencies_compiler_type=none
3971
 
  if test "$am_compiler_list" = ""; then
3972
 
     am_compiler_list=`sed -n 's/^#*\([a-zA-Z0-9]*\))$/\1/p' < ./depcomp`
3973
 
  fi
3974
 
  for depmode in $am_compiler_list; do
3975
 
    # Setup a source with many dependencies, because some compilers
3976
 
    # like to wrap large dependency lists on column 80 (with \), and
3977
 
    # we should not choose a depcomp mode which is confused by this.
3978
 
    #
3979
 
    # We need to recreate these files for each test, as the compiler may
3980
 
    # overwrite some of them when testing with obscure command lines.
3981
 
    # This happens at least with the AIX C compiler.
3982
 
    : > sub/conftest.c
3983
 
    for i in 1 2 3 4 5 6; do
3984
 
      echo '#include "conftst'$i'.h"' >> sub/conftest.c
3985
 
      # Using `: > sub/conftst$i.h' creates only sub/conftst1.h with
3986
 
      # Solaris 8's {/usr,}/bin/sh.
3987
 
      touch sub/conftst$i.h
3988
 
    done
3989
 
    echo "${am__include} ${am__quote}sub/conftest.Po${am__quote}" > confmf
3990
 
 
3991
 
    case $depmode in
3992
 
    nosideeffect)
3993
 
      # after this tag, mechanisms are not by side-effect, so they'll
3994
 
      # only be used when explicitly requested
3995
 
      if test "x$enable_dependency_tracking" = xyes; then
3996
 
        continue
3997
 
      else
3998
 
        break
3999
 
      fi
4000
 
      ;;
4001
 
    none) break ;;
4002
 
    esac
4003
 
    # We check with `-c' and `-o' for the sake of the "dashmstdout"
4004
 
    # mode.  It turns out that the SunPro C++ compiler does not properly
4005
 
    # handle `-M -o', and we need to detect this.
4006
 
    if depmode=$depmode \
4007
 
       source=sub/conftest.c object=sub/conftest.${OBJEXT-o} \
4008
 
       depfile=sub/conftest.Po tmpdepfile=sub/conftest.TPo \
4009
 
       $SHELL ./depcomp $depcc -c -o sub/conftest.${OBJEXT-o} sub/conftest.c \
4010
 
         >/dev/null 2>conftest.err &&
4011
 
       grep sub/conftst6.h sub/conftest.Po > /dev/null 2>&1 &&
4012
 
       grep sub/conftest.${OBJEXT-o} sub/conftest.Po > /dev/null 2>&1 &&
4013
 
       ${MAKE-make} -s -f confmf > /dev/null 2>&1; then
4014
 
      # icc doesn't choke on unknown options, it will just issue warnings
4015
 
      # or remarks (even with -Werror).  So we grep stderr for any message
4016
 
      # that says an option was ignored or not supported.
4017
 
      # When given -MP, icc 7.0 and 7.1 complain thusly:
4018
 
      #   icc: Command line warning: ignoring option '-M'; no argument required
4019
 
      # The diagnosis changed in icc 8.0:
4020
 
      #   icc: Command line remark: option '-MP' not supported
4021
 
      if (grep 'ignoring option' conftest.err ||
4022
 
          grep 'not supported' conftest.err) >/dev/null 2>&1; then :; else
4023
 
        am_cv_CC_dependencies_compiler_type=$depmode
4024
 
        break
4025
 
      fi
4026
 
    fi
4027
 
  done
4028
 
 
4029
 
  cd ..
4030
 
  rm -rf conftest.dir
4031
 
else
4032
 
  am_cv_CC_dependencies_compiler_type=none
4033
 
fi
4034
 
 
4035
 
fi
4036
 
{ echo "$as_me:$LINENO: result: $am_cv_CC_dependencies_compiler_type" >&5
4037
 
echo "${ECHO_T}$am_cv_CC_dependencies_compiler_type" >&6; }
4038
 
CCDEPMODE=depmode=$am_cv_CC_dependencies_compiler_type
4039
 
 
4040
 
 
4041
 
 
4042
 
if
4043
 
  test "x$enable_dependency_tracking" != xno \
4044
 
  && test "$am_cv_CC_dependencies_compiler_type" = gcc3; then
4045
 
  am__fastdepCC_TRUE=
4046
 
  am__fastdepCC_FALSE='#'
4047
 
else
4048
 
  am__fastdepCC_TRUE='#'
4049
 
  am__fastdepCC_FALSE=
4050
 
fi
4051
 
 
4052
 
 
 
3695
 
 
3696
depcc="$CC"   am_compiler_list=
 
3697
 
 
3698
{ echo "$as_me:$LINENO: checking dependency style of $depcc" >&5
 
3699
echo $ECHO_N "checking dependency style of $depcc... $ECHO_C" >&6; }
 
3700
if test "${am_cv_CC_dependencies_compiler_type+set}" = set; then
 
3701
  echo $ECHO_N "(cached) $ECHO_C" >&6
 
3702
else
 
3703
  if test -z "$AMDEP_TRUE" && test -f "$am_depcomp"; then
 
3704
  # We make a subdir and do the tests there.  Otherwise we can end up
 
3705
  # making bogus files that we don't know about and never remove.  For
 
3706
  # instance it was reported that on HP-UX the gcc test will end up
 
3707
  # making a dummy file named `D' -- because `-MD' means `put the output
 
3708
  # in D'.
 
3709
  mkdir conftest.dir
 
3710
  # Copy depcomp to subdir because otherwise we won't find it if we're
 
3711
  # using a relative directory.
 
3712
  cp "$am_depcomp" conftest.dir
 
3713
  cd conftest.dir
 
3714
  # We will build objects and dependencies in a subdirectory because
 
3715
  # it helps to detect inapplicable dependency modes.  For instance
 
3716
  # both Tru64's cc and ICC support -MD to output dependencies as a
 
3717
  # side effect of compilation, but ICC will put the dependencies in
 
3718
  # the current directory while Tru64 will put them in the object
 
3719
  # directory.
 
3720
  mkdir sub
 
3721
 
 
3722
  am_cv_CC_dependencies_compiler_type=none
 
3723
  if test "$am_compiler_list" = ""; then
 
3724
     am_compiler_list=`sed -n 's/^#*\([a-zA-Z0-9]*\))$/\1/p' < ./depcomp`
 
3725
  fi
 
3726
  for depmode in $am_compiler_list; do
 
3727
    # Setup a source with many dependencies, because some compilers
 
3728
    # like to wrap large dependency lists on column 80 (with \), and
 
3729
    # we should not choose a depcomp mode which is confused by this.
 
3730
    #
 
3731
    # We need to recreate these files for each test, as the compiler may
 
3732
    # overwrite some of them when testing with obscure command lines.
 
3733
    # This happens at least with the AIX C compiler.
 
3734
    : > sub/conftest.c
 
3735
    for i in 1 2 3 4 5 6; do
 
3736
      echo '#include "conftst'$i'.h"' >> sub/conftest.c
 
3737
      # Using `: > sub/conftst$i.h' creates only sub/conftst1.h with
 
3738
      # Solaris 8's {/usr,}/bin/sh.
 
3739
      touch sub/conftst$i.h
 
3740
    done
 
3741
    echo "${am__include} ${am__quote}sub/conftest.Po${am__quote}" > confmf
 
3742
 
 
3743
    case $depmode in
 
3744
    nosideeffect)
 
3745
      # after this tag, mechanisms are not by side-effect, so they'll
 
3746
      # only be used when explicitly requested
 
3747
      if test "x$enable_dependency_tracking" = xyes; then
 
3748
        continue
 
3749
      else
 
3750
        break
 
3751
      fi
 
3752
      ;;
 
3753
    none) break ;;
 
3754
    esac
 
3755
    # We check with `-c' and `-o' for the sake of the "dashmstdout"
 
3756
    # mode.  It turns out that the SunPro C++ compiler does not properly
 
3757
    # handle `-M -o', and we need to detect this.
 
3758
    if depmode=$depmode \
 
3759
       source=sub/conftest.c object=sub/conftest.${OBJEXT-o} \
 
3760
       depfile=sub/conftest.Po tmpdepfile=sub/conftest.TPo \
 
3761
       $SHELL ./depcomp $depcc -c -o sub/conftest.${OBJEXT-o} sub/conftest.c \
 
3762
         >/dev/null 2>conftest.err &&
 
3763
       grep sub/conftst6.h sub/conftest.Po > /dev/null 2>&1 &&
 
3764
       grep sub/conftest.${OBJEXT-o} sub/conftest.Po > /dev/null 2>&1 &&
 
3765
       ${MAKE-make} -s -f confmf > /dev/null 2>&1; then
 
3766
      # icc doesn't choke on unknown options, it will just issue warnings
 
3767
      # or remarks (even with -Werror).  So we grep stderr for any message
 
3768
      # that says an option was ignored or not supported.
 
3769
      # When given -MP, icc 7.0 and 7.1 complain thusly:
 
3770
      #   icc: Command line warning: ignoring option '-M'; no argument required
 
3771
      # The diagnosis changed in icc 8.0:
 
3772
      #   icc: Command line remark: option '-MP' not supported
 
3773
      if (grep 'ignoring option' conftest.err ||
 
3774
          grep 'not supported' conftest.err) >/dev/null 2>&1; then :; else
 
3775
        am_cv_CC_dependencies_compiler_type=$depmode
 
3776
        break
 
3777
      fi
 
3778
    fi
 
3779
  done
 
3780
 
 
3781
  cd ..
 
3782
  rm -rf conftest.dir
 
3783
else
 
3784
  am_cv_CC_dependencies_compiler_type=none
 
3785
fi
 
3786
 
 
3787
fi
 
3788
{ echo "$as_me:$LINENO: result: $am_cv_CC_dependencies_compiler_type" >&5
 
3789
echo "${ECHO_T}$am_cv_CC_dependencies_compiler_type" >&6; }
 
3790
CCDEPMODE=depmode=$am_cv_CC_dependencies_compiler_type
 
3791
 
 
3792
 
 
3793
 
 
3794
if
 
3795
  test "x$enable_dependency_tracking" != xno \
 
3796
  && test "$am_cv_CC_dependencies_compiler_type" = gcc3; then
 
3797
  am__fastdepCC_TRUE=
 
3798
  am__fastdepCC_FALSE='#'
 
3799
else
 
3800
  am__fastdepCC_TRUE='#'
 
3801
  am__fastdepCC_FALSE=
 
3802
fi
 
3803
 
 
3804
 
 
3805
 
 
3806
cat >conftest.$ac_ext <<_ACEOF
 
3807
/* confdefs.h.  */
 
3808
_ACEOF
 
3809
cat confdefs.h >>conftest.$ac_ext
 
3810
cat >>conftest.$ac_ext <<_ACEOF
 
3811
/* end confdefs.h.  */
 
3812
#include <sql.h>>
 
3813
        SQLRETURN  SQL_API SQLColAttribute
 
3814
        (SQLHSTMT StatementHandle,SQLUSMALLINT ColumnNumber,
 
3815
        SQLUSMALLINT FieldIdentifier, SQLPOINTER CharacterAttribute,
 
3816
        SQLSMALLINT BufferLength, SQLSMALLINT *StringLength,
 
3817
        SQLLEN *NumercAttribute);
 
3818
int
 
3819
main ()
 
3820
{
 
3821
 
 
3822
  ;
 
3823
  return 0;
 
3824
}
 
3825
_ACEOF
 
3826
rm -f conftest.$ac_objext
 
3827
if { (ac_try="$ac_compile"
 
3828
case "(($ac_try" in
 
3829
  *\"* | *\`* | *\\*) ac_try_echo=\$ac_try;;
 
3830
  *) ac_try_echo=$ac_try;;
 
3831
esac
 
3832
eval "echo \"\$as_me:$LINENO: $ac_try_echo\"") >&5
 
3833
  (eval "$ac_compile") 2>conftest.er1
 
3834
  ac_status=$?
 
3835
  grep -v '^ *+' conftest.er1 >conftest.err
 
3836
  rm -f conftest.er1
 
3837
  cat conftest.err >&5
 
3838
  echo "$as_me:$LINENO: \$? = $ac_status" >&5
 
3839
  (exit $ac_status); } &&
 
3840
         { ac_try='test -z "$ac_c_werror_flag" || test ! -s conftest.err'
 
3841
  { (case "(($ac_try" in
 
3842
  *\"* | *\`* | *\\*) ac_try_echo=\$ac_try;;
 
3843
  *) ac_try_echo=$ac_try;;
 
3844
esac
 
3845
eval "echo \"\$as_me:$LINENO: $ac_try_echo\"") >&5
 
3846
  (eval "$ac_try") 2>&5
 
3847
  ac_status=$?
 
3848
  echo "$as_me:$LINENO: \$? = $ac_status" >&5
 
3849
  (exit $ac_status); }; } &&
 
3850
         { ac_try='test -s conftest.$ac_objext'
 
3851
  { (case "(($ac_try" in
 
3852
  *\"* | *\`* | *\\*) ac_try_echo=\$ac_try;;
 
3853
  *) ac_try_echo=$ac_try;;
 
3854
esac
 
3855
eval "echo \"\$as_me:$LINENO: $ac_try_echo\"") >&5
 
3856
  (eval "$ac_try") 2>&5
 
3857
  ac_status=$?
 
3858
  echo "$as_me:$LINENO: \$? = $ac_status" >&5
 
3859
  (exit $ac_status); }; }; then
 
3860
 
 
3861
cat >>confdefs.h <<\_ACEOF
 
3862
#define SQLCOLATTRIBUTE_SQLLEN 1
 
3863
_ACEOF
 
3864
 
 
3865
else
 
3866
  echo "$as_me: failed program was:" >&5
 
3867
sed 's/^/| /' conftest.$ac_ext >&5
 
3868
 
 
3869
 
 
3870
fi
 
3871
 
 
3872
rm -f core conftest.err conftest.$ac_objext conftest.$ac_ext
 
3873
 
 
3874
 
 
3875
#
 
3876
# Whether libpq functionalities are used
 
3877
#
 
3878
 
 
3879
# Check whether --with-libpq was given.
 
3880
if test "${with_libpq+set}" = set; then
 
3881
  withval=$with_libpq;
 
3882
        if test "$withval" = no; then
 
3883
 
 
3884
cat >>confdefs.h <<\_ACEOF
 
3885
#define NOT_USE_LIBPQ 1
 
3886
_ACEOF
 
3887
 
 
3888
                enable_openssl=no
 
3889
        else
 
3890
                if test "$withval" != yes; then
 
3891
                        if test -d "$withval"; then
 
3892
                                PATH="$PATH:$withval/bin"
 
3893
                                CPPFLAGS="$CPPFLAGS -I$withval/include"
 
3894
                                LDFLAGS="$LDFLAGS -L$withval/lib"
 
3895
                        else
 
3896
                                if test -x "$withval"; then
 
3897
                                        PG_CONFIG=$withval
 
3898
                                else
 
3899
                                        { { echo "$as_me:$LINENO: error: specified pg_config not found" >&5
 
3900
echo "$as_me: error: specified pg_config not found" >&2;}
 
3901
   { (exit 1); exit 1; }; }
 
3902
                                fi
 
3903
                        fi
 
3904
                fi
 
3905
                with_libpq=yes
 
3906
        fi
 
3907
 
 
3908
else
 
3909
  with_libpq=yes
 
3910
fi
 
3911
 
 
3912
 
 
3913
 
 
3914
#
 
3915
# Default odbc version number (--with-odbcver), default 0x0351
 
3916
#
 
3917
 
 
3918
 
 
3919
pgac_args="$pgac_args with_odbcver"
 
3920
 
 
3921
 
 
3922
# Check whether --with-odbcver was given.
 
3923
if test "${with_odbcver+set}" = set; then
 
3924
  withval=$with_odbcver;
 
3925
  case $withval in
 
3926
    yes)
 
3927
      { { echo "$as_me:$LINENO: error: argument required for --with-odbcver option" >&5
 
3928
echo "$as_me: error: argument required for --with-odbcver option" >&2;}
 
3929
   { (exit 1); exit 1; }; }
 
3930
      ;;
 
3931
    no)
 
3932
      { { echo "$as_me:$LINENO: error: argument required for --with-odbcver option" >&5
 
3933
echo "$as_me: error: argument required for --with-odbcver option" >&2;}
 
3934
   { (exit 1); exit 1; }; }
 
3935
      ;;
 
3936
    *)
 
3937
 
 
3938
      ;;
 
3939
  esac
 
3940
 
 
3941
else
 
3942
  with_odbcver=0x0351
 
3943
fi
 
3944
 
 
3945
 
 
3946
 
 
3947
cat >>confdefs.h <<_ACEOF
 
3948
#define ODBCVER $with_odbcver
 
3949
_ACEOF
 
3950
 
 
3951
 
 
3952
 
 
3953
#
 
3954
# Unicode support
 
3955
#
 
3956
 
 
3957
 
 
3958
pgac_args="$pgac_args enable_unicode"
 
3959
 
 
3960
# Check whether --enable-unicode was given.
 
3961
if test "${enable_unicode+set}" = set; then
 
3962
  enableval=$enable_unicode;
 
3963
  case $enableval in
 
3964
    yes)
 
3965
 
 
3966
cat >>confdefs.h <<\_ACEOF
 
3967
#define UNICODE_SUPPORT 1
 
3968
_ACEOF
 
3969
 
 
3970
      ;;
 
3971
    no)
 
3972
      :
 
3973
      ;;
 
3974
    *)
 
3975
      { { echo "$as_me:$LINENO: error: no argument expected for --enable-unicode option" >&5
 
3976
echo "$as_me: error: no argument expected for --enable-unicode option" >&2;}
 
3977
   { (exit 1); exit 1; }; }
 
3978
      ;;
 
3979
  esac
 
3980
 
 
3981
else
 
3982
  enable_unicode=yes
 
3983
 
 
3984
cat >>confdefs.h <<\_ACEOF
 
3985
#define UNICODE_SUPPORT 1
 
3986
_ACEOF
 
3987
 
 
3988
fi
 
3989
 
 
3990
 
 
3991
 
 
3992
 
 
3993
 
 
3994
if test x"$enable_unicode" = xyes; then
 
3995
  enable_unicode_TRUE=
 
3996
  enable_unicode_FALSE='#'
 
3997
else
 
3998
  enable_unicode_TRUE='#'
 
3999
  enable_unicode_FALSE=
 
4000
fi
 
4001
 
 
4002
 
 
4003
 
 
4004
#
 
4005
# SSL support
 
4006
#
 
4007
 
 
4008
 
 
4009
pgac_args="$pgac_args enable_openssl"
 
4010
 
 
4011
# Check whether --enable-openssl was given.
 
4012
if test "${enable_openssl+set}" = set; then
 
4013
  enableval=$enable_openssl;
 
4014
  case $enableval in
 
4015
    yes)
 
4016
 
 
4017
cat >>confdefs.h <<\_ACEOF
 
4018
#define USE_SSL 1
 
4019
_ACEOF
 
4020
 
 
4021
      ;;
 
4022
    no)
 
4023
      :
 
4024
      ;;
 
4025
    *)
 
4026
      { { echo "$as_me:$LINENO: error: no argument expected for --enable-openssl option" >&5
 
4027
echo "$as_me: error: no argument expected for --enable-openssl option" >&2;}
 
4028
   { (exit 1); exit 1; }; }
 
4029
      ;;
 
4030
  esac
 
4031
 
 
4032
else
 
4033
  enable_openssl=yes
 
4034
 
 
4035
cat >>confdefs.h <<\_ACEOF
 
4036
#define USE_SSL 1
 
4037
_ACEOF
 
4038
 
 
4039
fi
 
4040
 
 
4041
 
 
4042
 
 
4043
 
 
4044
 
 
4045
if test x"$enable_openssl" = xyes; then
 
4046
  enable_openssl_TRUE=
 
4047
  enable_openssl_FALSE='#'
 
4048
else
 
4049
  enable_openssl_TRUE='#'
 
4050
  enable_openssl_FALSE=
 
4051
fi
 
4052
 
 
4053
 
 
4054
#
 
4055
# GSSAPI support
 
4056
#
 
4057
 
 
4058
 
 
4059
pgac_args="$pgac_args enable_gss"
 
4060
 
 
4061
# Check whether --enable-gss was given.
 
4062
if test "${enable_gss+set}" = set; then
 
4063
  enableval=$enable_gss;
 
4064
  case $enableval in
 
4065
    yes)
 
4066
 
 
4067
cat >>confdefs.h <<\_ACEOF
 
4068
#define USE_GSS 1
 
4069
_ACEOF
 
4070
 
 
4071
      ;;
 
4072
    no)
 
4073
      :
 
4074
      ;;
 
4075
    *)
 
4076
      { { echo "$as_me:$LINENO: error: no argument expected for --enable-gss option" >&5
 
4077
echo "$as_me: error: no argument expected for --enable-gss option" >&2;}
 
4078
   { (exit 1); exit 1; }; }
 
4079
      ;;
 
4080
  esac
 
4081
 
 
4082
else
 
4083
  enable_gss=no
 
4084
 
 
4085
fi
 
4086
 
 
4087
 
 
4088
 
 
4089
 
 
4090
 
 
4091
if test x"$enable_gss" = xyes; then
 
4092
  enable_gss_TRUE=
 
4093
  enable_gss_FALSE='#'
 
4094
else
 
4095
  enable_gss_TRUE='#'
 
4096
  enable_gss_FALSE=
 
4097
fi
 
4098
 
 
4099
 
 
4100
#
 
4101
# GKerberos 5 support
 
4102
#
 
4103
 
 
4104
 
 
4105
pgac_args="$pgac_args enable_krb5"
 
4106
 
 
4107
# Check whether --enable-krb5 was given.
 
4108
if test "${enable_krb5+set}" = set; then
 
4109
  enableval=$enable_krb5;
 
4110
  case $enableval in
 
4111
    yes)
 
4112
 
 
4113
cat >>confdefs.h <<\_ACEOF
 
4114
#define USE_KRB5 1
 
4115
_ACEOF
 
4116
 
 
4117
      ;;
 
4118
    no)
 
4119
      :
 
4120
      ;;
 
4121
    *)
 
4122
      { { echo "$as_me:$LINENO: error: no argument expected for --enable-krb5 option" >&5
 
4123
echo "$as_me: error: no argument expected for --enable-krb5 option" >&2;}
 
4124
   { (exit 1); exit 1; }; }
 
4125
      ;;
 
4126
  esac
 
4127
 
 
4128
else
 
4129
  enable_krb5=no
 
4130
 
 
4131
fi
 
4132
 
 
4133
 
 
4134
 
 
4135
 
 
4136
 
 
4137
if test x"$enable_krb5" = xyes; then
 
4138
  enable_krb5_TRUE=
 
4139
  enable_krb5_FALSE='#'
 
4140
else
 
4141
  enable_krb5_TRUE='#'
 
4142
  enable_krb5_FALSE=
 
4143
fi
 
4144
 
 
4145
 
 
4146
#
 
4147
# Pthreads
 
4148
#
 
4149
 
 
4150
 
 
4151
pgac_args="$pgac_args enable_pthreads"
 
4152
 
 
4153
# Check whether --enable-pthreads was given.
 
4154
if test "${enable_pthreads+set}" = set; then
 
4155
  enableval=$enable_pthreads;
 
4156
  case $enableval in
 
4157
    yes)
 
4158
 
 
4159
cat >>confdefs.h <<\_ACEOF
 
4160
#define POSIX_MULTITHREAD_SUPPORT 1
 
4161
_ACEOF
 
4162
 
 
4163
 
 
4164
cat >>confdefs.h <<\_ACEOF
 
4165
#define _REENTRANT 1
 
4166
_ACEOF
 
4167
 
 
4168
      ;;
 
4169
    no)
 
4170
      :
 
4171
      ;;
 
4172
    *)
 
4173
      { { echo "$as_me:$LINENO: error: no argument expected for --enable-pthreads option" >&5
 
4174
echo "$as_me: error: no argument expected for --enable-pthreads option" >&2;}
 
4175
   { (exit 1); exit 1; }; }
 
4176
      ;;
 
4177
  esac
 
4178
 
 
4179
else
 
4180
  enable_pthreads=yes
 
4181
 
 
4182
cat >>confdefs.h <<\_ACEOF
 
4183
#define POSIX_MULTITHREAD_SUPPORT 1
 
4184
_ACEOF
 
4185
 
 
4186
 
 
4187
cat >>confdefs.h <<\_ACEOF
 
4188
#define _REENTRANT 1
 
4189
_ACEOF
 
4190
 
 
4191
fi
 
4192
 
 
4193
 
 
4194
 
 
4195
 
 
4196
#
 
4197
# Find libpq headers and libraries
 
4198
#
 
4199
 
 
4200
if test "$with_libpq" = yes; then
 
4201
  if test -z "$PG_CONFIG"; then
 
4202
        for ac_prog in pg_config
 
4203
do
 
4204
  # Extract the first word of "$ac_prog", so it can be a program name with args.
 
4205
set dummy $ac_prog; ac_word=$2
 
4206
{ echo "$as_me:$LINENO: checking for $ac_word" >&5
 
4207
echo $ECHO_N "checking for $ac_word... $ECHO_C" >&6; }
 
4208
if test "${ac_cv_path_PG_CONFIG+set}" = set; then
 
4209
  echo $ECHO_N "(cached) $ECHO_C" >&6
 
4210
else
 
4211
  case $PG_CONFIG in
 
4212
  [\\/]* | ?:[\\/]*)
 
4213
  ac_cv_path_PG_CONFIG="$PG_CONFIG" # Let the user override the test with a path.
 
4214
  ;;
 
4215
  *)
 
4216
  as_save_IFS=$IFS; IFS=$PATH_SEPARATOR
 
4217
for as_dir in $PATH
 
4218
do
 
4219
  IFS=$as_save_IFS
 
4220
  test -z "$as_dir" && as_dir=.
 
4221
  for ac_exec_ext in '' $ac_executable_extensions; do
 
4222
  if { test -f "$as_dir/$ac_word$ac_exec_ext" && $as_executable_p "$as_dir/$ac_word$ac_exec_ext"; }; then
 
4223
    ac_cv_path_PG_CONFIG="$as_dir/$ac_word$ac_exec_ext"
 
4224
    echo "$as_me:$LINENO: found $as_dir/$ac_word$ac_exec_ext" >&5
 
4225
    break 2
 
4226
  fi
 
4227
done
 
4228
done
 
4229
IFS=$as_save_IFS
 
4230
 
 
4231
  ;;
 
4232
esac
 
4233
fi
 
4234
PG_CONFIG=$ac_cv_path_PG_CONFIG
 
4235
if test -n "$PG_CONFIG"; then
 
4236
  { echo "$as_me:$LINENO: result: $PG_CONFIG" >&5
 
4237
echo "${ECHO_T}$PG_CONFIG" >&6; }
 
4238
else
 
4239
  { echo "$as_me:$LINENO: result: no" >&5
 
4240
echo "${ECHO_T}no" >&6; }
 
4241
fi
 
4242
 
 
4243
 
 
4244
  test -n "$PG_CONFIG" && break
 
4245
done
 
4246
 
 
4247
  fi
 
4248
 
 
4249
  if test -n "$PG_CONFIG"; then
 
4250
    pg_includedir=`"$PG_CONFIG" --includedir`
 
4251
    pg_libdir=`"$PG_CONFIG" --libdir`
 
4252
    CPPFLAGS="$CPPFLAGS -I$pg_includedir"
 
4253
    LDFLAGS="$LDFLAGS -L$pg_libdir"
 
4254
  fi
 
4255
fi
 
4256
 
 
4257
 
 
4258
 
 
4259
# 1. Programs
 
4260
 
 
4261
ac_ext=c
 
4262
ac_cpp='$CPP $CPPFLAGS'
 
4263
ac_compile='$CC -c $CFLAGS $CPPFLAGS conftest.$ac_ext >&5'
 
4264
ac_link='$CC -o conftest$ac_exeext $CFLAGS $CPPFLAGS $LDFLAGS conftest.$ac_ext $LIBS >&5'
 
4265
ac_compiler_gnu=$ac_cv_c_compiler_gnu
 
4266
if test -n "$ac_tool_prefix"; then
 
4267
  # Extract the first word of "${ac_tool_prefix}gcc", so it can be a program name with args.
 
4268
set dummy ${ac_tool_prefix}gcc; ac_word=$2
 
4269
{ echo "$as_me:$LINENO: checking for $ac_word" >&5
 
4270
echo $ECHO_N "checking for $ac_word... $ECHO_C" >&6; }
 
4271
if test "${ac_cv_prog_CC+set}" = set; then
 
4272
  echo $ECHO_N "(cached) $ECHO_C" >&6
 
4273
else
 
4274
  if test -n "$CC"; then
 
4275
  ac_cv_prog_CC="$CC" # Let the user override the test.
 
4276
else
 
4277
as_save_IFS=$IFS; IFS=$PATH_SEPARATOR
 
4278
for as_dir in $PATH
 
4279
do
 
4280
  IFS=$as_save_IFS
 
4281
  test -z "$as_dir" && as_dir=.
 
4282
  for ac_exec_ext in '' $ac_executable_extensions; do
 
4283
  if { test -f "$as_dir/$ac_word$ac_exec_ext" && $as_executable_p "$as_dir/$ac_word$ac_exec_ext"; }; then
 
4284
    ac_cv_prog_CC="${ac_tool_prefix}gcc"
 
4285
    echo "$as_me:$LINENO: found $as_dir/$ac_word$ac_exec_ext" >&5
 
4286
    break 2
 
4287
  fi
 
4288
done
 
4289
done
 
4290
IFS=$as_save_IFS
 
4291
 
 
4292
fi
 
4293
fi
 
4294
CC=$ac_cv_prog_CC
 
4295
if test -n "$CC"; then
 
4296
  { echo "$as_me:$LINENO: result: $CC" >&5
 
4297
echo "${ECHO_T}$CC" >&6; }
 
4298
else
 
4299
  { echo "$as_me:$LINENO: result: no" >&5
 
4300
echo "${ECHO_T}no" >&6; }
 
4301
fi
 
4302
 
 
4303
 
 
4304
fi
 
4305
if test -z "$ac_cv_prog_CC"; then
 
4306
  ac_ct_CC=$CC
 
4307
  # Extract the first word of "gcc", so it can be a program name with args.
 
4308
set dummy gcc; ac_word=$2
 
4309
{ echo "$as_me:$LINENO: checking for $ac_word" >&5
 
4310
echo $ECHO_N "checking for $ac_word... $ECHO_C" >&6; }
 
4311
if test "${ac_cv_prog_ac_ct_CC+set}" = set; then
 
4312
  echo $ECHO_N "(cached) $ECHO_C" >&6
 
4313
else
 
4314
  if test -n "$ac_ct_CC"; then
 
4315
  ac_cv_prog_ac_ct_CC="$ac_ct_CC" # Let the user override the test.
 
4316
else
 
4317
as_save_IFS=$IFS; IFS=$PATH_SEPARATOR
 
4318
for as_dir in $PATH
 
4319
do
 
4320
  IFS=$as_save_IFS
 
4321
  test -z "$as_dir" && as_dir=.
 
4322
  for ac_exec_ext in '' $ac_executable_extensions; do
 
4323
  if { test -f "$as_dir/$ac_word$ac_exec_ext" && $as_executable_p "$as_dir/$ac_word$ac_exec_ext"; }; then
 
4324
    ac_cv_prog_ac_ct_CC="gcc"
 
4325
    echo "$as_me:$LINENO: found $as_dir/$ac_word$ac_exec_ext" >&5
 
4326
    break 2
 
4327
  fi
 
4328
done
 
4329
done
 
4330
IFS=$as_save_IFS
 
4331
 
 
4332
fi
 
4333
fi
 
4334
ac_ct_CC=$ac_cv_prog_ac_ct_CC
 
4335
if test -n "$ac_ct_CC"; then
 
4336
  { echo "$as_me:$LINENO: result: $ac_ct_CC" >&5
 
4337
echo "${ECHO_T}$ac_ct_CC" >&6; }
 
4338
else
 
4339
  { echo "$as_me:$LINENO: result: no" >&5
 
4340
echo "${ECHO_T}no" >&6; }
 
4341
fi
 
4342
 
 
4343
  if test "x$ac_ct_CC" = x; then
 
4344
    CC=""
 
4345
  else
 
4346
    case $cross_compiling:$ac_tool_warned in
 
4347
yes:)
 
4348
{ echo "$as_me:$LINENO: WARNING: In the future, Autoconf will not detect cross-tools
 
4349
whose name does not start with the host triplet.  If you think this
 
4350
configuration is useful to you, please write to autoconf@gnu.org." >&5
 
4351
echo "$as_me: WARNING: In the future, Autoconf will not detect cross-tools
 
4352
whose name does not start with the host triplet.  If you think this
 
4353
configuration is useful to you, please write to autoconf@gnu.org." >&2;}
 
4354
ac_tool_warned=yes ;;
 
4355
esac
 
4356
    CC=$ac_ct_CC
 
4357
  fi
 
4358
else
 
4359
  CC="$ac_cv_prog_CC"
 
4360
fi
 
4361
 
 
4362
if test -z "$CC"; then
 
4363
          if test -n "$ac_tool_prefix"; then
 
4364
    # Extract the first word of "${ac_tool_prefix}cc", so it can be a program name with args.
 
4365
set dummy ${ac_tool_prefix}cc; ac_word=$2
 
4366
{ echo "$as_me:$LINENO: checking for $ac_word" >&5
 
4367
echo $ECHO_N "checking for $ac_word... $ECHO_C" >&6; }
 
4368
if test "${ac_cv_prog_CC+set}" = set; then
 
4369
  echo $ECHO_N "(cached) $ECHO_C" >&6
 
4370
else
 
4371
  if test -n "$CC"; then
 
4372
  ac_cv_prog_CC="$CC" # Let the user override the test.
 
4373
else
 
4374
as_save_IFS=$IFS; IFS=$PATH_SEPARATOR
 
4375
for as_dir in $PATH
 
4376
do
 
4377
  IFS=$as_save_IFS
 
4378
  test -z "$as_dir" && as_dir=.
 
4379
  for ac_exec_ext in '' $ac_executable_extensions; do
 
4380
  if { test -f "$as_dir/$ac_word$ac_exec_ext" && $as_executable_p "$as_dir/$ac_word$ac_exec_ext"; }; then
 
4381
    ac_cv_prog_CC="${ac_tool_prefix}cc"
 
4382
    echo "$as_me:$LINENO: found $as_dir/$ac_word$ac_exec_ext" >&5
 
4383
    break 2
 
4384
  fi
 
4385
done
 
4386
done
 
4387
IFS=$as_save_IFS
 
4388
 
 
4389
fi
 
4390
fi
 
4391
CC=$ac_cv_prog_CC
 
4392
if test -n "$CC"; then
 
4393
  { echo "$as_me:$LINENO: result: $CC" >&5
 
4394
echo "${ECHO_T}$CC" >&6; }
 
4395
else
 
4396
  { echo "$as_me:$LINENO: result: no" >&5
 
4397
echo "${ECHO_T}no" >&6; }
 
4398
fi
 
4399
 
 
4400
 
 
4401
  fi
 
4402
fi
 
4403
if test -z "$CC"; then
 
4404
  # Extract the first word of "cc", so it can be a program name with args.
 
4405
set dummy cc; ac_word=$2
 
4406
{ echo "$as_me:$LINENO: checking for $ac_word" >&5
 
4407
echo $ECHO_N "checking for $ac_word... $ECHO_C" >&6; }
 
4408
if test "${ac_cv_prog_CC+set}" = set; then
 
4409
  echo $ECHO_N "(cached) $ECHO_C" >&6
 
4410
else
 
4411
  if test -n "$CC"; then
 
4412
  ac_cv_prog_CC="$CC" # Let the user override the test.
 
4413
else
 
4414
  ac_prog_rejected=no
 
4415
as_save_IFS=$IFS; IFS=$PATH_SEPARATOR
 
4416
for as_dir in $PATH
 
4417
do
 
4418
  IFS=$as_save_IFS
 
4419
  test -z "$as_dir" && as_dir=.
 
4420
  for ac_exec_ext in '' $ac_executable_extensions; do
 
4421
  if { test -f "$as_dir/$ac_word$ac_exec_ext" && $as_executable_p "$as_dir/$ac_word$ac_exec_ext"; }; then
 
4422
    if test "$as_dir/$ac_word$ac_exec_ext" = "/usr/ucb/cc"; then
 
4423
       ac_prog_rejected=yes
 
4424
       continue
 
4425
     fi
 
4426
    ac_cv_prog_CC="cc"
 
4427
    echo "$as_me:$LINENO: found $as_dir/$ac_word$ac_exec_ext" >&5
 
4428
    break 2
 
4429
  fi
 
4430
done
 
4431
done
 
4432
IFS=$as_save_IFS
 
4433
 
 
4434
if test $ac_prog_rejected = yes; then
 
4435
  # We found a bogon in the path, so make sure we never use it.
 
4436
  set dummy $ac_cv_prog_CC
 
4437
  shift
 
4438
  if test $# != 0; then
 
4439
    # We chose a different compiler from the bogus one.
 
4440
    # However, it has the same basename, so the bogon will be chosen
 
4441
    # first if we set CC to just the basename; use the full file name.
 
4442
    shift
 
4443
    ac_cv_prog_CC="$as_dir/$ac_word${1+' '}$@"
 
4444
  fi
 
4445
fi
 
4446
fi
 
4447
fi
 
4448
CC=$ac_cv_prog_CC
 
4449
if test -n "$CC"; then
 
4450
  { echo "$as_me:$LINENO: result: $CC" >&5
 
4451
echo "${ECHO_T}$CC" >&6; }
 
4452
else
 
4453
  { echo "$as_me:$LINENO: result: no" >&5
 
4454
echo "${ECHO_T}no" >&6; }
 
4455
fi
 
4456
 
 
4457
 
 
4458
fi
 
4459
if test -z "$CC"; then
 
4460
  if test -n "$ac_tool_prefix"; then
 
4461
  for ac_prog in cl.exe
 
4462
  do
 
4463
    # Extract the first word of "$ac_tool_prefix$ac_prog", so it can be a program name with args.
 
4464
set dummy $ac_tool_prefix$ac_prog; ac_word=$2
 
4465
{ echo "$as_me:$LINENO: checking for $ac_word" >&5
 
4466
echo $ECHO_N "checking for $ac_word... $ECHO_C" >&6; }
 
4467
if test "${ac_cv_prog_CC+set}" = set; then
 
4468
  echo $ECHO_N "(cached) $ECHO_C" >&6
 
4469
else
 
4470
  if test -n "$CC"; then
 
4471
  ac_cv_prog_CC="$CC" # Let the user override the test.
 
4472
else
 
4473
as_save_IFS=$IFS; IFS=$PATH_SEPARATOR
 
4474
for as_dir in $PATH
 
4475
do
 
4476
  IFS=$as_save_IFS
 
4477
  test -z "$as_dir" && as_dir=.
 
4478
  for ac_exec_ext in '' $ac_executable_extensions; do
 
4479
  if { test -f "$as_dir/$ac_word$ac_exec_ext" && $as_executable_p "$as_dir/$ac_word$ac_exec_ext"; }; then
 
4480
    ac_cv_prog_CC="$ac_tool_prefix$ac_prog"
 
4481
    echo "$as_me:$LINENO: found $as_dir/$ac_word$ac_exec_ext" >&5
 
4482
    break 2
 
4483
  fi
 
4484
done
 
4485
done
 
4486
IFS=$as_save_IFS
 
4487
 
 
4488
fi
 
4489
fi
 
4490
CC=$ac_cv_prog_CC
 
4491
if test -n "$CC"; then
 
4492
  { echo "$as_me:$LINENO: result: $CC" >&5
 
4493
echo "${ECHO_T}$CC" >&6; }
 
4494
else
 
4495
  { echo "$as_me:$LINENO: result: no" >&5
 
4496
echo "${ECHO_T}no" >&6; }
 
4497
fi
 
4498
 
 
4499
 
 
4500
    test -n "$CC" && break
 
4501
  done
 
4502
fi
 
4503
if test -z "$CC"; then
 
4504
  ac_ct_CC=$CC
 
4505
  for ac_prog in cl.exe
 
4506
do
 
4507
  # Extract the first word of "$ac_prog", so it can be a program name with args.
 
4508
set dummy $ac_prog; ac_word=$2
 
4509
{ echo "$as_me:$LINENO: checking for $ac_word" >&5
 
4510
echo $ECHO_N "checking for $ac_word... $ECHO_C" >&6; }
 
4511
if test "${ac_cv_prog_ac_ct_CC+set}" = set; then
 
4512
  echo $ECHO_N "(cached) $ECHO_C" >&6
 
4513
else
 
4514
  if test -n "$ac_ct_CC"; then
 
4515
  ac_cv_prog_ac_ct_CC="$ac_ct_CC" # Let the user override the test.
 
4516
else
 
4517
as_save_IFS=$IFS; IFS=$PATH_SEPARATOR
 
4518
for as_dir in $PATH
 
4519
do
 
4520
  IFS=$as_save_IFS
 
4521
  test -z "$as_dir" && as_dir=.
 
4522
  for ac_exec_ext in '' $ac_executable_extensions; do
 
4523
  if { test -f "$as_dir/$ac_word$ac_exec_ext" && $as_executable_p "$as_dir/$ac_word$ac_exec_ext"; }; then
 
4524
    ac_cv_prog_ac_ct_CC="$ac_prog"
 
4525
    echo "$as_me:$LINENO: found $as_dir/$ac_word$ac_exec_ext" >&5
 
4526
    break 2
 
4527
  fi
 
4528
done
 
4529
done
 
4530
IFS=$as_save_IFS
 
4531
 
 
4532
fi
 
4533
fi
 
4534
ac_ct_CC=$ac_cv_prog_ac_ct_CC
 
4535
if test -n "$ac_ct_CC"; then
 
4536
  { echo "$as_me:$LINENO: result: $ac_ct_CC" >&5
 
4537
echo "${ECHO_T}$ac_ct_CC" >&6; }
 
4538
else
 
4539
  { echo "$as_me:$LINENO: result: no" >&5
 
4540
echo "${ECHO_T}no" >&6; }
 
4541
fi
 
4542
 
 
4543
 
 
4544
  test -n "$ac_ct_CC" && break
 
4545
done
 
4546
 
 
4547
  if test "x$ac_ct_CC" = x; then
 
4548
    CC=""
 
4549
  else
 
4550
    case $cross_compiling:$ac_tool_warned in
 
4551
yes:)
 
4552
{ echo "$as_me:$LINENO: WARNING: In the future, Autoconf will not detect cross-tools
 
4553
whose name does not start with the host triplet.  If you think this
 
4554
configuration is useful to you, please write to autoconf@gnu.org." >&5
 
4555
echo "$as_me: WARNING: In the future, Autoconf will not detect cross-tools
 
4556
whose name does not start with the host triplet.  If you think this
 
4557
configuration is useful to you, please write to autoconf@gnu.org." >&2;}
 
4558
ac_tool_warned=yes ;;
 
4559
esac
 
4560
    CC=$ac_ct_CC
 
4561
  fi
 
4562
fi
 
4563
 
 
4564
fi
 
4565
 
 
4566
 
 
4567
test -z "$CC" && { { echo "$as_me:$LINENO: error: no acceptable C compiler found in \$PATH
 
4568
See \`config.log' for more details." >&5
 
4569
echo "$as_me: error: no acceptable C compiler found in \$PATH
 
4570
See \`config.log' for more details." >&2;}
 
4571
   { (exit 1); exit 1; }; }
 
4572
 
 
4573
# Provide some information about the compiler.
 
4574
echo "$as_me:$LINENO: checking for C compiler version" >&5
 
4575
ac_compiler=`set X $ac_compile; echo $2`
 
4576
{ (ac_try="$ac_compiler --version >&5"
 
4577
case "(($ac_try" in
 
4578
  *\"* | *\`* | *\\*) ac_try_echo=\$ac_try;;
 
4579
  *) ac_try_echo=$ac_try;;
 
4580
esac
 
4581
eval "echo \"\$as_me:$LINENO: $ac_try_echo\"") >&5
 
4582
  (eval "$ac_compiler --version >&5") 2>&5
 
4583
  ac_status=$?
 
4584
  echo "$as_me:$LINENO: \$? = $ac_status" >&5
 
4585
  (exit $ac_status); }
 
4586
{ (ac_try="$ac_compiler -v >&5"
 
4587
case "(($ac_try" in
 
4588
  *\"* | *\`* | *\\*) ac_try_echo=\$ac_try;;
 
4589
  *) ac_try_echo=$ac_try;;
 
4590
esac
 
4591
eval "echo \"\$as_me:$LINENO: $ac_try_echo\"") >&5
 
4592
  (eval "$ac_compiler -v >&5") 2>&5
 
4593
  ac_status=$?
 
4594
  echo "$as_me:$LINENO: \$? = $ac_status" >&5
 
4595
  (exit $ac_status); }
 
4596
{ (ac_try="$ac_compiler -V >&5"
 
4597
case "(($ac_try" in
 
4598
  *\"* | *\`* | *\\*) ac_try_echo=\$ac_try;;
 
4599
  *) ac_try_echo=$ac_try;;
 
4600
esac
 
4601
eval "echo \"\$as_me:$LINENO: $ac_try_echo\"") >&5
 
4602
  (eval "$ac_compiler -V >&5") 2>&5
 
4603
  ac_status=$?
 
4604
  echo "$as_me:$LINENO: \$? = $ac_status" >&5
 
4605
  (exit $ac_status); }
 
4606
 
 
4607
{ echo "$as_me:$LINENO: checking whether we are using the GNU C compiler" >&5
 
4608
echo $ECHO_N "checking whether we are using the GNU C compiler... $ECHO_C" >&6; }
 
4609
if test "${ac_cv_c_compiler_gnu+set}" = set; then
 
4610
  echo $ECHO_N "(cached) $ECHO_C" >&6
 
4611
else
 
4612
  cat >conftest.$ac_ext <<_ACEOF
 
4613
/* confdefs.h.  */
 
4614
_ACEOF
 
4615
cat confdefs.h >>conftest.$ac_ext
 
4616
cat >>conftest.$ac_ext <<_ACEOF
 
4617
/* end confdefs.h.  */
 
4618
 
 
4619
int
 
4620
main ()
 
4621
{
 
4622
#ifndef __GNUC__
 
4623
       choke me
 
4624
#endif
 
4625
 
 
4626
  ;
 
4627
  return 0;
 
4628
}
 
4629
_ACEOF
 
4630
rm -f conftest.$ac_objext
 
4631
if { (ac_try="$ac_compile"
 
4632
case "(($ac_try" in
 
4633
  *\"* | *\`* | *\\*) ac_try_echo=\$ac_try;;
 
4634
  *) ac_try_echo=$ac_try;;
 
4635
esac
 
4636
eval "echo \"\$as_me:$LINENO: $ac_try_echo\"") >&5
 
4637
  (eval "$ac_compile") 2>conftest.er1
 
4638
  ac_status=$?
 
4639
  grep -v '^ *+' conftest.er1 >conftest.err
 
4640
  rm -f conftest.er1
 
4641
  cat conftest.err >&5
 
4642
  echo "$as_me:$LINENO: \$? = $ac_status" >&5
 
4643
  (exit $ac_status); } &&
 
4644
         { ac_try='test -z "$ac_c_werror_flag" || test ! -s conftest.err'
 
4645
  { (case "(($ac_try" in
 
4646
  *\"* | *\`* | *\\*) ac_try_echo=\$ac_try;;
 
4647
  *) ac_try_echo=$ac_try;;
 
4648
esac
 
4649
eval "echo \"\$as_me:$LINENO: $ac_try_echo\"") >&5
 
4650
  (eval "$ac_try") 2>&5
 
4651
  ac_status=$?
 
4652
  echo "$as_me:$LINENO: \$? = $ac_status" >&5
 
4653
  (exit $ac_status); }; } &&
 
4654
         { ac_try='test -s conftest.$ac_objext'
 
4655
  { (case "(($ac_try" in
 
4656
  *\"* | *\`* | *\\*) ac_try_echo=\$ac_try;;
 
4657
  *) ac_try_echo=$ac_try;;
 
4658
esac
 
4659
eval "echo \"\$as_me:$LINENO: $ac_try_echo\"") >&5
 
4660
  (eval "$ac_try") 2>&5
 
4661
  ac_status=$?
 
4662
  echo "$as_me:$LINENO: \$? = $ac_status" >&5
 
4663
  (exit $ac_status); }; }; then
 
4664
  ac_compiler_gnu=yes
 
4665
else
 
4666
  echo "$as_me: failed program was:" >&5
 
4667
sed 's/^/| /' conftest.$ac_ext >&5
 
4668
 
 
4669
        ac_compiler_gnu=no
 
4670
fi
 
4671
 
 
4672
rm -f core conftest.err conftest.$ac_objext conftest.$ac_ext
 
4673
ac_cv_c_compiler_gnu=$ac_compiler_gnu
 
4674
 
 
4675
fi
 
4676
{ echo "$as_me:$LINENO: result: $ac_cv_c_compiler_gnu" >&5
 
4677
echo "${ECHO_T}$ac_cv_c_compiler_gnu" >&6; }
 
4678
GCC=`test $ac_compiler_gnu = yes && echo yes`
 
4679
ac_test_CFLAGS=${CFLAGS+set}
 
4680
ac_save_CFLAGS=$CFLAGS
 
4681
{ echo "$as_me:$LINENO: checking whether $CC accepts -g" >&5
 
4682
echo $ECHO_N "checking whether $CC accepts -g... $ECHO_C" >&6; }
 
4683
if test "${ac_cv_prog_cc_g+set}" = set; then
 
4684
  echo $ECHO_N "(cached) $ECHO_C" >&6
 
4685
else
 
4686
  ac_save_c_werror_flag=$ac_c_werror_flag
 
4687
   ac_c_werror_flag=yes
 
4688
   ac_cv_prog_cc_g=no
 
4689
   CFLAGS="-g"
 
4690
   cat >conftest.$ac_ext <<_ACEOF
 
4691
/* confdefs.h.  */
 
4692
_ACEOF
 
4693
cat confdefs.h >>conftest.$ac_ext
 
4694
cat >>conftest.$ac_ext <<_ACEOF
 
4695
/* end confdefs.h.  */
 
4696
 
 
4697
int
 
4698
main ()
 
4699
{
 
4700
 
 
4701
  ;
 
4702
  return 0;
 
4703
}
 
4704
_ACEOF
 
4705
rm -f conftest.$ac_objext
 
4706
if { (ac_try="$ac_compile"
 
4707
case "(($ac_try" in
 
4708
  *\"* | *\`* | *\\*) ac_try_echo=\$ac_try;;
 
4709
  *) ac_try_echo=$ac_try;;
 
4710
esac
 
4711
eval "echo \"\$as_me:$LINENO: $ac_try_echo\"") >&5
 
4712
  (eval "$ac_compile") 2>conftest.er1
 
4713
  ac_status=$?
 
4714
  grep -v '^ *+' conftest.er1 >conftest.err
 
4715
  rm -f conftest.er1
 
4716
  cat conftest.err >&5
 
4717
  echo "$as_me:$LINENO: \$? = $ac_status" >&5
 
4718
  (exit $ac_status); } &&
 
4719
         { ac_try='test -z "$ac_c_werror_flag" || test ! -s conftest.err'
 
4720
  { (case "(($ac_try" in
 
4721
  *\"* | *\`* | *\\*) ac_try_echo=\$ac_try;;
 
4722
  *) ac_try_echo=$ac_try;;
 
4723
esac
 
4724
eval "echo \"\$as_me:$LINENO: $ac_try_echo\"") >&5
 
4725
  (eval "$ac_try") 2>&5
 
4726
  ac_status=$?
 
4727
  echo "$as_me:$LINENO: \$? = $ac_status" >&5
 
4728
  (exit $ac_status); }; } &&
 
4729
         { ac_try='test -s conftest.$ac_objext'
 
4730
  { (case "(($ac_try" in
 
4731
  *\"* | *\`* | *\\*) ac_try_echo=\$ac_try;;
 
4732
  *) ac_try_echo=$ac_try;;
 
4733
esac
 
4734
eval "echo \"\$as_me:$LINENO: $ac_try_echo\"") >&5
 
4735
  (eval "$ac_try") 2>&5
 
4736
  ac_status=$?
 
4737
  echo "$as_me:$LINENO: \$? = $ac_status" >&5
 
4738
  (exit $ac_status); }; }; then
 
4739
  ac_cv_prog_cc_g=yes
 
4740
else
 
4741
  echo "$as_me: failed program was:" >&5
 
4742
sed 's/^/| /' conftest.$ac_ext >&5
 
4743
 
 
4744
        CFLAGS=""
 
4745
      cat >conftest.$ac_ext <<_ACEOF
 
4746
/* confdefs.h.  */
 
4747
_ACEOF
 
4748
cat confdefs.h >>conftest.$ac_ext
 
4749
cat >>conftest.$ac_ext <<_ACEOF
 
4750
/* end confdefs.h.  */
 
4751
 
 
4752
int
 
4753
main ()
 
4754
{
 
4755
 
 
4756
  ;
 
4757
  return 0;
 
4758
}
 
4759
_ACEOF
 
4760
rm -f conftest.$ac_objext
 
4761
if { (ac_try="$ac_compile"
 
4762
case "(($ac_try" in
 
4763
  *\"* | *\`* | *\\*) ac_try_echo=\$ac_try;;
 
4764
  *) ac_try_echo=$ac_try;;
 
4765
esac
 
4766
eval "echo \"\$as_me:$LINENO: $ac_try_echo\"") >&5
 
4767
  (eval "$ac_compile") 2>conftest.er1
 
4768
  ac_status=$?
 
4769
  grep -v '^ *+' conftest.er1 >conftest.err
 
4770
  rm -f conftest.er1
 
4771
  cat conftest.err >&5
 
4772
  echo "$as_me:$LINENO: \$? = $ac_status" >&5
 
4773
  (exit $ac_status); } &&
 
4774
         { ac_try='test -z "$ac_c_werror_flag" || test ! -s conftest.err'
 
4775
  { (case "(($ac_try" in
 
4776
  *\"* | *\`* | *\\*) ac_try_echo=\$ac_try;;
 
4777
  *) ac_try_echo=$ac_try;;
 
4778
esac
 
4779
eval "echo \"\$as_me:$LINENO: $ac_try_echo\"") >&5
 
4780
  (eval "$ac_try") 2>&5
 
4781
  ac_status=$?
 
4782
  echo "$as_me:$LINENO: \$? = $ac_status" >&5
 
4783
  (exit $ac_status); }; } &&
 
4784
         { ac_try='test -s conftest.$ac_objext'
 
4785
  { (case "(($ac_try" in
 
4786
  *\"* | *\`* | *\\*) ac_try_echo=\$ac_try;;
 
4787
  *) ac_try_echo=$ac_try;;
 
4788
esac
 
4789
eval "echo \"\$as_me:$LINENO: $ac_try_echo\"") >&5
 
4790
  (eval "$ac_try") 2>&5
 
4791
  ac_status=$?
 
4792
  echo "$as_me:$LINENO: \$? = $ac_status" >&5
 
4793
  (exit $ac_status); }; }; then
 
4794
  :
 
4795
else
 
4796
  echo "$as_me: failed program was:" >&5
 
4797
sed 's/^/| /' conftest.$ac_ext >&5
 
4798
 
 
4799
        ac_c_werror_flag=$ac_save_c_werror_flag
 
4800
         CFLAGS="-g"
 
4801
         cat >conftest.$ac_ext <<_ACEOF
 
4802
/* confdefs.h.  */
 
4803
_ACEOF
 
4804
cat confdefs.h >>conftest.$ac_ext
 
4805
cat >>conftest.$ac_ext <<_ACEOF
 
4806
/* end confdefs.h.  */
 
4807
 
 
4808
int
 
4809
main ()
 
4810
{
 
4811
 
 
4812
  ;
 
4813
  return 0;
 
4814
}
 
4815
_ACEOF
 
4816
rm -f conftest.$ac_objext
 
4817
if { (ac_try="$ac_compile"
 
4818
case "(($ac_try" in
 
4819
  *\"* | *\`* | *\\*) ac_try_echo=\$ac_try;;
 
4820
  *) ac_try_echo=$ac_try;;
 
4821
esac
 
4822
eval "echo \"\$as_me:$LINENO: $ac_try_echo\"") >&5
 
4823
  (eval "$ac_compile") 2>conftest.er1
 
4824
  ac_status=$?
 
4825
  grep -v '^ *+' conftest.er1 >conftest.err
 
4826
  rm -f conftest.er1
 
4827
  cat conftest.err >&5
 
4828
  echo "$as_me:$LINENO: \$? = $ac_status" >&5
 
4829
  (exit $ac_status); } &&
 
4830
         { ac_try='test -z "$ac_c_werror_flag" || test ! -s conftest.err'
 
4831
  { (case "(($ac_try" in
 
4832
  *\"* | *\`* | *\\*) ac_try_echo=\$ac_try;;
 
4833
  *) ac_try_echo=$ac_try;;
 
4834
esac
 
4835
eval "echo \"\$as_me:$LINENO: $ac_try_echo\"") >&5
 
4836
  (eval "$ac_try") 2>&5
 
4837
  ac_status=$?
 
4838
  echo "$as_me:$LINENO: \$? = $ac_status" >&5
 
4839
  (exit $ac_status); }; } &&
 
4840
         { ac_try='test -s conftest.$ac_objext'
 
4841
  { (case "(($ac_try" in
 
4842
  *\"* | *\`* | *\\*) ac_try_echo=\$ac_try;;
 
4843
  *) ac_try_echo=$ac_try;;
 
4844
esac
 
4845
eval "echo \"\$as_me:$LINENO: $ac_try_echo\"") >&5
 
4846
  (eval "$ac_try") 2>&5
 
4847
  ac_status=$?
 
4848
  echo "$as_me:$LINENO: \$? = $ac_status" >&5
 
4849
  (exit $ac_status); }; }; then
 
4850
  ac_cv_prog_cc_g=yes
 
4851
else
 
4852
  echo "$as_me: failed program was:" >&5
 
4853
sed 's/^/| /' conftest.$ac_ext >&5
 
4854
 
 
4855
 
 
4856
fi
 
4857
 
 
4858
rm -f core conftest.err conftest.$ac_objext conftest.$ac_ext
 
4859
fi
 
4860
 
 
4861
rm -f core conftest.err conftest.$ac_objext conftest.$ac_ext
 
4862
fi
 
4863
 
 
4864
rm -f core conftest.err conftest.$ac_objext conftest.$ac_ext
 
4865
   ac_c_werror_flag=$ac_save_c_werror_flag
 
4866
fi
 
4867
{ echo "$as_me:$LINENO: result: $ac_cv_prog_cc_g" >&5
 
4868
echo "${ECHO_T}$ac_cv_prog_cc_g" >&6; }
 
4869
if test "$ac_test_CFLAGS" = set; then
 
4870
  CFLAGS=$ac_save_CFLAGS
 
4871
elif test $ac_cv_prog_cc_g = yes; then
 
4872
  if test "$GCC" = yes; then
 
4873
    CFLAGS="-g -O2"
 
4874
  else
 
4875
    CFLAGS="-g"
 
4876
  fi
 
4877
else
 
4878
  if test "$GCC" = yes; then
 
4879
    CFLAGS="-O2"
 
4880
  else
 
4881
    CFLAGS=
 
4882
  fi
 
4883
fi
 
4884
{ echo "$as_me:$LINENO: checking for $CC option to accept ISO C89" >&5
 
4885
echo $ECHO_N "checking for $CC option to accept ISO C89... $ECHO_C" >&6; }
 
4886
if test "${ac_cv_prog_cc_c89+set}" = set; then
 
4887
  echo $ECHO_N "(cached) $ECHO_C" >&6
 
4888
else
 
4889
  ac_cv_prog_cc_c89=no
 
4890
ac_save_CC=$CC
 
4891
cat >conftest.$ac_ext <<_ACEOF
 
4892
/* confdefs.h.  */
 
4893
_ACEOF
 
4894
cat confdefs.h >>conftest.$ac_ext
 
4895
cat >>conftest.$ac_ext <<_ACEOF
 
4896
/* end confdefs.h.  */
 
4897
#include <stdarg.h>
 
4898
#include <stdio.h>
 
4899
#include <sys/types.h>
 
4900
#include <sys/stat.h>
 
4901
/* Most of the following tests are stolen from RCS 5.7's src/conf.sh.  */
 
4902
struct buf { int x; };
 
4903
FILE * (*rcsopen) (struct buf *, struct stat *, int);
 
4904
static char *e (p, i)
 
4905
     char **p;
 
4906
     int i;
 
4907
{
 
4908
  return p[i];
 
4909
}
 
4910
static char *f (char * (*g) (char **, int), char **p, ...)
 
4911
{
 
4912
  char *s;
 
4913
  va_list v;
 
4914
  va_start (v,p);
 
4915
  s = g (p, va_arg (v,int));
 
4916
  va_end (v);
 
4917
  return s;
 
4918
}
 
4919
 
 
4920
/* OSF 4.0 Compaq cc is some sort of almost-ANSI by default.  It has
 
4921
   function prototypes and stuff, but not '\xHH' hex character constants.
 
4922
   These don't provoke an error unfortunately, instead are silently treated
 
4923
   as 'x'.  The following induces an error, until -std is added to get
 
4924
   proper ANSI mode.  Curiously '\x00'!='x' always comes out true, for an
 
4925
   array size at least.  It's necessary to write '\x00'==0 to get something
 
4926
   that's true only with -std.  */
 
4927
int osf4_cc_array ['\x00' == 0 ? 1 : -1];
 
4928
 
 
4929
/* IBM C 6 for AIX is almost-ANSI by default, but it replaces macro parameters
 
4930
   inside strings and character constants.  */
 
4931
#define FOO(x) 'x'
 
4932
int xlc6_cc_array[FOO(a) == 'x' ? 1 : -1];
 
4933
 
 
4934
int test (int i, double x);
 
4935
struct s1 {int (*f) (int a);};
 
4936
struct s2 {int (*f) (double a);};
 
4937
int pairnames (int, char **, FILE *(*)(struct buf *, struct stat *, int), int, int);
 
4938
int argc;
 
4939
char **argv;
 
4940
int
 
4941
main ()
 
4942
{
 
4943
return f (e, argv, 0) != argv[0]  ||  f (e, argv, 1) != argv[1];
 
4944
  ;
 
4945
  return 0;
 
4946
}
 
4947
_ACEOF
 
4948
for ac_arg in '' -qlanglvl=extc89 -qlanglvl=ansi -std \
 
4949
        -Ae "-Aa -D_HPUX_SOURCE" "-Xc -D__EXTENSIONS__"
 
4950
do
 
4951
  CC="$ac_save_CC $ac_arg"
 
4952
  rm -f conftest.$ac_objext
 
4953
if { (ac_try="$ac_compile"
 
4954
case "(($ac_try" in
 
4955
  *\"* | *\`* | *\\*) ac_try_echo=\$ac_try;;
 
4956
  *) ac_try_echo=$ac_try;;
 
4957
esac
 
4958
eval "echo \"\$as_me:$LINENO: $ac_try_echo\"") >&5
 
4959
  (eval "$ac_compile") 2>conftest.er1
 
4960
  ac_status=$?
 
4961
  grep -v '^ *+' conftest.er1 >conftest.err
 
4962
  rm -f conftest.er1
 
4963
  cat conftest.err >&5
 
4964
  echo "$as_me:$LINENO: \$? = $ac_status" >&5
 
4965
  (exit $ac_status); } &&
 
4966
         { ac_try='test -z "$ac_c_werror_flag" || test ! -s conftest.err'
 
4967
  { (case "(($ac_try" in
 
4968
  *\"* | *\`* | *\\*) ac_try_echo=\$ac_try;;
 
4969
  *) ac_try_echo=$ac_try;;
 
4970
esac
 
4971
eval "echo \"\$as_me:$LINENO: $ac_try_echo\"") >&5
 
4972
  (eval "$ac_try") 2>&5
 
4973
  ac_status=$?
 
4974
  echo "$as_me:$LINENO: \$? = $ac_status" >&5
 
4975
  (exit $ac_status); }; } &&
 
4976
         { ac_try='test -s conftest.$ac_objext'
 
4977
  { (case "(($ac_try" in
 
4978
  *\"* | *\`* | *\\*) ac_try_echo=\$ac_try;;
 
4979
  *) ac_try_echo=$ac_try;;
 
4980
esac
 
4981
eval "echo \"\$as_me:$LINENO: $ac_try_echo\"") >&5
 
4982
  (eval "$ac_try") 2>&5
 
4983
  ac_status=$?
 
4984
  echo "$as_me:$LINENO: \$? = $ac_status" >&5
 
4985
  (exit $ac_status); }; }; then
 
4986
  ac_cv_prog_cc_c89=$ac_arg
 
4987
else
 
4988
  echo "$as_me: failed program was:" >&5
 
4989
sed 's/^/| /' conftest.$ac_ext >&5
 
4990
 
 
4991
 
 
4992
fi
 
4993
 
 
4994
rm -f core conftest.err conftest.$ac_objext
 
4995
  test "x$ac_cv_prog_cc_c89" != "xno" && break
 
4996
done
 
4997
rm -f conftest.$ac_ext
 
4998
CC=$ac_save_CC
 
4999
 
 
5000
fi
 
5001
# AC_CACHE_VAL
 
5002
case "x$ac_cv_prog_cc_c89" in
 
5003
  x)
 
5004
    { echo "$as_me:$LINENO: result: none needed" >&5
 
5005
echo "${ECHO_T}none needed" >&6; } ;;
 
5006
  xno)
 
5007
    { echo "$as_me:$LINENO: result: unsupported" >&5
 
5008
echo "${ECHO_T}unsupported" >&6; } ;;
 
5009
  *)
 
5010
    CC="$CC $ac_cv_prog_cc_c89"
 
5011
    { echo "$as_me:$LINENO: result: $ac_cv_prog_cc_c89" >&5
 
5012
echo "${ECHO_T}$ac_cv_prog_cc_c89" >&6; } ;;
 
5013
esac
 
5014
 
 
5015
 
 
5016
ac_ext=c
 
5017
ac_cpp='$CPP $CPPFLAGS'
 
5018
ac_compile='$CC -c $CFLAGS $CPPFLAGS conftest.$ac_ext >&5'
 
5019
ac_link='$CC -o conftest$ac_exeext $CFLAGS $CPPFLAGS $LDFLAGS conftest.$ac_ext $LIBS >&5'
 
5020
ac_compiler_gnu=$ac_cv_c_compiler_gnu
 
5021
 
 
5022
depcc="$CC"   am_compiler_list=
 
5023
 
 
5024
{ echo "$as_me:$LINENO: checking dependency style of $depcc" >&5
 
5025
echo $ECHO_N "checking dependency style of $depcc... $ECHO_C" >&6; }
 
5026
if test "${am_cv_CC_dependencies_compiler_type+set}" = set; then
 
5027
  echo $ECHO_N "(cached) $ECHO_C" >&6
 
5028
else
 
5029
  if test -z "$AMDEP_TRUE" && test -f "$am_depcomp"; then
 
5030
  # We make a subdir and do the tests there.  Otherwise we can end up
 
5031
  # making bogus files that we don't know about and never remove.  For
 
5032
  # instance it was reported that on HP-UX the gcc test will end up
 
5033
  # making a dummy file named `D' -- because `-MD' means `put the output
 
5034
  # in D'.
 
5035
  mkdir conftest.dir
 
5036
  # Copy depcomp to subdir because otherwise we won't find it if we're
 
5037
  # using a relative directory.
 
5038
  cp "$am_depcomp" conftest.dir
 
5039
  cd conftest.dir
 
5040
  # We will build objects and dependencies in a subdirectory because
 
5041
  # it helps to detect inapplicable dependency modes.  For instance
 
5042
  # both Tru64's cc and ICC support -MD to output dependencies as a
 
5043
  # side effect of compilation, but ICC will put the dependencies in
 
5044
  # the current directory while Tru64 will put them in the object
 
5045
  # directory.
 
5046
  mkdir sub
 
5047
 
 
5048
  am_cv_CC_dependencies_compiler_type=none
 
5049
  if test "$am_compiler_list" = ""; then
 
5050
     am_compiler_list=`sed -n 's/^#*\([a-zA-Z0-9]*\))$/\1/p' < ./depcomp`
 
5051
  fi
 
5052
  for depmode in $am_compiler_list; do
 
5053
    # Setup a source with many dependencies, because some compilers
 
5054
    # like to wrap large dependency lists on column 80 (with \), and
 
5055
    # we should not choose a depcomp mode which is confused by this.
 
5056
    #
 
5057
    # We need to recreate these files for each test, as the compiler may
 
5058
    # overwrite some of them when testing with obscure command lines.
 
5059
    # This happens at least with the AIX C compiler.
 
5060
    : > sub/conftest.c
 
5061
    for i in 1 2 3 4 5 6; do
 
5062
      echo '#include "conftst'$i'.h"' >> sub/conftest.c
 
5063
      # Using `: > sub/conftst$i.h' creates only sub/conftst1.h with
 
5064
      # Solaris 8's {/usr,}/bin/sh.
 
5065
      touch sub/conftst$i.h
 
5066
    done
 
5067
    echo "${am__include} ${am__quote}sub/conftest.Po${am__quote}" > confmf
 
5068
 
 
5069
    case $depmode in
 
5070
    nosideeffect)
 
5071
      # after this tag, mechanisms are not by side-effect, so they'll
 
5072
      # only be used when explicitly requested
 
5073
      if test "x$enable_dependency_tracking" = xyes; then
 
5074
        continue
 
5075
      else
 
5076
        break
 
5077
      fi
 
5078
      ;;
 
5079
    none) break ;;
 
5080
    esac
 
5081
    # We check with `-c' and `-o' for the sake of the "dashmstdout"
 
5082
    # mode.  It turns out that the SunPro C++ compiler does not properly
 
5083
    # handle `-M -o', and we need to detect this.
 
5084
    if depmode=$depmode \
 
5085
       source=sub/conftest.c object=sub/conftest.${OBJEXT-o} \
 
5086
       depfile=sub/conftest.Po tmpdepfile=sub/conftest.TPo \
 
5087
       $SHELL ./depcomp $depcc -c -o sub/conftest.${OBJEXT-o} sub/conftest.c \
 
5088
         >/dev/null 2>conftest.err &&
 
5089
       grep sub/conftst6.h sub/conftest.Po > /dev/null 2>&1 &&
 
5090
       grep sub/conftest.${OBJEXT-o} sub/conftest.Po > /dev/null 2>&1 &&
 
5091
       ${MAKE-make} -s -f confmf > /dev/null 2>&1; then
 
5092
      # icc doesn't choke on unknown options, it will just issue warnings
 
5093
      # or remarks (even with -Werror).  So we grep stderr for any message
 
5094
      # that says an option was ignored or not supported.
 
5095
      # When given -MP, icc 7.0 and 7.1 complain thusly:
 
5096
      #   icc: Command line warning: ignoring option '-M'; no argument required
 
5097
      # The diagnosis changed in icc 8.0:
 
5098
      #   icc: Command line remark: option '-MP' not supported
 
5099
      if (grep 'ignoring option' conftest.err ||
 
5100
          grep 'not supported' conftest.err) >/dev/null 2>&1; then :; else
 
5101
        am_cv_CC_dependencies_compiler_type=$depmode
 
5102
        break
 
5103
      fi
 
5104
    fi
 
5105
  done
 
5106
 
 
5107
  cd ..
 
5108
  rm -rf conftest.dir
 
5109
else
 
5110
  am_cv_CC_dependencies_compiler_type=none
 
5111
fi
 
5112
 
 
5113
fi
 
5114
{ echo "$as_me:$LINENO: result: $am_cv_CC_dependencies_compiler_type" >&5
 
5115
echo "${ECHO_T}$am_cv_CC_dependencies_compiler_type" >&6; }
 
5116
CCDEPMODE=depmode=$am_cv_CC_dependencies_compiler_type
 
5117
 
 
5118
 
 
5119
 
 
5120
if
 
5121
  test "x$enable_dependency_tracking" != xno \
 
5122
  && test "$am_cv_CC_dependencies_compiler_type" = gcc3; then
 
5123
  am__fastdepCC_TRUE=
 
5124
  am__fastdepCC_FALSE='#'
 
5125
else
 
5126
  am__fastdepCC_TRUE='#'
 
5127
  am__fastdepCC_FALSE=
 
5128
fi
 
5129
 
 
5130
 
 
5131
 
 
5132
 
 
5133
 
 
5134
if test -n "$GCC"; then
 
5135
  GCC_TRUE=
 
5136
  GCC_FALSE='#'
 
5137
else
 
5138
  GCC_TRUE='#'
 
5139
  GCC_FALSE=
 
5140
fi
4053
5141
 
4054
5142
 
4055
5143
# 2. Libraries
4823
5911
# Allow CC to be a program name with arguments.
4824
5912
compiler=$CC
4825
5913
 
4826
 
 
4827
5914
# Check whether --enable-libtool-lock was given.
4828
5915
if test "${enable_libtool_lock+set}" = set; then
4829
5916
  enableval=$enable_libtool_lock;
4855
5942
  ;;
4856
5943
*-*-irix6*)
4857
5944
  # Find out which ABI we are using.
4858
 
  echo '#line 4858 "configure"' > conftest.$ac_ext
 
5945
  echo '#line 5945 "configure"' > conftest.$ac_ext
4859
5946
  if { (eval echo "$as_me:$LINENO: \"$ac_compile\"") >&5
4860
5947
  (eval $ac_compile) 2>&5
4861
5948
  ac_status=$?
8109
9196
   -e 's:.*FLAGS}\{0,1\} :&$lt_compiler_flag :; t' \
8110
9197
   -e 's: [^ ]*conftest\.: $lt_compiler_flag&:; t' \
8111
9198
   -e 's:$: $lt_compiler_flag:'`
8112
 
   (eval echo "\"\$as_me:8112: $lt_compile\"" >&5)
 
9199
   (eval echo "\"\$as_me:9199: $lt_compile\"" >&5)
8113
9200
   (eval "$lt_compile" 2>conftest.err)
8114
9201
   ac_status=$?
8115
9202
   cat conftest.err >&5
8116
 
   echo "$as_me:8116: \$? = $ac_status" >&5
 
9203
   echo "$as_me:9203: \$? = $ac_status" >&5
8117
9204
   if (exit $ac_status) && test -s "$ac_outfile"; then
8118
9205
     # The compiler can only warn and ignore the option if not recognized
8119
9206
     # So say no if there are warnings other than the usual output.
8377
9464
   -e 's:.*FLAGS}\{0,1\} :&$lt_compiler_flag :; t' \
8378
9465
   -e 's: [^ ]*conftest\.: $lt_compiler_flag&:; t' \
8379
9466
   -e 's:$: $lt_compiler_flag:'`
8380
 
   (eval echo "\"\$as_me:8380: $lt_compile\"" >&5)
 
9467
   (eval echo "\"\$as_me:9467: $lt_compile\"" >&5)
8381
9468
   (eval "$lt_compile" 2>conftest.err)
8382
9469
   ac_status=$?
8383
9470
   cat conftest.err >&5
8384
 
   echo "$as_me:8384: \$? = $ac_status" >&5
 
9471
   echo "$as_me:9471: \$? = $ac_status" >&5
8385
9472
   if (exit $ac_status) && test -s "$ac_outfile"; then
8386
9473
     # The compiler can only warn and ignore the option if not recognized
8387
9474
     # So say no if there are warnings other than the usual output.
8481
9568
   -e 's:.*FLAGS}\{0,1\} :&$lt_compiler_flag :; t' \
8482
9569
   -e 's: [^ ]*conftest\.: $lt_compiler_flag&:; t' \
8483
9570
   -e 's:$: $lt_compiler_flag:'`
8484
 
   (eval echo "\"\$as_me:8484: $lt_compile\"" >&5)
 
9571
   (eval echo "\"\$as_me:9571: $lt_compile\"" >&5)
8485
9572
   (eval "$lt_compile" 2>out/conftest.err)
8486
9573
   ac_status=$?
8487
9574
   cat out/conftest.err >&5
8488
 
   echo "$as_me:8488: \$? = $ac_status" >&5
 
9575
   echo "$as_me:9575: \$? = $ac_status" >&5
8489
9576
   if (exit $ac_status) && test -s out/conftest2.$ac_objext
8490
9577
   then
8491
9578
     # The compiler can only warn and ignore the option if not recognized
10933
12020
  lt_dlunknown=0; lt_dlno_uscore=1; lt_dlneed_uscore=2
10934
12021
  lt_status=$lt_dlunknown
10935
12022
  cat > conftest.$ac_ext <<EOF
10936
 
#line 10936 "configure"
 
12023
#line 12023 "configure"
10937
12024
#include "confdefs.h"
10938
12025
 
10939
12026
#if HAVE_DLFCN_H
11033
12120
  lt_dlunknown=0; lt_dlno_uscore=1; lt_dlneed_uscore=2
11034
12121
  lt_status=$lt_dlunknown
11035
12122
  cat > conftest.$ac_ext <<EOF
11036
 
#line 11036 "configure"
 
12123
#line 12123 "configure"
11037
12124
#include "confdefs.h"
11038
12125
 
11039
12126
#if HAVE_DLFCN_H
13401
14488
   -e 's:.*FLAGS}\{0,1\} :&$lt_compiler_flag :; t' \
13402
14489
   -e 's: [^ ]*conftest\.: $lt_compiler_flag&:; t' \
13403
14490
   -e 's:$: $lt_compiler_flag:'`
13404
 
   (eval echo "\"\$as_me:13404: $lt_compile\"" >&5)
 
14491
   (eval echo "\"\$as_me:14491: $lt_compile\"" >&5)
13405
14492
   (eval "$lt_compile" 2>conftest.err)
13406
14493
   ac_status=$?
13407
14494
   cat conftest.err >&5
13408
 
   echo "$as_me:13408: \$? = $ac_status" >&5
 
14495
   echo "$as_me:14495: \$? = $ac_status" >&5
13409
14496
   if (exit $ac_status) && test -s "$ac_outfile"; then
13410
14497
     # The compiler can only warn and ignore the option if not recognized
13411
14498
     # So say no if there are warnings other than the usual output.
13505
14592
   -e 's:.*FLAGS}\{0,1\} :&$lt_compiler_flag :; t' \
13506
14593
   -e 's: [^ ]*conftest\.: $lt_compiler_flag&:; t' \
13507
14594
   -e 's:$: $lt_compiler_flag:'`
13508
 
   (eval echo "\"\$as_me:13508: $lt_compile\"" >&5)
 
14595
   (eval echo "\"\$as_me:14595: $lt_compile\"" >&5)
13509
14596
   (eval "$lt_compile" 2>out/conftest.err)
13510
14597
   ac_status=$?
13511
14598
   cat out/conftest.err >&5
13512
 
   echo "$as_me:13512: \$? = $ac_status" >&5
 
14599
   echo "$as_me:14599: \$? = $ac_status" >&5
13513
14600
   if (exit $ac_status) && test -s out/conftest2.$ac_objext
13514
14601
   then
13515
14602
     # The compiler can only warn and ignore the option if not recognized
15075
16162
   -e 's:.*FLAGS}\{0,1\} :&$lt_compiler_flag :; t' \
15076
16163
   -e 's: [^ ]*conftest\.: $lt_compiler_flag&:; t' \
15077
16164
   -e 's:$: $lt_compiler_flag:'`
15078
 
   (eval echo "\"\$as_me:15078: $lt_compile\"" >&5)
 
16165
   (eval echo "\"\$as_me:16165: $lt_compile\"" >&5)
15079
16166
   (eval "$lt_compile" 2>conftest.err)
15080
16167
   ac_status=$?
15081
16168
   cat conftest.err >&5
15082
 
   echo "$as_me:15082: \$? = $ac_status" >&5
 
16169
   echo "$as_me:16169: \$? = $ac_status" >&5
15083
16170
   if (exit $ac_status) && test -s "$ac_outfile"; then
15084
16171
     # The compiler can only warn and ignore the option if not recognized
15085
16172
     # So say no if there are warnings other than the usual output.
15179
16266
   -e 's:.*FLAGS}\{0,1\} :&$lt_compiler_flag :; t' \
15180
16267
   -e 's: [^ ]*conftest\.: $lt_compiler_flag&:; t' \
15181
16268
   -e 's:$: $lt_compiler_flag:'`
15182
 
   (eval echo "\"\$as_me:15182: $lt_compile\"" >&5)
 
16269
   (eval echo "\"\$as_me:16269: $lt_compile\"" >&5)
15183
16270
   (eval "$lt_compile" 2>out/conftest.err)
15184
16271
   ac_status=$?
15185
16272
   cat out/conftest.err >&5
15186
 
   echo "$as_me:15186: \$? = $ac_status" >&5
 
16273
   echo "$as_me:16273: \$? = $ac_status" >&5
15187
16274
   if (exit $ac_status) && test -s out/conftest2.$ac_objext
15188
16275
   then
15189
16276
     # The compiler can only warn and ignore the option if not recognized
17409
18496
   -e 's:.*FLAGS}\{0,1\} :&$lt_compiler_flag :; t' \
17410
18497
   -e 's: [^ ]*conftest\.: $lt_compiler_flag&:; t' \
17411
18498
   -e 's:$: $lt_compiler_flag:'`
17412
 
   (eval echo "\"\$as_me:17412: $lt_compile\"" >&5)
 
18499
   (eval echo "\"\$as_me:18499: $lt_compile\"" >&5)
17413
18500
   (eval "$lt_compile" 2>conftest.err)
17414
18501
   ac_status=$?
17415
18502
   cat conftest.err >&5
17416
 
   echo "$as_me:17416: \$? = $ac_status" >&5
 
18503
   echo "$as_me:18503: \$? = $ac_status" >&5
17417
18504
   if (exit $ac_status) && test -s "$ac_outfile"; then
17418
18505
     # The compiler can only warn and ignore the option if not recognized
17419
18506
     # So say no if there are warnings other than the usual output.
17677
18764
   -e 's:.*FLAGS}\{0,1\} :&$lt_compiler_flag :; t' \
17678
18765
   -e 's: [^ ]*conftest\.: $lt_compiler_flag&:; t' \
17679
18766
   -e 's:$: $lt_compiler_flag:'`
17680
 
   (eval echo "\"\$as_me:17680: $lt_compile\"" >&5)
 
18767
   (eval echo "\"\$as_me:18767: $lt_compile\"" >&5)
17681
18768
   (eval "$lt_compile" 2>conftest.err)
17682
18769
   ac_status=$?
17683
18770
   cat conftest.err >&5
17684
 
   echo "$as_me:17684: \$? = $ac_status" >&5
 
18771
   echo "$as_me:18771: \$? = $ac_status" >&5
17685
18772
   if (exit $ac_status) && test -s "$ac_outfile"; then
17686
18773
     # The compiler can only warn and ignore the option if not recognized
17687
18774
     # So say no if there are warnings other than the usual output.
17781
18868
   -e 's:.*FLAGS}\{0,1\} :&$lt_compiler_flag :; t' \
17782
18869
   -e 's: [^ ]*conftest\.: $lt_compiler_flag&:; t' \
17783
18870
   -e 's:$: $lt_compiler_flag:'`
17784
 
   (eval echo "\"\$as_me:17784: $lt_compile\"" >&5)
 
18871
   (eval echo "\"\$as_me:18871: $lt_compile\"" >&5)
17785
18872
   (eval "$lt_compile" 2>out/conftest.err)
17786
18873
   ac_status=$?
17787
18874
   cat out/conftest.err >&5
17788
 
   echo "$as_me:17788: \$? = $ac_status" >&5
 
18875
   echo "$as_me:18875: \$? = $ac_status" >&5
17789
18876
   if (exit $ac_status) && test -s out/conftest2.$ac_objext
17790
18877
   then
17791
18878
     # The compiler can only warn and ignore the option if not recognized
20866
21953
 
20867
21954
fi
20868
21955
 
 
21956
if test "$with_libpq" = yes; then
 
21957
 
 
21958
{ echo "$as_me:$LINENO: checking for PQconnectdb in -lpq" >&5
 
21959
echo $ECHO_N "checking for PQconnectdb in -lpq... $ECHO_C" >&6; }
 
21960
if test "${ac_cv_lib_pq_PQconnectdb+set}" = set; then
 
21961
  echo $ECHO_N "(cached) $ECHO_C" >&6
 
21962
else
 
21963
  ac_check_lib_save_LIBS=$LIBS
 
21964
LIBS="-lpq  $LIBS"
 
21965
cat >conftest.$ac_ext <<_ACEOF
 
21966
/* confdefs.h.  */
 
21967
_ACEOF
 
21968
cat confdefs.h >>conftest.$ac_ext
 
21969
cat >>conftest.$ac_ext <<_ACEOF
 
21970
/* end confdefs.h.  */
 
21971
 
 
21972
/* Override any GCC internal prototype to avoid an error.
 
21973
   Use char because int might match the return type of a GCC
 
21974
   builtin and then its argument prototype would still apply.  */
 
21975
#ifdef __cplusplus
 
21976
extern "C"
 
21977
#endif
 
21978
char PQconnectdb ();
 
21979
int
 
21980
main ()
 
21981
{
 
21982
return PQconnectdb ();
 
21983
  ;
 
21984
  return 0;
 
21985
}
 
21986
_ACEOF
 
21987
rm -f conftest.$ac_objext conftest$ac_exeext
 
21988
if { (ac_try="$ac_link"
 
21989
case "(($ac_try" in
 
21990
  *\"* | *\`* | *\\*) ac_try_echo=\$ac_try;;
 
21991
  *) ac_try_echo=$ac_try;;
 
21992
esac
 
21993
eval "echo \"\$as_me:$LINENO: $ac_try_echo\"") >&5
 
21994
  (eval "$ac_link") 2>conftest.er1
 
21995
  ac_status=$?
 
21996
  grep -v '^ *+' conftest.er1 >conftest.err
 
21997
  rm -f conftest.er1
 
21998
  cat conftest.err >&5
 
21999
  echo "$as_me:$LINENO: \$? = $ac_status" >&5
 
22000
  (exit $ac_status); } &&
 
22001
         { ac_try='test -z "$ac_c_werror_flag" || test ! -s conftest.err'
 
22002
  { (case "(($ac_try" in
 
22003
  *\"* | *\`* | *\\*) ac_try_echo=\$ac_try;;
 
22004
  *) ac_try_echo=$ac_try;;
 
22005
esac
 
22006
eval "echo \"\$as_me:$LINENO: $ac_try_echo\"") >&5
 
22007
  (eval "$ac_try") 2>&5
 
22008
  ac_status=$?
 
22009
  echo "$as_me:$LINENO: \$? = $ac_status" >&5
 
22010
  (exit $ac_status); }; } &&
 
22011
         { ac_try='test -s conftest$ac_exeext'
 
22012
  { (case "(($ac_try" in
 
22013
  *\"* | *\`* | *\\*) ac_try_echo=\$ac_try;;
 
22014
  *) ac_try_echo=$ac_try;;
 
22015
esac
 
22016
eval "echo \"\$as_me:$LINENO: $ac_try_echo\"") >&5
 
22017
  (eval "$ac_try") 2>&5
 
22018
  ac_status=$?
 
22019
  echo "$as_me:$LINENO: \$? = $ac_status" >&5
 
22020
  (exit $ac_status); }; }; then
 
22021
  ac_cv_lib_pq_PQconnectdb=yes
 
22022
else
 
22023
  echo "$as_me: failed program was:" >&5
 
22024
sed 's/^/| /' conftest.$ac_ext >&5
 
22025
 
 
22026
        ac_cv_lib_pq_PQconnectdb=no
 
22027
fi
 
22028
 
 
22029
rm -f core conftest.err conftest.$ac_objext \
 
22030
      conftest$ac_exeext conftest.$ac_ext
 
22031
LIBS=$ac_check_lib_save_LIBS
 
22032
fi
 
22033
{ echo "$as_me:$LINENO: result: $ac_cv_lib_pq_PQconnectdb" >&5
 
22034
echo "${ECHO_T}$ac_cv_lib_pq_PQconnectdb" >&6; }
 
22035
if test $ac_cv_lib_pq_PQconnectdb = yes; then
 
22036
  cat >>confdefs.h <<_ACEOF
 
22037
#define HAVE_LIBPQ 1
 
22038
_ACEOF
 
22039
 
 
22040
  LIBS="-lpq $LIBS"
 
22041
 
 
22042
else
 
22043
  { { echo "$as_me:$LINENO: error: libpq library not found" >&5
 
22044
echo "$as_me: error: libpq library not found" >&2;}
 
22045
   { (exit 1); exit 1; }; }
 
22046
fi
 
22047
 
 
22048
fi
 
22049
 
 
22050
if test "$enable_openssl" = yes; then
 
22051
 
 
22052
{ echo "$as_me:$LINENO: checking for SSL_read in -lssl" >&5
 
22053
echo $ECHO_N "checking for SSL_read in -lssl... $ECHO_C" >&6; }
 
22054
if test "${ac_cv_lib_ssl_SSL_read+set}" = set; then
 
22055
  echo $ECHO_N "(cached) $ECHO_C" >&6
 
22056
else
 
22057
  ac_check_lib_save_LIBS=$LIBS
 
22058
LIBS="-lssl  $LIBS"
 
22059
cat >conftest.$ac_ext <<_ACEOF
 
22060
/* confdefs.h.  */
 
22061
_ACEOF
 
22062
cat confdefs.h >>conftest.$ac_ext
 
22063
cat >>conftest.$ac_ext <<_ACEOF
 
22064
/* end confdefs.h.  */
 
22065
 
 
22066
/* Override any GCC internal prototype to avoid an error.
 
22067
   Use char because int might match the return type of a GCC
 
22068
   builtin and then its argument prototype would still apply.  */
 
22069
#ifdef __cplusplus
 
22070
extern "C"
 
22071
#endif
 
22072
char SSL_read ();
 
22073
int
 
22074
main ()
 
22075
{
 
22076
return SSL_read ();
 
22077
  ;
 
22078
  return 0;
 
22079
}
 
22080
_ACEOF
 
22081
rm -f conftest.$ac_objext conftest$ac_exeext
 
22082
if { (ac_try="$ac_link"
 
22083
case "(($ac_try" in
 
22084
  *\"* | *\`* | *\\*) ac_try_echo=\$ac_try;;
 
22085
  *) ac_try_echo=$ac_try;;
 
22086
esac
 
22087
eval "echo \"\$as_me:$LINENO: $ac_try_echo\"") >&5
 
22088
  (eval "$ac_link") 2>conftest.er1
 
22089
  ac_status=$?
 
22090
  grep -v '^ *+' conftest.er1 >conftest.err
 
22091
  rm -f conftest.er1
 
22092
  cat conftest.err >&5
 
22093
  echo "$as_me:$LINENO: \$? = $ac_status" >&5
 
22094
  (exit $ac_status); } &&
 
22095
         { ac_try='test -z "$ac_c_werror_flag" || test ! -s conftest.err'
 
22096
  { (case "(($ac_try" in
 
22097
  *\"* | *\`* | *\\*) ac_try_echo=\$ac_try;;
 
22098
  *) ac_try_echo=$ac_try;;
 
22099
esac
 
22100
eval "echo \"\$as_me:$LINENO: $ac_try_echo\"") >&5
 
22101
  (eval "$ac_try") 2>&5
 
22102
  ac_status=$?
 
22103
  echo "$as_me:$LINENO: \$? = $ac_status" >&5
 
22104
  (exit $ac_status); }; } &&
 
22105
         { ac_try='test -s conftest$ac_exeext'
 
22106
  { (case "(($ac_try" in
 
22107
  *\"* | *\`* | *\\*) ac_try_echo=\$ac_try;;
 
22108
  *) ac_try_echo=$ac_try;;
 
22109
esac
 
22110
eval "echo \"\$as_me:$LINENO: $ac_try_echo\"") >&5
 
22111
  (eval "$ac_try") 2>&5
 
22112
  ac_status=$?
 
22113
  echo "$as_me:$LINENO: \$? = $ac_status" >&5
 
22114
  (exit $ac_status); }; }; then
 
22115
  ac_cv_lib_ssl_SSL_read=yes
 
22116
else
 
22117
  echo "$as_me: failed program was:" >&5
 
22118
sed 's/^/| /' conftest.$ac_ext >&5
 
22119
 
 
22120
        ac_cv_lib_ssl_SSL_read=no
 
22121
fi
 
22122
 
 
22123
rm -f core conftest.err conftest.$ac_objext \
 
22124
      conftest$ac_exeext conftest.$ac_ext
 
22125
LIBS=$ac_check_lib_save_LIBS
 
22126
fi
 
22127
{ echo "$as_me:$LINENO: result: $ac_cv_lib_ssl_SSL_read" >&5
 
22128
echo "${ECHO_T}$ac_cv_lib_ssl_SSL_read" >&6; }
 
22129
if test $ac_cv_lib_ssl_SSL_read = yes; then
 
22130
  cat >>confdefs.h <<_ACEOF
 
22131
#define HAVE_LIBSSL 1
 
22132
_ACEOF
 
22133
 
 
22134
  LIBS="-lssl $LIBS"
 
22135
 
 
22136
else
 
22137
  { { echo "$as_me:$LINENO: error: ssl library not found" >&5
 
22138
echo "$as_me: error: ssl library not found" >&2;}
 
22139
   { (exit 1); exit 1; }; }
 
22140
fi
 
22141
 
 
22142
fi
 
22143
 
 
22144
if test "$enable_gss" = yes; then
 
22145
  { echo "$as_me:$LINENO: checking for library containing gss_init_sec_context" >&5
 
22146
echo $ECHO_N "checking for library containing gss_init_sec_context... $ECHO_C" >&6; }
 
22147
if test "${ac_cv_search_gss_init_sec_context+set}" = set; then
 
22148
  echo $ECHO_N "(cached) $ECHO_C" >&6
 
22149
else
 
22150
  ac_func_search_save_LIBS=$LIBS
 
22151
cat >conftest.$ac_ext <<_ACEOF
 
22152
/* confdefs.h.  */
 
22153
_ACEOF
 
22154
cat confdefs.h >>conftest.$ac_ext
 
22155
cat >>conftest.$ac_ext <<_ACEOF
 
22156
/* end confdefs.h.  */
 
22157
 
 
22158
/* Override any GCC internal prototype to avoid an error.
 
22159
   Use char because int might match the return type of a GCC
 
22160
   builtin and then its argument prototype would still apply.  */
 
22161
#ifdef __cplusplus
 
22162
extern "C"
 
22163
#endif
 
22164
char gss_init_sec_context ();
 
22165
int
 
22166
main ()
 
22167
{
 
22168
return gss_init_sec_context ();
 
22169
  ;
 
22170
  return 0;
 
22171
}
 
22172
_ACEOF
 
22173
for ac_lib in '' gssapi_krb5 gss 'gssapi -lkrb5 -lcrypto'; do
 
22174
  if test -z "$ac_lib"; then
 
22175
    ac_res="none required"
 
22176
  else
 
22177
    ac_res=-l$ac_lib
 
22178
    LIBS="-l$ac_lib  $ac_func_search_save_LIBS"
 
22179
  fi
 
22180
  rm -f conftest.$ac_objext conftest$ac_exeext
 
22181
if { (ac_try="$ac_link"
 
22182
case "(($ac_try" in
 
22183
  *\"* | *\`* | *\\*) ac_try_echo=\$ac_try;;
 
22184
  *) ac_try_echo=$ac_try;;
 
22185
esac
 
22186
eval "echo \"\$as_me:$LINENO: $ac_try_echo\"") >&5
 
22187
  (eval "$ac_link") 2>conftest.er1
 
22188
  ac_status=$?
 
22189
  grep -v '^ *+' conftest.er1 >conftest.err
 
22190
  rm -f conftest.er1
 
22191
  cat conftest.err >&5
 
22192
  echo "$as_me:$LINENO: \$? = $ac_status" >&5
 
22193
  (exit $ac_status); } &&
 
22194
         { ac_try='test -z "$ac_c_werror_flag" || test ! -s conftest.err'
 
22195
  { (case "(($ac_try" in
 
22196
  *\"* | *\`* | *\\*) ac_try_echo=\$ac_try;;
 
22197
  *) ac_try_echo=$ac_try;;
 
22198
esac
 
22199
eval "echo \"\$as_me:$LINENO: $ac_try_echo\"") >&5
 
22200
  (eval "$ac_try") 2>&5
 
22201
  ac_status=$?
 
22202
  echo "$as_me:$LINENO: \$? = $ac_status" >&5
 
22203
  (exit $ac_status); }; } &&
 
22204
         { ac_try='test -s conftest$ac_exeext'
 
22205
  { (case "(($ac_try" in
 
22206
  *\"* | *\`* | *\\*) ac_try_echo=\$ac_try;;
 
22207
  *) ac_try_echo=$ac_try;;
 
22208
esac
 
22209
eval "echo \"\$as_me:$LINENO: $ac_try_echo\"") >&5
 
22210
  (eval "$ac_try") 2>&5
 
22211
  ac_status=$?
 
22212
  echo "$as_me:$LINENO: \$? = $ac_status" >&5
 
22213
  (exit $ac_status); }; }; then
 
22214
  ac_cv_search_gss_init_sec_context=$ac_res
 
22215
else
 
22216
  echo "$as_me: failed program was:" >&5
 
22217
sed 's/^/| /' conftest.$ac_ext >&5
 
22218
 
 
22219
 
 
22220
fi
 
22221
 
 
22222
rm -f core conftest.err conftest.$ac_objext \
 
22223
      conftest$ac_exeext
 
22224
  if test "${ac_cv_search_gss_init_sec_context+set}" = set; then
 
22225
  break
 
22226
fi
 
22227
done
 
22228
if test "${ac_cv_search_gss_init_sec_context+set}" = set; then
 
22229
  :
 
22230
else
 
22231
  ac_cv_search_gss_init_sec_context=no
 
22232
fi
 
22233
rm conftest.$ac_ext
 
22234
LIBS=$ac_func_search_save_LIBS
 
22235
fi
 
22236
{ echo "$as_me:$LINENO: result: $ac_cv_search_gss_init_sec_context" >&5
 
22237
echo "${ECHO_T}$ac_cv_search_gss_init_sec_context" >&6; }
 
22238
ac_res=$ac_cv_search_gss_init_sec_context
 
22239
if test "$ac_res" != no; then
 
22240
  test "$ac_res" = "none required" || LIBS="$ac_res $LIBS"
 
22241
 
 
22242
else
 
22243
  { { echo "$as_me:$LINENO: error: gssapi library not found" >&5
 
22244
echo "$as_me: error: gssapi library not found" >&2;}
 
22245
   { (exit 1); exit 1; }; }
 
22246
fi
 
22247
 
 
22248
fi
 
22249
 
 
22250
if test "$enable_krb5" = yes; then
 
22251
  { echo "$as_me:$LINENO: checking for library containing krb5_sendauth" >&5
 
22252
echo $ECHO_N "checking for library containing krb5_sendauth... $ECHO_C" >&6; }
 
22253
if test "${ac_cv_search_krb5_sendauth+set}" = set; then
 
22254
  echo $ECHO_N "(cached) $ECHO_C" >&6
 
22255
else
 
22256
  ac_func_search_save_LIBS=$LIBS
 
22257
cat >conftest.$ac_ext <<_ACEOF
 
22258
/* confdefs.h.  */
 
22259
_ACEOF
 
22260
cat confdefs.h >>conftest.$ac_ext
 
22261
cat >>conftest.$ac_ext <<_ACEOF
 
22262
/* end confdefs.h.  */
 
22263
 
 
22264
/* Override any GCC internal prototype to avoid an error.
 
22265
   Use char because int might match the return type of a GCC
 
22266
   builtin and then its argument prototype would still apply.  */
 
22267
#ifdef __cplusplus
 
22268
extern "C"
 
22269
#endif
 
22270
char krb5_sendauth ();
 
22271
int
 
22272
main ()
 
22273
{
 
22274
return krb5_sendauth ();
 
22275
  ;
 
22276
  return 0;
 
22277
}
 
22278
_ACEOF
 
22279
for ac_lib in '' krb5 'krb5 -lcrypto -ldes -lasn1 -lroken'; do
 
22280
  if test -z "$ac_lib"; then
 
22281
    ac_res="none required"
 
22282
  else
 
22283
    ac_res=-l$ac_lib
 
22284
    LIBS="-l$ac_lib  $ac_func_search_save_LIBS"
 
22285
  fi
 
22286
  rm -f conftest.$ac_objext conftest$ac_exeext
 
22287
if { (ac_try="$ac_link"
 
22288
case "(($ac_try" in
 
22289
  *\"* | *\`* | *\\*) ac_try_echo=\$ac_try;;
 
22290
  *) ac_try_echo=$ac_try;;
 
22291
esac
 
22292
eval "echo \"\$as_me:$LINENO: $ac_try_echo\"") >&5
 
22293
  (eval "$ac_link") 2>conftest.er1
 
22294
  ac_status=$?
 
22295
  grep -v '^ *+' conftest.er1 >conftest.err
 
22296
  rm -f conftest.er1
 
22297
  cat conftest.err >&5
 
22298
  echo "$as_me:$LINENO: \$? = $ac_status" >&5
 
22299
  (exit $ac_status); } &&
 
22300
         { ac_try='test -z "$ac_c_werror_flag" || test ! -s conftest.err'
 
22301
  { (case "(($ac_try" in
 
22302
  *\"* | *\`* | *\\*) ac_try_echo=\$ac_try;;
 
22303
  *) ac_try_echo=$ac_try;;
 
22304
esac
 
22305
eval "echo \"\$as_me:$LINENO: $ac_try_echo\"") >&5
 
22306
  (eval "$ac_try") 2>&5
 
22307
  ac_status=$?
 
22308
  echo "$as_me:$LINENO: \$? = $ac_status" >&5
 
22309
  (exit $ac_status); }; } &&
 
22310
         { ac_try='test -s conftest$ac_exeext'
 
22311
  { (case "(($ac_try" in
 
22312
  *\"* | *\`* | *\\*) ac_try_echo=\$ac_try;;
 
22313
  *) ac_try_echo=$ac_try;;
 
22314
esac
 
22315
eval "echo \"\$as_me:$LINENO: $ac_try_echo\"") >&5
 
22316
  (eval "$ac_try") 2>&5
 
22317
  ac_status=$?
 
22318
  echo "$as_me:$LINENO: \$? = $ac_status" >&5
 
22319
  (exit $ac_status); }; }; then
 
22320
  ac_cv_search_krb5_sendauth=$ac_res
 
22321
else
 
22322
  echo "$as_me: failed program was:" >&5
 
22323
sed 's/^/| /' conftest.$ac_ext >&5
 
22324
 
 
22325
 
 
22326
fi
 
22327
 
 
22328
rm -f core conftest.err conftest.$ac_objext \
 
22329
      conftest$ac_exeext
 
22330
  if test "${ac_cv_search_krb5_sendauth+set}" = set; then
 
22331
  break
 
22332
fi
 
22333
done
 
22334
if test "${ac_cv_search_krb5_sendauth+set}" = set; then
 
22335
  :
 
22336
else
 
22337
  ac_cv_search_krb5_sendauth=no
 
22338
fi
 
22339
rm conftest.$ac_ext
 
22340
LIBS=$ac_func_search_save_LIBS
 
22341
fi
 
22342
{ echo "$as_me:$LINENO: result: $ac_cv_search_krb5_sendauth" >&5
 
22343
echo "${ECHO_T}$ac_cv_search_krb5_sendauth" >&6; }
 
22344
ac_res=$ac_cv_search_krb5_sendauth
 
22345
if test "$ac_res" != no; then
 
22346
  test "$ac_res" = "none required" || LIBS="$ac_res $LIBS"
 
22347
 
 
22348
else
 
22349
  { { echo "$as_me:$LINENO: error: krb5 library not found" >&5
 
22350
echo "$as_me: error: krb5 library not found" >&2;}
 
22351
   { (exit 1); exit 1; }; }
 
22352
fi
 
22353
 
 
22354
  { echo "$as_me:$LINENO: checking for library containing com_err" >&5
 
22355
echo $ECHO_N "checking for library containing com_err... $ECHO_C" >&6; }
 
22356
if test "${ac_cv_search_com_err+set}" = set; then
 
22357
  echo $ECHO_N "(cached) $ECHO_C" >&6
 
22358
else
 
22359
  ac_func_search_save_LIBS=$LIBS
 
22360
cat >conftest.$ac_ext <<_ACEOF
 
22361
/* confdefs.h.  */
 
22362
_ACEOF
 
22363
cat confdefs.h >>conftest.$ac_ext
 
22364
cat >>conftest.$ac_ext <<_ACEOF
 
22365
/* end confdefs.h.  */
 
22366
 
 
22367
/* Override any GCC internal prototype to avoid an error.
 
22368
   Use char because int might match the return type of a GCC
 
22369
   builtin and then its argument prototype would still apply.  */
 
22370
#ifdef __cplusplus
 
22371
extern "C"
 
22372
#endif
 
22373
char com_err ();
 
22374
int
 
22375
main ()
 
22376
{
 
22377
return com_err ();
 
22378
  ;
 
22379
  return 0;
 
22380
}
 
22381
_ACEOF
 
22382
for ac_lib in '' krb5 'krb5 -lcrypto -ldes -lasn1 -lroken' comerr 'comerr -lssl -lcrypto'; do
 
22383
  if test -z "$ac_lib"; then
 
22384
    ac_res="none required"
 
22385
  else
 
22386
    ac_res=-l$ac_lib
 
22387
    LIBS="-l$ac_lib  $ac_func_search_save_LIBS"
 
22388
  fi
 
22389
  rm -f conftest.$ac_objext conftest$ac_exeext
 
22390
if { (ac_try="$ac_link"
 
22391
case "(($ac_try" in
 
22392
  *\"* | *\`* | *\\*) ac_try_echo=\$ac_try;;
 
22393
  *) ac_try_echo=$ac_try;;
 
22394
esac
 
22395
eval "echo \"\$as_me:$LINENO: $ac_try_echo\"") >&5
 
22396
  (eval "$ac_link") 2>conftest.er1
 
22397
  ac_status=$?
 
22398
  grep -v '^ *+' conftest.er1 >conftest.err
 
22399
  rm -f conftest.er1
 
22400
  cat conftest.err >&5
 
22401
  echo "$as_me:$LINENO: \$? = $ac_status" >&5
 
22402
  (exit $ac_status); } &&
 
22403
         { ac_try='test -z "$ac_c_werror_flag" || test ! -s conftest.err'
 
22404
  { (case "(($ac_try" in
 
22405
  *\"* | *\`* | *\\*) ac_try_echo=\$ac_try;;
 
22406
  *) ac_try_echo=$ac_try;;
 
22407
esac
 
22408
eval "echo \"\$as_me:$LINENO: $ac_try_echo\"") >&5
 
22409
  (eval "$ac_try") 2>&5
 
22410
  ac_status=$?
 
22411
  echo "$as_me:$LINENO: \$? = $ac_status" >&5
 
22412
  (exit $ac_status); }; } &&
 
22413
         { ac_try='test -s conftest$ac_exeext'
 
22414
  { (case "(($ac_try" in
 
22415
  *\"* | *\`* | *\\*) ac_try_echo=\$ac_try;;
 
22416
  *) ac_try_echo=$ac_try;;
 
22417
esac
 
22418
eval "echo \"\$as_me:$LINENO: $ac_try_echo\"") >&5
 
22419
  (eval "$ac_try") 2>&5
 
22420
  ac_status=$?
 
22421
  echo "$as_me:$LINENO: \$? = $ac_status" >&5
 
22422
  (exit $ac_status); }; }; then
 
22423
  ac_cv_search_com_err=$ac_res
 
22424
else
 
22425
  echo "$as_me: failed program was:" >&5
 
22426
sed 's/^/| /' conftest.$ac_ext >&5
 
22427
 
 
22428
 
 
22429
fi
 
22430
 
 
22431
rm -f core conftest.err conftest.$ac_objext \
 
22432
      conftest$ac_exeext
 
22433
  if test "${ac_cv_search_com_err+set}" = set; then
 
22434
  break
 
22435
fi
 
22436
done
 
22437
if test "${ac_cv_search_com_err+set}" = set; then
 
22438
  :
 
22439
else
 
22440
  ac_cv_search_com_err=no
 
22441
fi
 
22442
rm conftest.$ac_ext
 
22443
LIBS=$ac_func_search_save_LIBS
 
22444
fi
 
22445
{ echo "$as_me:$LINENO: result: $ac_cv_search_com_err" >&5
 
22446
echo "${ECHO_T}$ac_cv_search_com_err" >&6; }
 
22447
ac_res=$ac_cv_search_com_err
 
22448
if test "$ac_res" != no; then
 
22449
  test "$ac_res" = "none required" || LIBS="$ac_res $LIBS"
 
22450
 
 
22451
else
 
22452
  { { echo "$as_me:$LINENO: error: comerr library not found" >&5
 
22453
echo "$as_me: error: comerr library not found" >&2;}
 
22454
   { (exit 1); exit 1; }; }
 
22455
fi
 
22456
 
 
22457
fi
20869
22458
 
20870
22459
# 3. Header files
20871
22460
 
21040
22629
 
21041
22630
done
21042
22631
 
 
22632
if test "$with_libpq" = yes; then
 
22633
  if test "${ac_cv_header_libpq_fe_h+set}" = set; then
 
22634
  { echo "$as_me:$LINENO: checking for libpq-fe.h" >&5
 
22635
echo $ECHO_N "checking for libpq-fe.h... $ECHO_C" >&6; }
 
22636
if test "${ac_cv_header_libpq_fe_h+set}" = set; then
 
22637
  echo $ECHO_N "(cached) $ECHO_C" >&6
 
22638
fi
 
22639
{ echo "$as_me:$LINENO: result: $ac_cv_header_libpq_fe_h" >&5
 
22640
echo "${ECHO_T}$ac_cv_header_libpq_fe_h" >&6; }
 
22641
else
 
22642
  # Is the header compilable?
 
22643
{ echo "$as_me:$LINENO: checking libpq-fe.h usability" >&5
 
22644
echo $ECHO_N "checking libpq-fe.h usability... $ECHO_C" >&6; }
 
22645
cat >conftest.$ac_ext <<_ACEOF
 
22646
/* confdefs.h.  */
 
22647
_ACEOF
 
22648
cat confdefs.h >>conftest.$ac_ext
 
22649
cat >>conftest.$ac_ext <<_ACEOF
 
22650
/* end confdefs.h.  */
 
22651
$ac_includes_default
 
22652
#include <libpq-fe.h>
 
22653
_ACEOF
 
22654
rm -f conftest.$ac_objext
 
22655
if { (ac_try="$ac_compile"
 
22656
case "(($ac_try" in
 
22657
  *\"* | *\`* | *\\*) ac_try_echo=\$ac_try;;
 
22658
  *) ac_try_echo=$ac_try;;
 
22659
esac
 
22660
eval "echo \"\$as_me:$LINENO: $ac_try_echo\"") >&5
 
22661
  (eval "$ac_compile") 2>conftest.er1
 
22662
  ac_status=$?
 
22663
  grep -v '^ *+' conftest.er1 >conftest.err
 
22664
  rm -f conftest.er1
 
22665
  cat conftest.err >&5
 
22666
  echo "$as_me:$LINENO: \$? = $ac_status" >&5
 
22667
  (exit $ac_status); } &&
 
22668
         { ac_try='test -z "$ac_c_werror_flag" || test ! -s conftest.err'
 
22669
  { (case "(($ac_try" in
 
22670
  *\"* | *\`* | *\\*) ac_try_echo=\$ac_try;;
 
22671
  *) ac_try_echo=$ac_try;;
 
22672
esac
 
22673
eval "echo \"\$as_me:$LINENO: $ac_try_echo\"") >&5
 
22674
  (eval "$ac_try") 2>&5
 
22675
  ac_status=$?
 
22676
  echo "$as_me:$LINENO: \$? = $ac_status" >&5
 
22677
  (exit $ac_status); }; } &&
 
22678
         { ac_try='test -s conftest.$ac_objext'
 
22679
  { (case "(($ac_try" in
 
22680
  *\"* | *\`* | *\\*) ac_try_echo=\$ac_try;;
 
22681
  *) ac_try_echo=$ac_try;;
 
22682
esac
 
22683
eval "echo \"\$as_me:$LINENO: $ac_try_echo\"") >&5
 
22684
  (eval "$ac_try") 2>&5
 
22685
  ac_status=$?
 
22686
  echo "$as_me:$LINENO: \$? = $ac_status" >&5
 
22687
  (exit $ac_status); }; }; then
 
22688
  ac_header_compiler=yes
 
22689
else
 
22690
  echo "$as_me: failed program was:" >&5
 
22691
sed 's/^/| /' conftest.$ac_ext >&5
 
22692
 
 
22693
        ac_header_compiler=no
 
22694
fi
 
22695
 
 
22696
rm -f core conftest.err conftest.$ac_objext conftest.$ac_ext
 
22697
{ echo "$as_me:$LINENO: result: $ac_header_compiler" >&5
 
22698
echo "${ECHO_T}$ac_header_compiler" >&6; }
 
22699
 
 
22700
# Is the header present?
 
22701
{ echo "$as_me:$LINENO: checking libpq-fe.h presence" >&5
 
22702
echo $ECHO_N "checking libpq-fe.h presence... $ECHO_C" >&6; }
 
22703
cat >conftest.$ac_ext <<_ACEOF
 
22704
/* confdefs.h.  */
 
22705
_ACEOF
 
22706
cat confdefs.h >>conftest.$ac_ext
 
22707
cat >>conftest.$ac_ext <<_ACEOF
 
22708
/* end confdefs.h.  */
 
22709
#include <libpq-fe.h>
 
22710
_ACEOF
 
22711
if { (ac_try="$ac_cpp conftest.$ac_ext"
 
22712
case "(($ac_try" in
 
22713
  *\"* | *\`* | *\\*) ac_try_echo=\$ac_try;;
 
22714
  *) ac_try_echo=$ac_try;;
 
22715
esac
 
22716
eval "echo \"\$as_me:$LINENO: $ac_try_echo\"") >&5
 
22717
  (eval "$ac_cpp conftest.$ac_ext") 2>conftest.er1
 
22718
  ac_status=$?
 
22719
  grep -v '^ *+' conftest.er1 >conftest.err
 
22720
  rm -f conftest.er1
 
22721
  cat conftest.err >&5
 
22722
  echo "$as_me:$LINENO: \$? = $ac_status" >&5
 
22723
  (exit $ac_status); } >/dev/null; then
 
22724
  if test -s conftest.err; then
 
22725
    ac_cpp_err=$ac_c_preproc_warn_flag
 
22726
    ac_cpp_err=$ac_cpp_err$ac_c_werror_flag
 
22727
  else
 
22728
    ac_cpp_err=
 
22729
  fi
 
22730
else
 
22731
  ac_cpp_err=yes
 
22732
fi
 
22733
if test -z "$ac_cpp_err"; then
 
22734
  ac_header_preproc=yes
 
22735
else
 
22736
  echo "$as_me: failed program was:" >&5
 
22737
sed 's/^/| /' conftest.$ac_ext >&5
 
22738
 
 
22739
  ac_header_preproc=no
 
22740
fi
 
22741
 
 
22742
rm -f conftest.err conftest.$ac_ext
 
22743
{ echo "$as_me:$LINENO: result: $ac_header_preproc" >&5
 
22744
echo "${ECHO_T}$ac_header_preproc" >&6; }
 
22745
 
 
22746
# So?  What about this header?
 
22747
case $ac_header_compiler:$ac_header_preproc:$ac_c_preproc_warn_flag in
 
22748
  yes:no: )
 
22749
    { echo "$as_me:$LINENO: WARNING: libpq-fe.h: accepted by the compiler, rejected by the preprocessor!" >&5
 
22750
echo "$as_me: WARNING: libpq-fe.h: accepted by the compiler, rejected by the preprocessor!" >&2;}
 
22751
    { echo "$as_me:$LINENO: WARNING: libpq-fe.h: proceeding with the compiler's result" >&5
 
22752
echo "$as_me: WARNING: libpq-fe.h: proceeding with the compiler's result" >&2;}
 
22753
    ac_header_preproc=yes
 
22754
    ;;
 
22755
  no:yes:* )
 
22756
    { echo "$as_me:$LINENO: WARNING: libpq-fe.h: present but cannot be compiled" >&5
 
22757
echo "$as_me: WARNING: libpq-fe.h: present but cannot be compiled" >&2;}
 
22758
    { echo "$as_me:$LINENO: WARNING: libpq-fe.h:     check for missing prerequisite headers?" >&5
 
22759
echo "$as_me: WARNING: libpq-fe.h:     check for missing prerequisite headers?" >&2;}
 
22760
    { echo "$as_me:$LINENO: WARNING: libpq-fe.h: see the Autoconf documentation" >&5
 
22761
echo "$as_me: WARNING: libpq-fe.h: see the Autoconf documentation" >&2;}
 
22762
    { echo "$as_me:$LINENO: WARNING: libpq-fe.h:     section \"Present But Cannot Be Compiled\"" >&5
 
22763
echo "$as_me: WARNING: libpq-fe.h:     section \"Present But Cannot Be Compiled\"" >&2;}
 
22764
    { echo "$as_me:$LINENO: WARNING: libpq-fe.h: proceeding with the preprocessor's result" >&5
 
22765
echo "$as_me: WARNING: libpq-fe.h: proceeding with the preprocessor's result" >&2;}
 
22766
    { echo "$as_me:$LINENO: WARNING: libpq-fe.h: in the future, the compiler will take precedence" >&5
 
22767
echo "$as_me: WARNING: libpq-fe.h: in the future, the compiler will take precedence" >&2;}
 
22768
    ( cat <<\_ASBOX
 
22769
## ---------------------------------------- ##
 
22770
## Report this to pgsql-odbc@postgresql.org ##
 
22771
## ---------------------------------------- ##
 
22772
_ASBOX
 
22773
     ) | sed "s/^/$as_me: WARNING:     /" >&2
 
22774
    ;;
 
22775
esac
 
22776
{ echo "$as_me:$LINENO: checking for libpq-fe.h" >&5
 
22777
echo $ECHO_N "checking for libpq-fe.h... $ECHO_C" >&6; }
 
22778
if test "${ac_cv_header_libpq_fe_h+set}" = set; then
 
22779
  echo $ECHO_N "(cached) $ECHO_C" >&6
 
22780
else
 
22781
  ac_cv_header_libpq_fe_h=$ac_header_preproc
 
22782
fi
 
22783
{ echo "$as_me:$LINENO: result: $ac_cv_header_libpq_fe_h" >&5
 
22784
echo "${ECHO_T}$ac_cv_header_libpq_fe_h" >&6; }
 
22785
 
 
22786
fi
 
22787
if test $ac_cv_header_libpq_fe_h = yes; then
 
22788
  :
 
22789
else
 
22790
  { { echo "$as_me:$LINENO: error: libpq header not found" >&5
 
22791
echo "$as_me: error: libpq header not found" >&2;}
 
22792
   { (exit 1); exit 1; }; }
 
22793
fi
 
22794
 
 
22795
 
 
22796
fi
 
22797
if test "$enable_openssl" = yes; then
 
22798
  if test "${ac_cv_header_openssl_ssl_h+set}" = set; then
 
22799
  { echo "$as_me:$LINENO: checking for openssl/ssl.h" >&5
 
22800
echo $ECHO_N "checking for openssl/ssl.h... $ECHO_C" >&6; }
 
22801
if test "${ac_cv_header_openssl_ssl_h+set}" = set; then
 
22802
  echo $ECHO_N "(cached) $ECHO_C" >&6
 
22803
fi
 
22804
{ echo "$as_me:$LINENO: result: $ac_cv_header_openssl_ssl_h" >&5
 
22805
echo "${ECHO_T}$ac_cv_header_openssl_ssl_h" >&6; }
 
22806
else
 
22807
  # Is the header compilable?
 
22808
{ echo "$as_me:$LINENO: checking openssl/ssl.h usability" >&5
 
22809
echo $ECHO_N "checking openssl/ssl.h usability... $ECHO_C" >&6; }
 
22810
cat >conftest.$ac_ext <<_ACEOF
 
22811
/* confdefs.h.  */
 
22812
_ACEOF
 
22813
cat confdefs.h >>conftest.$ac_ext
 
22814
cat >>conftest.$ac_ext <<_ACEOF
 
22815
/* end confdefs.h.  */
 
22816
$ac_includes_default
 
22817
#include <openssl/ssl.h>
 
22818
_ACEOF
 
22819
rm -f conftest.$ac_objext
 
22820
if { (ac_try="$ac_compile"
 
22821
case "(($ac_try" in
 
22822
  *\"* | *\`* | *\\*) ac_try_echo=\$ac_try;;
 
22823
  *) ac_try_echo=$ac_try;;
 
22824
esac
 
22825
eval "echo \"\$as_me:$LINENO: $ac_try_echo\"") >&5
 
22826
  (eval "$ac_compile") 2>conftest.er1
 
22827
  ac_status=$?
 
22828
  grep -v '^ *+' conftest.er1 >conftest.err
 
22829
  rm -f conftest.er1
 
22830
  cat conftest.err >&5
 
22831
  echo "$as_me:$LINENO: \$? = $ac_status" >&5
 
22832
  (exit $ac_status); } &&
 
22833
         { ac_try='test -z "$ac_c_werror_flag" || test ! -s conftest.err'
 
22834
  { (case "(($ac_try" in
 
22835
  *\"* | *\`* | *\\*) ac_try_echo=\$ac_try;;
 
22836
  *) ac_try_echo=$ac_try;;
 
22837
esac
 
22838
eval "echo \"\$as_me:$LINENO: $ac_try_echo\"") >&5
 
22839
  (eval "$ac_try") 2>&5
 
22840
  ac_status=$?
 
22841
  echo "$as_me:$LINENO: \$? = $ac_status" >&5
 
22842
  (exit $ac_status); }; } &&
 
22843
         { ac_try='test -s conftest.$ac_objext'
 
22844
  { (case "(($ac_try" in
 
22845
  *\"* | *\`* | *\\*) ac_try_echo=\$ac_try;;
 
22846
  *) ac_try_echo=$ac_try;;
 
22847
esac
 
22848
eval "echo \"\$as_me:$LINENO: $ac_try_echo\"") >&5
 
22849
  (eval "$ac_try") 2>&5
 
22850
  ac_status=$?
 
22851
  echo "$as_me:$LINENO: \$? = $ac_status" >&5
 
22852
  (exit $ac_status); }; }; then
 
22853
  ac_header_compiler=yes
 
22854
else
 
22855
  echo "$as_me: failed program was:" >&5
 
22856
sed 's/^/| /' conftest.$ac_ext >&5
 
22857
 
 
22858
        ac_header_compiler=no
 
22859
fi
 
22860
 
 
22861
rm -f core conftest.err conftest.$ac_objext conftest.$ac_ext
 
22862
{ echo "$as_me:$LINENO: result: $ac_header_compiler" >&5
 
22863
echo "${ECHO_T}$ac_header_compiler" >&6; }
 
22864
 
 
22865
# Is the header present?
 
22866
{ echo "$as_me:$LINENO: checking openssl/ssl.h presence" >&5
 
22867
echo $ECHO_N "checking openssl/ssl.h presence... $ECHO_C" >&6; }
 
22868
cat >conftest.$ac_ext <<_ACEOF
 
22869
/* confdefs.h.  */
 
22870
_ACEOF
 
22871
cat confdefs.h >>conftest.$ac_ext
 
22872
cat >>conftest.$ac_ext <<_ACEOF
 
22873
/* end confdefs.h.  */
 
22874
#include <openssl/ssl.h>
 
22875
_ACEOF
 
22876
if { (ac_try="$ac_cpp conftest.$ac_ext"
 
22877
case "(($ac_try" in
 
22878
  *\"* | *\`* | *\\*) ac_try_echo=\$ac_try;;
 
22879
  *) ac_try_echo=$ac_try;;
 
22880
esac
 
22881
eval "echo \"\$as_me:$LINENO: $ac_try_echo\"") >&5
 
22882
  (eval "$ac_cpp conftest.$ac_ext") 2>conftest.er1
 
22883
  ac_status=$?
 
22884
  grep -v '^ *+' conftest.er1 >conftest.err
 
22885
  rm -f conftest.er1
 
22886
  cat conftest.err >&5
 
22887
  echo "$as_me:$LINENO: \$? = $ac_status" >&5
 
22888
  (exit $ac_status); } >/dev/null; then
 
22889
  if test -s conftest.err; then
 
22890
    ac_cpp_err=$ac_c_preproc_warn_flag
 
22891
    ac_cpp_err=$ac_cpp_err$ac_c_werror_flag
 
22892
  else
 
22893
    ac_cpp_err=
 
22894
  fi
 
22895
else
 
22896
  ac_cpp_err=yes
 
22897
fi
 
22898
if test -z "$ac_cpp_err"; then
 
22899
  ac_header_preproc=yes
 
22900
else
 
22901
  echo "$as_me: failed program was:" >&5
 
22902
sed 's/^/| /' conftest.$ac_ext >&5
 
22903
 
 
22904
  ac_header_preproc=no
 
22905
fi
 
22906
 
 
22907
rm -f conftest.err conftest.$ac_ext
 
22908
{ echo "$as_me:$LINENO: result: $ac_header_preproc" >&5
 
22909
echo "${ECHO_T}$ac_header_preproc" >&6; }
 
22910
 
 
22911
# So?  What about this header?
 
22912
case $ac_header_compiler:$ac_header_preproc:$ac_c_preproc_warn_flag in
 
22913
  yes:no: )
 
22914
    { echo "$as_me:$LINENO: WARNING: openssl/ssl.h: accepted by the compiler, rejected by the preprocessor!" >&5
 
22915
echo "$as_me: WARNING: openssl/ssl.h: accepted by the compiler, rejected by the preprocessor!" >&2;}
 
22916
    { echo "$as_me:$LINENO: WARNING: openssl/ssl.h: proceeding with the compiler's result" >&5
 
22917
echo "$as_me: WARNING: openssl/ssl.h: proceeding with the compiler's result" >&2;}
 
22918
    ac_header_preproc=yes
 
22919
    ;;
 
22920
  no:yes:* )
 
22921
    { echo "$as_me:$LINENO: WARNING: openssl/ssl.h: present but cannot be compiled" >&5
 
22922
echo "$as_me: WARNING: openssl/ssl.h: present but cannot be compiled" >&2;}
 
22923
    { echo "$as_me:$LINENO: WARNING: openssl/ssl.h:     check for missing prerequisite headers?" >&5
 
22924
echo "$as_me: WARNING: openssl/ssl.h:     check for missing prerequisite headers?" >&2;}
 
22925
    { echo "$as_me:$LINENO: WARNING: openssl/ssl.h: see the Autoconf documentation" >&5
 
22926
echo "$as_me: WARNING: openssl/ssl.h: see the Autoconf documentation" >&2;}
 
22927
    { echo "$as_me:$LINENO: WARNING: openssl/ssl.h:     section \"Present But Cannot Be Compiled\"" >&5
 
22928
echo "$as_me: WARNING: openssl/ssl.h:     section \"Present But Cannot Be Compiled\"" >&2;}
 
22929
    { echo "$as_me:$LINENO: WARNING: openssl/ssl.h: proceeding with the preprocessor's result" >&5
 
22930
echo "$as_me: WARNING: openssl/ssl.h: proceeding with the preprocessor's result" >&2;}
 
22931
    { echo "$as_me:$LINENO: WARNING: openssl/ssl.h: in the future, the compiler will take precedence" >&5
 
22932
echo "$as_me: WARNING: openssl/ssl.h: in the future, the compiler will take precedence" >&2;}
 
22933
    ( cat <<\_ASBOX
 
22934
## ---------------------------------------- ##
 
22935
## Report this to pgsql-odbc@postgresql.org ##
 
22936
## ---------------------------------------- ##
 
22937
_ASBOX
 
22938
     ) | sed "s/^/$as_me: WARNING:     /" >&2
 
22939
    ;;
 
22940
esac
 
22941
{ echo "$as_me:$LINENO: checking for openssl/ssl.h" >&5
 
22942
echo $ECHO_N "checking for openssl/ssl.h... $ECHO_C" >&6; }
 
22943
if test "${ac_cv_header_openssl_ssl_h+set}" = set; then
 
22944
  echo $ECHO_N "(cached) $ECHO_C" >&6
 
22945
else
 
22946
  ac_cv_header_openssl_ssl_h=$ac_header_preproc
 
22947
fi
 
22948
{ echo "$as_me:$LINENO: result: $ac_cv_header_openssl_ssl_h" >&5
 
22949
echo "${ECHO_T}$ac_cv_header_openssl_ssl_h" >&6; }
 
22950
 
 
22951
fi
 
22952
if test $ac_cv_header_openssl_ssl_h = yes; then
 
22953
  :
 
22954
else
 
22955
  { { echo "$as_me:$LINENO: error: ssl header not found" >&5
 
22956
echo "$as_me: error: ssl header not found" >&2;}
 
22957
   { (exit 1); exit 1; }; }
 
22958
fi
 
22959
 
 
22960
 
 
22961
fi
 
22962
if test "$enable_gss" = yes; then
 
22963
 
 
22964
for ac_header in gssapi/gssapi.h
 
22965
do
 
22966
as_ac_Header=`echo "ac_cv_header_$ac_header" | $as_tr_sh`
 
22967
if { as_var=$as_ac_Header; eval "test \"\${$as_var+set}\" = set"; }; then
 
22968
  { echo "$as_me:$LINENO: checking for $ac_header" >&5
 
22969
echo $ECHO_N "checking for $ac_header... $ECHO_C" >&6; }
 
22970
if { as_var=$as_ac_Header; eval "test \"\${$as_var+set}\" = set"; }; then
 
22971
  echo $ECHO_N "(cached) $ECHO_C" >&6
 
22972
fi
 
22973
ac_res=`eval echo '${'$as_ac_Header'}'`
 
22974
               { echo "$as_me:$LINENO: result: $ac_res" >&5
 
22975
echo "${ECHO_T}$ac_res" >&6; }
 
22976
else
 
22977
  # Is the header compilable?
 
22978
{ echo "$as_me:$LINENO: checking $ac_header usability" >&5
 
22979
echo $ECHO_N "checking $ac_header usability... $ECHO_C" >&6; }
 
22980
cat >conftest.$ac_ext <<_ACEOF
 
22981
/* confdefs.h.  */
 
22982
_ACEOF
 
22983
cat confdefs.h >>conftest.$ac_ext
 
22984
cat >>conftest.$ac_ext <<_ACEOF
 
22985
/* end confdefs.h.  */
 
22986
$ac_includes_default
 
22987
#include <$ac_header>
 
22988
_ACEOF
 
22989
rm -f conftest.$ac_objext
 
22990
if { (ac_try="$ac_compile"
 
22991
case "(($ac_try" in
 
22992
  *\"* | *\`* | *\\*) ac_try_echo=\$ac_try;;
 
22993
  *) ac_try_echo=$ac_try;;
 
22994
esac
 
22995
eval "echo \"\$as_me:$LINENO: $ac_try_echo\"") >&5
 
22996
  (eval "$ac_compile") 2>conftest.er1
 
22997
  ac_status=$?
 
22998
  grep -v '^ *+' conftest.er1 >conftest.err
 
22999
  rm -f conftest.er1
 
23000
  cat conftest.err >&5
 
23001
  echo "$as_me:$LINENO: \$? = $ac_status" >&5
 
23002
  (exit $ac_status); } &&
 
23003
         { ac_try='test -z "$ac_c_werror_flag" || test ! -s conftest.err'
 
23004
  { (case "(($ac_try" in
 
23005
  *\"* | *\`* | *\\*) ac_try_echo=\$ac_try;;
 
23006
  *) ac_try_echo=$ac_try;;
 
23007
esac
 
23008
eval "echo \"\$as_me:$LINENO: $ac_try_echo\"") >&5
 
23009
  (eval "$ac_try") 2>&5
 
23010
  ac_status=$?
 
23011
  echo "$as_me:$LINENO: \$? = $ac_status" >&5
 
23012
  (exit $ac_status); }; } &&
 
23013
         { ac_try='test -s conftest.$ac_objext'
 
23014
  { (case "(($ac_try" in
 
23015
  *\"* | *\`* | *\\*) ac_try_echo=\$ac_try;;
 
23016
  *) ac_try_echo=$ac_try;;
 
23017
esac
 
23018
eval "echo \"\$as_me:$LINENO: $ac_try_echo\"") >&5
 
23019
  (eval "$ac_try") 2>&5
 
23020
  ac_status=$?
 
23021
  echo "$as_me:$LINENO: \$? = $ac_status" >&5
 
23022
  (exit $ac_status); }; }; then
 
23023
  ac_header_compiler=yes
 
23024
else
 
23025
  echo "$as_me: failed program was:" >&5
 
23026
sed 's/^/| /' conftest.$ac_ext >&5
 
23027
 
 
23028
        ac_header_compiler=no
 
23029
fi
 
23030
 
 
23031
rm -f core conftest.err conftest.$ac_objext conftest.$ac_ext
 
23032
{ echo "$as_me:$LINENO: result: $ac_header_compiler" >&5
 
23033
echo "${ECHO_T}$ac_header_compiler" >&6; }
 
23034
 
 
23035
# Is the header present?
 
23036
{ echo "$as_me:$LINENO: checking $ac_header presence" >&5
 
23037
echo $ECHO_N "checking $ac_header presence... $ECHO_C" >&6; }
 
23038
cat >conftest.$ac_ext <<_ACEOF
 
23039
/* confdefs.h.  */
 
23040
_ACEOF
 
23041
cat confdefs.h >>conftest.$ac_ext
 
23042
cat >>conftest.$ac_ext <<_ACEOF
 
23043
/* end confdefs.h.  */
 
23044
#include <$ac_header>
 
23045
_ACEOF
 
23046
if { (ac_try="$ac_cpp conftest.$ac_ext"
 
23047
case "(($ac_try" in
 
23048
  *\"* | *\`* | *\\*) ac_try_echo=\$ac_try;;
 
23049
  *) ac_try_echo=$ac_try;;
 
23050
esac
 
23051
eval "echo \"\$as_me:$LINENO: $ac_try_echo\"") >&5
 
23052
  (eval "$ac_cpp conftest.$ac_ext") 2>conftest.er1
 
23053
  ac_status=$?
 
23054
  grep -v '^ *+' conftest.er1 >conftest.err
 
23055
  rm -f conftest.er1
 
23056
  cat conftest.err >&5
 
23057
  echo "$as_me:$LINENO: \$? = $ac_status" >&5
 
23058
  (exit $ac_status); } >/dev/null; then
 
23059
  if test -s conftest.err; then
 
23060
    ac_cpp_err=$ac_c_preproc_warn_flag
 
23061
    ac_cpp_err=$ac_cpp_err$ac_c_werror_flag
 
23062
  else
 
23063
    ac_cpp_err=
 
23064
  fi
 
23065
else
 
23066
  ac_cpp_err=yes
 
23067
fi
 
23068
if test -z "$ac_cpp_err"; then
 
23069
  ac_header_preproc=yes
 
23070
else
 
23071
  echo "$as_me: failed program was:" >&5
 
23072
sed 's/^/| /' conftest.$ac_ext >&5
 
23073
 
 
23074
  ac_header_preproc=no
 
23075
fi
 
23076
 
 
23077
rm -f conftest.err conftest.$ac_ext
 
23078
{ echo "$as_me:$LINENO: result: $ac_header_preproc" >&5
 
23079
echo "${ECHO_T}$ac_header_preproc" >&6; }
 
23080
 
 
23081
# So?  What about this header?
 
23082
case $ac_header_compiler:$ac_header_preproc:$ac_c_preproc_warn_flag in
 
23083
  yes:no: )
 
23084
    { echo "$as_me:$LINENO: WARNING: $ac_header: accepted by the compiler, rejected by the preprocessor!" >&5
 
23085
echo "$as_me: WARNING: $ac_header: accepted by the compiler, rejected by the preprocessor!" >&2;}
 
23086
    { echo "$as_me:$LINENO: WARNING: $ac_header: proceeding with the compiler's result" >&5
 
23087
echo "$as_me: WARNING: $ac_header: proceeding with the compiler's result" >&2;}
 
23088
    ac_header_preproc=yes
 
23089
    ;;
 
23090
  no:yes:* )
 
23091
    { echo "$as_me:$LINENO: WARNING: $ac_header: present but cannot be compiled" >&5
 
23092
echo "$as_me: WARNING: $ac_header: present but cannot be compiled" >&2;}
 
23093
    { echo "$as_me:$LINENO: WARNING: $ac_header:     check for missing prerequisite headers?" >&5
 
23094
echo "$as_me: WARNING: $ac_header:     check for missing prerequisite headers?" >&2;}
 
23095
    { echo "$as_me:$LINENO: WARNING: $ac_header: see the Autoconf documentation" >&5
 
23096
echo "$as_me: WARNING: $ac_header: see the Autoconf documentation" >&2;}
 
23097
    { echo "$as_me:$LINENO: WARNING: $ac_header:     section \"Present But Cannot Be Compiled\"" >&5
 
23098
echo "$as_me: WARNING: $ac_header:     section \"Present But Cannot Be Compiled\"" >&2;}
 
23099
    { echo "$as_me:$LINENO: WARNING: $ac_header: proceeding with the preprocessor's result" >&5
 
23100
echo "$as_me: WARNING: $ac_header: proceeding with the preprocessor's result" >&2;}
 
23101
    { echo "$as_me:$LINENO: WARNING: $ac_header: in the future, the compiler will take precedence" >&5
 
23102
echo "$as_me: WARNING: $ac_header: in the future, the compiler will take precedence" >&2;}
 
23103
    ( cat <<\_ASBOX
 
23104
## ---------------------------------------- ##
 
23105
## Report this to pgsql-odbc@postgresql.org ##
 
23106
## ---------------------------------------- ##
 
23107
_ASBOX
 
23108
     ) | sed "s/^/$as_me: WARNING:     /" >&2
 
23109
    ;;
 
23110
esac
 
23111
{ echo "$as_me:$LINENO: checking for $ac_header" >&5
 
23112
echo $ECHO_N "checking for $ac_header... $ECHO_C" >&6; }
 
23113
if { as_var=$as_ac_Header; eval "test \"\${$as_var+set}\" = set"; }; then
 
23114
  echo $ECHO_N "(cached) $ECHO_C" >&6
 
23115
else
 
23116
  eval "$as_ac_Header=\$ac_header_preproc"
 
23117
fi
 
23118
ac_res=`eval echo '${'$as_ac_Header'}'`
 
23119
               { echo "$as_me:$LINENO: result: $ac_res" >&5
 
23120
echo "${ECHO_T}$ac_res" >&6; }
 
23121
 
 
23122
fi
 
23123
if test `eval echo '${'$as_ac_Header'}'` = yes; then
 
23124
  cat >>confdefs.h <<_ACEOF
 
23125
#define `echo "HAVE_$ac_header" | $as_tr_cpp` 1
 
23126
_ACEOF
 
23127
 
 
23128
else
 
23129
 
 
23130
for ac_header in gssapi.h
 
23131
do
 
23132
as_ac_Header=`echo "ac_cv_header_$ac_header" | $as_tr_sh`
 
23133
if { as_var=$as_ac_Header; eval "test \"\${$as_var+set}\" = set"; }; then
 
23134
  { echo "$as_me:$LINENO: checking for $ac_header" >&5
 
23135
echo $ECHO_N "checking for $ac_header... $ECHO_C" >&6; }
 
23136
if { as_var=$as_ac_Header; eval "test \"\${$as_var+set}\" = set"; }; then
 
23137
  echo $ECHO_N "(cached) $ECHO_C" >&6
 
23138
fi
 
23139
ac_res=`eval echo '${'$as_ac_Header'}'`
 
23140
               { echo "$as_me:$LINENO: result: $ac_res" >&5
 
23141
echo "${ECHO_T}$ac_res" >&6; }
 
23142
else
 
23143
  # Is the header compilable?
 
23144
{ echo "$as_me:$LINENO: checking $ac_header usability" >&5
 
23145
echo $ECHO_N "checking $ac_header usability... $ECHO_C" >&6; }
 
23146
cat >conftest.$ac_ext <<_ACEOF
 
23147
/* confdefs.h.  */
 
23148
_ACEOF
 
23149
cat confdefs.h >>conftest.$ac_ext
 
23150
cat >>conftest.$ac_ext <<_ACEOF
 
23151
/* end confdefs.h.  */
 
23152
$ac_includes_default
 
23153
#include <$ac_header>
 
23154
_ACEOF
 
23155
rm -f conftest.$ac_objext
 
23156
if { (ac_try="$ac_compile"
 
23157
case "(($ac_try" in
 
23158
  *\"* | *\`* | *\\*) ac_try_echo=\$ac_try;;
 
23159
  *) ac_try_echo=$ac_try;;
 
23160
esac
 
23161
eval "echo \"\$as_me:$LINENO: $ac_try_echo\"") >&5
 
23162
  (eval "$ac_compile") 2>conftest.er1
 
23163
  ac_status=$?
 
23164
  grep -v '^ *+' conftest.er1 >conftest.err
 
23165
  rm -f conftest.er1
 
23166
  cat conftest.err >&5
 
23167
  echo "$as_me:$LINENO: \$? = $ac_status" >&5
 
23168
  (exit $ac_status); } &&
 
23169
         { ac_try='test -z "$ac_c_werror_flag" || test ! -s conftest.err'
 
23170
  { (case "(($ac_try" in
 
23171
  *\"* | *\`* | *\\*) ac_try_echo=\$ac_try;;
 
23172
  *) ac_try_echo=$ac_try;;
 
23173
esac
 
23174
eval "echo \"\$as_me:$LINENO: $ac_try_echo\"") >&5
 
23175
  (eval "$ac_try") 2>&5
 
23176
  ac_status=$?
 
23177
  echo "$as_me:$LINENO: \$? = $ac_status" >&5
 
23178
  (exit $ac_status); }; } &&
 
23179
         { ac_try='test -s conftest.$ac_objext'
 
23180
  { (case "(($ac_try" in
 
23181
  *\"* | *\`* | *\\*) ac_try_echo=\$ac_try;;
 
23182
  *) ac_try_echo=$ac_try;;
 
23183
esac
 
23184
eval "echo \"\$as_me:$LINENO: $ac_try_echo\"") >&5
 
23185
  (eval "$ac_try") 2>&5
 
23186
  ac_status=$?
 
23187
  echo "$as_me:$LINENO: \$? = $ac_status" >&5
 
23188
  (exit $ac_status); }; }; then
 
23189
  ac_header_compiler=yes
 
23190
else
 
23191
  echo "$as_me: failed program was:" >&5
 
23192
sed 's/^/| /' conftest.$ac_ext >&5
 
23193
 
 
23194
        ac_header_compiler=no
 
23195
fi
 
23196
 
 
23197
rm -f core conftest.err conftest.$ac_objext conftest.$ac_ext
 
23198
{ echo "$as_me:$LINENO: result: $ac_header_compiler" >&5
 
23199
echo "${ECHO_T}$ac_header_compiler" >&6; }
 
23200
 
 
23201
# Is the header present?
 
23202
{ echo "$as_me:$LINENO: checking $ac_header presence" >&5
 
23203
echo $ECHO_N "checking $ac_header presence... $ECHO_C" >&6; }
 
23204
cat >conftest.$ac_ext <<_ACEOF
 
23205
/* confdefs.h.  */
 
23206
_ACEOF
 
23207
cat confdefs.h >>conftest.$ac_ext
 
23208
cat >>conftest.$ac_ext <<_ACEOF
 
23209
/* end confdefs.h.  */
 
23210
#include <$ac_header>
 
23211
_ACEOF
 
23212
if { (ac_try="$ac_cpp conftest.$ac_ext"
 
23213
case "(($ac_try" in
 
23214
  *\"* | *\`* | *\\*) ac_try_echo=\$ac_try;;
 
23215
  *) ac_try_echo=$ac_try;;
 
23216
esac
 
23217
eval "echo \"\$as_me:$LINENO: $ac_try_echo\"") >&5
 
23218
  (eval "$ac_cpp conftest.$ac_ext") 2>conftest.er1
 
23219
  ac_status=$?
 
23220
  grep -v '^ *+' conftest.er1 >conftest.err
 
23221
  rm -f conftest.er1
 
23222
  cat conftest.err >&5
 
23223
  echo "$as_me:$LINENO: \$? = $ac_status" >&5
 
23224
  (exit $ac_status); } >/dev/null; then
 
23225
  if test -s conftest.err; then
 
23226
    ac_cpp_err=$ac_c_preproc_warn_flag
 
23227
    ac_cpp_err=$ac_cpp_err$ac_c_werror_flag
 
23228
  else
 
23229
    ac_cpp_err=
 
23230
  fi
 
23231
else
 
23232
  ac_cpp_err=yes
 
23233
fi
 
23234
if test -z "$ac_cpp_err"; then
 
23235
  ac_header_preproc=yes
 
23236
else
 
23237
  echo "$as_me: failed program was:" >&5
 
23238
sed 's/^/| /' conftest.$ac_ext >&5
 
23239
 
 
23240
  ac_header_preproc=no
 
23241
fi
 
23242
 
 
23243
rm -f conftest.err conftest.$ac_ext
 
23244
{ echo "$as_me:$LINENO: result: $ac_header_preproc" >&5
 
23245
echo "${ECHO_T}$ac_header_preproc" >&6; }
 
23246
 
 
23247
# So?  What about this header?
 
23248
case $ac_header_compiler:$ac_header_preproc:$ac_c_preproc_warn_flag in
 
23249
  yes:no: )
 
23250
    { echo "$as_me:$LINENO: WARNING: $ac_header: accepted by the compiler, rejected by the preprocessor!" >&5
 
23251
echo "$as_me: WARNING: $ac_header: accepted by the compiler, rejected by the preprocessor!" >&2;}
 
23252
    { echo "$as_me:$LINENO: WARNING: $ac_header: proceeding with the compiler's result" >&5
 
23253
echo "$as_me: WARNING: $ac_header: proceeding with the compiler's result" >&2;}
 
23254
    ac_header_preproc=yes
 
23255
    ;;
 
23256
  no:yes:* )
 
23257
    { echo "$as_me:$LINENO: WARNING: $ac_header: present but cannot be compiled" >&5
 
23258
echo "$as_me: WARNING: $ac_header: present but cannot be compiled" >&2;}
 
23259
    { echo "$as_me:$LINENO: WARNING: $ac_header:     check for missing prerequisite headers?" >&5
 
23260
echo "$as_me: WARNING: $ac_header:     check for missing prerequisite headers?" >&2;}
 
23261
    { echo "$as_me:$LINENO: WARNING: $ac_header: see the Autoconf documentation" >&5
 
23262
echo "$as_me: WARNING: $ac_header: see the Autoconf documentation" >&2;}
 
23263
    { echo "$as_me:$LINENO: WARNING: $ac_header:     section \"Present But Cannot Be Compiled\"" >&5
 
23264
echo "$as_me: WARNING: $ac_header:     section \"Present But Cannot Be Compiled\"" >&2;}
 
23265
    { echo "$as_me:$LINENO: WARNING: $ac_header: proceeding with the preprocessor's result" >&5
 
23266
echo "$as_me: WARNING: $ac_header: proceeding with the preprocessor's result" >&2;}
 
23267
    { echo "$as_me:$LINENO: WARNING: $ac_header: in the future, the compiler will take precedence" >&5
 
23268
echo "$as_me: WARNING: $ac_header: in the future, the compiler will take precedence" >&2;}
 
23269
    ( cat <<\_ASBOX
 
23270
## ---------------------------------------- ##
 
23271
## Report this to pgsql-odbc@postgresql.org ##
 
23272
## ---------------------------------------- ##
 
23273
_ASBOX
 
23274
     ) | sed "s/^/$as_me: WARNING:     /" >&2
 
23275
    ;;
 
23276
esac
 
23277
{ echo "$as_me:$LINENO: checking for $ac_header" >&5
 
23278
echo $ECHO_N "checking for $ac_header... $ECHO_C" >&6; }
 
23279
if { as_var=$as_ac_Header; eval "test \"\${$as_var+set}\" = set"; }; then
 
23280
  echo $ECHO_N "(cached) $ECHO_C" >&6
 
23281
else
 
23282
  eval "$as_ac_Header=\$ac_header_preproc"
 
23283
fi
 
23284
ac_res=`eval echo '${'$as_ac_Header'}'`
 
23285
               { echo "$as_me:$LINENO: result: $ac_res" >&5
 
23286
echo "${ECHO_T}$ac_res" >&6; }
 
23287
 
 
23288
fi
 
23289
if test `eval echo '${'$as_ac_Header'}'` = yes; then
 
23290
  cat >>confdefs.h <<_ACEOF
 
23291
#define `echo "HAVE_$ac_header" | $as_tr_cpp` 1
 
23292
_ACEOF
 
23293
 
 
23294
else
 
23295
  { { echo "$as_me:$LINENO: error: gssapi header not found" >&5
 
23296
echo "$as_me: error: gssapi header not found" >&2;}
 
23297
   { (exit 1); exit 1; }; }
 
23298
fi
 
23299
 
 
23300
done
 
23301
 
 
23302
fi
 
23303
 
 
23304
done
 
23305
 
 
23306
fi
 
23307
if test "$enable_krb5" = yes; then
 
23308
  if test "${ac_cv_header_krb5_h+set}" = set; then
 
23309
  { echo "$as_me:$LINENO: checking for krb5.h" >&5
 
23310
echo $ECHO_N "checking for krb5.h... $ECHO_C" >&6; }
 
23311
if test "${ac_cv_header_krb5_h+set}" = set; then
 
23312
  echo $ECHO_N "(cached) $ECHO_C" >&6
 
23313
fi
 
23314
{ echo "$as_me:$LINENO: result: $ac_cv_header_krb5_h" >&5
 
23315
echo "${ECHO_T}$ac_cv_header_krb5_h" >&6; }
 
23316
else
 
23317
  # Is the header compilable?
 
23318
{ echo "$as_me:$LINENO: checking krb5.h usability" >&5
 
23319
echo $ECHO_N "checking krb5.h usability... $ECHO_C" >&6; }
 
23320
cat >conftest.$ac_ext <<_ACEOF
 
23321
/* confdefs.h.  */
 
23322
_ACEOF
 
23323
cat confdefs.h >>conftest.$ac_ext
 
23324
cat >>conftest.$ac_ext <<_ACEOF
 
23325
/* end confdefs.h.  */
 
23326
$ac_includes_default
 
23327
#include <krb5.h>
 
23328
_ACEOF
 
23329
rm -f conftest.$ac_objext
 
23330
if { (ac_try="$ac_compile"
 
23331
case "(($ac_try" in
 
23332
  *\"* | *\`* | *\\*) ac_try_echo=\$ac_try;;
 
23333
  *) ac_try_echo=$ac_try;;
 
23334
esac
 
23335
eval "echo \"\$as_me:$LINENO: $ac_try_echo\"") >&5
 
23336
  (eval "$ac_compile") 2>conftest.er1
 
23337
  ac_status=$?
 
23338
  grep -v '^ *+' conftest.er1 >conftest.err
 
23339
  rm -f conftest.er1
 
23340
  cat conftest.err >&5
 
23341
  echo "$as_me:$LINENO: \$? = $ac_status" >&5
 
23342
  (exit $ac_status); } &&
 
23343
         { ac_try='test -z "$ac_c_werror_flag" || test ! -s conftest.err'
 
23344
  { (case "(($ac_try" in
 
23345
  *\"* | *\`* | *\\*) ac_try_echo=\$ac_try;;
 
23346
  *) ac_try_echo=$ac_try;;
 
23347
esac
 
23348
eval "echo \"\$as_me:$LINENO: $ac_try_echo\"") >&5
 
23349
  (eval "$ac_try") 2>&5
 
23350
  ac_status=$?
 
23351
  echo "$as_me:$LINENO: \$? = $ac_status" >&5
 
23352
  (exit $ac_status); }; } &&
 
23353
         { ac_try='test -s conftest.$ac_objext'
 
23354
  { (case "(($ac_try" in
 
23355
  *\"* | *\`* | *\\*) ac_try_echo=\$ac_try;;
 
23356
  *) ac_try_echo=$ac_try;;
 
23357
esac
 
23358
eval "echo \"\$as_me:$LINENO: $ac_try_echo\"") >&5
 
23359
  (eval "$ac_try") 2>&5
 
23360
  ac_status=$?
 
23361
  echo "$as_me:$LINENO: \$? = $ac_status" >&5
 
23362
  (exit $ac_status); }; }; then
 
23363
  ac_header_compiler=yes
 
23364
else
 
23365
  echo "$as_me: failed program was:" >&5
 
23366
sed 's/^/| /' conftest.$ac_ext >&5
 
23367
 
 
23368
        ac_header_compiler=no
 
23369
fi
 
23370
 
 
23371
rm -f core conftest.err conftest.$ac_objext conftest.$ac_ext
 
23372
{ echo "$as_me:$LINENO: result: $ac_header_compiler" >&5
 
23373
echo "${ECHO_T}$ac_header_compiler" >&6; }
 
23374
 
 
23375
# Is the header present?
 
23376
{ echo "$as_me:$LINENO: checking krb5.h presence" >&5
 
23377
echo $ECHO_N "checking krb5.h presence... $ECHO_C" >&6; }
 
23378
cat >conftest.$ac_ext <<_ACEOF
 
23379
/* confdefs.h.  */
 
23380
_ACEOF
 
23381
cat confdefs.h >>conftest.$ac_ext
 
23382
cat >>conftest.$ac_ext <<_ACEOF
 
23383
/* end confdefs.h.  */
 
23384
#include <krb5.h>
 
23385
_ACEOF
 
23386
if { (ac_try="$ac_cpp conftest.$ac_ext"
 
23387
case "(($ac_try" in
 
23388
  *\"* | *\`* | *\\*) ac_try_echo=\$ac_try;;
 
23389
  *) ac_try_echo=$ac_try;;
 
23390
esac
 
23391
eval "echo \"\$as_me:$LINENO: $ac_try_echo\"") >&5
 
23392
  (eval "$ac_cpp conftest.$ac_ext") 2>conftest.er1
 
23393
  ac_status=$?
 
23394
  grep -v '^ *+' conftest.er1 >conftest.err
 
23395
  rm -f conftest.er1
 
23396
  cat conftest.err >&5
 
23397
  echo "$as_me:$LINENO: \$? = $ac_status" >&5
 
23398
  (exit $ac_status); } >/dev/null; then
 
23399
  if test -s conftest.err; then
 
23400
    ac_cpp_err=$ac_c_preproc_warn_flag
 
23401
    ac_cpp_err=$ac_cpp_err$ac_c_werror_flag
 
23402
  else
 
23403
    ac_cpp_err=
 
23404
  fi
 
23405
else
 
23406
  ac_cpp_err=yes
 
23407
fi
 
23408
if test -z "$ac_cpp_err"; then
 
23409
  ac_header_preproc=yes
 
23410
else
 
23411
  echo "$as_me: failed program was:" >&5
 
23412
sed 's/^/| /' conftest.$ac_ext >&5
 
23413
 
 
23414
  ac_header_preproc=no
 
23415
fi
 
23416
 
 
23417
rm -f conftest.err conftest.$ac_ext
 
23418
{ echo "$as_me:$LINENO: result: $ac_header_preproc" >&5
 
23419
echo "${ECHO_T}$ac_header_preproc" >&6; }
 
23420
 
 
23421
# So?  What about this header?
 
23422
case $ac_header_compiler:$ac_header_preproc:$ac_c_preproc_warn_flag in
 
23423
  yes:no: )
 
23424
    { echo "$as_me:$LINENO: WARNING: krb5.h: accepted by the compiler, rejected by the preprocessor!" >&5
 
23425
echo "$as_me: WARNING: krb5.h: accepted by the compiler, rejected by the preprocessor!" >&2;}
 
23426
    { echo "$as_me:$LINENO: WARNING: krb5.h: proceeding with the compiler's result" >&5
 
23427
echo "$as_me: WARNING: krb5.h: proceeding with the compiler's result" >&2;}
 
23428
    ac_header_preproc=yes
 
23429
    ;;
 
23430
  no:yes:* )
 
23431
    { echo "$as_me:$LINENO: WARNING: krb5.h: present but cannot be compiled" >&5
 
23432
echo "$as_me: WARNING: krb5.h: present but cannot be compiled" >&2;}
 
23433
    { echo "$as_me:$LINENO: WARNING: krb5.h:     check for missing prerequisite headers?" >&5
 
23434
echo "$as_me: WARNING: krb5.h:     check for missing prerequisite headers?" >&2;}
 
23435
    { echo "$as_me:$LINENO: WARNING: krb5.h: see the Autoconf documentation" >&5
 
23436
echo "$as_me: WARNING: krb5.h: see the Autoconf documentation" >&2;}
 
23437
    { echo "$as_me:$LINENO: WARNING: krb5.h:     section \"Present But Cannot Be Compiled\"" >&5
 
23438
echo "$as_me: WARNING: krb5.h:     section \"Present But Cannot Be Compiled\"" >&2;}
 
23439
    { echo "$as_me:$LINENO: WARNING: krb5.h: proceeding with the preprocessor's result" >&5
 
23440
echo "$as_me: WARNING: krb5.h: proceeding with the preprocessor's result" >&2;}
 
23441
    { echo "$as_me:$LINENO: WARNING: krb5.h: in the future, the compiler will take precedence" >&5
 
23442
echo "$as_me: WARNING: krb5.h: in the future, the compiler will take precedence" >&2;}
 
23443
    ( cat <<\_ASBOX
 
23444
## ---------------------------------------- ##
 
23445
## Report this to pgsql-odbc@postgresql.org ##
 
23446
## ---------------------------------------- ##
 
23447
_ASBOX
 
23448
     ) | sed "s/^/$as_me: WARNING:     /" >&2
 
23449
    ;;
 
23450
esac
 
23451
{ echo "$as_me:$LINENO: checking for krb5.h" >&5
 
23452
echo $ECHO_N "checking for krb5.h... $ECHO_C" >&6; }
 
23453
if test "${ac_cv_header_krb5_h+set}" = set; then
 
23454
  echo $ECHO_N "(cached) $ECHO_C" >&6
 
23455
else
 
23456
  ac_cv_header_krb5_h=$ac_header_preproc
 
23457
fi
 
23458
{ echo "$as_me:$LINENO: result: $ac_cv_header_krb5_h" >&5
 
23459
echo "${ECHO_T}$ac_cv_header_krb5_h" >&6; }
 
23460
 
 
23461
fi
 
23462
if test $ac_cv_header_krb5_h = yes; then
 
23463
  :
 
23464
else
 
23465
  { { echo "$as_me:$LINENO: error: krb5 header not found" >&5
 
23466
echo "$as_me: error: krb5 header not found" >&2;}
 
23467
   { (exit 1); exit 1; }; }
 
23468
fi
 
23469
 
 
23470
 
 
23471
fi
21043
23472
{ echo "$as_me:$LINENO: checking whether time.h and sys/time.h may both be included" >&5
21044
23473
echo $ECHO_N "checking whether time.h and sys/time.h may both be included... $ECHO_C" >&6; }
21045
23474
if test "${ac_cv_header_time+set}" = set; then
22202
24631
 
22203
24632
fi
22204
24633
 
 
24634
{ echo "$as_me:$LINENO: checking for signed char" >&5
 
24635
echo $ECHO_N "checking for signed char... $ECHO_C" >&6; }
 
24636
if test "${ac_cv_type_signed_char+set}" = set; then
 
24637
  echo $ECHO_N "(cached) $ECHO_C" >&6
 
24638
else
 
24639
  cat >conftest.$ac_ext <<_ACEOF
 
24640
/* confdefs.h.  */
 
24641
_ACEOF
 
24642
cat confdefs.h >>conftest.$ac_ext
 
24643
cat >>conftest.$ac_ext <<_ACEOF
 
24644
/* end confdefs.h.  */
 
24645
$ac_includes_default
 
24646
typedef signed char ac__type_new_;
 
24647
int
 
24648
main ()
 
24649
{
 
24650
if ((ac__type_new_ *) 0)
 
24651
  return 0;
 
24652
if (sizeof (ac__type_new_))
 
24653
  return 0;
 
24654
  ;
 
24655
  return 0;
 
24656
}
 
24657
_ACEOF
 
24658
rm -f conftest.$ac_objext
 
24659
if { (ac_try="$ac_compile"
 
24660
case "(($ac_try" in
 
24661
  *\"* | *\`* | *\\*) ac_try_echo=\$ac_try;;
 
24662
  *) ac_try_echo=$ac_try;;
 
24663
esac
 
24664
eval "echo \"\$as_me:$LINENO: $ac_try_echo\"") >&5
 
24665
  (eval "$ac_compile") 2>conftest.er1
 
24666
  ac_status=$?
 
24667
  grep -v '^ *+' conftest.er1 >conftest.err
 
24668
  rm -f conftest.er1
 
24669
  cat conftest.err >&5
 
24670
  echo "$as_me:$LINENO: \$? = $ac_status" >&5
 
24671
  (exit $ac_status); } &&
 
24672
         { ac_try='test -z "$ac_c_werror_flag" || test ! -s conftest.err'
 
24673
  { (case "(($ac_try" in
 
24674
  *\"* | *\`* | *\\*) ac_try_echo=\$ac_try;;
 
24675
  *) ac_try_echo=$ac_try;;
 
24676
esac
 
24677
eval "echo \"\$as_me:$LINENO: $ac_try_echo\"") >&5
 
24678
  (eval "$ac_try") 2>&5
 
24679
  ac_status=$?
 
24680
  echo "$as_me:$LINENO: \$? = $ac_status" >&5
 
24681
  (exit $ac_status); }; } &&
 
24682
         { ac_try='test -s conftest.$ac_objext'
 
24683
  { (case "(($ac_try" in
 
24684
  *\"* | *\`* | *\\*) ac_try_echo=\$ac_try;;
 
24685
  *) ac_try_echo=$ac_try;;
 
24686
esac
 
24687
eval "echo \"\$as_me:$LINENO: $ac_try_echo\"") >&5
 
24688
  (eval "$ac_try") 2>&5
 
24689
  ac_status=$?
 
24690
  echo "$as_me:$LINENO: \$? = $ac_status" >&5
 
24691
  (exit $ac_status); }; }; then
 
24692
  ac_cv_type_signed_char=yes
 
24693
else
 
24694
  echo "$as_me: failed program was:" >&5
 
24695
sed 's/^/| /' conftest.$ac_ext >&5
 
24696
 
 
24697
        ac_cv_type_signed_char=no
 
24698
fi
 
24699
 
 
24700
rm -f core conftest.err conftest.$ac_objext conftest.$ac_ext
 
24701
fi
 
24702
{ echo "$as_me:$LINENO: result: $ac_cv_type_signed_char" >&5
 
24703
echo "${ECHO_T}$ac_cv_type_signed_char" >&6; }
 
24704
if test $ac_cv_type_signed_char = yes; then
 
24705
 
 
24706
cat >>confdefs.h <<_ACEOF
 
24707
#define HAVE_SIGNED_CHAR 1
 
24708
_ACEOF
 
24709
 
 
24710
 
 
24711
fi
 
24712
 
22205
24713
 
22206
24714
{ echo "$as_me:$LINENO: checking for ssize_t" >&5
22207
24715
echo $ECHO_N "checking for ssize_t... $ECHO_C" >&6; }
22363
24871
fi
22364
24872
 
22365
24873
 
22366
 
 
22367
24874
# 5. Structures
22368
24875
 
22369
24876
{ echo "$as_me:$LINENO: checking whether struct tm is in sys/time.h or time.h" >&5
22656
25163
 
22657
25164
# 7. Functions, global variables
22658
25165
 
 
25166
{ echo "$as_me:$LINENO: checking whether strerror_r is declared" >&5
 
25167
echo $ECHO_N "checking whether strerror_r is declared... $ECHO_C" >&6; }
 
25168
if test "${ac_cv_have_decl_strerror_r+set}" = set; then
 
25169
  echo $ECHO_N "(cached) $ECHO_C" >&6
 
25170
else
 
25171
  cat >conftest.$ac_ext <<_ACEOF
 
25172
/* confdefs.h.  */
 
25173
_ACEOF
 
25174
cat confdefs.h >>conftest.$ac_ext
 
25175
cat >>conftest.$ac_ext <<_ACEOF
 
25176
/* end confdefs.h.  */
 
25177
$ac_includes_default
 
25178
int
 
25179
main ()
 
25180
{
 
25181
#ifndef strerror_r
 
25182
  char *p = (char *) strerror_r;
 
25183
  return !p;
 
25184
#endif
 
25185
 
 
25186
  ;
 
25187
  return 0;
 
25188
}
 
25189
_ACEOF
 
25190
rm -f conftest.$ac_objext
 
25191
if { (ac_try="$ac_compile"
 
25192
case "(($ac_try" in
 
25193
  *\"* | *\`* | *\\*) ac_try_echo=\$ac_try;;
 
25194
  *) ac_try_echo=$ac_try;;
 
25195
esac
 
25196
eval "echo \"\$as_me:$LINENO: $ac_try_echo\"") >&5
 
25197
  (eval "$ac_compile") 2>conftest.er1
 
25198
  ac_status=$?
 
25199
  grep -v '^ *+' conftest.er1 >conftest.err
 
25200
  rm -f conftest.er1
 
25201
  cat conftest.err >&5
 
25202
  echo "$as_me:$LINENO: \$? = $ac_status" >&5
 
25203
  (exit $ac_status); } &&
 
25204
         { ac_try='test -z "$ac_c_werror_flag" || test ! -s conftest.err'
 
25205
  { (case "(($ac_try" in
 
25206
  *\"* | *\`* | *\\*) ac_try_echo=\$ac_try;;
 
25207
  *) ac_try_echo=$ac_try;;
 
25208
esac
 
25209
eval "echo \"\$as_me:$LINENO: $ac_try_echo\"") >&5
 
25210
  (eval "$ac_try") 2>&5
 
25211
  ac_status=$?
 
25212
  echo "$as_me:$LINENO: \$? = $ac_status" >&5
 
25213
  (exit $ac_status); }; } &&
 
25214
         { ac_try='test -s conftest.$ac_objext'
 
25215
  { (case "(($ac_try" in
 
25216
  *\"* | *\`* | *\\*) ac_try_echo=\$ac_try;;
 
25217
  *) ac_try_echo=$ac_try;;
 
25218
esac
 
25219
eval "echo \"\$as_me:$LINENO: $ac_try_echo\"") >&5
 
25220
  (eval "$ac_try") 2>&5
 
25221
  ac_status=$?
 
25222
  echo "$as_me:$LINENO: \$? = $ac_status" >&5
 
25223
  (exit $ac_status); }; }; then
 
25224
  ac_cv_have_decl_strerror_r=yes
 
25225
else
 
25226
  echo "$as_me: failed program was:" >&5
 
25227
sed 's/^/| /' conftest.$ac_ext >&5
 
25228
 
 
25229
        ac_cv_have_decl_strerror_r=no
 
25230
fi
 
25231
 
 
25232
rm -f core conftest.err conftest.$ac_objext conftest.$ac_ext
 
25233
fi
 
25234
{ echo "$as_me:$LINENO: result: $ac_cv_have_decl_strerror_r" >&5
 
25235
echo "${ECHO_T}$ac_cv_have_decl_strerror_r" >&6; }
 
25236
if test $ac_cv_have_decl_strerror_r = yes; then
 
25237
 
 
25238
cat >>confdefs.h <<_ACEOF
 
25239
#define HAVE_DECL_STRERROR_R 1
 
25240
_ACEOF
 
25241
 
 
25242
 
 
25243
else
 
25244
  cat >>confdefs.h <<_ACEOF
 
25245
#define HAVE_DECL_STRERROR_R 0
 
25246
_ACEOF
 
25247
 
 
25248
 
 
25249
fi
 
25250
 
 
25251
 
22659
25252
 
22660
25253
for ac_func in strerror_r
22661
25254
do
22766
25359
fi
22767
25360
done
22768
25361
 
22769
 
 
22770
 
 
22771
 
for ac_func in strtoul strtoll
 
25362
{ echo "$as_me:$LINENO: checking whether strerror_r returns char *" >&5
 
25363
echo $ECHO_N "checking whether strerror_r returns char *... $ECHO_C" >&6; }
 
25364
if test "${ac_cv_func_strerror_r_char_p+set}" = set; then
 
25365
  echo $ECHO_N "(cached) $ECHO_C" >&6
 
25366
else
 
25367
 
 
25368
    ac_cv_func_strerror_r_char_p=no
 
25369
    if test $ac_cv_have_decl_strerror_r = yes; then
 
25370
      cat >conftest.$ac_ext <<_ACEOF
 
25371
/* confdefs.h.  */
 
25372
_ACEOF
 
25373
cat confdefs.h >>conftest.$ac_ext
 
25374
cat >>conftest.$ac_ext <<_ACEOF
 
25375
/* end confdefs.h.  */
 
25376
$ac_includes_default
 
25377
int
 
25378
main ()
 
25379
{
 
25380
 
 
25381
          char buf[100];
 
25382
          char x = *strerror_r (0, buf, sizeof buf);
 
25383
          char *p = strerror_r (0, buf, sizeof buf);
 
25384
          return !p || x;
 
25385
 
 
25386
  ;
 
25387
  return 0;
 
25388
}
 
25389
_ACEOF
 
25390
rm -f conftest.$ac_objext
 
25391
if { (ac_try="$ac_compile"
 
25392
case "(($ac_try" in
 
25393
  *\"* | *\`* | *\\*) ac_try_echo=\$ac_try;;
 
25394
  *) ac_try_echo=$ac_try;;
 
25395
esac
 
25396
eval "echo \"\$as_me:$LINENO: $ac_try_echo\"") >&5
 
25397
  (eval "$ac_compile") 2>conftest.er1
 
25398
  ac_status=$?
 
25399
  grep -v '^ *+' conftest.er1 >conftest.err
 
25400
  rm -f conftest.er1
 
25401
  cat conftest.err >&5
 
25402
  echo "$as_me:$LINENO: \$? = $ac_status" >&5
 
25403
  (exit $ac_status); } &&
 
25404
         { ac_try='test -z "$ac_c_werror_flag" || test ! -s conftest.err'
 
25405
  { (case "(($ac_try" in
 
25406
  *\"* | *\`* | *\\*) ac_try_echo=\$ac_try;;
 
25407
  *) ac_try_echo=$ac_try;;
 
25408
esac
 
25409
eval "echo \"\$as_me:$LINENO: $ac_try_echo\"") >&5
 
25410
  (eval "$ac_try") 2>&5
 
25411
  ac_status=$?
 
25412
  echo "$as_me:$LINENO: \$? = $ac_status" >&5
 
25413
  (exit $ac_status); }; } &&
 
25414
         { ac_try='test -s conftest.$ac_objext'
 
25415
  { (case "(($ac_try" in
 
25416
  *\"* | *\`* | *\\*) ac_try_echo=\$ac_try;;
 
25417
  *) ac_try_echo=$ac_try;;
 
25418
esac
 
25419
eval "echo \"\$as_me:$LINENO: $ac_try_echo\"") >&5
 
25420
  (eval "$ac_try") 2>&5
 
25421
  ac_status=$?
 
25422
  echo "$as_me:$LINENO: \$? = $ac_status" >&5
 
25423
  (exit $ac_status); }; }; then
 
25424
  ac_cv_func_strerror_r_char_p=yes
 
25425
else
 
25426
  echo "$as_me: failed program was:" >&5
 
25427
sed 's/^/| /' conftest.$ac_ext >&5
 
25428
 
 
25429
 
 
25430
fi
 
25431
 
 
25432
rm -f core conftest.err conftest.$ac_objext conftest.$ac_ext
 
25433
    else
 
25434
      # strerror_r is not declared.  Choose between
 
25435
      # systems that have relatively inaccessible declarations for the
 
25436
      # function.  BeOS and DEC UNIX 4.0 fall in this category, but the
 
25437
      # former has a strerror_r that returns char*, while the latter
 
25438
      # has a strerror_r that returns `int'.
 
25439
      # This test should segfault on the DEC system.
 
25440
      if test "$cross_compiling" = yes; then
 
25441
  :
 
25442
else
 
25443
  cat >conftest.$ac_ext <<_ACEOF
 
25444
/* confdefs.h.  */
 
25445
_ACEOF
 
25446
cat confdefs.h >>conftest.$ac_ext
 
25447
cat >>conftest.$ac_ext <<_ACEOF
 
25448
/* end confdefs.h.  */
 
25449
$ac_includes_default
 
25450
        extern char *strerror_r ();
 
25451
int
 
25452
main ()
 
25453
{
 
25454
char buf[100];
 
25455
          char x = *strerror_r (0, buf, sizeof buf);
 
25456
          return ! isalpha (x);
 
25457
  ;
 
25458
  return 0;
 
25459
}
 
25460
_ACEOF
 
25461
rm -f conftest$ac_exeext
 
25462
if { (ac_try="$ac_link"
 
25463
case "(($ac_try" in
 
25464
  *\"* | *\`* | *\\*) ac_try_echo=\$ac_try;;
 
25465
  *) ac_try_echo=$ac_try;;
 
25466
esac
 
25467
eval "echo \"\$as_me:$LINENO: $ac_try_echo\"") >&5
 
25468
  (eval "$ac_link") 2>&5
 
25469
  ac_status=$?
 
25470
  echo "$as_me:$LINENO: \$? = $ac_status" >&5
 
25471
  (exit $ac_status); } && { ac_try='./conftest$ac_exeext'
 
25472
  { (case "(($ac_try" in
 
25473
  *\"* | *\`* | *\\*) ac_try_echo=\$ac_try;;
 
25474
  *) ac_try_echo=$ac_try;;
 
25475
esac
 
25476
eval "echo \"\$as_me:$LINENO: $ac_try_echo\"") >&5
 
25477
  (eval "$ac_try") 2>&5
 
25478
  ac_status=$?
 
25479
  echo "$as_me:$LINENO: \$? = $ac_status" >&5
 
25480
  (exit $ac_status); }; }; then
 
25481
  ac_cv_func_strerror_r_char_p=yes
 
25482
else
 
25483
  echo "$as_me: program exited with status $ac_status" >&5
 
25484
echo "$as_me: failed program was:" >&5
 
25485
sed 's/^/| /' conftest.$ac_ext >&5
 
25486
 
 
25487
fi
 
25488
rm -f core *.core core.conftest.* gmon.out bb.out conftest$ac_exeext conftest.$ac_objext conftest.$ac_ext
 
25489
fi
 
25490
 
 
25491
 
 
25492
    fi
 
25493
 
 
25494
fi
 
25495
{ echo "$as_me:$LINENO: result: $ac_cv_func_strerror_r_char_p" >&5
 
25496
echo "${ECHO_T}$ac_cv_func_strerror_r_char_p" >&6; }
 
25497
if test $ac_cv_func_strerror_r_char_p = yes; then
 
25498
 
 
25499
cat >>confdefs.h <<\_ACEOF
 
25500
#define STRERROR_R_CHAR_P 1
 
25501
_ACEOF
 
25502
 
 
25503
fi
 
25504
 
 
25505
 
 
25506
 
 
25507
 
 
25508
 
 
25509
 
 
25510
for ac_func in strtoul strtoll strlcat strlcpy poll
22772
25511
do
22773
25512
as_ac_var=`echo "ac_cv_func_$ac_func" | $as_tr_sh`
22774
25513
{ echo "$as_me:$LINENO: checking for $ac_func" >&5
23231
25970
rm -f core conftest.err conftest.$ac_objext conftest.$ac_ext
23232
25971
  fi
23233
25972
fi
 
25973
if test "$enable_krb5" = yes; then
 
25974
  { echo "$as_me:$LINENO: checking for krb5_error.text.data" >&5
 
25975
echo $ECHO_N "checking for krb5_error.text.data... $ECHO_C" >&6; }
 
25976
if test "${ac_cv_member_krb5_error_text_data+set}" = set; then
 
25977
  echo $ECHO_N "(cached) $ECHO_C" >&6
 
25978
else
 
25979
  cat >conftest.$ac_ext <<_ACEOF
 
25980
/* confdefs.h.  */
 
25981
_ACEOF
 
25982
cat confdefs.h >>conftest.$ac_ext
 
25983
cat >>conftest.$ac_ext <<_ACEOF
 
25984
/* end confdefs.h.  */
 
25985
#include <krb5.h>
 
25986
 
 
25987
int
 
25988
main ()
 
25989
{
 
25990
static krb5_error ac_aggr;
 
25991
if (ac_aggr.text.data)
 
25992
return 0;
 
25993
  ;
 
25994
  return 0;
 
25995
}
 
25996
_ACEOF
 
25997
rm -f conftest.$ac_objext
 
25998
if { (ac_try="$ac_compile"
 
25999
case "(($ac_try" in
 
26000
  *\"* | *\`* | *\\*) ac_try_echo=\$ac_try;;
 
26001
  *) ac_try_echo=$ac_try;;
 
26002
esac
 
26003
eval "echo \"\$as_me:$LINENO: $ac_try_echo\"") >&5
 
26004
  (eval "$ac_compile") 2>conftest.er1
 
26005
  ac_status=$?
 
26006
  grep -v '^ *+' conftest.er1 >conftest.err
 
26007
  rm -f conftest.er1
 
26008
  cat conftest.err >&5
 
26009
  echo "$as_me:$LINENO: \$? = $ac_status" >&5
 
26010
  (exit $ac_status); } &&
 
26011
         { ac_try='test -z "$ac_c_werror_flag" || test ! -s conftest.err'
 
26012
  { (case "(($ac_try" in
 
26013
  *\"* | *\`* | *\\*) ac_try_echo=\$ac_try;;
 
26014
  *) ac_try_echo=$ac_try;;
 
26015
esac
 
26016
eval "echo \"\$as_me:$LINENO: $ac_try_echo\"") >&5
 
26017
  (eval "$ac_try") 2>&5
 
26018
  ac_status=$?
 
26019
  echo "$as_me:$LINENO: \$? = $ac_status" >&5
 
26020
  (exit $ac_status); }; } &&
 
26021
         { ac_try='test -s conftest.$ac_objext'
 
26022
  { (case "(($ac_try" in
 
26023
  *\"* | *\`* | *\\*) ac_try_echo=\$ac_try;;
 
26024
  *) ac_try_echo=$ac_try;;
 
26025
esac
 
26026
eval "echo \"\$as_me:$LINENO: $ac_try_echo\"") >&5
 
26027
  (eval "$ac_try") 2>&5
 
26028
  ac_status=$?
 
26029
  echo "$as_me:$LINENO: \$? = $ac_status" >&5
 
26030
  (exit $ac_status); }; }; then
 
26031
  ac_cv_member_krb5_error_text_data=yes
 
26032
else
 
26033
  echo "$as_me: failed program was:" >&5
 
26034
sed 's/^/| /' conftest.$ac_ext >&5
 
26035
 
 
26036
        cat >conftest.$ac_ext <<_ACEOF
 
26037
/* confdefs.h.  */
 
26038
_ACEOF
 
26039
cat confdefs.h >>conftest.$ac_ext
 
26040
cat >>conftest.$ac_ext <<_ACEOF
 
26041
/* end confdefs.h.  */
 
26042
#include <krb5.h>
 
26043
 
 
26044
int
 
26045
main ()
 
26046
{
 
26047
static krb5_error ac_aggr;
 
26048
if (sizeof ac_aggr.text.data)
 
26049
return 0;
 
26050
  ;
 
26051
  return 0;
 
26052
}
 
26053
_ACEOF
 
26054
rm -f conftest.$ac_objext
 
26055
if { (ac_try="$ac_compile"
 
26056
case "(($ac_try" in
 
26057
  *\"* | *\`* | *\\*) ac_try_echo=\$ac_try;;
 
26058
  *) ac_try_echo=$ac_try;;
 
26059
esac
 
26060
eval "echo \"\$as_me:$LINENO: $ac_try_echo\"") >&5
 
26061
  (eval "$ac_compile") 2>conftest.er1
 
26062
  ac_status=$?
 
26063
  grep -v '^ *+' conftest.er1 >conftest.err
 
26064
  rm -f conftest.er1
 
26065
  cat conftest.err >&5
 
26066
  echo "$as_me:$LINENO: \$? = $ac_status" >&5
 
26067
  (exit $ac_status); } &&
 
26068
         { ac_try='test -z "$ac_c_werror_flag" || test ! -s conftest.err'
 
26069
  { (case "(($ac_try" in
 
26070
  *\"* | *\`* | *\\*) ac_try_echo=\$ac_try;;
 
26071
  *) ac_try_echo=$ac_try;;
 
26072
esac
 
26073
eval "echo \"\$as_me:$LINENO: $ac_try_echo\"") >&5
 
26074
  (eval "$ac_try") 2>&5
 
26075
  ac_status=$?
 
26076
  echo "$as_me:$LINENO: \$? = $ac_status" >&5
 
26077
  (exit $ac_status); }; } &&
 
26078
         { ac_try='test -s conftest.$ac_objext'
 
26079
  { (case "(($ac_try" in
 
26080
  *\"* | *\`* | *\\*) ac_try_echo=\$ac_try;;
 
26081
  *) ac_try_echo=$ac_try;;
 
26082
esac
 
26083
eval "echo \"\$as_me:$LINENO: $ac_try_echo\"") >&5
 
26084
  (eval "$ac_try") 2>&5
 
26085
  ac_status=$?
 
26086
  echo "$as_me:$LINENO: \$? = $ac_status" >&5
 
26087
  (exit $ac_status); }; }; then
 
26088
  ac_cv_member_krb5_error_text_data=yes
 
26089
else
 
26090
  echo "$as_me: failed program was:" >&5
 
26091
sed 's/^/| /' conftest.$ac_ext >&5
 
26092
 
 
26093
        ac_cv_member_krb5_error_text_data=no
 
26094
fi
 
26095
 
 
26096
rm -f core conftest.err conftest.$ac_objext conftest.$ac_ext
 
26097
fi
 
26098
 
 
26099
rm -f core conftest.err conftest.$ac_objext conftest.$ac_ext
 
26100
fi
 
26101
{ echo "$as_me:$LINENO: result: $ac_cv_member_krb5_error_text_data" >&5
 
26102
echo "${ECHO_T}$ac_cv_member_krb5_error_text_data" >&6; }
 
26103
if test $ac_cv_member_krb5_error_text_data = yes; then
 
26104
 
 
26105
cat >>confdefs.h <<_ACEOF
 
26106
#define HAVE_KRB5_ERROR_TEXT_DATA 1
 
26107
_ACEOF
 
26108
 
 
26109
 
 
26110
else
 
26111
  { echo "$as_me:$LINENO: checking for krb5_error.e_data" >&5
 
26112
echo $ECHO_N "checking for krb5_error.e_data... $ECHO_C" >&6; }
 
26113
if test "${ac_cv_member_krb5_error_e_data+set}" = set; then
 
26114
  echo $ECHO_N "(cached) $ECHO_C" >&6
 
26115
else
 
26116
  cat >conftest.$ac_ext <<_ACEOF
 
26117
/* confdefs.h.  */
 
26118
_ACEOF
 
26119
cat confdefs.h >>conftest.$ac_ext
 
26120
cat >>conftest.$ac_ext <<_ACEOF
 
26121
/* end confdefs.h.  */
 
26122
#include <krb5.h>
 
26123
 
 
26124
int
 
26125
main ()
 
26126
{
 
26127
static krb5_error ac_aggr;
 
26128
if (ac_aggr.e_data)
 
26129
return 0;
 
26130
  ;
 
26131
  return 0;
 
26132
}
 
26133
_ACEOF
 
26134
rm -f conftest.$ac_objext
 
26135
if { (ac_try="$ac_compile"
 
26136
case "(($ac_try" in
 
26137
  *\"* | *\`* | *\\*) ac_try_echo=\$ac_try;;
 
26138
  *) ac_try_echo=$ac_try;;
 
26139
esac
 
26140
eval "echo \"\$as_me:$LINENO: $ac_try_echo\"") >&5
 
26141
  (eval "$ac_compile") 2>conftest.er1
 
26142
  ac_status=$?
 
26143
  grep -v '^ *+' conftest.er1 >conftest.err
 
26144
  rm -f conftest.er1
 
26145
  cat conftest.err >&5
 
26146
  echo "$as_me:$LINENO: \$? = $ac_status" >&5
 
26147
  (exit $ac_status); } &&
 
26148
         { ac_try='test -z "$ac_c_werror_flag" || test ! -s conftest.err'
 
26149
  { (case "(($ac_try" in
 
26150
  *\"* | *\`* | *\\*) ac_try_echo=\$ac_try;;
 
26151
  *) ac_try_echo=$ac_try;;
 
26152
esac
 
26153
eval "echo \"\$as_me:$LINENO: $ac_try_echo\"") >&5
 
26154
  (eval "$ac_try") 2>&5
 
26155
  ac_status=$?
 
26156
  echo "$as_me:$LINENO: \$? = $ac_status" >&5
 
26157
  (exit $ac_status); }; } &&
 
26158
         { ac_try='test -s conftest.$ac_objext'
 
26159
  { (case "(($ac_try" in
 
26160
  *\"* | *\`* | *\\*) ac_try_echo=\$ac_try;;
 
26161
  *) ac_try_echo=$ac_try;;
 
26162
esac
 
26163
eval "echo \"\$as_me:$LINENO: $ac_try_echo\"") >&5
 
26164
  (eval "$ac_try") 2>&5
 
26165
  ac_status=$?
 
26166
  echo "$as_me:$LINENO: \$? = $ac_status" >&5
 
26167
  (exit $ac_status); }; }; then
 
26168
  ac_cv_member_krb5_error_e_data=yes
 
26169
else
 
26170
  echo "$as_me: failed program was:" >&5
 
26171
sed 's/^/| /' conftest.$ac_ext >&5
 
26172
 
 
26173
        cat >conftest.$ac_ext <<_ACEOF
 
26174
/* confdefs.h.  */
 
26175
_ACEOF
 
26176
cat confdefs.h >>conftest.$ac_ext
 
26177
cat >>conftest.$ac_ext <<_ACEOF
 
26178
/* end confdefs.h.  */
 
26179
#include <krb5.h>
 
26180
 
 
26181
int
 
26182
main ()
 
26183
{
 
26184
static krb5_error ac_aggr;
 
26185
if (sizeof ac_aggr.e_data)
 
26186
return 0;
 
26187
  ;
 
26188
  return 0;
 
26189
}
 
26190
_ACEOF
 
26191
rm -f conftest.$ac_objext
 
26192
if { (ac_try="$ac_compile"
 
26193
case "(($ac_try" in
 
26194
  *\"* | *\`* | *\\*) ac_try_echo=\$ac_try;;
 
26195
  *) ac_try_echo=$ac_try;;
 
26196
esac
 
26197
eval "echo \"\$as_me:$LINENO: $ac_try_echo\"") >&5
 
26198
  (eval "$ac_compile") 2>conftest.er1
 
26199
  ac_status=$?
 
26200
  grep -v '^ *+' conftest.er1 >conftest.err
 
26201
  rm -f conftest.er1
 
26202
  cat conftest.err >&5
 
26203
  echo "$as_me:$LINENO: \$? = $ac_status" >&5
 
26204
  (exit $ac_status); } &&
 
26205
         { ac_try='test -z "$ac_c_werror_flag" || test ! -s conftest.err'
 
26206
  { (case "(($ac_try" in
 
26207
  *\"* | *\`* | *\\*) ac_try_echo=\$ac_try;;
 
26208
  *) ac_try_echo=$ac_try;;
 
26209
esac
 
26210
eval "echo \"\$as_me:$LINENO: $ac_try_echo\"") >&5
 
26211
  (eval "$ac_try") 2>&5
 
26212
  ac_status=$?
 
26213
  echo "$as_me:$LINENO: \$? = $ac_status" >&5
 
26214
  (exit $ac_status); }; } &&
 
26215
         { ac_try='test -s conftest.$ac_objext'
 
26216
  { (case "(($ac_try" in
 
26217
  *\"* | *\`* | *\\*) ac_try_echo=\$ac_try;;
 
26218
  *) ac_try_echo=$ac_try;;
 
26219
esac
 
26220
eval "echo \"\$as_me:$LINENO: $ac_try_echo\"") >&5
 
26221
  (eval "$ac_try") 2>&5
 
26222
  ac_status=$?
 
26223
  echo "$as_me:$LINENO: \$? = $ac_status" >&5
 
26224
  (exit $ac_status); }; }; then
 
26225
  ac_cv_member_krb5_error_e_data=yes
 
26226
else
 
26227
  echo "$as_me: failed program was:" >&5
 
26228
sed 's/^/| /' conftest.$ac_ext >&5
 
26229
 
 
26230
        ac_cv_member_krb5_error_e_data=no
 
26231
fi
 
26232
 
 
26233
rm -f core conftest.err conftest.$ac_objext conftest.$ac_ext
 
26234
fi
 
26235
 
 
26236
rm -f core conftest.err conftest.$ac_objext conftest.$ac_ext
 
26237
fi
 
26238
{ echo "$as_me:$LINENO: result: $ac_cv_member_krb5_error_e_data" >&5
 
26239
echo "${ECHO_T}$ac_cv_member_krb5_error_e_data" >&6; }
 
26240
if test $ac_cv_member_krb5_error_e_data = yes; then
 
26241
 
 
26242
cat >>confdefs.h <<_ACEOF
 
26243
#define HAVE_KRB5_ERROR_E_DATA 1
 
26244
_ACEOF
 
26245
 
 
26246
 
 
26247
else
 
26248
  { { echo "$as_me:$LINENO: error: could not determine how to extract Kerberos 5 error messages" >&5
 
26249
echo "$as_me: error: could not determine how to extract Kerberos 5 error messages" >&2;}
 
26250
   { (exit 1); exit 1; }; }
 
26251
fi
 
26252
 
 
26253
fi
 
26254
 
 
26255
  { echo "$as_me:$LINENO: checking for krb5_free_unparsed_name" >&5
 
26256
echo $ECHO_N "checking for krb5_free_unparsed_name... $ECHO_C" >&6; }
 
26257
  cat >conftest.$ac_ext <<_ACEOF
 
26258
/* confdefs.h.  */
 
26259
_ACEOF
 
26260
cat confdefs.h >>conftest.$ac_ext
 
26261
cat >>conftest.$ac_ext <<_ACEOF
 
26262
/* end confdefs.h.  */
 
26263
#include <krb5.h>
 
26264
int
 
26265
main ()
 
26266
{
 
26267
krb5_free_unparsed_name(NULL,NULL);
 
26268
  ;
 
26269
  return 0;
 
26270
}
 
26271
_ACEOF
 
26272
rm -f conftest.$ac_objext conftest$ac_exeext
 
26273
if { (ac_try="$ac_link"
 
26274
case "(($ac_try" in
 
26275
  *\"* | *\`* | *\\*) ac_try_echo=\$ac_try;;
 
26276
  *) ac_try_echo=$ac_try;;
 
26277
esac
 
26278
eval "echo \"\$as_me:$LINENO: $ac_try_echo\"") >&5
 
26279
  (eval "$ac_link") 2>conftest.er1
 
26280
  ac_status=$?
 
26281
  grep -v '^ *+' conftest.er1 >conftest.err
 
26282
  rm -f conftest.er1
 
26283
  cat conftest.err >&5
 
26284
  echo "$as_me:$LINENO: \$? = $ac_status" >&5
 
26285
  (exit $ac_status); } &&
 
26286
         { ac_try='test -z "$ac_c_werror_flag" || test ! -s conftest.err'
 
26287
  { (case "(($ac_try" in
 
26288
  *\"* | *\`* | *\\*) ac_try_echo=\$ac_try;;
 
26289
  *) ac_try_echo=$ac_try;;
 
26290
esac
 
26291
eval "echo \"\$as_me:$LINENO: $ac_try_echo\"") >&5
 
26292
  (eval "$ac_try") 2>&5
 
26293
  ac_status=$?
 
26294
  echo "$as_me:$LINENO: \$? = $ac_status" >&5
 
26295
  (exit $ac_status); }; } &&
 
26296
         { ac_try='test -s conftest$ac_exeext'
 
26297
  { (case "(($ac_try" in
 
26298
  *\"* | *\`* | *\\*) ac_try_echo=\$ac_try;;
 
26299
  *) ac_try_echo=$ac_try;;
 
26300
esac
 
26301
eval "echo \"\$as_me:$LINENO: $ac_try_echo\"") >&5
 
26302
  (eval "$ac_try") 2>&5
 
26303
  ac_status=$?
 
26304
  echo "$as_me:$LINENO: \$? = $ac_status" >&5
 
26305
  (exit $ac_status); }; }; then
 
26306
 
 
26307
cat >>confdefs.h <<\_ACEOF
 
26308
#define HAVE_KRB5_FREE_UNPARSED_NAME 1
 
26309
_ACEOF
 
26310
 
 
26311
{ echo "$as_me:$LINENO: result: yes" >&5
 
26312
echo "${ECHO_T}yes" >&6; }
 
26313
else
 
26314
  echo "$as_me: failed program was:" >&5
 
26315
sed 's/^/| /' conftest.$ac_ext >&5
 
26316
 
 
26317
        { echo "$as_me:$LINENO: result: no" >&5
 
26318
echo "${ECHO_T}no" >&6; }
 
26319
fi
 
26320
 
 
26321
rm -f core conftest.err conftest.$ac_objext \
 
26322
      conftest$ac_exeext conftest.$ac_ext
 
26323
fi
 
26324
 
 
26325
# 8. Libltdl
 
26326
 
 
26327
{ echo "$as_me:$LINENO: checking for lt_dlopen in -lltdl" >&5
 
26328
echo $ECHO_N "checking for lt_dlopen in -lltdl... $ECHO_C" >&6; }
 
26329
if test "${ac_cv_lib_ltdl_lt_dlopen+set}" = set; then
 
26330
  echo $ECHO_N "(cached) $ECHO_C" >&6
 
26331
else
 
26332
  ac_check_lib_save_LIBS=$LIBS
 
26333
LIBS="-lltdl  $LIBS"
 
26334
cat >conftest.$ac_ext <<_ACEOF
 
26335
/* confdefs.h.  */
 
26336
_ACEOF
 
26337
cat confdefs.h >>conftest.$ac_ext
 
26338
cat >>conftest.$ac_ext <<_ACEOF
 
26339
/* end confdefs.h.  */
 
26340
 
 
26341
/* Override any GCC internal prototype to avoid an error.
 
26342
   Use char because int might match the return type of a GCC
 
26343
   builtin and then its argument prototype would still apply.  */
 
26344
#ifdef __cplusplus
 
26345
extern "C"
 
26346
#endif
 
26347
char lt_dlopen ();
 
26348
int
 
26349
main ()
 
26350
{
 
26351
return lt_dlopen ();
 
26352
  ;
 
26353
  return 0;
 
26354
}
 
26355
_ACEOF
 
26356
rm -f conftest.$ac_objext conftest$ac_exeext
 
26357
if { (ac_try="$ac_link"
 
26358
case "(($ac_try" in
 
26359
  *\"* | *\`* | *\\*) ac_try_echo=\$ac_try;;
 
26360
  *) ac_try_echo=$ac_try;;
 
26361
esac
 
26362
eval "echo \"\$as_me:$LINENO: $ac_try_echo\"") >&5
 
26363
  (eval "$ac_link") 2>conftest.er1
 
26364
  ac_status=$?
 
26365
  grep -v '^ *+' conftest.er1 >conftest.err
 
26366
  rm -f conftest.er1
 
26367
  cat conftest.err >&5
 
26368
  echo "$as_me:$LINENO: \$? = $ac_status" >&5
 
26369
  (exit $ac_status); } &&
 
26370
         { ac_try='test -z "$ac_c_werror_flag" || test ! -s conftest.err'
 
26371
  { (case "(($ac_try" in
 
26372
  *\"* | *\`* | *\\*) ac_try_echo=\$ac_try;;
 
26373
  *) ac_try_echo=$ac_try;;
 
26374
esac
 
26375
eval "echo \"\$as_me:$LINENO: $ac_try_echo\"") >&5
 
26376
  (eval "$ac_try") 2>&5
 
26377
  ac_status=$?
 
26378
  echo "$as_me:$LINENO: \$? = $ac_status" >&5
 
26379
  (exit $ac_status); }; } &&
 
26380
         { ac_try='test -s conftest$ac_exeext'
 
26381
  { (case "(($ac_try" in
 
26382
  *\"* | *\`* | *\\*) ac_try_echo=\$ac_try;;
 
26383
  *) ac_try_echo=$ac_try;;
 
26384
esac
 
26385
eval "echo \"\$as_me:$LINENO: $ac_try_echo\"") >&5
 
26386
  (eval "$ac_try") 2>&5
 
26387
  ac_status=$?
 
26388
  echo "$as_me:$LINENO: \$? = $ac_status" >&5
 
26389
  (exit $ac_status); }; }; then
 
26390
  ac_cv_lib_ltdl_lt_dlopen=yes
 
26391
else
 
26392
  echo "$as_me: failed program was:" >&5
 
26393
sed 's/^/| /' conftest.$ac_ext >&5
 
26394
 
 
26395
        ac_cv_lib_ltdl_lt_dlopen=no
 
26396
fi
 
26397
 
 
26398
rm -f core conftest.err conftest.$ac_objext \
 
26399
      conftest$ac_exeext conftest.$ac_ext
 
26400
LIBS=$ac_check_lib_save_LIBS
 
26401
fi
 
26402
{ echo "$as_me:$LINENO: result: $ac_cv_lib_ltdl_lt_dlopen" >&5
 
26403
echo "${ECHO_T}$ac_cv_lib_ltdl_lt_dlopen" >&6; }
 
26404
if test $ac_cv_lib_ltdl_lt_dlopen = yes; then
 
26405
  cat >>confdefs.h <<_ACEOF
 
26406
#define HAVE_LIBLTDL 1
 
26407
_ACEOF
 
26408
 
 
26409
  LIBS="-lltdl $LIBS"
 
26410
 
 
26411
fi
23234
26412
 
23235
26413
 
23236
26414
 
23339
26517
Usually this means the macro was only invoked conditionally." >&2;}
23340
26518
   { (exit 1); exit 1; }; }
23341
26519
fi
 
26520
if test -z "${AMDEP_TRUE}" && test -z "${AMDEP_FALSE}"; then
 
26521
  { { echo "$as_me:$LINENO: error: conditional \"AMDEP\" was never defined.
 
26522
Usually this means the macro was only invoked conditionally." >&5
 
26523
echo "$as_me: error: conditional \"AMDEP\" was never defined.
 
26524
Usually this means the macro was only invoked conditionally." >&2;}
 
26525
   { (exit 1); exit 1; }; }
 
26526
fi
 
26527
if test -z "${am__fastdepCC_TRUE}" && test -z "${am__fastdepCC_FALSE}"; then
 
26528
  { { echo "$as_me:$LINENO: error: conditional \"am__fastdepCC\" was never defined.
 
26529
Usually this means the macro was only invoked conditionally." >&5
 
26530
echo "$as_me: error: conditional \"am__fastdepCC\" was never defined.
 
26531
Usually this means the macro was only invoked conditionally." >&2;}
 
26532
   { (exit 1); exit 1; }; }
 
26533
fi
23342
26534
if test -z "${enable_unicode_TRUE}" && test -z "${enable_unicode_FALSE}"; then
23343
26535
  { { echo "$as_me:$LINENO: error: conditional \"enable_unicode\" was never defined.
23344
26536
Usually this means the macro was only invoked conditionally." >&5
23353
26545
Usually this means the macro was only invoked conditionally." >&2;}
23354
26546
   { (exit 1); exit 1; }; }
23355
26547
fi
23356
 
if test -z "${AMDEP_TRUE}" && test -z "${AMDEP_FALSE}"; then
23357
 
  { { echo "$as_me:$LINENO: error: conditional \"AMDEP\" was never defined.
23358
 
Usually this means the macro was only invoked conditionally." >&5
23359
 
echo "$as_me: error: conditional \"AMDEP\" was never defined.
 
26548
if test -z "${enable_gss_TRUE}" && test -z "${enable_gss_FALSE}"; then
 
26549
  { { echo "$as_me:$LINENO: error: conditional \"enable_gss\" was never defined.
 
26550
Usually this means the macro was only invoked conditionally." >&5
 
26551
echo "$as_me: error: conditional \"enable_gss\" was never defined.
 
26552
Usually this means the macro was only invoked conditionally." >&2;}
 
26553
   { (exit 1); exit 1; }; }
 
26554
fi
 
26555
if test -z "${enable_krb5_TRUE}" && test -z "${enable_krb5_FALSE}"; then
 
26556
  { { echo "$as_me:$LINENO: error: conditional \"enable_krb5\" was never defined.
 
26557
Usually this means the macro was only invoked conditionally." >&5
 
26558
echo "$as_me: error: conditional \"enable_krb5\" was never defined.
23360
26559
Usually this means the macro was only invoked conditionally." >&2;}
23361
26560
   { (exit 1); exit 1; }; }
23362
26561
fi
23367
26566
Usually this means the macro was only invoked conditionally." >&2;}
23368
26567
   { (exit 1); exit 1; }; }
23369
26568
fi
 
26569
if test -z "${GCC_TRUE}" && test -z "${GCC_FALSE}"; then
 
26570
  { { echo "$as_me:$LINENO: error: conditional \"GCC\" was never defined.
 
26571
Usually this means the macro was only invoked conditionally." >&5
 
26572
echo "$as_me: error: conditional \"GCC\" was never defined.
 
26573
Usually this means the macro was only invoked conditionally." >&2;}
 
26574
   { (exit 1); exit 1; }; }
 
26575
fi
23370
26576
if test -z "${am__fastdepCXX_TRUE}" && test -z "${am__fastdepCXX_FALSE}"; then
23371
26577
  { { echo "$as_me:$LINENO: error: conditional \"am__fastdepCXX\" was never defined.
23372
26578
Usually this means the macro was only invoked conditionally." >&5
23661
26867
# report actual input values of CONFIG_FILES etc. instead of their
23662
26868
# values after options handling.
23663
26869
ac_log="
23664
 
This file was extended by psqlodbc $as_me 08.03.0200, which was
 
26870
This file was extended by psqlodbc $as_me 09.00.0200, which was
23665
26871
generated by GNU Autoconf 2.60.  Invocation command line was
23666
26872
 
23667
26873
  CONFIG_FILES    = $CONFIG_FILES
23714
26920
_ACEOF
23715
26921
cat >>$CONFIG_STATUS <<_ACEOF
23716
26922
ac_cs_version="\\
23717
 
psqlodbc config.status 08.03.0200
 
26923
psqlodbc config.status 09.00.0200
23718
26924
configured by $0, generated by GNU Autoconf 2.60,
23719
26925
  with options \\"`echo "$ac_configure_args" | sed 's/^ //; s/[\\""\`\$]/\\\\&/g'`\\"
23720
26926
 
23954
27160
MAINTAINER_MODE_FALSE!$MAINTAINER_MODE_FALSE$ac_delim
23955
27161
MAINT!$MAINT$ac_delim
23956
27162
ODBC_CONFIG!$ODBC_CONFIG$ac_delim
23957
 
enable_unicode_TRUE!$enable_unicode_TRUE$ac_delim
23958
 
enable_unicode_FALSE!$enable_unicode_FALSE$ac_delim
23959
 
enable_openssl_TRUE!$enable_openssl_TRUE$ac_delim
23960
 
enable_openssl_FALSE!$enable_openssl_FALSE$ac_delim
23961
 
PG_CONFIG!$PG_CONFIG$ac_delim
23962
27163
CC!$CC$ac_delim
23963
27164
CFLAGS!$CFLAGS$ac_delim
23964
27165
LDFLAGS!$LDFLAGS$ac_delim
23975
27176
CCDEPMODE!$CCDEPMODE$ac_delim
23976
27177
am__fastdepCC_TRUE!$am__fastdepCC_TRUE$ac_delim
23977
27178
am__fastdepCC_FALSE!$am__fastdepCC_FALSE$ac_delim
 
27179
enable_unicode_TRUE!$enable_unicode_TRUE$ac_delim
 
27180
enable_unicode_FALSE!$enable_unicode_FALSE$ac_delim
 
27181
enable_openssl_TRUE!$enable_openssl_TRUE$ac_delim
 
27182
enable_openssl_FALSE!$enable_openssl_FALSE$ac_delim
 
27183
enable_gss_TRUE!$enable_gss_TRUE$ac_delim
 
27184
enable_gss_FALSE!$enable_gss_FALSE$ac_delim
 
27185
enable_krb5_TRUE!$enable_krb5_TRUE$ac_delim
 
27186
enable_krb5_FALSE!$enable_krb5_FALSE$ac_delim
 
27187
PG_CONFIG!$PG_CONFIG$ac_delim
 
27188
GCC_TRUE!$GCC_TRUE$ac_delim
 
27189
GCC_FALSE!$GCC_FALSE$ac_delim
23978
27190
build!$build$ac_delim
23979
27191
build_cpu!$build_cpu$ac_delim
23980
27192
build_vendor!$build_vendor$ac_delim
23983
27195
host_cpu!$host_cpu$ac_delim
23984
27196
host_vendor!$host_vendor$ac_delim
23985
27197
host_os!$host_os$ac_delim
 
27198
_ACEOF
 
27199
 
 
27200
  if test `sed -n "s/.*$ac_delim\$/X/p" conf$$subs.sed | grep -c X` = 97; then
 
27201
    break
 
27202
  elif $ac_last_try; then
 
27203
    { { echo "$as_me:$LINENO: error: could not make $CONFIG_STATUS" >&5
 
27204
echo "$as_me: error: could not make $CONFIG_STATUS" >&2;}
 
27205
   { (exit 1); exit 1; }; }
 
27206
  else
 
27207
    ac_delim="$ac_delim!$ac_delim _$ac_delim!! "
 
27208
  fi
 
27209
done
 
27210
 
 
27211
ac_eof=`sed -n '/^CEOF[0-9]*$/s/CEOF/0/p' conf$$subs.sed`
 
27212
if test -n "$ac_eof"; then
 
27213
  ac_eof=`echo "$ac_eof" | sort -nru | sed 1q`
 
27214
  ac_eof=`expr $ac_eof + 1`
 
27215
fi
 
27216
 
 
27217
cat >>$CONFIG_STATUS <<_ACEOF
 
27218
cat >"\$tmp/subs-1.sed" <<\CEOF$ac_eof
 
27219
/@[a-zA-Z_][a-zA-Z_0-9]*@/!b
 
27220
_ACEOF
 
27221
sed '
 
27222
s/[,\\&]/\\&/g; s/@/@|#_!!_#|/g
 
27223
s/^/s,@/; s/!/@,|#_!!_#|/
 
27224
:n
 
27225
t n
 
27226
s/'"$ac_delim"'$/,g/; t
 
27227
s/$/\\/; p
 
27228
N; s/^.*\n//; s/[,\\&]/\\&/g; s/@/@|#_!!_#|/g; b n
 
27229
' >>$CONFIG_STATUS <conf$$subs.sed
 
27230
rm -f conf$$subs.sed
 
27231
cat >>$CONFIG_STATUS <<_ACEOF
 
27232
CEOF$ac_eof
 
27233
_ACEOF
 
27234
 
 
27235
 
 
27236
ac_delim='%!_!# '
 
27237
for ac_last_try in false false false false false :; do
 
27238
  cat >conf$$subs.sed <<_ACEOF
23986
27239
GREP!$GREP$ac_delim
23987
27240
EGREP!$EGREP$ac_delim
23988
27241
LN_S!$LN_S$ac_delim
23989
27242
ECHO!$ECHO$ac_delim
23990
27243
AR!$AR$ac_delim
23991
27244
RANLIB!$RANLIB$ac_delim
23992
 
_ACEOF
23993
 
 
23994
 
  if test `sed -n "s/.*$ac_delim\$/X/p" conf$$subs.sed | grep -c X` = 97; then
23995
 
    break
23996
 
  elif $ac_last_try; then
23997
 
    { { echo "$as_me:$LINENO: error: could not make $CONFIG_STATUS" >&5
23998
 
echo "$as_me: error: could not make $CONFIG_STATUS" >&2;}
23999
 
   { (exit 1); exit 1; }; }
24000
 
  else
24001
 
    ac_delim="$ac_delim!$ac_delim _$ac_delim!! "
24002
 
  fi
24003
 
done
24004
 
 
24005
 
ac_eof=`sed -n '/^CEOF[0-9]*$/s/CEOF/0/p' conf$$subs.sed`
24006
 
if test -n "$ac_eof"; then
24007
 
  ac_eof=`echo "$ac_eof" | sort -nru | sed 1q`
24008
 
  ac_eof=`expr $ac_eof + 1`
24009
 
fi
24010
 
 
24011
 
cat >>$CONFIG_STATUS <<_ACEOF
24012
 
cat >"\$tmp/subs-1.sed" <<\CEOF$ac_eof
24013
 
/@[a-zA-Z_][a-zA-Z_0-9]*@/!b
24014
 
_ACEOF
24015
 
sed '
24016
 
s/[,\\&]/\\&/g; s/@/@|#_!!_#|/g
24017
 
s/^/s,@/; s/!/@,|#_!!_#|/
24018
 
:n
24019
 
t n
24020
 
s/'"$ac_delim"'$/,g/; t
24021
 
s/$/\\/; p
24022
 
N; s/^.*\n//; s/[,\\&]/\\&/g; s/@/@|#_!!_#|/g; b n
24023
 
' >>$CONFIG_STATUS <conf$$subs.sed
24024
 
rm -f conf$$subs.sed
24025
 
cat >>$CONFIG_STATUS <<_ACEOF
24026
 
CEOF$ac_eof
24027
 
_ACEOF
24028
 
 
24029
 
 
24030
 
ac_delim='%!_!# '
24031
 
for ac_last_try in false false false false false :; do
24032
 
  cat >conf$$subs.sed <<_ACEOF
24033
27245
DLLTOOL!$DLLTOOL$ac_delim
24034
27246
AS!$AS$ac_delim
24035
27247
OBJDUMP!$OBJDUMP$ac_delim
24049
27261
LTLIBOBJS!$LTLIBOBJS$ac_delim
24050
27262
_ACEOF
24051
27263
 
24052
 
  if test `sed -n "s/.*$ac_delim\$/X/p" conf$$subs.sed | grep -c X` = 17; then
 
27264
  if test `sed -n "s/.*$ac_delim\$/X/p" conf$$subs.sed | grep -c X` = 23; then
24053
27265
    break
24054
27266
  elif $ac_last_try; then
24055
27267
    { { echo "$as_me:$LINENO: error: could not make $CONFIG_STATUS" >&5