aclocal.m4

   1 dnl***************************************************************************
   2 dnl Copyright (c) 1998-2010,2011 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 1995-on
  30 dnl
  31 dnl $Id: aclocal.m4,v 1.566 2011/08/07 18:55:48 tom Exp $
  32 dnl Macros used in NCURSES 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 AM_LANGINFO_CODESET version: 3 updated: 2002/10/27 23:21:42
  43 dnl -------------------
  44 dnl Inserted as requested by gettext 0.10.40
  45 dnl File from /usr/share/aclocal
  46 dnl codeset.m4
  47 dnl ====================
  48 dnl serial AM1
  49 dnl
  50 dnl From Bruno Haible.
  51 AC_DEFUN([AM_LANGINFO_CODESET],
  52 [
  53   AC_CACHE_CHECK([for nl_langinfo and CODESET], am_cv_langinfo_codeset,
  54     [AC_TRY_LINK([#include <langinfo.h>],
  55       [char* cs = nl_langinfo(CODESET);],
  56       am_cv_langinfo_codeset=yes,
  57       am_cv_langinfo_codeset=no)
  58     ])
  59   if test $am_cv_langinfo_codeset = yes; then
  60     AC_DEFINE(HAVE_LANGINFO_CODESET, 1,
  61       [Define if you have <langinfo.h> and nl_langinfo(CODESET).])
  62   fi
  63 ])dnl
  64 dnl ---------------------------------------------------------------------------
  65 dnl CF_ACVERSION_CHECK version: 2 updated: 2011/05/08 11:22:03
  66 dnl ------------------
  67 dnl Conditionally generate script according to whether we're using a given autoconf.
  68 dnl
  69 dnl $1 = version to compare against
  70 dnl $2 = code to use if AC_ACVERSION is at least as high as $1.
  71 dnl $3 = code to use if AC_ACVERSION is older than $1.
  72 define(CF_ACVERSION_CHECK,
  73 [
  74 ifdef([m4_version_compare],
  75 [m4_if(m4_version_compare(m4_defn([AC_ACVERSION]), [$1]), -1, [$3], [$2])],
  76 [CF_ACVERSION_COMPARE(
  77 AC_PREREQ_CANON(AC_PREREQ_SPLIT([$1])),
  78 AC_PREREQ_CANON(AC_PREREQ_SPLIT(AC_ACVERSION)), AC_ACVERSION, [$2], [$3])])])dnl
  79 dnl ---------------------------------------------------------------------------
  80 dnl CF_ACVERSION_COMPARE version: 2 updated: 2011/04/14 20:56:50
  81 dnl --------------------
  82 dnl CF_ACVERSION_COMPARE(MAJOR1, MINOR1, TERNARY1,
  83 dnl                      MAJOR2, MINOR2, TERNARY2,
  84 dnl                      PRINTABLE2, not FOUND, FOUND)
  85 define(CF_ACVERSION_COMPARE,
  86 [ifelse(builtin([eval], [$2 < $5]), 1,
  87 [ifelse([$8], , ,[$8])],
  88 [ifelse([$9], , ,[$9])])])dnl
  89 dnl ---------------------------------------------------------------------------
  90 dnl CF_ADA_INCLUDE_DIRS version: 6 updated: 2010/02/26 19:52:07
  91 dnl -------------------
  92 dnl Construct the list of include-options for the C programs in the Ada95
  93 dnl binding.
  94 AC_DEFUN([CF_ADA_INCLUDE_DIRS],
  95 [
  96 ACPPFLAGS="-I. -I../include -I../../include $ACPPFLAGS"
  97 if test "$srcdir" != "."; then
  98         ACPPFLAGS="-I\${srcdir}/../../include $ACPPFLAGS"
  99 fi
 100 if test "$GCC" != yes; then
 101         ACPPFLAGS="$ACPPFLAGS -I\${includedir}"
 102 elif test "$includedir" != "/usr/include"; then
 103         if test "$includedir" = '${prefix}/include' ; then
 104                 if test $prefix != /usr ; then
 105                         ACPPFLAGS="$ACPPFLAGS -I\${includedir}"
 106                 fi
 107         else
 108                 ACPPFLAGS="$ACPPFLAGS -I\${includedir}"
 109         fi
 110 fi
 111 AC_SUBST(ACPPFLAGS)
 112 ])dnl
 113 dnl ---------------------------------------------------------------------------
 114 dnl CF_ADD_ADAFLAGS version: 1 updated: 2010/06/19 15:22:18
 115 dnl ---------------
 116 dnl Add to $ADAFLAGS, which is substituted into makefile and scripts.
 117 AC_DEFUN([CF_ADD_ADAFLAGS],[
 118         ADAFLAGS="$ADAFLAGS $1"
 119         AC_SUBST(ADAFLAGS)
 120 ])dnl
 121 dnl ---------------------------------------------------------------------------
 122 dnl CF_ADD_CFLAGS version: 10 updated: 2010/05/26 05:38:42
 123 dnl -------------
 124 dnl Copy non-preprocessor flags to $CFLAGS, preprocessor flags to $CPPFLAGS
 125 dnl The second parameter if given makes this macro verbose.
 126 dnl
 127 dnl Put any preprocessor definitions that use quoted strings in $EXTRA_CPPFLAGS,
 128 dnl to simplify use of $CPPFLAGS in compiler checks, etc., that are easily
 129 dnl confused by the quotes (which require backslashes to keep them usable).
 130 AC_DEFUN([CF_ADD_CFLAGS],
 131 [
 132 cf_fix_cppflags=no
 133 cf_new_cflags=
 134 cf_new_cppflags=
 135 cf_new_extra_cppflags=
 136
 137 for cf_add_cflags in $1
 138 do
 139 case $cf_fix_cppflags in
 140 no)
 141         case $cf_add_cflags in #(vi
 142         -undef|-nostdinc*|-I*|-D*|-U*|-E|-P|-C) #(vi
 143                 case $cf_add_cflags in
 144                 -D*)
 145                         cf_tst_cflags=`echo ${cf_add_cflags} |sed -e 's/^-D[[^=]]*='\''\"[[^"]]*//'`
 146
 147                         test "${cf_add_cflags}" != "${cf_tst_cflags}" \
 148                                 && test -z "${cf_tst_cflags}" \
 149                                 && cf_fix_cppflags=yes
 150
 151                         if test $cf_fix_cppflags = yes ; then
 152                                 cf_new_extra_cppflags="$cf_new_extra_cppflags $cf_add_cflags"
 153                                 continue
 154                         elif test "${cf_tst_cflags}" = "\"'" ; then
 155                                 cf_new_extra_cppflags="$cf_new_extra_cppflags $cf_add_cflags"
 156                                 continue
 157                         fi
 158                         ;;
 159                 esac
 160                 case "$CPPFLAGS" in
 161                 *$cf_add_cflags) #(vi
 162                         ;;
 163                 *) #(vi
 164                         case $cf_add_cflags in #(vi
 165                         -D*)
 166                                 cf_tst_cppflags=`echo "x$cf_add_cflags" | sed -e 's/^...//' -e 's/=.*//'`
 167                                 CF_REMOVE_DEFINE(CPPFLAGS,$CPPFLAGS,$cf_tst_cppflags)
 168                                 ;;
 169                         esac
 170                         cf_new_cppflags="$cf_new_cppflags $cf_add_cflags"
 171                         ;;
 172                 esac
 173                 ;;
 174         *)
 175                 cf_new_cflags="$cf_new_cflags $cf_add_cflags"
 176                 ;;
 177         esac
 178         ;;
 179 yes)
 180         cf_new_extra_cppflags="$cf_new_extra_cppflags $cf_add_cflags"
 181
 182         cf_tst_cflags=`echo ${cf_add_cflags} |sed -e 's/^[[^"]]*"'\''//'`
 183
 184         test "${cf_add_cflags}" != "${cf_tst_cflags}" \
 185                 && test -z "${cf_tst_cflags}" \
 186                 && cf_fix_cppflags=no
 187         ;;
 188 esac
 189 done
 190
 191 if test -n "$cf_new_cflags" ; then
 192         ifelse([$2],,,[CF_VERBOSE(add to \$CFLAGS $cf_new_cflags)])
 193         CFLAGS="$CFLAGS $cf_new_cflags"
 194 fi
 195
 196 if test -n "$cf_new_cppflags" ; then
 197         ifelse([$2],,,[CF_VERBOSE(add to \$CPPFLAGS $cf_new_cppflags)])
 198         CPPFLAGS="$CPPFLAGS $cf_new_cppflags"
 199 fi
 200
 201 if test -n "$cf_new_extra_cppflags" ; then
 202         ifelse([$2],,,[CF_VERBOSE(add to \$EXTRA_CPPFLAGS $cf_new_extra_cppflags)])
 203         EXTRA_CPPFLAGS="$cf_new_extra_cppflags $EXTRA_CPPFLAGS"
 204 fi
 205
 206 AC_SUBST(EXTRA_CPPFLAGS)
 207
 208 ])dnl
 209 dnl ---------------------------------------------------------------------------
 210 dnl CF_ADD_INCDIR version: 13 updated: 2010/05/26 16:44:57
 211 dnl -------------
 212 dnl Add an include-directory to $CPPFLAGS.  Don't add /usr/include, since it's
 213 dnl redundant.  We don't normally need to add -I/usr/local/include for gcc,
 214 dnl but old versions (and some misinstalled ones) need that.  To make things
 215 dnl worse, gcc 3.x may give error messages if -I/usr/local/include is added to
 216 dnl the include-path).
 217 AC_DEFUN([CF_ADD_INCDIR],
 218 [
 219 if test -n "$1" ; then
 220   for cf_add_incdir in $1
 221   do
 222         while test $cf_add_incdir != /usr/include
 223         do
 224           if test -d $cf_add_incdir
 225           then
 226                 cf_have_incdir=no
 227                 if test -n "$CFLAGS$CPPFLAGS" ; then
 228                   # a loop is needed to ensure we can add subdirs of existing dirs
 229                   for cf_test_incdir in $CFLAGS $CPPFLAGS ; do
 230                         if test ".$cf_test_incdir" = ".-I$cf_add_incdir" ; then
 231                           cf_have_incdir=yes; break
 232                         fi
 233                   done
 234                 fi
 235
 236                 if test "$cf_have_incdir" = no ; then
 237                   if test "$cf_add_incdir" = /usr/local/include ; then
 238                         if test "$GCC" = yes
 239                         then
 240                           cf_save_CPPFLAGS=$CPPFLAGS
 241                           CPPFLAGS="$CPPFLAGS -I$cf_add_incdir"
 242                           AC_TRY_COMPILE([#include <stdio.h>],
 243                                   [printf("Hello")],
 244                                   [],
 245                                   [cf_have_incdir=yes])
 246                           CPPFLAGS=$cf_save_CPPFLAGS
 247                         fi
 248                   fi
 249                 fi
 250
 251                 if test "$cf_have_incdir" = no ; then
 252                   CF_VERBOSE(adding $cf_add_incdir to include-path)
 253                   ifelse([$2],,CPPFLAGS,[$2])="$ifelse([$2],,CPPFLAGS,[$2]) -I$cf_add_incdir"
 254
 255                   cf_top_incdir=`echo $cf_add_incdir | sed -e 's%/include/.*$%/include%'`
 256                   test "$cf_top_incdir" = "$cf_add_incdir" && break
 257                   cf_add_incdir="$cf_top_incdir"
 258                 else
 259                   break
 260                 fi
 261           fi
 262         done
 263   done
 264 fi
 265 ])dnl
 266 dnl ---------------------------------------------------------------------------
 267 dnl CF_ADD_LIB version: 2 updated: 2010/06/02 05:03:05
 268 dnl ----------
 269 dnl Add a library, used to enforce consistency.
 270 dnl
 271 dnl $1 = library to add, without the "-l"
 272 dnl $2 = variable to update (default $LIBS)
 273 AC_DEFUN([CF_ADD_LIB],[CF_ADD_LIBS(-l$1,ifelse($2,,LIBS,[$2]))])dnl
 274 dnl ---------------------------------------------------------------------------
 275 dnl CF_ADD_LIBDIR version: 9 updated: 2010/05/26 16:44:57
 276 dnl -------------
 277 dnl     Adds to the library-path
 278 dnl
 279 dnl     Some machines have trouble with multiple -L options.
 280 dnl
 281 dnl $1 is the (list of) directory(s) to add
 282 dnl $2 is the optional name of the variable to update (default LDFLAGS)
 283 dnl
 284 AC_DEFUN([CF_ADD_LIBDIR],
 285 [
 286 if test -n "$1" ; then
 287   for cf_add_libdir in $1
 288   do
 289     if test $cf_add_libdir = /usr/lib ; then
 290       :
 291     elif test -d $cf_add_libdir
 292     then
 293       cf_have_libdir=no
 294       if test -n "$LDFLAGS$LIBS" ; then
 295         # a loop is needed to ensure we can add subdirs of existing dirs
 296         for cf_test_libdir in $LDFLAGS $LIBS ; do
 297           if test ".$cf_test_libdir" = ".-L$cf_add_libdir" ; then
 298             cf_have_libdir=yes; break
 299           fi
 300         done
 301       fi
 302       if test "$cf_have_libdir" = no ; then
 303         CF_VERBOSE(adding $cf_add_libdir to library-path)
 304         ifelse([$2],,LDFLAGS,[$2])="-L$cf_add_libdir $ifelse([$2],,LDFLAGS,[$2])"
 305       fi
 306     fi
 307   done
 308 fi
 309 ])dnl
 310 dnl ---------------------------------------------------------------------------
 311 dnl CF_ADD_LIBS version: 1 updated: 2010/06/02 05:03:05
 312 dnl -----------
 313 dnl Add one or more libraries, used to enforce consistency.
 314 dnl
 315 dnl $1 = libraries to add, with the "-l", etc.
 316 dnl $2 = variable to update (default $LIBS)
 317 AC_DEFUN([CF_ADD_LIBS],[ifelse($2,,LIBS,[$2])="$1 [$]ifelse($2,,LIBS,[$2])"])dnl
 318 dnl ---------------------------------------------------------------------------
 319 dnl CF_ADD_SUBDIR_PATH version: 3 updated: 2010/07/03 20:58:12
 320 dnl ------------------
 321 dnl Append to a search-list for a nonstandard header/lib-file
 322 dnl     $1 = the variable to return as result
 323 dnl     $2 = the package name
 324 dnl     $3 = the subdirectory, e.g., bin, include or lib
 325 dnl $4 = the directory under which we will test for subdirectories
 326 dnl $5 = a directory that we do not want $4 to match
 327 AC_DEFUN([CF_ADD_SUBDIR_PATH],
 328 [
 329 test "$4" != "$5" && \
 330 test -d "$4" && \
 331 ifelse([$5],NONE,,[(test $5 = NONE || test "$4" != "$5") &&]) {
 332         test -n "$verbose" && echo "    ... testing for $3-directories under $4"
 333         test -d $4/$3 &&          $1="[$]$1 $4/$3"
 334         test -d $4/$3/$2 &&       $1="[$]$1 $4/$3/$2"
 335         test -d $4/$3/$2/$3 &&    $1="[$]$1 $4/$3/$2/$3"
 336         test -d $4/$2/$3 &&       $1="[$]$1 $4/$2/$3"
 337         test -d $4/$2/$3/$2 &&    $1="[$]$1 $4/$2/$3/$2"
 338 }
 339 ])dnl
 340 dnl ---------------------------------------------------------------------------
 341 dnl CF_ANSI_CC_CHECK version: 11 updated: 2011/07/01 19:47:45
 342 dnl ----------------
 343 dnl This was originally adapted from the macros 'fp_PROG_CC_STDC' and
 344 dnl 'fp_C_PROTOTYPES' in the sharutils 4.2 distribution.
 345 AC_DEFUN([CF_ANSI_CC_CHECK],
 346 [
 347 # This should have been defined by AC_PROG_CC
 348 : ${CC:=cc}
 349
 350 # Check for user's environment-breakage by stuffing CFLAGS/CPPFLAGS content
 351 # into CC.  This will not help with broken scripts that wrap the compiler with
 352 # options, but eliminates a more common category of user confusion.
 353 AC_MSG_CHECKING(\$CC variable)
 354 case "$CC" in #(vi
 355 *[[\ \  ]]-[[IUD]]*)
 356         AC_MSG_RESULT(broken)
 357         AC_MSG_WARN(your environment misuses the CC variable to hold CFLAGS/CPPFLAGS options)
 358         # humor him...
 359         cf_flags=`echo "$CC" | sed -e 's/^[[^   ]]*[[   ]]//'`
 360         CC=`echo "$CC" | sed -e 's/[[   ]].*//'`
 361         CF_ADD_CFLAGS($cf_flags)
 362         ;;
 363 *)
 364         AC_MSG_RESULT(ok)
 365         ;;
 366 esac
 367
 368 AC_CACHE_CHECK(for ${CC:-cc} option to accept ANSI C, cf_cv_ansi_cc,[
 369 cf_cv_ansi_cc=no
 370 cf_save_CFLAGS="$CFLAGS"
 371 cf_save_CPPFLAGS="$CPPFLAGS"
 372 # Don't try gcc -ansi; that turns off useful extensions and
 373 # breaks some systems' header files.
 374 # AIX                   -qlanglvl=ansi
 375 # Ultrix and OSF/1      -std1
 376 # HP-UX                 -Aa -D_HPUX_SOURCE
 377 # SVR4                  -Xc
 378 # UnixWare 1.2          (cannot use -Xc, since ANSI/POSIX clashes)
 379 for cf_arg in "-DCC_HAS_PROTOS" \
 380         "" \
 381         -qlanglvl=ansi \
 382         -std1 \
 383         -Ae \
 384         "-Aa -D_HPUX_SOURCE" \
 385         -Xc
 386 do
 387         CF_ADD_CFLAGS($cf_arg)
 388         AC_TRY_COMPILE(
 389 [
 390 #ifndef CC_HAS_PROTOS
 391 #if !defined(__STDC__) || (__STDC__ != 1)
 392 choke me
 393 #endif
 394 #endif
 395 ],[
 396         int test (int i, double x);
 397         struct s1 {int (*f) (int a);};
 398         struct s2 {int (*f) (double a);};],
 399         [cf_cv_ansi_cc="$cf_arg"; break])
 400 done
 401 CFLAGS="$cf_save_CFLAGS"
 402 CPPFLAGS="$cf_save_CPPFLAGS"
 403 ])
 404
 405 if test "$cf_cv_ansi_cc" != "no"; then
 406 if test ".$cf_cv_ansi_cc" != ".-DCC_HAS_PROTOS"; then
 407         CF_ADD_CFLAGS($cf_cv_ansi_cc)
 408 else
 409         AC_DEFINE(CC_HAS_PROTOS)
 410 fi
 411 fi
 412 ])dnl
 413 dnl ---------------------------------------------------------------------------
 414 dnl CF_ANSI_CC_REQD version: 4 updated: 2008/03/23 14:48:54
 415 dnl ---------------
 416 dnl For programs that must use an ANSI compiler, obtain compiler options that
 417 dnl will make it recognize prototypes.  We'll do preprocessor checks in other
 418 dnl macros, since tools such as unproto can fake prototypes, but only part of
 419 dnl the preprocessor.
 420 AC_DEFUN([CF_ANSI_CC_REQD],
 421 [AC_REQUIRE([CF_ANSI_CC_CHECK])
 422 if test "$cf_cv_ansi_cc" = "no"; then
 423         AC_MSG_ERROR(
 424 [Your compiler does not appear to recognize prototypes.
 425 You have the following choices:
 426         a. adjust your compiler options
 427         b. get an up-to-date compiler
 428         c. use a wrapper such as unproto])
 429 fi
 430 ])dnl
 431 dnl ---------------------------------------------------------------------------
 432 dnl CF_ARG_DISABLE version: 3 updated: 1999/03/30 17:24:31
 433 dnl --------------
 434 dnl Allow user to disable a normally-on option.
 435 AC_DEFUN([CF_ARG_DISABLE],
 436 [CF_ARG_OPTION($1,[$2],[$3],[$4],yes)])dnl
 437 dnl ---------------------------------------------------------------------------
 438 dnl CF_ARG_OPTION version: 4 updated: 2010/05/26 05:38:42
 439 dnl -------------
 440 dnl Restricted form of AC_ARG_ENABLE that ensures user doesn't give bogus
 441 dnl values.
 442 dnl
 443 dnl Parameters:
 444 dnl $1 = option name
 445 dnl $2 = help-string
 446 dnl $3 = action to perform if option is not default
 447 dnl $4 = action if perform if option is default
 448 dnl $5 = default option value (either 'yes' or 'no')
 449 AC_DEFUN([CF_ARG_OPTION],
 450 [AC_ARG_ENABLE([$1],[$2],[test "$enableval" != ifelse([$5],no,yes,no) && enableval=ifelse([$5],no,no,yes)
 451   if test "$enableval" != "$5" ; then
 452 ifelse([$3],,[    :]dnl
 453 ,[    $3]) ifelse([$4],,,[
 454   else
 455     $4])
 456   fi],[enableval=$5 ifelse([$4],,,[
 457   $4
 458 ])dnl
 459   ])])dnl
 460 dnl ---------------------------------------------------------------------------
 461 dnl CF_AR_FLAGS version: 5 updated: 2010/05/20 20:24:29
 462 dnl -----------
 463 dnl Check for suitable "ar" (archiver) options for updating an archive.
 464 AC_DEFUN([CF_AR_FLAGS],[
 465 AC_REQUIRE([CF_PROG_AR])
 466
 467 AC_CACHE_CHECK(for options to update archives, cf_cv_ar_flags,[
 468         cf_cv_ar_flags=unknown
 469         for cf_ar_flags in -curv curv -crv crv -cqv cqv -rv rv
 470         do
 471
 472                 # check if $ARFLAGS already contains this choice
 473                 if test "x$ARFLAGS" != "x" ; then
 474                         cf_check_ar_flags=`echo "x$ARFLAGS" | sed -e "s/$cf_ar_flags\$//" -e "s/$cf_ar_flags / /"`
 475                         if test "x$ARFLAGS" != "$cf_check_ar_flags" ; then
 476                                 cf_cv_ar_flags=
 477                                 break
 478                         fi
 479                 fi
 480
 481                 rm -f conftest.$ac_cv_objext
 482                 rm -f conftest.a
 483
 484                 cat >conftest.$ac_ext <<EOF
 485 #line __oline__ "configure"
 486 int     testdata[[3]] = { 123, 456, 789 };
 487 EOF
 488                 if AC_TRY_EVAL(ac_compile) ; then
 489                         echo "$AR $ARFLAGS $cf_ar_flags conftest.a conftest.$ac_cv_objext" >&AC_FD_CC
 490                         $AR $ARFLAGS $cf_ar_flags conftest.a conftest.$ac_cv_objext 2>&AC_FD_CC 1>/dev/null
 491                         if test -f conftest.a ; then
 492                                 cf_cv_ar_flags=$cf_ar_flags
 493                                 break
 494                         fi
 495                 else
 496                         CF_VERBOSE(cannot compile test-program)
 497                         break
 498                 fi
 499         done
 500         rm -f conftest.a conftest.$ac_ext conftest.$ac_cv_objext
 501 ])
 502
 503 if test -n "$ARFLAGS" ; then
 504         if test -n "$cf_cv_ar_flags" ; then
 505                 ARFLAGS="$ARFLAGS $cf_cv_ar_flags"
 506         fi
 507 else
 508         ARFLAGS=$cf_cv_ar_flags
 509 fi
 510
 511 AC_SUBST(ARFLAGS)
 512 ])
 513 dnl ---------------------------------------------------------------------------
 514 dnl CF_AWK_BIG_PRINTF version: 3 updated: 2008/12/27 12:30:03
 515 dnl -----------------
 516 dnl Check if awk can handle big strings using printf.  Some older versions of
 517 dnl awk choke on large strings passed via "%s".
 518 dnl
 519 dnl $1 = desired string size
 520 dnl $2 = variable to set with result
 521 AC_DEFUN([CF_AWK_BIG_PRINTF],
 522 [
 523         case x$AWK in #(vi
 524         x)
 525                 eval $2=no
 526                 ;;
 527         *) #(vi
 528                 if ( ${AWK} 'BEGIN { xx = "x"; while (length(xx) < $1) { xx = xx "x"; }; printf("%s\n", xx); }' \
 529                         | $AWK '{ printf "%d\n", length([$]0); }' | $AWK 'BEGIN { eqls=0; recs=0; } { recs++; if ([$]0 == 12000) eqls++; } END { if (recs != 1 || eqls != 1) exit 1; }' 2>/dev/null >/dev/null ) ; then
 530                         eval $2=yes
 531                 else
 532                         eval $2=no
 533                 fi
 534                 ;;
 535         esac
 536 ])dnl
 537 dnl ---------------------------------------------------------------------------
 538 dnl CF_BOOL_DECL version: 8 updated: 2004/01/30 15:51:18
 539 dnl ------------
 540 dnl Test if 'bool' is a builtin type in the configured C++ compiler.  Some
 541 dnl older compilers (e.g., gcc 2.5.8) don't support 'bool' directly; gcc
 542 dnl 2.6.3 does, in anticipation of the ANSI C++ standard.
 543 dnl
 544 dnl Treat the configuration-variable specially here, since we're directly
 545 dnl substituting its value (i.e., 1/0).
 546 dnl
 547 dnl $1 is the shell variable to store the result in, if not $cv_cv_builtin_bool
 548 AC_DEFUN([CF_BOOL_DECL],
 549 [
 550 AC_MSG_CHECKING(if we should include stdbool.h)
 551
 552 AC_CACHE_VAL(cf_cv_header_stdbool_h,[
 553         AC_TRY_COMPILE([],[bool foo = false],
 554                 [cf_cv_header_stdbool_h=0],
 555                 [AC_TRY_COMPILE([
 556 #ifndef __BEOS__
 557 #include <stdbool.h>
 558 #endif
 559 ],[bool foo = false],
 560                         [cf_cv_header_stdbool_h=1],
 561                         [cf_cv_header_stdbool_h=0])])])
 562
 563 if test "$cf_cv_header_stdbool_h" = 1
 564 then    AC_MSG_RESULT(yes)
 565 else    AC_MSG_RESULT(no)
 566 fi
 567
 568 AC_MSG_CHECKING([for builtin bool type])
 569
 570 AC_CACHE_VAL(ifelse($1,,cf_cv_builtin_bool,[$1]),[
 571         AC_TRY_COMPILE([
 572 #include <stdio.h>
 573 #include <sys/types.h>
 574 ],[bool x = false],
 575                 [ifelse($1,,cf_cv_builtin_bool,[$1])=1],
 576                 [ifelse($1,,cf_cv_builtin_bool,[$1])=0])
 577         ])
 578
 579 if test "$ifelse($1,,cf_cv_builtin_bool,[$1])" = 1
 580 then    AC_MSG_RESULT(yes)
 581 else    AC_MSG_RESULT(no)
 582 fi
 583 ])dnl
 584 dnl ---------------------------------------------------------------------------
 585 dnl CF_BOOL_SIZE version: 12 updated: 2006/12/16 12:33:30
 586 dnl ------------
 587 dnl Test for the size of 'bool' in the configured C++ compiler (e.g., a type).
 588 dnl Don't bother looking for bool.h, since it's been deprecated.
 589 dnl
 590 dnl If the current compiler is C rather than C++, we get the bool definition
 591 dnl from <stdbool.h>.
 592 AC_DEFUN([CF_BOOL_SIZE],
 593 [
 594 AC_MSG_CHECKING([for size of bool])
 595 AC_CACHE_VAL(cf_cv_type_of_bool,[
 596         rm -f cf_test.out
 597         AC_TRY_RUN([
 598 #include <stdlib.h>
 599 #include <stdio.h>
 600
 601 #if defined(__cplusplus)
 602
 603 #ifdef HAVE_GXX_BUILTIN_H
 604 #include <g++/builtin.h>
 605 #elif HAVE_GPP_BUILTIN_H
 606 #include <gpp/builtin.h>
 607 #elif HAVE_BUILTIN_H
 608 #include <builtin.h>
 609 #endif
 610
 611 #else
 612
 613 #if $cf_cv_header_stdbool_h
 614 #include <stdbool.h>
 615 #endif
 616
 617 #endif
 618
 619 main()
 620 {
 621         FILE *fp = fopen("cf_test.out", "w");
 622         if (fp != 0) {
 623                 bool x = true;
 624                 if ((bool)(-x) >= 0)
 625                         fputs("unsigned ", fp);
 626                 if (sizeof(x) == sizeof(int))       fputs("int",  fp);
 627                 else if (sizeof(x) == sizeof(char)) fputs("char", fp);
 628                 else if (sizeof(x) == sizeof(short))fputs("short",fp);
 629                 else if (sizeof(x) == sizeof(long)) fputs("long", fp);
 630                 fclose(fp);
 631         }
 632         ${cf_cv_main_return:-return}(0);
 633 }
 634                 ],
 635                 [cf_cv_type_of_bool=`cat cf_test.out`
 636                  if test -z "$cf_cv_type_of_bool"; then
 637                    cf_cv_type_of_bool=unknown
 638                  fi],
 639                 [cf_cv_type_of_bool=unknown],
 640                 [cf_cv_type_of_bool=unknown])
 641         ])
 642         rm -f cf_test.out
 643 AC_MSG_RESULT($cf_cv_type_of_bool)
 644 if test "$cf_cv_type_of_bool" = unknown ; then
 645         case .$NCURSES_BOOL in #(vi
 646         .auto|.) NCURSES_BOOL=unsigned;;
 647         esac
 648         AC_MSG_WARN(Assuming $NCURSES_BOOL for type of bool)
 649         cf_cv_type_of_bool=$NCURSES_BOOL
 650 fi
 651 ])dnl
 652 dnl ---------------------------------------------------------------------------
 653 dnl CF_BUILD_CC version: 6 updated: 2006/10/14 15:23:15
 654 dnl -----------
 655 dnl If we're cross-compiling, allow the user to override the tools and their
 656 dnl options.  The configure script is oriented toward identifying the host
 657 dnl compiler, etc., but we need a build compiler to generate parts of the
 658 dnl source.
 659 dnl
 660 dnl $1 = default for $CPPFLAGS
 661 dnl $2 = default for $LIBS
 662 AC_DEFUN([CF_BUILD_CC],[
 663 AC_REQUIRE([CF_PROG_EXT])
 664 if test "$cross_compiling" = yes ; then
 665
 666         # defaults that we might want to override
 667         : ${BUILD_CFLAGS:=''}
 668         : ${BUILD_CPPFLAGS:='ifelse([$1],,,[$1])'}
 669         : ${BUILD_LDFLAGS:=''}
 670         : ${BUILD_LIBS:='ifelse([$2],,,[$2])'}
 671         : ${BUILD_EXEEXT:='$x'}
 672         : ${BUILD_OBJEXT:='o'}
 673
 674         AC_ARG_WITH(build-cc,
 675                 [  --with-build-cc=XXX     the build C compiler ($BUILD_CC)],
 676                 [BUILD_CC="$withval"],
 677                 [AC_CHECK_PROGS(BUILD_CC, gcc cc cl)])
 678         AC_MSG_CHECKING(for native build C compiler)
 679         AC_MSG_RESULT($BUILD_CC)
 680
 681         AC_MSG_CHECKING(for native build C preprocessor)
 682         AC_ARG_WITH(build-cpp,
 683                 [  --with-build-cpp=XXX    the build C preprocessor ($BUILD_CPP)],
 684                 [BUILD_CPP="$withval"],
 685                 [BUILD_CPP='${BUILD_CC} -E'])
 686         AC_MSG_RESULT($BUILD_CPP)
 687
 688         AC_MSG_CHECKING(for native build C flags)
 689         AC_ARG_WITH(build-cflags,
 690                 [  --with-build-cflags=XXX the build C compiler-flags ($BUILD_CFLAGS)],
 691                 [BUILD_CFLAGS="$withval"])
 692         AC_MSG_RESULT($BUILD_CFLAGS)
 693
 694         AC_MSG_CHECKING(for native build C preprocessor-flags)
 695         AC_ARG_WITH(build-cppflags,
 696                 [  --with-build-cppflags=XXX the build C preprocessor-flags ($BUILD_CPPFLAGS)],
 697                 [BUILD_CPPFLAGS="$withval"])
 698         AC_MSG_RESULT($BUILD_CPPFLAGS)
 699
 700         AC_MSG_CHECKING(for native build linker-flags)
 701         AC_ARG_WITH(build-ldflags,
 702                 [  --with-build-ldflags=XXX the build linker-flags ($BUILD_LDFLAGS)],
 703                 [BUILD_LDFLAGS="$withval"])
 704         AC_MSG_RESULT($BUILD_LDFLAGS)
 705
 706         AC_MSG_CHECKING(for native build linker-libraries)
 707         AC_ARG_WITH(build-libs,
 708                 [  --with-build-libs=XXX   the build libraries (${BUILD_LIBS})],
 709                 [BUILD_LIBS="$withval"])
 710         AC_MSG_RESULT($BUILD_LIBS)
 711
 712         # this assumes we're on Unix.
 713         BUILD_EXEEXT=
 714         BUILD_OBJEXT=o
 715
 716         : ${BUILD_CC:='${CC}'}
 717
 718         if ( test "$BUILD_CC" = "$CC" || test "$BUILD_CC" = '${CC}' ) ; then
 719                 AC_MSG_ERROR([Cross-build requires two compilers.
 720 Use --with-build-cc to specify the native compiler.])
 721         fi
 722
 723 else
 724         : ${BUILD_CC:='${CC}'}
 725         : ${BUILD_CPP:='${CPP}'}
 726         : ${BUILD_CFLAGS:='${CFLAGS}'}
 727         : ${BUILD_CPPFLAGS:='${CPPFLAGS}'}
 728         : ${BUILD_LDFLAGS:='${LDFLAGS}'}
 729         : ${BUILD_LIBS:='${LIBS}'}
 730         : ${BUILD_EXEEXT:='$x'}
 731         : ${BUILD_OBJEXT:='o'}
 732 fi
 733
 734 AC_SUBST(BUILD_CC)
 735 AC_SUBST(BUILD_CPP)
 736 AC_SUBST(BUILD_CFLAGS)
 737 AC_SUBST(BUILD_CPPFLAGS)
 738 AC_SUBST(BUILD_LDFLAGS)
 739 AC_SUBST(BUILD_LIBS)
 740 AC_SUBST(BUILD_EXEEXT)
 741 AC_SUBST(BUILD_OBJEXT)
 742 ])dnl
 743 dnl ---------------------------------------------------------------------------
 744 dnl CF_CFG_DEFAULTS version: 8 updated: 2011/06/04 20:09:13
 745 dnl ---------------
 746 dnl Determine the default configuration into which we'll install ncurses.  This
 747 dnl can be overridden by the user's command-line options.  There's two items to
 748 dnl look for:
 749 dnl     1. the prefix (e.g., /usr)
 750 dnl     2. the header files (e.g., /usr/include/ncurses)
 751 dnl We'll look for a previous installation of ncurses and use the same defaults.
 752 dnl
 753 dnl We don't use AC_PREFIX_DEFAULT, because it gets evaluated too soon, and
 754 dnl we don't use AC_PREFIX_PROGRAM, because we cannot distinguish ncurses's
 755 dnl programs from a vendor's.
 756 AC_DEFUN([CF_CFG_DEFAULTS],
 757 [
 758 AC_MSG_CHECKING(for prefix)
 759 if test "x$prefix" = "xNONE" ; then
 760         case "$cf_cv_system_name" in
 761                 # non-vendor systems don't have a conflict
 762         openbsd*|freebsd*|mirbsd*|linux*|cygwin*|k*bsd*-gnu)
 763                 prefix=/usr
 764                 ;;
 765         *)      prefix=$ac_default_prefix
 766                 ;;
 767         esac
 768 fi
 769 AC_MSG_RESULT($prefix)
 770
 771 if test "x$prefix" = "xNONE" ; then
 772 AC_MSG_CHECKING(for default include-directory)
 773 test -n "$verbose" && echo 1>&AC_FD_MSG
 774 for cf_symbol in \
 775         $includedir \
 776         $includedir/ncurses \
 777         $prefix/include \
 778         $prefix/include/ncurses \
 779         /usr/local/include \
 780         /usr/local/include/ncurses \
 781         /usr/include \
 782         /usr/include/ncurses
 783 do
 784         cf_dir=`eval echo $cf_symbol`
 785         if test -f $cf_dir/curses.h ; then
 786         if ( fgrep NCURSES_VERSION $cf_dir/curses.h 2>&1 >/dev/null ) ; then
 787                 includedir="$cf_symbol"
 788                 test -n "$verbose"  && echo $ac_n "     found " 1>&AC_FD_MSG
 789                 break
 790         fi
 791         fi
 792         test -n "$verbose"  && echo "   tested $cf_dir" 1>&AC_FD_MSG
 793 done
 794 AC_MSG_RESULT($includedir)
 795 fi
 796 ])dnl
 797 dnl ---------------------------------------------------------------------------
 798 dnl CF_CGETENT version: 4 updated: 2011/08/07 14:54:41
 799 dnl ----------
 800 dnl Check if the terminal-capability database functions are available.  If not,
 801 dnl ncurses has a much-reduced version.
 802 AC_DEFUN([CF_CGETENT],[
 803 AC_CACHE_CHECK(for terminal-capability database functions,cf_cv_cgetent,[
 804 AC_TRY_LINK([
 805 #include <stdlib.h>],[
 806         char temp[128];
 807         char *buf = temp;
 808         char *db_array = temp;
 809         cgetent(&buf, &db_array, "vt100");
 810         cgetcap(buf, "tc", '=');
 811         cgetmatch(buf, "tc");
 812         ],
 813         [cf_cv_cgetent=yes],
 814         [cf_cv_cgetent=no])
 815 ])
 816
 817 if test "$cf_cv_cgetent" = yes
 818 then
 819         AC_DEFINE(HAVE_BSD_CGETENT)
 820 AC_CACHE_CHECK(if cgetent uses const parameter,cf_cv_cgetent_const,[
 821 AC_TRY_LINK([
 822 #include <stdlib.h>],[
 823         char temp[128];
 824         char *buf = temp;
 825 #ifndef _NETBSD_SOURCE                  /* given, since April 2004 in stdlib.h */
 826         const char *db_array = temp;
 827         cgetent(&buf, &db_array, "vt100");
 828 #endif
 829         cgetcap(buf, "tc", '=');
 830         cgetmatch(buf, "tc");
 831         ],
 832         [cf_cv_cgetent_const=yes],
 833         [cf_cv_cgetent_const=no])
 834 ])
 835         if test "$cf_cv_cgetent_const" = yes
 836         then
 837                 AC_DEFINE_UNQUOTED(CGETENT_CONST,const)
 838         fi
 839 fi
 840 ])dnl
 841 dnl ---------------------------------------------------------------------------
 842 dnl CF_CHECK_CACHE version: 11 updated: 2008/03/23 14:45:59
 843 dnl --------------
 844 dnl Check if we're accidentally using a cache from a different machine.
 845 dnl Derive the system name, as a check for reusing the autoconf cache.
 846 dnl
 847 dnl If we've packaged config.guess and config.sub, run that (since it does a
 848 dnl better job than uname).  Normally we'll use AC_CANONICAL_HOST, but allow
 849 dnl an extra parameter that we may override, e.g., for AC_CANONICAL_SYSTEM
 850 dnl which is useful in cross-compiles.
 851 dnl
 852 dnl Note: we would use $ac_config_sub, but that is one of the places where
 853 dnl autoconf 2.5x broke compatibility with autoconf 2.13
 854 AC_DEFUN([CF_CHECK_CACHE],
 855 [
 856 if test -f $srcdir/config.guess || test -f $ac_aux_dir/config.guess ; then
 857         ifelse([$1],,[AC_CANONICAL_HOST],[$1])
 858         system_name="$host_os"
 859 else
 860         system_name="`(uname -s -r) 2>/dev/null`"
 861         if test -z "$system_name" ; then
 862                 system_name="`(hostname) 2>/dev/null`"
 863         fi
 864 fi
 865 test -n "$system_name" && AC_DEFINE_UNQUOTED(SYSTEM_NAME,"$system_name")
 866 AC_CACHE_VAL(cf_cv_system_name,[cf_cv_system_name="$system_name"])
 867
 868 test -z "$system_name" && system_name="$cf_cv_system_name"
 869 test -n "$cf_cv_system_name" && AC_MSG_RESULT(Configuring for $cf_cv_system_name)
 870
 871 if test ".$system_name" != ".$cf_cv_system_name" ; then
 872         AC_MSG_RESULT(Cached system name ($system_name) does not agree with actual ($cf_cv_system_name))
 873         AC_MSG_ERROR("Please remove config.cache and try again.")
 874 fi
 875 ])dnl
 876 dnl ---------------------------------------------------------------------------
 877 dnl CF_CHECK_ERRNO version: 11 updated: 2010/05/26 05:38:42
 878 dnl --------------
 879 dnl Check for data that is usually declared in <stdio.h> or <errno.h>, e.g.,
 880 dnl the 'errno' variable.  Define a DECL_xxx symbol if we must declare it
 881 dnl ourselves.
 882 dnl
 883 dnl $1 = the name to check
 884 dnl $2 = the assumed type
 885 AC_DEFUN([CF_CHECK_ERRNO],
 886 [
 887 AC_CACHE_CHECK(if external $1 is declared, cf_cv_dcl_$1,[
 888     AC_TRY_COMPILE([
 889 #ifdef HAVE_STDLIB_H
 890 #include <stdlib.h>
 891 #endif
 892 #include <stdio.h>
 893 #include <sys/types.h>
 894 #include <errno.h> ],
 895     ifelse([$2],,int,[$2]) x = (ifelse([$2],,int,[$2])) $1,
 896     [cf_cv_dcl_$1=yes],
 897     [cf_cv_dcl_$1=no])
 898 ])
 899
 900 if test "$cf_cv_dcl_$1" = no ; then
 901     CF_UPPER(cf_result,decl_$1)
 902     AC_DEFINE_UNQUOTED($cf_result)
 903 fi
 904
 905 # It's possible (for near-UNIX clones) that the data doesn't exist
 906 CF_CHECK_EXTERN_DATA($1,ifelse([$2],,int,[$2]))
 907 ])dnl
 908 dnl ---------------------------------------------------------------------------
 909 dnl CF_CHECK_EXTERN_DATA version: 3 updated: 2001/12/30 18:03:23
 910 dnl --------------------
 911 dnl Check for existence of external data in the current set of libraries.  If
 912 dnl we can modify it, it's real enough.
 913 dnl $1 = the name to check
 914 dnl $2 = its type
 915 AC_DEFUN([CF_CHECK_EXTERN_DATA],
 916 [
 917 AC_CACHE_CHECK(if external $1 exists, cf_cv_have_$1,[
 918     AC_TRY_LINK([
 919 #undef $1
 920 extern $2 $1;
 921 ],
 922     [$1 = 2],
 923     [cf_cv_have_$1=yes],
 924     [cf_cv_have_$1=no])
 925 ])
 926
 927 if test "$cf_cv_have_$1" = yes ; then
 928     CF_UPPER(cf_result,have_$1)
 929     AC_DEFINE_UNQUOTED($cf_result)
 930 fi
 931
 932 ])dnl
 933 dnl ---------------------------------------------------------------------------
 934 dnl CF_CHECK_GPM_WGETCH version: 2 updated: 2010/08/14 18:25:37
 935 dnl -------------------
 936 dnl Check if GPM is already linked with curses.  If so - and if the linkage
 937 dnl is not "weak" - warn about this because it can create problems linking
 938 dnl applications with ncurses.
 939 AC_DEFUN([CF_CHECK_GPM_WGETCH],[
 940 AC_CHECK_LIB(gpm,Gpm_Wgetch,[
 941
 942 AC_CACHE_CHECK(if GPM is weakly bound to curses library, cf_cv_check_gpm_wgetch,[
 943 cf_cv_check_gpm_wgetch=unknown
 944 if test "$cross_compiling" != yes ; then
 945
 946 cat >conftest.$ac_ext <<CF_EOF
 947 #include <gpm.h>
 948 int main()
 949 {
 950         Gpm_Wgetch();
 951         ${cf_cv_main_return:-return}(0);
 952 }
 953 CF_EOF
 954
 955         cf_save_LIBS="$LIBS"
 956         # This only works if we can look at the symbol table.  If a shared
 957         # library is stripped for install, we cannot use that.  So we're forced
 958         # to rely on the static library, noting that some packagers may not
 959         # include it.
 960         LIBS="-static -lgpm -dynamic $LIBS"
 961         if AC_TRY_EVAL(ac_compile) ; then
 962                 if AC_TRY_EVAL(ac_link) ; then
 963                         cf_cv_check_gpm_wgetch=`nm conftest$ac_exeext | egrep '\<wgetch\>' | egrep '\<[[vVwW]]\>'`
 964                         test -n "$cf_cv_check_gpm_wgetch" && cf_cv_check_gpm_wgetch=yes
 965                         test -z "$cf_cv_check_gpm_wgetch" && cf_cv_check_gpm_wgetch=no
 966                 fi
 967         fi
 968         rm -rf conftest*
 969         LIBS="$cf_save_LIBS"
 970 fi
 971 ])
 972
 973 if test "$cf_cv_check_gpm_wgetch" != yes ; then
 974         AC_MSG_WARN(GPM library is already linked with curses - read the FAQ)
 975 fi
 976 ])])dnl
 977 dnl ---------------------------------------------------------------------------
 978 dnl CF_CPP_PARAM_INIT version: 4 updated: 2001/04/07 22:31:18
 979 dnl -----------------
 980 dnl Check if the C++ compiler accepts duplicate parameter initialization.  This
 981 dnl is a late feature for the standard and is not in some recent compilers
 982 dnl (1999/9/11).
 983 AC_DEFUN([CF_CPP_PARAM_INIT],
 984 [
 985 if test -n "$CXX"; then
 986 AC_CACHE_CHECK(if $CXX accepts parameter initialization,cf_cv_cpp_param_init,[
 987         AC_LANG_SAVE
 988         AC_LANG_CPLUSPLUS
 989         AC_TRY_RUN([
 990 class TEST {
 991 private:
 992         int value;
 993 public:
 994         TEST(int x = 1);
 995         ~TEST();
 996 };
 997
 998 TEST::TEST(int x = 1)   // some compilers do not like second initializer
 999 {
1000         value = x;
1001 }
1002 void main() { }
1003 ],
1004         [cf_cv_cpp_param_init=yes],
1005         [cf_cv_cpp_param_init=no],
1006         [cf_cv_cpp_param_init=unknown])
1007         AC_LANG_RESTORE
1008 ])
1009 fi
1010 test "$cf_cv_cpp_param_init" = yes && AC_DEFINE(CPP_HAS_PARAM_INIT)
1011 ])dnl
1012 dnl ---------------------------------------------------------------------------
1013 dnl CF_CPP_STATIC_CAST version: 1 updated: 2005/07/23 16:52:43
1014 dnl ------------------
1015 dnl Check if the C++ compiler accepts static_cast in generics.  This appears to
1016 dnl not be supported in g++ before 3.0
1017 AC_DEFUN([CF_CPP_STATIC_CAST],
1018 [
1019 if test -n "$CXX"; then
1020
1021 AC_CACHE_CHECK(if $CXX accepts static_cast,cf_cv_cpp_static_cast,[
1022         AC_LANG_SAVE
1023         AC_LANG_CPLUSPLUS
1024
1025         AC_TRY_COMPILE([
1026 class NCursesPanel
1027 {
1028 public:
1029   NCursesPanel(int nlines,
1030                int ncols,
1031                int begin_y = 0,
1032                int begin_x = 0)
1033   {
1034   }
1035
1036   ~NCursesPanel();
1037 };
1038
1039 template<class T> class NCursesUserPanel : public NCursesPanel
1040 {
1041 public:
1042   NCursesUserPanel (int nlines,
1043                     int ncols,
1044                     int begin_y = 0,
1045                     int begin_x = 0,
1046                     const T* p_UserData = static_cast<T*>(0))
1047     : NCursesPanel (nlines, ncols, begin_y, begin_x)
1048   {
1049   };
1050   NCursesUserPanel(const T* p_UserData = static_cast<T*>(0)) : NCursesPanel()
1051   {
1052   };
1053
1054   virtual ~NCursesUserPanel() {};
1055 };
1056 ],[
1057         const char* p_UserData = static_cast<char*>(0)],
1058         [cf_cv_cpp_static_cast=yes],
1059         [cf_cv_cpp_static_cast=no])
1060
1061         AC_LANG_RESTORE
1062 ])
1063
1064 fi
1065
1066 test "$cf_cv_cpp_static_cast" = yes && AC_DEFINE(CPP_HAS_STATIC_CAST)
1067 ])dnl
1068 dnl ---------------------------------------------------------------------------
1069 dnl CF_C_INLINE version: 3 updated: 2010/05/01 15:14:41
1070 dnl -----------
1071 dnl Check if the C compiler supports "inline".
1072 dnl $1 is the name of a shell variable to set if inline is supported
1073 dnl $2 is the threshold for gcc 4.x's option controlling maximum inline size
1074 AC_DEFUN([CF_C_INLINE],[
1075 AC_C_INLINE
1076 $1=
1077 if test "$ac_cv_c_inline" != no ; then
1078   $1=inline
1079   if test "$INTEL_COMPILER" = yes
1080   then
1081     :
1082   elif test "$GCC" = yes
1083   then
1084     AC_CACHE_CHECK(if $CC supports options to tune inlining,cf_cv_gcc_inline,[
1085       cf_save_CFLAGS=$CFLAGS
1086       CFLAGS="$CFLAGS --param max-inline-insns-single=$2"
1087       AC_TRY_COMPILE([inline int foo(void) { return 1; }],
1088       [${cf_cv_main_return:-return} foo()],
1089       [cf_cv_gcc_inline=yes],
1090       [cf_cv_gcc_inline=no])
1091       CFLAGS=$cf_save_CFLAGS
1092     ])
1093     if test "$cf_cv_gcc_inline" = yes ; then
1094         CF_ADD_CFLAGS([--param max-inline-insns-single=$2])
1095     fi
1096   fi
1097 fi
1098 AC_SUBST($1)
1099 ])dnl
1100 dnl ---------------------------------------------------------------------------
1101 dnl CF_DIRNAME version: 4 updated: 2002/12/21 19:25:52
1102 dnl ----------
1103 dnl "dirname" is not portable, so we fake it with a shell script.
1104 AC_DEFUN([CF_DIRNAME],[$1=`echo $2 | sed -e 's%/[[^/]]*$%%'`])dnl
1105 dnl ---------------------------------------------------------------------------
1106 dnl CF_DIRS_TO_MAKE version: 3 updated: 2002/02/23 20:38:31
1107 dnl ---------------
1108 AC_DEFUN([CF_DIRS_TO_MAKE],
1109 [
1110 DIRS_TO_MAKE="lib"
1111 for cf_item in $cf_list_models
1112 do
1113         CF_OBJ_SUBDIR($cf_item,cf_subdir)
1114         for cf_item2 in $DIRS_TO_MAKE
1115         do
1116                 test $cf_item2 = $cf_subdir && break
1117         done
1118         test ".$cf_item2" != ".$cf_subdir" && DIRS_TO_MAKE="$DIRS_TO_MAKE $cf_subdir"
1119 done
1120 for cf_dir in $DIRS_TO_MAKE
1121 do
1122         test ! -d $cf_dir && mkdir $cf_dir
1123 done
1124 AC_SUBST(DIRS_TO_MAKE)
1125 ])dnl
1126 dnl ---------------------------------------------------------------------------
1127 dnl CF_DISABLE_LEAKS version: 6 updated: 2010/07/23 04:14:32
1128 dnl ----------------
1129 dnl Combine no-leak checks with the libraries or tools that are used for the
1130 dnl checks.
1131 AC_DEFUN([CF_DISABLE_LEAKS],[
1132
1133 AC_REQUIRE([CF_WITH_DMALLOC])
1134 AC_REQUIRE([CF_WITH_DBMALLOC])
1135 AC_REQUIRE([CF_WITH_VALGRIND])
1136
1137 AC_MSG_CHECKING(if you want to perform memory-leak testing)
1138 AC_ARG_ENABLE(leaks,
1139         [  --disable-leaks         test: free permanent memory, analyze leaks],
1140         [if test "x$enableval" = xno; then with_no_leaks=yes; else with_no_leaks=no; fi],
1141         : ${with_no_leaks:=no})
1142 AC_MSG_RESULT($with_no_leaks)
1143
1144 if test "$with_no_leaks" = yes ; then
1145         AC_DEFINE(NO_LEAKS)
1146         AC_DEFINE(YY_NO_LEAKS)
1147 fi
1148 ])dnl
1149 dnl ---------------------------------------------------------------------------
1150 dnl CF_DISABLE_LIBTOOL_VERSION version: 1 updated: 2010/05/15 15:45:59
1151 dnl --------------------------
1152 dnl Check if we should use the libtool 1.5 feature "-version-number" instead of
1153 dnl the older "-version-info" feature.  The newer feature allows us to use
1154 dnl version numbering on shared libraries which make them compatible with
1155 dnl various systems.
1156 AC_DEFUN([CF_DISABLE_LIBTOOL_VERSION],
1157 [
1158 AC_MSG_CHECKING(if libtool -version-number should be used)
1159 CF_ARG_DISABLE(libtool-version,
1160         [  --disable-libtool-version  enable to use libtool's incompatible naming scheme],
1161         [cf_libtool_version=no],
1162         [cf_libtool_version=yes])
1163 AC_MSG_RESULT($cf_libtool_version)
1164
1165 if test "$cf_libtool_version" = yes ; then
1166         LIBTOOL_VERSION="-version-number"
1167 else
1168         LIBTOOL_VERSION="-version-info"
1169 fi
1170
1171 AC_SUBST(LIBTOOL_VERSION)
1172 ])dnl
1173 dnl ---------------------------------------------------------------------------
1174 dnl CF_DISABLE_RPATH_HACK version: 2 updated: 2011/02/13 13:31:33
1175 dnl ---------------------
1176 dnl The rpath-hack makes it simpler to build programs, particularly with the
1177 dnl *BSD ports which may have essential libraries in unusual places.  But it
1178 dnl can interfere with building an executable for the base system.  Use this
1179 dnl option in that case.
1180 AC_DEFUN([CF_DISABLE_RPATH_HACK],
1181 [
1182 AC_MSG_CHECKING(if rpath-hack should be disabled)
1183 CF_ARG_DISABLE(rpath-hack,
1184         [  --disable-rpath-hack    don't add rpath options for additional libraries],
1185         [cf_disable_rpath_hack=yes],
1186         [cf_disable_rpath_hack=no])
1187 AC_MSG_RESULT($cf_disable_rpath_hack)
1188 if test "$cf_disable_rpath_hack" = no ; then
1189         CF_RPATH_HACK
1190 fi
1191 ])
1192 dnl ---------------------------------------------------------------------------
1193 dnl CF_ENABLE_PC_FILES version: 4 updated: 2011/08/06 20:32:05
1194 dnl ------------------
1195 dnl This is the "--enable-pc-files" option, which is available if there is a
1196 dnl pkg-config configuration on the local machine.
1197 dnl
1198 dnl It sets/updates PKG_CONFIG_LIBDIR, which is used by pkg-config as a
1199 dnl special case: overriding PKG_CONFIG_PATH (preferred).
1200 AC_DEFUN([CF_ENABLE_PC_FILES],[
1201 AC_REQUIRE([CF_PATHSEP])
1202 AC_REQUIRE([CF_PKG_CONFIG])
1203
1204 if test "$PKG_CONFIG" != no ; then
1205         AC_MSG_CHECKING(if we should install .pc files for $PKG_CONFIG)
1206
1207         # Leave this as something that can be overridden in the environment.
1208         if test -z "$PKG_CONFIG_LIBDIR" ; then
1209                 if test -n "$PKG_CONFIG_PATH" ; then
1210                         for cf_config in `echo "$PKG_CONFIG_PATH" | sed -e 's/'$PATH_SEPARATOR'/ /g'`
1211                         do
1212                                 if test -n "$cf_config" && test -d "$cf_config"
1213                                 then
1214                                         PKG_CONFIG_LIBDIR=$cf_config
1215                                         break
1216                                 fi
1217                         done
1218                 fi
1219                 if test -z "$PKG_CONFIG_LIBDIR" ; then
1220                         cf_path=`echo "$PKG_CONFIG" | sed -e 's,/[[^/]]*/[[^/]]*$,,'`
1221                         case x`(arch) 2>/dev/null` in #(vi
1222                         *64) #(vi
1223                                 for cf_config in $cf_path/lib64 $cf_path/lib32 $cf_path/lib
1224                                 do
1225                                         if test -d $cf_config/pkgconfig
1226                                         then
1227                                                 PKG_CONFIG_LIBDIR=$cf_config/pkgconfig
1228                                                 break
1229                                         fi
1230                                 done
1231                                 ;;
1232                         *)
1233                                 PKG_CONFIG_LIBDIR=$cf_path/lib/pkgconfig
1234                                 ;;
1235                         esac
1236                 fi
1237         else
1238                 PKG_CONFIG_LIBDIR=`echo "$PKG_CONFIG_LIBDIR" | sed -e 's/^://' -e 's/:.*//'`
1239         fi
1240         if test -n "$PKG_CONFIG_LIBDIR" && test -d "$PKG_CONFIG_LIBDIR" ; then
1241                 AC_ARG_ENABLE(pc-files,
1242                         [  --enable-pc-files       generate and install .pc files for pkg-config],
1243                         [enable_pc_files=$enableval],
1244                         [enable_pc_files=no])
1245                 AC_MSG_RESULT($enable_pc_files)
1246                 CF_VERBOSE(found library $PKG_CONFIG_LIBDIR)
1247         else
1248                 AC_MSG_RESULT(no)
1249                 AC_MSG_WARN(did not find library $PKG_CONFIG_LIBDIR)
1250                 enable_pc_files=no
1251         fi
1252 fi
1253 AC_SUBST(PKG_CONFIG_LIBDIR)
1254 ])dnl
1255 dnl ---------------------------------------------------------------------------
1256 dnl CF_ENABLE_RPATH version: 2 updated: 2010/03/27 18:39:42
1257 dnl ---------------
1258 dnl Check if the rpath option should be used, setting cache variable
1259 dnl cf_cv_enable_rpath if so.
1260 AC_DEFUN([CF_ENABLE_RPATH],
1261 [
1262 AC_MSG_CHECKING(if rpath option should be used)
1263 AC_ARG_ENABLE(rpath,
1264 [  --enable-rpath          use rpath option when generating shared libraries],
1265 [cf_cv_enable_rpath=$enableval],
1266 [cf_cv_enable_rpath=no])
1267 AC_MSG_RESULT($cf_cv_enable_rpath)
1268 ])dnl
1269 dnl ---------------------------------------------------------------------------
1270 dnl CF_ERRNO version: 5 updated: 1997/11/30 12:44:39
1271 dnl --------
1272 dnl Check if 'errno' is declared in <errno.h>
1273 AC_DEFUN([CF_ERRNO],
1274 [
1275 CF_CHECK_ERRNO(errno)
1276 ])dnl
1277 dnl ---------------------------------------------------------------------------
1278 dnl CF_ETIP_DEFINES version: 3 updated: 2003/03/22 19:13:43
1279 dnl ---------------
1280 dnl Test for conflicting definitions of exception in gcc 2.8.0, etc., between
1281 dnl math.h and builtin.h, only for ncurses
1282 AC_DEFUN([CF_ETIP_DEFINES],
1283 [
1284 AC_MSG_CHECKING(for special defines needed for etip.h)
1285 cf_save_CXXFLAGS="$CXXFLAGS"
1286 cf_result="none"
1287 for cf_math in "" MATH_H
1288 do
1289 for cf_excp in "" MATH_EXCEPTION
1290 do
1291         CXXFLAGS="$cf_save_CXXFLAGS -I${srcdir}/c++ -I${srcdir}/menu -I${srcdir}/include"
1292         test -n "$cf_math" && CXXFLAGS="$CXXFLAGS -DETIP_NEEDS_${cf_math}"
1293         test -n "$cf_excp" && CXXFLAGS="$CXXFLAGS -DETIP_NEEDS_${cf_excp}"
1294 AC_TRY_COMPILE([
1295 #include <etip.h.in>
1296 ],[],[
1297         test -n "$cf_math" && AC_DEFINE_UNQUOTED(ETIP_NEEDS_${cf_math})
1298         test -n "$cf_excp" && AC_DEFINE_UNQUOTED(ETIP_NEEDS_${cf_excp})
1299         cf_result="$cf_math $cf_excp"
1300         break
1301 ],[])
1302 done
1303 done
1304 AC_MSG_RESULT($cf_result)
1305 CXXFLAGS="$cf_save_CXXFLAGS"
1306 ])
1307 dnl ---------------------------------------------------------------------------
1308 dnl CF_FIND_LINKAGE version: 19 updated: 2010/05/29 16:31:02
1309 dnl ---------------
1310 dnl Find a library (specifically the linkage used in the code fragment),
1311 dnl searching for it if it is not already in the library path.
1312 dnl See also CF_ADD_SEARCHPATH.
1313 dnl
1314 dnl Parameters (4-on are optional):
1315 dnl     $1 = headers for library entrypoint
1316 dnl     $2 = code fragment for library entrypoint
1317 dnl     $3 = the library name without the "-l" option or ".so" suffix.
1318 dnl     $4 = action to perform if successful (default: update CPPFLAGS, etc)
1319 dnl     $5 = action to perform if not successful
1320 dnl     $6 = module name, if not the same as the library name
1321 dnl     $7 = extra libraries
1322 dnl
1323 dnl Sets these variables:
1324 dnl     $cf_cv_find_linkage_$3 - yes/no according to whether linkage is found
1325 dnl     $cf_cv_header_path_$3 - include-directory if needed
1326 dnl     $cf_cv_library_path_$3 - library-directory if needed
1327 dnl     $cf_cv_library_file_$3 - library-file if needed, e.g., -l$3
1328 AC_DEFUN([CF_FIND_LINKAGE],[
1329
1330 # If the linkage is not already in the $CPPFLAGS/$LDFLAGS configuration, these
1331 # will be set on completion of the AC_TRY_LINK below.
1332 cf_cv_header_path_$3=
1333 cf_cv_library_path_$3=
1334
1335 CF_MSG_LOG([Starting [FIND_LINKAGE]($3,$6)])
1336
1337 cf_save_LIBS="$LIBS"
1338
1339 AC_TRY_LINK([$1],[$2],[
1340         cf_cv_find_linkage_$3=yes
1341         cf_cv_header_path_$3=/usr/include
1342         cf_cv_library_path_$3=/usr/lib
1343 ],[
1344
1345 LIBS="-l$3 $7 $cf_save_LIBS"
1346
1347 AC_TRY_LINK([$1],[$2],[
1348         cf_cv_find_linkage_$3=yes
1349         cf_cv_header_path_$3=/usr/include
1350         cf_cv_library_path_$3=/usr/lib
1351         cf_cv_library_file_$3="-l$3"
1352 ],[
1353         cf_cv_find_linkage_$3=no
1354         LIBS="$cf_save_LIBS"
1355
1356     CF_VERBOSE(find linkage for $3 library)
1357     CF_MSG_LOG([Searching for headers in [FIND_LINKAGE]($3,$6)])
1358
1359     cf_save_CPPFLAGS="$CPPFLAGS"
1360     cf_test_CPPFLAGS="$CPPFLAGS"
1361
1362     CF_HEADER_PATH(cf_search,ifelse([$6],,[$3],[$6]))
1363     for cf_cv_header_path_$3 in $cf_search
1364     do
1365       if test -d $cf_cv_header_path_$3 ; then
1366         CF_VERBOSE(... testing $cf_cv_header_path_$3)
1367         CPPFLAGS="$cf_save_CPPFLAGS -I$cf_cv_header_path_$3"
1368         AC_TRY_COMPILE([$1],[$2],[
1369             CF_VERBOSE(... found $3 headers in $cf_cv_header_path_$3)
1370             cf_cv_find_linkage_$3=maybe
1371             cf_test_CPPFLAGS="$CPPFLAGS"
1372             break],[
1373             CPPFLAGS="$cf_save_CPPFLAGS"
1374             ])
1375       fi
1376     done
1377
1378     if test "$cf_cv_find_linkage_$3" = maybe ; then
1379
1380       CF_MSG_LOG([Searching for $3 library in [FIND_LINKAGE]($3,$6)])
1381
1382       cf_save_LIBS="$LIBS"
1383       cf_save_LDFLAGS="$LDFLAGS"
1384
1385       ifelse([$6],,,[
1386         CPPFLAGS="$cf_test_CPPFLAGS"
1387         LIBS="-l$3 $7 $cf_save_LIBS"
1388         AC_TRY_LINK([$1],[$2],[
1389             CF_VERBOSE(... found $3 library in system)
1390             cf_cv_find_linkage_$3=yes])
1391             CPPFLAGS="$cf_save_CPPFLAGS"
1392             LIBS="$cf_save_LIBS"
1393             ])
1394
1395       if test "$cf_cv_find_linkage_$3" != yes ; then
1396         CF_LIBRARY_PATH(cf_search,$3)
1397         for cf_cv_library_path_$3 in $cf_search
1398         do
1399           if test -d $cf_cv_library_path_$3 ; then
1400             CF_VERBOSE(... testing $cf_cv_library_path_$3)
1401             CPPFLAGS="$cf_test_CPPFLAGS"
1402             LIBS="-l$3 $7 $cf_save_LIBS"
1403             LDFLAGS="$cf_save_LDFLAGS -L$cf_cv_library_path_$3"
1404             AC_TRY_LINK([$1],[$2],[
1405                 CF_VERBOSE(... found $3 library in $cf_cv_library_path_$3)
1406                 cf_cv_find_linkage_$3=yes
1407                 cf_cv_library_file_$3="-l$3"
1408                 break],[
1409                 CPPFLAGS="$cf_save_CPPFLAGS"
1410                 LIBS="$cf_save_LIBS"
1411                 LDFLAGS="$cf_save_LDFLAGS"
1412                 ])
1413           fi
1414         done
1415         CPPFLAGS="$cf_save_CPPFLAGS"
1416         LDFLAGS="$cf_save_LDFLAGS"
1417       fi
1418
1419     else
1420       cf_cv_find_linkage_$3=no
1421     fi
1422     ],$7)
1423 ])
1424
1425 LIBS="$cf_save_LIBS"
1426
1427 if test "$cf_cv_find_linkage_$3" = yes ; then
1428 ifelse([$4],,[
1429         CF_ADD_INCDIR($cf_cv_header_path_$3)
1430         CF_ADD_LIBDIR($cf_cv_library_path_$3)
1431         CF_ADD_LIB($3)
1432 ],[$4])
1433 else
1434 ifelse([$5],,AC_MSG_WARN(Cannot find $3 library),[$5])
1435 fi
1436 ])dnl
1437 dnl ---------------------------------------------------------------------------
1438 dnl CF_FUNC_DLSYM version: 2 updated: 2010/05/29 16:31:02
1439 dnl -------------
1440 dnl Test for dlsym() and related functions, as well as libdl.
1441 dnl
1442 dnl Sets
1443 dnl     $cf_have_dlsym
1444 dnl     $cf_have_libdl
1445 AC_DEFUN([CF_FUNC_DLSYM],[
1446 cf_have_dlsym=no
1447 AC_CHECK_FUNC(dlsym,cf_have_dlsym=yes,[
1448
1449 cf_have_libdl=no
1450 AC_CHECK_LIB(dl,dlsym,[
1451         cf_have_dlsym=yes
1452         cf_have_libdl=yes])])
1453
1454 if test "$cf_have_dlsym" = yes ; then
1455         test "$cf_have_libdl" = yes && CF_ADD_LIB(dl)
1456
1457         AC_MSG_CHECKING(whether able to link to dl*() functions)
1458         AC_TRY_LINK([#include <dlfcn.h>],[
1459                 void *obj;
1460                 if ((obj = dlopen("filename", 0)) != 0) {
1461                         if (dlsym(obj, "symbolname") == 0) {
1462                         dlclose(obj);
1463                         }
1464                 }],[
1465                 AC_DEFINE(HAVE_LIBDL)],[
1466                 AC_MSG_ERROR(Cannot link test program for libdl)])
1467         AC_MSG_RESULT(ok)
1468 else
1469         AC_MSG_ERROR(Cannot find dlsym function)
1470 fi
1471 ])
1472 dnl ---------------------------------------------------------------------------
1473 dnl CF_FUNC_MEMMOVE version: 7 updated: 2006/12/16 12:33:30
1474 dnl ---------------
1475 dnl Check for memmove, or a bcopy that can handle overlapping copy.  If neither
1476 dnl is found, add our own version of memmove to the list of objects.
1477 AC_DEFUN([CF_FUNC_MEMMOVE],
1478 [
1479 AC_CHECK_FUNC(memmove,,[
1480 AC_CHECK_FUNC(bcopy,[
1481         AC_CACHE_CHECK(if bcopy does overlapping moves,cf_cv_good_bcopy,[
1482                 AC_TRY_RUN([
1483 int main() {
1484         static char data[] = "abcdefghijklmnopqrstuwwxyz";
1485         char temp[40];
1486         bcopy(data, temp, sizeof(data));
1487         bcopy(temp+10, temp, 15);
1488         bcopy(temp+5, temp+15, 10);
1489         ${cf_cv_main_return:-return} (strcmp(temp, "klmnopqrstuwwxypqrstuwwxyz"));
1490 }
1491                 ],
1492                 [cf_cv_good_bcopy=yes],
1493                 [cf_cv_good_bcopy=no],
1494                 [cf_cv_good_bcopy=unknown])
1495                 ])
1496         ],[cf_cv_good_bcopy=no])
1497         if test "$cf_cv_good_bcopy" = yes ; then
1498                 AC_DEFINE(USE_OK_BCOPY)
1499         else
1500                 AC_DEFINE(USE_MY_MEMMOVE)
1501         fi
1502 ])])dnl
1503 dnl ---------------------------------------------------------------------------
1504 dnl CF_FUNC_NANOSLEEP version: 3 updated: 2006/12/16 12:33:30
1505 dnl -----------------
1506 dnl Check for existence of workable nanosleep() function.  Some systems, e.g.,
1507 dnl AIX 4.x, provide a non-working version.
1508 AC_DEFUN([CF_FUNC_NANOSLEEP],[
1509 AC_CACHE_CHECK(if nanosleep really works,cf_cv_func_nanosleep,[
1510 AC_TRY_RUN([
1511 #include <stdio.h>
1512 #include <errno.h>
1513 #include <time.h>
1514
1515 #ifdef HAVE_SYS_TIME_H
1516 #include <sys/time.h>
1517 #endif
1518
1519 int main() {
1520         struct timespec ts1, ts2;
1521         int code;
1522         ts1.tv_sec  = 0;
1523         ts1.tv_nsec = 750000000;
1524         ts2.tv_sec  = 0;
1525         ts2.tv_nsec = 0;
1526         errno = 0;
1527         code = nanosleep(&ts1, &ts2); /* on failure errno is ENOSYS. */
1528         ${cf_cv_main_return:-return}(code != 0);
1529 }
1530 ],
1531         [cf_cv_func_nanosleep=yes],
1532         [cf_cv_func_nanosleep=no],
1533         [cf_cv_func_nanosleep=unknown])])
1534
1535 test "$cf_cv_func_nanosleep" = "yes" && AC_DEFINE(HAVE_NANOSLEEP)
1536 ])
1537 dnl ---------------------------------------------------------------------------
1538 dnl CF_FUNC_OPENPTY version: 3 updated: 2010/05/29 16:31:02
1539 dnl ---------------
1540 dnl Check for openpty() function, along with <pty.h> header.  It may need the
1541 dnl "util" library as well.
1542 AC_DEFUN([CF_FUNC_OPENPTY],
1543 [
1544 AC_CHECK_LIB(util,openpty,cf_cv_lib_util=yes,cf_cv_lib_util=no)
1545 AC_CACHE_CHECK(for openpty header,cf_cv_func_openpty,[
1546     cf_save_LIBS="$LIBS"
1547     test $cf_cv_lib_util = yes && CF_ADD_LIB(util)
1548     for cf_header in pty.h libutil.h util.h
1549     do
1550     AC_TRY_LINK([
1551 #include <$cf_header>
1552 ],[
1553     int x = openpty((int *)0, (int *)0, (char *)0,
1554                    (struct termios *)0, (struct winsize *)0);
1555 ],[
1556         cf_cv_func_openpty=$cf_header
1557         break
1558 ],[
1559         cf_cv_func_openpty=no
1560 ])
1561     done
1562     LIBS="$cf_save_LIBS"
1563 ])
1564 ])dnl
1565 dnl ---------------------------------------------------------------------------
1566 dnl CF_FUNC_POLL version: 4 updated: 2006/12/16 12:33:30
1567 dnl ------------
1568 dnl See if the poll function really works.  Some platforms have poll(), but
1569 dnl it does not work for terminals or files.
1570 AC_DEFUN([CF_FUNC_POLL],[
1571 AC_CACHE_CHECK(if poll really works,cf_cv_working_poll,[
1572 AC_TRY_RUN([
1573 #include <stdio.h>
1574 #ifdef HAVE_POLL_H
1575 #include <poll.h>
1576 #else
1577 #include <sys/poll.h>
1578 #endif
1579 int main() {
1580         struct pollfd myfds;
1581         int ret;
1582
1583         myfds.fd = 0;
1584         myfds.events = POLLIN;
1585
1586         ret = poll(&myfds, 1, 100);
1587         ${cf_cv_main_return:-return}(ret != 0);
1588 }],
1589         [cf_cv_working_poll=yes],
1590         [cf_cv_working_poll=no],
1591         [cf_cv_working_poll=unknown])])
1592 test "$cf_cv_working_poll" = "yes" && AC_DEFINE(HAVE_WORKING_POLL)
1593 ])dnl
1594 dnl ---------------------------------------------------------------------------
1595 dnl CF_FUNC_TERMIOS version: 2 updated: 2000/07/22 23:37:24
1596 dnl ---------------
1597 dnl Some old/broken variations define tcgetattr() only as a macro in
1598 dnl termio(s).h
1599 AC_DEFUN([CF_FUNC_TERMIOS],[
1600 AC_REQUIRE([CF_STRUCT_TERMIOS])
1601 AC_CACHE_CHECK(for tcgetattr, cf_cv_have_tcgetattr,[
1602 AC_TRY_LINK([
1603 #include <sys/types.h>
1604 #ifdef HAVE_UNISTD_H
1605 #include <unistd.h>
1606 #endif
1607 #ifdef HAVE_TERMIOS_H
1608 #include <termios.h>
1609 #define TTY struct termios
1610 #else
1611 #ifdef HAVE_TERMIO_H
1612 #include <termio.h>
1613 #define TTY struct termio
1614 #endif
1615 #endif
1616 ],[
1617 TTY foo;
1618 tcgetattr(1, &foo);],
1619 [cf_cv_have_tcgetattr=yes],
1620 [cf_cv_have_tcgetattr=no])])
1621 test "$cf_cv_have_tcgetattr" = yes && AC_DEFINE(HAVE_TCGETATTR)
1622 ])dnl
1623 dnl ---------------------------------------------------------------------------
1624 dnl CF_FUNC_VSSCANF version: 3 updated: 2001/12/19 00:50:10
1625 dnl ---------------
1626 dnl Check for vsscanf() function, which is in c9x but generally not in earlier
1627 dnl versions of C.  It is in the GNU C library, and can often be simulated by
1628 dnl other functions.
1629 AC_DEFUN([CF_FUNC_VSSCANF],
1630 [
1631 AC_CACHE_CHECK(for vsscanf function or workaround,cf_cv_func_vsscanf,[
1632 AC_TRY_LINK([
1633 #include <stdarg.h>
1634 #include <stdio.h>],[
1635         va_list ap;
1636         vsscanf("from", "%d", ap)],[cf_cv_func_vsscanf=vsscanf],[
1637 AC_TRY_LINK([
1638 #include <stdarg.h>
1639 #include <stdio.h>],[
1640     FILE strbuf;
1641     char *str = "from";
1642
1643     strbuf._flag = _IOREAD;
1644     strbuf._ptr = strbuf._base = (unsigned char *) str;
1645     strbuf._cnt = strlen(str);
1646     strbuf._file = _NFILE;
1647     return (vfscanf(&strbuf, "%d", ap))],[cf_cv_func_vsscanf=vfscanf],[
1648 AC_TRY_LINK([
1649 #include <stdarg.h>
1650 #include <stdio.h>],[
1651     FILE strbuf;
1652     char *str = "from";
1653
1654     strbuf._flag = _IOREAD;
1655     strbuf._ptr = strbuf._base = (unsigned char *) str;
1656     strbuf._cnt = strlen(str);
1657     strbuf._file = _NFILE;
1658     return (_doscan(&strbuf, "%d", ap))],[cf_cv_func_vsscanf=_doscan],[
1659 cf_cv_func_vsscanf=no])])])])
1660
1661 case $cf_cv_func_vsscanf in #(vi
1662 vsscanf) AC_DEFINE(HAVE_VSSCANF);; #(vi
1663 vfscanf) AC_DEFINE(HAVE_VFSCANF);; #(vi
1664 _doscan) AC_DEFINE(HAVE__DOSCAN);;
1665 esac
1666
1667 ])dnl
1668 dnl ---------------------------------------------------------------------------
1669 dnl CF_GCC_ATTRIBUTES version: 14 updated: 2010/10/23 15:52:32
1670 dnl -----------------
1671 dnl Test for availability of useful gcc __attribute__ directives to quiet
1672 dnl compiler warnings.  Though useful, not all are supported -- and contrary
1673 dnl to documentation, unrecognized directives cause older compilers to barf.
1674 AC_DEFUN([CF_GCC_ATTRIBUTES],
1675 [
1676 if test "$GCC" = yes
1677 then
1678 cat > conftest.i <<EOF
1679 #ifndef GCC_PRINTF
1680 #define GCC_PRINTF 0
1681 #endif
1682 #ifndef GCC_SCANF
1683 #define GCC_SCANF 0
1684 #endif
1685 #ifndef GCC_NORETURN
1686 #define GCC_NORETURN /* nothing */
1687 #endif
1688 #ifndef GCC_UNUSED
1689 #define GCC_UNUSED /* nothing */
1690 #endif
1691 EOF
1692 if test "$GCC" = yes
1693 then
1694         AC_CHECKING([for $CC __attribute__ directives])
1695 cat > conftest.$ac_ext <<EOF
1696 #line __oline__ "${as_me:-configure}"
1697 #include "confdefs.h"
1698 #include "conftest.h"
1699 #include "conftest.i"
1700 #if     GCC_PRINTF
1701 #define GCC_PRINTFLIKE(fmt,var) __attribute__((format(printf,fmt,var)))
1702 #else
1703 #define GCC_PRINTFLIKE(fmt,var) /*nothing*/
1704 #endif
1705 #if     GCC_SCANF
1706 #define GCC_SCANFLIKE(fmt,var)  __attribute__((format(scanf,fmt,var)))
1707 #else
1708 #define GCC_SCANFLIKE(fmt,var)  /*nothing*/
1709 #endif
1710 extern void wow(char *,...) GCC_SCANFLIKE(1,2);
1711 extern void oops(char *,...) GCC_PRINTFLIKE(1,2) GCC_NORETURN;
1712 extern void foo(void) GCC_NORETURN;
1713 int main(int argc GCC_UNUSED, char *argv[[]] GCC_UNUSED) { return 0; }
1714 EOF
1715         cf_printf_attribute=no
1716         cf_scanf_attribute=no
1717         for cf_attribute in scanf printf unused noreturn
1718         do
1719                 CF_UPPER(cf_ATTRIBUTE,$cf_attribute)
1720                 cf_directive="__attribute__(($cf_attribute))"
1721                 echo "checking for $CC $cf_directive" 1>&AC_FD_CC
1722
1723                 case $cf_attribute in #(vi
1724                 printf) #(vi
1725                         cf_printf_attribute=yes
1726                         cat >conftest.h <<EOF
1727 #define GCC_$cf_ATTRIBUTE 1
1728 EOF
1729                         ;;
1730                 scanf) #(vi
1731                         cf_scanf_attribute=yes
1732                         cat >conftest.h <<EOF
1733 #define GCC_$cf_ATTRIBUTE 1
1734 EOF
1735                         ;;
1736                 *) #(vi
1737                         cat >conftest.h <<EOF
1738 #define GCC_$cf_ATTRIBUTE $cf_directive
1739 EOF
1740                         ;;
1741                 esac
1742
1743                 if AC_TRY_EVAL(ac_compile); then
1744                         test -n "$verbose" && AC_MSG_RESULT(... $cf_attribute)
1745                         cat conftest.h >>confdefs.h
1746                         case $cf_attribute in #(vi
1747                         printf) #(vi
1748                                 if test "$cf_printf_attribute" = no ; then
1749                                         cat >>confdefs.h <<EOF
1750 #define GCC_PRINTFLIKE(fmt,var) /* nothing */
1751 EOF
1752                                 else
1753                                         cat >>confdefs.h <<EOF
1754 #define GCC_PRINTFLIKE(fmt,var) __attribute__((format(printf,fmt,var)))
1755 EOF
1756                                 fi
1757                                 ;;
1758                         scanf) #(vi
1759                                 if test "$cf_scanf_attribute" = no ; then
1760                                         cat >>confdefs.h <<EOF
1761 #define GCC_SCANFLIKE(fmt,var) /* nothing */
1762 EOF
1763                                 else
1764                                         cat >>confdefs.h <<EOF
1765 #define GCC_SCANFLIKE(fmt,var)  __attribute__((format(scanf,fmt,var)))
1766 EOF
1767                                 fi
1768                                 ;;
1769                         esac
1770                 fi
1771         done
1772 else
1773         fgrep define conftest.i >>confdefs.h
1774 fi
1775 rm -rf conftest*
1776 fi
1777 ])dnl
1778 dnl ---------------------------------------------------------------------------
1779 dnl CF_GCC_VERSION version: 5 updated: 2010/04/24 11:02:31
1780 dnl --------------
1781 dnl Find version of gcc
1782 AC_DEFUN([CF_GCC_VERSION],[
1783 AC_REQUIRE([AC_PROG_CC])
1784 GCC_VERSION=none
1785 if test "$GCC" = yes ; then
1786         AC_MSG_CHECKING(version of $CC)
1787         GCC_VERSION="`${CC} --version 2>/dev/null | sed -e '2,$d' -e 's/^.*(GCC) //' -e 's/^[[^0-9.]]*//' -e 's/[[^0-9.]].*//'`"
1788         test -z "$GCC_VERSION" && GCC_VERSION=unknown
1789         AC_MSG_RESULT($GCC_VERSION)
1790 fi
1791 ])dnl
1792 dnl ---------------------------------------------------------------------------
1793 dnl CF_GCC_WARNINGS version: 27 updated: 2010/10/23 15:52:32
1794 dnl ---------------
1795 dnl Check if the compiler supports useful warning options.  There's a few that
1796 dnl we don't use, simply because they're too noisy:
1797 dnl
1798 dnl     -Wconversion (useful in older versions of gcc, but not in gcc 2.7.x)
1799 dnl     -Wredundant-decls (system headers make this too noisy)
1800 dnl     -Wtraditional (combines too many unrelated messages, only a few useful)
1801 dnl     -Wwrite-strings (too noisy, but should review occasionally).  This
1802 dnl             is enabled for ncurses using "--enable-const".
1803 dnl     -pedantic
1804 dnl
1805 dnl Parameter:
1806 dnl     $1 is an optional list of gcc warning flags that a particular
1807 dnl             application might want to use, e.g., "no-unused" for
1808 dnl             -Wno-unused
1809 dnl Special:
1810 dnl     If $with_ext_const is "yes", add a check for -Wwrite-strings
1811 dnl
1812 AC_DEFUN([CF_GCC_WARNINGS],
1813 [
1814 AC_REQUIRE([CF_GCC_VERSION])
1815 CF_INTEL_COMPILER(GCC,INTEL_COMPILER,CFLAGS)
1816
1817 cat > conftest.$ac_ext <<EOF
1818 #line __oline__ "${as_me:-configure}"
1819 int main(int argc, char *argv[[]]) { return (argv[[argc-1]] == 0) ; }
1820 EOF
1821
1822 if test "$INTEL_COMPILER" = yes
1823 then
1824 # The "-wdXXX" options suppress warnings:
1825 # remark #1419: external declaration in primary source file
1826 # remark #1683: explicit conversion of a 64-bit integral type to a smaller integral type (potential portability problem)
1827 # remark #1684: conversion from pointer to same-sized integral type (potential portability problem)
1828 # remark #193: zero used for undefined preprocessing identifier
1829 # remark #593: variable "curs_sb_left_arrow" was set but never used
1830 # remark #810: conversion from "int" to "Dimension={unsigned short}" may lose significant bits
1831 # remark #869: parameter "tw" was never referenced
1832 # remark #981: operands are evaluated in unspecified order
1833 # warning #279: controlling expression is constant
1834
1835         AC_CHECKING([for $CC warning options])
1836         cf_save_CFLAGS="$CFLAGS"
1837         EXTRA_CFLAGS="-Wall"
1838         for cf_opt in \
1839                 wd1419 \
1840                 wd1683 \
1841                 wd1684 \
1842                 wd193 \
1843                 wd593 \
1844                 wd279 \
1845                 wd810 \
1846                 wd869 \
1847                 wd981
1848         do
1849                 CFLAGS="$cf_save_CFLAGS $EXTRA_CFLAGS -$cf_opt"
1850                 if AC_TRY_EVAL(ac_compile); then
1851                         test -n "$verbose" && AC_MSG_RESULT(... -$cf_opt)
1852                         EXTRA_CFLAGS="$EXTRA_CFLAGS -$cf_opt"
1853                 fi
1854         done
1855         CFLAGS="$cf_save_CFLAGS"
1856
1857 elif test "$GCC" = yes
1858 then
1859         AC_CHECKING([for $CC warning options])
1860         cf_save_CFLAGS="$CFLAGS"
1861         EXTRA_CFLAGS=
1862         cf_warn_CONST=""
1863         test "$with_ext_const" = yes && cf_warn_CONST="Wwrite-strings"
1864         for cf_opt in W Wall \
1865                 Wbad-function-cast \
1866                 Wcast-align \
1867                 Wcast-qual \
1868                 Winline \
1869                 Wmissing-declarations \
1870                 Wmissing-prototypes \
1871                 Wnested-externs \
1872                 Wpointer-arith \
1873                 Wshadow \
1874                 Wstrict-prototypes \
1875                 Wundef $cf_warn_CONST $1
1876         do
1877                 CFLAGS="$cf_save_CFLAGS $EXTRA_CFLAGS -$cf_opt"
1878                 if AC_TRY_EVAL(ac_compile); then
1879                         test -n "$verbose" && AC_MSG_RESULT(... -$cf_opt)
1880                         case $cf_opt in #(vi
1881                         Wcast-qual) #(vi
1882                                 CPPFLAGS="$CPPFLAGS -DXTSTRINGDEFINES"
1883                                 ;;
1884                         Winline) #(vi
1885                                 case $GCC_VERSION in
1886                                 [[34]].*)
1887                                         CF_VERBOSE(feature is broken in gcc $GCC_VERSION)
1888                                         continue;;
1889                                 esac
1890                                 ;;
1891                         esac
1892                         EXTRA_CFLAGS="$EXTRA_CFLAGS -$cf_opt"
1893                 fi
1894         done
1895         CFLAGS="$cf_save_CFLAGS"
1896 fi
1897 rm -rf conftest*
1898
1899 AC_SUBST(EXTRA_CFLAGS)
1900 ])dnl
1901 dnl ---------------------------------------------------------------------------
1902 dnl CF_GETOPT_HEADER version: 4 updated: 2009/08/31 20:07:52
1903 dnl ----------------
1904 dnl Check for getopt's variables which are commonly defined in stdlib.h,
1905 dnl unistd.h or (nonstandard) in getopt.h
1906 AC_DEFUN([CF_GETOPT_HEADER],
1907 [
1908 AC_HAVE_HEADERS(unistd.h getopt.h)
1909 AC_CACHE_CHECK(for header declaring getopt variables,cf_cv_getopt_header,[
1910 cf_cv_getopt_header=none
1911 for cf_header in stdio.h stdlib.h unistd.h getopt.h
1912 do
1913 AC_TRY_COMPILE([
1914 #include <$cf_header>],
1915 [int x = optind; char *y = optarg],
1916 [cf_cv_getopt_header=$cf_header
1917  break])
1918 done
1919 ])
1920 if test $cf_cv_getopt_header != none ; then
1921         AC_DEFINE(HAVE_GETOPT_HEADER)
1922 fi
1923 ])dnl
1924 dnl ---------------------------------------------------------------------------
1925 dnl CF_GNAT_GENERICS version: 2 updated: 2011/03/23 20:24:41
1926 dnl ----------------
1927 AC_DEFUN([CF_GNAT_GENERICS],
1928 [
1929 AC_REQUIRE([CF_GNAT_VERSION])
1930
1931 AC_MSG_CHECKING(if GNAT supports generics)
1932 case $cf_gnat_version in #(vi
1933 3.[[1-9]]*|[[4-9]].*) #(vi
1934         cf_gnat_generics=yes
1935         ;;
1936 *)
1937         cf_gnat_generics=no
1938         ;;
1939 esac
1940 AC_MSG_RESULT($cf_gnat_generics)
1941
1942 if test "$cf_gnat_generics" = yes
1943 then
1944         cf_compile_generics=generics
1945         cf_generic_objects="\${GENOBJS}"
1946 else
1947         cf_compile_generics=
1948         cf_generic_objects=
1949 fi
1950
1951 AC_SUBST(cf_compile_generics)
1952 AC_SUBST(cf_generic_objects)
1953 ])dnl
1954 dnl ---------------------------------------------------------------------------
1955 dnl CF_GNAT_PRAGMA_UNREF version: 1 updated: 2010/06/19 15:22:18
1956 dnl --------------------
1957 dnl Check if the gnat pragma "Unreferenced" works.
1958 AC_DEFUN([CF_GNAT_PRAGMA_UNREF],[
1959 AC_CACHE_CHECK(if GNAT pragma Unreferenced works,cf_cv_pragma_unreferenced,[
1960 CF_GNAT_TRY_LINK([procedure conftest;],
1961 [with Text_IO;
1962 with GNAT.OS_Lib;
1963 procedure conftest is
1964    test : Integer;
1965    pragma Unreferenced (test);
1966 begin
1967    test := 1;
1968    Text_IO.Put ("Hello World");
1969    Text_IO.New_Line;
1970    GNAT.OS_Lib.OS_Exit (0);
1971 end conftest;],
1972         [cf_cv_pragma_unreferenced=yes],
1973         [cf_cv_pragma_unreferenced=no])])
1974
1975 # if the pragma is supported, use it (needed in the Trace code).
1976 if test $cf_cv_pragma_unreferenced = yes ; then
1977         PRAGMA_UNREF=TRUE
1978 else
1979         PRAGMA_UNREF=FALSE
1980 fi
1981 AC_SUBST(PRAGMA_UNREF)
1982 ])dnl
1983 dnl ---------------------------------------------------------------------------
1984 dnl CF_GNAT_PROJECTS version: 2 updated: 2011/03/23 20:24:41
1985 dnl ----------------
1986 dnl GNAT projects are configured with ".gpr" project files.
1987 dnl GNAT libraries are a further development, using the project feature.
1988 AC_DEFUN([CF_GNAT_PROJECTS],
1989 [
1990 AC_REQUIRE([CF_GNAT_VERSION])
1991
1992 cf_gnat_libraries=no
1993 cf_gnat_projects=no
1994
1995 AC_MSG_CHECKING(if GNAT supports project files)
1996 case $cf_gnat_version in #(vi
1997 3.[[0-9]]*) #(vi
1998         ;;
1999 *)
2000         case $cf_cv_system_name in #(vi
2001         cygwin*) #(vi
2002                 ;;
2003         *)
2004                 mkdir conftest.src conftest.bin conftest.lib
2005                 cd conftest.src
2006                 rm -rf conftest* *~conftest*
2007                 cat >>library.gpr <<CF_EOF
2008 project Library is
2009   Kind := External ("LIB_KIND");
2010   for Library_Name use "ConfTest";
2011   for Object_Dir use ".";
2012   for Library_ALI_Dir use External("LIBRARY_DIR");
2013   for Library_Version use External ("SONAME");
2014   for Library_Kind use Kind;
2015   for Library_Dir use External("BUILD_DIR");
2016   Source_Dir := External ("SOURCE_DIR");
2017   for Source_Dirs use (Source_Dir);
2018   package Compiler is
2019      for Default_Switches ("Ada") use
2020        ("-g",
2021         "-O2",
2022         "-gnatafno",
2023         "-gnatVa",   -- All validity checks
2024         "-gnatwa");  -- Activate all optional errors
2025   end Compiler;
2026 end Library;
2027 CF_EOF
2028                 cat >>confpackage.ads <<CF_EOF
2029 package ConfPackage is
2030    procedure conftest;
2031 end ConfPackage;
2032 CF_EOF
2033                 cat >>confpackage.adb <<CF_EOF
2034 with Text_IO;
2035 package body ConfPackage is
2036    procedure conftest is
2037    begin
2038       Text_IO.Put ("Hello World");
2039       Text_IO.New_Line;
2040    end conftest;
2041 end ConfPackage;
2042 CF_EOF
2043                 if ( $cf_ada_make $ADAFLAGS \
2044                                 -Plibrary.gpr \
2045                                 -XBUILD_DIR=`cd ../conftest.bin;pwd` \
2046                                 -XLIBRARY_DIR=`cd ../conftest.lib;pwd` \
2047                                 -XSOURCE_DIR=`pwd` \
2048                                 -XSONAME=libConfTest.so.1 \
2049                                 -XLIB_KIND=static 1>&AC_FD_CC 2>&1 ) ; then
2050                         cf_gnat_projects=yes
2051                 fi
2052                 cd ..
2053                 if test -f conftest.lib/confpackage.ali
2054                 then
2055                         cf_gnat_libraries=yes
2056                 fi
2057                 rm -rf conftest* *~conftest*
2058                 ;;
2059         esac
2060         ;;
2061 esac
2062 AC_MSG_RESULT($cf_gnat_projects)
2063
2064 if test $cf_gnat_projects = yes
2065 then
2066         AC_MSG_CHECKING(if GNAT supports libraries)
2067         AC_MSG_RESULT($cf_gnat_libraries)
2068 fi
2069
2070 if test "$cf_gnat_projects" = yes
2071 then
2072         USE_OLD_MAKERULES="#"
2073         USE_GNAT_PROJECTS=""
2074 else
2075         USE_OLD_MAKERULES=""
2076         USE_GNAT_PROJECTS="#"
2077 fi
2078
2079 if test "$cf_gnat_libraries" = yes
2080 then
2081         USE_GNAT_LIBRARIES=""
2082 else
2083         USE_GNAT_LIBRARIES="#"
2084 fi
2085
2086 AC_SUBST(USE_OLD_MAKERULES)
2087 AC_SUBST(USE_GNAT_PROJECTS)
2088 AC_SUBST(USE_GNAT_LIBRARIES)
2089 ])dnl
2090 dnl ---------------------------------------------------------------------------
2091 dnl CF_GNAT_SIGINT version: 1 updated: 2011/03/27 20:07:59
2092 dnl --------------
2093 dnl Check if gnat supports SIGINT, and presumably tasking.  For the latter, it
2094 dnl is noted that gnat may compile a tasking unit even for configurations which
2095 dnl fail at runtime.
2096 AC_DEFUN([CF_GNAT_SIGINT],[
2097 AC_CACHE_CHECK(if GNAT supports SIGINT,cf_cv_gnat_sigint,[
2098 CF_GNAT_TRY_LINK([with Ada.Interrupts.Names;
2099
2100 package ConfTest is
2101
2102    pragma Warnings (Off);  --  the next pragma exists since 3.11p
2103    pragma Unreserve_All_Interrupts;
2104    pragma Warnings (On);
2105
2106    protected Process is
2107       procedure Stop;
2108       function Continue return Boolean;
2109       pragma Attach_Handler (Stop, Ada.Interrupts.Names.SIGINT);
2110    private
2111       Done : Boolean := False;
2112    end Process;
2113
2114 end ConfTest;],
2115 [package body ConfTest is
2116    protected body Process is
2117       procedure Stop is
2118       begin
2119          Done := True;
2120       end Stop;
2121       function Continue return Boolean is
2122       begin
2123          return not Done;
2124       end Continue;
2125    end Process;
2126 end ConfTest;],
2127         [cf_cv_gnat_sigint=yes],
2128         [cf_cv_gnat_sigint=no])])
2129
2130 if test $cf_cv_gnat_sigint = yes ; then
2131         USE_GNAT_SIGINT=""
2132 else
2133         USE_GNAT_SIGINT="#"
2134 fi
2135 AC_SUBST(USE_GNAT_SIGINT)
2136 ])dnl
2137 dnl ---------------------------------------------------------------------------
2138 dnl CF_GNAT_TRY_LINK version: 3 updated: 2011/03/19 14:47:45
2139 dnl ----------------
2140 dnl Verify that a test program compiles/links with GNAT.
2141 dnl $cf_ada_make is set to the program that compiles/links
2142 dnl $ADAFLAGS may be set to the GNAT flags.
2143 dnl
2144 dnl $1 is the text of the spec
2145 dnl $2 is the text of the body
2146 dnl $3 is the shell command to execute if successful
2147 dnl $4 is the shell command to execute if not successful
2148 AC_DEFUN([CF_GNAT_TRY_LINK],
2149 [
2150 rm -rf conftest* *~conftest*
2151 cat >>conftest.ads <<CF_EOF
2152 $1
2153 CF_EOF
2154 cat >>conftest.adb <<CF_EOF
2155 $2
2156 CF_EOF
2157 if ( $cf_ada_make $ADAFLAGS conftest 1>&AC_FD_CC 2>&1 ) ; then
2158 ifelse($3,,      :,[      $3])
2159 ifelse($4,,,[else
2160    $4])
2161 fi
2162 rm -rf conftest* *~conftest*
2163 ])dnl
2164 dnl ---------------------------------------------------------------------------
2165 dnl CF_GNAT_TRY_RUN version: 5 updated: 2011/03/19 14:47:45
2166 dnl ---------------
2167 dnl Verify that a test program compiles and runs with GNAT
2168 dnl $cf_ada_make is set to the program that compiles/links
2169 dnl $ADAFLAGS may be set to the GNAT flags.
2170 dnl
2171 dnl $1 is the text of the spec
2172 dnl $2 is the text of the body
2173 dnl $3 is the shell command to execute if successful
2174 dnl $4 is the shell command to execute if not successful
2175 AC_DEFUN([CF_GNAT_TRY_RUN],
2176 [
2177 rm -rf conftest* *~conftest*
2178 cat >>conftest.ads <<CF_EOF
2179 $1
2180 CF_EOF
2181 cat >>conftest.adb <<CF_EOF
2182 $2
2183 CF_EOF
2184 if ( $cf_ada_make $ADAFLAGS conftest 1>&AC_FD_CC 2>&1 ) ; then
2185    if ( ./conftest 1>&AC_FD_CC 2>&1 ) ; then
2186 ifelse($3,,      :,[      $3])
2187 ifelse($4,,,[   else
2188       $4])
2189    fi
2190 ifelse($4,,,[else
2191    $4])
2192 fi
2193 rm -rf conftest* *~conftest*
2194 ])dnl
2195 dnl ---------------------------------------------------------------------------
2196 dnl CF_GNAT_VERSION version: 17 updated: 2011/03/23 20:24:41
2197 dnl ---------------
2198 dnl Verify version of GNAT.
2199 AC_DEFUN([CF_GNAT_VERSION],
2200 [
2201 AC_MSG_CHECKING(for gnat version)
2202 cf_gnat_version=`${cf_ada_make:-gnatmake} -v 2>&1 | \
2203         grep '[[0-9]].[[0-9]][[0-9]]*' |\
2204     sed -e '2,$d' -e 's/[[^0-9 \.]]//g' -e 's/^[[ ]]*//' -e 's/ .*//'`
2205 AC_MSG_RESULT($cf_gnat_version)
2206
2207 case $cf_gnat_version in #(vi
2208 3.1[[1-9]]*|3.[[2-9]]*|[[4-9]].*) #(vi
2209         cf_cv_prog_gnat_correct=yes
2210         ;;
2211 *)
2212         AC_MSG_WARN(Unsupported GNAT version $cf_gnat_version. We require 3.11 or better. Disabling Ada95 binding.)
2213         cf_cv_prog_gnat_correct=no
2214         ;;
2215 esac
2216 ])
2217 dnl ---------------------------------------------------------------------------
2218 dnl CF_GNU_SOURCE version: 6 updated: 2005/07/09 13:23:07
2219 dnl -------------
2220 dnl Check if we must define _GNU_SOURCE to get a reasonable value for
2221 dnl _XOPEN_SOURCE, upon which many POSIX definitions depend.  This is a defect
2222 dnl (or misfeature) of glibc2, which breaks portability of many applications,
2223 dnl since it is interwoven with GNU extensions.
2224 dnl
2225 dnl Well, yes we could work around it...
2226 AC_DEFUN([CF_GNU_SOURCE],
2227 [
2228 AC_CACHE_CHECK(if we must define _GNU_SOURCE,cf_cv_gnu_source,[
2229 AC_TRY_COMPILE([#include <sys/types.h>],[
2230 #ifndef _XOPEN_SOURCE
2231 make an error
2232 #endif],
2233         [cf_cv_gnu_source=no],
2234         [cf_save="$CPPFLAGS"
2235          CPPFLAGS="$CPPFLAGS -D_GNU_SOURCE"
2236          AC_TRY_COMPILE([#include <sys/types.h>],[
2237 #ifdef _XOPEN_SOURCE
2238 make an error
2239 #endif],
2240         [cf_cv_gnu_source=no],
2241         [cf_cv_gnu_source=yes])
2242         CPPFLAGS="$cf_save"
2243         ])
2244 ])
2245 test "$cf_cv_gnu_source" = yes && CPPFLAGS="$CPPFLAGS -D_GNU_SOURCE"
2246 ])dnl
2247 dnl ---------------------------------------------------------------------------
2248 dnl CF_GPP_LIBRARY version: 10 updated: 2010/05/29 16:31:02
2249 dnl --------------
2250 dnl If we're trying to use g++, test if libg++ is installed (a rather common
2251 dnl problem :-).  If we have the compiler but no library, we'll be able to
2252 dnl configure, but won't be able to build the c++ demo program.
2253 AC_DEFUN([CF_GPP_LIBRARY],
2254 [
2255 cf_cxx_library=unknown
2256 case $cf_cv_system_name in #(vi
2257 os2*) #(vi
2258         cf_gpp_libname=gpp
2259         ;;
2260 *)
2261         cf_gpp_libname=g++
2262         ;;
2263 esac
2264 if test "$GXX" = yes; then
2265         AC_MSG_CHECKING([for lib$cf_gpp_libname])
2266         cf_save="$LIBS"
2267         CF_ADD_LIB($cf_gpp_libname)
2268         AC_TRY_LINK([
2269 #include <$cf_gpp_libname/builtin.h>
2270         ],
2271         [two_arg_error_handler_t foo2 = lib_error_handler],
2272         [cf_cxx_library=yes
2273          CF_ADD_LIB($cf_gpp_libname,CXXLIBS)
2274          if test "$cf_gpp_libname" = cpp ; then
2275             AC_DEFINE(HAVE_GPP_BUILTIN_H)
2276          else
2277             AC_DEFINE(HAVE_GXX_BUILTIN_H)
2278          fi],
2279         [AC_TRY_LINK([
2280 #include <builtin.h>
2281         ],
2282         [two_arg_error_handler_t foo2 = lib_error_handler],
2283         [cf_cxx_library=yes
2284          CF_ADD_LIB($cf_gpp_libname,CXXLIBS)
2285          AC_DEFINE(HAVE_BUILTIN_H)],
2286         [cf_cxx_library=no])])
2287         LIBS="$cf_save"
2288         AC_MSG_RESULT($cf_cxx_library)
2289 fi
2290 ])dnl
2291 dnl ---------------------------------------------------------------------------
2292 dnl CF_GXX_VERSION version: 6 updated: 2010/10/23 15:44:18
2293 dnl --------------
2294 dnl Check for version of g++
2295 AC_DEFUN([CF_GXX_VERSION],[
2296 AC_REQUIRE([AC_PROG_CPP])
2297 GXX_VERSION=none
2298 if test "$GXX" = yes; then
2299         AC_MSG_CHECKING(version of g++)
2300         GXX_VERSION="`${CXX:-g++} --version| sed -e '2,$d' -e 's/^.*(GCC) //' -e 's/^[[^0-9.]]*//' -e 's/[[^0-9.]].*//'`"
2301         test -z "$GXX_VERSION" && GXX_VERSION=unknown
2302         AC_MSG_RESULT($GXX_VERSION)
2303 fi
2304 ])dnl
2305 dnl ---------------------------------------------------------------------------
2306 dnl CF_GXX_WARNINGS version: 6 updated: 2010/08/14 18:25:37
2307 dnl ---------------
2308 dnl Check if the compiler supports useful warning options.
2309 dnl
2310 dnl Most of gcc's options apply to g++, except:
2311 dnl     -Wbad-function-cast
2312 dnl     -Wmissing-declarations
2313 dnl     -Wnested-externs
2314 dnl
2315 dnl Omit a few (for now):
2316 dnl     -Winline
2317 dnl
2318 dnl Parameter:
2319 dnl     $1 is an optional list of g++ warning flags that a particular
2320 dnl             application might want to use, e.g., "no-unused" for
2321 dnl             -Wno-unused
2322 dnl Special:
2323 dnl     If $with_ext_const is "yes", add a check for -Wwrite-strings
2324 dnl
2325 AC_DEFUN([CF_GXX_WARNINGS],
2326 [
2327
2328 CF_INTEL_COMPILER(GXX,INTEL_CPLUSPLUS,CXXFLAGS)
2329
2330 AC_REQUIRE([CF_GXX_VERSION])
2331
2332 AC_LANG_SAVE
2333 AC_LANG_CPLUSPLUS
2334
2335 cat > conftest.$ac_ext <<EOF
2336 #line __oline__ "configure"
2337 int main(int argc, char *argv[[]]) { return (argv[[argc-1]] == 0) ; }
2338 EOF
2339
2340 if test "$INTEL_CPLUSPLUS" = yes
2341 then
2342 # The "-wdXXX" options suppress warnings:
2343 # remark #1419: external declaration in primary source file
2344 # remark #1682: implicit conversion of a 64-bit integral type to a smaller integral type (potential portability problem)
2345 # remark #1683: explicit conversion of a 64-bit integral type to a smaller integral type (potential portability problem)
2346 # remark #1684: conversion from pointer to same-sized integral type (potential portability problem)
2347 # remark #193: zero used for undefined preprocessing identifier
2348 # remark #593: variable "curs_sb_left_arrow" was set but never used
2349 # remark #810: conversion from "int" to "Dimension={unsigned short}" may lose significant bits
2350 # remark #869: parameter "tw" was never referenced
2351 # remark #981: operands are evaluated in unspecified order
2352 # warning #269: invalid format string conversion
2353
2354         AC_CHECKING([for $CC warning options])
2355         cf_save_CXXFLAGS="$CXXFLAGS"
2356         EXTRA_CXXFLAGS="-Wall"
2357         for cf_opt in \
2358                 wd1419 \
2359                 wd1682 \
2360                 wd1683 \
2361                 wd1684 \
2362                 wd193 \
2363                 wd279 \
2364                 wd593 \
2365                 wd810 \
2366                 wd869 \
2367                 wd981
2368         do
2369                 CXXFLAGS="$cf_save_CXXFLAGS $EXTRA_CXXFLAGS -$cf_opt"
2370                 if AC_TRY_EVAL(ac_compile); then
2371                         test -n "$verbose" && AC_MSG_RESULT(... -$cf_opt)
2372                         EXTRA_CXXFLAGS="$EXTRA_CXXFLAGS -$cf_opt"
2373                 fi
2374         done
2375         CXXFLAGS="$cf_save_CXXFLAGS"
2376
2377 elif test "$GXX" = yes
2378 then
2379         AC_CHECKING([for $CXX warning options])
2380         cf_save_CXXFLAGS="$CXXFLAGS"
2381         EXTRA_CXXFLAGS="-W -Wall"
2382         cf_gxx_extra_warnings=""
2383         test "$with_ext_const" = yes && cf_gxx_extra_warnings="Wwrite-strings"
2384         case "$GCC_VERSION" in
2385         [[1-2]].*)
2386                 ;;
2387         *)
2388                 cf_gxx_extra_warnings="$cf_gxx_extra_warnings Weffc++"
2389                 ;;
2390         esac
2391         for cf_opt in \
2392                 Wabi \
2393                 fabi-version=0 \
2394                 Woverloaded-virtual \
2395                 Wsign-promo \
2396                 Wsynth \
2397                 Wold-style-cast \
2398                 Wcast-align \
2399                 Wcast-qual \
2400                 Wmissing-prototypes \
2401                 Wpointer-arith \
2402                 Wshadow \
2403                 Wstrict-prototypes \
2404                 Wundef $cf_gxx_extra_warnings $1
2405         do
2406                 CXXFLAGS="$cf_save_CXXFLAGS $EXTRA_CXXFLAGS -Werror -$cf_opt"
2407                 if AC_TRY_EVAL(ac_compile); then
2408                         test -n "$verbose" && AC_MSG_RESULT(... -$cf_opt)
2409                         EXTRA_CXXFLAGS="$EXTRA_CXXFLAGS -$cf_opt"
2410                 else
2411                         test -n "$verbose" && AC_MSG_RESULT(... no -$cf_opt)
2412                 fi
2413         done
2414         CXXFLAGS="$cf_save_CXXFLAGS"
2415 fi
2416
2417 rm -rf conftest*
2418 AC_LANG_RESTORE
2419 AC_SUBST(EXTRA_CXXFLAGS)
2420 ])dnl
2421 dnl ---------------------------------------------------------------------------
2422 dnl CF_HASHED_DB version: 4 updated: 2010/05/29 16:31:02
2423 dnl ------------
2424 dnl Look for an instance of the Berkeley hashed database.
2425 dnl
2426 dnl $1 = optional parameter, to specify install-prefix for the database.
2427 AC_DEFUN([CF_HASHED_DB],
2428 [
2429 ifelse([$1],,,[
2430 case $1 in #(vi
2431 yes|*able*) #(vi
2432     ;;
2433 *)
2434     if test -d "$1" ; then
2435         CF_ADD_INCDIR($1/include)
2436         CF_ADD_LIBDIR($1/lib)
2437     fi
2438 esac
2439 ])
2440 AC_CHECK_HEADER(db.h,[
2441 CF_HASHED_DB_VERSION
2442 if test "$cf_cv_hashed_db_version" = unknown ; then
2443         AC_MSG_ERROR(Cannot determine version of db)
2444 else
2445         CF_HASHED_DB_LIBS
2446         if test "$cf_cv_hashed_db_libs" = unknown ; then
2447                 AC_MSG_ERROR(Cannot determine library for db)
2448         elif test "$cf_cv_hashed_db_libs" != default ; then
2449                 CF_ADD_LIB($cf_cv_hashed_db_libs)
2450         fi
2451 fi
2452 ],[
2453         AC_MSG_ERROR(Cannot find db.h)
2454 ])
2455 ])dnl
2456 dnl ---------------------------------------------------------------------------
2457 dnl CF_HASHED_DB_LIBS version: 9 updated: 2010/05/29 16:31:02
2458 dnl -----------------
2459 dnl Given that we have the header and version for hashed database, find the
2460 dnl library information.
2461 AC_DEFUN([CF_HASHED_DB_LIBS],
2462 [
2463 AC_CACHE_CHECK(for db libraries, cf_cv_hashed_db_libs,[
2464 cf_cv_hashed_db_libs=unknown
2465 for cf_db_libs in "" db$cf_cv_hashed_db_version db-$cf_cv_hashed_db_version db ''
2466 do
2467         cf_save_libs="$LIBS"
2468         if test -n "$cf_db_libs"; then
2469                 CF_ADD_LIB($cf_db_libs)
2470         fi
2471         CF_MSG_LOG(checking for library "$cf_db_libs")
2472         AC_TRY_LINK([
2473 $ac_includes_default
2474 #include <db.h>
2475 ],[
2476         char *path = "/tmp/foo";
2477 #ifdef DB_VERSION_MAJOR
2478 #if DB_VERSION_MAJOR >= 4
2479         DB *result = 0;
2480         db_create(&result, NULL, 0);
2481         result->open(result,
2482                 NULL,
2483                 path,
2484                 path,
2485                 DB_HASH,
2486                 DB_CREATE,
2487                 0644);
2488 #elif DB_VERSION_MAJOR >= 3
2489         DB *result = 0;
2490         db_create(&result, NULL, 0);
2491         result->open(result,
2492                 path,
2493                 path,
2494                 DB_HASH,
2495                 DB_CREATE,
2496                 0644);
2497 #elif DB_VERSION_MAJOR >= 2
2498         DB *result = 0;
2499         db_open(path,
2500                 DB_HASH,
2501                 DB_CREATE,
2502                 0644,
2503                 (DB_ENV *) 0,
2504                 (DB_INFO *) 0,
2505                 &result);
2506 #endif /* DB_VERSION_MAJOR */
2507 #else
2508         DB *result = dbopen(path,
2509                      2,
2510                      0644,
2511                      DB_HASH,
2512                      0);
2513 #endif
2514         ${cf_cv_main_return:-return}(result != 0)
2515 ],[
2516         if test -n "$cf_db_libs" ; then
2517                 cf_cv_hashed_db_libs=$cf_db_libs
2518         else
2519                 cf_cv_hashed_db_libs=default
2520         fi
2521         LIBS="$cf_save_libs"
2522         break
2523 ])
2524         LIBS="$cf_save_libs"
2525 done
2526 ])
2527 ])dnl
2528 dnl ---------------------------------------------------------------------------
2529 dnl CF_HASHED_DB_VERSION version: 3 updated: 2007/12/01 15:01:37
2530 dnl --------------------
2531 dnl Given that we have the header file for hashed database, find the version
2532 dnl information.
2533 AC_DEFUN([CF_HASHED_DB_VERSION],
2534 [
2535 AC_CACHE_CHECK(for version of db, cf_cv_hashed_db_version,[
2536 cf_cv_hashed_db_version=unknown
2537
2538 for cf_db_version in 1 2 3 4 5
2539 do
2540         CF_MSG_LOG(checking for db version $cf_db_version)
2541         AC_TRY_COMPILE([
2542 $ac_includes_default
2543 #include <db.h>
2544
2545 #ifdef DB_VERSION_MAJOR
2546         /* db2 (DB_VERSION_MAJOR=2) has also DB_VERSION_MINOR, tested with 7 */
2547 #if $cf_db_version == DB_VERSION_MAJOR
2548         /* ok */
2549 #else
2550         make an error
2551 #endif
2552 #else
2553 #if $cf_db_version == 1
2554         /* ok: assuming this is DB 1.8.5 */
2555 #else
2556         make an error
2557 #endif
2558 #endif
2559 ],[DBT *foo = 0],[
2560         cf_cv_hashed_db_version=$cf_db_version
2561         break
2562         ])
2563 done
2564 ])
2565 ])dnl
2566 dnl ---------------------------------------------------------------------------
2567 dnl CF_HEADER_PATH version: 12 updated: 2010/05/05 05:22:40
2568 dnl --------------
2569 dnl Construct a search-list of directories for a nonstandard header-file
2570 dnl
2571 dnl Parameters
2572 dnl     $1 = the variable to return as result
2573 dnl     $2 = the package name
2574 AC_DEFUN([CF_HEADER_PATH],
2575 [
2576 $1=
2577
2578 # collect the current set of include-directories from compiler flags
2579 cf_header_path_list=""
2580 if test -n "${CFLAGS}${CPPFLAGS}" ; then
2581         for cf_header_path in $CPPFLAGS $CFLAGS
2582         do
2583                 case $cf_header_path in #(vi
2584                 -I*)
2585                         cf_header_path=`echo ".$cf_header_path" |sed -e 's/^...//' -e 's,/include$,,'`
2586                         CF_ADD_SUBDIR_PATH($1,$2,include,$cf_header_path,NONE)
2587                         cf_header_path_list="$cf_header_path_list [$]$1"
2588                         ;;
2589                 esac
2590         done
2591 fi
2592
2593 # add the variations for the package we are looking for
2594 CF_SUBDIR_PATH($1,$2,include)
2595
2596 test "$includedir" != NONE && \
2597 test "$includedir" != "/usr/include" && \
2598 test -d "$includedir" && {
2599         test -d $includedir &&    $1="[$]$1 $includedir"
2600         test -d $includedir/$2 && $1="[$]$1 $includedir/$2"
2601 }
2602
2603 test "$oldincludedir" != NONE && \
2604 test "$oldincludedir" != "/usr/include" && \
2605 test -d "$oldincludedir" && {
2606         test -d $oldincludedir    && $1="[$]$1 $oldincludedir"
2607         test -d $oldincludedir/$2 && $1="[$]$1 $oldincludedir/$2"
2608 }
2609
2610 $1="[$]$1 $cf_header_path_list"
2611 ])dnl
2612 dnl ---------------------------------------------------------------------------
2613 dnl CF_HELP_MESSAGE version: 3 updated: 1998/01/14 10:56:23
2614 dnl ---------------
2615 dnl Insert text into the help-message, for readability, from AC_ARG_WITH.
2616 AC_DEFUN([CF_HELP_MESSAGE],
2617 [AC_DIVERT_HELP([$1])dnl
2618 ])dnl
2619 dnl ---------------------------------------------------------------------------
2620 dnl CF_INCLUDE_DIRS version: 6 updated: 2009/01/06 19:37:40
2621 dnl ---------------
2622 dnl Construct the list of include-options according to whether we're building
2623 dnl in the source directory or using '--srcdir=DIR' option.  If we're building
2624 dnl with gcc, don't append the includedir if it happens to be /usr/include,
2625 dnl since that usually breaks gcc's shadow-includes.
2626 AC_DEFUN([CF_INCLUDE_DIRS],
2627 [
2628 CPPFLAGS="$CPPFLAGS -I. -I../include"
2629 if test "$srcdir" != "."; then
2630         CPPFLAGS="$CPPFLAGS -I\${srcdir}/../include"
2631 fi
2632 if test "$GCC" != yes; then
2633         CPPFLAGS="$CPPFLAGS -I\${includedir}"
2634 elif test "$includedir" != "/usr/include"; then
2635         if test "$includedir" = '${prefix}/include' ; then
2636                 if test $prefix != /usr ; then
2637                         CPPFLAGS="$CPPFLAGS -I\${includedir}"
2638                 fi
2639         else
2640                 CPPFLAGS="$CPPFLAGS -I\${includedir}"
2641         fi
2642 fi
2643 AC_SUBST(CPPFLAGS)
2644 ])dnl
2645 dnl ---------------------------------------------------------------------------
2646 dnl CF_INTEL_COMPILER version: 4 updated: 2010/05/26 05:38:42
2647 dnl -----------------
2648 dnl Check if the given compiler is really the Intel compiler for Linux.  It
2649 dnl tries to imitate gcc, but does not return an error when it finds a mismatch
2650 dnl between prototypes, e.g., as exercised by CF_MISSING_CHECK.
2651 dnl
2652 dnl This macro should be run "soon" after AC_PROG_CC or AC_PROG_CPLUSPLUS, to
2653 dnl ensure that it is not mistaken for gcc/g++.  It is normally invoked from
2654 dnl the wrappers for gcc and g++ warnings.
2655 dnl
2656 dnl $1 = GCC (default) or GXX
2657 dnl $2 = INTEL_COMPILER (default) or INTEL_CPLUSPLUS
2658 dnl $3 = CFLAGS (default) or CXXFLAGS
2659 AC_DEFUN([CF_INTEL_COMPILER],[
2660 ifelse([$2],,INTEL_COMPILER,[$2])=no
2661
2662 if test "$ifelse([$1],,[$1],GCC)" = yes ; then
2663         case $host_os in
2664         linux*|gnu*)
2665                 AC_MSG_CHECKING(if this is really Intel ifelse([$1],GXX,C++,C) compiler)
2666                 cf_save_CFLAGS="$ifelse([$3],,CFLAGS,[$3])"
2667                 ifelse([$3],,CFLAGS,[$3])="$ifelse([$3],,CFLAGS,[$3]) -no-gcc"
2668                 AC_TRY_COMPILE([],[
2669 #ifdef __INTEL_COMPILER
2670 #else
2671 make an error
2672 #endif
2673 ],[ifelse([$2],,INTEL_COMPILER,[$2])=yes
2674 cf_save_CFLAGS="$cf_save_CFLAGS -we147 -no-gcc"
2675 ],[])
2676                 ifelse([$3],,CFLAGS,[$3])="$cf_save_CFLAGS"
2677                 AC_MSG_RESULT($ifelse([$2],,INTEL_COMPILER,[$2]))
2678                 ;;
2679         esac
2680 fi
2681 ])dnl
2682 dnl ---------------------------------------------------------------------------
2683 dnl CF_ISASCII version: 3 updated: 2000/08/12 23:18:52
2684 dnl ----------
2685 dnl Check if we have either a function or macro for 'isascii()'.
2686 AC_DEFUN([CF_ISASCII],
2687 [
2688 AC_MSG_CHECKING(for isascii)
2689 AC_CACHE_VAL(cf_cv_have_isascii,[
2690         AC_TRY_LINK([#include <ctype.h>],[int x = isascii(' ')],
2691         [cf_cv_have_isascii=yes],
2692         [cf_cv_have_isascii=no])
2693 ])dnl
2694 AC_MSG_RESULT($cf_cv_have_isascii)
2695 test "$cf_cv_have_isascii" = yes && AC_DEFINE(HAVE_ISASCII)
2696 ])dnl
2697 dnl ---------------------------------------------------------------------------
2698 dnl CF_LARGEFILE version: 7 updated: 2007/06/02 11:58:50
2699 dnl ------------
2700 dnl Add checks for large file support.
2701 AC_DEFUN([CF_LARGEFILE],[
2702 ifdef([AC_FUNC_FSEEKO],[
2703     AC_SYS_LARGEFILE
2704     if test "$enable_largefile" != no ; then
2705         AC_FUNC_FSEEKO
2706
2707         # Normally we would collect these definitions in the config.h,
2708         # but (like _XOPEN_SOURCE), some environments rely on having these
2709         # defined before any of the system headers are included.  Another
2710         # case comes up with C++, e.g., on AIX the compiler compiles the
2711         # header files by themselves before looking at the body files it is
2712         # told to compile.  For ncurses, those header files do not include
2713         # the config.h
2714         test "$ac_cv_sys_large_files"      != no && CPPFLAGS="$CPPFLAGS -D_LARGE_FILES "
2715         test "$ac_cv_sys_largefile_source" != no && CPPFLAGS="$CPPFLAGS -D_LARGEFILE_SOURCE "
2716         test "$ac_cv_sys_file_offset_bits" != no && CPPFLAGS="$CPPFLAGS -D_FILE_OFFSET_BITS=$ac_cv_sys_file_offset_bits "
2717
2718         AC_CACHE_CHECK(whether to use struct dirent64, cf_cv_struct_dirent64,[
2719                 AC_TRY_COMPILE([
2720 #include <sys/types.h>
2721 #include <dirent.h>
2722                 ],[
2723                 /* if transitional largefile support is setup, this is true */
2724                 extern struct dirent64 * readdir(DIR *);
2725                 struct dirent64 *x = readdir((DIR *)0);
2726                 struct dirent *y = readdir((DIR *)0);
2727                 int z = x - y;
2728                 ],
2729                 [cf_cv_struct_dirent64=yes],
2730                 [cf_cv_struct_dirent64=no])
2731         ])
2732         test "$cf_cv_struct_dirent64" = yes && AC_DEFINE(HAVE_STRUCT_DIRENT64)
2733     fi
2734 ])
2735 ])
2736 dnl ---------------------------------------------------------------------------
2737 dnl CF_LDFLAGS_STATIC version: 9 updated: 2011/07/02 15:36:04
2738 dnl -----------------
2739 dnl Check for compiler/linker flags used to temporarily force usage of static
2740 dnl libraries.  This depends on the compiler and platform.  Use this to help
2741 dnl ensure that the linker picks up a given library based on its position in
2742 dnl the list of linker options and libraries.
2743 AC_DEFUN([CF_LDFLAGS_STATIC],[
2744
2745 if test "$GCC" = yes ; then
2746         case $cf_cv_system_name in #(
2747         OS/2*|os2*|aix[[4]]*|solaris2.1[[0-9]]|darwin*)         #( vi
2748                 LDFLAGS_STATIC=
2749                 LDFLAGS_SHARED=
2750                 ;;
2751     *)  #( normally, except when broken
2752         LDFLAGS_STATIC=-static
2753         LDFLAGS_SHARED=-dynamic
2754         ;;
2755     esac
2756 else
2757         case $cf_cv_system_name in #(
2758         aix[[4-7]]*)    #( from ld manpage
2759                 LDFLAGS_STATIC=-bstatic
2760                 LDFLAGS_SHARED=-bdynamic
2761                 ;;
2762         hpux*)          #( from ld manpage for hpux10.20, hpux11.11
2763                 # We could also use just "archive" and "shared".
2764                 LDFLAGS_STATIC=-Wl,-a,archive_shared
2765                 LDFLAGS_SHARED=-Wl,-a,shared_archive
2766                 ;;
2767         irix*)          #( from ld manpage IRIX64
2768                 LDFLAGS_STATIC=-Bstatic
2769                 LDFLAGS_SHARED=-Bdynamic
2770                 ;;
2771         osf[[45]]*)     #( from ld manpage osf4.0d, osf5.1
2772                 # alternative "-oldstyle_liblookup" (not in cc manpage)
2773                 LDFLAGS_STATIC=-noso
2774                 LDFLAGS_SHARED=-so_archive
2775                 ;;
2776         solaris2*)
2777                 LDFLAGS_STATIC=-Bstatic
2778                 LDFLAGS_SHARED=-Bdynamic
2779                 ;;
2780         esac
2781 fi
2782
2783 if test -n "$LDFLAGS_STATIC" && test -n "$LDFLAGS_SHARED"
2784 then
2785         AC_MSG_CHECKING(if linker supports switching between static/dynamic)
2786
2787         rm -f libconftest.a
2788         cat >conftest.$ac_ext <<EOF
2789 #line __oline__ "configure"
2790 #include <stdio.h>
2791 int cf_ldflags_static(FILE *fp) { return fflush(fp); }
2792 EOF
2793         if AC_TRY_EVAL(ac_compile) ; then
2794                 ( $AR $ARFLAGS libconftest.a conftest.o ) 2>&AC_FD_CC 1>/dev/null
2795                 ( eval $RANLIB libconftest.a ) 2>&AC_FD_CC >/dev/null
2796         fi
2797         rm -f conftest.*
2798
2799         cf_save_LIBS="$LIBS"
2800
2801         LIBS="$LDFLAGS_STATIC -L`pwd` -lconftest $LDFLAGS_DYNAMIC $LIBS"
2802         AC_TRY_LINK([
2803 #line __oline__ "configure"
2804 #include <stdio.h>
2805 int cf_ldflags_static(FILE *fp);
2806 ],[
2807         return cf_ldflags_static(stdin);
2808 ],[cf_ldflags_static=yes],[cf_ldflags_static=no])
2809
2810         rm -f libconftest.*
2811         LIBS="$cf_save_LIBS"
2812
2813         AC_MSG_RESULT($cf_ldflags_static)
2814
2815         if test $cf_ldflags_static != yes
2816         then
2817                 LDFLAGS_STATIC=
2818                 LDFLAGS_SHARED=
2819         fi
2820 else
2821         LDFLAGS_STATIC=
2822         LDFLAGS_SHARED=
2823 fi
2824
2825 AC_SUBST(LDFLAGS_STATIC)
2826 AC_SUBST(LDFLAGS_SHARED)
2827 ])
2828 dnl ---------------------------------------------------------------------------
2829 dnl CF_LD_RPATH_OPT version: 5 updated: 2011/07/17 14:48:41
2830 dnl ---------------
2831 dnl For the given system and compiler, find the compiler flags to pass to the
2832 dnl loader to use the "rpath" feature.
2833 AC_DEFUN([CF_LD_RPATH_OPT],
2834 [
2835 AC_REQUIRE([CF_CHECK_CACHE])
2836
2837 LD_RPATH_OPT=
2838 AC_MSG_CHECKING(for an rpath option)
2839 case $cf_cv_system_name in #(vi
2840 irix*) #(vi
2841         if test "$GCC" = yes; then
2842                 LD_RPATH_OPT="-Wl,-rpath,"
2843         else
2844                 LD_RPATH_OPT="-rpath "
2845         fi
2846         ;;
2847 linux*|gnu*|k*bsd*-gnu) #(vi
2848         LD_RPATH_OPT="-Wl,-rpath,"
2849         ;;
2850 openbsd[[2-9]].*|mirbsd*) #(vi
2851         LD_RPATH_OPT="-Wl,-rpath,"
2852         ;;
2853 dragonfly*|freebsd*) #(vi
2854         LD_RPATH_OPT="-rpath "
2855         ;;
2856 netbsd*) #(vi
2857         LD_RPATH_OPT="-Wl,-rpath,"
2858         ;;
2859 osf*|mls+*) #(vi
2860         LD_RPATH_OPT="-rpath "
2861         ;;
2862 solaris2*) #(vi
2863         LD_RPATH_OPT="-R"
2864         ;;
2865 *)
2866         ;;
2867 esac
2868 AC_MSG_RESULT($LD_RPATH_OPT)
2869
2870 case "x$LD_RPATH_OPT" in #(vi
2871 x-R*)
2872         AC_MSG_CHECKING(if we need a space after rpath option)
2873         cf_save_LIBS="$LIBS"
2874         CF_ADD_LIBS(${LD_RPATH_OPT}$libdir)
2875         AC_TRY_LINK(, , cf_rpath_space=no, cf_rpath_space=yes)
2876         LIBS="$cf_save_LIBS"
2877         AC_MSG_RESULT($cf_rpath_space)
2878         test "$cf_rpath_space" = yes && LD_RPATH_OPT="$LD_RPATH_OPT "
2879         ;;
2880 esac
2881 ])dnl
2882 dnl ---------------------------------------------------------------------------
2883 dnl CF_LIBRARY_PATH version: 9 updated: 2010/03/28 12:52:50
2884 dnl ---------------
2885 dnl Construct a search-list of directories for a nonstandard library-file
2886 dnl
2887 dnl Parameters
2888 dnl     $1 = the variable to return as result
2889 dnl     $2 = the package name
2890 AC_DEFUN([CF_LIBRARY_PATH],
2891 [
2892 $1=
2893 cf_library_path_list=""
2894 if test -n "${LDFLAGS}${LIBS}" ; then
2895         for cf_library_path in $LDFLAGS $LIBS
2896         do
2897                 case $cf_library_path in #(vi
2898                 -L*)
2899                         cf_library_path=`echo ".$cf_library_path" |sed -e 's/^...//' -e 's,/lib$,,'`
2900                         CF_ADD_SUBDIR_PATH($1,$2,lib,$cf_library_path,NONE)
2901                         cf_library_path_list="$cf_library_path_list [$]$1"
2902                         ;;
2903                 esac
2904         done
2905 fi
2906
2907 CF_SUBDIR_PATH($1,$2,lib)
2908
2909 $1="$cf_library_path_list [$]$1"
2910 ])dnl
2911 dnl ---------------------------------------------------------------------------
2912 dnl CF_LIB_PREFIX version: 8 updated: 2008/09/13 11:34:16
2913 dnl -------------
2914 dnl Compute the library-prefix for the given host system
2915 dnl $1 = variable to set
2916 AC_DEFUN([CF_LIB_PREFIX],
2917 [
2918         case $cf_cv_system_name in #(vi
2919         OS/2*|os2*) #(vi
2920         LIB_PREFIX=''
2921         ;;
2922         *)      LIB_PREFIX='lib'
2923         ;;
2924         esac
2925 ifelse($1,,,[$1=$LIB_PREFIX])
2926         AC_SUBST(LIB_PREFIX)
2927 ])dnl
2928 dnl ---------------------------------------------------------------------------
2929 dnl CF_LIB_RULES version: 61 updated: 2010/10/23 16:10:30
2930 dnl ------------
2931 dnl Append definitions and rules for the given models to the subdirectory
2932 dnl Makefiles, and the recursion rule for the top-level Makefile.  If the
2933 dnl subdirectory is a library-source directory, modify the LIBS_TO_MAKE list in
2934 dnl the corresponding makefile to list the models that we'll generate.
2935 dnl
2936 dnl For shared libraries, make a list of symbolic links to construct when
2937 dnl generating each library.  The convention used for Linux is the simplest
2938 dnl one:
2939 dnl     lib<name>.so    ->
2940 dnl     lib<name>.so.<major>    ->
2941 dnl     lib<name>.so.<maj>.<minor>
2942 AC_DEFUN([CF_LIB_RULES],
2943 [
2944 CF_LIB_PREFIX(cf_prefix)
2945 AC_REQUIRE([CF_SUBST_NCURSES_VERSION])
2946
2947 if test $cf_cv_shlib_version = cygdll ; then
2948         TINFO_NAME=$TINFO_ARG_SUFFIX
2949         TINFO_SUFFIX=.dll
2950 fi
2951
2952 if test -n "$TINFO_SUFFIX" ; then
2953         case $TINFO_SUFFIX in
2954         tw*)
2955                 TINFO_NAME="${TINFO_NAME}tw"
2956                 TINFO_SUFFIX=`echo $TINFO_SUFFIX | sed 's/^tw//'`
2957                 ;;
2958         t*)
2959                 TINFO_NAME="${TINFO_NAME}t"
2960                 TINFO_SUFFIX=`echo $TINFO_SUFFIX | sed 's/^t//'`
2961                 ;;
2962         w*)
2963                 TINFO_NAME="${TINFO_NAME}w"
2964                 TINFO_SUFFIX=`echo $TINFO_SUFFIX | sed 's/^w//'`
2965                 ;;
2966         esac
2967 fi
2968
2969 for cf_dir in $SRC_SUBDIRS
2970 do
2971         if test ! -d $srcdir/$cf_dir ; then
2972                 continue
2973         elif test -f $srcdir/$cf_dir/modules; then
2974
2975                 SHARED_LIB=
2976                 LIBS_TO_MAKE=
2977                 for cf_item in $cf_LIST_MODELS
2978                 do
2979                         CF_LIB_SUFFIX($cf_item,cf_suffix,cf_depsuf)
2980                         if test $cf_item = shared ; then
2981                         if test "$cf_cv_do_symlinks" = yes ; then
2982                                 case "$cf_cv_shlib_version" in #(vi
2983                                 rel) #(vi
2984                                         case "$cf_cv_system_name" in #(vi
2985                                         darwin*)
2986                                         case .${LIB_SUFFIX} in
2987                                         .tw*)
2988                                                 cf_suffix=`echo $cf_suffix | sed 's/^tw//'`
2989                                                 cf_suffix=tw'.${REL_VERSION}'"$cf_suffix"
2990                                                 ;;
2991                                         .t*)
2992                                                 cf_suffix=`echo $cf_suffix | sed 's/^t//'`
2993                                                 cf_suffix=t'.${REL_VERSION}'"$cf_suffix"
2994                                                 ;;
2995                                         .w*)
2996                                                 cf_suffix=`echo $cf_suffix | sed 's/^w//'`
2997                                                 cf_suffix=w'.${REL_VERSION}'"$cf_suffix"
2998                                                 ;;
2999                                         *)
3000                                                 cf_suffix='.${REL_VERSION}'"$cf_suffix"
3001                                                 ;;
3002                                         esac
3003                                         ;; #(vi
3004                                         *) cf_suffix="$cf_suffix"'.${REL_VERSION}' ;;
3005                                         esac
3006                                         ;;
3007                                 abi)
3008                                         case "$cf_cv_system_name" in #(vi
3009                                         darwin*)
3010                                         case .${LIB_SUFFIX} in
3011                                         .tw*)
3012                                                 cf_suffix=`echo $cf_suffix | sed 's/^tw//'`
3013                                                 cf_suffix=tw'.${ABI_VERSION}'"$cf_suffix"
3014                                                 ;;
3015                                         .t*)
3016                                                 cf_suffix=`echo $cf_suffix | sed 's/^t//'`
3017                                                 cf_suffix=t'.${ABI_VERSION}'"$cf_suffix"
3018                                                 ;;
3019                                         .w*)
3020                                                 cf_suffix=`echo $cf_suffix | sed 's/^w//'`
3021                                                 cf_suffix=w'.${ABI_VERSION}'"$cf_suffix"
3022                                                 ;;
3023                                         *)
3024                                                 cf_suffix='.${ABI_VERSION}'"$cf_suffix"
3025                                                 ;;
3026                                         esac
3027                                         ;; #(vi
3028                                         *) cf_suffix="$cf_suffix"'.${ABI_VERSION}' ;;
3029                                         esac
3030                                         ;;
3031                                 esac
3032                         fi
3033                         # cygwin needs import library, and has unique naming convention
3034                         # use autodetected ${cf_prefix} for import lib and static lib, but
3035                         # use 'cyg' prefix for shared lib.
3036                         if test $cf_cv_shlib_version = cygdll ; then
3037                                 cf_cygsuf=`echo "$cf_suffix" | sed -e 's/\.dll/\${ABI_VERSION}.dll/'`
3038                                 LIBS_TO_MAKE="$LIBS_TO_MAKE ../lib/cyg${cf_dir}${cf_cygsuf}"
3039                                 continue
3040                         fi
3041                         fi
3042                         LIBS_TO_MAKE="$LIBS_TO_MAKE ../lib/${cf_prefix}${cf_dir}${cf_suffix}"
3043                 done
3044
3045                 if test $cf_dir = ncurses ; then
3046                         cf_subsets="$LIB_SUBSETS"
3047                         cf_r_parts="$cf_subsets"
3048                         cf_liblist="$LIBS_TO_MAKE"
3049
3050                         while test -n "$cf_r_parts"
3051                         do
3052                                 cf_l_parts=`echo "$cf_r_parts" |sed -e 's/ .*$//'`
3053                                 cf_r_parts=`echo "$cf_r_parts" |sed -e 's/^[[^ ]]* //'`
3054                                 if test "$cf_l_parts" != "$cf_r_parts" ; then
3055                                         cf_item=
3056                                         case $cf_l_parts in #(vi
3057                                         *termlib*) #(vi
3058                                                 cf_item=`echo $cf_liblist |sed -e s%${LIB_NAME}${LIB_SUFFIX}%${TINFO_LIB_SUFFIX}%g`
3059                                                 ;;
3060                                         *ticlib*)
3061                                                 cf_item=`echo $cf_liblist |sed -e s%${LIB_NAME}${LIB_SUFFIX}%${TICS_LIB_SUFFIX}%g`
3062                                                 ;;
3063                                         *)
3064                                                 break
3065                                                 ;;
3066                                         esac
3067                                         if test -n "$cf_item"; then
3068                                                 LIBS_TO_MAKE="$cf_item $LIBS_TO_MAKE"
3069                                         fi
3070                                 else
3071                                         break
3072                                 fi
3073                         done
3074                 else
3075                         cf_subsets=`echo "$LIB_SUBSETS" | sed -e 's/^termlib.* //'`
3076                 fi
3077
3078                 sed -e "s%@LIBS_TO_MAKE@%$LIBS_TO_MAKE%" \
3079                     -e "s%@SHARED_LIB@%$SHARED_LIB%" \
3080                         $cf_dir/Makefile >$cf_dir/Makefile.out
3081                 mv $cf_dir/Makefile.out $cf_dir/Makefile
3082
3083                 $AWK -f $srcdir/mk-0th.awk \
3084                         libname="${cf_dir}${LIB_SUFFIX}" subsets="$LIB_SUBSETS" \
3085                         $srcdir/$cf_dir/modules >>$cf_dir/Makefile
3086
3087                 for cf_subset in $cf_subsets
3088                 do
3089                         cf_subdirs=
3090                         for cf_item in $cf_LIST_MODELS
3091                         do
3092                         echo "Appending rules for ${cf_item} model (${cf_dir}: ${cf_subset})"
3093                         CF_UPPER(cf_ITEM,$cf_item)
3094                         CF_LIB_SUFFIX($cf_item,cf_suffix,cf_depsuf)
3095                         CF_OBJ_SUBDIR($cf_item,cf_subdir)
3096
3097                         # Test for case where we build libtinfo with a different name.
3098                         cf_libname=$cf_dir
3099                         if test $cf_dir = ncurses ; then
3100                                 case $cf_subset in
3101                                 *base*)
3102                                         cf_libname=${cf_libname}$LIB_SUFFIX
3103                                         ;;
3104                                 *termlib*)
3105                                         cf_libname=$TINFO_LIB_SUFFIX
3106                                         ;;
3107                                 ticlib*)
3108                                         cf_libname=$TICS_LIB_SUFFIX
3109                                         ;;
3110                                 esac
3111                         else
3112                                 cf_libname=${cf_libname}$LIB_SUFFIX
3113                         fi
3114                         if test -n "${DFT_ARG_SUFFIX}" ; then
3115                                 # undo $LIB_SUFFIX add-on in CF_LIB_SUFFIX
3116                                 cf_suffix=`echo $cf_suffix |sed -e "s%^${LIB_SUFFIX}%%"`
3117                         fi
3118
3119                         # These dependencies really are for development, not
3120                         # builds, but they are useful in porting, too.
3121                         cf_depend="../include/ncurses_cfg.h"
3122                         if test "$srcdir" = "."; then
3123                                 cf_reldir="."
3124                         else
3125                                 cf_reldir="\${srcdir}"
3126                         fi
3127
3128                         if test -f $srcdir/$cf_dir/$cf_dir.priv.h; then
3129                                 cf_depend="$cf_depend $cf_reldir/$cf_dir.priv.h"
3130                         elif test -f $srcdir/$cf_dir/curses.priv.h; then
3131                                 cf_depend="$cf_depend $cf_reldir/curses.priv.h"
3132                         fi
3133
3134                         cf_dir_suffix=
3135                         old_cf_suffix="$cf_suffix"
3136                         if test "$cf_cv_shlib_version_infix" = yes ; then
3137                         if test -n "$LIB_SUFFIX" ; then
3138                                 case $LIB_SUFFIX in
3139                                 tw*)
3140                                         cf_libname=`echo $cf_libname | sed 's/tw$//'`
3141                                         cf_suffix=`echo $cf_suffix | sed 's/^tw//'`
3142                                         cf_dir_suffix=tw
3143                                         ;;
3144                                 t*)
3145                                         cf_libname=`echo $cf_libname | sed 's/t$//'`
3146                                         cf_suffix=`echo $cf_suffix | sed 's/^t//'`
3147                                         cf_dir_suffix=t
3148                                         ;;
3149                                 w*)
3150                                         cf_libname=`echo $cf_libname | sed 's/w$//'`
3151                                         cf_suffix=`echo $cf_suffix | sed 's/^w//'`
3152                                         cf_dir_suffix=w
3153                                         ;;
3154                                 esac
3155                         fi
3156                         fi
3157
3158                         $AWK -f $srcdir/mk-1st.awk \
3159                                 name=${cf_libname}${cf_dir_suffix} \
3160                                 traces=$LIB_TRACING \
3161                                 MODEL=$cf_ITEM \
3162                                 model=$cf_subdir \
3163                                 prefix=$cf_prefix \
3164                                 suffix=$cf_suffix \
3165                                 subset=$cf_subset \
3166                                 SymLink="$LN_S" \
3167                                 TermlibRoot=$TINFO_NAME \
3168                                 TermlibSuffix=$TINFO_SUFFIX \
3169                                 ShlibVer=$cf_cv_shlib_version \
3170                                 ShlibVerInfix=$cf_cv_shlib_version_infix \
3171                                 ReLink=${cf_cv_do_relink:-no} \
3172                                 DoLinks=$cf_cv_do_symlinks \
3173                                 rmSoLocs=$cf_cv_rm_so_locs \
3174                                 ldconfig="$LDCONFIG" \
3175                                 overwrite=$WITH_OVERWRITE \
3176                                 depend="$cf_depend" \
3177                                 host="$host" \
3178                                 libtool_version="$LIBTOOL_VERSION" \
3179                                 $srcdir/$cf_dir/modules >>$cf_dir/Makefile
3180
3181                         cf_suffix="$old_cf_suffix"
3182
3183                         for cf_subdir2 in $cf_subdirs lib
3184                         do
3185                                 test $cf_subdir = $cf_subdir2 && break
3186                         done
3187                         test "${cf_subset}.${cf_subdir2}" != "${cf_subset}.${cf_subdir}" && \
3188                         $AWK -f $srcdir/mk-2nd.awk \
3189                                 name=$cf_dir \
3190                                 traces=$LIB_TRACING \
3191                                 MODEL=$cf_ITEM \
3192                                 model=$cf_subdir \
3193                                 subset=$cf_subset \
3194                                 srcdir=$srcdir \
3195                                 echo=$WITH_ECHO \
3196                                 crenames=$cf_cv_prog_CC_c_o \
3197                                 cxxrenames=$cf_cv_prog_CXX_c_o \
3198                                 $srcdir/$cf_dir/modules >>$cf_dir/Makefile
3199                         cf_subdirs="$cf_subdirs $cf_subdir"
3200                         done
3201                 done
3202         fi
3203
3204         echo '  cd '$cf_dir' && ${MAKE} ${CF_MFLAGS} [$]@' >>Makefile
3205 done
3206
3207 for cf_dir in $SRC_SUBDIRS
3208 do
3209         if test ! -d $srcdir/$cf_dir ; then
3210                 continue
3211         fi
3212
3213         if test -f $cf_dir/Makefile ; then
3214                 case "$cf_dir" in
3215                 Ada95) #(vi
3216                         echo 'libs \' >> Makefile
3217                         echo 'install.libs \' >> Makefile
3218                         echo 'uninstall.libs ::' >> Makefile
3219                         echo '  cd '$cf_dir' && ${MAKE} ${CF_MFLAGS} [$]@' >> Makefile
3220                         ;;
3221                 esac
3222         fi
3223
3224         if test -f $srcdir/$cf_dir/modules; then
3225                 echo >> Makefile
3226                 if test -f $srcdir/$cf_dir/headers; then
3227 cat >> Makefile <<CF_EOF
3228 install.includes \\
3229 uninstall.includes \\
3230 CF_EOF
3231                 fi
3232 if test "$cf_dir" != "c++" ; then
3233 echo 'lint \' >> Makefile
3234 fi
3235 cat >> Makefile <<CF_EOF
3236 libs \\
3237 lintlib \\
3238 install.libs \\
3239 uninstall.libs \\
3240 install.$cf_dir \\
3241 uninstall.$cf_dir ::
3242         cd $cf_dir && \${MAKE} \${CF_MFLAGS} \[$]@
3243 CF_EOF
3244         elif test -f $srcdir/$cf_dir/headers; then
3245 cat >> Makefile <<CF_EOF
3246
3247 libs \\
3248 install.libs \\
3249 uninstall.libs \\
3250 install.includes \\
3251 uninstall.includes ::
3252         cd $cf_dir && \${MAKE} \${CF_MFLAGS} \[$]@
3253 CF_EOF
3254 fi
3255 done
3256
3257 cat >> Makefile <<CF_EOF
3258
3259 install.libs uninstall.libs \\
3260 install.data uninstall.data ::
3261 $MAKE_TERMINFO  cd misc && \${MAKE} \${CF_MFLAGS} \[$]@
3262 CF_EOF
3263
3264 if test "x$cf_with_manpages" = xyes; then
3265 cat >> Makefile <<CF_EOF
3266
3267 install.man \\
3268 uninstall.man ::
3269         cd man && \${MAKE} \${CF_MFLAGS} \[$]@
3270 CF_EOF
3271 fi
3272
3273 cat >> Makefile <<CF_EOF
3274
3275 distclean ::
3276         rm -f config.cache config.log config.status Makefile include/ncurses_cfg.h
3277         rm -f headers.sh headers.sed mk_shared_lib.sh
3278         rm -f edit_man.* man_alias.*
3279         rm -rf \${DIRS_TO_MAKE}
3280 CF_EOF
3281
3282 # Special case: tack's manpage lives in its own directory.
3283 if test "x$cf_with_manpages" = xyes; then
3284 if test -d tack ; then
3285 if test -f $srcdir/$tack.h; then
3286 cat >> Makefile <<CF_EOF
3287
3288 install.man \\
3289 uninstall.man ::
3290         cd tack && \${MAKE} \${CF_MFLAGS} \[$]@
3291 CF_EOF
3292 fi
3293 fi
3294 fi
3295
3296 dnl If we're installing into a subdirectory of /usr/include, etc., we should
3297 dnl prepend the subdirectory's name to the "#include" paths.  It won't hurt
3298 dnl anything, and will make it more standardized.  It's awkward to decide this
3299 dnl at configuration because of quoting, so we'll simply make all headers
3300 dnl installed via a script that can do the right thing.
3301
3302 rm -f headers.sed headers.sh
3303
3304 dnl ( generating this script makes the makefiles a little tidier :-)
3305 echo creating headers.sh
3306 cat >headers.sh <<CF_EOF
3307 #! /bin/sh
3308 # This shell script is generated by the 'configure' script.  It is invoked in a
3309 # subdirectory of the build tree.  It generates a sed-script in the parent
3310 # directory that is used to adjust includes for header files that reside in a
3311 # subdirectory of /usr/include, etc.
3312 PRG=""
3313 while test \[$]# != 3
3314 do
3315 PRG="\$PRG \[$]1"; shift
3316 done
3317 DST=\[$]1
3318 REF=\[$]2
3319 SRC=\[$]3
3320 TMPSRC=\${TMPDIR:-/tmp}/\`basename \$SRC\`\$\$
3321 TMPSED=\${TMPDIR:-/tmp}/headers.sed\$\$
3322 echo installing \$SRC in \$DST
3323 CF_EOF
3324
3325 if test $WITH_CURSES_H = yes; then
3326         cat >>headers.sh <<CF_EOF
3327 case \$DST in
3328 /*/include/*)
3329         END=\`basename \$DST\`
3330         for i in \`cat \$REF/../*/headers |fgrep -v "#"\`
3331         do
3332                 NAME=\`basename \$i\`
3333                 echo "s/<\$NAME>/<\$END\/\$NAME>/" >> \$TMPSED
3334         done
3335         ;;
3336 *)
3337         echo "" >> \$TMPSED
3338         ;;
3339 esac
3340 CF_EOF
3341
3342 else
3343         cat >>headers.sh <<CF_EOF
3344 case \$DST in
3345 /*/include/*)
3346         END=\`basename \$DST\`
3347         for i in \`cat \$REF/../*/headers |fgrep -v "#"\`
3348         do
3349                 NAME=\`basename \$i\`
3350                 if test "\$NAME" = "curses.h"
3351                 then
3352                         echo "s/<curses.h>/<ncurses.h>/" >> \$TMPSED
3353                         NAME=ncurses.h
3354                 fi
3355                 echo "s/<\$NAME>/<\$END\/\$NAME>/" >> \$TMPSED
3356         done
3357         ;;
3358 *)
3359         echo "s/<curses.h>/<ncurses.h>/" >> \$TMPSED
3360         ;;
3361 esac
3362 CF_EOF
3363 fi
3364 cat >>headers.sh <<CF_EOF
3365 rm -f \$TMPSRC
3366 sed -f \$TMPSED \$SRC > \$TMPSRC
3367 NAME=\`basename \$SRC\`
3368 CF_EOF
3369 if test $WITH_CURSES_H != yes; then
3370         cat >>headers.sh <<CF_EOF
3371 test "\$NAME" = "curses.h" && NAME=ncurses.h
3372 CF_EOF
3373 fi
3374 cat >>headers.sh <<CF_EOF
3375 # Just in case someone gzip'd manpages, remove the conflicting copy.
3376 test -f \$DST/\$NAME.gz && rm -f \$DST/\$NAME.gz
3377
3378 eval \$PRG \$TMPSRC \$DST/\$NAME
3379 rm -f \$TMPSRC \$TMPSED
3380 CF_EOF
3381
3382 chmod 0755 headers.sh
3383
3384 for cf_dir in $SRC_SUBDIRS
3385 do
3386         if test ! -d $srcdir/$cf_dir ; then
3387                 continue
3388         fi
3389
3390         if test -f $srcdir/$cf_dir/headers; then
3391                 $AWK -f $srcdir/mk-hdr.awk \
3392                         subset="$LIB_SUBSETS" \
3393                         compat="$WITH_CURSES_H" \
3394                         $srcdir/$cf_dir/headers >>$cf_dir/Makefile
3395         fi
3396
3397         if test -f $srcdir/$cf_dir/modules; then
3398                 if test "$cf_dir" != "c++" ; then
3399                         cat >>$cf_dir/Makefile <<"CF_EOF"
3400 depend : ${AUTO_SRC}
3401         makedepend -- ${CPPFLAGS} -- ${C_SRC}
3402
3403 # DO NOT DELETE THIS LINE -- make depend depends on it.
3404 CF_EOF
3405                 fi
3406         fi
3407 done
3408 AC_SUBST(LIBS_TO_MAKE)
3409 ])dnl
3410 dnl ---------------------------------------------------------------------------
3411 dnl CF_LIB_SONAME version: 5 updated: 2010/08/14 18:25:37
3412 dnl -------------
3413 dnl Find the and soname for the given shared library.  Set the cache variable
3414 dnl cf_cv_$3_soname to this, unless it is not found.  Then set the cache
3415 dnl variable to "unknown".
3416 dnl
3417 dnl $1 = headers
3418 dnl $2 = code
3419 dnl $3 = library name
3420 AC_DEFUN([CF_LIB_SONAME],
3421 [
3422 AC_CACHE_CHECK(for soname of $3 library,cf_cv_$3_soname,[
3423
3424 cf_cv_$3_soname=unknown
3425 if test "$cross_compiling" != yes ; then
3426 cat >conftest.$ac_ext <<CF_EOF
3427 $1
3428 int main()
3429 {
3430 $2
3431         ${cf_cv_main_return:-return}(0);
3432 }
3433 CF_EOF
3434 cf_save_LIBS="$LIBS"
3435         CF_ADD_LIB($3)
3436         if AC_TRY_EVAL(ac_compile) ; then
3437                 if AC_TRY_EVAL(ac_link) ; then
3438                         cf_cv_$3_soname=`ldd conftest$ac_exeext 2>/dev/null | sed -e 's,^.*/,,' -e 's, .*$,,' | fgrep lib$3.`
3439                         test -z "$cf_cv_$3_soname" && cf_cv_$3_soname=unknown
3440                 fi
3441         fi
3442 rm -rf conftest*
3443 LIBS="$cf_save_LIBS"
3444 fi
3445 ])
3446 ])
3447 dnl ---------------------------------------------------------------------------
3448 dnl CF_LIB_SUFFIX version: 17 updated: 2011/07/02 15:36:04
3449 dnl -------------
3450 dnl Compute the library file-suffix from the given model name
3451 dnl $1 = model name
3452 dnl $2 = variable to set (the nominal library suffix)
3453 dnl $3 = dependency variable to set (actual filename)
3454 dnl The variable $LIB_SUFFIX, if set, prepends the variable to set.
3455 AC_DEFUN([CF_LIB_SUFFIX],
3456 [
3457         AC_REQUIRE([CF_SUBST_NCURSES_VERSION])
3458         case $1 in #(vi
3459         libtool) #(vi
3460                 $2='.la'
3461                 $3=[$]$2
3462                 ;;
3463         normal) #(vi
3464                 $2='.a'
3465                 $3=[$]$2
3466                 ;;
3467         debug) #(vi
3468                 $2='_g.a'
3469                 $3=[$]$2
3470                 ;;
3471         profile) #(vi
3472                 $2='_p.a'
3473                 $3=[$]$2
3474                 ;;
3475         shared) #(vi
3476                 case $cf_cv_system_name in
3477                 aix[[5-7]]*) #(vi
3478                         $2='.a'
3479                         $3=[$]$2
3480                         ;;
3481                 cygwin*) #(vi
3482                         $2='.dll'
3483                         $3='.dll.a'
3484                         ;;
3485                 darwin*) #(vi
3486                         $2='.dylib'
3487                         $3=[$]$2
3488                         ;;
3489                 hpux*) #(vi
3490                         case $target in
3491                         ia64*) #(vi
3492                                 $2='.so'
3493                                 $3=[$]$2
3494                                 ;;
3495                         *) #(vi
3496                                 $2='.sl'
3497                                 $3=[$]$2
3498                                 ;;
3499                         esac
3500                         ;;
3501                 *)      $2='.so'
3502                         $3=[$]$2
3503                         ;;
3504                 esac
3505         esac
3506         test -n "$LIB_SUFFIX" && $2="${LIB_SUFFIX}[$]{$2}"
3507         test -n "$LIB_SUFFIX" && $3="${LIB_SUFFIX}[$]{$3}"
3508 ])dnl
3509 dnl ---------------------------------------------------------------------------
3510 dnl CF_LIB_TYPE version: 4 updated: 2000/10/20 22:57:49
3511 dnl -----------
3512 dnl Compute the string to append to -library from the given model name
3513 dnl $1 = model name
3514 dnl $2 = variable to set
3515 dnl The variable $LIB_SUFFIX, if set, prepends the variable to set.
3516 AC_DEFUN([CF_LIB_TYPE],
3517 [
3518         case $1 in
3519         libtool) $2=''   ;;
3520         normal)  $2=''   ;;
3521         debug)   $2='_g' ;;
3522         profile) $2='_p' ;;
3523         shared)  $2=''   ;;
3524         esac
3525         test -n "$LIB_SUFFIX" && $2="${LIB_SUFFIX}[$]{$2}"
3526 ])dnl
3527 dnl ---------------------------------------------------------------------------
3528 dnl CF_LINK_DATAONLY version: 9 updated: 2009/01/01 20:21:38
3529 dnl ----------------
3530 dnl Some systems have a non-ANSI linker that doesn't pull in modules that have
3531 dnl only data (i.e., no functions), for example NeXT.  On those systems we'll
3532 dnl have to provide wrappers for global tables to ensure they're linked
3533 dnl properly.
3534 AC_DEFUN([CF_LINK_DATAONLY],
3535 [
3536 AC_MSG_CHECKING([if data-only library module links])
3537 AC_CACHE_VAL(cf_cv_link_dataonly,[
3538         rm -f conftest.a
3539         cat >conftest.$ac_ext <<EOF
3540 #line __oline__ "configure"
3541 int     testdata[[3]] = { 123, 456, 789 };
3542 EOF
3543         if AC_TRY_EVAL(ac_compile) ; then
3544                 mv conftest.o data.o && \
3545                 ( $AR $ARFLAGS conftest.a data.o ) 2>&AC_FD_CC 1>/dev/null
3546         fi
3547         rm -f conftest.$ac_ext data.o
3548         cat >conftest.$ac_ext <<EOF
3549 #line __oline__ "configure"
3550 int     testfunc()
3551 {
3552 #if defined(NeXT)
3553         ${cf_cv_main_return:-return}(1);        /* I'm told this linker is broken */
3554 #else
3555         extern int testdata[[3]];
3556         return testdata[[0]] == 123
3557            &&  testdata[[1]] == 456
3558            &&  testdata[[2]] == 789;
3559 #endif
3560 }
3561 EOF
3562         if AC_TRY_EVAL(ac_compile); then
3563                 mv conftest.o func.o && \
3564                 ( $AR $ARFLAGS conftest.a func.o ) 2>&AC_FD_CC 1>/dev/null
3565         fi
3566         rm -f conftest.$ac_ext func.o
3567         ( eval $RANLIB conftest.a ) 2>&AC_FD_CC >/dev/null
3568         cf_saveLIBS="$LIBS"
3569         LIBS="conftest.a $LIBS"
3570         AC_TRY_RUN([
3571         int main()
3572         {
3573                 extern int testfunc();
3574                 ${cf_cv_main_return:-return} (!testfunc());
3575         }
3576         ],
3577         [cf_cv_link_dataonly=yes],
3578         [cf_cv_link_dataonly=no],
3579         [cf_cv_link_dataonly=unknown])
3580         LIBS="$cf_saveLIBS"
3581         ])
3582 AC_MSG_RESULT($cf_cv_link_dataonly)
3583
3584 if test "$cf_cv_link_dataonly" = no ; then
3585         AC_DEFINE(BROKEN_LINKER)
3586         BROKEN_LINKER=1
3587 fi
3588
3589 ])dnl
3590 dnl ---------------------------------------------------------------------------
3591 dnl CF_LINK_FUNCS version: 7 updated: 2006/12/16 12:33:30
3592 dnl -------------
3593 dnl Most Unix systems have both link and symlink, a few don't have symlink.
3594 dnl A few non-Unix systems implement symlink, but not link.
3595 dnl A few non-systems implement neither (or have nonfunctional versions).
3596 AC_DEFUN([CF_LINK_FUNCS],
3597 [
3598 AC_CHECK_FUNCS( \
3599         remove \
3600         unlink )
3601
3602 if test "$cross_compiling" = yes ; then
3603         AC_CHECK_FUNCS( \
3604                 link \
3605                 symlink )
3606 else
3607         AC_CACHE_CHECK(if link/symlink functions work,cf_cv_link_funcs,[
3608                 cf_cv_link_funcs=
3609                 for cf_func in link symlink ; do
3610                         AC_TRY_RUN([
3611 #include <sys/types.h>
3612 #include <sys/stat.h>
3613 #ifdef HAVE_UNISTD_H
3614 #include <unistd.h>
3615 #endif
3616 int main()
3617 {
3618         int fail = 0;
3619         char *src = "config.log";
3620         char *dst = "conftest.chk";
3621         struct stat src_sb;
3622         struct stat dst_sb;
3623
3624         stat(src, &src_sb);
3625         fail = ($cf_func("config.log", "conftest.chk") < 0)
3626             || (stat(dst, &dst_sb) < 0)
3627             || (dst_sb.st_mtime != src_sb.st_mtime);
3628 #ifdef HAVE_UNLINK
3629         unlink(dst);
3630 #else
3631         remove(dst);
3632 #endif
3633         ${cf_cv_main_return:-return} (fail);
3634 }
3635                         ],[
3636                         cf_cv_link_funcs="$cf_cv_link_funcs $cf_func"
3637                         eval 'ac_cv_func_'$cf_func'=yes'],[
3638                         eval 'ac_cv_func_'$cf_func'=no'],[
3639                         eval 'ac_cv_func_'$cf_func'=error'])
3640                 done
3641                 test -z "$cf_cv_link_funcs" && cf_cv_link_funcs=no
3642         ])
3643         test "$ac_cv_func_link"    = yes && AC_DEFINE(HAVE_LINK)
3644         test "$ac_cv_func_symlink" = yes && AC_DEFINE(HAVE_SYMLINK)
3645 fi
3646 ])dnl
3647 dnl ---------------------------------------------------------------------------
3648 dnl CF_MAIN_RETURN version: 1 updated: 2006/12/10 09:51:54
3649 dnl --------------
3650 dnl Check if a return from main to the shell actually returns the same exit
3651 dnl code.  This is true for almost any POSIX environment.
3652 dnl
3653 dnl Some very old environments did not flush stdout, etc., on an exit.  That
3654 dnl would be a useful case to test for also.
3655 AC_DEFUN([CF_MAIN_RETURN],
3656 [
3657 cf_cv_main_return=return
3658 ])dnl
3659 dnl ---------------------------------------------------------------------------
3660 dnl CF_MAKEFLAGS version: 14 updated: 2011/03/31 19:29:46
3661 dnl ------------
3662 dnl Some 'make' programs support ${MAKEFLAGS}, some ${MFLAGS}, to pass 'make'
3663 dnl options to lower-levels.  It's very useful for "make -n" -- if we have it.
3664 dnl (GNU 'make' does both, something POSIX 'make', which happens to make the
3665 dnl ${MAKEFLAGS} variable incompatible because it adds the assignments :-)
3666 AC_DEFUN([CF_MAKEFLAGS],
3667 [
3668 AC_CACHE_CHECK(for makeflags variable, cf_cv_makeflags,[
3669         cf_cv_makeflags=''
3670         for cf_option in '-${MAKEFLAGS}' '${MFLAGS}'
3671         do
3672                 cat >cf_makeflags.tmp <<CF_EOF
3673 SHELL = /bin/sh
3674 all :
3675         @ echo '.$cf_option'
3676 CF_EOF
3677                 cf_result=`${MAKE:-make} -k -f cf_makeflags.tmp 2>/dev/null | fgrep -v "ing directory" | sed -e 's,[[   ]]*$,,'`
3678                 case "$cf_result" in
3679                 .*k)
3680                         cf_result=`${MAKE:-make} -k -f cf_makeflags.tmp CC=cc 2>/dev/null`
3681                         case "$cf_result" in
3682                         .*CC=*) cf_cv_makeflags=
3683                                 ;;
3684                         *)      cf_cv_makeflags=$cf_option
3685                                 ;;
3686                         esac
3687                         break
3688                         ;;
3689                 .-)     ;;
3690                 *)      echo "given option \"$cf_option\", no match \"$cf_result\""
3691                         ;;
3692                 esac
3693         done
3694         rm -f cf_makeflags.tmp
3695 ])
3696
3697 AC_SUBST(cf_cv_makeflags)
3698 ])dnl
3699 dnl ---------------------------------------------------------------------------
3700 dnl CF_MAKE_TAGS version: 6 updated: 2010/10/23 15:52:32
3701 dnl ------------
3702 dnl Generate tags/TAGS targets for makefiles.  Do not generate TAGS if we have
3703 dnl a monocase filesystem.
3704 AC_DEFUN([CF_MAKE_TAGS],[
3705 AC_REQUIRE([CF_MIXEDCASE_FILENAMES])
3706
3707 AC_CHECK_PROGS(CTAGS, exctags ctags)
3708 AC_CHECK_PROGS(ETAGS, exetags etags)
3709
3710 AC_CHECK_PROG(MAKE_LOWER_TAGS, ${CTAGS:-ctags}, yes, no)
3711
3712 if test "$cf_cv_mixedcase" = yes ; then
3713         AC_CHECK_PROG(MAKE_UPPER_TAGS, ${ETAGS:-etags}, yes, no)
3714 else
3715         MAKE_UPPER_TAGS=no
3716 fi
3717
3718 if test "$MAKE_UPPER_TAGS" = yes ; then
3719         MAKE_UPPER_TAGS=
3720 else
3721         MAKE_UPPER_TAGS="#"
3722 fi
3723
3724 if test "$MAKE_LOWER_TAGS" = yes ; then
3725         MAKE_LOWER_TAGS=
3726 else
3727         MAKE_LOWER_TAGS="#"
3728 fi
3729
3730 AC_SUBST(CTAGS)
3731 AC_SUBST(ETAGS)
3732
3733 AC_SUBST(MAKE_UPPER_TAGS)
3734 AC_SUBST(MAKE_LOWER_TAGS)
3735 ])dnl
3736 dnl ---------------------------------------------------------------------------
3737 dnl CF_MANPAGE_FORMAT version: 9 updated: 2010/10/23 16:10:30
3738 dnl -----------------
3739 dnl Option to allow user to override automatic configuration of manpage format.
3740 dnl There are several special cases:
3741 dnl
3742 dnl     gzip - man checks for, can display gzip'd files
3743 dnl     compress - man checks for, can display compressed files
3744 dnl     BSDI - files in the cat-directories are suffixed ".0"
3745 dnl     formatted - installer should format (put files in cat-directory)
3746 dnl     catonly - installer should only format, e.g., for a turnkey system.
3747 dnl
3748 dnl There are other configurations which this macro does not test, e.g., HPUX's
3749 dnl compressed manpages (but uncompressed manpages are fine, and HPUX's naming
3750 dnl convention would not match our use).
3751 AC_DEFUN([CF_MANPAGE_FORMAT],
3752 [
3753 AC_REQUIRE([CF_PATHSEP])
3754 AC_MSG_CHECKING(format of man-pages)
3755
3756 AC_ARG_WITH(manpage-format,
3757         [  --with-manpage-format   specify manpage-format: gzip/compress/BSDI/normal and
3758                           optionally formatted/catonly, e.g., gzip,formatted],
3759         [MANPAGE_FORMAT=$withval],
3760         [MANPAGE_FORMAT=unknown])
3761
3762 test -z "$MANPAGE_FORMAT" && MANPAGE_FORMAT=unknown
3763 MANPAGE_FORMAT=`echo "$MANPAGE_FORMAT" | sed -e 's/,/ /g'`
3764
3765 cf_unknown=
3766
3767 case $MANPAGE_FORMAT in
3768 unknown)
3769   if test -z "$MANPATH" ; then
3770     MANPATH="/usr/man:/usr/share/man"
3771   fi
3772
3773   # look for the 'date' man-page (it's most likely to be installed!)
3774   MANPAGE_FORMAT=
3775   cf_preform=no
3776   cf_catonly=yes
3777   cf_example=date
3778
3779   IFS="${IFS:-  }"; ac_save_ifs="$IFS"; IFS="${IFS}${PATH_SEPARATOR}"
3780   for cf_dir in $MANPATH; do
3781     test -z "$cf_dir" && cf_dir=/usr/man
3782     for cf_name in $cf_dir/man*/$cf_example.[[01]]* $cf_dir/cat*/$cf_example.[[01]]* $cf_dir/man*/$cf_example $cf_dir/cat*/$cf_example
3783     do
3784       cf_test=`echo $cf_name | sed -e 's/*//'`
3785       if test "x$cf_test" = "x$cf_name" ; then
3786
3787         case "$cf_name" in
3788         *.gz) MANPAGE_FORMAT="$MANPAGE_FORMAT gzip";;
3789         *.Z)  MANPAGE_FORMAT="$MANPAGE_FORMAT compress";;
3790         *.0)    MANPAGE_FORMAT="$MANPAGE_FORMAT BSDI";;
3791         *)    MANPAGE_FORMAT="$MANPAGE_FORMAT normal";;
3792         esac
3793
3794         case "$cf_name" in
3795         $cf_dir/man*)
3796           cf_catonly=no
3797           ;;
3798         $cf_dir/cat*)
3799           cf_preform=yes
3800           ;;
3801         esac
3802         break
3803       fi
3804
3805       # if we found a match in either man* or cat*, stop looking
3806       if test -n "$MANPAGE_FORMAT" ; then
3807         cf_found=no
3808         test "$cf_preform" = yes && MANPAGE_FORMAT="$MANPAGE_FORMAT formatted"
3809         test "$cf_catonly" = yes && MANPAGE_FORMAT="$MANPAGE_FORMAT catonly"
3810         case "$cf_name" in
3811         $cf_dir/cat*)
3812           cf_found=yes
3813           ;;
3814         esac
3815         test $cf_found=yes && break
3816       fi
3817     done
3818     # only check the first directory in $MANPATH where we find manpages
3819     if test -n "$MANPAGE_FORMAT" ; then
3820        break
3821     fi
3822   done
3823   # if we did not find the example, just assume it is normal
3824   test -z "$MANPAGE_FORMAT" && MANPAGE_FORMAT=normal
3825   IFS="$ac_save_ifs"
3826   ;;
3827 *)
3828   for cf_option in $MANPAGE_FORMAT; do
3829      case $cf_option in #(vi
3830      gzip|compress|BSDI|normal|formatted|catonly)
3831        ;;
3832      *)
3833        cf_unknown="$cf_unknown $cf_option"
3834        ;;
3835      esac
3836   done
3837   ;;
3838 esac
3839
3840 AC_MSG_RESULT($MANPAGE_FORMAT)
3841 if test -n "$cf_unknown" ; then
3842   AC_MSG_WARN(Unexpected manpage-format $cf_unknown)
3843 fi
3844 ])dnl
3845 dnl ---------------------------------------------------------------------------
3846 dnl CF_MANPAGE_RENAMES version: 7 updated: 2005/06/18 18:51:57
3847 dnl ------------------
3848 dnl The Debian people have their own naming convention for manpages.  This
3849 dnl option lets us override the name of the file containing renaming, or
3850 dnl disable it altogether.
3851 AC_DEFUN([CF_MANPAGE_RENAMES],
3852 [
3853 AC_MSG_CHECKING(for manpage renaming)
3854
3855 AC_ARG_WITH(manpage-renames,
3856         [  --with-manpage-renames  specify manpage-renaming],
3857         [MANPAGE_RENAMES=$withval],
3858         [MANPAGE_RENAMES=yes])
3859
3860 case ".$MANPAGE_RENAMES" in #(vi
3861 .no) #(vi
3862   ;;
3863 .|.yes)
3864   # Debian 'man' program?
3865   if test -f /etc/debian_version ; then
3866     MANPAGE_RENAMES=`cd $srcdir && pwd`/man/man_db.renames
3867   else
3868     MANPAGE_RENAMES=no
3869   fi
3870   ;;
3871 esac
3872
3873 if test "$MANPAGE_RENAMES" != no ; then
3874   if test -f $srcdir/man/$MANPAGE_RENAMES ; then
3875     MANPAGE_RENAMES=`cd $srcdir/man && pwd`/$MANPAGE_RENAMES
3876   elif test ! -f $MANPAGE_RENAMES ; then
3877     AC_MSG_ERROR(not a filename: $MANPAGE_RENAMES)
3878   fi
3879
3880   test ! -d man && mkdir man
3881
3882   # Construct a sed-script to perform renaming within man-pages
3883   if test -n "$MANPAGE_RENAMES" ; then
3884     test ! -d man && mkdir man
3885     sh $srcdir/man/make_sed.sh $MANPAGE_RENAMES >./edit_man.sed
3886   fi
3887 fi
3888
3889 AC_MSG_RESULT($MANPAGE_RENAMES)
3890 AC_SUBST(MANPAGE_RENAMES)
3891 ])dnl
3892 dnl ---------------------------------------------------------------------------
3893 dnl CF_MANPAGE_SYMLINKS version: 5 updated: 2010/07/24 17:12:40
3894 dnl -------------------
3895 dnl Some people expect each tool to make all aliases for manpages in the
3896 dnl man-directory.  This accommodates the older, less-capable implementations
3897 dnl of 'man', and is optional.
3898 AC_DEFUN([CF_MANPAGE_SYMLINKS],
3899 [
3900 AC_MSG_CHECKING(if manpage aliases will be installed)
3901
3902 AC_ARG_WITH(manpage-aliases,
3903         [  --with-manpage-aliases  specify manpage-aliases using .so],
3904         [MANPAGE_ALIASES=$withval],
3905         [MANPAGE_ALIASES=yes])
3906
3907 AC_MSG_RESULT($MANPAGE_ALIASES)
3908
3909 case "x$LN_S" in #(vi
3910 xln*) #(vi
3911         cf_use_symlinks=yes
3912         ;;
3913 *)
3914         cf_use_symlinks=no
3915         ;;
3916 esac
3917
3918 MANPAGE_SYMLINKS=no
3919 if test "$MANPAGE_ALIASES" = yes ; then
3920 AC_MSG_CHECKING(if manpage symlinks should be used)
3921
3922 AC_ARG_WITH(manpage-symlinks,
3923         [  --with-manpage-symlinks specify manpage-aliases using symlinks],
3924         [MANPAGE_SYMLINKS=$withval],
3925         [MANPAGE_SYMLINKS=$cf_use_symlinks])
3926
3927 if test "$$cf_use_symlinks" = no; then
3928 if test "$MANPAGE_SYMLINKS" = yes ; then
3929         AC_MSG_WARN(cannot make symlinks, will use .so files)
3930         MANPAGE_SYMLINKS=no
3931 fi
3932 fi
3933
3934 AC_MSG_RESULT($MANPAGE_SYMLINKS)
3935 fi
3936
3937 ])dnl
3938 dnl ---------------------------------------------------------------------------
3939 dnl CF_MANPAGE_TBL version: 3 updated: 2002/01/19 22:51:32
3940 dnl --------------
3941 dnl This option causes manpages to be run through tbl(1) to generate tables
3942 dnl correctly.
3943 AC_DEFUN([CF_MANPAGE_TBL],
3944 [
3945 AC_MSG_CHECKING(for manpage tbl)
3946
3947 AC_ARG_WITH(manpage-tbl,
3948         [  --with-manpage-tbl      specify manpage processing with tbl],
3949         [MANPAGE_TBL=$withval],
3950         [MANPAGE_TBL=no])
3951
3952 AC_MSG_RESULT($MANPAGE_TBL)
3953 ])dnl
3954 dnl ---------------------------------------------------------------------------
3955 dnl CF_MAN_PAGES version: 39 updated: 2010/10/23 15:44:18
3956 dnl ------------
3957 dnl Try to determine if the man-pages on the system are compressed, and if
3958 dnl so, what format is used.  Use this information to construct a script that
3959 dnl will install man-pages.
3960 AC_DEFUN([CF_MAN_PAGES],
3961 [
3962 CF_HELP_MESSAGE(Options to Specify How Manpages are Installed:)
3963 CF_MANPAGE_FORMAT
3964 CF_MANPAGE_RENAMES
3965 CF_MANPAGE_SYMLINKS
3966 CF_MANPAGE_TBL
3967
3968   if test "$prefix" = "NONE" ; then
3969      cf_prefix="$ac_default_prefix"
3970   else
3971      cf_prefix="$prefix"
3972   fi
3973
3974   case "$MANPAGE_FORMAT" in # (vi
3975   *catonly*) # (vi
3976     cf_format=yes
3977     cf_inboth=no
3978     ;;
3979   *formatted*) # (vi
3980     cf_format=yes
3981     cf_inboth=yes
3982     ;;
3983   *)
3984     cf_format=no
3985     cf_inboth=no
3986     ;;
3987   esac
3988
3989 test ! -d man && mkdir man
3990
3991 cf_so_strip=
3992 cf_compress=
3993 case "$MANPAGE_FORMAT" in #(vi
3994 *compress*) #(vi
3995         cf_so_strip="Z"
3996         cf_compress=compress
3997   ;;
3998 *gzip*)
3999         cf_so_strip="gz"
4000         cf_compress=gzip
4001   ;;
4002 esac
4003
4004 cf_edit_man=./edit_man.sh
4005 cf_man_alias=`pwd`/man_alias.sed
4006
4007 cat >$cf_edit_man <<CF_EOF
4008 #! /bin/sh
4009 # this script is generated by the configure-script CF_MAN_PAGES macro.
4010
4011 prefix="$cf_prefix"
4012 datadir="$datadir"
4013
4014 NCURSES_MAJOR="$NCURSES_MAJOR"
4015 NCURSES_MINOR="$NCURSES_MINOR"
4016 NCURSES_PATCH="$NCURSES_PATCH"
4017
4018 NCURSES_OSPEED="$NCURSES_OSPEED"
4019 TERMINFO="$TERMINFO"
4020
4021 INSTALL="$INSTALL"
4022 INSTALL_DATA="$INSTALL_DATA"
4023
4024 transform="$program_transform_name"
4025
4026 TMP=\${TMPDIR:=/tmp}/man\$\$
4027 trap "rm -f \$TMP" 0 1 2 5 15
4028
4029 form=\[$]1
4030 shift || exit 1
4031
4032 verb=\[$]1
4033 shift || exit 1
4034
4035 mandir=\[$]1
4036 shift || exit 1
4037
4038 srcdir=\[$]1
4039 top_srcdir=\[$]srcdir/..
4040 shift || exit 1
4041
4042 if test "\$form" = normal ; then
4043         if test "$cf_format" = yes ; then
4044         if test "$cf_inboth" = no ; then
4045                 sh \[$]0 format \$verb \$mandir \$srcdir \[$]*
4046                 exit $?
4047         fi
4048         fi
4049         cf_subdir=\$mandir/man
4050         cf_tables=$MANPAGE_TBL
4051 else
4052         cf_subdir=\$mandir/cat
4053         cf_tables=yes
4054 fi
4055
4056 # process the list of source-files
4057 for i in \[$]* ; do
4058 case \$i in #(vi
4059 *.orig|*.rej) ;; #(vi
4060 *.[[0-9]]*)
4061         section=\`expr "\$i" : '.*\\.\\([[0-9]]\\)[[xm]]*'\`;
4062         if test \$verb = installing ; then
4063         if test ! -d \$cf_subdir\${section} ; then
4064                 mkdir -p \$cf_subdir\$section
4065         fi
4066         fi
4067
4068         # replace variables in man page
4069         if test ! -f $cf_man_alias ; then
4070 cat >>$cf_man_alias <<-CF_EOF2
4071                 s,@DATADIR@,\$datadir,g
4072                 s,@TERMINFO@,\$TERMINFO,g
4073                 s,@NCURSES_MAJOR@,\$NCURSES_MAJOR,g
4074                 s,@NCURSES_MINOR@,\$NCURSES_MINOR,g
4075                 s,@NCURSES_PATCH@,\$NCURSES_PATCH,g
4076                 s,@NCURSES_OSPEED@,\$NCURSES_OSPEED,g
4077 CF_EOF
4078         ifelse($1,,,[
4079         for cf_name in $1
4080         do
4081                 cf_NAME=`echo "$cf_name" | sed y%abcdefghijklmnopqrstuvwxyz./-%ABCDEFGHIJKLMNOPQRSTUVWXYZ___%`
4082                 cf_name=`echo $cf_name|sed "$program_transform_name"`
4083 cat >>$cf_edit_man <<-CF_EOF
4084                 s,@$cf_NAME@,$cf_name,g
4085 CF_EOF
4086         done
4087         ])
4088 cat >>$cf_edit_man <<CF_EOF
4089 CF_EOF2
4090                 echo "...made $cf_man_alias"
4091         fi
4092
4093         aliases=
4094         cf_source=\`basename \$i\`
4095         inalias=\$cf_source
4096         test ! -f \$inalias && inalias="\$srcdir/\$inalias"
4097         if test ! -f \$inalias ; then
4098                 echo .. skipped \$cf_source
4099                 continue
4100         fi
4101 CF_EOF
4102
4103 if test "$MANPAGE_ALIASES" != no ; then
4104 cat >>$cf_edit_man <<CF_EOF
4105         aliases=\`sed -f \$top_srcdir/man/manlinks.sed \$inalias |sed -f $cf_man_alias | sort -u\`
4106 CF_EOF
4107 fi
4108
4109 if test "$MANPAGE_RENAMES" = no ; then
4110 cat >>$cf_edit_man <<CF_EOF
4111         # perform program transformations for section 1 man pages
4112         if test \$section = 1 ; then
4113                 cf_target=\$cf_subdir\${section}/\`echo \$cf_source|sed "\${transform}"\`
4114         else
4115                 cf_target=\$cf_subdir\${section}/\$cf_source
4116         fi
4117 CF_EOF
4118 else
4119 cat >>$cf_edit_man <<CF_EOF
4120         cf_target=\`grep "^\$cf_source" $MANPAGE_RENAMES | $AWK '{print \[$]2}'\`
4121         if test -z "\$cf_target" ; then
4122                 echo '? missing rename for '\$cf_source
4123                 cf_target="\$cf_source"
4124         fi
4125         cf_target="\$cf_subdir\${section}/\${cf_target}"
4126
4127 CF_EOF
4128 fi
4129
4130 cat >>$cf_edit_man <<CF_EOF
4131         sed     -f $cf_man_alias \\
4132 CF_EOF
4133
4134 if test -f $MANPAGE_RENAMES ; then
4135 cat >>$cf_edit_man <<CF_EOF
4136                 < \$i | sed -f `pwd`/edit_man.sed >\$TMP
4137 CF_EOF
4138 else
4139 cat >>$cf_edit_man <<CF_EOF
4140                 < \$i >\$TMP
4141 CF_EOF
4142 fi
4143
4144 cat >>$cf_edit_man <<CF_EOF
4145 if test \$cf_tables = yes ; then
4146         tbl \$TMP >\$TMP.out
4147         mv \$TMP.out \$TMP
4148 fi
4149 CF_EOF
4150
4151 if test $with_curses_h != yes ; then
4152 cat >>$cf_edit_man <<CF_EOF
4153         sed -e "/\#[    ]*include/s,curses.h,ncurses.h," < \$TMP >\$TMP.out
4154         mv \$TMP.out \$TMP
4155 CF_EOF
4156 fi
4157
4158 cat >>$cf_edit_man <<CF_EOF
4159         if test \$form = format ; then
4160                 nroff -man \$TMP >\$TMP.out
4161                 mv \$TMP.out \$TMP
4162         fi
4163 CF_EOF
4164
4165 if test -n "$cf_compress" ; then
4166 cat >>$cf_edit_man <<CF_EOF
4167         if test \$verb = installing ; then
4168         if ( $cf_compress -f \$TMP )
4169         then
4170                 mv \$TMP.$cf_so_strip \$TMP
4171         fi
4172         fi
4173         cf_target="\$cf_target.$cf_so_strip"
4174 CF_EOF
4175 fi
4176
4177 case "$MANPAGE_FORMAT" in #(vi
4178 *BSDI*)
4179 cat >>$cf_edit_man <<CF_EOF
4180         if test \$form = format ; then
4181                 # BSDI installs only .0 suffixes in the cat directories
4182                 cf_target="\`echo \$cf_target|sed -e 's/\.[[1-9]]\+[[a-z]]*/.0/'\`"
4183         fi
4184 CF_EOF
4185   ;;
4186 esac
4187
4188 cat >>$cf_edit_man <<CF_EOF
4189         suffix=\`basename \$cf_target | sed -e 's%^[[^.]]*%%'\`
4190         if test \$verb = installing ; then
4191                 echo \$verb \$cf_target
4192                 \$INSTALL_DATA \$TMP \$cf_target
4193                 test -d \$cf_subdir\${section} &&
4194                 test -n "\$aliases" && (
4195                         cd \$cf_subdir\${section} && (
4196                                 cf_source=\`echo \$cf_target |sed -e 's%^.*/\([[^/]][[^/]]*/[[^/]][[^/]]*$\)%\1%'\`
4197                                 test -n "$cf_so_strip" && cf_source=\`echo \$cf_source |sed -e 's%\.$cf_so_strip\$%%'\`
4198                                 cf_target=\`basename \$cf_target\`
4199                                 for cf_alias in \$aliases
4200                                 do
4201                                         if test \$section = 1 ; then
4202                                                 cf_alias=\`echo \$cf_alias|sed "\${transform}"\`
4203                                         fi
4204
4205                                         if test "$MANPAGE_SYMLINKS" = yes ; then
4206                                                 if test -f \$cf_alias\${suffix} ; then
4207                                                         if ( cmp -s \$cf_target \$cf_alias\${suffix} )
4208                                                         then
4209                                                                 continue
4210                                                         fi
4211                                                 fi
4212                                                 echo .. \$verb alias \$cf_alias\${suffix}
4213 CF_EOF
4214 case "x$LN_S" in #(vi
4215 *-f) #(vi
4216 cat >>$cf_edit_man <<CF_EOF
4217                                                 $LN_S \$cf_target \$cf_alias\${suffix}
4218 CF_EOF
4219         ;;
4220 *)
4221 cat >>$cf_edit_man <<CF_EOF
4222                                                 rm -f \$cf_alias\${suffix}
4223                                                 $LN_S \$cf_target \$cf_alias\${suffix}
4224 CF_EOF
4225         ;;
4226 esac
4227 cat >>$cf_edit_man <<CF_EOF
4228                                         elif test "\$cf_target" != "\$cf_alias\${suffix}" ; then
4229                                                 echo ".so \$cf_source" >\$TMP
4230 CF_EOF
4231 if test -n "$cf_compress" ; then
4232 cat >>$cf_edit_man <<CF_EOF
4233                                                 if test -n "$cf_so_strip" ; then
4234                                                         $cf_compress -f \$TMP
4235                                                         mv \$TMP.$cf_so_strip \$TMP
4236                                                 fi
4237 CF_EOF
4238 fi
4239 cat >>$cf_edit_man <<CF_EOF
4240                                                 echo .. \$verb alias \$cf_alias\${suffix}
4241                                                 rm -f \$cf_alias\${suffix}
4242                                                 \$INSTALL_DATA \$TMP \$cf_alias\${suffix}
4243                                         fi
4244                                 done
4245                         )
4246                 )
4247         elif test \$verb = removing ; then
4248                 test -f \$cf_target && (
4249                         echo \$verb \$cf_target
4250                         rm -f \$cf_target
4251                 )
4252                 test -d \$cf_subdir\${section} &&
4253                 test -n "\$aliases" && (
4254                         cd \$cf_subdir\${section} && (
4255                                 for cf_alias in \$aliases
4256                                 do
4257                                         if test \$section = 1 ; then
4258                                                 cf_alias=\`echo \$cf_alias|sed "\${transform}"\`
4259                                         fi
4260
4261                                         echo .. \$verb alias \$cf_alias\${suffix}
4262                                         rm -f \$cf_alias\${suffix}
4263                                 done
4264                         )
4265                 )
4266         else
4267 #               echo ".hy 0"
4268                 cat \$TMP
4269         fi
4270         ;;
4271 esac
4272 done
4273
4274 if test $cf_inboth = yes ; then
4275 if test \$form != format ; then
4276         sh \[$]0 format \$verb \$mandir \$srcdir \[$]*
4277 fi
4278 fi
4279
4280 exit 0
4281 CF_EOF
4282 chmod 755 $cf_edit_man
4283
4284 ])dnl
4285 dnl ---------------------------------------------------------------------------
4286 dnl CF_MATH_LIB version: 8 updated: 2010/05/29 16:31:02
4287 dnl -----------
4288 dnl Checks for libraries.  At least one UNIX system, Apple Macintosh
4289 dnl Rhapsody 5.5, does not have -lm.  We cannot use the simpler
4290 dnl AC_CHECK_LIB(m,sin), because that fails for C++.
4291 AC_DEFUN([CF_MATH_LIB],
4292 [
4293 AC_CACHE_CHECK(if -lm needed for math functions,
4294         cf_cv_need_libm,[
4295         AC_TRY_LINK([
4296         #include <stdio.h>
4297         #include <math.h>
4298         ],
4299         [double x = rand(); printf("result = %g\n", ]ifelse([$2],,sin(x),$2)[)],
4300         [cf_cv_need_libm=no],
4301         [cf_cv_need_libm=yes])])
4302 if test "$cf_cv_need_libm" = yes
4303 then
4304 ifelse($1,,[
4305         CF_ADD_LIB(m)
4306 ],[$1=-lm])
4307 fi
4308 ])
4309 dnl ---------------------------------------------------------------------------
4310 dnl CF_MIXEDCASE_FILENAMES version: 3 updated: 2003/09/20 17:07:55
4311 dnl ----------------------
4312 dnl Check if the file-system supports mixed-case filenames.  If we're able to
4313 dnl create a lowercase name and see it as uppercase, it doesn't support that.
4314 AC_DEFUN([CF_MIXEDCASE_FILENAMES],
4315 [
4316 AC_CACHE_CHECK(if filesystem supports mixed-case filenames,cf_cv_mixedcase,[
4317 if test "$cross_compiling" = yes ; then
4318         case $target_alias in #(vi
4319         *-os2-emx*|*-msdosdjgpp*|*-cygwin*|*-mingw32*|*-uwin*) #(vi
4320                 cf_cv_mixedcase=no
4321                 ;;
4322         *)
4323                 cf_cv_mixedcase=yes
4324                 ;;
4325         esac
4326 else
4327         rm -f conftest CONFTEST
4328         echo test >conftest
4329         if test -f CONFTEST ; then
4330                 cf_cv_mixedcase=no
4331         else
4332                 cf_cv_mixedcase=yes
4333         fi
4334         rm -f conftest CONFTEST
4335 fi
4336 ])
4337 test "$cf_cv_mixedcase" = yes && AC_DEFINE(MIXEDCASE_FILENAMES)
4338 ])dnl
4339 dnl ---------------------------------------------------------------------------
4340 dnl CF_MKSTEMP version: 7 updated: 2010/08/14 18:25:37
4341 dnl ----------
4342 dnl Check for a working mkstemp.  This creates two files, checks that they are
4343 dnl successfully created and distinct (AmigaOS apparently fails on the last).
4344 AC_DEFUN([CF_MKSTEMP],[
4345 AC_CACHE_CHECK(for working mkstemp, cf_cv_func_mkstemp,[
4346 rm -rf conftest*
4347 AC_TRY_RUN([
4348 #include <sys/types.h>
4349 #include <stdlib.h>
4350 #include <stdio.h>
4351 #include <string.h>
4352 #include <sys/stat.h>
4353 int main()
4354 {
4355         char *tmpl = "conftestXXXXXX";
4356         char name[2][80];
4357         int n;
4358         int result = 0;
4359         int fd;
4360         struct stat sb;
4361
4362         umask(077);
4363         for (n = 0; n < 2; ++n) {
4364                 strcpy(name[n], tmpl);
4365                 if ((fd = mkstemp(name[n])) >= 0) {
4366                         if (!strcmp(name[n], tmpl)
4367                          || stat(name[n], &sb) != 0
4368                          || (sb.st_mode & S_IFMT) != S_IFREG
4369                          || (sb.st_mode & 077) != 0) {
4370                                 result = 1;
4371                         }
4372                         close(fd);
4373                 }
4374         }
4375         if (result == 0
4376          && !strcmp(name[0], name[1]))
4377                 result = 1;
4378         ${cf_cv_main_return:-return}(result);
4379 }
4380 ],[cf_cv_func_mkstemp=yes
4381 ],[cf_cv_func_mkstemp=no
4382 ],[AC_CHECK_FUNC(mkstemp)
4383 ])
4384 ])
4385 if test "x$cf_cv_func_mkstemp" = xyes || test "x$ac_cv_func_mkstemp" = xyes ; then
4386         AC_DEFINE(HAVE_MKSTEMP)
4387 fi
4388 ])dnl
4389 dnl ---------------------------------------------------------------------------
4390 dnl CF_MSG_LOG version: 5 updated: 2010/10/23 15:52:32
4391 dnl ----------
4392 dnl Write a debug message to config.log, along with the line number in the
4393 dnl configure script.
4394 AC_DEFUN([CF_MSG_LOG],[
4395 echo "${as_me:-configure}:__oline__: testing $* ..." 1>&AC_FD_CC
4396 ])dnl
4397 dnl ---------------------------------------------------------------------------
4398 dnl CF_NCURSES_ABI_6 version: 1 updated: 2005/09/17 18:42:49
4399 dnl ----------------
4400 dnl Set ncurses' ABI to 6 unless overridden by explicit configure option, and
4401 dnl warn about this.
4402 AC_DEFUN([CF_NCURSES_ABI_6],[
4403 if test "${with_abi_version+set}" != set; then
4404         case $cf_cv_rel_version in
4405         5.*)
4406                 cf_cv_rel_version=6.0
4407                 cf_cv_abi_version=6
4408                 AC_MSG_WARN(Overriding ABI version to $cf_cv_abi_version)
4409                 ;;
4410         esac
4411 fi
4412 ])dnl
4413 dnl ---------------------------------------------------------------------------
4414 dnl CF_NO_LEAKS_OPTION version: 4 updated: 2006/12/16 14:24:05
4415 dnl ------------------
4416 dnl see CF_WITH_NO_LEAKS
4417 AC_DEFUN([CF_NO_LEAKS_OPTION],[
4418 AC_MSG_CHECKING(if you want to use $1 for testing)
4419 AC_ARG_WITH($1,
4420         [$2],
4421         [AC_DEFINE($3)ifelse([$4],,[
4422          $4
4423 ])
4424         : ${with_cflags:=-g}
4425         : ${with_no_leaks:=yes}
4426          with_$1=yes],
4427         [with_$1=])
4428 AC_MSG_RESULT(${with_$1:-no})
4429
4430 case .$with_cflags in #(vi
4431 .*-g*)
4432         case .$CFLAGS in #(vi
4433         .*-g*) #(vi
4434                 ;;
4435         *)
4436                 CF_ADD_CFLAGS([-g])
4437                 ;;
4438         esac
4439         ;;
4440 esac
4441 ])dnl
4442 dnl ---------------------------------------------------------------------------
4443 dnl CF_NUMBER_SYNTAX version: 1 updated: 2003/09/20 18:12:49
4444 dnl ----------------
4445 dnl Check if the given variable is a number.  If not, report an error.
4446 dnl $1 is the variable
4447 dnl $2 is the message
4448 AC_DEFUN([CF_NUMBER_SYNTAX],[
4449 if test -n "$1" ; then
4450   case $1 in #(vi
4451   [[0-9]]*) #(vi
4452         ;;
4453   *)
4454         AC_MSG_ERROR($2 is not a number: $1)
4455         ;;
4456   esac
4457 else
4458   AC_MSG_ERROR($2 value is empty)
4459 fi
4460 ])dnl
4461 dnl ---------------------------------------------------------------------------
4462 dnl CF_OBJ_SUBDIR version: 4 updated: 2002/02/23 20:38:31
4463 dnl -------------
4464 dnl Compute the object-directory name from the given model name
4465 AC_DEFUN([CF_OBJ_SUBDIR],
4466 [
4467         case $1 in
4468         libtool) $2='obj_lo'  ;;
4469         normal)  $2='objects' ;;
4470         debug)   $2='obj_g' ;;
4471         profile) $2='obj_p' ;;
4472         shared)
4473                 case $cf_cv_system_name in #(vi
4474                 cygwin) #(vi
4475                         $2='objects' ;;
4476                 *)
4477                         $2='obj_s' ;;