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