aclocal.m4

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