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