aclocal.m4

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