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