aclocal.m4

   1 dnl***************************************************************************
   2 dnl Copyright (c) 1998-2007,2008 Free Software Foundation, Inc.              *
   3 dnl                                                                          *
   4 dnl Permission is hereby granted, free of charge, to any person obtaining a  *
   5 dnl copy of this software and associated documentation files (the            *
   6 dnl "Software"), to deal in the Software without restriction, including      *
   7 dnl without limitation the rights to use, copy, modify, merge, publish,      *
   8 dnl distribute, distribute with modifications, sublicense, and/or sell       *
   9 dnl copies of the Software, and to permit persons to whom the Software is    *
  10 dnl furnished to do so, subject to the following conditions:                 *
  11 dnl                                                                          *
  12 dnl The above copyright notice and this permission notice shall be included  *
  13 dnl in all copies or substantial portions of the Software.                   *
  14 dnl                                                                          *
  15 dnl THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS  *
  16 dnl OR IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF               *
  17 dnl MERCHANTABILITY, FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT.   *
  18 dnl IN NO EVENT SHALL THE ABOVE COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM,   *
  19 dnl DAMAGES OR OTHER LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR    *
  20 dnl OTHERWISE, ARISING FROM, OUT OF OR IN CONNECTION WITH THE SOFTWARE OR    *
  21 dnl THE USE OR OTHER DEALINGS IN THE SOFTWARE.                               *
  22 dnl                                                                          *
  23 dnl Except as contained in this notice, the name(s) of the above copyright   *
  24 dnl holders shall not be used in advertising or otherwise to promote the     *
  25 dnl sale, use or other dealings in this Software without prior written       *
  26 dnl authorization.                                                           *
  27 dnl***************************************************************************
  28 dnl
  29 dnl Author: Thomas E. Dickey 1995-on
  30 dnl
  31 dnl $Id: aclocal.m4,v 1.466 2008/10/04 21:21:40 tom Exp $
  32 dnl Macros used in NCURSES auto-configuration script.
  33 dnl
  34 dnl These macros are maintained separately from NCURSES.  The copyright on
  35 dnl this file applies to the aggregation of macros and does not affect use of
  36 dnl these macros in other applications.
  37 dnl
  38 dnl See http://invisible-island.net/autoconf/ for additional information.
  39 dnl
  40 dnl ---------------------------------------------------------------------------
  41 dnl ---------------------------------------------------------------------------
  42 dnl AM_LANGINFO_CODESET version: 3 updated: 2002/10/27 23:21:42
  43 dnl -------------------
  44 dnl Inserted as requested by gettext 0.10.40
  45 dnl File from /usr/share/aclocal
  46 dnl codeset.m4
  47 dnl ====================
  48 dnl serial AM1
  49 dnl
  50 dnl From Bruno Haible.
  51 AC_DEFUN([AM_LANGINFO_CODESET],
  52 [
  53   AC_CACHE_CHECK([for nl_langinfo and CODESET], am_cv_langinfo_codeset,
  54     [AC_TRY_LINK([#include <langinfo.h>],
  55       [char* cs = nl_langinfo(CODESET);],
  56       am_cv_langinfo_codeset=yes,
  57       am_cv_langinfo_codeset=no)
  58     ])
  59   if test $am_cv_langinfo_codeset = yes; then
  60     AC_DEFINE(HAVE_LANGINFO_CODESET, 1,
  61       [Define if you have <langinfo.h> and nl_langinfo(CODESET).])
  62   fi
  63 ])dnl
  64 dnl ---------------------------------------------------------------------------
  65 dnl CF_ADA_INCLUDE_DIRS version: 5 updated: 2006/10/14 15:23:15
  66 dnl -------------------
  67 dnl Construct the list of include-options for the C programs in the Ada95
  68 dnl binding.
  69 AC_DEFUN([CF_ADA_INCLUDE_DIRS],
  70 [
  71 ACPPFLAGS="-I. -I../../include $ACPPFLAGS"
  72 if test "$srcdir" != "."; then
  73         ACPPFLAGS="-I\${srcdir}/../../include $ACPPFLAGS"
  74 fi
  75 if test "$GCC" != yes; then
  76         ACPPFLAGS="$ACPPFLAGS -I\${includedir}"
  77 elif test "$includedir" != "/usr/include"; then
  78         if test "$includedir" = '${prefix}/include' ; then
  79                 if test $prefix != /usr ; then
  80                         ACPPFLAGS="$ACPPFLAGS -I\${includedir}"
  81                 fi
  82         else
  83                 ACPPFLAGS="$ACPPFLAGS -I\${includedir}"
  84         fi
  85 fi
  86 AC_SUBST(ACPPFLAGS)
  87 ])dnl
  88 dnl ---------------------------------------------------------------------------
  89 dnl CF_ADD_CFLAGS version: 7 updated: 2004/04/25 17:48:30
  90 dnl -------------
  91 dnl Copy non-preprocessor flags to $CFLAGS, preprocessor flags to $CPPFLAGS
  92 dnl The second parameter if given makes this macro verbose.
  93 dnl
  94 dnl Put any preprocessor definitions that use quoted strings in $EXTRA_CPPFLAGS,
  95 dnl to simplify use of $CPPFLAGS in compiler checks, etc., that are easily
  96 dnl confused by the quotes (which require backslashes to keep them usable).
  97 AC_DEFUN([CF_ADD_CFLAGS],
  98 [
  99 cf_fix_cppflags=no
 100 cf_new_cflags=
 101 cf_new_cppflags=
 102 cf_new_extra_cppflags=
 103
 104 for cf_add_cflags in $1
 105 do
 106 case $cf_fix_cppflags in
 107 no)
 108         case $cf_add_cflags in #(vi
 109         -undef|-nostdinc*|-I*|-D*|-U*|-E|-P|-C) #(vi
 110                 case $cf_add_cflags in
 111                 -D*)
 112                         cf_tst_cflags=`echo ${cf_add_cflags} |sed -e 's/^-D[[^=]]*='\''\"[[^"]]*//'`
 113
 114                         test "${cf_add_cflags}" != "${cf_tst_cflags}" \
 115                         && test -z "${cf_tst_cflags}" \
 116                         && cf_fix_cppflags=yes
 117
 118                         if test $cf_fix_cppflags = yes ; then
 119                                 cf_new_extra_cppflags="$cf_new_extra_cppflags $cf_add_cflags"
 120                                 continue
 121                         elif test "${cf_tst_cflags}" = "\"'" ; then
 122                                 cf_new_extra_cppflags="$cf_new_extra_cppflags $cf_add_cflags"
 123                                 continue
 124                         fi
 125                         ;;
 126                 esac
 127                 case "$CPPFLAGS" in
 128                 *$cf_add_cflags) #(vi
 129                         ;;
 130                 *) #(vi
 131                         cf_new_cppflags="$cf_new_cppflags $cf_add_cflags"
 132                         ;;
 133                 esac
 134                 ;;
 135         *)
 136                 cf_new_cflags="$cf_new_cflags $cf_add_cflags"
 137                 ;;
 138         esac
 139         ;;
 140 yes)
 141         cf_new_extra_cppflags="$cf_new_extra_cppflags $cf_add_cflags"
 142
 143         cf_tst_cflags=`echo ${cf_add_cflags} |sed -e 's/^[[^"]]*"'\''//'`
 144
 145         test "${cf_add_cflags}" != "${cf_tst_cflags}" \
 146         && test -z "${cf_tst_cflags}" \
 147         && cf_fix_cppflags=no
 148         ;;
 149 esac
 150 done
 151
 152 if test -n "$cf_new_cflags" ; then
 153         ifelse($2,,,[CF_VERBOSE(add to \$CFLAGS $cf_new_cflags)])
 154         CFLAGS="$CFLAGS $cf_new_cflags"
 155 fi
 156
 157 if test -n "$cf_new_cppflags" ; then
 158         ifelse($2,,,[CF_VERBOSE(add to \$CPPFLAGS $cf_new_cppflags)])
 159         CPPFLAGS="$cf_new_cppflags $CPPFLAGS"
 160 fi
 161
 162 if test -n "$cf_new_extra_cppflags" ; then
 163         ifelse($2,,,[CF_VERBOSE(add to \$EXTRA_CPPFLAGS $cf_new_extra_cppflags)])
 164         EXTRA_CPPFLAGS="$cf_new_extra_cppflags $EXTRA_CPPFLAGS"
 165 fi
 166
 167 AC_SUBST(EXTRA_CPPFLAGS)
 168
 169 ])dnl
 170 dnl ---------------------------------------------------------------------------
 171 dnl CF_ADD_INCDIR version: 9 updated: 2008/02/09 13:15:34
 172 dnl -------------
 173 dnl Add an include-directory to $CPPFLAGS.  Don't add /usr/include, since it's
 174 dnl redundant.  We don't normally need to add -I/usr/local/include for gcc,
 175 dnl but old versions (and some misinstalled ones) need that.  To make things
 176 dnl worse, gcc 3.x may give error messages if -I/usr/local/include is added to
 177 dnl the include-path).
 178 AC_DEFUN([CF_ADD_INCDIR],
 179 [
 180 if test -n "$1" ; then
 181   for cf_add_incdir in $1
 182   do
 183         while test $cf_add_incdir != /usr/include
 184         do
 185           if test -d $cf_add_incdir
 186           then
 187                 cf_have_incdir=no
 188                 if test -n "$CFLAGS$CPPFLAGS" ; then
 189                   # a loop is needed to ensure we can add subdirs of existing dirs
 190                   for cf_test_incdir in $CFLAGS $CPPFLAGS ; do
 191                         if test ".$cf_test_incdir" = ".-I$cf_add_incdir" ; then
 192                           cf_have_incdir=yes; break
 193                         fi
 194                   done
 195                 fi
 196
 197                 if test "$cf_have_incdir" = no ; then
 198           if test "$cf_add_incdir" = /usr/local/include ; then
 199                         if test "$GCC" = yes
 200                         then
 201                           cf_save_CPPFLAGS=$CPPFLAGS
 202                           CPPFLAGS="$CPPFLAGS -I$cf_add_incdir"
 203                           AC_TRY_COMPILE([#include <stdio.h>],
 204                                   [printf("Hello")],
 205                                   [],
 206                                   [cf_have_incdir=yes])
 207                           CPPFLAGS=$cf_save_CPPFLAGS
 208                         fi
 209                   fi
 210                 fi
 211
 212                 if test "$cf_have_incdir" = no ; then
 213                   CF_VERBOSE(adding $cf_add_incdir to include-path)
 214                   ifelse($2,,CPPFLAGS,$2)="-I$cf_add_incdir $ifelse($2,,CPPFLAGS,[$]$2)"
 215
 216           cf_top_incdir=`echo $cf_add_incdir | sed -e 's%/include/.*$%/include%'`
 217           test "$cf_top_incdir" = "$cf_add_incdir" && break
 218           cf_add_incdir="$cf_top_incdir"
 219                 else
 220                   break
 221                 fi
 222           fi
 223         done
 224   done
 225 fi
 226 ])dnl
 227 dnl ---------------------------------------------------------------------------
 228 dnl CF_ADD_LIBDIR version: 6 updated: 2008/02/09 13:15:34
 229 dnl -------------
 230 dnl     Adds to the library-path
 231 dnl
 232 dnl     Some machines have trouble with multiple -L options.
 233 dnl
 234 dnl $1 is the (list of) directory(s) to add
 235 dnl $2 is the optional name of the variable to update (default LDFLAGS)
 236 dnl
 237 AC_DEFUN([CF_ADD_LIBDIR],
 238 [
 239 if test -n "$1" ; then
 240   for cf_add_libdir in $1
 241   do
 242     if test $cf_add_libdir = /usr/lib ; then
 243       :
 244     elif test -d $cf_add_libdir
 245     then
 246       cf_have_libdir=no
 247       if test -n "$LDFLAGS$LIBS" ; then
 248         # a loop is needed to ensure we can add subdirs of existing dirs
 249         for cf_test_libdir in $LDFLAGS $LIBS ; do
 250           if test ".$cf_test_libdir" = ".-L$cf_add_libdir" ; then
 251             cf_have_libdir=yes; break
 252           fi
 253         done
 254       fi
 255       if test "$cf_have_libdir" = no ; then
 256         CF_VERBOSE(adding $cf_add_libdir to library-path)
 257         ifelse($2,,LDFLAGS,$2)="-L$cf_add_libdir $ifelse($2,,LDFLAGS,[$]$2)"
 258       fi
 259     fi
 260   done
 261 fi
 262 ])dnl
 263 dnl ---------------------------------------------------------------------------
 264 dnl CF_ANSI_CC_CHECK version: 9 updated: 2001/12/30 17:53:34
 265 dnl ----------------
 266 dnl This is adapted from the macros 'fp_PROG_CC_STDC' and 'fp_C_PROTOTYPES'
 267 dnl in the sharutils 4.2 distribution.
 268 AC_DEFUN([CF_ANSI_CC_CHECK],
 269 [
 270 AC_CACHE_CHECK(for ${CC-cc} option to accept ANSI C, cf_cv_ansi_cc,[
 271 cf_cv_ansi_cc=no
 272 cf_save_CFLAGS="$CFLAGS"
 273 cf_save_CPPFLAGS="$CPPFLAGS"
 274 # Don't try gcc -ansi; that turns off useful extensions and
 275 # breaks some systems' header files.
 276 # AIX                   -qlanglvl=ansi
 277 # Ultrix and OSF/1      -std1
 278 # HP-UX                 -Aa -D_HPUX_SOURCE
 279 # SVR4                  -Xc
 280 # UnixWare 1.2          (cannot use -Xc, since ANSI/POSIX clashes)
 281 for cf_arg in "-DCC_HAS_PROTOS" \
 282         "" \
 283         -qlanglvl=ansi \
 284         -std1 \
 285         -Ae \
 286         "-Aa -D_HPUX_SOURCE" \
 287         -Xc
 288 do
 289         CF_ADD_CFLAGS($cf_arg)
 290         AC_TRY_COMPILE(
 291 [
 292 #ifndef CC_HAS_PROTOS
 293 #if !defined(__STDC__) || (__STDC__ != 1)
 294 choke me
 295 #endif
 296 #endif
 297 ],[
 298         int test (int i, double x);
 299         struct s1 {int (*f) (int a);};
 300         struct s2 {int (*f) (double a);};],
 301         [cf_cv_ansi_cc="$cf_arg"; break])
 302 done
 303 CFLAGS="$cf_save_CFLAGS"
 304 CPPFLAGS="$cf_save_CPPFLAGS"
 305 ])
 306
 307 if test "$cf_cv_ansi_cc" != "no"; then
 308 if test ".$cf_cv_ansi_cc" != ".-DCC_HAS_PROTOS"; then
 309         CF_ADD_CFLAGS($cf_cv_ansi_cc)
 310 else
 311         AC_DEFINE(CC_HAS_PROTOS)
 312 fi
 313 fi
 314 ])dnl
 315 dnl ---------------------------------------------------------------------------
 316 dnl CF_ANSI_CC_REQD version: 4 updated: 2008/03/23 14:48:54
 317 dnl ---------------
 318 dnl For programs that must use an ANSI compiler, obtain compiler options that
 319 dnl will make it recognize prototypes.  We'll do preprocessor checks in other
 320 dnl macros, since tools such as unproto can fake prototypes, but only part of
 321 dnl the preprocessor.
 322 AC_DEFUN([CF_ANSI_CC_REQD],
 323 [AC_REQUIRE([CF_ANSI_CC_CHECK])
 324 if test "$cf_cv_ansi_cc" = "no"; then
 325         AC_MSG_ERROR(
 326 [Your compiler does not appear to recognize prototypes.
 327 You have the following choices:
 328         a. adjust your compiler options
 329         b. get an up-to-date compiler
 330         c. use a wrapper such as unproto])
 331 fi
 332 ])dnl
 333 dnl ---------------------------------------------------------------------------
 334 dnl CF_AWK_BIG_PRINTF version: 2 updated: 2008/10/04 17:16:18
 335 dnl -----------------
 336 dnl Check if awk can handle big strings using printf.  Some older versions of
 337 dnl awk choke on large strings passed via "%s".
 338 dnl
 339 dnl $1 = desired string size
 340 dnl $2 = variable to set with result
 341 AC_DEFUN([CF_AWK_BIG_PRINTF],
 342 [
 343     case x$AWK in #(vi
 344     x)
 345         eval $2=no
 346         ;;
 347     *) #(vi
 348         if ( ${AWK} 'BEGIN { xx = "x"; while (length(xx) < $1) { xx = xx "x"; }; printf("%s\n", xx); }' \
 349             | $AWK '{ printf "%d\n", length([$]0); }' | $AWK 'BEGIN { eqls=0; recs=0; } { recs++; if ([$]0 == 12000) eqls++; } END { if (recs != 1 || eqls != 1) exit 1; }' 2>/dev/null >/dev/null ) ; then
 350             eval $2=yes
 351         else
 352             eval $2=no
 353         fi
 354         ;;
 355     esac
 356 ])dnl
 357 dnl ---------------------------------------------------------------------------
 358 dnl CF_BOOL_DECL version: 8 updated: 2004/01/30 15:51:18
 359 dnl ------------
 360 dnl Test if 'bool' is a builtin type in the configured C++ compiler.  Some
 361 dnl older compilers (e.g., gcc 2.5.8) don't support 'bool' directly; gcc
 362 dnl 2.6.3 does, in anticipation of the ANSI C++ standard.
 363 dnl
 364 dnl Treat the configuration-variable specially here, since we're directly
 365 dnl substituting its value (i.e., 1/0).
 366 dnl
 367 dnl $1 is the shell variable to store the result in, if not $cv_cv_builtin_bool
 368 AC_DEFUN([CF_BOOL_DECL],
 369 [
 370 AC_MSG_CHECKING(if we should include stdbool.h)
 371
 372 AC_CACHE_VAL(cf_cv_header_stdbool_h,[
 373         AC_TRY_COMPILE([],[bool foo = false],
 374                 [cf_cv_header_stdbool_h=0],
 375                 [AC_TRY_COMPILE([
 376 #ifndef __BEOS__
 377 #include <stdbool.h>
 378 #endif
 379 ],[bool foo = false],
 380                         [cf_cv_header_stdbool_h=1],
 381                         [cf_cv_header_stdbool_h=0])])])
 382
 383 if test "$cf_cv_header_stdbool_h" = 1
 384 then    AC_MSG_RESULT(yes)
 385 else    AC_MSG_RESULT(no)
 386 fi
 387
 388 AC_MSG_CHECKING([for builtin bool type])
 389
 390 AC_CACHE_VAL(ifelse($1,,cf_cv_builtin_bool,[$1]),[
 391         AC_TRY_COMPILE([
 392 #include <stdio.h>
 393 #include <sys/types.h>
 394 ],[bool x = false],
 395                 [ifelse($1,,cf_cv_builtin_bool,[$1])=1],
 396                 [ifelse($1,,cf_cv_builtin_bool,[$1])=0])
 397         ])
 398
 399 if test "$ifelse($1,,cf_cv_builtin_bool,[$1])" = 1
 400 then    AC_MSG_RESULT(yes)
 401 else    AC_MSG_RESULT(no)
 402 fi
 403 ])dnl
 404 dnl ---------------------------------------------------------------------------
 405 dnl CF_BOOL_SIZE version: 12 updated: 2006/12/16 12:33:30
 406 dnl ------------
 407 dnl Test for the size of 'bool' in the configured C++ compiler (e.g., a type).
 408 dnl Don't bother looking for bool.h, since it's been deprecated.
 409 dnl
 410 dnl If the current compiler is C rather than C++, we get the bool definition
 411 dnl from <stdbool.h>.
 412 AC_DEFUN([CF_BOOL_SIZE],
 413 [
 414 AC_MSG_CHECKING([for size of bool])
 415 AC_CACHE_VAL(cf_cv_type_of_bool,[
 416         rm -f cf_test.out
 417         AC_TRY_RUN([
 418 #include <stdlib.h>
 419 #include <stdio.h>
 420
 421 #if defined(__cplusplus)
 422
 423 #ifdef HAVE_GXX_BUILTIN_H
 424 #include <g++/builtin.h>
 425 #elif HAVE_GPP_BUILTIN_H
 426 #include <gpp/builtin.h>
 427 #elif HAVE_BUILTIN_H
 428 #include <builtin.h>
 429 #endif
 430
 431 #else
 432
 433 #if $cf_cv_header_stdbool_h
 434 #include <stdbool.h>
 435 #endif
 436
 437 #endif
 438
 439 main()
 440 {
 441         FILE *fp = fopen("cf_test.out", "w");
 442         if (fp != 0) {
 443                 bool x = true;
 444                 if ((bool)(-x) >= 0)
 445                         fputs("unsigned ", fp);
 446                 if (sizeof(x) == sizeof(int))       fputs("int",  fp);
 447                 else if (sizeof(x) == sizeof(char)) fputs("char", fp);
 448                 else if (sizeof(x) == sizeof(short))fputs("short",fp);
 449                 else if (sizeof(x) == sizeof(long)) fputs("long", fp);
 450                 fclose(fp);
 451         }
 452         ${cf_cv_main_return:-return}(0);
 453 }
 454                 ],
 455                 [cf_cv_type_of_bool=`cat cf_test.out`
 456                  if test -z "$cf_cv_type_of_bool"; then
 457                    cf_cv_type_of_bool=unknown
 458                  fi],
 459                 [cf_cv_type_of_bool=unknown],
 460                 [cf_cv_type_of_bool=unknown])
 461         ])
 462         rm -f cf_test.out
 463 AC_MSG_RESULT($cf_cv_type_of_bool)
 464 if test "$cf_cv_type_of_bool" = unknown ; then
 465         case .$NCURSES_BOOL in #(vi
 466         .auto|.) NCURSES_BOOL=unsigned;;
 467         esac
 468         AC_MSG_WARN(Assuming $NCURSES_BOOL for type of bool)
 469         cf_cv_type_of_bool=$NCURSES_BOOL
 470 fi
 471 ])dnl
 472 dnl ---------------------------------------------------------------------------
 473 dnl CF_BUILD_CC version: 6 updated: 2006/10/14 15:23:15
 474 dnl -----------
 475 dnl If we're cross-compiling, allow the user to override the tools and their
 476 dnl options.  The configure script is oriented toward identifying the host
 477 dnl compiler, etc., but we need a build compiler to generate parts of the
 478 dnl source.
 479 dnl
 480 dnl $1 = default for $CPPFLAGS
 481 dnl $2 = default for $LIBS
 482 AC_DEFUN([CF_BUILD_CC],[
 483 AC_REQUIRE([CF_PROG_EXT])
 484 if test "$cross_compiling" = yes ; then
 485
 486         # defaults that we might want to override
 487         : ${BUILD_CFLAGS:=''}
 488         : ${BUILD_CPPFLAGS:='ifelse([$1],,,[$1])'}
 489         : ${BUILD_LDFLAGS:=''}
 490         : ${BUILD_LIBS:='ifelse([$2],,,[$2])'}
 491         : ${BUILD_EXEEXT:='$x'}
 492         : ${BUILD_OBJEXT:='o'}
 493
 494         AC_ARG_WITH(build-cc,
 495                 [  --with-build-cc=XXX     the build C compiler ($BUILD_CC)],
 496                 [BUILD_CC="$withval"],
 497                 [AC_CHECK_PROGS(BUILD_CC, gcc cc cl)])
 498         AC_MSG_CHECKING(for native build C compiler)
 499         AC_MSG_RESULT($BUILD_CC)
 500
 501         AC_MSG_CHECKING(for native build C preprocessor)
 502         AC_ARG_WITH(build-cpp,
 503                 [  --with-build-cpp=XXX    the build C preprocessor ($BUILD_CPP)],
 504                 [BUILD_CPP="$withval"],
 505                 [BUILD_CPP='${BUILD_CC} -E'])
 506         AC_MSG_RESULT($BUILD_CPP)
 507
 508         AC_MSG_CHECKING(for native build C flags)
 509         AC_ARG_WITH(build-cflags,
 510                 [  --with-build-cflags=XXX the build C compiler-flags ($BUILD_CFLAGS)],
 511                 [BUILD_CFLAGS="$withval"])
 512         AC_MSG_RESULT($BUILD_CFLAGS)
 513
 514         AC_MSG_CHECKING(for native build C preprocessor-flags)
 515         AC_ARG_WITH(build-cppflags,
 516                 [  --with-build-cppflags=XXX the build C preprocessor-flags ($BUILD_CPPFLAGS)],
 517                 [BUILD_CPPFLAGS="$withval"])
 518         AC_MSG_RESULT($BUILD_CPPFLAGS)
 519
 520         AC_MSG_CHECKING(for native build linker-flags)
 521         AC_ARG_WITH(build-ldflags,
 522                 [  --with-build-ldflags=XXX the build linker-flags ($BUILD_LDFLAGS)],
 523                 [BUILD_LDFLAGS="$withval"])
 524         AC_MSG_RESULT($BUILD_LDFLAGS)
 525
 526         AC_MSG_CHECKING(for native build linker-libraries)
 527         AC_ARG_WITH(build-libs,
 528                 [  --with-build-libs=XXX   the build libraries (${BUILD_LIBS})],
 529                 [BUILD_LIBS="$withval"])
 530         AC_MSG_RESULT($BUILD_LIBS)
 531
 532         # this assumes we're on Unix.
 533         BUILD_EXEEXT=
 534         BUILD_OBJEXT=o
 535
 536         : ${BUILD_CC:='${CC}'}
 537
 538         if ( test "$BUILD_CC" = "$CC" || test "$BUILD_CC" = '${CC}' ) ; then
 539                 AC_MSG_ERROR([Cross-build requires two compilers.
 540 Use --with-build-cc to specify the native compiler.])
 541         fi
 542
 543 else
 544         : ${BUILD_CC:='${CC}'}
 545         : ${BUILD_CPP:='${CPP}'}
 546         : ${BUILD_CFLAGS:='${CFLAGS}'}
 547         : ${BUILD_CPPFLAGS:='${CPPFLAGS}'}
 548         : ${BUILD_LDFLAGS:='${LDFLAGS}'}
 549         : ${BUILD_LIBS:='${LIBS}'}
 550         : ${BUILD_EXEEXT:='$x'}
 551         : ${BUILD_OBJEXT:='o'}
 552 fi
 553
 554 AC_SUBST(BUILD_CC)
 555 AC_SUBST(BUILD_CPP)
 556 AC_SUBST(BUILD_CFLAGS)
 557 AC_SUBST(BUILD_CPPFLAGS)
 558 AC_SUBST(BUILD_LDFLAGS)
 559 AC_SUBST(BUILD_LIBS)
 560 AC_SUBST(BUILD_EXEEXT)
 561 AC_SUBST(BUILD_OBJEXT)
 562 ])dnl
 563 dnl ---------------------------------------------------------------------------
 564 dnl CF_CFG_DEFAULTS version: 7 updated: 2005/09/24 16:15:00
 565 dnl ---------------
 566 dnl Determine the default configuration into which we'll install ncurses.  This
 567 dnl can be overridden by the user's command-line options.  There's two items to
 568 dnl look for:
 569 dnl     1. the prefix (e.g., /usr)
 570 dnl     2. the header files (e.g., /usr/include/ncurses)
 571 dnl We'll look for a previous installation of ncurses and use the same defaults.
 572 dnl
 573 dnl We don't use AC_PREFIX_DEFAULT, because it gets evaluated too soon, and
 574 dnl we don't use AC_PREFIX_PROGRAM, because we cannot distinguish ncurses's
 575 dnl programs from a vendor's.
 576 AC_DEFUN([CF_CFG_DEFAULTS],
 577 [
 578 AC_MSG_CHECKING(for prefix)
 579 if test "x$prefix" = "xNONE" ; then
 580         case "$cf_cv_system_name" in
 581                 # non-vendor systems don't have a conflict
 582         openbsd*|freebsd*|linux*|cygwin*|k*bsd*-gnu)
 583                 prefix=/usr
 584                 ;;
 585         *)      prefix=$ac_default_prefix
 586                 ;;
 587         esac
 588 fi
 589 AC_MSG_RESULT($prefix)
 590
 591 if test "x$prefix" = "xNONE" ; then
 592 AC_MSG_CHECKING(for default include-directory)
 593 test -n "$verbose" && echo 1>&AC_FD_MSG
 594 for cf_symbol in \
 595         $includedir \
 596         $includedir/ncurses \
 597         $prefix/include \
 598         $prefix/include/ncurses \
 599         /usr/local/include \
 600         /usr/local/include/ncurses \
 601         /usr/include \
 602         /usr/include/ncurses
 603 do
 604         cf_dir=`eval echo $cf_symbol`
 605         if test -f $cf_dir/curses.h ; then
 606         if ( fgrep NCURSES_VERSION $cf_dir/curses.h 2>&1 >/dev/null ) ; then
 607                 includedir="$cf_symbol"
 608                 test -n "$verbose"  && echo $ac_n "     found " 1>&AC_FD_MSG
 609                 break
 610         fi
 611         fi
 612         test -n "$verbose"  && echo "   tested $cf_dir" 1>&AC_FD_MSG
 613 done
 614 AC_MSG_RESULT($includedir)
 615 fi
 616 ])dnl
 617 dnl ---------------------------------------------------------------------------
 618 dnl CF_CGETENT version: 3 updated: 2000/08/12 23:18:52
 619 dnl ----------
 620 dnl Check if the terminal-capability database functions are available.  If not,
 621 dnl ncurses has a much-reduced version.
 622 AC_DEFUN([CF_CGETENT],[
 623 AC_MSG_CHECKING(for terminal-capability database functions)
 624 AC_CACHE_VAL(cf_cv_cgetent,[
 625 AC_TRY_LINK([
 626 #include <stdlib.h>],[
 627         char temp[128];
 628         char *buf = temp;
 629         char *db_array = temp;
 630         cgetent(&buf, /* int *, */ &db_array, "vt100");
 631         cgetcap(buf, "tc", '=');
 632         cgetmatch(buf, "tc");
 633         ],
 634         [cf_cv_cgetent=yes],
 635         [cf_cv_cgetent=no])
 636 ])
 637 AC_MSG_RESULT($cf_cv_cgetent)
 638 test "$cf_cv_cgetent" = yes && AC_DEFINE(HAVE_BSD_CGETENT)
 639 ])dnl
 640 dnl ---------------------------------------------------------------------------
 641 dnl CF_CHECK_CACHE version: 11 updated: 2008/03/23 14:45:59
 642 dnl --------------
 643 dnl Check if we're accidentally using a cache from a different machine.
 644 dnl Derive the system name, as a check for reusing the autoconf cache.
 645 dnl
 646 dnl If we've packaged config.guess and config.sub, run that (since it does a
 647 dnl better job than uname).  Normally we'll use AC_CANONICAL_HOST, but allow
 648 dnl an extra parameter that we may override, e.g., for AC_CANONICAL_SYSTEM
 649 dnl which is useful in cross-compiles.
 650 dnl
 651 dnl Note: we would use $ac_config_sub, but that is one of the places where
 652 dnl autoconf 2.5x broke compatibility with autoconf 2.13
 653 AC_DEFUN([CF_CHECK_CACHE],
 654 [
 655 if test -f $srcdir/config.guess || test -f $ac_aux_dir/config.guess ; then
 656         ifelse([$1],,[AC_CANONICAL_HOST],[$1])
 657         system_name="$host_os"
 658 else
 659         system_name="`(uname -s -r) 2>/dev/null`"
 660         if test -z "$system_name" ; then
 661                 system_name="`(hostname) 2>/dev/null`"
 662         fi
 663 fi
 664 test -n "$system_name" && AC_DEFINE_UNQUOTED(SYSTEM_NAME,"$system_name")
 665 AC_CACHE_VAL(cf_cv_system_name,[cf_cv_system_name="$system_name"])
 666
 667 test -z "$system_name" && system_name="$cf_cv_system_name"
 668 test -n "$cf_cv_system_name" && AC_MSG_RESULT(Configuring for $cf_cv_system_name)
 669
 670 if test ".$system_name" != ".$cf_cv_system_name" ; then
 671         AC_MSG_RESULT(Cached system name ($system_name) does not agree with actual ($cf_cv_system_name))
 672         AC_MSG_ERROR("Please remove config.cache and try again.")
 673 fi
 674 ])dnl
 675 dnl ---------------------------------------------------------------------------
 676 dnl CF_CHECK_ERRNO version: 10 updated: 2008/08/22 16:33:22
 677 dnl --------------
 678 dnl Check for data that is usually declared in <stdio.h> or <errno.h>, e.g.,
 679 dnl the 'errno' variable.  Define a DECL_xxx symbol if we must declare it
 680 dnl ourselves.
 681 dnl
 682 dnl $1 = the name to check
 683 dnl $2 = the assumed type
 684 AC_DEFUN([CF_CHECK_ERRNO],
 685 [
 686 AC_CACHE_CHECK(if external $1 is declared, cf_cv_dcl_$1,[
 687     AC_TRY_COMPILE([
 688 #ifdef HAVE_STDLIB_H
 689 #include <stdlib.h>
 690 #endif
 691 #include <stdio.h>
 692 #include <sys/types.h>
 693 #include <errno.h> ],
 694     ifelse($2,,int,$2) x = (ifelse($2,,int,$2)) $1,
 695     [cf_cv_dcl_$1=yes],
 696     [cf_cv_dcl_$1=no])
 697 ])
 698
 699 if test "$cf_cv_dcl_$1" = no ; then
 700     CF_UPPER(cf_result,decl_$1)
 701     AC_DEFINE_UNQUOTED($cf_result)
 702 fi
 703
 704 # It's possible (for near-UNIX clones) that the data doesn't exist
 705 CF_CHECK_EXTERN_DATA($1,ifelse($2,,int,$2))
 706 ])dnl
 707 dnl ---------------------------------------------------------------------------
 708 dnl CF_CHECK_EXTERN_DATA version: 3 updated: 2001/12/30 18:03:23
 709 dnl --------------------
 710 dnl Check for existence of external data in the current set of libraries.  If
 711 dnl we can modify it, it's real enough.
 712 dnl $1 = the name to check
 713 dnl $2 = its type
 714 AC_DEFUN([CF_CHECK_EXTERN_DATA],
 715 [
 716 AC_CACHE_CHECK(if external $1 exists, cf_cv_have_$1,[
 717     AC_TRY_LINK([
 718 #undef $1
 719 extern $2 $1;
 720 ],
 721     [$1 = 2],
 722     [cf_cv_have_$1=yes],
 723     [cf_cv_have_$1=no])
 724 ])
 725
 726 if test "$cf_cv_have_$1" = yes ; then
 727     CF_UPPER(cf_result,have_$1)
 728     AC_DEFINE_UNQUOTED($cf_result)
 729 fi
 730
 731 ])dnl
 732 dnl ---------------------------------------------------------------------------
 733 dnl CF_CHECK_GPM_WGETCH version: 1 updated: 2007/04/28 14:38:06
 734 dnl -------------------
 735 dnl Check if GPM is already linked with curses.  If so - and if the linkage
 736 dnl is not "weak" - warn about this because it can create problems linking
 737 dnl applications with ncurses.
 738 AC_DEFUN([CF_CHECK_GPM_WGETCH],[
 739 AC_CHECK_LIB(gpm,Gpm_Wgetch,[
 740
 741 AC_CACHE_CHECK(if GPM is weakly bound to curses library, cf_cv_check_gpm_wgetch,[
 742 cf_cv_check_gpm_wgetch=unknown
 743 if test "$cross_compiling" != yes ; then
 744
 745 cat >conftest.$ac_ext <<CF_EOF
 746 #include <gpm.h>
 747 int main()
 748 {
 749         Gpm_Wgetch();
 750         ${cf_cv_main_return:-return}(0);
 751 }
 752 CF_EOF
 753
 754         cf_save_LIBS="$LIBS"
 755         # This only works if we can look at the symbol table.  If a shared
 756         # library is stripped for install, we cannot use that.  So we're forced
 757         # to rely on the static library, noting that some packagers may not
 758         # include it.
 759         LIBS="-static -lgpm -dynamic $LIBS"
 760         if AC_TRY_EVAL(ac_compile) ; then
 761                 if AC_TRY_EVAL(ac_link) ; then
 762                         cf_cv_check_gpm_wgetch=`nm conftest$ac_exeext | egrep '\<wgetch\>' | egrep '\<[[vVwW]]\>'`
 763                         test -n "$cf_cv_check_gpm_wgetch" && cf_cv_check_gpm_wgetch=yes
 764                         test -z "$cf_cv_check_gpm_wgetch" && cf_cv_check_gpm_wgetch=no
 765                 fi
 766         fi
 767         rm -f conftest*
 768         LIBS="$cf_save_LIBS"
 769 fi
 770 ])
 771
 772 if test "$cf_cv_check_gpm_wgetch" != yes ; then
 773         AC_MSG_WARN(GPM library is already linked with curses - read the FAQ)
 774 fi
 775 ])])dnl
 776 dnl ---------------------------------------------------------------------------
 777 dnl CF_CPP_PARAM_INIT version: 4 updated: 2001/04/07 22:31:18
 778 dnl -----------------
 779 dnl Check if the C++ compiler accepts duplicate parameter initialization.  This
 780 dnl is a late feature for the standard and is not in some recent compilers
 781 dnl (1999/9/11).
 782 AC_DEFUN([CF_CPP_PARAM_INIT],
 783 [
 784 if test -n "$CXX"; then
 785 AC_CACHE_CHECK(if $CXX accepts parameter initialization,cf_cv_cpp_param_init,[
 786         AC_LANG_SAVE
 787         AC_LANG_CPLUSPLUS
 788         AC_TRY_RUN([
 789 class TEST {
 790 private:
 791         int value;
 792 public:
 793         TEST(int x = 1);
 794         ~TEST();
 795 };
 796
 797 TEST::TEST(int x = 1)   // some compilers do not like second initializer
 798 {
 799         value = x;
 800 }
 801 void main() { }
 802 ],
 803         [cf_cv_cpp_param_init=yes],
 804         [cf_cv_cpp_param_init=no],
 805         [cf_cv_cpp_param_init=unknown])
 806         AC_LANG_RESTORE
 807 ])
 808 fi
 809 test "$cf_cv_cpp_param_init" = yes && AC_DEFINE(CPP_HAS_PARAM_INIT)
 810 ])dnl
 811 dnl ---------------------------------------------------------------------------
 812 dnl CF_CPP_STATIC_CAST version: 1 updated: 2005/07/23 16:52:43
 813 dnl ------------------
 814 dnl Check if the C++ compiler accepts static_cast in generics.  This appears to
 815 dnl not be supported in g++ before 3.0
 816 AC_DEFUN([CF_CPP_STATIC_CAST],
 817 [
 818 if test -n "$CXX"; then
 819
 820 AC_CACHE_CHECK(if $CXX accepts static_cast,cf_cv_cpp_static_cast,[
 821         AC_LANG_SAVE
 822         AC_LANG_CPLUSPLUS
 823
 824         AC_TRY_COMPILE([
 825 class NCursesPanel
 826 {
 827 public:
 828   NCursesPanel(int nlines,
 829                int ncols,
 830                int begin_y = 0,
 831                int begin_x = 0)
 832   {
 833   }
 834
 835   ~NCursesPanel();
 836 };
 837
 838 template<class T> class NCursesUserPanel : public NCursesPanel
 839 {
 840 public:
 841   NCursesUserPanel (int nlines,
 842                     int ncols,
 843                     int begin_y = 0,
 844                     int begin_x = 0,
 845                     const T* p_UserData = static_cast<T*>(0))
 846     : NCursesPanel (nlines, ncols, begin_y, begin_x)
 847   {
 848   };
 849   NCursesUserPanel(const T* p_UserData = static_cast<T*>(0)) : NCursesPanel()
 850   {
 851   };
 852
 853   virtual ~NCursesUserPanel() {};
 854 };
 855 ],[
 856         const char* p_UserData = static_cast<char*>(0)],
 857         [cf_cv_cpp_static_cast=yes],
 858         [cf_cv_cpp_static_cast=no])
 859
 860         AC_LANG_RESTORE
 861 ])
 862
 863 fi
 864
 865 test "$cf_cv_cpp_static_cast" = yes && AC_DEFINE(CPP_HAS_STATIC_CAST)
 866 ])dnl
 867 dnl ---------------------------------------------------------------------------
 868 dnl CF_C_INLINE version: 2 updated: 2007/08/11 14:09:50
 869 dnl -----------
 870 dnl Check if the C compiler supports "inline".
 871 dnl $1 is the name of a shell variable to set if inline is supported
 872 dnl $2 is the threshold for gcc 4.x's option controlling maximum inline size
 873 AC_DEFUN([CF_C_INLINE],[
 874 AC_C_INLINE
 875 $1=
 876 if test "$ac_cv_c_inline" != no ; then
 877   $1=inline
 878   if test "$INTEL_COMPILER" = yes
 879   then
 880     :
 881   elif test "$GCC" = yes
 882   then
 883     AC_CACHE_CHECK(if gcc supports options to tune inlining,cf_cv_gcc_inline,[
 884       cf_save_CFLAGS=$CFLAGS
 885       CFLAGS="$CFLAGS --param max-inline-insns-single=$2"
 886       AC_TRY_COMPILE([inline int foo(void) { return 1; }],
 887       [${cf_cv_main_return:-return} foo()],
 888       [cf_cv_gcc_inline=yes],
 889       [cf_cv_gcc_inline=no])
 890       CFLAGS=$cf_save_CFLAGS
 891     ])
 892     if test "$cf_cv_gcc_inline" = yes ; then
 893         CF_ADD_CFLAGS([--param max-inline-insns-single=$2])
 894     fi
 895   fi
 896 fi
 897 AC_SUBST($1)
 898 ])dnl
 899 dnl ---------------------------------------------------------------------------
 900 dnl CF_DIRNAME version: 4 updated: 2002/12/21 19:25:52
 901 dnl ----------
 902 dnl "dirname" is not portable, so we fake it with a shell script.
 903 AC_DEFUN([CF_DIRNAME],[$1=`echo $2 | sed -e 's%/[[^/]]*$%%'`])dnl
 904 dnl ---------------------------------------------------------------------------
 905 dnl CF_DIRS_TO_MAKE version: 3 updated: 2002/02/23 20:38:31
 906 dnl ---------------
 907 AC_DEFUN([CF_DIRS_TO_MAKE],
 908 [
 909 DIRS_TO_MAKE="lib"
 910 for cf_item in $cf_list_models
 911 do
 912         CF_OBJ_SUBDIR($cf_item,cf_subdir)
 913         for cf_item2 in $DIRS_TO_MAKE
 914         do
 915                 test $cf_item2 = $cf_subdir && break
 916         done
 917         test ".$cf_item2" != ".$cf_subdir" && DIRS_TO_MAKE="$DIRS_TO_MAKE $cf_subdir"
 918 done
 919 for cf_dir in $DIRS_TO_MAKE
 920 do
 921         test ! -d $cf_dir && mkdir $cf_dir
 922 done
 923 AC_SUBST(DIRS_TO_MAKE)
 924 ])dnl
 925 dnl ---------------------------------------------------------------------------
 926 dnl CF_DISABLE_LEAKS version: 4 updated: 2006/12/16 15:10:42
 927 dnl ----------------
 928 dnl Combine no-leak checks with the libraries or tools that are used for the
 929 dnl checks.
 930 AC_DEFUN([CF_DISABLE_LEAKS],[
 931
 932 AC_REQUIRE([CF_WITH_DMALLOC])
 933 AC_REQUIRE([CF_WITH_DBMALLOC])
 934 AC_REQUIRE([CF_WITH_VALGRIND])
 935
 936 AC_MSG_CHECKING(if you want to perform memory-leak testing)
 937 AC_ARG_ENABLE(leaks,
 938         [  --disable-leaks         test: free permanent memory, analyze leaks],
 939         [with_no_leaks=yes],
 940         : ${with_no_leaks:=no})
 941 AC_MSG_RESULT($with_no_leaks)
 942
 943 if test "$with_no_leaks" = yes ; then
 944         AC_DEFINE(NO_LEAKS)
 945 fi
 946 ])dnl
 947 dnl ---------------------------------------------------------------------------
 948 dnl CF_ENABLE_RPATH version: 1 updated: 2008/09/13 10:22:30
 949 dnl ---------------
 950 dnl Check if the rpath option should be used, setting cache variable
 951 dnl cf_cv_ld_rpath if so.
 952 AC_DEFUN([CF_ENABLE_RPATH],
 953 [
 954 AC_MSG_CHECKING(if rpath option should be used)
 955 AC_ARG_ENABLE(rpath,
 956 [  --enable-rpath          use rpath option when generating shared libraries],
 957 [cf_cv_ld_rpath=$enableval],
 958 [cf_cv_ld_rpath=no])
 959 AC_MSG_RESULT($cf_cv_ld_rpath)
 960 ])dnl
 961 dnl ---------------------------------------------------------------------------
 962 dnl CF_ERRNO version: 5 updated: 1997/11/30 12:44:39
 963 dnl --------
 964 dnl Check if 'errno' is declared in <errno.h>
 965 AC_DEFUN([CF_ERRNO],
 966 [
 967 CF_CHECK_ERRNO(errno)
 968 ])dnl
 969 dnl ---------------------------------------------------------------------------
 970 dnl CF_ETIP_DEFINES version: 3 updated: 2003/03/22 19:13:43
 971 dnl ---------------
 972 dnl Test for conflicting definitions of exception in gcc 2.8.0, etc., between
 973 dnl math.h and builtin.h, only for ncurses
 974 AC_DEFUN([CF_ETIP_DEFINES],
 975 [
 976 AC_MSG_CHECKING(for special defines needed for etip.h)
 977 cf_save_CXXFLAGS="$CXXFLAGS"
 978 cf_result="none"
 979 for cf_math in "" MATH_H
 980 do
 981 for cf_excp in "" MATH_EXCEPTION
 982 do
 983         CXXFLAGS="$cf_save_CXXFLAGS -I${srcdir}/c++ -I${srcdir}/menu -I${srcdir}/include"
 984         test -n "$cf_math" && CXXFLAGS="$CXXFLAGS -DETIP_NEEDS_${cf_math}"
 985         test -n "$cf_excp" && CXXFLAGS="$CXXFLAGS -DETIP_NEEDS_${cf_excp}"
 986 AC_TRY_COMPILE([
 987 #include <etip.h.in>
 988 ],[],[
 989         test -n "$cf_math" && AC_DEFINE_UNQUOTED(ETIP_NEEDS_${cf_math})
 990         test -n "$cf_excp" && AC_DEFINE_UNQUOTED(ETIP_NEEDS_${cf_excp})
 991         cf_result="$cf_math $cf_excp"
 992         break
 993 ],[])
 994 done
 995 done
 996 AC_MSG_RESULT($cf_result)
 997 CXXFLAGS="$cf_save_CXXFLAGS"
 998 ])
 999 dnl ---------------------------------------------------------------------------
1000 dnl CF_FUNC_DLSYM version: 1 updated: 2004/06/16 20:52:45
1001 dnl -------------
1002 dnl Test for dlsym() and related functions, as well as libdl.
1003 dnl
1004 dnl Sets
1005 dnl     $cf_have_dlsym
1006 dnl     $cf_have_libdl
1007 AC_DEFUN([CF_FUNC_DLSYM],[
1008 cf_have_dlsym=no
1009 AC_CHECK_FUNC(dlsym,cf_have_dlsym=yes,[
1010
1011 cf_have_libdl=no
1012 AC_CHECK_LIB(dl,dlsym,[
1013         cf_have_dlsym=yes
1014         cf_have_libdl=yes])])
1015
1016 if test "$cf_have_dlsym" = yes ; then
1017         test "$cf_have_libdl" = yes && LIBS="-ldl $LIBS"
1018
1019         AC_MSG_CHECKING(whether able to link to dl*() functions)
1020         AC_TRY_LINK([#include <dlfcn.h>],[
1021                 void *obj;
1022                 if ((obj = dlopen("filename", 0)) != 0) {
1023                         if (dlsym(obj, "symbolname") == 0) {
1024                         dlclose(obj);
1025                         }
1026                 }],[
1027                 AC_DEFINE(HAVE_LIBDL)],[
1028                 AC_MSG_ERROR(Cannot link test program for libdl)])
1029         AC_MSG_RESULT(ok)
1030 else
1031         AC_MSG_ERROR(Cannot find dlsym function)
1032 fi
1033 ])
1034 dnl ---------------------------------------------------------------------------
1035 dnl CF_FUNC_MEMMOVE version: 7 updated: 2006/12/16 12:33:30
1036 dnl ---------------
1037 dnl Check for memmove, or a bcopy that can handle overlapping copy.  If neither
1038 dnl is found, add our own version of memmove to the list of objects.
1039 AC_DEFUN([CF_FUNC_MEMMOVE],
1040 [
1041 AC_CHECK_FUNC(memmove,,[
1042 AC_CHECK_FUNC(bcopy,[
1043         AC_CACHE_CHECK(if bcopy does overlapping moves,cf_cv_good_bcopy,[
1044                 AC_TRY_RUN([
1045 int main() {
1046         static char data[] = "abcdefghijklmnopqrstuwwxyz";
1047         char temp[40];
1048         bcopy(data, temp, sizeof(data));
1049         bcopy(temp+10, temp, 15);
1050         bcopy(temp+5, temp+15, 10);
1051         ${cf_cv_main_return:-return} (strcmp(temp, "klmnopqrstuwwxypqrstuwwxyz"));
1052 }
1053                 ],
1054                 [cf_cv_good_bcopy=yes],
1055                 [cf_cv_good_bcopy=no],
1056                 [cf_cv_good_bcopy=unknown])
1057                 ])
1058         ],[cf_cv_good_bcopy=no])
1059         if test "$cf_cv_good_bcopy" = yes ; then
1060                 AC_DEFINE(USE_OK_BCOPY)
1061         else
1062                 AC_DEFINE(USE_MY_MEMMOVE)
1063         fi
1064 ])])dnl
1065 dnl ---------------------------------------------------------------------------
1066 dnl CF_FUNC_NANOSLEEP version: 3 updated: 2006/12/16 12:33:30
1067 dnl -----------------
1068 dnl Check for existence of workable nanosleep() function.  Some systems, e.g.,
1069 dnl AIX 4.x, provide a non-working version.
1070 AC_DEFUN([CF_FUNC_NANOSLEEP],[
1071 AC_CACHE_CHECK(if nanosleep really works,cf_cv_func_nanosleep,[
1072 AC_TRY_RUN([
1073 #include <stdio.h>
1074 #include <errno.h>
1075 #include <time.h>
1076
1077 #ifdef HAVE_SYS_TIME_H
1078 #include <sys/time.h>
1079 #endif
1080
1081 int main() {
1082         struct timespec ts1, ts2;
1083         int code;
1084         ts1.tv_sec  = 0;
1085         ts1.tv_nsec = 750000000;
1086         ts2.tv_sec  = 0;
1087         ts2.tv_nsec = 0;
1088         errno = 0;
1089         code = nanosleep(&ts1, &ts2); /* on failure errno is ENOSYS. */
1090         ${cf_cv_main_return:-return}(code != 0);
1091 }
1092 ],
1093         [cf_cv_func_nanosleep=yes],
1094         [cf_cv_func_nanosleep=no],
1095         [cf_cv_func_nanosleep=unknown])])
1096
1097 test "$cf_cv_func_nanosleep" = "yes" && AC_DEFINE(HAVE_NANOSLEEP)
1098 ])
1099 dnl ---------------------------------------------------------------------------
1100 dnl CF_FUNC_OPENPTY version: 2 updated: 2008/04/12 19:49:01
1101 dnl ---------------
1102 dnl Check for openpty() function, along with <pty.h> header.  It may need the
1103 dnl "util" library as well.
1104 AC_DEFUN([CF_FUNC_OPENPTY],
1105 [
1106 AC_CHECK_LIB(util,openpty,cf_cv_lib_util=yes,cf_cv_lib_util=no)
1107 AC_CACHE_CHECK(for openpty header,cf_cv_func_openpty,[
1108     cf_save_LIBS="$LIBS"
1109     test $cf_cv_lib_util = yes && LIBS="-lutil $LIBS"
1110     for cf_header in pty.h libutil.h util.h
1111     do
1112     AC_TRY_LINK([
1113 #include <$cf_header>
1114 ],[
1115     int x = openpty((int *)0, (int *)0, (char *)0,
1116                    (struct termios *)0, (struct winsize *)0);
1117 ],[
1118         cf_cv_func_openpty=$cf_header
1119         break
1120 ],[
1121         cf_cv_func_openpty=no
1122 ])
1123     done
1124     LIBS="$cf_save_LIBS"
1125 ])
1126 ])dnl
1127 dnl ---------------------------------------------------------------------------
1128 dnl CF_FUNC_POLL version: 4 updated: 2006/12/16 12:33:30
1129 dnl ------------
1130 dnl See if the poll function really works.  Some platforms have poll(), but
1131 dnl it does not work for terminals or files.
1132 AC_DEFUN([CF_FUNC_POLL],[
1133 AC_CACHE_CHECK(if poll really works,cf_cv_working_poll,[
1134 AC_TRY_RUN([
1135 #include <stdio.h>
1136 #ifdef HAVE_POLL_H
1137 #include <poll.h>
1138 #else
1139 #include <sys/poll.h>
1140 #endif
1141 int main() {
1142         struct pollfd myfds;
1143         int ret;
1144
1145         myfds.fd = 0;
1146         myfds.events = POLLIN;
1147
1148         ret = poll(&myfds, 1, 100);
1149         ${cf_cv_main_return:-return}(ret != 0);
1150 }],
1151         [cf_cv_working_poll=yes],
1152         [cf_cv_working_poll=no],
1153         [cf_cv_working_poll=unknown])])
1154 test "$cf_cv_working_poll" = "yes" && AC_DEFINE(HAVE_WORKING_POLL)
1155 ])dnl
1156 dnl ---------------------------------------------------------------------------
1157 dnl CF_FUNC_TERMIOS version: 2 updated: 2000/07/22 23:37:24
1158 dnl ---------------
1159 dnl Some old/broken variations define tcgetattr() only as a macro in
1160 dnl termio(s).h
1161 AC_DEFUN([CF_FUNC_TERMIOS],[
1162 AC_REQUIRE([CF_STRUCT_TERMIOS])
1163 AC_CACHE_CHECK(for tcgetattr, cf_cv_have_tcgetattr,[
1164 AC_TRY_LINK([
1165 #include <sys/types.h>
1166 #ifdef HAVE_UNISTD_H
1167 #include <unistd.h>
1168 #endif
1169 #ifdef HAVE_TERMIOS_H
1170 #include <termios.h>
1171 #define TTY struct termios
1172 #else
1173 #ifdef HAVE_TERMIO_H
1174 #include <termio.h>
1175 #define TTY struct termio
1176 #endif
1177 #endif
1178 ],[
1179 TTY foo;
1180 tcgetattr(1, &foo);],
1181 [cf_cv_have_tcgetattr=yes],
1182 [cf_cv_have_tcgetattr=no])])
1183 test "$cf_cv_have_tcgetattr" = yes && AC_DEFINE(HAVE_TCGETATTR)
1184 ])dnl
1185 dnl ---------------------------------------------------------------------------
1186 dnl CF_FUNC_VSSCANF version: 3 updated: 2001/12/19 00:50:10
1187 dnl ---------------
1188 dnl Check for vsscanf() function, which is in c9x but generally not in earlier
1189 dnl versions of C.  It is in the GNU C library, and can often be simulated by
1190 dnl other functions.
1191 AC_DEFUN([CF_FUNC_VSSCANF],
1192 [
1193 AC_CACHE_CHECK(for vsscanf function or workaround,cf_cv_func_vsscanf,[
1194 AC_TRY_LINK([
1195 #include <stdarg.h>
1196 #include <stdio.h>],[
1197         va_list ap;
1198         vsscanf("from", "%d", ap)],[cf_cv_func_vsscanf=vsscanf],[
1199 AC_TRY_LINK([
1200 #include <stdarg.h>
1201 #include <stdio.h>],[
1202     FILE strbuf;
1203     char *str = "from";
1204
1205     strbuf._flag = _IOREAD;
1206     strbuf._ptr = strbuf._base = (unsigned char *) str;
1207     strbuf._cnt = strlen(str);
1208     strbuf._file = _NFILE;
1209     return (vfscanf(&strbuf, "%d", ap))],[cf_cv_func_vsscanf=vfscanf],[
1210 AC_TRY_LINK([
1211 #include <stdarg.h>
1212 #include <stdio.h>],[
1213     FILE strbuf;
1214     char *str = "from";
1215
1216     strbuf._flag = _IOREAD;
1217     strbuf._ptr = strbuf._base = (unsigned char *) str;
1218     strbuf._cnt = strlen(str);
1219     strbuf._file = _NFILE;
1220     return (_doscan(&strbuf, "%d", ap))],[cf_cv_func_vsscanf=_doscan],[
1221 cf_cv_func_vsscanf=no])])])])
1222
1223 case $cf_cv_func_vsscanf in #(vi
1224 vsscanf) AC_DEFINE(HAVE_VSSCANF);; #(vi
1225 vfscanf) AC_DEFINE(HAVE_VFSCANF);; #(vi
1226 _doscan) AC_DEFINE(HAVE__DOSCAN);;
1227 esac
1228
1229 ])dnl
1230 dnl ---------------------------------------------------------------------------
1231 dnl CF_GCC_ATTRIBUTES version: 11 updated: 2007/07/29 09:55:12
1232 dnl -----------------
1233 dnl Test for availability of useful gcc __attribute__ directives to quiet
1234 dnl compiler warnings.  Though useful, not all are supported -- and contrary
1235 dnl to documentation, unrecognized directives cause older compilers to barf.
1236 AC_DEFUN([CF_GCC_ATTRIBUTES],
1237 [
1238 if test "$GCC" = yes
1239 then
1240 cat > conftest.i <<EOF
1241 #ifndef GCC_PRINTF
1242 #define GCC_PRINTF 0
1243 #endif
1244 #ifndef GCC_SCANF
1245 #define GCC_SCANF 0
1246 #endif
1247 #ifndef GCC_NORETURN
1248 #define GCC_NORETURN /* nothing */
1249 #endif
1250 #ifndef GCC_UNUSED
1251 #define GCC_UNUSED /* nothing */
1252 #endif
1253 EOF
1254 if test "$GCC" = yes
1255 then
1256         AC_CHECKING([for $CC __attribute__ directives])
1257 cat > conftest.$ac_ext <<EOF
1258 #line __oline__ "${as_me-configure}"
1259 #include "confdefs.h"
1260 #include "conftest.h"
1261 #include "conftest.i"
1262 #if     GCC_PRINTF
1263 #define GCC_PRINTFLIKE(fmt,var) __attribute__((format(printf,fmt,var)))
1264 #else
1265 #define GCC_PRINTFLIKE(fmt,var) /*nothing*/
1266 #endif
1267 #if     GCC_SCANF
1268 #define GCC_SCANFLIKE(fmt,var)  __attribute__((format(scanf,fmt,var)))
1269 #else
1270 #define GCC_SCANFLIKE(fmt,var)  /*nothing*/
1271 #endif
1272 extern void wow(char *,...) GCC_SCANFLIKE(1,2);
1273 extern void oops(char *,...) GCC_PRINTFLIKE(1,2) GCC_NORETURN;
1274 extern void foo(void) GCC_NORETURN;
1275 int main(int argc GCC_UNUSED, char *argv[[]] GCC_UNUSED) { return 0; }
1276 EOF
1277         for cf_attribute in scanf printf unused noreturn
1278         do
1279                 CF_UPPER(cf_ATTRIBUTE,$cf_attribute)
1280                 cf_directive="__attribute__(($cf_attribute))"
1281                 echo "checking for $CC $cf_directive" 1>&AC_FD_CC
1282                 case $cf_attribute in
1283                 scanf|printf)
1284                 cat >conftest.h <<EOF
1285 #define GCC_$cf_ATTRIBUTE 1
1286 EOF
1287                         ;;
1288                 *)
1289                 cat >conftest.h <<EOF
1290 #define GCC_$cf_ATTRIBUTE $cf_directive
1291 EOF
1292                         ;;
1293                 esac
1294                 if AC_TRY_EVAL(ac_compile); then
1295                         test -n "$verbose" && AC_MSG_RESULT(... $cf_attribute)
1296                         cat conftest.h >>confdefs.h
1297                 fi
1298         done
1299 else
1300         fgrep define conftest.i >>confdefs.h
1301 fi
1302 rm -rf conftest*
1303 fi
1304 ])dnl
1305 dnl ---------------------------------------------------------------------------
1306 dnl CF_GCC_VERSION version: 4 updated: 2005/08/27 09:53:42
1307 dnl --------------
1308 dnl Find version of gcc
1309 AC_DEFUN([CF_GCC_VERSION],[
1310 AC_REQUIRE([AC_PROG_CC])
1311 GCC_VERSION=none
1312 if test "$GCC" = yes ; then
1313         AC_MSG_CHECKING(version of $CC)
1314         GCC_VERSION="`${CC} --version| sed -e '2,$d' -e 's/^.*(GCC) //' -e 's/^[[^0-9.]]*//' -e 's/[[^0-9.]].*//'`"
1315         test -z "$GCC_VERSION" && GCC_VERSION=unknown
1316         AC_MSG_RESULT($GCC_VERSION)
1317 fi
1318 ])dnl
1319 dnl ---------------------------------------------------------------------------
1320 dnl CF_GCC_WARNINGS version: 23 updated: 2008/07/26 17:54:02
1321 dnl ---------------
1322 dnl Check if the compiler supports useful warning options.  There's a few that
1323 dnl we don't use, simply because they're too noisy:
1324 dnl
1325 dnl     -Wconversion (useful in older versions of gcc, but not in gcc 2.7.x)
1326 dnl     -Wredundant-decls (system headers make this too noisy)
1327 dnl     -Wtraditional (combines too many unrelated messages, only a few useful)
1328 dnl     -Wwrite-strings (too noisy, but should review occasionally).  This
1329 dnl             is enabled for ncurses using "--enable-const".
1330 dnl     -pedantic
1331 dnl
1332 dnl Parameter:
1333 dnl     $1 is an optional list of gcc warning flags that a particular
1334 dnl             application might want to use, e.g., "no-unused" for
1335 dnl             -Wno-unused
1336 dnl Special:
1337 dnl     If $with_ext_const is "yes", add a check for -Wwrite-strings
1338 dnl
1339 AC_DEFUN([CF_GCC_WARNINGS],
1340 [
1341 AC_REQUIRE([CF_GCC_VERSION])
1342 CF_INTEL_COMPILER(GCC,INTEL_COMPILER,CFLAGS)
1343
1344 cat > conftest.$ac_ext <<EOF
1345 #line __oline__ "${as_me-configure}"
1346 int main(int argc, char *argv[[]]) { return (argv[[argc-1]] == 0) ; }
1347 EOF
1348
1349 if test "$INTEL_COMPILER" = yes
1350 then
1351 # The "-wdXXX" options suppress warnings:
1352 # remark #1419: external declaration in primary source file
1353 # remark #1682: implicit conversion of a 64-bit integral type to a smaller integral type (potential portability problem)
1354 # remark #1683: explicit conversion of a 64-bit integral type to a smaller integral type (potential portability problem)
1355 # remark #1684: conversion from pointer to same-sized integral type (potential portability problem)
1356 # remark #193: zero used for undefined preprocessing identifier
1357 # remark #593: variable "curs_sb_left_arrow" was set but never used
1358 # remark #810: conversion from "int" to "Dimension={unsigned short}" may lose significant bits
1359 # remark #869: parameter "tw" was never referenced
1360 # remark #981: operands are evaluated in unspecified order
1361 # warning #269: invalid format string conversion
1362
1363         AC_CHECKING([for $CC warning options])
1364         cf_save_CFLAGS="$CFLAGS"
1365         EXTRA_CFLAGS="-Wall"
1366         for cf_opt in \
1367                 wd1419 \
1368                 wd1682 \
1369                 wd1683 \
1370                 wd1684 \
1371                 wd193 \
1372                 wd279 \
1373                 wd593 \
1374                 wd810 \
1375                 wd869 \
1376                 wd981
1377         do
1378                 CFLAGS="$cf_save_CFLAGS $EXTRA_CFLAGS -$cf_opt"
1379                 if AC_TRY_EVAL(ac_compile); then
1380                         test -n "$verbose" && AC_MSG_RESULT(... -$cf_opt)
1381                         EXTRA_CFLAGS="$EXTRA_CFLAGS -$cf_opt"
1382                 fi
1383         done
1384         CFLAGS="$cf_save_CFLAGS"
1385
1386 elif test "$GCC" = yes
1387 then
1388         AC_CHECKING([for $CC warning options])
1389         cf_save_CFLAGS="$CFLAGS"
1390         EXTRA_CFLAGS="-W -Wall"
1391         cf_warn_CONST=""
1392         test "$with_ext_const" = yes && cf_warn_CONST="Wwrite-strings"
1393         for cf_opt in \
1394                 Wbad-function-cast \
1395                 Wcast-align \
1396                 Wcast-qual \
1397                 Winline \
1398                 Wmissing-declarations \
1399                 Wmissing-prototypes \
1400                 Wnested-externs \
1401                 Wpointer-arith \
1402                 Wshadow \
1403                 Wstrict-prototypes \
1404                 Wundef $cf_warn_CONST $1
1405         do
1406                 CFLAGS="$cf_save_CFLAGS $EXTRA_CFLAGS -$cf_opt"
1407                 if AC_TRY_EVAL(ac_compile); then
1408                         test -n "$verbose" && AC_MSG_RESULT(... -$cf_opt)
1409                         case $cf_opt in #(vi
1410                         Wcast-qual) #(vi
1411                                 CPPFLAGS="$CPPFLAGS -DXTSTRINGDEFINES"
1412                                 ;;
1413                         Winline) #(vi
1414                                 case $GCC_VERSION in
1415                                 [[34]].*)
1416                                         CF_VERBOSE(feature is broken in gcc $GCC_VERSION)
1417                                         continue;;
1418                                 esac
1419                                 ;;
1420                         esac
1421                         EXTRA_CFLAGS="$EXTRA_CFLAGS -$cf_opt"
1422                 fi
1423         done
1424         CFLAGS="$cf_save_CFLAGS"
1425 fi
1426 rm -f conftest*
1427
1428 AC_SUBST(EXTRA_CFLAGS)
1429 ])dnl
1430 dnl ---------------------------------------------------------------------------
1431 dnl CF_GNAT_TRY_LINK version: 1 updated: 2004/08/21 19:02:08
1432 dnl ----------------
1433 dnl Verify that a test program compiles/links with GNAT.
1434 dnl $cf_ada_make is set to the program that compiles/links
1435 dnl $ADAFLAGS may be set to the GNAT flags.
1436 dnl
1437 dnl $1 is the text of the spec
1438 dnl $2 is the text of the body
1439 dnl $3 is the shell command to execute if successful
1440 dnl $4 is the shell command to execute if not successful
1441 AC_DEFUN([CF_GNAT_TRY_LINK],
1442 [
1443 rm -f conftest*
1444 cat >>conftest.ads <<CF_EOF
1445 $1
1446 CF_EOF
1447 cat >>conftest.adb <<CF_EOF
1448 $2
1449 CF_EOF
1450 if ( $cf_ada_make $ADAFLAGS conftest 1>&AC_FD_CC 2>&1 ) ; then
1451 ifelse($3,,      :,[      $3])
1452 ifelse($4,,,[else
1453    $4])
1454 fi
1455 rm -f conftest*
1456 ])dnl
1457 dnl ---------------------------------------------------------------------------
1458 dnl CF_GNAT_TRY_RUN version: 3 updated: 2004/08/21 19:02:08
1459 dnl ---------------
1460 dnl Verify that a test program compiles and runs with GNAT
1461 dnl $cf_ada_make is set to the program that compiles/links
1462 dnl $ADAFLAGS may be set to the GNAT flags.
1463 dnl
1464 dnl $1 is the text of the spec
1465 dnl $2 is the text of the body
1466 dnl $3 is the shell command to execute if successful
1467 dnl $4 is the shell command to execute if not successful
1468 AC_DEFUN([CF_GNAT_TRY_RUN],
1469 [
1470 rm -f conftest*
1471 cat >>conftest.ads <<CF_EOF
1472 $1
1473 CF_EOF
1474 cat >>conftest.adb <<CF_EOF
1475 $2
1476 CF_EOF
1477 if ( $cf_ada_make $ADAFLAGS conftest 1>&AC_FD_CC 2>&1 ) ; then
1478    if ( ./conftest 1>&AC_FD_CC 2>&1 ) ; then
1479 ifelse($3,,      :,[      $3])
1480 ifelse($4,,,[   else
1481       $4])
1482    fi
1483 ifelse($4,,,[else
1484    $4])
1485 fi
1486 rm -f conftest*
1487 ])dnl
1488 dnl ---------------------------------------------------------------------------
1489 dnl CF_GNAT_VERSION version: 12 updated: 2006/10/14 15:23:15
1490 dnl ---------------
1491 dnl Verify version of GNAT.
1492 AC_DEFUN([CF_GNAT_VERSION],
1493 [
1494 AC_MSG_CHECKING(for gnat version)
1495 cf_gnat_version=`${cf_ada_make-gnatmake} -v 2>&1 | grep '[[0-9]].[[0-9]][[0-9]]*' |\
1496   sed -e '2,$d' -e 's/[[^0-9 \.]]//g' -e 's/^[[ ]]*//' -e 's/ .*//'`
1497 AC_MSG_RESULT($cf_gnat_version)
1498
1499 case $cf_gnat_version in
1500   3.1[[1-9]]*|3.[[2-9]]*|[[4-9]].*)
1501     cf_cv_prog_gnat_correct=yes
1502     ;;
1503   *) echo Unsupported GNAT version $cf_gnat_version. Required is 3.11 or better. Disabling Ada95 binding.
1504      cf_cv_prog_gnat_correct=no
1505      ;;
1506 esac
1507 case $cf_gnat_version in
1508   3.[[1-9]]*|[[4-9]].*)
1509       cf_compile_generics=generics
1510       cf_generic_objects="\${GENOBJS}"
1511       ;;
1512   *)  cf_compile_generics=
1513       cf_generic_objects=
1514       ;;
1515 esac
1516 ])
1517 dnl ---------------------------------------------------------------------------
1518 dnl CF_GNU_SOURCE version: 6 updated: 2005/07/09 13:23:07
1519 dnl -------------
1520 dnl Check if we must define _GNU_SOURCE to get a reasonable value for
1521 dnl _XOPEN_SOURCE, upon which many POSIX definitions depend.  This is a defect
1522 dnl (or misfeature) of glibc2, which breaks portability of many applications,
1523 dnl since it is interwoven with GNU extensions.
1524 dnl
1525 dnl Well, yes we could work around it...
1526 AC_DEFUN([CF_GNU_SOURCE],
1527 [
1528 AC_CACHE_CHECK(if we must define _GNU_SOURCE,cf_cv_gnu_source,[
1529 AC_TRY_COMPILE([#include <sys/types.h>],[
1530 #ifndef _XOPEN_SOURCE
1531 make an error
1532 #endif],
1533         [cf_cv_gnu_source=no],
1534         [cf_save="$CPPFLAGS"
1535          CPPFLAGS="$CPPFLAGS -D_GNU_SOURCE"
1536          AC_TRY_COMPILE([#include <sys/types.h>],[
1537 #ifdef _XOPEN_SOURCE
1538 make an error
1539 #endif],
1540         [cf_cv_gnu_source=no],
1541         [cf_cv_gnu_source=yes])
1542         CPPFLAGS="$cf_save"
1543         ])
1544 ])
1545 test "$cf_cv_gnu_source" = yes && CPPFLAGS="$CPPFLAGS -D_GNU_SOURCE"
1546 ])dnl
1547 dnl ---------------------------------------------------------------------------
1548 dnl CF_GPP_LIBRARY version: 8 updated: 2003/02/02 01:41:46
1549 dnl --------------
1550 dnl If we're trying to use g++, test if libg++ is installed (a rather common
1551 dnl problem :-).  If we have the compiler but no library, we'll be able to
1552 dnl configure, but won't be able to build the c++ demo program.
1553 AC_DEFUN([CF_GPP_LIBRARY],
1554 [
1555 cf_cxx_library=unknown
1556 case $cf_cv_system_name in #(vi
1557 os2*) #(vi
1558         cf_gpp_libname=gpp
1559         ;;
1560 *)
1561         cf_gpp_libname=g++
1562         ;;
1563 esac
1564 if test "$GXX" = yes; then
1565         AC_MSG_CHECKING([for lib$cf_gpp_libname])
1566         cf_save="$LIBS"
1567         LIBS="$LIBS -l$cf_gpp_libname"
1568         AC_TRY_LINK([
1569 #include <$cf_gpp_libname/builtin.h>
1570         ],
1571         [two_arg_error_handler_t foo2 = lib_error_handler],
1572         [cf_cxx_library=yes
1573          CXXLIBS="$CXXLIBS -l$cf_gpp_libname"
1574          if test "$cf_gpp_libname" = cpp ; then
1575             AC_DEFINE(HAVE_GPP_BUILTIN_H)
1576          else
1577             AC_DEFINE(HAVE_GXX_BUILTIN_H)
1578          fi],
1579         [AC_TRY_LINK([
1580 #include <builtin.h>
1581         ],
1582         [two_arg_error_handler_t foo2 = lib_error_handler],
1583         [cf_cxx_library=yes
1584          CXXLIBS="$CXXLIBS -l$cf_gpp_libname"
1585          AC_DEFINE(HAVE_BUILTIN_H)],
1586         [cf_cxx_library=no])])
1587         LIBS="$cf_save"
1588         AC_MSG_RESULT($cf_cxx_library)
1589 fi
1590 ])dnl
1591 dnl ---------------------------------------------------------------------------
1592 dnl CF_GXX_VERSION version: 5 updated: 2005/08/27 09:53:42
1593 dnl --------------
1594 dnl Check for version of g++
1595 AC_DEFUN([CF_GXX_VERSION],[
1596 AC_REQUIRE([AC_PROG_CPP])
1597 GXX_VERSION=none
1598 if test "$GXX" = yes; then
1599         AC_MSG_CHECKING(version of g++)
1600         GXX_VERSION="`${CXX-g++} --version| sed -e '2,$d' -e 's/^.*(GCC) //' -e 's/^[[^0-9.]]*//' -e 's/[[^0-9.]].*//'`"
1601         test -z "$GXX_VERSION" && GXX_VERSION=unknown
1602         AC_MSG_RESULT($GXX_VERSION)
1603 fi
1604 ])dnl
1605 dnl ---------------------------------------------------------------------------
1606 dnl CF_GXX_WARNINGS version: 5 updated: 2005/08/13 14:54:38
1607 dnl ---------------
1608 dnl Check if the compiler supports useful warning options.
1609 dnl
1610 dnl Most of gcc's options apply to g++, except:
1611 dnl     -Wbad-function-cast
1612 dnl     -Wmissing-declarations
1613 dnl     -Wnested-externs
1614 dnl
1615 dnl Omit a few (for now):
1616 dnl     -Winline
1617 dnl
1618 dnl Parameter:
1619 dnl     $1 is an optional list of g++ warning flags that a particular
1620 dnl             application might want to use, e.g., "no-unused" for
1621 dnl             -Wno-unused
1622 dnl Special:
1623 dnl     If $with_ext_const is "yes", add a check for -Wwrite-strings
1624 dnl
1625 AC_DEFUN([CF_GXX_WARNINGS],
1626 [
1627
1628 CF_INTEL_COMPILER(GXX,INTEL_CPLUSPLUS,CXXFLAGS)
1629
1630 AC_REQUIRE([CF_GXX_VERSION])
1631
1632 AC_LANG_SAVE
1633 AC_LANG_CPLUSPLUS
1634
1635 cat > conftest.$ac_ext <<EOF
1636 #line __oline__ "configure"
1637 int main(int argc, char *argv[[]]) { return (argv[[argc-1]] == 0) ; }
1638 EOF
1639
1640 if test "$INTEL_CPLUSPLUS" = yes
1641 then
1642 # The "-wdXXX" options suppress warnings:
1643 # remark #1419: external declaration in primary source file
1644 # remark #1682: implicit conversion of a 64-bit integral type to a smaller integral type (potential portability problem)
1645 # remark #1683: explicit conversion of a 64-bit integral type to a smaller integral type (potential portability problem)
1646 # remark #1684: conversion from pointer to same-sized integral type (potential portability problem)
1647 # remark #193: zero used for undefined preprocessing identifier
1648 # remark #593: variable "curs_sb_left_arrow" was set but never used
1649 # remark #810: conversion from "int" to "Dimension={unsigned short}" may lose significant bits
1650 # remark #869: parameter "tw" was never referenced
1651 # remark #981: operands are evaluated in unspecified order
1652 # warning #269: invalid format string conversion
1653
1654         AC_CHECKING([for $CC warning options])
1655         cf_save_CXXFLAGS="$CXXFLAGS"
1656         EXTRA_CXXFLAGS="-Wall"
1657         for cf_opt in \
1658                 wd1419 \
1659                 wd1682 \
1660                 wd1683 \
1661                 wd1684 \
1662                 wd193 \
1663                 wd279 \
1664                 wd593 \
1665                 wd810 \
1666                 wd869 \
1667                 wd981
1668         do
1669                 CXXFLAGS="$cf_save_CXXFLAGS $EXTRA_CXXFLAGS -$cf_opt"
1670                 if AC_TRY_EVAL(ac_compile); then
1671                         test -n "$verbose" && AC_MSG_RESULT(... -$cf_opt)
1672                         EXTRA_CXXFLAGS="$EXTRA_CXXFLAGS -$cf_opt"
1673                 fi
1674         done
1675         CXXFLAGS="$cf_save_CXXFLAGS"
1676
1677 elif test "$GXX" = yes
1678 then
1679         AC_CHECKING([for $CXX warning options])
1680         cf_save_CXXFLAGS="$CXXFLAGS"
1681         EXTRA_CXXFLAGS="-W -Wall"
1682         cf_gxx_extra_warnings=""
1683         test "$with_ext_const" = yes && cf_gxx_extra_warnings="Wwrite-strings"
1684         case "$GCC_VERSION" in
1685         [[1-2]].*)
1686                 ;;
1687         *)
1688                 cf_gxx_extra_warnings="$cf_gxx_extra_warnings Weffc++"
1689                 ;;
1690         esac
1691         for cf_opt in \
1692                 Wabi \
1693                 fabi-version=0 \
1694                 Woverloaded-virtual \
1695                 Wsign-promo \
1696                 Wsynth \
1697                 Wold-style-cast \
1698                 Wcast-align \
1699                 Wcast-qual \
1700                 Wmissing-prototypes \
1701                 Wpointer-arith \
1702                 Wshadow \
1703                 Wstrict-prototypes \
1704                 Wundef $cf_gxx_extra_warnings $1
1705         do
1706                 CXXFLAGS="$cf_save_CXXFLAGS $EXTRA_CXXFLAGS -Werror -$cf_opt"
1707                 if AC_TRY_EVAL(ac_compile); then
1708                         test -n "$verbose" && AC_MSG_RESULT(... -$cf_opt)
1709                         EXTRA_CXXFLAGS="$EXTRA_CXXFLAGS -$cf_opt"
1710                 else
1711                         test -n "$verbose" && AC_MSG_RESULT(... no -$cf_opt)
1712                 fi
1713         done
1714         CXXFLAGS="$cf_save_CXXFLAGS"
1715 fi
1716
1717 rm -f conftest*
1718 AC_LANG_RESTORE
1719 AC_SUBST(EXTRA_CXXFLAGS)
1720 ])dnl
1721 dnl ---------------------------------------------------------------------------
1722 dnl CF_HASHED_DB version: 3 updated: 2007/11/24 17:43:37
1723 dnl ------------
1724 dnl Look for an instance of the Berkeley hashed database.
1725 dnl
1726 dnl $1 = optional parameter, to specify install-prefix for the database.
1727 AC_DEFUN([CF_HASHED_DB],
1728 [
1729 ifelse([$1],,,[
1730 case $1 in #(vi
1731 yes|*able*) #(vi
1732     ;;
1733 *)
1734     if test -d "$1" ; then
1735         CF_ADD_INCDIR($1/include)
1736         CF_ADD_LIBDIR($1/lib)
1737     fi
1738 esac
1739 ])
1740 AC_CHECK_HEADER(db.h,[
1741 CF_HASHED_DB_VERSION
1742 if test "$cf_cv_hashed_db_version" = unknown ; then
1743         AC_MSG_ERROR(Cannot determine version of db)
1744 else
1745         CF_HASHED_DB_LIBS
1746         if test "$cf_cv_hashed_db_libs" = unknown ; then
1747                 AC_MSG_ERROR(Cannot determine library for db)
1748         elif test "$cf_cv_hashed_db_libs" != default ; then
1749                 LIBS="-l$cf_cv_hashed_db_libs $LIBS"
1750         fi
1751 fi
1752 ],[
1753         AC_MSG_ERROR(Cannot find db.h)
1754 ])
1755 ])dnl
1756 dnl ---------------------------------------------------------------------------
1757 dnl CF_HASHED_DB_LIBS version: 8 updated: 2008/08/04 06:18:06
1758 dnl -----------------
1759 dnl Given that we have the header and version for hashed database, find the
1760 dnl library information.
1761 AC_DEFUN([CF_HASHED_DB_LIBS],
1762 [
1763 AC_CACHE_CHECK(for db libraries, cf_cv_hashed_db_libs,[
1764 cf_cv_hashed_db_libs=unknown
1765 for cf_db_libs in "" db$cf_cv_hashed_db_version db-$cf_cv_hashed_db_version db ''
1766 do
1767         cf_save_libs="$LIBS"
1768         if test -n "$cf_db_libs"; then
1769                 LIBS="-l$cf_db_libs $LIBS"
1770         fi
1771         CF_MSG_LOG(checking for library "$cf_db_libs")
1772         AC_TRY_LINK([
1773 $ac_includes_default
1774 #include <db.h>
1775 ],[
1776         char *path = "/tmp/foo";
1777 #ifdef DB_VERSION_MAJOR
1778 #if DB_VERSION_MAJOR >= 4
1779         DB *result = 0;
1780         db_create(&result, NULL, 0);
1781         result->open(result,
1782                 NULL,
1783                 path,
1784                 path,
1785                 DB_HASH,
1786                 DB_CREATE,
1787                 0644);
1788 #elif DB_VERSION_MAJOR >= 3
1789         DB *result = 0;
1790         db_create(&result, NULL, 0);
1791         result->open(result,
1792                 path,
1793                 path,
1794                 DB_HASH,
1795                 DB_CREATE,
1796                 0644);
1797 #elif DB_VERSION_MAJOR >= 2
1798         DB *result = 0;
1799         db_open(path,
1800                 DB_HASH,
1801                 DB_CREATE,
1802                 0644,
1803                 (DB_ENV *) 0,
1804                 (DB_INFO *) 0,
1805                 &result);
1806 #endif /* DB_VERSION_MAJOR */
1807 #else
1808         DB *result = dbopen(path,
1809                      2,
1810                      0644,
1811                      DB_HASH,
1812                      0);
1813 #endif
1814         ${cf_cv_main_return:-return}(result != 0)
1815 ],[
1816         if test -n "$cf_db_libs" ; then
1817                 cf_cv_hashed_db_libs=$cf_db_libs
1818         else
1819                 cf_cv_hashed_db_libs=default
1820         fi
1821         LIBS="$cf_save_libs"
1822         break
1823 ])
1824         LIBS="$cf_save_libs"
1825 done
1826 ])
1827 ])dnl
1828 dnl ---------------------------------------------------------------------------
1829 dnl CF_HASHED_DB_VERSION version: 3 updated: 2007/12/01 15:01:37
1830 dnl --------------------
1831 dnl Given that we have the header file for hashed database, find the version
1832 dnl information.
1833 AC_DEFUN([CF_HASHED_DB_VERSION],
1834 [
1835 AC_CACHE_CHECK(for version of db, cf_cv_hashed_db_version,[
1836 cf_cv_hashed_db_version=unknown
1837
1838 for cf_db_version in 1 2 3 4 5
1839 do
1840         CF_MSG_LOG(checking for db version $cf_db_version)
1841         AC_TRY_COMPILE([
1842 $ac_includes_default
1843 #include <db.h>
1844
1845 #ifdef DB_VERSION_MAJOR
1846         /* db2 (DB_VERSION_MAJOR=2) has also DB_VERSION_MINOR, tested with 7 */
1847 #if $cf_db_version == DB_VERSION_MAJOR
1848         /* ok */
1849 #else
1850         make an error
1851 #endif
1852 #else
1853 #if $cf_db_version == 1
1854         /* ok: assuming this is DB 1.8.5 */
1855 #else
1856         make an error
1857 #endif
1858 #endif
1859 ],[DBT *foo = 0],[
1860         cf_cv_hashed_db_version=$cf_db_version
1861         break
1862         ])
1863 done
1864 ])
1865 ])dnl
1866 dnl ---------------------------------------------------------------------------
1867 dnl CF_HELP_MESSAGE version: 3 updated: 1998/01/14 10:56:23
1868 dnl ---------------
1869 dnl Insert text into the help-message, for readability, from AC_ARG_WITH.
1870 AC_DEFUN([CF_HELP_MESSAGE],
1871 [AC_DIVERT_HELP([$1])dnl
1872 ])dnl
1873 dnl ---------------------------------------------------------------------------
1874 dnl CF_INCLUDE_DIRS version: 5 updated: 2006/10/14 15:23:15
1875 dnl ---------------
1876 dnl Construct the list of include-options according to whether we're building
1877 dnl in the source directory or using '--srcdir=DIR' option.  If we're building
1878 dnl with gcc, don't append the includedir if it happens to be /usr/include,
1879 dnl since that usually breaks gcc's shadow-includes.
1880 AC_DEFUN([CF_INCLUDE_DIRS],
1881 [
1882 CPPFLAGS="-I. -I../include $CPPFLAGS"
1883 if test "$srcdir" != "."; then
1884         CPPFLAGS="-I\${srcdir}/../include $CPPFLAGS"
1885 fi
1886 if test "$GCC" != yes; then
1887         CPPFLAGS="$CPPFLAGS -I\${includedir}"
1888 elif test "$includedir" != "/usr/include"; then
1889         if test "$includedir" = '${prefix}/include' ; then
1890                 if test $prefix != /usr ; then
1891                         CPPFLAGS="$CPPFLAGS -I\${includedir}"
1892                 fi
1893         else
1894                 CPPFLAGS="$CPPFLAGS -I\${includedir}"
1895         fi
1896 fi
1897 AC_SUBST(CPPFLAGS)
1898 ])dnl
1899 dnl ---------------------------------------------------------------------------
1900 dnl CF_INTEL_COMPILER version: 3 updated: 2005/08/06 18:37:29
1901 dnl -----------------
1902 dnl Check if the given compiler is really the Intel compiler for Linux.  It
1903 dnl tries to imitate gcc, but does not return an error when it finds a mismatch
1904 dnl between prototypes, e.g., as exercised by CF_MISSING_CHECK.
1905 dnl
1906 dnl This macro should be run "soon" after AC_PROG_CC or AC_PROG_CPLUSPLUS, to
1907 dnl ensure that it is not mistaken for gcc/g++.  It is normally invoked from
1908 dnl the wrappers for gcc and g++ warnings.
1909 dnl
1910 dnl $1 = GCC (default) or GXX
1911 dnl $2 = INTEL_COMPILER (default) or INTEL_CPLUSPLUS
1912 dnl $3 = CFLAGS (default) or CXXFLAGS
1913 AC_DEFUN([CF_INTEL_COMPILER],[
1914 ifelse($2,,INTEL_COMPILER,[$2])=no
1915
1916 if test "$ifelse($1,,[$1],GCC)" = yes ; then
1917         case $host_os in
1918         linux*|gnu*)
1919                 AC_MSG_CHECKING(if this is really Intel ifelse($1,GXX,C++,C) compiler)
1920                 cf_save_CFLAGS="$ifelse($3,,CFLAGS,[$3])"
1921                 ifelse($3,,CFLAGS,[$3])="$ifelse($3,,CFLAGS,[$3]) -no-gcc"
1922                 AC_TRY_COMPILE([],[
1923 #ifdef __INTEL_COMPILER
1924 #else
1925 make an error
1926 #endif
1927 ],[ifelse($2,,INTEL_COMPILER,[$2])=yes
1928 cf_save_CFLAGS="$cf_save_CFLAGS -we147 -no-gcc"
1929 ],[])
1930                 ifelse($3,,CFLAGS,[$3])="$cf_save_CFLAGS"
1931                 AC_MSG_RESULT($ifelse($2,,INTEL_COMPILER,[$2]))
1932                 ;;
1933         esac
1934 fi
1935 ])dnl
1936 dnl ---------------------------------------------------------------------------
1937 dnl CF_ISASCII version: 3 updated: 2000/08/12 23:18:52
1938 dnl ----------
1939 dnl Check if we have either a function or macro for 'isascii()'.
1940 AC_DEFUN([CF_ISASCII],
1941 [
1942 AC_MSG_CHECKING(for isascii)
1943 AC_CACHE_VAL(cf_cv_have_isascii,[
1944         AC_TRY_LINK([#include <ctype.h>],[int x = isascii(' ')],
1945         [cf_cv_have_isascii=yes],
1946         [cf_cv_have_isascii=no])
1947 ])dnl
1948 AC_MSG_RESULT($cf_cv_have_isascii)
1949 test "$cf_cv_have_isascii" = yes && AC_DEFINE(HAVE_ISASCII)
1950 ])dnl
1951 dnl ---------------------------------------------------------------------------
1952 dnl CF_LARGEFILE version: 7 updated: 2007/06/02 11:58:50
1953 dnl ------------
1954 dnl Add checks for large file support.
1955 AC_DEFUN([CF_LARGEFILE],[
1956 ifdef([AC_FUNC_FSEEKO],[
1957     AC_SYS_LARGEFILE
1958     if test "$enable_largefile" != no ; then
1959         AC_FUNC_FSEEKO
1960
1961         # Normally we would collect these definitions in the config.h,
1962         # but (like _XOPEN_SOURCE), some environments rely on having these
1963         # defined before any of the system headers are included.  Another
1964         # case comes up with C++, e.g., on AIX the compiler compiles the
1965         # header files by themselves before looking at the body files it is
1966         # told to compile.  For ncurses, those header files do not include
1967         # the config.h
1968         test "$ac_cv_sys_large_files"      != no && CPPFLAGS="$CPPFLAGS -D_LARGE_FILES "
1969         test "$ac_cv_sys_largefile_source" != no && CPPFLAGS="$CPPFLAGS -D_LARGEFILE_SOURCE "
1970         test "$ac_cv_sys_file_offset_bits" != no && CPPFLAGS="$CPPFLAGS -D_FILE_OFFSET_BITS=$ac_cv_sys_file_offset_bits "
1971
1972         AC_CACHE_CHECK(whether to use struct dirent64, cf_cv_struct_dirent64,[
1973                 AC_TRY_COMPILE([
1974 #include <sys/types.h>
1975 #include <dirent.h>
1976                 ],[
1977                 /* if transitional largefile support is setup, this is true */
1978                 extern struct dirent64 * readdir(DIR *);
1979                 struct dirent64 *x = readdir((DIR *)0);
1980                 struct dirent *y = readdir((DIR *)0);
1981                 int z = x - y;
1982                 ],
1983                 [cf_cv_struct_dirent64=yes],
1984                 [cf_cv_struct_dirent64=no])
1985         ])
1986         test "$cf_cv_struct_dirent64" = yes && AC_DEFINE(HAVE_STRUCT_DIRENT64)
1987     fi
1988 ])
1989 ])
1990 dnl ---------------------------------------------------------------------------
1991 dnl CF_LDFLAGS_STATIC version: 3 updated: 2008/07/05 13:56:40
1992 dnl -----------------
1993 dnl Check for compiler/linker flags used to temporarily force usage of static
1994 dnl libraries.  This depends on the compiler and platform.  Use this to help
1995 dnl ensure that the linker picks up a given library based on its position in
1996 dnl the list of linker options and libraries.
1997 AC_DEFUN([CF_LDFLAGS_STATIC],[
1998
1999 if test "$GCC" = yes ; then
2000         case $cf_cv_system_name in #(
2001         aix[[45]]*)     #( gcc 4.2.4 linkage on AIX is broken
2002                 LDFLAGS_STATIC=
2003                 LDFLAGS_SHARED=
2004                 ;;
2005     *)  #( normally, except when broken
2006         LDFLAGS_STATIC=-static
2007         LDFLAGS_SHARED=-dynamic
2008         ;;
2009     esac
2010 else
2011         case $cf_cv_system_name in #(
2012         aix[[45]]*)     #( from ld manpage
2013                 LDFLAGS_STATIC=-bstatic
2014                 LDFLAGS_SHARED=-bdynamic
2015                 ;;
2016         hpux*)          #( from ld manpage for hpux10.20, hpux11.11
2017                 # We could also use just "archive" and "shared".
2018                 LDFLAGS_STATIC=-Wl,-a,archive_shared
2019                 LDFLAGS_SHARED=-Wl,-a,shared_archive
2020                 ;;
2021         irix*)          #( from ld manpage IRIX64
2022                 LDFLAGS_STATIC=-Bstatic
2023                 LDFLAGS_SHARED=-Bdynamic
2024                 ;;
2025         osf[[45]]*)     #( from ld manpage osf4.0d, osf5.1
2026                 # alternative "-oldstyle_liblookup" (not in cc manpage)
2027                 LDFLAGS_STATIC=-noso
2028                 LDFLAGS_SHARED=-so_archive
2029                 ;;
2030         solaris2*)
2031                 LDFLAGS_STATIC=-Bstatic
2032                 LDFLAGS_SHARED=-Bdynamic
2033                 ;;
2034         esac
2035 fi
2036
2037 AC_SUBST(LDFLAGS_STATIC)
2038 AC_SUBST(LDFLAGS_SHARED)
2039 ])
2040 dnl ---------------------------------------------------------------------------
2041 dnl CF_LIBUTF8 version: 2 updated: 2002/01/19 22:51:32
2042 dnl ----------
2043 dnl Check for libutf8
2044 AC_DEFUN([CF_LIBUTF8],
2045 [
2046 AC_CACHE_CHECK(for putwc in libutf8,cf_cv_libutf8,[
2047         cf_save_LIBS="$LIBS"
2048         LIBS="-lutf8 $LIBS"
2049 AC_TRY_LINK([
2050 #include <libutf8.h>],[putwc(0,0);],
2051         [cf_cv_libutf8=yes],
2052         [cf_cv_libutf8=no])
2053         LIBS="$cf_save_LIBS"
2054 ])
2055
2056 if test "$cf_cv_libutf8" = yes ; then
2057         AC_DEFINE(HAVE_LIBUTF8_H)
2058         LIBS="-lutf8 $LIBS"
2059 fi
2060 ])dnl
2061 dnl ---------------------------------------------------------------------------
2062 dnl CF_LIB_PREFIX version: 8 updated: 2008/09/13 11:34:16
2063 dnl -------------
2064 dnl Compute the library-prefix for the given host system
2065 dnl $1 = variable to set
2066 AC_DEFUN([CF_LIB_PREFIX],
2067 [
2068         case $cf_cv_system_name in #(vi
2069         OS/2*|os2*) #(vi
2070         LIB_PREFIX=''
2071         ;;
2072         *)      LIB_PREFIX='lib'
2073         ;;
2074         esac
2075 ifelse($1,,,[$1=$LIB_PREFIX])
2076         AC_SUBST(LIB_PREFIX)
2077 ])dnl
2078 dnl ---------------------------------------------------------------------------
2079 dnl CF_LIB_RULES version: 53 updated: 2008/09/20 19:51:59
2080 dnl ------------
2081 dnl Append definitions and rules for the given models to the subdirectory
2082 dnl Makefiles, and the recursion rule for the top-level Makefile.  If the
2083 dnl subdirectory is a library-source directory, modify the LIBS_TO_MAKE list in
2084 dnl the corresponding makefile to list the models that we'll generate.
2085 dnl
2086 dnl For shared libraries, make a list of symbolic links to construct when
2087 dnl generating each library.  The convention used for Linux is the simplest
2088 dnl one:
2089 dnl     lib<name>.so    ->
2090 dnl     lib<name>.so.<major>    ->
2091 dnl     lib<name>.so.<maj>.<minor>
2092 AC_DEFUN([CF_LIB_RULES],
2093 [
2094 CF_LIB_PREFIX(cf_prefix)
2095 AC_REQUIRE([CF_SUBST_NCURSES_VERSION])
2096
2097 if test $cf_cv_shlib_version = cygdll ; then
2098         TINFO_NAME=$TINFO_ARG_SUFFIX
2099         TINFO_SUFFIX=.dll
2100 fi
2101
2102 for cf_dir in $SRC_SUBDIRS
2103 do
2104         if test ! -d $srcdir/$cf_dir ; then
2105                 continue
2106         elif test -f $srcdir/$cf_dir/modules; then
2107
2108                 SHARED_LIB=
2109                 LIBS_TO_MAKE=
2110                 for cf_item in $cf_LIST_MODELS
2111                 do
2112                         CF_LIB_SUFFIX($cf_item,cf_suffix,cf_depsuf)
2113                         if test $cf_item = shared ; then
2114                         if test "$cf_cv_do_symlinks" = yes ; then
2115                                 case "$cf_cv_shlib_version" in #(vi
2116                                 rel) #(vi
2117                                         case "$cf_cv_system_name" in #(vi
2118                                         darwin*)
2119                                         case .${LIB_SUFFIX} in
2120                                         .w*)
2121                                                 cf_suffix=`echo $cf_suffix | sed 's/^w//'`
2122                                                 cf_suffix=w'.${REL_VERSION}'"$cf_suffix"
2123                                                 ;;
2124                                         *)
2125                                                 cf_suffix='.${REL_VERSION}'"$cf_suffix"
2126                                                 ;;
2127                                         esac
2128                                         ;; #(vi
2129                                         *) cf_suffix="$cf_suffix"'.${REL_VERSION}' ;;
2130                                         esac
2131                                         ;;
2132                                 abi)
2133                                         case "$cf_cv_system_name" in #(vi
2134                                         darwin*)
2135                                         case .${LIB_SUFFIX} in
2136                                         .w*)
2137                                                 cf_suffix=`echo $cf_suffix | sed 's/^w//'`
2138                                                 cf_suffix=w'.${ABI_VERSION}'"$cf_suffix"
2139                                                 ;;
2140                                         *)
2141                                                 cf_suffix='.${ABI_VERSION}'"$cf_suffix"
2142                                                 ;;
2143                                         esac
2144                                         ;; #(vi
2145                                         *) cf_suffix="$cf_suffix"'.${ABI_VERSION}' ;;
2146                                         esac
2147                                         ;;
2148                                 esac
2149                         fi
2150                         # cygwin needs import library, and has unique naming convention
2151                         # use autodetected ${cf_prefix} for import lib and static lib, but
2152                         # use 'cyg' prefix for shared lib.
2153                         if test $cf_cv_shlib_version = cygdll ; then
2154                                 cf_cygsuf=`echo "$cf_suffix" | sed -e 's/\.dll/\${ABI_VERSION}.dll/'`
2155                                 LIBS_TO_MAKE="$LIBS_TO_MAKE ../lib/cyg${cf_dir}${cf_cygsuf}"
2156                                 continue
2157                         fi
2158                         fi
2159                         LIBS_TO_MAKE="$LIBS_TO_MAKE ../lib/${cf_prefix}${cf_dir}${cf_suffix}"
2160                 done
2161
2162                 if test $cf_dir = ncurses ; then
2163                         cf_subsets="$LIB_SUBSETS"
2164                         cf_r_parts="$cf_subsets"
2165                         cf_liblist="$LIBS_TO_MAKE"
2166
2167                         while test -n "$cf_r_parts"
2168                         do
2169                                 cf_l_parts=`echo "$cf_r_parts" |sed -e 's/ .*$//'`
2170                                 cf_r_parts=`echo "$cf_r_parts" |sed -e 's/^[[^ ]]* //'`
2171                                 if test "$cf_l_parts" != "$cf_r_parts" ; then
2172                                         cf_item=
2173                                         case $cf_l_parts in #(vi
2174                                         *termlib*) #(vi
2175                                                 cf_item=`echo $cf_liblist |sed -e s%${LIB_NAME}${LIB_SUFFIX}%${TINFO_LIB_SUFFIX}%g`
2176                                                 ;;
2177                                         *ticlib*)
2178                                                 cf_item=`echo $cf_liblist |sed -e s%${LIB_NAME}${LIB_SUFFIX}%${TICS_LIB_SUFFIX}%g`
2179                                                 ;;
2180                                         *)
2181                                                 break
2182                                                 ;;
2183                                         esac
2184                                         if test -n "$cf_item"; then
2185                                                 LIBS_TO_MAKE="$cf_item $LIBS_TO_MAKE"
2186                                         fi
2187                                 else
2188                                         break
2189                                 fi
2190                         done
2191                 else
2192                         cf_subsets=`echo "$LIB_SUBSETS" | sed -e 's/^termlib.* //'`
2193                 fi
2194
2195                 sed -e "s%@LIBS_TO_MAKE@%$LIBS_TO_MAKE%" \
2196                     -e "s%@SHARED_LIB@%$SHARED_LIB%" \
2197                         $cf_dir/Makefile >$cf_dir/Makefile.out
2198                 mv $cf_dir/Makefile.out $cf_dir/Makefile
2199
2200                 $AWK -f $srcdir/mk-0th.awk \
2201                         libname="${cf_dir}${LIB_SUFFIX}" subsets="$LIB_SUBSETS" \
2202                         $srcdir/$cf_dir/modules >>$cf_dir/Makefile
2203
2204                 for cf_subset in $cf_subsets
2205                 do
2206                         cf_subdirs=
2207                         for cf_item in $cf_LIST_MODELS
2208                         do
2209                         echo "Appending rules for ${cf_item} model (${cf_dir}: ${cf_subset})"
2210                         CF_UPPER(cf_ITEM,$cf_item)
2211                         CF_LIB_SUFFIX($cf_item,cf_suffix,cf_depsuf)
2212                         CF_OBJ_SUBDIR($cf_item,cf_subdir)
2213
2214                         # Test for case where we build libtinfo with a different name.
2215                         cf_libname=$cf_dir
2216                         if test $cf_dir = ncurses ; then
2217                                 case $cf_subset in
2218                                 *base*)
2219                                         cf_libname=${cf_libname}$LIB_SUFFIX
2220                                         ;;
2221                                 *termlib*)
2222                                         cf_libname=$TINFO_LIB_SUFFIX
2223                                         ;;
2224                                 ticlib*)
2225                                         cf_libname=$TICS_LIB_SUFFIX
2226                                         ;;
2227                                 esac
2228                         else
2229                                 cf_libname=${cf_libname}$LIB_SUFFIX
2230                         fi
2231                         if test -n "${DFT_ARG_SUFFIX}" ; then
2232                                 # undo $LIB_SUFFIX add-on in CF_LIB_SUFFIX
2233                                 cf_suffix=`echo $cf_suffix |sed -e "s%^${LIB_SUFFIX}%%"`
2234                         fi
2235
2236                         # These dependencies really are for development, not
2237                         # builds, but they are useful in porting, too.
2238                         cf_depend="../include/ncurses_cfg.h"
2239                         if test "$srcdir" = "."; then
2240                                 cf_reldir="."
2241                         else
2242                                 cf_reldir="\${srcdir}"
2243                         fi
2244
2245                         if test -f $srcdir/$cf_dir/$cf_dir.priv.h; then
2246                                 cf_depend="$cf_depend $cf_reldir/$cf_dir.priv.h"
2247                         elif test -f $srcdir/$cf_dir/curses.priv.h; then
2248                                 cf_depend="$cf_depend $cf_reldir/curses.priv.h"
2249                         fi
2250
2251                         cf_dir_suffix=
2252                         old_cf_suffix="$cf_suffix"
2253                         if test "$cf_cv_shlib_version_infix" = yes ; then
2254                         if test -n "$LIB_SUFFIX" ; then
2255                                 case $LIB_SUFFIX in
2256                                 w*)
2257                                         cf_libname=`echo $cf_libname | sed 's/w$//'`
2258                                         cf_suffix=`echo $cf_suffix | sed 's/^w//'`
2259                                         cf_dir_suffix=w
2260                                         ;;
2261                                 esac
2262                         fi
2263                         fi
2264
2265                         $AWK -f $srcdir/mk-1st.awk \
2266                                 name=${cf_libname}${cf_dir_suffix} \
2267                                 traces=$LIB_TRACING \
2268                                 MODEL=$cf_ITEM \
2269                                 model=$cf_subdir \
2270                                 prefix=$cf_prefix \
2271                                 suffix=$cf_suffix \
2272                                 subset=$cf_subset \
2273                                 TermlibRoot=$TINFO_NAME \
2274                                 TermlibSuffix=$TINFO_SUFFIX \
2275                                 ShlibVer=$cf_cv_shlib_version \
2276                                 ShlibVerInfix=$cf_cv_shlib_version_infix \
2277                                 ReLink=${cf_cv_do_relink-no} \
2278                                 DoLinks=$cf_cv_do_symlinks \
2279                                 rmSoLocs=$cf_cv_rm_so_locs \
2280                                 ldconfig="$LDCONFIG" \
2281                                 overwrite=$WITH_OVERWRITE \
2282                                 depend="$cf_depend" \
2283                                 host="$host" \
2284                                 $srcdir/$cf_dir/modules >>$cf_dir/Makefile
2285
2286                         cf_suffix="$old_cf_suffix"
2287
2288                         for cf_subdir2 in $cf_subdirs lib
2289                         do
2290                                 test $cf_subdir = $cf_subdir2 && break
2291                         done
2292                         test "${cf_subset}.${cf_subdir2}" != "${cf_subset}.${cf_subdir}" && \
2293                         $AWK -f $srcdir/mk-2nd.awk \
2294                                 name=$cf_dir \
2295                                 traces=$LIB_TRACING \
2296                                 MODEL=$cf_ITEM \
2297                                 model=$cf_subdir \
2298                                 subset=$cf_subset \
2299                                 srcdir=$srcdir \
2300                                 echo=$WITH_ECHO \
2301                                 crenames=$cf_cv_prog_CC_c_o \
2302                                 cxxrenames=$cf_cv_prog_CXX_c_o \
2303                                 $srcdir/$cf_dir/modules >>$cf_dir/Makefile
2304                         cf_subdirs="$cf_subdirs $cf_subdir"
2305                         done
2306                 done
2307         fi
2308
2309         echo '  cd '$cf_dir' && ${MAKE} ${CF_MFLAGS} [$]@' >>Makefile
2310 done
2311
2312 for cf_dir in $SRC_SUBDIRS
2313 do
2314         if test ! -d $srcdir/$cf_dir ; then
2315                 continue
2316         fi
2317
2318         if test -f $cf_dir/Makefile ; then
2319                 case "$cf_dir" in
2320                 Ada95) #(vi
2321                         echo 'libs \' >> Makefile
2322                         echo 'install.libs \' >> Makefile
2323                         echo 'uninstall.libs ::' >> Makefile
2324                         echo '  cd '$cf_dir' && ${MAKE} ${CF_MFLAGS} [$]@' >> Makefile
2325                         ;;
2326                 esac
2327         fi
2328
2329         if test -f $srcdir/$cf_dir/modules; then
2330                 echo >> Makefile
2331                 if test -f $srcdir/$cf_dir/headers; then
2332 cat >> Makefile <<CF_EOF
2333 install.includes \\
2334 uninstall.includes \\
2335 CF_EOF
2336                 fi
2337 if test "$cf_dir" != "c++" ; then
2338 echo 'lint \' >> Makefile
2339 fi
2340 cat >> Makefile <<CF_EOF
2341 libs \\
2342 lintlib \\
2343 install.libs \\
2344 uninstall.libs \\
2345 install.$cf_dir \\
2346 uninstall.$cf_dir ::
2347         cd $cf_dir && \${MAKE} \${CF_MFLAGS} \[$]@
2348 CF_EOF
2349         elif test -f $srcdir/$cf_dir/headers; then
2350 cat >> Makefile <<CF_EOF
2351
2352 libs \\
2353 install.libs \\
2354 uninstall.libs \\
2355 install.includes \\
2356 uninstall.includes ::
2357         cd $cf_dir && \${MAKE} \${CF_MFLAGS} \[$]@
2358 CF_EOF
2359 fi
2360 done
2361
2362 cat >> Makefile <<CF_EOF
2363
2364 install.libs uninstall.libs \\
2365 install.data uninstall.data ::
2366 $MAKE_TERMINFO  cd misc && \${MAKE} \${CF_MFLAGS} \[$]@
2367
2368 install.man \\
2369 uninstall.man ::
2370         cd man && \${MAKE} \${CF_MFLAGS} \[$]@
2371
2372 distclean ::
2373         rm -f config.cache config.log config.status Makefile include/ncurses_cfg.h
2374         rm -f headers.sh headers.sed mk_shared_lib.sh
2375         rm -rf \${DIRS_TO_MAKE}
2376 CF_EOF
2377
2378 # Special case: tack's manpage lives in its own directory.
2379 if test -d tack ; then
2380 if test -f $srcdir/$tack.h; then
2381 cat >> Makefile <<CF_EOF
2382
2383 install.man \\
2384 uninstall.man ::
2385         cd tack && \${MAKE} \${CF_MFLAGS} \[$]@
2386 CF_EOF
2387 fi
2388 fi
2389
2390 dnl If we're installing into a subdirectory of /usr/include, etc., we should
2391 dnl prepend the subdirectory's name to the "#include" paths.  It won't hurt
2392 dnl anything, and will make it more standardized.  It's awkward to decide this
2393 dnl at configuration because of quoting, so we'll simply make all headers
2394 dnl installed via a script that can do the right thing.
2395
2396 rm -f headers.sed headers.sh
2397
2398 dnl ( generating this script makes the makefiles a little tidier :-)
2399 echo creating headers.sh
2400 cat >headers.sh <<CF_EOF
2401 #! /bin/sh
2402 # This shell script is generated by the 'configure' script.  It is invoked in a
2403 # subdirectory of the build tree.  It generates a sed-script in the parent
2404 # directory that is used to adjust includes for header files that reside in a
2405 # subdirectory of /usr/include, etc.
2406 PRG=""
2407 while test \[$]# != 3
2408 do
2409 PRG="\$PRG \[$]1"; shift
2410 done
2411 DST=\[$]1
2412 REF=\[$]2
2413 SRC=\[$]3
2414 TMPSRC=\${TMPDIR-/tmp}/\`basename \$SRC\`\$\$
2415 TMPSED=\${TMPDIR-/tmp}/headers.sed\$\$
2416 echo installing \$SRC in \$DST
2417 CF_EOF
2418
2419 if test $WITH_CURSES_H = yes; then
2420         cat >>headers.sh <<CF_EOF
2421 case \$DST in
2422 /*/include/*)
2423         END=\`basename \$DST\`
2424         for i in \`cat \$REF/../*/headers |fgrep -v "#"\`
2425         do
2426                 NAME=\`basename \$i\`
2427                 echo "s/<\$NAME>/<\$END\/\$NAME>/" >> \$TMPSED
2428         done
2429         ;;
2430 *)
2431         echo "" >> \$TMPSED
2432         ;;
2433 esac
2434 CF_EOF
2435
2436 else
2437         cat >>headers.sh <<CF_EOF
2438 case \$DST in
2439 /*/include/*)
2440         END=\`basename \$DST\`
2441         for i in \`cat \$REF/../*/headers |fgrep -v "#"\`
2442         do
2443                 NAME=\`basename \$i\`
2444                 if test "\$NAME" = "curses.h"
2445                 then
2446                         echo "s/<curses.h>/<ncurses.h>/" >> \$TMPSED
2447                         NAME=ncurses.h
2448                 fi
2449                 echo "s/<\$NAME>/<\$END\/\$NAME>/" >> \$TMPSED
2450         done
2451         ;;
2452 *)
2453         echo "s/<curses.h>/<ncurses.h>/" >> \$TMPSED
2454         ;;
2455 esac
2456 CF_EOF
2457 fi
2458 cat >>headers.sh <<CF_EOF
2459 rm -f \$TMPSRC
2460 sed -f \$TMPSED \$SRC > \$TMPSRC
2461 NAME=\`basename \$SRC\`
2462 CF_EOF
2463 if test $WITH_CURSES_H != yes; then
2464         cat >>headers.sh <<CF_EOF
2465 test "\$NAME" = "curses.h" && NAME=ncurses.h
2466 CF_EOF
2467 fi
2468 cat >>headers.sh <<CF_EOF
2469 # Just in case someone gzip'd manpages, remove the conflicting copy.
2470 test -f \$DST/\$NAME.gz && rm -f \$DST/\$NAME.gz
2471
2472 eval \$PRG \$TMPSRC \$DST/\$NAME
2473 rm -f \$TMPSRC \$TMPSED
2474 CF_EOF
2475
2476 chmod 0755 headers.sh
2477
2478 for cf_dir in $SRC_SUBDIRS
2479 do
2480         if test ! -d $srcdir/$cf_dir ; then
2481                 continue
2482         fi
2483
2484         if test -f $srcdir/$cf_dir/headers; then
2485                 $AWK -f $srcdir/mk-hdr.awk \
2486                         subset="$LIB_SUBSETS" \
2487                         compat="$WITH_CURSES_H" \
2488                         $srcdir/$cf_dir/headers >>$cf_dir/Makefile
2489         fi
2490
2491         if test -f $srcdir/$cf_dir/modules; then
2492                 if test "$cf_dir" != "c++" ; then
2493                         cat >>$cf_dir/Makefile <<"CF_EOF"
2494 depend : ${AUTO_SRC}
2495         makedepend -- ${CPPFLAGS} -- ${C_SRC}
2496
2497 # DO NOT DELETE THIS LINE -- make depend depends on it.
2498 CF_EOF
2499                 fi
2500         fi
2501 done
2502
2503 ])dnl
2504 dnl ---------------------------------------------------------------------------
2505 dnl CF_LIB_SONAME version: 3 updated: 2006/12/16 15:55:46
2506 dnl -------------
2507 dnl Find the and soname for the given shared library.  Set the cache variable
2508 dnl cf_cv_$3_soname to this, unless it is not found.  Then set the cache
2509 dnl variable to "unknown".
2510 dnl
2511 dnl $1 = headers
2512 dnl $2 = code
2513 dnl $3 = library name
2514 AC_DEFUN([CF_LIB_SONAME],
2515 [
2516 AC_CACHE_CHECK(for soname of $3 library,cf_cv_$3_soname,[
2517
2518 cf_cv_$3_soname=unknown
2519 if test "$cross_compiling" != yes ; then
2520 cat >conftest.$ac_ext <<CF_EOF
2521 $1
2522 int main()
2523 {
2524 $2
2525         ${cf_cv_main_return:-return}(0);
2526 }
2527 CF_EOF
2528 cf_save_LIBS="$LIBS"
2529         LIBS="-l$3 $LIBS"
2530         if AC_TRY_EVAL(ac_compile) ; then
2531                 if AC_TRY_EVAL(ac_link) ; then
2532                         cf_cv_$3_soname=`ldd conftest$ac_exeext 2>/dev/null | sed -e 's,^.*/,,' -e 's, .*$,,' | fgrep lib$3.`
2533                         test -z "$cf_cv_$3_soname" && cf_cv_$3_soname=unknown
2534                 fi
2535         fi
2536 rm -f conftest*
2537 LIBS="$cf_save_LIBS"
2538 fi
2539 ])
2540 ])
2541 dnl ---------------------------------------------------------------------------
2542 dnl CF_LIB_SUFFIX version: 15 updated: 2008/09/13 11:54:48
2543 dnl -------------
2544 dnl Compute the library file-suffix from the given model name
2545 dnl $1 = model name
2546 dnl $2 = variable to set (the nominal library suffix)
2547 dnl $3 = dependency variable to set (actual filename)
2548 dnl The variable $LIB_SUFFIX, if set, prepends the variable to set.
2549 AC_DEFUN([CF_LIB_SUFFIX],
2550 [
2551         AC_REQUIRE([CF_SUBST_NCURSES_VERSION])
2552         case $1 in
2553         libtool)
2554                 $2='.la'
2555                 $3=[$]$2
2556                 ;;
2557         normal)
2558                 $2='.a'
2559                 $3=[$]$2
2560                 ;;
2561         debug)
2562                 $2='_g.a'
2563                 $3=[$]$2
2564                 ;;
2565         profile)
2566                 $2='_p.a'
2567                 $3=[$]$2
2568                 ;;
2569         shared)
2570                 case $cf_cv_system_name in
2571                 cygwin*)
2572                         $2='.dll'
2573                         $3='.dll.a'
2574                         ;;
2575                 darwin*)
2576                         $2='.dylib'
2577                         $3=[$]$2
2578                         ;;
2579                 hpux*)
2580                         case $target in
2581                         ia64*)
2582                                 $2='.so'
2583                                 $3=[$]$2
2584                                 ;;
2585                         *)
2586                                 $2='.sl'
2587                                 $3=[$]$2
2588                                 ;;
2589                         esac
2590                         ;;
2591                 *)      $2='.so'
2592                         $3=[$]$2
2593                         ;;
2594                 esac
2595         esac
2596         test -n "$LIB_SUFFIX" && $2="${LIB_SUFFIX}[$]{$2}"
2597         test -n "$LIB_SUFFIX" && $3="${LIB_SUFFIX}[$]{$3}"
2598 ])dnl
2599 dnl ---------------------------------------------------------------------------
2600 dnl CF_LIB_TYPE version: 4 updated: 2000/10/20 22:57:49
2601 dnl -----------
2602 dnl Compute the string to append to -library from the given model name
2603 dnl $1 = model name
2604 dnl $2 = variable to set
2605 dnl The variable $LIB_SUFFIX, if set, prepends the variable to set.
2606 AC_DEFUN([CF_LIB_TYPE],
2607 [
2608         case $1 in
2609         libtool) $2=''   ;;
2610         normal)  $2=''   ;;
2611         debug)   $2='_g' ;;
2612         profile) $2='_p' ;;
2613         shared)  $2=''   ;;
2614         esac
2615         test -n "$LIB_SUFFIX" && $2="${LIB_SUFFIX}[$]{$2}"
2616 ])dnl
2617 dnl ---------------------------------------------------------------------------
2618 dnl CF_LINK_DATAONLY version: 8 updated: 2006/12/16 12:33:30
2619 dnl ----------------
2620 dnl Some systems have a non-ANSI linker that doesn't pull in modules that have
2621 dnl only data (i.e., no functions), for example NeXT.  On those systems we'll
2622 dnl have to provide wrappers for global tables to ensure they're linked
2623 dnl properly.
2624 AC_DEFUN([CF_LINK_DATAONLY],
2625 [
2626 AC_MSG_CHECKING([if data-only library module links])
2627 AC_CACHE_VAL(cf_cv_link_dataonly,[
2628         rm -f conftest.a
2629         cat >conftest.$ac_ext <<EOF
2630 #line __oline__ "configure"
2631 int     testdata[[3]] = { 123, 456, 789 };
2632 EOF
2633         if AC_TRY_EVAL(ac_compile) ; then
2634                 mv conftest.o data.o && \
2635                 ( $AR $AR_OPTS conftest.a data.o ) 2>&AC_FD_CC 1>/dev/null
2636         fi
2637         rm -f conftest.$ac_ext data.o
2638         cat >conftest.$ac_ext <<EOF
2639 #line __oline__ "configure"
2640 int     testfunc()
2641 {
2642 #if defined(NeXT)
2643         ${cf_cv_main_return:-return}(1);        /* I'm told this linker is broken */
2644 #else
2645         extern int testdata[[3]];
2646         return testdata[[0]] == 123
2647            &&  testdata[[1]] == 456
2648            &&  testdata[[2]] == 789;
2649 #endif
2650 }
2651 EOF
2652         if AC_TRY_EVAL(ac_compile); then
2653                 mv conftest.o func.o && \
2654                 ( $AR $AR_OPTS conftest.a func.o ) 2>&AC_FD_CC 1>/dev/null
2655         fi
2656         rm -f conftest.$ac_ext func.o
2657         ( eval $RANLIB conftest.a ) 2>&AC_FD_CC >/dev/null
2658         cf_saveLIBS="$LIBS"
2659         LIBS="conftest.a $LIBS"
2660         AC_TRY_RUN([
2661         int main()
2662         {
2663                 extern int testfunc();
2664                 ${cf_cv_main_return:-return} (!testfunc());
2665         }
2666         ],
2667         [cf_cv_link_dataonly=yes],
2668         [cf_cv_link_dataonly=no],
2669         [cf_cv_link_dataonly=unknown])
2670         LIBS="$cf_saveLIBS"
2671         ])
2672 AC_MSG_RESULT($cf_cv_link_dataonly)
2673
2674 if test "$cf_cv_link_dataonly" = no ; then
2675         AC_DEFINE(BROKEN_LINKER)
2676         BROKEN_LINKER=1
2677 fi
2678
2679 ])dnl
2680 dnl ---------------------------------------------------------------------------
2681 dnl CF_LINK_FUNCS version: 7 updated: 2006/12/16 12:33:30
2682 dnl -------------
2683 dnl Most Unix systems have both link and symlink, a few don't have symlink.
2684 dnl A few non-Unix systems implement symlink, but not link.
2685 dnl A few non-systems implement neither (or have nonfunctional versions).
2686 AC_DEFUN([CF_LINK_FUNCS],
2687 [
2688 AC_CHECK_FUNCS( \
2689         remove \
2690         unlink )
2691
2692 if test "$cross_compiling" = yes ; then
2693         AC_CHECK_FUNCS( \
2694                 link \
2695                 symlink )
2696 else
2697         AC_CACHE_CHECK(if link/symlink functions work,cf_cv_link_funcs,[
2698                 cf_cv_link_funcs=
2699                 for cf_func in link symlink ; do
2700                         AC_TRY_RUN([
2701 #include <sys/types.h>
2702 #include <sys/stat.h>
2703 #ifdef HAVE_UNISTD_H
2704 #include <unistd.h>
2705 #endif
2706 int main()
2707 {
2708         int fail = 0;
2709         char *src = "config.log";
2710         char *dst = "conftest.chk";
2711         struct stat src_sb;
2712         struct stat dst_sb;
2713
2714         stat(src, &src_sb);
2715         fail = ($cf_func("config.log", "conftest.chk") < 0)
2716             || (stat(dst, &dst_sb) < 0)
2717             || (dst_sb.st_mtime != src_sb.st_mtime);
2718 #ifdef HAVE_UNLINK
2719         unlink(dst);
2720 #else
2721         remove(dst);
2722 #endif
2723         ${cf_cv_main_return:-return} (fail);
2724 }
2725                         ],[
2726                         cf_cv_link_funcs="$cf_cv_link_funcs $cf_func"
2727                         eval 'ac_cv_func_'$cf_func'=yes'],[
2728                         eval 'ac_cv_func_'$cf_func'=no'],[
2729                         eval 'ac_cv_func_'$cf_func'=error'])
2730                 done
2731                 test -z "$cf_cv_link_funcs" && cf_cv_link_funcs=no
2732         ])
2733         test "$ac_cv_func_link"    = yes && AC_DEFINE(HAVE_LINK)
2734         test "$ac_cv_func_symlink" = yes && AC_DEFINE(HAVE_SYMLINK)
2735 fi
2736 ])dnl
2737 dnl ---------------------------------------------------------------------------
2738 dnl CF_MAIN_RETURN version: 1 updated: 2006/12/10 09:51:54
2739 dnl --------------
2740 dnl Check if a return from main to the shell actually returns the same exit
2741 dnl code.  This is true for almost any POSIX environment.
2742 dnl
2743 dnl Some very old environments did not flush stdout, etc., on an exit.  That
2744 dnl would be a useful case to test for also.
2745 AC_DEFUN([CF_MAIN_RETURN],
2746 [
2747 cf_cv_main_return=return
2748 ])dnl
2749 dnl ---------------------------------------------------------------------------
2750 dnl CF_MAKEFLAGS version: 12 updated: 2006/10/21 08:27:03
2751 dnl ------------
2752 dnl Some 'make' programs support ${MAKEFLAGS}, some ${MFLAGS}, to pass 'make'
2753 dnl options to lower-levels.  It's very useful for "make -n" -- if we have it.
2754 dnl (GNU 'make' does both, something POSIX 'make', which happens to make the
2755 dnl ${MAKEFLAGS} variable incompatible because it adds the assignments :-)
2756 AC_DEFUN([CF_MAKEFLAGS],
2757 [
2758 AC_CACHE_CHECK(for makeflags variable, cf_cv_makeflags,[
2759         cf_cv_makeflags=''
2760         for cf_option in '-${MAKEFLAGS}' '${MFLAGS}'
2761         do
2762                 cat >cf_makeflags.tmp <<CF_EOF
2763 SHELL = /bin/sh
2764 all :
2765         @ echo '.$cf_option'
2766 CF_EOF
2767                 cf_result=`${MAKE-make} -k -f cf_makeflags.tmp 2>/dev/null | sed -e 's,[[       ]]*$,,'`
2768                 case "$cf_result" in
2769                 .*k)
2770                         cf_result=`${MAKE-make} -k -f cf_makeflags.tmp CC=cc 2>/dev/null`
2771                         case "$cf_result" in
2772                         .*CC=*) cf_cv_makeflags=
2773                                 ;;
2774                         *)      cf_cv_makeflags=$cf_option
2775                                 ;;
2776                         esac
2777                         break
2778                         ;;
2779                 .-)     ;;
2780                 *)      echo "given option \"$cf_option\", no match \"$cf_result\""
2781                         ;;
2782                 esac
2783         done
2784         rm -f cf_makeflags.tmp
2785 ])
2786
2787 AC_SUBST(cf_cv_makeflags)
2788 ])dnl
2789 dnl ---------------------------------------------------------------------------
2790 dnl CF_MAKE_TAGS version: 2 updated: 2000/10/04 09:18:40
2791 dnl ------------
2792 dnl Generate tags/TAGS targets for makefiles.  Do not generate TAGS if we have
2793 dnl a monocase filesystem.
2794 AC_DEFUN([CF_MAKE_TAGS],[
2795 AC_REQUIRE([CF_MIXEDCASE_FILENAMES])
2796 AC_CHECK_PROG(MAKE_LOWER_TAGS, ctags, yes, no)
2797
2798 if test "$cf_cv_mixedcase" = yes ; then
2799         AC_CHECK_PROG(MAKE_UPPER_TAGS, etags, yes, no)
2800 else
2801         MAKE_UPPER_TAGS=no
2802 fi
2803
2804 if test "$MAKE_UPPER_TAGS" = yes ; then
2805         MAKE_UPPER_TAGS=
2806 else
2807         MAKE_UPPER_TAGS="#"
2808 fi
2809 AC_SUBST(MAKE_UPPER_TAGS)
2810
2811 if test "$MAKE_LOWER_TAGS" = yes ; then
2812         MAKE_LOWER_TAGS=
2813 else
2814         MAKE_LOWER_TAGS="#"
2815 fi
2816 AC_SUBST(MAKE_LOWER_TAGS)
2817 ])dnl
2818 dnl ---------------------------------------------------------------------------
2819 dnl CF_MANPAGE_FORMAT version: 7 updated: 2003/12/20 19:30:34
2820 dnl -----------------
2821 dnl Option to allow user to override automatic configuration of manpage format.
2822 dnl There are several special cases:
2823 dnl
2824 dnl     gzip - man checks for, can display gzip'd files
2825 dnl     compress - man checks for, can display compressed files
2826 dnl     BSDI - files in the cat-directories are suffixed ".0"
2827 dnl     formatted - installer should format (put files in cat-directory)
2828 dnl     catonly - installer should only format, e.g., for a turnkey system.
2829 dnl
2830 dnl There are other configurations which this macro does not test, e.g., HPUX's
2831 dnl compressed manpages (but uncompressed manpages are fine, and HPUX's naming
2832 dnl convention would not match our use).
2833 AC_DEFUN([CF_MANPAGE_FORMAT],
2834 [
2835 AC_REQUIRE([CF_PATHSEP])
2836 AC_MSG_CHECKING(format of man-pages)
2837
2838 AC_ARG_WITH(manpage-format,
2839         [  --with-manpage-format   specify manpage-format: gzip/compress/BSDI/normal and
2840                           optionally formatted/catonly, e.g., gzip,formatted],
2841         [MANPAGE_FORMAT=$withval],
2842         [MANPAGE_FORMAT=unknown])
2843
2844 test -z "$MANPAGE_FORMAT" && MANPAGE_FORMAT=unknown
2845 MANPAGE_FORMAT=`echo "$MANPAGE_FORMAT" | sed -e 's/,/ /g'`
2846
2847 cf_unknown=
2848
2849 case $MANPAGE_FORMAT in
2850 unknown)
2851   if test -z "$MANPATH" ; then
2852     MANPATH="/usr/man:/usr/share/man"
2853   fi
2854
2855   # look for the 'date' man-page (it's most likely to be installed!)
2856   MANPAGE_FORMAT=
2857   cf_preform=no
2858   cf_catonly=yes
2859   cf_example=date
2860
2861   IFS="${IFS=   }"; ac_save_ifs="$IFS"; IFS="${IFS}${PATHSEP}"
2862   for cf_dir in $MANPATH; do
2863     test -z "$cf_dir" && cf_dir=/usr/man
2864     for cf_name in $cf_dir/man*/$cf_example.[[01]]* $cf_dir/cat*/$cf_example.[[01]]* $cf_dir/man*/$cf_example $cf_dir/cat*/$cf_example
2865     do
2866       cf_test=`echo $cf_name | sed -e 's/*//'`
2867       if test "x$cf_test" = "x$cf_name" ; then
2868
2869         case "$cf_name" in
2870         *.gz) MANPAGE_FORMAT="$MANPAGE_FORMAT gzip";;
2871         *.Z)  MANPAGE_FORMAT="$MANPAGE_FORMAT compress";;
2872         *.0)    MANPAGE_FORMAT="$MANPAGE_FORMAT BSDI";;
2873         *)    MANPAGE_FORMAT="$MANPAGE_FORMAT normal";;
2874         esac
2875
2876         case "$cf_name" in
2877         $cf_dir/man*)
2878           cf_catonly=no
2879           ;;
2880         $cf_dir/cat*)
2881           cf_preform=yes
2882           ;;
2883         esac
2884         break
2885       fi
2886
2887       # if we found a match in either man* or cat*, stop looking
2888       if test -n "$MANPAGE_FORMAT" ; then
2889         cf_found=no
2890         test "$cf_preform" = yes && MANPAGE_FORMAT="$MANPAGE_FORMAT formatted"
2891         test "$cf_catonly" = yes && MANPAGE_FORMAT="$MANPAGE_FORMAT catonly"
2892         case "$cf_name" in
2893         $cf_dir/cat*)
2894           cf_found=yes
2895           ;;
2896         esac
2897         test $cf_found=yes && break
2898       fi
2899     done
2900     # only check the first directory in $MANPATH where we find manpages
2901     if test -n "$MANPAGE_FORMAT" ; then
2902        break
2903     fi
2904   done
2905   # if we did not find the example, just assume it is normal
2906   test -z "$MANPAGE_FORMAT" && MANPAGE_FORMAT=normal
2907   IFS="$ac_save_ifs"
2908   ;;
2909 *)
2910   for cf_option in $MANPAGE_FORMAT; do
2911      case $cf_option in #(vi
2912      gzip|compress|BSDI|normal|formatted|catonly)
2913        ;;
2914      *)
2915        cf_unknown="$cf_unknown $cf_option"
2916        ;;
2917      esac
2918   done
2919   ;;
2920 esac
2921
2922 AC_MSG_RESULT($MANPAGE_FORMAT)
2923 if test -n "$cf_unknown" ; then
2924   AC_MSG_WARN(Unexpected manpage-format $cf_unknown)
2925 fi
2926 ])dnl
2927 dnl ---------------------------------------------------------------------------
2928 dnl CF_MANPAGE_RENAMES version: 7 updated: 2005/06/18 18:51:57
2929 dnl ------------------
2930 dnl The Debian people have their own naming convention for manpages.  This
2931 dnl option lets us override the name of the file containing renaming, or
2932 dnl disable it altogether.
2933 AC_DEFUN([CF_MANPAGE_RENAMES],
2934 [
2935 AC_MSG_CHECKING(for manpage renaming)
2936
2937 AC_ARG_WITH(manpage-renames,
2938         [  --with-manpage-renames  specify manpage-renaming],
2939         [MANPAGE_RENAMES=$withval],
2940         [MANPAGE_RENAMES=yes])
2941
2942 case ".$MANPAGE_RENAMES" in #(vi
2943 .no) #(vi
2944   ;;
2945 .|.yes)
2946   # Debian 'man' program?
2947   if test -f /etc/debian_version ; then
2948     MANPAGE_RENAMES=`cd $srcdir && pwd`/man/man_db.renames
2949   else
2950     MANPAGE_RENAMES=no
2951   fi
2952   ;;
2953 esac
2954
2955 if test "$MANPAGE_RENAMES" != no ; then
2956   if test -f $srcdir/man/$MANPAGE_RENAMES ; then
2957     MANPAGE_RENAMES=`cd $srcdir/man && pwd`/$MANPAGE_RENAMES
2958   elif test ! -f $MANPAGE_RENAMES ; then
2959     AC_MSG_ERROR(not a filename: $MANPAGE_RENAMES)
2960   fi
2961
2962   test ! -d man && mkdir man
2963
2964   # Construct a sed-script to perform renaming within man-pages
2965   if test -n "$MANPAGE_RENAMES" ; then
2966     test ! -d man && mkdir man
2967     sh $srcdir/man/make_sed.sh $MANPAGE_RENAMES >./edit_man.sed
2968   fi
2969 fi
2970
2971 AC_MSG_RESULT($MANPAGE_RENAMES)
2972 AC_SUBST(MANPAGE_RENAMES)
2973 ])dnl
2974 dnl ---------------------------------------------------------------------------
2975 dnl CF_MANPAGE_SYMLINKS version: 4 updated: 2003/12/13 18:01:58
2976 dnl -------------------
2977 dnl Some people expect each tool to make all aliases for manpages in the
2978 dnl man-directory.  This accommodates the older, less-capable implementations
2979 dnl of 'man', and is optional.
2980 AC_DEFUN([CF_MANPAGE_SYMLINKS],
2981 [
2982 AC_MSG_CHECKING(if manpage aliases will be installed)
2983
2984 AC_ARG_WITH(manpage-aliases,
2985         [  --with-manpage-aliases  specify manpage-aliases using .so],
2986         [MANPAGE_ALIASES=$withval],
2987         [MANPAGE_ALIASES=yes])
2988
2989 AC_MSG_RESULT($MANPAGE_ALIASES)
2990
2991 if test "$LN_S" = "ln -s"; then
2992         cf_use_symlinks=yes
2993 else
2994         cf_use_symlinks=no
2995 fi
2996
2997 MANPAGE_SYMLINKS=no
2998 if test "$MANPAGE_ALIASES" = yes ; then
2999 AC_MSG_CHECKING(if manpage symlinks should be used)
3000
3001 AC_ARG_WITH(manpage-symlinks,
3002         [  --with-manpage-symlinks specify manpage-aliases using symlinks],
3003         [MANPAGE_SYMLINKS=$withval],
3004         [MANPAGE_SYMLINKS=$cf_use_symlinks])
3005
3006 if test "$$cf_use_symlinks" = no; then
3007 if test "$MANPAGE_SYMLINKS" = yes ; then
3008         AC_MSG_WARN(cannot make symlinks, will use .so files)
3009         MANPAGE_SYMLINKS=no
3010 fi
3011 fi
3012
3013 AC_MSG_RESULT($MANPAGE_SYMLINKS)
3014 fi
3015
3016 ])dnl
3017 dnl ---------------------------------------------------------------------------
3018 dnl CF_MANPAGE_TBL version: 3 updated: 2002/01/19 22:51:32
3019 dnl --------------
3020 dnl This option causes manpages to be run through tbl(1) to generate tables
3021 dnl correctly.
3022 AC_DEFUN([CF_MANPAGE_TBL],
3023 [
3024 AC_MSG_CHECKING(for manpage tbl)
3025
3026 AC_ARG_WITH(manpage-tbl,
3027         [  --with-manpage-tbl      specify manpage processing with tbl],
3028         [MANPAGE_TBL=$withval],
3029         [MANPAGE_TBL=no])
3030
3031 AC_MSG_RESULT($MANPAGE_TBL)
3032 ])dnl
3033 dnl ---------------------------------------------------------------------------
3034 dnl CF_MAN_PAGES version: 35 updated: 2007/03/31 11:47:29
3035 dnl ------------
3036 dnl Try to determine if the man-pages on the system are compressed, and if
3037 dnl so, what format is used.  Use this information to construct a script that
3038 dnl will install man-pages.
3039 AC_DEFUN([CF_MAN_PAGES],
3040 [
3041 CF_HELP_MESSAGE(Options to Specify How Manpages are Installed:)
3042 CF_MANPAGE_FORMAT
3043 CF_MANPAGE_RENAMES
3044 CF_MANPAGE_SYMLINKS
3045 CF_MANPAGE_TBL
3046
3047   if test "$prefix" = "NONE" ; then
3048      cf_prefix="$ac_default_prefix"
3049   else
3050      cf_prefix="$prefix"
3051   fi
3052
3053   case "$MANPAGE_FORMAT" in # (vi
3054   *catonly*) # (vi
3055     cf_format=yes
3056     cf_inboth=no
3057     ;;
3058   *formatted*) # (vi
3059     cf_format=yes
3060     cf_inboth=yes
3061     ;;
3062   *)
3063     cf_format=no
3064     cf_inboth=no
3065     ;;
3066   esac
3067
3068 test ! -d man && mkdir man
3069
3070 cf_so_strip=
3071 cf_compress=
3072 case "$MANPAGE_FORMAT" in #(vi
3073 *compress*) #(vi
3074         cf_so_strip="Z"
3075         cf_compress=compress
3076   ;;
3077 *gzip*) #(vi
3078         cf_so_strip="gz"
3079         cf_compress=gzip
3080   ;;
3081 esac
3082
3083 cf_edit_man=./edit_man.sh
3084 cf_man_alias=`pwd`/man_alias.sed
3085
3086 cat >$cf_edit_man <<CF_EOF
3087 #! /bin/sh
3088 # this script is generated by the configure-script CF_MAN_PAGES macro.
3089
3090 prefix="$cf_prefix"
3091 datadir="$datadir"
3092
3093 NCURSES_MAJOR="$NCURSES_MAJOR"
3094 NCURSES_MINOR="$NCURSES_MINOR"
3095 NCURSES_PATCH="$NCURSES_PATCH"
3096
3097 NCURSES_OSPEED="$NCURSES_OSPEED"
3098 TERMINFO="$TERMINFO"
3099
3100 MKDIRS="sh `cd $srcdir && pwd`/mkdirs.sh"
3101
3102 INSTALL="$INSTALL"
3103 INSTALL_DATA="$INSTALL_DATA"
3104
3105 transform="$program_transform_name"
3106
3107 TMP=\${TMPDIR-/tmp}/man\$\$
3108 trap "rm -f \$TMP" 0 1 2 5 15
3109
3110 form=\[$]1
3111 shift || exit 1
3112
3113 verb=\[$]1
3114 shift || exit 1
3115
3116 mandir=\[$]1
3117 shift || exit 1
3118
3119 srcdir=\[$]1
3120 top_srcdir=\[$]srcdir/..
3121 shift || exit 1
3122
3123 if test "\$form" = normal ; then
3124         if test "$cf_format" = yes ; then
3125         if test "$cf_inboth" = no ; then
3126                 sh \[$]0 format \$verb \$mandir \$srcdir \[$]*
3127                 exit $?
3128         fi
3129         fi
3130         cf_subdir=\$mandir/man
3131         cf_tables=$MANPAGE_TBL
3132 else
3133         cf_subdir=\$mandir/cat
3134         cf_tables=yes
3135 fi
3136
3137 # process the list of source-files
3138 for i in \[$]* ; do
3139 case \$i in #(vi
3140 *.orig|*.rej) ;; #(vi
3141 *.[[0-9]]*)
3142         section=\`expr "\$i" : '.*\\.\\([[0-9]]\\)[[xm]]*'\`;
3143         if test \$verb = installing ; then
3144         if test ! -d \$cf_subdir\${section} ; then
3145                 \$MKDIRS \$cf_subdir\$section
3146         fi
3147         fi
3148
3149         # replace variables in man page
3150         if test ! -f $cf_man_alias ; then
3151 cat >>$cf_man_alias <<-CF_EOF2
3152                 s,@DATADIR@,\$datadir,g
3153                 s,@TERMINFO@,\$TERMINFO,g
3154                 s,@NCURSES_MAJOR@,\$NCURSES_MAJOR,g
3155                 s,@NCURSES_MINOR@,\$NCURSES_MINOR,g
3156                 s,@NCURSES_PATCH@,\$NCURSES_PATCH,g
3157                 s,@NCURSES_OSPEED@,\$NCURSES_OSPEED,g
3158 CF_EOF
3159         ifelse($1,,,[
3160         for cf_name in $1
3161         do
3162                 cf_NAME=`echo "$cf_name" | sed y%abcdefghijklmnopqrstuvwxyz./-%ABCDEFGHIJKLMNOPQRSTUVWXYZ___%`
3163                 cf_name=`echo $cf_name|sed "$program_transform_name"`
3164 cat >>$cf_edit_man <<-CF_EOF
3165                 s,@$cf_NAME@,$cf_name,
3166 CF_EOF
3167         done
3168         ])
3169 cat >>$cf_edit_man <<CF_EOF
3170 CF_EOF2
3171                 echo "...made $cf_man_alias"
3172         fi
3173
3174         aliases=
3175         cf_source=\`basename \$i\`
3176         inalias=\$cf_source
3177         test ! -f \$inalias && inalias="\$srcdir/\$inalias"
3178         if test ! -f \$inalias ; then
3179                 echo .. skipped \$cf_source
3180                 continue
3181         fi
3182 CF_EOF
3183
3184 if test "$MANPAGE_ALIASES" != no ; then
3185 cat >>$cf_edit_man <<CF_EOF
3186         aliases=\`sed -f \$top_srcdir/man/manlinks.sed \$inalias |sed -f $cf_man_alias | sort -u\`
3187 CF_EOF
3188 fi
3189
3190 if test "$MANPAGE_RENAMES" = no ; then
3191 cat >>$cf_edit_man <<CF_EOF
3192         # perform program transformations for section 1 man pages
3193         if test \$section = 1 ; then
3194                 cf_target=\$cf_subdir\${section}/\`echo \$cf_source|sed "\${transform}"\`
3195         else
3196                 cf_target=\$cf_subdir\${section}/\$cf_source
3197         fi
3198 CF_EOF
3199 else
3200 cat >>$cf_edit_man <<CF_EOF
3201         cf_target=\`grep "^\$cf_source" $MANPAGE_RENAMES | $AWK '{print \[$]2}'\`
3202         if test -z "\$cf_target" ; then
3203                 echo '? missing rename for '\$cf_source
3204                 cf_target="\$cf_source"
3205         fi
3206         cf_target="\$cf_subdir\${section}/\${cf_target}"
3207
3208 CF_EOF
3209 fi
3210
3211 cat >>$cf_edit_man <<CF_EOF
3212         sed     -f $cf_man_alias \\
3213 CF_EOF
3214
3215 if test -f $MANPAGE_RENAMES ; then
3216 cat >>$cf_edit_man <<CF_EOF
3217                 < \$i | sed -f `pwd`/edit_man.sed >\$TMP
3218 CF_EOF
3219 else
3220 cat >>$cf_edit_man <<CF_EOF
3221                 < \$i >\$TMP
3222 CF_EOF
3223 fi
3224
3225 cat >>$cf_edit_man <<CF_EOF
3226 if test \$cf_tables = yes ; then
3227         tbl \$TMP >\$TMP.out
3228         mv \$TMP.out \$TMP
3229 fi
3230 CF_EOF
3231
3232 if test $with_curses_h != yes ; then
3233 cat >>$cf_edit_man <<CF_EOF
3234         sed -e "/\#[    ]*include/s,curses.h,ncurses.h," < \$TMP >\$TMP.out
3235         mv \$TMP.out \$TMP
3236 CF_EOF
3237 fi
3238
3239 cat >>$cf_edit_man <<CF_EOF
3240         if test \$form = format ; then
3241                 nroff -man \$TMP >\$TMP.out
3242                 mv \$TMP.out \$TMP
3243         fi
3244 CF_EOF
3245
3246 if test -n "$cf_compress" ; then
3247 cat >>$cf_edit_man <<CF_EOF
3248         if test \$verb = installing ; then
3249         if ( $cf_compress -f \$TMP )
3250         then
3251                 mv \$TMP.$cf_so_strip \$TMP
3252         fi
3253         fi
3254         cf_target="\$cf_target.$cf_so_strip"
3255 CF_EOF
3256 fi
3257
3258 case "$MANPAGE_FORMAT" in #(vi
3259 *BSDI*)
3260 cat >>$cf_edit_man <<CF_EOF
3261         if test \$form = format ; then
3262                 # BSDI installs only .0 suffixes in the cat directories
3263                 cf_target="\`echo \$cf_target|sed -e 's/\.[[1-9]]\+[[a-z]]*/.0/'\`"
3264         fi
3265 CF_EOF
3266   ;;
3267 esac
3268
3269 cat >>$cf_edit_man <<CF_EOF
3270         suffix=\`basename \$cf_target | sed -e 's%^[[^.]]*%%'\`
3271         if test \$verb = installing ; then
3272                 echo \$verb \$cf_target
3273                 \$INSTALL_DATA \$TMP \$cf_target
3274                 test -d \$cf_subdir\${section} &&
3275                 test -n "\$aliases" && (
3276                         cd \$cf_subdir\${section} && (
3277                                 cf_source=\`echo \$cf_target |sed -e 's%^.*/\([[^/]][[^/]]*/[[^/]][[^/]]*$\)%\1%'\`
3278                                 test -n "$cf_so_strip" && cf_source=\`echo \$cf_source |sed -e 's%\.$cf_so_strip\$%%'\`
3279                                 cf_target=\`basename \$cf_target\`
3280                                 for cf_alias in \$aliases
3281                                 do
3282                                         if test \$section = 1 ; then
3283                                                 cf_alias=\`echo \$cf_alias|sed "\${transform}"\`
3284                                         fi
3285
3286                                         if test "$MANPAGE_SYMLINKS" = yes ; then
3287                                                 if test -f \$cf_alias\${suffix} ; then
3288                                                         if ( cmp -s \$cf_target \$cf_alias\${suffix} )
3289                                                         then
3290                                                                 continue
3291                                                         fi
3292                                                 fi
3293                                                 echo .. \$verb alias \$cf_alias\${suffix}
3294                                                 rm -f \$cf_alias\${suffix}
3295                                                 $LN_S \$cf_target \$cf_alias\${suffix}
3296                                         elif test "\$cf_target" != "\$cf_alias\${suffix}" ; then
3297                                                 echo ".so \$cf_source" >\$TMP
3298 CF_EOF
3299 if test -n "$cf_compress" ; then
3300 cat >>$cf_edit_man <<CF_EOF
3301                                                 if test -n "$cf_so_strip" ; then
3302                                                         $cf_compress -f \$TMP
3303                                                         mv \$TMP.$cf_so_strip \$TMP
3304                                                 fi
3305 CF_EOF
3306 fi
3307 cat >>$cf_edit_man <<CF_EOF
3308                                                 echo .. \$verb alias \$cf_alias\${suffix}
3309                                                 rm -f \$cf_alias\${suffix}
3310                                                 \$INSTALL_DATA \$TMP \$cf_alias\${suffix}
3311                                         fi
3312                                 done
3313                         )
3314                 )
3315         elif test \$verb = removing ; then
3316                 test -f \$cf_target && (
3317                         echo \$verb \$cf_target
3318                         rm -f \$cf_target
3319                 )
3320                 test -d \$cf_subdir\${section} &&
3321                 test -n "\$aliases" && (
3322                         cd \$cf_subdir\${section} && (
3323                                 for cf_alias in \$aliases
3324                                 do
3325                                         if test \$section = 1 ; then
3326                                                 cf_alias=\`echo \$cf_alias|sed "\${transform}"\`
3327                                         fi
3328
3329                                         echo .. \$verb alias \$cf_alias\${suffix}
3330                                         rm -f \$cf_alias\${suffix}
3331                                 done
3332                         )
3333                 )
3334         else
3335 #               echo ".hy 0"
3336                 cat \$TMP
3337         fi
3338         ;;
3339 esac
3340 done
3341
3342 if test $cf_inboth = yes ; then
3343 if test \$form != format ; then
3344         sh \[$]0 format \$verb \$mandir \$srcdir \[$]*
3345 fi
3346 fi
3347
3348 exit 0
3349 CF_EOF
3350 chmod 755 $cf_edit_man
3351
3352 ])dnl
3353 dnl ---------------------------------------------------------------------------
3354 dnl CF_MATH_LIB version: 5 updated: 2000/05/28 01:39:10
3355 dnl -----------
3356 dnl Checks for libraries.  At least one UNIX system, Apple Macintosh
3357 dnl Rhapsody 5.5, does not have -lm.  We cannot use the simpler
3358 dnl AC_CHECK_LIB(m,sin), because that fails for C++.
3359 AC_DEFUN([CF_MATH_LIB],
3360 [
3361 AC_CACHE_CHECK(if -lm needed for math functions,
3362         cf_cv_need_libm,[
3363         AC_TRY_LINK([
3364         #include <stdio.h>
3365         #include <math.h>
3366         ],
3367         [double x = rand(); printf("result = %g\n", ]ifelse($2,,sin(x),$2)[)],
3368         [cf_cv_need_libm=no],
3369         [cf_cv_need_libm=yes])])
3370 if test "$cf_cv_need_libm" = yes
3371 then
3372 ifelse($1,,[
3373         LIBS="$LIBS -lm"
3374 ],[$1=-lm])
3375 fi
3376 ])
3377 dnl ---------------------------------------------------------------------------
3378 dnl CF_MIXEDCASE_FILENAMES version: 3 updated: 2003/09/20 17:07:55
3379 dnl ----------------------
3380 dnl Check if the file-system supports mixed-case filenames.  If we're able to
3381 dnl create a lowercase name and see it as uppercase, it doesn't support that.
3382 AC_DEFUN([CF_MIXEDCASE_FILENAMES],
3383 [
3384 AC_CACHE_CHECK(if filesystem supports mixed-case filenames,cf_cv_mixedcase,[
3385 if test "$cross_compiling" = yes ; then
3386         case $target_alias in #(vi
3387         *-os2-emx*|*-msdosdjgpp*|*-cygwin*|*-mingw32*|*-uwin*) #(vi
3388                 cf_cv_mixedcase=no
3389                 ;;
3390         *)
3391                 cf_cv_mixedcase=yes
3392                 ;;
3393         esac
3394 else
3395         rm -f conftest CONFTEST
3396         echo test >conftest
3397         if test -f CONFTEST ; then
3398                 cf_cv_mixedcase=no
3399         else
3400                 cf_cv_mixedcase=yes
3401         fi
3402         rm -f conftest CONFTEST
3403 fi
3404 ])
3405 test "$cf_cv_mixedcase" = yes && AC_DEFINE(MIXEDCASE_FILENAMES)
3406 ])dnl
3407 dnl ---------------------------------------------------------------------------
3408 dnl CF_MKSTEMP version: 5 updated: 2006/12/16 12:33:30
3409 dnl ----------
3410 dnl Check for a working mkstemp.  This creates two files, checks that they are
3411 dnl successfully created and distinct (AmigaOS apparently fails on the last).
3412 AC_DEFUN([CF_MKSTEMP],[
3413 AC_CACHE_CHECK(for working mkstemp, cf_cv_func_mkstemp,[
3414 rm -f conftest*
3415 AC_TRY_RUN([
3416 #include <sys/types.h>
3417 #include <stdlib.h>
3418 #include <stdio.h>
3419 #include <string.h>
3420 #include <sys/stat.h>
3421 int main()
3422 {
3423         char *tmpl = "conftestXXXXXX";
3424         char name[2][80];
3425         int n;
3426         int result = 0;
3427         int fd;
3428         struct stat sb;
3429
3430         umask(077);
3431         for (n = 0; n < 2; ++n) {
3432                 strcpy(name[n], tmpl);
3433                 if ((fd = mkstemp(name[n])) >= 0) {
3434                         if (!strcmp(name[n], tmpl)
3435                          || stat(name[n], &sb) != 0
3436                          || (sb.st_mode & S_IFMT) != S_IFREG
3437                          || (sb.st_mode & 077) != 0) {
3438                                 result = 1;
3439                         }
3440                         close(fd);
3441                 }
3442         }
3443         if (result == 0
3444          && !strcmp(name[0], name[1]))
3445                 result = 1;
3446         ${cf_cv_main_return:-return}(result);
3447 }
3448 ],[cf_cv_func_mkstemp=yes
3449 ],[cf_cv_func_mkstemp=no
3450 ],[AC_CHECK_FUNC(mkstemp)
3451 ])
3452 ])
3453 if test "$cf_cv_func_mkstemp" = yes ; then
3454         AC_DEFINE(HAVE_MKSTEMP)
3455 fi
3456 ])dnl
3457 dnl ---------------------------------------------------------------------------
3458 dnl CF_MSG_LOG version: 4 updated: 2007/07/29 09:55:12
3459 dnl ----------
3460 dnl Write a debug message to config.log, along with the line number in the
3461 dnl configure script.
3462 AC_DEFUN([CF_MSG_LOG],[
3463 echo "${as_me-configure}:__oline__: testing $* ..." 1>&AC_FD_CC
3464 ])dnl
3465 dnl ---------------------------------------------------------------------------
3466 dnl CF_NCURSES_ABI_6 version: 1 updated: 2005/09/17 18:42:49
3467 dnl ----------------
3468 dnl Set ncurses' ABI to 6 unless overridden by explicit configure option, and
3469 dnl warn about this.
3470 AC_DEFUN([CF_NCURSES_ABI_6],[
3471 if test "${with_abi_version+set}" != set; then
3472         case $cf_cv_rel_version in
3473         5.*)
3474                 cf_cv_rel_version=6.0
3475                 cf_cv_abi_version=6
3476                 AC_MSG_WARN(Overriding ABI version to $cf_cv_abi_version)
3477                 ;;
3478         esac
3479 fi
3480 ])dnl
3481 dnl ---------------------------------------------------------------------------
3482 dnl CF_NO_LEAKS_OPTION version: 4 updated: 2006/12/16 14:24:05
3483 dnl ------------------
3484 dnl see CF_WITH_NO_LEAKS
3485 AC_DEFUN([CF_NO_LEAKS_OPTION],[
3486 AC_MSG_CHECKING(if you want to use $1 for testing)
3487 AC_ARG_WITH($1,
3488         [$2],
3489         [AC_DEFINE($3)ifelse([$4],,[
3490          $4
3491 ])
3492         : ${with_cflags:=-g}
3493         : ${with_no_leaks:=yes}
3494          with_$1=yes],
3495         [with_$1=])
3496 AC_MSG_RESULT(${with_$1:-no})
3497
3498 case .$with_cflags in #(vi
3499 .*-g*)
3500         case .$CFLAGS in #(vi
3501         .*-g*) #(vi
3502                 ;;
3503         *)
3504                 CF_ADD_CFLAGS([-g])
3505                 ;;
3506         esac
3507         ;;
3508 esac
3509 ])dnl
3510 dnl ---------------------------------------------------------------------------
3511 dnl CF_NUMBER_SYNTAX version: 1 updated: 2003/09/20 18:12:49
3512 dnl ----------------
3513 dnl Check if the given variable is a number.  If not, report an error.
3514 dnl $1 is the variable
3515 dnl $2 is the message
3516 AC_DEFUN([CF_NUMBER_SYNTAX],[
3517 if test -n "$1" ; then
3518   case $1 in #(vi
3519   [[0-9]]*) #(vi
3520         ;;
3521   *)
3522         AC_MSG_ERROR($2 is not a number: $1)
3523         ;;
3524   esac
3525 else
3526   AC_MSG_ERROR($2 value is empty)
3527 fi
3528 ])dnl
3529 dnl ---------------------------------------------------------------------------
3530 dnl CF_OBJ_SUBDIR version: 4 updated: 2002/02/23 20:38:31
3531 dnl -------------
3532 dnl Compute the object-directory name from the given model name
3533 AC_DEFUN([CF_OBJ_SUBDIR],
3534 [
3535         case $1 in
3536         libtool) $2='obj_lo'  ;;
3537         normal)  $2='objects' ;;
3538         debug)   $2='obj_g' ;;
3539         profile) $2='obj_p' ;;
3540         shared)
3541                 case $cf_cv_system_name in #(vi
3542                 cygwin) #(vi
3543                         $2='objects' ;;
3544                 *)
3545                         $2='obj_s' ;;
3546                 esac
3547         esac
3548 ])dnl
3549 dnl ---------------------------------------------------------------------------
3550 dnl CF_PATHSEP version: 3 updated: 2001/01/12 01:23:53
3551 dnl ----------
3552 dnl Provide a value for the $PATH and similar separator
3553 AC_DEFUN([CF_PATHSEP],
3554 [
3555         case $cf_cv_system_name in
3556         os2*)   PATHSEP=';'  ;;
3557         *)      PATHSEP=':'  ;;
3558         esac
3559 ifelse($1,,,[$1=$PATHSEP])
3560         AC_SUBST(PATHSEP)
3561 ])dnl
3562 dnl ---------------------------------------------------------------------------
3563 dnl CF_PATH_SYNTAX version: 12 updated: 2008/03/23 14:45:59
3564 dnl --------------
3565 dnl Check the argument to see that it looks like a pathname.  Rewrite it if it
3566 dnl begins with one of the prefix/exec_prefix variables, and then again if the
3567 dnl result begins with 'NONE'.  This is necessary to work around autoconf's
3568 dnl delayed evaluation of those symbols.
3569 AC_DEFUN([CF_PATH_SYNTAX],[
3570 if test "x$prefix" != xNONE; then
3571   cf_path_syntax="$prefix"
3572 else
3573   cf_path_syntax="$ac_default_prefix"
3574 fi
3575
3576 case ".[$]$1" in #(vi
3577 .\[$]\(*\)*|.\'*\'*) #(vi
3578   ;;
3579 ..|./*|.\\*) #(vi
3580   ;;
3581 .[[a-zA-Z]]:[[\\/]]*) #(vi OS/2 EMX
3582   ;;
3583 .\[$]{*prefix}*) #(vi
3584   eval $1="[$]$1"
3585   case ".[$]$1" in #(vi
3586   .NONE/*)
3587     $1=`echo [$]$1 | sed -e s%NONE%$cf_path_syntax%`
3588     ;;
3589   esac
3590   ;; #(vi
3591 .no|.NONE/*)
3592   $1=`echo [$]$1 | sed -e s%NONE%$cf_path_syntax%`
3593   ;;
3594 *)
3595   ifelse($2,,[AC_MSG_ERROR([expected a pathname, not \"[$]$1\"])],$2)
3596   ;;
3597 esac
3598 ])dnl
3599 dnl ---------------------------------------------------------------------------
3600 dnl CF_POSIX_C_SOURCE version: 6 updated: 2005/07/14 20:25:10
3601 dnl -----------------
3602 dnl Define _POSIX_C_SOURCE to the given level, and _POSIX_SOURCE if needed.
3603 dnl
3604 dnl     POSIX.1-1990                            _POSIX_SOURCE
3605 dnl     POSIX.1-1990 and                        _POSIX_SOURCE and
3606 dnl             POSIX.2-1992 C-Language                 _POSIX_C_SOURCE=2
3607 dnl             Bindings Option
3608 dnl     POSIX.1b-1993                           _POSIX_C_SOURCE=199309L
3609 dnl     POSIX.1c-1996                           _POSIX_C_SOURCE=199506L
3610 dnl     X/Open 2000                             _POSIX_C_SOURCE=200112L
3611 dnl
3612 dnl Parameters:
3613 dnl     $1 is the nominal value for _POSIX_C_SOURCE
3614 AC_DEFUN([CF_POSIX_C_SOURCE],
3615 [
3616 cf_POSIX_C_SOURCE=ifelse($1,,199506L,$1)
3617
3618 cf_save_CFLAGS="$CFLAGS"
3619 cf_save_CPPFLAGS="$CPPFLAGS"
3620
3621 CF_REMOVE_DEFINE(cf_trim_CFLAGS,$cf_save_CFLAGS,_POSIX_C_SOURCE)
3622 CF_REMOVE_DEFINE(cf_trim_CPPFLAGS,$cf_save_CPPFLAGS,_POSIX_C_SOURCE)
3623
3624 AC_CACHE_CHECK(if we should define _POSIX_C_SOURCE,cf_cv_posix_c_source,[
3625         CF_MSG_LOG(if the symbol is already defined go no further)
3626         AC_TRY_COMPILE([#include <sys/types.h>],[
3627 #ifndef _POSIX_C_SOURCE
3628 make an error
3629 #endif],
3630         [cf_cv_posix_c_source=no],
3631         [cf_want_posix_source=no
3632          case .$cf_POSIX_C_SOURCE in #(vi
3633          .[[12]]??*) #(vi
3634                 cf_cv_posix_c_source="-D_POSIX_C_SOURCE=$cf_POSIX_C_SOURCE"
3635                 ;;
3636          .2) #(vi
3637                 cf_cv_posix_c_source="-D_POSIX_C_SOURCE=$cf_POSIX_C_SOURCE"
3638                 cf_want_posix_source=yes
3639                 ;;
3640          .*)
3641                 cf_want_posix_source=yes
3642                 ;;
3643          esac
3644          if test "$cf_want_posix_source" = yes ; then
3645                 AC_TRY_COMPILE([#include <sys/types.h>],[
3646 #ifdef _POSIX_SOURCE
3647 make an error
3648 #endif],[],
3649                 cf_cv_posix_c_source="$cf_cv_posix_c_source -D_POSIX_SOURCE")
3650          fi
3651          CF_MSG_LOG(ifdef from value $cf_POSIX_C_SOURCE)
3652          CFLAGS="$cf_trim_CFLAGS"
3653          CPPFLAGS="$cf_trim_CPPFLAGS $cf_cv_posix_c_source"
3654          CF_MSG_LOG(if the second compile does not leave our definition intact error)
3655          AC_TRY_COMPILE([#include <sys/types.h>],[
3656 #ifndef _POSIX_C_SOURCE
3657 make an error
3658 #endif],,
3659          [cf_cv_posix_c_source=no])
3660          CFLAGS="$cf_save_CFLAGS"
3661          CPPFLAGS="$cf_save_CPPFLAGS"
3662         ])
3663 ])
3664
3665 if test "$cf_cv_posix_c_source" != no ; then
3666         CFLAGS="$cf_trim_CFLAGS"
3667         CPPFLAGS="$cf_trim_CPPFLAGS"
3668         if test "$cf_cv_cc_u_d_options" = yes ; then
3669                 cf_temp_posix_c_source=`echo "$cf_cv_posix_c_source" | \
3670                                 sed -e 's/-D/-U/g' -e 's/=[[^   ]]*//g'`
3671                 CPPFLAGS="$CPPFLAGS $cf_temp_posix_c_source"
3672         fi
3673         CPPFLAGS="$CPPFLAGS $cf_cv_posix_c_source"
3674 fi
3675
3676 ])dnl
3677 dnl ---------------------------------------------------------------------------
3678 dnl CF_PREDEFINE version: 1 updated: 2003/07/26 17:53:56
3679 dnl ------------
3680 dnl Add definitions to CPPFLAGS to ensure they're predefined for all compiles.
3681 dnl
3682 dnl $1 = symbol to test
3683 dnl $2 = value (if any) to use for a predefinition
3684 AC_DEFUN([CF_PREDEFINE],
3685 [
3686 AC_MSG_CHECKING(if we must define $1)
3687 AC_TRY_COMPILE([#include <sys/types.h>
3688 ],[
3689 #ifndef $1
3690 make an error
3691 #endif],[cf_result=no],[cf_result=yes])
3692 AC_MSG_RESULT($cf_result)
3693
3694 if test "$cf_result" = yes ; then
3695         CPPFLAGS="$CPPFLAGS ifelse($2,,-D$1,[-D$1=$2])"
3696 elif test "x$2" != "x" ; then
3697         AC_MSG_CHECKING(checking for compatible value versus $2)
3698         AC_TRY_COMPILE([#include <sys/types.h>
3699 ],[
3700 #if $1-$2 < 0
3701 make an error
3702 #endif],[cf_result=yes],[cf_result=no])
3703         AC_MSG_RESULT($cf_result)
3704         if test "$cf_result" = no ; then
3705                 # perhaps we can override it - try...
3706                 CPPFLAGS="$CPPFLAGS -D$1=$2"
3707         fi
3708 fi
3709 ])dnl
3710 dnl ---------------------------------------------------------------------------
3711 dnl CF_PRG_RULES version: 1 updated: 2006/06/03 11:45:08
3712 dnl ------------
3713 dnl Append definitions and rules for the given programs to the subdirectory
3714 dnl Makefiles, and the recursion rule for the top-level Makefile.
3715 dnl
3716 dnl parameters
3717 dnl     $1 = script to run
3718 dnl     $2 = list of subdirectories
3719 dnl
3720 dnl variables
3721 dnl     $AWK
3722 AC_DEFUN([CF_PRG_RULES],
3723 [
3724 for cf_dir in $2
3725 do
3726         if test ! -d $srcdir/$cf_dir; then
3727                 continue
3728         elif test -f $srcdir/$cf_dir/programs; then
3729                 $AWK -f $1 $srcdir/$cf_dir/programs >>$cf_dir/Makefile
3730         fi
3731 done
3732
3733 ])dnl
3734 dnl ---------------------------------------------------------------------------
3735 dnl CF_PROG_AWK version: 1 updated: 2006/09/16 11:40:59
3736 dnl -----------
3737 dnl Check for awk, ensure that the check found something.
3738 AC_DEFUN([CF_PROG_AWK],
3739 [
3740 AC_PROG_AWK
3741 test -z "$AWK" && AC_MSG_ERROR(No awk program found)
3742 ])dnl
3743 dnl ---------------------------------------------------------------------------
3744 dnl CF_PROG_CC_C_O version: 2 updated: 2006/12/16 15:55:46
3745 dnl --------------
3746 dnl Analogous to AC_PROG_CC_C_O, but more useful: tests only $CC, ensures that
3747 dnl the output file can be renamed, and allows for a shell variable that can
3748 dnl be used later.  The parameter is either CC or CXX.  The result is the
3749 dnl cache variable:
3750 dnl     $cf_cv_prog_CC_c_o
3751 dnl     $cf_cv_prog_CXX_c_o
3752 AC_DEFUN([CF_PROG_CC_C_O],
3753 [AC_REQUIRE([AC_PROG_CC])dnl
3754 AC_MSG_CHECKING([whether [$]$1 understands -c and -o together])
3755 AC_CACHE_VAL(cf_cv_prog_$1_c_o,
3756 [
3757 cat > conftest.$ac_ext <<CF_EOF
3758 #include <stdio.h>
3759 int main()
3760 {
3761         ${cf_cv_main_return:-return}(0);
3762 }
3763 CF_EOF
3764 # We do the test twice because some compilers refuse to overwrite an
3765 # existing .o file with -o, though they will create one.
3766 ac_try='[$]$1 -c conftest.$ac_ext -o conftest2.$ac_objext >&AC_FD_CC'
3767 if AC_TRY_EVAL(ac_try) &&
3768   test -f conftest2.$ac_objext && AC_TRY_EVAL(ac_try);
3769 then
3770   eval cf_cv_prog_$1_c_o=yes
3771 else
3772   eval cf_cv_prog_$1_c_o=no
3773 fi
3774 rm -f conftest*
3775 ])dnl
3776 if test $cf_cv_prog_$1_c_o = yes; then
3777   AC_MSG_RESULT([yes])
3778 else
3779   AC_MSG_RESULT([no])
3780 fi
3781 ])dnl
3782 dnl ---------------------------------------------------------------------------
3783 dnl CF_PROG_CC_U_D version: 1 updated: 2005/07/14 16:59:30
3784 dnl --------------
3785 dnl Check if C (preprocessor) -U and -D options are processed in the order
3786 dnl given rather than by type of option.  Some compilers insist on apply all
3787 dnl of the -U options after all of the -D options.  Others allow mixing them,
3788 dnl and may predefine symbols that conflict with those we define.
3789 AC_DEFUN([CF_PROG_CC_U_D],
3790 [
3791 AC_CACHE_CHECK(if $CC -U and -D options work together,cf_cv_cc_u_d_options,[