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