aclocal.m4

   1 dnl***************************************************************************
   2 dnl Copyright 2018-2020,2021 Thomas E. Dickey                                *
   3 dnl Copyright 1998-2017,2018 Free Software Foundation, Inc.                  *
   4 dnl                                                                          *
   5 dnl Permission is hereby granted, free of charge, to any person obtaining a  *
   6 dnl copy of this software and associated documentation files (the            *
   7 dnl "Software"), to deal in the Software without restriction, including      *
   8 dnl without limitation the rights to use, copy, modify, merge, publish,      *
   9 dnl distribute, distribute with modifications, sublicense, and/or sell       *
  10 dnl copies of the Software, and to permit persons to whom the Software is    *
  11 dnl furnished to do so, subject to the following conditions:                 *
  12 dnl                                                                          *
  13 dnl The above copyright notice and this permission notice shall be included  *
  14 dnl in all copies or substantial portions of the Software.                   *
  15 dnl                                                                          *
  16 dnl THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS  *
  17 dnl OR IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF               *
  18 dnl MERCHANTABILITY, FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT.   *
  19 dnl IN NO EVENT SHALL THE ABOVE COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM,   *
  20 dnl DAMAGES OR OTHER LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR    *
  21 dnl OTHERWISE, ARISING FROM, OUT OF OR IN CONNECTION WITH THE SOFTWARE OR    *
  22 dnl THE USE OR OTHER DEALINGS IN THE SOFTWARE.                               *
  23 dnl                                                                          *
  24 dnl Except as contained in this notice, the name(s) of the above copyright   *
  25 dnl holders shall not be used in advertising or otherwise to promote the     *
  26 dnl sale, use or other dealings in this Software without prior written       *
  27 dnl authorization.                                                           *
  28 dnl***************************************************************************
  29 dnl
  30 dnl Author: Thomas E. Dickey 1995-on
  31 dnl
  32 dnl $Id: aclocal.m4,v 1.999 2021/12/04 23:30:56 tom Exp $
  33 dnl Macros used in NCURSES auto-configuration script.
  34 dnl
  35 dnl These macros are maintained separately from NCURSES.  The copyright on
  36 dnl this file applies to the aggregation of macros and does not affect use of
  37 dnl these macros in other applications.
  38 dnl
  39 dnl See these pages for additional information:
  40 dnl             https://invisible-island.net/autoconf/
  41 dnl             https://invisible-island.net/autoconf/my-autoconf.html
  42 dnl
  43 dnl ---------------------------------------------------------------------------
  44 dnl ---------------------------------------------------------------------------
  45 dnl AM_LANGINFO_CODESET version: 6 updated: 2021/01/01 16:53:59
  46 dnl -------------------
  47 dnl Inserted as requested by gettext 0.10.40
  48 dnl File from /usr/share/aclocal
  49 dnl codeset.m4
  50 dnl ====================
  51 dnl serial AM1
  52 dnl
  53 dnl From Bruno Haible.
  54 AC_DEFUN([AM_LANGINFO_CODESET],
  55 [
  56 AC_CACHE_CHECK([for nl_langinfo and CODESET], am_cv_langinfo_codeset,
  57         [AC_TRY_LINK([#include <langinfo.h>],
  58         [char* cs = nl_langinfo(CODESET); (void)cs],
  59         am_cv_langinfo_codeset=yes,
  60         am_cv_langinfo_codeset=no)
  61         ])
  62         if test "$am_cv_langinfo_codeset" = yes; then
  63                 AC_DEFINE(HAVE_LANGINFO_CODESET, 1,
  64                 [Define if you have <langinfo.h> and nl_langinfo(CODESET).])
  65         fi
  66 ])dnl
  67 dnl ---------------------------------------------------------------------------
  68 dnl CF_ABI_DEFAULTS version: 2 updated: 2015/06/06 13:49:58
  69 dnl ---------------
  70 dnl Provide configure-script defaults for different ncurses ABIs.
  71 AC_DEFUN([CF_ABI_DEFAULTS],[
  72 AC_REQUIRE([CF_NCURSES_WITH_ABI_VERSION])
  73 case x$cf_cv_abi_version in
  74 (x[[6789]])
  75         cf_dft_ext_colors=yes
  76         cf_dft_ext_const=yes
  77         cf_dft_ext_mouse=yes
  78         cf_dft_ext_putwin=yes
  79         cf_dft_ext_spfuncs=yes
  80         cf_dft_filter_syms=yes
  81         cf_dft_chtype=uint32_t
  82         cf_dft_mmask_t=uint32_t
  83         cf_dft_interop=yes
  84         cf_dft_tparm_arg=intptr_t
  85         cf_dft_with_lp64=yes
  86         ;;
  87 (*)
  88         cf_dft_ext_colors=no
  89         cf_dft_ext_const=no
  90         cf_dft_ext_mouse=no
  91         cf_dft_ext_putwin=no
  92         cf_dft_ext_spfuncs=no
  93         cf_dft_filter_syms=no
  94         cf_dft_chtype=auto
  95         cf_dft_mmask_t=auto
  96         cf_dft_interop=no
  97         cf_dft_tparm_arg=long
  98         cf_dft_with_lp64=no
  99         ;;
 100 esac
 101 ])dnl
 102 dnl ---------------------------------------------------------------------------
 103 dnl CF_ACVERSION_CHECK version: 5 updated: 2014/06/04 19:11:49
 104 dnl ------------------
 105 dnl Conditionally generate script according to whether we're using a given autoconf.
 106 dnl
 107 dnl $1 = version to compare against
 108 dnl $2 = code to use if AC_ACVERSION is at least as high as $1.
 109 dnl $3 = code to use if AC_ACVERSION is older than $1.
 110 define([CF_ACVERSION_CHECK],
 111 [
 112 ifdef([AC_ACVERSION], ,[ifdef([AC_AUTOCONF_VERSION],[m4_copy([AC_AUTOCONF_VERSION],[AC_ACVERSION])],[m4_copy([m4_PACKAGE_VERSION],[AC_ACVERSION])])])dnl
 113 ifdef([m4_version_compare],
 114 [m4_if(m4_version_compare(m4_defn([AC_ACVERSION]), [$1]), -1, [$3], [$2])],
 115 [CF_ACVERSION_COMPARE(
 116 AC_PREREQ_CANON(AC_PREREQ_SPLIT([$1])),
 117 AC_PREREQ_CANON(AC_PREREQ_SPLIT(AC_ACVERSION)), AC_ACVERSION, [$2], [$3])])])dnl
 118 dnl ---------------------------------------------------------------------------
 119 dnl CF_ACVERSION_COMPARE version: 3 updated: 2012/10/03 18:39:53
 120 dnl --------------------
 121 dnl CF_ACVERSION_COMPARE(MAJOR1, MINOR1, TERNARY1,
 122 dnl                      MAJOR2, MINOR2, TERNARY2,
 123 dnl                      PRINTABLE2, not FOUND, FOUND)
 124 define([CF_ACVERSION_COMPARE],
 125 [ifelse(builtin([eval], [$2 < $5]), 1,
 126 [ifelse([$8], , ,[$8])],
 127 [ifelse([$9], , ,[$9])])])dnl
 128 dnl ---------------------------------------------------------------------------
 129 dnl CF_ADA_INCLUDE_DIRS version: 8 updated: 2013/10/14 04:24:07
 130 dnl -------------------
 131 dnl Construct the list of include-options for the C programs in the Ada95
 132 dnl binding.
 133 AC_DEFUN([CF_ADA_INCLUDE_DIRS],
 134 [
 135 ACPPFLAGS="-I. -I../include -I../../include $ACPPFLAGS"
 136 if test "$srcdir" != "."; then
 137         ACPPFLAGS="-I\${srcdir}/../../include $ACPPFLAGS"
 138 fi
 139 if test "$GCC" != yes; then
 140         ACPPFLAGS="$ACPPFLAGS -I\${includedir}"
 141 elif test "$includedir" != "/usr/include"; then
 142         if test "$includedir" = '${prefix}/include' ; then
 143                 if test x$prefix != x/usr ; then
 144                         ACPPFLAGS="$ACPPFLAGS -I\${includedir}"
 145                 fi
 146         else
 147                 ACPPFLAGS="$ACPPFLAGS -I\${includedir}"
 148         fi
 149 fi
 150 AC_SUBST(ACPPFLAGS)
 151 ])dnl
 152 dnl ---------------------------------------------------------------------------
 153 dnl CF_ADD_ADAFLAGS version: 1 updated: 2010/06/19 15:22:18
 154 dnl ---------------
 155 dnl Add to $ADAFLAGS, which is substituted into makefile and scripts.
 156 AC_DEFUN([CF_ADD_ADAFLAGS],[
 157         ADAFLAGS="$ADAFLAGS $1"
 158         AC_SUBST(ADAFLAGS)
 159 ])dnl
 160 dnl ---------------------------------------------------------------------------
 161 dnl CF_ADD_CFLAGS version: 15 updated: 2020/12/31 10:54:15
 162 dnl -------------
 163 dnl Copy non-preprocessor flags to $CFLAGS, preprocessor flags to $CPPFLAGS
 164 dnl $1 = flags to add
 165 dnl $2 = if given makes this macro verbose.
 166 dnl
 167 dnl Put any preprocessor definitions that use quoted strings in $EXTRA_CPPFLAGS,
 168 dnl to simplify use of $CPPFLAGS in compiler checks, etc., that are easily
 169 dnl confused by the quotes (which require backslashes to keep them usable).
 170 AC_DEFUN([CF_ADD_CFLAGS],
 171 [
 172 cf_fix_cppflags=no
 173 cf_new_cflags=
 174 cf_new_cppflags=
 175 cf_new_extra_cppflags=
 176
 177 for cf_add_cflags in $1
 178 do
 179 case "$cf_fix_cppflags" in
 180 (no)
 181         case "$cf_add_cflags" in
 182         (-undef|-nostdinc*|-I*|-D*|-U*|-E|-P|-C)
 183                 case "$cf_add_cflags" in
 184                 (-D*)
 185                         cf_tst_cflags=`echo "${cf_add_cflags}" |sed -e 's/^-D[[^=]]*='\''\"[[^"]]*//'`
 186
 187                         test "x${cf_add_cflags}" != "x${cf_tst_cflags}" \
 188                                 && test -z "${cf_tst_cflags}" \
 189                                 && cf_fix_cppflags=yes
 190
 191                         if test "$cf_fix_cppflags" = yes ; then
 192                                 CF_APPEND_TEXT(cf_new_extra_cppflags,$cf_add_cflags)
 193                                 continue
 194                         elif test "${cf_tst_cflags}" = "\"'" ; then
 195                                 CF_APPEND_TEXT(cf_new_extra_cppflags,$cf_add_cflags)
 196                                 continue
 197                         fi
 198                         ;;
 199                 esac
 200                 case "$CPPFLAGS" in
 201                 (*$cf_add_cflags)
 202                         ;;
 203                 (*)
 204                         case "$cf_add_cflags" in
 205                         (-D*)
 206                                 cf_tst_cppflags=`echo "x$cf_add_cflags" | sed -e 's/^...//' -e 's/=.*//'`
 207                                 CF_REMOVE_DEFINE(CPPFLAGS,$CPPFLAGS,$cf_tst_cppflags)
 208                                 ;;
 209                         esac
 210                         CF_APPEND_TEXT(cf_new_cppflags,$cf_add_cflags)
 211                         ;;
 212                 esac
 213                 ;;
 214         (*)
 215                 CF_APPEND_TEXT(cf_new_cflags,$cf_add_cflags)
 216                 ;;
 217         esac
 218         ;;
 219 (yes)
 220         CF_APPEND_TEXT(cf_new_extra_cppflags,$cf_add_cflags)
 221
 222         cf_tst_cflags=`echo "${cf_add_cflags}" |sed -e 's/^[[^"]]*"'\''//'`
 223
 224         test "x${cf_add_cflags}" != "x${cf_tst_cflags}" \
 225                 && test -z "${cf_tst_cflags}" \
 226                 && cf_fix_cppflags=no
 227         ;;
 228 esac
 229 done
 230
 231 if test -n "$cf_new_cflags" ; then
 232         ifelse([$2],,,[CF_VERBOSE(add to \$CFLAGS $cf_new_cflags)])
 233         CF_APPEND_TEXT(CFLAGS,$cf_new_cflags)
 234 fi
 235
 236 if test -n "$cf_new_cppflags" ; then
 237         ifelse([$2],,,[CF_VERBOSE(add to \$CPPFLAGS $cf_new_cppflags)])
 238         CF_APPEND_TEXT(CPPFLAGS,$cf_new_cppflags)
 239 fi
 240
 241 if test -n "$cf_new_extra_cppflags" ; then
 242         ifelse([$2],,,[CF_VERBOSE(add to \$EXTRA_CPPFLAGS $cf_new_extra_cppflags)])
 243         CF_APPEND_TEXT(EXTRA_CPPFLAGS,$cf_new_extra_cppflags)
 244 fi
 245
 246 AC_SUBST(EXTRA_CPPFLAGS)
 247
 248 ])dnl
 249 dnl ---------------------------------------------------------------------------
 250 dnl CF_ADD_CXXFLAGS version: 1 updated: 2020/04/04 16:16:13
 251 dnl ---------------
 252 dnl Copy non-preprocessor flags to $CXXFLAGS, preprocessor flags to $CPPFLAGS
 253 dnl The second parameter if given makes this macro verbose.
 254 dnl
 255 dnl Put any preprocessor definitions that use quoted strings in $EXTRA_CPPFLAGS,
 256 dnl to simplify use of $CPPFLAGS in compiler checks, etc., that are easily
 257 dnl confused by the quotes (which require backslashes to keep them usable).
 258 AC_DEFUN([CF_ADD_CXXFLAGS],
 259 [
 260 cf_save_CXXFLAGS="$CFLAGS"
 261 CFLAGS="$CXXFLAGS"
 262 CF_ADD_CFLAGS($1 ifelse($2,,,[,$2]))
 263 CXXFLAGS="$CFLAGS"
 264 CFLAGS="$cf_save_CXXFLAGS"
 265 ])dnl
 266 dnl ---------------------------------------------------------------------------
 267 dnl CF_ADD_INCDIR version: 17 updated: 2021/09/04 06:35:04
 268 dnl -------------
 269 dnl Add an include-directory to $CPPFLAGS.  Don't add /usr/include, since it is
 270 dnl redundant.  We don't normally need to add -I/usr/local/include for gcc,
 271 dnl but old versions (and some misinstalled ones) need that.  To make things
 272 dnl worse, gcc 3.x may give error messages if -I/usr/local/include is added to
 273 dnl the include-path).
 274 AC_DEFUN([CF_ADD_INCDIR],
 275 [
 276 if test -n "$1" ; then
 277   for cf_add_incdir in $1
 278   do
 279         while test "$cf_add_incdir" != /usr/include
 280         do
 281           if test -d "$cf_add_incdir"
 282           then
 283                 cf_have_incdir=no
 284                 if test -n "$CFLAGS$CPPFLAGS" ; then
 285                   # a loop is needed to ensure we can add subdirs of existing dirs
 286                   for cf_test_incdir in $CFLAGS $CPPFLAGS ; do
 287                         if test ".$cf_test_incdir" = ".-I$cf_add_incdir" ; then
 288                           cf_have_incdir=yes; break
 289                         fi
 290                   done
 291                 fi
 292
 293                 if test "$cf_have_incdir" = no ; then
 294                   if test "$cf_add_incdir" = /usr/local/include ; then
 295                         if test "$GCC" = yes
 296                         then
 297                           cf_save_CPPFLAGS=$CPPFLAGS
 298                           CF_APPEND_TEXT(CPPFLAGS,-I$cf_add_incdir)
 299                           AC_TRY_COMPILE([#include <stdio.h>],
 300                                   [printf("Hello")],
 301                                   [],
 302                                   [cf_have_incdir=yes])
 303                           CPPFLAGS=$cf_save_CPPFLAGS
 304                         fi
 305                   fi
 306                 fi
 307
 308                 if test "$cf_have_incdir" = no ; then
 309                   CF_VERBOSE(adding $cf_add_incdir to include-path)
 310                   ifelse([$2],,CPPFLAGS,[$2])="$ifelse([$2],,CPPFLAGS,[$2]) -I$cf_add_incdir"
 311
 312                   cf_top_incdir=`echo "$cf_add_incdir" | sed -e 's%/include/.*$%/include%'`
 313                   test "$cf_top_incdir" = "$cf_add_incdir" && break
 314                   cf_add_incdir="$cf_top_incdir"
 315                 else
 316                   break
 317                 fi
 318           else
 319                 break
 320           fi
 321         done
 322   done
 323 fi
 324 ])dnl
 325 dnl ---------------------------------------------------------------------------
 326 dnl CF_ADD_LIB version: 2 updated: 2010/06/02 05:03:05
 327 dnl ----------
 328 dnl Add a library, used to enforce consistency.
 329 dnl
 330 dnl $1 = library to add, without the "-l"
 331 dnl $2 = variable to update (default $LIBS)
 332 AC_DEFUN([CF_ADD_LIB],[CF_ADD_LIBS(-l$1,ifelse($2,,LIBS,[$2]))])dnl
 333 dnl ---------------------------------------------------------------------------
 334 dnl CF_ADD_LIBDIR version: 11 updated: 2020/12/31 20:19:42
 335 dnl -------------
 336 dnl     Adds to the library-path
 337 dnl
 338 dnl     Some machines have trouble with multiple -L options.
 339 dnl
 340 dnl $1 is the (list of) directory(s) to add
 341 dnl $2 is the optional name of the variable to update (default LDFLAGS)
 342 dnl
 343 AC_DEFUN([CF_ADD_LIBDIR],
 344 [
 345 if test -n "$1" ; then
 346         for cf_add_libdir in $1
 347         do
 348                 if test "$cf_add_libdir" = /usr/lib ; then
 349                         :
 350                 elif test -d "$cf_add_libdir"
 351                 then
 352                         cf_have_libdir=no
 353                         if test -n "$LDFLAGS$LIBS" ; then
 354                                 # a loop is needed to ensure we can add subdirs of existing dirs
 355                                 for cf_test_libdir in $LDFLAGS $LIBS ; do
 356                                         if test ".$cf_test_libdir" = ".-L$cf_add_libdir" ; then
 357                                                 cf_have_libdir=yes; break
 358                                         fi
 359                                 done
 360                         fi
 361                         if test "$cf_have_libdir" = no ; then
 362                                 CF_VERBOSE(adding $cf_add_libdir to library-path)
 363                                 ifelse([$2],,LDFLAGS,[$2])="-L$cf_add_libdir $ifelse([$2],,LDFLAGS,[$2])"
 364                         fi
 365                 fi
 366         done
 367 fi
 368 ])dnl
 369 dnl ---------------------------------------------------------------------------
 370 dnl CF_ADD_LIBS version: 3 updated: 2019/11/02 16:47:33
 371 dnl -----------
 372 dnl Add one or more libraries, used to enforce consistency.  Libraries are
 373 dnl prepended to an existing list, since their dependencies are assumed to
 374 dnl already exist in the list.
 375 dnl
 376 dnl $1 = libraries to add, with the "-l", etc.
 377 dnl $2 = variable to update (default $LIBS)
 378 AC_DEFUN([CF_ADD_LIBS],[
 379 cf_add_libs="[$]ifelse($2,,LIBS,[$2])"
 380 # reverse order
 381 cf_add_0lib=
 382 for cf_add_1lib in $1; do cf_add_0lib="$cf_add_1lib $cf_add_0lib"; done
 383 # filter duplicates
 384 for cf_add_1lib in $cf_add_0lib; do
 385         for cf_add_2lib in $cf_add_libs; do
 386                 if test "x$cf_add_1lib" = "x$cf_add_2lib"; then
 387                         cf_add_1lib=
 388                         break
 389                 fi
 390         done
 391         test -n "$cf_add_1lib" && cf_add_libs="$cf_add_1lib $cf_add_libs"
 392 done
 393 ifelse($2,,LIBS,[$2])="$cf_add_libs"
 394 ])dnl
 395 dnl ---------------------------------------------------------------------------
 396 dnl CF_ADD_SUBDIR_PATH version: 5 updated: 2020/12/31 20:19:42
 397 dnl ------------------
 398 dnl Append to a search-list for a nonstandard header/lib-file
 399 dnl     $1 = the variable to return as result
 400 dnl     $2 = the package name
 401 dnl     $3 = the subdirectory, e.g., bin, include or lib
 402 dnl $4 = the directory under which we will test for subdirectories
 403 dnl $5 = a directory that we do not want $4 to match
 404 AC_DEFUN([CF_ADD_SUBDIR_PATH],
 405 [
 406 test "x$4" != "x$5" && \
 407 test -d "$4" && \
 408 ifelse([$5],NONE,,[{ test -z "$5" || test "x$5" = xNONE || test "x$4" != "x$5"; } &&]) {
 409         test -n "$verbose" && echo "    ... testing for $3-directories under $4"
 410         test -d "$4/$3" &&          $1="[$]$1 $4/$3"
 411         test -d "$4/$3/$2" &&       $1="[$]$1 $4/$3/$2"
 412         test -d "$4/$3/$2/$3" &&    $1="[$]$1 $4/$3/$2/$3"
 413         test -d "$4/$2/$3" &&       $1="[$]$1 $4/$2/$3"
 414         test -d "$4/$2/$3/$2" &&    $1="[$]$1 $4/$2/$3/$2"
 415 }
 416 ])dnl
 417 dnl ---------------------------------------------------------------------------
 418 dnl CF_APPEND_CFLAGS version: 3 updated: 2021/09/05 17:25:40
 419 dnl ----------------
 420 dnl Use CF_ADD_CFLAGS after first checking for potential redefinitions.
 421 dnl $1 = flags to add
 422 dnl $2 = if given makes this macro verbose.
 423 define([CF_APPEND_CFLAGS],
 424 [
 425 for cf_add_cflags in $1
 426 do
 427         case "x$cf_add_cflags" in
 428         (x-[[DU]]*)
 429                 CF_REMOVE_CFLAGS($cf_add_cflags,CFLAGS,[$2])
 430                 CF_REMOVE_CFLAGS($cf_add_cflags,CPPFLAGS,[$2])
 431                 ;;
 432         esac
 433         CF_ADD_CFLAGS([$cf_add_cflags],[$2])
 434 done
 435 ])dnl
 436 dnl ---------------------------------------------------------------------------
 437 dnl CF_APPEND_TEXT version: 1 updated: 2017/02/25 18:58:55
 438 dnl --------------
 439 dnl use this macro for appending text without introducing an extra blank at
 440 dnl the beginning
 441 define([CF_APPEND_TEXT],
 442 [
 443         test -n "[$]$1" && $1="[$]$1 "
 444         $1="[$]{$1}$2"
 445 ])dnl
 446 dnl ---------------------------------------------------------------------------
 447 dnl CF_ARG_DISABLE version: 3 updated: 1999/03/30 17:24:31
 448 dnl --------------
 449 dnl Allow user to disable a normally-on option.
 450 AC_DEFUN([CF_ARG_DISABLE],
 451 [CF_ARG_OPTION($1,[$2],[$3],[$4],yes)])dnl
 452 dnl ---------------------------------------------------------------------------
 453 dnl CF_ARG_ENABLE version: 3 updated: 1999/03/30 17:24:31
 454 dnl -------------
 455 dnl Allow user to enable a normally-off option.
 456 AC_DEFUN([CF_ARG_ENABLE],
 457 [CF_ARG_OPTION($1,[$2],[$3],[$4],no)])dnl
 458 dnl ---------------------------------------------------------------------------
 459 dnl CF_ARG_OPTION version: 5 updated: 2015/05/10 19:52:14
 460 dnl -------------
 461 dnl Restricted form of AC_ARG_ENABLE that ensures user doesn't give bogus
 462 dnl values.
 463 dnl
 464 dnl Parameters:
 465 dnl $1 = option name
 466 dnl $2 = help-string
 467 dnl $3 = action to perform if option is not default
 468 dnl $4 = action if perform if option is default
 469 dnl $5 = default option value (either 'yes' or 'no')
 470 AC_DEFUN([CF_ARG_OPTION],
 471 [AC_ARG_ENABLE([$1],[$2],[test "$enableval" != ifelse([$5],no,yes,no) && enableval=ifelse([$5],no,no,yes)
 472         if test "$enableval" != "$5" ; then
 473 ifelse([$3],,[    :]dnl
 474 ,[    $3]) ifelse([$4],,,[
 475         else
 476                 $4])
 477         fi],[enableval=$5 ifelse([$4],,,[
 478         $4
 479 ])dnl
 480 ])])dnl
 481 dnl ---------------------------------------------------------------------------
 482 dnl CF_AR_FLAGS version: 9 updated: 2021/01/01 13:31:04
 483 dnl -----------
 484 dnl Check for suitable "ar" (archiver) options for updating an archive.
 485 dnl
 486 dnl In particular, handle some obsolete cases where the "-" might be omitted,
 487 dnl as well as a workaround for breakage of make's archive rules by the GNU
 488 dnl binutils "ar" program.
 489 AC_DEFUN([CF_AR_FLAGS],[
 490 AC_REQUIRE([CF_PROG_AR])
 491
 492 AC_CACHE_CHECK(for options to update archives, cf_cv_ar_flags,[
 493         case "$cf_cv_system_name" in
 494         (*-msvc*)
 495                 cf_cv_ar_flags=''
 496                 cat >mk_static_lib.sh <<-EOF
 497                 #!$SHELL
 498                 MSVC_BIN="[$]AR"
 499                 out="\[$]1"
 500                 shift
 501                 exec \[$]MSVC_BIN -out:"\[$]out" \[$]@
 502                 EOF
 503                 chmod +x mk_static_lib.sh
 504                 AR=`pwd`/mk_static_lib.sh
 505                 ;;
 506         (*)
 507                 cf_cv_ar_flags=unknown
 508                 for cf_ar_flags in -curvU -curv curv -crv crv -cqv cqv -rv rv
 509                 do
 510
 511                         # check if $ARFLAGS already contains this choice
 512                         if test "x$ARFLAGS" != "x" ; then
 513                                 cf_check_ar_flags=`echo "x$ARFLAGS" | sed -e "s/$cf_ar_flags\$//" -e "s/$cf_ar_flags / /"`
 514                                 if test "x$ARFLAGS" != "$cf_check_ar_flags" ; then
 515                                         cf_cv_ar_flags=
 516                                         break
 517                                 fi
 518                         fi
 519
 520                         rm -f "conftest.$ac_cv_objext"
 521                         rm -f conftest.a
 522
 523                         cat >"conftest.$ac_ext" <<EOF
 524 #line __oline__ "configure"
 525 int     testdata[[3]] = { 123, 456, 789 };
 526 EOF
 527                         if AC_TRY_EVAL(ac_compile) ; then
 528                                 echo "$AR $ARFLAGS $cf_ar_flags conftest.a conftest.$ac_cv_objext" >&AC_FD_CC
 529                                 $AR $ARFLAGS "$cf_ar_flags" conftest.a "conftest.$ac_cv_objext" 2>&AC_FD_CC 1>/dev/null
 530                                 if test -f conftest.a ; then
 531                                         cf_cv_ar_flags="$cf_ar_flags"
 532                                         break
 533                                 fi
 534                         else
 535                                 CF_VERBOSE(cannot compile test-program)
 536                                 break
 537                         fi
 538                 done
 539                 rm -f conftest.a "conftest.$ac_ext" "conftest.$ac_cv_objext"
 540                 ;;
 541         esac
 542 ])
 543
 544 if test -n "$ARFLAGS" ; then
 545         if test -n "$cf_cv_ar_flags" ; then
 546                 ARFLAGS="$ARFLAGS $cf_cv_ar_flags"
 547         fi
 548 else
 549         ARFLAGS=$cf_cv_ar_flags
 550 fi
 551
 552 AC_SUBST(ARFLAGS)
 553 ])
 554 dnl ---------------------------------------------------------------------------
 555 dnl CF_AWK_BIG_PRINTF version: 5 updated: 2015/04/17 21:13:04
 556 dnl -----------------
 557 dnl Check if awk can handle big strings using printf.  Some older versions of
 558 dnl awk choke on large strings passed via "%s".
 559 dnl
 560 dnl $1 = desired string size
 561 dnl $2 = variable to set with result
 562 AC_DEFUN([CF_AWK_BIG_PRINTF],
 563 [
 564         case x$AWK in
 565         (x)
 566                 eval $2=no
 567                 ;;
 568         (*)
 569                 if ( ${AWK} 'BEGIN { xx = "x"; while (length(xx) < $1) { xx = xx "x"; }; printf("%s\n", xx); }' 2>/dev/null \
 570                         | $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
 571                         eval $2=yes
 572                 else
 573                         eval $2=no
 574                 fi
 575                 ;;
 576         esac
 577 ])dnl
 578 dnl ---------------------------------------------------------------------------
 579 dnl CF_BOOL_DECL version: 8 updated: 2004/01/30 15:51:18
 580 dnl ------------
 581 dnl Test if 'bool' is a builtin type in the configured C++ compiler.  Some
 582 dnl older compilers (e.g., gcc 2.5.8) don't support 'bool' directly; gcc
 583 dnl 2.6.3 does, in anticipation of the ANSI C++ standard.
 584 dnl
 585 dnl Treat the configuration-variable specially here, since we're directly
 586 dnl substituting its value (i.e., 1/0).
 587 dnl
 588 dnl $1 is the shell variable to store the result in, if not $cv_cv_builtin_bool
 589 AC_DEFUN([CF_BOOL_DECL],
 590 [
 591 AC_MSG_CHECKING(if we should include stdbool.h)
 592
 593 AC_CACHE_VAL(cf_cv_header_stdbool_h,[
 594         AC_TRY_COMPILE([],[bool foo = false],
 595                 [cf_cv_header_stdbool_h=0],
 596                 [AC_TRY_COMPILE([
 597 #ifndef __BEOS__
 598 #include <stdbool.h>
 599 #endif
 600 ],[bool foo = false],
 601                         [cf_cv_header_stdbool_h=1],
 602                         [cf_cv_header_stdbool_h=0])])])
 603
 604 if test "$cf_cv_header_stdbool_h" = 1
 605 then    AC_MSG_RESULT(yes)
 606 else    AC_MSG_RESULT(no)
 607 fi
 608
 609 AC_MSG_CHECKING([for builtin bool type])
 610
 611 AC_CACHE_VAL(ifelse($1,,cf_cv_builtin_bool,[$1]),[
 612         AC_TRY_COMPILE([
 613 #include <stdio.h>
 614 #include <sys/types.h>
 615 ],[bool x = false],
 616                 [ifelse($1,,cf_cv_builtin_bool,[$1])=1],
 617                 [ifelse($1,,cf_cv_builtin_bool,[$1])=0])
 618         ])
 619
 620 if test "$ifelse($1,,cf_cv_builtin_bool,[$1])" = 1
 621 then    AC_MSG_RESULT(yes)
 622 else    AC_MSG_RESULT(no)
 623 fi
 624 ])dnl
 625 dnl ---------------------------------------------------------------------------
 626 dnl CF_BOOL_SIZE version: 18 updated: 2021/09/04 06:35:04
 627 dnl ------------
 628 dnl Test for the size of 'bool' in the configured C++ compiler (e.g., a type).
 629 dnl Don't bother looking for bool.h, since it has been deprecated.
 630 dnl
 631 dnl If the current compiler is C rather than C++, we get the bool definition
 632 dnl from <stdbool.h>.
 633 AC_DEFUN([CF_BOOL_SIZE],
 634 [
 635 AC_CHECK_SIZEOF(bool,,[
 636 #include <stdlib.h>
 637 #include <stdio.h>
 638
 639 #if defined(__cplusplus)
 640
 641 #ifdef HAVE_GXX_BUILTIN_H
 642 #include <g++/builtin.h>
 643 #elif HAVE_GPP_BUILTIN_H
 644 #include <gpp/builtin.h>
 645 #elif HAVE_BUILTIN_H
 646 #include <builtin.h>
 647 #endif
 648
 649 #else
 650
 651 #if $cf_cv_header_stdbool_h
 652 #include <stdbool.h>
 653 #endif
 654
 655 #endif
 656 ])
 657
 658 AC_CACHE_CHECK(for type of bool, cf_cv_type_of_bool,[
 659         rm -f cf_test.out
 660         AC_TRY_RUN([
 661 #include <stdlib.h>
 662 #include <stdio.h>
 663
 664 #if defined(__cplusplus)
 665
 666 #ifdef HAVE_GXX_BUILTIN_H
 667 #include <g++/builtin.h>
 668 #elif HAVE_GPP_BUILTIN_H
 669 #include <gpp/builtin.h>
 670 #elif HAVE_BUILTIN_H
 671 #include <builtin.h>
 672 #endif
 673
 674 #else
 675
 676 #if $cf_cv_header_stdbool_h
 677 #include <stdbool.h>
 678 #endif
 679
 680 #endif
 681
 682 int main(void)
 683 {
 684         FILE *fp = fopen("cf_test.out", "w");
 685         if (fp != 0) {
 686                 bool x = true;
 687                 if ((bool)(-x) >= 0)
 688                         fputs("unsigned ", fp);
 689                 if (sizeof(x) == sizeof(int))       fputs("int",  fp);
 690                 else if (sizeof(x) == sizeof(char)) fputs("char", fp);
 691                 else if (sizeof(x) == sizeof(short))fputs("short",fp);
 692                 else if (sizeof(x) == sizeof(long)) fputs("long", fp);
 693                 fclose(fp);
 694         }
 695         ${cf_cv_main_return:-return}(0);
 696 }
 697                 ],
 698                 [cf_cv_type_of_bool=`cat cf_test.out`
 699                  if test -z "$cf_cv_type_of_bool"; then
 700                    cf_cv_type_of_bool=unknown
 701                  fi],
 702                 [cf_cv_type_of_bool=unknown],
 703                 [
 704                 case x$ac_cv_sizeof_bool in
 705                 (x1) cf_cv_type_of_bool="unsigned char";;
 706                 (x2) cf_cv_type_of_bool="unsigned short";;
 707                 (x4) cf_cv_type_of_bool="unsigned int";;
 708                 (x8) cf_cv_type_of_bool="unsigned long";;
 709                 (*)  cf_cv_type_of_bool=unknown;;
 710                 esac
 711                 ])
 712         rm -f cf_test.out
 713 ])
 714
 715 if test "$cf_cv_type_of_bool" = unknown ; then
 716         case .$NCURSES_BOOL in
 717         (.auto|.) NCURSES_BOOL=unsigned;;
 718         esac
 719         AC_MSG_WARN(Assuming $NCURSES_BOOL for type of bool)
 720         cf_cv_type_of_bool=$NCURSES_BOOL
 721 fi
 722 ])dnl
 723 dnl ---------------------------------------------------------------------------
 724 dnl CF_BUILD_CC version: 9 updated: 2021/01/02 09:31:20
 725 dnl -----------
 726 dnl If we're cross-compiling, allow the user to override the tools and their
 727 dnl options.  The configure script is oriented toward identifying the host
 728 dnl compiler, etc., but we need a build compiler to generate parts of the
 729 dnl source.
 730 dnl
 731 dnl $1 = default for $CPPFLAGS
 732 dnl $2 = default for $LIBS
 733 AC_DEFUN([CF_BUILD_CC],[
 734 CF_ACVERSION_CHECK(2.52,,
 735         [AC_REQUIRE([CF_PROG_EXT])])
 736 if test "$cross_compiling" = yes ; then
 737
 738         # defaults that we might want to override
 739         : ${BUILD_CFLAGS:=''}
 740         : ${BUILD_CPPFLAGS:='ifelse([$1],,,[$1])'}
 741         : ${BUILD_LDFLAGS:=''}
 742         : ${BUILD_LIBS:='ifelse([$2],,,[$2])'}
 743         : ${BUILD_EXEEXT:='$x'}
 744         : ${BUILD_OBJEXT:='o'}
 745
 746         AC_ARG_WITH(build-cc,
 747                 [  --with-build-cc=XXX     the build C compiler ($BUILD_CC)],
 748                 [BUILD_CC="$withval"],
 749                 [AC_CHECK_PROGS(BUILD_CC, [gcc clang c99 c89 cc cl],none)])
 750         AC_MSG_CHECKING(for native build C compiler)
 751         AC_MSG_RESULT($BUILD_CC)
 752
 753         AC_MSG_CHECKING(for native build C preprocessor)
 754         AC_ARG_WITH(build-cpp,
 755                 [  --with-build-cpp=XXX    the build C preprocessor ($BUILD_CPP)],
 756                 [BUILD_CPP="$withval"],
 757                 [BUILD_CPP='${BUILD_CC} -E'])
 758         AC_MSG_RESULT($BUILD_CPP)
 759
 760         AC_MSG_CHECKING(for native build C flags)
 761         AC_ARG_WITH(build-cflags,
 762                 [  --with-build-cflags=XXX the build C compiler-flags ($BUILD_CFLAGS)],
 763                 [BUILD_CFLAGS="$withval"])
 764         AC_MSG_RESULT($BUILD_CFLAGS)
 765
 766         AC_MSG_CHECKING(for native build C preprocessor-flags)
 767         AC_ARG_WITH(build-cppflags,
 768                 [  --with-build-cppflags=XXX the build C preprocessor-flags ($BUILD_CPPFLAGS)],
 769                 [BUILD_CPPFLAGS="$withval"])
 770         AC_MSG_RESULT($BUILD_CPPFLAGS)
 771
 772         AC_MSG_CHECKING(for native build linker-flags)
 773         AC_ARG_WITH(build-ldflags,
 774                 [  --with-build-ldflags=XXX the build linker-flags ($BUILD_LDFLAGS)],
 775                 [BUILD_LDFLAGS="$withval"])
 776         AC_MSG_RESULT($BUILD_LDFLAGS)
 777
 778         AC_MSG_CHECKING(for native build linker-libraries)
 779         AC_ARG_WITH(build-libs,
 780                 [  --with-build-libs=XXX   the build libraries (${BUILD_LIBS})],
 781                 [BUILD_LIBS="$withval"])
 782         AC_MSG_RESULT($BUILD_LIBS)
 783
 784         # this assumes we're on Unix.
 785         BUILD_EXEEXT=
 786         BUILD_OBJEXT=o
 787
 788         : ${BUILD_CC:='${CC}'}
 789
 790         if { test "$BUILD_CC" = "$CC" || test "$BUILD_CC" = '${CC}'; } ; then
 791                 AC_MSG_ERROR([Cross-build requires two compilers.
 792 Use --with-build-cc to specify the native compiler.])
 793         fi
 794
 795 else
 796         : ${BUILD_CC:='${CC}'}
 797         : ${BUILD_CPP:='${CPP}'}
 798         : ${BUILD_CFLAGS:='${CFLAGS}'}
 799         : ${BUILD_CPPFLAGS:='${CPPFLAGS}'}
 800         : ${BUILD_LDFLAGS:='${LDFLAGS}'}
 801         : ${BUILD_LIBS:='${LIBS}'}
 802         : ${BUILD_EXEEXT:='$x'}
 803         : ${BUILD_OBJEXT:='o'}
 804 fi
 805
 806 AC_SUBST(BUILD_CC)
 807 AC_SUBST(BUILD_CPP)
 808 AC_SUBST(BUILD_CFLAGS)
 809 AC_SUBST(BUILD_CPPFLAGS)
 810 AC_SUBST(BUILD_LDFLAGS)
 811 AC_SUBST(BUILD_LIBS)
 812 AC_SUBST(BUILD_EXEEXT)
 813 AC_SUBST(BUILD_OBJEXT)
 814 ])dnl
 815 dnl ---------------------------------------------------------------------------
 816 dnl CF_C11_NORETURN version: 3 updated: 2021/03/28 11:36:23
 817 dnl ---------------
 818 AC_DEFUN([CF_C11_NORETURN],
 819 [
 820 AC_MSG_CHECKING(if you want to use C11 _Noreturn feature)
 821 CF_ARG_ENABLE(stdnoreturn,
 822         [  --enable-stdnoreturn    enable C11 _Noreturn feature for diagnostics],
 823         [enable_stdnoreturn=yes],
 824         [enable_stdnoreturn=no])
 825 AC_MSG_RESULT($enable_stdnoreturn)
 826
 827 if test $enable_stdnoreturn = yes; then
 828 AC_CACHE_CHECK([for C11 _Noreturn feature], cf_cv_c11_noreturn,
 829         [AC_TRY_COMPILE([
 830 #include <stdio.h>
 831 #include <stdlib.h>
 832 #include <stdnoreturn.h>
 833 static _Noreturn void giveup(void) { exit(0); }
 834         ],
 835         [if (feof(stdin)) giveup()],
 836         cf_cv_c11_noreturn=yes,
 837         cf_cv_c11_noreturn=no)
 838         ])
 839 else
 840         cf_cv_c11_noreturn=no,
 841 fi
 842
 843 if test "$cf_cv_c11_noreturn" = yes; then
 844         AC_DEFINE(HAVE_STDNORETURN_H, 1,[Define if <stdnoreturn.h> header is available and working])
 845         AC_DEFINE_UNQUOTED(STDC_NORETURN,_Noreturn,[Define if C11 _Noreturn keyword is supported])
 846         HAVE_STDNORETURN_H=1
 847 else
 848         HAVE_STDNORETURN_H=0
 849 fi
 850
 851 AC_SUBST(HAVE_STDNORETURN_H)
 852 AC_SUBST(STDC_NORETURN)
 853 ])dnl
 854 dnl ---------------------------------------------------------------------------
 855 dnl CF_CC_ENV_FLAGS version: 10 updated: 2020/12/31 18:40:20
 856 dnl ---------------
 857 dnl Check for user's environment-breakage by stuffing CFLAGS/CPPFLAGS content
 858 dnl into CC.  This will not help with broken scripts that wrap the compiler
 859 dnl with options, but eliminates a more common category of user confusion.
 860 dnl
 861 dnl In particular, it addresses the problem of being able to run the C
 862 dnl preprocessor in a consistent manner.
 863 dnl
 864 dnl Caveat: this also disallows blanks in the pathname for the compiler, but
 865 dnl the nuisance of having inconsistent settings for compiler and preprocessor
 866 dnl outweighs that limitation.
 867 AC_DEFUN([CF_CC_ENV_FLAGS],
 868 [
 869 # This should have been defined by AC_PROG_CC
 870 : "${CC:=cc}"
 871
 872 AC_MSG_CHECKING(\$CFLAGS variable)
 873 case "x$CFLAGS" in
 874 (*-[[IUD]]*)
 875         AC_MSG_RESULT(broken)
 876         AC_MSG_WARN(your environment uses the CFLAGS variable to hold CPPFLAGS options)
 877         cf_flags="$CFLAGS"
 878         CFLAGS=
 879         for cf_arg in $cf_flags
 880         do
 881                 CF_ADD_CFLAGS($cf_arg)
 882         done
 883         ;;
 884 (*)
 885         AC_MSG_RESULT(ok)
 886         ;;
 887 esac
 888
 889 AC_MSG_CHECKING(\$CC variable)
 890 case "$CC" in
 891 (*[[\ \ ]]-*)
 892         AC_MSG_RESULT(broken)
 893         AC_MSG_WARN(your environment uses the CC variable to hold CFLAGS/CPPFLAGS options)
 894         # humor him...
 895         cf_prog=`echo "$CC" | sed -e 's/        / /g' -e 's/[[ ]]* / /g' -e 's/[[ ]]*[[ ]]-[[^ ]].*//'`
 896         cf_flags=`echo "$CC" | ${AWK:-awk} -v prog="$cf_prog" '{ printf("%s", [substr]([$]0,1+length(prog))); }'`
 897         CC="$cf_prog"
 898         for cf_arg in $cf_flags
 899         do
 900                 case "x$cf_arg" in
 901                 (x-[[IUDfgOW]]*)
 902                         CF_ADD_CFLAGS($cf_arg)
 903                         ;;
 904                 (*)
 905                         CC="$CC $cf_arg"
 906                         ;;
 907                 esac
 908         done
 909         CF_VERBOSE(resulting CC: '$CC')
 910         CF_VERBOSE(resulting CFLAGS: '$CFLAGS')
 911         CF_VERBOSE(resulting CPPFLAGS: '$CPPFLAGS')
 912         ;;
 913 (*)
 914         AC_MSG_RESULT(ok)
 915         ;;
 916 esac
 917 ])dnl
 918 dnl ---------------------------------------------------------------------------
 919 dnl CF_CFG_DEFAULTS version: 16 updated: 2021/01/04 19:33:05
 920 dnl ---------------
 921 dnl Determine the default configuration into which we'll install ncurses.  This
 922 dnl can be overridden by the user's command-line options.  There's two items to
 923 dnl look for:
 924 dnl     1. the prefix (e.g., /usr)
 925 dnl     2. the header files (e.g., /usr/include/ncurses)
 926 dnl We'll look for a previous installation of ncurses and use the same defaults.
 927 dnl
 928 dnl We don't use AC_PREFIX_DEFAULT, because it gets evaluated too soon, and
 929 dnl we don't use AC_PREFIX_PROGRAM, because we cannot distinguish ncurses's
 930 dnl programs from a vendor's.
 931 AC_DEFUN([CF_CFG_DEFAULTS],
 932 [AC_REQUIRE([AC_PROG_FGREP])dnl
 933
 934 AC_MSG_CHECKING(for prefix)
 935 if test "x$prefix" = "xNONE" ; then
 936         case "$cf_cv_system_name" in
 937                 # non-vendor systems don't have a conflict
 938         (openbsd*|freebsd*|mirbsd*|linux*|cygwin*|msys*|k*bsd*-gnu|mingw*)
 939                 prefix=/usr
 940                 ;;
 941         (*)     prefix=$ac_default_prefix
 942                 ;;
 943         esac
 944 fi
 945 AC_MSG_RESULT($prefix)
 946
 947 if test "x$prefix" = "xNONE" ; then
 948 AC_MSG_CHECKING(for default include-directory)
 949 test -n "$verbose" && echo 1>&AC_FD_MSG
 950 for cf_symbol in \
 951         "$includedir" \
 952         "$includedir/ncurses" \
 953         "$prefix/include" \
 954         "$prefix/include/ncurses" \
 955         /usr/local/include \
 956         /usr/local/include/ncurses \
 957         /usr/include \
 958         /usr/include/ncurses
 959 do
 960         cf_dir=`eval echo "$cf_symbol"`
 961         if test -f "$cf_dir/curses.h" ; then
 962         if ( ${FGREP-fgrep} NCURSES_VERSION "$cf_dir/curses.h" >/dev/null 2>&1 ) ; then
 963                 includedir="$cf_symbol"
 964                 test -n "$verbose"  && echo $ECHO_N "   found " 1>&AC_FD_MSG
 965                 break
 966         fi
 967         fi
 968         test -n "$verbose"  && echo "   tested $cf_dir" 1>&AC_FD_MSG
 969 done
 970 AC_MSG_RESULT($includedir)
 971 fi
 972 ])dnl
 973 dnl ---------------------------------------------------------------------------
 974 dnl CF_CGETENT version: 6 updated: 2017/01/21 11:06:25
 975 dnl ----------
 976 dnl Check if the terminal-capability database functions are available.  If not,
 977 dnl ncurses has a much-reduced version.
 978 AC_DEFUN([CF_CGETENT],[
 979 AC_CACHE_CHECK(for terminal-capability database functions,cf_cv_cgetent,[
 980 AC_TRY_LINK([
 981 #include <stdlib.h>],[
 982         char temp[128];
 983         char *buf = temp;
 984         char *db_array = temp;
 985         cgetent(&buf, &db_array, "vt100");
 986         cgetcap(buf, "tc", '=');
 987         cgetmatch(buf, "tc");
 988         ],
 989         [cf_cv_cgetent=yes],
 990         [cf_cv_cgetent=no])
 991 ])
 992
 993 if test "$cf_cv_cgetent" = yes
 994 then
 995         AC_DEFINE(HAVE_BSD_CGETENT,1,[Define to 1 if we have BSD cgetent])
 996 AC_CACHE_CHECK(if cgetent uses const parameter,cf_cv_cgetent_const,[
 997 AC_TRY_LINK([
 998 #pragma GCC diagnostic error "-Wincompatible-pointer-types-discards-qualifiers"
 999 #include <stdlib.h>],[
1000         char temp[128];
1001         char *buf = temp;
1002 #ifndef _NETBSD_SOURCE                  /* given, since April 2004 in stdlib.h */
1003         const char *db_array = temp;
1004         cgetent(&buf, &db_array, "vt100");
1005 #endif
1006         cgetcap(buf, "tc", '=');
1007         cgetmatch(buf, "tc");
1008         ],
1009         [cf_cv_cgetent_const=yes],
1010         [cf_cv_cgetent_const=no])
1011 ])
1012         if test "$cf_cv_cgetent_const" = yes
1013         then
1014                 AC_DEFINE_UNQUOTED(CGETENT_CONST,const,[Define to const if needed for some BSD cgetent variations])
1015         fi
1016 fi
1017 ])dnl
1018 dnl ---------------------------------------------------------------------------
1019 dnl CF_CHECK_CACHE version: 13 updated: 2020/12/31 10:54:15
1020 dnl --------------
1021 dnl Check if we're accidentally using a cache from a different machine.
1022 dnl Derive the system name, as a check for reusing the autoconf cache.
1023 dnl
1024 dnl If we've packaged config.guess and config.sub, run that (since it does a
1025 dnl better job than uname).  Normally we'll use AC_CANONICAL_HOST, but allow
1026 dnl an extra parameter that we may override, e.g., for AC_CANONICAL_SYSTEM
1027 dnl which is useful in cross-compiles.
1028 dnl
1029 dnl Note: we would use $ac_config_sub, but that is one of the places where
1030 dnl autoconf 2.5x broke compatibility with autoconf 2.13
1031 AC_DEFUN([CF_CHECK_CACHE],
1032 [
1033 if test -f "$srcdir/config.guess" || test -f "$ac_aux_dir/config.guess" ; then
1034         ifelse([$1],,[AC_CANONICAL_HOST],[$1])
1035         system_name="$host_os"
1036 else
1037         system_name="`(uname -s -r) 2>/dev/null`"
1038         if test -z "$system_name" ; then
1039                 system_name="`(hostname) 2>/dev/null`"
1040         fi
1041 fi
1042 test -n "$system_name" && AC_DEFINE_UNQUOTED(SYSTEM_NAME,"$system_name",[Define to the system name.])
1043 AC_CACHE_VAL(cf_cv_system_name,[cf_cv_system_name="$system_name"])
1044
1045 test -z "$system_name" && system_name="$cf_cv_system_name"
1046 test -n "$cf_cv_system_name" && AC_MSG_RESULT(Configuring for $cf_cv_system_name)
1047
1048 if test ".$system_name" != ".$cf_cv_system_name" ; then
1049         AC_MSG_RESULT(Cached system name ($system_name) does not agree with actual ($cf_cv_system_name))
1050         AC_MSG_ERROR("Please remove config.cache and try again.")
1051 fi
1052 ])dnl
1053 dnl ---------------------------------------------------------------------------
1054 dnl CF_CHECK_ENVIRON version: 3 updated: 2010/05/26 16:44:57
1055 dnl ----------------
1056 dnl Check for data that is usually declared in <unistd.h>, e.g., the 'environ'
1057 dnl variable.  Define a DECL_xxx symbol if we must declare it ourselves.
1058 dnl
1059 dnl $1 = the name to check
1060 dnl $2 = the assumed type
1061 AC_DEFUN([CF_CHECK_ENVIRON],
1062 [
1063 AC_CACHE_CHECK(if external $1 is declared, cf_cv_dcl_$1,[
1064     AC_TRY_COMPILE([
1065 #ifdef HAVE_STDLIB_H
1066 #include <stdlib.h>
1067 #endif
1068 #include <unistd.h> ],
1069     ifelse([$2],,int,[$2]) x = (ifelse([$2],,int,[$2])) $1,
1070     [cf_cv_dcl_$1=yes],
1071     [cf_cv_dcl_$1=no])
1072 ])
1073
1074 if test "$cf_cv_dcl_$1" = no ; then
1075     CF_UPPER(cf_result,decl_$1)
1076     AC_DEFINE_UNQUOTED($cf_result)
1077 fi
1078
1079 # It's possible (for near-UNIX clones) that the data doesn't exist
1080 CF_CHECK_EXTERN_DATA($1,ifelse([$2],,int,[$2]))
1081 ])dnl
1082 dnl ---------------------------------------------------------------------------
1083 dnl CF_CHECK_ERRNO version: 13 updated: 2020/03/10 18:53:47
1084 dnl --------------
1085 dnl Check for data that is usually declared in <stdio.h> or <errno.h>, e.g.,
1086 dnl the 'errno' variable.  Define a DECL_xxx symbol if we must declare it
1087 dnl ourselves.
1088 dnl
1089 dnl $1 = the name to check
1090 dnl $2 = the assumed type
1091 AC_DEFUN([CF_CHECK_ERRNO],
1092 [
1093 AC_CACHE_CHECK(if external $1 is declared, cf_cv_dcl_$1,[
1094         AC_TRY_COMPILE([
1095 #ifdef HAVE_STDLIB_H
1096 #include <stdlib.h>
1097 #endif
1098 #include <stdio.h>
1099 #include <sys/types.h>
1100 #include <errno.h> ],
1101         ifelse([$2],,int,[$2]) x = (ifelse([$2],,int,[$2])) $1; (void)x,
1102         [cf_cv_dcl_$1=yes],
1103         [cf_cv_dcl_$1=no])
1104 ])
1105
1106 if test "$cf_cv_dcl_$1" = no ; then
1107         CF_UPPER(cf_result,decl_$1)
1108         AC_DEFINE_UNQUOTED($cf_result)
1109 fi
1110
1111 # It's possible (for near-UNIX clones) that the data doesn't exist
1112 CF_CHECK_EXTERN_DATA($1,ifelse([$2],,int,[$2]))
1113 ])dnl
1114 dnl ---------------------------------------------------------------------------
1115 dnl CF_CHECK_EXTERN_DATA version: 5 updated: 2021/09/04 06:35:04
1116 dnl --------------------
1117 dnl Check for existence of external data in the current set of libraries.  If
1118 dnl we can modify it, it is real enough.
1119 dnl $1 = the name to check
1120 dnl $2 = its type
1121 AC_DEFUN([CF_CHECK_EXTERN_DATA],
1122 [
1123 AC_CACHE_CHECK(if external $1 exists, cf_cv_have_$1,[
1124         AC_TRY_LINK([
1125 #undef $1
1126 extern $2 $1;
1127 ],
1128         [$1 = 2],
1129         [cf_cv_have_$1=yes],
1130         [cf_cv_have_$1=no])
1131 ])
1132
1133 if test "$cf_cv_have_$1" = yes ; then
1134         CF_UPPER(cf_result,have_$1)
1135         AC_DEFINE_UNQUOTED($cf_result)
1136 fi
1137
1138 ])dnl
1139 dnl ---------------------------------------------------------------------------
1140 dnl CF_CHECK_FVISIBILITY version: 2 updated: 2020/04/04 16:16:13
1141 dnl --------------------
1142 dnl Check whether the compiler understands -fvisibility=hidden
1143 dnl
1144 dnl $1 = compiler
1145 dnl $2 = compiler-flags variable name
1146 dnl $3 = cache variable to set
1147 AC_DEFUN([CF_CHECK_FVISIBILITY],[
1148 AC_CACHE_CHECK(if $1 -fvisibility=hidden option works,$3,[
1149     cf_save_cflags="[$]$2"
1150     $2="[$]$2 -fvisibility=hidden"
1151     AC_TRY_LINK([
1152 __attribute__ ((visibility("default"))) int somefunc() {return 42;}
1153         ],[
1154         if (somefunc()) return 1;
1155 ],
1156     [$3=yes],
1157     [$3=no])
1158     $2=$cf_save_cflags
1159 ])
1160 ])dnl
1161 dnl ---------------------------------------------------------------------------
1162 dnl CF_CHECK_GETENV version: 2 updated: 2021/01/02 17:09:14
1163 dnl ---------------
1164 dnl Check if repeated getenv calls return the same pointer, e.g., it does not
1165 dnl discard the previous pointer when returning a new one.
1166 AC_DEFUN([CF_CHECK_GETENV],
1167 [
1168 AC_REQUIRE([CF_CHECK_ENVIRON])
1169 AC_CHECK_FUNC( getenv, ,, AC_MSG_ERROR(getenv not found) )
1170 AC_CHECK_FUNCS( putenv setenv strdup )
1171 AC_CACHE_CHECK(if getenv returns consistent values,cf_cv_consistent_getenv,[
1172 AC_TRY_RUN([
1173 #include <stdlib.h>
1174 #include <unistd.h>
1175 #include <stdio.h>
1176 #include <string.h>
1177 #include <sys/types.h>
1178
1179 #if defined(HAVE_ENVIRON) && defined(DECL_ENVIRON) && !defined(environ)
1180 extern char **environ;  /* POSIX, but some systems are not... */
1181 #endif
1182
1183 #if defined(HAVE_STRDUP)
1184 #define str_alloc(s) strdup(s)
1185 #else
1186 #define str_alloc(s) strcpy(malloc(strlen(s) + 1, s))
1187 #endif
1188
1189 static void set_value(const char *name, const char *value)
1190 {
1191 #if defined(HAVE_SETENV)
1192         setenv(name, value, 1);
1193 #elif defined(HAVE_PUTENV)
1194         char buffer[1024];
1195         sprintf(buffer, "%s=%s", name, value);
1196         putenv(str_alloc(buffer));
1197 #else
1198 #error neither putenv/setenv found
1199 #endif
1200 }
1201 int main(void)
1202 {
1203         int pass;
1204         size_t numenv, limit, j;
1205         char **mynames;
1206         char **myvalues;
1207         char **mypointer;
1208         char *equals;
1209         for (numenv = 0; environ[numenv]; ++numenv) ;
1210         limit = numenv + 10;
1211         mynames = (char **) calloc(limit + 1, sizeof(char *));
1212         myvalues = (char **) calloc(limit + 1, sizeof(char *));
1213         mypointer = (char **) calloc(limit + 1, sizeof(char *));
1214 #if defined(HAVE_ENVIRON)
1215         for (j = 0; environ[j]; ++j) {
1216                 mynames[j] = str_alloc(environ[j]);
1217                 equals = strchr(mynames[j], '=');
1218                 if (equals != 0) {
1219                         *equals++ = '\\0';
1220                         myvalues[j] = str_alloc(equals);
1221                 } else {
1222                         myvalues[j] = str_alloc("");
1223                 }
1224         }
1225 #endif
1226         for (j = numenv; j < limit; ++j) {
1227                 char name[80];
1228                 char value[80];
1229                 size_t found;
1230                 size_t k = 0;
1231                 do {
1232                         size_t jk;
1233                         found = 0;
1234                         sprintf(name, "TERM%lu", (unsigned long) k);
1235                         for (jk = 0; jk < j; ++jk) {
1236                                 if (!strcmp(name, mynames[jk])) {
1237                                         found = 1;
1238                                         ++k;
1239                                         break;
1240                                 }
1241                         }
1242                 } while (found);
1243                 sprintf(value, "%lu:%p", (unsigned long) k, &mynames[j]);
1244                 set_value(name, value);
1245                 mynames[j] = str_alloc(name);
1246                 myvalues[j] = str_alloc(value);
1247         }
1248         for (pass = 0; pass < 3; ++pass) {
1249                 for (j = 0; j < limit; ++j) {
1250                         char *value = getenv(mynames[j]);
1251                         if (pass) {
1252                                 if (value == 0) {
1253                                         fprintf(stderr, "getenv returned null for %s\\n", mynames[j]);
1254                                         ${cf_cv_main_return:-return}(1);
1255                                 } else if (value != mypointer[j]) {
1256                                         fprintf(stderr, "getenv returned different pointer for %s\\n", mynames[j]);
1257                                         ${cf_cv_main_return:-return}(1);
1258                                 } else if (strcmp(value, myvalues[j])) {
1259                                         fprintf(stderr, "getenv returned different value for %s\\n", mynames[j]);
1260                                         ${cf_cv_main_return:-return}(1);
1261                                 }
1262                         } else {
1263                                 size_t k;
1264                                 mypointer[j] = value;
1265                                 for (k = 0; k < j; ++k) {
1266                                         if (mypointer[j] == mypointer[k]) {
1267                                                 fprintf(stderr, "getenv returned same pointer for %s and %s\\n", mynames[j], mynames[k]);
1268                                                 ${cf_cv_main_return:-return}(1);
1269                                         }
1270                                 }
1271                         }
1272                 }
1273         }
1274         ${cf_cv_main_return:-return}(0);
1275 }
1276 ],
1277 [cf_cv_consistent_getenv=yes],
1278 [cf_cv_consistent_getenv=no],
1279 [cf_cv_consistent_getenv=unknown])
1280 ])
1281
1282 if test "x$cf_cv_consistent_getenv" = xno
1283 then
1284         AC_DEFINE(HAVE_CONSISTENT_GETENV,1,[Define to 1 if getenv repeatably returns the same value for a given name])
1285 fi
1286 ])dnl
1287 dnl ---------------------------------------------------------------------------
1288 dnl CF_CHECK_GNAT_VERSION version: 4 updated: 2021/01/01 13:31:04
1289 dnl ---------------------
1290 AC_DEFUN([CF_CHECK_GNAT_VERSION],
1291 [
1292 AC_REQUIRE([CF_GNAT_VERSION])
1293 case "$cf_cv_gnat_version" in
1294 (3.1[[1-9]]*|3.[[2-9]]*|[[4-9]].*|[[1-9]][[0-9]].[[0-9]]*|20[[0-9]][[0-9]])
1295         cf_cv_prog_gnat_correct=yes
1296         ;;
1297 (*)
1298         AC_MSG_WARN(Unsupported GNAT version $cf_cv_gnat_version. We require 3.11 or better. Disabling Ada95 binding.)
1299         cf_cv_prog_gnat_correct=no
1300         ;;
1301 esac
1302 ])
1303 dnl ---------------------------------------------------------------------------
1304 dnl CF_CHECK_GPM_WGETCH version: 6 updated: 2021/01/04 18:48:01
1305 dnl -------------------
1306 dnl Check if GPM is already linked with curses.  If so - and if the linkage
1307 dnl is not "weak" - warn about this because it can create problems linking
1308 dnl applications with ncurses.
1309 AC_DEFUN([CF_CHECK_GPM_WGETCH],[
1310 AC_REQUIRE([AC_PROG_EGREP])dnl
1311
1312 AC_CHECK_LIB(gpm,Gpm_Wgetch,[
1313
1314 AC_CACHE_CHECK(if GPM is weakly bound to curses library, cf_cv_check_gpm_wgetch,[
1315 cf_cv_check_gpm_wgetch=unknown
1316 if test "$cross_compiling" != yes ; then
1317
1318 cat >conftest.$ac_ext <<CF_EOF
1319 #include <gpm.h>
1320 int main(void)
1321 {
1322         Gpm_Wgetch();
1323         ${cf_cv_main_return:-return}(0);
1324 }
1325 CF_EOF
1326
1327         cf_save_LIBS="$LIBS"
1328         # This only works if we can look at the symbol table.  If a shared
1329         # library is stripped for install, we cannot use that.  So we're forced
1330         # to rely on the static library, noting that some packagers may not
1331         # include it.
1332         LIBS="-static -lgpm -dynamic $LIBS"
1333         if AC_TRY_EVAL(ac_compile) ; then
1334                 if AC_TRY_EVAL(ac_link) ; then
1335                         cf_cv_check_gpm_wgetch="`nm \"conftest$ac_exeext\" | ${EGREP-egrep} '\<wgetch\>' | ${EGREP-egrep} '\<[[vVwW]]\>'`"
1336                         test -n "$cf_cv_check_gpm_wgetch" && cf_cv_check_gpm_wgetch=yes
1337                         test -z "$cf_cv_check_gpm_wgetch" && cf_cv_check_gpm_wgetch=no
1338                 fi
1339         fi
1340         rm -rf ./conftest*
1341         LIBS="$cf_save_LIBS"
1342 fi
1343 ])
1344
1345 if test "$cf_cv_check_gpm_wgetch" != yes ; then
1346         AC_MSG_WARN(GPM library is already linked with curses - read the FAQ)
1347 fi
1348 ])])dnl
1349 dnl ---------------------------------------------------------------------------
1350 dnl CF_CHECK_LIBSSP version: 1 updated: 2021/10/30 10:40:19
1351 dnl ---------------
1352 dnl Check if libssp is needed, e.g., to work around misconfigured libraries
1353 dnl used in cross-compiling to MinGW.
1354 AC_DEFUN([CF_CHECK_LIBSSP],[
1355 AC_CACHE_CHECK(if ssp library is needed,cf_cv_need_libssp,[
1356 AC_TRY_LINK([
1357 #include <sys/types.h>
1358 #include <dirent.h>
1359 ],[
1360        DIR *dp = opendir(".");
1361 ],cf_cv_need_libssp=no,[
1362         cf_save_LIBS="$LIBS"
1363         LIBS="$LIBS -lssp"
1364         AC_TRY_LINK([
1365 #include <sys/types.h>
1366 #include <dirent.h>
1367         ],[
1368                    DIR *dp = opendir(".");
1369         ],cf_cv_need_libssp=yes,
1370           cf_cv_need_libssp=maybe)
1371         LIBS="$cf_save_LIBS"
1372 ])dnl
1373 ])
1374
1375 if test "x$cf_cv_need_libssp" = xyes
1376 then
1377         CF_ADD_LIB(ssp)
1378 fi
1379 ])dnl
1380 dnl ---------------------------------------------------------------------------
1381 dnl CF_CHECK_LIBTOOL_VERSION version: 2 updated: 2021/05/01 16:24:34
1382 dnl ------------------------
1383 dnl Show the version of libtool
1384 dnl
1385 dnl Save the version in a cache variable - this is not entirely a good thing,
1386 dnl but the version string from libtool is very ugly, and for bug reports it
1387 dnl might be useful to have the original string.
1388 dnl
1389 dnl There is an imitation in OpenBSD, which has no apparent use other than to
1390 dnl deny that it is GNU libtool.  Just ignore it.
1391 AC_DEFUN([CF_CHECK_LIBTOOL_VERSION],[
1392 if test -n "$LIBTOOL" && test "$LIBTOOL" != none
1393 then
1394         AC_MSG_CHECKING(version of $LIBTOOL)
1395         CF_LIBTOOL_VERSION
1396         AC_MSG_RESULT($cf_cv_libtool_version)
1397         if test -n "$cf_cv_libtool_version"
1398         then
1399                 cf_check_libtool_version=`$LIBTOOL --version 2>&1 | sed -e '/^$/d' -e 's,[[()]],...,g' -e 's,[[ ]],-,g' -e '2,$d'`
1400                 case "x$cf_check_libtool_version" in
1401                 (*...GNU-libtool...*)
1402                         ;;
1403                 (*)
1404                         AC_MSG_ERROR(This is not GNU libtool)
1405                         ;;
1406                 esac
1407         else
1408                 AC_MSG_ERROR(No version found for $LIBTOOL)
1409         fi
1410 else
1411         AC_MSG_ERROR(GNU libtool has not been found)
1412 fi
1413 ])dnl
1414 dnl ---------------------------------------------------------------------------
1415 dnl CF_CHECK_WCHAR_H version: 3 updated: 2021/01/01 13:31:04
1416 dnl ----------------
1417 dnl Check if wchar.h can be used, i.e., without defining _XOPEN_SOURCE_EXTENDED
1418 AC_DEFUN([CF_CHECK_WCHAR_H],[
1419 AC_CHECK_HEADERS( \
1420 wchar.h \
1421 wctype.h \
1422 )
1423 AC_CACHE_CHECK(if wchar.h can be used as is,cf_cv_wchar_h_okay,[
1424 AC_TRY_COMPILE(
1425 [
1426 #include <stdlib.h>
1427 #ifdef HAVE_WCHAR_H
1428 #include <wchar.h>
1429 #endif
1430 #ifdef HAVE_WCTYPE_H
1431 #include <wctype.h>
1432 #endif
1433 ],[
1434         wint_t foo = 0;
1435         int bar = iswpunct(foo)],
1436         [cf_cv_wchar_h_okay=yes],
1437         [cf_cv_wchar_h_okay=no])])
1438
1439 if test "$cf_cv_wchar_h_okay" = no
1440 then
1441         CF_PREDEFINE(_XOPEN_SOURCE_EXTENDED)
1442 fi
1443 ])dnl
1444 dnl ---------------------------------------------------------------------------
1445 dnl CF_CHECK_WCWIDTH_GRAPHICS version: 2 updated: 2021/01/02 17:09:14
1446 dnl -------------------------
1447 dnl Most "modern" terminal emulators are based to some degree on VT100, and
1448 dnl should support line-drawing.  Even with Unicode.  There is a problem.
1449 dnl
1450 dnl While most of the VT100 graphics characters were incorporated into Unicode,
1451 dnl all of those were combined into a page of useful graphics characters.
1452 dnl
1453 dnl So far, so good.
1454 dnl
1455 dnl However, while they are useful, there are other considerations.  CJK
1456 dnl is (because of poor device resolution) often rendered as double-width
1457 dnl characters.  So... for these generally-useful characters, what should
1458 dnl be the width (to make them consistent with adjacent characters)?
1459 dnl
1460 dnl The obvious choice would have been to make this locale-dependent, and use
1461 dnl wcwidth() to tell applications what the actual width is.  That was too
1462 dnl obvious.  Instead, we have a slew of "ambiguous-width" characters.
1463 dnl See for example
1464 dnl             http://www.unicode.org/reports/tr11/tr11-29.html
1465 dnl             http://www.cl.cam.ac.uk/~mgk25/ucs/scw-proposal.html
1466 dnl
1467 dnl The EastAsianWidth-6.2.0.txt file from the Unicode organization lists
1468 dnl more than 22,000 characters, with 1281 of those as ambiguous-width.  For
1469 dnl instance, it lists half (44/96) of the Latin-1 characters as
1470 dnl ambiguous-width.  Also, all of the box-characters at 0x2500 are ambiguous.
1471 dnl
1472 dnl What this means for the implementor is that on some systems wcwidth() can
1473 dnl give bad advice.  On Solaris, some of the ambiguous widths are returned as
1474 dnl 1 (the Latin-1 characters), while others are returned as 2 (line-drawing
1475 dnl characters).  These do not necessarily match the behavior of the terminal
1476 dnl emulator.  xterm, for instance, does an optional startup check to find if
1477 dnl this problem (or similar) exists with the system's locale tables, rejecting
1478 dnl them if they are too unreliable.
1479 AC_DEFUN([CF_CHECK_WCWIDTH_GRAPHICS],[
1480 AC_CACHE_CHECK(if wcwidth agrees graphics are single-width, cf_cv_wcwidth_graphics,[
1481 cat >conftest.in <<CF_EOF
1482 -       VT100 symbols
1483 0x250c  upper left corner
1484 0x2514  lower left corner
1485 0x2510  upper right corner
1486 0x2518  lower right corner
1487 0x251c  tee pointing left
1488 0x2524  tee pointing right
1489 0x2534  tee pointing up
1490 0x252c  tee pointing down
1491 0x2500  horizontal line
1492 0x2502  vertical line
1493 0x253c  large plus or crossover
1494 0x23ba  scan line 1
1495 0x23bd  scan line 9
1496 0x25c6  diamond
1497 0x2592  checker board (stipple)
1498 0x00b0  degree symbol
1499 0x00b1  plus/minus
1500 0x00b7  bullet
1501 -       Teletype 5410v1 symbols
1502 0x2190  arrow pointing left
1503 0x2192  arrow pointing right
1504 0x2193  arrow pointing down
1505 0x2191  arrow pointing up
1506 0x2592  board of squares
1507 0x2603  lantern symbol
1508 0x25ae  solid square block
1509 -       these defaults were invented for ncurses
1510 0x23bb  scan line 3
1511 0x23bc  scan line 7
1512 0x2264  less-than-or-equal-to
1513 0x2265  greater-than-or-equal-to
1514 0x03c0  greek pi
1515 0x2260  not-equal
1516 0x00a3  pound-sterling symbol
1517 -       thick-line-drawing
1518 0x250f  upper left corner
1519 0x2517  lower left corner
1520 0x2513  upper right corner
1521 0x251b  lower right corner
1522 0x2523  tee pointing left
1523 0x252b  tee pointing right
1524 0x253b  tee pointing up
1525 0x2533  tee pointing down
1526 0x2501  horizontal line
1527 0x2503  vertical line
1528 0x254b  large plus or crossover
1529 -       double-line-drawing
1530 0x2554  upper left corner
1531 0x255a  lower left corner
1532 0x2557  upper right corner
1533 0x255d  lower right corner
1534 0x2563  tee pointing left
1535 0x2560  tee pointing right
1536 0x2569  tee pointing up
1537 0x2566  tee pointing down
1538 0x2550  horizontal line
1539 0x2551  vertical line
1540 0x256c  large plus or crossover
1541 CF_EOF
1542 AC_TRY_RUN([
1543 #include <locale.h>
1544 #include <stdio.h>
1545 #include <wchar.h>
1546
1547 #define MY_LEN 80
1548
1549 int
1550 main(void)
1551 {
1552         FILE *fp;
1553         int value;
1554         char buffer[MY_LEN + 1];
1555         char notes[MY_LEN + 1];
1556         int totals = 0;
1557         int passed = 0;
1558
1559         if (setlocale(LC_ALL, "en_US.UTF8") ||
1560                 setlocale(LC_ALL, "en_US.UTF-8") ||
1561                 setlocale(LC_ALL, "en_US.utf8") ||
1562                 setlocale(LC_ALL, "en_US.utf-8")) {
1563                 if ((fp = fopen("conftest.in", "r")) != 0) {
1564                         while (fgets(buffer, MY_LEN, fp) != 0) {
1565                                 if (*buffer == '-') {
1566                                         fprintf(stderr, "\\t%s", buffer);
1567                                 } else if (sscanf(buffer, "%x %s", &value, notes) == 2) {
1568                                         ++totals;
1569                                         if (wcwidth(value) == 1)
1570                                                 ++passed;
1571                                         fprintf(stderr, "%d\\t%s", wcwidth(value), buffer);
1572                                 } else {
1573                                         fprintf(stderr, "?\\t%s", buffer);
1574                                 }
1575                         }
1576                 }
1577         }
1578         fprintf(stderr, "%d/%d passed wcwidth/graphics check\\n", passed, totals);
1579         return (totals == passed) ? 0 : 1;
1580 }
1581 ],
1582 [cf_cv_wcwidth_graphics=yes],
1583 [cf_cv_wcwidth_graphics=no],
1584 [cf_cv_wcwidth_graphics=unknown])
1585 ])
1586 ])dnl
1587 dnl ---------------------------------------------------------------------------
1588 dnl CF_CLANG_COMPILER version: 8 updated: 2021/01/01 13:31:04
1589 dnl -----------------
1590 dnl Check if the given compiler is really clang.  clang's C driver defines
1591 dnl __GNUC__ (fooling the configure script into setting $GCC to yes) but does
1592 dnl not ignore some gcc options.
1593 dnl
1594 dnl This macro should be run "soon" after AC_PROG_CC or AC_PROG_CPLUSPLUS, to
1595 dnl ensure that it is not mistaken for gcc/g++.  It is normally invoked from
1596 dnl the wrappers for gcc and g++ warnings.
1597 dnl
1598 dnl $1 = GCC (default) or GXX
1599 dnl $2 = CLANG_COMPILER (default)
1600 dnl $3 = CFLAGS (default) or CXXFLAGS
1601 AC_DEFUN([CF_CLANG_COMPILER],[
1602 ifelse([$2],,CLANG_COMPILER,[$2])=no
1603
1604 if test "$ifelse([$1],,[$1],GCC)" = yes ; then
1605         AC_MSG_CHECKING(if this is really Clang ifelse([$1],GXX,C++,C) compiler)
1606         cf_save_CFLAGS="$ifelse([$3],,CFLAGS,[$3])"
1607         AC_TRY_COMPILE([],[
1608 #ifdef __clang__
1609 #else
1610 make an error
1611 #endif
1612 ],[ifelse([$2],,CLANG_COMPILER,[$2])=yes
1613 ],[])
1614         ifelse([$3],,CFLAGS,[$3])="$cf_save_CFLAGS"
1615         AC_MSG_RESULT($ifelse([$2],,CLANG_COMPILER,[$2]))
1616 fi
1617
1618 CLANG_VERSION=none
1619
1620 if test "x$ifelse([$2],,CLANG_COMPILER,[$2])" = "xyes" ; then
1621         case "$CC" in
1622         (c[[1-9]][[0-9]]|*/c[[1-9]][[0-9]])
1623                 AC_MSG_WARN(replacing broken compiler alias $CC)
1624                 CFLAGS="$CFLAGS -std=`echo "$CC" | sed -e 's%.*/%%'`"
1625                 CC=clang
1626                 ;;
1627         esac
1628
1629         AC_MSG_CHECKING(version of $CC)
1630         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.]].*//'`"
1631         test -z "$CLANG_VERSION" && CLANG_VERSION=unknown
1632         AC_MSG_RESULT($CLANG_VERSION)
1633
1634         for cf_clang_opt in \
1635                 -Qunused-arguments \
1636                 -Wno-error=implicit-function-declaration
1637         do
1638                 AC_MSG_CHECKING(if option $cf_clang_opt works)
1639                 cf_save_CFLAGS="$CFLAGS"
1640                 CFLAGS="$CFLAGS $cf_clang_opt"
1641                 AC_TRY_LINK([
1642                         #include <stdio.h>],[
1643                         printf("hello!\\n");],[
1644                         cf_clang_optok=yes],[
1645                         cf_clang_optok=no])
1646                 AC_MSG_RESULT($cf_clang_optok)
1647                 CFLAGS="$cf_save_CFLAGS"
1648                 if test "$cf_clang_optok" = yes; then
1649                         CF_VERBOSE(adding option $cf_clang_opt)
1650                         CF_APPEND_TEXT(CFLAGS,$cf_clang_opt)
1651                 fi
1652         done
1653 fi
1654 ])
1655 dnl ---------------------------------------------------------------------------
1656 dnl CF_CONST_X_STRING version: 7 updated: 2021/06/07 17:39:17
1657 dnl -----------------
1658 dnl The X11R4-X11R6 Xt specification uses an ambiguous String type for most
1659 dnl character-strings.
1660 dnl
1661 dnl It is ambiguous because the specification accommodated the pre-ANSI
1662 dnl compilers bundled by more than one vendor in lieu of providing a standard C
1663 dnl compiler other than by costly add-ons.  Because of this, the specification
1664 dnl did not take into account the use of const for telling the compiler that
1665 dnl string literals would be in readonly memory.
1666 dnl
1667 dnl As a workaround, one could (starting with X11R5) define XTSTRINGDEFINES, to
1668 dnl let the compiler decide how to represent Xt's strings which were #define'd.
1669 dnl That does not solve the problem of using the block of Xt's strings which
1670 dnl are compiled into the library (and is less efficient than one might want).
1671 dnl
1672 dnl Xt specification 7 introduces the _CONST_X_STRING symbol which is used both
1673 dnl when compiling the library and compiling using the library, to tell the
1674 dnl compiler that String is const.
1675 AC_DEFUN([CF_CONST_X_STRING],
1676 [
1677 AC_REQUIRE([AC_PATH_XTRA])
1678
1679 CF_SAVE_XTRA_FLAGS([CF_CONST_X_STRING])
1680
1681 AC_TRY_COMPILE(
1682 [
1683 #include <stdlib.h>
1684 #include <X11/Intrinsic.h>
1685 ],
1686 [String foo = malloc(1); free((void*)foo)],[
1687
1688 AC_CACHE_CHECK(for X11/Xt const-feature,cf_cv_const_x_string,[
1689         AC_TRY_COMPILE(
1690                 [
1691 #define _CONST_X_STRING /* X11R7.8 (perhaps) */
1692 #undef  XTSTRINGDEFINES /* X11R5 and later */
1693 #include <stdlib.h>
1694 #include <X11/Intrinsic.h>
1695                 ],[String foo = malloc(1); *foo = 0],[
1696                         cf_cv_const_x_string=no
1697                 ],[
1698                         cf_cv_const_x_string=yes
1699                 ])
1700 ])
1701
1702 CF_RESTORE_XTRA_FLAGS([CF_CONST_X_STRING])
1703
1704 case "$cf_cv_const_x_string" in
1705 (no)
1706         CF_APPEND_TEXT(CPPFLAGS,-DXTSTRINGDEFINES)
1707         ;;
1708 (*)
1709         CF_APPEND_TEXT(CPPFLAGS,-D_CONST_X_STRING)
1710         ;;
1711 esac
1712
1713 ])
1714 ])dnl
1715 dnl ---------------------------------------------------------------------------
1716 dnl CF_CPP_PARAM_INIT version: 7 updated: 2017/01/21 11:06:25
1717 dnl -----------------
1718 dnl Check if the C++ compiler accepts duplicate parameter initialization.  This
1719 dnl is a late feature for the standard and is not in some recent compilers
1720 dnl (1999/9/11).
1721 AC_DEFUN([CF_CPP_PARAM_INIT],
1722 [
1723 if test -n "$CXX"; then
1724 AC_CACHE_CHECK(if $CXX accepts parameter initialization,cf_cv_cpp_param_init,[
1725         AC_LANG_SAVE
1726         AC_LANG_CPLUSPLUS
1727         AC_TRY_RUN([
1728 class TEST {
1729 private:
1730         int value;
1731 public:
1732         TEST(int x = 1);
1733         ~TEST();
1734 };
1735
1736 TEST::TEST(int x = 1)   // some compilers do not like second initializer
1737 {
1738         value = x;
1739 }
1740 int main(void) { }
1741 ],
1742         [cf_cv_cpp_param_init=yes],
1743         [cf_cv_cpp_param_init=no],
1744         [cf_cv_cpp_param_init=unknown])
1745         AC_LANG_RESTORE
1746 ])
1747 fi
1748 test "$cf_cv_cpp_param_init" = yes && AC_DEFINE(CPP_HAS_PARAM_INIT,1,[Define to 1 if C++ has parameter initialization])
1749 ])dnl
1750 dnl ---------------------------------------------------------------------------
1751 dnl CF_CPP_STATIC_CAST version: 3 updated: 2013/04/13 18:03:21
1752 dnl ------------------
1753 dnl Check if the C++ compiler accepts static_cast in generics.  This appears to
1754 dnl not be supported in g++ before 3.0
1755 AC_DEFUN([CF_CPP_STATIC_CAST],
1756 [
1757 if test -n "$CXX"; then
1758
1759 AC_CACHE_CHECK(if $CXX accepts static_cast,cf_cv_cpp_static_cast,[
1760         AC_LANG_SAVE
1761         AC_LANG_CPLUSPLUS
1762
1763         AC_TRY_COMPILE([
1764 class NCursesPanel
1765 {
1766 public:
1767   NCursesPanel(int nlines,
1768                int ncols,
1769                int begin_y = 0,
1770                int begin_x = 0)
1771   {
1772   }
1773   NCursesPanel();
1774   ~NCursesPanel();
1775 };
1776
1777 template<class T> class NCursesUserPanel : public NCursesPanel
1778 {
1779 public:
1780   NCursesUserPanel (int nlines,
1781                     int ncols,
1782                     int begin_y = 0,
1783                     int begin_x = 0,
1784                     const T* p_UserData = static_cast<T*>(0))
1785     : NCursesPanel (nlines, ncols, begin_y, begin_x)
1786   {
1787   };
1788   NCursesUserPanel(const T* p_UserData = static_cast<T*>(0)) : NCursesPanel()
1789   {
1790   };
1791
1792   virtual ~NCursesUserPanel() {};
1793 };
1794 ],[
1795         const char* p_UserData = static_cast<char*>(0)],
1796         [cf_cv_cpp_static_cast=yes],
1797         [cf_cv_cpp_static_cast=no])
1798
1799         AC_LANG_RESTORE
1800 ])
1801
1802 fi
1803
1804 test "$cf_cv_cpp_static_cast" = yes && AC_DEFINE(CPP_HAS_STATIC_CAST,1,[Define to 1 if C++ has static_cast])
1805 ])dnl
1806 dnl ---------------------------------------------------------------------------
1807 dnl CF_CXX_AR_FLAGS version: 3 updated: 2021/01/01 13:31:04
1808 dnl ---------------
1809 dnl Setup special archiver flags for given compilers.
1810 AC_DEFUN([CF_CXX_AR_FLAGS],[
1811         CXX_AR='$(AR)'
1812         CXX_ARFLAGS='$(ARFLAGS)'
1813         case "$cf_cv_system_name" in
1814         (irix*)
1815             if test "$GXX" != yes ; then
1816                 CXX_AR='$(CXX)'
1817                 CXX_ARFLAGS='-ar -o'
1818             fi
1819             ;;
1820         (sco3.2v5*)
1821             CXXLDFLAGS="-u main"
1822             ;;
1823         (solaris2*)
1824             if test "$GXX" != yes ; then
1825                 CXX_AR='$(CXX)'
1826                 CXX_ARFLAGS='-xar -o'
1827             fi
1828             ;;
1829         esac
1830         AC_SUBST(CXXLDFLAGS)
1831         AC_SUBST(CXX_AR)
1832         AC_SUBST(CXX_ARFLAGS)
1833 ])dnl
1834 dnl ---------------------------------------------------------------------------
1835 dnl CF_CXX_IOSTREAM_NAMESPACE version: 2 updated: 2012/10/06 17:56:13
1836 dnl -------------------------
1837 dnl For c++, check if iostream uses "std::" namespace.
1838 AC_DEFUN([CF_CXX_IOSTREAM_NAMESPACE],[
1839 AC_CHECK_HEADERS(iostream)
1840 if test x"$ac_cv_header_iostream" = xyes ; then
1841         AC_MSG_CHECKING(if iostream uses std-namespace)
1842         AC_TRY_COMPILE([
1843 #include <iostream>
1844 using std::endl;
1845 using std::cerr;],[
1846 cerr << "testing" << endl;
1847 ],[cf_iostream_namespace=yes],[cf_iostream_namespace=no])
1848         AC_MSG_RESULT($cf_iostream_namespace)
1849         if test "$cf_iostream_namespace" = yes ; then
1850                 AC_DEFINE(IOSTREAM_NAMESPACE,1,[Define to 1 if C++ has namespace iostream])
1851         fi
1852 fi
1853 ])dnl
1854 dnl ---------------------------------------------------------------------------
1855 dnl CF_C_INLINE version: 6 updated: 2019/09/07 13:38:36
1856 dnl -----------
1857 dnl Check if the C compiler supports "inline".
1858 dnl $1 is the name of a shell variable to set if inline is supported
1859 dnl $2 is the threshold for gcc 4.x's option controlling maximum inline size
1860 AC_DEFUN([CF_C_INLINE],[
1861 AC_REQUIRE([CF_GCC_VERSION])
1862 AC_C_INLINE
1863 $1=
1864 if test "$ac_cv_c_inline" != no ; then
1865         $1=inline
1866         if test "$INTEL_COMPILER" = yes
1867         then
1868                 :
1869         elif test "$CLANG_COMPILER" = yes
1870         then
1871                 :
1872         elif test "$GCC" = yes
1873         then
1874                 AC_CACHE_CHECK(if $CC supports options to tune inlining,cf_cv_gcc_inline,[
1875                 cf_save_CFLAGS=$CFLAGS
1876                 CFLAGS="$CFLAGS --param max-inline-insns-single=$2"
1877                 AC_TRY_COMPILE([inline int foo(void) { return 1; }],
1878                 [${cf_cv_main_return:-return} foo()],
1879                 [cf_cv_gcc_inline=yes],
1880                 [cf_cv_gcc_inline=no])
1881                 CFLAGS=$cf_save_CFLAGS
1882                 ])
1883                 if test "$cf_cv_gcc_inline" = yes ; then
1884                         CF_ADD_CFLAGS([--param max-inline-insns-single=$2])
1885                 fi
1886         fi
1887 fi
1888 AC_SUBST($1)
1889 ])dnl
1890 dnl ---------------------------------------------------------------------------
1891 dnl CF_DIRNAME version: 5 updated: 2020/12/31 20:19:42
1892 dnl ----------
1893 dnl "dirname" is not portable, so we fake it with a shell script.
1894 AC_DEFUN([CF_DIRNAME],[$1=`echo "$2" | sed -e 's%/[[^/]]*$%%'`])dnl
1895 dnl ---------------------------------------------------------------------------
1896 dnl CF_DIRS_TO_MAKE version: 4 updated: 2021/01/01 13:31:04
1897 dnl ---------------
1898 AC_DEFUN([CF_DIRS_TO_MAKE],
1899 [
1900 DIRS_TO_MAKE="lib"
1901 for cf_item in $cf_list_models
1902 do
1903         CF_OBJ_SUBDIR($cf_item,cf_subdir)
1904         for cf_item2 in $DIRS_TO_MAKE
1905         do
1906                 test "$cf_item2" = "$cf_subdir" && break
1907         done
1908         test ".$cf_item2" != ".$cf_subdir" && DIRS_TO_MAKE="$DIRS_TO_MAKE $cf_subdir"
1909 done
1910 for cf_dir in $DIRS_TO_MAKE
1911 do
1912         test ! -d "$cf_dir" && mkdir "$cf_dir"
1913 done
1914 AC_SUBST(DIRS_TO_MAKE)
1915 ])dnl
1916 dnl ---------------------------------------------------------------------------
1917 dnl CF_DISABLE_ECHO version: 14 updated: 2021/09/04 06:35:04
1918 dnl ---------------
1919 dnl You can always use "make -n" to see the actual options, but it is hard to
1920 dnl pick out/analyze warning messages when the compile-line is long.
1921 dnl
1922 dnl Sets:
1923 dnl     ECHO_LT - symbol to control if libtool is verbose
1924 dnl     ECHO_LD - symbol to prefix "cc -o" lines
1925 dnl     RULE_CC - symbol to put before implicit "cc -c" lines (e.g., .c.o)
1926 dnl     SHOW_CC - symbol to put before explicit "cc -c" lines
1927 dnl     ECHO_CC - symbol to put before any "cc" line
1928 dnl
1929 AC_DEFUN([CF_DISABLE_ECHO],[
1930 AC_MSG_CHECKING(if you want to see long compiling messages)
1931 CF_ARG_DISABLE(echo,
1932         [  --disable-echo          do not display "compiling" commands],
1933         [
1934         ECHO_LT='--silent'
1935         ECHO_LD='@echo linking [$]@;'
1936         RULE_CC='@echo compiling [$]<'
1937         SHOW_CC='@echo compiling [$]@'
1938         ECHO_CC='@'
1939 ],[
1940         ECHO_LT=''
1941         ECHO_LD=''
1942         RULE_CC=''
1943         SHOW_CC=''
1944         ECHO_CC=''
1945 ])
1946 AC_MSG_RESULT($enableval)
1947 AC_SUBST(ECHO_LT)
1948 AC_SUBST(ECHO_LD)
1949 AC_SUBST(RULE_CC)
1950 AC_SUBST(SHOW_CC)
1951 AC_SUBST(ECHO_CC)
1952 ])dnl
1953 dnl ---------------------------------------------------------------------------
1954 dnl CF_DISABLE_GNAT_PROJECTS version: 1 updated: 2014/06/01 11:34:00
1955 dnl ------------------------
1956 AC_DEFUN([CF_DISABLE_GNAT_PROJECTS],[
1957 AC_MSG_CHECKING(if we want to use GNAT projects)
1958 CF_ARG_DISABLE(gnat-projects,
1959         [  --disable-gnat-projects test: disable GNAT projects even if usable],
1960         [enable_gnat_projects=no],
1961         [enable_gnat_projects=yes])
1962 AC_MSG_RESULT($enable_gnat_projects)
1963 ])dnl
1964 dnl ---------------------------------------------------------------------------
1965 dnl CF_DISABLE_LEAKS version: 9 updated: 2021/04/03 16:41:50
1966 dnl ----------------
1967 dnl Combine no-leak checks with the libraries or tools that are used for the
1968 dnl checks.
1969 AC_DEFUN([CF_DISABLE_LEAKS],[
1970
1971 AC_REQUIRE([CF_WITH_DMALLOC])
1972 AC_REQUIRE([CF_WITH_DBMALLOC])
1973 AC_REQUIRE([CF_WITH_VALGRIND])
1974
1975 AC_MSG_CHECKING(if you want to perform memory-leak testing)
1976 AC_ARG_ENABLE(leaks,
1977         [  --disable-leaks         test: free permanent memory, analyze leaks],
1978         [enable_leaks=$enableval],
1979         [enable_leaks=yes])
1980 dnl with_no_leaks is more readable...
1981 if test "x$enable_leaks" = xno; then with_no_leaks=yes; else with_no_leaks=no; fi
1982 AC_MSG_RESULT($with_no_leaks)
1983
1984 if test "$enable_leaks" = no ; then
1985         AC_DEFINE(NO_LEAKS,1,[Define to 1 if you want to perform memory-leak testing.])
1986         AC_DEFINE(YY_NO_LEAKS,1,[Define to 1 if you want to perform memory-leak testing.])
1987 fi
1988 ])dnl
1989 dnl ---------------------------------------------------------------------------
1990 dnl CF_DISABLE_LIBTOOL_VERSION version: 3 updated: 2015/04/17 21:13:04
1991 dnl --------------------------
1992 dnl Check if we should use the libtool 1.5 feature "-version-number" instead of
1993 dnl the older "-version-info" feature.  The newer feature allows us to use
1994 dnl version numbering on shared libraries which make them compatible with
1995 dnl various systems.
1996 AC_DEFUN([CF_DISABLE_LIBTOOL_VERSION],
1997 [
1998 AC_MSG_CHECKING(if libtool -version-number should be used)
1999 CF_ARG_DISABLE(libtool-version,
2000         [  --disable-libtool-version  enable to use libtool's incompatible naming scheme],
2001         [cf_libtool_version=no],
2002         [cf_libtool_version=yes])
2003 AC_MSG_RESULT($cf_libtool_version)
2004
2005 if test "$cf_libtool_version" = yes ; then
2006         LIBTOOL_VERSION="-version-number"
2007 else
2008         LIBTOOL_VERSION="-version-info"
2009         case "x$VERSION" in
2010         (x)
2011                 AC_MSG_WARN(VERSION was not set)
2012                 ;;
2013         (x*.*.*)
2014                 ABI_VERSION="$VERSION"
2015                 CF_VERBOSE(ABI_VERSION: $ABI_VERSION)
2016                 ;;
2017         (x*:*:*)
2018                 ABI_VERSION=`echo "$VERSION" | sed -e 's/:/./g'`
2019                 CF_VERBOSE(ABI_VERSION: $ABI_VERSION)
2020                 ;;
2021         (*)
2022                 AC_MSG_WARN(unexpected VERSION value: $VERSION)
2023                 ;;
2024         esac
2025 fi
2026
2027 AC_SUBST(ABI_VERSION)
2028 AC_SUBST(LIBTOOL_VERSION)
2029 ])dnl
2030 dnl ---------------------------------------------------------------------------
2031 dnl CF_DISABLE_RPATH_HACK version: 3 updated: 2021/01/05 20:14:44
2032 dnl ---------------------
2033 dnl The rpath-hack makes it simpler to build programs, particularly with the
2034 dnl *BSD ports which may have essential libraries in unusual places.  But it
2035 dnl can interfere with building an executable for the base system.  Use this
2036 dnl option in that case.
2037 AC_DEFUN([CF_DISABLE_RPATH_HACK],
2038 [
2039 AC_MSG_CHECKING(if rpath-hack should be disabled)
2040 CF_ARG_DISABLE(rpath-hack,
2041         [  --disable-rpath-hack    don't add rpath options for additional libraries],
2042         [enable_rpath_hack=no],
2043         [enable_rpath_hack=yes])
2044 dnl TODO - drop cf_disable_rpath_hack
2045 if test "x$enable_rpath_hack" = xno; then cf_disable_rpath_hack=yes; else cf_disable_rpath_hack=no; fi
2046 AC_MSG_RESULT($cf_disable_rpath_hack)
2047
2048 if test "$enable_rpath_hack" = yes ; then
2049         CF_RPATH_HACK
2050 fi
2051 ])
2052 dnl ---------------------------------------------------------------------------
2053 dnl CF_ENABLE_BROKEN_LINKER version: 2 updated: 2021/01/02 17:09:14
2054 dnl -----------------------
2055 dnl Some linkers cannot reference a data-only object.  Cygwin used to be one.
2056 dnl This usually follows CF_LINK_DATAONLY, but is not required in case we need
2057 dnl an unconditional feature.
2058 AC_DEFUN([CF_ENABLE_BROKEN_LINKER],[
2059
2060 AC_MSG_CHECKING(if you want broken-linker support code)
2061 AC_ARG_ENABLE(broken_linker,
2062         [  --enable-broken_linker  compile with broken-linker support code],
2063         [with_broken_linker=$enableval],
2064         [with_broken_linker=no])
2065 AC_MSG_RESULT($with_broken_linker)
2066
2067 : "${BROKEN_LINKER:=0}"
2068 if test "x$with_broken_linker" = xyes ; then
2069         AC_DEFINE(BROKEN_LINKER,1,[Define to 1 to work around linkers which cannot link data-only modules])
2070         BROKEN_LINKER=1
2071 fi
2072 AC_SUBST(BROKEN_LINKER)
2073 ])dnl
2074 dnl ---------------------------------------------------------------------------
2075 dnl CF_ENABLE_PC_FILES version: 16 updated: 2021/11/20 12:48:37
2076 dnl ------------------
2077 dnl This is the "--enable-pc-files" option, which is available if there is a
2078 dnl pkg-config configuration on the local machine.
2079 AC_DEFUN([CF_ENABLE_PC_FILES],[
2080 AC_REQUIRE([CF_PKG_CONFIG])
2081 AC_REQUIRE([CF_WITH_PKG_CONFIG_LIBDIR])
2082
2083 if test "x$PKG_CONFIG" != xnone
2084 then
2085         AC_MSG_CHECKING(if we should install .pc files for $PKG_CONFIG)
2086 else
2087         AC_MSG_CHECKING(if we should install .pc files)
2088 fi
2089
2090 AC_ARG_ENABLE(pc-files,
2091         [  --enable-pc-files       generate and install .pc files for pkg-config],
2092         [enable_pc_files=$enableval],
2093         [enable_pc_files=no])
2094 AC_MSG_RESULT($enable_pc_files)
2095
2096 if test "x$enable_pc_files" != xno
2097 then
2098         MAKE_PC_FILES=
2099         case "x$PKG_CONFIG_LIBDIR" in
2100         (xno|xnone|xyes|x)
2101                 AC_MSG_WARN(no PKG_CONFIG_LIBDIR was found)
2102                 ;;
2103         (*)
2104                 cf_pkg_config_libdir="$PKG_CONFIG_LIBDIR"
2105                 CF_PATH_SYNTAX(cf_pkg_config_libdir)
2106                 ;;
2107         esac
2108 else
2109         MAKE_PC_FILES="#"
2110 fi
2111 AC_SUBST(MAKE_PC_FILES)
2112 ])dnl
2113 dnl ---------------------------------------------------------------------------
2114 dnl CF_ENABLE_RPATH version: 2 updated: 2010/03/27 18:39:42
2115 dnl ---------------
2116 dnl Check if the rpath option should be used, setting cache variable
2117 dnl cf_cv_enable_rpath if so.
2118 AC_DEFUN([CF_ENABLE_RPATH],
2119 [
2120 AC_MSG_CHECKING(if rpath option should be used)
2121 AC_ARG_ENABLE(rpath,
2122 [  --enable-rpath          use rpath option when generating shared libraries],
2123 [cf_cv_enable_rpath=$enableval],
2124 [cf_cv_enable_rpath=no])
2125 AC_MSG_RESULT($cf_cv_enable_rpath)
2126 ])dnl
2127 dnl ---------------------------------------------------------------------------
2128 dnl CF_ENABLE_STRING_HACKS version: 6 updated: 2021/01/05 19:23:48
2129 dnl ----------------------
2130 dnl On a few platforms, the compiler and/or loader nags with untruthful
2131 dnl comments stating that "most" uses of strcat/strcpy/sprintf are incorrect,
2132 dnl and implying that most uses of the recommended alternatives are correct.
2133 dnl
2134 dnl Factually speaking, no one has actually counted the number of uses of these
2135 dnl functions versus the total of incorrect uses.  Samples of a few thousand
2136 dnl instances are meaningless compared to the hundreds of millions of lines of
2137 dnl existing C code.
2138 dnl
2139 dnl strlcat/strlcpy are (as of 2012) non-standard, and are available on some
2140 dnl platforms, in implementations of varying quality.  Likewise, snprintf is
2141 dnl standard - but evolved through phases, and older implementations are likely
2142 dnl to yield surprising results, as documented in manpages on various systems.
2143 AC_DEFUN([CF_ENABLE_STRING_HACKS],
2144 [
2145 AC_MSG_CHECKING(if you want to work around bogus compiler/loader warnings)
2146 AC_ARG_ENABLE(string-hacks,
2147         [  --enable-string-hacks   work around bogus compiler/loader warnings],
2148         [enable_string_hacks=$enableval],
2149         [enable_string_hacks=no])
2150 AC_MSG_RESULT($enable_string_hacks)
2151
2152 if test "x$enable_string_hacks" = "xyes"; then
2153         AC_DEFINE(USE_STRING_HACKS,1,[Define to 1 to work around bogus compiler/loader warnings])
2154         AC_MSG_WARN(enabling string-hacks to work around bogus compiler/loader warnings)
2155         AC_CHECK_FUNC(strlcat,[
2156                 AC_DEFINE(HAVE_STRLCAT,1,[Define to 1 if we have strlcat function])
2157                 ],[
2158                 AC_CHECK_LIB(bsd,strlcat,[
2159                         CF_ADD_LIB(bsd)
2160                         AC_CHECK_HEADERS(bsd/string.h)
2161                         AC_DEFINE(HAVE_STRLCAT,1,[Define to 1 if we have strlcat function])
2162                         ])
2163                 ])
2164         AC_CHECK_FUNCS( strlcpy snprintf )
2165 fi
2166 ])dnl
2167 dnl ---------------------------------------------------------------------------
2168 dnl CF_ENABLE_WARNINGS version: 9 updated: 2021/01/05 19:40:50
2169 dnl ------------------
2170 dnl Configure-option to enable gcc warnings
2171 dnl
2172 dnl $1 = extra options to add, if supported
2173 dnl $2 = option for checking attributes.  By default, this is done when
2174 dnl      warnings are enabled.  For other values:
2175 dnl      yes: always do this, e.g., to use in generated library-headers
2176 dnl      no: never do this
2177 AC_DEFUN([CF_ENABLE_WARNINGS],[
2178 if test "$GCC" = yes || test "$GXX" = yes
2179 then
2180 CF_FIX_WARNINGS(CFLAGS)
2181 CF_FIX_WARNINGS(CPPFLAGS)
2182 CF_FIX_WARNINGS(LDFLAGS)
2183 AC_MSG_CHECKING(if you want to turn on gcc warnings)
2184 CF_ARG_ENABLE(warnings,
2185         [  --enable-warnings       test: turn on gcc compiler warnings],
2186         [enable_warnings=yes],
2187         [enable_warnings=no])
2188 AC_MSG_RESULT($enable_warnings)
2189 if test "$enable_warnings" = "yes"
2190 then
2191         ifelse($2,,[CF_GCC_ATTRIBUTES])
2192         CF_GCC_WARNINGS($1)
2193 fi
2194 ifelse($2,yes,[CF_GCC_ATTRIBUTES])
2195 fi
2196 ])dnl
2197 dnl ---------------------------------------------------------------------------
2198 dnl CF_ERRNO version: 5 updated: 1997/11/30 12:44:39
2199 dnl --------
2200 dnl Check if 'errno' is declared in <errno.h>
2201 AC_DEFUN([CF_ERRNO],
2202 [
2203 CF_CHECK_ERRNO(errno)
2204 ])dnl
2205 dnl ---------------------------------------------------------------------------
2206 dnl CF_ETIP_DEFINES version: 6 updated: 2021/01/02 17:09:14
2207 dnl ---------------
2208 dnl Test for conflicting definitions of exception in gcc 2.8.0, etc., between
2209 dnl math.h and builtin.h, only for ncurses
2210 AC_DEFUN([CF_ETIP_DEFINES],
2211 [
2212 AC_MSG_CHECKING(for special defines needed for etip.h)
2213 cf_save_CXXFLAGS="$CXXFLAGS"
2214 cf_result="none"
2215
2216 # etip.h includes ncurses.h which includes ncurses_dll.h
2217 # But ncurses_dll.h is generated - fix here.
2218 test -d include || mkdir include
2219 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
2220
2221 for cf_math in "" MATH_H
2222 do
2223 for cf_excp in "" MATH_EXCEPTION
2224 do
2225         CXXFLAGS="$cf_save_CXXFLAGS -I${srcdir}/c++ -I${srcdir}/menu -Iinclude -I${srcdir}/include"
2226         test -n "$cf_math" && CXXFLAGS="$CXXFLAGS -DETIP_NEEDS_${cf_math}"
2227         test -n "$cf_excp" && CXXFLAGS="$CXXFLAGS -DETIP_NEEDS_${cf_excp}"
2228 AC_TRY_COMPILE([
2229 #include <etip.h.in>
2230 ],[],[
2231         test -n "$cf_math" && AC_DEFINE_UNQUOTED(ETIP_NEEDS_${cf_math})
2232         test -n "$cf_excp" && AC_DEFINE_UNQUOTED(ETIP_NEEDS_${cf_excp})
2233         cf_result="$cf_math $cf_excp"
2234         break 2
2235 ],[])
2236 done
2237 done
2238 AC_MSG_RESULT($cf_result)
2239 CXXFLAGS="$cf_save_CXXFLAGS"
2240 ])
2241 dnl ---------------------------------------------------------------------------
2242 dnl CF_FIND_LINKAGE version: 22 updated: 2020/12/31 20:19:42
2243 dnl ---------------
2244 dnl Find a library (specifically the linkage used in the code fragment),
2245 dnl searching for it if it is not already in the library path.
2246 dnl See also CF_ADD_SEARCHPATH.
2247 dnl
2248 dnl Parameters (4-on are optional):
2249 dnl     $1 = headers for library entrypoint
2250 dnl     $2 = code fragment for library entrypoint
2251 dnl     $3 = the library name without the "-l" option or ".so" suffix.
2252 dnl     $4 = action to perform if successful (default: update CPPFLAGS, etc)
2253 dnl     $5 = action to perform if not successful
2254 dnl     $6 = module name, if not the same as the library name
2255 dnl     $7 = extra libraries
2256 dnl
2257 dnl Sets these variables:
2258 dnl     $cf_cv_find_linkage_$3 - yes/no according to whether linkage is found
2259 dnl     $cf_cv_header_path_$3 - include-directory if needed
2260 dnl     $cf_cv_library_path_$3 - library-directory if needed
2261 dnl     $cf_cv_library_file_$3 - library-file if needed, e.g., -l$3
2262 AC_DEFUN([CF_FIND_LINKAGE],[
2263
2264 # If the linkage is not already in the $CPPFLAGS/$LDFLAGS configuration, these
2265 # will be set on completion of the AC_TRY_LINK below.
2266 cf_cv_header_path_$3=
2267 cf_cv_library_path_$3=
2268
2269 CF_MSG_LOG([Starting [FIND_LINKAGE]($3,$6)])
2270
2271 cf_save_LIBS="$LIBS"
2272
2273 AC_TRY_LINK([$1],[$2],[
2274         cf_cv_find_linkage_$3=yes
2275         cf_cv_header_path_$3=/usr/include
2276         cf_cv_library_path_$3=/usr/lib
2277 ],[
2278
2279 LIBS="-l$3 $7 $cf_save_LIBS"
2280
2281 AC_TRY_LINK([$1],[$2],[
2282         cf_cv_find_linkage_$3=yes
2283         cf_cv_header_path_$3=/usr/include
2284         cf_cv_library_path_$3=/usr/lib
2285         cf_cv_library_file_$3="-l$3"
2286 ],[
2287         cf_cv_find_linkage_$3=no
2288         LIBS="$cf_save_LIBS"
2289
2290         CF_VERBOSE(find linkage for $3 library)
2291         CF_MSG_LOG([Searching for headers in [FIND_LINKAGE]($3,$6)])
2292
2293         cf_save_CPPFLAGS="$CPPFLAGS"
2294         cf_test_CPPFLAGS="$CPPFLAGS"
2295
2296         CF_HEADER_PATH(cf_search,ifelse([$6],,[$3],[$6]))
2297         for cf_cv_header_path_$3 in $cf_search
2298         do
2299                 if test -d "$cf_cv_header_path_$3" ; then
2300                         CF_VERBOSE(... testing $cf_cv_header_path_$3)
2301                         CPPFLAGS="$cf_save_CPPFLAGS"
2302                         CF_APPEND_TEXT(CPPFLAGS,-I$cf_cv_header_path_$3)
2303                         AC_TRY_COMPILE([$1],[$2],[
2304                                 CF_VERBOSE(... found $3 headers in $cf_cv_header_path_$3)
2305                                 cf_cv_find_linkage_$3=maybe
2306                                 cf_test_CPPFLAGS="$CPPFLAGS"
2307                                 break],[
2308                                 CPPFLAGS="$cf_save_CPPFLAGS"
2309                                 ])
2310                 fi
2311         done
2312
2313         if test "$cf_cv_find_linkage_$3" = maybe ; then
2314
2315                 CF_MSG_LOG([Searching for $3 library in [FIND_LINKAGE]($3,$6)])
2316
2317                 cf_save_LIBS="$LIBS"
2318                 cf_save_LDFLAGS="$LDFLAGS"
2319
2320                 ifelse([$6],,,[
2321                 CPPFLAGS="$cf_test_CPPFLAGS"
2322                 LIBS="-l$3 $7 $cf_save_LIBS"
2323                 AC_TRY_LINK([$1],[$2],[
2324                         CF_VERBOSE(... found $3 library in system)
2325                         cf_cv_find_linkage_$3=yes])
2326                         CPPFLAGS="$cf_save_CPPFLAGS"
2327                         LIBS="$cf_save_LIBS"
2328                         ])
2329
2330                 if test "$cf_cv_find_linkage_$3" != yes ; then
2331                         CF_LIBRARY_PATH(cf_search,$3)
2332                         for cf_cv_library_path_$3 in $cf_search
2333                         do
2334                                 if test -d "$cf_cv_library_path_$3" ; then
2335                                         CF_VERBOSE(... testing $cf_cv_library_path_$3)
2336                                         CPPFLAGS="$cf_test_CPPFLAGS"
2337                                         LIBS="-l$3 $7 $cf_save_LIBS"
2338                                         LDFLAGS="$cf_save_LDFLAGS -L$cf_cv_library_path_$3"
2339                                         AC_TRY_LINK([$1],[$2],[
2340                                         CF_VERBOSE(... found $3 library in $cf_cv_library_path_$3)
2341                                         cf_cv_find_linkage_$3=yes
2342                                         cf_cv_library_file_$3="-l$3"
2343                                         break],[
2344                                         CPPFLAGS="$cf_save_CPPFLAGS"
2345                                         LIBS="$cf_save_LIBS"
2346                                         LDFLAGS="$cf_save_LDFLAGS"
2347                                         ])
2348                                 fi
2349                         done
2350                         CPPFLAGS="$cf_save_CPPFLAGS"
2351                         LDFLAGS="$cf_save_LDFLAGS"
2352                 fi
2353
2354         else
2355                 cf_cv_find_linkage_$3=no
2356         fi
2357         ],$7)
2358 ])
2359
2360 LIBS="$cf_save_LIBS"
2361
2362 if test "$cf_cv_find_linkage_$3" = yes ; then
2363 ifelse([$4],,[
2364         CF_ADD_INCDIR($cf_cv_header_path_$3)
2365         CF_ADD_LIBDIR($cf_cv_library_path_$3)
2366         CF_ADD_LIB($3)
2367 ],[$4])
2368 else
2369 ifelse([$5],,AC_MSG_WARN(Cannot find $3 library),[$5])
2370 fi
2371 ])dnl
2372 dnl ---------------------------------------------------------------------------
2373 dnl CF_FIND_SUB_INCDIR version: 3 updated: 2021/01/01 13:31:04
2374 dnl ------------------
2375 dnl Find an include-directory with the given leaf-name.  This is useful for
2376 dnl example with FreeBSD ports, which use this convention to distinguish
2377 dnl different versions of the same port.
2378 AC_DEFUN([CF_FIND_SUB_INCDIR],[
2379         CF_SUBDIR_PATH(cf_search,$1,include)
2380         for cf_item in $cf_search
2381         do
2382                 case "$cf_item" in
2383                 (*/$1)
2384                         CF_ADD_INCDIR($cf_item)
2385                         ;;
2386                 esac
2387         done
2388 ])dnl
2389 dnl ---------------------------------------------------------------------------
2390 dnl CF_FIND_SUB_LIBDIR version: 3 updated: 2021/01/01 13:31:04
2391 dnl ------------------
2392 dnl Find a library-directory with the given leaf-name.  This is useful for
2393 dnl example with FreeBSD ports, which use this convention to distinguish
2394 dnl different versions of the same port.
2395 AC_DEFUN([CF_FIND_SUB_LIBDIR],[
2396         CF_SUBDIR_PATH(cf_search,$1,lib)
2397         for cf_item in $cf_search
2398         do
2399                 case "$cf_item" in
2400                 (*/$1)
2401                         CF_ADD_LIBDIR($cf_item)
2402                         ;;
2403                 esac
2404         done
2405 ])dnl
2406 dnl ---------------------------------------------------------------------------
2407 dnl CF_FIXUP_ADAFLAGS version: 2 updated: 2015/04/17 21:13:04
2408 dnl -----------------
2409 dnl make ADAFLAGS consistent with CFLAGS
2410 AC_DEFUN([CF_FIXUP_ADAFLAGS],[
2411         AC_MSG_CHECKING(optimization options for ADAFLAGS)
2412         case "$CFLAGS" in
2413         (*-g*)
2414                 CF_ADD_ADAFLAGS(-g)
2415                 ;;
2416         esac
2417         case "$CFLAGS" in
2418         (*-O*)
2419                 cf_O_flag=`echo "$CFLAGS" |sed -e 's/^.*-O/-O/' -e 's/[[        ]].*//'`
2420                 CF_ADD_ADAFLAGS($cf_O_flag)
2421                 ;;
2422         esac
2423         AC_MSG_RESULT($ADAFLAGS)
2424 ])dnl
2425 dnl ---------------------------------------------------------------------------
2426 dnl CF_FIX_WARNINGS version: 3 updated: 2020/12/31 18:40:20
2427 dnl ---------------
2428 dnl Warning flags do not belong in CFLAGS, CPPFLAGS, etc.  Any of gcc's
2429 dnl "-Werror" flags can interfere with configure-checks.  Those go into
2430 dnl EXTRA_CFLAGS.
2431 dnl
2432 dnl $1 = variable name to repair
2433 define([CF_FIX_WARNINGS],[
2434 if test "$GCC" = yes || test "$GXX" = yes
2435 then
2436         case [$]$1 in
2437         (*-Werror=*)
2438                 CF_VERBOSE(repairing $1: [$]$1)
2439                 cf_temp_flags=
2440                 for cf_temp_scan in [$]$1
2441                 do
2442                         case "x$cf_temp_scan" in
2443                         (x-Werror=*)
2444                                 CF_APPEND_TEXT(EXTRA_CFLAGS,$cf_temp_scan)
2445                                 ;;
2446                         (*)
2447                                 CF_APPEND_TEXT(cf_temp_flags,$cf_temp_scan)
2448                                 ;;
2449                         esac
2450                 done
2451                 $1="$cf_temp_flags"
2452                 CF_VERBOSE(... fixed [$]$1)
2453                 CF_VERBOSE(... extra $EXTRA_CFLAGS)
2454                 ;;
2455         esac
2456 fi
2457 AC_SUBST(EXTRA_CFLAGS)
2458 ])dnl
2459 dnl ---------------------------------------------------------------------------
2460 dnl CF_FOPEN_BIN_R version: 2 updated: 2019/12/31 08:53:54
2461 dnl --------------
2462 dnl Check if fopen works when the "b" (binary) flag is added to the mode
2463 dnl parameter.  POSIX ignores the "b", which c89 specified.  Some very old
2464 dnl systems do not accept it.
2465 AC_DEFUN([CF_FOPEN_BIN_R],[
2466 AC_CACHE_CHECK(if fopen accepts explicit binary mode,cf_cv_fopen_bin_r,[
2467         AC_TRY_RUN([
2468 #include <stdio.h>
2469 int main(void) {
2470         FILE *fp = fopen("conftest.tmp", "wb");
2471         int rc = 0;
2472         if (fp != 0) {
2473                 int p, q;
2474                 for (p = 0; p < 256; ++p) {
2475                         fputc(p, fp);
2476                 }
2477                 fclose(fp);
2478                 fp = fopen("conftest.tmp", "rb");
2479                 if (fp != 0) {
2480                         for (p = 0; p < 256; ++p) {
2481                                 q = fgetc(fp);
2482                                 if (q != p) {
2483                                         rc = 1;
2484                                         break;
2485                                 }
2486                         }
2487                 } else {
2488                         rc = 1;
2489                 }
2490         } else {
2491                 rc = 1;
2492         }
2493         ${cf_cv_main_return:-return} (rc);
2494 }
2495 ],
2496                 [cf_cv_fopen_bin_r=yes],
2497                 [cf_cv_fopen_bin_r=no],
2498                 [cf_cv_fopen_bin_r=unknown])
2499 ])
2500 test "x$cf_cv_fopen_bin_r" != xno && AC_DEFINE(USE_FOPEN_BIN_R,1,[Define to 1 if fopen accepts explicit binary mode])
2501 ])dnl
2502 dnl ---------------------------------------------------------------------------
2503 dnl CF_FORGET_TOOL version: 1 updated: 2013/04/06 18:03:09
2504 dnl --------------
2505 dnl Forget that we saw the given tool.
2506 AC_DEFUN([CF_FORGET_TOOL],[
2507 unset ac_cv_prog_ac_ct_$1
2508 unset ac_ct_$1
2509 unset $1
2510 ])dnl
2511 dnl ---------------------------------------------------------------------------
2512 dnl CF_FUNC_DLSYM version: 4 updated: 2015/09/12 14:46:44
2513 dnl -------------
2514 dnl Test for dlsym() and related functions, as well as libdl.
2515 dnl
2516 dnl Sets
2517 dnl     $cf_have_dlsym
2518 dnl     $cf_have_libdl
2519 AC_DEFUN([CF_FUNC_DLSYM],[
2520 cf_have_dlsym=no
2521 AC_CHECK_FUNC(dlsym,cf_have_dlsym=yes,[
2522
2523 cf_have_libdl=no
2524 AC_CHECK_LIB(dl,dlsym,[
2525         cf_have_dlsym=yes
2526         cf_have_libdl=yes])])
2527
2528 if test "$cf_have_dlsym" = yes ; then
2529         test "$cf_have_libdl" = yes && { CF_ADD_LIB(dl) }
2530
2531         AC_MSG_CHECKING(whether able to link to dl*() functions)
2532         AC_TRY_LINK([#include <dlfcn.h>],[
2533                 void *obj;
2534                 if ((obj = dlopen("filename", 0)) != 0) {
2535                         if (dlsym(obj, "symbolname") == 0) {
2536                         dlclose(obj);
2537                         }
2538                 }],[
2539                 AC_DEFINE(HAVE_LIBDL,1,[Define to 1 if we have dl library])],[
2540                 AC_MSG_ERROR(Cannot link test program for libdl)])
2541         AC_MSG_RESULT(ok)
2542 else
2543         AC_MSG_ERROR(Cannot find dlsym function)
2544 fi
2545 ])
2546 dnl ---------------------------------------------------------------------------
2547 dnl CF_FUNC_GETTTYNAM version: 1 updated: 2021/12/04 18:29:47
2548 dnl -----------------
2549 dnl Check if the 4.3BSD function getttyname exists, as well as if <ttyent.h>
2550 dnl defines the _PATH_TTYS symbol.  If the corresponding file exists, but the
2551 dnl other checks fail, just define HAVE_PATH_TTYS.
2552 AC_DEFUN([CF_FUNC_GETTTYNAM],[
2553 AC_CACHE_CHECK(if _PATH_TTYS is defined in ttyent.h,cf_cv_PATH_TTYS,[
2554 AC_TRY_COMPILE([
2555 #include <stdio.h>
2556 #include <ttyent.h>],[
2557 FILE *fp = fopen(_PATH_TTYS, "r"); (void)fp],
2558         [cf_cv_PATH_TTYS=yes],
2559         [cf_cv_PATH_TTYS=no])])
2560
2561 if test $cf_cv_PATH_TTYS = no
2562 then
2563         for cf_ttys in /etc/ttytype /etc/ttys
2564         do
2565                 if test -f $cf_ttys
2566                 then
2567                         cf_cv_PATH_TTYS=maybe
2568                         AC_DEFINE(_PATH_TTYS,$cf_ttys,[define to pathname of file containing mapping from tty name to terminal type])
2569                         break
2570                 fi
2571         done
2572 fi
2573
2574 if test $cf_cv_PATH_TTYS != no
2575 then
2576         AC_CACHE_CHECK(if _PATH_TTYS file exists,cf_cv_have_PATH_TTYS,[
2577                 AC_TRY_RUN([
2578 #include <stdio.h>
2579 #include <ttyent.h>
2580 int main(void) {
2581         FILE *fp = fopen(_PATH_TTYS, "r");
2582         ${cf_cv_main_return:-return} (fp == 0);
2583 }],
2584                         [cf_cv_have_PATH_TTYS=yes],
2585                         [cf_cv_have_PATH_TTYS=no],
2586                         [cf_cv_have_PATH_TTYS=unknown])])
2587         test "$cf_cv_have_PATH_TTYS" = no && cf_cv_PATH_TTYS=no
2588 fi
2589
2590 if test $cf_cv_PATH_TTYS != no
2591 then
2592         AC_DEFINE(HAVE_PATH_TTYS,1,[define to 1 if system can map tty name to terminal type])
2593         AC_CACHE_CHECK(for getttynam,cf_cv_func_getttynam,[
2594                 AC_TRY_LINK([#include <ttyent.h>],
2595                 [struct ttyent *fp = getttynam("/dev/tty"); (void)fp],
2596                 [cf_cv_func_getttynam=yes],
2597                 [cf_cv_func_getttynam=no])])
2598         test "$cf_cv_func_getttynam" = yes && AC_DEFINE(HAVE_GETTTYNAM)
2599 fi
2600 ])dnl
2601 dnl ---------------------------------------------------------------------------
2602 dnl CF_FUNC_MEMMOVE version: 9 updated: 2017/01/21 11:06:25
2603 dnl ---------------
2604 dnl Check for memmove, or a bcopy that can handle overlapping copy.  If neither
2605 dnl is found, add our own version of memmove to the list of objects.
2606 AC_DEFUN([CF_FUNC_MEMMOVE],
2607 [
2608 AC_CHECK_FUNC(memmove,,[
2609 AC_CHECK_FUNC(bcopy,[
2610         AC_CACHE_CHECK(if bcopy does overlapping moves,cf_cv_good_bcopy,[
2611                 AC_TRY_RUN([
2612 int main(void) {
2613         static char data[] = "abcdefghijklmnopqrstuwwxyz";
2614         char temp[40];
2615         bcopy(data, temp, sizeof(data));
2616         bcopy(temp+10, temp, 15);
2617         bcopy(temp+5, temp+15, 10);
2618         ${cf_cv_main_return:-return} (strcmp(temp, "klmnopqrstuwwxypqrstuwwxyz"));
2619 }
2620                 ],
2621                 [cf_cv_good_bcopy=yes],
2622                 [cf_cv_good_bcopy=no],
2623                 [cf_cv_good_bcopy=unknown])
2624                 ])
2625         ],[cf_cv_good_bcopy=no])
2626         if test "$cf_cv_good_bcopy" = yes ; then
2627                 AC_DEFINE(USE_OK_BCOPY,1,[Define to 1 to use bcopy when memmove is unavailable])
2628         else
2629                 AC_DEFINE(USE_MY_MEMMOVE,1,[Define to 1 to use replacement function when memmove is unavailable])
2630         fi
2631 ])])dnl
2632 dnl ---------------------------------------------------------------------------
2633 dnl CF_FUNC_NANOSLEEP version: 5 updated: 2017/01/21 11:06:25
2634 dnl -----------------
2635 dnl Check for existence of workable nanosleep() function.  Some systems, e.g.,
2636 dnl AIX 4.x, provide a non-working version.
2637 AC_DEFUN([CF_FUNC_NANOSLEEP],[
2638 AC_CACHE_CHECK(if nanosleep really works,cf_cv_func_nanosleep,[
2639 AC_TRY_RUN([
2640 #include <stdio.h>
2641 #include <errno.h>
2642 #include <time.h>
2643
2644 #ifdef HAVE_SYS_TIME_H
2645 #include <sys/time.h>
2646 #endif
2647
2648 int main(void) {
2649         struct timespec ts1, ts2;
2650         int code;
2651         ts1.tv_sec  = 0;
2652         ts1.tv_nsec = 750000000;
2653         ts2.tv_sec  = 0;
2654         ts2.tv_nsec = 0;
2655         errno = 0;
2656         code = nanosleep(&ts1, &ts2); /* on failure errno is ENOSYS. */
2657         ${cf_cv_main_return:-return}(code != 0);
2658 }
2659 ],
2660         [cf_cv_func_nanosleep=yes],
2661         [cf_cv_func_nanosleep=no],
2662         [cf_cv_func_nanosleep=unknown])])
2663
2664 test "$cf_cv_func_nanosleep" = "yes" && AC_DEFINE(HAVE_NANOSLEEP,1,[Define to 1 if we have nanosleep()])
2665 ])
2666 dnl ---------------------------------------------------------------------------
2667 dnl CF_FUNC_OPENPTY version: 6 updated: 2021/01/01 13:31:04
2668 dnl ---------------
2669 dnl Check for openpty() function, along with <pty.h> header.  It may need the
2670 dnl "util" library as well.
2671 AC_DEFUN([CF_FUNC_OPENPTY],
2672 [
2673 AC_CHECK_LIB(util,openpty,cf_cv_lib_util=yes,cf_cv_lib_util=no)
2674 AC_CACHE_CHECK(for openpty header,cf_cv_func_openpty,[
2675         cf_save_LIBS="$LIBS"
2676         test "$cf_cv_lib_util" = yes && { CF_ADD_LIB(util) }
2677         for cf_header in pty.h libutil.h util.h
2678         do
2679         AC_TRY_LINK([
2680 #include <$cf_header>
2681 ],[
2682         int x = openpty((int *)0, (int *)0, (char *)0,
2683                                    (struct termios *)0, (struct winsize *)0);
2684 ],[
2685                 cf_cv_func_openpty=$cf_header
2686                 break
2687 ],[
2688                 cf_cv_func_openpty=no
2689 ])
2690         done
2691         LIBS="$cf_save_LIBS"
2692 ])
2693 ])dnl
2694 dnl ---------------------------------------------------------------------------
2695 dnl CF_FUNC_POLL version: 10 updated: 2021/01/04 19:13:57
2696 dnl ------------
2697 dnl See if the poll function really works.  Some platforms have poll(), but
2698 dnl it does not work for terminals or files.
2699 AC_DEFUN([CF_FUNC_POLL],[
2700 tty >/dev/null 2>&1 || { AC_CHECK_FUNCS(posix_openpt) }
2701 AC_CACHE_CHECK(if poll really works,cf_cv_working_poll,[
2702 AC_TRY_RUN([
2703 #include <stdlib.h>
2704 #include <stdio.h>
2705 #include <unistd.h>
2706 #include <fcntl.h>
2707 #ifdef HAVE_POLL_H
2708 #include <poll.h>
2709 #else
2710 #include <sys/poll.h>
2711 #endif
2712 int main(void) {
2713         struct pollfd myfds;
2714         int ret;
2715
2716         /* check for Darwin bug with respect to "devices" */
2717         myfds.fd = open("/dev/null", 1);        /* O_WRONLY */
2718         if (myfds.fd < 0)
2719                 myfds.fd = 0;
2720         myfds.events = POLLIN;
2721         myfds.revents = 0;
2722
2723         ret = poll(&myfds, 1, 100);
2724
2725         if (ret < 0 || (myfds.revents & POLLNVAL)) {
2726                 ret = -1;
2727         } else {
2728                 int fd = 0;
2729                 if (!isatty(fd)) {
2730                         fd = open("/dev/tty", 2);       /* O_RDWR */
2731                 }
2732 #ifdef HAVE_POSIX_OPENPT
2733                 if (fd < 0) {
2734                         fd = posix_openpt(O_RDWR);
2735                 }
2736 #endif
2737
2738                 if (fd >= 0) {
2739                         /* also check with standard input */
2740                         myfds.fd = fd;
2741                         myfds.events = POLLIN;
2742                         myfds.revents = 0;
2743                         ret = poll(&myfds, 1, 100);
2744                 } else {
2745                         ret = -1;
2746                 }
2747         }
2748         ${cf_cv_main_return:-return}(ret < 0);
2749 }],
2750         [cf_cv_working_poll=yes],
2751         [cf_cv_working_poll=no],
2752         [cf_cv_working_poll=unknown])])
2753 test "$cf_cv_working_poll" = "yes" && AC_DEFINE(HAVE_WORKING_POLL,1,[Define to 1 if the poll function seems to work])
2754 ])dnl
2755 dnl ---------------------------------------------------------------------------
2756 dnl CF_FUNC_TERMIOS version: 3 updated: 2012/10/06 17:56:13
2757 dnl ---------------
2758 dnl Some old/broken variations define tcgetattr() only as a macro in
2759 dnl termio(s).h
2760 AC_DEFUN([CF_FUNC_TERMIOS],[
2761 AC_REQUIRE([CF_STRUCT_TERMIOS])
2762 AC_CACHE_CHECK(for tcgetattr, cf_cv_have_tcgetattr,[
2763 AC_TRY_LINK([
2764 #include <sys/types.h>
2765 #ifdef HAVE_UNISTD_H
2766 #include <unistd.h>
2767 #endif
2768 #ifdef HAVE_TERMIOS_H
2769 #include <termios.h>
2770 #define TTY struct termios
2771 #else
2772 #ifdef HAVE_TERMIO_H
2773 #include <termio.h>
2774 #define TTY struct termio
2775 #endif
2776 #endif
2777 ],[
2778 TTY foo;
2779 tcgetattr(1, &foo);],
2780 [cf_cv_have_tcgetattr=yes],
2781 [cf_cv_have_tcgetattr=no])])
2782 test "$cf_cv_have_tcgetattr" = yes && AC_DEFINE(HAVE_TCGETATTR,1,[Define to 1 if we have tcgetattr])
2783 ])dnl
2784 dnl ---------------------------------------------------------------------------
2785 dnl CF_FUNC_VSSCANF version: 7 updated: 2021/01/01 13:31:04
2786 dnl ---------------
2787 dnl Check for vsscanf() function, which is in c9x but generally not in earlier
2788 dnl versions of C.  It is in the GNU C library, and can often be simulated by
2789 dnl other functions.
2790 AC_DEFUN([CF_FUNC_VSSCANF],
2791 [
2792 AC_CACHE_CHECK(for vsscanf function or workaround,cf_cv_func_vsscanf,[
2793 AC_TRY_LINK([
2794 #include <stdarg.h>
2795 #include <stdio.h>],[
2796         va_list ap;
2797         vsscanf("from", "%d", ap)],[cf_cv_func_vsscanf=vsscanf],[
2798 AC_TRY_LINK([
2799 #include <stdarg.h>
2800 #include <stdio.h>],[
2801         FILE strbuf;
2802         char *str = "from";
2803
2804         strbuf._flag = _IOREAD;
2805         strbuf._ptr = strbuf._base = (unsigned char *) str;
2806         strbuf._cnt = strlen(str);
2807         strbuf._file = _NFILE;
2808         return (vfscanf(&strbuf, "%d", ap))],[cf_cv_func_vsscanf=vfscanf],[
2809 AC_TRY_LINK([
2810 #include <stdarg.h>
2811 #include <stdio.h>],[
2812         FILE strbuf;
2813         char *str = "from";
2814
2815         strbuf._flag = _IOREAD;
2816         strbuf._ptr = strbuf._base = (unsigned char *) str;
2817         strbuf._cnt = strlen(str);
2818         strbuf._file = _NFILE;
2819         return (_doscan(&strbuf, "%d", ap))],[cf_cv_func_vsscanf=_doscan],[
2820 cf_cv_func_vsscanf=no])])])])
2821
2822 case "$cf_cv_func_vsscanf" in
2823 (vsscanf) AC_DEFINE(HAVE_VSSCANF,1,[Define to 1 if we have vsscanf]);;
2824 (vfscanf) AC_DEFINE(HAVE_VFSCANF,1,[Define to 1 if we have vfscanf]);;
2825 (_doscan) AC_DEFINE(HAVE__DOSCAN,1,[Define to 1 if we have _doscan]);;
2826 esac
2827
2828 ])dnl
2829 dnl ---------------------------------------------------------------------------
2830 dnl CF_GCC_ATTRIBUTES version: 24 updated: 2021/03/20 12:00:25
2831 dnl -----------------
2832 dnl Test for availability of useful gcc __attribute__ directives to quiet
2833 dnl compiler warnings.  Though useful, not all are supported -- and contrary
2834 dnl to documentation, unrecognized directives cause older compilers to barf.
2835 AC_DEFUN([CF_GCC_ATTRIBUTES],
2836 [AC_REQUIRE([AC_PROG_FGREP])dnl
2837 AC_REQUIRE([CF_C11_NORETURN])dnl
2838
2839 if test "$GCC" = yes || test "$GXX" = yes
2840 then
2841 cat > conftest.i <<EOF
2842 #ifndef GCC_PRINTF
2843 #define GCC_PRINTF 0
2844 #endif
2845 #ifndef GCC_SCANF
2846 #define GCC_SCANF 0
2847 #endif
2848 #ifndef GCC_NORETURN
2849 #define GCC_NORETURN /* nothing */
2850 #endif
2851 #ifndef GCC_UNUSED
2852 #define GCC_UNUSED /* nothing */
2853 #endif
2854 EOF
2855 if test "$GCC" = yes
2856 then
2857         AC_CHECKING([for $CC __attribute__ directives])
2858 cat > "conftest.$ac_ext" <<EOF
2859 #line __oline__ "${as_me:-configure}"
2860 #include "confdefs.h"
2861 #include "conftest.h"
2862 #include "conftest.i"
2863 #if     GCC_PRINTF
2864 #define GCC_PRINTFLIKE(fmt,var) __attribute__((format(printf,fmt,var)))
2865 #else
2866 #define GCC_PRINTFLIKE(fmt,var) /*nothing*/
2867 #endif
2868 #if     GCC_SCANF
2869 #define GCC_SCANFLIKE(fmt,var)  __attribute__((format(scanf,fmt,var)))
2870 #else
2871 #define GCC_SCANFLIKE(fmt,var)  /*nothing*/
2872 #endif
2873 extern void wow(char *,...) GCC_SCANFLIKE(1,2);
2874 extern GCC_NORETURN void oops(char *,...) GCC_PRINTFLIKE(1,2);
2875 extern GCC_NORETURN void foo(void);
2876 int main(int argc GCC_UNUSED, char *argv[[]] GCC_UNUSED) { (void)argc; (void)argv; return 0; }
2877 EOF
2878         cf_printf_attribute=no
2879         cf_scanf_attribute=no
2880         for cf_attribute in scanf printf unused noreturn
2881         do
2882                 CF_UPPER(cf_ATTRIBUTE,$cf_attribute)
2883                 cf_directive="__attribute__(($cf_attribute))"
2884                 echo "checking for $CC $cf_directive" 1>&AC_FD_CC
2885
2886                 case "$cf_attribute" in
2887                 (printf)
2888                         cf_printf_attribute=yes
2889                         cat >conftest.h <<EOF
2890 #define GCC_$cf_ATTRIBUTE 1
2891 EOF
2892                         ;;
2893                 (scanf)
2894                         cf_scanf_attribute=yes
2895                         cat >conftest.h <<EOF
2896 #define GCC_$cf_ATTRIBUTE 1
2897 EOF
2898                         ;;
2899                 (*)
2900                         cat >conftest.h <<EOF
2901 #define GCC_$cf_ATTRIBUTE $cf_directive
2902 EOF
2903                         ;;
2904                 esac
2905
2906                 if AC_TRY_EVAL(ac_compile); then
2907                         test -n "$verbose" && AC_MSG_RESULT(... $cf_attribute)
2908                         cat conftest.h >>confdefs.h
2909                         case "$cf_attribute" in
2910                         (noreturn)
2911                                 AC_DEFINE_UNQUOTED(GCC_NORETURN,$cf_directive,[Define to noreturn-attribute for gcc])
2912                                 ;;
2913                         (printf)
2914                                 cf_value='/* nothing */'
2915                                 if test "$cf_printf_attribute" != no ; then
2916                                         cf_value='__attribute__((format(printf,fmt,var)))'
2917                                         AC_DEFINE(GCC_PRINTF,1,[Define to 1 if the compiler supports gcc-like printf attribute.])
2918                                 fi
2919                                 AC_DEFINE_UNQUOTED(GCC_PRINTFLIKE(fmt,var),$cf_value,[Define to printf-attribute for gcc])
2920                                 ;;
2921                         (scanf)
2922                                 cf_value='/* nothing */'
2923                                 if test "$cf_scanf_attribute" != no ; then
2924                                         cf_value='__attribute__((format(scanf,fmt,var)))'
2925                                         AC_DEFINE(GCC_SCANF,1,[Define to 1 if the compiler supports gcc-like scanf attribute.])
2926                                 fi
2927                                 AC_DEFINE_UNQUOTED(GCC_SCANFLIKE(fmt,var),$cf_value,[Define to sscanf-attribute for gcc])
2928                                 ;;
2929                         (unused)
2930                                 AC_DEFINE_UNQUOTED(GCC_UNUSED,$cf_directive,[Define to unused-attribute for gcc])
2931                                 ;;
2932                         esac
2933                 fi
2934         done
2935 else
2936         ${FGREP-fgrep} define conftest.i >>confdefs.h
2937 fi
2938 rm -rf ./conftest*
2939 fi
2940 ])dnl
2941 dnl ---------------------------------------------------------------------------
2942 dnl CF_GCC_VERSION version: 8 updated: 2019/09/07 13:38:36
2943 dnl --------------
2944 dnl Find version of gcc, and (because icc/clang pretend to be gcc without being
2945 dnl compatible), attempt to determine if icc/clang is actually used.
2946 AC_DEFUN([CF_GCC_VERSION],[
2947 AC_REQUIRE([AC_PROG_CC])
2948 GCC_VERSION=none
2949 if test "$GCC" = yes ; then
2950         AC_MSG_CHECKING(version of $CC)
2951         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.]].*//'`"
2952         test -z "$GCC_VERSION" && GCC_VERSION=unknown
2953         AC_MSG_RESULT($GCC_VERSION)
2954 fi
2955 CF_INTEL_COMPILER(GCC,INTEL_COMPILER,CFLAGS)
2956 CF_CLANG_COMPILER(GCC,CLANG_COMPILER,CFLAGS)
2957 ])dnl
2958 dnl ---------------------------------------------------------------------------
2959 dnl CF_GCC_WARNINGS version: 41 updated: 2021/01/01 16:53:59
2960 dnl ---------------
2961 dnl Check if the compiler supports useful warning options.  There's a few that
2962 dnl we don't use, simply because they're too noisy:
2963 dnl
2964 dnl     -Wconversion (useful in older versions of gcc, but not in gcc 2.7.x)
2965 dnl     -Winline (usually not worthwhile)
2966 dnl     -Wredundant-decls (system headers make this too noisy)
2967 dnl     -Wtraditional (combines too many unrelated messages, only a few useful)
2968 dnl     -Wwrite-strings (too noisy, but should review occasionally).  This
2969 dnl             is enabled for ncurses using "--enable-const".
2970 dnl     -pedantic
2971 dnl
2972 dnl Parameter:
2973 dnl     $1 is an optional list of gcc warning flags that a particular
2974 dnl             application might want to use, e.g., "no-unused" for
2975 dnl             -Wno-unused
2976 dnl Special:
2977 dnl     If $with_ext_const is "yes", add a check for -Wwrite-strings
2978 dnl
2979 AC_DEFUN([CF_GCC_WARNINGS],
2980 [
2981 AC_REQUIRE([CF_GCC_VERSION])
2982 if test "x$have_x" = xyes; then CF_CONST_X_STRING fi
2983 cat > "conftest.$ac_ext" <<EOF
2984 #line __oline__ "${as_me:-configure}"
2985 int main(int argc, char *argv[[]]) { return (argv[[argc-1]] == 0) ; }
2986 EOF
2987 if test "$INTEL_COMPILER" = yes
2988 then
2989 # The "-wdXXX" options suppress warnings:
2990 # remark #1419: external declaration in primary source file
2991 # remark #1683: explicit conversion of a 64-bit integral type to a smaller integral type (potential portability problem)
2992 # remark #1684: conversion from pointer to same-sized integral type (potential portability problem)
2993 # remark #193: zero used for undefined preprocessing identifier
2994 # remark #593: variable "curs_sb_left_arrow" was set but never used
2995 # remark #810: conversion from "int" to "Dimension={unsigned short}" may lose significant bits
2996 # remark #869: parameter "tw" was never referenced
2997 # remark #981: operands are evaluated in unspecified order
2998 # warning #279: controlling expression is constant
2999
3000         AC_CHECKING([for $CC warning options])
3001         cf_save_CFLAGS="$CFLAGS"
3002         EXTRA_CFLAGS="$EXTRA_CFLAGS -Wall"
3003         for cf_opt in \
3004                 wd1419 \
3005                 wd1683 \
3006                 wd1684 \
3007                 wd193 \
3008                 wd593 \
3009                 wd279 \
3010                 wd810 \
3011                 wd869 \
3012                 wd981
3013         do
3014                 CFLAGS="$cf_save_CFLAGS $EXTRA_CFLAGS -$cf_opt"
3015                 if AC_TRY_EVAL(ac_compile); then
3016                         test -n "$verbose" && AC_MSG_RESULT(... -$cf_opt)
3017                         EXTRA_CFLAGS="$EXTRA_CFLAGS -$cf_opt"
3018                 fi
3019         done
3020         CFLAGS="$cf_save_CFLAGS"
3021 elif test "$GCC" = yes && test "$GCC_VERSION" != "unknown"
3022 then
3023         AC_CHECKING([for $CC warning options])
3024         cf_save_CFLAGS="$CFLAGS"
3025         cf_warn_CONST=""
3026         test "$with_ext_const" = yes && cf_warn_CONST="Wwrite-strings"
3027         cf_gcc_warnings="Wignored-qualifiers Wlogical-op Wvarargs"
3028         test "x$CLANG_COMPILER" = xyes && cf_gcc_warnings=
3029         for cf_opt in W Wall \
3030                 Wbad-function-cast \
3031                 Wcast-align \
3032                 Wcast-qual \
3033                 Wdeclaration-after-statement \
3034                 Wextra \
3035                 Winline \
3036                 Wmissing-declarations \
3037                 Wmissing-prototypes \
3038                 Wnested-externs \
3039                 Wpointer-arith \
3040                 Wshadow \
3041                 Wstrict-prototypes \
3042                 Wundef Wno-inline $cf_gcc_warnings $cf_warn_CONST $1
3043         do
3044                 CFLAGS="$cf_save_CFLAGS $EXTRA_CFLAGS -$cf_opt"
3045                 if AC_TRY_EVAL(ac_compile); then
3046                         test -n "$verbose" && AC_MSG_RESULT(... -$cf_opt)
3047                         case "$cf_opt" in
3048                         (Winline)
3049                                 case "$GCC_VERSION" in
3050                                 ([[34]].*)
3051                                         CF_VERBOSE(feature is broken in gcc $GCC_VERSION)
3052                                         continue;;
3053                                 esac
3054                                 ;;
3055                         (Wpointer-arith)
3056                                 case "$GCC_VERSION" in
3057                                 ([[12]].*)
3058                                         CF_VERBOSE(feature is broken in gcc $GCC_VERSION)
3059                                         continue;;
3060                                 esac
3061                                 ;;
3062                         esac
3063                         EXTRA_CFLAGS="$EXTRA_CFLAGS -$cf_opt"
3064                 fi
3065         done
3066         CFLAGS="$cf_save_CFLAGS"
3067 fi
3068 rm -rf ./conftest*
3069
3070 AC_SUBST(EXTRA_CFLAGS)
3071 ])dnl
3072 dnl ---------------------------------------------------------------------------
3073 dnl CF_GETOPT_HEADER version: 8 updated: 2021/06/19 19:16:16
3074 dnl ----------------
3075 dnl Check for getopt's variables which are commonly defined in stdlib.h,
3076 dnl unistd.h or (nonstandard) in getopt.h
3077 AC_DEFUN([CF_GETOPT_HEADER],
3078 [
3079 AC_HAVE_HEADERS(unistd.h getopt.h)
3080 AC_CACHE_CHECK(for header declaring getopt variables,cf_cv_getopt_header,[
3081 cf_cv_getopt_header=none
3082 for cf_header in stdio.h stdlib.h unistd.h getopt.h
3083 do
3084 AC_TRY_COMPILE([
3085 #include <$cf_header>],
3086 [int x = optind; char *y = optarg; (void)x; (void)y],
3087 [cf_cv_getopt_header=$cf_header
3088  break])
3089 done
3090 ])
3091 if test "$cf_cv_getopt_header" != none ; then
3092         AC_DEFINE(HAVE_GETOPT_HEADER,1,[Define to 1 if getopt variables are declared in header])
3093 fi
3094 if test "$cf_cv_getopt_header" = getopt.h ; then
3095         AC_DEFINE(NEED_GETOPT_H,1,[Define to 1 if we must include getopt.h])
3096 fi
3097 ])dnl
3098 dnl ---------------------------------------------------------------------------
3099 dnl CF_GNATPREP_OPT_T version: 1 updated: 2014/08/02 18:37:25
3100 dnl -----------------
3101 AC_DEFUN([CF_GNATPREP_OPT_T],[
3102 AC_CACHE_CHECK(if GNATPREP supports -T option,cf_cv_gnatprep_opt_t,[
3103 cf_cv_gnatprep_opt_t=no
3104 gnatprep -T 2>/dev/null >/dev/null && cf_cv_gnatprep_opt_t=yes
3105 ])
3106 test "$cf_cv_gnatprep_opt_t" = yes && GNATPREP_OPTS="-T $GNATPREP_OPTS"
3107 AC_SUBST(GNATPREP_OPTS)
3108 ])dnl
3109 dnl ---------------------------------------------------------------------------
3110 dnl CF_GNAT_GENERICS version: 7 updated: 2021/01/01 13:31:04
3111 dnl ----------------
3112 AC_DEFUN([CF_GNAT_GENERICS],
3113 [
3114 AC_REQUIRE([CF_GNAT_VERSION])
3115
3116 AC_MSG_CHECKING(if GNAT supports generics)
3117 case "$cf_cv_gnat_version" in
3118 (3.1[[1-9]]*|3.[[2-9]]*|[[4-9]].*|[[1-9]][[0-9]].[[0-9]]*|20[[0-9]][[0-9]])
3119         cf_gnat_generics=yes
3120         ;;
3121 (*)
3122         cf_gnat_generics=no
3123         ;;
3124 esac
3125 AC_MSG_RESULT($cf_gnat_generics)
3126
3127 if test "$cf_gnat_generics" = yes
3128 then
3129         cf_compile_generics=generics
3130         cf_generic_objects="\${GENOBJS}"
3131 else
3132         cf_compile_generics=
3133         cf_generic_objects=
3134 fi
3135
3136 AC_SUBST(cf_compile_generics)
3137 AC_SUBST(cf_generic_objects)
3138 ])dnl
3139 dnl ---------------------------------------------------------------------------
3140 dnl CF_GNAT_PROJECTS version: 13 updated: 2021/01/02 17:09:14
3141 dnl ----------------
3142 dnl GNAT projects are configured with ".gpr" project files.
3143 dnl GNAT libraries are a further development, using the project feature.
3144 AC_DEFUN([CF_GNAT_PROJECTS],
3145 [
3146 AC_REQUIRE([CF_GNAT_VERSION])
3147 AC_REQUIRE([CF_DISABLE_GNAT_PROJECTS])
3148
3149 cf_gnat_libraries=no
3150 cf_gnat_projects=no
3151
3152 if test "$enable_gnat_projects" != no ; then
3153 AC_MSG_CHECKING(if GNAT supports project files)
3154 case "$cf_cv_gnat_version" in
3155 (3.[[0-9]]*)
3156         ;;
3157 (*)
3158         case "$cf_cv_system_name" in
3159         (cygwin*|msys*)
3160                 ;;
3161         (*)
3162                 rm -rf ./conftest* ./*~conftest*
3163                 if mkdir conftest.src conftest.bin conftest.lib
3164                 then
3165                         cd conftest.src
3166                         rm -rf ./conftest* ./*~conftest*
3167                         cat >>library.gpr <<CF_EOF
3168 project Library is
3169   Kind := External ("LIB_KIND");
3170   for Library_Name use "ConfTest";
3171   for Object_Dir use ".";
3172   for Library_ALI_Dir use External("LIBRARY_DIR");
3173   for Library_Version use External ("SONAME");
3174   for Library_Kind use Kind;
3175   for Library_Dir use External("BUILD_DIR");
3176   Source_Dir := External ("SOURCE_DIR");
3177   for Source_Dirs use (Source_Dir);
3178 end Library;
3179 CF_EOF
3180                         cat >>confpackage.ads <<CF_EOF
3181 package ConfPackage is
3182    procedure conftest;
3183 end ConfPackage;
3184 CF_EOF
3185                         cat >>confpackage.adb <<CF_EOF
3186 with Text_IO;
3187 package body ConfPackage is
3188    procedure conftest is
3189    begin
3190       Text_IO.Put ("Hello World");
3191       Text_IO.New_Line;
3192    end conftest;
3193 end ConfPackage;
3194 CF_EOF
3195                         if ( "$cf_ada_make" $ADAFLAGS \
3196                                         -Plibrary.gpr \
3197                                         -XBUILD_DIR="`cd ../conftest.bin;pwd`" \
3198                                         -XLIBRARY_DIR="`cd ../conftest.lib;pwd`" \
3199                                         -XSOURCE_DIR="`pwd`" \
3200                                         -XSONAME=libConfTest.so.1 \
3201                                         -XLIB_KIND=static 1>&AC_FD_CC 2>&1 ) ; then
3202                                 cf_gnat_projects=yes
3203                         fi
3204                         cd ..
3205                 fi
3206                 if test -f conftest.lib/confpackage.ali
3207                 then
3208                         cf_gnat_libraries=yes
3209                 fi
3210                 rm -rf ./conftest* ./*~conftest*
3211                 ;;
3212         esac
3213         ;;
3214 esac
3215 AC_MSG_RESULT($cf_gnat_projects)
3216 fi # enable_gnat_projects
3217
3218 if test "$cf_gnat_projects" = yes
3219 then
3220         AC_MSG_CHECKING(if GNAT supports libraries)
3221         AC_MSG_RESULT($cf_gnat_libraries)
3222 fi
3223
3224 USE_OLD_MAKERULES=""
3225 USE_GNAT_PROJECTS="#"
3226 USE_GNAT_MAKE_GPR="#"
3227 USE_GNAT_GPRBUILD="#"
3228
3229 if test "$cf_gnat_projects" = yes
3230 then
3231         USE_OLD_MAKERULES="#"
3232         USE_GNAT_PROJECTS=""
3233         if test "$cf_cv_VERSION_GPRBUILD" != no
3234         then
3235                 USE_GNAT_GPRBUILD=""
3236         elif test "$cf_cv_VERSION_GNATMAKE" != no
3237         then
3238                 USE_GNAT_MAKE_GPR=""
3239         else
3240                 AC_MSG_WARN(use old makefile rules since tools are missing)
3241         fi
3242 fi
3243
3244 if test "$cf_gnat_libraries" = yes
3245 then
3246         USE_GNAT_LIBRARIES=""
3247 else
3248         USE_GNAT_LIBRARIES="#"
3249 fi
3250
3251 AC_SUBST(USE_OLD_MAKERULES)
3252 AC_SUBST(USE_GNAT_PROJECTS)
3253 AC_SUBST(USE_GNAT_LIBRARIES)
3254 AC_SUBST(USE_GNAT_MAKE_GPR)
3255 AC_SUBST(USE_GNAT_GPRBUILD)
3256 ])dnl
3257 dnl ---------------------------------------------------------------------------
3258 dnl CF_GNAT_SIGINT version: 2 updated: 2021/01/01 13:31:04
3259 dnl --------------
3260 dnl Check if gnat supports SIGINT, and presumably tasking.  For the latter, it
3261 dnl is noted that gnat may compile a tasking unit even for configurations which
3262 dnl fail at runtime.
3263 AC_DEFUN([CF_GNAT_SIGINT],[
3264 AC_CACHE_CHECK(if GNAT supports SIGINT,cf_cv_gnat_sigint,[
3265 CF_GNAT_TRY_LINK([with Ada.Interrupts.Names;
3266
3267 package ConfTest is
3268
3269    pragma Warnings (Off);  --  the next pragma exists since 3.11p
3270    pragma Unreserve_All_Interrupts;
3271    pragma Warnings (On);
3272
3273    protected Process is
3274       procedure Stop;
3275       function Continue return Boolean;
3276       pragma Attach_Handler (Stop, Ada.Interrupts.Names.SIGINT);
3277    private
3278       Done : Boolean := False;
3279    end Process;
3280
3281 end ConfTest;],
3282 [package body ConfTest is
3283    protected body Process is
3284       procedure Stop is
3285       begin
3286          Done := True;
3287       end Stop;
3288       function Continue return Boolean is
3289       begin
3290          return not Done;
3291       end Continue;
3292    end Process;
3293 end ConfTest;],
3294         [cf_cv_gnat_sigint=yes],
3295         [cf_cv_gnat_sigint=no])])
3296
3297 if test "$cf_cv_gnat_sigint" = yes ; then
3298         USE_GNAT_SIGINT=""
3299 else
3300         USE_GNAT_SIGINT="#"
3301 fi
3302 AC_SUBST(USE_GNAT_SIGINT)
3303 ])dnl
3304 dnl ---------------------------------------------------------------------------
3305 dnl CF_GNAT_TRY_LINK version: 4 updated: 2021/01/01 13:31:04
3306 dnl ----------------
3307 dnl Verify that a test program compiles/links with GNAT.
3308 dnl $cf_ada_make is set to the program that compiles/links
3309 dnl $ADAFLAGS may be set to the GNAT flags.
3310 dnl
3311 dnl $1 is the text of the spec
3312 dnl $2 is the text of the body
3313 dnl $3 is the shell command to execute if successful
3314 dnl $4 is the shell command to execute if not successful
3315 AC_DEFUN([CF_GNAT_TRY_LINK],
3316 [
3317 rm -rf ./conftest* ./*~conftest*
3318 cat >>conftest.ads <<CF_EOF
3319 $1
3320 CF_EOF
3321 cat >>conftest.adb <<CF_EOF
3322 $2
3323 CF_EOF
3324 if ( "$cf_ada_make" $ADAFLAGS conftest 1>&AC_FD_CC 2>&1 ) ; then
3325 ifelse($3,,      :,[      $3])
3326 ifelse($4,,,[else
3327    $4])
3328 fi
3329 rm -rf ./conftest* ./*~conftest*
3330 ])dnl
3331 dnl ---------------------------------------------------------------------------
3332 dnl CF_GNAT_TRY_RUN version: 6 updated: 2021/01/01 13:31:04
3333 dnl ---------------
3334 dnl Verify that a test program compiles and runs with GNAT
3335 dnl $cf_ada_make is set to the program that compiles/links
3336 dnl $ADAFLAGS may be set to the GNAT flags.
3337 dnl
3338 dnl $1 is the text of the spec
3339 dnl $2 is the text of the body
3340 dnl $3 is the shell command to execute if successful
3341 dnl $4 is the shell command to execute if not successful
3342 AC_DEFUN([CF_GNAT_TRY_RUN],
3343 [
3344 rm -rf ./conftest* ./*~conftest*
3345 cat >>conftest.ads <<CF_EOF
3346 $1
3347 CF_EOF
3348 cat >>conftest.adb <<CF_EOF
3349 $2
3350 CF_EOF
3351 if ( "$cf_ada_make" $ADAFLAGS conftest 1>&AC_FD_CC 2>&1 ) ; then
3352    if ( ./conftest 1>&AC_FD_CC 2>&1 ) ; then
3353 ifelse($3,,      :,[      $3])
3354 ifelse($4,,,[   else
3355       $4])
3356    fi
3357 ifelse($4,,,[else
3358    $4])
3359 fi
3360 rm -rf ./conftest* ./*~conftest*
3361 ])dnl
3362 dnl ---------------------------------------------------------------------------
3363 dnl CF_GNAT_VERSION version: 22 updated: 2019/12/31 08:53:54
3364 dnl ---------------
3365 dnl $1 = cache variable to update
3366 dnl $2 = program name
3367 dnl Verify version of GNAT or related tool
3368 AC_DEFUN([CF_GNAT_VERSION],
3369 [
3370 AC_CACHE_CHECK(for ifelse($2,,gnat,$2) version, cf_cv_gnat_version,[
3371 cf_cv_gnat_version=`ifelse($2,,${cf_ada_make:-gnatmake},$2) --version 2>&1 | \
3372         grep '[[0-9]].[[0-9]][[0-9]]*' |\
3373         sed -e '2,$d' -e 's/[[^0-9 \.]]//g' -e 's/^[[ ]]*//' -e 's/ .*//'`
3374 ])
3375 test -z "$cf_cv_gnat_version" && cf_cv_gnat_version=no
3376 ifelse($1,,,[eval $1=$cf_cv_gnat_version; unset cf_cv_gnat_version])
3377 ])dnl
3378 dnl ---------------------------------------------------------------------------
3379 dnl CF_GNU_SOURCE version: 10 updated: 2018/12/10 20:09:41
3380 dnl -------------
3381 dnl Check if we must define _GNU_SOURCE to get a reasonable value for
3382 dnl _XOPEN_SOURCE, upon which many POSIX definitions depend.  This is a defect
3383 dnl (or misfeature) of glibc2, which breaks portability of many applications,
3384 dnl since it is interwoven with GNU extensions.
3385 dnl
3386 dnl Well, yes we could work around it...
3387 dnl
3388 dnl Parameters:
3389 dnl     $1 is the nominal value for _XOPEN_SOURCE
3390 AC_DEFUN([CF_GNU_SOURCE],
3391 [
3392 cf_gnu_xopen_source=ifelse($1,,500,$1)
3393
3394 AC_CACHE_CHECK(if this is the GNU C library,cf_cv_gnu_library,[
3395 AC_TRY_COMPILE([#include <sys/types.h>],[
3396         #if __GLIBC__ > 0 && __GLIBC_MINOR__ >= 0
3397                 return 0;
3398         #elif __NEWLIB__ > 0 && __NEWLIB_MINOR__ >= 0
3399                 return 0;
3400         #else
3401         #       error not GNU C library
3402         #endif],
3403         [cf_cv_gnu_library=yes],
3404         [cf_cv_gnu_library=no])
3405 ])
3406
3407 if test x$cf_cv_gnu_library = xyes; then
3408
3409         # With glibc 2.19 (13 years after this check was begun), _DEFAULT_SOURCE
3410         # was changed to help a little.  newlib incorporated the change about 4
3411         # years later.
3412         AC_CACHE_CHECK(if _DEFAULT_SOURCE can be used as a basis,cf_cv_gnu_library_219,[
3413                 cf_save="$CPPFLAGS"
3414                 CF_APPEND_TEXT(CPPFLAGS,-D_DEFAULT_SOURCE)
3415                 AC_TRY_COMPILE([#include <sys/types.h>],[
3416                         #if (__GLIBC__ == 2 && __GLIBC_MINOR__ >= 19) || (__GLIBC__ > 2)
3417                                 return 0;
3418                         #elif (__NEWLIB__ == 2 && __NEWLIB_MINOR__ >= 4) || (__GLIBC__ > 3)
3419                                 return 0;
3420                         #else
3421                         #       error GNU C library __GLIBC__.__GLIBC_MINOR__ is too old
3422                         #endif],
3423                         [cf_cv_gnu_library_219=yes],
3424                         [cf_cv_gnu_library_219=no])
3425                 CPPFLAGS="$cf_save"
3426         ])
3427
3428         if test "x$cf_cv_gnu_library_219" = xyes; then
3429                 cf_save="$CPPFLAGS"
3430                 AC_CACHE_CHECK(if _XOPEN_SOURCE=$cf_gnu_xopen_source works with _DEFAULT_SOURCE,cf_cv_gnu_dftsrc_219,[
3431                         CF_ADD_CFLAGS(-D_DEFAULT_SOURCE -D_XOPEN_SOURCE=$cf_gnu_xopen_source)
3432                         AC_TRY_COMPILE([
3433                                 #include <limits.h>
3434                                 #include <sys/types.h>
3435                                 ],[
3436                                 #if (_XOPEN_SOURCE >= $cf_gnu_xopen_source) && (MB_LEN_MAX > 1)
3437                                         return 0;
3438                                 #else
3439                                 #       error GNU C library is too old
3440                                 #endif],
3441                                 [cf_cv_gnu_dftsrc_219=yes],
3442                                 [cf_cv_gnu_dftsrc_219=no])
3443                         ])
3444                 test "x$cf_cv_gnu_dftsrc_219" = "xyes" || CPPFLAGS="$cf_save"
3445         else
3446                 cf_cv_gnu_dftsrc_219=maybe
3447         fi
3448
3449         if test "x$cf_cv_gnu_dftsrc_219" != xyes; then
3450
3451                 AC_CACHE_CHECK(if we must define _GNU_SOURCE,cf_cv_gnu_source,[
3452                 AC_TRY_COMPILE([#include <sys/types.h>],[
3453                         #ifndef _XOPEN_SOURCE
3454                         #error  expected _XOPEN_SOURCE to be defined
3455                         #endif],
3456                         [cf_cv_gnu_source=no],
3457                         [cf_save="$CPPFLAGS"
3458                          CF_ADD_CFLAGS(-D_GNU_SOURCE)
3459                          AC_TRY_COMPILE([#include <sys/types.h>],[
3460                                 #ifdef _XOPEN_SOURCE
3461                                 #error  expected _XOPEN_SOURCE to be undefined
3462                                 #endif],
3463                                 [cf_cv_gnu_source=no],
3464                                 [cf_cv_gnu_source=yes])
3465                         CPPFLAGS="$cf_save"
3466                         ])
3467                 ])
3468
3469                 if test "$cf_cv_gnu_source" = yes
3470                 then
3471                 AC_CACHE_CHECK(if we should also define _DEFAULT_SOURCE,cf_cv_default_source,[
3472                         CF_APPEND_TEXT(CPPFLAGS,-D_GNU_SOURCE)
3473                         AC_TRY_COMPILE([#include <sys/types.h>],[
3474                                 #ifdef _DEFAULT_SOURCE
3475                                 #error  expected _DEFAULT_SOURCE to be undefined
3476                                 #endif],
3477                                 [cf_cv_default_source=no],
3478                                 [cf_cv_default_source=yes])
3479                         ])
3480                         if test "$cf_cv_default_source" = yes
3481                         then
3482                                 CF_APPEND_TEXT(CPPFLAGS,-D_DEFAULT_SOURCE)
3483                         fi
3484                 fi
3485         fi
3486
3487 fi
3488 ])dnl
3489 dnl ---------------------------------------------------------------------------
3490 dnl CF_GPP_LIBRARY version: 13 updated: 2021/01/01 13:31:04
3491 dnl --------------
3492 dnl If we're trying to use g++, test if libg++ is installed (a rather common
3493 dnl problem :-).  If we have the compiler but no library, we'll be able to
3494 dnl configure, but won't be able to build the c++ demo program.
3495 AC_DEFUN([CF_GPP_LIBRARY],
3496 [
3497 cf_cxx_library=unknown
3498 case "$cf_cv_system_name" in
3499 (os2*)
3500         cf_gpp_libname=gpp
3501         ;;
3502 (*)
3503         cf_gpp_libname=g++
3504         ;;
3505 esac
3506 if test "$GXX" = yes; then
3507         AC_MSG_CHECKING([for lib$cf_gpp_libname])
3508         cf_save="$LIBS"
3509         CF_ADD_LIB($cf_gpp_libname)
3510         AC_TRY_LINK([
3511 #include <$cf_gpp_libname/builtin.h>
3512         ],
3513         [two_arg_error_handler_t foo2 = lib_error_handler],
3514         [cf_cxx_library=yes
3515          CF_ADD_LIB($cf_gpp_libname,CXXLIBS)
3516          if test "$cf_gpp_libname" = cpp ; then
3517             AC_DEFINE(HAVE_GPP_BUILTIN_H,1,[Define to 1 if we have gpp builtin.h])
3518          else
3519             AC_DEFINE(HAVE_GXX_BUILTIN_H,1,[Define to 1 if we have g++ builtin.h])
3520          fi],
3521         [AC_TRY_LINK([
3522 #include <builtin.h>
3523         ],
3524         [two_arg_error_handler_t foo2 = lib_error_handler],
3525         [cf_cxx_library=yes
3526          CF_ADD_LIB($cf_gpp_libname,CXXLIBS)
3527          AC_DEFINE(HAVE_BUILTIN_H,1,[Define to 1 if we have builtin.h])],
3528         [cf_cxx_library=no])])
3529         LIBS="$cf_save"
3530         AC_MSG_RESULT($cf_cxx_library)
3531 fi
3532 ])dnl
3533 dnl ---------------------------------------------------------------------------
3534 dnl CF_GXX_VERSION version: 8 updated: 2017/02/11 14:48:57
3535 dnl --------------
3536 dnl Check for version of g++
3537 AC_DEFUN([CF_GXX_VERSION],[
3538 AC_REQUIRE([AC_PROG_CPP])
3539 GXX_VERSION=none
3540 if test "$GXX" = yes; then
3541         AC_MSG_CHECKING(version of ${CXX:-g++})
3542         GXX_VERSION="`${CXX:-g++} --version| sed -e '2,$d' -e 's/^.*(GCC) //' -e 's/^[[^0-9.]]*//' -e 's/[[^0-9.]].*//'`"
3543         if test -z "$GXX_VERSION"
3544         then
3545                 GXX_VERSION=unknown
3546                 GXX=no
3547         fi
3548         AC_MSG_RESULT($GXX_VERSION)
3549 fi
3550 ])dnl
3551 dnl ---------------------------------------------------------------------------
3552 dnl CF_GXX_WARNINGS version: 11 updated: 2021/01/08 16:50:55
3553 dnl ---------------
3554 dnl Check if the compiler supports useful warning options.
3555 dnl
3556 dnl Most of gcc's options apply to g++, except:
3557 dnl     -Wbad-function-cast
3558 dnl     -Wmissing-declarations
3559 dnl     -Wnested-externs
3560 dnl
3561 dnl Omit a few (for now):
3562 dnl     -Winline
3563 dnl
3564 dnl Parameter:
3565 dnl     $1 is an optional list of g++ warning flags that a particular
3566 dnl             application might want to use, e.g., "no-unused" for
3567 dnl             -Wno-unused
3568 dnl Special:
3569 dnl     If $with_ext_const is "yes", add a check for -Wwrite-strings
3570 dnl
3571 AC_DEFUN([CF_GXX_WARNINGS],
3572 [
3573
3574 CF_INTEL_COMPILER(GXX,INTEL_CPLUSPLUS,CXXFLAGS)
3575 CF_CLANG_COMPILER(GXX,CLANG_CPLUSPLUS,CXXFLAGS)
3576
3577 AC_REQUIRE([CF_GXX_VERSION])
3578
3579 AC_LANG_SAVE
3580 AC_LANG_CPLUSPLUS
3581
3582 cat > conftest.$ac_ext <<EOF
3583 #line __oline__ "configure"
3584 int main(int argc, char *argv[[]]) { return (argv[[argc-1]] == 0) ; }
3585 EOF
3586
3587 if test "$INTEL_CPLUSPLUS" = yes
3588 then
3589 # The "-wdXXX" options suppress warnings:
3590 # remark #1419: external declaration in primary source file
3591 # remark #1682: implicit conversion of a 64-bit integral type to a smaller integral type (potential portability problem)
3592 # remark #1683: explicit conversion of a 64-bit integral type to a smaller integral type (potential portability problem)
3593 # remark #1684: conversion from pointer to same-sized integral type (potential portability problem)
3594 # remark #193: zero used for undefined preprocessing identifier
3595 # remark #593: variable "curs_sb_left_arrow" was set but never used
3596 # remark #810: conversion from "int" to "Dimension={unsigned short}" may lose significant bits
3597 # remark #869: parameter "tw" was never referenced
3598 # remark #981: operands are evaluated in unspecified order
3599 # warning #269: invalid format string conversion
3600
3601         AC_CHECKING([for $CC warning options])
3602         cf_save_CXXFLAGS="$CXXFLAGS"
3603         EXTRA_CXXFLAGS="-Wall"
3604         for cf_opt in \
3605                 wd1419 \
3606                 wd1682 \
3607                 wd1683 \
3608                 wd1684 \
3609                 wd193 \
3610                 wd279 \
3611                 wd593 \
3612                 wd810 \
3613                 wd869 \
3614                 wd981
3615         do
3616                 CXXFLAGS="$cf_save_CXXFLAGS $EXTRA_CXXFLAGS -$cf_opt"
3617                 if AC_TRY_EVAL(ac_compile); then
3618                         test -n "$verbose" && AC_MSG_RESULT(... -$cf_opt)
3619                         EXTRA_CXXFLAGS="$EXTRA_CXXFLAGS -$cf_opt"
3620                 fi
3621         done
3622         CXXFLAGS="$cf_save_CXXFLAGS"
3623
3624 elif test "$GXX" = yes
3625 then
3626         AC_CHECKING([for $CXX warning options])
3627         cf_save_CXXFLAGS="$CXXFLAGS"
3628         EXTRA_CXXFLAGS="-W -Wall"
3629         cf_gxx_extra_warnings=""
3630         test "$with_ext_const" = yes && cf_gxx_extra_warnings="Wwrite-strings"
3631         case "$GXX_VERSION" in
3632         ([[1-2]].*)
3633                 ;;
3634         (*)
3635                 cf_gxx_extra_warnings="$cf_gxx_extra_warnings Weffc++"
3636                 ;;
3637         esac
3638         for cf_opt in \
3639                 Wabi \
3640                 fabi-version=0 \
3641                 Wextra \
3642                 Wignored-qualifiers \
3643                 Wlogical-op \
3644                 Woverloaded-virtual \
3645                 Wsign-promo \
3646                 Wsynth \
3647                 Wold-style-cast \
3648                 Wcast-align \
3649                 Wcast-qual \
3650                 Wpointer-arith \
3651                 Wshadow \
3652                 Wundef $cf_gxx_extra_warnings $1
3653         do
3654                 CXXFLAGS="$cf_save_CXXFLAGS $EXTRA_CXXFLAGS -Werror -$cf_opt"
3655                 if AC_TRY_EVAL(ac_compile); then
3656                         test -n "$verbose" && AC_MSG_RESULT(... -$cf_opt)
3657                         EXTRA_CXXFLAGS="$EXTRA_CXXFLAGS -$cf_opt"
3658                 else
3659                         test -n "$verbose" && AC_MSG_RESULT(... no -$cf_opt)
3660                 fi
3661         done
3662         CXXFLAGS="$cf_save_CXXFLAGS"
3663 fi
3664
3665 rm -rf ./conftest*
3666 AC_LANG_RESTORE
3667 AC_SUBST(EXTRA_CXXFLAGS)
3668 ])dnl
3669 dnl ---------------------------------------------------------------------------
3670 dnl CF_HASHED_DB version: 7 updated: 2015/04/18 08:56:57
3671 dnl ------------
3672 dnl Look for an instance of the Berkeley hashed database.
3673 dnl
3674 dnl $1 = optional parameter, to specify install-prefix for the database.
3675 AC_DEFUN([CF_HASHED_DB],
3676 [
3677 ifelse([$1],,,[
3678 case $1 in
3679 (yes|*able*)
3680         ;;
3681 (*)
3682         if test -d "$1" ; then
3683                 CF_ADD_INCDIR($1/include)
3684                 CF_ADD_LIBDIR($1/lib)
3685         else
3686                 case "$1" in
3687                 (./*|../*|/*)
3688                         AC_MSG_WARN(no such directory $1)
3689                         ;;
3690                 (*)
3691                         CF_FIND_SUB_INCDIR($1)
3692                         CF_FIND_SUB_LIBDIR($1)
3693                         ;;
3694                 esac
3695         fi
3696 esac
3697 ])
3698 AC_CHECK_HEADER(db.h,[
3699 CF_HASHED_DB_VERSION
3700 if test "$cf_cv_hashed_db_version" = unknown ; then
3701         AC_MSG_ERROR(Cannot determine version of db)
3702 else
3703         CF_HASHED_DB_LIBS
3704         if test "$cf_cv_hashed_db_libs" = unknown ; then
3705                 AC_MSG_ERROR(Cannot determine library for db)
3706         elif test "$cf_cv_hashed_db_libs" != default ; then
3707                 CF_ADD_LIB($cf_cv_hashed_db_libs)
3708         fi
3709 fi
3710 ],[
3711         AC_MSG_ERROR(Cannot find db.h)
3712 ])
3713 ])dnl
3714 dnl ---------------------------------------------------------------------------
3715 dnl CF_HASHED_DB_LIBS version: 10 updated: 2021/01/02 17:09:14
3716 dnl -----------------
3717 dnl Given that we have the header and version for hashed database, find the
3718 dnl library information.
3719 AC_DEFUN([CF_HASHED_DB_LIBS],
3720 [
3721 AC_CACHE_CHECK(for db libraries, cf_cv_hashed_db_libs,[
3722 cf_cv_hashed_db_libs=unknown
3723 for cf_db_libs in "" db$cf_cv_hashed_db_version db-$cf_cv_hashed_db_version db ''
3724 do
3725         cf_save_libs="$LIBS"
3726         if test -n "$cf_db_libs"; then
3727                 CF_ADD_LIB($cf_db_libs)
3728         fi
3729         CF_MSG_LOG(checking for library $cf_db_libs)
3730         AC_TRY_LINK([
3731 $ac_includes_default
3732 #include <db.h>
3733 ],[
3734         char *path = "/tmp/foo";
3735 #ifdef DB_VERSION_MAJOR
3736 #if DB_VERSION_MAJOR >= 4
3737         DB *result = 0;
3738         db_create(&result, NULL, 0);
3739         result->open(result,
3740                 NULL,
3741                 path,
3742                 path,
3743                 DB_HASH,
3744                 DB_CREATE,
3745                 0644);
3746 #elif DB_VERSION_MAJOR >= 3
3747         DB *result = 0;
3748         db_create(&result, NULL, 0);
3749         result->open(result,
3750                 path,
3751                 path,
3752                 DB_HASH,
3753                 DB_CREATE,
3754                 0644);
3755 #elif DB_VERSION_MAJOR >= 2
3756         DB *result = 0;
3757         db_open(path,
3758                 DB_HASH,
3759                 DB_CREATE,
3760                 0644,
3761                 (DB_ENV *) 0,
3762                 (DB_INFO *) 0,
3763                 &result);
3764 #endif /* DB_VERSION_MAJOR */
3765 #else
3766         DB *result = dbopen(path,
3767                      2,
3768                      0644,
3769                      DB_HASH,
3770                      0);
3771 #endif
3772         ${cf_cv_main_return:-return}(result != 0)
3773 ],[
3774         if test -n "$cf_db_libs" ; then
3775                 cf_cv_hashed_db_libs=$cf_db_libs
3776         else
3777                 cf_cv_hashed_db_libs=default
3778         fi
3779         LIBS="$cf_save_libs"
3780         break
3781 ])
3782         LIBS="$cf_save_libs"
3783 done
3784 ])
3785 ])dnl
3786 dnl ---------------------------------------------------------------------------
3787 dnl CF_HASHED_DB_VERSION version: 4 updated: 2014/04/12 16:47:01
3788 dnl --------------------
3789 dnl Given that we have the header file for hashed database, find the version
3790 dnl information.
3791 AC_DEFUN([CF_HASHED_DB_VERSION],
3792 [
3793 AC_CACHE_CHECK(for version of db, cf_cv_hashed_db_version,[
3794 cf_cv_hashed_db_version=unknown
3795
3796 for cf_db_version in 1 2 3 4 5 6
3797 do
3798         CF_MSG_LOG(checking for db version $cf_db_version)
3799         AC_TRY_COMPILE([
3800 $ac_includes_default
3801 #include <db.h>
3802
3803 #ifdef DB_VERSION_MAJOR
3804         /* db2 (DB_VERSION_MAJOR=2) has also DB_VERSION_MINOR, tested with 7 */
3805 #if $cf_db_version == DB_VERSION_MAJOR
3806         /* ok */
3807 #else
3808         make an error
3809 #endif
3810 #else
3811 #if $cf_db_version == 1
3812         /* ok: assuming this is DB 1.8.5 */
3813 #else
3814         make an error
3815 #endif
3816 #endif
3817 ],[DBT *foo = 0],[
3818         cf_cv_hashed_db_version=$cf_db_version
3819         break
3820         ])
3821 done
3822 ])
3823 ])dnl
3824 dnl ---------------------------------------------------------------------------
3825 dnl CF_HEADER_PATH version: 15 updated: 2021/01/01 13:31:04
3826 dnl --------------
3827 dnl Construct a search-list of directories for a nonstandard header-file
3828 dnl
3829 dnl Parameters
3830 dnl     $1 = the variable to return as result
3831 dnl     $2 = the package name
3832 AC_DEFUN([CF_HEADER_PATH],
3833 [
3834 $1=
3835
3836 # collect the current set of include-directories from compiler flags
3837 cf_header_path_list=""
3838 if test -n "${CFLAGS}${CPPFLAGS}" ; then
3839         for cf_header_path in $CPPFLAGS $CFLAGS
3840         do
3841                 case "$cf_header_path" in
3842                 (-I*)
3843                         cf_header_path=`echo ".$cf_header_path" |sed -e 's/^...//' -e 's,/include$,,'`
3844                         CF_ADD_SUBDIR_PATH($1,$2,include,$cf_header_path,NONE)
3845                         cf_header_path_list="$cf_header_path_list [$]$1"
3846                         ;;
3847                 esac
3848         done
3849 fi
3850
3851 # add the variations for the package we are looking for
3852 CF_SUBDIR_PATH($1,$2,include)
3853
3854 test "$includedir" != NONE && \
3855 test "$includedir" != "/usr/include" && \
3856 test -d "$includedir" && {
3857         test -d "$includedir" &&    $1="[$]$1 $includedir"
3858         test -d "$includedir/$2" && $1="[$]$1 $includedir/$2"
3859 }
3860
3861 test "$oldincludedir" != NONE && \
3862 test "$oldincludedir" != "/usr/include" && \
3863 test -d "$oldincludedir" && {
3864         test -d "$oldincludedir"    && $1="[$]$1 $oldincludedir"
3865         test -d "$oldincludedir/$2" && $1="[$]$1 $oldincludedir/$2"
3866 }
3867
3868 $1="[$]$1 $cf_header_path_list"
3869 ])dnl
3870 dnl ---------------------------------------------------------------------------
3871 dnl CF_HELP_MESSAGE version: 4 updated: 2019/12/31 08:53:54
3872 dnl ---------------
3873 dnl Insert text into the help-message, for readability, from AC_ARG_WITH.
3874 AC_DEFUN([CF_HELP_MESSAGE],
3875 [CF_ACVERSION_CHECK(2.53,[],[
3876 AC_DIVERT_HELP($1)])dnl
3877 ])dnl
3878 dnl ---------------------------------------------------------------------------
3879 dnl CF_INCLUDE_DIRS version: 10 updated: 2014/09/19 20:58:42
3880 dnl ---------------
3881 dnl Construct the list of include-options according to whether we're building
3882 dnl in the source directory or using '--srcdir=DIR' option.
3883 AC_DEFUN([CF_INCLUDE_DIRS],
3884 [
3885 if test "$srcdir" != "."; then
3886         CPPFLAGS="-I\${srcdir}/../include $CPPFLAGS"
3887 fi
3888 CPPFLAGS="-I../include $CPPFLAGS"
3889 if test "$srcdir" != "."; then
3890         CPPFLAGS="-I\${srcdir} $CPPFLAGS"
3891 fi
3892 CPPFLAGS="-I. $CPPFLAGS"
3893 AC_SUBST(CPPFLAGS)
3894 ])dnl
3895 dnl ---------------------------------------------------------------------------
3896 dnl CF_INSTALL_OPTS version: 2 updated: 2018/08/18 12:19:21
3897 dnl ---------------
3898 dnl prompt for/fill-in useful install-program options
3899 AC_DEFUN([CF_INSTALL_OPTS],
3900 [
3901 CF_INSTALL_OPT_S
3902 CF_INSTALL_OPT_P
3903 CF_INSTALL_OPT_O
3904 ])dnl
3905 dnl ---------------------------------------------------------------------------
3906 dnl CF_INSTALL_OPT_O version: 3 updated: 2020/12/31 20:19:42
3907 dnl ----------------
3908 dnl Almost all "install" programs default to the current user's ownership.
3909 dnl Almost - MINIX is an exception.
3910 AC_DEFUN([CF_INSTALL_OPT_O],
3911 [
3912 AC_MSG_CHECKING(if install needs to be told about ownership)
3913 case `$ac_config_guess` in
3914 (*minix)
3915         with_install_o=yes
3916         ;;
3917 (*)
3918         with_install_o=no
3919         ;;
3920 esac
3921
3922 AC_MSG_RESULT($with_install_o)
3923 if test "x$with_install_o" = xyes
3924 then
3925         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'`"
3926 else
3927         INSTALL_OPT_O=
3928 fi
3929
3930 AC_SUBST(INSTALL_OPT_O)
3931 ])dnl
3932 dnl ---------------------------------------------------------------------------
3933 dnl CF_INSTALL_OPT_P version: 3 updated: 2021/01/01 13:31:04
3934 dnl ----------------
3935 dnl Some install-programs accept a "-p" option to preserve file modification
3936 dnl timestamps.  That can be useful as an install option, as well as a way to
3937 dnl avoid the need for ranlib after copying a static archive.
3938 AC_DEFUN([CF_INSTALL_OPT_P],
3939 [
3940 : "${INSTALL:=install}"
3941 AC_CACHE_CHECK(if install accepts -p option, cf_cv_install_p,[
3942         rm -rf ./conftest*
3943         date >conftest.in
3944         mkdir conftest.out
3945         sleep 3
3946         if $INSTALL -p conftest.in conftest.out 2>/dev/null
3947         then
3948                 if test -f conftest.out/conftest.in
3949                 then
3950                         test conftest.in -nt conftest.out/conftest.in 2>conftest.err && \
3951                         test conftest.out/conftest.in -nt conftest.in 2>conftest.err
3952                         if test -s conftest.err
3953                         then
3954                                 cf_cv_install_p=no
3955                         else
3956                                 cf_cv_install_p=yes
3957                         fi
3958                 else
3959                         cf_cv_install_p=no
3960                 fi
3961         else
3962                 cf_cv_install_p=no
3963         fi
3964         rm -rf ./conftest*
3965 ])
3966 ])dnl
3967 dnl ---------------------------------------------------------------------------
3968 dnl CF_INSTALL_OPT_S version: 3 updated: 2021/01/05 19:23:48
3969 dnl ----------------
3970 dnl By default, we should strip executables which are installed, but leave the
3971 dnl ability to suppress that for unit-testing.
3972 AC_DEFUN([CF_INSTALL_OPT_S],
3973 [
3974 AC_MSG_CHECKING(if you want to install stripped executables)
3975 CF_ARG_DISABLE(stripping,
3976         [  --disable-stripping     do not strip (debug info) installed executables],
3977         [enable_stripping=no],
3978         [enable_stripping=yes])
3979 AC_MSG_RESULT($enable_stripping)
3980
3981 if test "$enable_stripping" = yes
3982 then
3983         INSTALL_OPT_S="-s"
3984 else
3985         INSTALL_OPT_S=
3986 fi
3987 AC_SUBST(INSTALL_OPT_S)
3988 ])dnl
3989 dnl ---------------------------------------------------------------------------
3990 dnl CF_INTEL_COMPILER version: 8 updated: 2021/01/01 16:53:59
3991 dnl -----------------
3992 dnl Check if the given compiler is really the Intel compiler for Linux.  It
3993 dnl tries to imitate gcc, but does not return an error when it finds a mismatch
3994 dnl between prototypes, e.g., as exercised by CF_MISSING_CHECK.
3995 dnl
3996 dnl This macro should be run "soon" after AC_PROG_CC or AC_PROG_CPLUSPLUS, to
3997 dnl ensure that it is not mistaken for gcc/g++.  It is normally invoked from
3998 dnl the wrappers for gcc and g++ warnings.
3999 dnl
4000 dnl $1 = GCC (default) or GXX
4001 dnl $2 = INTEL_COMPILER (default) or INTEL_CPLUSPLUS
4002 dnl $3 = CFLAGS (default) or CXXFLAGS
4003 AC_DEFUN([CF_INTEL_COMPILER],[
4004 AC_REQUIRE([AC_CANONICAL_HOST])
4005 ifelse([$2],,INTEL_COMPILER,[$2])=no
4006
4007 if test "$ifelse([$1],,[$1],GCC)" = yes ; then
4008         case "$host_os" in
4009         (linux*|gnu*)
4010                 AC_MSG_CHECKING(if this is really Intel ifelse([$1],GXX,C++,C) compiler)
4011                 cf_save_CFLAGS="$ifelse([$3],,CFLAGS,[$3])"
4012                 ifelse([$3],,CFLAGS,[$3])="$ifelse([$3],,CFLAGS,[$3]) -no-gcc"
4013                 AC_TRY_COMPILE([],[
4014 #ifdef __INTEL_COMPILER
4015 #else
4016 make an error
4017 #endif
4018 ],[ifelse([$2],,INTEL_COMPILER,[$2])=yes
4019 cf_save_CFLAGS="$cf_save_CFLAGS -we147"
4020 ],[])
4021                 ifelse([$3],,CFLAGS,[$3])="$cf_save_CFLAGS"
4022                 AC_MSG_RESULT($ifelse([$2],,INTEL_COMPILER,[$2]))
4023                 ;;
4024         esac
4025 fi
4026 ])dnl
4027 dnl ---------------------------------------------------------------------------
4028 dnl CF_ISASCII version: 4 updated: 2012/10/06 17:56:13
4029 dnl ----------
4030 dnl Check if we have either a function or macro for 'isascii()'.
4031 AC_DEFUN([CF_ISASCII],
4032 [
4033 AC_MSG_CHECKING(for isascii)
4034 AC_CACHE_VAL(cf_cv_have_isascii,[
4035         AC_TRY_LINK([#include <ctype.h>],[int x = isascii(' ')],
4036         [cf_cv_have_isascii=yes],
4037         [cf_cv_have_isascii=no])
4038 ])dnl
4039 AC_MSG_RESULT($cf_cv_have_isascii)
4040 test "$cf_cv_have_isascii" = yes && AC_DEFINE(HAVE_ISASCII,1,[Define to 1 if we have isascii()])
4041 ])dnl
4042 dnl ---------------------------------------------------------------------------
4043 dnl CF_LARGEFILE version: 12 updated: 2020/03/19 20:23:48
4044 dnl ------------
4045 dnl Add checks for large file support.
4046 AC_DEFUN([CF_LARGEFILE],[
4047 ifdef([AC_FUNC_FSEEKO],[
4048         AC_SYS_LARGEFILE
4049         if test "$enable_largefile" != no ; then
4050         AC_FUNC_FSEEKO
4051
4052         # Normally we would collect these definitions in the config.h,
4053         # but (like _XOPEN_SOURCE), some environments rely on having these
4054         # defined before any of the system headers are included.  Another
4055         # case comes up with C++, e.g., on AIX the compiler compiles the
4056         # header files by themselves before looking at the body files it is
4057         # told to compile.  For ncurses, those header files do not include
4058         # the config.h
4059         if test "$ac_cv_sys_large_files" != no
4060         then
4061                 CF_APPEND_TEXT(CPPFLAGS,-D_LARGE_FILES)
4062         fi
4063         if test "$ac_cv_sys_largefile_source" != no
4064         then
4065                 CF_APPEND_TEXT(CPPFLAGS,-D_LARGEFILE_SOURCE)
4066         fi
4067         if test "$ac_cv_sys_file_offset_bits" != no
4068         then
4069                 CF_APPEND_TEXT(CPPFLAGS,-D_FILE_OFFSET_BITS=$ac_cv_sys_file_offset_bits)
4070         fi
4071
4072         AC_CACHE_CHECK(whether to use struct dirent64, cf_cv_struct_dirent64,[
4073                 AC_TRY_COMPILE([
4074 #pragma GCC diagnostic error "-Wincompatible-pointer-types"
4075 #include <sys/types.h>
4076 #include <dirent.h>
4077                 ],[
4078                 /* if transitional largefile support is setup, this is true */
4079                 extern struct dirent64 * readdir(DIR *);
4080                 struct dirent64 *x = readdir((DIR *)0);
4081                 struct dirent *y = readdir((DIR *)0);
4082                 int z = x - y;
4083                 (void)z;
4084                 ],
4085                 [cf_cv_struct_dirent64=yes],
4086                 [cf_cv_struct_dirent64=no])
4087         ])
4088         test "$cf_cv_struct_dirent64" = yes && AC_DEFINE(HAVE_STRUCT_DIRENT64,1,[Define to 1 if we have struct dirent64])
4089         fi
4090 ])
4091 ])
4092 dnl ---------------------------------------------------------------------------
4093 dnl CF_LDFLAGS_STATIC version: 14 updated: 2021/01/02 17:09:14
4094 dnl -----------------
4095 dnl Check for compiler/linker flags used to temporarily force usage of static
4096 dnl libraries.  This depends on the compiler and platform.  Use this to help
4097 dnl ensure that the linker picks up a given library based on its position in
4098 dnl the list of linker options and libraries.
4099 AC_DEFUN([CF_LDFLAGS_STATIC],[
4100
4101 if test "$GCC" = yes ; then
4102         case "$cf_cv_system_name" in
4103         (OS/2*|os2*|aix[[4]]*|solaris2.1[[0-9]]|darwin*)
4104                 LDFLAGS_STATIC=
4105                 LDFLAGS_SHARED=
4106                 ;;
4107         (*)     # normally, except when broken
4108                 LDFLAGS_STATIC=-static
4109                 LDFLAGS_SHARED=-dynamic
4110                 ;;
4111         esac
4112 else
4113         case "$cf_cv_system_name" in
4114         (aix[[4-7]]*)   # from ld manpage
4115                 LDFLAGS_STATIC=-bstatic
4116                 LDFLAGS_SHARED=-bdynamic
4117                 ;;
4118         (hpux*)         # from ld manpage for hpux10.20, hpux11.11
4119                 # We could also use just "archive" and "shared".
4120                 LDFLAGS_STATIC=-Wl,-a,archive_shared
4121                 LDFLAGS_SHARED=-Wl,-a,shared_archive
4122                 ;;
4123         (irix*)         # from ld manpage IRIX64
4124                 LDFLAGS_STATIC=-Bstatic
4125                 LDFLAGS_SHARED=-Bdynamic
4126                 ;;
4127         (osf[[45]]*)    # from ld manpage osf4.0d, osf5.1
4128                 # alternative "-oldstyle_liblookup" (not in cc manpage)
4129                 LDFLAGS_STATIC=-noso
4130                 LDFLAGS_SHARED=-so_archive
4131                 ;;
4132         (solaris2*)
4133                 LDFLAGS_STATIC=-Bstatic
4134                 LDFLAGS_SHARED=-Bdynamic
4135                 ;;
4136         esac
4137 fi
4138
4139 if test -n "$LDFLAGS_STATIC" && test -n "$LDFLAGS_SHARED"
4140 then
4141         AC_MSG_CHECKING(if linker supports switching between static/dynamic)
4142
4143         rm -f libconftest.a
4144         cat >conftest.$ac_ext <<EOF
4145 #line __oline__ "configure"
4146 #include <stdio.h>
4147 int cf_ldflags_static(FILE *fp) { return fflush(fp); }
4148 EOF
4149         if AC_TRY_EVAL(ac_compile) ; then
4150                 ( $AR $ARFLAGS libconftest.a conftest.o ) 2>&AC_FD_CC 1>/dev/null
4151                 ( eval $RANLIB libconftest.a ) 2>&AC_FD_CC >/dev/null
4152         fi
4153         rm -f conftest.*
4154
4155         cf_save_LIBS="$LIBS"
4156
4157         LIBS="$LDFLAGS_STATIC -L`pwd` -lconftest $LDFLAGS_DYNAMIC $LIBS"
4158         AC_TRY_LINK([
4159 #line __oline__ "configure"
4160 #include <stdio.h>
4161 int cf_ldflags_static(FILE *fp);
4162 ],[
4163         return cf_ldflags_static(stdin);
4164 ],[
4165         # some linkers simply ignore the -dynamic
4166         case x`file "conftest$ac_exeext" 2>/dev/null` in
4167         (*static*)
4168                 cf_ldflags_static=no
4169                 ;;
4170         (*)
4171                 cf_ldflags_static=yes
4172                 ;;
4173         esac
4174 ],[cf_ldflags_static=no])
4175
4176         rm -f libconftest.*
4177         LIBS="$cf_save_LIBS"
4178
4179         AC_MSG_RESULT($cf_ldflags_static)
4180
4181         if test "$cf_ldflags_static" != yes
4182         then
4183                 LDFLAGS_STATIC=
4184                 LDFLAGS_SHARED=
4185         fi
4186 else
4187         LDFLAGS_STATIC=
4188         LDFLAGS_SHARED=
4189 fi
4190
4191 AC_SUBST(LDFLAGS_STATIC)
4192 AC_SUBST(LDFLAGS_SHARED)
4193 ])
4194 dnl ---------------------------------------------------------------------------
4195 dnl CF_LD_RPATH_OPT version: 9 updated: 2021/01/01 13:31:04
4196 dnl ---------------
4197 dnl For the given system and compiler, find the compiler flags to pass to the
4198 dnl loader to use the "rpath" feature.
4199 AC_DEFUN([CF_LD_RPATH_OPT],
4200 [
4201 AC_REQUIRE([CF_CHECK_CACHE])
4202
4203 LD_RPATH_OPT=
4204 if test "x$cf_cv_enable_rpath" != xno
4205 then
4206         AC_MSG_CHECKING(for an rpath option)
4207         case "$cf_cv_system_name" in
4208         (irix*)
4209                 if test "$GCC" = yes; then
4210                         LD_RPATH_OPT="-Wl,-rpath,"
4211                 else
4212                         LD_RPATH_OPT="-rpath "
4213                 fi
4214                 ;;
4215         (linux*|gnu*|k*bsd*-gnu|freebsd*)
4216                 LD_RPATH_OPT="-Wl,-rpath,"
4217                 ;;
4218         (openbsd[[2-9]].*|mirbsd*)
4219                 LD_RPATH_OPT="-Wl,-rpath,"
4220                 ;;
4221         (dragonfly*)
4222                 LD_RPATH_OPT="-rpath "
4223                 ;;
4224         (netbsd*)
4225                 LD_RPATH_OPT="-Wl,-rpath,"
4226                 ;;
4227         (osf*|mls+*)
4228                 LD_RPATH_OPT="-rpath "
4229                 ;;
4230         (solaris2*)
4231                 LD_RPATH_OPT="-R"
4232                 ;;
4233         (*)
4234                 ;;
4235         esac
4236         AC_MSG_RESULT($LD_RPATH_OPT)
4237
4238         case "x$LD_RPATH_OPT" in
4239         (x-R*)
4240                 AC_MSG_CHECKING(if we need a space after rpath option)
4241                 cf_save_LIBS="$LIBS"
4242                 CF_ADD_LIBS(${LD_RPATH_OPT}$libdir)
4243                 AC_TRY_LINK(, , cf_rpath_space=no, cf_rpath_space=yes)
4244                 LIBS="$cf_save_LIBS"
4245                 AC_MSG_RESULT($cf_rpath_space)
4246                 test "$cf_rpath_space" = yes && LD_RPATH_OPT="$LD_RPATH_OPT "
4247                 ;;
4248         esac
4249 fi
4250 ])dnl
4251 dnl ---------------------------------------------------------------------------
4252 dnl CF_LD_SEARCHPATH version: 3 updated: 2021/03/05 19:13:35
4253 dnl ----------------
4254 dnl Try to obtain the linker's search-path, for use in scripts.
4255 dnl
4256 dnl Ignore LD_LIBRARY_PATH, etc.
4257 AC_DEFUN([CF_LD_SEARCHPATH],[
4258 AC_CACHE_CHECK(for linker search path,cf_cv_ld_searchpath,[
4259
4260 if test "$cross_compiling" != yes ; then
4261
4262 # GNU binutils' ld does not involve permissions which may stop ldconfig.
4263 cf_pathlist=`ld --verbose 2>/dev/null | grep SEARCH_DIR | sed -e 's,SEARCH_DIR[[("=]][[("=]]*,,g' -e 's/"[[)]];//gp' | sort -u`
4264
4265 # The -NX options tell newer versions of Linux ldconfig to not attempt to
4266 # update the cache, which makes it run faster.
4267 test -z "$cf_pathlist" && \
4268         cf_pathlist=`(ldconfig -NX -v) 2>/dev/null | sed -e '/^[[       ]]/d' -e 's/:$//' | sort -u`
4269
4270 test -z "$cf_pathlist" &&
4271         cf_pathlist=`(ldconfig -v) 2>/dev/null | sed -n -e '/^[[        ]]/d' -e 's/:$//p' | sort -u`
4272
4273 # This works with OpenBSD 6.5, which lists only filenames
4274 test -z "$cf_pathlist" &&
4275         cf_pathlist=`(ldconfig -v) 2>/dev/null | sed -n -e 's,^Adding \(.*\)/.*[$],\1,p' | sort -u`
4276
4277 if test -z "$cf_pathlist"
4278 then
4279         # dyld default path with MacOS
4280         if test -f /usr/bin/otool && test "x`uname -s`" = xDarwin
4281         then
4282                 # do this to bypass check
4283                 cf_cv_ld_searchpath='$HOME/lib'
4284                 cf_pathlist="/usr/local/lib /lib /usr/lib"
4285         fi
4286 fi
4287
4288 if test -z "$cf_pathlist"
4289 then
4290         # Solaris is "SunOS"
4291         if test -f /usr/bin/isainfo && test "x`uname -s`" = xSunOS
4292         then
4293                 case x`(isainfo -b)` in
4294                 (x64)
4295                         cf_pathlist="$cf_pathlist /lib/64 /usr/lib/64"
4296                         ;;
4297                 (x32)
4298                         test -d /usr/ccs/lib && cf_pathlist="$cf_pathlist /usr/ccs/lib"
4299                         cf_pathlist="$cf_pathlist /lib /usr/lib"
4300                         ;;
4301                 (*)
4302                         AC_MSG_WARN(problem with Solaris architecture)
4303                         ;;
4304                 esac
4305         fi
4306 fi
4307
4308 if test -z "$cf_pathlist"
4309 then
4310         # HP-UX
4311         if test x"`uname -s`" = xHP-UX
4312         then
4313                 case x`getconf LONG_BIT` in
4314                 (x64)
4315                         cf_pathlist="/usr/lib/hpux64"
4316                         ;;
4317                 (x*)
4318                         cf_pathlist="/usr/lib/hpux32"
4319                         ;;
4320                 esac
4321         fi
4322 fi
4323
4324 fi
4325
4326 # If nothing else, assume it is conventional
4327 test -z "$cf_pathlist" && cf_pathlist="/usr/lib /lib"
4328
4329 # Finally, check that this is only directories
4330 for cf_path in [$]0 $cf_pathlist
4331 do
4332         if test -d "$cf_path"; then
4333                 test -n "$cf_cv_ld_searchpath" && cf_cv_ld_searchpath="${cf_cv_ld_searchpath} "
4334                 cf_cv_ld_searchpath="${cf_cv_ld_searchpath}${cf_path}"
4335         fi
4336 done
4337
4338 # Ensure that it is nonempty
4339 test -z "$cf_cv_ld_searchpath" && cf_cv_ld_searchpath=/usr/lib
4340 ])
4341
4342 LD_SEARCHPATH=`echo "$cf_cv_ld_searchpath"|sed -e 's/ /|/g'`
4343 AC_SUBST(LD_SEARCHPATH)
4344 ])dnl
4345 dnl ---------------------------------------------------------------------------
4346 dnl CF_LIBRARY_PATH version: 11 updated: 2021/01/01 13:31:04
4347 dnl ---------------
4348 dnl Construct a search-list of directories for a nonstandard library-file
4349 dnl
4350 dnl Parameters
4351 dnl     $1 = the variable to return as result
4352 dnl     $2 = the package name
4353 AC_DEFUN([CF_LIBRARY_PATH],
4354 [
4355 $1=
4356 cf_library_path_list=""
4357 if test -n "${LDFLAGS}${LIBS}" ; then
4358         for cf_library_path in $LDFLAGS $LIBS
4359         do
4360                 case "$cf_library_path" in
4361                 (-L*)
4362                         cf_library_path=`echo ".$cf_library_path" |sed -e 's/^...//' -e 's,/lib$,,'`
4363                         CF_ADD_SUBDIR_PATH($1,$2,lib,$cf_library_path,NONE)
4364                         cf_library_path_list="$cf_library_path_list [$]$1"
4365                         ;;
4366                 esac
4367         done
4368 fi
4369
4370 CF_SUBDIR_PATH($1,$2,lib)
4371
4372 $1="$cf_library_path_list [$]$1"
4373 ])dnl
4374 dnl ---------------------------------------------------------------------------
4375 dnl CF_LIBTOOL_VERSION version: 1 updated: 2013/04/06 18:03:09
4376 dnl ------------------
4377 AC_DEFUN([CF_LIBTOOL_VERSION],[
4378 if test -n "$LIBTOOL" && test "$LIBTOOL" != none
4379 then
4380         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.]].*//'`
4381 else
4382         cf_cv_libtool_version=
4383 fi
4384 test -z "$cf_cv_libtool_version" && unset cf_cv_libtool_version
4385 ])dnl
4386 dnl ---------------------------------------------------------------------------
4387 dnl CF_LIB_PREFIX version: 14 updated: 2021/01/01 13:31:04
4388 dnl -------------
4389 dnl Compute the library-prefix for the given host system
4390 dnl $1 = variable to set
4391 define([CF_LIB_PREFIX],
4392 [
4393         case "$cf_cv_system_name" in
4394         (OS/2*|os2*)
4395                 if test "$DFT_LWR_MODEL" = libtool; then
4396                         LIB_PREFIX='lib'
4397                 else
4398                         LIB_PREFIX=''
4399                 fi
4400                 ;;
4401         (*-msvc*)
4402                 LIB_PREFIX=''
4403                 ;;
4404         (*)     LIB_PREFIX='lib'
4405                 ;;
4406         esac
4407 ifelse($1,,,[$1=$LIB_PREFIX])
4408         AC_SUBST(LIB_PREFIX)
4409 ])dnl
4410 dnl ---------------------------------------------------------------------------
4411 dnl CF_LIB_RULES version: 97 updated: 2021/07/17 13:10:54
4412 dnl ------------
4413 dnl Append definitions and rules for the given models to the subdirectory
4414 dnl Makefiles, and the recursion rule for the top-level Makefile.  If the
4415 dnl subdirectory is a library-source directory, modify the Libs_To_Make list in
4416 dnl the corresponding makefile to list the models that we'll generate.
4417 dnl
4418 dnl For shared libraries, make a list of symbolic links to construct when
4419 dnl generating each library.  The convention used for Linux is the simplest
4420 dnl one:
4421 dnl     lib<name>.so    ->
4422 dnl     lib<name>.so.<major>    ->
4423 dnl     lib<name>.so.<maj>.<minor>
4424 dnl
4425 dnl Note: Libs_To_Make is mixed case, since it is not a pure autoconf variable.
4426 AC_DEFUN([CF_LIB_RULES],
4427 [AC_REQUIRE([AC_PROG_FGREP])dnl
4428 AC_REQUIRE([CF_MAKE_PHONY])dnl
4429
4430 cf_prefix=$LIB_PREFIX
4431 AC_REQUIRE([CF_SUBST_NCURSES_VERSION])
4432
4433 case "$cf_cv_shlib_version" in
4434 (cygdll|msysdll|mingw|msvcdll)
4435         TINFO_NAME=$TINFO_ARG_SUFFIX
4436         TINFO_SUFFIX=.dll
4437         ;;
4438 esac
4439
4440 if test -n "$TINFO_SUFFIX" ; then
4441         case "$TINFO_SUFFIX" in
4442         (tw*)
4443                 TINFO_NAME="${TINFO_NAME}tw${EXTRA_SUFFIX}"
4444                 TINFO_SUFFIX=`echo "$TINFO_SUFFIX" | sed 's/^tw'$EXTRA_SUFFIX'//'`
4445                 ;;
4446         (t*)
4447                 TINFO_NAME="${TINFO_NAME}t${EXTRA_SUFFIX}"
4448                 TINFO_SUFFIX=`echo "$TINFO_SUFFIX" | sed 's/^t'$EXTRA_SUFFIX'//'`
4449                 ;;
4450         (w*)
4451                 TINFO_NAME="${TINFO_NAME}w${EXTRA_SUFFIX}"
4452                 TINFO_SUFFIX=`echo "$TINFO_SUFFIX" | sed 's/^w'$EXTRA_SUFFIX'//'`
4453                 ;;
4454         esac
4455 fi
4456
4457 for cf_dir in $SRC_SUBDIRS
4458 do
4459         if test ! -d "$srcdir/$cf_dir" ; then
4460                 continue
4461         elif test -f "$srcdir/$cf_dir/modules" ; then
4462
4463                 SHARED_LIB=
4464                 Libs_To_Make=
4465                 cf_awk_program=
4466                 if test -n "${cf_cv_abi_version}" && test "x${cf_cv_abi_version}" != "x5"
4467                 then
4468                         cf_awk_program="$cf_awk_program\
4469 /deprecated in ABI${cf_cv_abi_version}/ { next; }\
4470 { sub(\"NCURSES([[WT]]+)?\", \"&${cf_cv_abi_version}\"); }\
4471 "
4472                 fi
4473
4474                 if test "x$WILDCARD_SYMS" = xno
4475                 then
4476                         cf_awk_program="$cf_awk_program\
4477 /[[     ]]_\\*;/ { skip=1; next; }\
4478 "
4479                 fi
4480
4481                 if test "x$cf_awk_program" != "x"
4482                 then
4483                         cat >>$cf_dir/Makefile <<CF_EOF
4484
4485 # Generated by CF_LIB_RULES
4486 resulting.map: $UNALTERED_SYMS
4487         $AWK 'BEGIN { skip = 1; last=""; } \
4488 $cf_awk_program \
4489 { if ( last != "" && ( skip == 0 || \[$]\[$]0 !~ /}/ ) ) { print last; }\
4490  skip = 0; last = \[$]\[$]0; } \
4491 END { print last; }' < "$UNALTERED_SYMS" >\[$]@
4492
4493 distclean::
4494         rm -f resulting.map
4495 CF_EOF
4496                 fi
4497
4498                 for cf_item in $cf_LIST_MODELS
4499                 do
4500                         CF_LIB_SUFFIX($cf_item,cf_suffix,cf_depsuf)
4501                         if test "$cf_dir" = "c++"
4502                         then
4503                                 CF_MAP_LIB_BASENAME(cf_libname,cxx)
4504                         else
4505                                 CF_MAP_LIB_BASENAME(cf_libname,$cf_dir)
4506                         fi
4507                         test -z "$cf_libname" && cf_libname="$cf_dir"
4508                         if test "$cf_item" = shared ; then
4509                                 if test -n "${LIB_SUFFIX}"
4510                                 then
4511                                         cf_shared_suffix=`echo "$cf_suffix" | sed 's/^'"${USE_LIB_SUFFIX}"'//'`
4512                                 else
4513                                         cf_shared_suffix="$cf_suffix"
4514                                 fi
4515                                 if test "$cf_cv_do_symlinks" = yes ; then
4516                                         cf_version_name=
4517
4518                                         case "$cf_cv_shlib_version" in
4519                                         (rel)
4520                                                 cf_version_name=REL_VERSION
4521                                                 ;;
4522                                         (abi)
4523                                                 cf_version_name=ABI_VERSION
4524                                                 ;;
4525                                         esac
4526
4527                                         if test -n "$cf_version_name"
4528                                         then
4529                                                 case "$cf_cv_system_name" in
4530                                                 (darwin*)
4531                                                         # "w", etc?
4532                                                         cf_suffix="${USE_LIB_SUFFIX}"'.${'$cf_version_name'}'"$cf_shared_suffix"
4533                                                         ;;
4534                                                 (*)
4535                                                         cf_suffix="$cf_suffix"'.${'$cf_version_name'}'
4536                                                         ;;
4537                                                 esac
4538                                         fi
4539                                         if test -n "${USE_LIB_SUFFIX}"
4540                                         then
4541                                                 cf_shared_suffix=`echo "$cf_suffix" | sed 's/^'"${USE_LIB_SUFFIX}"'//'`
4542                                         else
4543                                                 cf_shared_suffix="$cf_suffix"
4544                                         fi
4545                                 fi
4546                                 # cygwin needs import library, and has unique naming convention
4547                                 # use autodetected ${cf_prefix} for import lib and static lib, but
4548                                 # use 'cyg' prefix for shared lib.
4549                                 case "$cf_cv_shlib_version" in
4550                                 (cygdll)
4551                                         cf_cygsuf=`echo "$cf_suffix" | sed -e 's/\.dll/\${ABI_VERSION}.dll/'`
4552                                         cf_add_lib="../lib/cyg${cf_libname}${cf_cygsuf}"
4553                                         ;;
4554                                 (msysdll)
4555                                         cf_cygsuf=`echo "$cf_suffix" | sed -e 's/\.dll/\${ABI_VERSION}.dll/'`
4556                                         cf_add_lib="../lib/msys-${cf_libname}${cf_cygsuf}"
4557                                         ;;
4558                                 (mingw)
4559                                         cf_cygsuf=`echo "$cf_suffix" | sed -e 's/\.dll/\${ABI_VERSION}.dll/'`
4560                                         cf_add_lib="../lib/lib${cf_libname}${cf_cygsuf}"
4561                                         ;;
4562                                 (msvcdll)
4563                                         cf_cygsuf=`echo "$cf_suffix" | sed -e 's/\.dll/\${ABI_VERSION}.dll/'`
4564                                         cf_add_lib="../lib/${cf_libname}${cf_cygsuf}"
4565                                         ;;
4566                                 (*)
4567                                         cf_add_lib=
4568                                         ;;
4569                                 esac
4570                                 if test -n "$cf_add_lib"
4571                                 then
4572                                         Libs_To_Make="$Libs_To_Make $cf_add_lib"
4573                                         continue
4574                                 fi
4575                         fi
4576                         cf_add_lib="../lib/${cf_prefix}${cf_libname}${cf_suffix}"
4577                         Libs_To_Make="$Libs_To_Make $cf_add_lib"
4578                 done
4579
4580                 if test "$cf_dir" = ncurses ; then
4581                         cf_subsets="$LIB_SUBSETS"
4582                         cf_r_parts="$cf_subsets"
4583                         cf_liblist="$Libs_To_Make"
4584
4585                         while test -n "$cf_r_parts"
4586                         do
4587                                 cf_l_parts=`echo "$cf_r_parts" |sed -e 's/ .*$//'`
4588                                 cf_r_parts=`echo "$cf_r_parts" |sed -e 's/^[[^ ]]* //'`
4589                                 if test "$cf_l_parts" != "$cf_r_parts" ; then
4590                                         cf_add_lib=
4591                                         case "$cf_l_parts" in
4592                                         (*termlib*)
4593                                                 cf_add_lib=`echo "$cf_liblist" |sed -e s%${LIB_NAME}${USE_LIB_SUFFIX}%${TINFO_LIB_SUFFIX}%g`
4594                                                 ;;
4595                                         (*ticlib*)
4596                                                 cf_add_lib=`echo "$cf_liblist" |sed -e s%${LIB_NAME}${USE_LIB_SUFFIX}%${TICS_LIB_SUFFIX}%g`
4597                                                 ;;
4598                                         (*)
4599                                                 break
4600                                                 ;;
4601                                         esac
4602                                         if test -n "$cf_add_lib"; then
4603                                                 Libs_To_Make="$cf_add_lib $Libs_To_Make"
4604                                         fi
4605                                 else
4606                                         break
4607                                 fi
4608                         done
4609                 else
4610                         cf_subsets=`echo "$LIB_SUBSETS" | sed -e 's/^termlib.* //'`
4611                 fi
4612
4613                 if test "$cf_dir" = c++; then
4614                         if test "x$with_shared_cxx" != xyes && test -n "$cf_shared_suffix"; then
4615                                 cf_list=
4616                                 for cf_item in $Libs_To_Make
4617                                 do
4618                                         case "$cf_item" in
4619                                         (*.a)
4620                                                 ;;
4621                                         (*)
4622                                                 cf_item=`echo "$cf_item" | sed -e "s,"$cf_shared_suffix",.a,"`
4623                                                 ;;
4624                                         esac
4625                                         for cf_test in $cf_list
4626                                         do
4627                                                 if test "$cf_test" = "$cf_item"
4628                                                 then
4629                                                         cf_LIST_MODELS=`echo "$cf_LIST_MODELS" | sed -e 's/normal//'`
4630                                                         cf_item=
4631                                                         break
4632                                                 fi
4633                                         done
4634                                         test -n "$cf_item" && cf_list="$cf_list $cf_item"
4635                                 done
4636                                 Libs_To_Make="$cf_list"
4637                         fi
4638                 fi
4639
4640                 sed -e "s%@Libs_To_Make@%$Libs_To_Make%" \
4641                     -e "s%@SHARED_LIB@%$SHARED_LIB%" \
4642                         "$cf_dir/Makefile" >$cf_dir/Makefile.out
4643                 mv "$cf_dir/Makefile.out" "$cf_dir/Makefile"
4644
4645                 $AWK -f "$srcdir/mk-0th.awk" \
4646                         libname="${cf_dir}${LIB_SUFFIX}" subsets="$LIB_SUBSETS" ticlib="$TICS_LIB_SUFFIX" termlib="$TINFO_LIB_SUFFIX" \
4647                         "$srcdir/$cf_dir/modules" >>$cf_dir/Makefile
4648
4649                 for cf_subset in $cf_subsets
4650                 do
4651                         cf_subdirs=
4652                         for cf_item in $cf_LIST_MODELS
4653                         do
4654
4655                         echo "Appending rules for ${cf_item} model (${cf_dir}: ${cf_subset})"
4656                         CF_UPPER(cf_ITEM,$cf_item)
4657
4658                         CXX_MODEL=$cf_ITEM
4659                         if test "$CXX_MODEL" = SHARED; then
4660                                 case "$cf_cv_shlib_version" in
4661                                 (cygdll|msysdll|mingw|msvcdll)
4662                                         test "x$with_shared_cxx" = xno && CF_VERBOSE(overriding CXX_MODEL to SHARED)
4663                                         with_shared_cxx=yes
4664                                         ;;
4665                                 (*)
4666                                         test "x$with_shared_cxx" = xno && CXX_MODEL=NORMAL
4667                                         ;;
4668                                 esac
4669                         fi
4670
4671                         CF_LIB_SUFFIX($cf_item,cf_suffix,cf_depsuf)
4672                         CF_OBJ_SUBDIR($cf_item,cf_subdir)
4673
4674                         # Test for case where we build libtinfo with a different name.
4675                         cf_libname=$cf_dir
4676                         if test "$cf_dir" = ncurses ; then
4677                                 case "$cf_subset" in
4678                                 (*base*)
4679                                         cf_libname=${cf_libname}$USE_LIB_SUFFIX
4680                                         ;;
4681                                 (*termlib*)
4682                                         cf_libname=$TINFO_LIB_SUFFIX
4683                                         ;;
4684                                 (ticlib*)
4685                                         cf_libname=$TICS_LIB_SUFFIX
4686                                         ;;
4687                                 esac
4688                         elif test "$cf_dir" = c++ ; then
4689                                 CF_MAP_LIB_BASENAME(cf_libname,cxx)
4690                                 cf_libname=${cf_libname}$USE_LIB_SUFFIX
4691                         else
4692                                 CF_MAP_LIB_BASENAME(cf_libname,$cf_dir)
4693                                 cf_libname=${cf_libname}$USE_LIB_SUFFIX
4694                         fi
4695                         if test -n "${USE_ARG_SUFFIX}" ; then
4696                                 # undo $USE_LIB_SUFFIX add-on in CF_LIB_SUFFIX
4697                                 cf_suffix=`echo "$cf_suffix" |sed -e "s%^${USE_LIB_SUFFIX}%%"`
4698                         fi
4699
4700                         # These dependencies really are for development, not
4701                         # builds, but they are useful in porting, too.
4702                         cf_depend="../include/ncurses_cfg.h"
4703                         if test "$srcdir" = "."; then
4704                                 cf_reldir="."
4705                         else
4706                                 cf_reldir="\${srcdir}"
4707                         fi
4708
4709                         if test -f "$srcdir/$cf_dir/$cf_dir.priv.h" ; then
4710                                 cf_depend="$cf_depend $cf_reldir/$cf_dir.priv.h"
4711                         elif test -f "$srcdir/$cf_dir/curses.priv.h" ; then
4712                                 cf_depend="$cf_depend $cf_reldir/curses.priv.h"
4713                         fi
4714
4715                         cf_dir_suffix=
4716                         old_cf_suffix="$cf_suffix"
4717                         if test "$cf_cv_shlib_version_infix" = yes ; then
4718                         if test -n "$USE_LIB_SUFFIX" ; then
4719                                 case "$USE_LIB_SUFFIX" in
4720                                 (tw*)
4721                                         cf_libname=`echo "$cf_libname" | sed 's/tw'$EXTRA_SUFFIX'$//'`
4722                                         cf_suffix=`echo "$cf_suffix" | sed 's/^tw'$EXTRA_SUFFIX'//'`
4723                                         cf_dir_suffix=tw$EXTRA_SUFFIX
4724                                         ;;
4725                                 (t*)
4726                                         cf_libname=`echo "$cf_libname" | sed 's/t'$EXTRA_SUFFIX'$//'`
4727                                         cf_suffix=`echo "$cf_suffix" | sed 's/^t'$EXTRA_SUFFIX'//'`
4728                                         cf_dir_suffix=t$EXTRA_SUFFIX
4729                                         ;;
4730                                 (w*)
4731                                         cf_libname=`echo "$cf_libname" | sed 's/w'$EXTRA_SUFFIX'$//'`
4732                                         cf_suffix=`echo "$cf_suffix" | sed 's/^w'$EXTRA_SUFFIX'//'`
4733                                         cf_dir_suffix=w$EXTRA_SUFFIX
4734                                         ;;
4735                                 (*)
4736                                         cf_libname=`echo "$cf_libname" | sed 's/'$EXTRA_SUFFIX'$//'`
4737                                         cf_suffix=`echo "$cf_suffix" | sed 's/^'$EXTRA_SUFFIX'//'`
4738                                         cf_dir_suffix=$EXTRA_SUFFIX
4739                                         ;;
4740                                 esac
4741                         fi
4742                         fi
4743
4744                         $AWK -f "$srcdir/mk-1st.awk" \
4745                                 name=${cf_libname}${cf_dir_suffix} \
4746                                 traces=$LIB_TRACING \
4747                                 MODEL=$cf_ITEM \
4748                                 CXX_MODEL=$CXX_MODEL \
4749                                 LIB_SUFFIX=$LIB_SUFFIX \
4750                                 USE_LIB_SUFFIX=$USE_LIB_SUFFIX \
4751                                 make_phony="${cf_cv_make_PHONY:-no}" \
4752                                 model=$cf_subdir \
4753                                 prefix=$cf_prefix \
4754                                 suffix=$cf_suffix \
4755                                 subset=$cf_subset \
4756                                 driver=$cf_cv_term_driver \
4757                                 SymLink="$LN_S" \
4758                                 TermlibRoot=$TINFO_NAME \
4759                                 TermlibSuffix=$TINFO_SUFFIX \
4760                                 ShlibVer=$cf_cv_shlib_version \
4761                                 ShlibVerInfix=$cf_cv_shlib_version_infix \
4762                                 ReLink=${cf_cv_do_relink:-no} \
4763                                 ReRanlib=${cf_cv_do_reranlib:-yes} \
4764                                 DoLinks=$cf_cv_do_symlinks \
4765                                 rmSoLocs=$cf_cv_rm_so_locs \
4766                                 ldconfig="$LDCONFIG" \
4767                                 overwrite=$WITH_OVERWRITE \
4768                                 depend="$cf_depend" \
4769                                 host="$host" \
4770                                 libtool_version="$LIBTOOL_VERSION" \
4771                                 "$srcdir/$cf_dir/modules" >>$cf_dir/Makefile
4772
4773                         cf_suffix="$old_cf_suffix"
4774
4775                         for cf_subdir2 in $cf_subdirs lib
4776                         do
4777                                 test "$cf_subdir" = "$cf_subdir2" && break
4778                         done
4779                         test "${cf_subset}.${cf_subdir2}" != "${cf_subset}.${cf_subdir}" && \
4780                         $AWK -f "$srcdir/mk-2nd.awk" \
4781                                 name=$cf_dir \
4782                                 traces=$LIB_TRACING \
4783                                 MODEL=$cf_ITEM \
4784                                 model=$cf_subdir \
4785                                 subset=$cf_subset \
4786                                 srcdir=$srcdir \
4787                                 echo=$WITH_ECHO \
4788                                 crenames=$cf_cv_prog_CC_c_o \
4789                                 cxxrenames=$cf_cv_prog_CXX_c_o \
4790                                 "$srcdir/$cf_dir/modules" >>$cf_dir/Makefile
4791                         cf_subdirs="$cf_subdirs $cf_subdir"
4792                         done
4793                 done
4794         fi
4795
4796         echo '  ( cd '$cf_dir' && ${MAKE} ${TOP_MFLAGS} [$]@ )' >>Makefile
4797 done
4798
4799 echo >> Makefile
4800 echo '# generated by CF_LIB_RULES' >> Makefile
4801
4802 if test "x$cf_cv_make_PHONY" = xyes ; then
4803         cat >> Makefile <<-CF_EOF
4804
4805         .PHONY :        libs
4806         .PHONY :        lintlib
4807         .PHONY :        install.includes
4808         .PHONY :        uninstall.includes
4809         .PHONY :        install.libs
4810         .PHONY :        uninstall.libs
4811 CF_EOF
4812 fi
4813
4814 for cf_dir in $SRC_SUBDIRS
4815 do
4816         if test ! -d "$srcdir/$cf_dir" ; then
4817                 continue
4818         fi
4819
4820         if test -f "$cf_dir/Makefile" ; then
4821                 case "$cf_dir" in
4822                 (Ada95)
4823                         echo 'libs \' >> Makefile
4824                         echo 'install.libs \' >> Makefile
4825                         echo 'uninstall.libs ::' >> Makefile
4826                         echo '  ( cd '$cf_dir' && ${MAKE} ${TOP_MFLAGS} [$]@ )' >> Makefile
4827                         ;;
4828                 esac
4829         fi
4830
4831         if test -f "$srcdir/$cf_dir/modules" ; then
4832
4833                 if test "x$cf_cv_make_PHONY" = xyes ; then
4834                         cat >> Makefile <<-CF_EOF
4835
4836                         .PHONY :        install.$cf_dir
4837                         .PHONY :        uninstall.$cf_dir
4838 CF_EOF
4839                 fi
4840
4841                 echo >> Makefile
4842                 if test -f "$srcdir/$cf_dir/headers" ; then
4843 cat >> Makefile <<CF_EOF
4844 install.includes \\
4845 uninstall.includes \\
4846 CF_EOF
4847                 fi
4848
4849 cat >> Makefile <<CF_EOF
4850 lint \\
4851 libs \\
4852 lintlib \\
4853 install.libs \\
4854 uninstall.libs \\
4855 install.$cf_dir \\
4856 uninstall.$cf_dir ::
4857         ( cd "$cf_dir" && \${MAKE} \${TOP_MFLAGS} \[$]@ )
4858 CF_EOF
4859         elif test -f "$srcdir/$cf_dir/headers" ; then
4860 cat >> Makefile <<CF_EOF
4861
4862 libs \\
4863 install.libs \\
4864 uninstall.libs \\
4865 install.includes \\
4866 uninstall.includes ::
4867         ( cd "$cf_dir" && \${MAKE} \${TOP_MFLAGS} \[$]@ )
4868 CF_EOF
4869 fi
4870 done
4871
4872 if test "x$cf_cv_make_PHONY" = xyes ; then
4873         cat >> Makefile <<-CF_EOF
4874
4875         .PHONY :        install.data
4876         .PHONY :        uninstall.data
4877 CF_EOF
4878 fi
4879
4880 if test "x$cf_with_db_install" = xyes; then
4881 cat >> Makefile <<CF_EOF
4882
4883 install.libs uninstall.libs \\
4884 install.data uninstall.data ::
4885 $MAKE_TERMINFO  ( cd misc && \${MAKE} \${TOP_MFLAGS} \[$]@ )
4886 CF_EOF
4887 else
4888 cat >> Makefile <<CF_EOF
4889
4890 install.libs uninstall.libs ::
4891         ( cd misc && \${MAKE} \${TOP_MFLAGS} \[$]@ )
4892 CF_EOF
4893 fi
4894
4895 if test "x$cf_with_manpages" = xyes; then
4896
4897 if test "x$cf_cv_make_PHONY" = xyes ; then
4898         cat >> Makefile <<-CF_EOF
4899
4900         .PHONY :        install.man
4901         .PHONY :        uninstall.man
4902 CF_EOF
4903 fi
4904
4905 cat >> Makefile <<CF_EOF
4906
4907 install.man \\
4908 uninstall.man ::
4909         ( cd man && \${MAKE} \${TOP_MFLAGS} \[$]@ )
4910 CF_EOF
4911 fi
4912
4913 cat >> Makefile <<CF_EOF
4914
4915 distclean ::
4916         rm -f config.cache config.log config.status Makefile include/ncurses_cfg.h
4917         rm -f headers.sh headers.sed mk_shared_lib.sh
4918         rm -f edit_man.* man_alias.*
4919         rm -rf \${DIRS_TO_MAKE}
4920 CF_EOF
4921
4922 # Special case: tack's manpage lives in its own directory.
4923 if test "x$cf_with_manpages" = xyes; then
4924 if test "x$cf_with_tack" = "xyes"; then
4925 cat >> Makefile <<CF_EOF
4926
4927 install.man \\
4928 uninstall.man ::
4929         ( cd tack && \${MAKE} \${TOP_MFLAGS} \[$]@ )
4930 CF_EOF
4931 fi
4932 fi
4933
4934 dnl If we're installing into a subdirectory of /usr/include, etc., we should
4935 dnl prepend the subdirectory's name to the "#include" paths.  It won't hurt
4936 dnl anything, and will make it more standardized.  It's awkward to decide this
4937 dnl at configuration because of quoting, so we'll simply make all headers
4938 dnl installed via a script that can do the right thing.
4939
4940 rm -f headers.sed headers.sh
4941
4942 dnl ( generating this script makes the makefiles a little tidier :-)
4943 echo creating headers.sh
4944 cat >headers.sh <<CF_EOF
4945 #! $SHELL
4946 # This shell script is generated by the 'configure' script.  It is invoked in a
4947 # subdirectory of the build tree.  It generates a sed-script in the parent
4948 # directory that is used to adjust includes for header files that reside in a
4949 # subdirectory of /usr/include, etc.
4950 PRG=""
4951 while test \[$]# != 3
4952 do
4953 PRG="\$PRG \[$]1"; shift
4954 done
4955 DST=\[$]1
4956 REF=\[$]2
4957 SRC=\[$]3
4958 TMPSRC=\${TMPDIR:-/tmp}/\`basename \$SRC\`\$\$
4959 TMPSED=\${TMPDIR:-/tmp}/headers.sed\$\$
4960 echo installing \$SRC in \$DST
4961 CF_EOF
4962
4963 if test "$WITH_CURSES_H" = yes; then
4964         cat >>headers.sh <<CF_EOF
4965 case \$DST in
4966 (/*/include/*)
4967         END=\`basename \$DST\`
4968         for i in \`cat \$REF/../*/headers |${FGREP-fgrep} -v "#"\`
4969         do
4970                 NAME=\`basename \$i\`
4971                 echo "s/<\$NAME>/<\$END\/\$NAME>/" >> \$TMPSED
4972         done
4973         ;;
4974 (*)
4975         echo "" >> \$TMPSED
4976         ;;
4977 esac
4978 CF_EOF
4979
4980 else
4981         cat >>headers.sh <<CF_EOF
4982 case \$DST in
4983 (/*/include/*)
4984         END=\`basename \$DST\`
4985         for i in \`cat \$REF/../*/headers |${FGREP-fgrep} -v "#"\`
4986         do
4987                 NAME=\`basename \$i\`
4988                 if test "\$NAME" = "curses.h"
4989                 then
4990                         echo "s/<curses.h>/<ncurses.h>/" >> \$TMPSED
4991                         NAME=ncurses.h
4992                 fi
4993                 echo "s/<\$NAME>/<\$END\/\$NAME>/" >> \$TMPSED
4994         done
4995         ;;
4996 (*)
4997         echo "s/<curses.h>/<ncurses.h>/" >> \$TMPSED
4998         ;;
4999 esac
5000 CF_EOF
5001 fi
5002 cat >>headers.sh <<CF_EOF
5003 rm -f \$TMPSRC
5004 sed -f \$TMPSED \$SRC > \$TMPSRC
5005 NAME=\`basename \$SRC\`
5006 CF_EOF
5007 if test "$WITH_CURSES_H" != yes; then
5008         cat >>headers.sh <<CF_EOF
5009 test "\$NAME" = "curses.h" && NAME=ncurses.h
5010 CF_EOF
5011 fi
5012 cat >>headers.sh <<CF_EOF
5013 # Just in case someone gzip'd manpages, remove the conflicting copy.
5014 test -f \$DST/\$NAME.gz && rm -f \$DST/\$NAME.gz
5015
5016 eval \$PRG \$TMPSRC \$DST/\$NAME
5017 rm -f \$TMPSRC \$TMPSED
5018 CF_EOF
5019
5020 chmod 0755 headers.sh
5021
5022 for cf_dir in $SRC_SUBDIRS
5023 do
5024         if test ! -d "$srcdir/$cf_dir" ; then
5025                 continue
5026         fi
5027
5028         if test -f "$srcdir/$cf_dir/headers" ; then
5029                 $AWK -f "$srcdir/mk-hdr.awk" \
5030                         subset="$LIB_SUBSETS" \
5031                         compat="$WITH_CURSES_H" \
5032                         "$srcdir/$cf_dir/headers" >>$cf_dir/Makefile
5033         fi
5034
5035         if test -f "$srcdir/$cf_dir/modules" ; then
5036                 if test "$cf_dir" != "c++" ; then
5037                         if test "x$cf_cv_make_PHONY" = xyes ; then
5038                                 cat >> $cf_dir/Makefile <<-CF_EOF
5039
5040                                 .PHONY :        depend
5041 CF_EOF
5042                         fi
5043
5044                         cat >>$cf_dir/Makefile <<"CF_EOF"
5045 depend : ${AUTO_SRC}
5046         makedepend -- ${CPPFLAGS} -- ${C_SRC}
5047
5048 # DO NOT DELETE THIS LINE -- make depend depends on it.
5049 CF_EOF
5050                 fi
5051         fi
5052 done
5053 AC_SUBST(Libs_To_Make)
5054 ])dnl
5055 dnl ---------------------------------------------------------------------------
5056 dnl CF_LIB_SONAME version: 9 updated: 2021/01/04 18:48:01
5057 dnl -------------
5058 dnl Find the and soname for the given shared library.  Set the cache variable
5059 dnl cf_cv_$3_soname to this, unless it is not found.  Then set the cache
5060 dnl variable to "unknown".
5061 dnl
5062 dnl $1 = headers
5063 dnl $2 = code
5064 dnl $3 = library name
5065 AC_DEFUN([CF_LIB_SONAME],
5066 [AC_REQUIRE([AC_PROG_FGREP])dnl
5067