aclocal.m4

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