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.575 2011/09/24 16:55:29 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: 6 updated: 2011/09/10 16:31:04
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 AC_DEFUN([CF_ENABLE_PC_FILES],[
1198 AC_REQUIRE([CF_PKG_CONFIG])
1199 AC_REQUIRE([CF_WITH_PKG_CONFIG_LIBDIR])
1200
1201 if test "$PKG_CONFIG" != no ; then
1202         if test -n "$PKG_CONFIG_LIBDIR" && test -d "$PKG_CONFIG_LIBDIR" ; then
1203                 AC_MSG_CHECKING(if we should install .pc files for $PKG_CONFIG)
1204                 AC_ARG_ENABLE(pc-files,
1205                         [  --enable-pc-files       generate and install .pc files for pkg-config],
1206                         [enable_pc_files=$enableval],
1207                         [enable_pc_files=no])
1208                 AC_MSG_RESULT($enable_pc_files)
1209         elif test -z "$PKG_CONFIG_LIBDIR" || test "$PKG_CONFIG_LIBDIR" != no; then
1210                 enable_pc_files=no
1211                 AC_MSG_WARN(did not find $PKG_CONFIG library)
1212         fi
1213 else
1214         enable_pc_files=no
1215 fi
1216 ])dnl
1217 dnl ---------------------------------------------------------------------------
1218 dnl CF_ENABLE_RPATH version: 2 updated: 2010/03/27 18:39:42
1219 dnl ---------------
1220 dnl Check if the rpath option should be used, setting cache variable
1221 dnl cf_cv_enable_rpath if so.
1222 AC_DEFUN([CF_ENABLE_RPATH],
1223 [
1224 AC_MSG_CHECKING(if rpath option should be used)
1225 AC_ARG_ENABLE(rpath,
1226 [  --enable-rpath          use rpath option when generating shared libraries],
1227 [cf_cv_enable_rpath=$enableval],
1228 [cf_cv_enable_rpath=no])
1229 AC_MSG_RESULT($cf_cv_enable_rpath)
1230 ])dnl
1231 dnl ---------------------------------------------------------------------------
1232 dnl CF_ERRNO version: 5 updated: 1997/11/30 12:44:39
1233 dnl --------
1234 dnl Check if 'errno' is declared in <errno.h>
1235 AC_DEFUN([CF_ERRNO],
1236 [
1237 CF_CHECK_ERRNO(errno)
1238 ])dnl
1239 dnl ---------------------------------------------------------------------------
1240 dnl CF_ETIP_DEFINES version: 3 updated: 2003/03/22 19:13:43
1241 dnl ---------------
1242 dnl Test for conflicting definitions of exception in gcc 2.8.0, etc., between
1243 dnl math.h and builtin.h, only for ncurses
1244 AC_DEFUN([CF_ETIP_DEFINES],
1245 [
1246 AC_MSG_CHECKING(for special defines needed for etip.h)
1247 cf_save_CXXFLAGS="$CXXFLAGS"
1248 cf_result="none"
1249 for cf_math in "" MATH_H
1250 do
1251 for cf_excp in "" MATH_EXCEPTION
1252 do
1253         CXXFLAGS="$cf_save_CXXFLAGS -I${srcdir}/c++ -I${srcdir}/menu -I${srcdir}/include"
1254         test -n "$cf_math" && CXXFLAGS="$CXXFLAGS -DETIP_NEEDS_${cf_math}"
1255         test -n "$cf_excp" && CXXFLAGS="$CXXFLAGS -DETIP_NEEDS_${cf_excp}"
1256 AC_TRY_COMPILE([
1257 #include <etip.h.in>
1258 ],[],[
1259         test -n "$cf_math" && AC_DEFINE_UNQUOTED(ETIP_NEEDS_${cf_math})
1260         test -n "$cf_excp" && AC_DEFINE_UNQUOTED(ETIP_NEEDS_${cf_excp})
1261         cf_result="$cf_math $cf_excp"
1262         break
1263 ],[])
1264 done
1265 done
1266 AC_MSG_RESULT($cf_result)
1267 CXXFLAGS="$cf_save_CXXFLAGS"
1268 ])
1269 dnl ---------------------------------------------------------------------------
1270 dnl CF_FIND_LINKAGE version: 19 updated: 2010/05/29 16:31:02
1271 dnl ---------------
1272 dnl Find a library (specifically the linkage used in the code fragment),
1273 dnl searching for it if it is not already in the library path.
1274 dnl See also CF_ADD_SEARCHPATH.
1275 dnl
1276 dnl Parameters (4-on are optional):
1277 dnl     $1 = headers for library entrypoint
1278 dnl     $2 = code fragment for library entrypoint
1279 dnl     $3 = the library name without the "-l" option or ".so" suffix.
1280 dnl     $4 = action to perform if successful (default: update CPPFLAGS, etc)
1281 dnl     $5 = action to perform if not successful
1282 dnl     $6 = module name, if not the same as the library name
1283 dnl     $7 = extra libraries
1284 dnl
1285 dnl Sets these variables:
1286 dnl     $cf_cv_find_linkage_$3 - yes/no according to whether linkage is found
1287 dnl     $cf_cv_header_path_$3 - include-directory if needed
1288 dnl     $cf_cv_library_path_$3 - library-directory if needed
1289 dnl     $cf_cv_library_file_$3 - library-file if needed, e.g., -l$3
1290 AC_DEFUN([CF_FIND_LINKAGE],[
1291
1292 # If the linkage is not already in the $CPPFLAGS/$LDFLAGS configuration, these
1293 # will be set on completion of the AC_TRY_LINK below.
1294 cf_cv_header_path_$3=
1295 cf_cv_library_path_$3=
1296
1297 CF_MSG_LOG([Starting [FIND_LINKAGE]($3,$6)])
1298
1299 cf_save_LIBS="$LIBS"
1300
1301 AC_TRY_LINK([$1],[$2],[
1302         cf_cv_find_linkage_$3=yes
1303         cf_cv_header_path_$3=/usr/include
1304         cf_cv_library_path_$3=/usr/lib
1305 ],[
1306
1307 LIBS="-l$3 $7 $cf_save_LIBS"
1308
1309 AC_TRY_LINK([$1],[$2],[
1310         cf_cv_find_linkage_$3=yes
1311         cf_cv_header_path_$3=/usr/include
1312         cf_cv_library_path_$3=/usr/lib
1313         cf_cv_library_file_$3="-l$3"
1314 ],[
1315         cf_cv_find_linkage_$3=no
1316         LIBS="$cf_save_LIBS"
1317
1318     CF_VERBOSE(find linkage for $3 library)
1319     CF_MSG_LOG([Searching for headers in [FIND_LINKAGE]($3,$6)])
1320
1321     cf_save_CPPFLAGS="$CPPFLAGS"
1322     cf_test_CPPFLAGS="$CPPFLAGS"
1323
1324     CF_HEADER_PATH(cf_search,ifelse([$6],,[$3],[$6]))
1325     for cf_cv_header_path_$3 in $cf_search
1326     do
1327       if test -d $cf_cv_header_path_$3 ; then
1328         CF_VERBOSE(... testing $cf_cv_header_path_$3)
1329         CPPFLAGS="$cf_save_CPPFLAGS -I$cf_cv_header_path_$3"
1330         AC_TRY_COMPILE([$1],[$2],[
1331             CF_VERBOSE(... found $3 headers in $cf_cv_header_path_$3)
1332             cf_cv_find_linkage_$3=maybe
1333             cf_test_CPPFLAGS="$CPPFLAGS"
1334             break],[
1335             CPPFLAGS="$cf_save_CPPFLAGS"
1336             ])
1337       fi
1338     done
1339
1340     if test "$cf_cv_find_linkage_$3" = maybe ; then
1341
1342       CF_MSG_LOG([Searching for $3 library in [FIND_LINKAGE]($3,$6)])
1343
1344       cf_save_LIBS="$LIBS"
1345       cf_save_LDFLAGS="$LDFLAGS"
1346
1347       ifelse([$6],,,[
1348         CPPFLAGS="$cf_test_CPPFLAGS"
1349         LIBS="-l$3 $7 $cf_save_LIBS"
1350         AC_TRY_LINK([$1],[$2],[
1351             CF_VERBOSE(... found $3 library in system)
1352             cf_cv_find_linkage_$3=yes])
1353             CPPFLAGS="$cf_save_CPPFLAGS"
1354             LIBS="$cf_save_LIBS"
1355             ])
1356
1357       if test "$cf_cv_find_linkage_$3" != yes ; then
1358         CF_LIBRARY_PATH(cf_search,$3)
1359         for cf_cv_library_path_$3 in $cf_search
1360         do
1361           if test -d $cf_cv_library_path_$3 ; then
1362             CF_VERBOSE(... testing $cf_cv_library_path_$3)
1363             CPPFLAGS="$cf_test_CPPFLAGS"
1364             LIBS="-l$3 $7 $cf_save_LIBS"
1365             LDFLAGS="$cf_save_LDFLAGS -L$cf_cv_library_path_$3"
1366             AC_TRY_LINK([$1],[$2],[
1367                 CF_VERBOSE(... found $3 library in $cf_cv_library_path_$3)
1368                 cf_cv_find_linkage_$3=yes
1369                 cf_cv_library_file_$3="-l$3"
1370                 break],[
1371                 CPPFLAGS="$cf_save_CPPFLAGS"
1372                 LIBS="$cf_save_LIBS"
1373                 LDFLAGS="$cf_save_LDFLAGS"
1374                 ])
1375           fi
1376         done
1377         CPPFLAGS="$cf_save_CPPFLAGS"
1378         LDFLAGS="$cf_save_LDFLAGS"
1379       fi
1380
1381     else
1382       cf_cv_find_linkage_$3=no
1383     fi
1384     ],$7)
1385 ])
1386
1387 LIBS="$cf_save_LIBS"
1388
1389 if test "$cf_cv_find_linkage_$3" = yes ; then
1390 ifelse([$4],,[
1391         CF_ADD_INCDIR($cf_cv_header_path_$3)
1392         CF_ADD_LIBDIR($cf_cv_library_path_$3)
1393         CF_ADD_LIB($3)
1394 ],[$4])
1395 else
1396 ifelse([$5],,AC_MSG_WARN(Cannot find $3 library),[$5])
1397 fi
1398 ])dnl
1399 dnl ---------------------------------------------------------------------------
1400 dnl CF_FUNC_DLSYM version: 2 updated: 2010/05/29 16:31:02
1401 dnl -------------
1402 dnl Test for dlsym() and related functions, as well as libdl.
1403 dnl
1404 dnl Sets
1405 dnl     $cf_have_dlsym
1406 dnl     $cf_have_libdl
1407 AC_DEFUN([CF_FUNC_DLSYM],[
1408 cf_have_dlsym=no
1409 AC_CHECK_FUNC(dlsym,cf_have_dlsym=yes,[
1410
1411 cf_have_libdl=no
1412 AC_CHECK_LIB(dl,dlsym,[
1413         cf_have_dlsym=yes
1414         cf_have_libdl=yes])])
1415
1416 if test "$cf_have_dlsym" = yes ; then
1417         test "$cf_have_libdl" = yes && CF_ADD_LIB(dl)
1418
1419         AC_MSG_CHECKING(whether able to link to dl*() functions)
1420         AC_TRY_LINK([#include <dlfcn.h>],[
1421                 void *obj;
1422                 if ((obj = dlopen("filename", 0)) != 0) {
1423                         if (dlsym(obj, "symbolname") == 0) {
1424                         dlclose(obj);
1425                         }
1426                 }],[
1427                 AC_DEFINE(HAVE_LIBDL)],[
1428                 AC_MSG_ERROR(Cannot link test program for libdl)])
1429         AC_MSG_RESULT(ok)
1430 else
1431         AC_MSG_ERROR(Cannot find dlsym function)
1432 fi
1433 ])
1434 dnl ---------------------------------------------------------------------------
1435 dnl CF_FUNC_MEMMOVE version: 7 updated: 2006/12/16 12:33:30
1436 dnl ---------------
1437 dnl Check for memmove, or a bcopy that can handle overlapping copy.  If neither
1438 dnl is found, add our own version of memmove to the list of objects.
1439 AC_DEFUN([CF_FUNC_MEMMOVE],
1440 [
1441 AC_CHECK_FUNC(memmove,,[
1442 AC_CHECK_FUNC(bcopy,[
1443         AC_CACHE_CHECK(if bcopy does overlapping moves,cf_cv_good_bcopy,[
1444                 AC_TRY_RUN([
1445 int main() {
1446         static char data[] = "abcdefghijklmnopqrstuwwxyz";
1447         char temp[40];
1448         bcopy(data, temp, sizeof(data));
1449         bcopy(temp+10, temp, 15);
1450         bcopy(temp+5, temp+15, 10);
1451         ${cf_cv_main_return:-return} (strcmp(temp, "klmnopqrstuwwxypqrstuwwxyz"));
1452 }
1453                 ],
1454                 [cf_cv_good_bcopy=yes],
1455                 [cf_cv_good_bcopy=no],
1456                 [cf_cv_good_bcopy=unknown])
1457                 ])
1458         ],[cf_cv_good_bcopy=no])
1459         if test "$cf_cv_good_bcopy" = yes ; then
1460                 AC_DEFINE(USE_OK_BCOPY)
1461         else
1462                 AC_DEFINE(USE_MY_MEMMOVE)
1463         fi
1464 ])])dnl
1465 dnl ---------------------------------------------------------------------------
1466 dnl CF_FUNC_NANOSLEEP version: 3 updated: 2006/12/16 12:33:30
1467 dnl -----------------
1468 dnl Check for existence of workable nanosleep() function.  Some systems, e.g.,
1469 dnl AIX 4.x, provide a non-working version.
1470 AC_DEFUN([CF_FUNC_NANOSLEEP],[
1471 AC_CACHE_CHECK(if nanosleep really works,cf_cv_func_nanosleep,[
1472 AC_TRY_RUN([
1473 #include <stdio.h>
1474 #include <errno.h>
1475 #include <time.h>
1476
1477 #ifdef HAVE_SYS_TIME_H
1478 #include <sys/time.h>
1479 #endif
1480
1481 int main() {
1482         struct timespec ts1, ts2;
1483         int code;
1484         ts1.tv_sec  = 0;
1485         ts1.tv_nsec = 750000000;
1486         ts2.tv_sec  = 0;
1487         ts2.tv_nsec = 0;
1488         errno = 0;
1489         code = nanosleep(&ts1, &ts2); /* on failure errno is ENOSYS. */
1490         ${cf_cv_main_return:-return}(code != 0);
1491 }
1492 ],
1493         [cf_cv_func_nanosleep=yes],
1494         [cf_cv_func_nanosleep=no],
1495         [cf_cv_func_nanosleep=unknown])])
1496
1497 test "$cf_cv_func_nanosleep" = "yes" && AC_DEFINE(HAVE_NANOSLEEP)
1498 ])
1499 dnl ---------------------------------------------------------------------------
1500 dnl CF_FUNC_OPENPTY version: 3 updated: 2010/05/29 16:31:02
1501 dnl ---------------
1502 dnl Check for openpty() function, along with <pty.h> header.  It may need the
1503 dnl "util" library as well.
1504 AC_DEFUN([CF_FUNC_OPENPTY],
1505 [
1506 AC_CHECK_LIB(util,openpty,cf_cv_lib_util=yes,cf_cv_lib_util=no)
1507 AC_CACHE_CHECK(for openpty header,cf_cv_func_openpty,[
1508     cf_save_LIBS="$LIBS"
1509     test $cf_cv_lib_util = yes && CF_ADD_LIB(util)
1510     for cf_header in pty.h libutil.h util.h
1511     do
1512     AC_TRY_LINK([
1513 #include <$cf_header>
1514 ],[
1515     int x = openpty((int *)0, (int *)0, (char *)0,
1516                    (struct termios *)0, (struct winsize *)0);
1517 ],[
1518         cf_cv_func_openpty=$cf_header
1519         break
1520 ],[
1521         cf_cv_func_openpty=no
1522 ])
1523     done
1524     LIBS="$cf_save_LIBS"
1525 ])
1526 ])dnl
1527 dnl ---------------------------------------------------------------------------
1528 dnl CF_FUNC_POLL version: 4 updated: 2006/12/16 12:33:30
1529 dnl ------------
1530 dnl See if the poll function really works.  Some platforms have poll(), but
1531 dnl it does not work for terminals or files.
1532 AC_DEFUN([CF_FUNC_POLL],[
1533 AC_CACHE_CHECK(if poll really works,cf_cv_working_poll,[
1534 AC_TRY_RUN([
1535 #include <stdio.h>
1536 #ifdef HAVE_POLL_H
1537 #include <poll.h>
1538 #else
1539 #include <sys/poll.h>
1540 #endif
1541 int main() {
1542         struct pollfd myfds;
1543         int ret;
1544
1545         myfds.fd = 0;
1546         myfds.events = POLLIN;
1547
1548         ret = poll(&myfds, 1, 100);
1549         ${cf_cv_main_return:-return}(ret != 0);
1550 }],
1551         [cf_cv_working_poll=yes],
1552         [cf_cv_working_poll=no],
1553         [cf_cv_working_poll=unknown])])
1554 test "$cf_cv_working_poll" = "yes" && AC_DEFINE(HAVE_WORKING_POLL)
1555 ])dnl
1556 dnl ---------------------------------------------------------------------------
1557 dnl CF_FUNC_TERMIOS version: 2 updated: 2000/07/22 23:37:24
1558 dnl ---------------
1559 dnl Some old/broken variations define tcgetattr() only as a macro in
1560 dnl termio(s).h
1561 AC_DEFUN([CF_FUNC_TERMIOS],[
1562 AC_REQUIRE([CF_STRUCT_TERMIOS])
1563 AC_CACHE_CHECK(for tcgetattr, cf_cv_have_tcgetattr,[
1564 AC_TRY_LINK([
1565 #include <sys/types.h>
1566 #ifdef HAVE_UNISTD_H
1567 #include <unistd.h>
1568 #endif
1569 #ifdef HAVE_TERMIOS_H
1570 #include <termios.h>
1571 #define TTY struct termios
1572 #else
1573 #ifdef HAVE_TERMIO_H
1574 #include <termio.h>
1575 #define TTY struct termio
1576 #endif
1577 #endif
1578 ],[
1579 TTY foo;
1580 tcgetattr(1, &foo);],
1581 [cf_cv_have_tcgetattr=yes],
1582 [cf_cv_have_tcgetattr=no])])
1583 test "$cf_cv_have_tcgetattr" = yes && AC_DEFINE(HAVE_TCGETATTR)
1584 ])dnl
1585 dnl ---------------------------------------------------------------------------
1586 dnl CF_FUNC_VSSCANF version: 3 updated: 2001/12/19 00:50:10
1587 dnl ---------------
1588 dnl Check for vsscanf() function, which is in c9x but generally not in earlier
1589 dnl versions of C.  It is in the GNU C library, and can often be simulated by
1590 dnl other functions.
1591 AC_DEFUN([CF_FUNC_VSSCANF],
1592 [
1593 AC_CACHE_CHECK(for vsscanf function or workaround,cf_cv_func_vsscanf,[
1594 AC_TRY_LINK([
1595 #include <stdarg.h>
1596 #include <stdio.h>],[
1597         va_list ap;
1598         vsscanf("from", "%d", ap)],[cf_cv_func_vsscanf=vsscanf],[
1599 AC_TRY_LINK([
1600 #include <stdarg.h>
1601 #include <stdio.h>],[
1602     FILE strbuf;
1603     char *str = "from";
1604
1605     strbuf._flag = _IOREAD;
1606     strbuf._ptr = strbuf._base = (unsigned char *) str;
1607     strbuf._cnt = strlen(str);
1608     strbuf._file = _NFILE;
1609     return (vfscanf(&strbuf, "%d", ap))],[cf_cv_func_vsscanf=vfscanf],[
1610 AC_TRY_LINK([
1611 #include <stdarg.h>
1612 #include <stdio.h>],[
1613     FILE strbuf;
1614     char *str = "from";
1615
1616     strbuf._flag = _IOREAD;
1617     strbuf._ptr = strbuf._base = (unsigned char *) str;
1618     strbuf._cnt = strlen(str);
1619     strbuf._file = _NFILE;
1620     return (_doscan(&strbuf, "%d", ap))],[cf_cv_func_vsscanf=_doscan],[
1621 cf_cv_func_vsscanf=no])])])])
1622
1623 case $cf_cv_func_vsscanf in #(vi
1624 vsscanf) AC_DEFINE(HAVE_VSSCANF);; #(vi
1625 vfscanf) AC_DEFINE(HAVE_VFSCANF);; #(vi
1626 _doscan) AC_DEFINE(HAVE__DOSCAN);;
1627 esac
1628
1629 ])dnl
1630 dnl ---------------------------------------------------------------------------
1631 dnl CF_GCC_ATTRIBUTES version: 14 updated: 2010/10/23 15:52:32
1632 dnl -----------------
1633 dnl Test for availability of useful gcc __attribute__ directives to quiet
1634 dnl compiler warnings.  Though useful, not all are supported -- and contrary
1635 dnl to documentation, unrecognized directives cause older compilers to barf.
1636 AC_DEFUN([CF_GCC_ATTRIBUTES],
1637 [
1638 if test "$GCC" = yes
1639 then
1640 cat > conftest.i <<EOF
1641 #ifndef GCC_PRINTF
1642 #define GCC_PRINTF 0
1643 #endif
1644 #ifndef GCC_SCANF
1645 #define GCC_SCANF 0
1646 #endif
1647 #ifndef GCC_NORETURN
1648 #define GCC_NORETURN /* nothing */
1649 #endif
1650 #ifndef GCC_UNUSED
1651 #define GCC_UNUSED /* nothing */
1652 #endif
1653 EOF
1654 if test "$GCC" = yes
1655 then
1656         AC_CHECKING([for $CC __attribute__ directives])
1657 cat > conftest.$ac_ext <<EOF
1658 #line __oline__ "${as_me:-configure}"
1659 #include "confdefs.h"
1660 #include "conftest.h"
1661 #include "conftest.i"
1662 #if     GCC_PRINTF
1663 #define GCC_PRINTFLIKE(fmt,var) __attribute__((format(printf,fmt,var)))
1664 #else
1665 #define GCC_PRINTFLIKE(fmt,var) /*nothing*/
1666 #endif
1667 #if     GCC_SCANF
1668 #define GCC_SCANFLIKE(fmt,var)  __attribute__((format(scanf,fmt,var)))
1669 #else
1670 #define GCC_SCANFLIKE(fmt,var)  /*nothing*/
1671 #endif
1672 extern void wow(char *,...) GCC_SCANFLIKE(1,2);
1673 extern void oops(char *,...) GCC_PRINTFLIKE(1,2) GCC_NORETURN;
1674 extern void foo(void) GCC_NORETURN;
1675 int main(int argc GCC_UNUSED, char *argv[[]] GCC_UNUSED) { return 0; }
1676 EOF
1677         cf_printf_attribute=no
1678         cf_scanf_attribute=no
1679         for cf_attribute in scanf printf unused noreturn
1680         do
1681                 CF_UPPER(cf_ATTRIBUTE,$cf_attribute)
1682                 cf_directive="__attribute__(($cf_attribute))"
1683                 echo "checking for $CC $cf_directive" 1>&AC_FD_CC
1684
1685                 case $cf_attribute in #(vi
1686                 printf) #(vi
1687                         cf_printf_attribute=yes
1688                         cat >conftest.h <<EOF
1689 #define GCC_$cf_ATTRIBUTE 1
1690 EOF
1691                         ;;
1692                 scanf) #(vi
1693                         cf_scanf_attribute=yes
1694                         cat >conftest.h <<EOF
1695 #define GCC_$cf_ATTRIBUTE 1
1696 EOF
1697                         ;;
1698                 *) #(vi
1699                         cat >conftest.h <<EOF
1700 #define GCC_$cf_ATTRIBUTE $cf_directive
1701 EOF
1702                         ;;
1703                 esac
1704
1705                 if AC_TRY_EVAL(ac_compile); then
1706                         test -n "$verbose" && AC_MSG_RESULT(... $cf_attribute)
1707                         cat conftest.h >>confdefs.h
1708                         case $cf_attribute in #(vi
1709                         printf) #(vi
1710                                 if test "$cf_printf_attribute" = no ; then
1711                                         cat >>confdefs.h <<EOF
1712 #define GCC_PRINTFLIKE(fmt,var) /* nothing */
1713 EOF
1714                                 else
1715                                         cat >>confdefs.h <<EOF
1716 #define GCC_PRINTFLIKE(fmt,var) __attribute__((format(printf,fmt,var)))
1717 EOF
1718                                 fi
1719                                 ;;
1720                         scanf) #(vi
1721                                 if test "$cf_scanf_attribute" = no ; then
1722                                         cat >>confdefs.h <<EOF
1723 #define GCC_SCANFLIKE(fmt,var) /* nothing */
1724 EOF
1725                                 else
1726                                         cat >>confdefs.h <<EOF
1727 #define GCC_SCANFLIKE(fmt,var)  __attribute__((format(scanf,fmt,var)))
1728 EOF
1729                                 fi
1730                                 ;;
1731                         esac
1732                 fi
1733         done
1734 else
1735         fgrep define conftest.i >>confdefs.h
1736 fi
1737 rm -rf conftest*
1738 fi
1739 ])dnl
1740 dnl ---------------------------------------------------------------------------
1741 dnl CF_GCC_VERSION version: 5 updated: 2010/04/24 11:02:31
1742 dnl --------------
1743 dnl Find version of gcc
1744 AC_DEFUN([CF_GCC_VERSION],[
1745 AC_REQUIRE([AC_PROG_CC])
1746 GCC_VERSION=none
1747 if test "$GCC" = yes ; then
1748         AC_MSG_CHECKING(version of $CC)
1749         GCC_VERSION="`${CC} --version 2>/dev/null | sed -e '2,$d' -e 's/^.*(GCC) //' -e 's/^[[^0-9.]]*//' -e 's/[[^0-9.]].*//'`"
1750         test -z "$GCC_VERSION" && GCC_VERSION=unknown
1751         AC_MSG_RESULT($GCC_VERSION)
1752 fi
1753 ])dnl
1754 dnl ---------------------------------------------------------------------------
1755 dnl CF_GCC_WARNINGS version: 27 updated: 2010/10/23 15:52:32
1756 dnl ---------------
1757 dnl Check if the compiler supports useful warning options.  There's a few that
1758 dnl we don't use, simply because they're too noisy:
1759 dnl
1760 dnl     -Wconversion (useful in older versions of gcc, but not in gcc 2.7.x)
1761 dnl     -Wredundant-decls (system headers make this too noisy)
1762 dnl     -Wtraditional (combines too many unrelated messages, only a few useful)
1763 dnl     -Wwrite-strings (too noisy, but should review occasionally).  This
1764 dnl             is enabled for ncurses using "--enable-const".
1765 dnl     -pedantic
1766 dnl
1767 dnl Parameter:
1768 dnl     $1 is an optional list of gcc warning flags that a particular
1769 dnl             application might want to use, e.g., "no-unused" for
1770 dnl             -Wno-unused
1771 dnl Special:
1772 dnl     If $with_ext_const is "yes", add a check for -Wwrite-strings
1773 dnl
1774 AC_DEFUN([CF_GCC_WARNINGS],
1775 [
1776 AC_REQUIRE([CF_GCC_VERSION])
1777 CF_INTEL_COMPILER(GCC,INTEL_COMPILER,CFLAGS)
1778
1779 cat > conftest.$ac_ext <<EOF
1780 #line __oline__ "${as_me:-configure}"
1781 int main(int argc, char *argv[[]]) { return (argv[[argc-1]] == 0) ; }
1782 EOF
1783
1784 if test "$INTEL_COMPILER" = yes
1785 then
1786 # The "-wdXXX" options suppress warnings:
1787 # remark #1419: external declaration in primary source file
1788 # remark #1683: explicit conversion of a 64-bit integral type to a smaller integral type (potential portability problem)
1789 # remark #1684: conversion from pointer to same-sized integral type (potential portability problem)
1790 # remark #193: zero used for undefined preprocessing identifier
1791 # remark #593: variable "curs_sb_left_arrow" was set but never used
1792 # remark #810: conversion from "int" to "Dimension={unsigned short}" may lose significant bits
1793 # remark #869: parameter "tw" was never referenced
1794 # remark #981: operands are evaluated in unspecified order
1795 # warning #279: controlling expression is constant
1796
1797         AC_CHECKING([for $CC warning options])
1798         cf_save_CFLAGS="$CFLAGS"
1799         EXTRA_CFLAGS="-Wall"
1800         for cf_opt in \
1801                 wd1419 \
1802                 wd1683 \
1803                 wd1684 \
1804                 wd193 \
1805                 wd593 \
1806                 wd279 \
1807                 wd810 \
1808                 wd869 \
1809                 wd981
1810         do
1811                 CFLAGS="$cf_save_CFLAGS $EXTRA_CFLAGS -$cf_opt"
1812                 if AC_TRY_EVAL(ac_compile); then
1813                         test -n "$verbose" && AC_MSG_RESULT(... -$cf_opt)
1814                         EXTRA_CFLAGS="$EXTRA_CFLAGS -$cf_opt"
1815                 fi
1816         done
1817         CFLAGS="$cf_save_CFLAGS"
1818
1819 elif test "$GCC" = yes
1820 then
1821         AC_CHECKING([for $CC warning options])
1822         cf_save_CFLAGS="$CFLAGS"
1823         EXTRA_CFLAGS=
1824         cf_warn_CONST=""
1825         test "$with_ext_const" = yes && cf_warn_CONST="Wwrite-strings"
1826         for cf_opt in W Wall \
1827                 Wbad-function-cast \
1828                 Wcast-align \
1829                 Wcast-qual \
1830                 Winline \
1831                 Wmissing-declarations \
1832                 Wmissing-prototypes \
1833                 Wnested-externs \
1834                 Wpointer-arith \
1835                 Wshadow \
1836                 Wstrict-prototypes \
1837                 Wundef $cf_warn_CONST $1
1838         do
1839                 CFLAGS="$cf_save_CFLAGS $EXTRA_CFLAGS -$cf_opt"
1840                 if AC_TRY_EVAL(ac_compile); then
1841                         test -n "$verbose" && AC_MSG_RESULT(... -$cf_opt)
1842                         case $cf_opt in #(vi
1843                         Wcast-qual) #(vi
1844                                 CPPFLAGS="$CPPFLAGS -DXTSTRINGDEFINES"
1845                                 ;;
1846                         Winline) #(vi
1847                                 case $GCC_VERSION in
1848                                 [[34]].*)
1849                                         CF_VERBOSE(feature is broken in gcc $GCC_VERSION)
1850                                         continue;;
1851                                 esac
1852                                 ;;
1853                         esac
1854                         EXTRA_CFLAGS="$EXTRA_CFLAGS -$cf_opt"
1855                 fi
1856         done
1857         CFLAGS="$cf_save_CFLAGS"
1858 fi
1859 rm -rf conftest*
1860
1861 AC_SUBST(EXTRA_CFLAGS)
1862 ])dnl
1863 dnl ---------------------------------------------------------------------------
1864 dnl CF_GETOPT_HEADER version: 4 updated: 2009/08/31 20:07:52
1865 dnl ----------------
1866 dnl Check for getopt's variables which are commonly defined in stdlib.h,
1867 dnl unistd.h or (nonstandard) in getopt.h
1868 AC_DEFUN([CF_GETOPT_HEADER],
1869 [
1870 AC_HAVE_HEADERS(unistd.h getopt.h)
1871 AC_CACHE_CHECK(for header declaring getopt variables,cf_cv_getopt_header,[
1872 cf_cv_getopt_header=none
1873 for cf_header in stdio.h stdlib.h unistd.h getopt.h
1874 do
1875 AC_TRY_COMPILE([
1876 #include <$cf_header>],
1877 [int x = optind; char *y = optarg],
1878 [cf_cv_getopt_header=$cf_header
1879  break])
1880 done
1881 ])
1882 if test $cf_cv_getopt_header != none ; then
1883         AC_DEFINE(HAVE_GETOPT_HEADER)
1884 fi
1885 ])dnl
1886 dnl ---------------------------------------------------------------------------
1887 dnl CF_GNAT_GENERICS version: 2 updated: 2011/03/23 20:24:41
1888 dnl ----------------
1889 AC_DEFUN([CF_GNAT_GENERICS],
1890 [
1891 AC_REQUIRE([CF_GNAT_VERSION])
1892
1893 AC_MSG_CHECKING(if GNAT supports generics)
1894 case $cf_gnat_version in #(vi
1895 3.[[1-9]]*|[[4-9]].*) #(vi
1896         cf_gnat_generics=yes
1897         ;;
1898 *)
1899         cf_gnat_generics=no
1900         ;;
1901 esac
1902 AC_MSG_RESULT($cf_gnat_generics)
1903
1904 if test "$cf_gnat_generics" = yes
1905 then
1906         cf_compile_generics=generics
1907         cf_generic_objects="\${GENOBJS}"
1908 else
1909         cf_compile_generics=
1910         cf_generic_objects=
1911 fi
1912
1913 AC_SUBST(cf_compile_generics)
1914 AC_SUBST(cf_generic_objects)
1915 ])dnl
1916 dnl ---------------------------------------------------------------------------
1917 dnl CF_GNAT_PRAGMA_UNREF version: 1 updated: 2010/06/19 15:22:18
1918 dnl --------------------
1919 dnl Check if the gnat pragma "Unreferenced" works.
1920 AC_DEFUN([CF_GNAT_PRAGMA_UNREF],[
1921 AC_CACHE_CHECK(if GNAT pragma Unreferenced works,cf_cv_pragma_unreferenced,[
1922 CF_GNAT_TRY_LINK([procedure conftest;],
1923 [with Text_IO;
1924 with GNAT.OS_Lib;
1925 procedure conftest is
1926    test : Integer;
1927    pragma Unreferenced (test);
1928 begin
1929    test := 1;
1930    Text_IO.Put ("Hello World");
1931    Text_IO.New_Line;
1932    GNAT.OS_Lib.OS_Exit (0);
1933 end conftest;],
1934         [cf_cv_pragma_unreferenced=yes],
1935         [cf_cv_pragma_unreferenced=no])])
1936
1937 # if the pragma is supported, use it (needed in the Trace code).
1938 if test $cf_cv_pragma_unreferenced = yes ; then
1939         PRAGMA_UNREF=TRUE
1940 else
1941         PRAGMA_UNREF=FALSE
1942 fi
1943 AC_SUBST(PRAGMA_UNREF)
1944 ])dnl
1945 dnl ---------------------------------------------------------------------------
1946 dnl CF_GNAT_PROJECTS version: 2 updated: 2011/03/23 20:24:41
1947 dnl ----------------
1948 dnl GNAT projects are configured with ".gpr" project files.
1949 dnl GNAT libraries are a further development, using the project feature.
1950 AC_DEFUN([CF_GNAT_PROJECTS],
1951 [
1952 AC_REQUIRE([CF_GNAT_VERSION])
1953
1954 cf_gnat_libraries=no
1955 cf_gnat_projects=no
1956
1957 AC_MSG_CHECKING(if GNAT supports project files)
1958 case $cf_gnat_version in #(vi
1959 3.[[0-9]]*) #(vi
1960         ;;
1961 *)
1962         case $cf_cv_system_name in #(vi
1963         cygwin*) #(vi
1964                 ;;
1965         *)
1966                 mkdir conftest.src conftest.bin conftest.lib
1967                 cd conftest.src
1968                 rm -rf conftest* *~conftest*
1969                 cat >>library.gpr <<CF_EOF
1970 project Library is
1971   Kind := External ("LIB_KIND");
1972   for Library_Name use "ConfTest";
1973   for Object_Dir use ".";
1974   for Library_ALI_Dir use External("LIBRARY_DIR");
1975   for Library_Version use External ("SONAME");
1976   for Library_Kind use Kind;
1977   for Library_Dir use External("BUILD_DIR");
1978   Source_Dir := External ("SOURCE_DIR");
1979   for Source_Dirs use (Source_Dir);
1980   package Compiler is
1981      for Default_Switches ("Ada") use
1982        ("-g",
1983         "-O2",
1984         "-gnatafno",
1985         "-gnatVa",   -- All validity checks
1986         "-gnatwa");  -- Activate all optional errors
1987   end Compiler;
1988 end Library;
1989 CF_EOF
1990                 cat >>confpackage.ads <<CF_EOF
1991 package ConfPackage is
1992    procedure conftest;
1993 end ConfPackage;
1994 CF_EOF
1995                 cat >>confpackage.adb <<CF_EOF
1996 with Text_IO;
1997 package body ConfPackage is
1998    procedure conftest is
1999    begin
2000       Text_IO.Put ("Hello World");
2001       Text_IO.New_Line;
2002    end conftest;
2003 end ConfPackage;
2004 CF_EOF
2005                 if ( $cf_ada_make $ADAFLAGS \
2006                                 -Plibrary.gpr \
2007                                 -XBUILD_DIR=`cd ../conftest.bin;pwd` \
2008                                 -XLIBRARY_DIR=`cd ../conftest.lib;pwd` \
2009                                 -XSOURCE_DIR=`pwd` \
2010                                 -XSONAME=libConfTest.so.1 \
2011                                 -XLIB_KIND=static 1>&AC_FD_CC 2>&1 ) ; then
2012                         cf_gnat_projects=yes
2013                 fi
2014                 cd ..
2015                 if test -f conftest.lib/confpackage.ali
2016                 then
2017                         cf_gnat_libraries=yes
2018                 fi
2019                 rm -rf conftest* *~conftest*
2020                 ;;
2021         esac
2022         ;;
2023 esac
2024 AC_MSG_RESULT($cf_gnat_projects)
2025
2026 if test $cf_gnat_projects = yes
2027 then
2028         AC_MSG_CHECKING(if GNAT supports libraries)
2029         AC_MSG_RESULT($cf_gnat_libraries)
2030 fi
2031
2032 if test "$cf_gnat_projects" = yes
2033 then
2034         USE_OLD_MAKERULES="#"
2035         USE_GNAT_PROJECTS=""
2036 else
2037         USE_OLD_MAKERULES=""
2038         USE_GNAT_PROJECTS="#"
2039 fi
2040
2041 if test "$cf_gnat_libraries" = yes
2042 then
2043         USE_GNAT_LIBRARIES=""
2044 else
2045         USE_GNAT_LIBRARIES="#"
2046 fi
2047
2048 AC_SUBST(USE_OLD_MAKERULES)
2049 AC_SUBST(USE_GNAT_PROJECTS)
2050 AC_SUBST(USE_GNAT_LIBRARIES)
2051 ])dnl
2052 dnl ---------------------------------------------------------------------------
2053 dnl CF_GNAT_SIGINT version: 1 updated: 2011/03/27 20:07:59
2054 dnl --------------
2055 dnl Check if gnat supports SIGINT, and presumably tasking.  For the latter, it
2056 dnl is noted that gnat may compile a tasking unit even for configurations which
2057 dnl fail at runtime.
2058 AC_DEFUN([CF_GNAT_SIGINT],[
2059 AC_CACHE_CHECK(if GNAT supports SIGINT,cf_cv_gnat_sigint,[
2060 CF_GNAT_TRY_LINK([with Ada.Interrupts.Names;
2061
2062 package ConfTest is
2063
2064    pragma Warnings (Off);  --  the next pragma exists since 3.11p
2065    pragma Unreserve_All_Interrupts;
2066    pragma Warnings (On);
2067
2068    protected Process is
2069       procedure Stop;
2070       function Continue return Boolean;
2071       pragma Attach_Handler (Stop, Ada.Interrupts.Names.SIGINT);
2072    private
2073       Done : Boolean := False;
2074    end Process;
2075
2076 end ConfTest;],
2077 [package body ConfTest is
2078    protected body Process is
2079       procedure Stop is
2080       begin
2081          Done := True;
2082       end Stop;
2083       function Continue return Boolean is
2084       begin
2085          return not Done;
2086       end Continue;
2087    end Process;
2088 end ConfTest;],
2089         [cf_cv_gnat_sigint=yes],
2090         [cf_cv_gnat_sigint=no])])
2091
2092 if test $cf_cv_gnat_sigint = yes ; then
2093         USE_GNAT_SIGINT=""
2094 else
2095         USE_GNAT_SIGINT="#"
2096 fi
2097 AC_SUBST(USE_GNAT_SIGINT)
2098 ])dnl
2099 dnl ---------------------------------------------------------------------------
2100 dnl CF_GNAT_TRY_LINK version: 3 updated: 2011/03/19 14:47:45
2101 dnl ----------------
2102 dnl Verify that a test program compiles/links with GNAT.
2103 dnl $cf_ada_make is set to the program that compiles/links
2104 dnl $ADAFLAGS may be set to the GNAT flags.
2105 dnl
2106 dnl $1 is the text of the spec
2107 dnl $2 is the text of the body
2108 dnl $3 is the shell command to execute if successful
2109 dnl $4 is the shell command to execute if not successful
2110 AC_DEFUN([CF_GNAT_TRY_LINK],
2111 [
2112 rm -rf conftest* *~conftest*
2113 cat >>conftest.ads <<CF_EOF
2114 $1
2115 CF_EOF
2116 cat >>conftest.adb <<CF_EOF
2117 $2
2118 CF_EOF
2119 if ( $cf_ada_make $ADAFLAGS conftest 1>&AC_FD_CC 2>&1 ) ; then
2120 ifelse($3,,      :,[      $3])
2121 ifelse($4,,,[else
2122    $4])
2123 fi
2124 rm -rf conftest* *~conftest*
2125 ])dnl
2126 dnl ---------------------------------------------------------------------------
2127 dnl CF_GNAT_TRY_RUN version: 5 updated: 2011/03/19 14:47:45
2128 dnl ---------------
2129 dnl Verify that a test program compiles and runs with GNAT
2130 dnl $cf_ada_make is set to the program that compiles/links
2131 dnl $ADAFLAGS may be set to the GNAT flags.
2132 dnl
2133 dnl $1 is the text of the spec
2134 dnl $2 is the text of the body
2135 dnl $3 is the shell command to execute if successful
2136 dnl $4 is the shell command to execute if not successful
2137 AC_DEFUN([CF_GNAT_TRY_RUN],
2138 [
2139 rm -rf conftest* *~conftest*
2140 cat >>conftest.ads <<CF_EOF
2141 $1
2142 CF_EOF
2143 cat >>conftest.adb <<CF_EOF
2144 $2
2145 CF_EOF
2146 if ( $cf_ada_make $ADAFLAGS conftest 1>&AC_FD_CC 2>&1 ) ; then
2147    if ( ./conftest 1>&AC_FD_CC 2>&1 ) ; then
2148 ifelse($3,,      :,[      $3])
2149 ifelse($4,,,[   else
2150       $4])
2151    fi
2152 ifelse($4,,,[else
2153    $4])
2154 fi
2155 rm -rf conftest* *~conftest*
2156 ])dnl
2157 dnl ---------------------------------------------------------------------------
2158 dnl CF_GNAT_VERSION version: 17 updated: 2011/03/23 20:24:41
2159 dnl ---------------
2160 dnl Verify version of GNAT.
2161 AC_DEFUN([CF_GNAT_VERSION],
2162 [
2163 AC_MSG_CHECKING(for gnat version)
2164 cf_gnat_version=`${cf_ada_make:-gnatmake} -v 2>&1 | \
2165         grep '[[0-9]].[[0-9]][[0-9]]*' |\
2166     sed -e '2,$d' -e 's/[[^0-9 \.]]//g' -e 's/^[[ ]]*//' -e 's/ .*//'`
2167 AC_MSG_RESULT($cf_gnat_version)
2168
2169 case $cf_gnat_version in #(vi
2170 3.1[[1-9]]*|3.[[2-9]]*|[[4-9]].*) #(vi
2171         cf_cv_prog_gnat_correct=yes
2172         ;;
2173 *)
2174         AC_MSG_WARN(Unsupported GNAT version $cf_gnat_version. We require 3.11 or better. Disabling Ada95 binding.)
2175         cf_cv_prog_gnat_correct=no
2176         ;;
2177 esac
2178 ])
2179 dnl ---------------------------------------------------------------------------
2180 dnl CF_GNU_SOURCE version: 6 updated: 2005/07/09 13:23:07
2181 dnl -------------
2182 dnl Check if we must define _GNU_SOURCE to get a reasonable value for
2183 dnl _XOPEN_SOURCE, upon which many POSIX definitions depend.  This is a defect
2184 dnl (or misfeature) of glibc2, which breaks portability of many applications,
2185 dnl since it is interwoven with GNU extensions.
2186 dnl
2187 dnl Well, yes we could work around it...
2188 AC_DEFUN([CF_GNU_SOURCE],
2189 [
2190 AC_CACHE_CHECK(if we must define _GNU_SOURCE,cf_cv_gnu_source,[
2191 AC_TRY_COMPILE([#include <sys/types.h>],[
2192 #ifndef _XOPEN_SOURCE
2193 make an error
2194 #endif],
2195         [cf_cv_gnu_source=no],
2196         [cf_save="$CPPFLAGS"
2197          CPPFLAGS="$CPPFLAGS -D_GNU_SOURCE"
2198          AC_TRY_COMPILE([#include <sys/types.h>],[
2199 #ifdef _XOPEN_SOURCE
2200 make an error
2201 #endif],
2202         [cf_cv_gnu_source=no],
2203         [cf_cv_gnu_source=yes])
2204         CPPFLAGS="$cf_save"
2205         ])
2206 ])
2207 test "$cf_cv_gnu_source" = yes && CPPFLAGS="$CPPFLAGS -D_GNU_SOURCE"
2208 ])dnl
2209 dnl ---------------------------------------------------------------------------
2210 dnl CF_GPP_LIBRARY version: 10 updated: 2010/05/29 16:31:02
2211 dnl --------------
2212 dnl If we're trying to use g++, test if libg++ is installed (a rather common
2213 dnl problem :-).  If we have the compiler but no library, we'll be able to
2214 dnl configure, but won't be able to build the c++ demo program.
2215 AC_DEFUN([CF_GPP_LIBRARY],
2216 [
2217 cf_cxx_library=unknown
2218 case $cf_cv_system_name in #(vi
2219 os2*) #(vi
2220         cf_gpp_libname=gpp
2221         ;;
2222 *)
2223         cf_gpp_libname=g++
2224         ;;
2225 esac
2226 if test "$GXX" = yes; then
2227         AC_MSG_CHECKING([for lib$cf_gpp_libname])
2228         cf_save="$LIBS"
2229         CF_ADD_LIB($cf_gpp_libname)
2230         AC_TRY_LINK([
2231 #include <$cf_gpp_libname/builtin.h>
2232         ],
2233         [two_arg_error_handler_t foo2 = lib_error_handler],
2234         [cf_cxx_library=yes
2235          CF_ADD_LIB($cf_gpp_libname,CXXLIBS)
2236          if test "$cf_gpp_libname" = cpp ; then
2237             AC_DEFINE(HAVE_GPP_BUILTIN_H)
2238          else
2239             AC_DEFINE(HAVE_GXX_BUILTIN_H)
2240          fi],
2241         [AC_TRY_LINK([
2242 #include <builtin.h>
2243         ],
2244         [two_arg_error_handler_t foo2 = lib_error_handler],
2245         [cf_cxx_library=yes
2246          CF_ADD_LIB($cf_gpp_libname,CXXLIBS)
2247          AC_DEFINE(HAVE_BUILTIN_H)],
2248         [cf_cxx_library=no])])
2249         LIBS="$cf_save"
2250         AC_MSG_RESULT($cf_cxx_library)
2251 fi
2252 ])dnl
2253 dnl ---------------------------------------------------------------------------
2254 dnl CF_GXX_VERSION version: 6 updated: 2010/10/23 15:44:18
2255 dnl --------------
2256 dnl Check for version of g++
2257 AC_DEFUN([CF_GXX_VERSION],[
2258 AC_REQUIRE([AC_PROG_CPP])
2259 GXX_VERSION=none
2260 if test "$GXX" = yes; then
2261         AC_MSG_CHECKING(version of g++)
2262         GXX_VERSION="`${CXX:-g++} --version| sed -e '2,$d' -e 's/^.*(GCC) //' -e 's/^[[^0-9.]]*//' -e 's/[[^0-9.]].*//'`"
2263         test -z "$GXX_VERSION" && GXX_VERSION=unknown
2264         AC_MSG_RESULT($GXX_VERSION)
2265 fi
2266 ])dnl
2267 dnl ---------------------------------------------------------------------------
2268 dnl CF_GXX_WARNINGS version: 6 updated: 2010/08/14 18:25:37
2269 dnl ---------------
2270 dnl Check if the compiler supports useful warning options.
2271 dnl
2272 dnl Most of gcc's options apply to g++, except:
2273 dnl     -Wbad-function-cast
2274 dnl     -Wmissing-declarations
2275 dnl     -Wnested-externs
2276 dnl
2277 dnl Omit a few (for now):
2278 dnl     -Winline
2279 dnl
2280 dnl Parameter:
2281 dnl     $1 is an optional list of g++ warning flags that a particular
2282 dnl             application might want to use, e.g., "no-unused" for
2283 dnl             -Wno-unused
2284 dnl Special:
2285 dnl     If $with_ext_const is "yes", add a check for -Wwrite-strings
2286 dnl
2287 AC_DEFUN([CF_GXX_WARNINGS],
2288 [
2289
2290 CF_INTEL_COMPILER(GXX,INTEL_CPLUSPLUS,CXXFLAGS)
2291
2292 AC_REQUIRE([CF_GXX_VERSION])
2293
2294 AC_LANG_SAVE
2295 AC_LANG_CPLUSPLUS
2296
2297 cat > conftest.$ac_ext <<EOF
2298 #line __oline__ "configure"
2299 int main(int argc, char *argv[[]]) { return (argv[[argc-1]] == 0) ; }
2300 EOF
2301
2302 if test "$INTEL_CPLUSPLUS" = yes
2303 then
2304 # The "-wdXXX" options suppress warnings:
2305 # remark #1419: external declaration in primary source file
2306 # remark #1682: implicit conversion of a 64-bit integral type to a smaller integral type (potential portability problem)
2307 # remark #1683: explicit conversion of a 64-bit integral type to a smaller integral type (potential portability problem)
2308 # remark #1684: conversion from pointer to same-sized integral type (potential portability problem)
2309 # remark #193: zero used for undefined preprocessing identifier
2310 # remark #593: variable "curs_sb_left_arrow" was set but never used
2311 # remark #810: conversion from "int" to "Dimension={unsigned short}" may lose significant bits
2312 # remark #869: parameter "tw" was never referenced
2313 # remark #981: operands are evaluated in unspecified order
2314 # warning #269: invalid format string conversion
2315
2316         AC_CHECKING([for $CC warning options])
2317         cf_save_CXXFLAGS="$CXXFLAGS"
2318         EXTRA_CXXFLAGS="-Wall"
2319         for cf_opt in \
2320                 wd1419 \
2321                 wd1682 \
2322                 wd1683 \
2323                 wd1684 \
2324                 wd193 \
2325                 wd279 \
2326                 wd593 \
2327                 wd810 \
2328                 wd869 \
2329                 wd981
2330         do
2331                 CXXFLAGS="$cf_save_CXXFLAGS $EXTRA_CXXFLAGS -$cf_opt"
2332                 if AC_TRY_EVAL(ac_compile); then
2333                         test -n "$verbose" && AC_MSG_RESULT(... -$cf_opt)
2334                         EXTRA_CXXFLAGS="$EXTRA_CXXFLAGS -$cf_opt"
2335                 fi
2336         done
2337         CXXFLAGS="$cf_save_CXXFLAGS"
2338
2339 elif test "$GXX" = yes
2340 then
2341         AC_CHECKING([for $CXX warning options])
2342         cf_save_CXXFLAGS="$CXXFLAGS"
2343         EXTRA_CXXFLAGS="-W -Wall"
2344         cf_gxx_extra_warnings=""
2345         test "$with_ext_const" = yes && cf_gxx_extra_warnings="Wwrite-strings"
2346         case "$GCC_VERSION" in
2347         [[1-2]].*)
2348                 ;;
2349         *)
2350                 cf_gxx_extra_warnings="$cf_gxx_extra_warnings Weffc++"
2351                 ;;
2352         esac
2353         for cf_opt in \
2354                 Wabi \
2355                 fabi-version=0 \
2356                 Woverloaded-virtual \
2357                 Wsign-promo \
2358                 Wsynth \
2359                 Wold-style-cast \
2360                 Wcast-align \
2361                 Wcast-qual \
2362                 Wmissing-prototypes \
2363                 Wpointer-arith \
2364                 Wshadow \
2365                 Wstrict-prototypes \
2366                 Wundef $cf_gxx_extra_warnings $1
2367         do
2368                 CXXFLAGS="$cf_save_CXXFLAGS $EXTRA_CXXFLAGS -Werror -$cf_opt"
2369                 if AC_TRY_EVAL(ac_compile); then
2370                         test -n "$verbose" && AC_MSG_RESULT(... -$cf_opt)
2371                         EXTRA_CXXFLAGS="$EXTRA_CXXFLAGS -$cf_opt"
2372                 else
2373                         test -n "$verbose" && AC_MSG_RESULT(... no -$cf_opt)
2374                 fi
2375         done
2376         CXXFLAGS="$cf_save_CXXFLAGS"
2377 fi
2378
2379 rm -rf conftest*
2380 AC_LANG_RESTORE
2381 AC_SUBST(EXTRA_CXXFLAGS)
2382 ])dnl
2383 dnl ---------------------------------------------------------------------------
2384 dnl CF_HASHED_DB version: 4 updated: 2010/05/29 16:31:02
2385 dnl ------------
2386 dnl Look for an instance of the Berkeley hashed database.
2387 dnl
2388 dnl $1 = optional parameter, to specify install-prefix for the database.
2389 AC_DEFUN([CF_HASHED_DB],
2390 [
2391 ifelse([$1],,,[
2392 case $1 in #(vi
2393 yes|*able*) #(vi
2394     ;;
2395 *)
2396     if test -d "$1" ; then
2397         CF_ADD_INCDIR($1/include)
2398         CF_ADD_LIBDIR($1/lib)
2399     fi
2400 esac
2401 ])
2402 AC_CHECK_HEADER(db.h,[
2403 CF_HASHED_DB_VERSION
2404 if test "$cf_cv_hashed_db_version" = unknown ; then
2405         AC_MSG_ERROR(Cannot determine version of db)
2406 else
2407         CF_HASHED_DB_LIBS
2408         if test "$cf_cv_hashed_db_libs" = unknown ; then
2409                 AC_MSG_ERROR(Cannot determine library for db)
2410         elif test "$cf_cv_hashed_db_libs" != default ; then
2411                 CF_ADD_LIB($cf_cv_hashed_db_libs)
2412         fi
2413 fi
2414 ],[
2415         AC_MSG_ERROR(Cannot find db.h)
2416 ])
2417 ])dnl
2418 dnl ---------------------------------------------------------------------------
2419 dnl CF_HASHED_DB_LIBS version: 9 updated: 2010/05/29 16:31:02
2420 dnl -----------------
2421 dnl Given that we have the header and version for hashed database, find the
2422 dnl library information.
2423 AC_DEFUN([CF_HASHED_DB_LIBS],
2424 [
2425 AC_CACHE_CHECK(for db libraries, cf_cv_hashed_db_libs,[
2426 cf_cv_hashed_db_libs=unknown
2427 for cf_db_libs in "" db$cf_cv_hashed_db_version db-$cf_cv_hashed_db_version db ''
2428 do
2429         cf_save_libs="$LIBS"
2430         if test -n "$cf_db_libs"; then
2431                 CF_ADD_LIB($cf_db_libs)
2432         fi
2433         CF_MSG_LOG(checking for library "$cf_db_libs")
2434         AC_TRY_LINK([
2435 $ac_includes_default
2436 #include <db.h>
2437 ],[
2438         char *path = "/tmp/foo";
2439 #ifdef DB_VERSION_MAJOR
2440 #if DB_VERSION_MAJOR >= 4
2441         DB *result = 0;
2442         db_create(&result, NULL, 0);
2443         result->open(result,
2444                 NULL,
2445                 path,
2446                 path,
2447                 DB_HASH,
2448                 DB_CREATE,
2449                 0644);
2450 #elif DB_VERSION_MAJOR >= 3
2451         DB *result = 0;
2452         db_create(&result, NULL, 0);
2453         result->open(result,
2454                 path,
2455                 path,
2456                 DB_HASH,
2457                 DB_CREATE,
2458                 0644);
2459 #elif DB_VERSION_MAJOR >= 2
2460         DB *result = 0;
2461         db_open(path,
2462                 DB_HASH,
2463                 DB_CREATE,
2464                 0644,
2465                 (DB_ENV *) 0,
2466                 (DB_INFO *) 0,
2467                 &result);
2468 #endif /* DB_VERSION_MAJOR */
2469 #else
2470         DB *result = dbopen(path,
2471                      2,
2472                      0644,
2473                      DB_HASH,
2474                      0);
2475 #endif
2476         ${cf_cv_main_return:-return}(result != 0)
2477 ],[
2478         if test -n "$cf_db_libs" ; then
2479                 cf_cv_hashed_db_libs=$cf_db_libs
2480         else
2481                 cf_cv_hashed_db_libs=default
2482         fi
2483         LIBS="$cf_save_libs"
2484         break
2485 ])
2486         LIBS="$cf_save_libs"
2487 done
2488 ])
2489 ])dnl
2490 dnl ---------------------------------------------------------------------------
2491 dnl CF_HASHED_DB_VERSION version: 3 updated: 2007/12/01 15:01:37
2492 dnl --------------------
2493 dnl Given that we have the header file for hashed database, find the version
2494 dnl information.
2495 AC_DEFUN([CF_HASHED_DB_VERSION],
2496 [
2497 AC_CACHE_CHECK(for version of db, cf_cv_hashed_db_version,[
2498 cf_cv_hashed_db_version=unknown
2499
2500 for cf_db_version in 1 2 3 4 5
2501 do
2502         CF_MSG_LOG(checking for db version $cf_db_version)
2503         AC_TRY_COMPILE([
2504 $ac_includes_default
2505 #include <db.h>
2506
2507 #ifdef DB_VERSION_MAJOR
2508         /* db2 (DB_VERSION_MAJOR=2) has also DB_VERSION_MINOR, tested with 7 */
2509 #if $cf_db_version == DB_VERSION_MAJOR
2510         /* ok */
2511 #else
2512         make an error
2513 #endif
2514 #else
2515 #if $cf_db_version == 1
2516         /* ok: assuming this is DB 1.8.5 */
2517 #else
2518         make an error
2519 #endif
2520 #endif
2521 ],[DBT *foo = 0],[
2522         cf_cv_hashed_db_version=$cf_db_version
2523         break
2524         ])
2525 done
2526 ])
2527 ])dnl
2528 dnl ---------------------------------------------------------------------------
2529 dnl CF_HEADER_PATH version: 12 updated: 2010/05/05 05:22:40
2530 dnl --------------
2531 dnl Construct a search-list of directories for a nonstandard header-file
2532 dnl
2533 dnl Parameters
2534 dnl     $1 = the variable to return as result
2535 dnl     $2 = the package name
2536 AC_DEFUN([CF_HEADER_PATH],
2537 [
2538 $1=
2539
2540 # collect the current set of include-directories from compiler flags
2541 cf_header_path_list=""
2542 if test -n "${CFLAGS}${CPPFLAGS}" ; then
2543         for cf_header_path in $CPPFLAGS $CFLAGS
2544         do
2545                 case $cf_header_path in #(vi
2546                 -I*)
2547                         cf_header_path=`echo ".$cf_header_path" |sed -e 's/^...//' -e 's,/include$,,'`
2548                         CF_ADD_SUBDIR_PATH($1,$2,include,$cf_header_path,NONE)
2549                         cf_header_path_list="$cf_header_path_list [$]$1"
2550                         ;;
2551                 esac
2552         done
2553 fi
2554
2555 # add the variations for the package we are looking for
2556 CF_SUBDIR_PATH($1,$2,include)
2557
2558 test "$includedir" != NONE && \
2559 test "$includedir" != "/usr/include" && \
2560 test -d "$includedir" && {
2561         test -d $includedir &&    $1="[$]$1 $includedir"
2562         test -d $includedir/$2 && $1="[$]$1 $includedir/$2"
2563 }
2564
2565 test "$oldincludedir" != NONE && \
2566 test "$oldincludedir" != "/usr/include" && \
2567 test -d "$oldincludedir" && {
2568         test -d $oldincludedir    && $1="[$]$1 $oldincludedir"
2569         test -d $oldincludedir/$2 && $1="[$]$1 $oldincludedir/$2"
2570 }
2571
2572 $1="[$]$1 $cf_header_path_list"
2573 ])dnl
2574 dnl ---------------------------------------------------------------------------
2575 dnl CF_HELP_MESSAGE version: 3 updated: 1998/01/14 10:56:23
2576 dnl ---------------
2577 dnl Insert text into the help-message, for readability, from AC_ARG_WITH.
2578 AC_DEFUN([CF_HELP_MESSAGE],
2579 [AC_DIVERT_HELP([$1])dnl
2580 ])dnl
2581 dnl ---------------------------------------------------------------------------
2582 dnl CF_INCLUDE_DIRS version: 6 updated: 2009/01/06 19:37:40
2583 dnl ---------------
2584 dnl Construct the list of include-options according to whether we're building
2585 dnl in the source directory or using '--srcdir=DIR' option.  If we're building
2586 dnl with gcc, don't append the includedir if it happens to be /usr/include,
2587 dnl since that usually breaks gcc's shadow-includes.
2588 AC_DEFUN([CF_INCLUDE_DIRS],
2589 [
2590 CPPFLAGS="$CPPFLAGS -I. -I../include"
2591 if test "$srcdir" != "."; then
2592         CPPFLAGS="$CPPFLAGS -I\${srcdir}/../include"
2593 fi
2594 if test "$GCC" != yes; then
2595         CPPFLAGS="$CPPFLAGS -I\${includedir}"
2596 elif test "$includedir" != "/usr/include"; then
2597         if test "$includedir" = '${prefix}/include' ; then
2598                 if test $prefix != /usr ; then
2599                         CPPFLAGS="$CPPFLAGS -I\${includedir}"
2600                 fi
2601         else
2602                 CPPFLAGS="$CPPFLAGS -I\${includedir}"
2603         fi
2604 fi
2605 AC_SUBST(CPPFLAGS)
2606 ])dnl
2607 dnl ---------------------------------------------------------------------------
2608 dnl CF_INTEL_COMPILER version: 4 updated: 2010/05/26 05:38:42
2609 dnl -----------------
2610 dnl Check if the given compiler is really the Intel compiler for Linux.  It
2611 dnl tries to imitate gcc, but does not return an error when it finds a mismatch
2612 dnl between prototypes, e.g., as exercised by CF_MISSING_CHECK.
2613 dnl
2614 dnl This macro should be run "soon" after AC_PROG_CC or AC_PROG_CPLUSPLUS, to
2615 dnl ensure that it is not mistaken for gcc/g++.  It is normally invoked from
2616 dnl the wrappers for gcc and g++ warnings.
2617 dnl
2618 dnl $1 = GCC (default) or GXX
2619 dnl $2 = INTEL_COMPILER (default) or INTEL_CPLUSPLUS
2620 dnl $3 = CFLAGS (default) or CXXFLAGS
2621 AC_DEFUN([CF_INTEL_COMPILER],[
2622 ifelse([$2],,INTEL_COMPILER,[$2])=no
2623
2624 if test "$ifelse([$1],,[$1],GCC)" = yes ; then
2625         case $host_os in
2626         linux*|gnu*)
2627                 AC_MSG_CHECKING(if this is really Intel ifelse([$1],GXX,C++,C) compiler)
2628                 cf_save_CFLAGS="$ifelse([$3],,CFLAGS,[$3])"
2629                 ifelse([$3],,CFLAGS,[$3])="$ifelse([$3],,CFLAGS,[$3]) -no-gcc"
2630                 AC_TRY_COMPILE([],[
2631 #ifdef __INTEL_COMPILER
2632 #else
2633 make an error
2634 #endif
2635 ],[ifelse([$2],,INTEL_COMPILER,[$2])=yes
2636 cf_save_CFLAGS="$cf_save_CFLAGS -we147 -no-gcc"
2637 ],[])
2638                 ifelse([$3],,CFLAGS,[$3])="$cf_save_CFLAGS"
2639                 AC_MSG_RESULT($ifelse([$2],,INTEL_COMPILER,[$2]))
2640                 ;;
2641         esac
2642 fi
2643 ])dnl
2644 dnl ---------------------------------------------------------------------------
2645 dnl CF_ISASCII version: 3 updated: 2000/08/12 23:18:52
2646 dnl ----------
2647 dnl Check if we have either a function or macro for 'isascii()'.
2648 AC_DEFUN([CF_ISASCII],
2649 [
2650 AC_MSG_CHECKING(for isascii)
2651 AC_CACHE_VAL(cf_cv_have_isascii,[
2652         AC_TRY_LINK([#include <ctype.h>],[int x = isascii(' ')],
2653         [cf_cv_have_isascii=yes],
2654         [cf_cv_have_isascii=no])
2655 ])dnl
2656 AC_MSG_RESULT($cf_cv_have_isascii)
2657 test "$cf_cv_have_isascii" = yes && AC_DEFINE(HAVE_ISASCII)
2658 ])dnl
2659 dnl ---------------------------------------------------------------------------
2660 dnl CF_LARGEFILE version: 7 updated: 2007/06/02 11:58:50
2661 dnl ------------
2662 dnl Add checks for large file support.
2663 AC_DEFUN([CF_LARGEFILE],[
2664 ifdef([AC_FUNC_FSEEKO],[
2665     AC_SYS_LARGEFILE
2666     if test "$enable_largefile" != no ; then
2667         AC_FUNC_FSEEKO
2668
2669         # Normally we would collect these definitions in the config.h,
2670         # but (like _XOPEN_SOURCE), some environments rely on having these
2671         # defined before any of the system headers are included.  Another
2672         # case comes up with C++, e.g., on AIX the compiler compiles the
2673         # header files by themselves before looking at the body files it is
2674         # told to compile.  For ncurses, those header files do not include
2675         # the config.h
2676         test "$ac_cv_sys_large_files"      != no && CPPFLAGS="$CPPFLAGS -D_LARGE_FILES "
2677         test "$ac_cv_sys_largefile_source" != no && CPPFLAGS="$CPPFLAGS -D_LARGEFILE_SOURCE "
2678         test "$ac_cv_sys_file_offset_bits" != no && CPPFLAGS="$CPPFLAGS -D_FILE_OFFSET_BITS=$ac_cv_sys_file_offset_bits "
2679
2680         AC_CACHE_CHECK(whether to use struct dirent64, cf_cv_struct_dirent64,[
2681                 AC_TRY_COMPILE([
2682 #include <sys/types.h>
2683 #include <dirent.h>
2684                 ],[
2685                 /* if transitional largefile support is setup, this is true */
2686                 extern struct dirent64 * readdir(DIR *);
2687                 struct dirent64 *x = readdir((DIR *)0);
2688                 struct dirent *y = readdir((DIR *)0);
2689                 int z = x - y;
2690                 ],
2691                 [cf_cv_struct_dirent64=yes],
2692                 [cf_cv_struct_dirent64=no])
2693         ])
2694         test "$cf_cv_struct_dirent64" = yes && AC_DEFINE(HAVE_STRUCT_DIRENT64)
2695     fi
2696 ])
2697 ])
2698 dnl ---------------------------------------------------------------------------
2699 dnl CF_LDFLAGS_STATIC version: 10 updated: 2011/09/24 12:51:48
2700 dnl -----------------
2701 dnl Check for compiler/linker flags used to temporarily force usage of static
2702 dnl libraries.  This depends on the compiler and platform.  Use this to help
2703 dnl ensure that the linker picks up a given library based on its position in
2704 dnl the list of linker options and libraries.
2705 AC_DEFUN([CF_LDFLAGS_STATIC],[
2706
2707 if test "$GCC" = yes ; then
2708         case $cf_cv_system_name in #(
2709         OS/2*|os2*|aix[[4]]*|solaris2.1[[0-9]]|darwin*)         #( vi
2710                 LDFLAGS_STATIC=
2711                 LDFLAGS_SHARED=
2712                 ;;
2713     *)  #( normally, except when broken
2714         LDFLAGS_STATIC=-static
2715         LDFLAGS_SHARED=-dynamic
2716         ;;
2717     esac
2718 else
2719         case $cf_cv_system_name in #(
2720         aix[[4-7]]*)    #( from ld manpage
2721                 LDFLAGS_STATIC=-bstatic
2722                 LDFLAGS_SHARED=-bdynamic
2723                 ;;
2724         hpux*)          #( from ld manpage for hpux10.20, hpux11.11
2725                 # We could also use just "archive" and "shared".
2726                 LDFLAGS_STATIC=-Wl,-a,archive_shared
2727                 LDFLAGS_SHARED=-Wl,-a,shared_archive
2728                 ;;
2729         irix*)          #( from ld manpage IRIX64
2730                 LDFLAGS_STATIC=-Bstatic
2731                 LDFLAGS_SHARED=-Bdynamic
2732                 ;;
2733         osf[[45]]*)     #( from ld manpage osf4.0d, osf5.1
2734                 # alternative "-oldstyle_liblookup" (not in cc manpage)
2735                 LDFLAGS_STATIC=-noso
2736                 LDFLAGS_SHARED=-so_archive
2737                 ;;
2738         solaris2*)
2739                 LDFLAGS_STATIC=-Bstatic
2740                 LDFLAGS_SHARED=-Bdynamic
2741                 ;;
2742         esac
2743 fi
2744
2745 if test -n "$LDFLAGS_STATIC" && test -n "$LDFLAGS_SHARED"
2746 then
2747         AC_MSG_CHECKING(if linker supports switching between static/dynamic)
2748
2749         rm -f libconftest.a
2750         cat >conftest.$ac_ext <<EOF
2751 #line __oline__ "configure"
2752 #include <stdio.h>
2753 int cf_ldflags_static(FILE *fp) { return fflush(fp); }
2754 EOF
2755         if AC_TRY_EVAL(ac_compile) ; then
2756                 ( $AR $ARFLAGS libconftest.a conftest.o ) 2>&AC_FD_CC 1>/dev/null
2757                 ( eval $RANLIB libconftest.a ) 2>&AC_FD_CC >/dev/null
2758         fi
2759         rm -f conftest.*
2760
2761         cf_save_LIBS="$LIBS"
2762
2763         LIBS="$LDFLAGS_STATIC -L`pwd` -lconftest $LDFLAGS_DYNAMIC $LIBS"
2764         AC_TRY_LINK([
2765 #line __oline__ "configure"
2766 #include <stdio.h>
2767 int cf_ldflags_static(FILE *fp);
2768 ],[
2769         return cf_ldflags_static(stdin);
2770 ],[
2771         # some linkers simply ignore the -dynamic
2772         case x`file conftest$ac_exeext 2>/dev/null` in #(vi
2773         *static*) # (vi
2774                 cf_ldflags_static=no
2775                 ;;
2776         *)
2777                 cf_ldflags_static=yes
2778                 ;;
2779         esac
2780 ],[cf_ldflags_static=no])
2781
2782         rm -f libconftest.*
2783         LIBS="$cf_save_LIBS"
2784
2785         AC_MSG_RESULT($cf_ldflags_static)
2786
2787         if test $cf_ldflags_static != yes
2788         then
2789                 LDFLAGS_STATIC=
2790                 LDFLAGS_SHARED=
2791         fi
2792 else
2793         LDFLAGS_STATIC=
2794         LDFLAGS_SHARED=
2795 fi
2796
2797 AC_SUBST(LDFLAGS_STATIC)
2798 AC_SUBST(LDFLAGS_SHARED)
2799 ])
2800 dnl ---------------------------------------------------------------------------
2801 dnl CF_LD_RPATH_OPT version: 5 updated: 2011/07/17 14:48:41
2802 dnl ---------------
2803 dnl For the given system and compiler, find the compiler flags to pass to the
2804 dnl loader to use the "rpath" feature.
2805 AC_DEFUN([CF_LD_RPATH_OPT],
2806 [
2807 AC_REQUIRE([CF_CHECK_CACHE])
2808
2809 LD_RPATH_OPT=
2810 AC_MSG_CHECKING(for an rpath option)
2811 case $cf_cv_system_name in #(vi
2812 irix*) #(vi
2813         if test "$GCC" = yes; then
2814                 LD_RPATH_OPT="-Wl,-rpath,"
2815         else
2816                 LD_RPATH_OPT="-rpath "
2817         fi
2818         ;;
2819 linux*|gnu*|k*bsd*-gnu) #(vi
2820         LD_RPATH_OPT="-Wl,-rpath,"
2821         ;;
2822 openbsd[[2-9]].*|mirbsd*) #(vi
2823         LD_RPATH_OPT="-Wl,-rpath,"
2824         ;;
2825 dragonfly*|freebsd*) #(vi
2826         LD_RPATH_OPT="-rpath "
2827         ;;
2828 netbsd*) #(vi
2829         LD_RPATH_OPT="-Wl,-rpath,"
2830         ;;
2831 osf*|mls+*) #(vi
2832         LD_RPATH_OPT="-rpath "
2833         ;;
2834 solaris2*) #(vi
2835         LD_RPATH_OPT="-R"
2836         ;;
2837 *)
2838         ;;
2839 esac
2840 AC_MSG_RESULT($LD_RPATH_OPT)
2841
2842 case "x$LD_RPATH_OPT" in #(vi
2843 x-R*)
2844         AC_MSG_CHECKING(if we need a space after rpath option)
2845         cf_save_LIBS="$LIBS"
2846         CF_ADD_LIBS(${LD_RPATH_OPT}$libdir)
2847         AC_TRY_LINK(, , cf_rpath_space=no, cf_rpath_space=yes)
2848         LIBS="$cf_save_LIBS"
2849         AC_MSG_RESULT($cf_rpath_space)
2850         test "$cf_rpath_space" = yes && LD_RPATH_OPT="$LD_RPATH_OPT "
2851         ;;
2852 esac
2853 ])dnl
2854 dnl ---------------------------------------------------------------------------
2855 dnl CF_LIBRARY_PATH version: 9 updated: 2010/03/28 12:52:50
2856 dnl ---------------
2857 dnl Construct a search-list of directories for a nonstandard library-file
2858 dnl
2859 dnl Parameters
2860 dnl     $1 = the variable to return as result
2861 dnl     $2 = the package name
2862 AC_DEFUN([CF_LIBRARY_PATH],
2863 [
2864 $1=
2865 cf_library_path_list=""
2866 if test -n "${LDFLAGS}${LIBS}" ; then
2867         for cf_library_path in $LDFLAGS $LIBS
2868         do
2869                 case $cf_library_path in #(vi
2870                 -L*)
2871                         cf_library_path=`echo ".$cf_library_path" |sed -e 's/^...//' -e 's,/lib$,,'`
2872                         CF_ADD_SUBDIR_PATH($1,$2,lib,$cf_library_path,NONE)
2873                         cf_library_path_list="$cf_library_path_list [$]$1"
2874                         ;;
2875                 esac
2876         done
2877 fi
2878
2879 CF_SUBDIR_PATH($1,$2,lib)
2880
2881 $1="$cf_library_path_list [$]$1"
2882 ])dnl
2883 dnl ---------------------------------------------------------------------------
2884 dnl CF_LIB_PREFIX version: 8 updated: 2008/09/13 11:34:16
2885 dnl -------------
2886 dnl Compute the library-prefix for the given host system
2887 dnl $1 = variable to set
2888 AC_DEFUN([CF_LIB_PREFIX],
2889 [
2890         case $cf_cv_system_name in #(vi
2891         OS/2*|os2*) #(vi
2892         LIB_PREFIX=''
2893         ;;
2894         *)      LIB_PREFIX='lib'
2895         ;;
2896         esac
2897 ifelse($1,,,[$1=$LIB_PREFIX])
2898         AC_SUBST(LIB_PREFIX)
2899 ])dnl
2900 dnl ---------------------------------------------------------------------------
2901 dnl CF_LIB_RULES version: 61 updated: 2010/10/23 16:10:30
2902 dnl ------------
2903 dnl Append definitions and rules for the given models to the subdirectory
2904 dnl Makefiles, and the recursion rule for the top-level Makefile.  If the
2905 dnl subdirectory is a library-source directory, modify the LIBS_TO_MAKE list in
2906 dnl the corresponding makefile to list the models that we'll generate.
2907 dnl
2908 dnl For shared libraries, make a list of symbolic links to construct when
2909 dnl generating each library.  The convention used for Linux is the simplest
2910 dnl one:
2911 dnl     lib<name>.so    ->
2912 dnl     lib<name>.so.<major>    ->
2913 dnl     lib<name>.so.<maj>.<minor>
2914 AC_DEFUN([CF_LIB_RULES],
2915 [
2916 CF_LIB_PREFIX(cf_prefix)
2917 AC_REQUIRE([CF_SUBST_NCURSES_VERSION])
2918
2919 if test $cf_cv_shlib_version = cygdll ; then
2920         TINFO_NAME=$TINFO_ARG_SUFFIX
2921         TINFO_SUFFIX=.dll
2922 fi
2923
2924 if test -n "$TINFO_SUFFIX" ; then
2925         case $TINFO_SUFFIX in
2926         tw*)
2927                 TINFO_NAME="${TINFO_NAME}tw"
2928                 TINFO_SUFFIX=`echo $TINFO_SUFFIX | sed 's/^tw//'`
2929                 ;;
2930         t*)
2931                 TINFO_NAME="${TINFO_NAME}t"
2932                 TINFO_SUFFIX=`echo $TINFO_SUFFIX | sed 's/^t//'`
2933                 ;;
2934         w*)
2935                 TINFO_NAME="${TINFO_NAME}w"
2936                 TINFO_SUFFIX=`echo $TINFO_SUFFIX | sed 's/^w//'`
2937                 ;;
2938         esac
2939 fi
2940
2941 for cf_dir in $SRC_SUBDIRS
2942 do
2943         if test ! -d $srcdir/$cf_dir ; then
2944                 continue
2945         elif test -f $srcdir/$cf_dir/modules; then
2946
2947                 SHARED_LIB=
2948                 LIBS_TO_MAKE=
2949                 for cf_item in $cf_LIST_MODELS
2950                 do
2951                         CF_LIB_SUFFIX($cf_item,cf_suffix,cf_depsuf)
2952                         if test $cf_item = shared ; then
2953                         if test "$cf_cv_do_symlinks" = yes ; then
2954                                 case "$cf_cv_shlib_version" in #(vi
2955                                 rel) #(vi
2956                                         case "$cf_cv_system_name" in #(vi
2957                                         darwin*)
2958                                         case .${LIB_SUFFIX} in
2959                                         .tw*)
2960                                                 cf_suffix=`echo $cf_suffix | sed 's/^tw//'`
2961                                                 cf_suffix=tw'.${REL_VERSION}'"$cf_suffix"
2962                                                 ;;
2963                                         .t*)
2964                                                 cf_suffix=`echo $cf_suffix | sed 's/^t//'`
2965                                                 cf_suffix=t'.${REL_VERSION}'"$cf_suffix"
2966                                                 ;;
2967                                         .w*)
2968                                                 cf_suffix=`echo $cf_suffix | sed 's/^w//'`
2969                                                 cf_suffix=w'.${REL_VERSION}'"$cf_suffix"
2970                                                 ;;
2971                                         *)
2972                                                 cf_suffix='.${REL_VERSION}'"$cf_suffix"
2973                                                 ;;
2974                                         esac
2975                                         ;; #(vi
2976                                         *) cf_suffix="$cf_suffix"'.${REL_VERSION}' ;;
2977                                         esac
2978                                         ;;
2979                                 abi)
2980                                         case "$cf_cv_system_name" in #(vi
2981                                         darwin*)
2982                                         case .${LIB_SUFFIX} in
2983                                         .tw*)
2984                                                 cf_suffix=`echo $cf_suffix | sed 's/^tw//'`
2985                                                 cf_suffix=tw'.${ABI_VERSION}'"$cf_suffix"
2986                                                 ;;
2987                                         .t*)
2988                                                 cf_suffix=`echo $cf_suffix | sed 's/^t//'`
2989                                                 cf_suffix=t'.${ABI_VERSION}'"$cf_suffix"
2990                                                 ;;
2991                                         .w*)
2992                                                 cf_suffix=`echo $cf_suffix | sed 's/^w//'`
2993                                                 cf_suffix=w'.${ABI_VERSION}'"$cf_suffix"
2994                                                 ;;
2995                                         *)
2996                                                 cf_suffix='.${ABI_VERSION}'"$cf_suffix"
2997                                                 ;;
2998                                         esac
2999                                         ;; #(vi
3000                                         *) cf_suffix="$cf_suffix"'.${ABI_VERSION}' ;;
3001                                         esac
3002                                         ;;
3003                                 esac
3004                         fi
3005                         # cygwin needs import library, and has unique naming convention
3006                         # use autodetected ${cf_prefix} for import lib and static lib, but
3007                         # use 'cyg' prefix for shared lib.
3008                         if test $cf_cv_shlib_version = cygdll ; then
3009                                 cf_cygsuf=`echo "$cf_suffix" | sed -e 's/\.dll/\${ABI_VERSION}.dll/'`
3010                                 LIBS_TO_MAKE="$LIBS_TO_MAKE ../lib/cyg${cf_dir}${cf_cygsuf}"
3011                                 continue
3012                         fi
3013                         fi
3014                         LIBS_TO_MAKE="$LIBS_TO_MAKE ../lib/${cf_prefix}${cf_dir}${cf_suffix}"
3015                 done
3016
3017                 if test $cf_dir = ncurses ; then
3018                         cf_subsets="$LIB_SUBSETS"
3019                         cf_r_parts="$cf_subsets"
3020                         cf_liblist="$LIBS_TO_MAKE"
3021
3022                         while test -n "$cf_r_parts"
3023                         do
3024                                 cf_l_parts=`echo "$cf_r_parts" |sed -e 's/ .*$//'`
3025                                 cf_r_parts=`echo "$cf_r_parts" |sed -e 's/^[[^ ]]* //'`
3026                                 if test "$cf_l_parts" != "$cf_r_parts" ; then
3027                                         cf_item=
3028                                         case $cf_l_parts in #(vi
3029                                         *termlib*) #(vi
3030                                                 cf_item=`echo $cf_liblist |sed -e s%${LIB_NAME}${LIB_SUFFIX}%${TINFO_LIB_SUFFIX}%g`
3031                                                 ;;
3032                                         *ticlib*)
3033                                                 cf_item=`echo $cf_liblist |sed -e s%${LIB_NAME}${LIB_SUFFIX}%${TICS_LIB_SUFFIX}%g`
3034                                                 ;;
3035                                         *)
3036                                                 break
3037                                                 ;;
3038                                         esac
3039                                         if test -n "$cf_item"; then
3040                                                 LIBS_TO_MAKE="$cf_item $LIBS_TO_MAKE"
3041                                         fi
3042                                 else
3043                                         break
3044                                 fi
3045                         done
3046                 else
3047                         cf_subsets=`echo "$LIB_SUBSETS" | sed -e 's/^termlib.* //'`
3048                 fi
3049
3050                 sed -e "s%@LIBS_TO_MAKE@%$LIBS_TO_MAKE%" \
3051                     -e "s%@SHARED_LIB@%$SHARED_LIB%" \
3052                         $cf_dir/Makefile >$cf_dir/Makefile.out
3053                 mv $cf_dir/Makefile.out $cf_dir/Makefile
3054
3055                 $AWK -f $srcdir/mk-0th.awk \
3056                         libname="${cf_dir}${LIB_SUFFIX}" subsets="$LIB_SUBSETS" \
3057                         $srcdir/$cf_dir/modules >>$cf_dir/Makefile
3058
3059                 for cf_subset in $cf_subsets
3060                 do
3061                         cf_subdirs=
3062                         for cf_item in $cf_LIST_MODELS
3063                         do
3064                         echo "Appending rules for ${cf_item} model (${cf_dir}: ${cf_subset})"
3065                         CF_UPPER(cf_ITEM,$cf_item)
3066                         CF_LIB_SUFFIX($cf_item,cf_suffix,cf_depsuf)
3067                         CF_OBJ_SUBDIR($cf_item,cf_subdir)
3068
3069                         # Test for case where we build libtinfo with a different name.
3070                         cf_libname=$cf_dir
3071                         if test $cf_dir = ncurses ; then
3072                                 case $cf_subset in
3073                                 *base*)
3074                                         cf_libname=${cf_libname}$LIB_SUFFIX
3075                                         ;;
3076                                 *termlib*)
3077                                         cf_libname=$TINFO_LIB_SUFFIX
3078                                         ;;
3079                                 ticlib*)
3080                                         cf_libname=$TICS_LIB_SUFFIX
3081                                         ;;
3082                                 esac
3083                         else
3084                                 cf_libname=${cf_libname}$LIB_SUFFIX
3085                         fi
3086                         if test -n "${DFT_ARG_SUFFIX}" ; then
3087                                 # undo $LIB_SUFFIX add-on in CF_LIB_SUFFIX
3088                                 cf_suffix=`echo $cf_suffix |sed -e "s%^${LIB_SUFFIX}%%"`
3089                         fi
3090
3091                         # These dependencies really are for development, not
3092                         # builds, but they are useful in porting, too.
3093                         cf_depend="../include/ncurses_cfg.h"
3094                         if test "$srcdir" = "."; then
3095                                 cf_reldir="."
3096                         else
3097                                 cf_reldir="\${srcdir}"
3098                         fi
3099
3100                         if test -f $srcdir/$cf_dir/$cf_dir.priv.h; then
3101                                 cf_depend="$cf_depend $cf_reldir/$cf_dir.priv.h"
3102                         elif test -f $srcdir/$cf_dir/curses.priv.h; then
3103                                 cf_depend="$cf_depend $cf_reldir/curses.priv.h"
3104                         fi
3105
3106                         cf_dir_suffix=
3107                         old_cf_suffix="$cf_suffix"
3108                         if test "$cf_cv_shlib_version_infix" = yes ; then
3109                         if test -n "$LIB_SUFFIX" ; then
3110                                 case $LIB_SUFFIX in
3111                                 tw*)
3112                                         cf_libname=`echo $cf_libname | sed 's/tw$//'`
3113                                         cf_suffix=`echo $cf_suffix | sed 's/^tw//'`
3114                                         cf_dir_suffix=tw
3115                                         ;;
3116                                 t*)
3117                                         cf_libname=`echo $cf_libname | sed 's/t$//'`
3118                                         cf_suffix=`echo $cf_suffix | sed 's/^t//'`
3119                                         cf_dir_suffix=t
3120                                         ;;
3121                                 w*)
3122                                         cf_libname=`echo $cf_libname | sed 's/w$//'`
3123                                         cf_suffix=`echo $cf_suffix | sed 's/^w//'`
3124                                         cf_dir_suffix=w
3125                                         ;;
3126                                 esac
3127                         fi
3128                         fi
3129
3130                         $AWK -f $srcdir/mk-1st.awk \
3131                                 name=${cf_libname}${cf_dir_suffix} \
3132                                 traces=$LIB_TRACING \
3133                                 MODEL=$cf_ITEM \
3134                                 model=$cf_subdir \
3135                                 prefix=$cf_prefix \
3136                                 suffix=$cf_suffix \
3137                                 subset=$cf_subset \
3138                                 SymLink="$LN_S" \
3139                                 TermlibRoot=$TINFO_NAME \
3140                                 TermlibSuffix=$TINFO_SUFFIX \
3141                                 ShlibVer=$cf_cv_shlib_version \
3142                                 ShlibVerInfix=$cf_cv_shlib_version_infix \
3143                                 ReLink=${cf_cv_do_relink:-no} \
3144                                 DoLinks=$cf_cv_do_symlinks \
3145                                 rmSoLocs=$cf_cv_rm_so_locs \
3146                                 ldconfig="$LDCONFIG" \
3147                                 overwrite=$WITH_OVERWRITE \
3148                                 depend="$cf_depend" \
3149                                 host="$host" \
3150                                 libtool_version="$LIBTOOL_VERSION" \
3151                                 $srcdir/$cf_dir/modules >>$cf_dir/Makefile
3152
3153                         cf_suffix="$old_cf_suffix"
3154
3155                         for cf_subdir2 in $cf_subdirs lib
3156                         do
3157                                 test $cf_subdir = $cf_subdir2 && break
3158                         done
3159                         test "${cf_subset}.${cf_subdir2}" != "${cf_subset}.${cf_subdir}" && \
3160                         $AWK -f $srcdir/mk-2nd.awk \
3161                                 name=$cf_dir \
3162                                 traces=$LIB_TRACING \
3163                                 MODEL=$cf_ITEM \
3164                                 model=$cf_subdir \
3165                                 subset=$cf_subset \
3166                                 srcdir=$srcdir \
3167                                 echo=$WITH_ECHO \
3168                                 crenames=$cf_cv_prog_CC_c_o \
3169                                 cxxrenames=$cf_cv_prog_CXX_c_o \
3170                                 $srcdir/$cf_dir/modules >>$cf_dir/Makefile
3171                         cf_subdirs="$cf_subdirs $cf_subdir"
3172                         done
3173                 done
3174         fi
3175
3176         echo '  cd '$cf_dir' && ${MAKE} ${CF_MFLAGS} [$]@' >>Makefile
3177 done
3178
3179 for cf_dir in $SRC_SUBDIRS
3180 do
3181         if test ! -d $srcdir/$cf_dir ; then
3182                 continue
3183         fi
3184
3185         if test -f $cf_dir/Makefile ; then
3186                 case "$cf_dir" in
3187                 Ada95) #(vi
3188                         echo 'libs \' >> Makefile
3189                         echo 'install.libs \' >> Makefile
3190                         echo 'uninstall.libs ::' >> Makefile
3191                         echo '  cd '$cf_dir' && ${MAKE} ${CF_MFLAGS} [$]@' >> Makefile
3192                         ;;
3193                 esac
3194         fi
3195
3196         if test -f $srcdir/$cf_dir/modules; then
3197                 echo >> Makefile
3198                 if test -f $srcdir/$cf_dir/headers; then
3199 cat >> Makefile <<CF_EOF
3200 install.includes \\
3201 uninstall.includes \\
3202 CF_EOF
3203                 fi
3204 if test "$cf_dir" != "c++" ; then
3205 echo 'lint \' >> Makefile
3206 fi
3207 cat >> Makefile <<CF_EOF
3208 libs \\
3209 lintlib \\
3210 install.libs \\
3211 uninstall.libs \\
3212 install.$cf_dir \\
3213 uninstall.$cf_dir ::
3214         cd $cf_dir && \${MAKE} \${CF_MFLAGS} \[$]@
3215 CF_EOF
3216         elif test -f $srcdir/$cf_dir/headers; then
3217 cat >> Makefile <<CF_EOF
3218
3219 libs \\
3220 install.libs \\
3221 uninstall.libs \\
3222 install.includes \\
3223 uninstall.includes ::
3224         cd $cf_dir && \${MAKE} \${CF_MFLAGS} \[$]@
3225 CF_EOF
3226 fi
3227 done
3228
3229 cat >> Makefile <<CF_EOF
3230
3231 install.libs uninstall.libs \\
3232 install.data uninstall.data ::
3233 $MAKE_TERMINFO  cd misc && \${MAKE} \${CF_MFLAGS} \[$]@
3234 CF_EOF
3235
3236 if test "x$cf_with_manpages" = xyes; then
3237 cat >> Makefile <<CF_EOF
3238
3239 install.man \\
3240 uninstall.man ::
3241         cd man && \${MAKE} \${CF_MFLAGS} \[$]@
3242 CF_EOF
3243 fi
3244
3245 cat >> Makefile <<CF_EOF
3246
3247 distclean ::
3248         rm -f config.cache config.log config.status Makefile include/ncurses_cfg.h
3249         rm -f headers.sh headers.sed mk_shared_lib.sh
3250         rm -f edit_man.* man_alias.*
3251         rm -rf \${DIRS_TO_MAKE}
3252 CF_EOF
3253
3254 # Special case: tack's manpage lives in its own directory.
3255 if test "x$cf_with_manpages" = xyes; then
3256 if test -d tack ; then
3257 if test -f $srcdir/$tack.h; then
3258 cat >> Makefile <<CF_EOF
3259
3260 install.man \\
3261 uninstall.man ::
3262         cd tack && \${MAKE} \${CF_MFLAGS} \[$]@
3263 CF_EOF
3264 fi
3265 fi
3266 fi
3267
3268 dnl If we're installing into a subdirectory of /usr/include, etc., we should
3269 dnl prepend the subdirectory's name to the "#include" paths.  It won't hurt
3270 dnl anything, and will make it more standardized.  It's awkward to decide this
3271 dnl at configuration because of quoting, so we'll simply make all headers
3272 dnl installed via a script that can do the right thing.
3273
3274 rm -f headers.sed headers.sh
3275
3276 dnl ( generating this script makes the makefiles a little tidier :-)
3277 echo creating headers.sh
3278 cat >headers.sh <<CF_EOF
3279 #! /bin/sh
3280 # This shell script is generated by the 'configure' script.  It is invoked in a
3281 # subdirectory of the build tree.  It generates a sed-script in the parent
3282 # directory that is used to adjust includes for header files that reside in a
3283 # subdirectory of /usr/include, etc.
3284 PRG=""
3285 while test \[$]# != 3
3286 do
3287 PRG="\$PRG \[$]1"; shift
3288 done
3289 DST=\[$]1
3290 REF=\[$]2
3291 SRC=\[$]3
3292 TMPSRC=\${TMPDIR:-/tmp}/\`basename \$SRC\`\$\$
3293 TMPSED=\${TMPDIR:-/tmp}/headers.sed\$\$
3294 echo installing \$SRC in \$DST
3295 CF_EOF
3296
3297 if test $WITH_CURSES_H = yes; then
3298         cat >>headers.sh <<CF_EOF
3299 case \$DST in
3300 /*/include/*)
3301         END=\`basename \$DST\`
3302         for i in \`cat \$REF/../*/headers |fgrep -v "#"\`
3303         do
3304                 NAME=\`basename \$i\`
3305                 echo "s/<\$NAME>/<\$END\/\$NAME>/" >> \$TMPSED
3306         done
3307         ;;
3308 *)
3309         echo "" >> \$TMPSED
3310         ;;
3311 esac
3312 CF_EOF
3313
3314 else
3315         cat >>headers.sh <<CF_EOF
3316 case \$DST in
3317 /*/include/*)
3318         END=\`basename \$DST\`
3319         for i in \`cat \$REF/../*/headers |fgrep -v "#"\`
3320         do
3321                 NAME=\`basename \$i\`
3322                 if test "\$NAME" = "curses.h"
3323                 then
3324                         echo "s/<curses.h>/<ncurses.h>/" >> \$TMPSED
3325                         NAME=ncurses.h
3326                 fi
3327                 echo "s/<\$NAME>/<\$END\/\$NAME>/" >> \$TMPSED
3328         done
3329         ;;
3330 *)
3331         echo "s/<curses.h>/<ncurses.h>/" >> \$TMPSED
3332         ;;
3333 esac
3334 CF_EOF
3335 fi
3336 cat >>headers.sh <<CF_EOF
3337 rm -f \$TMPSRC
3338 sed -f \$TMPSED \$SRC > \$TMPSRC
3339 NAME=\`basename \$SRC\`
3340 CF_EOF
3341 if test $WITH_CURSES_H != yes; then
3342         cat >>headers.sh <<CF_EOF
3343 test "\$NAME" = "curses.h" && NAME=ncurses.h
3344 CF_EOF
3345 fi
3346 cat >>headers.sh <<CF_EOF
3347 # Just in case someone gzip'd manpages, remove the conflicting copy.
3348 test -f \$DST/\$NAME.gz && rm -f \$DST/\$NAME.gz
3349
3350 eval \$PRG \$TMPSRC \$DST/\$NAME
3351 rm -f \$TMPSRC \$TMPSED
3352 CF_EOF
3353
3354 chmod 0755 headers.sh
3355
3356 for cf_dir in $SRC_SUBDIRS
3357 do
3358         if test ! -d $srcdir/$cf_dir ; then
3359                 continue
3360         fi
3361
3362         if test -f $srcdir/$cf_dir/headers; then
3363                 $AWK -f $srcdir/mk-hdr.awk \
3364                         subset="$LIB_SUBSETS" \
3365                         compat="$WITH_CURSES_H" \
3366                         $srcdir/$cf_dir/headers >>$cf_dir/Makefile
3367         fi
3368
3369         if test -f $srcdir/$cf_dir/modules; then
3370                 if test "$cf_dir" != "c++" ; then
3371                         cat >>$cf_dir/Makefile <<"CF_EOF"
3372 depend : ${AUTO_SRC}
3373         makedepend -- ${CPPFLAGS} -- ${C_SRC}
3374
3375 # DO NOT DELETE THIS LINE -- make depend depends on it.
3376 CF_EOF
3377                 fi
3378         fi
3379 done
3380 AC_SUBST(LIBS_TO_MAKE)
3381 ])dnl
3382 dnl ---------------------------------------------------------------------------
3383 dnl CF_LIB_SONAME version: 5 updated: 2010/08/14 18:25:37
3384 dnl -------------
3385 dnl Find the and soname for the given shared library.  Set the cache variable
3386 dnl cf_cv_$3_soname to this, unless it is not found.  Then set the cache
3387 dnl variable to "unknown".
3388 dnl
3389 dnl $1 = headers
3390 dnl $2 = code
3391 dnl $3 = library name
3392 AC_DEFUN([CF_LIB_SONAME],
3393 [
3394 AC_CACHE_CHECK(for soname of $3 library,cf_cv_$3_soname,[
3395
3396 cf_cv_$3_soname=unknown
3397 if test "$cross_compiling" != yes ; then
3398 cat >conftest.$ac_ext <<CF_EOF
3399 $1
3400 int main()
3401 {
3402 $2
3403         ${cf_cv_main_return:-return}(0);
3404 }
3405 CF_EOF
3406 cf_save_LIBS="$LIBS"
3407         CF_ADD_LIB($3)
3408         if AC_TRY_EVAL(ac_compile) ; then
3409                 if AC_TRY_EVAL(ac_link) ; then
3410                         cf_cv_$3_soname=`ldd conftest$ac_exeext 2>/dev/null | sed -e 's,^.*/,,' -e 's, .*$,,' | fgrep lib$3.`
3411                         test -z "$cf_cv_$3_soname" && cf_cv_$3_soname=unknown
3412                 fi
3413         fi
3414 rm -rf conftest*
3415 LIBS="$cf_save_LIBS"
3416 fi
3417 ])
3418 ])
3419 dnl ---------------------------------------------------------------------------
3420 dnl CF_LIB_SUFFIX version: 17 updated: 2011/07/02 15:36:04
3421 dnl -------------
3422 dnl Compute the library file-suffix from the given model name
3423 dnl $1 = model name
3424 dnl $2 = variable to set (the nominal library suffix)
3425 dnl $3 = dependency variable to set (actual filename)
3426 dnl The variable $LIB_SUFFIX, if set, prepends the variable to set.
3427 AC_DEFUN([CF_LIB_SUFFIX],
3428 [
3429         AC_REQUIRE([CF_SUBST_NCURSES_VERSION])
3430         case $1 in #(vi
3431         libtool) #(vi
3432                 $2='.la'
3433                 $3=[$]$2
3434                 ;;
3435         normal) #(vi
3436                 $2='.a'
3437                 $3=[$]$2
3438                 ;;
3439         debug) #(vi
3440                 $2='_g.a'
3441                 $3=[$]$2
3442                 ;;
3443         profile) #(vi
3444                 $2='_p.a'
3445                 $3=[$]$2
3446                 ;;
3447         shared) #(vi
3448                 case $cf_cv_system_name in
3449                 aix[[5-7]]*) #(vi
3450                         $2='.a'
3451                         $3=[$]$2
3452                         ;;
3453                 cygwin*) #(vi
3454                         $2='.dll'
3455                         $3='.dll.a'
3456                         ;;
3457                 darwin*) #(vi
3458                         $2='.dylib'
3459                         $3=[$]$2
3460                         ;;
3461                 hpux*) #(vi
3462                         case $target in
3463                         ia64*) #(vi
3464                                 $2='.so'
3465                                 $3=[$]$2
3466                                 ;;
3467                         *) #(vi
3468                                 $2='.sl'
3469                                 $3=[$]$2
3470                                 ;;
3471                         esac
3472                         ;;
3473                 *)      $2='.so'
3474                         $3=[$]$2
3475                         ;;
3476                 esac
3477         esac
3478         test -n "$LIB_SUFFIX" && $2="${LIB_SUFFIX}[$]{$2}"
3479         test -n "$LIB_SUFFIX" && $3="${LIB_SUFFIX}[$]{$3}"
3480 ])dnl
3481 dnl ---------------------------------------------------------------------------
3482 dnl CF_LIB_TYPE version: 4 updated: 2000/10/20 22:57:49
3483 dnl -----------
3484 dnl Compute the string to append to -library from the given model name
3485 dnl $1 = model name
3486 dnl $2 = variable to set
3487 dnl The variable $LIB_SUFFIX, if set, prepends the variable to set.
3488 AC_DEFUN([CF_LIB_TYPE],
3489 [
3490         case $1 in
3491         libtool) $2=''   ;;
3492         normal)  $2=''   ;;
3493         debug)   $2='_g' ;;
3494         profile) $2='_p' ;;
3495         shared)  $2=''   ;;
3496         esac
3497         test -n "$LIB_SUFFIX" && $2="${LIB_SUFFIX}[$]{$2}"
3498 ])dnl
3499 dnl ---------------------------------------------------------------------------
3500 dnl CF_LINK_DATAONLY version: 9 updated: 2009/01/01 20:21:38
3501 dnl ----------------
3502 dnl Some systems have a non-ANSI linker that doesn't pull in modules that have
3503 dnl only data (i.e., no functions), for example NeXT.  On those systems we'll
3504 dnl have to provide wrappers for global tables to ensure they're linked
3505 dnl properly.
3506 AC_DEFUN([CF_LINK_DATAONLY],
3507 [
3508 AC_MSG_CHECKING([if data-only library module links])
3509 AC_CACHE_VAL(cf_cv_link_dataonly,[
3510         rm -f conftest.a
3511         cat >conftest.$ac_ext <<EOF
3512 #line __oline__ "configure"
3513 int     testdata[[3]] = { 123, 456, 789 };
3514 EOF
3515         if AC_TRY_EVAL(ac_compile) ; then
3516                 mv conftest.o data.o && \
3517                 ( $AR $ARFLAGS conftest.a data.o ) 2>&AC_FD_CC 1>/dev/null
3518         fi
3519         rm -f conftest.$ac_ext data.o
3520         cat >conftest.$ac_ext <<EOF
3521 #line __oline__ "configure"
3522 int     testfunc()
3523 {
3524 #if defined(NeXT)
3525         ${cf_cv_main_return:-return}(1);        /* I'm told this linker is broken */
3526 #else
3527         extern int testdata[[3]];
3528         return testdata[[0]] == 123
3529            &&  testdata[[1]] == 456
3530            &&  testdata[[2]] == 789;
3531 #endif
3532 }
3533 EOF
3534         if AC_TRY_EVAL(ac_compile); then
3535                 mv conftest.o func.o && \
3536                 ( $AR $ARFLAGS conftest.a func.o ) 2>&AC_FD_CC 1>/dev/null
3537         fi
3538         rm -f conftest.$ac_ext func.o
3539         ( eval $RANLIB conftest.a ) 2>&AC_FD_CC >/dev/null
3540         cf_saveLIBS="$LIBS"
3541         LIBS="conftest.a $LIBS"
3542         AC_TRY_RUN([
3543         int main()
3544         {
3545                 extern int testfunc();
3546                 ${cf_cv_main_return:-return} (!testfunc());
3547         }
3548         ],
3549         [cf_cv_link_dataonly=yes],
3550         [cf_cv_link_dataonly=no],
3551         [cf_cv_link_dataonly=unknown])
3552         LIBS="$cf_saveLIBS"
3553         ])
3554 AC_MSG_RESULT($cf_cv_link_dataonly)
3555
3556 if test "$cf_cv_link_dataonly" = no ; then
3557         AC_DEFINE(BROKEN_LINKER)
3558         BROKEN_LINKER=1
3559 fi
3560
3561 ])dnl
3562 dnl ---------------------------------------------------------------------------
3563 dnl CF_LINK_FUNCS version: 7 updated: 2006/12/16 12:33:30
3564 dnl -------------
3565 dnl Most Unix systems have both link and symlink, a few don't have symlink.
3566 dnl A few non-Unix systems implement symlink, but not link.
3567 dnl A few non-systems implement neither (or have nonfunctional versions).
3568 AC_DEFUN([CF_LINK_FUNCS],
3569 [
3570 AC_CHECK_FUNCS( \
3571         remove \
3572         unlink )
3573
3574 if test "$cross_compiling" = yes ; then
3575         AC_CHECK_FUNCS( \
3576                 link \
3577                 symlink )
3578 else
3579         AC_CACHE_CHECK(if link/symlink functions work,cf_cv_link_funcs,[
3580                 cf_cv_link_funcs=
3581                 for cf_func in link symlink ; do
3582                         AC_TRY_RUN([
3583 #include <sys/types.h>
3584 #include <sys/stat.h>
3585 #ifdef HAVE_UNISTD_H
3586 #include <unistd.h>
3587 #endif
3588 int main()
3589 {
3590         int fail = 0;
3591         char *src = "config.log";
3592         char *dst = "conftest.chk";
3593         struct stat src_sb;
3594         struct stat dst_sb;
3595
3596         stat(src, &src_sb);
3597         fail = ($cf_func("config.log", "conftest.chk") < 0)
3598             || (stat(dst, &dst_sb) < 0)
3599             || (dst_sb.st_mtime != src_sb.st_mtime);
3600 #ifdef HAVE_UNLINK
3601         unlink(dst);
3602 #else
3603         remove(dst);
3604 #endif
3605         ${cf_cv_main_return:-return} (fail);
3606 }
3607                         ],[
3608                         cf_cv_link_funcs="$cf_cv_link_funcs $cf_func"
3609                         eval 'ac_cv_func_'$cf_func'=yes'],[
3610                         eval 'ac_cv_func_'$cf_func'=no'],[
3611                         eval 'ac_cv_func_'$cf_func'=error'])
3612                 done
3613                 test -z "$cf_cv_link_funcs" && cf_cv_link_funcs=no
3614         ])
3615         test "$ac_cv_func_link"    = yes && AC_DEFINE(HAVE_LINK)
3616         test "$ac_cv_func_symlink" = yes && AC_DEFINE(HAVE_SYMLINK)
3617 fi
3618 ])dnl
3619 dnl ---------------------------------------------------------------------------
3620 dnl CF_MAIN_RETURN version: 1 updated: 2006/12/10 09:51:54
3621 dnl --------------
3622 dnl Check if a return from main to the shell actually returns the same exit
3623 dnl code.  This is true for almost any POSIX environment.
3624 dnl
3625 dnl Some very old environments did not flush stdout, etc., on an exit.  That
3626 dnl would be a useful case to test for also.
3627 AC_DEFUN([CF_MAIN_RETURN],
3628 [
3629 cf_cv_main_return=return
3630 ])dnl
3631 dnl ---------------------------------------------------------------------------
3632 dnl CF_MAKEFLAGS version: 14 updated: 2011/03/31 19:29:46
3633 dnl ------------
3634 dnl Some 'make' programs support ${MAKEFLAGS}, some ${MFLAGS}, to pass 'make'
3635 dnl options to lower-levels.  It's very useful for "make -n" -- if we have it.
3636 dnl (GNU 'make' does both, something POSIX 'make', which happens to make the
3637 dnl ${MAKEFLAGS} variable incompatible because it adds the assignments :-)
3638 AC_DEFUN([CF_MAKEFLAGS],
3639 [
3640 AC_CACHE_CHECK(for makeflags variable, cf_cv_makeflags,[
3641         cf_cv_makeflags=''
3642         for cf_option in '-${MAKEFLAGS}' '${MFLAGS}'
3643         do
3644                 cat >cf_makeflags.tmp <<CF_EOF
3645 SHELL = /bin/sh
3646 all :
3647         @ echo '.$cf_option'
3648 CF_EOF
3649                 cf_result=`${MAKE:-make} -k -f cf_makeflags.tmp 2>/dev/null | fgrep -v "ing directory" | sed -e 's,[[   ]]*$,,'`
3650                 case "$cf_result" in
3651                 .*k)
3652                         cf_result=`${MAKE:-make} -k -f cf_makeflags.tmp CC=cc 2>/dev/null`
3653                         case "$cf_result" in
3654                         .*CC=*) cf_cv_makeflags=
3655                                 ;;
3656                         *)      cf_cv_makeflags=$cf_option
3657                                 ;;
3658                         esac
3659                         break
3660                         ;;
3661                 .-)     ;;
3662                 *)      echo "given option \"$cf_option\", no match \"$cf_result\""
3663                         ;;
3664                 esac
3665         done
3666         rm -f cf_makeflags.tmp
3667 ])
3668
3669 AC_SUBST(cf_cv_makeflags)
3670 ])dnl
3671 dnl ---------------------------------------------------------------------------
3672 dnl CF_MAKE_TAGS version: 6 updated: 2010/10/23 15:52:32
3673 dnl ------------
3674 dnl Generate tags/TAGS targets for makefiles.  Do not generate TAGS if we have
3675 dnl a monocase filesystem.
3676 AC_DEFUN([CF_MAKE_TAGS],[
3677 AC_REQUIRE([CF_MIXEDCASE_FILENAMES])
3678
3679 AC_CHECK_PROGS(CTAGS, exctags ctags)
3680 AC_CHECK_PROGS(ETAGS, exetags etags)
3681
3682 AC_CHECK_PROG(MAKE_LOWER_TAGS, ${CTAGS:-ctags}, yes, no)
3683
3684 if test "$cf_cv_mixedcase" = yes ; then
3685         AC_CHECK_PROG(MAKE_UPPER_TAGS, ${ETAGS:-etags}, yes, no)
3686 else
3687         MAKE_UPPER_TAGS=no
3688 fi
3689
3690 if test "$MAKE_UPPER_TAGS" = yes ; then
3691         MAKE_UPPER_TAGS=
3692 else
3693         MAKE_UPPER_TAGS="#"
3694 fi
3695
3696 if test "$MAKE_LOWER_TAGS" = yes ; then
3697         MAKE_LOWER_TAGS=
3698 else
3699         MAKE_LOWER_TAGS="#"
3700 fi
3701
3702 AC_SUBST(CTAGS)
3703 AC_SUBST(ETAGS)
3704
3705 AC_SUBST(MAKE_UPPER_TAGS)
3706 AC_SUBST(MAKE_LOWER_TAGS)
3707 ])dnl
3708 dnl ---------------------------------------------------------------------------
3709 dnl CF_MANPAGE_FORMAT version: 9 updated: 2010/10/23 16:10:30
3710 dnl -----------------
3711 dnl Option to allow user to override automatic configuration of manpage format.
3712 dnl There are several special cases:
3713 dnl
3714 dnl     gzip - man checks for, can display gzip'd files
3715 dnl     compress - man checks for, can display compressed files
3716 dnl     BSDI - files in the cat-directories are suffixed ".0"
3717 dnl     formatted - installer should format (put files in cat-directory)
3718 dnl     catonly - installer should only format, e.g., for a turnkey system.
3719 dnl
3720 dnl There are other configurations which this macro does not test, e.g., HPUX's
3721 dnl compressed manpages (but uncompressed manpages are fine, and HPUX's naming
3722 dnl convention would not match our use).
3723 AC_DEFUN([CF_MANPAGE_FORMAT],
3724 [
3725 AC_REQUIRE([CF_PATHSEP])
3726 AC_MSG_CHECKING(format of man-pages)
3727
3728 AC_ARG_WITH(manpage-format,
3729         [  --with-manpage-format   specify manpage-format: gzip/compress/BSDI/normal and
3730                           optionally formatted/catonly, e.g., gzip,formatted],
3731         [MANPAGE_FORMAT=$withval],
3732         [MANPAGE_FORMAT=unknown])
3733
3734 test -z "$MANPAGE_FORMAT" && MANPAGE_FORMAT=unknown
3735 MANPAGE_FORMAT=`echo "$MANPAGE_FORMAT" | sed -e 's/,/ /g'`
3736
3737 cf_unknown=
3738
3739 case $MANPAGE_FORMAT in
3740 unknown)
3741   if test -z "$MANPATH" ; then
3742     MANPATH="/usr/man:/usr/share/man"
3743   fi
3744
3745   # look for the 'date' man-page (it's most likely to be installed!)
3746   MANPAGE_FORMAT=
3747   cf_preform=no
3748   cf_catonly=yes
3749   cf_example=date
3750
3751   IFS="${IFS:-  }"; ac_save_ifs="$IFS"; IFS="${IFS}${PATH_SEPARATOR}"
3752   for cf_dir in $MANPATH; do
3753     test -z "$cf_dir" && cf_dir=/usr/man
3754     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
3755     do
3756       cf_test=`echo $cf_name | sed -e 's/*//'`
3757       if test "x$cf_test" = "x$cf_name" ; then
3758
3759         case "$cf_name" in
3760         *.gz) MANPAGE_FORMAT="$MANPAGE_FORMAT gzip";;
3761         *.Z)  MANPAGE_FORMAT="$MANPAGE_FORMAT compress";;
3762         *.0)    MANPAGE_FORMAT="$MANPAGE_FORMAT BSDI";;
3763         *)    MANPAGE_FORMAT="$MANPAGE_FORMAT normal";;
3764         esac
3765
3766         case "$cf_name" in
3767         $cf_dir/man*)
3768           cf_catonly=no
3769           ;;
3770         $cf_dir/cat*)
3771           cf_preform=yes
3772           ;;
3773         esac
3774         break
3775       fi
3776
3777       # if we found a match in either man* or cat*, stop looking
3778       if test -n "$MANPAGE_FORMAT" ; then
3779         cf_found=no
3780         test "$cf_preform" = yes && MANPAGE_FORMAT="$MANPAGE_FORMAT formatted"
3781         test "$cf_catonly" = yes && MANPAGE_FORMAT="$MANPAGE_FORMAT catonly"
3782         case "$cf_name" in
3783         $cf_dir/cat*)
3784           cf_found=yes
3785           ;;
3786         esac
3787         test $cf_found=yes && break
3788       fi
3789     done
3790     # only check the first directory in $MANPATH where we find manpages
3791     if test -n "$MANPAGE_FORMAT" ; then
3792        break
3793     fi
3794   done
3795   # if we did not find the example, just assume it is normal
3796   test -z "$MANPAGE_FORMAT" && MANPAGE_FORMAT=normal
3797   IFS="$ac_save_ifs"
3798   ;;
3799 *)
3800   for cf_option in $MANPAGE_FORMAT; do
3801      case $cf_option in #(vi
3802      gzip|compress|BSDI|normal|formatted|catonly)
3803        ;;
3804      *)
3805        cf_unknown="$cf_unknown $cf_option"
3806        ;;
3807      esac
3808   done
3809   ;;
3810 esac
3811
3812 AC_MSG_RESULT($MANPAGE_FORMAT)
3813 if test -n "$cf_unknown" ; then
3814   AC_MSG_WARN(Unexpected manpage-format $cf_unknown)
3815 fi
3816 ])dnl
3817 dnl ---------------------------------------------------------------------------
3818 dnl CF_MANPAGE_RENAMES version: 7 updated: 2005/06/18 18:51:57
3819 dnl ------------------
3820 dnl The Debian people have their own naming convention for manpages.  This
3821 dnl option lets us override the name of the file containing renaming, or
3822 dnl disable it altogether.
3823 AC_DEFUN([CF_MANPAGE_RENAMES],
3824 [
3825 AC_MSG_CHECKING(for manpage renaming)
3826
3827 AC_ARG_WITH(manpage-renames,
3828         [  --with-manpage-renames  specify manpage-renaming],
3829         [MANPAGE_RENAMES=$withval],
3830         [MANPAGE_RENAMES=yes])
3831
3832 case ".$MANPAGE_RENAMES" in #(vi
3833 .no) #(vi
3834   ;;
3835 .|.yes)
3836   # Debian 'man' program?
3837   if test -f /etc/debian_version ; then
3838     MANPAGE_RENAMES=`cd $srcdir && pwd`/man/man_db.renames
3839   else
3840     MANPAGE_RENAMES=no
3841   fi
3842   ;;
3843 esac
3844
3845 if test "$MANPAGE_RENAMES" != no ; then
3846   if test -f $srcdir/man/$MANPAGE_RENAMES ; then
3847     MANPAGE_RENAMES=`cd $srcdir/man && pwd`/$MANPAGE_RENAMES
3848   elif test ! -f $MANPAGE_RENAMES ; then
3849     AC_MSG_ERROR(not a filename: $MANPAGE_RENAMES)
3850   fi
3851
3852   test ! -d man && mkdir man
3853
3854   # Construct a sed-script to perform renaming within man-pages
3855   if test -n "$MANPAGE_RENAMES" ; then
3856     test ! -d man && mkdir man
3857     sh $srcdir/man/make_sed.sh $MANPAGE_RENAMES >./edit_man.sed
3858   fi
3859 fi
3860
3861 AC_MSG_RESULT($MANPAGE_RENAMES)
3862 AC_SUBST(MANPAGE_RENAMES)
3863 ])dnl
3864 dnl ---------------------------------------------------------------------------
3865 dnl CF_MANPAGE_SYMLINKS version: 5 updated: 2010/07/24 17:12:40
3866 dnl -------------------
3867 dnl Some people expect each tool to make all aliases for manpages in the
3868 dnl man-directory.  This accommodates the older, less-capable implementations
3869 dnl of 'man', and is optional.
3870 AC_DEFUN([CF_MANPAGE_SYMLINKS],
3871 [
3872 AC_MSG_CHECKING(if manpage aliases will be installed)
3873
3874 AC_ARG_WITH(manpage-aliases,
3875         [  --with-manpage-aliases  specify manpage-aliases using .so],
3876         [MANPAGE_ALIASES=$withval],
3877         [MANPAGE_ALIASES=yes])
3878
3879 AC_MSG_RESULT($MANPAGE_ALIASES)
3880
3881 case "x$LN_S" in #(vi
3882 xln*) #(vi
3883         cf_use_symlinks=yes
3884         ;;
3885 *)
3886         cf_use_symlinks=no
3887         ;;
3888 esac
3889
3890 MANPAGE_SYMLINKS=no
3891 if test "$MANPAGE_ALIASES" = yes ; then
3892 AC_MSG_CHECKING(if manpage symlinks should be used)
3893
3894 AC_ARG_WITH(manpage-symlinks,
3895         [  --with-manpage-symlinks specify manpage-aliases using symlinks],
3896         [MANPAGE_SYMLINKS=$withval],
3897         [MANPAGE_SYMLINKS=$cf_use_symlinks])
3898
3899 if test "$$cf_use_symlinks" = no; then
3900 if test "$MANPAGE_SYMLINKS" = yes ; then
3901         AC_MSG_WARN(cannot make symlinks, will use .so files)
3902         MANPAGE_SYMLINKS=no
3903 fi
3904 fi
3905
3906 AC_MSG_RESULT($MANPAGE_SYMLINKS)
3907 fi
3908
3909 ])dnl
3910 dnl ---------------------------------------------------------------------------
3911 dnl CF_MANPAGE_TBL version: 3 updated: 2002/01/19 22:51:32
3912 dnl --------------
3913 dnl This option causes manpages to be run through tbl(1) to generate tables
3914 dnl correctly.
3915 AC_DEFUN([CF_MANPAGE_TBL],
3916 [
3917 AC_MSG_CHECKING(for manpage tbl)
3918
3919 AC_ARG_WITH(manpage-tbl,
3920         [  --with-manpage-tbl      specify manpage processing with tbl],
3921         [MANPAGE_TBL=$withval],
3922         [MANPAGE_TBL=no])
3923
3924 AC_MSG_RESULT($MANPAGE_TBL)
3925 ])dnl
3926 dnl ---------------------------------------------------------------------------
3927 dnl CF_MAN_PAGES version: 40 updated: 2011/09/10 16:20:21
3928 dnl ------------
3929 dnl Try to determine if the man-pages on the system are compressed, and if
3930 dnl so, what format is used.  Use this information to construct a script that
3931 dnl will install man-pages.
3932 AC_DEFUN([CF_MAN_PAGES],
3933 [
3934 CF_HELP_MESSAGE(Options to Specify How Manpages are Installed:)
3935 CF_MANPAGE_FORMAT
3936 CF_MANPAGE_RENAMES
3937 CF_MANPAGE_SYMLINKS
3938 CF_MANPAGE_TBL
3939
3940   if test "$prefix" = "NONE" ; then
3941      cf_prefix="$ac_default_prefix"
3942   else
3943      cf_prefix="$prefix"
3944   fi
3945
3946   case "$MANPAGE_FORMAT" in # (vi
3947   *catonly*) # (vi
3948     cf_format=yes
3949     cf_inboth=no
3950     ;;
3951   *formatted*) # (vi
3952     cf_format=yes
3953     cf_inboth=yes
3954     ;;
3955   *)
3956     cf_format=no
3957     cf_inboth=no
3958     ;;
3959   esac
3960
3961 test ! -d man && mkdir man
3962
3963 cf_so_strip=
3964 cf_compress=
3965 case "$MANPAGE_FORMAT" in #(vi
3966 *compress*) #(vi
3967         cf_so_strip="Z"
3968         cf_compress=compress
3969   ;;
3970 *gzip*)
3971         cf_so_strip="gz"
3972         cf_compress=gzip
3973   ;;
3974 esac
3975
3976 cf_edit_man=./edit_man.sh
3977 cf_man_alias=`pwd`/man_alias.sed
3978
3979 cat >$cf_edit_man <<CF_EOF
3980 #! /bin/sh
3981 # this script is generated by the configure-script CF_MAN_PAGES macro.
3982
3983 prefix="$cf_prefix"
3984 datadir="$datadir"
3985
3986 NCURSES_MAJOR="$NCURSES_MAJOR"
3987 NCURSES_MINOR="$NCURSES_MINOR"
3988 NCURSES_PATCH="$NCURSES_PATCH"
3989
3990 NCURSES_OSPEED="$NCURSES_OSPEED"
3991 TERMINFO="$TERMINFO"
3992
3993 INSTALL="$INSTALL"
3994 INSTALL_DATA="$INSTALL_DATA"
3995
3996 transform="$program_transform_name"
3997
3998 TMP=\${TMPDIR:=/tmp}/man\$\$
3999 trap "rm -f \$TMP" 0 1 2 5 15
4000
4001 form=\[$]1
4002 shift || exit 1
4003
4004 verb=\[$]1
4005 shift || exit 1
4006
4007 mandir=\[$]1
4008 shift || exit 1
4009
4010 srcdir=\[$]1
4011 top_srcdir=\[$]srcdir/..
4012 shift || exit 1
4013
4014 if test "\$form" = normal ; then
4015         if test "$cf_format" = yes ; then
4016         if test "$cf_inboth" = no ; then
4017                 sh \[$]0 format \$verb \$mandir \$srcdir \[$]*
4018                 exit $?
4019         fi
4020         fi
4021         cf_subdir=\$mandir/man
4022         cf_tables=$MANPAGE_TBL
4023 else
4024         cf_subdir=\$mandir/cat
4025         cf_tables=yes
4026 fi
4027
4028 # process the list of source-files
4029 for i in \[$]* ; do
4030 case \$i in #(vi
4031 *.orig|*.rej) ;; #(vi
4032 *.[[0-9]]*)
4033         section=\`expr "\$i" : '.*\\.\\([[0-9]]\\)[[xm]]*'\`;
4034         if test \$verb = installing ; then
4035         if test ! -d \$cf_subdir\${section} ; then
4036                 mkdir -p \$cf_subdir\$section
4037         fi
4038         fi
4039
4040         # replace variables in man page
4041         if test ! -f $cf_man_alias ; then
4042 cat >>$cf_man_alias <<-CF_EOF2
4043                 s,@DATADIR@,\$datadir,g
4044                 s,@TERMINFO@,\$TERMINFO,g
4045                 s,@NCURSES_MAJOR@,\$NCURSES_MAJOR,g
4046                 s,@NCURSES_MINOR@,\$NCURSES_MINOR,g
4047                 s,@NCURSES_PATCH@,\$NCURSES_PATCH,g
4048                 s,@NCURSES_OSPEED@,\$NCURSES_OSPEED,g
4049 CF_EOF
4050         ifelse($1,,,[
4051         for cf_name in $1
4052         do
4053                 cf_NAME=`echo "$cf_name" | sed y%abcdefghijklmnopqrstuvwxyz./-%ABCDEFGHIJKLMNOPQRSTUVWXYZ___%`
4054                 cf_name=`echo $cf_name|sed "$program_transform_name"`
4055 cat >>$cf_edit_man <<-CF_EOF
4056                 s,@$cf_NAME@,$cf_name,g
4057 CF_EOF
4058         done
4059         ])
4060 cat >>$cf_edit_man <<CF_EOF
4061 CF_EOF2
4062                 echo "...made $cf_man_alias"
4063         fi
4064
4065         aliases=
4066         cf_source=\`basename \$i\`
4067         inalias=\$cf_source
4068         test ! -f \$inalias && inalias="\$srcdir/\$inalias"
4069         if test ! -f \$inalias ; then
4070                 echo .. skipped \$cf_source
4071                 continue
4072         fi
4073 CF_EOF
4074
4075 if test "$MANPAGE_ALIASES" != no ; then
4076 cat >>$cf_edit_man <<CF_EOF
4077         nCurses=ignore.3x
4078         test $with_curses_h = yes && nCurses=ncurses.3x
4079         aliases=\`sed -f \$top_srcdir/man/manlinks.sed \$inalias |sed -f $cf_man_alias | sort -u; test \$inalias = \$nCurses && echo curses\`
4080 CF_EOF
4081 fi
4082
4083 if test "$MANPAGE_RENAMES" = no ; then
4084 cat >>$cf_edit_man <<CF_EOF
4085         # perform program transformations for section 1 man pages
4086         if test \$section = 1 ; then
4087                 cf_target=\$cf_subdir\${section}/\`echo \$cf_source|sed "\${transform}"\`
4088         else
4089                 cf_target=\$cf_subdir\${section}/\$cf_source
4090         fi
4091 CF_EOF
4092 else
4093 cat >>$cf_edit_man <<CF_EOF
4094         cf_target=\`grep "^\$cf_source" $MANPAGE_RENAMES | $AWK '{print \[$]2}'\`
4095         if test -z "\$cf_target" ; then
4096                 echo '? missing rename for '\$cf_source
4097                 cf_target="\$cf_source"
4098         fi
4099         cf_target="\$cf_subdir\${section}/\${cf_target}"
4100
4101 CF_EOF
4102 fi
4103
4104 cat >>$cf_edit_man <<CF_EOF
4105         sed     -f $cf_man_alias \\
4106 CF_EOF
4107
4108 if test -f $MANPAGE_RENAMES ; then
4109 cat >>$cf_edit_man <<CF_EOF
4110                 < \$i | sed -f `pwd`/edit_man.sed >\$TMP
4111 CF_EOF
4112 else
4113 cat >>$cf_edit_man <<CF_EOF
4114                 < \$i >\$TMP
4115 CF_EOF
4116 fi
4117
4118 cat >>$cf_edit_man <<CF_EOF
4119 if test \$cf_tables = yes ; then
4120         tbl \$TMP >\$TMP.out
4121         mv \$TMP.out \$TMP
4122 fi
4123 CF_EOF
4124
4125 if test $with_overwrite != yes ; then
4126 cat >>$cf_edit_man <<CF_EOF
4127         sed -e "/\#[    ]*include/s,<curses.h,<ncurses$LIB_SUFFIX/curses.h," < \$TMP >\$TMP.out
4128         mv \$TMP.out \$TMP
4129 CF_EOF
4130 fi
4131
4132 if test $with_curses_h != yes ; then
4133 cat >>$cf_edit_man <<CF_EOF
4134         sed -e "/\#[    ]*include/s,curses.h,ncurses.h," < \$TMP >\$TMP.out
4135         mv \$TMP.out \$TMP
4136 CF_EOF
4137 fi
4138
4139 cat >>$cf_edit_man <<CF_EOF
4140         if test \$form = format ; then
4141                 nroff -man \$TMP >\$TMP.out
4142                 mv \$TMP.out \$TMP
4143         fi
4144 CF_EOF
4145
4146 if test -n "$cf_compress" ; then
4147 cat >>$cf_edit_man <<CF_EOF
4148         if test \$verb = installing ; then
4149         if ( $cf_compress -f \$TMP )
4150         then
4151                 mv \$TMP.$cf_so_strip \$TMP
4152         fi
4153         fi
4154         cf_target="\$cf_target.$cf_so_strip"
4155 CF_EOF
4156 fi
4157
4158 case "$MANPAGE_FORMAT" in #(vi
4159 *BSDI*)
4160 cat >>$cf_edit_man <<CF_EOF
4161         if test \$form = format ; then
4162                 # BSDI installs only .0 suffixes in the cat directories
4163                 cf_target="\`echo \$cf_target|sed -e 's/\.[[1-9]]\+[[a-z]]*/.0/'\`"
4164         fi
4165 CF_EOF
4166   ;;
4167 esac
4168
4169 cat >>$cf_edit_man <<CF_EOF
4170         suffix=\`basename \$cf_target | sed -e 's%^[[^.]]*%%'\`
4171         if test \$verb = installing ; then
4172                 echo \$verb \$cf_target
4173                 \$INSTALL_DATA \$TMP \$cf_target
4174                 test -d \$cf_subdir\${section} &&
4175                 test -n "\$aliases" && (
4176                         cd \$cf_subdir\${section} && (
4177                                 cf_source=\`echo \$cf_target |sed -e 's%^.*/\([[^/]][[^/]]*/[[^/]][[^/]]*$\)%\1%'\`
4178                                 test -n "$cf_so_strip" && cf_source=\`echo \$cf_source |sed -e 's%\.$cf_so_strip\$%%'\`
4179                                 cf_target=\`basename \$cf_target\`
4180                                 for cf_alias in \$aliases
4181                                 do
4182                                         if test \$section = 1 ; then
4183                                                 cf_alias=\`echo \$cf_alias|sed "\${transform}"\`
4184                                         fi
4185
4186                                         if test "$MANPAGE_SYMLINKS" = yes ; then
4187                                                 if test -f \$cf_alias\${suffix} ; then
4188                                                         if ( cmp -s \$cf_target \$cf_alias\${suffix} )
4189                                                         then
4190                                                                 continue
4191                                                         fi
4192                                                 fi
4193                                                 echo .. \$verb alias \$cf_alias\${suffix}
4194 CF_EOF
4195 case "x$LN_S" in #(vi
4196 *-f) #(vi
4197 cat >>$cf_edit_man <<CF_EOF
4198                                                 $LN_S \$cf_target \$cf_alias\${suffix}
4199 CF_EOF
4200         ;;
4201 *)
4202 cat >>$cf_edit_man <<CF_EOF
4203                                                 rm -f \$cf_alias\${suffix}
4204                                                 $LN_S \$cf_target \$cf_alias\${suffix}
4205 CF_EOF
4206         ;;
4207 esac
4208 cat >>$cf_edit_man <<CF_EOF
4209                                         elif test "\$cf_target" != "\$cf_alias\${suffix}" ; then
4210                                                 echo ".so \$cf_source" >\$TMP
4211 CF_EOF
4212 if test -n "$cf_compress" ; then
4213 cat >>$cf_edit_man <<CF_EOF
4214                                                 if test -n "$cf_so_strip" ; then
4215                                                         $cf_compress -f \$TMP
4216                                                         mv \$TMP.$cf_so_strip \$TMP
4217                                                 fi
4218 CF_EOF
4219 fi
4220 cat >>$cf_edit_man <<CF_EOF
4221                                                 echo .. \$verb alias \$cf_alias\${suffix}
4222                                                 rm -f \$cf_alias\${suffix}
4223                                                 \$INSTALL_DATA \$TMP \$cf_alias\${suffix}
4224                                         fi
4225                                 done
4226                         )
4227                 )
4228         elif test \$verb = removing ; then
4229                 test -f \$cf_target && (
4230                         echo \$verb \$cf_target
4231                         rm -f \$cf_target
4232                 )
4233                 test -d \$cf_subdir\${section} &&
4234                 test -n "\$aliases" && (
4235                         cd \$cf_subdir\${section} && (
4236                                 for cf_alias in \$aliases
4237                                 do
4238                                         if test \$section = 1 ; then
4239                                                 cf_alias=\`echo \$cf_alias|sed "\${transform}"\`
4240                                         fi
4241
4242                                         echo .. \$verb alias \$cf_alias\${suffix}
4243                                         rm -f \$cf_alias\${suffix}
4244                                 done
4245                         )
4246                 )
4247         else
4248 #               echo ".hy 0"
4249                 cat \$TMP
4250         fi
4251         ;;
4252 esac
4253 done
4254
4255 if test $cf_inboth = yes ; then
4256 if test \$form != format ; then
4257         sh \[$]0 format \$verb \$mandir \$srcdir \[$]*
4258 fi
4259 fi
4260
4261 exit 0
4262 CF_EOF
4263 chmod 755 $cf_edit_man
4264
4265 ])dnl
4266 dnl ---------------------------------------------------------------------------
4267 dnl CF_MATH_LIB version: 8 updated: 2010/05/29 16:31:02
4268 dnl -----------
4269 dnl Checks for libraries.  At least one UNIX system, Apple Macintosh
4270 dnl Rhapsody 5.5, does not have -lm.  We cannot use the simpler
4271 dnl AC_CHECK_LIB(m,sin), because that fails for C++.
4272 AC_DEFUN([CF_MATH_LIB],
4273 [
4274 AC_CACHE_CHECK(if -lm needed for math functions,
4275         cf_cv_need_libm,[
4276         AC_TRY_LINK([
4277         #include <stdio.h>
4278         #include <math.h>
4279         ],
4280         [double x = rand(); printf("result = %g\n", ]ifelse([$2],,sin(x),$2)[)],
4281         [cf_cv_need_libm=no],
4282         [cf_cv_need_libm=yes])])
4283 if test "$cf_cv_need_libm" = yes
4284 then
4285 ifelse($1,,[
4286         CF_ADD_LIB(m)
4287 ],[$1=-lm])
4288 fi
4289 ])
4290 dnl ---------------------------------------------------------------------------
4291 dnl CF_MIXEDCASE_FILENAMES version: 3 updated: 2003/09/20 17:07:55
4292 dnl ----------------------
4293 dnl Check if the file-system supports mixed-case filenames.  If we're able to
4294 dnl create a lowercase name and see it as uppercase, it doesn't support that.
4295 AC_DEFUN([CF_MIXEDCASE_FILENAMES],
4296 [
4297 AC_CACHE_CHECK(if filesystem supports mixed-case filenames,cf_cv_mixedcase,[
4298 if test "$cross_compiling" = yes ; then
4299         case $target_alias in #(vi
4300         *-os2-emx*|*-msdosdjgpp*|*-cygwin*|*-mingw32*|*-uwin*) #(vi
4301                 cf_cv_mixedcase=no
4302                 ;;
4303         *)
4304                 cf_cv_mixedcase=yes
4305                 ;;
4306         esac
4307 else
4308         rm -f conftest CONFTEST
4309         echo test >conftest
4310         if test -f CONFTEST ; then
4311                 cf_cv_mixedcase=no
4312         else
4313                 cf_cv_mixedcase=yes
4314         fi
4315         rm -f conftest CONFTEST
4316 fi
4317 ])
4318 test "$cf_cv_mixedcase" = yes && AC_DEFINE(MIXEDCASE_FILENAMES)
4319 ])dnl
4320 dnl ---------------------------------------------------------------------------
4321 dnl CF_MKSTEMP version: 7 updated: 2010/08/14 18:25:37
4322 dnl ----------
4323 dnl Check for a working mkstemp.  This creates two files, checks that they are
4324 dnl successfully created and distinct (AmigaOS apparently fails on the last).
4325 AC_DEFUN([CF_MKSTEMP],[
4326 AC_CACHE_CHECK(for working mkstemp, cf_cv_func_mkstemp,[
4327 rm -rf conftest*
4328 AC_TRY_RUN([
4329 #include <sys/types.h>
4330 #include <stdlib.h>
4331 #include <stdio.h>
4332 #include <string.h>
4333 #include <sys/stat.h>
4334 int main()
4335 {
4336         char *tmpl = "conftestXXXXXX";
4337         char name[2][80];
4338         int n;
4339         int result = 0;
4340         int fd;
4341         struct stat sb;
4342
4343         umask(077);
4344         for (n = 0; n < 2; ++n) {
4345                 strcpy(name[n], tmpl);
4346                 if ((fd = mkstemp(name[n])) >= 0) {
4347                         if (!strcmp(name[n], tmpl)
4348                          || stat(name[n], &sb) != 0
4349                          || (sb.st_mode & S_IFMT) != S_IFREG
4350                          || (sb.st_mode & 077) != 0) {
4351                                 result = 1;
4352                         }
4353                         close(fd);
4354                 }
4355         }
4356         if (result == 0
4357          && !strcmp(name[0], name[1]))
4358                 result = 1;
4359         ${cf_cv_main_return:-return}(result);
4360 }
4361 ],[cf_cv_func_mkstemp=yes
4362 ],[cf_cv_func_mkstemp=no
4363 ],[AC_CHECK_FUNC(mkstemp)
4364 ])
4365 ])
4366 if test "x$cf_cv_func_mkstemp" = xyes || test "x$ac_cv_func_mkstemp" = xyes ; then
4367         AC_DEFINE(HAVE_MKSTEMP)
4368 fi
4369 ])dnl
4370 dnl ---------------------------------------------------------------------------
4371 dnl CF_MSG_LOG version: 5 updated: 2010/10/23 15:52:32
4372 dnl ----------
4373 dnl Write a debug message to config.log, along with the line number in the
4374 dnl configure script.
4375 AC_DEFUN([CF_MSG_LOG],[
4376 echo "${as_me:-configure}:__oline__: testing $* ..." 1>&AC_FD_CC
4377 ])dnl
4378 dnl ---------------------------------------------------------------------------
4379 dnl CF_NCURSES_ABI_6 version: 1 updated: 2005/09/17 18:42:49
4380 dnl ----------------
4381 dnl Set ncurses' ABI to 6 unless overridden by explicit configure option, and
4382 dnl warn about this.
4383 AC_DEFUN([CF_NCURSES_ABI_6],[
4384 if test "${with_abi_version+set}" != set; then
4385         case $cf_cv_rel_version in
4386         5.*)
4387                 cf_cv_rel_version=6.0
4388                 cf_cv_abi_version=6
4389                 AC_MSG_WARN(Overriding ABI version to $cf_cv_abi_version)
4390                 ;;
4391         esac
4392 fi
4393 ])dnl
4394 dnl ---------------------------------------------------------------------------
4395 dnl CF_NO_LEAKS_OPTION version: 4 updated: 2006/12/16 14:24:05
4396 dnl ------------------
4397 dnl see CF_WITH_NO_LEAKS
4398 AC_DEFUN([CF_NO_LEAKS_OPTION],[
4399 AC_MSG_CHECKING(if you want to use $1 for testing)
4400 AC_ARG_WITH($1,
4401         [$2],
4402         [AC_DEFINE($3)ifelse([$4],,[
4403          $4
4404 ])
4405         : ${with_cflags:=-g}
4406         : ${with_no_leaks:=yes}
4407          with_$1=yes],
4408         [with_$1=])
4409 AC_MSG_RESULT(${with_$1:-no})
4410
4411 case .$with_cflags in #(vi
4412 .*-g*)
4413         case .$CFLAGS in #(vi
4414         .*-g*) #(vi
4415                 ;;
4416         *)
4417                 CF_ADD_CFLAGS([-g])
4418                 ;;
4419         esac
4420         ;;
4421 esac
4422 ])dnl
4423 dnl ---------------------------------------------------------------------------
4424 dnl CF_NUMBER_SYNTAX version: 1 updated: 2003/09/20 18:12:49
4425 dnl ----------------
4426 dnl Check if the given variable is a number.  If not, report an error.
4427 dnl $1 is the variable
4428 dnl $2 is the message
4429 AC_DEFUN([CF_NUMBER_SYNTAX],[
4430 if test -n "$1" ; then
4431   case $1 in #(vi
4432   [[0-9]]*) #(vi
4433         ;;
4434   *)
4435         AC_MSG_ERROR($2 is not a number: $1)
4436         ;;
4437   esac
4438 else
4439   AC_MSG_ERROR($2 value is empty)
4440 fi
4441 ])dnl
4442 dnl ---------------------------------------------------------------------------
4443 dnl CF_OBJ_SUBDIR version: 4 updated: 2002/02/23 20:38:31
4444 dnl -------------
4445 dnl Compute the object-directory name from the given model name
4446 AC_DEFUN([CF_OBJ_SUBDIR],
4447 [
4448         case $1 in
4449         libtool) $2='obj_lo'  ;;
4450         normal)  $2='objects' ;;
4451         debug)   $2='obj_g' ;;
4452         profile) $2='obj_p' ;;
4453         shared)
4454                 case $cf_cv_system_name in #(vi
4455                 cygwin) #(vi
4456                         $2='objects' ;;
4457                 *)
4458                         $2='obj_s' ;;
4459                 esac
4460         esac
4461 ])dnl
4462 dnl ---------------------------------------------------------------------------
4463 dnl CF_PATHSEP version: 5 updated: 2010/05/26 05:38:42
4464 dnl ----------
4465 dnl Provide a value for the $PATH and similar separator
4466 AC_DEFUN([CF_PATHSEP],
4467 [
4468         case $cf_cv_system_name in
4469         os2*)   PATH_SEPARATOR=';'  ;;
4470         *)      PATH_SEPARATOR=':'  ;;
4471         esac
4472 ifelse([$1],,,[$1=$PATH_SEPARATOR])
4473         AC_SUBST(PATH_SEPARATOR)
4474 ])dnl
4475 dnl ---------------------------------------------------------------------------
4476 dnl CF_PATH_SYNTAX version: 13 updated: 2010/05/26 05:38:42
4477 dnl --------------
4478 dnl Check the argument to see that it looks like a pathname.  Rewrite it if it
4479 dnl begins with one of the prefix/exec_prefix variables, and then again if the
4480 dnl result begins with 'NONE'.  This is necessary to work around autoconf's
4481 dnl delayed evaluation of those symbols.
4482 AC_DEFUN([CF_PATH_SYNTAX],[
4483 if test "x$prefix" != xNONE; then
4484   cf_path_syntax="$prefix"
4485 else
4486   cf_path_syntax="$ac_default_prefix"
4487 fi
4488
4489 case ".[$]$1" in #(vi
4490 .\[$]\(*\)*|.\'*\'*) #(vi
4491   ;;
4492 ..|./*|.\\*) #(vi
4493   ;;
4494 .[[a-zA-Z]]:[[\\/]]*) #(vi OS/2 EMX
4495   ;;
4496 .\[$]{*prefix}*) #(vi
4497   eval $1="[$]$1"
4498   case ".[$]$1" in #(vi
4499   .NONE/*)
4500     $1=`echo [$]$1 | sed -e s%NONE%$cf_path_syntax%`
4501     ;;
4502   esac
4503   ;; #(vi
4504 .no|.NONE/*)
4505   $1=`echo [$]$1 | sed -e s%NONE%$cf_path_syntax%`
4506   ;;
4507 *)
4508   ifelse([$2],,[AC_MSG_ERROR([expected a pathname, not \"[$]$1\"])],$2)
4509   ;;
4510 esac
4511 ])dnl
4512 dnl ---------------------------------------------------------------------------
4513 dnl CF_PKG_CONFIG version: 7 updated: 2011/04/29 04:53:22
4514 dnl -------------
4515 dnl Check for the package-config program, unless disabled by command-line.
4516 AC_DEFUN([CF_PKG_CONFIG],
4517 [
4518 AC_MSG_CHECKING(if you want to use pkg-config)
4519 AC_ARG_WITH(pkg-config,
4520         [  --with-pkg-config{=path} enable/disable use of pkg-config],
4521         [cf_pkg_config=$withval],
4522         [cf_pkg_config=yes])
4523 AC_MSG_RESULT($cf_pkg_config)
4524
4525 case $cf_pkg_config in #(vi
4526 no) #(vi
4527         PKG_CONFIG=none
4528         ;;
4529 yes) #(vi
4530         CF_ACVERSION_CHECK(2.52,
4531                 [AC_PATH_TOOL(PKG_CONFIG, pkg-config, none)],
4532                 [AC_PATH_PROG(PKG_CONFIG, pkg-config, none)])
4533         ;;
4534 *)
4535         PKG_CONFIG=$withval
4536         ;;
4537 esac
4538
4539 test -z "$PKG_CONFIG" && PKG_CONFIG=none
4540 if test "$PKG_CONFIG" != none ; then
4541         CF_PATH_SYNTAX(PKG_CONFIG)
4542 fi
4543
4544 AC_SUBST(PKG_CONFIG)
4545 ])dnl
4546 dnl ---------------------------------------------------------------------------
4547 dnl CF_POSIX_C_SOURCE version: 8 updated: 2010/05/26 05:38:42
4548 dnl -----------------
4549 dnl Define _POSIX_C_SOURCE to the given level, and _POSIX_SOURCE if needed.
4550 dnl
4551 dnl     POSIX.1-1990                            _POSIX_SOURCE
4552 dnl     POSIX.1-1990 and                        _POSIX_SOURCE and
4553 dnl             POSIX.2-1992 C-Language                 _POSIX_C_SOURCE=2
4554 dnl             Bindings Option
4555 dnl     POSIX.1b-1993                           _POSIX_C_SOURCE=199309L
4556 dnl     POSIX.1c-1996                           _POSIX_C_SOURCE=199506L
4557 dnl     X/Open 2000                             _POSIX_C_SOURCE=200112L
4558 dnl
4559 dnl Parameters:
4560 dnl     $1 is the nominal value for _POSIX_C_SOURCE
4561 AC_DEFUN([CF_POSIX_C_SOURCE],
4562 [
4563 cf_POSIX_C_SOURCE=ifelse([$1],,199506L,[$1])
4564
4565 cf_save_CFLAGS="$CFLAGS"
4566 cf_save_CPPFLAGS="$CPPFLAGS"
4567
4568 CF_REMOVE_DEFINE(cf_trim_CFLAGS,$cf_save_CFLAGS,_POSIX_C_SOURCE)
4569 CF_REMOVE_DEFINE(cf_trim_CPPFLAGS,$cf_save_CPPFLAGS,_POSIX_C_SOURCE)
4570
4571 AC_CACHE_CHECK(if we should define _POSIX_C_SOURCE,cf_cv_posix_c_source,[
4572         CF_MSG_LOG(if the symbol is already defined go no further)
4573         AC_TRY_COMPILE([#include <sys/types.h>],[
4574 #ifndef _POSIX_C_SOURCE
4575 make an error
4576 #endif],
4577         [cf_cv_posix_c_source=no],
4578         [cf_want_posix_source=no
4579          case .$cf_POSIX_C_SOURCE in #(vi
4580          .[[12]]??*) #(vi
4581                 cf_cv_posix_c_source="-D_POSIX_C_SOURCE=$cf_POSIX_C_SOURCE"
4582                 ;;
4583          .2) #(vi
4584                 cf_cv_posix_c_source="-D_POSIX_C_SOURCE=$cf_POSIX_C_SOURCE"
4585                 cf_want_posix_source=yes
4586                 ;;
4587          .*)
4588                 cf_want_posix_source=yes
4589                 ;;
4590          esac
4591          if test "$cf_want_posix_source" = yes ; then
4592                 AC_TRY_COMPILE([#include <sys/types.h>],[
4593 #ifdef _POSIX_SOURCE
4594 make an error
4595 #endif],[],
4596                 cf_cv_posix_c_source="$cf_cv_posix_c_source -D_POSIX_SOURCE")
4597          fi
4598          CF_MSG_LOG(ifdef from value $cf_POSIX_C_SOURCE)
4599          CFLAGS="$cf_trim_CFLAGS"
4600          CPPFLAGS="$cf_trim_CPPFLAGS $cf_cv_posix_c_source"
4601          CF_MSG_LOG(if the second compile does not leave our definition intact error)
4602          AC_TRY_COMPILE([#include <sys/types.h>],[
4603 #ifndef _POSIX_C_SOURCE
4604 make an error
4605 #endif],,
4606          [cf_cv_posix_c_source=no])
4607          CFLAGS="$cf_save_CFLAGS"
4608          CPPFLAGS="$cf_save_CPPFLAGS"
4609         ])
4610 ])
4611
4612 if test "$cf_cv_posix_c_source" != no ; then
4613         CFLAGS="$cf_trim_CFLAGS"
4614         CPPFLAGS="$cf_trim_CPPFLAGS"
4615         CF_ADD_CFLAGS($cf_cv_posix_c_source)
4616 fi
4617
4618 ])dnl
4619 dnl ---------------------------------------------------------------------------
4620 dnl CF_PREDEFINE version: 2 updated: 2010/05/26 16:44:57
4621 dnl ------------
4622 dnl Add definitions to CPPFLAGS to ensure they're predefined for all compiles.
4623 dnl
4624 dnl $1 = symbol to test
4625 dnl $2 = value (if any) to use for a predefinition
4626 AC_DEFUN([CF_PREDEFINE],
4627 [
4628 AC_MSG_CHECKING(if we must define $1)
4629 AC_TRY_COMPILE([#include <sys/types.h>
4630 ],[
4631 #ifndef $1
4632 make an error
4633 #endif],[cf_result=no],[cf_result=yes])
4634 AC_MSG_RESULT($cf_result)
4635
4636 if test "$cf_result" = yes ; then
4637         CPPFLAGS="$CPPFLAGS ifelse([$2],,-D$1,[-D$1=$2])"
4638 elif test "x$2" != "x" ; then
4639         AC_MSG_CHECKING(checking for compatible value versus $2)
4640         AC_TRY_COMPILE([#include <sys/types.h>
4641 ],[
4642 #if $1-$2 < 0
4643 make an error
4644 #endif],[cf_result=yes],[cf_result=no])
4645         AC_MSG_RESULT($cf_result)
4646         if test "$cf_result" = no ; then
4647                 # perhaps we can override it - try...
4648                 CPPFLAGS="$CPPFLAGS -D$1=$2"
4649         fi
4650 fi
4651 ])dnl
4652 dnl ---------------------------------------------------------------------------
4653 dnl CF_PRG_RULES version: 1 updated: 2006/06/03 11:45:08
4654 dnl ------------
4655 dnl Append definitions and rules for the given programs to the subdirectory
4656 dnl Makefiles, and the recursion rule for the top-level Makefile.
4657 dnl
4658 dnl parameters
4659 dnl     $1 = script to run
4660 dnl     $2 = list of subdirectories
4661 dnl
4662 dnl variables
4663 dnl     $AWK
4664 AC_DEFUN([CF_PRG_RULES],
4665 [
4666 for cf_dir in $2
4667 do
4668         if test ! -d $srcdir/$cf_dir; then
4669                 continue
4670         elif test -f $srcdir/$cf_dir/programs; then
4671                 $AWK -f $1 $srcdir/$cf_dir/programs >>$cf_dir/Makefile
4672         fi
4673 done
4674
4675 ])dnl
4676 dnl ---------------------------------------------------------------------------
4677 dnl CF_PROG_AR version: 1 updated: 2009/01/01 20:15:22
4678 dnl ----------
4679 dnl Check for archiver "ar".
4680 AC_DEFUN([CF_PROG_AR],[
4681 AC_CHECK_TOOL(AR, ar, ar)
4682 ])
4683 dnl ---------------------------------------------------------------------------
4684 dnl CF_PROG_AWK version: 1 updated: 2006/09/16 11:40:59
4685 dnl -----------
4686 dnl Check for awk, ensure that the check found something.
4687 AC_DEFUN([CF_PROG_AWK],
4688 [
4689 AC_PROG_AWK
4690 test -z "$AWK" && AC_MSG_ERROR(No awk program found)
4691 ])dnl
4692 dnl ---------------------------------------------------------------------------
4693 dnl CF_PROG_CC_C_O version: 3 updated: 2010/08/14 18:25:37
4694 dnl --------------
4695 dnl Analogous to AC_PROG_CC_C_O, but more useful: tests only $CC, ensures that
4696 dnl the output file can be renamed, and allows for a shell variable that can
4697 dnl be used later.  The parameter is either CC or CXX.  The result is the
4698 dnl cache variable:
4699 dnl     $cf_cv_prog_CC_c_o
4700 dnl     $cf_cv_prog_CXX_c_o
4701 AC_DEFUN([CF_PROG_CC_C_O],
4702 [AC_REQUIRE([AC_PROG_CC])dnl
4703 AC_MSG_CHECKING([whether [$]$1 understands -c and -o together])
4704 AC_CACHE_VAL(cf_cv_prog_$1_c_o,
4705 [
4706 cat > conftest.$ac_ext <<CF_EOF
4707 #include <stdio.h>
4708 int main()
4709 {
4710         ${cf_cv_main_return:-return}(0);
4711 }
4712 CF_EOF
4713 # We do the test twice because some compilers refuse to overwrite an
4714 # existing .o file with -o, though they will create one.
4715 ac_try='[$]$1 -c conftest.$ac_ext -o conftest2.$ac_objext >&AC_FD_CC'
4716 if AC_TRY_EVAL(ac_try) &&
4717   test -f conftest2.$ac_objext && AC_TRY_EVAL(ac_try);
4718 then
4719   eval cf_cv_prog_$1_c_o=yes
4720 else
4721   eval cf_cv_prog_$1_c_o=no
4722 fi
4723 rm -rf conftest*
4724 ])dnl
4725 if test $cf_cv_prog_$1_c_o = yes; then
4726   AC_MSG_RESULT([yes])
4727 else
4728   AC_MSG_RESULT([no])
4729 fi
4730 ])dnl
4731 dnl ---------------------------------------------------------------------------
4732 dnl CF_PROG_CC_U_D version: 1 updated: 2005/07/14 16:59:30
4733 dnl --------------
4734 dnl Check if C (preprocessor) -U and -D options are processed in the order
4735 dnl given rather than by type of option.  Some compilers insist on apply all
4736 dnl of the -U options after all of the -D options.  Others allow mixing them,
4737 dnl and may predefine symbols that conflict with those we define.
4738 AC_DEFUN([CF_PROG_CC_U_D],
4739 [
4740 AC_CACHE_CHECK(if $CC -U and -D options work together,cf_cv_cc_u_d_options,[
4741         cf_save_CPPFLAGS="$CPPFLAGS"
4742         CPPFLAGS="-UU_D_OPTIONS -DU_D_OPTIONS -DD_U_OPTIONS -UD_U_OPTIONS"
4743         AC_TRY_COMPILE([],[
4744 #ifndef U_D_OPTIONS
4745 make an undefined-error
4746 #endif
4747 #ifdef  D_U_OPTIONS
4748 make a defined-error
4749 #endif
4750         ],[
4751         cf_cv_cc_u_d_options=yes],[
4752         cf_cv_cc_u_d_options=no])
4753         CPPFLAGS="$cf_save_CPPFLAGS"
4754 ])
4755 ])dnl
4756 dnl ---------------------------------------------------------------------------
4757 dnl CF_PROG_EGREP version: 1 updated: 2006/09/16 11:40:59
4758 dnl -------------
4759 dnl AC_PROG_EGREP was introduced in autoconf 2.53.
4760 dnl This macro adds a check to ensure the script found something.
4761 AC_DEFUN([CF_PROG_EGREP],
4762 [AC_CACHE_CHECK([for egrep], [ac_cv_prog_egrep],
4763    [if echo a | (grep -E '(a|b)') >/dev/null 2>&1
4764     then ac_cv_prog_egrep='grep -E'
4765     else ac_cv_prog_egrep='egrep'
4766     fi])
4767  EGREP=$ac_cv_prog_egrep
4768  AC_SUBST([EGREP])
4769 test -z "$EGREP" && AC_MSG_ERROR(No egrep program found)
4770 ])dnl
4771 dnl ---------------------------------------------------------------------------
4772 dnl CF_PROG_EXT version: 10 updated: 2004/01/03 19:28:18
4773 dnl -----------
4774 dnl Compute $PROG_EXT, used for non-Unix ports, such as OS/2 EMX.
4775 AC_DEFUN([CF_PROG_EXT],
4776 [
4777 AC_REQUIRE([CF_CHECK_CACHE])
4778 case $cf_cv_system_name in
4779 os2*)
4780     CFLAGS="$CFLAGS -Zmt"
4781     CPPFLAGS="$CPPFLAGS -D__ST_MT_ERRNO__"
4782     CXXFLAGS="$CXXFLAGS -Zmt"
4783     # autoconf's macro sets -Zexe and suffix both, which conflict:w
4784     LDFLAGS="$LDFLAGS -Zmt -Zcrtdll"
4785     ac_cv_exeext=.exe
4786     ;;
4787 esac
4788
4789 AC_EXEEXT
4790 AC_OBJEXT
4791
4792 PROG_EXT="$EXEEXT"
4793 AC_SUBST(PROG_EXT)
4794 test -n "$PROG_EXT" && AC_DEFINE_UNQUOTED(PROG_EXT,"$PROG_EXT")
4795 ])dnl
4796 dnl ---------------------------------------------------------------------------
4797 dnl CF_PROG_GNAT version: 1 updated: 2010/06/19 15:22:18
4798 dnl ------------
4799 dnl Check for gnatmake, ensure that it is complete.
4800 AC_DEFUN([CF_PROG_GNAT],[
4801 cf_ada_make=gnatmake
4802 AC_CHECK_PROG(gnat_exists, $cf_ada_make, yes, no)
4803 if test "$ac_cv_prog_gnat_exists" = no; then
4804    cf_ada_make=
4805 else
4806    CF_GNAT_VERSION
4807    AC_CHECK_PROG(M4_exists, m4, yes, no)
4808    if test "$ac_cv_prog_M4_exists" = no; then
4809       cf_cv_prog_gnat_correct=no
4810       echo Ada95 binding required program m4 not found. Ada95 binding disabled.
4811    fi
4812    if test "$cf_cv_prog_gnat_correct" = yes; then
4813       AC_MSG_CHECKING(if GNAT works)
4814       CF_GNAT_TRY_RUN([procedure conftest;],
4815 [with Text_IO;
4816 with GNAT.OS_Lib;
4817 procedure conftest is
4818 begin
4819    Text_IO.Put ("Hello World");
4820    Text_IO.New_Line;
4821    GNAT.OS_Lib.OS_Exit (0);
4822 end conftest;],[cf_cv_prog_gnat_correct=yes],[cf_cv_prog_gnat_correct=no])
4823       AC_MSG_RESULT($cf_cv_prog_gnat_correct)
4824    fi
4825 fi
4826
4827 AC_SUBST(cf_ada_make)
4828 ])dnl
4829 dnl ---------------------------------------------------------------------------
4830 dnl CF_PROG_INSTALL version: 5 updated: 2002/12/21 22:46:07
4831 dnl ---------------
4832 dnl Force $INSTALL to be an absolute-path.  Otherwise, edit_man.sh and the
4833 dnl misc/tabset install won't work properly.  Usually this happens only when
4834 dnl using the fallback mkinstalldirs script
4835 AC_DEFUN([CF_PROG_INSTALL],
4836 [AC_PROG_INSTALL
4837 case $INSTALL in
4838 /*)
4839   ;;
4840 *)
4841   CF_DIRNAME(cf_dir,$INSTALL)
4842   test -z "$cf_dir" && cf_dir=.
4843   INSTALL=`cd $cf_dir && pwd`/`echo $INSTALL | sed -e 's%^.*/%%'`
4844   ;;
4845 esac
4846 ])dnl
4847 dnl ---------------------------------------------------------------------------
4848 dnl CF_PROG_LDCONFIG version: 3 updated: 2011/06/04 20:09:13
4849 dnl ----------------
4850 dnl Check for ldconfig, needed to fixup shared libraries that would be built
4851 dnl and then used in the install.
4852 AC_DEFUN([CF_PROG_LDCONFIG],[
4853 if test "$cross_compiling" = yes ; then
4854   LDCONFIG=:
4855 else
4856 case "$cf_cv_system_name" in #(vi
4857 dragonfly*|mirbsd*|freebsd*) #(vi
4858   test -z "$LDCONFIG" && LDCONFIG="/sbin/ldconfig -R"
4859   ;;
4860 *) LDPATH=$PATH:/sbin:/usr/sbin
4861   AC_PATH_PROG(LDCONFIG,ldconfig,,$LDPATH)
4862   ;;
4863 esac
4864 fi
4865 AC_SUBST(LDCONFIG)
4866 ])dnl
4867 dnl ---------------------------------------------------------------------------
4868 dnl CF_PROG_LINT version: 2 updated: 2009/08/12 04:43:14
4869 dnl ------------
4870 AC_DEFUN([CF_PROG_LINT],
4871 [
4872 AC_CHECK_PROGS(LINT, tdlint lint alint splint lclint)
4873 AC_SUBST(LINT_OPTS)
4874 ])dnl
4875 dnl ---------------------------------------------------------------------------
4876 dnl CF_PROG_LN_S version: 2 updated: 2010/08/14 18:25:37
4877 dnl ------------
4878 dnl Combine checks for "ln -s" and "ln -sf", updating $LN_S to include "-f"
4879 dnl option if it is supported.
4880 AC_DEFUN([CF_PROG_LN_S],[
4881 AC_PROG_LN_S
4882 AC_MSG_CHECKING(if $LN_S -f options work)
4883
4884 rm -f conf$$.src conf$$dst
4885 echo >conf$$.dst
4886 echo first >conf$$.src
4887 if $LN_S -f conf$$.src conf$$.dst 2>/dev/null; then
4888         cf_prog_ln_sf=yes
4889 else
4890         cf_prog_ln_sf=no
4891 fi
4892 rm -f conf$$.dst conf$$src
4893 AC_MSG_RESULT($cf_prog_ln_sf)
4894
4895 test "$cf_prog_ln_sf" = yes && LN_S="$LN_S -f"
4896 ])dnl
4897 dnl ---------------------------------------------------------------------------
4898 dnl CF_REGEX version: 8 updated: 2010/08/07 14:09:44
4899 dnl --------
4900 dnl Attempt to determine if we've got one of the flavors of regular-expression
4901 dnl code that we can support.
4902 AC_DEFUN([CF_REGEX],
4903 [
4904
4905 cf_regex_func=no
4906
4907 cf_regex_libs="regex re"
4908 case $host_os in #(vi
4909 mingw*)
4910         cf_regex_libs="regex.dll $cf_regex_libs"
4911         ;;
4912 esac
4913
4914 AC_CHECK_FUNC(regcomp,[cf_regex_func=regcomp],[
4915         for cf_regex_lib in $cf_regex_libs
4916         do
4917                 AC_CHECK_LIB($cf_regex_lib,regcomp,[
4918                                 CF_ADD_LIB($cf_regex_lib)
4919                                 cf_regex_func=regcomp
4920                                 break])
4921         done
4922 ])
4923
4924 if test "$cf_regex_func" = no ; then
4925         AC_CHECK_FUNC(compile,[cf_regex_func=compile],[
4926                 AC_CHECK_LIB(gen,compile,[
4927                                 CF_ADD_LIB(gen)
4928                                 cf_regex_func=compile])])
4929 fi
4930
4931 if test "$cf_regex_func" = no ; then
4932         AC_MSG_WARN(cannot find regular expression library)
4933 fi
4934
4935 AC_CACHE_CHECK(for regular-expression headers,cf_cv_regex_hdrs,[
4936
4937 cf_cv_regex_hdrs=no
4938 case $cf_regex_func in #(vi
4939 compile) #(vi
4940         for cf_regex_hdr in regexp.h regexpr.h
4941         do
4942                 AC_TRY_LINK([#include <$cf_regex_hdr>],[
4943                         char *p = compile("", "", "", 0);
4944                         int x = step("", "");
4945                 ],[
4946                         cf_cv_regex_hdrs=$cf_regex_hdr
4947                         break
4948                 ])
4949         done
4950         ;;
4951 *)
4952         for cf_regex_hdr in regex.h
4953         do
4954                 AC_TRY_LINK([#include <sys/types.h>
4955 #include <$cf_regex_hdr>],[
4956                         regex_t *p;
4957                         int x = regcomp(p, "", 0);
4958                         int y = regexec(p, "", 0, 0, 0);
4959                         regfree(p);
4960                 ],[
4961                         cf_cv_regex_hdrs=$cf_regex_hdr
4962                         break
4963                 ])
4964         done
4965         ;;
4966 esac
4967
4968 ])
4969
4970 case $cf_cv_regex_hdrs in #(vi
4971     no)        AC_MSG_WARN(no regular expression header found) ;; #(vi
4972     regex.h)   AC_DEFINE(HAVE_REGEX_H_FUNCS) ;; #(vi
4973     regexp.h)  AC_DEFINE(HAVE_REGEXP_H_FUNCS) ;; #(vi
4974     regexpr.h) AC_DEFINE(HAVE_REGEXPR_H_FUNCS) ;;
4975 esac
4976 ])dnl
4977 dnl ---------------------------------------------------------------------------
4978 dnl CF_REMOVE_DEFINE version: 3 updated: 2010/01/09 11:05:50
4979 dnl ----------------
4980 dnl Remove all -U and -D options that refer to the given symbol from a list
4981 dnl of C compiler options.  This works around the problem that not all
4982 dnl compilers process -U and -D options from left-to-right, so a -U option
4983 dnl cannot be used to cancel the effect of a preceding -D option.
4984 dnl
4985 dnl $1 = target (which could be the same as the source variable)
4986 dnl $2 = source (including '$')
4987 dnl $3 = symbol to remove
4988 define([CF_REMOVE_DEFINE],
4989 [
4990 $1=`echo "$2" | \
4991         sed     -e 's/-[[UD]]'"$3"'\(=[[^       ]]*\)\?[[       ]]/ /g' \
4992                 -e 's/-[[UD]]'"$3"'\(=[[^       ]]*\)\?[$]//g'`
4993 ])dnl
4994 dnl ---------------------------------------------------------------------------
4995 dnl CF_REMOVE_LIB version: 1 updated: 2007/02/17 14:11:52
4996 dnl -------------
4997 dnl Remove the given library from the symbol
4998 dnl
4999 dnl $1 = target (which could be the same as the source variable)
5000 dnl $2 = source (including '$')
5001 dnl $3 = library to remove
5002 define([CF_REMOVE_LIB],
5003 [
5004 # remove $3 library from $2
5005 $1=`echo "$2" | sed -e 's/-l$3[[        ]]//g' -e 's/-l$3[$]//'`
5006 ])dnl
5007 dnl ---------------------------------------------------------------------------
5008 dnl CF_RPATH_HACK version: 9 updated: 2011/02/13 13:31:33
5009 dnl -------------
5010 AC_DEFUN([CF_RPATH_HACK],
5011 [
5012 AC_REQUIRE([CF_LD_RPATH_OPT])
5013 AC_MSG_CHECKING(for updated LDFLAGS)
5014 if test -n "$LD_RPATH_OPT" ; then
5015         AC_MSG_RESULT(maybe)
5016
5017         AC_CHECK_PROGS(cf_ldd_prog,ldd,no)
5018         cf_rpath_list="/usr/lib /lib"
5019         if test "$cf_ldd_prog" != no
5020         then
5021                 cf_rpath_oops=
5022
5023 AC_TRY_LINK([#include <stdio.h>],
5024                 [printf("Hello");],
5025                 [cf_rpath_oops=`$cf_ldd_prog conftest$ac_exeext | fgrep ' not found' | sed -e 's% =>.*$%%' |sort -u`
5026                  cf_rpath_list=`$cf_ldd_prog conftest$ac_exeext | fgrep / | sed -e 's%^.*[[     ]]/%/%' -e 's%/[[^/]][[^/]]*$%%' |sort -u`])
5027
5028                 # If we passed the link-test, but get a "not found" on a given library,
5029                 # this could be due to inept reconfiguration of gcc to make it only
5030                 # partly honor /usr/local/lib (or whatever).  Sometimes this behavior
5031                 # is intentional, e.g., installing gcc in /usr/bin and suppressing the
5032                 # /usr/local libraries.
5033                 if test -n "$cf_rpath_oops"
5034                 then
5035                         for cf_rpath_src in $cf_rpath_oops
5036                         do
5037                                 for cf_rpath_dir in \
5038                                         /usr/local \
5039                                         /usr/pkg \
5040                                         /opt/sfw
5041                                 do
5042                                         if test -f $cf_rpath_dir/lib/$cf_rpath_src
5043                                         then
5044                                                 CF_VERBOSE(...adding -L$cf_rpath_dir/lib to LDFLAGS for $cf_rpath_src)
5045                                                 LDFLAGS="$LDFLAGS -L$cf_rpath_dir/lib"
5046                                                 break
5047                                         fi
5048                                 done
5049                         done
5050                 fi
5051         fi
5052
5053         CF_VERBOSE(...checking EXTRA_LDFLAGS $EXTRA_LDFLAGS)
5054
5055         CF_RPATH_HACK_2(LDFLAGS)
5056         CF_RPATH_HACK_2(LIBS)
5057
5058         CF_VERBOSE(...checked EXTRA_LDFLAGS $EXTRA_LDFLAGS)
5059 fi
5060 AC_SUBST(EXTRA_LDFLAGS)
5061 ])dnl
5062 dnl ---------------------------------------------------------------------------
5063 dnl CF_RPATH_HACK_2 version: 6 updated: 2010/04/17 16:31:24
5064 dnl ---------------
5065 dnl Do one set of substitutions for CF_RPATH_HACK, adding an rpath option to
5066 dnl EXTRA_LDFLAGS for each -L option found.
5067 dnl
5068 dnl $cf_rpath_list contains a list of directories to ignore.
5069 dnl
5070 dnl $1 = variable name to update.  The LDFLAGS variable should be the only one,
5071 dnl      but LIBS often has misplaced -L options.
5072 AC_DEFUN([CF_RPATH_HACK_2],
5073 [
5074 CF_VERBOSE(...checking $1 [$]$1)
5075
5076 cf_rpath_dst=
5077 for cf_rpath_src in [$]$1
5078 do
5079         case $cf_rpath_src in #(vi
5080         -L*) #(vi
5081
5082                 # check if this refers to a directory which we will ignore
5083                 cf_rpath_skip=no
5084                 if test -n "$cf_rpath_list"
5085                 then
5086                         for cf_rpath_item in $cf_rpath_list
5087                         do
5088                                 if test "x$cf_rpath_src" = "x-L$cf_rpath_item"
5089                                 then
5090                                         cf_rpath_skip=yes
5091                                         break
5092                                 fi
5093                         done
5094                 fi
5095
5096                 if test "$cf_rpath_skip" = no
5097                 then
5098                         # transform the option
5099                         if test "$LD_RPATH_OPT" = "-R " ; then
5100                                 cf_rpath_tmp=`echo "$cf_rpath_src" |sed -e "s%-L%-R %"`
5101                         else
5102                                 cf_rpath_tmp=`echo "$cf_rpath_src" |sed -e "s%-L%$LD_RPATH_OPT%"`
5103                         fi
5104
5105                         # if we have not already added this, add it now
5106                         cf_rpath_tst=`echo "$EXTRA_LDFLAGS" | sed -e "s%$cf_rpath_tmp %%"`
5107                         if test "x$cf_rpath_tst" = "x$EXTRA_LDFLAGS"
5108                         then
5109                                 CF_VERBOSE(...Filter $cf_rpath_src ->$cf_rpath_tmp)
5110                                 EXTRA_LDFLAGS="$cf_rpath_tmp $EXTRA_LDFLAGS"
5111                         fi
5112                 fi
5113                 ;;
5114         esac
5115         cf_rpath_dst="$cf_rpath_dst $cf_rpath_src"
5116 done
5117 $1=$cf_rpath_dst
5118
5119 CF_VERBOSE(...checked $1 [$]$1)
5120 AC_SUBST(EXTRA_LDFLAGS)
5121 ])dnl
5122 dnl ---------------------------------------------------------------------------
5123 dnl CF_SHARED_OPTS version: 69 updated: 2011/07/30 19:31:39
5124 dnl --------------
5125 dnl --------------
5126 dnl Attempt to determine the appropriate CC/LD options for creating a shared
5127 dnl library.
5128 dnl
5129 dnl Note: ${LOCAL_LDFLAGS} is used to link executables that will run within the
5130 dnl build-tree, i.e., by making use of the libraries that are compiled in ../lib
5131 dnl We avoid compiling-in a ../lib path for the shared library since that can
5132 dnl lead to unexpected results at runtime.
5133 dnl ${LOCAL_LDFLAGS2} has the same intention but assumes that the shared libraries
5134 dnl are compiled in ../../lib
5135 dnl
5136 dnl The variable 'cf_cv_do_symlinks' is used to control whether we configure
5137 dnl to install symbolic links to the rel/abi versions of shared libraries.
5138 dnl
5139 dnl The variable 'cf_cv_shlib_version' controls whether we use the rel or abi
5140 dnl version when making symbolic links.
5141 dnl
5142 dnl The variable 'cf_cv_shlib_version_infix' controls whether shared library
5143 dnl version numbers are infix (ex: libncurses.<ver>.dylib) or postfix
5144 dnl (ex: libncurses.so.<ver>).
5145 dnl
5146 dnl Some loaders leave 'so_locations' lying around.  It's nice to clean up.
5147 AC_DEFUN([CF_SHARED_OPTS],
5148 [
5149         AC_REQUIRE([CF_SUBST_NCURSES_VERSION])
5150         AC_REQUIRE([CF_LD_RPATH_OPT])
5151         LOCAL_LDFLAGS=
5152         LOCAL_LDFLAGS2=
5153         LD_SHARED_OPTS=
5154         INSTALL_LIB="-m 644"
5155
5156         cf_cv_do_symlinks=no
5157         cf_ld_rpath_opt=
5158         test "$cf_cv_enable_rpath" = yes && cf_ld_rpath_opt="$LD_RPATH_OPT"
5159
5160         AC_MSG_CHECKING(if release/abi version should be used for shared libs)
5161         AC_ARG_WITH(shlib-version,
5162         [  --with-shlib-version=X  Specify rel or abi version for shared libs],
5163         [test -z "$withval" && withval=auto
5164         case $withval in #(vi
5165         yes) #(vi
5166                 cf_cv_shlib_version=auto
5167                 ;;
5168         rel|abi|auto|no) #(vi
5169                 cf_cv_shlib_version=$withval
5170                 ;;
5171         *)
5172                 AC_MSG_ERROR([option value must be one of: rel, abi, auto or no])
5173                 ;;
5174         esac
5175         ],[cf_cv_shlib_version=auto])
5176         AC_MSG_RESULT($cf_cv_shlib_version)
5177
5178         cf_cv_rm_so_locs=no
5179
5180         # Some less-capable ports of gcc support only -fpic
5181         CC_SHARED_OPTS=
5182         if test "$GCC" = yes
5183         then
5184                 AC_MSG_CHECKING(which $CC option to use)
5185                 cf_save_CFLAGS="$CFLAGS"
5186                 for CC_SHARED_OPTS in -fPIC -fpic ''
5187                 do
5188                         CFLAGS="$cf_save_CFLAGS $CC_SHARED_OPTS"
5189                         AC_TRY_COMPILE([#include <stdio.h>],[int x = 1],[break],[])
5190                 done
5191                 AC_MSG_RESULT($CC_SHARED_OPTS)
5192                 CFLAGS="$cf_save_CFLAGS"
5193         fi
5194
5195         cf_cv_shlib_version_infix=no
5196
5197         case $cf_cv_system_name in #(vi
5198         aix4.[3-9]*|aix[[5-7]]*) #(vi
5199                 if test "$GCC" = yes; then
5200                         CC_SHARED_OPTS=
5201                         MK_SHARED_LIB='${CC} -shared -Wl,-brtl -Wl,-blibpath:${RPATH_LIST}:/usr/lib -o [$]@'
5202                 else
5203                         # CC_SHARED_OPTS='-qpic=large -G'
5204                         # perhaps "-bM:SRE -bnoentry -bexpall"
5205                         MK_SHARED_LIB='${CC} -G -Wl,-brtl -Wl,-blibpath:${RPATH_LIST}:/usr/lib -o [$]@'
5206                 fi
5207                 ;;
5208         beos*) #(vi
5209                 MK_SHARED_LIB='${CC} ${CFLAGS} -o $[@] -Xlinker -soname=`basename $[@]` -nostart -e 0'
5210                 ;;
5211         cygwin*) #(vi
5212                 CC_SHARED_OPTS=
5213                 MK_SHARED_LIB='sh ../mk_shared_lib.sh [$]@ [$]{CC} [$]{CFLAGS}'
5214                 cf_cv_shlib_version=cygdll
5215                 cf_cv_shlib_version_infix=cygdll
5216                 cat >mk_shared_lib.sh <<-CF_EOF
5217                 #!/bin/sh
5218                 SHARED_LIB=\[$]1
5219                 IMPORT_LIB=\`echo "\[$]1" | sed -e 's/cyg/lib/' -e 's/[[0-9]]*\.dll[$]/.dll.a/'\`
5220                 shift
5221                 cat <<-EOF
5222                 Linking shared library
5223                 ** SHARED_LIB \[$]SHARED_LIB
5224                 ** IMPORT_LIB \[$]IMPORT_LIB
5225 EOF
5226                 exec \[$]* -shared -Wl,--out-implib=../lib/\[$]{IMPORT_LIB} -Wl,--export-all-symbols -o ../lib/\[$]{SHARED_LIB}
5227 CF_EOF
5228                 chmod +x mk_shared_lib.sh
5229                 ;;
5230         darwin*) #(vi
5231                 EXTRA_CFLAGS="-no-cpp-precomp"
5232                 CC_SHARED_OPTS="-dynamic"
5233                 MK_SHARED_LIB='${CC} ${CFLAGS} -dynamiclib -install_name ${libdir}/`basename $[@]` -compatibility_version ${ABI_VERSION} -current_version ${ABI_VERSION} -o $[@]'
5234                 test "$cf_cv_shlib_version" = auto && cf_cv_shlib_version=abi
5235                 cf_cv_shlib_version_infix=yes
5236                 AC_CACHE_CHECK([if ld -search_paths_first works], cf_cv_ldflags_search_paths_first, [
5237                         cf_save_LDFLAGS=$LDFLAGS
5238                         LDFLAGS="$LDFLAGS -Wl,-search_paths_first"
5239                         AC_TRY_LINK(, [int i;], cf_cv_ldflags_search_paths_first=yes, cf_cv_ldflags_search_paths_first=no)
5240                                 LDFLAGS=$cf_save_LDFLAGS])
5241                 if test $cf_cv_ldflags_search_paths_first = yes; then
5242                         LDFLAGS="$LDFLAGS -Wl,-search_paths_first"
5243                 fi
5244                 ;;
5245         hpux*) #(vi
5246                 # (tested with gcc 2.7.2 -- I don't have c89)
5247                 if test "$GCC" = yes; then
5248                         LD_SHARED_OPTS='-Xlinker +b -Xlinker ${libdir}'
5249                 else
5250                         CC_SHARED_OPTS='+Z'
5251                         LD_SHARED_OPTS='-Wl,+b,${libdir}'
5252                 fi
5253                 MK_SHARED_LIB='${LD} +b ${libdir} -b -o $[@]'
5254                 # HP-UX shared libraries must be executable, and should be
5255                 # readonly to exploit a quirk in the memory manager.
5256                 INSTALL_LIB="-m 555"
5257                 ;;
5258         interix*)
5259                 test "$cf_cv_shlib_version" = auto && cf_cv_shlib_version=rel
5260                 if test "$cf_cv_shlib_version" = rel; then
5261                         cf_shared_soname='`basename $@ .${REL_VERSION}`.${ABI_VERSION}'
5262                 else
5263                         cf_shared_soname='`basename $@`'
5264                 fi
5265                 CC_SHARED_OPTS=
5266                 MK_SHARED_LIB='${CC} -shared -Wl,-rpath,${RPATH_LIST} -Wl,-h,'$cf_shared_soname' -o $@'
5267                 ;;
5268         irix*) #(vi
5269                 if test "$cf_cv_enable_rpath" = yes ; then
5270                         EXTRA_LDFLAGS="${cf_ld_rpath_opt}\${RPATH_LIST} $EXTRA_LDFLAGS"
5271                 fi
5272                 # tested with IRIX 5.2 and 'cc'.
5273                 if test "$GCC" != yes; then
5274                         CC_SHARED_OPTS='-KPIC'
5275                         MK_SHARED_LIB='${CC} -shared -rdata_shared -soname `basename $[@]` -o $[@]'
5276                 else
5277                         MK_SHARED_LIB='${CC} -shared -Wl,-soname,`basename $[@]` -o $[@]'
5278                 fi
5279                 cf_cv_rm_so_locs=yes
5280                 ;;
5281         linux*|gnu*|k*bsd*-gnu) #(vi
5282                 if test "$DFT_LWR_MODEL" = "shared" ; then
5283                         LOCAL_LDFLAGS="${LD_RPATH_OPT}\$(LOCAL_LIBDIR)"
5284                         LOCAL_LDFLAGS2="$LOCAL_LDFLAGS"
5285                 fi
5286                 if test "$cf_cv_enable_rpath" = yes ; then
5287                         EXTRA_LDFLAGS="${cf_ld_rpath_opt}\${RPATH_LIST} $EXTRA_LDFLAGS"
5288                 fi
5289                 CF_SHARED_SONAME
5290                 MK_SHARED_LIB='${CC} ${CFLAGS} -shared -Wl,-soname,'$cf_cv_shared_soname',-stats,-lc -o $[@]'
5291                 ;;
5292         openbsd[[2-9]].*|mirbsd*) #(vi
5293                 if test "$DFT_LWR_MODEL" = "shared" ; then
5294                         LOCAL_LDFLAGS="${LD_RPATH_OPT}\$(LOCAL_LIBDIR)"
5295                         LOCAL_LDFLAGS2="$LOCAL_LDFLAGS"
5296                 fi
5297                 if test "$cf_cv_enable_rpath" = yes ; then
5298                         EXTRA_LDFLAGS="${cf_ld_rpath_opt}\${RPATH_LIST} $EXTRA_LDFLAGS"
5299                 fi
5300                 CC_SHARED_OPTS="$CC_SHARED_OPTS -DPIC"
5301                 CF_SHARED_SONAME
5302                 MK_SHARED_LIB='${CC} ${CFLAGS} -shared -Wl,-Bshareable,-soname,'$cf_cv_shared_soname',-stats,-lc -o $[@]'
5303                 ;;
5304         nto-qnx*|openbsd*|freebsd[[12]].*) #(vi
5305                 CC_SHARED_OPTS="$CC_SHARED_OPTS -DPIC"
5306                 MK_SHARED_LIB='${LD} -Bshareable -o $[@]'
5307                 test "$cf_cv_shlib_version" = auto && cf_cv_shlib_version=rel
5308                 ;;
5309         dragonfly*|freebsd*) #(vi
5310                 CC_SHARED_OPTS="$CC_SHARED_OPTS -DPIC"
5311                 if test "$DFT_LWR_MODEL" = "shared" && test "$cf_cv_enable_rpath" = yes ; then
5312                         LOCAL_LDFLAGS="${cf_ld_rpath_opt}\$(LOCAL_LIBDIR)"
5313                         LOCAL_LDFLAGS2="${cf_ld_rpath_opt}\${RPATH_LIST} $LOCAL_LDFLAGS"
5314                         EXTRA_LDFLAGS="${cf_ld_rpath_opt}\${RPATH_LIST} $EXTRA_LDFLAGS"
5315                 fi
5316                 CF_SHARED_SONAME
5317                 MK_SHARED_LIB='${LD} -shared -Bshareable -soname=`basename $[@]` -o $[@]'
5318                 ;;
5319         netbsd*) #(vi
5320                 CC_SHARED_OPTS="$CC_SHARED_OPTS -DPIC"
5321                 if test "$DFT_LWR_MODEL" = "shared" && test "$cf_cv_enable_rpath" = yes ; then
5322                         LOCAL_LDFLAGS="${cf_ld_rpath_opt}\$(LOCAL_LIBDIR)"
5323                         LOCAL_LDFLAGS2="$LOCAL_LDFLAGS"
5324                         EXTRA_LDFLAGS="${cf_ld_rpath_opt}\${RPATH_LIST} $EXTRA_LDFLAGS"
5325                         if test "$cf_cv_shlib_version" = auto; then
5326                         if test -f /usr/libexec/ld.elf_so; then
5327                                 cf_cv_shlib_version=abi
5328                         else
5329                                 cf_cv_shlib_version=rel
5330                         fi
5331                         fi
5332                         CF_SHARED_SONAME
5333                         MK_SHARED_LIB='${CC} ${CFLAGS} -shared -Wl,-soname,'$cf_cv_shared_soname' -o $[@]'
5334                 else
5335                         MK_SHARED_LIB='${LD} -shared -Bshareable -o $[@]'
5336                 fi
5337                 ;;
5338         osf*|mls+*) #(vi
5339                 # tested with OSF/1 V3.2 and 'cc'
5340                 # tested with OSF/1 V3.2 and gcc 2.6.3 (but the c++ demo didn't
5341                 # link with shared libs).
5342                 MK_SHARED_LIB='${LD} -set_version ${REL_VERSION}:${ABI_VERSION} -expect_unresolved "*" -shared -soname `basename $[@]`'
5343                 case $host_os in #(vi
5344                 osf4*)
5345                         MK_SHARED_LIB="${MK_SHARED_LIB} -msym"
5346                         ;;
5347                 esac
5348                 MK_SHARED_LIB="${MK_SHARED_LIB}"' -o $[@]'
5349                 if test "$DFT_LWR_MODEL" = "shared" ; then
5350                         LOCAL_LDFLAGS="${LD_RPATH_OPT}\$(LOCAL_LIBDIR)"
5351                         LOCAL_LDFLAGS2="$LOCAL_LDFLAGS"
5352                 fi
5353                 cf_cv_rm_so_locs=yes
5354                 ;;
5355         sco3.2v5*)  # (also uw2* and UW7: hops 13-Apr-98
5356                 # tested with osr5.0.5
5357                 if test "$GCC" != yes; then
5358                         CC_SHARED_OPTS='-belf -KPIC'
5359                 fi
5360                 MK_SHARED_LIB='${LD} -dy -G -h `basename $[@] .${REL_VERSION}`.${ABI_VERSION} -o [$]@'
5361                 if test "$cf_cv_enable_rpath" = yes ; then
5362                         # only way is to set LD_RUN_PATH but no switch for it
5363                         RUN_PATH=$libdir
5364                 fi
5365                 test "$cf_cv_shlib_version" = auto && cf_cv_shlib_version=rel
5366                 LINK_PROGS='LD_RUN_PATH=${libdir}'
5367                 LINK_TESTS='Pwd=`pwd`;LD_RUN_PATH=`dirname $${Pwd}`/lib'
5368                 ;;
5369         sunos4*) #(vi
5370                 # tested with SunOS 4.1.1 and gcc 2.7.0
5371                 if test "$GCC" != yes; then
5372                         CC_SHARED_OPTS='-KPIC'
5373                 fi
5374                 MK_SHARED_LIB='${LD} -assert pure-text -o $[@]'
5375                 test "$cf_cv_shlib_version" = auto && cf_cv_shlib_version=rel
5376                 ;;
5377         solaris2*) #(vi
5378                 # tested with SunOS 5.5.1 (solaris 2.5.1) and gcc 2.7.2
5379                 # tested with SunOS 5.10 (solaris 10) and gcc 3.4.3
5380                 if test "$DFT_LWR_MODEL" = "shared" ; then
5381                         LOCAL_LDFLAGS="-R \$(LOCAL_LIBDIR):\${libdir}"
5382                         LOCAL_LDFLAGS2="$LOCAL_LDFLAGS"
5383                 fi
5384                 if test "$cf_cv_enable_rpath" = yes ; then
5385                         EXTRA_LDFLAGS="-R \${libdir} $EXTRA_LDFLAGS"
5386                 fi
5387                 CF_SHARED_SONAME
5388                 if test "$GCC" != yes; then
5389                         cf_save_CFLAGS="$CFLAGS"
5390                         for cf_shared_opts in -xcode=pic32 -xcode=pic13 -KPIC -Kpic -O
5391                         do
5392                                 CFLAGS="$cf_shared_opts $cf_save_CFLAGS"
5393                                 AC_TRY_COMPILE([#include <stdio.h>],[printf("Hello\n");],[break])
5394                         done
5395                         CFLAGS="$cf_save_CFLAGS"
5396                         CC_SHARED_OPTS=$cf_shared_opts
5397                         MK_SHARED_LIB='${CC} -dy -G -h '$cf_cv_shared_soname' -o $[@]'
5398                 else
5399                         MK_SHARED_LIB='${CC} -shared -dy -G -h '$cf_cv_shared_soname' -o $[@]'
5400                 fi
5401                 ;;
5402         sysv5uw7*|unix_sv*) #(vi
5403                 # tested with UnixWare 7.1.0 (gcc 2.95.2 and cc)
5404                 if test "$GCC" != yes; then
5405                         CC_SHARED_OPTS='-KPIC'
5406                 fi
5407                 MK_SHARED_LIB='${LD} -d y -G -o [$]@'
5408                 ;;
5409         *)
5410                 CC_SHARED_OPTS='unknown'
5411                 MK_SHARED_LIB='echo unknown'
5412                 ;;
5413         esac
5414
5415         # This works if the last tokens in $MK_SHARED_LIB are the -o target.
5416         case "$cf_cv_shlib_version" in #(vi
5417         rel|abi)
5418                 case "$MK_SHARED_LIB" in #(vi
5419                 *'-o $[@]') #(vi
5420                         test "$cf_cv_do_symlinks" = no && cf_cv_do_symlinks=yes
5421                         ;;
5422                 *)
5423                         AC_MSG_WARN(ignored --with-shlib-version)
5424                         ;;
5425                 esac
5426                 ;;
5427         esac
5428
5429         # RPATH_LIST is a colon-separated list of directories
5430         test -n "$cf_ld_rpath_opt" && MK_SHARED_LIB="$MK_SHARED_LIB $cf_ld_rpath_opt\${RPATH_LIST}"
5431         test -z "$RPATH_LIST" && RPATH_LIST="\${libdir}"
5432
5433         AC_SUBST(CC_SHARED_OPTS)
5434         AC_SUBST(LD_RPATH_OPT)
5435         AC_SUBST(LD_SHARED_OPTS)
5436         AC_SUBST(MK_SHARED_LIB)
5437         AC_SUBST(LINK_PROGS)
5438         AC_SUBST(LINK_TESTS)
5439         AC_SUBST(EXTRA_LDFLAGS)
5440         AC_SUBST(LOCAL_LDFLAGS)
5441         AC_SUBST(LOCAL_LDFLAGS2)
5442         AC_SUBST(INSTALL_LIB)
5443         AC_SUBST(RPATH_LIST)
5444 ])dnl
5445 dnl ---------------------------------------------------------------------------
5446 dnl CF_SHARED_SONAME version: 3 updated: 2008/09/08 18:34:43
5447 dnl ----------------
5448 dnl utility macro for CF_SHARED_OPTS, constructs "$cf_cv_shared_soname" for
5449 dnl substitution into MK_SHARED_LIB string for the "-soname" (or similar)
5450 dnl option.
5451 dnl
5452 dnl $1 is the default that should be used for "$cf_cv_shlib_version".
5453 dnl If missing, use "rel".
5454 define([CF_SHARED_SONAME],
5455 [
5456         test "$cf_cv_shlib_version" = auto && cf_cv_shlib_version=ifelse($1,,rel,$1)
5457         if test "$cf_cv_shlib_version" = rel; then
5458                 cf_cv_shared_soname='`basename $[@] .${REL_VERSION}`.${ABI_VERSION}'
5459         else
5460                 cf_cv_shared_soname='`basename $[@]`'
5461         fi
5462 ])
5463 dnl ---------------------------------------------------------------------------
5464 dnl CF_SIGWINCH version: 1 updated: 2006/04/02 16:41:09
5465 dnl -----------
5466 dnl Use this macro after CF_XOPEN_SOURCE, but do not require it (not all
5467 dnl programs need this test).
5468 dnl
5469 dnl This is really a MacOS X 10.4.3 workaround.  Defining _POSIX_C_SOURCE
5470 dnl forces SIGWINCH to be undefined (breaks xterm, ncurses).  Oddly, the struct
5471 dnl winsize declaration is left alone - we may revisit this if Apple choose to
5472 dnl break that part of the interface as well.
5473 AC_DEFUN([CF_SIGWINCH],
5474 [
5475 AC_CACHE_CHECK(if SIGWINCH is defined,cf_cv_define_sigwinch,[
5476         AC_TRY_COMPILE([
5477 #include <sys/types.h>
5478 #include <sys/signal.h>
5479 ],[int x = SIGWINCH],
5480         [cf_cv_define_sigwinch=yes],
5481         [AC_TRY_COMPILE([
5482 #undef _XOPEN_SOURCE
5483 #undef _POSIX_SOURCE
5484 #undef _POSIX_C_SOURCE
5485 #include <sys/types.h>
5486 #include <sys/signal.h>
5487 ],[int x = SIGWINCH],
5488         [cf_cv_define_sigwinch=maybe],
5489         [cf_cv_define_sigwinch=no])
5490 ])
5491 ])
5492
5493 if test "$cf_cv_define_sigwinch" = maybe ; then
5494 AC_CACHE_CHECK(for actual SIGWINCH definition,cf_cv_fixup_sigwinch,[
5495 cf_cv_fixup_sigwinch=unknown
5496 cf_sigwinch=32
5497 while test $cf_sigwinch != 1
5498 do
5499         AC_TRY_COMPILE([
5500 #undef _XOPEN_SOURCE
5501 #undef _POSIX_SOURCE
5502 #undef _POSIX_C_SOURCE
5503 #include <sys/types.h>
5504 #include <sys/signal.h>
5505 ],[
5506 #if SIGWINCH != $cf_sigwinch
5507 make an error
5508 #endif
5509 int x = SIGWINCH],
5510         [cf_cv_fixup_sigwinch=$cf_sigwinch
5511          break])
5512
5513 cf_sigwinch=`expr $cf_sigwinch - 1`
5514 done
5515 ])
5516
5517         if test "$cf_cv_fixup_sigwinch" != unknown ; then
5518                 CPPFLAGS="$CPPFLAGS -DSIGWINCH=$cf_cv_fixup_sigwinch"
5519         fi
5520 fi
5521 ])dnl
5522 dnl ---------------------------------------------------------------------------
5523 dnl CF_SIG_ATOMIC_T version: 2 updated: 2005/09/18 17:27:12
5524 dnl ---------------
5525 dnl signal handler, but there are some gcc depedencies in that recommendation.
5526 dnl Try anyway.
5527 AC_DEFUN([CF_SIG_ATOMIC_T],
5528 [
5529 AC_MSG_CHECKING(for signal global datatype)
5530 AC_CACHE_VAL(cf_cv_sig_atomic_t,[
5531         for cf_type in \
5532                 "volatile sig_atomic_t" \
5533                 "sig_atomic_t" \
5534                 "int"
5535         do
5536         AC_TRY_COMPILE([
5537 #include <sys/types.h>
5538 #include <signal.h>
5539 #include <stdio.h>
5540
5541 extern $cf_type x;
5542 $cf_type x;
5543 static void handler(int sig)
5544 {
5545         x = 5;
5546 }],
5547                 [signal(SIGINT, handler);
5548                  x = 1],
5549                 [cf_cv_sig_atomic_t=$cf_type],
5550                 [cf_cv_sig_atomic_t=no])
5551                 test "$cf_cv_sig_atomic_t" != no && break
5552         done
5553         ])
5554 AC_MSG_RESULT($cf_cv_sig_atomic_t)
5555 test "$cf_cv_sig_atomic_t" != no && AC_DEFINE_UNQUOTED(SIG_ATOMIC_T, $cf_cv_sig_atomic_t)
5556 ])dnl
5557 dnl ---------------------------------------------------------------------------
5558 dnl CF_SIZECHANGE version: 8 updated: 2000/11/04 12:22:16
5559 dnl -------------
5560 dnl Check for definitions & structures needed for window size-changing
5561 dnl FIXME: check that this works with "snake" (HP-UX 10.x)
5562 AC_DEFUN([CF_SIZECHANGE],
5563 [
5564 AC_REQUIRE([CF_STRUCT_TERMIOS])
5565 AC_CACHE_CHECK(declaration of size-change, cf_cv_sizechange,[
5566     cf_cv_sizechange=unknown
5567     cf_save_CPPFLAGS="$CPPFLAGS"
5568
5569 for cf_opts in "" "NEED_PTEM_H"
5570 do
5571
5572     CPPFLAGS="$cf_save_CPPFLAGS"
5573     test -n "$cf_opts" && CPPFLAGS="$CPPFLAGS -D$cf_opts"
5574     AC_TRY_COMPILE([#include <sys/types.h>
5575 #ifdef HAVE_TERMIOS_H
5576 #include <termios.h>
5577 #else
5578 #ifdef HAVE_TERMIO_H
5579 #include <termio.h>
5580 #endif
5581 #endif
5582 #ifdef NEED_PTEM_H
5583 /* This is a workaround for SCO:  they neglected to define struct winsize in
5584  * termios.h -- it's only in termio.h and ptem.h
5585  */
5586 #include        <sys/stream.h>
5587 #include        <sys/ptem.h>
5588 #endif
5589 #if !defined(sun) || !defined(HAVE_TERMIOS_H)
5590 #include <sys/ioctl.h>
5591 #endif
5592 ],[
5593 #ifdef TIOCGSIZE
5594         struct ttysize win;     /* FIXME: what system is this? */
5595         int y = win.ts_lines;
5596         int x = win.ts_cols;
5597 #else
5598 #ifdef TIOCGWINSZ
5599         struct winsize win;
5600         int y = win.ws_row;
5601         int x = win.ws_col;
5602 #else
5603         no TIOCGSIZE or TIOCGWINSZ
5604 #endif /* TIOCGWINSZ */
5605 #endif /* TIOCGSIZE */
5606         ],
5607         [cf_cv_sizechange=yes],
5608         [cf_cv_sizechange=no])
5609
5610         CPPFLAGS="$cf_save_CPPFLAGS"
5611         if test "$cf_cv_sizechange" = yes ; then
5612                 echo "size-change succeeded ($cf_opts)" >&AC_FD_CC
5613                 test -n "$cf_opts" && cf_cv_sizechange="$cf_opts"
5614                 break
5615         fi
5616 done
5617 ])
5618 if test "$cf_cv_sizechange" != no ; then
5619         AC_DEFINE(HAVE_SIZECHANGE)
5620         case $cf_cv_sizechange in #(vi
5621         NEED*)
5622                 AC_DEFINE_UNQUOTED($cf_cv_sizechange )
5623                 ;;
5624         esac
5625 fi
5626 ])dnl
5627 dnl ---------------------------------------------------------------------------
5628 dnl CF_SRC_MODULES version: 21 updated: 2010/09/04 17:37:40
5629 dnl --------------
5630 dnl For each parameter, test if the source-directory exists, and if it contains
5631 dnl a 'modules' file.  If so, add to the list $cf_cv_src_modules which we'll
5632 dnl use in CF_LIB_RULES.
5633 dnl
5634 dnl This uses the configured value to make the lists SRC_SUBDIRS and
5635 dnl SUB_MAKEFILES which are used in the makefile-generation scheme.
5636 AC_DEFUN([CF_SRC_MODULES],
5637 [
5638 AC_MSG_CHECKING(for src modules)
5639
5640 # dependencies and linker-arguments for test-programs
5641 TEST_DEPS="${LIB_DIR}/${LIB_PREFIX}${LIB_NAME}${DFT_DEP_SUFFIX} $TEST_DEPS"
5642 TEST_DEP2="${LIB_2ND}/${LIB_PREFIX}${LIB_NAME}${DFT_DEP_SUFFIX} $TEST_DEP2"
5643 if test "$DFT_LWR_MODEL" = "libtool"; then
5644         TEST_ARGS="${TEST_DEPS}"
5645         TEST_ARG2="${TEST_DEP2}"
5646 else
5647         TEST_ARGS="-l${LIB_NAME}${DFT_ARG_SUFFIX} $TEST_ARGS"
5648         TEST_ARG2="-l${LIB_NAME}${DFT_ARG_SUFFIX} $TEST_ARG2"
5649 fi
5650
5651 cf_cv_src_modules=
5652 for cf_dir in $1
5653 do
5654         if test -f $srcdir/$cf_dir/modules; then
5655
5656                 # We may/may not have tack in the distribution, though the
5657                 # makefile is.
5658                 if test $cf_dir = tack ; then
5659                         if test ! -f $srcdir/${cf_dir}/${cf_dir}.h; then
5660                                 continue
5661                         fi
5662                 fi
5663
5664                 if test -z "$cf_cv_src_modules"; then
5665                         cf_cv_src_modules=$cf_dir
5666                 else
5667                         cf_cv_src_modules="$cf_cv_src_modules $cf_dir"
5668                 fi
5669
5670                 # Make the ncurses_cfg.h file record the library interface files as
5671                 # well.  These are header files that are the same name as their
5672                 # directory.  Ncurses is the only library that does not follow
5673                 # that pattern.
5674                 if test $cf_dir = tack ; then
5675                         continue
5676                 elif test -f $srcdir/${cf_dir}/${cf_dir}.h; then
5677                         CF_UPPER(cf_have_include,$cf_dir)
5678                         AC_DEFINE_UNQUOTED(HAVE_${cf_have_include}_H)
5679                         AC_DEFINE_UNQUOTED(HAVE_LIB${cf_have_include})
5680                         TEST_DEPS="${LIB_DIR}/${LIB_PREFIX}${cf_dir}${DFT_DEP_SUFFIX} $TEST_DEPS"
5681                         TEST_DEP2="${LIB_2ND}/${LIB_PREFIX}${cf_dir}${DFT_DEP_SUFFIX} $TEST_DEP2"
5682                         if test "$DFT_LWR_MODEL" = "libtool"; then
5683                                 TEST_ARGS="${TEST_DEPS}"
5684                                 TEST_ARG2="${TEST_DEP2}"
5685                         else
5686                                 TEST_ARGS="-l${cf_dir}${DFT_ARG_SUFFIX} $TEST_ARGS"
5687                                 TEST_ARG2="-l${cf_dir}${DFT_ARG_SUFFIX} $TEST_ARG2"
5688                         fi
5689                 fi
5690         fi
5691 done
5692 AC_MSG_RESULT($cf_cv_src_modules)
5693
5694 TEST_ARGS="-L${LIB_DIR} $TEST_ARGS"
5695 TEST_ARG2="-L${LIB_2ND} $TEST_ARG2"
5696
5697 AC_SUBST(TEST_ARGS)
5698 AC_SUBST(TEST_DEPS)
5699
5700 AC_SUBST(TEST_ARG2)
5701 AC_SUBST(TEST_DEP2)
5702
5703 SRC_SUBDIRS=
5704 if test "x$cf_with_manpages" != xno ; then
5705         SRC_SUBDIRS="$SRC_SUBDIRS man"
5706 fi
5707 SRC_SUBDIRS="$SRC_SUBDIRS include"
5708 for cf_dir in $cf_cv_src_modules
5709 do
5710         SRC_SUBDIRS="$SRC_SUBDIRS $cf_dir"
5711 done
5712 if test "x$cf_with_tests" != "xno" ; then
5713         SRC_SUBDIRS="$SRC_SUBDIRS test"
5714 fi
5715 test -z "$MAKE_TERMINFO" && SRC_SUBDIRS="$SRC_SUBDIRS misc"
5716 test "$cf_with_cxx_binding" != no && SRC_SUBDIRS="$SRC_SUBDIRS c++"
5717
5718 ADA_SUBDIRS=
5719 if test "$cf_cv_prog_gnat_correct" = yes && test -f $srcdir/Ada95/Makefile.in; then
5720         SRC_SUBDIRS="$SRC_SUBDIRS Ada95"
5721         ADA_SUBDIRS="gen src"
5722         if test "x$cf_with_tests" != "xno" ; then
5723                 ADA_SUBDIRS="$ADA_SUBDIRS samples"
5724         fi
5725 fi
5726
5727 SUB_MAKEFILES=
5728 for cf_dir in $SRC_SUBDIRS
5729 do
5730         SUB_MAKEFILES="$SUB_MAKEFILES $cf_dir/Makefile"
5731 done
5732
5733 if test -n "$ADA_SUBDIRS"; then
5734         for cf_dir in $ADA_SUBDIRS
5735         do
5736                 SUB_MAKEFILES="$SUB_MAKEFILES Ada95/$cf_dir/Makefile"
5737         done
5738         AC_SUBST(ADA_SUBDIRS)
5739 fi
5740 ])dnl
5741 dnl ---------------------------------------------------------------------------
5742 dnl CF_STDCPP_LIBRARY version: 7 updated: 2010/05/29 16:31:02
5743 dnl -----------------
5744 dnl Check for -lstdc++, which is GNU's standard C++ library.
5745 AC_DEFUN([CF_STDCPP_LIBRARY],
5746 [
5747 if test -n "$GXX" ; then
5748 case $cf_cv_system_name in #(vi
5749 os2*) #(vi
5750         cf_stdcpp_libname=stdcpp
5751         ;;
5752 *)
5753         cf_stdcpp_libname=stdc++
5754         ;;
5755 esac
5756 AC_CACHE_CHECK(for library $cf_stdcpp_libname,cf_cv_libstdcpp,[
5757         cf_save="$LIBS"
5758         CF_ADD_LIB($cf_stdcpp_libname)
5759 AC_TRY_LINK([
5760 #include <strstream.h>],[
5761 char buf[80];
5762 strstreambuf foo(buf, sizeof(buf))
5763 ],
5764         [cf_cv_libstdcpp=yes],
5765         [cf_cv_libstdcpp=no])
5766         LIBS="$cf_save"
5767 ])
5768 test "$cf_cv_libstdcpp" = yes && CF_ADD_LIB($cf_stdcpp_libname,CXXLIBS)
5769 fi
5770 ])dnl
5771 dnl ---------------------------------------------------------------------------
5772 dnl CF_STRIP_G_OPT version: 3 updated: 2002/12/21 19:25:52
5773 dnl --------------
5774 dnl     Remove "-g" option from the compiler options
5775 AC_DEFUN([CF_STRIP_G_OPT],
5776 [$1=`echo ${$1} | sed -e 's%-g %%' -e 's%-g$%%'`])dnl
5777 dnl ---------------------------------------------------------------------------
5778 dnl CF_STRUCT_SIGACTION version: 4 updated: 2011/04/16 11:52:53
5779 dnl -------------------
5780 dnl Check if we need _POSIX_SOURCE defined to use struct sigaction.  We'll only
5781 dnl do this if we've found the sigaction function.
5782 AC_DEFUN([CF_STRUCT_SIGACTION],[
5783 AC_REQUIRE([CF_XOPEN_SOURCE])
5784
5785 if test "$ac_cv_func_sigaction" = yes; then
5786 AC_MSG_CHECKING(whether sigaction needs _POSIX_SOURCE)
5787 AC_TRY_COMPILE([
5788 #include <sys/types.h>
5789 #include <signal.h>],
5790         [struct sigaction act],
5791         [sigact_bad=no],
5792         [
5793 AC_TRY_COMPILE([
5794 #define _POSIX_SOURCE
5795 #include <sys/types.h>
5796 #include <signal.h>],
5797         [struct sigaction act],
5798         [sigact_bad=yes
5799          AC_DEFINE(_POSIX_SOURCE)],
5800          [sigact_bad=unknown])])
5801 AC_MSG_RESULT($sigact_bad)
5802 fi
5803 ])dnl
5804 dnl ---------------------------------------------------------------------------
5805 dnl CF_STRUCT_TERMIOS version: 6 updated: 2011/04/16 11:52:53
5806 dnl -----------------
5807 dnl Some machines require _POSIX_SOURCE to completely define struct termios.
5808 AC_DEFUN([CF_STRUCT_TERMIOS],[
5809 AC_REQUIRE([CF_XOPEN_SOURCE])
5810
5811 AC_CHECK_HEADERS( \
5812 termio.h \
5813 termios.h \
5814 unistd.h \
5815 )
5816
5817 if test "$ISC" = yes ; then
5818         AC_CHECK_HEADERS( sys/termio.h )
5819 fi
5820 if test "$ac_cv_header_termios_h" = yes ; then
5821         case "$CFLAGS $CPPFLAGS" in
5822         *-D_POSIX_SOURCE*)
5823                 termios_bad=dunno ;;
5824         *)      termios_bad=maybe ;;
5825         esac
5826         if test "$termios_bad" = maybe ; then
5827         AC_MSG_CHECKING(whether termios.h needs _POSIX_SOURCE)
5828         AC_TRY_COMPILE([#include <termios.h>],
5829                 [struct termios foo; int x = foo.c_iflag],
5830                 termios_bad=no, [
5831                 AC_TRY_COMPILE([
5832 #define _POSIX_SOURCE
5833 #include <termios.h>],
5834                         [struct termios foo; int x = foo.c_iflag],
5835                         termios_bad=unknown,
5836                         termios_bad=yes AC_DEFINE(_POSIX_SOURCE))
5837                         ])
5838         AC_MSG_RESULT($termios_bad)
5839         fi
5840 fi
5841 ])dnl
5842 dnl ---------------------------------------------------------------------------
5843 dnl CF_SUBDIR_PATH version: 6 updated: 2010/04/21 06:20:50
5844 dnl --------------
5845 dnl Construct a search-list for a nonstandard header/lib-file
5846 dnl     $1 = the variable to return as result
5847 dnl     $2 = the package name
5848 dnl     $3 = the subdirectory, e.g., bin, include or lib
5849 AC_DEFUN([CF_SUBDIR_PATH],
5850 [
5851 $1=
5852
5853 CF_ADD_SUBDIR_PATH($1,$2,$3,/usr,$prefix)
5854 CF_ADD_SUBDIR_PATH($1,$2,$3,$prefix,NONE)
5855 CF_ADD_SUBDIR_PATH($1,$2,$3,/usr/local,$prefix)
5856 CF_ADD_SUBDIR_PATH($1,$2,$3,/opt,$prefix)
5857 CF_ADD_SUBDIR_PATH($1,$2,$3,[$]HOME,$prefix)
5858 ])dnl
5859 dnl ---------------------------------------------------------------------------
5860 dnl CF_SUBST version: 4 updated: 2006/06/17 12:33:03
5861 dnl --------
5862 dnl     Shorthand macro for substituting things that the user may override
5863 dnl     with an environment variable.
5864 dnl
5865 dnl     $1 = long/descriptive name
5866 dnl     $2 = environment variable
5867 dnl     $3 = default value
5868 AC_DEFUN([CF_SUBST],
5869 [AC_CACHE_VAL(cf_cv_subst_$2,[
5870 AC_MSG_CHECKING(for $1 (symbol $2))
5871 CF_SUBST_IF([-z "[$]$2"], [$2], [$3])
5872 cf_cv_subst_$2=[$]$2
5873 AC_MSG_RESULT([$]$2)
5874 ])
5875 ])dnl
5876 dnl ---------------------------------------------------------------------------
5877 dnl CF_SUBST_IF version: 2 updated: 2006/06/17 12:33:03
5878 dnl -----------
5879 dnl     Shorthand macro for substituting things that the user may override
5880 dnl     with an environment variable.
5881 dnl
5882 dnl     $1 = condition to pass to "test"
5883 dnl     $2 = environment variable
5884 dnl     $3 = value if the test succeeds
5885 dnl     $4 = value if the test fails
5886 AC_DEFUN([CF_SUBST_IF],
5887 [
5888 if test $1 ; then
5889         $2=$3
5890 ifelse($4,,,[else
5891         $2=$4])
5892 fi
5893 AC_SUBST($2)
5894 ])dnl
5895 dnl ---------------------------------------------------------------------------
5896 dnl CF_SUBST_NCURSES_VERSION version: 8 updated: 2006/09/16 11:40:59
5897 dnl ------------------------
5898 dnl Get the version-number for use in shared-library naming, etc.
5899 AC_DEFUN([CF_SUBST_NCURSES_VERSION],
5900 [
5901 AC_REQUIRE([CF_PROG_EGREP])
5902 NCURSES_MAJOR="`$ac_cv_prog_egrep '^NCURSES_MAJOR[[     ]]*=' $srcdir/dist.mk | sed -e 's/^[[^0-9]]*//'`"
5903 NCURSES_MINOR="`$ac_cv_prog_egrep '^NCURSES_MINOR[[     ]]*=' $srcdir/dist.mk | sed -e 's/^[[^0-9]]*//'`"
5904 NCURSES_PATCH="`$ac_cv_prog_egrep '^NCURSES_PATCH[[     ]]*=' $srcdir/dist.mk | sed -e 's/^[[^0-9]]*//'`"
5905 cf_cv_abi_version=${NCURSES_MAJOR}
5906 cf_cv_rel_version=${NCURSES_MAJOR}.${NCURSES_MINOR}
5907 dnl Show the computed version, for logging
5908 cf_cv_timestamp=`date`
5909 AC_MSG_RESULT(Configuring NCURSES $cf_cv_rel_version ABI $cf_cv_abi_version ($cf_cv_timestamp))
5910 dnl We need these values in the generated headers
5911 AC_SUBST(NCURSES_MAJOR)
5912 AC_SUBST(NCURSES_MINOR)
5913 AC_SUBST(NCURSES_PATCH)
5914 dnl We need these values in the generated makefiles
5915 AC_SUBST(cf_cv_rel_version)
5916 AC_SUBST(cf_cv_abi_version)
5917 AC_SUBST(cf_cv_builtin_bool)
5918 AC_SUBST(cf_cv_header_stdbool_h)
5919 AC_SUBST(cf_cv_type_of_bool)dnl
5920 ])dnl
5921 dnl ---------------------------------------------------------------------------
5922 dnl CF_SYS_TIME_SELECT version: 4 updated: 2000/10/04 09:18:40
5923 dnl ------------------
5924 dnl Check if we can include <sys/time.h> with <sys/select.h>; this breaks on
5925 dnl older SCO configurations.
5926 AC_DEFUN([CF_SYS_TIME_SELECT],
5927 [
5928 AC_MSG_CHECKING(if sys/time.h works with sys/select.h)
5929 AC_CACHE_VAL(cf_cv_sys_time_select,[
5930 AC_TRY_COMPILE([
5931 #include <sys/types.h>
5932 #ifdef HAVE_SYS_TIME_H
5933 #include <sys/time.h>
5934 #endif
5935 #ifdef HAVE_SYS_SELECT_H
5936 #include <sys/select.h>
5937 #endif
5938 ],[],[cf_cv_sys_time_select=yes],
5939      [cf_cv_sys_time_select=no])
5940      ])
5941 AC_MSG_RESULT($cf_cv_sys_time_select)
5942 test "$cf_cv_sys_time_select" = yes && AC_DEFINE(HAVE_SYS_TIME_SELECT)
5943 ])dnl
5944 dnl ---------------------------------------------------------------------------
5945 dnl CF_TOP_BUILDDIR version: 1 updated: 2006/10/15 16:33:23
5946 dnl ---------------
5947 dnl Define a top_builddir symbol, for applications that need an absolute path.
5948 AC_DEFUN([CF_TOP_BUILDDIR],
5949 [
5950 top_builddir=`pwd`
5951 AC_SUBST(top_builddir)
5952 ])dnl
5953 dnl ---------------------------------------------------------------------------
5954 dnl CF_TYPEOF_CHTYPE version: 8 updated: 2006/12/16 12:33:30
5955 dnl ----------------
5956 dnl Determine the type we should use for chtype (and attr_t, which is treated
5957 dnl as the same thing).  We want around 32 bits, so on most machines want a
5958 dnl long, but on newer 64-bit machines, probably want an int.  If we're using
5959 dnl wide characters, we have to have a type compatible with that, as well.
5960 AC_DEFUN([CF_TYPEOF_CHTYPE],
5961 [
5962 AC_MSG_CHECKING([for type of chtype])
5963 AC_CACHE_VAL(cf_cv_typeof_chtype,[
5964                 AC_TRY_RUN([
5965 #define WANT_BITS 31
5966 #include <stdio.h>
5967 int main()
5968 {
5969         FILE *fp = fopen("cf_test.out", "w");
5970         if (fp != 0) {
5971                 char *result = "long";
5972                 if (sizeof(unsigned long) > sizeof(unsigned int)) {
5973                         int n;
5974                         unsigned int x, y;
5975                         for (n = 0; n < WANT_BITS; n++) {
5976                                 x = (1 << n);
5977                                 y = (x >> n);
5978                                 if (y != 1 || x == 0) {
5979                                         x = 0;
5980                                         break;
5981                                 }
5982                         }
5983                         /*
5984                          * If x is nonzero, an int is big enough for the bits
5985                          * that we want.
5986                          */
5987                         result = (x != 0) ? "int" : "long";
5988                 }
5989                 fputs(result, fp);
5990                 fclose(fp);
5991         }
5992         ${cf_cv_main_return:-return}(0);
5993 }
5994                 ],
5995                 [cf_cv_typeof_chtype=`cat cf_test.out`],
5996                 [cf_cv_typeof_chtype=long],
5997                 [cf_cv_typeof_chtype=long])
5998                 rm -f cf_test.out
5999         ])
6000 AC_MSG_RESULT($cf_cv_typeof_chtype)
6001
6002 AC_SUBST(cf_cv_typeof_chtype)
6003 AC_DEFINE_UNQUOTED(TYPEOF_CHTYPE,$cf_cv_typeof_chtype)
6004 ])dnl
6005 dnl ---------------------------------------------------------------------------
6006 dnl CF_TYPE_SIGACTION version: 3 updated: 2000/08/12 23:18:52
6007 dnl -----------------
6008 dnl
6009 AC_DEFUN([CF_TYPE_SIGACTION],
6010 [
6011 AC_MSG_CHECKING([for type sigaction_t])
6012 AC_CACHE_VAL(cf_cv_type_sigaction,[
6013         AC_TRY_COMPILE([
6014 #include <signal.h>],
6015                 [sigaction_t x],
6016                 [cf_cv_type_sigaction=yes],
6017                 [cf_cv_type_sigaction=no])])
6018 AC_MSG_RESULT($cf_cv_type_sigaction)
6019 test "$cf_cv_type_sigaction" = yes && AC_DEFINE(HAVE_TYPE_SIGACTION)
6020 ])dnl
6021 dnl ---------------------------------------------------------------------------
6022 dnl CF_UNSIGNED_LITERALS version: 2 updated: 1998/02/07 22:10:16
6023 dnl --------------------
6024 dnl Test if the compiler supports 'U' and 'L' suffixes.  Only old compilers
6025 dnl won't, but they're still there.
6026 AC_DEFUN([CF_UNSIGNED_LITERALS],
6027 [
6028 AC_MSG_CHECKING([if unsigned literals are legal])
6029 AC_CACHE_VAL(cf_cv_unsigned_literals,[
6030         AC_TRY_COMPILE([],[long x = 1L + 1UL + 1U + 1],
6031                 [cf_cv_unsigned_literals=yes],
6032                 [cf_cv_unsigned_literals=no])
6033         ])
6034 AC_MSG_RESULT($cf_cv_unsigned_literals)
6035 ])dnl
6036 dnl ---------------------------------------------------------------------------
6037 dnl CF_UPPER version: 5 updated: 2001/01/29 23:40:59
6038 dnl --------
6039 dnl Make an uppercase version of a variable
6040 dnl $1=uppercase($2)
6041 AC_DEFUN([CF_UPPER],
6042 [
6043 $1=`echo "$2" | sed y%abcdefghijklmnopqrstuvwxyz./-%ABCDEFGHIJKLMNOPQRSTUVWXYZ___%`
6044 ])dnl
6045 dnl ---------------------------------------------------------------------------
6046 dnl CF_UTF8_LIB version: 7 updated: 2010/06/20 09:24:28
6047 dnl -----------
6048 dnl Check for multibyte support, and if not found, utf8 compatibility library
6049 AC_DEFUN([CF_UTF8_LIB],
6050 [
6051 AC_CACHE_CHECK(for multibyte character support,cf_cv_utf8_lib,[
6052         cf_save_LIBS="$LIBS"
6053         AC_TRY_LINK([
6054 #include <stdlib.h>],[putwc(0,0);],
6055         [cf_cv_utf8_lib=yes],
6056         [CF_FIND_LINKAGE([
6057 #include <libutf8.h>],[putwc(0,0);],utf8,
6058                 [cf_cv_utf8_lib=add-on],
6059                 [cf_cv_utf8_lib=no])
6060 ])])
6061
6062 # HAVE_LIBUTF8_H is used by ncurses if curses.h is shared between
6063 # ncurses/ncursesw:
6064 if test "$cf_cv_utf8_lib" = "add-on" ; then
6065         AC_DEFINE(HAVE_LIBUTF8_H)
6066         CF_ADD_INCDIR($cf_cv_header_path_utf8)
6067         CF_ADD_LIBDIR($cf_cv_library_path_utf8)
6068         CF_ADD_LIBS($cf_cv_library_file_utf8)
6069 fi
6070 ])dnl
6071 dnl ---------------------------------------------------------------------------
6072 dnl CF_VA_COPY version: 2 updated: 2010/03/04 05:37:29
6073 dnl ----------
6074 dnl check for va_copy, part of stdarg.h
6075 dnl Also, workaround for glibc's __va_copy, by checking for both.
6076 AC_DEFUN([CF_VA_COPY],[
6077 AC_CACHE_CHECK(for va_copy, cf_cv_have_va_copy,[
6078 AC_TRY_LINK([
6079 #include <stdarg.h>
6080 ],[
6081         static va_list dst;
6082         static va_list src;
6083         va_copy(dst, src)],
6084         cf_cv_have_va_copy=yes,
6085         cf_cv_have_va_copy=no)])
6086
6087 test "$cf_cv_have_va_copy" = yes && AC_DEFINE(HAVE_VA_COPY)
6088
6089 AC_CACHE_CHECK(for __va_copy, cf_cv_have___va_copy,[
6090 AC_TRY_LINK([
6091 #include <stdarg.h>
6092 ],[
6093         static va_list dst;
6094         static va_list src;
6095         __va_copy(dst, src)],
6096         cf_cv_have___va_copy=yes,
6097         cf_cv_have___va_copy=no)])
6098
6099 test "$cf_cv_have___va_copy" = yes && AC_DEFINE(HAVE___VA_COPY)
6100 ])
6101 dnl ---------------------------------------------------------------------------
6102 dnl CF_VERBOSE version: 3 updated: 2007/07/29 09:55:12
6103 dnl ----------
6104 dnl Use AC_VERBOSE w/o the warnings
6105 AC_DEFUN([CF_VERBOSE],
6106 [test -n "$verbose" && echo "   $1" 1>&AC_FD_MSG
6107 CF_MSG_LOG([$1])
6108 ])dnl
6109 dnl ---------------------------------------------------------------------------
6110 dnl CF_WCHAR_TYPE version: 3 updated: 2010/05/26 16:44:57
6111 dnl -------------
6112 dnl Check if type wide-character type $1 is declared, and if so, which header
6113 dnl file is needed.  The second parameter is used to set a shell variable when
6114 dnl the type is not found.  The first parameter sets a shell variable for the
6115 dnl opposite sense.
6116 AC_DEFUN([CF_WCHAR_TYPE],
6117 [
6118 # This is needed on Tru64 5.0 to declare $1
6119 AC_CACHE_CHECK(if we must include wchar.h to declare $1,cf_cv_$1,[
6120 AC_TRY_COMPILE([
6121 #include <stdlib.h>
6122 #include <stdarg.h>
6123 #include <stdio.h>
6124 #ifdef HAVE_LIBUTF8_H
6125 #include <libutf8.h>
6126 #endif],
6127         [$1 state],
6128         [cf_cv_$1=no],
6129         [AC_TRY_COMPILE([
6130 #include <stdlib.h>
6131 #include <stdarg.h>
6132 #include <stdio.h>
6133 #include <wchar.h>
6134 #ifdef HAVE_LIBUTF8_H
6135 #include <libutf8.h>
6136 #endif],
6137         [$1 value],
6138         [cf_cv_$1=yes],
6139         [cf_cv_$1=unknown])])])
6140
6141 if test "$cf_cv_$1" = yes ; then
6142         AC_DEFINE(NEED_WCHAR_H)
6143         NEED_WCHAR_H=1
6144 fi
6145
6146 ifelse([$2],,,[
6147 # if we do not find $1 in either place, use substitution to provide a fallback.
6148 if test "$cf_cv_$1" = unknown ; then
6149         $2=1
6150 fi
6151 ])
6152 ifelse($3,,,[
6153 # if we find $1 in either place, use substitution to provide a fallback.
6154 if test "$cf_cv_$1" != unknown ; then
6155         $3=1
6156 fi
6157 ])
6158 ])dnl
6159 dnl ---------------------------------------------------------------------------
6160 dnl CF_WEAK_SYMBOLS version: 1 updated: 2008/08/16 19:18:06
6161 dnl ---------------
6162 dnl Check for compiler-support for weak symbols.
6163 dnl This works with "recent" gcc.
6164 AC_DEFUN([CF_WEAK_SYMBOLS],[
6165 AC_CACHE_CHECK(if $CC supports weak symbols,cf_cv_weak_symbols,[
6166
6167 AC_TRY_COMPILE([
6168 #include <stdio.h>],
6169 [
6170 #if defined(__GNUC__)
6171 #  if defined __USE_ISOC99
6172 #    define _cat_pragma(exp)    _Pragma(#exp)
6173 #    define _weak_pragma(exp)   _cat_pragma(weak name)
6174 #  else
6175 #    define _weak_pragma(exp)
6176 #  endif
6177 #  define _declare(name)        __extension__ extern __typeof__(name) name
6178 #  define weak_symbol(name)     _weak_pragma(name) _declare(name) __attribute__((weak))
6179 #endif
6180
6181 weak_symbol(fopen);
6182 ],[cf_cv_weak_symbols=yes],[cf_cv_weak_symbols=no])
6183 ])
6184 ])dnl
6185 dnl ---------------------------------------------------------------------------
6186 dnl CF_WITH_ABI_VERSION version: 1 updated: 2003/09/20 18:12:49
6187 dnl -------------------
6188 dnl Allow library's ABI to be overridden.  Generally this happens when a
6189 dnl packager has incremented the ABI past that used in the original package,
6190 dnl and wishes to keep doing this.
6191 dnl
6192 dnl $1 is the package name, if any, to derive a corresponding {package}_ABI
6193 dnl symbol.
6194 AC_DEFUN([CF_WITH_ABI_VERSION],[
6195 test -z "$cf_cv_abi_version" && cf_cv_abi_version=0
6196 AC_ARG_WITH(abi-version,
6197 [  --with-abi-version=XXX  override derived ABI version],
6198 [AC_MSG_WARN(overriding ABI version $cf_cv_abi_version to $withval)
6199  cf_cv_abi_version=$withval])
6200  CF_NUMBER_SYNTAX($cf_cv_abi_version,ABI version)
6201 ifelse($1,,,[
6202 $1_ABI=$cf_cv_abi_version
6203 ])
6204 ])dnl
6205 dnl ---------------------------------------------------------------------------
6206 dnl CF_WITH_ADA_COMPILER version: 2 updated: 2010/06/26 17:35:58
6207 dnl --------------------
6208 dnl Command-line option to specify the Ada95 compiler.
6209 AC_DEFUN([CF_WITH_ADA_COMPILER],[
6210 AC_MSG_CHECKING(for ada-compiler)
6211 AC_ARG_WITH(ada-compiler,
6212         [  --with-ada-compiler=CMD specify Ada95 compiler command (default gnatmake)],
6213         [cf_ada_compiler=$withval],
6214         [cf_ada_compiler=gnatmake])
6215 AC_SUBST(cf_ada_compiler)
6216 AC_MSG_RESULT($cf_ada_compiler)
6217 ])dnl
6218 dnl ---------------------------------------------------------------------------
6219 dnl CF_WITH_ADA_INCLUDE version: 2 updated: 2010/06/26 17:35:58
6220 dnl -------------------
6221 dnl Command-line option to specify where Ada includes will install.
6222 AC_DEFUN([CF_WITH_ADA_INCLUDE],[
6223 AC_MSG_CHECKING(for ada-include)
6224 CF_WITH_PATH(ada-include,
6225    [  --with-ada-include=DIR  Ada includes are in DIR],
6226    ADA_INCLUDE,
6227    PREFIX/share/ada/adainclude,
6228    [$]prefix/share/ada/adainclude)
6229 AC_SUBST(ADA_INCLUDE)
6230 AC_MSG_RESULT($ADA_INCLUDE)
6231 ])dnl
6232 dnl ---------------------------------------------------------------------------
6233 dnl CF_WITH_ADA_OBJECTS version: 2 updated: 2010/06/26 17:35:58
6234 dnl -------------------
6235 dnl Command-line option to specify where Ada objects will install.
6236 AC_DEFUN([CF_WITH_ADA_OBJECTS],[
6237 AC_MSG_CHECKING(for ada-objects)
6238 CF_WITH_PATH(ada-objects,
6239    [  --with-ada-objects=DIR  Ada objects are in DIR],
6240    ADA_OBJECTS,
6241    PREFIX/lib/ada/adalib,
6242    [$]prefix/lib/ada/adalib)
6243 AC_SUBST(ADA_OBJECTS)
6244 AC_MSG_RESULT($ADA_OBJECTS)
6245 ])dnl
6246 dnl ---------------------------------------------------------------------------
6247 dnl CF_WITH_ADA_SHAREDLIB version: 2 updated: 2010/06/26 17:35:58
6248 dnl ---------------------
6249 dnl Command-line option to specify if an Ada95 shared-library should be built,
6250 dnl and optionally what its soname should be.
6251 AC_DEFUN([CF_WITH_ADA_SHAREDLIB],[
6252 AC_MSG_CHECKING(if an Ada95 shared-library should be built)
6253 AC_ARG_WITH(ada-sharedlib,
6254         [  --with-ada-sharedlib=XX build Ada95 shared-library],
6255         [with_ada_sharedlib=$withval],
6256         [with_ada_sharedlib=no])
6257 AC_MSG_RESULT($with_ada_sharedlib)
6258
6259 ADA_SHAREDLIB='lib$(LIB_NAME).so.1'
6260 MAKE_ADA_SHAREDLIB="#"
6261
6262 if test "x$with_ada_sharedlib" != xno
6263 then
6264         MAKE_ADA_SHAREDLIB=
6265         if test "x$with_ada_sharedlib" != xyes
6266         then
6267                 ADA_SHAREDLIB="$with_ada_sharedlib"
6268         fi
6269 fi
6270
6271 AC_SUBST(ADA_SHAREDLIB)
6272 AC_SUBST(MAKE_ADA_SHAREDLIB)
6273 ])dnl
6274 dnl ---------------------------------------------------------------------------
6275 dnl CF_WITH_DBMALLOC version: 7 updated: 2010/06/21 17:26:47
6276 dnl ----------------
6277 dnl Configure-option for dbmalloc.  The optional parameter is used to override
6278 dnl the updating of $LIBS, e.g., to avoid conflict with subsequent tests.
6279 AC_DEFUN([CF_WITH_DBMALLOC],[
6280 CF_NO_LEAKS_OPTION(dbmalloc,
6281         [  --with-dbmalloc         test: use Conor Cahill's dbmalloc library],
6282         [USE_DBMALLOC])
6283
6284 if test "$with_dbmalloc" = yes ; then
6285         AC_CHECK_HEADER(dbmalloc.h,
6286                 [AC_CHECK_LIB(dbmalloc,[debug_malloc]ifelse([$1],,[],[,$1]))])
6287 fi
6288 ])dnl
6289 dnl ---------------------------------------------------------------------------
6290 dnl CF_WITH_DMALLOC version: 7 updated: 2010/06/21 17:26:47
6291 dnl ---------------
6292 dnl Configure-option for dmalloc.  The optional parameter is used to override
6293 dnl the updating of $LIBS, e.g., to avoid conflict with subsequent tests.
6294 AC_DEFUN([CF_WITH_DMALLOC],[
6295 CF_NO_LEAKS_OPTION(dmalloc,
6296         [  --with-dmalloc          test: use Gray Watson's dmalloc library],
6297         [USE_DMALLOC])
6298
6299 if test "$with_dmalloc" = yes ; then
6300         AC_CHECK_HEADER(dmalloc.h,
6301                 [AC_CHECK_LIB(dmalloc,[dmalloc_debug]ifelse([$1],,[],[,$1]))])
6302 fi
6303 ])dnl
6304 dnl ---------------------------------------------------------------------------
6305 dnl CF_WITH_GPM version: 7 updated: 2008/03/23 14:48:54
6306 dnl -----------
6307 dnl
6308 dnl The option parameter (if neither yes/no) is assumed to be the name of
6309 dnl the gpm library, e.g., for dynamic loading.
6310 AC_DEFUN([CF_WITH_GPM],
6311 [
6312 AC_MSG_CHECKING(if you want to link with the GPM mouse library)
6313 AC_ARG_WITH(gpm,
6314         [  --with-gpm              use Alessandro Rubini's GPM library],
6315         [with_gpm=$withval],
6316         [with_gpm=maybe])
6317 AC_MSG_RESULT($with_gpm)
6318
6319 if test "$with_gpm" != no ; then
6320         AC_CHECK_HEADER(gpm.h,[
6321                 AC_DEFINE(HAVE_GPM_H)
6322                 if test "$with_gpm" != yes && test "$with_gpm" != maybe ; then
6323                         CF_VERBOSE(assuming we really have GPM library)
6324                         AC_DEFINE(HAVE_LIBGPM)
6325                 else
6326                         AC_CHECK_LIB(gpm,Gpm_Open,[:],[
6327                                 AC_MSG_ERROR(Cannot link with GPM library)
6328                 fi
6329                 with_gpm=yes
6330                 ])
6331         ],[
6332                 test "$with_gpm" != maybe && AC_MSG_WARN(Cannot find GPM header)
6333                 with_gpm=no
6334         ])
6335 fi
6336 ])
6337 dnl ---------------------------------------------------------------------------
6338 dnl CF_WITH_LIBTOOL version: 28 updated: 2011/07/02 15:40:32
6339 dnl ---------------
6340 dnl Provide a configure option to incorporate libtool.  Define several useful
6341 dnl symbols for the makefile rules.
6342 dnl
6343 dnl The reference to AC_PROG_LIBTOOL does not normally work, since it uses
6344 dnl macros from libtool.m4 which is in the aclocal directory of automake.
6345 dnl Following is a simple script which turns on the AC_PROG_LIBTOOL macro.
6346 dnl But that still does not work properly since the macro is expanded outside
6347 dnl the CF_WITH_LIBTOOL macro:
6348 dnl
6349 dnl     #!/bin/sh
6350 dnl     ACLOCAL=`aclocal --print-ac-dir`
6351 dnl     if test -z "$ACLOCAL" ; then
6352 dnl             echo cannot find aclocal directory
6353 dnl             exit 1
6354 dnl     elif test ! -f $ACLOCAL/libtool.m4 ; then
6355 dnl             echo cannot find libtool.m4 file
6356 dnl             exit 1
6357 dnl     fi
6358 dnl
6359 dnl     LOCAL=aclocal.m4
6360 dnl     ORIG=aclocal.m4.orig
6361 dnl
6362 dnl     trap "mv $ORIG $LOCAL" 0 1 2 5 15
6363 dnl     rm -f $ORIG
6364 dnl     mv $LOCAL $ORIG
6365 dnl
6366 dnl     # sed the LIBTOOL= assignment to omit the current directory?
6367 dnl     sed -e 's/^LIBTOOL=.*/LIBTOOL=${LIBTOOL:-libtool}/' $ACLOCAL/libtool.m4 >>$LOCAL
6368 dnl     cat $ORIG >>$LOCAL
6369 dnl
6370 dnl     autoconf-257 $*
6371 dnl
6372 AC_DEFUN([CF_WITH_LIBTOOL],
6373 [
6374 AC_REQUIRE([CF_DISABLE_LIBTOOL_VERSION])
6375 ifdef([AC_PROG_LIBTOOL],,[
6376 LIBTOOL=
6377 ])
6378 # common library maintenance symbols that are convenient for libtool scripts:
6379 LIB_CREATE='${AR} -cr'
6380 LIB_OBJECT='${OBJECTS}'
6381 LIB_SUFFIX=.a
6382 LIB_PREP="$RANLIB"
6383
6384 # symbols used to prop libtool up to enable it to determine what it should be
6385 # doing:
6386 LIB_CLEAN=
6387 LIB_COMPILE=
6388 LIB_LINK='${CC}'
6389 LIB_INSTALL=
6390 LIB_UNINSTALL=
6391
6392 AC_MSG_CHECKING(if you want to build libraries with libtool)
6393 AC_ARG_WITH(libtool,
6394         [  --with-libtool          generate libraries with libtool],
6395         [with_libtool=$withval],
6396         [with_libtool=no])
6397 AC_MSG_RESULT($with_libtool)
6398 if test "$with_libtool" != "no"; then
6399 ifdef([AC_PROG_LIBTOOL],[
6400         # missing_content_AC_PROG_LIBTOOL{{
6401         AC_PROG_LIBTOOL
6402         # missing_content_AC_PROG_LIBTOOL}}
6403 ],[
6404         if test "$with_libtool" != "yes" ; then
6405                 CF_PATH_SYNTAX(with_libtool)
6406                 LIBTOOL=$with_libtool
6407         else
6408                 AC_PATH_PROG(LIBTOOL,libtool)
6409         fi
6410         if test -z "$LIBTOOL" ; then
6411                 AC_MSG_ERROR(Cannot find libtool)
6412         fi
6413 ])dnl
6414         LIB_CREATE='${LIBTOOL} --mode=link ${CC} -rpath ${DESTDIR}${libdir} ${LIBTOOL_VERSION} `cut -f1 ${srcdir}/VERSION` ${LIBTOOL_OPTS} ${LT_UNDEF} $(LIBS) -o'
6415         LIB_OBJECT='${OBJECTS:.o=.lo}'
6416         LIB_SUFFIX=.la
6417         LIB_CLEAN='${LIBTOOL} --mode=clean'
6418         LIB_COMPILE='${LIBTOOL} --mode=compile'
6419         LIB_LINK='${LIBTOOL} --mode=link ${CC} ${LIBTOOL_OPTS}'
6420         LIB_INSTALL='${LIBTOOL} --mode=install'
6421         LIB_UNINSTALL='${LIBTOOL} --mode=uninstall'
6422         LIB_PREP=:
6423
6424         # Show the version of libtool
6425         AC_MSG_CHECKING(version of libtool)
6426
6427         # Save the version in a cache variable - this is not entirely a good
6428         # thing, but the version string from libtool is very ugly, and for
6429         # bug reports it might be useful to have the original string. "("
6430         cf_cv_libtool_version=`$LIBTOOL --version 2>&1 | sed -e '/^$/d' |sed -e '2,$d' -e 's/([[^)]]*)//g' -e 's/^[[^1-9]]*//' -e 's/[[^0-9.]].*//'`
6431         AC_MSG_RESULT($cf_cv_libtool_version)
6432         if test -z "$cf_cv_libtool_version" ; then
6433                 AC_MSG_ERROR(This is not GNU libtool)
6434         fi
6435
6436         # special hack to add -no-undefined (which libtool should do for itself)
6437         LT_UNDEF=
6438         case "$cf_cv_system_name" in #(vi
6439         cygwin*|mingw32*|uwin*|aix[[4-7]]) #(vi
6440                 LT_UNDEF=-no-undefined
6441                 ;;
6442         esac
6443         AC_SUBST([LT_UNDEF])
6444
6445         # special hack to add --tag option for C++ compiler
6446         case $cf_cv_libtool_version in #(vi
6447         1.[[5-9]]*|[[2-9]].[[0-9.a-z]]*) #(vi
6448                 LIBTOOL_CXX="$LIBTOOL --tag=CXX"
6449                 LIBTOOL="$LIBTOOL --tag=CC"
6450                 ;;
6451         *)
6452                 LIBTOOL_CXX="$LIBTOOL"
6453                 ;;
6454         esac
6455 else
6456         LIBTOOL=""
6457         LIBTOOL_CXX=""
6458 fi
6459
6460 test -z "$LIBTOOL" && ECHO_LT=
6461
6462 AC_SUBST(LIBTOOL)
6463 AC_SUBST(LIBTOOL_CXX)
6464 AC_SUBST(LIBTOOL_OPTS)
6465
6466 AC_SUBST(LIB_CREATE)
6467 AC_SUBST(LIB_OBJECT)
6468 AC_SUBST(LIB_SUFFIX)
6469 AC_SUBST(LIB_PREP)
6470
6471 AC_SUBST(LIB_CLEAN)
6472 AC_SUBST(LIB_COMPILE)
6473 AC_SUBST(LIB_LINK)
6474 AC_SUBST(LIB_INSTALL)
6475 AC_SUBST(LIB_UNINSTALL)
6476
6477 ])dnl
6478 dnl ---------------------------------------------------------------------------
6479 dnl CF_WITH_PATH version: 10 updated: 2010/10/23 15:44:18
6480 dnl ------------
6481 dnl Wrapper for AC_ARG_WITH to ensure that user supplies a pathname, not just
6482 dnl defaulting to yes/no.
6483 dnl
6484 dnl $1 = option name
6485 dnl $2 = help-text
6486 dnl $3 = environment variable to set
6487 dnl $4 = default value, shown in the help-message, must be a constant
6488 dnl $5 = default value, if it's an expression & cannot be in the help-message
6489 dnl
6490 AC_DEFUN([CF_WITH_PATH],
6491 [AC_ARG_WITH($1,[$2 ](default: ifelse([$4],,empty,[$4])),,
6492 ifelse([$4],,[withval="${$3}"],[withval="${$3:-ifelse([$5],,[$4],[$5])}"]))dnl
6493 if ifelse([$5],,true,[test -n "$5"]) ; then
6494 CF_PATH_SYNTAX(withval)
6495 fi
6496 $3="$withval"
6497 AC_SUBST($3)dnl
6498 ])dnl
6499 dnl ---------------------------------------------------------------------------
6500 dnl CF_WITH_PATHLIST version: 7 updated: 2010/10/23 16:10:30
6501 dnl ----------------
6502 dnl Process an option specifying a list of colon-separated paths.
6503 dnl
6504 dnl $1 = option name
6505 dnl $2 = help-text
6506 dnl $3 = environment variable to set
6507 dnl $4 = default value, shown in the help-message, must be a constant
6508 dnl $5 = default value, if it's an expression & cannot be in the help-message
6509 dnl $6 = flag to tell if we want to define or substitute
6510 dnl
6511 AC_DEFUN([CF_WITH_PATHLIST],[
6512 AC_REQUIRE([CF_PATHSEP])
6513 AC_ARG_WITH($1,[$2 ](default: ifelse($4,,empty,$4)),,
6514 ifelse($4,,[withval=${$3}],[withval=${$3:-ifelse($5,,$4,$5)}]))dnl
6515
6516 IFS="${IFS:-    }"; ac_save_ifs="$IFS"; IFS="${PATH_SEPARATOR}"
6517 cf_dst_path=
6518 for cf_src_path in $withval
6519 do
6520   CF_PATH_SYNTAX(cf_src_path)
6521   test -n "$cf_dst_path" && cf_dst_path="${cf_dst_path}:"
6522   cf_dst_path="${cf_dst_path}${cf_src_path}"
6523 done
6524 IFS="$ac_save_ifs"
6525
6526 ifelse($6,define,[
6527 # Strip single quotes from the value, e.g., when it was supplied as a literal
6528 # for $4 or $5.
6529 case $cf_dst_path in #(vi
6530 \'*)
6531   cf_dst_path=`echo $cf_dst_path |sed -e s/\'// -e s/\'\$//`
6532   ;;
6533 esac
6534 cf_dst_path=`echo "$cf_dst_path" | sed -e 's/\\\\/\\\\\\\\/g'`
6535 ])
6536
6537 eval '$3="$cf_dst_path"'
6538 AC_SUBST($3)dnl
6539
6540 ])dnl
6541 dnl ---------------------------------------------------------------------------
6542 dnl CF_WITH_PKG_CONFIG_LIBDIR version: 1 updated: 2011/09/10 16:20:21
6543 dnl -------------------------
6544 dnl Allow the choice of the pkg-config library directory to be overridden.
6545 AC_DEFUN([CF_WITH_PKG_CONFIG_LIBDIR],[
6546 if test "$PKG_CONFIG" != no ; then
6547         AC_MSG_CHECKING(for $PKG_CONFIG library directory)
6548         AC_ARG_WITH(pkg-config-libdir,
6549                 [  --with-pkg-config-libdir=XXX use given directory for installing pc-files],
6550                 [PKG_CONFIG_LIBDIR=$withval],
6551                 [PKG_CONFIG_LIBDIR=yes])
6552
6553         case x$PKG_CONFIG_LIBDIR in #(vi
6554         x/*) #(vi
6555                 ;;
6556         xyes) #(vi
6557                 # look for the library directory using the same prefix as the executable
6558                 cf_path=`echo "$PKG_CONFIG" | sed -e 's,/[[^/]]*/[[^/]]*$,,'`
6559                 case x`(arch) 2>/dev/null` in #(vi
6560                 *64) #(vi
6561                         for cf_config in $cf_path/share $cf_path/lib64 $cf_path/lib32 $cf_path/lib
6562                         do
6563                                 if test -d $cf_config/pkgconfig
6564                                 then
6565                                         PKG_CONFIG_LIBDIR=$cf_config/pkgconfig
6566                                         break
6567                                 fi
6568                         done
6569                         ;;
6570                 *)
6571                         PKG_CONFIG_LIBDIR=$cf_path/lib/pkgconfig
6572                         ;;
6573                 esac
6574                 ;;
6575         *)
6576                 ;;
6577         esac
6578
6579         AC_MSG_RESULT($PKG_CONFIG_LIBDIR)
6580 fi
6581
6582 AC_SUBST(PKG_CONFIG_LIBDIR)
6583 ])dnl
6584 dnl ---------------------------------------------------------------------------
6585 dnl CF_WITH_PTHREAD version: 3 updated: 2010/05/29 16:31:02
6586 dnl ---------------
6587 dnl Check for POSIX thread library.
6588 AC_DEFUN([CF_WITH_PTHREAD],
6589 [
6590 AC_MSG_CHECKING(if you want to link with the pthread library)
6591 AC_ARG_WITH(pthread,
6592     [  --with-pthread          use POSIX thread library],
6593     [with_pthread=$withval],
6594     [with_pthread=no])
6595 AC_MSG_RESULT($with_pthread)
6596
6597 if test "$with_pthread" != no ; then
6598     AC_CHECK_HEADER(pthread.h,[
6599         AC_DEFINE(HAVE_PTHREADS_H)
6600
6601         AC_MSG_CHECKING(if we can link with the pthread library)
6602         cf_save_LIBS="$LIBS"
6603         CF_ADD_LIB(pthread)
6604         AC_TRY_LINK([
6605 #include <pthread.h>
6606 ],[
6607         int rc = pthread_create(0,0,0,0);
6608 ],[with_pthread=yes],[with_pthread=no])
6609         LIBS="$cf_save_LIBS"
6610         AC_MSG_RESULT($with_pthread)
6611
6612         if test "$with_pthread" = yes ; then
6613             CF_ADD_LIB(pthread)
6614             AC_DEFINE(HAVE_LIBPTHREADS)
6615         else
6616             AC_MSG_ERROR(Cannot link with pthread library)
6617         fi
6618     ])
6619 fi
6620 ])
6621 dnl ---------------------------------------------------------------------------
6622 dnl CF_WITH_REL_VERSION version: 1 updated: 2003/09/20 18:12:49
6623 dnl -------------------
6624 dnl Allow library's release-version to be overridden.  Generally this happens when a
6625 dnl packager has incremented the release-version past that used in the original package,
6626 dnl and wishes to keep doing this.
6627 dnl
6628 dnl $1 is the package name, if any, to derive corresponding {package}_MAJOR
6629 dnl and {package}_MINOR symbols
6630 dnl symbol.
6631 AC_DEFUN([CF_WITH_REL_VERSION],[
6632 test -z "$cf_cv_rel_version" && cf_cv_rel_version=0.0
6633 AC_ARG_WITH(rel-version,
6634 [  --with-rel-version=XXX  override derived release version],
6635 [AC_MSG_WARN(overriding release version $cf_cv_rel_version to $withval)
6636  cf_cv_rel_version=$withval])
6637 ifelse($1,,[
6638  CF_NUMBER_SYNTAX($cf_cv_rel_version,Release version)
6639 ],[
6640  $1_MAJOR=`echo "$cf_cv_rel_version" | sed -e 's/\..*//'`
6641  $1_MINOR=`echo "$cf_cv_rel_version" | sed -e 's/^[[^.]]*//' -e 's/^\.//' -e 's/\..*//'`
6642  CF_NUMBER_SYNTAX([$]$1_MAJOR,Release major-version)
6643  CF_NUMBER_SYNTAX([$]$1_MINOR,Release minor-version)
6644 ])
6645 ])dnl
6646 dnl ---------------------------------------------------------------------------
6647 dnl CF_WITH_SYSMOUSE version: 2 updated: 2003/03/22 19:13:43
6648 dnl ----------------
6649 dnl If we can compile with sysmouse, make it available unless it is not wanted.
6650 AC_DEFUN([CF_WITH_SYSMOUSE],[
6651 # not everyone has "test -c"
6652 if test -c /dev/sysmouse 2>/dev/null ; then
6653 AC_MSG_CHECKING(if you want to use sysmouse)
6654 AC_ARG_WITH(sysmouse,
6655         [  --with-sysmouse         use sysmouse (FreeBSD console)],
6656         [cf_with_sysmouse=$withval],
6657         [cf_with_sysmouse=maybe])
6658         if test "$cf_with_sysmouse" != no ; then
6659         AC_TRY_COMPILE([
6660 #include <osreldate.h>
6661 #if (__FreeBSD_version >= 400017)
6662 #include <sys/consio.h>
6663 #include <sys/fbio.h>
6664 #else
6665 #include <machine/console.h>
6666 #endif
6667 ],[
6668         struct mouse_info the_mouse;
6669         ioctl(0, CONS_MOUSECTL, &the_mouse);
6670 ],[cf_with_sysmouse=yes],[cf_with_sysmouse=no])
6671         fi
6672 AC_MSG_RESULT($cf_with_sysmouse)
6673 test "$cf_with_sysmouse" = yes && AC_DEFINE(USE_SYSMOUSE)
6674 fi
6675 ])dnl
6676 dnl ---------------------------------------------------------------------------
6677 dnl CF_WITH_VALGRIND version: 1 updated: 2006/12/14 18:00:21
6678 dnl ----------------
6679 AC_DEFUN([CF_WITH_VALGRIND],[
6680 CF_NO_LEAKS_OPTION(valgrind,
6681         [  --with-valgrind         test: use valgrind],
6682         [USE_VALGRIND])
6683 ])dnl
6684 dnl ---------------------------------------------------------------------------
6685 dnl CF_XOPEN_SOURCE version: 37 updated: 2011/08/06 20:32:05
6686 dnl ---------------
6687 dnl Try to get _XOPEN_SOURCE defined properly that we can use POSIX functions,
6688 dnl or adapt to the vendor's definitions to get equivalent functionality,
6689 dnl without losing the common non-POSIX features.
6690 dnl
6691 dnl Parameters:
6692 dnl     $1 is the nominal value for _XOPEN_SOURCE
6693 dnl     $2 is the nominal value for _POSIX_C_SOURCE
6694 AC_DEFUN([CF_XOPEN_SOURCE],[
6695
6696 cf_XOPEN_SOURCE=ifelse([$1],,500,[$1])
6697 cf_POSIX_C_SOURCE=ifelse([$2],,199506L,[$2])
6698 cf_xopen_source=
6699
6700 case $host_os in #(vi
6701 aix[[4-7]]*) #(vi
6702         cf_xopen_source="-D_ALL_SOURCE"
6703         ;;
6704 cygwin) #(vi
6705         cf_XOPEN_SOURCE=600
6706         ;;
6707 darwin[[0-8]].*) #(vi
6708         cf_xopen_source="-D_APPLE_C_SOURCE"
6709         ;;
6710 darwin*) #(vi
6711         cf_xopen_source="-D_DARWIN_C_SOURCE"
6712         ;;
6713 freebsd*|dragonfly*) #(vi
6714         # 5.x headers associate
6715         #       _XOPEN_SOURCE=600 with _POSIX_C_SOURCE=200112L
6716         #       _XOPEN_SOURCE=500 with _POSIX_C_SOURCE=199506L
6717         cf_POSIX_C_SOURCE=200112L
6718         cf_XOPEN_SOURCE=600
6719         cf_xopen_source="-D_BSD_TYPES -D__BSD_VISIBLE -D_POSIX_C_SOURCE=$cf_POSIX_C_SOURCE -D_XOPEN_SOURCE=$cf_XOPEN_SOURCE"
6720         ;;
6721 hpux11*) #(vi
6722         cf_xopen_source="-D_HPUX_SOURCE -D_XOPEN_SOURCE=500"
6723         ;;
6724 hpux*) #(vi
6725         cf_xopen_source="-D_HPUX_SOURCE"
6726         ;;
6727 irix[[56]].*) #(vi
6728         cf_xopen_source="-D_SGI_SOURCE"
6729         ;;
6730 linux*|gnu*|mint*|k*bsd*-gnu) #(vi
6731         CF_GNU_SOURCE
6732         ;;
6733 mirbsd*) #(vi
6734         # setting _XOPEN_SOURCE or _POSIX_SOURCE breaks <arpa/inet.h>
6735         ;;
6736 netbsd*) #(vi
6737         cf_xopen_source="-D_NETBSD_SOURCE" # setting _XOPEN_SOURCE breaks IPv6 for lynx on NetBSD 1.6, breaks xterm, is not needed for ncursesw
6738         ;;
6739 openbsd*) #(vi
6740         # setting _XOPEN_SOURCE breaks xterm on OpenBSD 2.8, is not needed for ncursesw
6741         ;;
6742 osf[[45]]*) #(vi
6743         cf_xopen_source="-D_OSF_SOURCE"
6744         ;;
6745 nto-qnx*) #(vi
6746         cf_xopen_source="-D_QNX_SOURCE"
6747         ;;
6748 sco*) #(vi
6749         # setting _XOPEN_SOURCE breaks Lynx on SCO Unix / OpenServer
6750         ;;
6751 solaris2.1[[0-9]]) #(vi
6752         cf_xopen_source="-D__EXTENSIONS__ -D_XOPEN_SOURCE=$cf_XOPEN_SOURCE"
6753         ;;
6754 solaris2.[[1-9]]) #(vi
6755         cf_xopen_source="-D__EXTENSIONS__"
6756         ;;
6757 *)
6758         AC_CACHE_CHECK(if we should define _XOPEN_SOURCE,cf_cv_xopen_source,[
6759         AC_TRY_COMPILE([#include <sys/types.h>],[
6760 #ifndef _XOPEN_SOURCE
6761 make an error
6762 #endif],
6763         [cf_cv_xopen_source=no],
6764         [cf_save="$CPPFLAGS"
6765          CPPFLAGS="$CPPFLAGS -D_XOPEN_SOURCE=$cf_XOPEN_SOURCE"
6766          AC_TRY_COMPILE([#include <sys/types.h>],[
6767 #ifdef _XOPEN_SOURCE
6768 make an error
6769 #endif],
6770         [cf_cv_xopen_source=no],
6771         [cf_cv_xopen_source=$cf_XOPEN_SOURCE])
6772         CPPFLAGS="$cf_save"
6773         ])
6774 ])
6775         if test "$cf_cv_xopen_source" != no ; then
6776                 CF_REMOVE_DEFINE(CFLAGS,$CFLAGS,_XOPEN_SOURCE)
6777                 CF_REMOVE_DEFINE(CPPFLAGS,$CPPFLAGS,_XOPEN_SOURCE)
6778                 cf_temp_xopen_source="-D_XOPEN_SOURCE=$cf_cv_xopen_source"
6779                 CF_ADD_CFLAGS($cf_temp_xopen_source)
6780         fi
6781         CF_POSIX_C_SOURCE($cf_POSIX_C_SOURCE)
6782         ;;
6783 esac
6784
6785 if test -n "$cf_xopen_source" ; then
6786         CF_ADD_CFLAGS($cf_xopen_source)
6787 fi
6788 ])