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