aclocal.m4

   1 dnl***************************************************************************
   2 dnl Copyright (c) 1998-2006,2007 Free Software Foundation, Inc.              *
   3 dnl                                                                          *
   4 dnl Permission is hereby granted, free of charge, to any person obtaining a  *
   5 dnl copy of this software and associated documentation files (the            *
   6 dnl "Software"), to deal in the Software without restriction, including      *
   7 dnl without limitation the rights to use, copy, modify, merge, publish,      *
   8 dnl distribute, distribute with modifications, sublicense, and/or sell       *
   9 dnl copies of the Software, and to permit persons to whom the Software is    *
  10 dnl furnished to do so, subject to the following conditions:                 *
  11 dnl                                                                          *
  12 dnl The above copyright notice and this permission notice shall be included  *
  13 dnl in all copies or substantial portions of the Software.                   *
  14 dnl                                                                          *
  15 dnl THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS  *
  16 dnl OR IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF               *
  17 dnl MERCHANTABILITY, FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT.   *
  18 dnl IN NO EVENT SHALL THE ABOVE COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM,   *
  19 dnl DAMAGES OR OTHER LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR    *
  20 dnl OTHERWISE, ARISING FROM, OUT OF OR IN CONNECTION WITH THE SOFTWARE OR    *
  21 dnl THE USE OR OTHER DEALINGS IN THE SOFTWARE.                               *
  22 dnl                                                                          *
  23 dnl Except as contained in this notice, the name(s) of the above copyright   *
  24 dnl holders shall not be used in advertising or otherwise to promote the     *
  25 dnl sale, use or other dealings in this Software without prior written       *
  26 dnl authorization.                                                           *
  27 dnl***************************************************************************
  28 dnl
  29 dnl Author: Thomas E. Dickey 1995-on
  30 dnl
  31 dnl $Id: aclocal.m4,v 1.442 2007/12/01 20:02:42 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: 8 updated: 2007/07/30 19:22:58
 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                   AC_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: 5 updated: 2007/07/30 19:12:03
 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         AC_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: 3 updated: 1997/09/06 13:40:44
 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_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: 10 updated: 2004/05/23 13:03:31
 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_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_POLL version: 4 updated: 2006/12/16 12:33:30
1062 dnl ------------
1063 dnl See if the poll function really works.  Some platforms have poll(), but
1064 dnl it does not work for terminals or files.
1065 AC_DEFUN([CF_FUNC_POLL],[
1066 AC_CACHE_CHECK(if poll really works,cf_cv_working_poll,[
1067 AC_TRY_RUN([
1068 #include <stdio.h>
1069 #ifdef HAVE_POLL_H
1070 #include <poll.h>
1071 #else
1072 #include <sys/poll.h>
1073 #endif
1074 int main() {
1075         struct pollfd myfds;
1076         int ret;
1077
1078         myfds.fd = 0;
1079         myfds.events = POLLIN;
1080
1081         ret = poll(&myfds, 1, 100);
1082         ${cf_cv_main_return:-return}(ret != 0);
1083 }],
1084         [cf_cv_working_poll=yes],
1085         [cf_cv_working_poll=no],
1086         [cf_cv_working_poll=unknown])])
1087 test "$cf_cv_working_poll" = "yes" && AC_DEFINE(HAVE_WORKING_POLL)
1088 ])dnl
1089 dnl ---------------------------------------------------------------------------
1090 dnl CF_FUNC_TERMIOS version: 2 updated: 2000/07/22 23:37:24
1091 dnl ---------------
1092 dnl Some old/broken variations define tcgetattr() only as a macro in
1093 dnl termio(s).h
1094 AC_DEFUN([CF_FUNC_TERMIOS],[
1095 AC_REQUIRE([CF_STRUCT_TERMIOS])
1096 AC_CACHE_CHECK(for tcgetattr, cf_cv_have_tcgetattr,[
1097 AC_TRY_LINK([
1098 #include <sys/types.h>
1099 #ifdef HAVE_UNISTD_H
1100 #include <unistd.h>
1101 #endif
1102 #ifdef HAVE_TERMIOS_H
1103 #include <termios.h>
1104 #define TTY struct termios
1105 #else
1106 #ifdef HAVE_TERMIO_H
1107 #include <termio.h>
1108 #define TTY struct termio
1109 #endif
1110 #endif
1111 ],[
1112 TTY foo;
1113 tcgetattr(1, &foo);],
1114 [cf_cv_have_tcgetattr=yes],
1115 [cf_cv_have_tcgetattr=no])])
1116 test "$cf_cv_have_tcgetattr" = yes && AC_DEFINE(HAVE_TCGETATTR)
1117 ])dnl
1118 dnl ---------------------------------------------------------------------------
1119 dnl CF_FUNC_VSSCANF version: 3 updated: 2001/12/19 00:50:10
1120 dnl ---------------
1121 dnl Check for vsscanf() function, which is in c9x but generally not in earlier
1122 dnl versions of C.  It is in the GNU C library, and can often be simulated by
1123 dnl other functions.
1124 AC_DEFUN([CF_FUNC_VSSCANF],
1125 [
1126 AC_CACHE_CHECK(for vsscanf function or workaround,cf_cv_func_vsscanf,[
1127 AC_TRY_LINK([
1128 #include <stdarg.h>
1129 #include <stdio.h>],[
1130         va_list ap;
1131         vsscanf("from", "%d", ap)],[cf_cv_func_vsscanf=vsscanf],[
1132 AC_TRY_LINK([
1133 #include <stdarg.h>
1134 #include <stdio.h>],[
1135     FILE strbuf;
1136     char *str = "from";
1137
1138     strbuf._flag = _IOREAD;
1139     strbuf._ptr = strbuf._base = (unsigned char *) str;
1140     strbuf._cnt = strlen(str);
1141     strbuf._file = _NFILE;
1142     return (vfscanf(&strbuf, "%d", ap))],[cf_cv_func_vsscanf=vfscanf],[
1143 AC_TRY_LINK([
1144 #include <stdarg.h>
1145 #include <stdio.h>],[
1146     FILE strbuf;
1147     char *str = "from";
1148
1149     strbuf._flag = _IOREAD;
1150     strbuf._ptr = strbuf._base = (unsigned char *) str;
1151     strbuf._cnt = strlen(str);
1152     strbuf._file = _NFILE;
1153     return (_doscan(&strbuf, "%d", ap))],[cf_cv_func_vsscanf=_doscan],[
1154 cf_cv_func_vsscanf=no])])])])
1155
1156 case $cf_cv_func_vsscanf in #(vi
1157 vsscanf) AC_DEFINE(HAVE_VSSCANF);; #(vi
1158 vfscanf) AC_DEFINE(HAVE_VFSCANF);; #(vi
1159 _doscan) AC_DEFINE(HAVE__DOSCAN);;
1160 esac
1161
1162 ])dnl
1163 dnl ---------------------------------------------------------------------------
1164 dnl CF_GCC_ATTRIBUTES version: 11 updated: 2007/07/29 09:55:12
1165 dnl -----------------
1166 dnl Test for availability of useful gcc __attribute__ directives to quiet
1167 dnl compiler warnings.  Though useful, not all are supported -- and contrary
1168 dnl to documentation, unrecognized directives cause older compilers to barf.
1169 AC_DEFUN([CF_GCC_ATTRIBUTES],
1170 [
1171 if test "$GCC" = yes
1172 then
1173 cat > conftest.i <<EOF
1174 #ifndef GCC_PRINTF
1175 #define GCC_PRINTF 0
1176 #endif
1177 #ifndef GCC_SCANF
1178 #define GCC_SCANF 0
1179 #endif
1180 #ifndef GCC_NORETURN
1181 #define GCC_NORETURN /* nothing */
1182 #endif
1183 #ifndef GCC_UNUSED
1184 #define GCC_UNUSED /* nothing */
1185 #endif
1186 EOF
1187 if test "$GCC" = yes
1188 then
1189         AC_CHECKING([for $CC __attribute__ directives])
1190 cat > conftest.$ac_ext <<EOF
1191 #line __oline__ "${as_me-configure}"
1192 #include "confdefs.h"
1193 #include "conftest.h"
1194 #include "conftest.i"
1195 #if     GCC_PRINTF
1196 #define GCC_PRINTFLIKE(fmt,var) __attribute__((format(printf,fmt,var)))
1197 #else
1198 #define GCC_PRINTFLIKE(fmt,var) /*nothing*/
1199 #endif
1200 #if     GCC_SCANF
1201 #define GCC_SCANFLIKE(fmt,var)  __attribute__((format(scanf,fmt,var)))
1202 #else
1203 #define GCC_SCANFLIKE(fmt,var)  /*nothing*/
1204 #endif
1205 extern void wow(char *,...) GCC_SCANFLIKE(1,2);
1206 extern void oops(char *,...) GCC_PRINTFLIKE(1,2) GCC_NORETURN;
1207 extern void foo(void) GCC_NORETURN;
1208 int main(int argc GCC_UNUSED, char *argv[[]] GCC_UNUSED) { return 0; }
1209 EOF
1210         for cf_attribute in scanf printf unused noreturn
1211         do
1212                 CF_UPPER(cf_ATTRIBUTE,$cf_attribute)
1213                 cf_directive="__attribute__(($cf_attribute))"
1214                 echo "checking for $CC $cf_directive" 1>&AC_FD_CC
1215                 case $cf_attribute in
1216                 scanf|printf)
1217                 cat >conftest.h <<EOF
1218 #define GCC_$cf_ATTRIBUTE 1
1219 EOF
1220                         ;;
1221                 *)
1222                 cat >conftest.h <<EOF
1223 #define GCC_$cf_ATTRIBUTE $cf_directive
1224 EOF
1225                         ;;
1226                 esac
1227                 if AC_TRY_EVAL(ac_compile); then
1228                         test -n "$verbose" && AC_MSG_RESULT(... $cf_attribute)
1229                         cat conftest.h >>confdefs.h
1230                 fi
1231         done
1232 else
1233         fgrep define conftest.i >>confdefs.h
1234 fi
1235 rm -rf conftest*
1236 fi
1237 ])dnl
1238 dnl ---------------------------------------------------------------------------
1239 dnl CF_GCC_VERSION version: 4 updated: 2005/08/27 09:53:42
1240 dnl --------------
1241 dnl Find version of gcc
1242 AC_DEFUN([CF_GCC_VERSION],[
1243 AC_REQUIRE([AC_PROG_CC])
1244 GCC_VERSION=none
1245 if test "$GCC" = yes ; then
1246         AC_MSG_CHECKING(version of $CC)
1247         GCC_VERSION="`${CC} --version| sed -e '2,$d' -e 's/^.*(GCC) //' -e 's/^[[^0-9.]]*//' -e 's/[[^0-9.]].*//'`"
1248         test -z "$GCC_VERSION" && GCC_VERSION=unknown
1249         AC_MSG_RESULT($GCC_VERSION)
1250 fi
1251 ])dnl
1252 dnl ---------------------------------------------------------------------------
1253 dnl CF_GCC_WARNINGS version: 22 updated: 2007/07/29 09:55:12
1254 dnl ---------------
1255 dnl Check if the compiler supports useful warning options.  There's a few that
1256 dnl we don't use, simply because they're too noisy:
1257 dnl
1258 dnl     -Wconversion (useful in older versions of gcc, but not in gcc 2.7.x)
1259 dnl     -Wredundant-decls (system headers make this too noisy)
1260 dnl     -Wtraditional (combines too many unrelated messages, only a few useful)
1261 dnl     -Wwrite-strings (too noisy, but should review occasionally).  This
1262 dnl             is enabled for ncurses using "--enable-const".
1263 dnl     -pedantic
1264 dnl
1265 dnl Parameter:
1266 dnl     $1 is an optional list of gcc warning flags that a particular
1267 dnl             application might want to use, e.g., "no-unused" for
1268 dnl             -Wno-unused
1269 dnl Special:
1270 dnl     If $with_ext_const is "yes", add a check for -Wwrite-strings
1271 dnl
1272 AC_DEFUN([CF_GCC_WARNINGS],
1273 [
1274 AC_REQUIRE([CF_GCC_VERSION])
1275 CF_INTEL_COMPILER(GCC,INTEL_COMPILER,CFLAGS)
1276
1277 cat > conftest.$ac_ext <<EOF
1278 #line __oline__ "${as_me-configure}"
1279 int main(int argc, char *argv[[]]) { return (argv[[argc-1]] == 0) ; }
1280 EOF
1281
1282 if test "$INTEL_COMPILER" = yes
1283 then
1284 # The "-wdXXX" options suppress warnings:
1285 # remark #1419: external declaration in primary source file
1286 # remark #1682: implicit conversion of a 64-bit integral type to a smaller integral type (potential portability problem)
1287 # remark #1683: explicit conversion of a 64-bit integral type to a smaller integral type (potential portability problem)
1288 # remark #1684: conversion from pointer to same-sized integral type (potential portability problem)
1289 # remark #193: zero used for undefined preprocessing identifier
1290 # remark #593: variable "curs_sb_left_arrow" was set but never used
1291 # remark #810: conversion from "int" to "Dimension={unsigned short}" may lose significant bits
1292 # remark #869: parameter "tw" was never referenced
1293 # remark #981: operands are evaluated in unspecified order
1294 # warning #269: invalid format string conversion
1295
1296         AC_CHECKING([for $CC warning options])
1297         cf_save_CFLAGS="$CFLAGS"
1298         EXTRA_CFLAGS="-Wall"
1299         for cf_opt in \
1300                 wd1419 \
1301                 wd1682 \
1302                 wd1683 \
1303                 wd1684 \
1304                 wd193 \
1305                 wd279 \
1306                 wd593 \
1307                 wd810 \
1308                 wd869 \
1309                 wd981
1310         do
1311                 CFLAGS="$cf_save_CFLAGS $EXTRA_CFLAGS -$cf_opt"
1312                 if AC_TRY_EVAL(ac_compile); then
1313                         test -n "$verbose" && AC_MSG_RESULT(... -$cf_opt)
1314                         EXTRA_CFLAGS="$EXTRA_CFLAGS -$cf_opt"
1315                 fi
1316         done
1317         CFLAGS="$cf_save_CFLAGS"
1318
1319 elif test "$GCC" = yes
1320 then
1321         AC_CHECKING([for $CC warning options])
1322         cf_save_CFLAGS="$CFLAGS"
1323         EXTRA_CFLAGS="-W -Wall"
1324         cf_warn_CONST=""
1325         test "$with_ext_const" = yes && cf_warn_CONST="Wwrite-strings"
1326         for cf_opt in \
1327                 Wbad-function-cast \
1328                 Wcast-align \
1329                 Wcast-qual \
1330                 Winline \
1331                 Wmissing-declarations \
1332                 Wmissing-prototypes \
1333                 Wnested-externs \
1334                 Wpointer-arith \
1335                 Wshadow \
1336                 Wstrict-prototypes \
1337                 Wundef $cf_warn_CONST $1
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                         case $cf_opt in #(vi
1343                         Wcast-qual) #(vi
1344                                 CPPFLAGS="$CPPFLAGS -DXTSTRINGDEFINES"
1345                                 ;;
1346                         Winline) #(vi
1347                                 case $GCC_VERSION in
1348                                 3.3*)
1349                                         CF_VERBOSE(feature is broken in gcc $GCC_VERSION)
1350                                         continue;;
1351                                 esac
1352                                 ;;
1353                         esac
1354                         EXTRA_CFLAGS="$EXTRA_CFLAGS -$cf_opt"
1355                 fi
1356         done
1357         CFLAGS="$cf_save_CFLAGS"
1358 fi
1359 rm -f conftest*
1360
1361 AC_SUBST(EXTRA_CFLAGS)
1362 ])dnl
1363 dnl ---------------------------------------------------------------------------
1364 dnl CF_GNAT_TRY_LINK version: 1 updated: 2004/08/21 19:02:08
1365 dnl ----------------
1366 dnl Verify that a test program compiles/links with GNAT.
1367 dnl $cf_ada_make is set to the program that compiles/links
1368 dnl $ADAFLAGS may be set to the GNAT flags.
1369 dnl
1370 dnl $1 is the text of the spec
1371 dnl $2 is the text of the body
1372 dnl $3 is the shell command to execute if successful
1373 dnl $4 is the shell command to execute if not successful
1374 AC_DEFUN([CF_GNAT_TRY_LINK],
1375 [
1376 rm -f conftest*
1377 cat >>conftest.ads <<CF_EOF
1378 $1
1379 CF_EOF
1380 cat >>conftest.adb <<CF_EOF
1381 $2
1382 CF_EOF
1383 if ( $cf_ada_make $ADAFLAGS conftest 1>&AC_FD_CC 2>&1 ) ; then
1384 ifelse($3,,      :,[      $3])
1385 ifelse($4,,,[else
1386    $4])
1387 fi
1388 rm -f conftest*
1389 ])dnl
1390 dnl ---------------------------------------------------------------------------
1391 dnl CF_GNAT_TRY_RUN version: 3 updated: 2004/08/21 19:02:08
1392 dnl ---------------
1393 dnl Verify that a test program compiles and runs with GNAT
1394 dnl $cf_ada_make is set to the program that compiles/links
1395 dnl $ADAFLAGS may be set to the GNAT flags.
1396 dnl
1397 dnl $1 is the text of the spec
1398 dnl $2 is the text of the body
1399 dnl $3 is the shell command to execute if successful
1400 dnl $4 is the shell command to execute if not successful
1401 AC_DEFUN([CF_GNAT_TRY_RUN],
1402 [
1403 rm -f conftest*
1404 cat >>conftest.ads <<CF_EOF
1405 $1
1406 CF_EOF
1407 cat >>conftest.adb <<CF_EOF
1408 $2
1409 CF_EOF
1410 if ( $cf_ada_make $ADAFLAGS conftest 1>&AC_FD_CC 2>&1 ) ; then
1411    if ( ./conftest 1>&AC_FD_CC 2>&1 ) ; then
1412 ifelse($3,,      :,[      $3])
1413 ifelse($4,,,[   else
1414       $4])
1415    fi
1416 ifelse($4,,,[else
1417    $4])
1418 fi
1419 rm -f conftest*
1420 ])dnl
1421 dnl ---------------------------------------------------------------------------
1422 dnl CF_GNAT_VERSION version: 12 updated: 2006/10/14 15:23:15
1423 dnl ---------------
1424 dnl Verify version of GNAT.
1425 AC_DEFUN([CF_GNAT_VERSION],
1426 [
1427 AC_MSG_CHECKING(for gnat version)
1428 cf_gnat_version=`${cf_ada_make-gnatmake} -v 2>&1 | grep '[[0-9]].[[0-9]][[0-9]]*' |\
1429   sed -e '2,$d' -e 's/[[^0-9 \.]]//g' -e 's/^[[ ]]*//' -e 's/ .*//'`
1430 AC_MSG_RESULT($cf_gnat_version)
1431
1432 case $cf_gnat_version in
1433   3.1[[1-9]]*|3.[[2-9]]*|[[4-9]].*)
1434     cf_cv_prog_gnat_correct=yes
1435     ;;
1436   *) echo Unsupported GNAT version $cf_gnat_version. Required is 3.11 or better. Disabling Ada95 binding.
1437      cf_cv_prog_gnat_correct=no
1438      ;;
1439 esac
1440 case $cf_gnat_version in
1441   3.[[1-9]]*|[[4-9]].*)
1442       cf_compile_generics=generics
1443       cf_generic_objects="\${GENOBJS}"
1444       ;;
1445   *)  cf_compile_generics=
1446       cf_generic_objects=
1447       ;;
1448 esac
1449 ])
1450 dnl ---------------------------------------------------------------------------
1451 dnl CF_GNU_SOURCE version: 6 updated: 2005/07/09 13:23:07
1452 dnl -------------
1453 dnl Check if we must define _GNU_SOURCE to get a reasonable value for
1454 dnl _XOPEN_SOURCE, upon which many POSIX definitions depend.  This is a defect
1455 dnl (or misfeature) of glibc2, which breaks portability of many applications,
1456 dnl since it is interwoven with GNU extensions.
1457 dnl
1458 dnl Well, yes we could work around it...
1459 AC_DEFUN([CF_GNU_SOURCE],
1460 [
1461 AC_CACHE_CHECK(if we must define _GNU_SOURCE,cf_cv_gnu_source,[
1462 AC_TRY_COMPILE([#include <sys/types.h>],[
1463 #ifndef _XOPEN_SOURCE
1464 make an error
1465 #endif],
1466         [cf_cv_gnu_source=no],
1467         [cf_save="$CPPFLAGS"
1468          CPPFLAGS="$CPPFLAGS -D_GNU_SOURCE"
1469          AC_TRY_COMPILE([#include <sys/types.h>],[
1470 #ifdef _XOPEN_SOURCE
1471 make an error
1472 #endif],
1473         [cf_cv_gnu_source=no],
1474         [cf_cv_gnu_source=yes])
1475         CPPFLAGS="$cf_save"
1476         ])
1477 ])
1478 test "$cf_cv_gnu_source" = yes && CPPFLAGS="$CPPFLAGS -D_GNU_SOURCE"
1479 ])dnl
1480 dnl ---------------------------------------------------------------------------
1481 dnl CF_GPP_LIBRARY version: 8 updated: 2003/02/02 01:41:46
1482 dnl --------------
1483 dnl If we're trying to use g++, test if libg++ is installed (a rather common
1484 dnl problem :-).  If we have the compiler but no library, we'll be able to
1485 dnl configure, but won't be able to build the c++ demo program.
1486 AC_DEFUN([CF_GPP_LIBRARY],
1487 [
1488 cf_cxx_library=unknown
1489 case $cf_cv_system_name in #(vi
1490 os2*) #(vi
1491         cf_gpp_libname=gpp
1492         ;;
1493 *)
1494         cf_gpp_libname=g++
1495         ;;
1496 esac
1497 if test "$GXX" = yes; then
1498         AC_MSG_CHECKING([for lib$cf_gpp_libname])
1499         cf_save="$LIBS"
1500         LIBS="$LIBS -l$cf_gpp_libname"
1501         AC_TRY_LINK([
1502 #include <$cf_gpp_libname/builtin.h>
1503         ],
1504         [two_arg_error_handler_t foo2 = lib_error_handler],
1505         [cf_cxx_library=yes
1506          CXXLIBS="$CXXLIBS -l$cf_gpp_libname"
1507          if test "$cf_gpp_libname" = cpp ; then
1508             AC_DEFINE(HAVE_GPP_BUILTIN_H)
1509          else
1510             AC_DEFINE(HAVE_GXX_BUILTIN_H)
1511          fi],
1512         [AC_TRY_LINK([
1513 #include <builtin.h>
1514         ],
1515         [two_arg_error_handler_t foo2 = lib_error_handler],
1516         [cf_cxx_library=yes
1517          CXXLIBS="$CXXLIBS -l$cf_gpp_libname"
1518          AC_DEFINE(HAVE_BUILTIN_H)],
1519         [cf_cxx_library=no])])
1520         LIBS="$cf_save"
1521         AC_MSG_RESULT($cf_cxx_library)
1522 fi
1523 ])dnl
1524 dnl ---------------------------------------------------------------------------
1525 dnl CF_GXX_VERSION version: 5 updated: 2005/08/27 09:53:42
1526 dnl --------------
1527 dnl Check for version of g++
1528 AC_DEFUN([CF_GXX_VERSION],[
1529 AC_REQUIRE([AC_PROG_CPP])
1530 GXX_VERSION=none
1531 if test "$GXX" = yes; then
1532         AC_MSG_CHECKING(version of g++)
1533         GXX_VERSION="`${CXX-g++} --version| sed -e '2,$d' -e 's/^.*(GCC) //' -e 's/^[[^0-9.]]*//' -e 's/[[^0-9.]].*//'`"
1534         test -z "$GXX_VERSION" && GXX_VERSION=unknown
1535         AC_MSG_RESULT($GXX_VERSION)
1536 fi
1537 ])dnl
1538 dnl ---------------------------------------------------------------------------
1539 dnl CF_GXX_WARNINGS version: 5 updated: 2005/08/13 14:54:38
1540 dnl ---------------
1541 dnl Check if the compiler supports useful warning options.
1542 dnl
1543 dnl Most of gcc's options apply to g++, except:
1544 dnl     -Wbad-function-cast
1545 dnl     -Wmissing-declarations
1546 dnl     -Wnested-externs
1547 dnl
1548 dnl Omit a few (for now):
1549 dnl     -Winline
1550 dnl
1551 dnl Parameter:
1552 dnl     $1 is an optional list of g++ warning flags that a particular
1553 dnl             application might want to use, e.g., "no-unused" for
1554 dnl             -Wno-unused
1555 dnl Special:
1556 dnl     If $with_ext_const is "yes", add a check for -Wwrite-strings
1557 dnl
1558 AC_DEFUN([CF_GXX_WARNINGS],
1559 [
1560
1561 CF_INTEL_COMPILER(GXX,INTEL_CPLUSPLUS,CXXFLAGS)
1562
1563 AC_REQUIRE([CF_GXX_VERSION])
1564
1565 AC_LANG_SAVE
1566 AC_LANG_CPLUSPLUS
1567
1568 cat > conftest.$ac_ext <<EOF
1569 #line __oline__ "configure"
1570 int main(int argc, char *argv[[]]) { return (argv[[argc-1]] == 0) ; }
1571 EOF
1572
1573 if test "$INTEL_CPLUSPLUS" = yes
1574 then
1575 # The "-wdXXX" options suppress warnings:
1576 # remark #1419: external declaration in primary source file
1577 # remark #1682: implicit conversion of a 64-bit integral type to a smaller integral type (potential portability problem)
1578 # remark #1683: explicit conversion of a 64-bit integral type to a smaller integral type (potential portability problem)
1579 # remark #1684: conversion from pointer to same-sized integral type (potential portability problem)
1580 # remark #193: zero used for undefined preprocessing identifier
1581 # remark #593: variable "curs_sb_left_arrow" was set but never used
1582 # remark #810: conversion from "int" to "Dimension={unsigned short}" may lose significant bits
1583 # remark #869: parameter "tw" was never referenced
1584 # remark #981: operands are evaluated in unspecified order
1585 # warning #269: invalid format string conversion
1586
1587         AC_CHECKING([for $CC warning options])
1588         cf_save_CXXFLAGS="$CXXFLAGS"
1589         EXTRA_CXXFLAGS="-Wall"
1590         for cf_opt in \
1591                 wd1419 \
1592                 wd1682 \
1593                 wd1683 \
1594                 wd1684 \
1595                 wd193 \
1596                 wd279 \
1597                 wd593 \
1598                 wd810 \
1599                 wd869 \
1600                 wd981
1601         do
1602                 CXXFLAGS="$cf_save_CXXFLAGS $EXTRA_CXXFLAGS -$cf_opt"
1603                 if AC_TRY_EVAL(ac_compile); then
1604                         test -n "$verbose" && AC_MSG_RESULT(... -$cf_opt)
1605                         EXTRA_CXXFLAGS="$EXTRA_CXXFLAGS -$cf_opt"
1606                 fi
1607         done
1608         CXXFLAGS="$cf_save_CXXFLAGS"
1609
1610 elif test "$GXX" = yes
1611 then
1612         AC_CHECKING([for $CXX warning options])
1613         cf_save_CXXFLAGS="$CXXFLAGS"
1614         EXTRA_CXXFLAGS="-W -Wall"
1615         cf_gxx_extra_warnings=""
1616         test "$with_ext_const" = yes && cf_gxx_extra_warnings="Wwrite-strings"
1617         case "$GCC_VERSION" in
1618         [[1-2]].*)
1619                 ;;
1620         *)
1621                 cf_gxx_extra_warnings="$cf_gxx_extra_warnings Weffc++"
1622                 ;;
1623         esac
1624         for cf_opt in \
1625                 Wabi \
1626                 fabi-version=0 \
1627                 Woverloaded-virtual \
1628                 Wsign-promo \
1629                 Wsynth \
1630                 Wold-style-cast \
1631                 Wcast-align \
1632                 Wcast-qual \
1633                 Wmissing-prototypes \
1634                 Wpointer-arith \
1635                 Wshadow \
1636                 Wstrict-prototypes \
1637                 Wundef $cf_gxx_extra_warnings $1
1638         do
1639                 CXXFLAGS="$cf_save_CXXFLAGS $EXTRA_CXXFLAGS -Werror -$cf_opt"
1640                 if AC_TRY_EVAL(ac_compile); then
1641                         test -n "$verbose" && AC_MSG_RESULT(... -$cf_opt)
1642                         EXTRA_CXXFLAGS="$EXTRA_CXXFLAGS -$cf_opt"
1643                 else
1644                         test -n "$verbose" && AC_MSG_RESULT(... no -$cf_opt)
1645                 fi
1646         done
1647         CXXFLAGS="$cf_save_CXXFLAGS"
1648 fi
1649
1650 rm -f conftest*
1651 AC_LANG_RESTORE
1652 AC_SUBST(EXTRA_CXXFLAGS)
1653 ])dnl
1654 dnl ---------------------------------------------------------------------------
1655 dnl CF_HASHED_DB version: 3 updated: 2007/11/24 17:43:37
1656 dnl ------------
1657 dnl Look for an instance of the Berkeley hashed database.
1658 dnl
1659 dnl $1 = optional parameter, to specify install-prefix for the database.
1660 AC_DEFUN([CF_HASHED_DB],
1661 [
1662 ifelse([$1],,,[
1663 case $1 in #(vi
1664 yes|*able*) #(vi
1665     ;;
1666 *)
1667     if test -d "$1" ; then
1668         CF_ADD_INCDIR($1/include)
1669         CF_ADD_LIBDIR($1/lib)
1670     fi
1671 esac
1672 ])
1673 AC_CHECK_HEADER(db.h,[
1674 CF_HASHED_DB_VERSION
1675 if test "$cf_cv_hashed_db_version" = unknown ; then
1676         AC_MSG_ERROR(Cannot determine version of db)
1677 else
1678         CF_HASHED_DB_LIBS
1679         if test "$cf_cv_hashed_db_libs" = unknown ; then
1680                 AC_MSG_ERROR(Cannot determine library for db)
1681         elif test "$cf_cv_hashed_db_libs" != default ; then
1682                 LIBS="-l$cf_cv_hashed_db_libs $LIBS"
1683         fi
1684 fi
1685 ],[
1686         AC_MSG_ERROR(Cannot find db.h)
1687 ])
1688 ])dnl
1689 dnl ---------------------------------------------------------------------------
1690 dnl CF_HASHED_DB_LIBS version: 7 updated: 2007/12/01 15:01:37
1691 dnl -----------------
1692 dnl Given that we have the header and version for hashed database, find the
1693 dnl library information.
1694 AC_DEFUN([CF_HASHED_DB_LIBS],
1695 [
1696 AC_CACHE_CHECK(for db libraries, cf_cv_hashed_db_libs,[
1697 cf_cv_hashed_db_libs=unknown
1698 for cf_db_libs in db$cf_cv_hashed_db_version db-$cf_cv_hashed_db_version db ''
1699 do
1700         cf_save_libs="$LIBS"
1701         if test -n "$cf_db_libs"; then
1702                 LIBS="-l$cf_db_libs $LIBS"
1703         fi
1704         CF_MSG_LOG(checking for library "$cf_db_libs")
1705         AC_TRY_LINK([
1706 $ac_includes_default
1707 #include <db.h>
1708 ],[
1709         char *path = "/tmp/foo";
1710 #ifdef DB_VERSION_MAJOR
1711 #if DB_VERSION_MAJOR >= 4
1712         DB *result = 0;
1713         db_create(&result, NULL, 0);
1714         result->open(result,
1715                 NULL,
1716                 path,
1717                 path,
1718                 DB_HASH,
1719                 DB_CREATE,
1720                 0644);
1721 #elif DB_VERSION_MAJOR >= 3
1722         DB *result = 0;
1723         db_create(&result, NULL, 0);
1724         result->open(result,
1725                 path,
1726                 path,
1727                 DB_HASH,
1728                 DB_CREATE,
1729                 0644);
1730 #elif DB_VERSION_MAJOR >= 2
1731         DB *result = 0;
1732         db_open(path,
1733                 DB_HASH,
1734                 DB_CREATE,
1735                 0644,
1736                 (DB_ENV *) 0,
1737                 (DB_INFO *) 0,
1738                 &result);
1739 #endif /* DB_VERSION_MAJOR */
1740 #else
1741         DB *result = dbopen(path,
1742                      2,
1743                      0644,
1744                      DB_HASH,
1745                      0);
1746 #endif
1747         ${cf_cv_main_return:-return}(result != 0)
1748 ],[
1749         if test -n "$cf_db_libs" ; then
1750                 cf_cv_hashed_db_libs=$cf_db_libs
1751         else
1752                 cf_cv_hashed_db_libs=default
1753         fi
1754         LIBS="$cf_save_libs"
1755         break
1756 ])
1757         LIBS="$cf_save_libs"
1758 done
1759 ])
1760 ])dnl
1761 dnl ---------------------------------------------------------------------------
1762 dnl CF_HASHED_DB_VERSION version: 3 updated: 2007/12/01 15:01:37
1763 dnl --------------------
1764 dnl Given that we have the header file for hashed database, find the version
1765 dnl information.
1766 AC_DEFUN([CF_HASHED_DB_VERSION],
1767 [
1768 AC_CACHE_CHECK(for version of db, cf_cv_hashed_db_version,[
1769 cf_cv_hashed_db_version=unknown
1770
1771 for cf_db_version in 1 2 3 4 5
1772 do
1773         CF_MSG_LOG(checking for db version $cf_db_version)
1774         AC_TRY_COMPILE([
1775 $ac_includes_default
1776 #include <db.h>
1777
1778 #ifdef DB_VERSION_MAJOR
1779         /* db2 (DB_VERSION_MAJOR=2) has also DB_VERSION_MINOR, tested with 7 */
1780 #if $cf_db_version == DB_VERSION_MAJOR
1781         /* ok */
1782 #else
1783         make an error
1784 #endif
1785 #else
1786 #if $cf_db_version == 1
1787         /* ok: assuming this is DB 1.8.5 */
1788 #else
1789         make an error
1790 #endif
1791 #endif
1792 ],[DBT *foo = 0],[
1793         cf_cv_hashed_db_version=$cf_db_version
1794         break
1795         ])
1796 done
1797 ])
1798 ])dnl
1799 dnl ---------------------------------------------------------------------------
1800 dnl CF_HELP_MESSAGE version: 3 updated: 1998/01/14 10:56:23
1801 dnl ---------------
1802 dnl Insert text into the help-message, for readability, from AC_ARG_WITH.
1803 AC_DEFUN([CF_HELP_MESSAGE],
1804 [AC_DIVERT_HELP([$1])dnl
1805 ])dnl
1806 dnl ---------------------------------------------------------------------------
1807 dnl CF_INCLUDE_DIRS version: 5 updated: 2006/10/14 15:23:15
1808 dnl ---------------
1809 dnl Construct the list of include-options according to whether we're building
1810 dnl in the source directory or using '--srcdir=DIR' option.  If we're building
1811 dnl with gcc, don't append the includedir if it happens to be /usr/include,
1812 dnl since that usually breaks gcc's shadow-includes.
1813 AC_DEFUN([CF_INCLUDE_DIRS],
1814 [
1815 CPPFLAGS="-I. -I../include $CPPFLAGS"
1816 if test "$srcdir" != "."; then
1817         CPPFLAGS="-I\${srcdir}/../include $CPPFLAGS"
1818 fi
1819 if test "$GCC" != yes; then
1820         CPPFLAGS="$CPPFLAGS -I\${includedir}"
1821 elif test "$includedir" != "/usr/include"; then
1822         if test "$includedir" = '${prefix}/include' ; then
1823                 if test $prefix != /usr ; then
1824                         CPPFLAGS="$CPPFLAGS -I\${includedir}"
1825                 fi
1826         else
1827                 CPPFLAGS="$CPPFLAGS -I\${includedir}"
1828         fi
1829 fi
1830 AC_SUBST(CPPFLAGS)
1831 ])dnl
1832 dnl ---------------------------------------------------------------------------
1833 dnl CF_INTEL_COMPILER version: 3 updated: 2005/08/06 18:37:29
1834 dnl -----------------
1835 dnl Check if the given compiler is really the Intel compiler for Linux.  It
1836 dnl tries to imitate gcc, but does not return an error when it finds a mismatch
1837 dnl between prototypes, e.g., as exercised by CF_MISSING_CHECK.
1838 dnl
1839 dnl This macro should be run "soon" after AC_PROG_CC or AC_PROG_CPLUSPLUS, to
1840 dnl ensure that it is not mistaken for gcc/g++.  It is normally invoked from
1841 dnl the wrappers for gcc and g++ warnings.
1842 dnl
1843 dnl $1 = GCC (default) or GXX
1844 dnl $2 = INTEL_COMPILER (default) or INTEL_CPLUSPLUS
1845 dnl $3 = CFLAGS (default) or CXXFLAGS
1846 AC_DEFUN([CF_INTEL_COMPILER],[
1847 ifelse($2,,INTEL_COMPILER,[$2])=no
1848
1849 if test "$ifelse($1,,[$1],GCC)" = yes ; then
1850         case $host_os in
1851         linux*|gnu*)
1852                 AC_MSG_CHECKING(if this is really Intel ifelse($1,GXX,C++,C) compiler)
1853                 cf_save_CFLAGS="$ifelse($3,,CFLAGS,[$3])"
1854                 ifelse($3,,CFLAGS,[$3])="$ifelse($3,,CFLAGS,[$3]) -no-gcc"
1855                 AC_TRY_COMPILE([],[
1856 #ifdef __INTEL_COMPILER
1857 #else
1858 make an error
1859 #endif
1860 ],[ifelse($2,,INTEL_COMPILER,[$2])=yes
1861 cf_save_CFLAGS="$cf_save_CFLAGS -we147 -no-gcc"
1862 ],[])
1863                 ifelse($3,,CFLAGS,[$3])="$cf_save_CFLAGS"
1864                 AC_MSG_RESULT($ifelse($2,,INTEL_COMPILER,[$2]))
1865                 ;;
1866         esac
1867 fi
1868 ])dnl
1869 dnl ---------------------------------------------------------------------------
1870 dnl CF_ISASCII version: 3 updated: 2000/08/12 23:18:52
1871 dnl ----------
1872 dnl Check if we have either a function or macro for 'isascii()'.
1873 AC_DEFUN([CF_ISASCII],
1874 [
1875 AC_MSG_CHECKING(for isascii)
1876 AC_CACHE_VAL(cf_cv_have_isascii,[
1877         AC_TRY_LINK([#include <ctype.h>],[int x = isascii(' ')],
1878         [cf_cv_have_isascii=yes],
1879         [cf_cv_have_isascii=no])
1880 ])dnl
1881 AC_MSG_RESULT($cf_cv_have_isascii)
1882 test "$cf_cv_have_isascii" = yes && AC_DEFINE(HAVE_ISASCII)
1883 ])dnl
1884 dnl ---------------------------------------------------------------------------
1885 dnl CF_LARGEFILE version: 7 updated: 2007/06/02 11:58:50
1886 dnl ------------
1887 dnl Add checks for large file support.
1888 AC_DEFUN([CF_LARGEFILE],[
1889 ifdef([AC_FUNC_FSEEKO],[
1890     AC_SYS_LARGEFILE
1891     if test "$enable_largefile" != no ; then
1892         AC_FUNC_FSEEKO
1893
1894         # Normally we would collect these definitions in the config.h,
1895         # but (like _XOPEN_SOURCE), some environments rely on having these
1896         # defined before any of the system headers are included.  Another
1897         # case comes up with C++, e.g., on AIX the compiler compiles the
1898         # header files by themselves before looking at the body files it is
1899         # told to compile.  For ncurses, those header files do not include
1900         # the config.h
1901         test "$ac_cv_sys_large_files"      != no && CPPFLAGS="$CPPFLAGS -D_LARGE_FILES "
1902         test "$ac_cv_sys_largefile_source" != no && CPPFLAGS="$CPPFLAGS -D_LARGEFILE_SOURCE "
1903         test "$ac_cv_sys_file_offset_bits" != no && CPPFLAGS="$CPPFLAGS -D_FILE_OFFSET_BITS=$ac_cv_sys_file_offset_bits "
1904
1905         AC_CACHE_CHECK(whether to use struct dirent64, cf_cv_struct_dirent64,[
1906                 AC_TRY_COMPILE([
1907 #include <sys/types.h>
1908 #include <dirent.h>
1909                 ],[
1910                 /* if transitional largefile support is setup, this is true */
1911                 extern struct dirent64 * readdir(DIR *);
1912                 struct dirent64 *x = readdir((DIR *)0);
1913                 struct dirent *y = readdir((DIR *)0);
1914                 int z = x - y;
1915                 ],
1916                 [cf_cv_struct_dirent64=yes],
1917                 [cf_cv_struct_dirent64=no])
1918         ])
1919         test "$cf_cv_struct_dirent64" = yes && AC_DEFINE(HAVE_STRUCT_DIRENT64)
1920     fi
1921 ])
1922 ])
1923 dnl ---------------------------------------------------------------------------
1924 dnl CF_LDFLAGS_STATIC version: 2 updated: 2007/04/28 15:25:27
1925 dnl -----------------
1926 dnl Check for compiler/linker flags used to temporarily force usage of static
1927 dnl libraries.  This depends on the compiler and platform.  Use this to help
1928 dnl ensure that the linker picks up a given library based on its position in
1929 dnl the list of linker options and libraries.
1930 AC_DEFUN([CF_LDFLAGS_STATIC],[
1931
1932 if test "$GCC" = yes ; then
1933         LDFLAGS_STATIC=-static
1934         LDFLAGS_SHARED=-dynamic
1935 else
1936         case $cf_cv_system_name in #(
1937         aix[[45]]*)     #( from ld manpage
1938                 LDFLAGS_STATIC=-bstatic
1939                 LDFLAGS_SHARED=-bdynamic
1940                 ;;
1941         hpux*)          #( from ld manpage for hpux10.20, hpux11.11
1942                 # We could also use just "archive" and "shared".
1943                 LDFLAGS_STATIC=-Wl,-a,archive_shared
1944                 LDFLAGS_SHARED=-Wl,-a,shared_archive
1945                 ;;
1946         irix*)          #( from ld manpage IRIX64
1947                 LDFLAGS_STATIC=-Bstatic
1948                 LDFLAGS_SHARED=-Bdynamic
1949                 ;;
1950         osf[[45]]*)     #( from ld manpage osf4.0d, osf5.1
1951                 # alternative "-oldstyle_liblookup" (not in cc manpage)
1952                 LDFLAGS_STATIC=-noso
1953                 LDFLAGS_SHARED=-so_archive
1954                 ;;
1955         solaris2*)
1956                 LDFLAGS_STATIC=-Bstatic
1957                 LDFLAGS_SHARED=-Bdynamic
1958                 ;;
1959         esac
1960 fi
1961
1962 AC_SUBST(LDFLAGS_STATIC)
1963 AC_SUBST(LDFLAGS_SHARED)
1964 ])
1965 dnl ---------------------------------------------------------------------------
1966 dnl CF_LIBUTF8 version: 2 updated: 2002/01/19 22:51:32
1967 dnl ----------
1968 dnl Check for libutf8
1969 AC_DEFUN([CF_LIBUTF8],
1970 [
1971 AC_CACHE_CHECK(for putwc in libutf8,cf_cv_libutf8,[
1972         cf_save_LIBS="$LIBS"
1973         LIBS="-lutf8 $LIBS"
1974 AC_TRY_LINK([
1975 #include <libutf8.h>],[putwc(0,0);],
1976         [cf_cv_libutf8=yes],
1977         [cf_cv_libutf8=no])
1978         LIBS="$cf_save_LIBS"
1979 ])
1980
1981 if test "$cf_cv_libutf8" = yes ; then
1982         AC_DEFINE(HAVE_LIBUTF8_H)
1983         LIBS="-lutf8 $LIBS"
1984 fi
1985 ])dnl
1986 dnl ---------------------------------------------------------------------------
1987 dnl CF_LIB_PREFIX version: 7 updated: 2001/01/12 01:23:48
1988 dnl -------------
1989 dnl Compute the library-prefix for the given host system
1990 dnl $1 = variable to set
1991 AC_DEFUN([CF_LIB_PREFIX],
1992 [
1993         case $cf_cv_system_name in
1994         OS/2*)  LIB_PREFIX=''     ;;
1995         os2*)   LIB_PREFIX=''     ;;
1996         *)      LIB_PREFIX='lib'  ;;
1997         esac
1998 ifelse($1,,,[$1=$LIB_PREFIX])
1999         AC_SUBST(LIB_PREFIX)
2000 ])dnl
2001 dnl ---------------------------------------------------------------------------
2002 dnl CF_LIB_RULES version: 50 updated: 2007/03/24 18:26:59
2003 dnl ------------
2004 dnl Append definitions and rules for the given models to the subdirectory
2005 dnl Makefiles, and the recursion rule for the top-level Makefile.  If the
2006 dnl subdirectory is a library-source directory, modify the LIBS_TO_MAKE list in
2007 dnl the corresponding makefile to list the models that we'll generate.
2008 dnl
2009 dnl For shared libraries, make a list of symbolic links to construct when
2010 dnl generating each library.  The convention used for Linux is the simplest
2011 dnl one:
2012 dnl     lib<name>.so    ->
2013 dnl     lib<name>.so.<major>    ->
2014 dnl     lib<name>.so.<maj>.<minor>
2015 AC_DEFUN([CF_LIB_RULES],
2016 [
2017 CF_LIB_PREFIX(cf_prefix)
2018 AC_REQUIRE([CF_SUBST_NCURSES_VERSION])
2019 for cf_dir in $SRC_SUBDIRS
2020 do
2021         if test ! -d $srcdir/$cf_dir ; then
2022                 continue
2023         elif test -f $srcdir/$cf_dir/modules; then
2024
2025                 SHARED_LIB=
2026                 LIBS_TO_MAKE=
2027                 for cf_item in $cf_LIST_MODELS
2028                 do
2029                         CF_LIB_SUFFIX($cf_item,cf_suffix)
2030                         if test $cf_item = shared ; then
2031                         if test "$cf_cv_do_symlinks" = yes ; then
2032                                 case "$cf_cv_shlib_version" in #(vi
2033                                 rel) #(vi
2034                                         case "$cf_cv_system_name" in #(vi
2035                                         darwin*)
2036                                         case .${LIB_SUFFIX} in
2037                                         .w*)
2038                                                 cf_suffix=`echo $cf_suffix | sed 's/^w//'`
2039                                                 cf_suffix=w'.${REL_VERSION}'"$cf_suffix"
2040                                                 ;;
2041                                         *)
2042                                                 cf_suffix='.${REL_VERSION}'"$cf_suffix"
2043                                                 ;;
2044                                         esac
2045                                         ;; #(vi
2046                                         *) cf_suffix="$cf_suffix"'.${REL_VERSION}' ;;
2047                                         esac
2048                                         ;;
2049                                 abi)
2050                                         case "$cf_cv_system_name" in #(vi
2051                                         darwin*)
2052                                         case .${LIB_SUFFIX} in
2053                                         .w*)
2054                                                 cf_suffix=`echo $cf_suffix | sed 's/^w//'`
2055                                                 cf_suffix=w'.${ABI_VERSION}'"$cf_suffix"
2056                                                 ;;
2057                                         *)
2058                                                 cf_suffix='.${ABI_VERSION}'"$cf_suffix"
2059                                                 ;;
2060                                         esac
2061                                         ;; #(vi
2062                                         *) cf_suffix="$cf_suffix"'.${ABI_VERSION}' ;;
2063                                         esac
2064                                         ;;
2065                                 esac
2066                         fi
2067                         # cygwin needs import library, and has unique naming convention
2068                         # use autodetected ${cf_prefix} for import lib and static lib, but
2069                         # use 'cyg' prefix for shared lib.
2070                         if test $cf_cv_shlib_version = cygdll ; then
2071                                 LIBS_TO_MAKE="$LIBS_TO_MAKE ../lib/cyg${cf_dir}\${ABI_VERSION}.dll"
2072                                 continue
2073                         fi
2074                         fi
2075                         LIBS_TO_MAKE="$LIBS_TO_MAKE ../lib/${cf_prefix}${cf_dir}${cf_suffix}"
2076                 done
2077
2078                 if test $cf_dir = ncurses ; then
2079                         cf_subsets="$LIB_SUBSETS"
2080                         cf_r_parts="$cf_subsets"
2081
2082                         while test -n "$cf_r_parts"
2083                         do
2084                                 cf_l_parts=`echo "$cf_r_parts" |sed -e 's/ .*$//'`
2085                                 cf_r_parts=`echo "$cf_r_parts" |sed -e 's/^[[^ ]]* //'`
2086                                 if test "$cf_l_parts" != "$cf_r_parts" ; then
2087                                         case $cf_l_parts in #(vi
2088                                         *termlib*) #(vi
2089                                                 cf_item=`echo $LIBS_TO_MAKE |sed -e s%${LIB_NAME}${LIB_SUFFIX}%${TINFO_LIB_SUFFIX}%g`
2090                                                 ;;
2091                                         *ticlib*)
2092                                                 cf_item=`echo $LIBS_TO_MAKE |sed -e s%${LIB_NAME}${LIB_SUFFIX}%${TICS_LIB_SUFFIX}%g`
2093                                                 ;;
2094                                         *)
2095                                                 break
2096                                                 ;;
2097                                         esac
2098                                         LIBS_TO_MAKE="$cf_item $LIBS_TO_MAKE"
2099                                 else
2100                                         break
2101                                 fi
2102                         done
2103                 else
2104                         cf_subsets=`echo "$LIB_SUBSETS" | sed -e 's/^termlib.* //'`
2105                 fi
2106
2107                 sed -e "s%@LIBS_TO_MAKE@%$LIBS_TO_MAKE%" \
2108                     -e "s%@SHARED_LIB@%$SHARED_LIB%" \
2109                         $cf_dir/Makefile >$cf_dir/Makefile.out
2110                 mv $cf_dir/Makefile.out $cf_dir/Makefile
2111
2112                 $AWK -f $srcdir/mk-0th.awk \
2113                         libname="${cf_dir}${LIB_SUFFIX}" subsets="$LIB_SUBSETS" \
2114                         $srcdir/$cf_dir/modules >>$cf_dir/Makefile
2115
2116                 for cf_subset in $cf_subsets
2117                 do
2118                         cf_subdirs=
2119                         for cf_item in $cf_LIST_MODELS
2120                         do
2121                         echo "Appending rules for ${cf_item} model (${cf_dir}: ${cf_subset})"
2122                         CF_UPPER(cf_ITEM,$cf_item)
2123                         CF_LIB_SUFFIX($cf_item,cf_suffix)
2124                         CF_OBJ_SUBDIR($cf_item,cf_subdir)
2125
2126                         # Test for case where we build libtinfo with a different name.
2127                         cf_libname=$cf_dir
2128                         if test $cf_dir = ncurses ; then
2129                                 case $cf_subset in
2130                                 *base*)
2131                                         ;;
2132                                 *termlib*)
2133                                         cf_libname=$TINFO_LIB_SUFFIX
2134                                         if test -n "${DFT_ARG_SUFFIX}" ; then
2135                                                 # undo $LIB_SUFFIX add-on in CF_LIB_SUFFIX
2136                                                 cf_suffix=`echo $cf_suffix |sed -e "s%^${LIB_SUFFIX}%%"`
2137                                         fi
2138                                         ;;
2139                                 ticlib*)
2140                                         cf_libname=$TICS_LIB_SUFFIX
2141                                         if test -n "${DFT_ARG_SUFFIX}" ; then
2142                                                 # undo $LIB_SUFFIX add-on in CF_LIB_SUFFIX
2143                                                 cf_suffix=`echo $cf_suffix |sed -e "s%^${LIB_SUFFIX}%%"`
2144                                         fi
2145                                         ;;
2146                                 esac
2147                         fi
2148
2149                         # These dependencies really are for development, not
2150                         # builds, but they are useful in porting, too.
2151                         cf_depend="../include/ncurses_cfg.h"
2152                         if test "$srcdir" = "."; then
2153                                 cf_reldir="."
2154                         else
2155                                 cf_reldir="\${srcdir}"
2156                         fi
2157
2158                         if test -f $srcdir/$cf_dir/$cf_dir.priv.h; then
2159                                 cf_depend="$cf_depend $cf_reldir/$cf_dir.priv.h"
2160                         elif test -f $srcdir/$cf_dir/curses.priv.h; then
2161                                 cf_depend="$cf_depend $cf_reldir/curses.priv.h"
2162                         fi
2163
2164                         cf_dir_suffix=
2165                         old_cf_suffix="$cf_suffix"
2166                         if test "$cf_cv_shlib_version_infix" = yes ; then
2167                         if test -n "$LIB_SUFFIX" ; then
2168                                 case $LIB_SUFFIX in
2169                                 w*)
2170                                         cf_libname=`echo $cf_libname | sed 's/w$//'`
2171                                         cf_suffix=`echo $cf_suffix | sed 's/^w//'`
2172                                         cf_dir_suffix=w
2173                                         ;;
2174                                 esac
2175                         fi
2176                         fi
2177
2178                         $AWK -f $srcdir/mk-1st.awk \
2179                                 name=${cf_libname}${cf_dir_suffix} \
2180                                 traces=$LIB_TRACING \
2181                                 MODEL=$cf_ITEM \
2182                                 model=$cf_subdir \
2183                                 prefix=$cf_prefix \
2184                                 suffix=$cf_suffix \
2185                                 subset=$cf_subset \
2186                                 TermlibRoot=$TINFO_NAME \
2187                                 TermlibSuffix=$TINFO_SUFFIX \
2188                                 ShlibVer=$cf_cv_shlib_version \
2189                                 ShlibVerInfix=$cf_cv_shlib_version_infix \
2190                                 ReLink=${cf_cv_do_relink-no} \
2191                                 DoLinks=$cf_cv_do_symlinks \
2192                                 rmSoLocs=$cf_cv_rm_so_locs \
2193                                 ldconfig="$LDCONFIG" \
2194                                 overwrite=$WITH_OVERWRITE \
2195                                 depend="$cf_depend" \
2196                                 host="$host" \
2197                                 $srcdir/$cf_dir/modules >>$cf_dir/Makefile
2198
2199                         cf_suffix="$old_cf_suffix"
2200
2201                         for cf_subdir2 in $cf_subdirs lib
2202                         do
2203                                 test $cf_subdir = $cf_subdir2 && break
2204                         done
2205                         test "${cf_subset}.${cf_subdir2}" != "${cf_subset}.${cf_subdir}" && \
2206                         $AWK -f $srcdir/mk-2nd.awk \
2207                                 name=$cf_dir \
2208                                 traces=$LIB_TRACING \
2209                                 MODEL=$cf_ITEM \
2210                                 model=$cf_subdir \
2211                                 subset=$cf_subset \
2212                                 srcdir=$srcdir \
2213                                 echo=$WITH_ECHO \
2214                                 crenames=$cf_cv_prog_CC_c_o \
2215                                 cxxrenames=$cf_cv_prog_CXX_c_o \
2216                                 $srcdir/$cf_dir/modules >>$cf_dir/Makefile
2217                         cf_subdirs="$cf_subdirs $cf_subdir"
2218                         done
2219                 done
2220         fi
2221
2222         echo '  cd '$cf_dir' && ${MAKE} ${CF_MFLAGS} [$]@' >>Makefile
2223 done
2224
2225 for cf_dir in $SRC_SUBDIRS
2226 do
2227         if test ! -d $srcdir/$cf_dir ; then
2228                 continue
2229         fi
2230
2231         if test -f $cf_dir/Makefile ; then
2232                 case "$cf_dir" in
2233                 Ada95) #(vi
2234                         echo 'libs \' >> Makefile
2235                         echo 'install.libs \' >> Makefile
2236                         echo 'uninstall.libs ::' >> Makefile
2237                         echo '  cd '$cf_dir' && ${MAKE} ${CF_MFLAGS} [$]@' >> Makefile
2238                         ;;
2239                 esac
2240         fi
2241
2242         if test -f $srcdir/$cf_dir/modules; then
2243                 echo >> Makefile
2244                 if test -f $srcdir/$cf_dir/headers; then
2245 cat >> Makefile <<CF_EOF
2246 install.includes \\
2247 uninstall.includes \\
2248 CF_EOF
2249                 fi
2250 if test "$cf_dir" != "c++" ; then
2251 echo 'lint \' >> Makefile
2252 fi
2253 cat >> Makefile <<CF_EOF
2254 libs \\
2255 lintlib \\
2256 install.libs \\
2257 uninstall.libs \\
2258 install.$cf_dir \\
2259 uninstall.$cf_dir ::
2260         cd $cf_dir && \${MAKE} \${CF_MFLAGS} \[$]@
2261 CF_EOF
2262         elif test -f $srcdir/$cf_dir/headers; then
2263 cat >> Makefile <<CF_EOF
2264
2265 libs \\
2266 install.libs \\
2267 uninstall.libs \\
2268 install.includes \\
2269 uninstall.includes ::
2270         cd $cf_dir && \${MAKE} \${CF_MFLAGS} \[$]@
2271 CF_EOF
2272 fi
2273 done
2274
2275 cat >> Makefile <<CF_EOF
2276
2277 install.libs uninstall.libs \\
2278 install.data uninstall.data ::
2279 $MAKE_TERMINFO  cd misc && \${MAKE} \${CF_MFLAGS} \[$]@
2280
2281 install.man \\
2282 uninstall.man ::
2283         cd man && \${MAKE} \${CF_MFLAGS} \[$]@
2284
2285 distclean ::
2286         rm -f config.cache config.log config.status Makefile include/ncurses_cfg.h
2287         rm -f headers.sh headers.sed mk_shared_lib.sh
2288         rm -rf \${DIRS_TO_MAKE}
2289 CF_EOF
2290
2291 # Special case: tack's manpage lives in its own directory.
2292 if test -d tack ; then
2293 if test -f $srcdir/$tack.h; then
2294 cat >> Makefile <<CF_EOF
2295
2296 install.man \\
2297 uninstall.man ::
2298         cd tack && \${MAKE} \${CF_MFLAGS} \[$]@
2299 CF_EOF
2300 fi
2301 fi
2302
2303 dnl If we're installing into a subdirectory of /usr/include, etc., we should
2304 dnl prepend the subdirectory's name to the "#include" paths.  It won't hurt
2305 dnl anything, and will make it more standardized.  It's awkward to decide this
2306 dnl at configuration because of quoting, so we'll simply make all headers
2307 dnl installed via a script that can do the right thing.
2308
2309 rm -f headers.sed headers.sh
2310
2311 dnl ( generating this script makes the makefiles a little tidier :-)
2312 echo creating headers.sh
2313 cat >headers.sh <<CF_EOF
2314 #! /bin/sh
2315 # This shell script is generated by the 'configure' script.  It is invoked in a
2316 # subdirectory of the build tree.  It generates a sed-script in the parent
2317 # directory that is used to adjust includes for header files that reside in a
2318 # subdirectory of /usr/include, etc.
2319 PRG=""
2320 while test \[$]# != 3
2321 do
2322 PRG="\$PRG \[$]1"; shift
2323 done
2324 DST=\[$]1
2325 REF=\[$]2
2326 SRC=\[$]3
2327 TMPSRC=\${TMPDIR-/tmp}/\`basename \$SRC\`\$\$
2328 TMPSED=\${TMPDIR-/tmp}/headers.sed\$\$
2329 echo installing \$SRC in \$DST
2330 CF_EOF
2331
2332 if test $WITH_CURSES_H = yes; then
2333         cat >>headers.sh <<CF_EOF
2334 case \$DST in
2335 /*/include/*)
2336         END=\`basename \$DST\`
2337         for i in \`cat \$REF/../*/headers |fgrep -v "#"\`
2338         do
2339                 NAME=\`basename \$i\`
2340                 echo "s/<\$NAME>/<\$END\/\$NAME>/" >> \$TMPSED
2341         done
2342         ;;
2343 *)
2344         echo "" >> \$TMPSED
2345         ;;
2346 esac
2347 CF_EOF
2348
2349 else
2350         cat >>headers.sh <<CF_EOF
2351 case \$DST in
2352 /*/include/*)
2353         END=\`basename \$DST\`
2354         for i in \`cat \$REF/../*/headers |fgrep -v "#"\`
2355         do
2356                 NAME=\`basename \$i\`
2357                 if test "\$NAME" = "curses.h"
2358                 then
2359                         echo "s/<curses.h>/<ncurses.h>/" >> \$TMPSED
2360                         NAME=ncurses.h
2361                 fi
2362                 echo "s/<\$NAME>/<\$END\/\$NAME>/" >> \$TMPSED
2363         done
2364         ;;
2365 *)
2366         echo "s/<curses.h>/<ncurses.h>/" >> \$TMPSED
2367         ;;
2368 esac
2369 CF_EOF
2370 fi
2371 cat >>headers.sh <<CF_EOF
2372 rm -f \$TMPSRC
2373 sed -f \$TMPSED \$SRC > \$TMPSRC
2374 NAME=\`basename \$SRC\`
2375 CF_EOF
2376 if test $WITH_CURSES_H != yes; then
2377         cat >>headers.sh <<CF_EOF
2378 test "\$NAME" = "curses.h" && NAME=ncurses.h
2379 CF_EOF
2380 fi
2381 cat >>headers.sh <<CF_EOF
2382 # Just in case someone gzip'd manpages, remove the conflicting copy.
2383 test -f \$DST/\$NAME.gz && rm -f \$DST/\$NAME.gz
2384
2385 eval \$PRG \$TMPSRC \$DST/\$NAME
2386 rm -f \$TMPSRC \$TMPSED
2387 CF_EOF
2388
2389 chmod 0755 headers.sh
2390
2391 for cf_dir in $SRC_SUBDIRS
2392 do
2393         if test ! -d $srcdir/$cf_dir ; then
2394                 continue
2395         fi
2396
2397         if test -f $srcdir/$cf_dir/headers; then
2398                 $AWK -f $srcdir/mk-hdr.awk \
2399                         subset="$LIB_SUBSETS" \
2400                         compat="$WITH_CURSES_H" \
2401                         $srcdir/$cf_dir/headers >>$cf_dir/Makefile
2402         fi
2403
2404         if test -f $srcdir/$cf_dir/modules; then
2405                 if test "$cf_dir" != "c++" ; then
2406                         cat >>$cf_dir/Makefile <<"CF_EOF"
2407 depend : ${AUTO_SRC}
2408         makedepend -- ${CPPFLAGS} -- ${C_SRC}
2409
2410 # DO NOT DELETE THIS LINE -- make depend depends on it.
2411 CF_EOF
2412                 fi
2413         fi
2414 done
2415
2416 ])dnl
2417 dnl ---------------------------------------------------------------------------
2418 dnl CF_LIB_SONAME version: 3 updated: 2006/12/16 15:55:46
2419 dnl -------------
2420 dnl Find the and soname for the given shared library.  Set the cache variable
2421 dnl cf_cv_$3_soname to this, unless it is not found.  Then set the cache
2422 dnl variable to "unknown".
2423 dnl
2424 dnl $1 = headers
2425 dnl $2 = code
2426 dnl $3 = library name
2427 AC_DEFUN([CF_LIB_SONAME],
2428 [
2429 AC_CACHE_CHECK(for soname of $3 library,cf_cv_$3_soname,[
2430
2431 cf_cv_$3_soname=unknown
2432 if test "$cross_compiling" != yes ; then
2433 cat >conftest.$ac_ext <<CF_EOF
2434 $1
2435 int main()
2436 {
2437 $2
2438         ${cf_cv_main_return:-return}(0);
2439 }
2440 CF_EOF
2441 cf_save_LIBS="$LIBS"
2442         LIBS="-l$3 $LIBS"
2443         if AC_TRY_EVAL(ac_compile) ; then
2444                 if AC_TRY_EVAL(ac_link) ; then
2445                         cf_cv_$3_soname=`ldd conftest$ac_exeext 2>/dev/null | sed -e 's,^.*/,,' -e 's, .*$,,' | fgrep lib$3.`
2446                         test -z "$cf_cv_$3_soname" && cf_cv_$3_soname=unknown
2447                 fi
2448         fi
2449 rm -f conftest*
2450 LIBS="$cf_save_LIBS"
2451 fi
2452 ])
2453 ])
2454 dnl ---------------------------------------------------------------------------
2455 dnl CF_LIB_SUFFIX version: 13 updated: 2003/11/01 16:09:07
2456 dnl -------------
2457 dnl Compute the library file-suffix from the given model name
2458 dnl $1 = model name
2459 dnl $2 = variable to set
2460 dnl The variable $LIB_SUFFIX, if set, prepends the variable to set.
2461 AC_DEFUN([CF_LIB_SUFFIX],
2462 [
2463         AC_REQUIRE([CF_SUBST_NCURSES_VERSION])
2464         case $1 in
2465         libtool) $2='.la'  ;;
2466         normal)  $2='.a'   ;;
2467         debug)   $2='_g.a' ;;
2468         profile) $2='_p.a' ;;
2469         shared)
2470                 case $cf_cv_system_name in
2471                 cygwin*) $2='.dll' ;;
2472                 darwin*) $2='.dylib' ;;
2473                 hpux*)
2474                         case $target in
2475                         ia64*)  $2='.so' ;;
2476                         *)      $2='.sl' ;;
2477                         esac
2478                         ;;
2479                 *)      $2='.so'  ;;
2480                 esac
2481         esac
2482         test -n "$LIB_SUFFIX" && $2="${LIB_SUFFIX}[$]{$2}"
2483 ])dnl
2484 dnl ---------------------------------------------------------------------------
2485 dnl CF_LIB_TYPE version: 4 updated: 2000/10/20 22:57:49
2486 dnl -----------
2487 dnl Compute the string to append to -library from the given model name
2488 dnl $1 = model name
2489 dnl $2 = variable to set
2490 dnl The variable $LIB_SUFFIX, if set, prepends the variable to set.
2491 AC_DEFUN([CF_LIB_TYPE],
2492 [
2493         case $1 in
2494         libtool) $2=''   ;;
2495         normal)  $2=''   ;;
2496         debug)   $2='_g' ;;
2497         profile) $2='_p' ;;
2498         shared)  $2=''   ;;
2499         esac
2500         test -n "$LIB_SUFFIX" && $2="${LIB_SUFFIX}[$]{$2}"
2501 ])dnl
2502 dnl ---------------------------------------------------------------------------
2503 dnl CF_LINK_DATAONLY version: 8 updated: 2006/12/16 12:33:30
2504 dnl ----------------
2505 dnl Some systems have a non-ANSI linker that doesn't pull in modules that have
2506 dnl only data (i.e., no functions), for example NeXT.  On those systems we'll
2507 dnl have to provide wrappers for global tables to ensure they're linked
2508 dnl properly.
2509 AC_DEFUN([CF_LINK_DATAONLY],
2510 [
2511 AC_MSG_CHECKING([if data-only library module links])
2512 AC_CACHE_VAL(cf_cv_link_dataonly,[
2513         rm -f conftest.a
2514         cat >conftest.$ac_ext <<EOF
2515 #line __oline__ "configure"
2516 int     testdata[[3]] = { 123, 456, 789 };
2517 EOF
2518         if AC_TRY_EVAL(ac_compile) ; then
2519                 mv conftest.o data.o && \
2520                 ( $AR $AR_OPTS conftest.a data.o ) 2>&AC_FD_CC 1>/dev/null
2521         fi
2522         rm -f conftest.$ac_ext data.o
2523         cat >conftest.$ac_ext <<EOF
2524 #line __oline__ "configure"
2525 int     testfunc()
2526 {
2527 #if defined(NeXT)
2528         ${cf_cv_main_return:-return}(1);        /* I'm told this linker is broken */
2529 #else
2530         extern int testdata[[3]];
2531         return testdata[[0]] == 123
2532            &&  testdata[[1]] == 456
2533            &&  testdata[[2]] == 789;
2534 #endif
2535 }
2536 EOF
2537         if AC_TRY_EVAL(ac_compile); then
2538                 mv conftest.o func.o && \
2539                 ( $AR $AR_OPTS conftest.a func.o ) 2>&AC_FD_CC 1>/dev/null
2540         fi
2541         rm -f conftest.$ac_ext func.o
2542         ( eval $RANLIB conftest.a ) 2>&AC_FD_CC >/dev/null
2543         cf_saveLIBS="$LIBS"
2544         LIBS="conftest.a $LIBS"
2545         AC_TRY_RUN([
2546         int main()
2547         {
2548                 extern int testfunc();
2549                 ${cf_cv_main_return:-return} (!testfunc());
2550         }
2551         ],
2552         [cf_cv_link_dataonly=yes],
2553         [cf_cv_link_dataonly=no],
2554         [cf_cv_link_dataonly=unknown])
2555         LIBS="$cf_saveLIBS"
2556         ])
2557 AC_MSG_RESULT($cf_cv_link_dataonly)
2558
2559 if test "$cf_cv_link_dataonly" = no ; then
2560         AC_DEFINE(BROKEN_LINKER)
2561         BROKEN_LINKER=1
2562 fi
2563
2564 ])dnl
2565 dnl ---------------------------------------------------------------------------
2566 dnl CF_LINK_FUNCS version: 7 updated: 2006/12/16 12:33:30
2567 dnl -------------
2568 dnl Most Unix systems have both link and symlink, a few don't have symlink.
2569 dnl A few non-Unix systems implement symlink, but not link.
2570 dnl A few non-systems implement neither (or have nonfunctional versions).
2571 AC_DEFUN([CF_LINK_FUNCS],
2572 [
2573 AC_CHECK_FUNCS( \
2574         remove \
2575         unlink )
2576
2577 if test "$cross_compiling" = yes ; then
2578         AC_CHECK_FUNCS( \
2579                 link \
2580                 symlink )
2581 else
2582         AC_CACHE_CHECK(if link/symlink functions work,cf_cv_link_funcs,[
2583                 cf_cv_link_funcs=
2584                 for cf_func in link symlink ; do
2585                         AC_TRY_RUN([
2586 #include <sys/types.h>
2587 #include <sys/stat.h>
2588 #ifdef HAVE_UNISTD_H
2589 #include <unistd.h>
2590 #endif
2591 int main()
2592 {
2593         int fail = 0;
2594         char *src = "config.log";
2595         char *dst = "conftest.chk";
2596         struct stat src_sb;
2597         struct stat dst_sb;
2598
2599         stat(src, &src_sb);
2600         fail = ($cf_func("config.log", "conftest.chk") < 0)
2601             || (stat(dst, &dst_sb) < 0)
2602             || (dst_sb.st_mtime != src_sb.st_mtime);
2603 #ifdef HAVE_UNLINK
2604         unlink(dst);
2605 #else
2606         remove(dst);
2607 #endif
2608         ${cf_cv_main_return:-return} (fail);
2609 }
2610                         ],[
2611                         cf_cv_link_funcs="$cf_cv_link_funcs $cf_func"
2612                         eval 'ac_cv_func_'$cf_func'=yes'],[
2613                         eval 'ac_cv_func_'$cf_func'=no'],[
2614                         eval 'ac_cv_func_'$cf_func'=error'])
2615                 done
2616                 test -z "$cf_cv_link_funcs" && cf_cv_link_funcs=no
2617         ])
2618         test "$ac_cv_func_link"    = yes && AC_DEFINE(HAVE_LINK)
2619         test "$ac_cv_func_symlink" = yes && AC_DEFINE(HAVE_SYMLINK)
2620 fi
2621 ])dnl
2622 dnl ---------------------------------------------------------------------------
2623 dnl CF_MAIN_RETURN version: 1 updated: 2006/12/10 09:51:54
2624 dnl --------------
2625 dnl Check if a return from main to the shell actually returns the same exit
2626 dnl code.  This is true for almost any POSIX environment.
2627 dnl
2628 dnl Some very old environments did not flush stdout, etc., on an exit.  That
2629 dnl would be a useful case to test for also.
2630 AC_DEFUN([CF_MAIN_RETURN],
2631 [
2632 cf_cv_main_return=return
2633 ])dnl
2634 dnl ---------------------------------------------------------------------------
2635 dnl CF_MAKEFLAGS version: 12 updated: 2006/10/21 08:27:03
2636 dnl ------------
2637 dnl Some 'make' programs support ${MAKEFLAGS}, some ${MFLAGS}, to pass 'make'
2638 dnl options to lower-levels.  It's very useful for "make -n" -- if we have it.
2639 dnl (GNU 'make' does both, something POSIX 'make', which happens to make the
2640 dnl ${MAKEFLAGS} variable incompatible because it adds the assignments :-)
2641 AC_DEFUN([CF_MAKEFLAGS],
2642 [
2643 AC_CACHE_CHECK(for makeflags variable, cf_cv_makeflags,[
2644         cf_cv_makeflags=''
2645         for cf_option in '-${MAKEFLAGS}' '${MFLAGS}'
2646         do
2647                 cat >cf_makeflags.tmp <<CF_EOF
2648 SHELL = /bin/sh
2649 all :
2650         @ echo '.$cf_option'
2651 CF_EOF
2652                 cf_result=`${MAKE-make} -k -f cf_makeflags.tmp 2>/dev/null | sed -e 's,[[       ]]*$,,'`
2653                 case "$cf_result" in
2654                 .*k)
2655                         cf_result=`${MAKE-make} -k -f cf_makeflags.tmp CC=cc 2>/dev/null`
2656                         case "$cf_result" in
2657                         .*CC=*) cf_cv_makeflags=
2658                                 ;;
2659                         *)      cf_cv_makeflags=$cf_option
2660                                 ;;
2661                         esac
2662                         break
2663                         ;;
2664                 .-)     ;;
2665                 *)      echo "given option \"$cf_option\", no match \"$cf_result\""
2666                         ;;
2667                 esac
2668         done
2669         rm -f cf_makeflags.tmp
2670 ])
2671
2672 AC_SUBST(cf_cv_makeflags)
2673 ])dnl
2674 dnl ---------------------------------------------------------------------------
2675 dnl CF_MAKE_TAGS version: 2 updated: 2000/10/04 09:18:40
2676 dnl ------------
2677 dnl Generate tags/TAGS targets for makefiles.  Do not generate TAGS if we have
2678 dnl a monocase filesystem.
2679 AC_DEFUN([CF_MAKE_TAGS],[
2680 AC_REQUIRE([CF_MIXEDCASE_FILENAMES])
2681 AC_CHECK_PROG(MAKE_LOWER_TAGS, ctags, yes, no)
2682
2683 if test "$cf_cv_mixedcase" = yes ; then
2684         AC_CHECK_PROG(MAKE_UPPER_TAGS, etags, yes, no)
2685 else
2686         MAKE_UPPER_TAGS=no
2687 fi
2688
2689 if test "$MAKE_UPPER_TAGS" = yes ; then
2690         MAKE_UPPER_TAGS=
2691 else
2692         MAKE_UPPER_TAGS="#"
2693 fi
2694 AC_SUBST(MAKE_UPPER_TAGS)
2695
2696 if test "$MAKE_LOWER_TAGS" = yes ; then
2697         MAKE_LOWER_TAGS=
2698 else
2699         MAKE_LOWER_TAGS="#"
2700 fi
2701 AC_SUBST(MAKE_LOWER_TAGS)
2702 ])dnl
2703 dnl ---------------------------------------------------------------------------
2704 dnl CF_MANPAGE_FORMAT version: 7 updated: 2003/12/20 19:30:34
2705 dnl -----------------
2706 dnl Option to allow user to override automatic configuration of manpage format.
2707 dnl There are several special cases:
2708 dnl
2709 dnl     gzip - man checks for, can display gzip'd files
2710 dnl     compress - man checks for, can display compressed files
2711 dnl     BSDI - files in the cat-directories are suffixed ".0"
2712 dnl     formatted - installer should format (put files in cat-directory)
2713 dnl     catonly - installer should only format, e.g., for a turnkey system.
2714 dnl
2715 dnl There are other configurations which this macro does not test, e.g., HPUX's
2716 dnl compressed manpages (but uncompressed manpages are fine, and HPUX's naming
2717 dnl convention would not match our use).
2718 AC_DEFUN([CF_MANPAGE_FORMAT],
2719 [
2720 AC_REQUIRE([CF_PATHSEP])
2721 AC_MSG_CHECKING(format of man-pages)
2722
2723 AC_ARG_WITH(manpage-format,
2724         [  --with-manpage-format   specify manpage-format: gzip/compress/BSDI/normal and
2725                           optionally formatted/catonly, e.g., gzip,formatted],
2726         [MANPAGE_FORMAT=$withval],
2727         [MANPAGE_FORMAT=unknown])
2728
2729 test -z "$MANPAGE_FORMAT" && MANPAGE_FORMAT=unknown
2730 MANPAGE_FORMAT=`echo "$MANPAGE_FORMAT" | sed -e 's/,/ /g'`
2731
2732 cf_unknown=
2733
2734 case $MANPAGE_FORMAT in
2735 unknown)
2736   if test -z "$MANPATH" ; then
2737     MANPATH="/usr/man:/usr/share/man"
2738   fi
2739
2740   # look for the 'date' man-page (it's most likely to be installed!)
2741   MANPAGE_FORMAT=
2742   cf_preform=no
2743   cf_catonly=yes
2744   cf_example=date
2745
2746   IFS="${IFS=   }"; ac_save_ifs="$IFS"; IFS="${IFS}${PATHSEP}"
2747   for cf_dir in $MANPATH; do
2748     test -z "$cf_dir" && cf_dir=/usr/man
2749     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
2750     do
2751       cf_test=`echo $cf_name | sed -e 's/*//'`
2752       if test "x$cf_test" = "x$cf_name" ; then
2753
2754         case "$cf_name" in
2755         *.gz) MANPAGE_FORMAT="$MANPAGE_FORMAT gzip";;
2756         *.Z)  MANPAGE_FORMAT="$MANPAGE_FORMAT compress";;
2757         *.0)    MANPAGE_FORMAT="$MANPAGE_FORMAT BSDI";;
2758         *)    MANPAGE_FORMAT="$MANPAGE_FORMAT normal";;
2759         esac
2760
2761         case "$cf_name" in
2762         $cf_dir/man*)
2763           cf_catonly=no
2764           ;;
2765         $cf_dir/cat*)
2766           cf_preform=yes
2767           ;;
2768         esac
2769         break
2770       fi
2771
2772       # if we found a match in either man* or cat*, stop looking
2773       if test -n "$MANPAGE_FORMAT" ; then
2774         cf_found=no
2775         test "$cf_preform" = yes && MANPAGE_FORMAT="$MANPAGE_FORMAT formatted"
2776         test "$cf_catonly" = yes && MANPAGE_FORMAT="$MANPAGE_FORMAT catonly"
2777         case "$cf_name" in
2778         $cf_dir/cat*)
2779           cf_found=yes
2780           ;;
2781         esac
2782         test $cf_found=yes && break
2783       fi
2784     done
2785     # only check the first directory in $MANPATH where we find manpages
2786     if test -n "$MANPAGE_FORMAT" ; then
2787        break
2788     fi
2789   done
2790   # if we did not find the example, just assume it is normal
2791   test -z "$MANPAGE_FORMAT" && MANPAGE_FORMAT=normal
2792   IFS="$ac_save_ifs"
2793   ;;
2794 *)
2795   for cf_option in $MANPAGE_FORMAT; do
2796      case $cf_option in #(vi
2797      gzip|compress|BSDI|normal|formatted|catonly)
2798        ;;
2799      *)
2800        cf_unknown="$cf_unknown $cf_option"
2801        ;;
2802      esac
2803   done
2804   ;;
2805 esac
2806
2807 AC_MSG_RESULT($MANPAGE_FORMAT)
2808 if test -n "$cf_unknown" ; then
2809   AC_MSG_WARN(Unexpected manpage-format $cf_unknown)
2810 fi
2811 ])dnl
2812 dnl ---------------------------------------------------------------------------
2813 dnl CF_MANPAGE_RENAMES version: 7 updated: 2005/06/18 18:51:57
2814 dnl ------------------
2815 dnl The Debian people have their own naming convention for manpages.  This
2816 dnl option lets us override the name of the file containing renaming, or
2817 dnl disable it altogether.
2818 AC_DEFUN([CF_MANPAGE_RENAMES],
2819 [
2820 AC_MSG_CHECKING(for manpage renaming)
2821
2822 AC_ARG_WITH(manpage-renames,
2823         [  --with-manpage-renames  specify manpage-renaming],
2824         [MANPAGE_RENAMES=$withval],
2825         [MANPAGE_RENAMES=yes])
2826
2827 case ".$MANPAGE_RENAMES" in #(vi
2828 .no) #(vi
2829   ;;
2830 .|.yes)
2831   # Debian 'man' program?
2832   if test -f /etc/debian_version ; then
2833     MANPAGE_RENAMES=`cd $srcdir && pwd`/man/man_db.renames
2834   else
2835     MANPAGE_RENAMES=no
2836   fi
2837   ;;
2838 esac
2839
2840 if test "$MANPAGE_RENAMES" != no ; then
2841   if test -f $srcdir/man/$MANPAGE_RENAMES ; then
2842     MANPAGE_RENAMES=`cd $srcdir/man && pwd`/$MANPAGE_RENAMES
2843   elif test ! -f $MANPAGE_RENAMES ; then
2844     AC_MSG_ERROR(not a filename: $MANPAGE_RENAMES)
2845   fi
2846
2847   test ! -d man && mkdir man
2848
2849   # Construct a sed-script to perform renaming within man-pages
2850   if test -n "$MANPAGE_RENAMES" ; then
2851     test ! -d man && mkdir man
2852     sh $srcdir/man/make_sed.sh $MANPAGE_RENAMES >./edit_man.sed
2853   fi
2854 fi
2855
2856 AC_MSG_RESULT($MANPAGE_RENAMES)
2857 AC_SUBST(MANPAGE_RENAMES)
2858 ])dnl
2859 dnl ---------------------------------------------------------------------------
2860 dnl CF_MANPAGE_SYMLINKS version: 4 updated: 2003/12/13 18:01:58
2861 dnl -------------------
2862 dnl Some people expect each tool to make all aliases for manpages in the
2863 dnl man-directory.  This accommodates the older, less-capable implementations
2864 dnl of 'man', and is optional.
2865 AC_DEFUN([CF_MANPAGE_SYMLINKS],
2866 [
2867 AC_MSG_CHECKING(if manpage aliases will be installed)
2868
2869 AC_ARG_WITH(manpage-aliases,
2870         [  --with-manpage-aliases  specify manpage-aliases using .so],
2871         [MANPAGE_ALIASES=$withval],
2872         [MANPAGE_ALIASES=yes])
2873
2874 AC_MSG_RESULT($MANPAGE_ALIASES)
2875
2876 if test "$LN_S" = "ln -s"; then
2877         cf_use_symlinks=yes
2878 else
2879         cf_use_symlinks=no
2880 fi
2881
2882 MANPAGE_SYMLINKS=no
2883 if test "$MANPAGE_ALIASES" = yes ; then
2884 AC_MSG_CHECKING(if manpage symlinks should be used)
2885
2886 AC_ARG_WITH(manpage-symlinks,
2887         [  --with-manpage-symlinks specify manpage-aliases using symlinks],
2888         [MANPAGE_SYMLINKS=$withval],
2889         [MANPAGE_SYMLINKS=$cf_use_symlinks])
2890
2891 if test "$$cf_use_symlinks" = no; then
2892 if test "$MANPAGE_SYMLINKS" = yes ; then
2893         AC_MSG_WARN(cannot make symlinks, will use .so files)
2894         MANPAGE_SYMLINKS=no
2895 fi
2896 fi
2897
2898 AC_MSG_RESULT($MANPAGE_SYMLINKS)
2899 fi
2900
2901 ])dnl
2902 dnl ---------------------------------------------------------------------------
2903 dnl CF_MANPAGE_TBL version: 3 updated: 2002/01/19 22:51:32
2904 dnl --------------
2905 dnl This option causes manpages to be run through tbl(1) to generate tables
2906 dnl correctly.
2907 AC_DEFUN([CF_MANPAGE_TBL],
2908 [
2909 AC_MSG_CHECKING(for manpage tbl)
2910
2911 AC_ARG_WITH(manpage-tbl,
2912         [  --with-manpage-tbl      specify manpage processing with tbl],
2913         [MANPAGE_TBL=$withval],
2914         [MANPAGE_TBL=no])
2915
2916 AC_MSG_RESULT($MANPAGE_TBL)
2917 ])dnl
2918 dnl ---------------------------------------------------------------------------
2919 dnl CF_MAN_PAGES version: 35 updated: 2007/03/31 11:47:29
2920 dnl ------------
2921 dnl Try to determine if the man-pages on the system are compressed, and if
2922 dnl so, what format is used.  Use this information to construct a script that
2923 dnl will install man-pages.
2924 AC_DEFUN([CF_MAN_PAGES],
2925 [
2926 CF_HELP_MESSAGE(Options to Specify How Manpages are Installed:)
2927 CF_MANPAGE_FORMAT
2928 CF_MANPAGE_RENAMES
2929 CF_MANPAGE_SYMLINKS
2930 CF_MANPAGE_TBL
2931
2932   if test "$prefix" = "NONE" ; then
2933      cf_prefix="$ac_default_prefix"
2934   else
2935      cf_prefix="$prefix"
2936   fi
2937
2938   case "$MANPAGE_FORMAT" in # (vi
2939   *catonly*) # (vi
2940     cf_format=yes
2941     cf_inboth=no
2942     ;;
2943   *formatted*) # (vi
2944     cf_format=yes
2945     cf_inboth=yes
2946     ;;
2947   *)
2948     cf_format=no
2949     cf_inboth=no
2950     ;;
2951   esac
2952
2953 test ! -d man && mkdir man
2954
2955 cf_so_strip=
2956 cf_compress=
2957 case "$MANPAGE_FORMAT" in #(vi
2958 *compress*) #(vi
2959         cf_so_strip="Z"
2960         cf_compress=compress
2961   ;;
2962 *gzip*) #(vi
2963         cf_so_strip="gz"
2964         cf_compress=gzip
2965   ;;
2966 esac
2967
2968 cf_edit_man=./edit_man.sh
2969 cf_man_alias=`pwd`/man_alias.sed
2970
2971 cat >$cf_edit_man <<CF_EOF
2972 #! /bin/sh
2973 # this script is generated by the configure-script CF_MAN_PAGES macro.
2974
2975 prefix="$cf_prefix"
2976 datadir="$datadir"
2977
2978 NCURSES_MAJOR="$NCURSES_MAJOR"
2979 NCURSES_MINOR="$NCURSES_MINOR"
2980 NCURSES_PATCH="$NCURSES_PATCH"
2981
2982 NCURSES_OSPEED="$NCURSES_OSPEED"
2983 TERMINFO="$TERMINFO"
2984
2985 MKDIRS="sh `cd $srcdir && pwd`/mkdirs.sh"
2986
2987 INSTALL="$INSTALL"
2988 INSTALL_DATA="$INSTALL_DATA"
2989
2990 transform="$program_transform_name"
2991
2992 TMP=\${TMPDIR-/tmp}/man\$\$
2993 trap "rm -f \$TMP" 0 1 2 5 15
2994
2995 form=\[$]1
2996 shift || exit 1
2997
2998 verb=\[$]1
2999 shift || exit 1
3000
3001 mandir=\[$]1
3002 shift || exit 1
3003
3004 srcdir=\[$]1
3005 top_srcdir=\[$]srcdir/..
3006 shift || exit 1
3007
3008 if test "\$form" = normal ; then
3009         if test "$cf_format" = yes ; then
3010         if test "$cf_inboth" = no ; then
3011                 sh \[$]0 format \$verb \$mandir \$srcdir \[$]*
3012                 exit $?
3013         fi
3014         fi
3015         cf_subdir=\$mandir/man
3016         cf_tables=$MANPAGE_TBL
3017 else
3018         cf_subdir=\$mandir/cat
3019         cf_tables=yes
3020 fi
3021
3022 # process the list of source-files
3023 for i in \[$]* ; do
3024 case \$i in #(vi
3025 *.orig|*.rej) ;; #(vi
3026 *.[[0-9]]*)
3027         section=\`expr "\$i" : '.*\\.\\([[0-9]]\\)[[xm]]*'\`;
3028         if test \$verb = installing ; then
3029         if test ! -d \$cf_subdir\${section} ; then
3030                 \$MKDIRS \$cf_subdir\$section
3031         fi
3032         fi
3033
3034         # replace variables in man page
3035         if test ! -f $cf_man_alias ; then
3036 cat >>$cf_man_alias <<-CF_EOF2
3037                 s,@DATADIR@,\$datadir,g
3038                 s,@TERMINFO@,\$TERMINFO,g
3039                 s,@NCURSES_MAJOR@,\$NCURSES_MAJOR,g
3040                 s,@NCURSES_MINOR@,\$NCURSES_MINOR,g
3041                 s,@NCURSES_PATCH@,\$NCURSES_PATCH,g
3042                 s,@NCURSES_OSPEED@,\$NCURSES_OSPEED,g
3043 CF_EOF
3044         ifelse($1,,,[
3045         for cf_name in $1
3046         do
3047                 cf_NAME=`echo "$cf_name" | sed y%abcdefghijklmnopqrstuvwxyz./-%ABCDEFGHIJKLMNOPQRSTUVWXYZ___%`
3048                 cf_name=`echo $cf_name|sed "$program_transform_name"`
3049 cat >>$cf_edit_man <<-CF_EOF
3050                 s,@$cf_NAME@,$cf_name,
3051 CF_EOF
3052         done
3053         ])
3054 cat >>$cf_edit_man <<CF_EOF
3055 CF_EOF2
3056                 echo "...made $cf_man_alias"
3057         fi
3058
3059         aliases=
3060         cf_source=\`basename \$i\`
3061         inalias=\$cf_source
3062         test ! -f \$inalias && inalias="\$srcdir/\$inalias"
3063         if test ! -f \$inalias ; then
3064                 echo .. skipped \$cf_source
3065                 continue
3066         fi
3067 CF_EOF
3068
3069 if test "$MANPAGE_ALIASES" != no ; then
3070 cat >>$cf_edit_man <<CF_EOF
3071         aliases=\`sed -f \$top_srcdir/man/manlinks.sed \$inalias |sed -f $cf_man_alias | sort -u\`
3072 CF_EOF
3073 fi
3074
3075 if test "$MANPAGE_RENAMES" = no ; then
3076 cat >>$cf_edit_man <<CF_EOF
3077         # perform program transformations for section 1 man pages
3078         if test \$section = 1 ; then
3079                 cf_target=\$cf_subdir\${section}/\`echo \$cf_source|sed "\${transform}"\`
3080         else
3081                 cf_target=\$cf_subdir\${section}/\$cf_source
3082         fi
3083 CF_EOF
3084 else
3085 cat >>$cf_edit_man <<CF_EOF
3086         cf_target=\`grep "^\$cf_source" $MANPAGE_RENAMES | $AWK '{print \[$]2}'\`
3087         if test -z "\$cf_target" ; then
3088                 echo '? missing rename for '\$cf_source
3089                 cf_target="\$cf_source"
3090         fi
3091         cf_target="\$cf_subdir\${section}/\${cf_target}"
3092
3093 CF_EOF
3094 fi
3095
3096 cat >>$cf_edit_man <<CF_EOF
3097         sed     -f $cf_man_alias \\
3098 CF_EOF
3099
3100 if test -f $MANPAGE_RENAMES ; then
3101 cat >>$cf_edit_man <<CF_EOF
3102                 < \$i | sed -f `pwd`/edit_man.sed >\$TMP
3103 CF_EOF
3104 else
3105 cat >>$cf_edit_man <<CF_EOF
3106                 < \$i >\$TMP
3107 CF_EOF
3108 fi
3109
3110 cat >>$cf_edit_man <<CF_EOF
3111 if test \$cf_tables = yes ; then
3112         tbl \$TMP >\$TMP.out
3113         mv \$TMP.out \$TMP
3114 fi
3115 CF_EOF
3116
3117 if test $with_curses_h != yes ; then
3118 cat >>$cf_edit_man <<CF_EOF
3119         sed -e "/\#[    ]*include/s,curses.h,ncurses.h," < \$TMP >\$TMP.out
3120         mv \$TMP.out \$TMP
3121 CF_EOF
3122 fi
3123
3124 cat >>$cf_edit_man <<CF_EOF
3125         if test \$form = format ; then
3126                 nroff -man \$TMP >\$TMP.out
3127                 mv \$TMP.out \$TMP
3128         fi
3129 CF_EOF
3130
3131 if test -n "$cf_compress" ; then
3132 cat >>$cf_edit_man <<CF_EOF
3133         if test \$verb = installing ; then
3134         if ( $cf_compress -f \$TMP )
3135         then
3136                 mv \$TMP.$cf_so_strip \$TMP
3137         fi
3138         fi
3139         cf_target="\$cf_target.$cf_so_strip"
3140 CF_EOF
3141 fi
3142
3143 case "$MANPAGE_FORMAT" in #(vi
3144 *BSDI*)
3145 cat >>$cf_edit_man <<CF_EOF
3146         if test \$form = format ; then
3147                 # BSDI installs only .0 suffixes in the cat directories
3148                 cf_target="\`echo \$cf_target|sed -e 's/\.[[1-9]]\+[[a-z]]*/.0/'\`"
3149         fi
3150 CF_EOF
3151   ;;
3152 esac
3153
3154 cat >>$cf_edit_man <<CF_EOF
3155         suffix=\`basename \$cf_target | sed -e 's%^[[^.]]*%%'\`
3156         if test \$verb = installing ; then
3157                 echo \$verb \$cf_target
3158                 \$INSTALL_DATA \$TMP \$cf_target
3159                 test -d \$cf_subdir\${section} &&
3160                 test -n "\$aliases" && (
3161                         cd \$cf_subdir\${section} && (
3162                                 cf_source=\`echo \$cf_target |sed -e 's%^.*/\([[^/]][[^/]]*/[[^/]][[^/]]*$\)%\1%'\`
3163                                 test -n "$cf_so_strip" && cf_source=\`echo \$cf_source |sed -e 's%\.$cf_so_strip\$%%'\`
3164                                 cf_target=\`basename \$cf_target\`
3165                                 for cf_alias in \$aliases
3166                                 do
3167                                         if test \$section = 1 ; then
3168                                                 cf_alias=\`echo \$cf_alias|sed "\${transform}"\`
3169                                         fi
3170
3171                                         if test "$MANPAGE_SYMLINKS" = yes ; then
3172                                                 if test -f \$cf_alias\${suffix} ; then
3173                                                         if ( cmp -s \$cf_target \$cf_alias\${suffix} )
3174                                                         then
3175                                                                 continue
3176                                                         fi
3177                                                 fi
3178                                                 echo .. \$verb alias \$cf_alias\${suffix}
3179                                                 rm -f \$cf_alias\${suffix}
3180                                                 $LN_S \$cf_target \$cf_alias\${suffix}
3181                                         elif test "\$cf_target" != "\$cf_alias\${suffix}" ; then
3182                                                 echo ".so \$cf_source" >\$TMP
3183 CF_EOF
3184 if test -n "$cf_compress" ; then
3185 cat >>$cf_edit_man <<CF_EOF
3186                                                 if test -n "$cf_so_strip" ; then
3187                                                         $cf_compress -f \$TMP
3188                                                         mv \$TMP.$cf_so_strip \$TMP
3189                                                 fi
3190 CF_EOF
3191 fi
3192 cat >>$cf_edit_man <<CF_EOF
3193                                                 echo .. \$verb alias \$cf_alias\${suffix}
3194                                                 rm -f \$cf_alias\${suffix}
3195                                                 \$INSTALL_DATA \$TMP \$cf_alias\${suffix}
3196                                         fi
3197                                 done
3198                         )
3199                 )
3200         elif test \$verb = removing ; then
3201                 test -f \$cf_target && (
3202                         echo \$verb \$cf_target
3203                         rm -f \$cf_target
3204                 )
3205                 test -d \$cf_subdir\${section} &&
3206                 test -n "\$aliases" && (
3207                         cd \$cf_subdir\${section} && (
3208                                 for cf_alias in \$aliases
3209                                 do
3210                                         if test \$section = 1 ; then
3211                                                 cf_alias=\`echo \$cf_alias|sed "\${transform}"\`
3212                                         fi
3213
3214                                         echo .. \$verb alias \$cf_alias\${suffix}
3215                                         rm -f \$cf_alias\${suffix}
3216                                 done
3217                         )
3218                 )
3219         else
3220 #               echo ".hy 0"
3221                 cat \$TMP
3222         fi
3223         ;;
3224 esac
3225 done
3226
3227 if test $cf_inboth = yes ; then
3228 if test \$form != format ; then
3229         sh \[$]0 format \$verb \$mandir \$srcdir \[$]*
3230 fi
3231 fi
3232
3233 exit 0
3234 CF_EOF
3235 chmod 755 $cf_edit_man
3236
3237 ])dnl
3238 dnl ---------------------------------------------------------------------------
3239 dnl CF_MATH_LIB version: 5 updated: 2000/05/28 01:39:10
3240 dnl -----------
3241 dnl Checks for libraries.  At least one UNIX system, Apple Macintosh
3242 dnl Rhapsody 5.5, does not have -lm.  We cannot use the simpler
3243 dnl AC_CHECK_LIB(m,sin), because that fails for C++.
3244 AC_DEFUN([CF_MATH_LIB],
3245 [
3246 AC_CACHE_CHECK(if -lm needed for math functions,
3247         cf_cv_need_libm,[
3248         AC_TRY_LINK([
3249         #include <stdio.h>
3250         #include <math.h>
3251         ],
3252         [double x = rand(); printf("result = %g\n", ]ifelse($2,,sin(x),$2)[)],
3253         [cf_cv_need_libm=no],
3254         [cf_cv_need_libm=yes])])
3255 if test "$cf_cv_need_libm" = yes
3256 then
3257 ifelse($1,,[
3258         LIBS="$LIBS -lm"
3259 ],[$1=-lm])
3260 fi
3261 ])
3262 dnl ---------------------------------------------------------------------------
3263 dnl CF_MIXEDCASE_FILENAMES version: 3 updated: 2003/09/20 17:07:55
3264 dnl ----------------------
3265 dnl Check if the file-system supports mixed-case filenames.  If we're able to
3266 dnl create a lowercase name and see it as uppercase, it doesn't support that.
3267 AC_DEFUN([CF_MIXEDCASE_FILENAMES],
3268 [
3269 AC_CACHE_CHECK(if filesystem supports mixed-case filenames,cf_cv_mixedcase,[
3270 if test "$cross_compiling" = yes ; then
3271         case $target_alias in #(vi
3272         *-os2-emx*|*-msdosdjgpp*|*-cygwin*|*-mingw32*|*-uwin*) #(vi
3273                 cf_cv_mixedcase=no
3274                 ;;
3275         *)
3276                 cf_cv_mixedcase=yes
3277                 ;;
3278         esac
3279 else
3280         rm -f conftest CONFTEST
3281         echo test >conftest
3282         if test -f CONFTEST ; then
3283                 cf_cv_mixedcase=no
3284         else
3285                 cf_cv_mixedcase=yes
3286         fi
3287         rm -f conftest CONFTEST
3288 fi
3289 ])
3290 test "$cf_cv_mixedcase" = yes && AC_DEFINE(MIXEDCASE_FILENAMES)
3291 ])dnl
3292 dnl ---------------------------------------------------------------------------
3293 dnl CF_MKSTEMP version: 5 updated: 2006/12/16 12:33:30
3294 dnl ----------
3295 dnl Check for a working mkstemp.  This creates two files, checks that they are
3296 dnl successfully created and distinct (AmigaOS apparently fails on the last).
3297 AC_DEFUN([CF_MKSTEMP],[
3298 AC_CACHE_CHECK(for working mkstemp, cf_cv_func_mkstemp,[
3299 rm -f conftest*
3300 AC_TRY_RUN([
3301 #include <sys/types.h>
3302 #include <stdlib.h>
3303 #include <stdio.h>
3304 #include <string.h>
3305 #include <sys/stat.h>
3306 int main()
3307 {
3308         char *tmpl = "conftestXXXXXX";
3309         char name[2][80];
3310         int n;
3311         int result = 0;
3312         int fd;
3313         struct stat sb;
3314
3315         umask(077);
3316         for (n = 0; n < 2; ++n) {
3317                 strcpy(name[n], tmpl);
3318                 if ((fd = mkstemp(name[n])) >= 0) {
3319                         if (!strcmp(name[n], tmpl)
3320                          || stat(name[n], &sb) != 0
3321                          || (sb.st_mode & S_IFMT) != S_IFREG
3322                          || (sb.st_mode & 077) != 0) {
3323                                 result = 1;
3324                         }
3325                         close(fd);
3326                 }
3327         }
3328         if (result == 0
3329          && !strcmp(name[0], name[1]))
3330                 result = 1;
3331         ${cf_cv_main_return:-return}(result);
3332 }
3333 ],[cf_cv_func_mkstemp=yes
3334 ],[cf_cv_func_mkstemp=no
3335 ],[AC_CHECK_FUNC(mkstemp)
3336 ])
3337 ])
3338 if test "$cf_cv_func_mkstemp" = yes ; then
3339         AC_DEFINE(HAVE_MKSTEMP)
3340 fi
3341 ])dnl
3342 dnl ---------------------------------------------------------------------------
3343 dnl CF_MSG_LOG version: 4 updated: 2007/07/29 09:55:12
3344 dnl ----------
3345 dnl Write a debug message to config.log, along with the line number in the
3346 dnl configure script.
3347 AC_DEFUN([CF_MSG_LOG],[
3348 echo "${as_me-configure}:__oline__: testing $* ..." 1>&AC_FD_CC
3349 ])dnl
3350 dnl ---------------------------------------------------------------------------
3351 dnl CF_NCURSES_ABI_6 version: 1 updated: 2005/09/17 18:42:49
3352 dnl ----------------
3353 dnl Set ncurses' ABI to 6 unless overridden by explicit configure option, and
3354 dnl warn about this.
3355 AC_DEFUN([CF_NCURSES_ABI_6],[
3356 if test "${with_abi_version+set}" != set; then
3357         case $cf_cv_rel_version in
3358         5.*)
3359                 cf_cv_rel_version=6.0
3360                 cf_cv_abi_version=6
3361                 AC_MSG_WARN(Overriding ABI version to $cf_cv_abi_version)
3362                 ;;
3363         esac
3364 fi
3365 ])dnl
3366 dnl ---------------------------------------------------------------------------
3367 dnl CF_NO_LEAKS_OPTION version: 4 updated: 2006/12/16 14:24:05
3368 dnl ------------------
3369 dnl see CF_WITH_NO_LEAKS
3370 AC_DEFUN([CF_NO_LEAKS_OPTION],[
3371 AC_MSG_CHECKING(if you want to use $1 for testing)
3372 AC_ARG_WITH($1,
3373         [$2],
3374         [AC_DEFINE($3)ifelse([$4],,[
3375          $4
3376 ])
3377         : ${with_cflags:=-g}
3378         : ${with_no_leaks:=yes}
3379          with_$1=yes],
3380         [with_$1=])
3381 AC_MSG_RESULT(${with_$1:-no})
3382
3383 case .$with_cflags in #(vi
3384 .*-g*)
3385         case .$CFLAGS in #(vi
3386         .*-g*) #(vi
3387                 ;;
3388         *)
3389                 CF_ADD_CFLAGS([-g])
3390                 ;;
3391         esac
3392         ;;
3393 esac
3394 ])dnl
3395 dnl ---------------------------------------------------------------------------
3396 dnl CF_NUMBER_SYNTAX version: 1 updated: 2003/09/20 18:12:49
3397 dnl ----------------
3398 dnl Check if the given variable is a number.  If not, report an error.
3399 dnl $1 is the variable
3400 dnl $2 is the message
3401 AC_DEFUN([CF_NUMBER_SYNTAX],[
3402 if test -n "$1" ; then
3403   case $1 in #(vi
3404   [[0-9]]*) #(vi
3405         ;;
3406   *)
3407         AC_MSG_ERROR($2 is not a number: $1)
3408         ;;
3409   esac
3410 else
3411   AC_MSG_ERROR($2 value is empty)
3412 fi
3413 ])dnl
3414 dnl ---------------------------------------------------------------------------
3415 dnl CF_OBJ_SUBDIR version: 4 updated: 2002/02/23 20:38:31
3416 dnl -------------
3417 dnl Compute the object-directory name from the given model name
3418 AC_DEFUN([CF_OBJ_SUBDIR],
3419 [
3420         case $1 in
3421         libtool) $2='obj_lo'  ;;
3422         normal)  $2='objects' ;;
3423         debug)   $2='obj_g' ;;
3424         profile) $2='obj_p' ;;
3425         shared)
3426                 case $cf_cv_system_name in #(vi
3427                 cygwin) #(vi
3428                         $2='objects' ;;
3429                 *)
3430                         $2='obj_s' ;;
3431                 esac
3432         esac
3433 ])dnl
3434 dnl ---------------------------------------------------------------------------
3435 dnl CF_PATHSEP version: 3 updated: 2001/01/12 01:23:53
3436 dnl ----------
3437 dnl Provide a value for the $PATH and similar separator
3438 AC_DEFUN([CF_PATHSEP],
3439 [
3440         case $cf_cv_system_name in
3441         os2*)   PATHSEP=';'  ;;
3442         *)      PATHSEP=':'  ;;
3443         esac
3444 ifelse($1,,,[$1=$PATHSEP])
3445         AC_SUBST(PATHSEP)
3446 ])dnl
3447 dnl ---------------------------------------------------------------------------
3448 dnl CF_PATH_SYNTAX version: 11 updated: 2006/09/02 08:55:46
3449 dnl --------------
3450 dnl Check the argument to see that it looks like a pathname.  Rewrite it if it
3451 dnl begins with one of the prefix/exec_prefix variables, and then again if the
3452 dnl result begins with 'NONE'.  This is necessary to work around autoconf's
3453 dnl delayed evaluation of those symbols.
3454 AC_DEFUN([CF_PATH_SYNTAX],[
3455 if test "x$prefix" != xNONE; then
3456   cf_path_syntax="$prefix"
3457 else
3458   cf_path_syntax="$ac_default_prefix"
3459 fi
3460
3461 case ".[$]$1" in #(vi
3462 .\[$]\(*\)*|.\'*\'*) #(vi
3463   ;;
3464 ..|./*|.\\*) #(vi
3465   ;;
3466 .[[a-zA-Z]]:[[\\/]]*) #(vi OS/2 EMX
3467   ;;
3468 .\[$]{*prefix}*) #(vi
3469   eval $1="[$]$1"
3470   case ".[$]$1" in #(vi
3471   .NONE/*)
3472     $1=`echo [$]$1 | sed -e s%NONE%$cf_path_syntax%`
3473     ;;
3474   esac
3475   ;; #(vi
3476 .no|.NONE/*)
3477   $1=`echo [$]$1 | sed -e s%NONE%$cf_path_syntax%`
3478   ;;
3479 *)
3480   ifelse($2,,[AC_ERROR([expected a pathname, not \"[$]$1\"])],$2)
3481   ;;
3482 esac
3483 ])dnl
3484 dnl ---------------------------------------------------------------------------
3485 dnl CF_POSIX_C_SOURCE version: 6 updated: 2005/07/14 20:25:10
3486 dnl -----------------
3487 dnl Define _POSIX_C_SOURCE to the given level, and _POSIX_SOURCE if needed.
3488 dnl
3489 dnl     POSIX.1-1990                            _POSIX_SOURCE
3490 dnl     POSIX.1-1990 and                        _POSIX_SOURCE and
3491 dnl             POSIX.2-1992 C-Language                 _POSIX_C_SOURCE=2
3492 dnl             Bindings Option
3493 dnl     POSIX.1b-1993                           _POSIX_C_SOURCE=199309L
3494 dnl     POSIX.1c-1996                           _POSIX_C_SOURCE=199506L
3495 dnl     X/Open 2000                             _POSIX_C_SOURCE=200112L
3496 dnl
3497 dnl Parameters:
3498 dnl     $1 is the nominal value for _POSIX_C_SOURCE
3499 AC_DEFUN([CF_POSIX_C_SOURCE],
3500 [
3501 cf_POSIX_C_SOURCE=ifelse($1,,199506L,$1)
3502
3503 cf_save_CFLAGS="$CFLAGS"
3504 cf_save_CPPFLAGS="$CPPFLAGS"
3505
3506 CF_REMOVE_DEFINE(cf_trim_CFLAGS,$cf_save_CFLAGS,_POSIX_C_SOURCE)
3507 CF_REMOVE_DEFINE(cf_trim_CPPFLAGS,$cf_save_CPPFLAGS,_POSIX_C_SOURCE)
3508
3509 AC_CACHE_CHECK(if we should define _POSIX_C_SOURCE,cf_cv_posix_c_source,[
3510         CF_MSG_LOG(if the symbol is already defined go no further)
3511         AC_TRY_COMPILE([#include <sys/types.h>],[
3512 #ifndef _POSIX_C_SOURCE
3513 make an error
3514 #endif],
3515         [cf_cv_posix_c_source=no],
3516         [cf_want_posix_source=no
3517          case .$cf_POSIX_C_SOURCE in #(vi
3518          .[[12]]??*) #(vi
3519                 cf_cv_posix_c_source="-D_POSIX_C_SOURCE=$cf_POSIX_C_SOURCE"
3520                 ;;
3521          .2) #(vi
3522                 cf_cv_posix_c_source="-D_POSIX_C_SOURCE=$cf_POSIX_C_SOURCE"
3523                 cf_want_posix_source=yes
3524                 ;;
3525          .*)
3526                 cf_want_posix_source=yes
3527                 ;;
3528          esac
3529          if test "$cf_want_posix_source" = yes ; then
3530                 AC_TRY_COMPILE([#include <sys/types.h>],[
3531 #ifdef _POSIX_SOURCE
3532 make an error
3533 #endif],[],
3534                 cf_cv_posix_c_source="$cf_cv_posix_c_source -D_POSIX_SOURCE")
3535          fi
3536          CF_MSG_LOG(ifdef from value $cf_POSIX_C_SOURCE)
3537          CFLAGS="$cf_trim_CFLAGS"
3538          CPPFLAGS="$cf_trim_CPPFLAGS $cf_cv_posix_c_source"
3539          CF_MSG_LOG(if the second compile does not leave our definition intact error)
3540          AC_TRY_COMPILE([#include <sys/types.h>],[
3541 #ifndef _POSIX_C_SOURCE
3542 make an error
3543 #endif],,
3544          [cf_cv_posix_c_source=no])
3545          CFLAGS="$cf_save_CFLAGS"
3546          CPPFLAGS="$cf_save_CPPFLAGS"
3547         ])
3548 ])
3549
3550 if test "$cf_cv_posix_c_source" != no ; then
3551         CFLAGS="$cf_trim_CFLAGS"
3552         CPPFLAGS="$cf_trim_CPPFLAGS"
3553         if test "$cf_cv_cc_u_d_options" = yes ; then
3554                 cf_temp_posix_c_source=`echo "$cf_cv_posix_c_source" | \
3555                                 sed -e 's/-D/-U/g' -e 's/=[[^   ]]*//g'`
3556                 CPPFLAGS="$CPPFLAGS $cf_temp_posix_c_source"
3557         fi
3558         CPPFLAGS="$CPPFLAGS $cf_cv_posix_c_source"
3559 fi
3560
3561 ])dnl
3562 dnl ---------------------------------------------------------------------------
3563 dnl CF_PREDEFINE version: 1 updated: 2003/07/26 17:53:56
3564 dnl ------------
3565 dnl Add definitions to CPPFLAGS to ensure they're predefined for all compiles.
3566 dnl
3567 dnl $1 = symbol to test
3568 dnl $2 = value (if any) to use for a predefinition
3569 AC_DEFUN([CF_PREDEFINE],
3570 [
3571 AC_MSG_CHECKING(if we must define $1)
3572 AC_TRY_COMPILE([#include <sys/types.h>
3573 ],[
3574 #ifndef $1
3575 make an error
3576 #endif],[cf_result=no],[cf_result=yes])
3577 AC_MSG_RESULT($cf_result)
3578
3579 if test "$cf_result" = yes ; then
3580         CPPFLAGS="$CPPFLAGS ifelse($2,,-D$1,[-D$1=$2])"
3581 elif test "x$2" != "x" ; then
3582         AC_MSG_CHECKING(checking for compatible value versus $2)
3583         AC_TRY_COMPILE([#include <sys/types.h>
3584 ],[
3585 #if $1-$2 < 0
3586 make an error
3587 #endif],[cf_result=yes],[cf_result=no])
3588         AC_MSG_RESULT($cf_result)
3589         if test "$cf_result" = no ; then
3590                 # perhaps we can override it - try...
3591                 CPPFLAGS="$CPPFLAGS -D$1=$2"
3592         fi
3593 fi
3594 ])dnl
3595 dnl ---------------------------------------------------------------------------
3596 dnl CF_PRG_RULES version: 1 updated: 2006/06/03 11:45:08
3597 dnl ------------
3598 dnl Append definitions and rules for the given programs to the subdirectory
3599 dnl Makefiles, and the recursion rule for the top-level Makefile.
3600 dnl
3601 dnl parameters
3602 dnl     $1 = script to run
3603 dnl     $2 = list of subdirectories
3604 dnl
3605 dnl variables
3606 dnl     $AWK
3607 AC_DEFUN([CF_PRG_RULES],
3608 [
3609 for cf_dir in $2
3610 do
3611         if test ! -d $srcdir/$cf_dir; then
3612                 continue
3613         elif test -f $srcdir/$cf_dir/programs; then
3614                 $AWK -f $1 $srcdir/$cf_dir/programs >>$cf_dir/Makefile
3615         fi
3616 done
3617
3618 ])dnl
3619 dnl ---------------------------------------------------------------------------
3620 dnl CF_PROG_AWK version: 1 updated: 2006/09/16 11:40:59
3621 dnl -----------
3622 dnl Check for awk, ensure that the check found something.
3623 AC_DEFUN([CF_PROG_AWK],
3624 [
3625 AC_PROG_AWK
3626 test -z "$AWK" && AC_MSG_ERROR(No awk program found)
3627 ])dnl
3628 dnl ---------------------------------------------------------------------------
3629 dnl CF_PROG_CC_C_O version: 2 updated: 2006/12/16 15:55:46
3630 dnl --------------
3631 dnl Analogous to AC_PROG_CC_C_O, but more useful: tests only $CC, ensures that
3632 dnl the output file can be renamed, and allows for a shell variable that can
3633 dnl be used later.  The parameter is either CC or CXX.  The result is the
3634 dnl cache variable:
3635 dnl     $cf_cv_prog_CC_c_o
3636 dnl     $cf_cv_prog_CXX_c_o
3637 AC_DEFUN([CF_PROG_CC_C_O],
3638 [AC_REQUIRE([AC_PROG_CC])dnl
3639 AC_MSG_CHECKING([whether [$]$1 understands -c and -o together])
3640 AC_CACHE_VAL(cf_cv_prog_$1_c_o,
3641 [
3642 cat > conftest.$ac_ext <<CF_EOF
3643 #include <stdio.h>
3644 int main()
3645 {
3646         ${cf_cv_main_return:-return}(0);
3647 }
3648 CF_EOF
3649 # We do the test twice because some compilers refuse to overwrite an
3650 # existing .o file with -o, though they will create one.
3651 ac_try='[$]$1 -c conftest.$ac_ext -o conftest2.$ac_objext >&AC_FD_CC'
3652 if AC_TRY_EVAL(ac_try) &&
3653   test -f conftest2.$ac_objext && AC_TRY_EVAL(ac_try);
3654 then
3655   eval cf_cv_prog_$1_c_o=yes
3656 else
3657   eval cf_cv_prog_$1_c_o=no
3658 fi
3659 rm -f conftest*
3660 ])dnl
3661 if test $cf_cv_prog_$1_c_o = yes; then
3662   AC_MSG_RESULT([yes])
3663 else
3664   AC_MSG_RESULT([no])
3665 fi
3666 ])dnl
3667 dnl ---------------------------------------------------------------------------
3668 dnl CF_PROG_CC_U_D version: 1 updated: 2005/07/14 16:59:30
3669 dnl --------------
3670 dnl Check if C (preprocessor) -U and -D options are processed in the order
3671 dnl given rather than by type of option.  Some compilers insist on apply all
3672 dnl of the -U options after all of the -D options.  Others allow mixing them,
3673 dnl and may predefine symbols that conflict with those we define.
3674 AC_DEFUN([CF_PROG_CC_U_D],
3675 [
3676 AC_CACHE_CHECK(if $CC -U and -D options work together,cf_cv_cc_u_d_options,[
3677         cf_save_CPPFLAGS="$CPPFLAGS"
3678         CPPFLAGS="-UU_D_OPTIONS -DU_D_OPTIONS -DD_U_OPTIONS -UD_U_OPTIONS"
3679         AC_TRY_COMPILE([],[
3680 #ifndef U_D_OPTIONS
3681 make an undefined-error
3682 #endif
3683 #ifdef  D_U_OPTIONS
3684 make a defined-error
3685 #endif
3686         ],[
3687         cf_cv_cc_u_d_options=yes],[
3688         cf_cv_cc_u_d_options=no])
3689         CPPFLAGS="$cf_save_CPPFLAGS"
3690 ])
3691 ])dnl
3692 dnl ---------------------------------------------------------------------------
3693 dnl CF_PROG_EGREP version: 1 updated: 2006/09/16 11:40:59
3694 dnl -------------
3695 dnl AC_PROG_EGREP was introduced in autoconf 2.53.
3696 dnl This macro adds a check to ensure the script found something.
3697 AC_DEFUN([CF_PROG_EGREP],
3698 [AC_CACHE_CHECK([for egrep], [ac_cv_prog_egrep],
3699    [if echo a | (grep -E '(a|b)') >/dev/null 2>&1
3700     then ac_cv_prog_egrep='grep -E'
3701     else ac_cv_prog_egrep='egrep'
3702     fi])
3703  EGREP=$ac_cv_prog_egrep
3704  AC_SUBST([EGREP])
3705 test -z "$EGREP" && AC_MSG_ERROR(No egrep program found)
3706 ])dnl
3707 dnl ---------------------------------------------------------------------------
3708 dnl CF_PROG_EXT version: 10 updated: 2004/01/03 19:28:18
3709 dnl -----------
3710 dnl Compute $PROG_EXT, used for non-Unix ports, such as OS/2 EMX.
3711 AC_DEFUN([CF_PROG_EXT],
3712 [
3713 AC_REQUIRE([CF_CHECK_CACHE])
3714 case $cf_cv_system_name in
3715 os2*)
3716     CFLAGS="$CFLAGS -Zmt"
3717     CPPFLAGS="$CPPFLAGS -D__ST_MT_ERRNO__"
3718     CXXFLAGS="$CXXFLAGS -Zmt"
3719     # autoconf's macro sets -Zexe and suffix both, which conflict:w
3720     LDFLAGS="$LDFLAGS -Zmt -Zcrtdll"
3721     ac_cv_exeext=.exe
3722     ;;
3723 esac
3724
3725 AC_EXEEXT
3726 AC_OBJEXT
3727
3728 PROG_EXT="$EXEEXT"
3729 AC_SUBST(PROG_EXT)
3730 test -n "$PROG_EXT" && AC_DEFINE_UNQUOTED(PROG_EXT,"$PROG_EXT")
3731 ])dnl
3732 dnl ---------------------------------------------------------------------------
3733 dnl CF_PROG_INSTALL version: 5 updated: 2002/12/21 22:46:07
3734 dnl ---------------
3735 dnl Force $INSTALL to be an absolute-path.  Otherwise, edit_man.sh and the
3736 dnl misc/tabset install won't work properly.  Usually this happens only when
3737 dnl using the fallback mkinstalldirs script
3738 AC_DEFUN([CF_PROG_INSTALL],
3739 [AC_PROG_INSTALL
3740 case $INSTALL in
3741 /*)
3742   ;;
3743 *)
3744   CF_DIRNAME(cf_dir,$INSTALL)
3745   test -z "$cf_dir" && cf_dir=.
3746   INSTALL=`cd $cf_dir && pwd`/`echo $INSTALL | sed -e 's%^.*/%%'`
3747   ;;
3748 esac
3749 ])dnl
3750 dnl ---------------------------------------------------------------------------
3751 dnl CF_PROG_LDCONFIG version: 1 updated: 2003/09/20 17:07:55
3752 dnl ----------------
3753 dnl Check for ldconfig, needed to fixup shared libraries that would be built
3754 dnl and then used in the install.
3755 AC_DEFUN([CF_PROG_LDCONFIG],[
3756 if test "$cross_compiling" = yes ; then
3757   LDCONFIG=:
3758 else
3759 case "$cf_cv_system_name" in #(vi
3760 freebsd*) #(vi
3761   test -z "$LDCONFIG" && LDCONFIG="/sbin/ldconfig -R"
3762   ;;
3763 *) LDPATH=$PATH:/sbin:/usr/sbin
3764   AC_PATH_PROG(LDCONFIG,ldconfig,,$LDPATH)
3765   ;;
3766 esac
3767 fi
3768 AC_SUBST(LDCONFIG)
3769 ])dnl
3770 dnl ---------------------------------------------------------------------------
3771 dnl CF_PROG_LINT version: 1 updated: 2006/09/16 11:40:59
3772 dnl ------------
3773 AC_DEFUN([CF_PROG_LINT],
3774 [
3775 AC_CHECK_PROGS(LINT, tdlint lint alint)
3776 AC_SUBST(LINT_OPTS)
3777 ])dnl
3778 dnl ---------------------------------------------------------------------------
3779 dnl CF_REGEX version: 3 updated: 1997/11/01 14:26:01
3780 dnl --------
3781 dnl Attempt to determine if we've got one of the flavors of regular-expression
3782 dnl code that we can support.
3783 AC_DEFUN([CF_REGEX],
3784 [
3785 AC_MSG_CHECKING([for regular-expression headers])
3786 AC_CACHE_VAL(cf_cv_regex,[
3787 AC_TRY_LINK([#include <sys/types.h>
3788 #include <regex.h>],[
3789         regex_t *p;
3790         int x = regcomp(p, "", 0);
3791         int y = regexec(p, "", 0, 0, 0);
3792         regfree(p);
3793         ],[cf_cv_regex="regex.h"],[
3794         AC_TRY_LINK([#include <regexp.h>],[
3795                 char *p = compile("", "", "", 0);
3796                 int x = step("", "");
3797         ],[cf_cv_regex="regexp.h"],[
3798                 cf_save_LIBS="$LIBS"
3799                 LIBS="-lgen $LIBS"
3800                 AC_TRY_LINK([#include <regexpr.h>],[
3801                         char *p = compile("", "", "");
3802                         int x = step("", "");
3803                 ],[cf_cv_regex="regexpr.h"],[LIBS="$cf_save_LIBS"])])])
3804 ])
3805 AC_MSG_RESULT($cf_cv_regex)
3806 case $cf_cv_regex in
3807         regex.h)   AC_DEFINE(HAVE_REGEX_H_FUNCS) ;;
3808         regexp.h)  AC_DEFINE(HAVE_REGEXP_H_FUNCS) ;;
3809         regexpr.h) AC_DEFINE(HAVE_REGEXPR_H_FUNCS) ;;
3810 esac
3811 ])dnl
3812 dnl ---------------------------------------------------------------------------
3813 dnl CF_REMOVE_DEFINE version: 2 updated: 2005/07/09 16:12:18
3814 dnl ----------------
3815 dnl Remove all -U and -D options that refer to the given symbol from a list
3816 dnl of C compiler options.  This works around the problem that not all
3817 dnl compilers process -U and -D options from left-to-right, so a -U option
3818 dnl cannot be used to cancel the effect of a preceding -D option.
3819 dnl
3820 dnl $1 = target (which could be the same as the source variable)
3821 dnl $2 = source (including '$')
3822 dnl $3 = symbol to remove
3823 define([CF_REMOVE_DEFINE],
3824 [
3825 # remove $3 symbol from $2
3826 $1=`echo "$2" | \
3827         sed     -e 's/-[[UD]]$3\(=[[^   ]]*\)\?[[       ]]/ /g' \
3828                 -e 's/-[[UD]]$3\(=[[^   ]]*\)\?[$]//g'`
3829 ])dnl
3830 dnl ---------------------------------------------------------------------------
3831 dnl CF_REMOVE_LIB version: 1 updated: 2007/02/17 14:11:52
3832 dnl -------------
3833 dnl Remove the given library from the symbol
3834 dnl
3835 dnl $1 = target (which could be the same as the source variable)
3836 dnl $2 = source (including '$')
3837 dnl $3 = library to remove
3838 define([CF_REMOVE_LIB],
3839 [
3840 # remove $3 library from $2
3841 $1=`echo "$2" | sed -e 's/-l$3[[        ]]//g' -e 's/-l$3[$]//'`
3842 ])dnl
3843 dnl ---------------------------------------------------------------------------
3844 dnl CF_RPATH_HACK version: 3 updated: 2007/12/01 11:14:13
3845 dnl -------------
3846 AC_DEFUN([CF_RPATH_HACK],
3847 [
3848 AC_REQUIRE([CF_SHARED_OPTS])
3849 AC_MSG_CHECKING(for updated LDFLAGS)
3850 if test -n "$LDFLAGS" ; then
3851 AC_MSG_RESULT(maybe)
3852 CF_VERBOSE(...checking LDFLAGS $LDFLAGS)
3853 CF_VERBOSE(...checking EXTRA_LDFLAGS $EXTRA_LDFLAGS)
3854 case "$EXTRA_LDFLAGS" in #(vi
3855 -Wl,-rpath,*) #(vi
3856     cf_rpath_hack="-Wl,-rpath,"
3857     ;;
3858 -R\ *)
3859     cf_rpath_hack="-R "
3860     ;;
3861 -R*)
3862     cf_rpath_hack="-R"
3863     ;;
3864 *)
3865     cf_rpath_hack=
3866     ;;
3867 esac
3868 if test -n "$cf_rpath_hack" ; then
3869     cf_rpath_dst=
3870     for cf_rpath_src in $LDFLAGS
3871     do
3872         CF_VERBOSE(Filtering $cf_rpath_src)
3873         case $cf_rpath_src in #(vi
3874         -L*) #(vi
3875             if test "$cf_rpath_hack" = "-R " ; then
3876                 cf_rpath_tmp=`echo "$cf_rpath_src" |sed -e 's%-L%-R %'`
3877             else
3878                 cf_rpath_tmp=`echo "$cf_rpath_src" |sed -e s%-L%$cf_rpath_hack%`
3879             fi
3880             CF_VERBOSE(...Filter $cf_rpath_tmp)
3881             EXTRA_LDFLAGS="$cf_rpath_tmp $EXTRA_LDFLAGS"
3882             ;;
3883         *)
3884             cf_rpath_dst="$cf_rpath_dst $cf_rpath_src"
3885             ;;
3886         esac
3887     done
3888     LDFLAGS=$cf_rpath_dst
3889     CF_VERBOSE(...checked LDFLAGS $LDFLAGS)
3890     CF_VERBOSE(...checked EXTRA_LDFLAGS $EXTRA_LDFLAGS)
3891 fi
3892 else
3893 AC_MSG_RESULT(no)
3894 fi
3895 ])dnl
3896 dnl ---------------------------------------------------------------------------
3897 dnl CF_SHARED_OPTS version: 46 updated: 2007/02/24 18:58:09
3898 dnl --------------
3899 dnl --------------
3900 dnl Attempt to determine the appropriate CC/LD options for creating a shared
3901 dnl library.
3902 dnl
3903 dnl Note: ${LOCAL_LDFLAGS} is used to link executables that will run within the
3904 dnl build-tree, i.e., by making use of the libraries that are compiled in ../lib
3905 dnl We avoid compiling-in a ../lib path for the shared library since that can
3906 dnl lead to unexpected results at runtime.
3907 dnl ${LOCAL_LDFLAGS2} has the same intention but assumes that the shared libraries
3908 dnl are compiled in ../../lib
3909 dnl
3910 dnl The variable 'cf_cv_do_symlinks' is used to control whether we configure
3911 dnl to install symbolic links to the rel/abi versions of shared libraries.
3912 dnl
3913 dnl The variable 'cf_cv_shlib_version' controls whether we use the rel or abi
3914 dnl version when making symbolic links.
3915 dnl
3916 dnl The variable 'cf_cv_shlib_version_infix' controls whether shared library
3917 dnl version numbers are infix (ex: libncurses.<ver>.dylib) or postfix
3918 dnl (ex: libncurses.so.<ver>).
3919 dnl
3920 dnl Some loaders leave 'so_locations' lying around.  It's nice to clean up.
3921 AC_DEFUN([CF_SHARED_OPTS],
3922 [
3923         AC_REQUIRE([CF_SUBST_NCURSES_VERSION])
3924         LOCAL_LDFLAGS=
3925         LOCAL_LDFLAGS2=
3926         LD_SHARED_OPTS=
3927         INSTALL_LIB="-m 644"
3928
3929         cf_cv_do_symlinks=no
3930
3931         AC_MSG_CHECKING(if release/abi version should be used for shared libs)
3932         AC_ARG_WITH(shlib-version,
3933         [  --with-shlib-version=X  Specify rel or abi version for shared libs],
3934         [test -z "$withval" && withval=auto
3935         case $withval in #(vi
3936         yes) #(vi
3937                 cf_cv_shlib_version=auto
3938                 ;;
3939         rel|abi|auto|no) #(vi
3940                 cf_cv_shlib_version=$withval
3941                 ;;
3942         *)
3943                 AC_ERROR([option value must be one of: rel, abi, auto or no])
3944                 ;;
3945         esac
3946         ],[cf_cv_shlib_version=auto])
3947         AC_MSG_RESULT($cf_cv_shlib_version)
3948
3949         cf_cv_rm_so_locs=no
3950
3951         # Some less-capable ports of gcc support only -fpic
3952         CC_SHARED_OPTS=
3953         if test "$GCC" = yes
3954         then
3955                 AC_MSG_CHECKING(which $CC option to use)
3956                 cf_save_CFLAGS="$CFLAGS"
3957                 for CC_SHARED_OPTS in -fPIC -fpic ''
3958                 do
3959                         CFLAGS="$cf_save_CFLAGS $CC_SHARED_OPTS"
3960                         AC_TRY_COMPILE([#include <stdio.h>],[int x = 1],[break],[])
3961                 done
3962                 AC_MSG_RESULT($CC_SHARED_OPTS)
3963                 CFLAGS="$cf_save_CFLAGS"
3964         fi
3965
3966         cf_cv_shlib_version_infix=no
3967
3968         case $cf_cv_system_name in
3969         beos*)
3970                 MK_SHARED_LIB='${CC} ${CFLAGS} -o $[@] -Xlinker -soname=`basename $[@]` -nostart -e 0'
3971                 ;;
3972         cygwin*)
3973                 CC_SHARED_OPTS=
3974                 MK_SHARED_LIB='sh ../mk_shared_lib.sh [$]@ [$]{CC} [$]{CFLAGS}'
3975                 cf_cv_shlib_version=cygdll
3976                 cf_cv_shlib_version_infix=cygdll
3977                 cat >mk_shared_lib.sh <<-CF_EOF
3978                 #!/bin/sh
3979                 SHARED_LIB=\[$]1
3980                 IMPORT_LIB=\`echo "\[$]1" | sed -e 's/cyg/lib/' -e 's/[[0-9]]*\.dll[$]/.dll.a/'\`
3981                 shift
3982                 cat <<-EOF
3983                 Linking shared library
3984                 ** SHARED_LIB \[$]SHARED_LIB
3985                 ** IMPORT_LIB \[$]IMPORT_LIB
3986 EOF
3987                 exec \[$]* -shared -Wl,--out-implib=../lib/\[$]{IMPORT_LIB} -Wl,--export-all-symbols -o ../lib/\[$]{SHARED_LIB}
3988 CF_EOF
3989                 chmod +x mk_shared_lib.sh
3990                 ;;
3991         darwin*)
3992                 EXTRA_CFLAGS="-no-cpp-precomp"
3993                 CC_SHARED_OPTS="-dynamic"
3994                 MK_SHARED_LIB='${CC} ${CFLAGS} -dynamiclib -install_name ${libdir}/`basename $[@]` -compatibility_version ${ABI_VERSION} -current_version ${ABI_VERSION} -o $[@]'
3995                 test "$cf_cv_shlib_version" = auto && cf_cv_shlib_version=abi
3996                 cf_cv_shlib_version_infix=yes
3997                 AC_CACHE_CHECK([if ld -search_paths_first works], cf_cv_ldflags_search_paths_first, [
3998                         cf_save_LDFLAGS=$LDFLAGS
3999                         LDFLAGS="$LDFLAGS -Wl,-search_paths_first"
4000                         AC_TRY_LINK(, [int i;], cf_cv_ldflags_search_paths_first=yes, cf_cv_ldflags_search_paths_first=no)
4001                                 LDFLAGS=$cf_save_LDFLAGS])
4002                 if test $cf_cv_ldflags_search_paths_first = yes; then
4003                         LDFLAGS="$LDFLAGS -Wl,-search_paths_first"
4004                 fi
4005                 ;;
4006         hpux*)
4007                 # (tested with gcc 2.7.2 -- I don't have c89)
4008                 if test "$GCC" = yes; then
4009                         LD_SHARED_OPTS='-Xlinker +b -Xlinker ${libdir}'
4010                 else
4011                         CC_SHARED_OPTS='+Z'
4012                         LD_SHARED_OPTS='-Wl,+b,${libdir}'
4013                 fi
4014                 MK_SHARED_LIB='${LD} +b ${libdir} -b -o $[@]'
4015                 # HP-UX shared libraries must be executable, and should be
4016                 # readonly to exploit a quirk in the memory manager.
4017                 INSTALL_LIB="-m 555"
4018                 ;;
4019         irix*)
4020                 if test "$cf_cv_ld_rpath" = yes ; then
4021                         if test "$GCC" = yes; then
4022                                 cf_ld_rpath_opt="-Wl,-rpath,"
4023                                 EXTRA_LDFLAGS="-Wl,-rpath,\${libdir} $EXTRA_LDFLAGS"
4024                         else
4025                                 cf_ld_rpath_opt="-rpath "
4026                                 EXTRA_LDFLAGS="-rpath \${libdir} $EXTRA_LDFLAGS"
4027                         fi
4028                 fi
4029                 # tested with IRIX 5.2 and 'cc'.
4030                 if test "$GCC" != yes; then
4031                         CC_SHARED_OPTS='-KPIC'
4032                 fi
4033                 MK_SHARED_LIB='${CC} -shared -rdata_shared -soname `basename $[@]` -o $[@]'
4034                 cf_cv_rm_so_locs=yes
4035                 ;;
4036         linux*|gnu*|k*bsd*-gnu)
4037                 if test "$DFT_LWR_MODEL" = "shared" ; then
4038                         LOCAL_LDFLAGS="-Wl,-rpath,\$(LOCAL_LIBDIR)"
4039                         LOCAL_LDFLAGS2="$LOCAL_LDFLAGS"
4040                 fi
4041                 if test "$cf_cv_ld_rpath" = yes ; then
4042                         cf_ld_rpath_opt="-Wl,-rpath,"
4043                         EXTRA_LDFLAGS="-Wl,-rpath,\${libdir} $EXTRA_LDFLAGS"
4044                 fi
4045                 CF_SHARED_SONAME
4046                 MK_SHARED_LIB='${CC} ${CFLAGS} -shared -Wl,-soname,'$cf_shared_soname',-stats,-lc -o $[@]'
4047                 ;;
4048         openbsd[[2-9]].*)
4049                 CC_SHARED_OPTS="$CC_SHARED_OPTS -DPIC"
4050                 MK_SHARED_LIB='${LD} -Bshareable -soname,`basename $[@].${ABI_VERSION}` -o $[@]'
4051                 ;;
4052         openbsd*|freebsd[[12]].*)
4053                 CC_SHARED_OPTS="$CC_SHARED_OPTS -DPIC"
4054                 MK_SHARED_LIB='${LD} -Bshareable -o $[@]'
4055                 test "$cf_cv_shlib_version" = auto && cf_cv_shlib_version=rel
4056                 ;;
4057         freebsd*)
4058                 CC_SHARED_OPTS="$CC_SHARED_OPTS -DPIC"
4059                 if test "$DFT_LWR_MODEL" = "shared" && test "$cf_cv_ld_rpath" = yes ; then
4060                         LOCAL_LDFLAGS="-rpath \$(LOCAL_LIBDIR)"
4061                         LOCAL_LDFLAGS2="-rpath \${libdir} $LOCAL_LDFLAGS"
4062                         cf_ld_rpath_opt="-rpath "
4063                         EXTRA_LDFLAGS="-rpath \${libdir} $EXTRA_LDFLAGS"
4064                 fi
4065                 CF_SHARED_SONAME
4066                 MK_SHARED_LIB='${LD} -Bshareable -soname=`basename $[@]` -o $[@]'
4067                 ;;
4068         netbsd*)
4069                 CC_SHARED_OPTS="$CC_SHARED_OPTS -DPIC"
4070                 test "$cf_cv_ld_rpath" = yes && cf_ld_rpath_opt="-Wl,-rpath,"
4071                 if test "$DFT_LWR_MODEL" = "shared" && test "$cf_cv_ld_rpath" = yes ; then
4072                         LOCAL_LDFLAGS="-Wl,-rpath,\$(LOCAL_LIBDIR)"
4073                         LOCAL_LDFLAGS2="$LOCAL_LDFLAGS"
4074                         EXTRA_LDFLAGS="-Wl,-rpath,\${libdir} $EXTRA_LDFLAGS"
4075                         if test "$cf_cv_shlib_version" = auto; then
4076                         if test -f /usr/libexec/ld.elf_so; then
4077                                 cf_cv_shlib_version=abi
4078                         else
4079                                 cf_cv_shlib_version=rel
4080                         fi
4081                         fi
4082                         CF_SHARED_SONAME
4083                         MK_SHARED_LIB='${CC} ${CFLAGS} -shared -Wl,-soname,'$cf_shared_soname' -o $[@]'
4084                 else
4085                         MK_SHARED_LIB='${LD} -Bshareable -o $[@]'
4086                 fi
4087                 ;;
4088         osf*|mls+*)
4089                 # tested with OSF/1 V3.2 and 'cc'
4090                 # tested with OSF/1 V3.2 and gcc 2.6.3 (but the c++ demo didn't
4091                 # link with shared libs).
4092                 MK_SHARED_LIB='${LD} -set_version ${REL_VERSION}:${ABI_VERSION} -expect_unresolved "*" -shared -soname `basename $[@]`'
4093                 case $host_os in
4094                 osf4*)
4095                         MK_SHARED_LIB="${MK_SHARED_LIB} -msym"
4096                         ;;
4097                 esac
4098                 MK_SHARED_LIB="${MK_SHARED_LIB}"' -o $[@]'
4099                 if test "$DFT_LWR_MODEL" = "shared" ; then
4100                         LOCAL_LDFLAGS="-Wl,-rpath,\$(LOCAL_LIBDIR)"
4101                         LOCAL_LDFLAGS2="$LOCAL_LDFLAGS"
4102                 fi
4103                 if test "$cf_cv_ld_rpath" = yes ; then
4104                         cf_ld_rpath_opt="-rpath"
4105                         # EXTRA_LDFLAGS="$LOCAL_LDFLAGS $EXTRA_LDFLAGS"
4106                 fi
4107                 cf_cv_rm_so_locs=yes
4108                 ;;
4109         sco3.2v5*)  # (also uw2* and UW7) hops 13-Apr-98
4110                 # tested with osr5.0.5
4111                 if test "$GCC" != yes; then
4112                         CC_SHARED_OPTS='-belf -KPIC'
4113                 fi
4114                 MK_SHARED_LIB='${LD} -dy -G -h `basename $[@] .${REL_VERSION}`.${ABI_VERSION} -o [$]@'
4115                 if test "$cf_cv_ld_rpath" = yes ; then
4116                         # only way is to set LD_RUN_PATH but no switch for it
4117                         RUN_PATH=$libdir
4118                 fi
4119                 test "$cf_cv_shlib_version" = auto && cf_cv_shlib_version=rel
4120                 LINK_PROGS='LD_RUN_PATH=${libdir}'
4121                 LINK_TESTS='Pwd=`pwd`;LD_RUN_PATH=`dirname $${Pwd}`/lib'
4122                 ;;
4123         sunos4*)
4124                 # tested with SunOS 4.1.1 and gcc 2.7.0
4125                 if test "$GCC" != yes; then
4126                         CC_SHARED_OPTS='-KPIC'
4127                 fi
4128                 MK_SHARED_LIB='${LD} -assert pure-text -o $[@]'
4129                 test "$cf_cv_shlib_version" = auto && cf_cv_shlib_version=rel
4130                 ;;
4131         solaris2*)
4132                 # tested with SunOS 5.5.1 (solaris 2.5.1) and gcc 2.7.2
4133                 if test "$GCC" != yes; then
4134                         CC_SHARED_OPTS='-KPIC'
4135                 fi
4136                 if test "$DFT_LWR_MODEL" = "shared" ; then
4137                         LOCAL_LDFLAGS="-R \$(LOCAL_LIBDIR):\${libdir}"
4138                         LOCAL_LDFLAGS2="$LOCAL_LDFLAGS"
4139                 fi
4140                 if test "$cf_cv_ld_rpath" = yes ; then
4141                         cf_ld_rpath_opt="-R"
4142                         EXTRA_LDFLAGS="$LOCAL_LDFLAGS $EXTRA_LDFLAGS"
4143                 fi
4144                 CF_SHARED_SONAME
4145                 MK_SHARED_LIB='${CC} -dy -G -h '$cf_shared_soname' -o $[@]'
4146                 ;;
4147         sysv5uw7*|unix_sv*)
4148                 # tested with UnixWare 7.1.0 (gcc 2.95.2 and cc)
4149                 if test "$GCC" != yes; then
4150                         CC_SHARED_OPTS='-KPIC'
4151                 fi
4152                 MK_SHARED_LIB='${LD} -d y -G -o [$]@'
4153                 ;;
4154         *)
4155                 CC_SHARED_OPTS='unknown'
4156                 MK_SHARED_LIB='echo unknown'
4157                 ;;
4158         esac
4159
4160         # This works if the last tokens in $MK_SHARED_LIB are the -o target.
4161         case "$cf_cv_shlib_version" in #(vi
4162         rel|abi)
4163                 case "$MK_SHARED_LIB" in #(vi
4164                 *'-o $[@]')
4165                         test "$cf_cv_do_symlinks" = no && cf_cv_do_symlinks=yes
4166                         ;;
4167                 *)
4168                         AC_MSG_WARN(ignored --with-shlib-version)
4169                         ;;
4170                 esac
4171                 ;;
4172         esac
4173
4174         if test -n "$cf_ld_rpath_opt" ; then
4175                 AC_MSG_CHECKING(if we need a space after rpath option)
4176                 cf_save_LIBS="$LIBS"
4177                 LIBS="$LIBS ${cf_ld_rpath_opt}$libdir"
4178                 AC_TRY_LINK(, , cf_rpath_space=no, cf_rpath_space=yes)
4179                 LIBS="$cf_save_LIBS"
4180                 AC_MSG_RESULT($cf_rpath_space)
4181                 test "$cf_rpath_space" = yes && cf_ld_rpath_opt="$cf_ld_rpath_opt "
4182                 MK_SHARED_LIB="$MK_SHARED_LIB $cf_ld_rpath_opt\${libdir}"
4183         fi
4184
4185         AC_SUBST(CC_SHARED_OPTS)
4186         AC_SUBST(LD_SHARED_OPTS)
4187         AC_SUBST(MK_SHARED_LIB)
4188         AC_SUBST(LINK_PROGS)
4189         AC_SUBST(LINK_TESTS)
4190         AC_SUBST(EXTRA_LDFLAGS)
4191         AC_SUBST(LOCAL_LDFLAGS)
4192         AC_SUBST(LOCAL_LDFLAGS2)
4193         AC_SUBST(INSTALL_LIB)
4194 ])dnl
4195 dnl ---------------------------------------------------------------------------
4196 dnl CF_SHARED_SONAME version: 2 updated: 2006/10/21 12:33:41
4197 dnl ----------------
4198 dnl utility macro for CF_SHARED_OPTS, constructs "$cf_shared_soname" for
4199 dnl substitution into MK_SHARED_LIB string for the "-soname" (or similar)
4200 dnl option.
4201 dnl
4202 dnl $1 is the default that should be used for "$cf_cv_shlib_version".
4203 dnl If missing, use "rel".
4204 define([CF_SHARED_SONAME],
4205 [
4206         test "$cf_cv_shlib_version" = auto && cf_cv_shlib_version=ifelse($1,,rel,$1)
4207         if test "$cf_cv_shlib_version" = rel; then
4208                 cf_shared_soname='`basename $[@] .${REL_VERSION}`.${ABI_VERSION}'
4209         else
4210                 cf_shared_soname='`basename $[@]`'
4211         fi
4212 ])
4213 dnl ---------------------------------------------------------------------------
4214 dnl CF_SIGWINCH version: 1 updated: 2006/04/02 16:41:09
4215 dnl -----------
4216 dnl Use this macro after CF_XOPEN_SOURCE, but do not require it (not all
4217 dnl programs need this test).
4218 dnl
4219 dnl This is really a MacOS X 10.4.3 workaround.  Defining _POSIX_C_SOURCE
4220 dnl forces SIGWINCH to be undefined (breaks xterm, ncurses).  Oddly, the struct
4221 dnl winsize declaration is left alone - we may revisit this if Apple choose to
4222 dnl break that part of the interface as well.
4223 AC_DEFUN([CF_SIGWINCH],
4224 [
4225 AC_CACHE_CHECK(if SIGWINCH is defined,cf_cv_define_sigwinch,[
4226         AC_TRY_COMPILE([
4227 #include <sys/types.h>
4228 #include <sys/signal.h>
4229 ],[int x = SIGWINCH],
4230         [cf_cv_define_sigwinch=yes],
4231         [AC_TRY_COMPILE([
4232 #undef _XOPEN_SOURCE
4233 #undef _POSIX_SOURCE
4234 #undef _POSIX_C_SOURCE
4235 #include <sys/types.h>
4236 #include <sys/signal.h>
4237 ],[int x = SIGWINCH],
4238         [cf_cv_define_sigwinch=maybe],
4239         [cf_cv_define_sigwinch=no])
4240 ])
4241 ])
4242
4243 if test "$cf_cv_define_sigwinch" = maybe ; then
4244 AC_CACHE_CHECK(for actual SIGWINCH definition,cf_cv_fixup_sigwinch,[
4245 cf_cv_fixup_sigwinch=unknown
4246 cf_sigwinch=32
4247 while test $cf_sigwinch != 1
4248 do
4249         AC_TRY_COMPILE([
4250 #undef _XOPEN_SOURCE
4251 #undef _POSIX_SOURCE
4252 #undef _POSIX_C_SOURCE
4253 #include <sys/types.h>
4254 #include <sys/signal.h>
4255 ],[
4256 #if SIGWINCH != $cf_sigwinch
4257 make an error
4258 #endif
4259 int x = SIGWINCH],
4260         [cf_cv_fixup_sigwinch=$cf_sigwinch
4261          break])
4262
4263 cf_sigwinch=`expr $cf_sigwinch - 1`
4264 done
4265 ])
4266
4267         if test "$cf_cv_fixup_sigwinch" != unknown ; then
4268                 CPPFLAGS="$CPPFLAGS -DSIGWINCH=$cf_cv_fixup_sigwinch"
4269         fi
4270 fi
4271 ])dnl
4272 dnl ---------------------------------------------------------------------------
4273 dnl CF_SIG_ATOMIC_T version: 2 updated: 2005/09/18 17:27:12
4274 dnl ---------------
4275 dnl signal handler, but there are some gcc depedencies in that recommendation.
4276 dnl Try anyway.
4277 AC_DEFUN([CF_SIG_ATOMIC_T],
4278 [
4279 AC_MSG_CHECKING(for signal global datatype)
4280 AC_CACHE_VAL(cf_cv_sig_atomic_t,[
4281         for cf_type in \
4282                 "volatile sig_atomic_t" \
4283                 "sig_atomic_t" \
4284                 "int"
4285         do
4286         AC_TRY_COMPILE([
4287 #include <sys/types.h>
4288 #include <signal.h>
4289 #include <stdio.h>
4290
4291 extern $cf_type x;
4292 $cf_type x;
4293 static void handler(int sig)
4294 {
4295         x = 5;
4296 }],
4297                 [signal(SIGINT, handler);
4298                  x = 1],
4299                 [cf_cv_sig_atomic_t=$cf_type],
4300                 [cf_cv_sig_atomic_t=no])
4301                 test "$cf_cv_sig_atomic_t" != no && break
4302         done
4303         ])
4304 AC_MSG_RESULT($cf_cv_sig_atomic_t)
4305 test "$cf_cv_sig_atomic_t" != no && AC_DEFINE_UNQUOTED(SIG_ATOMIC_T, $cf_cv_sig_atomic_t)
4306 ])dnl
4307 dnl ---------------------------------------------------------------------------
4308 dnl CF_SIZECHANGE version: 8 updated: 2000/11/04 12:22:16
4309 dnl -------------
4310 dnl Check for definitions & structures needed for window size-changing
4311 dnl FIXME: check that this works with "snake" (HP-UX 10.x)
4312 AC_DEFUN([CF_SIZECHANGE],
4313 [
4314 AC_REQUIRE([CF_STRUCT_TERMIOS])
4315 AC_CACHE_CHECK(declaration of size-change, cf_cv_sizechange,[
4316     cf_cv_sizechange=unknown
4317     cf_save_CPPFLAGS="$CPPFLAGS"
4318
4319 for cf_opts in "" "NEED_PTEM_H"
4320 do
4321
4322     CPPFLAGS="$cf_save_CPPFLAGS"
4323     test -n "$cf_opts" && CPPFLAGS="$CPPFLAGS -D$cf_opts"
4324     AC_TRY_COMPILE([#include <sys/types.h>
4325 #ifdef HAVE_TERMIOS_H
4326 #include <termios.h>
4327 #else
4328 #ifdef HAVE_TERMIO_H
4329 #include <termio.h>
4330 #endif
4331 #endif
4332 #ifdef NEED_PTEM_H
4333 /* This is a workaround for SCO:  they neglected to define struct winsize in
4334  * termios.h -- it's only in termio.h and ptem.h
4335  */
4336 #include        <sys/stream.h>
4337 #include        <sys/ptem.h>
4338 #endif
4339 #if !defined(sun) || !defined(HAVE_TERMIOS_H)
4340 #include <sys/ioctl.h>
4341 #endif
4342 ],[
4343 #ifdef TIOCGSIZE
4344         struct ttysize win;     /* FIXME: what system is this? */
4345         int y = win.ts_lines;
4346         int x = win.ts_cols;
4347 #else
4348 #ifdef TIOCGWINSZ
4349         struct winsize win;
4350         int y = win.ws_row;
4351         int x = win.ws_col;
4352 #else
4353         no TIOCGSIZE or TIOCGWINSZ
4354 #endif /* TIOCGWINSZ */
4355 #endif /* TIOCGSIZE */
4356         ],
4357         [cf_cv_sizechange=yes],
4358         [cf_cv_sizechange=no])
4359
4360         CPPFLAGS="$cf_save_CPPFLAGS"
4361         if test "$cf_cv_sizechange" = yes ; then
4362                 echo "size-change succeeded ($cf_opts)" >&AC_FD_CC
4363                 test -n "$cf_opts" && cf_cv_sizechange="$cf_opts"
4364                 break
4365         fi
4366 done
4367 ])
4368 if test "$cf_cv_sizechange" != no ; then
4369         AC_DEFINE(HAVE_SIZECHANGE)
4370         case $cf_cv_sizechange in #(vi
4371         NEED*)
4372                 AC_DEFINE_UNQUOTED($cf_cv_sizechange )
4373                 ;;
4374         esac
4375 fi
4376 ])dnl
4377 dnl ---------------------------------------------------------------------------
4378 dnl CF_SRC_MODULES version: 18 updated: 2005/05/28 12:58:54
4379 dnl --------------
4380 dnl For each parameter, test if the source-directory exists, and if it contains
4381 dnl a 'modules' file.  If so, add to the list $cf_cv_src_modules which we'll
4382 dnl use in CF_LIB_RULES.
4383 dnl
4384 dnl This uses the configured value to make the lists SRC_SUBDIRS and
4385 dnl SUB_MAKEFILES which are used in the makefile-generation scheme.
4386 AC_DEFUN([CF_SRC_MODULES],
4387 [
4388 AC_MSG_CHECKING(for src modules)
4389
4390 # dependencies and linker-arguments for test-programs
4391 TEST_DEPS="${LIB_DIR}/${LIB_PREFIX}${LIB_NAME}${DFT_DEP_SUFFIX} $TEST_DEPS"
4392 TEST_DEP2="${LIB_2ND}/${LIB_PREFIX}${LIB_NAME}${DFT_DEP_SUFFIX} $TEST_DEP2"
4393 if test "$DFT_LWR_MODEL" = "libtool"; then
4394         TEST_ARGS="${TEST_DEPS}"
4395         TEST_ARG2="${TEST_DEP2}"
4396 else
4397         TEST_ARGS="-l${LIB_NAME}${DFT_ARG_SUFFIX} $TEST_ARGS"
4398         TEST_ARG2="-l${LIB_NAME}${DFT_ARG_SUFFIX} $TEST_ARG2"
4399 fi
4400
4401 cf_cv_src_modules=
4402 for cf_dir in $1
4403 do
4404         if test -f $srcdir/$cf_dir/modules; then
4405
4406                 # We may/may not have tack in the distribution, though the
4407                 # makefile is.
4408                 if test $cf_dir = tack ; then
4409                         if test ! -f $srcdir/${cf_dir}/${cf_dir}.h; then
4410                                 continue
4411                         fi
4412                 fi
4413
4414                 if test -z "$cf_cv_src_modules"; then
4415                         cf_cv_src_modules=$cf_dir
4416                 else
4417                         cf_cv_src_modules="$cf_cv_src_modules $cf_dir"
4418                 fi
4419
4420                 # Make the ncurses_cfg.h file record the library interface files as
4421                 # well.  These are header files that are the same name as their
4422                 # directory.  Ncurses is the only library that does not follow
4423                 # that pattern.
4424                 if test $cf_dir = tack ; then
4425                         continue
4426                 elif test -f $srcdir/${cf_dir}/${cf_dir}.h; then
4427                         CF_UPPER(cf_have_include,$cf_dir)
4428                         AC_DEFINE_UNQUOTED(HAVE_${cf_have_include}_H)
4429                         AC_DEFINE_UNQUOTED(HAVE_LIB${cf_have_include})
4430                         TEST_DEPS="${LIB_DIR}/${LIB_PREFIX}${cf_dir}${DFT_DEP_SUFFIX} $TEST_DEPS"
4431                         TEST_DEP2="${LIB_2ND}/${LIB_PREFIX}${cf_dir}${DFT_DEP_SUFFIX} $TEST_DEP2"
4432                         if test "$DFT_LWR_MODEL" = "libtool"; then
4433                                 TEST_ARGS="${TEST_DEPS}"
4434                                 TEST_ARG2="${TEST_DEP2}"
4435                         else
4436                                 TEST_ARGS="-l${cf_dir}${DFT_ARG_SUFFIX} $TEST_ARGS"
4437                                 TEST_ARG2="-l${cf_dir}${DFT_ARG_SUFFIX} $TEST_ARG2"
4438                         fi
4439                 fi
4440         fi
4441 done
4442 AC_MSG_RESULT($cf_cv_src_modules)
4443
4444 TEST_ARGS="-L${LIB_DIR} $TEST_ARGS"
4445 TEST_ARG2="-L${LIB_2ND} $TEST_ARG2"
4446
4447 AC_SUBST(TEST_ARGS)
4448 AC_SUBST(TEST_DEPS)
4449
4450 AC_SUBST(TEST_ARG2)
4451 AC_SUBST(TEST_DEP2)
4452
4453 SRC_SUBDIRS="man include"
4454 for cf_dir in $cf_cv_src_modules
4455 do
4456         SRC_SUBDIRS="$SRC_SUBDIRS $cf_dir"