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