aclocal.m4

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