aclocal.m4

   1 dnl***************************************************************************
   2 dnl Copyright 2018-2022,2023 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.1038 2023/04/15 20:03:39 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: 7 updated: 2023/01/11 04:05:23
  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([
  58 $ac_includes_default
  59 #include <langinfo.h>],
  60         [char* cs = nl_langinfo(CODESET); (void)cs],
  61         am_cv_langinfo_codeset=yes,
  62         am_cv_langinfo_codeset=no)
  63         ])
  64         if test "$am_cv_langinfo_codeset" = yes; then
  65                 AC_DEFINE(HAVE_LANGINFO_CODESET, 1,
  66                 [Define if you have <langinfo.h> and nl_langinfo(CODESET).])
  67         fi
  68 ])dnl
  69 dnl ---------------------------------------------------------------------------
  70 dnl CF_ABI_DEFAULTS version: 4 updated: 2023/01/07 16:32:06
  71 dnl ---------------
  72 dnl Provide configure-script defaults for different ncurses ABIs.
  73 AC_DEFUN([CF_ABI_DEFAULTS],[
  74 AC_REQUIRE([CF_NCURSES_WITH_ABI_VERSION])
  75
  76 # ABI 5 defaults:
  77 cf_dft_ccharw_max=5
  78 cf_dft_chtype=auto
  79 cf_dft_ext_colors=no
  80 cf_dft_ext_const=no
  81 cf_dft_ext_mouse=no
  82 cf_dft_ext_putwin=no
  83 cf_dft_ext_spfuncs=no
  84 cf_dft_filter_syms=no
  85 cf_dft_interop=no
  86 cf_dft_mmask_t=auto
  87 cf_dft_opaque_curses=no
  88 cf_dft_ordinate_type=short
  89 cf_dft_signed_char=no
  90 cf_dft_tparm_arg=long
  91 cf_dft_with_lp64=no
  92
  93 # ABI 6 defaults:
  94 case x$cf_cv_abi_default in
  95 (x[[6789]])
  96         cf_dft_chtype=uint32_t
  97         cf_dft_ext_colors=yes
  98         cf_dft_ext_const=yes
  99         cf_dft_ext_mouse=yes
 100         cf_dft_ext_putwin=yes
 101         cf_dft_ext_spfuncs=yes
 102         cf_dft_filter_syms=yes
 103         cf_dft_interop=yes
 104         cf_dft_mmask_t=uint32_t
 105         cf_dft_tparm_arg=intptr_t
 106         cf_dft_with_lp64=yes
 107         ;;
 108 esac
 109
 110 # ABI 7 defaults:
 111 case x$cf_cv_abi_default in
 112 (x[[789]])
 113         cf_dft_ccharw_max=6
 114         cf_dft_mmask_t=uint64_t
 115         cf_dft_opaque_curses=yes
 116         cf_dft_ordinate_type=int
 117         cf_dft_signed_char=yes
 118         # also: remove the wgetch-events feature in ABI 7
 119         ;;
 120 esac
 121 ])dnl
 122 dnl ---------------------------------------------------------------------------
 123 dnl CF_ACVERSION_CHECK version: 5 updated: 2014/06/04 19:11:49
 124 dnl ------------------
 125 dnl Conditionally generate script according to whether we're using a given autoconf.
 126 dnl
 127 dnl $1 = version to compare against
 128 dnl $2 = code to use if AC_ACVERSION is at least as high as $1.
 129 dnl $3 = code to use if AC_ACVERSION is older than $1.
 130 define([CF_ACVERSION_CHECK],
 131 [
 132 ifdef([AC_ACVERSION], ,[ifdef([AC_AUTOCONF_VERSION],[m4_copy([AC_AUTOCONF_VERSION],[AC_ACVERSION])],[m4_copy([m4_PACKAGE_VERSION],[AC_ACVERSION])])])dnl
 133 ifdef([m4_version_compare],
 134 [m4_if(m4_version_compare(m4_defn([AC_ACVERSION]), [$1]), -1, [$3], [$2])],
 135 [CF_ACVERSION_COMPARE(
 136 AC_PREREQ_CANON(AC_PREREQ_SPLIT([$1])),
 137 AC_PREREQ_CANON(AC_PREREQ_SPLIT(AC_ACVERSION)), AC_ACVERSION, [$2], [$3])])])dnl
 138 dnl ---------------------------------------------------------------------------
 139 dnl CF_ACVERSION_COMPARE version: 3 updated: 2012/10/03 18:39:53
 140 dnl --------------------
 141 dnl CF_ACVERSION_COMPARE(MAJOR1, MINOR1, TERNARY1,
 142 dnl                      MAJOR2, MINOR2, TERNARY2,
 143 dnl                      PRINTABLE2, not FOUND, FOUND)
 144 define([CF_ACVERSION_COMPARE],
 145 [ifelse(builtin([eval], [$2 < $5]), 1,
 146 [ifelse([$8], , ,[$8])],
 147 [ifelse([$9], , ,[$9])])])dnl
 148 dnl ---------------------------------------------------------------------------
 149 dnl CF_ADA_INCLUDE_DIRS version: 8 updated: 2013/10/14 04:24:07
 150 dnl -------------------
 151 dnl Construct the list of include-options for the C programs in the Ada95
 152 dnl binding.
 153 AC_DEFUN([CF_ADA_INCLUDE_DIRS],
 154 [
 155 ACPPFLAGS="-I. -I../include -I../../include $ACPPFLAGS"
 156 if test "$srcdir" != "."; then
 157         ACPPFLAGS="-I\${srcdir}/../../include $ACPPFLAGS"
 158 fi
 159 if test "$GCC" != yes; then
 160         ACPPFLAGS="$ACPPFLAGS -I\${includedir}"
 161 elif test "$includedir" != "/usr/include"; then
 162         if test "$includedir" = '${prefix}/include' ; then
 163                 if test x$prefix != x/usr ; then
 164                         ACPPFLAGS="$ACPPFLAGS -I\${includedir}"
 165                 fi
 166         else
 167                 ACPPFLAGS="$ACPPFLAGS -I\${includedir}"
 168         fi
 169 fi
 170 AC_SUBST(ACPPFLAGS)
 171 ])dnl
 172 dnl ---------------------------------------------------------------------------
 173 dnl CF_ADD_ADAFLAGS version: 1 updated: 2010/06/19 15:22:18
 174 dnl ---------------
 175 dnl Add to $ADAFLAGS, which is substituted into makefile and scripts.
 176 AC_DEFUN([CF_ADD_ADAFLAGS],[
 177         ADAFLAGS="$ADAFLAGS $1"
 178         AC_SUBST(ADAFLAGS)
 179 ])dnl
 180 dnl ---------------------------------------------------------------------------
 181 dnl CF_ADD_CFLAGS version: 15 updated: 2020/12/31 10:54:15
 182 dnl -------------
 183 dnl Copy non-preprocessor flags to $CFLAGS, preprocessor flags to $CPPFLAGS
 184 dnl $1 = flags to add
 185 dnl $2 = if given makes this macro verbose.
 186 dnl
 187 dnl Put any preprocessor definitions that use quoted strings in $EXTRA_CPPFLAGS,
 188 dnl to simplify use of $CPPFLAGS in compiler checks, etc., that are easily
 189 dnl confused by the quotes (which require backslashes to keep them usable).
 190 AC_DEFUN([CF_ADD_CFLAGS],
 191 [
 192 cf_fix_cppflags=no
 193 cf_new_cflags=
 194 cf_new_cppflags=
 195 cf_new_extra_cppflags=
 196
 197 for cf_add_cflags in $1
 198 do
 199 case "$cf_fix_cppflags" in
 200 (no)
 201         case "$cf_add_cflags" in
 202         (-undef|-nostdinc*|-I*|-D*|-U*|-E|-P|-C)
 203                 case "$cf_add_cflags" in
 204                 (-D*)
 205                         cf_tst_cflags=`echo "${cf_add_cflags}" |sed -e 's/^-D[[^=]]*='\''\"[[^"]]*//'`
 206
 207                         test "x${cf_add_cflags}" != "x${cf_tst_cflags}" \
 208                                 && test -z "${cf_tst_cflags}" \
 209                                 && cf_fix_cppflags=yes
 210
 211                         if test "$cf_fix_cppflags" = yes ; then
 212                                 CF_APPEND_TEXT(cf_new_extra_cppflags,$cf_add_cflags)
 213                                 continue
 214                         elif test "${cf_tst_cflags}" = "\"'" ; then
 215                                 CF_APPEND_TEXT(cf_new_extra_cppflags,$cf_add_cflags)
 216                                 continue
 217                         fi
 218                         ;;
 219                 esac
 220                 case "$CPPFLAGS" in
 221                 (*$cf_add_cflags)
 222                         ;;
 223                 (*)
 224                         case "$cf_add_cflags" in
 225                         (-D*)
 226                                 cf_tst_cppflags=`echo "x$cf_add_cflags" | sed -e 's/^...//' -e 's/=.*//'`
 227                                 CF_REMOVE_DEFINE(CPPFLAGS,$CPPFLAGS,$cf_tst_cppflags)
 228                                 ;;
 229                         esac
 230                         CF_APPEND_TEXT(cf_new_cppflags,$cf_add_cflags)
 231                         ;;
 232                 esac
 233                 ;;
 234         (*)
 235                 CF_APPEND_TEXT(cf_new_cflags,$cf_add_cflags)
 236                 ;;
 237         esac
 238         ;;
 239 (yes)
 240         CF_APPEND_TEXT(cf_new_extra_cppflags,$cf_add_cflags)
 241
 242         cf_tst_cflags=`echo "${cf_add_cflags}" |sed -e 's/^[[^"]]*"'\''//'`
 243
 244         test "x${cf_add_cflags}" != "x${cf_tst_cflags}" \
 245                 && test -z "${cf_tst_cflags}" \
 246                 && cf_fix_cppflags=no
 247         ;;
 248 esac
 249 done
 250
 251 if test -n "$cf_new_cflags" ; then
 252         ifelse([$2],,,[CF_VERBOSE(add to \$CFLAGS $cf_new_cflags)])
 253         CF_APPEND_TEXT(CFLAGS,$cf_new_cflags)
 254 fi
 255
 256 if test -n "$cf_new_cppflags" ; then
 257         ifelse([$2],,,[CF_VERBOSE(add to \$CPPFLAGS $cf_new_cppflags)])
 258         CF_APPEND_TEXT(CPPFLAGS,$cf_new_cppflags)
 259 fi
 260
 261 if test -n "$cf_new_extra_cppflags" ; then
 262         ifelse([$2],,,[CF_VERBOSE(add to \$EXTRA_CPPFLAGS $cf_new_extra_cppflags)])
 263         CF_APPEND_TEXT(EXTRA_CPPFLAGS,$cf_new_extra_cppflags)
 264 fi
 265
 266 AC_SUBST(EXTRA_CPPFLAGS)
 267
 268 ])dnl
 269 dnl ---------------------------------------------------------------------------
 270 dnl CF_ADD_CXXFLAGS version: 1 updated: 2020/04/04 16:16:13
 271 dnl ---------------
 272 dnl Copy non-preprocessor flags to $CXXFLAGS, preprocessor flags to $CPPFLAGS
 273 dnl The second parameter if given makes this macro verbose.
 274 dnl
 275 dnl Put any preprocessor definitions that use quoted strings in $EXTRA_CPPFLAGS,
 276 dnl to simplify use of $CPPFLAGS in compiler checks, etc., that are easily
 277 dnl confused by the quotes (which require backslashes to keep them usable).
 278 AC_DEFUN([CF_ADD_CXXFLAGS],
 279 [
 280 cf_save_CXXFLAGS="$CFLAGS"
 281 CFLAGS="$CXXFLAGS"
 282 CF_ADD_CFLAGS($1 ifelse($2,,,[,$2]))
 283 CXXFLAGS="$CFLAGS"
 284 CFLAGS="$cf_save_CXXFLAGS"
 285 ])dnl
 286 dnl ---------------------------------------------------------------------------
 287 dnl CF_ADD_INCDIR version: 17 updated: 2021/09/04 06:35:04
 288 dnl -------------
 289 dnl Add an include-directory to $CPPFLAGS.  Don't add /usr/include, since it is
 290 dnl redundant.  We don't normally need to add -I/usr/local/include for gcc,
 291 dnl but old versions (and some misinstalled ones) need that.  To make things
 292 dnl worse, gcc 3.x may give error messages if -I/usr/local/include is added to
 293 dnl the include-path).
 294 AC_DEFUN([CF_ADD_INCDIR],
 295 [
 296 if test -n "$1" ; then
 297   for cf_add_incdir in $1
 298   do
 299         while test "$cf_add_incdir" != /usr/include
 300         do
 301           if test -d "$cf_add_incdir"
 302           then
 303                 cf_have_incdir=no
 304                 if test -n "$CFLAGS$CPPFLAGS" ; then
 305                   # a loop is needed to ensure we can add subdirs of existing dirs
 306                   for cf_test_incdir in $CFLAGS $CPPFLAGS ; do
 307                         if test ".$cf_test_incdir" = ".-I$cf_add_incdir" ; then
 308                           cf_have_incdir=yes; break
 309                         fi
 310                   done
 311                 fi
 312
 313                 if test "$cf_have_incdir" = no ; then
 314                   if test "$cf_add_incdir" = /usr/local/include ; then
 315                         if test "$GCC" = yes
 316                         then
 317                           cf_save_CPPFLAGS=$CPPFLAGS
 318                           CF_APPEND_TEXT(CPPFLAGS,-I$cf_add_incdir)
 319                           AC_TRY_COMPILE([#include <stdio.h>],
 320                                   [printf("Hello")],
 321                                   [],
 322                                   [cf_have_incdir=yes])
 323                           CPPFLAGS=$cf_save_CPPFLAGS
 324                         fi
 325                   fi
 326                 fi
 327
 328                 if test "$cf_have_incdir" = no ; then
 329                   CF_VERBOSE(adding $cf_add_incdir to include-path)
 330                   ifelse([$2],,CPPFLAGS,[$2])="$ifelse([$2],,CPPFLAGS,[$2]) -I$cf_add_incdir"
 331
 332                   cf_top_incdir=`echo "$cf_add_incdir" | sed -e 's%/include/.*$%/include%'`
 333                   test "$cf_top_incdir" = "$cf_add_incdir" && break
 334                   cf_add_incdir="$cf_top_incdir"
 335                 else
 336                   break
 337                 fi
 338           else
 339                 break
 340           fi
 341         done
 342   done
 343 fi
 344 ])dnl
 345 dnl ---------------------------------------------------------------------------
 346 dnl CF_ADD_LIB version: 2 updated: 2010/06/02 05:03:05
 347 dnl ----------
 348 dnl Add a library, used to enforce consistency.
 349 dnl
 350 dnl $1 = library to add, without the "-l"
 351 dnl $2 = variable to update (default $LIBS)
 352 AC_DEFUN([CF_ADD_LIB],[CF_ADD_LIBS(-l$1,ifelse($2,,LIBS,[$2]))])dnl
 353 dnl ---------------------------------------------------------------------------
 354 dnl CF_ADD_LIBDIR version: 11 updated: 2020/12/31 20:19:42
 355 dnl -------------
 356 dnl     Adds to the library-path
 357 dnl
 358 dnl     Some machines have trouble with multiple -L options.
 359 dnl
 360 dnl $1 is the (list of) directory(s) to add
 361 dnl $2 is the optional name of the variable to update (default LDFLAGS)
 362 dnl
 363 AC_DEFUN([CF_ADD_LIBDIR],
 364 [
 365 if test -n "$1" ; then
 366         for cf_add_libdir in $1
 367         do
 368                 if test "$cf_add_libdir" = /usr/lib ; then
 369                         :
 370                 elif test -d "$cf_add_libdir"
 371                 then
 372                         cf_have_libdir=no
 373                         if test -n "$LDFLAGS$LIBS" ; then
 374                                 # a loop is needed to ensure we can add subdirs of existing dirs
 375                                 for cf_test_libdir in $LDFLAGS $LIBS ; do
 376                                         if test ".$cf_test_libdir" = ".-L$cf_add_libdir" ; then
 377                                                 cf_have_libdir=yes; break
 378                                         fi
 379                                 done
 380                         fi
 381                         if test "$cf_have_libdir" = no ; then
 382                                 CF_VERBOSE(adding $cf_add_libdir to library-path)
 383                                 ifelse([$2],,LDFLAGS,[$2])="-L$cf_add_libdir $ifelse([$2],,LDFLAGS,[$2])"
 384                         fi
 385                 fi
 386         done
 387 fi
 388 ])dnl
 389 dnl ---------------------------------------------------------------------------
 390 dnl CF_ADD_LIBS version: 3 updated: 2019/11/02 16:47:33
 391 dnl -----------
 392 dnl Add one or more libraries, used to enforce consistency.  Libraries are
 393 dnl prepended to an existing list, since their dependencies are assumed to
 394 dnl already exist in the list.
 395 dnl
 396 dnl $1 = libraries to add, with the "-l", etc.
 397 dnl $2 = variable to update (default $LIBS)
 398 AC_DEFUN([CF_ADD_LIBS],[
 399 cf_add_libs="[$]ifelse($2,,LIBS,[$2])"
 400 # reverse order
 401 cf_add_0lib=
 402 for cf_add_1lib in $1; do cf_add_0lib="$cf_add_1lib $cf_add_0lib"; done
 403 # filter duplicates
 404 for cf_add_1lib in $cf_add_0lib; do
 405         for cf_add_2lib in $cf_add_libs; do
 406                 if test "x$cf_add_1lib" = "x$cf_add_2lib"; then
 407                         cf_add_1lib=
 408                         break
 409                 fi
 410         done
 411         test -n "$cf_add_1lib" && cf_add_libs="$cf_add_1lib $cf_add_libs"
 412 done
 413 ifelse($2,,LIBS,[$2])="$cf_add_libs"
 414 ])dnl
 415 dnl ---------------------------------------------------------------------------
 416 dnl CF_ADD_SUBDIR_PATH version: 5 updated: 2020/12/31 20:19:42
 417 dnl ------------------
 418 dnl Append to a search-list for a nonstandard header/lib-file
 419 dnl     $1 = the variable to return as result
 420 dnl     $2 = the package name
 421 dnl     $3 = the subdirectory, e.g., bin, include or lib
 422 dnl $4 = the directory under which we will test for subdirectories
 423 dnl $5 = a directory that we do not want $4 to match
 424 AC_DEFUN([CF_ADD_SUBDIR_PATH],
 425 [
 426 test "x$4" != "x$5" && \
 427 test -d "$4" && \
 428 ifelse([$5],NONE,,[{ test -z "$5" || test "x$5" = xNONE || test "x$4" != "x$5"; } &&]) {
 429         test -n "$verbose" && echo "    ... testing for $3-directories under $4"
 430         test -d "$4/$3" &&          $1="[$]$1 $4/$3"
 431         test -d "$4/$3/$2" &&       $1="[$]$1 $4/$3/$2"
 432         test -d "$4/$3/$2/$3" &&    $1="[$]$1 $4/$3/$2/$3"
 433         test -d "$4/$2/$3" &&       $1="[$]$1 $4/$2/$3"
 434         test -d "$4/$2/$3/$2" &&    $1="[$]$1 $4/$2/$3/$2"
 435 }
 436 ])dnl
 437 dnl ---------------------------------------------------------------------------
 438 dnl CF_APPEND_CFLAGS version: 3 updated: 2021/09/05 17:25:40
 439 dnl ----------------
 440 dnl Use CF_ADD_CFLAGS after first checking for potential redefinitions.
 441 dnl $1 = flags to add
 442 dnl $2 = if given makes this macro verbose.
 443 define([CF_APPEND_CFLAGS],
 444 [
 445 for cf_add_cflags in $1
 446 do
 447         case "x$cf_add_cflags" in
 448         (x-[[DU]]*)
 449                 CF_REMOVE_CFLAGS($cf_add_cflags,CFLAGS,[$2])
 450                 CF_REMOVE_CFLAGS($cf_add_cflags,CPPFLAGS,[$2])
 451                 ;;
 452         esac
 453         CF_ADD_CFLAGS([$cf_add_cflags],[$2])
 454 done
 455 ])dnl
 456 dnl ---------------------------------------------------------------------------
 457 dnl CF_APPEND_TEXT version: 1 updated: 2017/02/25 18:58:55
 458 dnl --------------
 459 dnl use this macro for appending text without introducing an extra blank at
 460 dnl the beginning
 461 define([CF_APPEND_TEXT],
 462 [
 463         test -n "[$]$1" && $1="[$]$1 "
 464         $1="[$]{$1}$2"
 465 ])dnl
 466 dnl ---------------------------------------------------------------------------
 467 dnl CF_ARG_DISABLE version: 3 updated: 1999/03/30 17:24:31
 468 dnl --------------
 469 dnl Allow user to disable a normally-on option.
 470 AC_DEFUN([CF_ARG_DISABLE],
 471 [CF_ARG_OPTION($1,[$2],[$3],[$4],yes)])dnl
 472 dnl ---------------------------------------------------------------------------
 473 dnl CF_ARG_ENABLE version: 3 updated: 1999/03/30 17:24:31
 474 dnl -------------
 475 dnl Allow user to enable a normally-off option.
 476 AC_DEFUN([CF_ARG_ENABLE],
 477 [CF_ARG_OPTION($1,[$2],[$3],[$4],no)])dnl
 478 dnl ---------------------------------------------------------------------------
 479 dnl CF_ARG_OPTION version: 5 updated: 2015/05/10 19:52:14
 480 dnl -------------
 481 dnl Restricted form of AC_ARG_ENABLE that ensures user doesn't give bogus
 482 dnl values.
 483 dnl
 484 dnl Parameters:
 485 dnl $1 = option name
 486 dnl $2 = help-string
 487 dnl $3 = action to perform if option is not default
 488 dnl $4 = action if perform if option is default
 489 dnl $5 = default option value (either 'yes' or 'no')
 490 AC_DEFUN([CF_ARG_OPTION],
 491 [AC_ARG_ENABLE([$1],[$2],[test "$enableval" != ifelse([$5],no,yes,no) && enableval=ifelse([$5],no,no,yes)
 492         if test "$enableval" != "$5" ; then
 493 ifelse([$3],,[    :]dnl
 494 ,[    $3]) ifelse([$4],,,[
 495         else
 496                 $4])
 497         fi],[enableval=$5 ifelse([$4],,,[
 498         $4
 499 ])dnl
 500 ])])dnl
 501 dnl ---------------------------------------------------------------------------
 502 dnl CF_AR_FLAGS version: 9 updated: 2021/01/01 13:31:04
 503 dnl -----------
 504 dnl Check for suitable "ar" (archiver) options for updating an archive.
 505 dnl
 506 dnl In particular, handle some obsolete cases where the "-" might be omitted,
 507 dnl as well as a workaround for breakage of make's archive rules by the GNU
 508 dnl binutils "ar" program.
 509 AC_DEFUN([CF_AR_FLAGS],[
 510 AC_REQUIRE([CF_PROG_AR])
 511
 512 AC_CACHE_CHECK(for options to update archives, cf_cv_ar_flags,[
 513         case "$cf_cv_system_name" in
 514         (*-msvc*)
 515                 cf_cv_ar_flags=''
 516                 cat >mk_static_lib.sh <<-EOF
 517                 #!$SHELL
 518                 MSVC_BIN="[$]AR"
 519                 out="\[$]1"
 520                 shift
 521                 exec \[$]MSVC_BIN -out:"\[$]out" \[$]@
 522                 EOF
 523                 chmod +x mk_static_lib.sh
 524                 AR=`pwd`/mk_static_lib.sh
 525                 ;;
 526         (*)
 527                 cf_cv_ar_flags=unknown
 528                 for cf_ar_flags in -curvU -curv curv -crv crv -cqv cqv -rv rv
 529                 do
 530
 531                         # check if $ARFLAGS already contains this choice
 532                         if test "x$ARFLAGS" != "x" ; then
 533                                 cf_check_ar_flags=`echo "x$ARFLAGS" | sed -e "s/$cf_ar_flags\$//" -e "s/$cf_ar_flags / /"`
 534                                 if test "x$ARFLAGS" != "$cf_check_ar_flags" ; then
 535                                         cf_cv_ar_flags=
 536                                         break
 537                                 fi
 538                         fi
 539
 540                         rm -f "conftest.$ac_cv_objext"
 541                         rm -f conftest.a
 542
 543                         cat >"conftest.$ac_ext" <<EOF
 544 #line __oline__ "configure"
 545 int     testdata[[3]] = { 123, 456, 789 };
 546 EOF
 547                         if AC_TRY_EVAL(ac_compile) ; then
 548                                 echo "$AR $ARFLAGS $cf_ar_flags conftest.a conftest.$ac_cv_objext" >&AC_FD_CC
 549                                 $AR $ARFLAGS "$cf_ar_flags" conftest.a "conftest.$ac_cv_objext" 2>&AC_FD_CC 1>/dev/null
 550                                 if test -f conftest.a ; then
 551                                         cf_cv_ar_flags="$cf_ar_flags"
 552                                         break
 553                                 fi
 554                         else
 555                                 CF_VERBOSE(cannot compile test-program)
 556                                 break
 557                         fi
 558                 done
 559                 rm -f conftest.a "conftest.$ac_ext" "conftest.$ac_cv_objext"
 560                 ;;
 561         esac
 562 ])
 563
 564 if test -n "$ARFLAGS" ; then
 565         if test -n "$cf_cv_ar_flags" ; then
 566                 ARFLAGS="$ARFLAGS $cf_cv_ar_flags"
 567         fi
 568 else
 569         ARFLAGS=$cf_cv_ar_flags
 570 fi
 571
 572 AC_SUBST(ARFLAGS)
 573 ])
 574 dnl ---------------------------------------------------------------------------
 575 dnl CF_AWK_BIG_PRINTF version: 5 updated: 2015/04/17 21:13:04
 576 dnl -----------------
 577 dnl Check if awk can handle big strings using printf.  Some older versions of
 578 dnl awk choke on large strings passed via "%s".
 579 dnl
 580 dnl $1 = desired string size
 581 dnl $2 = variable to set with result
 582 AC_DEFUN([CF_AWK_BIG_PRINTF],
 583 [
 584         case x$AWK in
 585         (x)
 586                 eval $2=no
 587                 ;;
 588         (*)
 589                 if ( ${AWK} 'BEGIN { xx = "x"; while (length(xx) < $1) { xx = xx "x"; }; printf("%s\n", xx); }' 2>/dev/null \
 590                         | $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
 591                         eval $2=yes
 592                 else
 593                         eval $2=no
 594                 fi
 595                 ;;
 596         esac
 597 ])dnl
 598 dnl ---------------------------------------------------------------------------
 599 dnl CF_BOOL_DECL version: 8 updated: 2004/01/30 15:51:18
 600 dnl ------------
 601 dnl Test if 'bool' is a builtin type in the configured C++ compiler.  Some
 602 dnl older compilers (e.g., gcc 2.5.8) don't support 'bool' directly; gcc
 603 dnl 2.6.3 does, in anticipation of the ANSI C++ standard.
 604 dnl
 605 dnl Treat the configuration-variable specially here, since we're directly
 606 dnl substituting its value (i.e., 1/0).
 607 dnl
 608 dnl $1 is the shell variable to store the result in, if not $cv_cv_builtin_bool
 609 AC_DEFUN([CF_BOOL_DECL],
 610 [
 611 AC_MSG_CHECKING(if we should include stdbool.h)
 612
 613 AC_CACHE_VAL(cf_cv_header_stdbool_h,[
 614         AC_TRY_COMPILE([],[bool foo = false],
 615                 [cf_cv_header_stdbool_h=0],
 616                 [AC_TRY_COMPILE([
 617 #ifndef __BEOS__
 618 #include <stdbool.h>
 619 #endif
 620 ],[bool foo = false],
 621                         [cf_cv_header_stdbool_h=1],
 622                         [cf_cv_header_stdbool_h=0])])])
 623
 624 if test "$cf_cv_header_stdbool_h" = 1
 625 then    AC_MSG_RESULT(yes)
 626 else    AC_MSG_RESULT(no)
 627 fi
 628
 629 AC_MSG_CHECKING([for builtin bool type])
 630
 631 AC_CACHE_VAL(ifelse($1,,cf_cv_builtin_bool,[$1]),[
 632         AC_TRY_COMPILE([
 633 #include <stdio.h>
 634 #include <sys/types.h>
 635 ],[bool x = false],
 636                 [ifelse($1,,cf_cv_builtin_bool,[$1])=1],
 637                 [ifelse($1,,cf_cv_builtin_bool,[$1])=0])
 638         ])
 639
 640 if test "$ifelse($1,,cf_cv_builtin_bool,[$1])" = 1
 641 then    AC_MSG_RESULT(yes)
 642 else    AC_MSG_RESULT(no)
 643 fi
 644 ])dnl
 645 dnl ---------------------------------------------------------------------------
 646 dnl CF_BOOL_SIZE version: 20 updated: 2023/02/18 17:41:25
 647 dnl ------------
 648 dnl Test for the size of 'bool' in the configured C++ compiler (e.g., a type).
 649 dnl Don't bother looking for bool.h, since it has been deprecated.
 650 dnl
 651 dnl If the current compiler is C rather than C++, we get the bool definition
 652 dnl from <stdbool.h>.
 653 AC_DEFUN([CF_BOOL_SIZE],
 654 [
 655 AC_CHECK_SIZEOF(bool,,[
 656 $ac_includes_default
 657
 658 #if defined(__cplusplus)
 659
 660 #ifdef HAVE_GXX_BUILTIN_H
 661 #include <g++/builtin.h>
 662 #elif HAVE_GPP_BUILTIN_H
 663 #include <gpp/builtin.h>
 664 #elif HAVE_BUILTIN_H
 665 #include <builtin.h>
 666 #endif
 667
 668 #else
 669
 670 #if $cf_cv_header_stdbool_h
 671 #include <stdbool.h>
 672 #endif
 673
 674 #endif
 675 ])
 676
 677 AC_CACHE_CHECK(for type of bool, cf_cv_type_of_bool,[
 678         rm -f cf_test.out
 679         AC_TRY_RUN([
 680 $ac_includes_default
 681
 682 #if defined(__cplusplus)
 683
 684 #ifdef HAVE_GXX_BUILTIN_H
 685 #include <g++/builtin.h>
 686 #elif HAVE_GPP_BUILTIN_H
 687 #include <gpp/builtin.h>
 688 #elif HAVE_BUILTIN_H
 689 #include <builtin.h>
 690 #endif
 691
 692 #else
 693
 694 #if $cf_cv_header_stdbool_h
 695 #include <stdbool.h>
 696 #endif
 697
 698 #endif
 699
 700 int main(void)
 701 {
 702         FILE *fp = fopen("cf_test.out", "w");
 703         if (fp != 0) {
 704                 bool x = true;
 705                 if ((bool)(-x) >= 0)
 706                         fputs("unsigned ", fp);
 707                 if (sizeof(x) == sizeof(int))       fputs("int",  fp);
 708                 else if (sizeof(x) == sizeof(char)) fputs("char", fp);
 709                 else if (sizeof(x) == sizeof(short))fputs("short",fp);
 710                 else if (sizeof(x) == sizeof(long)) fputs("long", fp);
 711                 fclose(fp);
 712         }
 713         ${cf_cv_main_return:-return}(0);
 714 }
 715                 ],
 716                 [cf_cv_type_of_bool=`cat cf_test.out`
 717                  if test -z "$cf_cv_type_of_bool"; then
 718                    cf_cv_type_of_bool=unknown
 719                  fi],
 720                 [cf_cv_type_of_bool=unknown],
 721                 [
 722                 case x$ac_cv_sizeof_bool in
 723                 (x1) cf_cv_type_of_bool="unsigned char";;
 724                 (x2) cf_cv_type_of_bool="unsigned short";;
 725                 (x4) cf_cv_type_of_bool="unsigned int";;
 726                 (x8) cf_cv_type_of_bool="unsigned long";;
 727                 (*)  cf_cv_type_of_bool=unknown;;
 728                 esac
 729                 ])
 730         rm -f cf_test.out
 731 ])
 732
 733 if test "$cf_cv_type_of_bool" = unknown ; then
 734         case .$NCURSES_BOOL in
 735         (.auto|.) NCURSES_BOOL=unsigned;;
 736         esac
 737         AC_MSG_WARN(Assuming $NCURSES_BOOL for type of bool)
 738         cf_cv_type_of_bool=$NCURSES_BOOL
 739 fi
 740 ])dnl
 741 dnl ---------------------------------------------------------------------------
 742 dnl CF_BUILD_CC version: 11 updated: 2022/12/04 15:40:08
 743 dnl -----------
 744 dnl If we're cross-compiling, allow the user to override the tools and their
 745 dnl options.  The configure script is oriented toward identifying the host
 746 dnl compiler, etc., but we need a build compiler to generate parts of the
 747 dnl source.
 748 dnl
 749 dnl $1 = default for $CPPFLAGS
 750 dnl $2 = default for $LIBS
 751 AC_DEFUN([CF_BUILD_CC],[
 752 CF_ACVERSION_CHECK(2.52,,
 753         [AC_REQUIRE([CF_PROG_EXT])])
 754 if test "$cross_compiling" = yes ; then
 755
 756         # defaults that we might want to override
 757         : ${BUILD_CFLAGS:=''}
 758         : ${BUILD_CPPFLAGS:='ifelse([$1],,,[$1])'}
 759         : ${BUILD_LDFLAGS:=''}
 760         : ${BUILD_LIBS:='ifelse([$2],,,[$2])'}
 761         : ${BUILD_EXEEXT:='$x'}
 762         : ${BUILD_OBJEXT:='o'}
 763
 764         AC_ARG_WITH(build-cc,
 765                 [  --with-build-cc=XXX     the build C compiler ($BUILD_CC)],
 766                 [BUILD_CC="$withval"],
 767                 [AC_CHECK_PROGS(BUILD_CC, [gcc clang c99 c89 cc cl],none)])
 768         AC_MSG_CHECKING(for native build C compiler)
 769         AC_MSG_RESULT($BUILD_CC)
 770
 771         AC_MSG_CHECKING(for native build C preprocessor)
 772         AC_ARG_WITH(build-cpp,
 773                 [  --with-build-cpp=XXX    the build C preprocessor ($BUILD_CPP)],
 774                 [BUILD_CPP="$withval"],
 775                 [BUILD_CPP='${BUILD_CC} -E'])
 776         AC_MSG_RESULT($BUILD_CPP)
 777
 778         AC_MSG_CHECKING(for native build C flags)
 779         AC_ARG_WITH(build-cflags,
 780                 [  --with-build-cflags=XXX the build C compiler-flags ($BUILD_CFLAGS)],
 781                 [BUILD_CFLAGS="$withval"])
 782         AC_MSG_RESULT($BUILD_CFLAGS)
 783
 784         AC_MSG_CHECKING(for native build C preprocessor-flags)
 785         AC_ARG_WITH(build-cppflags,
 786                 [  --with-build-cppflags=XXX the build C preprocessor-flags ($BUILD_CPPFLAGS)],
 787                 [BUILD_CPPFLAGS="$withval"])
 788         AC_MSG_RESULT($BUILD_CPPFLAGS)
 789
 790         AC_MSG_CHECKING(for native build linker-flags)
 791         AC_ARG_WITH(build-ldflags,
 792                 [  --with-build-ldflags=XXX the build linker-flags ($BUILD_LDFLAGS)],
 793                 [BUILD_LDFLAGS="$withval"])
 794         AC_MSG_RESULT($BUILD_LDFLAGS)
 795
 796         AC_MSG_CHECKING(for native build linker-libraries)
 797         AC_ARG_WITH(build-libs,
 798                 [  --with-build-libs=XXX   the build libraries (${BUILD_LIBS})],
 799                 [BUILD_LIBS="$withval"])
 800         AC_MSG_RESULT($BUILD_LIBS)
 801
 802         # this assumes we're on Unix.
 803         BUILD_EXEEXT=
 804         BUILD_OBJEXT=o
 805
 806         : ${BUILD_CC:='${CC}'}
 807
 808         AC_MSG_CHECKING(if the build-compiler "$BUILD_CC" works)
 809
 810         cf_save_crossed=$cross_compiling
 811         cf_save_ac_link=$ac_link
 812         cross_compiling=no
 813         cf_build_cppflags=$BUILD_CPPFLAGS
 814         test "$cf_build_cppflags" = "#" && cf_build_cppflags=
 815         ac_link='$BUILD_CC -o "conftest$ac_exeext" $BUILD_CFLAGS $cf_build_cppflags $BUILD_LDFLAGS "conftest.$ac_ext" $BUILD_LIBS >&AS_MESSAGE_LOG_FD'
 816
 817         AC_TRY_RUN([#include <stdio.h>
 818                 int main(int argc, char *argv[])
 819                 {
 820                         ${cf_cv_main_return:-return}(argc < 0 || argv == 0 || argv[0] == 0);
 821                 }
 822         ],
 823                 cf_ok_build_cc=yes,
 824                 cf_ok_build_cc=no,
 825                 cf_ok_build_cc=unknown)
 826
 827         cross_compiling=$cf_save_crossed
 828         ac_link=$cf_save_ac_link
 829
 830         AC_MSG_RESULT($cf_ok_build_cc)
 831
 832         if test "$cf_ok_build_cc" != yes
 833         then
 834                 AC_MSG_ERROR([Cross-build requires two compilers.
 835 Use --with-build-cc to specify the native compiler.])
 836         fi
 837
 838 else
 839         : ${BUILD_CC:='${CC}'}
 840         : ${BUILD_CPP:='${CPP}'}
 841         : ${BUILD_CFLAGS:='${CFLAGS}'}
 842         : ${BUILD_CPPFLAGS:='${CPPFLAGS}'}
 843         : ${BUILD_LDFLAGS:='${LDFLAGS}'}
 844         : ${BUILD_LIBS:='${LIBS}'}
 845         : ${BUILD_EXEEXT:='$x'}
 846         : ${BUILD_OBJEXT:='o'}
 847 fi
 848
 849 AC_SUBST(BUILD_CC)
 850 AC_SUBST(BUILD_CPP)
 851 AC_SUBST(BUILD_CFLAGS)
 852 AC_SUBST(BUILD_CPPFLAGS)
 853 AC_SUBST(BUILD_LDFLAGS)
 854 AC_SUBST(BUILD_LIBS)
 855 AC_SUBST(BUILD_EXEEXT)
 856 AC_SUBST(BUILD_OBJEXT)
 857 ])dnl
 858 dnl ---------------------------------------------------------------------------
 859 dnl CF_C11_NORETURN version: 4 updated: 2023/02/18 17:41:25
 860 dnl ---------------
 861 AC_DEFUN([CF_C11_NORETURN],
 862 [
 863 AC_MSG_CHECKING(if you want to use C11 _Noreturn feature)
 864 CF_ARG_ENABLE(stdnoreturn,
 865         [  --enable-stdnoreturn    enable C11 _Noreturn feature for diagnostics],
 866         [enable_stdnoreturn=yes],
 867         [enable_stdnoreturn=no])
 868 AC_MSG_RESULT($enable_stdnoreturn)
 869
 870 if test $enable_stdnoreturn = yes; then
 871 AC_CACHE_CHECK([for C11 _Noreturn feature], cf_cv_c11_noreturn,
 872         [AC_TRY_COMPILE([
 873 $ac_includes_default
 874 #include <stdnoreturn.h>
 875 static _Noreturn void giveup(void) { exit(0); }
 876         ],
 877         [if (feof(stdin)) giveup()],
 878         cf_cv_c11_noreturn=yes,
 879         cf_cv_c11_noreturn=no)
 880         ])
 881 else
 882         cf_cv_c11_noreturn=no,
 883 fi
 884
 885 if test "$cf_cv_c11_noreturn" = yes; then
 886         AC_DEFINE(HAVE_STDNORETURN_H, 1,[Define if <stdnoreturn.h> header is available and working])
 887         AC_DEFINE_UNQUOTED(STDC_NORETURN,_Noreturn,[Define if C11 _Noreturn keyword is supported])
 888         HAVE_STDNORETURN_H=1
 889 else
 890         HAVE_STDNORETURN_H=0
 891 fi
 892
 893 AC_SUBST(HAVE_STDNORETURN_H)
 894 AC_SUBST(STDC_NORETURN)
 895 ])dnl
 896 dnl ---------------------------------------------------------------------------
 897 dnl CF_CC_ENV_FLAGS version: 11 updated: 2023/02/20 11:15:46
 898 dnl ---------------
 899 dnl Check for user's environment-breakage by stuffing CFLAGS/CPPFLAGS content
 900 dnl into CC.  This will not help with broken scripts that wrap the compiler
 901 dnl with options, but eliminates a more common category of user confusion.
 902 dnl
 903 dnl In particular, it addresses the problem of being able to run the C
 904 dnl preprocessor in a consistent manner.
 905 dnl
 906 dnl Caveat: this also disallows blanks in the pathname for the compiler, but
 907 dnl the nuisance of having inconsistent settings for compiler and preprocessor
 908 dnl outweighs that limitation.
 909 AC_DEFUN([CF_CC_ENV_FLAGS],
 910 [
 911 # This should have been defined by AC_PROG_CC
 912 : "${CC:=cc}"
 913
 914 AC_MSG_CHECKING(\$CFLAGS variable)
 915 case "x$CFLAGS" in
 916 (*-[[IUD]]*)
 917         AC_MSG_RESULT(broken)
 918         AC_MSG_WARN(your environment uses the CFLAGS variable to hold CPPFLAGS options)
 919         cf_flags="$CFLAGS"
 920         CFLAGS=
 921         for cf_arg in $cf_flags
 922         do
 923                 CF_ADD_CFLAGS($cf_arg)
 924         done
 925         ;;
 926 (*)
 927         AC_MSG_RESULT(ok)
 928         ;;
 929 esac
 930
 931 AC_MSG_CHECKING(\$CC variable)
 932 case "$CC" in
 933 (*[[\ \ ]]-*)
 934         AC_MSG_RESULT(broken)
 935         AC_MSG_WARN(your environment uses the CC variable to hold CFLAGS/CPPFLAGS options)
 936         # humor him...
 937         cf_prog=`echo "$CC" | sed -e 's/        / /g' -e 's/[[ ]]* / /g' -e 's/[[ ]]*[[ ]]-[[^ ]].*//'`
 938         cf_flags=`echo "$CC" | sed -e "s%^$cf_prog%%"`
 939         CC="$cf_prog"
 940         for cf_arg in $cf_flags
 941         do
 942                 case "x$cf_arg" in
 943                 (x-[[IUDfgOW]]*)
 944                         CF_ADD_CFLAGS($cf_arg)
 945                         ;;
 946                 (*)
 947                         CC="$CC $cf_arg"
 948                         ;;
 949                 esac
 950         done
 951         CF_VERBOSE(resulting CC: '$CC')
 952         CF_VERBOSE(resulting CFLAGS: '$CFLAGS')
 953         CF_VERBOSE(resulting CPPFLAGS: '$CPPFLAGS')
 954         ;;
 955 (*)
 956         AC_MSG_RESULT(ok)
 957         ;;
 958 esac
 959 ])dnl
 960 dnl ---------------------------------------------------------------------------
 961 dnl CF_CFG_DEFAULTS version: 16 updated: 2021/01/04 19:33:05
 962 dnl ---------------
 963 dnl Determine the default configuration into which we'll install ncurses.  This
 964 dnl can be overridden by the user's command-line options.  There's two items to
 965 dnl look for:
 966 dnl     1. the prefix (e.g., /usr)
 967 dnl     2. the header files (e.g., /usr/include/ncurses)
 968 dnl We'll look for a previous installation of ncurses and use the same defaults.
 969 dnl
 970 dnl We don't use AC_PREFIX_DEFAULT, because it gets evaluated too soon, and
 971 dnl we don't use AC_PREFIX_PROGRAM, because we cannot distinguish ncurses's
 972 dnl programs from a vendor's.
 973 AC_DEFUN([CF_CFG_DEFAULTS],
 974 [AC_REQUIRE([AC_PROG_FGREP])dnl
 975
 976 AC_MSG_CHECKING(for prefix)
 977 if test "x$prefix" = "xNONE" ; then
 978         case "$cf_cv_system_name" in
 979                 # non-vendor systems don't have a conflict
 980         (openbsd*|freebsd*|mirbsd*|linux*|cygwin*|msys*|k*bsd*-gnu|mingw*)
 981                 prefix=/usr
 982                 ;;
 983         (*)     prefix=$ac_default_prefix
 984                 ;;
 985         esac
 986 fi
 987 AC_MSG_RESULT($prefix)
 988
 989 if test "x$prefix" = "xNONE" ; then
 990 AC_MSG_CHECKING(for default include-directory)
 991 test -n "$verbose" && echo 1>&AC_FD_MSG
 992 for cf_symbol in \
 993         "$includedir" \
 994         "$includedir/ncurses" \
 995         "$prefix/include" \
 996         "$prefix/include/ncurses" \
 997         /usr/local/include \
 998         /usr/local/include/ncurses \
 999         /usr/include \
1000         /usr/include/ncurses
1001 do
1002         cf_dir=`eval echo "$cf_symbol"`
1003         if test -f "$cf_dir/curses.h" ; then
1004         if ( ${FGREP-fgrep} NCURSES_VERSION "$cf_dir/curses.h" >/dev/null 2>&1 ) ; then
1005                 includedir="$cf_symbol"
1006                 test -n "$verbose"  && echo $ECHO_N "   found " 1>&AC_FD_MSG
1007                 break
1008         fi
1009         fi
1010         test -n "$verbose"  && echo "   tested $cf_dir" 1>&AC_FD_MSG
1011 done
1012 AC_MSG_RESULT($includedir)
1013 fi
1014 ])dnl
1015 dnl ---------------------------------------------------------------------------
1016 dnl CF_CGETENT version: 7 updated: 2023/02/18 17:41:25
1017 dnl ----------
1018 dnl Check if the terminal-capability database functions are available.  If not,
1019 dnl ncurses has a much-reduced version.
1020 AC_DEFUN([CF_CGETENT],[
1021 AC_CACHE_CHECK(for terminal-capability database functions,cf_cv_cgetent,[
1022 AC_TRY_LINK([
1023 $ac_includes_default],[
1024         char temp[128];
1025         char *buf = temp;
1026         char *db_array = temp;
1027         cgetent(&buf, &db_array, "vt100");
1028         cgetcap(buf, "tc", '=');
1029         cgetmatch(buf, "tc");
1030         ],
1031         [cf_cv_cgetent=yes],
1032         [cf_cv_cgetent=no])
1033 ])
1034
1035 if test "$cf_cv_cgetent" = yes
1036 then
1037         AC_DEFINE(HAVE_BSD_CGETENT,1,[Define to 1 if we have BSD cgetent])
1038 AC_CACHE_CHECK(if cgetent uses const parameter,cf_cv_cgetent_const,[
1039 AC_TRY_LINK([
1040 #pragma GCC diagnostic error "-Wincompatible-pointer-types-discards-qualifiers"
1041 $ac_includes_default],[
1042         char temp[128];
1043         char *buf = temp;
1044 #ifndef _NETBSD_SOURCE                  /* given, since April 2004 in stdlib.h */
1045         const char *db_array = temp;
1046         cgetent(&buf, &db_array, "vt100");
1047 #endif
1048         cgetcap(buf, "tc", '=');
1049         cgetmatch(buf, "tc");
1050         ],
1051         [cf_cv_cgetent_const=yes],
1052         [cf_cv_cgetent_const=no])
1053 ])
1054         if test "$cf_cv_cgetent_const" = yes
1055         then
1056                 AC_DEFINE_UNQUOTED(CGETENT_CONST,const,[Define to const if needed for some BSD cgetent variations])
1057         fi
1058 fi
1059 ])dnl
1060 dnl ---------------------------------------------------------------------------
1061 dnl CF_CHECK_CACHE version: 13 updated: 2020/12/31 10:54:15
1062 dnl --------------
1063 dnl Check if we're accidentally using a cache from a different machine.
1064 dnl Derive the system name, as a check for reusing the autoconf cache.
1065 dnl
1066 dnl If we've packaged config.guess and config.sub, run that (since it does a
1067 dnl better job than uname).  Normally we'll use AC_CANONICAL_HOST, but allow
1068 dnl an extra parameter that we may override, e.g., for AC_CANONICAL_SYSTEM
1069 dnl which is useful in cross-compiles.
1070 dnl
1071 dnl Note: we would use $ac_config_sub, but that is one of the places where
1072 dnl autoconf 2.5x broke compatibility with autoconf 2.13
1073 AC_DEFUN([CF_CHECK_CACHE],
1074 [
1075 if test -f "$srcdir/config.guess" || test -f "$ac_aux_dir/config.guess" ; then
1076         ifelse([$1],,[AC_CANONICAL_HOST],[$1])
1077         system_name="$host_os"
1078 else
1079         system_name="`(uname -s -r) 2>/dev/null`"
1080         if test -z "$system_name" ; then
1081                 system_name="`(hostname) 2>/dev/null`"
1082         fi
1083 fi
1084 test -n "$system_name" && AC_DEFINE_UNQUOTED(SYSTEM_NAME,"$system_name",[Define to the system name.])
1085 AC_CACHE_VAL(cf_cv_system_name,[cf_cv_system_name="$system_name"])
1086
1087 test -z "$system_name" && system_name="$cf_cv_system_name"
1088 test -n "$cf_cv_system_name" && AC_MSG_RESULT(Configuring for $cf_cv_system_name)
1089
1090 if test ".$system_name" != ".$cf_cv_system_name" ; then
1091         AC_MSG_RESULT(Cached system name ($system_name) does not agree with actual ($cf_cv_system_name))
1092         AC_MSG_ERROR("Please remove config.cache and try again.")
1093 fi
1094 ])dnl
1095 dnl ---------------------------------------------------------------------------
1096 dnl CF_CHECK_ENVIRON version: 5 updated: 2023/02/18 17:41:25
1097 dnl ----------------
1098 dnl Check for data that is usually declared in <unistd.h>, e.g., the 'environ'
1099 dnl variable.  Define a DECL_xxx symbol if we must declare it ourselves.
1100 dnl
1101 dnl $1 = the name to check
1102 dnl $2 = the assumed type
1103 AC_DEFUN([CF_CHECK_ENVIRON],
1104 [
1105 AC_CACHE_CHECK(if external $1 is declared, cf_cv_dcl_$1,[
1106     AC_TRY_COMPILE([
1107 $ac_includes_default],
1108     ifelse([$2],,void*,[$2]) x = (ifelse([$2],,void*,[$2])) $1; (void)x,
1109     [cf_cv_dcl_$1=yes],
1110     [cf_cv_dcl_$1=no])
1111 ])
1112
1113 if test "$cf_cv_dcl_$1" = no ; then
1114     CF_UPPER(cf_result,decl_$1)
1115     AC_DEFINE_UNQUOTED($cf_result)
1116 fi
1117
1118 # It's possible (for near-UNIX clones) that the data doesn't exist
1119 CF_CHECK_EXTERN_DATA($1,ifelse([$2],,int,[$2]))
1120 ])dnl
1121 dnl ---------------------------------------------------------------------------
1122 dnl CF_CHECK_ERRNO version: 14 updated: 2023/02/18 17:41:25
1123 dnl --------------
1124 dnl Check for data that is usually declared in <stdio.h> or <errno.h>, e.g.,
1125 dnl the 'errno' variable.  Define a DECL_xxx symbol if we must declare it
1126 dnl ourselves.
1127 dnl
1128 dnl $1 = the name to check
1129 dnl $2 = the assumed type
1130 AC_DEFUN([CF_CHECK_ERRNO],
1131 [
1132 AC_CACHE_CHECK(if external $1 is declared, cf_cv_dcl_$1,[
1133         AC_TRY_COMPILE([
1134 $ac_includes_default
1135 #include <errno.h> ],
1136         ifelse([$2],,int,[$2]) x = (ifelse([$2],,int,[$2])) $1; (void)x,
1137         [cf_cv_dcl_$1=yes],
1138         [cf_cv_dcl_$1=no])
1139 ])
1140
1141 if test "$cf_cv_dcl_$1" = no ; then
1142         CF_UPPER(cf_result,decl_$1)
1143         AC_DEFINE_UNQUOTED($cf_result)
1144 fi
1145
1146 # It's possible (for near-UNIX clones) that the data doesn't exist
1147 CF_CHECK_EXTERN_DATA($1,ifelse([$2],,int,[$2]))
1148 ])dnl
1149 dnl ---------------------------------------------------------------------------
1150 dnl CF_CHECK_EXTERN_DATA version: 5 updated: 2021/09/04 06:35:04
1151 dnl --------------------
1152 dnl Check for existence of external data in the current set of libraries.  If
1153 dnl we can modify it, it is real enough.
1154 dnl $1 = the name to check
1155 dnl $2 = its type
1156 AC_DEFUN([CF_CHECK_EXTERN_DATA],
1157 [
1158 AC_CACHE_CHECK(if external $1 exists, cf_cv_have_$1,[
1159         AC_TRY_LINK([
1160 #undef $1
1161 extern $2 $1;
1162 ],
1163         [$1 = 2],
1164         [cf_cv_have_$1=yes],
1165         [cf_cv_have_$1=no])
1166 ])
1167
1168 if test "$cf_cv_have_$1" = yes ; then
1169         CF_UPPER(cf_result,have_$1)
1170         AC_DEFINE_UNQUOTED($cf_result)
1171 fi
1172
1173 ])dnl
1174 dnl ---------------------------------------------------------------------------
1175 dnl CF_CHECK_FVISIBILITY version: 2 updated: 2020/04/04 16:16:13
1176 dnl --------------------
1177 dnl Check whether the compiler understands -fvisibility=hidden
1178 dnl
1179 dnl $1 = compiler
1180 dnl $2 = compiler-flags variable name
1181 dnl $3 = cache variable to set
1182 AC_DEFUN([CF_CHECK_FVISIBILITY],[
1183 AC_CACHE_CHECK(if $1 -fvisibility=hidden option works,$3,[
1184     cf_save_cflags="[$]$2"
1185     $2="[$]$2 -fvisibility=hidden"
1186     AC_TRY_LINK([
1187 __attribute__ ((visibility("default"))) int somefunc() {return 42;}
1188         ],[
1189         if (somefunc()) return 1;
1190 ],
1191     [$3=yes],
1192     [$3=no])
1193     $2=$cf_save_cflags
1194 ])
1195 ])dnl
1196 dnl ---------------------------------------------------------------------------
1197 dnl CF_CHECK_GETENV version: 3 updated: 2023/01/05 17:47:56
1198 dnl ---------------
1199 dnl Check if repeated getenv calls return the same pointer, e.g., it does not
1200 dnl discard the previous pointer when returning a new one.
1201 AC_DEFUN([CF_CHECK_GETENV],
1202 [
1203 AC_REQUIRE([CF_CHECK_ENVIRON])
1204 AC_CHECK_FUNC( getenv, ,, AC_MSG_ERROR(getenv not found) )
1205 AC_CHECK_FUNCS( putenv setenv strdup )
1206 AC_CACHE_CHECK(if getenv returns consistent values,cf_cv_consistent_getenv,[
1207 AC_TRY_RUN([
1208 $ac_includes_default
1209
1210 #if defined(HAVE_ENVIRON) && defined(DECL_ENVIRON) && !defined(environ)
1211 extern char **environ;  /* POSIX, but some systems are not... */
1212 #endif
1213
1214 #if defined(HAVE_STRDUP)
1215 #define str_alloc(s) strdup(s)
1216 #else
1217 #define str_alloc(s) strcpy(malloc(strlen(s) + 1, s))
1218 #endif
1219
1220 static void set_value(const char *name, const char *value)
1221 {
1222 #if defined(HAVE_SETENV)
1223         setenv(name, value, 1);
1224 #elif defined(HAVE_PUTENV)
1225         char buffer[1024];
1226         sprintf(buffer, "%s=%s", name, value);
1227         putenv(str_alloc(buffer));
1228 #else
1229 #error neither putenv/setenv found
1230 #endif
1231 }
1232 int main(void)
1233 {
1234         int pass;
1235         size_t numenv, limit, j;
1236         char **mynames;
1237         char **myvalues;
1238         char **mypointer;
1239         char *equals;
1240         for (numenv = 0; environ[numenv]; ++numenv) ;
1241         limit = numenv + 10;
1242         mynames = (char **) calloc(limit + 1, sizeof(char *));
1243         myvalues = (char **) calloc(limit + 1, sizeof(char *));
1244         mypointer = (char **) calloc(limit + 1, sizeof(char *));
1245 #if defined(HAVE_ENVIRON)
1246         for (j = 0; environ[j]; ++j) {
1247                 mynames[j] = str_alloc(environ[j]);
1248                 equals = strchr(mynames[j], '=');
1249                 if (equals != 0) {
1250                         *equals++ = '\\0';
1251                         myvalues[j] = str_alloc(equals);
1252                 } else {
1253                         myvalues[j] = str_alloc("");
1254                 }
1255         }
1256 #endif
1257         for (j = numenv; j < limit; ++j) {
1258                 char name[80];
1259                 char value[80];
1260                 size_t found;
1261                 size_t k = 0;
1262                 do {
1263                         size_t jk;
1264                         found = 0;
1265                         sprintf(name, "TERM%lu", (unsigned long) k);
1266                         for (jk = 0; jk < j; ++jk) {
1267                                 if (!strcmp(name, mynames[jk])) {
1268                                         found = 1;
1269                                         ++k;
1270                                         break;
1271                                 }
1272                         }
1273                 } while (found);
1274                 sprintf(value, "%lu:%p", (unsigned long) k, &mynames[j]);
1275                 set_value(name, value);
1276                 mynames[j] = str_alloc(name);
1277                 myvalues[j] = str_alloc(value);
1278         }
1279         for (pass = 0; pass < 3; ++pass) {
1280                 for (j = 0; j < limit; ++j) {
1281                         char *value = getenv(mynames[j]);
1282                         if (pass) {
1283                                 if (value == 0) {
1284                                         fprintf(stderr, "getenv returned null for %s\\n", mynames[j]);
1285                                         ${cf_cv_main_return:-return}(1);
1286                                 } else if (value != mypointer[j]) {
1287                                         fprintf(stderr, "getenv returned different pointer for %s\\n", mynames[j]);
1288                                         ${cf_cv_main_return:-return}(1);
1289                                 } else if (strcmp(value, myvalues[j])) {
1290                                         fprintf(stderr, "getenv returned different value for %s\\n", mynames[j]);
1291                                         ${cf_cv_main_return:-return}(1);
1292                                 }
1293                         } else {
1294                                 size_t k;
1295                                 mypointer[j] = value;
1296                                 for (k = 0; k < j; ++k) {
1297                                         if (mypointer[j] == mypointer[k]) {
1298                                                 fprintf(stderr, "getenv returned same pointer for %s and %s\\n", mynames[j], mynames[k]);
1299                                                 ${cf_cv_main_return:-return}(1);
1300                                         }
1301                                 }
1302                         }
1303                 }
1304         }
1305         ${cf_cv_main_return:-return}(0);
1306 }
1307 ],
1308 [cf_cv_consistent_getenv=yes],
1309 [cf_cv_consistent_getenv=no],
1310 [cf_cv_consistent_getenv=unknown])
1311 ])
1312
1313 if test "x$cf_cv_consistent_getenv" = xno
1314 then
1315         AC_DEFINE(HAVE_CONSISTENT_GETENV,1,[Define to 1 if getenv repeatably returns the same value for a given name])
1316 fi
1317 ])dnl
1318 dnl ---------------------------------------------------------------------------
1319 dnl CF_CHECK_GNAT_VERSION version: 4 updated: 2021/01/01 13:31:04
1320 dnl ---------------------
1321 AC_DEFUN([CF_CHECK_GNAT_VERSION],
1322 [
1323 AC_REQUIRE([CF_GNAT_VERSION])
1324 case "$cf_cv_gnat_version" in
1325 (3.1[[1-9]]*|3.[[2-9]]*|[[4-9]].*|[[1-9]][[0-9]].[[0-9]]*|20[[0-9]][[0-9]])
1326         cf_cv_prog_gnat_correct=yes
1327         ;;
1328 (*)
1329         AC_MSG_WARN(Unsupported GNAT version $cf_cv_gnat_version. We require 3.11 or better. Disabling Ada95 binding.)
1330         cf_cv_prog_gnat_correct=no
1331         ;;
1332 esac
1333 ])
1334 dnl ---------------------------------------------------------------------------
1335 dnl CF_CHECK_GPM_WGETCH version: 6 updated: 2021/01/04 18:48:01
1336 dnl -------------------
1337 dnl Check if GPM is already linked with curses.  If so - and if the linkage
1338 dnl is not "weak" - warn about this because it can create problems linking
1339 dnl applications with ncurses.
1340 AC_DEFUN([CF_CHECK_GPM_WGETCH],[
1341 AC_REQUIRE([AC_PROG_EGREP])dnl
1342
1343 AC_CHECK_LIB(gpm,Gpm_Wgetch,[
1344
1345 AC_CACHE_CHECK(if GPM is weakly bound to curses library, cf_cv_check_gpm_wgetch,[
1346 cf_cv_check_gpm_wgetch=unknown
1347 if test "$cross_compiling" != yes ; then
1348
1349 cat >conftest.$ac_ext <<CF_EOF
1350 #include <gpm.h>
1351 int main(void)
1352 {
1353         Gpm_Wgetch();
1354         ${cf_cv_main_return:-return}(0);
1355 }
1356 CF_EOF
1357
1358         cf_save_LIBS="$LIBS"
1359         # This only works if we can look at the symbol table.  If a shared
1360         # library is stripped for install, we cannot use that.  So we're forced
1361         # to rely on the static library, noting that some packagers may not
1362         # include it.
1363         LIBS="-static -lgpm -dynamic $LIBS"
1364         if AC_TRY_EVAL(ac_compile) ; then
1365                 if AC_TRY_EVAL(ac_link) ; then
1366                         cf_cv_check_gpm_wgetch="`nm \"conftest$ac_exeext\" | ${EGREP-egrep} '\<wgetch\>' | ${EGREP-egrep} '\<[[vVwW]]\>'`"
1367                         test -n "$cf_cv_check_gpm_wgetch" && cf_cv_check_gpm_wgetch=yes
1368                         test -z "$cf_cv_check_gpm_wgetch" && cf_cv_check_gpm_wgetch=no
1369                 fi
1370         fi
1371         rm -rf ./conftest*
1372         LIBS="$cf_save_LIBS"
1373 fi
1374 ])
1375
1376 if test "$cf_cv_check_gpm_wgetch" != yes ; then
1377         AC_MSG_WARN(GPM library is already linked with curses - read the FAQ)
1378 fi
1379 ])])dnl
1380 dnl ---------------------------------------------------------------------------
1381 dnl CF_CHECK_LIBSSP version: 1 updated: 2021/10/30 10:40:19
1382 dnl ---------------
1383 dnl Check if libssp is needed, e.g., to work around misconfigured libraries
1384 dnl used in cross-compiling to MinGW.
1385 AC_DEFUN([CF_CHECK_LIBSSP],[
1386 AC_CACHE_CHECK(if ssp library is needed,cf_cv_need_libssp,[
1387 AC_TRY_LINK([
1388 #include <sys/types.h>
1389 #include <dirent.h>
1390 ],[
1391        DIR *dp = opendir(".");
1392 ],cf_cv_need_libssp=no,[
1393         cf_save_LIBS="$LIBS"
1394         LIBS="$LIBS -lssp"
1395         AC_TRY_LINK([
1396 #include <sys/types.h>
1397 #include <dirent.h>
1398         ],[
1399                    DIR *dp = opendir(".");
1400         ],cf_cv_need_libssp=yes,
1401           cf_cv_need_libssp=maybe)
1402         LIBS="$cf_save_LIBS"
1403 ])dnl
1404 ])
1405
1406 if test "x$cf_cv_need_libssp" = xyes
1407 then
1408         CF_ADD_LIB(ssp)
1409 fi
1410 ])dnl
1411 dnl ---------------------------------------------------------------------------
1412 dnl CF_CHECK_LIBTOOL_VERSION version: 2 updated: 2021/05/01 16:24:34
1413 dnl ------------------------
1414 dnl Show the version of libtool
1415 dnl
1416 dnl Save the version in a cache variable - this is not entirely a good thing,
1417 dnl but the version string from libtool is very ugly, and for bug reports it
1418 dnl might be useful to have the original string.
1419 dnl
1420 dnl There is an imitation in OpenBSD, which has no apparent use other than to
1421 dnl deny that it is GNU libtool.  Just ignore it.
1422 AC_DEFUN([CF_CHECK_LIBTOOL_VERSION],[
1423 if test -n "$LIBTOOL" && test "$LIBTOOL" != none
1424 then
1425         AC_MSG_CHECKING(version of $LIBTOOL)
1426         CF_LIBTOOL_VERSION
1427         AC_MSG_RESULT($cf_cv_libtool_version)
1428         if test -n "$cf_cv_libtool_version"
1429         then
1430                 cf_check_libtool_version=`$LIBTOOL --version 2>&1 | sed -e '/^$/d' -e 's,[[()]],...,g' -e 's,[[ ]],-,g' -e '2,$d'`
1431                 case "x$cf_check_libtool_version" in
1432                 (*...GNU-libtool...*)
1433                         ;;
1434                 (*)
1435                         AC_MSG_ERROR(This is not GNU libtool)
1436                         ;;
1437                 esac
1438         else
1439                 AC_MSG_ERROR(No version found for $LIBTOOL)
1440         fi
1441 else
1442         AC_MSG_ERROR(GNU libtool has not been found)
1443 fi
1444 ])dnl
1445 dnl ---------------------------------------------------------------------------
1446 dnl CF_CHECK_WCHAR_H version: 4 updated: 2023/02/18 17:41:25
1447 dnl ----------------
1448 dnl Check if wchar.h can be used, i.e., without defining _XOPEN_SOURCE_EXTENDED
1449 AC_DEFUN([CF_CHECK_WCHAR_H],[
1450 AC_CHECK_HEADERS( \
1451 wchar.h \
1452 wctype.h \
1453 )
1454 AC_CACHE_CHECK(if wchar.h can be used as is,cf_cv_wchar_h_okay,[
1455 AC_TRY_COMPILE(
1456 [
1457 $ac_includes_default
1458 #ifdef HAVE_WCHAR_H
1459 #include <wchar.h>
1460 #endif
1461 #ifdef HAVE_WCTYPE_H
1462 #include <wctype.h>
1463 #endif
1464 ],[
1465         wint_t foo = 0;
1466         int bar = iswpunct(foo)],
1467         [cf_cv_wchar_h_okay=yes],
1468         [cf_cv_wchar_h_okay=no])])
1469
1470 if test "$cf_cv_wchar_h_okay" = no
1471 then
1472         CF_PREDEFINE(_XOPEN_SOURCE_EXTENDED)
1473 fi
1474 ])dnl
1475 dnl ---------------------------------------------------------------------------
1476 dnl CF_CHECK_WCWIDTH_GRAPHICS version: 3 updated: 2023/01/05 18:01:30
1477 dnl -------------------------
1478 dnl Most "modern" terminal emulators are based to some degree on VT100, and
1479 dnl should support line-drawing.  Even with Unicode.  There is a problem.
1480 dnl
1481 dnl While most of the VT100 graphics characters were incorporated into Unicode,
1482 dnl all of those were combined into a page of useful graphics characters.
1483 dnl
1484 dnl So far, so good.
1485 dnl
1486 dnl However, while they are useful, there are other considerations.  CJK
1487 dnl is (because of poor device resolution) often rendered as double-width
1488 dnl characters.  So... for these generally-useful characters, what should
1489 dnl be the width (to make them consistent with adjacent characters)?
1490 dnl
1491 dnl The obvious choice would have been to make this locale-dependent, and use
1492 dnl wcwidth() to tell applications what the actual width is.  That was too
1493 dnl obvious.  Instead, we have a slew of "ambiguous-width" characters.
1494 dnl See for example
1495 dnl             http://www.unicode.org/reports/tr11/tr11-29.html
1496 dnl             http://www.cl.cam.ac.uk/~mgk25/ucs/scw-proposal.html
1497 dnl
1498 dnl The EastAsianWidth-6.2.0.txt file from the Unicode organization lists
1499 dnl more than 22,000 characters, with 1281 of those as ambiguous-width.  For
1500 dnl instance, it lists half (44/96) of the Latin-1 characters as
1501 dnl ambiguous-width.  Also, all of the box-characters at 0x2500 are ambiguous.
1502 dnl
1503 dnl What this means for the implementor is that on some systems wcwidth() can
1504 dnl give bad advice.  On Solaris, some of the ambiguous widths are returned as
1505 dnl 1 (the Latin-1 characters), while others are returned as 2 (line-drawing
1506 dnl characters).  These do not necessarily match the behavior of the terminal
1507 dnl emulator.  xterm, for instance, does an optional startup check to find if
1508 dnl this problem (or similar) exists with the system's locale tables, rejecting
1509 dnl them if they are too unreliable.
1510 AC_DEFUN([CF_CHECK_WCWIDTH_GRAPHICS],[
1511 AC_CACHE_CHECK(if wcwidth agrees graphics are single-width, cf_cv_wcwidth_graphics,[
1512 cat >conftest.in <<CF_EOF
1513 -       VT100 symbols
1514 0x250c  upper left corner
1515 0x2514  lower left corner
1516 0x2510  upper right corner
1517 0x2518  lower right corner
1518 0x251c  tee pointing left
1519 0x2524  tee pointing right
1520 0x2534  tee pointing up
1521 0x252c  tee pointing down
1522 0x2500  horizontal line
1523 0x2502  vertical line
1524 0x253c  large plus or crossover
1525 0x23ba  scan line 1
1526 0x23bd  scan line 9
1527 0x25c6  diamond
1528 0x2592  checker board (stipple)
1529 0x00b0  degree symbol
1530 0x00b1  plus/minus
1531 0x00b7  bullet
1532 -       Teletype 5410v1 symbols
1533 0x2190  arrow pointing left
1534 0x2192  arrow pointing right
1535 0x2193  arrow pointing down
1536 0x2191  arrow pointing up
1537 0x2592  board of squares
1538 0x2603  lantern symbol
1539 0x25ae  solid square block
1540 -       these defaults were invented for ncurses
1541 0x23bb  scan line 3
1542 0x23bc  scan line 7
1543 0x2264  less-than-or-equal-to
1544 0x2265  greater-than-or-equal-to
1545 0x03c0  greek pi
1546 0x2260  not-equal
1547 0x00a3  pound-sterling symbol
1548 -       thick-line-drawing
1549 0x250f  upper left corner
1550 0x2517  lower left corner
1551 0x2513  upper right corner
1552 0x251b  lower right corner
1553 0x2523  tee pointing left
1554 0x252b  tee pointing right
1555 0x253b  tee pointing up
1556 0x2533  tee pointing down
1557 0x2501  horizontal line
1558 0x2503  vertical line
1559 0x254b  large plus or crossover
1560 -       double-line-drawing
1561 0x2554  upper left corner
1562 0x255a  lower left corner
1563 0x2557  upper right corner
1564 0x255d  lower right corner
1565 0x2563  tee pointing left
1566 0x2560  tee pointing right
1567 0x2569  tee pointing up
1568 0x2566  tee pointing down
1569 0x2550  horizontal line
1570 0x2551  vertical line
1571 0x256c  large plus or crossover
1572 CF_EOF
1573 AC_TRY_RUN([
1574 $ac_includes_default
1575
1576 #include <locale.h>
1577 #include <wchar.h>
1578
1579 #define MY_LEN 80
1580
1581 int
1582 main(void)
1583 {
1584         FILE *fp;
1585         int value;
1586         char buffer[MY_LEN + 1];
1587         char notes[MY_LEN + 1];
1588         int totals = 0;
1589         int passed = 0;
1590
1591         if (setlocale(LC_ALL, "en_US.UTF8") ||
1592                 setlocale(LC_ALL, "en_US.UTF-8") ||
1593                 setlocale(LC_ALL, "en_US.utf8") ||
1594                 setlocale(LC_ALL, "en_US.utf-8")) {
1595                 if ((fp = fopen("conftest.in", "r")) != 0) {
1596                         while (fgets(buffer, MY_LEN, fp) != 0) {
1597                                 if (*buffer == '-') {
1598                                         fprintf(stderr, "\\t%s", buffer);
1599                                 } else if (sscanf(buffer, "%x %s", &value, notes) == 2) {
1600                                         ++totals;
1601                                         if (wcwidth(value) == 1)
1602                                                 ++passed;
1603                                         fprintf(stderr, "%d\\t%s", wcwidth(value), buffer);
1604                                 } else {
1605                                         fprintf(stderr, "?\\t%s", buffer);
1606                                 }
1607                         }
1608                 }
1609         }
1610         fprintf(stderr, "%d/%d passed wcwidth/graphics check\\n", passed, totals);
1611         return (totals == passed) ? 0 : 1;
1612 }
1613 ],
1614 [cf_cv_wcwidth_graphics=yes],
1615 [cf_cv_wcwidth_graphics=no],
1616 [cf_cv_wcwidth_graphics=unknown])
1617 ])
1618 ])dnl
1619 dnl ---------------------------------------------------------------------------
1620 dnl CF_CLANG_COMPILER version: 9 updated: 2023/02/18 17:41:25
1621 dnl -----------------
1622 dnl Check if the given compiler is really clang.  clang's C driver defines
1623 dnl __GNUC__ (fooling the configure script into setting $GCC to yes) but does
1624 dnl not ignore some gcc options.
1625 dnl
1626 dnl This macro should be run "soon" after AC_PROG_CC or AC_PROG_CPLUSPLUS, to
1627 dnl ensure that it is not mistaken for gcc/g++.  It is normally invoked from
1628 dnl the wrappers for gcc and g++ warnings.
1629 dnl
1630 dnl $1 = GCC (default) or GXX
1631 dnl $2 = CLANG_COMPILER (default)
1632 dnl $3 = CFLAGS (default) or CXXFLAGS
1633 AC_DEFUN([CF_CLANG_COMPILER],[
1634 ifelse([$2],,CLANG_COMPILER,[$2])=no
1635
1636 if test "$ifelse([$1],,[$1],GCC)" = yes ; then
1637         AC_MSG_CHECKING(if this is really Clang ifelse([$1],GXX,C++,C) compiler)
1638         cf_save_CFLAGS="$ifelse([$3],,CFLAGS,[$3])"
1639         AC_TRY_COMPILE([],[
1640 #ifdef __clang__
1641 #else
1642 #error __clang__ is not defined
1643 #endif
1644 ],[ifelse([$2],,CLANG_COMPILER,[$2])=yes
1645 ],[])
1646         ifelse([$3],,CFLAGS,[$3])="$cf_save_CFLAGS"
1647         AC_MSG_RESULT($ifelse([$2],,CLANG_COMPILER,[$2]))
1648 fi
1649
1650 CLANG_VERSION=none
1651
1652 if test "x$ifelse([$2],,CLANG_COMPILER,[$2])" = "xyes" ; then
1653         case "$CC" in
1654         (c[[1-9]][[0-9]]|*/c[[1-9]][[0-9]])
1655                 AC_MSG_WARN(replacing broken compiler alias $CC)
1656                 CFLAGS="$CFLAGS -std=`echo "$CC" | sed -e 's%.*/%%'`"
1657                 CC=clang
1658                 ;;
1659         esac
1660
1661         AC_MSG_CHECKING(version of $CC)
1662         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.]].*//'`"
1663         test -z "$CLANG_VERSION" && CLANG_VERSION=unknown
1664         AC_MSG_RESULT($CLANG_VERSION)
1665
1666         for cf_clang_opt in \
1667                 -Qunused-arguments \
1668                 -Wno-error=implicit-function-declaration
1669         do
1670                 AC_MSG_CHECKING(if option $cf_clang_opt works)
1671                 cf_save_CFLAGS="$CFLAGS"
1672                 CFLAGS="$CFLAGS $cf_clang_opt"
1673                 AC_TRY_LINK([
1674                         #include <stdio.h>],[
1675                         printf("hello!\\n");],[
1676                         cf_clang_optok=yes],[
1677                         cf_clang_optok=no])
1678                 AC_MSG_RESULT($cf_clang_optok)
1679                 CFLAGS="$cf_save_CFLAGS"
1680                 if test "$cf_clang_optok" = yes; then
1681                         CF_VERBOSE(adding option $cf_clang_opt)
1682                         CF_APPEND_TEXT(CFLAGS,$cf_clang_opt)
1683                 fi
1684         done
1685 fi
1686 ])
1687 dnl ---------------------------------------------------------------------------
1688 dnl CF_CONST_X_STRING version: 7 updated: 2021/06/07 17:39:17
1689 dnl -----------------
1690 dnl The X11R4-X11R6 Xt specification uses an ambiguous String type for most
1691 dnl character-strings.
1692 dnl
1693 dnl It is ambiguous because the specification accommodated the pre-ANSI
1694 dnl compilers bundled by more than one vendor in lieu of providing a standard C
1695 dnl compiler other than by costly add-ons.  Because of this, the specification
1696 dnl did not take into account the use of const for telling the compiler that
1697 dnl string literals would be in readonly memory.
1698 dnl
1699 dnl As a workaround, one could (starting with X11R5) define XTSTRINGDEFINES, to
1700 dnl let the compiler decide how to represent Xt's strings which were #define'd.
1701 dnl That does not solve the problem of using the block of Xt's strings which
1702 dnl are compiled into the library (and is less efficient than one might want).
1703 dnl
1704 dnl Xt specification 7 introduces the _CONST_X_STRING symbol which is used both
1705 dnl when compiling the library and compiling using the library, to tell the
1706 dnl compiler that String is const.
1707 AC_DEFUN([CF_CONST_X_STRING],
1708 [
1709 AC_REQUIRE([AC_PATH_XTRA])
1710
1711 CF_SAVE_XTRA_FLAGS([CF_CONST_X_STRING])
1712
1713 AC_TRY_COMPILE(
1714 [
1715 #include <stdlib.h>
1716 #include <X11/Intrinsic.h>
1717 ],
1718 [String foo = malloc(1); free((void*)foo)],[
1719
1720 AC_CACHE_CHECK(for X11/Xt const-feature,cf_cv_const_x_string,[
1721         AC_TRY_COMPILE(
1722                 [
1723 #define _CONST_X_STRING /* X11R7.8 (perhaps) */
1724 #undef  XTSTRINGDEFINES /* X11R5 and later */
1725 #include <stdlib.h>
1726 #include <X11/Intrinsic.h>
1727                 ],[String foo = malloc(1); *foo = 0],[
1728                         cf_cv_const_x_string=no
1729                 ],[
1730                         cf_cv_const_x_string=yes
1731                 ])
1732 ])
1733
1734 CF_RESTORE_XTRA_FLAGS([CF_CONST_X_STRING])
1735
1736 case "$cf_cv_const_x_string" in
1737 (no)
1738         CF_APPEND_TEXT(CPPFLAGS,-DXTSTRINGDEFINES)
1739         ;;
1740 (*)
1741         CF_APPEND_TEXT(CPPFLAGS,-D_CONST_X_STRING)
1742         ;;
1743 esac
1744
1745 ])
1746 ])dnl
1747 dnl ---------------------------------------------------------------------------
1748 dnl CF_CPP_OVERRIDE version: 1 updated: 2022/08/20 16:07:10
1749 dnl ---------------
1750 dnl Check if the C++ compiler accepts the override keyword.  This is a C++-11
1751 dnl feature.
1752 AC_DEFUN([CF_CPP_OVERRIDE],
1753 [
1754 if test -n "$CXX"; then
1755 AC_CACHE_CHECK(if $CXX accepts override keyword,cf_cv_cpp_override,[
1756         AC_LANG_SAVE
1757         AC_LANG_CPLUSPLUS
1758         AC_TRY_RUN([
1759
1760 class base
1761 {
1762 public:
1763         virtual int foo(float x) = 0;
1764 };
1765
1766
1767 class derived: public base
1768 {
1769 public:
1770         int foo(float x) override { return x != 0.0 ? 1 : 0; }
1771 };
1772
1773 int main(void) { }
1774 ],
1775         [cf_cv_cpp_override=yes],
1776         [cf_cv_cpp_override=no],
1777         [cf_cv_cpp_override=unknown])
1778         AC_LANG_RESTORE
1779 ])
1780 fi
1781 test "$cf_cv_cpp_override" = yes && AC_DEFINE(CPP_HAS_OVERRIDE,1,[Define to 1 if C++ has override keyword])
1782 ])dnl
1783 dnl ---------------------------------------------------------------------------
1784 dnl CF_CPP_PARAM_INIT version: 7 updated: 2017/01/21 11:06:25
1785 dnl -----------------
1786 dnl Check if the C++ compiler accepts duplicate parameter initialization.  This
1787 dnl is a late feature for the standard and is not in some recent compilers
1788 dnl (1999/9/11).
1789 AC_DEFUN([CF_CPP_PARAM_INIT],
1790 [
1791 if test -n "$CXX"; then
1792 AC_CACHE_CHECK(if $CXX accepts parameter initialization,cf_cv_cpp_param_init,[
1793         AC_LANG_SAVE
1794         AC_LANG_CPLUSPLUS
1795         AC_TRY_RUN([
1796 class TEST {
1797 private:
1798         int value;
1799 public:
1800         TEST(int x = 1);
1801         ~TEST();
1802 };
1803
1804 TEST::TEST(int x = 1)   // some compilers do not like second initializer
1805 {
1806         value = x;
1807 }
1808 int main(void) { }
1809 ],
1810         [cf_cv_cpp_param_init=yes],
1811         [cf_cv_cpp_param_init=no],
1812         [cf_cv_cpp_param_init=unknown])
1813         AC_LANG_RESTORE
1814 ])
1815 fi
1816 test "$cf_cv_cpp_param_init" = yes && AC_DEFINE(CPP_HAS_PARAM_INIT,1,[Define to 1 if C++ has parameter initialization])
1817 ])dnl
1818 dnl ---------------------------------------------------------------------------
1819 dnl CF_CPP_STATIC_CAST version: 3 updated: 2013/04/13 18:03:21
1820 dnl ------------------
1821 dnl Check if the C++ compiler accepts static_cast in generics.  This appears to
1822 dnl not be supported in g++ before 3.0
1823 AC_DEFUN([CF_CPP_STATIC_CAST],
1824 [
1825 if test -n "$CXX"; then
1826
1827 AC_CACHE_CHECK(if $CXX accepts static_cast,cf_cv_cpp_static_cast,[
1828         AC_LANG_SAVE
1829         AC_LANG_CPLUSPLUS
1830
1831         AC_TRY_COMPILE([
1832 class NCursesPanel
1833 {
1834 public:
1835   NCursesPanel(int nlines,
1836                int ncols,
1837                int begin_y = 0,
1838                int begin_x = 0)
1839   {
1840   }
1841   NCursesPanel();
1842   ~NCursesPanel();
1843 };
1844
1845 template<class T> class NCursesUserPanel : public NCursesPanel
1846 {
1847 public:
1848   NCursesUserPanel (int nlines,
1849                     int ncols,
1850                     int begin_y = 0,
1851                     int begin_x = 0,
1852                     const T* p_UserData = static_cast<T*>(0))
1853     : NCursesPanel (nlines, ncols, begin_y, begin_x)
1854   {
1855   };
1856   NCursesUserPanel(const T* p_UserData = static_cast<T*>(0)) : NCursesPanel()
1857   {
1858   };
1859
1860   virtual ~NCursesUserPanel() {};
1861 };
1862 ],[
1863         const char* p_UserData = static_cast<char*>(0)],
1864         [cf_cv_cpp_static_cast=yes],
1865         [cf_cv_cpp_static_cast=no])
1866
1867         AC_LANG_RESTORE
1868 ])
1869
1870 fi
1871
1872 test "$cf_cv_cpp_static_cast" = yes && AC_DEFINE(CPP_HAS_STATIC_CAST,1,[Define to 1 if C++ has static_cast])
1873 ])dnl
1874 dnl ---------------------------------------------------------------------------
1875 dnl CF_CXX_AR_FLAGS version: 3 updated: 2021/01/01 13:31:04
1876 dnl ---------------
1877 dnl Setup special archiver flags for given compilers.
1878 AC_DEFUN([CF_CXX_AR_FLAGS],[
1879         CXX_AR='$(AR)'
1880         CXX_ARFLAGS='$(ARFLAGS)'
1881         case "$cf_cv_system_name" in
1882         (irix*)
1883             if test "$GXX" != yes ; then
1884                 CXX_AR='$(CXX)'
1885                 CXX_ARFLAGS='-ar -o'
1886             fi
1887             ;;
1888         (sco3.2v5*)
1889             CXXLDFLAGS="-u main"
1890             ;;
1891         (solaris2*)
1892             if test "$GXX" != yes ; then
1893                 CXX_AR='$(CXX)'
1894                 CXX_ARFLAGS='-xar -o'
1895             fi
1896             ;;
1897         esac
1898         AC_SUBST(CXXLDFLAGS)
1899         AC_SUBST(CXX_AR)
1900         AC_SUBST(CXX_ARFLAGS)
1901 ])dnl
1902 dnl ---------------------------------------------------------------------------
1903 dnl CF_CXX_IOSTREAM_NAMESPACE version: 2 updated: 2012/10/06 17:56:13
1904 dnl -------------------------
1905 dnl For c++, check if iostream uses "std::" namespace.
1906 AC_DEFUN([CF_CXX_IOSTREAM_NAMESPACE],[
1907 AC_CHECK_HEADERS(iostream)
1908 if test x"$ac_cv_header_iostream" = xyes ; then
1909         AC_MSG_CHECKING(if iostream uses std-namespace)
1910         AC_TRY_COMPILE([
1911 #include <iostream>
1912 using std::endl;
1913 using std::cerr;],[
1914 cerr << "testing" << endl;
1915 ],[cf_iostream_namespace=yes],[cf_iostream_namespace=no])
1916         AC_MSG_RESULT($cf_iostream_namespace)
1917         if test "$cf_iostream_namespace" = yes ; then
1918                 AC_DEFINE(IOSTREAM_NAMESPACE,1,[Define to 1 if C++ has namespace iostream])
1919         fi
1920 fi
1921 ])dnl
1922 dnl ---------------------------------------------------------------------------
1923 dnl CF_C_INLINE version: 6 updated: 2019/09/07 13:38:36
1924 dnl -----------
1925 dnl Check if the C compiler supports "inline".
1926 dnl $1 is the name of a shell variable to set if inline is supported
1927 dnl $2 is the threshold for gcc 4.x's option controlling maximum inline size
1928 AC_DEFUN([CF_C_INLINE],[
1929 AC_REQUIRE([CF_GCC_VERSION])
1930 AC_C_INLINE
1931 $1=
1932 if test "$ac_cv_c_inline" != no ; then
1933         $1=inline
1934         if test "$INTEL_COMPILER" = yes
1935         then
1936                 :
1937         elif test "$CLANG_COMPILER" = yes
1938         then
1939                 :
1940         elif test "$GCC" = yes
1941         then
1942                 AC_CACHE_CHECK(if $CC supports options to tune inlining,cf_cv_gcc_inline,[
1943                 cf_save_CFLAGS=$CFLAGS
1944                 CFLAGS="$CFLAGS --param max-inline-insns-single=$2"
1945                 AC_TRY_COMPILE([inline int foo(void) { return 1; }],
1946                 [${cf_cv_main_return:-return} foo()],
1947                 [cf_cv_gcc_inline=yes],
1948                 [cf_cv_gcc_inline=no])
1949                 CFLAGS=$cf_save_CFLAGS
1950                 ])
1951                 if test "$cf_cv_gcc_inline" = yes ; then
1952                         CF_ADD_CFLAGS([--param max-inline-insns-single=$2])
1953                 fi
1954         fi
1955 fi
1956 AC_SUBST($1)
1957 ])dnl
1958 dnl ---------------------------------------------------------------------------
1959 dnl CF_DIRNAME version: 5 updated: 2020/12/31 20:19:42
1960 dnl ----------
1961 dnl "dirname" is not portable, so we fake it with a shell script.
1962 AC_DEFUN([CF_DIRNAME],[$1=`echo "$2" | sed -e 's%/[[^/]]*$%%'`])dnl
1963 dnl ---------------------------------------------------------------------------
1964 dnl CF_DIRS_TO_MAKE version: 4 updated: 2021/01/01 13:31:04
1965 dnl ---------------
1966 AC_DEFUN([CF_DIRS_TO_MAKE],
1967 [
1968 DIRS_TO_MAKE="lib"
1969 for cf_item in $cf_list_models
1970 do
1971         CF_OBJ_SUBDIR($cf_item,cf_subdir)
1972         for cf_item2 in $DIRS_TO_MAKE
1973         do
1974                 test "$cf_item2" = "$cf_subdir" && break
1975         done
1976         test ".$cf_item2" != ".$cf_subdir" && DIRS_TO_MAKE="$DIRS_TO_MAKE $cf_subdir"
1977 done
1978 for cf_dir in $DIRS_TO_MAKE
1979 do
1980         test ! -d "$cf_dir" && mkdir "$cf_dir"
1981 done
1982 AC_SUBST(DIRS_TO_MAKE)
1983 ])dnl
1984 dnl ---------------------------------------------------------------------------
1985 dnl CF_DISABLE_ECHO version: 14 updated: 2021/09/04 06:35:04
1986 dnl ---------------
1987 dnl You can always use "make -n" to see the actual options, but it is hard to
1988 dnl pick out/analyze warning messages when the compile-line is long.
1989 dnl
1990 dnl Sets:
1991 dnl     ECHO_LT - symbol to control if libtool is verbose
1992 dnl     ECHO_LD - symbol to prefix "cc -o" lines
1993 dnl     RULE_CC - symbol to put before implicit "cc -c" lines (e.g., .c.o)
1994 dnl     SHOW_CC - symbol to put before explicit "cc -c" lines
1995 dnl     ECHO_CC - symbol to put before any "cc" line
1996 dnl
1997 AC_DEFUN([CF_DISABLE_ECHO],[
1998 AC_MSG_CHECKING(if you want to see long compiling messages)
1999 CF_ARG_DISABLE(echo,
2000         [  --disable-echo          do not display "compiling" commands],
2001         [
2002         ECHO_LT='--silent'
2003         ECHO_LD='@echo linking [$]@;'
2004         RULE_CC='@echo compiling [$]<'
2005         SHOW_CC='@echo compiling [$]@'
2006         ECHO_CC='@'
2007 ],[
2008         ECHO_LT=''
2009         ECHO_LD=''
2010         RULE_CC=''
2011         SHOW_CC=''
2012         ECHO_CC=''
2013 ])
2014 AC_MSG_RESULT($enableval)
2015 AC_SUBST(ECHO_LT)
2016 AC_SUBST(ECHO_LD)
2017 AC_SUBST(RULE_CC)
2018 AC_SUBST(SHOW_CC)
2019 AC_SUBST(ECHO_CC)
2020 ])dnl
2021 dnl ---------------------------------------------------------------------------
2022 dnl CF_DISABLE_GNAT_PROJECTS version: 1 updated: 2014/06/01 11:34:00
2023 dnl ------------------------
2024 AC_DEFUN([CF_DISABLE_GNAT_PROJECTS],[
2025 AC_MSG_CHECKING(if we want to use GNAT projects)
2026 CF_ARG_DISABLE(gnat-projects,
2027         [  --disable-gnat-projects test: disable GNAT projects even if usable],
2028         [enable_gnat_projects=no],
2029         [enable_gnat_projects=yes])
2030 AC_MSG_RESULT($enable_gnat_projects)
2031 ])dnl
2032 dnl ---------------------------------------------------------------------------
2033 dnl CF_DISABLE_LEAKS version: 9 updated: 2021/04/03 16:41:50
2034 dnl ----------------
2035 dnl Combine no-leak checks with the libraries or tools that are used for the
2036 dnl checks.
2037 AC_DEFUN([CF_DISABLE_LEAKS],[
2038
2039 AC_REQUIRE([CF_WITH_DMALLOC])
2040 AC_REQUIRE([CF_WITH_DBMALLOC])
2041 AC_REQUIRE([CF_WITH_VALGRIND])
2042
2043 AC_MSG_CHECKING(if you want to perform memory-leak testing)
2044 AC_ARG_ENABLE(leaks,
2045         [  --disable-leaks         test: free permanent memory, analyze leaks],
2046         [enable_leaks=$enableval],
2047         [enable_leaks=yes])
2048 dnl with_no_leaks is more readable...
2049 if test "x$enable_leaks" = xno; then with_no_leaks=yes; else with_no_leaks=no; fi
2050 AC_MSG_RESULT($with_no_leaks)
2051
2052 if test "$enable_leaks" = no ; then
2053         AC_DEFINE(NO_LEAKS,1,[Define to 1 if you want to perform memory-leak testing.])
2054         AC_DEFINE(YY_NO_LEAKS,1,[Define to 1 if you want to perform memory-leak testing.])
2055 fi
2056 ])dnl
2057 dnl ---------------------------------------------------------------------------
2058 dnl CF_DISABLE_LIBTOOL_VERSION version: 3 updated: 2015/04/17 21:13:04
2059 dnl --------------------------
2060 dnl Check if we should use the libtool 1.5 feature "-version-number" instead of
2061 dnl the older "-version-info" feature.  The newer feature allows us to use
2062 dnl version numbering on shared libraries which make them compatible with
2063 dnl various systems.
2064 AC_DEFUN([CF_DISABLE_LIBTOOL_VERSION],
2065 [
2066 AC_MSG_CHECKING(if libtool -version-number should be used)
2067 CF_ARG_DISABLE(libtool-version,
2068         [  --disable-libtool-version  enable to use libtool's incompatible naming scheme],
2069         [cf_libtool_version=no],
2070         [cf_libtool_version=yes])
2071 AC_MSG_RESULT($cf_libtool_version)
2072
2073 if test "$cf_libtool_version" = yes ; then
2074         LIBTOOL_VERSION="-version-number"
2075 else
2076         LIBTOOL_VERSION="-version-info"
2077         case "x$VERSION" in
2078         (x)
2079                 AC_MSG_WARN(VERSION was not set)
2080                 ;;
2081         (x*.*.*)
2082                 ABI_VERSION="$VERSION"
2083                 CF_VERBOSE(ABI_VERSION: $ABI_VERSION)
2084                 ;;
2085         (x*:*:*)
2086                 ABI_VERSION=`echo "$VERSION" | sed -e 's/:/./g'`
2087                 CF_VERBOSE(ABI_VERSION: $ABI_VERSION)
2088                 ;;
2089         (*)
2090                 AC_MSG_WARN(unexpected VERSION value: $VERSION)
2091                 ;;
2092         esac
2093 fi
2094
2095 AC_SUBST(ABI_VERSION)
2096 AC_SUBST(LIBTOOL_VERSION)
2097 ])dnl
2098 dnl ---------------------------------------------------------------------------
2099 dnl CF_DISABLE_RPATH_HACK version: 3 updated: 2021/01/05 20:14:44
2100 dnl ---------------------
2101 dnl The rpath-hack makes it simpler to build programs, particularly with the
2102 dnl *BSD ports which may have essential libraries in unusual places.  But it
2103 dnl can interfere with building an executable for the base system.  Use this
2104 dnl option in that case.
2105 AC_DEFUN([CF_DISABLE_RPATH_HACK],
2106 [
2107 AC_MSG_CHECKING(if rpath-hack should be disabled)
2108 CF_ARG_DISABLE(rpath-hack,
2109         [  --disable-rpath-hack    don't add rpath options for additional libraries],
2110         [enable_rpath_hack=no],
2111         [enable_rpath_hack=yes])
2112 dnl TODO - drop cf_disable_rpath_hack
2113 if test "x$enable_rpath_hack" = xno; then cf_disable_rpath_hack=yes; else cf_disable_rpath_hack=no; fi
2114 AC_MSG_RESULT($cf_disable_rpath_hack)
2115
2116 if test "$enable_rpath_hack" = yes ; then
2117         CF_RPATH_HACK
2118 fi
2119 ])
2120 dnl ---------------------------------------------------------------------------
2121 dnl CF_ENABLE_BROKEN_LINKER version: 2 updated: 2021/01/02 17:09:14
2122 dnl -----------------------
2123 dnl Some linkers cannot reference a data-only object.  Cygwin used to be one.
2124 dnl This usually follows CF_LINK_DATAONLY, but is not required in case we need
2125 dnl an unconditional feature.
2126 AC_DEFUN([CF_ENABLE_BROKEN_LINKER],[
2127
2128 AC_MSG_CHECKING(if you want broken-linker support code)
2129 AC_ARG_ENABLE(broken_linker,
2130         [  --enable-broken_linker  compile with broken-linker support code],
2131         [with_broken_linker=$enableval],
2132         [with_broken_linker=no])
2133 AC_MSG_RESULT($with_broken_linker)
2134
2135 : "${BROKEN_LINKER:=0}"
2136 if test "x$with_broken_linker" = xyes ; then
2137         AC_DEFINE(BROKEN_LINKER,1,[Define to 1 to work around linkers which cannot link data-only modules])
2138         BROKEN_LINKER=1
2139 fi
2140 AC_SUBST(BROKEN_LINKER)
2141 ])dnl
2142 dnl ---------------------------------------------------------------------------
2143 dnl CF_ENABLE_PC_FILES version: 16 updated: 2021/11/20 12:48:37
2144 dnl ------------------
2145 dnl This is the "--enable-pc-files" option, which is available if there is a
2146 dnl pkg-config configuration on the local machine.
2147 AC_DEFUN([CF_ENABLE_PC_FILES],[
2148 AC_REQUIRE([CF_PKG_CONFIG])
2149 AC_REQUIRE([CF_WITH_PKG_CONFIG_LIBDIR])
2150
2151 if test "x$PKG_CONFIG" != xnone
2152 then
2153         AC_MSG_CHECKING(if we should install .pc files for $PKG_CONFIG)
2154 else
2155         AC_MSG_CHECKING(if we should install .pc files)
2156 fi
2157
2158 AC_ARG_ENABLE(pc-files,
2159         [  --enable-pc-files       generate and install .pc files for pkg-config],
2160         [enable_pc_files=$enableval],
2161         [enable_pc_files=no])
2162 AC_MSG_RESULT($enable_pc_files)
2163
2164 if test "x$enable_pc_files" != xno
2165 then
2166         MAKE_PC_FILES=
2167         case "x$PKG_CONFIG_LIBDIR" in
2168         (xno|xnone|xyes|x)
2169                 AC_MSG_WARN(no PKG_CONFIG_LIBDIR was found)
2170                 ;;
2171         (*)
2172                 cf_pkg_config_libdir="$PKG_CONFIG_LIBDIR"
2173                 CF_PATH_SYNTAX(cf_pkg_config_libdir)
2174                 ;;
2175         esac
2176 else
2177         MAKE_PC_FILES="#"
2178 fi
2179 AC_SUBST(MAKE_PC_FILES)
2180 ])dnl
2181 dnl ---------------------------------------------------------------------------
2182 dnl CF_ENABLE_RPATH version: 2 updated: 2010/03/27 18:39:42
2183 dnl ---------------
2184 dnl Check if the rpath option should be used, setting cache variable
2185 dnl cf_cv_enable_rpath if so.
2186 AC_DEFUN([CF_ENABLE_RPATH],
2187 [
2188 AC_MSG_CHECKING(if rpath option should be used)
2189 AC_ARG_ENABLE(rpath,
2190 [  --enable-rpath          use rpath option when generating shared libraries],
2191 [cf_cv_enable_rpath=$enableval],
2192 [cf_cv_enable_rpath=no])
2193 AC_MSG_RESULT($cf_cv_enable_rpath)
2194 ])dnl
2195 dnl ---------------------------------------------------------------------------
2196 dnl CF_ENABLE_STRING_HACKS version: 6 updated: 2021/01/05 19:23:48
2197 dnl ----------------------
2198 dnl On a few platforms, the compiler and/or loader nags with untruthful
2199 dnl comments stating that "most" uses of strcat/strcpy/sprintf are incorrect,
2200 dnl and implying that most uses of the recommended alternatives are correct.
2201 dnl
2202 dnl Factually speaking, no one has actually counted the number of uses of these
2203 dnl functions versus the total of incorrect uses.  Samples of a few thousand
2204 dnl instances are meaningless compared to the hundreds of millions of lines of
2205 dnl existing C code.
2206 dnl
2207 dnl strlcat/strlcpy are (as of 2012) non-standard, and are available on some
2208 dnl platforms, in implementations of varying quality.  Likewise, snprintf is
2209 dnl standard - but evolved through phases, and older implementations are likely
2210 dnl to yield surprising results, as documented in manpages on various systems.
2211 AC_DEFUN([CF_ENABLE_STRING_HACKS],
2212 [
2213 AC_MSG_CHECKING(if you want to work around bogus compiler/loader warnings)
2214 AC_ARG_ENABLE(string-hacks,
2215         [  --enable-string-hacks   work around bogus compiler/loader warnings],
2216         [enable_string_hacks=$enableval],
2217         [enable_string_hacks=no])
2218 AC_MSG_RESULT($enable_string_hacks)
2219
2220 if test "x$enable_string_hacks" = "xyes"; then
2221         AC_DEFINE(USE_STRING_HACKS,1,[Define to 1 to work around bogus compiler/loader warnings])
2222         AC_MSG_WARN(enabling string-hacks to work around bogus compiler/loader warnings)
2223         AC_CHECK_FUNC(strlcat,[
2224                 AC_DEFINE(HAVE_STRLCAT,1,[Define to 1 if we have strlcat function])
2225                 ],[
2226                 AC_CHECK_LIB(bsd,strlcat,[
2227                         CF_ADD_LIB(bsd)
2228                         AC_CHECK_HEADERS(bsd/string.h)
2229                         AC_DEFINE(HAVE_STRLCAT,1,[Define to 1 if we have strlcat function])
2230                         ])
2231                 ])
2232         AC_CHECK_FUNCS( strlcpy snprintf )
2233 fi
2234 ])dnl
2235 dnl ---------------------------------------------------------------------------
2236 dnl CF_ENABLE_WARNINGS version: 9 updated: 2021/01/05 19:40:50
2237 dnl ------------------
2238 dnl Configure-option to enable gcc warnings
2239 dnl
2240 dnl $1 = extra options to add, if supported
2241 dnl $2 = option for checking attributes.  By default, this is done when
2242 dnl      warnings are enabled.  For other values:
2243 dnl      yes: always do this, e.g., to use in generated library-headers
2244 dnl      no: never do this
2245 AC_DEFUN([CF_ENABLE_WARNINGS],[
2246 if test "$GCC" = yes || test "$GXX" = yes
2247 then
2248 CF_FIX_WARNINGS(CFLAGS)
2249 CF_FIX_WARNINGS(CPPFLAGS)
2250 CF_FIX_WARNINGS(LDFLAGS)
2251 AC_MSG_CHECKING(if you want to turn on gcc warnings)
2252 CF_ARG_ENABLE(warnings,
2253         [  --enable-warnings       test: turn on gcc compiler warnings],
2254         [enable_warnings=yes],
2255         [enable_warnings=no])
2256 AC_MSG_RESULT($enable_warnings)
2257 if test "$enable_warnings" = "yes"
2258 then
2259         ifelse($2,,[CF_GCC_ATTRIBUTES])
2260         CF_GCC_WARNINGS($1)
2261 fi
2262 ifelse($2,yes,[CF_GCC_ATTRIBUTES])
2263 fi
2264 ])dnl
2265 dnl ---------------------------------------------------------------------------
2266 dnl CF_ERRNO version: 5 updated: 1997/11/30 12:44:39
2267 dnl --------
2268 dnl Check if 'errno' is declared in <errno.h>
2269 AC_DEFUN([CF_ERRNO],
2270 [
2271 CF_CHECK_ERRNO(errno)
2272 ])dnl
2273 dnl ---------------------------------------------------------------------------
2274 dnl CF_ETIP_DEFINES version: 6 updated: 2021/01/02 17:09:14
2275 dnl ---------------
2276 dnl Test for conflicting definitions of exception in gcc 2.8.0, etc., between
2277 dnl math.h and builtin.h, only for ncurses
2278 AC_DEFUN([CF_ETIP_DEFINES],
2279 [
2280 AC_MSG_CHECKING(for special defines needed for etip.h)
2281 cf_save_CXXFLAGS="$CXXFLAGS"
2282 cf_result="none"
2283
2284 # etip.h includes ncurses.h which includes ncurses_dll.h
2285 # But ncurses_dll.h is generated - fix here.
2286 test -d include || mkdir include
2287 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
2288
2289 for cf_math in "" MATH_H
2290 do
2291 for cf_excp in "" MATH_EXCEPTION
2292 do
2293         CXXFLAGS="$cf_save_CXXFLAGS -I${srcdir}/c++ -I${srcdir}/menu -Iinclude -I${srcdir}/include"
2294         test -n "$cf_math" && CXXFLAGS="$CXXFLAGS -DETIP_NEEDS_${cf_math}"
2295         test -n "$cf_excp" && CXXFLAGS="$CXXFLAGS -DETIP_NEEDS_${cf_excp}"
2296 AC_TRY_COMPILE([
2297 #include <etip.h.in>
2298 ],[],[
2299         test -n "$cf_math" && AC_DEFINE_UNQUOTED(ETIP_NEEDS_${cf_math})
2300         test -n "$cf_excp" && AC_DEFINE_UNQUOTED(ETIP_NEEDS_${cf_excp})
2301         cf_result="$cf_math $cf_excp"
2302         break 2
2303 ],[])
2304 done
2305 done
2306 AC_MSG_RESULT($cf_result)
2307 CXXFLAGS="$cf_save_CXXFLAGS"
2308 ])
2309 dnl ---------------------------------------------------------------------------
2310 dnl CF_FIND_LINKAGE version: 22 updated: 2020/12/31 20:19:42
2311 dnl ---------------
2312 dnl Find a library (specifically the linkage used in the code fragment),
2313 dnl searching for it if it is not already in the library path.
2314 dnl See also CF_ADD_SEARCHPATH.
2315 dnl
2316 dnl Parameters (4-on are optional):
2317 dnl     $1 = headers for library entrypoint
2318 dnl     $2 = code fragment for library entrypoint
2319 dnl     $3 = the library name without the "-l" option or ".so" suffix.
2320 dnl     $4 = action to perform if successful (default: update CPPFLAGS, etc)
2321 dnl     $5 = action to perform if not successful
2322 dnl     $6 = module name, if not the same as the library name
2323 dnl     $7 = extra libraries
2324 dnl
2325 dnl Sets these variables:
2326 dnl     $cf_cv_find_linkage_$3 - yes/no according to whether linkage is found
2327 dnl     $cf_cv_header_path_$3 - include-directory if needed
2328 dnl     $cf_cv_library_path_$3 - library-directory if needed
2329 dnl     $cf_cv_library_file_$3 - library-file if needed, e.g., -l$3
2330 AC_DEFUN([CF_FIND_LINKAGE],[
2331
2332 # If the linkage is not already in the $CPPFLAGS/$LDFLAGS configuration, these
2333 # will be set on completion of the AC_TRY_LINK below.
2334 cf_cv_header_path_$3=
2335 cf_cv_library_path_$3=
2336
2337 CF_MSG_LOG([Starting [FIND_LINKAGE]($3,$6)])
2338
2339 cf_save_LIBS="$LIBS"
2340
2341 AC_TRY_LINK([$1],[$2],[
2342         cf_cv_find_linkage_$3=yes
2343         cf_cv_header_path_$3=/usr/include
2344         cf_cv_library_path_$3=/usr/lib
2345 ],[
2346
2347 LIBS="-l$3 $7 $cf_save_LIBS"
2348
2349 AC_TRY_LINK([$1],[$2],[
2350         cf_cv_find_linkage_$3=yes
2351         cf_cv_header_path_$3=/usr/include
2352         cf_cv_library_path_$3=/usr/lib
2353         cf_cv_library_file_$3="-l$3"
2354 ],[
2355         cf_cv_find_linkage_$3=no
2356         LIBS="$cf_save_LIBS"
2357
2358         CF_VERBOSE(find linkage for $3 library)
2359         CF_MSG_LOG([Searching for headers in [FIND_LINKAGE]($3,$6)])
2360
2361         cf_save_CPPFLAGS="$CPPFLAGS"
2362         cf_test_CPPFLAGS="$CPPFLAGS"
2363
2364         CF_HEADER_PATH(cf_search,ifelse([$6],,[$3],[$6]))
2365         for cf_cv_header_path_$3 in $cf_search
2366         do
2367                 if test -d "$cf_cv_header_path_$3" ; then
2368                         CF_VERBOSE(... testing $cf_cv_header_path_$3)
2369                         CPPFLAGS="$cf_save_CPPFLAGS"
2370                         CF_APPEND_TEXT(CPPFLAGS,-I$cf_cv_header_path_$3)
2371                         AC_TRY_COMPILE([$1],[$2],[
2372                                 CF_VERBOSE(... found $3 headers in $cf_cv_header_path_$3)
2373                                 cf_cv_find_linkage_$3=maybe
2374                                 cf_test_CPPFLAGS="$CPPFLAGS"
2375                                 break],[
2376                                 CPPFLAGS="$cf_save_CPPFLAGS"
2377                                 ])
2378                 fi
2379         done
2380
2381         if test "$cf_cv_find_linkage_$3" = maybe ; then
2382
2383                 CF_MSG_LOG([Searching for $3 library in [FIND_LINKAGE]($3,$6)])
2384
2385                 cf_save_LIBS="$LIBS"
2386                 cf_save_LDFLAGS="$LDFLAGS"
2387
2388                 ifelse([$6],,,[
2389                 CPPFLAGS="$cf_test_CPPFLAGS"
2390                 LIBS="-l$3 $7 $cf_save_LIBS"
2391                 AC_TRY_LINK([$1],[$2],[
2392                         CF_VERBOSE(... found $3 library in system)
2393                         cf_cv_find_linkage_$3=yes])
2394                         CPPFLAGS="$cf_save_CPPFLAGS"
2395                         LIBS="$cf_save_LIBS"
2396                         ])
2397
2398                 if test "$cf_cv_find_linkage_$3" != yes ; then
2399                         CF_LIBRARY_PATH(cf_search,$3)
2400                         for cf_cv_library_path_$3 in $cf_search
2401                         do
2402                                 if test -d "$cf_cv_library_path_$3" ; then
2403                                         CF_VERBOSE(... testing $cf_cv_library_path_$3)
2404                                         CPPFLAGS="$cf_test_CPPFLAGS"
2405                                         LIBS="-l$3 $7 $cf_save_LIBS"
2406                                         LDFLAGS="$cf_save_LDFLAGS -L$cf_cv_library_path_$3"
2407                                         AC_TRY_LINK([$1],[$2],[
2408                                         CF_VERBOSE(... found $3 library in $cf_cv_library_path_$3)
2409                                         cf_cv_find_linkage_$3=yes
2410                                         cf_cv_library_file_$3="-l$3"
2411                                         break],[
2412                                         CPPFLAGS="$cf_save_CPPFLAGS"
2413                                         LIBS="$cf_save_LIBS"
2414                                         LDFLAGS="$cf_save_LDFLAGS"
2415                                         ])
2416                                 fi
2417                         done
2418                         CPPFLAGS="$cf_save_CPPFLAGS"
2419                         LDFLAGS="$cf_save_LDFLAGS"
2420                 fi
2421
2422         else
2423                 cf_cv_find_linkage_$3=no
2424         fi
2425         ],$7)
2426 ])
2427
2428 LIBS="$cf_save_LIBS"
2429
2430 if test "$cf_cv_find_linkage_$3" = yes ; then
2431 ifelse([$4],,[
2432         CF_ADD_INCDIR($cf_cv_header_path_$3)
2433         CF_ADD_LIBDIR($cf_cv_library_path_$3)
2434         CF_ADD_LIB($3)
2435 ],[$4])
2436 else
2437 ifelse([$5],,AC_MSG_WARN(Cannot find $3 library),[$5])
2438 fi
2439 ])dnl
2440 dnl ---------------------------------------------------------------------------
2441 dnl CF_FIND_SUB_INCDIR version: 3 updated: 2021/01/01 13:31:04
2442 dnl ------------------
2443 dnl Find an include-directory with the given leaf-name.  This is useful for
2444 dnl example with FreeBSD ports, which use this convention to distinguish
2445 dnl different versions of the same port.
2446 AC_DEFUN([CF_FIND_SUB_INCDIR],[
2447         CF_SUBDIR_PATH(cf_search,$1,include)
2448         for cf_item in $cf_search
2449         do
2450                 case "$cf_item" in
2451                 (*/$1)
2452                         CF_ADD_INCDIR($cf_item)
2453                         ;;
2454                 esac
2455         done
2456 ])dnl
2457 dnl ---------------------------------------------------------------------------
2458 dnl CF_FIND_SUB_LIBDIR version: 3 updated: 2021/01/01 13:31:04
2459 dnl ------------------
2460 dnl Find a library-directory with the given leaf-name.  This is useful for
2461 dnl example with FreeBSD ports, which use this convention to distinguish
2462 dnl different versions of the same port.
2463 AC_DEFUN([CF_FIND_SUB_LIBDIR],[
2464         CF_SUBDIR_PATH(cf_search,$1,lib)
2465         for cf_item in $cf_search
2466         do
2467                 case "$cf_item" in
2468                 (*/$1)
2469                         CF_ADD_LIBDIR($cf_item)
2470                         ;;
2471                 esac
2472         done
2473 ])dnl
2474 dnl ---------------------------------------------------------------------------
2475 dnl CF_FIXUP_ADAFLAGS version: 2 updated: 2015/04/17 21:13:04
2476 dnl -----------------
2477 dnl make ADAFLAGS consistent with CFLAGS
2478 AC_DEFUN([CF_FIXUP_ADAFLAGS],[
2479         AC_MSG_CHECKING(optimization options for ADAFLAGS)
2480         case "$CFLAGS" in
2481         (*-g*)
2482                 CF_ADD_ADAFLAGS(-g)
2483                 ;;
2484         esac
2485         case "$CFLAGS" in
2486         (*-O*)
2487                 cf_O_flag=`echo "$CFLAGS" |sed -e 's/^.*-O/-O/' -e 's/[[        ]].*//'`
2488                 CF_ADD_ADAFLAGS($cf_O_flag)
2489                 ;;
2490         esac
2491         AC_MSG_RESULT($ADAFLAGS)
2492 ])dnl
2493 dnl ---------------------------------------------------------------------------
2494 dnl CF_FIX_WARNINGS version: 4 updated: 2021/12/16 18:22:31
2495 dnl ---------------
2496 dnl Warning flags do not belong in CFLAGS, CPPFLAGS, etc.  Any of gcc's
2497 dnl "-Werror" flags can interfere with configure-checks.  Those go into
2498 dnl EXTRA_CFLAGS.
2499 dnl
2500 dnl $1 = variable name to repair
2501 define([CF_FIX_WARNINGS],[
2502 if test "$GCC" = yes || test "$GXX" = yes
2503 then
2504         case [$]$1 in
2505         (*-Werror=*)
2506                 cf_temp_flags=
2507                 for cf_temp_scan in [$]$1
2508                 do
2509                         case "x$cf_temp_scan" in
2510                         (x-Werror=format*)
2511                                 CF_APPEND_TEXT(cf_temp_flags,$cf_temp_scan)
2512                                 ;;
2513                         (x-Werror=*)
2514                                 CF_APPEND_TEXT(EXTRA_CFLAGS,$cf_temp_scan)
2515                                 ;;
2516                         (*)
2517                                 CF_APPEND_TEXT(cf_temp_flags,$cf_temp_scan)
2518                                 ;;
2519                         esac
2520                 done
2521                 if test "x[$]$1" != "x$cf_temp_flags"
2522                 then
2523                         CF_VERBOSE(repairing $1: [$]$1)
2524                         $1="$cf_temp_flags"
2525                         CF_VERBOSE(... fixed [$]$1)
2526                         CF_VERBOSE(... extra $EXTRA_CFLAGS)
2527                 fi
2528                 ;;
2529         esac
2530 fi
2531 AC_SUBST(EXTRA_CFLAGS)
2532 ])dnl
2533 dnl ---------------------------------------------------------------------------
2534 dnl CF_FOPEN_BIN_R version: 3 updated: 2023/01/05 18:05:46
2535 dnl --------------
2536 dnl Check if fopen works when the "b" (binary) flag is added to the mode
2537 dnl parameter.  POSIX ignores the "b", which c89 specified.  Some very old
2538 dnl systems do not accept it.
2539 AC_DEFUN([CF_FOPEN_BIN_R],[
2540 AC_CACHE_CHECK(if fopen accepts explicit binary mode,cf_cv_fopen_bin_r,[
2541         AC_TRY_RUN([
2542 $ac_includes_default
2543
2544 int main(void)
2545 {
2546         FILE *fp = fopen("conftest.tmp", "wb");
2547         int rc = 0;
2548         if (fp != 0) {
2549                 int p, q;
2550                 for (p = 0; p < 256; ++p) {
2551                         fputc(p, fp);
2552                 }
2553                 fclose(fp);
2554                 fp = fopen("conftest.tmp", "rb");
2555                 if (fp != 0) {
2556                         for (p = 0; p < 256; ++p) {
2557                                 q = fgetc(fp);
2558                                 if (q != p) {
2559                                         rc = 1;
2560                                         break;
2561                                 }
2562                         }
2563                 } else {
2564                         rc = 1;
2565                 }
2566         } else {
2567                 rc = 1;
2568         }
2569         ${cf_cv_main_return:-return} (rc);
2570 }
2571 ],
2572                 [cf_cv_fopen_bin_r=yes],
2573                 [cf_cv_fopen_bin_r=no],
2574                 [cf_cv_fopen_bin_r=unknown])
2575 ])
2576 test "x$cf_cv_fopen_bin_r" != xno && AC_DEFINE(USE_FOPEN_BIN_R,1,[Define to 1 if fopen accepts explicit binary mode])
2577 ])dnl
2578 dnl ---------------------------------------------------------------------------
2579 dnl CF_FORGET_TOOL version: 1 updated: 2013/04/06 18:03:09
2580 dnl --------------
2581 dnl Forget that we saw the given tool.
2582 AC_DEFUN([CF_FORGET_TOOL],[
2583 unset ac_cv_prog_ac_ct_$1
2584 unset ac_ct_$1
2585 unset $1
2586 ])dnl
2587 dnl ---------------------------------------------------------------------------
2588 dnl CF_FUNC_DLSYM version: 4 updated: 2015/09/12 14:46:44
2589 dnl -------------
2590 dnl Test for dlsym() and related functions, as well as libdl.
2591 dnl
2592 dnl Sets
2593 dnl     $cf_have_dlsym
2594 dnl     $cf_have_libdl
2595 AC_DEFUN([CF_FUNC_DLSYM],[
2596 cf_have_dlsym=no
2597 AC_CHECK_FUNC(dlsym,cf_have_dlsym=yes,[
2598
2599 cf_have_libdl=no
2600 AC_CHECK_LIB(dl,dlsym,[
2601         cf_have_dlsym=yes
2602         cf_have_libdl=yes])])
2603
2604 if test "$cf_have_dlsym" = yes ; then
2605         test "$cf_have_libdl" = yes && { CF_ADD_LIB(dl) }
2606
2607         AC_MSG_CHECKING(whether able to link to dl*() functions)
2608         AC_TRY_LINK([#include <dlfcn.h>],[
2609                 void *obj;
2610                 if ((obj = dlopen("filename", 0)) != 0) {
2611                         if (dlsym(obj, "symbolname") == 0) {
2612                         dlclose(obj);
2613                         }
2614                 }],[
2615                 AC_DEFINE(HAVE_LIBDL,1,[Define to 1 if we have dl library])],[
2616                 AC_MSG_ERROR(Cannot link test program for libdl)])
2617         AC_MSG_RESULT(ok)
2618 else
2619         AC_MSG_ERROR(Cannot find dlsym function)
2620 fi
2621 ])
2622 dnl ---------------------------------------------------------------------------
2623 dnl CF_FUNC_GETTIME version: 2 updated: 2023/02/25 08:45:56
2624 dnl ---------------
2625 dnl Check for gettimeofday or clock_gettime.  In 2023, the former is still more
2626 dnl widely supported, but "deprecated" (2008), so we will use the latter if it
2627 dnl is available, to reduce compiler warnings.
2628 AC_DEFUN([CF_FUNC_GETTIME],[
2629 AC_CACHE_CHECK(for clock_gettime,cf_cv_func_clock_gettime,[
2630                 AC_TRY_LINK([#include <time.h>],
2631                 [struct timespec ts;
2632                 int rc = clock_gettime(CLOCK_REALTIME, &ts); (void) rc; (void)ts],
2633                 [cf_cv_func_clock_gettime=yes],
2634                 [cf_cv_func_clock_gettime=no])
2635 ])
2636
2637 if test "$cf_cv_func_clock_gettime" = yes
2638 then
2639         AC_DEFINE(HAVE_CLOCK_GETTIME,1,[Define to 1 if we have clock_gettime function])
2640 else
2641 AC_CHECK_FUNC(gettimeofday,
2642         AC_DEFINE(HAVE_GETTIMEOFDAY,1,[Define to 1 if we have gettimeofday function]),[
2643
2644 AC_CHECK_LIB(bsd, gettimeofday,
2645         AC_DEFINE(HAVE_GETTIMEOFDAY,1,[Define to 1 if we have gettimeofday function])
2646         CF_ADD_LIB(bsd))])dnl CLIX: bzero, select, gettimeofday
2647 fi
2648 ])dnl
2649 dnl ---------------------------------------------------------------------------
2650 dnl CF_FUNC_GETTTYNAM version: 2 updated: 2023/01/05 18:06:28
2651 dnl -----------------
2652 dnl Check if the 4.3BSD function getttyname exists, as well as if <ttyent.h>
2653 dnl defines the _PATH_TTYS symbol.  If the corresponding file exists, but the
2654 dnl other checks fail, just define HAVE_PATH_TTYS.
2655 AC_DEFUN([CF_FUNC_GETTTYNAM],[
2656 AC_CACHE_CHECK(if _PATH_TTYS is defined in ttyent.h,cf_cv_PATH_TTYS,[
2657 AC_TRY_COMPILE([
2658 #include <stdio.h>
2659 #include <ttyent.h>],[
2660 FILE *fp = fopen(_PATH_TTYS, "r"); (void)fp],
2661         [cf_cv_PATH_TTYS=yes],
2662         [cf_cv_PATH_TTYS=no])])
2663
2664 if test $cf_cv_PATH_TTYS = no
2665 then
2666         for cf_ttys in /etc/ttytype /etc/ttys
2667         do
2668                 if test -f $cf_ttys
2669                 then
2670                         cf_cv_PATH_TTYS=maybe
2671                         AC_DEFINE(_PATH_TTYS,$cf_ttys,[define to pathname of file containing mapping from tty name to terminal type])
2672                         break
2673                 fi
2674         done
2675 fi
2676
2677 if test $cf_cv_PATH_TTYS != no
2678 then
2679         AC_CACHE_CHECK(if _PATH_TTYS file exists,cf_cv_have_PATH_TTYS,[
2680                 AC_TRY_RUN([
2681 $ac_includes_default
2682
2683 #include <ttyent.h>
2684
2685 int main(void) {
2686         FILE *fp = fopen(_PATH_TTYS, "r");
2687         ${cf_cv_main_return:-return} (fp == 0);
2688 }],
2689                         [cf_cv_have_PATH_TTYS=yes],
2690                         [cf_cv_have_PATH_TTYS=no],
2691                         [cf_cv_have_PATH_TTYS=unknown])])
2692         test "$cf_cv_have_PATH_TTYS" = no && cf_cv_PATH_TTYS=no
2693 fi
2694
2695 if test $cf_cv_PATH_TTYS != no
2696 then
2697         AC_DEFINE(HAVE_PATH_TTYS,1,[define to 1 if system can map tty name to terminal type])
2698         AC_CACHE_CHECK(for getttynam,cf_cv_func_getttynam,[
2699                 AC_TRY_LINK([#include <ttyent.h>],
2700                 [struct ttyent *fp = getttynam("/dev/tty"); (void)fp],
2701                 [cf_cv_func_getttynam=yes],
2702                 [cf_cv_func_getttynam=no])])
2703         test "$cf_cv_func_getttynam" = yes && AC_DEFINE(HAVE_GETTTYNAM)
2704 fi
2705 ])dnl
2706 dnl ---------------------------------------------------------------------------
2707 dnl CF_FUNC_MEMMOVE version: 10 updated: 2023/01/05 18:51:28
2708 dnl ---------------
2709 dnl Check for memmove, or a bcopy that can handle overlapping copy.  If neither
2710 dnl is found, add our own version of memmove to the list of objects.
2711 AC_DEFUN([CF_FUNC_MEMMOVE],
2712 [
2713 AC_CHECK_FUNC(memmove,,[
2714 AC_CHECK_FUNC(bcopy,[
2715         AC_CACHE_CHECK(if bcopy does overlapping moves,cf_cv_good_bcopy,[
2716                 AC_TRY_RUN([
2717 $ac_includes_default
2718
2719 int main(void) {
2720         static char data[] = "abcdefghijklmnopqrstuwwxyz";
2721         char temp[40];
2722         bcopy(data, temp, sizeof(data));
2723         bcopy(temp+10, temp, 15);
2724         bcopy(temp+5, temp+15, 10);
2725         ${cf_cv_main_return:-return} (strcmp(temp, "klmnopqrstuwwxypqrstuwwxyz"));
2726 }
2727                 ],
2728                 [cf_cv_good_bcopy=yes],
2729                 [cf_cv_good_bcopy=no],
2730                 [cf_cv_good_bcopy=unknown])
2731                 ])
2732         ],[cf_cv_good_bcopy=no])
2733         if test "$cf_cv_good_bcopy" = yes ; then
2734                 AC_DEFINE(USE_OK_BCOPY,1,[Define to 1 to use bcopy when memmove is unavailable])
2735         else
2736                 AC_DEFINE(USE_MY_MEMMOVE,1,[Define to 1 to use replacement function when memmove is unavailable])
2737         fi
2738 ])])dnl
2739 dnl ---------------------------------------------------------------------------
2740 dnl CF_FUNC_NANOSLEEP version: 6 updated: 2023/01/05 18:51:33
2741 dnl -----------------
2742 dnl Check for existence of workable nanosleep() function.  Some systems, e.g.,
2743 dnl AIX 4.x, provide a non-working version.
2744 AC_DEFUN([CF_FUNC_NANOSLEEP],[
2745 AC_CACHE_CHECK(if nanosleep really works,cf_cv_func_nanosleep,[
2746 AC_TRY_RUN([
2747 $ac_includes_default
2748
2749 #include <errno.h>
2750 #include <time.h>
2751
2752 #ifdef HAVE_SYS_TIME_H
2753 #include <sys/time.h>
2754 #endif
2755
2756 int main(void) {
2757         struct timespec ts1, ts2;
2758         int code;
2759         ts1.tv_sec  = 0;
2760         ts1.tv_nsec = 750000000;
2761         ts2.tv_sec  = 0;
2762         ts2.tv_nsec = 0;
2763         errno = 0;
2764         code = nanosleep(&ts1, &ts2); /* on failure errno is ENOSYS. */
2765         ${cf_cv_main_return:-return}(code != 0);
2766 }
2767 ],
2768         [cf_cv_func_nanosleep=yes],
2769         [cf_cv_func_nanosleep=no],
2770         [cf_cv_func_nanosleep=unknown])])
2771
2772 test "$cf_cv_func_nanosleep" = "yes" && AC_DEFINE(HAVE_NANOSLEEP,1,[Define to 1 if we have nanosleep()])
2773 ])
2774 dnl ---------------------------------------------------------------------------
2775 dnl CF_FUNC_OPENPTY version: 6 updated: 2021/01/01 13:31:04
2776 dnl ---------------
2777 dnl Check for openpty() function, along with <pty.h> header.  It may need the
2778 dnl "util" library as well.
2779 AC_DEFUN([CF_FUNC_OPENPTY],
2780 [
2781 AC_CHECK_LIB(util,openpty,cf_cv_lib_util=yes,cf_cv_lib_util=no)
2782 AC_CACHE_CHECK(for openpty header,cf_cv_func_openpty,[
2783         cf_save_LIBS="$LIBS"
2784         test "$cf_cv_lib_util" = yes && { CF_ADD_LIB(util) }
2785         for cf_header in pty.h libutil.h util.h
2786         do
2787         AC_TRY_LINK([
2788 #include <$cf_header>
2789 ],[
2790         int x = openpty((int *)0, (int *)0, (char *)0,
2791                                    (struct termios *)0, (struct winsize *)0);
2792 ],[
2793                 cf_cv_func_openpty=$cf_header
2794                 break
2795 ],[
2796                 cf_cv_func_openpty=no
2797 ])
2798         done
2799         LIBS="$cf_save_LIBS"
2800 ])
2801 ])dnl
2802 dnl ---------------------------------------------------------------------------
2803 dnl CF_FUNC_POLL version: 11 updated: 2023/01/05 18:51:40
2804 dnl ------------
2805 dnl See if the poll function really works.  Some platforms have poll(), but
2806 dnl it does not work for terminals or files.
2807 AC_DEFUN([CF_FUNC_POLL],[
2808 tty >/dev/null 2>&1 || { AC_CHECK_FUNCS(posix_openpt) }
2809 AC_CACHE_CHECK(if poll really works,cf_cv_working_poll,[
2810 AC_TRY_RUN([
2811 $ac_includes_default
2812
2813 #include <fcntl.h>
2814
2815 #ifdef HAVE_POLL_H
2816 #include <poll.h>
2817 #else
2818 #include <sys/poll.h>
2819 #endif
2820
2821 int main(void) {
2822         struct pollfd myfds;
2823         int ret;
2824
2825         /* check for Darwin bug with respect to "devices" */
2826         myfds.fd = open("/dev/null", 1);        /* O_WRONLY */
2827         if (myfds.fd < 0)
2828                 myfds.fd = 0;
2829         myfds.events = POLLIN;
2830         myfds.revents = 0;
2831
2832         ret = poll(&myfds, 1, 100);
2833
2834         if (ret < 0 || (myfds.revents & POLLNVAL)) {
2835                 ret = -1;
2836         } else {
2837                 int fd = 0;
2838                 if (!isatty(fd)) {
2839                         fd = open("/dev/tty", 2);       /* O_RDWR */
2840                 }
2841 #ifdef HAVE_POSIX_OPENPT
2842                 if (fd < 0) {
2843                         fd = posix_openpt(O_RDWR);
2844                 }
2845 #endif
2846
2847                 if (fd >= 0) {
2848                         /* also check with standard input */
2849                         myfds.fd = fd;
2850                         myfds.events = POLLIN;
2851                         myfds.revents = 0;
2852                         ret = poll(&myfds, 1, 100);
2853                 } else {
2854                         ret = -1;
2855                 }
2856         }
2857         ${cf_cv_main_return:-return}(ret < 0);
2858 }],
2859         [cf_cv_working_poll=yes],
2860         [cf_cv_working_poll=no],
2861         [cf_cv_working_poll=unknown])])
2862 test "$cf_cv_working_poll" = "yes" && AC_DEFINE(HAVE_WORKING_POLL,1,[Define to 1 if the poll function seems to work])
2863 ])dnl
2864 dnl ---------------------------------------------------------------------------
2865 dnl CF_FUNC_TERMIOS version: 3 updated: 2012/10/06 17:56:13
2866 dnl ---------------
2867 dnl Some old/broken variations define tcgetattr() only as a macro in
2868 dnl termio(s).h
2869 AC_DEFUN([CF_FUNC_TERMIOS],[
2870 AC_REQUIRE([CF_STRUCT_TERMIOS])
2871 AC_CACHE_CHECK(for tcgetattr, cf_cv_have_tcgetattr,[
2872 AC_TRY_LINK([
2873 #include <sys/types.h>
2874 #ifdef HAVE_UNISTD_H
2875 #include <unistd.h>
2876 #endif
2877 #ifdef HAVE_TERMIOS_H
2878 #include <termios.h>
2879 #define TTY struct termios
2880 #else
2881 #ifdef HAVE_TERMIO_H
2882 #include <termio.h>
2883 #define TTY struct termio
2884 #endif
2885 #endif
2886 ],[
2887 TTY foo;
2888 tcgetattr(1, &foo);],
2889 [cf_cv_have_tcgetattr=yes],
2890 [cf_cv_have_tcgetattr=no])])
2891 test "$cf_cv_have_tcgetattr" = yes && AC_DEFINE(HAVE_TCGETATTR,1,[Define to 1 if we have tcgetattr])
2892 ])dnl
2893 dnl ---------------------------------------------------------------------------
2894 dnl CF_FUNC_VSSCANF version: 7 updated: 2021/01/01 13:31:04
2895 dnl ---------------
2896 dnl Check for vsscanf() function, which is in c9x but generally not in earlier
2897 dnl versions of C.  It is in the GNU C library, and can often be simulated by
2898 dnl other functions.
2899 AC_DEFUN([CF_FUNC_VSSCANF],
2900 [
2901 AC_CACHE_CHECK(for vsscanf function or workaround,cf_cv_func_vsscanf,[
2902 AC_TRY_LINK([
2903 #include <stdarg.h>
2904 #include <stdio.h>],[
2905         va_list ap;
2906         vsscanf("from", "%d", ap)],[cf_cv_func_vsscanf=vsscanf],[
2907 AC_TRY_LINK([
2908 #include <stdarg.h>
2909 #include <stdio.h>],[
2910         FILE strbuf;
2911         char *str = "from";
2912
2913         strbuf._flag = _IOREAD;
2914         strbuf._ptr = strbuf._base = (unsigned char *) str;
2915         strbuf._cnt = strlen(str);
2916         strbuf._file = _NFILE;
2917         return (vfscanf(&strbuf, "%d", ap))],[cf_cv_func_vsscanf=vfscanf],[
2918 AC_TRY_LINK([
2919 #include <stdarg.h>
2920 #include <stdio.h>],[
2921         FILE strbuf;
2922         char *str = "from";
2923
2924         strbuf._flag = _IOREAD;
2925         strbuf._ptr = strbuf._base = (unsigned char *) str;
2926         strbuf._cnt = strlen(str);
2927         strbuf._file = _NFILE;
2928         return (_doscan(&strbuf, "%d", ap))],[cf_cv_func_vsscanf=_doscan],[
2929 cf_cv_func_vsscanf=no])])])])
2930
2931 case "$cf_cv_func_vsscanf" in
2932 (vsscanf) AC_DEFINE(HAVE_VSSCANF,1,[Define to 1 if we have vsscanf]);;
2933 (vfscanf) AC_DEFINE(HAVE_VFSCANF,1,[Define to 1 if we have vfscanf]);;
2934 (_doscan) AC_DEFINE(HAVE__DOSCAN,1,[Define to 1 if we have _doscan]);;
2935 esac
2936
2937 ])dnl
2938 dnl ---------------------------------------------------------------------------
2939 dnl CF_GCC_ATTRIBUTES version: 24 updated: 2021/03/20 12:00:25
2940 dnl -----------------
2941 dnl Test for availability of useful gcc __attribute__ directives to quiet
2942 dnl compiler warnings.  Though useful, not all are supported -- and contrary
2943 dnl to documentation, unrecognized directives cause older compilers to barf.
2944 AC_DEFUN([CF_GCC_ATTRIBUTES],
2945 [AC_REQUIRE([AC_PROG_FGREP])dnl
2946 AC_REQUIRE([CF_C11_NORETURN])dnl
2947
2948 if test "$GCC" = yes || test "$GXX" = yes
2949 then
2950 cat > conftest.i <<EOF
2951 #ifndef GCC_PRINTF
2952 #define GCC_PRINTF 0
2953 #endif
2954 #ifndef GCC_SCANF
2955 #define GCC_SCANF 0
2956 #endif
2957 #ifndef GCC_NORETURN
2958 #define GCC_NORETURN /* nothing */
2959 #endif
2960 #ifndef GCC_UNUSED
2961 #define GCC_UNUSED /* nothing */
2962 #endif
2963 EOF
2964 if test "$GCC" = yes
2965 then
2966         AC_CHECKING([for $CC __attribute__ directives])
2967 cat > "conftest.$ac_ext" <<EOF
2968 #line __oline__ "${as_me:-configure}"
2969 #include <stdio.h>
2970 #include "confdefs.h"
2971 #include "conftest.h"
2972 #include "conftest.i"
2973 #if     GCC_PRINTF
2974 #define GCC_PRINTFLIKE(fmt,var) __attribute__((format(printf,fmt,var)))
2975 #else
2976 #define GCC_PRINTFLIKE(fmt,var) /*nothing*/
2977 #endif
2978 #if     GCC_SCANF
2979 #define GCC_SCANFLIKE(fmt,var)  __attribute__((format(scanf,fmt,var)))
2980 #else
2981 #define GCC_SCANFLIKE(fmt,var)  /*nothing*/
2982 #endif
2983 extern void wow(char *,...) GCC_SCANFLIKE(1,2);
2984 extern GCC_NORETURN void oops(char *,...) GCC_PRINTFLIKE(1,2);
2985 extern GCC_NORETURN void foo(void);
2986 int main(int argc GCC_UNUSED, char *argv[[]] GCC_UNUSED) { (void)argc; (void)argv; return 0; }
2987 EOF
2988         cf_printf_attribute=no
2989         cf_scanf_attribute=no
2990         for cf_attribute in scanf printf unused noreturn
2991         do
2992                 CF_UPPER(cf_ATTRIBUTE,$cf_attribute)
2993                 cf_directive="__attribute__(($cf_attribute))"
2994                 echo "checking for $CC $cf_directive" 1>&AC_FD_CC
2995
2996                 case "$cf_attribute" in
2997                 (printf)
2998                         cf_printf_attribute=yes
2999                         cat >conftest.h <<EOF
3000 #define GCC_$cf_ATTRIBUTE 1
3001 EOF
3002                         ;;
3003                 (scanf)
3004                         cf_scanf_attribute=yes
3005                         cat >conftest.h <<EOF
3006 #define GCC_$cf_ATTRIBUTE 1
3007 EOF
3008                         ;;
3009                 (*)
3010                         cat >conftest.h <<EOF
3011 #define GCC_$cf_ATTRIBUTE $cf_directive
3012 EOF
3013                         ;;
3014                 esac
3015
3016                 if AC_TRY_EVAL(ac_compile); then
3017                         test -n "$verbose" && AC_MSG_RESULT(... $cf_attribute)
3018                         cat conftest.h >>confdefs.h
3019                         case "$cf_attribute" in
3020                         (noreturn)
3021                                 AC_DEFINE_UNQUOTED(GCC_NORETURN,$cf_directive,[Define to noreturn-attribute for gcc])
3022                                 ;;
3023                         (printf)
3024                                 cf_value='/* nothing */'
3025                                 if test "$cf_printf_attribute" != no ; then
3026                                         cf_value='__attribute__((format(printf,fmt,var)))'
3027                                         AC_DEFINE(GCC_PRINTF,1,[Define to 1 if the compiler supports gcc-like printf attribute.])
3028                                 fi
3029                                 AC_DEFINE_UNQUOTED(GCC_PRINTFLIKE(fmt,var),$cf_value,[Define to printf-attribute for gcc])
3030                                 ;;
3031                         (scanf)
3032                                 cf_value='/* nothing */'
3033                                 if test "$cf_scanf_attribute" != no ; then
3034                                         cf_value='__attribute__((format(scanf,fmt,var)))'
3035                                         AC_DEFINE(GCC_SCANF,1,[Define to 1 if the compiler supports gcc-like scanf attribute.])
3036                                 fi
3037                                 AC_DEFINE_UNQUOTED(GCC_SCANFLIKE(fmt,var),$cf_value,[Define to sscanf-attribute for gcc])
3038                                 ;;
3039                         (unused)
3040                                 AC_DEFINE_UNQUOTED(GCC_UNUSED,$cf_directive,[Define to unused-attribute for gcc])
3041                                 ;;
3042                         esac
3043                 fi
3044         done
3045 else
3046         ${FGREP-fgrep} define conftest.i >>confdefs.h
3047 fi
3048 rm -rf ./conftest*
3049 fi
3050 ])dnl
3051 dnl ---------------------------------------------------------------------------
3052 dnl CF_GCC_VERSION version: 9 updated: 2023/03/05 14:30:13
3053 dnl --------------
3054 dnl Find version of gcc, and (because icc/clang pretend to be gcc without being
3055 dnl compatible), attempt to determine if icc/clang is actually used.
3056 AC_DEFUN([CF_GCC_VERSION],[
3057 AC_REQUIRE([AC_PROG_CC])
3058 GCC_VERSION=none
3059 if test "$GCC" = yes ; then
3060         AC_MSG_CHECKING(version of $CC)
3061         GCC_VERSION="`${CC} --version 2>/dev/null | sed -e '2,$d' -e 's/^[[^(]]*([[^)]][[^)]]*) //' -e 's/^[[^0-9.]]*//' -e 's/[[^0-9.]].*//'`"
3062         test -z "$GCC_VERSION" && GCC_VERSION=unknown
3063         AC_MSG_RESULT($GCC_VERSION)
3064 fi
3065 CF_INTEL_COMPILER(GCC,INTEL_COMPILER,CFLAGS)
3066 CF_CLANG_COMPILER(GCC,CLANG_COMPILER,CFLAGS)
3067 ])dnl
3068 dnl ---------------------------------------------------------------------------
3069 dnl CF_GCC_WARNINGS version: 41 updated: 2021/01/01 16:53:59
3070 dnl ---------------
3071 dnl Check if the compiler supports useful warning options.  There's a few that
3072 dnl we don't use, simply because they're too noisy:
3073 dnl
3074 dnl     -Wconversion (useful in older versions of gcc, but not in gcc 2.7.x)
3075 dnl     -Winline (usually not worthwhile)
3076 dnl     -Wredundant-decls (system headers make this too noisy)
3077 dnl     -Wtraditional (combines too many unrelated messages, only a few useful)
3078 dnl     -Wwrite-strings (too noisy, but should review occasionally).  This
3079 dnl             is enabled for ncurses using "--enable-const".
3080 dnl     -pedantic
3081 dnl
3082 dnl Parameter:
3083 dnl     $1 is an optional list of gcc warning flags that a particular
3084 dnl             application might want to use, e.g., "no-unused" for
3085 dnl             -Wno-unused
3086 dnl Special:
3087 dnl     If $with_ext_const is "yes", add a check for -Wwrite-strings
3088 dnl
3089 AC_DEFUN([CF_GCC_WARNINGS],
3090 [
3091 AC_REQUIRE([CF_GCC_VERSION])
3092 if test "x$have_x" = xyes; then CF_CONST_X_STRING fi
3093 cat > "conftest.$ac_ext" <<EOF
3094 #line __oline__ "${as_me:-configure}"
3095 int main(int argc, char *argv[[]]) { return (argv[[argc-1]] == 0) ; }
3096 EOF
3097 if test "$INTEL_COMPILER" = yes
3098 then
3099 # The "-wdXXX" options suppress warnings:
3100 # remark #1419: external declaration in primary source file
3101 # remark #1683: explicit conversion of a 64-bit integral type to a smaller integral type (potential portability problem)
3102 # remark #1684: conversion from pointer to same-sized integral type (potential portability problem)
3103 # remark #193: zero used for undefined preprocessing identifier
3104 # remark #593: variable "curs_sb_left_arrow" was set but never used
3105 # remark #810: conversion from "int" to "Dimension={unsigned short}" may lose significant bits
3106 # remark #869: parameter "tw" was never referenced
3107 # remark #981: operands are evaluated in unspecified order
3108 # warning #279: controlling expression is constant
3109
3110         AC_CHECKING([for $CC warning options])
3111         cf_save_CFLAGS="$CFLAGS"
3112         EXTRA_CFLAGS="$EXTRA_CFLAGS -Wall"
3113         for cf_opt in \
3114                 wd1419 \
3115                 wd1683 \
3116                 wd1684 \
3117                 wd193 \
3118                 wd593 \
3119                 wd279 \
3120                 wd810 \
3121                 wd869 \
3122                 wd981
3123         do
3124                 CFLAGS="$cf_save_CFLAGS $EXTRA_CFLAGS -$cf_opt"
3125                 if AC_TRY_EVAL(ac_compile); then
3126                         test -n "$verbose" && AC_MSG_RESULT(... -$cf_opt)
3127                         EXTRA_CFLAGS="$EXTRA_CFLAGS -$cf_opt"
3128                 fi
3129         done
3130         CFLAGS="$cf_save_CFLAGS"
3131 elif test "$GCC" = yes && test "$GCC_VERSION" != "unknown"
3132 then
3133         AC_CHECKING([for $CC warning options])
3134         cf_save_CFLAGS="$CFLAGS"
3135         cf_warn_CONST=""
3136         test "$with_ext_const" = yes && cf_warn_CONST="Wwrite-strings"
3137         cf_gcc_warnings="Wignored-qualifiers Wlogical-op Wvarargs"
3138         test "x$CLANG_COMPILER" = xyes && cf_gcc_warnings=
3139         for cf_opt in W Wall \
3140                 Wbad-function-cast \
3141                 Wcast-align \
3142                 Wcast-qual \
3143                 Wdeclaration-after-statement \
3144                 Wextra \
3145                 Winline \
3146                 Wmissing-declarations \
3147                 Wmissing-prototypes \
3148                 Wnested-externs \
3149                 Wpointer-arith \
3150                 Wshadow \
3151                 Wstrict-prototypes \
3152                 Wundef Wno-inline $cf_gcc_warnings $cf_warn_CONST $1
3153         do
3154                 CFLAGS="$cf_save_CFLAGS $EXTRA_CFLAGS -$cf_opt"
3155                 if AC_TRY_EVAL(ac_compile); then
3156                         test -n "$verbose" && AC_MSG_RESULT(... -$cf_opt)
3157                         case "$cf_opt" in
3158                         (Winline)
3159                                 case "$GCC_VERSION" in
3160                                 ([[34]].*)
3161                                         CF_VERBOSE(feature is broken in gcc $GCC_VERSION)
3162                                         continue;;
3163                                 esac
3164                                 ;;
3165                         (Wpointer-arith)
3166                                 case "$GCC_VERSION" in
3167                                 ([[12]].*)
3168                                         CF_VERBOSE(feature is broken in gcc $GCC_VERSION)
3169                                         continue;;
3170                                 esac
3171                                 ;;
3172                         esac
3173                         EXTRA_CFLAGS="$EXTRA_CFLAGS -$cf_opt"
3174                 fi
3175         done
3176         CFLAGS="$cf_save_CFLAGS"
3177 fi
3178 rm -rf ./conftest*
3179
3180 AC_SUBST(EXTRA_CFLAGS)
3181 ])dnl
3182 dnl ---------------------------------------------------------------------------
3183 dnl CF_GETOPT_HEADER version: 8 updated: 2021/06/19 19:16:16
3184 dnl ----------------
3185 dnl Check for getopt's variables which are commonly defined in stdlib.h,
3186 dnl unistd.h or (nonstandard) in getopt.h
3187 AC_DEFUN([CF_GETOPT_HEADER],
3188 [
3189 AC_HAVE_HEADERS(unistd.h getopt.h)
3190 AC_CACHE_CHECK(for header declaring getopt variables,cf_cv_getopt_header,[
3191 cf_cv_getopt_header=none
3192 for cf_header in stdio.h stdlib.h unistd.h getopt.h
3193 do
3194 AC_TRY_COMPILE([
3195 #include <$cf_header>],
3196 [int x = optind; char *y = optarg; (void)x; (void)y],
3197 [cf_cv_getopt_header=$cf_header
3198  break])
3199 done
3200 ])
3201 if test "$cf_cv_getopt_header" != none ; then
3202         AC_DEFINE(HAVE_GETOPT_HEADER,1,[Define to 1 if getopt variables are declared in header])
3203 fi
3204 if test "$cf_cv_getopt_header" = getopt.h ; then
3205         AC_DEFINE(NEED_GETOPT_H,1,[Define to 1 if we must include getopt.h])
3206 fi
3207 ])dnl
3208 dnl ---------------------------------------------------------------------------
3209 dnl CF_GNATPREP_OPT_T version: 1 updated: 2014/08/02 18:37:25
3210 dnl -----------------
3211 AC_DEFUN([CF_GNATPREP_OPT_T],[
3212 AC_CACHE_CHECK(if GNATPREP supports -T option,cf_cv_gnatprep_opt_t,[
3213 cf_cv_gnatprep_opt_t=no
3214 gnatprep -T 2>/dev/null >/dev/null && cf_cv_gnatprep_opt_t=yes
3215 ])
3216 test "$cf_cv_gnatprep_opt_t" = yes && GNATPREP_OPTS="-T $GNATPREP_OPTS"
3217 AC_SUBST(GNATPREP_OPTS)
3218 ])dnl
3219 dnl ---------------------------------------------------------------------------
3220 dnl CF_GNAT_GENERICS version: 7 updated: 2021/01/01 13:31:04
3221 dnl ----------------
3222 AC_DEFUN([CF_GNAT_GENERICS],
3223 [
3224 AC_REQUIRE([CF_GNAT_VERSION])
3225
3226 AC_MSG_CHECKING(if GNAT supports generics)
3227 case "$cf_cv_gnat_version" in
3228 (3.1[[1-9]]*|3.[[2-9]]*|[[4-9]].*|[[1-9]][[0-9]].[[0-9]]*|20[[0-9]][[0-9]])
3229         cf_gnat_generics=yes
3230         ;;
3231 (*)
3232         cf_gnat_generics=no
3233         ;;
3234 esac
3235 AC_MSG_RESULT($cf_gnat_generics)
3236
3237 if test "$cf_gnat_generics" = yes
3238 then
3239         cf_compile_generics=generics
3240         cf_generic_objects="\${GENOBJS}"
3241 else
3242         cf_compile_generics=
3243         cf_generic_objects=
3244 fi
3245
3246 AC_SUBST(cf_compile_generics)
3247 AC_SUBST(cf_generic_objects)
3248 ])dnl
3249 dnl ---------------------------------------------------------------------------
3250 dnl CF_GNAT_PROJECTS version: 13 updated: 2021/01/02 17:09:14
3251 dnl ----------------
3252 dnl GNAT projects are configured with ".gpr" project files.
3253 dnl GNAT libraries are a further development, using the project feature.
3254 AC_DEFUN([CF_GNAT_PROJECTS],
3255 [
3256 AC_REQUIRE([CF_GNAT_VERSION])
3257 AC_REQUIRE([CF_DISABLE_GNAT_PROJECTS])
3258
3259 cf_gnat_libraries=no
3260 cf_gnat_projects=no
3261
3262 if test "$enable_gnat_projects" != no ; then
3263 AC_MSG_CHECKING(if GNAT supports project files)
3264 case "$cf_cv_gnat_version" in
3265 (3.[[0-9]]*)
3266         ;;
3267 (*)
3268         case "$cf_cv_system_name" in
3269         (cygwin*|msys*)
3270                 ;;
3271         (*)
3272                 rm -rf ./conftest* ./*~conftest*
3273                 if mkdir conftest.src conftest.bin conftest.lib
3274                 then
3275                         cd conftest.src
3276                         rm -rf ./conftest* ./*~conftest*
3277                         cat >>library.gpr <<CF_EOF
3278 project Library is
3279   Kind := External ("LIB_KIND");
3280   for Library_Name use "ConfTest";
3281   for Object_Dir use ".";
3282   for Library_ALI_Dir use External("LIBRARY_DIR");
3283   for Library_Version use External ("SONAME");
3284   for Library_Kind use Kind;
3285   for Library_Dir use External("BUILD_DIR");
3286   Source_Dir := External ("SOURCE_DIR");
3287   for Source_Dirs use (Source_Dir);
3288 end Library;
3289 CF_EOF
3290                         cat >>confpackage.ads <<CF_EOF
3291 package ConfPackage is
3292    procedure conftest;
3293 end ConfPackage;
3294 CF_EOF
3295                         cat >>confpackage.adb <<CF_EOF
3296 with Text_IO;
3297 package body ConfPackage is
3298    procedure conftest is
3299    begin
3300       Text_IO.Put ("Hello World");
3301       Text_IO.New_Line;
3302    end conftest;
3303 end ConfPackage;
3304 CF_EOF
3305                         if ( "$cf_ada_make" $ADAFLAGS \
3306                                         -Plibrary.gpr \
3307                                         -XBUILD_DIR="`cd ../conftest.bin;pwd`" \
3308                                         -XLIBRARY_DIR="`cd ../conftest.lib;pwd`" \
3309                                         -XSOURCE_DIR="`pwd`" \
3310                                         -XSONAME=libConfTest.so.1 \
3311                                         -XLIB_KIND=static 1>&AC_FD_CC 2>&1 ) ; then
3312                                 cf_gnat_projects=yes
3313                         fi
3314                         cd ..
3315                 fi
3316                 if test -f conftest.lib/confpackage.ali
3317                 then
3318                         cf_gnat_libraries=yes
3319                 fi
3320                 rm -rf ./conftest* ./*~conftest*
3321                 ;;
3322         esac
3323         ;;
3324 esac
3325 AC_MSG_RESULT($cf_gnat_projects)
3326 fi # enable_gnat_projects
3327
3328 if test "$cf_gnat_projects" = yes
3329 then
3330         AC_MSG_CHECKING(if GNAT supports libraries)
3331         AC_MSG_RESULT($cf_gnat_libraries)
3332 fi
3333
3334 USE_OLD_MAKERULES=""
3335 USE_GNAT_PROJECTS="#"
3336 USE_GNAT_MAKE_GPR="#"
3337 USE_GNAT_GPRBUILD="#"
3338
3339 if test "$cf_gnat_projects" = yes
3340 then
3341         USE_OLD_MAKERULES="#"
3342         USE_GNAT_PROJECTS=""
3343         if test "$cf_cv_VERSION_GPRBUILD" != no
3344         then
3345                 USE_GNAT_GPRBUILD=""
3346         elif test "$cf_cv_VERSION_GNATMAKE" != no
3347         then
3348                 USE_GNAT_MAKE_GPR=""
3349         else
3350                 AC_MSG_WARN(use old makefile rules since tools are missing)
3351         fi
3352 fi
3353
3354 if test "$cf_gnat_libraries" = yes
3355 then
3356         USE_GNAT_LIBRARIES=""
3357 else
3358         USE_GNAT_LIBRARIES="#"
3359 fi
3360
3361 AC_SUBST(USE_OLD_MAKERULES)
3362 AC_SUBST(USE_GNAT_PROJECTS)
3363 AC_SUBST(USE_GNAT_LIBRARIES)
3364 AC_SUBST(USE_GNAT_MAKE_GPR)
3365 AC_SUBST(USE_GNAT_GPRBUILD)
3366 ])dnl
3367 dnl ---------------------------------------------------------------------------
3368 dnl CF_GNAT_SIGINT version: 2 updated: 2021/01/01 13:31:04
3369 dnl --------------
3370 dnl Check if gnat supports SIGINT, and presumably tasking.  For the latter, it
3371 dnl is noted that gnat may compile a tasking unit even for configurations which
3372 dnl fail at runtime.
3373 AC_DEFUN([CF_GNAT_SIGINT],[
3374 AC_CACHE_CHECK(if GNAT supports SIGINT,cf_cv_gnat_sigint,[
3375 CF_GNAT_TRY_LINK([with Ada.Interrupts.Names;
3376
3377 package ConfTest is
3378
3379    pragma Warnings (Off);  --  the next pragma exists since 3.11p
3380    pragma Unreserve_All_Interrupts;
3381    pragma Warnings (On);
3382
3383    protected Process is
3384       procedure Stop;
3385       function Continue return Boolean;
3386       pragma Attach_Handler (Stop, Ada.Interrupts.Names.SIGINT);
3387    private
3388       Done : Boolean := False;
3389    end Process;
3390
3391 end ConfTest;],
3392 [package body ConfTest is
3393    protected body Process is
3394       procedure Stop is
3395       begin
3396          Done := True;
3397       end Stop;
3398       function Continue return Boolean is
3399       begin
3400          return not Done;
3401       end Continue;
3402    end Process;
3403 end ConfTest;],
3404         [cf_cv_gnat_sigint=yes],
3405         [cf_cv_gnat_sigint=no])])
3406
3407 if test "$cf_cv_gnat_sigint" = yes ; then
3408         USE_GNAT_SIGINT=""
3409 else
3410         USE_GNAT_SIGINT="#"
3411 fi
3412 AC_SUBST(USE_GNAT_SIGINT)
3413 ])dnl
3414 dnl ---------------------------------------------------------------------------
3415 dnl CF_GNAT_TRY_LINK version: 4 updated: 2021/01/01 13:31:04
3416 dnl ----------------
3417 dnl Verify that a test program compiles/links with GNAT.
3418 dnl $cf_ada_make is set to the program that compiles/links
3419 dnl $ADAFLAGS may be set to the GNAT flags.
3420 dnl
3421 dnl $1 is the text of the spec
3422 dnl $2 is the text of the body
3423 dnl $3 is the shell command to execute if successful
3424 dnl $4 is the shell command to execute if not successful
3425 AC_DEFUN([CF_GNAT_TRY_LINK],
3426 [
3427 rm -rf ./conftest* ./*~conftest*
3428 cat >>conftest.ads <<CF_EOF
3429 $1
3430 CF_EOF
3431 cat >>conftest.adb <<CF_EOF
3432 $2
3433 CF_EOF
3434 if ( "$cf_ada_make" $ADAFLAGS conftest 1>&AC_FD_CC 2>&1 ) ; then
3435 ifelse($3,,      :,[      $3])
3436 ifelse($4,,,[else
3437    $4])
3438 fi
3439 rm -rf ./conftest* ./*~conftest*
3440 ])dnl
3441 dnl ---------------------------------------------------------------------------
3442 dnl CF_GNAT_TRY_RUN version: 6 updated: 2021/01/01 13:31:04
3443 dnl ---------------
3444 dnl Verify that a test program compiles and runs with GNAT
3445 dnl $cf_ada_make is set to the program that compiles/links
3446 dnl $ADAFLAGS may be set to the GNAT flags.
3447 dnl
3448 dnl $1 is the text of the spec
3449 dnl $2 is the text of the body
3450 dnl $3 is the shell command to execute if successful
3451 dnl $4 is the shell command to execute if not successful
3452 AC_DEFUN([CF_GNAT_TRY_RUN],
3453 [
3454 rm -rf ./conftest* ./*~conftest*
3455 cat >>conftest.ads <<CF_EOF
3456 $1
3457 CF_EOF
3458 cat >>conftest.adb <<CF_EOF
3459 $2
3460 CF_EOF
3461 if ( "$cf_ada_make" $ADAFLAGS conftest 1>&AC_FD_CC 2>&1 ) ; then
3462    if ( ./conftest 1>&AC_FD_CC 2>&1 ) ; then
3463 ifelse($3,,      :,[      $3])
3464 ifelse($4,,,[   else
3465       $4])
3466    fi
3467 ifelse($4,,,[else
3468    $4])
3469 fi
3470 rm -rf ./conftest* ./*~conftest*
3471 ])dnl
3472 dnl ---------------------------------------------------------------------------
3473 dnl CF_GNAT_VERSION version: 22 updated: 2019/12/31 08:53:54
3474 dnl ---------------
3475 dnl $1 = cache variable to update
3476 dnl $2 = program name
3477 dnl Verify version of GNAT or related tool
3478 AC_DEFUN([CF_GNAT_VERSION],
3479 [
3480 AC_CACHE_CHECK(for ifelse($2,,gnat,$2) version, cf_cv_gnat_version,[
3481 cf_cv_gnat_version=`ifelse($2,,${cf_ada_make:-gnatmake},$2) --version 2>&1 | \
3482         grep '[[0-9]].[[0-9]][[0-9]]*' |\
3483         sed -e '2,$d' -e 's/[[^0-9 \.]]//g' -e 's/^[[ ]]*//' -e 's/ .*//'`
3484 ])
3485 test -z "$cf_cv_gnat_version" && cf_cv_gnat_version=no
3486 ifelse($1,,,[eval $1=$cf_cv_gnat_version; unset cf_cv_gnat_version])
3487 ])dnl
3488 dnl ---------------------------------------------------------------------------
3489 dnl CF_GNU_SOURCE version: 10 updated: 2018/12/10 20:09:41
3490 dnl -------------
3491 dnl Check if we must define _GNU_SOURCE to get a reasonable value for
3492 dnl _XOPEN_SOURCE, upon which many POSIX definitions depend.  This is a defect
3493 dnl (or misfeature) of glibc2, which breaks portability of many applications,
3494 dnl since it is interwoven with GNU extensions.
3495 dnl
3496 dnl Well, yes we could work around it...
3497 dnl
3498 dnl Parameters:
3499 dnl     $1 is the nominal value for _XOPEN_SOURCE
3500 AC_DEFUN([CF_GNU_SOURCE],
3501 [
3502 cf_gnu_xopen_source=ifelse($1,,500,$1)
3503
3504 AC_CACHE_CHECK(if this is the GNU C library,cf_cv_gnu_library,[
3505 AC_TRY_COMPILE([#include <sys/types.h>],[
3506         #if __GLIBC__ > 0 && __GLIBC_MINOR__ >= 0
3507                 return 0;
3508         #elif __NEWLIB__ > 0 && __NEWLIB_MINOR__ >= 0
3509                 return 0;
3510         #else
3511         #       error not GNU C library
3512         #endif],
3513         [cf_cv_gnu_library=yes],
3514         [cf_cv_gnu_library=no])
3515 ])
3516
3517 if test x$cf_cv_gnu_library = xyes; then
3518
3519         # With glibc 2.19 (13 years after this check was begun), _DEFAULT_SOURCE
3520         # was changed to help a little.  newlib incorporated the change about 4
3521         # years later.
3522         AC_CACHE_CHECK(if _DEFAULT_SOURCE can be used as a basis,cf_cv_gnu_library_219,[
3523                 cf_save="$CPPFLAGS"
3524                 CF_APPEND_TEXT(CPPFLAGS,-D_DEFAULT_SOURCE)
3525                 AC_TRY_COMPILE([#include <sys/types.h>],[
3526                         #if (__GLIBC__ == 2 && __GLIBC_MINOR__ >= 19) || (__GLIBC__ > 2)
3527                                 return 0;
3528                         #elif (__NEWLIB__ == 2 && __NEWLIB_MINOR__ >= 4) || (__GLIBC__ > 3)
3529                                 return 0;
3530                         #else
3531                         #       error GNU C library __GLIBC__.__GLIBC_MINOR__ is too old
3532                         #endif],
3533                         [cf_cv_gnu_library_219=yes],
3534                         [cf_cv_gnu_library_219=no])
3535                 CPPFLAGS="$cf_save"
3536         ])
3537
3538         if test "x$cf_cv_gnu_library_219" = xyes; then
3539                 cf_save="$CPPFLAGS"
3540                 AC_CACHE_CHECK(if _XOPEN_SOURCE=$cf_gnu_xopen_source works with _DEFAULT_SOURCE,cf_cv_gnu_dftsrc_219,[
3541                         CF_ADD_CFLAGS(-D_DEFAULT_SOURCE -D_XOPEN_SOURCE=$cf_gnu_xopen_source)
3542                         AC_TRY_COMPILE([
3543                                 #include <limits.h>
3544                                 #include <sys/types.h>
3545                                 ],[
3546                                 #if (_XOPEN_SOURCE >= $cf_gnu_xopen_source) && (MB_LEN_MAX > 1)
3547                                         return 0;
3548                                 #else
3549                                 #       error GNU C library is too old
3550                                 #endif],
3551                                 [cf_cv_gnu_dftsrc_219=yes],
3552                                 [cf_cv_gnu_dftsrc_219=no])
3553                         ])
3554                 test "x$cf_cv_gnu_dftsrc_219" = "xyes" || CPPFLAGS="$cf_save"
3555         else
3556                 cf_cv_gnu_dftsrc_219=maybe
3557         fi
3558
3559         if test "x$cf_cv_gnu_dftsrc_219" != xyes; then
3560
3561                 AC_CACHE_CHECK(if we must define _GNU_SOURCE,cf_cv_gnu_source,[
3562                 AC_TRY_COMPILE([#include <sys/types.h>],[
3563                         #ifndef _XOPEN_SOURCE
3564                         #error  expected _XOPEN_SOURCE to be defined
3565                         #endif],
3566                         [cf_cv_gnu_source=no],
3567                         [cf_save="$CPPFLAGS"
3568                          CF_ADD_CFLAGS(-D_GNU_SOURCE)
3569                          AC_TRY_COMPILE([#include <sys/types.h>],[
3570                                 #ifdef _XOPEN_SOURCE
3571                                 #error  expected _XOPEN_SOURCE to be undefined
3572                                 #endif],
3573                                 [cf_cv_gnu_source=no],
3574                                 [cf_cv_gnu_source=yes])
3575                         CPPFLAGS="$cf_save"
3576                         ])
3577                 ])
3578
3579                 if test "$cf_cv_gnu_source" = yes
3580                 then
3581                 AC_CACHE_CHECK(if we should also define _DEFAULT_SOURCE,cf_cv_default_source,[
3582                         CF_APPEND_TEXT(CPPFLAGS,-D_GNU_SOURCE)
3583                         AC_TRY_COMPILE([#include <sys/types.h>],[
3584                                 #ifdef _DEFAULT_SOURCE
3585                                 #error  expected _DEFAULT_SOURCE to be undefined
3586                                 #endif],
3587                                 [cf_cv_default_source=no],
3588                                 [cf_cv_default_source=yes])
3589                         ])
3590                         if test "$cf_cv_default_source" = yes
3591                         then
3592                                 CF_APPEND_TEXT(CPPFLAGS,-D_DEFAULT_SOURCE)
3593                         fi
3594                 fi
3595         fi
3596
3597 fi
3598 ])dnl
3599 dnl ---------------------------------------------------------------------------
3600 dnl CF_GPP_LIBRARY version: 13 updated: 2021/01/01 13:31:04
3601 dnl --------------
3602 dnl If we're trying to use g++, test if libg++ is installed (a rather common
3603 dnl problem :-).  If we have the compiler but no library, we'll be able to
3604 dnl configure, but won't be able to build the c++ demo program.
3605 AC_DEFUN([CF_GPP_LIBRARY],
3606 [
3607 cf_cxx_library=unknown
3608 case "$cf_cv_system_name" in
3609 (os2*)
3610         cf_gpp_libname=gpp
3611         ;;
3612 (*)
3613         cf_gpp_libname=g++
3614         ;;
3615 esac
3616 if test "$GXX" = yes; then
3617         AC_MSG_CHECKING([for lib$cf_gpp_libname])
3618         cf_save="$LIBS"
3619         CF_ADD_LIB($cf_gpp_libname)
3620         AC_TRY_LINK([
3621 #include <$cf_gpp_libname/builtin.h>
3622         ],
3623         [two_arg_error_handler_t foo2 = lib_error_handler],
3624         [cf_cxx_library=yes
3625          CF_ADD_LIB($cf_gpp_libname,CXXLIBS)
3626          if test "$cf_gpp_libname" = cpp ; then
3627             AC_DEFINE(HAVE_GPP_BUILTIN_H,1,[Define to 1 if we have gpp builtin.h])
3628          else
3629             AC_DEFINE(HAVE_GXX_BUILTIN_H,1,[Define to 1 if we have g++ builtin.h])
3630          fi],
3631         [AC_TRY_LINK([
3632 #include <builtin.h>
3633         ],
3634         [two_arg_error_handler_t foo2 = lib_error_handler],
3635         [cf_cxx_library=yes
3636          CF_ADD_LIB($cf_gpp_libname,CXXLIBS)
3637          AC_DEFINE(HAVE_BUILTIN_H,1,[Define to 1 if we have builtin.h])],
3638         [cf_cxx_library=no])])
3639         LIBS="$cf_save"
3640         AC_MSG_RESULT($cf_cxx_library)
3641 fi
3642 ])dnl
3643 dnl ---------------------------------------------------------------------------
3644 dnl CF_GXX_VERSION version: 9 updated: 2023/03/05 14:30:13
3645 dnl --------------
3646 dnl Check for version of g++
3647 AC_DEFUN([CF_GXX_VERSION],[
3648 AC_REQUIRE([AC_PROG_CPP])
3649 GXX_VERSION=none
3650 if test "$GXX" = yes; then
3651         AC_MSG_CHECKING(version of ${CXX:-g++})
3652         GXX_VERSION="`${CXX:-g++} --version 2>/dev/null | sed -e '2,$d' -e 's/^[[^(]]*([[^)]][[^)]]*) //' -e 's/^[[^0-9.]]*//' -e 's/[[^0-9.]].*//'`"
3653         if test -z "$GXX_VERSION"
3654         then
3655                 GXX_VERSION=unknown
3656                 GXX=no
3657         fi
3658         AC_MSG_RESULT($GXX_VERSION)
3659 fi
3660 ])dnl
3661 dnl ---------------------------------------------------------------------------
3662 dnl CF_GXX_WARNINGS version: 11 updated: 2021/01/08 16:50:55
3663 dnl ---------------
3664 dnl Check if the compiler supports useful warning options.
3665 dnl
3666 dnl Most of gcc's options apply to g++, except:
3667 dnl     -Wbad-function-cast
3668 dnl     -Wmissing-declarations
3669 dnl     -Wnested-externs
3670 dnl
3671 dnl Omit a few (for now):
3672 dnl     -Winline
3673 dnl
3674 dnl Parameter:
3675 dnl     $1 is an optional list of g++ warning flags that a particular
3676 dnl             application might want to use, e.g., "no-unused" for
3677 dnl             -Wno-unused
3678 dnl Special:
3679 dnl     If $with_ext_const is "yes", add a check for -Wwrite-strings
3680 dnl
3681 AC_DEFUN([CF_GXX_WARNINGS],
3682 [
3683
3684 CF_INTEL_COMPILER(GXX,INTEL_CPLUSPLUS,CXXFLAGS)
3685 CF_CLANG_COMPILER(GXX,CLANG_CPLUSPLUS,CXXFLAGS)
3686
3687 AC_REQUIRE([CF_GXX_VERSION])
3688
3689 AC_LANG_SAVE
3690 AC_LANG_CPLUSPLUS
3691
3692 cat > conftest.$ac_ext <<EOF
3693 #line __oline__ "configure"
3694 int main(int argc, char *argv[[]]) { return (argv[[argc-1]] == 0) ; }
3695 EOF
3696
3697 if test "$INTEL_CPLUSPLUS" = yes
3698 then
3699 # The "-wdXXX" options suppress warnings:
3700 # remark #1419: external declaration in primary source file
3701 # remark #1682: implicit conversion of a 64-bit integral type to a smaller integral type (potential portability problem)
3702 # remark #1683: explicit conversion of a 64-bit integral type to a smaller integral type (potential portability problem)
3703 # remark #1684: conversion from pointer to same-sized integral type (potential portability problem)
3704 # remark #193: zero used for undefined preprocessing identifier
3705 # remark #593: variable "curs_sb_left_arrow" was set but never used
3706 # remark #810: conversion from "int" to "Dimension={unsigned short}" may lose significant bits
3707 # remark #869: parameter "tw" was never referenced
3708 # remark #981: operands are evaluated in unspecified order
3709 # warning #269: invalid format string conversion
3710
3711         AC_CHECKING([for $CC warning options])
3712         cf_save_CXXFLAGS="$CXXFLAGS"
3713         EXTRA_CXXFLAGS="-Wall"
3714         for cf_opt in \
3715                 wd1419 \
3716                 wd1682 \
3717                 wd1683 \
3718                 wd1684 \
3719                 wd193 \
3720                 wd279 \
3721                 wd593 \
3722                 wd810 \
3723                 wd869 \
3724                 wd981
3725         do
3726                 CXXFLAGS="$cf_save_CXXFLAGS $EXTRA_CXXFLAGS -$cf_opt"
3727                 if AC_TRY_EVAL(ac_compile); then
3728                         test -n "$verbose" && AC_MSG_RESULT(... -$cf_opt)
3729                         EXTRA_CXXFLAGS="$EXTRA_CXXFLAGS -$cf_opt"
3730                 fi
3731         done
3732         CXXFLAGS="$cf_save_CXXFLAGS"
3733
3734 elif test "$GXX" = yes
3735 then
3736         AC_CHECKING([for $CXX warning options])
3737         cf_save_CXXFLAGS="$CXXFLAGS"
3738         EXTRA_CXXFLAGS="-W -Wall"
3739         cf_gxx_extra_warnings=""
3740         test "$with_ext_const" = yes && cf_gxx_extra_warnings="Wwrite-strings"
3741         case "$GXX_VERSION" in
3742         ([[1-2]].*)
3743                 ;;
3744         (*)
3745                 cf_gxx_extra_warnings="$cf_gxx_extra_warnings Weffc++"
3746                 ;;
3747         esac
3748         for cf_opt in \
3749                 Wabi \
3750                 fabi-version=0 \
3751                 Wextra \
3752                 Wignored-qualifiers \
3753                 Wlogical-op \
3754                 Woverloaded-virtual \
3755                 Wsign-promo \
3756                 Wsynth \
3757                 Wold-style-cast \
3758                 Wcast-align \
3759                 Wcast-qual \
3760                 Wpointer-arith \
3761                 Wshadow \
3762                 Wundef $cf_gxx_extra_warnings $1
3763         do
3764                 CXXFLAGS="$cf_save_CXXFLAGS $EXTRA_CXXFLAGS -Werror -$cf_opt"
3765                 if AC_TRY_EVAL(ac_compile); then
3766                         test -n "$verbose" && AC_MSG_RESULT(... -$cf_opt)
3767                         EXTRA_CXXFLAGS="$EXTRA_CXXFLAGS -$cf_opt"
3768                 else
3769                         test -n "$verbose" && AC_MSG_RESULT(... no -$cf_opt)
3770                 fi
3771         done
3772         CXXFLAGS="$cf_save_CXXFLAGS"
3773 fi
3774
3775 rm -rf ./conftest*
3776 AC_LANG_RESTORE
3777 AC_SUBST(EXTRA_CXXFLAGS)
3778 ])dnl
3779 dnl ---------------------------------------------------------------------------
3780 dnl CF_HASHED_DB version: 7 updated: 2015/04/18 08:56:57
3781 dnl ------------
3782 dnl Look for an instance of the Berkeley hashed database.
3783 dnl
3784 dnl $1 = optional parameter, to specify install-prefix for the database.
3785 AC_DEFUN([CF_HASHED_DB],
3786 [
3787 ifelse([$1],,,[
3788 case $1 in
3789 (yes|*able*)
3790         ;;
3791 (*)
3792         if test -d "$1" ; then
3793                 CF_ADD_INCDIR($1/include)
3794                 CF_ADD_LIBDIR($1/lib)
3795         else
3796                 case "$1" in
3797                 (./*|../*|/*)
3798                         AC_MSG_WARN(no such directory $1)
3799                         ;;
3800                 (*)
3801                         CF_FIND_SUB_INCDIR($1)
3802                         CF_FIND_SUB_LIBDIR($1)
3803                         ;;
3804                 esac
3805         fi
3806 esac
3807 ])
3808 AC_CHECK_HEADER(db.h,[
3809 CF_HASHED_DB_VERSION
3810 if test "$cf_cv_hashed_db_version" = unknown ; then
3811         AC_MSG_ERROR(Cannot determine version of db)
3812 else
3813         CF_HASHED_DB_LIBS
3814         if test "$cf_cv_hashed_db_libs" = unknown ; then
3815                 AC_MSG_ERROR(Cannot determine library for db)
3816         elif test "$cf_cv_hashed_db_libs" != default ; then
3817                 CF_ADD_LIB($cf_cv_hashed_db_libs)
3818         fi
3819 fi
3820 ],[
3821         AC_MSG_ERROR(Cannot find db.h)
3822 ])
3823 ])dnl
3824 dnl ---------------------------------------------------------------------------
3825 dnl CF_HASHED_DB_LIBS version: 10 updated: 2021/01/02 17:09:14
3826 dnl -----------------
3827 dnl Given that we have the header and version for hashed database, find the
3828 dnl library information.
3829 AC_DEFUN([CF_HASHED_DB_LIBS],
3830 [
3831 AC_CACHE_CHECK(for db libraries, cf_cv_hashed_db_libs,[
3832 cf_cv_hashed_db_libs=unknown
3833 for cf_db_libs in "" db$cf_cv_hashed_db_version db-$cf_cv_hashed_db_version db ''
3834 do
3835         cf_save_libs="$LIBS"
3836         if test -n "$cf_db_libs"; then
3837                 CF_ADD_LIB($cf_db_libs)
3838         fi
3839         CF_MSG_LOG(checking for library $cf_db_libs)
3840         AC_TRY_LINK([
3841 $ac_includes_default
3842 #include <db.h>
3843 ],[
3844         char *path = "/tmp/foo";
3845 #ifdef DB_VERSION_MAJOR
3846 #if DB_VERSION_MAJOR >= 4
3847         DB *result = 0;
3848         db_create(&result, NULL, 0);
3849         result->open(result,
3850                 NULL,
3851                 path,
3852                 path,
3853                 DB_HASH,
3854                 DB_CREATE,
3855                 0644);
3856 #elif DB_VERSION_MAJOR >= 3
3857         DB *result = 0;
3858         db_create(&result, NULL, 0);
3859         result->open(result,
3860                 path,
3861                 path,
3862                 DB_HASH,
3863                 DB_CREATE,
3864                 0644);
3865 #elif DB_VERSION_MAJOR >= 2
3866         DB *result = 0;
3867         db_open(path,
3868                 DB_HASH,
3869                 DB_CREATE,
3870                 0644,
3871                 (DB_ENV *) 0,
3872                 (DB_INFO *) 0,
3873                 &result);
3874 #endif /* DB_VERSION_MAJOR */
3875 #else
3876         DB *result = dbopen(path,
3877                      2,
3878                      0644,
3879                      DB_HASH,
3880                      0);
3881 #endif
3882         ${cf_cv_main_return:-return}(result != 0)
3883 ],[
3884         if test -n "$cf_db_libs" ; then
3885                 cf_cv_hashed_db_libs=$cf_db_libs
3886         else
3887                 cf_cv_hashed_db_libs=default
3888         fi
3889         LIBS="$cf_save_libs"
3890         break
3891 ])
3892         LIBS="$cf_save_libs"
3893 done
3894 ])
3895 ])dnl
3896 dnl ---------------------------------------------------------------------------
3897 dnl CF_HASHED_DB_VERSION version: 5 updated: 2023/02/18 17:41:25
3898 dnl --------------------
3899 dnl Given that we have the header file for hashed database, find the version
3900 dnl information.
3901 AC_DEFUN([CF_HASHED_DB_VERSION],
3902 [
3903 AC_CACHE_CHECK(for version of db, cf_cv_hashed_db_version,[
3904 cf_cv_hashed_db_version=unknown
3905
3906 for cf_db_version in 1 2 3 4 5 6
3907 do
3908         CF_MSG_LOG(checking for db version $cf_db_version)
3909         AC_TRY_COMPILE([
3910 $ac_includes_default
3911 #include <db.h>
3912
3913 #ifdef DB_VERSION_MAJOR
3914         /* db2 (DB_VERSION_MAJOR=2) has also DB_VERSION_MINOR, tested with 7 */
3915 #if $cf_db_version == DB_VERSION_MAJOR
3916         /* ok */
3917 #else
3918         #error $cf_db_version is not DB_VERSION_MAJOR
3919 #endif
3920 #else
3921 #if $cf_db_version == 1
3922         /* ok: assuming this is DB 1.8.5 */
3923 #else
3924         #error $cf_db_version is not 1
3925 #endif
3926 #endif
3927 ],[DBT *foo = 0],[
3928         cf_cv_hashed_db_version=$cf_db_version
3929         break
3930         ])
3931 done
3932 ])
3933 ])dnl
3934 dnl ---------------------------------------------------------------------------
3935 dnl CF_HEADER_PATH version: 15 updated: 2021/01/01 13:31:04
3936 dnl --------------
3937 dnl Construct a search-list of directories for a nonstandard header-file
3938 dnl
3939 dnl Parameters
3940 dnl     $1 = the variable to return as result
3941 dnl     $2 = the package name
3942 AC_DEFUN([CF_HEADER_PATH],
3943 [
3944 $1=
3945
3946 # collect the current set of include-directories from compiler flags
3947 cf_header_path_list=""
3948 if test -n "${CFLAGS}${CPPFLAGS}" ; then
3949         for cf_header_path in $CPPFLAGS $CFLAGS
3950         do
3951                 case "$cf_header_path" in
3952                 (-I*)
3953                         cf_header_path=`echo ".$cf_header_path" |sed -e 's/^...//' -e 's,/include$,,'`
3954                         CF_ADD_SUBDIR_PATH($1,$2,include,$cf_header_path,NONE)
3955                         cf_header_path_list="$cf_header_path_list [$]$1"
3956                         ;;
3957                 esac
3958         done
3959 fi
3960
3961 # add the variations for the package we are looking for
3962 CF_SUBDIR_PATH($1,$2,include)
3963
3964 test "$includedir" != NONE && \
3965 test "$includedir" != "/usr/include" && \
3966 test -d "$includedir" && {
3967         test -d "$includedir" &&    $1="[$]$1 $includedir"
3968         test -d "$includedir/$2" && $1="[$]$1 $includedir/$2"
3969 }
3970
3971 test "$oldincludedir" != NONE && \
3972 test "$oldincludedir" != "/usr/include" && \
3973 test -d "$oldincludedir" && {
3974         test -d "$oldincludedir"    && $1="[$]$1 $oldincludedir"
3975         test -d "$oldincludedir/$2" && $1="[$]$1 $oldincludedir/$2"
3976 }
3977
3978 $1="[$]$1 $cf_header_path_list"
3979 ])dnl
3980 dnl ---------------------------------------------------------------------------
3981 dnl CF_HELP_MESSAGE version: 4 updated: 2019/12/31 08:53:54
3982 dnl ---------------
3983 dnl Insert text into the help-message, for readability, from AC_ARG_WITH.
3984 AC_DEFUN([CF_HELP_MESSAGE],
3985 [CF_ACVERSION_CHECK(2.53,[],[
3986 AC_DIVERT_HELP($1)])dnl
3987 ])dnl
3988 dnl ---------------------------------------------------------------------------
3989 dnl CF_INCLUDE_DIRS version: 10 updated: 2014/09/19 20:58:42
3990 dnl ---------------
3991 dnl Construct the list of include-options according to whether we're building
3992 dnl in the source directory or using '--srcdir=DIR' option.
3993 AC_DEFUN([CF_INCLUDE_DIRS],
3994 [
3995 if test "$srcdir" != "."; then
3996         CPPFLAGS="-I\${srcdir}/../include $CPPFLAGS"
3997 fi
3998 CPPFLAGS="-I../include $CPPFLAGS"
3999 if test "$srcdir" != "."; then
4000         CPPFLAGS="-I\${srcdir} $CPPFLAGS"
4001 fi
4002 CPPFLAGS="-I. $CPPFLAGS"
4003 AC_SUBST(CPPFLAGS)
4004 ])dnl
4005 dnl ---------------------------------------------------------------------------
4006 dnl CF_INSTALL_OPTS version: 2 updated: 2018/08/18 12:19:21
4007 dnl ---------------
4008 dnl prompt for/fill-in useful install-program options
4009 AC_DEFUN([CF_INSTALL_OPTS],
4010 [
4011 CF_INSTALL_OPT_S
4012 CF_INSTALL_OPT_P
4013 CF_INSTALL_OPT_O
4014 ])dnl
4015 dnl ---------------------------------------------------------------------------
4016 dnl CF_INSTALL_OPT_O version: 3 updated: 2020/12/31 20:19:42
4017 dnl ----------------
4018 dnl Almost all "install" programs default to the current user's ownership.
4019 dnl Almost - MINIX is an exception.
4020 AC_DEFUN([CF_INSTALL_OPT_O],
4021 [
4022 AC_MSG_CHECKING(if install needs to be told about ownership)
4023 case `$ac_config_guess` in
4024 (*minix)
4025         with_install_o=yes
4026         ;;
4027 (*)
4028         with_install_o=no
4029         ;;
4030 esac
4031
4032 AC_MSG_RESULT($with_install_o)
4033 if test "x$with_install_o" = xyes
4034 then
4035         INSTALL_OPT_O="`id root|sed -e 's/uid=[[0-9]]*(/ -o /' -e 's/gid=[[0-9]]*(/ -g /' -e 's/ [[^=[:space:]]][[^=[:space:]]]*=.*/ /' -e 's/)//g'`"
4036 else
4037         INSTALL_OPT_O=
4038 fi
4039
4040 AC_SUBST(INSTALL_OPT_O)
4041 ])dnl
4042 dnl ---------------------------------------------------------------------------
4043 dnl CF_INSTALL_OPT_P version: 3 updated: 2021/01/01 13:31:04
4044 dnl ----------------
4045 dnl Some install-programs accept a "-p" option to preserve file modification
4046 dnl timestamps.  That can be useful as an install option, as well as a way to
4047 dnl avoid the need for ranlib after copying a static archive.
4048 AC_DEFUN([CF_INSTALL_OPT_P],
4049 [
4050 : "${INSTALL:=install}"
4051 AC_CACHE_CHECK(if install accepts -p option, cf_cv_install_p,[
4052         rm -rf ./conftest*
4053         date >conftest.in
4054         mkdir conftest.out
4055         sleep 3
4056         if $INSTALL -p conftest.in conftest.out 2>/dev/null
4057         then
4058                 if test -f conftest.out/conftest.in
4059                 then
4060                         test conftest.in -nt conftest.out/conftest.in 2>conftest.err && \
4061                         test conftest.out/conftest.in -nt conftest.in 2>conftest.err
4062                         if test -s conftest.err
4063                         then
4064                                 cf_cv_install_p=no
4065                         else
4066                                 cf_cv_install_p=yes
4067                         fi
4068                 else
4069                         cf_cv_install_p=no
4070                 fi
4071         else
4072                 cf_cv_install_p=no
4073         fi
4074         rm -rf ./conftest*
4075 ])
4076 ])dnl
4077 dnl ---------------------------------------------------------------------------
4078 dnl CF_INSTALL_OPT_S version: 3 updated: 2021/01/05 19:23:48
4079 dnl ----------------
4080 dnl By default, we should strip executables which are installed, but leave the
4081 dnl ability to suppress that for unit-testing.
4082 AC_DEFUN([CF_INSTALL_OPT_S],
4083 [
4084 AC_MSG_CHECKING(if you want to install stripped executables)
4085 CF_ARG_DISABLE(stripping,
4086         [  --disable-stripping     do not strip (debug info) installed executables],
4087         [enable_stripping=no],
4088         [enable_stripping=yes])
4089 AC_MSG_RESULT($enable_stripping)
4090
4091 if test "$enable_stripping" = yes
4092 then
4093         INSTALL_OPT_S="-s"
4094 else
4095         INSTALL_OPT_S=
4096 fi
4097 AC_SUBST(INSTALL_OPT_S)
4098 ])dnl
4099 dnl ---------------------------------------------------------------------------
4100 dnl CF_INTEL_COMPILER version: 9 updated: 2023/02/18 17:41:25
4101 dnl -----------------
4102 dnl Check if the given compiler is really the Intel compiler for Linux.  It
4103 dnl tries to imitate gcc, but does not return an error when it finds a mismatch
4104 dnl between prototypes, e.g., as exercised by CF_MISSING_CHECK.
4105 dnl
4106 dnl This macro should be run "soon" after AC_PROG_CC or AC_PROG_CPLUSPLUS, to
4107 dnl ensure that it is not mistaken for gcc/g++.  It is normally invoked from
4108 dnl the wrappers for gcc and g++ warnings.
4109 dnl
4110 dnl $1 = GCC (default) or GXX
4111 dnl $2 = INTEL_COMPILER (default) or INTEL_CPLUSPLUS
4112 dnl $3 = CFLAGS (default) or CXXFLAGS
4113 AC_DEFUN([CF_INTEL_COMPILER],[
4114 AC_REQUIRE([AC_CANONICAL_HOST])
4115 ifelse([$2],,INTEL_COMPILER,[$2])=no
4116
4117 if test "$ifelse([$1],,[$1],GCC)" = yes ; then
4118         case "$host_os" in
4119         (linux*|gnu*)
4120                 AC_MSG_CHECKING(if this is really Intel ifelse([$1],GXX,C++,C) compiler)
4121                 cf_save_CFLAGS="$ifelse([$3],,CFLAGS,[$3])"
4122                 ifelse([$3],,CFLAGS,[$3])="$ifelse([$3],,CFLAGS,[$3]) -no-gcc"
4123                 AC_TRY_COMPILE([],[
4124 #ifdef __INTEL_COMPILER
4125 #else
4126 #error __INTEL_COMPILER is not defined
4127 #endif
4128 ],[ifelse([$2],,INTEL_COMPILER,[$2])=yes
4129 cf_save_CFLAGS="$cf_save_CFLAGS -we147"
4130 ],[])
4131                 ifelse([$3],,CFLAGS,[$3])="$cf_save_CFLAGS"
4132                 AC_MSG_RESULT($ifelse([$2],,INTEL_COMPILER,[$2]))
4133                 ;;
4134         esac
4135 fi
4136 ])dnl
4137 dnl ---------------------------------------------------------------------------
4138 dnl CF_ISASCII version: 4 updated: 2012/10/06 17:56:13
4139 dnl ----------
4140 dnl Check if we have either a function or macro for 'isascii()'.
4141 AC_DEFUN([CF_ISASCII],
4142 [
4143 AC_MSG_CHECKING(for isascii)
4144 AC_CACHE_VAL(cf_cv_have_isascii,[
4145         AC_TRY_LINK([#include <ctype.h>],[int x = isascii(' ')],
4146         [cf_cv_have_isascii=yes],
4147         [cf_cv_have_isascii=no])
4148 ])dnl
4149 AC_MSG_RESULT($cf_cv_have_isascii)
4150 test "$cf_cv_have_isascii" = yes && AC_DEFINE(HAVE_ISASCII,1,[Define to 1 if we have isascii()])
4151 ])dnl
4152 dnl ---------------------------------------------------------------------------
4153 dnl CF_LARGEFILE version: 12 updated: 2020/03/19 20:23:48
4154 dnl ------------
4155 dnl Add checks for large file support.
4156 AC_DEFUN([CF_LARGEFILE],[
4157 ifdef([AC_FUNC_FSEEKO],[
4158         AC_SYS_LARGEFILE
4159         if test "$enable_largefile" != no ; then
4160         AC_FUNC_FSEEKO
4161
4162         # Normally we would collect these definitions in the config.h,
4163         # but (like _XOPEN_SOURCE), some environments rely on having these
4164         # defined before any of the system headers are included.  Another
4165         # case comes up with C++, e.g., on AIX the compiler compiles the
4166         # header files by themselves before looking at the body files it is
4167         # told to compile.  For ncurses, those header files do not include
4168         # the config.h
4169         if test "$ac_cv_sys_large_files" != no
4170         then
4171                 CF_APPEND_TEXT(CPPFLAGS,-D_LARGE_FILES)
4172         fi
4173         if test "$ac_cv_sys_largefile_source" != no
4174         then
4175                 CF_APPEND_TEXT(CPPFLAGS,-D_LARGEFILE_SOURCE)
4176         fi
4177         if test "$ac_cv_sys_file_offset_bits" != no
4178         then
4179                 CF_APPEND_TEXT(CPPFLAGS,-D_FILE_OFFSET_BITS=$ac_cv_sys_file_offset_bits)
4180         fi
4181
4182         AC_CACHE_CHECK(whether to use struct dirent64, cf_cv_struct_dirent64,[
4183                 AC_TRY_COMPILE([
4184 #pragma GCC diagnostic error "-Wincompatible-pointer-types"
4185 #include <sys/types.h>
4186 #include <dirent.h>
4187                 ],[
4188                 /* if transitional largefile support is setup, this is true */
4189                 extern struct dirent64 * readdir(DIR *);
4190                 struct dirent64 *x = readdir((DIR *)0);
4191                 struct dirent *y = readdir((DIR *)0);
4192                 int z = x - y;
4193                 (void)z;
4194                 ],
4195                 [cf_cv_struct_dirent64=yes],
4196                 [cf_cv_struct_dirent64=no])
4197         ])
4198         test "$cf_cv_struct_dirent64" = yes && AC_DEFINE(HAVE_STRUCT_DIRENT64,1,[Define to 1 if we have struct dirent64])
4199         fi
4200 ])
4201 ])
4202 dnl ---------------------------------------------------------------------------
4203 dnl CF_LDFLAGS_STATIC version: 14 updated: 2021/01/02 17:09:14
4204 dnl -----------------
4205 dnl Check for compiler/linker flags used to temporarily force usage of static
4206 dnl libraries.  This depends on the compiler and platform.  Use this to help
4207 dnl ensure that the linker picks up a given library based on its position in
4208 dnl the list of linker options and libraries.
4209 AC_DEFUN([CF_LDFLAGS_STATIC],[
4210
4211 if test "$GCC" = yes ; then
4212         case "$cf_cv_system_name" in
4213         (OS/2*|os2*|aix[[4]]*|solaris2.1[[0-9]]|darwin*)
4214                 LDFLAGS_STATIC=
4215                 LDFLAGS_SHARED=
4216                 ;;
4217         (*)     # normally, except when broken
4218                 LDFLAGS_STATIC=-static
4219                 LDFLAGS_SHARED=-dynamic
4220                 ;;
4221         esac
4222 else
4223         case "$cf_cv_system_name" in
4224         (aix[[4-7]]*)   # from ld manpage
4225                 LDFLAGS_STATIC=-bstatic
4226                 LDFLAGS_SHARED=-bdynamic
4227                 ;;
4228         (hpux*)         # from ld manpage for hpux10.20, hpux11.11
4229                 # We could also use just "archive" and "shared".
4230                 LDFLAGS_STATIC=-Wl,-a,archive_shared
4231                 LDFLAGS_SHARED=-Wl,-a,shared_archive
4232                 ;;
4233         (irix*)         # from ld manpage IRIX64
4234                 LDFLAGS_STATIC=-Bstatic
4235                 LDFLAGS_SHARED=-Bdynamic
4236                 ;;
4237         (osf[[45]]*)    # from ld manpage osf4.0d, osf5.1
4238                 # alternative "-oldstyle_liblookup" (not in cc manpage)
4239                 LDFLAGS_STATIC=-noso
4240                 LDFLAGS_SHARED=-so_archive
4241                 ;;
4242         (solaris2*)
4243                 LDFLAGS_STATIC=-Bstatic
4244                 LDFLAGS_SHARED=-Bdynamic
4245                 ;;
4246         esac
4247 fi
4248
4249 if test -n "$LDFLAGS_STATIC" && test -n "$LDFLAGS_SHARED"
4250 then
4251         AC_MSG_CHECKING(if linker supports switching between static/dynamic)
4252
4253         rm -f libconftest.a
4254         cat >conftest.$ac_ext <<EOF
4255 #line __oline__ "configure"
4256 #include <stdio.h>
4257 int cf_ldflags_static(FILE *fp) { return fflush(fp); }
4258 EOF
4259         if AC_TRY_EVAL(ac_compile) ; then
4260                 ( $AR $ARFLAGS libconftest.a conftest.o ) 2>&AC_FD_CC 1>/dev/null
4261                 ( eval $RANLIB libconftest.a ) 2>&AC_FD_CC >/dev/null
4262         fi
4263         rm -f conftest.*
4264
4265         cf_save_LIBS="$LIBS"
4266
4267         LIBS="$LDFLAGS_STATIC -L`pwd` -lconftest $LDFLAGS_DYNAMIC $LIBS"
4268         AC_TRY_LINK([
4269 #line __oline__ "configure"
4270 #include <stdio.h>
4271 int cf_ldflags_static(FILE *fp);
4272 ],[
4273         return cf_ldflags_static(stdin);
4274 ],[
4275         # some linkers simply ignore the -dynamic
4276         case x`file "conftest$ac_exeext" 2>/dev/null` in
4277         (*static*)
4278                 cf_ldflags_static=no
4279                 ;;
4280         (*)
4281                 cf_ldflags_static=yes
4282                 ;;
4283         esac
4284 ],[cf_ldflags_static=no])
4285
4286         rm -f libconftest.*
4287         LIBS="$cf_save_LIBS"
4288
4289         AC_MSG_RESULT($cf_ldflags_static)
4290
4291         if test "$cf_ldflags_static" != yes
4292         then
4293                 LDFLAGS_STATIC=
4294                 LDFLAGS_SHARED=
4295         fi
4296 else
4297         LDFLAGS_STATIC=
4298         LDFLAGS_SHARED=
4299 fi
4300
4301 AC_SUBST(LDFLAGS_STATIC)
4302 AC_SUBST(LDFLAGS_SHARED)
4303 ])
4304 dnl ---------------------------------------------------------------------------
4305 dnl CF_LD_RPATH_OPT version: 9 updated: 2021/01/01 13:31:04
4306 dnl ---------------
4307 dnl For the given system and compiler, find the compiler flags to pass to the
4308 dnl loader to use the "rpath" feature.
4309 AC_DEFUN([CF_LD_RPATH_OPT],
4310 [
4311 AC_REQUIRE([CF_CHECK_CACHE])
4312
4313 LD_RPATH_OPT=
4314 if test "x$cf_cv_enable_rpath" != xno
4315 then
4316         AC_MSG_CHECKING(for an rpath option)
4317         case "$cf_cv_system_name" in
4318         (irix*)
4319                 if test "$GCC" = yes; then
4320                         LD_RPATH_OPT="-Wl,-rpath,"
4321                 else
4322                         LD_RPATH_OPT="-rpath "
4323                 fi
4324                 ;;
4325         (linux*|gnu*|k*bsd*-gnu|freebsd*)
4326                 LD_RPATH_OPT="-Wl,-rpath,"
4327                 ;;
4328         (openbsd[[2-9]].*|mirbsd*)
4329                 LD_RPATH_OPT="-Wl,-rpath,"
4330                 ;;
4331         (dragonfly*)
4332                 LD_RPATH_OPT="-rpath "
4333                 ;;
4334         (netbsd*)
4335                 LD_RPATH_OPT="-Wl,-rpath,"
4336                 ;;
4337         (osf*|mls+*)
4338                 LD_RPATH_OPT="-rpath "
4339                 ;;
4340         (solaris2*)
4341                 LD_RPATH_OPT="-R"
4342                 ;;
4343         (*)
4344                 ;;
4345         esac
4346         AC_MSG_RESULT($LD_RPATH_OPT)
4347
4348         case "x$LD_RPATH_OPT" in
4349         (x-R*)
4350                 AC_MSG_CHECKING(if we need a space after rpath option)
4351                 cf_save_LIBS="$LIBS"
4352                 CF_ADD_LIBS(${LD_RPATH_OPT}$libdir)
4353                 AC_TRY_LINK(, , cf_rpath_space=no, cf_rpath_space=yes)
4354                 LIBS="$cf_save_LIBS"
4355                 AC_MSG_RESULT($cf_rpath_space)
4356                 test "$cf_rpath_space" = yes && LD_RPATH_OPT="$LD_RPATH_OPT "
4357                 ;;
4358         esac
4359 fi
4360 ])dnl
4361 dnl ---------------------------------------------------------------------------
4362 dnl CF_LD_SEARCHPATH version: 4 updated: 2022/08/27 15:43:08
4363 dnl ----------------
4364 dnl Try to obtain the linker's search-path, for use in scripts.
4365 dnl
4366 dnl Ignore LD_LIBRARY_PATH, etc.
4367 AC_DEFUN([CF_LD_SEARCHPATH],[
4368 AC_CACHE_CHECK(for linker search path,cf_cv_ld_searchpath,[
4369
4370 if test "$cross_compiling" != yes ; then
4371
4372 # GNU binutils' ld does not involve permissions which may stop ldconfig.
4373 cf_pathlist=`${LD:-ld} --verbose 2>/dev/null | grep SEARCH_DIR | sed -e 's,SEARCH_DIR[[("=]][[("=]]*,,g' -e 's/"[[)]];//gp' | sort -u`
4374
4375 # The -NX options tell newer versions of Linux ldconfig to not attempt to
4376 # update the cache, which makes it run faster.
4377 test -z "$cf_pathlist" && \
4378         cf_pathlist=`(ldconfig -NX -v) 2>/dev/null | sed -e '/^[[       ]]/d' -e 's/:$//' | sort -u`
4379
4380 test -z "$cf_pathlist" &&
4381         cf_pathlist=`(ldconfig -v) 2>/dev/null | sed -n -e '/^[[        ]]/d' -e 's/:$//p' | sort -u`
4382
4383 # This works with OpenBSD 6.5, which lists only filenames
4384 test -z "$cf_pathlist" &&
4385         cf_pathlist=`(ldconfig -v) 2>/dev/null | sed -n -e 's,^Adding \(.*\)/.*[$],\1,p' | sort -u`
4386
4387 if test -z "$cf_pathlist"
4388 then
4389         # dyld default path with MacOS
4390         if test -f /usr/bin/otool && test "x`uname -s`" = xDarwin
4391         then
4392                 # do this to bypass check
4393                 cf_cv_ld_searchpath='$HOME/lib'
4394                 cf_pathlist="/usr/local/lib /lib /usr/lib"
4395         fi
4396 fi
4397
4398 if test -z "$cf_pathlist"
4399 then
4400         # Solaris is "SunOS"
4401         if test -f /usr/bin/isainfo && test "x`uname -s`" = xSunOS
4402         then
4403                 case x`(isainfo -b)` in
4404                 (x64)
4405                         cf_pathlist="$cf_pathlist /lib/64 /usr/lib/64"
4406                         ;;
4407                 (x32)
4408                         test -d /usr/ccs/lib && cf_pathlist="$cf_pathlist /usr/ccs/lib"
4409                         cf_pathlist="$cf_pathlist /lib /usr/lib"
4410                         ;;
4411                 (*)
4412                         AC_MSG_WARN(problem with Solaris architecture)
4413                         ;;
4414                 esac
4415         fi
4416 fi
4417
4418 if test -z "$cf_pathlist"
4419 then
4420         # HP-UX
4421         if test x"`uname -s`" = xHP-UX
4422         then
4423                 case x`getconf LONG_BIT` in
4424                 (x64)
4425                         cf_pathlist="/usr/lib/hpux64"
4426                         ;;
4427                 (x*)
4428                         cf_pathlist="/usr/lib/hpux32"
4429                         ;;
4430                 esac
4431         fi
4432 fi
4433
4434 fi
4435
4436 # If nothing else, assume it is conventional
4437 test -z "$cf_pathlist" && cf_pathlist="/usr/lib /lib"
4438
4439 # Finally, check that this is only directories
4440 for cf_path in [$]0 $cf_pathlist
4441 do
4442         if test -d "$cf_path"; then
4443                 test -n "$cf_cv_ld_searchpath" && cf_cv_ld_searchpath="${cf_cv_ld_searchpath} "
4444                 cf_cv_ld_searchpath="${cf_cv_ld_searchpath}${cf_path}"
4445         fi
4446 done
4447
4448 # Ensure that it is nonempty
4449 test -z "$cf_cv_ld_searchpath" && cf_cv_ld_searchpath=/usr/lib
4450 ])
4451
4452 LD_SEARCHPATH=`echo "$cf_cv_ld_searchpath"|sed -e 's/ /|/g'`
4453 AC_SUBST(LD_SEARCHPATH)
4454 ])dnl
4455 dnl ---------------------------------------------------------------------------
4456 dnl CF_LIBRARY_PATH version: 11 updated: 2021/01/01 13:31:04
4457 dnl ---------------
4458 dnl Construct a search-list of directories for a nonstandard library-file
4459 dnl
4460 dnl Parameters
4461 dnl     $1 = the variable to return as result
4462 dnl     $2 = the package name
4463 AC_DEFUN([CF_LIBRARY_PATH],
4464 [
4465 $1=
4466 cf_library_path_list=""
4467 if test -n "${LDFLAGS}${LIBS}" ; then
4468         for cf_library_path in $LDFLAGS $LIBS
4469         do
4470                 case "$cf_library_path" in
4471                 (-L*)
4472                         cf_library_path=`echo ".$cf_library_path" |sed -e 's/^...//' -e 's,/lib$,,'`
4473                         CF_ADD_SUBDIR_PATH($1,$2,lib,$cf_library_path,NONE)
4474                         cf_library_path_list="$cf_library_path_list [$]$1"
4475                         ;;
4476                 esac
4477         done
4478 fi
4479
4480 CF_SUBDIR_PATH($1,$2,lib)
4481
4482 $1="$cf_library_path_list [$]$1"
4483 ])dnl
4484 dnl ---------------------------------------------------------------------------
4485 dnl CF_LIBTOOL_VERSION version: 1 updated: 2013/04/06 18:03:09
4486 dnl ------------------
4487 AC_DEFUN([CF_LIBTOOL_VERSION],[
4488 if test -n "$LIBTOOL" && test "$LIBTOOL" != none
4489 then
4490         cf_cv_libtool_version=`$LIBTOOL --version 2>&1 | sed -e '/^$/d' |sed -e '2,$d' -e 's/([[^)]]*)//g' -e 's/^[[^1-9]]*//' -e 's/[[^0-9.]].*//'`
4491 else
4492         cf_cv_libtool_version=
4493 fi
4494 test -z "$cf_cv_libtool_version" && unset cf_cv_libtool_version
4495 ])dnl
4496 dnl ---------------------------------------------------------------------------
4497 dnl CF_LIB_PREFIX version: 14 updated: 2021/01/01 13:31:04
4498 dnl -------------
4499 dnl Compute the library-prefix for the given host system
4500 dnl $1 = variable to set
4501 define([CF_LIB_PREFIX],
4502 [
4503         case "$cf_cv_system_name" in
4504         (OS/2*|os2*)
4505                 if test "$DFT_LWR_MODEL" = libtool; then
4506                         LIB_PREFIX='lib'
4507                 else
4508                         LIB_PREFIX=''
4509                 fi
4510                 ;;
4511         (*-msvc*)
4512                 LIB_PREFIX=''
4513                 ;;
4514         (*)     LIB_PREFIX='lib'
4515                 ;;
4516         esac
4517 ifelse($1,,,[$1=$LIB_PREFIX])
4518         AC_SUBST(LIB_PREFIX)
4519 ])dnl
4520 dnl ---------------------------------------------------------------------------
4521 dnl CF_LIB_RULES version: 98 updated: 2023/01/07 16:32:06
4522 dnl ------------
4523 dnl Append definitions and rules for the given models to the subdirectory
4524 dnl Makefiles, and the recursion rule for the top-level Makefile.  If the
4525 dnl subdirectory is a library-source directory, modify the Libs_To_Make list in
4526 dnl the corresponding makefile to list the models that we'll generate.
4527 dnl
4528 dnl For shared libraries, make a list of symbolic links to construct when
4529 dnl generating each library.  The convention used for Linux is the simplest
4530 dnl one:
4531 dnl     lib<name>.so    ->
4532 dnl     lib<name>.so.<major>    ->
4533 dnl     lib<name>.so.<maj>.<minor>
4534 dnl
4535 dnl Note: Libs_To_Make is mixed case, since it is not a pure autoconf variable.
4536 AC_DEFUN([CF_LIB_RULES],
4537 [AC_REQUIRE([AC_PROG_FGREP])dnl
4538 AC_REQUIRE([CF_MAKE_PHONY])dnl
4539
4540 cf_prefix=$LIB_PREFIX
4541 AC_REQUIRE([CF_SUBST_NCURSES_VERSION])
4542
4543 case "$cf_cv_shlib_version" in
4544 (cygdll|msysdll|mingw|msvcdll)
4545         TINFO_NAME=$TINFO_ARG_SUFFIX
4546         TINFO_SUFFIX=.dll
4547         ;;
4548 esac
4549
4550 if test -n "$TINFO_SUFFIX" ; then
4551         case "$TINFO_SUFFIX" in
4552         (tw*)
4553                 TINFO_NAME="${TINFO_NAME}tw${EXTRA_SUFFIX}"
4554                 TINFO_SUFFIX=`echo "$TINFO_SUFFIX" | sed 's/^tw'$EXTRA_SUFFIX'//'`
4555                 ;;
4556         (t*)
4557                 TINFO_NAME="${TINFO_NAME}t${EXTRA_SUFFIX}"
4558                 TINFO_SUFFIX=`echo "$TINFO_SUFFIX" | sed 's/^t'$EXTRA_SUFFIX'//'`
4559                 ;;
4560         (w*)
4561                 TINFO_NAME="${TINFO_NAME}w${EXTRA_SUFFIX}"
4562                 TINFO_SUFFIX=`echo "$TINFO_SUFFIX" | sed 's/^w'$EXTRA_SUFFIX'//'`
4563                 ;;
4564         esac
4565 fi
4566
4567 for cf_dir in $SRC_SUBDIRS
4568 do
4569         if test ! -d "$srcdir/$cf_dir" ; then
4570                 continue
4571         elif test -f "$srcdir/$cf_dir/modules" ; then
4572
4573                 SHARED_LIB=
4574                 Libs_To_Make=
4575                 cf_awk_program=
4576                 if test -n "${cf_cv_abi_default}" && test "x${cf_cv_abi_default}" != "x5"
4577                 then
4578                         cf_awk_program="$cf_awk_program\
4579 /deprecated in ABI${cf_cv_abi_default}/ { next; }\
4580 { sub(\"NCURSES([[WT]]+)?\", \"&${cf_cv_abi_default}\"); }\
4581 "
4582                 fi
4583
4584                 if test "x$WILDCARD_SYMS" = xno
4585                 then
4586                         cf_awk_program="$cf_awk_program\
4587 /[[     ]]_\\*;/ { skip=1; next; }\
4588 "
4589                 fi
4590
4591                 if test "x$cf_awk_program" != "x"
4592                 then
4593                         cat >>$cf_dir/Makefile <<CF_EOF
4594
4595 # Generated by CF_LIB_RULES
4596 resulting.map: $UNALTERED_SYMS
4597         $AWK 'BEGIN { skip = 1; last=""; } \
4598 $cf_awk_program \
4599 { if ( last != "" && ( skip == 0 || \[$]\[$]0 !~ /}/ ) ) { print last; }\
4600  skip = 0; last = \[$]\[$]0; } \
4601 END { print last; }' < "$UNALTERED_SYMS" >\[$]@
4602
4603 distclean::
4604         rm -f resulting.map
4605 CF_EOF
4606                 fi
4607
4608                 for cf_item in $cf_LIST_MODELS
4609                 do
4610                         CF_LIB_SUFFIX($cf_item,cf_suffix,cf_depsuf)
4611                         if test "$cf_dir" = "c++"
4612                         then
4613                                 CF_MAP_LIB_BASENAME(cf_libname,cxx)
4614                         else
4615                                 CF_MAP_LIB_BASENAME(cf_libname,$cf_dir)
4616                         fi
4617                         test -z "$cf_libname" && cf_libname="$cf_dir"
4618                         if test "$cf_item" = shared ; then
4619                                 if test -n "${LIB_SUFFIX}"
4620                                 then
4621                                         cf_shared_suffix=`echo "$cf_suffix" | sed 's/^'"${USE_LIB_SUFFIX}"'//'`
4622                                 else
4623                                         cf_shared_suffix="$cf_suffix"
4624                                 fi
4625                                 if test "$cf_cv_do_symlinks" = yes ; then
4626                                         cf_version_name=
4627
4628                                         case "$cf_cv_shlib_version" in
4629                                         (rel)
4630                                                 cf_version_name=REL_VERSION
4631                                                 ;;
4632                                         (abi)
4633                                                 cf_version_name=ABI_VERSION
4634                                                 ;;
4635                                         esac
4636
4637                                         if test -n "$cf_version_name"
4638                                         then
4639                                                 case "$cf_cv_system_name" in
4640                                                 (darwin*)
4641                                                         # "w", etc?
4642                                                         cf_suffix="${USE_LIB_SUFFIX}"'.${'$cf_version_name'}'"$cf_shared_suffix"
4643                                                         ;;
4644                                                 (*)
4645                                                         cf_suffix="$cf_suffix"'.${'$cf_version_name'}'
4646                                                         ;;
4647                                                 esac
4648                                         fi
4649                                         if test -n "${USE_LIB_SUFFIX}"
4650                                         then
4651                                                 cf_shared_suffix=`echo "$cf_suffix" | sed 's/^'"${USE_LIB_SUFFIX}"'//'`
4652                                         else
4653                                                 cf_shared_suffix="$cf_suffix"
4654                                         fi
4655                                 fi
4656                                 # cygwin needs import library, and has unique naming convention
4657                                 # use autodetected ${cf_prefix} for import lib and static lib, but
4658                                 # use 'cyg' prefix for shared lib.
4659                                 case "$cf_cv_shlib_version" in
4660                                 (cygdll)
4661                                         cf_cygsuf=`echo "$cf_suffix" | sed -e 's/\.dll/\${ABI_VERSION}.dll/'`
4662                                         cf_add_lib="../lib/cyg${cf_libname}${cf_cygsuf}"
4663                                         ;;
4664                                 (msysdll)
4665                                         cf_cygsuf=`echo "$cf_suffix" | sed -e 's/\.dll/\${ABI_VERSION}.dll/'`
4666                                         cf_add_lib="../lib/msys-${cf_libname}${cf_cygsuf}"
4667                                         ;;
4668                                 (mingw)
4669                                         cf_cygsuf=`echo "$cf_suffix" | sed -e 's/\.dll/\${ABI_VERSION}.dll/'`
4670                                         cf_add_lib="../lib/lib${cf_libname}${cf_cygsuf}"
4671                                         ;;
4672                                 (msvcdll)
4673                                         cf_cygsuf=`echo "$cf_suffix" | sed -e 's/\.dll/\${ABI_VERSION}.dll/'`
4674                                         cf_add_lib="../lib/${cf_libname}${cf_cygsuf}"
4675                                         ;;
4676                                 (*)
4677                                         cf_add_lib=
4678                                         ;;
4679                                 esac
4680                                 if test -n "$cf_add_lib"
4681                                 then
4682                                         Libs_To_Make="$Libs_To_Make $cf_add_lib"
4683                                         continue
4684                                 fi
4685                         fi
4686                         cf_add_lib="../lib/${cf_prefix}${cf_libname}${cf_suffix}"
4687                         Libs_To_Make="$Libs_To_Make $cf_add_lib"
4688                 done
4689
4690                 if test "$cf_dir" = ncurses ; then
4691                         cf_subsets="$LIB_SUBSETS"
4692                         cf_r_parts="$cf_subsets"
4693                         cf_liblist="$Libs_To_Make"
4694
4695                         while test -n "$cf_r_parts"
4696                         do
4697                                 cf_l_parts=`echo "$cf_r_parts" |sed -e 's/ .*$//'`
4698                                 cf_r_parts=`echo "$cf_r_parts" |sed -e 's/^[[^ ]]* //'`
4699                                 if test "$cf_l_parts" != "$cf_r_parts" ; then
4700                                         cf_add_lib=
4701                                         case "$cf_l_parts" in
4702                                         (*termlib*)
4703                                                 cf_add_lib=`echo "$cf_liblist" |sed -e s%${LIB_NAME}${USE_LIB_SUFFIX}%${TINFO_LIB_SUFFIX}%g`
4704                                                 ;;
4705                                         (*ticlib*)
4706                                                 cf_add_lib=`echo "$cf_liblist" |sed -e s%${LIB_NAME}${USE_LIB_SUFFIX}%${TICS_LIB_SUFFIX}%g`
4707                                                 ;;
4708                                         (*)
4709                                                 break
4710                                                 ;;
4711                                         esac
4712                                         if test -n "$cf_add_lib"; then
4713                                                 Libs_To_Make="$cf_add_lib $Libs_To_Make"
4714                                         fi
4715                                 else
4716                                         break
4717                                 fi
4718                         done
4719                 else
4720                         cf_subsets=`echo "$LIB_SUBSETS" | sed -e 's/^termlib.* //'`
4721                 fi
4722
4723                 if test "$cf_dir" = c++; then
4724                         if test "x$with_shared_cxx" != xyes && test -n "$cf_shared_suffix"; then
4725                                 cf_list=
4726                                 for cf_item in $Libs_To_Make
4727                                 do
4728                                         case "$cf_item" in
4729                                         (*.a)
4730                                                 ;;
4731                                         (*)
4732                                                 cf_item=`echo "$cf_item" | sed -e "s,"$cf_shared_suffix",.a,"`
4733                                                 ;;
4734                                         esac
4735                                         for cf_test in $cf_list
4736                                         do
4737                                                 if test "$cf_test" = "$cf_item"
4738                                                 then
4739                                                         cf_LIST_MODELS=`echo "$cf_LIST_MODELS" | sed -e 's/normal//'`
4740                                                         cf_item=
4741                                                         break
4742                                                 fi
4743                                         done
4744                                         test -n "$cf_item" && cf_list="$cf_list $cf_item"
4745                                 done
4746                                 Libs_To_Make="$cf_list"
4747                         fi
4748                 fi
4749
4750                 sed -e "s%@Libs_To_Make@%$Libs_To_Make%" \
4751                     -e "s%@SHARED_LIB@%$SHARED_LIB%" \
4752                         "$cf_dir/Makefile" >$cf_dir/Makefile.out
4753                 mv "$cf_dir/Makefile.out" "$cf_dir/Makefile"
4754
4755                 $AWK -f "$srcdir/mk-0th.awk" \
4756                         libname="${cf_dir}${LIB_SUFFIX}" subsets="$LIB_SUBSETS" ticlib="$TICS_LIB_SUFFIX" termlib="$TINFO_LIB_SUFFIX" \
4757                         "$srcdir/$cf_dir/modules" >>$cf_dir/Makefile
4758
4759                 for cf_subset in $cf_subsets
4760                 do
4761                         cf_subdirs=
4762                         for cf_item in $cf_LIST_MODELS
4763                         do
4764
4765                         echo "Appending rules for ${cf_item} model (${cf_dir}: ${cf_subset})"
4766                         CF_UPPER(cf_ITEM,$cf_item)
4767
4768                         CXX_MODEL=$cf_ITEM
4769                         if test "$CXX_MODEL" = SHARED; then
4770                                 case "$cf_cv_shlib_version" in
4771                                 (cygdll|msysdll|mingw|msvcdll)
4772                                         test "x$with_shared_cxx" = xno && CF_VERBOSE(overriding CXX_MODEL to SHARED)
4773                                         with_shared_cxx=yes
4774                                         ;;
4775                                 (*)
4776                                         test "x$with_shared_cxx" = xno && CXX_MODEL=NORMAL
4777                                         ;;
4778                                 esac
4779                         fi
4780
4781                         CF_LIB_SUFFIX($cf_item,cf_suffix,cf_depsuf)
4782                         CF_OBJ_SUBDIR($cf_item,cf_subdir)
4783
4784                         # Test for case where we build libtinfo with a different name.
4785                         cf_libname=$cf_dir
4786                         if test "$cf_dir" = ncurses ; then
4787                                 case "$cf_subset" in
4788                                 (*base*)
4789                                         cf_libname=${cf_libname}$USE_LIB_SUFFIX
4790                                         ;;
4791                                 (*termlib*)
4792                                         cf_libname=$TINFO_LIB_SUFFIX
4793                                         ;;
4794                                 (ticlib*)
4795                                         cf_libname=$TICS_LIB_SUFFIX
4796                                         ;;
4797                                 esac
4798                         elif test "$cf_dir" = c++ ; then
4799                                 CF_MAP_LIB_BASENAME(cf_libname,cxx)
4800                                 cf_libname=${cf_libname}$USE_LIB_SUFFIX
4801                         else
4802                                 CF_MAP_LIB_BASENAME(cf_libname,$cf_dir)
4803                                 cf_libname=${cf_libname}$USE_LIB_SUFFIX
4804                         fi
4805                         if test -n "${USE_ARG_SUFFIX}" ; then
4806                                 # undo $USE_LIB_SUFFIX add-on in CF_LIB_SUFFIX
4807                                 cf_suffix=`echo "$cf_suffix" |sed -e "s%^${USE_LIB_SUFFIX}%%"`
4808                         fi
4809
4810                         # These dependencies really are for development, not
4811                         # builds, but they are useful in porting, too.
4812                         cf_depend="../include/ncurses_cfg.h"
4813                         if test "$srcdir" = "."; then
4814                                 cf_reldir="."
4815                         else
4816                                 cf_reldir="\${srcdir}"
4817                         fi
4818
4819                         if test -f "$srcdir/$cf_dir/$cf_dir.priv.h" ; then
4820                                 cf_depend="$cf_depend $cf_reldir/$cf_dir.priv.h"
4821                         elif test -f "$srcdir/$cf_dir/curses.priv.h" ; then
4822                                 cf_depend="$cf_depend $cf_reldir/curses.priv.h"
4823                         fi
4824
4825                         cf_dir_suffix=
4826                         old_cf_suffix="$cf_suffix"
4827                         if test "$cf_cv_shlib_version_infix" = yes ; then
4828                         if test -n "$USE_LIB_SUFFIX" ; then
4829                                 case "$USE_LIB_SUFFIX" in
4830                                 (tw*)
4831                                         cf_libname=`echo "$cf_libname" | sed 's/tw'$EXTRA_SUFFIX'$//'`
4832                                         cf_suffix=`echo "$cf_suffix" | sed 's/^tw'$EXTRA_SUFFIX'//'`
4833                                         cf_dir_suffix=tw$EXTRA_SUFFIX
4834                                         ;;
4835                                 (t*)
4836                                         cf_libname=`echo "$cf_libname" | sed 's/t'$EXTRA_SUFFIX'$//'`
4837                                         cf_suffix=`echo "$cf_suffix" | sed 's/^t'$EXTRA_SUFFIX'//'`
4838                                         cf_dir_suffix=t$EXTRA_SUFFIX
4839                                         ;;
4840                                 (w*)
4841                                         cf_libname=`echo "$cf_libname" | sed 's/w'$EXTRA_SUFFIX'$//'`
4842                                         cf_suffix=`echo "$cf_suffix" | sed 's/^w'$EXTRA_SUFFIX'//'`
4843                                         cf_dir_suffix=w$EXTRA_SUFFIX
4844                                         ;;
4845                                 (*)
4846                                         cf_libname=`echo "$cf_libname" | sed 's/'$EXTRA_SUFFIX'$//'`
4847                                         cf_suffix=`echo "$cf_suffix" | sed 's/^'$EXTRA_SUFFIX'//'`
4848                                         cf_dir_suffix=$EXTRA_SUFFIX
4849                                         ;;
4850                                 esac
4851                         fi
4852                         fi
4853
4854                         $AWK -f "$srcdir/mk-1st.awk" \
4855                                 name=${cf_libname}${cf_dir_suffix} \
4856                                 traces=$LIB_TRACING \
4857                                 MODEL=$cf_ITEM \
4858                                 CXX_MODEL=$CXX_MODEL \
4859                                 LIB_SUFFIX=$LIB_SUFFIX \
4860                                 USE_LIB_SUFFIX=$USE_LIB_SUFFIX \
4861                                 make_phony="${cf_cv_make_PHONY:-no}" \
4862                                 model=$cf_subdir \
4863                                 prefix=$cf_prefix \
4864                                 suffix=$cf_suffix \
4865                                 subset=$cf_subset \
4866                                 driver=$cf_cv_term_driver \
4867                                 SymLink="$LN_S" \
4868                                 TermlibRoot=$TINFO_NAME \
4869                                 TermlibSuffix=$TINFO_SUFFIX \
4870                                 ShlibVer=$cf_cv_shlib_version \
4871                                 ShlibVerInfix=$cf_cv_shlib_version_infix \
4872                                 ReLink=${cf_cv_do_relink:-no} \
4873                                 ReRanlib=${cf_cv_do_reranlib:-yes} \
4874                                 DoLinks=$cf_cv_do_symlinks \
4875                                 rmSoLocs=$cf_cv_rm_so_locs \
4876                                 ldconfig="$LDCONFIG" \
4877                                 overwrite=$WITH_OVERWRITE \
4878                                 depend="$cf_depend" \
4879                                 host="$host" \
4880                                 libtool_version="$LIBTOOL_VERSION" \
4881                                 "$srcdir/$cf_dir/modules" >>$cf_dir/Makefile
4882
4883                         cf_suffix="$old_cf_suffix"
4884
4885                         for cf_subdir2 in $cf_subdirs lib
4886                         do
4887                                 test "$cf_subdir" = "$cf_subdir2" && break
4888                         done
4889                         test "${cf_subset}.${cf_subdir2}" != "${cf_subset}.${cf_subdir}" && \
4890                         $AWK -f "$srcdir/mk-2nd.awk" \
4891                                 name=$cf_dir \
4892                                 traces=$LIB_TRACING \
4893                                 MODEL=$cf_ITEM \
4894                                 model=$cf_subdir \
4895                                 subset=$cf_subset \
4896                                 srcdir=$srcdir \
4897                                 echo=$WITH_ECHO \
4898                                 crenames=$cf_cv_prog_CC_c_o \
4899                                 cxxrenames=$cf_cv_prog_CXX_c_o \
4900                                 "$srcdir/$cf_dir/modules" >>$cf_dir/Makefile
4901                         cf_subdirs="$cf_subdirs $cf_subdir"
4902                         done
4903                 done
4904         fi
4905
4906         echo '  ( cd '$cf_dir' && ${MAKE} ${TOP_MFLAGS} [$]@ )' >>Makefile
4907 done
4908
4909 echo >> Makefile
4910 echo '# generated by CF_LIB_RULES' >> Makefile
4911
4912 if test "x$cf_cv_make_PHONY" = xyes ; then
4913         cat >> Makefile <<-CF_EOF
4914
4915         .PHONY :        libs
4916         .PHONY :        lintlib
4917         .PHONY :        install.includes
4918         .PHONY :        uninstall.includes
4919         .PHONY :        install.libs
4920         .PHONY :        uninstall.libs
4921 CF_EOF
4922 fi
4923
4924 for cf_dir in $SRC_SUBDIRS
4925 do
4926         if test ! -d "$srcdir/$cf_dir" ; then
4927                 continue
4928         fi
4929
4930         if test -f "$cf_dir/Makefile" ; then
4931                 case "$cf_dir" in
4932                 (Ada95)
4933                         echo 'libs \' >> Makefile
4934                         echo 'install.libs \' >> Makefile
4935                         echo 'uninstall.libs ::' >> Makefile
4936                         echo '  ( cd '$cf_dir' && ${MAKE} ${TOP_MFLAGS} [$]@ )' >> Makefile
4937                         ;;
4938                 esac
4939         fi
4940
4941         if test -f "$srcdir/$cf_dir/modules" ; then
4942
4943                 if test "x$cf_cv_make_PHONY" = xyes ; then
4944                         cat >> Makefile <<-CF_EOF
4945
4946                         .PHONY :        install.$cf_dir
4947                         .PHONY :        uninstall.$cf_dir
4948 CF_EOF
4949                 fi
4950
4951                 echo >> Makefile
4952                 if test -f "$srcdir/$cf_dir/headers" ; then
4953 cat >> Makefile <<CF_EOF
4954 install.includes \\
4955 uninstall.includes \\
4956 CF_EOF
4957                 fi
4958
4959 cat >> Makefile <<CF_EOF
4960 lint \\
4961 libs \\
4962 lintlib \\
4963 install.libs \\
4964 uninstall.libs \\
4965 install.$cf_dir \\
4966 uninstall.$cf_dir ::
4967         ( cd "$cf_dir" && \${MAKE} \${TOP_MFLAGS} \[$]@ )
4968 CF_EOF
4969         elif test -f "$srcdir/$cf_dir/headers" ; then
4970 cat >> Makefile <<CF_EOF
4971
4972 libs \\
4973 install.libs \\
4974 uninstall.libs \\
4975 install.includes \\
4976 uninstall.includes ::
4977         ( cd "$cf_dir" && \${MAKE} \${TOP_MFLAGS} \[$]@ )
4978 CF_EOF
4979 fi
4980 done
4981
4982 if test "x$cf_cv_make_PHONY" = xyes ; then
4983         cat >> Makefile <<-CF_EOF
4984
4985         .PHONY :        install.data
4986         .PHONY :        uninstall.data
4987 CF_EOF
4988 fi
4989
4990 if test "x$cf_with_db_install" = xyes; then
4991 cat >> Makefile <<CF_EOF
4992
4993 install.libs uninstall.libs \\
4994 install.data uninstall.data ::
4995 $MAKE_TERMINFO  ( cd misc && \${MAKE} \${TOP_MFLAGS} \[$]@ )
4996 CF_EOF
4997 else
4998 cat >> Makefile <<CF_EOF
4999
5000 install.libs uninstall.libs ::
5001         ( cd misc && \${MAKE} \${TOP_MFLAGS} \[$]@ )
5002 CF_EOF
5003 fi
5004
5005 if test "x$cf_with_manpages" = xyes; then
5006
5007 if test "x$cf_cv_make_PHONY" = xyes ; then
5008         cat >> Makefile <<-CF_EOF
5009
5010         .PHONY :        install.man
5011         .PHONY :        uninstall.man
5012 CF_EOF
5013 fi
5014
5015 cat >> Makefile <<CF_EOF
5016
5017 install.man \\
5018 uninstall.man ::
5019         ( cd man && \${MAKE} \${TOP_MFLAGS} \[$]@ )
5020 CF_EOF
5021 fi
5022
5023 cat >> Makefile <<CF_EOF
5024
5025 distclean ::
5026         rm -f config.cache config.log config.status Makefile include/ncurses_cfg.h
5027         rm -f headers.sh headers.sed mk_shared_lib.sh
5028         rm -f edit_man.* man_alias.*
5029         rm -rf \${DIRS_TO_MAKE}
5030 CF_EOF
5031
5032 # Special case: tack's manpage lives in its own directory.
5033 if test "x$cf_with_manpages" = xyes; then
5034 if test "x$cf_with_tack" = "xyes"; then
5035 cat >> Makefile <<CF_EOF
5036
5037 install.man \\
5038 uninstall.man ::
5039         ( cd tack && \${MAKE} \${TOP_MFLAGS} \[$]@ )
5040 CF_EOF
5041 fi
5042 fi
5043
5044 dnl If we're installing into a subdirectory of /usr/include, etc., we should
5045 dnl prepend the subdirectory's name to the "#include" paths.  It won't hurt
5046 dnl anything, and will make it more standardized.  It's awkward to decide this
5047 dnl at configuration because of quoting, so we'll simply make all headers
5048 dnl installed via a script that can do the right thing.
5049
5050 rm -f headers.sed headers.sh
5051
5052 dnl ( generating this script makes the makefiles a little tidier :-)
5053 echo creating headers.sh
5054 cat >headers.sh <<CF_EOF
5055 #! $SHELL
5056 # This shell script is generated by the 'configure' script.  It is invoked in a
5057 # subdirectory of the build tree.  It generates a sed-script in the parent
5058 # directory that is used to adjust includes for header files that reside in a
5059 # subdirectory of /usr/include, etc.
5060 PRG=""
5061 while test \[$]# != 3
5062 do
5063 PRG="\$PRG \[$]1"; shift
5064 done
5065 DST=\[$]1
5066 REF=\[$]2
5067 SRC=\[$]3
5068 TMPSRC=\${TMPDIR:-/tmp}/\`basename \$SRC\`\$\$
5069 TMPSED=\${TMPDIR:-/tmp}/headers.sed\$\$
5070 echo installing \$SRC in \$DST
5071 CF_EOF
5072
5073 if test "$WITH_CURSES_H" = yes; then
5074         cat >>headers.sh <<CF_EOF
5075 case \$DST in
5076 (/*/include/*)
5077         END=\`basename \$DST\`
5078         for i in \`cat \$REF/../*/headers |${FGREP-fgrep} -v "#"\`
5079         do
5080                 NAME=\`basename \$i\`
5081                 echo "s/<\$NAME>/<\$END\/\$NAME>/" >> \$TMPSED
5082         done
5083         ;;
5084 (*)
5085         echo "" >> \$TMPSED
5086         ;;
5087 esac
5088 CF_EOF
5089
5090 else
5091         cat >>headers.sh <<CF_EOF
5092 case \$DST in
5093 (/*/include/*)
5094         END=\`basename \$DST\`
5095         for i in \`cat \$REF/../*/headers |${FGREP-fgrep} -v "#"\`
5096         do
5097                 NAME=\`basename \$i\`
5098                 if test "\$NAME" = "curses.h"
5099                 then
5100                         echo "s/<curses.h>/<ncurses.h>/" >> \$TMPSED
5101                         NAME=ncurses.h
5102                 fi
5103                 echo "s/<\$NAME>/<\$END\/\$NAME>/" >> \$TMPSED
5104         done
5105         ;;
5106 (*)
5107         echo "s/<curses.h>/<ncurses.h>/" >> \$TMPSED
5108         ;;
5109 esac
5110 CF_EOF
5111 fi
5112 cat >>headers.sh <<CF_EOF
5113 rm -f \$TMPSRC
5114 sed -f \$TMPSED \$SRC > \$TMPSRC
5115 NAME=\`basename \$SRC\`
5116 CF_EOF
5117 if test "$WITH_CURSES_H" != yes; then
5118         cat >>headers.sh <<CF_EOF
5119 test "\$NAME" = "curses.h" && NAME=ncurses.h
5120 CF_EOF
5121 fi
5122 cat >>headers.sh <<CF_EOF
5123 # Just in case someone gzip'd manpages, remove the conflicting copy.
5124 test -f \$DST/\$NAME.gz && rm -f \$DST/\$NAME.gz
5125
5126 eval \$PRG \$TMPSRC \$DST/\$NAME
5127 rm -f \$TMPSRC \$TMPSED
5128 CF_EOF
5129
5130 chmod 0755 headers.sh
5131
5132 for cf_dir in $SRC_SUBDIRS
5133 do
5134         if test ! -d "$srcdir/$cf_dir" ; then
5135                 continue
5136         fi
5137
5138         if test -f "$srcdir/$cf_dir/headers" ; then
5139                 $AWK -f "$srcdir/mk-hdr.awk" \
5140                         subset="$LIB_SUBSETS" \
5141                         compat="$WITH_CURSES_H" \
5142                         "$srcdir/$cf_dir/headers" >>$cf_dir/Makefile
5143         fi
5144
5145         if test -f "$srcdir/$cf_dir/modules" ; then
5146                 if test "$cf_dir" != "c++" ; then
5147                         if test "x$cf_cv_make_PHONY" = xyes ; then
5148                                 cat >> $cf_dir/Makefile <<-CF_EOF
5149
5150                                 .PHONY :        depend
5151 CF_EOF
5152                         fi
5153
5154                         cat >>$cf_dir/Makefile <<"CF_EOF"
5155 depend : ${AUTO_SRC}
5156         makedepend -- ${CPPFLAGS} -- ${C_SRC}
5157
5158 # DO NOT DELETE THIS LINE -- make depend depends on it.
5159 CF_EOF
5160                 fi
5161         fi
5162 done
5163 AC_SUBST(Libs_To_Make)
5164 ])dnl
5165 dnl ---------------------------------------------------------------------------
5166 dnl CF_LIB_SONAME version: 9 updated: 2021/01/04 18:48:01
5167 dnl -------------
5168 dnl Find the and soname for the given shared library.  Set the cache variable
5169 dnl cf_cv_$3_soname to this, unless it is not found.  Then set the cache
5170 dnl variable to "unknown".
5171 dnl
5172 dnl $1 = headers
5173 dnl $2 = code
5174 dnl $3 = library name
5175 AC_DEFUN([CF_LIB_SONAME],
5176 [AC_REQUIRE([AC_PROG_FGREP])dnl
5177
5178 AC_CACHE_CHECK(for soname of $3 library,cf_cv_$3_soname,[
5179
5180 cf_cv_$3_soname=unknown
5181 if test "$cross_compiling" != yes ; then
5182 cat >conftest.$ac_ext <<CF_EOF
5183 $1
5184 int main(void)
5185 {
5186 $2
5187         ${cf_cv_main_return:-return}(0);
5188 }
5189 CF_EOF
5190 cf_save_LIBS="$LIBS"
5191         CF_ADD_LIB($3)
5192         if AC_TRY_EVAL(ac_compile) ; then
5193                 if AC_TRY_EVAL(ac_link) ; then
5194                         cf_cv_$3_soname="`ldd \"conftest$ac_exeext\" 2>/dev/null | sed -e 's,^.*/,,' -e 's, .*$,,' | ${FGREP-fgrep} lib$3.`"
5195                         test -z "$cf_cv_$3_soname" && cf_cv_$3_soname=unknown
5196                 fi
5197         fi
5198 rm -rf ./conftest*
5199 LIBS="$cf_save_LIBS"
5200 fi
5201 ])
5202 ])
5203 dnl ---------------------------------------------------------------------------
5204 dnl CF_LIB_SUFFIX version: 28 updated: 2021/01/01 16:53:59
5205 dnl -------------
5206 dnl Compute the library file-suffix from the given model name
5207 dnl $1 = model name
5208 dnl $2 = variable to set (the nominal library suffix)
5209 dnl $3 = dependency variable to set (actual filename)
5210 dnl The variable $LIB_SUFFIX, if set, prepends the variable to set.
5211 AC_DEFUN([CF_LIB_SUFFIX],
5212 [
5213         case X$1 in
5214         (Xlibtool)
5215                 $2='.la'
5216                 $3=[$]$2
5217                 ;;
5218         (Xdebug)
5219                 case "$cf_cv_system_name" in
5220                 (*-msvc*)
5221                         $2='_g.lib'
5222                         ;;
5223                 (*)
5224                         $2='_g.a'
5225                         ;;
5226                 esac
5227                 $3=[$]$2
5228                 ;;
5229         (Xprofile)
5230                 case "$cf_cv_system_name" in
5231                 (*-msvc*)
5232                         $2='_p.lib'
5233                         ;;
5234                 (*)
5235                         $2='_p.a'
5236                         ;;
5237                 esac
5238                 $3=[$]$2
5239                 ;;
5240         (Xshared)
5241                 case "$cf_cv_system_name" in
5242                 (aix[[5-7]]*)
5243                         $2='.so'
5244                         $3=[$]$2
5245                         ;;
5246                 (*-msvc*)
5247                         $2='.dll'
5248                         $3='.dll.lib'
5249                         ;;
5250                 (cygwin*|msys*|mingw*)
5251                         $2='.dll'
5252                         $3='.dll.a'
5253                         ;;
5254                 (darwin*)
5255                         $2='.dylib'
5256                         $3=[$]$2
5257                         ;;
5258                 (hpux*)
5259                         case "$target" in
5260                         (ia64*)
5261                                 $2='.so'
5262                                 $3=[$]$2
5263                                 ;;
5264                         (*)
5265                                 $2='.sl'
5266                                 $3=[$]$2
5267                                 ;;
5268                         esac
5269                         ;;
5270                 (*)
5271                         $2='.so'
5272                         $3=[$]$2
5273                         ;;
5274                 esac
5275                 ;;
5276         (*)
5277                 case "$target" in
5278                 (*-msvc*)
5279                         $2='.lib'
5280                         ;;
5281                 (*)
5282                         $2='.a'
5283                         ;;
5284                 esac
5285                 $3=[$]$2
5286                 ;;
5287         esac
5288         if test -n "${LIB_SUFFIX}${EXTRA_SUFFIX}"
5289         then
5290                 $2="${LIB_SUFFIX}${EXTRA_SUFFIX}[$]{$2}"
5291                 $3="${LIB_SUFFIX}${EXTRA_SUFFIX}[$]{$3}"
5292         fi
5293 ])dnl
5294 dnl ---------------------------------------------------------------------------
5295 dnl CF_LIB_TYPE version: 5 updated: 2015/04/17 21:13:04
5296 dnl -----------
5297 dnl Compute the string to append to -library from the given model name
5298 dnl $1 = model name
5299 dnl $2 = variable to set
5300 dnl The variable $LIB_SUFFIX, if set, prepends the variable to set.
5301 AC_DEFUN([CF_LIB_TYPE],
5302 [
5303         case $1 in
5304         (libtool) $2=''   ;;
5305         (normal)  $2=''   ;;
5306         (debug)   $2='_g' ;;
5307         (profile) $2='_p' ;;
5308         (shared)  $2=''   ;;
5309         esac
5310         test -n "$LIB_SUFFIX" && $2="${LIB_SUFFIX}[$]{$2}"
5311 ])dnl
5312 dnl ---------------------------------------------------------------------------
5313 dnl CF_LINK_DATAONLY version: 13 updated: 2020/02/08 15:59:30
5314 dnl ----------------
5315 dnl Some systems have a non-ANSI linker that doesn't pull in modules that have
5316 dnl only data (i.e., no functions), for example NeXT.  On those systems we'll
5317 dnl have to provide wrappers for global tables to ensure they're linked
5318 dnl properly.
5319 AC_DEFUN([CF_LINK_DATAONLY],
5320 [
5321 AC_MSG_CHECKING([if data-only library module links])
5322 AC_CACHE_VAL(cf_cv_link_dataonly,[
5323         rm -f conftest.a
5324         cat >conftest.$ac_ext <<EOF
5325 #line __oline__ "configure"
5326 int     testdata[[3]] = { 123, 456, 789 };
5327 EOF
5328         if AC_TRY_EVAL(ac_compile) ; then
5329                 mv conftest.o data.o && \
5330                 ( $AR $ARFLAGS conftest.a data.o ) 2>&AC_FD_CC 1>/dev/null
5331         fi
5332         rm -f conftest.$ac_ext data.o
5333         cat >conftest.$ac_ext <<EOF
5334 #line __oline__ "configure"
5335 int     testfunc(void)
5336 {
5337 #if defined(NeXT)
5338         ${cf_cv_main_return:-return}(1);        /* I'm told this linker is broken */
5339 #else
5340         extern int testdata[[3]];
5341         return testdata[[0]] == 123
5342            &&  testdata[[1]] == 456
5343            &&  testdata[[2]] == 789;
5344 #endif
5345 }
5346 EOF
5347         if AC_TRY_EVAL(ac_compile); then
5348                 mv conftest.o func.o && \
5349                 ( $AR $ARFLAGS conftest.a func.o ) 2>&AC_FD_CC 1>/dev/null
5350         fi
5351         rm -f conftest.$ac_ext func.o
5352         ( eval $RANLIB conftest.a ) 2>&AC_FD_CC >/dev/null
5353         cf_saveLIBS="$LIBS"
5354         LIBS="conftest.a $LIBS"
5355         AC_TRY_RUN([
5356         int main(void)
5357         {
5358                 extern int testfunc();
5359                 ${cf_cv_main_return:-return} (!testfunc());
5360         }
5361         ],
5362         [cf_cv_link_dataonly=yes],
5363         [cf_cv_link_dataonly=no],
5364         [cf_cv_link_dataonly=unknown])
5365         LIBS="$cf_saveLIBS"
5366         ])
5367 AC_MSG_RESULT($cf_cv_link_dataonly)
5368
5369 if test "$cf_cv_link_dataonly" = no ; then
5370         AC_DEFINE(BROKEN_LINKER,1,[if data-only library module does not link])
5371         BROKEN_LINKER=1
5372 fi
5373 AC_SUBST(BROKEN_LINKER)
5374
5375 ])dnl
5376 dnl ---------------------------------------------------------------------------
5377 dnl CF_LINK_FUNCS version: 12 updated: 2023/01/05 17:51:41
5378 dnl -------------
5379 dnl Most Unix systems have both link and symlink, a few don't have symlink.
5380 dnl A few non-Unix systems implement symlink, but not link.
5381 dnl A few non-systems implement neither (or have nonfunctional versions).
5382 dnl
5383 dnl This allows for a 2-second difference in modification times to allow for
5384 dnl some marginal NFS implementations.
5385 AC_DEFUN([CF_LINK_FUNCS],
5386 [
5387 AC_CHECK_HEADERS( \
5388 unistd.h \
5389 )
5390 AC_CHECK_FUNCS( \
5391         remove \
5392         unlink )
5393
5394 if test "$cross_compiling" = yes ; then
5395         AC_CHECK_FUNCS( \
5396                 link \
5397                 symlink )
5398 else
5399         AC_CACHE_CHECK(if link/symlink functions work,cf_cv_link_funcs,[
5400                 cf_cv_link_funcs=
5401                 for cf_func in link symlink ; do
5402                         AC_TRY_RUN([
5403 $ac_includes_default
5404
5405 int main(void)
5406 {
5407         int fail = 0;
5408         char *src = "conftest.tmp";
5409         char *dst = "conftest.chk";
5410         struct stat src_sb, dst_sb;
5411         FILE *fp = fopen(src, "w");
5412         if (fp == 0) { fail = 3; } else {
5413                 fclose(fp); stat(src, &src_sb);
5414                 if ($cf_func(src, dst) < 0) {
5415                         fail = 1;
5416                 } else if (stat(dst, &dst_sb) < 0) {
5417                         fail = 2;
5418                 } else {
5419                         long diff = (dst_sb.st_mtime - src_sb.st_mtime);
5420                         if (diff < 0) diff = -diff;
5421                         if (diff > 2) fail = 3;
5422                 }
5423         }
5424 #ifdef HAVE_UNLINK
5425         unlink(dst); unlink(src);
5426 #else
5427         remove(dst); remove(src);
5428 #endif
5429         ${cf_cv_main_return:-return} (fail);
5430 }
5431                         ],[
5432                         cf_cv_link_funcs="$cf_cv_link_funcs $cf_func"
5433                         eval 'ac_cv_func_'$cf_func'=yes'],[
5434                         eval 'ac_cv_func_'$cf_func'=no'],[
5435                         eval 'ac_cv_func_'$cf_func'=error'])
5436                 done
5437                 test -z "$cf_cv_link_funcs" && cf_cv_link_funcs=no
5438         ])
5439         test "$ac_cv_func_link"    = yes && AC_DEFINE(HAVE_LINK,1,[Define to 1 if we have link() function])
5440         test "$ac_cv_func_symlink" = yes && AC_DEFINE(HAVE_SYMLINK,1,[Define to 1 if we have symlink() function])
5441 fi
5442 ])dnl
5443 dnl ---------------------------------------------------------------------------
5444 dnl CF_MAKEFLAGS version: 21 updated: 2021/09/04 06:47:34
5445 dnl ------------
5446 dnl Some 'make' programs support ${MAKEFLAGS}, some ${MFLAGS}, to pass 'make'
5447 dnl options to lower-levels.  It is very useful for "make -n" -- if we have it.
5448 dnl (GNU 'make' does both, something POSIX 'make', which happens to make the
5449 dnl ${MAKEFLAGS} variable incompatible because it adds the assignments :-)
5450 AC_DEFUN([CF_MAKEFLAGS],
5451 [AC_REQUIRE([AC_PROG_FGREP])dnl
5452
5453 AC_CACHE_CHECK(for makeflags variable, cf_cv_makeflags,[
5454         cf_cv_makeflags=''
5455         for cf_option in '-${MAKEFLAGS}' '${MFLAGS}'
5456         do
5457                 cat >cf_makeflags.tmp <<CF_EOF
5458 SHELL = $SHELL
5459 all :
5460         @ echo '.$cf_option'
5461 CF_EOF
5462                 cf_result=`${MAKE:-make} -k -f cf_makeflags.tmp 2>/dev/null | ${FGREP-fgrep} -v "ing directory" | sed -e 's,[[  ]]*$,,'`
5463                 case "$cf_result" in
5464                 (.*k|.*kw)
5465                         cf_result="`${MAKE:-make} -k -f cf_makeflags.tmp CC=cc 2>/dev/null`"
5466                         case "$cf_result" in
5467                         (.*CC=*)        cf_cv_makeflags=
5468                                 ;;
5469                         (*)     cf_cv_makeflags=$cf_option
5470                                 ;;
5471                         esac
5472                         break
5473                         ;;
5474                 (.-)
5475                         ;;
5476                 (*)
5477                         CF_MSG_LOG(given option \"$cf_option\", no match \"$cf_result\")
5478                         ;;
5479                 esac
5480         done
5481         rm -f cf_makeflags.tmp
5482 ])
5483
5484 AC_SUBST(cf_cv_makeflags)
5485 ])dnl
5486 dnl ---------------------------------------------------------------------------
5487 dnl CF_MAKE_PHONY version: 3 updated: 2021/01/08 16:08:21
5488 dnl -------------
5489 dnl Check if the make-program handles a ".PHONY" target, e.g,. a target which
5490 dnl acts as a placeholder.
5491 dnl
5492 dnl The ".PHONY" feature was proposed in 2011 here
5493 dnl     https://www.austingroupbugs.net/view.php?id=523
5494 dnl and is scheduled for release in P1003.1 Issue 8 (late 2022).
5495 dnl
5496 dnl This is not supported by SVr4 make (or SunOS 4, 4.3SD, etc), but works with
5497 dnl a few others (i.e., GNU make and the non-POSIX "BSD" make):
5498 dnl
5499 dnl + This is a GNU make feature (since April 1988, but in turn from binutils,
5500 dnl   date unspecified).
5501 dnl
5502 dnl + It was adopted in NetBSD make in June 1995.
5503 dnl
5504 dnl + The other BSD make programs are derived from the NetBSD make (and for
5505 dnl   that reason are not actually different "implementations").
5506 dnl
5507 dnl + Some features of NetBSD make were actually adapted from pmake, which
5508 dnl   began as a modified GNU make starting in 1993.
5509 dnl
5510 dnl + Version 3.8 of the dmake program in January 1992 also implemented this
5511 dnl   GNU make extension, but is less well known than the BSD make.
5512 AC_DEFUN([CF_MAKE_PHONY],[
5513 AC_CACHE_CHECK(for \".PHONY\" make-support, cf_cv_make_PHONY,[
5514         rm -rf conftest*
5515         (
5516                 mkdir conftest || exit 1
5517                 cd conftest
5518                 cat >makefile <<'CF_EOF'
5519 .PHONY: always
5520 DATA=0
5521 always: always.out
5522         @echo "** making [$]@ [$](DATA)"
5523 once: once.out
5524         @echo "** making [$]@ [$](DATA)"
5525 always.out:
5526         @echo "** making [$]@ [$](DATA)"
5527         echo [$](DATA) > [$]@
5528 once.out:
5529         @echo "** making [$]@ [$](DATA)"
5530         echo [$](DATA) > [$]@
5531 CF_EOF
5532                 for cf_data in 1 2 3
5533                 do
5534                         ${MAKE:-make} always DATA=$cf_data
5535                         ${MAKE:-make} once   DATA=$cf_data
5536                         ${MAKE:-make} -t always once
5537                         if test -f always ; then
5538                                 echo "no (case 1)" > ../conftest.tmp
5539                         elif test ! -f always.out ; then
5540                                 echo "no (case 2)" > ../conftest.tmp
5541                         elif test ! -f once.out ; then
5542                                 echo "no (case 3)" > ../conftest.tmp
5543                         elif ! cmp -s always.out once.out ; then
5544                                 echo "no (case 4)" > ../conftest.tmp
5545                                 diff always.out once.out
5546                         else
5547                                 cf_check="`cat always.out`"
5548                                 if test "x$cf_check" != "x$cf_data" ; then
5549                                         echo "no (case 5)" > ../conftest.tmp
5550                                 else
5551                                         echo yes > ../conftest.tmp
5552                                         rm -f ./*.out
5553                                         continue
5554                                 fi
5555                         fi
5556                         break
5557                 done
5558         ) >&AC_FD_CC 2>&1
5559         cf_cv_make_PHONY="`cat conftest.tmp`"
5560         rm -rf conftest*
5561 ])
5562 MAKE_NO_PHONY="#"
5563 MAKE_PHONY="#"
5564 test "x$cf_cv_make_PHONY" = xyes && MAKE_PHONY=
5565 test "x$cf_cv_make_PHONY" != xyes && MAKE_NO_PHONY=
5566 AC_SUBST(MAKE_NO_PHONY)
5567 AC_SUBST(MAKE_PHONY)
5568 ])dnl
5569 dnl ---------------------------------------------------------------------------
5570 dnl CF_MAKE_TAGS version: 6 updated: 2010/10/23 15:52:32
5571 dnl ------------
5572 dnl Generate tags/TAGS targets for makefiles.  Do not generate TAGS if we have
5573 dnl a monocase filesystem.
5574 AC_DEFUN([CF_MAKE_TAGS],[
5575 AC_REQUIRE([CF_MIXEDCASE_FILENAMES])
5576
5577 AC_CHECK_PROGS(CTAGS, exctags ctags)
5578 AC_CHECK_PROGS(ETAGS, exetags etags)
5579
5580 AC_CHECK_PROG(MAKE_LOWER_TAGS, ${CTAGS:-ctags}, yes, no)
5581
5582 if test "$cf_cv_mixedcase" = yes ; then
5583         AC_CHECK_PROG(MAKE_UPPER_TAGS, ${ETAGS:-etags}, yes, no)
5584 else
5585         MAKE_UPPER_TAGS=no
5586 fi
5587
5588 if test "$MAKE_UPPER_TAGS" = yes ; then
5589         MAKE_UPPER_TAGS=
5590 else
5591         MAKE_UPPER_TAGS="#"
5592 fi
5593
5594 if test "$MAKE_LOWER_TAGS" = yes ; then
5595         MAKE_LOWER_TAGS=
5596 else
5597         MAKE_LOWER_TAGS="#"
5598 fi
5599
5600 AC_SUBST(CTAGS)
5601 AC_SUBST(ETAGS)
5602
5603 AC_SUBST(MAKE_UPPER_TAGS)
5604 AC_SUBST(MAKE_LOWER_TAGS)
5605 ])dnl
5606 dnl ---------------------------------------------------------------------------
5607 dnl CF_MANPAGE_FORMAT version: 17 updated: 2023/01/21 16:49:25
5608 dnl -----------------
5609 dnl Option to allow user to override automatic configuration of manpage format.
5610 dnl There are several special cases:
5611 dnl
5612 dnl     compress - man checks for, can display compressed files
5613 dnl     bzip2 - man checks for, can display bzip2'd files
5614 dnl     gzip - man checks for, can display gzip'd files
5615 dnl     xz - man checks for, can display xz'd files
5616 dnl
5617 dnl     BSDI - files in the cat-directories are suffixed ".0"
5618 dnl     formatted - installer should format (put files in cat-directory)
5619 dnl     catonly - installer should only format, e.g., for a turnkey system.
5620 dnl
5621 dnl There are other configurations which this macro does not test, e.g., HPUX's
5622 dnl compressed manpages (but uncompressed manpages are fine, and HPUX's naming
5623 dnl convention would not match our use).
5624 AC_DEFUN([CF_MANPAGE_FORMAT],
5625 [
5626 AC_REQUIRE([CF_PATHSEP])
5627 AC_MSG_CHECKING(format of man-pages)
5628
5629 AC_ARG_WITH(manpage-format,
5630         [  --with-manpage-format   specify manpage-format: gzip/compress/bzip2/xz,
5631                           BSDI/normal and optionally formatted/catonly,
5632                           e.g., gzip,formatted],
5633         [MANPAGE_FORMAT=$withval],
5634         [MANPAGE_FORMAT=unknown])
5635
5636 test -z "$MANPAGE_FORMAT" && MANPAGE_FORMAT=unknown
5637 MANPAGE_FORMAT=`echo "$MANPAGE_FORMAT" | sed -e 's/,/ /g'`
5638
5639 cf_unknown=
5640
5641 case "$MANPAGE_FORMAT" in
5642 (unknown)
5643         if test -z "$MANPATH" ; then
5644                 MANPATH="/usr/man:/usr/share/man"
5645         fi
5646
5647         # look for the 'date' man-page (it is most likely to be installed!)
5648         MANPAGE_FORMAT=
5649         cf_preform="no"
5650         cf_catonly="yes"
5651         cf_example="date"
5652
5653         IFS="${IFS:-    }"; ac_save_ifs="$IFS"; IFS="${IFS}${PATH_SEPARATOR}"
5654         for cf_dir in $MANPATH; do
5655                 test -z "$cf_dir" && cf_dir=/usr/man
5656                 for cf_name in $cf_dir/man*/$cf_example.[[01]]* $cf_dir/cat*/$cf_example.[[01]]* $cf_dir/man*/$cf_example $cf_dir/cat*/$cf_example
5657                 do
5658                         cf_test=`echo "$cf_name" | sed -e 's/*//'`
5659                         if test "x$cf_test" = "x$cf_name" ; then
5660
5661                                 case "$cf_name" in
5662                                 (*.bz2) MANPAGE_FORMAT="$MANPAGE_FORMAT bzip2";;
5663                                 (*.xz)  MANPAGE_FORMAT="$MANPAGE_FORMAT xz";;
5664                                 (*.gz)  MANPAGE_FORMAT="$MANPAGE_FORMAT gzip";;
5665                                 (*.Z)   MANPAGE_FORMAT="$MANPAGE_FORMAT compress";;
5666                                 (*.0)   MANPAGE_FORMAT="$MANPAGE_FORMAT BSDI";;
5667                                 (*)     MANPAGE_FORMAT="$MANPAGE_FORMAT normal";;
5668                                 esac
5669
5670                                 case "$cf_name" in
5671                                 ($cf_dir/man*)
5672                                         cf_catonly=no
5673                                         ;;
5674                                 ($cf_dir/cat*)
5675                                         cf_preform=yes
5676                                         ;;
5677                                 esac
5678                                 break
5679                         fi
5680
5681                         # if we found a match in either man* or cat*, stop looking
5682                         if test -n "$MANPAGE_FORMAT" ; then
5683                                 cf_found=no
5684                                 test "$cf_preform" = yes && MANPAGE_FORMAT="$MANPAGE_FORMAT formatted"
5685                                 test "$cf_catonly" = yes && MANPAGE_FORMAT="$MANPAGE_FORMAT catonly"
5686                                 case "$cf_name" in
5687                                 ($cf_dir/cat*)
5688                                         cf_found=yes
5689                                         ;;
5690                                 esac
5691                                 test "$cf_found" = yes && break
5692                         fi
5693                 done
5694                 # only check the first directory in $MANPATH where we find manpages
5695                 if test -n "$MANPAGE_FORMAT" ; then
5696                         break
5697                 fi
5698         done
5699         # if we did not find the example, just assume it is normal
5700         test -z "$MANPAGE_FORMAT" && MANPAGE_FORMAT=normal
5701         IFS="$ac_save_ifs"
5702         ;;
5703 (*)
5704         for cf_option in $MANPAGE_FORMAT; do
5705         case "$cf_option" in
5706         (xz|bzip2|gzip|compress|BSDI|normal|formatted|catonly)
5707                 ;;
5708         (*)
5709                 cf_unknown="$cf_unknown $cf_option"
5710                 ;;
5711         esac
5712         done
5713         ;;
5714 esac
5715
5716 AC_MSG_RESULT($MANPAGE_FORMAT)
5717 if test -n "$cf_unknown" ; then
5718         AC_MSG_WARN(Unexpected manpage-format $cf_unknown)
5719 fi
5720
5721 cf_manpage_format=no
5722 cf_manpage_inboth=no
5723 cf_manpage_so_strip=
5724 cf_manpage_compress=
5725
5726 for cf_item in $MANPAGE_FORMAT
5727 do
5728 case "$cf_item" in
5729 (catonly)
5730         cf_manpage_format=yes
5731         cf_manpage_inboth=no
5732         ;;
5733 (formatted)
5734         cf_manpage_format=yes
5735         cf_manpage_inboth=yes
5736         ;;
5737 (compress)
5738         cf_manpage_so_strip="Z"
5739         cf_manpage_compress=compress
5740         ;;
5741 (gzip)
5742         cf_manpage_so_strip="gz"
5743         cf_manpage_compress=gzip
5744         ;;
5745 (bzip2)
5746         cf_manpage_so_strip="bz2"
5747         cf_manpage_compress=bzip2
5748         ;;
5749 (xz)
5750         cf_manpage_so_strip="xz"
5751         cf_manpage_compress=xz
5752         ;;
5753 esac
5754 done
5755
5756 ])dnl
5757 dnl ---------------------------------------------------------------------------
5758 dnl CF_MANPAGE_RENAMES version: 17 updated: 2022/10/23 07:46:29
5759 dnl ------------------
5760 dnl The Debian people have their own naming convention for manpages.  This
5761 dnl option lets us override the name of the file containing renaming, or
5762 dnl disable it altogether.
5763 AC_DEFUN([CF_MANPAGE_RENAMES],
5764 [
5765 AC_MSG_CHECKING(for manpage renaming)
5766
5767 AC_ARG_WITH(manpage-renames,
5768         [  --with-manpage-renames  specify manpage-renaming],
5769         [MANPAGE_RENAMES=$withval],
5770         [MANPAGE_RENAMES=yes])
5771
5772 case ".$MANPAGE_RENAMES" in
5773 (.no)
5774         ;;
5775 (.|.yes)
5776         # Debian 'man' program?
5777         if test -f /etc/debian_version ; then
5778                 MANPAGE_RENAMES=man/man_db.renames
5779         else
5780                 MANPAGE_RENAMES=no
5781         fi
5782         ;;
5783 esac
5784
5785 if test "$MANPAGE_RENAMES" = man/man_db.renames ; then
5786         MANPAGE_RENAMES=`pwd`/$MANPAGE_RENAMES
5787 elif test "$MANPAGE_RENAMES" = no ; then
5788         :
5789 elif test ! -f "$MANPAGE_RENAMES" ; then
5790         AC_MSG_ERROR(not a filename: $MANPAGE_RENAMES)
5791 fi
5792
5793 AC_MSG_RESULT($MANPAGE_RENAMES)
5794 AC_SUBST(MANPAGE_RENAMES)
5795 ])dnl
5796 dnl ---------------------------------------------------------------------------
5797 dnl CF_MANPAGE_SYMLINKS version: 7 updated: 2023/01/21 16:37:17
5798 dnl -------------------
5799 dnl Some people expect each tool to make all aliases for manpages in the
5800 dnl man-directory.  This accommodates the older, less-capable implementations
5801 dnl of 'man', and is optional.
5802 AC_DEFUN([CF_MANPAGE_SYMLINKS],
5803 [
5804 AC_MSG_CHECKING(if manpage aliases will be installed)
5805
5806 AC_ARG_WITH(manpage-aliases,
5807         [  --with-manpage-aliases  specify manpage-aliases using .so],
5808         [MANPAGE_ALIASES=$withval],
5809         [MANPAGE_ALIASES=yes])
5810
5811 AC_MSG_RESULT($MANPAGE_ALIASES)
5812
5813 case "x$LN_S" in
5814 (xln*)
5815         cf_use_symlinks=yes
5816         ;;
5817 (*)
5818         cf_use_symlinks=no
5819         ;;
5820 esac
5821
5822 MANPAGE_SYMLINKS=no
5823 if test "$MANPAGE_ALIASES" = yes ; then
5824 AC_MSG_CHECKING(if manpage symlinks should be used)
5825
5826 AC_ARG_WITH(manpage-symlinks,
5827         [  --with-manpage-symlinks specify manpage-aliases using symlinks],
5828         [MANPAGE_SYMLINKS=$withval],
5829         [MANPAGE_SYMLINKS=$cf_use_symlinks])
5830
5831 if test "$cf_use_symlinks" = no; then
5832 if test "$MANPAGE_SYMLINKS" = yes ; then
5833         AC_MSG_WARN(cannot make symlinks, will use .so files)
5834         MANPAGE_SYMLINKS=no
5835 fi
5836 fi
5837
5838 AC_MSG_RESULT($MANPAGE_SYMLINKS)
5839 fi
5840
5841 ])dnl
5842 dnl ---------------------------------------------------------------------------
5843 dnl CF_MANPAGE_TBL version: 3 updated: 2002/01/19 22:51:32
5844 dnl --------------
5845 dnl This option causes manpages to be run through tbl(1) to generate tables
5846 dnl correctly.
5847 AC_DEFUN([CF_MANPAGE_TBL],
5848 [
5849 AC_MSG_CHECKING(for manpage tbl)
5850
5851 AC_ARG_WITH(manpage-tbl,
5852         [  --with-manpage-tbl      specify manpage processing with tbl],
5853         [MANPAGE_TBL=$withval],
5854         [MANPAGE_TBL=no])
5855
5856 AC_MSG_RESULT($MANPAGE_TBL)
5857 ])dnl
5858 dnl ---------------------------------------------------------------------------
5859 dnl CF_MAN_PAGES version: 56 updated: 2023/01/21 16:49:25
5860 dnl ------------
5861 dnl Try to determine if the man-pages on the system are compressed, and if
5862 dnl so, what format is used.  Use this information to construct a script that
5863 dnl will install man-pages.
5864 AC_DEFUN([CF_MAN_PAGES],
5865 [
5866 CF_HELP_MESSAGE(Options to Specify How Manpages are Installed:)
5867 CF_MANPAGE_FORMAT
5868 CF_MANPAGE_RENAMES
5869 CF_MANPAGE_SYMLINKS
5870 CF_MANPAGE_TBL
5871
5872 if test "$prefix" = "NONE" ; then
5873         cf_prefix="$ac_default_prefix"
5874 else
5875         cf_prefix="$prefix"
5876 fi
5877
5878 test ! -d man && mkdir man
5879
5880 cf_edit_man=./edit_man.sh
5881 cf_man_alias=`pwd`/man_alias.sed
5882
5883 cat >$cf_edit_man <<CF_EOF
5884 #! $SHELL
5885 # this script is generated by the configure-script CF_MAN_PAGES macro.
5886
5887 prefix="$cf_prefix"
5888 datarootdir="$datarootdir"
5889 datadir="$datadir"
5890
5891 NCURSES_MAJOR="$NCURSES_MAJOR"
5892 NCURSES_MINOR="$NCURSES_MINOR"
5893 NCURSES_PATCH="$NCURSES_PATCH"
5894
5895 NCURSES_OSPEED="$NCURSES_OSPEED"
5896 TERMINFO="$TERMINFO"
5897
5898 INSTALL="$INSTALL"
5899 INSTALL_DATA="$INSTALL_DATA"
5900
5901 transform="$program_transform_name"
5902
5903 TMP=\${TMPDIR:=/tmp}/man\$\$
5904 trap "rm -f \$TMP; exit 1" 1 2 3 15
5905 trap "rm -f \$TMP" 0
5906
5907 form=\[$]1
5908 shift || exit 1
5909
5910 verb=\[$]1
5911 shift || exit 1
5912
5913 mandir=\[$]1
5914 shift || exit 1
5915
5916 srcdir=\[$]1
5917 top_srcdir=\[$]srcdir/..
5918 shift || exit 1
5919
5920 if test "\$form" = normal ; then
5921         if test "$cf_manpage_format" = yes ; then
5922         if test "$cf_manpage_inboth" = no ; then
5923                 $SHELL "\[$]0" format "\$verb" "\$mandir" "\$srcdir" "\[$]@"
5924                 exit $?
5925         fi
5926         fi
5927         cf_subdir=\$mandir/man
5928         cf_tables=$MANPAGE_TBL
5929 else
5930         cf_subdir=\$mandir/cat
5931         cf_tables=yes
5932 fi
5933
5934 # process the list of source-files
5935 for i in "\[$]@" ; do
5936 case \$i in
5937 (*.orig|*.rej) ;;
5938 (*.[[0-9]]*)
5939         section=\`expr "\$i" : '.*\\.\\([[0-9]]\\)[[xm]]*'\`;
5940         if test "\$verb" = installing ; then
5941         if test ! -d "\$cf_subdir\${section}" ; then
5942                 mkdir -p "\$cf_subdir\$section"
5943         fi
5944         fi
5945
5946         # replace variables in man page
5947         if test ! -f "$cf_man_alias" ; then
5948 cat >>$cf_man_alias <<-CF_EOF2
5949                 s,@DATADIR@,\$datadir,g
5950                 s,@TERMINFO@,\${TERMINFO:="no default value"},g
5951                 s,@TERMINFO_DIRS@,\${TERMINFO_DIRS:="no default value"},g
5952                 s,@NCURSES_MAJOR@,\${NCURSES_MAJOR:="no default value"},g
5953                 s,@NCURSES_MINOR@,\${NCURSES_MINOR:="no default value"},g
5954                 s,@NCURSES_PATCH@,\${NCURSES_PATCH:="no default value"},g
5955                 s,@NCURSES_OSPEED@,\${NCURSES_OSPEED:="no default value"},g
5956 CF_EOF
5957         ifelse($1,,,[
5958         for cf_name in $1
5959         do
5960                 cf_NAME=`echo "$cf_name" | sed y%abcdefghijklmnopqrstuvwxyz./-%ABCDEFGHIJKLMNOPQRSTUVWXYZ___%`
5961                 cf_name=`echo "$cf_name" | sed "$program_transform_name"`
5962 cat >>$cf_edit_man <<-CF_EOF
5963                 s,@$cf_NAME@,$cf_name,g
5964 CF_EOF
5965         done
5966         ])
5967 cat >>$cf_edit_man <<CF_EOF
5968 CF_EOF2
5969                 echo "...made $cf_man_alias"
5970         fi
5971
5972         aliases=
5973         cf_source=\`basename "\$i"\`
5974         cf_full_alias=\$cf_source
5975         test ! -f "\$cf_full_alias" && cf_full_alias="\$srcdir/\$cf_full_alias"
5976         if test ! -f "\$cf_full_alias" ; then
5977                 echo ".. skipped \$cf_source"
5978                 continue
5979         fi
5980 CF_EOF
5981
5982 if test "$MANPAGE_ALIASES" != no ; then
5983 cat >>$cf_edit_man <<CF_EOF
5984         nCurses=ignore.3x
5985         cf_part_alias=\`echo \$cf_full_alias| sed -e 's,^.*/,,'\`
5986         test "$with_curses_h" = yes && nCurses=ncurses.3x
5987         aliases=\`sed -f "\$top_srcdir/man/manlinks.sed" "\$cf_full_alias" |sed -f "$cf_man_alias" | sort -u; test "\$cf_part_alias" = "\$nCurses" && echo curses\`
5988 CF_EOF
5989 fi
5990
5991 if test "$MANPAGE_RENAMES" = no ; then
5992 cat >>$cf_edit_man <<CF_EOF
5993         # perform program transformations for section 1 man pages
5994         if test \$section = 1 ; then
5995                 cf_target=\$cf_subdir\${section}/\`echo \$cf_source|sed "\${transform}"\`
5996         else
5997                 cf_target=\$cf_subdir\${section}/\$cf_source
5998         fi
5999 CF_EOF
6000 else
6001 cat >>$cf_edit_man <<CF_EOF
6002         cf_target=\`grep "^\$cf_source" $MANPAGE_RENAMES | $AWK '{print \[$]2}'\`
6003         if test -z "\$cf_target" ; then
6004                 echo "? missing rename for \$cf_source"
6005                 cf_target="\$cf_source"
6006         fi
6007         cf_target="\$cf_subdir\${section}/\${cf_target}"
6008
6009 CF_EOF
6010 fi
6011
6012 cat >>$cf_edit_man <<CF_EOF
6013         sed     -f "$cf_man_alias" \\
6014 CF_EOF
6015
6016 if test "$MANPAGE_RENAMES" != no ; then
6017 cat >>$cf_edit_man <<CF_EOF
6018                 < "\$i" | sed -f `pwd`/edit_man.sed >\$TMP
6019 CF_EOF
6020 else
6021 cat >>$cf_edit_man <<CF_EOF
6022                 < "\$i" >\$TMP
6023 CF_EOF
6024 fi
6025
6026 cat >>$cf_edit_man <<CF_EOF
6027 if test \$cf_tables = yes ; then
6028         tbl \$TMP >\$TMP.out
6029         mv \$TMP.out \$TMP
6030 fi
6031 CF_EOF
6032
6033 if test "$with_overwrite" != yes ; then
6034 cat >>$cf_edit_man <<CF_EOF
6035         sed -e "/\\#[    ]*include/s,<curses.h,<ncurses$LIB_SUFFIX/curses.h," < \$TMP >\$TMP.out
6036         mv \$TMP.out \$TMP
6037 CF_EOF
6038 fi
6039
6040 if test "$with_curses_h" != yes ; then
6041 cat >>$cf_edit_man <<CF_EOF
6042         sed -e "/\\#[    ]*include/s,curses.h,ncurses.h," < \$TMP >\$TMP.out
6043         mv \$TMP.out \$TMP
6044 CF_EOF
6045 fi
6046
6047 cat >>$cf_edit_man <<CF_EOF
6048         if test "\$form" = format ; then
6049                 nroff -man \$TMP >\$TMP.out
6050                 mv \$TMP.out \$TMP
6051         fi
6052 CF_EOF
6053
6054 if test -n "$cf_manpage_compress" ; then
6055 cat >>$cf_edit_man <<CF_EOF
6056         if test "\$verb" = installing ; then
6057         if ( "$cf_manpage_compress" -f \$TMP )
6058         then
6059                 mv \$TMP.$cf_manpage_so_strip \$TMP
6060         fi
6061         fi
6062         cf_target="\$cf_target.$cf_manpage_so_strip"
6063 CF_EOF
6064 fi
6065
6066 case "$MANPAGE_FORMAT" in
6067 (*BSDI*)
6068 cat >>$cf_edit_man <<CF_EOF
6069         if test "\$form" = format ; then
6070                 # BSDI installs only .0 suffixes in the cat directories
6071                 cf_target="\`echo \$cf_target|sed -e 's/\\.[[1-9]]\\+[[a-z]]*/.0/'\`"
6072         fi
6073 CF_EOF
6074   ;;
6075 esac
6076
6077 cat >>$cf_edit_man <<CF_EOF
6078         suffix=\`basename "\$cf_target" | sed -e 's%^[[^.]]*%%'\`
6079         if test "\$verb" = installing ; then
6080                 echo "\$verb \$cf_target"
6081                 \$INSTALL_DATA \$TMP "\$cf_target"
6082                 test -d "\$cf_subdir\${section}" &&
6083                 test -n "\$aliases" && (
6084                         cd "\$cf_subdir\${section}" && (
6085                                 cf_source=\`echo "\$cf_target" |sed -e 's%^.*/\\([[^/]][[^/]]*/[[^/]][[^/]]*$\\)%\\1%'\`
6086                                 test -n "$cf_manpage_so_strip" && cf_source=\`echo "\$cf_source" |sed -e 's%\\.$cf_manpage_so_strip\$%%'\`
6087                                 cf_target=\`basename "\$cf_target"\`
6088                                 for cf_alias in \$aliases
6089                                 do
6090                                         if test "\$section" = 1 ; then
6091                                                 cf_alias=\`echo "\$cf_alias" |sed "\${transform}"\`
6092                                         fi
6093
6094                                         if test "$MANPAGE_SYMLINKS" = yes ; then
6095                                                 if test -f "\$cf_alias\${suffix}" ; then
6096                                                         if ( cmp -s "\$cf_target" "\$cf_alias\${suffix}" )
6097                                                         then
6098                                                                 continue
6099                                                         fi
6100                                                 fi
6101                                                 echo ".. \$verb alias \$cf_alias\${suffix}"
6102 CF_EOF
6103 case "x$LN_S" in
6104 (*-f)
6105 cat >>$cf_edit_man <<CF_EOF
6106                                                 $LN_S "\$cf_target" "\$cf_alias\${suffix}"
6107 CF_EOF
6108         ;;
6109 (*)
6110 cat >>$cf_edit_man <<CF_EOF
6111                                                 rm -f "\$cf_alias\${suffix}"
6112                                                 $LN_S "\$cf_target" "\$cf_alias\${suffix}"
6113 CF_EOF
6114         ;;
6115 esac
6116 cat >>$cf_edit_man <<CF_EOF
6117                                         elif test "\$cf_target" != "\$cf_alias\${suffix}" ; then
6118                                                 echo ".so \$cf_source" >\$TMP
6119 CF_EOF
6120 if test -n "$cf_manpage_compress" ; then
6121 cat >>$cf_edit_man <<CF_EOF
6122                                                 if test -n "$cf_manpage_so_strip" ; then
6123                                                         "$cf_manpage_compress" -f \$TMP
6124                                                         mv \$TMP.$cf_manpage_so_strip \$TMP
6125                                                 fi
6126 CF_EOF
6127 fi
6128 cat >>$cf_edit_man <<CF_EOF
6129                                                 echo ".. \$verb alias \$cf_alias\${suffix}"
6130                                                 rm -f "\$cf_alias\${suffix}"
6131                                                 \$INSTALL_DATA \$TMP "\$cf_alias\${suffix}"
6132                                         fi
6133                                 done
6134                         )
6135                 )
6136         elif test "\$verb" = removing ; then
6137                 test -f "\$cf_target" && (
6138                         echo "\$verb \$cf_target"
6139                         rm -f "\$cf_target"
6140                 )
6141                 test -d "\$cf_subdir\${section}" &&
6142                 test -n "\$aliases" && (
6143                         cd "\$cf_subdir\${section}" && (
6144                                 for cf_alias in \$aliases
6145                                 do
6146                                         if test "\$section" = 1 ; then
6147                                                 cf_alias=\`echo "\$cf_alias" |sed "\${transform}"\`
6148                                         fi
6149
6150                                         echo ".. \$verb alias \$cf_alias\${suffix}"
6151                                         rm -f "\$cf_alias\${suffix}"
6152                                 done
6153                         )
6154                 )
6155         else
6156 #               echo ".hy 0"
6157                 cat \$TMP
6158         fi
6159         ;;
6160 esac
6161 done
6162
6163 if test "$cf_manpage_inboth" = yes ; then
6164 if test "\$form" != format ; then
6165         $SHELL "\[$]0" format "\$verb" "\$mandir" "\$srcdir" "\[$]@"
6166 fi
6167 fi
6168
6169 exit 0
6170 CF_EOF
6171 chmod 755 "$cf_edit_man"
6172
6173 ])dnl
6174 dnl ---------------------------------------------------------------------------
6175 dnl CF_MAP_LIB_BASENAME version: 2 updated: 2021/01/02 17:09:14
6176 dnl -------------------
6177 dnl Convert a default-libname to the actual one used via CF_WITH_LIB_BASENAME.
6178 dnl
6179 dnl $1 = variable to set
6180 dnl $2 = default-libname
6181 AC_DEFUN([CF_MAP_LIB_BASENAME],[
6182 CF_UPPER(cf_map_lib_basename,$2)
6183 eval $1="\$${cf_map_lib_basename}_NAME"
6184 ])dnl
6185 dnl ---------------------------------------------------------------------------
6186 dnl CF_MATH_LIB version: 11 updated: 2022/07/27 19:01:48
6187 dnl -----------
6188 dnl Checks for libraries.  At least one UNIX system, Apple Macintosh
6189 dnl Rhapsody 5.5, does not have -lm.  We cannot use the simpler
6190 dnl AC_CHECK_LIB(m,sin), because that fails for C++.
6191 AC_DEFUN([CF_MATH_LIB],
6192 [
6193 AC_CACHE_CHECK(if -lm needed for math functions,
6194         cf_cv_need_libm,[
6195         AC_TRY_LINK([
6196                 #include <stdio.h>
6197                 #include <stdlib.h>
6198                 #include <math.h>
6199         ],
6200         [double x = rand(); printf("result = %g\\n", ]ifelse([$2],,sin(x),$2)[)],
6201         [cf_cv_need_libm=no],
6202         [cf_cv_need_libm=yes])])
6203
6204 if test "$cf_cv_need_libm" = yes
6205 then
6206
6207         cf_save_LIBS="$LIBS"
6208         LIBS="$LIBS -lm"
6209         AC_CACHE_CHECK(if -lm is available for math functions,
6210         cf_cv_have_libm,[
6211         AC_TRY_LINK([
6212                 #include <stdio.h>
6213                 #include <stdlib.h>
6214                 #include <math.h>
6215         ],
6216         [double x = rand(); printf("result = %g\\n", ]ifelse([$2],,sin(x),$2)[)],
6217         [cf_cv_have_libm=yes],
6218         [cf_cv_have_libm=no])])
6219         LIBS="$cf_save_LIBS"
6220
6221         if test "$cf_cv_have_libm" = yes
6222         then
6223                 ifelse($1,,[CF_ADD_LIB(m)],[$1=-lm])
6224         fi
6225 else
6226         cf_cv_have_libm=yes
6227 fi
6228
6229 if test "$cf_cv_have_libm" = yes
6230 then
6231         AC_DEFINE(HAVE_MATH_FUNCS,1,[Define to 1 if math functions are available])
6232 fi
6233 ])
6234 dnl ---------------------------------------------------------------------------
6235 dnl CF_MIXEDCASE_FILENAMES version: 9 updated: 2021/01/01 16:53:59
6236 dnl ----------------------
6237 dnl Check if the file-system supports mixed-case filenames.  If we're able to
6238 dnl create a lowercase name and see it as uppercase, it doesn't support that.
6239 AC_DEFUN([CF_MIXEDCASE_FILENAMES],
6240 [
6241 AC_CACHE_CHECK(if filesystem supports mixed-case filenames,cf_cv_mixedcase,[
6242 if test "$cross_compiling" = yes ; then
6243         case "$target_alias" in
6244         (*-os2-emx*|*-msdosdjgpp*|*-cygwin*|*-msys*|*-mingw*|*-uwin*|darwin*)
6245                 cf_cv_mixedcase=no
6246                 ;;
6247         (*)
6248                 cf_cv_mixedcase=yes
6249                 ;;
6250         esac
6251 else
6252         rm -f conftest CONFTEST
6253         echo test >conftest
6254         if test -f CONFTEST ; then
6255                 cf_cv_mixedcase=no
6256         else
6257                 cf_cv_mixedcase=yes
6258         fi
6259         rm -f conftest CONFTEST
6260 fi
6261 ])
6262 test "$cf_cv_mixedcase" = yes && AC_DEFINE(MIXEDCASE_FILENAMES,1,[Define to 1 if filesystem supports mixed-case filenames.])
6263 ])dnl
6264 dnl ---------------------------------------------------------------------------
6265 dnl CF_MKSTEMP version: 12 updated: 2023/01/05 17:53:11
6266 dnl ----------
6267 dnl Check for a working mkstemp.  This creates two files, checks that they are
6268 dnl successfully created and distinct (AmigaOS apparently fails on the last).
6269 AC_DEFUN([CF_MKSTEMP],[
6270 AC_CHECK_HEADERS( \
6271 unistd.h \
6272 )
6273 AC_CACHE_CHECK(for working mkstemp, cf_cv_func_mkstemp,[
6274 rm -rf ./conftest*
6275 AC_TRY_RUN([
6276 $ac_includes_default
6277
6278 int main(void)
6279 {
6280         char *tmpl = "conftestXXXXXX";
6281         char name[2][80];
6282         int n;
6283         int result = 0;
6284         int fd;
6285         struct stat sb;
6286
6287         umask(077);
6288         for (n = 0; n < 2; ++n) {
6289                 strcpy(name[n], tmpl);
6290                 if ((fd = mkstemp(name[n])) >= 0) {
6291                         if (!strcmp(name[n], tmpl)
6292                          || stat(name[n], &sb) != 0
6293                          || (sb.st_mode & S_IFMT) != S_IFREG
6294                          || (sb.st_mode & 077) != 0) {
6295                                 result = 1;
6296                         }
6297                         close(fd);
6298                 }
6299         }
6300         if (result == 0
6301          && !strcmp(name[0], name[1]))
6302                 result = 1;
6303         ${cf_cv_main_return:-return}(result);
6304 }
6305 ],[cf_cv_func_mkstemp=yes
6306 ],[cf_cv_func_mkstemp=no
6307 ],[cf_cv_func_mkstemp=maybe])
6308 ])
6309 if test "x$cf_cv_func_mkstemp" = xmaybe ; then
6310         AC_CHECK_FUNC(mkstemp)
6311 fi
6312 if test "x$cf_cv_func_mkstemp" = xyes || test "x$ac_cv_func_mkstemp" = xyes ; then
6313         AC_DEFINE(HAVE_MKSTEMP,1,[Define to 1 if mkstemp() is available and working.])
6314 fi
6315 ])dnl
6316 dnl ---------------------------------------------------------------------------
6317 dnl CF_MSG_LOG version: 5 updated: 2010/10/23 15:52:32
6318 dnl ----------
6319 dnl Write a debug message to config.log, along with the line number in the
6320 dnl configure script.
6321 AC_DEFUN([CF_MSG_LOG],[
6322 echo "${as_me:-configure}:__oline__: testing $* ..." 1>&AC_FD_CC
6323 ])dnl
6324 dnl ---------------------------------------------------------------------------
6325 dnl CF_NCURSES_ABI_6 version: 5 updated: 2023/01/07 16:32:06
6326 dnl ----------------
6327 dnl Set ncurses' ABI to 6 unless overridden by explicit configure option, and
6328 dnl warn about this.
6329 AC_DEFUN([CF_NCURSES_ABI_6],[
6330 if test "${with_abi_version+set}" != set; then
6331         case "$cf_cv_rel_version" in
6332         (5.*)
6333                 cf_cv_rel_version=6.0
6334                 cf_cv_abi_version=6
6335                 cf_cv_abi_default=6
6336                 AC_MSG_WARN(overriding ABI version to $cf_cv_abi_default)
6337                 ;;
6338         esac
6339 fi
6340 ])dnl
6341 dnl ---------------------------------------------------------------------------
6342 dnl CF_NCURSES_WITH_ABI_VERSION version: 3 updated: 2021/01/01 13:31:04
6343 dnl ---------------------------
6344 dnl Allow ncurses's ABI to be overridden.  Generally this happens when a
6345 dnl packager has incremented the ABI past that used in the original package,
6346 dnl and wishes to keep doing this.
6347 dnl
6348 dnl $1 is the package name, if any, to derive a corresponding {package}_ABI
6349 dnl symbol.
6350 AC_DEFUN([CF_NCURSES_WITH_ABI_VERSION],[
6351 CF_WITH_ABI_VERSION($1)
6352 if test "x$cf_cv_abi_version" != "x$with_abi_version"
6353 then
6354         case "$cf_cv_rel_version" in
6355         (5.*)
6356                 cf_cv_rel_version=$with_abi_version.0
6357                 ;;
6358         esac
6359 fi
6360 ])dnl
6361 dnl ---------------------------------------------------------------------------
6362 dnl CF_NO_LEAKS_OPTION version: 9 updated: 2021/06/13 19:45:41
6363 dnl ------------------
6364 dnl see CF_WITH_NO_LEAKS
6365 dnl
6366 dnl $1 = option/name
6367 dnl $2 = help-text
6368 dnl $3 = symbol to define if the option is set
6369 dnl $4 = additional actions to take if the option is set
6370 AC_DEFUN([CF_NO_LEAKS_OPTION],[
6371 AC_MSG_CHECKING(if you want to use $1 for testing)
6372 AC_ARG_WITH($1,
6373         [$2],
6374         [case "x$withval" in
6375         (x|xno) ;;
6376         (*)
6377                 : "${with_cflags:=-g}"
6378                 : "${enable_leaks:=no}"
6379                 with_$1=yes
6380                 AC_DEFINE_UNQUOTED($3,1,"Define to 1 if you want to use $1 for testing.")ifelse([$4],,[
6381          $4
6382 ])
6383                 ;;
6384         esac],
6385         [with_$1=])
6386 AC_MSG_RESULT(${with_$1:-no})
6387
6388 case ".$with_cflags" in
6389 (.*-g*)
6390         case .$CFLAGS in
6391         (.*-g*)
6392                 ;;
6393         (*)
6394                 CF_ADD_CFLAGS([-g])
6395                 ;;
6396         esac
6397         ;;
6398 esac
6399 ])dnl
6400 dnl ---------------------------------------------------------------------------
6401 dnl CF_NUMBER_SYNTAX version: 2 updated: 2015/04/17 21:13:04
6402 dnl ----------------
6403 dnl Check if the given variable is a number.  If not, report an error.
6404 dnl $1 is the variable
6405 dnl $2 is the message
6406 AC_DEFUN([CF_NUMBER_SYNTAX],[
6407 if test -n "$1" ; then
6408   case $1 in
6409   ([[0-9]]*)
6410         ;;
6411   (*)
6412         AC_MSG_ERROR($2 is not a number: $1)
6413         ;;
6414   esac
6415 else
6416   AC_MSG_ERROR($2 value is empty)
6417 fi
6418 ])dnl
6419 dnl ---------------------------------------------------------------------------
6420 dnl CF_OBJ_SUBDIR version: 8 updated: 2021/01/01 13:31:04
6421 dnl -------------
6422 dnl Compute the object-directory name from the given model name
6423 AC_DEFUN([CF_OBJ_SUBDIR],
6424 [
6425         case $1 in
6426         (libtool) $2='obj_lo'  ;;
6427         (normal)  $2='objects' ;;
6428         (debug)   $2='obj_g' ;;
6429         (profile) $2='obj_p' ;;
6430         (shared)
6431                 case "$cf_cv_system_name" in
6432                 (cygwin|msys)
6433                         $2='objects' ;;
6434                 (*)
6435                         $2='obj_s' ;;
6436                 esac
6437         esac
6438 ])dnl
6439 dnl ---------------------------------------------------------------------------
6440 dnl CF_OUTPUT_MANPAGE_RENAMES version: 2 updated: 2022/10/22 19:12:31
6441 dnl -------------------------
6442 dnl This runs in the output step to config.status, after man_db.renames has
6443 dnl been generated.
6444 AC_DEFUN([CF_OUTPUT_MANPAGE_RENAMES],
6445 [
6446 AC_REQUIRE([CF_MANPAGE_RENAMES])
6447 if test "$MANPAGE_RENAMES" != no ; then
6448         # Construct a sed-script to perform renaming within man-pages
6449         test -n "$verbose" && echo "creating edit_man.sed"
6450         test ! -d man && mkdir man
6451         FGREP="${FGREP-grep -F}" $SHELL "$srcdir/man/make_sed.sh" "$MANPAGE_RENAMES" >./edit_man.sed
6452 fi
6453 ])dnl
6454 dnl ---------------------------------------------------------------------------
6455 dnl CF_PATHSEP version: 8 updated: 2021/01/01 13:31:04
6456 dnl ----------
6457 dnl Provide a value for the $PATH and similar separator (or amend the value
6458 dnl as provided in autoconf 2.5x).
6459 AC_DEFUN([CF_PATHSEP],
6460 [
6461         AC_MSG_CHECKING(for PATH separator)
6462         case "$cf_cv_system_name" in
6463         (os2*)  PATH_SEPARATOR=';'  ;;
6464         (*)     ${PATH_SEPARATOR:=':'}  ;;
6465         esac
6466 ifelse([$1],,,[$1=$PATH_SEPARATOR])
6467         AC_SUBST(PATH_SEPARATOR)
6468         AC_MSG_RESULT($PATH_SEPARATOR)
6469 ])dnl
6470 dnl ---------------------------------------------------------------------------
6471 dnl CF_PATH_PROG version: 12 updated: 2021/01/02 09:31:20
6472 dnl ------------
6473 dnl Check for a given program, defining corresponding symbol.
6474 dnl     $1 = environment variable, which is suffixed by "_PATH" in the #define.
6475 dnl     $2 = program name to find.
6476 dnl     $3 = optional list of additional program names to test.
6477 dnl $4 = $PATH
6478 dnl
6479 dnl If there is more than one token in the result, #define the remaining tokens
6480 dnl to $1_ARGS.  We need this for 'install' in particular.
6481 dnl
6482 dnl FIXME: we should allow this to be overridden by environment variables
6483 dnl
6484 AC_DEFUN([CF_PATH_PROG],[
6485 AC_REQUIRE([CF_PATHSEP])
6486 test -z "[$]$1" && $1="$2"
6487 AC_PATH_PROGS($1,[$]$1 $2 ifelse($3,,,$3),[$]$1, ifelse($4,,,$4))
6488
6489 cf_path_prog=""
6490 cf_path_args=""
6491 IFS="${IFS:-    }"; cf_save_ifs="$IFS"; IFS="${IFS}$PATH_SEPARATOR"
6492 for cf_temp in $ac_cv_path_$1
6493 do
6494         if test -z "$cf_path_prog" ; then
6495                 if test "$with_full_paths" = yes ; then
6496                         CF_PATH_SYNTAX(cf_temp,break)
6497                         cf_path_prog="$cf_temp"
6498                 else
6499                         cf_path_prog="`basename "$cf_temp"`"
6500                 fi
6501         elif test -z "$cf_path_args" ; then
6502                 cf_path_args="$cf_temp"
6503         else
6504                 cf_path_args="$cf_path_args $cf_temp"
6505         fi
6506 done
6507 IFS="$cf_save_ifs"
6508
6509 if test -n "$cf_path_prog" ; then
6510         CF_MSG_LOG(defining path for ${cf_path_prog})
6511         AC_DEFINE_UNQUOTED($1_PATH,"$cf_path_prog",Define to pathname $1)
6512         test -n "$cf_path_args" && AC_DEFINE_UNQUOTED($1_ARGS,"$cf_path_args",Define to provide args for $1)
6513 fi
6514 ])dnl
6515 dnl ---------------------------------------------------------------------------
6516 dnl CF_PATH_SYNTAX version: 18 updated: 2020/12/31 18:40:20
6517 dnl --------------
6518 dnl Check the argument to see that it looks like a pathname.  Rewrite it if it
6519 dnl begins with one of the prefix/exec_prefix variables, and then again if the
6520 dnl result begins with 'NONE'.  This is necessary to work around autoconf's
6521 dnl delayed evaluation of those symbols.
6522 AC_DEFUN([CF_PATH_SYNTAX],[
6523 if test "x$prefix" != xNONE; then
6524         cf_path_syntax="$prefix"
6525 else
6526         cf_path_syntax="$ac_default_prefix"
6527 fi
6528
6529 case ".[$]$1" in
6530 (.\[$]\(*\)*|.\'*\'*)
6531         ;;
6532 (..|./*|.\\*)
6533         ;;
6534 (.[[a-zA-Z]]:[[\\/]]*) # OS/2 EMX
6535         ;;
6536 (.\[$]\{*prefix\}*|.\[$]\{*dir\}*)
6537         eval $1="[$]$1"
6538         case ".[$]$1" in
6539         (.NONE/*)
6540                 $1=`echo "[$]$1" | sed -e s%NONE%$cf_path_syntax%`
6541                 ;;
6542         esac
6543         ;;
6544 (.no|.NONE/*)
6545         $1=`echo "[$]$1" | sed -e s%NONE%$cf_path_syntax%`
6546         ;;
6547 (*)
6548         ifelse([$2],,[AC_MSG_ERROR([expected a pathname, not \"[$]$1\"])],$2)
6549         ;;
6550 esac
6551 ])dnl
6552 dnl ---------------------------------------------------------------------------
6553 dnl CF_PKG_CONFIG version: 12 updated: 2021/10/10 20:18:09
6554 dnl -------------
6555 dnl Check for the package-config program, unless disabled by command-line.
6556 dnl
6557 dnl Sets $PKG_CONFIG to the pathname of the pkg-config program.
6558 AC_DEFUN([CF_PKG_CONFIG],
6559 [
6560 AC_MSG_CHECKING(if you want to use pkg-config)
6561 AC_ARG_WITH(pkg-config,
6562         [  --with-pkg-config{=path} enable/disable use of pkg-config],
6563         [cf_pkg_config=$withval],
6564         [cf_pkg_config=yes])
6565 AC_MSG_RESULT($cf_pkg_config)
6566
6567 case "$cf_pkg_config" in
6568 (no)
6569         PKG_CONFIG=none
6570         ;;
6571 (yes)
6572         CF_ACVERSION_CHECK(2.52,
6573                 [AC_PATH_TOOL(PKG_CONFIG, pkg-config, none)],
6574                 [AC_PATH_PROG(PKG_CONFIG, pkg-config, none)])
6575         ;;
6576 (*)
6577         PKG_CONFIG=$withval
6578         ;;
6579 esac
6580
6581 test -z "$PKG_CONFIG" && PKG_CONFIG=none
6582 if test "$PKG_CONFIG" != none ; then
6583         CF_PATH_SYNTAX(PKG_CONFIG)
6584 elif test "x$cf_pkg_config" != xno ; then
6585         AC_MSG_WARN(pkg-config is not installed)
6586 fi
6587
6588 AC_SUBST(PKG_CONFIG)
6589 ])dnl
6590 dnl ---------------------------------------------------------------------------
6591 dnl CF_POSIX_C_SOURCE version: 12 updated: 2023/02/18 17:41:25
6592 dnl -----------------
6593 dnl Define _POSIX_C_SOURCE to the given level, and _POSIX_SOURCE if needed.
6594 dnl
6595 dnl     POSIX.1-1990                            _POSIX_SOURCE
6596 dnl     POSIX.1-1990 and                        _POSIX_SOURCE and
6597 dnl             POSIX.2-1992 C-Language                 _POSIX_C_SOURCE=2
6598 dnl             Bindings Option
6599 dnl     POSIX.1b-1993                           _POSIX_C_SOURCE=199309L
6600 dnl     POSIX.1c-1996                           _POSIX_C_SOURCE=199506L
6601 dnl     X/Open 2000                             _POSIX_C_SOURCE=200112L
6602 dnl
6603 dnl Parameters:
6604 dnl     $1 is the nominal value for _POSIX_C_SOURCE
6605 AC_DEFUN([CF_POSIX_C_SOURCE],
6606 [AC_REQUIRE([CF_POSIX_VISIBLE])dnl
6607
6608 if test "$cf_cv_posix_visible" = no; then
6609
6610 cf_POSIX_C_SOURCE=ifelse([$1],,199506L,[$1])
6611
6612 cf_save_CFLAGS="$CFLAGS"
6613 cf_save_CPPFLAGS="$CPPFLAGS"
6614
6615 CF_REMOVE_DEFINE(cf_trim_CFLAGS,$cf_save_CFLAGS,_POSIX_C_SOURCE)
6616 CF_REMOVE_DEFINE(cf_trim_CPPFLAGS,$cf_save_CPPFLAGS,_POSIX_C_SOURCE)
6617
6618 AC_CACHE_CHECK(if we should define _POSIX_C_SOURCE,cf_cv_posix_c_source,[
6619         CF_MSG_LOG(if the symbol is already defined go no further)
6620         AC_TRY_COMPILE([#include <sys/types.h>],[
6621 #ifndef _POSIX_C_SOURCE
6622 #error _POSIX_C_SOURCE is not defined
6623 #endif],
6624         [cf_cv_posix_c_source=no],
6625         [cf_want_posix_source=no
6626          case .$cf_POSIX_C_SOURCE in
6627          (.[[12]]??*)
6628                 cf_cv_posix_c_source="-D_POSIX_C_SOURCE=$cf_POSIX_C_SOURCE"
6629                 ;;
6630          (.2)
6631                 cf_cv_posix_c_source="-D_POSIX_C_SOURCE=$cf_POSIX_C_SOURCE"
6632                 cf_want_posix_source=yes
6633                 ;;
6634          (.*)
6635                 cf_want_posix_source=yes
6636                 ;;
6637          esac
6638          if test "$cf_want_posix_source" = yes ; then
6639                 AC_TRY_COMPILE([#include <sys/types.h>],[
6640 #ifdef _POSIX_SOURCE
6641 #error _POSIX_SOURCE is defined
6642 #endif],[],
6643                 cf_cv_posix_c_source="$cf_cv_posix_c_source -D_POSIX_SOURCE")
6644          fi
6645          CF_MSG_LOG(ifdef from value $cf_POSIX_C_SOURCE)
6646          CFLAGS="$cf_trim_CFLAGS"
6647          CPPFLAGS="$cf_trim_CPPFLAGS"
6648          CF_APPEND_TEXT(CPPFLAGS,$cf_cv_posix_c_source)
6649          CF_MSG_LOG(if the second compile does not leave our definition intact error)
6650          AC_TRY_COMPILE([#include <sys/types.h>],[
6651 #ifndef _POSIX_C_SOURCE
6652 #error _POSIX_C_SOURCE is not defined
6653 #endif],,
6654          [cf_cv_posix_c_source=no])
6655          CFLAGS="$cf_save_CFLAGS"
6656          CPPFLAGS="$cf_save_CPPFLAGS"
6657         ])
6658 ])
6659
6660 if test "$cf_cv_posix_c_source" != no ; then
6661         CFLAGS="$cf_trim_CFLAGS"
6662         CPPFLAGS="$cf_trim_CPPFLAGS"
6663         CF_ADD_CFLAGS($cf_cv_posix_c_source)
6664 fi
6665
6666 fi # cf_cv_posix_visible
6667
6668 ])dnl
6669 dnl ---------------------------------------------------------------------------
6670 dnl CF_POSIX_VISIBLE version: 1 updated: 2018/12/31 20:46:17
6671 dnl ----------------
6672 dnl POSIX documents test-macros which an application may set before any system
6673 dnl headers are included to make features available.
6674 dnl
6675 dnl Some BSD platforms (originally FreeBSD, but copied by a few others)
6676 dnl diverged from POSIX in 2002 by setting symbols which make all of the most
6677 dnl recent features visible in the system header files unless the application
6678 dnl overrides the corresponding test-macros.  Doing that introduces portability
6679 dnl problems.
6680 dnl
6681 dnl This macro makes a special check for the symbols used for this, to avoid a
6682 dnl conflicting definition.
6683 AC_DEFUN([CF_POSIX_VISIBLE],
6684 [
6685 AC_CACHE_CHECK(if the POSIX test-macros are already defined,cf_cv_posix_visible,[
6686 AC_TRY_COMPILE([#include <stdio.h>],[
6687 #if defined(__POSIX_VISIBLE) && ((__POSIX_VISIBLE - 0L) > 0) \
6688         && defined(__XSI_VISIBLE) && ((__XSI_VISIBLE - 0L) > 0) \
6689         && defined(__BSD_VISIBLE) && ((__BSD_VISIBLE - 0L) > 0) \
6690         && defined(__ISO_C_VISIBLE) && ((__ISO_C_VISIBLE - 0L) > 0)
6691 #error conflicting symbols found
6692 #endif
6693 ],[cf_cv_posix_visible=no],[cf_cv_posix_visible=yes])
6694 ])
6695 ])dnl
6696 dnl ---------------------------------------------------------------------------
6697 dnl CF_PREDEFINE version: 3 updated: 2023/02/18 17:41:25
6698 dnl ------------
6699 dnl Add definitions to CPPFLAGS to ensure they're predefined for all compiles.
6700 dnl
6701 dnl $1 = symbol to test
6702 dnl $2 = value (if any) to use for a predefinition
6703 AC_DEFUN([CF_PREDEFINE],
6704 [
6705 AC_MSG_CHECKING(if we must define $1)
6706 AC_TRY_COMPILE([#include <sys/types.h>
6707 ],[
6708 #ifndef $1
6709 #error $1 is not defined
6710 #endif],[cf_result=no],[cf_result=yes])
6711 AC_MSG_RESULT($cf_result)
6712
6713 if test "$cf_result" = yes ; then
6714         CPPFLAGS="$CPPFLAGS ifelse([$2],,-D$1,[-D$1=$2])"
6715 elif test "x$2" != "x" ; then
6716         AC_MSG_CHECKING(checking for compatible value versus $2)
6717         AC_TRY_COMPILE([#include <sys/types.h>
6718 ],[
6719 #if $1-$2 < 0
6720 #error $1-$2 is negative
6721 #endif],[cf_result=yes],[cf_result=no])
6722         AC_MSG_RESULT($cf_result)
6723         if test "$cf_result" = no ; then
6724                 # perhaps we can override it - try...
6725                 CPPFLAGS="$CPPFLAGS -D$1=$2"
6726         fi
6727 fi
6728 ])dnl
6729 dnl ---------------------------------------------------------------------------
6730 dnl CF_PRG_RULES version: 2 updated: 2021/01/01 13:31:04
6731 dnl ------------
6732 dnl Append definitions and rules for the given programs to the subdirectory
6733 dnl Makefiles, and the recursion rule for the top-level Makefile.
6734 dnl
6735 dnl parameters
6736 dnl     $1 = script to run
6737 dnl     $2 = list of subdirectories
6738 dnl
6739 dnl variables
6740 dnl     $AWK
6741 AC_DEFUN([CF_PRG_RULES],
6742 [
6743 for cf_dir in $2
6744 do
6745         if test ! -d "$srcdir/$cf_dir" ; then
6746                 continue
6747         elif test -f "$srcdir/$cf_dir/programs" ; then
6748                 $AWK -f $1 "$srcdir/$cf_dir/programs" >>$cf_dir/Makefile
6749         fi
6750 done
6751
6752 ])dnl
6753 dnl ---------------------------------------------------------------------------
6754 dnl CF_PROG_AR version: 1 updated: 2009/01/01 20:15:22
6755 dnl ----------
6756 dnl Check for archiver "ar".
6757 AC_DEFUN([CF_PROG_AR],[
6758 AC_CHECK_TOOL(AR, ar, ar)
6759 ])
6760 dnl ---------------------------------------------------------------------------
6761 dnl CF_PROG_AWK version: 1 updated: 2006/09/16 11:40:59
6762 dnl -----------
6763 dnl Check for awk, ensure that the check found something.
6764 AC_DEFUN([CF_PROG_AWK],
6765 [
6766 AC_PROG_AWK
6767 test -z "$AWK" && AC_MSG_ERROR(No awk program found)
6768 ])dnl
6769 dnl ---------------------------------------------------------------------------
6770 dnl CF_PROG_CC version: 5 updated: 2019/12/31 08:53:54
6771 dnl ----------
6772 dnl standard check for CC, plus followup sanity checks
6773 dnl $1 = optional parameter to pass to AC_PROG_CC to specify compiler name
6774 AC_DEFUN([CF_PROG_CC],[
6775 CF_ACVERSION_CHECK(2.53,
6776         [AC_MSG_WARN(this will incorrectly handle gnatgcc choice)
6777          AC_REQUIRE([AC_PROG_CC])],
6778         [])
6779 ifelse($1,,[AC_PROG_CC],[AC_PROG_CC($1)])
6780 CF_GCC_VERSION
6781 CF_ACVERSION_CHECK(2.52,
6782         [AC_PROG_CC_STDC],
6783         [CF_ANSI_CC_REQD])
6784 CF_CC_ENV_FLAGS
6785 ])dnl
6786 dnl ---------------------------------------------------------------------------
6787 dnl CF_PROG_CC_C_O version: 6 updated: 2021/01/01 13:31:04
6788 dnl --------------
6789 dnl Analogous to AC_PROG_CC_C_O, but more useful: tests only $CC, ensures that
6790 dnl the output file can be renamed, and allows for a shell variable that can
6791 dnl be used later.  The parameter is either CC or CXX.  The result is the
6792 dnl cache variable:
6793 dnl     $cf_cv_prog_CC_c_o
6794 dnl     $cf_cv_prog_CXX_c_o
6795 dnl
6796 dnl $1 = compiler
6797 dnl $2 = compiler options, if any
6798 AC_DEFUN([CF_PROG_CC_C_O],
6799 [AC_REQUIRE([AC_PROG_CC])dnl
6800 AC_MSG_CHECKING([whether [$]$1 understands -c and -o together])
6801 AC_CACHE_VAL(cf_cv_prog_$1_c_o,
6802 [
6803 cat > conftest.$ac_ext <<CF_EOF
6804 int main(void)
6805 {
6806         ${cf_cv_main_return:-return}(0);
6807 }
6808 CF_EOF
6809 # We do the test twice because some compilers refuse to overwrite an
6810 # existing .o file with -o, though they will create one.
6811 ac_try='[$]$1 $2 -c conftest.$ac_ext -o conftest2.$ac_objext >&AC_FD_CC'
6812 if AC_TRY_EVAL(ac_try) &&
6813   test -f conftest2.$ac_objext && AC_TRY_EVAL(ac_try);
6814 then
6815   eval cf_cv_prog_$1_c_o=yes
6816 else
6817   eval cf_cv_prog_$1_c_o=no
6818 fi
6819 rm -rf ./conftest*
6820 ])dnl
6821 if test "$cf_cv_prog_$1_c_o" = yes; then
6822   AC_MSG_RESULT([yes])
6823 else
6824   AC_MSG_RESULT([no])
6825 fi
6826 ])dnl
6827 dnl ---------------------------------------------------------------------------
6828 dnl CF_PROG_GNAT version: 12 updated: 2021/01/02 17:09:14
6829 dnl ------------
6830 dnl Check for gnat/gnatmake/etc, ensure that the toolset is complete.
6831 AC_DEFUN([CF_PROG_GNAT],[
6832 for cf_prog_gnat in gnat gnatmake gprconfig gprbuild
6833 do
6834         CF_UPPER(cf_upper_prog_gnat,${cf_prog_gnat})
6835
6836         unset ac_cv_path_cf_TEMP_gnat
6837         unset cf_TEMP_gnat
6838         AC_PATH_PROG(cf_TEMP_gnat,$cf_prog_gnat,no)
6839         eval "cf_cv_PATH_$cf_upper_prog_gnat=[$]ac_cv_path_cf_TEMP_gnat"
6840
6841         if test "x$cf_TEMP_gnat" != xno; then
6842                 unset cf_cv_gnat_version
6843                 unset cf_TEMP_gnat
6844                 CF_GNAT_VERSION(cf_TEMP_gnat,$cf_prog_gnat)
6845         fi
6846         eval "cf_cv_VERSION_$cf_upper_prog_gnat=[$]cf_TEMP_gnat"
6847
6848         unset cf_TEMP_gnat
6849         unset cf_cv_gnat_version
6850         unset ac_cv_path_cf_TEMP_gnat
6851 done
6852
6853 if test "x$cf_cv_VERSION_GNATMAKE" = "xno"; then
6854         cf_ada_make=
6855         cf_cv_prog_gnat_correct=no
6856 else
6857         cf_ada_make=gnatmake
6858         if test "x$cf_cv_VERSION_GPRCONFIG" = "xno"; then
6859                 # gprconfig is newer than gnatmake; we can continue...
6860                 cf_ada_config="##"
6861         else
6862                 rm -rf ./conftest* ./*~conftest*
6863                 if mkdir conftest.src
6864                 then
6865                         cf_ada_config=""
6866                         cd conftest.src
6867                         for cf_gprconfig in Ada C
6868                         do
6869                                 AC_MSG_CHECKING(for gprconfig name for $cf_gprconfig)
6870                                 if test "$cf_gprconfig" = C
6871                                 then
6872                                         for cf_gprconfig_param in \
6873                                                 "$cf_gprconfig,,,,GNATGCC" \
6874                                                 "$cf_gprconfig,,,,GCC" \
6875                                                 "$cf_gprconfig"
6876                                         do
6877                                                 cf_gprconfig_value=`echo s| gprconfig --config=$cf_gprconfig_param 2>&AC_FD_CC | ${AWK:-awk} '/^\*/{print [$]3;}' | head -n 1`
6878                                                 test -n "$cf_gprconfig_value" && break
6879                                         done
6880                                 else
6881                                         cf_gprconfig_param=$cf_gprconfig
6882                                         cf_gprconfig_value=`echo s| gprconfig --config=$cf_gprconfig_param 2>&AC_FD_CC | ${AWK:-awk} '/^\*/{print [$]3;}' | head -n 1`
6883                                 fi
6884                                 if test -n "$cf_gprconfig_value"
6885                                 then
6886                                         eval "cf_ada_config_[$]cf_gprconfig=[$]cf_gprconfig_value"
6887                                         AC_MSG_RESULT($cf_gprconfig_value)
6888                                 else
6889                                         AC_MSG_RESULT(missing)
6890                                         cf_ada_config="#"
6891                                         break
6892                                 fi
6893                         done
6894                         cd ..
6895                         rm -rf ./conftest* ./*~conftest*
6896                 fi
6897         fi
6898         if test "x$cf_ada_config" != "x#"
6899         then
6900                 CF_GNAT_VERSION
6901                 CF_CHECK_GNAT_VERSION
6902                 AC_CHECK_PROG(M4_exists, m4, yes, no)
6903                 if test "$ac_cv_prog_M4_exists" = no; then
6904                         cf_cv_prog_gnat_correct=no
6905                         AC_MSG_WARN(Ada95 binding required program m4 not found. Ada95 binding disabled)
6906                 fi
6907                 if test "$cf_cv_prog_gnat_correct" = yes; then
6908                         AC_MSG_CHECKING(if GNAT works)
6909                         CF_GNAT_TRY_RUN([procedure conftest;],
6910 [with Text_IO;
6911 with GNAT.OS_Lib;
6912 procedure conftest is
6913 begin
6914    Text_IO.Put ("Hello World");
6915    Text_IO.New_Line;
6916    GNAT.OS_Lib.OS_Exit (0);
6917 end conftest;],
6918 [cf_cv_prog_gnat_correct=yes],
6919 [cf_cv_prog_gnat_correct=no])
6920                         AC_MSG_RESULT($cf_cv_prog_gnat_correct)
6921                 fi
6922         else
6923                 cf_cv_prog_gnat_correct=no
6924         fi
6925 fi
6926
6927 AC_SUBST(cf_ada_make)
6928 AC_SUBST(cf_ada_config)
6929 AC_SUBST(cf_ada_config_Ada)
6930 AC_SUBST(cf_ada_config_C)
6931 ])dnl
6932 dnl ---------------------------------------------------------------------------
6933 dnl CF_PROG_INSTALL version: 10 updated: 2021/01/04 19:33:05
6934 dnl ---------------
6935 dnl Force $INSTALL to be an absolute-path.  Otherwise, edit_man.sh and the
6936 dnl misc/tabset install won't work properly.  Usually this happens only when
6937 dnl using the fallback mkinstalldirs script
6938 AC_DEFUN([CF_PROG_INSTALL],
6939 [AC_PROG_INSTALL
6940 case $INSTALL in
6941 (/*)
6942         ;;
6943 (*)
6944         CF_DIRNAME(cf_dir,$INSTALL)
6945         test -z "$cf_dir" && cf_dir=.
6946         INSTALL="`cd \"$cf_dir\" && pwd`"/"`echo "$INSTALL" | sed -e 's%^.*/%%'`"
6947         ;;
6948 esac
6949 ])dnl
6950 dnl ---------------------------------------------------------------------------
6951 dnl CF_PROG_LDCONFIG version: 5 updated: 2015/04/18 08:56:57
6952 dnl ----------------
6953 dnl Check for ldconfig, needed to fixup shared libraries that would be built
6954 dnl and then used in the install.
6955 AC_DEFUN([CF_PROG_LDCONFIG],[
6956 if test "$cross_compiling" = yes ; then
6957         LDCONFIG=:
6958 else
6959         case "$cf_cv_system_name" in
6960         (dragonfly*|mirbsd*|freebsd*)
6961                 test -z "$LDCONFIG" && LDCONFIG="/sbin/ldconfig -R"
6962                 ;;
6963         (*) LDPATH=$PATH:/sbin:/usr/sbin
6964                 AC_PATH_PROG(LDCONFIG,ldconfig,,$LDPATH)
6965                 ;;
6966         esac
6967 fi
6968 AC_SUBST(LDCONFIG)
6969 ])dnl
6970 dnl ---------------------------------------------------------------------------
6971 dnl CF_PROG_LINT version: 5 updated: 2022/08/20 15:44:13
6972 dnl ------------
6973 AC_DEFUN([CF_PROG_LINT],
6974 [
6975 AC_CHECK_PROGS(LINT, lint cppcheck splint)
6976 case "x$LINT" in
6977 (xcppcheck|x*/cppcheck)
6978         test -z "$LINT_OPTS" && LINT_OPTS="--enable=all"
6979         ;;
6980 esac
6981 AC_SUBST(LINT_OPTS)
6982 AC_SUBST(LINT_LIBS)
6983 ])dnl
6984 dnl ---------------------------------------------------------------------------
6985 dnl CF_PROG_LN_S version: 2 updated: 2010/08/14 18:25:37
6986 dnl ------------
6987 dnl Combine checks for "ln -s" and "ln -sf", updating $LN_S to include "-f"
6988 dnl option if it is supported.
6989 AC_DEFUN([CF_PROG_LN_S],[
6990 AC_PROG_LN_S
6991 AC_MSG_CHECKING(if $LN_S -f options work)
6992
6993 rm -f conf$$.src conf$$dst
6994 echo >conf$$.dst
6995 echo first >conf$$.src
6996 if $LN_S -f conf$$.src conf$$.dst 2>/dev/null; then
6997         cf_prog_ln_sf=yes
6998 else
6999         cf_prog_ln_sf=no
7000 fi
7001 rm -f conf$$.dst conf$$src
7002 AC_MSG_RESULT($cf_prog_ln_sf)
7003
7004 test "$cf_prog_ln_sf" = yes && LN_S="$LN_S -f"
7005 ])dnl
7006 dnl ---------------------------------------------------------------------------
7007 dnl CF_REGEX version: 18 updated: 2021/01/01 16:53:59
7008 dnl --------
7009 dnl Attempt to determine if we've got one of the flavors of regular-expression
7010 dnl code that we can support.
7011 AC_DEFUN([CF_REGEX],
7012 [
7013
7014 cf_regex_func=no
7015 cf_regex_libs=
7016 case "$host_os" in
7017 (mingw*)
7018         # -lsystre -ltre -lintl -liconv
7019         AC_CHECK_LIB(systre,regcomp,[
7020                 AC_CHECK_LIB(iconv,libiconv_open,[CF_ADD_LIB(iconv)])
7021                 AC_CHECK_LIB(intl,libintl_gettext,[CF_ADD_LIB(intl)])
7022                 AC_CHECK_LIB(tre,tre_regcomp,[CF_ADD_LIB(tre)])
7023                 CF_ADD_LIB(systre)
7024                 cf_regex_func=regcomp
7025         ],[
7026                 AC_CHECK_LIB(gnurx,regcomp,[
7027                         CF_ADD_LIB(gnurx)
7028                         cf_regex_func=regcomp])
7029         ])
7030         ;;
7031 (*)
7032         cf_regex_libs="regex re"
7033         AC_CHECK_FUNC(regcomp,[cf_regex_func=regcomp],[
7034                 for cf_regex_lib in $cf_regex_libs
7035                 do
7036                         AC_CHECK_LIB($cf_regex_lib,regcomp,[
7037                                         CF_ADD_LIB($cf_regex_lib)
7038                                         cf_regex_func=regcomp
7039                                         break])
7040                 done
7041         ])
7042         ;;
7043 esac
7044
7045 if test "$cf_regex_func" = no ; then
7046         AC_CHECK_FUNC(compile,[cf_regex_func=compile],[
7047                 AC_CHECK_LIB(gen,compile,[
7048                                 CF_ADD_LIB(gen)
7049                                 cf_regex_func=compile])])
7050 fi
7051
7052 if test "$cf_regex_func" = no ; then
7053         AC_MSG_WARN(cannot find regular expression library)
7054 fi
7055
7056 AC_CACHE_CHECK(for regular-expression headers,cf_cv_regex_hdrs,[
7057
7058 cf_cv_regex_hdrs=no
7059 case "$cf_regex_func" in
7060 (compile)
7061         for cf_regex_hdr in regexp.h regexpr.h
7062         do
7063                 AC_TRY_LINK([#include <$cf_regex_hdr>],[
7064                         char *p = compile("", "", "", 0);
7065                         int x = step("", "");
7066                         (void)p;
7067                         (void)x;
7068                 ],[
7069                         cf_cv_regex_hdrs=$cf_regex_hdr
7070                         break
7071                 ])
7072         done
7073         ;;
7074 (*)
7075         for cf_regex_hdr in regex.h
7076         do
7077                 AC_TRY_LINK([#include <sys/types.h>
7078 #include <$cf_regex_hdr>],[
7079                         regex_t *p = 0;
7080                         int x = regcomp(p, "", 0);
7081                         int y = regexec(p, "", 0, 0, 0);
7082                         (void)x;
7083                         (void)y;
7084                         regfree(p);
7085                 ],[
7086                         cf_cv_regex_hdrs=$cf_regex_hdr
7087                         break
7088                 ])
7089         done
7090         ;;
7091 esac
7092
7093 ])
7094
7095 case "$cf_cv_regex_hdrs" in
7096         (no)            AC_MSG_WARN(no regular expression header found) ;;
7097         (regex.h)       AC_DEFINE(HAVE_REGEX_H_FUNCS,1,[Define to 1 to include regex.h for regular expressions]) ;;
7098         (regexp.h)      AC_DEFINE(HAVE_REGEXP_H_FUNCS,1,[Define to 1 to include regexp.h for regular expressions]) ;;
7099         (regexpr.h) AC_DEFINE(HAVE_REGEXPR_H_FUNCS,1,[Define to 1 to include regexpr.h for regular expressions]) ;;
7100 esac
7101 ])dnl
7102 dnl ---------------------------------------------------------------------------
7103 dnl CF_REMOVE_CFLAGS version: 3 updated: 2021/09/05 17:25:40
7104 dnl ----------------
7105 dnl Remove a given option from CFLAGS/CPPFLAGS
7106 dnl $1 = option to remove
7107 dnl $2 = variable to update
7108 dnl $3 = nonempty to allow verbose message
7109 define([CF_REMOVE_CFLAGS],
7110 [
7111 cf_tmp_cflag=`echo "x$1" | sed -e 's/^.//' -e 's/=.*//'`
7112 while true
7113 do
7114         cf_old_cflag=`echo "x[$]$2" | sed -e 's/^.//' -e 's/[[  ]][[    ]]*-/ -/g' -e "s%$cf_tmp_cflag\\(=[[^   ]][[^   ]]*\\)\?%%" -e 's/^[[   ]]*//' -e 's%[[ ]][[ ]]*-D% -D%g' -e 's%[[ ]][[ ]]*-I% -I%g'`
7115         test "[$]$2" != "$cf_old_cflag" || break
7116         ifelse([$3],,,[CF_VERBOSE(removing old option $1 from $2)])
7117         $2="$cf_old_cflag"
7118 done
7119 ])dnl
7120 dnl ---------------------------------------------------------------------------
7121 dnl CF_REMOVE_DEFINE version: 3 updated: 2010/01/09 11:05:50
7122 dnl ----------------
7123 dnl Remove all -U and -D options that refer to the given symbol from a list
7124 dnl of C compiler options.  This works around the problem that not all
7125 dnl compilers process -U and -D options from left-to-right, so a -U option
7126 dnl cannot be used to cancel the effect of a preceding -D option.
7127 dnl
7128 dnl $1 = target (which could be the same as the source variable)
7129 dnl $2 = source (including '$')
7130 dnl $3 = symbol to remove
7131 define([CF_REMOVE_DEFINE],
7132 [
7133 $1=`echo "$2" | \
7134         sed     -e 's/-[[UD]]'"$3"'\(=[[^       ]]*\)\?[[       ]]/ /g' \
7135                 -e 's/-[[UD]]'"$3"'\(=[[^       ]]*\)\?[$]//g'`
7136 ])dnl
7137 dnl ---------------------------------------------------------------------------
7138 dnl CF_REMOVE_LIB version: 1 updated: 2007/02/17 14:11:52
7139 dnl -------------
7140 dnl Remove the given library from the symbol
7141 dnl
7142 dnl $1 = target (which could be the same as the source variable)
7143 dnl $2 = source (including '$')
7144 dnl $3 = library to remove
7145 define([CF_REMOVE_LIB],
7146 [
7147 # remove $3 library from $2
7148 $1=`echo "$2" | sed -e 's/-l$3[[        ]]//g' -e 's/-l$3[$]//'`
7149 ])dnl
7150 dnl ---------------------------------------------------------------------------
7151 dnl CF_RESTORE_XTRA_FLAGS version: 1 updated: 2020/01/11 16:47:45
7152 dnl ---------------------
7153 dnl Restore flags saved in CF_SAVE_XTRA_FLAGS
7154 dnl $1 = name of current macro
7155 define([CF_RESTORE_XTRA_FLAGS],
7156 [
7157 LIBS="$cf_save_LIBS_$1"
7158 CFLAGS="$cf_save_CFLAGS_$1"
7159 CPPFLAGS="$cf_save_CPPFLAGS_$1"
7160 ])dnl
7161 dnl ---------------------------------------------------------------------------
7162 dnl CF_RPATH_HACK version: 13 updated: 2021/01/03 18:30:50
7163 dnl -------------
7164 AC_DEFUN([CF_RPATH_HACK],
7165 [AC_REQUIRE([AC_PROG_FGREP])dnl
7166 AC_REQUIRE([CF_LD_RPATH_OPT])dnl
7167
7168 AC_MSG_CHECKING(for updated LDFLAGS)
7169 if test -n "$LD_RPATH_OPT" ; then
7170         AC_MSG_RESULT(maybe)
7171
7172         AC_CHECK_PROGS(cf_ldd_prog,ldd,no)
7173         cf_rpath_list="/usr/lib /lib"
7174         if test "$cf_ldd_prog" != no
7175         then
7176                 cf_rpath_oops=
7177
7178 AC_TRY_LINK([#include <stdio.h>],
7179                 [printf("Hello");],
7180                 [cf_rpath_oops=`"$cf_ldd_prog" "conftest$ac_exeext" | ${FGREP-fgrep} ' not found' | sed -e 's% =>.*$%%' |sort | uniq`
7181                  cf_rpath_list=`"$cf_ldd_prog" "conftest$ac_exeext" | ${FGREP-fgrep} / | sed -e 's%^.*[[        ]]/%/%' -e 's%/[[^/]][[^/]]*$%%' |sort | uniq`])
7182
7183                 # If we passed the link-test, but get a "not found" on a given library,
7184                 # this could be due to inept reconfiguration of gcc to make it only
7185                 # partly honor /usr/local/lib (or whatever).  Sometimes this behavior
7186                 # is intentional, e.g., installing gcc in /usr/bin and suppressing the
7187                 # /usr/local libraries.
7188                 if test -n "$cf_rpath_oops"
7189                 then
7190                         for cf_rpath_src in $cf_rpath_oops
7191                         do
7192                                 for cf_rpath_dir in \
7193                                         /usr/local \
7194                                         /usr/pkg \
7195                                         /opt/sfw
7196                                 do
7197                                         if test -f "$cf_rpath_dir/lib/$cf_rpath_src"
7198                                         then
7199                                                 CF_VERBOSE(...adding -L$cf_rpath_dir/lib to LDFLAGS for $cf_rpath_src)
7200                                                 LDFLAGS="$LDFLAGS -L$cf_rpath_dir/lib"
7201                                                 break
7202                                         fi
7203                                 done
7204                         done
7205                 fi
7206         fi
7207
7208         CF_VERBOSE(...checking EXTRA_LDFLAGS $EXTRA_LDFLAGS)
7209
7210         CF_RPATH_HACK_2(LDFLAGS)
7211         CF_RPATH_HACK_2(LIBS)
7212
7213         CF_VERBOSE(...checked EXTRA_LDFLAGS $EXTRA_LDFLAGS)
7214 else
7215         AC_MSG_RESULT(no)
7216 fi
7217 AC_SUBST(EXTRA_LDFLAGS)
7218 ])dnl
7219 dnl ---------------------------------------------------------------------------
7220 dnl CF_RPATH_HACK_2 version: 8 updated: 2021/01/01 13:31:04
7221 dnl ---------------
7222 dnl Do one set of substitutions for CF_RPATH_HACK, adding an rpath option to
7223 dnl EXTRA_LDFLAGS for each -L option found.
7224 dnl
7225 dnl $cf_rpath_list contains a list of directories to ignore.
7226 dnl
7227 dnl $1 = variable name to update.  The LDFLAGS variable should be the only one,
7228 dnl      but LIBS often has misplaced -L options.
7229 AC_DEFUN([CF_RPATH_HACK_2],
7230 [
7231 CF_VERBOSE(...checking $1 [$]$1)
7232
7233 cf_rpath_dst=
7234 for cf_rpath_src in [$]$1
7235 do
7236         case "$cf_rpath_src" in
7237         (-L*)
7238
7239                 # check if this refers to a directory which we will ignore
7240                 cf_rpath_skip=no
7241                 if test -n "$cf_rpath_list"
7242                 then
7243                         for cf_rpath_item in $cf_rpath_list
7244                         do
7245                                 if test "x$cf_rpath_src" = "x-L$cf_rpath_item"
7246                                 then
7247                                         cf_rpath_skip=yes
7248                                         break
7249                                 fi
7250                         done
7251                 fi
7252
7253                 if test "$cf_rpath_skip" = no
7254                 then
7255                         # transform the option
7256                         if test "$LD_RPATH_OPT" = "-R " ; then
7257                                 cf_rpath_tmp=`echo "$cf_rpath_src" |sed -e "s%-L%-R %"`
7258                         else
7259                                 cf_rpath_tmp=`echo "$cf_rpath_src" |sed -e "s%-L%$LD_RPATH_OPT%"`
7260                         fi
7261
7262                         # if we have not already added this, add it now
7263                         cf_rpath_tst=`echo "$EXTRA_LDFLAGS" | sed -e "s%$cf_rpath_tmp %%"`
7264                         if test "x$cf_rpath_tst" = "x$EXTRA_LDFLAGS"
7265                         then
7266                                 CF_VERBOSE(...Filter $cf_rpath_src ->$cf_rpath_tmp)
7267                                 EXTRA_LDFLAGS="$cf_rpath_tmp $EXTRA_LDFLAGS"
7268                         fi
7269                 fi
7270                 ;;
7271         esac
7272         cf_rpath_dst="$cf_rpath_dst $cf_rpath_src"
7273 done
7274 $1=$cf_rpath_dst
7275
7276 CF_VERBOSE(...checked $1 [$]$1)
7277 AC_SUBST(EXTRA_LDFLAGS)
7278 ])dnl
7279 dnl ---------------------------------------------------------------------------
7280 dnl CF_SAVE_XTRA_FLAGS version: 1 updated: 2020/01/11 16:46:44
7281 dnl ------------------
7282 dnl Use this macro to save CFLAGS/CPPFLAGS/LIBS before checks against X headers
7283 dnl and libraries which do not update those variables.
7284 dnl
7285 dnl $1 = name of current macro
7286 define([CF_SAVE_XTRA_FLAGS],
7287 [
7288 cf_save_LIBS_$1="$LIBS"
7289 cf_save_CFLAGS_$1="$CFLAGS"
7290 cf_save_CPPFLAGS_$1="$CPPFLAGS"
7291 LIBS="$LIBS ${X_PRE_LIBS} ${X_LIBS} ${X_EXTRA_LIBS}"
7292 for cf_X_CFLAGS in $X_CFLAGS
7293 do
7294         case "x$cf_X_CFLAGS" in
7295         x-[[IUD]]*)
7296                 CPPFLAGS="$CPPFLAGS $cf_X_CFLAGS"
7297                 ;;
7298         *)
7299                 CFLAGS="$CFLAGS $cf_X_CFLAGS"
7300                 ;;
7301         esac
7302 done
7303 ])dnl
7304 dnl ---------------------------------------------------------------------------
7305 dnl CF_SHARED_OPTS version: 107 updated: 2021/09/04 06:47:34
7306 dnl --------------
7307 dnl --------------
7308 dnl Attempt to determine the appropriate CC/LD options for creating a shared
7309 dnl library.
7310 dnl
7311 dnl Notes:
7312 dnl a) ${LOCAL_LDFLAGS} is used to link executables that will run within
7313 dnl the build-tree, i.e., by making use of the libraries that are compiled in
7314 dnl $rel_builddir/lib We avoid compiling-in a $rel_builddir/lib path for the
7315 dnl shared library since that can lead to unexpected results at runtime.
7316 dnl b) ${LOCAL_LDFLAGS2} has the same intention but assumes that the shared
7317 dnl libraries are compiled in ../../lib
7318 dnl
7319 dnl The variable 'cf_cv_do_symlinks' is used to control whether we configure
7320 dnl to install symbolic links to the rel/abi versions of shared libraries.
7321 dnl
7322 dnl The variable 'cf_cv_shlib_version' controls whether we use the rel or abi
7323 dnl version when making symbolic links.
7324 dnl
7325 dnl The variable 'cf_cv_shlib_version_infix' controls whether shared library
7326 dnl version numbers are infix (ex: libncurses.<ver>.dylib) or postfix
7327 dnl (ex: libncurses.so.<ver>).
7328 dnl
7329 dnl Some loaders leave 'so_locations' lying around.  It is nice to clean up.
7330 AC_DEFUN([CF_SHARED_OPTS],
7331 [
7332         AC_REQUIRE([CF_LD_RPATH_OPT])
7333
7334         RM_SHARED_OPTS=
7335         LOCAL_LDFLAGS=
7336         LOCAL_LDFLAGS2=
7337         LD_SHARED_OPTS=
7338         INSTALL_LIB="-m 644"
7339         : ${rel_builddir:=.}
7340
7341         shlibdir=$libdir
7342         AC_SUBST(shlibdir)
7343
7344         MAKE_DLLS="#"
7345         AC_SUBST(MAKE_DLLS)
7346
7347         cf_cv_do_symlinks=no
7348         cf_ld_rpath_opt=
7349         test "$cf_cv_enable_rpath" = yes && cf_ld_rpath_opt="$LD_RPATH_OPT"
7350
7351         AC_MSG_CHECKING(if release/abi version should be used for shared libs)
7352         AC_ARG_WITH(shlib-version,
7353         [  --with-shlib-version=X  Specify rel or abi version for shared libs],
7354         [test -z "$withval" && withval=auto
7355         case "$withval" in
7356         (yes)
7357                 cf_cv_shlib_version=auto
7358                 ;;
7359         (rel|abi|auto)
7360                 cf_cv_shlib_version=$withval
7361                 ;;
7362         (*)
7363                 AC_MSG_RESULT($withval)
7364                 AC_MSG_ERROR([option value must be one of: rel, abi, or auto])
7365                 ;;
7366         esac
7367         ],[cf_cv_shlib_version=auto])
7368         AC_MSG_RESULT($cf_cv_shlib_version)
7369
7370         cf_cv_rm_so_locs=no
7371         cf_try_cflags=
7372
7373         # Some less-capable ports of gcc support only -fpic
7374         CC_SHARED_OPTS=
7375
7376         cf_try_fPIC=no
7377         if test "$GCC" = yes
7378         then
7379                 cf_try_fPIC=yes
7380         else
7381                 case "$cf_cv_system_name" in
7382                 (*linux*)       # e.g., PGI compiler
7383                         cf_try_fPIC=yes
7384                         ;;
7385                 esac
7386         fi
7387
7388         if test "$cf_try_fPIC" = yes
7389         then
7390                 AC_MSG_CHECKING(which $CC option to use)
7391                 cf_save_CFLAGS="$CFLAGS"
7392                 for CC_SHARED_OPTS in -fPIC -fpic ''
7393                 do
7394                         CFLAGS="$cf_save_CFLAGS $CC_SHARED_OPTS"
7395                         AC_TRY_COMPILE([#include <stdio.h>],[int x = 1],[break],[])
7396                 done
7397                 AC_MSG_RESULT($CC_SHARED_OPTS)
7398                 CFLAGS="$cf_save_CFLAGS"
7399         fi
7400
7401         cf_cv_shlib_version_infix=no
7402
7403         case "$cf_cv_system_name" in
7404         (aix4.[3-9]*|aix[[5-7]]*)
7405                 if test "$GCC" = yes; then
7406                         CC_SHARED_OPTS='-Wl,-brtl'
7407                         MK_SHARED_LIB='${CC} ${LDFLAGS} ${CFLAGS} -shared -Wl,-brtl -Wl,-blibpath:${RPATH_LIST}:/usr/lib -o [$]@'
7408                 else
7409                         CC_SHARED_OPTS='-brtl'
7410                         # as well as '-qpic=large -G' or perhaps "-bM:SRE -bnoentry -bexpall"
7411                         MK_SHARED_LIB='${CC} ${LDFLAGS} ${CFLAGS} -G -Wl,-brtl -Wl,-blibpath:${RPATH_LIST}:/usr/lib -o [$]@'
7412                 fi
7413                 ;;
7414         (beos*)
7415                 MK_SHARED_LIB='${CC} ${LDFLAGS} ${CFLAGS} -o $[@] -Xlinker -soname=`basename $[@]` -nostart -e 0'
7416                 ;;
7417         (cygwin*)
7418                 CC_SHARED_OPTS=
7419                 MK_SHARED_LIB=$SHELL' '$rel_builddir'/mk_shared_lib.sh [$]@ [$]{CC} [$]{CFLAGS}'
7420                 RM_SHARED_OPTS="$RM_SHARED_OPTS $rel_builddir/mk_shared_lib.sh *.dll.a"
7421                 cf_cv_shlib_version=cygdll
7422                 cf_cv_shlib_version_infix=cygdll
7423                 shlibdir=$bindir
7424                 MAKE_DLLS=
7425                 cat >mk_shared_lib.sh <<-CF_EOF
7426                 #!$SHELL
7427                 SHARED_LIB=\[$]1
7428                 IMPORT_LIB=\`echo "\[$]1" | sed -e 's/cyg/lib/' -e 's/[[0-9]]*\.dll[$]/.dll.a/'\`
7429                 shift
7430                 cat <<-EOF
7431                 Linking shared library
7432                 ** SHARED_LIB \[$]SHARED_LIB
7433                 ** IMPORT_LIB \[$]IMPORT_LIB
7434 EOF
7435                 exec \[$]* ${LDFLAGS} -shared -Wl,--out-implib=\[$]{IMPORT_LIB} -Wl,--export-all-symbols -o \[$]{SHARED_LIB}
7436 CF_EOF
7437                 chmod +x mk_shared_lib.sh
7438                 ;;
7439         (msys*)
7440                 CC_SHARED_OPTS=
7441                 MK_SHARED_LIB=$SHELL' '$rel_builddir'/mk_shared_lib.sh [$]@ [$]{CC} [$]{CFLAGS}'
7442                 RM_SHARED_OPTS="$RM_SHARED_OPTS $rel_builddir/mk_shared_lib.sh *.dll.a"
7443                 cf_cv_shlib_version=msysdll
7444                 cf_cv_shlib_version_infix=msysdll
7445                 shlibdir=$bindir
7446                 MAKE_DLLS=
7447                 cat >mk_shared_lib.sh <<-CF_EOF
7448                 #!$SHELL
7449                 SHARED_LIB=\[$]1
7450                 IMPORT_LIB=\`echo "\[$]1" | sed -e 's/msys-/lib/' -e 's/[[0-9]]*\.dll[$]/.dll.a/'\`
7451                 shift
7452                 cat <<-EOF
7453                 Linking shared library
7454                 ** SHARED_LIB \[$]SHARED_LIB
7455                 ** IMPORT_LIB \[$]IMPORT_LIB
7456 EOF
7457                 exec \[$]* ${LDFLAGS} -shared -Wl,--out-implib=\[$]{IMPORT_LIB} -Wl,--export-all-symbols -o \[$]{SHARED_LIB}
7458 CF_EOF
7459                 chmod +x mk_shared_lib.sh
7460                 ;;
7461         (darwin*)
7462                 cf_try_cflags="no-cpp-precomp"
7463                 CC_SHARED_OPTS="-dynamic"
7464                 MK_SHARED_LIB='${CC} ${LDFLAGS} ${CFLAGS} -dynamiclib -install_name ${libdir}/`basename $[@]` -compatibility_version ${ABI_VERSION} -current_version ${ABI_VERSION} -o $[@]'
7465                 test "$cf_cv_shlib_version" = auto && cf_cv_shlib_version=abi
7466                 cf_cv_shlib_version_infix=yes
7467                 AC_CACHE_CHECK([if ld -search_paths_first works], cf_cv_ldflags_search_paths_first, [
7468                         cf_save_LDFLAGS=$LDFLAGS
7469                         LDFLAGS="$LDFLAGS -Wl,-search_paths_first"
7470                         AC_TRY_LINK(, [int i;], cf_cv_ldflags_search_paths_first=yes, cf_cv_ldflags_search_paths_first=no)
7471                                 LDFLAGS=$cf_save_LDFLAGS])
7472                 if test "$cf_cv_ldflags_search_paths_first" = yes; then
7473                         LDFLAGS="$LDFLAGS -Wl,-search_paths_first"
7474                 fi
7475                 ;;
7476         (haiku*)
7477                 CF_SHARED_SONAME
7478                 MK_SHARED_LIB='${CC} ${LDFLAGS} ${CFLAGS} -shared -Wl,-soname,'$cf_cv_shared_soname',-stats,-lc -o $[@]'
7479                 ;;
7480         (hpux[[7-8]]*)
7481                 # HP-UX 8.07 ld lacks "+b" option used for libdir search-list
7482                 if test "$GCC" != yes; then
7483                         CC_SHARED_OPTS='+Z'
7484                 fi
7485                 MK_SHARED_LIB='${LD} ${LDFLAGS} -b -o $[@]'
7486                 INSTALL_LIB="-m 555"
7487                 ;;
7488         (hpux*)
7489                 # (tested with gcc 2.7.2 -- I don't have c89)
7490                 if test "$GCC" = yes; then
7491                         LD_SHARED_OPTS='-Xlinker +b -Xlinker ${libdir}'
7492                 else
7493                         CC_SHARED_OPTS='+Z'
7494                         LD_SHARED_OPTS='-Wl,+b,${libdir}'
7495                 fi
7496                 MK_SHARED_LIB='${LD} ${LDFLAGS} +b ${libdir} -b -o $[@]'
7497                 # HP-UX shared libraries must be executable, and should be
7498                 # readonly to exploit a quirk in the memory manager.
7499                 INSTALL_LIB="-m 555"
7500                 ;;
7501         (interix*)
7502                 test "$cf_cv_shlib_version" = auto && cf_cv_shlib_version=rel
7503                 if test "$cf_cv_shlib_version" = rel; then
7504                         cf_shared_soname='`basename $[@] .${REL_VERSION}`.${ABI_VERSION}'
7505                 else
7506                         cf_shared_soname='`basename $[@]`'
7507                 fi
7508                 CC_SHARED_OPTS=
7509                 MK_SHARED_LIB='${CC} ${LDFLAGS} ${CFLAGS} -shared -Wl,-rpath,${RPATH_LIST} -Wl,-h,'$cf_shared_soname' -o $[@]'
7510                 ;;
7511         (irix*)
7512                 if test "$cf_cv_enable_rpath" = yes ; then
7513                         EXTRA_LDFLAGS="${cf_ld_rpath_opt}\${RPATH_LIST} $EXTRA_LDFLAGS"
7514                 fi
7515                 # tested with IRIX 5.2 and 'cc'.
7516                 if test "$GCC" != yes; then
7517                         CC_SHARED_OPTS='-KPIC'
7518                         MK_SHARED_LIB='${CC} ${LDFLAGS} ${CFLAGS} -shared -rdata_shared -soname `basename $[@]` -o $[@]'
7519                 else
7520                         MK_SHARED_LIB='${CC} ${LDFLAGS} ${CFLAGS} -shared -Wl,-soname,`basename $[@]` -o $[@]'
7521                 fi
7522                 cf_cv_rm_so_locs=yes
7523                 ;;
7524         (linux*|gnu*|k*bsd*-gnu)
7525                 if test "$DFT_LWR_MODEL" = "shared" && test -n "$LD_RPATH_OPT" ; then
7526                         LOCAL_LDFLAGS="${LD_RPATH_OPT}\$(LOCAL_LIBDIR)"
7527                         LOCAL_LDFLAGS2="$LOCAL_LDFLAGS"
7528                 fi
7529                 if test "$cf_cv_enable_rpath" = yes ; then
7530                         EXTRA_LDFLAGS="${cf_ld_rpath_opt}\${RPATH_LIST} $EXTRA_LDFLAGS"
7531                 fi
7532                 CF_SHARED_SONAME
7533                 MK_SHARED_LIB='${CC} ${LDFLAGS} ${CFLAGS} -shared -Wl,-soname,'$cf_cv_shared_soname',-stats,-lc -o $[@]'
7534                 ;;
7535         (mingw*msvc*)
7536                 cf_cv_shlib_version=msvcdll
7537                 cf_cv_shlib_version_infix=msvcdll
7538                 shlibdir=$bindir
7539                 MAKE_DLLS=
7540                 if test "$DFT_LWR_MODEL" = "shared" ; then
7541                         LOCAL_LDFLAGS="-link -dll"
7542                         LOCAL_LDFLAGS2="$LOCAL_LDFLAGS"
7543                         EXTRA_LDFLAGS="-link -dll $EXTRA_LDFLAGS"
7544                 fi
7545                 CC_SHARED_OPTS=
7546                 MK_SHARED_LIB=$SHELL' '$rel_builddir'/mk_shared_lib.sh [$]@ ${LD} [$]{CFLAGS}'
7547                 RM_SHARED_OPTS="$RM_SHARED_OPTS $rel_builddir/mk_shared_lib.sh *.dll.lib"
7548                 cat >mk_shared_lib.sh <<-CF_EOF
7549                 #!$SHELL
7550                 SHARED_LIB=\[$]1
7551                 IMPORT_LIB=\`echo "\[$]1" | sed -e 's/[[0-9]]*\.dll[$]/.dll.lib/'\`
7552                 shift
7553                 my_ld=\[$]1
7554                 shift
7555                 cat <<-EOF
7556                 Linking shared library
7557                 ** SHARED LIB \$SHARED_LIB
7558                 ** IMPORT_LIB \$IMPORT_LIB
7559 EOF
7560                 args=\$(echo \[$]* | sed -E "s#-l(\w*)#\1.dll.lib#g" | sed -E "s#-L(\w*)#-LIBPATH:\1#g")
7561                 exec \$my_ld -DLL -IMPLIB:"\${IMPORT_LIB}" -OUT:"\${SHARED_LIB}" ${LDFLAGS} \$args
7562                 mv "\${IMPORT_LIB}" "\${IMPORT_LIB}"
7563 CF_EOF
7564                 chmod +x mk_shared_lib.sh
7565                 cat >mk_prog.sh <<-CF_EOF
7566                 #!$SHELL
7567                 shift
7568                 # Ignore first argument (compiler) and use LD (link.exe) unconditionally
7569                 LD="[$]LD"
7570                 clopts=()
7571                 ldopts=("/subsystem:console")
7572                 libs=()
7573                 isdll=0
7574                 while test \[$]# -gt 0; do
7575                         case "\[$]1" in
7576                                 -link)
7577                                         # ignore -link argument
7578                                         ;;
7579                                 -M[[TD]] | -M[[TD]]d)
7580                                         # ignore runtime-library option
7581                                         ;;
7582                                 -dll)
7583                                         isdll=1
7584                                         ;;
7585                                 -W* | -w*)
7586                                         # ignore warnings
7587                                         ;;
7588                                 -D*)
7589                                         clopts+=("\[$]1")
7590                                         ;;
7591                                 -I*)
7592                                         clopts+=("\[$]1")
7593                                         ;;
7594                                 -l*)
7595                                         libs+=("\`echo \"\[$]1\" | sed \"s/^-l//\"\`")
7596                                         ;;
7597                                 -L*)
7598                                         ldopts+=("\`echo \"\[$]1\" | sed \"s/^-L/-LIBPATH:/\"\`")
7599                                         ;;
7600                                 *.obj | *.o)
7601                                         ldopts+=("\[$]1")
7602                                         ;;
7603                                 -Wl,*)
7604                                         for linkarg in \`echo '\[$]1' | sed -e 's/-Wl,//' -e 's/,/ /'\`; do
7605                                                 ldopts+=("\[$]{linkarg}")
7606                                         done
7607                                         ;;
7608                                 *.lib)
7609                                         ldopts+=("\[$]1")
7610                                         ;;
7611                                 -o)
7612                                         shift
7613                                         ldopts+=("-out:\[$]1")
7614                                         ;;
7615                                 *)
7616                                         clopts+=("\[$]1")
7617                                         ldopts+=("\[$]1")
7618                                         ;;
7619                         esac
7620                         shift
7621                 done
7622                 if [[ "\$isdll" -ne 0 ]]; then
7623                         for lib in \[$]{libs[[*]]}; do
7624                                 ldopts+=("\[$]lib.dll.lib")
7625                         done
7626                 else
7627                         for lib in \[$]{libs[[*]]}; do
7628                                 ldopts+=("\[$]lib.lib")
7629                         done
7630                 fi
7631                 cat <<-EOF
7632                 Creating program
7633                 ** ld options:   "\[$]{ldopts[[@]]}"
7634 EOF
7635                 exec \[$]LD \[$]{ldopts[[@]]}
7636 CF_EOF
7637                 chmod +x mk_prog.sh
7638                 LINK_PROGS="$SHELL ${rel_builddir}/mk_prog.sh"
7639                 LINK_TESTS="$SHELL ${rel_builddir}/mk_prog.sh"
7640                 ;;
7641         (mingw*)
7642                 cf_cv_shlib_version=mingw
7643                 cf_cv_shlib_version_infix=mingw
7644                 shlibdir=$bindir
7645                 MAKE_DLLS=
7646                 if test "$DFT_LWR_MODEL" = "shared" ; then
7647                         LOCAL_LDFLAGS="-Wl,--enable-auto-import"
7648                         LOCAL_LDFLAGS2="$LOCAL_LDFLAGS"
7649                         EXTRA_LDFLAGS="-Wl,--enable-auto-import $EXTRA_LDFLAGS"
7650                 fi
7651                 CC_SHARED_OPTS=
7652                 MK_SHARED_LIB=$SHELL' '$rel_builddir'/mk_shared_lib.sh [$]@ [$]{CC} [$]{CFLAGS}'
7653                 RM_SHARED_OPTS="$RM_SHARED_OPTS $rel_builddir/mk_shared_lib.sh *.dll.a"
7654                 cat >mk_shared_lib.sh <<-CF_EOF
7655                 #!$SHELL
7656                 SHARED_LIB=\[$]1
7657                 IMPORT_LIB=\`echo "\[$]1" | sed -e 's/[[0-9]]*\.dll[$]/.dll.a/'\`
7658                 shift
7659                 cat <<-EOF
7660                 Linking shared library
7661                 ** SHARED_LIB \[$]SHARED_LIB
7662                 ** IMPORT_LIB \[$]IMPORT_LIB
7663 EOF
7664                 exec \[$]* ${LDFLAGS} -shared -Wl,--enable-auto-import,--out-implib=\[$]{IMPORT_LIB} -Wl,--export-all-symbols -o \[$]{SHARED_LIB}
7665 CF_EOF
7666                 chmod +x mk_shared_lib.sh
7667                 ;;
7668         (openbsd[[2-9]].*|mirbsd*)
7669                 if test "$DFT_LWR_MODEL" = "shared" && test -n "$LD_RPATH_OPT" ; then
7670                         LOCAL_LDFLAGS="${LD_RPATH_OPT}\$(LOCAL_LIBDIR)"
7671                         LOCAL_LDFLAGS2="$LOCAL_LDFLAGS"
7672                 fi
7673                 if test "$cf_cv_enable_rpath" = yes ; then
7674                         EXTRA_LDFLAGS="${cf_ld_rpath_opt}\${RPATH_LIST} $EXTRA_LDFLAGS"
7675                 fi
7676                 CC_SHARED_OPTS="$CC_SHARED_OPTS -DPIC"
7677                 CF_SHARED_SONAME
7678                 MK_SHARED_LIB='${CC} ${LDFLAGS} ${CFLAGS} -shared -Wl,-Bshareable,-soname,'$cf_cv_shared_soname',-stats,-lc -o $[@]'
7679                 ;;
7680         (nskJ*)
7681                 CC_SHARED_OPTS=
7682                 MK_SHARED_LIB='${LD} -Wshared -Weld=-export_all -o $[@]'
7683                 ;;
7684         (nskL*)
7685                 CC_SHARED_OPTS=
7686                 MK_SHARED_LIB='${LD} -Wshared -Wxld=-export_all -o $[@]'
7687                 ;;
7688         (nto-qnx*|openbsd*|freebsd[[12]].*)
7689                 CC_SHARED_OPTS="$CC_SHARED_OPTS -DPIC"
7690                 MK_SHARED_LIB='${LD} ${LDFLAGS} -Bshareable -o $[@]'
7691                 test "$cf_cv_shlib_version" = auto && cf_cv_shlib_version=rel
7692                 ;;
7693         (dragonfly*|freebsd*)
7694                 CC_SHARED_OPTS="$CC_SHARED_OPTS -DPIC"
7695                 if test "$DFT_LWR_MODEL" = "shared" && test "$cf_cv_enable_rpath" = yes ; then
7696                         LOCAL_LDFLAGS="${cf_ld_rpath_opt}\$(LOCAL_LIBDIR)"
7697                         LOCAL_LDFLAGS2="${cf_ld_rpath_opt}\${RPATH_LIST} $LOCAL_LDFLAGS"
7698                         EXTRA_LDFLAGS="${cf_ld_rpath_opt}\${RPATH_LIST} $EXTRA_LDFLAGS"
7699                 fi
7700                 CF_SHARED_SONAME
7701                 MK_SHARED_LIB='${CC} ${LDFLAGS} ${CFLAGS} -shared -Wl,-soname,'$cf_cv_shared_soname',-stats,-lc -o $[@]'
7702                 ;;
7703         (netbsd*)
7704                 CC_SHARED_OPTS="$CC_SHARED_OPTS -DPIC"
7705                 if test "$DFT_LWR_MODEL" = "shared" && test "$cf_cv_enable_rpath" = yes ; then
7706                         LOCAL_LDFLAGS="${cf_ld_rpath_opt}\$(LOCAL_LIBDIR)"
7707                         LOCAL_LDFLAGS2="$LOCAL_LDFLAGS"
7708                         EXTRA_LDFLAGS="${cf_ld_rpath_opt}\${RPATH_LIST} $EXTRA_LDFLAGS"
7709                         if test "$cf_cv_shlib_version" = auto; then
7710                         if test -f /usr/libexec/ld.elf_so; then
7711                                 cf_cv_shlib_version=abi
7712                         else
7713                                 cf_cv_shlib_version=rel
7714                         fi
7715                         fi
7716                         CF_SHARED_SONAME
7717                         MK_SHARED_LIB='${CC} ${LDFLAGS} ${CFLAGS} -shared -Wl,-soname,'$cf_cv_shared_soname' -o $[@]'
7718                 else
7719                         MK_SHARED_LIB='${CC} ${LDFLAGS} ${CFLAGS} -shared -o $[@]'
7720                 fi
7721                 ;;
7722         (osf*|mls+*)
7723                 # tested with OSF/1 V3.2 and 'cc'
7724                 # tested with OSF/1 V3.2 and gcc 2.6.3 (but the c++ demo didn't
7725                 # link with shared libs).
7726                 MK_SHARED_LIB='${LD} ${LDFLAGS} -set_version ${REL_VERSION}:${ABI_VERSION} -expect_unresolved "*" -shared -soname `basename $[@]`'
7727                 case "$host_os" in
7728                 (osf4*)
7729                         MK_SHARED_LIB="${MK_SHARED_LIB} -msym"
7730                         ;;
7731                 esac
7732                 MK_SHARED_LIB="${MK_SHARED_LIB}"' -o $[@]'
7733                 if test "$DFT_LWR_MODEL" = "shared" && test -n "$LD_RPATH_OPT" ; then
7734                         LOCAL_LDFLAGS="${LD_RPATH_OPT}\$(LOCAL_LIBDIR)"
7735                         LOCAL_LDFLAGS2="$LOCAL_LDFLAGS"
7736                 fi
7737                 cf_cv_rm_so_locs=yes
7738                 ;;
7739         (sco3.2v5*)  # also uw2* and UW7: hops 13-Apr-98
7740                 # tested with osr5.0.5
7741                 if test "$GCC" != yes; then
7742                         CC_SHARED_OPTS='-belf -KPIC'
7743                 fi
7744                 MK_SHARED_LIB='${LD} ${LDFLAGS} -dy -G -h `basename $[@] .${REL_VERSION}`.${ABI_VERSION} -o [$]@'
7745                 if test "$cf_cv_enable_rpath" = yes ; then
7746                         # only way is to set LD_RUN_PATH but no switch for it
7747                         RUN_PATH=$libdir
7748                 fi
7749                 test "$cf_cv_shlib_version" = auto && cf_cv_shlib_version=rel
7750                 LINK_PROGS='LD_RUN_PATH=${libdir}'
7751                 LINK_TESTS='Pwd=`pwd`;LD_RUN_PATH=`dirname $${Pwd}`/lib'
7752                 ;;
7753         (sunos4*)
7754                 # tested with SunOS 4.1.1 and gcc 2.7.0
7755                 if test "$GCC" != yes; then
7756                         CC_SHARED_OPTS='-KPIC'
7757                 fi
7758                 MK_SHARED_LIB='${LD} ${LDFLAGS} -assert pure-text -o $[@]'
7759                 test "$cf_cv_shlib_version" = auto && cf_cv_shlib_version=rel
7760                 ;;
7761         (solaris2*)
7762                 # tested with SunOS 5.5.1 (solaris 2.5.1) and gcc 2.7.2
7763                 # tested with SunOS 5.10 (solaris 10) and gcc 3.4.3
7764                 if test "$DFT_LWR_MODEL" = "shared" ; then
7765                         LOCAL_LDFLAGS="-R \$(LOCAL_LIBDIR):\${libdir}"
7766                         LOCAL_LDFLAGS2="$LOCAL_LDFLAGS"
7767                 fi
7768                 if test "$cf_cv_enable_rpath" = yes ; then
7769                         EXTRA_LDFLAGS="-R \${libdir} $EXTRA_LDFLAGS"
7770                 fi
7771                 CF_SHARED_SONAME
7772                 if test "$GCC" != yes; then
7773                         cf_save_CFLAGS="$CFLAGS"
7774                         for cf_shared_opts in -xcode=pic32 -xcode=pic13 -KPIC -Kpic -O
7775                         do
7776                                 CFLAGS="$cf_shared_opts $cf_save_CFLAGS"
7777                                 AC_TRY_COMPILE([#include <stdio.h>],[printf("Hello\\n");],[break])
7778                         done
7779                         CFLAGS="$cf_save_CFLAGS"
7780                         CC_SHARED_OPTS=$cf_shared_opts
7781                         MK_SHARED_LIB='${CC} ${LDFLAGS} ${CFLAGS} -dy -G -h '$cf_cv_shared_soname' -o $[@]'
7782                 else
7783                         MK_SHARED_LIB='${CC} ${LDFLAGS} ${CFLAGS} -shared -dy -G -h '$cf_cv_shared_soname' -o $[@]'
7784                 fi
7785                 ;;
7786         (sysv5uw7*|unix_sv*)
7787                 # tested with UnixWare 7.1.0 (gcc 2.95.2 and cc)
7788                 if test "$GCC" != yes; then
7789                         CC_SHARED_OPTS='-KPIC'
7790                 fi
7791                 MK_SHARED_LIB='${LD} ${LDFLAGS} -d y -G -o [$]@'
7792                 ;;
7793         (*)
7794                 CC_SHARED_OPTS='unknown'
7795                 MK_SHARED_LIB='echo unknown'
7796                 ;;
7797         esac
7798
7799         # This works if the last tokens in $MK_SHARED_LIB are the -o target.
7800         case "$cf_cv_shlib_version" in
7801         (rel|abi)
7802                 case "$MK_SHARED_LIB" in
7803                 (*'-o $[@]')
7804                         test "$cf_cv_do_symlinks" = no && cf_cv_do_symlinks=yes
7805                         ;;
7806                 (*)
7807                         AC_MSG_WARN(ignored --with-shlib-version)
7808                         ;;
7809                 esac
7810                 ;;
7811         esac
7812
7813         if test -n "$cf_try_cflags"
7814         then
7815 cat > conftest.$ac_ext <<EOF
7816 #line __oline__ "${as_me:-configure}"
7817 #include <stdio.h>
7818 int main(int argc, char *argv[[]])
7819 {
7820         printf("hello\\n");
7821         return (argv[[argc-1]] == 0) ;
7822 }
7823 EOF
7824                 cf_save_CFLAGS="$CFLAGS"
7825                 for cf_opt in $cf_try_cflags
7826                 do
7827                         CFLAGS="$cf_save_CFLAGS -$cf_opt"
7828                         AC_MSG_CHECKING(if CFLAGS option -$cf_opt works)
7829                         if AC_TRY_EVAL(ac_compile); then
7830                                 AC_MSG_RESULT(yes)
7831                                 cf_save_CFLAGS="$CFLAGS"
7832                         else
7833                                 AC_MSG_RESULT(no)
7834                         fi
7835                 done
7836                 CFLAGS="$cf_save_CFLAGS"
7837         fi
7838
7839
7840         # RPATH_LIST is a colon-separated list of directories
7841         test -n "$cf_ld_rpath_opt" && MK_SHARED_LIB="$MK_SHARED_LIB $cf_ld_rpath_opt\${RPATH_LIST}"
7842         test -z "$RPATH_LIST" && RPATH_LIST="\${libdir}"
7843
7844         test "$cf_cv_rm_so_locs" = yes && RM_SHARED_OPTS="$RM_SHARED_OPTS so_locations"
7845
7846         CF_VERBOSE(CC_SHARED_OPTS: $CC_SHARED_OPTS)
7847         CF_VERBOSE(MK_SHARED_LIB:  $MK_SHARED_LIB)
7848
7849         AC_SUBST(CC_SHARED_OPTS)
7850         AC_SUBST(LD_RPATH_OPT)
7851         AC_SUBST(LD_SHARED_OPTS)
7852         AC_SUBST(MK_SHARED_LIB)
7853         AC_SUBST(RM_SHARED_OPTS)
7854
7855         AC_SUBST(LINK_PROGS)
7856         AC_SUBST(LINK_TESTS)
7857
7858         AC_SUBST(EXTRA_LDFLAGS)
7859         AC_SUBST(LOCAL_LDFLAGS)
7860         AC_SUBST(LOCAL_LDFLAGS2)
7861
7862         AC_SUBST(INSTALL_LIB)
7863         AC_SUBST(RPATH_LIST)
7864 ])dnl
7865 dnl ---------------------------------------------------------------------------
7866 dnl CF_SHARED_SONAME version: 3 updated: 2008/09/08 18:34:43
7867 dnl ----------------
7868 dnl utility macro for CF_SHARED_OPTS, constructs "$cf_cv_shared_soname" for
7869 dnl substitution into MK_SHARED_LIB string for the "-soname" (or similar)
7870 dnl option.
7871 dnl
7872 dnl $1 is the default that should be used for "$cf_cv_shlib_version".
7873 dnl If missing, use "rel".
7874 define([CF_SHARED_SONAME],
7875 [
7876         test "$cf_cv_shlib_version" = auto && cf_cv_shlib_version=ifelse($1,,rel,$1)
7877         if test "$cf_cv_shlib_version" = rel; then
7878                 cf_cv_shared_soname='`basename $[@] .${REL_VERSION}`.${ABI_VERSION}'
7879         else
7880                 cf_cv_shared_soname='`basename $[@]`'
7881         fi
7882 ])
7883 dnl ---------------------------------------------------------------------------
7884 dnl CF_SIGWINCH version: 7 updated: 2023/02/18 17:41:25
7885 dnl -----------
7886 dnl Use this macro after CF_XOPEN_SOURCE, but do not require it (not all
7887 dnl programs need this test).
7888 dnl
7889 dnl This is really a Mac OS X 10.4.3 workaround.  Defining _POSIX_C_SOURCE
7890 dnl forces SIGWINCH to be undefined (breaks xterm, ncurses).  Oddly, the struct
7891 dnl winsize declaration is left alone - we may revisit this if Apple choose to
7892 dnl break that part of the interface as well.
7893 AC_DEFUN([CF_SIGWINCH],
7894 [
7895 AC_CACHE_CHECK(if SIGWINCH is defined,cf_cv_define_sigwinch,[
7896         AC_TRY_COMPILE([
7897 #include <sys/types.h>
7898 #include <sys/signal.h>
7899 ],[int x = SIGWINCH; (void)x],
7900         [cf_cv_define_sigwinch=yes],
7901         [AC_TRY_COMPILE([
7902 #undef _XOPEN_SOURCE
7903 #undef _POSIX_SOURCE
7904 #undef _POSIX_C_SOURCE
7905 #include <sys/types.h>
7906 #include <sys/signal.h>
7907 ],[int x = SIGWINCH; (void)x],
7908         [cf_cv_define_sigwinch=maybe],
7909         [cf_cv_define_sigwinch=no])
7910 ])
7911 ])
7912
7913 if test "$cf_cv_define_sigwinch" = maybe ; then
7914 AC_CACHE_CHECK(for actual SIGWINCH definition,cf_cv_fixup_sigwinch,[
7915 cf_cv_fixup_sigwinch=unknown
7916 cf_sigwinch=32
7917 while test "$cf_sigwinch" != 1
7918 do
7919         AC_TRY_COMPILE([
7920 #undef _XOPEN_SOURCE
7921 #undef _POSIX_SOURCE
7922 #undef _POSIX_C_SOURCE
7923 #include <sys/types.h>
7924 #include <sys/signal.h>
7925 ],[
7926 #if SIGWINCH != $cf_sigwinch
7927 #error SIGWINCH is not $cf_sigwinch
7928 #endif
7929 int x = SIGWINCH; (void)x],
7930         [cf_cv_fixup_sigwinch=$cf_sigwinch
7931          break])
7932
7933 cf_sigwinch="`expr "$cf_sigwinch" - 1`"
7934 done
7935 ])
7936
7937         if test "$cf_cv_fixup_sigwinch" != unknown ; then
7938                 CPPFLAGS="$CPPFLAGS -DSIGWINCH=$cf_cv_fixup_sigwinch"
7939         fi
7940 fi
7941 ])dnl
7942 dnl ---------------------------------------------------------------------------
7943 dnl CF_SIG_ATOMIC_T version: 5 updated: 2020/03/10 18:53:47
7944 dnl ---------------
7945 dnl signal handler, but there are some gcc dependencies in that recommendation.
7946 dnl Try anyway.
7947 AC_DEFUN([CF_SIG_ATOMIC_T],
7948 [
7949 AC_MSG_CHECKING(for signal global datatype)
7950 AC_CACHE_VAL(cf_cv_sig_atomic_t,[
7951         for cf_type in \
7952                 "volatile sig_atomic_t" \
7953                 "sig_atomic_t" \
7954                 "int"
7955         do
7956         AC_TRY_COMPILE([
7957 #include <sys/types.h>
7958 #include <signal.h>
7959 #include <stdio.h>
7960
7961 extern $cf_type x;
7962 $cf_type x;
7963 static void handler(int sig)
7964 {
7965         (void)sig;
7966         x = 5;
7967 }],
7968                 [signal(SIGINT, handler);
7969                  x = 1],
7970                 [cf_cv_sig_atomic_t=$cf_type],
7971                 [cf_cv_sig_atomic_t=no])
7972                 test "$cf_cv_sig_atomic_t" != no && break
7973         done
7974         ])
7975 AC_MSG_RESULT($cf_cv_sig_atomic_t)
7976 test "$cf_cv_sig_atomic_t" != no && AC_DEFINE_UNQUOTED(SIG_ATOMIC_T, $cf_cv_sig_atomic_t,[Define to signal global datatype])
7977 ])dnl
7978 dnl ---------------------------------------------------------------------------
7979 dnl CF_SIZECHANGE version: 18 updated: 2021/09/04 06:35:04
7980 dnl -------------
7981 dnl Check for definitions & structures needed for window size-changing
7982 dnl
7983 dnl https://stackoverflow.com/questions/18878141/difference-between-structures-ttysize-and-winsize/50769952#50769952
7984 AC_DEFUN([CF_SIZECHANGE],
7985 [
7986 AC_REQUIRE([CF_STRUCT_TERMIOS])
7987 AC_CACHE_CHECK(declaration of size-change, cf_cv_sizechange,[
7988         cf_cv_sizechange=unknown
7989         cf_save_CPPFLAGS="$CPPFLAGS"
7990
7991 for cf_opts in "" "NEED_PTEM_H"
7992 do
7993
7994         CPPFLAGS="$cf_save_CPPFLAGS"
7995         if test -n "$cf_opts"
7996         then
7997                 CF_APPEND_TEXT(CPPFLAGS,-D$cf_opts)
7998         fi
7999         AC_TRY_COMPILE([#include <sys/types.h>
8000 #ifdef HAVE_TERMIOS_H
8001 #include <termios.h>
8002 #else
8003 #ifdef HAVE_TERMIO_H
8004 #include <termio.h>
8005 #endif
8006 #endif
8007
8008 #ifdef NEED_PTEM_H
8009 /* This is a workaround for SCO:  they neglected to define struct winsize in
8010  * termios.h -- it is only in termio.h and ptem.h
8011  */
8012 #include <sys/stream.h>
8013 #include <sys/ptem.h>
8014 #endif
8015
8016 #ifdef HAVE_SYS_IOCTL_H
8017 #include <sys/ioctl.h>
8018 #endif
8019 ],[
8020 #ifdef TIOCGSIZE
8021         struct ttysize win;     /* SunOS 3.0... */
8022         int y = win.ts_lines = 2;
8023         int x = win.ts_cols = 1;
8024         (void)y;
8025         (void)x;
8026 #else
8027 #ifdef TIOCGWINSZ
8028         struct winsize win;     /* everything else */
8029         int y = win.ws_row = 2;
8030         int x = win.ws_col = 1;
8031         (void)y;
8032         (void)x;
8033 #else
8034         no TIOCGSIZE or TIOCGWINSZ
8035 #endif /* TIOCGWINSZ */
8036 #endif /* TIOCGSIZE */
8037         ],
8038         [cf_cv_sizechange=yes],
8039         [cf_cv_sizechange=no])
8040
8041         CPPFLAGS="$cf_save_CPPFLAGS"
8042         if test "$cf_cv_sizechange" = yes ; then
8043                 echo "size-change succeeded ($cf_opts)" >&AC_FD_CC
8044                 test -n "$cf_opts" && cf_cv_sizechange="$cf_opts"
8045                 break
8046         fi
8047 done
8048 ])
8049 if test "$cf_cv_sizechange" != no ; then
8050         AC_DEFINE(HAVE_SIZECHANGE,1,[Define to 1 if sizechange declarations are provided])
8051         case "$cf_cv_sizechange" in
8052         (NEED*)
8053                 AC_DEFINE_UNQUOTED($cf_cv_sizechange )
8054                 ;;
8055         esac
8056 fi
8057 ])dnl
8058 dnl ---------------------------------------------------------------------------
8059 dnl CF_SRC_MODULES version: 33 updated: 2021/01/01 13:31:04
8060 dnl --------------
8061 dnl For each parameter, test if the source-directory exists, and if it contains
8062 dnl a 'modules' file.  If so, add to the list $cf_cv_src_modules which we'll
8063 dnl use in CF_LIB_RULES.
8064 dnl
8065 dnl This uses the configured value to make the lists SRC_SUBDIRS and
8066 dnl SUB_MAKEFILES which are used in the makefile-generation scheme.
8067 AC_DEFUN([CF_SRC_MODULES],
8068 [
8069 AC_REQUIRE([CF_CHECK_GNAT_VERSION])
8070 AC_MSG_CHECKING(for src modules)
8071
8072 # dependencies and linker-arguments for test-programs
8073 TEST_DEPS="${LIB_DIR}/${LIB_PREFIX}${LIB_NAME}${DFT_DEP_SUFFIX} $TEST_DEPS"
8074 TEST_DEP2="${LIB_2ND}/${LIB_PREFIX}${LIB_NAME}${DFT_DEP_SUFFIX} $TEST_DEP2"
8075 if test "$DFT_LWR_MODEL" = "libtool"; then
8076         TEST_ARGS="${TEST_DEPS}"
8077         TEST_ARG2="${TEST_DEP2}"
8078 else
8079         TEST_ARGS="-l${LIB_NAME}${USE_ARG_SUFFIX} $TEST_ARGS"
8080         TEST_ARG2="-l${LIB_NAME}${USE_ARG_SUFFIX} $TEST_ARG2"
8081 fi
8082
8083 PC_MODULES_TO_MAKE="ncurses${USE_ARG_SUFFIX}"
8084 cf_cv_src_modules=
8085 for cf_dir in $1
8086 do
8087         if test -f "$srcdir/$cf_dir/modules" ; then
8088
8089                 # We may/may not have tack in the distribution, though the
8090                 # makefile is.
8091                 if test "$cf_dir" = tack ; then
8092                         if test "x$cf_with_tack" != "xyes"; then
8093                                 continue
8094                         fi
8095                 fi
8096
8097                 if test -z "$cf_cv_src_modules"; then
8098                         cf_cv_src_modules=$cf_dir
8099                 else
8100                         cf_cv_src_modules="$cf_cv_src_modules $cf_dir"
8101                 fi
8102
8103                 # Make the ncurses_cfg.h file record the library interface files as
8104                 # well.  These are header files that are the same name as their
8105                 # directory.  Ncurses is the only library that does not follow
8106                 # that pattern.
8107                 if test "$cf_dir" = tack ; then
8108                         continue
8109                 elif test -f "$srcdir/${cf_dir}/${cf_dir}.h" ; then
8110                         CF_UPPER(cf_have_include,$cf_dir)
8111                         AC_DEFINE_UNQUOTED(HAVE_${cf_have_include}_H)
8112                         AC_DEFINE_UNQUOTED(HAVE_LIB${cf_have_include})
8113                         CF_MAP_LIB_BASENAME(TEST_ROOT,$cf_dir)
8114                         TEST_DEPS="${LIB_DIR}/${LIB_PREFIX}${TEST_ROOT}${DFT_DEP_SUFFIX} $TEST_DEPS"
8115                         TEST_DEP2="${LIB_2ND}/${LIB_PREFIX}${TEST_ROOT}${DFT_DEP_SUFFIX} $TEST_DEP2"
8116                         if test "$DFT_LWR_MODEL" = "libtool"; then
8117                                 TEST_ARGS="${TEST_DEPS}"
8118                                 TEST_ARG2="${TEST_DEP2}"
8119                         else
8120                                 TEST_ARGS="-l${TEST_ROOT}${USE_ARG_SUFFIX} $TEST_ARGS"
8121                                 TEST_ARG2="-l${TEST_ROOT}${USE_ARG_SUFFIX} $TEST_ARG2"
8122                         fi
8123                         PC_MODULES_TO_MAKE="${PC_MODULES_TO_MAKE} ${cf_dir}${USE_ARG_SUFFIX}"
8124                 fi
8125         fi
8126 done
8127 AC_MSG_RESULT($cf_cv_src_modules)
8128
8129 TEST_ARGS="-L${LIB_DIR} $TEST_ARGS"
8130 TEST_ARG2="-L${LIB_2ND} $TEST_ARG2"
8131
8132 AC_SUBST(TEST_ARGS)
8133 AC_SUBST(TEST_DEPS)
8134
8135 AC_SUBST(TEST_ARG2)
8136 AC_SUBST(TEST_DEP2)
8137
8138 SRC_SUBDIRS=
8139 if test "x$cf_with_manpages" != xno ; then
8140         SRC_SUBDIRS="$SRC_SUBDIRS man"
8141 fi
8142 SRC_SUBDIRS="$SRC_SUBDIRS include"
8143 for cf_dir in $cf_cv_src_modules
8144 do
8145         SRC_SUBDIRS="$SRC_SUBDIRS $cf_dir"
8146 done
8147 if test "x$cf_with_tests" != "xno" ; then
8148         SRC_SUBDIRS="$SRC_SUBDIRS test"
8149 fi
8150 # always make this, to install the ncurses-config script
8151 SRC_SUBDIRS="$SRC_SUBDIRS misc"
8152 if test "$cf_with_cxx_binding" != no; then
8153         PC_MODULES_TO_MAKE="${PC_MODULES_TO_MAKE} ncurses++${USE_ARG_SUFFIX}"
8154         SRC_SUBDIRS="$SRC_SUBDIRS c++"
8155 fi
8156
8157 test "x$with_termlib" != xno && PC_MODULES_TO_MAKE="$PC_MODULES_TO_MAKE $TINFO_ARG_SUFFIX"
8158 test "x$with_ticlib" != xno && PC_MODULES_TO_MAKE="$PC_MODULES_TO_MAKE $TICS_ARG_SUFFIX"
8159
8160 AC_SUBST(PC_MODULES_TO_MAKE)
8161
8162 ADA_SUBDIRS=
8163 if test "x$cf_with_ada" = "xyes" && test "x$cf_cv_prog_gnat_correct" = xyes && test -f "$srcdir/Ada95/Makefile.in" ; then
8164         SRC_SUBDIRS="$SRC_SUBDIRS Ada95"
8165         ADA_SUBDIRS="gen src"
8166         if test "x$cf_with_tests" != "xno" ; then
8167                 ADA_SUBDIRS="$ADA_SUBDIRS samples"
8168         fi
8169 fi
8170
8171 SUB_MAKEFILES=
8172 for cf_dir in $SRC_SUBDIRS
8173 do
8174         SUB_MAKEFILES="$SUB_MAKEFILES $cf_dir/Makefile"
8175 done
8176
8177 if test -n "$ADA_SUBDIRS"; then
8178         for cf_dir in $ADA_SUBDIRS
8179         do
8180                 SUB_MAKEFILES="$SUB_MAKEFILES Ada95/$cf_dir/Makefile"
8181         done
8182         AC_SUBST(ADA_SUBDIRS)
8183 fi
8184 ])dnl
8185 dnl ---------------------------------------------------------------------------
8186 dnl CF_STDCPP_LIBRARY version: 12 updated: 2021/01/01 13:31:04
8187 dnl -----------------
8188 dnl Check for -lstdc++, which is GNU's standard C++ library.
8189 dnl If $CXXLIBS is set, add that to the libraries used for test-linking.
8190 dnl If -lstdc++ was not already added to $LIBS or $CXXLIBS, and is needed,
8191 dnl add it to $CXXLIBS.
8192 AC_DEFUN([CF_STDCPP_LIBRARY],
8193 [
8194 if test -n "$GXX" ; then
8195
8196         cf_save="$LIBS"
8197         LIBS="$LIBS $CXXLIBS"
8198         AC_MSG_CHECKING(if we already have C++ library)
8199         AC_TRY_LINK([
8200                         #include <iostream>],[
8201                         std::cout << "Hello World!" << std::endl;],
8202                 [cf_have_libstdcpp=yes],
8203                 [cf_have_libstdcpp=no])
8204         AC_MSG_RESULT($cf_have_libstdcpp)
8205         LIBS="$cf_save"
8206
8207         if test "$cf_have_libstdcpp" != yes
8208         then
8209                 case "$cf_cv_system_name" in
8210                 (os2*)
8211                         if test -z "`g++ -dM -E - < /dev/null | grep __KLIBC__`"; then
8212                                 cf_stdcpp_libname=stdcpp
8213                         else
8214                                 cf_stdcpp_libname=stdc++
8215                         fi
8216                         ;;
8217                 (*)
8218                         cf_stdcpp_libname=stdc++
8219                         ;;
8220                 esac
8221
8222                 AC_CACHE_CHECK(for library $cf_stdcpp_libname,cf_cv_libstdcpp,[
8223                         cf_save="$LIBS"
8224                         LIBS="$LIBS $CXXLIBS"
8225                         CF_ADD_LIB($cf_stdcpp_libname)
8226                 AC_TRY_LINK([
8227                                 #include <iostream>],[
8228                                 std::cout << "Hello World!" << std::endl;],
8229                         [cf_cv_libstdcpp=yes],
8230                         [cf_cv_libstdcpp=no])
8231                         LIBS="$cf_save"
8232                 ])
8233                 test "$cf_cv_libstdcpp" = yes && { CF_ADD_LIB($cf_stdcpp_libname,CXXLIBS) }
8234         fi
8235 fi
8236 ])dnl
8237 dnl ---------------------------------------------------------------------------
8238 dnl CF_STRIP_G_OPT version: 4 updated: 2021/01/02 09:31:20
8239 dnl --------------
8240 dnl     Remove "-g" option from the compiler options
8241 AC_DEFUN([CF_STRIP_G_OPT],
8242 [$1=`echo "${$1}" | CF__SED_TRIMBLANKS(-e 's%-g %%' -e 's%-g$%%')`])dnl
8243 dnl ---------------------------------------------------------------------------
8244 dnl CF_STRUCT_SIGACTION version: 5 updated: 2012/10/06 17:56:13
8245 dnl -------------------
8246 dnl Check if we need _POSIX_SOURCE defined to use struct sigaction.  We'll only
8247 dnl do this if we've found the sigaction function.
8248 AC_DEFUN([CF_STRUCT_SIGACTION],[
8249 AC_REQUIRE([CF_XOPEN_SOURCE])
8250
8251 if test "$ac_cv_func_sigaction" = yes; then
8252 AC_MSG_CHECKING(whether sigaction needs _POSIX_SOURCE)
8253 AC_TRY_COMPILE([
8254 #include <sys/types.h>
8255 #include <signal.h>],
8256         [struct sigaction act],
8257         [sigact_bad=no],
8258         [
8259 AC_TRY_COMPILE([
8260 #define _POSIX_SOURCE
8261 #include <sys/types.h>
8262 #include <signal.h>],
8263         [struct sigaction act],
8264         [sigact_bad=yes
8265          AC_DEFINE(_POSIX_SOURCE,1,[Define to 1 if we must define _POSIX_SOURCE])],
8266          [sigact_bad=unknown])])
8267 AC_MSG_RESULT($sigact_bad)
8268 fi
8269 ])dnl
8270 dnl ---------------------------------------------------------------------------
8271 dnl CF_STRUCT_TERMIOS version: 11 updated: 2020/03/19 20:46:13
8272 dnl -----------------
8273 dnl Some machines require _POSIX_SOURCE to completely define struct termios.
8274 AC_DEFUN([CF_STRUCT_TERMIOS],[
8275 AC_REQUIRE([CF_XOPEN_SOURCE])
8276
8277 AC_CHECK_HEADERS( \
8278 termio.h \
8279 termios.h \
8280 unistd.h \
8281 sys/ioctl.h \
8282 sys/termio.h \
8283 )
8284
8285 if test "$ac_cv_header_termios_h" = yes ; then
8286         case "$CFLAGS $CPPFLAGS" in
8287         (*-D_POSIX_SOURCE*)
8288                 termios_bad=dunno ;;
8289         (*)     termios_bad=maybe ;;
8290         esac
8291         if test "$termios_bad" = maybe ; then
8292         AC_MSG_CHECKING(whether termios.h needs _POSIX_SOURCE)
8293         AC_TRY_COMPILE([#include <termios.h>],
8294                 [struct termios foo; int x = foo.c_iflag = 1; (void)x],
8295                 termios_bad=no, [
8296                 AC_TRY_COMPILE([
8297 #define _POSIX_SOURCE
8298 #include <termios.h>],
8299                         [struct termios foo; int x = foo.c_iflag = 2; (void)x],
8300                         termios_bad=unknown,
8301                         termios_bad=yes AC_DEFINE(_POSIX_SOURCE,1,[Define to 1 if we must define _POSIX_SOURCE]))
8302                         ])
8303         AC_MSG_RESULT($termios_bad)
8304         fi
8305 fi
8306 ])dnl
8307 dnl ---------------------------------------------------------------------------
8308 dnl CF_SUBDIR_PATH version: 7 updated: 2014/12/04 04:33:06
8309 dnl --------------
8310 dnl Construct a search-list for a nonstandard header/lib-file
8311 dnl     $1 = the variable to return as result
8312 dnl     $2 = the package name
8313 dnl     $3 = the subdirectory, e.g., bin, include or lib
8314 AC_DEFUN([CF_SUBDIR_PATH],
8315 [
8316 $1=
8317
8318 CF_ADD_SUBDIR_PATH($1,$2,$3,$prefix,NONE)
8319
8320 for cf_subdir_prefix in \
8321         /usr \
8322         /usr/local \
8323         /usr/pkg \
8324         /opt \
8325         /opt/local \
8326         [$]HOME
8327 do
8328         CF_ADD_SUBDIR_PATH($1,$2,$3,$cf_subdir_prefix,$prefix)
8329 done
8330 ])dnl
8331 dnl ---------------------------------------------------------------------------
8332 dnl CF_SUBST_IF version: 2 updated: 2006/06/17 12:33:03
8333 dnl -----------
8334 dnl     Shorthand macro for substituting things that the user may override
8335 dnl     with an environment variable.
8336 dnl
8337 dnl     $1 = condition to pass to "test"
8338 dnl     $2 = environment variable
8339 dnl     $3 = value if the test succeeds
8340 dnl     $4 = value if the test fails
8341 AC_DEFUN([CF_SUBST_IF],
8342 [
8343 if test $1 ; then
8344         $2=$3
8345 ifelse($4,,,[else
8346         $2=$4])
8347 fi
8348 AC_SUBST($2)
8349 ])dnl
8350 dnl ---------------------------------------------------------------------------
8351 dnl CF_SUBST_NCURSES_VERSION version: 11 updated: 2023/01/07 16:32:06
8352 dnl ------------------------
8353 dnl Get the version-number for use in shared-library naming, etc.
8354 AC_DEFUN([CF_SUBST_NCURSES_VERSION],
8355 [AC_REQUIRE([AC_PROG_EGREP])dnl
8356
8357 NCURSES_MAJOR="`${EGREP-egrep} '^NCURSES_MAJOR[[        ]]*=' "$srcdir/dist.mk" | sed -e 's/^[[^0-9]]*//'`"
8358 NCURSES_MINOR="`${EGREP-egrep} '^NCURSES_MINOR[[        ]]*=' "$srcdir/dist.mk" | sed -e 's/^[[^0-9]]*//'`"
8359 NCURSES_PATCH="`${EGREP-egrep} '^NCURSES_PATCH[[        ]]*=' "$srcdir/dist.mk" | sed -e 's/^[[^0-9]]*//'`"
8360 cf_cv_abi_version=${NCURSES_MAJOR}
8361 cf_cv_abi_default=${NCURSES_MAJOR}
8362 cf_cv_rel_version=${NCURSES_MAJOR}.${NCURSES_MINOR}
8363 dnl Show the computed version, for logging
8364 cf_cv_timestamp=`date`
8365 AC_MSG_RESULT(Configuring NCURSES $cf_cv_rel_version ABI $cf_cv_abi_default ($cf_cv_timestamp))
8366 dnl We need these values in the generated headers
8367 AC_SUBST(NCURSES_MAJOR)
8368 AC_SUBST(NCURSES_MINOR)
8369 AC_SUBST(NCURSES_PATCH)
8370 dnl We need these values in the generated makefiles
8371 AC_SUBST(cf_cv_rel_version)
8372 AC_SUBST(cf_cv_abi_version)
8373 AC_SUBST(cf_cv_abi_default)
8374 AC_SUBST(cf_cv_builtin_bool)
8375 AC_SUBST(cf_cv_header_stdbool_h)
8376 AC_SUBST(cf_cv_type_of_bool)dnl
8377 ])dnl
8378 dnl ---------------------------------------------------------------------------
8379 dnl CF_SYS_TIME_SELECT version: 6 updated: 2015/04/18 08:56:57
8380 dnl ------------------
8381 dnl Check if we can include <sys/time.h> with <sys/select.h>; this breaks on
8382 dnl older SCO configurations.
8383 AC_DEFUN([CF_SYS_TIME_SELECT],
8384 [
8385 AC_MSG_CHECKING(if sys/time.h works with sys/select.h)
8386 AC_CACHE_VAL(cf_cv_sys_time_select,[
8387 AC_TRY_COMPILE([
8388 #include <sys/types.h>
8389 #ifdef HAVE_SYS_TIME_H
8390 #include <sys/time.h>
8391 #endif
8392 #ifdef HAVE_SYS_SELECT_H
8393 #include <sys/select.h>
8394 #endif
8395 ],[],[cf_cv_sys_time_select=yes],
8396          [cf_cv_sys_time_select=no])
8397          ])
8398 AC_MSG_RESULT($cf_cv_sys_time_select)
8399 test "$cf_cv_sys_time_select" = yes && AC_DEFINE(HAVE_SYS_TIME_SELECT,1,[Define to 1 if we can include <sys/time.h> with <sys/select.h>])
8400 ])dnl
8401 dnl ---------------------------------------------------------------------------
8402 dnl CF_TOP_BUILDDIR version: 2 updated: 2013/07/27 17:38:32
8403 dnl ---------------
8404 dnl Define a top_builddir symbol, for applications that need an absolute path.
8405 AC_DEFUN([CF_TOP_BUILDDIR],
8406 [
8407 top_builddir=ifelse($1,,`pwd`,$1)
8408 AC_SUBST(top_builddir)
8409 ])dnl
8410 dnl ---------------------------------------------------------------------------
8411 dnl CF_TRY_PKG_CONFIG version: 6 updated: 2020/12/31 10:54:15
8412 dnl -----------------
8413 dnl This is a simple wrapper to use for pkg-config, for libraries which may be
8414 dnl available in that form.
8415 dnl
8416 dnl $1 = package name, which may be a shell variable
8417 dnl $2 = extra logic to use, if any, after updating CFLAGS and LIBS
8418 dnl $3 = logic to use if pkg-config does not have the package
8419 AC_DEFUN([CF_TRY_PKG_CONFIG],[
8420 AC_REQUIRE([CF_PKG_CONFIG])
8421
8422 if test "$PKG_CONFIG" != none && "$PKG_CONFIG" --exists "$1"; then
8423         CF_VERBOSE(found package $1)
8424         cf_pkgconfig_incs="`$PKG_CONFIG --cflags "$1" 2>/dev/null`"
8425         cf_pkgconfig_libs="`$PKG_CONFIG --libs   "$1" 2>/dev/null`"
8426         CF_VERBOSE(package $1 CFLAGS: $cf_pkgconfig_incs)
8427         CF_VERBOSE(package $1 LIBS: $cf_pkgconfig_libs)
8428         CF_ADD_CFLAGS($cf_pkgconfig_incs)
8429         CF_ADD_LIBS($cf_pkgconfig_libs)
8430         ifelse([$2],,:,[$2])
8431 else
8432         cf_pkgconfig_incs=
8433         cf_pkgconfig_libs=
8434         ifelse([$3],,:,[$3])
8435 fi
8436 ])
8437 dnl ---------------------------------------------------------------------------
8438 dnl CF_TRY_XOPEN_SOURCE version: 4 updated: 2022/09/10 15:16:16
8439 dnl -------------------
8440 dnl If _XOPEN_SOURCE is not defined in the compile environment, check if we
8441 dnl can define it successfully.
8442 AC_DEFUN([CF_TRY_XOPEN_SOURCE],[
8443 AC_CACHE_CHECK(if we should define _XOPEN_SOURCE,cf_cv_xopen_source,[
8444         AC_TRY_COMPILE(CF__XOPEN_SOURCE_HEAD,CF__XOPEN_SOURCE_BODY,
8445         [cf_cv_xopen_source=no],
8446         [cf_save="$CPPFLAGS"
8447          CF_APPEND_TEXT(CPPFLAGS,-D_XOPEN_SOURCE=$cf_XOPEN_SOURCE)
8448          AC_TRY_COMPILE(CF__XOPEN_SOURCE_HEAD,CF__XOPEN_SOURCE_BODY,
8449                 [cf_cv_xopen_source=no],
8450                 [cf_cv_xopen_source=$cf_XOPEN_SOURCE])
8451                 CPPFLAGS="$cf_save"
8452         ])
8453 ])
8454
8455 if test "$cf_cv_xopen_source" != no ; then
8456         CF_REMOVE_DEFINE(CFLAGS,$CFLAGS,_XOPEN_SOURCE)
8457         CF_REMOVE_DEFINE(CPPFLAGS,$CPPFLAGS,_XOPEN_SOURCE)
8458         cf_temp_xopen_source="-D_XOPEN_SOURCE=$cf_cv_xopen_source"
8459         CF_APPEND_CFLAGS($cf_temp_xopen_source)
8460 fi
8461 ])
8462 dnl ---------------------------------------------------------------------------
8463 dnl CF_TYPEOF_CHTYPE version: 11 updated: 2023/01/05 17:57:59
8464 dnl ----------------
8465 dnl Determine the type we should use for chtype (and attr_t, which is treated
8466 dnl as the same thing).  We want around 32 bits, so on most machines want a
8467 dnl long, but on newer 64-bit machines, probably want an int.  If we're using
8468 dnl wide characters, we have to have a type compatible with that, as well.
8469 AC_DEFUN([CF_TYPEOF_CHTYPE],
8470 [
8471 AC_MSG_CHECKING([for type of chtype])
8472 AC_CACHE_VAL(cf_cv_typeof_chtype,[
8473                 AC_TRY_RUN([
8474 $ac_includes_default
8475 #define WANT_BITS 31
8476 int main(void)
8477 {
8478         FILE *fp = fopen("cf_test.out", "w");
8479         if (fp != 0) {
8480                 char *result = "long";
8481                 if (sizeof(unsigned long) > sizeof(unsigned int)) {
8482                         int n;
8483                         unsigned int x, y;
8484                         for (n = 0; n < WANT_BITS; n++) {
8485                                 x = (1 << n);
8486                                 y = (x >> n);
8487                                 if (y != 1 || x == 0) {
8488                                         x = 0;
8489                                         break;
8490                                 }
8491                         }
8492                         /*
8493                          * If x is nonzero, an int is big enough for the bits
8494                          * that we want.
8495                          */
8496                         result = (x != 0) ? "int" : "long";
8497                 }
8498                 fputs(result, fp);
8499                 fclose(fp);
8500         }
8501         ${cf_cv_main_return:-return}(0);
8502 }
8503                 ],
8504                 [cf_cv_typeof_chtype=`cat cf_test.out`],
8505                 [cf_cv_typeof_chtype=long],
8506                 [cf_cv_typeof_chtype=long])
8507                 rm -f cf_test.out
8508         ])
8509 AC_MSG_RESULT($cf_cv_typeof_chtype)
8510
8511 AC_SUBST(cf_cv_typeof_chtype)
8512 AC_DEFINE_UNQUOTED(TYPEOF_CHTYPE,$cf_cv_typeof_chtype,[Define to actual type if needed for chtype])
8513 ])dnl
8514 dnl ---------------------------------------------------------------------------
8515 dnl CF_TYPE_SIGACTION version: 4 updated: 2012/10/06 17:56:13
8516 dnl -----------------
8517 dnl
8518 AC_DEFUN([CF_TYPE_SIGACTION],
8519 [
8520 AC_MSG_CHECKING([for type sigaction_t])
8521 AC_CACHE_VAL(cf_cv_type_sigaction,[
8522         AC_TRY_COMPILE([
8523 #include <signal.h>],
8524                 [sigaction_t x],
8525                 [cf_cv_type_sigaction=yes],
8526                 [cf_cv_type_sigaction=no])])
8527 AC_MSG_RESULT($cf_cv_type_sigaction)
8528 test "$cf_cv_type_sigaction" = yes && AC_DEFINE(HAVE_TYPE_SIGACTION,1,[Define to 1 if we have the sigaction_t type])
8529 ])dnl
8530 dnl ---------------------------------------------------------------------------
8531 dnl CF_UNSIGNED_LITERALS version: 2 updated: 1998/02/07 22:10:16
8532 dnl --------------------
8533 dnl Test if the compiler supports 'U' and 'L' suffixes.  Only old compilers
8534 dnl won't, but they're still there.
8535 AC_DEFUN([CF_UNSIGNED_LITERALS],
8536 [
8537 AC_MSG_CHECKING([if unsigned literals are legal])
8538 AC_CACHE_VAL(cf_cv_unsigned_literals,[
8539         AC_TRY_COMPILE([],[long x = 1L + 1UL + 1U + 1],
8540                 [cf_cv_unsigned_literals=yes],
8541                 [cf_cv_unsigned_literals=no])
8542         ])
8543 AC_MSG_RESULT($cf_cv_unsigned_literals)
8544 ])dnl
8545 dnl ---------------------------------------------------------------------------
8546 dnl CF_UPPER version: 5 updated: 2001/01/29 23:40:59
8547 dnl --------
8548 dnl Make an uppercase version of a variable
8549 dnl $1=uppercase($2)
8550 AC_DEFUN([CF_UPPER],
8551 [
8552 $1=`echo "$2" | sed y%abcdefghijklmnopqrstuvwxyz./-%ABCDEFGHIJKLMNOPQRSTUVWXYZ___%`
8553 ])dnl
8554 dnl ---------------------------------------------------------------------------
8555 dnl CF_UTF8_LIB version: 10 updated: 2023/01/11 04:05:23
8556 dnl -----------
8557 dnl Check for multibyte support, and if not found, utf8 compatibility library
8558 AC_DEFUN([CF_UTF8_LIB],
8559 [
8560 AC_HAVE_HEADERS(wchar.h)
8561 AC_CACHE_CHECK(for multibyte character support,cf_cv_utf8_lib,[
8562         cf_save_LIBS="$LIBS"
8563         AC_TRY_LINK([
8564 $ac_includes_default
8565 #ifdef HAVE_WCHAR_H
8566 #include <wchar.h>
8567 #endif
8568 ],[putwc(0,0);],
8569         [cf_cv_utf8_lib=yes],
8570         [CF_FIND_LINKAGE([
8571 #include <libutf8.h>],[putwc(0,0);],utf8,
8572                 [cf_cv_utf8_lib=add-on],
8573                 [cf_cv_utf8_lib=no])
8574 ])])
8575
8576 # HAVE_LIBUTF8_H is used by ncurses if curses.h is shared between
8577 # ncurses/ncursesw:
8578 if test "$cf_cv_utf8_lib" = "add-on" ; then
8579         AC_DEFINE(HAVE_LIBUTF8_H,1,[Define to 1 if we should include libutf8.h])
8580         CF_ADD_INCDIR($cf_cv_header_path_utf8)
8581         CF_ADD_LIBDIR($cf_cv_library_path_utf8)
8582         CF_ADD_LIBS($cf_cv_library_file_utf8)
8583 fi
8584 ])dnl
8585 dnl ---------------------------------------------------------------------------
8586 dnl CF_VA_COPY version: 6 updated: 2018/12/04 18:14:25
8587 dnl ----------
8588 dnl check for va_copy, part of stdarg.h starting with ISO C 1999.
8589 dnl Also, workaround for glibc's __va_copy, by checking for both.
8590 dnl Finally, try to accommodate pre-ISO C 1999 headers.
8591 AC_DEFUN([CF_VA_COPY],[
8592 AC_CACHE_CHECK(for va_copy, cf_cv_have_va_copy,[
8593 AC_TRY_LINK([
8594 #include <stdarg.h>
8595 ],[
8596         static va_list dst;
8597         static va_list src;
8598         va_copy(dst, src)],
8599         cf_cv_have_va_copy=yes,
8600         cf_cv_have_va_copy=no)])
8601
8602 if test "$cf_cv_have_va_copy" = yes;
8603 then
8604         AC_DEFINE(HAVE_VA_COPY,1,[Define to 1 if we have va_copy])
8605 else # !cf_cv_have_va_copy
8606
8607 AC_CACHE_CHECK(for __va_copy, cf_cv_have___va_copy,[
8608 AC_TRY_LINK([
8609 #include <stdarg.h>
8610 ],[
8611         static va_list dst;
8612         static va_list src;
8613         __va_copy(dst, src)],
8614         cf_cv_have___va_copy=yes,
8615         cf_cv_have___va_copy=no)])
8616
8617 if test "$cf_cv_have___va_copy" = yes
8618 then
8619         AC_DEFINE(HAVE___VA_COPY,1,[Define to 1 if we have __va_copy])
8620 else # !cf_cv_have___va_copy
8621
8622 AC_CACHE_CHECK(for __builtin_va_copy, cf_cv_have___builtin_va_copy,[
8623 AC_TRY_LINK([
8624 #include <stdarg.h>
8625 ],[
8626         static va_list dst;
8627         static va_list src;
8628         __builtin_va_copy(dst, src)],
8629         cf_cv_have___builtin_va_copy=yes,
8630         cf_cv_have___builtin_va_copy=no)])
8631
8632 test "$cf_cv_have___builtin_va_copy" = yes &&
8633         AC_DEFINE(HAVE___BUILTIN_VA_COPY,1,[Define to 1 if we have __builtin_va_copy])
8634
8635 fi # cf_cv_have___va_copy
8636
8637 fi # cf_cv_have_va_copy
8638
8639 case "${cf_cv_have_va_copy}${cf_cv_have___va_copy}${cf_cv_have___builtin_va_copy}" in
8640 (*yes*)
8641         ;;
8642
8643 (*)
8644         AC_CACHE_CHECK(if we can simply copy va_list, cf_cv_pointer_va_list,[
8645 AC_TRY_LINK([
8646 #include <stdarg.h>
8647 ],[
8648         va_list dst;
8649         va_list src;
8650         dst = src],
8651         cf_cv_pointer_va_list=yes,
8652         cf_cv_pointer_va_list=no)])
8653
8654         if test "$cf_cv_pointer_va_list" = no
8655         then
8656                 AC_CACHE_CHECK(if we can copy va_list indirectly, cf_cv_array_va_list,[
8657 AC_TRY_LINK([
8658 #include <stdarg.h>
8659 ],[
8660         va_list dst;
8661         va_list src;
8662         *dst = *src],
8663                         cf_cv_array_va_list=yes,
8664                         cf_cv_array_va_list=no)])
8665                 test "$cf_cv_array_va_list" = yes && AC_DEFINE(ARRAY_VA_LIST,1,[Define to 1 if we can copy va_list indirectly])
8666         fi
8667         ;;
8668 esac
8669 ])
8670 dnl ---------------------------------------------------------------------------
8671 dnl CF_VERBOSE version: 3 updated: 2007/07/29 09:55:12
8672 dnl ----------
8673 dnl Use AC_VERBOSE w/o the warnings
8674 AC_DEFUN([CF_VERBOSE],
8675 [test -n "$verbose" && echo "   $1" 1>&AC_FD_MSG
8676 CF_MSG_LOG([$1])
8677 ])dnl
8678 dnl ---------------------------------------------------------------------------
8679 dnl CF_VERSION_INFO version: 8 updated: 2021/01/01 13:31:04
8680 dnl ---------------
8681 dnl Define several useful symbols derived from the VERSION file.  A separate
8682 dnl file is preferred to embedding the version numbers in various scripts.
8683 dnl (automake is a textbook-example of why the latter is a bad idea, but there
8684 dnl are others).
8685 dnl
8686 dnl The file contents are:
8687 dnl     libtool-version release-version patch-version
8688 dnl or
8689 dnl     release-version
8690 dnl where
8691 dnl     libtool-version (see ?) consists of 3 integers separated by '.'
8692 dnl     release-version consists of a major version and minor version
8693 dnl             separated by '.', optionally followed by a patch-version
8694 dnl             separated by '-'.  The minor version need not be an
8695 dnl             integer (but it is preferred).
8696 dnl     patch-version is an integer in the form yyyymmdd, so ifdef's and
8697 dnl             scripts can easily compare versions.
8698 dnl
8699 dnl If libtool is used, the first form is required, since CF_WITH_LIBTOOL
8700 dnl simply extracts the first field using 'cut -f1'.
8701 dnl
8702 dnl Optional parameters:
8703 dnl $1 = internal name for package
8704 dnl $2 = external name for package
8705 AC_DEFUN([CF_VERSION_INFO],
8706 [
8707 if test -f "$srcdir/VERSION" ; then
8708         AC_MSG_CHECKING(for package version)
8709
8710         # if there are not enough fields, cut returns the last one...
8711         cf_field1=`sed -e '2,$d' "$srcdir/VERSION" |cut -f1`
8712         cf_field2=`sed -e '2,$d' "$srcdir/VERSION" |cut -f2`
8713         cf_field3=`sed -e '2,$d' "$srcdir/VERSION" |cut -f3`
8714
8715         # this is how CF_BUNDLED_INTL uses $VERSION:
8716         VERSION="$cf_field1"
8717
8718         VERSION_MAJOR=`echo "$cf_field2" | sed -e 's/\..*//'`
8719         test -z "$VERSION_MAJOR" && AC_MSG_ERROR(missing major-version)
8720
8721         VERSION_MINOR=`echo "$cf_field2" | sed -e 's/^[[^.]]*\.//' -e 's/-.*//'`
8722         test -z "$VERSION_MINOR" && AC_MSG_ERROR(missing minor-version)
8723
8724         AC_MSG_RESULT(${VERSION_MAJOR}.${VERSION_MINOR})
8725
8726         AC_MSG_CHECKING(for package patch date)
8727         VERSION_PATCH=`echo "$cf_field3" | sed -e 's/^[[^-]]*-//'`
8728         case .$VERSION_PATCH in
8729         (.)
8730                 AC_MSG_ERROR(missing patch-date $VERSION_PATCH)
8731                 ;;
8732         (.[[0-9]][[0-9]][[0-9]][[0-9]][[0-9]][[0-9]][[0-9]][[0-9]])
8733                 ;;
8734         (*)
8735                 AC_MSG_ERROR(illegal patch-date $VERSION_PATCH)
8736                 ;;
8737         esac
8738         AC_MSG_RESULT($VERSION_PATCH)
8739 else
8740         AC_MSG_ERROR(did not find $srcdir/VERSION)
8741 fi
8742
8743 # show the actual data that we have for versions:
8744 CF_VERBOSE(ABI VERSION $VERSION)
8745 CF_VERBOSE(VERSION_MAJOR $VERSION_MAJOR)
8746 CF_VERBOSE(VERSION_MINOR $VERSION_MINOR)
8747 CF_VERBOSE(VERSION_PATCH $VERSION_PATCH)
8748
8749 AC_SUBST(VERSION)
8750 AC_SUBST(VERSION_MAJOR)
8751 AC_SUBST(VERSION_MINOR)
8752 AC_SUBST(VERSION_PATCH)
8753
8754 dnl if a package name is given, define its corresponding version info.  We
8755 dnl need the package name to ensure that the defined symbols are unique.
8756 ifelse($1,,,[
8757         cf_PACKAGE=$1
8758         PACKAGE=ifelse($2,,$1,$2)
8759         AC_DEFINE_UNQUOTED(PACKAGE, "$PACKAGE",[Define to the package-name])
8760         AC_SUBST(PACKAGE)
8761         CF_UPPER(cf_PACKAGE,$cf_PACKAGE)
8762         AC_DEFINE_UNQUOTED(${cf_PACKAGE}_VERSION,"${VERSION_MAJOR}.${VERSION_MINOR}")
8763         AC_DEFINE_UNQUOTED(${cf_PACKAGE}_PATCHDATE,${VERSION_PATCH})
8764 ])
8765 ])dnl
8766 dnl ---------------------------------------------------------------------------
8767 dnl CF_WCHAR_TYPE version: 4 updated: 2012/10/06 16:39:58
8768 dnl -------------
8769 dnl Check if type wide-character type $1 is declared, and if so, which header
8770 dnl file is needed.  The second parameter is used to set a shell variable when
8771 dnl the type is not found.  The first parameter sets a shell variable for the
8772 dnl opposite sense.
8773 AC_DEFUN([CF_WCHAR_TYPE],
8774 [
8775 # This is needed on Tru64 5.0 to declare $1
8776 AC_CACHE_CHECK(if we must include wchar.h to declare $1,cf_cv_$1,[
8777 AC_TRY_COMPILE([
8778 #include <stdlib.h>
8779 #include <stdarg.h>
8780 #include <stdio.h>
8781 #ifdef HAVE_LIBUTF8_H
8782 #include <libutf8.h>
8783 #endif],
8784         [$1 state],
8785         [cf_cv_$1=no],
8786         [AC_TRY_COMPILE([
8787 #include <stdlib.h>
8788 #include <stdarg.h>
8789 #include <stdio.h>
8790 #include <wchar.h>
8791 #ifdef HAVE_LIBUTF8_H
8792 #include <libutf8.h>
8793 #endif],
8794         [$1 value],
8795         [cf_cv_$1=yes],
8796         [cf_cv_$1=unknown])])])
8797
8798 if test "$cf_cv_$1" = yes ; then
8799         AC_DEFINE(NEED_WCHAR_H,1,[Define to 1 if we must include wchar.h])
8800         NEED_WCHAR_H=1
8801 fi
8802
8803 ifelse([$2],,,[
8804 # if we do not find $1 in either place, use substitution to provide a fallback.
8805 if test "$cf_cv_$1" = unknown ; then
8806         $2=1
8807 fi
8808 ])
8809 ifelse($3,,,[
8810 # if we find $1 in either place, use substitution to provide a fallback.
8811 if test "$cf_cv_$1" != unknown ; then
8812         $3=1
8813 fi
8814 ])
8815 ])dnl
8816 dnl ---------------------------------------------------------------------------
8817 dnl CF_WEAK_SYMBOLS version: 1 updated: 2008/08/16 19:18:06
8818 dnl ---------------
8819 dnl Check for compiler-support for weak symbols.
8820 dnl This works with "recent" gcc.
8821 AC_DEFUN([CF_WEAK_SYMBOLS],[
8822 AC_CACHE_CHECK(if $CC supports weak symbols,cf_cv_weak_symbols,[
8823
8824 AC_TRY_COMPILE([
8825 #include <stdio.h>],
8826 [
8827 #if defined(__GNUC__)
8828 #  if defined __USE_ISOC99
8829 #    define _cat_pragma(exp)    _Pragma(#exp)
8830 #    define _weak_pragma(exp)   _cat_pragma(weak name)
8831 #  else
8832 #    define _weak_pragma(exp)
8833 #  endif
8834 #  define _declare(name)        __extension__ extern __typeof__(name) name
8835 #  define weak_symbol(name)     _weak_pragma(name) _declare(name) __attribute__((weak))
8836 #endif
8837
8838 weak_symbol(fopen);
8839 ],[cf_cv_weak_symbols=yes],[cf_cv_weak_symbols=no])
8840 ])
8841 ])dnl
8842 dnl ---------------------------------------------------------------------------
8843 dnl CF_WITH_ABI_ALTERED version: 1 updated: 2023/01/07 16:32:06
8844 dnl -------------------
8845 dnl Provide a way to override the displayed ABI version, e.g., in filenames.
8846 dnl Check this option after using the ABI version in configuration decisions.
8847 AC_DEFUN([CF_WITH_ABI_ALTERED],[
8848 AC_REQUIRE([CF_WITH_ABI_VERSION])
8849 AC_REQUIRE([CF_ABI_DEFAULTS])
8850 AC_ARG_WITH(abi-altered,
8851 [  --with-abi-altered=XXX  override visible ABI version, for packaging],[
8852         CF_NUMBER_SYNTAX($withval,ABI altered)
8853         if test "$cf_cv_abi_version" != "$withval"
8854         then
8855                 AC_MSG_WARN(altering visible ABI from $cf_cv_abi_version to $withval)
8856                 cf_cv_abi_version=$withval
8857         fi
8858 ])dnl
8859 ])dnl
8860 dnl ---------------------------------------------------------------------------
8861 dnl CF_WITH_ABI_VERSION version: 5 updated: 2023/01/07 16:32:06
8862 dnl -------------------
8863 dnl Allow library's ABI to be overridden.  Generally this happens when a
8864 dnl packager has incremented the ABI past that used in the original package,
8865 dnl and wishes to keep doing this.
8866 dnl
8867 dnl $1 is the package name, if any, to derive a corresponding {package}_ABI
8868 dnl symbol.
8869 AC_DEFUN([CF_WITH_ABI_VERSION],[
8870 test -z "$cf_cv_abi_version" && cf_cv_abi_version=0
8871 AC_ARG_WITH(abi-version,
8872 [  --with-abi-version=XXX  override derived ABI version],[
8873         if test "x$cf_cv_abi_version" != "x$withval"
8874         then
8875                 AC_MSG_WARN(overriding ABI version $cf_cv_abi_version to $withval)
8876                 case "$cf_cv_rel_version" in
8877                 (5.*)
8878                         cf_cv_rel_version=$withval.0
8879                         ;;
8880                 (6.*)
8881                         cf_cv_rel_version=$withval.9    # FIXME: should be 10 as of 6.0 release
8882                         ;;
8883                 esac
8884         fi
8885         cf_cv_abi_version=$withval])
8886         CF_NUMBER_SYNTAX($cf_cv_abi_version,ABI version)
8887 ifelse($1,,,[
8888 $1_ABI=$cf_cv_abi_version
8889 ])
8890 cf_cv_abi_default=$cf_cv_abi_version
8891 ])dnl
8892 dnl ---------------------------------------------------------------------------
8893 dnl CF_WITH_ADA_COMPILER version: 2 updated: 2010/06/26 17:35:58
8894 dnl --------------------
8895 dnl Command-line option to specify the Ada95 compiler.
8896 AC_DEFUN([CF_WITH_ADA_COMPILER],[
8897 AC_MSG_CHECKING(for ada-compiler)
8898 AC_ARG_WITH(ada-compiler,
8899         [  --with-ada-compiler=CMD specify Ada95 compiler command (default gnatmake)],
8900         [cf_ada_compiler=$withval],
8901         [cf_ada_compiler=gnatmake])
8902 AC_SUBST(cf_ada_compiler)
8903 AC_MSG_RESULT($cf_ada_compiler)
8904 ])dnl
8905 dnl ---------------------------------------------------------------------------
8906 dnl CF_WITH_ADA_INCLUDE version: 2 updated: 2010/06/26 17:35:58
8907 dnl -------------------
8908 dnl Command-line option to specify where Ada includes will install.
8909 AC_DEFUN([CF_WITH_ADA_INCLUDE],[
8910 AC_MSG_CHECKING(for ada-include)
8911 CF_WITH_PATH(ada-include,
8912    [  --with-ada-include=DIR  Ada includes are in DIR],
8913    ADA_INCLUDE,
8914    PREFIX/share/ada/adainclude,
8915    [$]prefix/share/ada/adainclude)
8916 AC_SUBST(ADA_INCLUDE)
8917 AC_MSG_RESULT($ADA_INCLUDE)
8918 ])dnl
8919 dnl ---------------------------------------------------------------------------
8920 dnl CF_WITH_ADA_LIBNAME version: 1 updated: 2019/09/07 18:59:41
8921 dnl -------------------
8922 dnl CF_WITH_ADA_LIBNAME
8923 dnl -------------------
8924 dnl Command-line option to specify how to name the resulting Ada library.
8925 dnl $1 = default value
8926 AC_DEFUN([CF_WITH_ADA_LIBNAME],[
8927 AC_MSG_CHECKING(for ada-libname)
8928 AC_ARG_WITH(ada-libname,
8929    [  --with-ada-libname=XXX  override default Ada library-name],
8930    ADA_LIBNAME=[$]withval,
8931    ADA_LIBNAME=$1)
8932 case "x$ADA_LIBNAME" in
8933 (x|xyes|xno)
8934         ADA_LIBNAME=$1
8935         ;;
8936 esac
8937 AC_SUBST(ADA_LIBNAME)
8938 AC_MSG_RESULT($ADA_LIBNAME)
8939 ])dnl
8940 dnl ---------------------------------------------------------------------------
8941 dnl CF_WITH_ADA_OBJECTS version: 2 updated: 2010/06/26 17:35:58
8942 dnl -------------------
8943 dnl Command-line option to specify where Ada objects will install.
8944 AC_DEFUN([CF_WITH_ADA_OBJECTS],[
8945 AC_MSG_CHECKING(for ada-objects)
8946 CF_WITH_PATH(ada-objects,
8947    [  --with-ada-objects=DIR  Ada objects are in DIR],
8948    ADA_OBJECTS,
8949    PREFIX/lib/ada/adalib,
8950    [$]prefix/lib/ada/adalib)
8951 AC_SUBST(ADA_OBJECTS)
8952 AC_MSG_RESULT($ADA_OBJECTS)
8953 ])dnl
8954 dnl ---------------------------------------------------------------------------
8955 dnl CF_WITH_ADA_SHAREDLIB version: 5 updated: 2018/07/21 19:10:35
8956 dnl ---------------------
8957 dnl Command-line option to specify if an Ada95 shared-library should be built,
8958 dnl and optionally what its soname should be.
8959 AC_DEFUN([CF_WITH_ADA_SHAREDLIB],[
8960 AC_REQUIRE([CF_GNAT_PROJECTS])
8961 AC_MSG_CHECKING(if an Ada95 shared-library should be built)
8962 AC_ARG_WITH(ada-sharedlib,
8963         [  --with-ada-sharedlib=soname build shared-library (requires GNAT projects)],
8964         [with_ada_sharedlib=$withval],
8965         [with_ada_sharedlib=no])
8966 AC_MSG_RESULT($with_ada_sharedlib)
8967
8968 if test "x$with_ada_sharedlib" != xno
8969 then
8970         if test "x$cf_gnat_projects" != xyes
8971         then
8972                 AC_MSG_WARN(disabling shared-library since GNAT projects are not supported)
8973                 with_ada_sharedlib=no
8974         fi
8975 fi
8976
8977 ADA_SHAREDLIB='lib$(LIB_NAME).so.1'
8978 MAKE_ADA_SHAREDLIB="#"
8979
8980 if test "x$with_ada_sharedlib" != xno
8981 then
8982         MAKE_ADA_SHAREDLIB=
8983         if test "x$with_ada_sharedlib" != xyes
8984         then
8985                 ADA_SHAREDLIB="$with_ada_sharedlib"
8986         fi
8987 fi
8988
8989 AC_SUBST(ADA_SHAREDLIB)
8990 AC_SUBST(MAKE_ADA_SHAREDLIB)
8991 ])dnl
8992 dnl ---------------------------------------------------------------------------
8993 dnl CF_WITH_DBMALLOC version: 7 updated: 2010/06/21 17:26:47
8994 dnl ----------------
8995 dnl Configure-option for dbmalloc.  The optional parameter is used to override
8996 dnl the updating of $LIBS, e.g., to avoid conflict with subsequent tests.
8997 AC_DEFUN([CF_WITH_DBMALLOC],[
8998 CF_NO_LEAKS_OPTION(dbmalloc,
8999         [  --with-dbmalloc         test: use Conor Cahill's dbmalloc library],
9000         [USE_DBMALLOC])
9001
9002 if test "$with_dbmalloc" = yes ; then
9003         AC_CHECK_HEADER(dbmalloc.h,
9004                 [AC_CHECK_LIB(dbmalloc,[debug_malloc]ifelse([$1],,[],[,$1]))])
9005 fi
9006 ])dnl
9007 dnl ---------------------------------------------------------------------------
9008 dnl CF_WITH_DMALLOC version: 7 updated: 2010/06/21 17:26:47
9009 dnl ---------------
9010 dnl Configure-option for dmalloc.  The optional parameter is used to override
9011 dnl the updating of $LIBS, e.g., to avoid conflict with subsequent tests.
9012 AC_DEFUN([CF_WITH_DMALLOC],[
9013 CF_NO_LEAKS_OPTION(dmalloc,
9014         [  --with-dmalloc          test: use Gray Watson's dmalloc library],
9015         [USE_DMALLOC])
9016
9017 if test "$with_dmalloc" = yes ; then
9018         AC_CHECK_HEADER(dmalloc.h,
9019                 [AC_CHECK_LIB(dmalloc,[dmalloc_debug]ifelse([$1],,[],[,$1]))])
9020 fi
9021 ])dnl
9022 dnl ---------------------------------------------------------------------------
9023 dnl CF_WITH_EXPORT_SYMS version: 3 updated: 2014/12/20 19:16:08
9024 dnl -------------------
9025 dnl Use this with libtool to specify the list of symbols that may be exported.
9026 dnl The input file contains one symbol per line; comments work with "#".
9027 dnl
9028 dnl $1 = basename of the ".sym" file (default $PACKAGE)
9029 AC_DEFUN([CF_WITH_EXPORT_SYMS],
9030 [
9031 AC_MSG_CHECKING(if exported-symbols file should be used)
9032 AC_ARG_WITH(export-syms,
9033         [  --with-export-syms=XXX  limit exported symbols using libtool],
9034         [with_export_syms=$withval],
9035         [with_export_syms=no])
9036 if test "x$with_export_syms" = xyes
9037 then
9038         with_export_syms='${top_srcdir}/package/ifelse($1,,${PACKAGE},[$1]).sym'
9039         AC_SUBST(PACKAGE)
9040 fi
9041 AC_MSG_RESULT($with_export_syms)
9042 if test "x$with_export_syms" != xno
9043 then
9044         EXPORT_SYMS="-export-symbols $with_export_syms"
9045         AC_SUBST(EXPORT_SYMS)
9046 fi
9047 ])dnl
9048 dnl ---------------------------------------------------------------------------
9049 dnl CF_WITH_GPM version: 10 updated: 2017/04/29 18:32:18
9050 dnl -----------
9051 dnl
9052 dnl The option parameter (if neither yes/no) is assumed to be the name of
9053 dnl the gpm library, e.g., for dynamic loading.
9054 AC_DEFUN([CF_WITH_GPM],
9055 [
9056 AC_MSG_CHECKING(if you want to link with the GPM mouse library)
9057 AC_ARG_WITH(gpm,
9058         [  --with-gpm              use Alessandro Rubini's GPM library],
9059         [with_gpm=$withval],
9060         [with_gpm=maybe])
9061 AC_MSG_RESULT($with_gpm)
9062
9063 if test "$with_gpm" != no ; then
9064         AC_CHECK_HEADER(gpm.h,[
9065                 AC_DEFINE(HAVE_GPM_H,1,[Define to 1 if we have gpm.h header])
9066                 if test "$with_gpm" != yes && test "$with_gpm" != maybe ; then
9067                         CF_VERBOSE(assuming we really have GPM library)
9068                         AC_DEFINE(HAVE_LIBGPM,1,[Define to 1 if we have the gpm library])
9069                         with_gpm=yes
9070                 else
9071                         AC_CHECK_LIB(gpm,Gpm_Open,[with_gpm=yes],[
9072                                 if test "$with_gpm" = maybe; then
9073                                         AC_MSG_WARN(Cannot link with GPM library)
9074                                         with_gpm=no
9075                                 else
9076                                         AC_MSG_ERROR(Cannot link with GPM library)
9077                                 fi
9078                         ])
9079                 fi
9080         ],[
9081                 test "$with_gpm" != maybe && AC_MSG_WARN(Cannot find GPM header)
9082                 with_gpm=no
9083         ])
9084 fi
9085 ])
9086 dnl ---------------------------------------------------------------------------
9087 dnl CF_WITH_LIBTOOL version: 36 updated: 2021/01/01 13:31:04
9088 dnl ---------------
9089 dnl Provide a configure option to incorporate libtool.  Define several useful
9090 dnl symbols for the makefile rules.
9091 dnl
9092 dnl The reference to AC_PROG_LIBTOOL does not normally work, since it uses
9093 dnl macros from libtool.m4 which is in the aclocal directory of automake.
9094 dnl Following is a simple script which turns on the AC_PROG_LIBTOOL macro.
9095 dnl But that still does not work properly since the macro is expanded outside
9096 dnl the CF_WITH_LIBTOOL macro:
9097 dnl
9098 dnl     #!/bin/sh
9099 dnl     ACLOCAL=`aclocal --print-ac-dir`
9100 dnl     if test -z "$ACLOCAL" ; then
9101 dnl             echo cannot find aclocal directory
9102 dnl             exit 1
9103 dnl     elif test ! -f $ACLOCAL/libtool.m4 ; then
9104 dnl             echo cannot find libtool.m4 file
9105 dnl             exit 1
9106 dnl     fi
9107 dnl
9108 dnl     LOCAL=aclocal.m4
9109 dnl     ORIG=aclocal.m4.orig
9110 dnl
9111 dnl     trap "mv $ORIG $LOCAL" 0 1 2 3 15
9112 dnl     rm -f $ORIG
9113 dnl     mv $LOCAL $ORIG
9114 dnl
9115 dnl     # sed the LIBTOOL= assignment to omit the current directory?
9116 dnl     sed -e 's/^LIBTOOL=.*/LIBTOOL=${LIBTOOL:-libtool}/' $ACLOCAL/libtool.m4 >>$LOCAL
9117 dnl     cat $ORIG >>$LOCAL
9118 dnl
9119 dnl     autoconf-257 $*
9120 dnl
9121 AC_DEFUN([CF_WITH_LIBTOOL],
9122 [
9123 AC_REQUIRE([CF_DISABLE_LIBTOOL_VERSION])
9124 ifdef([AC_PROG_LIBTOOL],,[
9125 LIBTOOL=
9126 ])
9127 # common library maintenance symbols that are convenient for libtool scripts:
9128 LIB_CREATE='${AR} -cr'
9129 LIB_OBJECT='${OBJECTS}'
9130 LIB_SUFFIX=.a
9131 LIB_PREP="$RANLIB"
9132
9133 # symbols used to prop libtool up to enable it to determine what it should be
9134 # doing:
9135 LIB_CLEAN=
9136 LIB_COMPILE=
9137 LIB_LINK='${CC}'
9138 LIB_INSTALL=
9139 LIB_UNINSTALL=
9140
9141 AC_MSG_CHECKING(if you want to build libraries with libtool)
9142 AC_ARG_WITH(libtool,
9143         [  --with-libtool          generate libraries with libtool],
9144         [with_libtool=$withval],
9145         [with_libtool=no])
9146 AC_MSG_RESULT($with_libtool)
9147 if test "$with_libtool" != "no"; then
9148 ifdef([AC_PROG_LIBTOOL],[
9149         # missing_content_AC_PROG_LIBTOOL{{
9150         AC_PROG_LIBTOOL
9151         # missing_content_AC_PROG_LIBTOOL}}
9152 ],[
9153         if test "$with_libtool" != "yes" ; then
9154                 CF_PATH_SYNTAX(with_libtool)
9155                 LIBTOOL=$with_libtool
9156         else
9157                 AC_CHECK_TOOLS(LIBTOOL,[libtool glibtool],none)
9158                 CF_LIBTOOL_VERSION
9159                 if test -z "$cf_cv_libtool_version" && test "$LIBTOOL" = libtool
9160                 then
9161                         CF_FORGET_TOOL(LIBTOOL)
9162                         AC_CHECK_TOOLS(LIBTOOL,[glibtool],none)
9163                         CF_LIBTOOL_VERSION
9164                 fi
9165         fi
9166         if test -z "$LIBTOOL" ; then
9167                 AC_MSG_ERROR(Cannot find libtool)
9168         fi
9169 ])dnl
9170         LIB_CREATE='${LIBTOOL} --mode=link ${CC} -rpath ${libdir} ${LIBTOOL_VERSION} `cut -f1 ${top_srcdir}/VERSION` ${LIBTOOL_OPTS} ${LT_UNDEF} $(LIBS) -o'
9171         LIB_OBJECT='${OBJECTS:.o=.lo}'
9172         LIB_SUFFIX=.la
9173         LIB_CLEAN='${LIBTOOL} --mode=clean'
9174         LIB_COMPILE='${LIBTOOL} --mode=compile'
9175         LIB_LINK='${LIBTOOL} --mode=link ${CC} ${LIBTOOL_OPTS}'
9176         LIB_INSTALL='${LIBTOOL} --mode=install'
9177         LIB_UNINSTALL='${LIBTOOL} --mode=uninstall'
9178         LIB_PREP=:
9179
9180         CF_CHECK_LIBTOOL_VERSION
9181
9182         # special hack to add -no-undefined (which libtool should do for itself)
9183         LT_UNDEF=
9184         case "$cf_cv_system_name" in
9185         (cygwin*|msys*|mingw32*|os2*|uwin*|aix[[4-7]])
9186                 LT_UNDEF=-no-undefined
9187                 ;;
9188         esac
9189         AC_SUBST([LT_UNDEF])
9190
9191         # special hack to add --tag option for C++ compiler
9192         case "$cf_cv_libtool_version" in
9193         (1.[[5-9]]*|[[2-9]].[[0-9.a-z]]*)
9194                 LIBTOOL_CXX="$LIBTOOL --tag=CXX"
9195                 LIBTOOL="$LIBTOOL --tag=CC"
9196                 ;;
9197         (*)
9198                 LIBTOOL_CXX="$LIBTOOL"
9199                 ;;
9200         esac
9201 else
9202         LIBTOOL=""
9203         LIBTOOL_CXX=""
9204 fi
9205
9206 test -z "$LIBTOOL" && ECHO_LT=
9207
9208 AC_SUBST(LIBTOOL)
9209 AC_SUBST(LIBTOOL_CXX)
9210 AC_SUBST(LIBTOOL_OPTS)
9211
9212 AC_SUBST(LIB_CREATE)
9213 AC_SUBST(LIB_OBJECT)
9214 AC_SUBST(LIB_SUFFIX)
9215 AC_SUBST(LIB_PREP)
9216
9217 AC_SUBST(LIB_CLEAN)
9218 AC_SUBST(LIB_COMPILE)
9219 AC_SUBST(LIB_LINK)
9220 AC_SUBST(LIB_INSTALL)
9221 AC_SUBST(LIB_UNINSTALL)
9222
9223 ])dnl
9224 dnl ---------------------------------------------------------------------------
9225 dnl CF_WITH_LIBTOOL_OPTS version: 4 updated: 2015/04/17 21:13:04
9226 dnl --------------------
9227 dnl Allow user to pass additional libtool options into the library creation
9228 dnl and link steps.  The main use for this is to do something like
9229 dnl     ./configure --with-libtool-opts=-static
9230 dnl to get the same behavior as automake-flavored
9231 dnl     ./configure --enable-static
9232 AC_DEFUN([CF_WITH_LIBTOOL_OPTS],[
9233 AC_MSG_CHECKING(for additional libtool options)
9234 AC_ARG_WITH(libtool-opts,
9235         [  --with-libtool-opts=XXX specify additional libtool options],
9236         [with_libtool_opts=$withval],
9237         [with_libtool_opts=no])
9238 AC_MSG_RESULT($with_libtool_opts)
9239
9240 case .$with_libtool_opts in
9241 (.yes|.no|.)
9242         ;;
9243 (*)
9244         LIBTOOL_OPTS="$LIBTOOL_OPTS $with_libtool_opts"
9245         ;;
9246 esac
9247
9248 AC_SUBST(LIBTOOL_OPTS)
9249 ])dnl
9250 dnl ---------------------------------------------------------------------------
9251 dnl CF_WITH_LIB_BASENAME version: 1 updated: 2020/03/07 20:05:14
9252 dnl --------------------
9253 dnl Allow for overriding the basename of a library, i.e., the part to which
9254 dnl prefixes/suffixes are attached.
9255 dnl
9256 dnl $1 = variable to set
9257 dnl $2 = option name
9258 dnl $3 = default basename for library, if omitted use $2
9259 AC_DEFUN([CF_WITH_LIB_BASENAME],
9260 [
9261 AC_MSG_CHECKING(for desired basename for $2 library)
9262 AC_ARG_WITH($2-libname,
9263         [  --with-$2-libname=XXX override ifelse($3,,$2,$3) basename of library],
9264         [with_lib_basename=$withval],
9265         [with_lib_basename=ifelse($3,,$2,$3)])
9266 $1="$with_lib_basename"
9267
9268 case "x[$]$1" in
9269 (x|xno|xnone|xyes)
9270         $1=ifelse($3,,$2,$3)
9271         ;;
9272 (*)
9273         ;;
9274 esac
9275
9276 AC_MSG_RESULT([$]$1)
9277 AC_SUBST($1)
9278 ])dnl
9279 dnl ---------------------------------------------------------------------------
9280 dnl CF_WITH_LIB_PREFIX version: 2 updated: 2021/01/01 16:53:59
9281 dnl ------------------
9282 dnl Allow the library-prefix to be overridden.  OS/2 EMX originally had no
9283 dnl "lib" prefix, e.g., because it used the dll naming convention.
9284 dnl
9285 dnl $1 = variable to set
9286 AC_DEFUN([CF_WITH_LIB_PREFIX],
9287 [
9288 AC_MSG_CHECKING(if you want to have a library-prefix)
9289 AC_ARG_WITH(lib-prefix,
9290         [  --with-lib-prefix       override library-prefix],
9291         [with_lib_prefix=$withval],
9292         [with_lib_prefix=auto])
9293 AC_MSG_RESULT($with_lib_prefix)
9294
9295 if test "$with_lib_prefix" = auto
9296 then
9297         CF_LIB_PREFIX($1)
9298 elif test "$with_lib_prefix" = no
9299 then
9300         LIB_PREFIX=
9301 else
9302         LIB_PREFIX=$with_lib_prefix
9303 fi
9304 ])dnl
9305 dnl ---------------------------------------------------------------------------
9306 dnl CF_WITH_PATH version: 12 updated: 2021/09/04 06:35:04
9307 dnl ------------
9308 dnl Wrapper for AC_ARG_WITH to ensure that user supplies a pathname, not just
9309 dnl defaulting to yes/no.
9310 dnl
9311 dnl $1 = option name
9312 dnl $2 = help-text
9313 dnl $3 = environment variable to set
9314 dnl $4 = default value, shown in the help-message, must be a constant
9315 dnl $5 = default value, if it is an expression & cannot be in the help-message
9316 dnl
9317 AC_DEFUN([CF_WITH_PATH],
9318 [AC_ARG_WITH($1,[$2 ](default: ifelse([$4],,empty,[$4])),,
9319 ifelse([$4],,[withval="${$3}"],[withval="${$3:-ifelse([$5],,[$4],[$5])}"]))dnl
9320 if ifelse([$5],,true,[test -n "$5"]) ; then
9321 CF_PATH_SYNTAX(withval)
9322 fi
9323 eval $3="$withval"
9324 AC_SUBST($3)dnl
9325 ])dnl
9326 dnl ---------------------------------------------------------------------------
9327 dnl CF_WITH_PATHLIST version: 13 updated: 2021/09/04 06:35:04
9328 dnl ----------------
9329 dnl Process an option specifying a list of colon-separated paths.
9330 dnl
9331 dnl $1 = option name
9332 dnl $2 = help-text
9333 dnl $3 = environment variable to set
9334 dnl $4 = default value, shown in the help-message, must be a constant
9335 dnl $5 = default value, if it is an expression & cannot be in the help-message
9336 dnl $6 = flag to tell if we want to define or substitute
9337 dnl
9338 AC_DEFUN([CF_WITH_PATHLIST],[
9339 AC_REQUIRE([CF_PATHSEP])
9340 AC_ARG_WITH($1,[$2 ](default: ifelse($4,,empty,$4)),,
9341 ifelse($4,,[withval=${$3}],[withval=${$3:-ifelse($5,,$4,$5)}]))dnl
9342
9343 IFS="${IFS:-    }"; ac_save_ifs="$IFS"; IFS="${PATH_SEPARATOR}"
9344 cf_dst_path=
9345 for cf_src_path in $withval
9346 do
9347   CF_PATH_SYNTAX(cf_src_path)
9348   test -n "$cf_dst_path" && cf_dst_path="${cf_dst_path}$PATH_SEPARATOR"
9349   cf_dst_path="${cf_dst_path}${cf_src_path}"
9350 done
9351 IFS="$ac_save_ifs"
9352
9353 ifelse($6,define,[
9354 # Strip single quotes from the value, e.g., when it was supplied as a literal
9355 # for $4 or $5.
9356 case "$cf_dst_path" in
9357 (\'*)
9358   cf_dst_path="`echo "$cf_dst_path" |sed -e s/\'// -e s/\'\$//`"
9359   ;;
9360 esac
9361 cf_dst_path=`echo "$cf_dst_path" | sed -e 's/\\\\/\\\\\\\\/g'`
9362 ])
9363
9364 # This may use the prefix/exec_prefix symbols which will only yield "NONE"
9365 # so we have to check/work around.  We do prefer the result of "eval"...
9366 eval cf_dst_eval="$cf_dst_path"
9367 case "x$cf_dst_eval" in
9368 (xNONE*)
9369         $3=$cf_dst_path
9370         ;;
9371 (*)
9372         $3="$cf_dst_eval"
9373         ;;
9374 esac
9375 AC_SUBST($3)dnl
9376
9377 ])dnl
9378 dnl ---------------------------------------------------------------------------
9379 dnl CF_WITH_PATH_PROG version: 1 updated: 2019/06/30 19:44:43
9380 dnl -----------------
9381 dnl Check for a given program, like CF_PATH_PROG, but allow override using a
9382 dnl "--with-xxx" option.
9383 dnl
9384 dnl Parameters:
9385 dnl             $1 = environment variable to set/update
9386 dnl             $2 = program name
9387 dnl             $3 = help-text
9388 dnl             $4 = $PATH
9389 AC_DEFUN([CF_WITH_PATH_PROG],[
9390 AC_ARG_WITH($2-path,
9391         [  --with-$2-path=XXX     specify path of $2 ifelse($3,,,$3)],
9392         [AC_MSG_CHECKING(for $2 program ifelse($3,,,$3))
9393                 $1=$withval
9394                 AC_MSG_RESULT([$]$1)
9395                 CF_PATH_SYNTAX($1)
9396         ],
9397         [CF_PATH_PROG($1,$2,,ifelse($4,,,$4))
9398                 if test -z "[$]$1"
9399                 then
9400                         AC_MSG_WARN(no $2 program found ifelse($3,,,$3))
9401                 fi
9402         ])
9403 ])
9404 dnl ---------------------------------------------------------------------------
9405 dnl CF_WITH_PCRE2 version: 6 updated: 2021/08/11 20:35:34
9406 dnl -------------
9407 dnl Add PCRE2 (Perl-compatible regular expressions v2) to the build if it is
9408 dnl available and the user requests it.  Assume the application will otherwise
9409 dnl use the POSIX interface.
9410 dnl
9411 dnl TODO allow $withval to specify package location
9412 AC_DEFUN([CF_WITH_PCRE2],
9413 [
9414 AC_REQUIRE([CF_PKG_CONFIG])
9415
9416 AC_MSG_CHECKING(if you want to use PCRE2 for regular-expressions)
9417 AC_ARG_WITH(pcre2,
9418         [  --with-pcre2            use PCRE2 for regular-expressions])
9419 test -z "$with_pcre2" && with_pcre2=no
9420 AC_MSG_RESULT($with_pcre2)
9421
9422 if test "x$with_pcre2" != xno ; then
9423         cf_with_pcre2_ok=no
9424         for cf_with_pcre2 in libpcre2 libpcre2-posix libpcre
9425         do
9426                 CF_TRY_PKG_CONFIG($cf_with_pcre2,[cf_with_pcre2_ok=yes; break])
9427         done
9428         cf_with_pcre2_ok=yes || AC_MSG_ERROR(Cannot find PCRE2 library)
9429
9430         AC_DEFINE(HAVE_LIB_PCRE2,1,[Define to 1 if we can/should compile with the PCRE2 library])
9431
9432         # if pkgconfig gave no results, look for the libraries directly
9433         case "$LIBS" in
9434         (*pcre2-posix*|*pcreposix*)
9435                 ;;
9436         (*)
9437                 AC_CHECK_LIB(pcre2-posix,regcomp,[
9438                         CF_ADD_LIB(pcre2-posix)],
9439                         [AC_CHECK_LIB(pcreposix,regcomp,[
9440                          CF_ADD_LIB(pcreposix)
9441                         ],[AC_MSG_ERROR(Cannot find PCRE2 POSIX library)])])
9442                 ;;
9443         esac
9444
9445         # either way, check for the library header files
9446         AC_CHECK_HEADERS(pcre2posix.h pcreposix.h)
9447         AC_CHECK_FUNCS(PCRE2regcomp)
9448 fi
9449 ])dnl
9450 dnl ---------------------------------------------------------------------------
9451 dnl CF_WITH_PKG_CONFIG_LIBDIR version: 21 updated: 2023/01/22 13:37:42
9452 dnl -------------------------
9453 dnl Allow the choice of the pkg-config library directory to be overridden.
9454 dnl
9455 dnl pkg-config uses a search-list built from these colon-separated lists of
9456 dnl directories:
9457 dnl a) $PKG_CONFIG_PATH (tested first, added if set)
9458 dnl b) $PKG_CONFIG_LIBDIR (tested second, added if set)
9459 dnl c) builtin-list (added if $PKG_CONFIG_LIBDIR is not set)
9460 dnl
9461 dnl pkgconf (used with some systems such as FreeBSD in place of pkg-config)
9462 dnl optionally ignores $PKG_CONFIG_LIBDIR.  Very old versions of pkg-config,
9463 dnl e.g., Solaris 10 also do not recognize $PKG_CONFIG_LIBDIR.
9464 AC_DEFUN([CF_WITH_PKG_CONFIG_LIBDIR],[
9465
9466 case "$PKG_CONFIG" in
9467 (no|none|yes)
9468         AC_MSG_CHECKING(for pkg-config library directory)
9469         ;;
9470 (*)
9471         AC_MSG_CHECKING(for $PKG_CONFIG library directory)
9472         ;;
9473 esac
9474
9475 # if $PKG_CONFIG_LIBDIR is set, try to use that
9476 if test -n "$PKG_CONFIG_PATH"; then
9477         cf_search_path=`echo "$PKG_CONFIG_PATH" | sed -e 's/:/ /g' -e 's,^[[    ]]*,,' -e 's,[[         ]]*$,,'`
9478 elif test -n "$PKG_CONFIG_LIBDIR"; then
9479         cf_search_path=`echo "$PKG_CONFIG_LIBDIR" | sed -e 's/:/ /g' -e 's,^[[  ]]*,,' -e 's,[[         ]]*$,,'`
9480 else
9481         cf_search_path=auto
9482 fi
9483
9484 # if the option is used, let that override.  otherwise default to "libdir"
9485 AC_ARG_WITH(pkg-config-libdir,
9486         [  --with-pkg-config-libdir=XXX use given directory for installing pc-files],
9487         [cf_search_path=$withval],
9488         [test "x$PKG_CONFIG" != xnone && test -z "$cf_search_path" && cf_search_path=libdir])
9489
9490 case "x$cf_search_path" in
9491 (xlibdir)
9492         PKG_CONFIG_LIBDIR='${libdir}/pkgconfig'
9493         AC_MSG_RESULT($PKG_CONFIG_LIBDIR)
9494         cf_search_path=
9495         ;;
9496 (x)
9497         ;;
9498 (x/*\ *)
9499         PKG_CONFIG_LIBDIR=
9500         ;;
9501 (x/*)
9502         PKG_CONFIG_LIBDIR="$cf_search_path"
9503         AC_MSG_RESULT($PKG_CONFIG_LIBDIR)
9504         cf_search_path=
9505         ;;
9506 (xyes|xauto)
9507         AC_MSG_RESULT(auto)
9508         cf_search_path=
9509         # Look for the library directory using the same prefix as the executable
9510         AC_MSG_CHECKING(for search-list)
9511         if test "x$PKG_CONFIG" != xnone
9512         then
9513                 # works for pkg-config since version 0.24 (2009)
9514                 # works for pkgconf since version 0.8.3 (2012)
9515                 for cf_pkg_program in \
9516                         `echo "$PKG_CONFIG" | sed -e 's,^.*/,,'` \
9517                         pkg-config \
9518                         pkgconf
9519                 do
9520                         cf_search_path=`"$PKG_CONFIG" --variable=pc_path "$cf_pkg_program" 2>/dev/null | tr : ' '`
9521                         test -n "$cf_search_path" && break
9522                 done
9523
9524                 # works for pkg-config since import in 2005 of original 2001 HP code.
9525                 test -z "$cf_search_path" && \
9526                 cf_search_path=`
9527                 "$PKG_CONFIG" --debug --exists no-such-package 2>&1 | $AWK "\
9528 /^Scanning directory (#[1-9][0-9]* )?'.*'$/{ \
9529         sub(\"^[[^']]*'\",\"\"); \
9530         sub(\"'.*\",\"\"); \
9531         printf \" %s\", \\[$]0; } \
9532 { next; } \
9533 "`
9534         fi
9535
9536         AC_MSG_RESULT($cf_search_path)
9537         ;;
9538 (*)
9539         AC_MSG_ERROR(Unexpected option value: $cf_search_path)
9540         ;;
9541 esac
9542
9543 if test -n "$cf_search_path"
9544 then
9545         AC_MSG_CHECKING(for first directory)
9546         cf_pkg_config_path=none
9547         for cf_config in $cf_search_path
9548         do
9549                 if test -d "$cf_config"
9550                 then
9551                         cf_pkg_config_path=$cf_config
9552                         break
9553                 fi
9554         done
9555         AC_MSG_RESULT($cf_pkg_config_path)
9556
9557         if test "x$cf_pkg_config_path" != xnone ; then
9558                 # limit this to the first directory found
9559                 PKG_CONFIG_LIBDIR="$cf_pkg_config_path"
9560         fi
9561
9562         if test -z "$PKG_CONFIG_LIBDIR" && test -n "$cf_search_path"
9563         then
9564                 AC_MSG_CHECKING(for workaround)
9565                 if test "$prefix" = "NONE" ; then
9566                         cf_prefix="$ac_default_prefix"
9567                 else
9568                         cf_prefix="$prefix"
9569                 fi
9570                 eval cf_libdir=$libdir
9571                 cf_libdir=`echo "$cf_libdir" | sed -e "s,^NONE,$cf_prefix,"`
9572                 cf_backup=
9573                 for cf_config in $cf_search_path
9574                 do
9575                         case $cf_config in
9576                         $cf_libdir/pkgconfig)
9577                                 PKG_CONFIG_LIBDIR=$cf_libdir/pkgconfig
9578                                 break
9579                                 ;;
9580                         *)
9581                                 test -z "$cf_backup" && cf_backup=$cf_config
9582                                 ;;
9583                         esac
9584                 done
9585                 test -z "$PKG_CONFIG_LIBDIR" && PKG_CONFIG_LIBDIR=$cf_backup
9586                 AC_MSG_RESULT($PKG_CONFIG_LIBDIR)
9587         fi
9588 fi
9589
9590 AC_SUBST(PKG_CONFIG_LIBDIR)
9591 ])dnl
9592 dnl ---------------------------------------------------------------------------
9593 dnl CF_WITH_PTHREAD version: 7 updated: 2015/04/18 08:56:57
9594 dnl ---------------
9595 dnl Check for POSIX thread library.
9596 AC_DEFUN([CF_WITH_PTHREAD],
9597 [
9598 AC_MSG_CHECKING(if you want to link with the pthread library)
9599 AC_ARG_WITH(pthread,
9600         [  --with-pthread          use POSIX thread library],
9601         [with_pthread=$withval],
9602         [with_pthread=no])
9603 AC_MSG_RESULT($with_pthread)
9604
9605 if test "$with_pthread" != no ; then
9606         AC_CHECK_HEADER(pthread.h,[
9607         AC_DEFINE(HAVE_PTHREADS_H,1,[Define to 1 if we have pthreads.h header])
9608
9609         for cf_lib_pthread in pthread c_r
9610         do
9611             AC_MSG_CHECKING(if we can link with the $cf_lib_pthread library)
9612             cf_save_LIBS="$LIBS"
9613             CF_ADD_LIB($cf_lib_pthread)
9614             AC_TRY_LINK([
9615 #include <pthread.h>
9616 ],[
9617                 int rc = pthread_create(0,0,0,0);
9618                 int r2 = pthread_mutexattr_settype(0, 0);
9619 ],[with_pthread=yes],[with_pthread=no])
9620             LIBS="$cf_save_LIBS"
9621             AC_MSG_RESULT($with_pthread)
9622             test "$with_pthread" = yes && break
9623         done
9624
9625         if test "$with_pthread" = yes ; then
9626             CF_ADD_LIB($cf_lib_pthread)
9627             AC_DEFINE(HAVE_LIBPTHREADS,1,[Define to 1 if we have pthreads library])
9628         else
9629             AC_MSG_ERROR(Cannot link with pthread library)
9630         fi
9631         ])
9632 fi
9633 ])
9634 dnl ---------------------------------------------------------------------------
9635 dnl CF_WITH_REL_VERSION version: 1 updated: 2003/09/20 18:12:49
9636 dnl -------------------
9637 dnl Allow library's release-version to be overridden.  Generally this happens when a
9638 dnl packager has incremented the release-version past that used in the original package,
9639 dnl and wishes to keep doing this.
9640 dnl
9641 dnl $1 is the package name, if any, to derive corresponding {package}_MAJOR
9642 dnl and {package}_MINOR symbols
9643 dnl symbol.
9644 AC_DEFUN([CF_WITH_REL_VERSION],[
9645 test -z "$cf_cv_rel_version" && cf_cv_rel_version=0.0
9646 AC_ARG_WITH(rel-version,
9647 [  --with-rel-version=XXX  override derived release version],
9648 [AC_MSG_WARN(overriding release version $cf_cv_rel_version to $withval)
9649  cf_cv_rel_version=$withval])
9650 ifelse($1,,[
9651  CF_NUMBER_SYNTAX($cf_cv_rel_version,Release version)
9652 ],[
9653  $1_MAJOR=`echo "$cf_cv_rel_version" | sed -e 's/\..*//'`
9654  $1_MINOR=`echo "$cf_cv_rel_version" | sed -e 's/^[[^.]]*//' -e 's/^\.//' -e 's/\..*//'`
9655  CF_NUMBER_SYNTAX([$]$1_MAJOR,Release major-version)
9656  CF_NUMBER_SYNTAX([$]$1_MINOR,Release minor-version)
9657 ])
9658 ])dnl
9659 dnl ---------------------------------------------------------------------------
9660 dnl CF_WITH_SYSMOUSE version: 3 updated: 2012/10/06 17:56:13
9661 dnl ----------------
9662 dnl If we can compile with sysmouse, make it available unless it is not wanted.
9663 AC_DEFUN([CF_WITH_SYSMOUSE],[
9664 # not everyone has "test -c"
9665 if test -c /dev/sysmouse 2>/dev/null ; then
9666 AC_MSG_CHECKING(if you want to use sysmouse)
9667 AC_ARG_WITH(sysmouse,
9668         [  --with-sysmouse         use sysmouse (FreeBSD console)],
9669         [cf_with_sysmouse=$withval],
9670         [cf_with_sysmouse=maybe])
9671         if test "$cf_with_sysmouse" != no ; then
9672         AC_TRY_COMPILE([
9673 #include <osreldate.h>
9674 #if (__FreeBSD_version >= 400017)
9675 #include <sys/consio.h>
9676 #include <sys/fbio.h>
9677 #else
9678 #include <machine/console.h>
9679 #endif
9680 ],[
9681         struct mouse_info the_mouse;
9682         ioctl(0, CONS_MOUSECTL, &the_mouse);
9683 ],[cf_with_sysmouse=yes],[cf_with_sysmouse=no])
9684         fi
9685 AC_MSG_RESULT($cf_with_sysmouse)
9686 test "$cf_with_sysmouse" = yes && AC_DEFINE(USE_SYSMOUSE,1,[Define to 1 if we can/should use the sysmouse interface])
9687 fi
9688 ])dnl
9689 dnl ---------------------------------------------------------------------------
9690 dnl CF_WITH_SYSTYPE version: 1 updated: 2013/01/26 16:26:12
9691 dnl ---------------
9692 dnl For testing, override the derived host system-type which is used to decide
9693 dnl things such as the linker commands used to build shared libraries.  This is
9694 dnl normally chosen automatically based on the type of system which you are
9695 dnl building on.  We use it for testing the configure script.
9696 dnl
9697 dnl This is different from the --host option: it is used only for testing parts
9698 dnl of the configure script which would not be reachable with --host since that
9699 dnl relies on the build environment being real, rather than mocked up.
9700 AC_DEFUN([CF_WITH_SYSTYPE],[
9701 CF_CHECK_CACHE([AC_CANONICAL_SYSTEM])
9702 AC_ARG_WITH(system-type,
9703         [  --with-system-type=XXX  test: override derived host system-type],
9704 [AC_MSG_WARN(overriding system type to $withval)
9705         cf_cv_system_name=$withval
9706         host_os=$withval
9707 ])
9708 ])dnl
9709 dnl ---------------------------------------------------------------------------
9710 dnl CF_WITH_VALGRIND version: 1 updated: 2006/12/14 18:00:21
9711 dnl ----------------
9712 AC_DEFUN([CF_WITH_VALGRIND],[
9713 CF_NO_LEAKS_OPTION(valgrind,
9714         [  --with-valgrind         test: use valgrind],
9715         [USE_VALGRIND])
9716 ])dnl
9717 dnl ---------------------------------------------------------------------------
9718 dnl CF_WITH_VERSIONED_SYMS version: 10 updated: 2021/01/04 18:48:01
9719 dnl ----------------------
9720 dnl Use this when building shared library with ELF, to markup symbols with the
9721 dnl version identifier from the given input file.  Generally that identifier is
9722 dnl the same as the SONAME at which the symbol was first introduced.
9723 dnl
9724 dnl $1 = basename of the ".map" file (default $PACKAGE)
9725 AC_DEFUN([CF_WITH_VERSIONED_SYMS],
9726 [AC_REQUIRE([AC_PROG_FGREP])dnl
9727 AC_REQUIRE([AC_PROG_EGREP])dnl
9728
9729 AC_MSG_CHECKING(if versioned-symbols file should be used)
9730 AC_ARG_WITH(versioned-syms,
9731         [  --with-versioned-syms=X markup versioned symbols using ld],
9732         [with_versioned_syms=$withval],
9733         [with_versioned_syms=no])
9734 case "x$with_versioned_syms" in
9735 (xyes)
9736         with_versioned_syms='${top_srcdir}/package/ifelse($1,,${PACKAGE},[$1]).map'
9737         AC_SUBST(PACKAGE)
9738         ;;
9739 (xno)
9740         ;;
9741 (x/*)
9742         test -f "$with_versioned_syms" || AC_MSG_ERROR(expected a filename: $with_versioned_syms)
9743         ;;
9744 (*)
9745         test -f "$with_versioned_syms" || AC_MSG_ERROR(expected a filename: $with_versioned_syms)
9746         with_versioned_syms=`pwd`/"$with_versioned_syms"
9747         ;;
9748 esac
9749 AC_MSG_RESULT($with_versioned_syms)
9750
9751 RESULTING_SYMS=
9752 VERSIONED_SYMS=
9753 WILDCARD_SYMS=
9754
9755 if test "x$with_versioned_syms" != xno
9756 then
9757         RESULTING_SYMS=$with_versioned_syms
9758         case "x$MK_SHARED_LIB" in
9759         (*-Wl,*)
9760                 VERSIONED_SYMS="-Wl,--version-script,\${RESULTING_SYMS}"
9761                 MK_SHARED_LIB=`echo "$MK_SHARED_LIB" | sed -e "s%-Wl,%\\[$]{VERSIONED_SYMS} -Wl,%"`
9762                 CF_VERBOSE(MK_SHARED_LIB:  $MK_SHARED_LIB)
9763                 ;;
9764         (*-dy\ *)
9765                 VERSIONED_SYMS="-Wl,-M,\${RESULTING_SYMS}"
9766                 MK_SHARED_LIB=`echo "$MK_SHARED_LIB" | sed -e "s%-dy%\\[$]{VERSIONED_SYMS} -dy%"`
9767                 CF_VERBOSE(MK_SHARED_LIB:  $MK_SHARED_LIB)
9768                 ;;
9769         (*)
9770                 AC_MSG_WARN(this system does not support versioned-symbols)
9771                 ;;
9772         esac
9773
9774         # Linux ld can selectively override scope, e.g., of symbols beginning with
9775         # "_" by first declaring some as global, and then using a wildcard to
9776         # declare the others as local.  Some other loaders cannot do this.  Check
9777         # by constructing a (very) simple shared library and inspecting its
9778         # symbols.
9779         if test "x$VERSIONED_SYMS" != "x"
9780         then
9781                 AC_MSG_CHECKING(if wildcards can be used to selectively omit symbols)
9782                 WILDCARD_SYMS=no
9783
9784                 # make sources
9785                 rm -f conftest.*
9786
9787                 cat >conftest.ver <<EOF
9788 module_1.0 {
9789 global:
9790         globalf1;
9791 local:
9792         localf1;
9793 };
9794 module_2.0 {
9795 global:
9796         globalf2;
9797 local:
9798         localf2;
9799         _*;
9800 } module_1.0;
9801 submodule_1.0 {
9802 global:
9803         subglobalf1;
9804         _ismissing;
9805 local:
9806         sublocalf1;
9807 };
9808 submodule_2.0 {
9809 global:
9810         subglobalf2;
9811 local:
9812         sublocalf2;
9813         _*;
9814 } submodule_1.0;
9815 EOF
9816                 cat >conftest.$ac_ext <<EOF
9817 #line __oline__ "configure"
9818 int     _ismissing(void) { return 1; }
9819 int     _localf1(void) { return 1; }
9820 int     _localf2(void) { return 2; }
9821 int     globalf1(void) { return 1; }
9822 int     globalf2(void) { return 2; }
9823 int     _sublocalf1(void) { return 1; }
9824 int     _sublocalf2(void) { return 2; }
9825 int     subglobalf1(void) { return 1; }
9826 int     subglobalf2(void) { return 2; }
9827 EOF
9828                 cat >conftest.mk <<EOF
9829 CC=${CC}
9830 CFLAGS=${CFLAGS}
9831 CPPFLAGS=${CPPFLAGS}
9832 LDFLAGS=${LDFLAGS}
9833 LIBS=${LIBS}
9834 VERSIONED_SYMS=${VERSIONED_SYMS}
9835 RESULTING_SYMS=conftest.ver
9836 MK_SHARED_LIB=${MK_SHARED_LIB}
9837 conftest.so: conftest.$ac_cv_objext
9838                 \$(MK_SHARED_LIB) conftest.$ac_cv_objext
9839 EOF
9840
9841                 # compile source, make library
9842                 if make -f conftest.mk 2>&AC_FD_CC >/dev/null
9843                 then
9844                         # test for missing symbol in either Data or Text section
9845                         cf_missing="`nm -P conftest.so 2>&AC_FD_CC |${FGREP-fgrep} _ismissing | ${EGREP-egrep} '[[      ]][[DT]][[      ]]'`"
9846                         test -n "$cf_missing" && WILDCARD_SYMS=yes
9847                 fi
9848                 AC_MSG_RESULT($WILDCARD_SYMS)
9849                 rm -f conftest.*
9850         fi
9851 fi
9852 AC_SUBST(RESULTING_SYMS)
9853 AC_SUBST(VERSIONED_SYMS)
9854 AC_SUBST(WILDCARD_SYMS)
9855 ])dnl
9856 dnl ---------------------------------------------------------------------------
9857 dnl CF_WITH_X11_RGB version: 2 updated: 2019/12/31 08:53:54
9858 dnl ---------------
9859 dnl Handle configure option "--with-x11-rgb", setting these shell
9860 dnl variables:
9861 dnl
9862 dnl $RGB_PATH is the option value, used for finding the X11 rgb file.
9863 dnl $no_x11_rgb is a "#" (comment) if "--without-x11-rgb" is given.
9864 dnl
9865 dnl Most Linux's use this:
9866 dnl     /usr/share/X11/rgb.txt
9867 dnl Debian uses this:
9868 dnl     /etc/X11/rgb.txt
9869 dnl DragonFlyBSD ports uses this:
9870 dnl     /usr/pkg/lib/X11/rgb.txt
9871 dnl FreeBSD ports use these:
9872 dnl     /usr/local/lib/X11/rgb.txt
9873 dnl     /usr/local/share/X11/rgb.txt
9874 dnl Mandriva has these:
9875 dnl     /usr/lib/X11/rgb.txt
9876 dnl     /usr/lib64/X11/rgb.txt
9877 dnl NetBSD has these
9878 dnl     /usr/X11R7/lib/X11/rgb.txt
9879 dnl OpenSolaris uses
9880 dnl     32-bit:
9881 dnl     /usr/X11/etc/X11/rgb.txt
9882 dnl     /usr/X11/share/X11/rgb.txt
9883 dnl     /usr/X11/lib/X11/rgb.txt
9884 dnl OSX uses
9885 dnl             /opt/local/share/X11/rgb.txt (MacPorts)
9886 dnl             /opt/X11/share/X11/rgb.txt (non-ports)
9887 dnl     64-bit:
9888 dnl     /usr/X11/etc/X11/rgb.txt
9889 dnl     /usr/X11/share/X11/rgb.txt (perhaps)
9890 dnl     /usr/X11/lib/amd64/X11/rgb.txt
9891 dnl Solaris10 uses (in this order):
9892 dnl     /usr/openwin/lib/X11/rgb.txt
9893 dnl     /usr/X11/lib/X11/rgb.txt
9894 AC_DEFUN([CF_WITH_X11_RGB],[
9895 AC_MSG_CHECKING(for X11 rgb file)
9896 AC_ARG_WITH(x11-rgb,
9897         [  --with-x11-rgb=FILE   file containing X11 rgb information (EPREFIX/lib/X11/rgb.txt)],
9898         [RGB_PATH=$withval],
9899         [RGB_PATH=auto])
9900
9901 if test "x[$]RGB_PATH" = xauto
9902 then
9903         RGB_PATH='${exec_prefix}/lib/X11/rgb.txt'
9904         for cf_path in \
9905                 /opt/local/share/X11/rgb.txt \
9906                 /opt/X11/share/X11/rgb.txt \
9907                 /usr/share/X11/rgb.txt \
9908                 /usr/X11/share/X11/rgb.txt \
9909                 /usr/X11/lib/X11/rgb.txt \
9910                 /usr/lib/X11/rgb.txt \
9911                 /etc/X11/rgb.txt \
9912                 /usr/pkg/lib/X11/rgb.txt \
9913                 /usr/X11R7/lib/X11/rgb.txt \
9914                 /usr/X11R6/lib/X11/rgb.txt \
9915                 /usr/X11R5/lib/X11/rgb.txt \
9916                 /usr/X11R4/lib/X11/rgb.txt \
9917                 /usr/local/lib/X11/rgb.txt \
9918                 /usr/local/share/X11/rgb.txt \
9919                 /usr/lib64/X11/rgb.txt
9920         do
9921                 if test -f "$cf_path" ; then
9922                         RGB_PATH="$cf_path"
9923                         break
9924                 fi
9925         done
9926 else
9927         cf_path=$RGB_PATH
9928         CF_PATH_SYNTAX(cf_path)
9929 fi
9930
9931 AC_MSG_RESULT($RGB_PATH)
9932 AC_SUBST(RGB_PATH)
9933 AC_DEFINE_UNQUOTED(RGB_PATH,"$cf_path",[Define to the full pathname of rgb.txt])
9934
9935 no_x11_rgb=
9936 if test "$RGB_PATH" = no
9937 then
9938         no_x11_rgb="#"
9939 fi
9940 AC_SUBST(no_x11_rgb)
9941 ])dnl
9942 dnl ---------------------------------------------------------------------------
9943 dnl CF_XOPEN_SOURCE version: 66 updated: 2023/04/03 04:19:37
9944 dnl ---------------
9945 dnl Try to get _XOPEN_SOURCE defined properly that we can use POSIX functions,
9946 dnl or adapt to the vendor's definitions to get equivalent functionality,
9947 dnl without losing the common non-POSIX features.
9948 dnl
9949 dnl Parameters:
9950 dnl     $1 is the nominal value for _XOPEN_SOURCE
9951 dnl     $2 is the nominal value for _POSIX_C_SOURCE
9952 dnl
9953 dnl The default case prefers _XOPEN_SOURCE over _POSIX_C_SOURCE if the
9954 dnl implementation predefines it, because X/Open and most implementations agree
9955 dnl that the latter is a legacy or "aligned" value.
9956 dnl
9957 dnl Because _XOPEN_SOURCE is preferred, if defining _POSIX_C_SOURCE turns
9958 dnl that off, then refrain from setting _POSIX_C_SOURCE explicitly.
9959 dnl
9960 dnl References:
9961 dnl https://pubs.opengroup.org/onlinepubs/007904975/functions/xsh_chap02_02.html
9962 dnl https://docs.oracle.com/cd/E19253-01/816-5175/standards-5/index.html
9963 dnl https://www.gnu.org/software/libc/manual/html_node/Feature-Test-Macros.html
9964 AC_DEFUN([CF_XOPEN_SOURCE],[
9965 AC_REQUIRE([AC_CANONICAL_HOST])
9966 AC_REQUIRE([CF_POSIX_VISIBLE])
9967
9968 if test "$cf_cv_posix_visible" = no; then
9969
9970 cf_XOPEN_SOURCE=ifelse([$1],,500,[$1])
9971 cf_POSIX_C_SOURCE=ifelse([$2],,199506L,[$2])
9972 cf_xopen_source=
9973
9974 case "$host_os" in
9975 (aix[[4-7]]*)
9976         cf_xopen_source="-D_ALL_SOURCE"
9977         ;;
9978 (darwin[[0-8]].*)
9979         cf_xopen_source="-D_APPLE_C_SOURCE"
9980         ;;
9981 (darwin*)
9982         cf_xopen_source="-D_DARWIN_C_SOURCE"
9983         cf_XOPEN_SOURCE=
9984         ;;
9985 (freebsd*|dragonfly*|midnightbsd*)
9986         # 5.x headers associate
9987         #       _XOPEN_SOURCE=600 with _POSIX_C_SOURCE=200112L
9988         #       _XOPEN_SOURCE=500 with _POSIX_C_SOURCE=199506L
9989         cf_POSIX_C_SOURCE=200112L
9990         cf_XOPEN_SOURCE=600
9991         cf_xopen_source="-D_BSD_TYPES -D__BSD_VISIBLE -D_POSIX_C_SOURCE=$cf_POSIX_C_SOURCE -D_XOPEN_SOURCE=$cf_XOPEN_SOURCE"
9992         ;;
9993 (hpux11*)
9994         cf_xopen_source="-D_HPUX_SOURCE -D_XOPEN_SOURCE=500"
9995         ;;
9996 (hpux*)
9997         cf_xopen_source="-D_HPUX_SOURCE"
9998         ;;
9999 (irix[[56]].*)
10000         cf_xopen_source="-D_SGI_SOURCE"
10001         cf_XOPEN_SOURCE=
10002         ;;
10003 (linux*gnu|linux*gnuabi64|linux*gnuabin32|linux*gnueabi|linux*gnueabihf|linux*gnux32|uclinux*|gnu*|mint*|k*bsd*-gnu|cygwin|msys|mingw*)
10004         CF_GNU_SOURCE($cf_XOPEN_SOURCE)
10005         ;;
10006 (minix*)
10007         cf_xopen_source="-D_NETBSD_SOURCE" # POSIX.1-2001 features are ifdef'd with this...
10008         ;;
10009 (mirbsd*)
10010         # setting _XOPEN_SOURCE or _POSIX_SOURCE breaks <sys/select.h> and other headers which use u_int / u_short types
10011         cf_XOPEN_SOURCE=
10012         CF_POSIX_C_SOURCE($cf_POSIX_C_SOURCE)
10013         ;;
10014 (netbsd*)
10015         cf_xopen_source="-D_NETBSD_SOURCE" # setting _XOPEN_SOURCE breaks IPv6 for lynx on NetBSD 1.6, breaks xterm, is not needed for ncursesw
10016         ;;
10017 (openbsd[[6-9]]*)
10018         # OpenBSD 6.x has broken locale support, both compile-time and runtime.
10019         # see https://www.mail-archive.com/bugs@openbsd.org/msg13200.html
10020         # Abusing the conformance level is a workaround.
10021         AC_MSG_WARN(this system does not provide usable locale support)
10022         cf_xopen_source="-D_BSD_SOURCE"
10023         cf_XOPEN_SOURCE=700
10024         ;;
10025 (openbsd[[4-5]]*)
10026         # setting _XOPEN_SOURCE lower than 500 breaks g++ compile with wchar.h, needed for ncursesw
10027         cf_xopen_source="-D_BSD_SOURCE"
10028         cf_XOPEN_SOURCE=600
10029         ;;
10030 (openbsd*)
10031         # setting _XOPEN_SOURCE breaks xterm on OpenBSD 2.8, is not needed for ncursesw
10032         ;;
10033 (osf[[45]]*)
10034         cf_xopen_source="-D_OSF_SOURCE"
10035         ;;
10036 (nto-qnx*)
10037         cf_xopen_source="-D_QNX_SOURCE"
10038         ;;
10039 (sco*)
10040         # setting _XOPEN_SOURCE breaks Lynx on SCO Unix / OpenServer
10041         ;;
10042 (solaris2.*)
10043         cf_xopen_source="-D__EXTENSIONS__"
10044         cf_cv_xopen_source=broken
10045         ;;
10046 (sysv4.2uw2.*) # Novell/SCO UnixWare 2.x (tested on 2.1.2)
10047         cf_XOPEN_SOURCE=
10048         cf_POSIX_C_SOURCE=
10049         ;;
10050 (*)
10051         CF_TRY_XOPEN_SOURCE
10052         cf_save_xopen_cppflags="$CPPFLAGS"
10053         CF_POSIX_C_SOURCE($cf_POSIX_C_SOURCE)
10054         # Some of these niche implementations use copy/paste, double-check...
10055         if test "$cf_cv_xopen_source" = no ; then
10056                 CF_VERBOSE(checking if _POSIX_C_SOURCE interferes with _XOPEN_SOURCE)
10057                 AC_TRY_COMPILE(CF__XOPEN_SOURCE_HEAD,CF__XOPEN_SOURCE_BODY,,[
10058                         AC_MSG_WARN(_POSIX_C_SOURCE definition is not usable)
10059                         CPPFLAGS="$cf_save_xopen_cppflags"])
10060         fi
10061         ;;
10062 esac
10063
10064 if test -n "$cf_xopen_source" ; then
10065         CF_APPEND_CFLAGS($cf_xopen_source,true)
10066 fi
10067
10068 dnl In anything but the default case, we may have system-specific setting
10069 dnl which is still not guaranteed to provide all of the entrypoints that
10070 dnl _XOPEN_SOURCE would yield.
10071 if test -n "$cf_XOPEN_SOURCE" && test -z "$cf_cv_xopen_source" ; then
10072         AC_MSG_CHECKING(if _XOPEN_SOURCE really is set)
10073         AC_TRY_COMPILE([#include <stdlib.h>],[
10074 #ifndef _XOPEN_SOURCE
10075 #error _XOPEN_SOURCE is not defined
10076 #endif],
10077         [cf_XOPEN_SOURCE_set=yes],
10078         [cf_XOPEN_SOURCE_set=no])
10079         AC_MSG_RESULT($cf_XOPEN_SOURCE_set)
10080         if test "$cf_XOPEN_SOURCE_set" = yes
10081         then
10082                 AC_TRY_COMPILE([#include <stdlib.h>],[
10083 #if (_XOPEN_SOURCE - 0) < $cf_XOPEN_SOURCE
10084 #error (_XOPEN_SOURCE - 0) < $cf_XOPEN_SOURCE
10085 #endif],
10086                 [cf_XOPEN_SOURCE_set_ok=yes],
10087                 [cf_XOPEN_SOURCE_set_ok=no])
10088                 if test "$cf_XOPEN_SOURCE_set_ok" = no
10089                 then
10090                         AC_MSG_WARN(_XOPEN_SOURCE is lower than requested)
10091                 fi
10092         else
10093                 CF_TRY_XOPEN_SOURCE
10094         fi
10095 fi
10096 fi # cf_cv_posix_visible
10097 ])
10098 dnl ---------------------------------------------------------------------------
10099 dnl CF__SED_TRIMBLANKS version: 1 updated: 2021/01/02 09:31:20
10100 dnl ------------------
10101 dnl Trim something using sed, then trim extra whitespace
10102 dnl $1 = extra parameters, e.g., in CF_STRIP_G_OPT
10103 define([CF__SED_TRIMBLANKS],[sed ifelse($1,,,[$1] )-e 's%[[     ]]% %g' -e 's% [[ ]]*% %g' -e 's%^ %%' -e 's% [$]%%'])dnl
10104 dnl ---------------------------------------------------------------------------
10105 dnl CF__XOPEN_SOURCE_BODY version: 2 updated: 2023/02/18 17:41:25
10106 dnl ---------------------
10107 dnl body of test when test-compiling for _XOPEN_SOURCE check
10108 define([CF__XOPEN_SOURCE_BODY],
10109 [
10110 #ifndef _XOPEN_SOURCE
10111 #error _XOPEN_SOURCE is not defined
10112 #endif
10113 ])
10114 dnl ---------------------------------------------------------------------------
10115 dnl CF__XOPEN_SOURCE_HEAD version: 2 updated: 2023/02/18 17:41:25
10116 dnl ---------------------
10117 dnl headers to include when test-compiling for _XOPEN_SOURCE check
10118 define([CF__XOPEN_SOURCE_HEAD],
10119 [
10120 $ac_includes_default
10121 ])