aclocal.m4

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