aclocal.m4

   1 dnl***************************************************************************
   2 dnl Copyright 2018-2021,2022 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.1007 2022/07/27 23:34:31 tom Exp $
  33 dnl Macros used in NCURSES auto-configuration script.
  34 dnl
  35 dnl These macros are maintained separately from NCURSES.  The copyright on
  36 dnl this file applies to the aggregation of macros and does not affect use of
  37 dnl these macros in other applications.
  38 dnl
  39 dnl See these pages for additional information:
  40 dnl             https://invisible-island.net/autoconf/
  41 dnl             https://invisible-island.net/autoconf/my-autoconf.html
  42 dnl
  43 dnl ---------------------------------------------------------------------------
  44 dnl ---------------------------------------------------------------------------
  45 dnl AM_LANGINFO_CODESET version: 6 updated: 2021/01/01 16:53:59
  46 dnl -------------------
  47 dnl Inserted as requested by gettext 0.10.40
  48 dnl File from /usr/share/aclocal
  49 dnl codeset.m4
  50 dnl ====================
  51 dnl serial AM1
  52 dnl
  53 dnl From Bruno Haible.
  54 AC_DEFUN([AM_LANGINFO_CODESET],
  55 [
  56 AC_CACHE_CHECK([for nl_langinfo and CODESET], am_cv_langinfo_codeset,
  57         [AC_TRY_LINK([#include <langinfo.h>],
  58         [char* cs = nl_langinfo(CODESET); (void)cs],
  59         am_cv_langinfo_codeset=yes,
  60         am_cv_langinfo_codeset=no)
  61         ])
  62         if test "$am_cv_langinfo_codeset" = yes; then
  63                 AC_DEFINE(HAVE_LANGINFO_CODESET, 1,
  64                 [Define if you have <langinfo.h> and nl_langinfo(CODESET).])
  65         fi
  66 ])dnl
  67 dnl ---------------------------------------------------------------------------
  68 dnl CF_ABI_DEFAULTS version: 3 updated: 2022/01/22 19:13:38
  69 dnl ---------------
  70 dnl Provide configure-script defaults for different ncurses ABIs.
  71 AC_DEFUN([CF_ABI_DEFAULTS],[
  72 AC_REQUIRE([CF_NCURSES_WITH_ABI_VERSION])
  73
  74 # ABI 5 defaults:
  75 cf_dft_ccharw_max=5
  76 cf_dft_chtype=auto
  77 cf_dft_ext_colors=no
  78 cf_dft_ext_const=no
  79 cf_dft_ext_mouse=no
  80 cf_dft_ext_putwin=no
  81 cf_dft_ext_spfuncs=no
  82 cf_dft_filter_syms=no
  83 cf_dft_interop=no
  84 cf_dft_mmask_t=auto
  85 cf_dft_opaque_curses=no
  86 cf_dft_ordinate_type=short
  87 cf_dft_signed_char=no
  88 cf_dft_tparm_arg=long
  89 cf_dft_with_lp64=no
  90
  91 # ABI 6 defaults:
  92 case x$cf_cv_abi_version in
  93 (x[[6789]])
  94         cf_dft_chtype=uint32_t
  95         cf_dft_ext_colors=yes
  96         cf_dft_ext_const=yes
  97         cf_dft_ext_mouse=yes
  98         cf_dft_ext_putwin=yes
  99         cf_dft_ext_spfuncs=yes
 100         cf_dft_filter_syms=yes
 101         cf_dft_interop=yes
 102         cf_dft_mmask_t=uint32_t
 103         cf_dft_tparm_arg=intptr_t
 104         cf_dft_with_lp64=yes
 105         ;;
 106 esac
 107
 108 # ABI 7 defaults:
 109 case x$cf_cv_abi_version in
 110 (x[[789]])
 111         cf_dft_ccharw_max=6
 112         cf_dft_mmask_t=uint64_t
 113         cf_dft_opaque_curses=yes
 114         cf_dft_ordinate_type=int
 115         cf_dft_signed_char=yes
 116         # also: remove the wgetch-events feature in ABI 7
 117         ;;
 118 esac
 119 ])dnl
 120 dnl ---------------------------------------------------------------------------
 121 dnl CF_ACVERSION_CHECK version: 5 updated: 2014/06/04 19:11:49
 122 dnl ------------------
 123 dnl Conditionally generate script according to whether we're using a given autoconf.
 124 dnl
 125 dnl $1 = version to compare against
 126 dnl $2 = code to use if AC_ACVERSION is at least as high as $1.
 127 dnl $3 = code to use if AC_ACVERSION is older than $1.
 128 define([CF_ACVERSION_CHECK],
 129 [
 130 ifdef([AC_ACVERSION], ,[ifdef([AC_AUTOCONF_VERSION],[m4_copy([AC_AUTOCONF_VERSION],[AC_ACVERSION])],[m4_copy([m4_PACKAGE_VERSION],[AC_ACVERSION])])])dnl
 131 ifdef([m4_version_compare],
 132 [m4_if(m4_version_compare(m4_defn([AC_ACVERSION]), [$1]), -1, [$3], [$2])],
 133 [CF_ACVERSION_COMPARE(
 134 AC_PREREQ_CANON(AC_PREREQ_SPLIT([$1])),
 135 AC_PREREQ_CANON(AC_PREREQ_SPLIT(AC_ACVERSION)), AC_ACVERSION, [$2], [$3])])])dnl
 136 dnl ---------------------------------------------------------------------------
 137 dnl CF_ACVERSION_COMPARE version: 3 updated: 2012/10/03 18:39:53
 138 dnl --------------------
 139 dnl CF_ACVERSION_COMPARE(MAJOR1, MINOR1, TERNARY1,
 140 dnl                      MAJOR2, MINOR2, TERNARY2,
 141 dnl                      PRINTABLE2, not FOUND, FOUND)
 142 define([CF_ACVERSION_COMPARE],
 143 [ifelse(builtin([eval], [$2 < $5]), 1,
 144 [ifelse([$8], , ,[$8])],
 145 [ifelse([$9], , ,[$9])])])dnl
 146 dnl ---------------------------------------------------------------------------
 147 dnl CF_ADA_INCLUDE_DIRS version: 8 updated: 2013/10/14 04:24:07
 148 dnl -------------------
 149 dnl Construct the list of include-options for the C programs in the Ada95
 150 dnl binding.
 151 AC_DEFUN([CF_ADA_INCLUDE_DIRS],
 152 [
 153 ACPPFLAGS="-I. -I../include -I../../include $ACPPFLAGS"
 154 if test "$srcdir" != "."; then
 155         ACPPFLAGS="-I\${srcdir}/../../include $ACPPFLAGS"
 156 fi
 157 if test "$GCC" != yes; then
 158         ACPPFLAGS="$ACPPFLAGS -I\${includedir}"
 159 elif test "$includedir" != "/usr/include"; then
 160         if test "$includedir" = '${prefix}/include' ; then
 161                 if test x$prefix != x/usr ; then
 162                         ACPPFLAGS="$ACPPFLAGS -I\${includedir}"
 163                 fi
 164         else
 165                 ACPPFLAGS="$ACPPFLAGS -I\${includedir}"
 166         fi
 167 fi
 168 AC_SUBST(ACPPFLAGS)
 169 ])dnl
 170 dnl ---------------------------------------------------------------------------
 171 dnl CF_ADD_ADAFLAGS version: 1 updated: 2010/06/19 15:22:18
 172 dnl ---------------
 173 dnl Add to $ADAFLAGS, which is substituted into makefile and scripts.
 174 AC_DEFUN([CF_ADD_ADAFLAGS],[
 175         ADAFLAGS="$ADAFLAGS $1"
 176         AC_SUBST(ADAFLAGS)
 177 ])dnl
 178 dnl ---------------------------------------------------------------------------
 179 dnl CF_ADD_CFLAGS version: 15 updated: 2020/12/31 10:54:15
 180 dnl -------------
 181 dnl Copy non-preprocessor flags to $CFLAGS, preprocessor flags to $CPPFLAGS
 182 dnl $1 = flags to add
 183 dnl $2 = if given makes this macro verbose.
 184 dnl
 185 dnl Put any preprocessor definitions that use quoted strings in $EXTRA_CPPFLAGS,
 186 dnl to simplify use of $CPPFLAGS in compiler checks, etc., that are easily
 187 dnl confused by the quotes (which require backslashes to keep them usable).
 188 AC_DEFUN([CF_ADD_CFLAGS],
 189 [
 190 cf_fix_cppflags=no
 191 cf_new_cflags=
 192 cf_new_cppflags=
 193 cf_new_extra_cppflags=
 194
 195 for cf_add_cflags in $1
 196 do
 197 case "$cf_fix_cppflags" in
 198 (no)
 199         case "$cf_add_cflags" in
 200         (-undef|-nostdinc*|-I*|-D*|-U*|-E|-P|-C)
 201                 case "$cf_add_cflags" in
 202                 (-D*)
 203                         cf_tst_cflags=`echo "${cf_add_cflags}" |sed -e 's/^-D[[^=]]*='\''\"[[^"]]*//'`
 204
 205                         test "x${cf_add_cflags}" != "x${cf_tst_cflags}" \
 206                                 && test -z "${cf_tst_cflags}" \
 207                                 && cf_fix_cppflags=yes
 208
 209                         if test "$cf_fix_cppflags" = yes ; then
 210                                 CF_APPEND_TEXT(cf_new_extra_cppflags,$cf_add_cflags)
 211                                 continue
 212                         elif test "${cf_tst_cflags}" = "\"'" ; then
 213                                 CF_APPEND_TEXT(cf_new_extra_cppflags,$cf_add_cflags)
 214                                 continue
 215                         fi
 216                         ;;
 217                 esac
 218                 case "$CPPFLAGS" in
 219                 (*$cf_add_cflags)
 220                         ;;
 221                 (*)
 222                         case "$cf_add_cflags" in
 223                         (-D*)
 224                                 cf_tst_cppflags=`echo "x$cf_add_cflags" | sed -e 's/^...//' -e 's/=.*//'`
 225                                 CF_REMOVE_DEFINE(CPPFLAGS,$CPPFLAGS,$cf_tst_cppflags)
 226                                 ;;
 227                         esac
 228                         CF_APPEND_TEXT(cf_new_cppflags,$cf_add_cflags)
 229                         ;;
 230                 esac
 231                 ;;
 232         (*)
 233                 CF_APPEND_TEXT(cf_new_cflags,$cf_add_cflags)
 234                 ;;
 235         esac
 236         ;;
 237 (yes)
 238         CF_APPEND_TEXT(cf_new_extra_cppflags,$cf_add_cflags)
 239
 240         cf_tst_cflags=`echo "${cf_add_cflags}" |sed -e 's/^[[^"]]*"'\''//'`
 241
 242         test "x${cf_add_cflags}" != "x${cf_tst_cflags}" \
 243                 && test -z "${cf_tst_cflags}" \
 244                 && cf_fix_cppflags=no
 245         ;;
 246 esac
 247 done
 248
 249 if test -n "$cf_new_cflags" ; then
 250         ifelse([$2],,,[CF_VERBOSE(add to \$CFLAGS $cf_new_cflags)])
 251         CF_APPEND_TEXT(CFLAGS,$cf_new_cflags)
 252 fi
 253
 254 if test -n "$cf_new_cppflags" ; then
 255         ifelse([$2],,,[CF_VERBOSE(add to \$CPPFLAGS $cf_new_cppflags)])
 256         CF_APPEND_TEXT(CPPFLAGS,$cf_new_cppflags)
 257 fi
 258
 259 if test -n "$cf_new_extra_cppflags" ; then
 260         ifelse([$2],,,[CF_VERBOSE(add to \$EXTRA_CPPFLAGS $cf_new_extra_cppflags)])
 261         CF_APPEND_TEXT(EXTRA_CPPFLAGS,$cf_new_extra_cppflags)
 262 fi
 263
 264 AC_SUBST(EXTRA_CPPFLAGS)
 265
 266 ])dnl
 267 dnl ---------------------------------------------------------------------------
 268 dnl CF_ADD_CXXFLAGS version: 1 updated: 2020/04/04 16:16:13
 269 dnl ---------------
 270 dnl Copy non-preprocessor flags to $CXXFLAGS, preprocessor flags to $CPPFLAGS
 271 dnl The second parameter if given makes this macro verbose.
 272 dnl
 273 dnl Put any preprocessor definitions that use quoted strings in $EXTRA_CPPFLAGS,
 274 dnl to simplify use of $CPPFLAGS in compiler checks, etc., that are easily
 275 dnl confused by the quotes (which require backslashes to keep them usable).
 276 AC_DEFUN([CF_ADD_CXXFLAGS],
 277 [
 278 cf_save_CXXFLAGS="$CFLAGS"
 279 CFLAGS="$CXXFLAGS"
 280 CF_ADD_CFLAGS($1 ifelse($2,,,[,$2]))
 281 CXXFLAGS="$CFLAGS"
 282 CFLAGS="$cf_save_CXXFLAGS"
 283 ])dnl
 284 dnl ---------------------------------------------------------------------------
 285 dnl CF_ADD_INCDIR version: 17 updated: 2021/09/04 06:35:04
 286 dnl -------------
 287 dnl Add an include-directory to $CPPFLAGS.  Don't add /usr/include, since it is
 288 dnl redundant.  We don't normally need to add -I/usr/local/include for gcc,
 289 dnl but old versions (and some misinstalled ones) need that.  To make things
 290 dnl worse, gcc 3.x may give error messages if -I/usr/local/include is added to
 291 dnl the include-path).
 292 AC_DEFUN([CF_ADD_INCDIR],
 293 [
 294 if test -n "$1" ; then
 295   for cf_add_incdir in $1
 296   do
 297         while test "$cf_add_incdir" != /usr/include
 298         do
 299           if test -d "$cf_add_incdir"
 300           then
 301                 cf_have_incdir=no
 302                 if test -n "$CFLAGS$CPPFLAGS" ; then
 303                   # a loop is needed to ensure we can add subdirs of existing dirs
 304                   for cf_test_incdir in $CFLAGS $CPPFLAGS ; do
 305                         if test ".$cf_test_incdir" = ".-I$cf_add_incdir" ; then
 306                           cf_have_incdir=yes; break
 307                         fi
 308                   done
 309                 fi
 310
 311                 if test "$cf_have_incdir" = no ; then
 312                   if test "$cf_add_incdir" = /usr/local/include ; then
 313                         if test "$GCC" = yes
 314                         then
 315                           cf_save_CPPFLAGS=$CPPFLAGS
 316                           CF_APPEND_TEXT(CPPFLAGS,-I$cf_add_incdir)
 317                           AC_TRY_COMPILE([#include <stdio.h>],
 318                                   [printf("Hello")],
 319                                   [],
 320                                   [cf_have_incdir=yes])
 321                           CPPFLAGS=$cf_save_CPPFLAGS
 322                         fi
 323                   fi
 324                 fi
 325
 326                 if test "$cf_have_incdir" = no ; then
 327                   CF_VERBOSE(adding $cf_add_incdir to include-path)
 328                   ifelse([$2],,CPPFLAGS,[$2])="$ifelse([$2],,CPPFLAGS,[$2]) -I$cf_add_incdir"
 329
 330                   cf_top_incdir=`echo "$cf_add_incdir" | sed -e 's%/include/.*$%/include%'`
 331                   test "$cf_top_incdir" = "$cf_add_incdir" && break
 332                   cf_add_incdir="$cf_top_incdir"
 333                 else
 334                   break
 335                 fi
 336           else
 337                 break
 338           fi
 339         done
 340   done
 341 fi
 342 ])dnl
 343 dnl ---------------------------------------------------------------------------
 344 dnl CF_ADD_LIB version: 2 updated: 2010/06/02 05:03:05
 345 dnl ----------
 346 dnl Add a library, used to enforce consistency.
 347 dnl
 348 dnl $1 = library to add, without the "-l"
 349 dnl $2 = variable to update (default $LIBS)
 350 AC_DEFUN([CF_ADD_LIB],[CF_ADD_LIBS(-l$1,ifelse($2,,LIBS,[$2]))])dnl
 351 dnl ---------------------------------------------------------------------------
 352 dnl CF_ADD_LIBDIR version: 11 updated: 2020/12/31 20:19:42
 353 dnl -------------
 354 dnl     Adds to the library-path
 355 dnl
 356 dnl     Some machines have trouble with multiple -L options.
 357 dnl
 358 dnl $1 is the (list of) directory(s) to add
 359 dnl $2 is the optional name of the variable to update (default LDFLAGS)
 360 dnl
 361 AC_DEFUN([CF_ADD_LIBDIR],
 362 [
 363 if test -n "$1" ; then
 364         for cf_add_libdir in $1
 365         do
 366                 if test "$cf_add_libdir" = /usr/lib ; then
 367                         :
 368                 elif test -d "$cf_add_libdir"
 369                 then
 370                         cf_have_libdir=no
 371                         if test -n "$LDFLAGS$LIBS" ; then
 372                                 # a loop is needed to ensure we can add subdirs of existing dirs
 373                                 for cf_test_libdir in $LDFLAGS $LIBS ; do
 374                                         if test ".$cf_test_libdir" = ".-L$cf_add_libdir" ; then
 375                                                 cf_have_libdir=yes; break
 376                                         fi
 377                                 done
 378                         fi
 379                         if test "$cf_have_libdir" = no ; then
 380                                 CF_VERBOSE(adding $cf_add_libdir to library-path)
 381                                 ifelse([$2],,LDFLAGS,[$2])="-L$cf_add_libdir $ifelse([$2],,LDFLAGS,[$2])"
 382                         fi
 383                 fi
 384         done
 385 fi
 386 ])dnl
 387 dnl ---------------------------------------------------------------------------
 388 dnl CF_ADD_LIBS version: 3 updated: 2019/11/02 16:47:33
 389 dnl -----------
 390 dnl Add one or more libraries, used to enforce consistency.  Libraries are
 391 dnl prepended to an existing list, since their dependencies are assumed to
 392 dnl already exist in the list.
 393 dnl
 394 dnl $1 = libraries to add, with the "-l", etc.
 395 dnl $2 = variable to update (default $LIBS)
 396 AC_DEFUN([CF_ADD_LIBS],[
 397 cf_add_libs="[$]ifelse($2,,LIBS,[$2])"
 398 # reverse order
 399 cf_add_0lib=
 400 for cf_add_1lib in $1; do cf_add_0lib="$cf_add_1lib $cf_add_0lib"; done
 401 # filter duplicates
 402 for cf_add_1lib in $cf_add_0lib; do
 403         for cf_add_2lib in $cf_add_libs; do
 404                 if test "x$cf_add_1lib" = "x$cf_add_2lib"; then
 405                         cf_add_1lib=
 406                         break
 407                 fi
 408         done
 409         test -n "$cf_add_1lib" && cf_add_libs="$cf_add_1lib $cf_add_libs"
 410 done
 411 ifelse($2,,LIBS,[$2])="$cf_add_libs"
 412 ])dnl
 413 dnl ---------------------------------------------------------------------------
 414 dnl CF_ADD_SUBDIR_PATH version: 5 updated: 2020/12/31 20:19:42
 415 dnl ------------------
 416 dnl Append to a search-list for a nonstandard header/lib-file
 417 dnl     $1 = the variable to return as result
 418 dnl     $2 = the package name
 419 dnl     $3 = the subdirectory, e.g., bin, include or lib
 420 dnl $4 = the directory under which we will test for subdirectories
 421 dnl $5 = a directory that we do not want $4 to match
 422 AC_DEFUN([CF_ADD_SUBDIR_PATH],
 423 [
 424 test "x$4" != "x$5" && \
 425 test -d "$4" && \
 426 ifelse([$5],NONE,,[{ test -z "$5" || test "x$5" = xNONE || test "x$4" != "x$5"; } &&]) {
 427         test -n "$verbose" && echo "    ... testing for $3-directories under $4"
 428         test -d "$4/$3" &&          $1="[$]$1 $4/$3"
 429         test -d "$4/$3/$2" &&       $1="[$]$1 $4/$3/$2"
 430         test -d "$4/$3/$2/$3" &&    $1="[$]$1 $4/$3/$2/$3"
 431         test -d "$4/$2/$3" &&       $1="[$]$1 $4/$2/$3"
 432         test -d "$4/$2/$3/$2" &&    $1="[$]$1 $4/$2/$3/$2"
 433 }
 434 ])dnl
 435 dnl ---------------------------------------------------------------------------
 436 dnl CF_APPEND_CFLAGS version: 3 updated: 2021/09/05 17:25:40
 437 dnl ----------------
 438 dnl Use CF_ADD_CFLAGS after first checking for potential redefinitions.
 439 dnl $1 = flags to add
 440 dnl $2 = if given makes this macro verbose.
 441 define([CF_APPEND_CFLAGS],
 442 [
 443 for cf_add_cflags in $1
 444 do
 445         case "x$cf_add_cflags" in
 446         (x-[[DU]]*)
 447                 CF_REMOVE_CFLAGS($cf_add_cflags,CFLAGS,[$2])
 448                 CF_REMOVE_CFLAGS($cf_add_cflags,CPPFLAGS,[$2])
 449                 ;;
 450         esac
 451         CF_ADD_CFLAGS([$cf_add_cflags],[$2])
 452 done
 453 ])dnl
 454 dnl ---------------------------------------------------------------------------
 455 dnl CF_APPEND_TEXT version: 1 updated: 2017/02/25 18:58:55
 456 dnl --------------
 457 dnl use this macro for appending text without introducing an extra blank at
 458 dnl the beginning
 459 define([CF_APPEND_TEXT],
 460 [
 461         test -n "[$]$1" && $1="[$]$1 "
 462         $1="[$]{$1}$2"
 463 ])dnl
 464 dnl ---------------------------------------------------------------------------
 465 dnl CF_ARG_DISABLE version: 3 updated: 1999/03/30 17:24:31
 466 dnl --------------
 467 dnl Allow user to disable a normally-on option.
 468 AC_DEFUN([CF_ARG_DISABLE],
 469 [CF_ARG_OPTION($1,[$2],[$3],[$4],yes)])dnl
 470 dnl ---------------------------------------------------------------------------
 471 dnl CF_ARG_ENABLE version: 3 updated: 1999/03/30 17:24:31
 472 dnl -------------
 473 dnl Allow user to enable a normally-off option.
 474 AC_DEFUN([CF_ARG_ENABLE],
 475 [CF_ARG_OPTION($1,[$2],[$3],[$4],no)])dnl
 476 dnl ---------------------------------------------------------------------------
 477 dnl CF_ARG_OPTION version: 5 updated: 2015/05/10 19:52:14
 478 dnl -------------
 479 dnl Restricted form of AC_ARG_ENABLE that ensures user doesn't give bogus
 480 dnl values.
 481 dnl
 482 dnl Parameters:
 483 dnl $1 = option name
 484 dnl $2 = help-string
 485 dnl $3 = action to perform if option is not default
 486 dnl $4 = action if perform if option is default
 487 dnl $5 = default option value (either 'yes' or 'no')
 488 AC_DEFUN([CF_ARG_OPTION],
 489 [AC_ARG_ENABLE([$1],[$2],[test "$enableval" != ifelse([$5],no,yes,no) && enableval=ifelse([$5],no,no,yes)
 490         if test "$enableval" != "$5" ; then
 491 ifelse([$3],,[    :]dnl
 492 ,[    $3]) ifelse([$4],,,[
 493         else
 494                 $4])
 495         fi],[enableval=$5 ifelse([$4],,,[
 496         $4
 497 ])dnl
 498 ])])dnl
 499 dnl ---------------------------------------------------------------------------
 500 dnl CF_AR_FLAGS version: 9 updated: 2021/01/01 13:31:04
 501 dnl -----------
 502 dnl Check for suitable "ar" (archiver) options for updating an archive.
 503 dnl
 504 dnl In particular, handle some obsolete cases where the "-" might be omitted,
 505 dnl as well as a workaround for breakage of make's archive rules by the GNU
 506 dnl binutils "ar" program.
 507 AC_DEFUN([CF_AR_FLAGS],[
 508 AC_REQUIRE([CF_PROG_AR])
 509
 510 AC_CACHE_CHECK(for options to update archives, cf_cv_ar_flags,[
 511         case "$cf_cv_system_name" in
 512         (*-msvc*)
 513                 cf_cv_ar_flags=''
 514                 cat >mk_static_lib.sh <<-EOF
 515                 #!$SHELL
 516                 MSVC_BIN="[$]AR"
 517                 out="\[$]1"
 518                 shift
 519                 exec \[$]MSVC_BIN -out:"\[$]out" \[$]@
 520                 EOF
 521                 chmod +x mk_static_lib.sh
 522                 AR=`pwd`/mk_static_lib.sh
 523                 ;;
 524         (*)
 525                 cf_cv_ar_flags=unknown
 526                 for cf_ar_flags in -curvU -curv curv -crv crv -cqv cqv -rv rv
 527                 do
 528
 529                         # check if $ARFLAGS already contains this choice
 530                         if test "x$ARFLAGS" != "x" ; then
 531                                 cf_check_ar_flags=`echo "x$ARFLAGS" | sed -e "s/$cf_ar_flags\$//" -e "s/$cf_ar_flags / /"`
 532                                 if test "x$ARFLAGS" != "$cf_check_ar_flags" ; then
 533                                         cf_cv_ar_flags=
 534                                         break
 535                                 fi
 536                         fi
 537
 538                         rm -f "conftest.$ac_cv_objext"
 539                         rm -f conftest.a
 540
 541                         cat >"conftest.$ac_ext" <<EOF
 542 #line __oline__ "configure"
 543 int     testdata[[3]] = { 123, 456, 789 };
 544 EOF
 545                         if AC_TRY_EVAL(ac_compile) ; then
 546                                 echo "$AR $ARFLAGS $cf_ar_flags conftest.a conftest.$ac_cv_objext" >&AC_FD_CC
 547                                 $AR $ARFLAGS "$cf_ar_flags" conftest.a "conftest.$ac_cv_objext" 2>&AC_FD_CC 1>/dev/null
 548                                 if test -f conftest.a ; then
 549                                         cf_cv_ar_flags="$cf_ar_flags"
 550                                         break
 551                                 fi
 552                         else
 553                                 CF_VERBOSE(cannot compile test-program)
 554                                 break
 555                         fi
 556                 done
 557                 rm -f conftest.a "conftest.$ac_ext" "conftest.$ac_cv_objext"
 558                 ;;
 559         esac
 560 ])
 561
 562 if test -n "$ARFLAGS" ; then
 563         if test -n "$cf_cv_ar_flags" ; then
 564                 ARFLAGS="$ARFLAGS $cf_cv_ar_flags"
 565         fi
 566 else
 567         ARFLAGS=$cf_cv_ar_flags
 568 fi
 569
 570 AC_SUBST(ARFLAGS)
 571 ])
 572 dnl ---------------------------------------------------------------------------
 573 dnl CF_AWK_BIG_PRINTF version: 5 updated: 2015/04/17 21:13:04
 574 dnl -----------------
 575 dnl Check if awk can handle big strings using printf.  Some older versions of
 576 dnl awk choke on large strings passed via "%s".
 577 dnl
 578 dnl $1 = desired string size
 579 dnl $2 = variable to set with result
 580 AC_DEFUN([CF_AWK_BIG_PRINTF],
 581 [
 582         case x$AWK in
 583         (x)
 584                 eval $2=no
 585                 ;;
 586         (*)
 587                 if ( ${AWK} 'BEGIN { xx = "x"; while (length(xx) < $1) { xx = xx "x"; }; printf("%s\n", xx); }' 2>/dev/null \
 588                         | $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
 589                         eval $2=yes
 590                 else
 591                         eval $2=no
 592                 fi
 593                 ;;
 594         esac
 595 ])dnl
 596 dnl ---------------------------------------------------------------------------
 597 dnl CF_BOOL_DECL version: 8 updated: 2004/01/30 15:51:18
 598 dnl ------------
 599 dnl Test if 'bool' is a builtin type in the configured C++ compiler.  Some
 600 dnl older compilers (e.g., gcc 2.5.8) don't support 'bool' directly; gcc
 601 dnl 2.6.3 does, in anticipation of the ANSI C++ standard.
 602 dnl
 603 dnl Treat the configuration-variable specially here, since we're directly
 604 dnl substituting its value (i.e., 1/0).
 605 dnl
 606 dnl $1 is the shell variable to store the result in, if not $cv_cv_builtin_bool
 607 AC_DEFUN([CF_BOOL_DECL],
 608 [
 609 AC_MSG_CHECKING(if we should include stdbool.h)
 610
 611 AC_CACHE_VAL(cf_cv_header_stdbool_h,[
 612         AC_TRY_COMPILE([],[bool foo = false],
 613                 [cf_cv_header_stdbool_h=0],
 614                 [AC_TRY_COMPILE([
 615 #ifndef __BEOS__
 616 #include <stdbool.h>
 617 #endif
 618 ],[bool foo = false],
 619                         [cf_cv_header_stdbool_h=1],
 620                         [cf_cv_header_stdbool_h=0])])])
 621
 622 if test "$cf_cv_header_stdbool_h" = 1
 623 then    AC_MSG_RESULT(yes)
 624 else    AC_MSG_RESULT(no)
 625 fi
 626
 627 AC_MSG_CHECKING([for builtin bool type])
 628
 629 AC_CACHE_VAL(ifelse($1,,cf_cv_builtin_bool,[$1]),[
 630         AC_TRY_COMPILE([
 631 #include <stdio.h>
 632 #include <sys/types.h>
 633 ],[bool x = false],
 634                 [ifelse($1,,cf_cv_builtin_bool,[$1])=1],
 635                 [ifelse($1,,cf_cv_builtin_bool,[$1])=0])
 636         ])
 637
 638 if test "$ifelse($1,,cf_cv_builtin_bool,[$1])" = 1
 639 then    AC_MSG_RESULT(yes)
 640 else    AC_MSG_RESULT(no)
 641 fi
 642 ])dnl
 643 dnl ---------------------------------------------------------------------------
 644 dnl CF_BOOL_SIZE version: 18 updated: 2021/09/04 06:35:04
 645 dnl ------------
 646 dnl Test for the size of 'bool' in the configured C++ compiler (e.g., a type).
 647 dnl Don't bother looking for bool.h, since it has been deprecated.
 648 dnl
 649 dnl If the current compiler is C rather than C++, we get the bool definition
 650 dnl from <stdbool.h>.
 651 AC_DEFUN([CF_BOOL_SIZE],
 652 [
 653 AC_CHECK_SIZEOF(bool,,[
 654 #include <stdlib.h>
 655 #include <stdio.h>
 656
 657 #if defined(__cplusplus)
 658
 659 #ifdef HAVE_GXX_BUILTIN_H
 660 #include <g++/builtin.h>
 661 #elif HAVE_GPP_BUILTIN_H
 662 #include <gpp/builtin.h>
 663 #elif HAVE_BUILTIN_H
 664 #include <builtin.h>
 665 #endif
 666
 667 #else
 668
 669 #if $cf_cv_header_stdbool_h
 670 #include <stdbool.h>
 671 #endif
 672
 673 #endif
 674 ])
 675
 676 AC_CACHE_CHECK(for type of bool, cf_cv_type_of_bool,[
 677         rm -f cf_test.out
 678         AC_TRY_RUN([
 679 #include <stdlib.h>
 680 #include <stdio.h>
 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: 9 updated: 2021/01/02 09:31:20
 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         if { test "$BUILD_CC" = "$CC" || test "$BUILD_CC" = '${CC}'; } ; then
 809                 AC_MSG_ERROR([Cross-build requires two compilers.
 810 Use --with-build-cc to specify the native compiler.])
 811         fi
 812
 813 else
 814         : ${BUILD_CC:='${CC}'}
 815         : ${BUILD_CPP:='${CPP}'}
 816         : ${BUILD_CFLAGS:='${CFLAGS}'}
 817         : ${BUILD_CPPFLAGS:='${CPPFLAGS}'}
 818         : ${BUILD_LDFLAGS:='${LDFLAGS}'}
 819         : ${BUILD_LIBS:='${LIBS}'}
 820         : ${BUILD_EXEEXT:='$x'}
 821         : ${BUILD_OBJEXT:='o'}
 822 fi
 823
 824 AC_SUBST(BUILD_CC)
 825 AC_SUBST(BUILD_CPP)
 826 AC_SUBST(BUILD_CFLAGS)
 827 AC_SUBST(BUILD_CPPFLAGS)
 828 AC_SUBST(BUILD_LDFLAGS)
 829 AC_SUBST(BUILD_LIBS)
 830 AC_SUBST(BUILD_EXEEXT)
 831 AC_SUBST(BUILD_OBJEXT)
 832 ])dnl
 833 dnl ---------------------------------------------------------------------------
 834 dnl CF_C11_NORETURN version: 3 updated: 2021/03/28 11:36:23
 835 dnl ---------------
 836 AC_DEFUN([CF_C11_NORETURN],
 837 [
 838 AC_MSG_CHECKING(if you want to use C11 _Noreturn feature)
 839 CF_ARG_ENABLE(stdnoreturn,
 840         [  --enable-stdnoreturn    enable C11 _Noreturn feature for diagnostics],
 841         [enable_stdnoreturn=yes],
 842         [enable_stdnoreturn=no])
 843 AC_MSG_RESULT($enable_stdnoreturn)
 844
 845 if test $enable_stdnoreturn = yes; then
 846 AC_CACHE_CHECK([for C11 _Noreturn feature], cf_cv_c11_noreturn,
 847         [AC_TRY_COMPILE([
 848 #include <stdio.h>
 849 #include <stdlib.h>
 850 #include <stdnoreturn.h>
 851 static _Noreturn void giveup(void) { exit(0); }
 852         ],
 853         [if (feof(stdin)) giveup()],
 854         cf_cv_c11_noreturn=yes,
 855         cf_cv_c11_noreturn=no)
 856         ])
 857 else
 858         cf_cv_c11_noreturn=no,
 859 fi
 860
 861 if test "$cf_cv_c11_noreturn" = yes; then
 862         AC_DEFINE(HAVE_STDNORETURN_H, 1,[Define if <stdnoreturn.h> header is available and working])
 863         AC_DEFINE_UNQUOTED(STDC_NORETURN,_Noreturn,[Define if C11 _Noreturn keyword is supported])
 864         HAVE_STDNORETURN_H=1
 865 else
 866         HAVE_STDNORETURN_H=0
 867 fi
 868
 869 AC_SUBST(HAVE_STDNORETURN_H)
 870 AC_SUBST(STDC_NORETURN)
 871 ])dnl
 872 dnl ---------------------------------------------------------------------------
 873 dnl CF_CC_ENV_FLAGS version: 10 updated: 2020/12/31 18:40:20
 874 dnl ---------------
 875 dnl Check for user's environment-breakage by stuffing CFLAGS/CPPFLAGS content
 876 dnl into CC.  This will not help with broken scripts that wrap the compiler
 877 dnl with options, but eliminates a more common category of user confusion.
 878 dnl
 879 dnl In particular, it addresses the problem of being able to run the C
 880 dnl preprocessor in a consistent manner.
 881 dnl
 882 dnl Caveat: this also disallows blanks in the pathname for the compiler, but
 883 dnl the nuisance of having inconsistent settings for compiler and preprocessor
 884 dnl outweighs that limitation.
 885 AC_DEFUN([CF_CC_ENV_FLAGS],
 886 [
 887 # This should have been defined by AC_PROG_CC
 888 : "${CC:=cc}"
 889
 890 AC_MSG_CHECKING(\$CFLAGS variable)
 891 case "x$CFLAGS" in
 892 (*-[[IUD]]*)
 893         AC_MSG_RESULT(broken)
 894         AC_MSG_WARN(your environment uses the CFLAGS variable to hold CPPFLAGS options)
 895         cf_flags="$CFLAGS"
 896         CFLAGS=
 897         for cf_arg in $cf_flags
 898         do
 899                 CF_ADD_CFLAGS($cf_arg)
 900         done
 901         ;;
 902 (*)
 903         AC_MSG_RESULT(ok)
 904         ;;
 905 esac
 906
 907 AC_MSG_CHECKING(\$CC variable)
 908 case "$CC" in
 909 (*[[\ \ ]]-*)
 910         AC_MSG_RESULT(broken)
 911         AC_MSG_WARN(your environment uses the CC variable to hold CFLAGS/CPPFLAGS options)
 912         # humor him...
 913         cf_prog=`echo "$CC" | sed -e 's/        / /g' -e 's/[[ ]]* / /g' -e 's/[[ ]]*[[ ]]-[[^ ]].*//'`
 914         cf_flags=`echo "$CC" | ${AWK:-awk} -v prog="$cf_prog" '{ printf("%s", [substr]([$]0,1+length(prog))); }'`
 915         CC="$cf_prog"
 916         for cf_arg in $cf_flags
 917         do
 918                 case "x$cf_arg" in
 919                 (x-[[IUDfgOW]]*)
 920                         CF_ADD_CFLAGS($cf_arg)
 921                         ;;
 922                 (*)
 923                         CC="$CC $cf_arg"
 924                         ;;
 925                 esac
 926         done
 927         CF_VERBOSE(resulting CC: '$CC')
 928         CF_VERBOSE(resulting CFLAGS: '$CFLAGS')
 929         CF_VERBOSE(resulting CPPFLAGS: '$CPPFLAGS')
 930         ;;
 931 (*)
 932         AC_MSG_RESULT(ok)
 933         ;;
 934 esac
 935 ])dnl
 936 dnl ---------------------------------------------------------------------------
 937 dnl CF_CFG_DEFAULTS version: 16 updated: 2021/01/04 19:33:05
 938 dnl ---------------
 939 dnl Determine the default configuration into which we'll install ncurses.  This
 940 dnl can be overridden by the user's command-line options.  There's two items to
 941 dnl look for:
 942 dnl     1. the prefix (e.g., /usr)
 943 dnl     2. the header files (e.g., /usr/include/ncurses)
 944 dnl We'll look for a previous installation of ncurses and use the same defaults.
 945 dnl
 946 dnl We don't use AC_PREFIX_DEFAULT, because it gets evaluated too soon, and
 947 dnl we don't use AC_PREFIX_PROGRAM, because we cannot distinguish ncurses's
 948 dnl programs from a vendor's.
 949 AC_DEFUN([CF_CFG_DEFAULTS],
 950 [AC_REQUIRE([AC_PROG_FGREP])dnl
 951
 952 AC_MSG_CHECKING(for prefix)
 953 if test "x$prefix" = "xNONE" ; then
 954         case "$cf_cv_system_name" in
 955                 # non-vendor systems don't have a conflict
 956         (openbsd*|freebsd*|mirbsd*|linux*|cygwin*|msys*|k*bsd*-gnu|mingw*)
 957                 prefix=/usr
 958                 ;;
 959         (*)     prefix=$ac_default_prefix
 960                 ;;
 961         esac
 962 fi
 963 AC_MSG_RESULT($prefix)
 964
 965 if test "x$prefix" = "xNONE" ; then
 966 AC_MSG_CHECKING(for default include-directory)
 967 test -n "$verbose" && echo 1>&AC_FD_MSG
 968 for cf_symbol in \
 969         "$includedir" \
 970         "$includedir/ncurses" \
 971         "$prefix/include" \
 972         "$prefix/include/ncurses" \
 973         /usr/local/include \
 974         /usr/local/include/ncurses \
 975         /usr/include \
 976         /usr/include/ncurses
 977 do
 978         cf_dir=`eval echo "$cf_symbol"`
 979         if test -f "$cf_dir/curses.h" ; then
 980         if ( ${FGREP-fgrep} NCURSES_VERSION "$cf_dir/curses.h" >/dev/null 2>&1 ) ; then
 981                 includedir="$cf_symbol"
 982                 test -n "$verbose"  && echo $ECHO_N "   found " 1>&AC_FD_MSG
 983                 break
 984         fi
 985         fi
 986         test -n "$verbose"  && echo "   tested $cf_dir" 1>&AC_FD_MSG
 987 done
 988 AC_MSG_RESULT($includedir)
 989 fi
 990 ])dnl
 991 dnl ---------------------------------------------------------------------------
 992 dnl CF_CGETENT version: 6 updated: 2017/01/21 11:06:25
 993 dnl ----------
 994 dnl Check if the terminal-capability database functions are available.  If not,
 995 dnl ncurses has a much-reduced version.
 996 AC_DEFUN([CF_CGETENT],[
 997 AC_CACHE_CHECK(for terminal-capability database functions,cf_cv_cgetent,[
 998 AC_TRY_LINK([
 999 #include <stdlib.h>],[
1000         char temp[128];
1001         char *buf = temp;
1002         char *db_array = temp;
1003         cgetent(&buf, &db_array, "vt100");
1004         cgetcap(buf, "tc", '=');
1005         cgetmatch(buf, "tc");
1006         ],
1007         [cf_cv_cgetent=yes],
1008         [cf_cv_cgetent=no])
1009 ])
1010
1011 if test "$cf_cv_cgetent" = yes
1012 then
1013         AC_DEFINE(HAVE_BSD_CGETENT,1,[Define to 1 if we have BSD cgetent])
1014 AC_CACHE_CHECK(if cgetent uses const parameter,cf_cv_cgetent_const,[
1015 AC_TRY_LINK([
1016 #pragma GCC diagnostic error "-Wincompatible-pointer-types-discards-qualifiers"
1017 #include <stdlib.h>],[
1018         char temp[128];
1019         char *buf = temp;
1020 #ifndef _NETBSD_SOURCE                  /* given, since April 2004 in stdlib.h */
1021         const char *db_array = temp;
1022         cgetent(&buf, &db_array, "vt100");
1023 #endif
1024         cgetcap(buf, "tc", '=');
1025         cgetmatch(buf, "tc");
1026         ],
1027         [cf_cv_cgetent_const=yes],
1028         [cf_cv_cgetent_const=no])
1029 ])
1030         if test "$cf_cv_cgetent_const" = yes
1031         then
1032                 AC_DEFINE_UNQUOTED(CGETENT_CONST,const,[Define to const if needed for some BSD cgetent variations])
1033         fi
1034 fi
1035 ])dnl
1036 dnl ---------------------------------------------------------------------------
1037 dnl CF_CHECK_CACHE version: 13 updated: 2020/12/31 10:54:15
1038 dnl --------------
1039 dnl Check if we're accidentally using a cache from a different machine.
1040 dnl Derive the system name, as a check for reusing the autoconf cache.
1041 dnl
1042 dnl If we've packaged config.guess and config.sub, run that (since it does a
1043 dnl better job than uname).  Normally we'll use AC_CANONICAL_HOST, but allow
1044 dnl an extra parameter that we may override, e.g., for AC_CANONICAL_SYSTEM
1045 dnl which is useful in cross-compiles.
1046 dnl
1047 dnl Note: we would use $ac_config_sub, but that is one of the places where
1048 dnl autoconf 2.5x broke compatibility with autoconf 2.13
1049 AC_DEFUN([CF_CHECK_CACHE],
1050 [
1051 if test -f "$srcdir/config.guess" || test -f "$ac_aux_dir/config.guess" ; then
1052         ifelse([$1],,[AC_CANONICAL_HOST],[$1])
1053         system_name="$host_os"
1054 else
1055         system_name="`(uname -s -r) 2>/dev/null`"
1056         if test -z "$system_name" ; then
1057                 system_name="`(hostname) 2>/dev/null`"
1058         fi
1059 fi
1060 test -n "$system_name" && AC_DEFINE_UNQUOTED(SYSTEM_NAME,"$system_name",[Define to the system name.])
1061 AC_CACHE_VAL(cf_cv_system_name,[cf_cv_system_name="$system_name"])
1062
1063 test -z "$system_name" && system_name="$cf_cv_system_name"
1064 test -n "$cf_cv_system_name" && AC_MSG_RESULT(Configuring for $cf_cv_system_name)
1065
1066 if test ".$system_name" != ".$cf_cv_system_name" ; then
1067         AC_MSG_RESULT(Cached system name ($system_name) does not agree with actual ($cf_cv_system_name))
1068         AC_MSG_ERROR("Please remove config.cache and try again.")
1069 fi
1070 ])dnl
1071 dnl ---------------------------------------------------------------------------
1072 dnl CF_CHECK_ENVIRON version: 3 updated: 2010/05/26 16:44:57
1073 dnl ----------------
1074 dnl Check for data that is usually declared in <unistd.h>, e.g., the 'environ'
1075 dnl variable.  Define a DECL_xxx symbol if we must declare it ourselves.
1076 dnl
1077 dnl $1 = the name to check
1078 dnl $2 = the assumed type
1079 AC_DEFUN([CF_CHECK_ENVIRON],
1080 [
1081 AC_CACHE_CHECK(if external $1 is declared, cf_cv_dcl_$1,[
1082     AC_TRY_COMPILE([
1083 #ifdef HAVE_STDLIB_H
1084 #include <stdlib.h>
1085 #endif
1086 #include <unistd.h> ],
1087     ifelse([$2],,int,[$2]) x = (ifelse([$2],,int,[$2])) $1,
1088     [cf_cv_dcl_$1=yes],
1089     [cf_cv_dcl_$1=no])
1090 ])
1091
1092 if test "$cf_cv_dcl_$1" = no ; then
1093     CF_UPPER(cf_result,decl_$1)
1094     AC_DEFINE_UNQUOTED($cf_result)
1095 fi
1096
1097 # It's possible (for near-UNIX clones) that the data doesn't exist
1098 CF_CHECK_EXTERN_DATA($1,ifelse([$2],,int,[$2]))
1099 ])dnl
1100 dnl ---------------------------------------------------------------------------
1101 dnl CF_CHECK_ERRNO version: 13 updated: 2020/03/10 18:53:47
1102 dnl --------------
1103 dnl Check for data that is usually declared in <stdio.h> or <errno.h>, e.g.,
1104 dnl the 'errno' variable.  Define a DECL_xxx symbol if we must declare it
1105 dnl ourselves.
1106 dnl
1107 dnl $1 = the name to check
1108 dnl $2 = the assumed type
1109 AC_DEFUN([CF_CHECK_ERRNO],
1110 [
1111 AC_CACHE_CHECK(if external $1 is declared, cf_cv_dcl_$1,[
1112         AC_TRY_COMPILE([
1113 #ifdef HAVE_STDLIB_H
1114 #include <stdlib.h>
1115 #endif
1116 #include <stdio.h>
1117 #include <sys/types.h>
1118 #include <errno.h> ],
1119         ifelse([$2],,int,[$2]) x = (ifelse([$2],,int,[$2])) $1; (void)x,
1120         [cf_cv_dcl_$1=yes],
1121         [cf_cv_dcl_$1=no])
1122 ])
1123
1124 if test "$cf_cv_dcl_$1" = no ; then
1125         CF_UPPER(cf_result,decl_$1)
1126         AC_DEFINE_UNQUOTED($cf_result)
1127 fi
1128
1129 # It's possible (for near-UNIX clones) that the data doesn't exist
1130 CF_CHECK_EXTERN_DATA($1,ifelse([$2],,int,[$2]))
1131 ])dnl
1132 dnl ---------------------------------------------------------------------------
1133 dnl CF_CHECK_EXTERN_DATA version: 5 updated: 2021/09/04 06:35:04
1134 dnl --------------------
1135 dnl Check for existence of external data in the current set of libraries.  If
1136 dnl we can modify it, it is real enough.
1137 dnl $1 = the name to check
1138 dnl $2 = its type
1139 AC_DEFUN([CF_CHECK_EXTERN_DATA],
1140 [
1141 AC_CACHE_CHECK(if external $1 exists, cf_cv_have_$1,[
1142         AC_TRY_LINK([
1143 #undef $1
1144 extern $2 $1;
1145 ],
1146         [$1 = 2],
1147         [cf_cv_have_$1=yes],
1148         [cf_cv_have_$1=no])
1149 ])
1150
1151 if test "$cf_cv_have_$1" = yes ; then
1152         CF_UPPER(cf_result,have_$1)
1153         AC_DEFINE_UNQUOTED($cf_result)
1154 fi
1155
1156 ])dnl
1157 dnl ---------------------------------------------------------------------------
1158 dnl CF_CHECK_FVISIBILITY version: 2 updated: 2020/04/04 16:16:13
1159 dnl --------------------
1160 dnl Check whether the compiler understands -fvisibility=hidden
1161 dnl
1162 dnl $1 = compiler
1163 dnl $2 = compiler-flags variable name
1164 dnl $3 = cache variable to set
1165 AC_DEFUN([CF_CHECK_FVISIBILITY],[
1166 AC_CACHE_CHECK(if $1 -fvisibility=hidden option works,$3,[
1167     cf_save_cflags="[$]$2"
1168     $2="[$]$2 -fvisibility=hidden"
1169     AC_TRY_LINK([
1170 __attribute__ ((visibility("default"))) int somefunc() {return 42;}
1171         ],[
1172         if (somefunc()) return 1;
1173 ],
1174     [$3=yes],
1175     [$3=no])
1176     $2=$cf_save_cflags
1177 ])
1178 ])dnl
1179 dnl ---------------------------------------------------------------------------
1180 dnl CF_CHECK_GETENV version: 2 updated: 2021/01/02 17:09:14
1181 dnl ---------------
1182 dnl Check if repeated getenv calls return the same pointer, e.g., it does not
1183 dnl discard the previous pointer when returning a new one.
1184 AC_DEFUN([CF_CHECK_GETENV],
1185 [
1186 AC_REQUIRE([CF_CHECK_ENVIRON])
1187 AC_CHECK_FUNC( getenv, ,, AC_MSG_ERROR(getenv not found) )
1188 AC_CHECK_FUNCS( putenv setenv strdup )
1189 AC_CACHE_CHECK(if getenv returns consistent values,cf_cv_consistent_getenv,[
1190 AC_TRY_RUN([
1191 #include <stdlib.h>
1192 #include <unistd.h>
1193 #include <stdio.h>
1194 #include <string.h>
1195 #include <sys/types.h>
1196
1197 #if defined(HAVE_ENVIRON) && defined(DECL_ENVIRON) && !defined(environ)
1198 extern char **environ;  /* POSIX, but some systems are not... */
1199 #endif
1200
1201 #if defined(HAVE_STRDUP)
1202 #define str_alloc(s) strdup(s)
1203 #else
1204 #define str_alloc(s) strcpy(malloc(strlen(s) + 1, s))
1205 #endif
1206
1207 static void set_value(const char *name, const char *value)
1208 {
1209 #if defined(HAVE_SETENV)
1210         setenv(name, value, 1);
1211 #elif defined(HAVE_PUTENV)
1212         char buffer[1024];
1213         sprintf(buffer, "%s=%s", name, value);
1214         putenv(str_alloc(buffer));
1215 #else
1216 #error neither putenv/setenv found
1217 #endif
1218 }
1219 int main(void)
1220 {
1221         int pass;
1222         size_t numenv, limit, j;
1223         char **mynames;
1224         char **myvalues;
1225         char **mypointer;
1226         char *equals;
1227         for (numenv = 0; environ[numenv]; ++numenv) ;
1228         limit = numenv + 10;
1229         mynames = (char **) calloc(limit + 1, sizeof(char *));
1230         myvalues = (char **) calloc(limit + 1, sizeof(char *));
1231         mypointer = (char **) calloc(limit + 1, sizeof(char *));
1232 #if defined(HAVE_ENVIRON)
1233         for (j = 0; environ[j]; ++j) {
1234                 mynames[j] = str_alloc(environ[j]);
1235                 equals = strchr(mynames[j], '=');
1236                 if (equals != 0) {
1237                         *equals++ = '\\0';
1238                         myvalues[j] = str_alloc(equals);
1239                 } else {
1240                         myvalues[j] = str_alloc("");
1241                 }
1242         }
1243 #endif
1244         for (j = numenv; j < limit; ++j) {
1245                 char name[80];
1246                 char value[80];
1247                 size_t found;
1248                 size_t k = 0;
1249                 do {
1250                         size_t jk;
1251                         found = 0;
1252                         sprintf(name, "TERM%lu", (unsigned long) k);
1253                         for (jk = 0; jk < j; ++jk) {
1254                                 if (!strcmp(name, mynames[jk])) {
1255                                         found = 1;
1256                                         ++k;
1257                                         break;
1258                                 }
1259                         }
1260                 } while (found);
1261                 sprintf(value, "%lu:%p", (unsigned long) k, &mynames[j]);
1262                 set_value(name, value);
1263                 mynames[j] = str_alloc(name);
1264                 myvalues[j] = str_alloc(value);
1265         }
1266         for (pass = 0; pass < 3; ++pass) {
1267                 for (j = 0; j < limit; ++j) {
1268                         char *value = getenv(mynames[j]);
1269                         if (pass) {
1270                                 if (value == 0) {
1271                                         fprintf(stderr, "getenv returned null for %s\\n", mynames[j]);
1272                                         ${cf_cv_main_return:-return}(1);
1273                                 } else if (value != mypointer[j]) {
1274                                         fprintf(stderr, "getenv returned different pointer for %s\\n", mynames[j]);
1275                                         ${cf_cv_main_return:-return}(1);
1276                                 } else if (strcmp(value, myvalues[j])) {
1277                                         fprintf(stderr, "getenv returned different value for %s\\n", mynames[j]);
1278                                         ${cf_cv_main_return:-return}(1);
1279                                 }
1280                         } else {
1281                                 size_t k;
1282                                 mypointer[j] = value;
1283                                 for (k = 0; k < j; ++k) {
1284                                         if (mypointer[j] == mypointer[k]) {
1285                                                 fprintf(stderr, "getenv returned same pointer for %s and %s\\n", mynames[j], mynames[k]);
1286                                                 ${cf_cv_main_return:-return}(1);
1287                                         }
1288                                 }
1289                         }
1290                 }
1291         }
1292         ${cf_cv_main_return:-return}(0);
1293 }
1294 ],
1295 [cf_cv_consistent_getenv=yes],
1296 [cf_cv_consistent_getenv=no],
1297 [cf_cv_consistent_getenv=unknown])
1298 ])
1299
1300 if test "x$cf_cv_consistent_getenv" = xno
1301 then
1302         AC_DEFINE(HAVE_CONSISTENT_GETENV,1,[Define to 1 if getenv repeatably returns the same value for a given name])
1303 fi
1304 ])dnl
1305 dnl ---------------------------------------------------------------------------
1306 dnl CF_CHECK_GNAT_VERSION version: 4 updated: 2021/01/01 13:31:04
1307 dnl ---------------------
1308 AC_DEFUN([CF_CHECK_GNAT_VERSION],
1309 [
1310 AC_REQUIRE([CF_GNAT_VERSION])
1311 case "$cf_cv_gnat_version" in
1312 (3.1[[1-9]]*|3.[[2-9]]*|[[4-9]].*|[[1-9]][[0-9]].[[0-9]]*|20[[0-9]][[0-9]])
1313         cf_cv_prog_gnat_correct=yes
1314         ;;
1315 (*)
1316         AC_MSG_WARN(Unsupported GNAT version $cf_cv_gnat_version. We require 3.11 or better. Disabling Ada95 binding.)
1317         cf_cv_prog_gnat_correct=no
1318         ;;
1319 esac
1320 ])
1321 dnl ---------------------------------------------------------------------------
1322 dnl CF_CHECK_GPM_WGETCH version: 6 updated: 2021/01/04 18:48:01
1323 dnl -------------------
1324 dnl Check if GPM is already linked with curses.  If so - and if the linkage
1325 dnl is not "weak" - warn about this because it can create problems linking
1326 dnl applications with ncurses.
1327 AC_DEFUN([CF_CHECK_GPM_WGETCH],[
1328 AC_REQUIRE([AC_PROG_EGREP])dnl
1329
1330 AC_CHECK_LIB(gpm,Gpm_Wgetch,[
1331
1332 AC_CACHE_CHECK(if GPM is weakly bound to curses library, cf_cv_check_gpm_wgetch,[
1333 cf_cv_check_gpm_wgetch=unknown
1334 if test "$cross_compiling" != yes ; then
1335
1336 cat >conftest.$ac_ext <<CF_EOF
1337 #include <gpm.h>
1338 int main(void)
1339 {
1340         Gpm_Wgetch();
1341         ${cf_cv_main_return:-return}(0);
1342 }
1343 CF_EOF
1344
1345         cf_save_LIBS="$LIBS"
1346         # This only works if we can look at the symbol table.  If a shared
1347         # library is stripped for install, we cannot use that.  So we're forced
1348         # to rely on the static library, noting that some packagers may not
1349         # include it.
1350         LIBS="-static -lgpm -dynamic $LIBS"
1351         if AC_TRY_EVAL(ac_compile) ; then
1352                 if AC_TRY_EVAL(ac_link) ; then
1353                         cf_cv_check_gpm_wgetch="`nm \"conftest$ac_exeext\" | ${EGREP-egrep} '\<wgetch\>' | ${EGREP-egrep} '\<[[vVwW]]\>'`"
1354                         test -n "$cf_cv_check_gpm_wgetch" && cf_cv_check_gpm_wgetch=yes
1355                         test -z "$cf_cv_check_gpm_wgetch" && cf_cv_check_gpm_wgetch=no
1356                 fi
1357         fi
1358         rm -rf ./conftest*
1359         LIBS="$cf_save_LIBS"
1360 fi
1361 ])
1362
1363 if test "$cf_cv_check_gpm_wgetch" != yes ; then
1364         AC_MSG_WARN(GPM library is already linked with curses - read the FAQ)
1365 fi
1366 ])])dnl
1367 dnl ---------------------------------------------------------------------------
1368 dnl CF_CHECK_LIBSSP version: 1 updated: 2021/10/30 10:40:19
1369 dnl ---------------
1370 dnl Check if libssp is needed, e.g., to work around misconfigured libraries
1371 dnl used in cross-compiling to MinGW.
1372 AC_DEFUN([CF_CHECK_LIBSSP],[
1373 AC_CACHE_CHECK(if ssp library is needed,cf_cv_need_libssp,[
1374 AC_TRY_LINK([
1375 #include <sys/types.h>
1376 #include <dirent.h>
1377 ],[
1378        DIR *dp = opendir(".");
1379 ],cf_cv_need_libssp=no,[
1380         cf_save_LIBS="$LIBS"
1381         LIBS="$LIBS -lssp"
1382         AC_TRY_LINK([
1383 #include <sys/types.h>
1384 #include <dirent.h>
1385         ],[
1386                    DIR *dp = opendir(".");
1387         ],cf_cv_need_libssp=yes,
1388           cf_cv_need_libssp=maybe)
1389         LIBS="$cf_save_LIBS"
1390 ])dnl
1391 ])
1392
1393 if test "x$cf_cv_need_libssp" = xyes
1394 then
1395         CF_ADD_LIB(ssp)
1396 fi
1397 ])dnl
1398 dnl ---------------------------------------------------------------------------
1399 dnl CF_CHECK_LIBTOOL_VERSION version: 2 updated: 2021/05/01 16:24:34
1400 dnl ------------------------
1401 dnl Show the version of libtool
1402 dnl
1403 dnl Save the version in a cache variable - this is not entirely a good thing,
1404 dnl but the version string from libtool is very ugly, and for bug reports it
1405 dnl might be useful to have the original string.
1406 dnl
1407 dnl There is an imitation in OpenBSD, which has no apparent use other than to
1408 dnl deny that it is GNU libtool.  Just ignore it.
1409 AC_DEFUN([CF_CHECK_LIBTOOL_VERSION],[
1410 if test -n "$LIBTOOL" && test "$LIBTOOL" != none
1411 then
1412         AC_MSG_CHECKING(version of $LIBTOOL)
1413         CF_LIBTOOL_VERSION
1414         AC_MSG_RESULT($cf_cv_libtool_version)
1415         if test -n "$cf_cv_libtool_version"
1416         then
1417                 cf_check_libtool_version=`$LIBTOOL --version 2>&1 | sed -e '/^$/d' -e 's,[[()]],...,g' -e 's,[[ ]],-,g' -e '2,$d'`
1418                 case "x$cf_check_libtool_version" in
1419                 (*...GNU-libtool...*)
1420                         ;;
1421                 (*)
1422                         AC_MSG_ERROR(This is not GNU libtool)
1423                         ;;
1424                 esac
1425         else
1426                 AC_MSG_ERROR(No version found for $LIBTOOL)
1427         fi
1428 else
1429         AC_MSG_ERROR(GNU libtool has not been found)
1430 fi
1431 ])dnl
1432 dnl ---------------------------------------------------------------------------
1433 dnl CF_CHECK_WCHAR_H version: 3 updated: 2021/01/01 13:31:04
1434 dnl ----------------
1435 dnl Check if wchar.h can be used, i.e., without defining _XOPEN_SOURCE_EXTENDED
1436 AC_DEFUN([CF_CHECK_WCHAR_H],[
1437 AC_CHECK_HEADERS( \
1438 wchar.h \
1439 wctype.h \
1440 )
1441 AC_CACHE_CHECK(if wchar.h can be used as is,cf_cv_wchar_h_okay,[
1442 AC_TRY_COMPILE(
1443 [
1444 #include <stdlib.h>
1445 #ifdef HAVE_WCHAR_H
1446 #include <wchar.h>
1447 #endif
1448 #ifdef HAVE_WCTYPE_H
1449 #include <wctype.h>
1450 #endif
1451 ],[
1452         wint_t foo = 0;
1453         int bar = iswpunct(foo)],
1454         [cf_cv_wchar_h_okay=yes],
1455         [cf_cv_wchar_h_okay=no])])
1456
1457 if test "$cf_cv_wchar_h_okay" = no
1458 then
1459         CF_PREDEFINE(_XOPEN_SOURCE_EXTENDED)
1460 fi
1461 ])dnl
1462 dnl ---------------------------------------------------------------------------
1463 dnl CF_CHECK_WCWIDTH_GRAPHICS version: 2 updated: 2021/01/02 17:09:14
1464 dnl -------------------------
1465 dnl Most "modern" terminal emulators are based to some degree on VT100, and
1466 dnl should support line-drawing.  Even with Unicode.  There is a problem.
1467 dnl
1468 dnl While most of the VT100 graphics characters were incorporated into Unicode,
1469 dnl all of those were combined into a page of useful graphics characters.
1470 dnl
1471 dnl So far, so good.
1472 dnl
1473 dnl However, while they are useful, there are other considerations.  CJK
1474 dnl is (because of poor device resolution) often rendered as double-width
1475 dnl characters.  So... for these generally-useful characters, what should
1476 dnl be the width (to make them consistent with adjacent characters)?
1477 dnl
1478 dnl The obvious choice would have been to make this locale-dependent, and use
1479 dnl wcwidth() to tell applications what the actual width is.  That was too
1480 dnl obvious.  Instead, we have a slew of "ambiguous-width" characters.
1481 dnl See for example
1482 dnl             http://www.unicode.org/reports/tr11/tr11-29.html
1483 dnl             http://www.cl.cam.ac.uk/~mgk25/ucs/scw-proposal.html
1484 dnl
1485 dnl The EastAsianWidth-6.2.0.txt file from the Unicode organization lists
1486 dnl more than 22,000 characters, with 1281 of those as ambiguous-width.  For
1487 dnl instance, it lists half (44/96) of the Latin-1 characters as
1488 dnl ambiguous-width.  Also, all of the box-characters at 0x2500 are ambiguous.
1489 dnl
1490 dnl What this means for the implementor is that on some systems wcwidth() can
1491 dnl give bad advice.  On Solaris, some of the ambiguous widths are returned as
1492 dnl 1 (the Latin-1 characters), while others are returned as 2 (line-drawing
1493 dnl characters).  These do not necessarily match the behavior of the terminal
1494 dnl emulator.  xterm, for instance, does an optional startup check to find if
1495 dnl this problem (or similar) exists with the system's locale tables, rejecting
1496 dnl them if they are too unreliable.
1497 AC_DEFUN([CF_CHECK_WCWIDTH_GRAPHICS],[
1498 AC_CACHE_CHECK(if wcwidth agrees graphics are single-width, cf_cv_wcwidth_graphics,[
1499 cat >conftest.in <<CF_EOF
1500 -       VT100 symbols
1501 0x250c  upper left corner
1502 0x2514  lower left corner
1503 0x2510  upper right corner
1504 0x2518  lower right corner
1505 0x251c  tee pointing left
1506 0x2524  tee pointing right
1507 0x2534  tee pointing up
1508 0x252c  tee pointing down
1509 0x2500  horizontal line
1510 0x2502  vertical line
1511 0x253c  large plus or crossover
1512 0x23ba  scan line 1
1513 0x23bd  scan line 9
1514 0x25c6  diamond
1515 0x2592  checker board (stipple)
1516 0x00b0  degree symbol
1517 0x00b1  plus/minus
1518 0x00b7  bullet
1519 -       Teletype 5410v1 symbols
1520 0x2190  arrow pointing left
1521 0x2192  arrow pointing right
1522 0x2193  arrow pointing down
1523 0x2191  arrow pointing up
1524 0x2592  board of squares
1525 0x2603  lantern symbol
1526 0x25ae  solid square block
1527 -       these defaults were invented for ncurses
1528 0x23bb  scan line 3
1529 0x23bc  scan line 7
1530 0x2264  less-than-or-equal-to
1531 0x2265  greater-than-or-equal-to
1532 0x03c0  greek pi
1533 0x2260  not-equal
1534 0x00a3  pound-sterling symbol
1535 -       thick-line-drawing
1536 0x250f  upper left corner
1537 0x2517  lower left corner
1538 0x2513  upper right corner
1539 0x251b  lower right corner
1540 0x2523  tee pointing left
1541 0x252b  tee pointing right
1542 0x253b  tee pointing up
1543 0x2533  tee pointing down
1544 0x2501  horizontal line
1545 0x2503  vertical line
1546 0x254b  large plus or crossover
1547 -       double-line-drawing
1548 0x2554  upper left corner
1549 0x255a  lower left corner
1550 0x2557  upper right corner
1551 0x255d  lower right corner
1552 0x2563  tee pointing left
1553 0x2560  tee pointing right
1554 0x2569  tee pointing up
1555 0x2566  tee pointing down
1556 0x2550  horizontal line
1557 0x2551  vertical line
1558 0x256c  large plus or crossover
1559 CF_EOF
1560 AC_TRY_RUN([
1561 #include <locale.h>
1562 #include <stdio.h>
1563 #include <wchar.h>
1564
1565 #define MY_LEN 80
1566
1567 int
1568 main(void)
1569 {
1570         FILE *fp;
1571         int value;
1572         char buffer[MY_LEN + 1];
1573         char notes[MY_LEN + 1];
1574         int totals = 0;
1575         int passed = 0;
1576
1577         if (setlocale(LC_ALL, "en_US.UTF8") ||
1578                 setlocale(LC_ALL, "en_US.UTF-8") ||
1579                 setlocale(LC_ALL, "en_US.utf8") ||
1580                 setlocale(LC_ALL, "en_US.utf-8")) {
1581                 if ((fp = fopen("conftest.in", "r")) != 0) {
1582                         while (fgets(buffer, MY_LEN, fp) != 0) {
1583                                 if (*buffer == '-') {
1584                                         fprintf(stderr, "\\t%s", buffer);
1585                                 } else if (sscanf(buffer, "%x %s", &value, notes) == 2) {
1586                                         ++totals;
1587                                         if (wcwidth(value) == 1)
1588                                                 ++passed;
1589                                         fprintf(stderr, "%d\\t%s", wcwidth(value), buffer);
1590                                 } else {
1591                                         fprintf(stderr, "?\\t%s", buffer);
1592                                 }
1593                         }
1594                 }
1595         }
1596         fprintf(stderr, "%d/%d passed wcwidth/graphics check\\n", passed, totals);
1597         return (totals == passed) ? 0 : 1;
1598 }
1599 ],
1600 [cf_cv_wcwidth_graphics=yes],
1601 [cf_cv_wcwidth_graphics=no],
1602 [cf_cv_wcwidth_graphics=unknown])
1603 ])
1604 ])dnl
1605 dnl ---------------------------------------------------------------------------
1606 dnl CF_CLANG_COMPILER version: 8 updated: 2021/01/01 13:31:04
1607 dnl -----------------
1608 dnl Check if the given compiler is really clang.  clang's C driver defines
1609 dnl __GNUC__ (fooling the configure script into setting $GCC to yes) but does
1610 dnl not ignore some gcc options.
1611 dnl
1612 dnl This macro should be run "soon" after AC_PROG_CC or AC_PROG_CPLUSPLUS, to
1613 dnl ensure that it is not mistaken for gcc/g++.  It is normally invoked from
1614 dnl the wrappers for gcc and g++ warnings.
1615 dnl
1616 dnl $1 = GCC (default) or GXX
1617 dnl $2 = CLANG_COMPILER (default)
1618 dnl $3 = CFLAGS (default) or CXXFLAGS
1619 AC_DEFUN([CF_CLANG_COMPILER],[
1620 ifelse([$2],,CLANG_COMPILER,[$2])=no
1621
1622 if test "$ifelse([$1],,[$1],GCC)" = yes ; then
1623         AC_MSG_CHECKING(if this is really Clang ifelse([$1],GXX,C++,C) compiler)
1624         cf_save_CFLAGS="$ifelse([$3],,CFLAGS,[$3])"
1625         AC_TRY_COMPILE([],[
1626 #ifdef __clang__
1627 #else
1628 make an error
1629 #endif
1630 ],[ifelse([$2],,CLANG_COMPILER,[$2])=yes
1631 ],[])
1632         ifelse([$3],,CFLAGS,[$3])="$cf_save_CFLAGS"
1633         AC_MSG_RESULT($ifelse([$2],,CLANG_COMPILER,[$2]))
1634 fi
1635
1636 CLANG_VERSION=none
1637
1638 if test "x$ifelse([$2],,CLANG_COMPILER,[$2])" = "xyes" ; then
1639         case "$CC" in
1640         (c[[1-9]][[0-9]]|*/c[[1-9]][[0-9]])
1641                 AC_MSG_WARN(replacing broken compiler alias $CC)
1642                 CFLAGS="$CFLAGS -std=`echo "$CC" | sed -e 's%.*/%%'`"
1643                 CC=clang
1644                 ;;
1645         esac
1646
1647         AC_MSG_CHECKING(version of $CC)
1648         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.]].*//'`"
1649         test -z "$CLANG_VERSION" && CLANG_VERSION=unknown
1650         AC_MSG_RESULT($CLANG_VERSION)
1651
1652         for cf_clang_opt in \
1653                 -Qunused-arguments \
1654                 -Wno-error=implicit-function-declaration
1655         do
1656                 AC_MSG_CHECKING(if option $cf_clang_opt works)
1657                 cf_save_CFLAGS="$CFLAGS"
1658                 CFLAGS="$CFLAGS $cf_clang_opt"
1659                 AC_TRY_LINK([
1660                         #include <stdio.h>],[
1661                         printf("hello!\\n");],[
1662                         cf_clang_optok=yes],[
1663                         cf_clang_optok=no])
1664                 AC_MSG_RESULT($cf_clang_optok)
1665                 CFLAGS="$cf_save_CFLAGS"
1666                 if test "$cf_clang_optok" = yes; then
1667                         CF_VERBOSE(adding option $cf_clang_opt)
1668                         CF_APPEND_TEXT(CFLAGS,$cf_clang_opt)
1669                 fi
1670         done
1671 fi
1672 ])
1673 dnl ---------------------------------------------------------------------------
1674 dnl CF_CONST_X_STRING version: 7 updated: 2021/06/07 17:39:17
1675 dnl -----------------
1676 dnl The X11R4-X11R6 Xt specification uses an ambiguous String type for most
1677 dnl character-strings.
1678 dnl
1679 dnl It is ambiguous because the specification accommodated the pre-ANSI
1680 dnl compilers bundled by more than one vendor in lieu of providing a standard C
1681 dnl compiler other than by costly add-ons.  Because of this, the specification
1682 dnl did not take into account the use of const for telling the compiler that
1683 dnl string literals would be in readonly memory.
1684 dnl
1685 dnl As a workaround, one could (starting with X11R5) define XTSTRINGDEFINES, to
1686 dnl let the compiler decide how to represent Xt's strings which were #define'd.
1687 dnl That does not solve the problem of using the block of Xt's strings which
1688 dnl are compiled into the library (and is less efficient than one might want).
1689 dnl
1690 dnl Xt specification 7 introduces the _CONST_X_STRING symbol which is used both
1691 dnl when compiling the library and compiling using the library, to tell the
1692 dnl compiler that String is const.
1693 AC_DEFUN([CF_CONST_X_STRING],
1694 [
1695 AC_REQUIRE([AC_PATH_XTRA])
1696
1697 CF_SAVE_XTRA_FLAGS([CF_CONST_X_STRING])
1698
1699 AC_TRY_COMPILE(
1700 [
1701 #include <stdlib.h>
1702 #include <X11/Intrinsic.h>
1703 ],
1704 [String foo = malloc(1); free((void*)foo)],[
1705
1706 AC_CACHE_CHECK(for X11/Xt const-feature,cf_cv_const_x_string,[
1707         AC_TRY_COMPILE(
1708                 [
1709 #define _CONST_X_STRING /* X11R7.8 (perhaps) */
1710 #undef  XTSTRINGDEFINES /* X11R5 and later */
1711 #include <stdlib.h>
1712 #include <X11/Intrinsic.h>
1713                 ],[String foo = malloc(1); *foo = 0],[
1714                         cf_cv_const_x_string=no
1715                 ],[
1716                         cf_cv_const_x_string=yes
1717                 ])
1718 ])
1719
1720 CF_RESTORE_XTRA_FLAGS([CF_CONST_X_STRING])
1721
1722 case "$cf_cv_const_x_string" in
1723 (no)
1724         CF_APPEND_TEXT(CPPFLAGS,-DXTSTRINGDEFINES)
1725         ;;
1726 (*)
1727         CF_APPEND_TEXT(CPPFLAGS,-D_CONST_X_STRING)
1728         ;;
1729 esac
1730
1731 ])
1732 ])dnl
1733 dnl ---------------------------------------------------------------------------
1734 dnl CF_CPP_PARAM_INIT version: 7 updated: 2017/01/21 11:06:25
1735 dnl -----------------
1736 dnl Check if the C++ compiler accepts duplicate parameter initialization.  This
1737 dnl is a late feature for the standard and is not in some recent compilers
1738 dnl (1999/9/11).
1739 AC_DEFUN([CF_CPP_PARAM_INIT],
1740 [
1741 if test -n "$CXX"; then
1742 AC_CACHE_CHECK(if $CXX accepts parameter initialization,cf_cv_cpp_param_init,[
1743         AC_LANG_SAVE
1744         AC_LANG_CPLUSPLUS
1745         AC_TRY_RUN([
1746 class TEST {
1747 private:
1748         int value;
1749 public:
1750         TEST(int x = 1);
1751         ~TEST();
1752 };
1753
1754 TEST::TEST(int x = 1)   // some compilers do not like second initializer
1755 {
1756         value = x;
1757 }
1758 int main(void) { }
1759 ],
1760         [cf_cv_cpp_param_init=yes],
1761         [cf_cv_cpp_param_init=no],
1762         [cf_cv_cpp_param_init=unknown])
1763         AC_LANG_RESTORE
1764 ])
1765 fi
1766 test "$cf_cv_cpp_param_init" = yes && AC_DEFINE(CPP_HAS_PARAM_INIT,1,[Define to 1 if C++ has parameter initialization])
1767 ])dnl
1768 dnl ---------------------------------------------------------------------------
1769 dnl CF_CPP_STATIC_CAST version: 3 updated: 2013/04/13 18:03:21
1770 dnl ------------------
1771 dnl Check if the C++ compiler accepts static_cast in generics.  This appears to
1772 dnl not be supported in g++ before 3.0
1773 AC_DEFUN([CF_CPP_STATIC_CAST],
1774 [
1775 if test -n "$CXX"; then
1776
1777 AC_CACHE_CHECK(if $CXX accepts static_cast,cf_cv_cpp_static_cast,[
1778         AC_LANG_SAVE
1779         AC_LANG_CPLUSPLUS
1780
1781         AC_TRY_COMPILE([
1782 class NCursesPanel
1783 {
1784 public:
1785   NCursesPanel(int nlines,
1786                int ncols,
1787                int begin_y = 0,
1788                int begin_x = 0)
1789   {
1790   }
1791   NCursesPanel();
1792   ~NCursesPanel();
1793 };
1794
1795 template<class T> class NCursesUserPanel : public NCursesPanel
1796 {
1797 public:
1798   NCursesUserPanel (int nlines,
1799                     int ncols,
1800                     int begin_y = 0,
1801                     int begin_x = 0,
1802                     const T* p_UserData = static_cast<T*>(0))
1803     : NCursesPanel (nlines, ncols, begin_y, begin_x)
1804   {
1805   };
1806   NCursesUserPanel(const T* p_UserData = static_cast<T*>(0)) : NCursesPanel()
1807   {
1808   };
1809
1810   virtual ~NCursesUserPanel() {};
1811 };
1812 ],[
1813         const char* p_UserData = static_cast<char*>(0)],
1814         [cf_cv_cpp_static_cast=yes],
1815         [cf_cv_cpp_static_cast=no])
1816
1817         AC_LANG_RESTORE
1818 ])
1819
1820 fi
1821
1822 test "$cf_cv_cpp_static_cast" = yes && AC_DEFINE(CPP_HAS_STATIC_CAST,1,[Define to 1 if C++ has static_cast])
1823 ])dnl
1824 dnl ---------------------------------------------------------------------------
1825 dnl CF_CXX_AR_FLAGS version: 3 updated: 2021/01/01 13:31:04
1826 dnl ---------------
1827 dnl Setup special archiver flags for given compilers.
1828 AC_DEFUN([CF_CXX_AR_FLAGS],[
1829         CXX_AR='$(AR)'
1830         CXX_ARFLAGS='$(ARFLAGS)'
1831         case "$cf_cv_system_name" in
1832         (irix*)
1833             if test "$GXX" != yes ; then
1834                 CXX_AR='$(CXX)'
1835                 CXX_ARFLAGS='-ar -o'
1836             fi
1837             ;;
1838         (sco3.2v5*)
1839             CXXLDFLAGS="-u main"
1840             ;;
1841         (solaris2*)
1842             if test "$GXX" != yes ; then
1843                 CXX_AR='$(CXX)'
1844                 CXX_ARFLAGS='-xar -o'
1845             fi
1846             ;;
1847         esac
1848         AC_SUBST(CXXLDFLAGS)
1849         AC_SUBST(CXX_AR)
1850         AC_SUBST(CXX_ARFLAGS)
1851 ])dnl
1852 dnl ---------------------------------------------------------------------------
1853 dnl CF_CXX_IOSTREAM_NAMESPACE version: 2 updated: 2012/10/06 17:56:13
1854 dnl -------------------------
1855 dnl For c++, check if iostream uses "std::" namespace.
1856 AC_DEFUN([CF_CXX_IOSTREAM_NAMESPACE],[
1857 AC_CHECK_HEADERS(iostream)
1858 if test x"$ac_cv_header_iostream" = xyes ; then
1859         AC_MSG_CHECKING(if iostream uses std-namespace)
1860         AC_TRY_COMPILE([
1861 #include <iostream>
1862 using std::endl;
1863 using std::cerr;],[
1864 cerr << "testing" << endl;
1865 ],[cf_iostream_namespace=yes],[cf_iostream_namespace=no])
1866         AC_MSG_RESULT($cf_iostream_namespace)
1867         if test "$cf_iostream_namespace" = yes ; then
1868                 AC_DEFINE(IOSTREAM_NAMESPACE,1,[Define to 1 if C++ has namespace iostream])
1869         fi
1870 fi
1871 ])dnl
1872 dnl ---------------------------------------------------------------------------
1873 dnl CF_C_INLINE version: 6 updated: 2019/09/07 13:38:36
1874 dnl -----------
1875 dnl Check if the C compiler supports "inline".
1876 dnl $1 is the name of a shell variable to set if inline is supported
1877 dnl $2 is the threshold for gcc 4.x's option controlling maximum inline size
1878 AC_DEFUN([CF_C_INLINE],[
1879 AC_REQUIRE([CF_GCC_VERSION])
1880 AC_C_INLINE
1881 $1=
1882 if test "$ac_cv_c_inline" != no ; then
1883         $1=inline
1884         if test "$INTEL_COMPILER" = yes
1885         then
1886                 :
1887         elif test "$CLANG_COMPILER" = yes
1888         then
1889                 :
1890         elif test "$GCC" = yes
1891         then
1892                 AC_CACHE_CHECK(if $CC supports options to tune inlining,cf_cv_gcc_inline,[
1893                 cf_save_CFLAGS=$CFLAGS
1894                 CFLAGS="$CFLAGS --param max-inline-insns-single=$2"
1895                 AC_TRY_COMPILE([inline int foo(void) { return 1; }],
1896                 [${cf_cv_main_return:-return} foo()],
1897                 [cf_cv_gcc_inline=yes],
1898                 [cf_cv_gcc_inline=no])
1899                 CFLAGS=$cf_save_CFLAGS
1900                 ])
1901                 if test "$cf_cv_gcc_inline" = yes ; then
1902                         CF_ADD_CFLAGS([--param max-inline-insns-single=$2])
1903                 fi
1904         fi
1905 fi
1906 AC_SUBST($1)
1907 ])dnl
1908 dnl ---------------------------------------------------------------------------
1909 dnl CF_DIRNAME version: 5 updated: 2020/12/31 20:19:42
1910 dnl ----------
1911 dnl "dirname" is not portable, so we fake it with a shell script.
1912 AC_DEFUN([CF_DIRNAME],[$1=`echo "$2" | sed -e 's%/[[^/]]*$%%'`])dnl
1913 dnl ---------------------------------------------------------------------------
1914 dnl CF_DIRS_TO_MAKE version: 4 updated: 2021/01/01 13:31:04
1915 dnl ---------------
1916 AC_DEFUN([CF_DIRS_TO_MAKE],
1917 [
1918 DIRS_TO_MAKE="lib"
1919 for cf_item in $cf_list_models
1920 do
1921         CF_OBJ_SUBDIR($cf_item,cf_subdir)
1922         for cf_item2 in $DIRS_TO_MAKE
1923         do
1924                 test "$cf_item2" = "$cf_subdir" && break
1925         done
1926         test ".$cf_item2" != ".$cf_subdir" && DIRS_TO_MAKE="$DIRS_TO_MAKE $cf_subdir"
1927 done
1928 for cf_dir in $DIRS_TO_MAKE
1929 do
1930         test ! -d "$cf_dir" && mkdir "$cf_dir"
1931 done
1932 AC_SUBST(DIRS_TO_MAKE)
1933 ])dnl
1934 dnl ---------------------------------------------------------------------------
1935 dnl CF_DISABLE_ECHO version: 14 updated: 2021/09/04 06:35:04
1936 dnl ---------------
1937 dnl You can always use "make -n" to see the actual options, but it is hard to
1938 dnl pick out/analyze warning messages when the compile-line is long.
1939 dnl
1940 dnl Sets:
1941 dnl     ECHO_LT - symbol to control if libtool is verbose
1942 dnl     ECHO_LD - symbol to prefix "cc -o" lines
1943 dnl     RULE_CC - symbol to put before implicit "cc -c" lines (e.g., .c.o)
1944 dnl     SHOW_CC - symbol to put before explicit "cc -c" lines
1945 dnl     ECHO_CC - symbol to put before any "cc" line
1946 dnl
1947 AC_DEFUN([CF_DISABLE_ECHO],[
1948 AC_MSG_CHECKING(if you want to see long compiling messages)
1949 CF_ARG_DISABLE(echo,
1950         [  --disable-echo          do not display "compiling" commands],
1951         [
1952         ECHO_LT='--silent'
1953         ECHO_LD='@echo linking [$]@;'
1954         RULE_CC='@echo compiling [$]<'
1955         SHOW_CC='@echo compiling [$]@'
1956         ECHO_CC='@'
1957 ],[
1958         ECHO_LT=''
1959         ECHO_LD=''
1960         RULE_CC=''
1961         SHOW_CC=''
1962         ECHO_CC=''
1963 ])
1964 AC_MSG_RESULT($enableval)
1965 AC_SUBST(ECHO_LT)
1966 AC_SUBST(ECHO_LD)
1967 AC_SUBST(RULE_CC)
1968 AC_SUBST(SHOW_CC)
1969 AC_SUBST(ECHO_CC)
1970 ])dnl
1971 dnl ---------------------------------------------------------------------------
1972 dnl CF_DISABLE_GNAT_PROJECTS version: 1 updated: 2014/06/01 11:34:00
1973 dnl ------------------------
1974 AC_DEFUN([CF_DISABLE_GNAT_PROJECTS],[
1975 AC_MSG_CHECKING(if we want to use GNAT projects)
1976 CF_ARG_DISABLE(gnat-projects,
1977         [  --disable-gnat-projects test: disable GNAT projects even if usable],
1978         [enable_gnat_projects=no],
1979         [enable_gnat_projects=yes])
1980 AC_MSG_RESULT($enable_gnat_projects)
1981 ])dnl
1982 dnl ---------------------------------------------------------------------------
1983 dnl CF_DISABLE_LEAKS version: 9 updated: 2021/04/03 16:41:50
1984 dnl ----------------
1985 dnl Combine no-leak checks with the libraries or tools that are used for the
1986 dnl checks.
1987 AC_DEFUN([CF_DISABLE_LEAKS],[
1988
1989 AC_REQUIRE([CF_WITH_DMALLOC])
1990 AC_REQUIRE([CF_WITH_DBMALLOC])
1991 AC_REQUIRE([CF_WITH_VALGRIND])
1992
1993 AC_MSG_CHECKING(if you want to perform memory-leak testing)
1994 AC_ARG_ENABLE(leaks,
1995         [  --disable-leaks         test: free permanent memory, analyze leaks],
1996         [enable_leaks=$enableval],
1997         [enable_leaks=yes])
1998 dnl with_no_leaks is more readable...
1999 if test "x$enable_leaks" = xno; then with_no_leaks=yes; else with_no_leaks=no; fi
2000 AC_MSG_RESULT($with_no_leaks)
2001
2002 if test "$enable_leaks" = no ; then
2003         AC_DEFINE(NO_LEAKS,1,[Define to 1 if you want to perform memory-leak testing.])
2004         AC_DEFINE(YY_NO_LEAKS,1,[Define to 1 if you want to perform memory-leak testing.])
2005 fi
2006 ])dnl
2007 dnl ---------------------------------------------------------------------------
2008 dnl CF_DISABLE_LIBTOOL_VERSION version: 3 updated: 2015/04/17 21:13:04
2009 dnl --------------------------
2010 dnl Check if we should use the libtool 1.5 feature "-version-number" instead of
2011 dnl the older "-version-info" feature.  The newer feature allows us to use
2012 dnl version numbering on shared libraries which make them compatible with
2013 dnl various systems.
2014 AC_DEFUN([CF_DISABLE_LIBTOOL_VERSION],
2015 [
2016 AC_MSG_CHECKING(if libtool -version-number should be used)
2017 CF_ARG_DISABLE(libtool-version,
2018         [  --disable-libtool-version  enable to use libtool's incompatible naming scheme],
2019         [cf_libtool_version=no],
2020         [cf_libtool_version=yes])
2021 AC_MSG_RESULT($cf_libtool_version)
2022
2023 if test "$cf_libtool_version" = yes ; then
2024         LIBTOOL_VERSION="-version-number"
2025 else
2026         LIBTOOL_VERSION="-version-info"
2027         case "x$VERSION" in
2028         (x)
2029                 AC_MSG_WARN(VERSION was not set)
2030                 ;;
2031         (x*.*.*)
2032                 ABI_VERSION="$VERSION"
2033                 CF_VERBOSE(ABI_VERSION: $ABI_VERSION)
2034                 ;;
2035         (x*:*:*)
2036                 ABI_VERSION=`echo "$VERSION" | sed -e 's/:/./g'`
2037                 CF_VERBOSE(ABI_VERSION: $ABI_VERSION)
2038                 ;;
2039         (*)
2040                 AC_MSG_WARN(unexpected VERSION value: $VERSION)
2041                 ;;
2042         esac
2043 fi
2044
2045 AC_SUBST(ABI_VERSION)
2046 AC_SUBST(LIBTOOL_VERSION)
2047 ])dnl
2048 dnl ---------------------------------------------------------------------------
2049 dnl CF_DISABLE_RPATH_HACK version: 3 updated: 2021/01/05 20:14:44
2050 dnl ---------------------
2051 dnl The rpath-hack makes it simpler to build programs, particularly with the
2052 dnl *BSD ports which may have essential libraries in unusual places.  But it
2053 dnl can interfere with building an executable for the base system.  Use this
2054 dnl option in that case.
2055 AC_DEFUN([CF_DISABLE_RPATH_HACK],
2056 [
2057 AC_MSG_CHECKING(if rpath-hack should be disabled)
2058 CF_ARG_DISABLE(rpath-hack,
2059         [  --disable-rpath-hack    don't add rpath options for additional libraries],
2060         [enable_rpath_hack=no],
2061         [enable_rpath_hack=yes])
2062 dnl TODO - drop cf_disable_rpath_hack
2063 if test "x$enable_rpath_hack" = xno; then cf_disable_rpath_hack=yes; else cf_disable_rpath_hack=no; fi
2064 AC_MSG_RESULT($cf_disable_rpath_hack)
2065
2066 if test "$enable_rpath_hack" = yes ; then
2067         CF_RPATH_HACK
2068 fi
2069 ])
2070 dnl ---------------------------------------------------------------------------
2071 dnl CF_ENABLE_BROKEN_LINKER version: 2 updated: 2021/01/02 17:09:14
2072 dnl -----------------------
2073 dnl Some linkers cannot reference a data-only object.  Cygwin used to be one.
2074 dnl This usually follows CF_LINK_DATAONLY, but is not required in case we need
2075 dnl an unconditional feature.
2076 AC_DEFUN([CF_ENABLE_BROKEN_LINKER],[
2077
2078 AC_MSG_CHECKING(if you want broken-linker support code)
2079 AC_ARG_ENABLE(broken_linker,
2080         [  --enable-broken_linker  compile with broken-linker support code],
2081         [with_broken_linker=$enableval],
2082         [with_broken_linker=no])
2083 AC_MSG_RESULT($with_broken_linker)
2084
2085 : "${BROKEN_LINKER:=0}"
2086 if test "x$with_broken_linker" = xyes ; then
2087         AC_DEFINE(BROKEN_LINKER,1,[Define to 1 to work around linkers which cannot link data-only modules])
2088         BROKEN_LINKER=1
2089 fi
2090 AC_SUBST(BROKEN_LINKER)
2091 ])dnl
2092 dnl ---------------------------------------------------------------------------
2093 dnl CF_ENABLE_PC_FILES version: 16 updated: 2021/11/20 12:48:37
2094 dnl ------------------
2095 dnl This is the "--enable-pc-files" option, which is available if there is a
2096 dnl pkg-config configuration on the local machine.
2097 AC_DEFUN([CF_ENABLE_PC_FILES],[
2098 AC_REQUIRE([CF_PKG_CONFIG])
2099 AC_REQUIRE([CF_WITH_PKG_CONFIG_LIBDIR])
2100
2101 if test "x$PKG_CONFIG" != xnone
2102 then
2103         AC_MSG_CHECKING(if we should install .pc files for $PKG_CONFIG)
2104 else
2105         AC_MSG_CHECKING(if we should install .pc files)
2106 fi
2107
2108 AC_ARG_ENABLE(pc-files,
2109         [  --enable-pc-files       generate and install .pc files for pkg-config],
2110         [enable_pc_files=$enableval],
2111         [enable_pc_files=no])
2112 AC_MSG_RESULT($enable_pc_files)
2113
2114 if test "x$enable_pc_files" != xno
2115 then
2116         MAKE_PC_FILES=
2117         case "x$PKG_CONFIG_LIBDIR" in
2118         (xno|xnone|xyes|x)
2119                 AC_MSG_WARN(no PKG_CONFIG_LIBDIR was found)
2120                 ;;
2121         (*)
2122                 cf_pkg_config_libdir="$PKG_CONFIG_LIBDIR"
2123                 CF_PATH_SYNTAX(cf_pkg_config_libdir)
2124                 ;;
2125         esac
2126 else
2127         MAKE_PC_FILES="#"
2128 fi
2129 AC_SUBST(MAKE_PC_FILES)
2130 ])dnl
2131 dnl ---------------------------------------------------------------------------
2132 dnl CF_ENABLE_RPATH version: 2 updated: 2010/03/27 18:39:42
2133 dnl ---------------
2134 dnl Check if the rpath option should be used, setting cache variable
2135 dnl cf_cv_enable_rpath if so.
2136 AC_DEFUN([CF_ENABLE_RPATH],
2137 [
2138 AC_MSG_CHECKING(if rpath option should be used)
2139 AC_ARG_ENABLE(rpath,
2140 [  --enable-rpath          use rpath option when generating shared libraries],
2141 [cf_cv_enable_rpath=$enableval],
2142 [cf_cv_enable_rpath=no])
2143 AC_MSG_RESULT($cf_cv_enable_rpath)
2144 ])dnl
2145 dnl ---------------------------------------------------------------------------
2146 dnl CF_ENABLE_STRING_HACKS version: 6 updated: 2021/01/05 19:23:48
2147 dnl ----------------------
2148 dnl On a few platforms, the compiler and/or loader nags with untruthful
2149 dnl comments stating that "most" uses of strcat/strcpy/sprintf are incorrect,
2150 dnl and implying that most uses of the recommended alternatives are correct.
2151 dnl
2152 dnl Factually speaking, no one has actually counted the number of uses of these
2153 dnl functions versus the total of incorrect uses.  Samples of a few thousand
2154 dnl instances are meaningless compared to the hundreds of millions of lines of
2155 dnl existing C code.
2156 dnl
2157 dnl strlcat/strlcpy are (as of 2012) non-standard, and are available on some
2158 dnl platforms, in implementations of varying quality.  Likewise, snprintf is
2159 dnl standard - but evolved through phases, and older implementations are likely
2160 dnl to yield surprising results, as documented in manpages on various systems.
2161 AC_DEFUN([CF_ENABLE_STRING_HACKS],
2162 [
2163 AC_MSG_CHECKING(if you want to work around bogus compiler/loader warnings)
2164 AC_ARG_ENABLE(string-hacks,
2165         [  --enable-string-hacks   work around bogus compiler/loader warnings],
2166         [enable_string_hacks=$enableval],
2167         [enable_string_hacks=no])
2168 AC_MSG_RESULT($enable_string_hacks)
2169
2170 if test "x$enable_string_hacks" = "xyes"; then
2171         AC_DEFINE(USE_STRING_HACKS,1,[Define to 1 to work around bogus compiler/loader warnings])
2172         AC_MSG_WARN(enabling string-hacks to work around bogus compiler/loader warnings)
2173         AC_CHECK_FUNC(strlcat,[
2174                 AC_DEFINE(HAVE_STRLCAT,1,[Define to 1 if we have strlcat function])
2175                 ],[
2176                 AC_CHECK_LIB(bsd,strlcat,[
2177                         CF_ADD_LIB(bsd)
2178                         AC_CHECK_HEADERS(bsd/string.h)
2179                         AC_DEFINE(HAVE_STRLCAT,1,[Define to 1 if we have strlcat function])
2180                         ])
2181                 ])
2182         AC_CHECK_FUNCS( strlcpy snprintf )
2183 fi
2184 ])dnl
2185 dnl ---------------------------------------------------------------------------
2186 dnl CF_ENABLE_WARNINGS version: 9 updated: 2021/01/05 19:40:50
2187 dnl ------------------
2188 dnl Configure-option to enable gcc warnings
2189 dnl
2190 dnl $1 = extra options to add, if supported
2191 dnl $2 = option for checking attributes.  By default, this is done when
2192 dnl      warnings are enabled.  For other values:
2193 dnl      yes: always do this, e.g., to use in generated library-headers
2194 dnl      no: never do this
2195 AC_DEFUN([CF_ENABLE_WARNINGS],[
2196 if test "$GCC" = yes || test "$GXX" = yes
2197 then
2198 CF_FIX_WARNINGS(CFLAGS)
2199 CF_FIX_WARNINGS(CPPFLAGS)
2200 CF_FIX_WARNINGS(LDFLAGS)
2201 AC_MSG_CHECKING(if you want to turn on gcc warnings)
2202 CF_ARG_ENABLE(warnings,
2203         [  --enable-warnings       test: turn on gcc compiler warnings],
2204         [enable_warnings=yes],
2205         [enable_warnings=no])
2206 AC_MSG_RESULT($enable_warnings)
2207 if test "$enable_warnings" = "yes"
2208 then
2209         ifelse($2,,[CF_GCC_ATTRIBUTES])
2210         CF_GCC_WARNINGS($1)
2211 fi
2212 ifelse($2,yes,[CF_GCC_ATTRIBUTES])
2213 fi
2214 ])dnl
2215 dnl ---------------------------------------------------------------------------
2216 dnl CF_ERRNO version: 5 updated: 1997/11/30 12:44:39
2217 dnl --------
2218 dnl Check if 'errno' is declared in <errno.h>
2219 AC_DEFUN([CF_ERRNO],
2220 [
2221 CF_CHECK_ERRNO(errno)
2222 ])dnl
2223 dnl ---------------------------------------------------------------------------
2224 dnl CF_ETIP_DEFINES version: 6 updated: 2021/01/02 17:09:14
2225 dnl ---------------
2226 dnl Test for conflicting definitions of exception in gcc 2.8.0, etc., between
2227 dnl math.h and builtin.h, only for ncurses
2228 AC_DEFUN([CF_ETIP_DEFINES],
2229 [
2230 AC_MSG_CHECKING(for special defines needed for etip.h)
2231 cf_save_CXXFLAGS="$CXXFLAGS"
2232 cf_result="none"
2233
2234 # etip.h includes ncurses.h which includes ncurses_dll.h
2235 # But ncurses_dll.h is generated - fix here.
2236 test -d include || mkdir include
2237 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
2238
2239 for cf_math in "" MATH_H
2240 do
2241 for cf_excp in "" MATH_EXCEPTION
2242 do
2243         CXXFLAGS="$cf_save_CXXFLAGS -I${srcdir}/c++ -I${srcdir}/menu -Iinclude -I${srcdir}/include"
2244         test -n "$cf_math" && CXXFLAGS="$CXXFLAGS -DETIP_NEEDS_${cf_math}"
2245         test -n "$cf_excp" && CXXFLAGS="$CXXFLAGS -DETIP_NEEDS_${cf_excp}"
2246 AC_TRY_COMPILE([
2247 #include <etip.h.in>
2248 ],[],[
2249         test -n "$cf_math" && AC_DEFINE_UNQUOTED(ETIP_NEEDS_${cf_math})
2250         test -n "$cf_excp" && AC_DEFINE_UNQUOTED(ETIP_NEEDS_${cf_excp})
2251         cf_result="$cf_math $cf_excp"
2252         break 2
2253 ],[])
2254 done
2255 done
2256 AC_MSG_RESULT($cf_result)
2257 CXXFLAGS="$cf_save_CXXFLAGS"
2258 ])
2259 dnl ---------------------------------------------------------------------------
2260 dnl CF_FIND_LINKAGE version: 22 updated: 2020/12/31 20:19:42
2261 dnl ---------------
2262 dnl Find a library (specifically the linkage used in the code fragment),
2263 dnl searching for it if it is not already in the library path.
2264 dnl See also CF_ADD_SEARCHPATH.
2265 dnl
2266 dnl Parameters (4-on are optional):
2267 dnl     $1 = headers for library entrypoint
2268 dnl     $2 = code fragment for library entrypoint
2269 dnl     $3 = the library name without the "-l" option or ".so" suffix.
2270 dnl     $4 = action to perform if successful (default: update CPPFLAGS, etc)
2271 dnl     $5 = action to perform if not successful
2272 dnl     $6 = module name, if not the same as the library name
2273 dnl     $7 = extra libraries
2274 dnl
2275 dnl Sets these variables:
2276 dnl     $cf_cv_find_linkage_$3 - yes/no according to whether linkage is found
2277 dnl     $cf_cv_header_path_$3 - include-directory if needed
2278 dnl     $cf_cv_library_path_$3 - library-directory if needed
2279 dnl     $cf_cv_library_file_$3 - library-file if needed, e.g., -l$3
2280 AC_DEFUN([CF_FIND_LINKAGE],[
2281
2282 # If the linkage is not already in the $CPPFLAGS/$LDFLAGS configuration, these
2283 # will be set on completion of the AC_TRY_LINK below.
2284 cf_cv_header_path_$3=
2285 cf_cv_library_path_$3=
2286
2287 CF_MSG_LOG([Starting [FIND_LINKAGE]($3,$6)])
2288
2289 cf_save_LIBS="$LIBS"
2290
2291 AC_TRY_LINK([$1],[$2],[
2292         cf_cv_find_linkage_$3=yes
2293         cf_cv_header_path_$3=/usr/include
2294         cf_cv_library_path_$3=/usr/lib
2295 ],[
2296
2297 LIBS="-l$3 $7 $cf_save_LIBS"
2298
2299 AC_TRY_LINK([$1],[$2],[
2300         cf_cv_find_linkage_$3=yes
2301         cf_cv_header_path_$3=/usr/include
2302         cf_cv_library_path_$3=/usr/lib
2303         cf_cv_library_file_$3="-l$3"
2304 ],[
2305         cf_cv_find_linkage_$3=no
2306         LIBS="$cf_save_LIBS"
2307
2308         CF_VERBOSE(find linkage for $3 library)
2309         CF_MSG_LOG([Searching for headers in [FIND_LINKAGE]($3,$6)])
2310
2311         cf_save_CPPFLAGS="$CPPFLAGS"
2312         cf_test_CPPFLAGS="$CPPFLAGS"
2313
2314         CF_HEADER_PATH(cf_search,ifelse([$6],,[$3],[$6]))
2315         for cf_cv_header_path_$3 in $cf_search
2316         do
2317                 if test -d "$cf_cv_header_path_$3" ; then
2318                         CF_VERBOSE(... testing $cf_cv_header_path_$3)
2319                         CPPFLAGS="$cf_save_CPPFLAGS"
2320                         CF_APPEND_TEXT(CPPFLAGS,-I$cf_cv_header_path_$3)
2321                         AC_TRY_COMPILE([$1],[$2],[
2322                                 CF_VERBOSE(... found $3 headers in $cf_cv_header_path_$3)
2323                                 cf_cv_find_linkage_$3=maybe
2324                                 cf_test_CPPFLAGS="$CPPFLAGS"
2325                                 break],[
2326                                 CPPFLAGS="$cf_save_CPPFLAGS"
2327                                 ])
2328                 fi
2329         done
2330
2331         if test "$cf_cv_find_linkage_$3" = maybe ; then
2332
2333                 CF_MSG_LOG([Searching for $3 library in [FIND_LINKAGE]($3,$6)])
2334
2335                 cf_save_LIBS="$LIBS"
2336                 cf_save_LDFLAGS="$LDFLAGS"
2337
2338                 ifelse([$6],,,[
2339                 CPPFLAGS="$cf_test_CPPFLAGS"
2340                 LIBS="-l$3 $7 $cf_save_LIBS"
2341                 AC_TRY_LINK([$1],[$2],[
2342                         CF_VERBOSE(... found $3 library in system)
2343                         cf_cv_find_linkage_$3=yes])
2344                         CPPFLAGS="$cf_save_CPPFLAGS"
2345                         LIBS="$cf_save_LIBS"
2346                         ])
2347
2348                 if test "$cf_cv_find_linkage_$3" != yes ; then
2349                         CF_LIBRARY_PATH(cf_search,$3)
2350                         for cf_cv_library_path_$3 in $cf_search
2351                         do
2352                                 if test -d "$cf_cv_library_path_$3" ; then
2353                                         CF_VERBOSE(... testing $cf_cv_library_path_$3)
2354                                         CPPFLAGS="$cf_test_CPPFLAGS"
2355                                         LIBS="-l$3 $7 $cf_save_LIBS"
2356                                         LDFLAGS="$cf_save_LDFLAGS -L$cf_cv_library_path_$3"
2357                                         AC_TRY_LINK([$1],[$2],[
2358                                         CF_VERBOSE(... found $3 library in $cf_cv_library_path_$3)
2359                                         cf_cv_find_linkage_$3=yes
2360                                         cf_cv_library_file_$3="-l$3"
2361                                         break],[
2362                                         CPPFLAGS="$cf_save_CPPFLAGS"
2363                                         LIBS="$cf_save_LIBS"
2364                                         LDFLAGS="$cf_save_LDFLAGS"
2365                                         ])
2366                                 fi
2367                         done
2368                         CPPFLAGS="$cf_save_CPPFLAGS"
2369                         LDFLAGS="$cf_save_LDFLAGS"
2370                 fi
2371
2372         else
2373                 cf_cv_find_linkage_$3=no
2374         fi
2375         ],$7)
2376 ])
2377
2378 LIBS="$cf_save_LIBS"
2379
2380 if test "$cf_cv_find_linkage_$3" = yes ; then
2381 ifelse([$4],,[
2382         CF_ADD_INCDIR($cf_cv_header_path_$3)
2383         CF_ADD_LIBDIR($cf_cv_library_path_$3)
2384         CF_ADD_LIB($3)
2385 ],[$4])
2386 else
2387 ifelse([$5],,AC_MSG_WARN(Cannot find $3 library),[$5])
2388 fi
2389 ])dnl
2390 dnl ---------------------------------------------------------------------------
2391 dnl CF_FIND_SUB_INCDIR version: 3 updated: 2021/01/01 13:31:04
2392 dnl ------------------
2393 dnl Find an include-directory with the given leaf-name.  This is useful for
2394 dnl example with FreeBSD ports, which use this convention to distinguish
2395 dnl different versions of the same port.
2396 AC_DEFUN([CF_FIND_SUB_INCDIR],[
2397         CF_SUBDIR_PATH(cf_search,$1,include)
2398         for cf_item in $cf_search
2399         do
2400                 case "$cf_item" in
2401                 (*/$1)
2402                         CF_ADD_INCDIR($cf_item)
2403                         ;;
2404                 esac
2405         done
2406 ])dnl
2407 dnl ---------------------------------------------------------------------------
2408 dnl CF_FIND_SUB_LIBDIR version: 3 updated: 2021/01/01 13:31:04
2409 dnl ------------------
2410 dnl Find a library-directory with the given leaf-name.  This is useful for
2411 dnl example with FreeBSD ports, which use this convention to distinguish
2412 dnl different versions of the same port.
2413 AC_DEFUN([CF_FIND_SUB_LIBDIR],[
2414         CF_SUBDIR_PATH(cf_search,$1,lib)
2415         for cf_item in $cf_search
2416         do
2417                 case "$cf_item" in
2418                 (*/$1)
2419                         CF_ADD_LIBDIR($cf_item)
2420                         ;;
2421                 esac
2422         done
2423 ])dnl
2424 dnl ---------------------------------------------------------------------------
2425 dnl CF_FIXUP_ADAFLAGS version: 2 updated: 2015/04/17 21:13:04
2426 dnl -----------------
2427 dnl make ADAFLAGS consistent with CFLAGS
2428 AC_DEFUN([CF_FIXUP_ADAFLAGS],[
2429         AC_MSG_CHECKING(optimization options for ADAFLAGS)
2430         case "$CFLAGS" in
2431         (*-g*)
2432                 CF_ADD_ADAFLAGS(-g)
2433                 ;;
2434         esac
2435         case "$CFLAGS" in
2436         (*-O*)
2437                 cf_O_flag=`echo "$CFLAGS" |sed -e 's/^.*-O/-O/' -e 's/[[        ]].*//'`
2438                 CF_ADD_ADAFLAGS($cf_O_flag)
2439                 ;;
2440         esac
2441         AC_MSG_RESULT($ADAFLAGS)
2442 ])dnl
2443 dnl ---------------------------------------------------------------------------
2444 dnl CF_FIX_WARNINGS version: 4 updated: 2021/12/16 18:22:31
2445 dnl ---------------
2446 dnl Warning flags do not belong in CFLAGS, CPPFLAGS, etc.  Any of gcc's
2447 dnl "-Werror" flags can interfere with configure-checks.  Those go into
2448 dnl EXTRA_CFLAGS.
2449 dnl
2450 dnl $1 = variable name to repair
2451 define([CF_FIX_WARNINGS],[
2452 if test "$GCC" = yes || test "$GXX" = yes
2453 then
2454         case [$]$1 in
2455         (*-Werror=*)
2456                 cf_temp_flags=
2457                 for cf_temp_scan in [$]$1
2458                 do
2459                         case "x$cf_temp_scan" in
2460                         (x-Werror=format*)
2461                                 CF_APPEND_TEXT(cf_temp_flags,$cf_temp_scan)
2462                                 ;;
2463                         (x-Werror=*)
2464                                 CF_APPEND_TEXT(EXTRA_CFLAGS,$cf_temp_scan)
2465                                 ;;
2466                         (*)
2467                                 CF_APPEND_TEXT(cf_temp_flags,$cf_temp_scan)
2468                                 ;;
2469                         esac
2470                 done
2471                 if test "x[$]$1" != "x$cf_temp_flags"
2472                 then
2473                         CF_VERBOSE(repairing $1: [$]$1)
2474                         $1="$cf_temp_flags"
2475                         CF_VERBOSE(... fixed [$]$1)
2476                         CF_VERBOSE(... extra $EXTRA_CFLAGS)
2477                 fi
2478                 ;;
2479         esac
2480 fi
2481 AC_SUBST(EXTRA_CFLAGS)
2482 ])dnl
2483 dnl ---------------------------------------------------------------------------
2484 dnl CF_FOPEN_BIN_R version: 2 updated: 2019/12/31 08:53:54
2485 dnl --------------
2486 dnl Check if fopen works when the "b" (binary) flag is added to the mode
2487 dnl parameter.  POSIX ignores the "b", which c89 specified.  Some very old
2488 dnl systems do not accept it.
2489 AC_DEFUN([CF_FOPEN_BIN_R],[
2490 AC_CACHE_CHECK(if fopen accepts explicit binary mode,cf_cv_fopen_bin_r,[
2491         AC_TRY_RUN([
2492 #include <stdio.h>
2493 int main(void) {
2494         FILE *fp = fopen("conftest.tmp", "wb");
2495         int rc = 0;
2496         if (fp != 0) {
2497                 int p, q;
2498                 for (p = 0; p < 256; ++p) {
2499                         fputc(p, fp);
2500                 }
2501                 fclose(fp);
2502                 fp = fopen("conftest.tmp", "rb");
2503                 if (fp != 0) {
2504                         for (p = 0; p < 256; ++p) {
2505                                 q = fgetc(fp);
2506                                 if (q != p) {
2507                                         rc = 1;
2508                                         break;
2509                                 }
2510                         }
2511                 } else {
2512                         rc = 1;
2513                 }
2514         } else {
2515                 rc = 1;
2516         }
2517         ${cf_cv_main_return:-return} (rc);
2518 }
2519 ],
2520                 [cf_cv_fopen_bin_r=yes],
2521                 [cf_cv_fopen_bin_r=no],
2522                 [cf_cv_fopen_bin_r=unknown])
2523 ])
2524 test "x$cf_cv_fopen_bin_r" != xno && AC_DEFINE(USE_FOPEN_BIN_R,1,[Define to 1 if fopen accepts explicit binary mode])
2525 ])dnl
2526 dnl ---------------------------------------------------------------------------
2527 dnl CF_FORGET_TOOL version: 1 updated: 2013/04/06 18:03:09
2528 dnl --------------
2529 dnl Forget that we saw the given tool.
2530 AC_DEFUN([CF_FORGET_TOOL],[
2531 unset ac_cv_prog_ac_ct_$1
2532 unset ac_ct_$1
2533 unset $1
2534 ])dnl
2535 dnl ---------------------------------------------------------------------------
2536 dnl CF_FUNC_DLSYM version: 4 updated: 2015/09/12 14:46:44
2537 dnl -------------
2538 dnl Test for dlsym() and related functions, as well as libdl.
2539 dnl
2540 dnl Sets
2541 dnl     $cf_have_dlsym
2542 dnl     $cf_have_libdl
2543 AC_DEFUN([CF_FUNC_DLSYM],[
2544 cf_have_dlsym=no
2545 AC_CHECK_FUNC(dlsym,cf_have_dlsym=yes,[
2546
2547 cf_have_libdl=no
2548 AC_CHECK_LIB(dl,dlsym,[
2549         cf_have_dlsym=yes
2550         cf_have_libdl=yes])])
2551
2552 if test "$cf_have_dlsym" = yes ; then
2553         test "$cf_have_libdl" = yes && { CF_ADD_LIB(dl) }
2554
2555         AC_MSG_CHECKING(whether able to link to dl*() functions)
2556         AC_TRY_LINK([#include <dlfcn.h>],[
2557                 void *obj;
2558                 if ((obj = dlopen("filename", 0)) != 0) {
2559                         if (dlsym(obj, "symbolname") == 0) {
2560                         dlclose(obj);
2561                         }
2562                 }],[
2563                 AC_DEFINE(HAVE_LIBDL,1,[Define to 1 if we have dl library])],[
2564                 AC_MSG_ERROR(Cannot link test program for libdl)])
2565         AC_MSG_RESULT(ok)
2566 else
2567         AC_MSG_ERROR(Cannot find dlsym function)
2568 fi
2569 ])
2570 dnl ---------------------------------------------------------------------------
2571 dnl CF_FUNC_GETTTYNAM version: 1 updated: 2021/12/04 18:29:47
2572 dnl -----------------
2573 dnl Check if the 4.3BSD function getttyname exists, as well as if <ttyent.h>
2574 dnl defines the _PATH_TTYS symbol.  If the corresponding file exists, but the
2575 dnl other checks fail, just define HAVE_PATH_TTYS.
2576 AC_DEFUN([CF_FUNC_GETTTYNAM],[
2577 AC_CACHE_CHECK(if _PATH_TTYS is defined in ttyent.h,cf_cv_PATH_TTYS,[
2578 AC_TRY_COMPILE([
2579 #include <stdio.h>
2580 #include <ttyent.h>],[
2581 FILE *fp = fopen(_PATH_TTYS, "r"); (void)fp],
2582         [cf_cv_PATH_TTYS=yes],
2583         [cf_cv_PATH_TTYS=no])])
2584
2585 if test $cf_cv_PATH_TTYS = no
2586 then
2587         for cf_ttys in /etc/ttytype /etc/ttys
2588         do
2589                 if test -f $cf_ttys
2590                 then
2591                         cf_cv_PATH_TTYS=maybe
2592                         AC_DEFINE(_PATH_TTYS,$cf_ttys,[define to pathname of file containing mapping from tty name to terminal type])
2593                         break
2594                 fi
2595         done
2596 fi
2597
2598 if test $cf_cv_PATH_TTYS != no
2599 then
2600         AC_CACHE_CHECK(if _PATH_TTYS file exists,cf_cv_have_PATH_TTYS,[
2601                 AC_TRY_RUN([
2602 #include <stdio.h>
2603 #include <ttyent.h>
2604 int main(void) {
2605         FILE *fp = fopen(_PATH_TTYS, "r");
2606         ${cf_cv_main_return:-return} (fp == 0);
2607 }],
2608                         [cf_cv_have_PATH_TTYS=yes],
2609                         [cf_cv_have_PATH_TTYS=no],
2610                         [cf_cv_have_PATH_TTYS=unknown])])
2611         test "$cf_cv_have_PATH_TTYS" = no && cf_cv_PATH_TTYS=no
2612 fi
2613
2614 if test $cf_cv_PATH_TTYS != no
2615 then
2616         AC_DEFINE(HAVE_PATH_TTYS,1,[define to 1 if system can map tty name to terminal type])
2617         AC_CACHE_CHECK(for getttynam,cf_cv_func_getttynam,[
2618                 AC_TRY_LINK([#include <ttyent.h>],
2619                 [struct ttyent *fp = getttynam("/dev/tty"); (void)fp],
2620                 [cf_cv_func_getttynam=yes],
2621                 [cf_cv_func_getttynam=no])])
2622         test "$cf_cv_func_getttynam" = yes && AC_DEFINE(HAVE_GETTTYNAM)
2623 fi
2624 ])dnl
2625 dnl ---------------------------------------------------------------------------
2626 dnl CF_FUNC_MEMMOVE version: 9 updated: 2017/01/21 11:06:25
2627 dnl ---------------
2628 dnl Check for memmove, or a bcopy that can handle overlapping copy.  If neither
2629 dnl is found, add our own version of memmove to the list of objects.
2630 AC_DEFUN([CF_FUNC_MEMMOVE],
2631 [
2632 AC_CHECK_FUNC(memmove,,[
2633 AC_CHECK_FUNC(bcopy,[
2634         AC_CACHE_CHECK(if bcopy does overlapping moves,cf_cv_good_bcopy,[
2635                 AC_TRY_RUN([
2636 int main(void) {
2637         static char data[] = "abcdefghijklmnopqrstuwwxyz";
2638         char temp[40];
2639         bcopy(data, temp, sizeof(data));
2640         bcopy(temp+10, temp, 15);
2641         bcopy(temp+5, temp+15, 10);
2642         ${cf_cv_main_return:-return} (strcmp(temp, "klmnopqrstuwwxypqrstuwwxyz"));
2643 }
2644                 ],
2645                 [cf_cv_good_bcopy=yes],
2646                 [cf_cv_good_bcopy=no],
2647                 [cf_cv_good_bcopy=unknown])
2648                 ])
2649         ],[cf_cv_good_bcopy=no])
2650         if test "$cf_cv_good_bcopy" = yes ; then
2651                 AC_DEFINE(USE_OK_BCOPY,1,[Define to 1 to use bcopy when memmove is unavailable])
2652         else
2653                 AC_DEFINE(USE_MY_MEMMOVE,1,[Define to 1 to use replacement function when memmove is unavailable])
2654         fi
2655 ])])dnl
2656 dnl ---------------------------------------------------------------------------
2657 dnl CF_FUNC_NANOSLEEP version: 5 updated: 2017/01/21 11:06:25
2658 dnl -----------------
2659 dnl Check for existence of workable nanosleep() function.  Some systems, e.g.,
2660 dnl AIX 4.x, provide a non-working version.
2661 AC_DEFUN([CF_FUNC_NANOSLEEP],[
2662 AC_CACHE_CHECK(if nanosleep really works,cf_cv_func_nanosleep,[
2663 AC_TRY_RUN([
2664 #include <stdio.h>
2665 #include <errno.h>
2666 #include <time.h>
2667
2668 #ifdef HAVE_SYS_TIME_H
2669 #include <sys/time.h>
2670 #endif
2671
2672 int main(void) {
2673         struct timespec ts1, ts2;
2674         int code;
2675         ts1.tv_sec  = 0;
2676         ts1.tv_nsec = 750000000;
2677         ts2.tv_sec  = 0;
2678         ts2.tv_nsec = 0;
2679         errno = 0;
2680         code = nanosleep(&ts1, &ts2); /* on failure errno is ENOSYS. */
2681         ${cf_cv_main_return:-return}(code != 0);
2682 }
2683 ],
2684         [cf_cv_func_nanosleep=yes],
2685         [cf_cv_func_nanosleep=no],
2686         [cf_cv_func_nanosleep=unknown])])
2687
2688 test "$cf_cv_func_nanosleep" = "yes" && AC_DEFINE(HAVE_NANOSLEEP,1,[Define to 1 if we have nanosleep()])
2689 ])
2690 dnl ---------------------------------------------------------------------------
2691 dnl CF_FUNC_OPENPTY version: 6 updated: 2021/01/01 13:31:04
2692 dnl ---------------
2693 dnl Check for openpty() function, along with <pty.h> header.  It may need the
2694 dnl "util" library as well.
2695 AC_DEFUN([CF_FUNC_OPENPTY],
2696 [
2697 AC_CHECK_LIB(util,openpty,cf_cv_lib_util=yes,cf_cv_lib_util=no)
2698 AC_CACHE_CHECK(for openpty header,cf_cv_func_openpty,[
2699         cf_save_LIBS="$LIBS"
2700         test "$cf_cv_lib_util" = yes && { CF_ADD_LIB(util) }
2701         for cf_header in pty.h libutil.h util.h
2702         do
2703         AC_TRY_LINK([
2704 #include <$cf_header>
2705 ],[
2706         int x = openpty((int *)0, (int *)0, (char *)0,
2707                                    (struct termios *)0, (struct winsize *)0);
2708 ],[
2709                 cf_cv_func_openpty=$cf_header
2710                 break
2711 ],[
2712                 cf_cv_func_openpty=no
2713 ])
2714         done
2715         LIBS="$cf_save_LIBS"
2716 ])
2717 ])dnl
2718 dnl ---------------------------------------------------------------------------
2719 dnl CF_FUNC_POLL version: 10 updated: 2021/01/04 19:13:57
2720 dnl ------------
2721 dnl See if the poll function really works.  Some platforms have poll(), but
2722 dnl it does not work for terminals or files.
2723 AC_DEFUN([CF_FUNC_POLL],[
2724 tty >/dev/null 2>&1 || { AC_CHECK_FUNCS(posix_openpt) }
2725 AC_CACHE_CHECK(if poll really works,cf_cv_working_poll,[
2726 AC_TRY_RUN([
2727 #include <stdlib.h>
2728 #include <stdio.h>
2729 #include <unistd.h>
2730 #include <fcntl.h>
2731 #ifdef HAVE_POLL_H
2732 #include <poll.h>
2733 #else
2734 #include <sys/poll.h>
2735 #endif
2736 int main(void) {
2737         struct pollfd myfds;
2738         int ret;
2739
2740         /* check for Darwin bug with respect to "devices" */
2741         myfds.fd = open("/dev/null", 1);        /* O_WRONLY */
2742         if (myfds.fd < 0)
2743                 myfds.fd = 0;
2744         myfds.events = POLLIN;
2745         myfds.revents = 0;
2746
2747         ret = poll(&myfds, 1, 100);
2748
2749         if (ret < 0 || (myfds.revents & POLLNVAL)) {
2750                 ret = -1;
2751         } else {
2752                 int fd = 0;
2753                 if (!isatty(fd)) {
2754                         fd = open("/dev/tty", 2);       /* O_RDWR */
2755                 }
2756 #ifdef HAVE_POSIX_OPENPT
2757                 if (fd < 0) {
2758                         fd = posix_openpt(O_RDWR);
2759                 }
2760 #endif
2761
2762                 if (fd >= 0) {
2763                         /* also check with standard input */
2764                         myfds.fd = fd;
2765                         myfds.events = POLLIN;
2766                         myfds.revents = 0;
2767                         ret = poll(&myfds, 1, 100);
2768                 } else {
2769                         ret = -1;
2770                 }
2771         }
2772         ${cf_cv_main_return:-return}(ret < 0);
2773 }],
2774         [cf_cv_working_poll=yes],
2775         [cf_cv_working_poll=no],
2776         [cf_cv_working_poll=unknown])])
2777 test "$cf_cv_working_poll" = "yes" && AC_DEFINE(HAVE_WORKING_POLL,1,[Define to 1 if the poll function seems to work])
2778 ])dnl
2779 dnl ---------------------------------------------------------------------------
2780 dnl CF_FUNC_TERMIOS version: 3 updated: 2012/10/06 17:56:13
2781 dnl ---------------
2782 dnl Some old/broken variations define tcgetattr() only as a macro in
2783 dnl termio(s).h
2784 AC_DEFUN([CF_FUNC_TERMIOS],[
2785 AC_REQUIRE([CF_STRUCT_TERMIOS])
2786 AC_CACHE_CHECK(for tcgetattr, cf_cv_have_tcgetattr,[
2787 AC_TRY_LINK([
2788 #include <sys/types.h>
2789 #ifdef HAVE_UNISTD_H
2790 #include <unistd.h>
2791 #endif
2792 #ifdef HAVE_TERMIOS_H
2793 #include <termios.h>
2794 #define TTY struct termios
2795 #else
2796 #ifdef HAVE_TERMIO_H
2797 #include <termio.h>
2798 #define TTY struct termio
2799 #endif
2800 #endif
2801 ],[
2802 TTY foo;
2803 tcgetattr(1, &foo);],
2804 [cf_cv_have_tcgetattr=yes],
2805 [cf_cv_have_tcgetattr=no])])
2806 test "$cf_cv_have_tcgetattr" = yes && AC_DEFINE(HAVE_TCGETATTR,1,[Define to 1 if we have tcgetattr])
2807 ])dnl
2808 dnl ---------------------------------------------------------------------------
2809 dnl CF_FUNC_VSSCANF version: 7 updated: 2021/01/01 13:31:04
2810 dnl ---------------
2811 dnl Check for vsscanf() function, which is in c9x but generally not in earlier
2812 dnl versions of C.  It is in the GNU C library, and can often be simulated by
2813 dnl other functions.
2814 AC_DEFUN([CF_FUNC_VSSCANF],
2815 [
2816 AC_CACHE_CHECK(for vsscanf function or workaround,cf_cv_func_vsscanf,[
2817 AC_TRY_LINK([
2818 #include <stdarg.h>
2819 #include <stdio.h>],[
2820         va_list ap;
2821         vsscanf("from", "%d", ap)],[cf_cv_func_vsscanf=vsscanf],[
2822 AC_TRY_LINK([
2823 #include <stdarg.h>
2824 #include <stdio.h>],[
2825         FILE strbuf;
2826         char *str = "from";
2827
2828         strbuf._flag = _IOREAD;
2829         strbuf._ptr = strbuf._base = (unsigned char *) str;
2830         strbuf._cnt = strlen(str);
2831         strbuf._file = _NFILE;
2832         return (vfscanf(&strbuf, "%d", ap))],[cf_cv_func_vsscanf=vfscanf],[
2833 AC_TRY_LINK([
2834 #include <stdarg.h>
2835 #include <stdio.h>],[
2836         FILE strbuf;
2837         char *str = "from";
2838
2839         strbuf._flag = _IOREAD;
2840         strbuf._ptr = strbuf._base = (unsigned char *) str;
2841         strbuf._cnt = strlen(str);
2842         strbuf._file = _NFILE;
2843         return (_doscan(&strbuf, "%d", ap))],[cf_cv_func_vsscanf=_doscan],[
2844 cf_cv_func_vsscanf=no])])])])
2845
2846 case "$cf_cv_func_vsscanf" in
2847 (vsscanf) AC_DEFINE(HAVE_VSSCANF,1,[Define to 1 if we have vsscanf]);;
2848 (vfscanf) AC_DEFINE(HAVE_VFSCANF,1,[Define to 1 if we have vfscanf]);;
2849 (_doscan) AC_DEFINE(HAVE__DOSCAN,1,[Define to 1 if we have _doscan]);;
2850 esac
2851
2852 ])dnl
2853 dnl ---------------------------------------------------------------------------
2854 dnl CF_GCC_ATTRIBUTES version: 24 updated: 2021/03/20 12:00:25
2855 dnl -----------------
2856 dnl Test for availability of useful gcc __attribute__ directives to quiet
2857 dnl compiler warnings.  Though useful, not all are supported -- and contrary
2858 dnl to documentation, unrecognized directives cause older compilers to barf.
2859 AC_DEFUN([CF_GCC_ATTRIBUTES],
2860 [AC_REQUIRE([AC_PROG_FGREP])dnl
2861 AC_REQUIRE([CF_C11_NORETURN])dnl
2862
2863 if test "$GCC" = yes || test "$GXX" = yes
2864 then
2865 cat > conftest.i <<EOF
2866 #ifndef GCC_PRINTF
2867 #define GCC_PRINTF 0
2868 #endif
2869 #ifndef GCC_SCANF
2870 #define GCC_SCANF 0
2871 #endif
2872 #ifndef GCC_NORETURN
2873 #define GCC_NORETURN /* nothing */
2874 #endif
2875 #ifndef GCC_UNUSED
2876 #define GCC_UNUSED /* nothing */
2877 #endif
2878 EOF
2879 if test "$GCC" = yes
2880 then
2881         AC_CHECKING([for $CC __attribute__ directives])
2882 cat > "conftest.$ac_ext" <<EOF
2883 #line __oline__ "${as_me:-configure}"
2884 #include "confdefs.h"
2885 #include "conftest.h"
2886 #include "conftest.i"
2887 #if     GCC_PRINTF
2888 #define GCC_PRINTFLIKE(fmt,var) __attribute__((format(printf,fmt,var)))
2889 #else
2890 #define GCC_PRINTFLIKE(fmt,var) /*nothing*/
2891 #endif
2892 #if     GCC_SCANF
2893 #define GCC_SCANFLIKE(fmt,var)  __attribute__((format(scanf,fmt,var)))
2894 #else
2895 #define GCC_SCANFLIKE(fmt,var)  /*nothing*/
2896 #endif
2897 extern void wow(char *,...) GCC_SCANFLIKE(1,2);
2898 extern GCC_NORETURN void oops(char *,...) GCC_PRINTFLIKE(1,2);
2899 extern GCC_NORETURN void foo(void);
2900 int main(int argc GCC_UNUSED, char *argv[[]] GCC_UNUSED) { (void)argc; (void)argv; return 0; }
2901 EOF
2902         cf_printf_attribute=no
2903         cf_scanf_attribute=no
2904         for cf_attribute in scanf printf unused noreturn
2905         do
2906                 CF_UPPER(cf_ATTRIBUTE,$cf_attribute)
2907                 cf_directive="__attribute__(($cf_attribute))"
2908                 echo "checking for $CC $cf_directive" 1>&AC_FD_CC
2909
2910                 case "$cf_attribute" in
2911                 (printf)
2912                         cf_printf_attribute=yes
2913                         cat >conftest.h <<EOF
2914 #define GCC_$cf_ATTRIBUTE 1
2915 EOF
2916                         ;;
2917                 (scanf)
2918                         cf_scanf_attribute=yes
2919                         cat >conftest.h <<EOF
2920 #define GCC_$cf_ATTRIBUTE 1
2921 EOF
2922                         ;;
2923                 (*)
2924                         cat >conftest.h <<EOF
2925 #define GCC_$cf_ATTRIBUTE $cf_directive
2926 EOF
2927                         ;;
2928                 esac
2929
2930                 if AC_TRY_EVAL(ac_compile); then
2931                         test -n "$verbose" && AC_MSG_RESULT(... $cf_attribute)
2932                         cat conftest.h >>confdefs.h
2933                         case "$cf_attribute" in
2934                         (noreturn)
2935                                 AC_DEFINE_UNQUOTED(GCC_NORETURN,$cf_directive,[Define to noreturn-attribute for gcc])
2936                                 ;;
2937                         (printf)
2938                                 cf_value='/* nothing */'
2939                                 if test "$cf_printf_attribute" != no ; then
2940                                         cf_value='__attribute__((format(printf,fmt,var)))'
2941                                         AC_DEFINE(GCC_PRINTF,1,[Define to 1 if the compiler supports gcc-like printf attribute.])
2942                                 fi
2943                                 AC_DEFINE_UNQUOTED(GCC_PRINTFLIKE(fmt,var),$cf_value,[Define to printf-attribute for gcc])
2944                                 ;;
2945                         (scanf)
2946                                 cf_value='/* nothing */'
2947                                 if test "$cf_scanf_attribute" != no ; then
2948                                         cf_value='__attribute__((format(scanf,fmt,var)))'
2949                                         AC_DEFINE(GCC_SCANF,1,[Define to 1 if the compiler supports gcc-like scanf attribute.])
2950                                 fi
2951                                 AC_DEFINE_UNQUOTED(GCC_SCANFLIKE(fmt,var),$cf_value,[Define to sscanf-attribute for gcc])
2952                                 ;;
2953                         (unused)
2954                                 AC_DEFINE_UNQUOTED(GCC_UNUSED,$cf_directive,[Define to unused-attribute for gcc])
2955                                 ;;
2956                         esac
2957                 fi
2958         done
2959 else
2960         ${FGREP-fgrep} define conftest.i >>confdefs.h
2961 fi
2962 rm -rf ./conftest*
2963 fi
2964 ])dnl
2965 dnl ---------------------------------------------------------------------------
2966 dnl CF_GCC_VERSION version: 8 updated: 2019/09/07 13:38:36
2967 dnl --------------
2968 dnl Find version of gcc, and (because icc/clang pretend to be gcc without being
2969 dnl compatible), attempt to determine if icc/clang is actually used.
2970 AC_DEFUN([CF_GCC_VERSION],[
2971 AC_REQUIRE([AC_PROG_CC])
2972 GCC_VERSION=none
2973 if test "$GCC" = yes ; then
2974         AC_MSG_CHECKING(version of $CC)
2975         GCC_VERSION="`${CC} --version 2>/dev/null | sed -e '2,$d' -e 's/^.*(GCC[[^)]]*) //' -e 's/^.*(Debian[[^)]]*) //' -e 's/^[[^0-9.]]*//' -e 's/[[^0-9.]].*//'`"
2976         test -z "$GCC_VERSION" && GCC_VERSION=unknown
2977         AC_MSG_RESULT($GCC_VERSION)
2978 fi
2979 CF_INTEL_COMPILER(GCC,INTEL_COMPILER,CFLAGS)
2980 CF_CLANG_COMPILER(GCC,CLANG_COMPILER,CFLAGS)
2981 ])dnl
2982 dnl ---------------------------------------------------------------------------
2983 dnl CF_GCC_WARNINGS version: 41 updated: 2021/01/01 16:53:59
2984 dnl ---------------
2985 dnl Check if the compiler supports useful warning options.  There's a few that
2986 dnl we don't use, simply because they're too noisy:
2987 dnl
2988 dnl     -Wconversion (useful in older versions of gcc, but not in gcc 2.7.x)
2989 dnl     -Winline (usually not worthwhile)
2990 dnl     -Wredundant-decls (system headers make this too noisy)
2991 dnl     -Wtraditional (combines too many unrelated messages, only a few useful)
2992 dnl     -Wwrite-strings (too noisy, but should review occasionally).  This
2993 dnl             is enabled for ncurses using "--enable-const".
2994 dnl     -pedantic
2995 dnl
2996 dnl Parameter:
2997 dnl     $1 is an optional list of gcc warning flags that a particular
2998 dnl             application might want to use, e.g., "no-unused" for
2999 dnl             -Wno-unused
3000 dnl Special:
3001 dnl     If $with_ext_const is "yes", add a check for -Wwrite-strings
3002 dnl
3003 AC_DEFUN([CF_GCC_WARNINGS],
3004 [
3005 AC_REQUIRE([CF_GCC_VERSION])
3006 if test "x$have_x" = xyes; then CF_CONST_X_STRING fi
3007 cat > "conftest.$ac_ext" <<EOF
3008 #line __oline__ "${as_me:-configure}"
3009 int main(int argc, char *argv[[]]) { return (argv[[argc-1]] == 0) ; }
3010 EOF
3011 if test "$INTEL_COMPILER" = yes
3012 then
3013 # The "-wdXXX" options suppress warnings:
3014 # remark #1419: external declaration in primary source file
3015 # remark #1683: explicit conversion of a 64-bit integral type to a smaller integral type (potential portability problem)
3016 # remark #1684: conversion from pointer to same-sized integral type (potential portability problem)
3017 # remark #193: zero used for undefined preprocessing identifier
3018 # remark #593: variable "curs_sb_left_arrow" was set but never used
3019 # remark #810: conversion from "int" to "Dimension={unsigned short}" may lose significant bits
3020 # remark #869: parameter "tw" was never referenced
3021 # remark #981: operands are evaluated in unspecified order
3022 # warning #279: controlling expression is constant
3023
3024         AC_CHECKING([for $CC warning options])
3025         cf_save_CFLAGS="$CFLAGS"
3026         EXTRA_CFLAGS="$EXTRA_CFLAGS -Wall"
3027         for cf_opt in \
3028                 wd1419 \
3029                 wd1683 \
3030                 wd1684 \
3031                 wd193 \
3032                 wd593 \
3033                 wd279 \
3034                 wd810 \
3035                 wd869 \
3036                 wd981
3037         do
3038                 CFLAGS="$cf_save_CFLAGS $EXTRA_CFLAGS -$cf_opt"
3039                 if AC_TRY_EVAL(ac_compile); then
3040                         test -n "$verbose" && AC_MSG_RESULT(... -$cf_opt)
3041                         EXTRA_CFLAGS="$EXTRA_CFLAGS -$cf_opt"
3042                 fi
3043         done
3044         CFLAGS="$cf_save_CFLAGS"
3045 elif test "$GCC" = yes && test "$GCC_VERSION" != "unknown"
3046 then
3047         AC_CHECKING([for $CC warning options])
3048         cf_save_CFLAGS="$CFLAGS"
3049         cf_warn_CONST=""
3050         test "$with_ext_const" = yes && cf_warn_CONST="Wwrite-strings"
3051         cf_gcc_warnings="Wignored-qualifiers Wlogical-op Wvarargs"
3052         test "x$CLANG_COMPILER" = xyes && cf_gcc_warnings=
3053         for cf_opt in W Wall \
3054                 Wbad-function-cast \
3055                 Wcast-align \
3056                 Wcast-qual \
3057                 Wdeclaration-after-statement \
3058                 Wextra \
3059                 Winline \
3060                 Wmissing-declarations \
3061                 Wmissing-prototypes \
3062                 Wnested-externs \
3063                 Wpointer-arith \
3064                 Wshadow \
3065                 Wstrict-prototypes \
3066                 Wundef Wno-inline $cf_gcc_warnings $cf_warn_CONST $1
3067         do
3068                 CFLAGS="$cf_save_CFLAGS $EXTRA_CFLAGS -$cf_opt"
3069                 if AC_TRY_EVAL(ac_compile); then
3070                         test -n "$verbose" && AC_MSG_RESULT(... -$cf_opt)
3071                         case "$cf_opt" in
3072                         (Winline)
3073                                 case "$GCC_VERSION" in
3074                                 ([[34]].*)
3075                                         CF_VERBOSE(feature is broken in gcc $GCC_VERSION)
3076                                         continue;;
3077                                 esac
3078                                 ;;
3079                         (Wpointer-arith)
3080                                 case "$GCC_VERSION" in
3081                                 ([[12]].*)
3082                                         CF_VERBOSE(feature is broken in gcc $GCC_VERSION)
3083                                         continue;;
3084                                 esac
3085                                 ;;
3086                         esac
3087                         EXTRA_CFLAGS="$EXTRA_CFLAGS -$cf_opt"
3088                 fi
3089         done
3090         CFLAGS="$cf_save_CFLAGS"
3091 fi
3092 rm -rf ./conftest*
3093
3094 AC_SUBST(EXTRA_CFLAGS)
3095 ])dnl
3096 dnl ---------------------------------------------------------------------------
3097 dnl CF_GETOPT_HEADER version: 8 updated: 2021/06/19 19:16:16
3098 dnl ----------------
3099 dnl Check for getopt's variables which are commonly defined in stdlib.h,
3100 dnl unistd.h or (nonstandard) in getopt.h
3101 AC_DEFUN([CF_GETOPT_HEADER],
3102 [
3103 AC_HAVE_HEADERS(unistd.h getopt.h)
3104 AC_CACHE_CHECK(for header declaring getopt variables,cf_cv_getopt_header,[
3105 cf_cv_getopt_header=none
3106 for cf_header in stdio.h stdlib.h unistd.h getopt.h
3107 do
3108 AC_TRY_COMPILE([
3109 #include <$cf_header>],
3110 [int x = optind; char *y = optarg; (void)x; (void)y],
3111 [cf_cv_getopt_header=$cf_header
3112  break])
3113 done
3114 ])
3115 if test "$cf_cv_getopt_header" != none ; then
3116         AC_DEFINE(HAVE_GETOPT_HEADER,1,[Define to 1 if getopt variables are declared in header])
3117 fi
3118 if test "$cf_cv_getopt_header" = getopt.h ; then
3119         AC_DEFINE(NEED_GETOPT_H,1,[Define to 1 if we must include getopt.h])
3120 fi
3121 ])dnl
3122 dnl ---------------------------------------------------------------------------
3123 dnl CF_GNATPREP_OPT_T version: 1 updated: 2014/08/02 18:37:25
3124 dnl -----------------
3125 AC_DEFUN([CF_GNATPREP_OPT_T],[
3126 AC_CACHE_CHECK(if GNATPREP supports -T option,cf_cv_gnatprep_opt_t,[
3127 cf_cv_gnatprep_opt_t=no
3128 gnatprep -T 2>/dev/null >/dev/null && cf_cv_gnatprep_opt_t=yes
3129 ])
3130 test "$cf_cv_gnatprep_opt_t" = yes && GNATPREP_OPTS="-T $GNATPREP_OPTS"
3131 AC_SUBST(GNATPREP_OPTS)
3132 ])dnl
3133 dnl ---------------------------------------------------------------------------
3134 dnl CF_GNAT_GENERICS version: 7 updated: 2021/01/01 13:31:04
3135 dnl ----------------
3136 AC_DEFUN([CF_GNAT_GENERICS],
3137 [
3138 AC_REQUIRE([CF_GNAT_VERSION])
3139
3140 AC_MSG_CHECKING(if GNAT supports generics)
3141 case "$cf_cv_gnat_version" in
3142 (3.1[[1-9]]*|3.[[2-9]]*|[[4-9]].*|[[1-9]][[0-9]].[[0-9]]*|20[[0-9]][[0-9]])
3143         cf_gnat_generics=yes
3144         ;;
3145 (*)
3146         cf_gnat_generics=no
3147         ;;
3148 esac
3149 AC_MSG_RESULT($cf_gnat_generics)
3150
3151 if test "$cf_gnat_generics" = yes
3152 then
3153         cf_compile_generics=generics
3154         cf_generic_objects="\${GENOBJS}"
3155 else
3156         cf_compile_generics=
3157         cf_generic_objects=
3158 fi
3159
3160 AC_SUBST(cf_compile_generics)
3161 AC_SUBST(cf_generic_objects)
3162 ])dnl
3163 dnl ---------------------------------------------------------------------------
3164 dnl CF_GNAT_PROJECTS version: 13 updated: 2021/01/02 17:09:14
3165 dnl ----------------
3166 dnl GNAT projects are configured with ".gpr" project files.
3167 dnl GNAT libraries are a further development, using the project feature.
3168 AC_DEFUN([CF_GNAT_PROJECTS],
3169 [
3170 AC_REQUIRE([CF_GNAT_VERSION])
3171 AC_REQUIRE([CF_DISABLE_GNAT_PROJECTS])
3172
3173 cf_gnat_libraries=no
3174 cf_gnat_projects=no
3175
3176 if test "$enable_gnat_projects" != no ; then
3177 AC_MSG_CHECKING(if GNAT supports project files)
3178 case "$cf_cv_gnat_version" in
3179 (3.[[0-9]]*)
3180         ;;
3181 (*)
3182         case "$cf_cv_system_name" in
3183         (cygwin*|msys*)
3184                 ;;
3185         (*)
3186                 rm -rf ./conftest* ./*~conftest*
3187                 if mkdir conftest.src conftest.bin conftest.lib
3188                 then
3189                         cd conftest.src
3190                         rm -rf ./conftest* ./*~conftest*
3191                         cat >>library.gpr <<CF_EOF
3192 project Library is
3193   Kind := External ("LIB_KIND");
3194   for Library_Name use "ConfTest";
3195   for Object_Dir use ".";
3196   for Library_ALI_Dir use External("LIBRARY_DIR");
3197   for Library_Version use External ("SONAME");
3198   for Library_Kind use Kind;
3199   for Library_Dir use External("BUILD_DIR");
3200   Source_Dir := External ("SOURCE_DIR");
3201   for Source_Dirs use (Source_Dir);
3202 end Library;
3203 CF_EOF
3204                         cat >>confpackage.ads <<CF_EOF
3205 package ConfPackage is
3206    procedure conftest;
3207 end ConfPackage;
3208 CF_EOF
3209                         cat >>confpackage.adb <<CF_EOF
3210 with Text_IO;
3211 package body ConfPackage is
3212    procedure conftest is
3213    begin
3214       Text_IO.Put ("Hello World");
3215       Text_IO.New_Line;
3216    end conftest;
3217 end ConfPackage;
3218 CF_EOF
3219                         if ( "$cf_ada_make" $ADAFLAGS \
3220                                         -Plibrary.gpr \
3221                                         -XBUILD_DIR="`cd ../conftest.bin;pwd`" \
3222                                         -XLIBRARY_DIR="`cd ../conftest.lib;pwd`" \
3223                                         -XSOURCE_DIR="`pwd`" \
3224                                         -XSONAME=libConfTest.so.1 \
3225                                         -XLIB_KIND=static 1>&AC_FD_CC 2>&1 ) ; then
3226                                 cf_gnat_projects=yes
3227                         fi
3228                         cd ..
3229                 fi
3230                 if test -f conftest.lib/confpackage.ali
3231                 then
3232                         cf_gnat_libraries=yes
3233                 fi
3234                 rm -rf ./conftest* ./*~conftest*
3235                 ;;
3236         esac
3237         ;;
3238 esac
3239 AC_MSG_RESULT($cf_gnat_projects)
3240 fi # enable_gnat_projects
3241
3242 if test "$cf_gnat_projects" = yes
3243 then
3244         AC_MSG_CHECKING(if GNAT supports libraries)
3245         AC_MSG_RESULT($cf_gnat_libraries)
3246 fi
3247
3248 USE_OLD_MAKERULES=""
3249 USE_GNAT_PROJECTS="#"
3250 USE_GNAT_MAKE_GPR="#"
3251 USE_GNAT_GPRBUILD="#"
3252
3253 if test "$cf_gnat_projects" = yes
3254 then
3255         USE_OLD_MAKERULES="#"
3256         USE_GNAT_PROJECTS=""
3257         if test "$cf_cv_VERSION_GPRBUILD" != no
3258         then
3259                 USE_GNAT_GPRBUILD=""
3260         elif test "$cf_cv_VERSION_GNATMAKE" != no
3261         then
3262                 USE_GNAT_MAKE_GPR=""
3263         else
3264                 AC_MSG_WARN(use old makefile rules since tools are missing)
3265         fi
3266 fi
3267
3268 if test "$cf_gnat_libraries" = yes
3269 then
3270         USE_GNAT_LIBRARIES=""
3271 else
3272         USE_GNAT_LIBRARIES="#"
3273 fi
3274
3275 AC_SUBST(USE_OLD_MAKERULES)
3276 AC_SUBST(USE_GNAT_PROJECTS)
3277 AC_SUBST(USE_GNAT_LIBRARIES)
3278 AC_SUBST(USE_GNAT_MAKE_GPR)
3279 AC_SUBST(USE_GNAT_GPRBUILD)
3280 ])dnl
3281 dnl ---------------------------------------------------------------------------
3282 dnl CF_GNAT_SIGINT version: 2 updated: 2021/01/01 13:31:04
3283 dnl --------------
3284 dnl Check if gnat supports SIGINT, and presumably tasking.  For the latter, it
3285 dnl is noted that gnat may compile a tasking unit even for configurations which
3286 dnl fail at runtime.
3287 AC_DEFUN([CF_GNAT_SIGINT],[
3288 AC_CACHE_CHECK(if GNAT supports SIGINT,cf_cv_gnat_sigint,[
3289 CF_GNAT_TRY_LINK([with Ada.Interrupts.Names;
3290
3291 package ConfTest is
3292
3293    pragma Warnings (Off);  --  the next pragma exists since 3.11p
3294    pragma Unreserve_All_Interrupts;
3295    pragma Warnings (On);
3296
3297    protected Process is
3298       procedure Stop;
3299       function Continue return Boolean;
3300       pragma Attach_Handler (Stop, Ada.Interrupts.Names.SIGINT);
3301    private
3302       Done : Boolean := False;
3303    end Process;
3304
3305 end ConfTest;],
3306 [package body ConfTest is
3307    protected body Process is
3308       procedure Stop is
3309       begin
3310          Done := True;
3311       end Stop;
3312       function Continue return Boolean is
3313       begin
3314          return not Done;
3315       end Continue;
3316    end Process;
3317 end ConfTest;],
3318         [cf_cv_gnat_sigint=yes],
3319         [cf_cv_gnat_sigint=no])])
3320
3321 if test "$cf_cv_gnat_sigint" = yes ; then
3322         USE_GNAT_SIGINT=""
3323 else
3324         USE_GNAT_SIGINT="#"
3325 fi
3326 AC_SUBST(USE_GNAT_SIGINT)
3327 ])dnl
3328 dnl ---------------------------------------------------------------------------
3329 dnl CF_GNAT_TRY_LINK version: 4 updated: 2021/01/01 13:31:04
3330 dnl ----------------
3331 dnl Verify that a test program compiles/links with GNAT.
3332 dnl $cf_ada_make is set to the program that compiles/links
3333 dnl $ADAFLAGS may be set to the GNAT flags.
3334 dnl
3335 dnl $1 is the text of the spec
3336 dnl $2 is the text of the body
3337 dnl $3 is the shell command to execute if successful
3338 dnl $4 is the shell command to execute if not successful
3339 AC_DEFUN([CF_GNAT_TRY_LINK],
3340 [
3341 rm -rf ./conftest* ./*~conftest*
3342 cat >>conftest.ads <<CF_EOF
3343 $1
3344 CF_EOF
3345 cat >>conftest.adb <<CF_EOF
3346 $2
3347 CF_EOF
3348 if ( "$cf_ada_make" $ADAFLAGS conftest 1>&AC_FD_CC 2>&1 ) ; then
3349 ifelse($3,,      :,[      $3])
3350 ifelse($4,,,[else
3351    $4])
3352 fi
3353 rm -rf ./conftest* ./*~conftest*
3354 ])dnl
3355 dnl ---------------------------------------------------------------------------
3356 dnl CF_GNAT_TRY_RUN version: 6 updated: 2021/01/01 13:31:04
3357 dnl ---------------
3358 dnl Verify that a test program compiles and runs with GNAT
3359 dnl $cf_ada_make is set to the program that compiles/links
3360 dnl $ADAFLAGS may be set to the GNAT flags.
3361 dnl
3362 dnl $1 is the text of the spec
3363 dnl $2 is the text of the body
3364 dnl $3 is the shell command to execute if successful
3365 dnl $4 is the shell command to execute if not successful
3366 AC_DEFUN([CF_GNAT_TRY_RUN],
3367 [
3368 rm -rf ./conftest* ./*~conftest*
3369 cat >>conftest.ads <<CF_EOF
3370 $1
3371 CF_EOF
3372 cat >>conftest.adb <<CF_EOF
3373 $2
3374 CF_EOF
3375 if ( "$cf_ada_make" $ADAFLAGS conftest 1>&AC_FD_CC 2>&1 ) ; then
3376    if ( ./conftest 1>&AC_FD_CC 2>&1 ) ; then
3377 ifelse($3,,      :,[      $3])
3378 ifelse($4,,,[   else
3379       $4])
3380    fi
3381 ifelse($4,,,[else
3382    $4])
3383 fi
3384 rm -rf ./conftest* ./*~conftest*
3385 ])dnl
3386 dnl ---------------------------------------------------------------------------
3387 dnl CF_GNAT_VERSION version: 22 updated: 2019/12/31 08:53:54
3388 dnl ---------------
3389 dnl $1 = cache variable to update
3390 dnl $2 = program name
3391 dnl Verify version of GNAT or related tool
3392 AC_DEFUN([CF_GNAT_VERSION],
3393 [
3394 AC_CACHE_CHECK(for ifelse($2,,gnat,$2) version, cf_cv_gnat_version,[
3395 cf_cv_gnat_version=`ifelse($2,,${cf_ada_make:-gnatmake},$2) --version 2>&1 | \
3396         grep '[[0-9]].[[0-9]][[0-9]]*' |\
3397         sed -e '2,$d' -e 's/[[^0-9 \.]]//g' -e 's/^[[ ]]*//' -e 's/ .*//'`
3398 ])
3399 test -z "$cf_cv_gnat_version" && cf_cv_gnat_version=no
3400 ifelse($1,,,[eval $1=$cf_cv_gnat_version; unset cf_cv_gnat_version])
3401 ])dnl
3402 dnl ---------------------------------------------------------------------------
3403 dnl CF_GNU_SOURCE version: 10 updated: 2018/12/10 20:09:41
3404 dnl -------------
3405 dnl Check if we must define _GNU_SOURCE to get a reasonable value for
3406 dnl _XOPEN_SOURCE, upon which many POSIX definitions depend.  This is a defect
3407 dnl (or misfeature) of glibc2, which breaks portability of many applications,
3408 dnl since it is interwoven with GNU extensions.
3409 dnl
3410 dnl Well, yes we could work around it...
3411 dnl
3412 dnl Parameters:
3413 dnl     $1 is the nominal value for _XOPEN_SOURCE
3414 AC_DEFUN([CF_GNU_SOURCE],
3415 [
3416 cf_gnu_xopen_source=ifelse($1,,500,$1)
3417
3418 AC_CACHE_CHECK(if this is the GNU C library,cf_cv_gnu_library,[
3419 AC_TRY_COMPILE([#include <sys/types.h>],[
3420         #if __GLIBC__ > 0 && __GLIBC_MINOR__ >= 0
3421                 return 0;
3422         #elif __NEWLIB__ > 0 && __NEWLIB_MINOR__ >= 0
3423                 return 0;
3424         #else
3425         #       error not GNU C library
3426         #endif],
3427         [cf_cv_gnu_library=yes],
3428         [cf_cv_gnu_library=no])
3429 ])
3430
3431 if test x$cf_cv_gnu_library = xyes; then
3432
3433         # With glibc 2.19 (13 years after this check was begun), _DEFAULT_SOURCE
3434         # was changed to help a little.  newlib incorporated the change about 4
3435         # years later.
3436         AC_CACHE_CHECK(if _DEFAULT_SOURCE can be used as a basis,cf_cv_gnu_library_219,[
3437                 cf_save="$CPPFLAGS"
3438                 CF_APPEND_TEXT(CPPFLAGS,-D_DEFAULT_SOURCE)
3439                 AC_TRY_COMPILE([#include <sys/types.h>],[
3440                         #if (__GLIBC__ == 2 && __GLIBC_MINOR__ >= 19) || (__GLIBC__ > 2)
3441                                 return 0;
3442                         #elif (__NEWLIB__ == 2 && __NEWLIB_MINOR__ >= 4) || (__GLIBC__ > 3)
3443                                 return 0;
3444                         #else
3445                         #       error GNU C library __GLIBC__.__GLIBC_MINOR__ is too old
3446                         #endif],
3447                         [cf_cv_gnu_library_219=yes],
3448                         [cf_cv_gnu_library_219=no])
3449                 CPPFLAGS="$cf_save"
3450         ])
3451
3452         if test "x$cf_cv_gnu_library_219" = xyes; then
3453                 cf_save="$CPPFLAGS"
3454                 AC_CACHE_CHECK(if _XOPEN_SOURCE=$cf_gnu_xopen_source works with _DEFAULT_SOURCE,cf_cv_gnu_dftsrc_219,[
3455                         CF_ADD_CFLAGS(-D_DEFAULT_SOURCE -D_XOPEN_SOURCE=$cf_gnu_xopen_source)
3456                         AC_TRY_COMPILE([
3457                                 #include <limits.h>
3458                                 #include <sys/types.h>
3459                                 ],[
3460                                 #if (_XOPEN_SOURCE >= $cf_gnu_xopen_source) && (MB_LEN_MAX > 1)
3461                                         return 0;
3462                                 #else
3463                                 #       error GNU C library is too old
3464                                 #endif],
3465                                 [cf_cv_gnu_dftsrc_219=yes],
3466                                 [cf_cv_gnu_dftsrc_219=no])
3467                         ])
3468                 test "x$cf_cv_gnu_dftsrc_219" = "xyes" || CPPFLAGS="$cf_save"
3469         else
3470                 cf_cv_gnu_dftsrc_219=maybe
3471         fi
3472
3473         if test "x$cf_cv_gnu_dftsrc_219" != xyes; then
3474
3475                 AC_CACHE_CHECK(if we must define _GNU_SOURCE,cf_cv_gnu_source,[
3476                 AC_TRY_COMPILE([#include <sys/types.h>],[
3477                         #ifndef _XOPEN_SOURCE
3478                         #error  expected _XOPEN_SOURCE to be defined
3479                         #endif],
3480                         [cf_cv_gnu_source=no],
3481                         [cf_save="$CPPFLAGS"
3482                          CF_ADD_CFLAGS(-D_GNU_SOURCE)
3483                          AC_TRY_COMPILE([#include <sys/types.h>],[
3484                                 #ifdef _XOPEN_SOURCE
3485                                 #error  expected _XOPEN_SOURCE to be undefined
3486                                 #endif],
3487                                 [cf_cv_gnu_source=no],
3488                                 [cf_cv_gnu_source=yes])
3489                         CPPFLAGS="$cf_save"
3490                         ])
3491                 ])
3492
3493                 if test "$cf_cv_gnu_source" = yes
3494                 then
3495                 AC_CACHE_CHECK(if we should also define _DEFAULT_SOURCE,cf_cv_default_source,[
3496                         CF_APPEND_TEXT(CPPFLAGS,-D_GNU_SOURCE)
3497                         AC_TRY_COMPILE([#include <sys/types.h>],[
3498                                 #ifdef _DEFAULT_SOURCE
3499                                 #error  expected _DEFAULT_SOURCE to be undefined
3500                                 #endif],
3501                                 [cf_cv_default_source=no],
3502                                 [cf_cv_default_source=yes])
3503                         ])
3504                         if test "$cf_cv_default_source" = yes
3505                         then
3506                                 CF_APPEND_TEXT(CPPFLAGS,-D_DEFAULT_SOURCE)
3507                         fi
3508                 fi
3509         fi
3510
3511 fi
3512 ])dnl
3513 dnl ---------------------------------------------------------------------------
3514 dnl CF_GPP_LIBRARY version: 13 updated: 2021/01/01 13:31:04
3515 dnl --------------
3516 dnl If we're trying to use g++, test if libg++ is installed (a rather common
3517 dnl problem :-).  If we have the compiler but no library, we'll be able to
3518 dnl configure, but won't be able to build the c++ demo program.
3519 AC_DEFUN([CF_GPP_LIBRARY],
3520 [
3521 cf_cxx_library=unknown
3522 case "$cf_cv_system_name" in
3523 (os2*)
3524         cf_gpp_libname=gpp
3525         ;;
3526 (*)
3527         cf_gpp_libname=g++
3528         ;;
3529 esac
3530 if test "$GXX" = yes; then
3531         AC_MSG_CHECKING([for lib$cf_gpp_libname])
3532         cf_save="$LIBS"
3533         CF_ADD_LIB($cf_gpp_libname)
3534         AC_TRY_LINK([
3535 #include <$cf_gpp_libname/builtin.h>
3536         ],
3537         [two_arg_error_handler_t foo2 = lib_error_handler],
3538         [cf_cxx_library=yes
3539          CF_ADD_LIB($cf_gpp_libname,CXXLIBS)
3540          if test "$cf_gpp_libname" = cpp ; then
3541             AC_DEFINE(HAVE_GPP_BUILTIN_H,1,[Define to 1 if we have gpp builtin.h])
3542          else
3543             AC_DEFINE(HAVE_GXX_BUILTIN_H,1,[Define to 1 if we have g++ builtin.h])
3544          fi],
3545         [AC_TRY_LINK([
3546 #include <builtin.h>
3547         ],
3548         [two_arg_error_handler_t foo2 = lib_error_handler],
3549         [cf_cxx_library=yes
3550          CF_ADD_LIB($cf_gpp_libname,CXXLIBS)
3551          AC_DEFINE(HAVE_BUILTIN_H,1,[Define to 1 if we have builtin.h])],
3552         [cf_cxx_library=no])])
3553         LIBS="$cf_save"
3554         AC_MSG_RESULT($cf_cxx_library)
3555 fi
3556 ])dnl
3557 dnl ---------------------------------------------------------------------------
3558 dnl CF_GXX_VERSION version: 8 updated: 2017/02/11 14:48:57
3559 dnl --------------
3560 dnl Check for version of g++
3561 AC_DEFUN([CF_GXX_VERSION],[
3562 AC_REQUIRE([AC_PROG_CPP])
3563 GXX_VERSION=none
3564 if test "$GXX" = yes; then
3565         AC_MSG_CHECKING(version of ${CXX:-g++})
3566         GXX_VERSION="`${CXX:-g++} --version| sed -e '2,$d' -e 's/^.*(GCC) //' -e 's/^[[^0-9.]]*//' -e 's/[[^0-9.]].*//'`"
3567         if test -z "$GXX_VERSION"
3568         then
3569                 GXX_VERSION=unknown
3570                 GXX=no
3571         fi
3572         AC_MSG_RESULT($GXX_VERSION)
3573 fi
3574 ])dnl
3575 dnl ---------------------------------------------------------------------------
3576 dnl CF_GXX_WARNINGS version: 11 updated: 2021/01/08 16:50:55
3577 dnl ---------------
3578 dnl Check if the compiler supports useful warning options.
3579 dnl
3580 dnl Most of gcc's options apply to g++, except:
3581 dnl     -Wbad-function-cast
3582 dnl     -Wmissing-declarations
3583 dnl     -Wnested-externs
3584 dnl
3585 dnl Omit a few (for now):
3586 dnl     -Winline
3587 dnl
3588 dnl Parameter:
3589 dnl     $1 is an optional list of g++ warning flags that a particular
3590 dnl             application might want to use, e.g., "no-unused" for
3591 dnl             -Wno-unused
3592 dnl Special:
3593 dnl     If $with_ext_const is "yes", add a check for -Wwrite-strings
3594 dnl
3595 AC_DEFUN([CF_GXX_WARNINGS],
3596 [
3597
3598 CF_INTEL_COMPILER(GXX,INTEL_CPLUSPLUS,CXXFLAGS)
3599 CF_CLANG_COMPILER(GXX,CLANG_CPLUSPLUS,CXXFLAGS)
3600
3601 AC_REQUIRE([CF_GXX_VERSION])
3602
3603 AC_LANG_SAVE
3604 AC_LANG_CPLUSPLUS
3605
3606 cat > conftest.$ac_ext <<EOF
3607 #line __oline__ "configure"
3608 int main(int argc, char *argv[[]]) { return (argv[[argc-1]] == 0) ; }
3609 EOF
3610
3611 if test "$INTEL_CPLUSPLUS" = yes
3612 then
3613 # The "-wdXXX" options suppress warnings:
3614 # remark #1419: external declaration in primary source file
3615 # remark #1682: implicit conversion of a 64-bit integral type to a smaller integral type (potential portability problem)
3616 # remark #1683: explicit conversion of a 64-bit integral type to a smaller integral type (potential portability problem)
3617 # remark #1684: conversion from pointer to same-sized integral type (potential portability problem)
3618 # remark #193: zero used for undefined preprocessing identifier
3619 # remark #593: variable "curs_sb_left_arrow" was set but never used
3620 # remark #810: conversion from "int" to "Dimension={unsigned short}" may lose significant bits
3621 # remark #869: parameter "tw" was never referenced
3622 # remark #981: operands are evaluated in unspecified order
3623 # warning #269: invalid format string conversion
3624
3625         AC_CHECKING([for $CC warning options])
3626         cf_save_CXXFLAGS="$CXXFLAGS"
3627         EXTRA_CXXFLAGS="-Wall"
3628         for cf_opt in \
3629                 wd1419 \
3630                 wd1682 \
3631                 wd1683 \
3632                 wd1684 \
3633                 wd193 \
3634                 wd279 \
3635                 wd593 \
3636                 wd810 \
3637                 wd869 \
3638                 wd981
3639         do
3640                 CXXFLAGS="$cf_save_CXXFLAGS $EXTRA_CXXFLAGS -$cf_opt"
3641                 if AC_TRY_EVAL(ac_compile); then
3642                         test -n "$verbose" && AC_MSG_RESULT(... -$cf_opt)
3643                         EXTRA_CXXFLAGS="$EXTRA_CXXFLAGS -$cf_opt"
3644                 fi
3645         done
3646         CXXFLAGS="$cf_save_CXXFLAGS"
3647
3648 elif test "$GXX" = yes
3649 then
3650         AC_CHECKING([for $CXX warning options])
3651         cf_save_CXXFLAGS="$CXXFLAGS"
3652         EXTRA_CXXFLAGS="-W -Wall"
3653         cf_gxx_extra_warnings=""
3654         test "$with_ext_const" = yes && cf_gxx_extra_warnings="Wwrite-strings"
3655         case "$GXX_VERSION" in
3656         ([[1-2]].*)
3657                 ;;
3658         (*)
3659                 cf_gxx_extra_warnings="$cf_gxx_extra_warnings Weffc++"
3660                 ;;
3661         esac
3662         for cf_opt in \
3663                 Wabi \
3664                 fabi-version=0 \
3665                 Wextra \
3666                 Wignored-qualifiers \
3667                 Wlogical-op \
3668                 Woverloaded-virtual \
3669                 Wsign-promo \
3670                 Wsynth \
3671                 Wold-style-cast \
3672                 Wcast-align \
3673                 Wcast-qual \
3674                 Wpointer-arith \
3675                 Wshadow \
3676                 Wundef $cf_gxx_extra_warnings $1
3677         do
3678                 CXXFLAGS="$cf_save_CXXFLAGS $EXTRA_CXXFLAGS -Werror -$cf_opt"
3679                 if AC_TRY_EVAL(ac_compile); then
3680                         test -n "$verbose" && AC_MSG_RESULT(... -$cf_opt)
3681                         EXTRA_CXXFLAGS="$EXTRA_CXXFLAGS -$cf_opt"
3682                 else
3683                         test -n "$verbose" && AC_MSG_RESULT(... no -$cf_opt)
3684                 fi
3685         done
3686         CXXFLAGS="$cf_save_CXXFLAGS"
3687 fi
3688
3689 rm -rf ./conftest*
3690 AC_LANG_RESTORE
3691 AC_SUBST(EXTRA_CXXFLAGS)
3692 ])dnl
3693 dnl ---------------------------------------------------------------------------
3694 dnl CF_HASHED_DB version: 7 updated: 2015/04/18 08:56:57
3695 dnl ------------
3696 dnl Look for an instance of the Berkeley hashed database.
3697 dnl
3698 dnl $1 = optional parameter, to specify install-prefix for the database.
3699 AC_DEFUN([CF_HASHED_DB],
3700 [
3701 ifelse([$1],,,[
3702 case $1 in
3703 (yes|*able*)
3704         ;;
3705 (*)
3706         if test -d "$1" ; then
3707                 CF_ADD_INCDIR($1/include)
3708                 CF_ADD_LIBDIR($1/lib)
3709         else
3710                 case "$1" in
3711                 (./*|../*|/*)
3712                         AC_MSG_WARN(no such directory $1)
3713                         ;;
3714                 (*)
3715                         CF_FIND_SUB_INCDIR($1)
3716                         CF_FIND_SUB_LIBDIR($1)
3717                         ;;
3718                 esac
3719         fi
3720 esac
3721 ])
3722 AC_CHECK_HEADER(db.h,[
3723 CF_HASHED_DB_VERSION
3724 if test "$cf_cv_hashed_db_version" = unknown ; then
3725         AC_MSG_ERROR(Cannot determine version of db)
3726 else
3727         CF_HASHED_DB_LIBS
3728         if test "$cf_cv_hashed_db_libs" = unknown ; then
3729                 AC_MSG_ERROR(Cannot determine library for db)
3730         elif test "$cf_cv_hashed_db_libs" != default ; then
3731                 CF_ADD_LIB($cf_cv_hashed_db_libs)
3732         fi
3733 fi
3734 ],[
3735         AC_MSG_ERROR(Cannot find db.h)
3736 ])
3737 ])dnl
3738 dnl ---------------------------------------------------------------------------
3739 dnl CF_HASHED_DB_LIBS version: 10 updated: 2021/01/02 17:09:14
3740 dnl -----------------
3741 dnl Given that we have the header and version for hashed database, find the
3742 dnl library information.
3743 AC_DEFUN([CF_HASHED_DB_LIBS],
3744 [
3745 AC_CACHE_CHECK(for db libraries, cf_cv_hashed_db_libs,[
3746 cf_cv_hashed_db_libs=unknown
3747 for cf_db_libs in "" db$cf_cv_hashed_db_version db-$cf_cv_hashed_db_version db ''
3748 do
3749         cf_save_libs="$LIBS"
3750         if test -n "$cf_db_libs"; then
3751                 CF_ADD_LIB($cf_db_libs)
3752         fi
3753         CF_MSG_LOG(checking for library $cf_db_libs)
3754         AC_TRY_LINK([
3755 $ac_includes_default
3756 #include <db.h>
3757 ],[
3758         char *path = "/tmp/foo";
3759 #ifdef DB_VERSION_MAJOR
3760 #if DB_VERSION_MAJOR >= 4
3761         DB *result = 0;
3762         db_create(&result, NULL, 0);
3763         result->open(result,
3764                 NULL,
3765                 path,
3766                 path,
3767                 DB_HASH,
3768                 DB_CREATE,
3769                 0644);
3770 #elif DB_VERSION_MAJOR >= 3
3771         DB *result = 0;
3772         db_create(&result, NULL, 0);
3773         result->open(result,
3774                 path,
3775                 path,
3776                 DB_HASH,
3777                 DB_CREATE,
3778                 0644);
3779 #elif DB_VERSION_MAJOR >= 2
3780         DB *result = 0;
3781         db_open(path,
3782                 DB_HASH,
3783                 DB_CREATE,
3784                 0644,
3785                 (DB_ENV *) 0,
3786                 (DB_INFO *) 0,
3787                 &result);
3788 #endif /* DB_VERSION_MAJOR */
3789 #else
3790         DB *result = dbopen(path,
3791                      2,
3792                      0644,
3793                      DB_HASH,
3794                      0);
3795 #endif
3796         ${cf_cv_main_return:-return}(result != 0)
3797 ],[
3798         if test -n "$cf_db_libs" ; then
3799                 cf_cv_hashed_db_libs=$cf_db_libs
3800         else
3801                 cf_cv_hashed_db_libs=default
3802         fi
3803         LIBS="$cf_save_libs"
3804         break
3805 ])
3806         LIBS="$cf_save_libs"
3807 done
3808 ])
3809 ])dnl
3810 dnl ---------------------------------------------------------------------------
3811 dnl CF_HASHED_DB_VERSION version: 4 updated: 2014/04/12 16:47:01
3812 dnl --------------------
3813 dnl Given that we have the header file for hashed database, find the version
3814 dnl information.
3815 AC_DEFUN([CF_HASHED_DB_VERSION],
3816 [
3817 AC_CACHE_CHECK(for version of db, cf_cv_hashed_db_version,[
3818 cf_cv_hashed_db_version=unknown
3819
3820 for cf_db_version in 1 2 3 4 5 6
3821 do
3822         CF_MSG_LOG(checking for db version $cf_db_version)
3823         AC_TRY_COMPILE([
3824 $ac_includes_default
3825 #include <db.h>
3826
3827 #ifdef DB_VERSION_MAJOR
3828         /* db2 (DB_VERSION_MAJOR=2) has also DB_VERSION_MINOR, tested with 7 */
3829 #if $cf_db_version == DB_VERSION_MAJOR
3830         /* ok */
3831 #else
3832         make an error
3833 #endif
3834 #else
3835 #if $cf_db_version == 1
3836         /* ok: assuming this is DB 1.8.5 */
3837 #else
3838         make an error
3839 #endif
3840 #endif
3841 ],[DBT *foo = 0],[
3842         cf_cv_hashed_db_version=$cf_db_version
3843         break
3844         ])
3845 done
3846 ])
3847 ])dnl
3848 dnl ---------------------------------------------------------------------------
3849 dnl CF_HEADER_PATH version: 15 updated: 2021/01/01 13:31:04
3850 dnl --------------
3851 dnl Construct a search-list of directories for a nonstandard header-file
3852 dnl
3853 dnl Parameters
3854 dnl     $1 = the variable to return as result
3855 dnl     $2 = the package name
3856 AC_DEFUN([CF_HEADER_PATH],
3857 [
3858 $1=
3859
3860 # collect the current set of include-directories from compiler flags
3861 cf_header_path_list=""
3862 if test -n "${CFLAGS}${CPPFLAGS}" ; then
3863         for cf_header_path in $CPPFLAGS $CFLAGS
3864         do
3865                 case "$cf_header_path" in
3866                 (-I*)
3867                         cf_header_path=`echo ".$cf_header_path" |sed -e 's/^...//' -e 's,/include$,,'`
3868                         CF_ADD_SUBDIR_PATH($1,$2,include,$cf_header_path,NONE)
3869                         cf_header_path_list="$cf_header_path_list [$]$1"
3870                         ;;
3871                 esac
3872         done
3873 fi
3874
3875 # add the variations for the package we are looking for
3876 CF_SUBDIR_PATH($1,$2,include)
3877
3878 test "$includedir" != NONE && \
3879 test "$includedir" != "/usr/include" && \
3880 test -d "$includedir" && {
3881         test -d "$includedir" &&    $1="[$]$1 $includedir"
3882         test -d "$includedir/$2" && $1="[$]$1 $includedir/$2"
3883 }
3884
3885 test "$oldincludedir" != NONE && \
3886 test "$oldincludedir" != "/usr/include" && \
3887 test -d "$oldincludedir" && {
3888         test -d "$oldincludedir"    && $1="[$]$1 $oldincludedir"
3889         test -d "$oldincludedir/$2" && $1="[$]$1 $oldincludedir/$2"
3890 }
3891
3892 $1="[$]$1 $cf_header_path_list"
3893 ])dnl
3894 dnl ---------------------------------------------------------------------------
3895 dnl CF_HELP_MESSAGE version: 4 updated: 2019/12/31 08:53:54
3896 dnl ---------------
3897 dnl Insert text into the help-message, for readability, from AC_ARG_WITH.
3898 AC_DEFUN([CF_HELP_MESSAGE],
3899 [CF_ACVERSION_CHECK(2.53,[],[
3900 AC_DIVERT_HELP($1)])dnl
3901 ])dnl
3902 dnl ---------------------------------------------------------------------------
3903 dnl CF_INCLUDE_DIRS version: 10 updated: 2014/09/19 20:58:42
3904 dnl ---------------
3905 dnl Construct the list of include-options according to whether we're building
3906 dnl in the source directory or using '--srcdir=DIR' option.
3907 AC_DEFUN([CF_INCLUDE_DIRS],
3908 [
3909 if test "$srcdir" != "."; then
3910         CPPFLAGS="-I\${srcdir}/../include $CPPFLAGS"
3911 fi
3912 CPPFLAGS="-I../include $CPPFLAGS"
3913 if test "$srcdir" != "."; then
3914         CPPFLAGS="-I\${srcdir} $CPPFLAGS"
3915 fi
3916 CPPFLAGS="-I. $CPPFLAGS"
3917 AC_SUBST(CPPFLAGS)
3918 ])dnl
3919 dnl ---------------------------------------------------------------------------
3920 dnl CF_INSTALL_OPTS version: 2 updated: 2018/08/18 12:19:21
3921 dnl ---------------
3922 dnl prompt for/fill-in useful install-program options
3923 AC_DEFUN([CF_INSTALL_OPTS],
3924 [
3925 CF_INSTALL_OPT_S
3926 CF_INSTALL_OPT_P
3927 CF_INSTALL_OPT_O
3928 ])dnl
3929 dnl ---------------------------------------------------------------------------
3930 dnl CF_INSTALL_OPT_O version: 3 updated: 2020/12/31 20:19:42
3931 dnl ----------------
3932 dnl Almost all "install" programs default to the current user's ownership.
3933 dnl Almost - MINIX is an exception.
3934 AC_DEFUN([CF_INSTALL_OPT_O],
3935 [
3936 AC_MSG_CHECKING(if install needs to be told about ownership)
3937 case `$ac_config_guess` in
3938 (*minix)
3939         with_install_o=yes
3940         ;;
3941 (*)
3942         with_install_o=no
3943         ;;
3944 esac
3945
3946 AC_MSG_RESULT($with_install_o)
3947 if test "x$with_install_o" = xyes
3948 then
3949         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'`"
3950 else
3951         INSTALL_OPT_O=
3952 fi
3953
3954 AC_SUBST(INSTALL_OPT_O)
3955 ])dnl
3956 dnl ---------------------------------------------------------------------------
3957 dnl CF_INSTALL_OPT_P version: 3 updated: 2021/01/01 13:31:04
3958 dnl ----------------
3959 dnl Some install-programs accept a "-p" option to preserve file modification
3960 dnl timestamps.  That can be useful as an install option, as well as a way to
3961 dnl avoid the need for ranlib after copying a static archive.
3962 AC_DEFUN([CF_INSTALL_OPT_P],
3963 [
3964 : "${INSTALL:=install}"
3965 AC_CACHE_CHECK(if install accepts -p option, cf_cv_install_p,[
3966         rm -rf ./conftest*
3967         date >conftest.in
3968         mkdir conftest.out
3969         sleep 3
3970         if $INSTALL -p conftest.in conftest.out 2>/dev/null
3971         then
3972                 if test -f conftest.out/conftest.in
3973                 then
3974                         test conftest.in -nt conftest.out/conftest.in 2>conftest.err && \
3975                         test conftest.out/conftest.in -nt conftest.in 2>conftest.err
3976                         if test -s conftest.err
3977                         then
3978                                 cf_cv_install_p=no
3979                         else
3980                                 cf_cv_install_p=yes
3981                         fi
3982                 else
3983                         cf_cv_install_p=no
3984                 fi
3985         else
3986                 cf_cv_install_p=no
3987         fi
3988         rm -rf ./conftest*
3989 ])
3990 ])dnl
3991 dnl ---------------------------------------------------------------------------
3992 dnl CF_INSTALL_OPT_S version: 3 updated: 2021/01/05 19:23:48
3993 dnl ----------------
3994 dnl By default, we should strip executables which are installed, but leave the
3995 dnl ability to suppress that for unit-testing.
3996 AC_DEFUN([CF_INSTALL_OPT_S],
3997 [
3998 AC_MSG_CHECKING(if you want to install stripped executables)
3999 CF_ARG_DISABLE(stripping,
4000         [  --disable-stripping     do not strip (debug info) installed executables],
4001         [enable_stripping=no],
4002         [enable_stripping=yes])
4003 AC_MSG_RESULT($enable_stripping)
4004
4005 if test "$enable_stripping" = yes
4006 then
4007         INSTALL_OPT_S="-s"
4008 else
4009         INSTALL_OPT_S=
4010 fi
4011 AC_SUBST(INSTALL_OPT_S)
4012 ])dnl
4013 dnl ---------------------------------------------------------------------------
4014 dnl CF_INTEL_COMPILER version: 8 updated: 2021/01/01 16:53:59
4015 dnl -----------------
4016 dnl Check if the given compiler is really the Intel compiler for Linux.  It
4017 dnl tries to imitate gcc, but does not return an error when it finds a mismatch
4018 dnl between prototypes, e.g., as exercised by CF_MISSING_CHECK.
4019 dnl
4020 dnl This macro should be run "soon" after AC_PROG_CC or AC_PROG_CPLUSPLUS, to
4021 dnl ensure that it is not mistaken for gcc/g++.  It is normally invoked from
4022 dnl the wrappers for gcc and g++ warnings.
4023 dnl
4024 dnl $1 = GCC (default) or GXX
4025 dnl $2 = INTEL_COMPILER (default) or INTEL_CPLUSPLUS
4026 dnl $3 = CFLAGS (default) or CXXFLAGS
4027 AC_DEFUN([CF_INTEL_COMPILER],[
4028 AC_REQUIRE([AC_CANONICAL_HOST])
4029 ifelse([$2],,INTEL_COMPILER,[$2])=no
4030
4031 if test "$ifelse([$1],,[$1],GCC)" = yes ; then
4032         case "$host_os" in
4033         (linux*|gnu*)
4034                 AC_MSG_CHECKING(if this is really Intel ifelse([$1],GXX,C++,C) compiler)
4035                 cf_save_CFLAGS="$ifelse([$3],,CFLAGS,[$3])"
4036                 ifelse([$3],,CFLAGS,[$3])="$ifelse([$3],,CFLAGS,[$3]) -no-gcc"
4037                 AC_TRY_COMPILE([],[
4038 #ifdef __INTEL_COMPILER
4039 #else
4040 make an error
4041 #endif
4042 ],[ifelse([$2],,INTEL_COMPILER,[$2])=yes
4043 cf_save_CFLAGS="$cf_save_CFLAGS -we147"
4044 ],[])
4045                 ifelse([$3],,CFLAGS,[$3])="$cf_save_CFLAGS"
4046                 AC_MSG_RESULT($ifelse([$2],,INTEL_COMPILER,[$2]))
4047                 ;;
4048         esac
4049 fi
4050 ])dnl
4051 dnl ---------------------------------------------------------------------------
4052 dnl CF_ISASCII version: 4 updated: 2012/10/06 17:56:13
4053 dnl ----------
4054 dnl Check if we have either a function or macro for 'isascii()'.
4055 AC_DEFUN([CF_ISASCII],
4056 [
4057 AC_MSG_CHECKING(for isascii)
4058 AC_CACHE_VAL(cf_cv_have_isascii,[
4059         AC_TRY_LINK([#include <ctype.h>],[int x = isascii(' ')],
4060         [cf_cv_have_isascii=yes],
4061         [cf_cv_have_isascii=no])
4062 ])dnl
4063 AC_MSG_RESULT($cf_cv_have_isascii)
4064 test "$cf_cv_have_isascii" = yes && AC_DEFINE(HAVE_ISASCII,1,[Define to 1 if we have isascii()])
4065 ])dnl
4066 dnl ---------------------------------------------------------------------------
4067 dnl CF_LARGEFILE version: 12 updated: 2020/03/19 20:23:48
4068 dnl ------------
4069 dnl Add checks for large file support.
4070 AC_DEFUN([CF_LARGEFILE],[
4071 ifdef([AC_FUNC_FSEEKO],[
4072         AC_SYS_LARGEFILE
4073         if test "$enable_largefile" != no ; then
4074         AC_FUNC_FSEEKO
4075
4076         # Normally we would collect these definitions in the config.h,
4077         # but (like _XOPEN_SOURCE), some environments rely on having these
4078         # defined before any of the system headers are included.  Another
4079         # case comes up with C++, e.g., on AIX the compiler compiles the
4080         # header files by themselves before looking at the body files it is
4081         # told to compile.  For ncurses, those header files do not include
4082         # the config.h
4083         if test "$ac_cv_sys_large_files" != no
4084         then
4085                 CF_APPEND_TEXT(CPPFLAGS,-D_LARGE_FILES)
4086         fi
4087         if test "$ac_cv_sys_largefile_source" != no
4088         then
4089                 CF_APPEND_TEXT(CPPFLAGS,-D_LARGEFILE_SOURCE)
4090         fi
4091         if test "$ac_cv_sys_file_offset_bits" != no
4092         then
4093                 CF_APPEND_TEXT(CPPFLAGS,-D_FILE_OFFSET_BITS=$ac_cv_sys_file_offset_bits)
4094         fi
4095
4096         AC_CACHE_CHECK(whether to use struct dirent64, cf_cv_struct_dirent64,[
4097                 AC_TRY_COMPILE([
4098 #pragma GCC diagnostic error "-Wincompatible-pointer-types"
4099 #include <sys/types.h>
4100 #include <dirent.h>
4101                 ],[
4102                 /* if transitional largefile support is setup, this is true */
4103                 extern struct dirent64 * readdir(DIR *);
4104                 struct dirent64 *x = readdir((DIR *)0);
4105                 struct dirent *y = readdir((DIR *)0);
4106                 int z = x - y;
4107                 (void)z;
4108                 ],
4109                 [cf_cv_struct_dirent64=yes],
4110                 [cf_cv_struct_dirent64=no])
4111         ])
4112         test "$cf_cv_struct_dirent64" = yes && AC_DEFINE(HAVE_STRUCT_DIRENT64,1,[Define to 1 if we have struct dirent64])
4113         fi
4114 ])
4115 ])
4116 dnl ---------------------------------------------------------------------------
4117 dnl CF_LDFLAGS_STATIC version: 14 updated: 2021/01/02 17:09:14
4118 dnl -----------------
4119 dnl Check for compiler/linker flags used to temporarily force usage of static
4120 dnl libraries.  This depends on the compiler and platform.  Use this to help
4121 dnl ensure that the linker picks up a given library based on its position in
4122 dnl the list of linker options and libraries.
4123 AC_DEFUN([CF_LDFLAGS_STATIC],[
4124
4125 if test "$GCC" = yes ; then
4126         case "$cf_cv_system_name" in
4127         (OS/2*|os2*|aix[[4]]*|solaris2.1[[0-9]]|darwin*)
4128                 LDFLAGS_STATIC=
4129                 LDFLAGS_SHARED=
4130                 ;;
4131         (*)     # normally, except when broken
4132                 LDFLAGS_STATIC=-static
4133                 LDFLAGS_SHARED=-dynamic
4134                 ;;
4135         esac
4136 else
4137         case "$cf_cv_system_name" in
4138         (aix[[4-7]]*)   # from ld manpage
4139                 LDFLAGS_STATIC=-bstatic
4140                 LDFLAGS_SHARED=-bdynamic
4141                 ;;
4142         (hpux*)         # from ld manpage for hpux10.20, hpux11.11
4143                 # We could also use just "archive" and "shared".
4144                 LDFLAGS_STATIC=-Wl,-a,archive_shared
4145                 LDFLAGS_SHARED=-Wl,-a,shared_archive
4146                 ;;
4147         (irix*)         # from ld manpage IRIX64
4148                 LDFLAGS_STATIC=-Bstatic
4149                 LDFLAGS_SHARED=-Bdynamic
4150                 ;;
4151         (osf[[45]]*)    # from ld manpage osf4.0d, osf5.1
4152                 # alternative "-oldstyle_liblookup" (not in cc manpage)
4153                 LDFLAGS_STATIC=-noso
4154                 LDFLAGS_SHARED=-so_archive
4155                 ;;
4156         (solaris2*)
4157                 LDFLAGS_STATIC=-Bstatic
4158                 LDFLAGS_SHARED=-Bdynamic
4159                 ;;
4160         esac
4161 fi
4162
4163 if test -n "$LDFLAGS_STATIC" && test -n "$LDFLAGS_SHARED"
4164 then
4165         AC_MSG_CHECKING(if linker supports switching between static/dynamic)
4166
4167         rm -f libconftest.a
4168         cat >conftest.$ac_ext <<EOF
4169 #line __oline__ "configure"
4170 #include <stdio.h>
4171 int cf_ldflags_static(FILE *fp) { return fflush(fp); }
4172 EOF
4173         if AC_TRY_EVAL(ac_compile) ; then
4174                 ( $AR $ARFLAGS libconftest.a conftest.o ) 2>&AC_FD_CC 1>/dev/null
4175                 ( eval $RANLIB libconftest.a ) 2>&AC_FD_CC >/dev/null
4176         fi
4177         rm -f conftest.*
4178
4179         cf_save_LIBS="$LIBS"
4180
4181         LIBS="$LDFLAGS_STATIC -L`pwd` -lconftest $LDFLAGS_DYNAMIC $LIBS"
4182         AC_TRY_LINK([
4183 #line __oline__ "configure"
4184 #include <stdio.h>
4185 int cf_ldflags_static(FILE *fp);
4186 ],[
4187         return cf_ldflags_static(stdin);
4188 ],[
4189         # some linkers simply ignore the -dynamic
4190         case x`file "conftest$ac_exeext" 2>/dev/null` in
4191         (*static*)
4192                 cf_ldflags_static=no
4193                 ;;
4194         (*)
4195                 cf_ldflags_static=yes
4196                 ;;
4197         esac
4198 ],[cf_ldflags_static=no])
4199
4200         rm -f libconftest.*
4201         LIBS="$cf_save_LIBS"
4202
4203         AC_MSG_RESULT($cf_ldflags_static)
4204
4205         if test "$cf_ldflags_static" != yes
4206         then
4207                 LDFLAGS_STATIC=
4208                 LDFLAGS_SHARED=
4209         fi
4210 else
4211         LDFLAGS_STATIC=
4212         LDFLAGS_SHARED=
4213 fi
4214
4215 AC_SUBST(LDFLAGS_STATIC)
4216 AC_SUBST(LDFLAGS_SHARED)
4217 ])
4218 dnl ---------------------------------------------------------------------------
4219 dnl CF_LD_RPATH_OPT version: 9 updated: 2021/01/01 13:31:04
4220 dnl ---------------
4221 dnl For the given system and compiler, find the compiler flags to pass to the
4222 dnl loader to use the "rpath" feature.
4223 AC_DEFUN([CF_LD_RPATH_OPT],
4224 [
4225 AC_REQUIRE([CF_CHECK_CACHE])
4226
4227 LD_RPATH_OPT=
4228 if test "x$cf_cv_enable_rpath" != xno
4229 then
4230         AC_MSG_CHECKING(for an rpath option)
4231         case "$cf_cv_system_name" in
4232         (irix*)
4233                 if test "$GCC" = yes; then
4234                         LD_RPATH_OPT="-Wl,-rpath,"
4235                 else
4236                         LD_RPATH_OPT="-rpath "
4237                 fi
4238                 ;;
4239         (linux*|gnu*|k*bsd*-gnu|freebsd*)
4240                 LD_RPATH_OPT="-Wl,-rpath,"
4241                 ;;
4242         (openbsd[[2-9]].*|mirbsd*)
4243                 LD_RPATH_OPT="-Wl,-rpath,"
4244                 ;;
4245         (dragonfly*)
4246                 LD_RPATH_OPT="-rpath "
4247                 ;;
4248         (netbsd*)
4249                 LD_RPATH_OPT="-Wl,-rpath,"
4250                 ;;
4251         (osf*|mls+*)
4252                 LD_RPATH_OPT="-rpath "
4253                 ;;
4254         (solaris2*)
4255                 LD_RPATH_OPT="-R"
4256                 ;;
4257         (*)
4258                 ;;
4259         esac
4260         AC_MSG_RESULT($LD_RPATH_OPT)
4261
4262         case "x$LD_RPATH_OPT" in
4263         (x-R*)
4264                 AC_MSG_CHECKING(if we need a space after rpath option)
4265                 cf_save_LIBS="$LIBS"
4266                 CF_ADD_LIBS(${LD_RPATH_OPT}$libdir)
4267                 AC_TRY_LINK(, , cf_rpath_space=no, cf_rpath_space=yes)
4268                 LIBS="$cf_save_LIBS"
4269                 AC_MSG_RESULT($cf_rpath_space)
4270                 test "$cf_rpath_space" = yes && LD_RPATH_OPT="$LD_RPATH_OPT "
4271                 ;;
4272         esac
4273 fi
4274 ])dnl
4275 dnl ---------------------------------------------------------------------------
4276 dnl CF_LD_SEARCHPATH version: 3 updated: 2021/03/05 19:13:35
4277 dnl ----------------
4278 dnl Try to obtain the linker's search-path, for use in scripts.
4279 dnl
4280 dnl Ignore LD_LIBRARY_PATH, etc.
4281 AC_DEFUN([CF_LD_SEARCHPATH],[
4282 AC_CACHE_CHECK(for linker search path,cf_cv_ld_searchpath,[
4283
4284 if test "$cross_compiling" != yes ; then
4285
4286 # GNU binutils' ld does not involve permissions which may stop ldconfig.
4287 cf_pathlist=`ld --verbose 2>/dev/null | grep SEARCH_DIR | sed -e 's,SEARCH_DIR[[("=]][[("=]]*,,g' -e 's/"[[)]];//gp' | sort -u`
4288
4289 # The -NX options tell newer versions of Linux ldconfig to not attempt to
4290 # update the cache, which makes it run faster.
4291 test -z "$cf_pathlist" && \
4292         cf_pathlist=`(ldconfig -NX -v) 2>/dev/null | sed -e '/^[[       ]]/d' -e 's/:$//' | sort -u`
4293
4294 test -z "$cf_pathlist" &&
4295         cf_pathlist=`(ldconfig -v) 2>/dev/null | sed -n -e '/^[[        ]]/d' -e 's/:$//p' | sort -u`
4296
4297 # This works with OpenBSD 6.5, which lists only filenames
4298 test -z "$cf_pathlist" &&
4299         cf_pathlist=`(ldconfig -v) 2>/dev/null | sed -n -e 's,^Adding \(.*\)/.*[$],\1,p' | sort -u`
4300
4301 if test -z "$cf_pathlist"
4302 then
4303         # dyld default path with MacOS
4304         if test -f /usr/bin/otool && test "x`uname -s`" = xDarwin
4305         then
4306                 # do this to bypass check
4307                 cf_cv_ld_searchpath='$HOME/lib'
4308                 cf_pathlist="/usr/local/lib /lib /usr/lib"
4309         fi
4310 fi
4311
4312 if test -z "$cf_pathlist"
4313 then
4314         # Solaris is "SunOS"
4315         if test -f /usr/bin/isainfo && test "x`uname -s`" = xSunOS
4316         then
4317                 case x`(isainfo -b)` in
4318                 (x64)
4319                         cf_pathlist="$cf_pathlist /lib/64 /usr/lib/64"
4320                         ;;
4321                 (x32)
4322                         test -d /usr/ccs/lib && cf_pathlist="$cf_pathlist /usr/ccs/lib"
4323                         cf_pathlist="$cf_pathlist /lib /usr/lib"
4324                         ;;
4325                 (*)
4326                         AC_MSG_WARN(problem with Solaris architecture)
4327                         ;;
4328                 esac
4329         fi
4330 fi
4331
4332 if test -z "$cf_pathlist"
4333 then
4334         # HP-UX
4335         if test x"`uname -s`" = xHP-UX
4336         then
4337                 case x`getconf LONG_BIT` in
4338                 (x64)
4339                         cf_pathlist="/usr/lib/hpux64"
4340                         ;;
4341                 (x*)
4342                         cf_pathlist="/usr/lib/hpux32"
4343                         ;;
4344                 esac
4345         fi
4346 fi
4347
4348 fi
4349
4350 # If nothing else, assume it is conventional
4351 test -z "$cf_pathlist" && cf_pathlist="/usr/lib /lib"
4352
4353 # Finally, check that this is only directories
4354 for cf_path in [$]0 $cf_pathlist
4355 do
4356         if test -d "$cf_path"; then
4357                 test -n "$cf_cv_ld_searchpath" && cf_cv_ld_searchpath="${cf_cv_ld_searchpath} "
4358                 cf_cv_ld_searchpath="${cf_cv_ld_searchpath}${cf_path}"
4359         fi
4360 done
4361
4362 # Ensure that it is nonempty
4363 test -z "$cf_cv_ld_searchpath" && cf_cv_ld_searchpath=/usr/lib
4364 ])
4365
4366 LD_SEARCHPATH=`echo "$cf_cv_ld_searchpath"|sed -e 's/ /|/g'`
4367 AC_SUBST(LD_SEARCHPATH)
4368 ])dnl
4369 dnl ---------------------------------------------------------------------------
4370 dnl CF_LIBRARY_PATH version: 11 updated: 2021/01/01 13:31:04
4371 dnl ---------------
4372 dnl Construct a search-list of directories for a nonstandard library-file
4373 dnl
4374 dnl Parameters
4375 dnl     $1 = the variable to return as result
4376 dnl     $2 = the package name
4377 AC_DEFUN([CF_LIBRARY_PATH],
4378 [
4379 $1=
4380 cf_library_path_list=""
4381 if test -n "${LDFLAGS}${LIBS}" ; then
4382         for cf_library_path in $LDFLAGS $LIBS
4383         do
4384                 case "$cf_library_path" in
4385                 (-L*)
4386                         cf_library_path=`echo ".$cf_library_path" |sed -e 's/^...//' -e 's,/lib$,,'`
4387                         CF_ADD_SUBDIR_PATH($1,$2,lib,$cf_library_path,NONE)
4388                         cf_library_path_list="$cf_library_path_list [$]$1"
4389                         ;;
4390                 esac
4391         done
4392 fi
4393
4394 CF_SUBDIR_PATH($1,$2,lib)
4395
4396 $1="$cf_library_path_list [$]$1"
4397 ])dnl
4398 dnl ---------------------------------------------------------------------------
4399 dnl CF_LIBTOOL_VERSION version: 1 updated: 2013/04/06 18:03:09
4400 dnl ------------------
4401 AC_DEFUN([CF_LIBTOOL_VERSION],[
4402 if test -n "$LIBTOOL" && test "$LIBTOOL" != none
4403 then
4404         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.]].*//'`
4405 else
4406         cf_cv_libtool_version=
4407 fi
4408 test -z "$cf_cv_libtool_version" && unset cf_cv_libtool_version
4409 ])dnl
4410 dnl ---------------------------------------------------------------------------
4411 dnl CF_LIB_PREFIX version: 14 updated: 2021/01/01 13:31:04
4412 dnl -------------
4413 dnl Compute the library-prefix for the given host system
4414 dnl $1 = variable to set
4415 define([CF_LIB_PREFIX],
4416 [
4417         case "$cf_cv_system_name" in
4418         (OS/2*|os2*)
4419                 if test "$DFT_LWR_MODEL" = libtool; then
4420                         LIB_PREFIX='lib'
4421                 else
4422                         LIB_PREFIX=''
4423                 fi
4424                 ;;
4425         (*-msvc*)
4426                 LIB_PREFIX=''
4427                 ;;
4428         (*)     LIB_PREFIX='lib'
4429                 ;;
4430         esac
4431 ifelse($1,,,[$1=$LIB_PREFIX])
4432         AC_SUBST(LIB_PREFIX)
4433 ])dnl
4434 dnl ---------------------------------------------------------------------------
4435 dnl CF_LIB_RULES version: 97 updated: 2021/07/17 13:10:54
4436 dnl ------------
4437 dnl Append definitions and rules for the given models to the subdirectory
4438 dnl Makefiles, and the recursion rule for the top-level Makefile.  If the
4439 dnl subdirectory is a library-source directory, modify the Libs_To_Make list in
4440 dnl the corresponding makefile to list the models that we'll generate.
4441 dnl
4442 dnl For shared libraries, make a list of symbolic links to construct when
4443 dnl generating each library.  The convention used for Linux is the simplest
4444 dnl one:
4445 dnl     lib<name>.so    ->
4446 dnl     lib<name>.so.<major>    ->
4447 dnl     lib<name>.so.<maj>.<minor>
4448 dnl
4449 dnl Note: Libs_To_Make is mixed case, since it is not a pure autoconf variable.
4450 AC_DEFUN([CF_LIB_RULES],
4451 [AC_REQUIRE([AC_PROG_FGREP])dnl
4452 AC_REQUIRE([CF_MAKE_PHONY])dnl
4453
4454 cf_prefix=$LIB_PREFIX
4455 AC_REQUIRE([CF_SUBST_NCURSES_VERSION])
4456
4457 case "$cf_cv_shlib_version" in
4458 (cygdll|msysdll|mingw|msvcdll)
4459         TINFO_NAME=$TINFO_ARG_SUFFIX
4460         TINFO_SUFFIX=.dll
4461         ;;
4462 esac
4463
4464 if test -n "$TINFO_SUFFIX" ; then
4465         case "$TINFO_SUFFIX" in
4466         (tw*)
4467                 TINFO_NAME="${TINFO_NAME}tw${EXTRA_SUFFIX}"
4468                 TINFO_SUFFIX=`echo "$TINFO_SUFFIX" | sed 's/^tw'$EXTRA_SUFFIX'//'`
4469                 ;;
4470         (t*)
4471                 TINFO_NAME="${TINFO_NAME}t${EXTRA_SUFFIX}"
4472                 TINFO_SUFFIX=`echo "$TINFO_SUFFIX" | sed 's/^t'$EXTRA_SUFFIX'//'`
4473                 ;;
4474         (w*)
4475                 TINFO_NAME="${TINFO_NAME}w${EXTRA_SUFFIX}"
4476                 TINFO_SUFFIX=`echo "$TINFO_SUFFIX" | sed 's/^w'$EXTRA_SUFFIX'//'`
4477                 ;;
4478         esac
4479 fi
4480
4481 for cf_dir in $SRC_SUBDIRS
4482 do
4483         if test ! -d "$srcdir/$cf_dir" ; then
4484                 continue
4485         elif test -f "$srcdir/$cf_dir/modules" ; then
4486
4487                 SHARED_LIB=
4488                 Libs_To_Make=
4489                 cf_awk_program=
4490                 if test -n "${cf_cv_abi_version}" && test "x${cf_cv_abi_version}" != "x5"
4491                 then
4492                         cf_awk_program="$cf_awk_program\
4493 /deprecated in ABI${cf_cv_abi_version}/ { next; }\
4494 { sub(\"NCURSES([[WT]]+)?\", \"&${cf_cv_abi_version}\"); }\
4495 "
4496                 fi
4497
4498                 if test "x$WILDCARD_SYMS" = xno
4499                 then
4500                         cf_awk_program="$cf_awk_program\
4501 /[[     ]]_\\*;/ { skip=1; next; }\
4502 "
4503                 fi
4504
4505                 if test "x$cf_awk_program" != "x"
4506                 then
4507                         cat >>$cf_dir/Makefile <<CF_EOF
4508
4509 # Generated by CF_LIB_RULES
4510 resulting.map: $UNALTERED_SYMS
4511         $AWK 'BEGIN { skip = 1; last=""; } \
4512 $cf_awk_program \
4513 { if ( last != "" && ( skip == 0 || \[$]\[$]0 !~ /}/ ) ) { print last; }\
4514  skip = 0; last = \[$]\[$]0; } \
4515 END { print last; }' < "$UNALTERED_SYMS" >\[$]@
4516
4517 distclean::
4518         rm -f resulting.map
4519 CF_EOF
4520                 fi
4521
4522                 for cf_item in $cf_LIST_MODELS
4523                 do
4524                         CF_LIB_SUFFIX($cf_item,cf_suffix,cf_depsuf)
4525                         if test "$cf_dir" = "c++"
4526                         then
4527                                 CF_MAP_LIB_BASENAME(cf_libname,cxx)
4528                         else
4529                                 CF_MAP_LIB_BASENAME(cf_libname,$cf_dir)
4530                         fi
4531                         test -z "$cf_libname" && cf_libname="$cf_dir"
4532                         if test "$cf_item" = shared ; then
4533                                 if test -n "${LIB_SUFFIX}"
4534                                 then
4535                                         cf_shared_suffix=`echo "$cf_suffix" | sed 's/^'"${USE_LIB_SUFFIX}"'//'`
4536                                 else
4537                                         cf_shared_suffix="$cf_suffix"
4538                                 fi
4539                                 if test "$cf_cv_do_symlinks" = yes ; then
4540                                         cf_version_name=
4541
4542                                         case "$cf_cv_shlib_version" in
4543                                         (rel)
4544                                                 cf_version_name=REL_VERSION
4545                                                 ;;
4546                                         (abi)
4547                                                 cf_version_name=ABI_VERSION
4548                                                 ;;
4549                                         esac
4550
4551                                         if test -n "$cf_version_name"
4552                                         then
4553                                                 case "$cf_cv_system_name" in
4554                                                 (darwin*)
4555                                                         # "w", etc?
4556                                                         cf_suffix="${USE_LIB_SUFFIX}"'.${'$cf_version_name'}'"$cf_shared_suffix"
4557                                                         ;;
4558                                                 (*)
4559                                                         cf_suffix="$cf_suffix"'.${'$cf_version_name'}'
4560                                                         ;;
4561                                                 esac
4562                                         fi
4563                                         if test -n "${USE_LIB_SUFFIX}"
4564                                         then
4565                                                 cf_shared_suffix=`echo "$cf_suffix" | sed 's/^'"${USE_LIB_SUFFIX}"'//'`
4566                                         else
4567                                                 cf_shared_suffix="$cf_suffix"
4568                                         fi
4569                                 fi
4570                                 # cygwin needs import library, and has unique naming convention
4571                                 # use autodetected ${cf_prefix} for import lib and static lib, but
4572                                 # use 'cyg' prefix for shared lib.
4573                                 case "$cf_cv_shlib_version" in
4574                                 (cygdll)
4575                                         cf_cygsuf=`echo "$cf_suffix" | sed -e 's/\.dll/\${ABI_VERSION}.dll/'`
4576                                         cf_add_lib="../lib/cyg${cf_libname}${cf_cygsuf}"
4577                                         ;;
4578                                 (msysdll)
4579                                         cf_cygsuf=`echo "$cf_suffix" | sed -e 's/\.dll/\${ABI_VERSION}.dll/'`
4580                                         cf_add_lib="../lib/msys-${cf_libname}${cf_cygsuf}"
4581                                         ;;
4582                                 (mingw)
4583                                         cf_cygsuf=`echo "$cf_suffix" | sed -e 's/\.dll/\${ABI_VERSION}.dll/'`
4584                                         cf_add_lib="../lib/lib${cf_libname}${cf_cygsuf}"
4585                                         ;;
4586                                 (msvcdll)
4587                                         cf_cygsuf=`echo "$cf_suffix" | sed -e 's/\.dll/\${ABI_VERSION}.dll/'`
4588                                         cf_add_lib="../lib/${cf_libname}${cf_cygsuf}"
4589                                         ;;
4590                                 (*)
4591                                         cf_add_lib=
4592                                         ;;
4593                                 esac
4594                                 if test -n "$cf_add_lib"
4595                                 then
4596                                         Libs_To_Make="$Libs_To_Make $cf_add_lib"
4597                                         continue
4598                                 fi
4599                         fi
4600                         cf_add_lib="../lib/${cf_prefix}${cf_libname}${cf_suffix}"
4601                         Libs_To_Make="$Libs_To_Make $cf_add_lib"
4602                 done
4603
4604                 if test "$cf_dir" = ncurses ; then
4605                         cf_subsets="$LIB_SUBSETS"
4606                         cf_r_parts="$cf_subsets"
4607                         cf_liblist="$Libs_To_Make"
4608
4609                         while test -n "$cf_r_parts"
4610                         do
4611                                 cf_l_parts=`echo "$cf_r_parts" |sed -e 's/ .*$//'`
4612                                 cf_r_parts=`echo "$cf_r_parts" |sed -e 's/^[[^ ]]* //'`
4613                                 if test "$cf_l_parts" != "$cf_r_parts" ; then
4614                                         cf_add_lib=
4615                                         case "$cf_l_parts" in
4616                                         (*termlib*)
4617                                                 cf_add_lib=`echo "$cf_liblist" |sed -e s%${LIB_NAME}${USE_LIB_SUFFIX}%${TINFO_LIB_SUFFIX}%g`
4618                                                 ;;
4619                                         (*ticlib*)
4620                                                 cf_add_lib=`echo "$cf_liblist" |sed -e s%${LIB_NAME}${USE_LIB_SUFFIX}%${TICS_LIB_SUFFIX}%g`
4621                                                 ;;
4622                                         (*)
4623                                                 break
4624                                                 ;;
4625                                         esac
4626                                         if test -n "$cf_add_lib"; then
4627                                                 Libs_To_Make="$cf_add_lib $Libs_To_Make"
4628                                         fi
4629                                 else
4630                                         break
4631                                 fi
4632                         done
4633                 else
4634                         cf_subsets=`echo "$LIB_SUBSETS" | sed -e 's/^termlib.* //'`
4635                 fi
4636
4637                 if test "$cf_dir" = c++; then
4638                         if test "x$with_shared_cxx" != xyes && test -n "$cf_shared_suffix"; then
4639                                 cf_list=
4640                                 for cf_item in $Libs_To_Make
4641                                 do
4642                                         case "$cf_item" in
4643                                         (*.a)
4644                                                 ;;
4645                                         (*)
4646                                                 cf_item=`echo "$cf_item" | sed -e "s,"$cf_shared_suffix",.a,"`
4647                                                 ;;
4648                                         esac
4649                                         for cf_test in $cf_list
4650                                         do
4651                                                 if test "$cf_test" = "$cf_item"
4652                                                 then
4653                                                         cf_LIST_MODELS=`echo "$cf_LIST_MODELS" | sed -e 's/normal//'`
4654                                                         cf_item=
4655                                                         break
4656                                                 fi
4657                                         done
4658                                         test -n "$cf_item" && cf_list="$cf_list $cf_item"
4659                                 done
4660                                 Libs_To_Make="$cf_list"
4661                         fi
4662                 fi
4663
4664                 sed -e "s%@Libs_To_Make@%$Libs_To_Make%" \
4665                     -e "s%@SHARED_LIB@%$SHARED_LIB%" \
4666                         "$cf_dir/Makefile" >$cf_dir/Makefile.out
4667                 mv "$cf_dir/Makefile.out" "$cf_dir/Makefile"
4668
4669                 $AWK -f "$srcdir/mk-0th.awk" \
4670                         libname="${cf_dir}${LIB_SUFFIX}" subsets="$LIB_SUBSETS" ticlib="$TICS_LIB_SUFFIX" termlib="$TINFO_LIB_SUFFIX" \
4671                         "$srcdir/$cf_dir/modules" >>$cf_dir/Makefile
4672
4673                 for cf_subset in $cf_subsets
4674                 do
4675                         cf_subdirs=
4676                         for cf_item in $cf_LIST_MODELS
4677                         do
4678
4679                         echo "Appending rules for ${cf_item} model (${cf_dir}: ${cf_subset})"
4680                         CF_UPPER(cf_ITEM,$cf_item)
4681
4682                         CXX_MODEL=$cf_ITEM
4683                         if test "$CXX_MODEL" = SHARED; then
4684                                 case "$cf_cv_shlib_version" in
4685                                 (cygdll|msysdll|mingw|msvcdll)
4686                                         test "x$with_shared_cxx" = xno && CF_VERBOSE(overriding CXX_MODEL to SHARED)
4687                                         with_shared_cxx=yes
4688                                         ;;
4689                                 (*)
4690                                         test "x$with_shared_cxx" = xno && CXX_MODEL=NORMAL
4691                                         ;;
4692                                 esac
4693                         fi
4694
4695                         CF_LIB_SUFFIX($cf_item,cf_suffix,cf_depsuf)
4696                         CF_OBJ_SUBDIR($cf_item,cf_subdir)
4697
4698                         # Test for case where we build libtinfo with a different name.
4699                         cf_libname=$cf_dir
4700                         if test "$cf_dir" = ncurses ; then
4701                                 case "$cf_subset" in
4702                                 (*base*)
4703                                         cf_libname=${cf_libname}$USE_LIB_SUFFIX
4704                                         ;;
4705                                 (*termlib*)
4706                                         cf_libname=$TINFO_LIB_SUFFIX
4707                                         ;;
4708                                 (ticlib*)
4709                                         cf_libname=$TICS_LIB_SUFFIX
4710                                         ;;
4711                                 esac
4712                         elif test "$cf_dir" = c++ ; then
4713                                 CF_MAP_LIB_BASENAME(cf_libname,cxx)
4714                                 cf_libname=${cf_libname}$USE_LIB_SUFFIX
4715                         else
4716                                 CF_MAP_LIB_BASENAME(cf_libname,$cf_dir)
4717                                 cf_libname=${cf_libname}$USE_LIB_SUFFIX
4718                         fi
4719                         if test -n "${USE_ARG_SUFFIX}" ; then
4720                                 # undo $USE_LIB_SUFFIX add-on in CF_LIB_SUFFIX
4721                                 cf_suffix=`echo "$cf_suffix" |sed -e "s%^${USE_LIB_SUFFIX}%%"`
4722                         fi
4723
4724                         # These dependencies really are for development, not
4725                         # builds, but they are useful in porting, too.
4726                         cf_depend="../include/ncurses_cfg.h"
4727                         if test "$srcdir" = "."; then
4728                                 cf_reldir="."
4729                         else
4730                                 cf_reldir="\${srcdir}"
4731                         fi
4732
4733                         if test -f "$srcdir/$cf_dir/$cf_dir.priv.h" ; then
4734                                 cf_depend="$cf_depend $cf_reldir/$cf_dir.priv.h"
4735                         elif test -f "$srcdir/$cf_dir/curses.priv.h" ; then
4736                                 cf_depend="$cf_depend $cf_reldir/curses.priv.h"
4737                         fi
4738
4739                         cf_dir_suffix=
4740                         old_cf_suffix="$cf_suffix"
4741                         if test "$cf_cv_shlib_version_infix" = yes ; then
4742                         if test -n "$USE_LIB_SUFFIX" ; then
4743                                 case "$USE_LIB_SUFFIX" in
4744                                 (tw*)
4745                                         cf_libname=`echo "$cf_libname" | sed 's/tw'$EXTRA_SUFFIX'$//'`
4746                                         cf_suffix=`echo "$cf_suffix" | sed 's/^tw'$EXTRA_SUFFIX'//'`
4747                                         cf_dir_suffix=tw$EXTRA_SUFFIX
4748                                         ;;
4749                                 (t*)
4750                                         cf_libname=`echo "$cf_libname" | sed 's/t'$EXTRA_SUFFIX'$//'`
4751                                         cf_suffix=`echo "$cf_suffix" | sed 's/^t'$EXTRA_SUFFIX'//'`
4752                                         cf_dir_suffix=t$EXTRA_SUFFIX
4753                                         ;;
4754                                 (w*)
4755                                         cf_libname=`echo "$cf_libname" | sed 's/w'$EXTRA_SUFFIX'$//'`
4756                                         cf_suffix=`echo "$cf_suffix" | sed 's/^w'$EXTRA_SUFFIX'//'`
4757                                         cf_dir_suffix=w$EXTRA_SUFFIX
4758                                         ;;
4759                                 (*)
4760                                         cf_libname=`echo "$cf_libname" | sed 's/'$EXTRA_SUFFIX'$//'`
4761                                         cf_suffix=`echo "$cf_suffix" | sed 's/^'$EXTRA_SUFFIX'//'`
4762                                         cf_dir_suffix=$EXTRA_SUFFIX
4763                                         ;;
4764                                 esac
4765                         fi
4766                         fi
4767
4768                         $AWK -f "$srcdir/mk-1st.awk" \
4769                                 name=${cf_libname}${cf_dir_suffix} \
4770                                 traces=$LIB_TRACING \
4771                                 MODEL=$cf_ITEM \
4772                                 CXX_MODEL=$CXX_MODEL \
4773                                 LIB_SUFFIX=$LIB_SUFFIX \
4774                                 USE_LIB_SUFFIX=$USE_LIB_SUFFIX \
4775                                 make_phony="${cf_cv_make_PHONY:-no}" \
4776                                 model=$cf_subdir \
4777                                 prefix=$cf_prefix \
4778                                 suffix=$cf_suffix \
4779                                 subset=$cf_subset \
4780                                 driver=$cf_cv_term_driver \
4781                                 SymLink="$LN_S" \
4782                                 TermlibRoot=$TINFO_NAME \
4783                                 TermlibSuffix=$TINFO_SUFFIX \
4784                                 ShlibVer=$cf_cv_shlib_version \
4785                                 ShlibVerInfix=$cf_cv_shlib_version_infix \
4786                                 ReLink=${cf_cv_do_relink:-no} \
4787                                 ReRanlib=${cf_cv_do_reranlib:-yes} \
4788                                 DoLinks=$cf_cv_do_symlinks \
4789                                 rmSoLocs=$cf_cv_rm_so_locs \
4790                                 ldconfig="$LDCONFIG" \
4791                                 overwrite=$WITH_OVERWRITE \
4792                                 depend="$cf_depend" \
4793                                 host="$host" \
4794                                 libtool_version="$LIBTOOL_VERSION" \
4795                                 "$srcdir/$cf_dir/modules" >>$cf_dir/Makefile
4796
4797                         cf_suffix="$old_cf_suffix"
4798
4799                         for cf_subdir2 in $cf_subdirs lib
4800                         do
4801                                 test "$cf_subdir" = "$cf_subdir2" && break
4802                         done
4803                         test "${cf_subset}.${cf_subdir2}" != "${cf_subset}.${cf_subdir}" && \
4804                         $AWK -f "$srcdir/mk-2nd.awk" \
4805                                 name=$cf_dir \
4806                                 traces=$LIB_TRACING \
4807                                 MODEL=$cf_ITEM \
4808                                 model=$cf_subdir \
4809                                 subset=$cf_subset \
4810                                 srcdir=$srcdir \
4811                                 echo=$WITH_ECHO \
4812                                 crenames=$cf_cv_prog_CC_c_o \
4813                                 cxxrenames=$cf_cv_prog_CXX_c_o \
4814                                 "$srcdir/$cf_dir/modules" >>$cf_dir/Makefile
4815                         cf_subdirs="$cf_subdirs $cf_subdir"
4816                         done
4817                 done
4818         fi
4819
4820         echo '  ( cd '$cf_dir' && ${MAKE} ${TOP_MFLAGS} [$]@ )' >>Makefile
4821 done
4822
4823 echo >> Makefile
4824 echo '# generated by CF_LIB_RULES' >> Makefile
4825
4826 if test "x$cf_cv_make_PHONY" = xyes ; then
4827         cat >> Makefile <<-CF_EOF
4828
4829         .PHONY :        libs
4830         .PHONY :        lintlib
4831         .PHONY :        install.includes
4832         .PHONY :        uninstall.includes
4833         .PHONY :        install.libs
4834         .PHONY :        uninstall.libs
4835 CF_EOF
4836 fi
4837
4838 for cf_dir in $SRC_SUBDIRS
4839 do
4840         if test ! -d "$srcdir/$cf_dir" ; then
4841                 continue
4842         fi
4843
4844         if test -f "$cf_dir/Makefile" ; then
4845                 case "$cf_dir" in
4846                 (Ada95)
4847                         echo 'libs \' >> Makefile
4848                         echo 'install.libs \' >> Makefile
4849                         echo 'uninstall.libs ::' >> Makefile
4850                         echo '  ( cd '$cf_dir' && ${MAKE} ${TOP_MFLAGS} [$]@ )' >> Makefile
4851                         ;;
4852                 esac
4853         fi
4854
4855         if test -f "$srcdir/$cf_dir/modules" ; then
4856
4857                 if test "x$cf_cv_make_PHONY" = xyes ; then
4858                         cat >> Makefile <<-CF_EOF
4859
4860                         .PHONY :        install.$cf_dir
4861                         .PHONY :        uninstall.$cf_dir
4862 CF_EOF
4863                 fi
4864
4865                 echo >> Makefile
4866                 if test -f "$srcdir/$cf_dir/headers" ; then
4867 cat >> Makefile <<CF_EOF
4868 install.includes \\
4869 uninstall.includes \\
4870 CF_EOF
4871                 fi
4872
4873 cat >> Makefile <<CF_EOF
4874 lint \\
4875 libs \\
4876 lintlib \\
4877 install.libs \\
4878 uninstall.libs \\
4879 install.$cf_dir \\
4880 uninstall.$cf_dir ::
4881         ( cd "$cf_dir" && \${MAKE} \${TOP_MFLAGS} \[$]@ )
4882 CF_EOF
4883         elif test -f "$srcdir/$cf_dir/headers" ; then
4884 cat >> Makefile <<CF_EOF
4885
4886 libs \\
4887 install.libs \\
4888 uninstall.libs \\
4889 install.includes \\
4890 uninstall.includes ::
4891         ( cd "$cf_dir" && \${MAKE} \${TOP_MFLAGS} \[$]@ )
4892 CF_EOF
4893 fi
4894 done
4895
4896 if test "x$cf_cv_make_PHONY" = xyes ; then
4897         cat >> Makefile <<-CF_EOF
4898
4899         .PHONY :        install.data
4900         .PHONY :        uninstall.data
4901 CF_EOF
4902 fi
4903
4904 if test "x$cf_with_db_install" = xyes; then
4905 cat >> Makefile <<CF_EOF
4906
4907 install.libs uninstall.libs \\
4908 install.data uninstall.data ::
4909 $MAKE_TERMINFO  ( cd misc && \${MAKE} \${TOP_MFLAGS} \[$]@ )
4910 CF_EOF
4911 else
4912 cat >> Makefile <<CF_EOF
4913
4914 install.libs uninstall.libs ::
4915         ( cd misc && \${MAKE} \${TOP_MFLAGS} \[$]@ )
4916 CF_EOF
4917 fi
4918
4919 if test "x$cf_with_manpages" = xyes; then
4920
4921 if test "x$cf_cv_make_PHONY" = xyes ; then
4922         cat >> Makefile <<-CF_EOF
4923
4924         .PHONY :        install.man
4925         .PHONY :        uninstall.man
4926 CF_EOF
4927 fi
4928
4929 cat >> Makefile <<CF_EOF
4930
4931 install.man \\
4932 uninstall.man ::
4933         ( cd man && \${MAKE} \${TOP_MFLAGS} \[$]@ )
4934 CF_EOF
4935 fi
4936
4937 cat >> Makefile <<CF_EOF
4938
4939 distclean ::
4940         rm -f config.cache config.log config.status Makefile include/ncurses_cfg.h
4941         rm -f headers.sh headers.sed mk_shared_lib.sh
4942         rm -f edit_man.* man_alias.*
4943         rm -rf \${DIRS_TO_MAKE}
4944 CF_EOF
4945
4946 # Special case: tack's manpage lives in its own directory.
4947 if test "x$cf_with_manpages" = xyes; then
4948 if test "x$cf_with_tack" = "xyes"; then
4949 cat >> Makefile <<CF_EOF
4950
4951 install.man \\
4952 uninstall.man ::
4953         ( cd tack && \${MAKE} \${TOP_MFLAGS} \[$]@ )
4954 CF_EOF
4955 fi
4956 fi
4957
4958 dnl If we're installing into a subdirectory of /usr/include, etc., we should
4959 dnl prepend the subdirectory's name to the "#include" paths.  It won't hurt
4960 dnl anything, and will make it more standardized.  It's awkward to decide this
4961 dnl at configuration because of quoting, so we'll simply make all headers
4962 dnl installed via a script that can do the right thing.
4963
4964 rm -f headers.sed headers.sh
4965
4966 dnl ( generating this script makes the makefiles a little tidier :-)
4967 echo creating headers.sh
4968 cat >headers.sh <<CF_EOF
4969 #! $SHELL
4970 # This shell script is generated by the 'configure' script.  It is invoked in a
4971 # subdirectory of the build tree.  It generates a sed-script in the parent
4972 # directory that is used to adjust includes for header files that reside in a
4973 # subdirectory of /usr/include, etc.
4974 PRG=""
4975 while test \[$]# != 3
4976 do
4977 PRG="\$PRG \[$]1"; shift
4978 done
4979 DST=\[$]1
4980 REF=\[$]2
4981 SRC=\[$]3
4982 TMPSRC=\${TMPDIR:-/tmp}/\`basename \$SRC\`\$\$
4983 TMPSED=\${TMPDIR:-/tmp}/headers.sed\$\$
4984 echo installing \$SRC in \$DST
4985 CF_EOF
4986
4987 if test "$WITH_CURSES_H" = yes; then
4988         cat >>headers.sh <<CF_EOF
4989 case \$DST in
4990 (/*/include/*)
4991         END=\`basename \$DST\`
4992         for i in \`cat \$REF/../*/headers |${FGREP-fgrep} -v "#"\`
4993         do
4994                 NAME=\`basename \$i\`
4995                 echo "s/<\$NAME>/<\$END\/\$NAME>/" >> \$TMPSED
4996         done
4997         ;;
4998 (*)
4999         echo "" >> \$TMPSED
5000         ;;
5001 esac
5002 CF_EOF
5003
5004 else
5005         cat >>headers.sh <<CF_EOF
5006 case \$DST in
5007 (/*/include/*)
5008         END=\`basename \$DST\`
5009         for i in \`cat \$REF/../*/headers |${FGREP-fgrep} -v "#"\`
5010         do
5011                 NAME=\`basename \$i\`
5012                 if test "\$NAME" = "curses.h"
5013                 then
5014                         echo "s/<curses.h>/<ncurses.h>/" >> \$TMPSED
5015                         NAME=ncurses.h
5016                 fi
5017                 echo "s/<\$NAME>/<\$END\/\$NAME>/" >> \$TMPSED
5018         done
5019         ;;
5020 (*)
5021         echo "s/<curses.h>/<ncurses.h>/" >> \$TMPSED
5022         ;;
5023 esac
5024 CF_EOF
5025 fi
5026 cat >>headers.sh <<CF_EOF
5027 rm -f \$TMPSRC
5028 sed -f \$TMPSED \$SRC > \$TMPSRC
5029 NAME=\`basename \$SRC\`
5030 CF_EOF
5031 if test "$WITH_CURSES_H" != yes; then
5032         cat >>headers.sh <<CF_EOF
5033 test "\$NAME" = "curses.h" && NAME=ncurses.h
5034 CF_EOF
5035 fi
5036 cat >>headers.sh <<CF_EOF
5037 # Just in case someone gzip'd manpages, remove the conflicting copy.
5038 test -f \$DST/\$NAME.gz && rm -f \$DST/\$NAME.gz
5039
5040 eval \$PRG \$TMPSRC \$DST/\$NAME
5041 rm -f \$TMPSRC \$TMPSED
5042 CF_EOF
5043
5044 chmod 0755 headers.sh
5045
5046 for cf_dir in $SRC_SUBDIRS
5047 do
5048         if test ! -d "$srcdir/$cf_dir" ; then
5049                 continue
5050         fi
5051
5052         if test -f "$srcdir/$cf_dir/headers" ; then
5053                 $AWK -f "$srcdir/mk-hdr.awk" \
5054                         subset="$LIB_SUBSETS" \
5055                         compat="$WITH_CURSES_H" \
5056                         "$srcdir/$cf_dir/headers" >>$cf_dir/Makefile
5057         fi
5058
5059         if test -f "$srcdir/$cf_dir/modules" ; then
5060                 if test "$cf_dir" != "c++" ; then
5061                         if test "x$cf_cv_make_PHONY" = xyes ; then
5062                                 cat >> $cf_dir/Makefile <<-CF_EOF
5063
5064                                 .PHONY :        depend
5065 CF_EOF
5066                         fi
5067
5068                         cat >>$cf_dir/Makefile <<"CF_EOF"
5069 depend : ${AUTO_SRC}
5070         makedepend -- ${CPPFLAGS} -- ${C_SRC}
5071
5072 # DO NOT DELETE THIS LINE -- make depend depends on it.
5073 CF_EOF
5074                 fi
5075         fi
5076 done
5077 AC_SUBST(Libs_To_Make)
5078 ])dnl
5079 dnl ---------------------------------------------------------------------------
5080 dnl CF_LIB_SONAME version: 9 updated: 2021/01/04 18:48:01
5081 dnl -------------
5082 dnl Find the and soname for the given shared library.  Set the cache variable
5083 dnl cf_cv_$3_soname to this, unless it is not found.  Then set the cache
5084 dnl variable to "unknown".
5085 dnl
5086 dnl $1 = headers
5087 dnl $2 = code
5088 dnl $3 = library name
5089 AC_DEFUN([CF_LIB_SONAME],
5090 [AC_REQUIRE([AC_PROG_FGREP])dnl
5091
5092 AC_CACHE_CHECK(for soname of $3 library,cf_cv_$3_soname,[
5093
5094 cf_cv_$3_soname=unknown
5095 if test "$cross_compiling" != yes ; then
5096 cat >conftest.$ac_ext <<CF_EOF
5097 $1
5098 int main(void)
5099 {
5100 $2
5101         ${cf_cv_main_return:-return}(0);
5102 }
5103 CF_EOF
5104 cf_save_LIBS="$LIBS"
5105         CF_ADD_LIB($3)
5106         if AC_TRY_EVAL(ac_compile) ; then
5107                 if AC_TRY_EVAL(ac_link) ; then
5108                         cf_cv_$3_soname="`ldd \"conftest$ac_exeext\" 2>/dev/null | sed -e 's,^.*/,,' -e 's, .*$,,' | ${FGREP-fgrep} lib$3.`"
5109                         test -z "$cf_cv_$3_soname" && cf_cv_$3_soname=unknown
5110                 fi
5111         fi
5112 rm -rf ./conftest*
5113 LIBS="$cf_save_LIBS"
5114 fi
5115 ])
5116 ])
5117 dnl ---------------------------------------------------------------------------
5118 dnl CF_LIB_SUFFIX version: 28 updated: 2021/01/01 16:53:59
5119 dnl -------------
5120 dnl Compute the library file-suffix from the given model name
5121 dnl $1 = model name
5122 dnl $2 = variable to set (the nominal library suffix)
5123 dnl $3 = dependency variable to set (actual filename)
5124 dnl The variable $LIB_SUFFIX, if set, prepends the variable to set.
5125 AC_DEFUN([CF_LIB_SUFFIX],
5126 [
5127         case X$1 in
5128         (Xlibtool)
5129                 $2='.la'
5130                 $3=[$]$2
5131                 ;;
5132         (Xdebug)
5133                 case "$cf_cv_system_name" in
5134                 (*-msvc*)
5135                         $2='_g.lib'
5136                         ;;
5137                 (*)
5138                         $2='_g.a'
5139                         ;;
5140                 esac
5141                 $3=[$]$2
5142                 ;;
5143         (Xprofile)
5144                 case "$cf_cv_system_name" in
5145                 (*-msvc*)
5146                         $2='_p.lib'
5147                         ;;
5148                 (*)
5149                         $2='_p.a'
5150                         ;;
5151                 esac
5152                 $3=[$]$2
5153                 ;;
5154         (Xshared)
5155                 case "$cf_cv_system_name" in
5156                 (aix[[5-7]]*)
5157                         $2='.so'
5158                         $3=[$]$2
5159                         ;;
5160                 (*-msvc*)
5161                         $2='.dll'
5162                         $3='.dll.lib'
5163                         ;;
5164                 (cygwin*|msys*|mingw*)
5165                         $2='.dll'
5166                         $3='.dll.a'
5167                         ;;
5168                 (darwin*)
5169                         $2='.dylib'
5170                         $3=[$]$2
5171                         ;;
5172                 (hpux*)
5173                         case "$target" in
5174                         (ia64*)
5175                                 $2='.so'
5176                                 $3=[$]$2
5177                                 ;;
5178                         (*)
5179                                 $2='.sl'
5180                                 $3=[$]$2
5181                                 ;;
5182                         esac
5183                         ;;
5184                 (*)
5185                         $2='.so'
5186                         $3=[$]$2
5187                         ;;
5188                 esac
5189                 ;;
5190         (*)
5191                 case "$target" in
5192                 (*-msvc*)
5193                         $2='.lib'
5194                         ;;
5195                 (*)
5196                         $2='.a'
5197                         ;;
5198                 esac
5199                 $3=[$]$2
5200                 ;;
5201         esac
5202         if test -n "${LIB_SUFFIX}${EXTRA_SUFFIX}"
5203         then
5204                 $2="${LIB_SUFFIX}${EXTRA_SUFFIX}[$]{$2}"
5205                 $3="${LIB_SUFFIX}${EXTRA_SUFFIX}[$]{$3}"
5206         fi
5207 ])dnl
5208 dnl ---------------------------------------------------------------------------
5209 dnl CF_LIB_TYPE version: 5 updated: 2015/04/17 21:13:04
5210 dnl -----------
5211 dnl Compute the string to append to -library from the given model name
5212 dnl $1 = model name
5213 dnl $2 = variable to set
5214 dnl The variable $LIB_SUFFIX, if set, prepends the variable to set.
5215 AC_DEFUN([CF_LIB_TYPE],
5216 [
5217         case $1 in
5218         (libtool) $2=''   ;;
5219         (normal)  $2=''   ;;
5220         (debug)   $2='_g' ;;
5221         (profile) $2='_p' ;;
5222         (shared)  $2=''   ;;
5223         esac
5224         test -n "$LIB_SUFFIX" && $2="${LIB_SUFFIX}[$]{$2}"
5225 ])dnl
5226 dnl ---------------------------------------------------------------------------
5227 dnl CF_LINK_DATAONLY version: 13 updated: 2020/02/08 15:59:30
5228 dnl ----------------
5229 dnl Some systems have a non-ANSI linker that doesn't pull in modules that have
5230 dnl only data (i.e., no functions), for example NeXT.  On those systems we'll
5231 dnl have to provide wrappers for global tables to ensure they're linked
5232 dnl properly.
5233 AC_DEFUN([CF_LINK_DATAONLY],
5234 [
5235 AC_MSG_CHECKING([if data-only library module links])
5236 AC_CACHE_VAL(cf_cv_link_dataonly,[
5237         rm -f conftest.a
5238         cat >conftest.$ac_ext <<EOF
5239 #line __oline__ "configure"
5240 int     testdata[[3]] = { 123, 456, 789 };
5241 EOF
5242         if AC_TRY_EVAL(ac_compile) ; then
5243                 mv conftest.o data.o && \
5244                 ( $AR $ARFLAGS conftest.a data.o ) 2>&AC_FD_CC 1>/dev/null
5245         fi
5246         rm -f conftest.$ac_ext data.o
5247         cat >conftest.$ac_ext <<EOF
5248 #line __oline__ "configure"
5249 int     testfunc(void)
5250 {
5251 #if defined(NeXT)
5252         ${cf_cv_main_return:-return}(1);        /* I'm told this linker is broken */
5253 #else
5254         extern int testdata[[3]];
5255         return testdata[[0]] == 123
5256            &&  testdata[[1]] == 456
5257            &&  testdata[[2]] == 789;
5258 #endif
5259 }
5260 EOF
5261         if AC_TRY_EVAL(ac_compile); then
5262                 mv conftest.o func.o && \
5263                 ( $AR $ARFLAGS conftest.a func.o ) 2>&AC_FD_CC 1>/dev/null
5264         fi
5265         rm -f conftest.$ac_ext func.o
5266         ( eval $RANLIB conftest.a ) 2>&AC_FD_CC >/dev/null
5267         cf_saveLIBS="$LIBS"
5268         LIBS="conftest.a $LIBS"
5269         AC_TRY_RUN([
5270         int main(void)
5271         {
5272                 extern int testfunc();
5273                 ${cf_cv_main_return:-return} (!testfunc());
5274         }
5275         ],
5276         [cf_cv_link_dataonly=yes],
5277         [cf_cv_link_dataonly=no],
5278         [cf_cv_link_dataonly=unknown])
5279         LIBS="$cf_saveLIBS"
5280         ])
5281 AC_MSG_RESULT($cf_cv_link_dataonly)
5282
5283 if test "$cf_cv_link_dataonly" = no ; then
5284         AC_DEFINE(BROKEN_LINKER,1,[if data-only library module does not link])
5285         BROKEN_LINKER=1
5286 fi
5287 AC_SUBST(BROKEN_LINKER)
5288
5289 ])dnl
5290 dnl ---------------------------------------------------------------------------
5291 dnl CF_LINK_FUNCS version: 11 updated: 2021/04/18 14:08:47
5292 dnl -------------
5293 dnl Most Unix systems have both link and symlink, a few don't have symlink.
5294 dnl A few non-Unix systems implement symlink, but not link.
5295 dnl A few non-systems implement neither (or have nonfunctional versions).
5296 dnl
5297 dnl This allows for a 2-second difference in modification times to allow for
5298 dnl some marginal NFS implementations.
5299 AC_DEFUN([CF_LINK_FUNCS],
5300 [
5301 AC_CHECK_HEADERS( \
5302 unistd.h \
5303 )
5304 AC_CHECK_FUNCS( \
5305         remove \
5306         unlink )
5307
5308 if test "$cross_compiling" = yes ; then
5309         AC_CHECK_FUNCS( \
5310                 link \
5311                 symlink )
5312 else
5313         AC_CACHE_CHECK(if link/symlink functions work,cf_cv_link_funcs,[
5314                 cf_cv_link_funcs=
5315                 for cf_func in link symlink ; do
5316                         AC_TRY_RUN([
5317 #include <stdio.h>
5318 #include <sys/types.h>
5319 #include <sys/stat.h>
5320 #ifdef HAVE_UNISTD_H
5321 #include <unistd.h>
5322 #endif
5323 int main(void)
5324 {
5325         int fail = 0;
5326         char *src = "conftest.tmp";
5327         char *dst = "conftest.chk";
5328         struct stat src_sb, dst_sb;
5329         FILE *fp = fopen(src, "w");
5330         if (fp == 0) { fail = 3; } else {
5331                 fclose(fp); stat(src, &src_sb);
5332                 if ($cf_func(src, dst) < 0) {
5333                         fail = 1;
5334                 } else if (stat(dst, &dst_sb) < 0) {
5335                         fail = 2;
5336                 } else {
5337                         long diff = (dst_sb.st_mtime - src_sb.st_mtime);
5338                         if (diff < 0) diff = -diff;
5339                         if (diff > 2) fail = 3;
5340                 }
5341         }
5342 #ifdef HAVE_UNLINK
5343         unlink(dst); unlink(src);
5344 #else
5345         remove(dst); remove(src);
5346 #endif
5347         ${cf_cv_main_return:-return} (fail);
5348 }
5349                         ],[
5350                         cf_cv_link_funcs="$cf_cv_link_funcs $cf_func"
5351                         eval 'ac_cv_func_'$cf_func'=yes'],[
5352                         eval 'ac_cv_func_'$cf_func'=no'],[
5353                         eval 'ac_cv_func_'$cf_func'=error'])
5354                 done
5355                 test -z "$cf_cv_link_funcs" && cf_cv_link_funcs=no
5356         ])
5357         test "$ac_cv_func_link"    = yes && AC_DEFINE(HAVE_LINK,1,[Define to 1 if we have link() function])
5358         test "$ac_cv_func_symlink" = yes && AC_DEFINE(HAVE_SYMLINK,1,[Define to 1 if we have symlink() function])
5359 fi
5360 ])dnl
5361 dnl ---------------------------------------------------------------------------
5362 dnl CF_MAKEFLAGS version: 21 updated: 2021/09/04 06:47:34
5363 dnl ------------
5364 dnl Some 'make' programs support ${MAKEFLAGS}, some ${MFLAGS}, to pass 'make'
5365 dnl options to lower-levels.  It is very useful for "make -n" -- if we have it.
5366 dnl (GNU 'make' does both, something POSIX 'make', which happens to make the
5367 dnl ${MAKEFLAGS} variable incompatible because it adds the assignments :-)
5368 AC_DEFUN([CF_MAKEFLAGS],
5369 [AC_REQUIRE([AC_PROG_FGREP])dnl
5370
5371 AC_CACHE_CHECK(for makeflags variable, cf_cv_makeflags,[
5372         cf_cv_makeflags=''
5373         for cf_option in '-${MAKEFLAGS}' '${MFLAGS}'
5374         do
5375                 cat >cf_makeflags.tmp <<CF_EOF
5376 SHELL = $SHELL
5377 all :
5378         @ echo '.$cf_option'
5379 CF_EOF
5380                 cf_result=`${MAKE:-make} -k -f cf_makeflags.tmp 2>/dev/null | ${FGREP-fgrep} -v "ing directory" | sed -e 's,[[  ]]*$,,'`
5381                 case "$cf_result" in
5382                 (.*k|.*kw)
5383                         cf_result="`${MAKE:-make} -k -f cf_makeflags.tmp CC=cc 2>/dev/null`"
5384                         case "$cf_result" in
5385                         (.*CC=*)        cf_cv_makeflags=
5386                                 ;;
5387                         (*)     cf_cv_makeflags=$cf_option
5388                                 ;;
5389                         esac
5390                         break
5391                         ;;
5392                 (.-)
5393                         ;;
5394                 (*)
5395                         CF_MSG_LOG(given option \"$cf_option\", no match \"$cf_result\")
5396                         ;;
5397                 esac
5398         done
5399         rm -f cf_makeflags.tmp
5400 ])
5401
5402 AC_SUBST(cf_cv_makeflags)
5403 ])dnl
5404 dnl ---------------------------------------------------------------------------
5405 dnl CF_MAKE_PHONY version: 3 updated: 2021/01/08 16:08:21
5406 dnl -------------
5407 dnl Check if the make-program handles a ".PHONY" target, e.g,. a target which
5408 dnl acts as a placeholder.
5409 dnl
5410 dnl The ".PHONY" feature was proposed in 2011 here
5411 dnl     https://www.austingroupbugs.net/view.php?id=523
5412 dnl and is scheduled for release in P1003.1 Issue 8 (late 2022).
5413 dnl
5414 dnl This is not supported by SVr4 make (or SunOS 4, 4.3SD, etc), but works with
5415 dnl a few others (i.e., GNU make and the non-POSIX "BSD" make):
5416 dnl
5417 dnl + This is a GNU make feature (since April 1988, but in turn from binutils,
5418 dnl   date unspecified).
5419 dnl
5420 dnl + It was adopted in NetBSD make in June 1995.
5421 dnl
5422 dnl + The other BSD make programs are derived from the NetBSD make (and for
5423 dnl   that reason are not actually different "implementations").
5424 dnl
5425 dnl + Some features of NetBSD make were actually adapted from pmake, which
5426 dnl   began as a modified GNU make starting in 1993.
5427 dnl
5428 dnl + Version 3.8 of the dmake program in January 1992 also implemented this
5429 dnl   GNU make extension, but is less well known than the BSD make.
5430 AC_DEFUN([CF_MAKE_PHONY],[
5431 AC_CACHE_CHECK(for \".PHONY\" make-support, cf_cv_make_PHONY,[
5432         rm -rf conftest*
5433         (
5434                 mkdir conftest || exit 1
5435                 cd conftest
5436                 cat >makefile <<'CF_EOF'
5437 .PHONY: always
5438 DATA=0
5439 always: always.out
5440         @echo "** making [$]@ [$](DATA)"
5441 once: once.out
5442         @echo "** making [$]@ [$](DATA)"
5443 always.out:
5444         @echo "** making [$]@ [$](DATA)"
5445         echo [$](DATA) > [$]@
5446 once.out:
5447         @echo "** making [$]@ [$](DATA)"
5448         echo [$](DATA) > [$]@
5449 CF_EOF
5450                 for cf_data in 1 2 3
5451                 do
5452                         ${MAKE:-make} always DATA=$cf_data
5453                         ${MAKE:-make} once   DATA=$cf_data
5454                         ${MAKE:-make} -t always once
5455                         if test -f always ; then
5456                                 echo "no (case 1)" > ../conftest.tmp
5457                         elif test ! -f always.out ; then
5458                                 echo "no (case 2)" > ../conftest.tmp
5459                         elif test ! -f once.out ; then
5460                                 echo "no (case 3)" > ../conftest.tmp
5461                         elif ! cmp -s always.out once.out ; then
5462                                 echo "no (case 4)" > ../conftest.tmp
5463                                 diff always.out once.out
5464                         else
5465                                 cf_check="`cat always.out`"
5466                                 if test "x$cf_check" != "x$cf_data" ; then
5467                                         echo "no (case 5)" > ../conftest.tmp
5468                                 else
5469                                         echo yes > ../conftest.tmp
5470                                         rm -f ./*.out
5471                                         continue
5472                                 fi
5473                         fi
5474                         break
5475                 done
5476         ) >&AC_FD_CC 2>&1
5477         cf_cv_make_PHONY="`cat conftest.tmp`"
5478         rm -rf conftest*
5479 ])
5480 MAKE_NO_PHONY="#"
5481 MAKE_PHONY="#"
5482 test "x$cf_cv_make_PHONY" = xyes && MAKE_PHONY=
5483 test "x$cf_cv_make_PHONY" != xyes && MAKE_NO_PHONY=
5484 AC_SUBST(MAKE_NO_PHONY)
5485 AC_SUBST(MAKE_PHONY)
5486 ])dnl
5487 dnl ---------------------------------------------------------------------------
5488 dnl CF_MAKE_TAGS version: 6 updated: 2010/10/23 15:52:32
5489 dnl ------------
5490 dnl Generate tags/TAGS targets for makefiles.  Do not generate TAGS if we have
5491 dnl a monocase filesystem.
5492 AC_DEFUN([CF_MAKE_TAGS],[
5493 AC_REQUIRE([CF_MIXEDCASE_FILENAMES])
5494
5495 AC_CHECK_PROGS(CTAGS, exctags ctags)
5496 AC_CHECK_PROGS(ETAGS, exetags etags)
5497
5498 AC_CHECK_PROG(MAKE_LOWER_TAGS, ${CTAGS:-ctags}, yes, no)
5499
5500 if test "$cf_cv_mixedcase" = yes ; then
5501         AC_CHECK_PROG(MAKE_UPPER_TAGS, ${ETAGS:-etags}, yes, no)
5502 else
5503         MAKE_UPPER_TAGS=no
5504 fi
5505
5506 if test "$MAKE_UPPER_TAGS" = yes ; then
5507         MAKE_UPPER_TAGS=
5508 else
5509         MAKE_UPPER_TAGS="#"
5510 fi
5511
5512 if test "$MAKE_LOWER_TAGS" = yes ; then
5513         MAKE_LOWER_TAGS=
5514 else
5515         MAKE_LOWER_TAGS="#"
5516 fi
5517
5518 AC_SUBST(CTAGS)
5519 AC_SUBST(ETAGS)
5520
5521 AC_SUBST(MAKE_UPPER_TAGS)
5522 AC_SUBST(MAKE_LOWER_TAGS)
5523 ])dnl
5524 dnl ---------------------------------------------------------------------------
5525 dnl CF_MANPAGE_FORMAT version: 15 updated: 2021/09/04 06:35:04
5526 dnl -----------------
5527 dnl Option to allow user to override automatic configuration of manpage format.
5528 dnl There are several special cases:
5529 dnl
5530 dnl     gzip - man checks for, can display gzip'd files
5531 dnl     compress - man checks for, can display compressed files
5532 dnl     BSDI - files in the cat-directories are suffixed ".0"
5533 dnl     formatted - installer should format (put files in cat-directory)
5534 dnl     catonly - installer should only format, e.g., for a turnkey system.
5535 dnl
5536 dnl There are other configurations which this macro does not test, e.g., HPUX's
5537 dnl compressed manpages (but uncompressed manpages are fine, and HPUX's naming
5538 dnl convention would not match our use).
5539 AC_DEFUN([CF_MANPAGE_FORMAT],
5540 [
5541 AC_REQUIRE([CF_PATHSEP])
5542 AC_MSG_CHECKING(format of man-pages)
5543
5544 AC_ARG_WITH(manpage-format,
5545         [  --with-manpage-format   specify manpage-format: gzip/compress/BSDI/normal and
5546                           optionally formatted/catonly, e.g., gzip,formatted],
5547         [MANPAGE_FORMAT=$withval],
5548         [MANPAGE_FORMAT=unknown])
5549
5550 test -z "$MANPAGE_FORMAT" && MANPAGE_FORMAT=unknown
5551 MANPAGE_FORMAT=`echo "$MANPAGE_FORMAT" | sed -e 's/,/ /g'`
5552
5553 cf_unknown=
5554
5555 case "$MANPAGE_FORMAT" in
5556 (unknown)
5557         if test -z "$MANPATH" ; then
5558                 MANPATH="/usr/man:/usr/share/man"
5559         fi
5560
5561         # look for the 'date' man-page (it is most likely to be installed!)
5562         MANPAGE_FORMAT=
5563         cf_preform="no"
5564         cf_catonly="yes"
5565         cf_example="date"
5566
5567         IFS="${IFS:-    }"; ac_save_ifs="$IFS"; IFS="${IFS}${PATH_SEPARATOR}"
5568         for cf_dir in $MANPATH; do
5569                 test -z "$cf_dir" && cf_dir=/usr/man
5570                 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
5571                 do
5572                         cf_test=`echo "$cf_name" | sed -e 's/*//'`
5573                         if test "x$cf_test" = "x$cf_name" ; then
5574
5575                                 case "$cf_name" in
5576                                 (*.gz) MANPAGE_FORMAT="$MANPAGE_FORMAT gzip";;
5577                                 (*.Z)  MANPAGE_FORMAT="$MANPAGE_FORMAT compress";;
5578                                 (*.0)  MANPAGE_FORMAT="$MANPAGE_FORMAT BSDI";;
5579                                 (*)    MANPAGE_FORMAT="$MANPAGE_FORMAT normal";;
5580                                 esac
5581
5582                                 case "$cf_name" in
5583                                 ($cf_dir/man*)
5584                                         cf_catonly=no
5585                                         ;;
5586                                 ($cf_dir/cat*)
5587                                         cf_preform=yes
5588                                         ;;
5589                                 esac
5590                                 break
5591                         fi
5592
5593                         # if we found a match in either man* or cat*, stop looking
5594                         if test -n "$MANPAGE_FORMAT" ; then
5595                                 cf_found=no
5596                                 test "$cf_preform" = yes && MANPAGE_FORMAT="$MANPAGE_FORMAT formatted"
5597                                 test "$cf_catonly" = yes && MANPAGE_FORMAT="$MANPAGE_FORMAT catonly"
5598                                 case "$cf_name" in
5599                                 ($cf_dir/cat*)
5600                                         cf_found=yes
5601                                         ;;
5602                                 esac
5603                                 test "$cf_found" = yes && break
5604                         fi
5605                 done
5606                 # only check the first directory in $MANPATH where we find manpages
5607                 if test -n "$MANPAGE_FORMAT" ; then
5608                         break
5609                 fi
5610         done
5611         # if we did not find the example, just assume it is normal
5612         test -z "$MANPAGE_FORMAT" && MANPAGE_FORMAT=normal
5613         IFS="$ac_save_ifs"
5614         ;;
5615 (*)
5616         for cf_option in $MANPAGE_FORMAT; do
5617         case "$cf_option" in
5618         (gzip|compress|BSDI|normal|formatted|catonly)
5619                 ;;
5620         (*)
5621                 cf_unknown="$cf_unknown $cf_option"
5622                 ;;
5623         esac
5624         done
5625         ;;
5626 esac
5627
5628 AC_MSG_RESULT($MANPAGE_FORMAT)
5629 if test -n "$cf_unknown" ; then
5630         AC_MSG_WARN(Unexpected manpage-format $cf_unknown)
5631 fi
5632 ])dnl
5633 dnl ---------------------------------------------------------------------------
5634 dnl CF_MANPAGE_RENAMES version: 12 updated: 2021/01/01 16:53:59
5635 dnl ------------------
5636 dnl The Debian people have their own naming convention for manpages.  This
5637 dnl option lets us override the name of the file containing renaming, or
5638 dnl disable it altogether.
5639 AC_DEFUN([CF_MANPAGE_RENAMES],
5640 [
5641 AC_MSG_CHECKING(for manpage renaming)
5642
5643 AC_ARG_WITH(manpage-renames,
5644         [  --with-manpage-renames  specify manpage-renaming],
5645         [MANPAGE_RENAMES=$withval],
5646         [MANPAGE_RENAMES=yes])
5647
5648 case ".$MANPAGE_RENAMES" in
5649 (.no)
5650         ;;
5651 (.|.yes)
5652         # Debian 'man' program?
5653         if test -f /etc/debian_version ; then
5654                 MANPAGE_RENAMES=`cd "$srcdir" && pwd`/man/man_db.renames
5655         else
5656                 MANPAGE_RENAMES=no
5657         fi
5658         ;;
5659 esac
5660
5661 if test "$MANPAGE_RENAMES" != no ; then
5662         if test -f "$srcdir/man/$MANPAGE_RENAMES" ; then
5663                 MANPAGE_RENAMES=`cd "$srcdir/man" && pwd`/$MANPAGE_RENAMES
5664         elif test ! -f "$MANPAGE_RENAMES" ; then
5665                 AC_MSG_ERROR(not a filename: $MANPAGE_RENAMES)
5666         fi
5667
5668         test ! -d man && mkdir man
5669
5670         # Construct a sed-script to perform renaming within man-pages
5671         if test -n "$MANPAGE_RENAMES" ; then
5672                 test ! -d man && mkdir man
5673                 $SHELL "$srcdir/man/make_sed.sh" "$MANPAGE_RENAMES" >./edit_man.sed
5674         fi
5675 fi
5676
5677 AC_MSG_RESULT($MANPAGE_RENAMES)
5678 AC_SUBST(MANPAGE_RENAMES)
5679 ])dnl
5680 dnl ---------------------------------------------------------------------------
5681 dnl CF_MANPAGE_SYMLINKS version: 6 updated: 2015/04/17 21:13:04
5682 dnl -------------------
5683 dnl Some people expect each tool to make all aliases for manpages in the
5684 dnl man-directory.  This accommodates the older, less-capable implementations
5685 dnl of 'man', and is optional.
5686 AC_DEFUN([CF_MANPAGE_SYMLINKS],
5687 [
5688 AC_MSG_CHECKING(if manpage aliases will be installed)
5689
5690 AC_ARG_WITH(manpage-aliases,
5691         [  --with-manpage-aliases  specify manpage-aliases using .so],
5692         [MANPAGE_ALIASES=$withval],
5693         [MANPAGE_ALIASES=yes])
5694
5695 AC_MSG_RESULT($MANPAGE_ALIASES)
5696
5697 case "x$LN_S" in
5698 (xln*)
5699         cf_use_symlinks=yes
5700         ;;
5701 (*)
5702         cf_use_symlinks=no
5703         ;;
5704 esac
5705
5706 MANPAGE_SYMLINKS=no
5707 if test "$MANPAGE_ALIASES" = yes ; then
5708 AC_MSG_CHECKING(if manpage symlinks should be used)
5709
5710 AC_ARG_WITH(manpage-symlinks,
5711         [  --with-manpage-symlinks specify manpage-aliases using symlinks],
5712         [MANPAGE_SYMLINKS=$withval],
5713         [MANPAGE_SYMLINKS=$cf_use_symlinks])
5714
5715 if test "$$cf_use_symlinks" = no; then
5716 if test "$MANPAGE_SYMLINKS" = yes ; then
5717         AC_MSG_WARN(cannot make symlinks, will use .so files)
5718         MANPAGE_SYMLINKS=no
5719 fi
5720 fi
5721
5722 AC_MSG_RESULT($MANPAGE_SYMLINKS)
5723 fi
5724
5725 ])dnl
5726 dnl ---------------------------------------------------------------------------
5727 dnl CF_MANPAGE_TBL version: 3 updated: 2002/01/19 22:51:32
5728 dnl --------------
5729 dnl This option causes manpages to be run through tbl(1) to generate tables
5730 dnl correctly.
5731 AC_DEFUN([CF_MANPAGE_TBL],
5732 [
5733 AC_MSG_CHECKING(for manpage tbl)
5734
5735 AC_ARG_WITH(manpage-tbl,
5736         [  --with-manpage-tbl      specify manpage processing with tbl],
5737         [MANPAGE_TBL=$withval],
5738         [MANPAGE_TBL=no])
5739
5740 AC_MSG_RESULT($MANPAGE_TBL)
5741 ])dnl
5742 dnl ---------------------------------------------------------------------------
5743 dnl CF_MAN_PAGES version: 52 updated: 2022/02/05 12:31:08
5744 dnl ------------
5745 dnl Try to determine if the man-pages on the system are compressed, and if
5746 dnl so, what format is used.  Use this information to construct a script that
5747 dnl will install man-pages.
5748 AC_DEFUN([CF_MAN_PAGES],
5749 [
5750 CF_HELP_MESSAGE(Options to Specify How Manpages are Installed:)
5751 CF_MANPAGE_FORMAT
5752 CF_MANPAGE_RENAMES
5753 CF_MANPAGE_SYMLINKS
5754 CF_MANPAGE_TBL
5755
5756 if test "$prefix" = "NONE" ; then
5757         cf_prefix="$ac_default_prefix"
5758 else
5759         cf_prefix="$prefix"
5760 fi
5761
5762 case "$MANPAGE_FORMAT" in
5763 (*catonly*)
5764         cf_format=yes
5765         cf_inboth=no
5766         ;;
5767 (*formatted*)
5768         cf_format=yes
5769         cf_inboth=yes
5770         ;;
5771 (*)
5772         cf_format=no
5773         cf_inboth=no
5774         ;;
5775 esac
5776
5777 test ! -d man && mkdir man
5778
5779 cf_so_strip=
5780 cf_compress=
5781 case "$MANPAGE_FORMAT" in
5782 (*compress*)
5783         cf_so_strip="Z"
5784         cf_compress=compress
5785         ;;
5786 (*gzip*)
5787         cf_so_strip="gz"
5788         cf_compress=gzip
5789         ;;
5790 esac
5791
5792 cf_edit_man=./edit_man.sh
5793 cf_man_alias=`pwd`/man_alias.sed
5794
5795 cat >$cf_edit_man <<CF_EOF
5796 #! $SHELL
5797 # this script is generated by the configure-script CF_MAN_PAGES macro.
5798
5799 prefix="$cf_prefix"
5800 datarootdir="$datarootdir"
5801 datadir="$datadir"
5802
5803 NCURSES_MAJOR="$NCURSES_MAJOR"
5804 NCURSES_MINOR="$NCURSES_MINOR"
5805 NCURSES_PATCH="$NCURSES_PATCH"
5806
5807 NCURSES_OSPEED="$NCURSES_OSPEED"
5808 TERMINFO="$TERMINFO"
5809
5810 INSTALL="$INSTALL"
5811 INSTALL_DATA="$INSTALL_DATA"
5812
5813 transform="$program_transform_name"
5814
5815 TMP=\${TMPDIR:=/tmp}/man\$\$
5816 trap "rm -f \$TMP; exit 1" 1 2 3 15
5817 trap "rm -f \$TMP" 0
5818
5819 form=\[$]1
5820 shift || exit 1
5821
5822 verb=\[$]1
5823 shift || exit 1
5824
5825 mandir=\[$]1
5826 shift || exit 1
5827
5828 srcdir=\[$]1
5829 top_srcdir=\[$]srcdir/..
5830 shift || exit 1
5831
5832 if test "\$form" = normal ; then
5833         if test "$cf_format" = yes ; then
5834         if test "$cf_inboth" = no ; then
5835                 $SHELL "\[$]0" format "\$verb" "\$mandir" "\$srcdir" "\[$]@"
5836                 exit $?
5837         fi
5838         fi
5839         cf_subdir=\$mandir/man
5840         cf_tables=$MANPAGE_TBL
5841 else
5842         cf_subdir=\$mandir/cat
5843         cf_tables=yes
5844 fi
5845
5846 # process the list of source-files
5847 for i in "\[$]@" ; do
5848 case \$i in
5849 (*.orig|*.rej) ;;
5850 (*.[[0-9]]*)
5851         section=\`expr "\$i" : '.*\\.\\([[0-9]]\\)[[xm]]*'\`;
5852         if test "\$verb" = installing ; then
5853         if test ! -d "\$cf_subdir\${section}" ; then
5854                 mkdir -p "\$cf_subdir\$section"
5855         fi
5856         fi
5857
5858         # replace variables in man page
5859         if test ! -f "$cf_man_alias" ; then
5860 cat >>$cf_man_alias <<-CF_EOF2
5861                 s,@DATADIR@,\$datadir,g
5862                 s,@TERMINFO@,\${TERMINFO:="no default value"},g
5863                 s,@TERMINFO_DIRS@,\${TERMINFO_DIRS:="no default value"},g
5864                 s,@NCURSES_MAJOR@,\${NCURSES_MAJOR:="no default value"},g
5865                 s,@NCURSES_MINOR@,\${NCURSES_MINOR:="no default value"},g
5866                 s,@NCURSES_PATCH@,\${NCURSES_PATCH:="no default value"},g
5867                 s,@NCURSES_OSPEED@,\${NCURSES_OSPEED:="no default value"},g
5868 CF_EOF
5869         ifelse($1,,,[
5870         for cf_name in $1
5871         do
5872                 cf_NAME=`echo "$cf_name" | sed y%abcdefghijklmnopqrstuvwxyz./-%ABCDEFGHIJKLMNOPQRSTUVWXYZ___%`
5873                 cf_name=`echo "$cf_name" | sed "$program_transform_name"`
5874 cat >>$cf_edit_man <<-CF_EOF
5875                 s,@$cf_NAME@,$cf_name,g
5876 CF_EOF
5877         done
5878         ])
5879 cat >>$cf_edit_man <<CF_EOF
5880 CF_EOF2
5881                 echo "...made $cf_man_alias"
5882         fi
5883
5884         aliases=
5885         cf_source=\`basename "\$i"\`
5886         inalias=\$cf_source
5887         test ! -f "\$inalias" && inalias="\$srcdir/\$inalias"
5888         if test ! -f "\$inalias" ; then
5889                 echo ".. skipped \$cf_source"
5890                 continue
5891         fi
5892 CF_EOF
5893
5894 if test "$MANPAGE_ALIASES" != no ; then
5895 cat >>$cf_edit_man <<CF_EOF
5896         nCurses=ignore.3x
5897         test "$with_curses_h" = yes && nCurses=ncurses.3x
5898         aliases=\`sed -f "\$top_srcdir/man/manlinks.sed" "\$inalias" |sed -f "$cf_man_alias" | sort -u; test "\$inalias" = "\$nCurses" && echo curses\`
5899 CF_EOF
5900 fi
5901
5902 if test "$MANPAGE_RENAMES" = no ; then
5903 cat >>$cf_edit_man <<CF_EOF
5904         # perform program transformations for section 1 man pages
5905         if test \$section = 1 ; then
5906                 cf_target=\$cf_subdir\${section}/\`echo \$cf_source|sed "\${transform}"\`
5907         else
5908                 cf_target=\$cf_subdir\${section}/\$cf_source
5909         fi
5910 CF_EOF
5911 else
5912 cat >>$cf_edit_man <<CF_EOF
5913         cf_target=\`grep "^\$cf_source" $MANPAGE_RENAMES | $AWK '{print \[$]2}'\`
5914         if test -z "\$cf_target" ; then
5915                 echo "? missing rename for \$cf_source"
5916                 cf_target="\$cf_source"
5917         fi
5918         cf_target="\$cf_subdir\${section}/\${cf_target}"
5919
5920 CF_EOF
5921 fi
5922
5923 cat >>$cf_edit_man <<CF_EOF
5924         sed     -f "$cf_man_alias" \\
5925 CF_EOF
5926
5927 if test -f "$MANPAGE_RENAMES" ; then
5928 cat >>$cf_edit_man <<CF_EOF
5929                 < "\$i" | sed -f `pwd`/edit_man.sed >\$TMP
5930 CF_EOF
5931 else
5932 cat >>$cf_edit_man <<CF_EOF
5933                 < "\$i" >\$TMP
5934 CF_EOF
5935 fi
5936
5937 cat >>$cf_edit_man <<CF_EOF
5938 if test \$cf_tables = yes ; then
5939         tbl \$TMP >\$TMP.out
5940         mv \$TMP.out \$TMP
5941 fi
5942 CF_EOF
5943
5944 if test "$with_overwrite" != yes ; then
5945 cat >>$cf_edit_man <<CF_EOF
5946         sed -e "/\\#[    ]*include/s,<curses.h,<ncurses$LIB_SUFFIX/curses.h," < \$TMP >\$TMP.out
5947         mv \$TMP.out \$TMP
5948 CF_EOF
5949 fi
5950
5951 if test "$with_curses_h" != yes ; then
5952 cat >>$cf_edit_man <<CF_EOF
5953         sed -e "/\\#[    ]*include/s,curses.h,ncurses.h," < \$TMP >\$TMP.out
5954         mv \$TMP.out \$TMP
5955 CF_EOF
5956 fi
5957
5958 cat >>$cf_edit_man <<CF_EOF
5959         if test "\$form" = format ; then
5960                 nroff -man \$TMP >\$TMP.out
5961                 mv \$TMP.out \$TMP
5962         fi
5963 CF_EOF
5964
5965 if test -n "$cf_compress" ; then
5966 cat >>$cf_edit_man <<CF_EOF
5967         if test "\$verb" = installing ; then
5968         if ( "$cf_compress" -f \$TMP )
5969         then
5970                 mv \$TMP.$cf_so_strip \$TMP
5971         fi
5972         fi
5973         cf_target="\$cf_target.$cf_so_strip"
5974 CF_EOF
5975 fi
5976
5977 case "$MANPAGE_FORMAT" in
5978 (*BSDI*)
5979 cat >>$cf_edit_man <<CF_EOF
5980         if test "\$form" = format ; then
5981                 # BSDI installs only .0 suffixes in the cat directories
5982                 cf_target="\`echo \$cf_target|sed -e 's/\\.[[1-9]]\\+[[a-z]]*/.0/'\`"
5983         fi
5984 CF_EOF
5985   ;;
5986 esac
5987
5988 cat >>$cf_edit_man <<CF_EOF
5989         suffix=\`basename "\$cf_target" | sed -e 's%^[[^.]]*%%'\`
5990         if test "\$verb" = installing ; then
5991                 echo "\$verb \$cf_target"
5992                 \$INSTALL_DATA \$TMP "\$cf_target"
5993                 test -d "\$cf_subdir\${section}" &&
5994                 test -n "\$aliases" && (
5995                         cd "\$cf_subdir\${section}" && (
5996                                 cf_source=\`echo "\$cf_target" |sed -e 's%^.*/\\([[^/]][[^/]]*/[[^/]][[^/]]*$\\)%\\1%'\`
5997                                 test -n "$cf_so_strip" && cf_source=\`echo "\$cf_source" |sed -e 's%\\.$cf_so_strip\$%%'\`
5998                                 cf_target=\`basename "\$cf_target"\`
5999                                 for cf_alias in \$aliases
6000                                 do
6001                                         if test "\$section" = 1 ; then
6002                                                 cf_alias=\`echo "\$cf_alias" |sed "\${transform}"\`
6003                                         fi
6004
6005                                         if test "$MANPAGE_SYMLINKS" = yes ; then
6006                                                 if test -f "\$cf_alias\${suffix}" ; then
6007                                                         if ( cmp -s "\$cf_target" "\$cf_alias\${suffix}" )
6008                                                         then
6009                                                                 continue
6010                                                         fi
6011                                                 fi
6012                                                 echo ".. \$verb alias \$cf_alias\${suffix}"
6013 CF_EOF
6014 case "x$LN_S" in
6015 (*-f)
6016 cat >>$cf_edit_man <<CF_EOF
6017                                                 $LN_S "\$cf_target" "\$cf_alias\${suffix}"
6018 CF_EOF
6019         ;;
6020 (*)
6021 cat >>$cf_edit_man <<CF_EOF
6022                                                 rm -f "\$cf_alias\${suffix}"
6023                                                 $LN_S "\$cf_target" "\$cf_alias\${suffix}"
6024 CF_EOF
6025         ;;
6026 esac
6027 cat >>$cf_edit_man <<CF_EOF
6028                                         elif test "\$cf_target" != "\$cf_alias\${suffix}" ; then
6029                                                 echo ".so \$cf_source" >\$TMP
6030 CF_EOF
6031 if test -n "$cf_compress" ; then
6032 cat >>$cf_edit_man <<CF_EOF
6033                                                 if test -n "$cf_so_strip" ; then
6034                                                         "$cf_compress" -f \$TMP
6035                                                         mv \$TMP.$cf_so_strip \$TMP
6036                                                 fi
6037 CF_EOF
6038 fi
6039 cat >>$cf_edit_man <<CF_EOF
6040                                                 echo ".. \$verb alias \$cf_alias\${suffix}"
6041                                                 rm -f "\$cf_alias\${suffix}"
6042                                                 \$INSTALL_DATA \$TMP "\$cf_alias\${suffix}"
6043                                         fi
6044                                 done
6045                         )
6046                 )
6047         elif test "\$verb" = removing ; then
6048                 test -f "\$cf_target" && (
6049                         echo "\$verb \$cf_target"
6050                         rm -f "\$cf_target"
6051                 )
6052                 test -d "\$cf_subdir\${section}" &&
6053                 test -n "\$aliases" && (
6054                         cd "\$cf_subdir\${section}" && (
6055                                 for cf_alias in \$aliases
6056                                 do
6057                                         if test "\$section" = 1 ; then
6058                                                 cf_alias=\`echo "\$cf_alias" |sed "\${transform}"\`
6059                                         fi
6060
6061                                         echo ".. \$verb alias \$cf_alias\${suffix}"
6062                                         rm -f "\$cf_alias\${suffix}"
6063                                 done
6064                         )
6065                 )
6066         else
6067 #               echo ".hy 0"
6068                 cat \$TMP
6069         fi
6070         ;;
6071 esac
6072 done
6073
6074 if test "$cf_inboth" = yes ; then
6075 if test "\$form" != format ; then
6076         $SHELL "\[$]0" format "\$verb" "\$mandir" "\$srcdir" "\[$]@"
6077 fi
6078 fi
6079
6080 exit 0
6081 CF_EOF
6082 chmod 755 "$cf_edit_man"
6083
6084 ])dnl
6085 dnl ---------------------------------------------------------------------------
6086 dnl CF_MAP_LIB_BASENAME version: 2 updated: 2021/01/02 17:09:14
6087 dnl -------------------
6088 dnl Convert a default-libname to the actual one used via CF_WITH_LIB_BASENAME.
6089 dnl
6090 dnl $1 = variable to set
6091 dnl $2 = default-libname
6092 AC_DEFUN([CF_MAP_LIB_BASENAME],[
6093 CF_UPPER(cf_map_lib_basename,$2)
6094 eval $1="\$${cf_map_lib_basename}_NAME"
6095 ])dnl
6096 dnl ---------------------------------------------------------------------------
6097 dnl CF_MATH_LIB version: 11 updated: 2022/07/27 19:01:48
6098 dnl -----------
6099 dnl Checks for libraries.  At least one UNIX system, Apple Macintosh
6100 dnl Rhapsody 5.5, does not have -lm.  We cannot use the simpler
6101 dnl AC_CHECK_LIB(m,sin), because that fails for C++.
6102 AC_DEFUN([CF_MATH_LIB],
6103 [
6104 AC_CACHE_CHECK(if -lm needed for math functions,
6105         cf_cv_need_libm,[
6106         AC_TRY_LINK([
6107                 #include <stdio.h>
6108                 #include <stdlib.h>
6109                 #include <math.h>
6110         ],
6111         [double x = rand(); printf("result = %g\\n", ]ifelse([$2],,sin(x),$2)[)],
6112         [cf_cv_need_libm=no],
6113         [cf_cv_need_libm=yes])])
6114
6115 if test "$cf_cv_need_libm" = yes
6116 then
6117
6118         cf_save_LIBS="$LIBS"
6119         LIBS="$LIBS -lm"
6120         AC_CACHE_CHECK(if -lm is available for math functions,
6121         cf_cv_have_libm,[
6122         AC_TRY_LINK([
6123                 #include <stdio.h>
6124                 #include <stdlib.h>
6125                 #include <math.h>
6126         ],
6127         [double x = rand(); printf("result = %g\\n", ]ifelse([$2],,sin(x),$2)[)],
6128         [cf_cv_have_libm=yes],
6129         [cf_cv_have_libm=no])])
6130         LIBS="$cf_save_LIBS"
6131
6132         if test "$cf_cv_have_libm" = yes
6133         then
6134                 ifelse($1,,[CF_ADD_LIB(m)],[$1=-lm])
6135         fi
6136 else
6137         cf_cv_have_libm=yes
6138 fi
6139
6140 if test "$cf_cv_have_libm" = yes
6141 then
6142         AC_DEFINE(HAVE_MATH_FUNCS,1,[Define to 1 if math functions are available])
6143 fi
6144 ])
6145 dnl ---------------------------------------------------------------------------
6146 dnl CF_MIXEDCASE_FILENAMES version: 9 updated: 2021/01/01 16:53:59
6147 dnl ----------------------
6148 dnl Check if the file-system supports mixed-case filenames.  If we're able to
6149 dnl create a lowercase name and see it as uppercase, it doesn't support that.
6150 AC_DEFUN([CF_MIXEDCASE_FILENAMES],
6151 [
6152 AC_CACHE_CHECK(if filesystem supports mixed-case filenames,cf_cv_mixedcase,[
6153 if test "$cross_compiling" = yes ; then
6154         case "$target_alias" in
6155         (*-os2-emx*|*-msdosdjgpp*|*-cygwin*|*-msys*|*-mingw*|*-uwin*|darwin*)
6156                 cf_cv_mixedcase=no
6157                 ;;
6158         (*)
6159                 cf_cv_mixedcase=yes
6160                 ;;
6161         esac
6162 else
6163         rm -f conftest CONFTEST
6164         echo test >conftest
6165         if test -f CONFTEST ; then
6166                 cf_cv_mixedcase=no
6167         else
6168                 cf_cv_mixedcase=yes
6169         fi
6170         rm -f conftest CONFTEST
6171 fi
6172 ])
6173 test "$cf_cv_mixedcase" = yes && AC_DEFINE(MIXEDCASE_FILENAMES,1,[Define to 1 if filesystem supports mixed-case filenames.])
6174 ])dnl
6175 dnl ---------------------------------------------------------------------------
6176 dnl CF_MKSTEMP version: 11 updated: 2021/01/01 13:31:04
6177 dnl ----------
6178 dnl Check for a working mkstemp.  This creates two files, checks that they are
6179 dnl successfully created and distinct (AmigaOS apparently fails on the last).
6180 AC_DEFUN([CF_MKSTEMP],[
6181 AC_CHECK_HEADERS( \
6182 unistd.h \
6183 )
6184 AC_CACHE_CHECK(for working mkstemp, cf_cv_func_mkstemp,[
6185 rm -rf ./conftest*
6186 AC_TRY_RUN([
6187 #include <sys/types.h>
6188 #ifdef HAVE_UNISTD_H
6189 #include <unistd.h>
6190 #endif
6191 #include <stdlib.h>
6192 #include <stdio.h>
6193 #include <string.h>
6194 #include <sys/stat.h>
6195 int main(void)
6196 {
6197         char *tmpl = "conftestXXXXXX";
6198         char name[2][80];
6199         int n;
6200         int result = 0;
6201         int fd;
6202         struct stat sb;
6203
6204         umask(077);
6205         for (n = 0; n < 2; ++n) {
6206                 strcpy(name[n], tmpl);
6207                 if ((fd = mkstemp(name[n])) >= 0) {
6208                         if (!strcmp(name[n], tmpl)
6209                          || stat(name[n], &sb) != 0
6210                          || (sb.st_mode & S_IFMT) != S_IFREG
6211                          || (sb.st_mode & 077) != 0) {
6212                                 result = 1;
6213                         }
6214                         close(fd);
6215                 }
6216         }
6217         if (result == 0
6218          && !strcmp(name[0], name[1]))
6219                 result = 1;
6220         ${cf_cv_main_return:-return}(result);
6221 }
6222 ],[cf_cv_func_mkstemp=yes
6223 ],[cf_cv_func_mkstemp=no
6224 ],[cf_cv_func_mkstemp=maybe])
6225 ])
6226 if test "x$cf_cv_func_mkstemp" = xmaybe ; then
6227         AC_CHECK_FUNC(mkstemp)
6228 fi
6229 if test "x$cf_cv_func_mkstemp" = xyes || test "x$ac_cv_func_mkstemp" = xyes ; then
6230         AC_DEFINE(HAVE_MKSTEMP,1,[Define to 1 if mkstemp() is available and working.])
6231 fi
6232 ])dnl
6233 dnl ---------------------------------------------------------------------------
6234 dnl CF_MSG_LOG version: 5 updated: 2010/10/23 15:52:32
6235 dnl ----------
6236 dnl Write a debug message to config.log, along with the line number in the
6237 dnl configure script.
6238 AC_DEFUN([CF_MSG_LOG],[
6239 echo "${as_me:-configure}:__oline__: testing $* ..." 1>&AC_FD_CC
6240 ])dnl
6241 dnl ---------------------------------------------------------------------------
6242 dnl CF_NCURSES_ABI_6 version: 4 updated: 2021/01/01 13:31:04
6243 dnl ----------------
6244 dnl Set ncurses' ABI to 6 unless overridden by explicit configure option, and
6245 dnl warn about this.
6246 AC_DEFUN([CF_NCURSES_ABI_6],[
6247 if test "${with_abi_version+set}" != set; then
6248         case "$cf_cv_rel_version" in
6249         (5.*)
6250                 cf_cv_rel_version=6.0
6251                 cf_cv_abi_version=6
6252                 AC_MSG_WARN(overriding ABI version to $cf_cv_abi_version)
6253                 ;;
6254         esac
6255 fi
6256 ])dnl
6257 dnl ---------------------------------------------------------------------------
6258 dnl CF_NCURSES_WITH_ABI_VERSION version: 3 updated: 2021/01/01 13:31:04
6259 dnl ---------------------------
6260 dnl Allow ncurses's ABI to be overridden.  Generally this happens when a
6261 dnl packager has incremented the ABI past that used in the original package,
6262 dnl and wishes to keep doing this.
6263 dnl
6264 dnl $1 is the package name, if any, to derive a corresponding {package}_ABI
6265 dnl symbol.
6266 AC_DEFUN([CF_NCURSES_WITH_ABI_VERSION],[
6267 CF_WITH_ABI_VERSION($1)
6268 if test "x$cf_cv_abi_version" != "x$with_abi_version"
6269 then
6270         case "$cf_cv_rel_version" in
6271         (5.*)
6272                 cf_cv_rel_version=$with_abi_version.0
6273                 ;;
6274         esac
6275 fi
6276 ])dnl
6277 dnl ---------------------------------------------------------------------------
6278 dnl CF_NO_LEAKS_OPTION version: 9 updated: 2021/06/13 19:45:41
6279 dnl ------------------
6280 dnl see CF_WITH_NO_LEAKS
6281 dnl
6282 dnl $1 = option/name
6283 dnl $2 = help-text
6284 dnl $3 = symbol to define if the option is set
6285 dnl $4 = additional actions to take if the option is set
6286 AC_DEFUN([CF_NO_LEAKS_OPTION],[
6287 AC_MSG_CHECKING(if you want to use $1 for testing)
6288 AC_ARG_WITH($1,
6289         [$2],
6290         [case "x$withval" in
6291         (x|xno) ;;
6292         (*)
6293                 : "${with_cflags:=-g}"
6294                 : "${enable_leaks:=no}"
6295                 with_$1=yes
6296                 AC_DEFINE_UNQUOTED($3,1,"Define to 1 if you want to use $1 for testing.")ifelse([$4],,[
6297          $4
6298 ])
6299                 ;;
6300         esac],
6301         [with_$1=])
6302 AC_MSG_RESULT(${with_$1:-no})
6303
6304 case ".$with_cflags" in
6305 (.*-g*)
6306         case .$CFLAGS in
6307         (.*-g*)
6308                 ;;
6309         (*)
6310                 CF_ADD_CFLAGS([-g])
6311                 ;;
6312         esac
6313         ;;
6314 esac
6315 ])dnl
6316 dnl ---------------------------------------------------------------------------
6317 dnl CF_NUMBER_SYNTAX version: 2 updated: 2015/04/17 21:13:04
6318 dnl ----------------
6319 dnl Check if the given variable is a number.  If not, report an error.
6320 dnl $1 is the variable
6321 dnl $2 is the message
6322 AC_DEFUN([CF_NUMBER_SYNTAX],[
6323 if test -n "$1" ; then
6324   case $1 in
6325   ([[0-9]]*)
6326         ;;
6327   (*)
6328         AC_MSG_ERROR($2 is not a number: $1)
6329         ;;
6330   esac
6331 else
6332   AC_MSG_ERROR($2 value is empty)
6333 fi
6334 ])dnl
6335 dnl ---------------------------------------------------------------------------
6336 dnl CF_OBJ_SUBDIR version: 8 updated: 2021/01/01 13:31:04
6337 dnl -------------
6338 dnl Compute the object-directory name from the given model name
6339 AC_DEFUN([CF_OBJ_SUBDIR],
6340 [
6341         case $1 in
6342         (libtool) $2='obj_lo'  ;;
6343         (normal)  $2='objects' ;;
6344         (debug)   $2='obj_g' ;;
6345         (profile) $2='obj_p' ;;
6346         (shared)
6347                 case "$cf_cv_system_name" in
6348                 (cygwin|msys)
6349                         $2='objects' ;;
6350                 (*)
6351                         $2='obj_s' ;;
6352                 esac
6353         esac
6354 ])dnl
6355 dnl ---------------------------------------------------------------------------
6356 dnl CF_PATHSEP version: 8 updated: 2021/01/01 13:31:04
6357 dnl ----------
6358 dnl Provide a value for the $PATH and similar separator (or amend the value
6359 dnl as provided in autoconf 2.5x).
6360 AC_DEFUN([CF_PATHSEP],
6361 [
6362         AC_MSG_CHECKING(for PATH separator)
6363         case "$cf_cv_system_name" in
6364         (os2*)  PATH_SEPARATOR=';'  ;;
6365         (*)     ${PATH_SEPARATOR:=':'}  ;;
6366         esac
6367 ifelse([$1],,,[$1=$PATH_SEPARATOR])
6368         AC_SUBST(PATH_SEPARATOR)
6369         AC_MSG_RESULT($PATH_SEPARATOR)
6370 ])dnl
6371 dnl ---------------------------------------------------------------------------
6372 dnl CF_PATH_PROG version: 12 updated: 2021/01/02 09:31:20
6373 dnl ------------
6374 dnl Check for a given program, defining corresponding symbol.
6375 dnl     $1 = environment variable, which is suffixed by "_PATH" in the #define.
6376 dnl     $2 = program name to find.
6377 dnl     $3 = optional list of additional program names to test.
6378 dnl $4 = $PATH
6379 dnl
6380 dnl If there is more than one token in the result, #define the remaining tokens
6381 dnl to $1_ARGS.  We need this for 'install' in particular.
6382 dnl
6383 dnl FIXME: we should allow this to be overridden by environment variables
6384 dnl
6385 AC_DEFUN([CF_PATH_PROG],[
6386 AC_REQUIRE([CF_PATHSEP])
6387 test -z "[$]$1" && $1="$2"
6388 AC_PATH_PROGS($1,[$]$1 $2 ifelse($3,,,$3),[$]$1, ifelse($4,,,$4))
6389
6390 cf_path_prog=""
6391 cf_path_args=""
6392 IFS="${IFS:-    }"; cf_save_ifs="$IFS"; IFS="${IFS}$PATH_SEPARATOR"
6393 for cf_temp in $ac_cv_path_$1
6394 do
6395         if test -z "$cf_path_prog" ; then
6396                 if test "$with_full_paths" = yes ; then
6397                         CF_PATH_SYNTAX(cf_temp,break)
6398                         cf_path_prog="$cf_temp"
6399                 else
6400                         cf_path_prog="`basename "$cf_temp"`"
6401                 fi
6402         elif test -z "$cf_path_args" ; then
6403                 cf_path_args="$cf_temp"
6404         else
6405                 cf_path_args="$cf_path_args $cf_temp"
6406         fi
6407 done
6408 IFS="$cf_save_ifs"
6409
6410 if test -n "$cf_path_prog" ; then
6411         CF_MSG_LOG(defining path for ${cf_path_prog})
6412         AC_DEFINE_UNQUOTED($1_PATH,"$cf_path_prog",Define to pathname $1)
6413         test -n "$cf_path_args" && AC_DEFINE_UNQUOTED($1_ARGS,"$cf_path_args",Define to provide args for $1)
6414 fi
6415 ])dnl
6416 dnl ---------------------------------------------------------------------------
6417 dnl CF_PATH_SYNTAX version: 18 updated: 2020/12/31 18:40:20
6418 dnl --------------
6419 dnl Check the argument to see that it looks like a pathname.  Rewrite it if it
6420 dnl begins with one of the prefix/exec_prefix variables, and then again if the
6421 dnl result begins with 'NONE'.  This is necessary to work around autoconf's
6422 dnl delayed evaluation of those symbols.
6423 AC_DEFUN([CF_PATH_SYNTAX],[
6424 if test "x$prefix" != xNONE; then
6425         cf_path_syntax="$prefix"
6426 else
6427         cf_path_syntax="$ac_default_prefix"
6428 fi
6429
6430 case ".[$]$1" in
6431 (.\[$]\(*\)*|.\'*\'*)
6432         ;;
6433 (..|./*|.\\*)
6434         ;;
6435 (.[[a-zA-Z]]:[[\\/]]*) # OS/2 EMX
6436         ;;
6437 (.\[$]\{*prefix\}*|.\[$]\{*dir\}*)
6438         eval $1="[$]$1"
6439         case ".[$]$1" in
6440         (.NONE/*)
6441                 $1=`echo "[$]$1" | sed -e s%NONE%$cf_path_syntax%`
6442                 ;;
6443         esac
6444         ;;
6445 (.no|.NONE/*)
6446         $1=`echo "[$]$1" | sed -e s%NONE%$cf_path_syntax%`
6447         ;;
6448 (*)
6449         ifelse([$2],,[AC_MSG_ERROR([expected a pathname, not \"[$]$1\"])],$2)
6450         ;;
6451 esac
6452 ])dnl
6453 dnl ---------------------------------------------------------------------------
6454 dnl CF_PKG_CONFIG version: 12 updated: 2021/10/10 20:18:09
6455 dnl -------------
6456 dnl Check for the package-config program, unless disabled by command-line.
6457 dnl
6458 dnl Sets $PKG_CONFIG to the pathname of the pkg-config program.
6459 AC_DEFUN([CF_PKG_CONFIG],
6460 [
6461 AC_MSG_CHECKING(if you want to use pkg-config)
6462 AC_ARG_WITH(pkg-config,
6463         [  --with-pkg-config{=path} enable/disable use of pkg-config],
6464         [cf_pkg_config=$withval],
6465         [cf_pkg_config=yes])
6466 AC_MSG_RESULT($cf_pkg_config)
6467
6468 case "$cf_pkg_config" in
6469 (no)
6470         PKG_CONFIG=none
6471         ;;
6472 (yes)
6473         CF_ACVERSION_CHECK(2.52,
6474                 [AC_PATH_TOOL(PKG_CONFIG, pkg-config, none)],
6475                 [AC_PATH_PROG(PKG_CONFIG, pkg-config, none)])
6476         ;;
6477 (*)
6478         PKG_CONFIG=$withval
6479         ;;
6480 esac
6481
6482 test -z "$PKG_CONFIG" && PKG_CONFIG=none
6483 if test "$PKG_CONFIG" != none ; then
6484         CF_PATH_SYNTAX(PKG_CONFIG)
6485 elif test "x$cf_pkg_config" != xno ; then
6486         AC_MSG_WARN(pkg-config is not installed)
6487 fi
6488
6489 AC_SUBST(PKG_CONFIG)
6490 ])dnl
6491 dnl ---------------------------------------------------------------------------
6492 dnl CF_POSIX_C_SOURCE version: 11 updated: 2018/12/31 20:46:17
6493 dnl -----------------
6494 dnl Define _POSIX_C_SOURCE to the given level, and _POSIX_SOURCE if needed.
6495 dnl
6496 dnl     POSIX.1-1990                            _POSIX_SOURCE
6497 dnl     POSIX.1-1990 and                        _POSIX_SOURCE and
6498 dnl             POSIX.2-1992 C-Language                 _POSIX_C_SOURCE=2
6499 dnl             Bindings Option
6500 dnl     POSIX.1b-1993                           _POSIX_C_SOURCE=199309L
6501 dnl     POSIX.1c-1996                           _POSIX_C_SOURCE=199506L
6502 dnl     X/Open 2000                             _POSIX_C_SOURCE=200112L
6503 dnl
6504 dnl Parameters:
6505 dnl     $1 is the nominal value for _POSIX_C_SOURCE
6506 AC_DEFUN([CF_POSIX_C_SOURCE],
6507 [AC_REQUIRE([CF_POSIX_VISIBLE])dnl
6508
6509 if test "$cf_cv_posix_visible" = no; then
6510
6511 cf_POSIX_C_SOURCE=ifelse([$1],,199506L,[$1])
6512
6513 cf_save_CFLAGS="$CFLAGS"
6514 cf_save_CPPFLAGS="$CPPFLAGS"
6515
6516 CF_REMOVE_DEFINE(cf_trim_CFLAGS,$cf_save_CFLAGS,_POSIX_C_SOURCE)
6517 CF_REMOVE_DEFINE(cf_trim_CPPFLAGS,$cf_save_CPPFLAGS,_POSIX_C_SOURCE)
6518
6519 AC_CACHE_CHECK(if we should define _POSIX_C_SOURCE,cf_cv_posix_c_source,[
6520         CF_MSG_LOG(if the symbol is already defined go no further)
6521         AC_TRY_COMPILE([#include <sys/types.h>],[
6522 #ifndef _POSIX_C_SOURCE
6523 make an error
6524 #endif],
6525         [cf_cv_posix_c_source=no],
6526         [cf_want_posix_source=no
6527          case .$cf_POSIX_C_SOURCE in
6528          (.[[12]]??*)
6529                 cf_cv_posix_c_source="-D_POSIX_C_SOURCE=$cf_POSIX_C_SOURCE"
6530                 ;;
6531          (.2)
6532                 cf_cv_posix_c_source="-D_POSIX_C_SOURCE=$cf_POSIX_C_SOURCE"
6533                 cf_want_posix_source=yes
6534                 ;;
6535          (.*)
6536                 cf_want_posix_source=yes
6537                 ;;
6538          esac
6539          if test "$cf_want_posix_source" = yes ; then
6540                 AC_TRY_COMPILE([#include <sys/types.h>],[
6541 #ifdef _POSIX_SOURCE
6542 make an error
6543 #endif],[],
6544                 cf_cv_posix_c_source="$cf_cv_posix_c_source -D_POSIX_SOURCE")
6545          fi
6546          CF_MSG_LOG(ifdef from value $cf_POSIX_C_SOURCE)
6547          CFLAGS="$cf_trim_CFLAGS"
6548          CPPFLAGS="$cf_trim_CPPFLAGS"
6549          CF_APPEND_TEXT(CPPFLAGS,$cf_cv_posix_c_source)
6550          CF_MSG_LOG(if the second compile does not leave our definition intact error)
6551          AC_TRY_COMPILE([#include <sys/types.h>],[
6552 #ifndef _POSIX_C_SOURCE
6553 make an error
6554 #endif],,
6555          [cf_cv_posix_c_source=no])
6556          CFLAGS="$cf_save_CFLAGS"
6557          CPPFLAGS="$cf_save_CPPFLAGS"
6558         ])
6559 ])
6560
6561 if test "$cf_cv_posix_c_source" != no ; then
6562         CFLAGS="$cf_trim_CFLAGS"
6563         CPPFLAGS="$cf_trim_CPPFLAGS"
6564         CF_ADD_CFLAGS($cf_cv_posix_c_source)
6565 fi
6566
6567 fi # cf_cv_posix_visible
6568
6569 ])dnl
6570 dnl ---------------------------------------------------------------------------
6571 dnl CF_POSIX_VISIBLE version: 1 updated: 2018/12/31 20:46:17
6572 dnl ----------------
6573 dnl POSIX documents test-macros which an application may set before any system
6574 dnl headers are included to make features available.
6575 dnl
6576 dnl Some BSD platforms (originally FreeBSD, but copied by a few others)
6577 dnl diverged from POSIX in 2002 by setting symbols which make all of the most
6578 dnl recent features visible in the system header files unless the application
6579 dnl overrides the corresponding test-macros.  Doing that introduces portability
6580 dnl problems.
6581 dnl
6582 dnl This macro makes a special check for the symbols used for this, to avoid a
6583 dnl conflicting definition.
6584 AC_DEFUN([CF_POSIX_VISIBLE],
6585 [
6586 AC_CACHE_CHECK(if the POSIX test-macros are already defined,cf_cv_posix_visible,[
6587 AC_TRY_COMPILE([#include <stdio.h>],[
6588 #if defined(__POSIX_VISIBLE) && ((__POSIX_VISIBLE - 0L) > 0) \
6589         && defined(__XSI_VISIBLE) && ((__XSI_VISIBLE - 0L) > 0) \
6590         && defined(__BSD_VISIBLE) && ((__BSD_VISIBLE - 0L) > 0) \
6591         && defined(__ISO_C_VISIBLE) && ((__ISO_C_VISIBLE - 0L) > 0)
6592 #error conflicting symbols found
6593 #endif
6594 ],[cf_cv_posix_visible=no],[cf_cv_posix_visible=yes])
6595 ])
6596 ])dnl
6597 dnl ---------------------------------------------------------------------------
6598 dnl CF_PREDEFINE version: 2 updated: 2010/05/26 16:44:57
6599 dnl ------------
6600 dnl Add definitions to CPPFLAGS to ensure they're predefined for all compiles.
6601 dnl
6602 dnl $1 = symbol to test
6603 dnl $2 = value (if any) to use for a predefinition
6604 AC_DEFUN([CF_PREDEFINE],
6605 [
6606 AC_MSG_CHECKING(if we must define $1)
6607 AC_TRY_COMPILE([#include <sys/types.h>
6608 ],[
6609 #ifndef $1
6610 make an error
6611 #endif],[cf_result=no],[cf_result=yes])
6612 AC_MSG_RESULT($cf_result)
6613
6614 if test "$cf_result" = yes ; then
6615         CPPFLAGS="$CPPFLAGS ifelse([$2],,-D$1,[-D$1=$2])"
6616 elif test "x$2" != "x" ; then
6617         AC_MSG_CHECKING(checking for compatible value versus $2)
6618         AC_TRY_COMPILE([#include <sys/types.h>
6619 ],[
6620 #if $1-$2 < 0
6621 make an error
6622 #endif],[cf_result=yes],[cf_result=no])
6623         AC_MSG_RESULT($cf_result)
6624         if test "$cf_result" = no ; then
6625                 # perhaps we can override it - try...
6626                 CPPFLAGS="$CPPFLAGS -D$1=$2"
6627         fi
6628 fi
6629 ])dnl
6630 dnl ---------------------------------------------------------------------------
6631 dnl CF_PRG_RULES version: 2 updated: 2021/01/01 13:31:04
6632 dnl ------------
6633 dnl Append definitions and rules for the given programs to the subdirectory
6634 dnl Makefiles, and the recursion rule for the top-level Makefile.
6635 dnl
6636 dnl parameters
6637 dnl     $1 = script to run
6638 dnl     $2 = list of subdirectories
6639 dnl
6640 dnl variables
6641 dnl     $AWK
6642 AC_DEFUN([CF_PRG_RULES],
6643 [
6644 for cf_dir in $2
6645 do
6646         if test ! -d "$srcdir/$cf_dir" ; then
6647                 continue
6648         elif test -f "$srcdir/$cf_dir/programs" ; then
6649                 $AWK -f $1 "$srcdir/$cf_dir/programs" >>$cf_dir/Makefile
6650         fi
6651 done
6652
6653 ])dnl
6654 dnl ---------------------------------------------------------------------------
6655 dnl CF_PROG_AR version: 1 updated: 2009/01/01 20:15:22
6656 dnl ----------
6657 dnl Check for archiver "ar".
6658 AC_DEFUN([CF_PROG_AR],[
6659 AC_CHECK_TOOL(AR, ar, ar)
6660 ])
6661 dnl ---------------------------------------------------------------------------
6662 dnl CF_PROG_AWK version: 1 updated: 2006/09/16 11:40:59
6663 dnl -----------
6664 dnl Check for awk, ensure that the check found something.
6665 AC_DEFUN([CF_PROG_AWK],
6666 [
6667 AC_PROG_AWK
6668 test -z "$AWK" && AC_MSG_ERROR(No awk program found)
6669 ])dnl
6670 dnl ---------------------------------------------------------------------------
6671 dnl CF_PROG_CC version: 5 updated: 2019/12/31 08:53:54
6672 dnl ----------
6673 dnl standard check for CC, plus followup sanity checks
6674 dnl $1 = optional parameter to pass to AC_PROG_CC to specify compiler name
6675 AC_DEFUN([CF_PROG_CC],[
6676 CF_ACVERSION_CHECK(2.53,
6677         [AC_MSG_WARN(this will incorrectly handle gnatgcc choice)
6678          AC_REQUIRE([AC_PROG_CC])],
6679         [])
6680 ifelse($1,,[AC_PROG_CC],[AC_PROG_CC($1)])
6681 CF_GCC_VERSION
6682 CF_ACVERSION_CHECK(2.52,
6683         [AC_PROG_CC_STDC],
6684         [CF_ANSI_CC_REQD])
6685 CF_CC_ENV_FLAGS
6686 ])dnl
6687 dnl ---------------------------------------------------------------------------
6688 dnl CF_PROG_CC_C_O version: 6 updated: 2021/01/01 13:31:04
6689 dnl --------------
6690 dnl Analogous to AC_PROG_CC_C_O, but more useful: tests only $CC, ensures that
6691 dnl the output file can be renamed, and allows for a shell variable that can
6692 dnl be used later.  The parameter is either CC or CXX.  The result is the
6693 dnl cache variable:
6694 dnl     $cf_cv_prog_CC_c_o
6695 dnl     $cf_cv_prog_CXX_c_o
6696 dnl
6697 dnl $1 = compiler
6698 dnl $2 = compiler options, if any
6699 AC_DEFUN([CF_PROG_CC_C_O],
6700 [AC_REQUIRE([AC_PROG_CC])dnl
6701 AC_MSG_CHECKING([whether [$]$1 understands -c and -o together])
6702 AC_CACHE_VAL(cf_cv_prog_$1_c_o,
6703 [
6704 cat > conftest.$ac_ext <<CF_EOF
6705 int main(void)
6706 {
6707         ${cf_cv_main_return:-return}(0);
6708 }
6709 CF_EOF
6710 # We do the test twice because some compilers refuse to overwrite an
6711 # existing .o file with -o, though they will create one.
6712 ac_try='[$]$1 $2 -c conftest.$ac_ext -o conftest2.$ac_objext >&AC_FD_CC'
6713 if AC_TRY_EVAL(ac_try) &&
6714   test -f conftest2.$ac_objext && AC_TRY_EVAL(ac_try);
6715 then
6716   eval cf_cv_prog_$1_c_o=yes
6717 else
6718   eval cf_cv_prog_$1_c_o=no
6719 fi
6720 rm -rf ./conftest*
6721 ])dnl
6722 if test "$cf_cv_prog_$1_c_o" = yes; then
6723   AC_MSG_RESULT([yes])
6724 else
6725   AC_MSG_RESULT([no])
6726 fi
6727 ])dnl
6728 dnl ---------------------------------------------------------------------------
6729 dnl CF_PROG_GNAT version: 12 updated: 2021/01/02 17:09:14
6730 dnl ------------
6731 dnl Check for gnat/gnatmake/etc, ensure that the toolset is complete.
6732 AC_DEFUN([CF_PROG_GNAT],[
6733 for cf_prog_gnat in gnat gnatmake gprconfig gprbuild
6734 do
6735         CF_UPPER(cf_upper_prog_gnat,${cf_prog_gnat})
6736
6737         unset ac_cv_path_cf_TEMP_gnat
6738         unset cf_TEMP_gnat
6739         AC_PATH_PROG(cf_TEMP_gnat,$cf_prog_gnat,no)
6740         eval "cf_cv_PATH_$cf_upper_prog_gnat=[$]ac_cv_path_cf_TEMP_gnat"
6741
6742         if test "x$cf_TEMP_gnat" != xno; then
6743                 unset cf_cv_gnat_version
6744                 unset cf_TEMP_gnat
6745                 CF_GNAT_VERSION(cf_TEMP_gnat,$cf_prog_gnat)
6746         fi
6747         eval "cf_cv_VERSION_$cf_upper_prog_gnat=[$]cf_TEMP_gnat"
6748
6749         unset cf_TEMP_gnat
6750         unset cf_cv_gnat_version
6751         unset ac_cv_path_cf_TEMP_gnat
6752 done
6753
6754 if test "x$cf_cv_VERSION_GNATMAKE" = "xno"; then
6755         cf_ada_make=
6756         cf_cv_prog_gnat_correct=no
6757 else
6758         cf_ada_make=gnatmake
6759         if test "x$cf_cv_VERSION_GPRCONFIG" = "xno"; then
6760                 # gprconfig is newer than gnatmake; we can continue...
6761                 cf_ada_config="##"
6762         else
6763                 rm -rf ./conftest* ./*~conftest*
6764                 if mkdir conftest.src
6765                 then
6766                         cf_ada_config=""
6767                         cd conftest.src
6768                         for cf_gprconfig in Ada C
6769                         do
6770                                 AC_MSG_CHECKING(for gprconfig name for $cf_gprconfig)
6771                                 if test "$cf_gprconfig" = C
6772                                 then
6773                                         for cf_gprconfig_param in \
6774                                                 "$cf_gprconfig,,,,GNATGCC" \
6775                                                 "$cf_gprconfig,,,,GCC" \
6776                                                 "$cf_gprconfig"
6777                                         do
6778                                                 cf_gprconfig_value=`echo s| gprconfig --config=$cf_gprconfig_param 2>&AC_FD_CC | ${AWK:-awk} '/^\*/{print [$]3;}' | head -n 1`
6779                                                 test -n "$cf_gprconfig_value" && break
6780                                         done
6781                                 else
6782                                         cf_gprconfig_param=$cf_gprconfig
6783                                         cf_gprconfig_value=`echo s| gprconfig --config=$cf_gprconfig_param 2>&AC_FD_CC | ${AWK:-awk} '/^\*/{print [$]3;}' | head -n 1`
6784                                 fi
6785                                 if test -n "$cf_gprconfig_value"
6786                                 then
6787                                         eval "cf_ada_config_[$]cf_gprconfig=[$]cf_gprconfig_value"
6788                                         AC_MSG_RESULT($cf_gprconfig_value)
6789                                 else
6790                                         AC_MSG_RESULT(missing)
6791                                         cf_ada_config="#"
6792                                         break
6793                                 fi
6794                         done
6795                         cd ..
6796                         rm -rf ./conftest* ./*~conftest*
6797                 fi
6798         fi
6799         if test "x$cf_ada_config" != "x#"
6800         then
6801                 CF_GNAT_VERSION
6802                 CF_CHECK_GNAT_VERSION
6803                 AC_CHECK_PROG(M4_exists, m4, yes, no)
6804                 if test "$ac_cv_prog_M4_exists" = no; then
6805                         cf_cv_prog_gnat_correct=no
6806                         AC_MSG_WARN(Ada95 binding required program m4 not found. Ada95 binding disabled)
6807                 fi
6808                 if test "$cf_cv_prog_gnat_correct" = yes; then
6809                         AC_MSG_CHECKING(if GNAT works)
6810                         CF_GNAT_TRY_RUN([procedure conftest;],
6811 [with Text_IO;
6812 with GNAT.OS_Lib;
6813 procedure conftest is
6814 begin
6815    Text_IO.Put ("Hello World");
6816    Text_IO.New_Line;
6817    GNAT.OS_Lib.OS_Exit (0);
6818 end conftest;],
6819 [cf_cv_prog_gnat_correct=yes],
6820 [cf_cv_prog_gnat_correct=no])
6821                         AC_MSG_RESULT($cf_cv_prog_gnat_correct)
6822                 fi
6823         else
6824                 cf_cv_prog_gnat_correct=no
6825         fi
6826 fi
6827
6828 AC_SUBST(cf_ada_make)
6829 AC_SUBST(cf_ada_config)
6830 AC_SUBST(cf_ada_config_Ada)
6831 AC_SUBST(cf_ada_config_C)
6832 ])dnl
6833 dnl ---------------------------------------------------------------------------
6834 dnl CF_PROG_INSTALL version: 10 updated: 2021/01/04 19:33:05
6835 dnl ---------------
6836 dnl Force $INSTALL to be an absolute-path.  Otherwise, edit_man.sh and the
6837 dnl misc/tabset install won't work properly.  Usually this happens only when
6838 dnl using the fallback mkinstalldirs script
6839 AC_DEFUN([CF_PROG_INSTALL],
6840 [AC_PROG_INSTALL
6841 case $INSTALL in
6842 (/*)
6843         ;;
6844 (*)
6845         CF_DIRNAME(cf_dir,$INSTALL)
6846         test -z "$cf_dir" && cf_dir=.
6847         INSTALL="`cd \"$cf_dir\" && pwd`"/"`echo "$INSTALL" | sed -e 's%^.*/%%'`"
6848         ;;
6849 esac
6850 ])dnl
6851 dnl ---------------------------------------------------------------------------
6852 dnl CF_PROG_LDCONFIG version: 5 updated: 2015/04/18 08:56:57
6853 dnl ----------------
6854 dnl Check for ldconfig, needed to fixup shared libraries that would be built
6855 dnl and then used in the install.
6856 AC_DEFUN([CF_PROG_LDCONFIG],[
6857 if test "$cross_compiling" = yes ; then
6858         LDCONFIG=:
6859 else
6860         case "$cf_cv_system_name" in
6861         (dragonfly*|mirbsd*|freebsd*)
6862                 test -z "$LDCONFIG" && LDCONFIG="/sbin/ldconfig -R"
6863                 ;;
6864         (*) LDPATH=$PATH:/sbin:/usr/sbin
6865                 AC_PATH_PROG(LDCONFIG,ldconfig,,$LDPATH)
6866                 ;;
6867         esac
6868 fi
6869 AC_SUBST(LDCONFIG)
6870 ])dnl
6871 dnl ---------------------------------------------------------------------------
6872 dnl CF_PROG_LINT version: 4 updated: 2019/11/20 18:55:37
6873 dnl ------------
6874 AC_DEFUN([CF_PROG_LINT],
6875 [
6876 AC_CHECK_PROGS(LINT, lint cppcheck splint)
6877 case "x$LINT" in
6878 (xcppcheck|x*/cppcheck)
6879         test -z "$LINT_OPTS" && LINT_OPTS="--enable=all"
6880         ;;
6881 esac
6882 AC_SUBST(LINT_OPTS)
6883 ])dnl
6884 dnl ---------------------------------------------------------------------------
6885 dnl CF_PROG_LN_S version: 2 updated: 2010/08/14 18:25:37
6886 dnl ------------
6887 dnl Combine checks for "ln -s" and "ln -sf", updating $LN_S to include "-f"
6888 dnl option if it is supported.
6889 AC_DEFUN([CF_PROG_LN_S],[
6890 AC_PROG_LN_S
6891 AC_MSG_CHECKING(if $LN_S -f options work)
6892
6893 rm -f conf$$.src conf$$dst
6894 echo >conf$$.dst
6895 echo first >conf$$.src
6896 if $LN_S -f conf$$.src conf$$.dst 2>/dev/null; then
6897         cf_prog_ln_sf=yes
6898 else
6899         cf_prog_ln_sf=no
6900 fi
6901 rm -f conf$$.dst conf$$src
6902 AC_MSG_RESULT($cf_prog_ln_sf)
6903
6904 test "$cf_prog_ln_sf" = yes && LN_S="$LN_S -f"
6905 ])dnl
6906 dnl ---------------------------------------------------------------------------
6907 dnl CF_REGEX version: 18 updated: 2021/01/01 16:53:59
6908 dnl --------
6909 dnl Attempt to determine if we've got one of the flavors of regular-expression
6910 dnl code that we can support.
6911 AC_DEFUN([CF_REGEX],
6912 [
6913
6914 cf_regex_func=no
6915 cf_regex_libs=
6916 case "$host_os" in
6917 (mingw*)
6918         # -lsystre -ltre -lintl -liconv
6919         AC_CHECK_LIB(systre,regcomp,[
6920                 AC_CHECK_LIB(iconv,libiconv_open,[CF_ADD_LIB(iconv)])
6921                 AC_CHECK_LIB(intl,libintl_gettext,[CF_ADD_LIB(intl)])
6922                 AC_CHECK_LIB(tre,tre_regcomp,[CF_ADD_LIB(tre)])
6923                 CF_ADD_LIB(systre)
6924                 cf_regex_func=regcomp
6925         ],[
6926                 AC_CHECK_LIB(gnurx,regcomp,[
6927                         CF_ADD_LIB(gnurx)
6928                         cf_regex_func=regcomp])
6929         ])
6930         ;;
6931 (*)
6932         cf_regex_libs="regex re"
6933         AC_CHECK_FUNC(regcomp,[cf_regex_func=regcomp],[
6934                 for cf_regex_lib in $cf_regex_libs
6935                 do
6936                         AC_CHECK_LIB($cf_regex_lib,regcomp,[
6937                                         CF_ADD_LIB($cf_regex_lib)
6938                                         cf_regex_func=regcomp
6939                                         break])
6940                 done
6941         ])
6942         ;;
6943 esac
6944
6945 if test "$cf_regex_func" = no ; then
6946         AC_CHECK_FUNC(compile,[cf_regex_func=compile],[
6947                 AC_CHECK_LIB(gen,compile,[
6948                                 CF_ADD_LIB(gen)
6949                                 cf_regex_func=compile])])
6950 fi
6951
6952 if test "$cf_regex_func" = no ; then
6953         AC_MSG_WARN(cannot find regular expression library)
6954 fi
6955
6956 AC_CACHE_CHECK(for regular-expression headers,cf_cv_regex_hdrs,[
6957
6958 cf_cv_regex_hdrs=no
6959 case "$cf_regex_func" in
6960 (compile)
6961         for cf_regex_hdr in regexp.h regexpr.h
6962         do
6963                 AC_TRY_LINK([#include <$cf_regex_hdr>],[
6964                         char *p = compile("", "", "", 0);
6965                         int x = step("", "");
6966                         (void)p;
6967                         (void)x;
6968                 ],[
6969                         cf_cv_regex_hdrs=$cf_regex_hdr
6970                         break
6971                 ])
6972         done
6973         ;;
6974 (*)
6975         for cf_regex_hdr in regex.h
6976         do
6977                 AC_TRY_LINK([#include <sys/types.h>
6978 #include <$cf_regex_hdr>],[
6979                         regex_t *p = 0;
6980                         int x = regcomp(p, "", 0);
6981                         int y = regexec(p, "", 0, 0, 0);
6982                         (void)x;
6983                         (void)y;
6984                         regfree(p);
6985                 ],[
6986                         cf_cv_regex_hdrs=$cf_regex_hdr
6987                         break
6988                 ])
6989         done
6990         ;;
6991 esac
6992
6993 ])
6994
6995 case "$cf_cv_regex_hdrs" in
6996         (no)            AC_MSG_WARN(no regular expression header found) ;;
6997         (regex.h)       AC_DEFINE(HAVE_REGEX_H_FUNCS,1,[Define to 1 to include regex.h for regular expressions]) ;;
6998         (regexp.h)      AC_DEFINE(HAVE_REGEXP_H_FUNCS,1,[Define to 1 to include regexp.h for regular expressions]) ;;
6999         (regexpr.h) AC_DEFINE(HAVE_REGEXPR_H_FUNCS,1,[Define to 1 to include regexpr.h for regular expressions]) ;;
7000 esac
7001 ])dnl
7002 dnl ---------------------------------------------------------------------------
7003 dnl CF_REMOVE_CFLAGS version: 3 updated: 2021/09/05 17:25:40
7004 dnl ----------------
7005 dnl Remove a given option from CFLAGS/CPPFLAGS
7006 dnl $1 = option to remove
7007 dnl $2 = variable to update
7008 dnl $3 = nonempty to allow verbose message
7009 define([CF_REMOVE_CFLAGS],
7010 [
7011 cf_tmp_cflag=`echo "x$1" | sed -e 's/^.//' -e 's/=.*//'`
7012 while true
7013 do
7014         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'`
7015         test "[$]$2" != "$cf_old_cflag" || break
7016         ifelse([$3],,,[CF_VERBOSE(removing old option $1 from $2)])
7017         $2="$cf_old_cflag"
7018 done
7019 ])dnl
7020 dnl ---------------------------------------------------------------------------
7021 dnl CF_REMOVE_DEFINE version: 3 updated: 2010/01/09 11:05:50
7022 dnl ----------------
7023 dnl Remove all -U and -D options that refer to the given symbol from a list
7024 dnl of C compiler options.  This works around the problem that not all
7025 dnl compilers process -U and -D options from left-to-right, so a -U option
7026 dnl cannot be used to cancel the effect of a preceding -D option.
7027 dnl
7028 dnl $1 = target (which could be the same as the source variable)
7029 dnl $2 = source (including '$')
7030 dnl $3 = symbol to remove
7031 define([CF_REMOVE_DEFINE],
7032 [
7033 $1=`echo "$2" | \
7034         sed     -e 's/-[[UD]]'"$3"'\(=[[^       ]]*\)\?[[       ]]/ /g' \
7035                 -e 's/-[[UD]]'"$3"'\(=[[^       ]]*\)\?[$]//g'`
7036 ])dnl
7037 dnl ---------------------------------------------------------------------------
7038 dnl CF_REMOVE_LIB version: 1 updated: 2007/02/17 14:11:52
7039 dnl -------------
7040 dnl Remove the given library from the symbol
7041 dnl
7042 dnl $1 = target (which could be the same as the source variable)
7043 dnl $2 = source (including '$')
7044 dnl $3 = library to remove
7045 define([CF_REMOVE_LIB],
7046 [
7047 # remove $3 library from $2
7048 $1=`echo "$2" | sed -e 's/-l$3[[        ]]//g' -e 's/-l$3[$]//'`
7049 ])dnl
7050 dnl ---------------------------------------------------------------------------
7051 dnl CF_RESTORE_XTRA_FLAGS version: 1 updated: 2020/01/11 16:47:45
7052 dnl ---------------------
7053 dnl Restore flags saved in CF_SAVE_XTRA_FLAGS
7054 dnl $1 = name of current macro
7055 define([CF_RESTORE_XTRA_FLAGS],
7056 [
7057 LIBS="$cf_save_LIBS_$1"
7058 CFLAGS="$cf_save_CFLAGS_$1"
7059 CPPFLAGS="$cf_save_CPPFLAGS_$1"
7060 ])dnl
7061 dnl ---------------------------------------------------------------------------
7062 dnl CF_RPATH_HACK version: 13 updated: 2021/01/03 18:30:50
7063 dnl -------------
7064 AC_DEFUN([CF_RPATH_HACK],
7065 [AC_REQUIRE([AC_PROG_FGREP])dnl
7066 AC_REQUIRE([CF_LD_RPATH_OPT])dnl
7067
7068 AC_MSG_CHECKING(for updated LDFLAGS)
7069 if test -n "$LD_RPATH_OPT" ; then
7070         AC_MSG_RESULT(maybe)
7071
7072         AC_CHECK_PROGS(cf_ldd_prog,ldd,no)
7073         cf_rpath_list="/usr/lib /lib"
7074         if test "$cf_ldd_prog" != no
7075         then
7076                 cf_rpath_oops=
7077
7078 AC_TRY_LINK([#include <stdio.h>],
7079                 [printf("Hello");],
7080                 [cf_rpath_oops=`"$cf_ldd_prog" "conftest$ac_exeext" | ${FGREP-fgrep} ' not found' | sed -e 's% =>.*$%%' |sort | uniq`
7081                  cf_rpath_list=`"$cf_ldd_prog" "conftest$ac_exeext" | ${FGREP-fgrep} / | sed -e 's%^.*[[        ]]/%/%' -e 's%/[[^/]][[^/]]*$%%' |sort | uniq`])
7082
7083                 # If we passed the link-test, but get a "not found" on a given library,
7084                 # this could be due to inept reconfiguration of gcc to make it only
7085                 # partly honor /usr/local/lib (or whatever).  Sometimes this behavior
7086                 # is intentional, e.g., installing gcc in /usr/bin and suppressing the
7087                 # /usr/local libraries.
7088                 if test -n "$cf_rpath_oops"
7089                 then
7090                         for cf_rpath_src in $cf_rpath_oops
7091                         do
7092                                 for cf_rpath_dir in \
7093                                         /usr/local \
7094                                         /usr/pkg \
7095                                         /opt/sfw
7096                                 do
7097                                         if test -f "$cf_rpath_dir/lib/$cf_rpath_src"
7098                                         then
7099                                                 CF_VERBOSE(...adding -L$cf_rpath_dir/lib to LDFLAGS for $cf_rpath_src)
7100                                                 LDFLAGS="$LDFLAGS -L$cf_rpath_dir/lib"
7101                                                 break
7102                                         fi
7103                                 done
7104                         done
7105                 fi
7106         fi
7107
7108         CF_VERBOSE(...checking EXTRA_LDFLAGS $EXTRA_LDFLAGS)
7109
7110         CF_RPATH_HACK_2(LDFLAGS)
7111         CF_RPATH_HACK_2(LIBS)
7112
7113         CF_VERBOSE(...checked EXTRA_LDFLAGS $EXTRA_LDFLAGS)
7114 else
7115         AC_MSG_RESULT(no)
7116 fi
7117 AC_SUBST(EXTRA_LDFLAGS)
7118 ])dnl
7119 dnl ---------------------------------------------------------------------------
7120 dnl CF_RPATH_HACK_2 version: 8 updated: 2021/01/01 13:31:04
7121 dnl ---------------
7122 dnl Do one set of substitutions for CF_RPATH_HACK, adding an rpath option to
7123 dnl EXTRA_LDFLAGS for each -L option found.
7124 dnl
7125 dnl $cf_rpath_list contains a list of directories to ignore.
7126 dnl
7127 dnl $1 = variable name to update.  The LDFLAGS variable should be the only one,
7128 dnl      but LIBS often has misplaced -L options.
7129 AC_DEFUN([CF_RPATH_HACK_2],
7130 [
7131 CF_VERBOSE(...checking $1 [$]$1)
7132
7133 cf_rpath_dst=
7134 for cf_rpath_src in [$]$1
7135 do
7136         case "$cf_rpath_src" in
7137         (-L*)
7138
7139                 # check if this refers to a directory which we will ignore
7140                 cf_rpath_skip=no
7141                 if test -n "$cf_rpath_list"
7142                 then
7143                         for cf_rpath_item in $cf_rpath_list
7144                         do
7145                                 if test "x$cf_rpath_src" = "x-L$cf_rpath_item"
7146                                 then
7147                                         cf_rpath_skip=yes
7148                                         break
7149                                 fi
7150                         done
7151                 fi
7152
7153                 if test "$cf_rpath_skip" = no
7154                 then
7155                         # transform the option
7156                         if test "$LD_RPATH_OPT" = "-R " ; then
7157                                 cf_rpath_tmp=`echo "$cf_rpath_src" |sed -e "s%-L%-R %"`
7158                         else
7159                                 cf_rpath_tmp=`echo "$cf_rpath_src" |sed -e "s%-L%$LD_RPATH_OPT%"`
7160                         fi
7161
7162                         # if we have not already added this, add it now
7163                         cf_rpath_tst=`echo "$EXTRA_LDFLAGS" | sed -e "s%$cf_rpath_tmp %%"`
7164                         if test "x$cf_rpath_tst" = "x$EXTRA_LDFLAGS"
7165                         then
7166                                 CF_VERBOSE(...Filter $cf_rpath_src ->$cf_rpath_tmp)
7167                                 EXTRA_LDFLAGS="$cf_rpath_tmp $EXTRA_LDFLAGS"
7168                         fi
7169                 fi
7170                 ;;
7171         esac
7172         cf_rpath_dst="$cf_rpath_dst $cf_rpath_src"
7173 done
7174 $1=$cf_rpath_dst
7175
7176 CF_VERBOSE(...checked $1 [$]$1)
7177 AC_SUBST(EXTRA_LDFLAGS)
7178 ])dnl
7179 dnl ---------------------------------------------------------------------------
7180 dnl CF_SAVE_XTRA_FLAGS version: 1 updated: 2020/01/11 16:46:44
7181 dnl ------------------
7182 dnl Use this macro to save CFLAGS/CPPFLAGS/LIBS before checks against X headers
7183 dnl and libraries which do not update those variables.
7184 dnl
7185 dnl $1 = name of current macro
7186 define([CF_SAVE_XTRA_FLAGS],
7187 [
7188 cf_save_LIBS_$1="$LIBS"
7189 cf_save_CFLAGS_$1="$CFLAGS"
7190 cf_save_CPPFLAGS_$1="$CPPFLAGS"
7191 LIBS="$LIBS ${X_PRE_LIBS} ${X_LIBS} ${X_EXTRA_LIBS}"
7192 for cf_X_CFLAGS in $X_CFLAGS
7193 do
7194         case "x$cf_X_CFLAGS" in
7195         x-[[IUD]]*)
7196                 CPPFLAGS="$CPPFLAGS $cf_X_CFLAGS"
7197                 ;;
7198         *)
7199                 CFLAGS="$CFLAGS $cf_X_CFLAGS"
7200                 ;;
7201         esac
7202 done
7203 ])dnl
7204 dnl ---------------------------------------------------------------------------
7205 dnl CF_SHARED_OPTS version: 107 updated: 2021/09/04 06:47:34
7206 dnl --------------
7207 dnl --------------
7208 dnl Attempt to determine the appropriate CC/LD options for creating a shared
7209 dnl library.
7210 dnl
7211 dnl Notes:
7212 dnl a) ${LOCAL_LDFLAGS} is used to link executables that will run within
7213 dnl the build-tree, i.e., by making use of the libraries that are compiled in
7214 dnl $rel_builddir/lib We avoid compiling-in a $rel_builddir/lib path for the
7215 dnl shared library since that can lead to unexpected results at runtime.
7216 dnl b) ${LOCAL_LDFLAGS2} has the same intention but assumes that the shared
7217 dnl libraries are compiled in ../../lib
7218 dnl
7219 dnl The variable 'cf_cv_do_symlinks' is used to control whether we configure
7220 dnl to install symbolic links to the rel/abi versions of shared libraries.
7221 dnl
7222 dnl The variable 'cf_cv_shlib_version' controls whether we use the rel or abi
7223 dnl version when making symbolic links.
7224 dnl
7225 dnl The variable 'cf_cv_shlib_version_infix' controls whether shared library
7226 dnl version numbers are infix (ex: libncurses.<ver>.dylib) or postfix
7227 dnl (ex: libncurses.so.<ver>).
7228 dnl
7229 dnl Some loaders leave 'so_locations' lying around.  It is nice to clean up.
7230 AC_DEFUN([CF_SHARED_OPTS],
7231 [
7232         AC_REQUIRE([CF_LD_RPATH_OPT])
7233
7234         RM_SHARED_OPTS=
7235         LOCAL_LDFLAGS=
7236         LOCAL_LDFLAGS2=
7237         LD_SHARED_OPTS=
7238         INSTALL_LIB="-m 644"
7239         : ${rel_builddir:=.}
7240
7241         shlibdir=$libdir
7242         AC_SUBST(shlibdir)
7243
7244         MAKE_DLLS="#"
7245         AC_SUBST(MAKE_DLLS)
7246
7247         cf_cv_do_symlinks=no
7248         cf_ld_rpath_opt=
7249         test "$cf_cv_enable_rpath" = yes && cf_ld_rpath_opt="$LD_RPATH_OPT"
7250
7251         AC_MSG_CHECKING(if release/abi version should be used for shared libs)
7252         AC_ARG_WITH(shlib-version,
7253         [  --with-shlib-version=X  Specify rel or abi version for shared libs],
7254         [test -z "$withval" && withval=auto
7255         case "$withval" in
7256         (yes)
7257                 cf_cv_shlib_version=auto
7258                 ;;
7259         (rel|abi|auto)
7260                 cf_cv_shlib_version=$withval
7261                 ;;
7262         (*)
7263                 AC_MSG_RESULT($withval)
7264                 AC_MSG_ERROR([option value must be one of: rel, abi, or auto])
7265                 ;;
7266         esac
7267         ],[cf_cv_shlib_version=auto])
7268         AC_MSG_RESULT($cf_cv_shlib_version)
7269
7270         cf_cv_rm_so_locs=no
7271         cf_try_cflags=
7272
7273         # Some less-capable ports of gcc support only -fpic
7274         CC_SHARED_OPTS=
7275
7276         cf_try_fPIC=no
7277         if test "$GCC" = yes
7278         then
7279                 cf_try_fPIC=yes
7280         else
7281                 case "$cf_cv_system_name" in
7282                 (*linux*)       # e.g., PGI compiler
7283                         cf_try_fPIC=yes
7284                         ;;
7285                 esac
7286         fi
7287
7288         if test "$cf_try_fPIC" = yes
7289         then
7290                 AC_MSG_CHECKING(which $CC option to use)
7291                 cf_save_CFLAGS="$CFLAGS"
7292                 for CC_SHARED_OPTS in -fPIC -fpic ''
7293                 do
7294                         CFLAGS="$cf_save_CFLAGS $CC_SHARED_OPTS"
7295                         AC_TRY_COMPILE([#include <stdio.h>],[int x = 1],[break],[])
7296                 done
7297                 AC_MSG_RESULT($CC_SHARED_OPTS)
7298                 CFLAGS="$cf_save_CFLAGS"
7299         fi
7300
7301         cf_cv_shlib_version_infix=no
7302
7303         case "$cf_cv_system_name" in
7304         (aix4.[3-9]*|aix[[5-7]]*)
7305                 if test "$GCC" = yes; then
7306                         CC_SHARED_OPTS='-Wl,-brtl'
7307                         MK_SHARED_LIB='${CC} ${LDFLAGS} ${CFLAGS} -shared -Wl,-brtl -Wl,-blibpath:${RPATH_LIST}:/usr/lib -o [$]@'
7308                 else
7309                         CC_SHARED_OPTS='-brtl'
7310                         # as well as '-qpic=large -G' or perhaps "-bM:SRE -bnoentry -bexpall"
7311                         MK_SHARED_LIB='${CC} ${LDFLAGS} ${CFLAGS} -G -Wl,-brtl -Wl,-blibpath:${RPATH_LIST}:/usr/lib -o [$]@'
7312                 fi
7313                 ;;
7314         (beos*)
7315                 MK_SHARED_LIB='${CC} ${LDFLAGS} ${CFLAGS} -o $[@] -Xlinker -soname=`basename $[@]` -nostart -e 0'
7316                 ;;
7317         (cygwin*)
7318                 CC_SHARED_OPTS=
7319                 MK_SHARED_LIB=$SHELL' '$rel_builddir'/mk_shared_lib.sh [$]@ [$]{CC} [$]{CFLAGS}'
7320                 RM_SHARED_OPTS="$RM_SHARED_OPTS $rel_builddir/mk_shared_lib.sh *.dll.a"
7321                 cf_cv_shlib_version=cygdll
7322                 cf_cv_shlib_version_infix=cygdll
7323                 shlibdir=$bindir
7324                 MAKE_DLLS=
7325                 cat >mk_shared_lib.sh <<-CF_EOF
7326                 #!$SHELL
7327                 SHARED_LIB=\[$]1
7328                 IMPORT_LIB=\`echo "\[$]1" | sed -e 's/cyg/lib/' -e 's/[[0-9]]*\.dll[$]/.dll.a/'\`
7329                 shift
7330                 cat <<-EOF
7331                 Linking shared library
7332                 ** SHARED_LIB \[$]SHARED_LIB
7333                 ** IMPORT_LIB \[$]IMPORT_LIB
7334 EOF
7335                 exec \[$]* ${LDFLAGS} -shared -Wl,--out-implib=\[$]{IMPORT_LIB} -Wl,--export-all-symbols -o \[$]{SHARED_LIB}
7336 CF_EOF
7337                 chmod +x mk_shared_lib.sh
7338                 ;;
7339         (msys*)
7340                 CC_SHARED_OPTS=
7341                 MK_SHARED_LIB=$SHELL' '$rel_builddir'/mk_shared_lib.sh [$]@ [$]{CC} [$]{CFLAGS}'
7342                 RM_SHARED_OPTS="$RM_SHARED_OPTS $rel_builddir/mk_shared_lib.sh *.dll.a"
7343                 cf_cv_shlib_version=msysdll
7344                 cf_cv_shlib_version_infix=msysdll
7345                 shlibdir=$bindir
7346                 MAKE_DLLS=
7347                 cat >mk_shared_lib.sh <<-CF_EOF
7348                 #!$SHELL
7349                 SHARED_LIB=\[$]1
7350                 IMPORT_LIB=\`echo "\[$]1" | sed -e 's/msys-/lib/' -e 's/[[0-9]]*\.dll[$]/.dll.a/'\`
7351                 shift
7352                 cat <<-EOF
7353                 Linking shared library
7354                 ** SHARED_LIB \[$]SHARED_LIB
7355                 ** IMPORT_LIB \[$]IMPORT_LIB
7356 EOF
7357                 exec \[$]* ${LDFLAGS} -shared -Wl,--out-implib=\[$]{IMPORT_LIB} -Wl,--export-all-symbols -o \[$]{SHARED_LIB}
7358 CF_EOF
7359                 chmod +x mk_shared_lib.sh
7360                 ;;
7361         (darwin*)
7362                 cf_try_cflags="no-cpp-precomp"
7363                 CC_SHARED_OPTS="-dynamic"
7364                 MK_SHARED_LIB='${CC} ${LDFLAGS} ${CFLAGS} -dynamiclib -install_name ${libdir}/`basename $[@]` -compatibility_version ${ABI_VERSION} -current_version ${ABI_VERSION} -o $[@]'
7365                 test "$cf_cv_shlib_version" = auto && cf_cv_shlib_version=abi
7366                 cf_cv_shlib_version_infix=yes
7367                 AC_CACHE_CHECK([if ld -search_paths_first works], cf_cv_ldflags_search_paths_first, [
7368                         cf_save_LDFLAGS=$LDFLAGS
7369                         LDFLAGS="$LDFLAGS -Wl,-search_paths_first"
7370                         AC_TRY_LINK(, [int i;], cf_cv_ldflags_search_paths_first=yes, cf_cv_ldflags_search_paths_first=no)
7371                                 LDFLAGS=$cf_save_LDFLAGS])
7372                 if test "$cf_cv_ldflags_search_paths_first" = yes; then
7373                         LDFLAGS="$LDFLAGS -Wl,-search_paths_first"
7374                 fi
7375                 ;;
7376         (haiku*)
7377                 CF_SHARED_SONAME
7378                 MK_SHARED_LIB='${CC} ${LDFLAGS} ${CFLAGS} -shared -Wl,-soname,'$cf_cv_shared_soname',-stats,-lc -o $[@]'
7379                 ;;
7380         (hpux[[7-8]]*)
7381                 # HP-UX 8.07 ld lacks "+b" option used for libdir search-list
7382                 if test "$GCC" != yes; then
7383                         CC_SHARED_OPTS='+Z'
7384                 fi
7385                 MK_SHARED_LIB='${LD} ${LDFLAGS} -b -o $[@]'
7386                 INSTALL_LIB="-m 555"
7387                 ;;
7388         (hpux*)
7389                 # (tested with gcc 2.7.2 -- I don't have c89)
7390                 if test "$GCC" = yes; then
7391                         LD_SHARED_OPTS='-Xlinker +b -Xlinker ${libdir}'
7392                 else
7393                         CC_SHARED_OPTS='+Z'
7394                         LD_SHARED_OPTS='-Wl,+b,${libdir}'
7395                 fi
7396                 MK_SHARED_LIB='${LD} ${LDFLAGS} +b ${libdir} -b -o $[@]'
7397                 # HP-UX shared libraries must be executable, and should be
7398                 # readonly to exploit a quirk in the memory manager.
7399                 INSTALL_LIB="-m 555"
7400                 ;;
7401         (interix*)
7402                 test "$cf_cv_shlib_version" = auto && cf_cv_shlib_version=rel
7403                 if test "$cf_cv_shlib_version" = rel; then
7404                         cf_shared_soname='`basename $[@] .${REL_VERSION}`.${ABI_VERSION}'
7405                 else
7406                         cf_shared_soname='`basename $[@]`'
7407                 fi
7408                 CC_SHARED_OPTS=
7409                 MK_SHARED_LIB='${CC} ${LDFLAGS} ${CFLAGS} -shared -Wl,-rpath,${RPATH_LIST} -Wl,-h,'$cf_shared_soname' -o $[@]'
7410                 ;;
7411         (irix*)
7412                 if test "$cf_cv_enable_rpath" = yes ; then
7413                         EXTRA_LDFLAGS="${cf_ld_rpath_opt}\${RPATH_LIST} $EXTRA_LDFLAGS"
7414                 fi
7415                 # tested with IRIX 5.2 and 'cc'.
7416                 if test "$GCC" != yes; then
7417                         CC_SHARED_OPTS='-KPIC'
7418                         MK_SHARED_LIB='${CC} ${LDFLAGS} ${CFLAGS} -shared -rdata_shared -soname `basename $[@]` -o $[@]'
7419                 else
7420                         MK_SHARED_LIB='${CC} ${LDFLAGS} ${CFLAGS} -shared -Wl,-soname,`basename $[@]` -o $[@]'
7421                 fi
7422                 cf_cv_rm_so_locs=yes
7423                 ;;
7424         (linux*|gnu*|k*bsd*-gnu)
7425                 if test "$DFT_LWR_MODEL" = "shared" && test -n "$LD_RPATH_OPT" ; then
7426                         LOCAL_LDFLAGS="${LD_RPATH_OPT}\$(LOCAL_LIBDIR)"
7427                         LOCAL_LDFLAGS2="$LOCAL_LDFLAGS"
7428                 fi
7429                 if test "$cf_cv_enable_rpath" = yes ; then
7430                         EXTRA_LDFLAGS="${cf_ld_rpath_opt}\${RPATH_LIST} $EXTRA_LDFLAGS"
7431                 fi
7432                 CF_SHARED_SONAME
7433                 MK_SHARED_LIB='${CC} ${LDFLAGS} ${CFLAGS} -shared -Wl,-soname,'$cf_cv_shared_soname',-stats,-lc -o $[@]'
7434                 ;;
7435         (mingw*msvc*)
7436                 cf_cv_shlib_version=msvcdll
7437                 cf_cv_shlib_version_infix=msvcdll
7438                 shlibdir=$bindir
7439                 MAKE_DLLS=
7440                 if test "$DFT_LWR_MODEL" = "shared" ; then
7441                         LOCAL_LDFLAGS="-link -dll"
7442                         LOCAL_LDFLAGS2="$LOCAL_LDFLAGS"
7443                         EXTRA_LDFLAGS="-link -dll $EXTRA_LDFLAGS"
7444                 fi
7445                 CC_SHARED_OPTS=
7446                 MK_SHARED_LIB=$SHELL' '$rel_builddir'/mk_shared_lib.sh [$]@ ${LD} [$]{CFLAGS}'
7447                 RM_SHARED_OPTS="$RM_SHARED_OPTS $rel_builddir/mk_shared_lib.sh *.dll.lib"
7448                 cat >mk_shared_lib.sh <<-CF_EOF
7449                 #!$SHELL
7450                 SHARED_LIB=\[$]1
7451                 IMPORT_LIB=\`echo "\[$]1" | sed -e 's/[[0-9]]*\.dll[$]/.dll.lib/'\`
7452                 shift
7453                 my_ld=\[$]1
7454                 shift
7455                 cat <<-EOF
7456                 Linking shared library
7457                 ** SHARED LIB \$SHARED_LIB
7458                 ** IMPORT_LIB \$IMPORT_LIB
7459 EOF
7460                 args=\$(echo \[$]* | sed -E "s#-l(\w*)#\1.dll.lib#g" | sed -E "s#-L(\w*)#-LIBPATH:\1#g")
7461                 exec \$my_ld -DLL -IMPLIB:"\${IMPORT_LIB}" -OUT:"\${SHARED_LIB}" ${LDFLAGS} \$args
7462                 mv "\${IMPORT_LIB}" "\${IMPORT_LIB}"
7463 CF_EOF
7464                 chmod +x mk_shared_lib.sh
7465                 cat >mk_prog.sh <<-CF_EOF
7466                 #!$SHELL
7467                 shift
7468                 # Ignore first argument (compiler) and use LD (link.exe) unconditionally
7469                 LD="[$]LD"
7470                 clopts=()
7471                 ldopts=("/subsystem:console")
7472                 libs=()
7473                 isdll=0
7474                 while test \[$]# -gt 0; do
7475                         case "\[$]1" in
7476                                 -link)
7477                                         # ignore -link argument
7478                                         ;;
7479                                 -M[[TD]] | -M[[TD]]d)
7480                                         # ignore runtime-library option
7481                                         ;;
7482                                 -dll)
7483                                         isdll=1
7484                                         ;;
7485                                 -W* | -w*)
7486                                         # ignore warnings
7487                                         ;;
7488                                 -D*)
7489                                         clopts+=("\[$]1")
7490                                         ;;
7491                                 -I*)
7492                                         clopts+=("\[$]1")
7493                                         ;;
7494                                 -l*)
7495                                         libs+=("\`echo \"\[$]1\" | sed \"s/^-l//\"\`")
7496                                         ;;
7497                                 -L*)
7498                                         ldopts+=("\`echo \"\[$]1\" | sed \"s/^-L/-LIBPATH:/\"\`")
7499                                         ;;
7500                                 *.obj | *.o)
7501                                         ldopts+=("\[$]1")
7502                                         ;;
7503                                 -Wl,*)
7504                                         for linkarg in \`echo '\[$]1' | sed -e 's/-Wl,//' -e 's/,/ /'\`; do
7505                                                 ldopts+=("\[$]{linkarg}")
7506                                         done
7507                                         ;;
7508                                 *.lib)
7509                                         ldopts+=("\[$]1")
7510                                         ;;
7511                                 -o)
7512                                         shift
7513                                         ldopts+=("-out:\[$]1")
7514                                         ;;
7515                                 *)
7516                                         clopts+=("\[$]1")
7517                                         ldopts+=("\[$]1")
7518                                         ;;
7519                         esac
7520                         shift
7521                 done
7522                 if [[ "\$isdll" -ne 0 ]]; then
7523                         for lib in \[$]{libs[[*]]}; do
7524                                 ldopts+=("\[$]lib.dll.lib")
7525                         done
7526                 else
7527                         for lib in \[$]{libs[[*]]}; do
7528                                 ldopts+=("\[$]lib.lib")
7529                         done
7530                 fi
7531                 cat <<-EOF
7532                 Creating program
7533                 ** ld options:   "\[$]{ldopts[[@]]}"
7534 EOF
7535                 exec \[$]LD \[$]{ldopts[[@]]}
7536 CF_EOF
7537                 chmod +x mk_prog.sh
7538                 LINK_PROGS="$SHELL ${rel_builddir}/mk_prog.sh"
7539                 LINK_TESTS="$SHELL ${rel_builddir}/mk_prog.sh"
7540                 ;;
7541         (mingw*)
7542                 cf_cv_shlib_version=mingw
7543                 cf_cv_shlib_version_infix=mingw
7544                 shlibdir=$bindir
7545                 MAKE_DLLS=
7546                 if test "$DFT_LWR_MODEL" = "shared" ; then
7547                         LOCAL_LDFLAGS="-Wl,--enable-auto-import"
7548                         LOCAL_LDFLAGS2="$LOCAL_LDFLAGS"
7549                         EXTRA_LDFLAGS="-Wl,--enable-auto-import $EXTRA_LDFLAGS"
7550                 fi
7551                 CC_SHARED_OPTS=
7552                 MK_SHARED_LIB=$SHELL' '$rel_builddir'/mk_shared_lib.sh [$]@ [$]{CC} [$]{CFLAGS}'
7553                 RM_SHARED_OPTS="$RM_SHARED_OPTS $rel_builddir/mk_shared_lib.sh *.dll.a"
7554                 cat >mk_shared_lib.sh <<-CF_EOF
7555                 #!$SHELL
7556                 SHARED_LIB=\[$]1
7557                 IMPORT_LIB=\`echo "\[$]1" | sed -e 's/[[0-9]]*\.dll[$]/.dll.a/'\`
7558                 shift
7559                 cat <<-EOF
7560                 Linking shared library
7561                 ** SHARED_LIB \[$]SHARED_LIB
7562                 ** IMPORT_LIB \[$]IMPORT_LIB
7563 EOF
7564                 exec \[$]* ${LDFLAGS} -shared -Wl,--enable-auto-import,--out-implib=\[$]{IMPORT_LIB} -Wl,--export-all-symbols -o \[$]{SHARED_LIB}
7565 CF_EOF
7566                 chmod +x mk_shared_lib.sh
7567                 ;;
7568         (openbsd[[2-9]].*|mirbsd*)
7569                 if test "$DFT_LWR_MODEL" = "shared" && test -n "$LD_RPATH_OPT" ; then
7570                         LOCAL_LDFLAGS="${LD_RPATH_OPT}\$(LOCAL_LIBDIR)"
7571                         LOCAL_LDFLAGS2="$LOCAL_LDFLAGS"
7572                 fi
7573                 if test "$cf_cv_enable_rpath" = yes ; then
7574                         EXTRA_LDFLAGS="${cf_ld_rpath_opt}\${RPATH_LIST} $EXTRA_LDFLAGS"
7575                 fi
7576                 CC_SHARED_OPTS="$CC_SHARED_OPTS -DPIC"
7577                 CF_SHARED_SONAME
7578                 MK_SHARED_LIB='${CC} ${LDFLAGS} ${CFLAGS} -shared -Wl,-Bshareable,-soname,'$cf_cv_shared_soname',-stats,-lc -o $[@]'
7579                 ;;
7580         (nskJ*)
7581                 CC_SHARED_OPTS=
7582                 MK_SHARED_LIB='${LD} -Wshared -Weld=-export_all -o $[@]'
7583                 ;;
7584         (nskL*)
7585                 CC_SHARED_OPTS=
7586                 MK_SHARED_LIB='${LD} -Wshared -Wxld=-export_all -o $[@]'
7587                 ;;
7588         (nto-qnx*|openbsd*|freebsd[[12]].*)
7589                 CC_SHARED_OPTS="$CC_SHARED_OPTS -DPIC"
7590                 MK_SHARED_LIB='${LD} ${LDFLAGS} -Bshareable -o $[@]'
7591                 test "$cf_cv_shlib_version" = auto && cf_cv_shlib_version=rel
7592                 ;;
7593         (dragonfly*|freebsd*)
7594                 CC_SHARED_OPTS="$CC_SHARED_OPTS -DPIC"
7595                 if test "$DFT_LWR_MODEL" = "shared" && test "$cf_cv_enable_rpath" = yes ; then
7596                         LOCAL_LDFLAGS="${cf_ld_rpath_opt}\$(LOCAL_LIBDIR)"
7597                         LOCAL_LDFLAGS2="${cf_ld_rpath_opt}\${RPATH_LIST} $LOCAL_LDFLAGS"
7598                         EXTRA_LDFLAGS="${cf_ld_rpath_opt}\${RPATH_LIST} $EXTRA_LDFLAGS"
7599                 fi
7600                 CF_SHARED_SONAME
7601                 MK_SHARED_LIB='${CC} ${LDFLAGS} ${CFLAGS} -shared -Wl,-soname,'$cf_cv_shared_soname',-stats,-lc -o $[@]'
7602                 ;;
7603         (netbsd*)
7604                 CC_SHARED_OPTS="$CC_SHARED_OPTS -DPIC"
7605                 if test "$DFT_LWR_MODEL" = "shared" && test "$cf_cv_enable_rpath" = yes ; then
7606                         LOCAL_LDFLAGS="${cf_ld_rpath_opt}\$(LOCAL_LIBDIR)"
7607                         LOCAL_LDFLAGS2="$LOCAL_LDFLAGS"
7608                         EXTRA_LDFLAGS="${cf_ld_rpath_opt}\${RPATH_LIST} $EXTRA_LDFLAGS"
7609                         if test "$cf_cv_shlib_version" = auto; then
7610                         if test -f /usr/libexec/ld.elf_so; then
7611                                 cf_cv_shlib_version=abi
7612                         else
7613                                 cf_cv_shlib_version=rel
7614                         fi
7615                         fi
7616                         CF_SHARED_SONAME
7617                         MK_SHARED_LIB='${CC} ${LDFLAGS} ${CFLAGS} -shared -Wl,-soname,'$cf_cv_shared_soname' -o $[@]'
7618                 else
7619                         MK_SHARED_LIB='${CC} ${LDFLAGS} ${CFLAGS} -shared -o $[@]'
7620                 fi
7621                 ;;
7622         (osf*|mls+*)
7623                 # tested with OSF/1 V3.2 and 'cc'
7624                 # tested with OSF/1 V3.2 and gcc 2.6.3 (but the c++ demo didn't
7625                 # link with shared libs).
7626                 MK_SHARED_LIB='${LD} ${LDFLAGS} -set_version ${REL_VERSION}:${ABI_VERSION} -expect_unresolved "*" -shared -soname `basename $[@]`'
7627                 case "$host_os" in
7628                 (osf4*)
7629                         MK_SHARED_LIB="${MK_SHARED_LIB} -msym"
7630                         ;;
7631                 esac
7632                 MK_SHARED_LIB="${MK_SHARED_LIB}"' -o $[@]'
7633                 if test "$DFT_LWR_MODEL" = "shared" && test -n "$LD_RPATH_OPT" ; then
7634                         LOCAL_LDFLAGS="${LD_RPATH_OPT}\$(LOCAL_LIBDIR)"
7635                         LOCAL_LDFLAGS2="$LOCAL_LDFLAGS"
7636                 fi
7637                 cf_cv_rm_so_locs=yes
7638                 ;;
7639         (sco3.2v5*)  # also uw2* and UW7: hops 13-Apr-98
7640                 # tested with osr5.0.5
7641                 if test "$GCC" != yes; then
7642                         CC_SHARED_OPTS='-belf -KPIC'
7643                 fi
7644                 MK_SHARED_LIB='${LD} ${LDFLAGS} -dy -G -h `basename $[@] .${REL_VERSION}`.${ABI_VERSION} -o [$]@'
7645                 if test "$cf_cv_enable_rpath" = yes ; then
7646                         # only way is to set LD_RUN_PATH but no switch for it
7647                         RUN_PATH=$libdir
7648                 fi
7649                 test "$cf_cv_shlib_version" = auto && cf_cv_shlib_version=rel
7650                 LINK_PROGS='LD_RUN_PATH=${libdir}'
7651                 LINK_TESTS='Pwd=`pwd`;LD_RUN_PATH=`dirname $${Pwd}`/lib'
7652                 ;;
7653         (sunos4*)
7654                 # tested with SunOS 4.1.1 and gcc 2.7.0
7655                 if test "$GCC" != yes; then
7656                         CC_SHARED_OPTS='-KPIC'
7657                 fi
7658                 MK_SHARED_LIB='${LD} ${LDFLAGS} -assert pure-text -o $[@]'
7659                 test "$cf_cv_shlib_version" = auto && cf_cv_shlib_version=rel
7660                 ;;
7661         (solaris2*)
7662                 # tested with SunOS 5.5.1 (solaris 2.5.1) and gcc 2.7.2
7663                 # tested with SunOS 5.10 (solaris 10) and gcc 3.4.3
7664                 if test "$DFT_LWR_MODEL" = "shared" ; then
7665                         LOCAL_LDFLAGS="-R \$(LOCAL_LIBDIR):\${libdir}"
7666                         LOCAL_LDFLAGS2="$LOCAL_LDFLAGS"
7667                 fi
7668                 if test "$cf_cv_enable_rpath" = yes ; then
7669                         EXTRA_LDFLAGS="-R \${libdir} $EXTRA_LDFLAGS"
7670                 fi
7671                 CF_SHARED_SONAME
7672                 if test "$GCC" != yes; then
7673                         cf_save_CFLAGS="$CFLAGS"
7674                         for cf_shared_opts in -xcode=pic32 -xcode=pic13 -KPIC -Kpic -O
7675                         do
7676                                 CFLAGS="$cf_shared_opts $cf_save_CFLAGS"
7677                                 AC_TRY_COMPILE([#include <stdio.h>],[printf("Hello\\n");],[break])
7678                         done
7679                         CFLAGS="$cf_save_CFLAGS"
7680                         CC_SHARED_OPTS=$cf_shared_opts
7681                         MK_SHARED_LIB='${CC} ${LDFLAGS} ${CFLAGS} -dy -G -h '$cf_cv_shared_soname' -o $[@]'
7682                 else
7683                         MK_SHARED_LIB='${CC} ${LDFLAGS} ${CFLAGS} -shared -dy -G -h '$cf_cv_shared_soname' -o $[@]'
7684                 fi
7685                 ;;
7686         (sysv5uw7*|unix_sv*)
7687                 # tested with UnixWare 7.1.0 (gcc 2.95.2 and cc)
7688                 if test "$GCC" != yes; then
7689                         CC_SHARED_OPTS='-KPIC'
7690                 fi
7691                 MK_SHARED_LIB='${LD} ${LDFLAGS} -d y -G -o [$]@'
7692                 ;;
7693         (*)
7694                 CC_SHARED_OPTS='unknown'
7695                 MK_SHARED_LIB='echo unknown'
7696                 ;;
7697         esac
7698
7699         # This works if the last tokens in $MK_SHARED_LIB are the -o target.
7700         case "$cf_cv_shlib_version" in
7701         (rel|abi)
7702                 case "$MK_SHARED_LIB" in
7703                 (*'-o $[@]')
7704                         test "$cf_cv_do_symlinks" = no && cf_cv_do_symlinks=yes
7705                         ;;
7706                 (*)
7707                         AC_MSG_WARN(ignored --with-shlib-version)
7708                         ;;
7709                 esac
7710                 ;;
7711         esac
7712
7713         if test -n "$cf_try_cflags"
7714         then
7715 cat > conftest.$ac_ext <<EOF
7716 #line __oline__ "${as_me:-configure}"
7717 #include <stdio.h>
7718 int main(int argc, char *argv[[]])
7719 {
7720         printf("hello\\n");
7721         return (argv[[argc-1]] == 0) ;
7722 }
7723 EOF
7724                 cf_save_CFLAGS="$CFLAGS"
7725                 for cf_opt in $cf_try_cflags
7726                 do
7727                         CFLAGS="$cf_save_CFLAGS -$cf_opt"
7728                         AC_MSG_CHECKING(if CFLAGS option -$cf_opt works)
7729                         if AC_TRY_EVAL(ac_compile); then
7730                                 AC_MSG_RESULT(yes)
7731                                 cf_save_CFLAGS="$CFLAGS"
7732                         else
7733                                 AC_MSG_RESULT(no)
7734                         fi
7735                 done
7736                 CFLAGS="$cf_save_CFLAGS"
7737         fi
7738
7739
7740         # RPATH_LIST is a colon-separated list of directories
7741         test -n "$cf_ld_rpath_opt" && MK_SHARED_LIB="$MK_SHARED_LIB $cf_ld_rpath_opt\${RPATH_LIST}"
7742         test -z "$RPATH_LIST" && RPATH_LIST="\${libdir}"
7743
7744         test "$cf_cv_rm_so_locs" = yes && RM_SHARED_OPTS="$RM_SHARED_OPTS so_locations"
7745
7746         CF_VERBOSE(CC_SHARED_OPTS: $CC_SHARED_OPTS)
7747         CF_VERBOSE(MK_SHARED_LIB:  $MK_SHARED_LIB)
7748
7749         AC_SUBST(CC_SHARED_OPTS)
7750         AC_SUBST(LD_RPATH_OPT)
7751         AC_SUBST(LD_SHARED_OPTS)
7752         AC_SUBST(MK_SHARED_LIB)
7753         AC_SUBST(RM_SHARED_OPTS)
7754
7755         AC_SUBST(LINK_PROGS)
7756         AC_SUBST(LINK_TESTS)
7757
7758         AC_SUBST(EXTRA_LDFLAGS)
7759         AC_SUBST(LOCAL_LDFLAGS)
7760         AC_SUBST(LOCAL_LDFLAGS2)
7761
7762         AC_SUBST(INSTALL_LIB)
7763         AC_SUBST(RPATH_LIST)
7764 ])dnl
7765 dnl ---------------------------------------------------------------------------
7766 dnl CF_SHARED_SONAME version: 3 updated: 2008/09/08 18:34:43
7767 dnl ----------------
7768 dnl utility macro for CF_SHARED_OPTS, constructs "$cf_cv_shared_soname" for
7769 dnl substitution into MK_SHARED_LIB string for the "-soname" (or similar)
7770 dnl option.
7771 dnl
7772 dnl $1 is the default that should be used for "$cf_cv_shlib_version".
7773 dnl If missing, use "rel".
7774 define([CF_SHARED_SONAME],
7775 [
7776         test "$cf_cv_shlib_version" = auto && cf_cv_shlib_version=ifelse($1,,rel,$1)
7777         if test "$cf_cv_shlib_version" = rel; then
7778                 cf_cv_shared_soname='`basename $[@] .${REL_VERSION}`.${ABI_VERSION}'
7779         else
7780                 cf_cv_shared_soname='`basename $[@]`'
7781         fi
7782 ])
7783 dnl ---------------------------------------------------------------------------
7784 dnl CF_SIGWINCH version: 6 updated: 2021/01/01 13:31:04
7785 dnl -----------
7786 dnl Use this macro after CF_XOPEN_SOURCE, but do not require it (not all
7787 dnl programs need this test).
7788 dnl
7789 dnl This is really a Mac OS X 10.4.3 workaround.  Defining _POSIX_C_SOURCE
7790 dnl forces SIGWINCH to be undefined (breaks xterm, ncurses).  Oddly, the struct
7791 dnl winsize declaration is left alone - we may revisit this if Apple choose to
7792 dnl break that part of the interface as well.
7793 AC_DEFUN([CF_SIGWINCH],
7794 [
7795 AC_CACHE_CHECK(if SIGWINCH is defined,cf_cv_define_sigwinch,[
7796         AC_TRY_COMPILE([
7797 #include <sys/types.h>
7798 #include <sys/signal.h>
7799 ],[int x = SIGWINCH; (void)x],
7800         [cf_cv_define_sigwinch=yes],
7801         [AC_TRY_COMPILE([
7802 #undef _XOPEN_SOURCE
7803 #undef _POSIX_SOURCE
7804 #undef _POSIX_C_SOURCE
7805 #include <sys/types.h>
7806 #include <sys/signal.h>
7807 ],[int x = SIGWINCH; (void)x],
7808         [cf_cv_define_sigwinch=maybe],
7809         [cf_cv_define_sigwinch=no])
7810 ])
7811 ])
7812
7813 if test "$cf_cv_define_sigwinch" = maybe ; then
7814 AC_CACHE_CHECK(for actual SIGWINCH definition,cf_cv_fixup_sigwinch,[
7815 cf_cv_fixup_sigwinch=unknown
7816 cf_sigwinch=32
7817 while test "$cf_sigwinch" != 1
7818 do
7819         AC_TRY_COMPILE([
7820 #undef _XOPEN_SOURCE
7821 #undef _POSIX_SOURCE
7822 #undef _POSIX_C_SOURCE
7823 #include <sys/types.h>
7824 #include <sys/signal.h>
7825 ],[
7826 #if SIGWINCH != $cf_sigwinch
7827 make an error
7828 #endif
7829 int x = SIGWINCH; (void)x],
7830         [cf_cv_fixup_sigwinch=$cf_sigwinch
7831          break])
7832
7833 cf_sigwinch="`expr "$cf_sigwinch" - 1`"
7834 done
7835 ])
7836
7837         if test "$cf_cv_fixup_sigwinch" != unknown ; then
7838                 CPPFLAGS="$CPPFLAGS -DSIGWINCH=$cf_cv_fixup_sigwinch"
7839         fi
7840 fi
7841 ])dnl
7842 dnl ---------------------------------------------------------------------------
7843 dnl CF_SIG_ATOMIC_T version: 5 updated: 2020/03/10 18:53:47
7844 dnl ---------------
7845 dnl signal handler, but there are some gcc dependencies in that recommendation.
7846 dnl Try anyway.
7847 AC_DEFUN([CF_SIG_ATOMIC_T],
7848 [
7849 AC_MSG_CHECKING(for signal global datatype)
7850 AC_CACHE_VAL(cf_cv_sig_atomic_t,[
7851         for cf_type in \
7852                 "volatile sig_atomic_t" \
7853                 "sig_atomic_t" \
7854                 "int"
7855         do
7856         AC_TRY_COMPILE([
7857 #include <sys/types.h>
7858 #include <signal.h>
7859 #include <stdio.h>
7860
7861 extern $cf_type x;
7862 $cf_type x;
7863 static void handler(int sig)
7864 {
7865         (void)sig;
7866         x = 5;
7867 }],
7868                 [signal(SIGINT, handler);
7869                  x = 1],
7870                 [cf_cv_sig_atomic_t=$cf_type],
7871                 [cf_cv_sig_atomic_t=no])
7872                 test "$cf_cv_sig_atomic_t" != no && break
7873         done
7874         ])
7875 AC_MSG_RESULT($cf_cv_sig_atomic_t)
7876 test "$cf_cv_sig_atomic_t" != no && AC_DEFINE_UNQUOTED(SIG_ATOMIC_T, $cf_cv_sig_atomic_t,[Define to signal global datatype])
7877 ])dnl
7878 dnl ---------------------------------------------------------------------------
7879 dnl CF_SIZECHANGE version: 18 updated: 2021/09/04 06:35:04
7880 dnl -------------
7881 dnl Check for definitions & structures needed for window size-changing
7882 dnl
7883 dnl https://stackoverflow.com/questions/18878141/difference-between-structures-ttysize-and-winsize/50769952#50769952
7884 AC_DEFUN([CF_SIZECHANGE],
7885 [
7886 AC_REQUIRE([CF_STRUCT_TERMIOS])
7887 AC_CACHE_CHECK(declaration of size-change, cf_cv_sizechange,[
7888         cf_cv_sizechange=unknown
7889         cf_save_CPPFLAGS="$CPPFLAGS"
7890
7891 for cf_opts in "" "NEED_PTEM_H"
7892 do
7893
7894         CPPFLAGS="$cf_save_CPPFLAGS"
7895         if test -n "$cf_opts"
7896         then
7897                 CF_APPEND_TEXT(CPPFLAGS,-D$cf_opts)
7898         fi
7899         AC_TRY_COMPILE([#include <sys/types.h>
7900 #ifdef HAVE_TERMIOS_H
7901 #include <termios.h>
7902 #else
7903 #ifdef HAVE_TERMIO_H
7904 #include <termio.h>
7905 #endif
7906 #endif
7907
7908 #ifdef NEED_PTEM_H
7909 /* This is a workaround for SCO:  they neglected to define struct winsize in
7910  * termios.h -- it is only in termio.h and ptem.h
7911  */
7912 #include <sys/stream.h>
7913 #include <sys/ptem.h>
7914 #endif
7915
7916 #ifdef HAVE_SYS_IOCTL_H
7917 #include <sys/ioctl.h>
7918 #endif
7919 ],[
7920 #ifdef TIOCGSIZE
7921         struct ttysize win;     /* SunOS 3.0... */
7922         int y = win.ts_lines = 2;
7923         int x = win.ts_cols = 1;
7924         (void)y;
7925         (void)x;
7926 #else
7927 #ifdef TIOCGWINSZ
7928         struct winsize win;     /* everything else */
7929         int y = win.ws_row = 2;
7930         int x = win.ws_col = 1;
7931         (void)y;
7932         (void)x;
7933 #else
7934         no TIOCGSIZE or TIOCGWINSZ
7935 #endif /* TIOCGWINSZ */
7936 #endif /* TIOCGSIZE */
7937         ],
7938         [cf_cv_sizechange=yes],
7939         [cf_cv_sizechange=no])
7940
7941         CPPFLAGS="$cf_save_CPPFLAGS"
7942         if test "$cf_cv_sizechange" = yes ; then
7943                 echo "size-change succeeded ($cf_opts)" >&AC_FD_CC
7944                 test -n "$cf_opts" && cf_cv_sizechange="$cf_opts"
7945                 break
7946         fi
7947 done
7948 ])
7949 if test "$cf_cv_sizechange" != no ; then
7950         AC_DEFINE(HAVE_SIZECHANGE,1,[Define to 1 if sizechange declarations are provided])
7951         case "$cf_cv_sizechange" in
7952         (NEED*)
7953                 AC_DEFINE_UNQUOTED($cf_cv_sizechange )
7954                 ;;
7955         esac
7956 fi
7957 ])dnl
7958 dnl ---------------------------------------------------------------------------
7959 dnl CF_SRC_MODULES version: 33 updated: 2021/01/01 13:31:04
7960 dnl --------------
7961 dnl For each parameter, test if the source-directory exists, and if it contains
7962 dnl a 'modules' file.  If so, add to the list $cf_cv_src_modules which we'll
7963 dnl use in CF_LIB_RULES.
7964 dnl
7965 dnl This uses the configured value to make the lists SRC_SUBDIRS and
7966 dnl SUB_MAKEFILES which are used in the makefile-generation scheme.
7967 AC_DEFUN([CF_SRC_MODULES],
7968 [
7969 AC_REQUIRE([CF_CHECK_GNAT_VERSION])
7970 AC_MSG_CHECKING(for src modules)
7971
7972 # dependencies and linker-arguments for test-programs
7973 TEST_DEPS="${LIB_DIR}/${LIB_PREFIX}${LIB_NAME}${DFT_DEP_SUFFIX} $TEST_DEPS"
7974 TEST_DEP2="${LIB_2ND}/${LIB_PREFIX}${LIB_NAME}${DFT_DEP_SUFFIX} $TEST_DEP2"
7975 if test "$DFT_LWR_MODEL" = "libtool"; then
7976         TEST_ARGS="${TEST_DEPS}"
7977         TEST_ARG2="${TEST_DEP2}"
7978 else
7979         TEST_ARGS="-l${LIB_NAME}${USE_ARG_SUFFIX} $TEST_ARGS"
7980         TEST_ARG2="-l${LIB_NAME}${USE_ARG_SUFFIX} $TEST_ARG2"
7981 fi
7982
7983 PC_MODULES_TO_MAKE="ncurses${USE_ARG_SUFFIX}"
7984 cf_cv_src_modules=
7985 for cf_dir in $1
7986 do
7987         if test -f "$srcdir/$cf_dir/modules" ; then
7988
7989                 # We may/may not have tack in the distribution, though the
7990                 # makefile is.
7991                 if test "$cf_dir" = tack ; then
7992                         if test "x$cf_with_tack" != "xyes"; then
7993                                 continue
7994                         fi
7995                 fi
7996
7997                 if test -z "$cf_cv_src_modules"; then
7998                         cf_cv_src_modules=$cf_dir
7999                 else
8000                         cf_cv_src_modules="$cf_cv_src_modules $cf_dir"
8001                 fi
8002
8003                 # Make the ncurses_cfg.h file record the library interface files as
8004                 # well.  These are header files that are the same name as their
8005                 # directory.  Ncurses is the only library that does not follow
8006                 # that pattern.
8007                 if test "$cf_dir" = tack ; then
8008                         continue
8009                 elif test -f "$srcdir/${cf_dir}/${cf_dir}.h" ; then
8010                         CF_UPPER(cf_have_include,$cf_dir)
8011                         AC_DEFINE_UNQUOTED(HAVE_${cf_have_include}_H)
8012                         AC_DEFINE_UNQUOTED(HAVE_LIB${cf_have_include})
8013                         CF_MAP_LIB_BASENAME(TEST_ROOT,$cf_dir)
8014                         TEST_DEPS="${LIB_DIR}/${LIB_PREFIX}${TEST_ROOT}${DFT_DEP_SUFFIX} $TEST_DEPS"
8015                         TEST_DEP2="${LIB_2ND}/${LIB_PREFIX}${TEST_ROOT}${DFT_DEP_SUFFIX} $TEST_DEP2"
8016                         if test "$DFT_LWR_MODEL" = "libtool"; then
8017                                 TEST_ARGS="${TEST_DEPS}"
8018                                 TEST_ARG2="${TEST_DEP2}"
8019                         else
8020                                 TEST_ARGS="-l${TEST_ROOT}${USE_ARG_SUFFIX} $TEST_ARGS"
8021                                 TEST_ARG2="-l${TEST_ROOT}${USE_ARG_SUFFIX} $TEST_ARG2"
8022                         fi
8023                         PC_MODULES_TO_MAKE="${PC_MODULES_TO_MAKE} ${cf_dir}${USE_ARG_SUFFIX}"
8024                 fi
8025         fi
8026 done
8027 AC_MSG_RESULT($cf_cv_src_modules)
8028
8029 TEST_ARGS="-L${LIB_DIR} $TEST_ARGS"
8030 TEST_ARG2="-L${LIB_2ND} $TEST_ARG2"
8031
8032 AC_SUBST(TEST_ARGS)
8033 AC_SUBST(TEST_DEPS)
8034
8035 AC_SUBST(TEST_ARG2)
8036 AC_SUBST(TEST_DEP2)
8037
8038 SRC_SUBDIRS=
8039 if test "x$cf_with_manpages" != xno ; then
8040         SRC_SUBDIRS="$SRC_SUBDIRS man"
8041 fi
8042 SRC_SUBDIRS="$SRC_SUBDIRS include"
8043 for cf_dir in $cf_cv_src_modules
8044 do
8045         SRC_SUBDIRS="$SRC_SUBDIRS $cf_dir"
8046 done
8047 if test "x$cf_with_tests" != "xno" ; then
8048         SRC_SUBDIRS="$SRC_SUBDIRS test"
8049 fi
8050 # always make this, to install the ncurses-config script
8051 SRC_SUBDIRS="$SRC_SUBDIRS misc"
8052 if test "$cf_with_cxx_binding" != no; then
8053         PC_MODULES_TO_MAKE="${PC_MODULES_TO_MAKE} ncurses++${USE_ARG_SUFFIX}"
8054         SRC_SUBDIRS="$SRC_SUBDIRS c++"
8055 fi
8056
8057 test "x$with_termlib" != xno && PC_MODULES_TO_MAKE="$PC_MODULES_TO_MAKE $TINFO_ARG_SUFFIX"
8058 test "x$with_ticlib" != xno && PC_MODULES_TO_MAKE="$PC_MODULES_TO_MAKE $TICS_ARG_SUFFIX"
8059
8060 AC_SUBST(PC_MODULES_TO_MAKE)
8061
8062 ADA_SUBDIRS=
8063 if test "x$cf_with_ada" = "xyes" && test "x$cf_cv_prog_gnat_correct" = xyes && test -f "$srcdir/Ada95/Makefile.in" ; then
8064         SRC_SUBDIRS="$SRC_SUBDIRS Ada95"
8065         ADA_SUBDIRS="gen src"
8066         if test "x$cf_with_tests" != "xno" ; then
8067                 ADA_SUBDIRS="$ADA_SUBDIRS samples"
8068         fi
8069 fi
8070
8071 SUB_MAKEFILES=
8072 for cf_dir in $SRC_SUBDIRS
8073 do
8074         SUB_MAKEFILES="$SUB_MAKEFILES $cf_dir/Makefile"
8075 done
8076
8077 if test -n "$ADA_SUBDIRS"; then
8078         for cf_dir in $ADA_SUBDIRS
8079         do
8080                 SUB_MAKEFILES="$SUB_MAKEFILES Ada95/$cf_dir/Makefile"
8081         done
8082         AC_SUBST(ADA_SUBDIRS)
8083 fi
8084 ])dnl
8085 dnl ---------------------------------------------------------------------------
8086 dnl CF_STDCPP_LIBRARY version: 12 updated: 2021/01/01 13:31:04
8087 dnl -----------------
8088 dnl Check for -lstdc++, which is GNU's standard C++ library.
8089 dnl If $CXXLIBS is set, add that to the libraries used for test-linking.
8090 dnl If -lstdc++ was not already added to $LIBS or $CXXLIBS, and is needed,
8091 dnl add it to $CXXLIBS.
8092 AC_DEFUN([CF_STDCPP_LIBRARY],
8093 [
8094 if test -n "$GXX" ; then
8095
8096         cf_save="$LIBS"
8097         LIBS="$LIBS $CXXLIBS"
8098         AC_MSG_CHECKING(if we already have C++ library)
8099         AC_TRY_LINK([
8100                         #include <iostream>],[
8101                         std::cout << "Hello World!" << std::endl;],
8102                 [cf_have_libstdcpp=yes],
8103                 [cf_have_libstdcpp=no])
8104         AC_MSG_RESULT($cf_have_libstdcpp)
8105         LIBS="$cf_save"
8106
8107         if test "$cf_have_libstdcpp" != yes
8108         then
8109                 case "$cf_cv_system_name" in
8110                 (os2*)
8111                         if test -z "`g++ -dM -E - < /dev/null | grep __KLIBC__`"; then
8112                                 cf_stdcpp_libname=stdcpp
8113                         else
8114                                 cf_stdcpp_libname=stdc++
8115                         fi
8116                         ;;
8117                 (*)
8118                         cf_stdcpp_libname=stdc++
8119                         ;;
8120                 esac
8121
8122                 AC_CACHE_CHECK(for library $cf_stdcpp_libname,cf_cv_libstdcpp,[
8123                         cf_save="$LIBS"
8124                         LIBS="$LIBS $CXXLIBS"
8125                         CF_ADD_LIB($cf_stdcpp_libname)
8126                 AC_TRY_LINK([
8127                                 #include <iostream>],[
8128                                 std::cout << "Hello World!" << std::endl;],
8129                         [cf_cv_libstdcpp=yes],
8130                         [cf_cv_libstdcpp=no])
8131                         LIBS="$cf_save"
8132                 ])
8133                 test "$cf_cv_libstdcpp" = yes && { CF_ADD_LIB($cf_stdcpp_libname,CXXLIBS) }
8134         fi
8135 fi
8136 ])dnl
8137 dnl ---------------------------------------------------------------------------
8138 dnl CF_STRIP_G_OPT version: 4 updated: 2021/01/02 09:31:20
8139 dnl --------------
8140 dnl     Remove "-g" option from the compiler options
8141 AC_DEFUN([CF_STRIP_G_OPT],
8142 [$1=`echo "${$1}" | CF__SED_TRIMBLANKS(-e 's%-g %%' -e 's%-g$%%')`])dnl
8143 dnl ---------------------------------------------------------------------------
8144 dnl CF_STRUCT_SIGACTION version: 5 updated: 2012/10/06 17:56:13
8145 dnl -------------------
8146 dnl Check if we need _POSIX_SOURCE defined to use struct sigaction.  We'll only
8147 dnl do this if we've found the sigaction function.
8148 AC_DEFUN([CF_STRUCT_SIGACTION],[
8149 AC_REQUIRE([CF_XOPEN_SOURCE])
8150
8151 if test "$ac_cv_func_sigaction" = yes; then
8152 AC_MSG_CHECKING(whether sigaction needs _POSIX_SOURCE)
8153 AC_TRY_COMPILE([
8154 #include <sys/types.h>
8155 #include <signal.h>],
8156         [struct sigaction act],
8157         [sigact_bad=no],
8158         [
8159 AC_TRY_COMPILE([
8160 #define _POSIX_SOURCE
8161 #include <sys/types.h>
8162 #include <signal.h>],
8163         [struct sigaction act],
8164         [sigact_bad=yes
8165          AC_DEFINE(_POSIX_SOURCE,1,[Define to 1 if we must define _POSIX_SOURCE])],
8166          [sigact_bad=unknown])])
8167 AC_MSG_RESULT($sigact_bad)
8168 fi
8169 ])dnl
8170 dnl ---------------------------------------------------------------------------
8171 dnl CF_STRUCT_TERMIOS version: 11 updated: 2020/03/19 20:46:13
8172 dnl -----------------
8173 dnl Some machines require _POSIX_SOURCE to completely define struct termios.
8174 AC_DEFUN([CF_STRUCT_TERMIOS],[
8175 AC_REQUIRE([CF_XOPEN_SOURCE])
8176
8177 AC_CHECK_HEADERS( \
8178 termio.h \
8179 termios.h \
8180 unistd.h \
8181 sys/ioctl.h \
8182 sys/termio.h \
8183 )
8184
8185 if test "$ac_cv_header_termios_h" = yes ; then
8186         case "$CFLAGS $CPPFLAGS" in
8187         (*-D_POSIX_SOURCE*)
8188                 termios_bad=dunno ;;
8189         (*)     termios_bad=maybe ;;
8190         esac
8191         if test "$termios_bad" = maybe ; then
8192         AC_MSG_CHECKING(whether termios.h needs _POSIX_SOURCE)
8193         AC_TRY_COMPILE([#include <termios.h>],
8194                 [struct termios foo; int x = foo.c_iflag = 1; (void)x],
8195                 termios_bad=no, [
8196                 AC_TRY_COMPILE([
8197 #define _POSIX_SOURCE
8198 #include <termios.h>],
8199                         [struct termios foo; int x = foo.c_iflag = 2; (void)x],
8200                         termios_bad=unknown,
8201                         termios_bad=yes AC_DEFINE(_POSIX_SOURCE,1,[Define to 1 if we must define _POSIX_SOURCE]))
8202                         ])
8203         AC_MSG_RESULT($termios_bad)
8204         fi
8205 fi
8206 ])dnl
8207 dnl ---------------------------------------------------------------------------
8208 dnl CF_SUBDIR_PATH version: 7 updated: 2014/12/04 04:33:06
8209 dnl --------------
8210 dnl Construct a search-list for a nonstandard header/lib-file
8211 dnl     $1 = the variable to return as result
8212 dnl     $2 = the package name
8213 dnl     $3 = the subdirectory, e.g., bin, include or lib
8214 AC_DEFUN([CF_SUBDIR_PATH],
8215 [
8216 $1=
8217
8218 CF_ADD_SUBDIR_PATH($1,$2,$3,$prefix,NONE)
8219
8220 for cf_subdir_prefix in \
8221         /usr \
8222         /usr/local \
8223         /usr/pkg \
8224         /opt \
8225         /opt/local \
8226         [$]HOME
8227 do
8228         CF_ADD_SUBDIR_PATH($1,$2,$3,$cf_subdir_prefix,$prefix)
8229 done
8230 ])dnl
8231 dnl ---------------------------------------------------------------------------
8232 dnl CF_SUBST_IF version: 2 updated: 2006/06/17 12:33:03
8233 dnl -----------
8234 dnl     Shorthand macro for substituting things that the user may override
8235 dnl     with an environment variable.
8236 dnl
8237 dnl     $1 = condition to pass to "test"
8238 dnl     $2 = environment variable
8239 dnl     $3 = value if the test succeeds
8240 dnl     $4 = value if the test fails
8241 AC_DEFUN([CF_SUBST_IF],
8242 [
8243 if test $1 ; then
8244         $2=$3
8245 ifelse($4,,,[else
8246         $2=$4])
8247 fi
8248 AC_SUBST($2)
8249 ])dnl
8250 dnl ---------------------------------------------------------------------------
8251 dnl CF_SUBST_NCURSES_VERSION version: 10 updated: 2021/01/04 18:48:01
8252 dnl ------------------------
8253 dnl Get the version-number for use in shared-library naming, etc.
8254 AC_DEFUN([CF_SUBST_NCURSES_VERSION],
8255 [AC_REQUIRE([AC_PROG_EGREP])dnl
8256
8257 NCURSES_MAJOR="`${EGREP-egrep} '^NCURSES_MAJOR[[        ]]*=' "$srcdir/dist.mk" | sed -e 's/^[[^0-9]]*//'`"
8258 NCURSES_MINOR="`${EGREP-egrep} '^NCURSES_MINOR[[        ]]*=' "$srcdir/dist.mk" | sed -e 's/^[[^0-9]]*//'`"
8259 NCURSES_PATCH="`${EGREP-egrep} '^NCURSES_PATCH[[        ]]*=' "$srcdir/dist.mk" | sed -e 's/^[[^0-9]]*//'`"
8260 cf_cv_abi_version=${NCURSES_MAJOR}
8261 cf_cv_rel_version=${NCURSES_MAJOR}.${NCURSES_MINOR}
8262 dnl Show the computed version, for logging
8263 cf_cv_timestamp=`date`
8264 AC_MSG_RESULT(Configuring NCURSES $cf_cv_rel_version ABI $cf_cv_abi_version ($cf_cv_timestamp))
8265 dnl We need these values in the generated headers
8266 AC_SUBST(NCURSES_MAJOR)
8267 AC_SUBST(NCURSES_MINOR)
8268 AC_SUBST(NCURSES_PATCH)
8269 dnl We need these values in the generated makefiles
8270 AC_SUBST(cf_cv_rel_version)
8271 AC_SUBST(cf_cv_abi_version)
8272 AC_SUBST(cf_cv_builtin_bool)
8273 AC_SUBST(cf_cv_header_stdbool_h)
8274 AC_SUBST(cf_cv_type_of_bool)dnl
8275 ])dnl
8276 dnl ---------------------------------------------------------------------------
8277 dnl CF_SYS_TIME_SELECT version: 6 updated: 2015/04/18 08:56:57
8278 dnl ------------------
8279 dnl Check if we can include <sys/time.h> with <sys/select.h>; this breaks on
8280 dnl older SCO configurations.
8281 AC_DEFUN([CF_SYS_TIME_SELECT],
8282 [
8283 AC_MSG_CHECKING(if sys/time.h works with sys/select.h)
8284 AC_CACHE_VAL(cf_cv_sys_time_select,[
8285 AC_TRY_COMPILE([
8286 #include <sys/types.h>
8287 #ifdef HAVE_SYS_TIME_H
8288 #include <sys/time.h>
8289 #endif
8290 #ifdef HAVE_SYS_SELECT_H
8291 #include <sys/select.h>
8292 #endif
8293 ],[],[cf_cv_sys_time_select=yes],
8294          [cf_cv_sys_time_select=no])
8295          ])
8296 AC_MSG_RESULT($cf_cv_sys_time_select)
8297 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>])
8298 ])dnl
8299 dnl ---------------------------------------------------------------------------
8300 dnl CF_TOP_BUILDDIR version: 2 updated: 2013/07/27 17:38:32
8301 dnl ---------------
8302 dnl Define a top_builddir symbol, for applications that need an absolute path.
8303 AC_DEFUN([CF_TOP_BUILDDIR],
8304 [
8305 top_builddir=ifelse($1,,`pwd`,$1)
8306 AC_SUBST(top_builddir)
8307 ])dnl
8308 dnl ---------------------------------------------------------------------------
8309 dnl CF_TRY_PKG_CONFIG version: 6 updated: 2020/12/31 10:54:15
8310 dnl -----------------
8311 dnl This is a simple wrapper to use for pkg-config, for libraries which may be
8312 dnl available in that form.
8313 dnl
8314 dnl $1 = package name, which may be a shell variable
8315 dnl $2 = extra logic to use, if any, after updating CFLAGS and LIBS
8316 dnl $3 = logic to use if pkg-config does not have the package
8317 AC_DEFUN([CF_TRY_PKG_CONFIG],[
8318 AC_REQUIRE([CF_PKG_CONFIG])
8319
8320 if test "$PKG_CONFIG" != none && "$PKG_CONFIG" --exists "$1"; then
8321         CF_VERBOSE(found package $1)
8322         cf_pkgconfig_incs="`$PKG_CONFIG --cflags "$1" 2>/dev/null`"
8323         cf_pkgconfig_libs="`$PKG_CONFIG --libs   "$1" 2>/dev/null`"
8324         CF_VERBOSE(package $1 CFLAGS: $cf_pkgconfig_incs)
8325         CF_VERBOSE(package $1 LIBS: $cf_pkgconfig_libs)
8326         CF_ADD_CFLAGS($cf_pkgconfig_incs)
8327         CF_ADD_LIBS($cf_pkgconfig_libs)
8328         ifelse([$2],,:,[$2])
8329 else
8330         cf_pkgconfig_incs=
8331         cf_pkgconfig_libs=
8332         ifelse([$3],,:,[$3])
8333 fi
8334 ])
8335 dnl ---------------------------------------------------------------------------
8336 dnl CF_TRY_XOPEN_SOURCE version: 3 updated: 2021/08/28 15:20:37
8337 dnl -------------------
8338 dnl If _XOPEN_SOURCE is not defined in the compile environment, check if we
8339 dnl can define it successfully.
8340 AC_DEFUN([CF_TRY_XOPEN_SOURCE],[
8341 AC_CACHE_CHECK(if we should define _XOPEN_SOURCE,cf_cv_xopen_source,[
8342         AC_TRY_COMPILE([
8343 #include <stdlib.h>
8344 #include <string.h>
8345 #include <sys/types.h>
8346 ],[
8347 #ifndef _XOPEN_SOURCE
8348 make an error
8349 #endif],
8350         [cf_cv_xopen_source=no],
8351         [cf_save="$CPPFLAGS"
8352          CF_APPEND_TEXT(CPPFLAGS,-D_XOPEN_SOURCE=$cf_XOPEN_SOURCE)
8353          AC_TRY_COMPILE([
8354 #include <stdlib.h>
8355 #include <string.h>
8356 #include <sys/types.h>
8357 ],[
8358 #ifdef _XOPEN_SOURCE
8359 make an error
8360 #endif],
8361         [cf_cv_xopen_source=no],
8362         [cf_cv_xopen_source=$cf_XOPEN_SOURCE])
8363         CPPFLAGS="$cf_save"
8364         ])
8365 ])
8366
8367 if test "$cf_cv_xopen_source" != no ; then
8368         CF_REMOVE_DEFINE(CFLAGS,$CFLAGS,_XOPEN_SOURCE)
8369         CF_REMOVE_DEFINE(CPPFLAGS,$CPPFLAGS,_XOPEN_SOURCE)
8370         cf_temp_xopen_source="-D_XOPEN_SOURCE=$cf_cv_xopen_source"
8371         CF_APPEND_CFLAGS($cf_temp_xopen_source)
8372 fi
8373 ])
8374 dnl ---------------------------------------------------------------------------
8375 dnl CF_TYPEOF_CHTYPE version: 10 updated: 2017/01/21 11:06:25
8376 dnl ----------------
8377 dnl Determine the type we should use for chtype (and attr_t, which is treated
8378 dnl as the same thing).  We want around 32 bits, so on most machines want a
8379 dnl long, but on newer 64-bit machines, probably want an int.  If we're using
8380 dnl wide characters, we have to have a type compatible with that, as well.
8381 AC_DEFUN([CF_TYPEOF_CHTYPE],
8382 [
8383 AC_MSG_CHECKING([for type of chtype])
8384 AC_CACHE_VAL(cf_cv_typeof_chtype,[
8385                 AC_TRY_RUN([
8386 #define WANT_BITS 31
8387 #include <stdio.h>
8388 int main(void)
8389 {
8390         FILE *fp = fopen("cf_test.out", "w");
8391         if (fp != 0) {
8392                 char *result = "long";
8393                 if (sizeof(unsigned long) > sizeof(unsigned int)) {
8394                         int n;
8395                         unsigned int x, y;
8396                         for (n = 0; n < WANT_BITS; n++) {
8397                                 x = (1 << n);
8398                                 y = (x >> n);
8399                                 if (y != 1 || x == 0) {
8400                                         x = 0;
8401                                         break;
8402                                 }
8403                         }
8404                         /*
8405                          * If x is nonzero, an int is big enough for the bits
8406                          * that we want.
8407                          */
8408                         result = (x != 0) ? "int" : "long";
8409                 }
8410                 fputs(result, fp);
8411                 fclose(fp);
8412         }
8413         ${cf_cv_main_return:-return}(0);
8414 }
8415                 ],
8416                 [cf_cv_typeof_chtype=`cat cf_test.out`],
8417                 [cf_cv_typeof_chtype=long],
8418                 [cf_cv_typeof_chtype=long])
8419                 rm -f cf_test.out
8420         ])
8421 AC_MSG_RESULT($cf_cv_typeof_chtype)
8422
8423 AC_SUBST(cf_cv_typeof_chtype)
8424 AC_DEFINE_UNQUOTED(TYPEOF_CHTYPE,$cf_cv_typeof_chtype,[Define to actual type if needed for chtype])
8425 ])dnl
8426 dnl ---------------------------------------------------------------------------
8427 dnl CF_TYPE_SIGACTION version: 4 updated: 2012/10/06 17:56:13
8428 dnl -----------------
8429 dnl
8430 AC_DEFUN([CF_TYPE_SIGACTION],
8431 [
8432 AC_MSG_CHECKING([for type sigaction_t])
8433 AC_CACHE_VAL(cf_cv_type_sigaction,[
8434         AC_TRY_COMPILE([
8435 #include <signal.h>],
8436                 [sigaction_t x],
8437                 [cf_cv_type_sigaction=yes],
8438                 [cf_cv_type_sigaction=no])])
8439 AC_MSG_RESULT($cf_cv_type_sigaction)
8440 test "$cf_cv_type_sigaction" = yes && AC_DEFINE(HAVE_TYPE_SIGACTION,1,[Define to 1 if we have the sigaction_t type])
8441 ])dnl
8442 dnl ---------------------------------------------------------------------------
8443 dnl CF_UNSIGNED_LITERALS version: 2 updated: 1998/02/07 22:10:16
8444 dnl --------------------
8445 dnl Test if the compiler supports 'U' and 'L' suffixes.  Only old compilers
8446 dnl won't, but they're still there.
8447 AC_DEFUN([CF_UNSIGNED_LITERALS],
8448 [
8449 AC_MSG_CHECKING([if unsigned literals are legal])
8450 AC_CACHE_VAL(cf_cv_unsigned_literals,[
8451         AC_TRY_COMPILE([],[long x = 1L + 1UL + 1U + 1],
8452                 [cf_cv_unsigned_literals=yes],
8453                 [cf_cv_unsigned_literals=no])
8454         ])
8455 AC_MSG_RESULT($cf_cv_unsigned_literals)
8456 ])dnl
8457 dnl ---------------------------------------------------------------------------
8458 dnl CF_UPPER version: 5 updated: 2001/01/29 23:40:59
8459 dnl --------
8460 dnl Make an uppercase version of a variable
8461 dnl $1=uppercase($2)
8462 AC_DEFUN([CF_UPPER],
8463 [
8464 $1=`echo "$2" | sed y%abcdefghijklmnopqrstuvwxyz./-%ABCDEFGHIJKLMNOPQRSTUVWXYZ___%`
8465 ])dnl
8466 dnl ---------------------------------------------------------------------------
8467 dnl CF_UTF8_LIB version: 9 updated: 2021/05/19 19:35:25
8468 dnl -----------
8469 dnl Check for multibyte support, and if not found, utf8 compatibility library
8470 AC_DEFUN([CF_UTF8_LIB],
8471 [
8472 AC_HAVE_HEADERS(wchar.h)
8473 AC_CACHE_CHECK(for multibyte character support,cf_cv_utf8_lib,[
8474         cf_save_LIBS="$LIBS"
8475         AC_TRY_LINK([
8476 #include <stdlib.h>
8477 #include <stdio.h>
8478 #ifdef HAVE_WCHAR_H
8479 #include <wchar.h>
8480 #endif
8481 ],[putwc(0,0);],
8482         [cf_cv_utf8_lib=yes],
8483         [CF_FIND_LINKAGE([
8484 #include <libutf8.h>],[putwc(0,0);],utf8,
8485                 [cf_cv_utf8_lib=add-on],
8486                 [cf_cv_utf8_lib=no])
8487 ])])
8488
8489 # HAVE_LIBUTF8_H is used by ncurses if curses.h is shared between
8490 # ncurses/ncursesw:
8491 if test "$cf_cv_utf8_lib" = "add-on" ; then
8492         AC_DEFINE(HAVE_LIBUTF8_H,1,[Define to 1 if we should include libutf8.h])
8493         CF_ADD_INCDIR($cf_cv_header_path_utf8)
8494         CF_ADD_LIBDIR($cf_cv_library_path_utf8)
8495         CF_ADD_LIBS($cf_cv_library_file_utf8)
8496 fi
8497 ])dnl
8498 dnl ---------------------------------------------------------------------------
8499 dnl CF_VA_COPY version: 6 updated: 2018/12/04 18:14:25
8500 dnl ----------
8501 dnl check for va_copy, part of stdarg.h starting with ISO C 1999.
8502 dnl Also, workaround for glibc's __va_copy, by checking for both.
8503 dnl Finally, try to accommodate pre-ISO C 1999 headers.
8504 AC_DEFUN([CF_VA_COPY],[
8505 AC_CACHE_CHECK(for va_copy, cf_cv_have_va_copy,[
8506 AC_TRY_LINK([
8507 #include <stdarg.h>
8508 ],[
8509         static va_list dst;
8510         static va_list src;
8511         va_copy(dst, src)],
8512         cf_cv_have_va_copy=yes,
8513         cf_cv_have_va_copy=no)])
8514
8515 if test "$cf_cv_have_va_copy" = yes;
8516 then
8517         AC_DEFINE(HAVE_VA_COPY,1,[Define to 1 if we have va_copy])
8518 else # !cf_cv_have_va_copy
8519
8520 AC_CACHE_CHECK(for __va_copy, cf_cv_have___va_copy,[
8521 AC_TRY_LINK([
8522 #include <stdarg.h>
8523 ],[
8524         static va_list dst;
8525         static va_list src;
8526         __va_copy(dst, src)],
8527         cf_cv_have___va_copy=yes,
8528         cf_cv_have___va_copy=no)])
8529
8530 if test "$cf_cv_have___va_copy" = yes
8531 then
8532         AC_DEFINE(HAVE___VA_COPY,1,[Define to 1 if we have __va_copy])
8533 else # !cf_cv_have___va_copy
8534
8535 AC_CACHE_CHECK(for __builtin_va_copy, cf_cv_have___builtin_va_copy,[
8536 AC_TRY_LINK([
8537 #include <stdarg.h>
8538 ],[
8539         static va_list dst;
8540         static va_list src;
8541         __builtin_va_copy(dst, src)],
8542         cf_cv_have___builtin_va_copy=yes,
8543         cf_cv_have___builtin_va_copy=no)])
8544
8545 test "$cf_cv_have___builtin_va_copy" = yes &&
8546         AC_DEFINE(HAVE___BUILTIN_VA_COPY,1,[Define to 1 if we have __builtin_va_copy])
8547
8548 fi # cf_cv_have___va_copy
8549
8550 fi # cf_cv_have_va_copy
8551
8552 case "${cf_cv_have_va_copy}${cf_cv_have___va_copy}${cf_cv_have___builtin_va_copy}" in
8553 (*yes*)
8554         ;;
8555
8556 (*)
8557         AC_CACHE_CHECK(if we can simply copy va_list, cf_cv_pointer_va_list,[
8558 AC_TRY_LINK([
8559 #include <stdarg.h>
8560 ],[
8561         va_list dst;
8562         va_list src;
8563         dst = src],
8564         cf_cv_pointer_va_list=yes,
8565         cf_cv_pointer_va_list=no)])
8566
8567         if test "$cf_cv_pointer_va_list" = no
8568         then
8569                 AC_CACHE_CHECK(if we can copy va_list indirectly, cf_cv_array_va_list,[
8570 AC_TRY_LINK([
8571 #include <stdarg.h>
8572 ],[
8573         va_list dst;
8574         va_list src;
8575         *dst = *src],
8576                         cf_cv_array_va_list=yes,
8577                         cf_cv_array_va_list=no)])
8578                 test "$cf_cv_array_va_list" = yes && AC_DEFINE(ARRAY_VA_LIST,1,[Define to 1 if we can copy va_list indirectly])
8579         fi
8580         ;;
8581 esac
8582 ])
8583 dnl ---------------------------------------------------------------------------
8584 dnl CF_VERBOSE version: 3 updated: 2007/07/29 09:55:12
8585 dnl ----------
8586 dnl Use AC_VERBOSE w/o the warnings
8587 AC_DEFUN([CF_VERBOSE],
8588 [test -n "$verbose" && echo "   $1" 1>&AC_FD_MSG
8589 CF_MSG_LOG([$1])
8590 ])dnl
8591 dnl ---------------------------------------------------------------------------
8592 dnl CF_VERSION_INFO version: 8 updated: 2021/01/01 13:31:04
8593 dnl ---------------
8594 dnl Define several useful symbols derived from the VERSION file.  A separate
8595 dnl file is preferred to embedding the version numbers in various scripts.
8596 dnl (automake is a textbook-example of why the latter is a bad idea, but there
8597 dnl are others).
8598 dnl
8599 dnl The file contents are:
8600 dnl     libtool-version release-version patch-version
8601 dnl or
8602 dnl     release-version
8603 dnl where
8604 dnl     libtool-version (see ?) consists of 3 integers separated by '.'
8605 dnl     release-version consists of a major version and minor version
8606 dnl             separated by '.', optionally followed by a patch-version
8607 dnl             separated by '-'.  The minor version need not be an
8608 dnl             integer (but it is preferred).
8609 dnl     patch-version is an integer in the form yyyymmdd, so ifdef's and
8610 dnl             scripts can easily compare versions.
8611 dnl
8612 dnl If libtool is used, the first form is required, since CF_WITH_LIBTOOL
8613 dnl simply extracts the first field using 'cut -f1'.
8614 dnl
8615 dnl Optional parameters:
8616 dnl $1 = internal name for package
8617 dnl $2 = external name for package
8618 AC_DEFUN([CF_VERSION_INFO],
8619 [
8620 if test -f "$srcdir/VERSION" ; then
8621         AC_MSG_CHECKING(for package version)
8622
8623         # if there are not enough fields, cut returns the last one...
8624         cf_field1=`sed -e '2,$d' "$srcdir/VERSION" |cut -f1`
8625         cf_field2=`sed -e '2,$d' "$srcdir/VERSION" |cut -f2`
8626         cf_field3=`sed -e '2,$d' "$srcdir/VERSION" |cut -f3`
8627
8628         # this is how CF_BUNDLED_INTL uses $VERSION:
8629         VERSION="$cf_field1"
8630
8631         VERSION_MAJOR=`echo "$cf_field2" | sed -e 's/\..*//'`
8632         test -z "$VERSION_MAJOR" && AC_MSG_ERROR(missing major-version)
8633
8634         VERSION_MINOR=`echo "$cf_field2" | sed -e 's/^[[^.]]*\.//' -e 's/-.*//'`
8635         test -z "$VERSION_MINOR" && AC_MSG_ERROR(missing minor-version)
8636
8637         AC_MSG_RESULT(${VERSION_MAJOR}.${VERSION_MINOR})
8638
8639         AC_MSG_CHECKING(for package patch date)
8640         VERSION_PATCH=`echo "$cf_field3" | sed -e 's/^[[^-]]*-//'`
8641         case .$VERSION_PATCH in
8642         (.)
8643                 AC_MSG_ERROR(missing patch-date $VERSION_PATCH)
8644                 ;;
8645         (.[[0-9]][[0-9]][[0-9]][[0-9]][[0-9]][[0-9]][[0-9]][[0-9]])
8646                 ;;
8647         (*)
8648                 AC_MSG_ERROR(illegal patch-date $VERSION_PATCH)
8649                 ;;
8650         esac
8651         AC_MSG_RESULT($VERSION_PATCH)
8652 else
8653         AC_MSG_ERROR(did not find $srcdir/VERSION)
8654 fi
8655
8656 # show the actual data that we have for versions:
8657 CF_VERBOSE(ABI VERSION $VERSION)
8658 CF_VERBOSE(VERSION_MAJOR $VERSION_MAJOR)
8659 CF_VERBOSE(VERSION_MINOR $VERSION_MINOR)
8660 CF_VERBOSE(VERSION_PATCH $VERSION_PATCH)
8661
8662 AC_SUBST(VERSION)
8663 AC_SUBST(VERSION_MAJOR)
8664 AC_SUBST(VERSION_MINOR)
8665 AC_SUBST(VERSION_PATCH)
8666
8667 dnl if a package name is given, define its corresponding version info.  We
8668 dnl need the package name to ensure that the defined symbols are unique.
8669 ifelse($1,,,[
8670         cf_PACKAGE=$1
8671         PACKAGE=ifelse($2,,$1,$2)
8672         AC_DEFINE_UNQUOTED(PACKAGE, "$PACKAGE",[Define to the package-name])
8673         AC_SUBST(PACKAGE)
8674         CF_UPPER(cf_PACKAGE,$cf_PACKAGE)
8675         AC_DEFINE_UNQUOTED(${cf_PACKAGE}_VERSION,"${VERSION_MAJOR}.${VERSION_MINOR}")
8676         AC_DEFINE_UNQUOTED(${cf_PACKAGE}_PATCHDATE,${VERSION_PATCH})
8677 ])
8678 ])dnl
8679 dnl ---------------------------------------------------------------------------
8680 dnl CF_WCHAR_TYPE version: 4 updated: 2012/10/06 16:39:58
8681 dnl -------------
8682 dnl Check if type wide-character type $1 is declared, and if so, which header
8683 dnl file is needed.  The second parameter is used to set a shell variable when
8684 dnl the type is not found.  The first parameter sets a shell variable for the
8685 dnl opposite sense.
8686 AC_DEFUN([CF_WCHAR_TYPE],
8687 [
8688 # This is needed on Tru64 5.0 to declare $1
8689 AC_CACHE_CHECK(if we must include wchar.h to declare $1,cf_cv_$1,[
8690 AC_TRY_COMPILE([
8691 #include <stdlib.h>
8692 #include <stdarg.h>
8693 #include <stdio.h>
8694 #ifdef HAVE_LIBUTF8_H
8695 #include <libutf8.h>
8696 #endif],
8697         [$1 state],
8698         [cf_cv_$1=no],
8699         [AC_TRY_COMPILE([
8700 #include <stdlib.h>
8701 #include <stdarg.h>
8702 #include <stdio.h>
8703 #include <wchar.h>
8704 #ifdef HAVE_LIBUTF8_H
8705 #include <libutf8.h>
8706 #endif],
8707         [$1 value],
8708         [cf_cv_$1=yes],
8709         [cf_cv_$1=unknown])])])
8710
8711 if test "$cf_cv_$1" = yes ; then
8712         AC_DEFINE(NEED_WCHAR_H,1,[Define to 1 if we must include wchar.h])
8713         NEED_WCHAR_H=1
8714 fi
8715
8716 ifelse([$2],,,[
8717 # if we do not find $1 in either place, use substitution to provide a fallback.
8718 if test "$cf_cv_$1" = unknown ; then
8719         $2=1
8720 fi
8721 ])
8722 ifelse($3,,,[
8723 # if we find $1 in either place, use substitution to provide a fallback.
8724 if test "$cf_cv_$1" != unknown ; then
8725         $3=1
8726 fi
8727 ])
8728 ])dnl
8729 dnl ---------------------------------------------------------------------------
8730 dnl CF_WEAK_SYMBOLS version: 1 updated: 2008/08/16 19:18:06
8731 dnl ---------------
8732 dnl Check for compiler-support for weak symbols.
8733 dnl This works with "recent" gcc.
8734 AC_DEFUN([CF_WEAK_SYMBOLS],[
8735 AC_CACHE_CHECK(if $CC supports weak symbols,cf_cv_weak_symbols,[
8736
8737 AC_TRY_COMPILE([
8738 #include <stdio.h>],
8739 [
8740 #if defined(__GNUC__)
8741 #  if defined __USE_ISOC99
8742 #    define _cat_pragma(exp)    _Pragma(#exp)
8743 #    define _weak_pragma(exp)   _cat_pragma(weak name)
8744 #  else
8745 #    define _weak_pragma(exp)
8746 #  endif
8747 #  define _declare(name)        __extension__ extern __typeof__(name) name
8748 #  define weak_symbol(name)     _weak_pragma(name) _declare(name) __attribute__((weak))
8749 #endif
8750
8751 weak_symbol(fopen);
8752 ],[cf_cv_weak_symbols=yes],[cf_cv_weak_symbols=no])
8753 ])
8754 ])dnl
8755 dnl ---------------------------------------------------------------------------
8756 dnl CF_WITH_ABI_VERSION version: 4 updated: 2021/01/01 13:31:04
8757 dnl -------------------
8758 dnl Allow library's ABI to be overridden.  Generally this happens when a
8759 dnl packager has incremented the ABI past that used in the original package,
8760 dnl and wishes to keep doing this.
8761 dnl
8762 dnl $1 is the package name, if any, to derive a corresponding {package}_ABI
8763 dnl symbol.
8764 AC_DEFUN([CF_WITH_ABI_VERSION],[
8765 test -z "$cf_cv_abi_version" && cf_cv_abi_version=0
8766 AC_ARG_WITH(abi-version,
8767 [  --with-abi-version=XXX  override derived ABI version],[
8768         if test "x$cf_cv_abi_version" != "x$withval"
8769         then
8770                 AC_MSG_WARN(overriding ABI version $cf_cv_abi_version to $withval)
8771                 case "$cf_cv_rel_version" in
8772                 (5.*)
8773                         cf_cv_rel_version=$withval.0
8774                         ;;
8775                 (6.*)
8776                         cf_cv_rel_version=$withval.9    # FIXME: should be 10 as of 6.0 release
8777                         ;;
8778                 esac
8779         fi
8780         cf_cv_abi_version=$withval])
8781         CF_NUMBER_SYNTAX($cf_cv_abi_version,ABI version)
8782 ifelse($1,,,[
8783 $1_ABI=$cf_cv_abi_version
8784 ])
8785 ])dnl
8786 dnl ---------------------------------------------------------------------------
8787 dnl CF_WITH_ADA_COMPILER version: 2 updated: 2010/06/26 17:35:58
8788 dnl --------------------
8789 dnl Command-line option to specify the Ada95 compiler.
8790 AC_DEFUN([CF_WITH_ADA_COMPILER],[
8791 AC_MSG_CHECKING(for ada-compiler)
8792 AC_ARG_WITH(ada-compiler,
8793         [  --with-ada-compiler=CMD specify Ada95 compiler command (default gnatmake)],
8794         [cf_ada_compiler=$withval],
8795         [cf_ada_compiler=gnatmake])
8796 AC_SUBST(cf_ada_compiler)
8797 AC_MSG_RESULT($cf_ada_compiler)
8798 ])dnl
8799 dnl ---------------------------------------------------------------------------
8800 dnl CF_WITH_ADA_INCLUDE version: 2 updated: 2010/06/26 17:35:58
8801 dnl -------------------
8802 dnl Command-line option to specify where Ada includes will install.
8803 AC_DEFUN([CF_WITH_ADA_INCLUDE],[
8804 AC_MSG_CHECKING(for ada-include)
8805 CF_WITH_PATH(ada-include,
8806    [  --with-ada-include=DIR  Ada includes are in DIR],
8807    ADA_INCLUDE,
8808    PREFIX/share/ada/adainclude,
8809    [$]prefix/share/ada/adainclude)
8810 AC_SUBST(ADA_INCLUDE)
8811 AC_MSG_RESULT($ADA_INCLUDE)
8812 ])dnl
8813 dnl ---------------------------------------------------------------------------
8814 dnl CF_WITH_ADA_LIBNAME version: 1 updated: 2019/09/07 18:59:41
8815 dnl -------------------
8816 dnl CF_WITH_ADA_LIBNAME
8817 dnl -------------------
8818 dnl Command-line option to specify how to name the resulting Ada library.
8819 dnl $1 = default value
8820 AC_DEFUN([CF_WITH_ADA_LIBNAME],[
8821 AC_MSG_CHECKING(for ada-libname)
8822 AC_ARG_WITH(ada-libname,
8823    [  --with-ada-libname=XXX  override default Ada library-name],
8824    ADA_LIBNAME=[$]withval,
8825    ADA_LIBNAME=$1)
8826 case "x$ADA_LIBNAME" in
8827 (x|xyes|xno)
8828         ADA_LIBNAME=$1
8829         ;;
8830 esac
8831 AC_SUBST(ADA_LIBNAME)
8832 AC_MSG_RESULT($ADA_LIBNAME)
8833 ])dnl
8834 dnl ---------------------------------------------------------------------------
8835 dnl CF_WITH_ADA_OBJECTS version: 2 updated: 2010/06/26 17:35:58
8836 dnl -------------------
8837 dnl Command-line option to specify where Ada objects will install.
8838 AC_DEFUN([CF_WITH_ADA_OBJECTS],[
8839 AC_MSG_CHECKING(for ada-objects)
8840 CF_WITH_PATH(ada-objects,
8841    [  --with-ada-objects=DIR  Ada objects are in DIR],
8842    ADA_OBJECTS,
8843    PREFIX/lib/ada/adalib,
8844    [$]prefix/lib/ada/adalib)
8845 AC_SUBST(ADA_OBJECTS)
8846 AC_MSG_RESULT($ADA_OBJECTS)
8847 ])dnl
8848 dnl ---------------------------------------------------------------------------
8849 dnl CF_WITH_ADA_SHAREDLIB version: 5 updated: 2018/07/21 19:10:35
8850 dnl ---------------------
8851 dnl Command-line option to specify if an Ada95 shared-library should be built,
8852 dnl and optionally what its soname should be.
8853 AC_DEFUN([CF_WITH_ADA_SHAREDLIB],[
8854 AC_REQUIRE([CF_GNAT_PROJECTS])
8855 AC_MSG_CHECKING(if an Ada95 shared-library should be built)
8856 AC_ARG_WITH(ada-sharedlib,
8857         [  --with-ada-sharedlib=soname build shared-library (requires GNAT projects)],
8858         [with_ada_sharedlib=$withval],
8859         [with_ada_sharedlib=no])
8860 AC_MSG_RESULT($with_ada_sharedlib)
8861
8862 if test "x$with_ada_sharedlib" != xno
8863 then
8864         if test "x$cf_gnat_projects" != xyes
8865         then
8866                 AC_MSG_WARN(disabling shared-library since GNAT projects are not supported)
8867                 with_ada_sharedlib=no
8868         fi
8869 fi
8870
8871 ADA_SHAREDLIB='lib$(LIB_NAME).so.1'
8872 MAKE_ADA_SHAREDLIB="#"
8873
8874 if test "x$with_ada_sharedlib" != xno
8875 then
8876         MAKE_ADA_SHAREDLIB=
8877         if test "x$with_ada_sharedlib" != xyes
8878         then
8879                 ADA_SHAREDLIB="$with_ada_sharedlib"
8880         fi
8881 fi
8882
8883 AC_SUBST(ADA_SHAREDLIB)
8884 AC_SUBST(MAKE_ADA_SHAREDLIB)
8885 ])dnl
8886 dnl ---------------------------------------------------------------------------
8887 dnl CF_WITH_DBMALLOC version: 7 updated: 2010/06/21 17:26:47
8888 dnl ----------------
8889 dnl Configure-option for dbmalloc.  The optional parameter is used to override
8890 dnl the updating of $LIBS, e.g., to avoid conflict with subsequent tests.
8891 AC_DEFUN([CF_WITH_DBMALLOC],[
8892 CF_NO_LEAKS_OPTION(dbmalloc,
8893         [  --with-dbmalloc         test: use Conor Cahill's dbmalloc library],
8894         [USE_DBMALLOC])
8895
8896 if test "$with_dbmalloc" = yes ; then
8897         AC_CHECK_HEADER(dbmalloc.h,
8898                 [AC_CHECK_LIB(dbmalloc,[debug_malloc]ifelse([$1],,[],[,$1]))])
8899 fi
8900 ])dnl
8901 dnl ---------------------------------------------------------------------------
8902 dnl CF_WITH_DMALLOC version: 7 updated: 2010/06/21 17:26:47
8903 dnl ---------------
8904 dnl Configure-option for dmalloc.  The optional parameter is used to override
8905 dnl the updating of $LIBS, e.g., to avoid conflict with subsequent tests.
8906 AC_DEFUN([CF_WITH_DMALLOC],[
8907 CF_NO_LEAKS_OPTION(dmalloc,
8908         [  --with-dmalloc          test: use Gray Watson's dmalloc library],
8909         [USE_DMALLOC])
8910
8911 if test "$with_dmalloc" = yes ; then
8912         AC_CHECK_HEADER(dmalloc.h,
8913                 [AC_CHECK_LIB(dmalloc,[dmalloc_debug]ifelse([$1],,[],[,$1]))])
8914 fi
8915 ])dnl
8916 dnl ---------------------------------------------------------------------------
8917 dnl CF_WITH_EXPORT_SYMS version: 3 updated: 2014/12/20 19:16:08
8918 dnl -------------------
8919 dnl Use this with libtool to specify the list of symbols that may be exported.
8920 dnl The input file contains one symbol per line; comments work with "#".
8921 dnl
8922 dnl $1 = basename of the ".sym" file (default $PACKAGE)
8923 AC_DEFUN([CF_WITH_EXPORT_SYMS],
8924 [
8925 AC_MSG_CHECKING(if exported-symbols file should be used)
8926 AC_ARG_WITH(export-syms,
8927         [  --with-export-syms=XXX  limit exported symbols using libtool],
8928         [with_export_syms=$withval],
8929         [with_export_syms=no])
8930 if test "x$with_export_syms" = xyes
8931 then
8932         with_export_syms='${top_srcdir}/package/ifelse($1,,${PACKAGE},[$1]).sym'
8933         AC_SUBST(PACKAGE)
8934 fi
8935 AC_MSG_RESULT($with_export_syms)
8936 if test "x$with_export_syms" != xno
8937 then
8938         EXPORT_SYMS="-export-symbols $with_export_syms"
8939         AC_SUBST(EXPORT_SYMS)
8940 fi
8941 ])dnl
8942 dnl ---------------------------------------------------------------------------
8943 dnl CF_WITH_GPM version: 10 updated: 2017/04/29 18:32:18
8944 dnl -----------
8945 dnl
8946 dnl The option parameter (if neither yes/no) is assumed to be the name of
8947 dnl the gpm library, e.g., for dynamic loading.
8948 AC_DEFUN([CF_WITH_GPM],
8949 [
8950 AC_MSG_CHECKING(if you want to link with the GPM mouse library)
8951 AC_ARG_WITH(gpm,
8952         [  --with-gpm              use Alessandro Rubini's GPM library],
8953         [with_gpm=$withval],
8954         [with_gpm=maybe])
8955 AC_MSG_RESULT($with_gpm)
8956
8957 if test "$with_gpm" != no ; then
8958         AC_CHECK_HEADER(gpm.h,[
8959                 AC_DEFINE(HAVE_GPM_H,1,[Define to 1 if we have gpm.h header])
8960                 if test "$with_gpm" != yes && test "$with_gpm" != maybe ; then
8961                         CF_VERBOSE(assuming we really have GPM library)
8962                         AC_DEFINE(HAVE_LIBGPM,1,[Define to 1 if we have the gpm library])
8963                         with_gpm=yes
8964                 else
8965                         AC_CHECK_LIB(gpm,Gpm_Open,[with_gpm=yes],[
8966                                 if test "$with_gpm" = maybe; then
8967                                         AC_MSG_WARN(Cannot link with GPM library)
8968                                         with_gpm=no
8969                                 else
8970                                         AC_MSG_ERROR(Cannot link with GPM library)
8971                                 fi
8972                         ])
8973                 fi
8974         ],[
8975                 test "$with_gpm" != maybe && AC_MSG_WARN(Cannot find GPM header)
8976                 with_gpm=no
8977         ])
8978 fi
8979 ])
8980 dnl ---------------------------------------------------------------------------
8981 dnl CF_WITH_LIBTOOL version: 36 updated: 2021/01/01 13:31:04
8982 dnl ---------------
8983 dnl Provide a configure option to incorporate libtool.  Define several useful
8984 dnl symbols for the makefile rules.
8985 dnl
8986 dnl The reference to AC_PROG_LIBTOOL does not normally work, since it uses
8987 dnl macros from libtool.m4 which is in the aclocal directory of automake.
8988 dnl Following is a simple script which turns on the AC_PROG_LIBTOOL macro.
8989 dnl But that still does not work properly since the macro is expanded outside
8990 dnl the CF_WITH_LIBTOOL macro:
8991 dnl
8992 dnl     #!/bin/sh
8993 dnl     ACLOCAL=`aclocal --print-ac-dir`
8994 dnl     if test -z "$ACLOCAL" ; then
8995 dnl             echo cannot find aclocal directory
8996 dnl             exit 1
8997 dnl     elif test ! -f $ACLOCAL/libtool.m4 ; then
8998 dnl             echo cannot find libtool.m4 file
8999 dnl             exit 1
9000 dnl     fi
9001 dnl
9002 dnl     LOCAL=aclocal.m4
9003 dnl     ORIG=aclocal.m4.orig
9004 dnl
9005 dnl     trap "mv $ORIG $LOCAL" 0 1 2 3 15
9006 dnl     rm -f $ORIG
9007 dnl     mv $LOCAL $ORIG
9008 dnl
9009 dnl     # sed the LIBTOOL= assignment to omit the current directory?
9010 dnl     sed -e 's/^LIBTOOL=.*/LIBTOOL=${LIBTOOL:-libtool}/' $ACLOCAL/libtool.m4 >>$LOCAL
9011 dnl     cat $ORIG >>$LOCAL
9012 dnl
9013 dnl     autoconf-257 $*
9014 dnl
9015 AC_DEFUN([CF_WITH_LIBTOOL],
9016 [
9017 AC_REQUIRE([CF_DISABLE_LIBTOOL_VERSION])
9018 ifdef([AC_PROG_LIBTOOL],,[
9019 LIBTOOL=
9020 ])
9021 # common library maintenance symbols that are convenient for libtool scripts:
9022 LIB_CREATE='${AR} -cr'
9023 LIB_OBJECT='${OBJECTS}'
9024 LIB_SUFFIX=.a
9025 LIB_PREP="$RANLIB"
9026
9027 # symbols used to prop libtool up to enable it to determine what it should be
9028 # doing:
9029 LIB_CLEAN=
9030 LIB_COMPILE=
9031 LIB_LINK='${CC}'
9032 LIB_INSTALL=
9033 LIB_UNINSTALL=
9034
9035 AC_MSG_CHECKING(if you want to build libraries with libtool)
9036 AC_ARG_WITH(libtool,
9037         [  --with-libtool          generate libraries with libtool],
9038         [with_libtool=$withval],
9039         [with_libtool=no])
9040 AC_MSG_RESULT($with_libtool)
9041 if test "$with_libtool" != "no"; then
9042 ifdef([AC_PROG_LIBTOOL],[
9043         # missing_content_AC_PROG_LIBTOOL{{
9044         AC_PROG_LIBTOOL
9045         # missing_content_AC_PROG_LIBTOOL}}
9046 ],[
9047         if test "$with_libtool" != "yes" ; then
9048                 CF_PATH_SYNTAX(with_libtool)
9049                 LIBTOOL=$with_libtool
9050         else
9051                 AC_CHECK_TOOLS(LIBTOOL,[libtool glibtool],none)
9052                 CF_LIBTOOL_VERSION
9053                 if test -z "$cf_cv_libtool_version" && test "$LIBTOOL" = libtool
9054                 then
9055                         CF_FORGET_TOOL(LIBTOOL)
9056                         AC_CHECK_TOOLS(LIBTOOL,[glibtool],none)
9057                         CF_LIBTOOL_VERSION
9058                 fi
9059         fi
9060         if test -z "$LIBTOOL" ; then
9061                 AC_MSG_ERROR(Cannot find libtool)
9062         fi
9063 ])dnl
9064         LIB_CREATE='${LIBTOOL} --mode=link ${CC} -rpath ${libdir} ${LIBTOOL_VERSION} `cut -f1 ${top_srcdir}/VERSION` ${LIBTOOL_OPTS} ${LT_UNDEF} $(LIBS) -o'
9065         LIB_OBJECT='${OBJECTS:.o=.lo}'
9066         LIB_SUFFIX=.la
9067         LIB_CLEAN='${LIBTOOL} --mode=clean'
9068         LIB_COMPILE='${LIBTOOL} --mode=compile'
9069         LIB_LINK='${LIBTOOL} --mode=link ${CC} ${LIBTOOL_OPTS}'
9070         LIB_INSTALL='${LIBTOOL} --mode=install'
9071         LIB_UNINSTALL='${LIBTOOL} --mode=uninstall'
9072         LIB_PREP=:
9073
9074         CF_CHECK_LIBTOOL_VERSION
9075
9076         # special hack to add -no-undefined (which libtool should do for itself)
9077         LT_UNDEF=
9078         case "$cf_cv_system_name" in
9079         (cygwin*|msys*|mingw32*|os2*|uwin*|aix[[4-7]])
9080                 LT_UNDEF=-no-undefined
9081                 ;;
9082         esac
9083         AC_SUBST([LT_UNDEF])
9084
9085         # special hack to add --tag option for C++ compiler
9086         case "$cf_cv_libtool_version" in
9087         (1.[[5-9]]*|[[2-9]].[[0-9.a-z]]*)
9088                 LIBTOOL_CXX="$LIBTOOL --tag=CXX"
9089                 LIBTOOL="$LIBTOOL --tag=CC"
9090                 ;;
9091         (*)
9092                 LIBTOOL_CXX="$LIBTOOL"
9093                 ;;
9094         esac
9095 else
9096         LIBTOOL=""
9097         LIBTOOL_CXX=""
9098 fi
9099
9100 test -z "$LIBTOOL" && ECHO_LT=
9101
9102 AC_SUBST(LIBTOOL)
9103 AC_SUBST(LIBTOOL_CXX)
9104 AC_SUBST(LIBTOOL_OPTS)
9105
9106 AC_SUBST(LIB_CREATE)
9107 AC_SUBST(LIB_OBJECT)
9108 AC_SUBST(LIB_SUFFIX)
9109 AC_SUBST(LIB_PREP)
9110
9111 AC_SUBST(LIB_CLEAN)
9112 AC_SUBST(LIB_COMPILE)
9113 AC_SUBST(LIB_LINK)
9114 AC_SUBST(LIB_INSTALL)
9115 AC_SUBST(LIB_UNINSTALL)
9116
9117 ])dnl
9118 dnl ---------------------------------------------------------------------------
9119 dnl CF_WITH_LIBTOOL_OPTS version: 4 updated: 2015/04/17 21:13:04
9120 dnl --------------------
9121 dnl Allow user to pass additional libtool options into the library creation
9122 dnl and link steps.  The main use for this is to do something like
9123 dnl     ./configure --with-libtool-opts=-static
9124 dnl to get the same behavior as automake-flavored
9125 dnl     ./configure --enable-static
9126 AC_DEFUN([CF_WITH_LIBTOOL_OPTS],[
9127 AC_MSG_CHECKING(for additional libtool options)
9128 AC_ARG_WITH(libtool-opts,
9129         [  --with-libtool-opts=XXX specify additional libtool options],
9130         [with_libtool_opts=$withval],
9131         [with_libtool_opts=no])
9132 AC_MSG_RESULT($with_libtool_opts)
9133
9134 case .$with_libtool_opts in
9135 (.yes|.no|.)
9136         ;;
9137 (*)
9138         LIBTOOL_OPTS="$LIBTOOL_OPTS $with_libtool_opts"
9139         ;;
9140 esac
9141
9142 AC_SUBST(LIBTOOL_OPTS)
9143 ])dnl
9144 dnl ---------------------------------------------------------------------------
9145 dnl CF_WITH_LIB_BASENAME version: 1 updated: 2020/03/07 20:05:14
9146 dnl --------------------
9147 dnl Allow for overriding the basename of a library, i.e., the part to which
9148 dnl prefixes/suffixes are attached.
9149 dnl
9150 dnl $1 = variable to set
9151 dnl $2 = option name
9152 dnl $3 = default basename for library, if omitted use $2
9153 AC_DEFUN([CF_WITH_LIB_BASENAME],
9154 [
9155 AC_MSG_CHECKING(for desired basename for $2 library)
9156 AC_ARG_WITH($2-libname,
9157         [  --with-$2-libname=XXX override ifelse($3,,$2,$3) basename of library],
9158         [with_lib_basename=$withval],
9159         [with_lib_basename=ifelse($3,,$2,$3)])
9160 $1="$with_lib_basename"
9161
9162 case "x[$]$1" in
9163 (x|xno|xnone|xyes)
9164         $1=ifelse($3,,$2,$3)
9165         ;;
9166 (*)
9167         ;;
9168 esac
9169
9170 AC_MSG_RESULT([$]$1)
9171 AC_SUBST($1)
9172 ])dnl
9173 dnl ---------------------------------------------------------------------------
9174 dnl CF_WITH_LIB_PREFIX version: 2 updated: 2021/01/01 16:53:59
9175 dnl ------------------
9176 dnl Allow the library-prefix to be overridden.  OS/2 EMX originally had no
9177 dnl "lib" prefix, e.g., because it used the dll naming convention.
9178 dnl
9179 dnl $1 = variable to set
9180 AC_DEFUN([CF_WITH_LIB_PREFIX],
9181 [
9182 AC_MSG_CHECKING(if you want to have a library-prefix)
9183 AC_ARG_WITH(lib-prefix,
9184         [  --with-lib-prefix       override library-prefix],
9185         [with_lib_prefix=$withval],
9186         [with_lib_prefix=auto])
9187 AC_MSG_RESULT($with_lib_prefix)
9188
9189 if test "$with_lib_prefix" = auto
9190 then
9191         CF_LIB_PREFIX($1)
9192 elif test "$with_lib_prefix" = no
9193 then
9194         LIB_PREFIX=
9195 else
9196         LIB_PREFIX=$with_lib_prefix
9197 fi
9198 ])dnl
9199 dnl ---------------------------------------------------------------------------
9200 dnl CF_WITH_PATH version: 12 updated: 2021/09/04 06:35:04
9201 dnl ------------
9202 dnl Wrapper for AC_ARG_WITH to ensure that user supplies a pathname, not just
9203 dnl defaulting to yes/no.
9204 dnl
9205 dnl $1 = option name
9206 dnl $2 = help-text
9207 dnl $3 = environment variable to set
9208 dnl $4 = default value, shown in the help-message, must be a constant
9209 dnl $5 = default value, if it is an expression & cannot be in the help-message
9210 dnl
9211 AC_DEFUN([CF_WITH_PATH],
9212 [AC_ARG_WITH($1,[$2 ](default: ifelse([$4],,empty,[$4])),,
9213 ifelse([$4],,[withval="${$3}"],[withval="${$3:-ifelse([$5],,[$4],[$5])}"]))dnl
9214 if ifelse([$5],,true,[test -n "$5"]) ; then
9215 CF_PATH_SYNTAX(withval)
9216 fi
9217 eval $3="$withval"
9218 AC_SUBST($3)dnl
9219 ])dnl
9220 dnl ---------------------------------------------------------------------------
9221 dnl CF_WITH_PATHLIST version: 13 updated: 2021/09/04 06:35:04
9222 dnl ----------------
9223 dnl Process an option specifying a list of colon-separated paths.
9224 dnl
9225 dnl $1 = option name
9226 dnl $2 = help-text
9227 dnl $3 = environment variable to set
9228 dnl $4 = default value, shown in the help-message, must be a constant
9229 dnl $5 = default value, if it is an expression & cannot be in the help-message
9230 dnl $6 = flag to tell if we want to define or substitute
9231 dnl
9232 AC_DEFUN([CF_WITH_PATHLIST],[
9233 AC_REQUIRE([CF_PATHSEP])
9234 AC_ARG_WITH($1,[$2 ](default: ifelse($4,,empty,$4)),,
9235 ifelse($4,,[withval=${$3}],[withval=${$3:-ifelse($5,,$4,$5)}]))dnl
9236
9237 IFS="${IFS:-    }"; ac_save_ifs="$IFS"; IFS="${PATH_SEPARATOR}"
9238 cf_dst_path=
9239 for cf_src_path in $withval
9240 do
9241   CF_PATH_SYNTAX(cf_src_path)
9242   test -n "$cf_dst_path" && cf_dst_path="${cf_dst_path}$PATH_SEPARATOR"
9243   cf_dst_path="${cf_dst_path}${cf_src_path}"
9244 done
9245 IFS="$ac_save_ifs"
9246
9247 ifelse($6,define,[
9248 # Strip single quotes from the value, e.g., when it was supplied as a literal
9249 # for $4 or $5.
9250 case "$cf_dst_path" in
9251 (\'*)
9252   cf_dst_path="`echo "$cf_dst_path" |sed -e s/\'// -e s/\'\$//`"
9253   ;;
9254 esac
9255 cf_dst_path=`echo "$cf_dst_path" | sed -e 's/\\\\/\\\\\\\\/g'`
9256 ])
9257
9258 # This may use the prefix/exec_prefix symbols which will only yield "NONE"
9259 # so we have to check/work around.  We do prefer the result of "eval"...
9260 eval cf_dst_eval="$cf_dst_path"
9261 case "x$cf_dst_eval" in
9262 (xNONE*)
9263         $3=$cf_dst_path
9264         ;;
9265 (*)
9266         $3="$cf_dst_eval"
9267         ;;
9268 esac
9269 AC_SUBST($3)dnl
9270
9271 ])dnl
9272 dnl ---------------------------------------------------------------------------
9273 dnl CF_WITH_PATH_PROG version: 1 updated: 2019/06/30 19:44:43
9274 dnl -----------------
9275 dnl Check for a given program, like CF_PATH_PROG, but allow override using a
9276 dnl "--with-xxx" option.
9277 dnl
9278 dnl Parameters:
9279 dnl             $1 = environment variable to set/update
9280 dnl             $2 = program name
9281 dnl             $3 = help-text
9282 dnl             $4 = $PATH
9283 AC_DEFUN([CF_WITH_PATH_PROG],[
9284 AC_ARG_WITH($2-path,
9285         [  --with-$2-path=XXX     specify path of $2 ifelse($3,,,$3)],
9286         [AC_MSG_CHECKING(for $2 program ifelse($3,,,$3))
9287                 $1=$withval
9288                 AC_MSG_RESULT([$]$1)
9289                 CF_PATH_SYNTAX($1)
9290         ],
9291         [CF_PATH_PROG($1,$2,,ifelse($4,,,$4))
9292                 if test -z "[$]$1"
9293                 then
9294                         AC_MSG_WARN(no $2 program found ifelse($3,,,$3))
9295                 fi
9296         ])
9297 ])
9298 dnl ---------------------------------------------------------------------------
9299 dnl CF_WITH_PCRE2 version: 6 updated: 2021/08/11 20:35:34
9300 dnl -------------
9301 dnl Add PCRE2 (Perl-compatible regular expressions v2) to the build if it is
9302 dnl available and the user requests it.  Assume the application will otherwise
9303 dnl use the POSIX interface.
9304 dnl
9305 dnl TODO allow $withval to specify package location
9306 AC_DEFUN([CF_WITH_PCRE2],
9307 [
9308 AC_REQUIRE([CF_PKG_CONFIG])
9309
9310 AC_MSG_CHECKING(if you want to use PCRE2 for regular-expressions)
9311 AC_ARG_WITH(pcre2,
9312         [  --with-pcre2            use PCRE2 for regular-expressions])
9313 test -z "$with_pcre2" && with_pcre2=no
9314 AC_MSG_RESULT($with_pcre2)
9315
9316 if test "x$with_pcre2" != xno ; then
9317         cf_with_pcre2_ok=no
9318         for cf_with_pcre2 in libpcre2 libpcre2-posix libpcre
9319         do
9320                 CF_TRY_PKG_CONFIG($cf_with_pcre2,[cf_with_pcre2_ok=yes; break])
9321         done
9322         cf_with_pcre2_ok=yes || AC_MSG_ERROR(Cannot find PCRE2 library)
9323
9324         AC_DEFINE(HAVE_LIB_PCRE2,1,[Define to 1 if we can/should compile with the PCRE2 library])
9325
9326         # if pkgconfig gave no results, look for the libraries directly
9327         case "$LIBS" in
9328         (*pcre2-posix*|*pcreposix*)
9329                 ;;
9330         (*)
9331                 AC_CHECK_LIB(pcre2-posix,regcomp,[
9332                         CF_ADD_LIB(pcre2-posix)],
9333                         [AC_CHECK_LIB(pcreposix,regcomp,[
9334                          CF_ADD_LIB(pcreposix)
9335                         ],[AC_MSG_ERROR(Cannot find PCRE2 POSIX library)])])
9336                 ;;
9337         esac
9338
9339         # either way, check for the library header files
9340         AC_CHECK_HEADERS(pcre2posix.h pcreposix.h)
9341         AC_CHECK_FUNCS(PCRE2regcomp)
9342 fi
9343 ])dnl
9344 dnl ---------------------------------------------------------------------------
9345 dnl CF_WITH_PKG_CONFIG_LIBDIR version: 20 updated: 2022/01/29 17:03:42
9346 dnl -------------------------
9347 dnl Allow the choice of the pkg-config library directory to be overridden.
9348 dnl
9349 dnl pkg-config uses a search-list built from these colon-separated lists of
9350 dnl directories:
9351 dnl a) $PKG_CONFIG_PATH (tested first, added if set)
9352 dnl b) $PKG_CONFIG_LIBDIR (tested second, added if set)
9353 dnl c) builtin-list (added if $PKG_CONFIG_LIBDIR is not set)
9354 dnl
9355 dnl pkgconf (used with some systems such as FreeBSD in place of pkg-config)
9356 dnl optionally ignores $PKG_CONFIG_LIBDIR.
9357 AC_DEFUN([CF_WITH_PKG_CONFIG_LIBDIR],[
9358
9359 case "$PKG_CONFIG" in
9360 (no|none|yes)
9361         AC_MSG_CHECKING(for pkg-config library directory)
9362         ;;
9363 (*)
9364         AC_MSG_CHECKING(for $PKG_CONFIG library directory)
9365         ;;
9366 esac
9367
9368 # if $PKG_CONFIG_LIBDIR is set, try to use that
9369 cf_search_path=`echo "$PKG_CONFIG_LIBDIR" | sed -e 's/:/ /g' -e 's,^[[  ]]*,,'`
9370
9371 # if the option is used, let that override.  otherwise default to "libdir"
9372 AC_ARG_WITH(pkg-config-libdir,
9373         [  --with-pkg-config-libdir=XXX use given directory for installing pc-files],
9374         [cf_search_path=$withval],
9375         [test "x$PKG_CONFIG" != xnone && test -z "$cf_search_path" && cf_search_path=libdir])
9376
9377 case "x$cf_search_path" in
9378 (xlibdir)
9379         PKG_CONFIG_LIBDIR='${libdir}/pkgconfig'
9380         AC_MSG_RESULT($PKG_CONFIG_LIBDIR)
9381         cf_search_path=
9382         ;;
9383 (x)
9384         ;;
9385 (x/*\ *)
9386         PKG_CONFIG_LIBDIR=
9387         ;;
9388 (x/*)
9389         PKG_CONFIG_LIBDIR="$cf_search_path"
9390         AC_MSG_RESULT($PKG_CONFIG_LIBDIR)
9391         cf_search_path=
9392         ;;
9393 (xyes|xauto)
9394         AC_MSG_RESULT(auto)
9395         cf_search_path=
9396         # Look for the library directory using the same prefix as the executable
9397         AC_MSG_CHECKING(for search-list)
9398         if test "x$PKG_CONFIG" != xnone
9399         then
9400                 # works for pkg-config since version 0.24 (2009)
9401                 # works for pkgconf since version 0.8.3 (2012)
9402                 for cf_pkg_program in \
9403                         `echo "$PKG_CONFIG" | sed -e 's,^.*/,,'` \
9404                         pkg-config \
9405                         pkgconf
9406                 do
9407                         cf_search_path=`"$PKG_CONFIG" --variable=pc_path "$cf_pkg_program" 2>/dev/null | tr : ' '`
9408                         test -n "$cf_search_path" && break
9409                 done
9410
9411                 # works for pkg-config since import in 2005 of original 2001 HP code.
9412                 test -z "$cf_search_path" && \
9413                 cf_search_path=`
9414                 "$PKG_CONFIG" --debug --exists no-such-package 2>&1 | $AWK "\
9415 /^Scanning directory (#[1-9][0-9]* )?'.*'$/{ \
9416         sub(\"^[[^']]*'\",\"\"); \
9417         sub(\"'.*\",\"\"); \
9418         printf \" %s\", \\[$]0; } \
9419 { next; } \
9420 "`
9421         fi
9422
9423         AC_MSG_RESULT($cf_search_path)
9424         ;;
9425 (*)
9426         AC_MSG_ERROR(Unexpected option value: $cf_search_path)
9427         ;;
9428 esac
9429
9430 if test -n "$cf_search_path"
9431 then
9432         AC_MSG_CHECKING(for first directory)
9433         cf_pkg_config_path=none
9434         for cf_config in $cf_search_path
9435         do
9436                 if test -d "$cf_config"
9437                 then
9438                         cf_pkg_config_path=$cf_config
9439                         break
9440                 fi
9441         done
9442         AC_MSG_RESULT($cf_pkg_config_path)
9443
9444         if test "x$cf_pkg_config_path" != xnone ; then
9445                 # limit this to the first directory found
9446                 PKG_CONFIG_LIBDIR="$cf_pkg_config_path"
9447         fi
9448
9449         if test -z "$PKG_CONFIG_LIBDIR" && test -n "$cf_search_path"
9450         then
9451                 AC_MSG_CHECKING(for workaround)
9452                 if test "$prefix" = "NONE" ; then
9453                         cf_prefix="$ac_default_prefix"
9454                 else
9455                         cf_prefix="$prefix"
9456                 fi
9457                 eval cf_libdir=$libdir
9458                 cf_libdir=`echo "$cf_libdir" | sed -e "s,^NONE,$cf_prefix,"`
9459                 cf_backup=
9460                 for cf_config in $cf_search_path
9461                 do
9462                         case $cf_config in
9463                         $cf_libdir/pkgconfig)
9464                                 PKG_CONFIG_LIBDIR=$cf_libdir/pkgconfig
9465                                 break
9466                                 ;;
9467                         *)
9468                                 test -z "$cf_backup" && cf_backup=$cf_config
9469                                 ;;
9470                         esac
9471                 done
9472                 test -z "$PKG_CONFIG_LIBDIR" && PKG_CONFIG_LIBDIR=$cf_backup
9473                 AC_MSG_RESULT($PKG_CONFIG_LIBDIR)
9474         fi
9475 fi
9476
9477 AC_SUBST(PKG_CONFIG_LIBDIR)
9478 ])dnl
9479 dnl ---------------------------------------------------------------------------
9480 dnl CF_WITH_PTHREAD version: 7 updated: 2015/04/18 08:56:57
9481 dnl ---------------
9482 dnl Check for POSIX thread library.
9483 AC_DEFUN([CF_WITH_PTHREAD],
9484 [
9485 AC_MSG_CHECKING(if you want to link with the pthread library)
9486 AC_ARG_WITH(pthread,
9487         [  --with-pthread          use POSIX thread library],
9488         [with_pthread=$withval],
9489         [with_pthread=no])
9490 AC_MSG_RESULT($with_pthread)
9491
9492 if test "$with_pthread" != no ; then
9493         AC_CHECK_HEADER(pthread.h,[
9494         AC_DEFINE(HAVE_PTHREADS_H,1,[Define to 1 if we have pthreads.h header])
9495
9496         for cf_lib_pthread in pthread c_r
9497         do
9498             AC_MSG_CHECKING(if we can link with the $cf_lib_pthread library)
9499             cf_save_LIBS="$LIBS"
9500             CF_ADD_LIB($cf_lib_pthread)
9501             AC_TRY_LINK([
9502 #include <pthread.h>
9503 ],[
9504                 int rc = pthread_create(0,0,0,0);
9505                 int r2 = pthread_mutexattr_settype(0, 0);
9506 ],[with_pthread=yes],[with_pthread=no])
9507             LIBS="$cf_save_LIBS"
9508             AC_MSG_RESULT($with_pthread)
9509             test "$with_pthread" = yes && break
9510         done
9511
9512         if test "$with_pthread" = yes ; then
9513             CF_ADD_LIB($cf_lib_pthread)
9514             AC_DEFINE(HAVE_LIBPTHREADS,1,[Define to 1 if we have pthreads library])
9515         else
9516             AC_MSG_ERROR(Cannot link with pthread library)
9517         fi
9518         ])
9519 fi
9520 ])
9521 dnl ---------------------------------------------------------------------------
9522 dnl CF_WITH_REL_VERSION version: 1 updated: 2003/09/20 18:12:49
9523 dnl -------------------
9524 dnl Allow library's release-version to be overridden.  Generally this happens when a
9525 dnl packager has incremented the release-version past that used in the original package,
9526 dnl and wishes to keep doing this.
9527 dnl
9528 dnl $1 is the package name, if any, to derive corresponding {package}_MAJOR
9529 dnl and {package}_MINOR symbols
9530 dnl symbol.
9531 AC_DEFUN([CF_WITH_REL_VERSION],[
9532 test -z "$cf_cv_rel_version" && cf_cv_rel_version=0.0
9533 AC_ARG_WITH(rel-version,
9534 [  --with-rel-version=XXX  override derived release version],
9535 [AC_MSG_WARN(overriding release version $cf_cv_rel_version to $withval)
9536  cf_cv_rel_version=$withval])
9537 ifelse($1,,[
9538  CF_NUMBER_SYNTAX($cf_cv_rel_version,Release version)
9539 ],[
9540  $1_MAJOR=`echo "$cf_cv_rel_version" | sed -e 's/\..*//'`
9541  $1_MINOR=`echo "$cf_cv_rel_version" | sed -e 's/^[[^.]]*//' -e 's/^\.//' -e 's/\..*//'`
9542  CF_NUMBER_SYNTAX([$]$1_MAJOR,Release major-version)
9543  CF_NUMBER_SYNTAX([$]$1_MINOR,Release minor-version)
9544 ])
9545 ])dnl
9546 dnl ---------------------------------------------------------------------------
9547 dnl CF_WITH_SYSMOUSE version: 3 updated: 2012/10/06 17:56:13
9548 dnl ----------------
9549 dnl If we can compile with sysmouse, make it available unless it is not wanted.
9550 AC_DEFUN([CF_WITH_SYSMOUSE],[
9551 # not everyone has "test -c"
9552 if test -c /dev/sysmouse 2>/dev/null ; then
9553 AC_MSG_CHECKING(if you want to use sysmouse)
9554 AC_ARG_WITH(sysmouse,
9555         [  --with-sysmouse         use sysmouse (FreeBSD console)],
9556         [cf_with_sysmouse=$withval],
9557         [cf_with_sysmouse=maybe])
9558         if test "$cf_with_sysmouse" != no ; then
9559         AC_TRY_COMPILE([
9560 #include <osreldate.h>
9561 #if (__FreeBSD_version >= 400017)
9562 #include <sys/consio.h>
9563 #include <sys/fbio.h>
9564 #else
9565 #include <machine/console.h>
9566 #endif
9567 ],[
9568         struct mouse_info the_mouse;
9569         ioctl(0, CONS_MOUSECTL, &the_mouse);
9570 ],[cf_with_sysmouse=yes],[cf_with_sysmouse=no])
9571         fi
9572 AC_MSG_RESULT($cf_with_sysmouse)
9573 test "$cf_with_sysmouse" = yes && AC_DEFINE(USE_SYSMOUSE,1,[Define to 1 if we can/should use the sysmouse interface])
9574 fi
9575 ])dnl
9576 dnl ---------------------------------------------------------------------------
9577 dnl CF_WITH_SYSTYPE version: 1 updated: 2013/01/26 16:26:12
9578 dnl ---------------
9579 dnl For testing, override the derived host system-type which is used to decide
9580 dnl things such as the linker commands used to build shared libraries.  This is
9581 dnl normally chosen automatically based on the type of system which you are
9582 dnl building on.  We use it for testing the configure script.
9583 dnl
9584 dnl This is different from the --host option: it is used only for testing parts
9585 dnl of the configure script which would not be reachable with --host since that
9586 dnl relies on the build environment being real, rather than mocked up.
9587 AC_DEFUN([CF_WITH_SYSTYPE],[
9588 CF_CHECK_CACHE([AC_CANONICAL_SYSTEM])
9589 AC_ARG_WITH(system-type,
9590         [  --with-system-type=XXX  test: override derived host system-type],
9591 [AC_MSG_WARN(overriding system type to $withval)
9592         cf_cv_system_name=$withval
9593         host_os=$withval
9594 ])
9595 ])dnl
9596 dnl ---------------------------------------------------------------------------
9597 dnl CF_WITH_VALGRIND version: 1 updated: 2006/12/14 18:00:21
9598 dnl ----------------
9599 AC_DEFUN([CF_WITH_VALGRIND],[
9600 CF_NO_LEAKS_OPTION(valgrind,
9601         [  --with-valgrind         test: use valgrind],
9602         [USE_VALGRIND])
9603 ])dnl
9604 dnl ---------------------------------------------------------------------------
9605 dnl CF_WITH_VERSIONED_SYMS version: 10 updated: 2021/01/04 18:48:01
9606 dnl ----------------------
9607 dnl Use this when building shared library with ELF, to markup symbols with the
9608 dnl version identifier from the given input file.  Generally that identifier is
9609 dnl the same as the SONAME at which the symbol was first introduced.
9610 dnl
9611 dnl $1 = basename of the ".map" file (default $PACKAGE)
9612 AC_DEFUN([CF_WITH_VERSIONED_SYMS],
9613 [AC_REQUIRE([AC_PROG_FGREP])dnl
9614 AC_REQUIRE([AC_PROG_EGREP])dnl
9615
9616 AC_MSG_CHECKING(if versioned-symbols file should be used)
9617 AC_ARG_WITH(versioned-syms,
9618         [  --with-versioned-syms=X markup versioned symbols using ld],
9619         [with_versioned_syms=$withval],
9620         [with_versioned_syms=no])
9621 case "x$with_versioned_syms" in
9622 (xyes)
9623         with_versioned_syms='${top_srcdir}/package/ifelse($1,,${PACKAGE},[$1]).map'
9624         AC_SUBST(PACKAGE)
9625         ;;
9626 (xno)
9627         ;;
9628 (x/*)
9629         test -f "$with_versioned_syms" || AC_MSG_ERROR(expected a filename: $with_versioned_syms)
9630         ;;
9631 (*)
9632         test -f "$with_versioned_syms" || AC_MSG_ERROR(expected a filename: $with_versioned_syms)
9633         with_versioned_syms=`pwd`/"$with_versioned_syms"
9634         ;;
9635 esac
9636 AC_MSG_RESULT($with_versioned_syms)
9637
9638 RESULTING_SYMS=
9639 VERSIONED_SYMS=
9640 WILDCARD_SYMS=
9641
9642 if test "x$with_versioned_syms" != xno
9643 then
9644         RESULTING_SYMS=$with_versioned_syms
9645         case "x$MK_SHARED_LIB" in
9646         (*-Wl,*)
9647                 VERSIONED_SYMS="-Wl,--version-script,\${RESULTING_SYMS}"
9648                 MK_SHARED_LIB=`echo "$MK_SHARED_LIB" | sed -e "s%-Wl,%\\[$]{VERSIONED_SYMS} -Wl,%"`
9649                 CF_VERBOSE(MK_SHARED_LIB:  $MK_SHARED_LIB)
9650                 ;;
9651         (*-dy\ *)
9652                 VERSIONED_SYMS="-Wl,-M,\${RESULTING_SYMS}"
9653                 MK_SHARED_LIB=`echo "$MK_SHARED_LIB" | sed -e "s%-dy%\\[$]{VERSIONED_SYMS} -dy%"`
9654                 CF_VERBOSE(MK_SHARED_LIB:  $MK_SHARED_LIB)
9655                 ;;
9656         (*)
9657                 AC_MSG_WARN(this system does not support versioned-symbols)
9658                 ;;
9659         esac
9660
9661         # Linux ld can selectively override scope, e.g., of symbols beginning with
9662         # "_" by first declaring some as global, and then using a wildcard to
9663         # declare the others as local.  Some other loaders cannot do this.  Check
9664         # by constructing a (very) simple shared library and inspecting its
9665         # symbols.
9666         if test "x$VERSIONED_SYMS" != "x"
9667         then
9668                 AC_MSG_CHECKING(if wildcards can be used to selectively omit symbols)
9669                 WILDCARD_SYMS=no
9670
9671                 # make sources
9672                 rm -f conftest.*
9673
9674                 cat >conftest.ver <<EOF
9675 module_1.0 {
9676 global:
9677         globalf1;
9678 local:
9679         localf1;
9680 };
9681 module_2.0 {
9682 global:
9683         globalf2;
9684 local:
9685         localf2;
9686         _*;
9687 } module_1.0;
9688 submodule_1.0 {
9689 global:
9690         subglobalf1;
9691         _ismissing;
9692 local:
9693         sublocalf1;
9694 };
9695 submodule_2.0 {
9696 global:
9697         subglobalf2;
9698 local:
9699         sublocalf2;
9700         _*;
9701 } submodule_1.0;
9702 EOF
9703                 cat >conftest.$ac_ext <<EOF
9704 #line __oline__ "configure"
9705 int     _ismissing(void) { return 1; }
9706 int     _localf1(void) { return 1; }
9707 int     _localf2(void) { return 2; }
9708 int     globalf1(void) { return 1; }
9709 int     globalf2(void) { return 2; }
9710 int     _sublocalf1(void) { return 1; }
9711 int     _sublocalf2(void) { return 2; }
9712 int     subglobalf1(void) { return 1; }
9713 int     subglobalf2(void) { return 2; }
9714 EOF
9715                 cat >conftest.mk <<EOF
9716 CC=${CC}
9717 CFLAGS=${CFLAGS}
9718 CPPFLAGS=${CPPFLAGS}
9719 LDFLAGS=${LDFLAGS}
9720 LIBS=${LIBS}
9721 VERSIONED_SYMS=${VERSIONED_SYMS}
9722 RESULTING_SYMS=conftest.ver
9723 MK_SHARED_LIB=${MK_SHARED_LIB}
9724 conftest.so: conftest.$ac_cv_objext
9725                 \$(MK_SHARED_LIB) conftest.$ac_cv_objext
9726 EOF
9727
9728                 # compile source, make library
9729                 if make -f conftest.mk 2>&AC_FD_CC >/dev/null
9730                 then
9731                         # test for missing symbol in either Data or Text section
9732                         cf_missing="`nm -P conftest.so 2>&AC_FD_CC |${FGREP-fgrep} _ismissing | ${EGREP-egrep} '[[      ]][[DT]][[      ]]'`"
9733                         test -n "$cf_missing" && WILDCARD_SYMS=yes
9734                 fi
9735                 AC_MSG_RESULT($WILDCARD_SYMS)
9736                 rm -f conftest.*
9737         fi
9738 fi
9739 AC_SUBST(RESULTING_SYMS)
9740 AC_SUBST(VERSIONED_SYMS)
9741 AC_SUBST(WILDCARD_SYMS)
9742 ])dnl
9743 dnl ---------------------------------------------------------------------------
9744 dnl CF_WITH_X11_RGB version: 2 updated: 2019/12/31 08:53:54
9745 dnl ---------------
9746 dnl Handle configure option "--with-x11-rgb", setting these shell
9747 dnl variables:
9748 dnl
9749 dnl $RGB_PATH is the option value, used for finding the X11 rgb file.
9750 dnl $no_x11_rgb is a "#" (comment) if "--without-x11-rgb" is given.
9751 dnl
9752 dnl Most Linux's use this:
9753 dnl     /usr/share/X11/rgb.txt
9754 dnl Debian uses this:
9755 dnl     /etc/X11/rgb.txt
9756 dnl DragonFlyBSD ports uses this:
9757 dnl     /usr/pkg/lib/X11/rgb.txt
9758 dnl FreeBSD ports use these:
9759 dnl     /usr/local/lib/X11/rgb.txt
9760 dnl     /usr/local/share/X11/rgb.txt
9761 dnl Mandriva has these:
9762 dnl     /usr/lib/X11/rgb.txt
9763 dnl     /usr/lib64/X11/rgb.txt
9764 dnl NetBSD has these
9765 dnl     /usr/X11R7/lib/X11/rgb.txt
9766 dnl OpenSolaris uses
9767 dnl     32-bit:
9768 dnl     /usr/X11/etc/X11/rgb.txt
9769 dnl     /usr/X11/share/X11/rgb.txt
9770 dnl     /usr/X11/lib/X11/rgb.txt
9771 dnl OSX uses
9772 dnl             /opt/local/share/X11/rgb.txt (MacPorts)
9773 dnl             /opt/X11/share/X11/rgb.txt (non-ports)
9774 dnl     64-bit:
9775 dnl     /usr/X11/etc/X11/rgb.txt
9776 dnl     /usr/X11/share/X11/rgb.txt (perhaps)
9777 dnl     /usr/X11/lib/amd64/X11/rgb.txt
9778 dnl Solaris10 uses (in this order):
9779 dnl     /usr/openwin/lib/X11/rgb.txt
9780 dnl     /usr/X11/lib/X11/rgb.txt
9781 AC_DEFUN([CF_WITH_X11_RGB],[
9782 AC_MSG_CHECKING(for X11 rgb file)
9783 AC_ARG_WITH(x11-rgb,
9784         [  --with-x11-rgb=FILE   file containing X11 rgb information (EPREFIX/lib/X11/rgb.txt)],
9785         [RGB_PATH=$withval],
9786         [RGB_PATH=auto])
9787
9788 if test "x[$]RGB_PATH" = xauto
9789 then
9790         RGB_PATH='${exec_prefix}/lib/X11/rgb.txt'
9791         for cf_path in \
9792                 /opt/local/share/X11/rgb.txt \
9793                 /opt/X11/share/X11/rgb.txt \
9794                 /usr/share/X11/rgb.txt \
9795                 /usr/X11/share/X11/rgb.txt \
9796                 /usr/X11/lib/X11/rgb.txt \
9797                 /usr/lib/X11/rgb.txt \
9798                 /etc/X11/rgb.txt \
9799                 /usr/pkg/lib/X11/rgb.txt \
9800                 /usr/X11R7/lib/X11/rgb.txt \
9801                 /usr/X11R6/lib/X11/rgb.txt \
9802                 /usr/X11R5/lib/X11/rgb.txt \
9803                 /usr/X11R4/lib/X11/rgb.txt \
9804                 /usr/local/lib/X11/rgb.txt \
9805                 /usr/local/share/X11/rgb.txt \
9806                 /usr/lib64/X11/rgb.txt
9807         do
9808                 if test -f "$cf_path" ; then
9809                         RGB_PATH="$cf_path"
9810                         break
9811                 fi
9812         done
9813 else
9814         cf_path=$RGB_PATH
9815         CF_PATH_SYNTAX(cf_path)
9816 fi
9817
9818 AC_MSG_RESULT($RGB_PATH)
9819 AC_SUBST(RGB_PATH)
9820 AC_DEFINE_UNQUOTED(RGB_PATH,"$cf_path",[Define to the full pathname of rgb.txt])
9821
9822 no_x11_rgb=
9823 if test "$RGB_PATH" = no
9824 then
9825         no_x11_rgb="#"
9826 fi
9827 AC_SUBST(no_x11_rgb)
9828 ])dnl
9829 dnl ---------------------------------------------------------------------------
9830 dnl CF_XOPEN_SOURCE version: 59 updated: 2021/08/28 15:20:37
9831 dnl ---------------
9832 dnl Try to get _XOPEN_SOURCE defined properly that we can use POSIX functions,
9833 dnl or adapt to the vendor's definitions to get equivalent functionality,
9834 dnl without losing the common non-POSIX features.
9835 dnl
9836 dnl Parameters:
9837 dnl     $1 is the nominal value for _XOPEN_SOURCE
9838 dnl     $2 is the nominal value for _POSIX_C_SOURCE
9839 AC_DEFUN([CF_XOPEN_SOURCE],[
9840 AC_REQUIRE([AC_CANONICAL_HOST])
9841 AC_REQUIRE([CF_POSIX_VISIBLE])
9842
9843 if test "$cf_cv_posix_visible" = no; then
9844
9845 cf_XOPEN_SOURCE=ifelse([$1],,500,[$1])
9846 cf_POSIX_C_SOURCE=ifelse([$2],,199506L,[$2])
9847 cf_xopen_source=
9848
9849 case "$host_os" in
9850 (aix[[4-7]]*)
9851         cf_xopen_source="-D_ALL_SOURCE"
9852         ;;
9853 (msys)
9854         cf_XOPEN_SOURCE=600
9855         ;;
9856 (darwin[[0-8]].*)
9857         cf_xopen_source="-D_APPLE_C_SOURCE"
9858         ;;
9859 (darwin*)
9860         cf_xopen_source="-D_DARWIN_C_SOURCE"
9861         cf_XOPEN_SOURCE=
9862         ;;
9863 (freebsd*|dragonfly*|midnightbsd*)
9864         # 5.x headers associate
9865         #       _XOPEN_SOURCE=600 with _POSIX_C_SOURCE=200112L
9866         #       _XOPEN_SOURCE=500 with _POSIX_C_SOURCE=199506L
9867         cf_POSIX_C_SOURCE=200112L
9868         cf_XOPEN_SOURCE=600
9869         cf_xopen_source="-D_BSD_TYPES -D__BSD_VISIBLE -D_POSIX_C_SOURCE=$cf_POSIX_C_SOURCE -D_XOPEN_SOURCE=$cf_XOPEN_SOURCE"
9870         ;;
9871 (hpux11*)
9872         cf_xopen_source="-D_HPUX_SOURCE -D_XOPEN_SOURCE=500"
9873         ;;
9874 (hpux*)
9875         cf_xopen_source="-D_HPUX_SOURCE"
9876         ;;
9877 (irix[[56]].*)
9878         cf_xopen_source="-D_SGI_SOURCE"
9879         cf_XOPEN_SOURCE=
9880         ;;
9881 (linux*|uclinux*|gnu*|mint*|k*bsd*-gnu|cygwin)
9882         CF_GNU_SOURCE($cf_XOPEN_SOURCE)
9883         ;;
9884 (minix*)
9885         cf_xopen_source="-D_NETBSD_SOURCE" # POSIX.1-2001 features are ifdef'd with this...
9886         ;;
9887 (mirbsd*)
9888         # setting _XOPEN_SOURCE or _POSIX_SOURCE breaks <sys/select.h> and other headers which use u_int / u_short types
9889         cf_XOPEN_SOURCE=
9890         CF_POSIX_C_SOURCE($cf_POSIX_C_SOURCE)
9891         ;;
9892 (netbsd*)
9893         cf_xopen_source="-D_NETBSD_SOURCE" # setting _XOPEN_SOURCE breaks IPv6 for lynx on NetBSD 1.6, breaks xterm, is not needed for ncursesw
9894         ;;
9895 (openbsd[[6-9]]*)
9896         # OpenBSD 6.x has broken locale support, both compile-time and runtime.
9897         # see https://www.mail-archive.com/bugs@openbsd.org/msg13200.html
9898         # Abusing the conformance level is a workaround.
9899         AC_MSG_WARN(this system does not provide usable locale support)
9900         cf_xopen_source="-D_BSD_SOURCE"
9901         cf_XOPEN_SOURCE=700
9902         ;;
9903 (openbsd[[4-5]]*)
9904         # setting _XOPEN_SOURCE lower than 500 breaks g++ compile with wchar.h, needed for ncursesw
9905         cf_xopen_source="-D_BSD_SOURCE"
9906         cf_XOPEN_SOURCE=600
9907         ;;
9908 (openbsd*)
9909         # setting _XOPEN_SOURCE breaks xterm on OpenBSD 2.8, is not needed for ncursesw
9910         ;;
9911 (osf[[45]]*)
9912         cf_xopen_source="-D_OSF_SOURCE"
9913         ;;
9914 (nto-qnx*)
9915         cf_xopen_source="-D_QNX_SOURCE"
9916         ;;
9917 (sco*)
9918         # setting _XOPEN_SOURCE breaks Lynx on SCO Unix / OpenServer
9919         ;;
9920 (solaris2.*)
9921         cf_xopen_source="-D__EXTENSIONS__"
9922         cf_cv_xopen_source=broken
9923         ;;
9924 (sysv4.2uw2.*) # Novell/SCO UnixWare 2.x (tested on 2.1.2)
9925         cf_XOPEN_SOURCE=
9926         cf_POSIX_C_SOURCE=
9927         ;;
9928 (*)
9929         CF_TRY_XOPEN_SOURCE
9930         CF_POSIX_C_SOURCE($cf_POSIX_C_SOURCE)
9931         ;;
9932 esac
9933
9934 if test -n "$cf_xopen_source" ; then
9935         CF_APPEND_CFLAGS($cf_xopen_source,true)
9936 fi
9937
9938 dnl In anything but the default case, we may have system-specific setting
9939 dnl which is still not guaranteed to provide all of the entrypoints that
9940 dnl _XOPEN_SOURCE would yield.
9941 if test -n "$cf_XOPEN_SOURCE" && test -z "$cf_cv_xopen_source" ; then
9942         AC_MSG_CHECKING(if _XOPEN_SOURCE really is set)
9943         AC_TRY_COMPILE([#include <stdlib.h>],[
9944 #ifndef _XOPEN_SOURCE
9945 make an error
9946 #endif],
9947         [cf_XOPEN_SOURCE_set=yes],
9948         [cf_XOPEN_SOURCE_set=no])
9949         AC_MSG_RESULT($cf_XOPEN_SOURCE_set)
9950         if test "$cf_XOPEN_SOURCE_set" = yes
9951         then
9952                 AC_TRY_COMPILE([#include <stdlib.h>],[
9953 #if (_XOPEN_SOURCE - 0) < $cf_XOPEN_SOURCE
9954 make an error
9955 #endif],
9956                 [cf_XOPEN_SOURCE_set_ok=yes],
9957                 [cf_XOPEN_SOURCE_set_ok=no])
9958                 if test "$cf_XOPEN_SOURCE_set_ok" = no
9959                 then
9960                         AC_MSG_WARN(_XOPEN_SOURCE is lower than requested)
9961                 fi
9962         else
9963                 CF_TRY_XOPEN_SOURCE
9964         fi
9965 fi
9966 fi # cf_cv_posix_visible
9967 ])
9968 dnl ---------------------------------------------------------------------------
9969 dnl CF__SED_TRIMBLANKS version: 1 updated: 2021/01/02 09:31:20
9970 dnl ------------------
9971 dnl Trim something using sed, then trim extra whitespace
9972 dnl $1 = extra parameters, e.g., in CF_STRIP_G_OPT
9973 define([CF__SED_TRIMBLANKS],[sed ifelse($1,,,[$1] )-e 's%[[     ]]% %g' -e 's% [[ ]]*% %g' -e 's%^ %%' -e 's% [$]%%'])dnl