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)
3806   test -z "$cf_dir" && cf_dir=.
3807   INSTALL=`cd $cf_dir && pwd`/`echo $INSTALL | sed -e 's%^.*/%%'`
3808   ;;
3809 esac
3810 ])dnl
3811 dnl ---------------------------------------------------------------------------
3812 dnl CF_PROG_LDCONFIG version: 1 updated: 2003/09/20 17:07:55
3813 dnl ----------------
3814 dnl Check for ldconfig, needed to fixup shared libraries that would be built
3815 dnl and then used in the install.
3816 AC_DEFUN([CF_PROG_LDCONFIG],[
3817 if test "$cross_compiling" = yes ; then
3818   LDCONFIG=:
3819 else
3820 case "$cf_cv_system_name" in #(vi
3821 freebsd*) #(vi
3822   test -z "$LDCONFIG" && LDCONFIG="/sbin/ldconfig -R"
3823   ;;
3824 *) LDPATH=$PATH:/sbin:/usr/sbin
3825   AC_PATH_PROG(LDCONFIG,ldconfig,,$LDPATH)
3826   ;;
3827 esac
3828 fi
3829 AC_SUBST(LDCONFIG)
3830 ])dnl
3831 dnl ---------------------------------------------------------------------------
3832 dnl CF_PROG_LINT version: 1 updated: 2006/09/16 11:40:59
3833 dnl ------------
3834 AC_DEFUN([CF_PROG_LINT],
3835 [
3836 AC_CHECK_PROGS(LINT, tdlint lint alint)
3837 AC_SUBST(LINT_OPTS)
3838 ])dnl
3839 dnl ---------------------------------------------------------------------------
3840 dnl CF_REGEX version: 3 updated: 1997/11/01 14:26:01
3841 dnl --------
3842 dnl Attempt to determine if we've got one of the flavors of regular-expression
3843 dnl code that we can support.
3844 AC_DEFUN([CF_REGEX],
3845 [
3846 AC_MSG_CHECKING([for regular-expression headers])
3847 AC_CACHE_VAL(cf_cv_regex,[
3848 AC_TRY_LINK([#include <sys/types.h>
3849 #include <regex.h>],[
3850         regex_t *p;
3851         int x = regcomp(p, "", 0);
3852         int y = regexec(p, "", 0, 0, 0);
3853         regfree(p);
3854         ],[cf_cv_regex="regex.h"],[
3855         AC_TRY_LINK([#include <regexp.h>],[
3856                 char *p = compile("", "", "", 0);
3857                 int x = step("", "");
3858         ],[cf_cv_regex="regexp.h"],[
3859                 cf_save_LIBS="$LIBS"
3860                 LIBS="-lgen $LIBS"
3861                 AC_TRY_LINK([#include <regexpr.h>],[
3862                         char *p = compile("", "", "");
3863                         int x = step("", "");
3864                 ],[cf_cv_regex="regexpr.h"],[LIBS="$cf_save_LIBS"])])])
3865 ])
3866 AC_MSG_RESULT($cf_cv_regex)
3867 case $cf_cv_regex in
3868         regex.h)   AC_DEFINE(HAVE_REGEX_H_FUNCS) ;;
3869         regexp.h)  AC_DEFINE(HAVE_REGEXP_H_FUNCS) ;;
3870         regexpr.h) AC_DEFINE(HAVE_REGEXPR_H_FUNCS) ;;
3871 esac
3872 ])dnl
3873 dnl ---------------------------------------------------------------------------
3874 dnl CF_REMOVE_DEFINE version: 2 updated: 2005/07/09 16:12:18
3875 dnl ----------------
3876 dnl Remove all -U and -D options that refer to the given symbol from a list
3877 dnl of C compiler options.  This works around the problem that not all
3878 dnl compilers process -U and -D options from left-to-right, so a -U option
3879 dnl cannot be used to cancel the effect of a preceding -D option.
3880 dnl
3881 dnl $1 = target (which could be the same as the source variable)
3882 dnl $2 = source (including '$')
3883 dnl $3 = symbol to remove
3884 define([CF_REMOVE_DEFINE],
3885 [
3886 # remove $3 symbol from $2
3887 $1=`echo "$2" | \
3888         sed     -e 's/-[[UD]]$3\(=[[^   ]]*\)\?[[       ]]/ /g' \
3889                 -e 's/-[[UD]]$3\(=[[^   ]]*\)\?[$]//g'`
3890 ])dnl
3891 dnl ---------------------------------------------------------------------------
3892 dnl CF_REMOVE_LIB version: 1 updated: 2007/02/17 14:11:52
3893 dnl -------------
3894 dnl Remove the given library from the symbol
3895 dnl
3896 dnl $1 = target (which could be the same as the source variable)
3897 dnl $2 = source (including '$')
3898 dnl $3 = library to remove
3899 define([CF_REMOVE_LIB],
3900 [
3901 # remove $3 library from $2
3902 $1=`echo "$2" | sed -e 's/-l$3[[        ]]//g' -e 's/-l$3[$]//'`
3903 ])dnl
3904 dnl ---------------------------------------------------------------------------
3905 dnl CF_RPATH_HACK version: 3 updated: 2007/12/01 11:14:13
3906 dnl -------------
3907 AC_DEFUN([CF_RPATH_HACK],
3908 [
3909 AC_REQUIRE([CF_SHARED_OPTS])
3910 AC_MSG_CHECKING(for updated LDFLAGS)
3911 if test -n "$LDFLAGS" ; then
3912 AC_MSG_RESULT(maybe)
3913 CF_VERBOSE(...checking LDFLAGS $LDFLAGS)
3914 CF_VERBOSE(...checking EXTRA_LDFLAGS $EXTRA_LDFLAGS)
3915 case "$EXTRA_LDFLAGS" in #(vi
3916 -Wl,-rpath,*) #(vi
3917     cf_rpath_hack="-Wl,-rpath,"
3918     ;;
3919 -R\ *)
3920     cf_rpath_hack="-R "
3921     ;;
3922 -R*)
3923     cf_rpath_hack="-R"
3924     ;;
3925 *)
3926     cf_rpath_hack=
3927     ;;
3928 esac
3929 if test -n "$cf_rpath_hack" ; then
3930     cf_rpath_dst=
3931     for cf_rpath_src in $LDFLAGS
3932     do
3933         CF_VERBOSE(Filtering $cf_rpath_src)
3934         case $cf_rpath_src in #(vi
3935         -L*) #(vi
3936             if test "$cf_rpath_hack" = "-R " ; then
3937                 cf_rpath_tmp=`echo "$cf_rpath_src" |sed -e 's%-L%-R %'`
3938             else
3939                 cf_rpath_tmp=`echo "$cf_rpath_src" |sed -e s%-L%$cf_rpath_hack%`
3940             fi
3941             CF_VERBOSE(...Filter $cf_rpath_tmp)
3942             EXTRA_LDFLAGS="$cf_rpath_tmp $EXTRA_LDFLAGS"
3943             ;;
3944         *)
3945             cf_rpath_dst="$cf_rpath_dst $cf_rpath_src"
3946             ;;
3947         esac
3948     done
3949     LDFLAGS=$cf_rpath_dst
3950     CF_VERBOSE(...checked LDFLAGS $LDFLAGS)
3951     CF_VERBOSE(...checked EXTRA_LDFLAGS $EXTRA_LDFLAGS)
3952 fi
3953 else
3954 AC_MSG_RESULT(no)
3955 fi
3956 ])dnl
3957 dnl ---------------------------------------------------------------------------
3958 dnl CF_SHARED_OPTS version: 49 updated: 2008/09/06 17:36:03
3959 dnl --------------
3960 dnl --------------
3961 dnl Attempt to determine the appropriate CC/LD options for creating a shared
3962 dnl library.
3963 dnl
3964 dnl Note: ${LOCAL_LDFLAGS} is used to link executables that will run within the
3965 dnl build-tree, i.e., by making use of the libraries that are compiled in ../lib
3966 dnl We avoid compiling-in a ../lib path for the shared library since that can
3967 dnl lead to unexpected results at runtime.
3968 dnl ${LOCAL_LDFLAGS2} has the same intention but assumes that the shared libraries
3969 dnl are compiled in ../../lib
3970 dnl
3971 dnl The variable 'cf_cv_do_symlinks' is used to control whether we configure
3972 dnl to install symbolic links to the rel/abi versions of shared libraries.
3973 dnl
3974 dnl The variable 'cf_cv_shlib_version' controls whether we use the rel or abi
3975 dnl version when making symbolic links.
3976 dnl
3977 dnl The variable 'cf_cv_shlib_version_infix' controls whether shared library
3978 dnl version numbers are infix (ex: libncurses.<ver>.dylib) or postfix
3979 dnl (ex: libncurses.so.<ver>).
3980 dnl
3981 dnl Some loaders leave 'so_locations' lying around.  It's nice to clean up.
3982 AC_DEFUN([CF_SHARED_OPTS],
3983 [
3984         AC_REQUIRE([CF_SUBST_NCURSES_VERSION])
3985         LOCAL_LDFLAGS=
3986         LOCAL_LDFLAGS2=
3987         LD_SHARED_OPTS=
3988         INSTALL_LIB="-m 644"
3989
3990         cf_cv_do_symlinks=no
3991
3992         AC_MSG_CHECKING(if release/abi version should be used for shared libs)
3993         AC_ARG_WITH(shlib-version,
3994         [  --with-shlib-version=X  Specify rel or abi version for shared libs],
3995         [test -z "$withval" && withval=auto
3996         case $withval in #(vi
3997         yes) #(vi
3998                 cf_cv_shlib_version=auto
3999                 ;;
4000         rel|abi|auto|no) #(vi
4001                 cf_cv_shlib_version=$withval
4002                 ;;
4003         *)
4004                 AC_MSG_ERROR([option value must be one of: rel, abi, auto or no])
4005                 ;;
4006         esac
4007         ],[cf_cv_shlib_version=auto])
4008         AC_MSG_RESULT($cf_cv_shlib_version)
4009
4010         cf_cv_rm_so_locs=no
4011
4012         # Some less-capable ports of gcc support only -fpic
4013         CC_SHARED_OPTS=
4014         if test "$GCC" = yes
4015         then
4016                 AC_MSG_CHECKING(which $CC option to use)
4017                 cf_save_CFLAGS="$CFLAGS"
4018                 for CC_SHARED_OPTS in -fPIC -fpic ''
4019                 do
4020                         CFLAGS="$cf_save_CFLAGS $CC_SHARED_OPTS"
4021                         AC_TRY_COMPILE([#include <stdio.h>],[int x = 1],[break],[])
4022                 done
4023                 AC_MSG_RESULT($CC_SHARED_OPTS)
4024                 CFLAGS="$cf_save_CFLAGS"
4025         fi
4026
4027         cf_cv_shlib_version_infix=no
4028
4029         case $cf_cv_system_name in
4030         beos*)
4031                 MK_SHARED_LIB='${CC} ${CFLAGS} -o $[@] -Xlinker -soname=`basename $[@]` -nostart -e 0'
4032                 ;;
4033         cygwin*)
4034                 CC_SHARED_OPTS=
4035                 MK_SHARED_LIB='sh ../mk_shared_lib.sh [$]@ [$]{CC} [$]{CFLAGS}'
4036                 cf_cv_shlib_version=cygdll
4037                 cf_cv_shlib_version_infix=cygdll
4038                 cat >mk_shared_lib.sh <<-CF_EOF
4039                 #!/bin/sh
4040                 SHARED_LIB=\[$]1
4041                 IMPORT_LIB=\`echo "\[$]1" | sed -e 's/cyg/lib/' -e 's/[[0-9]]*\.dll[$]/.dll.a/'\`
4042                 shift
4043                 cat <<-EOF
4044                 Linking shared library
4045                 ** SHARED_LIB \[$]SHARED_LIB
4046                 ** IMPORT_LIB \[$]IMPORT_LIB
4047 EOF
4048                 exec \[$]* -shared -Wl,--out-implib=../lib/\[$]{IMPORT_LIB} -Wl,--export-all-symbols -o ../lib/\[$]{SHARED_LIB}
4049 CF_EOF
4050                 chmod +x mk_shared_lib.sh
4051                 ;;
4052         darwin*)
4053                 EXTRA_CFLAGS="-no-cpp-precomp"
4054                 CC_SHARED_OPTS="-dynamic"
4055                 MK_SHARED_LIB='${CC} ${CFLAGS} -dynamiclib -install_name ${libdir}/`basename $[@]` -compatibility_version ${ABI_VERSION} -current_version ${ABI_VERSION} -o $[@]'
4056                 test "$cf_cv_shlib_version" = auto && cf_cv_shlib_version=abi
4057                 cf_cv_shlib_version_infix=yes
4058                 AC_CACHE_CHECK([if ld -search_paths_first works], cf_cv_ldflags_search_paths_first, [
4059                         cf_save_LDFLAGS=$LDFLAGS
4060                         LDFLAGS="$LDFLAGS -Wl,-search_paths_first"
4061                         AC_TRY_LINK(, [int i;], cf_cv_ldflags_search_paths_first=yes, cf_cv_ldflags_search_paths_first=no)
4062                                 LDFLAGS=$cf_save_LDFLAGS])
4063                 if test $cf_cv_ldflags_search_paths_first = yes; then
4064                         LDFLAGS="$LDFLAGS -Wl,-search_paths_first"
4065                 fi
4066                 ;;
4067         hpux*)
4068                 # (tested with gcc 2.7.2 -- I don't have c89)
4069                 if test "$GCC" = yes; then
4070                         LD_SHARED_OPTS='-Xlinker +b -Xlinker ${libdir}'
4071                 else
4072                         CC_SHARED_OPTS='+Z'
4073                         LD_SHARED_OPTS='-Wl,+b,${libdir}'
4074                 fi
4075                 MK_SHARED_LIB='${LD} +b ${libdir} -b -o $[@]'
4076                 # HP-UX shared libraries must be executable, and should be
4077                 # readonly to exploit a quirk in the memory manager.
4078                 INSTALL_LIB="-m 555"
4079                 ;;
4080         irix*)
4081                 if test "$cf_cv_ld_rpath" = yes ; then
4082                         if test "$GCC" = yes; then
4083                                 cf_ld_rpath_opt="-Wl,-rpath,"
4084                                 EXTRA_LDFLAGS="-Wl,-rpath,\${libdir} $EXTRA_LDFLAGS"
4085                         else
4086                                 cf_ld_rpath_opt="-rpath "
4087                                 EXTRA_LDFLAGS="-rpath \${libdir} $EXTRA_LDFLAGS"
4088                         fi
4089                 fi
4090                 # tested with IRIX 5.2 and 'cc'.
4091                 if test "$GCC" != yes; then
4092                         CC_SHARED_OPTS='-KPIC'
4093             MK_SHARED_LIB='${CC} -shared -rdata_shared -soname `basename $[@]` -o $[@]'
4094         else
4095             MK_SHARED_LIB='${CC} -shared -Wl,-soname,`basename $[@]` -o $[@]'
4096                 fi
4097                 cf_cv_rm_so_locs=yes
4098                 ;;
4099         linux*|gnu*|k*bsd*-gnu)
4100                 if test "$DFT_LWR_MODEL" = "shared" ; then
4101                         LOCAL_LDFLAGS="-Wl,-rpath,\$(LOCAL_LIBDIR)"
4102                         LOCAL_LDFLAGS2="$LOCAL_LDFLAGS"
4103                 fi
4104                 if test "$cf_cv_ld_rpath" = yes ; then
4105                         cf_ld_rpath_opt="-Wl,-rpath,"
4106                         EXTRA_LDFLAGS="-Wl,-rpath,\${libdir} $EXTRA_LDFLAGS"
4107                 fi
4108                 CF_SHARED_SONAME
4109                 MK_SHARED_LIB='${CC} ${CFLAGS} -shared -Wl,-soname,'$cf_shared_soname',-stats,-lc -o $[@]'
4110                 ;;
4111         openbsd[[2-9]].*)
4112                 CC_SHARED_OPTS="$CC_SHARED_OPTS -DPIC"
4113                 MK_SHARED_LIB='${LD} -Bshareable -soname,`basename $[@].${ABI_VERSION}` -o $[@]'
4114                 ;;
4115         openbsd*|freebsd[[12]].*)
4116                 CC_SHARED_OPTS="$CC_SHARED_OPTS -DPIC"
4117                 MK_SHARED_LIB='${LD} -Bshareable -o $[@]'
4118                 test "$cf_cv_shlib_version" = auto && cf_cv_shlib_version=rel
4119                 ;;
4120         freebsd*)
4121                 CC_SHARED_OPTS="$CC_SHARED_OPTS -DPIC"
4122                 if test "$DFT_LWR_MODEL" = "shared" && test "$cf_cv_ld_rpath" = yes ; then
4123                         LOCAL_LDFLAGS="-rpath \$(LOCAL_LIBDIR)"
4124                         LOCAL_LDFLAGS2="-rpath \${libdir} $LOCAL_LDFLAGS"
4125                         cf_ld_rpath_opt="-rpath "
4126                         EXTRA_LDFLAGS="-rpath \${libdir} $EXTRA_LDFLAGS"
4127                 fi
4128                 CF_SHARED_SONAME
4129                 MK_SHARED_LIB='${LD} -Bshareable -soname=`basename $[@]` -o $[@]'
4130                 ;;
4131         netbsd*)
4132                 CC_SHARED_OPTS="$CC_SHARED_OPTS -DPIC"
4133                 test "$cf_cv_ld_rpath" = yes && cf_ld_rpath_opt="-Wl,-rpath,"
4134                 if test "$DFT_LWR_MODEL" = "shared" && test "$cf_cv_ld_rpath" = yes ; then
4135                         LOCAL_LDFLAGS="-Wl,-rpath,\$(LOCAL_LIBDIR)"
4136                         LOCAL_LDFLAGS2="$LOCAL_LDFLAGS"
4137                         EXTRA_LDFLAGS="-Wl,-rpath,\${libdir} $EXTRA_LDFLAGS"
4138                         if test "$cf_cv_shlib_version" = auto; then
4139                         if test -f /usr/libexec/ld.elf_so; then
4140                                 cf_cv_shlib_version=abi
4141                         else
4142                                 cf_cv_shlib_version=rel
4143                         fi
4144                         fi
4145                         CF_SHARED_SONAME
4146                         MK_SHARED_LIB='${CC} ${CFLAGS} -shared -Wl,-soname,'$cf_shared_soname' -o $[@]'
4147                 else
4148                         MK_SHARED_LIB='${LD} -Bshareable -o $[@]'
4149                 fi
4150                 ;;
4151         osf*|mls+*)
4152                 # tested with OSF/1 V3.2 and 'cc'
4153                 # tested with OSF/1 V3.2 and gcc 2.6.3 (but the c++ demo didn't
4154                 # link with shared libs).
4155                 MK_SHARED_LIB='${LD} -set_version ${REL_VERSION}:${ABI_VERSION} -expect_unresolved "*" -shared -soname `basename $[@]`'
4156                 case $host_os in
4157                 osf4*)
4158                         MK_SHARED_LIB="${MK_SHARED_LIB} -msym"
4159                         ;;
4160                 esac
4161                 MK_SHARED_LIB="${MK_SHARED_LIB}"' -o $[@]'
4162                 if test "$DFT_LWR_MODEL" = "shared" ; then
4163                         LOCAL_LDFLAGS="-Wl,-rpath,\$(LOCAL_LIBDIR)"
4164                         LOCAL_LDFLAGS2="$LOCAL_LDFLAGS"
4165                 fi
4166                 if test "$cf_cv_ld_rpath" = yes ; then
4167                         cf_ld_rpath_opt="-rpath"
4168                         # EXTRA_LDFLAGS="$LOCAL_LDFLAGS $EXTRA_LDFLAGS"
4169                 fi
4170                 cf_cv_rm_so_locs=yes
4171                 ;;
4172         sco3.2v5*)  # (also uw2* and UW7) hops 13-Apr-98
4173                 # tested with osr5.0.5
4174                 if test "$GCC" != yes; then
4175                         CC_SHARED_OPTS='-belf -KPIC'
4176                 fi
4177                 MK_SHARED_LIB='${LD} -dy -G -h `basename $[@] .${REL_VERSION}`.${ABI_VERSION} -o [$]@'
4178                 if test "$cf_cv_ld_rpath" = yes ; then
4179                         # only way is to set LD_RUN_PATH but no switch for it
4180                         RUN_PATH=$libdir
4181                 fi
4182                 test "$cf_cv_shlib_version" = auto && cf_cv_shlib_version=rel
4183                 LINK_PROGS='LD_RUN_PATH=${libdir}'
4184                 LINK_TESTS='Pwd=`pwd`;LD_RUN_PATH=`dirname $${Pwd}`/lib'
4185                 ;;
4186         sunos4*)
4187                 # tested with SunOS 4.1.1 and gcc 2.7.0
4188                 if test "$GCC" != yes; then
4189                         CC_SHARED_OPTS='-KPIC'
4190                 fi
4191                 MK_SHARED_LIB='${LD} -assert pure-text -o $[@]'
4192                 test "$cf_cv_shlib_version" = auto && cf_cv_shlib_version=rel
4193                 ;;
4194         solaris2*)
4195                 # tested with SunOS 5.5.1 (solaris 2.5.1) and gcc 2.7.2
4196                 # tested with SunOS 5.10 (solaris 10) and gcc 3.4.3
4197                 if test "$DFT_LWR_MODEL" = "shared" ; then
4198                         LOCAL_LDFLAGS="-R \$(LOCAL_LIBDIR):\${libdir}"
4199                         LOCAL_LDFLAGS2="$LOCAL_LDFLAGS"
4200                 fi
4201                 if test "$cf_cv_ld_rpath" = yes ; then
4202                         cf_ld_rpath_opt="-R"
4203                         EXTRA_LDFLAGS="$LOCAL_LDFLAGS $EXTRA_LDFLAGS"
4204                 fi
4205                 CF_SHARED_SONAME
4206                 if test "$GCC" != yes; then
4207                         CC_SHARED_OPTS='-xcode=pic32'
4208                         MK_SHARED_LIB='${CC} -dy -G -h '$cf_shared_soname' -o $[@]'
4209                 else
4210                         MK_SHARED_LIB='${CC} -shared -dy -G -h '$cf_shared_soname' -o $[@]'
4211                 fi
4212                 ;;
4213         sysv5uw7*|unix_sv*)
4214                 # tested with UnixWare 7.1.0 (gcc 2.95.2 and cc)
4215                 if test "$GCC" != yes; then
4216                         CC_SHARED_OPTS='-KPIC'
4217                 fi
4218                 MK_SHARED_LIB='${LD} -d y -G -o [$]@'
4219                 ;;
4220         *)
4221                 CC_SHARED_OPTS='unknown'
4222                 MK_SHARED_LIB='echo unknown'
4223                 ;;
4224         esac
4225
4226         # This works if the last tokens in $MK_SHARED_LIB are the -o target.
4227         case "$cf_cv_shlib_version" in #(vi
4228         rel|abi)
4229                 case "$MK_SHARED_LIB" in #(vi
4230                 *'-o $[@]')
4231                         test "$cf_cv_do_symlinks" = no && cf_cv_do_symlinks=yes
4232                         ;;
4233                 *)
4234                         AC_MSG_WARN(ignored --with-shlib-version)
4235                         ;;
4236                 esac
4237                 ;;
4238         esac
4239
4240         if test -n "$cf_ld_rpath_opt" ; then
4241                 AC_MSG_CHECKING(if we need a space after rpath option)
4242                 cf_save_LIBS="$LIBS"
4243                 LIBS="$LIBS ${cf_ld_rpath_opt}$libdir"
4244                 AC_TRY_LINK(, , cf_rpath_space=no, cf_rpath_space=yes)
4245                 LIBS="$cf_save_LIBS"
4246                 AC_MSG_RESULT($cf_rpath_space)
4247                 test "$cf_rpath_space" = yes && cf_ld_rpath_opt="$cf_ld_rpath_opt "
4248                 MK_SHARED_LIB="$MK_SHARED_LIB $cf_ld_rpath_opt\${libdir}"
4249         fi
4250
4251         AC_SUBST(CC_SHARED_OPTS)
4252         AC_SUBST(LD_SHARED_OPTS)
4253         AC_SUBST(MK_SHARED_LIB)
4254         AC_SUBST(LINK_PROGS)
4255         AC_SUBST(LINK_TESTS)
4256         AC_SUBST(EXTRA_LDFLAGS)
4257         AC_SUBST(LOCAL_LDFLAGS)
4258         AC_SUBST(LOCAL_LDFLAGS2)
4259         AC_SUBST(INSTALL_LIB)
4260 ])dnl
4261 dnl ---------------------------------------------------------------------------
4262 dnl CF_SHARED_SONAME version: 2 updated: 2006/10/21 12:33:41
4263 dnl ----------------
4264 dnl utility macro for CF_SHARED_OPTS, constructs "$cf_shared_soname" for
4265 dnl substitution into MK_SHARED_LIB string for the "-soname" (or similar)
4266 dnl option.
4267 dnl
4268 dnl $1 is the default that should be used for "$cf_cv_shlib_version".
4269 dnl If missing, use "rel".
4270 define([CF_SHARED_SONAME],
4271 [
4272         test "$cf_cv_shlib_version" = auto && cf_cv_shlib_version=ifelse($1,,rel,$1)
4273         if test "$cf_cv_shlib_version" = rel; then
4274                 cf_shared_soname='`basename $[@] .${REL_VERSION}`.${ABI_VERSION}'
4275         else
4276                 cf_shared_soname='`basename $[@]`'
4277         fi
4278 ])
4279 dnl ---------------------------------------------------------------------------
4280 dnl CF_SIGWINCH version: 1 updated: 2006/04/02 16:41:09
4281 dnl -----------
4282 dnl Use this macro after CF_XOPEN_SOURCE, but do not require it (not all
4283 dnl programs need this test).
4284 dnl
4285 dnl This is really a MacOS X 10.4.3 workaround.  Defining _POSIX_C_SOURCE
4286 dnl forces SIGWINCH to be undefined (breaks xterm, ncurses).  Oddly, the struct
4287 dnl winsize declaration is left alone - we may revisit this if Apple choose to
4288 dnl break that part of the interface as well.
4289 AC_DEFUN([CF_SIGWINCH],
4290 [
4291 AC_CACHE_CHECK(if SIGWINCH is defined,cf_cv_define_sigwinch,[
4292         AC_TRY_COMPILE([
4293 #include <sys/types.h>
4294 #include <sys/signal.h>
4295 ],[int x = SIGWINCH],
4296         [cf_cv_define_sigwinch=yes],
4297         [AC_TRY_COMPILE([
4298 #undef _XOPEN_SOURCE
4299 #undef _POSIX_SOURCE
4300 #undef _POSIX_C_SOURCE
4301 #include <sys/types.h>
4302 #include <sys/signal.h>
4303 ],[int x = SIGWINCH],
4304         [cf_cv_define_sigwinch=maybe],
4305         [cf_cv_define_sigwinch=no])
4306 ])
4307 ])
4308
4309 if test "$cf_cv_define_sigwinch" = maybe ; then
4310 AC_CACHE_CHECK(for actual SIGWINCH definition,cf_cv_fixup_sigwinch,[
4311 cf_cv_fixup_sigwinch=unknown
4312 cf_sigwinch=32
4313 while test $cf_sigwinch != 1
4314 do
4315         AC_TRY_COMPILE([
4316 #undef _XOPEN_SOURCE
4317 #undef _POSIX_SOURCE
4318 #undef _POSIX_C_SOURCE
4319 #include <sys/types.h>
4320 #include <sys/signal.h>
4321 ],[
4322 #if SIGWINCH != $cf_sigwinch
4323 make an error
4324 #endif
4325 int x = SIGWINCH],
4326         [cf_cv_fixup_sigwinch=$cf_sigwinch
4327          break])
4328
4329 cf_sigwinch=`expr $cf_sigwinch - 1`
4330 done
4331 ])
4332
4333         if test "$cf_cv_fixup_sigwinch" != unknown ; then
4334                 CPPFLAGS="$CPPFLAGS -DSIGWINCH=$cf_cv_fixup_sigwinch"
4335         fi
4336 fi
4337 ])dnl
4338 dnl ---------------------------------------------------------------------------
4339 dnl CF_SIG_ATOMIC_T version: 2 updated: 2005/09/18 17:27:12
4340 dnl ---------------
4341 dnl signal handler, but there are some gcc depedencies in that recommendation.
4342 dnl Try anyway.
4343 AC_DEFUN([CF_SIG_ATOMIC_T],
4344 [
4345 AC_MSG_CHECKING(for signal global datatype)
4346 AC_CACHE_VAL(cf_cv_sig_atomic_t,[
4347         for cf_type in \
4348                 "volatile sig_atomic_t" \
4349                 "sig_atomic_t" \
4350                 "int"
4351         do
4352         AC_TRY_COMPILE([
4353 #include <sys/types.h>
4354 #include <signal.h>
4355 #include <stdio.h>
4356
4357 extern $cf_type x;
4358 $cf_type x;
4359 static void handler(int sig)
4360 {
4361         x = 5;
4362 }],
4363                 [signal(SIGINT, handler);
4364                  x = 1],
4365                 [cf_cv_sig_atomic_t=$cf_type],
4366                 [cf_cv_sig_atomic_t=no])
4367                 test "$cf_cv_sig_atomic_t" != no && break
4368         done
4369         ])
4370 AC_MSG_RESULT($cf_cv_sig_atomic_t)
4371 test "$cf_cv_sig_atomic_t" != no && AC_DEFINE_UNQUOTED(SIG_ATOMIC_T, $cf_cv_sig_atomic_t)
4372 ])dnl
4373 dnl ---------------------------------------------------------------------------
4374 dnl CF_SIZECHANGE version: 8 updated: 2000/11/04 12:22:16
4375 dnl -------------
4376 dnl Check for definitions & structures needed for window size-changing
4377 dnl FIXME: check that this works with "snake" (HP-UX 10.x)
4378 AC_DEFUN([CF_SIZECHANGE],
4379 [
4380 AC_REQUIRE([CF_STRUCT_TERMIOS])
4381 AC_CACHE_CHECK(declaration of size-change, cf_cv_sizechange,[
4382     cf_cv_sizechange=unknown
4383     cf_save_CPPFLAGS="$CPPFLAGS"
4384
4385 for cf_opts in "" "NEED_PTEM_H"
4386 do
4387
4388     CPPFLAGS="$cf_save_CPPFLAGS"
4389     test -n "$cf_opts" && CPPFLAGS="$CPPFLAGS -D$cf_opts"
4390     AC_TRY_COMPILE([#include <sys/types.h>
4391 #ifdef HAVE_TERMIOS_H
4392 #include <termios.h>
4393 #else
4394 #ifdef HAVE_TERMIO_H
4395 #include <termio.h>
4396 #endif
4397 #endif
4398 #ifdef NEED_PTEM_H
4399 /* This is a workaround for SCO:  they neglected to define struct winsize in
4400  * termios.h -- it's only in termio.h and ptem.h
4401  */
4402 #include        <sys/stream.h>
4403 #include        <sys/ptem.h>
4404 #endif
4405 #if !defined(sun) || !defined(HAVE_TERMIOS_H)
4406 #include <sys/ioctl.h>
4407 #endif
4408 ],[
4409 #ifdef TIOCGSIZE
4410         struct ttysize win;     /* FIXME: what system is this? */
4411         int y = win.ts_lines;
4412         int x = win.ts_cols;
4413 #else
4414 #ifdef TIOCGWINSZ
4415         struct winsize win;
4416         int y = win.ws_row;
4417         int x = win.ws_col;
4418 #else
4419         no TIOCGSIZE or TIOCGWINSZ
4420 #endif /* TIOCGWINSZ */
4421 #endif /* TIOCGSIZE */
4422         ],
4423         [cf_cv_sizechange=yes],
4424         [cf_cv_sizechange=no])
4425
4426         CPPFLAGS="$cf_save_CPPFLAGS"
4427         if test "$cf_cv_sizechange" = yes ; then
4428                 echo "size-change succeeded ($cf_opts)" >&AC_FD_CC
4429                 test -n "$cf_opts" && cf_cv_sizechange="$cf_opts"
4430                 break
4431         fi
4432 done
4433 ])
4434 if test "$cf_cv_sizechange" != no ; then
4435         AC_DEFINE(HAVE_SIZECHANGE)
4436         case $cf_cv_sizechange in #(vi
4437         NEED*)
4438                 AC_DEFINE_UNQUOTED($cf_cv_sizechange )
4439                 ;;
4440         esac
4441 fi
4442 ])dnl
4443 dnl ---------------------------------------------------------------------------
4444 dnl CF_SRC_MODULES version: 18 updated: 2005/05/28 12:58:54
4445 dnl --------------
4446 dnl For each parameter, test if the source-directory exists, and if it contains
4447 dnl a 'modules' file.  If so, add to the list $cf_cv_src_modules which we'll
4448 dnl use in CF_LIB_RULES.
4449 dnl
4450 dnl This uses the configured value to make the lists SRC_SUBDIRS and
4451 dnl SUB_MAKEFILES which are used in the makefile-generation scheme.
4452 AC_DEFUN([CF_SRC_MODULES],
4453 [
4454 AC_MSG_CHECKING(for src modules)
4455
4456 # dependencies and linker-arguments for test-programs
4457 TEST_DEPS="${LIB_DIR}/${LIB_PREFIX}${LIB_NAME}${DFT_DEP_SUFFIX} $TEST_DEPS"
4458 TEST_DEP2="${LIB_2ND}/${LIB_PREFIX}${LIB_NAME}${DFT_DEP_SUFFIX} $TEST_DEP2"
4459 if test "$DFT_LWR_MODEL" = "libtool"; then
4460         TEST_ARGS="${TEST_DEPS}"
4461         TEST_ARG2="${TEST_DEP2}"
4462 else
4463         TEST_ARGS="-l${LIB_NAME}${DFT_ARG_SUFFIX} $TEST_ARGS"
4464         TEST_ARG2="-l${LIB_NAME}${DFT_ARG_SUFFIX} $TEST_ARG2"
4465 fi
4466
4467 cf_cv_src_modules=
4468 for cf_dir in $1
4469 do
4470         if test -f $srcdir/$cf_dir/modules; then
4471
4472                 # We may/may not have tack in the distribution, though the
4473                 # makefile is.
4474                 if test $cf_dir = tack ; then
4475                         if test ! -f $srcdir/${cf_dir}/${cf_dir}.h; then
4476                                 continue
4477                         fi
4478                 fi
4479
4480                 if test -z "$cf_cv_src_modules"; then
4481                         cf_cv_src_modules=$cf_dir
4482                 else
4483                         cf_cv_src_modules="$cf_cv_src_modules $cf_dir"
4484                 fi
4485
4486                 # Make the ncurses_cfg.h file record the library interface files as
4487                 # well.  These are header files that are the same name as their
4488                 # directory.  Ncurses is the only library that does not follow
4489                 # that pattern.
4490                 if test $cf_dir = tack ; then
4491                         continue
4492                 elif test -f $srcdir/${cf_dir}/${cf_dir}.h; then
4493                         CF_UPPER(cf_have_include,$cf_dir)
4494                         AC_DEFINE_UNQUOTED(HAVE_${cf_have_include}_H)
4495                         AC_DEFINE_UNQUOTED(HAVE_LIB${cf_have_include})
4496                         TEST_DEPS="${LIB_DIR}/${LIB_PREFIX}${cf_dir}${DFT_DEP_SUFFIX} $TEST_DEPS"
4497                         TEST_DEP2="${LIB_2ND}/${LIB_PREFIX}${cf_dir}${DFT_DEP_SUFFIX} $TEST_DEP2"
4498                         if test "$DFT_LWR_MODEL" = "libtool"; then
4499                                 TEST_ARGS="${TEST_DEPS}"
4500                                 TEST_ARG2="${TEST_DEP2}"
4501                         else
4502                                 TEST_ARGS="-l${cf_dir}${DFT_ARG_SUFFIX} $TEST_ARGS"
4503                                 TEST_ARG2="-l${cf_dir}${DFT_ARG_SUFFIX} $TEST_ARG2"
4504                         fi
4505                 fi
4506         fi
4507 done
4508 AC_MSG_RESULT($cf_cv_src_modules)
4509
4510 TEST_ARGS="-L${LIB_DIR} $TEST_ARGS"
4511 TEST_ARG2="-L${LIB_2ND} $TEST_ARG2"
4512
4513 AC_SUBST(TEST_ARGS)
4514 AC_SUBST(TEST_DEPS)
4515
4516 AC_SUBST(TEST_ARG2)
4517 AC_SUBST(TEST_DEP2)
4518
4519 SRC_SUBDIRS="man include"
4520 for cf_dir in $cf_cv_src_modules
4521 do
4522         SRC_SUBDIRS="$SRC_SUBDIRS $cf_dir"
4523 done
4524 SRC_SUBDIRS="$SRC_SUBDIRS test"
4525 test -z "$MAKE_TERMINFO" && SRC_SUBDIRS="$SRC_SUBDIRS misc"
4526 test "$cf_with_cxx_binding" != no && SRC_SUBDIRS="$SRC_SUBDIRS c++"
4527
4528 ADA_SUBDIRS=
4529 if test "$cf_cv_prog_gnat_correct" = yes && test -f $srcdir/Ada95/Makefile.in; then
4530    SRC_SUBDIRS="$SRC_SUBDIRS Ada95"
4531    ADA_SUBDIRS="gen src samples"
4532 fi
4533
4534 SUB_MAKEFILES=
4535 for cf_dir in $SRC_SUBDIRS
4536 do
4537         SUB_MAKEFILES="$SUB_MAKEFILES $cf_dir/Makefile"
4538 done
4539
4540 if test -n "$ADA_SUBDIRS"; then
4541    for cf_dir in $ADA_SUBDIRS
4542    do
4543       SUB_MAKEFILES="$SUB_MAKEFILES Ada95/$cf_dir/Makefile"
4544    done
4545    AC_SUBST(ADA_SUBDIRS)
4546 fi
4547 ])dnl
4548 dnl ---------------------------------------------------------------------------
4549 dnl CF_STDCPP_LIBRARY version: 5 updated: 2000/08/12 23:18:52
4550 dnl -----------------
4551 dnl Check for -lstdc++, which is GNU's standard C++ library.
4552 AC_DEFUN([CF_STDCPP_LIBRARY],
4553 [
4554 if test -n "$GXX" ; then
4555 case $cf_cv_system_name in #(vi
4556 os2*) #(vi
4557         cf_stdcpp_libname=stdcpp
4558         ;;
4559 *)
4560         cf_stdcpp_libname=stdc++
4561         ;;
4562 esac
4563 AC_CACHE_CHECK(for library $cf_stdcpp_libname,cf_cv_libstdcpp,[
4564         cf_save="$LIBS"
4565         LIBS="$LIBS -l$cf_stdcpp_libname"
4566 AC_TRY_LINK([
4567 #include <strstream.h>],[
4568 char buf[80];
4569 strstreambuf foo(buf, sizeof(buf))
4570 ],
4571         [cf_cv_libstdcpp=yes],
4572         [cf_cv_libstdcpp=no])
4573         LIBS="$cf_save"
4574 ])
4575 test "$cf_cv_libstdcpp" = yes && CXXLIBS="$CXXLIBS -l$cf_stdcpp_libname"
4576 fi
4577 ])dnl
4578 dnl ---------------------------------------------------------------------------
4579 dnl CF_STRIP_G_OPT version: 3 updated: 2002/12/21 19:25:52
4580 dnl --------------
4581 dnl     Remove "-g" option from the compiler options
4582 AC_DEFUN([CF_STRIP_G_OPT],
4583 [$1=`echo ${$1} | sed -e 's%-g %%' -e 's%-g$%%'`])dnl
4584 dnl ---------------------------------------------------------------------------
4585 dnl CF_STRUCT_SIGACTION version: 3 updated: 2000/08/12 23:18:52
4586 dnl -------------------
4587 dnl Check if we need _POSIX_SOURCE defined to use struct sigaction.  We'll only
4588 dnl do this if we've found the sigaction function.
4589 dnl
4590 dnl If needed, define SVR4_ACTION.
4591 AC_DEFUN([CF_STRUCT_SIGACTION],[
4592 if test "$ac_cv_func_sigaction" = yes; then
4593 AC_MSG_CHECKING(whether sigaction needs _POSIX_SOURCE)
4594 AC_TRY_COMPILE([
4595 #include <sys/types.h>
4596 #include <signal.h>],
4597         [struct sigaction act],
4598         [sigact_bad=no],
4599         [
4600 AC_TRY_COMPILE([
4601 #define _POSIX_SOURCE
4602 #include <sys/types.h>
4603 #include <signal.h>],
4604         [struct sigaction act],
4605         [sigact_bad=yes
4606          AC_DEFINE(SVR4_ACTION)],
4607          [sigact_bad=unknown])])
4608 AC_MSG_RESULT($sigact_bad)
4609 fi
4610 ])dnl
4611 dnl ---------------------------------------------------------------------------
4612 dnl CF_STRUCT_TERMIOS version: 5 updated: 2000/11/04 12:22:46
4613 dnl -----------------
4614 dnl Some machines require _POSIX_SOURCE to completely define struct termios.
4615 dnl If so, define SVR4_TERMIO
4616 AC_DEFUN([CF_STRUCT_TERMIOS],[
4617 AC_CHECK_HEADERS( \
4618 termio.h \
4619 termios.h \
4620 unistd.h \
4621 )
4622 if test "$ISC" = yes ; then
4623         AC_CHECK_HEADERS( sys/termio.h )
4624 fi
4625 if test "$ac_cv_header_termios_h" = yes ; then
4626         case "$CFLAGS $CPPFLAGS" in
4627         *-D_POSIX_SOURCE*)
4628                 termios_bad=dunno ;;
4629         *)      termios_bad=maybe ;;
4630         esac
4631         if test "$termios_bad" = maybe ; then
4632         AC_MSG_CHECKING(whether termios.h needs _POSIX_SOURCE)
4633         AC_TRY_COMPILE([#include <termios.h>],
4634                 [struct termios foo; int x = foo.c_iflag],
4635                 termios_bad=no, [
4636                 AC_TRY_COMPILE([
4637 #define _POSIX_SOURCE
4638 #include <termios.h>],
4639                         [struct termios foo; int x = foo.c_iflag],
4640                         termios_bad=unknown,
4641                         termios_bad=yes AC_DEFINE(SVR4_TERMIO))
4642                         ])
4643         AC_MSG_RESULT($termios_bad)
4644         fi
4645 fi
4646 ])dnl
4647 dnl ---------------------------------------------------------------------------
4648 dnl CF_SUBST version: 4 updated: 2006/06/17 12:33:03
4649 dnl --------
4650 dnl     Shorthand macro for substituting things that the user may override
4651 dnl     with an environment variable.
4652 dnl
4653 dnl     $1 = long/descriptive name
4654 dnl     $2 = environment variable
4655 dnl     $3 = default value
4656 AC_DEFUN([CF_SUBST],
4657 [AC_CACHE_VAL(cf_cv_subst_$2,[
4658 AC_MSG_CHECKING(for $1 (symbol $2))
4659 CF_SUBST_IF([-z "[$]$2"], [$2], [$3])
4660 cf_cv_subst_$2=[$]$2
4661 AC_MSG_RESULT([$]$2)
4662 ])
4663 ])dnl
4664 dnl ---------------------------------------------------------------------------
4665 dnl CF_SUBST_IF version: 2 updated: 2006/06/17 12:33:03
4666 dnl -----------
4667 dnl     Shorthand macro for substituting things that the user may override
4668 dnl     with an environment variable.
4669 dnl
4670 dnl     $1 = condition to pass to "test"
4671 dnl     $2 = environment variable
4672 dnl     $3 = value if the test succeeds
4673 dnl     $4 = value if the test fails
4674 AC_DEFUN([CF_SUBST_IF],
4675 [
4676 if test $1 ; then
4677         $2=$3
4678 ifelse($4,,,[else
4679         $2=$4])
4680 fi
4681 AC_SUBST($2)
4682 ])dnl
4683 dnl ---------------------------------------------------------------------------
4684 dnl CF_SUBST_NCURSES_VERSION version: 8 updated: 2006/09/16 11:40:59
4685 dnl ------------------------
4686 dnl Get the version-number for use in shared-library naming, etc.
4687 AC_DEFUN([CF_SUBST_NCURSES_VERSION],
4688 [
4689 AC_REQUIRE([CF_PROG_EGREP])
4690 NCURSES_MAJOR="`$ac_cv_prog_egrep '^NCURSES_MAJOR[[     ]]*=' $srcdir/dist.mk | sed -e 's/^[[^0-9]]*//'`"
4691 NCURSES_MINOR="`$ac_cv_prog_egrep '^NCURSES_MINOR[[     ]]*=' $srcdir/dist.mk | sed -e 's/^[[^0-9]]*//'`"
4692 NCURSES_PATCH="`$ac_cv_prog_egrep '^NCURSES_PATCH[[     ]]*=' $srcdir/dist.mk | sed -e 's/^[[^0-9]]*//'`"
4693 cf_cv_abi_version=${NCURSES_MAJOR}
4694 cf_cv_rel_version=${NCURSES_MAJOR}.${NCURSES_MINOR}
4695 dnl Show the computed version, for logging
4696 cf_cv_timestamp=`date`
4697 AC_MSG_RESULT(Configuring NCURSES $cf_cv_rel_version ABI $cf_cv_abi_version ($cf_cv_timestamp))
4698 dnl We need these values in the generated headers
4699 AC_SUBST(NCURSES_MAJOR)
4700 AC_SUBST(NCURSES_MINOR)
4701 AC_SUBST(NCURSES_PATCH)
4702 dnl We need these values in the generated makefiles
4703 AC_SUBST(cf_cv_rel_version)
4704 AC_SUBST(cf_cv_abi_version)
4705 AC_SUBST(cf_cv_builtin_bool)
4706 AC_SUBST(cf_cv_header_stdbool_h)
4707 AC_SUBST(cf_cv_type_of_bool)dnl
4708 ])dnl
4709 dnl ---------------------------------------------------------------------------
4710 dnl CF_SYS_TIME_SELECT version: 4 updated: 2000/10/04 09:18:40
4711 dnl ------------------
4712 dnl Check if we can include <sys/time.h> with <sys/select.h>; this breaks on
4713 dnl older SCO configurations.
4714 AC_DEFUN([CF_SYS_TIME_SELECT],
4715 [
4716 AC_MSG_CHECKING(if sys/time.h works with sys/select.h)
4717 AC_CACHE_VAL(cf_cv_sys_time_select,[
4718 AC_TRY_COMPILE([
4719 #include <sys/types.h>
4720 #ifdef HAVE_SYS_TIME_H
4721 #include <sys/time.h>
4722 #endif
4723 #ifdef HAVE_SYS_SELECT_H
4724 #include <sys/select.h>
4725 #endif
4726 ],[],[cf_cv_sys_time_select=yes],
4727      [cf_cv_sys_time_select=no])
4728      ])
4729 AC_MSG_RESULT($cf_cv_sys_time_select)
4730 test "$cf_cv_sys_time_select" = yes && AC_DEFINE(HAVE_SYS_TIME_SELECT)
4731 ])dnl
4732 dnl ---------------------------------------------------------------------------
4733 dnl CF_TOP_BUILDDIR version: 1 updated: 2006/10/15 16:33:23
4734 dnl ---------------
4735 dnl Define a top_builddir symbol, for applications that need an absolute path.
4736 AC_DEFUN([CF_TOP_BUILDDIR],
4737 [
4738 top_builddir=`pwd`
4739 AC_SUBST(top_builddir)
4740 ])dnl
4741 dnl ---------------------------------------------------------------------------
4742 dnl CF_TYPEOF_CHTYPE version: 8 updated: 2006/12/16 12:33:30
4743 dnl ----------------
4744 dnl Determine the type we should use for chtype (and attr_t, which is treated
4745 dnl as the same thing).  We want around 32 bits, so on most machines want a
4746 dnl long, but on newer 64-bit machines, probably want an int.  If we're using
4747 dnl wide characters, we have to have a type compatible with that, as well.
4748 AC_DEFUN([CF_TYPEOF_CHTYPE],
4749 [
4750 AC_MSG_CHECKING([for type of chtype])
4751 AC_CACHE_VAL(cf_cv_typeof_chtype,[
4752                 AC_TRY_RUN([
4753 #define WANT_BITS 31
4754 #include <stdio.h>
4755 int main()
4756 {
4757         FILE *fp = fopen("cf_test.out", "w");
4758         if (fp != 0) {
4759                 char *result = "long";
4760                 if (sizeof(unsigned long) > sizeof(unsigned int)) {
4761                         int n;
4762                         unsigned int x, y;
4763                         for (n = 0; n < WANT_BITS; n++) {
4764                                 x = (1 << n);
4765                                 y = (x >> n);
4766                                 if (y != 1 || x == 0) {
4767                                         x = 0;
4768                                         break;
4769                                 }
4770                         }
4771                         /*
4772                          * If x is nonzero, an int is big enough for the bits
4773                          * that we want.
4774                          */
4775                         result = (x != 0) ? "int" : "long";
4776                 }
4777                 fputs(result, fp);
4778                 fclose(fp);
4779         }
4780         ${cf_cv_main_return:-return}(0);
4781 }
4782                 ],
4783                 [cf_cv_typeof_chtype=`cat cf_test.out`],
4784                 [cf_cv_typeof_chtype=long],
4785                 [cf_cv_typeof_chtype=long])
4786                 rm -f cf_test.out
4787         ])
4788 AC_MSG_RESULT($cf_cv_typeof_chtype)
4789
4790 AC_SUBST(cf_cv_typeof_chtype)
4791 AC_DEFINE_UNQUOTED(TYPEOF_CHTYPE,$cf_cv_typeof_chtype)
4792 ])dnl
4793 dnl ---------------------------------------------------------------------------
4794 dnl CF_TYPE_SIGACTION version: 3 updated: 2000/08/12 23:18:52
4795 dnl -----------------
4796 dnl
4797 AC_DEFUN([CF_TYPE_SIGACTION],
4798 [
4799 AC_MSG_CHECKING([for type sigaction_t])
4800 AC_CACHE_VAL(cf_cv_type_sigaction,[
4801         AC_TRY_COMPILE([
4802 #include <signal.h>],
4803                 [sigaction_t x],
4804                 [cf_cv_type_sigaction=yes],
4805                 [cf_cv_type_sigaction=no])])
4806 AC_MSG_RESULT($cf_cv_type_sigaction)
4807 test "$cf_cv_type_sigaction" = yes && AC_DEFINE(HAVE_TYPE_SIGACTION)
4808 ])dnl
4809 dnl ---------------------------------------------------------------------------
4810 dnl CF_UNSIGNED_LITERALS version: 2 updated: 1998/02/07 22:10:16
4811 dnl --------------------
4812 dnl Test if the compiler supports 'U' and 'L' suffixes.  Only old compilers
4813 dnl won't, but they're still there.
4814 AC_DEFUN([CF_UNSIGNED_LITERALS],
4815 [
4816 AC_MSG_CHECKING([if unsigned literals are legal])
4817 AC_CACHE_VAL(cf_cv_unsigned_literals,[
4818         AC_TRY_COMPILE([],[long x = 1L + 1UL + 1U + 1],
4819                 [cf_cv_unsigned_literals=yes],
4820                 [cf_cv_unsigned_literals=no])
4821         ])
4822 AC_MSG_RESULT($cf_cv_unsigned_literals)
4823 ])dnl
4824 dnl ---------------------------------------------------------------------------
4825 dnl CF_UPPER version: 5 updated: 2001/01/29 23:40:59
4826 dnl --------
4827 dnl Make an uppercase version of a variable
4828 dnl $1=uppercase($2)
4829 AC_DEFUN([CF_UPPER],
4830 [
4831 $1=`echo "$2" | sed y%abcdefghijklmnopqrstuvwxyz./-%ABCDEFGHIJKLMNOPQRSTUVWXYZ___%`
4832 ])dnl
4833 dnl ---------------------------------------------------------------------------
4834 dnl CF_VERBOSE version: 3 updated: 2007/07/29 09:55:12
4835 dnl ----------
4836 dnl Use AC_VERBOSE w/o the warnings
4837 AC_DEFUN([CF_VERBOSE],
4838 [test -n "$verbose" && echo "   $1" 1>&AC_FD_MSG
4839 CF_MSG_LOG([$1])
4840 ])dnl
4841 dnl ---------------------------------------------------------------------------
4842 dnl CF_WCHAR_TYPE version: 2 updated: 2004/01/17 19:18:20
4843 dnl -------------
4844 dnl Check if type wide-character type $1 is declared, and if so, which header
4845 dnl file is needed.  The second parameter is used to set a shell variable when
4846 dnl the type is not found.  The first parameter sets a shell variable for the
4847 dnl opposite sense.
4848 AC_DEFUN([CF_WCHAR_TYPE],
4849 [
4850 # This is needed on Tru64 5.0 to declare $1
4851 AC_CACHE_CHECK(if we must include wchar.h to declare $1,cf_cv_$1,[
4852 AC_TRY_COMPILE([
4853 #include <stdlib.h>
4854 #include <stdarg.h>
4855 #include <stdio.h>
4856 #ifdef HAVE_LIBUTF8_H
4857 #include <libutf8.h>
4858 #endif],
4859         [$1 state],
4860         [cf_cv_$1=no],
4861         [AC_TRY_COMPILE([
4862 #include <stdlib.h>
4863 #include <stdarg.h>
4864 #include <stdio.h>
4865 #include <wchar.h>
4866 #ifdef HAVE_LIBUTF8_H
4867 #include <libutf8.h>
4868 #endif],
4869         [$1 value],
4870         [cf_cv_$1=yes],
4871         [cf_cv_$1=unknown])])])
4872
4873 if test "$cf_cv_$1" = yes ; then
4874         AC_DEFINE(NEED_WCHAR_H)
4875         NEED_WCHAR_H=1
4876 fi
4877
4878 ifelse($2,,,[
4879 # if we do not find $1 in either place, use substitution to provide a fallback.
4880 if test "$cf_cv_$1" = unknown ; then
4881         $2=1
4882 fi
4883 ])
4884 ifelse($3,,,[
4885 # if we find $1 in either place, use substitution to provide a fallback.
4886 if test "$cf_cv_$1" != unknown ; then
4887         $3=1
4888 fi
4889 ])
4890 ])dnl
4891 dnl ---------------------------------------------------------------------------
4892 dnl CF_WEAK_SYMBOLS version: 1 updated: 2008/08/16 19:18:06
4893 dnl ---------------
4894 dnl Check for compiler-support for weak symbols.
4895 dnl This works with "recent" gcc.
4896 AC_DEFUN([CF_WEAK_SYMBOLS],[
4897 AC_CACHE_CHECK(if $CC supports weak symbols,cf_cv_weak_symbols,[
4898
4899 AC_TRY_COMPILE([
4900 #include <stdio.h>],
4901 [
4902 #if defined(__GNUC__)
4903 #  if defined __USE_ISOC99
4904 #    define _cat_pragma(exp)    _Pragma(#exp)
4905 #    define _weak_pragma(exp)   _cat_pragma(weak name)
4906 #  else
4907 #    define _weak_pragma(exp)
4908 #  endif
4909 #  define _declare(name)        __extension__ extern __typeof__(name) name
4910 #  define weak_symbol(name)     _weak_pragma(name) _declare(name) __attribute__((weak))
4911 #endif
4912
4913 weak_symbol(fopen);
4914 ],[cf_cv_weak_symbols=yes],[cf_cv_weak_symbols=no])
4915 ])
4916 ])dnl
4917 dnl ---------------------------------------------------------------------------
4918 dnl CF_WITH_ABI_VERSION version: 1 updated: 2003/09/20 18:12:49
4919 dnl -------------------
4920 dnl Allow library's ABI to be overridden.  Generally this happens when a
4921 dnl packager has incremented the ABI past that used in the original package,
4922 dnl and wishes to keep doing this.
4923 dnl
4924 dnl $1 is the package name, if any, to derive a corresponding {package}_ABI
4925 dnl symbol.
4926 AC_DEFUN([CF_WITH_ABI_VERSION],[
4927 test -z "$cf_cv_abi_version" && cf_cv_abi_version=0
4928 AC_ARG_WITH(abi-version,
4929 [  --with-abi-version=XXX  override derived ABI version],
4930 [AC_MSG_WARN(overriding ABI version $cf_cv_abi_version to $withval)
4931  cf_cv_abi_version=$withval])
4932  CF_NUMBER_SYNTAX($cf_cv_abi_version,ABI version)
4933 ifelse($1,,,[
4934 $1_ABI=$cf_cv_abi_version
4935 ])
4936 ])dnl
4937 dnl ---------------------------------------------------------------------------
4938 dnl CF_WITH_DBMALLOC version: 6 updated: 2006/12/16 14:24:05
4939 dnl ----------------
4940 dnl Configure-option for dbmalloc.  The optional parameter is used to override
4941 dnl the updating of $LIBS, e.g., to avoid conflict with subsequent tests.
4942 AC_DEFUN([CF_WITH_DBMALLOC],[
4943 CF_NO_LEAKS_OPTION(dbmalloc,
4944         [  --with-dbmalloc         test: use Conor Cahill's dbmalloc library],
4945         [USE_DBMALLOC])
4946
4947 if test "$with_dbmalloc" = yes ; then
4948         AC_CHECK_HEADER(dbmalloc.h,
4949                 [AC_CHECK_LIB(dbmalloc,[debug_malloc]ifelse($1,,[],[,$1]))])
4950 fi
4951 ])dnl
4952 dnl ---------------------------------------------------------------------------
4953 dnl CF_WITH_DMALLOC version: 6 updated: 2006/12/16 14:24:05
4954 dnl ---------------
4955 dnl Configure-option for dmalloc.  The optional parameter is used to override
4956 dnl the updating of $LIBS, e.g., to avoid conflict with subsequent tests.
4957 AC_DEFUN([CF_WITH_DMALLOC],[
4958 CF_NO_LEAKS_OPTION(dmalloc,
4959         [  --with-dmalloc          test: use Gray Watson's dmalloc library],
4960         [USE_DMALLOC])
4961
4962 if test "$with_dmalloc" = yes ; then
4963         AC_CHECK_HEADER(dmalloc.h,
4964                 [AC_CHECK_LIB(dmalloc,[dmalloc_debug]ifelse($1,,[],[,$1]))])
4965 fi
4966 ])dnl
4967 dnl ---------------------------------------------------------------------------
4968 dnl CF_WITH_GPM version: 7 updated: 2008/03/23 14:48:54
4969 dnl -----------
4970 dnl
4971 dnl The option parameter (if neither yes/no) is assumed to be the name of
4972 dnl the gpm library, e.g., for dynamic loading.
4973 AC_DEFUN([CF_WITH_GPM],
4974 [
4975 AC_MSG_CHECKING(if you want to link with the GPM mouse library)
4976 AC_ARG_WITH(gpm,
4977         [  --with-gpm              use Alessandro Rubini's GPM library],
4978         [with_gpm=$withval],
4979         [with_gpm=maybe])
4980 AC_MSG_RESULT($with_gpm)
4981
4982 if test "$with_gpm" != no ; then
4983         AC_CHECK_HEADER(gpm.h,[
4984                 AC_DEFINE(HAVE_GPM_H)
4985                 if test "$with_gpm" != yes && test "$with_gpm" != maybe ; then
4986                         CF_VERBOSE(assuming we really have GPM library)
4987                         AC_DEFINE(HAVE_LIBGPM)
4988                 else
4989                         AC_CHECK_LIB(gpm,Gpm_Open,[:],[
4990                                 AC_MSG_ERROR(Cannot link with GPM library)
4991                 fi
4992                 with_gpm=yes
4993                 ])
4994         ],[
4995                 test "$with_gpm" != maybe && AC_MSG_WARN(Cannot find GPM header)
4996                 with_gpm=no
4997         ])
4998 fi
4999 ])
5000 dnl ---------------------------------------------------------------------------
5001 dnl CF_WITH_LIBTOOL version: 19 updated: 2008/03/29 15:46:43
5002 dnl ---------------
5003 dnl Provide a configure option to incorporate libtool.  Define several useful
5004 dnl symbols for the makefile rules.
5005 dnl
5006 dnl The reference to AC_PROG_LIBTOOL does not normally work, since it uses
5007 dnl macros from libtool.m4 which is in the aclocal directory of automake.
5008 dnl Following is a simple script which turns on the AC_PROG_LIBTOOL macro.
5009 dnl But that still does not work properly since the macro is expanded outside
5010 dnl the CF_WITH_LIBTOOL macro:
5011 dnl
5012 dnl     #!/bin/sh
5013 dnl     ACLOCAL=`aclocal --print-ac-dir`
5014 dnl     if test -z "$ACLOCAL" ; then
5015 dnl             echo cannot find aclocal directory
5016 dnl             exit 1
5017 dnl     elif test ! -f $ACLOCAL/libtool.m4 ; then
5018 dnl             echo cannot find libtool.m4 file
5019 dnl             exit 1
5020 dnl     fi
5021 dnl
5022 dnl     LOCAL=aclocal.m4
5023 dnl     ORIG=aclocal.m4.orig
5024 dnl
5025 dnl     trap "mv $ORIG $LOCAL" 0 1 2 5 15
5026 dnl     rm -f $ORIG
5027 dnl     mv $LOCAL $ORIG
5028 dnl
5029 dnl     # sed the LIBTOOL= assignment to omit the current directory?
5030 dnl     sed -e 's/^LIBTOOL=.*/LIBTOOL=${LIBTOOL-libtool}/' $ACLOCAL/libtool.m4 >>$LOCAL
5031 dnl     cat $ORIG >>$LOCAL
5032 dnl
5033 dnl     autoconf-257 $*
5034 dnl
5035 AC_DEFUN([CF_WITH_LIBTOOL],
5036 [
5037 ifdef([AC_PROG_LIBTOOL],,[
5038 LIBTOOL=
5039 ])
5040 # common library maintenance symbols that are convenient for libtool scripts:
5041 LIB_CREATE='${AR} -cr'
5042 LIB_OBJECT='${OBJECTS}'
5043 LIB_SUFFIX=.a
5044 LIB_PREP="$RANLIB"
5045
5046 # symbols used to prop libtool up to enable it to determine what it should be
5047 # doing:
5048 LIB_CLEAN=
5049 LIB_COMPILE=
5050 LIB_LINK='${CC}'
5051 LIB_INSTALL=
5052 LIB_UNINSTALL=
5053
5054 AC_MSG_CHECKING(if you want to build libraries with libtool)
5055 AC_ARG_WITH(libtool,
5056         [  --with-libtool          generate libraries with libtool],
5057         [with_libtool=$withval],
5058         [with_libtool=no])
5059 AC_MSG_RESULT($with_libtool)
5060 if test "$with_libtool" != "no"; then
5061 ifdef([AC_PROG_LIBTOOL],[
5062         # missing_content_AC_PROG_LIBTOOL{{
5063         AC_PROG_LIBTOOL
5064         # missing_content_AC_PROG_LIBTOOL}}
5065 ],[
5066         if test "$with_libtool" != "yes" ; then
5067                 CF_PATH_SYNTAX(with_libtool)
5068                 LIBTOOL=$with_libtool
5069         else
5070                 AC_PATH_PROG(LIBTOOL,libtool)
5071         fi
5072         if test -z "$LIBTOOL" ; then
5073                 AC_MSG_ERROR(Cannot find libtool)
5074         fi
5075 ])dnl
5076         LIB_CREATE='${LIBTOOL} --mode=link ${CC} -rpath ${DESTDIR}${libdir} -version-info `cut -f1 ${srcdir}/VERSION` ${LIBTOOL_OPTS} -o'
5077         LIB_OBJECT='${OBJECTS:.o=.lo}'
5078         LIB_SUFFIX=.la
5079         LIB_CLEAN='${LIBTOOL} --mode=clean'
5080         LIB_COMPILE='${LIBTOOL} --mode=compile'
5081         LIB_LINK='${LIBTOOL} --mode=link ${CC} ${LIBTOOL_OPTS}'
5082         LIB_INSTALL='${LIBTOOL} --mode=install'
5083         LIB_UNINSTALL='${LIBTOOL} --mode=uninstall'
5084         LIB_PREP=:
5085
5086         # Show the version of libtool
5087         AC_MSG_CHECKING(version of libtool)
5088
5089         # Save the version in a cache variable - this is not entirely a good
5090         # thing, but the version string from libtool is very ugly, and for
5091         # bug reports it might be useful to have the original string.
5092         cf_cv_libtool_version=`$LIBTOOL --version 2>&1 | sed -e '/^$/d' |sed -e '2,$d' -e 's/([[^)]]*)//g' -e 's/^[[^1-9]]*//' -e 's/[[^0-9.]].*//'`
5093         AC_MSG_RESULT($cf_cv_libtool_version)
5094         if test -z "$cf_cv_libtool_version" ; then
5095                 AC_MSG_ERROR(This is not GNU libtool)
5096         fi
5097
5098         # special hack to add --tag option for C++ compiler
5099         case $cf_cv_libtool_version in
5100         1.[[5-9]]*|[[2-9]]*)
5101                 LIBTOOL_CXX="$LIBTOOL --tag=CXX"
5102                 LIBTOOL="$LIBTOOL --tag=CC"
5103                 ;;
5104         *)
5105                 LIBTOOL_CXX="$LIBTOOL"
5106                 ;;
5107         esac
5108 else
5109         LIBTOOL=""
5110         LIBTOOL_CXX=""
5111 fi
5112
5113 test -z "$LIBTOOL" && ECHO_LT=
5114
5115 AC_SUBST(LIBTOOL)
5116 AC_SUBST(LIBTOOL_CXX)
5117 AC_SUBST(LIBTOOL_OPTS)
5118
5119 AC_SUBST(LIB_CREATE)
5120 AC_SUBST(LIB_OBJECT)
5121 AC_SUBST(LIB_SUFFIX)
5122 AC_SUBST(LIB_PREP)
5123
5124 AC_SUBST(LIB_CLEAN)
5125 AC_SUBST(LIB_COMPILE)
5126 AC_SUBST(LIB_LINK)
5127 AC_SUBST(LIB_INSTALL)
5128 AC_SUBST(LIB_UNINSTALL)
5129
5130 ])dnl
5131 dnl ---------------------------------------------------------------------------
5132 dnl CF_WITH_PATH version: 8 updated: 2007/05/13 13:16:35
5133 dnl ------------
5134 dnl Wrapper for AC_ARG_WITH to ensure that user supplies a pathname, not just
5135 dnl defaulting to yes/no.
5136 dnl
5137 dnl $1 = option name
5138 dnl $2 = help-text
5139 dnl $3 = environment variable to set
5140 dnl $4 = default value, shown in the help-message, must be a constant
5141 dnl $5 = default value, if it's an expression & cannot be in the help-message
5142 dnl
5143 AC_DEFUN([CF_WITH_PATH],
5144 [AC_ARG_WITH($1,[$2 ](default: ifelse($4,,empty,$4)),,
5145 ifelse($4,,[withval="${$3}"],[withval="${$3-ifelse($5,,$4,$5)}"]))dnl
5146 if ifelse($5,,true,[test -n "$5"]) ; then
5147 CF_PATH_SYNTAX(withval)
5148 fi
5149 $3="$withval"
5150 AC_SUBST($3)dnl
5151 ])dnl
5152 dnl ---------------------------------------------------------------------------
5153 dnl CF_WITH_PATHLIST version: 5 updated: 2001/12/10 01:28:30
5154 dnl ----------------
5155 dnl Process an option specifying a list of colon-separated paths.
5156 dnl
5157 dnl $1 = option name
5158 dnl $2 = help-text
5159 dnl $3 = environment variable to set
5160 dnl $4 = default value, shown in the help-message, must be a constant
5161 dnl $5 = default value, if it's an expression & cannot be in the help-message
5162 dnl $6 = flag to tell if we want to define or substitute
5163 dnl
5164 AC_DEFUN([CF_WITH_PATHLIST],[
5165 AC_REQUIRE([CF_PATHSEP])
5166 AC_ARG_WITH($1,[$2 ](default: ifelse($4,,empty,$4)),,
5167 ifelse($4,,[withval=${$3}],[withval=${$3-ifelse($5,,$4,$5)}]))dnl
5168
5169 IFS="${IFS=     }"; ac_save_ifs="$IFS"; IFS="${PATHSEP}"
5170 cf_dst_path=
5171 for cf_src_path in $withval
5172 do
5173   CF_PATH_SYNTAX(cf_src_path)
5174   test -n "$cf_dst_path" && cf_dst_path="${cf_dst_path}:"
5175   cf_dst_path="${cf_dst_path}${cf_src_path}"
5176 done
5177 IFS="$ac_save_ifs"
5178
5179 ifelse($6,define,[
5180 # Strip single quotes from the value, e.g., when it was supplied as a literal
5181 # for $4 or $5.
5182 case $cf_dst_path in #(vi
5183 \'*)
5184   cf_dst_path=`echo $cf_dst_path |sed -e s/\'// -e s/\'\$//`
5185   ;;
5186 esac
5187 cf_dst_path=`echo "$cf_dst_path" | sed -e 's/\\\\/\\\\\\\\/g'`
5188 ])
5189
5190 eval '$3="$cf_dst_path"'
5191 AC_SUBST($3)dnl
5192
5193 ])dnl
5194 dnl ---------------------------------------------------------------------------
5195 dnl CF_WITH_PTHREAD version: 2 updated: 2008/08/23 18:26:05
5196 dnl ---------------
5197 dnl Check for POSIX thread library.
5198 AC_DEFUN([CF_WITH_PTHREAD],
5199 [
5200 AC_MSG_CHECKING(if you want to link with the pthread library)
5201 AC_ARG_WITH(pthread,
5202     [  --with-pthread          use POSIX thread library],
5203     [with_pthread=$withval],
5204     [with_pthread=no])
5205 AC_MSG_RESULT($with_pthread)
5206
5207 if test "$with_pthread" != no ; then
5208     AC_CHECK_HEADER(pthread.h,[
5209         AC_DEFINE(HAVE_PTHREADS_H)
5210
5211         AC_MSG_CHECKING(if we can link with the pthread library)
5212         cf_save_LIBS="$LIBS"
5213         LIBS="-lpthread $LIBS"
5214         AC_TRY_LINK([
5215 #include <pthread.h>
5216 ],[
5217         int rc = pthread_create(0,0,0,0);
5218 ],[with_pthread=yes],[with_pthread=no])
5219         LIBS="$cf_save_LIBS"
5220         AC_MSG_RESULT($with_pthread)
5221
5222         if test "$with_pthread" = yes ; then
5223             LIBS="-lpthread $LIBS"
5224             AC_DEFINE(HAVE_LIBPTHREADS)
5225         else
5226             AC_MSG_ERROR(Cannot link with pthread library)
5227         fi
5228     ])
5229 fi
5230 ])
5231 dnl ---------------------------------------------------------------------------
5232 dnl CF_WITH_REL_VERSION version: 1 updated: 2003/09/20 18:12:49
5233 dnl -------------------
5234 dnl Allow library's release-version to be overridden.  Generally this happens when a
5235 dnl packager has incremented the release-version past that used in the original package,
5236 dnl and wishes to keep doing this.
5237 dnl
5238 dnl $1 is the package name, if any, to derive corresponding {package}_MAJOR
5239 dnl and {package}_MINOR symbols
5240 dnl symbol.
5241 AC_DEFUN([CF_WITH_REL_VERSION],[
5242 test -z "$cf_cv_rel_version" && cf_cv_rel_version=0.0
5243 AC_ARG_WITH(rel-version,
5244 [  --with-rel-version=XXX  override derived release version],
5245 [AC_MSG_WARN(overriding release version $cf_cv_rel_version to $withval)
5246  cf_cv_rel_version=$withval])
5247 ifelse($1,,[
5248  CF_NUMBER_SYNTAX($cf_cv_rel_version,Release version)
5249 ],[
5250  $1_MAJOR=`echo "$cf_cv_rel_version" | sed -e 's/\..*//'`
5251  $1_MINOR=`echo "$cf_cv_rel_version" | sed -e 's/^[[^.]]*//' -e 's/^\.//' -e 's/\..*//'`
5252  CF_NUMBER_SYNTAX([$]$1_MAJOR,Release major-version)
5253  CF_NUMBER_SYNTAX([$]$1_MINOR,Release minor-version)
5254 ])
5255 ])dnl
5256 dnl ---------------------------------------------------------------------------
5257 dnl CF_WITH_SYSMOUSE version: 2 updated: 2003/03/22 19:13:43
5258 dnl ----------------
5259 dnl If we can compile with sysmouse, make it available unless it is not wanted.
5260 AC_DEFUN([CF_WITH_SYSMOUSE],[
5261 # not everyone has "test -c"
5262 if test -c /dev/sysmouse 2>/dev/null ; then
5263 AC_MSG_CHECKING(if you want to use sysmouse)
5264 AC_ARG_WITH(sysmouse,
5265         [  --with-sysmouse         use sysmouse (FreeBSD console)],
5266         [cf_with_sysmouse=$withval],
5267         [cf_with_sysmouse=maybe])
5268         if test "$cf_with_sysmouse" != no ; then
5269         AC_TRY_COMPILE([
5270 #include <osreldate.h>
5271 #if (__FreeBSD_version >= 400017)
5272 #include <sys/consio.h>
5273 #include <sys/fbio.h>
5274 #else
5275 #include <machine/console.h>
5276 #endif
5277 ],[
5278         struct mouse_info the_mouse;
5279         ioctl(0, CONS_MOUSECTL, &the_mouse);
5280 ],[cf_with_sysmouse=yes],[cf_with_sysmouse=no])
5281         fi
5282 AC_MSG_RESULT($cf_with_sysmouse)
5283 test "$cf_with_sysmouse" = yes && AC_DEFINE(USE_SYSMOUSE)
5284 fi
5285 ])dnl
5286 dnl ---------------------------------------------------------------------------
5287 dnl CF_WITH_VALGRIND version: 1 updated: 2006/12/14 18:00:21
5288 dnl ----------------
5289 AC_DEFUN([CF_WITH_VALGRIND],[
5290 CF_NO_LEAKS_OPTION(valgrind,
5291         [  --with-valgrind         test: use valgrind],
5292         [USE_VALGRIND])
5293 ])dnl
5294 dnl ---------------------------------------------------------------------------
5295 dnl CF_XOPEN_SOURCE version: 26 updated: 2008/07/27 11:26:57
5296 dnl ---------------
5297 dnl Try to get _XOPEN_SOURCE defined properly that we can use POSIX functions,
5298 dnl or adapt to the vendor's definitions to get equivalent functionality,
5299 dnl without losing the common non-POSIX features.
5300 dnl
5301 dnl Parameters:
5302 dnl     $1 is the nominal value for _XOPEN_SOURCE
5303 dnl     $2 is the nominal value for _POSIX_C_SOURCE
5304 AC_DEFUN([CF_XOPEN_SOURCE],[
5305
5306 AC_REQUIRE([CF_PROG_CC_U_D])
5307
5308 cf_XOPEN_SOURCE=ifelse($1,,500,$1)
5309 cf_POSIX_C_SOURCE=ifelse($2,,199506L,$2)
5310
5311 case $host_os in #(vi
5312 aix[[45]]*) #(vi
5313         CPPFLAGS="$CPPFLAGS -D_ALL_SOURCE"
5314         ;;
5315 freebsd*|dragonfly*) #(vi
5316         # 5.x headers associate
5317         #       _XOPEN_SOURCE=600 with _POSIX_C_SOURCE=200112L
5318         #       _XOPEN_SOURCE=500 with _POSIX_C_SOURCE=199506L
5319         cf_POSIX_C_SOURCE=200112L
5320         cf_XOPEN_SOURCE=600
5321         CPPFLAGS="$CPPFLAGS -D_BSD_TYPES -D__BSD_VISIBLE -D_POSIX_C_SOURCE=$cf_POSIX_C_SOURCE -D_XOPEN_SOURCE=$cf_XOPEN_SOURCE"
5322         ;;
5323 hpux*) #(vi
5324         CPPFLAGS="$CPPFLAGS -D_HPUX_SOURCE"
5325         ;;
5326 irix[[56]].*) #(vi
5327         CPPFLAGS="$CPPFLAGS -D_SGI_SOURCE"
5328         ;;
5329 linux*|gnu*|k*bsd*-gnu) #(vi
5330         CF_GNU_SOURCE
5331         ;;
5332 mirbsd*) #(vi
5333         # setting _XOPEN_SOURCE or _POSIX_SOURCE breaks <arpa/inet.h>
5334         ;;
5335 netbsd*) #(vi
5336         # setting _XOPEN_SOURCE breaks IPv6 for lynx on NetBSD 1.6, breaks xterm, is not needed for ncursesw
5337         ;;
5338 openbsd*) #(vi
5339         # setting _XOPEN_SOURCE breaks xterm on OpenBSD 2.8, is not needed for ncursesw
5340         ;;
5341 osf[[45]]*) #(vi
5342         CPPFLAGS="$CPPFLAGS -D_OSF_SOURCE"
5343         ;;
5344 nto-qnx*) #(vi
5345         CPPFLAGS="$CPPFLAGS -D_QNX_SOURCE"
5346         ;;
5347 sco*) #(vi
5348         # setting _XOPEN_SOURCE breaks Lynx on SCO Unix / OpenServer
5349         ;;
5350 solaris*) #(vi
5351         CPPFLAGS="$CPPFLAGS -D__EXTENSIONS__"
5352         ;;
5353 *)
5354         AC_CACHE_CHECK(if we should define _XOPEN_SOURCE,cf_cv_xopen_source,[
5355         AC_TRY_COMPILE([#include <sys/types.h>],[
5356 #ifndef _XOPEN_SOURCE
5357 make an error
5358 #endif],
5359         [cf_cv_xopen_source=no],
5360         [cf_save="$CPPFLAGS"
5361          CPPFLAGS="$CPPFLAGS -D_XOPEN_SOURCE=$cf_XOPEN_SOURCE"
5362          AC_TRY_COMPILE([#include <sys/types.h>],[
5363 #ifdef _XOPEN_SOURCE
5364 make an error
5365 #endif],
5366         [cf_cv_xopen_source=no],
5367         [cf_cv_xopen_source=$cf_XOPEN_SOURCE])
5368         CPPFLAGS="$cf_save"
5369         ])
5370 ])
5371         if test "$cf_cv_xopen_source" != no ; then
5372                 CF_REMOVE_DEFINE(CFLAGS,$CFLAGS,_XOPEN_SOURCE)
5373                 CF_REMOVE_DEFINE(CPPFLAGS,$CPPFLAGS,_XOPEN_SOURCE)
5374                 test "$cf_cv_cc_u_d_options" = yes && \
5375                         CPPFLAGS="$CPPFLAGS -U_XOPEN_SOURCE"
5376                 CPPFLAGS="$CPPFLAGS -D_XOPEN_SOURCE=$cf_cv_xopen_source"
5377         fi
5378         CF_POSIX_C_SOURCE($cf_POSIX_C_SOURCE)
5379         ;;
5380 esac
5381 ])