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.558 2011/06/05 00:13:55 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_ACVERSION_CHECK version: 2 updated: 2011/05/08 11:22:03
  66 dnl ------------------
  67 dnl Conditionally generate script according to whether we're using a given autoconf.
  68 dnl
  69 dnl $1 = version to compare against
  70 dnl $2 = code to use if AC_ACVERSION is at least as high as $1.
  71 dnl $3 = code to use if AC_ACVERSION is older than $1.
  72 define(CF_ACVERSION_CHECK,
  73 [
  74 ifdef([m4_version_compare],
  75 [m4_if(m4_version_compare(m4_defn([AC_ACVERSION]), [$1]), -1, [$3], [$2])],
  76 [CF_ACVERSION_COMPARE(
  77 AC_PREREQ_CANON(AC_PREREQ_SPLIT([$1])),
  78 AC_PREREQ_CANON(AC_PREREQ_SPLIT(AC_ACVERSION)), AC_ACVERSION, [$2], [$3])])])dnl
  79 dnl ---------------------------------------------------------------------------
  80 dnl CF_ACVERSION_COMPARE version: 2 updated: 2011/04/14 20:56:50
  81 dnl --------------------
  82 dnl CF_ACVERSION_COMPARE(MAJOR1, MINOR1, TERNARY1,
  83 dnl                      MAJOR2, MINOR2, TERNARY2,
  84 dnl                      PRINTABLE2, not FOUND, FOUND)
  85 define(CF_ACVERSION_COMPARE,
  86 [ifelse(builtin([eval], [$2 < $5]), 1,
  87 [ifelse([$8], , ,[$8])],
  88 [ifelse([$9], , ,[$9])])])dnl
  89 dnl ---------------------------------------------------------------------------
  90 dnl CF_ADA_INCLUDE_DIRS version: 6 updated: 2010/02/26 19:52:07
  91 dnl -------------------
  92 dnl Construct the list of include-options for the C programs in the Ada95
  93 dnl binding.
  94 AC_DEFUN([CF_ADA_INCLUDE_DIRS],
  95 [
  96 ACPPFLAGS="-I. -I../include -I../../include $ACPPFLAGS"
  97 if test "$srcdir" != "."; then
  98         ACPPFLAGS="-I\${srcdir}/../../include $ACPPFLAGS"
  99 fi
 100 if test "$GCC" != yes; then
 101         ACPPFLAGS="$ACPPFLAGS -I\${includedir}"
 102 elif test "$includedir" != "/usr/include"; then
 103         if test "$includedir" = '${prefix}/include' ; then
 104                 if test $prefix != /usr ; then
 105                         ACPPFLAGS="$ACPPFLAGS -I\${includedir}"
 106                 fi
 107         else
 108                 ACPPFLAGS="$ACPPFLAGS -I\${includedir}"
 109         fi
 110 fi
 111 AC_SUBST(ACPPFLAGS)
 112 ])dnl
 113 dnl ---------------------------------------------------------------------------
 114 dnl CF_ADD_ADAFLAGS version: 1 updated: 2010/06/19 15:22:18
 115 dnl ---------------
 116 dnl Add to $ADAFLAGS, which is substituted into makefile and scripts.
 117 AC_DEFUN([CF_ADD_ADAFLAGS],[
 118         ADAFLAGS="$ADAFLAGS $1"
 119         AC_SUBST(ADAFLAGS)
 120 ])dnl
 121 dnl ---------------------------------------------------------------------------
 122 dnl CF_ADD_CFLAGS version: 10 updated: 2010/05/26 05:38:42
 123 dnl -------------
 124 dnl Copy non-preprocessor flags to $CFLAGS, preprocessor flags to $CPPFLAGS
 125 dnl The second parameter if given makes this macro verbose.
 126 dnl
 127 dnl Put any preprocessor definitions that use quoted strings in $EXTRA_CPPFLAGS,
 128 dnl to simplify use of $CPPFLAGS in compiler checks, etc., that are easily
 129 dnl confused by the quotes (which require backslashes to keep them usable).
 130 AC_DEFUN([CF_ADD_CFLAGS],
 131 [
 132 cf_fix_cppflags=no
 133 cf_new_cflags=
 134 cf_new_cppflags=
 135 cf_new_extra_cppflags=
 136
 137 for cf_add_cflags in $1
 138 do
 139 case $cf_fix_cppflags in
 140 no)
 141         case $cf_add_cflags in #(vi
 142         -undef|-nostdinc*|-I*|-D*|-U*|-E|-P|-C) #(vi
 143                 case $cf_add_cflags in
 144                 -D*)
 145                         cf_tst_cflags=`echo ${cf_add_cflags} |sed -e 's/^-D[[^=]]*='\''\"[[^"]]*//'`
 146
 147                         test "${cf_add_cflags}" != "${cf_tst_cflags}" \
 148                                 && test -z "${cf_tst_cflags}" \
 149                                 && cf_fix_cppflags=yes
 150
 151                         if test $cf_fix_cppflags = yes ; then
 152                                 cf_new_extra_cppflags="$cf_new_extra_cppflags $cf_add_cflags"
 153                                 continue
 154                         elif test "${cf_tst_cflags}" = "\"'" ; then
 155                                 cf_new_extra_cppflags="$cf_new_extra_cppflags $cf_add_cflags"
 156                                 continue
 157                         fi
 158                         ;;
 159                 esac
 160                 case "$CPPFLAGS" in
 161                 *$cf_add_cflags) #(vi
 162                         ;;
 163                 *) #(vi
 164                         case $cf_add_cflags in #(vi
 165                         -D*)
 166                                 cf_tst_cppflags=`echo "x$cf_add_cflags" | sed -e 's/^...//' -e 's/=.*//'`
 167                                 CF_REMOVE_DEFINE(CPPFLAGS,$CPPFLAGS,$cf_tst_cppflags)
 168                                 ;;
 169                         esac
 170                         cf_new_cppflags="$cf_new_cppflags $cf_add_cflags"
 171                         ;;
 172                 esac
 173                 ;;
 174         *)
 175                 cf_new_cflags="$cf_new_cflags $cf_add_cflags"
 176                 ;;
 177         esac
 178         ;;
 179 yes)
 180         cf_new_extra_cppflags="$cf_new_extra_cppflags $cf_add_cflags"
 181
 182         cf_tst_cflags=`echo ${cf_add_cflags} |sed -e 's/^[[^"]]*"'\''//'`
 183
 184         test "${cf_add_cflags}" != "${cf_tst_cflags}" \
 185                 && test -z "${cf_tst_cflags}" \
 186                 && cf_fix_cppflags=no
 187         ;;
 188 esac
 189 done
 190
 191 if test -n "$cf_new_cflags" ; then
 192         ifelse([$2],,,[CF_VERBOSE(add to \$CFLAGS $cf_new_cflags)])
 193         CFLAGS="$CFLAGS $cf_new_cflags"
 194 fi
 195
 196 if test -n "$cf_new_cppflags" ; then
 197         ifelse([$2],,,[CF_VERBOSE(add to \$CPPFLAGS $cf_new_cppflags)])
 198         CPPFLAGS="$CPPFLAGS $cf_new_cppflags"
 199 fi
 200
 201 if test -n "$cf_new_extra_cppflags" ; then
 202         ifelse([$2],,,[CF_VERBOSE(add to \$EXTRA_CPPFLAGS $cf_new_extra_cppflags)])
 203         EXTRA_CPPFLAGS="$cf_new_extra_cppflags $EXTRA_CPPFLAGS"
 204 fi
 205
 206 AC_SUBST(EXTRA_CPPFLAGS)
 207
 208 ])dnl
 209 dnl ---------------------------------------------------------------------------
 210 dnl CF_ADD_INCDIR version: 13 updated: 2010/05/26 16:44:57
 211 dnl -------------
 212 dnl Add an include-directory to $CPPFLAGS.  Don't add /usr/include, since it's
 213 dnl redundant.  We don't normally need to add -I/usr/local/include for gcc,
 214 dnl but old versions (and some misinstalled ones) need that.  To make things
 215 dnl worse, gcc 3.x may give error messages if -I/usr/local/include is added to
 216 dnl the include-path).
 217 AC_DEFUN([CF_ADD_INCDIR],
 218 [
 219 if test -n "$1" ; then
 220   for cf_add_incdir in $1
 221   do
 222         while test $cf_add_incdir != /usr/include
 223         do
 224           if test -d $cf_add_incdir
 225           then
 226                 cf_have_incdir=no
 227                 if test -n "$CFLAGS$CPPFLAGS" ; then
 228                   # a loop is needed to ensure we can add subdirs of existing dirs
 229                   for cf_test_incdir in $CFLAGS $CPPFLAGS ; do
 230                         if test ".$cf_test_incdir" = ".-I$cf_add_incdir" ; then
 231                           cf_have_incdir=yes; break
 232                         fi
 233                   done
 234                 fi
 235
 236                 if test "$cf_have_incdir" = no ; then
 237                   if test "$cf_add_incdir" = /usr/local/include ; then
 238                         if test "$GCC" = yes
 239                         then
 240                           cf_save_CPPFLAGS=$CPPFLAGS
 241                           CPPFLAGS="$CPPFLAGS -I$cf_add_incdir"
 242                           AC_TRY_COMPILE([#include <stdio.h>],
 243                                   [printf("Hello")],
 244                                   [],
 245                                   [cf_have_incdir=yes])
 246                           CPPFLAGS=$cf_save_CPPFLAGS
 247                         fi
 248                   fi
 249                 fi
 250
 251                 if test "$cf_have_incdir" = no ; then
 252                   CF_VERBOSE(adding $cf_add_incdir to include-path)
 253                   ifelse([$2],,CPPFLAGS,[$2])="$ifelse([$2],,CPPFLAGS,[$2]) -I$cf_add_incdir"
 254
 255                   cf_top_incdir=`echo $cf_add_incdir | sed -e 's%/include/.*$%/include%'`
 256                   test "$cf_top_incdir" = "$cf_add_incdir" && break
 257                   cf_add_incdir="$cf_top_incdir"
 258                 else
 259                   break
 260                 fi
 261           fi
 262         done
 263   done
 264 fi
 265 ])dnl
 266 dnl ---------------------------------------------------------------------------
 267 dnl CF_ADD_LIB version: 2 updated: 2010/06/02 05:03:05
 268 dnl ----------
 269 dnl Add a library, used to enforce consistency.
 270 dnl
 271 dnl $1 = library to add, without the "-l"
 272 dnl $2 = variable to update (default $LIBS)
 273 AC_DEFUN([CF_ADD_LIB],[CF_ADD_LIBS(-l$1,ifelse($2,,LIBS,[$2]))])dnl
 274 dnl ---------------------------------------------------------------------------
 275 dnl CF_ADD_LIBDIR version: 9 updated: 2010/05/26 16:44:57
 276 dnl -------------
 277 dnl     Adds to the library-path
 278 dnl
 279 dnl     Some machines have trouble with multiple -L options.
 280 dnl
 281 dnl $1 is the (list of) directory(s) to add
 282 dnl $2 is the optional name of the variable to update (default LDFLAGS)
 283 dnl
 284 AC_DEFUN([CF_ADD_LIBDIR],
 285 [
 286 if test -n "$1" ; then
 287   for cf_add_libdir in $1
 288   do
 289     if test $cf_add_libdir = /usr/lib ; then
 290       :
 291     elif test -d $cf_add_libdir
 292     then
 293       cf_have_libdir=no
 294       if test -n "$LDFLAGS$LIBS" ; then
 295         # a loop is needed to ensure we can add subdirs of existing dirs
 296         for cf_test_libdir in $LDFLAGS $LIBS ; do
 297           if test ".$cf_test_libdir" = ".-L$cf_add_libdir" ; then
 298             cf_have_libdir=yes; break
 299           fi
 300         done
 301       fi
 302       if test "$cf_have_libdir" = no ; then
 303         CF_VERBOSE(adding $cf_add_libdir to library-path)
 304         ifelse([$2],,LDFLAGS,[$2])="-L$cf_add_libdir $ifelse([$2],,LDFLAGS,[$2])"
 305       fi
 306     fi
 307   done
 308 fi
 309 ])dnl
 310 dnl ---------------------------------------------------------------------------
 311 dnl CF_ADD_LIBS version: 1 updated: 2010/06/02 05:03:05
 312 dnl -----------
 313 dnl Add one or more libraries, used to enforce consistency.
 314 dnl
 315 dnl $1 = libraries to add, with the "-l", etc.
 316 dnl $2 = variable to update (default $LIBS)
 317 AC_DEFUN([CF_ADD_LIBS],[ifelse($2,,LIBS,[$2])="$1 [$]ifelse($2,,LIBS,[$2])"])dnl
 318 dnl ---------------------------------------------------------------------------
 319 dnl CF_ADD_SUBDIR_PATH version: 3 updated: 2010/07/03 20:58:12
 320 dnl ------------------
 321 dnl Append to a search-list for a nonstandard header/lib-file
 322 dnl     $1 = the variable to return as result
 323 dnl     $2 = the package name
 324 dnl     $3 = the subdirectory, e.g., bin, include or lib
 325 dnl $4 = the directory under which we will test for subdirectories
 326 dnl $5 = a directory that we do not want $4 to match
 327 AC_DEFUN([CF_ADD_SUBDIR_PATH],
 328 [
 329 test "$4" != "$5" && \
 330 test -d "$4" && \
 331 ifelse([$5],NONE,,[(test $5 = NONE || test "$4" != "$5") &&]) {
 332         test -n "$verbose" && echo "    ... testing for $3-directories under $4"
 333         test -d $4/$3 &&          $1="[$]$1 $4/$3"
 334         test -d $4/$3/$2 &&       $1="[$]$1 $4/$3/$2"
 335         test -d $4/$3/$2/$3 &&    $1="[$]$1 $4/$3/$2/$3"
 336         test -d $4/$2/$3 &&       $1="[$]$1 $4/$2/$3"
 337         test -d $4/$2/$3/$2 &&    $1="[$]$1 $4/$2/$3/$2"
 338 }
 339 ])dnl
 340 dnl ---------------------------------------------------------------------------
 341 dnl CF_ANSI_CC_CHECK version: 10 updated: 2010/10/23 15:52:32
 342 dnl ----------------
 343 dnl This is adapted from the macros 'fp_PROG_CC_STDC' and 'fp_C_PROTOTYPES'
 344 dnl in the sharutils 4.2 distribution.
 345 AC_DEFUN([CF_ANSI_CC_CHECK],
 346 [
 347 AC_CACHE_CHECK(for ${CC:-cc} option to accept ANSI C, cf_cv_ansi_cc,[
 348 cf_cv_ansi_cc=no
 349 cf_save_CFLAGS="$CFLAGS"
 350 cf_save_CPPFLAGS="$CPPFLAGS"
 351 # Don't try gcc -ansi; that turns off useful extensions and
 352 # breaks some systems' header files.
 353 # AIX                   -qlanglvl=ansi
 354 # Ultrix and OSF/1      -std1
 355 # HP-UX                 -Aa -D_HPUX_SOURCE
 356 # SVR4                  -Xc
 357 # UnixWare 1.2          (cannot use -Xc, since ANSI/POSIX clashes)
 358 for cf_arg in "-DCC_HAS_PROTOS" \
 359         "" \
 360         -qlanglvl=ansi \
 361         -std1 \
 362         -Ae \
 363         "-Aa -D_HPUX_SOURCE" \
 364         -Xc
 365 do
 366         CF_ADD_CFLAGS($cf_arg)
 367         AC_TRY_COMPILE(
 368 [
 369 #ifndef CC_HAS_PROTOS
 370 #if !defined(__STDC__) || (__STDC__ != 1)
 371 choke me
 372 #endif
 373 #endif
 374 ],[
 375         int test (int i, double x);
 376         struct s1 {int (*f) (int a);};
 377         struct s2 {int (*f) (double a);};],
 378         [cf_cv_ansi_cc="$cf_arg"; break])
 379 done
 380 CFLAGS="$cf_save_CFLAGS"
 381 CPPFLAGS="$cf_save_CPPFLAGS"
 382 ])
 383
 384 if test "$cf_cv_ansi_cc" != "no"; then
 385 if test ".$cf_cv_ansi_cc" != ".-DCC_HAS_PROTOS"; then
 386         CF_ADD_CFLAGS($cf_cv_ansi_cc)
 387 else
 388         AC_DEFINE(CC_HAS_PROTOS)
 389 fi
 390 fi
 391 ])dnl
 392 dnl ---------------------------------------------------------------------------
 393 dnl CF_ANSI_CC_REQD version: 4 updated: 2008/03/23 14:48:54
 394 dnl ---------------
 395 dnl For programs that must use an ANSI compiler, obtain compiler options that
 396 dnl will make it recognize prototypes.  We'll do preprocessor checks in other
 397 dnl macros, since tools such as unproto can fake prototypes, but only part of
 398 dnl the preprocessor.
 399 AC_DEFUN([CF_ANSI_CC_REQD],
 400 [AC_REQUIRE([CF_ANSI_CC_CHECK])
 401 if test "$cf_cv_ansi_cc" = "no"; then
 402         AC_MSG_ERROR(
 403 [Your compiler does not appear to recognize prototypes.
 404 You have the following choices:
 405         a. adjust your compiler options
 406         b. get an up-to-date compiler
 407         c. use a wrapper such as unproto])
 408 fi
 409 ])dnl
 410 dnl ---------------------------------------------------------------------------
 411 dnl CF_ARG_DISABLE version: 3 updated: 1999/03/30 17:24:31
 412 dnl --------------
 413 dnl Allow user to disable a normally-on option.
 414 AC_DEFUN([CF_ARG_DISABLE],
 415 [CF_ARG_OPTION($1,[$2],[$3],[$4],yes)])dnl
 416 dnl ---------------------------------------------------------------------------
 417 dnl CF_ARG_OPTION version: 4 updated: 2010/05/26 05:38:42
 418 dnl -------------
 419 dnl Restricted form of AC_ARG_ENABLE that ensures user doesn't give bogus
 420 dnl values.
 421 dnl
 422 dnl Parameters:
 423 dnl $1 = option name
 424 dnl $2 = help-string
 425 dnl $3 = action to perform if option is not default
 426 dnl $4 = action if perform if option is default
 427 dnl $5 = default option value (either 'yes' or 'no')
 428 AC_DEFUN([CF_ARG_OPTION],
 429 [AC_ARG_ENABLE([$1],[$2],[test "$enableval" != ifelse([$5],no,yes,no) && enableval=ifelse([$5],no,no,yes)
 430   if test "$enableval" != "$5" ; then
 431 ifelse([$3],,[    :]dnl
 432 ,[    $3]) ifelse([$4],,,[
 433   else
 434     $4])
 435   fi],[enableval=$5 ifelse([$4],,,[
 436   $4
 437 ])dnl
 438   ])])dnl
 439 dnl ---------------------------------------------------------------------------
 440 dnl CF_AR_FLAGS version: 5 updated: 2010/05/20 20:24:29
 441 dnl -----------
 442 dnl Check for suitable "ar" (archiver) options for updating an archive.
 443 AC_DEFUN([CF_AR_FLAGS],[
 444 AC_REQUIRE([CF_PROG_AR])
 445
 446 AC_CACHE_CHECK(for options to update archives, cf_cv_ar_flags,[
 447         cf_cv_ar_flags=unknown
 448         for cf_ar_flags in -curv curv -crv crv -cqv cqv -rv rv
 449         do
 450
 451                 # check if $ARFLAGS already contains this choice
 452                 if test "x$ARFLAGS" != "x" ; then
 453                         cf_check_ar_flags=`echo "x$ARFLAGS" | sed -e "s/$cf_ar_flags\$//" -e "s/$cf_ar_flags / /"`
 454                         if test "x$ARFLAGS" != "$cf_check_ar_flags" ; then
 455                                 cf_cv_ar_flags=
 456                                 break
 457                         fi
 458                 fi
 459
 460                 rm -f conftest.$ac_cv_objext
 461                 rm -f conftest.a
 462
 463                 cat >conftest.$ac_ext <<EOF
 464 #line __oline__ "configure"
 465 int     testdata[[3]] = { 123, 456, 789 };
 466 EOF
 467                 if AC_TRY_EVAL(ac_compile) ; then
 468                         echo "$AR $ARFLAGS $cf_ar_flags conftest.a conftest.$ac_cv_objext" >&AC_FD_CC
 469                         $AR $ARFLAGS $cf_ar_flags conftest.a conftest.$ac_cv_objext 2>&AC_FD_CC 1>/dev/null
 470                         if test -f conftest.a ; then
 471                                 cf_cv_ar_flags=$cf_ar_flags
 472                                 break
 473                         fi
 474                 else
 475                         CF_VERBOSE(cannot compile test-program)
 476                         break
 477                 fi
 478         done
 479         rm -f conftest.a conftest.$ac_ext conftest.$ac_cv_objext
 480 ])
 481
 482 if test -n "$ARFLAGS" ; then
 483         if test -n "$cf_cv_ar_flags" ; then
 484                 ARFLAGS="$ARFLAGS $cf_cv_ar_flags"
 485         fi
 486 else
 487         ARFLAGS=$cf_cv_ar_flags
 488 fi
 489
 490 AC_SUBST(ARFLAGS)
 491 ])
 492 dnl ---------------------------------------------------------------------------
 493 dnl CF_AWK_BIG_PRINTF version: 3 updated: 2008/12/27 12:30:03
 494 dnl -----------------
 495 dnl Check if awk can handle big strings using printf.  Some older versions of
 496 dnl awk choke on large strings passed via "%s".
 497 dnl
 498 dnl $1 = desired string size
 499 dnl $2 = variable to set with result
 500 AC_DEFUN([CF_AWK_BIG_PRINTF],
 501 [
 502         case x$AWK in #(vi
 503         x)
 504                 eval $2=no
 505                 ;;
 506         *) #(vi
 507                 if ( ${AWK} 'BEGIN { xx = "x"; while (length(xx) < $1) { xx = xx "x"; }; printf("%s\n", xx); }' \
 508                         | $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
 509                         eval $2=yes
 510                 else
 511                         eval $2=no
 512                 fi
 513                 ;;
 514         esac
 515 ])dnl
 516 dnl ---------------------------------------------------------------------------
 517 dnl CF_BOOL_DECL version: 8 updated: 2004/01/30 15:51:18
 518 dnl ------------
 519 dnl Test if 'bool' is a builtin type in the configured C++ compiler.  Some
 520 dnl older compilers (e.g., gcc 2.5.8) don't support 'bool' directly; gcc
 521 dnl 2.6.3 does, in anticipation of the ANSI C++ standard.
 522 dnl
 523 dnl Treat the configuration-variable specially here, since we're directly
 524 dnl substituting its value (i.e., 1/0).
 525 dnl
 526 dnl $1 is the shell variable to store the result in, if not $cv_cv_builtin_bool
 527 AC_DEFUN([CF_BOOL_DECL],
 528 [
 529 AC_MSG_CHECKING(if we should include stdbool.h)
 530
 531 AC_CACHE_VAL(cf_cv_header_stdbool_h,[
 532         AC_TRY_COMPILE([],[bool foo = false],
 533                 [cf_cv_header_stdbool_h=0],
 534                 [AC_TRY_COMPILE([
 535 #ifndef __BEOS__
 536 #include <stdbool.h>
 537 #endif
 538 ],[bool foo = false],
 539                         [cf_cv_header_stdbool_h=1],
 540                         [cf_cv_header_stdbool_h=0])])])
 541
 542 if test "$cf_cv_header_stdbool_h" = 1
 543 then    AC_MSG_RESULT(yes)
 544 else    AC_MSG_RESULT(no)
 545 fi
 546
 547 AC_MSG_CHECKING([for builtin bool type])
 548
 549 AC_CACHE_VAL(ifelse($1,,cf_cv_builtin_bool,[$1]),[
 550         AC_TRY_COMPILE([
 551 #include <stdio.h>
 552 #include <sys/types.h>
 553 ],[bool x = false],
 554                 [ifelse($1,,cf_cv_builtin_bool,[$1])=1],
 555                 [ifelse($1,,cf_cv_builtin_bool,[$1])=0])
 556         ])
 557
 558 if test "$ifelse($1,,cf_cv_builtin_bool,[$1])" = 1
 559 then    AC_MSG_RESULT(yes)
 560 else    AC_MSG_RESULT(no)
 561 fi
 562 ])dnl
 563 dnl ---------------------------------------------------------------------------
 564 dnl CF_BOOL_SIZE version: 12 updated: 2006/12/16 12:33:30
 565 dnl ------------
 566 dnl Test for the size of 'bool' in the configured C++ compiler (e.g., a type).
 567 dnl Don't bother looking for bool.h, since it's been deprecated.
 568 dnl
 569 dnl If the current compiler is C rather than C++, we get the bool definition
 570 dnl from <stdbool.h>.
 571 AC_DEFUN([CF_BOOL_SIZE],
 572 [
 573 AC_MSG_CHECKING([for size of bool])
 574 AC_CACHE_VAL(cf_cv_type_of_bool,[
 575         rm -f cf_test.out
 576         AC_TRY_RUN([
 577 #include <stdlib.h>
 578 #include <stdio.h>
 579
 580 #if defined(__cplusplus)
 581
 582 #ifdef HAVE_GXX_BUILTIN_H
 583 #include <g++/builtin.h>
 584 #elif HAVE_GPP_BUILTIN_H
 585 #include <gpp/builtin.h>
 586 #elif HAVE_BUILTIN_H
 587 #include <builtin.h>
 588 #endif
 589
 590 #else
 591
 592 #if $cf_cv_header_stdbool_h
 593 #include <stdbool.h>
 594 #endif
 595
 596 #endif
 597
 598 main()
 599 {
 600         FILE *fp = fopen("cf_test.out", "w");
 601         if (fp != 0) {
 602                 bool x = true;
 603                 if ((bool)(-x) >= 0)
 604                         fputs("unsigned ", fp);
 605                 if (sizeof(x) == sizeof(int))       fputs("int",  fp);
 606                 else if (sizeof(x) == sizeof(char)) fputs("char", fp);
 607                 else if (sizeof(x) == sizeof(short))fputs("short",fp);
 608                 else if (sizeof(x) == sizeof(long)) fputs("long", fp);
 609                 fclose(fp);
 610         }
 611         ${cf_cv_main_return:-return}(0);
 612 }
 613                 ],
 614                 [cf_cv_type_of_bool=`cat cf_test.out`
 615                  if test -z "$cf_cv_type_of_bool"; then
 616                    cf_cv_type_of_bool=unknown
 617                  fi],
 618                 [cf_cv_type_of_bool=unknown],
 619                 [cf_cv_type_of_bool=unknown])
 620         ])
 621         rm -f cf_test.out
 622 AC_MSG_RESULT($cf_cv_type_of_bool)
 623 if test "$cf_cv_type_of_bool" = unknown ; then
 624         case .$NCURSES_BOOL in #(vi
 625         .auto|.) NCURSES_BOOL=unsigned;;
 626         esac
 627         AC_MSG_WARN(Assuming $NCURSES_BOOL for type of bool)
 628         cf_cv_type_of_bool=$NCURSES_BOOL
 629 fi
 630 ])dnl
 631 dnl ---------------------------------------------------------------------------
 632 dnl CF_BUILD_CC version: 6 updated: 2006/10/14 15:23:15
 633 dnl -----------
 634 dnl If we're cross-compiling, allow the user to override the tools and their
 635 dnl options.  The configure script is oriented toward identifying the host
 636 dnl compiler, etc., but we need a build compiler to generate parts of the
 637 dnl source.
 638 dnl
 639 dnl $1 = default for $CPPFLAGS
 640 dnl $2 = default for $LIBS
 641 AC_DEFUN([CF_BUILD_CC],[
 642 AC_REQUIRE([CF_PROG_EXT])
 643 if test "$cross_compiling" = yes ; then
 644
 645         # defaults that we might want to override
 646         : ${BUILD_CFLAGS:=''}
 647         : ${BUILD_CPPFLAGS:='ifelse([$1],,,[$1])'}
 648         : ${BUILD_LDFLAGS:=''}
 649         : ${BUILD_LIBS:='ifelse([$2],,,[$2])'}
 650         : ${BUILD_EXEEXT:='$x'}
 651         : ${BUILD_OBJEXT:='o'}
 652
 653         AC_ARG_WITH(build-cc,
 654                 [  --with-build-cc=XXX     the build C compiler ($BUILD_CC)],
 655                 [BUILD_CC="$withval"],
 656                 [AC_CHECK_PROGS(BUILD_CC, gcc cc cl)])
 657         AC_MSG_CHECKING(for native build C compiler)
 658         AC_MSG_RESULT($BUILD_CC)
 659
 660         AC_MSG_CHECKING(for native build C preprocessor)
 661         AC_ARG_WITH(build-cpp,
 662                 [  --with-build-cpp=XXX    the build C preprocessor ($BUILD_CPP)],
 663                 [BUILD_CPP="$withval"],
 664                 [BUILD_CPP='${BUILD_CC} -E'])
 665         AC_MSG_RESULT($BUILD_CPP)
 666
 667         AC_MSG_CHECKING(for native build C flags)
 668         AC_ARG_WITH(build-cflags,
 669                 [  --with-build-cflags=XXX the build C compiler-flags ($BUILD_CFLAGS)],
 670                 [BUILD_CFLAGS="$withval"])
 671         AC_MSG_RESULT($BUILD_CFLAGS)
 672
 673         AC_MSG_CHECKING(for native build C preprocessor-flags)
 674         AC_ARG_WITH(build-cppflags,
 675                 [  --with-build-cppflags=XXX the build C preprocessor-flags ($BUILD_CPPFLAGS)],
 676                 [BUILD_CPPFLAGS="$withval"])
 677         AC_MSG_RESULT($BUILD_CPPFLAGS)
 678
 679         AC_MSG_CHECKING(for native build linker-flags)
 680         AC_ARG_WITH(build-ldflags,
 681                 [  --with-build-ldflags=XXX the build linker-flags ($BUILD_LDFLAGS)],
 682                 [BUILD_LDFLAGS="$withval"])
 683         AC_MSG_RESULT($BUILD_LDFLAGS)
 684
 685         AC_MSG_CHECKING(for native build linker-libraries)
 686         AC_ARG_WITH(build-libs,
 687                 [  --with-build-libs=XXX   the build libraries (${BUILD_LIBS})],
 688                 [BUILD_LIBS="$withval"])
 689         AC_MSG_RESULT($BUILD_LIBS)
 690
 691         # this assumes we're on Unix.
 692         BUILD_EXEEXT=
 693         BUILD_OBJEXT=o
 694
 695         : ${BUILD_CC:='${CC}'}
 696
 697         if ( test "$BUILD_CC" = "$CC" || test "$BUILD_CC" = '${CC}' ) ; then
 698                 AC_MSG_ERROR([Cross-build requires two compilers.
 699 Use --with-build-cc to specify the native compiler.])
 700         fi
 701
 702 else
 703         : ${BUILD_CC:='${CC}'}
 704         : ${BUILD_CPP:='${CPP}'}
 705         : ${BUILD_CFLAGS:='${CFLAGS}'}
 706         : ${BUILD_CPPFLAGS:='${CPPFLAGS}'}
 707         : ${BUILD_LDFLAGS:='${LDFLAGS}'}
 708         : ${BUILD_LIBS:='${LIBS}'}
 709         : ${BUILD_EXEEXT:='$x'}
 710         : ${BUILD_OBJEXT:='o'}
 711 fi
 712
 713 AC_SUBST(BUILD_CC)
 714 AC_SUBST(BUILD_CPP)
 715 AC_SUBST(BUILD_CFLAGS)
 716 AC_SUBST(BUILD_CPPFLAGS)
 717 AC_SUBST(BUILD_LDFLAGS)
 718 AC_SUBST(BUILD_LIBS)
 719 AC_SUBST(BUILD_EXEEXT)
 720 AC_SUBST(BUILD_OBJEXT)
 721 ])dnl
 722 dnl ---------------------------------------------------------------------------
 723 dnl CF_CFG_DEFAULTS version: 8 updated: 2011/06/04 20:09:13
 724 dnl ---------------
 725 dnl Determine the default configuration into which we'll install ncurses.  This
 726 dnl can be overridden by the user's command-line options.  There's two items to
 727 dnl look for:
 728 dnl     1. the prefix (e.g., /usr)
 729 dnl     2. the header files (e.g., /usr/include/ncurses)
 730 dnl We'll look for a previous installation of ncurses and use the same defaults.
 731 dnl
 732 dnl We don't use AC_PREFIX_DEFAULT, because it gets evaluated too soon, and
 733 dnl we don't use AC_PREFIX_PROGRAM, because we cannot distinguish ncurses's
 734 dnl programs from a vendor's.
 735 AC_DEFUN([CF_CFG_DEFAULTS],
 736 [
 737 AC_MSG_CHECKING(for prefix)
 738 if test "x$prefix" = "xNONE" ; then
 739         case "$cf_cv_system_name" in
 740                 # non-vendor systems don't have a conflict
 741         openbsd*|freebsd*|mirbsd*|linux*|cygwin*|k*bsd*-gnu)
 742                 prefix=/usr
 743                 ;;
 744         *)      prefix=$ac_default_prefix
 745                 ;;
 746         esac
 747 fi
 748 AC_MSG_RESULT($prefix)
 749
 750 if test "x$prefix" = "xNONE" ; then
 751 AC_MSG_CHECKING(for default include-directory)
 752 test -n "$verbose" && echo 1>&AC_FD_MSG
 753 for cf_symbol in \
 754         $includedir \
 755         $includedir/ncurses \
 756         $prefix/include \
 757         $prefix/include/ncurses \
 758         /usr/local/include \
 759         /usr/local/include/ncurses \
 760         /usr/include \
 761         /usr/include/ncurses
 762 do
 763         cf_dir=`eval echo $cf_symbol`
 764         if test -f $cf_dir/curses.h ; then
 765         if ( fgrep NCURSES_VERSION $cf_dir/curses.h 2>&1 >/dev/null ) ; then
 766                 includedir="$cf_symbol"
 767                 test -n "$verbose"  && echo $ac_n "     found " 1>&AC_FD_MSG
 768                 break
 769         fi
 770         fi
 771         test -n "$verbose"  && echo "   tested $cf_dir" 1>&AC_FD_MSG
 772 done
 773 AC_MSG_RESULT($includedir)
 774 fi
 775 ])dnl
 776 dnl ---------------------------------------------------------------------------
 777 dnl CF_CGETENT version: 3 updated: 2000/08/12 23:18:52
 778 dnl ----------
 779 dnl Check if the terminal-capability database functions are available.  If not,
 780 dnl ncurses has a much-reduced version.
 781 AC_DEFUN([CF_CGETENT],[
 782 AC_MSG_CHECKING(for terminal-capability database functions)
 783 AC_CACHE_VAL(cf_cv_cgetent,[
 784 AC_TRY_LINK([
 785 #include <stdlib.h>],[
 786         char temp[128];
 787         char *buf = temp;
 788         char *db_array = temp;
 789         cgetent(&buf, /* int *, */ &db_array, "vt100");
 790         cgetcap(buf, "tc", '=');
 791         cgetmatch(buf, "tc");
 792         ],
 793         [cf_cv_cgetent=yes],
 794         [cf_cv_cgetent=no])
 795 ])
 796 AC_MSG_RESULT($cf_cv_cgetent)
 797 test "$cf_cv_cgetent" = yes && AC_DEFINE(HAVE_BSD_CGETENT)
 798 ])dnl
 799 dnl ---------------------------------------------------------------------------
 800 dnl CF_CHECK_CACHE version: 11 updated: 2008/03/23 14:45:59
 801 dnl --------------
 802 dnl Check if we're accidentally using a cache from a different machine.
 803 dnl Derive the system name, as a check for reusing the autoconf cache.
 804 dnl
 805 dnl If we've packaged config.guess and config.sub, run that (since it does a
 806 dnl better job than uname).  Normally we'll use AC_CANONICAL_HOST, but allow
 807 dnl an extra parameter that we may override, e.g., for AC_CANONICAL_SYSTEM
 808 dnl which is useful in cross-compiles.
 809 dnl
 810 dnl Note: we would use $ac_config_sub, but that is one of the places where
 811 dnl autoconf 2.5x broke compatibility with autoconf 2.13
 812 AC_DEFUN([CF_CHECK_CACHE],
 813 [
 814 if test -f $srcdir/config.guess || test -f $ac_aux_dir/config.guess ; then
 815         ifelse([$1],,[AC_CANONICAL_HOST],[$1])
 816         system_name="$host_os"
 817 else
 818         system_name="`(uname -s -r) 2>/dev/null`"
 819         if test -z "$system_name" ; then
 820                 system_name="`(hostname) 2>/dev/null`"
 821         fi
 822 fi
 823 test -n "$system_name" && AC_DEFINE_UNQUOTED(SYSTEM_NAME,"$system_name")
 824 AC_CACHE_VAL(cf_cv_system_name,[cf_cv_system_name="$system_name"])
 825
 826 test -z "$system_name" && system_name="$cf_cv_system_name"
 827 test -n "$cf_cv_system_name" && AC_MSG_RESULT(Configuring for $cf_cv_system_name)
 828
 829 if test ".$system_name" != ".$cf_cv_system_name" ; then
 830         AC_MSG_RESULT(Cached system name ($system_name) does not agree with actual ($cf_cv_system_name))
 831         AC_MSG_ERROR("Please remove config.cache and try again.")
 832 fi
 833 ])dnl
 834 dnl ---------------------------------------------------------------------------
 835 dnl CF_CHECK_ERRNO version: 11 updated: 2010/05/26 05:38:42
 836 dnl --------------
 837 dnl Check for data that is usually declared in <stdio.h> or <errno.h>, e.g.,
 838 dnl the 'errno' variable.  Define a DECL_xxx symbol if we must declare it
 839 dnl ourselves.
 840 dnl
 841 dnl $1 = the name to check
 842 dnl $2 = the assumed type
 843 AC_DEFUN([CF_CHECK_ERRNO],
 844 [
 845 AC_CACHE_CHECK(if external $1 is declared, cf_cv_dcl_$1,[
 846     AC_TRY_COMPILE([
 847 #ifdef HAVE_STDLIB_H
 848 #include <stdlib.h>
 849 #endif
 850 #include <stdio.h>
 851 #include <sys/types.h>
 852 #include <errno.h> ],
 853     ifelse([$2],,int,[$2]) x = (ifelse([$2],,int,[$2])) $1,
 854     [cf_cv_dcl_$1=yes],
 855     [cf_cv_dcl_$1=no])
 856 ])
 857
 858 if test "$cf_cv_dcl_$1" = no ; then
 859     CF_UPPER(cf_result,decl_$1)
 860     AC_DEFINE_UNQUOTED($cf_result)
 861 fi
 862
 863 # It's possible (for near-UNIX clones) that the data doesn't exist
 864 CF_CHECK_EXTERN_DATA($1,ifelse([$2],,int,[$2]))
 865 ])dnl
 866 dnl ---------------------------------------------------------------------------
 867 dnl CF_CHECK_EXTERN_DATA version: 3 updated: 2001/12/30 18:03:23
 868 dnl --------------------
 869 dnl Check for existence of external data in the current set of libraries.  If
 870 dnl we can modify it, it's real enough.
 871 dnl $1 = the name to check
 872 dnl $2 = its type
 873 AC_DEFUN([CF_CHECK_EXTERN_DATA],
 874 [
 875 AC_CACHE_CHECK(if external $1 exists, cf_cv_have_$1,[
 876     AC_TRY_LINK([
 877 #undef $1
 878 extern $2 $1;
 879 ],
 880     [$1 = 2],
 881     [cf_cv_have_$1=yes],
 882     [cf_cv_have_$1=no])
 883 ])
 884
 885 if test "$cf_cv_have_$1" = yes ; then
 886     CF_UPPER(cf_result,have_$1)
 887     AC_DEFINE_UNQUOTED($cf_result)
 888 fi
 889
 890 ])dnl
 891 dnl ---------------------------------------------------------------------------
 892 dnl CF_CHECK_GPM_WGETCH version: 2 updated: 2010/08/14 18:25:37
 893 dnl -------------------
 894 dnl Check if GPM is already linked with curses.  If so - and if the linkage
 895 dnl is not "weak" - warn about this because it can create problems linking
 896 dnl applications with ncurses.
 897 AC_DEFUN([CF_CHECK_GPM_WGETCH],[
 898 AC_CHECK_LIB(gpm,Gpm_Wgetch,[
 899
 900 AC_CACHE_CHECK(if GPM is weakly bound to curses library, cf_cv_check_gpm_wgetch,[
 901 cf_cv_check_gpm_wgetch=unknown
 902 if test "$cross_compiling" != yes ; then
 903
 904 cat >conftest.$ac_ext <<CF_EOF
 905 #include <gpm.h>
 906 int main()
 907 {
 908         Gpm_Wgetch();
 909         ${cf_cv_main_return:-return}(0);
 910 }
 911 CF_EOF
 912
 913         cf_save_LIBS="$LIBS"
 914         # This only works if we can look at the symbol table.  If a shared
 915         # library is stripped for install, we cannot use that.  So we're forced
 916         # to rely on the static library, noting that some packagers may not
 917         # include it.
 918         LIBS="-static -lgpm -dynamic $LIBS"
 919         if AC_TRY_EVAL(ac_compile) ; then
 920                 if AC_TRY_EVAL(ac_link) ; then
 921                         cf_cv_check_gpm_wgetch=`nm conftest$ac_exeext | egrep '\<wgetch\>' | egrep '\<[[vVwW]]\>'`
 922                         test -n "$cf_cv_check_gpm_wgetch" && cf_cv_check_gpm_wgetch=yes
 923                         test -z "$cf_cv_check_gpm_wgetch" && cf_cv_check_gpm_wgetch=no
 924                 fi
 925         fi
 926         rm -rf conftest*
 927         LIBS="$cf_save_LIBS"
 928 fi
 929 ])
 930
 931 if test "$cf_cv_check_gpm_wgetch" != yes ; then
 932         AC_MSG_WARN(GPM library is already linked with curses - read the FAQ)
 933 fi
 934 ])])dnl
 935 dnl ---------------------------------------------------------------------------
 936 dnl CF_CPP_PARAM_INIT version: 4 updated: 2001/04/07 22:31:18
 937 dnl -----------------
 938 dnl Check if the C++ compiler accepts duplicate parameter initialization.  This
 939 dnl is a late feature for the standard and is not in some recent compilers
 940 dnl (1999/9/11).
 941 AC_DEFUN([CF_CPP_PARAM_INIT],
 942 [
 943 if test -n "$CXX"; then
 944 AC_CACHE_CHECK(if $CXX accepts parameter initialization,cf_cv_cpp_param_init,[
 945         AC_LANG_SAVE
 946         AC_LANG_CPLUSPLUS
 947         AC_TRY_RUN([
 948 class TEST {
 949 private:
 950         int value;
 951 public:
 952         TEST(int x = 1);
 953         ~TEST();
 954 };
 955
 956 TEST::TEST(int x = 1)   // some compilers do not like second initializer
 957 {
 958         value = x;
 959 }
 960 void main() { }
 961 ],
 962         [cf_cv_cpp_param_init=yes],
 963         [cf_cv_cpp_param_init=no],
 964         [cf_cv_cpp_param_init=unknown])
 965         AC_LANG_RESTORE
 966 ])
 967 fi
 968 test "$cf_cv_cpp_param_init" = yes && AC_DEFINE(CPP_HAS_PARAM_INIT)
 969 ])dnl
 970 dnl ---------------------------------------------------------------------------
 971 dnl CF_CPP_STATIC_CAST version: 1 updated: 2005/07/23 16:52:43
 972 dnl ------------------
 973 dnl Check if the C++ compiler accepts static_cast in generics.  This appears to
 974 dnl not be supported in g++ before 3.0
 975 AC_DEFUN([CF_CPP_STATIC_CAST],
 976 [
 977 if test -n "$CXX"; then
 978
 979 AC_CACHE_CHECK(if $CXX accepts static_cast,cf_cv_cpp_static_cast,[
 980         AC_LANG_SAVE
 981         AC_LANG_CPLUSPLUS
 982
 983         AC_TRY_COMPILE([
 984 class NCursesPanel
 985 {
 986 public:
 987   NCursesPanel(int nlines,
 988                int ncols,
 989                int begin_y = 0,
 990                int begin_x = 0)
 991   {
 992   }
 993
 994   ~NCursesPanel();
 995 };
 996
 997 template<class T> class NCursesUserPanel : public NCursesPanel
 998 {
 999 public:
1000   NCursesUserPanel (int nlines,
1001                     int ncols,
1002                     int begin_y = 0,
1003                     int begin_x = 0,
1004                     const T* p_UserData = static_cast<T*>(0))
1005     : NCursesPanel (nlines, ncols, begin_y, begin_x)
1006   {
1007   };
1008   NCursesUserPanel(const T* p_UserData = static_cast<T*>(0)) : NCursesPanel()
1009   {
1010   };
1011
1012   virtual ~NCursesUserPanel() {};
1013 };
1014 ],[
1015         const char* p_UserData = static_cast<char*>(0)],
1016         [cf_cv_cpp_static_cast=yes],
1017         [cf_cv_cpp_static_cast=no])
1018
1019         AC_LANG_RESTORE
1020 ])
1021
1022 fi
1023
1024 test "$cf_cv_cpp_static_cast" = yes && AC_DEFINE(CPP_HAS_STATIC_CAST)
1025 ])dnl
1026 dnl ---------------------------------------------------------------------------
1027 dnl CF_C_INLINE version: 3 updated: 2010/05/01 15:14:41
1028 dnl -----------
1029 dnl Check if the C compiler supports "inline".
1030 dnl $1 is the name of a shell variable to set if inline is supported
1031 dnl $2 is the threshold for gcc 4.x's option controlling maximum inline size
1032 AC_DEFUN([CF_C_INLINE],[
1033 AC_C_INLINE
1034 $1=
1035 if test "$ac_cv_c_inline" != no ; then
1036   $1=inline
1037   if test "$INTEL_COMPILER" = yes
1038   then
1039     :
1040   elif test "$GCC" = yes
1041   then
1042     AC_CACHE_CHECK(if $CC supports options to tune inlining,cf_cv_gcc_inline,[
1043       cf_save_CFLAGS=$CFLAGS
1044       CFLAGS="$CFLAGS --param max-inline-insns-single=$2"
1045       AC_TRY_COMPILE([inline int foo(void) { return 1; }],
1046       [${cf_cv_main_return:-return} foo()],
1047       [cf_cv_gcc_inline=yes],
1048       [cf_cv_gcc_inline=no])
1049       CFLAGS=$cf_save_CFLAGS
1050     ])
1051     if test "$cf_cv_gcc_inline" = yes ; then
1052         CF_ADD_CFLAGS([--param max-inline-insns-single=$2])
1053     fi
1054   fi
1055 fi
1056 AC_SUBST($1)
1057 ])dnl
1058 dnl ---------------------------------------------------------------------------
1059 dnl CF_DIRNAME version: 4 updated: 2002/12/21 19:25:52
1060 dnl ----------
1061 dnl "dirname" is not portable, so we fake it with a shell script.
1062 AC_DEFUN([CF_DIRNAME],[$1=`echo $2 | sed -e 's%/[[^/]]*$%%'`])dnl
1063 dnl ---------------------------------------------------------------------------
1064 dnl CF_DIRS_TO_MAKE version: 3 updated: 2002/02/23 20:38:31
1065 dnl ---------------
1066 AC_DEFUN([CF_DIRS_TO_MAKE],
1067 [
1068 DIRS_TO_MAKE="lib"
1069 for cf_item in $cf_list_models
1070 do
1071         CF_OBJ_SUBDIR($cf_item,cf_subdir)
1072         for cf_item2 in $DIRS_TO_MAKE
1073         do
1074                 test $cf_item2 = $cf_subdir && break
1075         done
1076         test ".$cf_item2" != ".$cf_subdir" && DIRS_TO_MAKE="$DIRS_TO_MAKE $cf_subdir"
1077 done
1078 for cf_dir in $DIRS_TO_MAKE
1079 do
1080         test ! -d $cf_dir && mkdir $cf_dir
1081 done
1082 AC_SUBST(DIRS_TO_MAKE)
1083 ])dnl
1084 dnl ---------------------------------------------------------------------------
1085 dnl CF_DISABLE_LEAKS version: 6 updated: 2010/07/23 04:14:32
1086 dnl ----------------
1087 dnl Combine no-leak checks with the libraries or tools that are used for the
1088 dnl checks.
1089 AC_DEFUN([CF_DISABLE_LEAKS],[
1090
1091 AC_REQUIRE([CF_WITH_DMALLOC])
1092 AC_REQUIRE([CF_WITH_DBMALLOC])
1093 AC_REQUIRE([CF_WITH_VALGRIND])
1094
1095 AC_MSG_CHECKING(if you want to perform memory-leak testing)
1096 AC_ARG_ENABLE(leaks,
1097         [  --disable-leaks         test: free permanent memory, analyze leaks],
1098         [if test "x$enableval" = xno; then with_no_leaks=yes; else with_no_leaks=no; fi],
1099         : ${with_no_leaks:=no})
1100 AC_MSG_RESULT($with_no_leaks)
1101
1102 if test "$with_no_leaks" = yes ; then
1103         AC_DEFINE(NO_LEAKS)
1104         AC_DEFINE(YY_NO_LEAKS)
1105 fi
1106 ])dnl
1107 dnl ---------------------------------------------------------------------------
1108 dnl CF_DISABLE_LIBTOOL_VERSION version: 1 updated: 2010/05/15 15:45:59
1109 dnl --------------------------
1110 dnl Check if we should use the libtool 1.5 feature "-version-number" instead of
1111 dnl the older "-version-info" feature.  The newer feature allows us to use
1112 dnl version numbering on shared libraries which make them compatible with
1113 dnl various systems.
1114 AC_DEFUN([CF_DISABLE_LIBTOOL_VERSION],
1115 [
1116 AC_MSG_CHECKING(if libtool -version-number should be used)
1117 CF_ARG_DISABLE(libtool-version,
1118         [  --disable-libtool-version  enable to use libtool's incompatible naming scheme],
1119         [cf_libtool_version=no],
1120         [cf_libtool_version=yes])
1121 AC_MSG_RESULT($cf_libtool_version)
1122
1123 if test "$cf_libtool_version" = yes ; then
1124         LIBTOOL_VERSION="-version-number"
1125 else
1126         LIBTOOL_VERSION="-version-info"
1127 fi
1128
1129 AC_SUBST(LIBTOOL_VERSION)
1130 ])dnl
1131 dnl ---------------------------------------------------------------------------
1132 dnl CF_DISABLE_RPATH_HACK version: 2 updated: 2011/02/13 13:31:33
1133 dnl ---------------------
1134 dnl The rpath-hack makes it simpler to build programs, particularly with the
1135 dnl *BSD ports which may have essential libraries in unusual places.  But it
1136 dnl can interfere with building an executable for the base system.  Use this
1137 dnl option in that case.
1138 AC_DEFUN([CF_DISABLE_RPATH_HACK],
1139 [
1140 AC_MSG_CHECKING(if rpath-hack should be disabled)
1141 CF_ARG_DISABLE(rpath-hack,
1142         [  --disable-rpath-hack    don't add rpath options for additional libraries],
1143         [cf_disable_rpath_hack=yes],
1144         [cf_disable_rpath_hack=no])
1145 AC_MSG_RESULT($cf_disable_rpath_hack)
1146 if test "$cf_disable_rpath_hack" = no ; then
1147         CF_RPATH_HACK
1148 fi
1149 ])
1150 dnl ---------------------------------------------------------------------------
1151 dnl CF_ENABLE_RPATH version: 2 updated: 2010/03/27 18:39:42
1152 dnl ---------------
1153 dnl Check if the rpath option should be used, setting cache variable
1154 dnl cf_cv_enable_rpath if so.
1155 AC_DEFUN([CF_ENABLE_RPATH],
1156 [
1157 AC_MSG_CHECKING(if rpath option should be used)
1158 AC_ARG_ENABLE(rpath,
1159 [  --enable-rpath          use rpath option when generating shared libraries],
1160 [cf_cv_enable_rpath=$enableval],
1161 [cf_cv_enable_rpath=no])
1162 AC_MSG_RESULT($cf_cv_enable_rpath)
1163 ])dnl
1164 dnl ---------------------------------------------------------------------------
1165 dnl CF_ERRNO version: 5 updated: 1997/11/30 12:44:39
1166 dnl --------
1167 dnl Check if 'errno' is declared in <errno.h>
1168 AC_DEFUN([CF_ERRNO],
1169 [
1170 CF_CHECK_ERRNO(errno)
1171 ])dnl
1172 dnl ---------------------------------------------------------------------------
1173 dnl CF_ETIP_DEFINES version: 3 updated: 2003/03/22 19:13:43
1174 dnl ---------------
1175 dnl Test for conflicting definitions of exception in gcc 2.8.0, etc., between
1176 dnl math.h and builtin.h, only for ncurses
1177 AC_DEFUN([CF_ETIP_DEFINES],
1178 [
1179 AC_MSG_CHECKING(for special defines needed for etip.h)
1180 cf_save_CXXFLAGS="$CXXFLAGS"
1181 cf_result="none"
1182 for cf_math in "" MATH_H
1183 do
1184 for cf_excp in "" MATH_EXCEPTION
1185 do
1186         CXXFLAGS="$cf_save_CXXFLAGS -I${srcdir}/c++ -I${srcdir}/menu -I${srcdir}/include"
1187         test -n "$cf_math" && CXXFLAGS="$CXXFLAGS -DETIP_NEEDS_${cf_math}"
1188         test -n "$cf_excp" && CXXFLAGS="$CXXFLAGS -DETIP_NEEDS_${cf_excp}"
1189 AC_TRY_COMPILE([
1190 #include <etip.h.in>
1191 ],[],[
1192         test -n "$cf_math" && AC_DEFINE_UNQUOTED(ETIP_NEEDS_${cf_math})
1193         test -n "$cf_excp" && AC_DEFINE_UNQUOTED(ETIP_NEEDS_${cf_excp})
1194         cf_result="$cf_math $cf_excp"
1195         break
1196 ],[])
1197 done
1198 done
1199 AC_MSG_RESULT($cf_result)
1200 CXXFLAGS="$cf_save_CXXFLAGS"
1201 ])
1202 dnl ---------------------------------------------------------------------------
1203 dnl CF_FIND_LINKAGE version: 19 updated: 2010/05/29 16:31:02
1204 dnl ---------------
1205 dnl Find a library (specifically the linkage used in the code fragment),
1206 dnl searching for it if it is not already in the library path.
1207 dnl See also CF_ADD_SEARCHPATH.
1208 dnl
1209 dnl Parameters (4-on are optional):
1210 dnl     $1 = headers for library entrypoint
1211 dnl     $2 = code fragment for library entrypoint
1212 dnl     $3 = the library name without the "-l" option or ".so" suffix.
1213 dnl     $4 = action to perform if successful (default: update CPPFLAGS, etc)
1214 dnl     $5 = action to perform if not successful
1215 dnl     $6 = module name, if not the same as the library name
1216 dnl     $7 = extra libraries
1217 dnl
1218 dnl Sets these variables:
1219 dnl     $cf_cv_find_linkage_$3 - yes/no according to whether linkage is found
1220 dnl     $cf_cv_header_path_$3 - include-directory if needed
1221 dnl     $cf_cv_library_path_$3 - library-directory if needed
1222 dnl     $cf_cv_library_file_$3 - library-file if needed, e.g., -l$3
1223 AC_DEFUN([CF_FIND_LINKAGE],[
1224
1225 # If the linkage is not already in the $CPPFLAGS/$LDFLAGS configuration, these
1226 # will be set on completion of the AC_TRY_LINK below.
1227 cf_cv_header_path_$3=
1228 cf_cv_library_path_$3=
1229
1230 CF_MSG_LOG([Starting [FIND_LINKAGE]($3,$6)])
1231
1232 cf_save_LIBS="$LIBS"
1233
1234 AC_TRY_LINK([$1],[$2],[
1235         cf_cv_find_linkage_$3=yes
1236         cf_cv_header_path_$3=/usr/include
1237         cf_cv_library_path_$3=/usr/lib
1238 ],[
1239
1240 LIBS="-l$3 $7 $cf_save_LIBS"
1241
1242 AC_TRY_LINK([$1],[$2],[
1243         cf_cv_find_linkage_$3=yes
1244         cf_cv_header_path_$3=/usr/include
1245         cf_cv_library_path_$3=/usr/lib
1246         cf_cv_library_file_$3="-l$3"
1247 ],[
1248         cf_cv_find_linkage_$3=no
1249         LIBS="$cf_save_LIBS"
1250
1251     CF_VERBOSE(find linkage for $3 library)
1252     CF_MSG_LOG([Searching for headers in [FIND_LINKAGE]($3,$6)])
1253
1254     cf_save_CPPFLAGS="$CPPFLAGS"
1255     cf_test_CPPFLAGS="$CPPFLAGS"
1256
1257     CF_HEADER_PATH(cf_search,ifelse([$6],,[$3],[$6]))
1258     for cf_cv_header_path_$3 in $cf_search
1259     do
1260       if test -d $cf_cv_header_path_$3 ; then
1261         CF_VERBOSE(... testing $cf_cv_header_path_$3)
1262         CPPFLAGS="$cf_save_CPPFLAGS -I$cf_cv_header_path_$3"
1263         AC_TRY_COMPILE([$1],[$2],[
1264             CF_VERBOSE(... found $3 headers in $cf_cv_header_path_$3)
1265             cf_cv_find_linkage_$3=maybe
1266             cf_test_CPPFLAGS="$CPPFLAGS"
1267             break],[
1268             CPPFLAGS="$cf_save_CPPFLAGS"
1269             ])
1270       fi
1271     done
1272
1273     if test "$cf_cv_find_linkage_$3" = maybe ; then
1274
1275       CF_MSG_LOG([Searching for $3 library in [FIND_LINKAGE]($3,$6)])
1276
1277       cf_save_LIBS="$LIBS"
1278       cf_save_LDFLAGS="$LDFLAGS"
1279
1280       ifelse([$6],,,[
1281         CPPFLAGS="$cf_test_CPPFLAGS"
1282         LIBS="-l$3 $7 $cf_save_LIBS"
1283         AC_TRY_LINK([$1],[$2],[
1284             CF_VERBOSE(... found $3 library in system)
1285             cf_cv_find_linkage_$3=yes])
1286             CPPFLAGS="$cf_save_CPPFLAGS"
1287             LIBS="$cf_save_LIBS"
1288             ])
1289
1290       if test "$cf_cv_find_linkage_$3" != yes ; then
1291         CF_LIBRARY_PATH(cf_search,$3)
1292         for cf_cv_library_path_$3 in $cf_search
1293         do
1294           if test -d $cf_cv_library_path_$3 ; then
1295             CF_VERBOSE(... testing $cf_cv_library_path_$3)
1296             CPPFLAGS="$cf_test_CPPFLAGS"
1297             LIBS="-l$3 $7 $cf_save_LIBS"
1298             LDFLAGS="$cf_save_LDFLAGS -L$cf_cv_library_path_$3"
1299             AC_TRY_LINK([$1],[$2],[
1300                 CF_VERBOSE(... found $3 library in $cf_cv_library_path_$3)
1301                 cf_cv_find_linkage_$3=yes
1302                 cf_cv_library_file_$3="-l$3"
1303                 break],[
1304                 CPPFLAGS="$cf_save_CPPFLAGS"
1305                 LIBS="$cf_save_LIBS"
1306                 LDFLAGS="$cf_save_LDFLAGS"
1307                 ])
1308           fi
1309         done
1310         CPPFLAGS="$cf_save_CPPFLAGS"
1311         LDFLAGS="$cf_save_LDFLAGS"
1312       fi
1313
1314     else
1315       cf_cv_find_linkage_$3=no
1316     fi
1317     ],$7)
1318 ])
1319
1320 LIBS="$cf_save_LIBS"
1321
1322 if test "$cf_cv_find_linkage_$3" = yes ; then
1323 ifelse([$4],,[
1324         CF_ADD_INCDIR($cf_cv_header_path_$3)
1325         CF_ADD_LIBDIR($cf_cv_library_path_$3)
1326         CF_ADD_LIB($3)
1327 ],[$4])
1328 else
1329 ifelse([$5],,AC_MSG_WARN(Cannot find $3 library),[$5])
1330 fi
1331 ])dnl
1332 dnl ---------------------------------------------------------------------------
1333 dnl CF_FUNC_DLSYM version: 2 updated: 2010/05/29 16:31:02
1334 dnl -------------
1335 dnl Test for dlsym() and related functions, as well as libdl.
1336 dnl
1337 dnl Sets
1338 dnl     $cf_have_dlsym
1339 dnl     $cf_have_libdl
1340 AC_DEFUN([CF_FUNC_DLSYM],[
1341 cf_have_dlsym=no
1342 AC_CHECK_FUNC(dlsym,cf_have_dlsym=yes,[
1343
1344 cf_have_libdl=no
1345 AC_CHECK_LIB(dl,dlsym,[
1346         cf_have_dlsym=yes
1347         cf_have_libdl=yes])])
1348
1349 if test "$cf_have_dlsym" = yes ; then
1350         test "$cf_have_libdl" = yes && CF_ADD_LIB(dl)
1351
1352         AC_MSG_CHECKING(whether able to link to dl*() functions)
1353         AC_TRY_LINK([#include <dlfcn.h>],[
1354                 void *obj;
1355                 if ((obj = dlopen("filename", 0)) != 0) {
1356                         if (dlsym(obj, "symbolname") == 0) {
1357                         dlclose(obj);
1358                         }
1359                 }],[
1360                 AC_DEFINE(HAVE_LIBDL)],[
1361                 AC_MSG_ERROR(Cannot link test program for libdl)])
1362         AC_MSG_RESULT(ok)
1363 else
1364         AC_MSG_ERROR(Cannot find dlsym function)
1365 fi
1366 ])
1367 dnl ---------------------------------------------------------------------------
1368 dnl CF_FUNC_MEMMOVE version: 7 updated: 2006/12/16 12:33:30
1369 dnl ---------------
1370 dnl Check for memmove, or a bcopy that can handle overlapping copy.  If neither
1371 dnl is found, add our own version of memmove to the list of objects.
1372 AC_DEFUN([CF_FUNC_MEMMOVE],
1373 [
1374 AC_CHECK_FUNC(memmove,,[
1375 AC_CHECK_FUNC(bcopy,[
1376         AC_CACHE_CHECK(if bcopy does overlapping moves,cf_cv_good_bcopy,[
1377                 AC_TRY_RUN([
1378 int main() {
1379         static char data[] = "abcdefghijklmnopqrstuwwxyz";
1380         char temp[40];
1381         bcopy(data, temp, sizeof(data));
1382         bcopy(temp+10, temp, 15);
1383         bcopy(temp+5, temp+15, 10);
1384         ${cf_cv_main_return:-return} (strcmp(temp, "klmnopqrstuwwxypqrstuwwxyz"));
1385 }
1386                 ],
1387                 [cf_cv_good_bcopy=yes],
1388                 [cf_cv_good_bcopy=no],
1389                 [cf_cv_good_bcopy=unknown])
1390                 ])
1391         ],[cf_cv_good_bcopy=no])
1392         if test "$cf_cv_good_bcopy" = yes ; then
1393                 AC_DEFINE(USE_OK_BCOPY)
1394         else
1395                 AC_DEFINE(USE_MY_MEMMOVE)
1396         fi
1397 ])])dnl
1398 dnl ---------------------------------------------------------------------------
1399 dnl CF_FUNC_NANOSLEEP version: 3 updated: 2006/12/16 12:33:30
1400 dnl -----------------
1401 dnl Check for existence of workable nanosleep() function.  Some systems, e.g.,
1402 dnl AIX 4.x, provide a non-working version.
1403 AC_DEFUN([CF_FUNC_NANOSLEEP],[
1404 AC_CACHE_CHECK(if nanosleep really works,cf_cv_func_nanosleep,[
1405 AC_TRY_RUN([
1406 #include <stdio.h>
1407 #include <errno.h>
1408 #include <time.h>
1409
1410 #ifdef HAVE_SYS_TIME_H
1411 #include <sys/time.h>
1412 #endif
1413
1414 int main() {
1415         struct timespec ts1, ts2;
1416         int code;
1417         ts1.tv_sec  = 0;
1418         ts1.tv_nsec = 750000000;
1419         ts2.tv_sec  = 0;
1420         ts2.tv_nsec = 0;
1421         errno = 0;
1422         code = nanosleep(&ts1, &ts2); /* on failure errno is ENOSYS. */
1423         ${cf_cv_main_return:-return}(code != 0);
1424 }
1425 ],
1426         [cf_cv_func_nanosleep=yes],
1427         [cf_cv_func_nanosleep=no],
1428         [cf_cv_func_nanosleep=unknown])])
1429
1430 test "$cf_cv_func_nanosleep" = "yes" && AC_DEFINE(HAVE_NANOSLEEP)
1431 ])
1432 dnl ---------------------------------------------------------------------------
1433 dnl CF_FUNC_OPENPTY version: 3 updated: 2010/05/29 16:31:02
1434 dnl ---------------
1435 dnl Check for openpty() function, along with <pty.h> header.  It may need the
1436 dnl "util" library as well.
1437 AC_DEFUN([CF_FUNC_OPENPTY],
1438 [
1439 AC_CHECK_LIB(util,openpty,cf_cv_lib_util=yes,cf_cv_lib_util=no)
1440 AC_CACHE_CHECK(for openpty header,cf_cv_func_openpty,[
1441     cf_save_LIBS="$LIBS"
1442     test $cf_cv_lib_util = yes && CF_ADD_LIB(util)
1443     for cf_header in pty.h libutil.h util.h
1444     do
1445     AC_TRY_LINK([
1446 #include <$cf_header>
1447 ],[
1448     int x = openpty((int *)0, (int *)0, (char *)0,
1449                    (struct termios *)0, (struct winsize *)0);
1450 ],[
1451         cf_cv_func_openpty=$cf_header
1452         break
1453 ],[
1454         cf_cv_func_openpty=no
1455 ])
1456     done
1457     LIBS="$cf_save_LIBS"
1458 ])
1459 ])dnl
1460 dnl ---------------------------------------------------------------------------
1461 dnl CF_FUNC_POLL version: 4 updated: 2006/12/16 12:33:30
1462 dnl ------------
1463 dnl See if the poll function really works.  Some platforms have poll(), but
1464 dnl it does not work for terminals or files.
1465 AC_DEFUN([CF_FUNC_POLL],[
1466 AC_CACHE_CHECK(if poll really works,cf_cv_working_poll,[
1467 AC_TRY_RUN([
1468 #include <stdio.h>
1469 #ifdef HAVE_POLL_H
1470 #include <poll.h>
1471 #else
1472 #include <sys/poll.h>
1473 #endif
1474 int main() {
1475         struct pollfd myfds;
1476         int ret;
1477
1478         myfds.fd = 0;
1479         myfds.events = POLLIN;
1480
1481         ret = poll(&myfds, 1, 100);
1482         ${cf_cv_main_return:-return}(ret != 0);
1483 }],
1484         [cf_cv_working_poll=yes],
1485         [cf_cv_working_poll=no],
1486         [cf_cv_working_poll=unknown])])
1487 test "$cf_cv_working_poll" = "yes" && AC_DEFINE(HAVE_WORKING_POLL)
1488 ])dnl
1489 dnl ---------------------------------------------------------------------------
1490 dnl CF_FUNC_TERMIOS version: 2 updated: 2000/07/22 23:37:24
1491 dnl ---------------
1492 dnl Some old/broken variations define tcgetattr() only as a macro in
1493 dnl termio(s).h
1494 AC_DEFUN([CF_FUNC_TERMIOS],[
1495 AC_REQUIRE([CF_STRUCT_TERMIOS])
1496 AC_CACHE_CHECK(for tcgetattr, cf_cv_have_tcgetattr,[
1497 AC_TRY_LINK([
1498 #include <sys/types.h>
1499 #ifdef HAVE_UNISTD_H
1500 #include <unistd.h>
1501 #endif
1502 #ifdef HAVE_TERMIOS_H
1503 #include <termios.h>
1504 #define TTY struct termios
1505 #else
1506 #ifdef HAVE_TERMIO_H
1507 #include <termio.h>
1508 #define TTY struct termio
1509 #endif
1510 #endif
1511 ],[
1512 TTY foo;
1513 tcgetattr(1, &foo);],
1514 [cf_cv_have_tcgetattr=yes],
1515 [cf_cv_have_tcgetattr=no])])
1516 test "$cf_cv_have_tcgetattr" = yes && AC_DEFINE(HAVE_TCGETATTR)
1517 ])dnl
1518 dnl ---------------------------------------------------------------------------
1519 dnl CF_FUNC_VSSCANF version: 3 updated: 2001/12/19 00:50:10
1520 dnl ---------------
1521 dnl Check for vsscanf() function, which is in c9x but generally not in earlier
1522 dnl versions of C.  It is in the GNU C library, and can often be simulated by
1523 dnl other functions.
1524 AC_DEFUN([CF_FUNC_VSSCANF],
1525 [
1526 AC_CACHE_CHECK(for vsscanf function or workaround,cf_cv_func_vsscanf,[
1527 AC_TRY_LINK([
1528 #include <stdarg.h>
1529 #include <stdio.h>],[
1530         va_list ap;
1531         vsscanf("from", "%d", ap)],[cf_cv_func_vsscanf=vsscanf],[
1532 AC_TRY_LINK([
1533 #include <stdarg.h>
1534 #include <stdio.h>],[
1535     FILE strbuf;
1536     char *str = "from";
1537
1538     strbuf._flag = _IOREAD;
1539     strbuf._ptr = strbuf._base = (unsigned char *) str;
1540     strbuf._cnt = strlen(str);
1541     strbuf._file = _NFILE;
1542     return (vfscanf(&strbuf, "%d", ap))],[cf_cv_func_vsscanf=vfscanf],[
1543 AC_TRY_LINK([
1544 #include <stdarg.h>
1545 #include <stdio.h>],[
1546     FILE strbuf;
1547     char *str = "from";
1548
1549     strbuf._flag = _IOREAD;
1550     strbuf._ptr = strbuf._base = (unsigned char *) str;
1551     strbuf._cnt = strlen(str);
1552     strbuf._file = _NFILE;
1553     return (_doscan(&strbuf, "%d", ap))],[cf_cv_func_vsscanf=_doscan],[
1554 cf_cv_func_vsscanf=no])])])])
1555
1556 case $cf_cv_func_vsscanf in #(vi
1557 vsscanf) AC_DEFINE(HAVE_VSSCANF);; #(vi
1558 vfscanf) AC_DEFINE(HAVE_VFSCANF);; #(vi
1559 _doscan) AC_DEFINE(HAVE__DOSCAN);;
1560 esac
1561
1562 ])dnl
1563 dnl ---------------------------------------------------------------------------
1564 dnl CF_GCC_ATTRIBUTES version: 14 updated: 2010/10/23 15:52:32
1565 dnl -----------------
1566 dnl Test for availability of useful gcc __attribute__ directives to quiet
1567 dnl compiler warnings.  Though useful, not all are supported -- and contrary
1568 dnl to documentation, unrecognized directives cause older compilers to barf.
1569 AC_DEFUN([CF_GCC_ATTRIBUTES],
1570 [
1571 if test "$GCC" = yes
1572 then
1573 cat > conftest.i <<EOF
1574 #ifndef GCC_PRINTF
1575 #define GCC_PRINTF 0
1576 #endif
1577 #ifndef GCC_SCANF
1578 #define GCC_SCANF 0
1579 #endif
1580 #ifndef GCC_NORETURN
1581 #define GCC_NORETURN /* nothing */
1582 #endif
1583 #ifndef GCC_UNUSED
1584 #define GCC_UNUSED /* nothing */
1585 #endif
1586 EOF
1587 if test "$GCC" = yes
1588 then
1589         AC_CHECKING([for $CC __attribute__ directives])
1590 cat > conftest.$ac_ext <<EOF
1591 #line __oline__ "${as_me:-configure}"
1592 #include "confdefs.h"
1593 #include "conftest.h"
1594 #include "conftest.i"
1595 #if     GCC_PRINTF
1596 #define GCC_PRINTFLIKE(fmt,var) __attribute__((format(printf,fmt,var)))
1597 #else
1598 #define GCC_PRINTFLIKE(fmt,var) /*nothing*/
1599 #endif
1600 #if     GCC_SCANF
1601 #define GCC_SCANFLIKE(fmt,var)  __attribute__((format(scanf,fmt,var)))
1602 #else
1603 #define GCC_SCANFLIKE(fmt,var)  /*nothing*/
1604 #endif
1605 extern void wow(char *,...) GCC_SCANFLIKE(1,2);
1606 extern void oops(char *,...) GCC_PRINTFLIKE(1,2) GCC_NORETURN;
1607 extern void foo(void) GCC_NORETURN;
1608 int main(int argc GCC_UNUSED, char *argv[[]] GCC_UNUSED) { return 0; }
1609 EOF
1610         cf_printf_attribute=no
1611         cf_scanf_attribute=no
1612         for cf_attribute in scanf printf unused noreturn
1613         do
1614                 CF_UPPER(cf_ATTRIBUTE,$cf_attribute)
1615                 cf_directive="__attribute__(($cf_attribute))"
1616                 echo "checking for $CC $cf_directive" 1>&AC_FD_CC
1617
1618                 case $cf_attribute in #(vi
1619                 printf) #(vi
1620                         cf_printf_attribute=yes
1621                         cat >conftest.h <<EOF
1622 #define GCC_$cf_ATTRIBUTE 1
1623 EOF
1624                         ;;
1625                 scanf) #(vi
1626                         cf_scanf_attribute=yes
1627                         cat >conftest.h <<EOF
1628 #define GCC_$cf_ATTRIBUTE 1
1629 EOF
1630                         ;;
1631                 *) #(vi
1632                         cat >conftest.h <<EOF
1633 #define GCC_$cf_ATTRIBUTE $cf_directive
1634 EOF
1635                         ;;
1636                 esac
1637
1638                 if AC_TRY_EVAL(ac_compile); then
1639                         test -n "$verbose" && AC_MSG_RESULT(... $cf_attribute)
1640                         cat conftest.h >>confdefs.h
1641                         case $cf_attribute in #(vi
1642                         printf) #(vi
1643                                 if test "$cf_printf_attribute" = no ; then
1644                                         cat >>confdefs.h <<EOF
1645 #define GCC_PRINTFLIKE(fmt,var) /* nothing */
1646 EOF
1647                                 else
1648                                         cat >>confdefs.h <<EOF
1649 #define GCC_PRINTFLIKE(fmt,var) __attribute__((format(printf,fmt,var)))
1650 EOF
1651                                 fi
1652                                 ;;
1653                         scanf) #(vi
1654                                 if test "$cf_scanf_attribute" = no ; then
1655                                         cat >>confdefs.h <<EOF
1656 #define GCC_SCANFLIKE(fmt,var) /* nothing */
1657 EOF
1658                                 else
1659                                         cat >>confdefs.h <<EOF
1660 #define GCC_SCANFLIKE(fmt,var)  __attribute__((format(scanf,fmt,var)))
1661 EOF
1662                                 fi
1663                                 ;;
1664                         esac
1665                 fi
1666         done
1667 else
1668         fgrep define conftest.i >>confdefs.h
1669 fi
1670 rm -rf conftest*
1671 fi
1672 ])dnl
1673 dnl ---------------------------------------------------------------------------
1674 dnl CF_GCC_VERSION version: 5 updated: 2010/04/24 11:02:31
1675 dnl --------------
1676 dnl Find version of gcc
1677 AC_DEFUN([CF_GCC_VERSION],[
1678 AC_REQUIRE([AC_PROG_CC])
1679 GCC_VERSION=none
1680 if test "$GCC" = yes ; then
1681         AC_MSG_CHECKING(version of $CC)
1682         GCC_VERSION="`${CC} --version 2>/dev/null | sed -e '2,$d' -e 's/^.*(GCC) //' -e 's/^[[^0-9.]]*//' -e 's/[[^0-9.]].*//'`"
1683         test -z "$GCC_VERSION" && GCC_VERSION=unknown
1684         AC_MSG_RESULT($GCC_VERSION)
1685 fi
1686 ])dnl
1687 dnl ---------------------------------------------------------------------------
1688 dnl CF_GCC_WARNINGS version: 27 updated: 2010/10/23 15:52:32
1689 dnl ---------------
1690 dnl Check if the compiler supports useful warning options.  There's a few that
1691 dnl we don't use, simply because they're too noisy:
1692 dnl
1693 dnl     -Wconversion (useful in older versions of gcc, but not in gcc 2.7.x)
1694 dnl     -Wredundant-decls (system headers make this too noisy)
1695 dnl     -Wtraditional (combines too many unrelated messages, only a few useful)
1696 dnl     -Wwrite-strings (too noisy, but should review occasionally).  This
1697 dnl             is enabled for ncurses using "--enable-const".
1698 dnl     -pedantic
1699 dnl
1700 dnl Parameter:
1701 dnl     $1 is an optional list of gcc warning flags that a particular
1702 dnl             application might want to use, e.g., "no-unused" for
1703 dnl             -Wno-unused
1704 dnl Special:
1705 dnl     If $with_ext_const is "yes", add a check for -Wwrite-strings
1706 dnl
1707 AC_DEFUN([CF_GCC_WARNINGS],
1708 [
1709 AC_REQUIRE([CF_GCC_VERSION])
1710 CF_INTEL_COMPILER(GCC,INTEL_COMPILER,CFLAGS)
1711
1712 cat > conftest.$ac_ext <<EOF
1713 #line __oline__ "${as_me:-configure}"
1714 int main(int argc, char *argv[[]]) { return (argv[[argc-1]] == 0) ; }
1715 EOF
1716
1717 if test "$INTEL_COMPILER" = yes
1718 then
1719 # The "-wdXXX" options suppress warnings:
1720 # remark #1419: external declaration in primary source file
1721 # remark #1683: explicit conversion of a 64-bit integral type to a smaller integral type (potential portability problem)
1722 # remark #1684: conversion from pointer to same-sized integral type (potential portability problem)
1723 # remark #193: zero used for undefined preprocessing identifier
1724 # remark #593: variable "curs_sb_left_arrow" was set but never used
1725 # remark #810: conversion from "int" to "Dimension={unsigned short}" may lose significant bits
1726 # remark #869: parameter "tw" was never referenced
1727 # remark #981: operands are evaluated in unspecified order
1728 # warning #279: controlling expression is constant
1729
1730         AC_CHECKING([for $CC warning options])
1731         cf_save_CFLAGS="$CFLAGS"
1732         EXTRA_CFLAGS="-Wall"
1733         for cf_opt in \
1734                 wd1419 \
1735                 wd1683 \
1736                 wd1684 \
1737                 wd193 \
1738                 wd593 \
1739                 wd279 \
1740                 wd810 \
1741                 wd869 \
1742                 wd981
1743         do
1744                 CFLAGS="$cf_save_CFLAGS $EXTRA_CFLAGS -$cf_opt"
1745                 if AC_TRY_EVAL(ac_compile); then
1746                         test -n "$verbose" && AC_MSG_RESULT(... -$cf_opt)
1747                         EXTRA_CFLAGS="$EXTRA_CFLAGS -$cf_opt"
1748                 fi
1749         done
1750         CFLAGS="$cf_save_CFLAGS"
1751
1752 elif test "$GCC" = yes
1753 then
1754         AC_CHECKING([for $CC warning options])
1755         cf_save_CFLAGS="$CFLAGS"
1756         EXTRA_CFLAGS=
1757         cf_warn_CONST=""
1758         test "$with_ext_const" = yes && cf_warn_CONST="Wwrite-strings"
1759         for cf_opt in W Wall \
1760                 Wbad-function-cast \
1761                 Wcast-align \
1762                 Wcast-qual \
1763                 Winline \
1764                 Wmissing-declarations \
1765                 Wmissing-prototypes \
1766                 Wnested-externs \
1767                 Wpointer-arith \
1768                 Wshadow \
1769                 Wstrict-prototypes \
1770                 Wundef $cf_warn_CONST $1
1771         do
1772                 CFLAGS="$cf_save_CFLAGS $EXTRA_CFLAGS -$cf_opt"
1773                 if AC_TRY_EVAL(ac_compile); then
1774                         test -n "$verbose" && AC_MSG_RESULT(... -$cf_opt)
1775                         case $cf_opt in #(vi
1776                         Wcast-qual) #(vi
1777                                 CPPFLAGS="$CPPFLAGS -DXTSTRINGDEFINES"
1778                                 ;;
1779                         Winline) #(vi
1780                                 case $GCC_VERSION in
1781                                 [[34]].*)
1782                                         CF_VERBOSE(feature is broken in gcc $GCC_VERSION)
1783                                         continue;;
1784                                 esac
1785                                 ;;
1786                         esac
1787                         EXTRA_CFLAGS="$EXTRA_CFLAGS -$cf_opt"
1788                 fi
1789         done
1790         CFLAGS="$cf_save_CFLAGS"
1791 fi
1792 rm -rf conftest*
1793
1794 AC_SUBST(EXTRA_CFLAGS)
1795 ])dnl
1796 dnl ---------------------------------------------------------------------------
1797 dnl CF_GETOPT_HEADER version: 4 updated: 2009/08/31 20:07:52
1798 dnl ----------------
1799 dnl Check for getopt's variables which are commonly defined in stdlib.h,
1800 dnl unistd.h or (nonstandard) in getopt.h
1801 AC_DEFUN([CF_GETOPT_HEADER],
1802 [
1803 AC_HAVE_HEADERS(unistd.h getopt.h)
1804 AC_CACHE_CHECK(for header declaring getopt variables,cf_cv_getopt_header,[
1805 cf_cv_getopt_header=none
1806 for cf_header in stdio.h stdlib.h unistd.h getopt.h
1807 do
1808 AC_TRY_COMPILE([
1809 #include <$cf_header>],
1810 [int x = optind; char *y = optarg],
1811 [cf_cv_getopt_header=$cf_header
1812  break])
1813 done
1814 ])
1815 if test $cf_cv_getopt_header != none ; then
1816         AC_DEFINE(HAVE_GETOPT_HEADER)
1817 fi
1818 ])dnl
1819 dnl ---------------------------------------------------------------------------
1820 dnl CF_GNAT_GENERICS version: 2 updated: 2011/03/23 20:24:41
1821 dnl ----------------
1822 AC_DEFUN([CF_GNAT_GENERICS],
1823 [
1824 AC_REQUIRE([CF_GNAT_VERSION])
1825
1826 AC_MSG_CHECKING(if GNAT supports generics)
1827 case $cf_gnat_version in #(vi
1828 3.[[1-9]]*|[[4-9]].*) #(vi
1829         cf_gnat_generics=yes
1830         ;;
1831 *)
1832         cf_gnat_generics=no
1833         ;;
1834 esac
1835 AC_MSG_RESULT($cf_gnat_generics)
1836
1837 if test "$cf_gnat_generics" = yes
1838 then
1839         cf_compile_generics=generics
1840         cf_generic_objects="\${GENOBJS}"
1841 else
1842         cf_compile_generics=
1843         cf_generic_objects=
1844 fi
1845
1846 AC_SUBST(cf_compile_generics)
1847 AC_SUBST(cf_generic_objects)
1848 ])dnl
1849 dnl ---------------------------------------------------------------------------
1850 dnl CF_GNAT_PRAGMA_UNREF version: 1 updated: 2010/06/19 15:22:18
1851 dnl --------------------
1852 dnl Check if the gnat pragma "Unreferenced" works.
1853 AC_DEFUN([CF_GNAT_PRAGMA_UNREF],[
1854 AC_CACHE_CHECK(if GNAT pragma Unreferenced works,cf_cv_pragma_unreferenced,[
1855 CF_GNAT_TRY_LINK([procedure conftest;],
1856 [with Text_IO;
1857 with GNAT.OS_Lib;
1858 procedure conftest is
1859    test : Integer;
1860    pragma Unreferenced (test);
1861 begin
1862    test := 1;
1863    Text_IO.Put ("Hello World");
1864    Text_IO.New_Line;
1865    GNAT.OS_Lib.OS_Exit (0);
1866 end conftest;],
1867         [cf_cv_pragma_unreferenced=yes],
1868         [cf_cv_pragma_unreferenced=no])])
1869
1870 # if the pragma is supported, use it (needed in the Trace code).
1871 if test $cf_cv_pragma_unreferenced = yes ; then
1872         PRAGMA_UNREF=TRUE
1873 else
1874         PRAGMA_UNREF=FALSE
1875 fi
1876 AC_SUBST(PRAGMA_UNREF)
1877 ])dnl
1878 dnl ---------------------------------------------------------------------------
1879 dnl CF_GNAT_PROJECTS version: 2 updated: 2011/03/23 20:24:41
1880 dnl ----------------
1881 dnl GNAT projects are configured with ".gpr" project files.
1882 dnl GNAT libraries are a further development, using the project feature.
1883 AC_DEFUN([CF_GNAT_PROJECTS],
1884 [
1885 AC_REQUIRE([CF_GNAT_VERSION])
1886
1887 cf_gnat_libraries=no
1888 cf_gnat_projects=no
1889
1890 AC_MSG_CHECKING(if GNAT supports project files)
1891 case $cf_gnat_version in #(vi
1892 3.[[0-9]]*) #(vi
1893         ;;
1894 *)
1895         case $cf_cv_system_name in #(vi
1896         cygwin*) #(vi
1897                 ;;
1898         *)
1899                 mkdir conftest.src conftest.bin conftest.lib
1900                 cd conftest.src
1901                 rm -rf conftest* *~conftest*
1902                 cat >>library.gpr <<CF_EOF
1903 project Library is
1904   Kind := External ("LIB_KIND");
1905   for Library_Name use "ConfTest";
1906   for Object_Dir use ".";
1907   for Library_ALI_Dir use External("LIBRARY_DIR");
1908   for Library_Version use External ("SONAME");
1909   for Library_Kind use Kind;
1910   for Library_Dir use External("BUILD_DIR");
1911   Source_Dir := External ("SOURCE_DIR");
1912   for Source_Dirs use (Source_Dir);
1913   package Compiler is
1914      for Default_Switches ("Ada") use
1915        ("-g",
1916         "-O2",
1917         "-gnatafno",
1918         "-gnatVa",   -- All validity checks
1919         "-gnatwa");  -- Activate all optional errors
1920   end Compiler;
1921 end Library;
1922 CF_EOF
1923                 cat >>confpackage.ads <<CF_EOF
1924 package ConfPackage is
1925    procedure conftest;
1926 end ConfPackage;
1927 CF_EOF
1928                 cat >>confpackage.adb <<CF_EOF
1929 with Text_IO;
1930 package body ConfPackage is
1931    procedure conftest is
1932    begin
1933       Text_IO.Put ("Hello World");
1934       Text_IO.New_Line;
1935    end conftest;
1936 end ConfPackage;
1937 CF_EOF
1938                 if ( $cf_ada_make $ADAFLAGS \
1939                                 -Plibrary.gpr \
1940                                 -XBUILD_DIR=`cd ../conftest.bin;pwd` \
1941                                 -XLIBRARY_DIR=`cd ../conftest.lib;pwd` \
1942                                 -XSOURCE_DIR=`pwd` \
1943                                 -XSONAME=libConfTest.so.1 \
1944                                 -XLIB_KIND=static 1>&AC_FD_CC 2>&1 ) ; then
1945                         cf_gnat_projects=yes
1946                 fi
1947                 cd ..
1948                 if test -f conftest.lib/confpackage.ali
1949                 then
1950                         cf_gnat_libraries=yes
1951                 fi
1952                 rm -rf conftest* *~conftest*
1953                 ;;
1954         esac
1955         ;;
1956 esac
1957 AC_MSG_RESULT($cf_gnat_projects)
1958
1959 if test $cf_gnat_projects = yes
1960 then
1961         AC_MSG_CHECKING(if GNAT supports libraries)
1962         AC_MSG_RESULT($cf_gnat_libraries)
1963 fi
1964
1965 if test "$cf_gnat_projects" = yes
1966 then
1967         USE_OLD_MAKERULES="#"
1968         USE_GNAT_PROJECTS=""
1969 else
1970         USE_OLD_MAKERULES=""
1971         USE_GNAT_PROJECTS="#"
1972 fi
1973
1974 if test "$cf_gnat_libraries" = yes
1975 then
1976         USE_GNAT_LIBRARIES=""
1977 else
1978         USE_GNAT_LIBRARIES="#"
1979 fi
1980
1981 AC_SUBST(USE_OLD_MAKERULES)
1982 AC_SUBST(USE_GNAT_PROJECTS)
1983 AC_SUBST(USE_GNAT_LIBRARIES)
1984 ])dnl
1985 dnl ---------------------------------------------------------------------------
1986 dnl CF_GNAT_SIGINT version: 1 updated: 2011/03/27 20:07:59
1987 dnl --------------
1988 dnl Check if gnat supports SIGINT, and presumably tasking.  For the latter, it
1989 dnl is noted that gnat may compile a tasking unit even for configurations which
1990 dnl fail at runtime.
1991 AC_DEFUN([CF_GNAT_SIGINT],[
1992 AC_CACHE_CHECK(if GNAT supports SIGINT,cf_cv_gnat_sigint,[
1993 CF_GNAT_TRY_LINK([with Ada.Interrupts.Names;
1994
1995 package ConfTest is
1996
1997    pragma Warnings (Off);  --  the next pragma exists since 3.11p
1998    pragma Unreserve_All_Interrupts;
1999    pragma Warnings (On);
2000
2001    protected Process is
2002       procedure Stop;
2003       function Continue return Boolean;
2004       pragma Attach_Handler (Stop, Ada.Interrupts.Names.SIGINT);
2005    private
2006       Done : Boolean := False;
2007    end Process;
2008
2009 end ConfTest;],
2010 [package body ConfTest is
2011    protected body Process is
2012       procedure Stop is
2013       begin
2014          Done := True;
2015       end Stop;
2016       function Continue return Boolean is
2017       begin
2018          return not Done;
2019       end Continue;
2020    end Process;
2021 end ConfTest;],
2022         [cf_cv_gnat_sigint=yes],
2023         [cf_cv_gnat_sigint=no])])
2024
2025 if test $cf_cv_gnat_sigint = yes ; then
2026         USE_GNAT_SIGINT=""
2027 else
2028         USE_GNAT_SIGINT="#"
2029 fi
2030 AC_SUBST(USE_GNAT_SIGINT)
2031 ])dnl
2032 dnl ---------------------------------------------------------------------------
2033 dnl CF_GNAT_TRY_LINK version: 3 updated: 2011/03/19 14:47:45
2034 dnl ----------------
2035 dnl Verify that a test program compiles/links with GNAT.
2036 dnl $cf_ada_make is set to the program that compiles/links
2037 dnl $ADAFLAGS may be set to the GNAT flags.
2038 dnl
2039 dnl $1 is the text of the spec
2040 dnl $2 is the text of the body
2041 dnl $3 is the shell command to execute if successful
2042 dnl $4 is the shell command to execute if not successful
2043 AC_DEFUN([CF_GNAT_TRY_LINK],
2044 [
2045 rm -rf conftest* *~conftest*
2046 cat >>conftest.ads <<CF_EOF
2047 $1
2048 CF_EOF
2049 cat >>conftest.adb <<CF_EOF
2050 $2
2051 CF_EOF
2052 if ( $cf_ada_make $ADAFLAGS conftest 1>&AC_FD_CC 2>&1 ) ; then
2053 ifelse($3,,      :,[      $3])
2054 ifelse($4,,,[else
2055    $4])
2056 fi
2057 rm -rf conftest* *~conftest*
2058 ])dnl
2059 dnl ---------------------------------------------------------------------------
2060 dnl CF_GNAT_TRY_RUN version: 5 updated: 2011/03/19 14:47:45
2061 dnl ---------------
2062 dnl Verify that a test program compiles and runs with GNAT
2063 dnl $cf_ada_make is set to the program that compiles/links
2064 dnl $ADAFLAGS may be set to the GNAT flags.
2065 dnl
2066 dnl $1 is the text of the spec
2067 dnl $2 is the text of the body
2068 dnl $3 is the shell command to execute if successful
2069 dnl $4 is the shell command to execute if not successful
2070 AC_DEFUN([CF_GNAT_TRY_RUN],
2071 [
2072 rm -rf conftest* *~conftest*
2073 cat >>conftest.ads <<CF_EOF
2074 $1
2075 CF_EOF
2076 cat >>conftest.adb <<CF_EOF
2077 $2
2078 CF_EOF
2079 if ( $cf_ada_make $ADAFLAGS conftest 1>&AC_FD_CC 2>&1 ) ; then
2080    if ( ./conftest 1>&AC_FD_CC 2>&1 ) ; then
2081 ifelse($3,,      :,[      $3])
2082 ifelse($4,,,[   else
2083       $4])
2084    fi
2085 ifelse($4,,,[else
2086    $4])
2087 fi
2088 rm -rf conftest* *~conftest*
2089 ])dnl
2090 dnl ---------------------------------------------------------------------------
2091 dnl CF_GNAT_VERSION version: 17 updated: 2011/03/23 20:24:41
2092 dnl ---------------
2093 dnl Verify version of GNAT.
2094 AC_DEFUN([CF_GNAT_VERSION],
2095 [
2096 AC_MSG_CHECKING(for gnat version)
2097 cf_gnat_version=`${cf_ada_make:-gnatmake} -v 2>&1 | \
2098         grep '[[0-9]].[[0-9]][[0-9]]*' |\
2099     sed -e '2,$d' -e 's/[[^0-9 \.]]//g' -e 's/^[[ ]]*//' -e 's/ .*//'`
2100 AC_MSG_RESULT($cf_gnat_version)
2101
2102 case $cf_gnat_version in #(vi
2103 3.1[[1-9]]*|3.[[2-9]]*|[[4-9]].*) #(vi
2104         cf_cv_prog_gnat_correct=yes
2105         ;;
2106 *)
2107         AC_MSG_WARN(Unsupported GNAT version $cf_gnat_version. We require 3.11 or better. Disabling Ada95 binding.)
2108         cf_cv_prog_gnat_correct=no
2109         ;;
2110 esac
2111 ])
2112 dnl ---------------------------------------------------------------------------
2113 dnl CF_GNU_SOURCE version: 6 updated: 2005/07/09 13:23:07
2114 dnl -------------
2115 dnl Check if we must define _GNU_SOURCE to get a reasonable value for
2116 dnl _XOPEN_SOURCE, upon which many POSIX definitions depend.  This is a defect
2117 dnl (or misfeature) of glibc2, which breaks portability of many applications,
2118 dnl since it is interwoven with GNU extensions.
2119 dnl
2120 dnl Well, yes we could work around it...
2121 AC_DEFUN([CF_GNU_SOURCE],
2122 [
2123 AC_CACHE_CHECK(if we must define _GNU_SOURCE,cf_cv_gnu_source,[
2124 AC_TRY_COMPILE([#include <sys/types.h>],[
2125 #ifndef _XOPEN_SOURCE
2126 make an error
2127 #endif],
2128         [cf_cv_gnu_source=no],
2129         [cf_save="$CPPFLAGS"
2130          CPPFLAGS="$CPPFLAGS -D_GNU_SOURCE"
2131          AC_TRY_COMPILE([#include <sys/types.h>],[
2132 #ifdef _XOPEN_SOURCE
2133 make an error
2134 #endif],
2135         [cf_cv_gnu_source=no],
2136         [cf_cv_gnu_source=yes])
2137         CPPFLAGS="$cf_save"
2138         ])
2139 ])
2140 test "$cf_cv_gnu_source" = yes && CPPFLAGS="$CPPFLAGS -D_GNU_SOURCE"
2141 ])dnl
2142 dnl ---------------------------------------------------------------------------
2143 dnl CF_GPP_LIBRARY version: 10 updated: 2010/05/29 16:31:02
2144 dnl --------------
2145 dnl If we're trying to use g++, test if libg++ is installed (a rather common
2146 dnl problem :-).  If we have the compiler but no library, we'll be able to
2147 dnl configure, but won't be able to build the c++ demo program.
2148 AC_DEFUN([CF_GPP_LIBRARY],
2149 [
2150 cf_cxx_library=unknown
2151 case $cf_cv_system_name in #(vi
2152 os2*) #(vi
2153         cf_gpp_libname=gpp
2154         ;;
2155 *)
2156         cf_gpp_libname=g++
2157         ;;
2158 esac
2159 if test "$GXX" = yes; then
2160         AC_MSG_CHECKING([for lib$cf_gpp_libname])
2161         cf_save="$LIBS"
2162         CF_ADD_LIB($cf_gpp_libname)
2163         AC_TRY_LINK([
2164 #include <$cf_gpp_libname/builtin.h>
2165         ],
2166         [two_arg_error_handler_t foo2 = lib_error_handler],
2167         [cf_cxx_library=yes
2168          CF_ADD_LIB($cf_gpp_libname,CXXLIBS)
2169          if test "$cf_gpp_libname" = cpp ; then
2170             AC_DEFINE(HAVE_GPP_BUILTIN_H)
2171          else
2172             AC_DEFINE(HAVE_GXX_BUILTIN_H)
2173          fi],
2174         [AC_TRY_LINK([
2175 #include <builtin.h>
2176         ],
2177         [two_arg_error_handler_t foo2 = lib_error_handler],
2178         [cf_cxx_library=yes
2179          CF_ADD_LIB($cf_gpp_libname,CXXLIBS)
2180          AC_DEFINE(HAVE_BUILTIN_H)],
2181         [cf_cxx_library=no])])
2182         LIBS="$cf_save"
2183         AC_MSG_RESULT($cf_cxx_library)
2184 fi
2185 ])dnl
2186 dnl ---------------------------------------------------------------------------
2187 dnl CF_GXX_VERSION version: 6 updated: 2010/10/23 15:44:18
2188 dnl --------------
2189 dnl Check for version of g++
2190 AC_DEFUN([CF_GXX_VERSION],[
2191 AC_REQUIRE([AC_PROG_CPP])
2192 GXX_VERSION=none
2193 if test "$GXX" = yes; then
2194         AC_MSG_CHECKING(version of g++)
2195         GXX_VERSION="`${CXX:-g++} --version| sed -e '2,$d' -e 's/^.*(GCC) //' -e 's/^[[^0-9.]]*//' -e 's/[[^0-9.]].*//'`"
2196         test -z "$GXX_VERSION" && GXX_VERSION=unknown
2197         AC_MSG_RESULT($GXX_VERSION)
2198 fi
2199 ])dnl
2200 dnl ---------------------------------------------------------------------------
2201 dnl CF_GXX_WARNINGS version: 6 updated: 2010/08/14 18:25:37
2202 dnl ---------------
2203 dnl Check if the compiler supports useful warning options.
2204 dnl
2205 dnl Most of gcc's options apply to g++, except:
2206 dnl     -Wbad-function-cast
2207 dnl     -Wmissing-declarations
2208 dnl     -Wnested-externs
2209 dnl
2210 dnl Omit a few (for now):
2211 dnl     -Winline
2212 dnl
2213 dnl Parameter:
2214 dnl     $1 is an optional list of g++ warning flags that a particular
2215 dnl             application might want to use, e.g., "no-unused" for
2216 dnl             -Wno-unused
2217 dnl Special:
2218 dnl     If $with_ext_const is "yes", add a check for -Wwrite-strings
2219 dnl
2220 AC_DEFUN([CF_GXX_WARNINGS],
2221 [
2222
2223 CF_INTEL_COMPILER(GXX,INTEL_CPLUSPLUS,CXXFLAGS)
2224
2225 AC_REQUIRE([CF_GXX_VERSION])
2226
2227 AC_LANG_SAVE
2228 AC_LANG_CPLUSPLUS
2229
2230 cat > conftest.$ac_ext <<EOF
2231 #line __oline__ "configure"
2232 int main(int argc, char *argv[[]]) { return (argv[[argc-1]] == 0) ; }
2233 EOF
2234
2235 if test "$INTEL_CPLUSPLUS" = yes
2236 then
2237 # The "-wdXXX" options suppress warnings:
2238 # remark #1419: external declaration in primary source file
2239 # remark #1682: implicit conversion of a 64-bit integral type to a smaller integral type (potential portability problem)
2240 # remark #1683: explicit conversion of a 64-bit integral type to a smaller integral type (potential portability problem)
2241 # remark #1684: conversion from pointer to same-sized integral type (potential portability problem)
2242 # remark #193: zero used for undefined preprocessing identifier
2243 # remark #593: variable "curs_sb_left_arrow" was set but never used
2244 # remark #810: conversion from "int" to "Dimension={unsigned short}" may lose significant bits
2245 # remark #869: parameter "tw" was never referenced
2246 # remark #981: operands are evaluated in unspecified order
2247 # warning #269: invalid format string conversion
2248
2249         AC_CHECKING([for $CC warning options])
2250         cf_save_CXXFLAGS="$CXXFLAGS"
2251         EXTRA_CXXFLAGS="-Wall"
2252         for cf_opt in \
2253                 wd1419 \
2254                 wd1682 \
2255                 wd1683 \
2256                 wd1684 \
2257                 wd193 \
2258                 wd279 \
2259                 wd593 \
2260                 wd810 \
2261                 wd869 \
2262                 wd981
2263         do
2264                 CXXFLAGS="$cf_save_CXXFLAGS $EXTRA_CXXFLAGS -$cf_opt"
2265                 if AC_TRY_EVAL(ac_compile); then
2266                         test -n "$verbose" && AC_MSG_RESULT(... -$cf_opt)
2267                         EXTRA_CXXFLAGS="$EXTRA_CXXFLAGS -$cf_opt"
2268                 fi
2269         done
2270         CXXFLAGS="$cf_save_CXXFLAGS"
2271
2272 elif test "$GXX" = yes
2273 then
2274         AC_CHECKING([for $CXX warning options])
2275         cf_save_CXXFLAGS="$CXXFLAGS"
2276         EXTRA_CXXFLAGS="-W -Wall"
2277         cf_gxx_extra_warnings=""
2278         test "$with_ext_const" = yes && cf_gxx_extra_warnings="Wwrite-strings"
2279         case "$GCC_VERSION" in
2280         [[1-2]].*)
2281                 ;;
2282         *)
2283                 cf_gxx_extra_warnings="$cf_gxx_extra_warnings Weffc++"
2284                 ;;
2285         esac
2286         for cf_opt in \
2287                 Wabi \
2288                 fabi-version=0 \
2289                 Woverloaded-virtual \
2290                 Wsign-promo \
2291                 Wsynth \
2292                 Wold-style-cast \
2293                 Wcast-align \
2294                 Wcast-qual \
2295                 Wmissing-prototypes \
2296                 Wpointer-arith \
2297                 Wshadow \
2298                 Wstrict-prototypes \
2299                 Wundef $cf_gxx_extra_warnings $1
2300         do
2301                 CXXFLAGS="$cf_save_CXXFLAGS $EXTRA_CXXFLAGS -Werror -$cf_opt"
2302                 if AC_TRY_EVAL(ac_compile); then
2303                         test -n "$verbose" && AC_MSG_RESULT(... -$cf_opt)
2304                         EXTRA_CXXFLAGS="$EXTRA_CXXFLAGS -$cf_opt"
2305                 else
2306                         test -n "$verbose" && AC_MSG_RESULT(... no -$cf_opt)
2307                 fi
2308         done
2309         CXXFLAGS="$cf_save_CXXFLAGS"
2310 fi
2311
2312 rm -rf conftest*
2313 AC_LANG_RESTORE
2314 AC_SUBST(EXTRA_CXXFLAGS)
2315 ])dnl
2316 dnl ---------------------------------------------------------------------------
2317 dnl CF_HASHED_DB version: 4 updated: 2010/05/29 16:31:02
2318 dnl ------------
2319 dnl Look for an instance of the Berkeley hashed database.
2320 dnl
2321 dnl $1 = optional parameter, to specify install-prefix for the database.
2322 AC_DEFUN([CF_HASHED_DB],
2323 [
2324 ifelse([$1],,,[
2325 case $1 in #(vi
2326 yes|*able*) #(vi
2327     ;;
2328 *)
2329     if test -d "$1" ; then
2330         CF_ADD_INCDIR($1/include)
2331         CF_ADD_LIBDIR($1/lib)
2332     fi
2333 esac
2334 ])
2335 AC_CHECK_HEADER(db.h,[
2336 CF_HASHED_DB_VERSION
2337 if test "$cf_cv_hashed_db_version" = unknown ; then
2338         AC_MSG_ERROR(Cannot determine version of db)
2339 else
2340         CF_HASHED_DB_LIBS
2341         if test "$cf_cv_hashed_db_libs" = unknown ; then
2342                 AC_MSG_ERROR(Cannot determine library for db)
2343         elif test "$cf_cv_hashed_db_libs" != default ; then
2344                 CF_ADD_LIB($cf_cv_hashed_db_libs)
2345         fi
2346 fi
2347 ],[
2348         AC_MSG_ERROR(Cannot find db.h)
2349 ])
2350 ])dnl
2351 dnl ---------------------------------------------------------------------------
2352 dnl CF_HASHED_DB_LIBS version: 9 updated: 2010/05/29 16:31:02
2353 dnl -----------------
2354 dnl Given that we have the header and version for hashed database, find the
2355 dnl library information.
2356 AC_DEFUN([CF_HASHED_DB_LIBS],
2357 [
2358 AC_CACHE_CHECK(for db libraries, cf_cv_hashed_db_libs,[
2359 cf_cv_hashed_db_libs=unknown
2360 for cf_db_libs in "" db$cf_cv_hashed_db_version db-$cf_cv_hashed_db_version db ''
2361 do
2362         cf_save_libs="$LIBS"
2363         if test -n "$cf_db_libs"; then
2364                 CF_ADD_LIB($cf_db_libs)
2365         fi
2366         CF_MSG_LOG(checking for library "$cf_db_libs")
2367         AC_TRY_LINK([
2368 $ac_includes_default
2369 #include <db.h>
2370 ],[
2371         char *path = "/tmp/foo";
2372 #ifdef DB_VERSION_MAJOR
2373 #if DB_VERSION_MAJOR >= 4
2374         DB *result = 0;
2375         db_create(&result, NULL, 0);
2376         result->open(result,
2377                 NULL,
2378                 path,
2379                 path,
2380                 DB_HASH,
2381                 DB_CREATE,
2382                 0644);
2383 #elif DB_VERSION_MAJOR >= 3
2384         DB *result = 0;
2385         db_create(&result, NULL, 0);
2386         result->open(result,
2387                 path,
2388                 path,
2389                 DB_HASH,
2390                 DB_CREATE,
2391                 0644);
2392 #elif DB_VERSION_MAJOR >= 2
2393         DB *result = 0;
2394         db_open(path,
2395                 DB_HASH,
2396                 DB_CREATE,
2397                 0644,
2398                 (DB_ENV *) 0,
2399                 (DB_INFO *) 0,
2400                 &result);
2401 #endif /* DB_VERSION_MAJOR */
2402 #else
2403         DB *result = dbopen(path,
2404                      2,
2405                      0644,
2406                      DB_HASH,
2407                      0);
2408 #endif
2409         ${cf_cv_main_return:-return}(result != 0)
2410 ],[
2411         if test -n "$cf_db_libs" ; then
2412                 cf_cv_hashed_db_libs=$cf_db_libs
2413         else
2414                 cf_cv_hashed_db_libs=default
2415         fi
2416         LIBS="$cf_save_libs"
2417         break
2418 ])
2419         LIBS="$cf_save_libs"
2420 done
2421 ])
2422 ])dnl
2423 dnl ---------------------------------------------------------------------------
2424 dnl CF_HASHED_DB_VERSION version: 3 updated: 2007/12/01 15:01:37
2425 dnl --------------------
2426 dnl Given that we have the header file for hashed database, find the version
2427 dnl information.
2428 AC_DEFUN([CF_HASHED_DB_VERSION],
2429 [
2430 AC_CACHE_CHECK(for version of db, cf_cv_hashed_db_version,[
2431 cf_cv_hashed_db_version=unknown
2432
2433 for cf_db_version in 1 2 3 4 5
2434 do
2435         CF_MSG_LOG(checking for db version $cf_db_version)
2436         AC_TRY_COMPILE([
2437 $ac_includes_default
2438 #include <db.h>
2439
2440 #ifdef DB_VERSION_MAJOR
2441         /* db2 (DB_VERSION_MAJOR=2) has also DB_VERSION_MINOR, tested with 7 */
2442 #if $cf_db_version == DB_VERSION_MAJOR
2443         /* ok */
2444 #else
2445         make an error
2446 #endif
2447 #else
2448 #if $cf_db_version == 1
2449         /* ok: assuming this is DB 1.8.5 */
2450 #else
2451         make an error
2452 #endif
2453 #endif
2454 ],[DBT *foo = 0],[
2455         cf_cv_hashed_db_version=$cf_db_version
2456         break
2457         ])
2458 done
2459 ])
2460 ])dnl
2461 dnl ---------------------------------------------------------------------------
2462 dnl CF_HEADER_PATH version: 12 updated: 2010/05/05 05:22:40
2463 dnl --------------
2464 dnl Construct a search-list of directories for a nonstandard header-file
2465 dnl
2466 dnl Parameters
2467 dnl     $1 = the variable to return as result
2468 dnl     $2 = the package name
2469 AC_DEFUN([CF_HEADER_PATH],
2470 [
2471 $1=
2472
2473 # collect the current set of include-directories from compiler flags
2474 cf_header_path_list=""
2475 if test -n "${CFLAGS}${CPPFLAGS}" ; then
2476         for cf_header_path in $CPPFLAGS $CFLAGS
2477         do
2478                 case $cf_header_path in #(vi
2479                 -I*)
2480                         cf_header_path=`echo ".$cf_header_path" |sed -e 's/^...//' -e 's,/include$,,'`
2481                         CF_ADD_SUBDIR_PATH($1,$2,include,$cf_header_path,NONE)
2482                         cf_header_path_list="$cf_header_path_list [$]$1"
2483                         ;;
2484                 esac
2485         done
2486 fi
2487
2488 # add the variations for the package we are looking for
2489 CF_SUBDIR_PATH($1,$2,include)
2490
2491 test "$includedir" != NONE && \
2492 test "$includedir" != "/usr/include" && \
2493 test -d "$includedir" && {
2494         test -d $includedir &&    $1="[$]$1 $includedir"
2495         test -d $includedir/$2 && $1="[$]$1 $includedir/$2"
2496 }
2497
2498 test "$oldincludedir" != NONE && \
2499 test "$oldincludedir" != "/usr/include" && \
2500 test -d "$oldincludedir" && {
2501         test -d $oldincludedir    && $1="[$]$1 $oldincludedir"
2502         test -d $oldincludedir/$2 && $1="[$]$1 $oldincludedir/$2"
2503 }
2504
2505 $1="[$]$1 $cf_header_path_list"
2506 ])dnl
2507 dnl ---------------------------------------------------------------------------
2508 dnl CF_HELP_MESSAGE version: 3 updated: 1998/01/14 10:56:23
2509 dnl ---------------
2510 dnl Insert text into the help-message, for readability, from AC_ARG_WITH.
2511 AC_DEFUN([CF_HELP_MESSAGE],
2512 [AC_DIVERT_HELP([$1])dnl
2513 ])dnl
2514 dnl ---------------------------------------------------------------------------
2515 dnl CF_INCLUDE_DIRS version: 6 updated: 2009/01/06 19:37:40
2516 dnl ---------------
2517 dnl Construct the list of include-options according to whether we're building
2518 dnl in the source directory or using '--srcdir=DIR' option.  If we're building
2519 dnl with gcc, don't append the includedir if it happens to be /usr/include,
2520 dnl since that usually breaks gcc's shadow-includes.
2521 AC_DEFUN([CF_INCLUDE_DIRS],
2522 [
2523 CPPFLAGS="$CPPFLAGS -I. -I../include"
2524 if test "$srcdir" != "."; then
2525         CPPFLAGS="$CPPFLAGS -I\${srcdir}/../include"
2526 fi
2527 if test "$GCC" != yes; then
2528         CPPFLAGS="$CPPFLAGS -I\${includedir}"
2529 elif test "$includedir" != "/usr/include"; then
2530         if test "$includedir" = '${prefix}/include' ; then
2531                 if test $prefix != /usr ; then
2532                         CPPFLAGS="$CPPFLAGS -I\${includedir}"
2533                 fi
2534         else
2535                 CPPFLAGS="$CPPFLAGS -I\${includedir}"
2536         fi
2537 fi
2538 AC_SUBST(CPPFLAGS)
2539 ])dnl
2540 dnl ---------------------------------------------------------------------------
2541 dnl CF_INTEL_COMPILER version: 4 updated: 2010/05/26 05:38:42
2542 dnl -----------------
2543 dnl Check if the given compiler is really the Intel compiler for Linux.  It
2544 dnl tries to imitate gcc, but does not return an error when it finds a mismatch
2545 dnl between prototypes, e.g., as exercised by CF_MISSING_CHECK.
2546 dnl
2547 dnl This macro should be run "soon" after AC_PROG_CC or AC_PROG_CPLUSPLUS, to
2548 dnl ensure that it is not mistaken for gcc/g++.  It is normally invoked from
2549 dnl the wrappers for gcc and g++ warnings.
2550 dnl
2551 dnl $1 = GCC (default) or GXX
2552 dnl $2 = INTEL_COMPILER (default) or INTEL_CPLUSPLUS
2553 dnl $3 = CFLAGS (default) or CXXFLAGS
2554 AC_DEFUN([CF_INTEL_COMPILER],[
2555 ifelse([$2],,INTEL_COMPILER,[$2])=no
2556
2557 if test "$ifelse([$1],,[$1],GCC)" = yes ; then
2558         case $host_os in
2559         linux*|gnu*)
2560                 AC_MSG_CHECKING(if this is really Intel ifelse([$1],GXX,C++,C) compiler)
2561                 cf_save_CFLAGS="$ifelse([$3],,CFLAGS,[$3])"
2562                 ifelse([$3],,CFLAGS,[$3])="$ifelse([$3],,CFLAGS,[$3]) -no-gcc"
2563                 AC_TRY_COMPILE([],[
2564 #ifdef __INTEL_COMPILER
2565 #else
2566 make an error
2567 #endif
2568 ],[ifelse([$2],,INTEL_COMPILER,[$2])=yes
2569 cf_save_CFLAGS="$cf_save_CFLAGS -we147 -no-gcc"
2570 ],[])
2571                 ifelse([$3],,CFLAGS,[$3])="$cf_save_CFLAGS"
2572                 AC_MSG_RESULT($ifelse([$2],,INTEL_COMPILER,[$2]))
2573                 ;;
2574         esac
2575 fi
2576 ])dnl
2577 dnl ---------------------------------------------------------------------------
2578 dnl CF_ISASCII version: 3 updated: 2000/08/12 23:18:52
2579 dnl ----------
2580 dnl Check if we have either a function or macro for 'isascii()'.
2581 AC_DEFUN([CF_ISASCII],
2582 [
2583 AC_MSG_CHECKING(for isascii)
2584 AC_CACHE_VAL(cf_cv_have_isascii,[
2585         AC_TRY_LINK([#include <ctype.h>],[int x = isascii(' ')],
2586         [cf_cv_have_isascii=yes],
2587         [cf_cv_have_isascii=no])
2588 ])dnl
2589 AC_MSG_RESULT($cf_cv_have_isascii)
2590 test "$cf_cv_have_isascii" = yes && AC_DEFINE(HAVE_ISASCII)
2591 ])dnl
2592 dnl ---------------------------------------------------------------------------
2593 dnl CF_LARGEFILE version: 7 updated: 2007/06/02 11:58:50
2594 dnl ------------
2595 dnl Add checks for large file support.
2596 AC_DEFUN([CF_LARGEFILE],[
2597 ifdef([AC_FUNC_FSEEKO],[
2598     AC_SYS_LARGEFILE
2599     if test "$enable_largefile" != no ; then
2600         AC_FUNC_FSEEKO
2601
2602         # Normally we would collect these definitions in the config.h,
2603         # but (like _XOPEN_SOURCE), some environments rely on having these
2604         # defined before any of the system headers are included.  Another
2605         # case comes up with C++, e.g., on AIX the compiler compiles the
2606         # header files by themselves before looking at the body files it is
2607         # told to compile.  For ncurses, those header files do not include
2608         # the config.h
2609         test "$ac_cv_sys_large_files"      != no && CPPFLAGS="$CPPFLAGS -D_LARGE_FILES "
2610         test "$ac_cv_sys_largefile_source" != no && CPPFLAGS="$CPPFLAGS -D_LARGEFILE_SOURCE "
2611         test "$ac_cv_sys_file_offset_bits" != no && CPPFLAGS="$CPPFLAGS -D_FILE_OFFSET_BITS=$ac_cv_sys_file_offset_bits "
2612
2613         AC_CACHE_CHECK(whether to use struct dirent64, cf_cv_struct_dirent64,[
2614                 AC_TRY_COMPILE([
2615 #include <sys/types.h>
2616 #include <dirent.h>
2617                 ],[
2618                 /* if transitional largefile support is setup, this is true */
2619                 extern struct dirent64 * readdir(DIR *);
2620                 struct dirent64 *x = readdir((DIR *)0);
2621                 struct dirent *y = readdir((DIR *)0);
2622                 int z = x - y;
2623                 ],
2624                 [cf_cv_struct_dirent64=yes],
2625                 [cf_cv_struct_dirent64=no])
2626         ])
2627         test "$cf_cv_struct_dirent64" = yes && AC_DEFINE(HAVE_STRUCT_DIRENT64)
2628     fi
2629 ])
2630 ])
2631 dnl ---------------------------------------------------------------------------
2632 dnl CF_LDFLAGS_STATIC version: 8 updated: 2010/10/23 14:39:56
2633 dnl -----------------
2634 dnl Check for compiler/linker flags used to temporarily force usage of static
2635 dnl libraries.  This depends on the compiler and platform.  Use this to help
2636 dnl ensure that the linker picks up a given library based on its position in
2637 dnl the list of linker options and libraries.
2638 AC_DEFUN([CF_LDFLAGS_STATIC],[
2639
2640 if test "$GCC" = yes ; then
2641         case $cf_cv_system_name in #(
2642         OS/2*|os2*|aix[[4]]*|solaris2.1[[0-9]]|darwin*)         #( vi
2643                 LDFLAGS_STATIC=
2644                 LDFLAGS_SHARED=
2645                 ;;
2646     *)  #( normally, except when broken
2647         LDFLAGS_STATIC=-static
2648         LDFLAGS_SHARED=-dynamic
2649         ;;
2650     esac
2651 else
2652         case $cf_cv_system_name in #(
2653         aix[[456]]*)    #( from ld manpage
2654                 LDFLAGS_STATIC=-bstatic
2655                 LDFLAGS_SHARED=-bdynamic
2656                 ;;
2657         hpux*)          #( from ld manpage for hpux10.20, hpux11.11
2658                 # We could also use just "archive" and "shared".
2659                 LDFLAGS_STATIC=-Wl,-a,archive_shared
2660                 LDFLAGS_SHARED=-Wl,-a,shared_archive
2661                 ;;
2662         irix*)          #( from ld manpage IRIX64
2663                 LDFLAGS_STATIC=-Bstatic
2664                 LDFLAGS_SHARED=-Bdynamic
2665                 ;;
2666         osf[[45]]*)     #( from ld manpage osf4.0d, osf5.1
2667                 # alternative "-oldstyle_liblookup" (not in cc manpage)
2668                 LDFLAGS_STATIC=-noso
2669                 LDFLAGS_SHARED=-so_archive
2670                 ;;
2671         solaris2*)
2672                 LDFLAGS_STATIC=-Bstatic
2673                 LDFLAGS_SHARED=-Bdynamic
2674                 ;;
2675         esac
2676 fi
2677
2678 if test -n "$LDFLAGS_STATIC" && test -n "$LDFLAGS_SHARED"
2679 then
2680         AC_MSG_CHECKING(if linker supports switching between static/dynamic)
2681
2682         rm -f libconftest.a
2683         cat >conftest.$ac_ext <<EOF
2684 #line __oline__ "configure"
2685 #include <stdio.h>
2686 int cf_ldflags_static(FILE *fp) { return fflush(fp); }
2687 EOF
2688         if AC_TRY_EVAL(ac_compile) ; then
2689                 ( $AR $ARFLAGS libconftest.a conftest.o ) 2>&AC_FD_CC 1>/dev/null
2690                 ( eval $RANLIB libconftest.a ) 2>&AC_FD_CC >/dev/null
2691         fi
2692         rm -f conftest.*
2693
2694         cf_save_LIBS="$LIBS"
2695
2696         LIBS="$LDFLAGS_STATIC -L`pwd` -lconftest $LDFLAGS_DYNAMIC $LIBS"
2697         AC_TRY_LINK([
2698 #line __oline__ "configure"
2699 #include <stdio.h>
2700 int cf_ldflags_static(FILE *fp);
2701 ],[
2702         return cf_ldflags_static(stdin);
2703 ],[cf_ldflags_static=yes],[cf_ldflags_static=no])
2704
2705         rm -f libconftest.*
2706         LIBS="$cf_save_LIBS"
2707
2708         AC_MSG_RESULT($cf_ldflags_static)
2709
2710         if test $cf_ldflags_static != yes
2711         then
2712                 LDFLAGS_STATIC=
2713                 LDFLAGS_SHARED=
2714         fi
2715 else
2716         LDFLAGS_STATIC=
2717         LDFLAGS_SHARED=
2718 fi
2719
2720 AC_SUBST(LDFLAGS_STATIC)
2721 AC_SUBST(LDFLAGS_SHARED)
2722 ])
2723 dnl ---------------------------------------------------------------------------
2724 dnl CF_LD_RPATH_OPT version: 4 updated: 2011/06/04 20:09:13
2725 dnl ---------------
2726 dnl For the given system and compiler, find the compiler flags to pass to the
2727 dnl loader to use the "rpath" feature.
2728 AC_DEFUN([CF_LD_RPATH_OPT],
2729 [
2730 AC_REQUIRE([CF_CHECK_CACHE])
2731
2732 LD_RPATH_OPT=
2733 AC_MSG_CHECKING(for an rpath option)
2734 case $cf_cv_system_name in #(vi
2735 irix*) #(vi
2736         if test "$GCC" = yes; then
2737                 LD_RPATH_OPT="-Wl,-rpath,"
2738         else
2739                 LD_RPATH_OPT="-rpath "
2740         fi
2741         ;;
2742 linux*|gnu*|k*bsd*-gnu) #(vi
2743         LD_RPATH_OPT="-Wl,-rpath,"
2744         ;;
2745 openbsd[[2-9]].*|mirbsd*) #(vi
2746         LD_RPATH_OPT="-Wl,-rpath,"
2747         ;;
2748 freebsd*) #(vi
2749         LD_RPATH_OPT="-rpath "
2750         ;;
2751 netbsd*) #(vi
2752         LD_RPATH_OPT="-Wl,-rpath,"
2753         ;;
2754 osf*|mls+*) #(vi
2755         LD_RPATH_OPT="-rpath "
2756         ;;
2757 solaris2*) #(vi
2758         LD_RPATH_OPT="-R"
2759         ;;
2760 *)
2761         ;;
2762 esac
2763 AC_MSG_RESULT($LD_RPATH_OPT)
2764
2765 case "x$LD_RPATH_OPT" in #(vi
2766 x-R*)
2767         AC_MSG_CHECKING(if we need a space after rpath option)
2768         cf_save_LIBS="$LIBS"
2769         CF_ADD_LIBS(${LD_RPATH_OPT}$libdir)
2770         AC_TRY_LINK(, , cf_rpath_space=no, cf_rpath_space=yes)
2771         LIBS="$cf_save_LIBS"
2772         AC_MSG_RESULT($cf_rpath_space)
2773         test "$cf_rpath_space" = yes && LD_RPATH_OPT="$LD_RPATH_OPT "
2774         ;;
2775 esac
2776 ])dnl
2777 dnl ---------------------------------------------------------------------------
2778 dnl CF_LIBRARY_PATH version: 9 updated: 2010/03/28 12:52:50
2779 dnl ---------------
2780 dnl Construct a search-list of directories for a nonstandard library-file
2781 dnl
2782 dnl Parameters
2783 dnl     $1 = the variable to return as result
2784 dnl     $2 = the package name
2785 AC_DEFUN([CF_LIBRARY_PATH],
2786 [
2787 $1=
2788 cf_library_path_list=""
2789 if test -n "${LDFLAGS}${LIBS}" ; then
2790         for cf_library_path in $LDFLAGS $LIBS
2791         do
2792                 case $cf_library_path in #(vi
2793                 -L*)
2794                         cf_library_path=`echo ".$cf_library_path" |sed -e 's/^...//' -e 's,/lib$,,'`
2795                         CF_ADD_SUBDIR_PATH($1,$2,lib,$cf_library_path,NONE)
2796                         cf_library_path_list="$cf_library_path_list [$]$1"
2797                         ;;
2798                 esac
2799         done
2800 fi
2801
2802 CF_SUBDIR_PATH($1,$2,lib)
2803
2804 $1="$cf_library_path_list [$]$1"
2805 ])dnl
2806 dnl ---------------------------------------------------------------------------
2807 dnl CF_LIB_PREFIX version: 8 updated: 2008/09/13 11:34:16
2808 dnl -------------
2809 dnl Compute the library-prefix for the given host system
2810 dnl $1 = variable to set
2811 AC_DEFUN([CF_LIB_PREFIX],
2812 [
2813         case $cf_cv_system_name in #(vi
2814         OS/2*|os2*) #(vi
2815         LIB_PREFIX=''
2816         ;;
2817         *)      LIB_PREFIX='lib'
2818         ;;
2819         esac
2820 ifelse($1,,,[$1=$LIB_PREFIX])
2821         AC_SUBST(LIB_PREFIX)
2822 ])dnl
2823 dnl ---------------------------------------------------------------------------
2824 dnl CF_LIB_RULES version: 61 updated: 2010/10/23 16:10:30
2825 dnl ------------
2826 dnl Append definitions and rules for the given models to the subdirectory
2827 dnl Makefiles, and the recursion rule for the top-level Makefile.  If the
2828 dnl subdirectory is a library-source directory, modify the LIBS_TO_MAKE list in
2829 dnl the corresponding makefile to list the models that we'll generate.
2830 dnl
2831 dnl For shared libraries, make a list of symbolic links to construct when
2832 dnl generating each library.  The convention used for Linux is the simplest
2833 dnl one:
2834 dnl     lib<name>.so    ->
2835 dnl     lib<name>.so.<major>    ->
2836 dnl     lib<name>.so.<maj>.<minor>
2837 AC_DEFUN([CF_LIB_RULES],
2838 [
2839 CF_LIB_PREFIX(cf_prefix)
2840 AC_REQUIRE([CF_SUBST_NCURSES_VERSION])
2841
2842 if test $cf_cv_shlib_version = cygdll ; then
2843         TINFO_NAME=$TINFO_ARG_SUFFIX
2844         TINFO_SUFFIX=.dll
2845 fi
2846
2847 if test -n "$TINFO_SUFFIX" ; then
2848         case $TINFO_SUFFIX in
2849         tw*)
2850                 TINFO_NAME="${TINFO_NAME}tw"
2851                 TINFO_SUFFIX=`echo $TINFO_SUFFIX | sed 's/^tw//'`
2852                 ;;
2853         t*)
2854                 TINFO_NAME="${TINFO_NAME}t"
2855                 TINFO_SUFFIX=`echo $TINFO_SUFFIX | sed 's/^t//'`
2856                 ;;
2857         w*)
2858                 TINFO_NAME="${TINFO_NAME}w"
2859                 TINFO_SUFFIX=`echo $TINFO_SUFFIX | sed 's/^w//'`
2860                 ;;
2861         esac
2862 fi
2863
2864 for cf_dir in $SRC_SUBDIRS
2865 do
2866         if test ! -d $srcdir/$cf_dir ; then
2867                 continue
2868         elif test -f $srcdir/$cf_dir/modules; then
2869
2870                 SHARED_LIB=
2871                 LIBS_TO_MAKE=
2872                 for cf_item in $cf_LIST_MODELS
2873                 do
2874                         CF_LIB_SUFFIX($cf_item,cf_suffix,cf_depsuf)
2875                         if test $cf_item = shared ; then
2876                         if test "$cf_cv_do_symlinks" = yes ; then
2877                                 case "$cf_cv_shlib_version" in #(vi
2878                                 rel) #(vi
2879                                         case "$cf_cv_system_name" in #(vi
2880                                         darwin*)
2881                                         case .${LIB_SUFFIX} in
2882                                         .tw*)
2883                                                 cf_suffix=`echo $cf_suffix | sed 's/^tw//'`
2884                                                 cf_suffix=tw'.${REL_VERSION}'"$cf_suffix"
2885                                                 ;;
2886                                         .t*)
2887                                                 cf_suffix=`echo $cf_suffix | sed 's/^t//'`
2888                                                 cf_suffix=t'.${REL_VERSION}'"$cf_suffix"
2889                                                 ;;
2890                                         .w*)
2891                                                 cf_suffix=`echo $cf_suffix | sed 's/^w//'`
2892                                                 cf_suffix=w'.${REL_VERSION}'"$cf_suffix"
2893                                                 ;;
2894                                         *)
2895                                                 cf_suffix='.${REL_VERSION}'"$cf_suffix"
2896                                                 ;;
2897                                         esac
2898                                         ;; #(vi
2899                                         *) cf_suffix="$cf_suffix"'.${REL_VERSION}' ;;
2900                                         esac
2901                                         ;;
2902                                 abi)
2903                                         case "$cf_cv_system_name" in #(vi
2904                                         darwin*)
2905                                         case .${LIB_SUFFIX} in
2906                                         .tw*)
2907                                                 cf_suffix=`echo $cf_suffix | sed 's/^tw//'`
2908                                                 cf_suffix=tw'.${ABI_VERSION}'"$cf_suffix"
2909                                                 ;;
2910                                         .t*)
2911                                                 cf_suffix=`echo $cf_suffix | sed 's/^t//'`
2912                                                 cf_suffix=t'.${ABI_VERSION}'"$cf_suffix"
2913                                                 ;;
2914                                         .w*)
2915                                                 cf_suffix=`echo $cf_suffix | sed 's/^w//'`
2916                                                 cf_suffix=w'.${ABI_VERSION}'"$cf_suffix"
2917                                                 ;;
2918                                         *)
2919                                                 cf_suffix='.${ABI_VERSION}'"$cf_suffix"
2920                                                 ;;
2921                                         esac
2922                                         ;; #(vi
2923                                         *) cf_suffix="$cf_suffix"'.${ABI_VERSION}' ;;
2924                                         esac
2925                                         ;;
2926                                 esac
2927                         fi
2928                         # cygwin needs import library, and has unique naming convention
2929                         # use autodetected ${cf_prefix} for import lib and static lib, but
2930                         # use 'cyg' prefix for shared lib.
2931                         if test $cf_cv_shlib_version = cygdll ; then
2932                                 cf_cygsuf=`echo "$cf_suffix" | sed -e 's/\.dll/\${ABI_VERSION}.dll/'`
2933                                 LIBS_TO_MAKE="$LIBS_TO_MAKE ../lib/cyg${cf_dir}${cf_cygsuf}"
2934                                 continue
2935                         fi
2936                         fi
2937                         LIBS_TO_MAKE="$LIBS_TO_MAKE ../lib/${cf_prefix}${cf_dir}${cf_suffix}"
2938                 done
2939
2940                 if test $cf_dir = ncurses ; then
2941                         cf_subsets="$LIB_SUBSETS"
2942                         cf_r_parts="$cf_subsets"
2943                         cf_liblist="$LIBS_TO_MAKE"
2944
2945                         while test -n "$cf_r_parts"
2946                         do
2947                                 cf_l_parts=`echo "$cf_r_parts" |sed -e 's/ .*$//'`
2948                                 cf_r_parts=`echo "$cf_r_parts" |sed -e 's/^[[^ ]]* //'`
2949                                 if test "$cf_l_parts" != "$cf_r_parts" ; then
2950                                         cf_item=
2951                                         case $cf_l_parts in #(vi
2952                                         *termlib*) #(vi
2953                                                 cf_item=`echo $cf_liblist |sed -e s%${LIB_NAME}${LIB_SUFFIX}%${TINFO_LIB_SUFFIX}%g`
2954                                                 ;;
2955                                         *ticlib*)
2956                                                 cf_item=`echo $cf_liblist |sed -e s%${LIB_NAME}${LIB_SUFFIX}%${TICS_LIB_SUFFIX}%g`
2957                                                 ;;
2958                                         *)
2959                                                 break
2960                                                 ;;
2961                                         esac
2962                                         if test -n "$cf_item"; then
2963                                                 LIBS_TO_MAKE="$cf_item $LIBS_TO_MAKE"
2964                                         fi
2965                                 else
2966                                         break
2967                                 fi
2968                         done
2969                 else
2970                         cf_subsets=`echo "$LIB_SUBSETS" | sed -e 's/^termlib.* //'`
2971                 fi
2972
2973                 sed -e "s%@LIBS_TO_MAKE@%$LIBS_TO_MAKE%" \
2974                     -e "s%@SHARED_LIB@%$SHARED_LIB%" \
2975                         $cf_dir/Makefile >$cf_dir/Makefile.out
2976                 mv $cf_dir/Makefile.out $cf_dir/Makefile
2977
2978                 $AWK -f $srcdir/mk-0th.awk \
2979                         libname="${cf_dir}${LIB_SUFFIX}" subsets="$LIB_SUBSETS" \
2980                         $srcdir/$cf_dir/modules >>$cf_dir/Makefile
2981
2982                 for cf_subset in $cf_subsets
2983                 do
2984                         cf_subdirs=
2985                         for cf_item in $cf_LIST_MODELS
2986                         do
2987                         echo "Appending rules for ${cf_item} model (${cf_dir}: ${cf_subset})"
2988                         CF_UPPER(cf_ITEM,$cf_item)
2989                         CF_LIB_SUFFIX($cf_item,cf_suffix,cf_depsuf)
2990                         CF_OBJ_SUBDIR($cf_item,cf_subdir)
2991
2992                         # Test for case where we build libtinfo with a different name.
2993                         cf_libname=$cf_dir
2994                         if test $cf_dir = ncurses ; then
2995                                 case $cf_subset in
2996                                 *base*)
2997                                         cf_libname=${cf_libname}$LIB_SUFFIX
2998                                         ;;
2999                                 *termlib*)
3000                                         cf_libname=$TINFO_LIB_SUFFIX
3001                                         ;;
3002                                 ticlib*)
3003                                         cf_libname=$TICS_LIB_SUFFIX
3004                                         ;;
3005                                 esac
3006                         else
3007                                 cf_libname=${cf_libname}$LIB_SUFFIX
3008                         fi
3009                         if test -n "${DFT_ARG_SUFFIX}" ; then
3010                                 # undo $LIB_SUFFIX add-on in CF_LIB_SUFFIX
3011                                 cf_suffix=`echo $cf_suffix |sed -e "s%^${LIB_SUFFIX}%%"`
3012                         fi
3013
3014                         # These dependencies really are for development, not
3015                         # builds, but they are useful in porting, too.
3016                         cf_depend="../include/ncurses_cfg.h"
3017                         if test "$srcdir" = "."; then
3018                                 cf_reldir="."
3019                         else
3020                                 cf_reldir="\${srcdir}"
3021                         fi
3022
3023                         if test -f $srcdir/$cf_dir/$cf_dir.priv.h; then
3024                                 cf_depend="$cf_depend $cf_reldir/$cf_dir.priv.h"
3025                         elif test -f $srcdir/$cf_dir/curses.priv.h; then
3026                                 cf_depend="$cf_depend $cf_reldir/curses.priv.h"
3027                         fi
3028
3029                         cf_dir_suffix=
3030                         old_cf_suffix="$cf_suffix"
3031                         if test "$cf_cv_shlib_version_infix" = yes ; then
3032                         if test -n "$LIB_SUFFIX" ; then
3033                                 case $LIB_SUFFIX in
3034                                 tw*)
3035                                         cf_libname=`echo $cf_libname | sed 's/tw$//'`
3036                                         cf_suffix=`echo $cf_suffix | sed 's/^tw//'`
3037                                         cf_dir_suffix=tw
3038                                         ;;
3039                                 t*)
3040                                         cf_libname=`echo $cf_libname | sed 's/t$//'`
3041                                         cf_suffix=`echo $cf_suffix | sed 's/^t//'`
3042                                         cf_dir_suffix=t
3043                                         ;;
3044                                 w*)
3045                                         cf_libname=`echo $cf_libname | sed 's/w$//'`
3046                                         cf_suffix=`echo $cf_suffix | sed 's/^w//'`
3047                                         cf_dir_suffix=w
3048                                         ;;
3049                                 esac
3050                         fi
3051                         fi
3052
3053                         $AWK -f $srcdir/mk-1st.awk \
3054                                 name=${cf_libname}${cf_dir_suffix} \
3055                                 traces=$LIB_TRACING \
3056                                 MODEL=$cf_ITEM \
3057                                 model=$cf_subdir \
3058                                 prefix=$cf_prefix \
3059                                 suffix=$cf_suffix \
3060                                 subset=$cf_subset \
3061                                 SymLink="$LN_S" \
3062                                 TermlibRoot=$TINFO_NAME \
3063                                 TermlibSuffix=$TINFO_SUFFIX \
3064                                 ShlibVer=$cf_cv_shlib_version \
3065                                 ShlibVerInfix=$cf_cv_shlib_version_infix \
3066                                 ReLink=${cf_cv_do_relink:-no} \
3067                                 DoLinks=$cf_cv_do_symlinks \
3068                                 rmSoLocs=$cf_cv_rm_so_locs \
3069                                 ldconfig="$LDCONFIG" \
3070                                 overwrite=$WITH_OVERWRITE \
3071                                 depend="$cf_depend" \
3072                                 host="$host" \
3073                                 libtool_version="$LIBTOOL_VERSION" \
3074                                 $srcdir/$cf_dir/modules >>$cf_dir/Makefile
3075
3076                         cf_suffix="$old_cf_suffix"
3077
3078                         for cf_subdir2 in $cf_subdirs lib
3079                         do
3080                                 test $cf_subdir = $cf_subdir2 && break
3081                         done
3082                         test "${cf_subset}.${cf_subdir2}" != "${cf_subset}.${cf_subdir}" && \
3083                         $AWK -f $srcdir/mk-2nd.awk \
3084                                 name=$cf_dir \
3085                                 traces=$LIB_TRACING \
3086                                 MODEL=$cf_ITEM \
3087                                 model=$cf_subdir \
3088                                 subset=$cf_subset \
3089                                 srcdir=$srcdir \
3090                                 echo=$WITH_ECHO \
3091                                 crenames=$cf_cv_prog_CC_c_o \
3092                                 cxxrenames=$cf_cv_prog_CXX_c_o \
3093                                 $srcdir/$cf_dir/modules >>$cf_dir/Makefile
3094                         cf_subdirs="$cf_subdirs $cf_subdir"
3095                         done
3096                 done
3097         fi
3098
3099         echo '  cd '$cf_dir' && ${MAKE} ${CF_MFLAGS} [$]@' >>Makefile
3100 done
3101
3102 for cf_dir in $SRC_SUBDIRS
3103 do
3104         if test ! -d $srcdir/$cf_dir ; then
3105                 continue
3106         fi
3107
3108         if test -f $cf_dir/Makefile ; then
3109                 case "$cf_dir" in
3110                 Ada95) #(vi
3111                         echo 'libs \' >> Makefile
3112                         echo 'install.libs \' >> Makefile
3113                         echo 'uninstall.libs ::' >> Makefile
3114                         echo '  cd '$cf_dir' && ${MAKE} ${CF_MFLAGS} [$]@' >> Makefile
3115                         ;;
3116                 esac
3117         fi
3118
3119         if test -f $srcdir/$cf_dir/modules; then
3120                 echo >> Makefile
3121                 if test -f $srcdir/$cf_dir/headers; then
3122 cat >> Makefile <<CF_EOF
3123 install.includes \\
3124 uninstall.includes \\
3125 CF_EOF
3126                 fi
3127 if test "$cf_dir" != "c++" ; then
3128 echo 'lint \' >> Makefile
3129 fi
3130 cat >> Makefile <<CF_EOF
3131 libs \\
3132 lintlib \\
3133 install.libs \\
3134 uninstall.libs \\
3135 install.$cf_dir \\
3136 uninstall.$cf_dir ::
3137         cd $cf_dir && \${MAKE} \${CF_MFLAGS} \[$]@
3138 CF_EOF
3139         elif test -f $srcdir/$cf_dir/headers; then
3140 cat >> Makefile <<CF_EOF
3141
3142 libs \\
3143 install.libs \\
3144 uninstall.libs \\
3145 install.includes \\
3146 uninstall.includes ::
3147         cd $cf_dir && \${MAKE} \${CF_MFLAGS} \[$]@
3148 CF_EOF
3149 fi
3150 done
3151
3152 cat >> Makefile <<CF_EOF
3153
3154 install.libs uninstall.libs \\
3155 install.data uninstall.data ::
3156 $MAKE_TERMINFO  cd misc && \${MAKE} \${CF_MFLAGS} \[$]@
3157 CF_EOF
3158
3159 if test "x$cf_with_manpages" = xyes; then
3160 cat >> Makefile <<CF_EOF
3161
3162 install.man \\
3163 uninstall.man ::
3164         cd man && \${MAKE} \${CF_MFLAGS} \[$]@
3165 CF_EOF
3166 fi
3167
3168 cat >> Makefile <<CF_EOF
3169
3170 distclean ::
3171         rm -f config.cache config.log config.status Makefile include/ncurses_cfg.h
3172         rm -f headers.sh headers.sed mk_shared_lib.sh
3173         rm -f edit_man.* man_alias.*
3174         rm -rf \${DIRS_TO_MAKE}
3175 CF_EOF
3176
3177 # Special case: tack's manpage lives in its own directory.
3178 if test "x$cf_with_manpages" = xyes; then
3179 if test -d tack ; then
3180 if test -f $srcdir/$tack.h; then
3181 cat >> Makefile <<CF_EOF
3182
3183 install.man \\
3184 uninstall.man ::
3185         cd tack && \${MAKE} \${CF_MFLAGS} \[$]@
3186 CF_EOF
3187 fi
3188 fi
3189 fi
3190
3191 dnl If we're installing into a subdirectory of /usr/include, etc., we should
3192 dnl prepend the subdirectory's name to the "#include" paths.  It won't hurt
3193 dnl anything, and will make it more standardized.  It's awkward to decide this
3194 dnl at configuration because of quoting, so we'll simply make all headers
3195 dnl installed via a script that can do the right thing.
3196
3197 rm -f headers.sed headers.sh
3198
3199 dnl ( generating this script makes the makefiles a little tidier :-)
3200 echo creating headers.sh
3201 cat >headers.sh <<CF_EOF
3202 #! /bin/sh
3203 # This shell script is generated by the 'configure' script.  It is invoked in a
3204 # subdirectory of the build tree.  It generates a sed-script in the parent
3205 # directory that is used to adjust includes for header files that reside in a
3206 # subdirectory of /usr/include, etc.
3207 PRG=""
3208 while test \[$]# != 3
3209 do
3210 PRG="\$PRG \[$]1"; shift
3211 done
3212 DST=\[$]1
3213 REF=\[$]2
3214 SRC=\[$]3
3215 TMPSRC=\${TMPDIR:-/tmp}/\`basename \$SRC\`\$\$
3216 TMPSED=\${TMPDIR:-/tmp}/headers.sed\$\$
3217 echo installing \$SRC in \$DST
3218 CF_EOF
3219
3220 if test $WITH_CURSES_H = yes; then
3221         cat >>headers.sh <<CF_EOF
3222 case \$DST in
3223 /*/include/*)
3224         END=\`basename \$DST\`
3225         for i in \`cat \$REF/../*/headers |fgrep -v "#"\`
3226         do
3227                 NAME=\`basename \$i\`
3228                 echo "s/<\$NAME>/<\$END\/\$NAME>/" >> \$TMPSED
3229         done
3230         ;;
3231 *)
3232         echo "" >> \$TMPSED
3233         ;;
3234 esac
3235 CF_EOF
3236
3237 else
3238         cat >>headers.sh <<CF_EOF
3239 case \$DST in
3240 /*/include/*)
3241         END=\`basename \$DST\`
3242         for i in \`cat \$REF/../*/headers |fgrep -v "#"\`
3243         do
3244                 NAME=\`basename \$i\`
3245                 if test "\$NAME" = "curses.h"
3246                 then
3247                         echo "s/<curses.h>/<ncurses.h>/" >> \$TMPSED
3248                         NAME=ncurses.h
3249                 fi
3250                 echo "s/<\$NAME>/<\$END\/\$NAME>/" >> \$TMPSED
3251         done
3252         ;;
3253 *)
3254         echo "s/<curses.h>/<ncurses.h>/" >> \$TMPSED
3255         ;;
3256 esac
3257 CF_EOF
3258 fi
3259 cat >>headers.sh <<CF_EOF
3260 rm -f \$TMPSRC
3261 sed -f \$TMPSED \$SRC > \$TMPSRC
3262 NAME=\`basename \$SRC\`
3263 CF_EOF
3264 if test $WITH_CURSES_H != yes; then
3265         cat >>headers.sh <<CF_EOF
3266 test "\$NAME" = "curses.h" && NAME=ncurses.h
3267 CF_EOF
3268 fi
3269 cat >>headers.sh <<CF_EOF
3270 # Just in case someone gzip'd manpages, remove the conflicting copy.
3271 test -f \$DST/\$NAME.gz && rm -f \$DST/\$NAME.gz
3272
3273 eval \$PRG \$TMPSRC \$DST/\$NAME
3274 rm -f \$TMPSRC \$TMPSED
3275 CF_EOF
3276
3277 chmod 0755 headers.sh
3278
3279 for cf_dir in $SRC_SUBDIRS
3280 do
3281         if test ! -d $srcdir/$cf_dir ; then
3282                 continue
3283         fi
3284
3285         if test -f $srcdir/$cf_dir/headers; then
3286                 $AWK -f $srcdir/mk-hdr.awk \
3287                         subset="$LIB_SUBSETS" \
3288                         compat="$WITH_CURSES_H" \
3289                         $srcdir/$cf_dir/headers >>$cf_dir/Makefile
3290         fi
3291
3292         if test -f $srcdir/$cf_dir/modules; then
3293                 if test "$cf_dir" != "c++" ; then
3294                         cat >>$cf_dir/Makefile <<"CF_EOF"
3295 depend : ${AUTO_SRC}
3296         makedepend -- ${CPPFLAGS} -- ${C_SRC}
3297
3298 # DO NOT DELETE THIS LINE -- make depend depends on it.
3299 CF_EOF
3300                 fi
3301         fi
3302 done
3303 AC_SUBST(LIBS_TO_MAKE)
3304 ])dnl
3305 dnl ---------------------------------------------------------------------------
3306 dnl CF_LIB_SONAME version: 5 updated: 2010/08/14 18:25:37
3307 dnl -------------
3308 dnl Find the and soname for the given shared library.  Set the cache variable
3309 dnl cf_cv_$3_soname to this, unless it is not found.  Then set the cache
3310 dnl variable to "unknown".
3311 dnl
3312 dnl $1 = headers
3313 dnl $2 = code
3314 dnl $3 = library name
3315 AC_DEFUN([CF_LIB_SONAME],
3316 [
3317 AC_CACHE_CHECK(for soname of $3 library,cf_cv_$3_soname,[
3318
3319 cf_cv_$3_soname=unknown
3320 if test "$cross_compiling" != yes ; then
3321 cat >conftest.$ac_ext <<CF_EOF
3322 $1
3323 int main()
3324 {
3325 $2
3326         ${cf_cv_main_return:-return}(0);
3327 }
3328 CF_EOF
3329 cf_save_LIBS="$LIBS"
3330         CF_ADD_LIB($3)
3331         if AC_TRY_EVAL(ac_compile) ; then
3332                 if AC_TRY_EVAL(ac_link) ; then
3333                         cf_cv_$3_soname=`ldd conftest$ac_exeext 2>/dev/null | sed -e 's,^.*/,,' -e 's, .*$,,' | fgrep lib$3.`
3334                         test -z "$cf_cv_$3_soname" && cf_cv_$3_soname=unknown
3335                 fi
3336         fi
3337 rm -rf conftest*
3338 LIBS="$cf_save_LIBS"
3339 fi
3340 ])
3341 ])
3342 dnl ---------------------------------------------------------------------------
3343 dnl CF_LIB_SUFFIX version: 16 updated: 2008/12/27 12:30:03
3344 dnl -------------
3345 dnl Compute the library file-suffix from the given model name
3346 dnl $1 = model name
3347 dnl $2 = variable to set (the nominal library suffix)
3348 dnl $3 = dependency variable to set (actual filename)
3349 dnl The variable $LIB_SUFFIX, if set, prepends the variable to set.
3350 AC_DEFUN([CF_LIB_SUFFIX],
3351 [
3352         AC_REQUIRE([CF_SUBST_NCURSES_VERSION])
3353         case $1 in #(vi
3354         libtool) #(vi
3355                 $2='.la'
3356                 $3=[$]$2
3357                 ;;
3358         normal) #(vi
3359                 $2='.a'
3360                 $3=[$]$2
3361                 ;;
3362         debug) #(vi
3363                 $2='_g.a'
3364                 $3=[$]$2
3365                 ;;
3366         profile) #(vi
3367                 $2='_p.a'
3368                 $3=[$]$2
3369                 ;;
3370         shared) #(vi
3371                 case $cf_cv_system_name in
3372                 aix[[56]]*) #(vi
3373                         $2='.a'
3374                         $3=[$]$2
3375                         ;;
3376                 cygwin*) #(vi
3377                         $2='.dll'
3378                         $3='.dll.a'
3379                         ;;
3380                 darwin*) #(vi
3381                         $2='.dylib'
3382                         $3=[$]$2
3383                         ;;
3384                 hpux*) #(vi
3385                         case $target in
3386                         ia64*) #(vi
3387                                 $2='.so'
3388                                 $3=[$]$2
3389                                 ;;
3390                         *) #(vi
3391                                 $2='.sl'
3392                                 $3=[$]$2
3393                                 ;;
3394                         esac
3395                         ;;
3396                 *)      $2='.so'
3397                         $3=[$]$2
3398                         ;;
3399                 esac
3400         esac
3401         test -n "$LIB_SUFFIX" && $2="${LIB_SUFFIX}[$]{$2}"
3402         test -n "$LIB_SUFFIX" && $3="${LIB_SUFFIX}[$]{$3}"
3403 ])dnl
3404 dnl ---------------------------------------------------------------------------
3405 dnl CF_LIB_TYPE version: 4 updated: 2000/10/20 22:57:49
3406 dnl -----------
3407 dnl Compute the string to append to -library from the given model name
3408 dnl $1 = model name
3409 dnl $2 = variable to set
3410 dnl The variable $LIB_SUFFIX, if set, prepends the variable to set.
3411 AC_DEFUN([CF_LIB_TYPE],
3412 [
3413         case $1 in
3414         libtool) $2=''   ;;
3415         normal)  $2=''   ;;
3416         debug)   $2='_g' ;;
3417         profile) $2='_p' ;;
3418         shared)  $2=''   ;;
3419         esac
3420         test -n "$LIB_SUFFIX" && $2="${LIB_SUFFIX}[$]{$2}"
3421 ])dnl
3422 dnl ---------------------------------------------------------------------------
3423 dnl CF_LINK_DATAONLY version: 9 updated: 2009/01/01 20:21:38
3424 dnl ----------------
3425 dnl Some systems have a non-ANSI linker that doesn't pull in modules that have
3426 dnl only data (i.e., no functions), for example NeXT.  On those systems we'll
3427 dnl have to provide wrappers for global tables to ensure they're linked
3428 dnl properly.
3429 AC_DEFUN([CF_LINK_DATAONLY],
3430 [
3431 AC_MSG_CHECKING([if data-only library module links])
3432 AC_CACHE_VAL(cf_cv_link_dataonly,[
3433         rm -f conftest.a
3434         cat >conftest.$ac_ext <<EOF
3435 #line __oline__ "configure"
3436 int     testdata[[3]] = { 123, 456, 789 };
3437 EOF
3438         if AC_TRY_EVAL(ac_compile) ; then
3439                 mv conftest.o data.o && \
3440                 ( $AR $ARFLAGS conftest.a data.o ) 2>&AC_FD_CC 1>/dev/null
3441         fi
3442         rm -f conftest.$ac_ext data.o
3443         cat >conftest.$ac_ext <<EOF
3444 #line __oline__ "configure"
3445 int     testfunc()
3446 {
3447 #if defined(NeXT)
3448         ${cf_cv_main_return:-return}(1);        /* I'm told this linker is broken */
3449 #else
3450         extern int testdata[[3]];
3451         return testdata[[0]] == 123
3452            &&  testdata[[1]] == 456
3453            &&  testdata[[2]] == 789;
3454 #endif
3455 }
3456 EOF
3457         if AC_TRY_EVAL(ac_compile); then
3458                 mv conftest.o func.o && \
3459                 ( $AR $ARFLAGS conftest.a func.o ) 2>&AC_FD_CC 1>/dev/null
3460         fi
3461         rm -f conftest.$ac_ext func.o
3462         ( eval $RANLIB conftest.a ) 2>&AC_FD_CC >/dev/null
3463         cf_saveLIBS="$LIBS"
3464         LIBS="conftest.a $LIBS"
3465         AC_TRY_RUN([
3466         int main()
3467         {
3468                 extern int testfunc();
3469                 ${cf_cv_main_return:-return} (!testfunc());
3470         }
3471         ],
3472         [cf_cv_link_dataonly=yes],
3473         [cf_cv_link_dataonly=no],
3474         [cf_cv_link_dataonly=unknown])
3475         LIBS="$cf_saveLIBS"
3476         ])
3477 AC_MSG_RESULT($cf_cv_link_dataonly)
3478
3479 if test "$cf_cv_link_dataonly" = no ; then
3480         AC_DEFINE(BROKEN_LINKER)
3481         BROKEN_LINKER=1
3482 fi
3483
3484 ])dnl
3485 dnl ---------------------------------------------------------------------------
3486 dnl CF_LINK_FUNCS version: 7 updated: 2006/12/16 12:33:30
3487 dnl -------------
3488 dnl Most Unix systems have both link and symlink, a few don't have symlink.
3489 dnl A few non-Unix systems implement symlink, but not link.
3490 dnl A few non-systems implement neither (or have nonfunctional versions).
3491 AC_DEFUN([CF_LINK_FUNCS],
3492 [
3493 AC_CHECK_FUNCS( \
3494         remove \
3495         unlink )
3496
3497 if test "$cross_compiling" = yes ; then
3498         AC_CHECK_FUNCS( \
3499                 link \
3500                 symlink )
3501 else
3502         AC_CACHE_CHECK(if link/symlink functions work,cf_cv_link_funcs,[
3503                 cf_cv_link_funcs=
3504                 for cf_func in link symlink ; do
3505                         AC_TRY_RUN([
3506 #include <sys/types.h>
3507 #include <sys/stat.h>
3508 #ifdef HAVE_UNISTD_H
3509 #include <unistd.h>
3510 #endif
3511 int main()
3512 {
3513         int fail = 0;
3514         char *src = "config.log";
3515         char *dst = "conftest.chk";
3516         struct stat src_sb;
3517         struct stat dst_sb;
3518
3519         stat(src, &src_sb);
3520         fail = ($cf_func("config.log", "conftest.chk") < 0)
3521             || (stat(dst, &dst_sb) < 0)
3522             || (dst_sb.st_mtime != src_sb.st_mtime);
3523 #ifdef HAVE_UNLINK
3524         unlink(dst);
3525 #else
3526         remove(dst);
3527 #endif
3528         ${cf_cv_main_return:-return} (fail);
3529 }
3530                         ],[
3531                         cf_cv_link_funcs="$cf_cv_link_funcs $cf_func"
3532                         eval 'ac_cv_func_'$cf_func'=yes'],[
3533                         eval 'ac_cv_func_'$cf_func'=no'],[
3534                         eval 'ac_cv_func_'$cf_func'=error'])
3535                 done
3536                 test -z "$cf_cv_link_funcs" && cf_cv_link_funcs=no
3537         ])
3538         test "$ac_cv_func_link"    = yes && AC_DEFINE(HAVE_LINK)
3539         test "$ac_cv_func_symlink" = yes && AC_DEFINE(HAVE_SYMLINK)
3540 fi
3541 ])dnl
3542 dnl ---------------------------------------------------------------------------
3543 dnl CF_MAIN_RETURN version: 1 updated: 2006/12/10 09:51:54
3544 dnl --------------
3545 dnl Check if a return from main to the shell actually returns the same exit
3546 dnl code.  This is true for almost any POSIX environment.
3547 dnl
3548 dnl Some very old environments did not flush stdout, etc., on an exit.  That
3549 dnl would be a useful case to test for also.
3550 AC_DEFUN([CF_MAIN_RETURN],
3551 [
3552 cf_cv_main_return=return
3553 ])dnl
3554 dnl ---------------------------------------------------------------------------
3555 dnl CF_MAKEFLAGS version: 14 updated: 2011/03/31 19:29:46
3556 dnl ------------
3557 dnl Some 'make' programs support ${MAKEFLAGS}, some ${MFLAGS}, to pass 'make'
3558 dnl options to lower-levels.  It's very useful for "make -n" -- if we have it.
3559 dnl (GNU 'make' does both, something POSIX 'make', which happens to make the
3560 dnl ${MAKEFLAGS} variable incompatible because it adds the assignments :-)
3561 AC_DEFUN([CF_MAKEFLAGS],
3562 [
3563 AC_CACHE_CHECK(for makeflags variable, cf_cv_makeflags,[
3564         cf_cv_makeflags=''
3565         for cf_option in '-${MAKEFLAGS}' '${MFLAGS}'
3566         do
3567                 cat >cf_makeflags.tmp <<CF_EOF
3568 SHELL = /bin/sh
3569 all :
3570         @ echo '.$cf_option'
3571 CF_EOF
3572                 cf_result=`${MAKE:-make} -k -f cf_makeflags.tmp 2>/dev/null | fgrep -v "ing directory" | sed -e 's,[[   ]]*$,,'`
3573                 case "$cf_result" in
3574                 .*k)
3575                         cf_result=`${MAKE:-make} -k -f cf_makeflags.tmp CC=cc 2>/dev/null`
3576                         case "$cf_result" in
3577                         .*CC=*) cf_cv_makeflags=
3578                                 ;;
3579                         *)      cf_cv_makeflags=$cf_option
3580                                 ;;
3581                         esac
3582                         break
3583                         ;;
3584                 .-)     ;;
3585                 *)      echo "given option \"$cf_option\", no match \"$cf_result\""
3586                         ;;
3587                 esac
3588         done
3589         rm -f cf_makeflags.tmp
3590 ])
3591
3592 AC_SUBST(cf_cv_makeflags)
3593 ])dnl
3594 dnl ---------------------------------------------------------------------------
3595 dnl CF_MAKE_TAGS version: 6 updated: 2010/10/23 15:52:32
3596 dnl ------------
3597 dnl Generate tags/TAGS targets for makefiles.  Do not generate TAGS if we have
3598 dnl a monocase filesystem.
3599 AC_DEFUN([CF_MAKE_TAGS],[
3600 AC_REQUIRE([CF_MIXEDCASE_FILENAMES])
3601
3602 AC_CHECK_PROGS(CTAGS, exctags ctags)
3603 AC_CHECK_PROGS(ETAGS, exetags etags)
3604
3605 AC_CHECK_PROG(MAKE_LOWER_TAGS, ${CTAGS:-ctags}, yes, no)
3606
3607 if test "$cf_cv_mixedcase" = yes ; then
3608         AC_CHECK_PROG(MAKE_UPPER_TAGS, ${ETAGS:-etags}, yes, no)
3609 else
3610         MAKE_UPPER_TAGS=no
3611 fi
3612
3613 if test "$MAKE_UPPER_TAGS" = yes ; then
3614         MAKE_UPPER_TAGS=
3615 else
3616         MAKE_UPPER_TAGS="#"
3617 fi
3618
3619 if test "$MAKE_LOWER_TAGS" = yes ; then
3620         MAKE_LOWER_TAGS=
3621 else
3622         MAKE_LOWER_TAGS="#"
3623 fi
3624
3625 AC_SUBST(CTAGS)
3626 AC_SUBST(ETAGS)
3627
3628 AC_SUBST(MAKE_UPPER_TAGS)
3629 AC_SUBST(MAKE_LOWER_TAGS)
3630 ])dnl
3631 dnl ---------------------------------------------------------------------------
3632 dnl CF_MANPAGE_FORMAT version: 9 updated: 2010/10/23 16:10:30
3633 dnl -----------------
3634 dnl Option to allow user to override automatic configuration of manpage format.
3635 dnl There are several special cases:
3636 dnl
3637 dnl     gzip - man checks for, can display gzip'd files
3638 dnl     compress - man checks for, can display compressed files
3639 dnl     BSDI - files in the cat-directories are suffixed ".0"
3640 dnl     formatted - installer should format (put files in cat-directory)
3641 dnl     catonly - installer should only format, e.g., for a turnkey system.
3642 dnl
3643 dnl There are other configurations which this macro does not test, e.g., HPUX's
3644 dnl compressed manpages (but uncompressed manpages are fine, and HPUX's naming
3645 dnl convention would not match our use).
3646 AC_DEFUN([CF_MANPAGE_FORMAT],
3647 [
3648 AC_REQUIRE([CF_PATHSEP])
3649 AC_MSG_CHECKING(format of man-pages)
3650
3651 AC_ARG_WITH(manpage-format,
3652         [  --with-manpage-format   specify manpage-format: gzip/compress/BSDI/normal and
3653                           optionally formatted/catonly, e.g., gzip,formatted],
3654         [MANPAGE_FORMAT=$withval],
3655         [MANPAGE_FORMAT=unknown])
3656
3657 test -z "$MANPAGE_FORMAT" && MANPAGE_FORMAT=unknown
3658 MANPAGE_FORMAT=`echo "$MANPAGE_FORMAT" | sed -e 's/,/ /g'`
3659
3660 cf_unknown=
3661
3662 case $MANPAGE_FORMAT in
3663 unknown)
3664   if test -z "$MANPATH" ; then
3665     MANPATH="/usr/man:/usr/share/man"
3666   fi
3667
3668   # look for the 'date' man-page (it's most likely to be installed!)
3669   MANPAGE_FORMAT=
3670   cf_preform=no
3671   cf_catonly=yes
3672   cf_example=date
3673
3674   IFS="${IFS:-  }"; ac_save_ifs="$IFS"; IFS="${IFS}${PATH_SEPARATOR}"
3675   for cf_dir in $MANPATH; do
3676     test -z "$cf_dir" && cf_dir=/usr/man
3677     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
3678     do
3679       cf_test=`echo $cf_name | sed -e 's/*//'`
3680       if test "x$cf_test" = "x$cf_name" ; then
3681
3682         case "$cf_name" in
3683         *.gz) MANPAGE_FORMAT="$MANPAGE_FORMAT gzip";;
3684         *.Z)  MANPAGE_FORMAT="$MANPAGE_FORMAT compress";;
3685         *.0)    MANPAGE_FORMAT="$MANPAGE_FORMAT BSDI";;
3686         *)    MANPAGE_FORMAT="$MANPAGE_FORMAT normal";;
3687         esac
3688
3689         case "$cf_name" in
3690         $cf_dir/man*)
3691           cf_catonly=no
3692           ;;
3693         $cf_dir/cat*)
3694           cf_preform=yes
3695           ;;
3696         esac
3697         break
3698       fi
3699
3700       # if we found a match in either man* or cat*, stop looking
3701       if test -n "$MANPAGE_FORMAT" ; then
3702         cf_found=no
3703         test "$cf_preform" = yes && MANPAGE_FORMAT="$MANPAGE_FORMAT formatted"
3704         test "$cf_catonly" = yes && MANPAGE_FORMAT="$MANPAGE_FORMAT catonly"
3705         case "$cf_name" in
3706         $cf_dir/cat*)
3707           cf_found=yes
3708           ;;
3709         esac
3710         test $cf_found=yes && break
3711       fi
3712     done
3713     # only check the first directory in $MANPATH where we find manpages
3714     if test -n "$MANPAGE_FORMAT" ; then
3715        break
3716     fi
3717   done
3718   # if we did not find the example, just assume it is normal
3719   test -z "$MANPAGE_FORMAT" && MANPAGE_FORMAT=normal
3720   IFS="$ac_save_ifs"
3721   ;;
3722 *)
3723   for cf_option in $MANPAGE_FORMAT; do
3724      case $cf_option in #(vi
3725      gzip|compress|BSDI|normal|formatted|catonly)
3726        ;;
3727      *)
3728        cf_unknown="$cf_unknown $cf_option"
3729        ;;
3730      esac
3731   done
3732   ;;
3733 esac
3734
3735 AC_MSG_RESULT($MANPAGE_FORMAT)
3736 if test -n "$cf_unknown" ; then
3737   AC_MSG_WARN(Unexpected manpage-format $cf_unknown)
3738 fi
3739 ])dnl
3740 dnl ---------------------------------------------------------------------------
3741 dnl CF_MANPAGE_RENAMES version: 7 updated: 2005/06/18 18:51:57
3742 dnl ------------------
3743 dnl The Debian people have their own naming convention for manpages.  This
3744 dnl option lets us override the name of the file containing renaming, or
3745 dnl disable it altogether.
3746 AC_DEFUN([CF_MANPAGE_RENAMES],
3747 [
3748 AC_MSG_CHECKING(for manpage renaming)
3749
3750 AC_ARG_WITH(manpage-renames,
3751         [  --with-manpage-renames  specify manpage-renaming],
3752         [MANPAGE_RENAMES=$withval],
3753         [MANPAGE_RENAMES=yes])
3754
3755 case ".$MANPAGE_RENAMES" in #(vi
3756 .no) #(vi
3757   ;;
3758 .|.yes)
3759   # Debian 'man' program?
3760   if test -f /etc/debian_version ; then
3761     MANPAGE_RENAMES=`cd $srcdir && pwd`/man/man_db.renames
3762   else
3763     MANPAGE_RENAMES=no
3764   fi
3765   ;;