aclocal.m4

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