aclocal.m4

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