Ada95/configure

   1 #! /bin/sh
   2 # From configure.in Revision: 1.85 .
   3 # Guess values for system-dependent variables and create Makefiles.
   4 # Generated by Autoconf 2.52.20210509.
   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="gen/gen.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
 618 #
 619 # Report the --help message.
 620 #
 621 if test "$ac_init_help" = "long"; then
 622   # Omit some internal or obsolete options to make the list less imposing.
 623   # This message is too long to be a string in the A/UX 3.1 sh.
 624   cat <<EOF
 625 \`configure' configures this package to adapt to many kinds of systems.
 626
 627 Usage: $0 [OPTION]... [VAR=VALUE]...
 628
 629 To assign environment variables (e.g., CC, CFLAGS...), specify them as
 630 VAR=VALUE.  See below for descriptions of some of the useful variables.
 631
 632 Defaults for the options are specified in brackets.
 633
 634 Configuration:
 635   -h, --help              display this help and exit
 636       --help=short        display options specific to this package
 637       --help=recursive    display the short help of all the included packages
 638   -V, --version           display version information and exit
 639   -q, --quiet, --silent   do not print \`checking...' messages
 640       --cache-file=FILE   cache test results in FILE [disabled]
 641   -C, --config-cache      alias for \`--cache-file=config.cache'
 642   -n, --no-create         do not create output files
 643       --srcdir=DIR        find the sources in DIR [configure dir or \`..']
 644
 645 EOF
 646
 647   cat <<EOF
 648 Installation directories:
 649   --prefix=PREFIX         install architecture-independent files in PREFIX
 650                           [$ac_default_prefix]
 651   --exec-prefix=EPREFIX   install architecture-dependent files in EPREFIX
 652                           [PREFIX]
 653
 654 By default, \`make install' will install all the files in
 655 \`$ac_default_prefix/bin', \`$ac_default_prefix/lib' etc.  You can specify
 656 an installation prefix other than \`$ac_default_prefix' using \`--prefix',
 657 for instance \`--prefix=\$HOME'.
 658
 659 For better control, use the options below.
 660
 661 Fine tuning of the installation directories:
 662   --bindir=DIR            user executables [EPREFIX/bin]
 663   --sbindir=DIR           system admin executables [EPREFIX/sbin]
 664   --libexecdir=DIR        program executables [EPREFIX/libexec]
 665   --datarootdir=DIR       read-only architecture-independent data [PREFIX/share]
 666   --datadir=DIR           read-only architecture-independent data [DATAROOTDIR]
 667   --sysconfdir=DIR        read-only single-machine data [PREFIX/etc]
 668   --sharedstatedir=DIR    modifiable architecture-independent data [PREFIX/com]
 669   --localstatedir=DIR     modifiable single-machine data [PREFIX/var]
 670   --runstatedir=DIR       extra definition of runtime data [LOCALSTATEDIR/run]
 671   --libdir=DIR            object code libraries [EPREFIX/lib]
 672   --includedir=DIR        C header files [PREFIX/include]
 673   --oldincludedir=DIR     C header files for non-gcc [/usr/include]
 674   --infodir=DIR           info documentation [DATAROOTDIR/info]
 675   --mandir=DIR            man documentation [DATAROOTDIR/man]
 676 EOF
 677
 678   cat <<\EOF
 679
 680 Program names:
 681   --program-prefix=PREFIX            prepend PREFIX to installed program names
 682   --program-suffix=SUFFIX            append SUFFIX to installed program names
 683   --program-transform-name=PROGRAM   run sed PROGRAM on installed program names
 684
 685 System types:
 686   --build=BUILD           configure for building on BUILD [guessed]
 687   --host=HOST       build programs to run on HOST [BUILD]
 688   --target=TARGET   configure for building compilers for TARGET [HOST]
 689 EOF
 690 fi
 691
 692 if test -n "$ac_init_help"; then
 693
 694   cat <<\EOF
 695
 696 Optional Packages:
 697   --with-PACKAGE[=ARG]    use PACKAGE [ARG=yes]
 698   --without-PACKAGE       do not use PACKAGE (same as --with-PACKAGE=no)
 699
 700 Optional Features:
 701   --disable-FEATURE       do not include FEATURE (same as --enable-FEATURE=no)
 702   --enable-FEATURE[=ARG]  include FEATURE [ARG=yes]
 703
 704 General Options:
 705   --with-system-type=XXX  test: override derived host system-type
 706   --disable-stripping     do not strip (debug info) installed executables
 707   --with-pkg-config{=path} enable/disable use of pkg-config
 708   --with-pkg-config-libdir=XXX use given directory for installing pc-files
 709   --without-tests         suppress build with test-programs
 710   --enable-mixed-case     tic should assume mixed-case filenames
 711   --with-install-prefix   prefixes actual install-location ($DESTDIR)
 712 Build-Tools Needed to Compile Temporary Applications for Cross-compiling:
 713   --with-build-cc=XXX     the build C compiler ($BUILD_CC)
 714   --with-build-cpp=XXX    the build C preprocessor ($BUILD_CPP)
 715   --with-build-cflags=XXX the build C compiler-flags ($BUILD_CFLAGS)
 716   --with-build-cppflags=XXX the build C preprocessor-flags ($BUILD_CPPFLAGS)
 717   --with-build-ldflags=XXX the build linker-flags ($BUILD_LDFLAGS)
 718   --with-build-libs=XXX   the build libraries (${BUILD_LIBS})
 719 Options to Specify the Libraries Built/Used:
 720   --with-shared           generate shared C-objects (needed for --with-ada-sharedlib)
 721   --with-curses-dir=DIR   directory in which (n)curses is installed
 722   --enable-widec          compile with wide-char/UTF-8 code
 723   --with-lib-prefix       override library-prefix
 724   --with-shlib-version=X  Specify rel or abi version for shared libs
 725   --enable-rpath-link     link sample programs with rpath option
 726 Fine-Tuning Your Configuration:
 727   --enable-broken_linker  compile with broken-linker support code
 728   --disable-largefile     omit support for large files
 729   --with-rcs-ids          compile-in RCS identifiers
 730 Extensions:
 731   --disable-ext-funcs     disable function-extensions
 732   --enable-const          compile with extra/non-standard const
 733 Development Code:
 734   --without-develop       disable development options
 735 Experimental Code:
 736   --with-pthread          use POSIX thread library
 737   --enable-weak-symbols   enable weak-symbols for pthreads
 738   --enable-reentrant      compile with experimental reentrant code
 739   --with-wrap-prefix=XXX  override prefix used for public variables
 740 Testing/development Options:
 741   --disable-echo          do not display "compiling" commands
 742   --enable-warnings       test: turn on gcc compiler warnings
 743   --enable-stdnoreturn    enable C11 _Noreturn feature for diagnostics
 744   --enable-assertions     test: turn on generation of assertion code
 745   --enable-expanded       test: generate functions for certain macros
 746   --disable-macros        test: use functions rather than macros
 747   --with-trace            test: add trace() function to all models of ncurses
 748   --disable-gnat-projects test: disable GNAT projects even if usable
 749 Ada95 Binding Options:
 750   --with-ada-compiler=CMD specify Ada95 compiler command (default gnatmake)
 751   --with-ada-include=DIR  Ada includes are in DIR (default: PREFIX/share/ada/adainclude)
 752   --with-ada-objects=DIR  Ada objects are in DIR (default: PREFIX/lib/ada/adalib)
 753   --with-ada-sharedlib=soname build shared-library (requires GNAT projects)
 754   --with-ada-libname=XXX  override default Ada library-name
 755
 756 Some influential environment variables:
 757   CC          C compiler command
 758   CFLAGS      C compiler flags
 759   LDFLAGS     linker flags, e.g. -L<lib dir> if you have libraries in a
 760               nonstandard directory <lib dir>
 761   CPPFLAGS    C/C++ preprocessor flags, e.g. -I<include dir> if you have
 762               headers in a nonstandard directory <include dir>
 763   CPP         C preprocessor
 764
 765 Use these variables to override the choices made by `configure' or to help
 766 it to find libraries and programs with nonstandard names/locations.
 767
 768 EOF
 769 fi
 770
 771 if test "$ac_init_help" = "recursive"; then
 772   # If there are subdirs, report their specific --help.
 773   ac_popdir=`pwd`
 774   for ac_subdir in : $ac_subdirs_all; do test "x$ac_subdir" = x: && continue
 775     cd "$ac_subdir"
 776     # A "../" for each directory in /$ac_subdir.
 777     ac_dots=`echo "$ac_subdir" |
 778              sed 's,^\./,,;s,[^/]$,&/,;s,[^/]*/,../,g'`
 779
 780     case "$srcdir" in
 781     .) # No --srcdir option.  We are building in place.
 782       ac_sub_srcdir="$srcdir" ;;
 783     [\\/]* | ?:[\\/]* ) # Absolute path.
 784       ac_sub_srcdir="$srcdir/$ac_subdir" ;;
 785     *) # Relative path.
 786       ac_sub_srcdir="$ac_dots$srcdir/$ac_subdir" ;;
 787     esac
 788
 789     # Check for guested configure; otherwise get Cygnus style configure.
 790     if test -f "$ac_sub_srcdir/configure.gnu"; then
 791       echo
 792       $SHELL "$ac_sub_srcdir/configure.gnu" --help=recursive
 793     elif test -f "$ac_sub_srcdir/configure"; then
 794       echo
 795       $SHELL "$ac_sub_srcdir/configure" --help=recursive
 796     elif test -f "$ac_sub_srcdir/configure.ac" ||
 797            test -f "$ac_sub_srcdir/configure.in"; then
 798       echo
 799       "$ac_configure" --help
 800     else
 801       echo "$as_me: WARNING: no configuration information is in $ac_subdir" >&2
 802     fi
 803     cd "$ac_popdir"
 804   done
 805 fi
 806
 807 test -n "$ac_init_help" && exit 0
 808 if "$ac_init_version"; then
 809   cat <<\EOF
 810
 811 Copyright 2003-2020,2021        Thomas E. Dickey
 812 Copyright 1992, 1993, 1994, 1995, 1996, 1998, 1999, 2000, 2001
 813 Free Software Foundation, Inc.
 814 This configure script is free software; the Free Software Foundation
 815 gives unlimited permission to copy, distribute and modify it.
 816 EOF
 817   exit 0
 818 fi
 819 exec 5>config.log
 820 cat >&5 <<EOF
 821 This file contains any messages produced by compilers while
 822 running configure, to aid debugging if configure makes a mistake.
 823
 824 It was created by $as_me, which was
 825 generated by GNU Autoconf 2.52.20210509.  Invocation command line was
 826
 827   $ $0 $@
 828
 829 EOF
 830 {
 831 cat <<_ASUNAME
 832 ## ---------- ##
 833 ## Platform.  ##
 834 ## ---------- ##
 835
 836 hostname = `(hostname || uname -n) 2>/dev/null | sed 1q`
 837 uname -m = `(uname -m) 2>/dev/null || echo unknown`
 838 uname -r = `(uname -r) 2>/dev/null || echo unknown`
 839 uname -s = `(uname -s) 2>/dev/null || echo unknown`
 840 uname -v = `(uname -v) 2>/dev/null || echo unknown`
 841
 842 /usr/bin/uname -p = `(/usr/bin/uname -p) 2>/dev/null || echo unknown`
 843 /bin/uname -X     = `(/bin/uname -X) 2>/dev/null     || echo unknown`
 844
 845 /bin/arch              = `(/bin/arch) 2>/dev/null              || echo unknown`
 846 /usr/bin/arch -k       = `(/usr/bin/arch -k) 2>/dev/null       || echo unknown`
 847 /usr/convex/getsysinfo = `(/usr/convex/getsysinfo) 2>/dev/null || echo unknown`
 848 hostinfo               = `(hostinfo) 2>/dev/null               || echo unknown`
 849 /bin/machine           = `(/bin/machine) 2>/dev/null           || echo unknown`
 850 /usr/bin/oslevel       = `(/usr/bin/oslevel) 2>/dev/null       || echo unknown`
 851 /bin/universe          = `(/bin/universe) 2>/dev/null          || echo unknown`
 852
 853 PATH = $PATH
 854
 855 _ASUNAME
 856 } >&5
 857
 858 cat >&5 <<EOF
 859 ## ------------ ##
 860 ## Core tests.  ##
 861 ## ------------ ##
 862
 863 EOF
 864
 865 # Keep a trace of the command line.
 866 # Strip out --no-create and --no-recursion so they do not pile up.
 867 # Also quote any args containing shell meta-characters.
 868 ac_configure_args=
 869 ac_sep=
 870 for ac_arg
 871 do
 872   case "$ac_arg" in
 873   -no-create | --no-create | --no-creat | --no-crea | --no-cre \
 874   | --no-cr | --no-c) ;;
 875   -no-recursion | --no-recursion | --no-recursio | --no-recursi \
 876   | --no-recurs | --no-recur | --no-recu | --no-rec | --no-re | --no-r) ;;
 877   *" "*|*"      "*|*[\[\]\~\#\$\^\&\*\(\)\{\}\\\|\;\<\>\?\"\']*)
 878     ac_arg=`echo "$ac_arg" | sed "s/'/'\\\\\\\\''/g"`
 879     ac_configure_args="$ac_configure_args$ac_sep'$ac_arg'"
 880     ac_sep=" " ;;
 881   *) ac_configure_args="$ac_configure_args$ac_sep$ac_arg"
 882      ac_sep=" " ;;
 883   esac
 884   # Get rid of the leading space.
 885 done
 886
 887 # When interrupted or exit'd, cleanup temporary files, and complete
 888 # config.log.  We remove comments because anyway the quotes in there
 889 # would cause problems or look ugly.
 890 trap 'exit_status=$?
 891   # Save into config.log some information that might help in debugging.
 892   echo >&5
 893   echo "## ----------------- ##" >&5
 894   echo "## Cache variables.  ##" >&5
 895   echo "## ----------------- ##" >&5
 896   echo >&5
 897   # The following way of writing the cache mishandles newlines in values,
 898 {
 899   (set) 2>&1 |
 900     case `(ac_space='"'"' '"'"'; set | grep ac_space) 2>&1` in
 901     *ac_space=\ *)
 902       sed -n \
 903         "s/'"'"'/'"'"'\\\\'"'"''"'"'/g;
 904           s/^\\([_$as_cr_alnum]*_cv_[_$as_cr_alnum]*\\)=\\(.*\\)/\\1='"'"'\\2'"'"'/p"
 905       ;;
 906     *)
 907       sed -n \
 908         "s/^\\([_$as_cr_alnum]*_cv_[_$as_cr_alnum]*\\)=\\(.*\\)/\\1=\\2/p"
 909       ;;
 910     esac;
 911 } >&5
 912   sed "/^$/d" confdefs.h >conftest.log
 913   if test -s conftest.log; then
 914     echo >&5
 915     echo "## ------------ ##" >&5
 916     echo "## confdefs.h.  ##" >&5
 917     echo "## ------------ ##" >&5
 918     echo >&5
 919     cat conftest.log >&5
 920   fi
 921   (echo; echo) >&5
 922   test "$ac_signal" != 0 &&
 923     echo "$as_me: caught signal $ac_signal" >&5
 924   echo "$as_me: exit $exit_status" >&5
 925   rm -rf conftest* confdefs* core core.* *.core conf$$* $ac_clean_files &&
 926     exit $exit_status
 927      ' 0
 928 for ac_signal in 1 2 13 15; do
 929   trap 'ac_signal='$ac_signal'; { (exit 1); exit 1; }' "$ac_signal"
 930 done
 931 ac_signal=0
 932
 933 # confdefs.h avoids OS command line length limits that DEFS can exceed.
 934 rm -rf conftest* confdefs.h
 935 # AIX cpp loses on an empty file, so make sure it contains at least a newline.
 936 echo >confdefs.h
 937
 938 # Let the site file select an alternate cache file if it wants to.
 939 # Prefer explicitly selected file to automatically selected ones.
 940 if test -z "$CONFIG_SITE"; then
 941   if test "x$prefix" != xNONE; then
 942     CONFIG_SITE="$prefix/share/config.site $prefix/etc/config.site"
 943   else
 944     CONFIG_SITE="$ac_default_prefix/share/config.site $ac_default_prefix/etc/config.site"
 945   fi
 946 fi
 947 for ac_site_file in $CONFIG_SITE; do
 948   if test -r "$ac_site_file"; then
 949     { echo "$as_me:949: loading site script $ac_site_file" >&5
 950 echo "$as_me: loading site script $ac_site_file" >&6;}
 951     cat "$ac_site_file" >&5
 952     . "$ac_site_file"
 953   fi
 954 done
 955
 956 if test -r "$cache_file"; then
 957   # Some versions of bash will fail to source /dev/null (special
 958   # files actually), so we avoid doing that.
 959   if test -f "$cache_file"; then
 960     { echo "$as_me:960: loading cache $cache_file" >&5
 961 echo "$as_me: loading cache $cache_file" >&6;}
 962     case $cache_file in
 963       [\\/]* | ?:[\\/]* ) . $cache_file;;
 964       *)                      . ./$cache_file;;
 965     esac
 966   fi
 967 else
 968   { echo "$as_me:968: creating cache $cache_file" >&5
 969 echo "$as_me: creating cache $cache_file" >&6;}
 970   >$cache_file
 971 fi
 972
 973 # Check that the precious variables saved in the cache have kept the same
 974 # value.
 975 ac_cache_corrupted=false
 976 for ac_var in `(set) 2>&1 |
 977                sed -n 's/^ac_env_\([a-zA-Z_0-9]*\)_set=.*/\1/p'`; do
 978   eval ac_old_set=\$ac_cv_env_${ac_var}_set
 979   eval ac_new_set=\$ac_env_${ac_var}_set
 980   eval ac_old_val="\$ac_cv_env_${ac_var}_value"
 981   eval ac_new_val="\$ac_env_${ac_var}_value"
 982   case "$ac_old_set,$ac_new_set" in
 983     set,)
 984       { echo "$as_me:984: error: \`$ac_var' was set to \`$ac_old_val' in the previous run" >&5
 985 echo "$as_me: error: \`$ac_var' was set to \`$ac_old_val' in the previous run" >&2;}
 986       ac_cache_corrupted=: ;;
 987     ,set)
 988       { echo "$as_me:988: error: \`$ac_var' was not set in the previous run" >&5
 989 echo "$as_me: error: \`$ac_var' was not set in the previous run" >&2;}
 990       ac_cache_corrupted=: ;;
 991     ,);;
 992     *)
 993       if test "x$ac_old_val" != "x$ac_new_val"; then
 994         { echo "$as_me:994: error: \`$ac_var' has changed since the previous run:" >&5
 995 echo "$as_me: error: \`$ac_var' has changed since the previous run:" >&2;}
 996         { echo "$as_me:996:   former value:  $ac_old_val" >&5
 997 echo "$as_me:   former value:  $ac_old_val" >&2;}
 998         { echo "$as_me:998:   current value: $ac_new_val" >&5
 999 echo "$as_me:   current value: $ac_new_val" >&2;}
1000         ac_cache_corrupted=:
1001       fi;;
1002   esac
1003   # Pass precious variables to config.status.  It doesn't matter if
1004   # we pass some twice (in addition to the command line arguments).
1005   if test "$ac_new_set" = set; then
1006     case "$ac_new_val" in
1007     *" "*|*"    "*|*[\[\]\~\#\$\^\&\*\(\)\{\}\\\|\;\<\>\?\"\']*)
1008       ac_arg=$ac_var=`echo "$ac_new_val" | sed "s/'/'\\\\\\\\''/g"`
1009       ac_configure_args="$ac_configure_args '$ac_arg'"
1010       ;;
1011     *) ac_configure_args="$ac_configure_args $ac_var=$ac_new_val"
1012        ;;
1013     esac
1014   fi
1015 done
1016 if "$ac_cache_corrupted"; then
1017   { echo "$as_me:1017: error: changes in the environment can compromise the build" >&5
1018 echo "$as_me: error: changes in the environment can compromise the build" >&2;}
1019   { { echo "$as_me:1019: error: run \`make distclean' and/or \`rm $cache_file' and start over" >&5
1020 echo "$as_me: error: run \`make distclean' and/or \`rm $cache_file' and start over" >&2;}
1021    { (exit 1); exit 1; }; }
1022 fi
1023
1024 ac_ext=c
1025 ac_cpp='$CPP $CPPFLAGS'
1026 ac_compile='$CC -c $CFLAGS $CPPFLAGS "conftest.$ac_ext" >&5'
1027 ac_link='$CC -o "conftest$ac_exeext" $CFLAGS $CPPFLAGS $LDFLAGS "conftest.$ac_ext" $LIBS >&5'
1028 ac_compiler_gnu=$ac_cv_c_compiler_gnu
1029 ac_main_return="return"
1030
1031 case `echo "testing\c" 2>/dev/null; echo 1,2,3`,`echo -n testing 2>/dev/null; echo 1,2,3` in
1032   *c*,-n*) ECHO_N=
1033            ECHO_C=      # newlines do not sed ;-) only broken shells would use this case anyway
1034            ECHO_T='     '
1035            ;;
1036   *c*,*  ) ECHO_N=-n
1037            ECHO_C=
1038            ECHO_T=
1039            ;;
1040   *)       ECHO_N=
1041            ECHO_C='\c'
1042            ECHO_T=
1043            ;;
1044 esac
1045 echo "#! $SHELL" >conftest.sh
1046 echo  "exit 0"   >>conftest.sh
1047 chmod +x conftest.sh
1048 if { (echo "$as_me:1048: PATH=\".;.\"; conftest.sh") >&5
1049   (PATH=".;."; conftest.sh) 2>&5
1050   ac_status=$?
1051   echo "$as_me:1051: \$? = $ac_status" >&5
1052   (exit "$ac_status"); }; then
1053   ac_path_separator=';'
1054 else
1055   ac_path_separator=:
1056 fi
1057 PATH_SEPARATOR="$ac_path_separator"
1058 rm -f conftest.sh
1059
1060 ac_config_headers="$ac_config_headers include/ncurses_cfg.h:include/ncurses_cfg.hin"
1061
1062 top_builddir=`pwd`
1063
1064 ac_aux_dir=
1065 for ac_dir in $srcdir $srcdir/.. $srcdir/../..; do
1066   if test -f "$ac_dir/install-sh"; then
1067     ac_aux_dir=$ac_dir
1068     ac_install_sh="$ac_aux_dir/install-sh -c"
1069     break
1070   elif test -f "$ac_dir/install.sh"; then
1071     ac_aux_dir=$ac_dir
1072     ac_install_sh="$ac_aux_dir/install.sh -c"
1073     break
1074   elif test -f "$ac_dir/shtool"; then
1075     ac_aux_dir=$ac_dir
1076     ac_install_sh="$ac_aux_dir/shtool install -c"
1077     break
1078   fi
1079 done
1080 if test -z "$ac_aux_dir"; then
1081   { { echo "$as_me:1081: error: cannot find install-sh or install.sh in $srcdir $srcdir/.. $srcdir/../.." >&5
1082 echo "$as_me: error: cannot find install-sh or install.sh in $srcdir $srcdir/.. $srcdir/../.." >&2;}
1083    { (exit 1); exit 1; }; }
1084 fi
1085 ac_config_guess="$SHELL $ac_aux_dir/config.guess"
1086 ac_config_sub="$SHELL $ac_aux_dir/config.sub"
1087 ac_configure="$SHELL $ac_aux_dir/configure" # This should be Cygnus configure.
1088
1089 # Make sure we can run config.sub.
1090 $ac_config_sub sun4 >/dev/null 2>&1 ||
1091   { { echo "$as_me:1091: error: cannot run $ac_config_sub" >&5
1092 echo "$as_me: error: cannot run $ac_config_sub" >&2;}
1093    { (exit 1); exit 1; }; }
1094
1095 echo "$as_me:1095: checking build system type" >&5
1096 echo $ECHO_N "checking build system type... $ECHO_C" >&6
1097 if test "${ac_cv_build+set}" = set; then
1098   echo $ECHO_N "(cached) $ECHO_C" >&6
1099 else
1100   ac_cv_build_alias=$build_alias
1101 test -z "$ac_cv_build_alias" &&
1102   ac_cv_build_alias=`$ac_config_guess`
1103 test -z "$ac_cv_build_alias" &&
1104   { { echo "$as_me:1104: error: cannot guess build type; you must specify one" >&5
1105 echo "$as_me: error: cannot guess build type; you must specify one" >&2;}
1106    { (exit 1); exit 1; }; }
1107 ac_cv_build=`$ac_config_sub "$ac_cv_build_alias"` ||
1108   { { echo "$as_me:1108: error: $ac_config_sub $ac_cv_build_alias failed." >&5
1109 echo "$as_me: error: $ac_config_sub $ac_cv_build_alias failed." >&2;}
1110    { (exit 1); exit 1; }; }
1111
1112 fi
1113 echo "$as_me:1113: result: $ac_cv_build" >&5
1114 echo "${ECHO_T}$ac_cv_build" >&6
1115 build=$ac_cv_build
1116 build_cpu=`echo "$ac_cv_build" | sed 's/^\([^-]*\)-\([^-]*\)-\(.*\)$/\1/'`
1117 build_vendor=`echo "$ac_cv_build" | sed 's/^\([^-]*\)-\([^-]*\)-\(.*\)$/\2/'`
1118 build_os=`echo "$ac_cv_build" | sed 's/^\([^-]*\)-\([^-]*\)-\(.*\)$/\3/'`
1119
1120 echo "$as_me:1120: checking host system type" >&5
1121 echo $ECHO_N "checking host system type... $ECHO_C" >&6
1122 if test "${ac_cv_host+set}" = set; then
1123   echo $ECHO_N "(cached) $ECHO_C" >&6
1124 else
1125   ac_cv_host_alias=$host_alias
1126 test -z "$ac_cv_host_alias" &&
1127   ac_cv_host_alias=$ac_cv_build_alias
1128 ac_cv_host=`$ac_config_sub "$ac_cv_host_alias"` ||
1129   { { echo "$as_me:1129: error: $ac_config_sub $ac_cv_host_alias failed" >&5
1130 echo "$as_me: error: $ac_config_sub $ac_cv_host_alias failed" >&2;}
1131    { (exit 1); exit 1; }; }
1132
1133 fi
1134 echo "$as_me:1134: result: $ac_cv_host" >&5
1135 echo "${ECHO_T}$ac_cv_host" >&6
1136 host=$ac_cv_host
1137 host_cpu=`echo "$ac_cv_host" | sed 's/^\([^-]*\)-\([^-]*\)-\(.*\)$/\1/'`
1138 host_vendor=`echo "$ac_cv_host" | sed 's/^\([^-]*\)-\([^-]*\)-\(.*\)$/\2/'`
1139 host_os=`echo "$ac_cv_host" | sed 's/^\([^-]*\)-\([^-]*\)-\(.*\)$/\3/'`
1140
1141 if test -f "$srcdir/config.guess" || test -f "$ac_aux_dir/config.guess" ; then
1142         echo "$as_me:1142: checking target system type" >&5
1143 echo $ECHO_N "checking target system type... $ECHO_C" >&6
1144 if test "${ac_cv_target+set}" = set; then
1145   echo $ECHO_N "(cached) $ECHO_C" >&6
1146 else
1147   ac_cv_target_alias=$target_alias
1148 test "x$ac_cv_target_alias" = "x" &&
1149   ac_cv_target_alias=$ac_cv_host_alias
1150 ac_cv_target=`$ac_config_sub "$ac_cv_target_alias"` ||
1151   { { echo "$as_me:1151: error: $ac_config_sub $ac_cv_target_alias failed" >&5
1152 echo "$as_me: error: $ac_config_sub $ac_cv_target_alias failed" >&2;}
1153    { (exit 1); exit 1; }; }
1154
1155 fi
1156 echo "$as_me:1156: result: $ac_cv_target" >&5
1157 echo "${ECHO_T}$ac_cv_target" >&6
1158 target=$ac_cv_target
1159 target_cpu=`echo "$ac_cv_target" | sed 's/^\([^-]*\)-\([^-]*\)-\(.*\)$/\1/'`
1160 target_vendor=`echo "$ac_cv_target" | sed 's/^\([^-]*\)-\([^-]*\)-\(.*\)$/\2/'`
1161 target_os=`echo "$ac_cv_target" | sed 's/^\([^-]*\)-\([^-]*\)-\(.*\)$/\3/'`
1162
1163 # The aliases save the names the user supplied, while $host etc.
1164 # will get canonicalized.
1165 test -n "$target_alias" &&
1166   test "$program_prefix$program_suffix$program_transform_name" = \
1167     NONENONEs,x,x, &&
1168   program_prefix=${target_alias}-
1169         system_name="$host_os"
1170 else
1171         system_name="`(uname -s -r) 2>/dev/null`"
1172         if test -z "$system_name" ; then
1173                 system_name="`(hostname) 2>/dev/null`"
1174         fi
1175 fi
1176 test -n "$system_name" &&
1177 cat >>confdefs.h <<EOF
1178 #define SYSTEM_NAME "$system_name"
1179 EOF
1180
1181 if test "${cf_cv_system_name+set}" = set; then
1182   echo $ECHO_N "(cached) $ECHO_C" >&6
1183 else
1184   cf_cv_system_name="$system_name"
1185 fi
1186
1187 test -z "$system_name" && system_name="$cf_cv_system_name"
1188 test -n "$cf_cv_system_name" && echo "$as_me:1188: result: Configuring for $cf_cv_system_name" >&5
1189 echo "${ECHO_T}Configuring for $cf_cv_system_name" >&6
1190
1191 if test ".$system_name" != ".$cf_cv_system_name" ; then
1192         echo "$as_me:1192: result: Cached system name ($system_name) does not agree with actual ($cf_cv_system_name)" >&5
1193 echo "${ECHO_T}Cached system name ($system_name) does not agree with actual ($cf_cv_system_name)" >&6
1194         { { echo "$as_me:1194: error: \"Please remove config.cache and try again.\"" >&5
1195 echo "$as_me: error: \"Please remove config.cache and try again.\"" >&2;}
1196    { (exit 1); exit 1; }; }
1197 fi
1198
1199 # Check whether --with-system-type or --without-system-type was given.
1200 if test "${with_system_type+set}" = set; then
1201   withval="$with_system_type"
1202   { echo "$as_me:1202: WARNING: overriding system type to $withval" >&5
1203 echo "$as_me: WARNING: overriding system type to $withval" >&2;}
1204         cf_cv_system_name=$withval
1205         host_os=$withval
1206
1207 fi;
1208
1209 ###     Save the given $CFLAGS to allow user-override.
1210 cf_user_CFLAGS="$CFLAGS"
1211
1212 ###     Default install-location
1213 for ac_prog in ggrep grep
1214 do
1215   # Extract the first word of "$ac_prog", so it can be a program name with args.
1216 set dummy $ac_prog; ac_word=$2
1217 echo "$as_me:1217: checking for $ac_word" >&5
1218 echo $ECHO_N "checking for $ac_word... $ECHO_C" >&6
1219 if test "${ac_cv_prog_GREP+set}" = set; then
1220   echo $ECHO_N "(cached) $ECHO_C" >&6
1221 else
1222   if test -n "$GREP"; then
1223   ac_cv_prog_GREP="$GREP" # Let the user override the test.
1224 else
1225   ac_save_IFS=$IFS; IFS=$ac_path_separator
1226 ac_dummy="$PATH"
1227 for ac_dir in $ac_dummy; do
1228   IFS=$ac_save_IFS
1229   test -z "$ac_dir" && ac_dir=.
1230   $as_executable_p "$ac_dir/$ac_word" || continue
1231 ac_cv_prog_GREP="$ac_prog"
1232 echo "$as_me:1232: found $ac_dir/$ac_word" >&5
1233 break
1234 done
1235
1236 fi
1237 fi
1238 GREP=$ac_cv_prog_GREP
1239 if test -n "$GREP"; then
1240   echo "$as_me:1240: result: $GREP" >&5
1241 echo "${ECHO_T}$GREP" >&6
1242 else
1243   echo "$as_me:1243: result: no" >&5
1244 echo "${ECHO_T}no" >&6
1245 fi
1246
1247   test -n "$GREP" && break
1248 done
1249 test -n "$GREP" || GREP=": "
1250
1251 echo "$as_me:1251: checking for fgrep" >&5
1252 echo $ECHO_N "checking for fgrep... $ECHO_C" >&6
1253 if test "${ac_cv_path_FGREP+set}" = set; then
1254   echo $ECHO_N "(cached) $ECHO_C" >&6
1255 else
1256   if echo 'ab*c' | $GREP -F 'ab*c' >/dev/null 2>&1
1257    then ac_cv_path_FGREP="$GREP -F"
1258    else
1259      for ac_prog in gfgrep fgrep
1260 do
1261   # Extract the first word of "$ac_prog", so it can be a program name with args.
1262 set dummy $ac_prog; ac_word=$2
1263 echo "$as_me:1263: checking for $ac_word" >&5
1264 echo $ECHO_N "checking for $ac_word... $ECHO_C" >&6
1265 if test "${ac_cv_path_FGREP+set}" = set; then
1266   echo $ECHO_N "(cached) $ECHO_C" >&6
1267 else
1268   case $FGREP in
1269   [\\/]* | ?:[\\/]*)
1270   ac_cv_path_FGREP="$FGREP" # Let the user override the test with a path.
1271   ;;
1272   *)
1273   ac_save_IFS=$IFS; IFS=$ac_path_separator
1274 ac_dummy="$PATH"
1275 for ac_dir in $ac_dummy; do
1276   IFS=$ac_save_IFS
1277   test -z "$ac_dir" && ac_dir=.
1278   if $as_executable_p "$ac_dir/$ac_word"; then
1279    ac_cv_path_FGREP="$ac_dir/$ac_word"
1280    echo "$as_me:1280: found $ac_dir/$ac_word" >&5
1281    break
1282 fi
1283 done
1284
1285   ;;
1286 esac
1287 fi
1288 FGREP=$ac_cv_path_FGREP
1289
1290 if test -n "$FGREP"; then
1291   echo "$as_me:1291: result: $FGREP" >&5
1292 echo "${ECHO_T}$FGREP" >&6
1293 else
1294   echo "$as_me:1294: result: no" >&5
1295 echo "${ECHO_T}no" >&6
1296 fi
1297
1298   test -n "$FGREP" && break
1299 done
1300 test -n "$FGREP" || FGREP=": "
1301
1302      test "x$ac_cv_path_FGREP" = "x:" && { { echo "$as_me:1302: error: cannot find workable fgrep" >&5
1303 echo "$as_me: error: cannot find workable fgrep" >&2;}
1304    { (exit 1); exit 1; }; }
1305    fi
1306 fi
1307 echo "$as_me:1307: result: $ac_cv_path_FGREP" >&5
1308 echo "${ECHO_T}$ac_cv_path_FGREP" >&6
1309  FGREP="$ac_cv_path_FGREP"
1310
1311 echo "$as_me:1311: checking for prefix" >&5
1312 echo $ECHO_N "checking for prefix... $ECHO_C" >&6
1313 if test "x$prefix" = "xNONE" ; then
1314         case "$cf_cv_system_name" in
1315                 # non-vendor systems don't have a conflict
1316         (openbsd*|freebsd*|mirbsd*|linux*|cygwin*|msys*|k*bsd*-gnu|mingw*)
1317                 prefix=/usr
1318                 ;;
1319         (*)     prefix=$ac_default_prefix
1320                 ;;
1321         esac
1322 fi
1323 echo "$as_me:1323: result: $prefix" >&5
1324 echo "${ECHO_T}$prefix" >&6
1325
1326 if test "x$prefix" = "xNONE" ; then
1327 echo "$as_me:1327: checking for default include-directory" >&5
1328 echo $ECHO_N "checking for default include-directory... $ECHO_C" >&6
1329 test -n "$verbose" && echo 1>&6
1330 for cf_symbol in \
1331         "$includedir" \
1332         "$includedir/ncurses" \
1333         "$prefix/include" \
1334         "$prefix/include/ncurses" \
1335         /usr/local/include \
1336         /usr/local/include/ncurses \
1337         /usr/include \
1338         /usr/include/ncurses
1339 do
1340         cf_dir=`eval echo "$cf_symbol"`
1341         if test -f "$cf_dir/curses.h" ; then
1342         if ( ${FGREP-fgrep} NCURSES_VERSION "$cf_dir/curses.h" >/dev/null 2>&1 ) ; then
1343                 includedir="$cf_symbol"
1344                 test -n "$verbose"  && echo $ECHO_N "   found " 1>&6
1345                 break
1346         fi
1347         fi
1348         test -n "$verbose"  && echo "   tested $cf_dir" 1>&6
1349 done
1350 echo "$as_me:1350: result: $includedir" >&5
1351 echo "${ECHO_T}$includedir" >&6
1352 fi
1353
1354 ###     Checks for programs.
1355
1356 ac_ext=c
1357 ac_cpp='$CPP $CPPFLAGS'
1358 ac_compile='$CC -c $CFLAGS $CPPFLAGS "conftest.$ac_ext" >&5'
1359 ac_link='$CC -o "conftest$ac_exeext" $CFLAGS $CPPFLAGS $LDFLAGS "conftest.$ac_ext" $LIBS >&5'
1360 ac_compiler_gnu=$ac_cv_c_compiler_gnu
1361 ac_main_return="return"
1362 if test -n "$ac_tool_prefix"; then
1363   for ac_prog in gnatgcc gcc cc
1364   do
1365     # Extract the first word of "$ac_tool_prefix$ac_prog", so it can be a program name with args.
1366 set dummy $ac_tool_prefix$ac_prog; ac_word=$2
1367 echo "$as_me:1367: checking for $ac_word" >&5
1368 echo $ECHO_N "checking for $ac_word... $ECHO_C" >&6
1369 if test "${ac_cv_prog_CC+set}" = set; then
1370   echo $ECHO_N "(cached) $ECHO_C" >&6
1371 else
1372   if test -n "$CC"; then
1373   ac_cv_prog_CC="$CC" # Let the user override the test.
1374 else
1375   ac_save_IFS=$IFS; IFS=$ac_path_separator
1376 ac_dummy="$PATH"
1377 for ac_dir in $ac_dummy; do
1378   IFS=$ac_save_IFS
1379   test -z "$ac_dir" && ac_dir=.
1380   $as_executable_p "$ac_dir/$ac_word" || continue
1381 ac_cv_prog_CC="$ac_tool_prefix$ac_prog"
1382 echo "$as_me:1382: found $ac_dir/$ac_word" >&5
1383 break
1384 done
1385
1386 fi
1387 fi
1388 CC=$ac_cv_prog_CC
1389 if test -n "$CC"; then
1390   echo "$as_me:1390: result: $CC" >&5
1391 echo "${ECHO_T}$CC" >&6
1392 else
1393   echo "$as_me:1393: result: no" >&5
1394 echo "${ECHO_T}no" >&6
1395 fi
1396
1397     test -n "$CC" && break
1398   done
1399 fi
1400 if test -z "$CC"; then
1401   ac_ct_CC=$CC
1402   for ac_prog in gnatgcc gcc cc
1403 do
1404   # Extract the first word of "$ac_prog", so it can be a program name with args.
1405 set dummy $ac_prog; ac_word=$2
1406 echo "$as_me:1406: checking for $ac_word" >&5
1407 echo $ECHO_N "checking for $ac_word... $ECHO_C" >&6
1408 if test "${ac_cv_prog_ac_ct_CC+set}" = set; then
1409   echo $ECHO_N "(cached) $ECHO_C" >&6
1410 else
1411   if test -n "$ac_ct_CC"; then
1412   ac_cv_prog_ac_ct_CC="$ac_ct_CC" # Let the user override the test.
1413 else
1414   ac_save_IFS=$IFS; IFS=$ac_path_separator
1415 ac_dummy="$PATH"
1416 for ac_dir in $ac_dummy; do
1417   IFS=$ac_save_IFS
1418   test -z "$ac_dir" && ac_dir=.
1419   $as_executable_p "$ac_dir/$ac_word" || continue
1420 ac_cv_prog_ac_ct_CC="$ac_prog"
1421 echo "$as_me:1421: found $ac_dir/$ac_word" >&5
1422 break
1423 done
1424
1425 fi
1426 fi
1427 ac_ct_CC=$ac_cv_prog_ac_ct_CC
1428 if test -n "$ac_ct_CC"; then
1429   echo "$as_me:1429: result: $ac_ct_CC" >&5
1430 echo "${ECHO_T}$ac_ct_CC" >&6
1431 else
1432   echo "$as_me:1432: result: no" >&5
1433 echo "${ECHO_T}no" >&6
1434 fi
1435
1436   test -n "$ac_ct_CC" && break
1437 done
1438
1439   CC=$ac_ct_CC
1440 fi
1441
1442 test -z "$CC" && { { echo "$as_me:1442: error: no acceptable cc found in \$PATH" >&5
1443 echo "$as_me: error: no acceptable cc found in \$PATH" >&2;}
1444    { (exit 1); exit 1; }; }
1445
1446 # Provide some information about the compiler.
1447 echo "$as_me:1447:" \
1448      "checking for C compiler version" >&5
1449 ac_compiler=`set X $ac_compile; echo "$2"`
1450 { (eval echo "$as_me:1450: \"$ac_compiler --version </dev/null >&5\"") >&5
1451   (eval $ac_compiler --version </dev/null >&5) 2>&5
1452   ac_status=$?
1453   echo "$as_me:1453: \$? = $ac_status" >&5
1454   (exit "$ac_status"); }
1455 { (eval echo "$as_me:1455: \"$ac_compiler -v </dev/null >&5\"") >&5
1456   (eval $ac_compiler -v </dev/null >&5) 2>&5
1457   ac_status=$?
1458   echo "$as_me:1458: \$? = $ac_status" >&5
1459   (exit "$ac_status"); }
1460 { (eval echo "$as_me:1460: \"$ac_compiler -V </dev/null >&5\"") >&5
1461   (eval $ac_compiler -V </dev/null >&5) 2>&5
1462   ac_status=$?
1463   echo "$as_me:1463: \$? = $ac_status" >&5
1464   (exit "$ac_status"); }
1465
1466 cat >"conftest.$ac_ext" <<_ACEOF
1467 #line 1467 "configure"
1468 #include "confdefs.h"
1469
1470 int
1471 main (void)
1472 {
1473
1474   ;
1475   return 0;
1476 }
1477 _ACEOF
1478 ac_clean_files_save=$ac_clean_files
1479 ac_clean_files="$ac_clean_files a.out a.exe"
1480 # Try to create an executable without -o first, disregard a.out.
1481 # It will help us diagnose broken compilers, and finding out an intuition
1482 # of exeext.
1483 echo "$as_me:1483: checking for C compiler default output" >&5
1484 echo $ECHO_N "checking for C compiler default output... $ECHO_C" >&6
1485 ac_link_default=`echo "$ac_link" | sed 's/ -o *"conftest[^"]*"//'`
1486 if { (eval echo "$as_me:1486: \"$ac_link_default\"") >&5
1487   (eval $ac_link_default) 2>&5
1488   ac_status=$?
1489   echo "$as_me:1489: \$? = $ac_status" >&5
1490   (exit "$ac_status"); }; then
1491   # Find the output, starting from the most likely.  This scheme is
1492 # not robust to junk in `.', hence go to wildcards (a.*) only as a last
1493 # resort.
1494 for ac_file in `ls a.exe conftest.exe 2>/dev/null;
1495                 ls a.out conftest 2>/dev/null;
1496                 ls a.* conftest.* 2>/dev/null`; do
1497   case $ac_file in
1498     *.$ac_ext | *.xcoff | *.tds | *.d | *.dbg | *.pdb | *.xSYM | *.bb | *.bbg | *.map | *.inf | *.o | *.obj ) ;;
1499     a.out ) # We found the default executable, but exeext='' is most
1500             # certainly right.
1501             break;;
1502     *.* ) ac_cv_exeext=`expr "$ac_file" : '[^.]*\(\..*\)'`
1503           # FIXME: I believe we export ac_cv_exeext for Libtool --akim.
1504           export ac_cv_exeext
1505           break;;
1506     * ) break;;
1507   esac
1508 done
1509 else
1510   echo "$as_me: failed program was:" >&5
1511 cat "conftest.$ac_ext" >&5
1512 { { echo "$as_me:1512: error: C compiler cannot create executables" >&5
1513 echo "$as_me: error: C compiler cannot create executables" >&2;}
1514    { (exit 77); exit 77; }; }
1515 fi
1516
1517 ac_exeext=$ac_cv_exeext
1518 echo "$as_me:1518: result: $ac_file" >&5
1519 echo "${ECHO_T}$ac_file" >&6
1520
1521 # Check the compiler produces executables we can run.  If not, either
1522 # the compiler is broken, or we cross compile.
1523 echo "$as_me:1523: checking whether the C compiler works" >&5
1524 echo $ECHO_N "checking whether the C compiler works... $ECHO_C" >&6
1525 # FIXME: These cross compiler hacks should be removed for Autoconf 3.0
1526 # If not cross compiling, check that we can run a simple program.
1527 if test "$cross_compiling" != yes; then
1528   if { ac_try='./$ac_file'
1529   { (eval echo "$as_me:1529: \"$ac_try\"") >&5
1530   (eval $ac_try) 2>&5
1531   ac_status=$?
1532   echo "$as_me:1532: \$? = $ac_status" >&5
1533   (exit "$ac_status"); }; }; then
1534     cross_compiling=no
1535   else
1536     if test "$cross_compiling" = maybe; then
1537         cross_compiling=yes
1538     else
1539         { { echo "$as_me:1539: error: cannot run C compiled programs.
1540 If you meant to cross compile, use \`--host'." >&5
1541 echo "$as_me: error: cannot run C compiled programs.
1542 If you meant to cross compile, use \`--host'." >&2;}
1543    { (exit 1); exit 1; }; }
1544     fi
1545   fi
1546 fi
1547 echo "$as_me:1547: result: yes" >&5
1548 echo "${ECHO_T}yes" >&6
1549
1550 rm -f a.out a.exe "conftest$ac_cv_exeext"
1551 ac_clean_files=$ac_clean_files_save
1552 # Check the compiler produces executables we can run.  If not, either
1553 # the compiler is broken, or we cross compile.
1554 echo "$as_me:1554: checking whether we are cross compiling" >&5
1555 echo $ECHO_N "checking whether we are cross compiling... $ECHO_C" >&6
1556 echo "$as_me:1556: result: $cross_compiling" >&5
1557 echo "${ECHO_T}$cross_compiling" >&6
1558
1559 echo "$as_me:1559: checking for executable suffix" >&5
1560 echo $ECHO_N "checking for executable suffix... $ECHO_C" >&6
1561 if { (eval echo "$as_me:1561: \"$ac_link\"") >&5
1562   (eval $ac_link) 2>&5
1563   ac_status=$?
1564   echo "$as_me:1564: \$? = $ac_status" >&5
1565   (exit "$ac_status"); }; then
1566   # If both `conftest.exe' and `conftest' are `present' (well, observable)
1567 # catch `conftest.exe'.  For instance with Cygwin, `ls conftest' will
1568 # work properly (i.e., refer to `conftest.exe'), while it won't with
1569 # `rm'.
1570 for ac_file in `(ls conftest.exe; ls conftest; ls conftest.*) 2>/dev/null`; do
1571   case $ac_file in
1572     *.$ac_ext | *.xcoff | *.tds | *.d | *.dbg | *.pdb | *.xSYM | *.bb | *.bbg | *.map | *.inf | *.o | *.obj ) ;;
1573     *.* ) ac_cv_exeext=`expr "$ac_file" : '[^.]*\(\..*\)'`
1574           export ac_cv_exeext
1575           break;;
1576     * ) break;;
1577   esac
1578 done
1579 else
1580   { { echo "$as_me:1580: error: cannot compute EXEEXT: cannot compile and link" >&5
1581 echo "$as_me: error: cannot compute EXEEXT: cannot compile and link" >&2;}
1582    { (exit 1); exit 1; }; }
1583 fi
1584
1585 rm -f "conftest$ac_cv_exeext"
1586 echo "$as_me:1586: result: $ac_cv_exeext" >&5
1587 echo "${ECHO_T}$ac_cv_exeext" >&6
1588
1589 rm -f "conftest.$ac_ext"
1590 EXEEXT=$ac_cv_exeext
1591 ac_exeext=$EXEEXT
1592 echo "$as_me:1592: checking for object suffix" >&5
1593 echo $ECHO_N "checking for object suffix... $ECHO_C" >&6
1594 if test "${ac_cv_objext+set}" = set; then
1595   echo $ECHO_N "(cached) $ECHO_C" >&6
1596 else
1597   cat >"conftest.$ac_ext" <<_ACEOF
1598 #line 1598 "configure"
1599 #include "confdefs.h"
1600
1601 int
1602 main (void)
1603 {
1604
1605   ;
1606   return 0;
1607 }
1608 _ACEOF
1609 rm -f conftest.o conftest.obj
1610 if { (eval echo "$as_me:1610: \"$ac_compile\"") >&5
1611   (eval $ac_compile) 2>&5
1612   ac_status=$?
1613   echo "$as_me:1613: \$? = $ac_status" >&5
1614   (exit "$ac_status"); }; then
1615   for ac_file in `(ls conftest.o conftest.obj; ls conftest.*) 2>/dev/null`; do
1616   case $ac_file in
1617     *.$ac_ext | *.xcoff | *.tds | *.d | *.dbg | *.pdb | *.xSYM | *.map | *.inf ) ;;
1618     *) ac_cv_objext=`expr "$ac_file" : '.*\.\(.*\)'`
1619        break;;
1620   esac
1621 done
1622 else
1623   echo "$as_me: failed program was:" >&5
1624 cat "conftest.$ac_ext" >&5
1625 { { echo "$as_me:1625: error: cannot compute OBJEXT: cannot compile" >&5
1626 echo "$as_me: error: cannot compute OBJEXT: cannot compile" >&2;}
1627    { (exit 1); exit 1; }; }
1628 fi
1629
1630 rm -f "conftest.$ac_cv_objext" "conftest.$ac_ext"
1631 fi
1632 echo "$as_me:1632: result: $ac_cv_objext" >&5
1633 echo "${ECHO_T}$ac_cv_objext" >&6
1634 OBJEXT=$ac_cv_objext
1635 ac_objext=$OBJEXT
1636 echo "$as_me:1636: checking whether we are using the GNU C compiler" >&5
1637 echo $ECHO_N "checking whether we are using the GNU C compiler... $ECHO_C" >&6
1638 if test "${ac_cv_c_compiler_gnu+set}" = set; then
1639   echo $ECHO_N "(cached) $ECHO_C" >&6
1640 else
1641   cat >"conftest.$ac_ext" <<_ACEOF
1642 #line 1642 "configure"
1643 #include "confdefs.h"
1644
1645 int
1646 main (void)
1647 {
1648 #ifndef __GNUC__
1649        choke me
1650 #endif
1651
1652   ;
1653   return 0;
1654 }
1655 _ACEOF
1656 rm -f "conftest.$ac_objext"
1657 if { (eval echo "$as_me:1657: \"$ac_compile\"") >&5
1658   (eval $ac_compile) 2>&5
1659   ac_status=$?
1660   echo "$as_me:1660: \$? = $ac_status" >&5
1661   (exit "$ac_status"); } &&
1662          { ac_try='test -s "conftest.$ac_objext"'
1663   { (eval echo "$as_me:1663: \"$ac_try\"") >&5
1664   (eval $ac_try) 2>&5
1665   ac_status=$?
1666   echo "$as_me:1666: \$? = $ac_status" >&5
1667   (exit "$ac_status"); }; }; then
1668   ac_compiler_gnu=yes
1669 else
1670   echo "$as_me: failed program was:" >&5
1671 cat "conftest.$ac_ext" >&5
1672 ac_compiler_gnu=no
1673 fi
1674 rm -f "conftest.$ac_objext" "conftest.$ac_ext"
1675 ac_cv_c_compiler_gnu=$ac_compiler_gnu
1676
1677 fi
1678 echo "$as_me:1678: result: $ac_cv_c_compiler_gnu" >&5
1679 echo "${ECHO_T}$ac_cv_c_compiler_gnu" >&6
1680 GCC=`test $ac_compiler_gnu = yes && echo yes`
1681 ac_test_CFLAGS=${CFLAGS+set}
1682 ac_save_CFLAGS=$CFLAGS
1683 CFLAGS="-g"
1684 echo "$as_me:1684: checking whether $CC accepts -g" >&5
1685 echo $ECHO_N "checking whether $CC accepts -g... $ECHO_C" >&6
1686 if test "${ac_cv_prog_cc_g+set}" = set; then
1687   echo $ECHO_N "(cached) $ECHO_C" >&6
1688 else
1689   cat >"conftest.$ac_ext" <<_ACEOF
1690 #line 1690 "configure"
1691 #include "confdefs.h"
1692
1693 int
1694 main (void)
1695 {
1696
1697   ;
1698   return 0;
1699 }
1700 _ACEOF
1701 rm -f "conftest.$ac_objext"
1702 if { (eval echo "$as_me:1702: \"$ac_compile\"") >&5
1703   (eval $ac_compile) 2>&5
1704   ac_status=$?
1705   echo "$as_me:1705: \$? = $ac_status" >&5
1706   (exit "$ac_status"); } &&
1707          { ac_try='test -s "conftest.$ac_objext"'
1708   { (eval echo "$as_me:1708: \"$ac_try\"") >&5
1709   (eval $ac_try) 2>&5
1710   ac_status=$?
1711   echo "$as_me:1711: \$? = $ac_status" >&5
1712   (exit "$ac_status"); }; }; then
1713   ac_cv_prog_cc_g=yes
1714 else
1715   echo "$as_me: failed program was:" >&5
1716 cat "conftest.$ac_ext" >&5
1717 ac_cv_prog_cc_g=no
1718 fi
1719 rm -f "conftest.$ac_objext" "conftest.$ac_ext"
1720 fi
1721 echo "$as_me:1721: result: $ac_cv_prog_cc_g" >&5
1722 echo "${ECHO_T}$ac_cv_prog_cc_g" >&6
1723 if test "$ac_test_CFLAGS" = set; then
1724   CFLAGS=$ac_save_CFLAGS
1725 elif test $ac_cv_prog_cc_g = yes; then
1726   if test "$GCC" = yes; then
1727     CFLAGS="-g -O2"
1728   else
1729     CFLAGS="-g"
1730   fi
1731 else
1732   if test "$GCC" = yes; then
1733     CFLAGS="-O2"
1734   else
1735     CFLAGS=
1736   fi
1737 fi
1738 # Some people use a C++ compiler to compile C.  Since we use `exit',
1739 # in C++ we need to declare it.  In case someone uses the same compiler
1740 # for both compiling C and C++ we need to have the C++ compiler decide
1741 # the declaration of exit, since it's the most demanding environment.
1742 cat >"conftest.$ac_ext" <<_ACEOF
1743 #ifndef __cplusplus
1744   choke me
1745 #endif
1746 _ACEOF
1747 rm -f "conftest.$ac_objext"
1748 if { (eval echo "$as_me:1748: \"$ac_compile\"") >&5
1749   (eval $ac_compile) 2>&5
1750   ac_status=$?
1751   echo "$as_me:1751: \$? = $ac_status" >&5
1752   (exit "$ac_status"); } &&
1753          { ac_try='test -s "conftest.$ac_objext"'
1754   { (eval echo "$as_me:1754: \"$ac_try\"") >&5
1755   (eval $ac_try) 2>&5
1756   ac_status=$?
1757   echo "$as_me:1757: \$? = $ac_status" >&5
1758   (exit "$ac_status"); }; }; then
1759   for ac_declaration in \
1760    ''\
1761    '#include <stdlib.h>' \
1762    'extern "C" void std::exit (int) throw (); using std::exit;' \
1763    'extern "C" void std::exit (int); using std::exit;' \
1764    'extern "C" void exit (int) throw ();' \
1765    'extern "C" void exit (int);' \
1766    'void exit (int);'
1767 do
1768   cat >"conftest.$ac_ext" <<_ACEOF
1769 #line 1769 "configure"
1770 #include "confdefs.h"
1771 #include <stdlib.h>
1772 $ac_declaration
1773 int
1774 main (void)
1775 {
1776 exit (42);
1777   ;
1778   return 0;
1779 }
1780 _ACEOF
1781 rm -f "conftest.$ac_objext"
1782 if { (eval echo "$as_me:1782: \"$ac_compile\"") >&5
1783   (eval $ac_compile) 2>&5
1784   ac_status=$?
1785   echo "$as_me:1785: \$? = $ac_status" >&5
1786   (exit "$ac_status"); } &&
1787          { ac_try='test -s "conftest.$ac_objext"'
1788   { (eval echo "$as_me:1788: \"$ac_try\"") >&5
1789   (eval $ac_try) 2>&5
1790   ac_status=$?
1791   echo "$as_me:1791: \$? = $ac_status" >&5
1792   (exit "$ac_status"); }; }; then
1793   :
1794 else
1795   echo "$as_me: failed program was:" >&5
1796 cat "conftest.$ac_ext" >&5
1797 continue
1798 fi
1799 rm -f "conftest.$ac_objext" "conftest.$ac_ext"
1800   cat >"conftest.$ac_ext" <<_ACEOF
1801 #line 1801 "configure"
1802 #include "confdefs.h"
1803 $ac_declaration
1804 int
1805 main (void)
1806 {
1807 exit (42);
1808   ;
1809   return 0;
1810 }
1811 _ACEOF
1812 rm -f "conftest.$ac_objext"
1813 if { (eval echo "$as_me:1813: \"$ac_compile\"") >&5
1814   (eval $ac_compile) 2>&5
1815   ac_status=$?
1816   echo "$as_me:1816: \$? = $ac_status" >&5
1817   (exit "$ac_status"); } &&
1818          { ac_try='test -s "conftest.$ac_objext"'
1819   { (eval echo "$as_me:1819: \"$ac_try\"") >&5
1820   (eval $ac_try) 2>&5
1821   ac_status=$?
1822   echo "$as_me:1822: \$? = $ac_status" >&5
1823   (exit "$ac_status"); }; }; then
1824   break
1825 else
1826   echo "$as_me: failed program was:" >&5
1827 cat "conftest.$ac_ext" >&5
1828 fi
1829 rm -f "conftest.$ac_objext" "conftest.$ac_ext"
1830 done
1831 rm -rf conftest*
1832 if test -n "$ac_declaration"; then
1833   echo '#ifdef __cplusplus' >>confdefs.h
1834   echo "$ac_declaration"    >>confdefs.h
1835   echo '#endif'             >>confdefs.h
1836 fi
1837
1838 else
1839   echo "$as_me: failed program was:" >&5
1840 cat "conftest.$ac_ext" >&5
1841 fi
1842 rm -f "conftest.$ac_objext" "conftest.$ac_ext"
1843 ac_ext=c
1844 ac_cpp='$CPP $CPPFLAGS'
1845 ac_compile='$CC -c $CFLAGS $CPPFLAGS "conftest.$ac_ext" >&5'
1846 ac_link='$CC -o "conftest$ac_exeext" $CFLAGS $CPPFLAGS $LDFLAGS "conftest.$ac_ext" $LIBS >&5'
1847 ac_compiler_gnu=$ac_cv_c_compiler_gnu
1848 ac_main_return="return"
1849
1850 GCC_VERSION=none
1851 if test "$GCC" = yes ; then
1852         echo "$as_me:1852: checking version of $CC" >&5
1853 echo $ECHO_N "checking version of $CC... $ECHO_C" >&6
1854         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.].*//'`"
1855         test -z "$GCC_VERSION" && GCC_VERSION=unknown
1856         echo "$as_me:1856: result: $GCC_VERSION" >&5
1857 echo "${ECHO_T}$GCC_VERSION" >&6
1858 fi
1859
1860 INTEL_COMPILER=no
1861
1862 if test "$GCC" = yes ; then
1863         case "$host_os" in
1864         (linux*|gnu*)
1865                 echo "$as_me:1865: checking if this is really Intel C compiler" >&5
1866 echo $ECHO_N "checking if this is really Intel C compiler... $ECHO_C" >&6
1867                 cf_save_CFLAGS="$CFLAGS"
1868                 CFLAGS="$CFLAGS -no-gcc"
1869                 cat >"conftest.$ac_ext" <<_ACEOF
1870 #line 1870 "configure"
1871 #include "confdefs.h"
1872
1873 int
1874 main (void)
1875 {
1876
1877 #ifdef __INTEL_COMPILER
1878 #else
1879 make an error
1880 #endif
1881
1882   ;
1883   return 0;
1884 }
1885 _ACEOF
1886 rm -f "conftest.$ac_objext"
1887 if { (eval echo "$as_me:1887: \"$ac_compile\"") >&5
1888   (eval $ac_compile) 2>&5
1889   ac_status=$?
1890   echo "$as_me:1890: \$? = $ac_status" >&5
1891   (exit "$ac_status"); } &&
1892          { ac_try='test -s "conftest.$ac_objext"'
1893   { (eval echo "$as_me:1893: \"$ac_try\"") >&5
1894   (eval $ac_try) 2>&5
1895   ac_status=$?
1896   echo "$as_me:1896: \$? = $ac_status" >&5
1897   (exit "$ac_status"); }; }; then
1898   INTEL_COMPILER=yes
1899 cf_save_CFLAGS="$cf_save_CFLAGS -we147"
1900
1901 else
1902   echo "$as_me: failed program was:" >&5
1903 cat "conftest.$ac_ext" >&5
1904 fi
1905 rm -f "conftest.$ac_objext" "conftest.$ac_ext"
1906                 CFLAGS="$cf_save_CFLAGS"
1907                 echo "$as_me:1907: result: $INTEL_COMPILER" >&5
1908 echo "${ECHO_T}$INTEL_COMPILER" >&6
1909                 ;;
1910         esac
1911 fi
1912
1913 CLANG_COMPILER=no
1914
1915 if test "$GCC" = yes ; then
1916         echo "$as_me:1916: checking if this is really Clang C compiler" >&5
1917 echo $ECHO_N "checking if this is really Clang C compiler... $ECHO_C" >&6
1918         cf_save_CFLAGS="$CFLAGS"
1919         cat >"conftest.$ac_ext" <<_ACEOF
1920 #line 1920 "configure"
1921 #include "confdefs.h"
1922
1923 int
1924 main (void)
1925 {
1926
1927 #ifdef __clang__
1928 #else
1929 make an error
1930 #endif
1931
1932   ;
1933   return 0;
1934 }
1935 _ACEOF
1936 rm -f "conftest.$ac_objext"
1937 if { (eval echo "$as_me:1937: \"$ac_compile\"") >&5
1938   (eval $ac_compile) 2>&5
1939   ac_status=$?
1940   echo "$as_me:1940: \$? = $ac_status" >&5
1941   (exit "$ac_status"); } &&
1942          { ac_try='test -s "conftest.$ac_objext"'
1943   { (eval echo "$as_me:1943: \"$ac_try\"") >&5
1944   (eval $ac_try) 2>&5
1945   ac_status=$?
1946   echo "$as_me:1946: \$? = $ac_status" >&5
1947   (exit "$ac_status"); }; }; then
1948   CLANG_COMPILER=yes
1949
1950 else
1951   echo "$as_me: failed program was:" >&5
1952 cat "conftest.$ac_ext" >&5
1953 fi
1954 rm -f "conftest.$ac_objext" "conftest.$ac_ext"
1955         CFLAGS="$cf_save_CFLAGS"
1956         echo "$as_me:1956: result: $CLANG_COMPILER" >&5
1957 echo "${ECHO_T}$CLANG_COMPILER" >&6
1958 fi
1959
1960 CLANG_VERSION=none
1961
1962 if test "x$CLANG_COMPILER" = "xyes" ; then
1963         case "$CC" in
1964         (c[1-9][0-9]|*/c[1-9][0-9])
1965                 { echo "$as_me:1965: WARNING: replacing broken compiler alias $CC" >&5
1966 echo "$as_me: WARNING: replacing broken compiler alias $CC" >&2;}
1967                 CFLAGS="$CFLAGS -std=`echo "$CC" | sed -e 's%.*/%%'`"
1968                 CC=clang
1969                 ;;
1970         esac
1971
1972         echo "$as_me:1972: checking version of $CC" >&5
1973 echo $ECHO_N "checking version of $CC... $ECHO_C" >&6
1974         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.].*//'`"
1975         test -z "$CLANG_VERSION" && CLANG_VERSION=unknown
1976         echo "$as_me:1976: result: $CLANG_VERSION" >&5
1977 echo "${ECHO_T}$CLANG_VERSION" >&6
1978
1979         for cf_clang_opt in \
1980                 -Qunused-arguments \
1981                 -Wno-error=implicit-function-declaration
1982         do
1983                 echo "$as_me:1983: checking if option $cf_clang_opt works" >&5
1984 echo $ECHO_N "checking if option $cf_clang_opt works... $ECHO_C" >&6
1985                 cf_save_CFLAGS="$CFLAGS"
1986                 CFLAGS="$CFLAGS $cf_clang_opt"
1987                 cat >"conftest.$ac_ext" <<_ACEOF
1988 #line 1988 "configure"
1989 #include "confdefs.h"
1990
1991                         #include <stdio.h>
1992 int
1993 main (void)
1994 {
1995
1996                         printf("hello!\\n");
1997   ;
1998   return 0;
1999 }
2000 _ACEOF
2001 rm -f "conftest.$ac_objext" "conftest$ac_exeext"
2002 if { (eval echo "$as_me:2002: \"$ac_link\"") >&5
2003   (eval $ac_link) 2>&5
2004   ac_status=$?
2005   echo "$as_me:2005: \$? = $ac_status" >&5
2006   (exit "$ac_status"); } &&
2007          { ac_try='test -s "conftest$ac_exeext"'
2008   { (eval echo "$as_me:2008: \"$ac_try\"") >&5
2009   (eval $ac_try) 2>&5
2010   ac_status=$?
2011   echo "$as_me:2011: \$? = $ac_status" >&5
2012   (exit "$ac_status"); }; }; then
2013
2014                         cf_clang_optok=yes
2015 else
2016   echo "$as_me: failed program was:" >&5
2017 cat "conftest.$ac_ext" >&5
2018
2019                         cf_clang_optok=no
2020 fi
2021 rm -f "conftest.$ac_objext" "conftest$ac_exeext" "conftest.$ac_ext"
2022                 echo "$as_me:2022: result: $cf_clang_optok" >&5
2023 echo "${ECHO_T}$cf_clang_optok" >&6
2024                 CFLAGS="$cf_save_CFLAGS"
2025                 if test "$cf_clang_optok" = yes; then
2026                         test -n "$verbose" && echo "    adding option $cf_clang_opt" 1>&6
2027
2028 echo "${as_me:-configure}:2028: testing adding option $cf_clang_opt ..." 1>&5
2029
2030         test -n "$CFLAGS" && CFLAGS="$CFLAGS "
2031         CFLAGS="${CFLAGS}$cf_clang_opt"
2032
2033                 fi
2034         done
2035 fi
2036
2037 echo "$as_me:2037: checking for $CC option to accept ANSI C" >&5
2038 echo $ECHO_N "checking for $CC option to accept ANSI C... $ECHO_C" >&6
2039 if test "${ac_cv_prog_cc_stdc+set}" = set; then
2040   echo $ECHO_N "(cached) $ECHO_C" >&6
2041 else
2042   ac_cv_prog_cc_stdc=no
2043 ac_save_CC=$CC
2044 cat >"conftest.$ac_ext" <<_ACEOF
2045 #line 2045 "configure"
2046 #include "confdefs.h"
2047 #include <stdarg.h>
2048 #include <stdio.h>
2049 #include <sys/types.h>
2050 #include <sys/stat.h>
2051 /* Most of the following tests are stolen from RCS 5.7's src/conf.sh.  */
2052 struct buf { int x; };
2053 FILE * (*rcsopen) (struct buf *, struct stat *, int);
2054 static char *e (p, i)
2055      char **p;
2056      int i;
2057 {
2058   return p[i];
2059 }
2060 static char *f (char * (*g) (char **, int), char **p, ...)
2061 {
2062   char *s;
2063   va_list v;
2064   va_start (v,p);
2065   s = g (p, va_arg (v,int));
2066   va_end (v);
2067   return s;
2068 }
2069 int test (int i, double x);
2070 struct s1 {int (*f) (int a);};
2071 struct s2 {int (*f) (double a);};
2072 int pairnames (int, char **, FILE *(*)(struct buf *, struct stat *, int), int, int);
2073 int argc;
2074 char **argv;
2075 int
2076 main (void)
2077 {
2078 return f (e, argv, 0) != argv[0]  ||  f (e, argv, 1) != argv[1];
2079   ;
2080   return 0;
2081 }
2082 _ACEOF
2083 # Don't try gcc -ansi; that turns off useful extensions and
2084 # breaks some systems' header files.
2085 # AIX                   -qlanglvl=ansi
2086 # Ultrix and OSF/1      -std1
2087 # HP-UX 10.20 and later -Ae
2088 # HP-UX older versions  -Aa -D_HPUX_SOURCE
2089 # SVR4                  -Xc -D__EXTENSIONS__
2090 for ac_arg in "" -qlanglvl=ansi -std1 -Ae "-Aa -D_HPUX_SOURCE" "-Xc -D__EXTENSIONS__"
2091 do
2092   CC="$ac_save_CC $ac_arg"
2093   rm -f "conftest.$ac_objext"
2094 if { (eval echo "$as_me:2094: \"$ac_compile\"") >&5
2095   (eval $ac_compile) 2>&5
2096   ac_status=$?
2097   echo "$as_me:2097: \$? = $ac_status" >&5
2098   (exit "$ac_status"); } &&
2099          { ac_try='test -s "conftest.$ac_objext"'
2100   { (eval echo "$as_me:2100: \"$ac_try\"") >&5
2101   (eval $ac_try) 2>&5
2102   ac_status=$?
2103   echo "$as_me:2103: \$? = $ac_status" >&5
2104   (exit "$ac_status"); }; }; then
2105   ac_cv_prog_cc_stdc=$ac_arg
2106 break
2107 else
2108   echo "$as_me: failed program was:" >&5
2109 cat "conftest.$ac_ext" >&5
2110 fi
2111 rm -f "conftest.$ac_objext"
2112 done
2113 rm -f "conftest.$ac_ext" "conftest.$ac_objext"
2114 CC=$ac_save_CC
2115
2116 fi
2117
2118 case "x$ac_cv_prog_cc_stdc" in
2119   x|xno)
2120     echo "$as_me:2120: result: none needed" >&5
2121 echo "${ECHO_T}none needed" >&6 ;;
2122   *)
2123     echo "$as_me:2123: result: $ac_cv_prog_cc_stdc" >&5
2124 echo "${ECHO_T}$ac_cv_prog_cc_stdc" >&6
2125     CC="$CC $ac_cv_prog_cc_stdc" ;;
2126 esac
2127
2128 # This should have been defined by AC_PROG_CC
2129 : "${CC:=cc}"
2130
2131 echo "$as_me:2131: checking \$CFLAGS variable" >&5
2132 echo $ECHO_N "checking \$CFLAGS variable... $ECHO_C" >&6
2133 case "x$CFLAGS" in
2134 (*-[IUD]*)
2135         echo "$as_me:2135: result: broken" >&5
2136 echo "${ECHO_T}broken" >&6
2137         { echo "$as_me:2137: WARNING: your environment uses the CFLAGS variable to hold CPPFLAGS options" >&5
2138 echo "$as_me: WARNING: your environment uses the CFLAGS variable to hold CPPFLAGS options" >&2;}
2139         cf_flags="$CFLAGS"
2140         CFLAGS=
2141         for cf_arg in $cf_flags
2142         do
2143
2144 cf_fix_cppflags=no
2145 cf_new_cflags=
2146 cf_new_cppflags=
2147 cf_new_extra_cppflags=
2148
2149 for cf_add_cflags in $cf_arg
2150 do
2151 case "$cf_fix_cppflags" in
2152 (no)
2153         case "$cf_add_cflags" in
2154         (-undef|-nostdinc*|-I*|-D*|-U*|-E|-P|-C)
2155                 case "$cf_add_cflags" in
2156                 (-D*)
2157                         cf_tst_cflags=`echo "${cf_add_cflags}" |sed -e 's/^-D[^=]*='\''\"[^"]*//'`
2158
2159                         test "x${cf_add_cflags}" != "x${cf_tst_cflags}" \
2160                                 && test -z "${cf_tst_cflags}" \
2161                                 && cf_fix_cppflags=yes
2162
2163                         if test "$cf_fix_cppflags" = yes ; then
2164
2165         test -n "$cf_new_extra_cppflags" && cf_new_extra_cppflags="$cf_new_extra_cppflags "
2166         cf_new_extra_cppflags="${cf_new_extra_cppflags}$cf_add_cflags"
2167
2168                                 continue
2169                         elif test "${cf_tst_cflags}" = "\"'" ; then
2170
2171         test -n "$cf_new_extra_cppflags" && cf_new_extra_cppflags="$cf_new_extra_cppflags "
2172         cf_new_extra_cppflags="${cf_new_extra_cppflags}$cf_add_cflags"
2173
2174                                 continue
2175                         fi
2176                         ;;
2177                 esac
2178                 case "$CPPFLAGS" in
2179                 (*$cf_add_cflags)
2180                         ;;
2181                 (*)
2182                         case "$cf_add_cflags" in
2183                         (-D*)
2184                                 cf_tst_cppflags=`echo "x$cf_add_cflags" | sed -e 's/^...//' -e 's/=.*//'`
2185
2186 CPPFLAGS=`echo "$CPPFLAGS" | \
2187         sed     -e 's/-[UD]'"$cf_tst_cppflags"'\(=[^    ]*\)\?[         ]/ /g' \
2188                 -e 's/-[UD]'"$cf_tst_cppflags"'\(=[^    ]*\)\?$//g'`
2189
2190                                 ;;
2191                         esac
2192
2193         test -n "$cf_new_cppflags" && cf_new_cppflags="$cf_new_cppflags "
2194         cf_new_cppflags="${cf_new_cppflags}$cf_add_cflags"
2195
2196                         ;;
2197                 esac
2198                 ;;
2199         (*)
2200
2201         test -n "$cf_new_cflags" && cf_new_cflags="$cf_new_cflags "
2202         cf_new_cflags="${cf_new_cflags}$cf_add_cflags"
2203
2204                 ;;
2205         esac
2206         ;;
2207 (yes)
2208
2209         test -n "$cf_new_extra_cppflags" && cf_new_extra_cppflags="$cf_new_extra_cppflags "
2210         cf_new_extra_cppflags="${cf_new_extra_cppflags}$cf_add_cflags"
2211
2212         cf_tst_cflags=`echo "${cf_add_cflags}" |sed -e 's/^[^"]*"'\''//'`
2213
2214         test "x${cf_add_cflags}" != "x${cf_tst_cflags}" \
2215                 && test -z "${cf_tst_cflags}" \
2216                 && cf_fix_cppflags=no
2217         ;;
2218 esac
2219 done
2220
2221 if test -n "$cf_new_cflags" ; then
2222
2223         test -n "$CFLAGS" && CFLAGS="$CFLAGS "
2224         CFLAGS="${CFLAGS}$cf_new_cflags"
2225
2226 fi
2227
2228 if test -n "$cf_new_cppflags" ; then
2229
2230         test -n "$CPPFLAGS" && CPPFLAGS="$CPPFLAGS "
2231         CPPFLAGS="${CPPFLAGS}$cf_new_cppflags"
2232
2233 fi
2234
2235 if test -n "$cf_new_extra_cppflags" ; then
2236
2237         test -n "$EXTRA_CPPFLAGS" && EXTRA_CPPFLAGS="$EXTRA_CPPFLAGS "
2238         EXTRA_CPPFLAGS="${EXTRA_CPPFLAGS}$cf_new_extra_cppflags"
2239
2240 fi
2241
2242         done
2243         ;;
2244 (*)
2245         echo "$as_me:2245: result: ok" >&5
2246 echo "${ECHO_T}ok" >&6
2247         ;;
2248 esac
2249
2250 echo "$as_me:2250: checking \$CC variable" >&5
2251 echo $ECHO_N "checking \$CC variable... $ECHO_C" >&6
2252 case "$CC" in
2253 (*[\ \  ]-*)
2254         echo "$as_me:2254: result: broken" >&5
2255 echo "${ECHO_T}broken" >&6
2256         { echo "$as_me:2256: WARNING: your environment uses the CC variable to hold CFLAGS/CPPFLAGS options" >&5
2257 echo "$as_me: WARNING: your environment uses the CC variable to hold CFLAGS/CPPFLAGS options" >&2;}
2258         # humor him...
2259         cf_prog=`echo "$CC" | sed -e 's/        / /g' -e 's/[ ]* / /g' -e 's/[ ]*[ ]-[^ ].*//'`
2260         cf_flags=`echo "$CC" | ${AWK:-awk} -v prog="$cf_prog" '{ printf("%s", substr($0,1+length(prog))); }'`
2261         CC="$cf_prog"
2262         for cf_arg in $cf_flags
2263         do
2264                 case "x$cf_arg" in
2265                 (x-[IUDfgOW]*)
2266
2267 cf_fix_cppflags=no
2268 cf_new_cflags=
2269 cf_new_cppflags=
2270 cf_new_extra_cppflags=
2271
2272 for cf_add_cflags in $cf_arg
2273 do
2274 case "$cf_fix_cppflags" in
2275 (no)
2276         case "$cf_add_cflags" in
2277         (-undef|-nostdinc*|-I*|-D*|-U*|-E|-P|-C)
2278                 case "$cf_add_cflags" in
2279                 (-D*)
2280                         cf_tst_cflags=`echo "${cf_add_cflags}" |sed -e 's/^-D[^=]*='\''\"[^"]*//'`
2281
2282                         test "x${cf_add_cflags}" != "x${cf_tst_cflags}" \
2283                                 && test -z "${cf_tst_cflags}" \
2284                                 && cf_fix_cppflags=yes
2285
2286                         if test "$cf_fix_cppflags" = yes ; then
2287
2288         test -n "$cf_new_extra_cppflags" && cf_new_extra_cppflags="$cf_new_extra_cppflags "
2289         cf_new_extra_cppflags="${cf_new_extra_cppflags}$cf_add_cflags"
2290
2291                                 continue
2292                         elif test "${cf_tst_cflags}" = "\"'" ; then
2293
2294         test -n "$cf_new_extra_cppflags" && cf_new_extra_cppflags="$cf_new_extra_cppflags "
2295         cf_new_extra_cppflags="${cf_new_extra_cppflags}$cf_add_cflags"
2296
2297                                 continue
2298                         fi
2299                         ;;
2300                 esac
2301                 case "$CPPFLAGS" in
2302                 (*$cf_add_cflags)
2303                         ;;
2304                 (*)
2305                         case "$cf_add_cflags" in
2306                         (-D*)
2307                                 cf_tst_cppflags=`echo "x$cf_add_cflags" | sed -e 's/^...//' -e 's/=.*//'`
2308
2309 CPPFLAGS=`echo "$CPPFLAGS" | \
2310         sed     -e 's/-[UD]'"$cf_tst_cppflags"'\(=[^    ]*\)\?[         ]/ /g' \
2311                 -e 's/-[UD]'"$cf_tst_cppflags"'\(=[^    ]*\)\?$//g'`
2312
2313                                 ;;
2314                         esac
2315
2316         test -n "$cf_new_cppflags" && cf_new_cppflags="$cf_new_cppflags "
2317         cf_new_cppflags="${cf_new_cppflags}$cf_add_cflags"
2318
2319                         ;;
2320                 esac
2321                 ;;
2322         (*)
2323
2324         test -n "$cf_new_cflags" && cf_new_cflags="$cf_new_cflags "
2325         cf_new_cflags="${cf_new_cflags}$cf_add_cflags"
2326
2327                 ;;
2328         esac
2329         ;;
2330 (yes)
2331
2332         test -n "$cf_new_extra_cppflags" && cf_new_extra_cppflags="$cf_new_extra_cppflags "
2333         cf_new_extra_cppflags="${cf_new_extra_cppflags}$cf_add_cflags"
2334
2335         cf_tst_cflags=`echo "${cf_add_cflags}" |sed -e 's/^[^"]*"'\''//'`
2336
2337         test "x${cf_add_cflags}" != "x${cf_tst_cflags}" \
2338                 && test -z "${cf_tst_cflags}" \
2339                 && cf_fix_cppflags=no
2340         ;;
2341 esac
2342 done
2343
2344 if test -n "$cf_new_cflags" ; then
2345
2346         test -n "$CFLAGS" && CFLAGS="$CFLAGS "
2347         CFLAGS="${CFLAGS}$cf_new_cflags"
2348
2349 fi
2350
2351 if test -n "$cf_new_cppflags" ; then
2352
2353         test -n "$CPPFLAGS" && CPPFLAGS="$CPPFLAGS "
2354         CPPFLAGS="${CPPFLAGS}$cf_new_cppflags"
2355
2356 fi
2357
2358 if test -n "$cf_new_extra_cppflags" ; then
2359
2360         test -n "$EXTRA_CPPFLAGS" && EXTRA_CPPFLAGS="$EXTRA_CPPFLAGS "
2361         EXTRA_CPPFLAGS="${EXTRA_CPPFLAGS}$cf_new_extra_cppflags"
2362
2363 fi
2364
2365                         ;;
2366                 (*)
2367                         CC="$CC $cf_arg"
2368                         ;;
2369                 esac
2370         done
2371         test -n "$verbose" && echo "    resulting CC: '$CC'" 1>&6
2372
2373 echo "${as_me:-configure}:2373: testing resulting CC: '$CC' ..." 1>&5
2374
2375         test -n "$verbose" && echo "    resulting CFLAGS: '$CFLAGS'" 1>&6
2376
2377 echo "${as_me:-configure}:2377: testing resulting CFLAGS: '$CFLAGS' ..." 1>&5
2378
2379         test -n "$verbose" && echo "    resulting CPPFLAGS: '$CPPFLAGS'" 1>&6
2380
2381 echo "${as_me:-configure}:2381: testing resulting CPPFLAGS: '$CPPFLAGS' ..." 1>&5
2382
2383         ;;
2384 (*)
2385         echo "$as_me:2385: result: ok" >&5
2386 echo "${ECHO_T}ok" >&6
2387         ;;
2388 esac
2389
2390 echo "$as_me:2390: checking for egrep" >&5
2391 echo $ECHO_N "checking for egrep... $ECHO_C" >&6
2392 if test "${ac_cv_path_EGREP+set}" = set; then
2393   echo $ECHO_N "(cached) $ECHO_C" >&6
2394 else
2395   if echo a | $GREP -E '(a|b)' >/dev/null 2>&1
2396    then ac_cv_path_EGREP="$GREP -E"
2397    else
2398      for ac_prog in gegrep egrep
2399 do
2400   # Extract the first word of "$ac_prog", so it can be a program name with args.
2401 set dummy $ac_prog; ac_word=$2
2402 echo "$as_me:2402: checking for $ac_word" >&5
2403 echo $ECHO_N "checking for $ac_word... $ECHO_C" >&6
2404 if test "${ac_cv_path_EGREP+set}" = set; then
2405   echo $ECHO_N "(cached) $ECHO_C" >&6
2406 else
2407   case $EGREP in
2408   [\\/]* | ?:[\\/]*)
2409   ac_cv_path_EGREP="$EGREP" # Let the user override the test with a path.
2410   ;;
2411   *)
2412   ac_save_IFS=$IFS; IFS=$ac_path_separator
2413 ac_dummy="$PATH"
2414 for ac_dir in $ac_dummy; do
2415   IFS=$ac_save_IFS
2416   test -z "$ac_dir" && ac_dir=.
2417   if $as_executable_p "$ac_dir/$ac_word"; then
2418    ac_cv_path_EGREP="$ac_dir/$ac_word"
2419    echo "$as_me:2419: found $ac_dir/$ac_word" >&5
2420    break
2421 fi
2422 done
2423
2424   ;;
2425 esac
2426 fi
2427 EGREP=$ac_cv_path_EGREP
2428
2429 if test -n "$EGREP"; then
2430   echo "$as_me:2430: result: $EGREP" >&5
2431 echo "${ECHO_T}$EGREP" >&6
2432 else
2433   echo "$as_me:2433: result: no" >&5
2434 echo "${ECHO_T}no" >&6
2435 fi
2436
2437   test -n "$EGREP" && break
2438 done
2439 test -n "$EGREP" || EGREP=": "
2440
2441      test "x$ac_cv_path_EGREP" = "x:" && { { echo "$as_me:2441: error: cannot find workable egrep" >&5
2442 echo "$as_me: error: cannot find workable egrep" >&2;}
2443    { (exit 1); exit 1; }; }
2444    fi
2445 fi
2446 echo "$as_me:2446: result: $ac_cv_path_EGREP" >&5
2447 echo "${ECHO_T}$ac_cv_path_EGREP" >&6
2448  EGREP="$ac_cv_path_EGREP"
2449
2450 ac_ext=c
2451 ac_cpp='$CPP $CPPFLAGS'
2452 ac_compile='$CC -c $CFLAGS $CPPFLAGS "conftest.$ac_ext" >&5'
2453 ac_link='$CC -o "conftest$ac_exeext" $CFLAGS $CPPFLAGS $LDFLAGS "conftest.$ac_ext" $LIBS >&5'
2454 ac_compiler_gnu=$ac_cv_c_compiler_gnu
2455 ac_main_return="return"
2456 echo "$as_me:2456: checking how to run the C preprocessor" >&5
2457 echo $ECHO_N "checking how to run the C preprocessor... $ECHO_C" >&6
2458 # On Suns, sometimes $CPP names a directory.
2459 if test -n "$CPP" && test -d "$CPP"; then
2460   CPP=
2461 fi
2462 if test -z "$CPP"; then
2463   if test "${ac_cv_prog_CPP+set}" = set; then
2464   echo $ECHO_N "(cached) $ECHO_C" >&6
2465 else
2466       # Double quotes because CPP needs to be expanded
2467     for CPP in "$CC -E" "$CC -E -traditional-cpp" "/lib/cpp"
2468     do
2469       ac_preproc_ok=false
2470 for ac_c_preproc_warn_flag in '' yes
2471 do
2472   # Use a header file that comes with gcc, so configuring glibc
2473   # with a fresh cross-compiler works.
2474   # On the NeXT, cc -E runs the code through the compiler's parser,
2475   # not just through cpp. "Syntax error" is here to catch this case.
2476   cat >"conftest.$ac_ext" <<_ACEOF
2477 #line 2477 "configure"
2478 #include "confdefs.h"
2479 #include <assert.h>
2480                      Syntax error
2481 _ACEOF
2482 if { (eval echo "$as_me:2482: \"$ac_cpp "conftest.$ac_ext"\"") >&5
2483   (eval $ac_cpp "conftest.$ac_ext") 2>conftest.er1
2484   ac_status=$?
2485   $EGREP -v '^ *\+' conftest.er1 >conftest.err
2486   rm -f conftest.er1
2487   cat conftest.err >&5
2488   echo "$as_me:2488: \$? = $ac_status" >&5
2489   (exit "$ac_status"); } >/dev/null; then
2490   if test -s conftest.err; then
2491     ac_cpp_err=$ac_c_preproc_warn_flag
2492   else
2493     ac_cpp_err=
2494   fi
2495 else
2496   ac_cpp_err=yes
2497 fi
2498 if test -z "$ac_cpp_err"; then
2499   :
2500 else
2501   echo "$as_me: failed program was:" >&5
2502   cat "conftest.$ac_ext" >&5
2503   # Broken: fails on valid input.
2504 continue
2505 fi
2506 rm -f conftest.err "conftest.$ac_ext"
2507
2508   # OK, works on sane cases.  Now check whether non-existent headers
2509   # can be detected and how.
2510   cat >"conftest.$ac_ext" <<_ACEOF
2511 #line 2511 "configure"
2512 #include "confdefs.h"
2513 #include <ac_nonexistent.h>
2514 _ACEOF
2515 if { (eval echo "$as_me:2515: \"$ac_cpp "conftest.$ac_ext"\"") >&5
2516   (eval $ac_cpp "conftest.$ac_ext") 2>conftest.er1
2517   ac_status=$?
2518   $EGREP -v '^ *\+' conftest.er1 >conftest.err
2519   rm -f conftest.er1
2520   cat conftest.err >&5
2521   echo "$as_me:2521: \$? = $ac_status" >&5
2522   (exit "$ac_status"); } >/dev/null; then
2523   if test -s conftest.err; then
2524     ac_cpp_err=$ac_c_preproc_warn_flag
2525   else
2526     ac_cpp_err=
2527   fi
2528 else
2529   ac_cpp_err=yes
2530 fi
2531 if test -z "$ac_cpp_err"; then
2532   # Broken: success on invalid input.
2533 continue
2534 else
2535   echo "$as_me: failed program was:" >&5
2536   cat "conftest.$ac_ext" >&5
2537   # Passes both tests.
2538 ac_preproc_ok=:
2539 break
2540 fi
2541 rm -f conftest.err "conftest.$ac_ext"
2542
2543 done
2544 # Because of `break', _AC_PREPROC_IFELSE's cleaning code was skipped.
2545 rm -f conftest.err "conftest.$ac_ext"
2546 if $ac_preproc_ok; then
2547   break
2548 fi
2549
2550     done
2551     ac_cv_prog_CPP=$CPP
2552
2553 fi
2554   CPP=$ac_cv_prog_CPP
2555 else
2556   ac_cv_prog_CPP=$CPP
2557 fi
2558 echo "$as_me:2558: result: $CPP" >&5
2559 echo "${ECHO_T}$CPP" >&6
2560 ac_preproc_ok=false
2561 for ac_c_preproc_warn_flag in '' yes
2562 do
2563   # Use a header file that comes with gcc, so configuring glibc
2564   # with a fresh cross-compiler works.
2565   # On the NeXT, cc -E runs the code through the compiler's parser,
2566   # not just through cpp. "Syntax error" is here to catch this case.
2567   cat >"conftest.$ac_ext" <<_ACEOF
2568 #line 2568 "configure"
2569 #include "confdefs.h"
2570 #include <assert.h>
2571                      Syntax error
2572 _ACEOF
2573 if { (eval echo "$as_me:2573: \"$ac_cpp "conftest.$ac_ext"\"") >&5
2574   (eval $ac_cpp "conftest.$ac_ext") 2>conftest.er1
2575   ac_status=$?
2576   $EGREP -v '^ *\+' conftest.er1 >conftest.err
2577   rm -f conftest.er1
2578   cat conftest.err >&5
2579   echo "$as_me:2579: \$? = $ac_status" >&5
2580   (exit "$ac_status"); } >/dev/null; then
2581   if test -s conftest.err; then
2582     ac_cpp_err=$ac_c_preproc_warn_flag
2583   else
2584     ac_cpp_err=
2585   fi
2586 else
2587   ac_cpp_err=yes
2588 fi
2589 if test -z "$ac_cpp_err"; then
2590   :
2591 else
2592   echo "$as_me: failed program was:" >&5
2593   cat "conftest.$ac_ext" >&5
2594   # Broken: fails on valid input.
2595 continue
2596 fi
2597 rm -f conftest.err "conftest.$ac_ext"
2598
2599   # OK, works on sane cases.  Now check whether non-existent headers
2600   # can be detected and how.
2601   cat >"conftest.$ac_ext" <<_ACEOF
2602 #line 2602 "configure"
2603 #include "confdefs.h"
2604 #include <ac_nonexistent.h>
2605 _ACEOF
2606 if { (eval echo "$as_me:2606: \"$ac_cpp "conftest.$ac_ext"\"") >&5
2607   (eval $ac_cpp "conftest.$ac_ext") 2>conftest.er1
2608   ac_status=$?
2609   $EGREP -v '^ *\+' conftest.er1 >conftest.err
2610   rm -f conftest.er1
2611   cat conftest.err >&5
2612   echo "$as_me:2612: \$? = $ac_status" >&5
2613   (exit "$ac_status"); } >/dev/null; then
2614   if test -s conftest.err; then
2615     ac_cpp_err=$ac_c_preproc_warn_flag
2616   else
2617     ac_cpp_err=
2618   fi
2619 else
2620   ac_cpp_err=yes
2621 fi
2622 if test -z "$ac_cpp_err"; then
2623   # Broken: success on invalid input.
2624 continue
2625 else
2626   echo "$as_me: failed program was:" >&5
2627   cat "conftest.$ac_ext" >&5
2628   # Passes both tests.
2629 ac_preproc_ok=:
2630 break
2631 fi
2632 rm -f conftest.err "conftest.$ac_ext"
2633
2634 done
2635 # Because of `break', _AC_PREPROC_IFELSE's cleaning code was skipped.
2636 rm -f conftest.err "conftest.$ac_ext"
2637 if $ac_preproc_ok; then
2638   :
2639 else
2640   { { echo "$as_me:2640: error: C preprocessor \"$CPP\" fails sanity check" >&5
2641 echo "$as_me: error: C preprocessor \"$CPP\" fails sanity check" >&2;}
2642    { (exit 1); exit 1; }; }
2643 fi
2644
2645 ac_ext=c
2646 ac_cpp='$CPP $CPPFLAGS'
2647 ac_compile='$CC -c $CFLAGS $CPPFLAGS "conftest.$ac_ext" >&5'
2648 ac_link='$CC -o "conftest$ac_exeext" $CFLAGS $CPPFLAGS $LDFLAGS "conftest.$ac_ext" $LIBS >&5'
2649 ac_compiler_gnu=$ac_cv_c_compiler_gnu
2650 ac_main_return="return"
2651
2652 if test $ac_cv_c_compiler_gnu = yes; then
2653     echo "$as_me:2653: checking whether $CC needs -traditional" >&5
2654 echo $ECHO_N "checking whether $CC needs -traditional... $ECHO_C" >&6
2655 if test "${ac_cv_prog_gcc_traditional+set}" = set; then
2656   echo $ECHO_N "(cached) $ECHO_C" >&6
2657 else
2658     ac_pattern="Autoconf.*'x'"
2659   cat >"conftest.$ac_ext" <<_ACEOF
2660 #line 2660 "configure"
2661 #include "confdefs.h"
2662 #include <sgtty.h>
2663 int Autoconf = TIOCGETP;
2664 _ACEOF
2665 if (eval "$ac_cpp conftest.$ac_ext") 2>&5 |
2666   $EGREP "$ac_pattern" >/dev/null 2>&1; then
2667   ac_cv_prog_gcc_traditional=yes
2668 else
2669   ac_cv_prog_gcc_traditional=no
2670 fi
2671 rm -rf conftest*
2672
2673   if test $ac_cv_prog_gcc_traditional = no; then
2674     cat >"conftest.$ac_ext" <<_ACEOF
2675 #line 2675 "configure"
2676 #include "confdefs.h"
2677 #include <termio.h>
2678 int Autoconf = TCGETA;
2679 _ACEOF
2680 if (eval "$ac_cpp conftest.$ac_ext") 2>&5 |
2681   $EGREP "$ac_pattern" >/dev/null 2>&1; then
2682   ac_cv_prog_gcc_traditional=yes
2683 fi
2684 rm -rf conftest*
2685
2686   fi
2687 fi
2688 echo "$as_me:2688: result: $ac_cv_prog_gcc_traditional" >&5
2689 echo "${ECHO_T}$ac_cv_prog_gcc_traditional" >&6
2690   if test $ac_cv_prog_gcc_traditional = yes; then
2691     CC="$CC -traditional"
2692   fi
2693 fi
2694
2695 echo "$as_me:2695: checking whether $CC understands -c and -o together" >&5
2696 echo $ECHO_N "checking whether $CC understands -c and -o together... $ECHO_C" >&6
2697 if test "${cf_cv_prog_CC_c_o+set}" = set; then
2698   echo $ECHO_N "(cached) $ECHO_C" >&6
2699 else
2700
2701 cat > conftest.$ac_ext <<CF_EOF
2702 int main(void)
2703 {
2704         ${cf_cv_main_return:-return}(0);
2705 }
2706 CF_EOF
2707 # We do the test twice because some compilers refuse to overwrite an
2708 # existing .o file with -o, though they will create one.
2709 ac_try='$CC $CFLAGS $CPPFLAGS -c conftest.$ac_ext -o conftest2.$ac_objext >&5'
2710 if { (eval echo "$as_me:2710: \"$ac_try\"") >&5
2711   (eval $ac_try) 2>&5
2712   ac_status=$?
2713   echo "$as_me:2713: \$? = $ac_status" >&5
2714   (exit "$ac_status"); } &&
2715   test -f conftest2.$ac_objext && { (eval echo "$as_me:2715: \"$ac_try\"") >&5
2716   (eval $ac_try) 2>&5
2717   ac_status=$?
2718   echo "$as_me:2718: \$? = $ac_status" >&5
2719   (exit "$ac_status"); };
2720 then
2721   eval cf_cv_prog_CC_c_o=yes
2722 else
2723   eval cf_cv_prog_CC_c_o=no
2724 fi
2725 rm -rf ./conftest*
2726
2727 fi
2728 if test "$cf_cv_prog_CC_c_o" = yes; then
2729   echo "$as_me:2729: result: yes" >&5
2730 echo "${ECHO_T}yes" >&6
2731 else
2732   echo "$as_me:2732: result: no" >&5
2733 echo "${ECHO_T}no" >&6
2734 fi
2735
2736 test "$program_prefix" != NONE &&
2737   program_transform_name="s,^,$program_prefix,;$program_transform_name"
2738 # Use a double $ so make ignores it.
2739 test "$program_suffix" != NONE &&
2740   program_transform_name="s,\$,$program_suffix,;$program_transform_name"
2741 # Double any \ or $.  echo might interpret backslashes.
2742 # By default was `s,x,x', remove it if useless.
2743 cat <<\_ACEOF >conftest.sed
2744 s/[\\$]/&&/g;s/;s,x,x,$//
2745 _ACEOF
2746 program_transform_name=`echo $program_transform_name | sed -f conftest.sed`
2747 rm conftest.sed
2748
2749 for ac_prog in mawk gawk nawk awk
2750 do
2751   # Extract the first word of "$ac_prog", so it can be a program name with args.
2752 set dummy $ac_prog; ac_word=$2
2753 echo "$as_me:2753: checking for $ac_word" >&5
2754 echo $ECHO_N "checking for $ac_word... $ECHO_C" >&6
2755 if test "${ac_cv_prog_AWK+set}" = set; then
2756   echo $ECHO_N "(cached) $ECHO_C" >&6
2757 else
2758   if test -n "$AWK"; then
2759   ac_cv_prog_AWK="$AWK" # Let the user override the test.
2760 else
2761   ac_save_IFS=$IFS; IFS=$ac_path_separator
2762 ac_dummy="$PATH"
2763 for ac_dir in $ac_dummy; do
2764   IFS=$ac_save_IFS
2765   test -z "$ac_dir" && ac_dir=.
2766   $as_executable_p "$ac_dir/$ac_word" || continue
2767 ac_cv_prog_AWK="$ac_prog"
2768 echo "$as_me:2768: found $ac_dir/$ac_word" >&5
2769 break
2770 done
2771
2772 fi
2773 fi
2774 AWK=$ac_cv_prog_AWK
2775 if test -n "$AWK"; then
2776   echo "$as_me:2776: result: $AWK" >&5
2777 echo "${ECHO_T}$AWK" >&6
2778 else
2779   echo "$as_me:2779: result: no" >&5
2780 echo "${ECHO_T}no" >&6
2781 fi
2782
2783   test -n "$AWK" && break
2784 done
2785
2786 test -z "$AWK" && { { echo "$as_me:2786: error: No awk program found" >&5
2787 echo "$as_me: error: No awk program found" >&2;}
2788    { (exit 1); exit 1; }; }
2789
2790 echo "$as_me:2790: checking for egrep" >&5
2791 echo $ECHO_N "checking for egrep... $ECHO_C" >&6
2792 if test "${ac_cv_prog_egrep+set}" = set; then
2793   echo $ECHO_N "(cached) $ECHO_C" >&6
2794 else
2795   if echo a | (grep -E '(a|b)') >/dev/null 2>&1
2796                 then ac_cv_prog_egrep='grep -E'
2797                 else ac_cv_prog_egrep='egrep'
2798         fi
2799 fi
2800 echo "$as_me:2800: result: $ac_cv_prog_egrep" >&5
2801 echo "${ECHO_T}$ac_cv_prog_egrep" >&6
2802         EGREP=$ac_cv_prog_egrep
2803
2804         test -z "$EGREP" && { { echo "$as_me:2804: error: No egrep program found" >&5
2805 echo "$as_me: error: No egrep program found" >&2;}
2806    { (exit 1); exit 1; }; }
2807
2808 # Find a good install program.  We prefer a C program (faster),
2809 # so one script is as good as another.  But avoid the broken or
2810 # incompatible versions:
2811 # SysV /etc/install, /usr/sbin/install
2812 # SunOS /usr/etc/install
2813 # IRIX /sbin/install
2814 # AIX /bin/install
2815 # AmigaOS /C/install, which installs bootblocks on floppy discs
2816 # AIX 4 /usr/bin/installbsd, which doesn't work without a -g flag
2817 # AFS /usr/afsws/bin/install, which mishandles nonexistent args
2818 # SVR4 /usr/ucb/install, which tries to use the nonexistent group "staff"
2819 # ./install, which can be erroneously created by make from ./install.sh.
2820 echo "$as_me:2820: checking for a BSD compatible install" >&5
2821 echo $ECHO_N "checking for a BSD compatible install... $ECHO_C" >&6
2822 if test -z "$INSTALL"; then
2823 if test "${ac_cv_path_install+set}" = set; then
2824   echo $ECHO_N "(cached) $ECHO_C" >&6
2825 else
2826     ac_save_IFS=$IFS; IFS=$ac_path_separator
2827   for ac_dir in $PATH; do
2828     IFS=$ac_save_IFS
2829     # Account for people who put trailing slashes in PATH elements.
2830     case $ac_dir/ in
2831     / | ./ | .// | /cC/* \
2832     | /etc/* | /usr/sbin/* | /usr/etc/* | /sbin/* | /usr/afsws/bin/* \
2833     | /usr/ucb/* ) ;;
2834     *)
2835       # OSF1 and SCO ODT 3.0 have their own names for install.
2836       # Don't use installbsd from OSF since it installs stuff as root
2837       # by default.
2838       for ac_prog in ginstall scoinst install; do
2839         if $as_executable_p "$ac_dir/$ac_prog"; then
2840           if test $ac_prog = install &&
2841             grep dspmsg "$ac_dir/$ac_prog" >/dev/null 2>&1; then
2842             # AIX install.  It has an incompatible calling convention.
2843             :
2844           elif test $ac_prog = install &&
2845             grep pwplus "$ac_dir/$ac_prog" >/dev/null 2>&1; then
2846             # program-specific install script used by HP pwplus--don't use.
2847             :
2848           else
2849             ac_cv_path_install="$ac_dir/$ac_prog -c"
2850             break 2
2851           fi
2852         fi
2853       done
2854       ;;
2855     esac
2856   done
2857
2858 fi
2859   if test "${ac_cv_path_install+set}" = set; then
2860     INSTALL=$ac_cv_path_install
2861   else
2862     # As a last resort, use the slow shell script.  We don't cache a
2863     # path for INSTALL within a source directory, because that will
2864     # break other packages using the cache if that directory is
2865     # removed, or if the path is relative.
2866     INSTALL=$ac_install_sh
2867   fi
2868 fi
2869 echo "$as_me:2869: result: $INSTALL" >&5
2870 echo "${ECHO_T}$INSTALL" >&6
2871
2872 # Use test -z because SunOS4 sh mishandles braces in ${var-val}.
2873 # It thinks the first close brace ends the variable substitution.
2874 test -z "$INSTALL_PROGRAM" && INSTALL_PROGRAM='${INSTALL}'
2875
2876 test -z "$INSTALL_SCRIPT" && INSTALL_SCRIPT='${INSTALL}'
2877
2878 test -z "$INSTALL_DATA" && INSTALL_DATA='${INSTALL} -m 644'
2879
2880 echo "$as_me:2880: checking whether ln -s works" >&5
2881 echo $ECHO_N "checking whether ln -s works... $ECHO_C" >&6
2882 LN_S=$as_ln_s
2883 if test "$LN_S" = "ln -s"; then
2884   echo "$as_me:2884: result: yes" >&5
2885 echo "${ECHO_T}yes" >&6
2886 else
2887   echo "$as_me:2887: result: no, using $LN_S" >&5
2888 echo "${ECHO_T}no, using $LN_S" >&6
2889 fi
2890
2891 echo "$as_me:2891: checking if $LN_S -f options work" >&5
2892 echo $ECHO_N "checking if $LN_S -f options work... $ECHO_C" >&6
2893
2894 rm -f conf$$.src conf$$dst
2895 echo >conf$$.dst
2896 echo first >conf$$.src
2897 if $LN_S -f conf$$.src conf$$.dst 2>/dev/null; then
2898         cf_prog_ln_sf=yes
2899 else
2900         cf_prog_ln_sf=no
2901 fi
2902 rm -f conf$$.dst conf$$src
2903 echo "$as_me:2903: result: $cf_prog_ln_sf" >&5
2904 echo "${ECHO_T}$cf_prog_ln_sf" >&6
2905
2906 test "$cf_prog_ln_sf" = yes && LN_S="$LN_S -f"
2907
2908 # Find a good install program.  We prefer a C program (faster),
2909 # so one script is as good as another.  But avoid the broken or
2910 # incompatible versions:
2911 # SysV /etc/install, /usr/sbin/install
2912 # SunOS /usr/etc/install
2913 # IRIX /sbin/install
2914 # AIX /bin/install
2915 # AmigaOS /C/install, which installs bootblocks on floppy discs
2916 # AIX 4 /usr/bin/installbsd, which doesn't work without a -g flag
2917 # AFS /usr/afsws/bin/install, which mishandles nonexistent args
2918 # SVR4 /usr/ucb/install, which tries to use the nonexistent group "staff"
2919 # ./install, which can be erroneously created by make from ./install.sh.
2920 echo "$as_me:2920: checking for a BSD compatible install" >&5
2921 echo $ECHO_N "checking for a BSD compatible install... $ECHO_C" >&6
2922 if test -z "$INSTALL"; then
2923 if test "${ac_cv_path_install+set}" = set; then
2924   echo $ECHO_N "(cached) $ECHO_C" >&6
2925 else
2926     ac_save_IFS=$IFS; IFS=$ac_path_separator
2927   for ac_dir in $PATH; do
2928     IFS=$ac_save_IFS
2929     # Account for people who put trailing slashes in PATH elements.
2930     case $ac_dir/ in
2931     / | ./ | .// | /cC/* \
2932     | /etc/* | /usr/sbin/* | /usr/etc/* | /sbin/* | /usr/afsws/bin/* \
2933     | /usr/ucb/* ) ;;
2934     *)
2935       # OSF1 and SCO ODT 3.0 have their own names for install.
2936       # Don't use installbsd from OSF since it installs stuff as root
2937       # by default.
2938       for ac_prog in ginstall scoinst install; do
2939         if $as_executable_p "$ac_dir/$ac_prog"; then
2940           if test $ac_prog = install &&
2941             grep dspmsg "$ac_dir/$ac_prog" >/dev/null 2>&1; then
2942             # AIX install.  It has an incompatible calling convention.
2943             :
2944           elif test $ac_prog = install &&
2945             grep pwplus "$ac_dir/$ac_prog" >/dev/null 2>&1; then
2946             # program-specific install script used by HP pwplus--don't use.
2947             :
2948           else
2949             ac_cv_path_install="$ac_dir/$ac_prog -c"
2950             break 2
2951           fi
2952         fi
2953       done
2954       ;;
2955     esac
2956   done
2957
2958 fi
2959   if test "${ac_cv_path_install+set}" = set; then
2960     INSTALL=$ac_cv_path_install
2961   else
2962     # As a last resort, use the slow shell script.  We don't cache a
2963     # path for INSTALL within a source directory, because that will
2964     # break other packages using the cache if that directory is
2965     # removed, or if the path is relative.
2966     INSTALL=$ac_install_sh
2967   fi
2968 fi
2969 echo "$as_me:2969: result: $INSTALL" >&5
2970 echo "${ECHO_T}$INSTALL" >&6
2971
2972 # Use test -z because SunOS4 sh mishandles braces in ${var-val}.
2973 # It thinks the first close brace ends the variable substitution.
2974 test -z "$INSTALL_PROGRAM" && INSTALL_PROGRAM='${INSTALL}'
2975
2976 test -z "$INSTALL_SCRIPT" && INSTALL_SCRIPT='${INSTALL}'
2977
2978 test -z "$INSTALL_DATA" && INSTALL_DATA='${INSTALL} -m 644'
2979
2980 case $INSTALL in
2981 (/*)
2982         ;;
2983 (*)
2984         cf_dir=`echo "$INSTALL" | sed -e 's%/[^/]*$%%'`
2985         test -z "$cf_dir" && cf_dir=.
2986         INSTALL="`cd \"$cf_dir\" && pwd`"/"`echo "$INSTALL" | sed -e 's%^.*/%%'`"
2987         ;;
2988 esac
2989
2990 echo "$as_me:2990: checking if you want to install stripped executables" >&5
2991 echo $ECHO_N "checking if you want to install stripped executables... $ECHO_C" >&6
2992
2993 # Check whether --enable-stripping or --disable-stripping was given.
2994 if test "${enable_stripping+set}" = set; then
2995   enableval="$enable_stripping"
2996   test "$enableval" != no && enableval=yes
2997         if test "$enableval" != "yes" ; then
2998     enable_stripping=no
2999         else
3000                 enable_stripping=yes
3001         fi
3002 else
3003   enableval=yes
3004         enable_stripping=yes
3005
3006 fi;
3007 echo "$as_me:3007: result: $enable_stripping" >&5
3008 echo "${ECHO_T}$enable_stripping" >&6
3009
3010 if test "$enable_stripping" = yes
3011 then
3012         INSTALL_OPT_S="-s"
3013 else
3014         INSTALL_OPT_S=
3015 fi
3016
3017 : "${INSTALL:=install}"
3018 echo "$as_me:3018: checking if install accepts -p option" >&5
3019 echo $ECHO_N "checking if install accepts -p option... $ECHO_C" >&6
3020 if test "${cf_cv_install_p+set}" = set; then
3021   echo $ECHO_N "(cached) $ECHO_C" >&6
3022 else
3023
3024         rm -rf ./conftest*
3025         date >conftest.in
3026         mkdir conftest.out
3027         sleep 3
3028         if $INSTALL -p conftest.in conftest.out 2>/dev/null
3029         then
3030                 if test -f conftest.out/conftest.in
3031                 then
3032                         test conftest.in -nt conftest.out/conftest.in 2>conftest.err && \
3033                         test conftest.out/conftest.in -nt conftest.in 2>conftest.err
3034                         if test -s conftest.err
3035                         then
3036                                 cf_cv_install_p=no
3037                         else
3038                                 cf_cv_install_p=yes
3039                         fi
3040                 else
3041                         cf_cv_install_p=no
3042                 fi
3043         else
3044                 cf_cv_install_p=no
3045         fi
3046         rm -rf ./conftest*
3047
3048 fi
3049 echo "$as_me:3049: result: $cf_cv_install_p" >&5
3050 echo "${ECHO_T}$cf_cv_install_p" >&6
3051
3052 echo "$as_me:3052: checking if install needs to be told about ownership" >&5
3053 echo $ECHO_N "checking if install needs to be told about ownership... $ECHO_C" >&6
3054 case `$ac_config_guess` in
3055 (*minix)
3056         with_install_o=yes
3057         ;;
3058 (*)
3059         with_install_o=no
3060         ;;
3061 esac
3062
3063 echo "$as_me:3063: result: $with_install_o" >&5
3064 echo "${ECHO_T}$with_install_o" >&6
3065 if test "x$with_install_o" = xyes
3066 then
3067         INSTALL_OPT_O="`id root|sed -e 's/uid=[0-9]*(/ -o /' -e 's/gid=[0-9]*(/ -g /' -e 's/ [^=[:space:]][^=[:space:]]*=.*/ /' -e 's/)//g'`"
3068 else
3069         INSTALL_OPT_O=
3070 fi
3071
3072 echo "$as_me:3072: checking for long file names" >&5
3073 echo $ECHO_N "checking for long file names... $ECHO_C" >&6
3074 if test "${ac_cv_sys_long_file_names+set}" = set; then
3075   echo $ECHO_N "(cached) $ECHO_C" >&6
3076 else
3077   ac_cv_sys_long_file_names=yes
3078 # Test for long file names in all the places we know might matter:
3079 #      .                the current directory, where building will happen
3080 #      $prefix/lib      where we will be installing things
3081 #      $exec_prefix/lib likewise
3082 # eval it to expand exec_prefix.
3083 #      $TMPDIR          if set, where it might want to write temporary files
3084 # if $TMPDIR is not set:
3085 #      /tmp             where it might want to write temporary files
3086 #      /var/tmp         likewise
3087 #      /usr/tmp         likewise
3088 if test -n "$TMPDIR" && test -d "$TMPDIR" && test -w "$TMPDIR"; then
3089   ac_tmpdirs=$TMPDIR
3090 else
3091   ac_tmpdirs='/tmp /var/tmp /usr/tmp'
3092 fi
3093 for ac_dir in  . $ac_tmpdirs `eval echo "$prefix/lib" "$exec_prefix/lib"` ; do
3094   test -d "$ac_dir" || continue
3095   test -w "$ac_dir" || continue # It is less confusing to not echo anything here.
3096   ac_xdir=$ac_dir/cf$$
3097   (umask 077 && mkdir "$ac_xdir" 2>/dev/null) || continue
3098   ac_tf1=$ac_xdir/conftest9012345
3099   ac_tf2=$ac_xdir/conftest9012346
3100   (echo 1 >"$ac_tf1") 2>/dev/null
3101   (echo 2 >"$ac_tf2") 2>/dev/null
3102   ac_val=`cat "$ac_tf1" 2>/dev/null`
3103   if test ! -f "$ac_tf1" || test "$ac_val" != 1; then
3104     ac_cv_sys_long_file_names=no
3105     rm -rf "$ac_xdir" 2>/dev/null
3106     break
3107   fi
3108   rm -rf "$ac_xdir" 2>/dev/null
3109 done
3110 fi
3111 echo "$as_me:3111: result: $ac_cv_sys_long_file_names" >&5
3112 echo "${ECHO_T}$ac_cv_sys_long_file_names" >&6
3113 if test "$ac_cv_sys_long_file_names" = yes; then
3114
3115 cat >>confdefs.h <<\EOF
3116 #define HAVE_LONG_FILE_NAMES 1
3117 EOF
3118
3119 fi
3120
3121 # if we find pkg-config, check if we should install the ".pc" files.
3122
3123 echo "$as_me:3123: checking if you want to use pkg-config" >&5
3124 echo $ECHO_N "checking if you want to use pkg-config... $ECHO_C" >&6
3125
3126 # Check whether --with-pkg-config or --without-pkg-config was given.
3127 if test "${with_pkg_config+set}" = set; then
3128   withval="$with_pkg_config"
3129   cf_pkg_config=$withval
3130 else
3131   cf_pkg_config=yes
3132 fi;
3133 echo "$as_me:3133: result: $cf_pkg_config" >&5
3134 echo "${ECHO_T}$cf_pkg_config" >&6
3135
3136 case "$cf_pkg_config" in
3137 (no)
3138         PKG_CONFIG=none
3139         ;;
3140 (yes)
3141
3142 if test -n "$ac_tool_prefix"; then
3143   # Extract the first word of "${ac_tool_prefix}pkg-config", so it can be a program name with args.
3144 set dummy ${ac_tool_prefix}pkg-config; ac_word=$2
3145 echo "$as_me:3145: checking for $ac_word" >&5
3146 echo $ECHO_N "checking for $ac_word... $ECHO_C" >&6
3147 if test "${ac_cv_path_PKG_CONFIG+set}" = set; then
3148   echo $ECHO_N "(cached) $ECHO_C" >&6
3149 else
3150   case $PKG_CONFIG in
3151   [\\/]* | ?:[\\/]*)
3152   ac_cv_path_PKG_CONFIG="$PKG_CONFIG" # Let the user override the test with a path.
3153   ;;
3154   *)
3155   ac_save_IFS=$IFS; IFS=$ac_path_separator
3156 ac_dummy="$PATH"
3157 for ac_dir in $ac_dummy; do
3158   IFS=$ac_save_IFS
3159   test -z "$ac_dir" && ac_dir=.
3160   if $as_executable_p "$ac_dir/$ac_word"; then
3161    ac_cv_path_PKG_CONFIG="$ac_dir/$ac_word"
3162    echo "$as_me:3162: found $ac_dir/$ac_word" >&5
3163    break
3164 fi
3165 done
3166
3167   ;;
3168 esac
3169 fi
3170 PKG_CONFIG=$ac_cv_path_PKG_CONFIG
3171
3172 if test -n "$PKG_CONFIG"; then
3173   echo "$as_me:3173: result: $PKG_CONFIG" >&5
3174 echo "${ECHO_T}$PKG_CONFIG" >&6
3175 else
3176   echo "$as_me:3176: result: no" >&5
3177 echo "${ECHO_T}no" >&6
3178 fi
3179
3180 fi
3181 if test -z "$ac_cv_path_PKG_CONFIG"; then
3182   ac_pt_PKG_CONFIG=$PKG_CONFIG
3183   # Extract the first word of "pkg-config", so it can be a program name with args.
3184 set dummy pkg-config; ac_word=$2
3185 echo "$as_me:3185: checking for $ac_word" >&5
3186 echo $ECHO_N "checking for $ac_word... $ECHO_C" >&6
3187 if test "${ac_cv_path_ac_pt_PKG_CONFIG+set}" = set; then
3188   echo $ECHO_N "(cached) $ECHO_C" >&6
3189 else
3190   case $ac_pt_PKG_CONFIG in
3191   [\\/]* | ?:[\\/]*)
3192   ac_cv_path_ac_pt_PKG_CONFIG="$ac_pt_PKG_CONFIG" # Let the user override the test with a path.
3193   ;;
3194   *)
3195   ac_save_IFS=$IFS; IFS=$ac_path_separator
3196 ac_dummy="$PATH"
3197 for ac_dir in $ac_dummy; do
3198   IFS=$ac_save_IFS
3199   test -z "$ac_dir" && ac_dir=.
3200   if $as_executable_p "$ac_dir/$ac_word"; then
3201    ac_cv_path_ac_pt_PKG_CONFIG="$ac_dir/$ac_word"
3202    echo "$as_me:3202: found $ac_dir/$ac_word" >&5
3203    break
3204 fi
3205 done
3206
3207   test -z "$ac_cv_path_ac_pt_PKG_CONFIG" && ac_cv_path_ac_pt_PKG_CONFIG="none"
3208   ;;
3209 esac
3210 fi
3211 ac_pt_PKG_CONFIG=$ac_cv_path_ac_pt_PKG_CONFIG
3212
3213 if test -n "$ac_pt_PKG_CONFIG"; then
3214   echo "$as_me:3214: result: $ac_pt_PKG_CONFIG" >&5
3215 echo "${ECHO_T}$ac_pt_PKG_CONFIG" >&6
3216 else
3217   echo "$as_me:3217: result: no" >&5
3218 echo "${ECHO_T}no" >&6
3219 fi
3220
3221   PKG_CONFIG=$ac_pt_PKG_CONFIG
3222 else
3223   PKG_CONFIG="$ac_cv_path_PKG_CONFIG"
3224 fi
3225
3226         ;;
3227 (*)
3228         PKG_CONFIG=$withval
3229         ;;
3230 esac
3231
3232 test -z "$PKG_CONFIG" && PKG_CONFIG=none
3233 if test "$PKG_CONFIG" != none ; then
3234
3235 if test "x$prefix" != xNONE; then
3236         cf_path_syntax="$prefix"
3237 else
3238         cf_path_syntax="$ac_default_prefix"
3239 fi
3240
3241 case ".$PKG_CONFIG" in
3242 (.\$\(*\)*|.\'*\'*)
3243         ;;
3244 (..|./*|.\\*)
3245         ;;
3246 (.[a-zA-Z]:[\\/]*) # OS/2 EMX
3247         ;;
3248 (.\$\{*prefix\}*|.\$\{*dir\}*)
3249         eval PKG_CONFIG="$PKG_CONFIG"
3250         case ".$PKG_CONFIG" in
3251         (.NONE/*)
3252                 PKG_CONFIG=`echo "$PKG_CONFIG" | sed -e s%NONE%$cf_path_syntax%`
3253                 ;;
3254         esac
3255         ;;
3256 (.no|.NONE/*)
3257         PKG_CONFIG=`echo "$PKG_CONFIG" | sed -e s%NONE%$cf_path_syntax%`
3258         ;;
3259 (*)
3260         { { echo "$as_me:3260: error: expected a pathname, not \"$PKG_CONFIG\"" >&5
3261 echo "$as_me: error: expected a pathname, not \"$PKG_CONFIG\"" >&2;}
3262    { (exit 1); exit 1; }; }
3263         ;;
3264 esac
3265
3266 elif test "x$cf_pkg_config" != xno ; then
3267         { echo "$as_me:3267: WARNING: pkg-config is not installed" >&5
3268 echo "$as_me: WARNING: pkg-config is not installed" >&2;}
3269 fi
3270
3271 case "$PKG_CONFIG" in
3272 (no|none|yes)
3273         echo "$as_me:3273: checking for pkg-config library directory" >&5
3274 echo $ECHO_N "checking for pkg-config library directory... $ECHO_C" >&6
3275         ;;
3276 (*)
3277         echo "$as_me:3277: checking for $PKG_CONFIG library directory" >&5
3278 echo $ECHO_N "checking for $PKG_CONFIG library directory... $ECHO_C" >&6
3279         ;;
3280 esac
3281
3282 # if $PKG_CONFIG_LIBDIR is set, try to use that
3283 cf_search_path=`echo "$PKG_CONFIG_LIBDIR" | sed -e 's/:/ /g' -e 's,^[   ]*,,'`
3284
3285 # if the option is used, let that override.  otherwise default to "libdir"
3286
3287 # Check whether --with-pkg-config-libdir or --without-pkg-config-libdir was given.
3288 if test "${with_pkg_config_libdir+set}" = set; then
3289   withval="$with_pkg_config_libdir"
3290   cf_search_path=$withval
3291 else
3292   test "x$PKG_CONFIG" != xnone && test -z "$cf_search_path" && cf_search_path=libdir
3293 fi;
3294
3295 case "x$cf_search_path" in
3296 (xlibdir)
3297         PKG_CONFIG_LIBDIR='${libdir}/pkgconfig'
3298         echo "$as_me:3298: result: $PKG_CONFIG_LIBDIR" >&5
3299 echo "${ECHO_T}$PKG_CONFIG_LIBDIR" >&6
3300         cf_search_path=
3301         ;;
3302 (x)
3303         ;;
3304 (x/*\ *)
3305         PKG_CONFIG_LIBDIR=
3306         ;;
3307 (x/*)
3308         PKG_CONFIG_LIBDIR="$cf_search_path"
3309         echo "$as_me:3309: result: $PKG_CONFIG_LIBDIR" >&5
3310 echo "${ECHO_T}$PKG_CONFIG_LIBDIR" >&6
3311         cf_search_path=
3312         ;;
3313 (xyes|xauto)
3314         echo "$as_me:3314: result: auto" >&5
3315 echo "${ECHO_T}auto" >&6
3316         cf_search_path=
3317         # Look for the library directory using the same prefix as the executable
3318         echo "$as_me:3318: checking for search-list" >&5
3319 echo $ECHO_N "checking for search-list... $ECHO_C" >&6
3320         if test "x$PKG_CONFIG" != xnone
3321         then
3322                 # works for pkg-config since version 0.24 (2009)
3323                 # works for pkgconf since version 0.8.3 (2012)
3324                 for cf_pkg_program in \
3325                         `echo "$PKG_CONFIG" | sed -e 's,^.*/,,'` \
3326                         pkg-config \
3327                         pkgconf
3328                 do
3329                         cf_search_path=`"$PKG_CONFIG" --variable=pc_path "$cf_pkg_program" 2>/dev/null | tr : ' '`
3330                         test -n "$cf_search_path" && break
3331                 done
3332
3333                 # works for pkg-config since import in 2005 of original 2001 HP code.
3334                 test -z "$cf_search_path" && \
3335                 cf_search_path=`
3336                 "$PKG_CONFIG" --debug --exists no-such-package 2>&1 | $AWK "\
3337 /^Scanning directory (#[1-9][0-9]* )?'.*'$/{ \
3338         sub(\"^[^']*'\",\"\"); \
3339         sub(\"'.*\",\"\"); \
3340         printf \" %s\", \\$0; } \
3341 { next; } \
3342 "`
3343         fi
3344
3345         echo "$as_me:3345: result: $cf_search_path" >&5
3346 echo "${ECHO_T}$cf_search_path" >&6
3347         ;;
3348 (*)
3349         { { echo "$as_me:3349: error: Unexpected option value: $cf_search_path" >&5
3350 echo "$as_me: error: Unexpected option value: $cf_search_path" >&2;}
3351    { (exit 1); exit 1; }; }
3352         ;;
3353 esac
3354
3355 if test -n "$cf_search_path"
3356 then
3357         echo "$as_me:3357: checking for first directory" >&5
3358 echo $ECHO_N "checking for first directory... $ECHO_C" >&6
3359         cf_pkg_config_path=none
3360         for cf_config in $cf_search_path
3361         do
3362                 if test -d "$cf_config"
3363                 then
3364                         cf_pkg_config_path=$cf_config
3365                         break
3366                 fi
3367         done
3368         echo "$as_me:3368: result: $cf_pkg_config_path" >&5
3369 echo "${ECHO_T}$cf_pkg_config_path" >&6
3370
3371         if test "x$cf_pkg_config_path" != xnone ; then
3372                 # limit this to the first directory found
3373                 PKG_CONFIG_LIBDIR="$cf_pkg_config_path"
3374         fi
3375
3376         if test -z "$PKG_CONFIG_LIBDIR" && test -n "$cf_search_path"
3377         then
3378                 echo "$as_me:3378: checking for workaround" >&5
3379 echo $ECHO_N "checking for workaround... $ECHO_C" >&6
3380                 if test "$prefix" = "NONE" ; then
3381                         cf_prefix="$ac_default_prefix"
3382                 else
3383                         cf_prefix="$prefix"
3384                 fi
3385                 eval cf_libdir=$libdir
3386                 cf_libdir=`echo "$cf_libdir" | sed -e "s,^NONE,$cf_prefix,"`
3387                 cf_backup=
3388                 for cf_config in $cf_search_path
3389                 do
3390                         case $cf_config in
3391                         $cf_libdir/pkgconfig)
3392                                 PKG_CONFIG_LIBDIR=$cf_libdir/pkgconfig
3393                                 break
3394                                 ;;
3395                         *)
3396                                 test -z "$cf_backup" && cf_backup=$cf_config
3397                                 ;;
3398                         esac
3399                 done
3400                 test -z "$PKG_CONFIG_LIBDIR" && PKG_CONFIG_LIBDIR=$cf_backup
3401                 echo "$as_me:3401: result: $PKG_CONFIG_LIBDIR" >&5
3402 echo "${ECHO_T}$PKG_CONFIG_LIBDIR" >&6
3403         fi
3404 fi
3405
3406 echo "$as_me:3406: checking if you want to build test-programs" >&5
3407 echo $ECHO_N "checking if you want to build test-programs... $ECHO_C" >&6
3408
3409 # Check whether --with-tests or --without-tests was given.
3410 if test "${with_tests+set}" = set; then
3411   withval="$with_tests"
3412   cf_with_tests=$withval
3413 else
3414   cf_with_tests=yes
3415 fi;
3416 echo "$as_me:3416: result: $cf_with_tests" >&5
3417 echo "${ECHO_T}$cf_with_tests" >&6
3418
3419 echo "$as_me:3419: checking if we should assume mixed-case filenames" >&5
3420 echo $ECHO_N "checking if we should assume mixed-case filenames... $ECHO_C" >&6
3421
3422 # Check whether --enable-mixed-case or --disable-mixed-case was given.
3423 if test "${enable_mixed_case+set}" = set; then
3424   enableval="$enable_mixed_case"
3425   enable_mixedcase=$enableval
3426 else
3427   enable_mixedcase=auto
3428 fi;
3429 echo "$as_me:3429: result: $enable_mixedcase" >&5
3430 echo "${ECHO_T}$enable_mixedcase" >&6
3431 if test "$enable_mixedcase" = "auto" ; then
3432
3433 echo "$as_me:3433: checking if filesystem supports mixed-case filenames" >&5
3434 echo $ECHO_N "checking if filesystem supports mixed-case filenames... $ECHO_C" >&6
3435 if test "${cf_cv_mixedcase+set}" = set; then
3436   echo $ECHO_N "(cached) $ECHO_C" >&6
3437 else
3438
3439 if test "$cross_compiling" = yes ; then
3440         case "$target_alias" in
3441         (*-os2-emx*|*-msdosdjgpp*|*-cygwin*|*-msys*|*-mingw*|*-uwin*|darwin*)
3442                 cf_cv_mixedcase=no
3443                 ;;
3444         (*)
3445                 cf_cv_mixedcase=yes
3446                 ;;
3447         esac
3448 else
3449         rm -f conftest CONFTEST
3450         echo test >conftest
3451         if test -f CONFTEST ; then
3452                 cf_cv_mixedcase=no
3453         else
3454                 cf_cv_mixedcase=yes
3455         fi
3456         rm -f conftest CONFTEST
3457 fi
3458
3459 fi
3460 echo "$as_me:3460: result: $cf_cv_mixedcase" >&5
3461 echo "${ECHO_T}$cf_cv_mixedcase" >&6
3462 test "$cf_cv_mixedcase" = yes &&
3463 cat >>confdefs.h <<\EOF
3464 #define MIXEDCASE_FILENAMES 1
3465 EOF
3466
3467 else
3468         cf_cv_mixedcase=$enable_mixedcase
3469         if test "$enable_mixedcase" = "yes" ; then
3470                 cat >>confdefs.h <<\EOF
3471 #define MIXEDCASE_FILENAMES 1
3472 EOF
3473
3474         fi
3475 fi
3476
3477 # do this after mixed-case option (tags/TAGS is not as important as tic).
3478 echo "$as_me:3478: checking whether ${MAKE-make} sets \${MAKE}" >&5
3479 echo $ECHO_N "checking whether ${MAKE-make} sets \${MAKE}... $ECHO_C" >&6
3480 set dummy ${MAKE-make}; ac_make=`echo "$2" | sed 'y,./+-,__p_,'`
3481 if eval "test \"\${ac_cv_prog_make_${ac_make}_set+set}\" = set"; then
3482   echo $ECHO_N "(cached) $ECHO_C" >&6
3483 else
3484   cat >conftest.make <<\EOF
3485 all:
3486         @echo 'ac_maketemp="${MAKE}"'
3487 EOF
3488 # GNU make sometimes prints "make[1]: Entering...", which would confuse us.
3489 eval `${MAKE-make} -f conftest.make 2>/dev/null | grep temp=`
3490 if test -n "$ac_maketemp"; then
3491   eval ac_cv_prog_make_${ac_make}_set=yes
3492 else
3493   eval ac_cv_prog_make_${ac_make}_set=no
3494 fi
3495 rm -f conftest.make
3496 fi
3497 if eval "test \"`echo '$ac_cv_prog_make_'${ac_make}_set`\" = yes"; then
3498   echo "$as_me:3498: result: yes" >&5
3499 echo "${ECHO_T}yes" >&6
3500   SET_MAKE=
3501 else
3502   echo "$as_me:3502: result: no" >&5
3503 echo "${ECHO_T}no" >&6
3504   SET_MAKE="MAKE=${MAKE-make}"
3505 fi
3506
3507 echo "$as_me:3507: checking for \".PHONY\" make-support" >&5
3508 echo $ECHO_N "checking for \".PHONY\" make-support... $ECHO_C" >&6
3509 if test "${cf_cv_make_PHONY+set}" = set; then
3510   echo $ECHO_N "(cached) $ECHO_C" >&6
3511 else
3512
3513         rm -rf conftest*
3514         (
3515                 mkdir conftest || exit 1
3516                 cd conftest
3517                 cat >makefile <<'CF_EOF'
3518 .PHONY: always
3519 DATA=0
3520 always: always.out
3521         @echo "** making $@ $(DATA)"
3522 once: once.out
3523         @echo "** making $@ $(DATA)"
3524 always.out:
3525         @echo "** making $@ $(DATA)"
3526         echo $(DATA) > $@
3527 once.out:
3528         @echo "** making $@ $(DATA)"
3529         echo $(DATA) > $@
3530 CF_EOF
3531                 for cf_data in 1 2 3
3532                 do
3533                         ${MAKE:-make} always DATA=$cf_data
3534                         ${MAKE:-make} once   DATA=$cf_data
3535                         ${MAKE:-make} -t always once
3536                         if test -f always ; then
3537                                 echo "no (case 1)" > ../conftest.tmp
3538                         elif test ! -f always.out ; then
3539                                 echo "no (case 2)" > ../conftest.tmp
3540                         elif test ! -f once.out ; then
3541                                 echo "no (case 3)" > ../conftest.tmp
3542                         elif ! cmp -s always.out once.out ; then
3543                                 echo "no (case 4)" > ../conftest.tmp
3544                                 diff always.out once.out
3545                         else
3546                                 cf_check="`cat always.out`"
3547                                 if test "x$cf_check" != "x$cf_data" ; then
3548                                         echo "no (case 5)" > ../conftest.tmp
3549                                 else
3550                                         echo yes > ../conftest.tmp
3551                                         rm -f ./*.out
3552                                         continue
3553                                 fi
3554                         fi
3555                         break
3556                 done
3557         ) >&5 2>&1
3558         cf_cv_make_PHONY="`cat conftest.tmp`"
3559         rm -rf conftest*
3560
3561 fi
3562 echo "$as_me:3562: result: $cf_cv_make_PHONY" >&5
3563 echo "${ECHO_T}$cf_cv_make_PHONY" >&6
3564 MAKE_NO_PHONY="#"
3565 MAKE_PHONY="#"
3566 test "x$cf_cv_make_PHONY" = xyes && MAKE_PHONY=
3567 test "x$cf_cv_make_PHONY" != xyes && MAKE_NO_PHONY=
3568
3569 for ac_prog in exctags ctags
3570 do
3571   # Extract the first word of "$ac_prog", so it can be a program name with args.
3572 set dummy $ac_prog; ac_word=$2
3573 echo "$as_me:3573: checking for $ac_word" >&5
3574 echo $ECHO_N "checking for $ac_word... $ECHO_C" >&6
3575 if test "${ac_cv_prog_CTAGS+set}" = set; then
3576   echo $ECHO_N "(cached) $ECHO_C" >&6
3577 else
3578   if test -n "$CTAGS"; then
3579   ac_cv_prog_CTAGS="$CTAGS" # Let the user override the test.
3580 else
3581   ac_save_IFS=$IFS; IFS=$ac_path_separator
3582 ac_dummy="$PATH"
3583 for ac_dir in $ac_dummy; do
3584   IFS=$ac_save_IFS
3585   test -z "$ac_dir" && ac_dir=.
3586   $as_executable_p "$ac_dir/$ac_word" || continue
3587 ac_cv_prog_CTAGS="$ac_prog"
3588 echo "$as_me:3588: found $ac_dir/$ac_word" >&5
3589 break
3590 done
3591
3592 fi
3593 fi
3594 CTAGS=$ac_cv_prog_CTAGS
3595 if test -n "$CTAGS"; then
3596   echo "$as_me:3596: result: $CTAGS" >&5
3597 echo "${ECHO_T}$CTAGS" >&6
3598 else
3599   echo "$as_me:3599: result: no" >&5
3600 echo "${ECHO_T}no" >&6
3601 fi
3602
3603   test -n "$CTAGS" && break
3604 done
3605
3606 for ac_prog in exetags etags
3607 do
3608   # Extract the first word of "$ac_prog", so it can be a program name with args.
3609 set dummy $ac_prog; ac_word=$2
3610 echo "$as_me:3610: checking for $ac_word" >&5
3611 echo $ECHO_N "checking for $ac_word... $ECHO_C" >&6
3612 if test "${ac_cv_prog_ETAGS+set}" = set; then
3613   echo $ECHO_N "(cached) $ECHO_C" >&6
3614 else
3615   if test -n "$ETAGS"; then
3616   ac_cv_prog_ETAGS="$ETAGS" # Let the user override the test.
3617 else
3618   ac_save_IFS=$IFS; IFS=$ac_path_separator
3619 ac_dummy="$PATH"
3620 for ac_dir in $ac_dummy; do
3621   IFS=$ac_save_IFS
3622   test -z "$ac_dir" && ac_dir=.
3623   $as_executable_p "$ac_dir/$ac_word" || continue
3624 ac_cv_prog_ETAGS="$ac_prog"
3625 echo "$as_me:3625: found $ac_dir/$ac_word" >&5
3626 break
3627 done
3628
3629 fi
3630 fi
3631 ETAGS=$ac_cv_prog_ETAGS
3632 if test -n "$ETAGS"; then
3633   echo "$as_me:3633: result: $ETAGS" >&5
3634 echo "${ECHO_T}$ETAGS" >&6
3635 else
3636   echo "$as_me:3636: result: no" >&5
3637 echo "${ECHO_T}no" >&6
3638 fi
3639
3640   test -n "$ETAGS" && break
3641 done
3642
3643 # Extract the first word of "${CTAGS:-ctags}", so it can be a program name with args.
3644 set dummy ${CTAGS:-ctags}; ac_word=$2
3645 echo "$as_me:3645: checking for $ac_word" >&5
3646 echo $ECHO_N "checking for $ac_word... $ECHO_C" >&6
3647 if test "${ac_cv_prog_MAKE_LOWER_TAGS+set}" = set; then
3648   echo $ECHO_N "(cached) $ECHO_C" >&6
3649 else
3650   if test -n "$MAKE_LOWER_TAGS"; then
3651   ac_cv_prog_MAKE_LOWER_TAGS="$MAKE_LOWER_TAGS" # Let the user override the test.
3652 else
3653   ac_save_IFS=$IFS; IFS=$ac_path_separator
3654 ac_dummy="$PATH"
3655 for ac_dir in $ac_dummy; do
3656   IFS=$ac_save_IFS
3657   test -z "$ac_dir" && ac_dir=.
3658   $as_executable_p "$ac_dir/$ac_word" || continue
3659 ac_cv_prog_MAKE_LOWER_TAGS="yes"
3660 echo "$as_me:3660: found $ac_dir/$ac_word" >&5
3661 break
3662 done
3663
3664   test -z "$ac_cv_prog_MAKE_LOWER_TAGS" && ac_cv_prog_MAKE_LOWER_TAGS="no"
3665 fi
3666 fi
3667 MAKE_LOWER_TAGS=$ac_cv_prog_MAKE_LOWER_TAGS
3668 if test -n "$MAKE_LOWER_TAGS"; then
3669   echo "$as_me:3669: result: $MAKE_LOWER_TAGS" >&5
3670 echo "${ECHO_T}$MAKE_LOWER_TAGS" >&6
3671 else
3672   echo "$as_me:3672: result: no" >&5
3673 echo "${ECHO_T}no" >&6
3674 fi
3675
3676 if test "$cf_cv_mixedcase" = yes ; then
3677         # Extract the first word of "${ETAGS:-etags}", so it can be a program name with args.
3678 set dummy ${ETAGS:-etags}; ac_word=$2
3679 echo "$as_me:3679: checking for $ac_word" >&5
3680 echo $ECHO_N "checking for $ac_word... $ECHO_C" >&6
3681 if test "${ac_cv_prog_MAKE_UPPER_TAGS+set}" = set; then
3682   echo $ECHO_N "(cached) $ECHO_C" >&6
3683 else
3684   if test -n "$MAKE_UPPER_TAGS"; then
3685   ac_cv_prog_MAKE_UPPER_TAGS="$MAKE_UPPER_TAGS" # Let the user override the test.
3686 else
3687   ac_save_IFS=$IFS; IFS=$ac_path_separator
3688 ac_dummy="$PATH"
3689 for ac_dir in $ac_dummy; do
3690   IFS=$ac_save_IFS
3691   test -z "$ac_dir" && ac_dir=.
3692   $as_executable_p "$ac_dir/$ac_word" || continue
3693 ac_cv_prog_MAKE_UPPER_TAGS="yes"
3694 echo "$as_me:3694: found $ac_dir/$ac_word" >&5
3695 break
3696 done
3697
3698   test -z "$ac_cv_prog_MAKE_UPPER_TAGS" && ac_cv_prog_MAKE_UPPER_TAGS="no"
3699 fi
3700 fi
3701 MAKE_UPPER_TAGS=$ac_cv_prog_MAKE_UPPER_TAGS
3702 if test -n "$MAKE_UPPER_TAGS"; then
3703   echo "$as_me:3703: result: $MAKE_UPPER_TAGS" >&5
3704 echo "${ECHO_T}$MAKE_UPPER_TAGS" >&6
3705 else
3706   echo "$as_me:3706: result: no" >&5
3707 echo "${ECHO_T}no" >&6
3708 fi
3709
3710 else
3711         MAKE_UPPER_TAGS=no
3712 fi
3713
3714 if test "$MAKE_UPPER_TAGS" = yes ; then
3715         MAKE_UPPER_TAGS=
3716 else
3717         MAKE_UPPER_TAGS="#"
3718 fi
3719
3720 if test "$MAKE_LOWER_TAGS" = yes ; then
3721         MAKE_LOWER_TAGS=
3722 else
3723         MAKE_LOWER_TAGS="#"
3724 fi
3725
3726 echo "$as_me:3726: checking for makeflags variable" >&5
3727 echo $ECHO_N "checking for makeflags variable... $ECHO_C" >&6
3728 if test "${cf_cv_makeflags+set}" = set; then
3729   echo $ECHO_N "(cached) $ECHO_C" >&6
3730 else
3731
3732         cf_cv_makeflags=''
3733         for cf_option in '-${MAKEFLAGS}' '${MFLAGS}'
3734         do
3735                 cat >cf_makeflags.tmp <<CF_EOF
3736 SHELL = $SHELL
3737 all :
3738         @ echo '.$cf_option'
3739 CF_EOF
3740                 cf_result=`${MAKE:-make} -k -f cf_makeflags.tmp 2>/dev/null | ${FGREP-fgrep} -v "ing directory" | sed -e 's,[   ]*$,,'`
3741                 case "$cf_result" in
3742                 (.*k|.*kw)
3743                         cf_result="`${MAKE:-make} -k -f cf_makeflags.tmp CC=cc 2>/dev/null`"
3744                         case "$cf_result" in
3745                         (.*CC=*)        cf_cv_makeflags=
3746                                 ;;
3747                         (*)     cf_cv_makeflags=$cf_option
3748                                 ;;
3749                         esac
3750                         break
3751                         ;;
3752                 (.-)
3753                         ;;
3754                 (*)
3755
3756 echo "${as_me:-configure}:3756: testing given option \"$cf_option\",no match \"$cf_result\" ..." 1>&5
3757
3758                         ;;
3759                 esac
3760         done
3761         rm -f cf_makeflags.tmp
3762
3763 fi
3764 echo "$as_me:3764: result: $cf_cv_makeflags" >&5
3765 echo "${ECHO_T}$cf_cv_makeflags" >&6
3766
3767 if test -n "$ac_tool_prefix"; then
3768   # Extract the first word of "${ac_tool_prefix}ranlib", so it can be a program name with args.
3769 set dummy ${ac_tool_prefix}ranlib; ac_word=$2
3770 echo "$as_me:3770: checking for $ac_word" >&5
3771 echo $ECHO_N "checking for $ac_word... $ECHO_C" >&6
3772 if test "${ac_cv_prog_RANLIB+set}" = set; then
3773   echo $ECHO_N "(cached) $ECHO_C" >&6
3774 else
3775   if test -n "$RANLIB"; then
3776   ac_cv_prog_RANLIB="$RANLIB" # Let the user override the test.
3777 else
3778   ac_save_IFS=$IFS; IFS=$ac_path_separator
3779 ac_dummy="$PATH"
3780 for ac_dir in $ac_dummy; do
3781   IFS=$ac_save_IFS
3782   test -z "$ac_dir" && ac_dir=.
3783   $as_executable_p "$ac_dir/$ac_word" || continue
3784 ac_cv_prog_RANLIB="${ac_tool_prefix}ranlib"
3785 echo "$as_me:3785: found $ac_dir/$ac_word" >&5
3786 break
3787 done
3788
3789 fi
3790 fi
3791 RANLIB=$ac_cv_prog_RANLIB
3792 if test -n "$RANLIB"; then
3793   echo "$as_me:3793: result: $RANLIB" >&5
3794 echo "${ECHO_T}$RANLIB" >&6
3795 else
3796   echo "$as_me:3796: result: no" >&5
3797 echo "${ECHO_T}no" >&6
3798 fi
3799
3800 fi
3801 if test -z "$ac_cv_prog_RANLIB"; then
3802   ac_ct_RANLIB=$RANLIB
3803   # Extract the first word of "ranlib", so it can be a program name with args.
3804 set dummy ranlib; ac_word=$2
3805 echo "$as_me:3805: checking for $ac_word" >&5
3806 echo $ECHO_N "checking for $ac_word... $ECHO_C" >&6
3807 if test "${ac_cv_prog_ac_ct_RANLIB+set}" = set; then
3808   echo $ECHO_N "(cached) $ECHO_C" >&6
3809 else
3810   if test -n "$ac_ct_RANLIB"; then
3811   ac_cv_prog_ac_ct_RANLIB="$ac_ct_RANLIB" # Let the user override the test.
3812 else
3813   ac_save_IFS=$IFS; IFS=$ac_path_separator
3814 ac_dummy="$PATH"
3815 for ac_dir in $ac_dummy; do
3816   IFS=$ac_save_IFS
3817   test -z "$ac_dir" && ac_dir=.
3818   $as_executable_p "$ac_dir/$ac_word" || continue
3819 ac_cv_prog_ac_ct_RANLIB="ranlib"
3820 echo "$as_me:3820: found $ac_dir/$ac_word" >&5
3821 break
3822 done
3823
3824   test -z "$ac_cv_prog_ac_ct_RANLIB" && ac_cv_prog_ac_ct_RANLIB="':'"
3825 fi
3826 fi
3827 ac_ct_RANLIB=$ac_cv_prog_ac_ct_RANLIB
3828 if test -n "$ac_ct_RANLIB"; then
3829   echo "$as_me:3829: result: $ac_ct_RANLIB" >&5
3830 echo "${ECHO_T}$ac_ct_RANLIB" >&6
3831 else
3832   echo "$as_me:3832: result: no" >&5
3833 echo "${ECHO_T}no" >&6
3834 fi
3835
3836   RANLIB=$ac_ct_RANLIB
3837 else
3838   RANLIB="$ac_cv_prog_RANLIB"
3839 fi
3840
3841 if test -n "$ac_tool_prefix"; then
3842   # Extract the first word of "${ac_tool_prefix}ld", so it can be a program name with args.
3843 set dummy ${ac_tool_prefix}ld; ac_word=$2
3844 echo "$as_me:3844: checking for $ac_word" >&5
3845 echo $ECHO_N "checking for $ac_word... $ECHO_C" >&6
3846 if test "${ac_cv_prog_LD+set}" = set; then
3847   echo $ECHO_N "(cached) $ECHO_C" >&6
3848 else
3849   if test -n "$LD"; then
3850   ac_cv_prog_LD="$LD" # Let the user override the test.
3851 else
3852   ac_save_IFS=$IFS; IFS=$ac_path_separator
3853 ac_dummy="$PATH"
3854 for ac_dir in $ac_dummy; do
3855   IFS=$ac_save_IFS
3856   test -z "$ac_dir" && ac_dir=.
3857   $as_executable_p "$ac_dir/$ac_word" || continue
3858 ac_cv_prog_LD="${ac_tool_prefix}ld"
3859 echo "$as_me:3859: found $ac_dir/$ac_word" >&5
3860 break
3861 done
3862
3863 fi
3864 fi
3865 LD=$ac_cv_prog_LD
3866 if test -n "$LD"; then
3867   echo "$as_me:3867: result: $LD" >&5
3868 echo "${ECHO_T}$LD" >&6
3869 else
3870   echo "$as_me:3870: result: no" >&5
3871 echo "${ECHO_T}no" >&6
3872 fi
3873
3874 fi
3875 if test -z "$ac_cv_prog_LD"; then
3876   ac_ct_LD=$LD
3877   # Extract the first word of "ld", so it can be a program name with args.
3878 set dummy ld; ac_word=$2
3879 echo "$as_me:3879: checking for $ac_word" >&5
3880 echo $ECHO_N "checking for $ac_word... $ECHO_C" >&6
3881 if test "${ac_cv_prog_ac_ct_LD+set}" = set; then
3882   echo $ECHO_N "(cached) $ECHO_C" >&6
3883 else
3884   if test -n "$ac_ct_LD"; then
3885   ac_cv_prog_ac_ct_LD="$ac_ct_LD" # Let the user override the test.
3886 else
3887   ac_save_IFS=$IFS; IFS=$ac_path_separator
3888 ac_dummy="$PATH"
3889 for ac_dir in $ac_dummy; do
3890   IFS=$ac_save_IFS
3891   test -z "$ac_dir" && ac_dir=.
3892   $as_executable_p "$ac_dir/$ac_word" || continue
3893 ac_cv_prog_ac_ct_LD="ld"
3894 echo "$as_me:3894: found $ac_dir/$ac_word" >&5
3895 break
3896 done
3897
3898   test -z "$ac_cv_prog_ac_ct_LD" && ac_cv_prog_ac_ct_LD="ld"
3899 fi
3900 fi
3901 ac_ct_LD=$ac_cv_prog_ac_ct_LD
3902 if test -n "$ac_ct_LD"; then
3903   echo "$as_me:3903: result: $ac_ct_LD" >&5
3904 echo "${ECHO_T}$ac_ct_LD" >&6
3905 else
3906   echo "$as_me:3906: result: no" >&5
3907 echo "${ECHO_T}no" >&6
3908 fi
3909
3910   LD=$ac_ct_LD
3911 else
3912   LD="$ac_cv_prog_LD"
3913 fi
3914
3915 if test -n "$ac_tool_prefix"; then
3916   # Extract the first word of "${ac_tool_prefix}ar", so it can be a program name with args.
3917 set dummy ${ac_tool_prefix}ar; ac_word=$2
3918 echo "$as_me:3918: checking for $ac_word" >&5
3919 echo $ECHO_N "checking for $ac_word... $ECHO_C" >&6
3920 if test "${ac_cv_prog_AR+set}" = set; then
3921   echo $ECHO_N "(cached) $ECHO_C" >&6
3922 else
3923   if test -n "$AR"; then
3924   ac_cv_prog_AR="$AR" # Let the user override the test.
3925 else
3926   ac_save_IFS=$IFS; IFS=$ac_path_separator
3927 ac_dummy="$PATH"
3928 for ac_dir in $ac_dummy; do
3929   IFS=$ac_save_IFS
3930   test -z "$ac_dir" && ac_dir=.
3931   $as_executable_p "$ac_dir/$ac_word" || continue
3932 ac_cv_prog_AR="${ac_tool_prefix}ar"
3933 echo "$as_me:3933: found $ac_dir/$ac_word" >&5
3934 break
3935 done
3936
3937 fi
3938 fi
3939 AR=$ac_cv_prog_AR
3940 if test -n "$AR"; then
3941   echo "$as_me:3941: result: $AR" >&5
3942 echo "${ECHO_T}$AR" >&6
3943 else
3944   echo "$as_me:3944: result: no" >&5
3945 echo "${ECHO_T}no" >&6
3946 fi
3947
3948 fi
3949 if test -z "$ac_cv_prog_AR"; then
3950   ac_ct_AR=$AR
3951   # Extract the first word of "ar", so it can be a program name with args.
3952 set dummy ar; ac_word=$2
3953 echo "$as_me:3953: checking for $ac_word" >&5
3954 echo $ECHO_N "checking for $ac_word... $ECHO_C" >&6
3955 if test "${ac_cv_prog_ac_ct_AR+set}" = set; then
3956   echo $ECHO_N "(cached) $ECHO_C" >&6
3957 else
3958   if test -n "$ac_ct_AR"; then
3959   ac_cv_prog_ac_ct_AR="$ac_ct_AR" # Let the user override the test.
3960 else
3961   ac_save_IFS=$IFS; IFS=$ac_path_separator
3962 ac_dummy="$PATH"
3963 for ac_dir in $ac_dummy; do
3964   IFS=$ac_save_IFS
3965   test -z "$ac_dir" && ac_dir=.
3966   $as_executable_p "$ac_dir/$ac_word" || continue
3967 ac_cv_prog_ac_ct_AR="ar"
3968 echo "$as_me:3968: found $ac_dir/$ac_word" >&5
3969 break
3970 done
3971
3972   test -z "$ac_cv_prog_ac_ct_AR" && ac_cv_prog_ac_ct_AR="ar"
3973 fi
3974 fi
3975 ac_ct_AR=$ac_cv_prog_ac_ct_AR
3976 if test -n "$ac_ct_AR"; then
3977   echo "$as_me:3977: result: $ac_ct_AR" >&5
3978 echo "${ECHO_T}$ac_ct_AR" >&6
3979 else
3980   echo "$as_me:3980: result: no" >&5
3981 echo "${ECHO_T}no" >&6
3982 fi
3983
3984   AR=$ac_ct_AR
3985 else
3986   AR="$ac_cv_prog_AR"
3987 fi
3988
3989 if test -n "$ac_tool_prefix"; then
3990   # Extract the first word of "${ac_tool_prefix}ar", so it can be a program name with args.
3991 set dummy ${ac_tool_prefix}ar; ac_word=$2
3992 echo "$as_me:3992: checking for $ac_word" >&5
3993 echo $ECHO_N "checking for $ac_word... $ECHO_C" >&6
3994 if test "${ac_cv_prog_AR+set}" = set; then
3995   echo $ECHO_N "(cached) $ECHO_C" >&6
3996 else
3997   if test -n "$AR"; then
3998   ac_cv_prog_AR="$AR" # Let the user override the test.
3999 else
4000   ac_save_IFS=$IFS; IFS=$ac_path_separator
4001 ac_dummy="$PATH"
4002 for ac_dir in $ac_dummy; do
4003   IFS=$ac_save_IFS
4004   test -z "$ac_dir" && ac_dir=.
4005   $as_executable_p "$ac_dir/$ac_word" || continue
4006 ac_cv_prog_AR="${ac_tool_prefix}ar"
4007 echo "$as_me:4007: found $ac_dir/$ac_word" >&5
4008 break
4009 done
4010
4011 fi
4012 fi
4013 AR=$ac_cv_prog_AR
4014 if test -n "$AR"; then
4015   echo "$as_me:4015: result: $AR" >&5
4016 echo "${ECHO_T}$AR" >&6
4017 else
4018   echo "$as_me:4018: result: no" >&5
4019 echo "${ECHO_T}no" >&6
4020 fi
4021
4022 fi
4023 if test -z "$ac_cv_prog_AR"; then
4024   ac_ct_AR=$AR
4025   # Extract the first word of "ar", so it can be a program name with args.
4026 set dummy ar; ac_word=$2
4027 echo "$as_me:4027: checking for $ac_word" >&5
4028 echo $ECHO_N "checking for $ac_word... $ECHO_C" >&6
4029 if test "${ac_cv_prog_ac_ct_AR+set}" = set; then
4030   echo $ECHO_N "(cached) $ECHO_C" >&6
4031 else
4032   if test -n "$ac_ct_AR"; then
4033   ac_cv_prog_ac_ct_AR="$ac_ct_AR" # Let the user override the test.
4034 else
4035   ac_save_IFS=$IFS; IFS=$ac_path_separator
4036 ac_dummy="$PATH"
4037 for ac_dir in $ac_dummy; do
4038   IFS=$ac_save_IFS
4039   test -z "$ac_dir" && ac_dir=.
4040   $as_executable_p "$ac_dir/$ac_word" || continue
4041 ac_cv_prog_ac_ct_AR="ar"
4042 echo "$as_me:4042: found $ac_dir/$ac_word" >&5
4043 break
4044 done
4045
4046   test -z "$ac_cv_prog_ac_ct_AR" && ac_cv_prog_ac_ct_AR="ar"
4047 fi
4048 fi
4049 ac_ct_AR=$ac_cv_prog_ac_ct_AR
4050 if test -n "$ac_ct_AR"; then
4051   echo "$as_me:4051: result: $ac_ct_AR" >&5
4052 echo "${ECHO_T}$ac_ct_AR" >&6
4053 else
4054   echo "$as_me:4054: result: no" >&5
4055 echo "${ECHO_T}no" >&6
4056 fi
4057
4058   AR=$ac_ct_AR
4059 else
4060   AR="$ac_cv_prog_AR"
4061 fi
4062
4063 echo "$as_me:4063: checking for options to update archives" >&5
4064 echo $ECHO_N "checking for options to update archives... $ECHO_C" >&6
4065 if test "${cf_cv_ar_flags+set}" = set; then
4066   echo $ECHO_N "(cached) $ECHO_C" >&6
4067 else
4068
4069         case "$cf_cv_system_name" in
4070         (*-msvc*)
4071                 cf_cv_ar_flags=''
4072                 cat >mk_static_lib.sh <<-EOF
4073                 #!$SHELL
4074                 MSVC_BIN="$AR"
4075                 out="\$1"
4076                 shift
4077                 exec \$MSVC_BIN -out:"\$out" \$@
4078                 EOF
4079                 chmod +x mk_static_lib.sh
4080                 AR=`pwd`/mk_static_lib.sh
4081                 ;;
4082         (*)
4083                 cf_cv_ar_flags=unknown
4084                 for cf_ar_flags in -curvU -curv curv -crv crv -cqv cqv -rv rv
4085                 do
4086
4087                         # check if $ARFLAGS already contains this choice
4088                         if test "x$ARFLAGS" != "x" ; then
4089                                 cf_check_ar_flags=`echo "x$ARFLAGS" | sed -e "s/$cf_ar_flags\$//" -e "s/$cf_ar_flags / /"`
4090                                 if test "x$ARFLAGS" != "$cf_check_ar_flags" ; then
4091                                         cf_cv_ar_flags=
4092                                         break
4093                                 fi
4094                         fi
4095
4096                         rm -f "conftest.$ac_cv_objext"
4097                         rm -f conftest.a
4098
4099                         cat >"conftest.$ac_ext" <<EOF
4100 #line 4100 "configure"
4101 int     testdata[3] = { 123, 456, 789 };
4102 EOF
4103                         if { (eval echo "$as_me:4103: \"$ac_compile\"") >&5
4104   (eval $ac_compile) 2>&5
4105   ac_status=$?
4106   echo "$as_me:4106: \$? = $ac_status" >&5
4107   (exit "$ac_status"); } ; then
4108                                 echo "$AR $ARFLAGS $cf_ar_flags conftest.a conftest.$ac_cv_objext" >&5
4109                                 $AR $ARFLAGS "$cf_ar_flags" conftest.a "conftest.$ac_cv_objext" 2>&5 1>/dev/null
4110                                 if test -f conftest.a ; then
4111                                         cf_cv_ar_flags="$cf_ar_flags"
4112                                         break
4113                                 fi
4114                         else
4115                                 test -n "$verbose" && echo "    cannot compile test-program" 1>&6
4116
4117 echo "${as_me:-configure}:4117: testing cannot compile test-program ..." 1>&5
4118
4119                                 break
4120                         fi
4121                 done
4122                 rm -f conftest.a "conftest.$ac_ext" "conftest.$ac_cv_objext"
4123                 ;;
4124         esac
4125
4126 fi
4127 echo "$as_me:4127: result: $cf_cv_ar_flags" >&5
4128 echo "${ECHO_T}$cf_cv_ar_flags" >&6
4129
4130 if test -n "$ARFLAGS" ; then
4131         if test -n "$cf_cv_ar_flags" ; then
4132                 ARFLAGS="$ARFLAGS $cf_cv_ar_flags"
4133         fi
4134 else
4135         ARFLAGS=$cf_cv_ar_flags
4136 fi
4137
4138         echo "$as_me:4138: checking for PATH separator" >&5
4139 echo $ECHO_N "checking for PATH separator... $ECHO_C" >&6
4140         case "$cf_cv_system_name" in
4141         (os2*)  PATH_SEPARATOR=';'  ;;
4142         (*)     ${PATH_SEPARATOR:=':'}  ;;
4143         esac
4144
4145         echo "$as_me:4145: result: $PATH_SEPARATOR" >&5
4146 echo "${ECHO_T}$PATH_SEPARATOR" >&6
4147
4148 echo "$as_me:4148: checking if you have specified an install-prefix" >&5
4149 echo $ECHO_N "checking if you have specified an install-prefix... $ECHO_C" >&6
4150
4151 # Check whether --with-install-prefix or --without-install-prefix was given.
4152 if test "${with_install_prefix+set}" = set; then
4153   withval="$with_install_prefix"
4154   case "$withval" in
4155         (yes|no)
4156                 ;;
4157         (*)     DESTDIR="$withval"
4158                 ;;
4159         esac
4160 fi;
4161 echo "$as_me:4161: result: $DESTDIR" >&5
4162 echo "${ECHO_T}$DESTDIR" >&6
4163
4164 ###############################################################################
4165
4166 # If we're cross-compiling, allow the user to override the tools and their
4167 # options.  The configure script is oriented toward identifying the host
4168 # compiler, etc., but we need a build compiler to generate parts of the source.
4169
4170 if test "$cross_compiling" = yes ; then
4171
4172         # defaults that we might want to override
4173         : ${BUILD_CFLAGS:=''}
4174         : ${BUILD_CPPFLAGS:=''}
4175         : ${BUILD_LDFLAGS:=''}
4176         : ${BUILD_LIBS:=''}
4177         : ${BUILD_EXEEXT:='$x'}
4178         : ${BUILD_OBJEXT:='o'}
4179
4180 # Check whether --with-build-cc or --without-build-cc was given.
4181 if test "${with_build_cc+set}" = set; then
4182   withval="$with_build_cc"
4183   BUILD_CC="$withval"
4184 else
4185   for ac_prog in gcc clang c99 c89 cc cl
4186 do
4187   # Extract the first word of "$ac_prog", so it can be a program name with args.
4188 set dummy $ac_prog; ac_word=$2
4189 echo "$as_me:4189: checking for $ac_word" >&5
4190 echo $ECHO_N "checking for $ac_word... $ECHO_C" >&6
4191 if test "${ac_cv_prog_BUILD_CC+set}" = set; then
4192   echo $ECHO_N "(cached) $ECHO_C" >&6
4193 else
4194   if test -n "$BUILD_CC"; then
4195   ac_cv_prog_BUILD_CC="$BUILD_CC" # Let the user override the test.
4196 else
4197   ac_save_IFS=$IFS; IFS=$ac_path_separator
4198 ac_dummy="$PATH"
4199 for ac_dir in $ac_dummy; do
4200   IFS=$ac_save_IFS
4201   test -z "$ac_dir" && ac_dir=.
4202   $as_executable_p "$ac_dir/$ac_word" || continue
4203 ac_cv_prog_BUILD_CC="$ac_prog"
4204 echo "$as_me:4204: found $ac_dir/$ac_word" >&5
4205 break
4206 done
4207
4208 fi
4209 fi
4210 BUILD_CC=$ac_cv_prog_BUILD_CC
4211 if test -n "$BUILD_CC"; then
4212   echo "$as_me:4212: result: $BUILD_CC" >&5
4213 echo "${ECHO_T}$BUILD_CC" >&6
4214 else
4215   echo "$as_me:4215: result: no" >&5
4216 echo "${ECHO_T}no" >&6
4217 fi
4218
4219   test -n "$BUILD_CC" && break
4220 done
4221 test -n "$BUILD_CC" || BUILD_CC="none"
4222
4223 fi;
4224         echo "$as_me:4224: checking for native build C compiler" >&5
4225 echo $ECHO_N "checking for native build C compiler... $ECHO_C" >&6
4226         echo "$as_me:4226: result: $BUILD_CC" >&5
4227 echo "${ECHO_T}$BUILD_CC" >&6
4228
4229         echo "$as_me:4229: checking for native build C preprocessor" >&5
4230 echo $ECHO_N "checking for native build C preprocessor... $ECHO_C" >&6
4231
4232 # Check whether --with-build-cpp or --without-build-cpp was given.
4233 if test "${with_build_cpp+set}" = set; then
4234   withval="$with_build_cpp"
4235   BUILD_CPP="$withval"
4236 else
4237   BUILD_CPP='${BUILD_CC} -E'
4238 fi;
4239         echo "$as_me:4239: result: $BUILD_CPP" >&5
4240 echo "${ECHO_T}$BUILD_CPP" >&6
4241
4242         echo "$as_me:4242: checking for native build C flags" >&5
4243 echo $ECHO_N "checking for native build C flags... $ECHO_C" >&6
4244
4245 # Check whether --with-build-cflags or --without-build-cflags was given.
4246 if test "${with_build_cflags+set}" = set; then
4247   withval="$with_build_cflags"
4248   BUILD_CFLAGS="$withval"
4249 fi;
4250         echo "$as_me:4250: result: $BUILD_CFLAGS" >&5
4251 echo "${ECHO_T}$BUILD_CFLAGS" >&6
4252
4253         echo "$as_me:4253: checking for native build C preprocessor-flags" >&5
4254 echo $ECHO_N "checking for native build C preprocessor-flags... $ECHO_C" >&6
4255
4256 # Check whether --with-build-cppflags or --without-build-cppflags was given.
4257 if test "${with_build_cppflags+set}" = set; then
4258   withval="$with_build_cppflags"
4259   BUILD_CPPFLAGS="$withval"
4260 fi;
4261         echo "$as_me:4261: result: $BUILD_CPPFLAGS" >&5
4262 echo "${ECHO_T}$BUILD_CPPFLAGS" >&6
4263
4264         echo "$as_me:4264: checking for native build linker-flags" >&5
4265 echo $ECHO_N "checking for native build linker-flags... $ECHO_C" >&6
4266
4267 # Check whether --with-build-ldflags or --without-build-ldflags was given.
4268 if test "${with_build_ldflags+set}" = set; then
4269   withval="$with_build_ldflags"
4270   BUILD_LDFLAGS="$withval"
4271 fi;
4272         echo "$as_me:4272: result: $BUILD_LDFLAGS" >&5
4273 echo "${ECHO_T}$BUILD_LDFLAGS" >&6
4274
4275         echo "$as_me:4275: checking for native build linker-libraries" >&5
4276 echo $ECHO_N "checking for native build linker-libraries... $ECHO_C" >&6
4277
4278 # Check whether --with-build-libs or --without-build-libs was given.
4279 if test "${with_build_libs+set}" = set; then
4280   withval="$with_build_libs"
4281   BUILD_LIBS="$withval"
4282 fi;
4283         echo "$as_me:4283: result: $BUILD_LIBS" >&5
4284 echo "${ECHO_T}$BUILD_LIBS" >&6
4285
4286         # this assumes we're on Unix.
4287         BUILD_EXEEXT=
4288         BUILD_OBJEXT=o
4289
4290         : ${BUILD_CC:='${CC}'}
4291
4292         if { test "$BUILD_CC" = "$CC" || test "$BUILD_CC" = '${CC}'; } ; then
4293                 { { echo "$as_me:4293: error: Cross-build requires two compilers.
4294 Use --with-build-cc to specify the native compiler." >&5
4295 echo "$as_me: error: Cross-build requires two compilers.
4296 Use --with-build-cc to specify the native compiler." >&2;}
4297    { (exit 1); exit 1; }; }
4298         fi
4299
4300 else
4301         : ${BUILD_CC:='${CC}'}
4302         : ${BUILD_CPP:='${CPP}'}
4303         : ${BUILD_CFLAGS:='${CFLAGS}'}
4304         : ${BUILD_CPPFLAGS:='${CPPFLAGS}'}
4305         : ${BUILD_LDFLAGS:='${LDFLAGS}'}
4306         : ${BUILD_LIBS:='${LIBS}'}
4307         : ${BUILD_EXEEXT:='$x'}
4308         : ${BUILD_OBJEXT:='o'}
4309 fi
4310
4311 ###############################################################################
4312
4313 ### Options to allow the user to specify the set of libraries which are used.
4314 ### Use "--without-normal --with-shared" to allow the default model to be
4315 ### shared, for example.
4316 cf_list_models=""
4317
4318 echo "$as_me:4318: checking if you want to build shared C-objects" >&5
4319 echo $ECHO_N "checking if you want to build shared C-objects... $ECHO_C" >&6
4320
4321 # Check whether --with-shared or --without-shared was given.
4322 if test "${with_shared+set}" = set; then
4323   withval="$with_shared"
4324   with_shared=$withval
4325 else
4326   with_shared=no
4327 fi;
4328 echo "$as_me:4328: result: $with_shared" >&5
4329 echo "${ECHO_T}$with_shared" >&6
4330 test "$with_shared" = "yes" && cf_list_models="$cf_list_models shared"
4331
4332 echo "$as_me:4332: checking for specified models" >&5
4333 echo $ECHO_N "checking for specified models... $ECHO_C" >&6
4334 test -z "$cf_list_models" && cf_list_models=normal
4335 echo "$as_me:4335: result: $cf_list_models" >&5
4336 echo "${ECHO_T}$cf_list_models" >&6
4337
4338 ### Use the first model as the default, and save its suffix for use in building
4339 ### up test-applications.
4340 echo "$as_me:4340: checking for default model" >&5
4341 echo $ECHO_N "checking for default model... $ECHO_C" >&6
4342 DFT_LWR_MODEL=`echo "$cf_list_models" | $AWK '{print $1}'`
4343 echo "$as_me:4343: result: $DFT_LWR_MODEL" >&5
4344 echo "${ECHO_T}$DFT_LWR_MODEL" >&6
4345
4346 DFT_UPR_MODEL=`echo "$DFT_LWR_MODEL" | sed y%abcdefghijklmnopqrstuvwxyz./-%ABCDEFGHIJKLMNOPQRSTUVWXYZ___%`
4347
4348 echo "$as_me:4348: checking for specific curses-directory" >&5
4349 echo $ECHO_N "checking for specific curses-directory... $ECHO_C" >&6
4350
4351 # Check whether --with-curses-dir or --without-curses-dir was given.
4352 if test "${with_curses_dir+set}" = set; then
4353   withval="$with_curses_dir"
4354   cf_cv_curses_dir=$withval
4355 else
4356   cf_cv_curses_dir=no
4357 fi;
4358 echo "$as_me:4358: result: $cf_cv_curses_dir" >&5
4359 echo "${ECHO_T}$cf_cv_curses_dir" >&6
4360
4361 if test -n "$cf_cv_curses_dir" && test "$cf_cv_curses_dir" != "no"
4362 then
4363
4364 if test "x$prefix" != xNONE; then
4365         cf_path_syntax="$prefix"
4366 else
4367         cf_path_syntax="$ac_default_prefix"
4368 fi
4369
4370 case ".$withval" in
4371 (.\$\(*\)*|.\'*\'*)
4372         ;;
4373 (..|./*|.\\*)
4374         ;;
4375 (.[a-zA-Z]:[\\/]*) # OS/2 EMX
4376         ;;
4377 (.\$\{*prefix\}*|.\$\{*dir\}*)
4378         eval withval="$withval"
4379         case ".$withval" in
4380         (.NONE/*)
4381                 withval=`echo "$withval" | sed -e s%NONE%$cf_path_syntax%`
4382                 ;;
4383         esac
4384         ;;
4385 (.no|.NONE/*)
4386         withval=`echo "$withval" | sed -e s%NONE%$cf_path_syntax%`
4387         ;;
4388 (*)
4389         { { echo "$as_me:4389: error: expected a pathname, not \"$withval\"" >&5
4390 echo "$as_me: error: expected a pathname, not \"$withval\"" >&2;}
4391    { (exit 1); exit 1; }; }
4392         ;;
4393 esac
4394
4395         if test -d "$cf_cv_curses_dir"
4396         then
4397
4398 if test -n "$cf_cv_curses_dir/include" ; then
4399   for cf_add_incdir in $cf_cv_curses_dir/include
4400   do
4401         while test "$cf_add_incdir" != /usr/include
4402         do
4403           if test -d "$cf_add_incdir"
4404           then
4405                 cf_have_incdir=no
4406                 if test -n "$CFLAGS$CPPFLAGS" ; then
4407                   # a loop is needed to ensure we can add subdirs of existing dirs
4408                   for cf_test_incdir in $CFLAGS $CPPFLAGS ; do
4409                         if test ".$cf_test_incdir" = ".-I$cf_add_incdir" ; then
4410                           cf_have_incdir=yes; break
4411                         fi
4412                   done
4413                 fi
4414
4415                 if test "$cf_have_incdir" = no ; then
4416                   if test "$cf_add_incdir" = /usr/local/include ; then
4417                         if test "$GCC" = yes
4418                         then
4419                           cf_save_CPPFLAGS=$CPPFLAGS
4420
4421         test -n "$CPPFLAGS" && CPPFLAGS="$CPPFLAGS "
4422         CPPFLAGS="${CPPFLAGS}-I$cf_add_incdir"
4423
4424                           cat >"conftest.$ac_ext" <<_ACEOF
4425 #line 4425 "configure"
4426 #include "confdefs.h"
4427 #include <stdio.h>
4428 int
4429 main (void)
4430 {
4431 printf("Hello")
4432   ;
4433   return 0;
4434 }
4435 _ACEOF
4436 rm -f "conftest.$ac_objext"
4437 if { (eval echo "$as_me:4437: \"$ac_compile\"") >&5
4438   (eval $ac_compile) 2>&5
4439   ac_status=$?
4440   echo "$as_me:4440: \$? = $ac_status" >&5
4441   (exit "$ac_status"); } &&
4442          { ac_try='test -s "conftest.$ac_objext"'
4443   { (eval echo "$as_me:4443: \"$ac_try\"") >&5
4444   (eval $ac_try) 2>&5
4445   ac_status=$?
4446   echo "$as_me:4446: \$? = $ac_status" >&5
4447   (exit "$ac_status"); }; }; then
4448   :
4449 else
4450   echo "$as_me: failed program was:" >&5
4451 cat "conftest.$ac_ext" >&5
4452 cf_have_incdir=yes
4453 fi
4454 rm -f "conftest.$ac_objext" "conftest.$ac_ext"
4455                           CPPFLAGS=$cf_save_CPPFLAGS
4456                         fi
4457                   fi
4458                 fi
4459
4460                 if test "$cf_have_incdir" = no ; then
4461                   test -n "$verbose" && echo "  adding $cf_add_incdir to include-path" 1>&6
4462
4463 echo "${as_me:-configure}:4463: testing adding $cf_add_incdir to include-path ..." 1>&5
4464
4465                   CPPFLAGS="$CPPFLAGS -I$cf_add_incdir"
4466
4467                   cf_top_incdir=`echo "$cf_add_incdir" | sed -e 's%/include/.*$%/include%'`
4468                   test "$cf_top_incdir" = "$cf_add_incdir" && break
4469                   cf_add_incdir="$cf_top_incdir"
4470                 else
4471                   break
4472                 fi
4473           else
4474                 break
4475           fi
4476         done
4477   done
4478 fi
4479
4480 if test -n "$cf_cv_curses_dir/lib" ; then
4481         for cf_add_libdir in $cf_cv_curses_dir/lib
4482         do
4483                 if test "$cf_add_libdir" = /usr/lib ; then
4484                         :
4485                 elif test -d "$cf_add_libdir"
4486                 then
4487                         cf_have_libdir=no
4488                         if test -n "$LDFLAGS$LIBS" ; then
4489                                 # a loop is needed to ensure we can add subdirs of existing dirs
4490                                 for cf_test_libdir in $LDFLAGS $LIBS ; do
4491                                         if test ".$cf_test_libdir" = ".-L$cf_add_libdir" ; then
4492                                                 cf_have_libdir=yes; break
4493                                         fi
4494                                 done
4495                         fi
4496                         if test "$cf_have_libdir" = no ; then
4497                                 test -n "$verbose" && echo "    adding $cf_add_libdir to library-path" 1>&6
4498
4499 echo "${as_me:-configure}:4499: testing adding $cf_add_libdir to library-path ..." 1>&5
4500
4501                                 LDFLAGS="-L$cf_add_libdir $LDFLAGS"
4502                         fi
4503                 fi
4504         done
4505 fi
4506
4507         fi
4508 fi
4509
4510 cf_ncuconfig_root=ncurses
4511 cf_have_ncuconfig=no
4512
4513 if test "x${PKG_CONFIG:=none}" != xnone; then
4514         echo "$as_me:4514: checking pkg-config for $cf_ncuconfig_root" >&5
4515 echo $ECHO_N "checking pkg-config for $cf_ncuconfig_root... $ECHO_C" >&6
4516         if "$PKG_CONFIG" --exists $cf_ncuconfig_root ; then
4517                 echo "$as_me:4517: result: yes" >&5
4518 echo "${ECHO_T}yes" >&6
4519
4520                 echo "$as_me:4520: checking if the $cf_ncuconfig_root package files work" >&5
4521 echo $ECHO_N "checking if the $cf_ncuconfig_root package files work... $ECHO_C" >&6
4522                 cf_have_ncuconfig=unknown
4523
4524                 cf_save_CFLAGS="$CFLAGS"
4525                 cf_save_CPPFLAGS="$CPPFLAGS"
4526                 cf_save_LIBS="$LIBS"
4527
4528                 cf_pkg_cflags="`$PKG_CONFIG --cflags $cf_ncuconfig_root`"
4529                 cf_pkg_libs="`$PKG_CONFIG --libs $cf_ncuconfig_root`"
4530
4531                 # while -W for passing linker flags is prevalent, it is not "standard".
4532                 # At least one wrapper for c89/c99 (in Apple's xcode) has its own
4533                 # incompatible _and_ non-standard -W option which gives an error.  Work
4534                 # around that pitfall.
4535                 case "x${CC}@@${cf_pkg_libs}@${cf_pkg_cflags}" in
4536                 (x*c[89]9@@*-W*)
4537
4538 cf_fix_cppflags=no
4539 cf_new_cflags=
4540 cf_new_cppflags=
4541 cf_new_extra_cppflags=
4542
4543 for cf_add_cflags in $cf_pkg_cflags
4544 do
4545 case "$cf_fix_cppflags" in
4546 (no)
4547         case "$cf_add_cflags" in
4548         (-undef|-nostdinc*|-I*|-D*|-U*|-E|-P|-C)
4549                 case "$cf_add_cflags" in
4550                 (-D*)
4551                         cf_tst_cflags=`echo "${cf_add_cflags}" |sed -e 's/^-D[^=]*='\''\"[^"]*//'`
4552
4553                         test "x${cf_add_cflags}" != "x${cf_tst_cflags}" \
4554                                 && test -z "${cf_tst_cflags}" \
4555                                 && cf_fix_cppflags=yes
4556
4557                         if test "$cf_fix_cppflags" = yes ; then
4558
4559         test -n "$cf_new_extra_cppflags" && cf_new_extra_cppflags="$cf_new_extra_cppflags "
4560         cf_new_extra_cppflags="${cf_new_extra_cppflags}$cf_add_cflags"
4561
4562                                 continue
4563                         elif test "${cf_tst_cflags}" = "\"'" ; then
4564
4565         test -n "$cf_new_extra_cppflags" && cf_new_extra_cppflags="$cf_new_extra_cppflags "
4566         cf_new_extra_cppflags="${cf_new_extra_cppflags}$cf_add_cflags"
4567
4568                                 continue
4569                         fi
4570                         ;;
4571                 esac
4572                 case "$CPPFLAGS" in
4573                 (*$cf_add_cflags)
4574                         ;;
4575                 (*)
4576                         case "$cf_add_cflags" in
4577                         (-D*)
4578                                 cf_tst_cppflags=`echo "x$cf_add_cflags" | sed -e 's/^...//' -e 's/=.*//'`
4579
4580 CPPFLAGS=`echo "$CPPFLAGS" | \
4581         sed     -e 's/-[UD]'"$cf_tst_cppflags"'\(=[^    ]*\)\?[         ]/ /g' \
4582                 -e 's/-[UD]'"$cf_tst_cppflags"'\(=[^    ]*\)\?$//g'`
4583
4584                                 ;;
4585                         esac
4586
4587         test -n "$cf_new_cppflags" && cf_new_cppflags="$cf_new_cppflags "
4588         cf_new_cppflags="${cf_new_cppflags}$cf_add_cflags"
4589
4590                         ;;
4591                 esac
4592                 ;;
4593         (*)
4594
4595         test -n "$cf_new_cflags" && cf_new_cflags="$cf_new_cflags "
4596         cf_new_cflags="${cf_new_cflags}$cf_add_cflags"
4597
4598                 ;;
4599         esac
4600         ;;
4601 (yes)
4602
4603         test -n "$cf_new_extra_cppflags" && cf_new_extra_cppflags="$cf_new_extra_cppflags "
4604         cf_new_extra_cppflags="${cf_new_extra_cppflags}$cf_add_cflags"
4605
4606         cf_tst_cflags=`echo "${cf_add_cflags}" |sed -e 's/^[^"]*"'\''//'`
4607
4608         test "x${cf_add_cflags}" != "x${cf_tst_cflags}" \
4609                 && test -z "${cf_tst_cflags}" \
4610                 && cf_fix_cppflags=no
4611         ;;
4612 esac
4613 done
4614
4615 if test -n "$cf_new_cflags" ; then
4616
4617         test -n "$CFLAGS" && CFLAGS="$CFLAGS "
4618         CFLAGS="${CFLAGS}$cf_new_cflags"
4619
4620 fi
4621
4622 if test -n "$cf_new_cppflags" ; then
4623
4624         test -n "$CPPFLAGS" && CPPFLAGS="$CPPFLAGS "
4625         CPPFLAGS="${CPPFLAGS}$cf_new_cppflags"
4626
4627 fi
4628
4629 if test -n "$cf_new_extra_cppflags" ; then
4630
4631         test -n "$EXTRA_CPPFLAGS" && EXTRA_CPPFLAGS="$EXTRA_CPPFLAGS "
4632         EXTRA_CPPFLAGS="${EXTRA_CPPFLAGS}$cf_new_extra_cppflags"
4633
4634 fi
4635
4636 cf_add_libs="$LIBS"
4637 # reverse order
4638 cf_add_0lib=
4639 for cf_add_1lib in $cf_pkg_libs; do cf_add_0lib="$cf_add_1lib $cf_add_0lib"; done
4640 # filter duplicates
4641 for cf_add_1lib in $cf_add_0lib; do
4642         for cf_add_2lib in $cf_add_libs; do
4643                 if test "x$cf_add_1lib" = "x$cf_add_2lib"; then
4644                         cf_add_1lib=
4645                         break
4646                 fi
4647         done
4648         test -n "$cf_add_1lib" && cf_add_libs="$cf_add_1lib $cf_add_libs"
4649 done
4650 LIBS="$cf_add_libs"
4651
4652                         cat >"conftest.$ac_ext" <<_ACEOF
4653 #line 4653 "configure"
4654 #include "confdefs.h"
4655 #include <${cf_cv_ncurses_header:-curses.h}>
4656 int
4657 main (void)
4658 {
4659 initscr(); mousemask(0,0); tigetstr((char *)0);
4660   ;
4661   return 0;
4662 }
4663 _ACEOF
4664 rm -f "conftest.$ac_objext" "conftest$ac_exeext"
4665 if { (eval echo "$as_me:4665: \"$ac_link\"") >&5
4666   (eval $ac_link) 2>&5
4667   ac_status=$?
4668   echo "$as_me:4668: \$? = $ac_status" >&5
4669   (exit "$ac_status"); } &&
4670          { ac_try='test -s "conftest$ac_exeext"'
4671   { (eval echo "$as_me:4671: \"$ac_try\"") >&5
4672   (eval $ac_try) 2>&5
4673   ac_status=$?
4674   echo "$as_me:4674: \$? = $ac_status" >&5
4675   (exit "$ac_status"); }; }; then
4676   if test "$cross_compiling" = yes; then
4677   cf_test_ncuconfig=maybe
4678 else
4679   cat >"conftest.$ac_ext" <<_ACEOF
4680 #line 4680 "configure"
4681 #include "confdefs.h"
4682 #include <${cf_cv_ncurses_header:-curses.h}>
4683                                         int main(void)
4684                                         { const char *xx = curses_version(); return (xx == 0); }
4685 _ACEOF
4686 rm -f "conftest$ac_exeext"
4687 if { (eval echo "$as_me:4687: \"$ac_link\"") >&5
4688   (eval $ac_link) 2>&5
4689   ac_status=$?
4690   echo "$as_me:4690: \$? = $ac_status" >&5
4691   (exit "$ac_status"); } && { ac_try='"./conftest$ac_exeext"'
4692   { (eval echo "$as_me:4692: \"$ac_try\"") >&5
4693   (eval $ac_try) 2>&5
4694   ac_status=$?
4695   echo "$as_me:4695: \$? = $ac_status" >&5
4696   (exit "$ac_status"); }; }; then
4697   cf_test_ncuconfig=yes
4698 else
4699   echo "$as_me: program exited with status $ac_status" >&5
4700 echo "$as_me: failed program was:" >&5
4701 cat "conftest.$ac_ext" >&5
4702 cf_test_ncuconfig=no
4703 fi
4704 rm -f core ./core.* ./*.core "conftest$ac_exeext" "conftest.$ac_objext" "conftest.$ac_ext"
4705 fi
4706 else
4707   echo "$as_me: failed program was:" >&5
4708 cat "conftest.$ac_ext" >&5
4709 cf_test_ncuconfig=no
4710 fi
4711 rm -f "conftest.$ac_objext" "conftest$ac_exeext" "conftest.$ac_ext"
4712
4713                         CFLAGS="$cf_save_CFLAGS"
4714                         CPPFLAGS="$cf_save_CPPFLAGS"
4715                         LIBS="$cf_save_LIBS"
4716
4717                         if test "x$cf_test_ncuconfig" != xyes; then
4718                                 cf_temp=`echo "x$cf_pkg_cflags" | sed -e s/^x// -e 's/-W[^      ]*//g'`
4719                                 cf_pkg_cflags="$cf_temp"
4720                                 cf_temp=`echo "x$cf_pkg_libs" | sed -e s/^x// -e 's/-W[^        ]*//g'`
4721                                 cf_pkg_libs="$cf_temp"
4722                         fi
4723                         ;;
4724                 esac
4725
4726 for cf_add_cflags in $cf_pkg_cflags
4727 do
4728         case "x$cf_add_cflags" in
4729         (x-[DU]*)
4730
4731 cf_tmp_cflag=`echo "x$cf_add_cflags" | sed -e 's/^.//' -e 's/=.*//'`
4732 while true
4733 do
4734         cf_old_cflag=`echo "x$CFLAGS" | sed -e 's/^.//' -e 's/[         ][      ]*-/ -/g' -e "s%$cf_tmp_cflag\\(=[^     ][^     ]*\\)\?%%" -e 's/^[     ]*//' -e 's%[ ][ ]*-D% -D%g' -e 's%[ ][ ]*-I% -I%g'`
4735         test "$CFLAGS" != "$cf_old_cflag" || break
4736
4737         CFLAGS="$cf_old_cflag"
4738 done
4739
4740 cf_tmp_cflag=`echo "x$cf_add_cflags" | sed -e 's/^.//' -e 's/=.*//'`
4741 while true
4742 do
4743         cf_old_cflag=`echo "x$CPPFLAGS" | sed -e 's/^.//' -e 's/[       ][      ]*-/ -/g' -e "s%$cf_tmp_cflag\\(=[^     ][^     ]*\\)\?%%" -e 's/^[     ]*//' -e 's%[ ][ ]*-D% -D%g' -e 's%[ ][ ]*-I% -I%g'`
4744         test "$CPPFLAGS" != "$cf_old_cflag" || break
4745
4746         CPPFLAGS="$cf_old_cflag"
4747 done
4748
4749                 ;;
4750         esac
4751
4752 cf_fix_cppflags=no
4753 cf_new_cflags=
4754 cf_new_cppflags=
4755 cf_new_extra_cppflags=
4756
4757 for cf_add_cflags in $cf_add_cflags
4758 do
4759 case "$cf_fix_cppflags" in
4760 (no)
4761         case "$cf_add_cflags" in
4762         (-undef|-nostdinc*|-I*|-D*|-U*|-E|-P|-C)
4763                 case "$cf_add_cflags" in
4764                 (-D*)
4765                         cf_tst_cflags=`echo "${cf_add_cflags}" |sed -e 's/^-D[^=]*='\''\"[^"]*//'`
4766
4767                         test "x${cf_add_cflags}" != "x${cf_tst_cflags}" \
4768                                 && test -z "${cf_tst_cflags}" \
4769                                 && cf_fix_cppflags=yes
4770
4771                         if test "$cf_fix_cppflags" = yes ; then
4772
4773         test -n "$cf_new_extra_cppflags" && cf_new_extra_cppflags="$cf_new_extra_cppflags "
4774         cf_new_extra_cppflags="${cf_new_extra_cppflags}$cf_add_cflags"
4775
4776                                 continue
4777                         elif test "${cf_tst_cflags}" = "\"'" ; then
4778
4779         test -n "$cf_new_extra_cppflags" && cf_new_extra_cppflags="$cf_new_extra_cppflags "
4780         cf_new_extra_cppflags="${cf_new_extra_cppflags}$cf_add_cflags"
4781
4782                                 continue
4783                         fi
4784                         ;;
4785                 esac
4786                 case "$CPPFLAGS" in
4787                 (*$cf_add_cflags)
4788                         ;;
4789                 (*)
4790                         case "$cf_add_cflags" in
4791                         (-D*)
4792                                 cf_tst_cppflags=`echo "x$cf_add_cflags" | sed -e 's/^...//' -e 's/=.*//'`
4793
4794 CPPFLAGS=`echo "$CPPFLAGS" | \
4795         sed     -e 's/-[UD]'"$cf_tst_cppflags"'\(=[^    ]*\)\?[         ]/ /g' \
4796                 -e 's/-[UD]'"$cf_tst_cppflags"'\(=[^    ]*\)\?$//g'`
4797
4798                                 ;;
4799                         esac
4800
4801         test -n "$cf_new_cppflags" && cf_new_cppflags="$cf_new_cppflags "
4802         cf_new_cppflags="${cf_new_cppflags}$cf_add_cflags"
4803
4804                         ;;
4805                 esac
4806                 ;;
4807         (*)
4808
4809         test -n "$cf_new_cflags" && cf_new_cflags="$cf_new_cflags "
4810         cf_new_cflags="${cf_new_cflags}$cf_add_cflags"
4811
4812                 ;;
4813         esac
4814         ;;
4815 (yes)
4816
4817         test -n "$cf_new_extra_cppflags" && cf_new_extra_cppflags="$cf_new_extra_cppflags "
4818         cf_new_extra_cppflags="${cf_new_extra_cppflags}$cf_add_cflags"
4819
4820         cf_tst_cflags=`echo "${cf_add_cflags}" |sed -e 's/^[^"]*"'\''//'`
4821
4822         test "x${cf_add_cflags}" != "x${cf_tst_cflags}" \
4823                 && test -z "${cf_tst_cflags}" \
4824                 && cf_fix_cppflags=no
4825         ;;
4826 esac
4827 done
4828
4829 if test -n "$cf_new_cflags" ; then
4830
4831         test -n "$CFLAGS" && CFLAGS="$CFLAGS "
4832         CFLAGS="${CFLAGS}$cf_new_cflags"
4833
4834 fi
4835
4836 if test -n "$cf_new_cppflags" ; then
4837
4838         test -n "$CPPFLAGS" && CPPFLAGS="$CPPFLAGS "
4839         CPPFLAGS="${CPPFLAGS}$cf_new_cppflags"
4840
4841 fi
4842
4843 if test -n "$cf_new_extra_cppflags" ; then
4844
4845         test -n "$EXTRA_CPPFLAGS" && EXTRA_CPPFLAGS="$EXTRA_CPPFLAGS "
4846         EXTRA_CPPFLAGS="${EXTRA_CPPFLAGS}$cf_new_extra_cppflags"
4847
4848 fi
4849
4850 done
4851
4852 cf_add_libs="$LIBS"
4853 # reverse order
4854 cf_add_0lib=
4855 for cf_add_1lib in $cf_pkg_libs; do cf_add_0lib="$cf_add_1lib $cf_add_0lib"; done
4856 # filter duplicates
4857 for cf_add_1lib in $cf_add_0lib; do
4858         for cf_add_2lib in $cf_add_libs; do
4859                 if test "x$cf_add_1lib" = "x$cf_add_2lib"; then
4860                         cf_add_1lib=
4861                         break
4862                 fi
4863         done
4864         test -n "$cf_add_1lib" && cf_add_libs="$cf_add_1lib $cf_add_libs"
4865 done
4866 LIBS="$cf_add_libs"
4867
4868                 cat >"conftest.$ac_ext" <<_ACEOF
4869 #line 4869 "configure"
4870 #include "confdefs.h"
4871 #include <${cf_cv_ncurses_header:-curses.h}>
4872 int
4873 main (void)
4874 {
4875 initscr(); mousemask(0,0); tigetstr((char *)0);
4876   ;
4877   return 0;
4878 }
4879 _ACEOF
4880 rm -f "conftest.$ac_objext" "conftest$ac_exeext"
4881 if { (eval echo "$as_me:4881: \"$ac_link\"") >&5
4882   (eval $ac_link) 2>&5
4883   ac_status=$?
4884   echo "$as_me:4884: \$? = $ac_status" >&5
4885   (exit "$ac_status"); } &&
4886          { ac_try='test -s "conftest$ac_exeext"'
4887   { (eval echo "$as_me:4887: \"$ac_try\"") >&5
4888   (eval $ac_try) 2>&5
4889   ac_status=$?
4890   echo "$as_me:4890: \$? = $ac_status" >&5
4891   (exit "$ac_status"); }; }; then
4892   if test "$cross_compiling" = yes; then
4893   cf_have_ncuconfig=maybe
4894 else
4895   cat >"conftest.$ac_ext" <<_ACEOF
4896 #line 4896 "configure"
4897 #include "confdefs.h"
4898 #include <${cf_cv_ncurses_header:-curses.h}>
4899                                 int main(void)
4900                                 { const char *xx = curses_version(); return (xx == 0); }
4901 _ACEOF
4902 rm -f "conftest$ac_exeext"
4903 if { (eval echo "$as_me:4903: \"$ac_link\"") >&5
4904   (eval $ac_link) 2>&5
4905   ac_status=$?
4906   echo "$as_me:4906: \$? = $ac_status" >&5
4907   (exit "$ac_status"); } && { ac_try='"./conftest$ac_exeext"'
4908   { (eval echo "$as_me:4908: \"$ac_try\"") >&5
4909   (eval $ac_try) 2>&5
4910   ac_status=$?
4911   echo "$as_me:4911: \$? = $ac_status" >&5
4912   (exit "$ac_status"); }; }; then
4913   cf_have_ncuconfig=yes
4914 else
4915   echo "$as_me: program exited with status $ac_status" >&5
4916 echo "$as_me: failed program was:" >&5
4917 cat "conftest.$ac_ext" >&5
4918 cf_have_ncuconfig=no
4919 fi
4920 rm -f core ./core.* ./*.core "conftest$ac_exeext" "conftest.$ac_objext" "conftest.$ac_ext"
4921 fi
4922 else
4923   echo "$as_me: failed program was:" >&5
4924 cat "conftest.$ac_ext" >&5
4925 cf_have_ncuconfig=no
4926 fi
4927 rm -f "conftest.$ac_objext" "conftest$ac_exeext" "conftest.$ac_ext"
4928                 echo "$as_me:4928: result: $cf_have_ncuconfig" >&5
4929 echo "${ECHO_T}$cf_have_ncuconfig" >&6
4930                 test "$cf_have_ncuconfig" = maybe && cf_have_ncuconfig=yes
4931                 if test "$cf_have_ncuconfig" != "yes"
4932                 then
4933                         CPPFLAGS="$cf_save_CPPFLAGS"
4934                         LIBS="$cf_save_LIBS"
4935                         NCURSES_CONFIG_PKG=none
4936                 else
4937
4938 cat >>confdefs.h <<\EOF
4939 #define NCURSES 1
4940 EOF
4941
4942                         NCURSES_CONFIG_PKG=$cf_ncuconfig_root
4943
4944 echo "$as_me:4944: checking for terminfo header" >&5
4945 echo $ECHO_N "checking for terminfo header... $ECHO_C" >&6
4946 if test "${cf_cv_term_header+set}" = set; then
4947   echo $ECHO_N "(cached) $ECHO_C" >&6
4948 else
4949
4950 case "${cf_cv_ncurses_header}" in
4951 (*/ncurses.h|*/ncursesw.h)
4952         cf_term_header=`echo "$cf_cv_ncurses_header" | sed -e 's%ncurses[^.]*\.h$%term.h%'`
4953         ;;
4954 (*)
4955         cf_term_header=term.h
4956         ;;
4957 esac
4958
4959 for cf_test in $cf_term_header "ncurses/term.h" "ncursesw/term.h"
4960 do
4961 cat >"conftest.$ac_ext" <<_ACEOF
4962 #line 4962 "configure"
4963 #include "confdefs.h"
4964 #include <stdio.h>
4965 #include <${cf_cv_ncurses_header:-curses.h}>
4966 #include <$cf_test>
4967
4968 int
4969 main (void)
4970 {
4971 int x = auto_left_margin; (void)x
4972   ;
4973   return 0;
4974 }
4975 _ACEOF
4976 rm -f "conftest.$ac_objext"
4977 if { (eval echo "$as_me:4977: \"$ac_compile\"") >&5
4978   (eval $ac_compile) 2>&5
4979   ac_status=$?
4980   echo "$as_me:4980: \$? = $ac_status" >&5
4981   (exit "$ac_status"); } &&
4982          { ac_try='test -s "conftest.$ac_objext"'
4983   { (eval echo "$as_me:4983: \"$ac_try\"") >&5
4984   (eval $ac_try) 2>&5
4985   ac_status=$?
4986   echo "$as_me:4986: \$? = $ac_status" >&5
4987   (exit "$ac_status"); }; }; then
4988
4989         cf_cv_term_header="$cf_test"
4990 else
4991   echo "$as_me: failed program was:" >&5
4992 cat "conftest.$ac_ext" >&5
4993
4994         cf_cv_term_header=unknown
4995
4996 fi
4997 rm -f "conftest.$ac_objext" "conftest.$ac_ext"
4998         test "$cf_cv_term_header" != unknown && break
4999 done
5000
5001 fi
5002 echo "$as_me:5002: result: $cf_cv_term_header" >&5
5003 echo "${ECHO_T}$cf_cv_term_header" >&6
5004
5005 # Set definitions to allow ifdef'ing to accommodate subdirectories
5006
5007 case "$cf_cv_term_header" in
5008 (*term.h)
5009
5010 cat >>confdefs.h <<\EOF
5011 #define HAVE_TERM_H 1
5012 EOF
5013
5014         ;;
5015 esac
5016
5017 case "$cf_cv_term_header" in
5018 (ncurses/term.h)
5019
5020 cat >>confdefs.h <<\EOF
5021 #define HAVE_NCURSES_TERM_H 1
5022 EOF
5023
5024         ;;
5025 (ncursesw/term.h)
5026
5027 cat >>confdefs.h <<\EOF
5028 #define HAVE_NCURSESW_TERM_H 1
5029 EOF
5030
5031         ;;
5032 esac
5033
5034                 fi
5035
5036         else
5037                 echo "$as_me:5037: result: no" >&5
5038 echo "${ECHO_T}no" >&6
5039                 NCURSES_CONFIG_PKG=none
5040         fi
5041 else
5042         NCURSES_CONFIG_PKG=none
5043 fi
5044
5045 if test "x$cf_have_ncuconfig" = "xno"; then
5046         cf_ncurses_config="${cf_ncuconfig_root}${NCURSES_CONFIG_SUFFIX}-config"; echo "Looking for ${cf_ncurses_config}"
5047
5048 if test -n "$ac_tool_prefix"; then
5049   for ac_prog in ${cf_ncurses_config} ${cf_ncuconfig_root}6-config ${cf_ncuconfig_root}6-config ${cf_ncuconfig_root}5-config
5050   do
5051     # Extract the first word of "$ac_tool_prefix$ac_prog", so it can be a program name with args.
5052 set dummy $ac_tool_prefix$ac_prog; ac_word=$2
5053 echo "$as_me:5053: checking for $ac_word" >&5
5054 echo $ECHO_N "checking for $ac_word... $ECHO_C" >&6
5055 if test "${ac_cv_prog_NCURSES_CONFIG+set}" = set; then
5056   echo $ECHO_N "(cached) $ECHO_C" >&6
5057 else
5058   if test -n "$NCURSES_CONFIG"; then
5059   ac_cv_prog_NCURSES_CONFIG="$NCURSES_CONFIG" # Let the user override the test.
5060 else
5061   ac_save_IFS=$IFS; IFS=$ac_path_separator
5062 ac_dummy="$PATH"
5063 for ac_dir in $ac_dummy; do
5064   IFS=$ac_save_IFS
5065   test -z "$ac_dir" && ac_dir=.
5066   $as_executable_p "$ac_dir/$ac_word" || continue
5067 ac_cv_prog_NCURSES_CONFIG="$ac_tool_prefix$ac_prog"
5068 echo "$as_me:5068: found $ac_dir/$ac_word" >&5
5069 break
5070 done
5071
5072 fi
5073 fi
5074 NCURSES_CONFIG=$ac_cv_prog_NCURSES_CONFIG
5075 if test -n "$NCURSES_CONFIG"; then
5076   echo "$as_me:5076: result: $NCURSES_CONFIG" >&5
5077 echo "${ECHO_T}$NCURSES_CONFIG" >&6
5078 else
5079   echo "$as_me:5079: result: no" >&5
5080 echo "${ECHO_T}no" >&6
5081 fi
5082
5083     test -n "$NCURSES_CONFIG" && break
5084   done
5085 fi
5086 if test -z "$NCURSES_CONFIG"; then
5087   ac_ct_NCURSES_CONFIG=$NCURSES_CONFIG
5088   for ac_prog in ${cf_ncurses_config} ${cf_ncuconfig_root}6-config ${cf_ncuconfig_root}6-config ${cf_ncuconfig_root}5-config
5089 do
5090   # Extract the first word of "$ac_prog", so it can be a program name with args.
5091 set dummy $ac_prog; ac_word=$2
5092 echo "$as_me:5092: checking for $ac_word" >&5
5093 echo $ECHO_N "checking for $ac_word... $ECHO_C" >&6
5094 if test "${ac_cv_prog_ac_ct_NCURSES_CONFIG+set}" = set; then
5095   echo $ECHO_N "(cached) $ECHO_C" >&6
5096 else
5097   if test -n "$ac_ct_NCURSES_CONFIG"; then
5098   ac_cv_prog_ac_ct_NCURSES_CONFIG="$ac_ct_NCURSES_CONFIG" # Let the user override the test.
5099 else
5100   ac_save_IFS=$IFS; IFS=$ac_path_separator
5101 ac_dummy="$PATH"
5102 for ac_dir in $ac_dummy; do
5103   IFS=$ac_save_IFS
5104   test -z "$ac_dir" && ac_dir=.
5105   $as_executable_p "$ac_dir/$ac_word" || continue
5106 ac_cv_prog_ac_ct_NCURSES_CONFIG="$ac_prog"
5107 echo "$as_me:5107: found $ac_dir/$ac_word" >&5
5108 break
5109 done
5110
5111 fi
5112 fi
5113 ac_ct_NCURSES_CONFIG=$ac_cv_prog_ac_ct_NCURSES_CONFIG
5114 if test -n "$ac_ct_NCURSES_CONFIG"; then
5115   echo "$as_me:5115: result: $ac_ct_NCURSES_CONFIG" >&5
5116 echo "${ECHO_T}$ac_ct_NCURSES_CONFIG" >&6
5117 else
5118   echo "$as_me:5118: result: no" >&5
5119 echo "${ECHO_T}no" >&6
5120 fi
5121
5122   test -n "$ac_ct_NCURSES_CONFIG" && break
5123 done
5124 test -n "$ac_ct_NCURSES_CONFIG" || ac_ct_NCURSES_CONFIG="none"
5125
5126   NCURSES_CONFIG=$ac_ct_NCURSES_CONFIG
5127 fi
5128
5129         if test "$NCURSES_CONFIG" != none ; then
5130
5131 for cf_add_cflags in `$NCURSES_CONFIG --cflags`
5132 do
5133         case "x$cf_add_cflags" in
5134         (x-[DU]*)
5135
5136 cf_tmp_cflag=`echo "x$cf_add_cflags" | sed -e 's/^.//' -e 's/=.*//'`
5137 while true
5138 do
5139         cf_old_cflag=`echo "x$CFLAGS" | sed -e 's/^.//' -e 's/[         ][      ]*-/ -/g' -e "s%$cf_tmp_cflag\\(=[^     ][^     ]*\\)\?%%" -e 's/^[     ]*//' -e 's%[ ][ ]*-D% -D%g' -e 's%[ ][ ]*-I% -I%g'`
5140         test "$CFLAGS" != "$cf_old_cflag" || break
5141
5142         CFLAGS="$cf_old_cflag"
5143 done
5144
5145 cf_tmp_cflag=`echo "x$cf_add_cflags" | sed -e 's/^.//' -e 's/=.*//'`
5146 while true
5147 do
5148         cf_old_cflag=`echo "x$CPPFLAGS" | sed -e 's/^.//' -e 's/[       ][      ]*-/ -/g' -e "s%$cf_tmp_cflag\\(=[^     ][^     ]*\\)\?%%" -e 's/^[     ]*//' -e 's%[ ][ ]*-D% -D%g' -e 's%[ ][ ]*-I% -I%g'`
5149         test "$CPPFLAGS" != "$cf_old_cflag" || break
5150
5151         CPPFLAGS="$cf_old_cflag"
5152 done
5153
5154                 ;;
5155         esac
5156
5157 cf_fix_cppflags=no
5158 cf_new_cflags=
5159 cf_new_cppflags=
5160 cf_new_extra_cppflags=
5161
5162 for cf_add_cflags in $cf_add_cflags
5163 do
5164 case "$cf_fix_cppflags" in
5165 (no)
5166         case "$cf_add_cflags" in
5167         (-undef|-nostdinc*|-I*|-D*|-U*|-E|-P|-C)
5168                 case "$cf_add_cflags" in
5169                 (-D*)
5170                         cf_tst_cflags=`echo "${cf_add_cflags}" |sed -e 's/^-D[^=]*='\''\"[^"]*//'`
5171
5172                         test "x${cf_add_cflags}" != "x${cf_tst_cflags}" \
5173                                 && test -z "${cf_tst_cflags}" \
5174                                 && cf_fix_cppflags=yes
5175
5176                         if test "$cf_fix_cppflags" = yes ; then
5177
5178         test -n "$cf_new_extra_cppflags" && cf_new_extra_cppflags="$cf_new_extra_cppflags "
5179         cf_new_extra_cppflags="${cf_new_extra_cppflags}$cf_add_cflags"
5180
5181                                 continue
5182                         elif test "${cf_tst_cflags}" = "\"'" ; then
5183
5184         test -n "$cf_new_extra_cppflags" && cf_new_extra_cppflags="$cf_new_extra_cppflags "
5185         cf_new_extra_cppflags="${cf_new_extra_cppflags}$cf_add_cflags"
5186
5187                                 continue
5188                         fi
5189                         ;;
5190                 esac
5191                 case "$CPPFLAGS" in
5192                 (*$cf_add_cflags)
5193                         ;;
5194                 (*)
5195                         case "$cf_add_cflags" in
5196                         (-D*)
5197                                 cf_tst_cppflags=`echo "x$cf_add_cflags" | sed -e 's/^...//' -e 's/=.*//'`
5198
5199 CPPFLAGS=`echo "$CPPFLAGS" | \
5200         sed     -e 's/-[UD]'"$cf_tst_cppflags"'\(=[^    ]*\)\?[         ]/ /g' \
5201                 -e 's/-[UD]'"$cf_tst_cppflags"'\(=[^    ]*\)\?$//g'`
5202
5203                                 ;;
5204                         esac
5205
5206         test -n "$cf_new_cppflags" && cf_new_cppflags="$cf_new_cppflags "
5207         cf_new_cppflags="${cf_new_cppflags}$cf_add_cflags"
5208
5209                         ;;
5210                 esac
5211                 ;;
5212         (*)
5213
5214         test -n "$cf_new_cflags" && cf_new_cflags="$cf_new_cflags "
5215         cf_new_cflags="${cf_new_cflags}$cf_add_cflags"
5216
5217                 ;;
5218         esac
5219         ;;
5220 (yes)
5221
5222         test -n "$cf_new_extra_cppflags" && cf_new_extra_cppflags="$cf_new_extra_cppflags "
5223         cf_new_extra_cppflags="${cf_new_extra_cppflags}$cf_add_cflags"
5224
5225         cf_tst_cflags=`echo "${cf_add_cflags}" |sed -e 's/^[^"]*"'\''//'`
5226
5227         test "x${cf_add_cflags}" != "x${cf_tst_cflags}" \
5228                 && test -z "${cf_tst_cflags}" \
5229                 && cf_fix_cppflags=no
5230         ;;
5231 esac
5232 done
5233
5234 if test -n "$cf_new_cflags" ; then
5235
5236         test -n "$CFLAGS" && CFLAGS="$CFLAGS "
5237         CFLAGS="${CFLAGS}$cf_new_cflags"
5238
5239 fi
5240
5241 if test -n "$cf_new_cppflags" ; then
5242
5243         test -n "$CPPFLAGS" && CPPFLAGS="$CPPFLAGS "
5244         CPPFLAGS="${CPPFLAGS}$cf_new_cppflags"
5245
5246 fi
5247
5248 if test -n "$cf_new_extra_cppflags" ; then
5249
5250         test -n "$EXTRA_CPPFLAGS" && EXTRA_CPPFLAGS="$EXTRA_CPPFLAGS "
5251         EXTRA_CPPFLAGS="${EXTRA_CPPFLAGS}$cf_new_extra_cppflags"
5252
5253 fi
5254
5255 done
5256
5257 cf_add_libs="$LIBS"
5258 # reverse order
5259 cf_add_0lib=
5260 for cf_add_1lib in `$NCURSES_CONFIG --libs`; do cf_add_0lib="$cf_add_1lib $cf_add_0lib"; done
5261 # filter duplicates
5262 for cf_add_1lib in $cf_add_0lib; do
5263         for cf_add_2lib in $cf_add_libs; do
5264                 if test "x$cf_add_1lib" = "x$cf_add_2lib"; then
5265                         cf_add_1lib=
5266                         break
5267                 fi
5268         done
5269         test -n "$cf_add_1lib" && cf_add_libs="$cf_add_1lib $cf_add_libs"
5270 done
5271 LIBS="$cf_add_libs"
5272
5273                 # even with config script, some packages use no-override for curses.h
5274
5275 echo "$as_me:5275: checking if we have identified curses headers" >&5
5276 echo $ECHO_N "checking if we have identified curses headers... $ECHO_C" >&6
5277 if test "${cf_cv_ncurses_header+set}" = set; then
5278   echo $ECHO_N "(cached) $ECHO_C" >&6
5279 else
5280
5281 cf_cv_ncurses_header=none
5282 for cf_header in \
5283         ncurses.h ncurses/ncurses.h \
5284         curses.h ncurses/curses.h
5285 do
5286 cat >"conftest.$ac_ext" <<_ACEOF
5287 #line 5287 "configure"
5288 #include "confdefs.h"
5289 #include <${cf_header}>
5290 int
5291 main (void)
5292 {
5293 initscr(); tgoto("?", 0,0)
5294   ;
5295   return 0;
5296 }
5297 _ACEOF
5298 rm -f "conftest.$ac_objext"
5299 if { (eval echo "$as_me:5299: \"$ac_compile\"") >&5
5300   (eval $ac_compile) 2>&5
5301   ac_status=$?
5302   echo "$as_me:5302: \$? = $ac_status" >&5
5303   (exit "$ac_status"); } &&
5304          { ac_try='test -s "conftest.$ac_objext"'
5305   { (eval echo "$as_me:5305: \"$ac_try\"") >&5
5306   (eval $ac_try) 2>&5
5307   ac_status=$?
5308   echo "$as_me:5308: \$? = $ac_status" >&5
5309   (exit "$ac_status"); }; }; then
5310   cf_cv_ncurses_header=$cf_header; break
5311 else
5312   echo "$as_me: failed program was:" >&5
5313 cat "conftest.$ac_ext" >&5
5314 fi
5315 rm -f "conftest.$ac_objext" "conftest.$ac_ext"
5316 done
5317
5318 fi
5319 echo "$as_me:5319: result: $cf_cv_ncurses_header" >&5
5320 echo "${ECHO_T}$cf_cv_ncurses_header" >&6
5321
5322 if test "$cf_cv_ncurses_header" = none ; then
5323         { { echo "$as_me:5323: error: No curses header-files found" >&5
5324 echo "$as_me: error: No curses header-files found" >&2;}
5325    { (exit 1); exit 1; }; }
5326 fi
5327
5328 # cheat, to get the right #define's for HAVE_NCURSES_H, etc.
5329
5330 for ac_header in $cf_cv_ncurses_header
5331 do
5332 as_ac_Header=`echo "ac_cv_header_$ac_header" | $as_tr_sh`
5333 echo "$as_me:5333: checking for $ac_header" >&5
5334 echo $ECHO_N "checking for $ac_header... $ECHO_C" >&6
5335 if eval "test \"\${$as_ac_Header+set}\" = set"; then
5336   echo $ECHO_N "(cached) $ECHO_C" >&6
5337 else
5338   cat >"conftest.$ac_ext" <<_ACEOF
5339 #line 5339 "configure"
5340 #include "confdefs.h"
5341 #include <$ac_header>
5342 _ACEOF
5343 if { (eval echo "$as_me:5343: \"$ac_cpp "conftest.$ac_ext"\"") >&5
5344   (eval $ac_cpp "conftest.$ac_ext") 2>conftest.er1
5345   ac_status=$?
5346   $EGREP -v '^ *\+' conftest.er1 >conftest.err
5347   rm -f conftest.er1
5348   cat conftest.err >&5
5349   echo "$as_me:5349: \$? = $ac_status" >&5
5350   (exit "$ac_status"); } >/dev/null; then
5351   if test -s conftest.err; then
5352     ac_cpp_err=$ac_c_preproc_warn_flag
5353   else
5354     ac_cpp_err=
5355   fi
5356 else
5357   ac_cpp_err=yes
5358 fi
5359 if test -z "$ac_cpp_err"; then
5360   eval "$as_ac_Header=yes"
5361 else
5362   echo "$as_me: failed program was:" >&5
5363   cat "conftest.$ac_ext" >&5
5364   eval "$as_ac_Header=no"
5365 fi
5366 rm -f conftest.err "conftest.$ac_ext"
5367 fi
5368 echo "$as_me:5368: result: `eval echo '${'"$as_ac_Header"'}'`" >&5
5369 echo "${ECHO_T}`eval echo '${'"$as_ac_Header"'}'`" >&6
5370 if test "`eval echo '${'"$as_ac_Header"'}'`" = yes; then
5371   cat >>confdefs.h <<EOF
5372 #define `echo "HAVE_$ac_header" | $as_tr_cpp` 1
5373 EOF
5374
5375 fi
5376 done
5377
5378 cat >>confdefs.h <<\EOF
5379 #define NCURSES 1
5380 EOF
5381
5382 cf_nculib_ROOT=`echo "HAVE_LIB$cf_ncuconfig_root" | sed y%abcdefghijklmnopqrstuvwxyz./-%ABCDEFGHIJKLMNOPQRSTUVWXYZ___%`
5383
5384                 cat >>confdefs.h <<EOF
5385 #define $cf_nculib_ROOT 1
5386 EOF
5387
5388                                 cf_cv_ncurses_version="`$NCURSES_CONFIG --version`"
5389
5390         else
5391
5392 cf_ncuhdr_root=ncurses
5393
5394 test -n "$cf_cv_curses_dir" && \
5395 test "$cf_cv_curses_dir" != "no" && { \
5396
5397 if test -n "$cf_cv_curses_dir/include/$cf_ncuhdr_root" ; then
5398   for cf_add_incdir in $cf_cv_curses_dir/include/$cf_ncuhdr_root
5399   do
5400         while test "$cf_add_incdir" != /usr/include
5401         do
5402           if test -d "$cf_add_incdir"
5403           then
5404                 cf_have_incdir=no
5405                 if test -n "$CFLAGS$CPPFLAGS" ; then
5406                   # a loop is needed to ensure we can add subdirs of existing dirs
5407                   for cf_test_incdir in $CFLAGS $CPPFLAGS ; do
5408                         if test ".$cf_test_incdir" = ".-I$cf_add_incdir" ; then
5409                           cf_have_incdir=yes; break
5410                         fi
5411                   done
5412                 fi
5413
5414                 if test "$cf_have_incdir" = no ; then
5415                   if test "$cf_add_incdir" = /usr/local/include ; then
5416                         if test "$GCC" = yes
5417                         then
5418                           cf_save_CPPFLAGS=$CPPFLAGS
5419
5420         test -n "$CPPFLAGS" && CPPFLAGS="$CPPFLAGS "
5421         CPPFLAGS="${CPPFLAGS}-I$cf_add_incdir"
5422
5423                           cat >"conftest.$ac_ext" <<_ACEOF
5424 #line 5424 "configure"
5425 #include "confdefs.h"
5426 #include <stdio.h>
5427 int
5428 main (void)
5429 {
5430 printf("Hello")
5431   ;
5432   return 0;
5433 }
5434 _ACEOF
5435 rm -f "conftest.$ac_objext"
5436 if { (eval echo "$as_me:5436: \"$ac_compile\"") >&5
5437   (eval $ac_compile) 2>&5
5438   ac_status=$?
5439   echo "$as_me:5439: \$? = $ac_status" >&5
5440   (exit "$ac_status"); } &&
5441          { ac_try='test -s "conftest.$ac_objext"'
5442   { (eval echo "$as_me:5442: \"$ac_try\"") >&5
5443   (eval $ac_try) 2>&5
5444   ac_status=$?
5445   echo "$as_me:5445: \$? = $ac_status" >&5
5446   (exit "$ac_status"); }; }; then
5447   :
5448 else
5449   echo "$as_me: failed program was:" >&5
5450 cat "conftest.$ac_ext" >&5
5451 cf_have_incdir=yes
5452 fi
5453 rm -f "conftest.$ac_objext" "conftest.$ac_ext"
5454                           CPPFLAGS=$cf_save_CPPFLAGS
5455                         fi
5456                   fi
5457                 fi
5458
5459                 if test "$cf_have_incdir" = no ; then
5460                   test -n "$verbose" && echo "  adding $cf_add_incdir to include-path" 1>&6
5461
5462 echo "${as_me:-configure}:5462: testing adding $cf_add_incdir to include-path ..." 1>&5
5463
5464                   CPPFLAGS="$CPPFLAGS -I$cf_add_incdir"
5465
5466                   cf_top_incdir=`echo "$cf_add_incdir" | sed -e 's%/include/.*$%/include%'`
5467                   test "$cf_top_incdir" = "$cf_add_incdir" && break
5468                   cf_add_incdir="$cf_top_incdir"
5469                 else
5470                   break
5471                 fi
5472           else