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