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