~vorlon/ubuntu/oneiric/lcms/multiarch

« back to all changes in this revision

Viewing changes to configure

  • Committer: Bazaar Package Importer
  • Author(s): Oleksandr Moskalenko
  • Date: 2008-07-24 14:29:36 UTC
  • mfrom: (1.1.4 upstream)
  • Revision ID: james.westby@ubuntu.com-20080724142936-9fgs00bge01jgdl5
Tags: 1.17.dfsg-1
Removed Adobe sRGB profiles from the testdbed and python/testbed
directories (Closes: #491995).

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 lcms 1.16.
 
3
# Generated by GNU Autoconf 2.61 for lcms 1.17.
4
4
#
5
5
# Copyright (C) 1992, 1993, 1994, 1995, 1996, 1998, 1999, 2000, 2001,
6
6
# 2002, 2003, 2004, 2005, 2006 Free Software Foundation, Inc.
10
10
## M4sh Initialization.  ##
11
11
## --------------------- ##
12
12
 
13
 
# Be Bourne compatible
 
13
# Be more Bourne compatible
 
14
DUALCASE=1; export DUALCASE # for MKS sh
14
15
if test -n "${ZSH_VERSION+set}" && (emulate sh) >/dev/null 2>&1; then
15
16
  emulate sh
16
17
  NULLCMD=:
19
20
  alias -g '${1+"$@"}'='"$@"'
20
21
  setopt NO_GLOB_SUBST
21
22
else
22
 
  case `(set -o) 2>/dev/null` in *posix*) set -o posix;; esac
 
23
  case `(set -o) 2>/dev/null` in
 
24
  *posix*) set -o posix ;;
 
25
esac
 
26
 
23
27
fi
24
 
BIN_SH=xpg4; export BIN_SH # for Tru64
25
 
DUALCASE=1; export DUALCASE # for MKS sh
 
28
 
 
29
 
26
30
 
27
31
 
28
32
# PATH needs CR
215
219
else
216
220
  as_candidate_shells=
217
221
    as_save_IFS=$IFS; IFS=$PATH_SEPARATOR
218
 
for as_dir in /usr/bin/posix$PATH_SEPARATOR/bin$PATH_SEPARATOR/usr/bin$PATH_SEPARATOR$PATH
 
222
for as_dir in /bin$PATH_SEPARATOR/usr/bin$PATH_SEPARATOR$PATH
219
223
do
220
224
  IFS=$as_save_IFS
221
225
  test -z "$as_dir" && as_dir=.
233
237
         # Try only shells that exist, to save several forks.
234
238
         if { test -f "$as_shell" || test -f "$as_shell.exe"; } &&
235
239
                { ("$as_shell") 2> /dev/null <<\_ASEOF
236
 
# Be Bourne compatible
237
240
if test -n "${ZSH_VERSION+set}" && (emulate sh) >/dev/null 2>&1; then
238
241
  emulate sh
239
242
  NULLCMD=:
242
245
  alias -g '${1+"$@"}'='"$@"'
243
246
  setopt NO_GLOB_SUBST
244
247
else
245
 
  case `(set -o) 2>/dev/null` in *posix*) set -o posix;; esac
 
248
  case `(set -o) 2>/dev/null` in
 
249
  *posix*) set -o posix ;;
 
250
esac
 
251
 
246
252
fi
247
 
BIN_SH=xpg4; export BIN_SH # for Tru64
248
 
DUALCASE=1; export DUALCASE # for MKS sh
 
253
 
249
254
 
250
255
:
251
256
_ASEOF
253
258
  CONFIG_SHELL=$as_shell
254
259
               as_have_required=yes
255
260
               if { "$as_shell" 2> /dev/null <<\_ASEOF
256
 
# Be Bourne compatible
257
261
if test -n "${ZSH_VERSION+set}" && (emulate sh) >/dev/null 2>&1; then
258
262
  emulate sh
259
263
  NULLCMD=:
262
266
  alias -g '${1+"$@"}'='"$@"'
263
267
  setopt NO_GLOB_SUBST
264
268
else
265
 
  case `(set -o) 2>/dev/null` in *posix*) set -o posix;; esac
 
269
  case `(set -o) 2>/dev/null` in
 
270
  *posix*) set -o posix ;;
 
271
esac
 
272
 
266
273
fi
267
 
BIN_SH=xpg4; export BIN_SH # for Tru64
268
 
DUALCASE=1; export DUALCASE # for MKS sh
 
274
 
269
275
 
270
276
:
271
277
(as_func_return () {
512
518
  as_mkdir_p=false
513
519
fi
514
520
 
515
 
# Find out whether ``test -x'' works.  Don't use a zero-byte file, as
516
 
# systems may use methods other than mode bits to determine executability.
517
 
cat >conf$$.file <<_ASEOF
518
 
#! /bin/sh
519
 
exit 0
520
 
_ASEOF
521
 
chmod +x conf$$.file
522
 
if test -x conf$$.file >/dev/null 2>&1; then
523
 
  as_executable_p="test -x"
 
521
if test -x / >/dev/null 2>&1; then
 
522
  as_test_x='test -x'
524
523
else
525
 
  as_executable_p=:
 
524
  if ls -dL / >/dev/null 2>&1; then
 
525
    as_ls_L_option=L
 
526
  else
 
527
    as_ls_L_option=
 
528
  fi
 
529
  as_test_x='
 
530
    eval sh -c '\''
 
531
      if test -d "$1"; then
 
532
        test -d "$1/.";
 
533
      else
 
534
        case $1 in
 
535
        -*)set "./$1";;
 
536
        esac;
 
537
        case `ls -ld'$as_ls_L_option' "$1" 2>/dev/null` in
 
538
        ???[sx]*):;;*)false;;esac;fi
 
539
    '\'' sh
 
540
  '
526
541
fi
527
 
rm -f conf$$.file
 
542
as_executable_p=$as_test_x
528
543
 
529
544
# Sed expression to map a string onto a valid CPP name.
530
545
as_tr_cpp="eval sed 'y%*$as_cr_letters%P$as_cr_LETTERS%;s%[^_$as_cr_alnum]%_%g'"
711
726
# Identity of this package.
712
727
PACKAGE_NAME='lcms'
713
728
PACKAGE_TARNAME='lcms'
714
 
PACKAGE_VERSION='1.16'
715
 
PACKAGE_STRING='lcms 1.16'
 
729
PACKAGE_VERSION='1.17'
 
730
PACKAGE_STRING='lcms 1.17'
716
731
PACKAGE_BUGREPORT=''
717
732
 
718
733
# Factoring default headers for most tests.
719
734
ac_includes_default="\
720
735
#include <stdio.h>
721
 
#if HAVE_SYS_TYPES_H
 
736
#ifdef HAVE_SYS_TYPES_H
722
737
# include <sys/types.h>
723
738
#endif
724
 
#if HAVE_SYS_STAT_H
 
739
#ifdef HAVE_SYS_STAT_H
725
740
# include <sys/stat.h>
726
741
#endif
727
 
#if STDC_HEADERS
 
742
#ifdef STDC_HEADERS
728
743
# include <stdlib.h>
729
744
# include <stddef.h>
730
745
#else
731
 
# if HAVE_STDLIB_H
 
746
# ifdef HAVE_STDLIB_H
732
747
#  include <stdlib.h>
733
748
# endif
734
749
#endif
735
 
#if HAVE_STRING_H
736
 
# if !STDC_HEADERS && HAVE_MEMORY_H
 
750
#ifdef HAVE_STRING_H
 
751
# if !defined STDC_HEADERS && defined HAVE_MEMORY_H
737
752
#  include <memory.h>
738
753
# endif
739
754
# include <string.h>
740
755
#endif
741
 
#if HAVE_STRINGS_H
 
756
#ifdef HAVE_STRINGS_H
742
757
# include <strings.h>
743
758
#endif
744
 
#if HAVE_INTTYPES_H
 
759
#ifdef HAVE_INTTYPES_H
745
760
# include <inttypes.h>
746
761
#endif
747
 
#if HAVE_STDINT_H
 
762
#ifdef HAVE_STDINT_H
748
763
# include <stdint.h>
749
764
#endif
750
 
#if HAVE_UNISTD_H
 
765
#ifdef HAVE_UNISTD_H
751
766
# include <unistd.h>
752
767
#endif"
753
768
 
913
928
CC
914
929
CFLAGS
915
930
LDFLAGS
 
931
LIBS
916
932
CPPFLAGS
917
933
CPP
918
934
CXX
1026
1042
  -disable-* | --disable-*)
1027
1043
    ac_feature=`expr "x$ac_option" : 'x-*disable-\(.*\)'`
1028
1044
    # Reject names that are not valid shell variable names.
1029
 
    expr "x$ac_feature" : ".*[^-_$as_cr_alnum]" >/dev/null &&
 
1045
    expr "x$ac_feature" : ".*[^-._$as_cr_alnum]" >/dev/null &&
1030
1046
      { echo "$as_me: error: invalid feature name: $ac_feature" >&2
1031
1047
   { (exit 1); exit 1; }; }
1032
 
    ac_feature=`echo $ac_feature | sed 's/-/_/g'`
 
1048
    ac_feature=`echo $ac_feature | sed 's/[-.]/_/g'`
1033
1049
    eval enable_$ac_feature=no ;;
1034
1050
 
1035
1051
  -docdir | --docdir | --docdi | --doc | --do)
1045
1061
  -enable-* | --enable-*)
1046
1062
    ac_feature=`expr "x$ac_option" : 'x-*enable-\([^=]*\)'`
1047
1063
    # Reject names that are not valid shell variable names.
1048
 
    expr "x$ac_feature" : ".*[^-_$as_cr_alnum]" >/dev/null &&
 
1064
    expr "x$ac_feature" : ".*[^-._$as_cr_alnum]" >/dev/null &&
1049
1065
      { echo "$as_me: error: invalid feature name: $ac_feature" >&2
1050
1066
   { (exit 1); exit 1; }; }
1051
 
    ac_feature=`echo $ac_feature | sed 's/-/_/g'`
 
1067
    ac_feature=`echo $ac_feature | sed 's/[-.]/_/g'`
1052
1068
    eval enable_$ac_feature=\$ac_optarg ;;
1053
1069
 
1054
1070
  -exec-prefix | --exec_prefix | --exec-prefix | --exec-prefi \
1242
1258
  -with-* | --with-*)
1243
1259
    ac_package=`expr "x$ac_option" : 'x-*with-\([^=]*\)'`
1244
1260
    # Reject names that are not valid shell variable names.
1245
 
    expr "x$ac_package" : ".*[^-_$as_cr_alnum]" >/dev/null &&
 
1261
    expr "x$ac_package" : ".*[^-._$as_cr_alnum]" >/dev/null &&
1246
1262
      { echo "$as_me: error: invalid package name: $ac_package" >&2
1247
1263
   { (exit 1); exit 1; }; }
1248
 
    ac_package=`echo $ac_package| sed 's/-/_/g'`
 
1264
    ac_package=`echo $ac_package | sed 's/[-.]/_/g'`
1249
1265
    eval with_$ac_package=\$ac_optarg ;;
1250
1266
 
1251
1267
  -without-* | --without-*)
1252
1268
    ac_package=`expr "x$ac_option" : 'x-*without-\(.*\)'`
1253
1269
    # Reject names that are not valid shell variable names.
1254
 
    expr "x$ac_package" : ".*[^-_$as_cr_alnum]" >/dev/null &&
 
1270
    expr "x$ac_package" : ".*[^-._$as_cr_alnum]" >/dev/null &&
1255
1271
      { echo "$as_me: error: invalid package name: $ac_package" >&2
1256
1272
   { (exit 1); exit 1; }; }
1257
 
    ac_package=`echo $ac_package | sed 's/-/_/g'`
 
1273
    ac_package=`echo $ac_package | sed 's/[-.]/_/g'`
1258
1274
    eval with_$ac_package=no ;;
1259
1275
 
1260
1276
  --x)
1423
1439
  # Omit some internal or obsolete options to make the list less imposing.
1424
1440
  # This message is too long to be a string in the A/UX 3.1 sh.
1425
1441
  cat <<_ACEOF
1426
 
\`configure' configures lcms 1.16 to adapt to many kinds of systems.
 
1442
\`configure' configures lcms 1.17 to adapt to many kinds of systems.
1427
1443
 
1428
1444
Usage: $0 [OPTION]... [VAR=VALUE]...
1429
1445
 
1494
1510
 
1495
1511
if test -n "$ac_init_help"; then
1496
1512
  case $ac_init_help in
1497
 
     short | recursive ) echo "Configuration of lcms 1.16:";;
 
1513
     short | recursive ) echo "Configuration of lcms 1.17:";;
1498
1514
   esac
1499
1515
  cat <<\_ACEOF
1500
1516
 
1528
1544
  CFLAGS      C compiler flags
1529
1545
  LDFLAGS     linker flags, e.g. -L<lib dir> if you have libraries in a
1530
1546
              nonstandard directory <lib dir>
 
1547
  LIBS        libraries to pass to the linker, e.g. -l<library>
1531
1548
  CPPFLAGS    C/C++/Objective C preprocessor flags, e.g. -I<include dir> if
1532
1549
              you have headers in a nonstandard directory <include dir>
1533
1550
  CPP         C preprocessor
1600
1617
test -n "$ac_init_help" && exit $ac_status
1601
1618
if $ac_init_version; then
1602
1619
  cat <<\_ACEOF
1603
 
lcms configure 1.16
1604
 
generated by GNU Autoconf 2.60
 
1620
lcms configure 1.17
 
1621
generated by GNU Autoconf 2.61
1605
1622
 
1606
1623
Copyright (C) 1992, 1993, 1994, 1995, 1996, 1998, 1999, 2000, 2001,
1607
1624
2002, 2003, 2004, 2005, 2006 Free Software Foundation, Inc.
1614
1631
This file contains any messages produced by compilers while
1615
1632
running configure, to aid debugging if configure makes a mistake.
1616
1633
 
1617
 
It was created by lcms $as_me 1.16, which was
1618
 
generated by GNU Autoconf 2.60.  Invocation command line was
 
1634
It was created by lcms $as_me 1.17, which was
 
1635
generated by GNU Autoconf 2.61.  Invocation command line was
1619
1636
 
1620
1637
  $ $0 $@
1621
1638
 
2241
2258
    # by default.
2242
2259
    for ac_prog in ginstall scoinst install; do
2243
2260
      for ac_exec_ext in '' $ac_executable_extensions; do
2244
 
        if { test -f "$as_dir/$ac_prog$ac_exec_ext" && $as_executable_p "$as_dir/$ac_prog$ac_exec_ext"; }; then
 
2261
        if { test -f "$as_dir/$ac_prog$ac_exec_ext" && $as_test_x "$as_dir/$ac_prog$ac_exec_ext"; }; then
2245
2262
          if test $ac_prog = install &&
2246
2263
            grep dspmsg "$as_dir/$ac_prog$ac_exec_ext" >/dev/null 2>&1; then
2247
2264
            # AIX install.  It has an incompatible calling convention.
2324
2341
  test -z "$as_dir" && as_dir=.
2325
2342
  for ac_prog in mkdir gmkdir; do
2326
2343
         for ac_exec_ext in '' $ac_executable_extensions; do
2327
 
           { test -f "$as_dir/$ac_prog$ac_exec_ext" && $as_executable_p "$as_dir/$ac_prog$ac_exec_ext"; } || continue
 
2344
           { test -f "$as_dir/$ac_prog$ac_exec_ext" && $as_test_x "$as_dir/$ac_prog$ac_exec_ext"; } || continue
2328
2345
           case `"$as_dir/$ac_prog$ac_exec_ext" --version 2>&1` in #(
2329
2346
             'mkdir (GNU coreutils) '* | \
2330
2347
             'mkdir (coreutils) '* | \
2377
2394
  IFS=$as_save_IFS
2378
2395
  test -z "$as_dir" && as_dir=.
2379
2396
  for ac_exec_ext in '' $ac_executable_extensions; do
2380
 
  if { test -f "$as_dir/$ac_word$ac_exec_ext" && $as_executable_p "$as_dir/$ac_word$ac_exec_ext"; }; then
 
2397
  if { test -f "$as_dir/$ac_word$ac_exec_ext" && $as_test_x "$as_dir/$ac_word$ac_exec_ext"; }; then
2381
2398
    ac_cv_prog_AWK="$ac_prog"
2382
2399
    echo "$as_me:$LINENO: found $as_dir/$ac_word$ac_exec_ext" >&5
2383
2400
    break 2
2464
2481
 
2465
2482
# Define the identity of the package.
2466
2483
 PACKAGE='lcms'
2467
 
 VERSION='1.16'
 
2484
 VERSION='1.17'
2468
2485
 
2469
2486
 
2470
2487
# Some tools Automake needs.
2507
2524
  IFS=$as_save_IFS
2508
2525
  test -z "$as_dir" && as_dir=.
2509
2526
  for ac_exec_ext in '' $ac_executable_extensions; do
2510
 
  if { test -f "$as_dir/$ac_word$ac_exec_ext" && $as_executable_p "$as_dir/$ac_word$ac_exec_ext"; }; then
 
2527
  if { test -f "$as_dir/$ac_word$ac_exec_ext" && $as_test_x "$as_dir/$ac_word$ac_exec_ext"; }; then
2511
2528
    ac_cv_prog_STRIP="${ac_tool_prefix}strip"
2512
2529
    echo "$as_me:$LINENO: found $as_dir/$ac_word$ac_exec_ext" >&5
2513
2530
    break 2
2547
2564
  IFS=$as_save_IFS
2548
2565
  test -z "$as_dir" && as_dir=.
2549
2566
  for ac_exec_ext in '' $ac_executable_extensions; do
2550
 
  if { test -f "$as_dir/$ac_word$ac_exec_ext" && $as_executable_p "$as_dir/$ac_word$ac_exec_ext"; }; then
 
2567
  if { test -f "$as_dir/$ac_word$ac_exec_ext" && $as_test_x "$as_dir/$ac_word$ac_exec_ext"; }; then
2551
2568
    ac_cv_prog_ac_ct_STRIP="strip"
2552
2569
    echo "$as_me:$LINENO: found $as_dir/$ac_word$ac_exec_ext" >&5
2553
2570
    break 2
2665
2682
  IFS=$as_save_IFS
2666
2683
  test -z "$as_dir" && as_dir=.
2667
2684
  for ac_exec_ext in '' $ac_executable_extensions; do
2668
 
  if { test -f "$as_dir/$ac_word$ac_exec_ext" && $as_executable_p "$as_dir/$ac_word$ac_exec_ext"; }; then
 
2685
  if { test -f "$as_dir/$ac_word$ac_exec_ext" && $as_test_x "$as_dir/$ac_word$ac_exec_ext"; }; then
2669
2686
    ac_cv_prog_CC="${ac_tool_prefix}gcc"
2670
2687
    echo "$as_me:$LINENO: found $as_dir/$ac_word$ac_exec_ext" >&5
2671
2688
    break 2
2705
2722
  IFS=$as_save_IFS
2706
2723
  test -z "$as_dir" && as_dir=.
2707
2724
  for ac_exec_ext in '' $ac_executable_extensions; do
2708
 
  if { test -f "$as_dir/$ac_word$ac_exec_ext" && $as_executable_p "$as_dir/$ac_word$ac_exec_ext"; }; then
 
2725
  if { test -f "$as_dir/$ac_word$ac_exec_ext" && $as_test_x "$as_dir/$ac_word$ac_exec_ext"; }; then
2709
2726
    ac_cv_prog_ac_ct_CC="gcc"
2710
2727
    echo "$as_me:$LINENO: found $as_dir/$ac_word$ac_exec_ext" >&5
2711
2728
    break 2
2762
2779
  IFS=$as_save_IFS
2763
2780
  test -z "$as_dir" && as_dir=.
2764
2781
  for ac_exec_ext in '' $ac_executable_extensions; do
2765
 
  if { test -f "$as_dir/$ac_word$ac_exec_ext" && $as_executable_p "$as_dir/$ac_word$ac_exec_ext"; }; then
 
2782
  if { test -f "$as_dir/$ac_word$ac_exec_ext" && $as_test_x "$as_dir/$ac_word$ac_exec_ext"; }; then
2766
2783
    ac_cv_prog_CC="${ac_tool_prefix}cc"
2767
2784
    echo "$as_me:$LINENO: found $as_dir/$ac_word$ac_exec_ext" >&5
2768
2785
    break 2
2803
2820
  IFS=$as_save_IFS
2804
2821
  test -z "$as_dir" && as_dir=.
2805
2822
  for ac_exec_ext in '' $ac_executable_extensions; do
2806
 
  if { test -f "$as_dir/$ac_word$ac_exec_ext" && $as_executable_p "$as_dir/$ac_word$ac_exec_ext"; }; then
 
2823
  if { test -f "$as_dir/$ac_word$ac_exec_ext" && $as_test_x "$as_dir/$ac_word$ac_exec_ext"; }; then
2807
2824
    if test "$as_dir/$ac_word$ac_exec_ext" = "/usr/ucb/cc"; then
2808
2825
       ac_prog_rejected=yes
2809
2826
       continue
2861
2878
  IFS=$as_save_IFS
2862
2879
  test -z "$as_dir" && as_dir=.
2863
2880
  for ac_exec_ext in '' $ac_executable_extensions; do
2864
 
  if { test -f "$as_dir/$ac_word$ac_exec_ext" && $as_executable_p "$as_dir/$ac_word$ac_exec_ext"; }; then
 
2881
  if { test -f "$as_dir/$ac_word$ac_exec_ext" && $as_test_x "$as_dir/$ac_word$ac_exec_ext"; }; then
2865
2882
    ac_cv_prog_CC="$ac_tool_prefix$ac_prog"
2866
2883
    echo "$as_me:$LINENO: found $as_dir/$ac_word$ac_exec_ext" >&5
2867
2884
    break 2
2905
2922
  IFS=$as_save_IFS
2906
2923
  test -z "$as_dir" && as_dir=.
2907
2924
  for ac_exec_ext in '' $ac_executable_extensions; do
2908
 
  if { test -f "$as_dir/$ac_word$ac_exec_ext" && $as_executable_p "$as_dir/$ac_word$ac_exec_ext"; }; then
 
2925
  if { test -f "$as_dir/$ac_word$ac_exec_ext" && $as_test_x "$as_dir/$ac_word$ac_exec_ext"; }; then
2909
2926
    ac_cv_prog_ac_ct_CC="$ac_prog"
2910
2927
    echo "$as_me:$LINENO: found $as_dir/$ac_word$ac_exec_ext" >&5
2911
2928
    break 2
3046
3063
# in a Makefile.  We should not override ac_cv_exeext if it was cached,
3047
3064
# so that the user can short-circuit this test for compilers unknown to
3048
3065
# Autoconf.
3049
 
for ac_file in $ac_files
 
3066
for ac_file in $ac_files ''
3050
3067
do
3051
3068
  test -f "$ac_file" || continue
3052
3069
  case $ac_file in
3074
3091
test "$ac_cv_exeext" = no && ac_cv_exeext=
3075
3092
 
3076
3093
else
 
3094
  ac_file=''
 
3095
fi
 
3096
 
 
3097
{ echo "$as_me:$LINENO: result: $ac_file" >&5
 
3098
echo "${ECHO_T}$ac_file" >&6; }
 
3099
if test -z "$ac_file"; then
3077
3100
  echo "$as_me: failed program was:" >&5
3078
3101
sed 's/^/| /' conftest.$ac_ext >&5
3079
3102
 
3085
3108
fi
3086
3109
 
3087
3110
ac_exeext=$ac_cv_exeext
3088
 
{ echo "$as_me:$LINENO: result: $ac_file" >&5
3089
 
echo "${ECHO_T}$ac_file" >&6; }
3090
3111
 
3091
3112
# Check that the compiler produces executables we can run.  If not, either
3092
3113
# the compiler is broken, or we cross compile.
3264
3285
  rm -f conftest.er1
3265
3286
  cat conftest.err >&5
3266
3287
  echo "$as_me:$LINENO: \$? = $ac_status" >&5
3267
 
  (exit $ac_status); } &&
3268
 
         { ac_try='test -z "$ac_c_werror_flag" || test ! -s conftest.err'
3269
 
  { (case "(($ac_try" in
3270
 
  *\"* | *\`* | *\\*) ac_try_echo=\$ac_try;;
3271
 
  *) ac_try_echo=$ac_try;;
3272
 
esac
3273
 
eval "echo \"\$as_me:$LINENO: $ac_try_echo\"") >&5
3274
 
  (eval "$ac_try") 2>&5
3275
 
  ac_status=$?
3276
 
  echo "$as_me:$LINENO: \$? = $ac_status" >&5
3277
 
  (exit $ac_status); }; } &&
3278
 
         { ac_try='test -s conftest.$ac_objext'
3279
 
  { (case "(($ac_try" in
3280
 
  *\"* | *\`* | *\\*) ac_try_echo=\$ac_try;;
3281
 
  *) ac_try_echo=$ac_try;;
3282
 
esac
3283
 
eval "echo \"\$as_me:$LINENO: $ac_try_echo\"") >&5
3284
 
  (eval "$ac_try") 2>&5
3285
 
  ac_status=$?
3286
 
  echo "$as_me:$LINENO: \$? = $ac_status" >&5
3287
 
  (exit $ac_status); }; }; then
 
3288
  (exit $ac_status); } && {
 
3289
         test -z "$ac_c_werror_flag" ||
 
3290
         test ! -s conftest.err
 
3291
       } && test -s conftest.$ac_objext; then
3288
3292
  ac_compiler_gnu=yes
3289
3293
else
3290
3294
  echo "$as_me: failed program was:" >&5
3339
3343
  rm -f conftest.er1
3340
3344
  cat conftest.err >&5
3341
3345
  echo "$as_me:$LINENO: \$? = $ac_status" >&5
3342
 
  (exit $ac_status); } &&
3343
 
         { ac_try='test -z "$ac_c_werror_flag" || test ! -s conftest.err'
3344
 
  { (case "(($ac_try" in
3345
 
  *\"* | *\`* | *\\*) ac_try_echo=\$ac_try;;
3346
 
  *) ac_try_echo=$ac_try;;
3347
 
esac
3348
 
eval "echo \"\$as_me:$LINENO: $ac_try_echo\"") >&5
3349
 
  (eval "$ac_try") 2>&5
3350
 
  ac_status=$?
3351
 
  echo "$as_me:$LINENO: \$? = $ac_status" >&5
3352
 
  (exit $ac_status); }; } &&
3353
 
         { ac_try='test -s conftest.$ac_objext'
3354
 
  { (case "(($ac_try" in
3355
 
  *\"* | *\`* | *\\*) ac_try_echo=\$ac_try;;
3356
 
  *) ac_try_echo=$ac_try;;
3357
 
esac
3358
 
eval "echo \"\$as_me:$LINENO: $ac_try_echo\"") >&5
3359
 
  (eval "$ac_try") 2>&5
3360
 
  ac_status=$?
3361
 
  echo "$as_me:$LINENO: \$? = $ac_status" >&5
3362
 
  (exit $ac_status); }; }; then
 
3346
  (exit $ac_status); } && {
 
3347
         test -z "$ac_c_werror_flag" ||
 
3348
         test ! -s conftest.err
 
3349
       } && test -s conftest.$ac_objext; then
3363
3350
  ac_cv_prog_cc_g=yes
3364
3351
else
3365
3352
  echo "$as_me: failed program was:" >&5
3394
3381
  rm -f conftest.er1
3395
3382
  cat conftest.err >&5
3396
3383
  echo "$as_me:$LINENO: \$? = $ac_status" >&5
3397
 
  (exit $ac_status); } &&
3398
 
         { ac_try='test -z "$ac_c_werror_flag" || test ! -s conftest.err'
3399
 
  { (case "(($ac_try" in
3400
 
  *\"* | *\`* | *\\*) ac_try_echo=\$ac_try;;
3401
 
  *) ac_try_echo=$ac_try;;
3402
 
esac
3403
 
eval "echo \"\$as_me:$LINENO: $ac_try_echo\"") >&5
3404
 
  (eval "$ac_try") 2>&5
3405
 
  ac_status=$?
3406
 
  echo "$as_me:$LINENO: \$? = $ac_status" >&5
3407
 
  (exit $ac_status); }; } &&
3408
 
         { ac_try='test -s conftest.$ac_objext'
3409
 
  { (case "(($ac_try" in
3410
 
  *\"* | *\`* | *\\*) ac_try_echo=\$ac_try;;
3411
 
  *) ac_try_echo=$ac_try;;
3412
 
esac
3413
 
eval "echo \"\$as_me:$LINENO: $ac_try_echo\"") >&5
3414
 
  (eval "$ac_try") 2>&5
3415
 
  ac_status=$?
3416
 
  echo "$as_me:$LINENO: \$? = $ac_status" >&5
3417
 
  (exit $ac_status); }; }; then
 
3384
  (exit $ac_status); } && {
 
3385
         test -z "$ac_c_werror_flag" ||
 
3386
         test ! -s conftest.err
 
3387
       } && test -s conftest.$ac_objext; then
3418
3388
  :
3419
3389
else
3420
3390
  echo "$as_me: failed program was:" >&5
3450
3420
  rm -f conftest.er1
3451
3421
  cat conftest.err >&5
3452
3422
  echo "$as_me:$LINENO: \$? = $ac_status" >&5
3453
 
  (exit $ac_status); } &&
3454
 
         { ac_try='test -z "$ac_c_werror_flag" || test ! -s conftest.err'
3455
 
  { (case "(($ac_try" in
3456
 
  *\"* | *\`* | *\\*) ac_try_echo=\$ac_try;;
3457
 
  *) ac_try_echo=$ac_try;;
3458
 
esac
3459
 
eval "echo \"\$as_me:$LINENO: $ac_try_echo\"") >&5
3460
 
  (eval "$ac_try") 2>&5
3461
 
  ac_status=$?
3462
 
  echo "$as_me:$LINENO: \$? = $ac_status" >&5
3463
 
  (exit $ac_status); }; } &&
3464
 
         { ac_try='test -s conftest.$ac_objext'
3465
 
  { (case "(($ac_try" in
3466
 
  *\"* | *\`* | *\\*) ac_try_echo=\$ac_try;;
3467
 
  *) ac_try_echo=$ac_try;;
3468
 
esac
3469
 
eval "echo \"\$as_me:$LINENO: $ac_try_echo\"") >&5
3470
 
  (eval "$ac_try") 2>&5
3471
 
  ac_status=$?
3472
 
  echo "$as_me:$LINENO: \$? = $ac_status" >&5
3473
 
  (exit $ac_status); }; }; then
 
3423
  (exit $ac_status); } && {
 
3424
         test -z "$ac_c_werror_flag" ||
 
3425
         test ! -s conftest.err
 
3426
       } && test -s conftest.$ac_objext; then
3474
3427
  ac_cv_prog_cc_g=yes
3475
3428
else
3476
3429
  echo "$as_me: failed program was:" >&5
3586
3539
  rm -f conftest.er1
3587
3540
  cat conftest.err >&5
3588
3541
  echo "$as_me:$LINENO: \$? = $ac_status" >&5
3589
 
  (exit $ac_status); } &&
3590
 
         { ac_try='test -z "$ac_c_werror_flag" || test ! -s conftest.err'
3591
 
  { (case "(($ac_try" in
3592
 
  *\"* | *\`* | *\\*) ac_try_echo=\$ac_try;;
3593
 
  *) ac_try_echo=$ac_try;;
3594
 
esac
3595
 
eval "echo \"\$as_me:$LINENO: $ac_try_echo\"") >&5
3596
 
  (eval "$ac_try") 2>&5
3597
 
  ac_status=$?
3598
 
  echo "$as_me:$LINENO: \$? = $ac_status" >&5
3599
 
  (exit $ac_status); }; } &&
3600
 
         { ac_try='test -s conftest.$ac_objext'
3601
 
  { (case "(($ac_try" in
3602
 
  *\"* | *\`* | *\\*) ac_try_echo=\$ac_try;;
3603
 
  *) ac_try_echo=$ac_try;;
3604
 
esac
3605
 
eval "echo \"\$as_me:$LINENO: $ac_try_echo\"") >&5
3606
 
  (eval "$ac_try") 2>&5
3607
 
  ac_status=$?
3608
 
  echo "$as_me:$LINENO: \$? = $ac_status" >&5
3609
 
  (exit $ac_status); }; }; then
 
3542
  (exit $ac_status); } && {
 
3543
         test -z "$ac_c_werror_flag" ||
 
3544
         test ! -s conftest.err
 
3545
       } && test -s conftest.$ac_objext; then
3610
3546
  ac_cv_prog_cc_c89=$ac_arg
3611
3547
else
3612
3548
  echo "$as_me: failed program was:" >&5
3834
3770
#include <wchar.h>
3835
3771
#include <stdio.h>
3836
3772
 
 
3773
// Check varargs macros.  These examples are taken from C99 6.10.3.5.
 
3774
#define debug(...) fprintf (stderr, __VA_ARGS__)
 
3775
#define showlist(...) puts (#__VA_ARGS__)
 
3776
#define report(test,...) ((test) ? puts (#test) : printf (__VA_ARGS__))
 
3777
static void
 
3778
test_varargs_macros (void)
 
3779
{
 
3780
  int x = 1234;
 
3781
  int y = 5678;
 
3782
  debug ("Flag");
 
3783
  debug ("X = %d\n", x);
 
3784
  showlist (The first, second, and third items.);
 
3785
  report (x>y, "x is %d but y is %d", x, y);
 
3786
}
 
3787
 
 
3788
// Check long long types.
 
3789
#define BIG64 18446744073709551615ull
 
3790
#define BIG32 4294967295ul
 
3791
#define BIG_OK (BIG64 / BIG32 == 4294967297ull && BIG64 % BIG32 == 0)
 
3792
#if !BIG_OK
 
3793
  your preprocessor is broken;
 
3794
#endif
 
3795
#if BIG_OK
 
3796
#else
 
3797
  your preprocessor is broken;
 
3798
#endif
 
3799
static long long int bignum = -9223372036854775807LL;
 
3800
static unsigned long long int ubignum = BIG64;
 
3801
 
3837
3802
struct incomplete_array
3838
3803
{
3839
3804
  int datasize;
3849
3814
typedef const char *ccp;
3850
3815
 
3851
3816
static inline int
3852
 
test_restrict(ccp restrict text)
 
3817
test_restrict (ccp restrict text)
3853
3818
{
3854
3819
  // See if C++-style comments work.
3855
3820
  // Iterate through items via the restricted pointer.
3859
3824
  return 0;
3860
3825
}
3861
3826
 
3862
 
// Check varargs and va_copy work.
 
3827
// Check varargs and va_copy.
3863
3828
static void
3864
 
test_varargs(const char *format, ...)
 
3829
test_varargs (const char *format, ...)
3865
3830
{
3866
3831
  va_list args;
3867
 
  va_start(args, format);
 
3832
  va_start (args, format);
3868
3833
  va_list args_copy;
3869
 
  va_copy(args_copy, args);
 
3834
  va_copy (args_copy, args);
3870
3835
 
3871
3836
  const char *str;
3872
3837
  int number;
3877
3842
      switch (*format++)
3878
3843
        {
3879
3844
        case 's': // string
3880
 
          str = va_arg(args_copy, const char *);
 
3845
          str = va_arg (args_copy, const char *);
3881
3846
          break;
3882
3847
        case 'd': // int
3883
 
          number = va_arg(args_copy, int);
 
3848
          number = va_arg (args_copy, int);
3884
3849
          break;
3885
3850
        case 'f': // float
3886
 
          fnumber = (float) va_arg(args_copy, double);
 
3851
          fnumber = va_arg (args_copy, double);
3887
3852
          break;
3888
3853
        default:
3889
3854
          break;
3890
3855
        }
3891
3856
    }
3892
 
  va_end(args_copy);
3893
 
  va_end(args);
 
3857
  va_end (args_copy);
 
3858
  va_end (args);
3894
3859
}
3895
3860
 
3896
3861
int
3897
3862
main ()
3898
3863
{
3899
3864
 
3900
 
  // Check bool and long long datatypes.
 
3865
  // Check bool.
3901
3866
  _Bool success = false;
3902
 
  long long int bignum = -1234567890LL;
3903
 
  unsigned long long int ubignum = 1234567890uLL;
3904
3867
 
3905
3868
  // Check restrict.
3906
 
  if (test_restrict("String literal") != 0)
 
3869
  if (test_restrict ("String literal") == 0)
3907
3870
    success = true;
3908
3871
  char *restrict newvar = "Another string";
3909
3872
 
3910
3873
  // Check varargs.
3911
 
  test_varargs("s, d' f .", "string", 65, 34.234);
 
3874
  test_varargs ("s, d' f .", "string", 65, 34.234);
 
3875
  test_varargs_macros ();
3912
3876
 
3913
 
  // Check incomplete arrays work.
 
3877
  // Check flexible array members.
3914
3878
  struct incomplete_array *ia =
3915
 
    malloc(sizeof(struct incomplete_array) + (sizeof(double) * 10));
 
3879
    malloc (sizeof (struct incomplete_array) + (sizeof (double) * 10));
3916
3880
  ia->datasize = 10;
3917
3881
  for (int i = 0; i < ia->datasize; ++i)
3918
 
    ia->data[i] = (double) i * 1.234;
 
3882
    ia->data[i] = i * 1.234;
3919
3883
 
3920
 
  // Check named initialisers.
 
3884
  // Check named initializers.
3921
3885
  struct named_init ni = {
3922
3886
    .number = 34,
3923
3887
    .name = L"Test wide string",
3927
3891
  ni.number = 58;
3928
3892
 
3929
3893
  int dynamic_array[ni.number];
3930
 
  dynamic_array[43] = 543;
 
3894
  dynamic_array[ni.number - 1] = 543;
3931
3895
 
3932
3896
  // work around unused variable warnings
3933
 
  return  bignum == 0LL || ubignum == 0uLL || newvar[0] == 'x';
 
3897
  return (!success || bignum == 0LL || ubignum == 0uLL || newvar[0] == 'x'
 
3898
          || dynamic_array[ni.number - 1] != 543);
3934
3899
 
3935
3900
  ;
3936
3901
  return 0;
3952
3917
  rm -f conftest.er1
3953
3918
  cat conftest.err >&5
3954
3919
  echo "$as_me:$LINENO: \$? = $ac_status" >&5
3955
 
  (exit $ac_status); } &&
3956
 
         { ac_try='test -z "$ac_c_werror_flag" || test ! -s conftest.err'
3957
 
  { (case "(($ac_try" in
3958
 
  *\"* | *\`* | *\\*) ac_try_echo=\$ac_try;;
3959
 
  *) ac_try_echo=$ac_try;;
3960
 
esac
3961
 
eval "echo \"\$as_me:$LINENO: $ac_try_echo\"") >&5
3962
 
  (eval "$ac_try") 2>&5
3963
 
  ac_status=$?
3964
 
  echo "$as_me:$LINENO: \$? = $ac_status" >&5
3965
 
  (exit $ac_status); }; } &&
3966
 
         { ac_try='test -s conftest.$ac_objext'
3967
 
  { (case "(($ac_try" in
3968
 
  *\"* | *\`* | *\\*) ac_try_echo=\$ac_try;;
3969
 
  *) ac_try_echo=$ac_try;;
3970
 
esac
3971
 
eval "echo \"\$as_me:$LINENO: $ac_try_echo\"") >&5
3972
 
  (eval "$ac_try") 2>&5
3973
 
  ac_status=$?
3974
 
  echo "$as_me:$LINENO: \$? = $ac_status" >&5
3975
 
  (exit $ac_status); }; }; then
 
3920
  (exit $ac_status); } && {
 
3921
         test -z "$ac_c_werror_flag" ||
 
3922
         test ! -s conftest.err
 
3923
       } && test -s conftest.$ac_objext; then
3976
3924
  ac_cv_prog_cc_c99=$ac_arg
3977
3925
else
3978
3926
  echo "$as_me: failed program was:" >&5
4085
4033
  rm -f conftest.er1
4086
4034
  cat conftest.err >&5
4087
4035
  echo "$as_me:$LINENO: \$? = $ac_status" >&5
4088
 
  (exit $ac_status); } &&
4089
 
         { ac_try='test -z "$ac_c_werror_flag" || test ! -s conftest.err'
4090
 
  { (case "(($ac_try" in
4091
 
  *\"* | *\`* | *\\*) ac_try_echo=\$ac_try;;
4092
 
  *) ac_try_echo=$ac_try;;
4093
 
esac
4094
 
eval "echo \"\$as_me:$LINENO: $ac_try_echo\"") >&5
4095
 
  (eval "$ac_try") 2>&5
4096
 
  ac_status=$?
4097
 
  echo "$as_me:$LINENO: \$? = $ac_status" >&5
4098
 
  (exit $ac_status); }; } &&
4099
 
         { ac_try='test -s conftest.$ac_objext'
4100
 
  { (case "(($ac_try" in
4101
 
  *\"* | *\`* | *\\*) ac_try_echo=\$ac_try;;
4102
 
  *) ac_try_echo=$ac_try;;
4103
 
esac
4104
 
eval "echo \"\$as_me:$LINENO: $ac_try_echo\"") >&5
4105
 
  (eval "$ac_try") 2>&5
4106
 
  ac_status=$?
4107
 
  echo "$as_me:$LINENO: \$? = $ac_status" >&5
4108
 
  (exit $ac_status); }; }; then
 
4036
  (exit $ac_status); } && {
 
4037
         test -z "$ac_c_werror_flag" ||
 
4038
         test ! -s conftest.err
 
4039
       } && test -s conftest.$ac_objext; then
4109
4040
  ac_cv_prog_cc_c89=$ac_arg
4110
4041
else
4111
4042
  echo "$as_me: failed program was:" >&5
4213
4144
  rm -f conftest.er1
4214
4145
  cat conftest.err >&5
4215
4146
  echo "$as_me:$LINENO: \$? = $ac_status" >&5
4216
 
  (exit $ac_status); } >/dev/null; then
4217
 
  if test -s conftest.err; then
4218
 
    ac_cpp_err=$ac_c_preproc_warn_flag
4219
 
    ac_cpp_err=$ac_cpp_err$ac_c_werror_flag
4220
 
  else
4221
 
    ac_cpp_err=
4222
 
  fi
4223
 
else
4224
 
  ac_cpp_err=yes
4225
 
fi
4226
 
if test -z "$ac_cpp_err"; then
 
4147
  (exit $ac_status); } >/dev/null && {
 
4148
         test -z "$ac_c_preproc_warn_flag$ac_c_werror_flag" ||
 
4149
         test ! -s conftest.err
 
4150
       }; then
4227
4151
  :
4228
4152
else
4229
4153
  echo "$as_me: failed program was:" >&5
4257
4181
  rm -f conftest.er1
4258
4182
  cat conftest.err >&5
4259
4183
  echo "$as_me:$LINENO: \$? = $ac_status" >&5
4260
 
  (exit $ac_status); } >/dev/null; then
4261
 
  if test -s conftest.err; then
4262
 
    ac_cpp_err=$ac_c_preproc_warn_flag
4263
 
    ac_cpp_err=$ac_cpp_err$ac_c_werror_flag
4264
 
  else
4265
 
    ac_cpp_err=
4266
 
  fi
4267
 
else
4268
 
  ac_cpp_err=yes
4269
 
fi
4270
 
if test -z "$ac_cpp_err"; then
 
4184
  (exit $ac_status); } >/dev/null && {
 
4185
         test -z "$ac_c_preproc_warn_flag$ac_c_werror_flag" ||
 
4186
         test ! -s conftest.err
 
4187
       }; then
4271
4188
  # Broken: success on invalid input.
4272
4189
continue
4273
4190
else
4332
4249
  rm -f conftest.er1
4333
4250
  cat conftest.err >&5
4334
4251
  echo "$as_me:$LINENO: \$? = $ac_status" >&5
4335
 
  (exit $ac_status); } >/dev/null; then
4336
 
  if test -s conftest.err; then
4337
 
    ac_cpp_err=$ac_c_preproc_warn_flag
4338
 
    ac_cpp_err=$ac_cpp_err$ac_c_werror_flag
4339
 
  else
4340
 
    ac_cpp_err=
4341
 
  fi
4342
 
else
4343
 
  ac_cpp_err=yes
4344
 
fi
4345
 
if test -z "$ac_cpp_err"; then
 
4252
  (exit $ac_status); } >/dev/null && {
 
4253
         test -z "$ac_c_preproc_warn_flag$ac_c_werror_flag" ||
 
4254
         test ! -s conftest.err
 
4255
       }; then
4346
4256
  :
4347
4257
else
4348
4258
  echo "$as_me: failed program was:" >&5
4376
4286
  rm -f conftest.er1
4377
4287
  cat conftest.err >&5
4378
4288
  echo "$as_me:$LINENO: \$? = $ac_status" >&5
4379
 
  (exit $ac_status); } >/dev/null; then
4380
 
  if test -s conftest.err; then
4381
 
    ac_cpp_err=$ac_c_preproc_warn_flag
4382
 
    ac_cpp_err=$ac_cpp_err$ac_c_werror_flag
4383
 
  else
4384
 
    ac_cpp_err=
4385
 
  fi
4386
 
else
4387
 
  ac_cpp_err=yes
4388
 
fi
4389
 
if test -z "$ac_cpp_err"; then
 
4289
  (exit $ac_status); } >/dev/null && {
 
4290
         test -z "$ac_c_preproc_warn_flag$ac_c_werror_flag" ||
 
4291
         test ! -s conftest.err
 
4292
       }; then
4390
4293
  # Broken: success on invalid input.
4391
4294
continue
4392
4295
else
4499
4402
  for ac_prog in grep ggrep; do
4500
4403
  for ac_exec_ext in '' $ac_executable_extensions; do
4501
4404
    ac_path_GREP="$as_dir/$ac_prog$ac_exec_ext"
4502
 
    { test -f "$ac_path_GREP" && $as_executable_p "$ac_path_GREP"; } || continue
 
4405
    { test -f "$ac_path_GREP" && $as_test_x "$ac_path_GREP"; } || continue
4503
4406
    # Check for GNU ac_path_GREP and select it if it is found.
4504
4407
  # Check for GNU $ac_path_GREP
4505
4408
case `"$ac_path_GREP" --version 2>&1` in
4581
4484
  for ac_prog in egrep; do
4582
4485
  for ac_exec_ext in '' $ac_executable_extensions; do
4583
4486
    ac_path_EGREP="$as_dir/$ac_prog$ac_exec_ext"
4584
 
    { test -f "$ac_path_EGREP" && $as_executable_p "$ac_path_EGREP"; } || continue
 
4487
    { test -f "$ac_path_EGREP" && $as_test_x "$ac_path_EGREP"; } || continue
4585
4488
    # Check for GNU ac_path_EGREP and select it if it is found.
4586
4489
  # Check for GNU $ac_path_EGREP
4587
4490
case `"$ac_path_EGREP" --version 2>&1` in
4784
4687
    # by default.
4785
4688
    for ac_prog in ginstall scoinst install; do
4786
4689
      for ac_exec_ext in '' $ac_executable_extensions; do
4787
 
        if { test -f "$as_dir/$ac_prog$ac_exec_ext" && $as_executable_p "$as_dir/$ac_prog$ac_exec_ext"; }; then
 
4690
        if { test -f "$as_dir/$ac_prog$ac_exec_ext" && $as_test_x "$as_dir/$ac_prog$ac_exec_ext"; }; then
4788
4691
          if test $ac_prog = install &&
4789
4692
            grep dspmsg "$as_dir/$ac_prog$ac_exec_ext" >/dev/null 2>&1; then
4790
4693
            # AIX install.  It has an incompatible calling convention.
4897
4800
  IFS=$as_save_IFS
4898
4801
  test -z "$as_dir" && as_dir=.
4899
4802
  for ac_exec_ext in '' $ac_executable_extensions; do
4900
 
  if { test -f "$as_dir/$ac_word$ac_exec_ext" && $as_executable_p "$as_dir/$ac_word$ac_exec_ext"; }; then
 
4803
  if { test -f "$as_dir/$ac_word$ac_exec_ext" && $as_test_x "$as_dir/$ac_word$ac_exec_ext"; }; then
4901
4804
    ac_cv_prog_CXX="$ac_tool_prefix$ac_prog"
4902
4805
    echo "$as_me:$LINENO: found $as_dir/$ac_word$ac_exec_ext" >&5
4903
4806
    break 2
4941
4844
  IFS=$as_save_IFS
4942
4845
  test -z "$as_dir" && as_dir=.
4943
4846
  for ac_exec_ext in '' $ac_executable_extensions; do
4944
 
  if { test -f "$as_dir/$ac_word$ac_exec_ext" && $as_executable_p "$as_dir/$ac_word$ac_exec_ext"; }; then
 
4847
  if { test -f "$as_dir/$ac_word$ac_exec_ext" && $as_test_x "$as_dir/$ac_word$ac_exec_ext"; }; then
4945
4848
    ac_cv_prog_ac_ct_CXX="$ac_prog"
4946
4849
    echo "$as_me:$LINENO: found $as_dir/$ac_word$ac_exec_ext" >&5
4947
4850
    break 2
5054
4957
  rm -f conftest.er1
5055
4958
  cat conftest.err >&5
5056
4959
  echo "$as_me:$LINENO: \$? = $ac_status" >&5
5057
 
  (exit $ac_status); } &&
5058
 
         { ac_try='test -z "$ac_cxx_werror_flag" || test ! -s conftest.err'
5059
 
  { (case "(($ac_try" in
5060
 
  *\"* | *\`* | *\\*) ac_try_echo=\$ac_try;;
5061
 
  *) ac_try_echo=$ac_try;;
5062
 
esac
5063
 
eval "echo \"\$as_me:$LINENO: $ac_try_echo\"") >&5
5064
 
  (eval "$ac_try") 2>&5
5065
 
  ac_status=$?
5066
 
  echo "$as_me:$LINENO: \$? = $ac_status" >&5
5067
 
  (exit $ac_status); }; } &&
5068
 
         { ac_try='test -s conftest.$ac_objext'
5069
 
  { (case "(($ac_try" in
5070
 
  *\"* | *\`* | *\\*) ac_try_echo=\$ac_try;;
5071
 
  *) ac_try_echo=$ac_try;;
5072
 
esac
5073
 
eval "echo \"\$as_me:$LINENO: $ac_try_echo\"") >&5
5074
 
  (eval "$ac_try") 2>&5
5075
 
  ac_status=$?
5076
 
  echo "$as_me:$LINENO: \$? = $ac_status" >&5
5077
 
  (exit $ac_status); }; }; then
 
4960
  (exit $ac_status); } && {
 
4961
         test -z "$ac_cxx_werror_flag" ||
 
4962
         test ! -s conftest.err
 
4963
       } && test -s conftest.$ac_objext; then
5078
4964
  ac_compiler_gnu=yes
5079
4965
else
5080
4966
  echo "$as_me: failed program was:" >&5
5129
5015
  rm -f conftest.er1
5130
5016
  cat conftest.err >&5
5131
5017
  echo "$as_me:$LINENO: \$? = $ac_status" >&5
5132
 
  (exit $ac_status); } &&
5133
 
         { ac_try='test -z "$ac_cxx_werror_flag" || test ! -s conftest.err'
5134
 
  { (case "(($ac_try" in
5135
 
  *\"* | *\`* | *\\*) ac_try_echo=\$ac_try;;
5136
 
  *) ac_try_echo=$ac_try;;
5137
 
esac
5138
 
eval "echo \"\$as_me:$LINENO: $ac_try_echo\"") >&5
5139
 
  (eval "$ac_try") 2>&5
5140
 
  ac_status=$?
5141
 
  echo "$as_me:$LINENO: \$? = $ac_status" >&5
5142
 
  (exit $ac_status); }; } &&
5143
 
         { ac_try='test -s conftest.$ac_objext'
5144
 
  { (case "(($ac_try" in
5145
 
  *\"* | *\`* | *\\*) ac_try_echo=\$ac_try;;
5146
 
  *) ac_try_echo=$ac_try;;
5147
 
esac
5148
 
eval "echo \"\$as_me:$LINENO: $ac_try_echo\"") >&5
5149
 
  (eval "$ac_try") 2>&5
5150
 
  ac_status=$?
5151
 
  echo "$as_me:$LINENO: \$? = $ac_status" >&5
5152
 
  (exit $ac_status); }; }; then
 
5018
  (exit $ac_status); } && {
 
5019
         test -z "$ac_cxx_werror_flag" ||
 
5020
         test ! -s conftest.err
 
5021
       } && test -s conftest.$ac_objext; then
5153
5022
  ac_cv_prog_cxx_g=yes
5154
5023
else
5155
5024
  echo "$as_me: failed program was:" >&5
5184
5053
  rm -f conftest.er1
5185
5054
  cat conftest.err >&5
5186
5055
  echo "$as_me:$LINENO: \$? = $ac_status" >&5
5187
 
  (exit $ac_status); } &&
5188
 
         { ac_try='test -z "$ac_cxx_werror_flag" || test ! -s conftest.err'
5189
 
  { (case "(($ac_try" in
5190
 
  *\"* | *\`* | *\\*) ac_try_echo=\$ac_try;;
5191
 
  *) ac_try_echo=$ac_try;;
5192
 
esac
5193
 
eval "echo \"\$as_me:$LINENO: $ac_try_echo\"") >&5
5194
 
  (eval "$ac_try") 2>&5
5195
 
  ac_status=$?
5196
 
  echo "$as_me:$LINENO: \$? = $ac_status" >&5
5197
 
  (exit $ac_status); }; } &&
5198
 
         { ac_try='test -s conftest.$ac_objext'
5199
 
  { (case "(($ac_try" in
5200
 
  *\"* | *\`* | *\\*) ac_try_echo=\$ac_try;;
5201
 
  *) ac_try_echo=$ac_try;;
5202
 
esac
5203
 
eval "echo \"\$as_me:$LINENO: $ac_try_echo\"") >&5
5204
 
  (eval "$ac_try") 2>&5
5205
 
  ac_status=$?
5206
 
  echo "$as_me:$LINENO: \$? = $ac_status" >&5
5207
 
  (exit $ac_status); }; }; then
 
5056
  (exit $ac_status); } && {
 
5057
         test -z "$ac_cxx_werror_flag" ||
 
5058
         test ! -s conftest.err
 
5059
       } && test -s conftest.$ac_objext; then
5208
5060
  :
5209
5061
else
5210
5062
  echo "$as_me: failed program was:" >&5
5240
5092
  rm -f conftest.er1
5241
5093
  cat conftest.err >&5
5242
5094
  echo "$as_me:$LINENO: \$? = $ac_status" >&5
5243
 
  (exit $ac_status); } &&
5244
 
         { ac_try='test -z "$ac_cxx_werror_flag" || test ! -s conftest.err'
5245
 
  { (case "(($ac_try" in
5246
 
  *\"* | *\`* | *\\*) ac_try_echo=\$ac_try;;
5247
 
  *) ac_try_echo=$ac_try;;
5248
 
esac
5249
 
eval "echo \"\$as_me:$LINENO: $ac_try_echo\"") >&5
5250
 
  (eval "$ac_try") 2>&5
5251
 
  ac_status=$?
5252
 
  echo "$as_me:$LINENO: \$? = $ac_status" >&5
5253
 
  (exit $ac_status); }; } &&
5254
 
         { ac_try='test -s conftest.$ac_objext'
5255
 
  { (case "(($ac_try" in
5256
 
  *\"* | *\`* | *\\*) ac_try_echo=\$ac_try;;
5257
 
  *) ac_try_echo=$ac_try;;
5258
 
esac
5259
 
eval "echo \"\$as_me:$LINENO: $ac_try_echo\"") >&5
5260
 
  (eval "$ac_try") 2>&5
5261
 
  ac_status=$?
5262
 
  echo "$as_me:$LINENO: \$? = $ac_status" >&5
5263
 
  (exit $ac_status); }; }; then
 
5095
  (exit $ac_status); } && {
 
5096
         test -z "$ac_cxx_werror_flag" ||
 
5097
         test ! -s conftest.err
 
5098
       } && test -s conftest.$ac_objext; then
5264
5099
  ac_cv_prog_cxx_g=yes
5265
5100
else
5266
5101
  echo "$as_me: failed program was:" >&5
5495
5330
  IFS=$as_save_IFS
5496
5331
  test -z "$as_dir" && as_dir=.
5497
5332
  for ac_exec_ext in '' $ac_executable_extensions; do
5498
 
  if { test -f "$as_dir/$ac_word$ac_exec_ext" && $as_executable_p "$as_dir/$ac_word$ac_exec_ext"; }; then
 
5333
  if { test -f "$as_dir/$ac_word$ac_exec_ext" && $as_test_x "$as_dir/$ac_word$ac_exec_ext"; }; then
5499
5334
    ac_cv_path_PYTHON="$as_dir/$ac_word$ac_exec_ext"
5500
5335
    echo "$as_me:$LINENO: found $as_dir/$ac_word$ac_exec_ext" >&5
5501
5336
    break 2
6039
5874
  ;;
6040
5875
*-*-irix6*)
6041
5876
  # Find out which ABI we are using.
6042
 
  echo '#line 6042 "configure"' > conftest.$ac_ext
 
5877
  echo '#line 5877 "configure"' > conftest.$ac_ext
6043
5878
  if { (eval echo "$as_me:$LINENO: \"$ac_compile\"") >&5
6044
5879
  (eval $ac_compile) 2>&5
6045
5880
  ac_status=$?
6170
6005
  rm -f conftest.er1
6171
6006
  cat conftest.err >&5
6172
6007
  echo "$as_me:$LINENO: \$? = $ac_status" >&5
6173
 
  (exit $ac_status); } &&
6174
 
         { ac_try='test -z "$ac_c_werror_flag" || test ! -s conftest.err'
6175
 
  { (case "(($ac_try" in
6176
 
  *\"* | *\`* | *\\*) ac_try_echo=\$ac_try;;
6177
 
  *) ac_try_echo=$ac_try;;
6178
 
esac
6179
 
eval "echo \"\$as_me:$LINENO: $ac_try_echo\"") >&5
6180
 
  (eval "$ac_try") 2>&5
6181
 
  ac_status=$?
6182
 
  echo "$as_me:$LINENO: \$? = $ac_status" >&5
6183
 
  (exit $ac_status); }; } &&
6184
 
         { ac_try='test -s conftest$ac_exeext'
6185
 
  { (case "(($ac_try" in
6186
 
  *\"* | *\`* | *\\*) ac_try_echo=\$ac_try;;
6187
 
  *) ac_try_echo=$ac_try;;
6188
 
esac
6189
 
eval "echo \"\$as_me:$LINENO: $ac_try_echo\"") >&5
6190
 
  (eval "$ac_try") 2>&5
6191
 
  ac_status=$?
6192
 
  echo "$as_me:$LINENO: \$? = $ac_status" >&5
6193
 
  (exit $ac_status); }; }; then
 
6008
  (exit $ac_status); } && {
 
6009
         test -z "$ac_c_werror_flag" ||
 
6010
         test ! -s conftest.err
 
6011
       } && test -s conftest$ac_exeext &&
 
6012
       $as_test_x conftest$ac_exeext; then
6194
6013
  lt_cv_cc_needs_belf=yes
6195
6014
else
6196
6015
  echo "$as_me: failed program was:" >&5
6199
6018
        lt_cv_cc_needs_belf=no
6200
6019
fi
6201
6020
 
6202
 
rm -f core conftest.err conftest.$ac_objext \
 
6021
rm -f core conftest.err conftest.$ac_objext conftest_ipa8_conftest.oo \
6203
6022
      conftest$ac_exeext conftest.$ac_ext
6204
6023
     ac_ext=c
6205
6024
ac_cpp='$CPP $CPPFLAGS'
6253
6072
  IFS=$as_save_IFS
6254
6073
  test -z "$as_dir" && as_dir=.
6255
6074
  for ac_exec_ext in '' $ac_executable_extensions; do
6256
 
  if { test -f "$as_dir/$ac_word$ac_exec_ext" && $as_executable_p "$as_dir/$ac_word$ac_exec_ext"; }; then
 
6075
  if { test -f "$as_dir/$ac_word$ac_exec_ext" && $as_test_x "$as_dir/$ac_word$ac_exec_ext"; }; then
6257
6076
    ac_cv_prog_DLLTOOL="${ac_tool_prefix}dlltool"
6258
6077
    echo "$as_me:$LINENO: found $as_dir/$ac_word$ac_exec_ext" >&5
6259
6078
    break 2
6293
6112
  IFS=$as_save_IFS
6294
6113
  test -z "$as_dir" && as_dir=.
6295
6114
  for ac_exec_ext in '' $ac_executable_extensions; do
6296
 
  if { test -f "$as_dir/$ac_word$ac_exec_ext" && $as_executable_p "$as_dir/$ac_word$ac_exec_ext"; }; then
 
6115
  if { test -f "$as_dir/$ac_word$ac_exec_ext" && $as_test_x "$as_dir/$ac_word$ac_exec_ext"; }; then
6297
6116
    ac_cv_prog_ac_ct_DLLTOOL="dlltool"
6298
6117
    echo "$as_me:$LINENO: found $as_dir/$ac_word$ac_exec_ext" >&5
6299
6118
    break 2
6349
6168
  IFS=$as_save_IFS
6350
6169
  test -z "$as_dir" && as_dir=.
6351
6170
  for ac_exec_ext in '' $ac_executable_extensions; do
6352
 
  if { test -f "$as_dir/$ac_word$ac_exec_ext" && $as_executable_p "$as_dir/$ac_word$ac_exec_ext"; }; then
 
6171
  if { test -f "$as_dir/$ac_word$ac_exec_ext" && $as_test_x "$as_dir/$ac_word$ac_exec_ext"; }; then
6353
6172
    ac_cv_prog_AS="${ac_tool_prefix}as"
6354
6173
    echo "$as_me:$LINENO: found $as_dir/$ac_word$ac_exec_ext" >&5
6355
6174
    break 2
6389
6208
  IFS=$as_save_IFS
6390
6209
  test -z "$as_dir" && as_dir=.
6391
6210
  for ac_exec_ext in '' $ac_executable_extensions; do
6392
 
  if { test -f "$as_dir/$ac_word$ac_exec_ext" && $as_executable_p "$as_dir/$ac_word$ac_exec_ext"; }; then
 
6211
  if { test -f "$as_dir/$ac_word$ac_exec_ext" && $as_test_x "$as_dir/$ac_word$ac_exec_ext"; }; then
6393
6212
    ac_cv_prog_ac_ct_AS="as"
6394
6213
    echo "$as_me:$LINENO: found $as_dir/$ac_word$ac_exec_ext" >&5
6395
6214
    break 2
6445
6264
  IFS=$as_save_IFS
6446
6265
  test -z "$as_dir" && as_dir=.
6447
6266
  for ac_exec_ext in '' $ac_executable_extensions; do
6448
 
  if { test -f "$as_dir/$ac_word$ac_exec_ext" && $as_executable_p "$as_dir/$ac_word$ac_exec_ext"; }; then
 
6267
  if { test -f "$as_dir/$ac_word$ac_exec_ext" && $as_test_x "$as_dir/$ac_word$ac_exec_ext"; }; then
6449
6268
    ac_cv_prog_OBJDUMP="${ac_tool_prefix}objdump"
6450
6269
    echo "$as_me:$LINENO: found $as_dir/$ac_word$ac_exec_ext" >&5
6451
6270
    break 2
6485
6304
  IFS=$as_save_IFS
6486
6305
  test -z "$as_dir" && as_dir=.
6487
6306
  for ac_exec_ext in '' $ac_executable_extensions; do
6488
 
  if { test -f "$as_dir/$ac_word$ac_exec_ext" && $as_executable_p "$as_dir/$ac_word$ac_exec_ext"; }; then
 
6307
  if { test -f "$as_dir/$ac_word$ac_exec_ext" && $as_test_x "$as_dir/$ac_word$ac_exec_ext"; }; then
6489
6308
    ac_cv_prog_ac_ct_OBJDUMP="objdump"
6490
6309
    echo "$as_me:$LINENO: found $as_dir/$ac_word$ac_exec_ext" >&5
6491
6310
    break 2
6569
6388
  rm -f conftest.er1
6570
6389
  cat conftest.err >&5
6571
6390
  echo "$as_me:$LINENO: \$? = $ac_status" >&5
6572
 
  (exit $ac_status); } &&
6573
 
         { ac_try='test -z "$ac_c_werror_flag" || test ! -s conftest.err'
6574
 
  { (case "(($ac_try" in
6575
 
  *\"* | *\`* | *\\*) ac_try_echo=\$ac_try;;
6576
 
  *) ac_try_echo=$ac_try;;
6577
 
esac
6578
 
eval "echo \"\$as_me:$LINENO: $ac_try_echo\"") >&5
6579
 
  (eval "$ac_try") 2>&5
6580
 
  ac_status=$?
6581
 
  echo "$as_me:$LINENO: \$? = $ac_status" >&5
6582
 
  (exit $ac_status); }; } &&
6583
 
         { ac_try='test -s conftest.$ac_objext'
6584
 
  { (case "(($ac_try" in
6585
 
  *\"* | *\`* | *\\*) ac_try_echo=\$ac_try;;
6586
 
  *) ac_try_echo=$ac_try;;
6587
 
esac
6588
 
eval "echo \"\$as_me:$LINENO: $ac_try_echo\"") >&5
6589
 
  (eval "$ac_try") 2>&5
6590
 
  ac_status=$?
6591
 
  echo "$as_me:$LINENO: \$? = $ac_status" >&5
6592
 
  (exit $ac_status); }; }; then
 
6391
  (exit $ac_status); } && {
 
6392
         test -z "$ac_c_werror_flag" ||
 
6393
         test ! -s conftest.err
 
6394
       } && test -s conftest.$ac_objext; then
6593
6395
  ac_cv_header_stdc=yes
6594
6396
else
6595
6397
  echo "$as_me: failed program was:" >&5
6765
6567
  rm -f conftest.er1
6766
6568
  cat conftest.err >&5
6767
6569
  echo "$as_me:$LINENO: \$? = $ac_status" >&5
6768
 
  (exit $ac_status); } &&
6769
 
         { ac_try='test -z "$ac_c_werror_flag" || test ! -s conftest.err'
6770
 
  { (case "(($ac_try" in
6771
 
  *\"* | *\`* | *\\*) ac_try_echo=\$ac_try;;
6772
 
  *) ac_try_echo=$ac_try;;
6773
 
esac
6774
 
eval "echo \"\$as_me:$LINENO: $ac_try_echo\"") >&5
6775
 
  (eval "$ac_try") 2>&5
6776
 
  ac_status=$?
6777
 
  echo "$as_me:$LINENO: \$? = $ac_status" >&5
6778
 
  (exit $ac_status); }; } &&
6779
 
         { ac_try='test -s conftest.$ac_objext'
6780
 
  { (case "(($ac_try" in
6781
 
  *\"* | *\`* | *\\*) ac_try_echo=\$ac_try;;
6782
 
  *) ac_try_echo=$ac_try;;
6783
 
esac
6784
 
eval "echo \"\$as_me:$LINENO: $ac_try_echo\"") >&5
6785
 
  (eval "$ac_try") 2>&5
6786
 
  ac_status=$?
6787
 
  echo "$as_me:$LINENO: \$? = $ac_status" >&5
6788
 
  (exit $ac_status); }; }; then
 
6570
  (exit $ac_status); } && {
 
6571
         test -z "$ac_c_werror_flag" ||
 
6572
         test ! -s conftest.err
 
6573
       } && test -s conftest.$ac_objext; then
6789
6574
  eval "$as_ac_Header=yes"
6790
6575
else
6791
6576
  echo "$as_me: failed program was:" >&5
6848
6633
  rm -f conftest.er1
6849
6634
  cat conftest.err >&5
6850
6635
  echo "$as_me:$LINENO: \$? = $ac_status" >&5
6851
 
  (exit $ac_status); } &&
6852
 
         { ac_try='test -z "$ac_c_werror_flag" || test ! -s conftest.err'
6853
 
  { (case "(($ac_try" in
6854
 
  *\"* | *\`* | *\\*) ac_try_echo=\$ac_try;;
6855
 
  *) ac_try_echo=$ac_try;;
6856
 
esac
6857
 
eval "echo \"\$as_me:$LINENO: $ac_try_echo\"") >&5
6858
 
  (eval "$ac_try") 2>&5
6859
 
  ac_status=$?
6860
 
  echo "$as_me:$LINENO: \$? = $ac_status" >&5
6861
 
  (exit $ac_status); }; } &&
6862
 
         { ac_try='test -s conftest.$ac_objext'
6863
 
  { (case "(($ac_try" in
6864
 
  *\"* | *\`* | *\\*) ac_try_echo=\$ac_try;;
6865
 
  *) ac_try_echo=$ac_try;;
6866
 
esac
6867
 
eval "echo \"\$as_me:$LINENO: $ac_try_echo\"") >&5
6868
 
  (eval "$ac_try") 2>&5
6869
 
  ac_status=$?
6870
 
  echo "$as_me:$LINENO: \$? = $ac_status" >&5
6871
 
  (exit $ac_status); }; }; then
 
6636
  (exit $ac_status); } && {
 
6637
         test -z "$ac_c_werror_flag" ||
 
6638
         test ! -s conftest.err
 
6639
       } && test -s conftest.$ac_objext; then
6872
6640
  ac_header_compiler=yes
6873
6641
else
6874
6642
  echo "$as_me: failed program was:" >&5
6904
6672
  rm -f conftest.er1
6905
6673
  cat conftest.err >&5
6906
6674
  echo "$as_me:$LINENO: \$? = $ac_status" >&5
6907
 
  (exit $ac_status); } >/dev/null; then
6908
 
  if test -s conftest.err; then
6909
 
    ac_cpp_err=$ac_c_preproc_warn_flag
6910
 
    ac_cpp_err=$ac_cpp_err$ac_c_werror_flag
6911
 
  else
6912
 
    ac_cpp_err=
6913
 
  fi
6914
 
else
6915
 
  ac_cpp_err=yes
6916
 
fi
6917
 
if test -z "$ac_cpp_err"; then
 
6675
  (exit $ac_status); } >/dev/null && {
 
6676
         test -z "$ac_c_preproc_warn_flag$ac_c_werror_flag" ||
 
6677
         test ! -s conftest.err
 
6678
       }; then
6918
6679
  ac_header_preproc=yes
6919
6680
else
6920
6681
  echo "$as_me: failed program was:" >&5
7026
6787
  rm -f conftest.er1
7027
6788
  cat conftest.err >&5
7028
6789
  echo "$as_me:$LINENO: \$? = $ac_status" >&5
7029
 
  (exit $ac_status); } >/dev/null; then
7030
 
  if test -s conftest.err; then
7031
 
    ac_cpp_err=$ac_cxx_preproc_warn_flag
7032
 
    ac_cpp_err=$ac_cpp_err$ac_cxx_werror_flag
7033
 
  else
7034
 
    ac_cpp_err=
7035
 
  fi
7036
 
else
7037
 
  ac_cpp_err=yes
7038
 
fi
7039
 
if test -z "$ac_cpp_err"; then
 
6790
  (exit $ac_status); } >/dev/null && {
 
6791
         test -z "$ac_cxx_preproc_warn_flag$ac_cxx_werror_flag" ||
 
6792
         test ! -s conftest.err
 
6793
       }; then
7040
6794
  :
7041
6795
else
7042
6796
  echo "$as_me: failed program was:" >&5
7070
6824
  rm -f conftest.er1
7071
6825
  cat conftest.err >&5
7072
6826
  echo "$as_me:$LINENO: \$? = $ac_status" >&5
7073
 
  (exit $ac_status); } >/dev/null; then
7074
 
  if test -s conftest.err; then
7075
 
    ac_cpp_err=$ac_cxx_preproc_warn_flag
7076
 
    ac_cpp_err=$ac_cpp_err$ac_cxx_werror_flag
7077
 
  else
7078
 
    ac_cpp_err=
7079
 
  fi
7080
 
else
7081
 
  ac_cpp_err=yes
7082
 
fi
7083
 
if test -z "$ac_cpp_err"; then
 
6827
  (exit $ac_status); } >/dev/null && {
 
6828
         test -z "$ac_cxx_preproc_warn_flag$ac_cxx_werror_flag" ||
 
6829
         test ! -s conftest.err
 
6830
       }; then
7084
6831
  # Broken: success on invalid input.
7085
6832
continue
7086
6833
else
7145
6892
  rm -f conftest.er1
7146
6893
  cat conftest.err >&5
7147
6894
  echo "$as_me:$LINENO: \$? = $ac_status" >&5
7148
 
  (exit $ac_status); } >/dev/null; then
7149
 
  if test -s conftest.err; then
7150
 
    ac_cpp_err=$ac_cxx_preproc_warn_flag
7151
 
    ac_cpp_err=$ac_cpp_err$ac_cxx_werror_flag
7152
 
  else
7153
 
    ac_cpp_err=
7154
 
  fi
7155
 
else
7156
 
  ac_cpp_err=yes
7157
 
fi
7158
 
if test -z "$ac_cpp_err"; then
 
6895
  (exit $ac_status); } >/dev/null && {
 
6896
         test -z "$ac_cxx_preproc_warn_flag$ac_cxx_werror_flag" ||
 
6897
         test ! -s conftest.err
 
6898
       }; then
7159
6899
  :
7160
6900
else
7161
6901
  echo "$as_me: failed program was:" >&5
7189
6929
  rm -f conftest.er1
7190
6930
  cat conftest.err >&5
7191
6931
  echo "$as_me:$LINENO: \$? = $ac_status" >&5
7192
 
  (exit $ac_status); } >/dev/null; then
7193
 
  if test -s conftest.err; then
7194
 
    ac_cpp_err=$ac_cxx_preproc_warn_flag
7195
 
    ac_cpp_err=$ac_cpp_err$ac_cxx_werror_flag
7196
 
  else
7197
 
    ac_cpp_err=
7198
 
  fi
7199
 
else
7200
 
  ac_cpp_err=yes
7201
 
fi
7202
 
if test -z "$ac_cpp_err"; then
 
6932
  (exit $ac_status); } >/dev/null && {
 
6933
         test -z "$ac_cxx_preproc_warn_flag$ac_cxx_werror_flag" ||
 
6934
         test ! -s conftest.err
 
6935
       }; then
7203
6936
  # Broken: success on invalid input.
7204
6937
continue
7205
6938
else
7240
6973
ac_link='$F77 -o conftest$ac_exeext $FFLAGS $LDFLAGS conftest.$ac_ext $LIBS >&5'
7241
6974
ac_compiler_gnu=$ac_cv_f77_compiler_gnu
7242
6975
if test -n "$ac_tool_prefix"; then
7243
 
  for ac_prog in g77 f77 xlf frt pgf77 cf77 fort77 fl32 af77 f90 xlf90 pgf90 pghpf epcf90 gfortran g95 f95 fort xlf95 ifort ifc efc pgf95 lf95 ftn
 
6976
  for ac_prog in g77 xlf f77 frt pgf77 cf77 fort77 fl32 af77 xlf90 f90 pgf90 pghpf epcf90 gfortran g95 xlf95 f95 fort ifort ifc efc pgf95 lf95 ftn
7244
6977
  do
7245
6978
    # Extract the first word of "$ac_tool_prefix$ac_prog", so it can be a program name with args.
7246
6979
set dummy $ac_tool_prefix$ac_prog; ac_word=$2
7258
6991
  IFS=$as_save_IFS
7259
6992
  test -z "$as_dir" && as_dir=.
7260
6993
  for ac_exec_ext in '' $ac_executable_extensions; do
7261
 
  if { test -f "$as_dir/$ac_word$ac_exec_ext" && $as_executable_p "$as_dir/$ac_word$ac_exec_ext"; }; then
 
6994
  if { test -f "$as_dir/$ac_word$ac_exec_ext" && $as_test_x "$as_dir/$ac_word$ac_exec_ext"; }; then
7262
6995
    ac_cv_prog_F77="$ac_tool_prefix$ac_prog"
7263
6996
    echo "$as_me:$LINENO: found $as_dir/$ac_word$ac_exec_ext" >&5
7264
6997
    break 2
7284
7017
fi
7285
7018
if test -z "$F77"; then
7286
7019
  ac_ct_F77=$F77
7287
 
  for ac_prog in g77 f77 xlf frt pgf77 cf77 fort77 fl32 af77 f90 xlf90 pgf90 pghpf epcf90 gfortran g95 f95 fort xlf95 ifort ifc efc pgf95 lf95 ftn
 
7020
  for ac_prog in g77 xlf f77 frt pgf77 cf77 fort77 fl32 af77 xlf90 f90 pgf90 pghpf epcf90 gfortran g95 xlf95 f95 fort ifort ifc efc pgf95 lf95 ftn
7288
7021
do
7289
7022
  # Extract the first word of "$ac_prog", so it can be a program name with args.
7290
7023
set dummy $ac_prog; ac_word=$2
7302
7035
  IFS=$as_save_IFS
7303
7036
  test -z "$as_dir" && as_dir=.
7304
7037
  for ac_exec_ext in '' $ac_executable_extensions; do
7305
 
  if { test -f "$as_dir/$ac_word$ac_exec_ext" && $as_executable_p "$as_dir/$ac_word$ac_exec_ext"; }; then
 
7038
  if { test -f "$as_dir/$ac_word$ac_exec_ext" && $as_test_x "$as_dir/$ac_word$ac_exec_ext"; }; then
7306
7039
    ac_cv_prog_ac_ct_F77="$ac_prog"
7307
7040
    echo "$as_me:$LINENO: found $as_dir/$ac_word$ac_exec_ext" >&5
7308
7041
    break 2
7409
7142
  rm -f conftest.er1
7410
7143
  cat conftest.err >&5
7411
7144
  echo "$as_me:$LINENO: \$? = $ac_status" >&5
7412
 
  (exit $ac_status); } &&
7413
 
         { ac_try='test -z "$ac_f77_werror_flag" || test ! -s conftest.err'
7414
 
  { (case "(($ac_try" in
7415
 
  *\"* | *\`* | *\\*) ac_try_echo=\$ac_try;;
7416
 
  *) ac_try_echo=$ac_try;;
7417
 
esac
7418
 
eval "echo \"\$as_me:$LINENO: $ac_try_echo\"") >&5
7419
 
  (eval "$ac_try") 2>&5
7420
 
  ac_status=$?
7421
 
  echo "$as_me:$LINENO: \$? = $ac_status" >&5
7422
 
  (exit $ac_status); }; } &&
7423
 
         { ac_try='test -s conftest.$ac_objext'
7424
 
  { (case "(($ac_try" in
7425
 
  *\"* | *\`* | *\\*) ac_try_echo=\$ac_try;;
7426
 
  *) ac_try_echo=$ac_try;;
7427
 
esac
7428
 
eval "echo \"\$as_me:$LINENO: $ac_try_echo\"") >&5
7429
 
  (eval "$ac_try") 2>&5
7430
 
  ac_status=$?
7431
 
  echo "$as_me:$LINENO: \$? = $ac_status" >&5
7432
 
  (exit $ac_status); }; }; then
 
7145
  (exit $ac_status); } && {
 
7146
         test -z "$ac_f77_werror_flag" ||
 
7147
         test ! -s conftest.err
 
7148
       } && test -s conftest.$ac_objext; then
7433
7149
  ac_compiler_gnu=yes
7434
7150
else
7435
7151
  echo "$as_me: failed program was:" >&5
7472
7188
  rm -f conftest.er1
7473
7189
  cat conftest.err >&5
7474
7190
  echo "$as_me:$LINENO: \$? = $ac_status" >&5
7475
 
  (exit $ac_status); } &&
7476
 
         { ac_try='test -z "$ac_f77_werror_flag" || test ! -s conftest.err'
7477
 
  { (case "(($ac_try" in
7478
 
  *\"* | *\`* | *\\*) ac_try_echo=\$ac_try;;
7479
 
  *) ac_try_echo=$ac_try;;
7480
 
esac
7481
 
eval "echo \"\$as_me:$LINENO: $ac_try_echo\"") >&5
7482
 
  (eval "$ac_try") 2>&5
7483
 
  ac_status=$?
7484
 
  echo "$as_me:$LINENO: \$? = $ac_status" >&5
7485
 
  (exit $ac_status); }; } &&
7486
 
         { ac_try='test -s conftest.$ac_objext'
7487
 
  { (case "(($ac_try" in
7488
 
  *\"* | *\`* | *\\*) ac_try_echo=\$ac_try;;
7489
 
  *) ac_try_echo=$ac_try;;
7490
 
esac
7491
 
eval "echo \"\$as_me:$LINENO: $ac_try_echo\"") >&5
7492
 
  (eval "$ac_try") 2>&5
7493
 
  ac_status=$?
7494
 
  echo "$as_me:$LINENO: \$? = $ac_status" >&5
7495
 
  (exit $ac_status); }; }; then
 
7191
  (exit $ac_status); } && {
 
7192
         test -z "$ac_f77_werror_flag" ||
 
7193
         test ! -s conftest.err
 
7194
       } && test -s conftest.$ac_objext; then
7496
7195
  ac_cv_prog_f77_g=yes
7497
7196
else
7498
7197
  echo "$as_me: failed program was:" >&5
7947
7646
  IFS=$as_save_IFS
7948
7647
  test -z "$as_dir" && as_dir=.
7949
7648
  for ac_exec_ext in '' $ac_executable_extensions; do
7950
 
  if { test -f "$as_dir/$ac_word$ac_exec_ext" && $as_executable_p "$as_dir/$ac_word$ac_exec_ext"; }; then
 
7649
  if { test -f "$as_dir/$ac_word$ac_exec_ext" && $as_test_x "$as_dir/$ac_word$ac_exec_ext"; }; then
7951
7650
    ac_cv_prog_AR="${ac_tool_prefix}ar"
7952
7651
    echo "$as_me:$LINENO: found $as_dir/$ac_word$ac_exec_ext" >&5
7953
7652
    break 2
7987
7686
  IFS=$as_save_IFS
7988
7687
  test -z "$as_dir" && as_dir=.
7989
7688
  for ac_exec_ext in '' $ac_executable_extensions; do
7990
 
  if { test -f "$as_dir/$ac_word$ac_exec_ext" && $as_executable_p "$as_dir/$ac_word$ac_exec_ext"; }; then
 
7689
  if { test -f "$as_dir/$ac_word$ac_exec_ext" && $as_test_x "$as_dir/$ac_word$ac_exec_ext"; }; then
7991
7690
    ac_cv_prog_ac_ct_AR="ar"
7992
7691
    echo "$as_me:$LINENO: found $as_dir/$ac_word$ac_exec_ext" >&5
7993
7692
    break 2
8043
7742
  IFS=$as_save_IFS
8044
7743
  test -z "$as_dir" && as_dir=.
8045
7744
  for ac_exec_ext in '' $ac_executable_extensions; do
8046
 
  if { test -f "$as_dir/$ac_word$ac_exec_ext" && $as_executable_p "$as_dir/$ac_word$ac_exec_ext"; }; then
 
7745
  if { test -f "$as_dir/$ac_word$ac_exec_ext" && $as_test_x "$as_dir/$ac_word$ac_exec_ext"; }; then
8047
7746
    ac_cv_prog_RANLIB="${ac_tool_prefix}ranlib"
8048
7747
    echo "$as_me:$LINENO: found $as_dir/$ac_word$ac_exec_ext" >&5
8049
7748
    break 2
8083
7782
  IFS=$as_save_IFS
8084
7783
  test -z "$as_dir" && as_dir=.
8085
7784
  for ac_exec_ext in '' $ac_executable_extensions; do
8086
 
  if { test -f "$as_dir/$ac_word$ac_exec_ext" && $as_executable_p "$as_dir/$ac_word$ac_exec_ext"; }; then
 
7785
  if { test -f "$as_dir/$ac_word$ac_exec_ext" && $as_test_x "$as_dir/$ac_word$ac_exec_ext"; }; then
8087
7786
    ac_cv_prog_ac_ct_RANLIB="ranlib"
8088
7787
    echo "$as_me:$LINENO: found $as_dir/$ac_word$ac_exec_ext" >&5
8089
7788
    break 2
8139
7838
  IFS=$as_save_IFS
8140
7839
  test -z "$as_dir" && as_dir=.
8141
7840
  for ac_exec_ext in '' $ac_executable_extensions; do
8142
 
  if { test -f "$as_dir/$ac_word$ac_exec_ext" && $as_executable_p "$as_dir/$ac_word$ac_exec_ext"; }; then
 
7841
  if { test -f "$as_dir/$ac_word$ac_exec_ext" && $as_test_x "$as_dir/$ac_word$ac_exec_ext"; }; then
8143
7842
    ac_cv_prog_STRIP="${ac_tool_prefix}strip"
8144
7843
    echo "$as_me:$LINENO: found $as_dir/$ac_word$ac_exec_ext" >&5
8145
7844
    break 2
8179
7878
  IFS=$as_save_IFS
8180
7879
  test -z "$as_dir" && as_dir=.
8181
7880
  for ac_exec_ext in '' $ac_executable_extensions; do
8182
 
  if { test -f "$as_dir/$ac_word$ac_exec_ext" && $as_executable_p "$as_dir/$ac_word$ac_exec_ext"; }; then
 
7881
  if { test -f "$as_dir/$ac_word$ac_exec_ext" && $as_test_x "$as_dir/$ac_word$ac_exec_ext"; }; then
8183
7882
    ac_cv_prog_ac_ct_STRIP="strip"
8184
7883
    echo "$as_me:$LINENO: found $as_dir/$ac_word$ac_exec_ext" >&5
8185
7884
    break 2
8496
8195
   -e 's:.*FLAGS}\{0,1\} :&$lt_compiler_flag :; t' \
8497
8196
   -e 's: [^ ]*conftest\.: $lt_compiler_flag&:; t' \
8498
8197
   -e 's:$: $lt_compiler_flag:'`
8499
 
   (eval echo "\"\$as_me:8499: $lt_compile\"" >&5)
 
8198
   (eval echo "\"\$as_me:8198: $lt_compile\"" >&5)
8500
8199
   (eval "$lt_compile" 2>conftest.err)
8501
8200
   ac_status=$?
8502
8201
   cat conftest.err >&5
8503
 
   echo "$as_me:8503: \$? = $ac_status" >&5
 
8202
   echo "$as_me:8202: \$? = $ac_status" >&5
8504
8203
   if (exit $ac_status) && test -s "$ac_outfile"; then
8505
8204
     # The compiler can only warn and ignore the option if not recognized
8506
8205
     # So say no if there are warnings other than the usual output.
8786
8485
   -e 's:.*FLAGS}\{0,1\} :&$lt_compiler_flag :; t' \
8787
8486
   -e 's: [^ ]*conftest\.: $lt_compiler_flag&:; t' \
8788
8487
   -e 's:$: $lt_compiler_flag:'`
8789
 
   (eval echo "\"\$as_me:8789: $lt_compile\"" >&5)
 
8488
   (eval echo "\"\$as_me:8488: $lt_compile\"" >&5)
8790
8489
   (eval "$lt_compile" 2>conftest.err)
8791
8490
   ac_status=$?
8792
8491
   cat conftest.err >&5
8793
 
   echo "$as_me:8793: \$? = $ac_status" >&5
 
8492
   echo "$as_me:8492: \$? = $ac_status" >&5
8794
8493
   if (exit $ac_status) && test -s "$ac_outfile"; then
8795
8494
     # The compiler can only warn and ignore the option if not recognized
8796
8495
     # So say no if there are warnings other than the usual output.
8890
8589
   -e 's:.*FLAGS}\{0,1\} :&$lt_compiler_flag :; t' \
8891
8590
   -e 's: [^ ]*conftest\.: $lt_compiler_flag&:; t' \
8892
8591
   -e 's:$: $lt_compiler_flag:'`
8893
 
   (eval echo "\"\$as_me:8893: $lt_compile\"" >&5)
 
8592
   (eval echo "\"\$as_me:8592: $lt_compile\"" >&5)
8894
8593
   (eval "$lt_compile" 2>out/conftest.err)
8895
8594
   ac_status=$?
8896
8595
   cat out/conftest.err >&5
8897
 
   echo "$as_me:8897: \$? = $ac_status" >&5
 
8596
   echo "$as_me:8596: \$? = $ac_status" >&5
8898
8597
   if (exit $ac_status) && test -s out/conftest2.$ac_objext
8899
8598
   then
8900
8599
     # The compiler can only warn and ignore the option if not recognized
9379
9078
  rm -f conftest.er1
9380
9079
  cat conftest.err >&5
9381
9080
  echo "$as_me:$LINENO: \$? = $ac_status" >&5
9382
 
  (exit $ac_status); } &&
9383
 
         { ac_try='test -z "$ac_c_werror_flag" || test ! -s conftest.err'
9384
 
  { (case "(($ac_try" in
9385
 
  *\"* | *\`* | *\\*) ac_try_echo=\$ac_try;;
9386
 
  *) ac_try_echo=$ac_try;;
9387
 
esac
9388
 
eval "echo \"\$as_me:$LINENO: $ac_try_echo\"") >&5
9389
 
  (eval "$ac_try") 2>&5
9390
 
  ac_status=$?
9391
 
  echo "$as_me:$LINENO: \$? = $ac_status" >&5
9392
 
  (exit $ac_status); }; } &&
9393
 
         { ac_try='test -s conftest$ac_exeext'
9394
 
  { (case "(($ac_try" in
9395
 
  *\"* | *\`* | *\\*) ac_try_echo=\$ac_try;;
9396
 
  *) ac_try_echo=$ac_try;;
9397
 
esac
9398
 
eval "echo \"\$as_me:$LINENO: $ac_try_echo\"") >&5
9399
 
  (eval "$ac_try") 2>&5
9400
 
  ac_status=$?
9401
 
  echo "$as_me:$LINENO: \$? = $ac_status" >&5
9402
 
  (exit $ac_status); }; }; then
 
9081
  (exit $ac_status); } && {
 
9082
         test -z "$ac_c_werror_flag" ||
 
9083
         test ! -s conftest.err
 
9084
       } && test -s conftest$ac_exeext &&
 
9085
       $as_test_x conftest$ac_exeext; then
9403
9086
 
9404
9087
lt_aix_libpath_sed='
9405
9088
    /Import File Strings/,/^$/ {
9420
9103
 
9421
9104
fi
9422
9105
 
9423
 
rm -f core conftest.err conftest.$ac_objext \
 
9106
rm -f core conftest.err conftest.$ac_objext conftest_ipa8_conftest.oo \
9424
9107
      conftest$ac_exeext conftest.$ac_ext
9425
9108
if test -z "$aix_libpath"; then aix_libpath="/usr/lib:/lib"; fi
9426
9109
 
9461
9144
  rm -f conftest.er1
9462
9145
  cat conftest.err >&5
9463
9146
  echo "$as_me:$LINENO: \$? = $ac_status" >&5
9464
 
  (exit $ac_status); } &&
9465
 
         { ac_try='test -z "$ac_c_werror_flag" || test ! -s conftest.err'
9466
 
  { (case "(($ac_try" in
9467
 
  *\"* | *\`* | *\\*) ac_try_echo=\$ac_try;;
9468
 
  *) ac_try_echo=$ac_try;;
9469
 
esac
9470
 
eval "echo \"\$as_me:$LINENO: $ac_try_echo\"") >&5
9471
 
  (eval "$ac_try") 2>&5
9472
 
  ac_status=$?
9473
 
  echo "$as_me:$LINENO: \$? = $ac_status" >&5
9474
 
  (exit $ac_status); }; } &&
9475
 
         { ac_try='test -s conftest$ac_exeext'
9476
 
  { (case "(($ac_try" in
9477
 
  *\"* | *\`* | *\\*) ac_try_echo=\$ac_try;;
9478
 
  *) ac_try_echo=$ac_try;;
9479
 
esac
9480
 
eval "echo \"\$as_me:$LINENO: $ac_try_echo\"") >&5
9481
 
  (eval "$ac_try") 2>&5
9482
 
  ac_status=$?
9483
 
  echo "$as_me:$LINENO: \$? = $ac_status" >&5
9484
 
  (exit $ac_status); }; }; then
 
9147
  (exit $ac_status); } && {
 
9148
         test -z "$ac_c_werror_flag" ||
 
9149
         test ! -s conftest.err
 
9150
       } && test -s conftest$ac_exeext &&
 
9151
       $as_test_x conftest$ac_exeext; then
9485
9152
 
9486
9153
lt_aix_libpath_sed='
9487
9154
    /Import File Strings/,/^$/ {
9502
9169
 
9503
9170
fi
9504
9171
 
9505
 
rm -f core conftest.err conftest.$ac_objext \
 
9172
rm -f core conftest.err conftest.$ac_objext conftest_ipa8_conftest.oo \
9506
9173
      conftest$ac_exeext conftest.$ac_ext
9507
9174
if test -z "$aix_libpath"; then aix_libpath="/usr/lib:/lib"; fi
9508
9175
 
10764
10431
  rm -f conftest.er1
10765
10432
  cat conftest.err >&5
10766
10433
  echo "$as_me:$LINENO: \$? = $ac_status" >&5
10767
 
  (exit $ac_status); } &&
10768
 
         { ac_try='test -z "$ac_c_werror_flag" || test ! -s conftest.err'
10769
 
  { (case "(($ac_try" in
10770
 
  *\"* | *\`* | *\\*) ac_try_echo=\$ac_try;;
10771
 
  *) ac_try_echo=$ac_try;;
10772
 
esac
10773
 
eval "echo \"\$as_me:$LINENO: $ac_try_echo\"") >&5
10774
 
  (eval "$ac_try") 2>&5
10775
 
  ac_status=$?
10776
 
  echo "$as_me:$LINENO: \$? = $ac_status" >&5
10777
 
  (exit $ac_status); }; } &&
10778
 
         { ac_try='test -s conftest$ac_exeext'
10779
 
  { (case "(($ac_try" in
10780
 
  *\"* | *\`* | *\\*) ac_try_echo=\$ac_try;;
10781
 
  *) ac_try_echo=$ac_try;;
10782
 
esac
10783
 
eval "echo \"\$as_me:$LINENO: $ac_try_echo\"") >&5
10784
 
  (eval "$ac_try") 2>&5
10785
 
  ac_status=$?
10786
 
  echo "$as_me:$LINENO: \$? = $ac_status" >&5
10787
 
  (exit $ac_status); }; }; then
 
10434
  (exit $ac_status); } && {
 
10435
         test -z "$ac_c_werror_flag" ||
 
10436
         test ! -s conftest.err
 
10437
       } && test -s conftest$ac_exeext &&
 
10438
       $as_test_x conftest$ac_exeext; then
10788
10439
  ac_cv_lib_dl_dlopen=yes
10789
10440
else
10790
10441
  echo "$as_me: failed program was:" >&5
10793
10444
        ac_cv_lib_dl_dlopen=no
10794
10445
fi
10795
10446
 
10796
 
rm -f core conftest.err conftest.$ac_objext \
 
10447
rm -f core conftest.err conftest.$ac_objext conftest_ipa8_conftest.oo \
10797
10448
      conftest$ac_exeext conftest.$ac_ext
10798
10449
LIBS=$ac_check_lib_save_LIBS
10799
10450
fi
10875
10526
  rm -f conftest.er1
10876
10527
  cat conftest.err >&5
10877
10528
  echo "$as_me:$LINENO: \$? = $ac_status" >&5
10878
 
  (exit $ac_status); } &&
10879
 
         { ac_try='test -z "$ac_c_werror_flag" || test ! -s conftest.err'
10880
 
  { (case "(($ac_try" in
10881
 
  *\"* | *\`* | *\\*) ac_try_echo=\$ac_try;;
10882
 
  *) ac_try_echo=$ac_try;;
10883
 
esac
10884
 
eval "echo \"\$as_me:$LINENO: $ac_try_echo\"") >&5
10885
 
  (eval "$ac_try") 2>&5
10886
 
  ac_status=$?
10887
 
  echo "$as_me:$LINENO: \$? = $ac_status" >&5
10888
 
  (exit $ac_status); }; } &&
10889
 
         { ac_try='test -s conftest$ac_exeext'
10890
 
  { (case "(($ac_try" in
10891
 
  *\"* | *\`* | *\\*) ac_try_echo=\$ac_try;;
10892
 
  *) ac_try_echo=$ac_try;;
10893
 
esac
10894
 
eval "echo \"\$as_me:$LINENO: $ac_try_echo\"") >&5
10895
 
  (eval "$ac_try") 2>&5
10896
 
  ac_status=$?
10897
 
  echo "$as_me:$LINENO: \$? = $ac_status" >&5
10898
 
  (exit $ac_status); }; }; then
 
10529
  (exit $ac_status); } && {
 
10530
         test -z "$ac_c_werror_flag" ||
 
10531
         test ! -s conftest.err
 
10532
       } && test -s conftest$ac_exeext &&
 
10533
       $as_test_x conftest$ac_exeext; then
10899
10534
  ac_cv_func_shl_load=yes
10900
10535
else
10901
10536
  echo "$as_me: failed program was:" >&5
10904
10539
        ac_cv_func_shl_load=no
10905
10540
fi
10906
10541
 
10907
 
rm -f core conftest.err conftest.$ac_objext \
 
10542
rm -f core conftest.err conftest.$ac_objext conftest_ipa8_conftest.oo \
10908
10543
      conftest$ac_exeext conftest.$ac_ext
10909
10544
fi
10910
10545
{ echo "$as_me:$LINENO: result: $ac_cv_func_shl_load" >&5
10954
10589
  rm -f conftest.er1
10955
10590
  cat conftest.err >&5
10956
10591
  echo "$as_me:$LINENO: \$? = $ac_status" >&5
10957
 
  (exit $ac_status); } &&
10958
 
         { ac_try='test -z "$ac_c_werror_flag" || test ! -s conftest.err'
10959
 
  { (case "(($ac_try" in
10960
 
  *\"* | *\`* | *\\*) ac_try_echo=\$ac_try;;
10961
 
  *) ac_try_echo=$ac_try;;
10962
 
esac
10963
 
eval "echo \"\$as_me:$LINENO: $ac_try_echo\"") >&5
10964
 
  (eval "$ac_try") 2>&5
10965
 
  ac_status=$?
10966
 
  echo "$as_me:$LINENO: \$? = $ac_status" >&5
10967
 
  (exit $ac_status); }; } &&
10968
 
         { ac_try='test -s conftest$ac_exeext'
10969
 
  { (case "(($ac_try" in
10970
 
  *\"* | *\`* | *\\*) ac_try_echo=\$ac_try;;
10971
 
  *) ac_try_echo=$ac_try;;
10972
 
esac
10973
 
eval "echo \"\$as_me:$LINENO: $ac_try_echo\"") >&5
10974
 
  (eval "$ac_try") 2>&5
10975
 
  ac_status=$?
10976
 
  echo "$as_me:$LINENO: \$? = $ac_status" >&5
10977
 
  (exit $ac_status); }; }; then
 
10592
  (exit $ac_status); } && {
 
10593
         test -z "$ac_c_werror_flag" ||
 
10594
         test ! -s conftest.err
 
10595
       } && test -s conftest$ac_exeext &&
 
10596
       $as_test_x conftest$ac_exeext; then
10978
10597
  ac_cv_lib_dld_shl_load=yes
10979
10598
else
10980
10599
  echo "$as_me: failed program was:" >&5
10983
10602
        ac_cv_lib_dld_shl_load=no
10984
10603
fi
10985
10604
 
10986
 
rm -f core conftest.err conftest.$ac_objext \
 
10605
rm -f core conftest.err conftest.$ac_objext conftest_ipa8_conftest.oo \
10987
10606
      conftest$ac_exeext conftest.$ac_ext
10988
10607
LIBS=$ac_check_lib_save_LIBS
10989
10608
fi
11055
10674
  rm -f conftest.er1
11056
10675
  cat conftest.err >&5
11057
10676
  echo "$as_me:$LINENO: \$? = $ac_status" >&5
11058
 
  (exit $ac_status); } &&
11059
 
         { ac_try='test -z "$ac_c_werror_flag" || test ! -s conftest.err'
11060
 
  { (case "(($ac_try" in
11061
 
  *\"* | *\`* | *\\*) ac_try_echo=\$ac_try;;
11062
 
  *) ac_try_echo=$ac_try;;
11063
 
esac
11064
 
eval "echo \"\$as_me:$LINENO: $ac_try_echo\"") >&5
11065
 
  (eval "$ac_try") 2>&5
11066
 
  ac_status=$?
11067
 
  echo "$as_me:$LINENO: \$? = $ac_status" >&5
11068
 
  (exit $ac_status); }; } &&
11069
 
         { ac_try='test -s conftest$ac_exeext'
11070
 
  { (case "(($ac_try" in
11071
 
  *\"* | *\`* | *\\*) ac_try_echo=\$ac_try;;
11072
 
  *) ac_try_echo=$ac_try;;
11073
 
esac
11074
 
eval "echo \"\$as_me:$LINENO: $ac_try_echo\"") >&5
11075
 
  (eval "$ac_try") 2>&5
11076
 
  ac_status=$?
11077
 
  echo "$as_me:$LINENO: \$? = $ac_status" >&5
11078
 
  (exit $ac_status); }; }; then
 
10677
  (exit $ac_status); } && {
 
10678
         test -z "$ac_c_werror_flag" ||
 
10679
         test ! -s conftest.err
 
10680
       } && test -s conftest$ac_exeext &&
 
10681
       $as_test_x conftest$ac_exeext; then
11079
10682
  ac_cv_func_dlopen=yes
11080
10683
else
11081
10684
  echo "$as_me: failed program was:" >&5
11084
10687
        ac_cv_func_dlopen=no
11085
10688
fi
11086
10689
 
11087
 
rm -f core conftest.err conftest.$ac_objext \
 
10690
rm -f core conftest.err conftest.$ac_objext conftest_ipa8_conftest.oo \
11088
10691
      conftest$ac_exeext conftest.$ac_ext
11089
10692
fi
11090
10693
{ echo "$as_me:$LINENO: result: $ac_cv_func_dlopen" >&5
11134
10737
  rm -f conftest.er1
11135
10738
  cat conftest.err >&5
11136
10739
  echo "$as_me:$LINENO: \$? = $ac_status" >&5
11137
 
  (exit $ac_status); } &&
11138
 
         { ac_try='test -z "$ac_c_werror_flag" || test ! -s conftest.err'
11139
 
  { (case "(($ac_try" in
11140
 
  *\"* | *\`* | *\\*) ac_try_echo=\$ac_try;;
11141
 
  *) ac_try_echo=$ac_try;;
11142
 
esac
11143
 
eval "echo \"\$as_me:$LINENO: $ac_try_echo\"") >&5
11144
 
  (eval "$ac_try") 2>&5
11145
 
  ac_status=$?
11146
 
  echo "$as_me:$LINENO: \$? = $ac_status" >&5
11147
 
  (exit $ac_status); }; } &&
11148
 
         { ac_try='test -s conftest$ac_exeext'
11149
 
  { (case "(($ac_try" in
11150
 
  *\"* | *\`* | *\\*) ac_try_echo=\$ac_try;;
11151
 
  *) ac_try_echo=$ac_try;;
11152
 
esac
11153
 
eval "echo \"\$as_me:$LINENO: $ac_try_echo\"") >&5
11154
 
  (eval "$ac_try") 2>&5
11155
 
  ac_status=$?
11156
 
  echo "$as_me:$LINENO: \$? = $ac_status" >&5
11157
 
  (exit $ac_status); }; }; then
 
10740
  (exit $ac_status); } && {
 
10741
         test -z "$ac_c_werror_flag" ||
 
10742
         test ! -s conftest.err
 
10743
       } && test -s conftest$ac_exeext &&
 
10744
       $as_test_x conftest$ac_exeext; then
11158
10745
  ac_cv_lib_dl_dlopen=yes
11159
10746
else
11160
10747
  echo "$as_me: failed program was:" >&5
11163
10750
        ac_cv_lib_dl_dlopen=no
11164
10751
fi
11165
10752
 
11166
 
rm -f core conftest.err conftest.$ac_objext \
 
10753
rm -f core conftest.err conftest.$ac_objext conftest_ipa8_conftest.oo \
11167
10754
      conftest$ac_exeext conftest.$ac_ext
11168
10755
LIBS=$ac_check_lib_save_LIBS
11169
10756
fi
11214
10801
  rm -f conftest.er1
11215
10802
  cat conftest.err >&5
11216
10803
  echo "$as_me:$LINENO: \$? = $ac_status" >&5
11217
 
  (exit $ac_status); } &&
11218
 
         { ac_try='test -z "$ac_c_werror_flag" || test ! -s conftest.err'
11219
 
  { (case "(($ac_try" in
11220
 
  *\"* | *\`* | *\\*) ac_try_echo=\$ac_try;;
11221
 
  *) ac_try_echo=$ac_try;;
11222
 
esac
11223
 
eval "echo \"\$as_me:$LINENO: $ac_try_echo\"") >&5
11224
 
  (eval "$ac_try") 2>&5
11225
 
  ac_status=$?
11226
 
  echo "$as_me:$LINENO: \$? = $ac_status" >&5
11227
 
  (exit $ac_status); }; } &&
11228
 
         { ac_try='test -s conftest$ac_exeext'
11229
 
  { (case "(($ac_try" in
11230
 
  *\"* | *\`* | *\\*) ac_try_echo=\$ac_try;;
11231
 
  *) ac_try_echo=$ac_try;;
11232
 
esac
11233
 
eval "echo \"\$as_me:$LINENO: $ac_try_echo\"") >&5
11234
 
  (eval "$ac_try") 2>&5
11235
 
  ac_status=$?
11236
 
  echo "$as_me:$LINENO: \$? = $ac_status" >&5
11237
 
  (exit $ac_status); }; }; then
 
10804
  (exit $ac_status); } && {
 
10805
         test -z "$ac_c_werror_flag" ||
 
10806
         test ! -s conftest.err
 
10807
       } && test -s conftest$ac_exeext &&
 
10808
       $as_test_x conftest$ac_exeext; then
11238
10809
  ac_cv_lib_svld_dlopen=yes
11239
10810
else
11240
10811
  echo "$as_me: failed program was:" >&5
11243
10814
        ac_cv_lib_svld_dlopen=no
11244
10815
fi
11245
10816
 
11246
 
rm -f core conftest.err conftest.$ac_objext \
 
10817
rm -f core conftest.err conftest.$ac_objext conftest_ipa8_conftest.oo \
11247
10818
      conftest$ac_exeext conftest.$ac_ext
11248
10819
LIBS=$ac_check_lib_save_LIBS
11249
10820
fi
11294
10865
  rm -f conftest.er1
11295
10866
  cat conftest.err >&5
11296
10867
  echo "$as_me:$LINENO: \$? = $ac_status" >&5
11297
 
  (exit $ac_status); } &&
11298
 
         { ac_try='test -z "$ac_c_werror_flag" || test ! -s conftest.err'
11299
 
  { (case "(($ac_try" in
11300
 
  *\"* | *\`* | *\\*) ac_try_echo=\$ac_try;;
11301
 
  *) ac_try_echo=$ac_try;;
11302
 
esac
11303
 
eval "echo \"\$as_me:$LINENO: $ac_try_echo\"") >&5
11304
 
  (eval "$ac_try") 2>&5
11305
 
  ac_status=$?
11306
 
  echo "$as_me:$LINENO: \$? = $ac_status" >&5
11307
 
  (exit $ac_status); }; } &&
11308
 
         { ac_try='test -s conftest$ac_exeext'
11309
 
  { (case "(($ac_try" in
11310
 
  *\"* | *\`* | *\\*) ac_try_echo=\$ac_try;;
11311
 
  *) ac_try_echo=$ac_try;;
11312
 
esac
11313
 
eval "echo \"\$as_me:$LINENO: $ac_try_echo\"") >&5
11314
 
  (eval "$ac_try") 2>&5
11315
 
  ac_status=$?
11316
 
  echo "$as_me:$LINENO: \$? = $ac_status" >&5
11317
 
  (exit $ac_status); }; }; then
 
10868
  (exit $ac_status); } && {
 
10869
         test -z "$ac_c_werror_flag" ||
 
10870
         test ! -s conftest.err
 
10871
       } && test -s conftest$ac_exeext &&
 
10872
       $as_test_x conftest$ac_exeext; then
11318
10873
  ac_cv_lib_dld_dld_link=yes
11319
10874
else
11320
10875
  echo "$as_me: failed program was:" >&5
11323
10878
        ac_cv_lib_dld_dld_link=no
11324
10879
fi
11325
10880
 
11326
 
rm -f core conftest.err conftest.$ac_objext \
 
10881
rm -f core conftest.err conftest.$ac_objext conftest_ipa8_conftest.oo \
11327
10882
      conftest$ac_exeext conftest.$ac_ext
11328
10883
LIBS=$ac_check_lib_save_LIBS
11329
10884
fi
11379
10934
  lt_dlunknown=0; lt_dlno_uscore=1; lt_dlneed_uscore=2
11380
10935
  lt_status=$lt_dlunknown
11381
10936
  cat > conftest.$ac_ext <<EOF
11382
 
#line 11382 "configure"
 
10937
#line 10937 "configure"
11383
10938
#include "confdefs.h"
11384
10939
 
11385
10940
#if HAVE_DLFCN_H
11479
11034
  lt_dlunknown=0; lt_dlno_uscore=1; lt_dlneed_uscore=2
11480
11035
  lt_status=$lt_dlunknown
11481
11036
  cat > conftest.$ac_ext <<EOF
11482
 
#line 11482 "configure"
 
11037
#line 11037 "configure"
11483
11038
#include "confdefs.h"
11484
11039
 
11485
11040
#if HAVE_DLFCN_H
12566
12121
  rm -f conftest.er1
12567
12122
  cat conftest.err >&5
12568
12123
  echo "$as_me:$LINENO: \$? = $ac_status" >&5
12569
 
  (exit $ac_status); } &&
12570
 
         { ac_try='test -z "$ac_cxx_werror_flag" || test ! -s conftest.err'
12571
 
  { (case "(($ac_try" in
12572
 
  *\"* | *\`* | *\\*) ac_try_echo=\$ac_try;;
12573
 
  *) ac_try_echo=$ac_try;;
12574
 
esac
12575
 
eval "echo \"\$as_me:$LINENO: $ac_try_echo\"") >&5
12576
 
  (eval "$ac_try") 2>&5
12577
 
  ac_status=$?
12578
 
  echo "$as_me:$LINENO: \$? = $ac_status" >&5
12579
 
  (exit $ac_status); }; } &&
12580
 
         { ac_try='test -s conftest$ac_exeext'
12581
 
  { (case "(($ac_try" in
12582
 
  *\"* | *\`* | *\\*) ac_try_echo=\$ac_try;;
12583
 
  *) ac_try_echo=$ac_try;;
12584
 
esac
12585
 
eval "echo \"\$as_me:$LINENO: $ac_try_echo\"") >&5
12586
 
  (eval "$ac_try") 2>&5
12587
 
  ac_status=$?
12588
 
  echo "$as_me:$LINENO: \$? = $ac_status" >&5
12589
 
  (exit $ac_status); }; }; then
 
12124
  (exit $ac_status); } && {
 
12125
         test -z "$ac_cxx_werror_flag" ||
 
12126
         test ! -s conftest.err
 
12127
       } && test -s conftest$ac_exeext &&
 
12128
       $as_test_x conftest$ac_exeext; then
12590
12129
 
12591
12130
lt_aix_libpath_sed='
12592
12131
    /Import File Strings/,/^$/ {
12607
12146
 
12608
12147
fi
12609
12148
 
12610
 
rm -f core conftest.err conftest.$ac_objext \
 
12149
rm -f core conftest.err conftest.$ac_objext conftest_ipa8_conftest.oo \
12611
12150
      conftest$ac_exeext conftest.$ac_ext
12612
12151
if test -z "$aix_libpath"; then aix_libpath="/usr/lib:/lib"; fi
12613
12152
 
12649
12188
  rm -f conftest.er1
12650
12189
  cat conftest.err >&5
12651
12190
  echo "$as_me:$LINENO: \$? = $ac_status" >&5
12652
 
  (exit $ac_status); } &&
12653
 
         { ac_try='test -z "$ac_cxx_werror_flag" || test ! -s conftest.err'
12654
 
  { (case "(($ac_try" in
12655
 
  *\"* | *\`* | *\\*) ac_try_echo=\$ac_try;;
12656
 
  *) ac_try_echo=$ac_try;;
12657
 
esac
12658
 
eval "echo \"\$as_me:$LINENO: $ac_try_echo\"") >&5
12659
 
  (eval "$ac_try") 2>&5
12660
 
  ac_status=$?
12661
 
  echo "$as_me:$LINENO: \$? = $ac_status" >&5
12662
 
  (exit $ac_status); }; } &&
12663
 
         { ac_try='test -s conftest$ac_exeext'
12664
 
  { (case "(($ac_try" in
12665
 
  *\"* | *\`* | *\\*) ac_try_echo=\$ac_try;;
12666
 
  *) ac_try_echo=$ac_try;;
12667
 
esac
12668
 
eval "echo \"\$as_me:$LINENO: $ac_try_echo\"") >&5
12669
 
  (eval "$ac_try") 2>&5
12670
 
  ac_status=$?
12671
 
  echo "$as_me:$LINENO: \$? = $ac_status" >&5
12672
 
  (exit $ac_status); }; }; then
 
12191
  (exit $ac_status); } && {
 
12192
         test -z "$ac_cxx_werror_flag" ||
 
12193
         test ! -s conftest.err
 
12194
       } && test -s conftest$ac_exeext &&
 
12195
       $as_test_x conftest$ac_exeext; then
12673
12196
 
12674
12197
lt_aix_libpath_sed='
12675
12198
    /Import File Strings/,/^$/ {
12690
12213
 
12691
12214
fi
12692
12215
 
12693
 
rm -f core conftest.err conftest.$ac_objext \
 
12216
rm -f core conftest.err conftest.$ac_objext conftest_ipa8_conftest.oo \
12694
12217
      conftest$ac_exeext conftest.$ac_ext
12695
12218
if test -z "$aix_libpath"; then aix_libpath="/usr/lib:/lib"; fi
12696
12219
 
13926
13449
   -e 's:.*FLAGS}\{0,1\} :&$lt_compiler_flag :; t' \
13927
13450
   -e 's: [^ ]*conftest\.: $lt_compiler_flag&:; t' \
13928
13451
   -e 's:$: $lt_compiler_flag:'`
13929
 
   (eval echo "\"\$as_me:13929: $lt_compile\"" >&5)
 
13452
   (eval echo "\"\$as_me:13452: $lt_compile\"" >&5)
13930
13453
   (eval "$lt_compile" 2>conftest.err)
13931
13454
   ac_status=$?
13932
13455
   cat conftest.err >&5
13933
 
   echo "$as_me:13933: \$? = $ac_status" >&5
 
13456
   echo "$as_me:13456: \$? = $ac_status" >&5
13934
13457
   if (exit $ac_status) && test -s "$ac_outfile"; then
13935
13458
     # The compiler can only warn and ignore the option if not recognized
13936
13459
     # So say no if there are warnings other than the usual output.
14030
13553
   -e 's:.*FLAGS}\{0,1\} :&$lt_compiler_flag :; t' \
14031
13554
   -e 's: [^ ]*conftest\.: $lt_compiler_flag&:; t' \
14032
13555
   -e 's:$: $lt_compiler_flag:'`
14033
 
   (eval echo "\"\$as_me:14033: $lt_compile\"" >&5)
 
13556
   (eval echo "\"\$as_me:13556: $lt_compile\"" >&5)
14034
13557
   (eval "$lt_compile" 2>out/conftest.err)
14035
13558
   ac_status=$?
14036
13559
   cat out/conftest.err >&5
14037
 
   echo "$as_me:14037: \$? = $ac_status" >&5
 
13560
   echo "$as_me:13560: \$? = $ac_status" >&5
14038
13561
   if (exit $ac_status) && test -s out/conftest2.$ac_objext
14039
13562
   then
14040
13563
     # The compiler can only warn and ignore the option if not recognized
15591
15114
   -e 's:.*FLAGS}\{0,1\} :&$lt_compiler_flag :; t' \
15592
15115
   -e 's: [^ ]*conftest\.: $lt_compiler_flag&:; t' \
15593
15116
   -e 's:$: $lt_compiler_flag:'`
15594
 
   (eval echo "\"\$as_me:15594: $lt_compile\"" >&5)
 
15117
   (eval echo "\"\$as_me:15117: $lt_compile\"" >&5)
15595
15118
   (eval "$lt_compile" 2>conftest.err)
15596
15119
   ac_status=$?
15597
15120
   cat conftest.err >&5
15598
 
   echo "$as_me:15598: \$? = $ac_status" >&5
 
15121
   echo "$as_me:15121: \$? = $ac_status" >&5
15599
15122
   if (exit $ac_status) && test -s "$ac_outfile"; then
15600
15123
     # The compiler can only warn and ignore the option if not recognized
15601
15124
     # So say no if there are warnings other than the usual output.
15695
15218
   -e 's:.*FLAGS}\{0,1\} :&$lt_compiler_flag :; t' \
15696
15219
   -e 's: [^ ]*conftest\.: $lt_compiler_flag&:; t' \
15697
15220
   -e 's:$: $lt_compiler_flag:'`
15698
 
   (eval echo "\"\$as_me:15698: $lt_compile\"" >&5)
 
15221
   (eval echo "\"\$as_me:15221: $lt_compile\"" >&5)
15699
15222
   (eval "$lt_compile" 2>out/conftest.err)
15700
15223
   ac_status=$?
15701
15224
   cat out/conftest.err >&5
15702
 
   echo "$as_me:15702: \$? = $ac_status" >&5
 
15225
   echo "$as_me:15225: \$? = $ac_status" >&5
15703
15226
   if (exit $ac_status) && test -s out/conftest2.$ac_objext
15704
15227
   then
15705
15228
     # The compiler can only warn and ignore the option if not recognized
16174
15697
  rm -f conftest.er1
16175
15698
  cat conftest.err >&5
16176
15699
  echo "$as_me:$LINENO: \$? = $ac_status" >&5
16177
 
  (exit $ac_status); } &&
16178
 
         { ac_try='test -z "$ac_f77_werror_flag" || test ! -s conftest.err'
16179
 
  { (case "(($ac_try" in
16180
 
  *\"* | *\`* | *\\*) ac_try_echo=\$ac_try;;
16181
 
  *) ac_try_echo=$ac_try;;
16182
 
esac
16183
 
eval "echo \"\$as_me:$LINENO: $ac_try_echo\"") >&5
16184
 
  (eval "$ac_try") 2>&5
16185
 
  ac_status=$?
16186
 
  echo "$as_me:$LINENO: \$? = $ac_status" >&5
16187
 
  (exit $ac_status); }; } &&
16188
 
         { ac_try='test -s conftest$ac_exeext'
16189
 
  { (case "(($ac_try" in
16190
 
  *\"* | *\`* | *\\*) ac_try_echo=\$ac_try;;
16191
 
  *) ac_try_echo=$ac_try;;
16192
 
esac
16193
 
eval "echo \"\$as_me:$LINENO: $ac_try_echo\"") >&5
16194
 
  (eval "$ac_try") 2>&5
16195
 
  ac_status=$?
16196
 
  echo "$as_me:$LINENO: \$? = $ac_status" >&5
16197
 
  (exit $ac_status); }; }; then
 
15700
  (exit $ac_status); } && {
 
15701
         test -z "$ac_f77_werror_flag" ||
 
15702
         test ! -s conftest.err
 
15703
       } && test -s conftest$ac_exeext &&
 
15704
       $as_test_x conftest$ac_exeext; then
16198
15705
 
16199
15706
lt_aix_libpath_sed='
16200
15707
    /Import File Strings/,/^$/ {
16215
15722
 
16216
15723
fi
16217
15724
 
16218
 
rm -f core conftest.err conftest.$ac_objext \
 
15725
rm -f core conftest.err conftest.$ac_objext conftest_ipa8_conftest.oo \
16219
15726
      conftest$ac_exeext conftest.$ac_ext
16220
15727
if test -z "$aix_libpath"; then aix_libpath="/usr/lib:/lib"; fi
16221
15728
 
16246
15753
  rm -f conftest.er1
16247
15754
  cat conftest.err >&5
16248
15755
  echo "$as_me:$LINENO: \$? = $ac_status" >&5
16249
 
  (exit $ac_status); } &&
16250
 
         { ac_try='test -z "$ac_f77_werror_flag" || test ! -s conftest.err'
16251
 
  { (case "(($ac_try" in
16252
 
  *\"* | *\`* | *\\*) ac_try_echo=\$ac_try;;
16253
 
  *) ac_try_echo=$ac_try;;
16254
 
esac
16255
 
eval "echo \"\$as_me:$LINENO: $ac_try_echo\"") >&5
16256
 
  (eval "$ac_try") 2>&5
16257
 
  ac_status=$?
16258
 
  echo "$as_me:$LINENO: \$? = $ac_status" >&5
16259
 
  (exit $ac_status); }; } &&
16260
 
         { ac_try='test -s conftest$ac_exeext'
16261
 
  { (case "(($ac_try" in
16262
 
  *\"* | *\`* | *\\*) ac_try_echo=\$ac_try;;
16263
 
  *) ac_try_echo=$ac_try;;
16264
 
esac
16265
 
eval "echo \"\$as_me:$LINENO: $ac_try_echo\"") >&5
16266
 
  (eval "$ac_try") 2>&5
16267
 
  ac_status=$?
16268
 
  echo "$as_me:$LINENO: \$? = $ac_status" >&5
16269
 
  (exit $ac_status); }; }; then
 
15756
  (exit $ac_status); } && {
 
15757
         test -z "$ac_f77_werror_flag" ||
 
15758
         test ! -s conftest.err
 
15759
       } && test -s conftest$ac_exeext &&
 
15760
       $as_test_x conftest$ac_exeext; then
16270
15761
 
16271
15762
lt_aix_libpath_sed='
16272
15763
    /Import File Strings/,/^$/ {
16287
15778
 
16288
15779
fi
16289
15780
 
16290
 
rm -f core conftest.err conftest.$ac_objext \
 
15781
rm -f core conftest.err conftest.$ac_objext conftest_ipa8_conftest.oo \
16291
15782
      conftest$ac_exeext conftest.$ac_ext
16292
15783
if test -z "$aix_libpath"; then aix_libpath="/usr/lib:/lib"; fi
16293
15784
 
17909
17400
   -e 's:.*FLAGS}\{0,1\} :&$lt_compiler_flag :; t' \
17910
17401
   -e 's: [^ ]*conftest\.: $lt_compiler_flag&:; t' \
17911
17402
   -e 's:$: $lt_compiler_flag:'`
17912
 
   (eval echo "\"\$as_me:17912: $lt_compile\"" >&5)
 
17403
   (eval echo "\"\$as_me:17403: $lt_compile\"" >&5)
17913
17404
   (eval "$lt_compile" 2>conftest.err)
17914
17405
   ac_status=$?
17915
17406
   cat conftest.err >&5
17916
 
   echo "$as_me:17916: \$? = $ac_status" >&5
 
17407
   echo "$as_me:17407: \$? = $ac_status" >&5
17917
17408
   if (exit $ac_status) && test -s "$ac_outfile"; then
17918
17409
     # The compiler can only warn and ignore the option if not recognized
17919
17410
     # So say no if there are warnings other than the usual output.
18199
17690
   -e 's:.*FLAGS}\{0,1\} :&$lt_compiler_flag :; t' \
18200
17691
   -e 's: [^ ]*conftest\.: $lt_compiler_flag&:; t' \
18201
17692
   -e 's:$: $lt_compiler_flag:'`
18202
 
   (eval echo "\"\$as_me:18202: $lt_compile\"" >&5)
 
17693
   (eval echo "\"\$as_me:17693: $lt_compile\"" >&5)
18203
17694
   (eval "$lt_compile" 2>conftest.err)
18204
17695
   ac_status=$?
18205
17696
   cat conftest.err >&5
18206
 
   echo "$as_me:18206: \$? = $ac_status" >&5
 
17697
   echo "$as_me:17697: \$? = $ac_status" >&5
18207
17698
   if (exit $ac_status) && test -s "$ac_outfile"; then
18208
17699
     # The compiler can only warn and ignore the option if not recognized
18209
17700
     # So say no if there are warnings other than the usual output.
18303
17794
   -e 's:.*FLAGS}\{0,1\} :&$lt_compiler_flag :; t' \
18304
17795
   -e 's: [^ ]*conftest\.: $lt_compiler_flag&:; t' \
18305
17796
   -e 's:$: $lt_compiler_flag:'`
18306
 
   (eval echo "\"\$as_me:18306: $lt_compile\"" >&5)
 
17797
   (eval echo "\"\$as_me:17797: $lt_compile\"" >&5)
18307
17798
   (eval "$lt_compile" 2>out/conftest.err)
18308
17799
   ac_status=$?
18309
17800
   cat out/conftest.err >&5
18310
 
   echo "$as_me:18310: \$? = $ac_status" >&5
 
17801
   echo "$as_me:17801: \$? = $ac_status" >&5
18311
17802
   if (exit $ac_status) && test -s out/conftest2.$ac_objext
18312
17803
   then
18313
17804
     # The compiler can only warn and ignore the option if not recognized
18792
18283
  rm -f conftest.er1
18793
18284
  cat conftest.err >&5
18794
18285
  echo "$as_me:$LINENO: \$? = $ac_status" >&5
18795
 
  (exit $ac_status); } &&
18796
 
         { ac_try='test -z "$ac_c_werror_flag" || test ! -s conftest.err'
18797
 
  { (case "(($ac_try" in
18798
 
  *\"* | *\`* | *\\*) ac_try_echo=\$ac_try;;
18799
 
  *) ac_try_echo=$ac_try;;
18800
 
esac
18801
 
eval "echo \"\$as_me:$LINENO: $ac_try_echo\"") >&5
18802
 
  (eval "$ac_try") 2>&5
18803
 
  ac_status=$?
18804
 
  echo "$as_me:$LINENO: \$? = $ac_status" >&5
18805
 
  (exit $ac_status); }; } &&
18806
 
         { ac_try='test -s conftest$ac_exeext'
18807
 
  { (case "(($ac_try" in
18808
 
  *\"* | *\`* | *\\*) ac_try_echo=\$ac_try;;
18809
 
  *) ac_try_echo=$ac_try;;
18810
 
esac
18811
 
eval "echo \"\$as_me:$LINENO: $ac_try_echo\"") >&5
18812
 
  (eval "$ac_try") 2>&5
18813
 
  ac_status=$?
18814
 
  echo "$as_me:$LINENO: \$? = $ac_status" >&5
18815
 
  (exit $ac_status); }; }; then
 
18286
  (exit $ac_status); } && {
 
18287
         test -z "$ac_c_werror_flag" ||
 
18288
         test ! -s conftest.err
 
18289
       } && test -s conftest$ac_exeext &&
 
18290
       $as_test_x conftest$ac_exeext; then
18816
18291
 
18817
18292
lt_aix_libpath_sed='
18818
18293
    /Import File Strings/,/^$/ {
18833
18308
 
18834
18309
fi
18835
18310
 
18836
 
rm -f core conftest.err conftest.$ac_objext \
 
18311
rm -f core conftest.err conftest.$ac_objext conftest_ipa8_conftest.oo \
18837
18312
      conftest$ac_exeext conftest.$ac_ext
18838
18313
if test -z "$aix_libpath"; then aix_libpath="/usr/lib:/lib"; fi
18839
18314
 
18874
18349
  rm -f conftest.er1
18875
18350
  cat conftest.err >&5
18876
18351
  echo "$as_me:$LINENO: \$? = $ac_status" >&5
18877
 
  (exit $ac_status); } &&
18878
 
         { ac_try='test -z "$ac_c_werror_flag" || test ! -s conftest.err'
18879
 
  { (case "(($ac_try" in
18880
 
  *\"* | *\`* | *\\*) ac_try_echo=\$ac_try;;
18881
 
  *) ac_try_echo=$ac_try;;
18882
 
esac
18883
 
eval "echo \"\$as_me:$LINENO: $ac_try_echo\"") >&5
18884
 
  (eval "$ac_try") 2>&5
18885
 
  ac_status=$?
18886
 
  echo "$as_me:$LINENO: \$? = $ac_status" >&5
18887
 
  (exit $ac_status); }; } &&
18888
 
         { ac_try='test -s conftest$ac_exeext'
18889
 
  { (case "(($ac_try" in
18890
 
  *\"* | *\`* | *\\*) ac_try_echo=\$ac_try;;
18891
 
  *) ac_try_echo=$ac_try;;
18892
 
esac
18893
 
eval "echo \"\$as_me:$LINENO: $ac_try_echo\"") >&5
18894
 
  (eval "$ac_try") 2>&5
18895
 
  ac_status=$?
18896
 
  echo "$as_me:$LINENO: \$? = $ac_status" >&5
18897
 
  (exit $ac_status); }; }; then
 
18352
  (exit $ac_status); } && {
 
18353
         test -z "$ac_c_werror_flag" ||
 
18354
         test ! -s conftest.err
 
18355
       } && test -s conftest$ac_exeext &&
 
18356
       $as_test_x conftest$ac_exeext; then
18898
18357
 
18899
18358
lt_aix_libpath_sed='
18900
18359
    /Import File Strings/,/^$/ {
18915
18374
 
18916
18375
fi
18917
18376
 
18918
 
rm -f core conftest.err conftest.$ac_objext \
 
18377
rm -f core conftest.err conftest.$ac_objext conftest_ipa8_conftest.oo \
18919
18378
      conftest$ac_exeext conftest.$ac_ext
18920
18379
if test -z "$aix_libpath"; then aix_libpath="/usr/lib:/lib"; fi
18921
18380
 
21049
20508
  rm -f conftest.er1
21050
20509
  cat conftest.err >&5
21051
20510
  echo "$as_me:$LINENO: \$? = $ac_status" >&5
21052
 
  (exit $ac_status); } &&
21053
 
         { ac_try='test -z "$ac_c_werror_flag" || test ! -s conftest.err'
21054
 
  { (case "(($ac_try" in
21055
 
  *\"* | *\`* | *\\*) ac_try_echo=\$ac_try;;
21056
 
  *) ac_try_echo=$ac_try;;
21057
 
esac
21058
 
eval "echo \"\$as_me:$LINENO: $ac_try_echo\"") >&5
21059
 
  (eval "$ac_try") 2>&5
21060
 
  ac_status=$?
21061
 
  echo "$as_me:$LINENO: \$? = $ac_status" >&5
21062
 
  (exit $ac_status); }; } &&
21063
 
         { ac_try='test -s conftest.$ac_objext'
21064
 
  { (case "(($ac_try" in
21065
 
  *\"* | *\`* | *\\*) ac_try_echo=\$ac_try;;
21066
 
  *) ac_try_echo=$ac_try;;
21067
 
esac
21068
 
eval "echo \"\$as_me:$LINENO: $ac_try_echo\"") >&5
21069
 
  (eval "$ac_try") 2>&5
21070
 
  ac_status=$?
21071
 
  echo "$as_me:$LINENO: \$? = $ac_status" >&5
21072
 
  (exit $ac_status); }; }; then
 
20511
  (exit $ac_status); } && {
 
20512
         test -z "$ac_c_werror_flag" ||
 
20513
         test ! -s conftest.err
 
20514
       } && test -s conftest.$ac_objext; then
21073
20515
  ac_cv_c_inline=$ac_kw
21074
20516
else
21075
20517
  echo "$as_me: failed program was:" >&5
21124
20566
int
21125
20567
main ()
21126
20568
{
21127
 
#if !BYTE_ORDER || !BIG_ENDIAN || !LITTLE_ENDIAN
 
20569
#if  ! (defined BYTE_ORDER && defined BIG_ENDIAN && defined LITTLE_ENDIAN \
 
20570
        && BYTE_ORDER && BIG_ENDIAN && LITTLE_ENDIAN)
21128
20571
 bogus endian macros
21129
20572
#endif
21130
20573
 
21145
20588
  rm -f conftest.er1
21146
20589
  cat conftest.err >&5
21147
20590
  echo "$as_me:$LINENO: \$? = $ac_status" >&5
21148
 
  (exit $ac_status); } &&
21149
 
         { ac_try='test -z "$ac_c_werror_flag" || test ! -s conftest.err'
21150
 
  { (case "(($ac_try" in
21151
 
  *\"* | *\`* | *\\*) ac_try_echo=\$ac_try;;
21152
 
  *) ac_try_echo=$ac_try;;
21153
 
esac
21154
 
eval "echo \"\$as_me:$LINENO: $ac_try_echo\"") >&5
21155
 
  (eval "$ac_try") 2>&5
21156
 
  ac_status=$?
21157
 
  echo "$as_me:$LINENO: \$? = $ac_status" >&5
21158
 
  (exit $ac_status); }; } &&
21159
 
         { ac_try='test -s conftest.$ac_objext'
21160
 
  { (case "(($ac_try" in
21161
 
  *\"* | *\`* | *\\*) ac_try_echo=\$ac_try;;
21162
 
  *) ac_try_echo=$ac_try;;
21163
 
esac
21164
 
eval "echo \"\$as_me:$LINENO: $ac_try_echo\"") >&5
21165
 
  (eval "$ac_try") 2>&5
21166
 
  ac_status=$?
21167
 
  echo "$as_me:$LINENO: \$? = $ac_status" >&5
21168
 
  (exit $ac_status); }; }; then
 
20591
  (exit $ac_status); } && {
 
20592
         test -z "$ac_c_werror_flag" ||
 
20593
         test ! -s conftest.err
 
20594
       } && test -s conftest.$ac_objext; then
21169
20595
  # It does; now see whether it defined to BIG_ENDIAN or not.
21170
20596
cat >conftest.$ac_ext <<_ACEOF
21171
20597
/* confdefs.h.  */
21200
20626
  rm -f conftest.er1
21201
20627
  cat conftest.err >&5
21202
20628
  echo "$as_me:$LINENO: \$? = $ac_status" >&5
21203
 
  (exit $ac_status); } &&
21204
 
         { ac_try='test -z "$ac_c_werror_flag" || test ! -s conftest.err'
21205
 
  { (case "(($ac_try" in
21206
 
  *\"* | *\`* | *\\*) ac_try_echo=\$ac_try;;
21207
 
  *) ac_try_echo=$ac_try;;
21208
 
esac
21209
 
eval "echo \"\$as_me:$LINENO: $ac_try_echo\"") >&5
21210
 
  (eval "$ac_try") 2>&5
21211
 
  ac_status=$?
21212
 
  echo "$as_me:$LINENO: \$? = $ac_status" >&5
21213
 
  (exit $ac_status); }; } &&
21214
 
         { ac_try='test -s conftest.$ac_objext'
21215
 
  { (case "(($ac_try" in
21216
 
  *\"* | *\`* | *\\*) ac_try_echo=\$ac_try;;
21217
 
  *) ac_try_echo=$ac_try;;
21218
 
esac
21219
 
eval "echo \"\$as_me:$LINENO: $ac_try_echo\"") >&5
21220
 
  (eval "$ac_try") 2>&5
21221
 
  ac_status=$?
21222
 
  echo "$as_me:$LINENO: \$? = $ac_status" >&5
21223
 
  (exit $ac_status); }; }; then
 
20629
  (exit $ac_status); } && {
 
20630
         test -z "$ac_c_werror_flag" ||
 
20631
         test ! -s conftest.err
 
20632
       } && test -s conftest.$ac_objext; then
21224
20633
  ac_cv_c_bigendian=yes
21225
20634
else
21226
20635
  echo "$as_me: failed program was:" >&5
21271
20680
  rm -f conftest.er1
21272
20681
  cat conftest.err >&5
21273
20682
  echo "$as_me:$LINENO: \$? = $ac_status" >&5
21274
 
  (exit $ac_status); } &&
21275
 
         { ac_try='test -z "$ac_c_werror_flag" || test ! -s conftest.err'
21276
 
  { (case "(($ac_try" in
21277
 
  *\"* | *\`* | *\\*) ac_try_echo=\$ac_try;;
21278
 
  *) ac_try_echo=$ac_try;;
21279
 
esac
21280
 
eval "echo \"\$as_me:$LINENO: $ac_try_echo\"") >&5
21281
 
  (eval "$ac_try") 2>&5
21282
 
  ac_status=$?
21283
 
  echo "$as_me:$LINENO: \$? = $ac_status" >&5
21284
 
  (exit $ac_status); }; } &&
21285
 
         { ac_try='test -s conftest.$ac_objext'
21286
 
  { (case "(($ac_try" in
21287
 
  *\"* | *\`* | *\\*) ac_try_echo=\$ac_try;;
21288
 
  *) ac_try_echo=$ac_try;;
21289
 
esac
21290
 
eval "echo \"\$as_me:$LINENO: $ac_try_echo\"") >&5
21291
 
  (eval "$ac_try") 2>&5
21292
 
  ac_status=$?
21293
 
  echo "$as_me:$LINENO: \$? = $ac_status" >&5
21294
 
  (exit $ac_status); }; }; then
 
20683
  (exit $ac_status); } && {
 
20684
         test -z "$ac_c_werror_flag" ||
 
20685
         test ! -s conftest.err
 
20686
       } && test -s conftest.$ac_objext; then
21295
20687
  if grep BIGenDianSyS conftest.$ac_objext >/dev/null ; then
21296
20688
  ac_cv_c_bigendian=yes
21297
20689
fi
21448
20840
  rm -f conftest.er1
21449
20841
  cat conftest.err >&5
21450
20842
  echo "$as_me:$LINENO: \$? = $ac_status" >&5
21451
 
  (exit $ac_status); } &&
21452
 
         { ac_try='test -z "$ac_c_werror_flag" || test ! -s conftest.err'
21453
 
  { (case "(($ac_try" in
21454
 
  *\"* | *\`* | *\\*) ac_try_echo=\$ac_try;;
21455
 
  *) ac_try_echo=$ac_try;;
21456
 
esac
21457
 
eval "echo \"\$as_me:$LINENO: $ac_try_echo\"") >&5
21458
 
  (eval "$ac_try") 2>&5
21459
 
  ac_status=$?
21460
 
  echo "$as_me:$LINENO: \$? = $ac_status" >&5
21461
 
  (exit $ac_status); }; } &&
21462
 
         { ac_try='test -s conftest.$ac_objext'
21463
 
  { (case "(($ac_try" in
21464
 
  *\"* | *\`* | *\\*) ac_try_echo=\$ac_try;;
21465
 
  *) ac_try_echo=$ac_try;;
21466
 
esac
21467
 
eval "echo \"\$as_me:$LINENO: $ac_try_echo\"") >&5
21468
 
  (eval "$ac_try") 2>&5
21469
 
  ac_status=$?
21470
 
  echo "$as_me:$LINENO: \$? = $ac_status" >&5
21471
 
  (exit $ac_status); }; }; then
 
20843
  (exit $ac_status); } && {
 
20844
         test -z "$ac_c_werror_flag" ||
 
20845
         test ! -s conftest.err
 
20846
       } && test -s conftest.$ac_objext; then
21472
20847
  ac_cv_type_int=yes
21473
20848
else
21474
20849
  echo "$as_me: failed program was:" >&5
21482
20857
{ echo "$as_me:$LINENO: result: $ac_cv_type_int" >&5
21483
20858
echo "${ECHO_T}$ac_cv_type_int" >&6; }
21484
20859
 
 
20860
# The cast to long int works around a bug in the HP C Compiler
 
20861
# version HP92453-01 B.11.11.23709.GP, which incorrectly rejects
 
20862
# declarations like `int a3[[(sizeof (unsigned char)) >= 0]];'.
 
20863
# This bug is HP SR number 8606223364.
21485
20864
{ echo "$as_me:$LINENO: checking size of int" >&5
21486
20865
echo $ECHO_N "checking size of int... $ECHO_C" >&6; }
21487
20866
if test "${ac_cv_sizeof_int+set}" = set; then
21488
20867
  echo $ECHO_N "(cached) $ECHO_C" >&6
21489
20868
else
21490
 
  if test "$ac_cv_type_int" = yes; then
21491
 
  # The cast to long int works around a bug in the HP C Compiler
21492
 
  # version HP92453-01 B.11.11.23709.GP, which incorrectly rejects
21493
 
  # declarations like `int a3[[(sizeof (unsigned char)) >= 0]];'.
21494
 
  # This bug is HP SR number 8606223364.
21495
20869
  if test "$cross_compiling" = yes; then
21496
20870
  # Depending upon the size, compute the lo and hi bounds.
21497
20871
cat >conftest.$ac_ext <<_ACEOF
21501
20875
cat >>conftest.$ac_ext <<_ACEOF
21502
20876
/* end confdefs.h.  */
21503
20877
$ac_includes_default
21504
 
                   typedef int ac__type_sizeof_;
 
20878
   typedef int ac__type_sizeof_;
21505
20879
int
21506
20880
main ()
21507
20881
{
21525
20899
  rm -f conftest.er1
21526
20900
  cat conftest.err >&5
21527
20901
  echo "$as_me:$LINENO: \$? = $ac_status" >&5
21528
 
  (exit $ac_status); } &&
21529
 
         { ac_try='test -z "$ac_c_werror_flag" || test ! -s conftest.err'
21530
 
  { (case "(($ac_try" in
21531
 
  *\"* | *\`* | *\\*) ac_try_echo=\$ac_try;;
21532
 
  *) ac_try_echo=$ac_try;;
21533
 
esac
21534
 
eval "echo \"\$as_me:$LINENO: $ac_try_echo\"") >&5
21535
 
  (eval "$ac_try") 2>&5
21536
 
  ac_status=$?
21537
 
  echo "$as_me:$LINENO: \$? = $ac_status" >&5
21538
 
  (exit $ac_status); }; } &&
21539
 
         { ac_try='test -s conftest.$ac_objext'
21540
 
  { (case "(($ac_try" in
21541
 
  *\"* | *\`* | *\\*) ac_try_echo=\$ac_try;;
21542
 
  *) ac_try_echo=$ac_try;;
21543
 
esac
21544
 
eval "echo \"\$as_me:$LINENO: $ac_try_echo\"") >&5
21545
 
  (eval "$ac_try") 2>&5
21546
 
  ac_status=$?
21547
 
  echo "$as_me:$LINENO: \$? = $ac_status" >&5
21548
 
  (exit $ac_status); }; }; then
 
20902
  (exit $ac_status); } && {
 
20903
         test -z "$ac_c_werror_flag" ||
 
20904
         test ! -s conftest.err
 
20905
       } && test -s conftest.$ac_objext; then
21549
20906
  ac_lo=0 ac_mid=0
21550
20907
  while :; do
21551
20908
    cat >conftest.$ac_ext <<_ACEOF
21555
20912
cat >>conftest.$ac_ext <<_ACEOF
21556
20913
/* end confdefs.h.  */
21557
20914
$ac_includes_default
21558
 
                   typedef int ac__type_sizeof_;
 
20915
   typedef int ac__type_sizeof_;
21559
20916
int
21560
20917
main ()
21561
20918
{
21579
20936
  rm -f conftest.er1
21580
20937
  cat conftest.err >&5
21581
20938
  echo "$as_me:$LINENO: \$? = $ac_status" >&5
21582
 
  (exit $ac_status); } &&
21583
 
         { ac_try='test -z "$ac_c_werror_flag" || test ! -s conftest.err'
21584
 
  { (case "(($ac_try" in
21585
 
  *\"* | *\`* | *\\*) ac_try_echo=\$ac_try;;
21586
 
  *) ac_try_echo=$ac_try;;
21587
 
esac
21588
 
eval "echo \"\$as_me:$LINENO: $ac_try_echo\"") >&5
21589
 
  (eval "$ac_try") 2>&5
21590
 
  ac_status=$?
21591
 
  echo "$as_me:$LINENO: \$? = $ac_status" >&5
21592
 
  (exit $ac_status); }; } &&
21593
 
         { ac_try='test -s conftest.$ac_objext'
21594
 
  { (case "(($ac_try" in
21595
 
  *\"* | *\`* | *\\*) ac_try_echo=\$ac_try;;
21596
 
  *) ac_try_echo=$ac_try;;
21597
 
esac
21598
 
eval "echo \"\$as_me:$LINENO: $ac_try_echo\"") >&5
21599
 
  (eval "$ac_try") 2>&5
21600
 
  ac_status=$?
21601
 
  echo "$as_me:$LINENO: \$? = $ac_status" >&5
21602
 
  (exit $ac_status); }; }; then
 
20939
  (exit $ac_status); } && {
 
20940
         test -z "$ac_c_werror_flag" ||
 
20941
         test ! -s conftest.err
 
20942
       } && test -s conftest.$ac_objext; then
21603
20943
  ac_hi=$ac_mid; break
21604
20944
else
21605
20945
  echo "$as_me: failed program was:" >&5
21626
20966
cat >>conftest.$ac_ext <<_ACEOF
21627
20967
/* end confdefs.h.  */
21628
20968
$ac_includes_default
21629
 
                   typedef int ac__type_sizeof_;
 
20969
   typedef int ac__type_sizeof_;
21630
20970
int
21631
20971
main ()
21632
20972
{
21650
20990
  rm -f conftest.er1
21651
20991
  cat conftest.err >&5
21652
20992
  echo "$as_me:$LINENO: \$? = $ac_status" >&5
21653
 
  (exit $ac_status); } &&
21654
 
         { ac_try='test -z "$ac_c_werror_flag" || test ! -s conftest.err'
21655
 
  { (case "(($ac_try" in
21656
 
  *\"* | *\`* | *\\*) ac_try_echo=\$ac_try;;
21657
 
  *) ac_try_echo=$ac_try;;
21658
 
esac
21659
 
eval "echo \"\$as_me:$LINENO: $ac_try_echo\"") >&5
21660
 
  (eval "$ac_try") 2>&5
21661
 
  ac_status=$?
21662
 
  echo "$as_me:$LINENO: \$? = $ac_status" >&5
21663
 
  (exit $ac_status); }; } &&
21664
 
         { ac_try='test -s conftest.$ac_objext'
21665
 
  { (case "(($ac_try" in
21666
 
  *\"* | *\`* | *\\*) ac_try_echo=\$ac_try;;
21667
 
  *) ac_try_echo=$ac_try;;
21668
 
esac
21669
 
eval "echo \"\$as_me:$LINENO: $ac_try_echo\"") >&5
21670
 
  (eval "$ac_try") 2>&5
21671
 
  ac_status=$?
21672
 
  echo "$as_me:$LINENO: \$? = $ac_status" >&5
21673
 
  (exit $ac_status); }; }; then
 
20993
  (exit $ac_status); } && {
 
20994
         test -z "$ac_c_werror_flag" ||
 
20995
         test ! -s conftest.err
 
20996
       } && test -s conftest.$ac_objext; then
21674
20997
  ac_hi=-1 ac_mid=-1
21675
20998
  while :; do
21676
20999
    cat >conftest.$ac_ext <<_ACEOF
21680
21003
cat >>conftest.$ac_ext <<_ACEOF
21681
21004
/* end confdefs.h.  */
21682
21005
$ac_includes_default
21683
 
                   typedef int ac__type_sizeof_;
 
21006
   typedef int ac__type_sizeof_;
21684
21007
int
21685
21008
main ()
21686
21009
{
21704
21027
  rm -f conftest.er1
21705
21028
  cat conftest.err >&5
21706
21029
  echo "$as_me:$LINENO: \$? = $ac_status" >&5
21707
 
  (exit $ac_status); } &&
21708
 
         { ac_try='test -z "$ac_c_werror_flag" || test ! -s conftest.err'
21709
 
  { (case "(($ac_try" in
21710
 
  *\"* | *\`* | *\\*) ac_try_echo=\$ac_try;;
21711
 
  *) ac_try_echo=$ac_try;;
21712
 
esac
21713
 
eval "echo \"\$as_me:$LINENO: $ac_try_echo\"") >&5
21714
 
  (eval "$ac_try") 2>&5
21715
 
  ac_status=$?
21716
 
  echo "$as_me:$LINENO: \$? = $ac_status" >&5
21717
 
  (exit $ac_status); }; } &&
21718
 
         { ac_try='test -s conftest.$ac_objext'
21719
 
  { (case "(($ac_try" in
21720
 
  *\"* | *\`* | *\\*) ac_try_echo=\$ac_try;;
21721
 
  *) ac_try_echo=$ac_try;;
21722
 
esac
21723
 
eval "echo \"\$as_me:$LINENO: $ac_try_echo\"") >&5
21724
 
  (eval "$ac_try") 2>&5
21725
 
  ac_status=$?
21726
 
  echo "$as_me:$LINENO: \$? = $ac_status" >&5
21727
 
  (exit $ac_status); }; }; then
 
21030
  (exit $ac_status); } && {
 
21031
         test -z "$ac_c_werror_flag" ||
 
21032
         test ! -s conftest.err
 
21033
       } && test -s conftest.$ac_objext; then
21728
21034
  ac_lo=$ac_mid; break
21729
21035
else
21730
21036
  echo "$as_me: failed program was:" >&5
21761
21067
cat >>conftest.$ac_ext <<_ACEOF
21762
21068
/* end confdefs.h.  */
21763
21069
$ac_includes_default
21764
 
                   typedef int ac__type_sizeof_;
 
21070
   typedef int ac__type_sizeof_;
21765
21071
int
21766
21072
main ()
21767
21073
{
21785
21091
  rm -f conftest.er1
21786
21092
  cat conftest.err >&5
21787
21093
  echo "$as_me:$LINENO: \$? = $ac_status" >&5
21788
 
  (exit $ac_status); } &&
21789
 
         { ac_try='test -z "$ac_c_werror_flag" || test ! -s conftest.err'
21790
 
  { (case "(($ac_try" in
21791
 
  *\"* | *\`* | *\\*) ac_try_echo=\$ac_try;;
21792
 
  *) ac_try_echo=$ac_try;;
21793
 
esac
21794
 
eval "echo \"\$as_me:$LINENO: $ac_try_echo\"") >&5
21795
 
  (eval "$ac_try") 2>&5
21796
 
  ac_status=$?
21797
 
  echo "$as_me:$LINENO: \$? = $ac_status" >&5
21798
 
  (exit $ac_status); }; } &&
21799
 
         { ac_try='test -s conftest.$ac_objext'
21800
 
  { (case "(($ac_try" in
21801
 
  *\"* | *\`* | *\\*) ac_try_echo=\$ac_try;;
21802
 
  *) ac_try_echo=$ac_try;;
21803
 
esac
21804
 
eval "echo \"\$as_me:$LINENO: $ac_try_echo\"") >&5
21805
 
  (eval "$ac_try") 2>&5
21806
 
  ac_status=$?
21807
 
  echo "$as_me:$LINENO: \$? = $ac_status" >&5
21808
 
  (exit $ac_status); }; }; then
 
21094
  (exit $ac_status); } && {
 
21095
         test -z "$ac_c_werror_flag" ||
 
21096
         test ! -s conftest.err
 
21097
       } && test -s conftest.$ac_objext; then
21809
21098
  ac_hi=$ac_mid
21810
21099
else
21811
21100
  echo "$as_me: failed program was:" >&5
21818
21107
done
21819
21108
case $ac_lo in
21820
21109
?*) ac_cv_sizeof_int=$ac_lo;;
21821
 
'') { { echo "$as_me:$LINENO: error: cannot compute sizeof (int)
 
21110
'') if test "$ac_cv_type_int" = yes; then
 
21111
     { { echo "$as_me:$LINENO: error: cannot compute sizeof (int)
21822
21112
See \`config.log' for more details." >&5
21823
21113
echo "$as_me: error: cannot compute sizeof (int)
21824
21114
See \`config.log' for more details." >&2;}
21825
 
   { (exit 77); exit 77; }; } ;;
 
21115
   { (exit 77); exit 77; }; }
 
21116
   else
 
21117
     ac_cv_sizeof_int=0
 
21118
   fi ;;
21826
21119
esac
21827
21120
else
21828
21121
  cat >conftest.$ac_ext <<_ACEOF
21832
21125
cat >>conftest.$ac_ext <<_ACEOF
21833
21126
/* end confdefs.h.  */
21834
21127
$ac_includes_default
21835
 
                   typedef int ac__type_sizeof_;
 
21128
   typedef int ac__type_sizeof_;
21836
21129
static long int longval () { return (long int) (sizeof (ac__type_sizeof_)); }
21837
21130
static unsigned long int ulongval () { return (long int) (sizeof (ac__type_sizeof_)); }
21838
21131
#include <stdio.h>
21891
21184
sed 's/^/| /' conftest.$ac_ext >&5
21892
21185
 
21893
21186
( exit $ac_status )
21894
 
{ { echo "$as_me:$LINENO: error: cannot compute sizeof (int)
 
21187
if test "$ac_cv_type_int" = yes; then
 
21188
     { { echo "$as_me:$LINENO: error: cannot compute sizeof (int)
21895
21189
See \`config.log' for more details." >&5
21896
21190
echo "$as_me: error: cannot compute sizeof (int)
21897
21191
See \`config.log' for more details." >&2;}
21898
21192
   { (exit 77); exit 77; }; }
 
21193
   else
 
21194
     ac_cv_sizeof_int=0
 
21195
   fi
21899
21196
fi
21900
21197
rm -f core *.core core.conftest.* gmon.out bb.out conftest$ac_exeext conftest.$ac_objext conftest.$ac_ext
21901
21198
fi
21902
21199
rm -f conftest.val
21903
 
else
21904
 
  ac_cv_sizeof_int=0
21905
 
fi
21906
21200
fi
21907
21201
{ echo "$as_me:$LINENO: result: $ac_cv_sizeof_int" >&5
21908
21202
echo "${ECHO_T}$ac_cv_sizeof_int" >&6; }
 
21203
 
 
21204
 
 
21205
 
21909
21206
cat >>confdefs.h <<_ACEOF
21910
21207
#define SIZEOF_INT $ac_cv_sizeof_int
21911
21208
_ACEOF
21951
21248
  rm -f conftest.er1
21952
21249
  cat conftest.err >&5
21953
21250
  echo "$as_me:$LINENO: \$? = $ac_status" >&5
21954
 
  (exit $ac_status); } &&
21955
 
         { ac_try='test -z "$ac_c_werror_flag" || test ! -s conftest.err'
21956
 
  { (case "(($ac_try" in
21957
 
  *\"* | *\`* | *\\*) ac_try_echo=\$ac_try;;
21958
 
  *) ac_try_echo=$ac_try;;
21959
 
esac
21960
 
eval "echo \"\$as_me:$LINENO: $ac_try_echo\"") >&5
21961
 
  (eval "$ac_try") 2>&5
21962
 
  ac_status=$?
21963
 
  echo "$as_me:$LINENO: \$? = $ac_status" >&5
21964
 
  (exit $ac_status); }; } &&
21965
 
         { ac_try='test -s conftest.$ac_objext'
21966
 
  { (case "(($ac_try" in
21967
 
  *\"* | *\`* | *\\*) ac_try_echo=\$ac_try;;
21968
 
  *) ac_try_echo=$ac_try;;
21969
 
esac
21970
 
eval "echo \"\$as_me:$LINENO: $ac_try_echo\"") >&5
21971
 
  (eval "$ac_try") 2>&5
21972
 
  ac_status=$?
21973
 
  echo "$as_me:$LINENO: \$? = $ac_status" >&5
21974
 
  (exit $ac_status); }; }; then
 
21251
  (exit $ac_status); } && {
 
21252
         test -z "$ac_c_werror_flag" ||
 
21253
         test ! -s conftest.err
 
21254
       } && test -s conftest.$ac_objext; then
21975
21255
  ac_cv_type_unsigned_int=yes
21976
21256
else
21977
21257
  echo "$as_me: failed program was:" >&5
21985
21265
{ echo "$as_me:$LINENO: result: $ac_cv_type_unsigned_int" >&5
21986
21266
echo "${ECHO_T}$ac_cv_type_unsigned_int" >&6; }
21987
21267
 
 
21268
# The cast to long int works around a bug in the HP C Compiler
 
21269
# version HP92453-01 B.11.11.23709.GP, which incorrectly rejects
 
21270
# declarations like `int a3[[(sizeof (unsigned char)) >= 0]];'.
 
21271
# This bug is HP SR number 8606223364.
21988
21272
{ echo "$as_me:$LINENO: checking size of unsigned int" >&5
21989
21273
echo $ECHO_N "checking size of unsigned int... $ECHO_C" >&6; }
21990
21274
if test "${ac_cv_sizeof_unsigned_int+set}" = set; then
21991
21275
  echo $ECHO_N "(cached) $ECHO_C" >&6
21992
21276
else
21993
 
  if test "$ac_cv_type_unsigned_int" = yes; then
21994
 
  # The cast to long int works around a bug in the HP C Compiler
21995
 
  # version HP92453-01 B.11.11.23709.GP, which incorrectly rejects
21996
 
  # declarations like `int a3[[(sizeof (unsigned char)) >= 0]];'.
21997
 
  # This bug is HP SR number 8606223364.
21998
21277
  if test "$cross_compiling" = yes; then
21999
21278
  # Depending upon the size, compute the lo and hi bounds.
22000
21279
cat >conftest.$ac_ext <<_ACEOF
22004
21283
cat >>conftest.$ac_ext <<_ACEOF
22005
21284
/* end confdefs.h.  */
22006
21285
$ac_includes_default
22007
 
                   typedef unsigned int ac__type_sizeof_;
 
21286
   typedef unsigned int ac__type_sizeof_;
22008
21287
int
22009
21288
main ()
22010
21289
{
22028
21307
  rm -f conftest.er1
22029
21308
  cat conftest.err >&5
22030
21309
  echo "$as_me:$LINENO: \$? = $ac_status" >&5
22031
 
  (exit $ac_status); } &&
22032
 
         { ac_try='test -z "$ac_c_werror_flag" || test ! -s conftest.err'
22033
 
  { (case "(($ac_try" in
22034
 
  *\"* | *\`* | *\\*) ac_try_echo=\$ac_try;;
22035
 
  *) ac_try_echo=$ac_try;;
22036
 
esac
22037
 
eval "echo \"\$as_me:$LINENO: $ac_try_echo\"") >&5
22038
 
  (eval "$ac_try") 2>&5
22039
 
  ac_status=$?
22040
 
  echo "$as_me:$LINENO: \$? = $ac_status" >&5
22041
 
  (exit $ac_status); }; } &&
22042
 
         { ac_try='test -s conftest.$ac_objext'
22043
 
  { (case "(($ac_try" in
22044
 
  *\"* | *\`* | *\\*) ac_try_echo=\$ac_try;;
22045
 
  *) ac_try_echo=$ac_try;;
22046
 
esac
22047
 
eval "echo \"\$as_me:$LINENO: $ac_try_echo\"") >&5
22048
 
  (eval "$ac_try") 2>&5
22049
 
  ac_status=$?
22050
 
  echo "$as_me:$LINENO: \$? = $ac_status" >&5
22051
 
  (exit $ac_status); }; }; then
 
21310
  (exit $ac_status); } && {
 
21311
         test -z "$ac_c_werror_flag" ||
 
21312
         test ! -s conftest.err
 
21313
       } && test -s conftest.$ac_objext; then
22052
21314
  ac_lo=0 ac_mid=0
22053
21315
  while :; do
22054
21316
    cat >conftest.$ac_ext <<_ACEOF
22058
21320
cat >>conftest.$ac_ext <<_ACEOF
22059
21321
/* end confdefs.h.  */
22060
21322
$ac_includes_default
22061
 
                   typedef unsigned int ac__type_sizeof_;
 
21323
   typedef unsigned int ac__type_sizeof_;
22062
21324
int
22063
21325
main ()
22064
21326
{
22082
21344
  rm -f conftest.er1
22083
21345
  cat conftest.err >&5
22084
21346
  echo "$as_me:$LINENO: \$? = $ac_status" >&5
22085
 
  (exit $ac_status); } &&
22086
 
         { ac_try='test -z "$ac_c_werror_flag" || test ! -s conftest.err'
22087
 
  { (case "(($ac_try" in
22088
 
  *\"* | *\`* | *\\*) ac_try_echo=\$ac_try;;
22089
 
  *) ac_try_echo=$ac_try;;
22090
 
esac
22091
 
eval "echo \"\$as_me:$LINENO: $ac_try_echo\"") >&5
22092
 
  (eval "$ac_try") 2>&5
22093
 
  ac_status=$?
22094
 
  echo "$as_me:$LINENO: \$? = $ac_status" >&5
22095
 
  (exit $ac_status); }; } &&
22096
 
         { ac_try='test -s conftest.$ac_objext'
22097
 
  { (case "(($ac_try" in
22098
 
  *\"* | *\`* | *\\*) ac_try_echo=\$ac_try;;
22099
 
  *) ac_try_echo=$ac_try;;
22100
 
esac
22101
 
eval "echo \"\$as_me:$LINENO: $ac_try_echo\"") >&5
22102
 
  (eval "$ac_try") 2>&5
22103
 
  ac_status=$?
22104
 
  echo "$as_me:$LINENO: \$? = $ac_status" >&5
22105
 
  (exit $ac_status); }; }; then
 
21347
  (exit $ac_status); } && {
 
21348
         test -z "$ac_c_werror_flag" ||
 
21349
         test ! -s conftest.err
 
21350
       } && test -s conftest.$ac_objext; then
22106
21351
  ac_hi=$ac_mid; break
22107
21352
else
22108
21353
  echo "$as_me: failed program was:" >&5
22129
21374
cat >>conftest.$ac_ext <<_ACEOF
22130
21375
/* end confdefs.h.  */
22131
21376
$ac_includes_default
22132
 
                   typedef unsigned int ac__type_sizeof_;
 
21377
   typedef unsigned int ac__type_sizeof_;
22133
21378
int
22134
21379
main ()
22135
21380
{
22153
21398
  rm -f conftest.er1
22154
21399
  cat conftest.err >&5
22155
21400
  echo "$as_me:$LINENO: \$? = $ac_status" >&5
22156
 
  (exit $ac_status); } &&
22157
 
         { ac_try='test -z "$ac_c_werror_flag" || test ! -s conftest.err'
22158
 
  { (case "(($ac_try" in
22159
 
  *\"* | *\`* | *\\*) ac_try_echo=\$ac_try;;
22160
 
  *) ac_try_echo=$ac_try;;
22161
 
esac
22162
 
eval "echo \"\$as_me:$LINENO: $ac_try_echo\"") >&5
22163
 
  (eval "$ac_try") 2>&5
22164
 
  ac_status=$?
22165
 
  echo "$as_me:$LINENO: \$? = $ac_status" >&5
22166
 
  (exit $ac_status); }; } &&
22167
 
         { ac_try='test -s conftest.$ac_objext'
22168
 
  { (case "(($ac_try" in
22169
 
  *\"* | *\`* | *\\*) ac_try_echo=\$ac_try;;
22170
 
  *) ac_try_echo=$ac_try;;
22171
 
esac
22172
 
eval "echo \"\$as_me:$LINENO: $ac_try_echo\"") >&5
22173
 
  (eval "$ac_try") 2>&5
22174
 
  ac_status=$?
22175
 
  echo "$as_me:$LINENO: \$? = $ac_status" >&5
22176
 
  (exit $ac_status); }; }; then
 
21401
  (exit $ac_status); } && {
 
21402
         test -z "$ac_c_werror_flag" ||
 
21403
         test ! -s conftest.err
 
21404
       } && test -s conftest.$ac_objext; then
22177
21405
  ac_hi=-1 ac_mid=-1
22178
21406
  while :; do
22179
21407
    cat >conftest.$ac_ext <<_ACEOF
22183
21411
cat >>conftest.$ac_ext <<_ACEOF
22184
21412
/* end confdefs.h.  */
22185
21413
$ac_includes_default
22186
 
                   typedef unsigned int ac__type_sizeof_;
 
21414
   typedef unsigned int ac__type_sizeof_;
22187
21415
int
22188
21416
main ()
22189
21417
{
22207
21435
  rm -f conftest.er1
22208
21436
  cat conftest.err >&5
22209
21437
  echo "$as_me:$LINENO: \$? = $ac_status" >&5
22210
 
  (exit $ac_status); } &&
22211
 
         { ac_try='test -z "$ac_c_werror_flag" || test ! -s conftest.err'
22212
 
  { (case "(($ac_try" in
22213
 
  *\"* | *\`* | *\\*) ac_try_echo=\$ac_try;;
22214
 
  *) ac_try_echo=$ac_try;;
22215
 
esac
22216
 
eval "echo \"\$as_me:$LINENO: $ac_try_echo\"") >&5
22217
 
  (eval "$ac_try") 2>&5
22218
 
  ac_status=$?
22219
 
  echo "$as_me:$LINENO: \$? = $ac_status" >&5
22220
 
  (exit $ac_status); }; } &&
22221
 
         { ac_try='test -s conftest.$ac_objext'
22222
 
  { (case "(($ac_try" in
22223
 
  *\"* | *\`* | *\\*) ac_try_echo=\$ac_try;;
22224
 
  *) ac_try_echo=$ac_try;;
22225
 
esac
22226
 
eval "echo \"\$as_me:$LINENO: $ac_try_echo\"") >&5
22227
 
  (eval "$ac_try") 2>&5
22228
 
  ac_status=$?
22229
 
  echo "$as_me:$LINENO: \$? = $ac_status" >&5
22230
 
  (exit $ac_status); }; }; then
 
21438
  (exit $ac_status); } && {
 
21439
         test -z "$ac_c_werror_flag" ||
 
21440
         test ! -s conftest.err
 
21441
       } && test -s conftest.$ac_objext; then
22231
21442
  ac_lo=$ac_mid; break
22232
21443
else
22233
21444
  echo "$as_me: failed program was:" >&5
22264
21475
cat >>conftest.$ac_ext <<_ACEOF
22265
21476
/* end confdefs.h.  */
22266
21477
$ac_includes_default
22267
 
                   typedef unsigned int ac__type_sizeof_;
 
21478
   typedef unsigned int ac__type_sizeof_;
22268
21479
int
22269
21480
main ()
22270
21481
{
22288
21499
  rm -f conftest.er1
22289
21500
  cat conftest.err >&5
22290
21501
  echo "$as_me:$LINENO: \$? = $ac_status" >&5
22291
 
  (exit $ac_status); } &&
22292
 
         { ac_try='test -z "$ac_c_werror_flag" || test ! -s conftest.err'
22293
 
  { (case "(($ac_try" in
22294
 
  *\"* | *\`* | *\\*) ac_try_echo=\$ac_try;;
22295
 
  *) ac_try_echo=$ac_try;;
22296
 
esac
22297
 
eval "echo \"\$as_me:$LINENO: $ac_try_echo\"") >&5
22298
 
  (eval "$ac_try") 2>&5
22299
 
  ac_status=$?
22300
 
  echo "$as_me:$LINENO: \$? = $ac_status" >&5
22301
 
  (exit $ac_status); }; } &&
22302
 
         { ac_try='test -s conftest.$ac_objext'
22303
 
  { (case "(($ac_try" in
22304
 
  *\"* | *\`* | *\\*) ac_try_echo=\$ac_try;;
22305
 
  *) ac_try_echo=$ac_try;;
22306
 
esac
22307
 
eval "echo \"\$as_me:$LINENO: $ac_try_echo\"") >&5
22308
 
  (eval "$ac_try") 2>&5
22309
 
  ac_status=$?
22310
 
  echo "$as_me:$LINENO: \$? = $ac_status" >&5
22311
 
  (exit $ac_status); }; }; then
 
21502
  (exit $ac_status); } && {
 
21503
         test -z "$ac_c_werror_flag" ||
 
21504
         test ! -s conftest.err
 
21505
       } && test -s conftest.$ac_objext; then
22312
21506
  ac_hi=$ac_mid
22313
21507
else
22314
21508
  echo "$as_me: failed program was:" >&5
22321
21515
done
22322
21516
case $ac_lo in
22323
21517
?*) ac_cv_sizeof_unsigned_int=$ac_lo;;
22324
 
'') { { echo "$as_me:$LINENO: error: cannot compute sizeof (unsigned int)
 
21518
'') if test "$ac_cv_type_unsigned_int" = yes; then
 
21519
     { { echo "$as_me:$LINENO: error: cannot compute sizeof (unsigned int)
22325
21520
See \`config.log' for more details." >&5
22326
21521
echo "$as_me: error: cannot compute sizeof (unsigned int)
22327
21522
See \`config.log' for more details." >&2;}
22328
 
   { (exit 77); exit 77; }; } ;;
 
21523
   { (exit 77); exit 77; }; }
 
21524
   else
 
21525
     ac_cv_sizeof_unsigned_int=0
 
21526
   fi ;;
22329
21527
esac
22330
21528
else
22331
21529
  cat >conftest.$ac_ext <<_ACEOF
22335
21533
cat >>conftest.$ac_ext <<_ACEOF
22336
21534
/* end confdefs.h.  */
22337
21535
$ac_includes_default
22338
 
                   typedef unsigned int ac__type_sizeof_;
 
21536
   typedef unsigned int ac__type_sizeof_;
22339
21537
static long int longval () { return (long int) (sizeof (ac__type_sizeof_)); }
22340
21538
static unsigned long int ulongval () { return (long int) (sizeof (ac__type_sizeof_)); }
22341
21539
#include <stdio.h>
22394
21592
sed 's/^/| /' conftest.$ac_ext >&5
22395
21593
 
22396
21594
( exit $ac_status )
22397
 
{ { echo "$as_me:$LINENO: error: cannot compute sizeof (unsigned int)
 
21595
if test "$ac_cv_type_unsigned_int" = yes; then
 
21596
     { { echo "$as_me:$LINENO: error: cannot compute sizeof (unsigned int)
22398
21597
See \`config.log' for more details." >&5
22399
21598
echo "$as_me: error: cannot compute sizeof (unsigned int)
22400
21599
See \`config.log' for more details." >&2;}
22401
21600
   { (exit 77); exit 77; }; }
 
21601
   else
 
21602
     ac_cv_sizeof_unsigned_int=0
 
21603
   fi
22402
21604
fi
22403
21605
rm -f core *.core core.conftest.* gmon.out bb.out conftest$ac_exeext conftest.$ac_objext conftest.$ac_ext
22404
21606
fi
22405
21607
rm -f conftest.val
22406
 
else
22407
 
  ac_cv_sizeof_unsigned_int=0
22408
 
fi
22409
21608
fi
22410
21609
{ echo "$as_me:$LINENO: result: $ac_cv_sizeof_unsigned_int" >&5
22411
21610
echo "${ECHO_T}$ac_cv_sizeof_unsigned_int" >&6; }
 
21611
 
 
21612
 
 
21613
 
22412
21614
cat >>confdefs.h <<_ACEOF
22413
21615
#define SIZEOF_UNSIGNED_INT $ac_cv_sizeof_unsigned_int
22414
21616
_ACEOF
22454
21656
  rm -f conftest.er1
22455
21657
  cat conftest.err >&5
22456
21658
  echo "$as_me:$LINENO: \$? = $ac_status" >&5
22457
 
  (exit $ac_status); } &&
22458
 
         { ac_try='test -z "$ac_c_werror_flag" || test ! -s conftest.err'
22459
 
  { (case "(($ac_try" in
22460
 
  *\"* | *\`* | *\\*) ac_try_echo=\$ac_try;;
22461
 
  *) ac_try_echo=$ac_try;;
22462
 
esac
22463
 
eval "echo \"\$as_me:$LINENO: $ac_try_echo\"") >&5
22464
 
  (eval "$ac_try") 2>&5
22465
 
  ac_status=$?
22466
 
  echo "$as_me:$LINENO: \$? = $ac_status" >&5
22467
 
  (exit $ac_status); }; } &&
22468
 
         { ac_try='test -s conftest.$ac_objext'
22469
 
  { (case "(($ac_try" in
22470
 
  *\"* | *\`* | *\\*) ac_try_echo=\$ac_try;;
22471
 
  *) ac_try_echo=$ac_try;;
22472
 
esac
22473
 
eval "echo \"\$as_me:$LINENO: $ac_try_echo\"") >&5
22474
 
  (eval "$ac_try") 2>&5
22475
 
  ac_status=$?
22476
 
  echo "$as_me:$LINENO: \$? = $ac_status" >&5
22477
 
  (exit $ac_status); }; }; then
 
21659
  (exit $ac_status); } && {
 
21660
         test -z "$ac_c_werror_flag" ||
 
21661
         test ! -s conftest.err
 
21662
       } && test -s conftest.$ac_objext; then
22478
21663
  ac_cv_type_long=yes
22479
21664
else
22480
21665
  echo "$as_me: failed program was:" >&5
22488
21673
{ echo "$as_me:$LINENO: result: $ac_cv_type_long" >&5
22489
21674
echo "${ECHO_T}$ac_cv_type_long" >&6; }
22490
21675
 
 
21676
# The cast to long int works around a bug in the HP C Compiler
 
21677
# version HP92453-01 B.11.11.23709.GP, which incorrectly rejects
 
21678
# declarations like `int a3[[(sizeof (unsigned char)) >= 0]];'.
 
21679
# This bug is HP SR number 8606223364.
22491
21680
{ echo "$as_me:$LINENO: checking size of long" >&5
22492
21681
echo $ECHO_N "checking size of long... $ECHO_C" >&6; }
22493
21682
if test "${ac_cv_sizeof_long+set}" = set; then
22494
21683
  echo $ECHO_N "(cached) $ECHO_C" >&6
22495
21684
else
22496
 
  if test "$ac_cv_type_long" = yes; then
22497
 
  # The cast to long int works around a bug in the HP C Compiler
22498
 
  # version HP92453-01 B.11.11.23709.GP, which incorrectly rejects
22499
 
  # declarations like `int a3[[(sizeof (unsigned char)) >= 0]];'.
22500
 
  # This bug is HP SR number 8606223364.
22501
21685
  if test "$cross_compiling" = yes; then
22502
21686
  # Depending upon the size, compute the lo and hi bounds.
22503
21687
cat >conftest.$ac_ext <<_ACEOF
22507
21691
cat >>conftest.$ac_ext <<_ACEOF
22508
21692
/* end confdefs.h.  */
22509
21693
$ac_includes_default
22510
 
                   typedef long ac__type_sizeof_;
 
21694
   typedef long ac__type_sizeof_;
22511
21695
int
22512
21696
main ()
22513
21697
{
22531
21715
  rm -f conftest.er1
22532
21716
  cat conftest.err >&5
22533
21717
  echo "$as_me:$LINENO: \$? = $ac_status" >&5
22534
 
  (exit $ac_status); } &&
22535
 
         { ac_try='test -z "$ac_c_werror_flag" || test ! -s conftest.err'
22536
 
  { (case "(($ac_try" in
22537
 
  *\"* | *\`* | *\\*) ac_try_echo=\$ac_try;;
22538
 
  *) ac_try_echo=$ac_try;;
22539
 
esac
22540
 
eval "echo \"\$as_me:$LINENO: $ac_try_echo\"") >&5
22541
 
  (eval "$ac_try") 2>&5
22542
 
  ac_status=$?
22543
 
  echo "$as_me:$LINENO: \$? = $ac_status" >&5
22544
 
  (exit $ac_status); }; } &&
22545
 
         { ac_try='test -s conftest.$ac_objext'
22546
 
  { (case "(($ac_try" in
22547
 
  *\"* | *\`* | *\\*) ac_try_echo=\$ac_try;;
22548
 
  *) ac_try_echo=$ac_try;;
22549
 
esac
22550
 
eval "echo \"\$as_me:$LINENO: $ac_try_echo\"") >&5
22551
 
  (eval "$ac_try") 2>&5
22552
 
  ac_status=$?
22553
 
  echo "$as_me:$LINENO: \$? = $ac_status" >&5
22554
 
  (exit $ac_status); }; }; then
 
21718
  (exit $ac_status); } && {
 
21719
         test -z "$ac_c_werror_flag" ||
 
21720
         test ! -s conftest.err
 
21721
       } && test -s conftest.$ac_objext; then
22555
21722
  ac_lo=0 ac_mid=0
22556
21723
  while :; do
22557
21724
    cat >conftest.$ac_ext <<_ACEOF
22561
21728
cat >>conftest.$ac_ext <<_ACEOF
22562
21729
/* end confdefs.h.  */
22563
21730
$ac_includes_default
22564
 
                   typedef long ac__type_sizeof_;
 
21731
   typedef long ac__type_sizeof_;
22565
21732
int
22566
21733
main ()
22567
21734
{
22585
21752
  rm -f conftest.er1
22586
21753
  cat conftest.err >&5
22587
21754
  echo "$as_me:$LINENO: \$? = $ac_status" >&5
22588
 
  (exit $ac_status); } &&
22589
 
         { ac_try='test -z "$ac_c_werror_flag" || test ! -s conftest.err'
22590
 
  { (case "(($ac_try" in
22591
 
  *\"* | *\`* | *\\*) ac_try_echo=\$ac_try;;
22592
 
  *) ac_try_echo=$ac_try;;
22593
 
esac
22594
 
eval "echo \"\$as_me:$LINENO: $ac_try_echo\"") >&5
22595
 
  (eval "$ac_try") 2>&5
22596
 
  ac_status=$?
22597
 
  echo "$as_me:$LINENO: \$? = $ac_status" >&5
22598
 
  (exit $ac_status); }; } &&
22599
 
         { ac_try='test -s conftest.$ac_objext'
22600
 
  { (case "(($ac_try" in
22601
 
  *\"* | *\`* | *\\*) ac_try_echo=\$ac_try;;
22602
 
  *) ac_try_echo=$ac_try;;
22603
 
esac
22604
 
eval "echo \"\$as_me:$LINENO: $ac_try_echo\"") >&5
22605
 
  (eval "$ac_try") 2>&5
22606
 
  ac_status=$?
22607
 
  echo "$as_me:$LINENO: \$? = $ac_status" >&5
22608
 
  (exit $ac_status); }; }; then
 
21755
  (exit $ac_status); } && {
 
21756
         test -z "$ac_c_werror_flag" ||
 
21757
         test ! -s conftest.err
 
21758
       } && test -s conftest.$ac_objext; then
22609
21759
  ac_hi=$ac_mid; break
22610
21760
else
22611
21761
  echo "$as_me: failed program was:" >&5
22632
21782
cat >>conftest.$ac_ext <<_ACEOF
22633
21783
/* end confdefs.h.  */
22634
21784
$ac_includes_default
22635
 
                   typedef long ac__type_sizeof_;
 
21785
   typedef long ac__type_sizeof_;
22636
21786
int
22637
21787
main ()
22638
21788
{
22656
21806
  rm -f conftest.er1
22657
21807
  cat conftest.err >&5
22658
21808
  echo "$as_me:$LINENO: \$? = $ac_status" >&5
22659
 
  (exit $ac_status); } &&
22660
 
         { ac_try='test -z "$ac_c_werror_flag" || test ! -s conftest.err'
22661
 
  { (case "(($ac_try" in
22662
 
  *\"* | *\`* | *\\*) ac_try_echo=\$ac_try;;
22663
 
  *) ac_try_echo=$ac_try;;
22664
 
esac
22665
 
eval "echo \"\$as_me:$LINENO: $ac_try_echo\"") >&5
22666
 
  (eval "$ac_try") 2>&5
22667
 
  ac_status=$?
22668
 
  echo "$as_me:$LINENO: \$? = $ac_status" >&5
22669
 
  (exit $ac_status); }; } &&
22670
 
         { ac_try='test -s conftest.$ac_objext'
22671
 
  { (case "(($ac_try" in
22672
 
  *\"* | *\`* | *\\*) ac_try_echo=\$ac_try;;
22673
 
  *) ac_try_echo=$ac_try;;
22674
 
esac
22675
 
eval "echo \"\$as_me:$LINENO: $ac_try_echo\"") >&5
22676
 
  (eval "$ac_try") 2>&5
22677
 
  ac_status=$?
22678
 
  echo "$as_me:$LINENO: \$? = $ac_status" >&5
22679
 
  (exit $ac_status); }; }; then
 
21809
  (exit $ac_status); } && {
 
21810
         test -z "$ac_c_werror_flag" ||
 
21811
         test ! -s conftest.err
 
21812
       } && test -s conftest.$ac_objext; then
22680
21813
  ac_hi=-1 ac_mid=-1
22681
21814
  while :; do
22682
21815
    cat >conftest.$ac_ext <<_ACEOF
22686
21819
cat >>conftest.$ac_ext <<_ACEOF
22687
21820
/* end confdefs.h.  */
22688
21821
$ac_includes_default
22689
 
                   typedef long ac__type_sizeof_;
 
21822
   typedef long ac__type_sizeof_;
22690
21823
int
22691
21824
main ()
22692
21825
{
22710
21843
  rm -f conftest.er1
22711
21844
  cat conftest.err >&5
22712
21845
  echo "$as_me:$LINENO: \$? = $ac_status" >&5
22713
 
  (exit $ac_status); } &&
22714
 
         { ac_try='test -z "$ac_c_werror_flag" || test ! -s conftest.err'
22715
 
  { (case "(($ac_try" in
22716
 
  *\"* | *\`* | *\\*) ac_try_echo=\$ac_try;;
22717
 
  *) ac_try_echo=$ac_try;;
22718
 
esac
22719
 
eval "echo \"\$as_me:$LINENO: $ac_try_echo\"") >&5
22720
 
  (eval "$ac_try") 2>&5
22721
 
  ac_status=$?
22722
 
  echo "$as_me:$LINENO: \$? = $ac_status" >&5
22723
 
  (exit $ac_status); }; } &&
22724
 
         { ac_try='test -s conftest.$ac_objext'
22725
 
  { (case "(($ac_try" in
22726
 
  *\"* | *\`* | *\\*) ac_try_echo=\$ac_try;;
22727
 
  *) ac_try_echo=$ac_try;;
22728
 
esac
22729
 
eval "echo \"\$as_me:$LINENO: $ac_try_echo\"") >&5
22730
 
  (eval "$ac_try") 2>&5
22731
 
  ac_status=$?
22732
 
  echo "$as_me:$LINENO: \$? = $ac_status" >&5
22733
 
  (exit $ac_status); }; }; then
 
21846
  (exit $ac_status); } && {
 
21847
         test -z "$ac_c_werror_flag" ||
 
21848
         test ! -s conftest.err
 
21849
       } && test -s conftest.$ac_objext; then
22734
21850
  ac_lo=$ac_mid; break
22735
21851
else
22736
21852
  echo "$as_me: failed program was:" >&5
22767
21883
cat >>conftest.$ac_ext <<_ACEOF
22768
21884
/* end confdefs.h.  */
22769
21885
$ac_includes_default
22770
 
                   typedef long ac__type_sizeof_;
 
21886
   typedef long ac__type_sizeof_;
22771
21887
int
22772
21888
main ()
22773
21889
{
22791
21907
  rm -f conftest.er1
22792
21908
  cat conftest.err >&5
22793
21909
  echo "$as_me:$LINENO: \$? = $ac_status" >&5
22794
 
  (exit $ac_status); } &&
22795
 
         { ac_try='test -z "$ac_c_werror_flag" || test ! -s conftest.err'
22796
 
  { (case "(($ac_try" in
22797
 
  *\"* | *\`* | *\\*) ac_try_echo=\$ac_try;;
22798
 
  *) ac_try_echo=$ac_try;;
22799
 
esac
22800
 
eval "echo \"\$as_me:$LINENO: $ac_try_echo\"") >&5
22801
 
  (eval "$ac_try") 2>&5
22802
 
  ac_status=$?
22803
 
  echo "$as_me:$LINENO: \$? = $ac_status" >&5
22804
 
  (exit $ac_status); }; } &&
22805
 
         { ac_try='test -s conftest.$ac_objext'
22806
 
  { (case "(($ac_try" in
22807
 
  *\"* | *\`* | *\\*) ac_try_echo=\$ac_try;;
22808
 
  *) ac_try_echo=$ac_try;;
22809
 
esac
22810
 
eval "echo \"\$as_me:$LINENO: $ac_try_echo\"") >&5
22811
 
  (eval "$ac_try") 2>&5
22812
 
  ac_status=$?
22813
 
  echo "$as_me:$LINENO: \$? = $ac_status" >&5
22814
 
  (exit $ac_status); }; }; then
 
21910
  (exit $ac_status); } && {
 
21911
         test -z "$ac_c_werror_flag" ||
 
21912
         test ! -s conftest.err
 
21913
       } && test -s conftest.$ac_objext; then
22815
21914
  ac_hi=$ac_mid
22816
21915
else
22817
21916
  echo "$as_me: failed program was:" >&5
22824
21923
done
22825
21924
case $ac_lo in
22826
21925
?*) ac_cv_sizeof_long=$ac_lo;;
22827
 
'') { { echo "$as_me:$LINENO: error: cannot compute sizeof (long)
 
21926
'') if test "$ac_cv_type_long" = yes; then
 
21927
     { { echo "$as_me:$LINENO: error: cannot compute sizeof (long)
22828
21928
See \`config.log' for more details." >&5
22829
21929
echo "$as_me: error: cannot compute sizeof (long)
22830
21930
See \`config.log' for more details." >&2;}
22831
 
   { (exit 77); exit 77; }; } ;;
 
21931
   { (exit 77); exit 77; }; }
 
21932
   else
 
21933
     ac_cv_sizeof_long=0
 
21934
   fi ;;
22832
21935
esac
22833
21936
else
22834
21937
  cat >conftest.$ac_ext <<_ACEOF
22838
21941
cat >>conftest.$ac_ext <<_ACEOF
22839
21942
/* end confdefs.h.  */
22840
21943
$ac_includes_default
22841
 
                   typedef long ac__type_sizeof_;
 
21944
   typedef long ac__type_sizeof_;
22842
21945
static long int longval () { return (long int) (sizeof (ac__type_sizeof_)); }
22843
21946
static unsigned long int ulongval () { return (long int) (sizeof (ac__type_sizeof_)); }
22844
21947
#include <stdio.h>
22897
22000
sed 's/^/| /' conftest.$ac_ext >&5
22898
22001
 
22899
22002
( exit $ac_status )
22900
 
{ { echo "$as_me:$LINENO: error: cannot compute sizeof (long)
 
22003
if test "$ac_cv_type_long" = yes; then
 
22004
     { { echo "$as_me:$LINENO: error: cannot compute sizeof (long)
22901
22005
See \`config.log' for more details." >&5
22902
22006
echo "$as_me: error: cannot compute sizeof (long)
22903
22007
See \`config.log' for more details." >&2;}
22904
22008
   { (exit 77); exit 77; }; }
 
22009
   else
 
22010
     ac_cv_sizeof_long=0
 
22011
   fi
22905
22012
fi
22906
22013
rm -f core *.core core.conftest.* gmon.out bb.out conftest$ac_exeext conftest.$ac_objext conftest.$ac_ext
22907
22014
fi
22908
22015
rm -f conftest.val
22909
 
else
22910
 
  ac_cv_sizeof_long=0
22911
 
fi
22912
22016
fi
22913
22017
{ echo "$as_me:$LINENO: result: $ac_cv_sizeof_long" >&5
22914
22018
echo "${ECHO_T}$ac_cv_sizeof_long" >&6; }
 
22019
 
 
22020
 
 
22021
 
22915
22022
cat >>confdefs.h <<_ACEOF
22916
22023
#define SIZEOF_LONG $ac_cv_sizeof_long
22917
22024
_ACEOF
22957
22064
  rm -f conftest.er1
22958
22065
  cat conftest.err >&5
22959
22066
  echo "$as_me:$LINENO: \$? = $ac_status" >&5
22960
 
  (exit $ac_status); } &&
22961
 
         { ac_try='test -z "$ac_c_werror_flag" || test ! -s conftest.err'
22962
 
  { (case "(($ac_try" in
22963
 
  *\"* | *\`* | *\\*) ac_try_echo=\$ac_try;;
22964
 
  *) ac_try_echo=$ac_try;;
22965
 
esac
22966
 
eval "echo \"\$as_me:$LINENO: $ac_try_echo\"") >&5
22967
 
  (eval "$ac_try") 2>&5
22968
 
  ac_status=$?
22969
 
  echo "$as_me:$LINENO: \$? = $ac_status" >&5
22970
 
  (exit $ac_status); }; } &&
22971
 
         { ac_try='test -s conftest.$ac_objext'
22972
 
  { (case "(($ac_try" in
22973
 
  *\"* | *\`* | *\\*) ac_try_echo=\$ac_try;;
22974
 
  *) ac_try_echo=$ac_try;;
22975
 
esac
22976
 
eval "echo \"\$as_me:$LINENO: $ac_try_echo\"") >&5
22977
 
  (eval "$ac_try") 2>&5
22978
 
  ac_status=$?
22979
 
  echo "$as_me:$LINENO: \$? = $ac_status" >&5
22980
 
  (exit $ac_status); }; }; then
 
22067
  (exit $ac_status); } && {
 
22068
         test -z "$ac_c_werror_flag" ||
 
22069
         test ! -s conftest.err
 
22070
       } && test -s conftest.$ac_objext; then
22981
22071
  ac_cv_type_unsigned_long=yes
22982
22072
else
22983
22073
  echo "$as_me: failed program was:" >&5
22991
22081
{ echo "$as_me:$LINENO: result: $ac_cv_type_unsigned_long" >&5
22992
22082
echo "${ECHO_T}$ac_cv_type_unsigned_long" >&6; }
22993
22083
 
 
22084
# The cast to long int works around a bug in the HP C Compiler
 
22085
# version HP92453-01 B.11.11.23709.GP, which incorrectly rejects
 
22086
# declarations like `int a3[[(sizeof (unsigned char)) >= 0]];'.
 
22087
# This bug is HP SR number 8606223364.
22994
22088
{ echo "$as_me:$LINENO: checking size of unsigned long" >&5
22995
22089
echo $ECHO_N "checking size of unsigned long... $ECHO_C" >&6; }
22996
22090
if test "${ac_cv_sizeof_unsigned_long+set}" = set; then
22997
22091
  echo $ECHO_N "(cached) $ECHO_C" >&6
22998
22092
else
22999
 
  if test "$ac_cv_type_unsigned_long" = yes; then
23000
 
  # The cast to long int works around a bug in the HP C Compiler
23001
 
  # version HP92453-01 B.11.11.23709.GP, which incorrectly rejects
23002
 
  # declarations like `int a3[[(sizeof (unsigned char)) >= 0]];'.
23003
 
  # This bug is HP SR number 8606223364.
23004
22093
  if test "$cross_compiling" = yes; then
23005
22094
  # Depending upon the size, compute the lo and hi bounds.
23006
22095
cat >conftest.$ac_ext <<_ACEOF
23010
22099
cat >>conftest.$ac_ext <<_ACEOF
23011
22100
/* end confdefs.h.  */
23012
22101
$ac_includes_default
23013
 
                   typedef unsigned long ac__type_sizeof_;
 
22102
   typedef unsigned long ac__type_sizeof_;
23014
22103
int
23015
22104
main ()
23016
22105
{
23034
22123
  rm -f conftest.er1
23035
22124
  cat conftest.err >&5
23036
22125
  echo "$as_me:$LINENO: \$? = $ac_status" >&5
23037
 
  (exit $ac_status); } &&
23038
 
         { ac_try='test -z "$ac_c_werror_flag" || test ! -s conftest.err'
23039
 
  { (case "(($ac_try" in
23040
 
  *\"* | *\`* | *\\*) ac_try_echo=\$ac_try;;
23041
 
  *) ac_try_echo=$ac_try;;
23042
 
esac
23043
 
eval "echo \"\$as_me:$LINENO: $ac_try_echo\"") >&5
23044
 
  (eval "$ac_try") 2>&5
23045
 
  ac_status=$?
23046
 
  echo "$as_me:$LINENO: \$? = $ac_status" >&5
23047
 
  (exit $ac_status); }; } &&
23048
 
         { ac_try='test -s conftest.$ac_objext'
23049
 
  { (case "(($ac_try" in
23050
 
  *\"* | *\`* | *\\*) ac_try_echo=\$ac_try;;
23051
 
  *) ac_try_echo=$ac_try;;
23052
 
esac
23053
 
eval "echo \"\$as_me:$LINENO: $ac_try_echo\"") >&5
23054
 
  (eval "$ac_try") 2>&5
23055
 
  ac_status=$?
23056
 
  echo "$as_me:$LINENO: \$? = $ac_status" >&5
23057
 
  (exit $ac_status); }; }; then
 
22126
  (exit $ac_status); } && {
 
22127
         test -z "$ac_c_werror_flag" ||
 
22128
         test ! -s conftest.err
 
22129
       } && test -s conftest.$ac_objext; then
23058
22130
  ac_lo=0 ac_mid=0
23059
22131
  while :; do
23060
22132
    cat >conftest.$ac_ext <<_ACEOF
23064
22136
cat >>conftest.$ac_ext <<_ACEOF
23065
22137
/* end confdefs.h.  */
23066
22138
$ac_includes_default
23067
 
                   typedef unsigned long ac__type_sizeof_;
 
22139
   typedef unsigned long ac__type_sizeof_;
23068
22140
int
23069
22141
main ()
23070
22142
{
23088
22160
  rm -f conftest.er1
23089
22161
  cat conftest.err >&5
23090
22162
  echo "$as_me:$LINENO: \$? = $ac_status" >&5
23091
 
  (exit $ac_status); } &&
23092
 
         { ac_try='test -z "$ac_c_werror_flag" || test ! -s conftest.err'
23093
 
  { (case "(($ac_try" in
23094
 
  *\"* | *\`* | *\\*) ac_try_echo=\$ac_try;;
23095
 
  *) ac_try_echo=$ac_try;;
23096
 
esac
23097
 
eval "echo \"\$as_me:$LINENO: $ac_try_echo\"") >&5
23098
 
  (eval "$ac_try") 2>&5
23099
 
  ac_status=$?
23100
 
  echo "$as_me:$LINENO: \$? = $ac_status" >&5
23101
 
  (exit $ac_status); }; } &&
23102
 
         { ac_try='test -s conftest.$ac_objext'
23103
 
  { (case "(($ac_try" in
23104
 
  *\"* | *\`* | *\\*) ac_try_echo=\$ac_try;;
23105
 
  *) ac_try_echo=$ac_try;;
23106
 
esac
23107
 
eval "echo \"\$as_me:$LINENO: $ac_try_echo\"") >&5
23108
 
  (eval "$ac_try") 2>&5
23109
 
  ac_status=$?
23110
 
  echo "$as_me:$LINENO: \$? = $ac_status" >&5
23111
 
  (exit $ac_status); }; }; then
 
22163
  (exit $ac_status); } && {
 
22164
         test -z "$ac_c_werror_flag" ||
 
22165
         test ! -s conftest.err
 
22166
       } && test -s conftest.$ac_objext; then
23112
22167
  ac_hi=$ac_mid; break
23113
22168
else
23114
22169
  echo "$as_me: failed program was:" >&5
23135
22190
cat >>conftest.$ac_ext <<_ACEOF
23136
22191
/* end confdefs.h.  */
23137
22192
$ac_includes_default
23138
 
                   typedef unsigned long ac__type_sizeof_;
 
22193
   typedef unsigned long ac__type_sizeof_;
23139
22194
int
23140
22195
main ()
23141
22196
{
23159
22214
  rm -f conftest.er1
23160
22215
  cat conftest.err >&5
23161
22216
  echo "$as_me:$LINENO: \$? = $ac_status" >&5
23162
 
  (exit $ac_status); } &&
23163
 
         { ac_try='test -z "$ac_c_werror_flag" || test ! -s conftest.err'
23164
 
  { (case "(($ac_try" in
23165
 
  *\"* | *\`* | *\\*) ac_try_echo=\$ac_try;;
23166
 
  *) ac_try_echo=$ac_try;;
23167
 
esac
23168
 
eval "echo \"\$as_me:$LINENO: $ac_try_echo\"") >&5
23169
 
  (eval "$ac_try") 2>&5
23170
 
  ac_status=$?
23171
 
  echo "$as_me:$LINENO: \$? = $ac_status" >&5
23172
 
  (exit $ac_status); }; } &&
23173
 
         { ac_try='test -s conftest.$ac_objext'
23174
 
  { (case "(($ac_try" in
23175
 
  *\"* | *\`* | *\\*) ac_try_echo=\$ac_try;;
23176
 
  *) ac_try_echo=$ac_try;;
23177
 
esac
23178
 
eval "echo \"\$as_me:$LINENO: $ac_try_echo\"") >&5
23179
 
  (eval "$ac_try") 2>&5
23180
 
  ac_status=$?
23181
 
  echo "$as_me:$LINENO: \$? = $ac_status" >&5
23182
 
  (exit $ac_status); }; }; then
 
22217
  (exit $ac_status); } && {
 
22218
         test -z "$ac_c_werror_flag" ||
 
22219
         test ! -s conftest.err
 
22220
       } && test -s conftest.$ac_objext; then
23183
22221
  ac_hi=-1 ac_mid=-1
23184
22222
  while :; do
23185
22223
    cat >conftest.$ac_ext <<_ACEOF
23189
22227
cat >>conftest.$ac_ext <<_ACEOF
23190
22228
/* end confdefs.h.  */
23191
22229
$ac_includes_default
23192
 
                   typedef unsigned long ac__type_sizeof_;
 
22230
   typedef unsigned long ac__type_sizeof_;
23193
22231
int
23194
22232
main ()
23195
22233
{
23213
22251
  rm -f conftest.er1
23214
22252
  cat conftest.err >&5
23215
22253
  echo "$as_me:$LINENO: \$? = $ac_status" >&5
23216
 
  (exit $ac_status); } &&
23217
 
         { ac_try='test -z "$ac_c_werror_flag" || test ! -s conftest.err'
23218
 
  { (case "(($ac_try" in
23219
 
  *\"* | *\`* | *\\*) ac_try_echo=\$ac_try;;
23220
 
  *) ac_try_echo=$ac_try;;
23221
 
esac
23222
 
eval "echo \"\$as_me:$LINENO: $ac_try_echo\"") >&5
23223
 
  (eval "$ac_try") 2>&5
23224
 
  ac_status=$?
23225
 
  echo "$as_me:$LINENO: \$? = $ac_status" >&5
23226
 
  (exit $ac_status); }; } &&
23227
 
         { ac_try='test -s conftest.$ac_objext'
23228
 
  { (case "(($ac_try" in
23229
 
  *\"* | *\`* | *\\*) ac_try_echo=\$ac_try;;
23230
 
  *) ac_try_echo=$ac_try;;
23231
 
esac
23232
 
eval "echo \"\$as_me:$LINENO: $ac_try_echo\"") >&5
23233
 
  (eval "$ac_try") 2>&5
23234
 
  ac_status=$?
23235
 
  echo "$as_me:$LINENO: \$? = $ac_status" >&5
23236
 
  (exit $ac_status); }; }; then
 
22254
  (exit $ac_status); } && {
 
22255
         test -z "$ac_c_werror_flag" ||
 
22256
         test ! -s conftest.err
 
22257
       } && test -s conftest.$ac_objext; then
23237
22258
  ac_lo=$ac_mid; break
23238
22259
else
23239
22260
  echo "$as_me: failed program was:" >&5
23270
22291
cat >>conftest.$ac_ext <<_ACEOF
23271
22292
/* end confdefs.h.  */
23272
22293
$ac_includes_default
23273
 
                   typedef unsigned long ac__type_sizeof_;
 
22294
   typedef unsigned long ac__type_sizeof_;
23274
22295
int
23275
22296
main ()
23276
22297
{
23294
22315
  rm -f conftest.er1
23295
22316
  cat conftest.err >&5
23296
22317
  echo "$as_me:$LINENO: \$? = $ac_status" >&5
23297
 
  (exit $ac_status); } &&
23298
 
         { ac_try='test -z "$ac_c_werror_flag" || test ! -s conftest.err'
23299
 
  { (case "(($ac_try" in
23300
 
  *\"* | *\`* | *\\*) ac_try_echo=\$ac_try;;
23301
 
  *) ac_try_echo=$ac_try;;
23302
 
esac
23303
 
eval "echo \"\$as_me:$LINENO: $ac_try_echo\"") >&5
23304
 
  (eval "$ac_try") 2>&5
23305
 
  ac_status=$?
23306
 
  echo "$as_me:$LINENO: \$? = $ac_status" >&5
23307
 
  (exit $ac_status); }; } &&
23308
 
         { ac_try='test -s conftest.$ac_objext'
23309
 
  { (case "(($ac_try" in
23310
 
  *\"* | *\`* | *\\*) ac_try_echo=\$ac_try;;
23311
 
  *) ac_try_echo=$ac_try;;
23312
 
esac
23313
 
eval "echo \"\$as_me:$LINENO: $ac_try_echo\"") >&5
23314
 
  (eval "$ac_try") 2>&5
23315
 
  ac_status=$?
23316
 
  echo "$as_me:$LINENO: \$? = $ac_status" >&5
23317
 
  (exit $ac_status); }; }; then
 
22318
  (exit $ac_status); } && {
 
22319
         test -z "$ac_c_werror_flag" ||
 
22320
         test ! -s conftest.err
 
22321
       } && test -s conftest.$ac_objext; then
23318
22322
  ac_hi=$ac_mid
23319
22323
else
23320
22324
  echo "$as_me: failed program was:" >&5
23327
22331
done
23328
22332
case $ac_lo in
23329
22333
?*) ac_cv_sizeof_unsigned_long=$ac_lo;;
23330
 
'') { { echo "$as_me:$LINENO: error: cannot compute sizeof (unsigned long)
 
22334
'') if test "$ac_cv_type_unsigned_long" = yes; then
 
22335
     { { echo "$as_me:$LINENO: error: cannot compute sizeof (unsigned long)
23331
22336
See \`config.log' for more details." >&5
23332
22337
echo "$as_me: error: cannot compute sizeof (unsigned long)
23333
22338
See \`config.log' for more details." >&2;}
23334
 
   { (exit 77); exit 77; }; } ;;
 
22339
   { (exit 77); exit 77; }; }
 
22340
   else
 
22341
     ac_cv_sizeof_unsigned_long=0
 
22342
   fi ;;
23335
22343
esac
23336
22344
else
23337
22345
  cat >conftest.$ac_ext <<_ACEOF
23341
22349
cat >>conftest.$ac_ext <<_ACEOF
23342
22350
/* end confdefs.h.  */
23343
22351
$ac_includes_default
23344
 
                   typedef unsigned long ac__type_sizeof_;
 
22352
   typedef unsigned long ac__type_sizeof_;
23345
22353
static long int longval () { return (long int) (sizeof (ac__type_sizeof_)); }
23346
22354
static unsigned long int ulongval () { return (long int) (sizeof (ac__type_sizeof_)); }
23347
22355
#include <stdio.h>
23400
22408
sed 's/^/| /' conftest.$ac_ext >&5
23401
22409
 
23402
22410
( exit $ac_status )
23403
 
{ { echo "$as_me:$LINENO: error: cannot compute sizeof (unsigned long)
 
22411
if test "$ac_cv_type_unsigned_long" = yes; then
 
22412
     { { echo "$as_me:$LINENO: error: cannot compute sizeof (unsigned long)
23404
22413
See \`config.log' for more details." >&5
23405
22414
echo "$as_me: error: cannot compute sizeof (unsigned long)
23406
22415
See \`config.log' for more details." >&2;}
23407
22416
   { (exit 77); exit 77; }; }
 
22417
   else
 
22418
     ac_cv_sizeof_unsigned_long=0
 
22419
   fi
23408
22420
fi
23409
22421
rm -f core *.core core.conftest.* gmon.out bb.out conftest$ac_exeext conftest.$ac_objext conftest.$ac_ext
23410
22422
fi
23411
22423
rm -f conftest.val
23412
 
else
23413
 
  ac_cv_sizeof_unsigned_long=0
23414
 
fi
23415
22424
fi
23416
22425
{ echo "$as_me:$LINENO: result: $ac_cv_sizeof_unsigned_long" >&5
23417
22426
echo "${ECHO_T}$ac_cv_sizeof_unsigned_long" >&6; }
 
22427
 
 
22428
 
 
22429
 
23418
22430
cat >>confdefs.h <<_ACEOF
23419
22431
#define SIZEOF_UNSIGNED_LONG $ac_cv_sizeof_unsigned_long
23420
22432
_ACEOF
23461
22473
  rm -f conftest.er1
23462
22474
  cat conftest.err >&5
23463
22475
  echo "$as_me:$LINENO: \$? = $ac_status" >&5
23464
 
  (exit $ac_status); } &&
23465
 
         { ac_try='test -z "$ac_c_werror_flag" || test ! -s conftest.err'
23466
 
  { (case "(($ac_try" in
23467
 
  *\"* | *\`* | *\\*) ac_try_echo=\$ac_try;;
23468
 
  *) ac_try_echo=$ac_try;;
23469
 
esac
23470
 
eval "echo \"\$as_me:$LINENO: $ac_try_echo\"") >&5
23471
 
  (eval "$ac_try") 2>&5
23472
 
  ac_status=$?
23473
 
  echo "$as_me:$LINENO: \$? = $ac_status" >&5
23474
 
  (exit $ac_status); }; } &&
23475
 
         { ac_try='test -s conftest.$ac_objext'
23476
 
  { (case "(($ac_try" in
23477
 
  *\"* | *\`* | *\\*) ac_try_echo=\$ac_try;;
23478
 
  *) ac_try_echo=$ac_try;;
23479
 
esac
23480
 
eval "echo \"\$as_me:$LINENO: $ac_try_echo\"") >&5
23481
 
  (eval "$ac_try") 2>&5
23482
 
  ac_status=$?
23483
 
  echo "$as_me:$LINENO: \$? = $ac_status" >&5
23484
 
  (exit $ac_status); }; }; then
 
22476
  (exit $ac_status); } && {
 
22477
         test -z "$ac_c_werror_flag" ||
 
22478
         test ! -s conftest.err
 
22479
       } && test -s conftest.$ac_objext; then
23485
22480
  ac_cv_type_long_long=yes
23486
22481
else
23487
22482
  echo "$as_me: failed program was:" >&5
23495
22490
{ echo "$as_me:$LINENO: result: $ac_cv_type_long_long" >&5
23496
22491
echo "${ECHO_T}$ac_cv_type_long_long" >&6; }
23497
22492
 
 
22493
# The cast to long int works around a bug in the HP C Compiler
 
22494
# version HP92453-01 B.11.11.23709.GP, which incorrectly rejects
 
22495
# declarations like `int a3[[(sizeof (unsigned char)) >= 0]];'.
 
22496
# This bug is HP SR number 8606223364.
23498
22497
{ echo "$as_me:$LINENO: checking size of long long" >&5
23499
22498
echo $ECHO_N "checking size of long long... $ECHO_C" >&6; }
23500
22499
if test "${ac_cv_sizeof_long_long+set}" = set; then
23501
22500
  echo $ECHO_N "(cached) $ECHO_C" >&6
23502
22501
else
23503
 
  if test "$ac_cv_type_long_long" = yes; then
23504
 
  # The cast to long int works around a bug in the HP C Compiler
23505
 
  # version HP92453-01 B.11.11.23709.GP, which incorrectly rejects
23506
 
  # declarations like `int a3[[(sizeof (unsigned char)) >= 0]];'.
23507
 
  # This bug is HP SR number 8606223364.
23508
22502
  if test "$cross_compiling" = yes; then
23509
22503
  # Depending upon the size, compute the lo and hi bounds.
23510
22504
cat >conftest.$ac_ext <<_ACEOF
23514
22508
cat >>conftest.$ac_ext <<_ACEOF
23515
22509
/* end confdefs.h.  */
23516
22510
$ac_includes_default
23517
 
                   typedef long long ac__type_sizeof_;
 
22511
   typedef long long ac__type_sizeof_;
23518
22512
int
23519
22513
main ()
23520
22514
{
23538
22532
  rm -f conftest.er1
23539
22533
  cat conftest.err >&5
23540
22534
  echo "$as_me:$LINENO: \$? = $ac_status" >&5
23541
 
  (exit $ac_status); } &&
23542
 
         { ac_try='test -z "$ac_c_werror_flag" || test ! -s conftest.err'
23543
 
  { (case "(($ac_try" in
23544
 
  *\"* | *\`* | *\\*) ac_try_echo=\$ac_try;;
23545
 
  *) ac_try_echo=$ac_try;;
23546
 
esac
23547
 
eval "echo \"\$as_me:$LINENO: $ac_try_echo\"") >&5
23548
 
  (eval "$ac_try") 2>&5
23549
 
  ac_status=$?
23550
 
  echo "$as_me:$LINENO: \$? = $ac_status" >&5
23551
 
  (exit $ac_status); }; } &&
23552
 
         { ac_try='test -s conftest.$ac_objext'
23553
 
  { (case "(($ac_try" in
23554
 
  *\"* | *\`* | *\\*) ac_try_echo=\$ac_try;;
23555
 
  *) ac_try_echo=$ac_try;;
23556
 
esac
23557
 
eval "echo \"\$as_me:$LINENO: $ac_try_echo\"") >&5
23558
 
  (eval "$ac_try") 2>&5
23559
 
  ac_status=$?
23560
 
  echo "$as_me:$LINENO: \$? = $ac_status" >&5
23561
 
  (exit $ac_status); }; }; then
 
22535
  (exit $ac_status); } && {
 
22536
         test -z "$ac_c_werror_flag" ||
 
22537
         test ! -s conftest.err
 
22538
       } && test -s conftest.$ac_objext; then
23562
22539
  ac_lo=0 ac_mid=0
23563
22540
  while :; do
23564
22541
    cat >conftest.$ac_ext <<_ACEOF
23568
22545
cat >>conftest.$ac_ext <<_ACEOF
23569
22546
/* end confdefs.h.  */
23570
22547
$ac_includes_default
23571
 
                   typedef long long ac__type_sizeof_;
 
22548
   typedef long long ac__type_sizeof_;
23572
22549
int
23573
22550
main ()
23574
22551
{
23592
22569
  rm -f conftest.er1
23593
22570
  cat conftest.err >&5
23594
22571
  echo "$as_me:$LINENO: \$? = $ac_status" >&5
23595
 
  (exit $ac_status); } &&
23596
 
         { ac_try='test -z "$ac_c_werror_flag" || test ! -s conftest.err'
23597
 
  { (case "(($ac_try" in
23598
 
  *\"* | *\`* | *\\*) ac_try_echo=\$ac_try;;
23599
 
  *) ac_try_echo=$ac_try;;
23600
 
esac
23601
 
eval "echo \"\$as_me:$LINENO: $ac_try_echo\"") >&5
23602
 
  (eval "$ac_try") 2>&5
23603
 
  ac_status=$?
23604
 
  echo "$as_me:$LINENO: \$? = $ac_status" >&5
23605
 
  (exit $ac_status); }; } &&
23606
 
         { ac_try='test -s conftest.$ac_objext'
23607
 
  { (case "(($ac_try" in
23608
 
  *\"* | *\`* | *\\*) ac_try_echo=\$ac_try;;
23609
 
  *) ac_try_echo=$ac_try;;
23610
 
esac
23611
 
eval "echo \"\$as_me:$LINENO: $ac_try_echo\"") >&5
23612
 
  (eval "$ac_try") 2>&5
23613
 
  ac_status=$?
23614
 
  echo "$as_me:$LINENO: \$? = $ac_status" >&5
23615
 
  (exit $ac_status); }; }; then
 
22572
  (exit $ac_status); } && {
 
22573
         test -z "$ac_c_werror_flag" ||
 
22574
         test ! -s conftest.err
 
22575
       } && test -s conftest.$ac_objext; then
23616
22576
  ac_hi=$ac_mid; break
23617
22577
else
23618
22578
  echo "$as_me: failed program was:" >&5
23639
22599
cat >>conftest.$ac_ext <<_ACEOF
23640
22600
/* end confdefs.h.  */
23641
22601
$ac_includes_default
23642
 
                   typedef long long ac__type_sizeof_;
 
22602
   typedef long long ac__type_sizeof_;
23643
22603
int
23644
22604
main ()
23645
22605
{
23663
22623
  rm -f conftest.er1
23664
22624
  cat conftest.err >&5
23665
22625
  echo "$as_me:$LINENO: \$? = $ac_status" >&5
23666
 
  (exit $ac_status); } &&
23667
 
         { ac_try='test -z "$ac_c_werror_flag" || test ! -s conftest.err'
23668
 
  { (case "(($ac_try" in
23669
 
  *\"* | *\`* | *\\*) ac_try_echo=\$ac_try;;
23670
 
  *) ac_try_echo=$ac_try;;
23671
 
esac
23672
 
eval "echo \"\$as_me:$LINENO: $ac_try_echo\"") >&5
23673
 
  (eval "$ac_try") 2>&5
23674
 
  ac_status=$?
23675
 
  echo "$as_me:$LINENO: \$? = $ac_status" >&5
23676
 
  (exit $ac_status); }; } &&
23677
 
         { ac_try='test -s conftest.$ac_objext'
23678
 
  { (case "(($ac_try" in
23679
 
  *\"* | *\`* | *\\*) ac_try_echo=\$ac_try;;
23680
 
  *) ac_try_echo=$ac_try;;
23681
 
esac
23682
 
eval "echo \"\$as_me:$LINENO: $ac_try_echo\"") >&5
23683
 
  (eval "$ac_try") 2>&5
23684
 
  ac_status=$?
23685
 
  echo "$as_me:$LINENO: \$? = $ac_status" >&5
23686
 
  (exit $ac_status); }; }; then
 
22626
  (exit $ac_status); } && {
 
22627
         test -z "$ac_c_werror_flag" ||
 
22628
         test ! -s conftest.err
 
22629
       } && test -s conftest.$ac_objext; then
23687
22630
  ac_hi=-1 ac_mid=-1
23688
22631
  while :; do
23689
22632
    cat >conftest.$ac_ext <<_ACEOF
23693
22636
cat >>conftest.$ac_ext <<_ACEOF
23694
22637
/* end confdefs.h.  */
23695
22638
$ac_includes_default
23696
 
                   typedef long long ac__type_sizeof_;
 
22639
   typedef long long ac__type_sizeof_;
23697
22640
int
23698
22641
main ()
23699
22642
{
23717
22660
  rm -f conftest.er1
23718
22661
  cat conftest.err >&5
23719
22662
  echo "$as_me:$LINENO: \$? = $ac_status" >&5
23720
 
  (exit $ac_status); } &&
23721
 
         { ac_try='test -z "$ac_c_werror_flag" || test ! -s conftest.err'
23722
 
  { (case "(($ac_try" in
23723
 
  *\"* | *\`* | *\\*) ac_try_echo=\$ac_try;;
23724
 
  *) ac_try_echo=$ac_try;;
23725
 
esac
23726
 
eval "echo \"\$as_me:$LINENO: $ac_try_echo\"") >&5
23727
 
  (eval "$ac_try") 2>&5
23728
 
  ac_status=$?
23729
 
  echo "$as_me:$LINENO: \$? = $ac_status" >&5
23730
 
  (exit $ac_status); }; } &&
23731
 
         { ac_try='test -s conftest.$ac_objext'
23732
 
  { (case "(($ac_try" in
23733
 
  *\"* | *\`* | *\\*) ac_try_echo=\$ac_try;;
23734
 
  *) ac_try_echo=$ac_try;;
23735
 
esac
23736
 
eval "echo \"\$as_me:$LINENO: $ac_try_echo\"") >&5
23737
 
  (eval "$ac_try") 2>&5
23738
 
  ac_status=$?
23739
 
  echo "$as_me:$LINENO: \$? = $ac_status" >&5
23740
 
  (exit $ac_status); }; }; then
 
22663
  (exit $ac_status); } && {
 
22664
         test -z "$ac_c_werror_flag" ||
 
22665
         test ! -s conftest.err
 
22666
       } && test -s conftest.$ac_objext; then
23741
22667
  ac_lo=$ac_mid; break
23742
22668
else
23743
22669
  echo "$as_me: failed program was:" >&5
23774
22700
cat >>conftest.$ac_ext <<_ACEOF
23775
22701
/* end confdefs.h.  */
23776
22702
$ac_includes_default
23777
 
                   typedef long long ac__type_sizeof_;
 
22703
   typedef long long ac__type_sizeof_;
23778
22704
int
23779
22705
main ()
23780
22706
{
23798
22724
  rm -f conftest.er1
23799
22725
  cat conftest.err >&5
23800
22726
  echo "$as_me:$LINENO: \$? = $ac_status" >&5
23801
 
  (exit $ac_status); } &&
23802
 
         { ac_try='test -z "$ac_c_werror_flag" || test ! -s conftest.err'
23803
 
  { (case "(($ac_try" in
23804
 
  *\"* | *\`* | *\\*) ac_try_echo=\$ac_try;;
23805
 
  *) ac_try_echo=$ac_try;;
23806
 
esac
23807
 
eval "echo \"\$as_me:$LINENO: $ac_try_echo\"") >&5
23808
 
  (eval "$ac_try") 2>&5
23809
 
  ac_status=$?
23810
 
  echo "$as_me:$LINENO: \$? = $ac_status" >&5
23811
 
  (exit $ac_status); }; } &&
23812
 
         { ac_try='test -s conftest.$ac_objext'
23813
 
  { (case "(($ac_try" in
23814
 
  *\"* | *\`* | *\\*) ac_try_echo=\$ac_try;;
23815
 
  *) ac_try_echo=$ac_try;;
23816
 
esac
23817
 
eval "echo \"\$as_me:$LINENO: $ac_try_echo\"") >&5
23818
 
  (eval "$ac_try") 2>&5
23819
 
  ac_status=$?
23820
 
  echo "$as_me:$LINENO: \$? = $ac_status" >&5
23821
 
  (exit $ac_status); }; }; then
 
22727
  (exit $ac_status); } && {
 
22728
         test -z "$ac_c_werror_flag" ||
 
22729
         test ! -s conftest.err
 
22730
       } && test -s conftest.$ac_objext; then
23822
22731
  ac_hi=$ac_mid
23823
22732
else
23824
22733
  echo "$as_me: failed program was:" >&5
23831
22740
done
23832
22741
case $ac_lo in
23833
22742
?*) ac_cv_sizeof_long_long=$ac_lo;;
23834
 
'') { { echo "$as_me:$LINENO: error: cannot compute sizeof (long long)
 
22743
'') if test "$ac_cv_type_long_long" = yes; then
 
22744
     { { echo "$as_me:$LINENO: error: cannot compute sizeof (long long)
23835
22745
See \`config.log' for more details." >&5
23836
22746
echo "$as_me: error: cannot compute sizeof (long long)
23837
22747
See \`config.log' for more details." >&2;}
23838
 
   { (exit 77); exit 77; }; } ;;
 
22748
   { (exit 77); exit 77; }; }
 
22749
   else
 
22750
     ac_cv_sizeof_long_long=0
 
22751
   fi ;;
23839
22752
esac
23840
22753
else
23841
22754
  cat >conftest.$ac_ext <<_ACEOF
23845
22758
cat >>conftest.$ac_ext <<_ACEOF
23846
22759
/* end confdefs.h.  */
23847
22760
$ac_includes_default
23848
 
                   typedef long long ac__type_sizeof_;
 
22761
   typedef long long ac__type_sizeof_;
23849
22762
static long int longval () { return (long int) (sizeof (ac__type_sizeof_)); }
23850
22763
static unsigned long int ulongval () { return (long int) (sizeof (ac__type_sizeof_)); }
23851
22764
#include <stdio.h>
23904
22817
sed 's/^/| /' conftest.$ac_ext >&5
23905
22818
 
23906
22819
( exit $ac_status )
23907
 
{ { echo "$as_me:$LINENO: error: cannot compute sizeof (long long)
 
22820
if test "$ac_cv_type_long_long" = yes; then
 
22821
     { { echo "$as_me:$LINENO: error: cannot compute sizeof (long long)
23908
22822
See \`config.log' for more details." >&5
23909
22823
echo "$as_me: error: cannot compute sizeof (long long)
23910
22824
See \`config.log' for more details." >&2;}
23911
22825
   { (exit 77); exit 77; }; }
 
22826
   else
 
22827
     ac_cv_sizeof_long_long=0
 
22828
   fi
23912
22829
fi
23913
22830
rm -f core *.core core.conftest.* gmon.out bb.out conftest$ac_exeext conftest.$ac_objext conftest.$ac_ext
23914
22831
fi
23915
22832
rm -f conftest.val
23916
 
else
23917
 
  ac_cv_sizeof_long_long=0
23918
 
fi
23919
22833
fi
23920
22834
{ echo "$as_me:$LINENO: result: $ac_cv_sizeof_long_long" >&5
23921
22835
echo "${ECHO_T}$ac_cv_sizeof_long_long" >&6; }
 
22836
 
 
22837
 
 
22838
 
23922
22839
cat >>confdefs.h <<_ACEOF
23923
22840
#define SIZEOF_LONG_LONG $ac_cv_sizeof_long_long
23924
22841
_ACEOF
23966
22883
  rm -f conftest.er1
23967
22884
  cat conftest.err >&5
23968
22885
  echo "$as_me:$LINENO: \$? = $ac_status" >&5
23969
 
  (exit $ac_status); } &&
23970
 
         { ac_try='test -z "$ac_c_werror_flag" || test ! -s conftest.err'
23971
 
  { (case "(($ac_try" in
23972
 
  *\"* | *\`* | *\\*) ac_try_echo=\$ac_try;;
23973
 
  *) ac_try_echo=$ac_try;;
23974
 
esac
23975
 
eval "echo \"\$as_me:$LINENO: $ac_try_echo\"") >&5
23976
 
  (eval "$ac_try") 2>&5
23977
 
  ac_status=$?
23978
 
  echo "$as_me:$LINENO: \$? = $ac_status" >&5
23979
 
  (exit $ac_status); }; } &&
23980
 
         { ac_try='test -s conftest.$ac_objext'
23981
 
  { (case "(($ac_try" in
23982
 
  *\"* | *\`* | *\\*) ac_try_echo=\$ac_try;;
23983
 
  *) ac_try_echo=$ac_try;;
23984
 
esac
23985
 
eval "echo \"\$as_me:$LINENO: $ac_try_echo\"") >&5
23986
 
  (eval "$ac_try") 2>&5
23987
 
  ac_status=$?
23988
 
  echo "$as_me:$LINENO: \$? = $ac_status" >&5
23989
 
  (exit $ac_status); }; }; then
 
22886
  (exit $ac_status); } && {
 
22887
         test -z "$ac_c_werror_flag" ||
 
22888
         test ! -s conftest.err
 
22889
       } && test -s conftest.$ac_objext; then
23990
22890
  ac_cv_type_unsigned_long_long=yes
23991
22891
else
23992
22892
  echo "$as_me: failed program was:" >&5
24000
22900
{ echo "$as_me:$LINENO: result: $ac_cv_type_unsigned_long_long" >&5
24001
22901
echo "${ECHO_T}$ac_cv_type_unsigned_long_long" >&6; }
24002
22902
 
 
22903
# The cast to long int works around a bug in the HP C Compiler
 
22904
# version HP92453-01 B.11.11.23709.GP, which incorrectly rejects
 
22905
# declarations like `int a3[[(sizeof (unsigned char)) >= 0]];'.
 
22906
# This bug is HP SR number 8606223364.
24003
22907
{ echo "$as_me:$LINENO: checking size of unsigned long long" >&5
24004
22908
echo $ECHO_N "checking size of unsigned long long... $ECHO_C" >&6; }
24005
22909
if test "${ac_cv_sizeof_unsigned_long_long+set}" = set; then
24006
22910
  echo $ECHO_N "(cached) $ECHO_C" >&6
24007
22911
else
24008
 
  if test "$ac_cv_type_unsigned_long_long" = yes; then
24009
 
  # The cast to long int works around a bug in the HP C Compiler
24010
 
  # version HP92453-01 B.11.11.23709.GP, which incorrectly rejects
24011
 
  # declarations like `int a3[[(sizeof (unsigned char)) >= 0]];'.
24012
 
  # This bug is HP SR number 8606223364.
24013
22912
  if test "$cross_compiling" = yes; then
24014
22913
  # Depending upon the size, compute the lo and hi bounds.
24015
22914
cat >conftest.$ac_ext <<_ACEOF
24019
22918
cat >>conftest.$ac_ext <<_ACEOF
24020
22919
/* end confdefs.h.  */
24021
22920
$ac_includes_default
24022
 
                   typedef unsigned long long ac__type_sizeof_;
 
22921
   typedef unsigned long long ac__type_sizeof_;
24023
22922
int
24024
22923
main ()
24025
22924
{
24043
22942
  rm -f conftest.er1
24044
22943
  cat conftest.err >&5
24045
22944
  echo "$as_me:$LINENO: \$? = $ac_status" >&5
24046
 
  (exit $ac_status); } &&
24047
 
         { ac_try='test -z "$ac_c_werror_flag" || test ! -s conftest.err'
24048
 
  { (case "(($ac_try" in
24049
 
  *\"* | *\`* | *\\*) ac_try_echo=\$ac_try;;
24050
 
  *) ac_try_echo=$ac_try;;
24051
 
esac
24052
 
eval "echo \"\$as_me:$LINENO: $ac_try_echo\"") >&5
24053
 
  (eval "$ac_try") 2>&5
24054
 
  ac_status=$?
24055
 
  echo "$as_me:$LINENO: \$? = $ac_status" >&5
24056
 
  (exit $ac_status); }; } &&
24057
 
         { ac_try='test -s conftest.$ac_objext'
24058
 
  { (case "(($ac_try" in
24059
 
  *\"* | *\`* | *\\*) ac_try_echo=\$ac_try;;
24060
 
  *) ac_try_echo=$ac_try;;
24061
 
esac
24062
 
eval "echo \"\$as_me:$LINENO: $ac_try_echo\"") >&5
24063
 
  (eval "$ac_try") 2>&5
24064
 
  ac_status=$?
24065
 
  echo "$as_me:$LINENO: \$? = $ac_status" >&5
24066
 
  (exit $ac_status); }; }; then
 
22945
  (exit $ac_status); } && {
 
22946
         test -z "$ac_c_werror_flag" ||
 
22947
         test ! -s conftest.err
 
22948
       } && test -s conftest.$ac_objext; then
24067
22949
  ac_lo=0 ac_mid=0
24068
22950
  while :; do
24069
22951
    cat >conftest.$ac_ext <<_ACEOF
24073
22955
cat >>conftest.$ac_ext <<_ACEOF
24074
22956
/* end confdefs.h.  */
24075
22957
$ac_includes_default
24076
 
                   typedef unsigned long long ac__type_sizeof_;
 
22958
   typedef unsigned long long ac__type_sizeof_;
24077
22959
int
24078
22960
main ()
24079
22961
{
24097
22979
  rm -f conftest.er1
24098
22980
  cat conftest.err >&5
24099
22981
  echo "$as_me:$LINENO: \$? = $ac_status" >&5
24100
 
  (exit $ac_status); } &&
24101
 
         { ac_try='test -z "$ac_c_werror_flag" || test ! -s conftest.err'
24102
 
  { (case "(($ac_try" in
24103
 
  *\"* | *\`* | *\\*) ac_try_echo=\$ac_try;;
24104
 
  *) ac_try_echo=$ac_try;;
24105
 
esac
24106
 
eval "echo \"\$as_me:$LINENO: $ac_try_echo\"") >&5
24107
 
  (eval "$ac_try") 2>&5
24108
 
  ac_status=$?
24109
 
  echo "$as_me:$LINENO: \$? = $ac_status" >&5
24110
 
  (exit $ac_status); }; } &&
24111
 
         { ac_try='test -s conftest.$ac_objext'
24112
 
  { (case "(($ac_try" in
24113
 
  *\"* | *\`* | *\\*) ac_try_echo=\$ac_try;;
24114
 
  *) ac_try_echo=$ac_try;;
24115
 
esac
24116
 
eval "echo \"\$as_me:$LINENO: $ac_try_echo\"") >&5
24117
 
  (eval "$ac_try") 2>&5
24118
 
  ac_status=$?
24119
 
  echo "$as_me:$LINENO: \$? = $ac_status" >&5
24120
 
  (exit $ac_status); }; }; then
 
22982
  (exit $ac_status); } && {
 
22983
         test -z "$ac_c_werror_flag" ||
 
22984
         test ! -s conftest.err
 
22985
       } && test -s conftest.$ac_objext; then
24121
22986
  ac_hi=$ac_mid; break
24122
22987
else
24123
22988
  echo "$as_me: failed program was:" >&5
24144
23009
cat >>conftest.$ac_ext <<_ACEOF
24145
23010
/* end confdefs.h.  */
24146
23011
$ac_includes_default
24147
 
                   typedef unsigned long long ac__type_sizeof_;
 
23012
   typedef unsigned long long ac__type_sizeof_;
24148
23013
int
24149
23014
main ()
24150
23015
{
24168
23033
  rm -f conftest.er1
24169
23034
  cat conftest.err >&5
24170
23035
  echo "$as_me:$LINENO: \$? = $ac_status" >&5
24171
 
  (exit $ac_status); } &&
24172
 
         { ac_try='test -z "$ac_c_werror_flag" || test ! -s conftest.err'
24173
 
  { (case "(($ac_try" in
24174
 
  *\"* | *\`* | *\\*) ac_try_echo=\$ac_try;;
24175
 
  *) ac_try_echo=$ac_try;;
24176
 
esac
24177
 
eval "echo \"\$as_me:$LINENO: $ac_try_echo\"") >&5
24178
 
  (eval "$ac_try") 2>&5
24179
 
  ac_status=$?
24180
 
  echo "$as_me:$LINENO: \$? = $ac_status" >&5
24181
 
  (exit $ac_status); }; } &&
24182
 
         { ac_try='test -s conftest.$ac_objext'
24183
 
  { (case "(($ac_try" in
24184
 
  *\"* | *\`* | *\\*) ac_try_echo=\$ac_try;;
24185
 
  *) ac_try_echo=$ac_try;;
24186
 
esac
24187
 
eval "echo \"\$as_me:$LINENO: $ac_try_echo\"") >&5
24188
 
  (eval "$ac_try") 2>&5
24189
 
  ac_status=$?
24190
 
  echo "$as_me:$LINENO: \$? = $ac_status" >&5
24191
 
  (exit $ac_status); }; }; then
 
23036
  (exit $ac_status); } && {
 
23037
         test -z "$ac_c_werror_flag" ||
 
23038
         test ! -s conftest.err
 
23039
       } && test -s conftest.$ac_objext; then
24192
23040
  ac_hi=-1 ac_mid=-1
24193
23041
  while :; do
24194
23042
    cat >conftest.$ac_ext <<_ACEOF
24198
23046
cat >>conftest.$ac_ext <<_ACEOF
24199
23047
/* end confdefs.h.  */
24200
23048
$ac_includes_default
24201
 
                   typedef unsigned long long ac__type_sizeof_;
 
23049
   typedef unsigned long long ac__type_sizeof_;
24202
23050
int
24203
23051
main ()
24204
23052
{
24222
23070
  rm -f conftest.er1
24223
23071
  cat conftest.err >&5
24224
23072
  echo "$as_me:$LINENO: \$? = $ac_status" >&5
24225
 
  (exit $ac_status); } &&
24226
 
         { ac_try='test -z "$ac_c_werror_flag" || test ! -s conftest.err'
24227
 
  { (case "(($ac_try" in
24228
 
  *\"* | *\`* | *\\*) ac_try_echo=\$ac_try;;
24229
 
  *) ac_try_echo=$ac_try;;
24230
 
esac
24231
 
eval "echo \"\$as_me:$LINENO: $ac_try_echo\"") >&5
24232
 
  (eval "$ac_try") 2>&5
24233
 
  ac_status=$?
24234
 
  echo "$as_me:$LINENO: \$? = $ac_status" >&5
24235
 
  (exit $ac_status); }; } &&
24236
 
         { ac_try='test -s conftest.$ac_objext'
24237
 
  { (case "(($ac_try" in
24238
 
  *\"* | *\`* | *\\*) ac_try_echo=\$ac_try;;
24239
 
  *) ac_try_echo=$ac_try;;
24240
 
esac
24241
 
eval "echo \"\$as_me:$LINENO: $ac_try_echo\"") >&5
24242
 
  (eval "$ac_try") 2>&5
24243
 
  ac_status=$?
24244
 
  echo "$as_me:$LINENO: \$? = $ac_status" >&5
24245
 
  (exit $ac_status); }; }; then
 
23073
  (exit $ac_status); } && {
 
23074
         test -z "$ac_c_werror_flag" ||
 
23075
         test ! -s conftest.err
 
23076
       } && test -s conftest.$ac_objext; then
24246
23077
  ac_lo=$ac_mid; break
24247
23078
else
24248
23079
  echo "$as_me: failed program was:" >&5
24279
23110
cat >>conftest.$ac_ext <<_ACEOF
24280
23111
/* end confdefs.h.  */
24281
23112
$ac_includes_default
24282
 
                   typedef unsigned long long ac__type_sizeof_;
 
23113
   typedef unsigned long long ac__type_sizeof_;
24283
23114
int
24284
23115
main ()
24285
23116
{
24303
23134
  rm -f conftest.er1
24304
23135
  cat conftest.err >&5
24305
23136
  echo "$as_me:$LINENO: \$? = $ac_status" >&5
24306
 
  (exit $ac_status); } &&
24307
 
         { ac_try='test -z "$ac_c_werror_flag" || test ! -s conftest.err'
24308
 
  { (case "(($ac_try" in
24309
 
  *\"* | *\`* | *\\*) ac_try_echo=\$ac_try;;
24310
 
  *) ac_try_echo=$ac_try;;
24311
 
esac
24312
 
eval "echo \"\$as_me:$LINENO: $ac_try_echo\"") >&5
24313
 
  (eval "$ac_try") 2>&5
24314
 
  ac_status=$?
24315
 
  echo "$as_me:$LINENO: \$? = $ac_status" >&5
24316
 
  (exit $ac_status); }; } &&
24317
 
         { ac_try='test -s conftest.$ac_objext'
24318
 
  { (case "(($ac_try" in
24319
 
  *\"* | *\`* | *\\*) ac_try_echo=\$ac_try;;
24320
 
  *) ac_try_echo=$ac_try;;
24321
 
esac
24322
 
eval "echo \"\$as_me:$LINENO: $ac_try_echo\"") >&5
24323
 
  (eval "$ac_try") 2>&5
24324
 
  ac_status=$?
24325
 
  echo "$as_me:$LINENO: \$? = $ac_status" >&5
24326
 
  (exit $ac_status); }; }; then
 
23137
  (exit $ac_status); } && {
 
23138
         test -z "$ac_c_werror_flag" ||
 
23139
         test ! -s conftest.err
 
23140
       } && test -s conftest.$ac_objext; then
24327
23141
  ac_hi=$ac_mid
24328
23142
else
24329
23143
  echo "$as_me: failed program was:" >&5
24336
23150
done
24337
23151
case $ac_lo in
24338
23152
?*) ac_cv_sizeof_unsigned_long_long=$ac_lo;;
24339
 
'') { { echo "$as_me:$LINENO: error: cannot compute sizeof (unsigned long long)
 
23153
'') if test "$ac_cv_type_unsigned_long_long" = yes; then
 
23154
     { { echo "$as_me:$LINENO: error: cannot compute sizeof (unsigned long long)
24340
23155
See \`config.log' for more details." >&5
24341
23156
echo "$as_me: error: cannot compute sizeof (unsigned long long)
24342
23157
See \`config.log' for more details." >&2;}
24343
 
   { (exit 77); exit 77; }; } ;;
 
23158
   { (exit 77); exit 77; }; }
 
23159
   else
 
23160
     ac_cv_sizeof_unsigned_long_long=0
 
23161
   fi ;;
24344
23162
esac
24345
23163
else
24346
23164
  cat >conftest.$ac_ext <<_ACEOF
24350
23168
cat >>conftest.$ac_ext <<_ACEOF
24351
23169
/* end confdefs.h.  */
24352
23170
$ac_includes_default
24353
 
                   typedef unsigned long long ac__type_sizeof_;
 
23171
   typedef unsigned long long ac__type_sizeof_;
24354
23172
static long int longval () { return (long int) (sizeof (ac__type_sizeof_)); }
24355
23173
static unsigned long int ulongval () { return (long int) (sizeof (ac__type_sizeof_)); }
24356
23174
#include <stdio.h>
24409
23227
sed 's/^/| /' conftest.$ac_ext >&5
24410
23228
 
24411
23229
( exit $ac_status )
24412
 
{ { echo "$as_me:$LINENO: error: cannot compute sizeof (unsigned long long)
 
23230
if test "$ac_cv_type_unsigned_long_long" = yes; then
 
23231
     { { echo "$as_me:$LINENO: error: cannot compute sizeof (unsigned long long)
24413
23232
See \`config.log' for more details." >&5
24414
23233
echo "$as_me: error: cannot compute sizeof (unsigned long long)
24415
23234
See \`config.log' for more details." >&2;}
24416
23235
   { (exit 77); exit 77; }; }
 
23236
   else
 
23237
     ac_cv_sizeof_unsigned_long_long=0
 
23238
   fi
24417
23239
fi
24418
23240
rm -f core *.core core.conftest.* gmon.out bb.out conftest$ac_exeext conftest.$ac_objext conftest.$ac_ext
24419
23241
fi
24420
23242
rm -f conftest.val
24421
 
else
24422
 
  ac_cv_sizeof_unsigned_long_long=0
24423
 
fi
24424
23243
fi
24425
23244
{ echo "$as_me:$LINENO: result: $ac_cv_sizeof_unsigned_long_long" >&5
24426
23245
echo "${ECHO_T}$ac_cv_sizeof_unsigned_long_long" >&6; }
 
23246
 
 
23247
 
 
23248
 
24427
23249
cat >>confdefs.h <<_ACEOF
24428
23250
#define SIZEOF_UNSIGNED_LONG_LONG $ac_cv_sizeof_unsigned_long_long
24429
23251
_ACEOF
24565
23387
  rm -f conftest.er1
24566
23388
  cat conftest.err >&5
24567
23389
  echo "$as_me:$LINENO: \$? = $ac_status" >&5
24568
 
  (exit $ac_status); } &&
24569
 
         { ac_try='test -z "$ac_c_werror_flag" || test ! -s conftest.err'
24570
 
  { (case "(($ac_try" in
24571
 
  *\"* | *\`* | *\\*) ac_try_echo=\$ac_try;;
24572
 
  *) ac_try_echo=$ac_try;;
24573
 
esac
24574
 
eval "echo \"\$as_me:$LINENO: $ac_try_echo\"") >&5
24575
 
  (eval "$ac_try") 2>&5
24576
 
  ac_status=$?
24577
 
  echo "$as_me:$LINENO: \$? = $ac_status" >&5
24578
 
  (exit $ac_status); }; } &&
24579
 
         { ac_try='test -s conftest$ac_exeext'
24580
 
  { (case "(($ac_try" in
24581
 
  *\"* | *\`* | *\\*) ac_try_echo=\$ac_try;;
24582
 
  *) ac_try_echo=$ac_try;;
24583
 
esac
24584
 
eval "echo \"\$as_me:$LINENO: $ac_try_echo\"") >&5
24585
 
  (eval "$ac_try") 2>&5
24586
 
  ac_status=$?
24587
 
  echo "$as_me:$LINENO: \$? = $ac_status" >&5
24588
 
  (exit $ac_status); }; }; then
 
23390
  (exit $ac_status); } && {
 
23391
         test -z "$ac_c_werror_flag" ||
 
23392
         test ! -s conftest.err
 
23393
       } && test -s conftest$ac_exeext &&
 
23394
       $as_test_x conftest$ac_exeext; then
24589
23395
  ac_cv_lib_m_sqrt=yes
24590
23396
else
24591
23397
  echo "$as_me: failed program was:" >&5
24594
23400
        ac_cv_lib_m_sqrt=no
24595
23401
fi
24596
23402
 
24597
 
rm -f core conftest.err conftest.$ac_objext \
 
23403
rm -f core conftest.err conftest.$ac_objext conftest_ipa8_conftest.oo \
24598
23404
      conftest$ac_exeext conftest.$ac_ext
24599
23405
LIBS=$ac_check_lib_save_LIBS
24600
23406
fi
24654
23460
  rm -f conftest.er1
24655
23461
  cat conftest.err >&5
24656
23462
  echo "$as_me:$LINENO: \$? = $ac_status" >&5
24657
 
  (exit $ac_status); } &&
24658
 
         { ac_try='test -z "$ac_c_werror_flag" || test ! -s conftest.err'
24659
 
  { (case "(($ac_try" in
24660
 
  *\"* | *\`* | *\\*) ac_try_echo=\$ac_try;;
24661
 
  *) ac_try_echo=$ac_try;;
24662
 
esac
24663
 
eval "echo \"\$as_me:$LINENO: $ac_try_echo\"") >&5
24664
 
  (eval "$ac_try") 2>&5
24665
 
  ac_status=$?
24666
 
  echo "$as_me:$LINENO: \$? = $ac_status" >&5
24667
 
  (exit $ac_status); }; } &&
24668
 
         { ac_try='test -s conftest.$ac_objext'
24669
 
  { (case "(($ac_try" in
24670
 
  *\"* | *\`* | *\\*) ac_try_echo=\$ac_try;;
24671
 
  *) ac_try_echo=$ac_try;;
24672
 
esac
24673
 
eval "echo \"\$as_me:$LINENO: $ac_try_echo\"") >&5
24674
 
  (eval "$ac_try") 2>&5
24675
 
  ac_status=$?
24676
 
  echo "$as_me:$LINENO: \$? = $ac_status" >&5
24677
 
  (exit $ac_status); }; }; then
 
23463
  (exit $ac_status); } && {
 
23464
         test -z "$ac_c_werror_flag" ||
 
23465
         test ! -s conftest.err
 
23466
       } && test -s conftest.$ac_objext; then
24678
23467
  ac_header_compiler=yes
24679
23468
else
24680
23469
  echo "$as_me: failed program was:" >&5
24710
23499
  rm -f conftest.er1
24711
23500
  cat conftest.err >&5
24712
23501
  echo "$as_me:$LINENO: \$? = $ac_status" >&5
24713
 
  (exit $ac_status); } >/dev/null; then
24714
 
  if test -s conftest.err; then
24715
 
    ac_cpp_err=$ac_c_preproc_warn_flag
24716
 
    ac_cpp_err=$ac_cpp_err$ac_c_werror_flag
24717
 
  else
24718
 
    ac_cpp_err=
24719
 
  fi
24720
 
else
24721
 
  ac_cpp_err=yes
24722
 
fi
24723
 
if test -z "$ac_cpp_err"; then
 
23502
  (exit $ac_status); } >/dev/null && {
 
23503
         test -z "$ac_c_preproc_warn_flag$ac_c_werror_flag" ||
 
23504
         test ! -s conftest.err
 
23505
       }; then
24724
23506
  ac_header_preproc=yes
24725
23507
else
24726
23508
  echo "$as_me: failed program was:" >&5
24810
23592
  rm -f conftest.er1
24811
23593
  cat conftest.err >&5
24812
23594
  echo "$as_me:$LINENO: \$? = $ac_status" >&5
24813
 
  (exit $ac_status); } &&
24814
 
         { ac_try='test -z "$ac_c_werror_flag" || test ! -s conftest.err'
24815
 
  { (case "(($ac_try" in
24816
 
  *\"* | *\`* | *\\*) ac_try_echo=\$ac_try;;
24817
 
  *) ac_try_echo=$ac_try;;
24818
 
esac
24819
 
eval "echo \"\$as_me:$LINENO: $ac_try_echo\"") >&5
24820
 
  (eval "$ac_try") 2>&5
24821
 
  ac_status=$?
24822
 
  echo "$as_me:$LINENO: \$? = $ac_status" >&5
24823
 
  (exit $ac_status); }; } &&
24824
 
         { ac_try='test -s conftest.$ac_objext'
24825
 
  { (case "(($ac_try" in
24826
 
  *\"* | *\`* | *\\*) ac_try_echo=\$ac_try;;
24827
 
  *) ac_try_echo=$ac_try;;
24828
 
esac
24829
 
eval "echo \"\$as_me:$LINENO: $ac_try_echo\"") >&5
24830
 
  (eval "$ac_try") 2>&5
24831
 
  ac_status=$?
24832
 
  echo "$as_me:$LINENO: \$? = $ac_status" >&5
24833
 
  (exit $ac_status); }; }; then
 
23595
  (exit $ac_status); } && {
 
23596
         test -z "$ac_c_werror_flag" ||
 
23597
         test ! -s conftest.err
 
23598
       } && test -s conftest.$ac_objext; then
24834
23599
  ac_header_compiler=yes
24835
23600
else
24836
23601
  echo "$as_me: failed program was:" >&5
24866
23631
  rm -f conftest.er1
24867
23632
  cat conftest.err >&5
24868
23633
  echo "$as_me:$LINENO: \$? = $ac_status" >&5
24869
 
  (exit $ac_status); } >/dev/null; then
24870
 
  if test -s conftest.err; then
24871
 
    ac_cpp_err=$ac_c_preproc_warn_flag
24872
 
    ac_cpp_err=$ac_cpp_err$ac_c_werror_flag
24873
 
  else
24874
 
    ac_cpp_err=
24875
 
  fi
24876
 
else
24877
 
  ac_cpp_err=yes
24878
 
fi
24879
 
if test -z "$ac_cpp_err"; then
 
23634
  (exit $ac_status); } >/dev/null && {
 
23635
         test -z "$ac_c_preproc_warn_flag$ac_c_werror_flag" ||
 
23636
         test ! -s conftest.err
 
23637
       }; then
24880
23638
  ac_header_preproc=yes
24881
23639
else
24882
23640
  echo "$as_me: failed program was:" >&5
24966
23724
  rm -f conftest.er1
24967
23725
  cat conftest.err >&5
24968
23726
  echo "$as_me:$LINENO: \$? = $ac_status" >&5
24969
 
  (exit $ac_status); } &&
24970
 
         { ac_try='test -z "$ac_c_werror_flag" || test ! -s conftest.err'
24971
 
  { (case "(($ac_try" in
24972
 
  *\"* | *\`* | *\\*) ac_try_echo=\$ac_try;;
24973
 
  *) ac_try_echo=$ac_try;;
24974
 
esac
24975
 
eval "echo \"\$as_me:$LINENO: $ac_try_echo\"") >&5
24976
 
  (eval "$ac_try") 2>&5
24977
 
  ac_status=$?
24978
 
  echo "$as_me:$LINENO: \$? = $ac_status" >&5
24979
 
  (exit $ac_status); }; } &&
24980
 
         { ac_try='test -s conftest.$ac_objext'
24981
 
  { (case "(($ac_try" in
24982
 
  *\"* | *\`* | *\\*) ac_try_echo=\$ac_try;;
24983
 
  *) ac_try_echo=$ac_try;;
24984
 
esac
24985
 
eval "echo \"\$as_me:$LINENO: $ac_try_echo\"") >&5
24986
 
  (eval "$ac_try") 2>&5
24987
 
  ac_status=$?
24988
 
  echo "$as_me:$LINENO: \$? = $ac_status" >&5
24989
 
  (exit $ac_status); }; }; then
 
23727
  (exit $ac_status); } && {
 
23728
         test -z "$ac_c_werror_flag" ||
 
23729
         test ! -s conftest.err
 
23730
       } && test -s conftest.$ac_objext; then
24990
23731
  ac_header_compiler=yes
24991
23732
else
24992
23733
  echo "$as_me: failed program was:" >&5
25022
23763
  rm -f conftest.er1
25023
23764
  cat conftest.err >&5
25024
23765
  echo "$as_me:$LINENO: \$? = $ac_status" >&5
25025
 
  (exit $ac_status); } >/dev/null; then
25026
 
  if test -s conftest.err; then
25027
 
    ac_cpp_err=$ac_c_preproc_warn_flag
25028
 
    ac_cpp_err=$ac_cpp_err$ac_c_werror_flag
25029
 
  else
25030
 
    ac_cpp_err=
25031
 
  fi
25032
 
else
25033
 
  ac_cpp_err=yes
25034
 
fi
25035
 
if test -z "$ac_cpp_err"; then
 
23766
  (exit $ac_status); } >/dev/null && {
 
23767
         test -z "$ac_c_preproc_warn_flag$ac_c_werror_flag" ||
 
23768
         test ! -s conftest.err
 
23769
       }; then
25036
23770
  ac_header_preproc=yes
25037
23771
else
25038
23772
  echo "$as_me: failed program was:" >&5
25122
23856
  rm -f conftest.er1
25123
23857
  cat conftest.err >&5
25124
23858
  echo "$as_me:$LINENO: \$? = $ac_status" >&5
25125
 
  (exit $ac_status); } &&
25126
 
         { ac_try='test -z "$ac_c_werror_flag" || test ! -s conftest.err'
25127
 
  { (case "(($ac_try" in
25128
 
  *\"* | *\`* | *\\*) ac_try_echo=\$ac_try;;
25129
 
  *) ac_try_echo=$ac_try;;
25130
 
esac
25131
 
eval "echo \"\$as_me:$LINENO: $ac_try_echo\"") >&5
25132
 
  (eval "$ac_try") 2>&5
25133
 
  ac_status=$?
25134
 
  echo "$as_me:$LINENO: \$? = $ac_status" >&5
25135
 
  (exit $ac_status); }; } &&
25136
 
         { ac_try='test -s conftest.$ac_objext'
25137
 
  { (case "(($ac_try" in
25138
 
  *\"* | *\`* | *\\*) ac_try_echo=\$ac_try;;
25139
 
  *) ac_try_echo=$ac_try;;
25140
 
esac
25141
 
eval "echo \"\$as_me:$LINENO: $ac_try_echo\"") >&5
25142
 
  (eval "$ac_try") 2>&5
25143
 
  ac_status=$?
25144
 
  echo "$as_me:$LINENO: \$? = $ac_status" >&5
25145
 
  (exit $ac_status); }; }; then
 
23859
  (exit $ac_status); } && {
 
23860
         test -z "$ac_c_werror_flag" ||
 
23861
         test ! -s conftest.err
 
23862
       } && test -s conftest.$ac_objext; then
25146
23863
  ac_header_compiler=yes
25147
23864
else
25148
23865
  echo "$as_me: failed program was:" >&5
25178
23895
  rm -f conftest.er1
25179
23896
  cat conftest.err >&5
25180
23897
  echo "$as_me:$LINENO: \$? = $ac_status" >&5
25181
 
  (exit $ac_status); } >/dev/null; then
25182
 
  if test -s conftest.err; then
25183
 
    ac_cpp_err=$ac_c_preproc_warn_flag
25184
 
    ac_cpp_err=$ac_cpp_err$ac_c_werror_flag
25185
 
  else
25186
 
    ac_cpp_err=
25187
 
  fi
25188
 
else
25189
 
  ac_cpp_err=yes
25190
 
fi
25191
 
if test -z "$ac_cpp_err"; then
 
23898
  (exit $ac_status); } >/dev/null && {
 
23899
         test -z "$ac_c_preproc_warn_flag$ac_c_werror_flag" ||
 
23900
         test ! -s conftest.err
 
23901
       }; then
25192
23902
  ac_header_preproc=yes
25193
23903
else
25194
23904
  echo "$as_me: failed program was:" >&5
25286
23996
  rm -f conftest.er1
25287
23997
  cat conftest.err >&5
25288
23998
  echo "$as_me:$LINENO: \$? = $ac_status" >&5
25289
 
  (exit $ac_status); } &&
25290
 
         { ac_try='test -z "$ac_c_werror_flag" || test ! -s conftest.err'
25291
 
  { (case "(($ac_try" in
25292
 
  *\"* | *\`* | *\\*) ac_try_echo=\$ac_try;;
25293
 
  *) ac_try_echo=$ac_try;;
25294
 
esac
25295
 
eval "echo \"\$as_me:$LINENO: $ac_try_echo\"") >&5
25296
 
  (eval "$ac_try") 2>&5
25297
 
  ac_status=$?
25298
 
  echo "$as_me:$LINENO: \$? = $ac_status" >&5
25299
 
  (exit $ac_status); }; } &&
25300
 
         { ac_try='test -s conftest$ac_exeext'
25301
 
  { (case "(($ac_try" in
25302
 
  *\"* | *\`* | *\\*) ac_try_echo=\$ac_try;;
25303
 
  *) ac_try_echo=$ac_try;;
25304
 
esac
25305
 
eval "echo \"\$as_me:$LINENO: $ac_try_echo\"") >&5
25306
 
  (eval "$ac_try") 2>&5
25307
 
  ac_status=$?
25308
 
  echo "$as_me:$LINENO: \$? = $ac_status" >&5
25309
 
  (exit $ac_status); }; }; then
 
23999
  (exit $ac_status); } && {
 
24000
         test -z "$ac_c_werror_flag" ||
 
24001
         test ! -s conftest.err
 
24002
       } && test -s conftest$ac_exeext &&
 
24003
       $as_test_x conftest$ac_exeext; then
25310
24004
  ac_cv_lib_jpeg_jpeg_read_header=yes
25311
24005
else
25312
24006
  echo "$as_me: failed program was:" >&5
25315
24009
        ac_cv_lib_jpeg_jpeg_read_header=no
25316
24010
fi
25317
24011
 
25318
 
rm -f core conftest.err conftest.$ac_objext \
 
24012
rm -f core conftest.err conftest.$ac_objext conftest_ipa8_conftest.oo \
25319
24013
      conftest$ac_exeext conftest.$ac_ext
25320
24014
LIBS=$ac_check_lib_save_LIBS
25321
24015
fi
25371
24065
  rm -f conftest.er1
25372
24066
  cat conftest.err >&5
25373
24067
  echo "$as_me:$LINENO: \$? = $ac_status" >&5
25374
 
  (exit $ac_status); } &&
25375
 
         { ac_try='test -z "$ac_c_werror_flag" || test ! -s conftest.err'
25376
 
  { (case "(($ac_try" in
25377
 
  *\"* | *\`* | *\\*) ac_try_echo=\$ac_try;;
25378
 
  *) ac_try_echo=$ac_try;;
25379
 
esac
25380
 
eval "echo \"\$as_me:$LINENO: $ac_try_echo\"") >&5
25381
 
  (eval "$ac_try") 2>&5
25382
 
  ac_status=$?
25383
 
  echo "$as_me:$LINENO: \$? = $ac_status" >&5
25384
 
  (exit $ac_status); }; } &&
25385
 
         { ac_try='test -s conftest.$ac_objext'
25386
 
  { (case "(($ac_try" in
25387
 
  *\"* | *\`* | *\\*) ac_try_echo=\$ac_try;;
25388
 
  *) ac_try_echo=$ac_try;;
25389
 
esac
25390
 
eval "echo \"\$as_me:$LINENO: $ac_try_echo\"") >&5
25391
 
  (eval "$ac_try") 2>&5
25392
 
  ac_status=$?
25393
 
  echo "$as_me:$LINENO: \$? = $ac_status" >&5
25394
 
  (exit $ac_status); }; }; then
 
24068
  (exit $ac_status); } && {
 
24069
         test -z "$ac_c_werror_flag" ||
 
24070
         test ! -s conftest.err
 
24071
       } && test -s conftest.$ac_objext; then
25395
24072
  ac_cv_jpeg_version_ok='yes'
25396
24073
else
25397
24074
  echo "$as_me: failed program was:" >&5
25497
24174
  rm -f conftest.er1
25498
24175
  cat conftest.err >&5
25499
24176
  echo "$as_me:$LINENO: \$? = $ac_status" >&5
25500
 
  (exit $ac_status); } &&
25501
 
         { ac_try='test -z "$ac_c_werror_flag" || test ! -s conftest.err'
25502
 
  { (case "(($ac_try" in
25503
 
  *\"* | *\`* | *\\*) ac_try_echo=\$ac_try;;
25504
 
  *) ac_try_echo=$ac_try;;
25505
 
esac
25506
 
eval "echo \"\$as_me:$LINENO: $ac_try_echo\"") >&5
25507
 
  (eval "$ac_try") 2>&5
25508
 
  ac_status=$?
25509
 
  echo "$as_me:$LINENO: \$? = $ac_status" >&5
25510
 
  (exit $ac_status); }; } &&
25511
 
         { ac_try='test -s conftest.$ac_objext'
25512
 
  { (case "(($ac_try" in
25513
 
  *\"* | *\`* | *\\*) ac_try_echo=\$ac_try;;
25514
 
  *) ac_try_echo=$ac_try;;
25515
 
esac
25516
 
eval "echo \"\$as_me:$LINENO: $ac_try_echo\"") >&5
25517
 
  (eval "$ac_try") 2>&5
25518
 
  ac_status=$?
25519
 
  echo "$as_me:$LINENO: \$? = $ac_status" >&5
25520
 
  (exit $ac_status); }; }; then
 
24177
  (exit $ac_status); } && {
 
24178
         test -z "$ac_c_werror_flag" ||
 
24179
         test ! -s conftest.err
 
24180
       } && test -s conftest.$ac_objext; then
25521
24181
  ac_header_compiler=yes
25522
24182
else
25523
24183
  echo "$as_me: failed program was:" >&5
25553
24213
  rm -f conftest.er1
25554
24214
  cat conftest.err >&5
25555
24215
  echo "$as_me:$LINENO: \$? = $ac_status" >&5
25556
 
  (exit $ac_status); } >/dev/null; then
25557
 
  if test -s conftest.err; then
25558
 
    ac_cpp_err=$ac_c_preproc_warn_flag
25559
 
    ac_cpp_err=$ac_cpp_err$ac_c_werror_flag
25560
 
  else
25561
 
    ac_cpp_err=
25562
 
  fi
25563
 
else
25564
 
  ac_cpp_err=yes
25565
 
fi
25566
 
if test -z "$ac_cpp_err"; then
 
24216
  (exit $ac_status); } >/dev/null && {
 
24217
         test -z "$ac_c_preproc_warn_flag$ac_c_werror_flag" ||
 
24218
         test ! -s conftest.err
 
24219
       }; then
25567
24220
  ac_header_preproc=yes
25568
24221
else
25569
24222
  echo "$as_me: failed program was:" >&5
25653
24306
  rm -f conftest.er1
25654
24307
  cat conftest.err >&5
25655
24308
  echo "$as_me:$LINENO: \$? = $ac_status" >&5
25656
 
  (exit $ac_status); } &&
25657
 
         { ac_try='test -z "$ac_c_werror_flag" || test ! -s conftest.err'
25658
 
  { (case "(($ac_try" in
25659
 
  *\"* | *\`* | *\\*) ac_try_echo=\$ac_try;;
25660
 
  *) ac_try_echo=$ac_try;;
25661
 
esac
25662
 
eval "echo \"\$as_me:$LINENO: $ac_try_echo\"") >&5
25663
 
  (eval "$ac_try") 2>&5
25664
 
  ac_status=$?
25665
 
  echo "$as_me:$LINENO: \$? = $ac_status" >&5
25666
 
  (exit $ac_status); }; } &&
25667
 
         { ac_try='test -s conftest.$ac_objext'
25668
 
  { (case "(($ac_try" in
25669
 
  *\"* | *\`* | *\\*) ac_try_echo=\$ac_try;;
25670
 
  *) ac_try_echo=$ac_try;;
25671
 
esac
25672
 
eval "echo \"\$as_me:$LINENO: $ac_try_echo\"") >&5
25673
 
  (eval "$ac_try") 2>&5
25674
 
  ac_status=$?
25675
 
  echo "$as_me:$LINENO: \$? = $ac_status" >&5
25676
 
  (exit $ac_status); }; }; then
 
24309
  (exit $ac_status); } && {
 
24310
         test -z "$ac_c_werror_flag" ||
 
24311
         test ! -s conftest.err
 
24312
       } && test -s conftest.$ac_objext; then
25677
24313
  ac_header_compiler=yes
25678
24314
else
25679
24315
  echo "$as_me: failed program was:" >&5
25709
24345
  rm -f conftest.er1
25710
24346
  cat conftest.err >&5
25711
24347
  echo "$as_me:$LINENO: \$? = $ac_status" >&5
25712
 
  (exit $ac_status); } >/dev/null; then
25713
 
  if test -s conftest.err; then
25714
 
    ac_cpp_err=$ac_c_preproc_warn_flag
25715
 
    ac_cpp_err=$ac_cpp_err$ac_c_werror_flag
25716
 
  else
25717
 
    ac_cpp_err=
25718
 
  fi
25719
 
else
25720
 
  ac_cpp_err=yes
25721
 
fi
25722
 
if test -z "$ac_cpp_err"; then
 
24348
  (exit $ac_status); } >/dev/null && {
 
24349
         test -z "$ac_c_preproc_warn_flag$ac_c_werror_flag" ||
 
24350
         test ! -s conftest.err
 
24351
       }; then
25723
24352
  ac_header_preproc=yes
25724
24353
else
25725
24354
  echo "$as_me: failed program was:" >&5
25817
24446
  rm -f conftest.er1
25818
24447
  cat conftest.err >&5
25819
24448
  echo "$as_me:$LINENO: \$? = $ac_status" >&5
25820
 
  (exit $ac_status); } &&
25821
 
         { ac_try='test -z "$ac_c_werror_flag" || test ! -s conftest.err'
25822
 
  { (case "(($ac_try" in
25823
 
  *\"* | *\`* | *\\*) ac_try_echo=\$ac_try;;
25824
 
  *) ac_try_echo=$ac_try;;
25825
 
esac
25826
 
eval "echo \"\$as_me:$LINENO: $ac_try_echo\"") >&5
25827
 
  (eval "$ac_try") 2>&5
25828
 
  ac_status=$?
25829
 
  echo "$as_me:$LINENO: \$? = $ac_status" >&5
25830
 
  (exit $ac_status); }; } &&
25831
 
         { ac_try='test -s conftest$ac_exeext'
25832
 
  { (case "(($ac_try" in
25833
 
  *\"* | *\`* | *\\*) ac_try_echo=\$ac_try;;
25834
 
  *) ac_try_echo=$ac_try;;
25835
 
esac
25836
 
eval "echo \"\$as_me:$LINENO: $ac_try_echo\"") >&5
25837
 
  (eval "$ac_try") 2>&5
25838
 
  ac_status=$?
25839
 
  echo "$as_me:$LINENO: \$? = $ac_status" >&5
25840
 
  (exit $ac_status); }; }; then
 
24449
  (exit $ac_status); } && {
 
24450
         test -z "$ac_c_werror_flag" ||
 
24451
         test ! -s conftest.err
 
24452
       } && test -s conftest$ac_exeext &&
 
24453
       $as_test_x conftest$ac_exeext; then
25841
24454
  ac_cv_lib_z_compress=yes
25842
24455
else
25843
24456
  echo "$as_me: failed program was:" >&5
25846
24459
        ac_cv_lib_z_compress=no
25847
24460
fi
25848
24461
 
25849
 
rm -f core conftest.err conftest.$ac_objext \
 
24462
rm -f core conftest.err conftest.$ac_objext conftest_ipa8_conftest.oo \
25850
24463
      conftest$ac_exeext conftest.$ac_ext
25851
24464
LIBS=$ac_check_lib_save_LIBS
25852
24465
fi
25900
24513
  rm -f conftest.er1
25901
24514
  cat conftest.err >&5
25902
24515
  echo "$as_me:$LINENO: \$? = $ac_status" >&5
25903
 
  (exit $ac_status); } &&
25904
 
         { ac_try='test -z "$ac_c_werror_flag" || test ! -s conftest.err'
25905
 
  { (case "(($ac_try" in
25906
 
  *\"* | *\`* | *\\*) ac_try_echo=\$ac_try;;
25907
 
  *) ac_try_echo=$ac_try;;
25908
 
esac
25909
 
eval "echo \"\$as_me:$LINENO: $ac_try_echo\"") >&5
25910
 
  (eval "$ac_try") 2>&5
25911
 
  ac_status=$?
25912
 
  echo "$as_me:$LINENO: \$? = $ac_status" >&5
25913
 
  (exit $ac_status); }; } &&
25914
 
         { ac_try='test -s conftest$ac_exeext'
25915
 
  { (case "(($ac_try" in
25916
 
  *\"* | *\`* | *\\*) ac_try_echo=\$ac_try;;
25917
 
  *) ac_try_echo=$ac_try;;
25918
 
esac
25919
 
eval "echo \"\$as_me:$LINENO: $ac_try_echo\"") >&5
25920
 
  (eval "$ac_try") 2>&5
25921
 
  ac_status=$?
25922
 
  echo "$as_me:$LINENO: \$? = $ac_status" >&5
25923
 
  (exit $ac_status); }; }; then
 
24516
  (exit $ac_status); } && {
 
24517
         test -z "$ac_c_werror_flag" ||
 
24518
         test ! -s conftest.err
 
24519
       } && test -s conftest$ac_exeext &&
 
24520
       $as_test_x conftest$ac_exeext; then
25924
24521
  ac_cv_lib_z_uncompress=yes
25925
24522
else
25926
24523
  echo "$as_me: failed program was:" >&5
25929
24526
        ac_cv_lib_z_uncompress=no
25930
24527
fi
25931
24528
 
25932
 
rm -f core conftest.err conftest.$ac_objext \
 
24529
rm -f core conftest.err conftest.$ac_objext conftest_ipa8_conftest.oo \
25933
24530
      conftest$ac_exeext conftest.$ac_ext
25934
24531
LIBS=$ac_check_lib_save_LIBS
25935
24532
fi
25983
24580
  rm -f conftest.er1
25984
24581
  cat conftest.err >&5
25985
24582
  echo "$as_me:$LINENO: \$? = $ac_status" >&5
25986
 
  (exit $ac_status); } &&
25987
 
         { ac_try='test -z "$ac_c_werror_flag" || test ! -s conftest.err'
25988
 
  { (case "(($ac_try" in
25989
 
  *\"* | *\`* | *\\*) ac_try_echo=\$ac_try;;
25990
 
  *) ac_try_echo=$ac_try;;
25991
 
esac
25992
 
eval "echo \"\$as_me:$LINENO: $ac_try_echo\"") >&5
25993
 
  (eval "$ac_try") 2>&5
25994
 
  ac_status=$?
25995
 
  echo "$as_me:$LINENO: \$? = $ac_status" >&5
25996
 
  (exit $ac_status); }; } &&
25997
 
         { ac_try='test -s conftest$ac_exeext'
25998
 
  { (case "(($ac_try" in
25999
 
  *\"* | *\`* | *\\*) ac_try_echo=\$ac_try;;
26000
 
  *) ac_try_echo=$ac_try;;
26001
 
esac
26002
 
eval "echo \"\$as_me:$LINENO: $ac_try_echo\"") >&5
26003
 
  (eval "$ac_try") 2>&5
26004
 
  ac_status=$?
26005
 
  echo "$as_me:$LINENO: \$? = $ac_status" >&5
26006
 
  (exit $ac_status); }; }; then
 
24583
  (exit $ac_status); } && {
 
24584
         test -z "$ac_c_werror_flag" ||
 
24585
         test ! -s conftest.err
 
24586
       } && test -s conftest$ac_exeext &&
 
24587
       $as_test_x conftest$ac_exeext; then
26007
24588
  ac_cv_lib_z_deflate=yes
26008
24589
else
26009
24590
  echo "$as_me: failed program was:" >&5
26012
24593
        ac_cv_lib_z_deflate=no
26013
24594
fi
26014
24595
 
26015
 
rm -f core conftest.err conftest.$ac_objext \
 
24596
rm -f core conftest.err conftest.$ac_objext conftest_ipa8_conftest.oo \
26016
24597
      conftest$ac_exeext conftest.$ac_ext
26017
24598
LIBS=$ac_check_lib_save_LIBS
26018
24599
fi
26066
24647
  rm -f conftest.er1
26067
24648
  cat conftest.err >&5
26068
24649
  echo "$as_me:$LINENO: \$? = $ac_status" >&5
26069
 
  (exit $ac_status); } &&
26070
 
         { ac_try='test -z "$ac_c_werror_flag" || test ! -s conftest.err'
26071
 
  { (case "(($ac_try" in
26072
 
  *\"* | *\`* | *\\*) ac_try_echo=\$ac_try;;
26073
 
  *) ac_try_echo=$ac_try;;
26074
 
esac
26075
 
eval "echo \"\$as_me:$LINENO: $ac_try_echo\"") >&5
26076
 
  (eval "$ac_try") 2>&5
26077
 
  ac_status=$?
26078
 
  echo "$as_me:$LINENO: \$? = $ac_status" >&5
26079
 
  (exit $ac_status); }; } &&
26080
 
         { ac_try='test -s conftest$ac_exeext'
26081
 
  { (case "(($ac_try" in
26082
 
  *\"* | *\`* | *\\*) ac_try_echo=\$ac_try;;
26083
 
  *) ac_try_echo=$ac_try;;
26084
 
esac
26085
 
eval "echo \"\$as_me:$LINENO: $ac_try_echo\"") >&5
26086
 
  (eval "$ac_try") 2>&5
26087
 
  ac_status=$?
26088
 
  echo "$as_me:$LINENO: \$? = $ac_status" >&5
26089
 
  (exit $ac_status); }; }; then
 
24650
  (exit $ac_status); } && {
 
24651
         test -z "$ac_c_werror_flag" ||
 
24652
         test ! -s conftest.err
 
24653
       } && test -s conftest$ac_exeext &&
 
24654
       $as_test_x conftest$ac_exeext; then
26090
24655
  ac_cv_lib_z_inflate=yes
26091
24656
else
26092
24657
  echo "$as_me: failed program was:" >&5
26095
24660
        ac_cv_lib_z_inflate=no
26096
24661
fi
26097
24662
 
26098
 
rm -f core conftest.err conftest.$ac_objext \
 
24663
rm -f core conftest.err conftest.$ac_objext conftest_ipa8_conftest.oo \
26099
24664
      conftest$ac_exeext conftest.$ac_ext
26100
24665
LIBS=$ac_check_lib_save_LIBS
26101
24666
fi
26149
24714
  rm -f conftest.er1
26150
24715
  cat conftest.err >&5
26151
24716
  echo "$as_me:$LINENO: \$? = $ac_status" >&5
26152
 
  (exit $ac_status); } &&
26153
 
         { ac_try='test -z "$ac_c_werror_flag" || test ! -s conftest.err'
26154
 
  { (case "(($ac_try" in
26155
 
  *\"* | *\`* | *\\*) ac_try_echo=\$ac_try;;
26156
 
  *) ac_try_echo=$ac_try;;
26157
 
esac
26158
 
eval "echo \"\$as_me:$LINENO: $ac_try_echo\"") >&5
26159
 
  (eval "$ac_try") 2>&5
26160
 
  ac_status=$?
26161
 
  echo "$as_me:$LINENO: \$? = $ac_status" >&5
26162
 
  (exit $ac_status); }; } &&
26163
 
         { ac_try='test -s conftest$ac_exeext'
26164
 
  { (case "(($ac_try" in
26165
 
  *\"* | *\`* | *\\*) ac_try_echo=\$ac_try;;
26166
 
  *) ac_try_echo=$ac_try;;
26167
 
esac
26168
 
eval "echo \"\$as_me:$LINENO: $ac_try_echo\"") >&5
26169
 
  (eval "$ac_try") 2>&5
26170
 
  ac_status=$?
26171
 
  echo "$as_me:$LINENO: \$? = $ac_status" >&5
26172
 
  (exit $ac_status); }; }; then
 
24717
  (exit $ac_status); } && {
 
24718
         test -z "$ac_c_werror_flag" ||
 
24719
         test ! -s conftest.err
 
24720
       } && test -s conftest$ac_exeext &&
 
24721
       $as_test_x conftest$ac_exeext; then
26173
24722
  ac_cv_lib_z_gzseek=yes
26174
24723
else
26175
24724
  echo "$as_me: failed program was:" >&5
26178
24727
        ac_cv_lib_z_gzseek=no
26179
24728
fi
26180
24729
 
26181
 
rm -f core conftest.err conftest.$ac_objext \
 
24730
rm -f core conftest.err conftest.$ac_objext conftest_ipa8_conftest.oo \
26182
24731
      conftest$ac_exeext conftest.$ac_ext
26183
24732
LIBS=$ac_check_lib_save_LIBS
26184
24733
fi
26232
24781
  rm -f conftest.er1
26233
24782
  cat conftest.err >&5
26234
24783
  echo "$as_me:$LINENO: \$? = $ac_status" >&5
26235
 
  (exit $ac_status); } &&
26236
 
         { ac_try='test -z "$ac_c_werror_flag" || test ! -s conftest.err'
26237
 
  { (case "(($ac_try" in
26238
 
  *\"* | *\`* | *\\*) ac_try_echo=\$ac_try;;
26239
 
  *) ac_try_echo=$ac_try;;
26240
 
esac
26241
 
eval "echo \"\$as_me:$LINENO: $ac_try_echo\"") >&5
26242
 
  (eval "$ac_try") 2>&5
26243
 
  ac_status=$?
26244
 
  echo "$as_me:$LINENO: \$? = $ac_status" >&5
26245
 
  (exit $ac_status); }; } &&
26246
 
         { ac_try='test -s conftest$ac_exeext'
26247
 
  { (case "(($ac_try" in
26248
 
  *\"* | *\`* | *\\*) ac_try_echo=\$ac_try;;
26249
 
  *) ac_try_echo=$ac_try;;
26250
 
esac
26251
 
eval "echo \"\$as_me:$LINENO: $ac_try_echo\"") >&5
26252
 
  (eval "$ac_try") 2>&5
26253
 
  ac_status=$?
26254
 
  echo "$as_me:$LINENO: \$? = $ac_status" >&5
26255
 
  (exit $ac_status); }; }; then
 
24784
  (exit $ac_status); } && {
 
24785
         test -z "$ac_c_werror_flag" ||
 
24786
         test ! -s conftest.err
 
24787
       } && test -s conftest$ac_exeext &&
 
24788
       $as_test_x conftest$ac_exeext; then
26256
24789
  ac_cv_lib_z_gztell=yes
26257
24790
else
26258
24791
  echo "$as_me: failed program was:" >&5
26261
24794
        ac_cv_lib_z_gztell=no
26262
24795
fi
26263
24796
 
26264
 
rm -f core conftest.err conftest.$ac_objext \
 
24797
rm -f core conftest.err conftest.$ac_objext conftest_ipa8_conftest.oo \
26265
24798
      conftest$ac_exeext conftest.$ac_ext
26266
24799
LIBS=$ac_check_lib_save_LIBS
26267
24800
fi
26356
24889
  rm -f conftest.er1
26357
24890
  cat conftest.err >&5
26358
24891
  echo "$as_me:$LINENO: \$? = $ac_status" >&5
26359
 
  (exit $ac_status); } &&
26360
 
         { ac_try='test -z "$ac_c_werror_flag" || test ! -s conftest.err'
26361
 
  { (case "(($ac_try" in
26362
 
  *\"* | *\`* | *\\*) ac_try_echo=\$ac_try;;
26363
 
  *) ac_try_echo=$ac_try;;
26364
 
esac
26365
 
eval "echo \"\$as_me:$LINENO: $ac_try_echo\"") >&5
26366
 
  (eval "$ac_try") 2>&5
26367
 
  ac_status=$?
26368
 
  echo "$as_me:$LINENO: \$? = $ac_status" >&5
26369
 
  (exit $ac_status); }; } &&
26370
 
         { ac_try='test -s conftest.$ac_objext'
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); }; }; then
 
24892
  (exit $ac_status); } && {
 
24893
         test -z "$ac_c_werror_flag" ||
 
24894
         test ! -s conftest.err
 
24895
       } && test -s conftest.$ac_objext; then
26380
24896
  ac_header_compiler=yes
26381
24897
else
26382
24898
  echo "$as_me: failed program was:" >&5
26412
24928
  rm -f conftest.er1
26413
24929
  cat conftest.err >&5
26414
24930
  echo "$as_me:$LINENO: \$? = $ac_status" >&5
26415
 
  (exit $ac_status); } >/dev/null; then
26416
 
  if test -s conftest.err; then
26417
 
    ac_cpp_err=$ac_c_preproc_warn_flag
26418
 
    ac_cpp_err=$ac_cpp_err$ac_c_werror_flag
26419
 
  else
26420
 
    ac_cpp_err=
26421
 
  fi
26422
 
else
26423
 
  ac_cpp_err=yes
26424
 
fi
26425
 
if test -z "$ac_cpp_err"; then
 
24931
  (exit $ac_status); } >/dev/null && {
 
24932
         test -z "$ac_c_preproc_warn_flag$ac_c_werror_flag" ||
 
24933
         test ! -s conftest.err
 
24934
       }; then
26426
24935
  ac_header_preproc=yes
26427
24936
else
26428
24937
  echo "$as_me: failed program was:" >&5
26512
25021
  rm -f conftest.er1
26513
25022
  cat conftest.err >&5
26514
25023
  echo "$as_me:$LINENO: \$? = $ac_status" >&5
26515
 
  (exit $ac_status); } &&
26516
 
         { ac_try='test -z "$ac_c_werror_flag" || test ! -s conftest.err'
26517
 
  { (case "(($ac_try" in
26518
 
  *\"* | *\`* | *\\*) ac_try_echo=\$ac_try;;
26519
 
  *) ac_try_echo=$ac_try;;
26520
 
esac
26521
 
eval "echo \"\$as_me:$LINENO: $ac_try_echo\"") >&5
26522
 
  (eval "$ac_try") 2>&5
26523
 
  ac_status=$?
26524
 
  echo "$as_me:$LINENO: \$? = $ac_status" >&5
26525
 
  (exit $ac_status); }; } &&
26526
 
         { ac_try='test -s conftest.$ac_objext'
26527
 
  { (case "(($ac_try" in
26528
 
  *\"* | *\`* | *\\*) ac_try_echo=\$ac_try;;
26529
 
  *) ac_try_echo=$ac_try;;
26530
 
esac
26531
 
eval "echo \"\$as_me:$LINENO: $ac_try_echo\"") >&5
26532
 
  (eval "$ac_try") 2>&5
26533
 
  ac_status=$?
26534
 
  echo "$as_me:$LINENO: \$? = $ac_status" >&5
26535
 
  (exit $ac_status); }; }; then
 
25024
  (exit $ac_status); } && {
 
25025
         test -z "$ac_c_werror_flag" ||
 
25026
         test ! -s conftest.err
 
25027
       } && test -s conftest.$ac_objext; then
26536
25028
  ac_header_compiler=yes
26537
25029
else
26538
25030
  echo "$as_me: failed program was:" >&5
26568
25060
  rm -f conftest.er1
26569
25061
  cat conftest.err >&5
26570
25062
  echo "$as_me:$LINENO: \$? = $ac_status" >&5
26571
 
  (exit $ac_status); } >/dev/null; then
26572
 
  if test -s conftest.err; then
26573
 
    ac_cpp_err=$ac_c_preproc_warn_flag
26574
 
    ac_cpp_err=$ac_cpp_err$ac_c_werror_flag
26575
 
  else
26576
 
    ac_cpp_err=
26577
 
  fi
26578
 
else
26579
 
  ac_cpp_err=yes
26580
 
fi
26581
 
if test -z "$ac_cpp_err"; then
 
25063
  (exit $ac_status); } >/dev/null && {
 
25064
         test -z "$ac_c_preproc_warn_flag$ac_c_werror_flag" ||
 
25065
         test ! -s conftest.err
 
25066
       }; then
26582
25067
  ac_header_preproc=yes
26583
25068
else
26584
25069
  echo "$as_me: failed program was:" >&5
26676
25161
  rm -f conftest.er1
26677
25162
  cat conftest.err >&5
26678
25163
  echo "$as_me:$LINENO: \$? = $ac_status" >&5
26679
 
  (exit $ac_status); } &&
26680
 
         { ac_try='test -z "$ac_c_werror_flag" || test ! -s conftest.err'
26681
 
  { (case "(($ac_try" in
26682
 
  *\"* | *\`* | *\\*) ac_try_echo=\$ac_try;;
26683
 
  *) ac_try_echo=$ac_try;;
26684
 
esac
26685
 
eval "echo \"\$as_me:$LINENO: $ac_try_echo\"") >&5
26686
 
  (eval "$ac_try") 2>&5
26687
 
  ac_status=$?
26688
 
  echo "$as_me:$LINENO: \$? = $ac_status" >&5
26689
 
  (exit $ac_status); }; } &&
26690
 
         { ac_try='test -s conftest$ac_exeext'
26691
 
  { (case "(($ac_try" in
26692
 
  *\"* | *\`* | *\\*) ac_try_echo=\$ac_try;;
26693
 
  *) ac_try_echo=$ac_try;;
26694
 
esac
26695
 
eval "echo \"\$as_me:$LINENO: $ac_try_echo\"") >&5
26696
 
  (eval "$ac_try") 2>&5
26697
 
  ac_status=$?
26698
 
  echo "$as_me:$LINENO: \$? = $ac_status" >&5
26699
 
  (exit $ac_status); }; }; then
 
25164
  (exit $ac_status); } && {
 
25165
         test -z "$ac_c_werror_flag" ||
 
25166
         test ! -s conftest.err
 
25167
       } && test -s conftest$ac_exeext &&
 
25168
       $as_test_x conftest$ac_exeext; then
26700
25169
  ac_cv_lib_tiff_TIFFOpen=yes
26701
25170
else
26702
25171
  echo "$as_me: failed program was:" >&5
26705
25174
        ac_cv_lib_tiff_TIFFOpen=no
26706
25175
fi
26707
25176
 
26708
 
rm -f core conftest.err conftest.$ac_objext \
 
25177
rm -f core conftest.err conftest.$ac_objext conftest_ipa8_conftest.oo \
26709
25178
      conftest$ac_exeext conftest.$ac_ext
26710
25179
LIBS=$ac_check_lib_save_LIBS
26711
25180
fi
26759
25228
  rm -f conftest.er1
26760
25229
  cat conftest.err >&5
26761
25230
  echo "$as_me:$LINENO: \$? = $ac_status" >&5
26762
 
  (exit $ac_status); } &&
26763
 
         { ac_try='test -z "$ac_c_werror_flag" || test ! -s conftest.err'
26764
 
  { (case "(($ac_try" in
26765
 
  *\"* | *\`* | *\\*) ac_try_echo=\$ac_try;;
26766
 
  *) ac_try_echo=$ac_try;;
26767
 
esac
26768
 
eval "echo \"\$as_me:$LINENO: $ac_try_echo\"") >&5
26769
 
  (eval "$ac_try") 2>&5
26770
 
  ac_status=$?
26771
 
  echo "$as_me:$LINENO: \$? = $ac_status" >&5
26772
 
  (exit $ac_status); }; } &&
26773
 
         { ac_try='test -s conftest$ac_exeext'
26774
 
  { (case "(($ac_try" in
26775
 
  *\"* | *\`* | *\\*) ac_try_echo=\$ac_try;;
26776
 
  *) ac_try_echo=$ac_try;;
26777
 
esac
26778
 
eval "echo \"\$as_me:$LINENO: $ac_try_echo\"") >&5
26779
 
  (eval "$ac_try") 2>&5
26780
 
  ac_status=$?
26781
 
  echo "$as_me:$LINENO: \$? = $ac_status" >&5
26782
 
  (exit $ac_status); }; }; then
 
25231
  (exit $ac_status); } && {
 
25232
         test -z "$ac_c_werror_flag" ||
 
25233
         test ! -s conftest.err
 
25234
       } && test -s conftest$ac_exeext &&
 
25235
       $as_test_x conftest$ac_exeext; then
26783
25236
  ac_cv_lib_tiff_TIFFClientOpen=yes
26784
25237
else
26785
25238
  echo "$as_me: failed program was:" >&5
26788
25241
        ac_cv_lib_tiff_TIFFClientOpen=no
26789
25242
fi
26790
25243
 
26791
 
rm -f core conftest.err conftest.$ac_objext \
 
25244
rm -f core conftest.err conftest.$ac_objext conftest_ipa8_conftest.oo \
26792
25245
      conftest$ac_exeext conftest.$ac_ext
26793
25246
LIBS=$ac_check_lib_save_LIBS
26794
25247
fi
26842
25295
  rm -f conftest.er1
26843
25296
  cat conftest.err >&5
26844
25297
  echo "$as_me:$LINENO: \$? = $ac_status" >&5
26845
 
  (exit $ac_status); } &&
26846
 
         { ac_try='test -z "$ac_c_werror_flag" || test ! -s conftest.err'
26847
 
  { (case "(($ac_try" in
26848
 
  *\"* | *\`* | *\\*) ac_try_echo=\$ac_try;;
26849
 
  *) ac_try_echo=$ac_try;;
26850
 
esac
26851
 
eval "echo \"\$as_me:$LINENO: $ac_try_echo\"") >&5
26852
 
  (eval "$ac_try") 2>&5
26853
 
  ac_status=$?
26854
 
  echo "$as_me:$LINENO: \$? = $ac_status" >&5
26855
 
  (exit $ac_status); }; } &&
26856
 
         { ac_try='test -s conftest$ac_exeext'
26857
 
  { (case "(($ac_try" in
26858
 
  *\"* | *\`* | *\\*) ac_try_echo=\$ac_try;;
26859
 
  *) ac_try_echo=$ac_try;;
26860
 
esac
26861
 
eval "echo \"\$as_me:$LINENO: $ac_try_echo\"") >&5
26862
 
  (eval "$ac_try") 2>&5
26863
 
  ac_status=$?
26864
 
  echo "$as_me:$LINENO: \$? = $ac_status" >&5
26865
 
  (exit $ac_status); }; }; then
 
25298
  (exit $ac_status); } && {
 
25299
         test -z "$ac_c_werror_flag" ||
 
25300
         test ! -s conftest.err
 
25301
       } && test -s conftest$ac_exeext &&
 
25302
       $as_test_x conftest$ac_exeext; then
26866
25303
  ac_cv_lib_tiff_TIFFIsByteSwapped=yes
26867
25304
else
26868
25305
  echo "$as_me: failed program was:" >&5
26871
25308
        ac_cv_lib_tiff_TIFFIsByteSwapped=no
26872
25309
fi
26873
25310
 
26874
 
rm -f core conftest.err conftest.$ac_objext \
 
25311
rm -f core conftest.err conftest.$ac_objext conftest_ipa8_conftest.oo \
26875
25312
      conftest$ac_exeext conftest.$ac_ext
26876
25313
LIBS=$ac_check_lib_save_LIBS
26877
25314
fi
26942
25379
  rm -f conftest.er1
26943
25380
  cat conftest.err >&5
26944
25381
  echo "$as_me:$LINENO: \$? = $ac_status" >&5
26945
 
  (exit $ac_status); } &&
26946
 
         { ac_try='test -z "$ac_c_werror_flag" || test ! -s conftest.err'
26947
 
  { (case "(($ac_try" in
26948
 
  *\"* | *\`* | *\\*) ac_try_echo=\$ac_try;;
26949
 
  *) ac_try_echo=$ac_try;;
26950
 
esac
26951
 
eval "echo \"\$as_me:$LINENO: $ac_try_echo\"") >&5
26952
 
  (eval "$ac_try") 2>&5
26953
 
  ac_status=$?
26954
 
  echo "$as_me:$LINENO: \$? = $ac_status" >&5
26955
 
  (exit $ac_status); }; } &&
26956
 
         { ac_try='test -s conftest.$ac_objext'
26957
 
  { (case "(($ac_try" in
26958
 
  *\"* | *\`* | *\\*) ac_try_echo=\$ac_try;;
26959
 
  *) ac_try_echo=$ac_try;;
26960
 
esac
26961
 
eval "echo \"\$as_me:$LINENO: $ac_try_echo\"") >&5
26962
 
  (eval "$ac_try") 2>&5
26963
 
  ac_status=$?
26964
 
  echo "$as_me:$LINENO: \$? = $ac_status" >&5
26965
 
  (exit $ac_status); }; }; then
 
25382
  (exit $ac_status); } && {
 
25383
         test -z "$ac_c_werror_flag" ||
 
25384
         test ! -s conftest.err
 
25385
       } && test -s conftest.$ac_objext; then
26966
25386
  ac_header_compiler=yes
26967
25387
else
26968
25388
  echo "$as_me: failed program was:" >&5
26998
25418
  rm -f conftest.er1
26999
25419
  cat conftest.err >&5
27000
25420
  echo "$as_me:$LINENO: \$? = $ac_status" >&5
27001
 
  (exit $ac_status); } >/dev/null; then
27002
 
  if test -s conftest.err; then
27003
 
    ac_cpp_err=$ac_c_preproc_warn_flag
27004
 
    ac_cpp_err=$ac_cpp_err$ac_c_werror_flag
27005
 
  else
27006
 
    ac_cpp_err=
27007
 
  fi
27008
 
else
27009
 
  ac_cpp_err=yes
27010
 
fi
27011
 
if test -z "$ac_cpp_err"; then
 
25421
  (exit $ac_status); } >/dev/null && {
 
25422
         test -z "$ac_c_preproc_warn_flag$ac_c_werror_flag" ||
 
25423
         test ! -s conftest.err
 
25424
       }; then
27012
25425
  ac_header_preproc=yes
27013
25426
else
27014
25427
  echo "$as_me: failed program was:" >&5
27330
25743
## M4sh Initialization.  ##
27331
25744
## --------------------- ##
27332
25745
 
27333
 
# Be Bourne compatible
 
25746
# Be more Bourne compatible
 
25747
DUALCASE=1; export DUALCASE # for MKS sh
27334
25748
if test -n "${ZSH_VERSION+set}" && (emulate sh) >/dev/null 2>&1; then
27335
25749
  emulate sh
27336
25750
  NULLCMD=:
27339
25753
  alias -g '${1+"$@"}'='"$@"'
27340
25754
  setopt NO_GLOB_SUBST
27341
25755
else
27342
 
  case `(set -o) 2>/dev/null` in *posix*) set -o posix;; esac
 
25756
  case `(set -o) 2>/dev/null` in
 
25757
  *posix*) set -o posix ;;
 
25758
esac
 
25759
 
27343
25760
fi
27344
 
BIN_SH=xpg4; export BIN_SH # for Tru64
27345
 
DUALCASE=1; export DUALCASE # for MKS sh
 
25761
 
 
25762
 
27346
25763
 
27347
25764
 
27348
25765
# PATH needs CR
27566
25983
  as_mkdir_p=false
27567
25984
fi
27568
25985
 
27569
 
# Find out whether ``test -x'' works.  Don't use a zero-byte file, as
27570
 
# systems may use methods other than mode bits to determine executability.
27571
 
cat >conf$$.file <<_ASEOF
27572
 
#! /bin/sh
27573
 
exit 0
27574
 
_ASEOF
27575
 
chmod +x conf$$.file
27576
 
if test -x conf$$.file >/dev/null 2>&1; then
27577
 
  as_executable_p="test -x"
 
25986
if test -x / >/dev/null 2>&1; then
 
25987
  as_test_x='test -x'
27578
25988
else
27579
 
  as_executable_p=:
 
25989
  if ls -dL / >/dev/null 2>&1; then
 
25990
    as_ls_L_option=L
 
25991
  else
 
25992
    as_ls_L_option=
 
25993
  fi
 
25994
  as_test_x='
 
25995
    eval sh -c '\''
 
25996
      if test -d "$1"; then
 
25997
        test -d "$1/.";
 
25998
      else
 
25999
        case $1 in
 
26000
        -*)set "./$1";;
 
26001
        esac;
 
26002
        case `ls -ld'$as_ls_L_option' "$1" 2>/dev/null` in
 
26003
        ???[sx]*):;;*)false;;esac;fi
 
26004
    '\'' sh
 
26005
  '
27580
26006
fi
27581
 
rm -f conf$$.file
 
26007
as_executable_p=$as_test_x
27582
26008
 
27583
26009
# Sed expression to map a string onto a valid CPP name.
27584
26010
as_tr_cpp="eval sed 'y%*$as_cr_letters%P$as_cr_LETTERS%;s%[^_$as_cr_alnum]%_%g'"
27593
26019
# report actual input values of CONFIG_FILES etc. instead of their
27594
26020
# values after options handling.
27595
26021
ac_log="
27596
 
This file was extended by lcms $as_me 1.16, which was
27597
 
generated by GNU Autoconf 2.60.  Invocation command line was
 
26022
This file was extended by lcms $as_me 1.17, which was
 
26023
generated by GNU Autoconf 2.61.  Invocation command line was
27598
26024
 
27599
26025
  CONFIG_FILES    = $CONFIG_FILES
27600
26026
  CONFIG_HEADERS  = $CONFIG_HEADERS
27622
26048
Usage: $0 [OPTIONS] [FILE]...
27623
26049
 
27624
26050
  -h, --help       print this help, then exit
27625
 
  -V, --version    print version number, then exit
 
26051
  -V, --version    print version number and configuration settings, then exit
27626
26052
  -q, --quiet      do not print progress messages
27627
26053
  -d, --debug      don't remove temporary files
27628
26054
      --recheck    update $as_me by reconfiguring in the same conditions
27640
26066
_ACEOF
27641
26067
cat >>$CONFIG_STATUS <<_ACEOF
27642
26068
ac_cs_version="\\
27643
 
lcms config.status 1.16
27644
 
configured by $0, generated by GNU Autoconf 2.60,
 
26069
lcms config.status 1.17
 
26070
configured by $0, generated by GNU Autoconf 2.61,
27645
26071
  with options \\"`echo "$ac_configure_args" | sed 's/^ //; s/[\\""\`\$]/\\\\&/g'`\\"
27646
26072
 
27647
26073
Copyright (C) 2006 Free Software Foundation, Inc.