aclocal.m4

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