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