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.11 2010/06/19 20:18:12 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: 2 updated: 2007/07/29 10:12:59
 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 -d $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: 25 updated: 2010/04/24 11:03:31
 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 -f 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: 1 updated: 2004/08/21 19:02:08
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 -f 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 -f conftest*
1097 ])dnl
1098 dnl ---------------------------------------------------------------------------
1099 dnl CF_GNAT_TRY_RUN version: 3 updated: 2004/08/21 19:02:08
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 -f 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 -f conftest*
1128 ])dnl
1129 dnl ---------------------------------------------------------------------------
1130 dnl CF_GNAT_VERSION version: 13 updated: 2010/06/19 15:22:18
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 case $cf_gnat_version in
1149   3.[[1-9]]*|[[4-9]].*)
1150       cf_compile_generics=generics
1151       cf_generic_objects="\${GENOBJS}"
1152       ;;
1153   *)  cf_compile_generics=
1154       cf_generic_objects=
1155       ;;
1156 esac
1157
1158 AC_SUBST(cf_compile_generics)
1159 AC_SUBST(cf_generic_objects)
1160 ])
1161 dnl ---------------------------------------------------------------------------
1162 dnl CF_GNU_SOURCE version: 6 updated: 2005/07/09 13:23:07
1163 dnl -------------
1164 dnl Check if we must define _GNU_SOURCE to get a reasonable value for
1165 dnl _XOPEN_SOURCE, upon which many POSIX definitions depend.  This is a defect
1166 dnl (or misfeature) of glibc2, which breaks portability of many applications,
1167 dnl since it is interwoven with GNU extensions.
1168 dnl
1169 dnl Well, yes we could work around it...
1170 AC_DEFUN([CF_GNU_SOURCE],
1171 [
1172 AC_CACHE_CHECK(if we must define _GNU_SOURCE,cf_cv_gnu_source,[
1173 AC_TRY_COMPILE([#include <sys/types.h>],[
1174 #ifndef _XOPEN_SOURCE
1175 make an error
1176 #endif],
1177         [cf_cv_gnu_source=no],
1178         [cf_save="$CPPFLAGS"
1179          CPPFLAGS="$CPPFLAGS -D_GNU_SOURCE"
1180          AC_TRY_COMPILE([#include <sys/types.h>],[
1181 #ifdef _XOPEN_SOURCE
1182 make an error
1183 #endif],
1184         [cf_cv_gnu_source=no],
1185         [cf_cv_gnu_source=yes])
1186         CPPFLAGS="$cf_save"
1187         ])
1188 ])
1189 test "$cf_cv_gnu_source" = yes && CPPFLAGS="$CPPFLAGS -D_GNU_SOURCE"
1190 ])dnl
1191 dnl ---------------------------------------------------------------------------
1192 dnl CF_HEADER_PATH version: 12 updated: 2010/05/05 05:22:40
1193 dnl --------------
1194 dnl Construct a search-list of directories for a nonstandard header-file
1195 dnl
1196 dnl Parameters
1197 dnl     $1 = the variable to return as result
1198 dnl     $2 = the package name
1199 AC_DEFUN([CF_HEADER_PATH],
1200 [
1201 $1=
1202
1203 # collect the current set of include-directories from compiler flags
1204 cf_header_path_list=""
1205 if test -n "${CFLAGS}${CPPFLAGS}" ; then
1206         for cf_header_path in $CPPFLAGS $CFLAGS
1207         do
1208                 case $cf_header_path in #(vi
1209                 -I*)
1210                         cf_header_path=`echo ".$cf_header_path" |sed -e 's/^...//' -e 's,/include$,,'`
1211                         CF_ADD_SUBDIR_PATH($1,$2,include,$cf_header_path,NONE)
1212                         cf_header_path_list="$cf_header_path_list [$]$1"
1213                         ;;
1214                 esac
1215         done
1216 fi
1217
1218 # add the variations for the package we are looking for
1219 CF_SUBDIR_PATH($1,$2,include)
1220
1221 test "$includedir" != NONE && \
1222 test "$includedir" != "/usr/include" && \
1223 test -d "$includedir" && {
1224         test -d $includedir &&    $1="[$]$1 $includedir"
1225         test -d $includedir/$2 && $1="[$]$1 $includedir/$2"
1226 }
1227
1228 test "$oldincludedir" != NONE && \
1229 test "$oldincludedir" != "/usr/include" && \
1230 test -d "$oldincludedir" && {
1231         test -d $oldincludedir    && $1="[$]$1 $oldincludedir"
1232         test -d $oldincludedir/$2 && $1="[$]$1 $oldincludedir/$2"
1233 }
1234
1235 $1="[$]$1 $cf_header_path_list"
1236 ])dnl
1237 dnl ---------------------------------------------------------------------------
1238 dnl CF_HELP_MESSAGE version: 3 updated: 1998/01/14 10:56:23
1239 dnl ---------------
1240 dnl Insert text into the help-message, for readability, from AC_ARG_WITH.
1241 AC_DEFUN([CF_HELP_MESSAGE],
1242 [AC_DIVERT_HELP([$1])dnl
1243 ])dnl
1244 dnl ---------------------------------------------------------------------------
1245 dnl CF_INCLUDE_DIRS version: 6 updated: 2009/01/06 19:37:40
1246 dnl ---------------
1247 dnl Construct the list of include-options according to whether we're building
1248 dnl in the source directory or using '--srcdir=DIR' option.  If we're building
1249 dnl with gcc, don't append the includedir if it happens to be /usr/include,
1250 dnl since that usually breaks gcc's shadow-includes.
1251 AC_DEFUN([CF_INCLUDE_DIRS],
1252 [
1253 CPPFLAGS="$CPPFLAGS -I. -I../include"
1254 if test "$srcdir" != "."; then
1255         CPPFLAGS="$CPPFLAGS -I\${srcdir}/../include"
1256 fi
1257 if test "$GCC" != yes; then
1258         CPPFLAGS="$CPPFLAGS -I\${includedir}"
1259 elif test "$includedir" != "/usr/include"; then
1260         if test "$includedir" = '${prefix}/include' ; then
1261                 if test $prefix != /usr ; then
1262                         CPPFLAGS="$CPPFLAGS -I\${includedir}"
1263                 fi
1264         else
1265                 CPPFLAGS="$CPPFLAGS -I\${includedir}"
1266         fi
1267 fi
1268 AC_SUBST(CPPFLAGS)
1269 ])dnl
1270 dnl ---------------------------------------------------------------------------
1271 dnl CF_INTEL_COMPILER version: 4 updated: 2010/05/26 05:38:42
1272 dnl -----------------
1273 dnl Check if the given compiler is really the Intel compiler for Linux.  It
1274 dnl tries to imitate gcc, but does not return an error when it finds a mismatch
1275 dnl between prototypes, e.g., as exercised by CF_MISSING_CHECK.
1276 dnl
1277 dnl This macro should be run "soon" after AC_PROG_CC or AC_PROG_CPLUSPLUS, to
1278 dnl ensure that it is not mistaken for gcc/g++.  It is normally invoked from
1279 dnl the wrappers for gcc and g++ warnings.
1280 dnl
1281 dnl $1 = GCC (default) or GXX
1282 dnl $2 = INTEL_COMPILER (default) or INTEL_CPLUSPLUS
1283 dnl $3 = CFLAGS (default) or CXXFLAGS
1284 AC_DEFUN([CF_INTEL_COMPILER],[
1285 ifelse([$2],,INTEL_COMPILER,[$2])=no
1286
1287 if test "$ifelse([$1],,[$1],GCC)" = yes ; then
1288         case $host_os in
1289         linux*|gnu*)
1290                 AC_MSG_CHECKING(if this is really Intel ifelse([$1],GXX,C++,C) compiler)
1291                 cf_save_CFLAGS="$ifelse([$3],,CFLAGS,[$3])"
1292                 ifelse([$3],,CFLAGS,[$3])="$ifelse([$3],,CFLAGS,[$3]) -no-gcc"
1293                 AC_TRY_COMPILE([],[
1294 #ifdef __INTEL_COMPILER
1295 #else
1296 make an error
1297 #endif
1298 ],[ifelse([$2],,INTEL_COMPILER,[$2])=yes
1299 cf_save_CFLAGS="$cf_save_CFLAGS -we147 -no-gcc"
1300 ],[])
1301                 ifelse([$3],,CFLAGS,[$3])="$cf_save_CFLAGS"
1302                 AC_MSG_RESULT($ifelse([$2],,INTEL_COMPILER,[$2]))
1303                 ;;
1304         esac
1305 fi
1306 ])dnl
1307 dnl ---------------------------------------------------------------------------
1308 dnl CF_LARGEFILE version: 7 updated: 2007/06/02 11:58:50
1309 dnl ------------
1310 dnl Add checks for large file support.
1311 AC_DEFUN([CF_LARGEFILE],[
1312 ifdef([AC_FUNC_FSEEKO],[
1313     AC_SYS_LARGEFILE
1314     if test "$enable_largefile" != no ; then
1315         AC_FUNC_FSEEKO
1316
1317         # Normally we would collect these definitions in the config.h,
1318         # but (like _XOPEN_SOURCE), some environments rely on having these
1319         # defined before any of the system headers are included.  Another
1320         # case comes up with C++, e.g., on AIX the compiler compiles the
1321         # header files by themselves before looking at the body files it is
1322         # told to compile.  For ncurses, those header files do not include
1323         # the config.h
1324         test "$ac_cv_sys_large_files"      != no && CPPFLAGS="$CPPFLAGS -D_LARGE_FILES "
1325         test "$ac_cv_sys_largefile_source" != no && CPPFLAGS="$CPPFLAGS -D_LARGEFILE_SOURCE "
1326         test "$ac_cv_sys_file_offset_bits" != no && CPPFLAGS="$CPPFLAGS -D_FILE_OFFSET_BITS=$ac_cv_sys_file_offset_bits "
1327
1328         AC_CACHE_CHECK(whether to use struct dirent64, cf_cv_struct_dirent64,[
1329                 AC_TRY_COMPILE([
1330 #include <sys/types.h>
1331 #include <dirent.h>
1332                 ],[
1333                 /* if transitional largefile support is setup, this is true */
1334                 extern struct dirent64 * readdir(DIR *);
1335                 struct dirent64 *x = readdir((DIR *)0);
1336                 struct dirent *y = readdir((DIR *)0);
1337                 int z = x - y;
1338                 ],
1339                 [cf_cv_struct_dirent64=yes],
1340                 [cf_cv_struct_dirent64=no])
1341         ])
1342         test "$cf_cv_struct_dirent64" = yes && AC_DEFINE(HAVE_STRUCT_DIRENT64)
1343     fi
1344 ])
1345 ])
1346 dnl ---------------------------------------------------------------------------
1347 dnl CF_LD_RPATH_OPT version: 3 updated: 2010/06/02 05:03:05
1348 dnl ---------------
1349 dnl For the given system and compiler, find the compiler flags to pass to the
1350 dnl loader to use the "rpath" feature.
1351 AC_DEFUN([CF_LD_RPATH_OPT],
1352 [
1353 AC_REQUIRE([CF_CHECK_CACHE])
1354
1355 LD_RPATH_OPT=
1356 AC_MSG_CHECKING(for an rpath option)
1357 case $cf_cv_system_name in #(vi
1358 irix*) #(vi
1359         if test "$GCC" = yes; then
1360                 LD_RPATH_OPT="-Wl,-rpath,"
1361         else
1362                 LD_RPATH_OPT="-rpath "
1363         fi
1364         ;;
1365 linux*|gnu*|k*bsd*-gnu) #(vi
1366         LD_RPATH_OPT="-Wl,-rpath,"
1367         ;;
1368 openbsd[[2-9]].*) #(vi
1369         LD_RPATH_OPT="-Wl,-rpath,"
1370         ;;
1371 freebsd*) #(vi
1372         LD_RPATH_OPT="-rpath "
1373         ;;
1374 netbsd*) #(vi
1375         LD_RPATH_OPT="-Wl,-rpath,"
1376         ;;
1377 osf*|mls+*) #(vi
1378         LD_RPATH_OPT="-rpath "
1379         ;;
1380 solaris2*) #(vi
1381         LD_RPATH_OPT="-R"
1382         ;;
1383 *)
1384         ;;
1385 esac
1386 AC_MSG_RESULT($LD_RPATH_OPT)
1387
1388 case "x$LD_RPATH_OPT" in #(vi
1389 x-R*)
1390         AC_MSG_CHECKING(if we need a space after rpath option)
1391         cf_save_LIBS="$LIBS"
1392         CF_ADD_LIBS(${LD_RPATH_OPT}$libdir)
1393         AC_TRY_LINK(, , cf_rpath_space=no, cf_rpath_space=yes)
1394         LIBS="$cf_save_LIBS"
1395         AC_MSG_RESULT($cf_rpath_space)
1396         test "$cf_rpath_space" = yes && LD_RPATH_OPT="$LD_RPATH_OPT "
1397         ;;
1398 esac
1399 ])dnl
1400 dnl ---------------------------------------------------------------------------
1401 dnl CF_LIBRARY_PATH version: 9 updated: 2010/03/28 12:52:50
1402 dnl ---------------
1403 dnl Construct a search-list of directories for a nonstandard library-file
1404 dnl
1405 dnl Parameters
1406 dnl     $1 = the variable to return as result
1407 dnl     $2 = the package name
1408 AC_DEFUN([CF_LIBRARY_PATH],
1409 [
1410 $1=
1411 cf_library_path_list=""
1412 if test -n "${LDFLAGS}${LIBS}" ; then
1413         for cf_library_path in $LDFLAGS $LIBS
1414         do
1415                 case $cf_library_path in #(vi
1416                 -L*)
1417                         cf_library_path=`echo ".$cf_library_path" |sed -e 's/^...//' -e 's,/lib$,,'`
1418                         CF_ADD_SUBDIR_PATH($1,$2,lib,$cf_library_path,NONE)
1419                         cf_library_path_list="$cf_library_path_list [$]$1"
1420                         ;;
1421                 esac
1422         done
1423 fi
1424
1425 CF_SUBDIR_PATH($1,$2,lib)
1426
1427 $1="$cf_library_path_list [$]$1"
1428 ])dnl
1429 dnl ---------------------------------------------------------------------------
1430 dnl CF_LIB_PREFIX version: 8 updated: 2008/09/13 11:34:16
1431 dnl -------------
1432 dnl Compute the library-prefix for the given host system
1433 dnl $1 = variable to set
1434 AC_DEFUN([CF_LIB_PREFIX],
1435 [
1436         case $cf_cv_system_name in #(vi
1437         OS/2*|os2*) #(vi
1438         LIB_PREFIX=''
1439         ;;
1440         *)      LIB_PREFIX='lib'
1441         ;;
1442         esac
1443 ifelse($1,,,[$1=$LIB_PREFIX])
1444         AC_SUBST(LIB_PREFIX)
1445 ])dnl
1446 dnl ---------------------------------------------------------------------------
1447 dnl CF_LIB_SONAME version: 4 updated: 2010/05/29 16:31:02
1448 dnl -------------
1449 dnl Find the and soname for the given shared library.  Set the cache variable
1450 dnl cf_cv_$3_soname to this, unless it is not found.  Then set the cache
1451 dnl variable to "unknown".
1452 dnl
1453 dnl $1 = headers
1454 dnl $2 = code
1455 dnl $3 = library name
1456 AC_DEFUN([CF_LIB_SONAME],
1457 [
1458 AC_CACHE_CHECK(for soname of $3 library,cf_cv_$3_soname,[
1459
1460 cf_cv_$3_soname=unknown
1461 if test "$cross_compiling" != yes ; then
1462 cat >conftest.$ac_ext <<CF_EOF
1463 $1
1464 int main()
1465 {
1466 $2
1467         ${cf_cv_main_return:-return}(0);
1468 }
1469 CF_EOF
1470 cf_save_LIBS="$LIBS"
1471         CF_ADD_LIB($3)
1472         if AC_TRY_EVAL(ac_compile) ; then
1473                 if AC_TRY_EVAL(ac_link) ; then
1474                         cf_cv_$3_soname=`ldd conftest$ac_exeext 2>/dev/null | sed -e 's,^.*/,,' -e 's, .*$,,' | fgrep lib$3.`
1475                         test -z "$cf_cv_$3_soname" && cf_cv_$3_soname=unknown
1476                 fi
1477         fi
1478 rm -f conftest*
1479 LIBS="$cf_save_LIBS"
1480 fi
1481 ])
1482 ])
1483 dnl ---------------------------------------------------------------------------
1484 dnl CF_LIB_SUFFIX version: 16 updated: 2008/12/27 12:30:03
1485 dnl -------------
1486 dnl Compute the library file-suffix from the given model name
1487 dnl $1 = model name
1488 dnl $2 = variable to set (the nominal library suffix)
1489 dnl $3 = dependency variable to set (actual filename)
1490 dnl The variable $LIB_SUFFIX, if set, prepends the variable to set.
1491 AC_DEFUN([CF_LIB_SUFFIX],
1492 [
1493         AC_REQUIRE([CF_SUBST_NCURSES_VERSION])
1494         case $1 in #(vi
1495         libtool) #(vi
1496                 $2='.la'
1497                 $3=[$]$2
1498                 ;;
1499         normal) #(vi
1500                 $2='.a'
1501                 $3=[$]$2
1502                 ;;
1503         debug) #(vi
1504                 $2='_g.a'
1505                 $3=[$]$2
1506                 ;;
1507         profile) #(vi
1508                 $2='_p.a'
1509                 $3=[$]$2
1510                 ;;
1511         shared) #(vi
1512                 case $cf_cv_system_name in
1513                 aix[[56]]*) #(vi
1514                         $2='.a'
1515                         $3=[$]$2
1516                         ;;
1517                 cygwin*) #(vi
1518                         $2='.dll'
1519                         $3='.dll.a'
1520                         ;;
1521                 darwin*) #(vi
1522                         $2='.dylib'
1523                         $3=[$]$2
1524                         ;;
1525                 hpux*) #(vi
1526                         case $target in
1527                         ia64*) #(vi
1528                                 $2='.so'
1529                                 $3=[$]$2
1530                                 ;;
1531                         *) #(vi
1532                                 $2='.sl'
1533                                 $3=[$]$2
1534                                 ;;
1535                         esac
1536                         ;;
1537                 *)      $2='.so'
1538                         $3=[$]$2
1539                         ;;
1540                 esac
1541         esac
1542         test -n "$LIB_SUFFIX" && $2="${LIB_SUFFIX}[$]{$2}"
1543         test -n "$LIB_SUFFIX" && $3="${LIB_SUFFIX}[$]{$3}"
1544 ])dnl
1545 dnl ---------------------------------------------------------------------------
1546 dnl CF_LIB_TYPE version: 4 updated: 2000/10/20 22:57:49
1547 dnl -----------
1548 dnl Compute the string to append to -library from the given model name
1549 dnl $1 = model name
1550 dnl $2 = variable to set
1551 dnl The variable $LIB_SUFFIX, if set, prepends the variable to set.
1552 AC_DEFUN([CF_LIB_TYPE],
1553 [
1554         case $1 in
1555         libtool) $2=''   ;;
1556         normal)  $2=''   ;;
1557         debug)   $2='_g' ;;
1558         profile) $2='_p' ;;
1559         shared)  $2=''   ;;
1560         esac
1561         test -n "$LIB_SUFFIX" && $2="${LIB_SUFFIX}[$]{$2}"
1562 ])dnl
1563 dnl ---------------------------------------------------------------------------
1564 dnl CF_LINK_DATAONLY version: 9 updated: 2009/01/01 20:21:38
1565 dnl ----------------
1566 dnl Some systems have a non-ANSI linker that doesn't pull in modules that have
1567 dnl only data (i.e., no functions), for example NeXT.  On those systems we'll
1568 dnl have to provide wrappers for global tables to ensure they're linked
1569 dnl properly.
1570 AC_DEFUN([CF_LINK_DATAONLY],
1571 [
1572 AC_MSG_CHECKING([if data-only library module links])
1573 AC_CACHE_VAL(cf_cv_link_dataonly,[
1574         rm -f conftest.a
1575         cat >conftest.$ac_ext <<EOF
1576 #line __oline__ "configure"
1577 int     testdata[[3]] = { 123, 456, 789 };
1578 EOF
1579         if AC_TRY_EVAL(ac_compile) ; then
1580                 mv conftest.o data.o && \
1581                 ( $AR $ARFLAGS conftest.a data.o ) 2>&AC_FD_CC 1>/dev/null
1582         fi
1583         rm -f conftest.$ac_ext data.o
1584         cat >conftest.$ac_ext <<EOF
1585 #line __oline__ "configure"
1586 int     testfunc()
1587 {
1588 #if defined(NeXT)
1589         ${cf_cv_main_return:-return}(1);        /* I'm told this linker is broken */
1590 #else
1591         extern int testdata[[3]];
1592         return testdata[[0]] == 123
1593            &&  testdata[[1]] == 456
1594            &&  testdata[[2]] == 789;
1595 #endif
1596 }
1597 EOF
1598         if AC_TRY_EVAL(ac_compile); then
1599                 mv conftest.o func.o && \
1600                 ( $AR $ARFLAGS conftest.a func.o ) 2>&AC_FD_CC 1>/dev/null
1601         fi
1602         rm -f conftest.$ac_ext func.o
1603         ( eval $RANLIB conftest.a ) 2>&AC_FD_CC >/dev/null
1604         cf_saveLIBS="$LIBS"
1605         LIBS="conftest.a $LIBS"
1606         AC_TRY_RUN([
1607         int main()
1608         {
1609                 extern int testfunc();
1610                 ${cf_cv_main_return:-return} (!testfunc());
1611         }
1612         ],
1613         [cf_cv_link_dataonly=yes],
1614         [cf_cv_link_dataonly=no],
1615         [cf_cv_link_dataonly=unknown])
1616         LIBS="$cf_saveLIBS"
1617         ])
1618 AC_MSG_RESULT($cf_cv_link_dataonly)
1619
1620 if test "$cf_cv_link_dataonly" = no ; then
1621         AC_DEFINE(BROKEN_LINKER)
1622         BROKEN_LINKER=1
1623 fi
1624
1625 ])dnl
1626 dnl ---------------------------------------------------------------------------
1627 dnl CF_LINK_FUNCS version: 7 updated: 2006/12/16 12:33:30
1628 dnl -------------
1629 dnl Most Unix systems have both link and symlink, a few don't have symlink.
1630 dnl A few non-Unix systems implement symlink, but not link.
1631 dnl A few non-systems implement neither (or have nonfunctional versions).
1632 AC_DEFUN([CF_LINK_FUNCS],
1633 [
1634 AC_CHECK_FUNCS( \
1635         remove \
1636         unlink )
1637
1638 if test "$cross_compiling" = yes ; then
1639         AC_CHECK_FUNCS( \
1640                 link \
1641                 symlink )
1642 else
1643         AC_CACHE_CHECK(if link/symlink functions work,cf_cv_link_funcs,[
1644                 cf_cv_link_funcs=
1645                 for cf_func in link symlink ; do
1646                         AC_TRY_RUN([
1647 #include <sys/types.h>
1648 #include <sys/stat.h>
1649 #ifdef HAVE_UNISTD_H
1650 #include <unistd.h>
1651 #endif
1652 int main()
1653 {
1654         int fail = 0;
1655         char *src = "config.log";
1656         char *dst = "conftest.chk";
1657         struct stat src_sb;
1658         struct stat dst_sb;
1659
1660         stat(src, &src_sb);
1661         fail = ($cf_func("config.log", "conftest.chk") < 0)
1662             || (stat(dst, &dst_sb) < 0)
1663             || (dst_sb.st_mtime != src_sb.st_mtime);
1664 #ifdef HAVE_UNLINK
1665         unlink(dst);
1666 #else
1667         remove(dst);
1668 #endif
1669         ${cf_cv_main_return:-return} (fail);
1670 }
1671                         ],[
1672                         cf_cv_link_funcs="$cf_cv_link_funcs $cf_func"
1673                         eval 'ac_cv_func_'$cf_func'=yes'],[
1674                         eval 'ac_cv_func_'$cf_func'=no'],[
1675                         eval 'ac_cv_func_'$cf_func'=error'])
1676                 done
1677                 test -z "$cf_cv_link_funcs" && cf_cv_link_funcs=no
1678         ])
1679         test "$ac_cv_func_link"    = yes && AC_DEFINE(HAVE_LINK)
1680         test "$ac_cv_func_symlink" = yes && AC_DEFINE(HAVE_SYMLINK)
1681 fi
1682 ])dnl
1683 dnl ---------------------------------------------------------------------------
1684 dnl CF_MAIN_RETURN version: 1 updated: 2006/12/10 09:51:54
1685 dnl --------------
1686 dnl Check if a return from main to the shell actually returns the same exit
1687 dnl code.  This is true for almost any POSIX environment.
1688 dnl
1689 dnl Some very old environments did not flush stdout, etc., on an exit.  That
1690 dnl would be a useful case to test for also.
1691 AC_DEFUN([CF_MAIN_RETURN],
1692 [
1693 cf_cv_main_return=return
1694 ])dnl
1695 dnl ---------------------------------------------------------------------------
1696 dnl CF_MAKEFLAGS version: 12 updated: 2006/10/21 08:27:03
1697 dnl ------------
1698 dnl Some 'make' programs support ${MAKEFLAGS}, some ${MFLAGS}, to pass 'make'
1699 dnl options to lower-levels.  It's very useful for "make -n" -- if we have it.
1700 dnl (GNU 'make' does both, something POSIX 'make', which happens to make the
1701 dnl ${MAKEFLAGS} variable incompatible because it adds the assignments :-)
1702 AC_DEFUN([CF_MAKEFLAGS],
1703 [
1704 AC_CACHE_CHECK(for makeflags variable, cf_cv_makeflags,[
1705         cf_cv_makeflags=''
1706         for cf_option in '-${MAKEFLAGS}' '${MFLAGS}'
1707         do
1708                 cat >cf_makeflags.tmp <<CF_EOF
1709 SHELL = /bin/sh
1710 all :
1711         @ echo '.$cf_option'
1712 CF_EOF
1713                 cf_result=`${MAKE-make} -k -f cf_makeflags.tmp 2>/dev/null | sed -e 's,[[       ]]*$,,'`
1714                 case "$cf_result" in
1715                 .*k)
1716                         cf_result=`${MAKE-make} -k -f cf_makeflags.tmp CC=cc 2>/dev/null`
1717                         case "$cf_result" in
1718                         .*CC=*) cf_cv_makeflags=
1719                                 ;;
1720                         *)      cf_cv_makeflags=$cf_option
1721                                 ;;
1722                         esac
1723                         break
1724                         ;;
1725                 .-)     ;;
1726                 *)      echo "given option \"$cf_option\", no match \"$cf_result\""
1727                         ;;
1728                 esac
1729         done
1730         rm -f cf_makeflags.tmp
1731 ])
1732
1733 AC_SUBST(cf_cv_makeflags)
1734 ])dnl
1735 dnl ---------------------------------------------------------------------------
1736 dnl CF_MAKE_TAGS version: 5 updated: 2010/04/03 20:07:32
1737 dnl ------------
1738 dnl Generate tags/TAGS targets for makefiles.  Do not generate TAGS if we have
1739 dnl a monocase filesystem.
1740 AC_DEFUN([CF_MAKE_TAGS],[
1741 AC_REQUIRE([CF_MIXEDCASE_FILENAMES])
1742
1743 AC_CHECK_PROGS(CTAGS, exctags ctags)
1744 AC_CHECK_PROGS(ETAGS, exetags etags)
1745
1746 AC_CHECK_PROG(MAKE_LOWER_TAGS, ${CTAGS-ctags}, yes, no)
1747
1748 if test "$cf_cv_mixedcase" = yes ; then
1749         AC_CHECK_PROG(MAKE_UPPER_TAGS, ${ETAGS-etags}, yes, no)
1750 else
1751         MAKE_UPPER_TAGS=no
1752 fi
1753
1754 if test "$MAKE_UPPER_TAGS" = yes ; then
1755         MAKE_UPPER_TAGS=
1756 else
1757         MAKE_UPPER_TAGS="#"
1758 fi
1759
1760 if test "$MAKE_LOWER_TAGS" = yes ; then
1761         MAKE_LOWER_TAGS=
1762 else
1763         MAKE_LOWER_TAGS="#"
1764 fi
1765
1766 AC_SUBST(CTAGS)
1767 AC_SUBST(ETAGS)
1768
1769 AC_SUBST(MAKE_UPPER_TAGS)
1770 AC_SUBST(MAKE_LOWER_TAGS)
1771 ])dnl
1772 dnl ---------------------------------------------------------------------------
1773 dnl CF_MIXEDCASE_FILENAMES version: 3 updated: 2003/09/20 17:07:55
1774 dnl ----------------------
1775 dnl Check if the file-system supports mixed-case filenames.  If we're able to
1776 dnl create a lowercase name and see it as uppercase, it doesn't support that.
1777 AC_DEFUN([CF_MIXEDCASE_FILENAMES],
1778 [
1779 AC_CACHE_CHECK(if filesystem supports mixed-case filenames,cf_cv_mixedcase,[
1780 if test "$cross_compiling" = yes ; then
1781         case $target_alias in #(vi
1782         *-os2-emx*|*-msdosdjgpp*|*-cygwin*|*-mingw32*|*-uwin*) #(vi
1783                 cf_cv_mixedcase=no
1784                 ;;
1785         *)
1786                 cf_cv_mixedcase=yes
1787                 ;;
1788         esac
1789 else
1790         rm -f conftest CONFTEST
1791         echo test >conftest
1792         if test -f CONFTEST ; then
1793                 cf_cv_mixedcase=no
1794         else
1795                 cf_cv_mixedcase=yes
1796         fi
1797         rm -f conftest CONFTEST
1798 fi
1799 ])
1800 test "$cf_cv_mixedcase" = yes && AC_DEFINE(MIXEDCASE_FILENAMES)
1801 ])dnl
1802 dnl ---------------------------------------------------------------------------
1803 dnl CF_MKSTEMP version: 6 updated: 2010/05/22 14:44:30
1804 dnl ----------
1805 dnl Check for a working mkstemp.  This creates two files, checks that they are
1806 dnl successfully created and distinct (AmigaOS apparently fails on the last).
1807 AC_DEFUN([CF_MKSTEMP],[
1808 AC_CACHE_CHECK(for working mkstemp, cf_cv_func_mkstemp,[
1809 rm -f conftest*
1810 AC_TRY_RUN([
1811 #include <sys/types.h>
1812 #include <stdlib.h>
1813 #include <stdio.h>
1814 #include <string.h>
1815 #include <sys/stat.h>
1816 int main()
1817 {
1818         char *tmpl = "conftestXXXXXX";
1819         char name[2][80];
1820         int n;
1821         int result = 0;
1822         int fd;
1823         struct stat sb;
1824
1825         umask(077);
1826         for (n = 0; n < 2; ++n) {
1827                 strcpy(name[n], tmpl);
1828                 if ((fd = mkstemp(name[n])) >= 0) {
1829                         if (!strcmp(name[n], tmpl)
1830                          || stat(name[n], &sb) != 0
1831                          || (sb.st_mode & S_IFMT) != S_IFREG
1832                          || (sb.st_mode & 077) != 0) {
1833                                 result = 1;
1834                         }
1835                         close(fd);
1836                 }
1837         }
1838         if (result == 0
1839          && !strcmp(name[0], name[1]))
1840                 result = 1;
1841         ${cf_cv_main_return:-return}(result);
1842 }
1843 ],[cf_cv_func_mkstemp=yes
1844 ],[cf_cv_func_mkstemp=no
1845 ],[AC_CHECK_FUNC(mkstemp)
1846 ])
1847 ])
1848 if test "x$cf_cv_func_mkstemp" = xyes || test "x$ac_cv_func_mkstemp" = xyes ; then
1849         AC_DEFINE(HAVE_MKSTEMP)
1850 fi
1851 ])dnl
1852 dnl ---------------------------------------------------------------------------
1853 dnl CF_MSG_LOG version: 4 updated: 2007/07/29 09:55:12
1854 dnl ----------
1855 dnl Write a debug message to config.log, along with the line number in the
1856 dnl configure script.
1857 AC_DEFUN([CF_MSG_LOG],[
1858 echo "${as_me-configure}:__oline__: testing $* ..." 1>&AC_FD_CC
1859 ])dnl
1860 dnl ---------------------------------------------------------------------------
1861 dnl CF_NCURSES_ADDON version: 2 updated: 2010/02/27 18:27:44
1862 dnl ----------------
1863 dnl Configure an ncurses add-on, built outside the ncurses tree.
1864 AC_DEFUN([CF_NCURSES_ADDON],[
1865
1866 AC_PROVIDE([CF_SUBST_NCURSES_VERSION])
1867
1868 AC_MSG_CHECKING(if you want wide-character code)
1869 AC_ARG_ENABLE(widec,
1870         [  --enable-widec          compile with wide-char/UTF-8 code],
1871         [with_widec=$enableval],
1872         [with_widec=no])
1873 AC_MSG_RESULT($with_widec)
1874 if test "$with_widec" = yes ; then
1875         CF_UTF8_LIB
1876         CF_NCURSES_CONFIG(ncursesw)
1877 else
1878         CF_NCURSES_CONFIG(ncurses)
1879 fi
1880
1881 if test "$NCURSES_CONFIG" != none ; then
1882
1883 cf_version=`$NCURSES_CONFIG --version`
1884
1885 NCURSES_MAJOR=`echo "$cf_version" | sed -e 's/\..*//'`
1886 NCURSES_MINOR=`echo "$cf_version" | sed -e 's/^[[0-9]]\+\.//' -e 's/\..*//'`
1887 NCURSES_PATCH=`echo "$cf_version" | sed -e 's/^[[0-9]]\+\.[[0-9]]\+\.//'`
1888
1889 # ABI version is not available from headers
1890 cf_cv_abi_version=`$NCURSES_CONFIG --abi-version`
1891
1892 else
1893
1894 for cf_name in MAJOR MINOR PATCH
1895 do
1896 cat >conftest.$ac_ext <<CF_EOF
1897 #include <${cf_cv_ncurses_header-curses.h}>
1898 AUTOCONF_$cf_name NCURSES_VERSION_$cf_name
1899 CF_EOF
1900         cf_try="$ac_cpp conftest.$ac_ext 2>&5 | fgrep AUTOCONF_$cf_name >conftest.out"
1901         AC_TRY_EVAL(cf_try)
1902         if test -f conftest.out ; then
1903                 cf_result=`cat conftest.out | sed -e "s/^.*AUTOCONF_$cf_name[[  ]]\+//"`
1904                 eval NCURSES_$cf_name=$cf_result
1905                 cat conftest.$ac_ext
1906                 cat conftest.out
1907         fi
1908 done
1909
1910 cf_cv_abi_version=${NCURSES_MAJOR}
1911
1912 fi
1913
1914 cf_cv_rel_version=${NCURSES_MAJOR}.${NCURSES_MINOR}
1915
1916 dnl Show the computed version, for logging
1917 cf_cv_timestamp=`date`
1918
1919 AC_MSG_RESULT(Configuring NCURSES $cf_cv_rel_version ABI $cf_cv_abi_version ($cf_cv_timestamp))
1920
1921 dnl We need these values in the generated headers
1922 AC_SUBST(NCURSES_MAJOR)
1923 AC_SUBST(NCURSES_MINOR)
1924 AC_SUBST(NCURSES_PATCH)
1925
1926 dnl We need these values in the generated makefiles
1927 AC_SUBST(cf_cv_rel_version)
1928 AC_SUBST(cf_cv_abi_version)
1929
1930 dnl FIXME - not needed for Ada95
1931 AC_SUBST(cf_cv_builtin_bool)
1932 AC_SUBST(cf_cv_header_stdbool_h)
1933 AC_SUBST(cf_cv_type_of_bool)dnl
1934
1935 ])
1936 dnl ---------------------------------------------------------------------------
1937 dnl CF_NCURSES_CC_CHECK version: 4 updated: 2007/07/29 10:39:05
1938 dnl -------------------
1939 dnl Check if we can compile with ncurses' header file
1940 dnl $1 is the cache variable to set
1941 dnl $2 is the header-file to include
1942 dnl $3 is the root name (ncurses or ncursesw)
1943 AC_DEFUN([CF_NCURSES_CC_CHECK],[
1944         AC_TRY_COMPILE([
1945 ]ifelse($3,ncursesw,[
1946 #define _XOPEN_SOURCE_EXTENDED
1947 #undef  HAVE_LIBUTF8_H  /* in case we used CF_UTF8_LIB */
1948 #define HAVE_LIBUTF8_H  /* to force ncurses' header file to use cchar_t */
1949 ])[
1950 #include <$2>],[
1951 #ifdef NCURSES_VERSION
1952 ]ifelse($3,ncursesw,[
1953 #ifndef WACS_BSSB
1954         make an error
1955 #endif
1956 ])[
1957 printf("%s\n", NCURSES_VERSION);
1958 #else
1959 #ifdef __NCURSES_H
1960 printf("old\n");
1961 #else
1962         make an error
1963 #endif
1964 #endif
1965         ]
1966         ,[$1=$2]
1967         ,[$1=no])
1968 ])dnl
1969 dnl ---------------------------------------------------------------------------
1970 dnl CF_NCURSES_CONFIG version: 6 updated: 2010/04/28 06:02:16
1971 dnl -----------------
1972 dnl Tie together the configure-script macros for ncurses.
1973 dnl Prefer the "-config" script from ncurses 5.6, to simplify analysis.
1974 dnl Allow that to be overridden using the $NCURSES_CONFIG environment variable.
1975 dnl
1976 dnl $1 is the root library name (default: "ncurses")
1977 AC_DEFUN([CF_NCURSES_CONFIG],
1978 [
1979 cf_ncuconfig_root=ifelse($1,,ncurses,$1)
1980
1981 echo "Looking for ${cf_ncuconfig_root}-config"
1982 AC_PATH_PROGS(NCURSES_CONFIG,${cf_ncuconfig_root}6-config ${cf_ncuconfig_root}5-config,none)
1983
1984 if test "$NCURSES_CONFIG" != none ; then
1985
1986 CPPFLAGS="$CPPFLAGS `$NCURSES_CONFIG --cflags`"
1987 LIBS="`$NCURSES_CONFIG --libs` $LIBS"
1988
1989 # even with config script, some packages use no-override for curses.h
1990 CF_CURSES_HEADER(ifelse($1,,ncurses,$1))
1991
1992 dnl like CF_NCURSES_CPPFLAGS
1993 AC_DEFINE(NCURSES)
1994
1995 dnl like CF_NCURSES_LIBS
1996 CF_UPPER(cf_nculib_ROOT,HAVE_LIB$cf_ncuconfig_root)
1997 AC_DEFINE_UNQUOTED($cf_nculib_ROOT)
1998
1999 dnl like CF_NCURSES_VERSION
2000 cf_cv_ncurses_version=`$NCURSES_CONFIG --version`
2001
2002 else
2003
2004 CF_NCURSES_CPPFLAGS(ifelse($1,,ncurses,$1))
2005 CF_NCURSES_LIBS(ifelse($1,,ncurses,$1))
2006
2007 fi
2008 ])dnl
2009 dnl ---------------------------------------------------------------------------
2010 dnl CF_NCURSES_CPPFLAGS version: 19 updated: 2007/07/29 13:35:20
2011 dnl -------------------
2012 dnl Look for the SVr4 curses clone 'ncurses' in the standard places, adjusting
2013 dnl the CPPFLAGS variable so we can include its header.
2014 dnl
2015 dnl The header files may be installed as either curses.h, or ncurses.h (would
2016 dnl be obsolete, except that some packagers prefer this name to distinguish it
2017 dnl from a "native" curses implementation).  If not installed for overwrite,
2018 dnl the curses.h file would be in an ncurses subdirectory (e.g.,
2019 dnl /usr/include/ncurses), but someone may have installed overwriting the
2020 dnl vendor's curses.  Only very old versions (pre-1.9.2d, the first autoconf'd
2021 dnl version) of ncurses don't define either __NCURSES_H or NCURSES_VERSION in
2022 dnl the header.
2023 dnl
2024 dnl If the installer has set $CFLAGS or $CPPFLAGS so that the ncurses header
2025 dnl is already in the include-path, don't even bother with this, since we cannot
2026 dnl easily determine which file it is.  In this case, it has to be <curses.h>.
2027 dnl
2028 dnl The optional parameter gives the root name of the library, in case it is
2029 dnl not installed as the default curses library.  That is how the
2030 dnl wide-character version of ncurses is installed.
2031 AC_DEFUN([CF_NCURSES_CPPFLAGS],
2032 [AC_REQUIRE([CF_WITH_CURSES_DIR])
2033
2034 AC_PROVIDE([CF_CURSES_CPPFLAGS])dnl
2035 cf_ncuhdr_root=ifelse($1,,ncurses,$1)
2036
2037 test -n "$cf_cv_curses_dir" && \
2038 test "$cf_cv_curses_dir" != "no" && { \
2039   CF_ADD_INCDIR($cf_cv_curses_dir/include $cf_cv_curses_dir/include/$cf_ncuhdr_root)
2040 }
2041
2042 AC_CACHE_CHECK(for $cf_ncuhdr_root header in include-path, cf_cv_ncurses_h,[
2043         cf_header_list="$cf_ncuhdr_root/curses.h $cf_ncuhdr_root/ncurses.h"
2044         ( test "$cf_ncuhdr_root" = ncurses || test "$cf_ncuhdr_root" = ncursesw ) && cf_header_list="$cf_header_list curses.h ncurses.h"
2045         for cf_header in $cf_header_list
2046         do
2047                 CF_NCURSES_CC_CHECK(cf_cv_ncurses_h,$cf_header,$1)
2048                 test "$cf_cv_ncurses_h" != no && break
2049         done
2050 ])
2051
2052 CF_NCURSES_HEADER
2053 CF_TERM_HEADER
2054
2055 # some applications need this, but should check for NCURSES_VERSION
2056 AC_DEFINE(NCURSES)
2057
2058 CF_NCURSES_VERSION
2059 ])dnl
2060 dnl ---------------------------------------------------------------------------
2061 dnl CF_NCURSES_HEADER version: 2 updated: 2008/03/23 14:48:54
2062 dnl -----------------
2063 dnl Find a "curses" header file, e.g,. "curses.h", or one of the more common
2064 dnl variations of ncurses' installs.
2065 dnl
2066 dnl See also CF_CURSES_HEADER, which sets the same cache variable.
2067 AC_DEFUN([CF_NCURSES_HEADER],[
2068
2069 if test "$cf_cv_ncurses_h" != no ; then
2070         cf_cv_ncurses_header=$cf_cv_ncurses_h
2071 else
2072
2073 AC_CACHE_CHECK(for $cf_ncuhdr_root include-path, cf_cv_ncurses_h2,[
2074         test -n "$verbose" && echo
2075         CF_HEADER_PATH(cf_search,$cf_ncuhdr_root)
2076         test -n "$verbose" && echo search path $cf_search
2077         cf_save2_CPPFLAGS="$CPPFLAGS"
2078         for cf_incdir in $cf_search
2079         do
2080                 CF_ADD_INCDIR($cf_incdir)
2081                 for cf_header in \
2082                         ncurses.h \
2083                         curses.h
2084                 do
2085                         CF_NCURSES_CC_CHECK(cf_cv_ncurses_h2,$cf_header,$1)
2086                         if test "$cf_cv_ncurses_h2" != no ; then
2087                                 cf_cv_ncurses_h2=$cf_incdir/$cf_header
2088                                 test -n "$verbose" && echo $ac_n "      ... found $ac_c" 1>&AC_FD_MSG
2089                                 break
2090                         fi
2091                         test -n "$verbose" && echo "    ... tested $cf_incdir/$cf_header" 1>&AC_FD_MSG
2092                 done
2093                 CPPFLAGS="$cf_save2_CPPFLAGS"
2094                 test "$cf_cv_ncurses_h2" != no && break
2095         done
2096         test "$cf_cv_ncurses_h2" = no && AC_MSG_ERROR(not found)
2097         ])
2098
2099         CF_DIRNAME(cf_1st_incdir,$cf_cv_ncurses_h2)
2100         cf_cv_ncurses_header=`basename $cf_cv_ncurses_h2`
2101         if test `basename $cf_1st_incdir` = $cf_ncuhdr_root ; then
2102                 cf_cv_ncurses_header=$cf_ncuhdr_root/$cf_cv_ncurses_header
2103         fi
2104         CF_ADD_INCDIR($cf_1st_incdir)
2105
2106 fi
2107
2108 # Set definitions to allow ifdef'ing for ncurses.h
2109
2110 case $cf_cv_ncurses_header in # (vi
2111 *ncurses.h)
2112         AC_DEFINE(HAVE_NCURSES_H)
2113         ;;
2114 esac
2115
2116 case $cf_cv_ncurses_header in # (vi
2117 ncurses/curses.h|ncurses/ncurses.h)
2118         AC_DEFINE(HAVE_NCURSES_NCURSES_H)
2119         ;;
2120 ncursesw/curses.h|ncursesw/ncurses.h)
2121         AC_DEFINE(HAVE_NCURSESW_NCURSES_H)
2122         ;;
2123 esac
2124
2125 ])dnl
2126 dnl ---------------------------------------------------------------------------
2127 dnl CF_NCURSES_LIBS version: 13 updated: 2007/07/29 10:29:20
2128 dnl ---------------
2129 dnl Look for the ncurses library.  This is a little complicated on Linux,
2130 dnl because it may be linked with the gpm (general purpose mouse) library.
2131 dnl Some distributions have gpm linked with (bsd) curses, which makes it
2132 dnl unusable with ncurses.  However, we don't want to link with gpm unless
2133 dnl ncurses has a dependency, since gpm is normally set up as a shared library,
2134 dnl and the linker will record a dependency.
2135 dnl
2136 dnl The optional parameter gives the root name of the library, in case it is
2137 dnl not installed as the default curses library.  That is how the
2138 dnl wide-character version of ncurses is installed.
2139 AC_DEFUN([CF_NCURSES_LIBS],
2140 [AC_REQUIRE([CF_NCURSES_CPPFLAGS])
2141
2142 cf_nculib_root=ifelse($1,,ncurses,$1)
2143         # This works, except for the special case where we find gpm, but
2144         # ncurses is in a nonstandard location via $LIBS, and we really want
2145         # to link gpm.
2146 cf_ncurses_LIBS=""
2147 cf_ncurses_SAVE="$LIBS"
2148 AC_CHECK_LIB(gpm,Gpm_Open,
2149         [AC_CHECK_LIB(gpm,initscr,
2150                 [LIBS="$cf_ncurses_SAVE"],
2151                 [cf_ncurses_LIBS="-lgpm"])])
2152
2153 case $host_os in #(vi
2154 freebsd*)
2155         # This is only necessary if you are linking against an obsolete
2156         # version of ncurses (but it should do no harm, since it's static).
2157         if test "$cf_nculib_root" = ncurses ; then
2158                 AC_CHECK_LIB(mytinfo,tgoto,[cf_ncurses_LIBS="-lmytinfo $cf_ncurses_LIBS"])
2159         fi
2160         ;;
2161 esac
2162
2163 LIBS="$cf_ncurses_LIBS $LIBS"
2164
2165 if ( test -n "$cf_cv_curses_dir" && test "$cf_cv_curses_dir" != "no" )
2166 then
2167         CF_ADD_LIBDIR($cf_cv_curses_dir/lib)
2168         LIBS="-l$cf_nculib_root $LIBS"
2169 else
2170         CF_FIND_LIBRARY($cf_nculib_root,$cf_nculib_root,
2171                 [#include <${cf_cv_ncurses_header-curses.h}>],
2172                 [initscr()],
2173                 initscr)
2174 fi
2175
2176 if test -n "$cf_ncurses_LIBS" ; then
2177         AC_MSG_CHECKING(if we can link $cf_nculib_root without $cf_ncurses_LIBS)
2178         cf_ncurses_SAVE="$LIBS"
2179         for p in $cf_ncurses_LIBS ; do
2180                 q=`echo $LIBS | sed -e "s%$p %%" -e "s%$p$%%"`
2181                 if test "$q" != "$LIBS" ; then
2182                         LIBS="$q"
2183                 fi
2184         done
2185         AC_TRY_LINK([#include <${cf_cv_ncurses_header-curses.h}>],
2186                 [initscr(); mousemask(0,0); tgoto((char *)0, 0, 0);],
2187                 [AC_MSG_RESULT(yes)],
2188                 [AC_MSG_RESULT(no)
2189                  LIBS="$cf_ncurses_SAVE"])
2190 fi
2191
2192 CF_UPPER(cf_nculib_ROOT,HAVE_LIB$cf_nculib_root)
2193 AC_DEFINE_UNQUOTED($cf_nculib_ROOT)
2194 ])dnl
2195 dnl ---------------------------------------------------------------------------
2196 dnl CF_NCURSES_VERSION version: 12 updated: 2007/04/28 09:15:55
2197 dnl ------------------
2198 dnl Check for the version of ncurses, to aid in reporting bugs, etc.
2199 dnl Call CF_CURSES_CPPFLAGS first, or CF_NCURSES_CPPFLAGS.  We don't use
2200 dnl AC_REQUIRE since that does not work with the shell's if/then/else/fi.
2201 AC_DEFUN([CF_NCURSES_VERSION],
2202 [
2203 AC_REQUIRE([CF_CURSES_CPPFLAGS])dnl
2204 AC_CACHE_CHECK(for ncurses version, cf_cv_ncurses_version,[
2205         cf_cv_ncurses_version=no
2206         cf_tempfile=out$$
2207         rm -f $cf_tempfile
2208         AC_TRY_RUN([
2209 #include <${cf_cv_ncurses_header-curses.h}>
2210 #include <stdio.h>
2211 int main()
2212 {
2213         FILE *fp = fopen("$cf_tempfile", "w");
2214 #ifdef NCURSES_VERSION
2215 # ifdef NCURSES_VERSION_PATCH
2216         fprintf(fp, "%s.%d\n", NCURSES_VERSION, NCURSES_VERSION_PATCH);
2217 # else
2218         fprintf(fp, "%s\n", NCURSES_VERSION);
2219 # endif
2220 #else
2221 # ifdef __NCURSES_H
2222         fprintf(fp, "old\n");
2223 # else
2224         make an error
2225 # endif
2226 #endif
2227         ${cf_cv_main_return-return}(0);
2228 }],[
2229         cf_cv_ncurses_version=`cat $cf_tempfile`],,[
2230
2231         # This will not work if the preprocessor splits the line after the
2232         # Autoconf token.  The 'unproto' program does that.
2233         cat > conftest.$ac_ext <<EOF
2234 #include <${cf_cv_ncurses_header-curses.h}>
2235 #undef Autoconf
2236 #ifdef NCURSES_VERSION
2237 Autoconf NCURSES_VERSION
2238 #else
2239 #ifdef __NCURSES_H
2240 Autoconf "old"
2241 #endif
2242 ;
2243 #endif
2244 EOF
2245         cf_try="$ac_cpp conftest.$ac_ext 2>&AC_FD_CC | grep '^Autoconf ' >conftest.out"
2246         AC_TRY_EVAL(cf_try)
2247         if test -f conftest.out ; then
2248                 cf_out=`cat conftest.out | sed -e 's%^Autoconf %%' -e 's%^[[^"]]*"%%' -e 's%".*%%'`
2249                 test -n "$cf_out" && cf_cv_ncurses_version="$cf_out"
2250                 rm -f conftest.out
2251         fi
2252 ])
2253         rm -f $cf_tempfile
2254 ])
2255 test "$cf_cv_ncurses_version" = no || AC_DEFINE(NCURSES)
2256 ])dnl
2257 dnl ---------------------------------------------------------------------------
2258 dnl CF_NO_LEAKS_OPTION version: 4 updated: 2006/12/16 14:24:05
2259 dnl ------------------
2260 dnl see CF_WITH_NO_LEAKS
2261 AC_DEFUN([CF_NO_LEAKS_OPTION],[
2262 AC_MSG_CHECKING(if you want to use $1 for testing)
2263 AC_ARG_WITH($1,
2264         [$2],
2265         [AC_DEFINE($3)ifelse([$4],,[
2266          $4
2267 ])
2268         : ${with_cflags:=-g}
2269         : ${with_no_leaks:=yes}
2270          with_$1=yes],
2271         [with_$1=])
2272 AC_MSG_RESULT(${with_$1:-no})
2273
2274 case .$with_cflags in #(vi
2275 .*-g*)
2276         case .$CFLAGS in #(vi
2277         .*-g*) #(vi
2278                 ;;
2279         *)
2280                 CF_ADD_CFLAGS([-g])
2281                 ;;
2282         esac
2283         ;;
2284 esac
2285 ])dnl
2286 dnl ---------------------------------------------------------------------------
2287 dnl CF_NUMBER_SYNTAX version: 1 updated: 2003/09/20 18:12:49
2288 dnl ----------------
2289 dnl Check if the given variable is a number.  If not, report an error.
2290 dnl $1 is the variable
2291 dnl $2 is the message
2292 AC_DEFUN([CF_NUMBER_SYNTAX],[
2293 if test -n "$1" ; then
2294   case $1 in #(vi
2295   [[0-9]]*) #(vi
2296         ;;
2297   *)
2298         AC_MSG_ERROR($2 is not a number: $1)
2299         ;;
2300   esac
2301 else
2302   AC_MSG_ERROR($2 value is empty)
2303 fi
2304 ])dnl
2305 dnl ---------------------------------------------------------------------------
2306 dnl CF_OBJ_SUBDIR version: 4 updated: 2002/02/23 20:38:31
2307 dnl -------------
2308 dnl Compute the object-directory name from the given model name
2309 AC_DEFUN([CF_OBJ_SUBDIR],
2310 [
2311         case $1 in
2312         libtool) $2='obj_lo'  ;;
2313         normal)  $2='objects' ;;
2314         debug)   $2='obj_g' ;;
2315         profile) $2='obj_p' ;;
2316         shared)
2317                 case $cf_cv_system_name in #(vi
2318                 cygwin) #(vi
2319                         $2='objects' ;;
2320                 *)
2321                         $2='obj_s' ;;
2322                 esac
2323         esac
2324 ])dnl
2325 dnl ---------------------------------------------------------------------------
2326 dnl CF_PATHSEP version: 5 updated: 2010/05/26 05:38:42
2327 dnl ----------
2328 dnl Provide a value for the $PATH and similar separator
2329 AC_DEFUN([CF_PATHSEP],
2330 [
2331         case $cf_cv_system_name in
2332         os2*)   PATH_SEPARATOR=';'  ;;
2333         *)      PATH_SEPARATOR=':'  ;;
2334         esac
2335 ifelse([$1],,,[$1=$PATH_SEPARATOR])
2336         AC_SUBST(PATH_SEPARATOR)
2337 ])dnl
2338 dnl ---------------------------------------------------------------------------
2339 dnl CF_PATH_SYNTAX version: 13 updated: 2010/05/26 05:38:42
2340 dnl --------------
2341 dnl Check the argument to see that it looks like a pathname.  Rewrite it if it
2342 dnl begins with one of the prefix/exec_prefix variables, and then again if the
2343 dnl result begins with 'NONE'.  This is necessary to work around autoconf's
2344 dnl delayed evaluation of those symbols.
2345 AC_DEFUN([CF_PATH_SYNTAX],[
2346 if test "x$prefix" != xNONE; then
2347   cf_path_syntax="$prefix"
2348 else
2349   cf_path_syntax="$ac_default_prefix"
2350 fi
2351
2352 case ".[$]$1" in #(vi
2353 .\[$]\(*\)*|.\'*\'*) #(vi
2354   ;;
2355 ..|./*|.\\*) #(vi
2356   ;;
2357 .[[a-zA-Z]]:[[\\/]]*) #(vi OS/2 EMX
2358   ;;
2359 .\[$]{*prefix}*) #(vi
2360   eval $1="[$]$1"
2361   case ".[$]$1" in #(vi
2362   .NONE/*)
2363     $1=`echo [$]$1 | sed -e s%NONE%$cf_path_syntax%`
2364     ;;
2365   esac
2366   ;; #(vi
2367 .no|.NONE/*)
2368   $1=`echo [$]$1 | sed -e s%NONE%$cf_path_syntax%`
2369   ;;
2370 *)
2371   ifelse([$2],,[AC_MSG_ERROR([expected a pathname, not \"[$]$1\"])],$2)
2372   ;;
2373 esac
2374 ])dnl
2375 dnl ---------------------------------------------------------------------------
2376 dnl CF_PKG_CONFIG version: 3 updated: 2009/01/25 10:55:09
2377 dnl -------------
2378 dnl Check for the package-config program, unless disabled by command-line.
2379 AC_DEFUN([CF_PKG_CONFIG],
2380 [
2381 AC_MSG_CHECKING(if you want to use pkg-config)
2382 AC_ARG_WITH(pkg-config,
2383         [  --with-pkg-config{=path} enable/disable use of pkg-config],
2384         [cf_pkg_config=$withval],
2385         [cf_pkg_config=yes])
2386 AC_MSG_RESULT($cf_pkg_config)
2387
2388 case $cf_pkg_config in #(vi
2389 no) #(vi
2390         PKG_CONFIG=none
2391         ;;
2392 yes) #(vi
2393         AC_PATH_PROG(PKG_CONFIG, pkg-config, none)
2394         ;;
2395 *)
2396         PKG_CONFIG=$withval
2397         ;;
2398 esac
2399
2400 test -z "$PKG_CONFIG" && PKG_CONFIG=none
2401 if test "$PKG_CONFIG" != none ; then
2402         CF_PATH_SYNTAX(PKG_CONFIG)
2403 fi
2404
2405 AC_SUBST(PKG_CONFIG)
2406 ])dnl
2407 dnl ---------------------------------------------------------------------------
2408 dnl CF_POSIX_C_SOURCE version: 8 updated: 2010/05/26 05:38:42
2409 dnl -----------------
2410 dnl Define _POSIX_C_SOURCE to the given level, and _POSIX_SOURCE if needed.
2411 dnl
2412 dnl     POSIX.1-1990                            _POSIX_SOURCE
2413 dnl     POSIX.1-1990 and                        _POSIX_SOURCE and
2414 dnl             POSIX.2-1992 C-Language                 _POSIX_C_SOURCE=2
2415 dnl             Bindings Option
2416 dnl     POSIX.1b-1993                           _POSIX_C_SOURCE=199309L
2417 dnl     POSIX.1c-1996                           _POSIX_C_SOURCE=199506L
2418 dnl     X/Open 2000                             _POSIX_C_SOURCE=200112L
2419 dnl
2420 dnl Parameters:
2421 dnl     $1 is the nominal value for _POSIX_C_SOURCE
2422 AC_DEFUN([CF_POSIX_C_SOURCE],
2423 [
2424 cf_POSIX_C_SOURCE=ifelse([$1],,199506L,[$1])
2425
2426 cf_save_CFLAGS="$CFLAGS"
2427 cf_save_CPPFLAGS="$CPPFLAGS"
2428
2429 CF_REMOVE_DEFINE(cf_trim_CFLAGS,$cf_save_CFLAGS,_POSIX_C_SOURCE)
2430 CF_REMOVE_DEFINE(cf_trim_CPPFLAGS,$cf_save_CPPFLAGS,_POSIX_C_SOURCE)
2431
2432 AC_CACHE_CHECK(if we should define _POSIX_C_SOURCE,cf_cv_posix_c_source,[
2433         CF_MSG_LOG(if the symbol is already defined go no further)
2434         AC_TRY_COMPILE([#include <sys/types.h>],[
2435 #ifndef _POSIX_C_SOURCE
2436 make an error
2437 #endif],
2438         [cf_cv_posix_c_source=no],
2439         [cf_want_posix_source=no
2440          case .$cf_POSIX_C_SOURCE in #(vi
2441          .[[12]]??*) #(vi
2442                 cf_cv_posix_c_source="-D_POSIX_C_SOURCE=$cf_POSIX_C_SOURCE"
2443                 ;;
2444          .2) #(vi
2445                 cf_cv_posix_c_source="-D_POSIX_C_SOURCE=$cf_POSIX_C_SOURCE"
2446                 cf_want_posix_source=yes
2447                 ;;
2448          .*)
2449                 cf_want_posix_source=yes
2450                 ;;
2451          esac
2452          if test "$cf_want_posix_source" = yes ; then
2453                 AC_TRY_COMPILE([#include <sys/types.h>],[
2454 #ifdef _POSIX_SOURCE
2455 make an error
2456 #endif],[],
2457                 cf_cv_posix_c_source="$cf_cv_posix_c_source -D_POSIX_SOURCE")
2458          fi
2459          CF_MSG_LOG(ifdef from value $cf_POSIX_C_SOURCE)
2460          CFLAGS="$cf_trim_CFLAGS"
2461          CPPFLAGS="$cf_trim_CPPFLAGS $cf_cv_posix_c_source"
2462          CF_MSG_LOG(if the second compile does not leave our definition intact error)
2463          AC_TRY_COMPILE([#include <sys/types.h>],[
2464 #ifndef _POSIX_C_SOURCE
2465 make an error
2466 #endif],,
2467          [cf_cv_posix_c_source=no])
2468          CFLAGS="$cf_save_CFLAGS"
2469          CPPFLAGS="$cf_save_CPPFLAGS"
2470         ])
2471 ])
2472
2473 if test "$cf_cv_posix_c_source" != no ; then
2474         CFLAGS="$cf_trim_CFLAGS"
2475         CPPFLAGS="$cf_trim_CPPFLAGS"
2476         CF_ADD_CFLAGS($cf_cv_posix_c_source)
2477 fi
2478
2479 ])dnl
2480 dnl ---------------------------------------------------------------------------
2481 dnl CF_PROG_AR version: 1 updated: 2009/01/01 20:15:22
2482 dnl ----------
2483 dnl Check for archiver "ar".
2484 AC_DEFUN([CF_PROG_AR],[
2485 AC_CHECK_TOOL(AR, ar, ar)
2486 ])
2487 dnl ---------------------------------------------------------------------------
2488 dnl CF_PROG_AWK version: 1 updated: 2006/09/16 11:40:59
2489 dnl -----------
2490 dnl Check for awk, ensure that the check found something.
2491 AC_DEFUN([CF_PROG_AWK],
2492 [
2493 AC_PROG_AWK
2494 test -z "$AWK" && AC_MSG_ERROR(No awk program found)
2495 ])dnl
2496 dnl ---------------------------------------------------------------------------
2497 dnl CF_PROG_CC_C_O version: 2 updated: 2006/12/16 15:55:46
2498 dnl --------------
2499 dnl Analogous to AC_PROG_CC_C_O, but more useful: tests only $CC, ensures that
2500 dnl the output file can be renamed, and allows for a shell variable that can
2501 dnl be used later.  The parameter is either CC or CXX.  The result is the
2502 dnl cache variable:
2503 dnl     $cf_cv_prog_CC_c_o
2504 dnl     $cf_cv_prog_CXX_c_o
2505 AC_DEFUN([CF_PROG_CC_C_O],
2506 [AC_REQUIRE([AC_PROG_CC])dnl
2507 AC_MSG_CHECKING([whether [$]$1 understands -c and -o together])
2508 AC_CACHE_VAL(cf_cv_prog_$1_c_o,
2509 [
2510 cat > conftest.$ac_ext <<CF_EOF
2511 #include <stdio.h>
2512 int main()
2513 {
2514         ${cf_cv_main_return:-return}(0);
2515 }
2516 CF_EOF
2517 # We do the test twice because some compilers refuse to overwrite an
2518 # existing .o file with -o, though they will create one.
2519 ac_try='[$]$1 -c conftest.$ac_ext -o conftest2.$ac_objext >&AC_FD_CC'
2520 if AC_TRY_EVAL(ac_try) &&
2521   test -f conftest2.$ac_objext && AC_TRY_EVAL(ac_try);
2522 then
2523   eval cf_cv_prog_$1_c_o=yes
2524 else
2525   eval cf_cv_prog_$1_c_o=no
2526 fi
2527 rm -f conftest*
2528 ])dnl
2529 if test $cf_cv_prog_$1_c_o = yes; then
2530   AC_MSG_RESULT([yes])
2531 else
2532   AC_MSG_RESULT([no])
2533 fi
2534 ])dnl
2535 dnl ---------------------------------------------------------------------------
2536 dnl CF_PROG_EGREP version: 1 updated: 2006/09/16 11:40:59
2537 dnl -------------
2538 dnl AC_PROG_EGREP was introduced in autoconf 2.53.
2539 dnl This macro adds a check to ensure the script found something.
2540 AC_DEFUN([CF_PROG_EGREP],
2541 [AC_CACHE_CHECK([for egrep], [ac_cv_prog_egrep],
2542    [if echo a | (grep -E '(a|b)') >/dev/null 2>&1
2543     then ac_cv_prog_egrep='grep -E'
2544     else ac_cv_prog_egrep='egrep'
2545     fi])
2546  EGREP=$ac_cv_prog_egrep
2547  AC_SUBST([EGREP])
2548 test -z "$EGREP" && AC_MSG_ERROR(No egrep program found)
2549 ])dnl
2550 dnl ---------------------------------------------------------------------------
2551 dnl CF_PROG_EXT version: 10 updated: 2004/01/03 19:28:18
2552 dnl -----------
2553 dnl Compute $PROG_EXT, used for non-Unix ports, such as OS/2 EMX.
2554 AC_DEFUN([CF_PROG_EXT],
2555 [
2556 AC_REQUIRE([CF_CHECK_CACHE])
2557 case $cf_cv_system_name in
2558 os2*)
2559     CFLAGS="$CFLAGS -Zmt"
2560     CPPFLAGS="$CPPFLAGS -D__ST_MT_ERRNO__"
2561     CXXFLAGS="$CXXFLAGS -Zmt"
2562     # autoconf's macro sets -Zexe and suffix both, which conflict:w
2563     LDFLAGS="$LDFLAGS -Zmt -Zcrtdll"
2564     ac_cv_exeext=.exe
2565     ;;
2566 esac
2567
2568 AC_EXEEXT
2569 AC_OBJEXT
2570
2571 PROG_EXT="$EXEEXT"
2572 AC_SUBST(PROG_EXT)
2573 test -n "$PROG_EXT" && AC_DEFINE_UNQUOTED(PROG_EXT,"$PROG_EXT")
2574 ])dnl
2575 dnl ---------------------------------------------------------------------------
2576 dnl CF_PROG_GNAT version: 1 updated: 2010/06/19 15:22:18
2577 dnl ------------
2578 dnl Check for gnatmake, ensure that it is complete.
2579 AC_DEFUN([CF_PROG_GNAT],[
2580 cf_ada_make=gnatmake
2581 AC_CHECK_PROG(gnat_exists, $cf_ada_make, yes, no)
2582 if test "$ac_cv_prog_gnat_exists" = no; then
2583    cf_ada_make=
2584 else
2585    CF_GNAT_VERSION
2586    AC_CHECK_PROG(M4_exists, m4, yes, no)
2587    if test "$ac_cv_prog_M4_exists" = no; then
2588       cf_cv_prog_gnat_correct=no
2589       echo Ada95 binding required program m4 not found. Ada95 binding disabled.
2590    fi
2591    if test "$cf_cv_prog_gnat_correct" = yes; then
2592       AC_MSG_CHECKING(if GNAT works)
2593       CF_GNAT_TRY_RUN([procedure conftest;],
2594 [with Text_IO;
2595 with GNAT.OS_Lib;
2596 procedure conftest is
2597 begin
2598    Text_IO.Put ("Hello World");
2599    Text_IO.New_Line;
2600    GNAT.OS_Lib.OS_Exit (0);
2601 end conftest;],[cf_cv_prog_gnat_correct=yes],[cf_cv_prog_gnat_correct=no])
2602       AC_MSG_RESULT($cf_cv_prog_gnat_correct)
2603    fi
2604 fi
2605
2606 AC_SUBST(cf_ada_make)
2607 ])dnl
2608 dnl ---------------------------------------------------------------------------
2609 dnl CF_REMOVE_DEFINE version: 3 updated: 2010/01/09 11:05:50
2610 dnl ----------------
2611 dnl Remove all -U and -D options that refer to the given symbol from a list
2612 dnl of C compiler options.  This works around the problem that not all
2613 dnl compilers process -U and -D options from left-to-right, so a -U option
2614 dnl cannot be used to cancel the effect of a preceding -D option.
2615 dnl
2616 dnl $1 = target (which could be the same as the source variable)
2617 dnl $2 = source (including '$')
2618 dnl $3 = symbol to remove
2619 define([CF_REMOVE_DEFINE],
2620 [
2621 $1=`echo "$2" | \
2622         sed     -e 's/-[[UD]]'"$3"'\(=[[^       ]]*\)\?[[       ]]/ /g' \
2623                 -e 's/-[[UD]]'"$3"'\(=[[^       ]]*\)\?[$]//g'`
2624 ])dnl
2625 dnl ---------------------------------------------------------------------------
2626 dnl CF_REMOVE_LIB version: 1 updated: 2007/02/17 14:11:52
2627 dnl -------------
2628 dnl Remove the given library from the symbol
2629 dnl
2630 dnl $1 = target (which could be the same as the source variable)
2631 dnl $2 = source (including '$')
2632 dnl $3 = library to remove
2633 define([CF_REMOVE_LIB],
2634 [
2635 # remove $3 library from $2
2636 $1=`echo "$2" | sed -e 's/-l$3[[        ]]//g' -e 's/-l$3[$]//'`
2637 ])dnl
2638 dnl ---------------------------------------------------------------------------
2639 dnl CF_SHARED_OPTS version: 64 updated: 2010/06/05 16:51:16
2640 dnl --------------
2641 dnl --------------
2642 dnl Attempt to determine the appropriate CC/LD options for creating a shared
2643 dnl library.
2644 dnl
2645 dnl Note: ${LOCAL_LDFLAGS} is used to link executables that will run within the
2646 dnl build-tree, i.e., by making use of the libraries that are compiled in ../lib
2647 dnl We avoid compiling-in a ../lib path for the shared library since that can
2648 dnl lead to unexpected results at runtime.
2649 dnl ${LOCAL_LDFLAGS2} has the same intention but assumes that the shared libraries
2650 dnl are compiled in ../../lib
2651 dnl
2652 dnl The variable 'cf_cv_do_symlinks' is used to control whether we configure
2653 dnl to install symbolic links to the rel/abi versions of shared libraries.
2654 dnl
2655 dnl The variable 'cf_cv_shlib_version' controls whether we use the rel or abi
2656 dnl version when making symbolic links.
2657 dnl
2658 dnl The variable 'cf_cv_shlib_version_infix' controls whether shared library
2659 dnl version numbers are infix (ex: libncurses.<ver>.dylib) or postfix
2660 dnl (ex: libncurses.so.<ver>).
2661 dnl
2662 dnl Some loaders leave 'so_locations' lying around.  It's nice to clean up.
2663 AC_DEFUN([CF_SHARED_OPTS],
2664 [
2665         AC_REQUIRE([CF_SUBST_NCURSES_VERSION])
2666         AC_REQUIRE([CF_LD_RPATH_OPT])
2667         LOCAL_LDFLAGS=
2668         LOCAL_LDFLAGS2=
2669         LD_SHARED_OPTS=
2670         INSTALL_LIB="-m 644"
2671
2672         cf_cv_do_symlinks=no
2673         cf_ld_rpath_opt=
2674         test "$cf_cv_enable_rpath" = yes && cf_ld_rpath_opt="$LD_RPATH_OPT"
2675
2676         AC_MSG_CHECKING(if release/abi version should be used for shared libs)
2677         AC_ARG_WITH(shlib-version,
2678         [  --with-shlib-version=X  Specify rel or abi version for shared libs],
2679         [test -z "$withval" && withval=auto
2680         case $withval in #(vi
2681         yes) #(vi
2682                 cf_cv_shlib_version=auto
2683                 ;;
2684         rel|abi|auto|no) #(vi
2685                 cf_cv_shlib_version=$withval
2686                 ;;
2687         *)
2688                 AC_MSG_ERROR([option value must be one of: rel, abi, auto or no])
2689                 ;;
2690         esac
2691         ],[cf_cv_shlib_version=auto])
2692         AC_MSG_RESULT($cf_cv_shlib_version)
2693
2694         cf_cv_rm_so_locs=no
2695
2696         # Some less-capable ports of gcc support only -fpic
2697         CC_SHARED_OPTS=
2698         if test "$GCC" = yes
2699         then
2700                 AC_MSG_CHECKING(which $CC option to use)
2701                 cf_save_CFLAGS="$CFLAGS"
2702                 for CC_SHARED_OPTS in -fPIC -fpic ''
2703                 do
2704                         CFLAGS="$cf_save_CFLAGS $CC_SHARED_OPTS"
2705                         AC_TRY_COMPILE([#include <stdio.h>],[int x = 1],[break],[])
2706                 done
2707                 AC_MSG_RESULT($CC_SHARED_OPTS)
2708                 CFLAGS="$cf_save_CFLAGS"
2709         fi
2710
2711         cf_cv_shlib_version_infix=no
2712
2713         case $cf_cv_system_name in #(vi
2714         aix[[56]]*) #(vi
2715                 if test "$GCC" = yes; then
2716                         CC_SHARED_OPTS=
2717                         MK_SHARED_LIB='$(CC) -shared'
2718                 fi
2719                 ;;
2720         beos*) #(vi
2721                 MK_SHARED_LIB='${CC} ${CFLAGS} -o $[@] -Xlinker -soname=`basename $[@]` -nostart -e 0'
2722                 ;;
2723         cygwin*) #(vi
2724                 CC_SHARED_OPTS=
2725                 MK_SHARED_LIB='sh ../mk_shared_lib.sh [$]@ [$]{CC} [$]{CFLAGS}'
2726                 cf_cv_shlib_version=cygdll
2727                 cf_cv_shlib_version_infix=cygdll
2728                 cat >mk_shared_lib.sh <<-CF_EOF
2729                 #!/bin/sh
2730                 SHARED_LIB=\[$]1
2731                 IMPORT_LIB=\`echo "\[$]1" | sed -e 's/cyg/lib/' -e 's/[[0-9]]*\.dll[$]/.dll.a/'\`
2732                 shift
2733                 cat <<-EOF
2734                 Linking shared library
2735                 ** SHARED_LIB \[$]SHARED_LIB
2736                 ** IMPORT_LIB \[$]IMPORT_LIB
2737 EOF
2738                 exec \[$]* -shared -Wl,--out-implib=../lib/\[$]{IMPORT_LIB} -Wl,--export-all-symbols -o ../lib/\[$]{SHARED_LIB}
2739 CF_EOF
2740                 chmod +x mk_shared_lib.sh
2741                 ;;
2742         darwin*) #(vi
2743                 EXTRA_CFLAGS="-no-cpp-precomp"
2744                 CC_SHARED_OPTS="-dynamic"
2745                 MK_SHARED_LIB='${CC} ${CFLAGS} -dynamiclib -install_name ${libdir}/`basename $[@]` -compatibility_version ${ABI_VERSION} -current_version ${ABI_VERSION} -o $[@]'
2746                 test "$cf_cv_shlib_version" = auto && cf_cv_shlib_version=abi
2747                 cf_cv_shlib_version_infix=yes
2748                 AC_CACHE_CHECK([if ld -search_paths_first works], cf_cv_ldflags_search_paths_first, [
2749                         cf_save_LDFLAGS=$LDFLAGS
2750                         LDFLAGS="$LDFLAGS -Wl,-search_paths_first"
2751                         AC_TRY_LINK(, [int i;], cf_cv_ldflags_search_paths_first=yes, cf_cv_ldflags_search_paths_first=no)
2752                                 LDFLAGS=$cf_save_LDFLAGS])
2753                 if test $cf_cv_ldflags_search_paths_first = yes; then
2754                         LDFLAGS="$LDFLAGS -Wl,-search_paths_first"
2755                 fi
2756                 ;;
2757         hpux*) #(vi
2758                 # (tested with gcc 2.7.2 -- I don't have c89)
2759                 if test "$GCC" = yes; then
2760                         LD_SHARED_OPTS='-Xlinker +b -Xlinker ${libdir}'
2761                 else
2762                         CC_SHARED_OPTS='+Z'
2763                         LD_SHARED_OPTS='-Wl,+b,${libdir}'
2764                 fi
2765                 MK_SHARED_LIB='${LD} +b ${libdir} -b -o $[@]'
2766                 # HP-UX shared libraries must be executable, and should be
2767                 # readonly to exploit a quirk in the memory manager.
2768                 INSTALL_LIB="-m 555"
2769                 ;;
2770         irix*) #(vi
2771                 if test "$cf_cv_enable_rpath" = yes ; then
2772                         EXTRA_LDFLAGS="${cf_ld_rpath_opt}\${libdir} $EXTRA_LDFLAGS"
2773                 fi
2774                 # tested with IRIX 5.2 and 'cc'.
2775                 if test "$GCC" != yes; then
2776                         CC_SHARED_OPTS='-KPIC'
2777                         MK_SHARED_LIB='${CC} -shared -rdata_shared -soname `basename $[@]` -o $[@]'
2778                 else
2779                         MK_SHARED_LIB='${CC} -shared -Wl,-soname,`basename $[@]` -o $[@]'
2780                 fi
2781                 cf_cv_rm_so_locs=yes
2782                 ;;
2783         linux*|gnu*|k*bsd*-gnu) #(vi
2784                 if test "$DFT_LWR_MODEL" = "shared" ; then
2785                         LOCAL_LDFLAGS="${LD_RPATH_OPT}\$(LOCAL_LIBDIR)"
2786                         LOCAL_LDFLAGS2="$LOCAL_LDFLAGS"
2787                 fi
2788                 if test "$cf_cv_enable_rpath" = yes ; then
2789                         EXTRA_LDFLAGS="${cf_ld_rpath_opt}\${libdir} $EXTRA_LDFLAGS"
2790                 fi
2791                 CF_SHARED_SONAME
2792                 MK_SHARED_LIB='${CC} ${CFLAGS} -shared -Wl,-soname,'$cf_cv_shared_soname',-stats,-lc -o $[@]'
2793                 ;;
2794         openbsd[[2-9]].*) #(vi
2795                 if test "$DFT_LWR_MODEL" = "shared" ; then
2796                         LOCAL_LDFLAGS="${LD_RPATH_OPT}\$(LOCAL_LIBDIR)"
2797                         LOCAL_LDFLAGS2="$LOCAL_LDFLAGS"
2798                 fi
2799                 if test "$cf_cv_enable_rpath" = yes ; then
2800                         EXTRA_LDFLAGS="${cf_ld_rpath_opt}\${libdir} $EXTRA_LDFLAGS"
2801                 fi
2802                 CC_SHARED_OPTS="$CC_SHARED_OPTS -DPIC"
2803                 CF_SHARED_SONAME
2804                 MK_SHARED_LIB='${CC} ${CFLAGS} -shared -Wl,-Bshareable,-soname,'$cf_cv_shared_soname',-stats,-lc -o $[@]'
2805                 ;;
2806         nto-qnx*|openbsd*|freebsd[[12]].*) #(vi
2807                 CC_SHARED_OPTS="$CC_SHARED_OPTS -DPIC"
2808                 MK_SHARED_LIB='${LD} -Bshareable -o $[@]'
2809                 test "$cf_cv_shlib_version" = auto && cf_cv_shlib_version=rel
2810                 ;;
2811         freebsd*) #(vi
2812                 CC_SHARED_OPTS="$CC_SHARED_OPTS -DPIC"
2813                 if test "$DFT_LWR_MODEL" = "shared" && test "$cf_cv_enable_rpath" = yes ; then
2814                         LOCAL_LDFLAGS="${cf_ld_rpath_opt}\$(LOCAL_LIBDIR)"
2815                         LOCAL_LDFLAGS2="${cf_ld_rpath_opt}\${libdir} $LOCAL_LDFLAGS"
2816                         EXTRA_LDFLAGS="${cf_ld_rpath_opt}\${libdir} $EXTRA_LDFLAGS"
2817                 fi
2818                 CF_SHARED_SONAME
2819                 MK_SHARED_LIB='${LD} -shared -Bshareable -soname=`basename $[@]` -o $[@]'
2820                 ;;
2821         netbsd*) #(vi
2822                 CC_SHARED_OPTS="$CC_SHARED_OPTS -DPIC"
2823                 if test "$DFT_LWR_MODEL" = "shared" && test "$cf_cv_enable_rpath" = yes ; then
2824                         LOCAL_LDFLAGS="${cf_ld_rpath_opt}\$(LOCAL_LIBDIR)"
2825                         LOCAL_LDFLAGS2="$LOCAL_LDFLAGS"
2826                         EXTRA_LDFLAGS="${cf_ld_rpath_opt}\${libdir} $EXTRA_LDFLAGS"
2827                         if test "$cf_cv_shlib_version" = auto; then
2828                         if test -f /usr/libexec/ld.elf_so; then
2829                                 cf_cv_shlib_version=abi
2830                         else
2831                                 cf_cv_shlib_version=rel
2832                         fi
2833                         fi
2834                         CF_SHARED_SONAME
2835                         MK_SHARED_LIB='${CC} ${CFLAGS} -shared -Wl,-soname,'$cf_cv_shared_soname' -o $[@]'
2836                 else
2837                         MK_SHARED_LIB='${LD} -shared -Bshareable -o $[@]'
2838                 fi
2839                 ;;
2840         osf*|mls+*) #(vi
2841                 # tested with OSF/1 V3.2 and 'cc'
2842                 # tested with OSF/1 V3.2 and gcc 2.6.3 (but the c++ demo didn't
2843                 # link with shared libs).
2844                 MK_SHARED_LIB='${LD} -set_version ${REL_VERSION}:${ABI_VERSION} -expect_unresolved "*" -shared -soname `basename $[@]`'
2845                 case $host_os in #(vi
2846                 osf4*)
2847                         MK_SHARED_LIB="${MK_SHARED_LIB} -msym"
2848                         ;;
2849                 esac
2850                 MK_SHARED_LIB="${MK_SHARED_LIB}"' -o $[@]'
2851                 if test "$DFT_LWR_MODEL" = "shared" ; then
2852                         LOCAL_LDFLAGS="${LD_RPATH_OPT}\$(LOCAL_LIBDIR)"
2853                         LOCAL_LDFLAGS2="$LOCAL_LDFLAGS"
2854                 fi
2855                 cf_cv_rm_so_locs=yes
2856                 ;;
2857         sco3.2v5*)  # (also uw2* and UW7: hops 13-Apr-98
2858                 # tested with osr5.0.5
2859                 if test "$GCC" != yes; then
2860                         CC_SHARED_OPTS='-belf -KPIC'
2861                 fi
2862                 MK_SHARED_LIB='${LD} -dy -G -h `basename $[@] .${REL_VERSION}`.${ABI_VERSION} -o [$]@'
2863                 if test "$cf_cv_enable_rpath" = yes ; then
2864                         # only way is to set LD_RUN_PATH but no switch for it
2865                         RUN_PATH=$libdir
2866                 fi
2867                 test "$cf_cv_shlib_version" = auto && cf_cv_shlib_version=rel
2868                 LINK_PROGS='LD_RUN_PATH=${libdir}'
2869                 LINK_TESTS='Pwd=`pwd`;LD_RUN_PATH=`dirname $${Pwd}`/lib'
2870                 ;;
2871         sunos4*) #(vi
2872                 # tested with SunOS 4.1.1 and gcc 2.7.0
2873                 if test "$GCC" != yes; then
2874                         CC_SHARED_OPTS='-KPIC'
2875                 fi
2876                 MK_SHARED_LIB='${LD} -assert pure-text -o $[@]'
2877                 test "$cf_cv_shlib_version" = auto && cf_cv_shlib_version=rel
2878                 ;;
2879         solaris2*) #(vi
2880                 # tested with SunOS 5.5.1 (solaris 2.5.1) and gcc 2.7.2
2881                 # tested with SunOS 5.10 (solaris 10) and gcc 3.4.3
2882                 if test "$DFT_LWR_MODEL" = "shared" ; then
2883                         LOCAL_LDFLAGS="-R \$(LOCAL_LIBDIR):\${libdir}"
2884                         LOCAL_LDFLAGS2="$LOCAL_LDFLAGS"
2885                 fi
2886                 if test "$cf_cv_enable_rpath" = yes ; then
2887                         EXTRA_LDFLAGS="-R \${libdir} $EXTRA_LDFLAGS"
2888                 fi
2889                 CF_SHARED_SONAME
2890                 if test "$GCC" != yes; then
2891                         cf_save_CFLAGS="$CFLAGS"
2892                         for cf_shared_opts in -xcode=pic32 -xcode=pic13 -KPIC -Kpic -O
2893                         do
2894                                 CFLAGS="$cf_shared_opts $cf_save_CFLAGS"
2895                                 AC_TRY_COMPILE([#include <stdio.h>],[printf("Hello\n");],[break])
2896                         done
2897                         CFLAGS="$cf_save_CFLAGS"
2898                         CC_SHARED_OPTS=$cf_shared_opts
2899                         MK_SHARED_LIB='${CC} -dy -G -h '$cf_cv_shared_soname' -o $[@]'
2900                 else
2901                         MK_SHARED_LIB='${CC} -shared -dy -G -h '$cf_cv_shared_soname' -o $[@]'
2902                 fi
2903                 ;;
2904         sysv5uw7*|unix_sv*) #(vi
2905                 # tested with UnixWare 7.1.0 (gcc 2.95.2 and cc)
2906                 if test "$GCC" != yes; then
2907                         CC_SHARED_OPTS='-KPIC'
2908                 fi
2909                 MK_SHARED_LIB='${LD} -d y -G -o [$]@'
2910                 ;;
2911         *)
2912                 CC_SHARED_OPTS='unknown'
2913                 MK_SHARED_LIB='echo unknown'
2914                 ;;
2915         esac
2916
2917         # This works if the last tokens in $MK_SHARED_LIB are the -o target.
2918         case "$cf_cv_shlib_version" in #(vi
2919         rel|abi)
2920                 case "$MK_SHARED_LIB" in #(vi
2921                 *'-o $[@]') #(vi
2922                         test "$cf_cv_do_symlinks" = no && cf_cv_do_symlinks=yes
2923                         ;;
2924                 *)
2925                         AC_MSG_WARN(ignored --with-shlib-version)
2926                         ;;
2927                 esac
2928                 ;;
2929         esac
2930
2931         if test -n "$cf_ld_rpath_opt" ; then
2932                 MK_SHARED_LIB="$MK_SHARED_LIB $cf_ld_rpath_opt\${libdir}"
2933         fi
2934
2935         AC_SUBST(CC_SHARED_OPTS)
2936         AC_SUBST(LD_RPATH_OPT)
2937         AC_SUBST(LD_SHARED_OPTS)
2938         AC_SUBST(MK_SHARED_LIB)
2939         AC_SUBST(LINK_PROGS)
2940         AC_SUBST(LINK_TESTS)
2941         AC_SUBST(EXTRA_LDFLAGS)
2942         AC_SUBST(LOCAL_LDFLAGS)
2943         AC_SUBST(LOCAL_LDFLAGS2)
2944         AC_SUBST(INSTALL_LIB)
2945 ])dnl
2946 dnl ---------------------------------------------------------------------------
2947 dnl CF_SHARED_SONAME version: 3 updated: 2008/09/08 18:34:43
2948 dnl ----------------
2949 dnl utility macro for CF_SHARED_OPTS, constructs "$cf_cv_shared_soname" for
2950 dnl substitution into MK_SHARED_LIB string for the "-soname" (or similar)
2951 dnl option.
2952 dnl
2953 dnl $1 is the default that should be used for "$cf_cv_shlib_version".
2954 dnl If missing, use "rel".
2955 define([CF_SHARED_SONAME],
2956 [
2957         test "$cf_cv_shlib_version" = auto && cf_cv_shlib_version=ifelse($1,,rel,$1)
2958         if test "$cf_cv_shlib_version" = rel; then
2959                 cf_cv_shared_soname='`basename $[@] .${REL_VERSION}`.${ABI_VERSION}'
2960         else
2961                 cf_cv_shared_soname='`basename $[@]`'
2962         fi
2963 ])
2964 dnl ---------------------------------------------------------------------------
2965 dnl CF_STRIP_G_OPT version: 3 updated: 2002/12/21 19:25:52
2966 dnl --------------
2967 dnl     Remove "-g" option from the compiler options
2968 AC_DEFUN([CF_STRIP_G_OPT],
2969 [$1=`echo ${$1} | sed -e 's%-g %%' -e 's%-g$%%'`])dnl
2970 dnl ---------------------------------------------------------------------------
2971 dnl CF_SUBDIR_PATH version: 6 updated: 2010/04/21 06:20:50
2972 dnl --------------
2973 dnl Construct a search-list for a nonstandard header/lib-file
2974 dnl     $1 = the variable to return as result
2975 dnl     $2 = the package name
2976 dnl     $3 = the subdirectory, e.g., bin, include or lib
2977 AC_DEFUN([CF_SUBDIR_PATH],
2978 [
2979 $1=
2980
2981 CF_ADD_SUBDIR_PATH($1,$2,$3,/usr,$prefix)
2982 CF_ADD_SUBDIR_PATH($1,$2,$3,$prefix,NONE)
2983 CF_ADD_SUBDIR_PATH($1,$2,$3,/usr/local,$prefix)
2984 CF_ADD_SUBDIR_PATH($1,$2,$3,/opt,$prefix)
2985 CF_ADD_SUBDIR_PATH($1,$2,$3,[$]HOME,$prefix)
2986 ])dnl
2987 dnl ---------------------------------------------------------------------------
2988 dnl CF_SUBST version: 4 updated: 2006/06/17 12:33:03
2989 dnl --------
2990 dnl     Shorthand macro for substituting things that the user may override
2991 dnl     with an environment variable.
2992 dnl
2993 dnl     $1 = long/descriptive name
2994 dnl     $2 = environment variable
2995 dnl     $3 = default value
2996 AC_DEFUN([CF_SUBST],
2997 [AC_CACHE_VAL(cf_cv_subst_$2,[
2998 AC_MSG_CHECKING(for $1 (symbol $2))
2999 CF_SUBST_IF([-z "[$]$2"], [$2], [$3])
3000 cf_cv_subst_$2=[$]$2
3001 AC_MSG_RESULT([$]$2)
3002 ])
3003 ])dnl
3004 dnl ---------------------------------------------------------------------------
3005 dnl CF_TERM_HEADER version: 1 updated: 2005/12/31 13:26:39
3006 dnl --------------
3007 dnl Look for term.h, which is part of X/Open curses.  It defines the interface
3008 dnl to terminfo database.  Usually it is in the same include-path as curses.h,
3009 dnl but some packagers change this, breaking various applications.
3010 AC_DEFUN([CF_TERM_HEADER],[
3011 AC_CACHE_CHECK(for terminfo header, cf_cv_term_header,[
3012 case ${cf_cv_ncurses_header} in #(vi
3013 */ncurses.h|*/ncursesw.h) #(vi
3014         cf_term_header=`echo "$cf_cv_ncurses_header" | sed -e 's%ncurses[[^.]]*\.h$%term.h%'`
3015         ;;
3016 *)
3017         cf_term_header=term.h
3018         ;;
3019 esac
3020
3021 for cf_test in $cf_term_header "ncurses/term.h" "ncursesw/term.h"
3022 do
3023 AC_TRY_COMPILE([#include <stdio.h>
3024 #include <${cf_cv_ncurses_header-curses.h}>
3025 #include <$cf_test>
3026 ],[int x = auto_left_margin],[
3027         cf_cv_term_header="$cf_test"],[
3028         cf_cv_term_header=unknown
3029         ])
3030         test "$cf_cv_term_header" != unknown && break
3031 done
3032 ])
3033
3034 # Set definitions to allow ifdef'ing to accommodate subdirectories
3035
3036 case $cf_cv_term_header in # (vi
3037 *term.h)
3038         AC_DEFINE(HAVE_TERM_H)
3039         ;;
3040 esac
3041
3042 case $cf_cv_term_header in # (vi
3043 ncurses/term.h) #(vi
3044         AC_DEFINE(HAVE_NCURSES_TERM_H)
3045         ;;
3046 ncursesw/term.h)
3047         AC_DEFINE(HAVE_NCURSESW_TERM_H)
3048         ;;
3049 esac
3050 ])dnl
3051 dnl ---------------------------------------------------------------------------
3052 dnl CF_TOP_BUILDDIR version: 1 updated: 2006/10/15 16:33:23
3053 dnl ---------------
3054 dnl Define a top_builddir symbol, for applications that need an absolute path.
3055 AC_DEFUN([CF_TOP_BUILDDIR],
3056 [
3057 top_builddir=`pwd`
3058 AC_SUBST(top_builddir)
3059 ])dnl
3060 dnl ---------------------------------------------------------------------------
3061 dnl CF_UPPER version: 5 updated: 2001/01/29 23:40:59
3062 dnl --------
3063 dnl Make an uppercase version of a variable
3064 dnl $1=uppercase($2)
3065 AC_DEFUN([CF_UPPER],
3066 [
3067 $1=`echo "$2" | sed y%abcdefghijklmnopqrstuvwxyz./-%ABCDEFGHIJKLMNOPQRSTUVWXYZ___%`
3068 ])dnl
3069 dnl ---------------------------------------------------------------------------
3070 dnl CF_UTF8_LIB version: 6 updated: 2010/04/21 06:20:50
3071 dnl -----------
3072 dnl Check for multibyte support, and if not found, utf8 compatibility library
3073 AC_DEFUN([CF_UTF8_LIB],
3074 [
3075 AC_CACHE_CHECK(for multibyte character support,cf_cv_utf8_lib,[
3076         cf_save_LIBS="$LIBS"
3077         AC_TRY_LINK([
3078 #include <stdlib.h>],[putwc(0,0);],
3079         [cf_cv_utf8_lib=yes],
3080         [CF_FIND_LINKAGE([
3081 #include <libutf8.h>],[putwc(0,0);],utf8,
3082                 [cf_cv_utf8_lib=add-on],
3083                 [cf_cv_utf8_lib=no])
3084 ])])
3085
3086 # HAVE_LIBUTF8_H is used by ncurses if curses.h is shared between
3087 # ncurses/ncursesw:
3088 if test "$cf_cv_utf8_lib" = "add-on" ; then
3089         AC_DEFINE(HAVE_LIBUTF8_H)
3090         CF_ADD_INCDIR($cf_cv_header_path_utf8)
3091         CF_ADD_LIBDIR($cf_cv_library_path_utf8)
3092         LIBS="$cf_cv_library_file_utf8 $LIBS"
3093 fi
3094 ])dnl
3095 dnl ---------------------------------------------------------------------------
3096 dnl CF_VERBOSE version: 3 updated: 2007/07/29 09:55:12
3097 dnl ----------
3098 dnl Use AC_VERBOSE w/o the warnings
3099 AC_DEFUN([CF_VERBOSE],
3100 [test -n "$verbose" && echo "   $1" 1>&AC_FD_MSG
3101 CF_MSG_LOG([$1])
3102 ])dnl
3103 dnl ---------------------------------------------------------------------------
3104 dnl CF_WEAK_SYMBOLS version: 1 updated: 2008/08/16 19:18:06
3105 dnl ---------------
3106 dnl Check for compiler-support for weak symbols.
3107 dnl This works with "recent" gcc.
3108 AC_DEFUN([CF_WEAK_SYMBOLS],[
3109 AC_CACHE_CHECK(if $CC supports weak symbols,cf_cv_weak_symbols,[
3110
3111 AC_TRY_COMPILE([
3112 #include <stdio.h>],
3113 [
3114 #if defined(__GNUC__)
3115 #  if defined __USE_ISOC99
3116 #    define _cat_pragma(exp)    _Pragma(#exp)
3117 #    define _weak_pragma(exp)   _cat_pragma(weak name)
3118 #  else
3119 #    define _weak_pragma(exp)
3120 #  endif
3121 #  define _declare(name)        __extension__ extern __typeof__(name) name
3122 #  define weak_symbol(name)     _weak_pragma(name) _declare(name) __attribute__((weak))
3123 #endif
3124
3125 weak_symbol(fopen);
3126 ],[cf_cv_weak_symbols=yes],[cf_cv_weak_symbols=no])
3127 ])
3128 ])dnl
3129 dnl ---------------------------------------------------------------------------
3130 dnl CF_WITH_ADA_COMPILER version: 1 updated: 2010/06/19 15:22:18
3131 dnl --------------------
3132 dnl Command-line option to specify the Ada95 compiler.
3133 AC_DEFUN([CF_WITH_ADA_COMPILER],[
3134 AC_ARG_WITH(ada-compiler,
3135         [  --with-ada-compiler=CMD specify Ada95 compiler command (default gnatmake)],
3136         [cf_ada_compiler=$withval],
3137         [cf_ada_compiler=gnatmake])
3138 AC_SUBST(cf_ada_compiler)
3139 ])dnl
3140 dnl ---------------------------------------------------------------------------
3141 dnl CF_WITH_ADA_INCLUDE version: 1 updated: 2010/06/19 15:22:18
3142 dnl -------------------
3143 dnl Command-line option to specify where Ada includes will install.
3144 AC_DEFUN([CF_WITH_ADA_INCLUDE],[
3145 CF_WITH_PATH(ada-include,
3146    [  --with-ada-include=DIR  Ada includes are in DIR],
3147    ADA_INCLUDE,
3148    PREFIX/share/ada/adainclude,
3149    [$]prefix/share/ada/adainclude)
3150 AC_SUBST(ADA_INCLUDE)
3151 ])dnl
3152 dnl ---------------------------------------------------------------------------
3153 dnl CF_WITH_ADA_OBJECTS version: 1 updated: 2010/06/19 15:22:18
3154 dnl -------------------
3155 dnl Command-line option to specify where Ada objects will install.
3156 AC_DEFUN([CF_WITH_ADA_OBJECTS],[
3157 CF_WITH_PATH(ada-objects,
3158    [  --with-ada-objects=DIR  Ada objects are in DIR],
3159    ADA_OBJECTS,
3160    PREFIX/lib/ada/adalib,
3161    [$]prefix/lib/ada/adalib)
3162 AC_SUBST(ADA_OBJECTS)
3163 ])dnl
3164 dnl ---------------------------------------------------------------------------
3165 dnl CF_WITH_ADA_SHAREDLIB version: 1 updated: 2010/06/19 16:12:21
3166 dnl ---------------------
3167 dnl Command-line option to specify if an Ada95 shared-library should be built,
3168 dnl and optionally what its soname should be.
3169 AC_DEFUN([CF_WITH_ADA_SHAREDLIB],[
3170 AC_ARG_WITH(ada-sharedlib,
3171         [  --with-ada-sharedlib=XX build Ada95 shared-library],
3172         [with_ada_sharedlib=$withval],
3173         [with_ada_sharedlib=no])
3174 AC_MSG_RESULT($with_ada_sharedlib)
3175
3176 if test "x$with_ada_sharedlib" != xno
3177 then
3178         MAKE_ADA_SHAREDLIB=
3179         if test "x$with_ada_sharedlib" != xyes
3180         then
3181                 ADA_SHAREDLIB="$with_ada_sharedlib"
3182         else
3183                 ADA_SHAREDLIB='lib$(LIB_NAME).so.1'
3184         fi
3185 else
3186         MAKE_ADA_SHAREDLIB="#"
3187 fi
3188
3189 AC_SUBST(ADA_SHAREDLIB)
3190 AC_SUBST(MAKE_ADA_SHAREDLIB)
3191 ])dnl
3192 dnl ---------------------------------------------------------------------------
3193 dnl CF_WITH_CURSES_DIR version: 2 updated: 2002/11/10 14:46:59
3194 dnl ------------------
3195 dnl Wrapper for AC_ARG_WITH to specify directory under which to look for curses
3196 dnl libraries.
3197 AC_DEFUN([CF_WITH_CURSES_DIR],[
3198 AC_ARG_WITH(curses-dir,
3199         [  --with-curses-dir=DIR   directory in which (n)curses is installed],
3200         [CF_PATH_SYNTAX(withval)
3201          cf_cv_curses_dir=$withval],
3202         [cf_cv_curses_dir=no])
3203 ])dnl
3204 dnl ---------------------------------------------------------------------------
3205 dnl CF_WITH_PATH version: 9 updated: 2010/05/26 05:38:42
3206 dnl ------------
3207 dnl Wrapper for AC_ARG_WITH to ensure that user supplies a pathname, not just
3208 dnl defaulting to yes/no.
3209 dnl
3210 dnl $1 = option name
3211 dnl $2 = help-text
3212 dnl $3 = environment variable to set
3213 dnl $4 = default value, shown in the help-message, must be a constant
3214 dnl $5 = default value, if it's an expression & cannot be in the help-message
3215 dnl
3216 AC_DEFUN([CF_WITH_PATH],
3217 [AC_ARG_WITH($1,[$2 ](default: ifelse([$4],,empty,[$4])),,
3218 ifelse([$4],,[withval="${$3}"],[withval="${$3-ifelse([$5],,[$4],[$5])}"]))dnl
3219 if ifelse([$5],,true,[test -n "$5"]) ; then
3220 CF_PATH_SYNTAX(withval)
3221 fi
3222 $3="$withval"
3223 AC_SUBST($3)dnl
3224 ])dnl
3225 dnl ---------------------------------------------------------------------------
3226 dnl CF_WITH_PTHREAD version: 3 updated: 2010/05/29 16:31:02
3227 dnl ---------------
3228 dnl Check for POSIX thread library.
3229 AC_DEFUN([CF_WITH_PTHREAD],
3230 [
3231 AC_MSG_CHECKING(if you want to link with the pthread library)
3232 AC_ARG_WITH(pthread,
3233     [  --with-pthread          use POSIX thread library],
3234     [with_pthread=$withval],
3235     [with_pthread=no])
3236 AC_MSG_RESULT($with_pthread)
3237
3238 if test "$with_pthread" != no ; then
3239     AC_CHECK_HEADER(pthread.h,[
3240         AC_DEFINE(HAVE_PTHREADS_H)
3241
3242         AC_MSG_CHECKING(if we can link with the pthread library)
3243         cf_save_LIBS="$LIBS"
3244         CF_ADD_LIB(pthread)
3245         AC_TRY_LINK([
3246 #include <pthread.h>
3247 ],[
3248         int rc = pthread_create(0,0,0,0);
3249 ],[with_pthread=yes],[with_pthread=no])
3250         LIBS="$cf_save_LIBS"
3251         AC_MSG_RESULT($with_pthread)
3252
3253         if test "$with_pthread" = yes ; then
3254             CF_ADD_LIB(pthread)
3255             AC_DEFINE(HAVE_LIBPTHREADS)
3256         else
3257             AC_MSG_ERROR(Cannot link with pthread library)
3258         fi
3259     ])
3260 fi
3261 ])
3262 dnl ---------------------------------------------------------------------------
3263 dnl CF_XOPEN_SOURCE version: 34 updated: 2010/05/26 05:38:42
3264 dnl ---------------
3265 dnl Try to get _XOPEN_SOURCE defined properly that we can use POSIX functions,
3266 dnl or adapt to the vendor's definitions to get equivalent functionality,
3267 dnl without losing the common non-POSIX features.
3268 dnl
3269 dnl Parameters:
3270 dnl     $1 is the nominal value for _XOPEN_SOURCE
3271 dnl     $2 is the nominal value for _POSIX_C_SOURCE
3272 AC_DEFUN([CF_XOPEN_SOURCE],[
3273
3274 cf_XOPEN_SOURCE=ifelse([$1],,500,[$1])
3275 cf_POSIX_C_SOURCE=ifelse([$2],,199506L,[$2])
3276 cf_xopen_source=
3277
3278 case $host_os in #(vi
3279 aix[[456]]*) #(vi
3280         cf_xopen_source="-D_ALL_SOURCE"
3281         ;;
3282 darwin[[0-8]].*) #(vi
3283         cf_xopen_source="-D_APPLE_C_SOURCE"
3284         ;;
3285 darwin*) #(vi
3286         cf_xopen_source="-D_DARWIN_C_SOURCE"
3287         ;;
3288 freebsd*|dragonfly*) #(vi
3289         # 5.x headers associate
3290         #       _XOPEN_SOURCE=600 with _POSIX_C_SOURCE=200112L
3291         #       _XOPEN_SOURCE=500 with _POSIX_C_SOURCE=199506L
3292         cf_POSIX_C_SOURCE=200112L
3293         cf_XOPEN_SOURCE=600
3294         cf_xopen_source="-D_BSD_TYPES -D__BSD_VISIBLE -D_POSIX_C_SOURCE=$cf_POSIX_C_SOURCE -D_XOPEN_SOURCE=$cf_XOPEN_SOURCE"
3295         ;;
3296 hpux11*) #(vi
3297         cf_xopen_source="-D_HPUX_SOURCE -D_XOPEN_SOURCE=500"
3298         ;;
3299 hpux*) #(vi
3300         cf_xopen_source="-D_HPUX_SOURCE"
3301         ;;
3302 irix[[56]].*) #(vi
3303         cf_xopen_source="-D_SGI_SOURCE"
3304         ;;
3305 linux*|gnu*|mint*|k*bsd*-gnu) #(vi
3306         CF_GNU_SOURCE
3307         ;;
3308 mirbsd*) #(vi
3309         # setting _XOPEN_SOURCE or _POSIX_SOURCE breaks <arpa/inet.h>
3310         ;;
3311 netbsd*) #(vi
3312         # setting _XOPEN_SOURCE breaks IPv6 for lynx on NetBSD 1.6, breaks xterm, is not needed for ncursesw
3313         ;;
3314 openbsd*) #(vi
3315         # setting _XOPEN_SOURCE breaks xterm on OpenBSD 2.8, is not needed for ncursesw
3316         ;;
3317 osf[[45]]*) #(vi
3318         cf_xopen_source="-D_OSF_SOURCE"
3319         ;;
3320 nto-qnx*) #(vi
3321         cf_xopen_source="-D_QNX_SOURCE"
3322         ;;
3323 sco*) #(vi
3324         # setting _XOPEN_SOURCE breaks Lynx on SCO Unix / OpenServer
3325         ;;
3326 solaris2.1[[0-9]]) #(vi
3327         cf_xopen_source="-D__EXTENSIONS__ -D_XOPEN_SOURCE=$cf_XOPEN_SOURCE"
3328         ;;
3329 solaris2.[[1-9]]) #(vi
3330         cf_xopen_source="-D__EXTENSIONS__"
3331         ;;
3332 *)
3333         AC_CACHE_CHECK(if we should define _XOPEN_SOURCE,cf_cv_xopen_source,[
3334         AC_TRY_COMPILE([#include <sys/types.h>],[
3335 #ifndef _XOPEN_SOURCE
3336 make an error
3337 #endif],
3338         [cf_cv_xopen_source=no],
3339         [cf_save="$CPPFLAGS"
3340          CPPFLAGS="$CPPFLAGS -D_XOPEN_SOURCE=$cf_XOPEN_SOURCE"
3341          AC_TRY_COMPILE([#include <sys/types.h>],[
3342 #ifdef _XOPEN_SOURCE
3343 make an error
3344 #endif],
3345         [cf_cv_xopen_source=no],
3346         [cf_cv_xopen_source=$cf_XOPEN_SOURCE])
3347         CPPFLAGS="$cf_save"
3348         ])
3349 ])
3350         if test "$cf_cv_xopen_source" != no ; then
3351                 CF_REMOVE_DEFINE(CFLAGS,$CFLAGS,_XOPEN_SOURCE)
3352                 CF_REMOVE_DEFINE(CPPFLAGS,$CPPFLAGS,_XOPEN_SOURCE)
3353                 cf_temp_xopen_source="-D_XOPEN_SOURCE=$cf_cv_xopen_source"
3354                 CF_ADD_CFLAGS($cf_temp_xopen_source)
3355         fi
3356         CF_POSIX_C_SOURCE($cf_POSIX_C_SOURCE)
3357         ;;
3358 esac
3359
3360 if test -n "$cf_xopen_source" ; then
3361         CF_ADD_CFLAGS($cf_xopen_source)
3362 fi
3363 ])