aclocal.m4

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