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