Ada95/configure

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