aclocal.m4

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