configure

   1 #! /bin/sh
   2 # From configure.in Revision: 1.729 .
   3 # Guess values for system-dependent variables and create Makefiles.
   4 # Generated by Autoconf 2.52.20210105.
   5 #
   6 # Copyright 2003-2020,2021      Thomas E. Dickey
   7 # Copyright 1992, 1993, 1994, 1995, 1996, 1998, 1999, 2000, 2001
   8 # Free Software Foundation, Inc.
   9 # This configure script is free software; the Free Software Foundation
  10 # gives unlimited permission to copy, distribute and modify it.
  11
  12 # Avoid depending upon Character Ranges.
  13 as_cr_letters='abcdefghijklmnopqrstuvwxyz'
  14 as_cr_LETTERS='ABCDEFGHIJKLMNOPQRSTUVWXYZ'
  15 as_cr_Letters=$as_cr_letters$as_cr_LETTERS
  16 as_cr_digits='0123456789'
  17 as_cr_alnum=$as_cr_Letters$as_cr_digits
  18
  19 # Sed expression to map a string onto a valid variable name.
  20 as_tr_sh="sed y%*+%pp%;s%[^_$as_cr_alnum]%_%g"
  21
  22 # Sed expression to map a string onto a valid CPP name.
  23 as_tr_cpp="sed y%*$as_cr_letters%P$as_cr_LETTERS%;s%[^_$as_cr_alnum]%_%g"
  24
  25 # Be Bourne compatible
  26 if test -n "${ZSH_VERSION+set}" && (emulate sh) >/dev/null 2>&1; then
  27   emulate sh
  28   NULLCMD=:
  29 elif test -n "${BASH_VERSION+set}" && (set -o posix) >/dev/null 2>&1; then
  30   set -o posix
  31 fi
  32
  33 # Name of the executable.
  34 as_me=`echo "$0" |sed 's,.*[\\/],,'`
  35
  36 if expr a : '\(a\)' >/dev/null 2>&1; then
  37   as_expr=expr
  38 else
  39   as_expr=false
  40 fi
  41
  42 rm -f conf$$ conf$$.exe conf$$.file
  43 echo >conf$$.file
  44 if ln -s conf$$.file conf$$ 2>/dev/null; then
  45   # We could just check for DJGPP; but this test a) works b) is more generic
  46   # and c) will remain valid once DJGPP supports symlinks (DJGPP 2.04).
  47   if test -f conf$$.exe; then
  48     # Don't use ln at all; we don't have any links
  49     as_ln_s='cp -p'
  50   else
  51     as_ln_s='ln -s'
  52   fi
  53 elif ln conf$$.file conf$$ 2>/dev/null; then
  54   as_ln_s=ln
  55 else
  56   as_ln_s='cp -p'
  57 fi
  58 rm -f conf$$ conf$$.exe conf$$.file
  59
  60 as_executable_p="test -f"
  61
  62 # Support unset when possible.
  63 if (FOO=FOO; unset FOO) >/dev/null 2>&1; then
  64   as_unset="unset"
  65 else
  66   as_unset="false"
  67 fi
  68
  69 # NLS nuisances.
  70 $as_unset LANG || test "${LANG+set}" != set || { LANG=C; export LANG; }
  71 $as_unset LC_ALL || test "${LC_ALL+set}" != set || { LC_ALL=C; export LC_ALL; }
  72 $as_unset LC_TIME || test "${LC_TIME+set}" != set || { LC_TIME=C; export LC_TIME; }
  73 $as_unset LC_CTYPE || test "${LC_CTYPE+set}" != set || { LC_CTYPE=C; export LC_CTYPE; }
  74 $as_unset LANGUAGE || test "${LANGUAGE+set}" != set || { LANGUAGE=C; export LANGUAGE; }
  75 $as_unset LC_COLLATE || test "${LC_COLLATE+set}" != set || { LC_COLLATE=C; export LC_COLLATE; }
  76 $as_unset LC_NUMERIC || test "${LC_NUMERIC+set}" != set || { LC_NUMERIC=C; export LC_NUMERIC; }
  77 $as_unset LC_MESSAGES || test "${LC_MESSAGES+set}" != set || { LC_MESSAGES=C; export LC_MESSAGES; }
  78
  79 # IFS
  80 # We need space, tab and new line, in precisely that order.
  81 as_nl='
  82 '
  83 IFS="   $as_nl"
  84
  85 # CDPATH.
  86 $as_unset CDPATH || test "${CDPATH+set}" != set || { CDPATH=:; export CDPATH; }
  87
  88 # Name of the host.
  89 # hostname on some systems (SVR3.2, Linux) returns a bogus exit status,
  90 # so uname gets run too.
  91 ac_hostname=`(hostname || uname -n) 2>/dev/null | sed 1q`
  92
  93 exec 6>&1
  94
  95 #
  96 # Initializations.
  97 #
  98 ac_default_prefix=/usr/local
  99 cross_compiling=no
 100 subdirs=
 101 MFLAGS=
 102 MAKEFLAGS=
 103 SHELL=${CONFIG_SHELL-/bin/sh}
 104
 105 # Maximum number of lines to put in a shell here document.
 106 # This variable seems obsolete.  It should probably be removed, and
 107 # only ac_max_sed_lines should be used.
 108 : "${ac_max_here_lines=38}"
 109
 110 ac_unique_file="ncurses/base/lib_initscr.c"
 111 # Factoring default headers for most tests.
 112 ac_includes_default="\
 113 #include <stdio.h>
 114 #if HAVE_SYS_TYPES_H
 115 # include <sys/types.h>
 116 #endif
 117 #if HAVE_SYS_STAT_H
 118 # include <sys/stat.h>
 119 #endif
 120 #if STDC_HEADERS
 121 # include <stdlib.h>
 122 # include <stddef.h>
 123 #else
 124 # if HAVE_STDLIB_H
 125 #  include <stdlib.h>
 126 # endif
 127 #endif
 128 #if HAVE_STRING_H
 129 # if !STDC_HEADERS && HAVE_MEMORY_H
 130 #  include <memory.h>
 131 # endif
 132 # include <string.h>
 133 #endif
 134 #if HAVE_STRINGS_H
 135 # include <strings.h>
 136 #endif
 137 #if HAVE_INTTYPES_H
 138 # include <inttypes.h>
 139 #else
 140 # if HAVE_STDINT_H
 141 #  include <stdint.h>
 142 # endif
 143 #endif
 144 #if HAVE_UNISTD_H
 145 # include <unistd.h>
 146 #endif"
 147
 148 # Initialize some variables set by options.
 149 ac_init_help=
 150 ac_init_version=false
 151 # The variables have the same names as the options, with
 152 # dashes changed to underlines.
 153 cache_file=/dev/null
 154 exec_prefix=NONE
 155 no_create=
 156 no_recursion=
 157 prefix=NONE
 158 program_prefix=NONE
 159 program_suffix=NONE
 160 program_transform_name=s,x,x,
 161 silent=
 162 site=
 163 srcdir=
 164 verbose=
 165 x_includes=NONE
 166 x_libraries=NONE
 167
 168 # Installation directory options.
 169 # These are left unexpanded so users can "make install exec_prefix=/foo"
 170 # and all the variables that are supposed to be based on exec_prefix
 171 # by default will actually change.
 172 # Use braces instead of parens because sh, perl, etc. also accept them.
 173 bindir='${exec_prefix}/bin'
 174 sbindir='${exec_prefix}/sbin'
 175 libexecdir='${exec_prefix}/libexec'
 176 datarootdir='${prefix}/share'
 177 datadir='${datarootdir}'
 178 sysconfdir='${prefix}/etc'
 179 sharedstatedir='${prefix}/com'
 180 localstatedir='${prefix}/var'
 181 runstatedir='${localstatedir}/run'
 182 libdir='${exec_prefix}/lib'
 183 includedir='${prefix}/include'
 184 oldincludedir='/usr/include'
 185 infodir='${datarootdir}/info'
 186 mandir='${datarootdir}/man'
 187
 188 # Identity of this package.
 189 PACKAGE_NAME=
 190 PACKAGE_TARNAME=
 191 PACKAGE_VERSION=
 192 PACKAGE_STRING=
 193 PACKAGE_BUGREPORT=
 194
 195 ac_prev=
 196 for ac_option
 197 do
 198   # If the previous option needs an argument, assign it.
 199   if test -n "$ac_prev"; then
 200     eval "$ac_prev=\$ac_option"
 201     ac_prev=
 202     continue
 203   fi
 204
 205   ac_optarg=`expr "x$ac_option" : 'x[^=]*=\(.*\)'`
 206
 207   # Accept the important Cygnus configure options, so we can diagnose typos.
 208
 209   case "$ac_option" in
 210
 211   -bindir | --bindir | --bindi | --bind | --bin | --bi)
 212     ac_prev=bindir ;;
 213   -bindir=* | --bindir=* | --bindi=* | --bind=* | --bin=* | --bi=*)
 214     bindir=$ac_optarg ;;
 215
 216   -build | --build | --buil | --bui | --bu)
 217     ac_prev=build_alias ;;
 218   -build=* | --build=* | --buil=* | --bui=* | --bu=*)
 219     build_alias=$ac_optarg ;;
 220
 221   -cache-file | --cache-file | --cache-fil | --cache-fi \
 222   | --cache-f | --cache- | --cache | --cach | --cac | --ca | --c)
 223     ac_prev=cache_file ;;
 224   -cache-file=* | --cache-file=* | --cache-fil=* | --cache-fi=* \
 225   | --cache-f=* | --cache-=* | --cache=* | --cach=* | --cac=* | --ca=* | --c=*)
 226     cache_file=$ac_optarg ;;
 227
 228   --config-cache | -C)
 229     cache_file=config.cache ;;
 230
 231   -datadir | --datadir | --datadi | --datad | --data | --dat | --da)
 232     ac_prev=datadir ;;
 233   -datadir=* | --datadir=* | --datadi=* | --datad=* | --data=* | --dat=* \
 234   | --da=*)
 235     datadir=$ac_optarg ;;
 236
 237   -datarootdir | --datarootdir | --datarootdi | --datarootd | --dataroot \
 238   | --dataroo | --dataro | --datar)
 239     ac_prev=datarootdir ;;
 240   -datarootdir=* | --datarootdir=* | --datarootdi=* | --datarootd=* \
 241   | --dataroot=* | --dataroo=* | --dataro=* | --datar=*)
 242     datarootdir=$ac_optarg ;;
 243
 244   -disable-* | --disable-*)
 245     ac_feature=`expr "x$ac_option" : 'x-*disable-\(.*\)'`
 246     # Reject names that are not valid shell variable names.
 247     expr "x$ac_feature" : ".*[^-_$as_cr_alnum]" >/dev/null &&
 248       { echo "$as_me: error: invalid feature name: $ac_feature" >&2
 249    { (exit 1); exit 1; }; }
 250     ac_feature=`echo "$ac_feature" | sed 's/-/_/g'`
 251     eval "enable_$ac_feature=no" ;;
 252
 253   -enable-* | --enable-*)
 254     ac_feature=`expr "x$ac_option" : 'x-*enable-\([^=]*\)'`
 255     # Reject names that are not valid shell variable names.
 256     expr "x$ac_feature" : ".*[^-_$as_cr_alnum]" >/dev/null &&
 257       { echo "$as_me: error: invalid feature name: $ac_feature" >&2
 258    { (exit 1); exit 1; }; }
 259     ac_feature=`echo "$ac_feature" | sed 's/-/_/g'`
 260     case "$ac_option" in
 261       *=*) ac_optarg=`echo "$ac_optarg" | sed "s/'/'\\\\\\\\''/g"`;;
 262       *) ac_optarg=yes ;;
 263     esac
 264     eval "enable_$ac_feature='$ac_optarg'" ;;
 265
 266   -exec-prefix | --exec_prefix | --exec-prefix | --exec-prefi \
 267   | --exec-pref | --exec-pre | --exec-pr | --exec-p | --exec- \
 268   | --exec | --exe | --ex)
 269     ac_prev=exec_prefix ;;
 270   -exec-prefix=* | --exec_prefix=* | --exec-prefix=* | --exec-prefi=* \
 271   | --exec-pref=* | --exec-pre=* | --exec-pr=* | --exec-p=* | --exec-=* \
 272   | --exec=* | --exe=* | --ex=*)
 273     exec_prefix=$ac_optarg ;;
 274
 275   -gas | --gas | --ga | --g)
 276     # Obsolete; use --with-gas.
 277     with_gas=yes ;;
 278
 279   -help | --help | --hel | --he | -h)
 280     ac_init_help=long ;;
 281   -help=r* | --help=r* | --hel=r* | --he=r* | -hr*)
 282     ac_init_help=recursive ;;
 283   -help=s* | --help=s* | --hel=s* | --he=s* | -hs*)
 284     ac_init_help=short ;;
 285
 286   -host | --host | --hos | --ho)
 287     ac_prev=host_alias ;;
 288   -host=* | --host=* | --hos=* | --ho=*)
 289     host_alias=$ac_optarg ;;
 290
 291   -includedir | --includedir | --includedi | --included | --include \
 292   | --includ | --inclu | --incl | --inc)
 293     ac_prev=includedir ;;
 294   -includedir=* | --includedir=* | --includedi=* | --included=* | --include=* \
 295   | --includ=* | --inclu=* | --incl=* | --inc=*)
 296     includedir=$ac_optarg ;;
 297
 298   -infodir | --infodir | --infodi | --infod | --info | --inf)
 299     ac_prev=infodir ;;
 300   -infodir=* | --infodir=* | --infodi=* | --infod=* | --info=* | --inf=*)
 301     infodir=$ac_optarg ;;
 302
 303   -libdir | --libdir | --libdi | --libd)
 304     ac_prev=libdir ;;
 305   -libdir=* | --libdir=* | --libdi=* | --libd=*)
 306     libdir=$ac_optarg ;;
 307
 308   -libexecdir | --libexecdir | --libexecdi | --libexecd | --libexec \
 309   | --libexe | --libex | --libe)
 310     ac_prev=libexecdir ;;
 311   -libexecdir=* | --libexecdir=* | --libexecdi=* | --libexecd=* | --libexec=* \
 312   | --libexe=* | --libex=* | --libe=*)
 313     libexecdir=$ac_optarg ;;
 314
 315   -localstatedir | --localstatedir | --localstatedi | --localstated \
 316   | --localstate | --localstat | --localsta | --localst \
 317   | --locals | --local | --loca | --loc | --lo)
 318     ac_prev=localstatedir ;;
 319   -localstatedir=* | --localstatedir=* | --localstatedi=* | --localstated=* \
 320   | --localstate=* | --localstat=* | --localsta=* | --localst=* \
 321   | --locals=* | --local=* | --loca=* | --loc=* | --lo=*)
 322     localstatedir=$ac_optarg ;;
 323
 324   -runstatedir | --runstatedir | --runstatedi | --runstated \
 325   | --runstate | --runstat | --runsta | --runst \
 326   | --runs | --run | --ru)
 327     ac_prev=runstatedir ;;
 328   -runstatedir=* | --runstatedir=* | --runstatedi=* | --runstated=* \
 329   | --runstate=* | --runstat=* | --runsta=* | --runst=* \
 330   | --runs=* | --run=* | --ru=*)
 331     runstatedir=$ac_optarg ;;
 332
 333   -mandir | --mandir | --mandi | --mand | --man | --ma | --m)
 334     ac_prev=mandir ;;
 335   -mandir=* | --mandir=* | --mandi=* | --mand=* | --man=* | --ma=* | --m=*)
 336     mandir=$ac_optarg ;;
 337
 338   -nfp | --nfp | --nf)
 339     # Obsolete; use --without-fp.
 340     with_fp=no ;;
 341
 342   -no-create | --no-create | --no-creat | --no-crea | --no-cre \
 343   | --no-cr | --no-c)
 344     no_create=yes ;;
 345
 346   -no-recursion | --no-recursion | --no-recursio | --no-recursi \
 347   | --no-recurs | --no-recur | --no-recu | --no-rec | --no-re | --no-r)
 348     no_recursion=yes ;;
 349
 350   -oldincludedir | --oldincludedir | --oldincludedi | --oldincluded \
 351   | --oldinclude | --oldinclud | --oldinclu | --oldincl | --oldinc \
 352   | --oldin | --oldi | --old | --ol | --o)
 353     ac_prev=oldincludedir ;;
 354   -oldincludedir=* | --oldincludedir=* | --oldincludedi=* | --oldincluded=* \
 355   | --oldinclude=* | --oldinclud=* | --oldinclu=* | --oldincl=* | --oldinc=* \
 356   | --oldin=* | --oldi=* | --old=* | --ol=* | --o=*)
 357     oldincludedir=$ac_optarg ;;
 358
 359   -prefix | --prefix | --prefi | --pref | --pre | --pr | --p)
 360     ac_prev=prefix ;;
 361   -prefix=* | --prefix=* | --prefi=* | --pref=* | --pre=* | --pr=* | --p=*)
 362     prefix=$ac_optarg ;;
 363
 364   -program-prefix | --program-prefix | --program-prefi | --program-pref \
 365   | --program-pre | --program-pr | --program-p)
 366     ac_prev=program_prefix ;;
 367   -program-prefix=* | --program-prefix=* | --program-prefi=* \
 368   | --program-pref=* | --program-pre=* | --program-pr=* | --program-p=*)
 369     program_prefix=$ac_optarg ;;
 370
 371   -program-suffix | --program-suffix | --program-suffi | --program-suff \
 372   | --program-suf | --program-su | --program-s)
 373     ac_prev=program_suffix ;;
 374   -program-suffix=* | --program-suffix=* | --program-suffi=* \
 375   | --program-suff=* | --program-suf=* | --program-su=* | --program-s=*)
 376     program_suffix=$ac_optarg ;;
 377
 378   -program-transform-name | --program-transform-name \
 379   | --program-transform-nam | --program-transform-na \
 380   | --program-transform-n | --program-transform- \
 381   | --program-transform | --program-transfor \
 382   | --program-transfo | --program-transf \
 383   | --program-trans | --program-tran \
 384   | --progr-tra | --program-tr | --program-t)
 385     ac_prev=program_transform_name ;;
 386   -program-transform-name=* | --program-transform-name=* \
 387   | --program-transform-nam=* | --program-transform-na=* \
 388   | --program-transform-n=* | --program-transform-=* \
 389   | --program-transform=* | --program-transfor=* \
 390   | --program-transfo=* | --program-transf=* \
 391   | --program-trans=* | --program-tran=* \
 392   | --progr-tra=* | --program-tr=* | --program-t=*)
 393     program_transform_name=$ac_optarg ;;
 394
 395   -q | -quiet | --quiet | --quie | --qui | --qu | --q \
 396   | -silent | --silent | --silen | --sile | --sil)
 397     silent=yes ;;
 398
 399   -sbindir | --sbindir | --sbindi | --sbind | --sbin | --sbi | --sb)
 400     ac_prev=sbindir ;;
 401   -sbindir=* | --sbindir=* | --sbindi=* | --sbind=* | --sbin=* \
 402   | --sbi=* | --sb=*)
 403     sbindir=$ac_optarg ;;
 404
 405   -sharedstatedir | --sharedstatedir | --sharedstatedi \
 406   | --sharedstated | --sharedstate | --sharedstat | --sharedsta \
 407   | --sharedst | --shareds | --shared | --share | --shar \
 408   | --sha | --sh)
 409     ac_prev=sharedstatedir ;;
 410   -sharedstatedir=* | --sharedstatedir=* | --sharedstatedi=* \
 411   | --sharedstated=* | --sharedstate=* | --sharedstat=* | --sharedsta=* \
 412   | --sharedst=* | --shareds=* | --shared=* | --share=* | --shar=* \
 413   | --sha=* | --sh=*)
 414     sharedstatedir=$ac_optarg ;;
 415
 416   -site | --site | --sit)
 417     ac_prev=site ;;
 418   -site=* | --site=* | --sit=*)
 419     site=$ac_optarg ;;
 420
 421   -srcdir | --srcdir | --srcdi | --srcd | --src | --sr)
 422     ac_prev=srcdir ;;
 423   -srcdir=* | --srcdir=* | --srcdi=* | --srcd=* | --src=* | --sr=*)
 424     srcdir=$ac_optarg ;;
 425
 426   -sysconfdir | --sysconfdir | --sysconfdi | --sysconfd | --sysconf \
 427   | --syscon | --sysco | --sysc | --sys | --sy)
 428     ac_prev=sysconfdir ;;
 429   -sysconfdir=* | --sysconfdir=* | --sysconfdi=* | --sysconfd=* | --sysconf=* \
 430   | --syscon=* | --sysco=* | --sysc=* | --sys=* | --sy=*)
 431     sysconfdir=$ac_optarg ;;
 432
 433   -target | --target | --targe | --targ | --tar | --ta | --t)
 434     ac_prev=target_alias ;;
 435   -target=* | --target=* | --targe=* | --targ=* | --tar=* | --ta=* | --t=*)
 436     target_alias=$ac_optarg ;;
 437
 438   -v | -verbose | --verbose | --verbos | --verbo | --verb)
 439     verbose=yes ;;
 440
 441   -version | --version | --versio | --versi | --vers | -V)
 442     ac_init_version=: ;;
 443
 444   -with-* | --with-*)
 445     ac_package=`expr "x$ac_option" : 'x-*with-\([^=]*\)'`
 446     # Reject names that are not valid shell variable names.
 447     expr "x$ac_package" : ".*[^-_$as_cr_alnum]" >/dev/null &&
 448       { echo "$as_me: error: invalid package name: $ac_package" >&2
 449    { (exit 1); exit 1; }; }
 450     ac_package=`echo "$ac_package" | sed 's/-/_/g'`
 451     case "$ac_option" in
 452       *=*) ac_optarg=`echo "$ac_optarg" | sed "s/'/'\\\\\\\\''/g"`;;
 453       *) ac_optarg=yes ;;
 454     esac
 455     eval "with_$ac_package='$ac_optarg'" ;;
 456
 457   -without-* | --without-*)
 458     ac_package=`expr "x$ac_option" : 'x-*without-\(.*\)'`
 459     # Reject names that are not valid shell variable names.
 460     expr "x$ac_package" : ".*[^-_$as_cr_alnum]" >/dev/null &&
 461       { echo "$as_me: error: invalid package name: $ac_package" >&2
 462    { (exit 1); exit 1; }; }
 463     ac_package=`echo "$ac_package" | sed 's/-/_/g'`
 464     eval "with_$ac_package=no" ;;
 465
 466   --x)
 467     # Obsolete; use --with-x.
 468     with_x=yes ;;
 469
 470   -x-includes | --x-includes | --x-include | --x-includ | --x-inclu \
 471   | --x-incl | --x-inc | --x-in | --x-i)
 472     ac_prev=x_includes ;;
 473   -x-includes=* | --x-includes=* | --x-include=* | --x-includ=* | --x-inclu=* \
 474   | --x-incl=* | --x-inc=* | --x-in=* | --x-i=*)
 475     x_includes=$ac_optarg ;;
 476
 477   -x-libraries | --x-libraries | --x-librarie | --x-librari \
 478   | --x-librar | --x-libra | --x-libr | --x-lib | --x-li | --x-l)
 479     ac_prev=x_libraries ;;
 480   -x-libraries=* | --x-libraries=* | --x-librarie=* | --x-librari=* \
 481   | --x-librar=* | --x-libra=* | --x-libr=* | --x-lib=* | --x-li=* | --x-l=*)
 482     x_libraries=$ac_optarg ;;
 483
 484   -*) { echo "$as_me: error: unrecognized option: $ac_option
 485 Try \`$0 --help' for more information." >&2
 486    { (exit 1); exit 1; }; }
 487     ;;
 488
 489   *=*)
 490     ac_envvar=`expr "x$ac_option" : 'x\([^=]*\)='`
 491     # Reject names that are not valid shell variable names.
 492     expr "x$ac_envvar" : ".*[^_$as_cr_alnum]" >/dev/null &&
 493       { echo "$as_me: error: invalid variable name: $ac_envvar" >&2
 494    { (exit 1); exit 1; }; }
 495     ac_optarg=`echo "$ac_optarg" | sed "s/'/'\\\\\\\\''/g"`
 496     eval "$ac_envvar='$ac_optarg'"
 497     export "$ac_envvar" ;;
 498
 499   *)
 500     # FIXME: should be removed in autoconf 3.0.
 501     echo "$as_me: WARNING: you should use --build, --host, --target" >&2
 502     expr "x$ac_option" : ".*[^-._$as_cr_alnum]" >/dev/null &&
 503       echo "$as_me: WARNING: invalid host type: $ac_option" >&2
 504     : "${build_alias=$ac_option}" "${host_alias=$ac_option}" "${target_alias=$ac_option}"
 505     ;;
 506
 507   esac
 508 done
 509
 510 if test -n "$ac_prev"; then
 511   ac_option=--`echo "$ac_prev" | sed 's/_/-/g'`
 512   { echo "$as_me: error: missing argument to $ac_option" >&2
 513    { (exit 1); exit 1; }; }
 514 fi
 515
 516 # Be sure to have absolute paths.
 517 for ac_var in exec_prefix prefix
 518 do
 519   eval ac_val=$`echo "$ac_var"`
 520   case "$ac_val" in
 521     [\\/$]* | ?:[\\/]* | NONE | '' ) ;;
 522     *)  { echo "$as_me: error: expected an absolute path for --$ac_var: $ac_val" >&2
 523    { (exit 1); exit 1; }; };;
 524   esac
 525 done
 526
 527 # Be sure to have absolute paths.
 528 for ac_var in bindir sbindir libexecdir datarootdir datadir sysconfdir sharedstatedir \
 529               localstatedir libdir includedir oldincludedir infodir mandir
 530 do
 531   eval ac_val=$`echo "$ac_var"`
 532   case "$ac_val" in
 533     [\\/$]* | ?:[\\/]* ) ;;
 534     *)  { echo "$as_me: error: expected an absolute path for --$ac_var: $ac_val" >&2
 535    { (exit 1); exit 1; }; };;
 536   esac
 537 done
 538
 539 # There might be people who depend on the old broken behavior: `$host'
 540 # used to hold the argument of --host etc.
 541 build=$build_alias
 542 host=$host_alias
 543 target=$target_alias
 544
 545 # FIXME: should be removed in autoconf 3.0.
 546 if test "x$host_alias" != x; then
 547   if test "x$build_alias" = x; then
 548     cross_compiling=maybe
 549     echo "$as_me: WARNING: If you wanted to set the --build type, don't use --host.
 550     If a cross compiler is detected then cross compile mode will be used." >&2
 551   elif test "x$build_alias" != "x$host_alias"; then
 552     cross_compiling=yes
 553   fi
 554 fi
 555
 556 ac_tool_prefix=
 557 test -n "$host_alias" && ac_tool_prefix=$host_alias-
 558
 559 test "$silent" = yes && exec 6>/dev/null
 560
 561 # Find the source files, if location was not specified.
 562 if test -z "$srcdir"; then
 563   ac_srcdir_defaulted=yes
 564   # Try the directory containing this script, then its parent.
 565   ac_prog=$0
 566   ac_confdir=`echo "$ac_prog" | sed 's%[\\/][^\\/][^\\/]*$%%'`
 567   test "x$ac_confdir" = "x$ac_prog" && ac_confdir=.
 568   srcdir=$ac_confdir
 569   if test ! -r "$srcdir/$ac_unique_file"; then
 570     srcdir=..
 571   fi
 572 else
 573   ac_srcdir_defaulted=no
 574 fi
 575 if test ! -r "$srcdir/$ac_unique_file"; then
 576   if test "$ac_srcdir_defaulted" = yes; then
 577     { echo "$as_me: error: cannot find sources in $ac_confdir or .." >&2
 578    { (exit 1); exit 1; }; }
 579   else
 580     { echo "$as_me: error: cannot find sources in $srcdir" >&2
 581    { (exit 1); exit 1; }; }
 582   fi
 583 fi
 584 srcdir=`echo "$srcdir" | sed 's%\([^\\/]\)[\\/]*$%\1%'`
 585 ac_env_build_alias_set=${build_alias+set}
 586 ac_env_build_alias_value=$build_alias
 587 ac_cv_env_build_alias_set=${build_alias+set}
 588 ac_cv_env_build_alias_value=$build_alias
 589 ac_env_host_alias_set=${host_alias+set}
 590 ac_env_host_alias_value=$host_alias
 591 ac_cv_env_host_alias_set=${host_alias+set}
 592 ac_cv_env_host_alias_value=$host_alias
 593 ac_env_target_alias_set=${target_alias+set}
 594 ac_env_target_alias_value=$target_alias
 595 ac_cv_env_target_alias_set=${target_alias+set}
 596 ac_cv_env_target_alias_value=$target_alias
 597 ac_env_CC_set=${CC+set}
 598 ac_env_CC_value=$CC
 599 ac_cv_env_CC_set=${CC+set}
 600 ac_cv_env_CC_value=$CC
 601 ac_env_CFLAGS_set=${CFLAGS+set}
 602 ac_env_CFLAGS_value=$CFLAGS
 603 ac_cv_env_CFLAGS_set=${CFLAGS+set}
 604 ac_cv_env_CFLAGS_value=$CFLAGS
 605 ac_env_LDFLAGS_set=${LDFLAGS+set}
 606 ac_env_LDFLAGS_value=$LDFLAGS
 607 ac_cv_env_LDFLAGS_set=${LDFLAGS+set}
 608 ac_cv_env_LDFLAGS_value=$LDFLAGS
 609 ac_env_CPPFLAGS_set=${CPPFLAGS+set}
 610 ac_env_CPPFLAGS_value=$CPPFLAGS
 611 ac_cv_env_CPPFLAGS_set=${CPPFLAGS+set}
 612 ac_cv_env_CPPFLAGS_value=$CPPFLAGS
 613 ac_env_CPP_set=${CPP+set}
 614 ac_env_CPP_value=$CPP
 615 ac_cv_env_CPP_set=${CPP+set}
 616 ac_cv_env_CPP_value=$CPP
 617 ac_env_CXX_set=${CXX+set}
 618 ac_env_CXX_value=$CXX
 619 ac_cv_env_CXX_set=${CXX+set}
 620 ac_cv_env_CXX_value=$CXX
 621 ac_env_CXXFLAGS_set=${CXXFLAGS+set}
 622 ac_env_CXXFLAGS_value=$CXXFLAGS
 623 ac_cv_env_CXXFLAGS_set=${CXXFLAGS+set}
 624 ac_cv_env_CXXFLAGS_value=$CXXFLAGS
 625 ac_env_CXXCPP_set=${CXXCPP+set}
 626 ac_env_CXXCPP_value=$CXXCPP
 627 ac_cv_env_CXXCPP_set=${CXXCPP+set}
 628 ac_cv_env_CXXCPP_value=$CXXCPP
 629
 630 #
 631 # Report the --help message.
 632 #
 633 if test "$ac_init_help" = "long"; then
 634   # Omit some internal or obsolete options to make the list less imposing.
 635   # This message is too long to be a string in the A/UX 3.1 sh.
 636   cat <<EOF
 637 \`configure' configures this package to adapt to many kinds of systems.
 638
 639 Usage: $0 [OPTION]... [VAR=VALUE]...
 640
 641 To assign environment variables (e.g., CC, CFLAGS...), specify them as
 642 VAR=VALUE.  See below for descriptions of some of the useful variables.
 643
 644 Defaults for the options are specified in brackets.
 645
 646 Configuration:
 647   -h, --help              display this help and exit
 648       --help=short        display options specific to this package
 649       --help=recursive    display the short help of all the included packages
 650   -V, --version           display version information and exit
 651   -q, --quiet, --silent   do not print \`checking...' messages
 652       --cache-file=FILE   cache test results in FILE [disabled]
 653   -C, --config-cache      alias for \`--cache-file=config.cache'
 654   -n, --no-create         do not create output files
 655       --srcdir=DIR        find the sources in DIR [configure dir or \`..']
 656
 657 EOF
 658
 659   cat <<EOF
 660 Installation directories:
 661   --prefix=PREFIX         install architecture-independent files in PREFIX
 662                           [$ac_default_prefix]
 663   --exec-prefix=EPREFIX   install architecture-dependent files in EPREFIX
 664                           [PREFIX]
 665
 666 By default, \`make install' will install all the files in
 667 \`$ac_default_prefix/bin', \`$ac_default_prefix/lib' etc.  You can specify
 668 an installation prefix other than \`$ac_default_prefix' using \`--prefix',
 669 for instance \`--prefix=\$HOME'.
 670
 671 For better control, use the options below.
 672
 673 Fine tuning of the installation directories:
 674   --bindir=DIR            user executables [EPREFIX/bin]
 675   --sbindir=DIR           system admin executables [EPREFIX/sbin]
 676   --libexecdir=DIR        program executables [EPREFIX/libexec]
 677   --datarootdir=DIR       read-only architecture-independent data [PREFIX/share]
 678   --datadir=DIR           read-only architecture-independent data [DATAROOTDIR]
 679   --sysconfdir=DIR        read-only single-machine data [PREFIX/etc]
 680   --sharedstatedir=DIR    modifiable architecture-independent data [PREFIX/com]
 681   --localstatedir=DIR     modifiable single-machine data [PREFIX/var]
 682   --runstatedir=DIR       extra definition of runtime data [LOCALSTATEDIR/run]
 683   --libdir=DIR            object code libraries [EPREFIX/lib]
 684   --includedir=DIR        C header files [PREFIX/include]
 685   --oldincludedir=DIR     C header files for non-gcc [/usr/include]
 686   --infodir=DIR           info documentation [DATAROOTDIR/info]
 687   --mandir=DIR            man documentation [DATAROOTDIR/man]
 688 EOF
 689
 690   cat <<\EOF
 691
 692 Program names:
 693   --program-prefix=PREFIX            prepend PREFIX to installed program names
 694   --program-suffix=SUFFIX            append SUFFIX to installed program names
 695   --program-transform-name=PROGRAM   run sed PROGRAM on installed program names
 696
 697 System types:
 698   --build=BUILD           configure for building on BUILD [guessed]
 699   --host=HOST       build programs to run on HOST [BUILD]
 700   --target=TARGET   configure for building compilers for TARGET [HOST]
 701 EOF
 702 fi
 703
 704 if test -n "$ac_init_help"; then
 705
 706   cat <<\EOF
 707
 708 Optional Packages:
 709   --with-PACKAGE[=ARG]    use PACKAGE [ARG=yes]
 710   --without-PACKAGE       do not use PACKAGE (same as --with-PACKAGE=no)
 711
 712 Optional Features:
 713   --disable-FEATURE       do not include FEATURE (same as --enable-FEATURE=no)
 714   --enable-FEATURE[=ARG]  include FEATURE [ARG=yes]
 715
 716   --with-rel-version=XXX  override derived release version
 717   --with-abi-version=XXX  override derived ABI version
 718   --with-system-type=XXX  test: override derived host system-type
 719   --without-ada           suppress check for Ada compiler, don't build demo
 720   --without-cxx           do not adjust ncurses bool to match C++
 721   --without-cxx-binding   do not build C++ binding and demo
 722   --disable-db-install    suppress install of terminal database
 723   --without-manpages      suppress install of manpages
 724   --without-progs         suppress build/install with programs (e.g., tic)
 725   --without-tack          suppress build/install with tack program
 726   --without-tests         suppress build/install with test-programs
 727   --without-curses-h      install curses.h as ncurses.h only
 728   --with-config-suffix=X  suffixes ncursesXX-config file
 729   --with-pkg-config{=path} enable/disable use of pkg-config
 730   --with-pkg-config-libdir=XXX use given directory for installing pc-files
 731   --enable-pc-files       generate and install .pc files for pkg-config
 732   --with-pc-suffix        suffixes pc-files
 733   --enable-mixed-case     tic should assume mixed-case filenames
 734   --with-install-prefix   prefixes actual install-location ($DESTDIR)
 735 Build-Tools Needed to Compile Temporary Applications for Cross-compiling:
 736   --with-build-cc=XXX     the build C compiler ($BUILD_CC)
 737   --with-build-cpp=XXX    the build C preprocessor ($BUILD_CPP)
 738   --with-build-cflags=XXX the build C compiler-flags ($BUILD_CFLAGS)
 739   --with-build-cppflags=XXX the build C preprocessor-flags ($BUILD_CPPFLAGS)
 740   --with-build-ldflags=XXX the build linker-flags ($BUILD_LDFLAGS)
 741   --with-build-libs=XXX   the build libraries (${BUILD_LIBS})
 742 Options to Specify the Libraries Built/Used:
 743   --disable-libtool-version  enable to use libtool's incompatible naming scheme
 744   --with-libtool          generate libraries with libtool
 745   --with-shared           generate shared-libraries
 746   --with-normal           generate normal-libraries (default)
 747   --with-debug            generate debug-libraries (default)
 748   --with-profile          generate profile-libraries
 749   --with-cxx-shared       generate C++ shared-libraries
 750   --with-lib-prefix       override library-prefix
 751   --with-termlib          generate separate terminfo library
 752   --with-ticlib           generate separate tic library
 753   --enable-rpath          use rpath option when generating shared libraries
 754   --disable-relink        relink shared libraries during install
 755   --with-shlib-version=X  Specify rel or abi version for shared libs
 756   --with-libtool-opts=XXX specify additional libtool options
 757   --with-export-syms=XXX  limit exported symbols using libtool
 758   --with-versioned-syms=X markup versioned symbols using ld
 759   --with-gpm              use Alessandro Rubini's GPM library
 760   --without-dlsym         do not use dlsym() to load GPM dynamically
 761   --with-pcre2            use PCRE2 for regular-expressions
 762   --with-sysmouse         use sysmouse (FreeBSD console)
 763   --disable-lib-suffixes  disable library suffixes
 764   --disable-rpath-hack    don't add rpath options for additional libraries
 765   --disable-pkg-ldflags   disable extra LDFLAGS for package-scripts
 766 Fine-Tuning Your Configuration:
 767   --with-extra-suffix=X   append extra suffix to header/library paths
 768   --disable-overwrite     put headers in subdir, omit link to -lcurses
 769   --disable-database      do not use terminfo, only fallbacks/termcap
 770   --with-database=XXX     specify terminfo source to install
 771   --with-hashed-db        specify hashed-database library
 772   --with-fallbacks=XXX    specify list of fallback terminal descriptions
 773   --with-tic-path=XXX     specify path of tic for fallbacks
 774   --with-infocmp-path=XXX     specify path of infocmp for fallbacks
 775   --without-xterm-new     specify if xterm terminfo should be old version
 776   --with-xterm-kbs=XXX    specify if xterm backspace sends BS or DEL
 777   --with-terminfo-dirs=XXX specify list of terminfo directories (default: DATADIR/terminfo)
 778   --with-default-terminfo-dir=DIR default terminfo directory (default: DATADIR/terminfo)
 779   --disable-big-core      assume machine has little memory
 780   --disable-big-strings   assume compiler has only standard-size strings
 781   --enable-termcap        compile in termcap fallback support
 782   --with-termpath=XXX     specify list of termcap files (default: /etc/termcap:/usr/share/misc/termcap)
 783   --enable-getcap         fast termcap load, no xrefs to terminfo
 784   --enable-getcap-cache   cache translated termcaps in ~/.terminfo
 785   --disable-home-terminfo drop ~/.terminfo from terminfo search-path
 786   --disable-root-environ  restrict environment when running as root
 787   --enable-symlinks       make tic use symbolic links not hard links
 788   --enable-broken_linker  compile with broken-linker support code
 789   --enable-bsdpad         recognize BSD-style prefix padding
 790   --enable-widec          compile with wide-char/UTF-8 code
 791   --disable-lp64          allow chtype to be long (ignore _LP64)
 792   --disable-largefile     omit support for large files
 793   --disable-tparm-varargs compile tparm() without varargs interface
 794   --disable-tic-depends   link tic library without explicit dependency on ncurses library
 795   --disable-wattr-macros  suppress wattr* macros to help with ncurses5/ncurses6 transition
 796   --with-x11-rgb=FILE   file containing X11 rgb information (EPREFIX/lib/X11/rgb.txt)
 797   --with-bool=TYPE        override fallback type of bool variable
 798   --with-caps=alt         compile with alternate Caps file
 799   --with-chtype=TYPE      override type of chtype
 800   --with-ospeed=TYPE      override type of ospeed variable
 801   --with-mmask-t=TYPE     override type of mmask_t
 802   --with-ccharw-max=XXX   override size CCHARW_MAX
 803   --enable-signed-char    compile using signed Boolean's in term.h
 804   --with-tparm-arg=TYPE   override parameter type of tparm
 805   --with-rcs-ids          compile-in RCS identifiers
 806 Options to Specify How Manpages are Installed:
 807   --with-manpage-format   specify manpage-format: gzip/compress/BSDI/normal and
 808                           optionally formatted/catonly, e.g., gzip,formatted
 809   --with-manpage-renames  specify manpage-renaming
 810   --with-manpage-aliases  specify manpage-aliases using .so
 811   --with-manpage-symlinks specify manpage-aliases using symlinks
 812   --with-manpage-tbl      specify manpage processing with tbl
 813 Extensions:
 814   --disable-ext-funcs     disable function-extensions
 815   --enable-sp-funcs       enable SCREEN-extensions
 816   --enable-term-driver    enable terminal-driver
 817   --enable-const          compile with extra/non-standard const
 818   --enable-ext-colors     compile for 256-color support
 819   --enable-ext-mouse      compile for extended mouse-encoding
 820   --enable-ext-putwin     compile with extended putwin/screendump
 821   --enable-no-padding     compile with $NCURSES_NO_PADDING code
 822   --enable-sigwinch       compile with SIGWINCH handler
 823   --enable-tcap-names     compile with user-definable terminal capabilities
 824 Reentrant Code:
 825   --with-pthread          use POSIX thread library
 826   --enable-pthreads-eintr enable EINTR in wgetch with pthreads
 827   --enable-weak-symbols   enable weak-symbols for pthreads
 828   --enable-reentrant      compile with reentrant code
 829   --enable-opaque-curses  make curses WINDOW, etc., "opaque"
 830   --enable-opaque-form    make form-library structures "opaque"
 831   --enable-opaque-menu    make menu-library structures "opaque"
 832   --enable-opaque-panel   make panel-library structures "opaque"
 833   --with-wrap-prefix=XXX  override prefix used for public variables
 834 Development Code:
 835   --without-develop       disable development options
 836   --enable-hard-tabs      compile with hard-tabs code
 837   --enable-xmc-glitch     compile with support for xmc (magic-cookie)
 838 Experimental Code:
 839   --disable-assumed-color do not assume anything about default-colors
 840   --disable-hashmap       compile without hashmap scrolling-optimization
 841   --enable-colorfgbg      compile-in experimental $COLORFGBG code
 842   --enable-fvisibility    compile with -fvisibility=hidden
 843   --enable-interop        compile-in interop bindings
 844   --enable-safe-sprintf   compile with experimental safe-sprintf code
 845   --disable-scroll-hints  compile without scroll-hints code
 846   --enable-wgetch-events  compile with wgetch-events code
 847   --enable-exp-win32      compile with experimental-Windows driver
 848 Testing/development Options:
 849   --disable-echo          do not display "compiling" commands
 850   --disable-stripping     do not strip (debug info) installed executables
 851   --enable-warnings       test: turn on gcc compiler warnings
 852   --enable-string-hacks   work around bogus compiler/loader warnings
 853   --enable-assertions     test: turn on generation of assertion code
 854   --with-dmalloc          test: use Gray Watson's dmalloc library
 855   --with-dbmalloc         test: use Conor Cahill's dbmalloc library
 856   --with-valgrind         test: use valgrind
 857   --disable-leaks         test: free permanent memory, analyze leaks
 858   --enable-expanded       test: generate functions for certain macros
 859   --disable-macros        test: use functions rather than macros
 860   --with-trace            test: add trace() function to all models of ncurses
 861   --disable-gnat-projects test: disable GNAT projects even if usable
 862 Ada Binding Options:
 863   --with-ada-compiler=CMD specify Ada95 compiler command (default gnatmake)
 864   --with-ada-include=DIR  Ada includes are in DIR (default: PREFIX/share/ada/adainclude)
 865   --with-ada-objects=DIR  Ada objects are in DIR (default: PREFIX/lib/ada/adalib)
 866   --with-ada-sharedlib=soname build shared-library (requires GNAT projects)
 867   --with-ada-libname=XXX  override default Ada library-name
 868   --with-form-libname=XXX override form basename of library
 869   --with-menu-libname=XXX override menu basename of library
 870   --with-panel-libname=XXX override panel basename of library
 871   --with-cxx-libname=XXX override ncurses++ basename of library
 872
 873 Some influential environment variables:
 874   CC          C compiler command
 875   CFLAGS      C compiler flags
 876   LDFLAGS     linker flags, e.g. -L<lib dir> if you have libraries in a
 877               nonstandard directory <lib dir>
 878   CPPFLAGS    C/C++ preprocessor flags, e.g. -I<include dir> if you have
 879               headers in a nonstandard directory <include dir>
 880   CPP         C preprocessor
 881   CXX         C++ compiler command
 882   CXXFLAGS    C++ compiler flags
 883   CXXCPP      C++ preprocessor
 884
 885 Use these variables to override the choices made by `configure' or to help
 886 it to find libraries and programs with nonstandard names/locations.
 887
 888 EOF
 889 fi
 890
 891 if test "$ac_init_help" = "recursive"; then
 892   # If there are subdirs, report their specific --help.
 893   ac_popdir=`pwd`
 894   for ac_subdir in : $ac_subdirs_all; do test "x$ac_subdir" = x: && continue
 895     cd "$ac_subdir"
 896     # A "../" for each directory in /$ac_subdir.
 897     ac_dots=`echo "$ac_subdir" |
 898              sed 's,^\./,,;s,[^/]$,&/,;s,[^/]*/,../,g'`
 899
 900     case "$srcdir" in
 901     .) # No --srcdir option.  We are building in place.
 902       ac_sub_srcdir="$srcdir" ;;
 903     [\\/]* | ?:[\\/]* ) # Absolute path.
 904       ac_sub_srcdir="$srcdir/$ac_subdir" ;;
 905     *) # Relative path.
 906       ac_sub_srcdir="$ac_dots$srcdir/$ac_subdir" ;;
 907     esac
 908
 909     # Check for guested configure; otherwise get Cygnus style configure.
 910     if test -f "$ac_sub_srcdir/configure.gnu"; then
 911       echo
 912       $SHELL "$ac_sub_srcdir/configure.gnu" --help=recursive
 913     elif test -f "$ac_sub_srcdir/configure"; then
 914       echo
 915       $SHELL "$ac_sub_srcdir/configure" --help=recursive
 916     elif test -f "$ac_sub_srcdir/configure.ac" ||
 917            test -f "$ac_sub_srcdir/configure.in"; then
 918       echo
 919       "$ac_configure" --help
 920     else
 921       echo "$as_me: WARNING: no configuration information is in $ac_subdir" >&2
 922     fi
 923     cd "$ac_popdir"
 924   done
 925 fi
 926
 927 test -n "$ac_init_help" && exit 0
 928 if "$ac_init_version"; then
 929   cat <<\EOF
 930
 931 Copyright 2003-2020,2021        Thomas E. Dickey
 932 Copyright 1992, 1993, 1994, 1995, 1996, 1998, 1999, 2000, 2001
 933 Free Software Foundation, Inc.
 934 This configure script is free software; the Free Software Foundation
 935 gives unlimited permission to copy, distribute and modify it.
 936 EOF
 937   exit 0
 938 fi
 939 exec 5>config.log
 940 cat >&5 <<EOF
 941 This file contains any messages produced by compilers while
 942 running configure, to aid debugging if configure makes a mistake.
 943
 944 It was created by $as_me, which was
 945 generated by GNU Autoconf 2.52.20210105.  Invocation command line was
 946
 947   $ $0 $@
 948
 949 EOF
 950 {
 951 cat <<_ASUNAME
 952 ## ---------- ##
 953 ## Platform.  ##
 954 ## ---------- ##
 955
 956 hostname = `(hostname || uname -n) 2>/dev/null | sed 1q`
 957 uname -m = `(uname -m) 2>/dev/null || echo unknown`
 958 uname -r = `(uname -r) 2>/dev/null || echo unknown`
 959 uname -s = `(uname -s) 2>/dev/null || echo unknown`
 960 uname -v = `(uname -v) 2>/dev/null || echo unknown`
 961
 962 /usr/bin/uname -p = `(/usr/bin/uname -p) 2>/dev/null || echo unknown`
 963 /bin/uname -X     = `(/bin/uname -X) 2>/dev/null     || echo unknown`
 964
 965 /bin/arch              = `(/bin/arch) 2>/dev/null              || echo unknown`
 966 /usr/bin/arch -k       = `(/usr/bin/arch -k) 2>/dev/null       || echo unknown`
 967 /usr/convex/getsysinfo = `(/usr/convex/getsysinfo) 2>/dev/null || echo unknown`
 968 hostinfo               = `(hostinfo) 2>/dev/null               || echo unknown`
 969 /bin/machine           = `(/bin/machine) 2>/dev/null           || echo unknown`
 970 /usr/bin/oslevel       = `(/usr/bin/oslevel) 2>/dev/null       || echo unknown`
 971 /bin/universe          = `(/bin/universe) 2>/dev/null          || echo unknown`
 972
 973 PATH = $PATH
 974
 975 _ASUNAME
 976 } >&5
 977
 978 cat >&5 <<EOF
 979 ## ------------ ##
 980 ## Core tests.  ##
 981 ## ------------ ##
 982
 983 EOF
 984
 985 # Keep a trace of the command line.
 986 # Strip out --no-create and --no-recursion so they do not pile up.
 987 # Also quote any args containing shell meta-characters.
 988 ac_configure_args=
 989 ac_sep=
 990 for ac_arg
 991 do
 992   case "$ac_arg" in
 993   -no-create | --no-create | --no-creat | --no-crea | --no-cre \
 994   | --no-cr | --no-c) ;;
 995   -no-recursion | --no-recursion | --no-recursio | --no-recursi \
 996   | --no-recurs | --no-recur | --no-recu | --no-rec | --no-re | --no-r) ;;
 997   *" "*|*"      "*|*[\[\]\~\#\$\^\&\*\(\)\{\}\\\|\;\<\>\?\"\']*)
 998     ac_arg=`echo "$ac_arg" | sed "s/'/'\\\\\\\\''/g"`
 999     ac_configure_args="$ac_configure_args$ac_sep'$ac_arg'"
1000     ac_sep=" " ;;
1001   *) ac_configure_args="$ac_configure_args$ac_sep$ac_arg"
1002      ac_sep=" " ;;
1003   esac
1004   # Get rid of the leading space.
1005 done
1006
1007 # When interrupted or exit'd, cleanup temporary files, and complete
1008 # config.log.  We remove comments because anyway the quotes in there
1009 # would cause problems or look ugly.
1010 trap 'exit_status=$?
1011   # Save into config.log some information that might help in debugging.
1012   echo >&5
1013   echo "## ----------------- ##" >&5
1014   echo "## Cache variables.  ##" >&5
1015   echo "## ----------------- ##" >&5
1016   echo >&5
1017   # The following way of writing the cache mishandles newlines in values,
1018 {
1019   (set) 2>&1 |
1020     case `(ac_space='"'"' '"'"'; set | grep ac_space) 2>&1` in
1021     *ac_space=\ *)
1022       sed -n \
1023         "s/'"'"'/'"'"'\\\\'"'"''"'"'/g;
1024           s/^\\([_$as_cr_alnum]*_cv_[_$as_cr_alnum]*\\)=\\(.*\\)/\\1='"'"'\\2'"'"'/p"
1025       ;;
1026     *)
1027       sed -n \
1028         "s/^\\([_$as_cr_alnum]*_cv_[_$as_cr_alnum]*\\)=\\(.*\\)/\\1=\\2/p"
1029       ;;
1030     esac;
1031 } >&5
1032   sed "/^$/d" confdefs.h >conftest.log
1033   if test -s conftest.log; then
1034     echo >&5
1035     echo "## ------------ ##" >&5
1036     echo "## confdefs.h.  ##" >&5
1037     echo "## ------------ ##" >&5
1038     echo >&5
1039     cat conftest.log >&5
1040   fi
1041   (echo; echo) >&5
1042   test "$ac_signal" != 0 &&
1043     echo "$as_me: caught signal $ac_signal" >&5
1044   echo "$as_me: exit $exit_status" >&5
1045   rm -rf conftest* confdefs* core core.* *.core conf$$* $ac_clean_files &&
1046     exit $exit_status
1047      ' 0
1048 for ac_signal in 1 2 13 15; do
1049   trap 'ac_signal='$ac_signal'; { (exit 1); exit 1; }' "$ac_signal"
1050 done
1051 ac_signal=0
1052
1053 # confdefs.h avoids OS command line length limits that DEFS can exceed.
1054 rm -rf conftest* confdefs.h
1055 # AIX cpp loses on an empty file, so make sure it contains at least a newline.
1056 echo >confdefs.h
1057
1058 # Let the site file select an alternate cache file if it wants to.
1059 # Prefer explicitly selected file to automatically selected ones.
1060 if test -z "$CONFIG_SITE"; then
1061   if test "x$prefix" != xNONE; then
1062     CONFIG_SITE="$prefix/share/config.site $prefix/etc/config.site"
1063   else
1064     CONFIG_SITE="$ac_default_prefix/share/config.site $ac_default_prefix/etc/config.site"
1065   fi
1066 fi
1067 for ac_site_file in $CONFIG_SITE; do
1068   if test -r "$ac_site_file"; then
1069     { echo "$as_me:1069: loading site script $ac_site_file" >&5
1070 echo "$as_me: loading site script $ac_site_file" >&6;}
1071     cat "$ac_site_file" >&5
1072     . "$ac_site_file"
1073   fi
1074 done
1075
1076 if test -r "$cache_file"; then
1077   # Some versions of bash will fail to source /dev/null (special
1078   # files actually), so we avoid doing that.
1079   if test -f "$cache_file"; then
1080     { echo "$as_me:1080: loading cache $cache_file" >&5
1081 echo "$as_me: loading cache $cache_file" >&6;}
1082     case $cache_file in
1083       [\\/]* | ?:[\\/]* ) . $cache_file;;
1084       *)                      . ./$cache_file;;
1085     esac
1086   fi
1087 else
1088   { echo "$as_me:1088: creating cache $cache_file" >&5
1089 echo "$as_me: creating cache $cache_file" >&6;}
1090   >$cache_file
1091 fi
1092
1093 # Check that the precious variables saved in the cache have kept the same
1094 # value.
1095 ac_cache_corrupted=false
1096 for ac_var in `(set) 2>&1 |
1097                sed -n 's/^ac_env_\([a-zA-Z_0-9]*\)_set=.*/\1/p'`; do
1098   eval ac_old_set=\$ac_cv_env_${ac_var}_set
1099   eval ac_new_set=\$ac_env_${ac_var}_set
1100   eval ac_old_val="\$ac_cv_env_${ac_var}_value"
1101   eval ac_new_val="\$ac_env_${ac_var}_value"
1102   case "$ac_old_set,$ac_new_set" in
1103     set,)
1104       { echo "$as_me:1104: error: \`$ac_var' was set to \`$ac_old_val' in the previous run" >&5
1105 echo "$as_me: error: \`$ac_var' was set to \`$ac_old_val' in the previous run" >&2;}
1106       ac_cache_corrupted=: ;;
1107     ,set)
1108       { echo "$as_me:1108: error: \`$ac_var' was not set in the previous run" >&5
1109 echo "$as_me: error: \`$ac_var' was not set in the previous run" >&2;}
1110       ac_cache_corrupted=: ;;
1111     ,);;
1112     *)
1113       if test "x$ac_old_val" != "x$ac_new_val"; then
1114         { echo "$as_me:1114: error: \`$ac_var' has changed since the previous run:" >&5
1115 echo "$as_me: error: \`$ac_var' has changed since the previous run:" >&2;}
1116         { echo "$as_me:1116:   former value:  $ac_old_val" >&5
1117 echo "$as_me:   former value:  $ac_old_val" >&2;}
1118         { echo "$as_me:1118:   current value: $ac_new_val" >&5
1119 echo "$as_me:   current value: $ac_new_val" >&2;}
1120         ac_cache_corrupted=:
1121       fi;;
1122   esac
1123   # Pass precious variables to config.status.  It doesn't matter if
1124   # we pass some twice (in addition to the command line arguments).
1125   if test "$ac_new_set" = set; then
1126     case "$ac_new_val" in
1127     *" "*|*"    "*|*[\[\]\~\#\$\^\&\*\(\)\{\}\\\|\;\<\>\?\"\']*)
1128       ac_arg=$ac_var=`echo "$ac_new_val" | sed "s/'/'\\\\\\\\''/g"`
1129       ac_configure_args="$ac_configure_args '$ac_arg'"
1130       ;;
1131     *) ac_configure_args="$ac_configure_args $ac_var=$ac_new_val"
1132        ;;
1133     esac
1134   fi
1135 done
1136 if "$ac_cache_corrupted"; then
1137   { echo "$as_me:1137: error: changes in the environment can compromise the build" >&5
1138 echo "$as_me: error: changes in the environment can compromise the build" >&2;}
1139   { { echo "$as_me:1139: error: run \`make distclean' and/or \`rm $cache_file' and start over" >&5
1140 echo "$as_me: error: run \`make distclean' and/or \`rm $cache_file' and start over" >&2;}
1141    { (exit 1); exit 1; }; }
1142 fi
1143
1144 ac_ext=c
1145 ac_cpp='$CPP $CPPFLAGS'
1146 ac_compile='$CC -c $CFLAGS $CPPFLAGS "conftest.$ac_ext" >&5'
1147 ac_link='$CC -o "conftest$ac_exeext" $CFLAGS $CPPFLAGS $LDFLAGS "conftest.$ac_ext" $LIBS >&5'
1148 ac_compiler_gnu=$ac_cv_c_compiler_gnu
1149 ac_main_return="return"
1150
1151 case `echo "testing\c" 2>/dev/null; echo 1,2,3`,`echo -n testing 2>/dev/null; echo 1,2,3` in
1152   *c*,-n*) ECHO_N=
1153            ECHO_C=      # newlines do not sed ;-) only broken shells would use this case anyway
1154            ECHO_T='     '
1155            ;;
1156   *c*,*  ) ECHO_N=-n
1157            ECHO_C=
1158            ECHO_T=
1159            ;;
1160   *)       ECHO_N=
1161            ECHO_C='\c'
1162            ECHO_T=
1163            ;;
1164 esac
1165 echo "#! $SHELL" >conftest.sh
1166 echo  "exit 0"   >>conftest.sh
1167 chmod +x conftest.sh
1168 if { (echo "$as_me:1168: PATH=\".;.\"; conftest.sh") >&5
1169   (PATH=".;."; conftest.sh) 2>&5
1170   ac_status=$?
1171   echo "$as_me:1171: \$? = $ac_status" >&5
1172   (exit "$ac_status"); }; then
1173   ac_path_separator=';'
1174 else
1175   ac_path_separator=:
1176 fi
1177 PATH_SEPARATOR="$ac_path_separator"
1178 rm -f conftest.sh
1179
1180 ac_config_headers="$ac_config_headers include/ncurses_cfg.h:include/ncurses_cfg.hin"
1181
1182 top_builddir=`pwd`
1183
1184 for ac_prog in ggrep grep
1185 do
1186   # Extract the first word of "$ac_prog", so it can be a program name with args.
1187 set dummy $ac_prog; ac_word=$2
1188 echo "$as_me:1188: checking for $ac_word" >&5
1189 echo $ECHO_N "checking for $ac_word... $ECHO_C" >&6
1190 if test "${ac_cv_prog_GREP+set}" = set; then
1191   echo $ECHO_N "(cached) $ECHO_C" >&6
1192 else
1193   if test -n "$GREP"; then
1194   ac_cv_prog_GREP="$GREP" # Let the user override the test.
1195 else
1196   ac_save_IFS=$IFS; IFS=$ac_path_separator
1197 ac_dummy="$PATH"
1198 for ac_dir in $ac_dummy; do
1199   IFS=$ac_save_IFS
1200   test -z "$ac_dir" && ac_dir=.
1201   $as_executable_p "$ac_dir/$ac_word" || continue
1202 ac_cv_prog_GREP="$ac_prog"
1203 echo "$as_me:1203: found $ac_dir/$ac_word" >&5
1204 break
1205 done
1206
1207 fi
1208 fi
1209 GREP=$ac_cv_prog_GREP
1210 if test -n "$GREP"; then
1211   echo "$as_me:1211: result: $GREP" >&5
1212 echo "${ECHO_T}$GREP" >&6
1213 else
1214   echo "$as_me:1214: result: no" >&5
1215 echo "${ECHO_T}no" >&6
1216 fi
1217
1218   test -n "$GREP" && break
1219 done
1220 test -n "$GREP" || GREP=": "
1221
1222 echo "$as_me:1222: checking for egrep" >&5
1223 echo $ECHO_N "checking for egrep... $ECHO_C" >&6
1224 if test "${ac_cv_path_EGREP+set}" = set; then
1225   echo $ECHO_N "(cached) $ECHO_C" >&6
1226 else
1227   if echo a | $GREP -E '(a|b)' >/dev/null 2>&1
1228    then ac_cv_path_EGREP="$GREP -E"
1229    else
1230      for ac_prog in gegrep egrep
1231 do
1232   # Extract the first word of "$ac_prog", so it can be a program name with args.
1233 set dummy $ac_prog; ac_word=$2
1234 echo "$as_me:1234: checking for $ac_word" >&5
1235 echo $ECHO_N "checking for $ac_word... $ECHO_C" >&6
1236 if test "${ac_cv_path_EGREP+set}" = set; then
1237   echo $ECHO_N "(cached) $ECHO_C" >&6
1238 else
1239   case $EGREP in
1240   [\\/]* | ?:[\\/]*)
1241   ac_cv_path_EGREP="$EGREP" # Let the user override the test with a path.
1242   ;;
1243   *)
1244   ac_save_IFS=$IFS; IFS=$ac_path_separator
1245 ac_dummy="$PATH"
1246 for ac_dir in $ac_dummy; do
1247   IFS=$ac_save_IFS
1248   test -z "$ac_dir" && ac_dir=.
1249   if $as_executable_p "$ac_dir/$ac_word"; then
1250    ac_cv_path_EGREP="$ac_dir/$ac_word"
1251    echo "$as_me:1251: found $ac_dir/$ac_word" >&5
1252    break
1253 fi
1254 done
1255
1256   ;;
1257 esac
1258 fi
1259 EGREP=$ac_cv_path_EGREP
1260
1261 if test -n "$EGREP"; then
1262   echo "$as_me:1262: result: $EGREP" >&5
1263 echo "${ECHO_T}$EGREP" >&6
1264 else
1265   echo "$as_me:1265: result: no" >&5
1266 echo "${ECHO_T}no" >&6
1267 fi
1268
1269   test -n "$EGREP" && break
1270 done
1271 test -n "$EGREP" || EGREP=": "
1272
1273      test "x$ac_cv_path_EGREP" = "x:" && { { echo "$as_me:1273: error: cannot find workable egrep" >&5
1274 echo "$as_me: error: cannot find workable egrep" >&2;}
1275    { (exit 1); exit 1; }; }
1276    fi
1277 fi
1278 echo "$as_me:1278: result: $ac_cv_path_EGREP" >&5
1279 echo "${ECHO_T}$ac_cv_path_EGREP" >&6
1280  EGREP="$ac_cv_path_EGREP"
1281
1282 NCURSES_MAJOR="`${EGREP-egrep} '^NCURSES_MAJOR[         ]*=' "$srcdir/dist.mk" | sed -e 's/^[^0-9]*//'`"
1283 NCURSES_MINOR="`${EGREP-egrep} '^NCURSES_MINOR[         ]*=' "$srcdir/dist.mk" | sed -e 's/^[^0-9]*//'`"
1284 NCURSES_PATCH="`${EGREP-egrep} '^NCURSES_PATCH[         ]*=' "$srcdir/dist.mk" | sed -e 's/^[^0-9]*//'`"
1285 cf_cv_abi_version=${NCURSES_MAJOR}
1286 cf_cv_rel_version=${NCURSES_MAJOR}.${NCURSES_MINOR}
1287 cf_cv_timestamp=`date`
1288 echo "$as_me:1288: result: Configuring NCURSES $cf_cv_rel_version ABI $cf_cv_abi_version ($cf_cv_timestamp)" >&5
1289 echo "${ECHO_T}Configuring NCURSES $cf_cv_rel_version ABI $cf_cv_abi_version ($cf_cv_timestamp)" >&6
1290
1291 if test -f "$srcdir/VERSION" ; then
1292         echo "$as_me:1292: checking for package version" >&5
1293 echo $ECHO_N "checking for package version... $ECHO_C" >&6
1294
1295         # if there are not enough fields, cut returns the last one...
1296         cf_field1=`sed -e '2,$d' "$srcdir/VERSION" |cut -f1`
1297         cf_field2=`sed -e '2,$d' "$srcdir/VERSION" |cut -f2`
1298         cf_field3=`sed -e '2,$d' "$srcdir/VERSION" |cut -f3`
1299
1300         # this is how CF_BUNDLED_INTL uses $VERSION:
1301         VERSION="$cf_field1"
1302
1303         VERSION_MAJOR=`echo "$cf_field2" | sed -e 's/\..*//'`
1304         test -z "$VERSION_MAJOR" && { { echo "$as_me:1304: error: missing major-version" >&5
1305 echo "$as_me: error: missing major-version" >&2;}
1306    { (exit 1); exit 1; }; }
1307
1308         VERSION_MINOR=`echo "$cf_field2" | sed -e 's/^[^.]*\.//' -e 's/-.*//'`
1309         test -z "$VERSION_MINOR" && { { echo "$as_me:1309: error: missing minor-version" >&5
1310 echo "$as_me: error: missing minor-version" >&2;}
1311    { (exit 1); exit 1; }; }
1312
1313         echo "$as_me:1313: result: ${VERSION_MAJOR}.${VERSION_MINOR}" >&5
1314 echo "${ECHO_T}${VERSION_MAJOR}.${VERSION_MINOR}" >&6
1315
1316         echo "$as_me:1316: checking for package patch date" >&5
1317 echo $ECHO_N "checking for package patch date... $ECHO_C" >&6
1318         VERSION_PATCH=`echo "$cf_field3" | sed -e 's/^[^-]*-//'`
1319         case .$VERSION_PATCH in
1320         (.)
1321                 { { echo "$as_me:1321: error: missing patch-date $VERSION_PATCH" >&5
1322 echo "$as_me: error: missing patch-date $VERSION_PATCH" >&2;}
1323    { (exit 1); exit 1; }; }
1324                 ;;
1325         (.[0-9][0-9][0-9][0-9][0-9][0-9][0-9][0-9])
1326                 ;;
1327         (*)
1328                 { { echo "$as_me:1328: error: illegal patch-date $VERSION_PATCH" >&5
1329 echo "$as_me: error: illegal patch-date $VERSION_PATCH" >&2;}
1330    { (exit 1); exit 1; }; }
1331                 ;;
1332         esac
1333         echo "$as_me:1333: result: $VERSION_PATCH" >&5
1334 echo "${ECHO_T}$VERSION_PATCH" >&6
1335 else
1336         { { echo "$as_me:1336: error: did not find $srcdir/VERSION" >&5
1337 echo "$as_me: error: did not find $srcdir/VERSION" >&2;}
1338    { (exit 1); exit 1; }; }
1339 fi
1340
1341 # show the actual data that we have for versions:
1342 test -n "$verbose" && echo "    ABI VERSION $VERSION" 1>&6
1343
1344 echo "${as_me:-configure}:1344: testing ABI VERSION $VERSION ..." 1>&5
1345
1346 test -n "$verbose" && echo "    VERSION_MAJOR $VERSION_MAJOR" 1>&6
1347
1348 echo "${as_me:-configure}:1348: testing VERSION_MAJOR $VERSION_MAJOR ..." 1>&5
1349
1350 test -n "$verbose" && echo "    VERSION_MINOR $VERSION_MINOR" 1>&6
1351
1352 echo "${as_me:-configure}:1352: testing VERSION_MINOR $VERSION_MINOR ..." 1>&5
1353
1354 test -n "$verbose" && echo "    VERSION_PATCH $VERSION_PATCH" 1>&6
1355
1356 echo "${as_me:-configure}:1356: testing VERSION_PATCH $VERSION_PATCH ..." 1>&5
1357
1358         cf_PACKAGE=NCURSES
1359         PACKAGE=ncurses
1360
1361 cat >>confdefs.h <<EOF
1362 #define PACKAGE "$PACKAGE"
1363 EOF
1364
1365 cf_PACKAGE=`echo "$cf_PACKAGE" | sed y%abcdefghijklmnopqrstuvwxyz./-%ABCDEFGHIJKLMNOPQRSTUVWXYZ___%`
1366
1367         cat >>confdefs.h <<EOF
1368 #define ${cf_PACKAGE}_VERSION "${VERSION_MAJOR}.${VERSION_MINOR}"
1369 EOF
1370
1371         cat >>confdefs.h <<EOF
1372 #define ${cf_PACKAGE}_PATCHDATE ${VERSION_PATCH}
1373 EOF
1374
1375 test -z "$cf_cv_rel_version" && cf_cv_rel_version=0.0
1376
1377 # Check whether --with-rel-version or --without-rel-version was given.
1378 if test "${with_rel_version+set}" = set; then
1379   withval="$with_rel_version"
1380   { echo "$as_me:1380: WARNING: overriding release version $cf_cv_rel_version to $withval" >&5
1381 echo "$as_me: WARNING: overriding release version $cf_cv_rel_version to $withval" >&2;}
1382  cf_cv_rel_version=$withval
1383 fi;
1384
1385  NCURSES_MAJOR=`echo "$cf_cv_rel_version" | sed -e 's/\..*//'`
1386  NCURSES_MINOR=`echo "$cf_cv_rel_version" | sed -e 's/^[^.]*//' -e 's/^\.//' -e 's/\..*//'`
1387
1388 if test -n "$NCURSES_MAJOR" ; then
1389   case $NCURSES_MAJOR in
1390   ([0-9]*)
1391         ;;
1392   (*)
1393         { { echo "$as_me:1393: error: Release major-version is not a number: $NCURSES_MAJOR" >&5
1394 echo "$as_me: error: Release major-version is not a number: $NCURSES_MAJOR" >&2;}
1395    { (exit 1); exit 1; }; }
1396         ;;
1397   esac
1398 else
1399   { { echo "$as_me:1399: error: Release major-version value is empty" >&5
1400 echo "$as_me: error: Release major-version value is empty" >&2;}
1401    { (exit 1); exit 1; }; }
1402 fi
1403
1404 if test -n "$NCURSES_MINOR" ; then
1405   case $NCURSES_MINOR in
1406   ([0-9]*)
1407         ;;
1408   (*)
1409         { { echo "$as_me:1409: error: Release minor-version is not a number: $NCURSES_MINOR" >&5
1410 echo "$as_me: error: Release minor-version is not a number: $NCURSES_MINOR" >&2;}
1411    { (exit 1); exit 1; }; }
1412         ;;
1413   esac
1414 else
1415   { { echo "$as_me:1415: error: Release minor-version value is empty" >&5
1416 echo "$as_me: error: Release minor-version value is empty" >&2;}
1417    { (exit 1); exit 1; }; }
1418 fi
1419
1420 test -z "$cf_cv_abi_version" && cf_cv_abi_version=0
1421
1422 # Check whether --with-abi-version or --without-abi-version was given.
1423 if test "${with_abi_version+set}" = set; then
1424   withval="$with_abi_version"
1425
1426         if test "x$cf_cv_abi_version" != "x$withval"
1427         then
1428                 { echo "$as_me:1428: WARNING: overriding ABI version $cf_cv_abi_version to $withval" >&5
1429 echo "$as_me: WARNING: overriding ABI version $cf_cv_abi_version to $withval" >&2;}
1430                 case "$cf_cv_rel_version" in
1431                 (5.*)
1432                         cf_cv_rel_version=$withval.0
1433                         ;;
1434                 (6.*)
1435                         cf_cv_rel_version=$withval.9    # FIXME: should be 10 as of 6.0 release
1436                         ;;
1437                 esac
1438         fi
1439         cf_cv_abi_version=$withval
1440 fi;
1441
1442 if test -n "$cf_cv_abi_version" ; then
1443   case $cf_cv_abi_version in
1444   ([0-9]*)
1445         ;;
1446   (*)
1447         { { echo "$as_me:1447: error: ABI version is not a number: $cf_cv_abi_version" >&5
1448 echo "$as_me: error: ABI version is not a number: $cf_cv_abi_version" >&2;}
1449    { (exit 1); exit 1; }; }
1450         ;;
1451   esac
1452 else
1453   { { echo "$as_me:1453: error: ABI version value is empty" >&5
1454 echo "$as_me: error: ABI version value is empty" >&2;}
1455    { (exit 1); exit 1; }; }
1456 fi
1457
1458 if test "x$cf_cv_abi_version" != "x$with_abi_version"
1459 then
1460         case "$cf_cv_rel_version" in
1461         (5.*)
1462                 cf_cv_rel_version=$with_abi_version.0
1463                 ;;
1464         esac
1465 fi
1466
1467 ac_aux_dir=
1468 for ac_dir in $srcdir $srcdir/.. $srcdir/../..; do
1469   if test -f "$ac_dir/install-sh"; then
1470     ac_aux_dir=$ac_dir
1471     ac_install_sh="$ac_aux_dir/install-sh -c"
1472     break
1473   elif test -f "$ac_dir/install.sh"; then
1474     ac_aux_dir=$ac_dir
1475     ac_install_sh="$ac_aux_dir/install.sh -c"
1476     break
1477   elif test -f "$ac_dir/shtool"; then
1478     ac_aux_dir=$ac_dir
1479     ac_install_sh="$ac_aux_dir/shtool install -c"
1480     break
1481   fi
1482 done
1483 if test -z "$ac_aux_dir"; then
1484   { { echo "$as_me:1484: error: cannot find install-sh or install.sh in $srcdir $srcdir/.. $srcdir/../.." >&5
1485 echo "$as_me: error: cannot find install-sh or install.sh in $srcdir $srcdir/.. $srcdir/../.." >&2;}
1486    { (exit 1); exit 1; }; }
1487 fi
1488 ac_config_guess="$SHELL $ac_aux_dir/config.guess"
1489 ac_config_sub="$SHELL $ac_aux_dir/config.sub"
1490 ac_configure="$SHELL $ac_aux_dir/configure" # This should be Cygnus configure.
1491
1492 # Make sure we can run config.sub.
1493 $ac_config_sub sun4 >/dev/null 2>&1 ||
1494   { { echo "$as_me:1494: error: cannot run $ac_config_sub" >&5
1495 echo "$as_me: error: cannot run $ac_config_sub" >&2;}
1496    { (exit 1); exit 1; }; }
1497
1498 echo "$as_me:1498: checking build system type" >&5
1499 echo $ECHO_N "checking build system type... $ECHO_C" >&6
1500 if test "${ac_cv_build+set}" = set; then
1501   echo $ECHO_N "(cached) $ECHO_C" >&6
1502 else
1503   ac_cv_build_alias=$build_alias
1504 test -z "$ac_cv_build_alias" &&
1505   ac_cv_build_alias=`$ac_config_guess`
1506 test -z "$ac_cv_build_alias" &&
1507   { { echo "$as_me:1507: error: cannot guess build type; you must specify one" >&5
1508 echo "$as_me: error: cannot guess build type; you must specify one" >&2;}
1509    { (exit 1); exit 1; }; }
1510 ac_cv_build=`$ac_config_sub "$ac_cv_build_alias"` ||
1511   { { echo "$as_me:1511: error: $ac_config_sub $ac_cv_build_alias failed." >&5
1512 echo "$as_me: error: $ac_config_sub $ac_cv_build_alias failed." >&2;}
1513    { (exit 1); exit 1; }; }
1514
1515 fi
1516 echo "$as_me:1516: result: $ac_cv_build" >&5
1517 echo "${ECHO_T}$ac_cv_build" >&6
1518 build=$ac_cv_build
1519 build_cpu=`echo "$ac_cv_build" | sed 's/^\([^-]*\)-\([^-]*\)-\(.*\)$/\1/'`
1520 build_vendor=`echo "$ac_cv_build" | sed 's/^\([^-]*\)-\([^-]*\)-\(.*\)$/\2/'`
1521 build_os=`echo "$ac_cv_build" | sed 's/^\([^-]*\)-\([^-]*\)-\(.*\)$/\3/'`
1522
1523 echo "$as_me:1523: checking host system type" >&5
1524 echo $ECHO_N "checking host system type... $ECHO_C" >&6
1525 if test "${ac_cv_host+set}" = set; then
1526   echo $ECHO_N "(cached) $ECHO_C" >&6
1527 else
1528   ac_cv_host_alias=$host_alias
1529 test -z "$ac_cv_host_alias" &&
1530   ac_cv_host_alias=$ac_cv_build_alias
1531 ac_cv_host=`$ac_config_sub "$ac_cv_host_alias"` ||
1532   { { echo "$as_me:1532: error: $ac_config_sub $ac_cv_host_alias failed" >&5
1533 echo "$as_me: error: $ac_config_sub $ac_cv_host_alias failed" >&2;}
1534    { (exit 1); exit 1; }; }
1535
1536 fi
1537 echo "$as_me:1537: result: $ac_cv_host" >&5
1538 echo "${ECHO_T}$ac_cv_host" >&6
1539 host=$ac_cv_host
1540 host_cpu=`echo "$ac_cv_host" | sed 's/^\([^-]*\)-\([^-]*\)-\(.*\)$/\1/'`
1541 host_vendor=`echo "$ac_cv_host" | sed 's/^\([^-]*\)-\([^-]*\)-\(.*\)$/\2/'`
1542 host_os=`echo "$ac_cv_host" | sed 's/^\([^-]*\)-\([^-]*\)-\(.*\)$/\3/'`
1543
1544 if test -f "$srcdir/config.guess" || test -f "$ac_aux_dir/config.guess" ; then
1545         echo "$as_me:1545: checking target system type" >&5
1546 echo $ECHO_N "checking target system type... $ECHO_C" >&6
1547 if test "${ac_cv_target+set}" = set; then
1548   echo $ECHO_N "(cached) $ECHO_C" >&6
1549 else
1550   ac_cv_target_alias=$target_alias
1551 test "x$ac_cv_target_alias" = "x" &&
1552   ac_cv_target_alias=$ac_cv_host_alias
1553 ac_cv_target=`$ac_config_sub "$ac_cv_target_alias"` ||
1554   { { echo "$as_me:1554: error: $ac_config_sub $ac_cv_target_alias failed" >&5
1555 echo "$as_me: error: $ac_config_sub $ac_cv_target_alias failed" >&2;}
1556    { (exit 1); exit 1; }; }
1557
1558 fi
1559 echo "$as_me:1559: result: $ac_cv_target" >&5
1560 echo "${ECHO_T}$ac_cv_target" >&6
1561 target=$ac_cv_target
1562 target_cpu=`echo "$ac_cv_target" | sed 's/^\([^-]*\)-\([^-]*\)-\(.*\)$/\1/'`
1563 target_vendor=`echo "$ac_cv_target" | sed 's/^\([^-]*\)-\([^-]*\)-\(.*\)$/\2/'`
1564 target_os=`echo "$ac_cv_target" | sed 's/^\([^-]*\)-\([^-]*\)-\(.*\)$/\3/'`
1565
1566 # The aliases save the names the user supplied, while $host etc.
1567 # will get canonicalized.
1568 test -n "$target_alias" &&
1569   test "$program_prefix$program_suffix$program_transform_name" = \
1570     NONENONEs,x,x, &&
1571   program_prefix=${target_alias}-
1572         system_name="$host_os"
1573 else
1574         system_name="`(uname -s -r) 2>/dev/null`"
1575         if test -z "$system_name" ; then
1576                 system_name="`(hostname) 2>/dev/null`"
1577         fi
1578 fi
1579 test -n "$system_name" &&
1580 cat >>confdefs.h <<EOF
1581 #define SYSTEM_NAME "$system_name"
1582 EOF
1583
1584 if test "${cf_cv_system_name+set}" = set; then
1585   echo $ECHO_N "(cached) $ECHO_C" >&6
1586 else
1587   cf_cv_system_name="$system_name"
1588 fi
1589
1590 test -z "$system_name" && system_name="$cf_cv_system_name"
1591 test -n "$cf_cv_system_name" && echo "$as_me:1591: result: Configuring for $cf_cv_system_name" >&5
1592 echo "${ECHO_T}Configuring for $cf_cv_system_name" >&6
1593
1594 if test ".$system_name" != ".$cf_cv_system_name" ; then
1595         echo "$as_me:1595: result: Cached system name ($system_name) does not agree with actual ($cf_cv_system_name)" >&5
1596 echo "${ECHO_T}Cached system name ($system_name) does not agree with actual ($cf_cv_system_name)" >&6
1597         { { echo "$as_me:1597: error: \"Please remove config.cache and try again.\"" >&5
1598 echo "$as_me: error: \"Please remove config.cache and try again.\"" >&2;}
1599    { (exit 1); exit 1; }; }
1600 fi
1601
1602 # Check whether --with-system-type or --without-system-type was given.
1603 if test "${with_system_type+set}" = set; then
1604   withval="$with_system_type"
1605   { echo "$as_me:1605: WARNING: overriding system type to $withval" >&5
1606 echo "$as_me: WARNING: overriding system type to $withval" >&2;}
1607         cf_cv_system_name=$withval
1608         host_os=$withval
1609
1610 fi;
1611
1612 ###     Save the given $CFLAGS to allow user-override.
1613 cf_user_CFLAGS="$CFLAGS"
1614
1615 ###     Default install-location
1616 echo "$as_me:1616: checking for fgrep" >&5
1617 echo $ECHO_N "checking for fgrep... $ECHO_C" >&6
1618 if test "${ac_cv_path_FGREP+set}" = set; then
1619   echo $ECHO_N "(cached) $ECHO_C" >&6
1620 else
1621   if echo 'ab*c' | $GREP -F 'ab*c' >/dev/null 2>&1
1622    then ac_cv_path_FGREP="$GREP -F"
1623    else
1624      for ac_prog in gfgrep fgrep
1625 do
1626   # Extract the first word of "$ac_prog", so it can be a program name with args.
1627 set dummy $ac_prog; ac_word=$2
1628 echo "$as_me:1628: checking for $ac_word" >&5
1629 echo $ECHO_N "checking for $ac_word... $ECHO_C" >&6
1630 if test "${ac_cv_path_FGREP+set}" = set; then
1631   echo $ECHO_N "(cached) $ECHO_C" >&6
1632 else
1633   case $FGREP in
1634   [\\/]* | ?:[\\/]*)
1635   ac_cv_path_FGREP="$FGREP" # Let the user override the test with a path.
1636   ;;
1637   *)
1638   ac_save_IFS=$IFS; IFS=$ac_path_separator
1639 ac_dummy="$PATH"
1640 for ac_dir in $ac_dummy; do
1641   IFS=$ac_save_IFS
1642   test -z "$ac_dir" && ac_dir=.
1643   if $as_executable_p "$ac_dir/$ac_word"; then
1644    ac_cv_path_FGREP="$ac_dir/$ac_word"
1645    echo "$as_me:1645: found $ac_dir/$ac_word" >&5
1646    break
1647 fi
1648 done
1649
1650   ;;
1651 esac
1652 fi
1653 FGREP=$ac_cv_path_FGREP
1654
1655 if test -n "$FGREP"; then
1656   echo "$as_me:1656: result: $FGREP" >&5
1657 echo "${ECHO_T}$FGREP" >&6
1658 else
1659   echo "$as_me:1659: result: no" >&5
1660 echo "${ECHO_T}no" >&6
1661 fi
1662
1663   test -n "$FGREP" && break
1664 done
1665 test -n "$FGREP" || FGREP=": "
1666
1667      test "x$ac_cv_path_FGREP" = "x:" && { { echo "$as_me:1667: error: cannot find workable fgrep" >&5
1668 echo "$as_me: error: cannot find workable fgrep" >&2;}
1669    { (exit 1); exit 1; }; }
1670    fi
1671 fi
1672 echo "$as_me:1672: result: $ac_cv_path_FGREP" >&5
1673 echo "${ECHO_T}$ac_cv_path_FGREP" >&6
1674  FGREP="$ac_cv_path_FGREP"
1675
1676 echo "$as_me:1676: checking for prefix" >&5
1677 echo $ECHO_N "checking for prefix... $ECHO_C" >&6
1678 if test "x$prefix" = "xNONE" ; then
1679         case "$cf_cv_system_name" in
1680                 # non-vendor systems don't have a conflict
1681         (openbsd*|freebsd*|mirbsd*|linux*|cygwin*|msys*|k*bsd*-gnu|mingw*)
1682                 prefix=/usr
1683                 ;;
1684         (*)     prefix=$ac_default_prefix
1685                 ;;
1686         esac
1687 fi
1688 echo "$as_me:1688: result: $prefix" >&5
1689 echo "${ECHO_T}$prefix" >&6
1690
1691 if test "x$prefix" = "xNONE" ; then
1692 echo "$as_me:1692: checking for default include-directory" >&5
1693 echo $ECHO_N "checking for default include-directory... $ECHO_C" >&6
1694 test -n "$verbose" && echo 1>&6
1695 for cf_symbol in \
1696         "$includedir" \
1697         "$includedir/ncurses" \
1698         "$prefix/include" \
1699         "$prefix/include/ncurses" \
1700         /usr/local/include \
1701         /usr/local/include/ncurses \
1702         /usr/include \
1703         /usr/include/ncurses
1704 do
1705         cf_dir=`eval echo "$cf_symbol"`
1706         if test -f "$cf_dir/curses.h" ; then
1707         if ( ${FGREP-fgrep} NCURSES_VERSION "$cf_dir/curses.h" >/dev/null 2>&1 ) ; then
1708                 includedir="$cf_symbol"
1709                 test -n "$verbose"  && echo $ECHO_N "   found " 1>&6
1710                 break
1711         fi
1712         fi
1713         test -n "$verbose"  && echo "   tested $cf_dir" 1>&6
1714 done
1715 echo "$as_me:1715: result: $includedir" >&5
1716 echo "${ECHO_T}$includedir" >&6
1717 fi
1718
1719 ### Defaults for ncurses ABI
1720
1721 case x$cf_cv_abi_version in
1722 (x[6789])
1723         cf_dft_ext_colors=yes
1724         cf_dft_ext_const=yes
1725         cf_dft_ext_mouse=yes
1726         cf_dft_ext_putwin=yes
1727         cf_dft_ext_spfuncs=yes
1728         cf_dft_filter_syms=yes
1729         cf_dft_chtype=uint32_t
1730         cf_dft_mmask_t=uint32_t
1731         cf_dft_interop=yes
1732         cf_dft_tparm_arg=intptr_t
1733         cf_dft_with_lp64=yes
1734         ;;
1735 (*)
1736         cf_dft_ext_colors=no
1737         cf_dft_ext_const=no
1738         cf_dft_ext_mouse=no
1739         cf_dft_ext_putwin=no
1740         cf_dft_ext_spfuncs=no
1741         cf_dft_filter_syms=no
1742         cf_dft_chtype=auto
1743         cf_dft_mmask_t=auto
1744         cf_dft_interop=no
1745         cf_dft_tparm_arg=long
1746         cf_dft_with_lp64=no
1747         ;;
1748 esac
1749
1750 ###     Checks for programs.
1751
1752 # Check whether --with-ada or --without-ada was given.
1753 if test "${with_ada+set}" = set; then
1754   withval="$with_ada"
1755   cf_with_ada=$withval
1756 else
1757   cf_with_ada=yes
1758 fi;
1759
1760 if test "x$cf_with_ada" = xyes
1761 then
1762         cf_prog_cc="gnatgcc gcc cc"
1763 else
1764         cf_prog_cc="gcc cc"
1765 fi
1766
1767 ac_ext=c
1768 ac_cpp='$CPP $CPPFLAGS'
1769 ac_compile='$CC -c $CFLAGS $CPPFLAGS "conftest.$ac_ext" >&5'
1770 ac_link='$CC -o "conftest$ac_exeext" $CFLAGS $CPPFLAGS $LDFLAGS "conftest.$ac_ext" $LIBS >&5'
1771 ac_compiler_gnu=$ac_cv_c_compiler_gnu
1772 ac_main_return="return"
1773 if test -n "$ac_tool_prefix"; then
1774   for ac_prog in $cf_prog_cc
1775   do
1776     # Extract the first word of "$ac_tool_prefix$ac_prog", so it can be a program name with args.
1777 set dummy $ac_tool_prefix$ac_prog; ac_word=$2
1778 echo "$as_me:1778: checking for $ac_word" >&5
1779 echo $ECHO_N "checking for $ac_word... $ECHO_C" >&6
1780 if test "${ac_cv_prog_CC+set}" = set; then
1781   echo $ECHO_N "(cached) $ECHO_C" >&6
1782 else
1783   if test -n "$CC"; then
1784   ac_cv_prog_CC="$CC" # Let the user override the test.
1785 else
1786   ac_save_IFS=$IFS; IFS=$ac_path_separator
1787 ac_dummy="$PATH"
1788 for ac_dir in $ac_dummy; do
1789   IFS=$ac_save_IFS
1790   test -z "$ac_dir" && ac_dir=.
1791   $as_executable_p "$ac_dir/$ac_word" || continue
1792 ac_cv_prog_CC="$ac_tool_prefix$ac_prog"
1793 echo "$as_me:1793: found $ac_dir/$ac_word" >&5
1794 break
1795 done
1796
1797 fi
1798 fi
1799 CC=$ac_cv_prog_CC
1800 if test -n "$CC"; then
1801   echo "$as_me:1801: result: $CC" >&5
1802 echo "${ECHO_T}$CC" >&6
1803 else
1804   echo "$as_me:1804: result: no" >&5
1805 echo "${ECHO_T}no" >&6
1806 fi
1807
1808     test -n "$CC" && break
1809   done
1810 fi
1811 if test -z "$CC"; then
1812   ac_ct_CC=$CC
1813   for ac_prog in $cf_prog_cc
1814 do
1815   # Extract the first word of "$ac_prog", so it can be a program name with args.
1816 set dummy $ac_prog; ac_word=$2
1817 echo "$as_me:1817: checking for $ac_word" >&5
1818 echo $ECHO_N "checking for $ac_word... $ECHO_C" >&6
1819 if test "${ac_cv_prog_ac_ct_CC+set}" = set; then
1820   echo $ECHO_N "(cached) $ECHO_C" >&6
1821 else
1822   if test -n "$ac_ct_CC"; then
1823   ac_cv_prog_ac_ct_CC="$ac_ct_CC" # Let the user override the test.
1824 else
1825   ac_save_IFS=$IFS; IFS=$ac_path_separator
1826 ac_dummy="$PATH"
1827 for ac_dir in $ac_dummy; do
1828   IFS=$ac_save_IFS
1829   test -z "$ac_dir" && ac_dir=.
1830   $as_executable_p "$ac_dir/$ac_word" || continue
1831 ac_cv_prog_ac_ct_CC="$ac_prog"
1832 echo "$as_me:1832: found $ac_dir/$ac_word" >&5
1833 break
1834 done
1835
1836 fi
1837 fi
1838 ac_ct_CC=$ac_cv_prog_ac_ct_CC
1839 if test -n "$ac_ct_CC"; then
1840   echo "$as_me:1840: result: $ac_ct_CC" >&5
1841 echo "${ECHO_T}$ac_ct_CC" >&6
1842 else
1843   echo "$as_me:1843: result: no" >&5
1844 echo "${ECHO_T}no" >&6
1845 fi
1846
1847   test -n "$ac_ct_CC" && break
1848 done
1849
1850   CC=$ac_ct_CC
1851 fi
1852
1853 test -z "$CC" && { { echo "$as_me:1853: error: no acceptable cc found in \$PATH" >&5
1854 echo "$as_me: error: no acceptable cc found in \$PATH" >&2;}
1855    { (exit 1); exit 1; }; }
1856
1857 # Provide some information about the compiler.
1858 echo "$as_me:1858:" \
1859      "checking for C compiler version" >&5
1860 ac_compiler=`set X $ac_compile; echo "$2"`
1861 { (eval echo "$as_me:1861: \"$ac_compiler --version </dev/null >&5\"") >&5
1862   (eval $ac_compiler --version </dev/null >&5) 2>&5
1863   ac_status=$?
1864   echo "$as_me:1864: \$? = $ac_status" >&5
1865   (exit "$ac_status"); }
1866 { (eval echo "$as_me:1866: \"$ac_compiler -v </dev/null >&5\"") >&5
1867   (eval $ac_compiler -v </dev/null >&5) 2>&5
1868   ac_status=$?
1869   echo "$as_me:1869: \$? = $ac_status" >&5
1870   (exit "$ac_status"); }
1871 { (eval echo "$as_me:1871: \"$ac_compiler -V </dev/null >&5\"") >&5
1872   (eval $ac_compiler -V </dev/null >&5) 2>&5
1873   ac_status=$?
1874   echo "$as_me:1874: \$? = $ac_status" >&5
1875   (exit "$ac_status"); }
1876
1877 cat >"conftest.$ac_ext" <<_ACEOF
1878 #line 1878 "configure"
1879 #include "confdefs.h"
1880
1881 int
1882 main (void)
1883 {
1884
1885   ;
1886   return 0;
1887 }
1888 _ACEOF
1889 ac_clean_files_save=$ac_clean_files
1890 ac_clean_files="$ac_clean_files a.out a.exe"
1891 # Try to create an executable without -o first, disregard a.out.
1892 # It will help us diagnose broken compilers, and finding out an intuition
1893 # of exeext.
1894 echo "$as_me:1894: checking for C compiler default output" >&5
1895 echo $ECHO_N "checking for C compiler default output... $ECHO_C" >&6
1896 ac_link_default=`echo "$ac_link" | sed 's/ -o *"conftest[^"]*"//'`
1897 if { (eval echo "$as_me:1897: \"$ac_link_default\"") >&5
1898   (eval $ac_link_default) 2>&5
1899   ac_status=$?
1900   echo "$as_me:1900: \$? = $ac_status" >&5
1901   (exit "$ac_status"); }; then
1902   # Find the output, starting from the most likely.  This scheme is
1903 # not robust to junk in `.', hence go to wildcards (a.*) only as a last
1904 # resort.
1905 for ac_file in `ls a.exe conftest.exe 2>/dev/null;
1906                 ls a.out conftest 2>/dev/null;
1907                 ls a.* conftest.* 2>/dev/null`; do
1908   case $ac_file in
1909     *.$ac_ext | *.xcoff | *.tds | *.d | *.dbg | *.pdb | *.xSYM | *.bb | *.bbg | *.map | *.inf | *.o | *.obj ) ;;
1910     a.out ) # We found the default executable, but exeext='' is most
1911             # certainly right.
1912             break;;
1913     *.* ) ac_cv_exeext=`expr "$ac_file" : '[^.]*\(\..*\)'`
1914           # FIXME: I believe we export ac_cv_exeext for Libtool --akim.
1915           export ac_cv_exeext
1916           break;;
1917     * ) break;;
1918   esac
1919 done
1920 else
1921   echo "$as_me: failed program was:" >&5
1922 cat "conftest.$ac_ext" >&5
1923 { { echo "$as_me:1923: error: C compiler cannot create executables" >&5
1924 echo "$as_me: error: C compiler cannot create executables" >&2;}
1925    { (exit 77); exit 77; }; }
1926 fi
1927
1928 ac_exeext=$ac_cv_exeext
1929 echo "$as_me:1929: result: $ac_file" >&5
1930 echo "${ECHO_T}$ac_file" >&6
1931
1932 # Check the compiler produces executables we can run.  If not, either
1933 # the compiler is broken, or we cross compile.
1934 echo "$as_me:1934: checking whether the C compiler works" >&5
1935 echo $ECHO_N "checking whether the C compiler works... $ECHO_C" >&6
1936 # FIXME: These cross compiler hacks should be removed for Autoconf 3.0
1937 # If not cross compiling, check that we can run a simple program.
1938 if test "$cross_compiling" != yes; then
1939   if { ac_try='./$ac_file'
1940   { (eval echo "$as_me:1940: \"$ac_try\"") >&5
1941   (eval $ac_try) 2>&5
1942   ac_status=$?
1943   echo "$as_me:1943: \$? = $ac_status" >&5
1944   (exit "$ac_status"); }; }; then
1945     cross_compiling=no
1946   else
1947     if test "$cross_compiling" = maybe; then
1948         cross_compiling=yes
1949     else
1950         { { echo "$as_me:1950: error: cannot run C compiled programs.
1951 If you meant to cross compile, use \`--host'." >&5
1952 echo "$as_me: error: cannot run C compiled programs.
1953 If you meant to cross compile, use \`--host'." >&2;}
1954    { (exit 1); exit 1; }; }
1955     fi
1956   fi
1957 fi
1958 echo "$as_me:1958: result: yes" >&5
1959 echo "${ECHO_T}yes" >&6
1960
1961 rm -f a.out a.exe "conftest$ac_cv_exeext"
1962 ac_clean_files=$ac_clean_files_save
1963 # Check the compiler produces executables we can run.  If not, either
1964 # the compiler is broken, or we cross compile.
1965 echo "$as_me:1965: checking whether we are cross compiling" >&5
1966 echo $ECHO_N "checking whether we are cross compiling... $ECHO_C" >&6
1967 echo "$as_me:1967: result: $cross_compiling" >&5
1968 echo "${ECHO_T}$cross_compiling" >&6
1969
1970 echo "$as_me:1970: checking for executable suffix" >&5
1971 echo $ECHO_N "checking for executable suffix... $ECHO_C" >&6
1972 if { (eval echo "$as_me:1972: \"$ac_link\"") >&5
1973   (eval $ac_link) 2>&5
1974   ac_status=$?
1975   echo "$as_me:1975: \$? = $ac_status" >&5
1976   (exit "$ac_status"); }; then
1977   # If both `conftest.exe' and `conftest' are `present' (well, observable)
1978 # catch `conftest.exe'.  For instance with Cygwin, `ls conftest' will
1979 # work properly (i.e., refer to `conftest.exe'), while it won't with
1980 # `rm'.
1981 for ac_file in `(ls conftest.exe; ls conftest; ls conftest.*) 2>/dev/null`; do
1982   case $ac_file in
1983     *.$ac_ext | *.xcoff | *.tds | *.d | *.dbg | *.pdb | *.xSYM | *.bb | *.bbg | *.map | *.inf | *.o | *.obj ) ;;
1984     *.* ) ac_cv_exeext=`expr "$ac_file" : '[^.]*\(\..*\)'`
1985           export ac_cv_exeext
1986           break;;
1987     * ) break;;
1988   esac
1989 done
1990 else
1991   { { echo "$as_me:1991: error: cannot compute EXEEXT: cannot compile and link" >&5
1992 echo "$as_me: error: cannot compute EXEEXT: cannot compile and link" >&2;}
1993    { (exit 1); exit 1; }; }
1994 fi
1995
1996 rm -f "conftest$ac_cv_exeext"
1997 echo "$as_me:1997: result: $ac_cv_exeext" >&5
1998 echo "${ECHO_T}$ac_cv_exeext" >&6
1999
2000 rm -f "conftest.$ac_ext"
2001 EXEEXT=$ac_cv_exeext
2002 ac_exeext=$EXEEXT
2003 echo "$as_me:2003: checking for object suffix" >&5
2004 echo $ECHO_N "checking for object suffix... $ECHO_C" >&6
2005 if test "${ac_cv_objext+set}" = set; then
2006   echo $ECHO_N "(cached) $ECHO_C" >&6
2007 else
2008   cat >"conftest.$ac_ext" <<_ACEOF
2009 #line 2009 "configure"
2010 #include "confdefs.h"
2011
2012 int
2013 main (void)
2014 {
2015
2016   ;
2017   return 0;
2018 }
2019 _ACEOF
2020 rm -f conftest.o conftest.obj
2021 if { (eval echo "$as_me:2021: \"$ac_compile\"") >&5
2022   (eval $ac_compile) 2>&5
2023   ac_status=$?
2024   echo "$as_me:2024: \$? = $ac_status" >&5
2025   (exit "$ac_status"); }; then
2026   for ac_file in `(ls conftest.o conftest.obj; ls conftest.*) 2>/dev/null`; do
2027   case $ac_file in
2028     *.$ac_ext | *.xcoff | *.tds | *.d | *.dbg | *.pdb | *.xSYM | *.map | *.inf ) ;;
2029     *) ac_cv_objext=`expr "$ac_file" : '.*\.\(.*\)'`
2030        break;;
2031   esac
2032 done
2033 else
2034   echo "$as_me: failed program was:" >&5
2035 cat "conftest.$ac_ext" >&5
2036 { { echo "$as_me:2036: error: cannot compute OBJEXT: cannot compile" >&5
2037 echo "$as_me: error: cannot compute OBJEXT: cannot compile" >&2;}
2038    { (exit 1); exit 1; }; }
2039 fi
2040
2041 rm -f "conftest.$ac_cv_objext" "conftest.$ac_ext"
2042 fi
2043 echo "$as_me:2043: result: $ac_cv_objext" >&5
2044 echo "${ECHO_T}$ac_cv_objext" >&6
2045 OBJEXT=$ac_cv_objext
2046 ac_objext=$OBJEXT
2047 echo "$as_me:2047: checking whether we are using the GNU C compiler" >&5
2048 echo $ECHO_N "checking whether we are using the GNU C compiler... $ECHO_C" >&6
2049 if test "${ac_cv_c_compiler_gnu+set}" = set; then
2050   echo $ECHO_N "(cached) $ECHO_C" >&6
2051 else
2052   cat >"conftest.$ac_ext" <<_ACEOF
2053 #line 2053 "configure"
2054 #include "confdefs.h"
2055
2056 int
2057 main (void)
2058 {
2059 #ifndef __GNUC__
2060        choke me
2061 #endif
2062
2063   ;
2064   return 0;
2065 }
2066 _ACEOF
2067 rm -f "conftest.$ac_objext"
2068 if { (eval echo "$as_me:2068: \"$ac_compile\"") >&5
2069   (eval $ac_compile) 2>&5
2070   ac_status=$?
2071   echo "$as_me:2071: \$? = $ac_status" >&5
2072   (exit "$ac_status"); } &&
2073          { ac_try='test -s "conftest.$ac_objext"'
2074   { (eval echo "$as_me:2074: \"$ac_try\"") >&5
2075   (eval $ac_try) 2>&5
2076   ac_status=$?
2077   echo "$as_me:2077: \$? = $ac_status" >&5
2078   (exit "$ac_status"); }; }; then
2079   ac_compiler_gnu=yes
2080 else
2081   echo "$as_me: failed program was:" >&5
2082 cat "conftest.$ac_ext" >&5
2083 ac_compiler_gnu=no
2084 fi
2085 rm -f "conftest.$ac_objext" "conftest.$ac_ext"
2086 ac_cv_c_compiler_gnu=$ac_compiler_gnu
2087
2088 fi
2089 echo "$as_me:2089: result: $ac_cv_c_compiler_gnu" >&5
2090 echo "${ECHO_T}$ac_cv_c_compiler_gnu" >&6
2091 GCC=`test $ac_compiler_gnu = yes && echo yes`
2092 ac_test_CFLAGS=${CFLAGS+set}
2093 ac_save_CFLAGS=$CFLAGS
2094 CFLAGS="-g"
2095 echo "$as_me:2095: checking whether $CC accepts -g" >&5
2096 echo $ECHO_N "checking whether $CC accepts -g... $ECHO_C" >&6
2097 if test "${ac_cv_prog_cc_g+set}" = set; then
2098   echo $ECHO_N "(cached) $ECHO_C" >&6
2099 else
2100   cat >"conftest.$ac_ext" <<_ACEOF
2101 #line 2101 "configure"
2102 #include "confdefs.h"
2103
2104 int
2105 main (void)
2106 {
2107
2108   ;
2109   return 0;
2110 }
2111 _ACEOF
2112 rm -f "conftest.$ac_objext"
2113 if { (eval echo "$as_me:2113: \"$ac_compile\"") >&5
2114   (eval $ac_compile) 2>&5
2115   ac_status=$?
2116   echo "$as_me:2116: \$? = $ac_status" >&5
2117   (exit "$ac_status"); } &&
2118          { ac_try='test -s "conftest.$ac_objext"'
2119   { (eval echo "$as_me:2119: \"$ac_try\"") >&5
2120   (eval $ac_try) 2>&5
2121   ac_status=$?
2122   echo "$as_me:2122: \$? = $ac_status" >&5
2123   (exit "$ac_status"); }; }; then
2124   ac_cv_prog_cc_g=yes
2125 else
2126   echo "$as_me: failed program was:" >&5
2127 cat "conftest.$ac_ext" >&5
2128 ac_cv_prog_cc_g=no
2129 fi
2130 rm -f "conftest.$ac_objext" "conftest.$ac_ext"
2131 fi
2132 echo "$as_me:2132: result: $ac_cv_prog_cc_g" >&5
2133 echo "${ECHO_T}$ac_cv_prog_cc_g" >&6
2134 if test "$ac_test_CFLAGS" = set; then
2135   CFLAGS=$ac_save_CFLAGS
2136 elif test $ac_cv_prog_cc_g = yes; then
2137   if test "$GCC" = yes; then
2138     CFLAGS="-g -O2"
2139   else
2140     CFLAGS="-g"
2141   fi
2142 else
2143   if test "$GCC" = yes; then
2144     CFLAGS="-O2"
2145   else
2146     CFLAGS=
2147   fi
2148 fi
2149 # Some people use a C++ compiler to compile C.  Since we use `exit',
2150 # in C++ we need to declare it.  In case someone uses the same compiler
2151 # for both compiling C and C++ we need to have the C++ compiler decide
2152 # the declaration of exit, since it's the most demanding environment.
2153 cat >"conftest.$ac_ext" <<_ACEOF
2154 #ifndef __cplusplus
2155   choke me
2156 #endif
2157 _ACEOF
2158 rm -f "conftest.$ac_objext"
2159 if { (eval echo "$as_me:2159: \"$ac_compile\"") >&5
2160   (eval $ac_compile) 2>&5
2161   ac_status=$?
2162   echo "$as_me:2162: \$? = $ac_status" >&5
2163   (exit "$ac_status"); } &&
2164          { ac_try='test -s "conftest.$ac_objext"'
2165   { (eval echo "$as_me:2165: \"$ac_try\"") >&5
2166   (eval $ac_try) 2>&5
2167   ac_status=$?
2168   echo "$as_me:2168: \$? = $ac_status" >&5
2169   (exit "$ac_status"); }; }; then
2170   for ac_declaration in \
2171    ''\
2172    '#include <stdlib.h>' \
2173    'extern "C" void std::exit (int) throw (); using std::exit;' \
2174    'extern "C" void std::exit (int); using std::exit;' \
2175    'extern "C" void exit (int) throw ();' \
2176    'extern "C" void exit (int);' \
2177    'void exit (int);'
2178 do
2179   cat >"conftest.$ac_ext" <<_ACEOF
2180 #line 2180 "configure"
2181 #include "confdefs.h"
2182 #include <stdlib.h>
2183 $ac_declaration
2184 int
2185 main (void)
2186 {
2187 exit (42);
2188   ;
2189   return 0;
2190 }
2191 _ACEOF
2192 rm -f "conftest.$ac_objext"
2193 if { (eval echo "$as_me:2193: \"$ac_compile\"") >&5
2194   (eval $ac_compile) 2>&5
2195   ac_status=$?
2196   echo "$as_me:2196: \$? = $ac_status" >&5
2197   (exit "$ac_status"); } &&
2198          { ac_try='test -s "conftest.$ac_objext"'
2199   { (eval echo "$as_me:2199: \"$ac_try\"") >&5
2200   (eval $ac_try) 2>&5
2201   ac_status=$?
2202   echo "$as_me:2202: \$? = $ac_status" >&5
2203   (exit "$ac_status"); }; }; then
2204   :
2205 else
2206   echo "$as_me: failed program was:" >&5
2207 cat "conftest.$ac_ext" >&5
2208 continue
2209 fi
2210 rm -f "conftest.$ac_objext" "conftest.$ac_ext"
2211   cat >"conftest.$ac_ext" <<_ACEOF
2212 #line 2212 "configure"
2213 #include "confdefs.h"
2214 $ac_declaration
2215 int
2216 main (void)
2217 {
2218 exit (42);
2219   ;
2220   return 0;
2221 }
2222 _ACEOF
2223 rm -f "conftest.$ac_objext"
2224 if { (eval echo "$as_me:2224: \"$ac_compile\"") >&5
2225   (eval $ac_compile) 2>&5
2226   ac_status=$?
2227   echo "$as_me:2227: \$? = $ac_status" >&5
2228   (exit "$ac_status"); } &&
2229          { ac_try='test -s "conftest.$ac_objext"'
2230   { (eval echo "$as_me:2230: \"$ac_try\"") >&5
2231   (eval $ac_try) 2>&5
2232   ac_status=$?
2233   echo "$as_me:2233: \$? = $ac_status" >&5
2234   (exit "$ac_status"); }; }; then
2235   break
2236 else
2237   echo "$as_me: failed program was:" >&5
2238 cat "conftest.$ac_ext" >&5
2239 fi
2240 rm -f "conftest.$ac_objext" "conftest.$ac_ext"
2241 done
2242 rm -rf conftest*
2243 if test -n "$ac_declaration"; then
2244   echo '#ifdef __cplusplus' >>confdefs.h
2245   echo "$ac_declaration"    >>confdefs.h
2246   echo '#endif'             >>confdefs.h
2247 fi
2248
2249 else
2250   echo "$as_me: failed program was:" >&5
2251 cat "conftest.$ac_ext" >&5
2252 fi
2253 rm -f "conftest.$ac_objext" "conftest.$ac_ext"
2254 ac_ext=c
2255 ac_cpp='$CPP $CPPFLAGS'
2256 ac_compile='$CC -c $CFLAGS $CPPFLAGS "conftest.$ac_ext" >&5'
2257 ac_link='$CC -o "conftest$ac_exeext" $CFLAGS $CPPFLAGS $LDFLAGS "conftest.$ac_ext" $LIBS >&5'
2258 ac_compiler_gnu=$ac_cv_c_compiler_gnu
2259 ac_main_return="return"
2260
2261 GCC_VERSION=none
2262 if test "$GCC" = yes ; then
2263         echo "$as_me:2263: checking version of $CC" >&5
2264 echo $ECHO_N "checking version of $CC... $ECHO_C" >&6
2265         GCC_VERSION="`${CC} --version 2>/dev/null | sed -e '2,$d' -e 's/^.*(GCC[^)]*) //' -e 's/^.*(Debian[^)]*) //' -e 's/^[^0-9.]*//' -e 's/[^0-9.].*//'`"
2266         test -z "$GCC_VERSION" && GCC_VERSION=unknown
2267         echo "$as_me:2267: result: $GCC_VERSION" >&5
2268 echo "${ECHO_T}$GCC_VERSION" >&6
2269 fi
2270
2271 INTEL_COMPILER=no
2272
2273 if test "$GCC" = yes ; then
2274         case "$host_os" in
2275         (linux*|gnu*)
2276                 echo "$as_me:2276: checking if this is really Intel C compiler" >&5
2277 echo $ECHO_N "checking if this is really Intel C compiler... $ECHO_C" >&6
2278                 cf_save_CFLAGS="$CFLAGS"
2279                 CFLAGS="$CFLAGS -no-gcc"
2280                 cat >"conftest.$ac_ext" <<_ACEOF
2281 #line 2281 "configure"
2282 #include "confdefs.h"
2283
2284 int
2285 main (void)
2286 {
2287
2288 #ifdef __INTEL_COMPILER
2289 #else
2290 make an error
2291 #endif
2292
2293   ;
2294   return 0;
2295 }
2296 _ACEOF
2297 rm -f "conftest.$ac_objext"
2298 if { (eval echo "$as_me:2298: \"$ac_compile\"") >&5
2299   (eval $ac_compile) 2>&5
2300   ac_status=$?
2301   echo "$as_me:2301: \$? = $ac_status" >&5
2302   (exit "$ac_status"); } &&
2303          { ac_try='test -s "conftest.$ac_objext"'
2304   { (eval echo "$as_me:2304: \"$ac_try\"") >&5
2305   (eval $ac_try) 2>&5
2306   ac_status=$?
2307   echo "$as_me:2307: \$? = $ac_status" >&5
2308   (exit "$ac_status"); }; }; then
2309   INTEL_COMPILER=yes
2310 cf_save_CFLAGS="$cf_save_CFLAGS -we147"
2311
2312 else
2313   echo "$as_me: failed program was:" >&5
2314 cat "conftest.$ac_ext" >&5
2315 fi
2316 rm -f "conftest.$ac_objext" "conftest.$ac_ext"
2317                 CFLAGS="$cf_save_CFLAGS"
2318                 echo "$as_me:2318: result: $INTEL_COMPILER" >&5
2319 echo "${ECHO_T}$INTEL_COMPILER" >&6
2320                 ;;
2321         esac
2322 fi
2323
2324 CLANG_COMPILER=no
2325
2326 if test "$GCC" = yes ; then
2327         echo "$as_me:2327: checking if this is really Clang C compiler" >&5
2328 echo $ECHO_N "checking if this is really Clang C compiler... $ECHO_C" >&6
2329         cf_save_CFLAGS="$CFLAGS"
2330         cat >"conftest.$ac_ext" <<_ACEOF
2331 #line 2331 "configure"
2332 #include "confdefs.h"
2333
2334 int
2335 main (void)
2336 {
2337
2338 #ifdef __clang__
2339 #else
2340 make an error
2341 #endif
2342
2343   ;
2344   return 0;
2345 }
2346 _ACEOF
2347 rm -f "conftest.$ac_objext"
2348 if { (eval echo "$as_me:2348: \"$ac_compile\"") >&5
2349   (eval $ac_compile) 2>&5
2350   ac_status=$?
2351   echo "$as_me:2351: \$? = $ac_status" >&5
2352   (exit "$ac_status"); } &&
2353          { ac_try='test -s "conftest.$ac_objext"'
2354   { (eval echo "$as_me:2354: \"$ac_try\"") >&5
2355   (eval $ac_try) 2>&5
2356   ac_status=$?
2357   echo "$as_me:2357: \$? = $ac_status" >&5
2358   (exit "$ac_status"); }; }; then
2359   CLANG_COMPILER=yes
2360
2361 else
2362   echo "$as_me: failed program was:" >&5
2363 cat "conftest.$ac_ext" >&5
2364 fi
2365 rm -f "conftest.$ac_objext" "conftest.$ac_ext"
2366         CFLAGS="$cf_save_CFLAGS"
2367         echo "$as_me:2367: result: $CLANG_COMPILER" >&5
2368 echo "${ECHO_T}$CLANG_COMPILER" >&6
2369 fi
2370
2371 CLANG_VERSION=none
2372
2373 if test "x$CLANG_COMPILER" = "xyes" ; then
2374         case "$CC" in
2375         (c[1-9][0-9]|*/c[1-9][0-9])
2376                 { echo "$as_me:2376: WARNING: replacing broken compiler alias $CC" >&5
2377 echo "$as_me: WARNING: replacing broken compiler alias $CC" >&2;}
2378                 CFLAGS="$CFLAGS -std=`echo "$CC" | sed -e 's%.*/%%'`"
2379                 CC=clang
2380                 ;;
2381         esac
2382
2383         echo "$as_me:2383: checking version of $CC" >&5
2384 echo $ECHO_N "checking version of $CC... $ECHO_C" >&6
2385         CLANG_VERSION="`$CC --version 2>/dev/null | sed -e '2,$d' -e 's/^.*(CLANG[^)]*) //' -e 's/^.*(Debian[^)]*) //' -e 's/^[^0-9.]*//' -e 's/[^0-9.].*//'`"
2386         test -z "$CLANG_VERSION" && CLANG_VERSION=unknown
2387         echo "$as_me:2387: result: $CLANG_VERSION" >&5
2388 echo "${ECHO_T}$CLANG_VERSION" >&6
2389
2390         for cf_clang_opt in \
2391                 -Qunused-arguments \
2392                 -Wno-error=implicit-function-declaration
2393         do
2394                 echo "$as_me:2394: checking if option $cf_clang_opt works" >&5
2395 echo $ECHO_N "checking if option $cf_clang_opt works... $ECHO_C" >&6
2396                 cf_save_CFLAGS="$CFLAGS"
2397                 CFLAGS="$CFLAGS $cf_clang_opt"
2398                 cat >"conftest.$ac_ext" <<_ACEOF
2399 #line 2399 "configure"
2400 #include "confdefs.h"
2401
2402                         #include <stdio.h>
2403 int
2404 main (void)
2405 {
2406
2407                         printf("hello!\\n");
2408   ;
2409   return 0;
2410 }
2411 _ACEOF
2412 rm -f "conftest.$ac_objext" "conftest$ac_exeext"
2413 if { (eval echo "$as_me:2413: \"$ac_link\"") >&5
2414   (eval $ac_link) 2>&5
2415   ac_status=$?
2416   echo "$as_me:2416: \$? = $ac_status" >&5
2417   (exit "$ac_status"); } &&
2418          { ac_try='test -s "conftest$ac_exeext"'
2419   { (eval echo "$as_me:2419: \"$ac_try\"") >&5
2420   (eval $ac_try) 2>&5
2421   ac_status=$?
2422   echo "$as_me:2422: \$? = $ac_status" >&5
2423   (exit "$ac_status"); }; }; then
2424
2425                         cf_clang_optok=yes
2426 else
2427   echo "$as_me: failed program was:" >&5
2428 cat "conftest.$ac_ext" >&5
2429
2430                         cf_clang_optok=no
2431 fi
2432 rm -f "conftest.$ac_objext" "conftest$ac_exeext" "conftest.$ac_ext"
2433                 echo "$as_me:2433: result: $cf_clang_optok" >&5
2434 echo "${ECHO_T}$cf_clang_optok" >&6
2435                 CFLAGS="$cf_save_CFLAGS"
2436                 if test "$cf_clang_optok" = yes; then
2437                         test -n "$verbose" && echo "    adding option $cf_clang_opt" 1>&6
2438
2439 echo "${as_me:-configure}:2439: testing adding option $cf_clang_opt ..." 1>&5
2440
2441         test -n "$CFLAGS" && CFLAGS="$CFLAGS "
2442         CFLAGS="${CFLAGS}$cf_clang_opt"
2443
2444                 fi
2445         done
2446 fi
2447
2448 echo "$as_me:2448: checking for $CC option to accept ANSI C" >&5
2449 echo $ECHO_N "checking for $CC option to accept ANSI C... $ECHO_C" >&6
2450 if test "${ac_cv_prog_cc_stdc+set}" = set; then
2451   echo $ECHO_N "(cached) $ECHO_C" >&6
2452 else
2453   ac_cv_prog_cc_stdc=no
2454 ac_save_CC=$CC
2455 cat >"conftest.$ac_ext" <<_ACEOF
2456 #line 2456 "configure"
2457 #include "confdefs.h"
2458 #include <stdarg.h>
2459 #include <stdio.h>
2460 #include <sys/types.h>
2461 #include <sys/stat.h>
2462 /* Most of the following tests are stolen from RCS 5.7's src/conf.sh.  */
2463 struct buf { int x; };
2464 FILE * (*rcsopen) (struct buf *, struct stat *, int);
2465 static char *e (p, i)
2466      char **p;
2467      int i;
2468 {
2469   return p[i];
2470 }
2471 static char *f (char * (*g) (char **, int), char **p, ...)
2472 {
2473   char *s;
2474   va_list v;
2475   va_start (v,p);
2476   s = g (p, va_arg (v,int));
2477   va_end (v);
2478   return s;
2479 }
2480 int test (int i, double x);
2481 struct s1 {int (*f) (int a);};
2482 struct s2 {int (*f) (double a);};
2483 int pairnames (int, char **, FILE *(*)(struct buf *, struct stat *, int), int, int);
2484 int argc;
2485 char **argv;
2486 int
2487 main (void)
2488 {
2489 return f (e, argv, 0) != argv[0]  ||  f (e, argv, 1) != argv[1];
2490   ;
2491   return 0;
2492 }
2493 _ACEOF
2494 # Don't try gcc -ansi; that turns off useful extensions and
2495 # breaks some systems' header files.
2496 # AIX                   -qlanglvl=ansi
2497 # Ultrix and OSF/1      -std1
2498 # HP-UX 10.20 and later -Ae
2499 # HP-UX older versions  -Aa -D_HPUX_SOURCE
2500 # SVR4                  -Xc -D__EXTENSIONS__
2501 for ac_arg in "" -qlanglvl=ansi -std1 -Ae "-Aa -D_HPUX_SOURCE" "-Xc -D__EXTENSIONS__"
2502 do
2503   CC="$ac_save_CC $ac_arg"
2504   rm -f "conftest.$ac_objext"
2505 if { (eval echo "$as_me:2505: \"$ac_compile\"") >&5
2506   (eval $ac_compile) 2>&5
2507   ac_status=$?
2508   echo "$as_me:2508: \$? = $ac_status" >&5
2509   (exit "$ac_status"); } &&
2510          { ac_try='test -s "conftest.$ac_objext"'
2511   { (eval echo "$as_me:2511: \"$ac_try\"") >&5
2512   (eval $ac_try) 2>&5
2513   ac_status=$?
2514   echo "$as_me:2514: \$? = $ac_status" >&5
2515   (exit "$ac_status"); }; }; then
2516   ac_cv_prog_cc_stdc=$ac_arg
2517 break
2518 else
2519   echo "$as_me: failed program was:" >&5
2520 cat "conftest.$ac_ext" >&5
2521 fi
2522 rm -f "conftest.$ac_objext"
2523 done
2524 rm -f "conftest.$ac_ext" "conftest.$ac_objext"
2525 CC=$ac_save_CC
2526
2527 fi
2528
2529 case "x$ac_cv_prog_cc_stdc" in
2530   x|xno)
2531     echo "$as_me:2531: result: none needed" >&5
2532 echo "${ECHO_T}none needed" >&6 ;;
2533   *)
2534     echo "$as_me:2534: result: $ac_cv_prog_cc_stdc" >&5
2535 echo "${ECHO_T}$ac_cv_prog_cc_stdc" >&6
2536     CC="$CC $ac_cv_prog_cc_stdc" ;;
2537 esac
2538
2539 # This should have been defined by AC_PROG_CC
2540 : "${CC:=cc}"
2541
2542 echo "$as_me:2542: checking \$CFLAGS variable" >&5
2543 echo $ECHO_N "checking \$CFLAGS variable... $ECHO_C" >&6
2544 case "x$CFLAGS" in
2545 (*-[IUD]*)
2546         echo "$as_me:2546: result: broken" >&5
2547 echo "${ECHO_T}broken" >&6
2548         { echo "$as_me:2548: WARNING: your environment uses the CFLAGS variable to hold CPPFLAGS options" >&5
2549 echo "$as_me: WARNING: your environment uses the CFLAGS variable to hold CPPFLAGS options" >&2;}
2550         cf_flags="$CFLAGS"
2551         CFLAGS=
2552         for cf_arg in $cf_flags
2553         do
2554
2555 cf_fix_cppflags=no
2556 cf_new_cflags=
2557 cf_new_cppflags=
2558 cf_new_extra_cppflags=
2559
2560 for cf_add_cflags in $cf_arg
2561 do
2562 case "$cf_fix_cppflags" in
2563 (no)
2564         case "$cf_add_cflags" in
2565         (-undef|-nostdinc*|-I*|-D*|-U*|-E|-P|-C)
2566                 case "$cf_add_cflags" in
2567                 (-D*)
2568                         cf_tst_cflags=`echo "${cf_add_cflags}" |sed -e 's/^-D[^=]*='\''\"[^"]*//'`
2569
2570                         test "x${cf_add_cflags}" != "x${cf_tst_cflags}" \
2571                                 && test -z "${cf_tst_cflags}" \
2572                                 && cf_fix_cppflags=yes
2573
2574                         if test "$cf_fix_cppflags" = yes ; then
2575
2576         test -n "$cf_new_extra_cppflags" && cf_new_extra_cppflags="$cf_new_extra_cppflags "
2577         cf_new_extra_cppflags="${cf_new_extra_cppflags}$cf_add_cflags"
2578
2579                                 continue
2580                         elif test "${cf_tst_cflags}" = "\"'" ; then
2581
2582         test -n "$cf_new_extra_cppflags" && cf_new_extra_cppflags="$cf_new_extra_cppflags "
2583         cf_new_extra_cppflags="${cf_new_extra_cppflags}$cf_add_cflags"
2584
2585                                 continue
2586                         fi
2587                         ;;
2588                 esac
2589                 case "$CPPFLAGS" in
2590                 (*$cf_add_cflags)
2591                         ;;
2592                 (*)
2593                         case "$cf_add_cflags" in
2594                         (-D*)
2595                                 cf_tst_cppflags=`echo "x$cf_add_cflags" | sed -e 's/^...//' -e 's/=.*//'`
2596
2597 CPPFLAGS=`echo "$CPPFLAGS" | \
2598         sed     -e 's/-[UD]'"$cf_tst_cppflags"'\(=[^    ]*\)\?[         ]/ /g' \
2599                 -e 's/-[UD]'"$cf_tst_cppflags"'\(=[^    ]*\)\?$//g'`
2600
2601                                 ;;
2602                         esac
2603
2604         test -n "$cf_new_cppflags" && cf_new_cppflags="$cf_new_cppflags "
2605         cf_new_cppflags="${cf_new_cppflags}$cf_add_cflags"
2606
2607                         ;;
2608                 esac
2609                 ;;
2610         (*)
2611
2612         test -n "$cf_new_cflags" && cf_new_cflags="$cf_new_cflags "
2613         cf_new_cflags="${cf_new_cflags}$cf_add_cflags"
2614
2615                 ;;
2616         esac
2617         ;;
2618 (yes)
2619
2620         test -n "$cf_new_extra_cppflags" && cf_new_extra_cppflags="$cf_new_extra_cppflags "
2621         cf_new_extra_cppflags="${cf_new_extra_cppflags}$cf_add_cflags"
2622
2623         cf_tst_cflags=`echo "${cf_add_cflags}" |sed -e 's/^[^"]*"'\''//'`
2624
2625         test "x${cf_add_cflags}" != "x${cf_tst_cflags}" \
2626                 && test -z "${cf_tst_cflags}" \
2627                 && cf_fix_cppflags=no
2628         ;;
2629 esac
2630 done
2631
2632 if test -n "$cf_new_cflags" ; then
2633
2634         test -n "$CFLAGS" && CFLAGS="$CFLAGS "
2635         CFLAGS="${CFLAGS}$cf_new_cflags"
2636
2637 fi
2638
2639 if test -n "$cf_new_cppflags" ; then
2640
2641         test -n "$CPPFLAGS" && CPPFLAGS="$CPPFLAGS "
2642         CPPFLAGS="${CPPFLAGS}$cf_new_cppflags"
2643
2644 fi
2645
2646 if test -n "$cf_new_extra_cppflags" ; then
2647
2648         test -n "$EXTRA_CPPFLAGS" && EXTRA_CPPFLAGS="$EXTRA_CPPFLAGS "
2649         EXTRA_CPPFLAGS="${EXTRA_CPPFLAGS}$cf_new_extra_cppflags"
2650
2651 fi
2652
2653         done
2654         ;;
2655 (*)
2656         echo "$as_me:2656: result: ok" >&5
2657 echo "${ECHO_T}ok" >&6
2658         ;;
2659 esac
2660
2661 echo "$as_me:2661: checking \$CC variable" >&5
2662 echo $ECHO_N "checking \$CC variable... $ECHO_C" >&6
2663 case "$CC" in
2664 (*[\ \  ]-*)
2665         echo "$as_me:2665: result: broken" >&5
2666 echo "${ECHO_T}broken" >&6
2667         { echo "$as_me:2667: WARNING: your environment uses the CC variable to hold CFLAGS/CPPFLAGS options" >&5
2668 echo "$as_me: WARNING: your environment uses the CC variable to hold CFLAGS/CPPFLAGS options" >&2;}
2669         # humor him...
2670         cf_prog=`echo "$CC" | sed -e 's/        / /g' -e 's/[ ]* / /g' -e 's/[ ]*[ ]-[^ ].*//'`
2671         cf_flags=`echo "$CC" | ${AWK:-awk} -v prog="$cf_prog" '{ printf("%s", substr($0,1+length(prog))); }'`
2672         CC="$cf_prog"
2673         for cf_arg in $cf_flags
2674         do
2675                 case "x$cf_arg" in
2676                 (x-[IUDfgOW]*)
2677
2678 cf_fix_cppflags=no
2679 cf_new_cflags=
2680 cf_new_cppflags=
2681 cf_new_extra_cppflags=
2682
2683 for cf_add_cflags in $cf_arg
2684 do
2685 case "$cf_fix_cppflags" in
2686 (no)
2687         case "$cf_add_cflags" in
2688         (-undef|-nostdinc*|-I*|-D*|-U*|-E|-P|-C)
2689                 case "$cf_add_cflags" in
2690                 (-D*)
2691                         cf_tst_cflags=`echo "${cf_add_cflags}" |sed -e 's/^-D[^=]*='\''\"[^"]*//'`
2692
2693                         test "x${cf_add_cflags}" != "x${cf_tst_cflags}" \
2694                                 && test -z "${cf_tst_cflags}" \
2695                                 && cf_fix_cppflags=yes
2696
2697                         if test "$cf_fix_cppflags" = yes ; then
2698
2699         test -n "$cf_new_extra_cppflags" && cf_new_extra_cppflags="$cf_new_extra_cppflags "
2700         cf_new_extra_cppflags="${cf_new_extra_cppflags}$cf_add_cflags"
2701
2702                                 continue
2703                         elif test "${cf_tst_cflags}" = "\"'" ; then
2704
2705         test -n "$cf_new_extra_cppflags" && cf_new_extra_cppflags="$cf_new_extra_cppflags "
2706         cf_new_extra_cppflags="${cf_new_extra_cppflags}$cf_add_cflags"
2707
2708                                 continue
2709                         fi
2710                         ;;
2711                 esac
2712                 case "$CPPFLAGS" in
2713                 (*$cf_add_cflags)
2714                         ;;
2715                 (*)
2716                         case "$cf_add_cflags" in
2717                         (-D*)
2718                                 cf_tst_cppflags=`echo "x$cf_add_cflags" | sed -e 's/^...//' -e 's/=.*//'`
2719
2720 CPPFLAGS=`echo "$CPPFLAGS" | \
2721         sed     -e 's/-[UD]'"$cf_tst_cppflags"'\(=[^    ]*\)\?[         ]/ /g' \
2722                 -e 's/-[UD]'"$cf_tst_cppflags"'\(=[^    ]*\)\?$//g'`
2723
2724                                 ;;
2725                         esac
2726
2727         test -n "$cf_new_cppflags" && cf_new_cppflags="$cf_new_cppflags "
2728         cf_new_cppflags="${cf_new_cppflags}$cf_add_cflags"
2729
2730                         ;;
2731                 esac
2732                 ;;
2733         (*)
2734
2735         test -n "$cf_new_cflags" && cf_new_cflags="$cf_new_cflags "
2736         cf_new_cflags="${cf_new_cflags}$cf_add_cflags"
2737
2738                 ;;
2739         esac
2740         ;;
2741 (yes)
2742
2743         test -n "$cf_new_extra_cppflags" && cf_new_extra_cppflags="$cf_new_extra_cppflags "
2744         cf_new_extra_cppflags="${cf_new_extra_cppflags}$cf_add_cflags"
2745
2746         cf_tst_cflags=`echo "${cf_add_cflags}" |sed -e 's/^[^"]*"'\''//'`
2747
2748         test "x${cf_add_cflags}" != "x${cf_tst_cflags}" \
2749                 && test -z "${cf_tst_cflags}" \
2750                 && cf_fix_cppflags=no
2751         ;;
2752 esac
2753 done
2754
2755 if test -n "$cf_new_cflags" ; then
2756
2757         test -n "$CFLAGS" && CFLAGS="$CFLAGS "
2758         CFLAGS="${CFLAGS}$cf_new_cflags"
2759
2760 fi
2761
2762 if test -n "$cf_new_cppflags" ; then
2763
2764         test -n "$CPPFLAGS" && CPPFLAGS="$CPPFLAGS "
2765         CPPFLAGS="${CPPFLAGS}$cf_new_cppflags"
2766
2767 fi
2768
2769 if test -n "$cf_new_extra_cppflags" ; then
2770
2771         test -n "$EXTRA_CPPFLAGS" && EXTRA_CPPFLAGS="$EXTRA_CPPFLAGS "
2772         EXTRA_CPPFLAGS="${EXTRA_CPPFLAGS}$cf_new_extra_cppflags"
2773
2774 fi
2775
2776                         ;;
2777                 (*)
2778                         CC="$CC $cf_arg"
2779                         ;;
2780                 esac
2781         done
2782         test -n "$verbose" && echo "    resulting CC: '$CC'" 1>&6
2783
2784 echo "${as_me:-configure}:2784: testing resulting CC: '$CC' ..." 1>&5
2785
2786         test -n "$verbose" && echo "    resulting CFLAGS: '$CFLAGS'" 1>&6
2787
2788 echo "${as_me:-configure}:2788: testing resulting CFLAGS: '$CFLAGS' ..." 1>&5
2789
2790         test -n "$verbose" && echo "    resulting CPPFLAGS: '$CPPFLAGS'" 1>&6
2791
2792 echo "${as_me:-configure}:2792: testing resulting CPPFLAGS: '$CPPFLAGS' ..." 1>&5
2793
2794         ;;
2795 (*)
2796         echo "$as_me:2796: result: ok" >&5
2797 echo "${ECHO_T}ok" >&6
2798         ;;
2799 esac
2800
2801 ac_ext=c
2802 ac_cpp='$CPP $CPPFLAGS'
2803 ac_compile='$CC -c $CFLAGS $CPPFLAGS "conftest.$ac_ext" >&5'
2804 ac_link='$CC -o "conftest$ac_exeext" $CFLAGS $CPPFLAGS $LDFLAGS "conftest.$ac_ext" $LIBS >&5'
2805 ac_compiler_gnu=$ac_cv_c_compiler_gnu
2806 ac_main_return="return"
2807 echo "$as_me:2807: checking how to run the C preprocessor" >&5
2808 echo $ECHO_N "checking how to run the C preprocessor... $ECHO_C" >&6
2809 # On Suns, sometimes $CPP names a directory.
2810 if test -n "$CPP" && test -d "$CPP"; then
2811   CPP=
2812 fi
2813 if test -z "$CPP"; then
2814   if test "${ac_cv_prog_CPP+set}" = set; then
2815   echo $ECHO_N "(cached) $ECHO_C" >&6
2816 else
2817       # Double quotes because CPP needs to be expanded
2818     for CPP in "$CC -E" "$CC -E -traditional-cpp" "/lib/cpp"
2819     do
2820       ac_preproc_ok=false
2821 for ac_c_preproc_warn_flag in '' yes
2822 do
2823   # Use a header file that comes with gcc, so configuring glibc
2824   # with a fresh cross-compiler works.
2825   # On the NeXT, cc -E runs the code through the compiler's parser,
2826   # not just through cpp. "Syntax error" is here to catch this case.
2827   cat >"conftest.$ac_ext" <<_ACEOF
2828 #line 2828 "configure"
2829 #include "confdefs.h"
2830 #include <assert.h>
2831                      Syntax error
2832 _ACEOF
2833 if { (eval echo "$as_me:2833: \"$ac_cpp "conftest.$ac_ext"\"") >&5
2834   (eval $ac_cpp "conftest.$ac_ext") 2>conftest.er1
2835   ac_status=$?
2836   $EGREP -v '^ *\+' conftest.er1 >conftest.err
2837   rm -f conftest.er1
2838   cat conftest.err >&5
2839   echo "$as_me:2839: \$? = $ac_status" >&5
2840   (exit "$ac_status"); } >/dev/null; then
2841   if test -s conftest.err; then
2842     ac_cpp_err=$ac_c_preproc_warn_flag
2843   else
2844     ac_cpp_err=
2845   fi
2846 else
2847   ac_cpp_err=yes
2848 fi
2849 if test -z "$ac_cpp_err"; then
2850   :
2851 else
2852   echo "$as_me: failed program was:" >&5
2853   cat "conftest.$ac_ext" >&5
2854   # Broken: fails on valid input.
2855 continue
2856 fi
2857 rm -f conftest.err "conftest.$ac_ext"
2858
2859   # OK, works on sane cases.  Now check whether non-existent headers
2860   # can be detected and how.
2861   cat >"conftest.$ac_ext" <<_ACEOF
2862 #line 2862 "configure"
2863 #include "confdefs.h"
2864 #include <ac_nonexistent.h>
2865 _ACEOF
2866 if { (eval echo "$as_me:2866: \"$ac_cpp "conftest.$ac_ext"\"") >&5
2867   (eval $ac_cpp "conftest.$ac_ext") 2>conftest.er1
2868   ac_status=$?
2869   $EGREP -v '^ *\+' conftest.er1 >conftest.err
2870   rm -f conftest.er1
2871   cat conftest.err >&5
2872   echo "$as_me:2872: \$? = $ac_status" >&5
2873   (exit "$ac_status"); } >/dev/null; then
2874   if test -s conftest.err; then
2875     ac_cpp_err=$ac_c_preproc_warn_flag
2876   else
2877     ac_cpp_err=
2878   fi
2879 else
2880   ac_cpp_err=yes
2881 fi
2882 if test -z "$ac_cpp_err"; then
2883   # Broken: success on invalid input.
2884 continue
2885 else
2886   echo "$as_me: failed program was:" >&5
2887   cat "conftest.$ac_ext" >&5
2888   # Passes both tests.
2889 ac_preproc_ok=:
2890 break
2891 fi
2892 rm -f conftest.err "conftest.$ac_ext"
2893
2894 done
2895 # Because of `break', _AC_PREPROC_IFELSE's cleaning code was skipped.
2896 rm -f conftest.err "conftest.$ac_ext"
2897 if $ac_preproc_ok; then
2898   break
2899 fi
2900
2901     done
2902     ac_cv_prog_CPP=$CPP
2903
2904 fi
2905   CPP=$ac_cv_prog_CPP
2906 else
2907   ac_cv_prog_CPP=$CPP
2908 fi
2909 echo "$as_me:2909: result: $CPP" >&5
2910 echo "${ECHO_T}$CPP" >&6
2911 ac_preproc_ok=false
2912 for ac_c_preproc_warn_flag in '' yes
2913 do
2914   # Use a header file that comes with gcc, so configuring glibc
2915   # with a fresh cross-compiler works.
2916   # On the NeXT, cc -E runs the code through the compiler's parser,
2917   # not just through cpp. "Syntax error" is here to catch this case.
2918   cat >"conftest.$ac_ext" <<_ACEOF
2919 #line 2919 "configure"
2920 #include "confdefs.h"
2921 #include <assert.h>
2922                      Syntax error
2923 _ACEOF
2924 if { (eval echo "$as_me:2924: \"$ac_cpp "conftest.$ac_ext"\"") >&5
2925   (eval $ac_cpp "conftest.$ac_ext") 2>conftest.er1
2926   ac_status=$?
2927   $EGREP -v '^ *\+' conftest.er1 >conftest.err
2928   rm -f conftest.er1
2929   cat conftest.err >&5
2930   echo "$as_me:2930: \$? = $ac_status" >&5
2931   (exit "$ac_status"); } >/dev/null; then
2932   if test -s conftest.err; then
2933     ac_cpp_err=$ac_c_preproc_warn_flag
2934   else
2935     ac_cpp_err=
2936   fi
2937 else
2938   ac_cpp_err=yes
2939 fi
2940 if test -z "$ac_cpp_err"; then
2941   :
2942 else
2943   echo "$as_me: failed program was:" >&5
2944   cat "conftest.$ac_ext" >&5
2945   # Broken: fails on valid input.
2946 continue
2947 fi
2948 rm -f conftest.err "conftest.$ac_ext"
2949
2950   # OK, works on sane cases.  Now check whether non-existent headers
2951   # can be detected and how.
2952   cat >"conftest.$ac_ext" <<_ACEOF
2953 #line 2953 "configure"
2954 #include "confdefs.h"
2955 #include <ac_nonexistent.h>
2956 _ACEOF
2957 if { (eval echo "$as_me:2957: \"$ac_cpp "conftest.$ac_ext"\"") >&5
2958   (eval $ac_cpp "conftest.$ac_ext") 2>conftest.er1
2959   ac_status=$?
2960   $EGREP -v '^ *\+' conftest.er1 >conftest.err
2961   rm -f conftest.er1
2962   cat conftest.err >&5
2963   echo "$as_me:2963: \$? = $ac_status" >&5
2964   (exit "$ac_status"); } >/dev/null; then
2965   if test -s conftest.err; then
2966     ac_cpp_err=$ac_c_preproc_warn_flag
2967   else
2968     ac_cpp_err=
2969   fi
2970 else
2971   ac_cpp_err=yes
2972 fi
2973 if test -z "$ac_cpp_err"; then
2974   # Broken: success on invalid input.
2975 continue
2976 else
2977   echo "$as_me: failed program was:" >&5
2978   cat "conftest.$ac_ext" >&5
2979   # Passes both tests.
2980 ac_preproc_ok=:
2981 break
2982 fi
2983 rm -f conftest.err "conftest.$ac_ext"
2984
2985 done
2986 # Because of `break', _AC_PREPROC_IFELSE's cleaning code was skipped.
2987 rm -f conftest.err "conftest.$ac_ext"
2988 if $ac_preproc_ok; then
2989   :
2990 else
2991   { { echo "$as_me:2991: error: C preprocessor \"$CPP\" fails sanity check" >&5
2992 echo "$as_me: error: C preprocessor \"$CPP\" fails sanity check" >&2;}
2993    { (exit 1); exit 1; }; }
2994 fi
2995
2996 ac_ext=c
2997 ac_cpp='$CPP $CPPFLAGS'
2998 ac_compile='$CC -c $CFLAGS $CPPFLAGS "conftest.$ac_ext" >&5'
2999 ac_link='$CC -o "conftest$ac_exeext" $CFLAGS $CPPFLAGS $LDFLAGS "conftest.$ac_ext" $LIBS >&5'
3000 ac_compiler_gnu=$ac_cv_c_compiler_gnu
3001 ac_main_return="return"
3002
3003 if test $ac_cv_c_compiler_gnu = yes; then
3004     echo "$as_me:3004: checking whether $CC needs -traditional" >&5
3005 echo $ECHO_N "checking whether $CC needs -traditional... $ECHO_C" >&6
3006 if test "${ac_cv_prog_gcc_traditional+set}" = set; then
3007   echo $ECHO_N "(cached) $ECHO_C" >&6
3008 else
3009     ac_pattern="Autoconf.*'x'"
3010   cat >"conftest.$ac_ext" <<_ACEOF
3011 #line 3011 "configure"
3012 #include "confdefs.h"
3013 #include <sgtty.h>
3014 int Autoconf = TIOCGETP;
3015 _ACEOF
3016 if (eval "$ac_cpp conftest.$ac_ext") 2>&5 |
3017   $EGREP "$ac_pattern" >/dev/null 2>&1; then
3018   ac_cv_prog_gcc_traditional=yes
3019 else
3020   ac_cv_prog_gcc_traditional=no
3021 fi
3022 rm -rf conftest*
3023
3024   if test $ac_cv_prog_gcc_traditional = no; then
3025     cat >"conftest.$ac_ext" <<_ACEOF
3026 #line 3026 "configure"
3027 #include "confdefs.h"
3028 #include <termio.h>
3029 int Autoconf = TCGETA;
3030 _ACEOF
3031 if (eval "$ac_cpp conftest.$ac_ext") 2>&5 |
3032   $EGREP "$ac_pattern" >/dev/null 2>&1; then
3033   ac_cv_prog_gcc_traditional=yes
3034 fi
3035 rm -rf conftest*
3036
3037   fi
3038 fi
3039 echo "$as_me:3039: result: $ac_cv_prog_gcc_traditional" >&5
3040 echo "${ECHO_T}$ac_cv_prog_gcc_traditional" >&6
3041   if test $ac_cv_prog_gcc_traditional = yes; then
3042     CC="$CC -traditional"
3043   fi
3044 fi
3045
3046 echo "$as_me:3046: checking whether $CC understands -c and -o together" >&5
3047 echo $ECHO_N "checking whether $CC understands -c and -o together... $ECHO_C" >&6
3048 if test "${cf_cv_prog_CC_c_o+set}" = set; then
3049   echo $ECHO_N "(cached) $ECHO_C" >&6
3050 else
3051
3052 cat > conftest.$ac_ext <<CF_EOF
3053 int main(void)
3054 {
3055         ${cf_cv_main_return:-return}(0);
3056 }
3057 CF_EOF
3058 # We do the test twice because some compilers refuse to overwrite an
3059 # existing .o file with -o, though they will create one.
3060 ac_try='$CC $CFLAGS $CPPFLAGS -c conftest.$ac_ext -o conftest2.$ac_objext >&5'
3061 if { (eval echo "$as_me:3061: \"$ac_try\"") >&5
3062   (eval $ac_try) 2>&5
3063   ac_status=$?
3064   echo "$as_me:3064: \$? = $ac_status" >&5
3065   (exit "$ac_status"); } &&
3066   test -f conftest2.$ac_objext && { (eval echo "$as_me:3066: \"$ac_try\"") >&5
3067   (eval $ac_try) 2>&5
3068   ac_status=$?
3069   echo "$as_me:3069: \$? = $ac_status" >&5
3070   (exit "$ac_status"); };
3071 then
3072   eval cf_cv_prog_CC_c_o=yes
3073 else
3074   eval cf_cv_prog_CC_c_o=no
3075 fi
3076 rm -rf ./conftest*
3077
3078 fi
3079 if test "$cf_cv_prog_CC_c_o" = yes; then
3080   echo "$as_me:3080: result: yes" >&5
3081 echo "${ECHO_T}yes" >&6
3082 else
3083   echo "$as_me:3083: result: no" >&5
3084 echo "${ECHO_T}no" >&6
3085 fi
3086
3087 if test "$cross_compiling" = yes ; then
3088         LDCONFIG=:
3089 else
3090         case "$cf_cv_system_name" in
3091         (dragonfly*|mirbsd*|freebsd*)
3092                 test -z "$LDCONFIG" && LDCONFIG="/sbin/ldconfig -R"
3093                 ;;
3094         (*) LDPATH=$PATH:/sbin:/usr/sbin
3095                 # Extract the first word of "ldconfig", so it can be a program name with args.
3096 set dummy ldconfig; ac_word=$2
3097 echo "$as_me:3097: checking for $ac_word" >&5
3098 echo $ECHO_N "checking for $ac_word... $ECHO_C" >&6
3099 if test "${ac_cv_path_LDCONFIG+set}" = set; then
3100   echo $ECHO_N "(cached) $ECHO_C" >&6
3101 else
3102   case $LDCONFIG in
3103   [\\/]* | ?:[\\/]*)
3104   ac_cv_path_LDCONFIG="$LDCONFIG" # Let the user override the test with a path.
3105   ;;
3106   *)
3107   ac_save_IFS=$IFS; IFS=$ac_path_separator
3108 ac_dummy="$LDPATH"
3109 for ac_dir in $ac_dummy; do
3110   IFS=$ac_save_IFS
3111   test -z "$ac_dir" && ac_dir=.
3112   if $as_executable_p "$ac_dir/$ac_word"; then
3113    ac_cv_path_LDCONFIG="$ac_dir/$ac_word"
3114    echo "$as_me:3114: found $ac_dir/$ac_word" >&5
3115    break
3116 fi
3117 done
3118
3119   ;;
3120 esac
3121 fi
3122 LDCONFIG=$ac_cv_path_LDCONFIG
3123
3124 if test -n "$LDCONFIG"; then
3125   echo "$as_me:3125: result: $LDCONFIG" >&5
3126 echo "${ECHO_T}$LDCONFIG" >&6
3127 else
3128   echo "$as_me:3128: result: no" >&5
3129 echo "${ECHO_T}no" >&6
3130 fi
3131
3132                 ;;
3133         esac
3134 fi
3135
3136 echo "$as_me:3136: checking if you want to ensure bool is consistent with C++" >&5
3137 echo $ECHO_N "checking if you want to ensure bool is consistent with C++... $ECHO_C" >&6
3138
3139 # Check whether --with-cxx or --without-cxx was given.
3140 if test "${with_cxx+set}" = set; then
3141   withval="$with_cxx"
3142   cf_with_cxx=$withval
3143 else
3144   cf_with_cxx=yes
3145 fi;
3146 echo "$as_me:3146: result: $cf_with_cxx" >&5
3147 echo "${ECHO_T}$cf_with_cxx" >&6
3148 if test "X$cf_with_cxx" = Xno ; then
3149         CXX=""
3150         GXX=""
3151 else
3152         # with autoconf 2.13, we can change the error to a warning:
3153                 ac_ext=cc
3154 ac_cpp='$CXXCPP $CPPFLAGS'
3155 ac_compile='$CXX -c $CXXFLAGS $CPPFLAGS "conftest.$ac_ext" >&5'
3156 ac_link='$CXX -o "conftest$ac_exeext" $CXXFLAGS $CPPFLAGS $LDFLAGS "conftest.$ac_ext" $LIBS >&5'
3157 ac_compiler_gnu=$ac_cv_cxx_compiler_gnu
3158 ac_main_return="return"
3159 if test -n "$ac_tool_prefix"; then
3160   for ac_prog in $CCC g++ c++ gpp aCC CC cxx cc++ cl FCC KCC RCC xlC_r xlC
3161   do
3162     # Extract the first word of "$ac_tool_prefix$ac_prog", so it can be a program name with args.
3163 set dummy $ac_tool_prefix$ac_prog; ac_word=$2
3164 echo "$as_me:3164: checking for $ac_word" >&5
3165 echo $ECHO_N "checking for $ac_word... $ECHO_C" >&6
3166 if test "${ac_cv_prog_CXX+set}" = set; then
3167   echo $ECHO_N "(cached) $ECHO_C" >&6
3168 else
3169   if test -n "$CXX"; then
3170   ac_cv_prog_CXX="$CXX" # Let the user override the test.
3171 else
3172   ac_save_IFS=$IFS; IFS=$ac_path_separator
3173 ac_dummy="$PATH"
3174 for ac_dir in $ac_dummy; do
3175   IFS=$ac_save_IFS
3176   test -z "$ac_dir" && ac_dir=.
3177   $as_executable_p "$ac_dir/$ac_word" || continue
3178 ac_cv_prog_CXX="$ac_tool_prefix$ac_prog"
3179 echo "$as_me:3179: found $ac_dir/$ac_word" >&5
3180 break
3181 done
3182
3183 fi
3184 fi
3185 CXX=$ac_cv_prog_CXX
3186 if test -n "$CXX"; then
3187   echo "$as_me:3187: result: $CXX" >&5
3188 echo "${ECHO_T}$CXX" >&6
3189 else
3190   echo "$as_me:3190: result: no" >&5
3191 echo "${ECHO_T}no" >&6
3192 fi
3193
3194     test -n "$CXX" && break
3195   done
3196 fi
3197 if test -z "$CXX"; then
3198   ac_ct_CXX=$CXX
3199   for ac_prog in $CCC g++ c++ gpp aCC CC cxx cc++ cl FCC KCC RCC xlC_r xlC
3200 do
3201   # Extract the first word of "$ac_prog", so it can be a program name with args.
3202 set dummy $ac_prog; ac_word=$2
3203 echo "$as_me:3203: checking for $ac_word" >&5
3204 echo $ECHO_N "checking for $ac_word... $ECHO_C" >&6
3205 if test "${ac_cv_prog_ac_ct_CXX+set}" = set; then
3206   echo $ECHO_N "(cached) $ECHO_C" >&6
3207 else
3208   if test -n "$ac_ct_CXX"; then
3209   ac_cv_prog_ac_ct_CXX="$ac_ct_CXX" # Let the user override the test.
3210 else
3211   ac_save_IFS=$IFS; IFS=$ac_path_separator
3212 ac_dummy="$PATH"
3213 for ac_dir in $ac_dummy; do
3214   IFS=$ac_save_IFS
3215   test -z "$ac_dir" && ac_dir=.
3216   $as_executable_p "$ac_dir/$ac_word" || continue
3217 ac_cv_prog_ac_ct_CXX="$ac_prog"
3218 echo "$as_me:3218: found $ac_dir/$ac_word" >&5
3219 break
3220 done
3221
3222 fi
3223 fi
3224 ac_ct_CXX=$ac_cv_prog_ac_ct_CXX
3225 if test -n "$ac_ct_CXX"; then
3226   echo "$as_me:3226: result: $ac_ct_CXX" >&5
3227 echo "${ECHO_T}$ac_ct_CXX" >&6
3228 else
3229   echo "$as_me:3229: result: no" >&5
3230 echo "${ECHO_T}no" >&6
3231 fi
3232
3233   test -n "$ac_ct_CXX" && break
3234 done
3235 test -n "$ac_ct_CXX" || ac_ct_CXX="g++"
3236
3237   CXX=$ac_ct_CXX
3238 fi
3239
3240 # Provide some information about the compiler.
3241 echo "$as_me:3241:" \
3242      "checking for C++ compiler version" >&5
3243 ac_compiler=`set X $ac_compile; echo $2`
3244 { (eval echo "$as_me:3244: \"$ac_compiler --version </dev/null >&5\"") >&5
3245   (eval $ac_compiler --version </dev/null >&5) 2>&5
3246   ac_status=$?
3247   echo "$as_me:3247: \$? = $ac_status" >&5
3248   (exit "$ac_status"); }
3249 { (eval echo "$as_me:3249: \"$ac_compiler -v </dev/null >&5\"") >&5
3250   (eval $ac_compiler -v </dev/null >&5) 2>&5
3251   ac_status=$?
3252   echo "$as_me:3252: \$? = $ac_status" >&5
3253   (exit "$ac_status"); }
3254 { (eval echo "$as_me:3254: \"$ac_compiler -V </dev/null >&5\"") >&5
3255   (eval $ac_compiler -V </dev/null >&5) 2>&5
3256   ac_status=$?
3257   echo "$as_me:3257: \$? = $ac_status" >&5
3258   (exit "$ac_status"); }
3259
3260 echo "$as_me:3260: checking whether we are using the GNU C++ compiler" >&5
3261 echo $ECHO_N "checking whether we are using the GNU C++ compiler... $ECHO_C" >&6
3262 if test "${ac_cv_cxx_compiler_gnu+set}" = set; then
3263   echo $ECHO_N "(cached) $ECHO_C" >&6
3264 else
3265   cat >"conftest.$ac_ext" <<_ACEOF
3266 #line 3266 "configure"
3267 #include "confdefs.h"
3268
3269 int
3270 main (void)
3271 {
3272 #ifndef __GNUC__
3273        choke me
3274 #endif
3275
3276   ;
3277   return 0;
3278 }
3279 _ACEOF
3280 rm -f "conftest.$ac_objext"
3281 if { (eval echo "$as_me:3281: \"$ac_compile\"") >&5
3282   (eval $ac_compile) 2>&5
3283   ac_status=$?
3284   echo "$as_me:3284: \$? = $ac_status" >&5
3285   (exit "$ac_status"); } &&
3286          { ac_try='test -s "conftest.$ac_objext"'
3287   { (eval echo "$as_me:3287: \"$ac_try\"") >&5
3288   (eval $ac_try) 2>&5
3289   ac_status=$?
3290   echo "$as_me:3290: \$? = $ac_status" >&5
3291   (exit "$ac_status"); }; }; then
3292   ac_compiler_gnu=yes
3293 else
3294   echo "$as_me: failed program was:" >&5
3295 cat "conftest.$ac_ext" >&5
3296 ac_compiler_gnu=no
3297 fi
3298 rm -f "conftest.$ac_objext" "conftest.$ac_ext"
3299 ac_cv_cxx_compiler_gnu=$ac_compiler_gnu
3300
3301 fi
3302 echo "$as_me:3302: result: $ac_cv_cxx_compiler_gnu" >&5
3303 echo "${ECHO_T}$ac_cv_cxx_compiler_gnu" >&6
3304 GXX=`test $ac_compiler_gnu = yes && echo yes`
3305 ac_test_CXXFLAGS=${CXXFLAGS+set}
3306 ac_save_CXXFLAGS=$CXXFLAGS
3307 CXXFLAGS="-g"
3308 echo "$as_me:3308: checking whether $CXX accepts -g" >&5
3309 echo $ECHO_N "checking whether $CXX accepts -g... $ECHO_C" >&6
3310 if test "${ac_cv_prog_cxx_g+set}" = set; then
3311   echo $ECHO_N "(cached) $ECHO_C" >&6
3312 else
3313   cat >"conftest.$ac_ext" <<_ACEOF
3314 #line 3314 "configure"
3315 #include "confdefs.h"
3316
3317 int
3318 main (void)
3319 {
3320
3321   ;
3322   return 0;
3323 }
3324 _ACEOF
3325 rm -f "conftest.$ac_objext"
3326 if { (eval echo "$as_me:3326: \"$ac_compile\"") >&5
3327   (eval $ac_compile) 2>&5
3328   ac_status=$?
3329   echo "$as_me:3329: \$? = $ac_status" >&5
3330   (exit "$ac_status"); } &&
3331          { ac_try='test -s "conftest.$ac_objext"'
3332   { (eval echo "$as_me:3332: \"$ac_try\"") >&5
3333   (eval $ac_try) 2>&5
3334   ac_status=$?
3335   echo "$as_me:3335: \$? = $ac_status" >&5
3336   (exit "$ac_status"); }; }; then
3337   ac_cv_prog_cxx_g=yes
3338 else
3339   echo "$as_me: failed program was:" >&5
3340 cat "conftest.$ac_ext" >&5
3341 ac_cv_prog_cxx_g=no
3342 fi
3343 rm -f "conftest.$ac_objext" "conftest.$ac_ext"
3344 fi
3345 echo "$as_me:3345: result: $ac_cv_prog_cxx_g" >&5
3346 echo "${ECHO_T}$ac_cv_prog_cxx_g" >&6
3347 if test "$ac_test_CXXFLAGS" = set; then
3348   CXXFLAGS=$ac_save_CXXFLAGS
3349 elif test $ac_cv_prog_cxx_g = yes; then
3350   if test "$GXX" = yes; then
3351     CXXFLAGS="-g -O2"
3352   else
3353     CXXFLAGS="-g"
3354   fi
3355 else
3356   if test "$GXX" = yes; then
3357     CXXFLAGS="-O2"
3358   else
3359     CXXFLAGS=
3360   fi
3361 fi
3362 for ac_declaration in \
3363    ''\
3364    '#include <stdlib.h>' \
3365    'extern "C" void std::exit (int) throw (); using std::exit;' \
3366    'extern "C" void std::exit (int); using std::exit;' \
3367    'extern "C" void exit (int) throw ();' \
3368    'extern "C" void exit (int);' \
3369    'void exit (int);'
3370 do
3371   cat >"conftest.$ac_ext" <<_ACEOF
3372 #line 3372 "configure"
3373 #include "confdefs.h"
3374 #include <stdlib.h>
3375 $ac_declaration
3376 int
3377 main (void)
3378 {
3379 exit (42);
3380   ;
3381   return 0;
3382 }
3383 _ACEOF
3384 rm -f "conftest.$ac_objext"
3385 if { (eval echo "$as_me:3385: \"$ac_compile\"") >&5
3386   (eval $ac_compile) 2>&5
3387   ac_status=$?
3388   echo "$as_me:3388: \$? = $ac_status" >&5
3389   (exit "$ac_status"); } &&
3390          { ac_try='test -s "conftest.$ac_objext"'
3391   { (eval echo "$as_me:3391: \"$ac_try\"") >&5
3392   (eval $ac_try) 2>&5
3393   ac_status=$?
3394   echo "$as_me:3394: \$? = $ac_status" >&5
3395   (exit "$ac_status"); }; }; then
3396   :
3397 else
3398   echo "$as_me: failed program was:" >&5
3399 cat "conftest.$ac_ext" >&5
3400 continue
3401 fi
3402 rm -f "conftest.$ac_objext" "conftest.$ac_ext"
3403   cat >"conftest.$ac_ext" <<_ACEOF
3404 #line 3404 "configure"
3405 #include "confdefs.h"
3406 $ac_declaration
3407 int
3408 main (void)
3409 {
3410 exit (42);
3411   ;
3412   return 0;
3413 }
3414 _ACEOF
3415 rm -f "conftest.$ac_objext"
3416 if { (eval echo "$as_me:3416: \"$ac_compile\"") >&5
3417   (eval $ac_compile) 2>&5
3418   ac_status=$?
3419   echo "$as_me:3419: \$? = $ac_status" >&5
3420   (exit "$ac_status"); } &&
3421          { ac_try='test -s "conftest.$ac_objext"'
3422   { (eval echo "$as_me:3422: \"$ac_try\"") >&5
3423   (eval $ac_try) 2>&5
3424   ac_status=$?
3425   echo "$as_me:3425: \$? = $ac_status" >&5
3426   (exit "$ac_status"); }; }; then
3427   break
3428 else
3429   echo "$as_me: failed program was:" >&5
3430 cat "conftest.$ac_ext" >&5
3431 fi
3432 rm -f "conftest.$ac_objext" "conftest.$ac_ext"
3433 done
3434 rm -rf conftest*
3435 if test -n "$ac_declaration"; then
3436   echo '#ifdef __cplusplus' >>confdefs.h
3437   echo "$ac_declaration"    >>confdefs.h
3438   echo '#endif'             >>confdefs.h
3439 fi
3440
3441 ac_ext=c
3442 ac_cpp='$CPP $CPPFLAGS'
3443 ac_compile='$CC -c $CFLAGS $CPPFLAGS "conftest.$ac_ext" >&5'
3444 ac_link='$CC -o "conftest$ac_exeext" $CFLAGS $CPPFLAGS $LDFLAGS "conftest.$ac_ext" $LIBS >&5'
3445 ac_compiler_gnu=$ac_cv_c_compiler_gnu
3446 ac_main_return="return"
3447
3448         ac_ext=cc
3449 ac_cpp='$CXXCPP $CPPFLAGS'
3450 ac_compile='$CXX -c $CXXFLAGS $CPPFLAGS "conftest.$ac_ext" >&5'
3451 ac_link='$CXX -o "conftest$ac_exeext" $CXXFLAGS $CPPFLAGS $LDFLAGS "conftest.$ac_ext" $LIBS >&5'
3452 ac_compiler_gnu=$ac_cv_cxx_compiler_gnu
3453 ac_main_return="return"
3454
3455         if test "x$cf_with_cxx" != xno
3456         then
3457                 # Several of the C++ configurations do not work, particularly when
3458                 # cross-compiling (20140913 -TD)
3459                 echo "$as_me:3459: checking if $CXX works" >&5
3460 echo $ECHO_N "checking if $CXX works... $ECHO_C" >&6
3461
3462                 save_CPPFLAGS="$CPPFLAGS"
3463                 eval cf_includedir=${includedir}
3464                 CPPFLAGS="$CPPFLAGS -I${cf_includedir}"
3465
3466 cat >"conftest.$ac_ext" <<_ACEOF
3467 #line 3467 "configure"
3468 #include "confdefs.h"
3469
3470 #include <stdlib.h>
3471 #include <stdio.h>
3472
3473 int
3474 main (void)
3475 {
3476
3477                 printf("Hello world!\n")
3478
3479   ;
3480   return 0;
3481 }
3482 _ACEOF
3483 rm -f "conftest.$ac_objext"
3484 if { (eval echo "$as_me:3484: \"$ac_compile\"") >&5
3485   (eval $ac_compile) 2>&5
3486   ac_status=$?
3487   echo "$as_me:3487: \$? = $ac_status" >&5
3488   (exit "$ac_status"); } &&
3489          { ac_try='test -s "conftest.$ac_objext"'
3490   { (eval echo "$as_me:3490: \"$ac_try\"") >&5
3491   (eval $ac_try) 2>&5
3492   ac_status=$?
3493   echo "$as_me:3493: \$? = $ac_status" >&5
3494   (exit "$ac_status"); }; }; then
3495   cf_cxx_works=yes
3496 else
3497   echo "$as_me: failed program was:" >&5
3498 cat "conftest.$ac_ext" >&5
3499 cf_cxx_works=no
3500 fi
3501 rm -f "conftest.$ac_objext" "conftest.$ac_ext"
3502                 CPPFLAGS="$save_CPPFLAGS"
3503
3504                 echo "$as_me:3504: result: $cf_cxx_works" >&5
3505 echo "${ECHO_T}$cf_cxx_works" >&6
3506                 if test "x$cf_cxx_works" = xno
3507                 then
3508                         { echo "$as_me:3508: WARNING: Ignore $CXX, since it cannot compile hello-world." >&5
3509 echo "$as_me: WARNING: Ignore $CXX, since it cannot compile hello-world." >&2;}
3510                         cf_with_cxx=no; CXX=""; GXX="";
3511                 fi
3512         fi
3513         ac_ext=c
3514 ac_cpp='$CPP $CPPFLAGS'
3515 ac_compile='$CC -c $CFLAGS $CPPFLAGS "conftest.$ac_ext" >&5'
3516 ac_link='$CC -o "conftest$ac_exeext" $CFLAGS $CPPFLAGS $LDFLAGS "conftest.$ac_ext" $LIBS >&5'
3517 ac_compiler_gnu=$ac_cv_c_compiler_gnu
3518 ac_main_return="return"
3519
3520         # autoconf 2.5x removed the error (hardcoding it to g++, or just blank)
3521         if test "$CXX" = "g++" ; then
3522                 # Extract the first word of "g++", so it can be a program name with args.
3523 set dummy g++; ac_word=$2
3524 echo "$as_me:3524: checking for $ac_word" >&5
3525 echo $ECHO_N "checking for $ac_word... $ECHO_C" >&6
3526 if test "${ac_cv_path_CXX+set}" = set; then
3527   echo $ECHO_N "(cached) $ECHO_C" >&6
3528 else
3529   case $CXX in
3530   [\\/]* | ?:[\\/]*)
3531   ac_cv_path_CXX="$CXX" # Let the user override the test with a path.
3532   ;;
3533   *)
3534   ac_save_IFS=$IFS; IFS=$ac_path_separator
3535 ac_dummy="$PATH"
3536 for ac_dir in $ac_dummy; do
3537   IFS=$ac_save_IFS
3538   test -z "$ac_dir" && ac_dir=.
3539   if $as_executable_p "$ac_dir/$ac_word"; then
3540    ac_cv_path_CXX="$ac_dir/$ac_word"
3541    echo "$as_me:3541: found $ac_dir/$ac_word" >&5
3542    break
3543 fi
3544 done
3545
3546   ;;
3547 esac
3548 fi
3549 CXX=$ac_cv_path_CXX
3550
3551 if test -n "$CXX"; then
3552   echo "$as_me:3552: result: $CXX" >&5
3553 echo "${ECHO_T}$CXX" >&6
3554 else
3555   echo "$as_me:3555: result: no" >&5
3556 echo "${ECHO_T}no" >&6
3557 fi
3558
3559         fi
3560         case "x$CXX" in
3561         (x|xg++)
3562                 { echo "$as_me:3562: WARNING: You don't have any C++ compiler, too bad" >&5
3563 echo "$as_me: WARNING: You don't have any C++ compiler, too bad" >&2;}
3564                 cf_with_cxx=no; CXX=""; GXX="";
3565                 ;;
3566         esac
3567 fi
3568
3569 GXX_VERSION=none
3570 if test "$GXX" = yes; then
3571         echo "$as_me:3571: checking version of ${CXX:-g++}" >&5
3572 echo $ECHO_N "checking version of ${CXX:-g++}... $ECHO_C" >&6
3573         GXX_VERSION="`${CXX:-g++} --version| sed -e '2,$d' -e 's/^.*(GCC) //' -e 's/^[^0-9.]*//' -e 's/[^0-9.].*//'`"
3574         if test -z "$GXX_VERSION"
3575         then
3576                 GXX_VERSION=unknown
3577                 GXX=no
3578         fi
3579         echo "$as_me:3579: result: $GXX_VERSION" >&5
3580 echo "${ECHO_T}$GXX_VERSION" >&6
3581 fi
3582
3583 case "$GXX_VERSION" in
3584 ([1-9][0-9].*)
3585         ;;
3586 (1.*|2.[0-6]*)
3587         { echo "$as_me:3587: WARNING: templates do not work" >&5
3588 echo "$as_me: WARNING: templates do not work" >&2;}
3589         ;;
3590 esac
3591
3592 echo "$as_me:3592: checking if you want to build C++ binding and demo" >&5
3593 echo $ECHO_N "checking if you want to build C++ binding and demo... $ECHO_C" >&6
3594
3595 # Check whether --with-cxx-binding or --without-cxx-binding was given.
3596 if test "${with_cxx_binding+set}" = set; then
3597   withval="$with_cxx_binding"
3598   cf_with_cxx_binding=$withval
3599 else
3600   cf_with_cxx_binding=$cf_with_cxx
3601 fi;
3602 echo "$as_me:3602: result: $cf_with_cxx_binding" >&5
3603 echo "${ECHO_T}$cf_with_cxx_binding" >&6
3604
3605 echo "$as_me:3605: checking if you want to build with Ada" >&5
3606 echo $ECHO_N "checking if you want to build with Ada... $ECHO_C" >&6
3607 echo "$as_me:3607: result: $cf_with_ada" >&5
3608 echo "${ECHO_T}$cf_with_ada" >&6
3609
3610 echo "$as_me:3610: checking if you want to install terminal database" >&5
3611 echo $ECHO_N "checking if you want to install terminal database... $ECHO_C" >&6
3612
3613 # Check whether --enable-db-install or --disable-db-install was given.
3614 if test "${enable_db_install+set}" = set; then
3615   enableval="$enable_db_install"
3616   cf_with_db_install=$enableval
3617 else
3618   cf_with_db_install=yes
3619 fi;
3620 echo "$as_me:3620: result: $cf_with_db_install" >&5
3621 echo "${ECHO_T}$cf_with_db_install" >&6
3622
3623 echo "$as_me:3623: checking if you want to install manpages" >&5
3624 echo $ECHO_N "checking if you want to install manpages... $ECHO_C" >&6
3625
3626 # Check whether --with-manpages or --without-manpages was given.
3627 if test "${with_manpages+set}" = set; then
3628   withval="$with_manpages"
3629   cf_with_manpages=$withval
3630 else
3631   cf_with_manpages=yes
3632 fi;
3633 echo "$as_me:3633: result: $cf_with_manpages" >&5
3634 echo "${ECHO_T}$cf_with_manpages" >&6
3635
3636 echo "$as_me:3636: checking if you want to build programs such as tic" >&5
3637 echo $ECHO_N "checking if you want to build programs such as tic... $ECHO_C" >&6
3638
3639 # Check whether --with-progs or --without-progs was given.
3640 if test "${with_progs+set}" = set; then
3641   withval="$with_progs"
3642   cf_with_progs=$withval
3643 else
3644   cf_with_progs=yes
3645 fi;
3646 echo "$as_me:3646: result: $cf_with_progs" >&5
3647 echo "${ECHO_T}$cf_with_progs" >&6
3648
3649 if test -f "$srcdir/tack/tack.h" ; then
3650         if test "x$cross_compiling" = xyes ; then
3651                 test -n "$verbose" && echo "    ignoring tack because we are cross-compiling" 1>&6
3652
3653 echo "${as_me:-configure}:3653: testing ignoring tack because we are cross-compiling ..." 1>&5
3654
3655                 cf_with_tack=no
3656         else
3657                 echo "$as_me:3657: checking if you want to build the tack program" >&5
3658 echo $ECHO_N "checking if you want to build the tack program... $ECHO_C" >&6
3659
3660 # Check whether --with-tack or --without-tack was given.
3661 if test "${with_tack+set}" = set; then
3662   withval="$with_tack"
3663   cf_with_tack=$withval
3664 else
3665   cf_with_tack=$cf_with_progs
3666 fi;
3667                 echo "$as_me:3667: result: $cf_with_tack" >&5
3668 echo "${ECHO_T}$cf_with_tack" >&6
3669         fi
3670 else
3671         cf_with_tack=no
3672 fi
3673
3674 echo "$as_me:3674: checking if you want to build test-programs" >&5
3675 echo $ECHO_N "checking if you want to build test-programs... $ECHO_C" >&6
3676
3677 # Check whether --with-tests or --without-tests was given.
3678 if test "${with_tests+set}" = set; then
3679   withval="$with_tests"
3680   cf_with_tests=$withval
3681 else
3682   cf_with_tests=yes
3683 fi;
3684 echo "$as_me:3684: result: $cf_with_tests" >&5
3685 echo "${ECHO_T}$cf_with_tests" >&6
3686
3687 echo "$as_me:3687: checking if you wish to install curses.h" >&5
3688 echo $ECHO_N "checking if you wish to install curses.h... $ECHO_C" >&6
3689
3690 # Check whether --with-curses-h or --without-curses-h was given.
3691 if test "${with_curses_h+set}" = set; then
3692   withval="$with_curses_h"
3693   with_curses_h=$withval
3694 else
3695   with_curses_h=yes
3696 fi;
3697 echo "$as_me:3697: result: $with_curses_h" >&5
3698 echo "${ECHO_T}$with_curses_h" >&6
3699
3700 modules_to_build="ncurses"
3701 test "X$cf_with_progs" != Xno && modules_to_build="$modules_to_build progs"
3702 test "X$cf_with_tack"  != Xno && modules_to_build="$modules_to_build tack"
3703 modules_to_build="$modules_to_build panel menu form"
3704
3705 test "$program_prefix" != NONE &&
3706   program_transform_name="s,^,$program_prefix,;$program_transform_name"
3707 # Use a double $ so make ignores it.
3708 test "$program_suffix" != NONE &&
3709   program_transform_name="s,\$,$program_suffix,;$program_transform_name"
3710 # Double any \ or $.  echo might interpret backslashes.
3711 # By default was `s,x,x', remove it if useless.
3712 cat <<\_ACEOF >conftest.sed
3713 s/[\\$]/&&/g;s/;s,x,x,$//
3714 _ACEOF
3715 program_transform_name=`echo $program_transform_name | sed -f conftest.sed`
3716 rm conftest.sed
3717
3718 for ac_prog in mawk gawk nawk awk
3719 do
3720   # Extract the first word of "$ac_prog", so it can be a program name with args.
3721 set dummy $ac_prog; ac_word=$2
3722 echo "$as_me:3722: checking for $ac_word" >&5
3723 echo $ECHO_N "checking for $ac_word... $ECHO_C" >&6
3724 if test "${ac_cv_prog_AWK+set}" = set; then
3725   echo $ECHO_N "(cached) $ECHO_C" >&6
3726 else
3727   if test -n "$AWK"; then
3728   ac_cv_prog_AWK="$AWK" # Let the user override the test.
3729 else
3730   ac_save_IFS=$IFS; IFS=$ac_path_separator
3731 ac_dummy="$PATH"
3732 for ac_dir in $ac_dummy; do
3733   IFS=$ac_save_IFS
3734   test -z "$ac_dir" && ac_dir=.
3735   $as_executable_p "$ac_dir/$ac_word" || continue
3736 ac_cv_prog_AWK="$ac_prog"
3737 echo "$as_me:3737: found $ac_dir/$ac_word" >&5
3738 break
3739 done
3740
3741 fi
3742 fi
3743 AWK=$ac_cv_prog_AWK
3744 if test -n "$AWK"; then
3745   echo "$as_me:3745: result: $AWK" >&5
3746 echo "${ECHO_T}$AWK" >&6
3747 else
3748   echo "$as_me:3748: result: no" >&5
3749 echo "${ECHO_T}no" >&6
3750 fi
3751
3752   test -n "$AWK" && break
3753 done
3754
3755 test -z "$AWK" && { { echo "$as_me:3755: error: No awk program found" >&5
3756 echo "$as_me: error: No awk program found" >&2;}
3757    { (exit 1); exit 1; }; }
3758
3759 # Find a good install program.  We prefer a C program (faster),
3760 # so one script is as good as another.  But avoid the broken or
3761 # incompatible versions:
3762 # SysV /etc/install, /usr/sbin/install
3763 # SunOS /usr/etc/install
3764 # IRIX /sbin/install
3765 # AIX /bin/install
3766 # AmigaOS /C/install, which installs bootblocks on floppy discs
3767 # AIX 4 /usr/bin/installbsd, which doesn't work without a -g flag
3768 # AFS /usr/afsws/bin/install, which mishandles nonexistent args
3769 # SVR4 /usr/ucb/install, which tries to use the nonexistent group "staff"
3770 # ./install, which can be erroneously created by make from ./install.sh.
3771 echo "$as_me:3771: checking for a BSD compatible install" >&5
3772 echo $ECHO_N "checking for a BSD compatible install... $ECHO_C" >&6
3773 if test -z "$INSTALL"; then
3774 if test "${ac_cv_path_install+set}" = set; then
3775   echo $ECHO_N "(cached) $ECHO_C" >&6
3776 else
3777     ac_save_IFS=$IFS; IFS=$ac_path_separator
3778   for ac_dir in $PATH; do
3779     IFS=$ac_save_IFS
3780     # Account for people who put trailing slashes in PATH elements.
3781     case $ac_dir/ in
3782     / | ./ | .// | /cC/* \
3783     | /etc/* | /usr/sbin/* | /usr/etc/* | /sbin/* | /usr/afsws/bin/* \
3784     | /usr/ucb/* ) ;;
3785     *)
3786       # OSF1 and SCO ODT 3.0 have their own names for install.
3787       # Don't use installbsd from OSF since it installs stuff as root
3788       # by default.
3789       for ac_prog in ginstall scoinst install; do
3790         if $as_executable_p "$ac_dir/$ac_prog"; then
3791           if test $ac_prog = install &&
3792             grep dspmsg "$ac_dir/$ac_prog" >/dev/null 2>&1; then
3793             # AIX install.  It has an incompatible calling convention.
3794             :
3795           elif test $ac_prog = install &&
3796             grep pwplus "$ac_dir/$ac_prog" >/dev/null 2>&1; then
3797             # program-specific install script used by HP pwplus--don't use.
3798             :
3799           else
3800             ac_cv_path_install="$ac_dir/$ac_prog -c"
3801             break 2
3802           fi
3803         fi
3804       done
3805       ;;
3806     esac
3807   done
3808
3809 fi
3810   if test "${ac_cv_path_install+set}" = set; then
3811     INSTALL=$ac_cv_path_install
3812   else
3813     # As a last resort, use the slow shell script.  We don't cache a
3814     # path for INSTALL within a source directory, because that will
3815     # break other packages using the cache if that directory is
3816     # removed, or if the path is relative.
3817     INSTALL=$ac_install_sh
3818   fi
3819 fi
3820 echo "$as_me:3820: result: $INSTALL" >&5
3821 echo "${ECHO_T}$INSTALL" >&6
3822
3823 # Use test -z because SunOS4 sh mishandles braces in ${var-val}.
3824 # It thinks the first close brace ends the variable substitution.
3825 test -z "$INSTALL_PROGRAM" && INSTALL_PROGRAM='${INSTALL}'
3826
3827 test -z "$INSTALL_SCRIPT" && INSTALL_SCRIPT='${INSTALL}'
3828
3829 test -z "$INSTALL_DATA" && INSTALL_DATA='${INSTALL} -m 644'
3830
3831 case $INSTALL in
3832 (/*)
3833         ;;
3834 (*)
3835         cf_dir=`echo "$INSTALL" | sed -e 's%/[^/]*$%%'`
3836         test -z "$cf_dir" && cf_dir=.
3837         INSTALL="`cd \"$cf_dir\" && pwd`"/"`echo "$INSTALL" | sed -e 's%^.*/%%'`"
3838         ;;
3839 esac
3840
3841 for ac_prog in lint cppcheck splint
3842 do
3843   # Extract the first word of "$ac_prog", so it can be a program name with args.
3844 set dummy $ac_prog; ac_word=$2
3845 echo "$as_me:3845: checking for $ac_word" >&5
3846 echo $ECHO_N "checking for $ac_word... $ECHO_C" >&6
3847 if test "${ac_cv_prog_LINT+set}" = set; then
3848   echo $ECHO_N "(cached) $ECHO_C" >&6
3849 else
3850   if test -n "$LINT"; then
3851   ac_cv_prog_LINT="$LINT" # Let the user override the test.
3852 else
3853   ac_save_IFS=$IFS; IFS=$ac_path_separator
3854 ac_dummy="$PATH"
3855 for ac_dir in $ac_dummy; do
3856   IFS=$ac_save_IFS
3857   test -z "$ac_dir" && ac_dir=.
3858   $as_executable_p "$ac_dir/$ac_word" || continue
3859 ac_cv_prog_LINT="$ac_prog"
3860 echo "$as_me:3860: found $ac_dir/$ac_word" >&5
3861 break
3862 done
3863
3864 fi
3865 fi
3866 LINT=$ac_cv_prog_LINT
3867 if test -n "$LINT"; then
3868   echo "$as_me:3868: result: $LINT" >&5
3869 echo "${ECHO_T}$LINT" >&6
3870 else
3871   echo "$as_me:3871: result: no" >&5
3872 echo "${ECHO_T}no" >&6
3873 fi
3874
3875   test -n "$LINT" && break
3876 done
3877
3878 case "x$LINT" in
3879 (xcppcheck|x*/cppcheck)
3880         test -z "$LINT_OPTS" && LINT_OPTS="--enable=all"
3881         ;;
3882 esac
3883
3884 echo "$as_me:3884: checking whether ln -s works" >&5
3885 echo $ECHO_N "checking whether ln -s works... $ECHO_C" >&6
3886 LN_S=$as_ln_s
3887 if test "$LN_S" = "ln -s"; then
3888   echo "$as_me:3888: result: yes" >&5
3889 echo "${ECHO_T}yes" >&6
3890 else
3891   echo "$as_me:3891: result: no, using $LN_S" >&5
3892 echo "${ECHO_T}no, using $LN_S" >&6
3893 fi
3894
3895 echo "$as_me:3895: checking if $LN_S -f options work" >&5
3896 echo $ECHO_N "checking if $LN_S -f options work... $ECHO_C" >&6
3897
3898 rm -f conf$$.src conf$$dst
3899 echo >conf$$.dst
3900 echo first >conf$$.src
3901 if $LN_S -f conf$$.src conf$$.dst 2>/dev/null; then
3902         cf_prog_ln_sf=yes
3903 else
3904         cf_prog_ln_sf=no
3905 fi
3906 rm -f conf$$.dst conf$$src
3907 echo "$as_me:3907: result: $cf_prog_ln_sf" >&5
3908 echo "${ECHO_T}$cf_prog_ln_sf" >&6
3909
3910 test "$cf_prog_ln_sf" = yes && LN_S="$LN_S -f"
3911
3912 echo "$as_me:3912: checking for long file names" >&5
3913 echo $ECHO_N "checking for long file names... $ECHO_C" >&6
3914 if test "${ac_cv_sys_long_file_names+set}" = set; then
3915   echo $ECHO_N "(cached) $ECHO_C" >&6
3916 else
3917   ac_cv_sys_long_file_names=yes
3918 # Test for long file names in all the places we know might matter:
3919 #      .                the current directory, where building will happen
3920 #      $prefix/lib      where we will be installing things
3921 #      $exec_prefix/lib likewise
3922 # eval it to expand exec_prefix.
3923 #      $TMPDIR          if set, where it might want to write temporary files
3924 # if $TMPDIR is not set:
3925 #      /tmp             where it might want to write temporary files
3926 #      /var/tmp         likewise
3927 #      /usr/tmp         likewise
3928 if test -n "$TMPDIR" && test -d "$TMPDIR" && test -w "$TMPDIR"; then
3929   ac_tmpdirs=$TMPDIR
3930 else
3931   ac_tmpdirs='/tmp /var/tmp /usr/tmp'
3932 fi
3933 for ac_dir in  . $ac_tmpdirs `eval echo "$prefix/lib" "$exec_prefix/lib"` ; do
3934   test -d "$ac_dir" || continue
3935   test -w "$ac_dir" || continue # It is less confusing to not echo anything here.
3936   ac_xdir=$ac_dir/cf$$
3937   (umask 077 && mkdir "$ac_xdir" 2>/dev/null) || continue
3938   ac_tf1=$ac_xdir/conftest9012345
3939   ac_tf2=$ac_xdir/conftest9012346
3940   (echo 1 >"$ac_tf1") 2>/dev/null
3941   (echo 2 >"$ac_tf2") 2>/dev/null
3942   ac_val=`cat "$ac_tf1" 2>/dev/null`
3943   if test ! -f "$ac_tf1" || test "$ac_val" != 1; then
3944     ac_cv_sys_long_file_names=no
3945     rm -rf "$ac_xdir" 2>/dev/null
3946     break
3947   fi
3948   rm -rf "$ac_xdir" 2>/dev/null
3949 done
3950 fi
3951 echo "$as_me:3951: result: $ac_cv_sys_long_file_names" >&5
3952 echo "${ECHO_T}$ac_cv_sys_long_file_names" >&6
3953 if test "$ac_cv_sys_long_file_names" = yes; then
3954
3955 cat >>confdefs.h <<\EOF
3956 #define HAVE_LONG_FILE_NAMES 1
3957 EOF
3958
3959 fi
3960
3961 # Provide for renaming "ncurses5-config" to "ncurses5X-config", etc., in case
3962 # of package conflict.
3963 cf_config_suffix=
3964
3965 # Check whether --with-config-suffix or --without-config-suffix was given.
3966 if test "${with_config_suffix+set}" = set; then
3967   withval="$with_config_suffix"
3968   case "x$withval" in
3969         (xyes|xno)
3970                 { echo "$as_me:3970: WARNING: expected a value for config-suffix option" >&5
3971 echo "$as_me: WARNING: expected a value for config-suffix option" >&2;}
3972                 ;;
3973         (*)     cf_config_suffix="$withval"
3974                 ;;
3975         esac
3976 fi;
3977
3978 # If we find pkg-config, check if we should install the ".pc" files.
3979
3980 echo "$as_me:3980: checking if you want to use pkg-config" >&5
3981 echo $ECHO_N "checking if you want to use pkg-config... $ECHO_C" >&6
3982
3983 # Check whether --with-pkg-config or --without-pkg-config was given.
3984 if test "${with_pkg_config+set}" = set; then
3985   withval="$with_pkg_config"
3986   cf_pkg_config=$withval
3987 else
3988   cf_pkg_config=yes
3989 fi;
3990 echo "$as_me:3990: result: $cf_pkg_config" >&5
3991 echo "${ECHO_T}$cf_pkg_config" >&6
3992
3993 case "$cf_pkg_config" in
3994 (no)
3995         PKG_CONFIG=none
3996         ;;
3997 (yes)
3998
3999 if test -n "$ac_tool_prefix"; then
4000   # Extract the first word of "${ac_tool_prefix}pkg-config", so it can be a program name with args.
4001 set dummy ${ac_tool_prefix}pkg-config; ac_word=$2
4002 echo "$as_me:4002: checking for $ac_word" >&5
4003 echo $ECHO_N "checking for $ac_word... $ECHO_C" >&6
4004 if test "${ac_cv_path_PKG_CONFIG+set}" = set; then
4005   echo $ECHO_N "(cached) $ECHO_C" >&6
4006 else
4007   case $PKG_CONFIG in
4008   [\\/]* | ?:[\\/]*)
4009   ac_cv_path_PKG_CONFIG="$PKG_CONFIG" # Let the user override the test with a path.
4010   ;;
4011   *)
4012   ac_save_IFS=$IFS; IFS=$ac_path_separator
4013 ac_dummy="$PATH"
4014 for ac_dir in $ac_dummy; do
4015   IFS=$ac_save_IFS
4016   test -z "$ac_dir" && ac_dir=.
4017   if $as_executable_p "$ac_dir/$ac_word"; then
4018    ac_cv_path_PKG_CONFIG="$ac_dir/$ac_word"
4019    echo "$as_me:4019: found $ac_dir/$ac_word" >&5
4020    break
4021 fi
4022 done
4023
4024   ;;
4025 esac
4026 fi
4027 PKG_CONFIG=$ac_cv_path_PKG_CONFIG
4028
4029 if test -n "$PKG_CONFIG"; then
4030   echo "$as_me:4030: result: $PKG_CONFIG" >&5
4031 echo "${ECHO_T}$PKG_CONFIG" >&6
4032 else
4033   echo "$as_me:4033: result: no" >&5
4034 echo "${ECHO_T}no" >&6
4035 fi
4036
4037 fi
4038 if test -z "$ac_cv_path_PKG_CONFIG"; then
4039   ac_pt_PKG_CONFIG=$PKG_CONFIG
4040   # Extract the first word of "pkg-config", so it can be a program name with args.
4041 set dummy pkg-config; ac_word=$2
4042 echo "$as_me:4042: checking for $ac_word" >&5
4043 echo $ECHO_N "checking for $ac_word... $ECHO_C" >&6
4044 if test "${ac_cv_path_ac_pt_PKG_CONFIG+set}" = set; then
4045   echo $ECHO_N "(cached) $ECHO_C" >&6
4046 else
4047   case $ac_pt_PKG_CONFIG in
4048   [\\/]* | ?:[\\/]*)
4049   ac_cv_path_ac_pt_PKG_CONFIG="$ac_pt_PKG_CONFIG" # Let the user override the test with a path.
4050   ;;
4051   *)
4052   ac_save_IFS=$IFS; IFS=$ac_path_separator
4053 ac_dummy="$PATH"
4054 for ac_dir in $ac_dummy; do
4055   IFS=$ac_save_IFS
4056   test -z "$ac_dir" && ac_dir=.
4057   if $as_executable_p "$ac_dir/$ac_word"; then
4058    ac_cv_path_ac_pt_PKG_CONFIG="$ac_dir/$ac_word"
4059    echo "$as_me:4059: found $ac_dir/$ac_word" >&5
4060    break
4061 fi
4062 done
4063
4064   test -z "$ac_cv_path_ac_pt_PKG_CONFIG" && ac_cv_path_ac_pt_PKG_CONFIG="none"
4065   ;;
4066 esac
4067 fi
4068 ac_pt_PKG_CONFIG=$ac_cv_path_ac_pt_PKG_CONFIG
4069
4070 if test -n "$ac_pt_PKG_CONFIG"; then
4071   echo "$as_me:4071: result: $ac_pt_PKG_CONFIG" >&5
4072 echo "${ECHO_T}$ac_pt_PKG_CONFIG" >&6
4073 else
4074   echo "$as_me:4074: result: no" >&5
4075 echo "${ECHO_T}no" >&6
4076 fi
4077
4078   PKG_CONFIG=$ac_pt_PKG_CONFIG
4079 else
4080   PKG_CONFIG="$ac_cv_path_PKG_CONFIG"
4081 fi
4082
4083         ;;
4084 (*)
4085         PKG_CONFIG=$withval
4086         ;;
4087 esac
4088
4089 test -z "$PKG_CONFIG" && PKG_CONFIG=none
4090 if test "$PKG_CONFIG" != none ; then
4091
4092 if test "x$prefix" != xNONE; then
4093         cf_path_syntax="$prefix"
4094 else
4095         cf_path_syntax="$ac_default_prefix"
4096 fi
4097
4098 case ".$PKG_CONFIG" in
4099 (.\$\(*\)*|.\'*\'*)
4100         ;;
4101 (..|./*|.\\*)
4102         ;;
4103 (.[a-zA-Z]:[\\/]*) # OS/2 EMX
4104         ;;
4105 (.\$\{*prefix\}*|.\$\{*dir\}*)
4106         eval PKG_CONFIG="$PKG_CONFIG"
4107         case ".$PKG_CONFIG" in
4108         (.NONE/*)
4109                 PKG_CONFIG=`echo "$PKG_CONFIG" | sed -e s%NONE%$cf_path_syntax%`
4110                 ;;
4111         esac
4112         ;;
4113 (.no|.NONE/*)
4114         PKG_CONFIG=`echo "$PKG_CONFIG" | sed -e s%NONE%$cf_path_syntax%`
4115         ;;
4116 (*)
4117         { { echo "$as_me:4117: error: expected a pathname, not \"$PKG_CONFIG\"" >&5
4118 echo "$as_me: error: expected a pathname, not \"$PKG_CONFIG\"" >&2;}
4119    { (exit 1); exit 1; }; }
4120         ;;
4121 esac
4122
4123 elif test "x$cf_pkg_config" != xno ; then
4124         { echo "$as_me:4124: WARNING: pkg-config is not installed" >&5
4125 echo "$as_me: WARNING: pkg-config is not installed" >&2;}
4126 fi
4127
4128 case "$PKG_CONFIG" in
4129 (no|none|yes)
4130         echo "$as_me:4130: checking for pkg-config library directory" >&5
4131 echo $ECHO_N "checking for pkg-config library directory... $ECHO_C" >&6
4132         ;;
4133 (*)
4134         echo "$as_me:4134: checking for $PKG_CONFIG library directory" >&5
4135 echo $ECHO_N "checking for $PKG_CONFIG library directory... $ECHO_C" >&6
4136         ;;
4137 esac
4138
4139 PKG_CONFIG_LIBDIR=no
4140
4141 # Check whether --with-pkg-config-libdir or --without-pkg-config-libdir was given.
4142 if test "${with_pkg_config_libdir+set}" = set; then
4143   withval="$with_pkg_config_libdir"
4144   PKG_CONFIG_LIBDIR=$withval
4145 else
4146   test "x$PKG_CONFIG" != xnone && PKG_CONFIG_LIBDIR=yes
4147 fi;
4148
4149 case x$PKG_CONFIG_LIBDIR in
4150 (x/*)
4151         ;;
4152 (xyes)
4153         # Look for the library directory using the same prefix as the executable
4154         if test "x$PKG_CONFIG" = xnone
4155         then
4156                 cf_path=$prefix
4157         else
4158                 cf_path=`echo "$PKG_CONFIG" | sed -e 's,/[^/]*/[^/]*$,,'`
4159         fi
4160
4161         # If you don't like using the default architecture, you have to specify the
4162         # intended library directory and corresponding compiler/linker options.
4163         #
4164         # This case allows for Debian's 2014-flavor of multiarch, along with the
4165         # most common variations before that point.  Some other variants spell the
4166         # directory differently, e.g., "pkg-config", and put it in unusual places.
4167         # pkg-config has always been poorly standardized, which is ironic...
4168         case x`(arch) 2>/dev/null` in
4169         (*64)
4170                 cf_search_path="\
4171                         $cf_path/lib/*64-linux-gnu \
4172                         $cf_path/share \
4173                         $cf_path/lib64 \
4174                         $cf_path/lib32 \
4175                         $cf_path/lib"
4176                 ;;
4177         (*)
4178                 cf_search_path="\
4179                         $cf_path/lib/*-linux-gnu \
4180                         $cf_path/share \
4181                         $cf_path/lib32 \
4182                         $cf_path/lib \
4183                         $cf_path/libdata"
4184                 ;;
4185         esac
4186
4187         test -n "$verbose" && echo "    list..." 1>&6
4188
4189 echo "${as_me:-configure}:4189: testing list... ..." 1>&5
4190
4191         for cf_config in $cf_search_path
4192         do
4193                 test -n "$verbose" && echo "    checking $cf_config/pkgconfig" 1>&6
4194
4195 echo "${as_me:-configure}:4195: testing checking $cf_config/pkgconfig ..." 1>&5
4196
4197                 if test -d "$cf_config/pkgconfig"
4198                 then
4199                         PKG_CONFIG_LIBDIR=$cf_config/pkgconfig
4200                         echo "$as_me:4200: checking done" >&5
4201 echo $ECHO_N "checking done... $ECHO_C" >&6
4202                         break
4203                 fi
4204         done
4205         ;;
4206 (*)
4207         ;;
4208 esac
4209
4210 if test "x$PKG_CONFIG_LIBDIR" != xno ; then
4211         echo "$as_me:4211: result: $PKG_CONFIG_LIBDIR" >&5
4212 echo "${ECHO_T}$PKG_CONFIG_LIBDIR" >&6
4213 fi
4214
4215 if test "x$PKG_CONFIG" != xnone
4216 then
4217         echo "$as_me:4217: checking if we should install .pc files for $PKG_CONFIG" >&5
4218 echo $ECHO_N "checking if we should install .pc files for $PKG_CONFIG... $ECHO_C" >&6
4219 else
4220         echo "$as_me:4220: checking if we should install .pc files" >&5
4221 echo $ECHO_N "checking if we should install .pc files... $ECHO_C" >&6
4222 fi
4223
4224 # Check whether --enable-pc-files or --disable-pc-files was given.
4225 if test "${enable_pc_files+set}" = set; then
4226   enableval="$enable_pc_files"
4227   enable_pc_files=$enableval
4228 else
4229   enable_pc_files=no
4230 fi;
4231 echo "$as_me:4231: result: $enable_pc_files" >&5
4232 echo "${ECHO_T}$enable_pc_files" >&6
4233
4234 if test "x$enable_pc_files" != xno
4235 then
4236         MAKE_PC_FILES=
4237         case "x$PKG_CONFIG_LIBDIR" in
4238         (xno|xyes)
4239                 { echo "$as_me:4239: WARNING: no PKG_CONFIG_LIBDIR was found" >&5
4240 echo "$as_me: WARNING: no PKG_CONFIG_LIBDIR was found" >&2;}
4241                 ;;
4242         (*)
4243
4244 if test "x$prefix" != xNONE; then
4245         cf_path_syntax="$prefix"
4246 else
4247         cf_path_syntax="$ac_default_prefix"
4248 fi
4249
4250 case ".$PKG_CONFIG_LIBDIR" in
4251 (.\$\(*\)*|.\'*\'*)
4252         ;;
4253 (..|./*|.\\*)
4254         ;;
4255 (.[a-zA-Z]:[\\/]*) # OS/2 EMX
4256         ;;
4257 (.\$\{*prefix\}*|.\$\{*dir\}*)
4258         eval PKG_CONFIG_LIBDIR="$PKG_CONFIG_LIBDIR"
4259         case ".$PKG_CONFIG_LIBDIR" in
4260         (.NONE/*)
4261                 PKG_CONFIG_LIBDIR=`echo "$PKG_CONFIG_LIBDIR" | sed -e s%NONE%$cf_path_syntax%`
4262                 ;;
4263         esac
4264         ;;
4265 (.no|.NONE/*)
4266         PKG_CONFIG_LIBDIR=`echo "$PKG_CONFIG_LIBDIR" | sed -e s%NONE%$cf_path_syntax%`
4267         ;;
4268 (*)
4269         { { echo "$as_me:4269: error: expected a pathname, not \"$PKG_CONFIG_LIBDIR\"" >&5
4270 echo "$as_me: error: expected a pathname, not \"$PKG_CONFIG_LIBDIR\"" >&2;}
4271    { (exit 1); exit 1; }; }
4272         ;;
4273 esac
4274
4275                 ;;
4276         esac
4277 else
4278         MAKE_PC_FILES="#"
4279 fi
4280
4281 if test -z "$MAKE_PC_FILES"
4282 then
4283         echo "$as_me:4283: checking for suffix to add to pc-files" >&5
4284 echo $ECHO_N "checking for suffix to add to pc-files... $ECHO_C" >&6
4285
4286 # Check whether --with-pc-suffix or --without-pc-suffix was given.
4287 if test "${with_pc_suffix+set}" = set; then
4288   withval="$with_pc_suffix"
4289   case "x$withval" in
4290         (xyes|xno)
4291                 PC_MODULE_SUFFIX=
4292                 ;;
4293         (*)     PC_MODULE_SUFFIX="$withval"
4294                 ;;
4295         esac
4296 fi;
4297         test -z "$PC_MODULE_SUFFIX" && PC_MODULE_SUFFIX=none
4298         echo "$as_me:4298: result: $PC_MODULE_SUFFIX" >&5
4299 echo "${ECHO_T}$PC_MODULE_SUFFIX" >&6
4300         test "$PC_MODULE_SUFFIX" = none && PC_MODULE_SUFFIX=
4301
4302 fi
4303
4304 echo "$as_me:4304: checking if we should assume mixed-case filenames" >&5
4305 echo $ECHO_N "checking if we should assume mixed-case filenames... $ECHO_C" >&6
4306
4307 # Check whether --enable-mixed-case or --disable-mixed-case was given.
4308 if test "${enable_mixed_case+set}" = set; then
4309   enableval="$enable_mixed_case"
4310   enable_mixedcase=$enableval
4311 else
4312   enable_mixedcase=auto
4313 fi;
4314 echo "$as_me:4314: result: $enable_mixedcase" >&5
4315 echo "${ECHO_T}$enable_mixedcase" >&6
4316 if test "$enable_mixedcase" = "auto" ; then
4317
4318 echo "$as_me:4318: checking if filesystem supports mixed-case filenames" >&5
4319 echo $ECHO_N "checking if filesystem supports mixed-case filenames... $ECHO_C" >&6
4320 if test "${cf_cv_mixedcase+set}" = set; then
4321   echo $ECHO_N "(cached) $ECHO_C" >&6
4322 else
4323
4324 if test "$cross_compiling" = yes ; then
4325         case "$target_alias" in
4326         (*-os2-emx*|*-msdosdjgpp*|*-cygwin*|*-msys*|*-mingw*|*-uwin*|darwin*)
4327                 cf_cv_mixedcase=no
4328                 ;;
4329         (*)
4330                 cf_cv_mixedcase=yes
4331                 ;;
4332         esac
4333 else
4334         rm -f conftest CONFTEST
4335         echo test >conftest
4336         if test -f CONFTEST ; then
4337                 cf_cv_mixedcase=no
4338         else
4339                 cf_cv_mixedcase=yes
4340         fi
4341         rm -f conftest CONFTEST
4342 fi
4343
4344 fi
4345 echo "$as_me:4345: result: $cf_cv_mixedcase" >&5
4346 echo "${ECHO_T}$cf_cv_mixedcase" >&6
4347 test "$cf_cv_mixedcase" = yes &&
4348 cat >>confdefs.h <<\EOF
4349 #define MIXEDCASE_FILENAMES 1
4350 EOF
4351
4352 else
4353         cf_cv_mixedcase=$enable_mixedcase
4354         if test "x$enable_mixedcase" = "xyes" ; then
4355
4356 cat >>confdefs.h <<\EOF
4357 #define MIXEDCASE_FILENAMES 1
4358 EOF
4359
4360         fi
4361 fi
4362
4363 # do this after mixed-case option (tags/TAGS is not as important as tic).
4364 echo "$as_me:4364: checking whether ${MAKE-make} sets \${MAKE}" >&5
4365 echo $ECHO_N "checking whether ${MAKE-make} sets \${MAKE}... $ECHO_C" >&6
4366 set dummy ${MAKE-make}; ac_make=`echo "$2" | sed 'y,./+-,__p_,'`
4367 if eval "test \"\${ac_cv_prog_make_${ac_make}_set+set}\" = set"; then
4368   echo $ECHO_N "(cached) $ECHO_C" >&6
4369 else
4370   cat >conftest.make <<\EOF
4371 all:
4372         @echo 'ac_maketemp="${MAKE}"'
4373 EOF
4374 # GNU make sometimes prints "make[1]: Entering...", which would confuse us.
4375 eval `${MAKE-make} -f conftest.make 2>/dev/null | grep temp=`
4376 if test -n "$ac_maketemp"; then
4377   eval ac_cv_prog_make_${ac_make}_set=yes
4378 else
4379   eval ac_cv_prog_make_${ac_make}_set=no
4380 fi
4381 rm -f conftest.make
4382 fi
4383 if eval "test \"`echo '$ac_cv_prog_make_'${ac_make}_set`\" = yes"; then
4384   echo "$as_me:4384: result: yes" >&5
4385 echo "${ECHO_T}yes" >&6
4386   SET_MAKE=
4387 else
4388   echo "$as_me:4388: result: no" >&5
4389 echo "${ECHO_T}no" >&6
4390   SET_MAKE="MAKE=${MAKE-make}"
4391 fi
4392
4393 for ac_prog in exctags ctags
4394 do
4395   # Extract the first word of "$ac_prog", so it can be a program name with args.
4396 set dummy $ac_prog; ac_word=$2
4397 echo "$as_me:4397: checking for $ac_word" >&5
4398 echo $ECHO_N "checking for $ac_word... $ECHO_C" >&6
4399 if test "${ac_cv_prog_CTAGS+set}" = set; then
4400   echo $ECHO_N "(cached) $ECHO_C" >&6
4401 else
4402   if test -n "$CTAGS"; then
4403   ac_cv_prog_CTAGS="$CTAGS" # Let the user override the test.
4404 else
4405   ac_save_IFS=$IFS; IFS=$ac_path_separator
4406 ac_dummy="$PATH"
4407 for ac_dir in $ac_dummy; do
4408   IFS=$ac_save_IFS
4409   test -z "$ac_dir" && ac_dir=.
4410   $as_executable_p "$ac_dir/$ac_word" || continue
4411 ac_cv_prog_CTAGS="$ac_prog"
4412 echo "$as_me:4412: found $ac_dir/$ac_word" >&5
4413 break
4414 done
4415
4416 fi
4417 fi
4418 CTAGS=$ac_cv_prog_CTAGS
4419 if test -n "$CTAGS"; then
4420   echo "$as_me:4420: result: $CTAGS" >&5
4421 echo "${ECHO_T}$CTAGS" >&6
4422 else
4423   echo "$as_me:4423: result: no" >&5
4424 echo "${ECHO_T}no" >&6
4425 fi
4426
4427   test -n "$CTAGS" && break
4428 done
4429
4430 for ac_prog in exetags etags
4431 do
4432   # Extract the first word of "$ac_prog", so it can be a program name with args.
4433 set dummy $ac_prog; ac_word=$2
4434 echo "$as_me:4434: checking for $ac_word" >&5
4435 echo $ECHO_N "checking for $ac_word... $ECHO_C" >&6
4436 if test "${ac_cv_prog_ETAGS+set}" = set; then
4437   echo $ECHO_N "(cached) $ECHO_C" >&6
4438 else
4439   if test -n "$ETAGS"; then
4440   ac_cv_prog_ETAGS="$ETAGS" # Let the user override the test.
4441 else
4442   ac_save_IFS=$IFS; IFS=$ac_path_separator
4443 ac_dummy="$PATH"
4444 for ac_dir in $ac_dummy; do
4445   IFS=$ac_save_IFS
4446   test -z "$ac_dir" && ac_dir=.
4447   $as_executable_p "$ac_dir/$ac_word" || continue
4448 ac_cv_prog_ETAGS="$ac_prog"
4449 echo "$as_me:4449: found $ac_dir/$ac_word" >&5
4450 break
4451 done
4452
4453 fi
4454 fi
4455 ETAGS=$ac_cv_prog_ETAGS
4456 if test -n "$ETAGS"; then
4457   echo "$as_me:4457: result: $ETAGS" >&5
4458 echo "${ECHO_T}$ETAGS" >&6
4459 else
4460   echo "$as_me:4460: result: no" >&5
4461 echo "${ECHO_T}no" >&6
4462 fi
4463
4464   test -n "$ETAGS" && break
4465 done
4466
4467 # Extract the first word of "${CTAGS:-ctags}", so it can be a program name with args.
4468 set dummy ${CTAGS:-ctags}; ac_word=$2
4469 echo "$as_me:4469: checking for $ac_word" >&5
4470 echo $ECHO_N "checking for $ac_word... $ECHO_C" >&6
4471 if test "${ac_cv_prog_MAKE_LOWER_TAGS+set}" = set; then
4472   echo $ECHO_N "(cached) $ECHO_C" >&6
4473 else
4474   if test -n "$MAKE_LOWER_TAGS"; then
4475   ac_cv_prog_MAKE_LOWER_TAGS="$MAKE_LOWER_TAGS" # Let the user override the test.
4476 else
4477   ac_save_IFS=$IFS; IFS=$ac_path_separator
4478 ac_dummy="$PATH"
4479 for ac_dir in $ac_dummy; do
4480   IFS=$ac_save_IFS
4481   test -z "$ac_dir" && ac_dir=.
4482   $as_executable_p "$ac_dir/$ac_word" || continue
4483 ac_cv_prog_MAKE_LOWER_TAGS="yes"
4484 echo "$as_me:4484: found $ac_dir/$ac_word" >&5
4485 break
4486 done
4487
4488   test -z "$ac_cv_prog_MAKE_LOWER_TAGS" && ac_cv_prog_MAKE_LOWER_TAGS="no"
4489 fi
4490 fi
4491 MAKE_LOWER_TAGS=$ac_cv_prog_MAKE_LOWER_TAGS
4492 if test -n "$MAKE_LOWER_TAGS"; then
4493   echo "$as_me:4493: result: $MAKE_LOWER_TAGS" >&5
4494 echo "${ECHO_T}$MAKE_LOWER_TAGS" >&6
4495 else
4496   echo "$as_me:4496: result: no" >&5
4497 echo "${ECHO_T}no" >&6
4498 fi
4499
4500 if test "$cf_cv_mixedcase" = yes ; then
4501         # Extract the first word of "${ETAGS:-etags}", so it can be a program name with args.
4502 set dummy ${ETAGS:-etags}; ac_word=$2
4503 echo "$as_me:4503: checking for $ac_word" >&5
4504 echo $ECHO_N "checking for $ac_word... $ECHO_C" >&6
4505 if test "${ac_cv_prog_MAKE_UPPER_TAGS+set}" = set; then
4506   echo $ECHO_N "(cached) $ECHO_C" >&6
4507 else
4508   if test -n "$MAKE_UPPER_TAGS"; then
4509   ac_cv_prog_MAKE_UPPER_TAGS="$MAKE_UPPER_TAGS" # Let the user override the test.
4510 else
4511   ac_save_IFS=$IFS; IFS=$ac_path_separator
4512 ac_dummy="$PATH"
4513 for ac_dir in $ac_dummy; do
4514   IFS=$ac_save_IFS
4515   test -z "$ac_dir" && ac_dir=.
4516   $as_executable_p "$ac_dir/$ac_word" || continue
4517 ac_cv_prog_MAKE_UPPER_TAGS="yes"
4518 echo "$as_me:4518: found $ac_dir/$ac_word" >&5
4519 break
4520 done
4521
4522   test -z "$ac_cv_prog_MAKE_UPPER_TAGS" && ac_cv_prog_MAKE_UPPER_TAGS="no"
4523 fi
4524 fi
4525 MAKE_UPPER_TAGS=$ac_cv_prog_MAKE_UPPER_TAGS
4526 if test -n "$MAKE_UPPER_TAGS"; then
4527   echo "$as_me:4527: result: $MAKE_UPPER_TAGS" >&5
4528 echo "${ECHO_T}$MAKE_UPPER_TAGS" >&6
4529 else
4530   echo "$as_me:4530: result: no" >&5
4531 echo "${ECHO_T}no" >&6
4532 fi
4533
4534 else
4535         MAKE_UPPER_TAGS=no
4536 fi
4537
4538 if test "$MAKE_UPPER_TAGS" = yes ; then
4539         MAKE_UPPER_TAGS=
4540 else
4541         MAKE_UPPER_TAGS="#"
4542 fi
4543
4544 if test "$MAKE_LOWER_TAGS" = yes ; then
4545         MAKE_LOWER_TAGS=
4546 else
4547         MAKE_LOWER_TAGS="#"
4548 fi
4549
4550 echo "$as_me:4550: checking for makeflags variable" >&5
4551 echo $ECHO_N "checking for makeflags variable... $ECHO_C" >&6
4552 if test "${cf_cv_makeflags+set}" = set; then
4553   echo $ECHO_N "(cached) $ECHO_C" >&6
4554 else
4555
4556         cf_cv_makeflags=''
4557         for cf_option in '-${MAKEFLAGS}' '${MFLAGS}'
4558         do
4559                 cat >cf_makeflags.tmp <<CF_EOF
4560 SHELL = $SHELL
4561 all :
4562         @ echo '.$cf_option'
4563 CF_EOF
4564                 cf_result=`${MAKE:-make} -k -f cf_makeflags.tmp 2>/dev/null | ${FGREP-fgrep} -v "ing directory" | sed -e 's,[   ]*$,,'`
4565                 case "$cf_result" in
4566                 (.*k|.*kw)
4567                         cf_result="`${MAKE:-make} -k -f cf_makeflags.tmp CC=cc 2>/dev/null`"
4568                         case "$cf_result" in
4569                         (.*CC=*)        cf_cv_makeflags=
4570                                 ;;
4571                         (*)     cf_cv_makeflags=$cf_option
4572                                 ;;
4573                         esac
4574                         break
4575                         ;;
4576                 (.-)
4577                         ;;
4578                 (*)
4579
4580 echo "${as_me:-configure}:4580: testing given option \"$cf_option\",no match \"$cf_result\" ..." 1>&5
4581
4582                         ;;
4583                 esac
4584         done
4585         rm -f cf_makeflags.tmp
4586
4587 fi
4588 echo "$as_me:4588: result: $cf_cv_makeflags" >&5
4589 echo "${ECHO_T}$cf_cv_makeflags" >&6
4590
4591 if test -n "$ac_tool_prefix"; then
4592   # Extract the first word of "${ac_tool_prefix}ranlib", so it can be a program name with args.
4593 set dummy ${ac_tool_prefix}ranlib; ac_word=$2
4594 echo "$as_me:4594: checking for $ac_word" >&5
4595 echo $ECHO_N "checking for $ac_word... $ECHO_C" >&6
4596 if test "${ac_cv_prog_RANLIB+set}" = set; then
4597   echo $ECHO_N "(cached) $ECHO_C" >&6
4598 else
4599   if test -n "$RANLIB"; then
4600   ac_cv_prog_RANLIB="$RANLIB" # Let the user override the test.
4601 else
4602   ac_save_IFS=$IFS; IFS=$ac_path_separator
4603 ac_dummy="$PATH"
4604 for ac_dir in $ac_dummy; do
4605   IFS=$ac_save_IFS
4606   test -z "$ac_dir" && ac_dir=.
4607   $as_executable_p "$ac_dir/$ac_word" || continue
4608 ac_cv_prog_RANLIB="${ac_tool_prefix}ranlib"
4609 echo "$as_me:4609: found $ac_dir/$ac_word" >&5
4610 break
4611 done
4612
4613 fi
4614 fi
4615 RANLIB=$ac_cv_prog_RANLIB
4616 if test -n "$RANLIB"; then
4617   echo "$as_me:4617: result: $RANLIB" >&5
4618 echo "${ECHO_T}$RANLIB" >&6
4619 else
4620   echo "$as_me:4620: result: no" >&5
4621 echo "${ECHO_T}no" >&6
4622 fi
4623
4624 fi
4625 if test -z "$ac_cv_prog_RANLIB"; then
4626   ac_ct_RANLIB=$RANLIB
4627   # Extract the first word of "ranlib", so it can be a program name with args.
4628 set dummy ranlib; ac_word=$2
4629 echo "$as_me:4629: checking for $ac_word" >&5
4630 echo $ECHO_N "checking for $ac_word... $ECHO_C" >&6
4631 if test "${ac_cv_prog_ac_ct_RANLIB+set}" = set; then
4632   echo $ECHO_N "(cached) $ECHO_C" >&6
4633 else
4634   if test -n "$ac_ct_RANLIB"; then
4635   ac_cv_prog_ac_ct_RANLIB="$ac_ct_RANLIB" # Let the user override the test.
4636 else
4637   ac_save_IFS=$IFS; IFS=$ac_path_separator
4638 ac_dummy="$PATH"
4639 for ac_dir in $ac_dummy; do
4640   IFS=$ac_save_IFS
4641   test -z "$ac_dir" && ac_dir=.
4642   $as_executable_p "$ac_dir/$ac_word" || continue
4643 ac_cv_prog_ac_ct_RANLIB="ranlib"
4644 echo "$as_me:4644: found $ac_dir/$ac_word" >&5
4645 break
4646 done
4647
4648   test -z "$ac_cv_prog_ac_ct_RANLIB" && ac_cv_prog_ac_ct_RANLIB="':'"
4649 fi
4650 fi
4651 ac_ct_RANLIB=$ac_cv_prog_ac_ct_RANLIB
4652 if test -n "$ac_ct_RANLIB"; then
4653   echo "$as_me:4653: result: $ac_ct_RANLIB" >&5
4654 echo "${ECHO_T}$ac_ct_RANLIB" >&6
4655 else
4656   echo "$as_me:4656: result: no" >&5
4657 echo "${ECHO_T}no" >&6
4658 fi
4659
4660   RANLIB=$ac_ct_RANLIB
4661 else
4662   RANLIB="$ac_cv_prog_RANLIB"
4663 fi
4664
4665 if test -n "$ac_tool_prefix"; then
4666   # Extract the first word of "${ac_tool_prefix}ld", so it can be a program name with args.
4667 set dummy ${ac_tool_prefix}ld; ac_word=$2
4668 echo "$as_me:4668: checking for $ac_word" >&5
4669 echo $ECHO_N "checking for $ac_word... $ECHO_C" >&6
4670 if test "${ac_cv_prog_LD+set}" = set; then
4671   echo $ECHO_N "(cached) $ECHO_C" >&6
4672 else
4673   if test -n "$LD"; then
4674   ac_cv_prog_LD="$LD" # Let the user override the test.
4675 else
4676   ac_save_IFS=$IFS; IFS=$ac_path_separator
4677 ac_dummy="$PATH"
4678 for ac_dir in $ac_dummy; do
4679   IFS=$ac_save_IFS
4680   test -z "$ac_dir" && ac_dir=.
4681   $as_executable_p "$ac_dir/$ac_word" || continue
4682 ac_cv_prog_LD="${ac_tool_prefix}ld"
4683 echo "$as_me:4683: found $ac_dir/$ac_word" >&5
4684 break
4685 done
4686
4687 fi
4688 fi
4689 LD=$ac_cv_prog_LD
4690 if test -n "$LD"; then
4691   echo "$as_me:4691: result: $LD" >&5
4692 echo "${ECHO_T}$LD" >&6
4693 else
4694   echo "$as_me:4694: result: no" >&5
4695 echo "${ECHO_T}no" >&6
4696 fi
4697
4698 fi
4699 if test -z "$ac_cv_prog_LD"; then
4700   ac_ct_LD=$LD
4701   # Extract the first word of "ld", so it can be a program name with args.
4702 set dummy ld; ac_word=$2
4703 echo "$as_me:4703: checking for $ac_word" >&5
4704 echo $ECHO_N "checking for $ac_word... $ECHO_C" >&6
4705 if test "${ac_cv_prog_ac_ct_LD+set}" = set; then
4706   echo $ECHO_N "(cached) $ECHO_C" >&6
4707 else
4708   if test -n "$ac_ct_LD"; then
4709   ac_cv_prog_ac_ct_LD="$ac_ct_LD" # Let the user override the test.
4710 else
4711   ac_save_IFS=$IFS; IFS=$ac_path_separator
4712 ac_dummy="$PATH"
4713 for ac_dir in $ac_dummy; do
4714   IFS=$ac_save_IFS
4715   test -z "$ac_dir" && ac_dir=.
4716   $as_executable_p "$ac_dir/$ac_word" || continue
4717 ac_cv_prog_ac_ct_LD="ld"
4718 echo "$as_me:4718: found $ac_dir/$ac_word" >&5
4719 break
4720 done
4721
4722   test -z "$ac_cv_prog_ac_ct_LD" && ac_cv_prog_ac_ct_LD="ld"
4723 fi
4724 fi
4725 ac_ct_LD=$ac_cv_prog_ac_ct_LD
4726 if test -n "$ac_ct_LD"; then
4727   echo "$as_me:4727: result: $ac_ct_LD" >&5
4728 echo "${ECHO_T}$ac_ct_LD" >&6
4729 else
4730   echo "$as_me:4730: result: no" >&5
4731 echo "${ECHO_T}no" >&6
4732 fi
4733
4734   LD=$ac_ct_LD
4735 else
4736   LD="$ac_cv_prog_LD"
4737 fi
4738
4739 if test -n "$ac_tool_prefix"; then
4740   # Extract the first word of "${ac_tool_prefix}ar", so it can be a program name with args.
4741 set dummy ${ac_tool_prefix}ar; ac_word=$2
4742 echo "$as_me:4742: checking for $ac_word" >&5
4743 echo $ECHO_N "checking for $ac_word... $ECHO_C" >&6
4744 if test "${ac_cv_prog_AR+set}" = set; then
4745   echo $ECHO_N "(cached) $ECHO_C" >&6
4746 else
4747   if test -n "$AR"; then
4748   ac_cv_prog_AR="$AR" # Let the user override the test.
4749 else
4750   ac_save_IFS=$IFS; IFS=$ac_path_separator
4751 ac_dummy="$PATH"
4752 for ac_dir in $ac_dummy; do
4753   IFS=$ac_save_IFS
4754   test -z "$ac_dir" && ac_dir=.
4755   $as_executable_p "$ac_dir/$ac_word" || continue
4756 ac_cv_prog_AR="${ac_tool_prefix}ar"
4757 echo "$as_me:4757: found $ac_dir/$ac_word" >&5
4758 break
4759 done
4760
4761 fi
4762 fi
4763 AR=$ac_cv_prog_AR
4764 if test -n "$AR"; then
4765   echo "$as_me:4765: result: $AR" >&5
4766 echo "${ECHO_T}$AR" >&6
4767 else
4768   echo "$as_me:4768: result: no" >&5
4769 echo "${ECHO_T}no" >&6
4770 fi
4771
4772 fi
4773 if test -z "$ac_cv_prog_AR"; then
4774   ac_ct_AR=$AR
4775   # Extract the first word of "ar", so it can be a program name with args.
4776 set dummy ar; ac_word=$2
4777 echo "$as_me:4777: checking for $ac_word" >&5
4778 echo $ECHO_N "checking for $ac_word... $ECHO_C" >&6
4779 if test "${ac_cv_prog_ac_ct_AR+set}" = set; then
4780   echo $ECHO_N "(cached) $ECHO_C" >&6
4781 else
4782   if test -n "$ac_ct_AR"; then
4783   ac_cv_prog_ac_ct_AR="$ac_ct_AR" # Let the user override the test.
4784 else
4785   ac_save_IFS=$IFS; IFS=$ac_path_separator
4786 ac_dummy="$PATH"
4787 for ac_dir in $ac_dummy; do
4788   IFS=$ac_save_IFS
4789   test -z "$ac_dir" && ac_dir=.
4790   $as_executable_p "$ac_dir/$ac_word" || continue
4791 ac_cv_prog_ac_ct_AR="ar"
4792 echo "$as_me:4792: found $ac_dir/$ac_word" >&5
4793 break
4794 done
4795
4796   test -z "$ac_cv_prog_ac_ct_AR" && ac_cv_prog_ac_ct_AR="ar"
4797 fi
4798 fi
4799 ac_ct_AR=$ac_cv_prog_ac_ct_AR
4800 if test -n "$ac_ct_AR"; then
4801   echo "$as_me:4801: result: $ac_ct_AR" >&5
4802 echo "${ECHO_T}$ac_ct_AR" >&6
4803 else
4804   echo "$as_me:4804: result: no" >&5
4805 echo "${ECHO_T}no" >&6
4806 fi
4807
4808   AR=$ac_ct_AR
4809 else
4810   AR="$ac_cv_prog_AR"
4811 fi
4812
4813 if test -n "$ac_tool_prefix"; then
4814   # Extract the first word of "${ac_tool_prefix}nm", so it can be a program name with args.
4815 set dummy ${ac_tool_prefix}nm; ac_word=$2
4816 echo "$as_me:4816: checking for $ac_word" >&5
4817 echo $ECHO_N "checking for $ac_word... $ECHO_C" >&6
4818 if test "${ac_cv_prog_NM+set}" = set; then
4819   echo $ECHO_N "(cached) $ECHO_C" >&6
4820 else
4821   if test -n "$NM"; then
4822   ac_cv_prog_NM="$NM" # Let the user override the test.
4823 else
4824   ac_save_IFS=$IFS; IFS=$ac_path_separator
4825 ac_dummy="$PATH"
4826 for ac_dir in $ac_dummy; do
4827   IFS=$ac_save_IFS
4828   test -z "$ac_dir" && ac_dir=.
4829   $as_executable_p "$ac_dir/$ac_word" || continue
4830 ac_cv_prog_NM="${ac_tool_prefix}nm"
4831 echo "$as_me:4831: found $ac_dir/$ac_word" >&5
4832 break
4833 done
4834
4835 fi
4836 fi
4837 NM=$ac_cv_prog_NM
4838 if test -n "$NM"; then
4839   echo "$as_me:4839: result: $NM" >&5
4840 echo "${ECHO_T}$NM" >&6
4841 else
4842   echo "$as_me:4842: result: no" >&5
4843 echo "${ECHO_T}no" >&6
4844 fi