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