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