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