aclocal.m4

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