aclocal.m4

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