Ada95/aclocal.m4

   1 dnl***************************************************************************
   2 dnl Copyright (c) 2010 Free Software Foundation, Inc.                        *
   3 dnl                                                                          *
   4 dnl Permission is hereby granted, free of charge, to any person obtaining a  *
   5 dnl copy of this software and associated documentation files (the            *
   6 dnl "Software"), to deal in the Software without restriction, including      *
   7 dnl without limitation the rights to use, copy, modify, merge, publish,      *
   8 dnl distribute, distribute with modifications, sublicense, and/or sell       *
   9 dnl copies of the Software, and to permit persons to whom the Software is    *
  10 dnl furnished to do so, subject to the following conditions:                 *
  11 dnl                                                                          *
  12 dnl The above copyright notice and this permission notice shall be included  *
  13 dnl in all copies or substantial portions of the Software.                   *
  14 dnl                                                                          *
  15 dnl THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS  *
  16 dnl OR IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF               *
  17 dnl MERCHANTABILITY, FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT.   *
  18 dnl IN NO EVENT SHALL THE ABOVE COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM,   *
  19 dnl DAMAGES OR OTHER LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR    *
  20 dnl OTHERWISE, ARISING FROM, OUT OF OR IN CONNECTION WITH THE SOFTWARE OR    *
  21 dnl THE USE OR OTHER DEALINGS IN THE SOFTWARE.                               *
  22 dnl                                                                          *
  23 dnl Except as contained in this notice, the name(s) of the above copyright   *
  24 dnl holders shall not be used in advertising or otherwise to promote the     *
  25 dnl sale, use or other dealings in this Software without prior written       *
  26 dnl authorization.                                                           *
  27 dnl***************************************************************************
  28 dnl
  29 dnl Author: Thomas E. Dickey
  30 dnl
  31 dnl $Id: aclocal.m4,v 1.16 2010/09/04 21:41:53 tom Exp $
  32 dnl Macros used in NCURSES Ada95 auto-configuration script.
  33 dnl
  34 dnl These macros are maintained separately from NCURSES.  The copyright on
  35 dnl this file applies to the aggregation of macros and does not affect use of
  36 dnl these macros in other applications.
  37 dnl
  38 dnl See http://invisible-island.net/autoconf/ for additional information.
  39 dnl
  40 dnl ---------------------------------------------------------------------------
  41 dnl ---------------------------------------------------------------------------
  42 dnl CF_ADA_INCLUDE_DIRS version: 6 updated: 2010/02/26 19:52:07
  43 dnl -------------------
  44 dnl Construct the list of include-options for the C programs in the Ada95
  45 dnl binding.
  46 AC_DEFUN([CF_ADA_INCLUDE_DIRS],
  47 [
  48 ACPPFLAGS="-I. -I../include -I../../include $ACPPFLAGS"
  49 if test "$srcdir" != "."; then
  50         ACPPFLAGS="-I\${srcdir}/../../include $ACPPFLAGS"
  51 fi
  52 if test "$GCC" != yes; then
  53         ACPPFLAGS="$ACPPFLAGS -I\${includedir}"
  54 elif test "$includedir" != "/usr/include"; then
  55         if test "$includedir" = '${prefix}/include' ; then
  56                 if test $prefix != /usr ; then
  57                         ACPPFLAGS="$ACPPFLAGS -I\${includedir}"
  58                 fi
  59         else
  60                 ACPPFLAGS="$ACPPFLAGS -I\${includedir}"
  61         fi
  62 fi
  63 AC_SUBST(ACPPFLAGS)
  64 ])dnl
  65 dnl ---------------------------------------------------------------------------
  66 dnl CF_ADD_ADAFLAGS version: 1 updated: 2010/06/19 15:22:18
  67 dnl ---------------
  68 dnl Add to $ADAFLAGS, which is substituted into makefile and scripts.
  69 AC_DEFUN([CF_ADD_ADAFLAGS],[
  70         ADAFLAGS="$ADAFLAGS $1"
  71         AC_SUBST(ADAFLAGS)
  72 ])dnl
  73 dnl ---------------------------------------------------------------------------
  74 dnl CF_ADD_CFLAGS version: 10 updated: 2010/05/26 05:38:42
  75 dnl -------------
  76 dnl Copy non-preprocessor flags to $CFLAGS, preprocessor flags to $CPPFLAGS
  77 dnl The second parameter if given makes this macro verbose.
  78 dnl
  79 dnl Put any preprocessor definitions that use quoted strings in $EXTRA_CPPFLAGS,
  80 dnl to simplify use of $CPPFLAGS in compiler checks, etc., that are easily
  81 dnl confused by the quotes (which require backslashes to keep them usable).
  82 AC_DEFUN([CF_ADD_CFLAGS],
  83 [
  84 cf_fix_cppflags=no
  85 cf_new_cflags=
  86 cf_new_cppflags=
  87 cf_new_extra_cppflags=
  88
  89 for cf_add_cflags in $1
  90 do
  91 case $cf_fix_cppflags in
  92 no)
  93         case $cf_add_cflags in #(vi
  94         -undef|-nostdinc*|-I*|-D*|-U*|-E|-P|-C) #(vi
  95                 case $cf_add_cflags in
  96                 -D*)
  97                         cf_tst_cflags=`echo ${cf_add_cflags} |sed -e 's/^-D[[^=]]*='\''\"[[^"]]*//'`
  98
  99                         test "${cf_add_cflags}" != "${cf_tst_cflags}" \
 100                                 && test -z "${cf_tst_cflags}" \
 101                                 && cf_fix_cppflags=yes
 102
 103                         if test $cf_fix_cppflags = yes ; then
 104                                 cf_new_extra_cppflags="$cf_new_extra_cppflags $cf_add_cflags"
 105                                 continue
 106                         elif test "${cf_tst_cflags}" = "\"'" ; then
 107                                 cf_new_extra_cppflags="$cf_new_extra_cppflags $cf_add_cflags"
 108                                 continue
 109                         fi
 110                         ;;
 111                 esac
 112                 case "$CPPFLAGS" in
 113                 *$cf_add_cflags) #(vi
 114                         ;;
 115                 *) #(vi
 116                         case $cf_add_cflags in #(vi
 117                         -D*)
 118                                 cf_tst_cppflags=`echo "x$cf_add_cflags" | sed -e 's/^...//' -e 's/=.*//'`
 119                                 CF_REMOVE_DEFINE(CPPFLAGS,$CPPFLAGS,$cf_tst_cppflags)
 120                                 ;;
 121                         esac
 122                         cf_new_cppflags="$cf_new_cppflags $cf_add_cflags"
 123                         ;;
 124                 esac
 125                 ;;
 126         *)
 127                 cf_new_cflags="$cf_new_cflags $cf_add_cflags"
 128                 ;;
 129         esac
 130         ;;
 131 yes)
 132         cf_new_extra_cppflags="$cf_new_extra_cppflags $cf_add_cflags"
 133
 134         cf_tst_cflags=`echo ${cf_add_cflags} |sed -e 's/^[[^"]]*"'\''//'`
 135
 136         test "${cf_add_cflags}" != "${cf_tst_cflags}" \
 137                 && test -z "${cf_tst_cflags}" \
 138                 && cf_fix_cppflags=no
 139         ;;
 140 esac
 141 done
 142
 143 if test -n "$cf_new_cflags" ; then
 144         ifelse([$2],,,[CF_VERBOSE(add to \$CFLAGS $cf_new_cflags)])
 145         CFLAGS="$CFLAGS $cf_new_cflags"
 146 fi
 147
 148 if test -n "$cf_new_cppflags" ; then
 149         ifelse([$2],,,[CF_VERBOSE(add to \$CPPFLAGS $cf_new_cppflags)])
 150         CPPFLAGS="$CPPFLAGS $cf_new_cppflags"
 151 fi
 152
 153 if test -n "$cf_new_extra_cppflags" ; then
 154         ifelse([$2],,,[CF_VERBOSE(add to \$EXTRA_CPPFLAGS $cf_new_extra_cppflags)])
 155         EXTRA_CPPFLAGS="$cf_new_extra_cppflags $EXTRA_CPPFLAGS"
 156 fi
 157
 158 AC_SUBST(EXTRA_CPPFLAGS)
 159
 160 ])dnl
 161 dnl ---------------------------------------------------------------------------
 162 dnl CF_ADD_INCDIR version: 13 updated: 2010/05/26 16:44:57
 163 dnl -------------
 164 dnl Add an include-directory to $CPPFLAGS.  Don't add /usr/include, since it's
 165 dnl redundant.  We don't normally need to add -I/usr/local/include for gcc,
 166 dnl but old versions (and some misinstalled ones) need that.  To make things
 167 dnl worse, gcc 3.x may give error messages if -I/usr/local/include is added to
 168 dnl the include-path).
 169 AC_DEFUN([CF_ADD_INCDIR],
 170 [
 171 if test -n "$1" ; then
 172   for cf_add_incdir in $1
 173   do
 174         while test $cf_add_incdir != /usr/include
 175         do
 176           if test -d $cf_add_incdir
 177           then
 178                 cf_have_incdir=no
 179                 if test -n "$CFLAGS$CPPFLAGS" ; then
 180                   # a loop is needed to ensure we can add subdirs of existing dirs
 181                   for cf_test_incdir in $CFLAGS $CPPFLAGS ; do
 182                         if test ".$cf_test_incdir" = ".-I$cf_add_incdir" ; then
 183                           cf_have_incdir=yes; break
 184                         fi
 185                   done
 186                 fi
 187
 188                 if test "$cf_have_incdir" = no ; then
 189                   if test "$cf_add_incdir" = /usr/local/include ; then
 190                         if test "$GCC" = yes
 191                         then
 192                           cf_save_CPPFLAGS=$CPPFLAGS
 193                           CPPFLAGS="$CPPFLAGS -I$cf_add_incdir"
 194                           AC_TRY_COMPILE([#include <stdio.h>],
 195                                   [printf("Hello")],
 196                                   [],
 197                                   [cf_have_incdir=yes])
 198                           CPPFLAGS=$cf_save_CPPFLAGS
 199                         fi
 200                   fi
 201                 fi
 202
 203                 if test "$cf_have_incdir" = no ; then
 204                   CF_VERBOSE(adding $cf_add_incdir to include-path)
 205                   ifelse([$2],,CPPFLAGS,[$2])="$ifelse([$2],,CPPFLAGS,[$2]) -I$cf_add_incdir"
 206
 207                   cf_top_incdir=`echo $cf_add_incdir | sed -e 's%/include/.*$%/include%'`
 208                   test "$cf_top_incdir" = "$cf_add_incdir" && break
 209                   cf_add_incdir="$cf_top_incdir"
 210                 else
 211                   break
 212                 fi
 213           fi
 214         done
 215   done
 216 fi
 217 ])dnl
 218 dnl ---------------------------------------------------------------------------
 219 dnl CF_ADD_LIB version: 2 updated: 2010/06/02 05:03:05
 220 dnl ----------
 221 dnl Add a library, used to enforce consistency.
 222 dnl
 223 dnl $1 = library to add, without the "-l"
 224 dnl $2 = variable to update (default $LIBS)
 225 AC_DEFUN([CF_ADD_LIB],[CF_ADD_LIBS(-l$1,ifelse($2,,LIBS,[$2]))])dnl
 226 dnl ---------------------------------------------------------------------------
 227 dnl CF_ADD_LIBDIR version: 9 updated: 2010/05/26 16:44:57
 228 dnl -------------
 229 dnl     Adds to the library-path
 230 dnl
 231 dnl     Some machines have trouble with multiple -L options.
 232 dnl
 233 dnl $1 is the (list of) directory(s) to add
 234 dnl $2 is the optional name of the variable to update (default LDFLAGS)
 235 dnl
 236 AC_DEFUN([CF_ADD_LIBDIR],
 237 [
 238 if test -n "$1" ; then
 239   for cf_add_libdir in $1
 240   do
 241     if test $cf_add_libdir = /usr/lib ; then
 242       :
 243     elif test -d $cf_add_libdir
 244     then
 245       cf_have_libdir=no
 246       if test -n "$LDFLAGS$LIBS" ; then
 247         # a loop is needed to ensure we can add subdirs of existing dirs
 248         for cf_test_libdir in $LDFLAGS $LIBS ; do
 249           if test ".$cf_test_libdir" = ".-L$cf_add_libdir" ; then
 250             cf_have_libdir=yes; break
 251           fi
 252         done
 253       fi
 254       if test "$cf_have_libdir" = no ; then
 255         CF_VERBOSE(adding $cf_add_libdir to library-path)
 256         ifelse([$2],,LDFLAGS,[$2])="-L$cf_add_libdir $ifelse([$2],,LDFLAGS,[$2])"
 257       fi
 258     fi
 259   done
 260 fi
 261 ])dnl
 262 dnl ---------------------------------------------------------------------------
 263 dnl CF_ADD_LIBS version: 1 updated: 2010/06/02 05:03:05
 264 dnl -----------
 265 dnl Add one or more libraries, used to enforce consistency.
 266 dnl
 267 dnl $1 = libraries to add, with the "-l", etc.
 268 dnl $2 = variable to update (default $LIBS)
 269 AC_DEFUN([CF_ADD_LIBS],[ifelse($2,,LIBS,[$2])="$1 [$]ifelse($2,,LIBS,[$2])"])dnl
 270 dnl ---------------------------------------------------------------------------
 271 dnl CF_ADD_SUBDIR_PATH version: 3 updated: 2010/07/03 20:58:12
 272 dnl ------------------
 273 dnl Append to a search-list for a nonstandard header/lib-file
 274 dnl     $1 = the variable to return as result
 275 dnl     $2 = the package name
 276 dnl     $3 = the subdirectory, e.g., bin, include or lib
 277 dnl $4 = the directory under which we will test for subdirectories
 278 dnl $5 = a directory that we do not want $4 to match
 279 AC_DEFUN([CF_ADD_SUBDIR_PATH],
 280 [
 281 test "$4" != "$5" && \
 282 test -d "$4" && \
 283 ifelse([$5],NONE,,[(test $5 = NONE || test "$4" != "$5") &&]) {
 284         test -n "$verbose" && echo "    ... testing for $3-directories under $4"
 285         test -d $4/$3 &&          $1="[$]$1 $4/$3"
 286         test -d $4/$3/$2 &&       $1="[$]$1 $4/$3/$2"
 287         test -d $4/$3/$2/$3 &&    $1="[$]$1 $4/$3/$2/$3"
 288         test -d $4/$2/$3 &&       $1="[$]$1 $4/$2/$3"
 289         test -d $4/$2/$3/$2 &&    $1="[$]$1 $4/$2/$3/$2"
 290 }
 291 ])dnl
 292 dnl ---------------------------------------------------------------------------
 293 dnl CF_ANSI_CC_CHECK version: 9 updated: 2001/12/30 17:53:34
 294 dnl ----------------
 295 dnl This is adapted from the macros 'fp_PROG_CC_STDC' and 'fp_C_PROTOTYPES'
 296 dnl in the sharutils 4.2 distribution.
 297 AC_DEFUN([CF_ANSI_CC_CHECK],
 298 [
 299 AC_CACHE_CHECK(for ${CC-cc} option to accept ANSI C, cf_cv_ansi_cc,[
 300 cf_cv_ansi_cc=no
 301 cf_save_CFLAGS="$CFLAGS"
 302 cf_save_CPPFLAGS="$CPPFLAGS"
 303 # Don't try gcc -ansi; that turns off useful extensions and
 304 # breaks some systems' header files.
 305 # AIX                   -qlanglvl=ansi
 306 # Ultrix and OSF/1      -std1
 307 # HP-UX                 -Aa -D_HPUX_SOURCE
 308 # SVR4                  -Xc
 309 # UnixWare 1.2          (cannot use -Xc, since ANSI/POSIX clashes)
 310 for cf_arg in "-DCC_HAS_PROTOS" \
 311         "" \
 312         -qlanglvl=ansi \
 313         -std1 \
 314         -Ae \
 315         "-Aa -D_HPUX_SOURCE" \
 316         -Xc
 317 do
 318         CF_ADD_CFLAGS($cf_arg)
 319         AC_TRY_COMPILE(
 320 [
 321 #ifndef CC_HAS_PROTOS
 322 #if !defined(__STDC__) || (__STDC__ != 1)
 323 choke me
 324 #endif
 325 #endif
 326 ],[
 327         int test (int i, double x);
 328         struct s1 {int (*f) (int a);};
 329         struct s2 {int (*f) (double a);};],
 330         [cf_cv_ansi_cc="$cf_arg"; break])
 331 done
 332 CFLAGS="$cf_save_CFLAGS"
 333 CPPFLAGS="$cf_save_CPPFLAGS"
 334 ])
 335
 336 if test "$cf_cv_ansi_cc" != "no"; then
 337 if test ".$cf_cv_ansi_cc" != ".-DCC_HAS_PROTOS"; then
 338         CF_ADD_CFLAGS($cf_cv_ansi_cc)
 339 else
 340         AC_DEFINE(CC_HAS_PROTOS)
 341 fi
 342 fi
 343 ])dnl
 344 dnl ---------------------------------------------------------------------------
 345 dnl CF_ANSI_CC_REQD version: 4 updated: 2008/03/23 14:48:54
 346 dnl ---------------
 347 dnl For programs that must use an ANSI compiler, obtain compiler options that
 348 dnl will make it recognize prototypes.  We'll do preprocessor checks in other
 349 dnl macros, since tools such as unproto can fake prototypes, but only part of
 350 dnl the preprocessor.
 351 AC_DEFUN([CF_ANSI_CC_REQD],
 352 [AC_REQUIRE([CF_ANSI_CC_CHECK])
 353 if test "$cf_cv_ansi_cc" = "no"; then
 354         AC_MSG_ERROR(
 355 [Your compiler does not appear to recognize prototypes.
 356 You have the following choices:
 357         a. adjust your compiler options
 358         b. get an up-to-date compiler
 359         c. use a wrapper such as unproto])
 360 fi
 361 ])dnl
 362 dnl ---------------------------------------------------------------------------
 363 dnl CF_AR_FLAGS version: 5 updated: 2010/05/20 20:24:29
 364 dnl -----------
 365 dnl Check for suitable "ar" (archiver) options for updating an archive.
 366 AC_DEFUN([CF_AR_FLAGS],[
 367 AC_REQUIRE([CF_PROG_AR])
 368
 369 AC_CACHE_CHECK(for options to update archives, cf_cv_ar_flags,[
 370         cf_cv_ar_flags=unknown
 371         for cf_ar_flags in -curv curv -crv crv -cqv cqv -rv rv
 372         do
 373
 374                 # check if $ARFLAGS already contains this choice
 375                 if test "x$ARFLAGS" != "x" ; then
 376                         cf_check_ar_flags=`echo "x$ARFLAGS" | sed -e "s/$cf_ar_flags\$//" -e "s/$cf_ar_flags / /"`
 377                         if test "x$ARFLAGS" != "$cf_check_ar_flags" ; then
 378                                 cf_cv_ar_flags=
 379                                 break
 380                         fi
 381                 fi
 382
 383                 rm -f conftest.$ac_cv_objext
 384                 rm -f conftest.a
 385
 386                 cat >conftest.$ac_ext <<EOF
 387 #line __oline__ "configure"
 388 int     testdata[[3]] = { 123, 456, 789 };
 389 EOF
 390                 if AC_TRY_EVAL(ac_compile) ; then
 391                         echo "$AR $ARFLAGS $cf_ar_flags conftest.a conftest.$ac_cv_objext" >&AC_FD_CC
 392                         $AR $ARFLAGS $cf_ar_flags conftest.a conftest.$ac_cv_objext 2>&AC_FD_CC 1>/dev/null
 393                         if test -f conftest.a ; then
 394                                 cf_cv_ar_flags=$cf_ar_flags
 395                                 break
 396                         fi
 397                 else
 398                         CF_VERBOSE(cannot compile test-program)
 399                         break
 400                 fi
 401         done
 402         rm -f conftest.a conftest.$ac_ext conftest.$ac_cv_objext
 403 ])
 404
 405 if test -n "$ARFLAGS" ; then
 406         if test -n "$cf_cv_ar_flags" ; then
 407                 ARFLAGS="$ARFLAGS $cf_cv_ar_flags"
 408         fi
 409 else
 410         ARFLAGS=$cf_cv_ar_flags
 411 fi
 412
 413 AC_SUBST(ARFLAGS)
 414 ])
 415 dnl ---------------------------------------------------------------------------
 416 dnl CF_BUILD_CC version: 6 updated: 2006/10/14 15:23:15
 417 dnl -----------
 418 dnl If we're cross-compiling, allow the user to override the tools and their
 419 dnl options.  The configure script is oriented toward identifying the host
 420 dnl compiler, etc., but we need a build compiler to generate parts of the
 421 dnl source.
 422 dnl
 423 dnl $1 = default for $CPPFLAGS
 424 dnl $2 = default for $LIBS
 425 AC_DEFUN([CF_BUILD_CC],[
 426 AC_REQUIRE([CF_PROG_EXT])
 427 if test "$cross_compiling" = yes ; then
 428
 429         # defaults that we might want to override
 430         : ${BUILD_CFLAGS:=''}
 431         : ${BUILD_CPPFLAGS:='ifelse([$1],,,[$1])'}
 432         : ${BUILD_LDFLAGS:=''}
 433         : ${BUILD_LIBS:='ifelse([$2],,,[$2])'}
 434         : ${BUILD_EXEEXT:='$x'}
 435         : ${BUILD_OBJEXT:='o'}
 436
 437         AC_ARG_WITH(build-cc,
 438                 [  --with-build-cc=XXX     the build C compiler ($BUILD_CC)],
 439                 [BUILD_CC="$withval"],
 440                 [AC_CHECK_PROGS(BUILD_CC, gcc cc cl)])
 441         AC_MSG_CHECKING(for native build C compiler)
 442         AC_MSG_RESULT($BUILD_CC)
 443
 444         AC_MSG_CHECKING(for native build C preprocessor)
 445         AC_ARG_WITH(build-cpp,
 446                 [  --with-build-cpp=XXX    the build C preprocessor ($BUILD_CPP)],
 447                 [BUILD_CPP="$withval"],
 448                 [BUILD_CPP='${BUILD_CC} -E'])
 449         AC_MSG_RESULT($BUILD_CPP)
 450
 451         AC_MSG_CHECKING(for native build C flags)
 452         AC_ARG_WITH(build-cflags,
 453                 [  --with-build-cflags=XXX the build C compiler-flags ($BUILD_CFLAGS)],
 454                 [BUILD_CFLAGS="$withval"])
 455         AC_MSG_RESULT($BUILD_CFLAGS)
 456
 457         AC_MSG_CHECKING(for native build C preprocessor-flags)
 458         AC_ARG_WITH(build-cppflags,
 459                 [  --with-build-cppflags=XXX the build C preprocessor-flags ($BUILD_CPPFLAGS)],
 460                 [BUILD_CPPFLAGS="$withval"])
 461         AC_MSG_RESULT($BUILD_CPPFLAGS)
 462
 463         AC_MSG_CHECKING(for native build linker-flags)
 464         AC_ARG_WITH(build-ldflags,
 465                 [  --with-build-ldflags=XXX the build linker-flags ($BUILD_LDFLAGS)],
 466                 [BUILD_LDFLAGS="$withval"])
 467         AC_MSG_RESULT($BUILD_LDFLAGS)
 468
 469         AC_MSG_CHECKING(for native build linker-libraries)
 470         AC_ARG_WITH(build-libs,
 471                 [  --with-build-libs=XXX   the build libraries (${BUILD_LIBS})],
 472                 [BUILD_LIBS="$withval"])
 473         AC_MSG_RESULT($BUILD_LIBS)
 474
 475         # this assumes we're on Unix.
 476         BUILD_EXEEXT=
 477         BUILD_OBJEXT=o
 478
 479         : ${BUILD_CC:='${CC}'}
 480
 481         if ( test "$BUILD_CC" = "$CC" || test "$BUILD_CC" = '${CC}' ) ; then
 482                 AC_MSG_ERROR([Cross-build requires two compilers.
 483 Use --with-build-cc to specify the native compiler.])
 484         fi
 485
 486 else
 487         : ${BUILD_CC:='${CC}'}
 488         : ${BUILD_CPP:='${CPP}'}
 489         : ${BUILD_CFLAGS:='${CFLAGS}'}
 490         : ${BUILD_CPPFLAGS:='${CPPFLAGS}'}
 491         : ${BUILD_LDFLAGS:='${LDFLAGS}'}
 492         : ${BUILD_LIBS:='${LIBS}'}
 493         : ${BUILD_EXEEXT:='$x'}
 494         : ${BUILD_OBJEXT:='o'}
 495 fi
 496
 497 AC_SUBST(BUILD_CC)
 498 AC_SUBST(BUILD_CPP)
 499 AC_SUBST(BUILD_CFLAGS)
 500 AC_SUBST(BUILD_CPPFLAGS)
 501 AC_SUBST(BUILD_LDFLAGS)
 502 AC_SUBST(BUILD_LIBS)
 503 AC_SUBST(BUILD_EXEEXT)
 504 AC_SUBST(BUILD_OBJEXT)
 505 ])dnl
 506 dnl ---------------------------------------------------------------------------
 507 dnl CF_CFG_DEFAULTS version: 7 updated: 2005/09/24 16:15:00
 508 dnl ---------------
 509 dnl Determine the default configuration into which we'll install ncurses.  This
 510 dnl can be overridden by the user's command-line options.  There's two items to
 511 dnl look for:
 512 dnl     1. the prefix (e.g., /usr)
 513 dnl     2. the header files (e.g., /usr/include/ncurses)
 514 dnl We'll look for a previous installation of ncurses and use the same defaults.
 515 dnl
 516 dnl We don't use AC_PREFIX_DEFAULT, because it gets evaluated too soon, and
 517 dnl we don't use AC_PREFIX_PROGRAM, because we cannot distinguish ncurses's
 518 dnl programs from a vendor's.
 519 AC_DEFUN([CF_CFG_DEFAULTS],
 520 [
 521 AC_MSG_CHECKING(for prefix)
 522 if test "x$prefix" = "xNONE" ; then
 523         case "$cf_cv_system_name" in
 524                 # non-vendor systems don't have a conflict
 525         openbsd*|freebsd*|linux*|cygwin*|k*bsd*-gnu)
 526                 prefix=/usr
 527                 ;;
 528         *)      prefix=$ac_default_prefix
 529                 ;;
 530         esac
 531 fi
 532 AC_MSG_RESULT($prefix)
 533
 534 if test "x$prefix" = "xNONE" ; then
 535 AC_MSG_CHECKING(for default include-directory)
 536 test -n "$verbose" && echo 1>&AC_FD_MSG
 537 for cf_symbol in \
 538         $includedir \
 539         $includedir/ncurses \
 540         $prefix/include \
 541         $prefix/include/ncurses \
 542         /usr/local/include \
 543         /usr/local/include/ncurses \
 544         /usr/include \
 545         /usr/include/ncurses
 546 do
 547         cf_dir=`eval echo $cf_symbol`
 548         if test -f $cf_dir/curses.h ; then
 549         if ( fgrep NCURSES_VERSION $cf_dir/curses.h 2>&1 >/dev/null ) ; then
 550                 includedir="$cf_symbol"
 551                 test -n "$verbose"  && echo $ac_n "     found " 1>&AC_FD_MSG
 552                 break
 553         fi
 554         fi
 555         test -n "$verbose"  && echo "   tested $cf_dir" 1>&AC_FD_MSG
 556 done
 557 AC_MSG_RESULT($includedir)
 558 fi
 559 ])dnl
 560 dnl ---------------------------------------------------------------------------
 561 dnl CF_CHECK_CACHE version: 11 updated: 2008/03/23 14:45:59
 562 dnl --------------
 563 dnl Check if we're accidentally using a cache from a different machine.
 564 dnl Derive the system name, as a check for reusing the autoconf cache.
 565 dnl
 566 dnl If we've packaged config.guess and config.sub, run that (since it does a
 567 dnl better job than uname).  Normally we'll use AC_CANONICAL_HOST, but allow
 568 dnl an extra parameter that we may override, e.g., for AC_CANONICAL_SYSTEM
 569 dnl which is useful in cross-compiles.
 570 dnl
 571 dnl Note: we would use $ac_config_sub, but that is one of the places where
 572 dnl autoconf 2.5x broke compatibility with autoconf 2.13
 573 AC_DEFUN([CF_CHECK_CACHE],
 574 [
 575 if test -f $srcdir/config.guess || test -f $ac_aux_dir/config.guess ; then
 576         ifelse([$1],,[AC_CANONICAL_HOST],[$1])
 577         system_name="$host_os"
 578 else
 579         system_name="`(uname -s -r) 2>/dev/null`"
 580         if test -z "$system_name" ; then
 581                 system_name="`(hostname) 2>/dev/null`"
 582         fi
 583 fi
 584 test -n "$system_name" && AC_DEFINE_UNQUOTED(SYSTEM_NAME,"$system_name")
 585 AC_CACHE_VAL(cf_cv_system_name,[cf_cv_system_name="$system_name"])
 586
 587 test -z "$system_name" && system_name="$cf_cv_system_name"
 588 test -n "$cf_cv_system_name" && AC_MSG_RESULT(Configuring for $cf_cv_system_name)
 589
 590 if test ".$system_name" != ".$cf_cv_system_name" ; then
 591         AC_MSG_RESULT(Cached system name ($system_name) does not agree with actual ($cf_cv_system_name))
 592         AC_MSG_ERROR("Please remove config.cache and try again.")
 593 fi
 594 ])dnl
 595 dnl ---------------------------------------------------------------------------
 596 dnl CF_CURSES_HEADER version: 2 updated: 2010/04/28 06:02:16
 597 dnl ----------------
 598 dnl Find a "curses" header file, e.g,. "curses.h", or one of the more common
 599 dnl variations of ncurses' installs.
 600 dnl
 601 dnl $1 = ncurses when looking for ncurses, or is empty
 602 AC_DEFUN([CF_CURSES_HEADER],[
 603 AC_CACHE_CHECK(if we have identified curses headers,cf_cv_ncurses_header,[
 604 cf_cv_ncurses_header=none
 605 for cf_header in ifelse($1,,,[ \
 606     $1/curses.h \
 607         $1/ncurses.h]) \
 608         curses.h \
 609         ncurses.h ifelse($1,,[ncurses/curses.h ncurses/ncurses.h])
 610 do
 611 AC_TRY_COMPILE([#include <${cf_header}>],
 612         [initscr(); tgoto("?", 0,0)],
 613         [cf_cv_ncurses_header=$cf_header; break],[])
 614 done
 615 ])
 616
 617 if test "$cf_cv_ncurses_header" = none ; then
 618         AC_MSG_ERROR(No curses header-files found)
 619 fi
 620
 621 # cheat, to get the right #define's for HAVE_NCURSES_H, etc.
 622 AC_CHECK_HEADERS($cf_cv_ncurses_header)
 623 ])dnl
 624 dnl ---------------------------------------------------------------------------
 625 dnl CF_DIRNAME version: 4 updated: 2002/12/21 19:25:52
 626 dnl ----------
 627 dnl "dirname" is not portable, so we fake it with a shell script.
 628 AC_DEFUN([CF_DIRNAME],[$1=`echo $2 | sed -e 's%/[[^/]]*$%%'`])dnl
 629 dnl ---------------------------------------------------------------------------
 630 dnl CF_FIND_LIBRARY version: 9 updated: 2008/03/23 14:48:54
 631 dnl ---------------
 632 dnl Look for a non-standard library, given parameters for AC_TRY_LINK.  We
 633 dnl prefer a standard location, and use -L options only if we do not find the
 634 dnl library in the standard library location(s).
 635 dnl     $1 = library name
 636 dnl     $2 = library class, usually the same as library name
 637 dnl     $3 = includes
 638 dnl     $4 = code fragment to compile/link
 639 dnl     $5 = corresponding function-name
 640 dnl     $6 = flag, nonnull if failure should not cause an error-exit
 641 dnl
 642 dnl Sets the variable "$cf_libdir" as a side-effect, so we can see if we had
 643 dnl to use a -L option.
 644 AC_DEFUN([CF_FIND_LIBRARY],
 645 [
 646         eval 'cf_cv_have_lib_'$1'=no'
 647         cf_libdir=""
 648         AC_CHECK_FUNC($5,
 649                 eval 'cf_cv_have_lib_'$1'=yes',[
 650                 cf_save_LIBS="$LIBS"
 651                 AC_MSG_CHECKING(for $5 in -l$1)
 652                 LIBS="-l$1 $LIBS"
 653                 AC_TRY_LINK([$3],[$4],
 654                         [AC_MSG_RESULT(yes)
 655                          eval 'cf_cv_have_lib_'$1'=yes'
 656                         ],
 657                         [AC_MSG_RESULT(no)
 658                         CF_LIBRARY_PATH(cf_search,$2)
 659                         for cf_libdir in $cf_search
 660                         do
 661                                 AC_MSG_CHECKING(for -l$1 in $cf_libdir)
 662                                 LIBS="-L$cf_libdir -l$1 $cf_save_LIBS"
 663                                 AC_TRY_LINK([$3],[$4],
 664                                         [AC_MSG_RESULT(yes)
 665                                          eval 'cf_cv_have_lib_'$1'=yes'
 666                                          break],
 667                                         [AC_MSG_RESULT(no)
 668                                          LIBS="$cf_save_LIBS"])
 669                         done
 670                         ])
 671                 ])
 672 eval 'cf_found_library=[$]cf_cv_have_lib_'$1
 673 ifelse($6,,[
 674 if test $cf_found_library = no ; then
 675         AC_MSG_ERROR(Cannot link $1 library)
 676 fi
 677 ])
 678 ])dnl
 679 dnl ---------------------------------------------------------------------------
 680 dnl CF_FIND_LINKAGE version: 19 updated: 2010/05/29 16:31:02
 681 dnl ---------------
 682 dnl Find a library (specifically the linkage used in the code fragment),
 683 dnl searching for it if it is not already in the library path.
 684 dnl See also CF_ADD_SEARCHPATH.
 685 dnl
 686 dnl Parameters (4-on are optional):
 687 dnl     $1 = headers for library entrypoint
 688 dnl     $2 = code fragment for library entrypoint
 689 dnl     $3 = the library name without the "-l" option or ".so" suffix.
 690 dnl     $4 = action to perform if successful (default: update CPPFLAGS, etc)
 691 dnl     $5 = action to perform if not successful
 692 dnl     $6 = module name, if not the same as the library name
 693 dnl     $7 = extra libraries
 694 dnl
 695 dnl Sets these variables:
 696 dnl     $cf_cv_find_linkage_$3 - yes/no according to whether linkage is found
 697 dnl     $cf_cv_header_path_$3 - include-directory if needed
 698 dnl     $cf_cv_library_path_$3 - library-directory if needed
 699 dnl     $cf_cv_library_file_$3 - library-file if needed, e.g., -l$3
 700 AC_DEFUN([CF_FIND_LINKAGE],[
 701
 702 # If the linkage is not already in the $CPPFLAGS/$LDFLAGS configuration, these
 703 # will be set on completion of the AC_TRY_LINK below.
 704 cf_cv_header_path_$3=
 705 cf_cv_library_path_$3=
 706
 707 CF_MSG_LOG([Starting [FIND_LINKAGE]($3,$6)])
 708
 709 cf_save_LIBS="$LIBS"
 710
 711 AC_TRY_LINK([$1],[$2],[
 712         cf_cv_find_linkage_$3=yes
 713         cf_cv_header_path_$3=/usr/include
 714         cf_cv_library_path_$3=/usr/lib
 715 ],[
 716
 717 LIBS="-l$3 $7 $cf_save_LIBS"
 718
 719 AC_TRY_LINK([$1],[$2],[
 720         cf_cv_find_linkage_$3=yes
 721         cf_cv_header_path_$3=/usr/include
 722         cf_cv_library_path_$3=/usr/lib
 723         cf_cv_library_file_$3="-l$3"
 724 ],[
 725         cf_cv_find_linkage_$3=no
 726         LIBS="$cf_save_LIBS"
 727
 728     CF_VERBOSE(find linkage for $3 library)
 729     CF_MSG_LOG([Searching for headers in [FIND_LINKAGE]($3,$6)])
 730
 731     cf_save_CPPFLAGS="$CPPFLAGS"
 732     cf_test_CPPFLAGS="$CPPFLAGS"
 733
 734     CF_HEADER_PATH(cf_search,ifelse([$6],,[$3],[$6]))
 735     for cf_cv_header_path_$3 in $cf_search
 736     do
 737       if test -d $cf_cv_header_path_$3 ; then
 738         CF_VERBOSE(... testing $cf_cv_header_path_$3)
 739         CPPFLAGS="$cf_save_CPPFLAGS -I$cf_cv_header_path_$3"
 740         AC_TRY_COMPILE([$1],[$2],[
 741             CF_VERBOSE(... found $3 headers in $cf_cv_header_path_$3)
 742             cf_cv_find_linkage_$3=maybe
 743             cf_test_CPPFLAGS="$CPPFLAGS"
 744             break],[
 745             CPPFLAGS="$cf_save_CPPFLAGS"
 746             ])
 747       fi
 748     done
 749
 750     if test "$cf_cv_find_linkage_$3" = maybe ; then
 751
 752       CF_MSG_LOG([Searching for $3 library in [FIND_LINKAGE]($3,$6)])
 753
 754       cf_save_LIBS="$LIBS"
 755       cf_save_LDFLAGS="$LDFLAGS"
 756
 757       ifelse([$6],,,[
 758         CPPFLAGS="$cf_test_CPPFLAGS"
 759         LIBS="-l$3 $7 $cf_save_LIBS"
 760         AC_TRY_LINK([$1],[$2],[
 761             CF_VERBOSE(... found $3 library in system)
 762             cf_cv_find_linkage_$3=yes])
 763             CPPFLAGS="$cf_save_CPPFLAGS"
 764             LIBS="$cf_save_LIBS"
 765             ])
 766
 767       if test "$cf_cv_find_linkage_$3" != yes ; then
 768         CF_LIBRARY_PATH(cf_search,$3)
 769         for cf_cv_library_path_$3 in $cf_search
 770         do
 771           if test -d $cf_cv_library_path_$3 ; then
 772             CF_VERBOSE(... testing $cf_cv_library_path_$3)
 773             CPPFLAGS="$cf_test_CPPFLAGS"
 774             LIBS="-l$3 $7 $cf_save_LIBS"
 775             LDFLAGS="$cf_save_LDFLAGS -L$cf_cv_library_path_$3"
 776             AC_TRY_LINK([$1],[$2],[
 777                 CF_VERBOSE(... found $3 library in $cf_cv_library_path_$3)
 778                 cf_cv_find_linkage_$3=yes
 779                 cf_cv_library_file_$3="-l$3"
 780                 break],[
 781                 CPPFLAGS="$cf_save_CPPFLAGS"
 782                 LIBS="$cf_save_LIBS"
 783                 LDFLAGS="$cf_save_LDFLAGS"
 784                 ])
 785           fi
 786         done
 787         CPPFLAGS="$cf_save_CPPFLAGS"
 788         LDFLAGS="$cf_save_LDFLAGS"
 789       fi
 790
 791     else
 792       cf_cv_find_linkage_$3=no
 793     fi
 794     ],$7)
 795 ])
 796
 797 LIBS="$cf_save_LIBS"
 798
 799 if test "$cf_cv_find_linkage_$3" = yes ; then
 800 ifelse([$4],,[
 801         CF_ADD_INCDIR($cf_cv_header_path_$3)
 802         CF_ADD_LIBDIR($cf_cv_library_path_$3)
 803         CF_ADD_LIB($3)
 804 ],[$4])
 805 else
 806 ifelse([$5],,AC_MSG_WARN(Cannot find $3 library),[$5])
 807 fi
 808 ])dnl
 809 dnl ---------------------------------------------------------------------------
 810 dnl CF_GCC_ATTRIBUTES version: 13 updated: 2009/08/11 20:19:56
 811 dnl -----------------
 812 dnl Test for availability of useful gcc __attribute__ directives to quiet
 813 dnl compiler warnings.  Though useful, not all are supported -- and contrary
 814 dnl to documentation, unrecognized directives cause older compilers to barf.
 815 AC_DEFUN([CF_GCC_ATTRIBUTES],
 816 [
 817 if test "$GCC" = yes
 818 then
 819 cat > conftest.i <<EOF
 820 #ifndef GCC_PRINTF
 821 #define GCC_PRINTF 0
 822 #endif
 823 #ifndef GCC_SCANF
 824 #define GCC_SCANF 0
 825 #endif
 826 #ifndef GCC_NORETURN
 827 #define GCC_NORETURN /* nothing */
 828 #endif
 829 #ifndef GCC_UNUSED
 830 #define GCC_UNUSED /* nothing */
 831 #endif
 832 EOF
 833 if test "$GCC" = yes
 834 then
 835         AC_CHECKING([for $CC __attribute__ directives])
 836 cat > conftest.$ac_ext <<EOF
 837 #line __oline__ "${as_me-configure}"
 838 #include "confdefs.h"
 839 #include "conftest.h"
 840 #include "conftest.i"
 841 #if     GCC_PRINTF
 842 #define GCC_PRINTFLIKE(fmt,var) __attribute__((format(printf,fmt,var)))
 843 #else
 844 #define GCC_PRINTFLIKE(fmt,var) /*nothing*/
 845 #endif
 846 #if     GCC_SCANF
 847 #define GCC_SCANFLIKE(fmt,var)  __attribute__((format(scanf,fmt,var)))
 848 #else
 849 #define GCC_SCANFLIKE(fmt,var)  /*nothing*/
 850 #endif
 851 extern void wow(char *,...) GCC_SCANFLIKE(1,2);
 852 extern void oops(char *,...) GCC_PRINTFLIKE(1,2) GCC_NORETURN;
 853 extern void foo(void) GCC_NORETURN;
 854 int main(int argc GCC_UNUSED, char *argv[[]] GCC_UNUSED) { return 0; }
 855 EOF
 856         cf_printf_attribute=no
 857         cf_scanf_attribute=no
 858         for cf_attribute in scanf printf unused noreturn
 859         do
 860                 CF_UPPER(cf_ATTRIBUTE,$cf_attribute)
 861                 cf_directive="__attribute__(($cf_attribute))"
 862                 echo "checking for $CC $cf_directive" 1>&AC_FD_CC
 863
 864                 case $cf_attribute in #(vi
 865                 printf) #(vi
 866                         cf_printf_attribute=yes
 867                         cat >conftest.h <<EOF
 868 #define GCC_$cf_ATTRIBUTE 1
 869 EOF
 870                         ;;
 871                 scanf) #(vi
 872                         cf_scanf_attribute=yes
 873                         cat >conftest.h <<EOF
 874 #define GCC_$cf_ATTRIBUTE 1
 875 EOF
 876                         ;;
 877                 *) #(vi
 878                         cat >conftest.h <<EOF
 879 #define GCC_$cf_ATTRIBUTE $cf_directive
 880 EOF
 881                         ;;
 882                 esac
 883
 884                 if AC_TRY_EVAL(ac_compile); then
 885                         test -n "$verbose" && AC_MSG_RESULT(... $cf_attribute)
 886                         cat conftest.h >>confdefs.h
 887                         case $cf_attribute in #(vi
 888                         printf) #(vi
 889                                 if test "$cf_printf_attribute" = no ; then
 890                                         cat >>confdefs.h <<EOF
 891 #define GCC_PRINTFLIKE(fmt,var) /* nothing */
 892 EOF
 893                                 else
 894                                         cat >>confdefs.h <<EOF
 895 #define GCC_PRINTFLIKE(fmt,var) __attribute__((format(printf,fmt,var)))
 896 EOF
 897                                 fi
 898                                 ;;
 899                         scanf) #(vi
 900                                 if test "$cf_scanf_attribute" = no ; then
 901                                         cat >>confdefs.h <<EOF
 902 #define GCC_SCANFLIKE(fmt,var) /* nothing */
 903 EOF
 904                                 else
 905                                         cat >>confdefs.h <<EOF
 906 #define GCC_SCANFLIKE(fmt,var)  __attribute__((format(scanf,fmt,var)))
 907 EOF
 908                                 fi
 909                                 ;;
 910                         esac
 911                 fi
 912         done
 913 else
 914         fgrep define conftest.i >>confdefs.h
 915 fi
 916 rm -rf conftest*
 917 fi
 918 ])dnl
 919 dnl ---------------------------------------------------------------------------
 920 dnl CF_GCC_VERSION version: 5 updated: 2010/04/24 11:02:31
 921 dnl --------------
 922 dnl Find version of gcc
 923 AC_DEFUN([CF_GCC_VERSION],[
 924 AC_REQUIRE([AC_PROG_CC])
 925 GCC_VERSION=none
 926 if test "$GCC" = yes ; then
 927         AC_MSG_CHECKING(version of $CC)
 928         GCC_VERSION="`${CC} --version 2>/dev/null | sed -e '2,$d' -e 's/^.*(GCC) //' -e 's/^[[^0-9.]]*//' -e 's/[[^0-9.]].*//'`"
 929         test -z "$GCC_VERSION" && GCC_VERSION=unknown
 930         AC_MSG_RESULT($GCC_VERSION)
 931 fi
 932 ])dnl
 933 dnl ---------------------------------------------------------------------------
 934 dnl CF_GCC_WARNINGS version: 26 updated: 2010/08/14 18:25:37
 935 dnl ---------------
 936 dnl Check if the compiler supports useful warning options.  There's a few that
 937 dnl we don't use, simply because they're too noisy:
 938 dnl
 939 dnl     -Wconversion (useful in older versions of gcc, but not in gcc 2.7.x)
 940 dnl     -Wredundant-decls (system headers make this too noisy)
 941 dnl     -Wtraditional (combines too many unrelated messages, only a few useful)
 942 dnl     -Wwrite-strings (too noisy, but should review occasionally).  This
 943 dnl             is enabled for ncurses using "--enable-const".
 944 dnl     -pedantic
 945 dnl
 946 dnl Parameter:
 947 dnl     $1 is an optional list of gcc warning flags that a particular
 948 dnl             application might want to use, e.g., "no-unused" for
 949 dnl             -Wno-unused
 950 dnl Special:
 951 dnl     If $with_ext_const is "yes", add a check for -Wwrite-strings
 952 dnl
 953 AC_DEFUN([CF_GCC_WARNINGS],
 954 [
 955 AC_REQUIRE([CF_GCC_VERSION])
 956 CF_INTEL_COMPILER(GCC,INTEL_COMPILER,CFLAGS)
 957
 958 cat > conftest.$ac_ext <<EOF
 959 #line __oline__ "${as_me-configure}"
 960 int main(int argc, char *argv[[]]) { return (argv[[argc-1]] == 0) ; }
 961 EOF
 962
 963 if test "$INTEL_COMPILER" = yes
 964 then
 965 # The "-wdXXX" options suppress warnings:
 966 # remark #1419: external declaration in primary source file
 967 # remark #1683: explicit conversion of a 64-bit integral type to a smaller integral type (potential portability problem)
 968 # remark #1684: conversion from pointer to same-sized integral type (potential portability problem)
 969 # remark #193: zero used for undefined preprocessing identifier
 970 # remark #593: variable "curs_sb_left_arrow" was set but never used
 971 # remark #810: conversion from "int" to "Dimension={unsigned short}" may lose significant bits
 972 # remark #869: parameter "tw" was never referenced
 973 # remark #981: operands are evaluated in unspecified order
 974 # warning #279: controlling expression is constant
 975
 976         AC_CHECKING([for $CC warning options])
 977         cf_save_CFLAGS="$CFLAGS"
 978         EXTRA_CFLAGS="-Wall"
 979         for cf_opt in \
 980                 wd1419 \
 981                 wd1683 \
 982                 wd1684 \
 983                 wd193 \
 984                 wd593 \
 985                 wd279 \
 986                 wd810 \
 987                 wd869 \
 988                 wd981
 989         do
 990                 CFLAGS="$cf_save_CFLAGS $EXTRA_CFLAGS -$cf_opt"
 991                 if AC_TRY_EVAL(ac_compile); then
 992                         test -n "$verbose" && AC_MSG_RESULT(... -$cf_opt)
 993                         EXTRA_CFLAGS="$EXTRA_CFLAGS -$cf_opt"
 994                 fi
 995         done
 996         CFLAGS="$cf_save_CFLAGS"
 997
 998 elif test "$GCC" = yes
 999 then
1000         AC_CHECKING([for $CC warning options])
1001         cf_save_CFLAGS="$CFLAGS"
1002         EXTRA_CFLAGS=
1003         cf_warn_CONST=""
1004         test "$with_ext_const" = yes && cf_warn_CONST="Wwrite-strings"
1005         for cf_opt in W Wall \
1006                 Wbad-function-cast \
1007                 Wcast-align \
1008                 Wcast-qual \
1009                 Winline \
1010                 Wmissing-declarations \
1011                 Wmissing-prototypes \
1012                 Wnested-externs \
1013                 Wpointer-arith \
1014                 Wshadow \
1015                 Wstrict-prototypes \
1016                 Wundef $cf_warn_CONST $1
1017         do
1018                 CFLAGS="$cf_save_CFLAGS $EXTRA_CFLAGS -$cf_opt"
1019                 if AC_TRY_EVAL(ac_compile); then
1020                         test -n "$verbose" && AC_MSG_RESULT(... -$cf_opt)
1021                         case $cf_opt in #(vi
1022                         Wcast-qual) #(vi
1023                                 CPPFLAGS="$CPPFLAGS -DXTSTRINGDEFINES"
1024                                 ;;
1025                         Winline) #(vi
1026                                 case $GCC_VERSION in
1027                                 [[34]].*)
1028                                         CF_VERBOSE(feature is broken in gcc $GCC_VERSION)
1029                                         continue;;
1030                                 esac
1031                                 ;;
1032                         esac
1033                         EXTRA_CFLAGS="$EXTRA_CFLAGS -$cf_opt"
1034                 fi
1035         done
1036         CFLAGS="$cf_save_CFLAGS"
1037 fi
1038 rm -rf conftest*
1039
1040 AC_SUBST(EXTRA_CFLAGS)
1041 ])dnl
1042 dnl ---------------------------------------------------------------------------
1043 dnl CF_GNAT_PRAGMA_UNREF version: 1 updated: 2010/06/19 15:22:18
1044 dnl --------------------
1045 dnl Check if the gnat pragma "Unreferenced" works.
1046 AC_DEFUN([CF_GNAT_PRAGMA_UNREF],[
1047 AC_CACHE_CHECK(if GNAT pragma Unreferenced works,cf_cv_pragma_unreferenced,[
1048 CF_GNAT_TRY_LINK([procedure conftest;],
1049 [with Text_IO;
1050 with GNAT.OS_Lib;
1051 procedure conftest is
1052    test : Integer;
1053    pragma Unreferenced (test);
1054 begin
1055    test := 1;
1056    Text_IO.Put ("Hello World");
1057    Text_IO.New_Line;
1058    GNAT.OS_Lib.OS_Exit (0);
1059 end conftest;],
1060         [cf_cv_pragma_unreferenced=yes],
1061         [cf_cv_pragma_unreferenced=no])])
1062
1063 # if the pragma is supported, use it (needed in the Trace code).
1064 if test $cf_cv_pragma_unreferenced = yes ; then
1065         PRAGMA_UNREF=TRUE
1066 else
1067         PRAGMA_UNREF=FALSE
1068 fi
1069 AC_SUBST(PRAGMA_UNREF)
1070 ])dnl
1071 dnl ---------------------------------------------------------------------------
1072 dnl CF_GNAT_TRY_LINK version: 2 updated: 2010/08/14 18:25:37
1073 dnl ----------------
1074 dnl Verify that a test program compiles/links with GNAT.
1075 dnl $cf_ada_make is set to the program that compiles/links
1076 dnl $ADAFLAGS may be set to the GNAT flags.
1077 dnl
1078 dnl $1 is the text of the spec
1079 dnl $2 is the text of the body
1080 dnl $3 is the shell command to execute if successful
1081 dnl $4 is the shell command to execute if not successful
1082 AC_DEFUN([CF_GNAT_TRY_LINK],
1083 [
1084 rm -rf conftest*
1085 cat >>conftest.ads <<CF_EOF
1086 $1
1087 CF_EOF
1088 cat >>conftest.adb <<CF_EOF
1089 $2
1090 CF_EOF
1091 if ( $cf_ada_make $ADAFLAGS conftest 1>&AC_FD_CC 2>&1 ) ; then
1092 ifelse($3,,      :,[      $3])
1093 ifelse($4,,,[else
1094    $4])
1095 fi
1096 rm -rf conftest*
1097 ])dnl
1098 dnl ---------------------------------------------------------------------------
1099 dnl CF_GNAT_TRY_RUN version: 4 updated: 2010/08/14 18:25:37
1100 dnl ---------------
1101 dnl Verify that a test program compiles and runs with GNAT
1102 dnl $cf_ada_make is set to the program that compiles/links
1103 dnl $ADAFLAGS may be set to the GNAT flags.
1104 dnl
1105 dnl $1 is the text of the spec
1106 dnl $2 is the text of the body
1107 dnl $3 is the shell command to execute if successful
1108 dnl $4 is the shell command to execute if not successful
1109 AC_DEFUN([CF_GNAT_TRY_RUN],
1110 [
1111 rm -rf conftest*
1112 cat >>conftest.ads <<CF_EOF
1113 $1
1114 CF_EOF
1115 cat >>conftest.adb <<CF_EOF
1116 $2
1117 CF_EOF
1118 if ( $cf_ada_make $ADAFLAGS conftest 1>&AC_FD_CC 2>&1 ) ; then
1119    if ( ./conftest 1>&AC_FD_CC 2>&1 ) ; then
1120 ifelse($3,,      :,[      $3])
1121 ifelse($4,,,[   else
1122       $4])
1123    fi
1124 ifelse($4,,,[else
1125    $4])
1126 fi
1127 rm -rf conftest*
1128 ])dnl
1129 dnl ---------------------------------------------------------------------------
1130 dnl CF_GNAT_VERSION version: 14 updated: 2010/07/03 17:45:09
1131 dnl ---------------
1132 dnl Verify version of GNAT.
1133 AC_DEFUN([CF_GNAT_VERSION],
1134 [
1135 AC_MSG_CHECKING(for gnat version)
1136 cf_gnat_version=`${cf_ada_make-gnatmake} -v 2>&1 | grep '[[0-9]].[[0-9]][[0-9]]*' |\
1137   sed -e '2,$d' -e 's/[[^0-9 \.]]//g' -e 's/^[[ ]]*//' -e 's/ .*//'`
1138 AC_MSG_RESULT($cf_gnat_version)
1139
1140 case $cf_gnat_version in
1141   3.1[[1-9]]*|3.[[2-9]]*|[[4-9]].*)
1142     cf_cv_prog_gnat_correct=yes
1143     ;;
1144   *) echo Unsupported GNAT version $cf_gnat_version. Required is 3.11 or better. Disabling Ada95 binding.
1145      cf_cv_prog_gnat_correct=no
1146      ;;
1147 esac
1148
1149 case $cf_gnat_version in
1150   3.[[1-9]]*|[[4-9]].*)
1151       cf_compile_generics=generics
1152       cf_generic_objects="\${GENOBJS}"
1153       ;;
1154   *)  cf_compile_generics=
1155       cf_generic_objects=
1156       ;;
1157 esac
1158
1159 case $cf_gnat_version in
1160   3.[[0-9]]*)
1161     USE_OLD_MAKERULES=""
1162     USE_GNAT_PROJECTS="#"
1163     ;;
1164   *)
1165     USE_OLD_MAKERULES="#"
1166     USE_GNAT_PROJECTS=""
1167     ;;
1168 esac
1169
1170 AC_SUBST(cf_compile_generics)
1171 AC_SUBST(cf_generic_objects)
1172
1173 AC_SUBST(USE_OLD_MAKERULES)
1174 AC_SUBST(USE_GNAT_PROJECTS)
1175 ])
1176 dnl ---------------------------------------------------------------------------
1177 dnl CF_GNU_SOURCE version: 6 updated: 2005/07/09 13:23:07
1178 dnl -------------
1179 dnl Check if we must define _GNU_SOURCE to get a reasonable value for
1180 dnl _XOPEN_SOURCE, upon which many POSIX definitions depend.  This is a defect
1181 dnl (or misfeature) of glibc2, which breaks portability of many applications,
1182 dnl since it is interwoven with GNU extensions.
1183 dnl
1184 dnl Well, yes we could work around it...
1185 AC_DEFUN([CF_GNU_SOURCE],
1186 [
1187 AC_CACHE_CHECK(if we must define _GNU_SOURCE,cf_cv_gnu_source,[
1188 AC_TRY_COMPILE([#include <sys/types.h>],[
1189 #ifndef _XOPEN_SOURCE
1190 make an error
1191 #endif],
1192         [cf_cv_gnu_source=no],
1193         [cf_save="$CPPFLAGS"
1194          CPPFLAGS="$CPPFLAGS -D_GNU_SOURCE"
1195          AC_TRY_COMPILE([#include <sys/types.h>],[
1196 #ifdef _XOPEN_SOURCE
1197 make an error
1198 #endif],
1199         [cf_cv_gnu_source=no],
1200         [cf_cv_gnu_source=yes])
1201         CPPFLAGS="$cf_save"
1202         ])
1203 ])
1204 test "$cf_cv_gnu_source" = yes && CPPFLAGS="$CPPFLAGS -D_GNU_SOURCE"
1205 ])dnl
1206 dnl ---------------------------------------------------------------------------
1207 dnl CF_HEADER_PATH version: 12 updated: 2010/05/05 05:22:40
1208 dnl --------------
1209 dnl Construct a search-list of directories for a nonstandard header-file
1210 dnl
1211 dnl Parameters
1212 dnl     $1 = the variable to return as result
1213 dnl     $2 = the package name
1214 AC_DEFUN([CF_HEADER_PATH],
1215 [
1216 $1=
1217
1218 # collect the current set of include-directories from compiler flags
1219 cf_header_path_list=""
1220 if test -n "${CFLAGS}${CPPFLAGS}" ; then
1221         for cf_header_path in $CPPFLAGS $CFLAGS
1222         do
1223                 case $cf_header_path in #(vi
1224                 -I*)
1225                         cf_header_path=`echo ".$cf_header_path" |sed -e 's/^...//' -e 's,/include$,,'`
1226                         CF_ADD_SUBDIR_PATH($1,$2,include,$cf_header_path,NONE)
1227                         cf_header_path_list="$cf_header_path_list [$]$1"
1228                         ;;
1229                 esac
1230         done
1231 fi
1232
1233 # add the variations for the package we are looking for
1234 CF_SUBDIR_PATH($1,$2,include)
1235
1236 test "$includedir" != NONE && \
1237 test "$includedir" != "/usr/include" && \
1238 test -d "$includedir" && {
1239         test -d $includedir &&    $1="[$]$1 $includedir"
1240         test -d $includedir/$2 && $1="[$]$1 $includedir/$2"
1241 }
1242
1243 test "$oldincludedir" != NONE && \
1244 test "$oldincludedir" != "/usr/include" && \
1245 test -d "$oldincludedir" && {
1246         test -d $oldincludedir    && $1="[$]$1 $oldincludedir"
1247         test -d $oldincludedir/$2 && $1="[$]$1 $oldincludedir/$2"
1248 }
1249
1250 $1="[$]$1 $cf_header_path_list"
1251 ])dnl
1252 dnl ---------------------------------------------------------------------------
1253 dnl CF_HELP_MESSAGE version: 3 updated: 1998/01/14 10:56:23
1254 dnl ---------------
1255 dnl Insert text into the help-message, for readability, from AC_ARG_WITH.
1256 AC_DEFUN([CF_HELP_MESSAGE],
1257 [AC_DIVERT_HELP([$1])dnl
1258 ])dnl
1259 dnl ---------------------------------------------------------------------------
1260 dnl CF_INCLUDE_DIRS version: 6 updated: 2009/01/06 19:37:40
1261 dnl ---------------
1262 dnl Construct the list of include-options according to whether we're building
1263 dnl in the source directory or using '--srcdir=DIR' option.  If we're building
1264 dnl with gcc, don't append the includedir if it happens to be /usr/include,
1265 dnl since that usually breaks gcc's shadow-includes.
1266 AC_DEFUN([CF_INCLUDE_DIRS],
1267 [
1268 CPPFLAGS="$CPPFLAGS -I. -I../include"
1269 if test "$srcdir" != "."; then
1270         CPPFLAGS="$CPPFLAGS -I\${srcdir}/../include"
1271 fi
1272 if test "$GCC" != yes; then
1273         CPPFLAGS="$CPPFLAGS -I\${includedir}"
1274 elif test "$includedir" != "/usr/include"; then
1275         if test "$includedir" = '${prefix}/include' ; then
1276                 if test $prefix != /usr ; then
1277                         CPPFLAGS="$CPPFLAGS -I\${includedir}"
1278                 fi
1279         else
1280                 CPPFLAGS="$CPPFLAGS -I\${includedir}"
1281         fi
1282 fi
1283 AC_SUBST(CPPFLAGS)
1284 ])dnl
1285 dnl ---------------------------------------------------------------------------
1286 dnl CF_INTEL_COMPILER version: 4 updated: 2010/05/26 05:38:42
1287 dnl -----------------
1288 dnl Check if the given compiler is really the Intel compiler for Linux.  It
1289 dnl tries to imitate gcc, but does not return an error when it finds a mismatch
1290 dnl between prototypes, e.g., as exercised by CF_MISSING_CHECK.
1291 dnl
1292 dnl This macro should be run "soon" after AC_PROG_CC or AC_PROG_CPLUSPLUS, to
1293 dnl ensure that it is not mistaken for gcc/g++.  It is normally invoked from
1294 dnl the wrappers for gcc and g++ warnings.
1295 dnl
1296 dnl $1 = GCC (default) or GXX
1297 dnl $2 = INTEL_COMPILER (default) or INTEL_CPLUSPLUS
1298 dnl $3 = CFLAGS (default) or CXXFLAGS
1299 AC_DEFUN([CF_INTEL_COMPILER],[
1300 ifelse([$2],,INTEL_COMPILER,[$2])=no
1301
1302 if test "$ifelse([$1],,[$1],GCC)" = yes ; then
1303         case $host_os in
1304         linux*|gnu*)
1305                 AC_MSG_CHECKING(if this is really Intel ifelse([$1],GXX,C++,C) compiler)
1306                 cf_save_CFLAGS="$ifelse([$3],,CFLAGS,[$3])"
1307                 ifelse([$3],,CFLAGS,[$3])="$ifelse([$3],,CFLAGS,[$3]) -no-gcc"
1308                 AC_TRY_COMPILE([],[
1309 #ifdef __INTEL_COMPILER
1310 #else
1311 make an error
1312 #endif
1313 ],[ifelse([$2],,INTEL_COMPILER,[$2])=yes
1314 cf_save_CFLAGS="$cf_save_CFLAGS -we147 -no-gcc"
1315 ],[])
1316                 ifelse([$3],,CFLAGS,[$3])="$cf_save_CFLAGS"
1317                 AC_MSG_RESULT($ifelse([$2],,INTEL_COMPILER,[$2]))
1318                 ;;
1319         esac
1320 fi
1321 ])dnl
1322 dnl ---------------------------------------------------------------------------
1323 dnl CF_LARGEFILE version: 7 updated: 2007/06/02 11:58:50
1324 dnl ------------
1325 dnl Add checks for large file support.
1326 AC_DEFUN([CF_LARGEFILE],[
1327 ifdef([AC_FUNC_FSEEKO],[
1328     AC_SYS_LARGEFILE
1329     if test "$enable_largefile" != no ; then
1330         AC_FUNC_FSEEKO
1331
1332         # Normally we would collect these definitions in the config.h,
1333         # but (like _XOPEN_SOURCE), some environments rely on having these
1334         # defined before any of the system headers are included.  Another
1335         # case comes up with C++, e.g., on AIX the compiler compiles the
1336         # header files by themselves before looking at the body files it is
1337         # told to compile.  For ncurses, those header files do not include
1338         # the config.h
1339         test "$ac_cv_sys_large_files"      != no && CPPFLAGS="$CPPFLAGS -D_LARGE_FILES "
1340         test "$ac_cv_sys_largefile_source" != no && CPPFLAGS="$CPPFLAGS -D_LARGEFILE_SOURCE "
1341         test "$ac_cv_sys_file_offset_bits" != no && CPPFLAGS="$CPPFLAGS -D_FILE_OFFSET_BITS=$ac_cv_sys_file_offset_bits "
1342
1343         AC_CACHE_CHECK(whether to use struct dirent64, cf_cv_struct_dirent64,[
1344                 AC_TRY_COMPILE([
1345 #include <sys/types.h>
1346 #include <dirent.h>
1347                 ],[
1348                 /* if transitional largefile support is setup, this is true */
1349                 extern struct dirent64 * readdir(DIR *);
1350                 struct dirent64 *x = readdir((DIR *)0);
1351                 struct dirent *y = readdir((DIR *)0);
1352                 int z = x - y;
1353                 ],
1354                 [cf_cv_struct_dirent64=yes],
1355                 [cf_cv_struct_dirent64=no])
1356         ])
1357         test "$cf_cv_struct_dirent64" = yes && AC_DEFINE(HAVE_STRUCT_DIRENT64)
1358     fi
1359 ])
1360 ])
1361 dnl ---------------------------------------------------------------------------
1362 dnl CF_LD_RPATH_OPT version: 3 updated: 2010/06/02 05:03:05
1363 dnl ---------------
1364 dnl For the given system and compiler, find the compiler flags to pass to the
1365 dnl loader to use the "rpath" feature.
1366 AC_DEFUN([CF_LD_RPATH_OPT],
1367 [
1368 AC_REQUIRE([CF_CHECK_CACHE])
1369
1370 LD_RPATH_OPT=
1371 AC_MSG_CHECKING(for an rpath option)
1372 case $cf_cv_system_name in #(vi
1373 irix*) #(vi
1374         if test "$GCC" = yes; then
1375                 LD_RPATH_OPT="-Wl,-rpath,"
1376         else
1377                 LD_RPATH_OPT="-rpath "
1378         fi
1379         ;;
1380 linux*|gnu*|k*bsd*-gnu) #(vi
1381         LD_RPATH_OPT="-Wl,-rpath,"
1382         ;;
1383 openbsd[[2-9]].*) #(vi
1384         LD_RPATH_OPT="-Wl,-rpath,"
1385         ;;
1386 freebsd*) #(vi
1387         LD_RPATH_OPT="-rpath "
1388         ;;
1389 netbsd*) #(vi
1390         LD_RPATH_OPT="-Wl,-rpath,"
1391         ;;
1392 osf*|mls+*) #(vi
1393         LD_RPATH_OPT="-rpath "
1394         ;;
1395 solaris2*) #(vi
1396         LD_RPATH_OPT="-R"
1397         ;;
1398 *)
1399         ;;
1400 esac
1401 AC_MSG_RESULT($LD_RPATH_OPT)
1402
1403 case "x$LD_RPATH_OPT" in #(vi
1404 x-R*)
1405         AC_MSG_CHECKING(if we need a space after rpath option)
1406         cf_save_LIBS="$LIBS"
1407         CF_ADD_LIBS(${LD_RPATH_OPT}$libdir)
1408         AC_TRY_LINK(, , cf_rpath_space=no, cf_rpath_space=yes)
1409         LIBS="$cf_save_LIBS"
1410         AC_MSG_RESULT($cf_rpath_space)
1411         test "$cf_rpath_space" = yes && LD_RPATH_OPT="$LD_RPATH_OPT "
1412         ;;
1413 esac
1414 ])dnl
1415 dnl ---------------------------------------------------------------------------
1416 dnl CF_LIBRARY_PATH version: 9 updated: 2010/03/28 12:52:50
1417 dnl ---------------
1418 dnl Construct a search-list of directories for a nonstandard library-file
1419 dnl
1420 dnl Parameters
1421 dnl     $1 = the variable to return as result
1422 dnl     $2 = the package name
1423 AC_DEFUN([CF_LIBRARY_PATH],
1424 [
1425 $1=
1426 cf_library_path_list=""
1427 if test -n "${LDFLAGS}${LIBS}" ; then
1428         for cf_library_path in $LDFLAGS $LIBS
1429         do
1430                 case $cf_library_path in #(vi
1431                 -L*)
1432                         cf_library_path=`echo ".$cf_library_path" |sed -e 's/^...//' -e 's,/lib$,,'`
1433                         CF_ADD_SUBDIR_PATH($1,$2,lib,$cf_library_path,NONE)
1434                         cf_library_path_list="$cf_library_path_list [$]$1"
1435                         ;;
1436                 esac
1437         done
1438 fi
1439
1440 CF_SUBDIR_PATH($1,$2,lib)
1441
1442 $1="$cf_library_path_list [$]$1"
1443 ])dnl
1444 dnl ---------------------------------------------------------------------------
1445 dnl CF_LIB_PREFIX version: 8 updated: 2008/09/13 11:34:16
1446 dnl -------------
1447 dnl Compute the library-prefix for the given host system
1448 dnl $1 = variable to set
1449 AC_DEFUN([CF_LIB_PREFIX],
1450 [
1451         case $cf_cv_system_name in #(vi
1452         OS/2*|os2*) #(vi
1453         LIB_PREFIX=''
1454         ;;
1455         *)      LIB_PREFIX='lib'
1456         ;;
1457         esac
1458 ifelse($1,,,[$1=$LIB_PREFIX])
1459         AC_SUBST(LIB_PREFIX)
1460 ])dnl
1461 dnl ---------------------------------------------------------------------------
1462 dnl CF_LIB_SONAME version: 5 updated: 2010/08/14 18:25:37
1463 dnl -------------
1464 dnl Find the and soname for the given shared library.  Set the cache variable
1465 dnl cf_cv_$3_soname to this, unless it is not found.  Then set the cache
1466 dnl variable to "unknown".
1467 dnl
1468 dnl $1 = headers
1469 dnl $2 = code
1470 dnl $3 = library name
1471 AC_DEFUN([CF_LIB_SONAME],
1472 [
1473 AC_CACHE_CHECK(for soname of $3 library,cf_cv_$3_soname,[
1474
1475 cf_cv_$3_soname=unknown
1476 if test "$cross_compiling" != yes ; then
1477 cat >conftest.$ac_ext <<CF_EOF
1478 $1
1479 int main()
1480 {
1481 $2
1482         ${cf_cv_main_return:-return}(0);
1483 }
1484 CF_EOF
1485 cf_save_LIBS="$LIBS"
1486         CF_ADD_LIB($3)
1487         if AC_TRY_EVAL(ac_compile) ; then
1488                 if AC_TRY_EVAL(ac_link) ; then
1489                         cf_cv_$3_soname=`ldd conftest$ac_exeext 2>/dev/null | sed -e 's,^.*/,,' -e 's, .*$,,' | fgrep lib$3.`
1490                         test -z "$cf_cv_$3_soname" && cf_cv_$3_soname=unknown
1491                 fi
1492         fi
1493 rm -rf conftest*
1494 LIBS="$cf_save_LIBS"
1495 fi
1496 ])
1497 ])
1498 dnl ---------------------------------------------------------------------------
1499 dnl CF_LIB_SUFFIX version: 16 updated: 2008/12/27 12:30:03
1500 dnl -------------
1501 dnl Compute the library file-suffix from the given model name
1502 dnl $1 = model name
1503 dnl $2 = variable to set (the nominal library suffix)
1504 dnl $3 = dependency variable to set (actual filename)
1505 dnl The variable $LIB_SUFFIX, if set, prepends the variable to set.
1506 AC_DEFUN([CF_LIB_SUFFIX],
1507 [
1508         AC_REQUIRE([CF_SUBST_NCURSES_VERSION])
1509         case $1 in #(vi
1510         libtool) #(vi
1511                 $2='.la'
1512                 $3=[$]$2
1513                 ;;
1514         normal) #(vi
1515                 $2='.a'
1516                 $3=[$]$2
1517                 ;;
1518         debug) #(vi
1519                 $2='_g.a'
1520                 $3=[$]$2
1521                 ;;
1522         profile) #(vi
1523                 $2='_p.a'
1524                 $3=[$]$2
1525                 ;;
1526         shared) #(vi
1527                 case $cf_cv_system_name in
1528                 aix[[56]]*) #(vi
1529                         $2='.a'
1530                         $3=[$]$2
1531                         ;;
1532                 cygwin*) #(vi
1533                         $2='.dll'
1534                         $3='.dll.a'
1535                         ;;
1536                 darwin*) #(vi
1537                         $2='.dylib'
1538                         $3=[$]$2
1539                         ;;
1540                 hpux*) #(vi
1541                         case $target in
1542                         ia64*) #(vi
1543                                 $2='.so'
1544                                 $3=[$]$2
1545                                 ;;
1546                         *) #(vi
1547                                 $2='.sl'
1548                                 $3=[$]$2
1549                                 ;;
1550                         esac
1551                         ;;
1552                 *)      $2='.so'
1553                         $3=[$]$2
1554                         ;;
1555                 esac
1556         esac
1557         test -n "$LIB_SUFFIX" && $2="${LIB_SUFFIX}[$]{$2}"
1558         test -n "$LIB_SUFFIX" && $3="${LIB_SUFFIX}[$]{$3}"
1559 ])dnl
1560 dnl ---------------------------------------------------------------------------
1561 dnl CF_LIB_TYPE version: 4 updated: 2000/10/20 22:57:49
1562 dnl -----------
1563 dnl Compute the string to append to -library from the given model name
1564 dnl $1 = model name
1565 dnl $2 = variable to set
1566 dnl The variable $LIB_SUFFIX, if set, prepends the variable to set.
1567 AC_DEFUN([CF_LIB_TYPE],
1568 [
1569         case $1 in
1570         libtool) $2=''   ;;
1571         normal)  $2=''   ;;
1572         debug)   $2='_g' ;;
1573         profile) $2='_p' ;;
1574         shared)  $2=''   ;;
1575         esac
1576         test -n "$LIB_SUFFIX" && $2="${LIB_SUFFIX}[$]{$2}"
1577 ])dnl
1578 dnl ---------------------------------------------------------------------------
1579 dnl CF_LINK_DATAONLY version: 9 updated: 2009/01/01 20:21:38
1580 dnl ----------------
1581 dnl Some systems have a non-ANSI linker that doesn't pull in modules that have
1582 dnl only data (i.e., no functions), for example NeXT.  On those systems we'll
1583 dnl have to provide wrappers for global tables to ensure they're linked
1584 dnl properly.
1585 AC_DEFUN([CF_LINK_DATAONLY],
1586 [
1587 AC_MSG_CHECKING([if data-only library module links])
1588 AC_CACHE_VAL(cf_cv_link_dataonly,[
1589         rm -f conftest.a
1590         cat >conftest.$ac_ext <<EOF
1591 #line __oline__ "configure"
1592 int     testdata[[3]] = { 123, 456, 789 };
1593 EOF
1594         if AC_TRY_EVAL(ac_compile) ; then
1595                 mv conftest.o data.o && \
1596                 ( $AR $ARFLAGS conftest.a data.o ) 2>&AC_FD_CC 1>/dev/null
1597         fi
1598         rm -f conftest.$ac_ext data.o
1599         cat >conftest.$ac_ext <<EOF
1600 #line __oline__ "configure"
1601 int     testfunc()
1602 {
1603 #if defined(NeXT)
1604         ${cf_cv_main_return:-return}(1);        /* I'm told this linker is broken */
1605 #else
1606         extern int testdata[[3]];
1607         return testdata[[0]] == 123
1608            &&  testdata[[1]] == 456
1609            &&  testdata[[2]] == 789;
1610 #endif
1611 }
1612 EOF
1613         if AC_TRY_EVAL(ac_compile); then
1614                 mv conftest.o func.o && \
1615                 ( $AR $ARFLAGS conftest.a func.o ) 2>&AC_FD_CC 1>/dev/null
1616         fi
1617         rm -f conftest.$ac_ext func.o
1618         ( eval $RANLIB conftest.a ) 2>&AC_FD_CC >/dev/null
1619         cf_saveLIBS="$LIBS"
1620         LIBS="conftest.a $LIBS"
1621         AC_TRY_RUN([
1622         int main()
1623         {
1624                 extern int testfunc();
1625                 ${cf_cv_main_return:-return} (!testfunc());
1626         }
1627         ],
1628         [cf_cv_link_dataonly=yes],
1629         [cf_cv_link_dataonly=no],
1630         [cf_cv_link_dataonly=unknown])
1631         LIBS="$cf_saveLIBS"
1632         ])
1633 AC_MSG_RESULT($cf_cv_link_dataonly)
1634
1635 if test "$cf_cv_link_dataonly" = no ; then
1636         AC_DEFINE(BROKEN_LINKER)
1637         BROKEN_LINKER=1
1638 fi
1639
1640 ])dnl
1641 dnl ---------------------------------------------------------------------------
1642 dnl CF_LINK_FUNCS version: 7 updated: 2006/12/16 12:33:30
1643 dnl -------------
1644 dnl Most Unix systems have both link and symlink, a few don't have symlink.
1645 dnl A few non-Unix systems implement symlink, but not link.
1646 dnl A few non-systems implement neither (or have nonfunctional versions).
1647 AC_DEFUN([CF_LINK_FUNCS],
1648 [
1649 AC_CHECK_FUNCS( \
1650         remove \
1651         unlink )
1652
1653 if test "$cross_compiling" = yes ; then
1654         AC_CHECK_FUNCS( \
1655                 link \
1656                 symlink )
1657 else
1658         AC_CACHE_CHECK(if link/symlink functions work,cf_cv_link_funcs,[
1659                 cf_cv_link_funcs=
1660                 for cf_func in link symlink ; do
1661                         AC_TRY_RUN([
1662 #include <sys/types.h>
1663 #include <sys/stat.h>
1664 #ifdef HAVE_UNISTD_H
1665 #include <unistd.h>
1666 #endif
1667 int main()
1668 {
1669         int fail = 0;
1670         char *src = "config.log";
1671         char *dst = "conftest.chk";
1672         struct stat src_sb;
1673         struct stat dst_sb;
1674
1675         stat(src, &src_sb);
1676         fail = ($cf_func("config.log", "conftest.chk") < 0)
1677             || (stat(dst, &dst_sb) < 0)
1678             || (dst_sb.st_mtime != src_sb.st_mtime);
1679 #ifdef HAVE_UNLINK
1680         unlink(dst);
1681 #else
1682         remove(dst);
1683 #endif
1684         ${cf_cv_main_return:-return} (fail);
1685 }
1686                         ],[
1687                         cf_cv_link_funcs="$cf_cv_link_funcs $cf_func"
1688                         eval 'ac_cv_func_'$cf_func'=yes'],[
1689                         eval 'ac_cv_func_'$cf_func'=no'],[
1690                         eval 'ac_cv_func_'$cf_func'=error'])
1691                 done
1692                 test -z "$cf_cv_link_funcs" && cf_cv_link_funcs=no
1693         ])
1694         test "$ac_cv_func_link"    = yes && AC_DEFINE(HAVE_LINK)
1695         test "$ac_cv_func_symlink" = yes && AC_DEFINE(HAVE_SYMLINK)
1696 fi
1697 ])dnl
1698 dnl ---------------------------------------------------------------------------
1699 dnl CF_MAIN_RETURN version: 1 updated: 2006/12/10 09:51:54
1700 dnl --------------
1701 dnl Check if a return from main to the shell actually returns the same exit
1702 dnl code.  This is true for almost any POSIX environment.
1703 dnl
1704 dnl Some very old environments did not flush stdout, etc., on an exit.  That
1705 dnl would be a useful case to test for also.
1706 AC_DEFUN([CF_MAIN_RETURN],
1707 [
1708 cf_cv_main_return=return
1709 ])dnl
1710 dnl ---------------------------------------------------------------------------
1711 dnl CF_MAKEFLAGS version: 12 updated: 2006/10/21 08:27:03
1712 dnl ------------
1713 dnl Some 'make' programs support ${MAKEFLAGS}, some ${MFLAGS}, to pass 'make'
1714 dnl options to lower-levels.  It's very useful for "make -n" -- if we have it.
1715 dnl (GNU 'make' does both, something POSIX 'make', which happens to make the
1716 dnl ${MAKEFLAGS} variable incompatible because it adds the assignments :-)
1717 AC_DEFUN([CF_MAKEFLAGS],
1718 [
1719 AC_CACHE_CHECK(for makeflags variable, cf_cv_makeflags,[
1720         cf_cv_makeflags=''
1721         for cf_option in '-${MAKEFLAGS}' '${MFLAGS}'
1722         do
1723                 cat >cf_makeflags.tmp <<CF_EOF
1724 SHELL = /bin/sh
1725 all :
1726         @ echo '.$cf_option'
1727 CF_EOF
1728                 cf_result=`${MAKE-make} -k -f cf_makeflags.tmp 2>/dev/null | sed -e 's,[[       ]]*$,,'`
1729                 case "$cf_result" in
1730                 .*k)
1731                         cf_result=`${MAKE-make} -k -f cf_makeflags.tmp CC=cc 2>/dev/null`
1732                         case "$cf_result" in
1733                         .*CC=*) cf_cv_makeflags=
1734                                 ;;
1735                         *)      cf_cv_makeflags=$cf_option
1736                                 ;;
1737                         esac
1738                         break
1739                         ;;
1740                 .-)     ;;
1741                 *)      echo "given option \"$cf_option\", no match \"$cf_result\""
1742                         ;;
1743                 esac
1744         done
1745         rm -f cf_makeflags.tmp
1746 ])
1747
1748 AC_SUBST(cf_cv_makeflags)
1749 ])dnl
1750 dnl ---------------------------------------------------------------------------
1751 dnl CF_MAKE_TAGS version: 5 updated: 2010/04/03 20:07:32
1752 dnl ------------
1753 dnl Generate tags/TAGS targets for makefiles.  Do not generate TAGS if we have
1754 dnl a monocase filesystem.
1755 AC_DEFUN([CF_MAKE_TAGS],[
1756 AC_REQUIRE([CF_MIXEDCASE_FILENAMES])
1757
1758 AC_CHECK_PROGS(CTAGS, exctags ctags)
1759 AC_CHECK_PROGS(ETAGS, exetags etags)
1760
1761 AC_CHECK_PROG(MAKE_LOWER_TAGS, ${CTAGS-ctags}, yes, no)
1762
1763 if test "$cf_cv_mixedcase" = yes ; then
1764         AC_CHECK_PROG(MAKE_UPPER_TAGS, ${ETAGS-etags}, yes, no)
1765 else
1766         MAKE_UPPER_TAGS=no
1767 fi
1768
1769 if test "$MAKE_UPPER_TAGS" = yes ; then
1770         MAKE_UPPER_TAGS=
1771 else
1772         MAKE_UPPER_TAGS="#"
1773 fi
1774
1775 if test "$MAKE_LOWER_TAGS" = yes ; then
1776         MAKE_LOWER_TAGS=
1777 else
1778         MAKE_LOWER_TAGS="#"
1779 fi
1780
1781 AC_SUBST(CTAGS)
1782 AC_SUBST(ETAGS)
1783
1784 AC_SUBST(MAKE_UPPER_TAGS)
1785 AC_SUBST(MAKE_LOWER_TAGS)
1786 ])dnl
1787 dnl ---------------------------------------------------------------------------
1788 dnl CF_MIXEDCASE_FILENAMES version: 3 updated: 2003/09/20 17:07:55
1789 dnl ----------------------
1790 dnl Check if the file-system supports mixed-case filenames.  If we're able to
1791 dnl create a lowercase name and see it as uppercase, it doesn't support that.
1792 AC_DEFUN([CF_MIXEDCASE_FILENAMES],
1793 [
1794 AC_CACHE_CHECK(if filesystem supports mixed-case filenames,cf_cv_mixedcase,[
1795 if test "$cross_compiling" = yes ; then
1796         case $target_alias in #(vi
1797         *-os2-emx*|*-msdosdjgpp*|*-cygwin*|*-mingw32*|*-uwin*) #(vi
1798                 cf_cv_mixedcase=no
1799                 ;;
1800         *)
1801                 cf_cv_mixedcase=yes
1802                 ;;
1803         esac
1804 else
1805         rm -f conftest CONFTEST
1806         echo test >conftest
1807         if test -f CONFTEST ; then
1808                 cf_cv_mixedcase=no
1809         else
1810                 cf_cv_mixedcase=yes
1811         fi
1812         rm -f conftest CONFTEST
1813 fi
1814 ])
1815 test "$cf_cv_mixedcase" = yes && AC_DEFINE(MIXEDCASE_FILENAMES)
1816 ])dnl
1817 dnl ---------------------------------------------------------------------------
1818 dnl CF_MKSTEMP version: 7 updated: 2010/08/14 18:25:37
1819 dnl ----------
1820 dnl Check for a working mkstemp.  This creates two files, checks that they are
1821 dnl successfully created and distinct (AmigaOS apparently fails on the last).
1822 AC_DEFUN([CF_MKSTEMP],[
1823 AC_CACHE_CHECK(for working mkstemp, cf_cv_func_mkstemp,[
1824 rm -rf conftest*
1825 AC_TRY_RUN([
1826 #include <sys/types.h>
1827 #include <stdlib.h>
1828 #include <stdio.h>
1829 #include <string.h>
1830 #include <sys/stat.h>
1831 int main()
1832 {
1833         char *tmpl = "conftestXXXXXX";
1834         char name[2][80];
1835         int n;
1836         int result = 0;
1837         int fd;
1838         struct stat sb;
1839
1840         umask(077);
1841         for (n = 0; n < 2; ++n) {
1842                 strcpy(name[n], tmpl);
1843                 if ((fd = mkstemp(name[n])) >= 0) {
1844                         if (!strcmp(name[n], tmpl)
1845                          || stat(name[n], &sb) != 0
1846                          || (sb.st_mode & S_IFMT) != S_IFREG
1847                          || (sb.st_mode & 077) != 0) {
1848                                 result = 1;
1849                         }
1850                         close(fd);
1851                 }
1852         }
1853         if (result == 0
1854          && !strcmp(name[0], name[1]))
1855                 result = 1;
1856         ${cf_cv_main_return:-return}(result);
1857 }
1858 ],[cf_cv_func_mkstemp=yes
1859 ],[cf_cv_func_mkstemp=no
1860 ],[AC_CHECK_FUNC(mkstemp)
1861 ])
1862 ])
1863 if test "x$cf_cv_func_mkstemp" = xyes || test "x$ac_cv_func_mkstemp" = xyes ; then
1864         AC_DEFINE(HAVE_MKSTEMP)
1865 fi
1866 ])dnl
1867 dnl ---------------------------------------------------------------------------
1868 dnl CF_MSG_LOG version: 4 updated: 2007/07/29 09:55:12
1869 dnl ----------
1870 dnl Write a debug message to config.log, along with the line number in the
1871 dnl configure script.
1872 AC_DEFUN([CF_MSG_LOG],[
1873 echo "${as_me-configure}:__oline__: testing $* ..." 1>&AC_FD_CC
1874 ])dnl
1875 dnl ---------------------------------------------------------------------------
1876 dnl CF_NCURSES_ADDON version: 2 updated: 2010/02/27 18:27:44
1877 dnl ----------------
1878 dnl Configure an ncurses add-on, built outside the ncurses tree.
1879 AC_DEFUN([CF_NCURSES_ADDON],[
1880
1881 AC_PROVIDE([CF_SUBST_NCURSES_VERSION])
1882
1883 AC_MSG_CHECKING(if you want wide-character code)
1884 AC_ARG_ENABLE(widec,
1885         [  --enable-widec          compile with wide-char/UTF-8 code],
1886         [with_widec=$enableval],
1887         [with_widec=no])
1888 AC_MSG_RESULT($with_widec)
1889 if test "$with_widec" = yes ; then
1890         CF_UTF8_LIB
1891         CF_NCURSES_CONFIG(ncursesw)
1892 else
1893         CF_NCURSES_CONFIG(ncurses)
1894 fi
1895
1896 if test "$NCURSES_CONFIG" != none ; then
1897
1898 cf_version=`$NCURSES_CONFIG --version`
1899
1900 NCURSES_MAJOR=`echo "$cf_version" | sed -e 's/\..*//'`
1901 NCURSES_MINOR=`echo "$cf_version" | sed -e 's/^[[0-9]]\+\.//' -e 's/\..*//'`
1902 NCURSES_PATCH=`echo "$cf_version" | sed -e 's/^[[0-9]]\+\.[[0-9]]\+\.//'`
1903
1904 # ABI version is not available from headers
1905 cf_cv_abi_version=`$NCURSES_CONFIG --abi-version`
1906
1907 else
1908
1909 for cf_name in MAJOR MINOR PATCH
1910 do
1911 cat >conftest.$ac_ext <<CF_EOF
1912 #include <${cf_cv_ncurses_header-curses.h}>
1913 AUTOCONF_$cf_name NCURSES_VERSION_$cf_name
1914 CF_EOF
1915         cf_try="$ac_cpp conftest.$ac_ext 2>&5 | fgrep AUTOCONF_$cf_name >conftest.out"
1916         AC_TRY_EVAL(cf_try)
1917         if test -f conftest.out ; then
1918                 cf_result=`cat conftest.out | sed -e "s/^.*AUTOCONF_$cf_name[[  ]]\+//"`
1919                 eval NCURSES_$cf_name=$cf_result
1920                 cat conftest.$ac_ext
1921                 cat conftest.out
1922         fi
1923 done
1924
1925 cf_cv_abi_version=${NCURSES_MAJOR}
1926
1927 fi
1928
1929 cf_cv_rel_version=${NCURSES_MAJOR}.${NCURSES_MINOR}
1930
1931 dnl Show the computed version, for logging
1932 cf_cv_timestamp=`date`
1933
1934 AC_MSG_RESULT(Configuring NCURSES $cf_cv_rel_version ABI $cf_cv_abi_version ($cf_cv_timestamp))
1935
1936 dnl We need these values in the generated headers
1937 AC_SUBST(NCURSES_MAJOR)
1938 AC_SUBST(NCURSES_MINOR)
1939 AC_SUBST(NCURSES_PATCH)
1940
1941 dnl We need these values in the generated makefiles
1942 AC_SUBST(cf_cv_rel_version)
1943 AC_SUBST(cf_cv_abi_version)
1944
1945 dnl FIXME - not needed for Ada95
1946 AC_SUBST(cf_cv_builtin_bool)
1947 AC_SUBST(cf_cv_header_stdbool_h)
1948 AC_SUBST(cf_cv_type_of_bool)dnl
1949
1950 ])
1951 dnl ---------------------------------------------------------------------------
1952 dnl CF_NCURSES_CC_CHECK version: 4 updated: 2007/07/29 10:39:05
1953 dnl -------------------
1954 dnl Check if we can compile with ncurses' header file
1955 dnl $1 is the cache variable to set
1956 dnl $2 is the header-file to include
1957 dnl $3 is the root name (ncurses or ncursesw)
1958 AC_DEFUN([CF_NCURSES_CC_CHECK],[
1959         AC_TRY_COMPILE([
1960 ]ifelse($3,ncursesw,[
1961 #define _XOPEN_SOURCE_EXTENDED
1962 #undef  HAVE_LIBUTF8_H  /* in case we used CF_UTF8_LIB */
1963 #define HAVE_LIBUTF8_H  /* to force ncurses' header file to use cchar_t */
1964 ])[
1965 #include <$2>],[
1966 #ifdef NCURSES_VERSION
1967 ]ifelse($3,ncursesw,[
1968 #ifndef WACS_BSSB
1969         make an error
1970 #endif
1971 ])[
1972 printf("%s\n", NCURSES_VERSION);
1973 #else
1974 #ifdef __NCURSES_H
1975 printf("old\n");
1976 #else
1977         make an error
1978 #endif
1979 #endif
1980         ]
1981         ,[$1=$2]
1982         ,[$1=no])
1983 ])dnl
1984 dnl ---------------------------------------------------------------------------
1985 dnl CF_NCURSES_CONFIG version: 8 updated: 2010/07/08 05:17:30
1986 dnl -----------------
1987 dnl Tie together the configure-script macros for ncurses.
1988 dnl Prefer the "-config" script from ncurses 6.x, to simplify analysis.
1989 dnl Allow that to be overridden using the $NCURSES_CONFIG environment variable.
1990 dnl
1991 dnl $1 is the root library name (default: "ncurses")
1992 AC_DEFUN([CF_NCURSES_CONFIG],
1993 [
1994 cf_ncuconfig_root=ifelse($1,,ncurses,$1)
1995
1996 echo "Looking for ${cf_ncuconfig_root}-config"
1997 AC_PATH_PROGS(NCURSES_CONFIG,${cf_ncuconfig_root}6-config ${cf_ncuconfig_root}5-config,none)
1998
1999 if test "$NCURSES_CONFIG" != none ; then
2000
2001 CPPFLAGS="$CPPFLAGS `$NCURSES_CONFIG --cflags`"
2002 CF_ADD_LIBS(`$NCURSES_CONFIG --libs`)
2003
2004 # even with config script, some packages use no-override for curses.h
2005 CF_CURSES_HEADER(ifelse($1,,ncurses,$1))
2006
2007 dnl like CF_NCURSES_CPPFLAGS
2008 AC_DEFINE(NCURSES)
2009
2010 dnl like CF_NCURSES_LIBS
2011 CF_UPPER(cf_nculib_ROOT,HAVE_LIB$cf_ncuconfig_root)
2012 AC_DEFINE_UNQUOTED($cf_nculib_ROOT)
2013
2014 dnl like CF_NCURSES_VERSION
2015 cf_cv_ncurses_version=`$NCURSES_CONFIG --version`
2016
2017 else
2018
2019 CF_NCURSES_CPPFLAGS(ifelse($1,,ncurses,$1))
2020 CF_NCURSES_LIBS(ifelse($1,,ncurses,$1))
2021
2022 fi
2023 ])dnl
2024 dnl ---------------------------------------------------------------------------
2025 dnl CF_NCURSES_CPPFLAGS version: 19 updated: 2007/07/29 13:35:20
2026 dnl -------------------
2027 dnl Look for the SVr4 curses clone 'ncurses' in the standard places, adjusting
2028 dnl the CPPFLAGS variable so we can include its header.
2029 dnl
2030 dnl The header files may be installed as either curses.h, or ncurses.h (would
2031 dnl be obsolete, except that some packagers prefer this name to distinguish it
2032 dnl from a "native" curses implementation).  If not installed for overwrite,
2033 dnl the curses.h file would be in an ncurses subdirectory (e.g.,
2034 dnl /usr/include/ncurses), but someone may have installed overwriting the
2035 dnl vendor's curses.  Only very old versions (pre-1.9.2d, the first autoconf'd
2036 dnl version) of ncurses don't define either __NCURSES_H or NCURSES_VERSION in
2037 dnl the header.
2038 dnl
2039 dnl If the installer has set $CFLAGS or $CPPFLAGS so that the ncurses header
2040 dnl is already in the include-path, don't even bother with this, since we cannot
2041 dnl easily determine which file it is.  In this case, it has to be <curses.h>.
2042 dnl
2043 dnl The optional parameter gives the root name of the library, in case it is
2044 dnl not installed as the default curses library.  That is how the
2045 dnl wide-character version of ncurses is installed.
2046 AC_DEFUN([CF_NCURSES_CPPFLAGS],
2047 [AC_REQUIRE([CF_WITH_CURSES_DIR])
2048
2049 AC_PROVIDE([CF_CURSES_CPPFLAGS])dnl
2050 cf_ncuhdr_root=ifelse($1,,ncurses,$1)
2051
2052 test -n "$cf_cv_curses_dir" && \
2053 test "$cf_cv_curses_dir" != "no" && { \
2054   CF_ADD_INCDIR($cf_cv_curses_dir/include $cf_cv_curses_dir/include/$cf_ncuhdr_root)
2055 }
2056
2057 AC_CACHE_CHECK(for $cf_ncuhdr_root header in include-path, cf_cv_ncurses_h,[
2058         cf_header_list="$cf_ncuhdr_root/curses.h $cf_ncuhdr_root/ncurses.h"
2059         ( test "$cf_ncuhdr_root" = ncurses || test "$cf_ncuhdr_root" = ncursesw ) && cf_header_list="$cf_header_list curses.h ncurses.h"
2060         for cf_header in $cf_header_list
2061         do
2062                 CF_NCURSES_CC_CHECK(cf_cv_ncurses_h,$cf_header,$1)
2063                 test "$cf_cv_ncurses_h" != no && break
2064         done
2065 ])
2066
2067 CF_NCURSES_HEADER
2068 CF_TERM_HEADER
2069
2070 # some applications need this, but should check for NCURSES_VERSION
2071 AC_DEFINE(NCURSES)
2072
2073 CF_NCURSES_VERSION
2074 ])dnl
2075 dnl ---------------------------------------------------------------------------
2076 dnl CF_NCURSES_HEADER version: 2 updated: 2008/03/23 14:48:54
2077 dnl -----------------
2078 dnl Find a "curses" header file, e.g,. "curses.h", or one of the more common
2079 dnl variations of ncurses' installs.
2080 dnl
2081 dnl See also CF_CURSES_HEADER, which sets the same cache variable.
2082 AC_DEFUN([CF_NCURSES_HEADER],[
2083
2084 if test "$cf_cv_ncurses_h" != no ; then
2085         cf_cv_ncurses_header=$cf_cv_ncurses_h
2086 else
2087
2088 AC_CACHE_CHECK(for $cf_ncuhdr_root include-path, cf_cv_ncurses_h2,[
2089         test -n "$verbose" && echo
2090         CF_HEADER_PATH(cf_search,$cf_ncuhdr_root)
2091         test -n "$verbose" && echo search path $cf_search
2092         cf_save2_CPPFLAGS="$CPPFLAGS"
2093         for cf_incdir in $cf_search
2094         do
2095                 CF_ADD_INCDIR($cf_incdir)
2096                 for cf_header in \
2097                         ncurses.h \
2098                         curses.h
2099                 do
2100                         CF_NCURSES_CC_CHECK(cf_cv_ncurses_h2,$cf_header,$1)
2101                         if test "$cf_cv_ncurses_h2" != no ; then
2102                                 cf_cv_ncurses_h2=$cf_incdir/$cf_header
2103                                 test -n "$verbose" && echo $ac_n "      ... found $ac_c" 1>&AC_FD_MSG
2104                                 break
2105                         fi
2106                         test -n "$verbose" && echo "    ... tested $cf_incdir/$cf_header" 1>&AC_FD_MSG
2107                 done
2108                 CPPFLAGS="$cf_save2_CPPFLAGS"
2109                 test "$cf_cv_ncurses_h2" != no && break
2110         done
2111         test "$cf_cv_ncurses_h2" = no && AC_MSG_ERROR(not found)
2112         ])
2113
2114         CF_DIRNAME(cf_1st_incdir,$cf_cv_ncurses_h2)
2115         cf_cv_ncurses_header=`basename $cf_cv_ncurses_h2`
2116         if test `basename $cf_1st_incdir` = $cf_ncuhdr_root ; then
2117                 cf_cv_ncurses_header=$cf_ncuhdr_root/$cf_cv_ncurses_header
2118         fi
2119         CF_ADD_INCDIR($cf_1st_incdir)
2120
2121 fi
2122
2123 # Set definitions to allow ifdef'ing for ncurses.h
2124
2125 case $cf_cv_ncurses_header in # (vi
2126 *ncurses.h)
2127         AC_DEFINE(HAVE_NCURSES_H)
2128         ;;
2129 esac
2130
2131 case $cf_cv_ncurses_header in # (vi
2132 ncurses/curses.h|ncurses/ncurses.h)
2133         AC_DEFINE(HAVE_NCURSES_NCURSES_H)
2134         ;;
2135 ncursesw/curses.h|ncursesw/ncurses.h)
2136         AC_DEFINE(HAVE_NCURSESW_NCURSES_H)
2137         ;;
2138 esac
2139
2140 ])dnl
2141 dnl ---------------------------------------------------------------------------
2142 dnl CF_NCURSES_LIBS version: 14 updated: 2010/06/20 09:24:28
2143 dnl ---------------
2144 dnl Look for the ncurses library.  This is a little complicated on Linux,
2145 dnl because it may be linked with the gpm (general purpose mouse) library.
2146 dnl Some distributions have gpm linked with (bsd) curses, which makes it
2147 dnl unusable with ncurses.  However, we don't want to link with gpm unless
2148 dnl ncurses has a dependency, since gpm is normally set up as a shared library,
2149 dnl and the linker will record a dependency.
2150 dnl
2151 dnl The optional parameter gives the root name of the library, in case it is
2152 dnl not installed as the default curses library.  That is how the
2153 dnl wide-character version of ncurses is installed.
2154 AC_DEFUN([CF_NCURSES_LIBS],
2155 [AC_REQUIRE([CF_NCURSES_CPPFLAGS])
2156
2157 cf_nculib_root=ifelse($1,,ncurses,$1)
2158         # This works, except for the special case where we find gpm, but
2159         # ncurses is in a nonstandard location via $LIBS, and we really want
2160         # to link gpm.
2161 cf_ncurses_LIBS=""
2162 cf_ncurses_SAVE="$LIBS"
2163 AC_CHECK_LIB(gpm,Gpm_Open,
2164         [AC_CHECK_LIB(gpm,initscr,
2165                 [LIBS="$cf_ncurses_SAVE"],
2166                 [cf_ncurses_LIBS="-lgpm"])])
2167
2168 case $host_os in #(vi
2169 freebsd*)
2170         # This is only necessary if you are linking against an obsolete
2171         # version of ncurses (but it should do no harm, since it's static).
2172         if test "$cf_nculib_root" = ncurses ; then
2173                 AC_CHECK_LIB(mytinfo,tgoto,[cf_ncurses_LIBS="-lmytinfo $cf_ncurses_LIBS"])
2174         fi
2175         ;;
2176 esac
2177
2178 CF_ADD_LIBS($cf_ncurses_LIBS)
2179
2180 if ( test -n "$cf_cv_curses_dir" && test "$cf_cv_curses_dir" != "no" )
2181 then
2182         CF_ADD_LIBDIR($cf_cv_curses_dir/lib)
2183         CF_ADD_LIBS(-l$cf_nculib_root)
2184 else
2185         CF_FIND_LIBRARY($cf_nculib_root,$cf_nculib_root,
2186                 [#include <${cf_cv_ncurses_header-curses.h}>],
2187                 [initscr()],
2188                 initscr)
2189 fi
2190
2191 if test -n "$cf_ncurses_LIBS" ; then
2192         AC_MSG_CHECKING(if we can link $cf_nculib_root without $cf_ncurses_LIBS)
2193         cf_ncurses_SAVE="$LIBS"
2194         for p in $cf_ncurses_LIBS ; do
2195                 q=`echo $LIBS | sed -e "s%$p %%" -e "s%$p$%%"`
2196                 if test "$q" != "$LIBS" ; then
2197                         LIBS="$q"
2198                 fi
2199         done
2200         AC_TRY_LINK([#include <${cf_cv_ncurses_header-curses.h}>],
2201                 [initscr(); mousemask(0,0); tgoto((char *)0, 0, 0);],
2202                 [AC_MSG_RESULT(yes)],
2203                 [AC_MSG_RESULT(no)
2204                  LIBS="$cf_ncurses_SAVE"])
2205 fi
2206
2207 CF_UPPER(cf_nculib_ROOT,HAVE_LIB$cf_nculib_root)
2208 AC_DEFINE_UNQUOTED($cf_nculib_ROOT)
2209 ])dnl
2210 dnl ---------------------------------------------------------------------------
2211 dnl CF_NCURSES_VERSION version: 12 updated: 2007/04/28 09:15:55
2212 dnl ------------------
2213 dnl Check for the version of ncurses, to aid in reporting bugs, etc.
2214 dnl Call CF_CURSES_CPPFLAGS first, or CF_NCURSES_CPPFLAGS.  We don't use
2215 dnl AC_REQUIRE since that does not work with the shell's if/then/else/fi.
2216 AC_DEFUN([CF_NCURSES_VERSION],
2217 [
2218 AC_REQUIRE([CF_CURSES_CPPFLAGS])dnl
2219 AC_CACHE_CHECK(for ncurses version, cf_cv_ncurses_version,[
2220         cf_cv_ncurses_version=no
2221         cf_tempfile=out$$
2222         rm -f $cf_tempfile
2223         AC_TRY_RUN([
2224 #include <${cf_cv_ncurses_header-curses.h}>
2225 #include <stdio.h>
2226 int main()
2227 {
2228         FILE *fp = fopen("$cf_tempfile", "w");
2229 #ifdef NCURSES_VERSION
2230 # ifdef NCURSES_VERSION_PATCH
2231         fprintf(fp, "%s.%d\n", NCURSES_VERSION, NCURSES_VERSION_PATCH);
2232 # else
2233         fprintf(fp, "%s\n", NCURSES_VERSION);
2234 # endif
2235 #else
2236 # ifdef __NCURSES_H
2237         fprintf(fp, "old\n");
2238 # else
2239         make an error
2240 # endif
2241 #endif
2242         ${cf_cv_main_return-return}(0);
2243 }],[
2244         cf_cv_ncurses_version=`cat $cf_tempfile`],,[
2245
2246         # This will not work if the preprocessor splits the line after the
2247         # Autoconf token.  The 'unproto' program does that.
2248         cat > conftest.$ac_ext <<EOF
2249 #include <${cf_cv_ncurses_header-curses.h}>
2250 #undef Autoconf
2251 #ifdef NCURSES_VERSION
2252 Autoconf NCURSES_VERSION
2253 #else
2254 #ifdef __NCURSES_H
2255 Autoconf "old"
2256 #endif
2257 ;
2258 #endif
2259 EOF
2260         cf_try="$ac_cpp conftest.$ac_ext 2>&AC_FD_CC | grep '^Autoconf ' >conftest.out"
2261         AC_TRY_EVAL(cf_try)
2262         if test -f conftest.out ; then
2263                 cf_out=`cat conftest.out | sed -e 's%^Autoconf %%' -e 's%^[[^"]]*"%%' -e 's%".*%%'`
2264                 test -n "$cf_out" && cf_cv_ncurses_version="$cf_out"
2265                 rm -f conftest.out
2266         fi
2267 ])
2268         rm -f $cf_tempfile
2269 ])
2270 test "$cf_cv_ncurses_version" = no || AC_DEFINE(NCURSES)
2271 ])dnl
2272 dnl ---------------------------------------------------------------------------
2273 dnl CF_NO_LEAKS_OPTION version: 4 updated: 2006/12/16 14:24:05
2274 dnl ------------------
2275 dnl see CF_WITH_NO_LEAKS
2276 AC_DEFUN([CF_NO_LEAKS_OPTION],[
2277 AC_MSG_CHECKING(if you want to use $1 for testing)
2278 AC_ARG_WITH($1,
2279         [$2],
2280         [AC_DEFINE($3)ifelse([$4],,[
2281          $4
2282 ])
2283         : ${with_cflags:=-g}
2284         : ${with_no_leaks:=yes}
2285          with_$1=yes],
2286         [with_$1=])
2287 AC_MSG_RESULT(${with_$1:-no})
2288
2289 case .$with_cflags in #(vi
2290 .*-g*)
2291         case .$CFLAGS in #(vi
2292         .*-g*) #(vi
2293                 ;;
2294         *)
2295                 CF_ADD_CFLAGS([-g])
2296                 ;;
2297         esac
2298         ;;
2299 esac
2300 ])dnl
2301 dnl ---------------------------------------------------------------------------
2302 dnl CF_NUMBER_SYNTAX version: 1 updated: 2003/09/20 18:12:49
2303 dnl ----------------
2304 dnl Check if the given variable is a number.  If not, report an error.
2305 dnl $1 is the variable
2306 dnl $2 is the message
2307 AC_DEFUN([CF_NUMBER_SYNTAX],[
2308 if test -n "$1" ; then
2309   case $1 in #(vi
2310   [[0-9]]*) #(vi
2311         ;;
2312   *)
2313         AC_MSG_ERROR($2 is not a number: $1)
2314         ;;
2315   esac
2316 else
2317   AC_MSG_ERROR($2 value is empty)
2318 fi
2319 ])dnl
2320 dnl ---------------------------------------------------------------------------
2321 dnl CF_OBJ_SUBDIR version: 4 updated: 2002/02/23 20:38:31
2322 dnl -------------
2323 dnl Compute the object-directory name from the given model name
2324 AC_DEFUN([CF_OBJ_SUBDIR],
2325 [
2326         case $1 in
2327         libtool) $2='obj_lo'  ;;
2328         normal)  $2='objects' ;;
2329         debug)   $2='obj_g' ;;
2330         profile) $2='obj_p' ;;
2331         shared)
2332                 case $cf_cv_system_name in #(vi
2333                 cygwin) #(vi
2334                         $2='objects' ;;
2335                 *)
2336                         $2='obj_s' ;;
2337                 esac
2338         esac
2339 ])dnl
2340 dnl ---------------------------------------------------------------------------
2341 dnl CF_PATHSEP version: 5 updated: 2010/05/26 05:38:42
2342 dnl ----------
2343 dnl Provide a value for the $PATH and similar separator
2344 AC_DEFUN([CF_PATHSEP],
2345 [
2346         case $cf_cv_system_name in
2347         os2*)   PATH_SEPARATOR=';'  ;;
2348         *)      PATH_SEPARATOR=':'  ;;
2349         esac
2350 ifelse([$1],,,[$1=$PATH_SEPARATOR])
2351         AC_SUBST(PATH_SEPARATOR)
2352 ])dnl
2353 dnl ---------------------------------------------------------------------------
2354 dnl CF_PATH_SYNTAX version: 13 updated: 2010/05/26 05:38:42
2355 dnl --------------
2356 dnl Check the argument to see that it looks like a pathname.  Rewrite it if it
2357 dnl begins with one of the prefix/exec_prefix variables, and then again if the
2358 dnl result begins with 'NONE'.  This is necessary to work around autoconf's
2359 dnl delayed evaluation of those symbols.
2360 AC_DEFUN([CF_PATH_SYNTAX],[
2361 if test "x$prefix" != xNONE; then
2362   cf_path_syntax="$prefix"
2363 else
2364   cf_path_syntax="$ac_default_prefix"
2365 fi
2366
2367 case ".[$]$1" in #(vi
2368 .\[$]\(*\)*|.\'*\'*) #(vi
2369   ;;
2370 ..|./*|.\\*) #(vi
2371   ;;
2372 .[[a-zA-Z]]:[[\\/]]*) #(vi OS/2 EMX
2373   ;;
2374 .\[$]{*prefix}*) #(vi
2375   eval $1="[$]$1"
2376   case ".[$]$1" in #(vi
2377   .NONE/*)
2378     $1=`echo [$]$1 | sed -e s%NONE%$cf_path_syntax%`
2379     ;;
2380   esac
2381   ;; #(vi
2382 .no|.NONE/*)
2383   $1=`echo [$]$1 | sed -e s%NONE%$cf_path_syntax%`
2384   ;;
2385 *)
2386   ifelse([$2],,[AC_MSG_ERROR([expected a pathname, not \"[$]$1\"])],$2)
2387   ;;
2388 esac
2389 ])dnl
2390 dnl ---------------------------------------------------------------------------
2391 dnl CF_PKG_CONFIG version: 3 updated: 2009/01/25 10:55:09
2392 dnl -------------
2393 dnl Check for the package-config program, unless disabled by command-line.
2394 AC_DEFUN([CF_PKG_CONFIG],
2395 [
2396 AC_MSG_CHECKING(if you want to use pkg-config)
2397 AC_ARG_WITH(pkg-config,
2398         [  --with-pkg-config{=path} enable/disable use of pkg-config],
2399         [cf_pkg_config=$withval],
2400         [cf_pkg_config=yes])
2401 AC_MSG_RESULT($cf_pkg_config)
2402
2403 case $cf_pkg_config in #(vi
2404 no) #(vi
2405         PKG_CONFIG=none
2406         ;;
2407 yes) #(vi
2408         AC_PATH_PROG(PKG_CONFIG, pkg-config, none)
2409         ;;
2410 *)
2411         PKG_CONFIG=$withval
2412         ;;
2413 esac
2414
2415 test -z "$PKG_CONFIG" && PKG_CONFIG=none
2416 if test "$PKG_CONFIG" != none ; then
2417         CF_PATH_SYNTAX(PKG_CONFIG)
2418 fi
2419
2420 AC_SUBST(PKG_CONFIG)
2421 ])dnl
2422 dnl ---------------------------------------------------------------------------
2423 dnl CF_POSIX_C_SOURCE version: 8 updated: 2010/05/26 05:38:42
2424 dnl -----------------
2425 dnl Define _POSIX_C_SOURCE to the given level, and _POSIX_SOURCE if needed.
2426 dnl
2427 dnl     POSIX.1-1990                            _POSIX_SOURCE
2428 dnl     POSIX.1-1990 and                        _POSIX_SOURCE and
2429 dnl             POSIX.2-1992 C-Language                 _POSIX_C_SOURCE=2
2430 dnl             Bindings Option
2431 dnl     POSIX.1b-1993                           _POSIX_C_SOURCE=199309L
2432 dnl     POSIX.1c-1996                           _POSIX_C_SOURCE=199506L
2433 dnl     X/Open 2000                             _POSIX_C_SOURCE=200112L
2434 dnl
2435 dnl Parameters:
2436 dnl     $1 is the nominal value for _POSIX_C_SOURCE
2437 AC_DEFUN([CF_POSIX_C_SOURCE],
2438 [
2439 cf_POSIX_C_SOURCE=ifelse([$1],,199506L,[$1])
2440
2441 cf_save_CFLAGS="$CFLAGS"
2442 cf_save_CPPFLAGS="$CPPFLAGS"
2443
2444 CF_REMOVE_DEFINE(cf_trim_CFLAGS,$cf_save_CFLAGS,_POSIX_C_SOURCE)
2445 CF_REMOVE_DEFINE(cf_trim_CPPFLAGS,$cf_save_CPPFLAGS,_POSIX_C_SOURCE)
2446
2447 AC_CACHE_CHECK(if we should define _POSIX_C_SOURCE,cf_cv_posix_c_source,[
2448         CF_MSG_LOG(if the symbol is already defined go no further)
2449         AC_TRY_COMPILE([#include <sys/types.h>],[
2450 #ifndef _POSIX_C_SOURCE
2451 make an error
2452 #endif],
2453         [cf_cv_posix_c_source=no],
2454         [cf_want_posix_source=no
2455          case .$cf_POSIX_C_SOURCE in #(vi
2456          .[[12]]??*) #(vi
2457                 cf_cv_posix_c_source="-D_POSIX_C_SOURCE=$cf_POSIX_C_SOURCE"
2458                 ;;
2459          .2) #(vi
2460                 cf_cv_posix_c_source="-D_POSIX_C_SOURCE=$cf_POSIX_C_SOURCE"
2461                 cf_want_posix_source=yes
2462                 ;;
2463          .*)
2464                 cf_want_posix_source=yes
2465                 ;;
2466          esac
2467          if test "$cf_want_posix_source" = yes ; then
2468                 AC_TRY_COMPILE([#include <sys/types.h>],[
2469 #ifdef _POSIX_SOURCE
2470 make an error
2471 #endif],[],
2472                 cf_cv_posix_c_source="$cf_cv_posix_c_source -D_POSIX_SOURCE")
2473          fi
2474          CF_MSG_LOG(ifdef from value $cf_POSIX_C_SOURCE)
2475          CFLAGS="$cf_trim_CFLAGS"
2476          CPPFLAGS="$cf_trim_CPPFLAGS $cf_cv_posix_c_source"
2477          CF_MSG_LOG(if the second compile does not leave our definition intact error)
2478          AC_TRY_COMPILE([#include <sys/types.h>],[
2479 #ifndef _POSIX_C_SOURCE
2480 make an error
2481 #endif],,
2482          [cf_cv_posix_c_source=no])
2483          CFLAGS="$cf_save_CFLAGS"
2484          CPPFLAGS="$cf_save_CPPFLAGS"
2485         ])
2486 ])
2487
2488 if test "$cf_cv_posix_c_source" != no ; then
2489         CFLAGS="$cf_trim_CFLAGS"
2490         CPPFLAGS="$cf_trim_CPPFLAGS"
2491         CF_ADD_CFLAGS($cf_cv_posix_c_source)
2492 fi
2493
2494 ])dnl
2495 dnl ---------------------------------------------------------------------------
2496 dnl CF_PROG_AR version: 1 updated: 2009/01/01 20:15:22
2497 dnl ----------
2498 dnl Check for archiver "ar".
2499 AC_DEFUN([CF_PROG_AR],[
2500 AC_CHECK_TOOL(AR, ar, ar)
2501 ])
2502 dnl ---------------------------------------------------------------------------
2503 dnl CF_PROG_AWK version: 1 updated: 2006/09/16 11:40:59
2504 dnl -----------
2505 dnl Check for awk, ensure that the check found something.
2506 AC_DEFUN([CF_PROG_AWK],
2507 [
2508 AC_PROG_AWK
2509 test -z "$AWK" && AC_MSG_ERROR(No awk program found)
2510 ])dnl
2511 dnl ---------------------------------------------------------------------------
2512 dnl CF_PROG_CC_C_O version: 3 updated: 2010/08/14 18:25:37
2513 dnl --------------
2514 dnl Analogous to AC_PROG_CC_C_O, but more useful: tests only $CC, ensures that
2515 dnl the output file can be renamed, and allows for a shell variable that can
2516 dnl be used later.  The parameter is either CC or CXX.  The result is the
2517 dnl cache variable:
2518 dnl     $cf_cv_prog_CC_c_o
2519 dnl     $cf_cv_prog_CXX_c_o
2520 AC_DEFUN([CF_PROG_CC_C_O],
2521 [AC_REQUIRE([AC_PROG_CC])dnl
2522 AC_MSG_CHECKING([whether [$]$1 understands -c and -o together])
2523 AC_CACHE_VAL(cf_cv_prog_$1_c_o,
2524 [
2525 cat > conftest.$ac_ext <<CF_EOF
2526 #include <stdio.h>
2527 int main()
2528 {
2529         ${cf_cv_main_return:-return}(0);
2530 }
2531 CF_EOF
2532 # We do the test twice because some compilers refuse to overwrite an
2533 # existing .o file with -o, though they will create one.
2534 ac_try='[$]$1 -c conftest.$ac_ext -o conftest2.$ac_objext >&AC_FD_CC'
2535 if AC_TRY_EVAL(ac_try) &&
2536   test -f conftest2.$ac_objext && AC_TRY_EVAL(ac_try);
2537 then
2538   eval cf_cv_prog_$1_c_o=yes
2539 else
2540   eval cf_cv_prog_$1_c_o=no
2541 fi
2542 rm -rf conftest*
2543 ])dnl
2544 if test $cf_cv_prog_$1_c_o = yes; then
2545   AC_MSG_RESULT([yes])
2546 else
2547   AC_MSG_RESULT([no])
2548 fi
2549 ])dnl
2550 dnl ---------------------------------------------------------------------------
2551 dnl CF_PROG_EGREP version: 1 updated: 2006/09/16 11:40:59
2552 dnl -------------
2553 dnl AC_PROG_EGREP was introduced in autoconf 2.53.
2554 dnl This macro adds a check to ensure the script found something.
2555 AC_DEFUN([CF_PROG_EGREP],
2556 [AC_CACHE_CHECK([for egrep], [ac_cv_prog_egrep],
2557    [if echo a | (grep -E '(a|b)') >/dev/null 2>&1
2558     then ac_cv_prog_egrep='grep -E'
2559     else ac_cv_prog_egrep='egrep'
2560     fi])
2561  EGREP=$ac_cv_prog_egrep
2562  AC_SUBST([EGREP])
2563 test -z "$EGREP" && AC_MSG_ERROR(No egrep program found)
2564 ])dnl
2565 dnl ---------------------------------------------------------------------------
2566 dnl CF_PROG_EXT version: 10 updated: 2004/01/03 19:28:18
2567 dnl -----------
2568 dnl Compute $PROG_EXT, used for non-Unix ports, such as OS/2 EMX.
2569 AC_DEFUN([CF_PROG_EXT],
2570 [
2571 AC_REQUIRE([CF_CHECK_CACHE])
2572 case $cf_cv_system_name in
2573 os2*)
2574     CFLAGS="$CFLAGS -Zmt"
2575     CPPFLAGS="$CPPFLAGS -D__ST_MT_ERRNO__"
2576     CXXFLAGS="$CXXFLAGS -Zmt"
2577     # autoconf's macro sets -Zexe and suffix both, which conflict:w
2578     LDFLAGS="$LDFLAGS -Zmt -Zcrtdll"
2579     ac_cv_exeext=.exe
2580     ;;
2581 esac
2582
2583 AC_EXEEXT
2584 AC_OBJEXT
2585
2586 PROG_EXT="$EXEEXT"
2587 AC_SUBST(PROG_EXT)
2588 test -n "$PROG_EXT" && AC_DEFINE_UNQUOTED(PROG_EXT,"$PROG_EXT")
2589 ])dnl
2590 dnl ---------------------------------------------------------------------------
2591 dnl CF_PROG_GNAT version: 1 updated: 2010/06/19 15:22:18
2592 dnl ------------
2593 dnl Check for gnatmake, ensure that it is complete.
2594 AC_DEFUN([CF_PROG_GNAT],[
2595 cf_ada_make=gnatmake
2596 AC_CHECK_PROG(gnat_exists, $cf_ada_make, yes, no)
2597 if test "$ac_cv_prog_gnat_exists" = no; then
2598    cf_ada_make=
2599 else
2600    CF_GNAT_VERSION
2601    AC_CHECK_PROG(M4_exists, m4, yes, no)
2602    if test "$ac_cv_prog_M4_exists" = no; then
2603       cf_cv_prog_gnat_correct=no
2604       echo Ada95 binding required program m4 not found. Ada95 binding disabled.
2605    fi
2606    if test "$cf_cv_prog_gnat_correct" = yes; then
2607       AC_MSG_CHECKING(if GNAT works)
2608       CF_GNAT_TRY_RUN([procedure conftest;],
2609 [with Text_IO;
2610 with GNAT.OS_Lib;
2611 procedure conftest is
2612 begin
2613    Text_IO.Put ("Hello World");
2614    Text_IO.New_Line;
2615    GNAT.OS_Lib.OS_Exit (0);
2616 end conftest;],[cf_cv_prog_gnat_correct=yes],[cf_cv_prog_gnat_correct=no])
2617       AC_MSG_RESULT($cf_cv_prog_gnat_correct)
2618    fi
2619 fi
2620
2621 AC_SUBST(cf_ada_make)
2622 ])dnl
2623 dnl ---------------------------------------------------------------------------
2624 dnl CF_PROG_LN_S version: 2 updated: 2010/08/14 18:25:37
2625 dnl ------------
2626 dnl Combine checks for "ln -s" and "ln -sf", updating $LN_S to include "-f"
2627 dnl option if it is supported.
2628 AC_DEFUN([CF_PROG_LN_S],[
2629 AC_PROG_LN_S
2630 AC_MSG_CHECKING(if $LN_S -f options work)
2631
2632 rm -f conf$$.src conf$$dst
2633 echo >conf$$.dst
2634 echo first >conf$$.src
2635 if $LN_S -f conf$$.src conf$$.dst 2>/dev/null; then
2636         cf_prog_ln_sf=yes
2637 else
2638         cf_prog_ln_sf=no
2639 fi
2640 rm -f conf$$.dst conf$$src
2641 AC_MSG_RESULT($cf_prog_ln_sf)
2642
2643 test "$cf_prog_ln_sf" = yes && LN_S="$LN_S -f"
2644 ])dnl
2645 dnl ---------------------------------------------------------------------------
2646 dnl CF_REMOVE_DEFINE version: 3 updated: 2010/01/09 11:05:50
2647 dnl ----------------
2648 dnl Remove all -U and -D options that refer to the given symbol from a list
2649 dnl of C compiler options.  This works around the problem that not all
2650 dnl compilers process -U and -D options from left-to-right, so a -U option
2651 dnl cannot be used to cancel the effect of a preceding -D option.
2652 dnl
2653 dnl $1 = target (which could be the same as the source variable)
2654 dnl $2 = source (including '$')
2655 dnl $3 = symbol to remove
2656 define([CF_REMOVE_DEFINE],
2657 [
2658 $1=`echo "$2" | \
2659         sed     -e 's/-[[UD]]'"$3"'\(=[[^       ]]*\)\?[[       ]]/ /g' \
2660                 -e 's/-[[UD]]'"$3"'\(=[[^       ]]*\)\?[$]//g'`
2661 ])dnl
2662 dnl ---------------------------------------------------------------------------
2663 dnl CF_REMOVE_LIB version: 1 updated: 2007/02/17 14:11:52
2664 dnl -------------
2665 dnl Remove the given library from the symbol
2666 dnl
2667 dnl $1 = target (which could be the same as the source variable)
2668 dnl $2 = source (including '$')
2669 dnl $3 = library to remove
2670 define([CF_REMOVE_LIB],
2671 [
2672 # remove $3 library from $2
2673 $1=`echo "$2" | sed -e 's/-l$3[[        ]]//g' -e 's/-l$3[$]//'`
2674 ])dnl
2675 dnl ---------------------------------------------------------------------------
2676 dnl CF_SHARED_OPTS version: 64 updated: 2010/06/05 16:51:16
2677 dnl --------------
2678 dnl --------------
2679 dnl Attempt to determine the appropriate CC/LD options for creating a shared
2680 dnl library.
2681 dnl
2682 dnl Note: ${LOCAL_LDFLAGS} is used to link executables that will run within the
2683 dnl build-tree, i.e., by making use of the libraries that are compiled in ../lib
2684 dnl We avoid compiling-in a ../lib path for the shared library since that can
2685 dnl lead to unexpected results at runtime.
2686 dnl ${LOCAL_LDFLAGS2} has the same intention but assumes that the shared libraries
2687 dnl are compiled in ../../lib
2688 dnl
2689 dnl The variable 'cf_cv_do_symlinks' is used to control whether we configure
2690 dnl to install symbolic links to the rel/abi versions of shared libraries.
2691 dnl
2692 dnl The variable 'cf_cv_shlib_version' controls whether we use the rel or abi
2693 dnl version when making symbolic links.
2694 dnl
2695 dnl The variable 'cf_cv_shlib_version_infix' controls whether shared library
2696 dnl version numbers are infix (ex: libncurses.<ver>.dylib) or postfix
2697 dnl (ex: libncurses.so.<ver>).
2698 dnl
2699 dnl Some loaders leave 'so_locations' lying around.  It's nice to clean up.
2700 AC_DEFUN([CF_SHARED_OPTS],
2701 [
2702         AC_REQUIRE([CF_SUBST_NCURSES_VERSION])
2703         AC_REQUIRE([CF_LD_RPATH_OPT])
2704         LOCAL_LDFLAGS=
2705         LOCAL_LDFLAGS2=
2706         LD_SHARED_OPTS=
2707         INSTALL_LIB="-m 644"
2708
2709         cf_cv_do_symlinks=no
2710         cf_ld_rpath_opt=
2711         test "$cf_cv_enable_rpath" = yes && cf_ld_rpath_opt="$LD_RPATH_OPT"
2712
2713         AC_MSG_CHECKING(if release/abi version should be used for shared libs)
2714         AC_ARG_WITH(shlib-version,
2715         [  --with-shlib-version=X  Specify rel or abi version for shared libs],
2716         [test -z "$withval" && withval=auto
2717         case $withval in #(vi
2718         yes) #(vi
2719                 cf_cv_shlib_version=auto
2720                 ;;
2721         rel|abi|auto|no) #(vi
2722                 cf_cv_shlib_version=$withval
2723                 ;;
2724         *)
2725                 AC_MSG_ERROR([option value must be one of: rel, abi, auto or no])
2726                 ;;
2727         esac
2728         ],[cf_cv_shlib_version=auto])
2729         AC_MSG_RESULT($cf_cv_shlib_version)
2730
2731         cf_cv_rm_so_locs=no
2732
2733         # Some less-capable ports of gcc support only -fpic
2734         CC_SHARED_OPTS=
2735         if test "$GCC" = yes
2736         then
2737                 AC_MSG_CHECKING(which $CC option to use)
2738                 cf_save_CFLAGS="$CFLAGS"
2739                 for CC_SHARED_OPTS in -fPIC -fpic ''
2740                 do
2741                         CFLAGS="$cf_save_CFLAGS $CC_SHARED_OPTS"
2742                         AC_TRY_COMPILE([#include <stdio.h>],[int x = 1],[break],[])
2743                 done
2744                 AC_MSG_RESULT($CC_SHARED_OPTS)
2745                 CFLAGS="$cf_save_CFLAGS"
2746         fi
2747
2748         cf_cv_shlib_version_infix=no
2749
2750         case $cf_cv_system_name in #(vi
2751         aix[[56]]*) #(vi
2752                 if test "$GCC" = yes; then
2753                         CC_SHARED_OPTS=
2754                         MK_SHARED_LIB='$(CC) -shared'
2755                 fi
2756                 ;;
2757         beos*) #(vi
2758                 MK_SHARED_LIB='${CC} ${CFLAGS} -o $[@] -Xlinker -soname=`basename $[@]` -nostart -e 0'
2759                 ;;
2760         cygwin*) #(vi
2761                 CC_SHARED_OPTS=
2762                 MK_SHARED_LIB='sh ../mk_shared_lib.sh [$]@ [$]{CC} [$]{CFLAGS}'
2763                 cf_cv_shlib_version=cygdll
2764                 cf_cv_shlib_version_infix=cygdll
2765                 cat >mk_shared_lib.sh <<-CF_EOF
2766                 #!/bin/sh
2767                 SHARED_LIB=\[$]1
2768                 IMPORT_LIB=\`echo "\[$]1" | sed -e 's/cyg/lib/' -e 's/[[0-9]]*\.dll[$]/.dll.a/'\`
2769                 shift
2770                 cat <<-EOF
2771                 Linking shared library
2772                 ** SHARED_LIB \[$]SHARED_LIB
2773                 ** IMPORT_LIB \[$]IMPORT_LIB
2774 EOF
2775                 exec \[$]* -shared -Wl,--out-implib=../lib/\[$]{IMPORT_LIB} -Wl,--export-all-symbols -o ../lib/\[$]{SHARED_LIB}
2776 CF_EOF
2777                 chmod +x mk_shared_lib.sh
2778                 ;;
2779         darwin*) #(vi
2780                 EXTRA_CFLAGS="-no-cpp-precomp"
2781                 CC_SHARED_OPTS="-dynamic"
2782                 MK_SHARED_LIB='${CC} ${CFLAGS} -dynamiclib -install_name ${libdir}/`basename $[@]` -compatibility_version ${ABI_VERSION} -current_version ${ABI_VERSION} -o $[@]'
2783                 test "$cf_cv_shlib_version" = auto && cf_cv_shlib_version=abi
2784                 cf_cv_shlib_version_infix=yes
2785                 AC_CACHE_CHECK([if ld -search_paths_first works], cf_cv_ldflags_search_paths_first, [
2786                         cf_save_LDFLAGS=$LDFLAGS
2787                         LDFLAGS="$LDFLAGS -Wl,-search_paths_first"
2788                         AC_TRY_LINK(, [int i;], cf_cv_ldflags_search_paths_first=yes, cf_cv_ldflags_search_paths_first=no)
2789                                 LDFLAGS=$cf_save_LDFLAGS])
2790                 if test $cf_cv_ldflags_search_paths_first = yes; then
2791                         LDFLAGS="$LDFLAGS -Wl,-search_paths_first"
2792                 fi
2793                 ;;
2794         hpux*) #(vi
2795                 # (tested with gcc 2.7.2 -- I don't have c89)
2796                 if test "$GCC" = yes; then
2797                         LD_SHARED_OPTS='-Xlinker +b -Xlinker ${libdir}'
2798                 else
2799                         CC_SHARED_OPTS='+Z'
2800                         LD_SHARED_OPTS='-Wl,+b,${libdir}'
2801                 fi
2802                 MK_SHARED_LIB='${LD} +b ${libdir} -b -o $[@]'
2803                 # HP-UX shared libraries must be executable, and should be
2804                 # readonly to exploit a quirk in the memory manager.
2805                 INSTALL_LIB="-m 555"
2806                 ;;
2807         irix*) #(vi
2808                 if test "$cf_cv_enable_rpath" = yes ; then
2809                         EXTRA_LDFLAGS="${cf_ld_rpath_opt}\${libdir} $EXTRA_LDFLAGS"
2810                 fi
2811                 # tested with IRIX 5.2 and 'cc'.
2812                 if test "$GCC" != yes; then
2813                         CC_SHARED_OPTS='-KPIC'
2814                         MK_SHARED_LIB='${CC} -shared -rdata_shared -soname `basename $[@]` -o $[@]'
2815                 else
2816                         MK_SHARED_LIB='${CC} -shared -Wl,-soname,`basename $[@]` -o $[@]'
2817                 fi
2818                 cf_cv_rm_so_locs=yes
2819                 ;;
2820         linux*|gnu*|k*bsd*-gnu) #(vi
2821                 if test "$DFT_LWR_MODEL" = "shared" ; then
2822                         LOCAL_LDFLAGS="${LD_RPATH_OPT}\$(LOCAL_LIBDIR)"
2823                         LOCAL_LDFLAGS2="$LOCAL_LDFLAGS"
2824                 fi
2825                 if test "$cf_cv_enable_rpath" = yes ; then
2826                         EXTRA_LDFLAGS="${cf_ld_rpath_opt}\${libdir} $EXTRA_LDFLAGS"
2827                 fi
2828                 CF_SHARED_SONAME
2829                 MK_SHARED_LIB='${CC} ${CFLAGS} -shared -Wl,-soname,'$cf_cv_shared_soname',-stats,-lc -o $[@]'
2830                 ;;
2831         openbsd[[2-9]].*) #(vi
2832                 if test "$DFT_LWR_MODEL" = "shared" ; then
2833                         LOCAL_LDFLAGS="${LD_RPATH_OPT}\$(LOCAL_LIBDIR)"
2834                         LOCAL_LDFLAGS2="$LOCAL_LDFLAGS"
2835                 fi
2836                 if test "$cf_cv_enable_rpath" = yes ; then
2837                         EXTRA_LDFLAGS="${cf_ld_rpath_opt}\${libdir} $EXTRA_LDFLAGS"
2838                 fi
2839                 CC_SHARED_OPTS="$CC_SHARED_OPTS -DPIC"
2840                 CF_SHARED_SONAME
2841                 MK_SHARED_LIB='${CC} ${CFLAGS} -shared -Wl,-Bshareable,-soname,'$cf_cv_shared_soname',-stats,-lc -o $[@]'
2842                 ;;
2843         nto-qnx*|openbsd*|freebsd[[12]].*) #(vi
2844                 CC_SHARED_OPTS="$CC_SHARED_OPTS -DPIC"
2845                 MK_SHARED_LIB='${LD} -Bshareable -o $[@]'
2846                 test "$cf_cv_shlib_version" = auto && cf_cv_shlib_version=rel
2847                 ;;
2848         freebsd*) #(vi
2849                 CC_SHARED_OPTS="$CC_SHARED_OPTS -DPIC"
2850                 if test "$DFT_LWR_MODEL" = "shared" && test "$cf_cv_enable_rpath" = yes ; then
2851                         LOCAL_LDFLAGS="${cf_ld_rpath_opt}\$(LOCAL_LIBDIR)"
2852                         LOCAL_LDFLAGS2="${cf_ld_rpath_opt}\${libdir} $LOCAL_LDFLAGS"
2853                         EXTRA_LDFLAGS="${cf_ld_rpath_opt}\${libdir} $EXTRA_LDFLAGS"
2854                 fi
2855                 CF_SHARED_SONAME
2856                 MK_SHARED_LIB='${LD} -shared -Bshareable -soname=`basename $[@]` -o $[@]'
2857                 ;;
2858         netbsd*) #(vi
2859                 CC_SHARED_OPTS="$CC_SHARED_OPTS -DPIC"
2860                 if test "$DFT_LWR_MODEL" = "shared" && test "$cf_cv_enable_rpath" = yes ; then
2861                         LOCAL_LDFLAGS="${cf_ld_rpath_opt}\$(LOCAL_LIBDIR)"
2862                         LOCAL_LDFLAGS2="$LOCAL_LDFLAGS"
2863                         EXTRA_LDFLAGS="${cf_ld_rpath_opt}\${libdir} $EXTRA_LDFLAGS"
2864                         if test "$cf_cv_shlib_version" = auto; then
2865                         if test -f /usr/libexec/ld.elf_so; then
2866                                 cf_cv_shlib_version=abi
2867                         else
2868                                 cf_cv_shlib_version=rel
2869                         fi
2870                         fi
2871                         CF_SHARED_SONAME
2872                         MK_SHARED_LIB='${CC} ${CFLAGS} -shared -Wl,-soname,'$cf_cv_shared_soname' -o $[@]'
2873                 else
2874                         MK_SHARED_LIB='${LD} -shared -Bshareable -o $[@]'
2875                 fi
2876                 ;;
2877         osf*|mls+*) #(vi
2878                 # tested with OSF/1 V3.2 and 'cc'
2879                 # tested with OSF/1 V3.2 and gcc 2.6.3 (but the c++ demo didn't
2880                 # link with shared libs).
2881                 MK_SHARED_LIB='${LD} -set_version ${REL_VERSION}:${ABI_VERSION} -expect_unresolved "*" -shared -soname `basename $[@]`'
2882                 case $host_os in #(vi
2883                 osf4*)
2884                         MK_SHARED_LIB="${MK_SHARED_LIB} -msym"
2885                         ;;
2886                 esac
2887                 MK_SHARED_LIB="${MK_SHARED_LIB}"' -o $[@]'
2888                 if test "$DFT_LWR_MODEL" = "shared" ; then
2889                         LOCAL_LDFLAGS="${LD_RPATH_OPT}\$(LOCAL_LIBDIR)"
2890                         LOCAL_LDFLAGS2="$LOCAL_LDFLAGS"
2891                 fi
2892                 cf_cv_rm_so_locs=yes
2893                 ;;
2894         sco3.2v5*)  # (also uw2* and UW7: hops 13-Apr-98
2895                 # tested with osr5.0.5
2896                 if test "$GCC" != yes; then
2897                         CC_SHARED_OPTS='-belf -KPIC'
2898                 fi
2899                 MK_SHARED_LIB='${LD} -dy -G -h `basename $[@] .${REL_VERSION}`.${ABI_VERSION} -o [$]@'
2900                 if test "$cf_cv_enable_rpath" = yes ; then
2901                         # only way is to set LD_RUN_PATH but no switch for it
2902                         RUN_PATH=$libdir
2903                 fi
2904                 test "$cf_cv_shlib_version" = auto && cf_cv_shlib_version=rel
2905                 LINK_PROGS='LD_RUN_PATH=${libdir}'
2906                 LINK_TESTS='Pwd=`pwd`;LD_RUN_PATH=`dirname $${Pwd}`/lib'
2907                 ;;
2908         sunos4*) #(vi
2909                 # tested with SunOS 4.1.1 and gcc 2.7.0
2910                 if test "$GCC" != yes; then
2911                         CC_SHARED_OPTS='-KPIC'
2912                 fi
2913                 MK_SHARED_LIB='${LD} -assert pure-text -o $[@]'
2914                 test "$cf_cv_shlib_version" = auto && cf_cv_shlib_version=rel
2915                 ;;
2916         solaris2*) #(vi
2917                 # tested with SunOS 5.5.1 (solaris 2.5.1) and gcc 2.7.2
2918                 # tested with SunOS 5.10 (solaris 10) and gcc 3.4.3
2919                 if test "$DFT_LWR_MODEL" = "shared" ; then
2920                         LOCAL_LDFLAGS="-R \$(LOCAL_LIBDIR):\${libdir}"
2921                         LOCAL_LDFLAGS2="$LOCAL_LDFLAGS"
2922                 fi
2923                 if test "$cf_cv_enable_rpath" = yes ; then
2924                         EXTRA_LDFLAGS="-R \${libdir} $EXTRA_LDFLAGS"
2925                 fi
2926                 CF_SHARED_SONAME
2927                 if test "$GCC" != yes; then
2928                         cf_save_CFLAGS="$CFLAGS"
2929                         for cf_shared_opts in -xcode=pic32 -xcode=pic13 -KPIC -Kpic -O
2930                         do
2931                                 CFLAGS="$cf_shared_opts $cf_save_CFLAGS"
2932                                 AC_TRY_COMPILE([#include <stdio.h>],[printf("Hello\n");],[break])
2933                         done
2934                         CFLAGS="$cf_save_CFLAGS"
2935                         CC_SHARED_OPTS=$cf_shared_opts
2936                         MK_SHARED_LIB='${CC} -dy -G -h '$cf_cv_shared_soname' -o $[@]'
2937                 else
2938                         MK_SHARED_LIB='${CC} -shared -dy -G -h '$cf_cv_shared_soname' -o $[@]'
2939                 fi
2940                 ;;
2941         sysv5uw7*|unix_sv*) #(vi
2942                 # tested with UnixWare 7.1.0 (gcc 2.95.2 and cc)
2943                 if test "$GCC" != yes; then
2944                         CC_SHARED_OPTS='-KPIC'
2945                 fi
2946                 MK_SHARED_LIB='${LD} -d y -G -o [$]@'
2947                 ;;
2948         *)
2949                 CC_SHARED_OPTS='unknown'
2950                 MK_SHARED_LIB='echo unknown'
2951                 ;;
2952         esac
2953
2954         # This works if the last tokens in $MK_SHARED_LIB are the -o target.
2955         case "$cf_cv_shlib_version" in #(vi
2956         rel|abi)
2957                 case "$MK_SHARED_LIB" in #(vi
2958                 *'-o $[@]') #(vi
2959                         test "$cf_cv_do_symlinks" = no && cf_cv_do_symlinks=yes
2960                         ;;
2961                 *)
2962                         AC_MSG_WARN(ignored --with-shlib-version)
2963                         ;;
2964                 esac
2965                 ;;
2966         esac
2967
2968         if test -n "$cf_ld_rpath_opt" ; then
2969                 MK_SHARED_LIB="$MK_SHARED_LIB $cf_ld_rpath_opt\${libdir}"
2970         fi
2971
2972         AC_SUBST(CC_SHARED_OPTS)
2973         AC_SUBST(LD_RPATH_OPT)
2974         AC_SUBST(LD_SHARED_OPTS)
2975         AC_SUBST(MK_SHARED_LIB)
2976         AC_SUBST(LINK_PROGS)
2977         AC_SUBST(LINK_TESTS)
2978         AC_SUBST(EXTRA_LDFLAGS)
2979         AC_SUBST(LOCAL_LDFLAGS)
2980         AC_SUBST(LOCAL_LDFLAGS2)
2981         AC_SUBST(INSTALL_LIB)
2982 ])dnl
2983 dnl ---------------------------------------------------------------------------
2984 dnl CF_SHARED_SONAME version: 3 updated: 2008/09/08 18:34:43
2985 dnl ----------------
2986 dnl utility macro for CF_SHARED_OPTS, constructs "$cf_cv_shared_soname" for
2987 dnl substitution into MK_SHARED_LIB string for the "-soname" (or similar)
2988 dnl option.
2989 dnl
2990 dnl $1 is the default that should be used for "$cf_cv_shlib_version".
2991 dnl If missing, use "rel".
2992 define([CF_SHARED_SONAME],
2993 [
2994         test "$cf_cv_shlib_version" = auto && cf_cv_shlib_version=ifelse($1,,rel,$1)
2995         if test "$cf_cv_shlib_version" = rel; then
2996                 cf_cv_shared_soname='`basename $[@] .${REL_VERSION}`.${ABI_VERSION}'
2997         else
2998                 cf_cv_shared_soname='`basename $[@]`'
2999         fi
3000 ])
3001 dnl ---------------------------------------------------------------------------
3002 dnl CF_STRIP_G_OPT version: 3 updated: 2002/12/21 19:25:52
3003 dnl --------------
3004 dnl     Remove "-g" option from the compiler options
3005 AC_DEFUN([CF_STRIP_G_OPT],
3006 [$1=`echo ${$1} | sed -e 's%-g %%' -e 's%-g$%%'`])dnl
3007 dnl ---------------------------------------------------------------------------
3008 dnl CF_SUBDIR_PATH version: 6 updated: 2010/04/21 06:20:50
3009 dnl --------------
3010 dnl Construct a search-list for a nonstandard header/lib-file
3011 dnl     $1 = the variable to return as result
3012 dnl     $2 = the package name
3013 dnl     $3 = the subdirectory, e.g., bin, include or lib
3014 AC_DEFUN([CF_SUBDIR_PATH],
3015 [
3016 $1=
3017
3018 CF_ADD_SUBDIR_PATH($1,$2,$3,/usr,$prefix)
3019 CF_ADD_SUBDIR_PATH($1,$2,$3,$prefix,NONE)
3020 CF_ADD_SUBDIR_PATH($1,$2,$3,/usr/local,$prefix)
3021 CF_ADD_SUBDIR_PATH($1,$2,$3,/opt,$prefix)
3022 CF_ADD_SUBDIR_PATH($1,$2,$3,[$]HOME,$prefix)
3023 ])dnl
3024 dnl ---------------------------------------------------------------------------
3025 dnl CF_SUBST version: 4 updated: 2006/06/17 12:33:03
3026 dnl --------
3027 dnl     Shorthand macro for substituting things that the user may override
3028 dnl     with an environment variable.
3029 dnl
3030 dnl     $1 = long/descriptive name
3031 dnl     $2 = environment variable
3032 dnl     $3 = default value
3033 AC_DEFUN([CF_SUBST],
3034 [AC_CACHE_VAL(cf_cv_subst_$2,[
3035 AC_MSG_CHECKING(for $1 (symbol $2))
3036 CF_SUBST_IF([-z "[$]$2"], [$2], [$3])
3037 cf_cv_subst_$2=[$]$2
3038 AC_MSG_RESULT([$]$2)
3039 ])
3040 ])dnl
3041 dnl ---------------------------------------------------------------------------
3042 dnl CF_TERM_HEADER version: 1 updated: 2005/12/31 13:26:39
3043 dnl --------------
3044 dnl Look for term.h, which is part of X/Open curses.  It defines the interface
3045 dnl to terminfo database.  Usually it is in the same include-path as curses.h,
3046 dnl but some packagers change this, breaking various applications.
3047 AC_DEFUN([CF_TERM_HEADER],[
3048 AC_CACHE_CHECK(for terminfo header, cf_cv_term_header,[
3049 case ${cf_cv_ncurses_header} in #(vi
3050 */ncurses.h|*/ncursesw.h) #(vi
3051         cf_term_header=`echo "$cf_cv_ncurses_header" | sed -e 's%ncurses[[^.]]*\.h$%term.h%'`
3052         ;;
3053 *)
3054         cf_term_header=term.h
3055         ;;
3056 esac
3057
3058 for cf_test in $cf_term_header "ncurses/term.h" "ncursesw/term.h"
3059 do
3060 AC_TRY_COMPILE([#include <stdio.h>
3061 #include <${cf_cv_ncurses_header-curses.h}>
3062 #include <$cf_test>
3063 ],[int x = auto_left_margin],[
3064         cf_cv_term_header="$cf_test"],[
3065         cf_cv_term_header=unknown
3066         ])
3067         test "$cf_cv_term_header" != unknown && break
3068 done
3069 ])
3070
3071 # Set definitions to allow ifdef'ing to accommodate subdirectories
3072
3073 case $cf_cv_term_header in # (vi
3074 *term.h)
3075         AC_DEFINE(HAVE_TERM_H)
3076         ;;
3077 esac
3078
3079 case $cf_cv_term_header in # (vi
3080 ncurses/term.h) #(vi
3081         AC_DEFINE(HAVE_NCURSES_TERM_H)
3082         ;;
3083 ncursesw/term.h)
3084         AC_DEFINE(HAVE_NCURSESW_TERM_H)
3085         ;;
3086 esac
3087 ])dnl
3088 dnl ---------------------------------------------------------------------------
3089 dnl CF_TOP_BUILDDIR version: 1 updated: 2006/10/15 16:33:23
3090 dnl ---------------
3091 dnl Define a top_builddir symbol, for applications that need an absolute path.
3092 AC_DEFUN([CF_TOP_BUILDDIR],
3093 [
3094 top_builddir=`pwd`
3095 AC_SUBST(top_builddir)
3096 ])dnl
3097 dnl ---------------------------------------------------------------------------
3098 dnl CF_UPPER version: 5 updated: 2001/01/29 23:40:59
3099 dnl --------
3100 dnl Make an uppercase version of a variable
3101 dnl $1=uppercase($2)
3102 AC_DEFUN([CF_UPPER],
3103 [
3104 $1=`echo "$2" | sed y%abcdefghijklmnopqrstuvwxyz./-%ABCDEFGHIJKLMNOPQRSTUVWXYZ___%`
3105 ])dnl
3106 dnl ---------------------------------------------------------------------------
3107 dnl CF_UTF8_LIB version: 7 updated: 2010/06/20 09:24:28
3108 dnl -----------
3109 dnl Check for multibyte support, and if not found, utf8 compatibility library
3110 AC_DEFUN([CF_UTF8_LIB],
3111 [
3112 AC_CACHE_CHECK(for multibyte character support,cf_cv_utf8_lib,[
3113         cf_save_LIBS="$LIBS"
3114         AC_TRY_LINK([
3115 #include <stdlib.h>],[putwc(0,0);],
3116         [cf_cv_utf8_lib=yes],
3117         [CF_FIND_LINKAGE([
3118 #include <libutf8.h>],[putwc(0,0);],utf8,
3119                 [cf_cv_utf8_lib=add-on],
3120                 [cf_cv_utf8_lib=no])
3121 ])])
3122
3123 # HAVE_LIBUTF8_H is used by ncurses if curses.h is shared between
3124 # ncurses/ncursesw:
3125 if test "$cf_cv_utf8_lib" = "add-on" ; then
3126         AC_DEFINE(HAVE_LIBUTF8_H)
3127         CF_ADD_INCDIR($cf_cv_header_path_utf8)
3128         CF_ADD_LIBDIR($cf_cv_library_path_utf8)
3129         CF_ADD_LIBS($cf_cv_library_file_utf8)
3130 fi
3131 ])dnl
3132 dnl ---------------------------------------------------------------------------
3133 dnl CF_VERBOSE version: 3 updated: 2007/07/29 09:55:12
3134 dnl ----------
3135 dnl Use AC_VERBOSE w/o the warnings
3136 AC_DEFUN([CF_VERBOSE],
3137 [test -n "$verbose" && echo "   $1" 1>&AC_FD_MSG
3138 CF_MSG_LOG([$1])
3139 ])dnl
3140 dnl ---------------------------------------------------------------------------
3141 dnl CF_WEAK_SYMBOLS version: 1 updated: 2008/08/16 19:18:06
3142 dnl ---------------
3143 dnl Check for compiler-support for weak symbols.
3144 dnl This works with "recent" gcc.
3145 AC_DEFUN([CF_WEAK_SYMBOLS],[
3146 AC_CACHE_CHECK(if $CC supports weak symbols,cf_cv_weak_symbols,[
3147
3148 AC_TRY_COMPILE([
3149 #include <stdio.h>],
3150 [
3151 #if defined(__GNUC__)
3152 #  if defined __USE_ISOC99
3153 #    define _cat_pragma(exp)    _Pragma(#exp)
3154 #    define _weak_pragma(exp)   _cat_pragma(weak name)
3155 #  else
3156 #    define _weak_pragma(exp)
3157 #  endif
3158 #  define _declare(name)        __extension__ extern __typeof__(name) name
3159 #  define weak_symbol(name)     _weak_pragma(name) _declare(name) __attribute__((weak))
3160 #endif
3161
3162 weak_symbol(fopen);
3163 ],[cf_cv_weak_symbols=yes],[cf_cv_weak_symbols=no])
3164 ])
3165 ])dnl
3166 dnl ---------------------------------------------------------------------------
3167 dnl CF_WITH_ADA_COMPILER version: 2 updated: 2010/06/26 17:35:58
3168 dnl --------------------
3169 dnl Command-line option to specify the Ada95 compiler.
3170 AC_DEFUN([CF_WITH_ADA_COMPILER],[
3171 AC_MSG_CHECKING(for ada-compiler)
3172 AC_ARG_WITH(ada-compiler,
3173         [  --with-ada-compiler=CMD specify Ada95 compiler command (default gnatmake)],
3174         [cf_ada_compiler=$withval],
3175         [cf_ada_compiler=gnatmake])
3176 AC_SUBST(cf_ada_compiler)
3177 AC_MSG_RESULT($cf_ada_compiler)
3178 ])dnl
3179 dnl ---------------------------------------------------------------------------
3180 dnl CF_WITH_ADA_INCLUDE version: 2 updated: 2010/06/26 17:35:58
3181 dnl -------------------
3182 dnl Command-line option to specify where Ada includes will install.
3183 AC_DEFUN([CF_WITH_ADA_INCLUDE],[
3184 AC_MSG_CHECKING(for ada-include)
3185 CF_WITH_PATH(ada-include,
3186    [  --with-ada-include=DIR  Ada includes are in DIR],
3187    ADA_INCLUDE,
3188    PREFIX/share/ada/adainclude,
3189    [$]prefix/share/ada/adainclude)
3190 AC_SUBST(ADA_INCLUDE)
3191 AC_MSG_RESULT($ADA_INCLUDE)
3192 ])dnl
3193 dnl ---------------------------------------------------------------------------
3194 dnl CF_WITH_ADA_OBJECTS version: 2 updated: 2010/06/26 17:35:58
3195 dnl -------------------
3196 dnl Command-line option to specify where Ada objects will install.
3197 AC_DEFUN([CF_WITH_ADA_OBJECTS],[
3198 AC_MSG_CHECKING(for ada-objects)
3199 CF_WITH_PATH(ada-objects,
3200    [  --with-ada-objects=DIR  Ada objects are in DIR],
3201    ADA_OBJECTS,
3202    PREFIX/lib/ada/adalib,
3203    [$]prefix/lib/ada/adalib)
3204 AC_SUBST(ADA_OBJECTS)
3205 AC_MSG_RESULT($ADA_OBJECTS)
3206 ])dnl
3207 dnl ---------------------------------------------------------------------------
3208 dnl CF_WITH_ADA_SHAREDLIB version: 2 updated: 2010/06/26 17:35:58
3209 dnl ---------------------
3210 dnl Command-line option to specify if an Ada95 shared-library should be built,
3211 dnl and optionally what its soname should be.
3212 AC_DEFUN([CF_WITH_ADA_SHAREDLIB],[
3213 AC_MSG_CHECKING(if an Ada95 shared-library should be built)
3214 AC_ARG_WITH(ada-sharedlib,
3215         [  --with-ada-sharedlib=XX build Ada95 shared-library],
3216         [with_ada_sharedlib=$withval],
3217         [with_ada_sharedlib=no])
3218 AC_MSG_RESULT($with_ada_sharedlib)
3219
3220 ADA_SHAREDLIB='lib$(LIB_NAME).so.1'
3221 MAKE_ADA_SHAREDLIB="#"
3222
3223 if test "x$with_ada_sharedlib" != xno
3224 then
3225         MAKE_ADA_SHAREDLIB=
3226         if test "x$with_ada_sharedlib" != xyes
3227         then
3228                 ADA_SHAREDLIB="$with_ada_sharedlib"
3229         fi
3230 fi
3231
3232 AC_SUBST(ADA_SHAREDLIB)
3233 AC_SUBST(MAKE_ADA_SHAREDLIB)
3234 ])dnl
3235 dnl ---------------------------------------------------------------------------
3236 dnl CF_WITH_CURSES_DIR version: 2 updated: 2002/11/10 14:46:59
3237 dnl ------------------
3238 dnl Wrapper for AC_ARG_WITH to specify directory under which to look for curses
3239 dnl libraries.
3240 AC_DEFUN([CF_WITH_CURSES_DIR],[
3241 AC_ARG_WITH(curses-dir,
3242         [  --with-curses-dir=DIR   directory in which (n)curses is installed],
3243         [CF_PATH_SYNTAX(withval)
3244          cf_cv_curses_dir=$withval],
3245         [cf_cv_curses_dir=no])
3246 ])dnl
3247 dnl ---------------------------------------------------------------------------
3248 dnl CF_WITH_PATH version: 9 updated: 2010/05/26 05:38:42
3249 dnl ------------
3250 dnl Wrapper for AC_ARG_WITH to ensure that user supplies a pathname, not just
3251 dnl defaulting to yes/no.
3252 dnl
3253 dnl $1 = option name
3254 dnl $2 = help-text
3255 dnl $3 = environment variable to set
3256 dnl $4 = default value, shown in the help-message, must be a constant
3257 dnl $5 = default value, if it's an expression & cannot be in the help-message
3258 dnl
3259 AC_DEFUN([CF_WITH_PATH],
3260 [AC_ARG_WITH($1,[$2 ](default: ifelse([$4],,empty,[$4])),,
3261 ifelse([$4],,[withval="${$3}"],[withval="${$3-ifelse([$5],,[$4],[$5])}"]))dnl
3262 if ifelse([$5],,true,[test -n "$5"]) ; then
3263 CF_PATH_SYNTAX(withval)
3264 fi
3265 $3="$withval"
3266 AC_SUBST($3)dnl
3267 ])dnl
3268 dnl ---------------------------------------------------------------------------
3269 dnl CF_WITH_PTHREAD version: 3 updated: 2010/05/29 16:31:02
3270 dnl ---------------
3271 dnl Check for POSIX thread library.
3272 AC_DEFUN([CF_WITH_PTHREAD],
3273 [
3274 AC_MSG_CHECKING(if you want to link with the pthread library)
3275 AC_ARG_WITH(pthread,
3276     [  --with-pthread          use POSIX thread library],
3277     [with_pthread=$withval],
3278     [with_pthread=no])
3279 AC_MSG_RESULT($with_pthread)
3280
3281 if test "$with_pthread" != no ; then
3282     AC_CHECK_HEADER(pthread.h,[
3283         AC_DEFINE(HAVE_PTHREADS_H)
3284
3285         AC_MSG_CHECKING(if we can link with the pthread library)
3286         cf_save_LIBS="$LIBS"
3287         CF_ADD_LIB(pthread)
3288         AC_TRY_LINK([
3289 #include <pthread.h>
3290 ],[
3291         int rc = pthread_create(0,0,0,0);
3292 ],[with_pthread=yes],[with_pthread=no])
3293         LIBS="$cf_save_LIBS"
3294         AC_MSG_RESULT($with_pthread)
3295
3296         if test "$with_pthread" = yes ; then
3297             CF_ADD_LIB(pthread)
3298             AC_DEFINE(HAVE_LIBPTHREADS)
3299         else
3300             AC_MSG_ERROR(Cannot link with pthread library)
3301         fi
3302     ])
3303 fi
3304 ])
3305 dnl ---------------------------------------------------------------------------
3306 dnl CF_XOPEN_SOURCE version: 34 updated: 2010/05/26 05:38:42
3307 dnl ---------------
3308 dnl Try to get _XOPEN_SOURCE defined properly that we can use POSIX functions,
3309 dnl or adapt to the vendor's definitions to get equivalent functionality,
3310 dnl without losing the common non-POSIX features.
3311 dnl
3312 dnl Parameters:
3313 dnl     $1 is the nominal value for _XOPEN_SOURCE
3314 dnl     $2 is the nominal value for _POSIX_C_SOURCE
3315 AC_DEFUN([CF_XOPEN_SOURCE],[
3316
3317 cf_XOPEN_SOURCE=ifelse([$1],,500,[$1])
3318 cf_POSIX_C_SOURCE=ifelse([$2],,199506L,[$2])
3319 cf_xopen_source=
3320
3321 case $host_os in #(vi
3322 aix[[456]]*) #(vi
3323         cf_xopen_source="-D_ALL_SOURCE"
3324         ;;
3325 darwin[[0-8]].*) #(vi
3326         cf_xopen_source="-D_APPLE_C_SOURCE"
3327         ;;
3328 darwin*) #(vi
3329         cf_xopen_source="-D_DARWIN_C_SOURCE"
3330         ;;
3331 freebsd*|dragonfly*) #(vi
3332         # 5.x headers associate
3333         #       _XOPEN_SOURCE=600 with _POSIX_C_SOURCE=200112L
3334         #       _XOPEN_SOURCE=500 with _POSIX_C_SOURCE=199506L
3335         cf_POSIX_C_SOURCE=200112L
3336         cf_XOPEN_SOURCE=600
3337         cf_xopen_source="-D_BSD_TYPES -D__BSD_VISIBLE -D_POSIX_C_SOURCE=$cf_POSIX_C_SOURCE -D_XOPEN_SOURCE=$cf_XOPEN_SOURCE"
3338         ;;
3339 hpux11*) #(vi
3340         cf_xopen_source="-D_HPUX_SOURCE -D_XOPEN_SOURCE=500"
3341         ;;
3342 hpux*) #(vi
3343         cf_xopen_source="-D_HPUX_SOURCE"
3344         ;;
3345 irix[[56]].*) #(vi
3346         cf_xopen_source="-D_SGI_SOURCE"
3347         ;;
3348 linux*|gnu*|mint*|k*bsd*-gnu) #(vi
3349         CF_GNU_SOURCE
3350         ;;
3351 mirbsd*) #(vi
3352         # setting _XOPEN_SOURCE or _POSIX_SOURCE breaks <arpa/inet.h>
3353         ;;
3354 netbsd*) #(vi
3355         # setting _XOPEN_SOURCE breaks IPv6 for lynx on NetBSD 1.6, breaks xterm, is not needed for ncursesw
3356         ;;
3357 openbsd*) #(vi
3358         # setting _XOPEN_SOURCE breaks xterm on OpenBSD 2.8, is not needed for ncursesw
3359         ;;
3360 osf[[45]]*) #(vi
3361         cf_xopen_source="-D_OSF_SOURCE"
3362         ;;
3363 nto-qnx*) #(vi
3364         cf_xopen_source="-D_QNX_SOURCE"
3365         ;;
3366 sco*) #(vi
3367         # setting _XOPEN_SOURCE breaks Lynx on SCO Unix / OpenServer
3368         ;;
3369 solaris2.1[[0-9]]) #(vi
3370         cf_xopen_source="-D__EXTENSIONS__ -D_XOPEN_SOURCE=$cf_XOPEN_SOURCE"
3371         ;;
3372 solaris2.[[1-9]]) #(vi
3373         cf_xopen_source="-D__EXTENSIONS__"
3374         ;;
3375 *)
3376         AC_CACHE_CHECK(if we should define _XOPEN_SOURCE,cf_cv_xopen_source,[
3377         AC_TRY_COMPILE([#include <sys/types.h>],[
3378 #ifndef _XOPEN_SOURCE
3379 make an error
3380 #endif],
3381         [cf_cv_xopen_source=no],
3382         [cf_save="$CPPFLAGS"
3383          CPPFLAGS="$CPPFLAGS -D_XOPEN_SOURCE=$cf_XOPEN_SOURCE"
3384          AC_TRY_COMPILE([#include <sys/types.h>],[
3385 #ifdef _XOPEN_SOURCE
3386 make an error
3387 #endif],
3388         [cf_cv_xopen_source=no],
3389         [cf_cv_xopen_source=$cf_XOPEN_SOURCE])
3390         CPPFLAGS="$cf_save"
3391         ])
3392 ])
3393         if test "$cf_cv_xopen_source" != no ; then
3394                 CF_REMOVE_DEFINE(CFLAGS,$CFLAGS,_XOPEN_SOURCE)
3395                 CF_REMOVE_DEFINE(CPPFLAGS,$CPPFLAGS,_XOPEN_SOURCE)
3396                 cf_temp_xopen_source="-D_XOPEN_SOURCE=$cf_cv_xopen_source"
3397                 CF_ADD_CFLAGS($cf_temp_xopen_source)
3398         fi
3399         CF_POSIX_C_SOURCE($cf_POSIX_C_SOURCE)
3400         ;;
3401 esac
3402
3403 if test -n "$cf_xopen_source" ; then
3404         CF_ADD_CFLAGS($cf_xopen_source)
3405 fi
3406 ])