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