aclocal.m4

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