Ada95/aclocal.m4

   1 dnl***************************************************************************
   2 dnl Copyright 2018-2022,2023 Thomas E. Dickey                                *
   3 dnl Copyright 2010-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
  31 dnl
  32 dnl $Id: aclocal.m4,v 1.199 2023/01/22 18:37:42 tom Exp $
  33 dnl Macros used in NCURSES Ada95 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 CF_ACVERSION_CHECK version: 5 updated: 2014/06/04 19:11:49
  46 dnl ------------------
  47 dnl Conditionally generate script according to whether we're using a given autoconf.
  48 dnl
  49 dnl $1 = version to compare against
  50 dnl $2 = code to use if AC_ACVERSION is at least as high as $1.
  51 dnl $3 = code to use if AC_ACVERSION is older than $1.
  52 define([CF_ACVERSION_CHECK],
  53 [
  54 ifdef([AC_ACVERSION], ,[ifdef([AC_AUTOCONF_VERSION],[m4_copy([AC_AUTOCONF_VERSION],[AC_ACVERSION])],[m4_copy([m4_PACKAGE_VERSION],[AC_ACVERSION])])])dnl
  55 ifdef([m4_version_compare],
  56 [m4_if(m4_version_compare(m4_defn([AC_ACVERSION]), [$1]), -1, [$3], [$2])],
  57 [CF_ACVERSION_COMPARE(
  58 AC_PREREQ_CANON(AC_PREREQ_SPLIT([$1])),
  59 AC_PREREQ_CANON(AC_PREREQ_SPLIT(AC_ACVERSION)), AC_ACVERSION, [$2], [$3])])])dnl
  60 dnl ---------------------------------------------------------------------------
  61 dnl CF_ACVERSION_COMPARE version: 3 updated: 2012/10/03 18:39:53
  62 dnl --------------------
  63 dnl CF_ACVERSION_COMPARE(MAJOR1, MINOR1, TERNARY1,
  64 dnl                      MAJOR2, MINOR2, TERNARY2,
  65 dnl                      PRINTABLE2, not FOUND, FOUND)
  66 define([CF_ACVERSION_COMPARE],
  67 [ifelse(builtin([eval], [$2 < $5]), 1,
  68 [ifelse([$8], , ,[$8])],
  69 [ifelse([$9], , ,[$9])])])dnl
  70 dnl ---------------------------------------------------------------------------
  71 dnl CF_ADA_INCLUDE_DIRS version: 8 updated: 2013/10/14 04:24:07
  72 dnl -------------------
  73 dnl Construct the list of include-options for the C programs in the Ada95
  74 dnl binding.
  75 AC_DEFUN([CF_ADA_INCLUDE_DIRS],
  76 [
  77 ACPPFLAGS="-I. -I../include -I../../include $ACPPFLAGS"
  78 if test "$srcdir" != "."; then
  79         ACPPFLAGS="-I\${srcdir}/../../include $ACPPFLAGS"
  80 fi
  81 if test "$GCC" != yes; then
  82         ACPPFLAGS="$ACPPFLAGS -I\${includedir}"
  83 elif test "$includedir" != "/usr/include"; then
  84         if test "$includedir" = '${prefix}/include' ; then
  85                 if test x$prefix != x/usr ; then
  86                         ACPPFLAGS="$ACPPFLAGS -I\${includedir}"
  87                 fi
  88         else
  89                 ACPPFLAGS="$ACPPFLAGS -I\${includedir}"
  90         fi
  91 fi
  92 AC_SUBST(ACPPFLAGS)
  93 ])dnl
  94 dnl ---------------------------------------------------------------------------
  95 dnl CF_ADD_ADAFLAGS version: 1 updated: 2010/06/19 15:22:18
  96 dnl ---------------
  97 dnl Add to $ADAFLAGS, which is substituted into makefile and scripts.
  98 AC_DEFUN([CF_ADD_ADAFLAGS],[
  99         ADAFLAGS="$ADAFLAGS $1"
 100         AC_SUBST(ADAFLAGS)
 101 ])dnl
 102 dnl ---------------------------------------------------------------------------
 103 dnl CF_ADD_CFLAGS version: 15 updated: 2020/12/31 10:54:15
 104 dnl -------------
 105 dnl Copy non-preprocessor flags to $CFLAGS, preprocessor flags to $CPPFLAGS
 106 dnl $1 = flags to add
 107 dnl $2 = if given makes this macro verbose.
 108 dnl
 109 dnl Put any preprocessor definitions that use quoted strings in $EXTRA_CPPFLAGS,
 110 dnl to simplify use of $CPPFLAGS in compiler checks, etc., that are easily
 111 dnl confused by the quotes (which require backslashes to keep them usable).
 112 AC_DEFUN([CF_ADD_CFLAGS],
 113 [
 114 cf_fix_cppflags=no
 115 cf_new_cflags=
 116 cf_new_cppflags=
 117 cf_new_extra_cppflags=
 118
 119 for cf_add_cflags in $1
 120 do
 121 case "$cf_fix_cppflags" in
 122 (no)
 123         case "$cf_add_cflags" in
 124         (-undef|-nostdinc*|-I*|-D*|-U*|-E|-P|-C)
 125                 case "$cf_add_cflags" in
 126                 (-D*)
 127                         cf_tst_cflags=`echo "${cf_add_cflags}" |sed -e 's/^-D[[^=]]*='\''\"[[^"]]*//'`
 128
 129                         test "x${cf_add_cflags}" != "x${cf_tst_cflags}" \
 130                                 && test -z "${cf_tst_cflags}" \
 131                                 && cf_fix_cppflags=yes
 132
 133                         if test "$cf_fix_cppflags" = yes ; then
 134                                 CF_APPEND_TEXT(cf_new_extra_cppflags,$cf_add_cflags)
 135                                 continue
 136                         elif test "${cf_tst_cflags}" = "\"'" ; then
 137                                 CF_APPEND_TEXT(cf_new_extra_cppflags,$cf_add_cflags)
 138                                 continue
 139                         fi
 140                         ;;
 141                 esac
 142                 case "$CPPFLAGS" in
 143                 (*$cf_add_cflags)
 144                         ;;
 145                 (*)
 146                         case "$cf_add_cflags" in
 147                         (-D*)
 148                                 cf_tst_cppflags=`echo "x$cf_add_cflags" | sed -e 's/^...//' -e 's/=.*//'`
 149                                 CF_REMOVE_DEFINE(CPPFLAGS,$CPPFLAGS,$cf_tst_cppflags)
 150                                 ;;
 151                         esac
 152                         CF_APPEND_TEXT(cf_new_cppflags,$cf_add_cflags)
 153                         ;;
 154                 esac
 155                 ;;
 156         (*)
 157                 CF_APPEND_TEXT(cf_new_cflags,$cf_add_cflags)
 158                 ;;
 159         esac
 160         ;;
 161 (yes)
 162         CF_APPEND_TEXT(cf_new_extra_cppflags,$cf_add_cflags)
 163
 164         cf_tst_cflags=`echo "${cf_add_cflags}" |sed -e 's/^[[^"]]*"'\''//'`
 165
 166         test "x${cf_add_cflags}" != "x${cf_tst_cflags}" \
 167                 && test -z "${cf_tst_cflags}" \
 168                 && cf_fix_cppflags=no
 169         ;;
 170 esac
 171 done
 172
 173 if test -n "$cf_new_cflags" ; then
 174         ifelse([$2],,,[CF_VERBOSE(add to \$CFLAGS $cf_new_cflags)])
 175         CF_APPEND_TEXT(CFLAGS,$cf_new_cflags)
 176 fi
 177
 178 if test -n "$cf_new_cppflags" ; then
 179         ifelse([$2],,,[CF_VERBOSE(add to \$CPPFLAGS $cf_new_cppflags)])
 180         CF_APPEND_TEXT(CPPFLAGS,$cf_new_cppflags)
 181 fi
 182
 183 if test -n "$cf_new_extra_cppflags" ; then
 184         ifelse([$2],,,[CF_VERBOSE(add to \$EXTRA_CPPFLAGS $cf_new_extra_cppflags)])
 185         CF_APPEND_TEXT(EXTRA_CPPFLAGS,$cf_new_extra_cppflags)
 186 fi
 187
 188 AC_SUBST(EXTRA_CPPFLAGS)
 189
 190 ])dnl
 191 dnl ---------------------------------------------------------------------------
 192 dnl CF_ADD_INCDIR version: 17 updated: 2021/09/04 06:35:04
 193 dnl -------------
 194 dnl Add an include-directory to $CPPFLAGS.  Don't add /usr/include, since it is
 195 dnl redundant.  We don't normally need to add -I/usr/local/include for gcc,
 196 dnl but old versions (and some misinstalled ones) need that.  To make things
 197 dnl worse, gcc 3.x may give error messages if -I/usr/local/include is added to
 198 dnl the include-path).
 199 AC_DEFUN([CF_ADD_INCDIR],
 200 [
 201 if test -n "$1" ; then
 202   for cf_add_incdir in $1
 203   do
 204         while test "$cf_add_incdir" != /usr/include
 205         do
 206           if test -d "$cf_add_incdir"
 207           then
 208                 cf_have_incdir=no
 209                 if test -n "$CFLAGS$CPPFLAGS" ; then
 210                   # a loop is needed to ensure we can add subdirs of existing dirs
 211                   for cf_test_incdir in $CFLAGS $CPPFLAGS ; do
 212                         if test ".$cf_test_incdir" = ".-I$cf_add_incdir" ; then
 213                           cf_have_incdir=yes; break
 214                         fi
 215                   done
 216                 fi
 217
 218                 if test "$cf_have_incdir" = no ; then
 219                   if test "$cf_add_incdir" = /usr/local/include ; then
 220                         if test "$GCC" = yes
 221                         then
 222                           cf_save_CPPFLAGS=$CPPFLAGS
 223                           CF_APPEND_TEXT(CPPFLAGS,-I$cf_add_incdir)
 224                           AC_TRY_COMPILE([#include <stdio.h>],
 225                                   [printf("Hello")],
 226                                   [],
 227                                   [cf_have_incdir=yes])
 228                           CPPFLAGS=$cf_save_CPPFLAGS
 229                         fi
 230                   fi
 231                 fi
 232
 233                 if test "$cf_have_incdir" = no ; then
 234                   CF_VERBOSE(adding $cf_add_incdir to include-path)
 235                   ifelse([$2],,CPPFLAGS,[$2])="$ifelse([$2],,CPPFLAGS,[$2]) -I$cf_add_incdir"
 236
 237                   cf_top_incdir=`echo "$cf_add_incdir" | sed -e 's%/include/.*$%/include%'`
 238                   test "$cf_top_incdir" = "$cf_add_incdir" && break
 239                   cf_add_incdir="$cf_top_incdir"
 240                 else
 241                   break
 242                 fi
 243           else
 244                 break
 245           fi
 246         done
 247   done
 248 fi
 249 ])dnl
 250 dnl ---------------------------------------------------------------------------
 251 dnl CF_ADD_LIB version: 2 updated: 2010/06/02 05:03:05
 252 dnl ----------
 253 dnl Add a library, used to enforce consistency.
 254 dnl
 255 dnl $1 = library to add, without the "-l"
 256 dnl $2 = variable to update (default $LIBS)
 257 AC_DEFUN([CF_ADD_LIB],[CF_ADD_LIBS(-l$1,ifelse($2,,LIBS,[$2]))])dnl
 258 dnl ---------------------------------------------------------------------------
 259 dnl CF_ADD_LIBDIR version: 11 updated: 2020/12/31 20:19:42
 260 dnl -------------
 261 dnl     Adds to the library-path
 262 dnl
 263 dnl     Some machines have trouble with multiple -L options.
 264 dnl
 265 dnl $1 is the (list of) directory(s) to add
 266 dnl $2 is the optional name of the variable to update (default LDFLAGS)
 267 dnl
 268 AC_DEFUN([CF_ADD_LIBDIR],
 269 [
 270 if test -n "$1" ; then
 271         for cf_add_libdir in $1
 272         do
 273                 if test "$cf_add_libdir" = /usr/lib ; then
 274                         :
 275                 elif test -d "$cf_add_libdir"
 276                 then
 277                         cf_have_libdir=no
 278                         if test -n "$LDFLAGS$LIBS" ; then
 279                                 # a loop is needed to ensure we can add subdirs of existing dirs
 280                                 for cf_test_libdir in $LDFLAGS $LIBS ; do
 281                                         if test ".$cf_test_libdir" = ".-L$cf_add_libdir" ; then
 282                                                 cf_have_libdir=yes; break
 283                                         fi
 284                                 done
 285                         fi
 286                         if test "$cf_have_libdir" = no ; then
 287                                 CF_VERBOSE(adding $cf_add_libdir to library-path)
 288                                 ifelse([$2],,LDFLAGS,[$2])="-L$cf_add_libdir $ifelse([$2],,LDFLAGS,[$2])"
 289                         fi
 290                 fi
 291         done
 292 fi
 293 ])dnl
 294 dnl ---------------------------------------------------------------------------
 295 dnl CF_ADD_LIBS version: 3 updated: 2019/11/02 16:47:33
 296 dnl -----------
 297 dnl Add one or more libraries, used to enforce consistency.  Libraries are
 298 dnl prepended to an existing list, since their dependencies are assumed to
 299 dnl already exist in the list.
 300 dnl
 301 dnl $1 = libraries to add, with the "-l", etc.
 302 dnl $2 = variable to update (default $LIBS)
 303 AC_DEFUN([CF_ADD_LIBS],[
 304 cf_add_libs="[$]ifelse($2,,LIBS,[$2])"
 305 # reverse order
 306 cf_add_0lib=
 307 for cf_add_1lib in $1; do cf_add_0lib="$cf_add_1lib $cf_add_0lib"; done
 308 # filter duplicates
 309 for cf_add_1lib in $cf_add_0lib; do
 310         for cf_add_2lib in $cf_add_libs; do
 311                 if test "x$cf_add_1lib" = "x$cf_add_2lib"; then
 312                         cf_add_1lib=
 313                         break
 314                 fi
 315         done
 316         test -n "$cf_add_1lib" && cf_add_libs="$cf_add_1lib $cf_add_libs"
 317 done
 318 ifelse($2,,LIBS,[$2])="$cf_add_libs"
 319 ])dnl
 320 dnl ---------------------------------------------------------------------------
 321 dnl CF_ADD_SUBDIR_PATH version: 5 updated: 2020/12/31 20:19:42
 322 dnl ------------------
 323 dnl Append to a search-list for a nonstandard header/lib-file
 324 dnl     $1 = the variable to return as result
 325 dnl     $2 = the package name
 326 dnl     $3 = the subdirectory, e.g., bin, include or lib
 327 dnl $4 = the directory under which we will test for subdirectories
 328 dnl $5 = a directory that we do not want $4 to match
 329 AC_DEFUN([CF_ADD_SUBDIR_PATH],
 330 [
 331 test "x$4" != "x$5" && \
 332 test -d "$4" && \
 333 ifelse([$5],NONE,,[{ test -z "$5" || test "x$5" = xNONE || test "x$4" != "x$5"; } &&]) {
 334         test -n "$verbose" && echo "    ... testing for $3-directories under $4"
 335         test -d "$4/$3" &&          $1="[$]$1 $4/$3"
 336         test -d "$4/$3/$2" &&       $1="[$]$1 $4/$3/$2"
 337         test -d "$4/$3/$2/$3" &&    $1="[$]$1 $4/$3/$2/$3"
 338         test -d "$4/$2/$3" &&       $1="[$]$1 $4/$2/$3"
 339         test -d "$4/$2/$3/$2" &&    $1="[$]$1 $4/$2/$3/$2"
 340 }
 341 ])dnl
 342 dnl ---------------------------------------------------------------------------
 343 dnl CF_APPEND_CFLAGS version: 3 updated: 2021/09/05 17:25:40
 344 dnl ----------------
 345 dnl Use CF_ADD_CFLAGS after first checking for potential redefinitions.
 346 dnl $1 = flags to add
 347 dnl $2 = if given makes this macro verbose.
 348 define([CF_APPEND_CFLAGS],
 349 [
 350 for cf_add_cflags in $1
 351 do
 352         case "x$cf_add_cflags" in
 353         (x-[[DU]]*)
 354                 CF_REMOVE_CFLAGS($cf_add_cflags,CFLAGS,[$2])
 355                 CF_REMOVE_CFLAGS($cf_add_cflags,CPPFLAGS,[$2])
 356                 ;;
 357         esac
 358         CF_ADD_CFLAGS([$cf_add_cflags],[$2])
 359 done
 360 ])dnl
 361 dnl ---------------------------------------------------------------------------
 362 dnl CF_APPEND_TEXT version: 1 updated: 2017/02/25 18:58:55
 363 dnl --------------
 364 dnl use this macro for appending text without introducing an extra blank at
 365 dnl the beginning
 366 define([CF_APPEND_TEXT],
 367 [
 368         test -n "[$]$1" && $1="[$]$1 "
 369         $1="[$]{$1}$2"
 370 ])dnl
 371 dnl ---------------------------------------------------------------------------
 372 dnl CF_ARG_DISABLE version: 3 updated: 1999/03/30 17:24:31
 373 dnl --------------
 374 dnl Allow user to disable a normally-on option.
 375 AC_DEFUN([CF_ARG_DISABLE],
 376 [CF_ARG_OPTION($1,[$2],[$3],[$4],yes)])dnl
 377 dnl ---------------------------------------------------------------------------
 378 dnl CF_ARG_ENABLE version: 3 updated: 1999/03/30 17:24:31
 379 dnl -------------
 380 dnl Allow user to enable a normally-off option.
 381 AC_DEFUN([CF_ARG_ENABLE],
 382 [CF_ARG_OPTION($1,[$2],[$3],[$4],no)])dnl
 383 dnl ---------------------------------------------------------------------------
 384 dnl CF_ARG_OPTION version: 5 updated: 2015/05/10 19:52:14
 385 dnl -------------
 386 dnl Restricted form of AC_ARG_ENABLE that ensures user doesn't give bogus
 387 dnl values.
 388 dnl
 389 dnl Parameters:
 390 dnl $1 = option name
 391 dnl $2 = help-string
 392 dnl $3 = action to perform if option is not default
 393 dnl $4 = action if perform if option is default
 394 dnl $5 = default option value (either 'yes' or 'no')
 395 AC_DEFUN([CF_ARG_OPTION],
 396 [AC_ARG_ENABLE([$1],[$2],[test "$enableval" != ifelse([$5],no,yes,no) && enableval=ifelse([$5],no,no,yes)
 397         if test "$enableval" != "$5" ; then
 398 ifelse([$3],,[    :]dnl
 399 ,[    $3]) ifelse([$4],,,[
 400         else
 401                 $4])
 402         fi],[enableval=$5 ifelse([$4],,,[
 403         $4
 404 ])dnl
 405 ])])dnl
 406 dnl ---------------------------------------------------------------------------
 407 dnl CF_AR_FLAGS version: 9 updated: 2021/01/01 13:31:04
 408 dnl -----------
 409 dnl Check for suitable "ar" (archiver) options for updating an archive.
 410 dnl
 411 dnl In particular, handle some obsolete cases where the "-" might be omitted,
 412 dnl as well as a workaround for breakage of make's archive rules by the GNU
 413 dnl binutils "ar" program.
 414 AC_DEFUN([CF_AR_FLAGS],[
 415 AC_REQUIRE([CF_PROG_AR])
 416
 417 AC_CACHE_CHECK(for options to update archives, cf_cv_ar_flags,[
 418         case "$cf_cv_system_name" in
 419         (*-msvc*)
 420                 cf_cv_ar_flags=''
 421                 cat >mk_static_lib.sh <<-EOF
 422                 #!$SHELL
 423                 MSVC_BIN="[$]AR"
 424                 out="\[$]1"
 425                 shift
 426                 exec \[$]MSVC_BIN -out:"\[$]out" \[$]@
 427                 EOF
 428                 chmod +x mk_static_lib.sh
 429                 AR=`pwd`/mk_static_lib.sh
 430                 ;;
 431         (*)
 432                 cf_cv_ar_flags=unknown
 433                 for cf_ar_flags in -curvU -curv curv -crv crv -cqv cqv -rv rv
 434                 do
 435
 436                         # check if $ARFLAGS already contains this choice
 437                         if test "x$ARFLAGS" != "x" ; then
 438                                 cf_check_ar_flags=`echo "x$ARFLAGS" | sed -e "s/$cf_ar_flags\$//" -e "s/$cf_ar_flags / /"`
 439                                 if test "x$ARFLAGS" != "$cf_check_ar_flags" ; then
 440                                         cf_cv_ar_flags=
 441                                         break
 442                                 fi
 443                         fi
 444
 445                         rm -f "conftest.$ac_cv_objext"
 446                         rm -f conftest.a
 447
 448                         cat >"conftest.$ac_ext" <<EOF
 449 #line __oline__ "configure"
 450 int     testdata[[3]] = { 123, 456, 789 };
 451 EOF
 452                         if AC_TRY_EVAL(ac_compile) ; then
 453                                 echo "$AR $ARFLAGS $cf_ar_flags conftest.a conftest.$ac_cv_objext" >&AC_FD_CC
 454                                 $AR $ARFLAGS "$cf_ar_flags" conftest.a "conftest.$ac_cv_objext" 2>&AC_FD_CC 1>/dev/null
 455                                 if test -f conftest.a ; then
 456                                         cf_cv_ar_flags="$cf_ar_flags"
 457                                         break
 458                                 fi
 459                         else
 460                                 CF_VERBOSE(cannot compile test-program)
 461                                 break
 462                         fi
 463                 done
 464                 rm -f conftest.a "conftest.$ac_ext" "conftest.$ac_cv_objext"
 465                 ;;
 466         esac
 467 ])
 468
 469 if test -n "$ARFLAGS" ; then
 470         if test -n "$cf_cv_ar_flags" ; then
 471                 ARFLAGS="$ARFLAGS $cf_cv_ar_flags"
 472         fi
 473 else
 474         ARFLAGS=$cf_cv_ar_flags
 475 fi
 476
 477 AC_SUBST(ARFLAGS)
 478 ])
 479 dnl ---------------------------------------------------------------------------
 480 dnl CF_BUILD_CC version: 11 updated: 2022/12/04 15:40:08
 481 dnl -----------
 482 dnl If we're cross-compiling, allow the user to override the tools and their
 483 dnl options.  The configure script is oriented toward identifying the host
 484 dnl compiler, etc., but we need a build compiler to generate parts of the
 485 dnl source.
 486 dnl
 487 dnl $1 = default for $CPPFLAGS
 488 dnl $2 = default for $LIBS
 489 AC_DEFUN([CF_BUILD_CC],[
 490 CF_ACVERSION_CHECK(2.52,,
 491         [AC_REQUIRE([CF_PROG_EXT])])
 492 if test "$cross_compiling" = yes ; then
 493
 494         # defaults that we might want to override
 495         : ${BUILD_CFLAGS:=''}
 496         : ${BUILD_CPPFLAGS:='ifelse([$1],,,[$1])'}
 497         : ${BUILD_LDFLAGS:=''}
 498         : ${BUILD_LIBS:='ifelse([$2],,,[$2])'}
 499         : ${BUILD_EXEEXT:='$x'}
 500         : ${BUILD_OBJEXT:='o'}
 501
 502         AC_ARG_WITH(build-cc,
 503                 [  --with-build-cc=XXX     the build C compiler ($BUILD_CC)],
 504                 [BUILD_CC="$withval"],
 505                 [AC_CHECK_PROGS(BUILD_CC, [gcc clang c99 c89 cc cl],none)])
 506         AC_MSG_CHECKING(for native build C compiler)
 507         AC_MSG_RESULT($BUILD_CC)
 508
 509         AC_MSG_CHECKING(for native build C preprocessor)
 510         AC_ARG_WITH(build-cpp,
 511                 [  --with-build-cpp=XXX    the build C preprocessor ($BUILD_CPP)],
 512                 [BUILD_CPP="$withval"],
 513                 [BUILD_CPP='${BUILD_CC} -E'])
 514         AC_MSG_RESULT($BUILD_CPP)
 515
 516         AC_MSG_CHECKING(for native build C flags)
 517         AC_ARG_WITH(build-cflags,
 518                 [  --with-build-cflags=XXX the build C compiler-flags ($BUILD_CFLAGS)],
 519                 [BUILD_CFLAGS="$withval"])
 520         AC_MSG_RESULT($BUILD_CFLAGS)
 521
 522         AC_MSG_CHECKING(for native build C preprocessor-flags)
 523         AC_ARG_WITH(build-cppflags,
 524                 [  --with-build-cppflags=XXX the build C preprocessor-flags ($BUILD_CPPFLAGS)],
 525                 [BUILD_CPPFLAGS="$withval"])
 526         AC_MSG_RESULT($BUILD_CPPFLAGS)
 527
 528         AC_MSG_CHECKING(for native build linker-flags)
 529         AC_ARG_WITH(build-ldflags,
 530                 [  --with-build-ldflags=XXX the build linker-flags ($BUILD_LDFLAGS)],
 531                 [BUILD_LDFLAGS="$withval"])
 532         AC_MSG_RESULT($BUILD_LDFLAGS)
 533
 534         AC_MSG_CHECKING(for native build linker-libraries)
 535         AC_ARG_WITH(build-libs,
 536                 [  --with-build-libs=XXX   the build libraries (${BUILD_LIBS})],
 537                 [BUILD_LIBS="$withval"])
 538         AC_MSG_RESULT($BUILD_LIBS)
 539
 540         # this assumes we're on Unix.
 541         BUILD_EXEEXT=
 542         BUILD_OBJEXT=o
 543
 544         : ${BUILD_CC:='${CC}'}
 545
 546         AC_MSG_CHECKING(if the build-compiler "$BUILD_CC" works)
 547
 548         cf_save_crossed=$cross_compiling
 549         cf_save_ac_link=$ac_link
 550         cross_compiling=no
 551         cf_build_cppflags=$BUILD_CPPFLAGS
 552         test "$cf_build_cppflags" = "#" && cf_build_cppflags=
 553         ac_link='$BUILD_CC -o "conftest$ac_exeext" $BUILD_CFLAGS $cf_build_cppflags $BUILD_LDFLAGS "conftest.$ac_ext" $BUILD_LIBS >&AS_MESSAGE_LOG_FD'
 554
 555         AC_TRY_RUN([#include <stdio.h>
 556                 int main(int argc, char *argv[])
 557                 {
 558                         ${cf_cv_main_return:-return}(argc < 0 || argv == 0 || argv[0] == 0);
 559                 }
 560         ],
 561                 cf_ok_build_cc=yes,
 562                 cf_ok_build_cc=no,
 563                 cf_ok_build_cc=unknown)
 564
 565         cross_compiling=$cf_save_crossed
 566         ac_link=$cf_save_ac_link
 567
 568         AC_MSG_RESULT($cf_ok_build_cc)
 569
 570         if test "$cf_ok_build_cc" != yes
 571         then
 572                 AC_MSG_ERROR([Cross-build requires two compilers.
 573 Use --with-build-cc to specify the native compiler.])
 574         fi
 575
 576 else
 577         : ${BUILD_CC:='${CC}'}
 578         : ${BUILD_CPP:='${CPP}'}
 579         : ${BUILD_CFLAGS:='${CFLAGS}'}
 580         : ${BUILD_CPPFLAGS:='${CPPFLAGS}'}
 581         : ${BUILD_LDFLAGS:='${LDFLAGS}'}
 582         : ${BUILD_LIBS:='${LIBS}'}
 583         : ${BUILD_EXEEXT:='$x'}
 584         : ${BUILD_OBJEXT:='o'}
 585 fi
 586
 587 AC_SUBST(BUILD_CC)
 588 AC_SUBST(BUILD_CPP)
 589 AC_SUBST(BUILD_CFLAGS)
 590 AC_SUBST(BUILD_CPPFLAGS)
 591 AC_SUBST(BUILD_LDFLAGS)
 592 AC_SUBST(BUILD_LIBS)
 593 AC_SUBST(BUILD_EXEEXT)
 594 AC_SUBST(BUILD_OBJEXT)
 595 ])dnl
 596 dnl ---------------------------------------------------------------------------
 597 dnl CF_C11_NORETURN version: 3 updated: 2021/03/28 11:36:23
 598 dnl ---------------
 599 AC_DEFUN([CF_C11_NORETURN],
 600 [
 601 AC_MSG_CHECKING(if you want to use C11 _Noreturn feature)
 602 CF_ARG_ENABLE(stdnoreturn,
 603         [  --enable-stdnoreturn    enable C11 _Noreturn feature for diagnostics],
 604         [enable_stdnoreturn=yes],
 605         [enable_stdnoreturn=no])
 606 AC_MSG_RESULT($enable_stdnoreturn)
 607
 608 if test $enable_stdnoreturn = yes; then
 609 AC_CACHE_CHECK([for C11 _Noreturn feature], cf_cv_c11_noreturn,
 610         [AC_TRY_COMPILE([
 611 #include <stdio.h>
 612 #include <stdlib.h>
 613 #include <stdnoreturn.h>
 614 static _Noreturn void giveup(void) { exit(0); }
 615         ],
 616         [if (feof(stdin)) giveup()],
 617         cf_cv_c11_noreturn=yes,
 618         cf_cv_c11_noreturn=no)
 619         ])
 620 else
 621         cf_cv_c11_noreturn=no,
 622 fi
 623
 624 if test "$cf_cv_c11_noreturn" = yes; then
 625         AC_DEFINE(HAVE_STDNORETURN_H, 1,[Define if <stdnoreturn.h> header is available and working])
 626         AC_DEFINE_UNQUOTED(STDC_NORETURN,_Noreturn,[Define if C11 _Noreturn keyword is supported])
 627         HAVE_STDNORETURN_H=1
 628 else
 629         HAVE_STDNORETURN_H=0
 630 fi
 631
 632 AC_SUBST(HAVE_STDNORETURN_H)
 633 AC_SUBST(STDC_NORETURN)
 634 ])dnl
 635 dnl ---------------------------------------------------------------------------
 636 dnl CF_CC_ENV_FLAGS version: 10 updated: 2020/12/31 18:40:20
 637 dnl ---------------
 638 dnl Check for user's environment-breakage by stuffing CFLAGS/CPPFLAGS content
 639 dnl into CC.  This will not help with broken scripts that wrap the compiler
 640 dnl with options, but eliminates a more common category of user confusion.
 641 dnl
 642 dnl In particular, it addresses the problem of being able to run the C
 643 dnl preprocessor in a consistent manner.
 644 dnl
 645 dnl Caveat: this also disallows blanks in the pathname for the compiler, but
 646 dnl the nuisance of having inconsistent settings for compiler and preprocessor
 647 dnl outweighs that limitation.
 648 AC_DEFUN([CF_CC_ENV_FLAGS],
 649 [
 650 # This should have been defined by AC_PROG_CC
 651 : "${CC:=cc}"
 652
 653 AC_MSG_CHECKING(\$CFLAGS variable)
 654 case "x$CFLAGS" in
 655 (*-[[IUD]]*)
 656         AC_MSG_RESULT(broken)
 657         AC_MSG_WARN(your environment uses the CFLAGS variable to hold CPPFLAGS options)
 658         cf_flags="$CFLAGS"
 659         CFLAGS=
 660         for cf_arg in $cf_flags
 661         do
 662                 CF_ADD_CFLAGS($cf_arg)
 663         done
 664         ;;
 665 (*)
 666         AC_MSG_RESULT(ok)
 667         ;;
 668 esac
 669
 670 AC_MSG_CHECKING(\$CC variable)
 671 case "$CC" in
 672 (*[[\ \ ]]-*)
 673         AC_MSG_RESULT(broken)
 674         AC_MSG_WARN(your environment uses the CC variable to hold CFLAGS/CPPFLAGS options)
 675         # humor him...
 676         cf_prog=`echo "$CC" | sed -e 's/        / /g' -e 's/[[ ]]* / /g' -e 's/[[ ]]*[[ ]]-[[^ ]].*//'`
 677         cf_flags=`echo "$CC" | ${AWK:-awk} -v prog="$cf_prog" '{ printf("%s", [substr]([$]0,1+length(prog))); }'`
 678         CC="$cf_prog"
 679         for cf_arg in $cf_flags
 680         do
 681                 case "x$cf_arg" in
 682                 (x-[[IUDfgOW]]*)
 683                         CF_ADD_CFLAGS($cf_arg)
 684                         ;;
 685                 (*)
 686                         CC="$CC $cf_arg"
 687                         ;;
 688                 esac
 689         done
 690         CF_VERBOSE(resulting CC: '$CC')
 691         CF_VERBOSE(resulting CFLAGS: '$CFLAGS')
 692         CF_VERBOSE(resulting CPPFLAGS: '$CPPFLAGS')
 693         ;;
 694 (*)
 695         AC_MSG_RESULT(ok)
 696         ;;
 697 esac
 698 ])dnl
 699 dnl ---------------------------------------------------------------------------
 700 dnl CF_CFG_DEFAULTS version: 16 updated: 2021/01/04 19:33:05
 701 dnl ---------------
 702 dnl Determine the default configuration into which we'll install ncurses.  This
 703 dnl can be overridden by the user's command-line options.  There's two items to
 704 dnl look for:
 705 dnl     1. the prefix (e.g., /usr)
 706 dnl     2. the header files (e.g., /usr/include/ncurses)
 707 dnl We'll look for a previous installation of ncurses and use the same defaults.
 708 dnl
 709 dnl We don't use AC_PREFIX_DEFAULT, because it gets evaluated too soon, and
 710 dnl we don't use AC_PREFIX_PROGRAM, because we cannot distinguish ncurses's
 711 dnl programs from a vendor's.
 712 AC_DEFUN([CF_CFG_DEFAULTS],
 713 [AC_REQUIRE([AC_PROG_FGREP])dnl
 714
 715 AC_MSG_CHECKING(for prefix)
 716 if test "x$prefix" = "xNONE" ; then
 717         case "$cf_cv_system_name" in
 718                 # non-vendor systems don't have a conflict
 719         (openbsd*|freebsd*|mirbsd*|linux*|cygwin*|msys*|k*bsd*-gnu|mingw*)
 720                 prefix=/usr
 721                 ;;
 722         (*)     prefix=$ac_default_prefix
 723                 ;;
 724         esac
 725 fi
 726 AC_MSG_RESULT($prefix)
 727
 728 if test "x$prefix" = "xNONE" ; then
 729 AC_MSG_CHECKING(for default include-directory)
 730 test -n "$verbose" && echo 1>&AC_FD_MSG
 731 for cf_symbol in \
 732         "$includedir" \
 733         "$includedir/ncurses" \
 734         "$prefix/include" \
 735         "$prefix/include/ncurses" \
 736         /usr/local/include \
 737         /usr/local/include/ncurses \
 738         /usr/include \
 739         /usr/include/ncurses
 740 do
 741         cf_dir=`eval echo "$cf_symbol"`
 742         if test -f "$cf_dir/curses.h" ; then
 743         if ( ${FGREP-fgrep} NCURSES_VERSION "$cf_dir/curses.h" >/dev/null 2>&1 ) ; then
 744                 includedir="$cf_symbol"
 745                 test -n "$verbose"  && echo $ECHO_N "   found " 1>&AC_FD_MSG
 746                 break
 747         fi
 748         fi
 749         test -n "$verbose"  && echo "   tested $cf_dir" 1>&AC_FD_MSG
 750 done
 751 AC_MSG_RESULT($includedir)
 752 fi
 753 ])dnl
 754 dnl ---------------------------------------------------------------------------
 755 dnl CF_CHECK_CACHE version: 13 updated: 2020/12/31 10:54:15
 756 dnl --------------
 757 dnl Check if we're accidentally using a cache from a different machine.
 758 dnl Derive the system name, as a check for reusing the autoconf cache.
 759 dnl
 760 dnl If we've packaged config.guess and config.sub, run that (since it does a
 761 dnl better job than uname).  Normally we'll use AC_CANONICAL_HOST, but allow
 762 dnl an extra parameter that we may override, e.g., for AC_CANONICAL_SYSTEM
 763 dnl which is useful in cross-compiles.
 764 dnl
 765 dnl Note: we would use $ac_config_sub, but that is one of the places where
 766 dnl autoconf 2.5x broke compatibility with autoconf 2.13
 767 AC_DEFUN([CF_CHECK_CACHE],
 768 [
 769 if test -f "$srcdir/config.guess" || test -f "$ac_aux_dir/config.guess" ; then
 770         ifelse([$1],,[AC_CANONICAL_HOST],[$1])
 771         system_name="$host_os"
 772 else
 773         system_name="`(uname -s -r) 2>/dev/null`"
 774         if test -z "$system_name" ; then
 775                 system_name="`(hostname) 2>/dev/null`"
 776         fi
 777 fi
 778 test -n "$system_name" && AC_DEFINE_UNQUOTED(SYSTEM_NAME,"$system_name",[Define to the system name.])
 779 AC_CACHE_VAL(cf_cv_system_name,[cf_cv_system_name="$system_name"])
 780
 781 test -z "$system_name" && system_name="$cf_cv_system_name"
 782 test -n "$cf_cv_system_name" && AC_MSG_RESULT(Configuring for $cf_cv_system_name)
 783
 784 if test ".$system_name" != ".$cf_cv_system_name" ; then
 785         AC_MSG_RESULT(Cached system name ($system_name) does not agree with actual ($cf_cv_system_name))
 786         AC_MSG_ERROR("Please remove config.cache and try again.")
 787 fi
 788 ])dnl
 789 dnl ---------------------------------------------------------------------------
 790 dnl CF_CHECK_GNAT_VERSION version: 4 updated: 2021/01/01 13:31:04
 791 dnl ---------------------
 792 AC_DEFUN([CF_CHECK_GNAT_VERSION],
 793 [
 794 AC_REQUIRE([CF_GNAT_VERSION])
 795 case "$cf_cv_gnat_version" in
 796 (3.1[[1-9]]*|3.[[2-9]]*|[[4-9]].*|[[1-9]][[0-9]].[[0-9]]*|20[[0-9]][[0-9]])
 797         cf_cv_prog_gnat_correct=yes
 798         ;;
 799 (*)
 800         AC_MSG_WARN(Unsupported GNAT version $cf_cv_gnat_version. We require 3.11 or better. Disabling Ada95 binding.)
 801         cf_cv_prog_gnat_correct=no
 802         ;;
 803 esac
 804 ])
 805 dnl ---------------------------------------------------------------------------
 806 dnl CF_CHECK_LIBSSP version: 1 updated: 2021/10/30 10:40:19
 807 dnl ---------------
 808 dnl Check if libssp is needed, e.g., to work around misconfigured libraries
 809 dnl used in cross-compiling to MinGW.
 810 AC_DEFUN([CF_CHECK_LIBSSP],[
 811 AC_CACHE_CHECK(if ssp library is needed,cf_cv_need_libssp,[
 812 AC_TRY_LINK([
 813 #include <sys/types.h>
 814 #include <dirent.h>
 815 ],[
 816        DIR *dp = opendir(".");
 817 ],cf_cv_need_libssp=no,[
 818         cf_save_LIBS="$LIBS"
 819         LIBS="$LIBS -lssp"
 820         AC_TRY_LINK([
 821 #include <sys/types.h>
 822 #include <dirent.h>
 823         ],[
 824                    DIR *dp = opendir(".");
 825         ],cf_cv_need_libssp=yes,
 826           cf_cv_need_libssp=maybe)
 827         LIBS="$cf_save_LIBS"
 828 ])dnl
 829 ])
 830
 831 if test "x$cf_cv_need_libssp" = xyes
 832 then
 833         CF_ADD_LIB(ssp)
 834 fi
 835 ])dnl
 836 dnl ---------------------------------------------------------------------------
 837 dnl CF_CLANG_COMPILER version: 8 updated: 2021/01/01 13:31:04
 838 dnl -----------------
 839 dnl Check if the given compiler is really clang.  clang's C driver defines
 840 dnl __GNUC__ (fooling the configure script into setting $GCC to yes) but does
 841 dnl not ignore some gcc options.
 842 dnl
 843 dnl This macro should be run "soon" after AC_PROG_CC or AC_PROG_CPLUSPLUS, to
 844 dnl ensure that it is not mistaken for gcc/g++.  It is normally invoked from
 845 dnl the wrappers for gcc and g++ warnings.
 846 dnl
 847 dnl $1 = GCC (default) or GXX
 848 dnl $2 = CLANG_COMPILER (default)
 849 dnl $3 = CFLAGS (default) or CXXFLAGS
 850 AC_DEFUN([CF_CLANG_COMPILER],[
 851 ifelse([$2],,CLANG_COMPILER,[$2])=no
 852
 853 if test "$ifelse([$1],,[$1],GCC)" = yes ; then
 854         AC_MSG_CHECKING(if this is really Clang ifelse([$1],GXX,C++,C) compiler)
 855         cf_save_CFLAGS="$ifelse([$3],,CFLAGS,[$3])"
 856         AC_TRY_COMPILE([],[
 857 #ifdef __clang__
 858 #else
 859 make an error
 860 #endif
 861 ],[ifelse([$2],,CLANG_COMPILER,[$2])=yes
 862 ],[])
 863         ifelse([$3],,CFLAGS,[$3])="$cf_save_CFLAGS"
 864         AC_MSG_RESULT($ifelse([$2],,CLANG_COMPILER,[$2]))
 865 fi
 866
 867 CLANG_VERSION=none
 868
 869 if test "x$ifelse([$2],,CLANG_COMPILER,[$2])" = "xyes" ; then
 870         case "$CC" in
 871         (c[[1-9]][[0-9]]|*/c[[1-9]][[0-9]])
 872                 AC_MSG_WARN(replacing broken compiler alias $CC)
 873                 CFLAGS="$CFLAGS -std=`echo "$CC" | sed -e 's%.*/%%'`"
 874                 CC=clang
 875                 ;;
 876         esac
 877
 878         AC_MSG_CHECKING(version of $CC)
 879         CLANG_VERSION="`$CC --version 2>/dev/null | sed -e '2,$d' -e 's/^.*(CLANG[[^)]]*) //' -e 's/^.*(Debian[[^)]]*) //' -e 's/^[[^0-9.]]*//' -e 's/[[^0-9.]].*//'`"
 880         test -z "$CLANG_VERSION" && CLANG_VERSION=unknown
 881         AC_MSG_RESULT($CLANG_VERSION)
 882
 883         for cf_clang_opt in \
 884                 -Qunused-arguments \
 885                 -Wno-error=implicit-function-declaration
 886         do
 887                 AC_MSG_CHECKING(if option $cf_clang_opt works)
 888                 cf_save_CFLAGS="$CFLAGS"
 889                 CFLAGS="$CFLAGS $cf_clang_opt"
 890                 AC_TRY_LINK([
 891                         #include <stdio.h>],[
 892                         printf("hello!\\n");],[
 893                         cf_clang_optok=yes],[
 894                         cf_clang_optok=no])
 895                 AC_MSG_RESULT($cf_clang_optok)
 896                 CFLAGS="$cf_save_CFLAGS"
 897                 if test "$cf_clang_optok" = yes; then
 898                         CF_VERBOSE(adding option $cf_clang_opt)
 899                         CF_APPEND_TEXT(CFLAGS,$cf_clang_opt)
 900                 fi
 901         done
 902 fi
 903 ])
 904 dnl ---------------------------------------------------------------------------
 905 dnl CF_CONST_X_STRING version: 7 updated: 2021/06/07 17:39:17
 906 dnl -----------------
 907 dnl The X11R4-X11R6 Xt specification uses an ambiguous String type for most
 908 dnl character-strings.
 909 dnl
 910 dnl It is ambiguous because the specification accommodated the pre-ANSI
 911 dnl compilers bundled by more than one vendor in lieu of providing a standard C
 912 dnl compiler other than by costly add-ons.  Because of this, the specification
 913 dnl did not take into account the use of const for telling the compiler that
 914 dnl string literals would be in readonly memory.
 915 dnl
 916 dnl As a workaround, one could (starting with X11R5) define XTSTRINGDEFINES, to
 917 dnl let the compiler decide how to represent Xt's strings which were #define'd.
 918 dnl That does not solve the problem of using the block of Xt's strings which
 919 dnl are compiled into the library (and is less efficient than one might want).
 920 dnl
 921 dnl Xt specification 7 introduces the _CONST_X_STRING symbol which is used both
 922 dnl when compiling the library and compiling using the library, to tell the
 923 dnl compiler that String is const.
 924 AC_DEFUN([CF_CONST_X_STRING],
 925 [
 926 AC_REQUIRE([AC_PATH_XTRA])
 927
 928 CF_SAVE_XTRA_FLAGS([CF_CONST_X_STRING])
 929
 930 AC_TRY_COMPILE(
 931 [
 932 #include <stdlib.h>
 933 #include <X11/Intrinsic.h>
 934 ],
 935 [String foo = malloc(1); free((void*)foo)],[
 936
 937 AC_CACHE_CHECK(for X11/Xt const-feature,cf_cv_const_x_string,[
 938         AC_TRY_COMPILE(
 939                 [
 940 #define _CONST_X_STRING /* X11R7.8 (perhaps) */
 941 #undef  XTSTRINGDEFINES /* X11R5 and later */
 942 #include <stdlib.h>
 943 #include <X11/Intrinsic.h>
 944                 ],[String foo = malloc(1); *foo = 0],[
 945                         cf_cv_const_x_string=no
 946                 ],[
 947                         cf_cv_const_x_string=yes
 948                 ])
 949 ])
 950
 951 CF_RESTORE_XTRA_FLAGS([CF_CONST_X_STRING])
 952
 953 case "$cf_cv_const_x_string" in
 954 (no)
 955         CF_APPEND_TEXT(CPPFLAGS,-DXTSTRINGDEFINES)
 956         ;;
 957 (*)
 958         CF_APPEND_TEXT(CPPFLAGS,-D_CONST_X_STRING)
 959         ;;
 960 esac
 961
 962 ])
 963 ])dnl
 964 dnl ---------------------------------------------------------------------------
 965 dnl CF_CONST_X_STRING version: 7 updated: 2021/06/07 17:39:17
 966 dnl -----------------
 967 dnl The X11R4-X11R6 Xt specification uses an ambiguous String type for most
 968 dnl character-strings.
 969 dnl
 970 dnl It is ambiguous because the specification accommodated the pre-ANSI
 971 dnl compilers bundled by more than one vendor in lieu of providing a standard C
 972 dnl compiler other than by costly add-ons.  Because of this, the specification
 973 dnl did not take into account the use of const for telling the compiler that
 974 dnl string literals would be in readonly memory.
 975 dnl
 976 dnl As a workaround, one could (starting with X11R5) define XTSTRINGDEFINES, to
 977 dnl let the compiler decide how to represent Xt's strings which were #define'd.
 978 dnl That does not solve the problem of using the block of Xt's strings which
 979 dnl are compiled into the library (and is less efficient than one might want).
 980 dnl
 981 dnl Xt specification 7 introduces the _CONST_X_STRING symbol which is used both
 982 dnl when compiling the library and compiling using the library, to tell the
 983 dnl compiler that String is const.
 984 AC_DEFUN([CF_CONST_X_STRING],
 985 [
 986 AC_REQUIRE([AC_PATH_XTRA])
 987
 988 CF_SAVE_XTRA_FLAGS([CF_CONST_X_STRING])
 989
 990 AC_TRY_COMPILE(
 991 [
 992 #include <stdlib.h>
 993 #include <X11/Intrinsic.h>
 994 ],
 995 [String foo = malloc(1); free((void*)foo)],[
 996
 997 AC_CACHE_CHECK(for X11/Xt const-feature,cf_cv_const_x_string,[
 998         AC_TRY_COMPILE(
 999                 [
1000 #define _CONST_X_STRING /* X11R7.8 (perhaps) */
1001 #undef  XTSTRINGDEFINES /* X11R5 and later */
1002 #include <stdlib.h>
1003 #include <X11/Intrinsic.h>
1004                 ],[String foo = malloc(1); *foo = 0],[
1005                         cf_cv_const_x_string=no
1006                 ],[
1007                         cf_cv_const_x_string=yes
1008                 ])
1009 ])
1010
1011 CF_RESTORE_XTRA_FLAGS([CF_CONST_X_STRING])
1012
1013 case "$cf_cv_const_x_string" in
1014 (no)
1015         CF_APPEND_TEXT(CPPFLAGS,-DXTSTRINGDEFINES)
1016         ;;
1017 (*)
1018         CF_APPEND_TEXT(CPPFLAGS,-D_CONST_X_STRING)
1019         ;;
1020 esac
1021
1022 ])
1023 ])dnl
1024 dnl ---------------------------------------------------------------------------
1025 dnl CF_CURSES_HEADER version: 6 updated: 2022/12/02 20:06:52
1026 dnl ----------------
1027 dnl Find a "curses" header file, e.g,. "curses.h", or one of the more common
1028 dnl variations of ncurses' installs.
1029 dnl
1030 dnl $1 = ncurses when looking for ncurses, or is empty
1031 AC_DEFUN([CF_CURSES_HEADER],[
1032 AC_CACHE_CHECK(if we have identified curses headers,cf_cv_ncurses_header,[
1033 cf_cv_ncurses_header=none
1034 for cf_header in \
1035         ncurses.h ifelse($1,,,[$1/ncurses.h]) \
1036         curses.h ifelse($1,,,[$1/curses.h]) ifelse($1,,[ncurses/ncurses.h ncurses/curses.h])
1037 do
1038 AC_TRY_COMPILE([#include <${cf_header}>],
1039         [initscr(); endwin()],
1040         [cf_cv_ncurses_header=$cf_header; break],[])
1041 done
1042 ])
1043
1044 if test "$cf_cv_ncurses_header" = none ; then
1045         AC_MSG_ERROR(No curses header-files found)
1046 fi
1047
1048 # cheat, to get the right #define's for HAVE_NCURSES_H, etc.
1049 AC_CHECK_HEADERS($cf_cv_ncurses_header)
1050 ])dnl
1051 dnl ---------------------------------------------------------------------------
1052 dnl CF_DIRNAME version: 5 updated: 2020/12/31 20:19:42
1053 dnl ----------
1054 dnl "dirname" is not portable, so we fake it with a shell script.
1055 AC_DEFUN([CF_DIRNAME],[$1=`echo "$2" | sed -e 's%/[[^/]]*$%%'`])dnl
1056 dnl ---------------------------------------------------------------------------
1057 dnl CF_DISABLE_ECHO version: 14 updated: 2021/09/04 06:35:04
1058 dnl ---------------
1059 dnl You can always use "make -n" to see the actual options, but it is hard to
1060 dnl pick out/analyze warning messages when the compile-line is long.
1061 dnl
1062 dnl Sets:
1063 dnl     ECHO_LT - symbol to control if libtool is verbose
1064 dnl     ECHO_LD - symbol to prefix "cc -o" lines
1065 dnl     RULE_CC - symbol to put before implicit "cc -c" lines (e.g., .c.o)
1066 dnl     SHOW_CC - symbol to put before explicit "cc -c" lines
1067 dnl     ECHO_CC - symbol to put before any "cc" line
1068 dnl
1069 AC_DEFUN([CF_DISABLE_ECHO],[
1070 AC_MSG_CHECKING(if you want to see long compiling messages)
1071 CF_ARG_DISABLE(echo,
1072         [  --disable-echo          do not display "compiling" commands],
1073         [
1074         ECHO_LT='--silent'
1075         ECHO_LD='@echo linking [$]@;'
1076         RULE_CC='@echo compiling [$]<'
1077         SHOW_CC='@echo compiling [$]@'
1078         ECHO_CC='@'
1079 ],[
1080         ECHO_LT=''
1081         ECHO_LD=''
1082         RULE_CC=''
1083         SHOW_CC=''
1084         ECHO_CC=''
1085 ])
1086 AC_MSG_RESULT($enableval)
1087 AC_SUBST(ECHO_LT)
1088 AC_SUBST(ECHO_LD)
1089 AC_SUBST(RULE_CC)
1090 AC_SUBST(SHOW_CC)
1091 AC_SUBST(ECHO_CC)
1092 ])dnl
1093 dnl ---------------------------------------------------------------------------
1094 dnl CF_DISABLE_GNAT_PROJECTS version: 1 updated: 2014/06/01 11:34:00
1095 dnl ------------------------
1096 AC_DEFUN([CF_DISABLE_GNAT_PROJECTS],[
1097 AC_MSG_CHECKING(if we want to use GNAT projects)
1098 CF_ARG_DISABLE(gnat-projects,
1099         [  --disable-gnat-projects test: disable GNAT projects even if usable],
1100         [enable_gnat_projects=no],
1101         [enable_gnat_projects=yes])
1102 AC_MSG_RESULT($enable_gnat_projects)
1103 ])dnl
1104 dnl ---------------------------------------------------------------------------
1105 dnl CF_ENABLE_BROKEN_LINKER version: 2 updated: 2021/01/02 17:09:14
1106 dnl -----------------------
1107 dnl Some linkers cannot reference a data-only object.  Cygwin used to be one.
1108 dnl This usually follows CF_LINK_DATAONLY, but is not required in case we need
1109 dnl an unconditional feature.
1110 AC_DEFUN([CF_ENABLE_BROKEN_LINKER],[
1111
1112 AC_MSG_CHECKING(if you want broken-linker support code)
1113 AC_ARG_ENABLE(broken_linker,
1114         [  --enable-broken_linker  compile with broken-linker support code],
1115         [with_broken_linker=$enableval],
1116         [with_broken_linker=no])
1117 AC_MSG_RESULT($with_broken_linker)
1118
1119 : "${BROKEN_LINKER:=0}"
1120 if test "x$with_broken_linker" = xyes ; then
1121         AC_DEFINE(BROKEN_LINKER,1,[Define to 1 to work around linkers which cannot link data-only modules])
1122         BROKEN_LINKER=1
1123 fi
1124 AC_SUBST(BROKEN_LINKER)
1125 ])dnl
1126 dnl ---------------------------------------------------------------------------
1127 dnl CF_ENABLE_WARNINGS version: 9 updated: 2021/01/05 19:40:50
1128 dnl ------------------
1129 dnl Configure-option to enable gcc warnings
1130 dnl
1131 dnl $1 = extra options to add, if supported
1132 dnl $2 = option for checking attributes.  By default, this is done when
1133 dnl      warnings are enabled.  For other values:
1134 dnl      yes: always do this, e.g., to use in generated library-headers
1135 dnl      no: never do this
1136 AC_DEFUN([CF_ENABLE_WARNINGS],[
1137 if test "$GCC" = yes || test "$GXX" = yes
1138 then
1139 CF_FIX_WARNINGS(CFLAGS)
1140 CF_FIX_WARNINGS(CPPFLAGS)
1141 CF_FIX_WARNINGS(LDFLAGS)
1142 AC_MSG_CHECKING(if you want to turn on gcc warnings)
1143 CF_ARG_ENABLE(warnings,
1144         [  --enable-warnings       test: turn on gcc compiler warnings],
1145         [enable_warnings=yes],
1146         [enable_warnings=no])
1147 AC_MSG_RESULT($enable_warnings)
1148 if test "$enable_warnings" = "yes"
1149 then
1150         ifelse($2,,[CF_GCC_ATTRIBUTES])
1151         CF_GCC_WARNINGS($1)
1152 fi
1153 ifelse($2,yes,[CF_GCC_ATTRIBUTES])
1154 fi
1155 ])dnl
1156 dnl ---------------------------------------------------------------------------
1157 dnl CF_FIND_LIBRARY version: 11 updated: 2021/01/02 09:31:20
1158 dnl ---------------
1159 dnl Look for a non-standard library, given parameters for AC_TRY_LINK.  We
1160 dnl prefer a standard location, and use -L options only if we do not find the
1161 dnl library in the standard library location(s).
1162 dnl     $1 = library name
1163 dnl     $2 = library class, usually the same as library name
1164 dnl     $3 = includes
1165 dnl     $4 = code fragment to compile/link
1166 dnl     $5 = corresponding function-name
1167 dnl     $6 = flag, nonnull if failure should not cause an error-exit
1168 dnl
1169 dnl Sets the variable "$cf_libdir" as a side-effect, so we can see if we had
1170 dnl to use a -L option.
1171 AC_DEFUN([CF_FIND_LIBRARY],
1172 [
1173         eval 'cf_cv_have_lib_'"$1"'=no'
1174         cf_libdir=""
1175         AC_CHECK_FUNC($5,
1176                 eval 'cf_cv_have_lib_'"$1"'=yes',[
1177                 cf_save_LIBS="$LIBS"
1178                 AC_MSG_CHECKING(for $5 in -l$1)
1179                 LIBS="-l$1 $LIBS"
1180                 AC_TRY_LINK([$3],[$4],
1181                         [AC_MSG_RESULT(yes)
1182                          eval 'cf_cv_have_lib_'"$1"'=yes'
1183                         ],
1184                         [AC_MSG_RESULT(no)
1185                         CF_LIBRARY_PATH(cf_search,$2)
1186                         for cf_libdir in $cf_search
1187                         do
1188                                 AC_MSG_CHECKING(for -l$1 in $cf_libdir)
1189                                 LIBS="-L$cf_libdir -l$1 $cf_save_LIBS"
1190                                 AC_TRY_LINK([$3],[$4],
1191                                         [AC_MSG_RESULT(yes)
1192                                          eval 'cf_cv_have_lib_'"$1"'=yes'
1193                                          break],
1194                                         [AC_MSG_RESULT(no)
1195                                          LIBS="$cf_save_LIBS"])
1196                         done
1197                         ])
1198                 ])
1199 eval 'cf_found_library="[$]cf_cv_have_lib_'"$1"\"
1200 ifelse($6,,[
1201 if test "$cf_found_library" = no ; then
1202         AC_MSG_ERROR(Cannot link $1 library)
1203 fi
1204 ])
1205 ])dnl
1206 dnl ---------------------------------------------------------------------------
1207 dnl CF_FIND_LINKAGE version: 22 updated: 2020/12/31 20:19:42
1208 dnl ---------------
1209 dnl Find a library (specifically the linkage used in the code fragment),
1210 dnl searching for it if it is not already in the library path.
1211 dnl See also CF_ADD_SEARCHPATH.
1212 dnl
1213 dnl Parameters (4-on are optional):
1214 dnl     $1 = headers for library entrypoint
1215 dnl     $2 = code fragment for library entrypoint
1216 dnl     $3 = the library name without the "-l" option or ".so" suffix.
1217 dnl     $4 = action to perform if successful (default: update CPPFLAGS, etc)
1218 dnl     $5 = action to perform if not successful
1219 dnl     $6 = module name, if not the same as the library name
1220 dnl     $7 = extra libraries
1221 dnl
1222 dnl Sets these variables:
1223 dnl     $cf_cv_find_linkage_$3 - yes/no according to whether linkage is found
1224 dnl     $cf_cv_header_path_$3 - include-directory if needed
1225 dnl     $cf_cv_library_path_$3 - library-directory if needed
1226 dnl     $cf_cv_library_file_$3 - library-file if needed, e.g., -l$3
1227 AC_DEFUN([CF_FIND_LINKAGE],[
1228
1229 # If the linkage is not already in the $CPPFLAGS/$LDFLAGS configuration, these
1230 # will be set on completion of the AC_TRY_LINK below.
1231 cf_cv_header_path_$3=
1232 cf_cv_library_path_$3=
1233
1234 CF_MSG_LOG([Starting [FIND_LINKAGE]($3,$6)])
1235
1236 cf_save_LIBS="$LIBS"
1237
1238 AC_TRY_LINK([$1],[$2],[
1239         cf_cv_find_linkage_$3=yes
1240         cf_cv_header_path_$3=/usr/include
1241         cf_cv_library_path_$3=/usr/lib
1242 ],[
1243
1244 LIBS="-l$3 $7 $cf_save_LIBS"
1245
1246 AC_TRY_LINK([$1],[$2],[
1247         cf_cv_find_linkage_$3=yes
1248         cf_cv_header_path_$3=/usr/include
1249         cf_cv_library_path_$3=/usr/lib
1250         cf_cv_library_file_$3="-l$3"
1251 ],[
1252         cf_cv_find_linkage_$3=no
1253         LIBS="$cf_save_LIBS"
1254
1255         CF_VERBOSE(find linkage for $3 library)
1256         CF_MSG_LOG([Searching for headers in [FIND_LINKAGE]($3,$6)])
1257
1258         cf_save_CPPFLAGS="$CPPFLAGS"
1259         cf_test_CPPFLAGS="$CPPFLAGS"
1260
1261         CF_HEADER_PATH(cf_search,ifelse([$6],,[$3],[$6]))
1262         for cf_cv_header_path_$3 in $cf_search
1263         do
1264                 if test -d "$cf_cv_header_path_$3" ; then
1265                         CF_VERBOSE(... testing $cf_cv_header_path_$3)
1266                         CPPFLAGS="$cf_save_CPPFLAGS"
1267                         CF_APPEND_TEXT(CPPFLAGS,-I$cf_cv_header_path_$3)
1268                         AC_TRY_COMPILE([$1],[$2],[
1269                                 CF_VERBOSE(... found $3 headers in $cf_cv_header_path_$3)
1270                                 cf_cv_find_linkage_$3=maybe
1271                                 cf_test_CPPFLAGS="$CPPFLAGS"
1272                                 break],[
1273                                 CPPFLAGS="$cf_save_CPPFLAGS"
1274                                 ])
1275                 fi
1276         done
1277
1278         if test "$cf_cv_find_linkage_$3" = maybe ; then
1279
1280                 CF_MSG_LOG([Searching for $3 library in [FIND_LINKAGE]($3,$6)])
1281
1282                 cf_save_LIBS="$LIBS"
1283                 cf_save_LDFLAGS="$LDFLAGS"
1284
1285                 ifelse([$6],,,[
1286                 CPPFLAGS="$cf_test_CPPFLAGS"
1287                 LIBS="-l$3 $7 $cf_save_LIBS"
1288                 AC_TRY_LINK([$1],[$2],[
1289                         CF_VERBOSE(... found $3 library in system)
1290                         cf_cv_find_linkage_$3=yes])
1291                         CPPFLAGS="$cf_save_CPPFLAGS"
1292                         LIBS="$cf_save_LIBS"
1293                         ])
1294
1295                 if test "$cf_cv_find_linkage_$3" != yes ; then
1296                         CF_LIBRARY_PATH(cf_search,$3)
1297                         for cf_cv_library_path_$3 in $cf_search
1298                         do
1299                                 if test -d "$cf_cv_library_path_$3" ; then
1300                                         CF_VERBOSE(... testing $cf_cv_library_path_$3)
1301                                         CPPFLAGS="$cf_test_CPPFLAGS"
1302                                         LIBS="-l$3 $7 $cf_save_LIBS"
1303                                         LDFLAGS="$cf_save_LDFLAGS -L$cf_cv_library_path_$3"
1304                                         AC_TRY_LINK([$1],[$2],[
1305                                         CF_VERBOSE(... found $3 library in $cf_cv_library_path_$3)
1306                                         cf_cv_find_linkage_$3=yes
1307                                         cf_cv_library_file_$3="-l$3"
1308                                         break],[
1309                                         CPPFLAGS="$cf_save_CPPFLAGS"
1310                                         LIBS="$cf_save_LIBS"
1311                                         LDFLAGS="$cf_save_LDFLAGS"
1312                                         ])
1313                                 fi
1314                         done
1315                         CPPFLAGS="$cf_save_CPPFLAGS"
1316                         LDFLAGS="$cf_save_LDFLAGS"
1317                 fi
1318
1319         else
1320                 cf_cv_find_linkage_$3=no
1321         fi
1322         ],$7)
1323 ])
1324
1325 LIBS="$cf_save_LIBS"
1326
1327 if test "$cf_cv_find_linkage_$3" = yes ; then
1328 ifelse([$4],,[
1329         CF_ADD_INCDIR($cf_cv_header_path_$3)
1330         CF_ADD_LIBDIR($cf_cv_library_path_$3)
1331         CF_ADD_LIB($3)
1332 ],[$4])
1333 else
1334 ifelse([$5],,AC_MSG_WARN(Cannot find $3 library),[$5])
1335 fi
1336 ])dnl
1337 dnl ---------------------------------------------------------------------------
1338 dnl CF_FIXUP_ADAFLAGS version: 2 updated: 2015/04/17 21:13:04
1339 dnl -----------------
1340 dnl make ADAFLAGS consistent with CFLAGS
1341 AC_DEFUN([CF_FIXUP_ADAFLAGS],[
1342         AC_MSG_CHECKING(optimization options for ADAFLAGS)
1343         case "$CFLAGS" in
1344         (*-g*)
1345                 CF_ADD_ADAFLAGS(-g)
1346                 ;;
1347         esac
1348         case "$CFLAGS" in
1349         (*-O*)
1350                 cf_O_flag=`echo "$CFLAGS" |sed -e 's/^.*-O/-O/' -e 's/[[        ]].*//'`
1351                 CF_ADD_ADAFLAGS($cf_O_flag)
1352                 ;;
1353         esac
1354         AC_MSG_RESULT($ADAFLAGS)
1355 ])dnl
1356 dnl ---------------------------------------------------------------------------
1357 dnl CF_FIX_WARNINGS version: 4 updated: 2021/12/16 18:22:31
1358 dnl ---------------
1359 dnl Warning flags do not belong in CFLAGS, CPPFLAGS, etc.  Any of gcc's
1360 dnl "-Werror" flags can interfere with configure-checks.  Those go into
1361 dnl EXTRA_CFLAGS.
1362 dnl
1363 dnl $1 = variable name to repair
1364 define([CF_FIX_WARNINGS],[
1365 if test "$GCC" = yes || test "$GXX" = yes
1366 then
1367         case [$]$1 in
1368         (*-Werror=*)
1369                 cf_temp_flags=
1370                 for cf_temp_scan in [$]$1
1371                 do
1372                         case "x$cf_temp_scan" in
1373                         (x-Werror=format*)
1374                                 CF_APPEND_TEXT(cf_temp_flags,$cf_temp_scan)
1375                                 ;;
1376                         (x-Werror=*)
1377                                 CF_APPEND_TEXT(EXTRA_CFLAGS,$cf_temp_scan)
1378                                 ;;
1379                         (*)
1380                                 CF_APPEND_TEXT(cf_temp_flags,$cf_temp_scan)
1381                                 ;;
1382                         esac
1383                 done
1384                 if test "x[$]$1" != "x$cf_temp_flags"
1385                 then
1386                         CF_VERBOSE(repairing $1: [$]$1)
1387                         $1="$cf_temp_flags"
1388                         CF_VERBOSE(... fixed [$]$1)
1389                         CF_VERBOSE(... extra $EXTRA_CFLAGS)
1390                 fi
1391                 ;;
1392         esac
1393 fi
1394 AC_SUBST(EXTRA_CFLAGS)
1395 ])dnl
1396 dnl ---------------------------------------------------------------------------
1397 dnl CF_GCC_ATTRIBUTES version: 24 updated: 2021/03/20 12:00:25
1398 dnl -----------------
1399 dnl Test for availability of useful gcc __attribute__ directives to quiet
1400 dnl compiler warnings.  Though useful, not all are supported -- and contrary
1401 dnl to documentation, unrecognized directives cause older compilers to barf.
1402 AC_DEFUN([CF_GCC_ATTRIBUTES],
1403 [AC_REQUIRE([AC_PROG_FGREP])dnl
1404 AC_REQUIRE([CF_C11_NORETURN])dnl
1405
1406 if test "$GCC" = yes || test "$GXX" = yes
1407 then
1408 cat > conftest.i <<EOF
1409 #ifndef GCC_PRINTF
1410 #define GCC_PRINTF 0
1411 #endif
1412 #ifndef GCC_SCANF
1413 #define GCC_SCANF 0
1414 #endif
1415 #ifndef GCC_NORETURN
1416 #define GCC_NORETURN /* nothing */
1417 #endif
1418 #ifndef GCC_UNUSED
1419 #define GCC_UNUSED /* nothing */
1420 #endif
1421 EOF
1422 if test "$GCC" = yes
1423 then
1424         AC_CHECKING([for $CC __attribute__ directives])
1425 cat > "conftest.$ac_ext" <<EOF
1426 #line __oline__ "${as_me:-configure}"
1427 #include <stdio.h>
1428 #include "confdefs.h"
1429 #include "conftest.h"
1430 #include "conftest.i"
1431 #if     GCC_PRINTF
1432 #define GCC_PRINTFLIKE(fmt,var) __attribute__((format(printf,fmt,var)))
1433 #else
1434 #define GCC_PRINTFLIKE(fmt,var) /*nothing*/
1435 #endif
1436 #if     GCC_SCANF
1437 #define GCC_SCANFLIKE(fmt,var)  __attribute__((format(scanf,fmt,var)))
1438 #else
1439 #define GCC_SCANFLIKE(fmt,var)  /*nothing*/
1440 #endif
1441 extern void wow(char *,...) GCC_SCANFLIKE(1,2);
1442 extern GCC_NORETURN void oops(char *,...) GCC_PRINTFLIKE(1,2);
1443 extern GCC_NORETURN void foo(void);
1444 int main(int argc GCC_UNUSED, char *argv[[]] GCC_UNUSED) { (void)argc; (void)argv; return 0; }
1445 EOF
1446         cf_printf_attribute=no
1447         cf_scanf_attribute=no
1448         for cf_attribute in scanf printf unused noreturn
1449         do
1450                 CF_UPPER(cf_ATTRIBUTE,$cf_attribute)
1451                 cf_directive="__attribute__(($cf_attribute))"
1452                 echo "checking for $CC $cf_directive" 1>&AC_FD_CC
1453
1454                 case "$cf_attribute" in
1455                 (printf)
1456                         cf_printf_attribute=yes
1457                         cat >conftest.h <<EOF
1458 #define GCC_$cf_ATTRIBUTE 1
1459 EOF
1460                         ;;
1461                 (scanf)
1462                         cf_scanf_attribute=yes
1463                         cat >conftest.h <<EOF
1464 #define GCC_$cf_ATTRIBUTE 1
1465 EOF
1466                         ;;
1467                 (*)
1468                         cat >conftest.h <<EOF
1469 #define GCC_$cf_ATTRIBUTE $cf_directive
1470 EOF
1471                         ;;
1472                 esac
1473
1474                 if AC_TRY_EVAL(ac_compile); then
1475                         test -n "$verbose" && AC_MSG_RESULT(... $cf_attribute)
1476                         cat conftest.h >>confdefs.h
1477                         case "$cf_attribute" in
1478                         (noreturn)
1479                                 AC_DEFINE_UNQUOTED(GCC_NORETURN,$cf_directive,[Define to noreturn-attribute for gcc])
1480                                 ;;
1481                         (printf)
1482                                 cf_value='/* nothing */'
1483                                 if test "$cf_printf_attribute" != no ; then
1484                                         cf_value='__attribute__((format(printf,fmt,var)))'
1485                                         AC_DEFINE(GCC_PRINTF,1,[Define to 1 if the compiler supports gcc-like printf attribute.])
1486                                 fi
1487                                 AC_DEFINE_UNQUOTED(GCC_PRINTFLIKE(fmt,var),$cf_value,[Define to printf-attribute for gcc])
1488                                 ;;
1489                         (scanf)
1490                                 cf_value='/* nothing */'
1491                                 if test "$cf_scanf_attribute" != no ; then
1492                                         cf_value='__attribute__((format(scanf,fmt,var)))'
1493                                         AC_DEFINE(GCC_SCANF,1,[Define to 1 if the compiler supports gcc-like scanf attribute.])
1494                                 fi
1495                                 AC_DEFINE_UNQUOTED(GCC_SCANFLIKE(fmt,var),$cf_value,[Define to sscanf-attribute for gcc])
1496                                 ;;
1497                         (unused)
1498                                 AC_DEFINE_UNQUOTED(GCC_UNUSED,$cf_directive,[Define to unused-attribute for gcc])
1499                                 ;;
1500                         esac
1501                 fi
1502         done
1503 else
1504         ${FGREP-fgrep} define conftest.i >>confdefs.h
1505 fi
1506 rm -rf ./conftest*
1507 fi
1508 ])dnl
1509 dnl ---------------------------------------------------------------------------
1510 dnl CF_GCC_VERSION version: 8 updated: 2019/09/07 13:38:36
1511 dnl --------------
1512 dnl Find version of gcc, and (because icc/clang pretend to be gcc without being
1513 dnl compatible), attempt to determine if icc/clang is actually used.
1514 AC_DEFUN([CF_GCC_VERSION],[
1515 AC_REQUIRE([AC_PROG_CC])
1516 GCC_VERSION=none
1517 if test "$GCC" = yes ; then
1518         AC_MSG_CHECKING(version of $CC)
1519         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.]].*//'`"
1520         test -z "$GCC_VERSION" && GCC_VERSION=unknown
1521         AC_MSG_RESULT($GCC_VERSION)
1522 fi
1523 CF_INTEL_COMPILER(GCC,INTEL_COMPILER,CFLAGS)
1524 CF_CLANG_COMPILER(GCC,CLANG_COMPILER,CFLAGS)
1525 ])dnl
1526 dnl ---------------------------------------------------------------------------
1527 dnl CF_GCC_WARNINGS version: 41 updated: 2021/01/01 16:53:59
1528 dnl ---------------
1529 dnl Check if the compiler supports useful warning options.  There's a few that
1530 dnl we don't use, simply because they're too noisy:
1531 dnl
1532 dnl     -Wconversion (useful in older versions of gcc, but not in gcc 2.7.x)
1533 dnl     -Winline (usually not worthwhile)
1534 dnl     -Wredundant-decls (system headers make this too noisy)
1535 dnl     -Wtraditional (combines too many unrelated messages, only a few useful)
1536 dnl     -Wwrite-strings (too noisy, but should review occasionally).  This
1537 dnl             is enabled for ncurses using "--enable-const".
1538 dnl     -pedantic
1539 dnl
1540 dnl Parameter:
1541 dnl     $1 is an optional list of gcc warning flags that a particular
1542 dnl             application might want to use, e.g., "no-unused" for
1543 dnl             -Wno-unused
1544 dnl Special:
1545 dnl     If $with_ext_const is "yes", add a check for -Wwrite-strings
1546 dnl
1547 AC_DEFUN([CF_GCC_WARNINGS],
1548 [
1549 AC_REQUIRE([CF_GCC_VERSION])
1550 if test "x$have_x" = xyes; then CF_CONST_X_STRING fi
1551 cat > "conftest.$ac_ext" <<EOF
1552 #line __oline__ "${as_me:-configure}"
1553 int main(int argc, char *argv[[]]) { return (argv[[argc-1]] == 0) ; }
1554 EOF
1555 if test "$INTEL_COMPILER" = yes
1556 then
1557 # The "-wdXXX" options suppress warnings:
1558 # remark #1419: external declaration in primary source file
1559 # remark #1683: explicit conversion of a 64-bit integral type to a smaller integral type (potential portability problem)
1560 # remark #1684: conversion from pointer to same-sized integral type (potential portability problem)
1561 # remark #193: zero used for undefined preprocessing identifier
1562 # remark #593: variable "curs_sb_left_arrow" was set but never used
1563 # remark #810: conversion from "int" to "Dimension={unsigned short}" may lose significant bits
1564 # remark #869: parameter "tw" was never referenced
1565 # remark #981: operands are evaluated in unspecified order
1566 # warning #279: controlling expression is constant
1567
1568         AC_CHECKING([for $CC warning options])
1569         cf_save_CFLAGS="$CFLAGS"
1570         EXTRA_CFLAGS="$EXTRA_CFLAGS -Wall"
1571         for cf_opt in \
1572                 wd1419 \
1573                 wd1683 \
1574                 wd1684 \
1575                 wd193 \
1576                 wd593 \
1577                 wd279 \
1578                 wd810 \
1579                 wd869 \
1580                 wd981
1581         do
1582                 CFLAGS="$cf_save_CFLAGS $EXTRA_CFLAGS -$cf_opt"
1583                 if AC_TRY_EVAL(ac_compile); then
1584                         test -n "$verbose" && AC_MSG_RESULT(... -$cf_opt)
1585                         EXTRA_CFLAGS="$EXTRA_CFLAGS -$cf_opt"
1586                 fi
1587         done
1588         CFLAGS="$cf_save_CFLAGS"
1589 elif test "$GCC" = yes && test "$GCC_VERSION" != "unknown"
1590 then
1591         AC_CHECKING([for $CC warning options])
1592         cf_save_CFLAGS="$CFLAGS"
1593         cf_warn_CONST=""
1594         test "$with_ext_const" = yes && cf_warn_CONST="Wwrite-strings"
1595         cf_gcc_warnings="Wignored-qualifiers Wlogical-op Wvarargs"
1596         test "x$CLANG_COMPILER" = xyes && cf_gcc_warnings=
1597         for cf_opt in W Wall \
1598                 Wbad-function-cast \
1599                 Wcast-align \
1600                 Wcast-qual \
1601                 Wdeclaration-after-statement \
1602                 Wextra \
1603                 Winline \
1604                 Wmissing-declarations \
1605                 Wmissing-prototypes \
1606                 Wnested-externs \
1607                 Wpointer-arith \
1608                 Wshadow \
1609                 Wstrict-prototypes \
1610                 Wundef Wno-inline $cf_gcc_warnings $cf_warn_CONST $1
1611         do
1612                 CFLAGS="$cf_save_CFLAGS $EXTRA_CFLAGS -$cf_opt"
1613                 if AC_TRY_EVAL(ac_compile); then
1614                         test -n "$verbose" && AC_MSG_RESULT(... -$cf_opt)
1615                         case "$cf_opt" in
1616                         (Winline)
1617                                 case "$GCC_VERSION" in
1618                                 ([[34]].*)
1619                                         CF_VERBOSE(feature is broken in gcc $GCC_VERSION)
1620                                         continue;;
1621                                 esac
1622                                 ;;
1623                         (Wpointer-arith)
1624                                 case "$GCC_VERSION" in
1625                                 ([[12]].*)
1626                                         CF_VERBOSE(feature is broken in gcc $GCC_VERSION)
1627                                         continue;;
1628                                 esac
1629                                 ;;
1630                         esac
1631                         EXTRA_CFLAGS="$EXTRA_CFLAGS -$cf_opt"
1632                 fi
1633         done
1634         CFLAGS="$cf_save_CFLAGS"
1635 fi
1636 rm -rf ./conftest*
1637
1638 AC_SUBST(EXTRA_CFLAGS)
1639 ])dnl
1640 dnl ---------------------------------------------------------------------------
1641 dnl CF_GNATPREP_OPT_T version: 1 updated: 2014/08/02 18:37:25
1642 dnl -----------------
1643 AC_DEFUN([CF_GNATPREP_OPT_T],[
1644 AC_CACHE_CHECK(if GNATPREP supports -T option,cf_cv_gnatprep_opt_t,[
1645 cf_cv_gnatprep_opt_t=no
1646 gnatprep -T 2>/dev/null >/dev/null && cf_cv_gnatprep_opt_t=yes
1647 ])
1648 test "$cf_cv_gnatprep_opt_t" = yes && GNATPREP_OPTS="-T $GNATPREP_OPTS"
1649 AC_SUBST(GNATPREP_OPTS)
1650 ])dnl
1651 dnl ---------------------------------------------------------------------------
1652 dnl CF_GNAT_GENERICS version: 7 updated: 2021/01/01 13:31:04
1653 dnl ----------------
1654 AC_DEFUN([CF_GNAT_GENERICS],
1655 [
1656 AC_REQUIRE([CF_GNAT_VERSION])
1657
1658 AC_MSG_CHECKING(if GNAT supports generics)
1659 case "$cf_cv_gnat_version" in
1660 (3.1[[1-9]]*|3.[[2-9]]*|[[4-9]].*|[[1-9]][[0-9]].[[0-9]]*|20[[0-9]][[0-9]])
1661         cf_gnat_generics=yes
1662         ;;
1663 (*)
1664         cf_gnat_generics=no
1665         ;;
1666 esac
1667 AC_MSG_RESULT($cf_gnat_generics)
1668
1669 if test "$cf_gnat_generics" = yes
1670 then
1671         cf_compile_generics=generics
1672         cf_generic_objects="\${GENOBJS}"
1673 else
1674         cf_compile_generics=
1675         cf_generic_objects=
1676 fi
1677
1678 AC_SUBST(cf_compile_generics)
1679 AC_SUBST(cf_generic_objects)
1680 ])dnl
1681 dnl ---------------------------------------------------------------------------
1682 dnl CF_GNAT_PROJECTS version: 13 updated: 2021/01/02 17:09:14
1683 dnl ----------------
1684 dnl GNAT projects are configured with ".gpr" project files.
1685 dnl GNAT libraries are a further development, using the project feature.
1686 AC_DEFUN([CF_GNAT_PROJECTS],
1687 [
1688 AC_REQUIRE([CF_GNAT_VERSION])
1689 AC_REQUIRE([CF_DISABLE_GNAT_PROJECTS])
1690
1691 cf_gnat_libraries=no
1692 cf_gnat_projects=no
1693
1694 if test "$enable_gnat_projects" != no ; then
1695 AC_MSG_CHECKING(if GNAT supports project files)
1696 case "$cf_cv_gnat_version" in
1697 (3.[[0-9]]*)
1698         ;;
1699 (*)
1700         case "$cf_cv_system_name" in
1701         (cygwin*|msys*)
1702                 ;;
1703         (*)
1704                 rm -rf ./conftest* ./*~conftest*
1705                 if mkdir conftest.src conftest.bin conftest.lib
1706                 then
1707                         cd conftest.src
1708                         rm -rf ./conftest* ./*~conftest*
1709                         cat >>library.gpr <<CF_EOF
1710 project Library is
1711   Kind := External ("LIB_KIND");
1712   for Library_Name use "ConfTest";
1713   for Object_Dir use ".";
1714   for Library_ALI_Dir use External("LIBRARY_DIR");
1715   for Library_Version use External ("SONAME");
1716   for Library_Kind use Kind;
1717   for Library_Dir use External("BUILD_DIR");
1718   Source_Dir := External ("SOURCE_DIR");
1719   for Source_Dirs use (Source_Dir);
1720 end Library;
1721 CF_EOF
1722                         cat >>confpackage.ads <<CF_EOF
1723 package ConfPackage is
1724    procedure conftest;
1725 end ConfPackage;
1726 CF_EOF
1727                         cat >>confpackage.adb <<CF_EOF
1728 with Text_IO;
1729 package body ConfPackage is
1730    procedure conftest is
1731    begin
1732       Text_IO.Put ("Hello World");
1733       Text_IO.New_Line;
1734    end conftest;
1735 end ConfPackage;
1736 CF_EOF
1737                         if ( "$cf_ada_make" $ADAFLAGS \
1738                                         -Plibrary.gpr \
1739                                         -XBUILD_DIR="`cd ../conftest.bin;pwd`" \
1740                                         -XLIBRARY_DIR="`cd ../conftest.lib;pwd`" \
1741                                         -XSOURCE_DIR="`pwd`" \
1742                                         -XSONAME=libConfTest.so.1 \
1743                                         -XLIB_KIND=static 1>&AC_FD_CC 2>&1 ) ; then
1744                                 cf_gnat_projects=yes
1745                         fi
1746                         cd ..
1747                 fi
1748                 if test -f conftest.lib/confpackage.ali
1749                 then
1750                         cf_gnat_libraries=yes
1751                 fi
1752                 rm -rf ./conftest* ./*~conftest*
1753                 ;;
1754         esac
1755         ;;
1756 esac
1757 AC_MSG_RESULT($cf_gnat_projects)
1758 fi # enable_gnat_projects
1759
1760 if test "$cf_gnat_projects" = yes
1761 then
1762         AC_MSG_CHECKING(if GNAT supports libraries)
1763         AC_MSG_RESULT($cf_gnat_libraries)
1764 fi
1765
1766 USE_OLD_MAKERULES=""
1767 USE_GNAT_PROJECTS="#"
1768 USE_GNAT_MAKE_GPR="#"
1769 USE_GNAT_GPRBUILD="#"
1770
1771 if test "$cf_gnat_projects" = yes
1772 then
1773         USE_OLD_MAKERULES="#"
1774         USE_GNAT_PROJECTS=""
1775         if test "$cf_cv_VERSION_GPRBUILD" != no
1776         then
1777                 USE_GNAT_GPRBUILD=""
1778         elif test "$cf_cv_VERSION_GNATMAKE" != no
1779         then
1780                 USE_GNAT_MAKE_GPR=""
1781         else
1782                 AC_MSG_WARN(use old makefile rules since tools are missing)
1783         fi
1784 fi
1785
1786 if test "$cf_gnat_libraries" = yes
1787 then
1788         USE_GNAT_LIBRARIES=""
1789 else
1790         USE_GNAT_LIBRARIES="#"
1791 fi
1792
1793 AC_SUBST(USE_OLD_MAKERULES)
1794 AC_SUBST(USE_GNAT_PROJECTS)
1795 AC_SUBST(USE_GNAT_LIBRARIES)
1796 AC_SUBST(USE_GNAT_MAKE_GPR)
1797 AC_SUBST(USE_GNAT_GPRBUILD)
1798 ])dnl
1799 dnl ---------------------------------------------------------------------------
1800 dnl CF_GNAT_SIGINT version: 2 updated: 2021/01/01 13:31:04
1801 dnl --------------
1802 dnl Check if gnat supports SIGINT, and presumably tasking.  For the latter, it
1803 dnl is noted that gnat may compile a tasking unit even for configurations which
1804 dnl fail at runtime.
1805 AC_DEFUN([CF_GNAT_SIGINT],[
1806 AC_CACHE_CHECK(if GNAT supports SIGINT,cf_cv_gnat_sigint,[
1807 CF_GNAT_TRY_LINK([with Ada.Interrupts.Names;
1808
1809 package ConfTest is
1810
1811    pragma Warnings (Off);  --  the next pragma exists since 3.11p
1812    pragma Unreserve_All_Interrupts;
1813    pragma Warnings (On);
1814
1815    protected Process is
1816       procedure Stop;
1817       function Continue return Boolean;
1818       pragma Attach_Handler (Stop, Ada.Interrupts.Names.SIGINT);
1819    private
1820       Done : Boolean := False;
1821    end Process;
1822
1823 end ConfTest;],
1824 [package body ConfTest is
1825    protected body Process is
1826       procedure Stop is
1827       begin
1828          Done := True;
1829       end Stop;
1830       function Continue return Boolean is
1831       begin
1832          return not Done;
1833       end Continue;
1834    end Process;
1835 end ConfTest;],
1836         [cf_cv_gnat_sigint=yes],
1837         [cf_cv_gnat_sigint=no])])
1838
1839 if test "$cf_cv_gnat_sigint" = yes ; then
1840         USE_GNAT_SIGINT=""
1841 else
1842         USE_GNAT_SIGINT="#"
1843 fi
1844 AC_SUBST(USE_GNAT_SIGINT)
1845 ])dnl
1846 dnl ---------------------------------------------------------------------------
1847 dnl CF_GNAT_TRY_LINK version: 4 updated: 2021/01/01 13:31:04
1848 dnl ----------------
1849 dnl Verify that a test program compiles/links with GNAT.
1850 dnl $cf_ada_make is set to the program that compiles/links
1851 dnl $ADAFLAGS may be set to the GNAT flags.
1852 dnl
1853 dnl $1 is the text of the spec
1854 dnl $2 is the text of the body
1855 dnl $3 is the shell command to execute if successful
1856 dnl $4 is the shell command to execute if not successful
1857 AC_DEFUN([CF_GNAT_TRY_LINK],
1858 [
1859 rm -rf ./conftest* ./*~conftest*
1860 cat >>conftest.ads <<CF_EOF
1861 $1
1862 CF_EOF
1863 cat >>conftest.adb <<CF_EOF
1864 $2
1865 CF_EOF
1866 if ( "$cf_ada_make" $ADAFLAGS conftest 1>&AC_FD_CC 2>&1 ) ; then
1867 ifelse($3,,      :,[      $3])
1868 ifelse($4,,,[else
1869    $4])
1870 fi
1871 rm -rf ./conftest* ./*~conftest*
1872 ])dnl
1873 dnl ---------------------------------------------------------------------------
1874 dnl CF_GNAT_TRY_RUN version: 6 updated: 2021/01/01 13:31:04
1875 dnl ---------------
1876 dnl Verify that a test program compiles and runs with GNAT
1877 dnl $cf_ada_make is set to the program that compiles/links
1878 dnl $ADAFLAGS may be set to the GNAT flags.
1879 dnl
1880 dnl $1 is the text of the spec
1881 dnl $2 is the text of the body
1882 dnl $3 is the shell command to execute if successful
1883 dnl $4 is the shell command to execute if not successful
1884 AC_DEFUN([CF_GNAT_TRY_RUN],
1885 [
1886 rm -rf ./conftest* ./*~conftest*
1887 cat >>conftest.ads <<CF_EOF
1888 $1
1889 CF_EOF
1890 cat >>conftest.adb <<CF_EOF
1891 $2
1892 CF_EOF
1893 if ( "$cf_ada_make" $ADAFLAGS conftest 1>&AC_FD_CC 2>&1 ) ; then
1894    if ( ./conftest 1>&AC_FD_CC 2>&1 ) ; then
1895 ifelse($3,,      :,[      $3])
1896 ifelse($4,,,[   else
1897       $4])
1898    fi
1899 ifelse($4,,,[else
1900    $4])
1901 fi
1902 rm -rf ./conftest* ./*~conftest*
1903 ])dnl
1904 dnl ---------------------------------------------------------------------------
1905 dnl CF_GNAT_VERSION version: 22 updated: 2019/12/31 08:53:54
1906 dnl ---------------
1907 dnl $1 = cache variable to update
1908 dnl $2 = program name
1909 dnl Verify version of GNAT or related tool
1910 AC_DEFUN([CF_GNAT_VERSION],
1911 [
1912 AC_CACHE_CHECK(for ifelse($2,,gnat,$2) version, cf_cv_gnat_version,[
1913 cf_cv_gnat_version=`ifelse($2,,${cf_ada_make:-gnatmake},$2) --version 2>&1 | \
1914         grep '[[0-9]].[[0-9]][[0-9]]*' |\
1915         sed -e '2,$d' -e 's/[[^0-9 \.]]//g' -e 's/^[[ ]]*//' -e 's/ .*//'`
1916 ])
1917 test -z "$cf_cv_gnat_version" && cf_cv_gnat_version=no
1918 ifelse($1,,,[eval $1=$cf_cv_gnat_version; unset cf_cv_gnat_version])
1919 ])dnl
1920 dnl ---------------------------------------------------------------------------
1921 dnl CF_GNU_SOURCE version: 10 updated: 2018/12/10 20:09:41
1922 dnl -------------
1923 dnl Check if we must define _GNU_SOURCE to get a reasonable value for
1924 dnl _XOPEN_SOURCE, upon which many POSIX definitions depend.  This is a defect
1925 dnl (or misfeature) of glibc2, which breaks portability of many applications,
1926 dnl since it is interwoven with GNU extensions.
1927 dnl
1928 dnl Well, yes we could work around it...
1929 dnl
1930 dnl Parameters:
1931 dnl     $1 is the nominal value for _XOPEN_SOURCE
1932 AC_DEFUN([CF_GNU_SOURCE],
1933 [
1934 cf_gnu_xopen_source=ifelse($1,,500,$1)
1935
1936 AC_CACHE_CHECK(if this is the GNU C library,cf_cv_gnu_library,[
1937 AC_TRY_COMPILE([#include <sys/types.h>],[
1938         #if __GLIBC__ > 0 && __GLIBC_MINOR__ >= 0
1939                 return 0;
1940         #elif __NEWLIB__ > 0 && __NEWLIB_MINOR__ >= 0
1941                 return 0;
1942         #else
1943         #       error not GNU C library
1944         #endif],
1945         [cf_cv_gnu_library=yes],
1946         [cf_cv_gnu_library=no])
1947 ])
1948
1949 if test x$cf_cv_gnu_library = xyes; then
1950
1951         # With glibc 2.19 (13 years after this check was begun), _DEFAULT_SOURCE
1952         # was changed to help a little.  newlib incorporated the change about 4
1953         # years later.
1954         AC_CACHE_CHECK(if _DEFAULT_SOURCE can be used as a basis,cf_cv_gnu_library_219,[
1955                 cf_save="$CPPFLAGS"
1956                 CF_APPEND_TEXT(CPPFLAGS,-D_DEFAULT_SOURCE)
1957                 AC_TRY_COMPILE([#include <sys/types.h>],[
1958                         #if (__GLIBC__ == 2 && __GLIBC_MINOR__ >= 19) || (__GLIBC__ > 2)
1959                                 return 0;
1960                         #elif (__NEWLIB__ == 2 && __NEWLIB_MINOR__ >= 4) || (__GLIBC__ > 3)
1961                                 return 0;
1962                         #else
1963                         #       error GNU C library __GLIBC__.__GLIBC_MINOR__ is too old
1964                         #endif],
1965                         [cf_cv_gnu_library_219=yes],
1966                         [cf_cv_gnu_library_219=no])
1967                 CPPFLAGS="$cf_save"
1968         ])
1969
1970         if test "x$cf_cv_gnu_library_219" = xyes; then
1971                 cf_save="$CPPFLAGS"
1972                 AC_CACHE_CHECK(if _XOPEN_SOURCE=$cf_gnu_xopen_source works with _DEFAULT_SOURCE,cf_cv_gnu_dftsrc_219,[
1973                         CF_ADD_CFLAGS(-D_DEFAULT_SOURCE -D_XOPEN_SOURCE=$cf_gnu_xopen_source)
1974                         AC_TRY_COMPILE([
1975                                 #include <limits.h>
1976                                 #include <sys/types.h>
1977                                 ],[
1978                                 #if (_XOPEN_SOURCE >= $cf_gnu_xopen_source) && (MB_LEN_MAX > 1)
1979                                         return 0;
1980                                 #else
1981                                 #       error GNU C library is too old
1982                                 #endif],
1983                                 [cf_cv_gnu_dftsrc_219=yes],
1984                                 [cf_cv_gnu_dftsrc_219=no])
1985                         ])
1986                 test "x$cf_cv_gnu_dftsrc_219" = "xyes" || CPPFLAGS="$cf_save"
1987         else
1988                 cf_cv_gnu_dftsrc_219=maybe
1989         fi
1990
1991         if test "x$cf_cv_gnu_dftsrc_219" != xyes; then
1992
1993                 AC_CACHE_CHECK(if we must define _GNU_SOURCE,cf_cv_gnu_source,[
1994                 AC_TRY_COMPILE([#include <sys/types.h>],[
1995                         #ifndef _XOPEN_SOURCE
1996                         #error  expected _XOPEN_SOURCE to be defined
1997                         #endif],
1998                         [cf_cv_gnu_source=no],
1999                         [cf_save="$CPPFLAGS"
2000                          CF_ADD_CFLAGS(-D_GNU_SOURCE)
2001                          AC_TRY_COMPILE([#include <sys/types.h>],[
2002                                 #ifdef _XOPEN_SOURCE
2003                                 #error  expected _XOPEN_SOURCE to be undefined
2004                                 #endif],
2005                                 [cf_cv_gnu_source=no],
2006                                 [cf_cv_gnu_source=yes])
2007                         CPPFLAGS="$cf_save"
2008                         ])
2009                 ])
2010
2011                 if test "$cf_cv_gnu_source" = yes
2012                 then
2013                 AC_CACHE_CHECK(if we should also define _DEFAULT_SOURCE,cf_cv_default_source,[
2014                         CF_APPEND_TEXT(CPPFLAGS,-D_GNU_SOURCE)
2015                         AC_TRY_COMPILE([#include <sys/types.h>],[
2016                                 #ifdef _DEFAULT_SOURCE
2017                                 #error  expected _DEFAULT_SOURCE to be undefined
2018                                 #endif],
2019                                 [cf_cv_default_source=no],
2020                                 [cf_cv_default_source=yes])
2021                         ])
2022                         if test "$cf_cv_default_source" = yes
2023                         then
2024                                 CF_APPEND_TEXT(CPPFLAGS,-D_DEFAULT_SOURCE)
2025                         fi
2026                 fi
2027         fi
2028
2029 fi
2030 ])dnl
2031 dnl ---------------------------------------------------------------------------
2032 dnl CF_HEADER_PATH version: 15 updated: 2021/01/01 13:31:04
2033 dnl --------------
2034 dnl Construct a search-list of directories for a nonstandard header-file
2035 dnl
2036 dnl Parameters
2037 dnl     $1 = the variable to return as result
2038 dnl     $2 = the package name
2039 AC_DEFUN([CF_HEADER_PATH],
2040 [
2041 $1=
2042
2043 # collect the current set of include-directories from compiler flags
2044 cf_header_path_list=""
2045 if test -n "${CFLAGS}${CPPFLAGS}" ; then
2046         for cf_header_path in $CPPFLAGS $CFLAGS
2047         do
2048                 case "$cf_header_path" in
2049                 (-I*)
2050                         cf_header_path=`echo ".$cf_header_path" |sed -e 's/^...//' -e 's,/include$,,'`
2051                         CF_ADD_SUBDIR_PATH($1,$2,include,$cf_header_path,NONE)
2052                         cf_header_path_list="$cf_header_path_list [$]$1"
2053                         ;;
2054                 esac
2055         done
2056 fi
2057
2058 # add the variations for the package we are looking for
2059 CF_SUBDIR_PATH($1,$2,include)
2060
2061 test "$includedir" != NONE && \
2062 test "$includedir" != "/usr/include" && \
2063 test -d "$includedir" && {
2064         test -d "$includedir" &&    $1="[$]$1 $includedir"
2065         test -d "$includedir/$2" && $1="[$]$1 $includedir/$2"
2066 }
2067
2068 test "$oldincludedir" != NONE && \
2069 test "$oldincludedir" != "/usr/include" && \
2070 test -d "$oldincludedir" && {
2071         test -d "$oldincludedir"    && $1="[$]$1 $oldincludedir"
2072         test -d "$oldincludedir/$2" && $1="[$]$1 $oldincludedir/$2"
2073 }
2074
2075 $1="[$]$1 $cf_header_path_list"
2076 ])dnl
2077 dnl ---------------------------------------------------------------------------
2078 dnl CF_HELP_MESSAGE version: 4 updated: 2019/12/31 08:53:54
2079 dnl ---------------
2080 dnl Insert text into the help-message, for readability, from AC_ARG_WITH.
2081 AC_DEFUN([CF_HELP_MESSAGE],
2082 [CF_ACVERSION_CHECK(2.53,[],[
2083 AC_DIVERT_HELP($1)])dnl
2084 ])dnl
2085 dnl ---------------------------------------------------------------------------
2086 dnl CF_INCLUDE_DIRS version: 10 updated: 2014/09/19 20:58:42
2087 dnl ---------------
2088 dnl Construct the list of include-options according to whether we're building
2089 dnl in the source directory or using '--srcdir=DIR' option.
2090 AC_DEFUN([CF_INCLUDE_DIRS],
2091 [
2092 if test "$srcdir" != "."; then
2093         CPPFLAGS="-I\${srcdir}/../include $CPPFLAGS"
2094 fi
2095 CPPFLAGS="-I../include $CPPFLAGS"
2096 if test "$srcdir" != "."; then
2097         CPPFLAGS="-I\${srcdir} $CPPFLAGS"
2098 fi
2099 CPPFLAGS="-I. $CPPFLAGS"
2100 AC_SUBST(CPPFLAGS)
2101 ])dnl
2102 dnl ---------------------------------------------------------------------------
2103 dnl CF_INSTALL_OPTS version: 2 updated: 2018/08/18 12:19:21
2104 dnl ---------------
2105 dnl prompt for/fill-in useful install-program options
2106 AC_DEFUN([CF_INSTALL_OPTS],
2107 [
2108 CF_INSTALL_OPT_S
2109 CF_INSTALL_OPT_P
2110 CF_INSTALL_OPT_O
2111 ])dnl
2112 dnl ---------------------------------------------------------------------------
2113 dnl CF_INSTALL_OPT_O version: 3 updated: 2020/12/31 20:19:42
2114 dnl ----------------
2115 dnl Almost all "install" programs default to the current user's ownership.
2116 dnl Almost - MINIX is an exception.
2117 AC_DEFUN([CF_INSTALL_OPT_O],
2118 [
2119 AC_MSG_CHECKING(if install needs to be told about ownership)
2120 case `$ac_config_guess` in
2121 (*minix)
2122         with_install_o=yes
2123         ;;
2124 (*)
2125         with_install_o=no
2126         ;;
2127 esac
2128
2129 AC_MSG_RESULT($with_install_o)
2130 if test "x$with_install_o" = xyes
2131 then
2132         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'`"
2133 else
2134         INSTALL_OPT_O=
2135 fi
2136
2137 AC_SUBST(INSTALL_OPT_O)
2138 ])dnl
2139 dnl ---------------------------------------------------------------------------
2140 dnl CF_INSTALL_OPT_P version: 3 updated: 2021/01/01 13:31:04
2141 dnl ----------------
2142 dnl Some install-programs accept a "-p" option to preserve file modification
2143 dnl timestamps.  That can be useful as an install option, as well as a way to
2144 dnl avoid the need for ranlib after copying a static archive.
2145 AC_DEFUN([CF_INSTALL_OPT_P],
2146 [
2147 : "${INSTALL:=install}"
2148 AC_CACHE_CHECK(if install accepts -p option, cf_cv_install_p,[
2149         rm -rf ./conftest*
2150         date >conftest.in
2151         mkdir conftest.out
2152         sleep 3
2153         if $INSTALL -p conftest.in conftest.out 2>/dev/null
2154         then
2155                 if test -f conftest.out/conftest.in
2156                 then
2157                         test conftest.in -nt conftest.out/conftest.in 2>conftest.err && \
2158                         test conftest.out/conftest.in -nt conftest.in 2>conftest.err
2159                         if test -s conftest.err
2160                         then
2161                                 cf_cv_install_p=no
2162                         else
2163                                 cf_cv_install_p=yes
2164                         fi
2165                 else
2166                         cf_cv_install_p=no
2167                 fi
2168         else
2169                 cf_cv_install_p=no
2170         fi
2171         rm -rf ./conftest*
2172 ])
2173 ])dnl
2174 dnl ---------------------------------------------------------------------------
2175 dnl CF_INSTALL_OPT_S version: 3 updated: 2021/01/05 19:23:48
2176 dnl ----------------
2177 dnl By default, we should strip executables which are installed, but leave the
2178 dnl ability to suppress that for unit-testing.
2179 AC_DEFUN([CF_INSTALL_OPT_S],
2180 [
2181 AC_MSG_CHECKING(if you want to install stripped executables)
2182 CF_ARG_DISABLE(stripping,
2183         [  --disable-stripping     do not strip (debug info) installed executables],
2184         [enable_stripping=no],
2185         [enable_stripping=yes])
2186 AC_MSG_RESULT($enable_stripping)
2187
2188 if test "$enable_stripping" = yes
2189 then
2190         INSTALL_OPT_S="-s"
2191 else
2192         INSTALL_OPT_S=
2193 fi
2194 AC_SUBST(INSTALL_OPT_S)
2195 ])dnl
2196 dnl ---------------------------------------------------------------------------
2197 dnl CF_INTEL_COMPILER version: 8 updated: 2021/01/01 16:53:59
2198 dnl -----------------
2199 dnl Check if the given compiler is really the Intel compiler for Linux.  It
2200 dnl tries to imitate gcc, but does not return an error when it finds a mismatch
2201 dnl between prototypes, e.g., as exercised by CF_MISSING_CHECK.
2202 dnl
2203 dnl This macro should be run "soon" after AC_PROG_CC or AC_PROG_CPLUSPLUS, to
2204 dnl ensure that it is not mistaken for gcc/g++.  It is normally invoked from
2205 dnl the wrappers for gcc and g++ warnings.
2206 dnl
2207 dnl $1 = GCC (default) or GXX
2208 dnl $2 = INTEL_COMPILER (default) or INTEL_CPLUSPLUS
2209 dnl $3 = CFLAGS (default) or CXXFLAGS
2210 AC_DEFUN([CF_INTEL_COMPILER],[
2211 AC_REQUIRE([AC_CANONICAL_HOST])
2212 ifelse([$2],,INTEL_COMPILER,[$2])=no
2213
2214 if test "$ifelse([$1],,[$1],GCC)" = yes ; then
2215         case "$host_os" in
2216         (linux*|gnu*)
2217                 AC_MSG_CHECKING(if this is really Intel ifelse([$1],GXX,C++,C) compiler)
2218                 cf_save_CFLAGS="$ifelse([$3],,CFLAGS,[$3])"
2219                 ifelse([$3],,CFLAGS,[$3])="$ifelse([$3],,CFLAGS,[$3]) -no-gcc"
2220                 AC_TRY_COMPILE([],[
2221 #ifdef __INTEL_COMPILER
2222 #else
2223 make an error
2224 #endif
2225 ],[ifelse([$2],,INTEL_COMPILER,[$2])=yes
2226 cf_save_CFLAGS="$cf_save_CFLAGS -we147"
2227 ],[])
2228                 ifelse([$3],,CFLAGS,[$3])="$cf_save_CFLAGS"
2229                 AC_MSG_RESULT($ifelse([$2],,INTEL_COMPILER,[$2]))
2230                 ;;
2231         esac
2232 fi
2233 ])dnl
2234 dnl ---------------------------------------------------------------------------
2235 dnl CF_LARGEFILE version: 12 updated: 2020/03/19 20:23:48
2236 dnl ------------
2237 dnl Add checks for large file support.
2238 AC_DEFUN([CF_LARGEFILE],[
2239 ifdef([AC_FUNC_FSEEKO],[
2240         AC_SYS_LARGEFILE
2241         if test "$enable_largefile" != no ; then
2242         AC_FUNC_FSEEKO
2243
2244         # Normally we would collect these definitions in the config.h,
2245         # but (like _XOPEN_SOURCE), some environments rely on having these
2246         # defined before any of the system headers are included.  Another
2247         # case comes up with C++, e.g., on AIX the compiler compiles the
2248         # header files by themselves before looking at the body files it is
2249         # told to compile.  For ncurses, those header files do not include
2250         # the config.h
2251         if test "$ac_cv_sys_large_files" != no
2252         then
2253                 CF_APPEND_TEXT(CPPFLAGS,-D_LARGE_FILES)
2254         fi
2255         if test "$ac_cv_sys_largefile_source" != no
2256         then
2257                 CF_APPEND_TEXT(CPPFLAGS,-D_LARGEFILE_SOURCE)
2258         fi
2259         if test "$ac_cv_sys_file_offset_bits" != no
2260         then
2261                 CF_APPEND_TEXT(CPPFLAGS,-D_FILE_OFFSET_BITS=$ac_cv_sys_file_offset_bits)
2262         fi
2263
2264         AC_CACHE_CHECK(whether to use struct dirent64, cf_cv_struct_dirent64,[
2265                 AC_TRY_COMPILE([
2266 #pragma GCC diagnostic error "-Wincompatible-pointer-types"
2267 #include <sys/types.h>
2268 #include <dirent.h>
2269                 ],[
2270                 /* if transitional largefile support is setup, this is true */
2271                 extern struct dirent64 * readdir(DIR *);
2272                 struct dirent64 *x = readdir((DIR *)0);
2273                 struct dirent *y = readdir((DIR *)0);
2274                 int z = x - y;
2275                 (void)z;
2276                 ],
2277                 [cf_cv_struct_dirent64=yes],
2278                 [cf_cv_struct_dirent64=no])
2279         ])
2280         test "$cf_cv_struct_dirent64" = yes && AC_DEFINE(HAVE_STRUCT_DIRENT64,1,[Define to 1 if we have struct dirent64])
2281         fi
2282 ])
2283 ])
2284 dnl ---------------------------------------------------------------------------
2285 dnl CF_LD_RPATH_OPT version: 9 updated: 2021/01/01 13:31:04
2286 dnl ---------------
2287 dnl For the given system and compiler, find the compiler flags to pass to the
2288 dnl loader to use the "rpath" feature.
2289 AC_DEFUN([CF_LD_RPATH_OPT],
2290 [
2291 AC_REQUIRE([CF_CHECK_CACHE])
2292
2293 LD_RPATH_OPT=
2294 if test "x$cf_cv_enable_rpath" != xno
2295 then
2296         AC_MSG_CHECKING(for an rpath option)
2297         case "$cf_cv_system_name" in
2298         (irix*)
2299                 if test "$GCC" = yes; then
2300                         LD_RPATH_OPT="-Wl,-rpath,"
2301                 else
2302                         LD_RPATH_OPT="-rpath "
2303                 fi
2304                 ;;
2305         (linux*|gnu*|k*bsd*-gnu|freebsd*)
2306                 LD_RPATH_OPT="-Wl,-rpath,"
2307                 ;;
2308         (openbsd[[2-9]].*|mirbsd*)
2309                 LD_RPATH_OPT="-Wl,-rpath,"
2310                 ;;
2311         (dragonfly*)
2312                 LD_RPATH_OPT="-rpath "
2313                 ;;
2314         (netbsd*)
2315                 LD_RPATH_OPT="-Wl,-rpath,"
2316                 ;;
2317         (osf*|mls+*)
2318                 LD_RPATH_OPT="-rpath "
2319                 ;;
2320         (solaris2*)
2321                 LD_RPATH_OPT="-R"
2322                 ;;
2323         (*)
2324                 ;;
2325         esac
2326         AC_MSG_RESULT($LD_RPATH_OPT)
2327
2328         case "x$LD_RPATH_OPT" in
2329         (x-R*)
2330                 AC_MSG_CHECKING(if we need a space after rpath option)
2331                 cf_save_LIBS="$LIBS"
2332                 CF_ADD_LIBS(${LD_RPATH_OPT}$libdir)
2333                 AC_TRY_LINK(, , cf_rpath_space=no, cf_rpath_space=yes)
2334                 LIBS="$cf_save_LIBS"
2335                 AC_MSG_RESULT($cf_rpath_space)
2336                 test "$cf_rpath_space" = yes && LD_RPATH_OPT="$LD_RPATH_OPT "
2337                 ;;
2338         esac
2339 fi
2340 ])dnl
2341 dnl ---------------------------------------------------------------------------
2342 dnl CF_LIBRARY_PATH version: 11 updated: 2021/01/01 13:31:04
2343 dnl ---------------
2344 dnl Construct a search-list of directories for a nonstandard library-file
2345 dnl
2346 dnl Parameters
2347 dnl     $1 = the variable to return as result
2348 dnl     $2 = the package name
2349 AC_DEFUN([CF_LIBRARY_PATH],
2350 [
2351 $1=
2352 cf_library_path_list=""
2353 if test -n "${LDFLAGS}${LIBS}" ; then
2354         for cf_library_path in $LDFLAGS $LIBS
2355         do
2356                 case "$cf_library_path" in
2357                 (-L*)
2358                         cf_library_path=`echo ".$cf_library_path" |sed -e 's/^...//' -e 's,/lib$,,'`
2359                         CF_ADD_SUBDIR_PATH($1,$2,lib,$cf_library_path,NONE)
2360                         cf_library_path_list="$cf_library_path_list [$]$1"
2361                         ;;
2362                 esac
2363         done
2364 fi
2365
2366 CF_SUBDIR_PATH($1,$2,lib)
2367
2368 $1="$cf_library_path_list [$]$1"
2369 ])dnl
2370 dnl ---------------------------------------------------------------------------
2371 dnl CF_LIB_PREFIX version: 14 updated: 2021/01/01 13:31:04
2372 dnl -------------
2373 dnl Compute the library-prefix for the given host system
2374 dnl $1 = variable to set
2375 define([CF_LIB_PREFIX],
2376 [
2377         case "$cf_cv_system_name" in
2378         (OS/2*|os2*)
2379                 if test "$DFT_LWR_MODEL" = libtool; then
2380                         LIB_PREFIX='lib'
2381                 else
2382                         LIB_PREFIX=''
2383                 fi
2384                 ;;
2385         (*-msvc*)
2386                 LIB_PREFIX=''
2387                 ;;
2388         (*)     LIB_PREFIX='lib'
2389                 ;;
2390         esac
2391 ifelse($1,,,[$1=$LIB_PREFIX])
2392         AC_SUBST(LIB_PREFIX)
2393 ])dnl
2394 dnl ---------------------------------------------------------------------------
2395 dnl CF_LIB_SUFFIX version: 28 updated: 2021/01/01 16:53:59
2396 dnl -------------
2397 dnl Compute the library file-suffix from the given model name
2398 dnl $1 = model name
2399 dnl $2 = variable to set (the nominal library suffix)
2400 dnl $3 = dependency variable to set (actual filename)
2401 dnl The variable $LIB_SUFFIX, if set, prepends the variable to set.
2402 AC_DEFUN([CF_LIB_SUFFIX],
2403 [
2404         case X$1 in
2405         (Xlibtool)
2406                 $2='.la'
2407                 $3=[$]$2
2408                 ;;
2409         (Xdebug)
2410                 case "$cf_cv_system_name" in
2411                 (*-msvc*)
2412                         $2='_g.lib'
2413                         ;;
2414                 (*)
2415                         $2='_g.a'
2416                         ;;
2417                 esac
2418                 $3=[$]$2
2419                 ;;
2420         (Xprofile)
2421                 case "$cf_cv_system_name" in
2422                 (*-msvc*)
2423                         $2='_p.lib'
2424                         ;;
2425                 (*)
2426                         $2='_p.a'
2427                         ;;
2428                 esac
2429                 $3=[$]$2
2430                 ;;
2431         (Xshared)
2432                 case "$cf_cv_system_name" in
2433                 (aix[[5-7]]*)
2434                         $2='.so'
2435                         $3=[$]$2
2436                         ;;
2437                 (*-msvc*)
2438                         $2='.dll'
2439                         $3='.dll.lib'
2440                         ;;
2441                 (cygwin*|msys*|mingw*)
2442                         $2='.dll'
2443                         $3='.dll.a'
2444                         ;;
2445                 (darwin*)
2446                         $2='.dylib'
2447                         $3=[$]$2
2448                         ;;
2449                 (hpux*)
2450                         case "$target" in
2451                         (ia64*)
2452                                 $2='.so'
2453                                 $3=[$]$2
2454                                 ;;
2455                         (*)
2456                                 $2='.sl'
2457                                 $3=[$]$2
2458                                 ;;
2459                         esac
2460                         ;;
2461                 (*)
2462                         $2='.so'
2463                         $3=[$]$2
2464                         ;;
2465                 esac
2466                 ;;
2467         (*)
2468                 case "$target" in
2469                 (*-msvc*)
2470                         $2='.lib'
2471                         ;;
2472                 (*)
2473                         $2='.a'
2474                         ;;
2475                 esac
2476                 $3=[$]$2
2477                 ;;
2478         esac
2479         if test -n "${LIB_SUFFIX}${EXTRA_SUFFIX}"
2480         then
2481                 $2="${LIB_SUFFIX}${EXTRA_SUFFIX}[$]{$2}"
2482                 $3="${LIB_SUFFIX}${EXTRA_SUFFIX}[$]{$3}"
2483         fi
2484 ])dnl
2485 dnl ---------------------------------------------------------------------------
2486 dnl CF_LIB_TYPE version: 5 updated: 2015/04/17 21:13:04
2487 dnl -----------
2488 dnl Compute the string to append to -library from the given model name
2489 dnl $1 = model name
2490 dnl $2 = variable to set
2491 dnl The variable $LIB_SUFFIX, if set, prepends the variable to set.
2492 AC_DEFUN([CF_LIB_TYPE],
2493 [
2494         case $1 in
2495         (libtool) $2=''   ;;
2496         (normal)  $2=''   ;;
2497         (debug)   $2='_g' ;;
2498         (profile) $2='_p' ;;
2499         (shared)  $2=''   ;;
2500         esac
2501         test -n "$LIB_SUFFIX" && $2="${LIB_SUFFIX}[$]{$2}"
2502 ])dnl
2503 dnl ---------------------------------------------------------------------------
2504 dnl CF_LINK_DATAONLY version: 13 updated: 2020/02/08 15:59:30
2505 dnl ----------------
2506 dnl Some systems have a non-ANSI linker that doesn't pull in modules that have
2507 dnl only data (i.e., no functions), for example NeXT.  On those systems we'll
2508 dnl have to provide wrappers for global tables to ensure they're linked
2509 dnl properly.
2510 AC_DEFUN([CF_LINK_DATAONLY],
2511 [
2512 AC_MSG_CHECKING([if data-only library module links])
2513 AC_CACHE_VAL(cf_cv_link_dataonly,[
2514         rm -f conftest.a
2515         cat >conftest.$ac_ext <<EOF
2516 #line __oline__ "configure"
2517 int     testdata[[3]] = { 123, 456, 789 };
2518 EOF
2519         if AC_TRY_EVAL(ac_compile) ; then
2520                 mv conftest.o data.o && \
2521                 ( $AR $ARFLAGS conftest.a data.o ) 2>&AC_FD_CC 1>/dev/null
2522         fi
2523         rm -f conftest.$ac_ext data.o
2524         cat >conftest.$ac_ext <<EOF
2525 #line __oline__ "configure"
2526 int     testfunc(void)
2527 {
2528 #if defined(NeXT)
2529         ${cf_cv_main_return:-return}(1);        /* I'm told this linker is broken */
2530 #else
2531         extern int testdata[[3]];
2532         return testdata[[0]] == 123
2533            &&  testdata[[1]] == 456
2534            &&  testdata[[2]] == 789;
2535 #endif
2536 }
2537 EOF
2538         if AC_TRY_EVAL(ac_compile); then
2539                 mv conftest.o func.o && \
2540                 ( $AR $ARFLAGS conftest.a func.o ) 2>&AC_FD_CC 1>/dev/null
2541         fi
2542         rm -f conftest.$ac_ext func.o
2543         ( eval $RANLIB conftest.a ) 2>&AC_FD_CC >/dev/null
2544         cf_saveLIBS="$LIBS"
2545         LIBS="conftest.a $LIBS"
2546         AC_TRY_RUN([
2547         int main(void)
2548         {
2549                 extern int testfunc();
2550                 ${cf_cv_main_return:-return} (!testfunc());
2551         }
2552         ],
2553         [cf_cv_link_dataonly=yes],
2554         [cf_cv_link_dataonly=no],
2555         [cf_cv_link_dataonly=unknown])
2556         LIBS="$cf_saveLIBS"
2557         ])
2558 AC_MSG_RESULT($cf_cv_link_dataonly)
2559
2560 if test "$cf_cv_link_dataonly" = no ; then
2561         AC_DEFINE(BROKEN_LINKER,1,[if data-only library module does not link])
2562         BROKEN_LINKER=1
2563 fi
2564 AC_SUBST(BROKEN_LINKER)
2565
2566 ])dnl
2567 dnl ---------------------------------------------------------------------------
2568 dnl CF_MAKEFLAGS version: 21 updated: 2021/09/04 06:47:34
2569 dnl ------------
2570 dnl Some 'make' programs support ${MAKEFLAGS}, some ${MFLAGS}, to pass 'make'
2571 dnl options to lower-levels.  It is very useful for "make -n" -- if we have it.
2572 dnl (GNU 'make' does both, something POSIX 'make', which happens to make the
2573 dnl ${MAKEFLAGS} variable incompatible because it adds the assignments :-)
2574 AC_DEFUN([CF_MAKEFLAGS],
2575 [AC_REQUIRE([AC_PROG_FGREP])dnl
2576
2577 AC_CACHE_CHECK(for makeflags variable, cf_cv_makeflags,[
2578         cf_cv_makeflags=''
2579         for cf_option in '-${MAKEFLAGS}' '${MFLAGS}'
2580         do
2581                 cat >cf_makeflags.tmp <<CF_EOF
2582 SHELL = $SHELL
2583 all :
2584         @ echo '.$cf_option'
2585 CF_EOF
2586                 cf_result=`${MAKE:-make} -k -f cf_makeflags.tmp 2>/dev/null | ${FGREP-fgrep} -v "ing directory" | sed -e 's,[[  ]]*$,,'`
2587                 case "$cf_result" in
2588                 (.*k|.*kw)
2589                         cf_result="`${MAKE:-make} -k -f cf_makeflags.tmp CC=cc 2>/dev/null`"
2590                         case "$cf_result" in
2591                         (.*CC=*)        cf_cv_makeflags=
2592                                 ;;
2593                         (*)     cf_cv_makeflags=$cf_option
2594                                 ;;
2595                         esac
2596                         break
2597                         ;;
2598                 (.-)
2599                         ;;
2600                 (*)
2601                         CF_MSG_LOG(given option \"$cf_option\", no match \"$cf_result\")
2602                         ;;
2603                 esac
2604         done
2605         rm -f cf_makeflags.tmp
2606 ])
2607
2608 AC_SUBST(cf_cv_makeflags)
2609 ])dnl
2610 dnl ---------------------------------------------------------------------------
2611 dnl CF_MAKE_PHONY version: 3 updated: 2021/01/08 16:08:21
2612 dnl -------------
2613 dnl Check if the make-program handles a ".PHONY" target, e.g,. a target which
2614 dnl acts as a placeholder.
2615 dnl
2616 dnl The ".PHONY" feature was proposed in 2011 here
2617 dnl     https://www.austingroupbugs.net/view.php?id=523
2618 dnl and is scheduled for release in P1003.1 Issue 8 (late 2022).
2619 dnl
2620 dnl This is not supported by SVr4 make (or SunOS 4, 4.3SD, etc), but works with
2621 dnl a few others (i.e., GNU make and the non-POSIX "BSD" make):
2622 dnl
2623 dnl + This is a GNU make feature (since April 1988, but in turn from binutils,
2624 dnl   date unspecified).
2625 dnl
2626 dnl + It was adopted in NetBSD make in June 1995.
2627 dnl
2628 dnl + The other BSD make programs are derived from the NetBSD make (and for
2629 dnl   that reason are not actually different "implementations").
2630 dnl
2631 dnl + Some features of NetBSD make were actually adapted from pmake, which
2632 dnl   began as a modified GNU make starting in 1993.
2633 dnl
2634 dnl + Version 3.8 of the dmake program in January 1992 also implemented this
2635 dnl   GNU make extension, but is less well known than the BSD make.
2636 AC_DEFUN([CF_MAKE_PHONY],[
2637 AC_CACHE_CHECK(for \".PHONY\" make-support, cf_cv_make_PHONY,[
2638         rm -rf conftest*
2639         (
2640                 mkdir conftest || exit 1
2641                 cd conftest
2642                 cat >makefile <<'CF_EOF'
2643 .PHONY: always
2644 DATA=0
2645 always: always.out
2646         @echo "** making [$]@ [$](DATA)"
2647 once: once.out
2648         @echo "** making [$]@ [$](DATA)"
2649 always.out:
2650         @echo "** making [$]@ [$](DATA)"
2651         echo [$](DATA) > [$]@
2652 once.out:
2653         @echo "** making [$]@ [$](DATA)"
2654         echo [$](DATA) > [$]@
2655 CF_EOF
2656                 for cf_data in 1 2 3
2657                 do
2658                         ${MAKE:-make} always DATA=$cf_data
2659                         ${MAKE:-make} once   DATA=$cf_data
2660                         ${MAKE:-make} -t always once
2661                         if test -f always ; then
2662                                 echo "no (case 1)" > ../conftest.tmp
2663                         elif test ! -f always.out ; then
2664                                 echo "no (case 2)" > ../conftest.tmp
2665                         elif test ! -f once.out ; then
2666                                 echo "no (case 3)" > ../conftest.tmp
2667                         elif ! cmp -s always.out once.out ; then
2668                                 echo "no (case 4)" > ../conftest.tmp
2669                                 diff always.out once.out
2670                         else
2671                                 cf_check="`cat always.out`"
2672                                 if test "x$cf_check" != "x$cf_data" ; then
2673                                         echo "no (case 5)" > ../conftest.tmp
2674                                 else
2675                                         echo yes > ../conftest.tmp
2676                                         rm -f ./*.out
2677                                         continue
2678                                 fi
2679                         fi
2680                         break
2681                 done
2682         ) >&AC_FD_CC 2>&1
2683         cf_cv_make_PHONY="`cat conftest.tmp`"
2684         rm -rf conftest*
2685 ])
2686 MAKE_NO_PHONY="#"
2687 MAKE_PHONY="#"
2688 test "x$cf_cv_make_PHONY" = xyes && MAKE_PHONY=
2689 test "x$cf_cv_make_PHONY" != xyes && MAKE_NO_PHONY=
2690 AC_SUBST(MAKE_NO_PHONY)
2691 AC_SUBST(MAKE_PHONY)
2692 ])dnl
2693 dnl ---------------------------------------------------------------------------
2694 dnl CF_MAKE_TAGS version: 6 updated: 2010/10/23 15:52:32
2695 dnl ------------
2696 dnl Generate tags/TAGS targets for makefiles.  Do not generate TAGS if we have
2697 dnl a monocase filesystem.
2698 AC_DEFUN([CF_MAKE_TAGS],[
2699 AC_REQUIRE([CF_MIXEDCASE_FILENAMES])
2700
2701 AC_CHECK_PROGS(CTAGS, exctags ctags)
2702 AC_CHECK_PROGS(ETAGS, exetags etags)
2703
2704 AC_CHECK_PROG(MAKE_LOWER_TAGS, ${CTAGS:-ctags}, yes, no)
2705
2706 if test "$cf_cv_mixedcase" = yes ; then
2707         AC_CHECK_PROG(MAKE_UPPER_TAGS, ${ETAGS:-etags}, yes, no)
2708 else
2709         MAKE_UPPER_TAGS=no
2710 fi
2711
2712 if test "$MAKE_UPPER_TAGS" = yes ; then
2713         MAKE_UPPER_TAGS=
2714 else
2715         MAKE_UPPER_TAGS="#"
2716 fi
2717
2718 if test "$MAKE_LOWER_TAGS" = yes ; then
2719         MAKE_LOWER_TAGS=
2720 else
2721         MAKE_LOWER_TAGS="#"
2722 fi
2723
2724 AC_SUBST(CTAGS)
2725 AC_SUBST(ETAGS)
2726
2727 AC_SUBST(MAKE_UPPER_TAGS)
2728 AC_SUBST(MAKE_LOWER_TAGS)
2729 ])dnl
2730 dnl ---------------------------------------------------------------------------
2731 dnl CF_MIXEDCASE_FILENAMES version: 9 updated: 2021/01/01 16:53:59
2732 dnl ----------------------
2733 dnl Check if the file-system supports mixed-case filenames.  If we're able to
2734 dnl create a lowercase name and see it as uppercase, it doesn't support that.
2735 AC_DEFUN([CF_MIXEDCASE_FILENAMES],
2736 [
2737 AC_CACHE_CHECK(if filesystem supports mixed-case filenames,cf_cv_mixedcase,[
2738 if test "$cross_compiling" = yes ; then
2739         case "$target_alias" in
2740         (*-os2-emx*|*-msdosdjgpp*|*-cygwin*|*-msys*|*-mingw*|*-uwin*|darwin*)
2741                 cf_cv_mixedcase=no
2742                 ;;
2743         (*)
2744                 cf_cv_mixedcase=yes
2745                 ;;
2746         esac
2747 else
2748         rm -f conftest CONFTEST
2749         echo test >conftest
2750         if test -f CONFTEST ; then
2751                 cf_cv_mixedcase=no
2752         else
2753                 cf_cv_mixedcase=yes
2754         fi
2755         rm -f conftest CONFTEST
2756 fi
2757 ])
2758 test "$cf_cv_mixedcase" = yes && AC_DEFINE(MIXEDCASE_FILENAMES,1,[Define to 1 if filesystem supports mixed-case filenames.])
2759 ])dnl
2760 dnl ---------------------------------------------------------------------------
2761 dnl CF_MKSTEMP version: 12 updated: 2023/01/05 17:53:11
2762 dnl ----------
2763 dnl Check for a working mkstemp.  This creates two files, checks that they are
2764 dnl successfully created and distinct (AmigaOS apparently fails on the last).
2765 AC_DEFUN([CF_MKSTEMP],[
2766 AC_CHECK_HEADERS( \
2767 unistd.h \
2768 )
2769 AC_CACHE_CHECK(for working mkstemp, cf_cv_func_mkstemp,[
2770 rm -rf ./conftest*
2771 AC_TRY_RUN([
2772 $ac_includes_default
2773
2774 int main(void)
2775 {
2776         char *tmpl = "conftestXXXXXX";
2777         char name[2][80];
2778         int n;
2779         int result = 0;
2780         int fd;
2781         struct stat sb;
2782
2783         umask(077);
2784         for (n = 0; n < 2; ++n) {
2785                 strcpy(name[n], tmpl);
2786                 if ((fd = mkstemp(name[n])) >= 0) {
2787                         if (!strcmp(name[n], tmpl)
2788                          || stat(name[n], &sb) != 0
2789                          || (sb.st_mode & S_IFMT) != S_IFREG
2790                          || (sb.st_mode & 077) != 0) {
2791                                 result = 1;
2792                         }
2793                         close(fd);
2794                 }
2795         }
2796         if (result == 0
2797          && !strcmp(name[0], name[1]))
2798                 result = 1;
2799         ${cf_cv_main_return:-return}(result);
2800 }
2801 ],[cf_cv_func_mkstemp=yes
2802 ],[cf_cv_func_mkstemp=no
2803 ],[cf_cv_func_mkstemp=maybe])
2804 ])
2805 if test "x$cf_cv_func_mkstemp" = xmaybe ; then
2806         AC_CHECK_FUNC(mkstemp)
2807 fi
2808 if test "x$cf_cv_func_mkstemp" = xyes || test "x$ac_cv_func_mkstemp" = xyes ; then
2809         AC_DEFINE(HAVE_MKSTEMP,1,[Define to 1 if mkstemp() is available and working.])
2810 fi
2811 ])dnl
2812 dnl ---------------------------------------------------------------------------
2813 dnl CF_MSG_LOG version: 5 updated: 2010/10/23 15:52:32
2814 dnl ----------
2815 dnl Write a debug message to config.log, along with the line number in the
2816 dnl configure script.
2817 AC_DEFUN([CF_MSG_LOG],[
2818 echo "${as_me:-configure}:__oline__: testing $* ..." 1>&AC_FD_CC
2819 ])dnl
2820 dnl ---------------------------------------------------------------------------
2821 dnl CF_NCURSES_ADDON version: 6 updated: 2021/01/04 19:33:05
2822 dnl ----------------
2823 dnl Configure an ncurses add-on, built outside the ncurses tree.
2824 AC_DEFUN([CF_NCURSES_ADDON],[
2825 AC_REQUIRE([CF_NCURSES_CONFIG])
2826
2827 AC_PROVIDE([CF_SUBST_NCURSES_VERSION])
2828
2829 AC_MSG_CHECKING(if you want wide-character code)
2830 AC_ARG_ENABLE(widec,
2831         [  --enable-widec          compile with wide-char/UTF-8 code],
2832         [with_widec=$enableval],
2833         [with_widec=no])
2834 AC_MSG_RESULT($with_widec)
2835 if test "$with_widec" = yes ; then
2836         CF_UTF8_LIB
2837         CF_NCURSES_CONFIG(ncursesw)
2838 else
2839         CF_NCURSES_CONFIG(ncurses)
2840 fi
2841
2842 if test "$NCURSES_CONFIG_PKG" != none ; then
2843         cf_version=`$PKG_CONFIG --modversion $NCURSES_CONFIG_PKG 2>/dev/null`
2844
2845         NCURSES_MAJOR=`echo "$cf_version" | sed -e 's/\..*//'`
2846         NCURSES_MINOR=`echo "$cf_version" | sed -e 's/^[[0-9]][[0-9]]*\.//' -e 's/\..*//'`
2847         NCURSES_PATCH=`echo "$cf_version" | sed -e 's/^[[0-9]][[0-9]]*\.[[0-9]][[0-9]]*\.//'`
2848
2849         cf_cv_abi_version=`$PKG_CONFIG --variable=abi_version $NCURSES_CONFIG_PKG 2>/dev/null`
2850         if test -z "$cf_cv_abi_version"
2851         then
2852                 cf_cv_abi_version=`$PKG_CONFIG --variable=major_version $NCURSES_CONFIG_PKG 2>/dev/null`
2853         fi
2854
2855 elif test "$NCURSES_CONFIG" != none ; then
2856
2857         cf_version=`$NCURSES_CONFIG --version 2>/dev/null`
2858
2859         NCURSES_MAJOR=`echo "$cf_version" | sed -e 's/\..*//'`
2860         NCURSES_MINOR=`echo "$cf_version" | sed -e 's/^[[0-9]][[0-9]]*\.//' -e 's/\..*//'`
2861         NCURSES_PATCH=`echo "$cf_version" | sed -e 's/^[[0-9]][[0-9]]*\.[[0-9]][[0-9]]*\.//'`
2862
2863         # ABI version is not available from headers
2864         cf_cv_abi_version=`$NCURSES_CONFIG --abi-version 2>/dev/null`
2865
2866 else
2867
2868         for cf_name in MAJOR MINOR PATCH
2869         do
2870         cat >conftest.$ac_ext <<CF_EOF
2871         #include <${cf_cv_ncurses_header:-curses.h}>
2872         AUTOCONF_$cf_name NCURSES_VERSION_$cf_name
2873 CF_EOF
2874                 cf_try="$ac_cpp conftest.$ac_ext 2>&5 | fgrep AUTOCONF_$cf_name >conftest.out"
2875                 AC_TRY_EVAL(cf_try)
2876                 if test -f conftest.out ; then
2877                         cf_result=`sed -e "s/^.*AUTOCONF_${cf_name}[[   ]][[    ]]*//" conftest.out`
2878                         eval NCURSES_$cf_name=\"$cf_result\"
2879                         # cat conftest.$ac_ext
2880                         # cat conftest.out
2881                 fi
2882         done
2883
2884         cf_cv_abi_version=${NCURSES_MAJOR}
2885
2886 fi
2887
2888 cf_cv_rel_version=${NCURSES_MAJOR}.${NCURSES_MINOR}
2889
2890 dnl Show the computed version, for logging
2891 cf_cv_timestamp=`date`
2892
2893 AC_MSG_RESULT(Configuring NCURSES $cf_cv_rel_version ABI $cf_cv_abi_version ($cf_cv_timestamp))
2894
2895 dnl We need these values in the generated headers
2896 AC_SUBST(NCURSES_MAJOR)
2897 AC_SUBST(NCURSES_MINOR)
2898 AC_SUBST(NCURSES_PATCH)
2899
2900 dnl We need these values in the generated makefiles
2901 AC_SUBST(cf_cv_rel_version)
2902 AC_SUBST(cf_cv_abi_version)
2903
2904 dnl FIXME - not needed for Ada95
2905 AC_SUBST(cf_cv_builtin_bool)
2906 AC_SUBST(cf_cv_header_stdbool_h)
2907 AC_SUBST(cf_cv_type_of_bool)dnl
2908
2909 ])
2910 dnl ---------------------------------------------------------------------------
2911 dnl CF_NCURSES_CC_CHECK version: 5 updated: 2020/12/31 20:19:42
2912 dnl -------------------
2913 dnl Check if we can compile with ncurses' header file
2914 dnl $1 is the cache variable to set
2915 dnl $2 is the header-file to include
2916 dnl $3 is the root name (ncurses or ncursesw)
2917 AC_DEFUN([CF_NCURSES_CC_CHECK],[
2918         AC_TRY_COMPILE([
2919 ]ifelse($3,ncursesw,[
2920 #define _XOPEN_SOURCE_EXTENDED
2921 #undef  HAVE_LIBUTF8_H  /* in case we used CF_UTF8_LIB */
2922 #define HAVE_LIBUTF8_H  /* to force ncurses' header file to use cchar_t */
2923 ])[
2924 #include <$2>],[
2925 #ifdef NCURSES_VERSION
2926 ]ifelse($3,ncursesw,[
2927 #ifndef WACS_BSSB
2928         make an error
2929 #endif
2930 ])[
2931 printf("%s\\n", NCURSES_VERSION);
2932 #else
2933 #ifdef __NCURSES_H
2934 printf("old\\n");
2935 #else
2936         make an error
2937 #endif
2938 #endif
2939         ]
2940         ,[$1=$2]
2941         ,[$1=no])
2942 ])dnl
2943 dnl ---------------------------------------------------------------------------
2944 dnl CF_NCURSES_CONFIG version: 28 updated: 2021/08/28 15:20:37
2945 dnl -----------------
2946 dnl Tie together the configure-script macros for ncurses, preferring these in
2947 dnl order:
2948 dnl a) ".pc" files for pkg-config, using $NCURSES_CONFIG_PKG
2949 dnl b) the "-config" script from ncurses, using $NCURSES_CONFIG
2950 dnl c) just plain libraries
2951 dnl
2952 dnl $1 is the root library name (default: "ncurses")
2953 AC_DEFUN([CF_NCURSES_CONFIG],[
2954 AC_REQUIRE([CF_PKG_CONFIG])
2955 cf_ncuconfig_root=ifelse($1,,ncurses,$1)
2956 cf_have_ncuconfig=no
2957
2958 if test "x${PKG_CONFIG:=none}" != xnone; then
2959         AC_MSG_CHECKING(pkg-config for $cf_ncuconfig_root)
2960         if "$PKG_CONFIG" --exists $cf_ncuconfig_root ; then
2961                 AC_MSG_RESULT(yes)
2962
2963                 AC_MSG_CHECKING(if the $cf_ncuconfig_root package files work)
2964                 cf_have_ncuconfig=unknown
2965
2966                 cf_save_CFLAGS="$CFLAGS"
2967                 cf_save_CPPFLAGS="$CPPFLAGS"
2968                 cf_save_LIBS="$LIBS"
2969
2970                 cf_pkg_cflags="`$PKG_CONFIG --cflags $cf_ncuconfig_root`"
2971                 cf_pkg_libs="`$PKG_CONFIG --libs $cf_ncuconfig_root`"
2972
2973                 # while -W for passing linker flags is prevalent, it is not "standard".
2974                 # At least one wrapper for c89/c99 (in Apple's xcode) has its own
2975                 # incompatible _and_ non-standard -W option which gives an error.  Work
2976                 # around that pitfall.
2977                 case "x${CC}@@${cf_pkg_libs}@${cf_pkg_cflags}" in
2978                 (x*c[[89]]9@@*-W*)
2979                         CF_ADD_CFLAGS($cf_pkg_cflags)
2980                         CF_ADD_LIBS($cf_pkg_libs)
2981
2982                         AC_TRY_LINK([#include <${cf_cv_ncurses_header:-curses.h}>],
2983                                 [initscr(); mousemask(0,0); tigetstr((char *)0);],
2984                                 [AC_TRY_RUN([#include <${cf_cv_ncurses_header:-curses.h}>
2985                                         int main(void)
2986                                         { const char *xx = curses_version(); return (xx == 0); }],
2987                                         [cf_test_ncuconfig=yes],
2988                                         [cf_test_ncuconfig=no],
2989                                         [cf_test_ncuconfig=maybe])],
2990                                 [cf_test_ncuconfig=no])
2991
2992                         CFLAGS="$cf_save_CFLAGS"
2993                         CPPFLAGS="$cf_save_CPPFLAGS"
2994                         LIBS="$cf_save_LIBS"
2995
2996                         if test "x$cf_test_ncuconfig" != xyes; then
2997                                 cf_temp=`echo "x$cf_pkg_cflags" | sed -e s/^x// -e 's/-W[[^     ]]*//g'`
2998                                 cf_pkg_cflags="$cf_temp"
2999                                 cf_temp=`echo "x$cf_pkg_libs" | sed -e s/^x// -e 's/-W[[^       ]]*//g'`
3000                                 cf_pkg_libs="$cf_temp"
3001                         fi
3002                         ;;
3003                 esac
3004
3005                 CF_APPEND_CFLAGS($cf_pkg_cflags)
3006                 CF_ADD_LIBS($cf_pkg_libs)
3007
3008                 AC_TRY_LINK([#include <${cf_cv_ncurses_header:-curses.h}>],
3009                         [initscr(); mousemask(0,0); tigetstr((char *)0);],
3010                         [AC_TRY_RUN([#include <${cf_cv_ncurses_header:-curses.h}>
3011                                 int main(void)
3012                                 { const char *xx = curses_version(); return (xx == 0); }],
3013                                 [cf_have_ncuconfig=yes],
3014                                 [cf_have_ncuconfig=no],
3015                                 [cf_have_ncuconfig=maybe])],
3016                         [cf_have_ncuconfig=no])
3017                 AC_MSG_RESULT($cf_have_ncuconfig)
3018                 test "$cf_have_ncuconfig" = maybe && cf_have_ncuconfig=yes
3019                 if test "$cf_have_ncuconfig" != "yes"
3020                 then
3021                         CPPFLAGS="$cf_save_CPPFLAGS"
3022                         LIBS="$cf_save_LIBS"
3023                         NCURSES_CONFIG_PKG=none
3024                 else
3025                         AC_DEFINE(NCURSES,1,[Define to 1 if we are using ncurses headers/libraries])
3026                         NCURSES_CONFIG_PKG=$cf_ncuconfig_root
3027                         CF_TERM_HEADER
3028                 fi
3029
3030         else
3031                 AC_MSG_RESULT(no)
3032                 NCURSES_CONFIG_PKG=none
3033         fi
3034 else
3035         NCURSES_CONFIG_PKG=none
3036 fi
3037
3038 if test "x$cf_have_ncuconfig" = "xno"; then
3039         cf_ncurses_config="${cf_ncuconfig_root}${NCURSES_CONFIG_SUFFIX}-config"; echo "Looking for ${cf_ncurses_config}"
3040
3041         CF_ACVERSION_CHECK(2.52,
3042                 [AC_CHECK_TOOLS(NCURSES_CONFIG, ${cf_ncurses_config} ${cf_ncuconfig_root}6-config ${cf_ncuconfig_root}6-config ${cf_ncuconfig_root}5-config, none)],
3043                 [AC_PATH_PROGS(NCURSES_CONFIG,  ${cf_ncurses_config} ${cf_ncuconfig_root}6-config ${cf_ncuconfig_root}6-config ${cf_ncuconfig_root}5-config, none)])
3044
3045         if test "$NCURSES_CONFIG" != none ; then
3046
3047                 CF_APPEND_CFLAGS(`$NCURSES_CONFIG --cflags`)
3048                 CF_ADD_LIBS(`$NCURSES_CONFIG --libs`)
3049
3050                 # even with config script, some packages use no-override for curses.h
3051                 CF_CURSES_HEADER(ifelse($1,,ncurses,$1))
3052
3053                 dnl like CF_NCURSES_CPPFLAGS
3054                 AC_DEFINE(NCURSES,1,[Define to 1 if we are using ncurses headers/libraries])
3055
3056                 dnl like CF_NCURSES_LIBS
3057                 CF_UPPER(cf_nculib_ROOT,HAVE_LIB$cf_ncuconfig_root)
3058                 AC_DEFINE_UNQUOTED($cf_nculib_ROOT)
3059
3060                 dnl like CF_NCURSES_VERSION
3061                 cf_cv_ncurses_version="`$NCURSES_CONFIG --version`"
3062
3063         else
3064
3065                 CF_NCURSES_CPPFLAGS(ifelse($1,,ncurses,$1))
3066                 CF_NCURSES_LIBS(ifelse($1,,ncurses,$1))
3067
3068         fi
3069 else
3070         NCURSES_CONFIG=none
3071 fi
3072 ])dnl
3073 dnl ---------------------------------------------------------------------------
3074 dnl CF_NCURSES_CPPFLAGS version: 22 updated: 2021/01/02 09:31:20
3075 dnl -------------------
3076 dnl Look for the SVr4 curses clone 'ncurses' in the standard places, adjusting
3077 dnl the CPPFLAGS variable so we can include its header.
3078 dnl
3079 dnl The header files may be installed as either curses.h, or ncurses.h (would
3080 dnl be obsolete, except that some packagers prefer this name to distinguish it
3081 dnl from a "native" curses implementation).  If not installed for overwrite,
3082 dnl the curses.h file would be in an ncurses subdirectory (e.g.,
3083 dnl /usr/include/ncurses), but someone may have installed overwriting the
3084 dnl vendor's curses.  Only very old versions (pre-1.9.2d, the first autoconf'd
3085 dnl version) of ncurses don't define either __NCURSES_H or NCURSES_VERSION in
3086 dnl the header.
3087 dnl
3088 dnl If the installer has set $CFLAGS or $CPPFLAGS so that the ncurses header
3089 dnl is already in the include-path, don't even bother with this, since we cannot
3090 dnl easily determine which file it is.  In this case, it has to be <curses.h>.
3091 dnl
3092 dnl The optional parameter gives the root name of the library, in case it is
3093 dnl not installed as the default curses library.  That is how the
3094 dnl wide-character version of ncurses is installed.
3095 AC_DEFUN([CF_NCURSES_CPPFLAGS],
3096 [AC_REQUIRE([CF_WITH_CURSES_DIR])
3097
3098 AC_PROVIDE([CF_CURSES_CPPFLAGS])dnl
3099 cf_ncuhdr_root=ifelse($1,,ncurses,$1)
3100
3101 test -n "$cf_cv_curses_dir" && \
3102 test "$cf_cv_curses_dir" != "no" && { \
3103   CF_ADD_INCDIR($cf_cv_curses_dir/include/$cf_ncuhdr_root)
3104 }
3105
3106 AC_CACHE_CHECK(for $cf_ncuhdr_root header in include-path, cf_cv_ncurses_h,[
3107         cf_header_list="$cf_ncuhdr_root/curses.h $cf_ncuhdr_root/ncurses.h"
3108         { test "$cf_ncuhdr_root" = ncurses || test "$cf_ncuhdr_root" = ncursesw; } && cf_header_list="$cf_header_list curses.h ncurses.h"
3109         for cf_header in $cf_header_list
3110         do
3111                 CF_NCURSES_CC_CHECK(cf_cv_ncurses_h,$cf_header,$1)
3112                 test "$cf_cv_ncurses_h" != no && break
3113         done
3114 ])
3115
3116 CF_NCURSES_HEADER
3117 CF_TERM_HEADER
3118
3119 # some applications need this, but should check for NCURSES_VERSION
3120 AC_DEFINE(NCURSES,1,[Define to 1 if we are using ncurses headers/libraries])
3121
3122 CF_NCURSES_VERSION
3123 ])dnl
3124 dnl ---------------------------------------------------------------------------
3125 dnl CF_NCURSES_HEADER version: 7 updated: 2021/01/04 19:33:05
3126 dnl -----------------
3127 dnl Find a "curses" header file, e.g,. "curses.h", or one of the more common
3128 dnl variations of ncurses' installs.
3129 dnl
3130 dnl See also CF_CURSES_HEADER, which sets the same cache variable.
3131 AC_DEFUN([CF_NCURSES_HEADER],[
3132
3133 if test "$cf_cv_ncurses_h" != no ; then
3134         cf_cv_ncurses_header=$cf_cv_ncurses_h
3135 else
3136
3137 AC_CACHE_CHECK(for $cf_ncuhdr_root include-path, cf_cv_ncurses_h2,[
3138         test -n "$verbose" && echo
3139         CF_HEADER_PATH(cf_search,$cf_ncuhdr_root)
3140         test -n "$verbose" && echo "search path $cf_search"
3141         cf_save2_CPPFLAGS="$CPPFLAGS"
3142         for cf_incdir in $cf_search
3143         do
3144                 CF_ADD_INCDIR($cf_incdir)
3145                 for cf_header in \
3146                         ncurses.h \
3147                         curses.h
3148                 do
3149                         CF_NCURSES_CC_CHECK(cf_cv_ncurses_h2,$cf_header,$1)
3150                         if test "$cf_cv_ncurses_h2" != no ; then
3151                                 cf_cv_ncurses_h2=$cf_incdir/$cf_header
3152                                 test -n "$verbose" && echo $ECHO_N "    ... found $ECHO_C" 1>&AC_FD_MSG
3153                                 break
3154                         fi
3155                         test -n "$verbose" && echo "    ... tested $cf_incdir/$cf_header" 1>&AC_FD_MSG
3156                 done
3157                 CPPFLAGS="$cf_save2_CPPFLAGS"
3158                 test "$cf_cv_ncurses_h2" != no && break
3159         done
3160         test "$cf_cv_ncurses_h2" = no && AC_MSG_ERROR(not found)
3161         ])
3162
3163         CF_DIRNAME(cf_1st_incdir,$cf_cv_ncurses_h2)
3164         cf_cv_ncurses_header="`basename "$cf_cv_ncurses_h2"`"
3165         if test "`basename "$cf_1st_incdir"`" = "$cf_ncuhdr_root" ; then
3166                 cf_cv_ncurses_header="$cf_ncuhdr_root/$cf_cv_ncurses_header"
3167         fi
3168         CF_ADD_INCDIR($cf_1st_incdir)
3169
3170 fi
3171
3172 # Set definitions to allow ifdef'ing for ncurses.h
3173
3174 case "$cf_cv_ncurses_header" in
3175 (*ncurses.h)
3176         AC_DEFINE(HAVE_NCURSES_H,1,[Define to 1 if we have ncurses.h])
3177         ;;
3178 esac
3179
3180 case "$cf_cv_ncurses_header" in
3181 (ncurses/curses.h|ncurses/ncurses.h)
3182         AC_DEFINE(HAVE_NCURSES_NCURSES_H,1,[Define to 1 if we have ncurses/ncurses.h])
3183         ;;
3184 (ncursesw/curses.h|ncursesw/ncurses.h)
3185         AC_DEFINE(HAVE_NCURSESW_NCURSES_H,1,[Define to 1 if we have ncursesw/ncurses.h])
3186         ;;
3187 esac
3188
3189 ])dnl
3190 dnl ---------------------------------------------------------------------------
3191 dnl CF_NCURSES_LIBS version: 21 updated: 2021/09/04 06:37:12
3192 dnl ---------------
3193 dnl Look for the ncurses library.  This is a little complicated on Linux,
3194 dnl because it may be linked with the gpm (general purpose mouse) library.
3195 dnl Some distributions have gpm linked with (bsd) curses, which makes it
3196 dnl unusable with ncurses.  However, we don't want to link with gpm unless
3197 dnl ncurses has a dependency, since gpm is normally set up as a shared library,
3198 dnl and the linker will record a dependency.
3199 dnl
3200 dnl The optional parameter gives the root name of the library, in case it is
3201 dnl not installed as the default curses library.  That is how the
3202 dnl wide-character version of ncurses is installed.
3203 AC_DEFUN([CF_NCURSES_LIBS],
3204 [AC_REQUIRE([CF_NCURSES_CPPFLAGS])
3205
3206 cf_nculib_root=ifelse($1,,ncurses,$1)
3207         # This works, except for the special case where we find gpm, but
3208         # ncurses is in a nonstandard location via $LIBS, and we really want
3209         # to link gpm.
3210 cf_ncurses_LIBS=""
3211 cf_ncurses_SAVE="$LIBS"
3212 AC_CHECK_LIB(gpm,Gpm_Open,
3213         [AC_CHECK_LIB(gpm,initscr,
3214                 [LIBS="$cf_ncurses_SAVE"],
3215                 [cf_ncurses_LIBS="-lgpm"])])
3216
3217 case "$host_os" in
3218 (freebsd*)
3219         # This is only necessary if you are linking against an obsolete
3220         # version of ncurses (but it should do no harm, since it is static).
3221         if test "$cf_nculib_root" = ncurses ; then
3222                 AC_CHECK_LIB(mytinfo,tgoto,[cf_ncurses_LIBS="-lmytinfo $cf_ncurses_LIBS"])
3223         fi
3224         ;;
3225 esac
3226
3227 CF_ADD_LIBS($cf_ncurses_LIBS)
3228
3229 if test -n "$cf_cv_curses_dir" && test "$cf_cv_curses_dir" != "no"
3230 then
3231         CF_ADD_LIBS(-l$cf_nculib_root)
3232 else
3233         CF_FIND_LIBRARY($cf_nculib_root,$cf_nculib_root,
3234                 [#include <${cf_cv_ncurses_header:-curses.h}>],
3235                 [initscr()],
3236                 initscr)
3237 fi
3238
3239 if test -n "$cf_ncurses_LIBS" ; then
3240         AC_MSG_CHECKING(if we can link $cf_nculib_root without $cf_ncurses_LIBS)
3241         cf_ncurses_SAVE="$LIBS"
3242         for p in $cf_ncurses_LIBS ; do
3243                 q=`echo "$LIBS" | sed -e "s%$p %%" -e "s%$p$%%"`
3244                 if test "$q" != "$LIBS" ; then
3245                         LIBS="$q"
3246                 fi
3247         done
3248         AC_TRY_LINK([#include <${cf_cv_ncurses_header:-curses.h}>],
3249                 [initscr(); mousemask(0,0); tigetstr((char *)0);],
3250                 [AC_MSG_RESULT(yes)],
3251                 [AC_MSG_RESULT(no)
3252                  LIBS="$cf_ncurses_SAVE"])
3253 fi
3254
3255 CF_UPPER(cf_nculib_ROOT,HAVE_LIB$cf_nculib_root)
3256 AC_DEFINE_UNQUOTED($cf_nculib_ROOT)
3257 ])dnl
3258 dnl ---------------------------------------------------------------------------
3259 dnl CF_NCURSES_VERSION version: 17 updated: 2023/01/05 18:54:02
3260 dnl ------------------
3261 dnl Check for the version of ncurses, to aid in reporting bugs, etc.
3262 dnl Call CF_CURSES_CPPFLAGS first, or CF_NCURSES_CPPFLAGS.  We don't use
3263 dnl AC_REQUIRE since that does not work with the shell's if/then/else/fi.
3264 AC_DEFUN([CF_NCURSES_VERSION],
3265 [
3266 AC_REQUIRE([CF_CURSES_CPPFLAGS])dnl
3267 AC_CACHE_CHECK(for ncurses version, cf_cv_ncurses_version,[
3268         cf_cv_ncurses_version=no
3269         cf_tempfile=out$$
3270         rm -f "$cf_tempfile"
3271         AC_TRY_RUN([
3272 $ac_includes_default
3273
3274 #include <${cf_cv_ncurses_header:-curses.h}>
3275
3276 int main(void)
3277 {
3278         FILE *fp = fopen("$cf_tempfile", "w");
3279 #ifdef NCURSES_VERSION
3280 # ifdef NCURSES_VERSION_PATCH
3281         fprintf(fp, "%s.%d\\n", NCURSES_VERSION, NCURSES_VERSION_PATCH);
3282 # else
3283         fprintf(fp, "%s\\n", NCURSES_VERSION);
3284 # endif
3285 #else
3286 # ifdef __NCURSES_H
3287         fprintf(fp, "old\\n");
3288 # else
3289         make an error
3290 # endif
3291 #endif
3292         ${cf_cv_main_return:-return}(0);
3293 }],[
3294         cf_cv_ncurses_version=`cat $cf_tempfile`],,[
3295
3296         # This will not work if the preprocessor splits the line after the
3297         # Autoconf token.  The 'unproto' program does that.
3298         cat > "conftest.$ac_ext" <<EOF
3299 #include <${cf_cv_ncurses_header:-curses.h}>
3300 #undef Autoconf
3301 #ifdef NCURSES_VERSION
3302 Autoconf NCURSES_VERSION
3303 #else
3304 #ifdef __NCURSES_H
3305 Autoconf "old"
3306 #endif
3307 ;
3308 #endif
3309 EOF
3310         cf_try="$ac_cpp conftest.$ac_ext 2>&AC_FD_CC | grep '^Autoconf ' >conftest.out"
3311         AC_TRY_EVAL(cf_try)
3312         if test -f conftest.out ; then
3313                 cf_out=`sed -e 's%^Autoconf %%' -e 's%^[[^"]]*"%%' -e 's%".*%%' conftest.out`
3314                 test -n "$cf_out" && cf_cv_ncurses_version="$cf_out"
3315                 rm -f conftest.out
3316         fi
3317 ])
3318         rm -f "$cf_tempfile"
3319 ])
3320 test "$cf_cv_ncurses_version" = no || AC_DEFINE(NCURSES,1,[Define to 1 if we are using ncurses headers/libraries])
3321 ])dnl
3322 dnl ---------------------------------------------------------------------------
3323 dnl CF_OBJ_SUBDIR version: 8 updated: 2021/01/01 13:31:04
3324 dnl -------------
3325 dnl Compute the object-directory name from the given model name
3326 AC_DEFUN([CF_OBJ_SUBDIR],
3327 [
3328         case $1 in
3329         (libtool) $2='obj_lo'  ;;
3330         (normal)  $2='objects' ;;
3331         (debug)   $2='obj_g' ;;
3332         (profile) $2='obj_p' ;;
3333         (shared)
3334                 case "$cf_cv_system_name" in
3335                 (cygwin|msys)
3336                         $2='objects' ;;
3337                 (*)
3338                         $2='obj_s' ;;
3339                 esac
3340         esac
3341 ])dnl
3342 dnl ---------------------------------------------------------------------------
3343 dnl CF_PATHSEP version: 8 updated: 2021/01/01 13:31:04
3344 dnl ----------
3345 dnl Provide a value for the $PATH and similar separator (or amend the value
3346 dnl as provided in autoconf 2.5x).
3347 AC_DEFUN([CF_PATHSEP],
3348 [
3349         AC_MSG_CHECKING(for PATH separator)
3350         case "$cf_cv_system_name" in
3351         (os2*)  PATH_SEPARATOR=';'  ;;
3352         (*)     ${PATH_SEPARATOR:=':'}  ;;
3353         esac
3354 ifelse([$1],,,[$1=$PATH_SEPARATOR])
3355         AC_SUBST(PATH_SEPARATOR)
3356         AC_MSG_RESULT($PATH_SEPARATOR)
3357 ])dnl
3358 dnl ---------------------------------------------------------------------------
3359 dnl CF_PATH_SYNTAX version: 18 updated: 2020/12/31 18:40:20
3360 dnl --------------
3361 dnl Check the argument to see that it looks like a pathname.  Rewrite it if it
3362 dnl begins with one of the prefix/exec_prefix variables, and then again if the
3363 dnl result begins with 'NONE'.  This is necessary to work around autoconf's
3364 dnl delayed evaluation of those symbols.
3365 AC_DEFUN([CF_PATH_SYNTAX],[
3366 if test "x$prefix" != xNONE; then
3367         cf_path_syntax="$prefix"
3368 else
3369         cf_path_syntax="$ac_default_prefix"
3370 fi
3371
3372 case ".[$]$1" in
3373 (.\[$]\(*\)*|.\'*\'*)
3374         ;;
3375 (..|./*|.\\*)
3376         ;;
3377 (.[[a-zA-Z]]:[[\\/]]*) # OS/2 EMX
3378         ;;
3379 (.\[$]\{*prefix\}*|.\[$]\{*dir\}*)
3380         eval $1="[$]$1"
3381         case ".[$]$1" in
3382         (.NONE/*)
3383                 $1=`echo "[$]$1" | sed -e s%NONE%$cf_path_syntax%`
3384                 ;;
3385         esac
3386         ;;
3387 (.no|.NONE/*)
3388         $1=`echo "[$]$1" | sed -e s%NONE%$cf_path_syntax%`
3389         ;;
3390 (*)
3391         ifelse([$2],,[AC_MSG_ERROR([expected a pathname, not \"[$]$1\"])],$2)
3392         ;;
3393 esac
3394 ])dnl
3395 dnl ---------------------------------------------------------------------------
3396 dnl CF_PKG_CONFIG version: 12 updated: 2021/10/10 20:18:09
3397 dnl -------------
3398 dnl Check for the package-config program, unless disabled by command-line.
3399 dnl
3400 dnl Sets $PKG_CONFIG to the pathname of the pkg-config program.
3401 AC_DEFUN([CF_PKG_CONFIG],
3402 [
3403 AC_MSG_CHECKING(if you want to use pkg-config)
3404 AC_ARG_WITH(pkg-config,
3405         [  --with-pkg-config{=path} enable/disable use of pkg-config],
3406         [cf_pkg_config=$withval],
3407         [cf_pkg_config=yes])
3408 AC_MSG_RESULT($cf_pkg_config)
3409
3410 case "$cf_pkg_config" in
3411 (no)
3412         PKG_CONFIG=none
3413         ;;
3414 (yes)
3415         CF_ACVERSION_CHECK(2.52,
3416                 [AC_PATH_TOOL(PKG_CONFIG, pkg-config, none)],
3417                 [AC_PATH_PROG(PKG_CONFIG, pkg-config, none)])
3418         ;;
3419 (*)
3420         PKG_CONFIG=$withval
3421         ;;
3422 esac
3423
3424 test -z "$PKG_CONFIG" && PKG_CONFIG=none
3425 if test "$PKG_CONFIG" != none ; then
3426         CF_PATH_SYNTAX(PKG_CONFIG)
3427 elif test "x$cf_pkg_config" != xno ; then
3428         AC_MSG_WARN(pkg-config is not installed)
3429 fi
3430
3431 AC_SUBST(PKG_CONFIG)
3432 ])dnl
3433 dnl ---------------------------------------------------------------------------
3434 dnl CF_POSIX_C_SOURCE version: 11 updated: 2018/12/31 20:46:17
3435 dnl -----------------
3436 dnl Define _POSIX_C_SOURCE to the given level, and _POSIX_SOURCE if needed.
3437 dnl
3438 dnl     POSIX.1-1990                            _POSIX_SOURCE
3439 dnl     POSIX.1-1990 and                        _POSIX_SOURCE and
3440 dnl             POSIX.2-1992 C-Language                 _POSIX_C_SOURCE=2
3441 dnl             Bindings Option
3442 dnl     POSIX.1b-1993                           _POSIX_C_SOURCE=199309L
3443 dnl     POSIX.1c-1996                           _POSIX_C_SOURCE=199506L
3444 dnl     X/Open 2000                             _POSIX_C_SOURCE=200112L
3445 dnl
3446 dnl Parameters:
3447 dnl     $1 is the nominal value for _POSIX_C_SOURCE
3448 AC_DEFUN([CF_POSIX_C_SOURCE],
3449 [AC_REQUIRE([CF_POSIX_VISIBLE])dnl
3450
3451 if test "$cf_cv_posix_visible" = no; then
3452
3453 cf_POSIX_C_SOURCE=ifelse([$1],,199506L,[$1])
3454
3455 cf_save_CFLAGS="$CFLAGS"
3456 cf_save_CPPFLAGS="$CPPFLAGS"
3457
3458 CF_REMOVE_DEFINE(cf_trim_CFLAGS,$cf_save_CFLAGS,_POSIX_C_SOURCE)
3459 CF_REMOVE_DEFINE(cf_trim_CPPFLAGS,$cf_save_CPPFLAGS,_POSIX_C_SOURCE)
3460
3461 AC_CACHE_CHECK(if we should define _POSIX_C_SOURCE,cf_cv_posix_c_source,[
3462         CF_MSG_LOG(if the symbol is already defined go no further)
3463         AC_TRY_COMPILE([#include <sys/types.h>],[
3464 #ifndef _POSIX_C_SOURCE
3465 make an error
3466 #endif],
3467         [cf_cv_posix_c_source=no],
3468         [cf_want_posix_source=no
3469          case .$cf_POSIX_C_SOURCE in
3470          (.[[12]]??*)
3471                 cf_cv_posix_c_source="-D_POSIX_C_SOURCE=$cf_POSIX_C_SOURCE"
3472                 ;;
3473          (.2)
3474                 cf_cv_posix_c_source="-D_POSIX_C_SOURCE=$cf_POSIX_C_SOURCE"
3475                 cf_want_posix_source=yes
3476                 ;;
3477          (.*)
3478                 cf_want_posix_source=yes
3479                 ;;
3480          esac
3481          if test "$cf_want_posix_source" = yes ; then
3482                 AC_TRY_COMPILE([#include <sys/types.h>],[
3483 #ifdef _POSIX_SOURCE
3484 make an error
3485 #endif],[],
3486                 cf_cv_posix_c_source="$cf_cv_posix_c_source -D_POSIX_SOURCE")
3487          fi
3488          CF_MSG_LOG(ifdef from value $cf_POSIX_C_SOURCE)
3489          CFLAGS="$cf_trim_CFLAGS"
3490          CPPFLAGS="$cf_trim_CPPFLAGS"
3491          CF_APPEND_TEXT(CPPFLAGS,$cf_cv_posix_c_source)
3492          CF_MSG_LOG(if the second compile does not leave our definition intact error)
3493          AC_TRY_COMPILE([#include <sys/types.h>],[
3494 #ifndef _POSIX_C_SOURCE
3495 make an error
3496 #endif],,
3497          [cf_cv_posix_c_source=no])
3498          CFLAGS="$cf_save_CFLAGS"
3499          CPPFLAGS="$cf_save_CPPFLAGS"
3500         ])
3501 ])
3502
3503 if test "$cf_cv_posix_c_source" != no ; then
3504         CFLAGS="$cf_trim_CFLAGS"
3505         CPPFLAGS="$cf_trim_CPPFLAGS"
3506         CF_ADD_CFLAGS($cf_cv_posix_c_source)
3507 fi
3508
3509 fi # cf_cv_posix_visible
3510
3511 ])dnl
3512 dnl ---------------------------------------------------------------------------
3513 dnl CF_POSIX_VISIBLE version: 1 updated: 2018/12/31 20:46:17
3514 dnl ----------------
3515 dnl POSIX documents test-macros which an application may set before any system
3516 dnl headers are included to make features available.
3517 dnl
3518 dnl Some BSD platforms (originally FreeBSD, but copied by a few others)
3519 dnl diverged from POSIX in 2002 by setting symbols which make all of the most
3520 dnl recent features visible in the system header files unless the application
3521 dnl overrides the corresponding test-macros.  Doing that introduces portability
3522 dnl problems.
3523 dnl
3524 dnl This macro makes a special check for the symbols used for this, to avoid a
3525 dnl conflicting definition.
3526 AC_DEFUN([CF_POSIX_VISIBLE],
3527 [
3528 AC_CACHE_CHECK(if the POSIX test-macros are already defined,cf_cv_posix_visible,[
3529 AC_TRY_COMPILE([#include <stdio.h>],[
3530 #if defined(__POSIX_VISIBLE) && ((__POSIX_VISIBLE - 0L) > 0) \
3531         && defined(__XSI_VISIBLE) && ((__XSI_VISIBLE - 0L) > 0) \
3532         && defined(__BSD_VISIBLE) && ((__BSD_VISIBLE - 0L) > 0) \
3533         && defined(__ISO_C_VISIBLE) && ((__ISO_C_VISIBLE - 0L) > 0)
3534 #error conflicting symbols found
3535 #endif
3536 ],[cf_cv_posix_visible=no],[cf_cv_posix_visible=yes])
3537 ])
3538 ])dnl
3539 dnl ---------------------------------------------------------------------------
3540 dnl CF_PROG_AR version: 1 updated: 2009/01/01 20:15:22
3541 dnl ----------
3542 dnl Check for archiver "ar".
3543 AC_DEFUN([CF_PROG_AR],[
3544 AC_CHECK_TOOL(AR, ar, ar)
3545 ])
3546 dnl ---------------------------------------------------------------------------
3547 dnl CF_PROG_AWK version: 1 updated: 2006/09/16 11:40:59
3548 dnl -----------
3549 dnl Check for awk, ensure that the check found something.
3550 AC_DEFUN([CF_PROG_AWK],
3551 [
3552 AC_PROG_AWK
3553 test -z "$AWK" && AC_MSG_ERROR(No awk program found)
3554 ])dnl
3555 dnl ---------------------------------------------------------------------------
3556 dnl CF_PROG_CC version: 5 updated: 2019/12/31 08:53:54
3557 dnl ----------
3558 dnl standard check for CC, plus followup sanity checks
3559 dnl $1 = optional parameter to pass to AC_PROG_CC to specify compiler name
3560 AC_DEFUN([CF_PROG_CC],[
3561 CF_ACVERSION_CHECK(2.53,
3562         [AC_MSG_WARN(this will incorrectly handle gnatgcc choice)
3563          AC_REQUIRE([AC_PROG_CC])],
3564         [])
3565 ifelse($1,,[AC_PROG_CC],[AC_PROG_CC($1)])
3566 CF_GCC_VERSION
3567 CF_ACVERSION_CHECK(2.52,
3568         [AC_PROG_CC_STDC],
3569         [CF_ANSI_CC_REQD])
3570 CF_CC_ENV_FLAGS
3571 ])dnl
3572 dnl ---------------------------------------------------------------------------
3573 dnl CF_PROG_CC_C_O version: 6 updated: 2021/01/01 13:31:04
3574 dnl --------------
3575 dnl Analogous to AC_PROG_CC_C_O, but more useful: tests only $CC, ensures that
3576 dnl the output file can be renamed, and allows for a shell variable that can
3577 dnl be used later.  The parameter is either CC or CXX.  The result is the
3578 dnl cache variable:
3579 dnl     $cf_cv_prog_CC_c_o
3580 dnl     $cf_cv_prog_CXX_c_o
3581 dnl
3582 dnl $1 = compiler
3583 dnl $2 = compiler options, if any
3584 AC_DEFUN([CF_PROG_CC_C_O],
3585 [AC_REQUIRE([AC_PROG_CC])dnl
3586 AC_MSG_CHECKING([whether [$]$1 understands -c and -o together])
3587 AC_CACHE_VAL(cf_cv_prog_$1_c_o,
3588 [
3589 cat > conftest.$ac_ext <<CF_EOF
3590 int main(void)
3591 {
3592         ${cf_cv_main_return:-return}(0);
3593 }
3594 CF_EOF
3595 # We do the test twice because some compilers refuse to overwrite an
3596 # existing .o file with -o, though they will create one.
3597 ac_try='[$]$1 $2 -c conftest.$ac_ext -o conftest2.$ac_objext >&AC_FD_CC'
3598 if AC_TRY_EVAL(ac_try) &&
3599   test -f conftest2.$ac_objext && AC_TRY_EVAL(ac_try);
3600 then
3601   eval cf_cv_prog_$1_c_o=yes
3602 else
3603   eval cf_cv_prog_$1_c_o=no
3604 fi
3605 rm -rf ./conftest*
3606 ])dnl
3607 if test "$cf_cv_prog_$1_c_o" = yes; then
3608   AC_MSG_RESULT([yes])
3609 else
3610   AC_MSG_RESULT([no])
3611 fi
3612 ])dnl
3613 dnl ---------------------------------------------------------------------------
3614 dnl CF_PROG_EGREP version: 2 updated: 2015/04/18 08:56:57
3615 dnl -------------
3616 dnl AC_PROG_EGREP was introduced in autoconf 2.53.
3617 dnl This macro adds a check to ensure the script found something.
3618 AC_DEFUN([CF_PROG_EGREP],
3619 [AC_CACHE_CHECK([for egrep], [ac_cv_prog_egrep],
3620         [if echo a | (grep -E '(a|b)') >/dev/null 2>&1
3621                 then ac_cv_prog_egrep='grep -E'
3622                 else ac_cv_prog_egrep='egrep'
3623         fi])
3624         EGREP=$ac_cv_prog_egrep
3625         AC_SUBST([EGREP])
3626         test -z "$EGREP" && AC_MSG_ERROR(No egrep program found)
3627 ])dnl
3628 dnl ---------------------------------------------------------------------------
3629 dnl CF_PROG_EXT version: 15 updated: 2021/01/02 09:31:20
3630 dnl -----------
3631 dnl Compute $PROG_EXT, used for non-Unix ports, such as OS/2 EMX.
3632 AC_DEFUN([CF_PROG_EXT],
3633 [
3634 AC_REQUIRE([CF_CHECK_CACHE])
3635 case "$cf_cv_system_name" in
3636 (os2*)
3637         CFLAGS="$CFLAGS -Zmt"
3638         CF_APPEND_TEXT(CPPFLAGS,-D__ST_MT_ERRNO__)
3639         CXXFLAGS="$CXXFLAGS -Zmt"
3640         # autoconf's macro sets -Zexe and suffix both, which conflict:w
3641         LDFLAGS="$LDFLAGS -Zmt -Zcrtdll"
3642         ac_cv_exeext=.exe
3643         ;;
3644 esac
3645
3646 AC_EXEEXT
3647 AC_OBJEXT
3648
3649 PROG_EXT="$EXEEXT"
3650 AC_SUBST(PROG_EXT)
3651 test -n "$PROG_EXT" && AC_DEFINE_UNQUOTED(PROG_EXT,"$PROG_EXT",[Define to the program extension (normally blank)])
3652 ])dnl
3653 dnl ---------------------------------------------------------------------------
3654 dnl CF_PROG_GNAT version: 12 updated: 2021/01/02 17:09:14
3655 dnl ------------
3656 dnl Check for gnat/gnatmake/etc, ensure that the toolset is complete.
3657 AC_DEFUN([CF_PROG_GNAT],[
3658 for cf_prog_gnat in gnat gnatmake gprconfig gprbuild
3659 do
3660         CF_UPPER(cf_upper_prog_gnat,${cf_prog_gnat})
3661
3662         unset ac_cv_path_cf_TEMP_gnat
3663         unset cf_TEMP_gnat
3664         AC_PATH_PROG(cf_TEMP_gnat,$cf_prog_gnat,no)
3665         eval "cf_cv_PATH_$cf_upper_prog_gnat=[$]ac_cv_path_cf_TEMP_gnat"
3666
3667         if test "x$cf_TEMP_gnat" != xno; then
3668                 unset cf_cv_gnat_version
3669                 unset cf_TEMP_gnat
3670                 CF_GNAT_VERSION(cf_TEMP_gnat,$cf_prog_gnat)
3671         fi
3672         eval "cf_cv_VERSION_$cf_upper_prog_gnat=[$]cf_TEMP_gnat"
3673
3674         unset cf_TEMP_gnat
3675         unset cf_cv_gnat_version
3676         unset ac_cv_path_cf_TEMP_gnat
3677 done
3678
3679 if test "x$cf_cv_VERSION_GNATMAKE" = "xno"; then
3680         cf_ada_make=
3681         cf_cv_prog_gnat_correct=no
3682 else
3683         cf_ada_make=gnatmake
3684         if test "x$cf_cv_VERSION_GPRCONFIG" = "xno"; then
3685                 # gprconfig is newer than gnatmake; we can continue...
3686                 cf_ada_config="##"
3687         else
3688                 rm -rf ./conftest* ./*~conftest*
3689                 if mkdir conftest.src
3690                 then
3691                         cf_ada_config=""
3692                         cd conftest.src
3693                         for cf_gprconfig in Ada C
3694                         do
3695                                 AC_MSG_CHECKING(for gprconfig name for $cf_gprconfig)
3696                                 if test "$cf_gprconfig" = C
3697                                 then
3698                                         for cf_gprconfig_param in \
3699                                                 "$cf_gprconfig,,,,GNATGCC" \
3700                                                 "$cf_gprconfig,,,,GCC" \
3701                                                 "$cf_gprconfig"
3702                                         do
3703                                                 cf_gprconfig_value=`echo s| gprconfig --config=$cf_gprconfig_param 2>&AC_FD_CC | ${AWK:-awk} '/^\*/{print [$]3;}' | head -n 1`
3704                                                 test -n "$cf_gprconfig_value" && break
3705                                         done
3706                                 else
3707                                         cf_gprconfig_param=$cf_gprconfig
3708                                         cf_gprconfig_value=`echo s| gprconfig --config=$cf_gprconfig_param 2>&AC_FD_CC | ${AWK:-awk} '/^\*/{print [$]3;}' | head -n 1`
3709                                 fi
3710                                 if test -n "$cf_gprconfig_value"
3711                                 then
3712                                         eval "cf_ada_config_[$]cf_gprconfig=[$]cf_gprconfig_value"
3713                                         AC_MSG_RESULT($cf_gprconfig_value)
3714                                 else
3715                                         AC_MSG_RESULT(missing)
3716                                         cf_ada_config="#"
3717                                         break
3718                                 fi
3719                         done
3720                         cd ..
3721                         rm -rf ./conftest* ./*~conftest*
3722                 fi
3723         fi
3724         if test "x$cf_ada_config" != "x#"
3725         then
3726                 CF_GNAT_VERSION
3727                 CF_CHECK_GNAT_VERSION
3728                 AC_CHECK_PROG(M4_exists, m4, yes, no)
3729                 if test "$ac_cv_prog_M4_exists" = no; then
3730                         cf_cv_prog_gnat_correct=no
3731                         AC_MSG_WARN(Ada95 binding required program m4 not found. Ada95 binding disabled)
3732                 fi
3733                 if test "$cf_cv_prog_gnat_correct" = yes; then
3734                         AC_MSG_CHECKING(if GNAT works)
3735                         CF_GNAT_TRY_RUN([procedure conftest;],
3736 [with Text_IO;
3737 with GNAT.OS_Lib;
3738 procedure conftest is
3739 begin
3740    Text_IO.Put ("Hello World");
3741    Text_IO.New_Line;
3742    GNAT.OS_Lib.OS_Exit (0);
3743 end conftest;],
3744 [cf_cv_prog_gnat_correct=yes],
3745 [cf_cv_prog_gnat_correct=no])
3746                         AC_MSG_RESULT($cf_cv_prog_gnat_correct)
3747                 fi
3748         else
3749                 cf_cv_prog_gnat_correct=no
3750         fi
3751 fi
3752
3753 AC_SUBST(cf_ada_make)
3754 AC_SUBST(cf_ada_config)
3755 AC_SUBST(cf_ada_config_Ada)
3756 AC_SUBST(cf_ada_config_C)
3757 ])dnl
3758 dnl ---------------------------------------------------------------------------
3759 dnl CF_PROG_INSTALL version: 10 updated: 2021/01/04 19:33:05
3760 dnl ---------------
3761 dnl Force $INSTALL to be an absolute-path.  Otherwise, edit_man.sh and the
3762 dnl misc/tabset install won't work properly.  Usually this happens only when
3763 dnl using the fallback mkinstalldirs script
3764 AC_DEFUN([CF_PROG_INSTALL],
3765 [AC_PROG_INSTALL
3766 case $INSTALL in
3767 (/*)
3768         ;;
3769 (*)
3770         CF_DIRNAME(cf_dir,$INSTALL)
3771         test -z "$cf_dir" && cf_dir=.
3772         INSTALL="`cd \"$cf_dir\" && pwd`"/"`echo "$INSTALL" | sed -e 's%^.*/%%'`"
3773         ;;
3774 esac
3775 ])dnl
3776 dnl ---------------------------------------------------------------------------
3777 dnl CF_PROG_LN_S version: 2 updated: 2010/08/14 18:25:37
3778 dnl ------------
3779 dnl Combine checks for "ln -s" and "ln -sf", updating $LN_S to include "-f"
3780 dnl option if it is supported.
3781 AC_DEFUN([CF_PROG_LN_S],[
3782 AC_PROG_LN_S
3783 AC_MSG_CHECKING(if $LN_S -f options work)
3784
3785 rm -f conf$$.src conf$$dst
3786 echo >conf$$.dst
3787 echo first >conf$$.src
3788 if $LN_S -f conf$$.src conf$$.dst 2>/dev/null; then
3789         cf_prog_ln_sf=yes
3790 else
3791         cf_prog_ln_sf=no
3792 fi
3793 rm -f conf$$.dst conf$$src
3794 AC_MSG_RESULT($cf_prog_ln_sf)
3795
3796 test "$cf_prog_ln_sf" = yes && LN_S="$LN_S -f"
3797 ])dnl
3798 dnl ---------------------------------------------------------------------------
3799 dnl CF_REMOVE_CFLAGS version: 3 updated: 2021/09/05 17:25:40
3800 dnl ----------------
3801 dnl Remove a given option from CFLAGS/CPPFLAGS
3802 dnl $1 = option to remove
3803 dnl $2 = variable to update
3804 dnl $3 = nonempty to allow verbose message
3805 define([CF_REMOVE_CFLAGS],
3806 [
3807 cf_tmp_cflag=`echo "x$1" | sed -e 's/^.//' -e 's/=.*//'`
3808 while true
3809 do
3810         cf_old_cflag=`echo "x[$]$2" | sed -e 's/^.//' -e 's/[[  ]][[    ]]*-/ -/g' -e "s%$cf_tmp_cflag\\(=[[^   ]][[^   ]]*\\)\?%%" -e 's/^[[   ]]*//' -e 's%[[ ]][[ ]]*-D% -D%g' -e 's%[[ ]][[ ]]*-I% -I%g'`
3811         test "[$]$2" != "$cf_old_cflag" || break
3812         ifelse([$3],,,[CF_VERBOSE(removing old option $1 from $2)])
3813         $2="$cf_old_cflag"
3814 done
3815 ])dnl
3816 dnl ---------------------------------------------------------------------------
3817 dnl CF_REMOVE_DEFINE version: 3 updated: 2010/01/09 11:05:50
3818 dnl ----------------
3819 dnl Remove all -U and -D options that refer to the given symbol from a list
3820 dnl of C compiler options.  This works around the problem that not all
3821 dnl compilers process -U and -D options from left-to-right, so a -U option
3822 dnl cannot be used to cancel the effect of a preceding -D option.
3823 dnl
3824 dnl $1 = target (which could be the same as the source variable)
3825 dnl $2 = source (including '$')
3826 dnl $3 = symbol to remove
3827 define([CF_REMOVE_DEFINE],
3828 [
3829 $1=`echo "$2" | \
3830         sed     -e 's/-[[UD]]'"$3"'\(=[[^       ]]*\)\?[[       ]]/ /g' \
3831                 -e 's/-[[UD]]'"$3"'\(=[[^       ]]*\)\?[$]//g'`
3832 ])dnl
3833 dnl ---------------------------------------------------------------------------
3834 dnl CF_REMOVE_LIB version: 1 updated: 2007/02/17 14:11:52
3835 dnl -------------
3836 dnl Remove the given library from the symbol
3837 dnl
3838 dnl $1 = target (which could be the same as the source variable)
3839 dnl $2 = source (including '$')
3840 dnl $3 = library to remove
3841 define([CF_REMOVE_LIB],
3842 [
3843 # remove $3 library from $2
3844 $1=`echo "$2" | sed -e 's/-l$3[[        ]]//g' -e 's/-l$3[$]//'`
3845 ])dnl
3846 dnl ---------------------------------------------------------------------------
3847 dnl CF_RESTORE_XTRA_FLAGS version: 1 updated: 2020/01/11 16:47:45
3848 dnl ---------------------
3849 dnl Restore flags saved in CF_SAVE_XTRA_FLAGS
3850 dnl $1 = name of current macro
3851 define([CF_RESTORE_XTRA_FLAGS],
3852 [
3853 LIBS="$cf_save_LIBS_$1"
3854 CFLAGS="$cf_save_CFLAGS_$1"
3855 CPPFLAGS="$cf_save_CPPFLAGS_$1"
3856 ])dnl
3857 dnl ---------------------------------------------------------------------------
3858 dnl CF_SAVE_XTRA_FLAGS version: 1 updated: 2020/01/11 16:46:44
3859 dnl ------------------
3860 dnl Use this macro to save CFLAGS/CPPFLAGS/LIBS before checks against X headers
3861 dnl and libraries which do not update those variables.
3862 dnl
3863 dnl $1 = name of current macro
3864 define([CF_SAVE_XTRA_FLAGS],
3865 [
3866 cf_save_LIBS_$1="$LIBS"
3867 cf_save_CFLAGS_$1="$CFLAGS"
3868 cf_save_CPPFLAGS_$1="$CPPFLAGS"
3869 LIBS="$LIBS ${X_PRE_LIBS} ${X_LIBS} ${X_EXTRA_LIBS}"
3870 for cf_X_CFLAGS in $X_CFLAGS
3871 do
3872         case "x$cf_X_CFLAGS" in
3873         x-[[IUD]]*)
3874                 CPPFLAGS="$CPPFLAGS $cf_X_CFLAGS"
3875                 ;;
3876         *)
3877                 CFLAGS="$CFLAGS $cf_X_CFLAGS"
3878                 ;;
3879         esac
3880 done
3881 ])dnl
3882 dnl ---------------------------------------------------------------------------
3883 dnl CF_SHARED_OPTS version: 107 updated: 2021/09/04 06:47:34
3884 dnl --------------
3885 dnl --------------
3886 dnl Attempt to determine the appropriate CC/LD options for creating a shared
3887 dnl library.
3888 dnl
3889 dnl Notes:
3890 dnl a) ${LOCAL_LDFLAGS} is used to link executables that will run within
3891 dnl the build-tree, i.e., by making use of the libraries that are compiled in
3892 dnl $rel_builddir/lib We avoid compiling-in a $rel_builddir/lib path for the
3893 dnl shared library since that can lead to unexpected results at runtime.
3894 dnl b) ${LOCAL_LDFLAGS2} has the same intention but assumes that the shared
3895 dnl libraries are compiled in ../../lib
3896 dnl
3897 dnl The variable 'cf_cv_do_symlinks' is used to control whether we configure
3898 dnl to install symbolic links to the rel/abi versions of shared libraries.
3899 dnl
3900 dnl The variable 'cf_cv_shlib_version' controls whether we use the rel or abi
3901 dnl version when making symbolic links.
3902 dnl
3903 dnl The variable 'cf_cv_shlib_version_infix' controls whether shared library
3904 dnl version numbers are infix (ex: libncurses.<ver>.dylib) or postfix
3905 dnl (ex: libncurses.so.<ver>).
3906 dnl
3907 dnl Some loaders leave 'so_locations' lying around.  It is nice to clean up.
3908 AC_DEFUN([CF_SHARED_OPTS],
3909 [
3910         AC_REQUIRE([CF_LD_RPATH_OPT])
3911
3912         RM_SHARED_OPTS=
3913         LOCAL_LDFLAGS=
3914         LOCAL_LDFLAGS2=
3915         LD_SHARED_OPTS=
3916         INSTALL_LIB="-m 644"
3917         : ${rel_builddir:=.}
3918
3919         shlibdir=$libdir
3920         AC_SUBST(shlibdir)
3921
3922         MAKE_DLLS="#"
3923         AC_SUBST(MAKE_DLLS)
3924
3925         cf_cv_do_symlinks=no
3926         cf_ld_rpath_opt=
3927         test "$cf_cv_enable_rpath" = yes && cf_ld_rpath_opt="$LD_RPATH_OPT"
3928
3929         AC_MSG_CHECKING(if release/abi version should be used for shared libs)
3930         AC_ARG_WITH(shlib-version,
3931         [  --with-shlib-version=X  Specify rel or abi version for shared libs],
3932         [test -z "$withval" && withval=auto
3933         case "$withval" in
3934         (yes)
3935                 cf_cv_shlib_version=auto
3936                 ;;
3937         (rel|abi|auto)
3938                 cf_cv_shlib_version=$withval
3939                 ;;
3940         (*)
3941                 AC_MSG_RESULT($withval)
3942                 AC_MSG_ERROR([option value must be one of: rel, abi, or auto])
3943                 ;;
3944         esac
3945         ],[cf_cv_shlib_version=auto])
3946         AC_MSG_RESULT($cf_cv_shlib_version)
3947
3948         cf_cv_rm_so_locs=no
3949         cf_try_cflags=
3950
3951         # Some less-capable ports of gcc support only -fpic
3952         CC_SHARED_OPTS=
3953
3954         cf_try_fPIC=no
3955         if test "$GCC" = yes
3956         then
3957                 cf_try_fPIC=yes
3958         else
3959                 case "$cf_cv_system_name" in
3960                 (*linux*)       # e.g., PGI compiler
3961                         cf_try_fPIC=yes
3962                         ;;
3963                 esac
3964         fi
3965
3966         if test "$cf_try_fPIC" = yes
3967         then
3968                 AC_MSG_CHECKING(which $CC option to use)
3969                 cf_save_CFLAGS="$CFLAGS"
3970                 for CC_SHARED_OPTS in -fPIC -fpic ''
3971                 do
3972                         CFLAGS="$cf_save_CFLAGS $CC_SHARED_OPTS"
3973                         AC_TRY_COMPILE([#include <stdio.h>],[int x = 1],[break],[])
3974                 done
3975                 AC_MSG_RESULT($CC_SHARED_OPTS)
3976                 CFLAGS="$cf_save_CFLAGS"
3977         fi
3978
3979         cf_cv_shlib_version_infix=no
3980
3981         case "$cf_cv_system_name" in
3982         (aix4.[3-9]*|aix[[5-7]]*)
3983                 if test "$GCC" = yes; then
3984                         CC_SHARED_OPTS='-Wl,-brtl'
3985                         MK_SHARED_LIB='${CC} ${LDFLAGS} ${CFLAGS} -shared -Wl,-brtl -Wl,-blibpath:${RPATH_LIST}:/usr/lib -o [$]@'
3986                 else
3987                         CC_SHARED_OPTS='-brtl'
3988                         # as well as '-qpic=large -G' or perhaps "-bM:SRE -bnoentry -bexpall"
3989                         MK_SHARED_LIB='${CC} ${LDFLAGS} ${CFLAGS} -G -Wl,-brtl -Wl,-blibpath:${RPATH_LIST}:/usr/lib -o [$]@'
3990                 fi
3991                 ;;
3992         (beos*)
3993                 MK_SHARED_LIB='${CC} ${LDFLAGS} ${CFLAGS} -o $[@] -Xlinker -soname=`basename $[@]` -nostart -e 0'
3994                 ;;
3995         (cygwin*)
3996                 CC_SHARED_OPTS=
3997                 MK_SHARED_LIB=$SHELL' '$rel_builddir'/mk_shared_lib.sh [$]@ [$]{CC} [$]{CFLAGS}'
3998                 RM_SHARED_OPTS="$RM_SHARED_OPTS $rel_builddir/mk_shared_lib.sh *.dll.a"
3999                 cf_cv_shlib_version=cygdll
4000                 cf_cv_shlib_version_infix=cygdll
4001                 shlibdir=$bindir
4002                 MAKE_DLLS=
4003                 cat >mk_shared_lib.sh <<-CF_EOF
4004                 #!$SHELL
4005                 SHARED_LIB=\[$]1
4006                 IMPORT_LIB=\`echo "\[$]1" | sed -e 's/cyg/lib/' -e 's/[[0-9]]*\.dll[$]/.dll.a/'\`
4007                 shift
4008                 cat <<-EOF
4009                 Linking shared library
4010                 ** SHARED_LIB \[$]SHARED_LIB
4011                 ** IMPORT_LIB \[$]IMPORT_LIB
4012 EOF
4013                 exec \[$]* ${LDFLAGS} -shared -Wl,--out-implib=\[$]{IMPORT_LIB} -Wl,--export-all-symbols -o \[$]{SHARED_LIB}
4014 CF_EOF
4015                 chmod +x mk_shared_lib.sh
4016                 ;;
4017         (msys*)
4018                 CC_SHARED_OPTS=
4019                 MK_SHARED_LIB=$SHELL' '$rel_builddir'/mk_shared_lib.sh [$]@ [$]{CC} [$]{CFLAGS}'
4020                 RM_SHARED_OPTS="$RM_SHARED_OPTS $rel_builddir/mk_shared_lib.sh *.dll.a"
4021                 cf_cv_shlib_version=msysdll
4022                 cf_cv_shlib_version_infix=msysdll
4023                 shlibdir=$bindir
4024                 MAKE_DLLS=
4025                 cat >mk_shared_lib.sh <<-CF_EOF
4026                 #!$SHELL
4027                 SHARED_LIB=\[$]1
4028                 IMPORT_LIB=\`echo "\[$]1" | sed -e 's/msys-/lib/' -e 's/[[0-9]]*\.dll[$]/.dll.a/'\`
4029                 shift
4030                 cat <<-EOF
4031                 Linking shared library
4032                 ** SHARED_LIB \[$]SHARED_LIB
4033                 ** IMPORT_LIB \[$]IMPORT_LIB
4034 EOF
4035                 exec \[$]* ${LDFLAGS} -shared -Wl,--out-implib=\[$]{IMPORT_LIB} -Wl,--export-all-symbols -o \[$]{SHARED_LIB}
4036 CF_EOF
4037                 chmod +x mk_shared_lib.sh
4038                 ;;
4039         (darwin*)
4040                 cf_try_cflags="no-cpp-precomp"
4041                 CC_SHARED_OPTS="-dynamic"
4042                 MK_SHARED_LIB='${CC} ${LDFLAGS} ${CFLAGS} -dynamiclib -install_name ${libdir}/`basename $[@]` -compatibility_version ${ABI_VERSION} -current_version ${ABI_VERSION} -o $[@]'
4043                 test "$cf_cv_shlib_version" = auto && cf_cv_shlib_version=abi
4044                 cf_cv_shlib_version_infix=yes
4045                 AC_CACHE_CHECK([if ld -search_paths_first works], cf_cv_ldflags_search_paths_first, [
4046                         cf_save_LDFLAGS=$LDFLAGS
4047                         LDFLAGS="$LDFLAGS -Wl,-search_paths_first"
4048                         AC_TRY_LINK(, [int i;], cf_cv_ldflags_search_paths_first=yes, cf_cv_ldflags_search_paths_first=no)
4049                                 LDFLAGS=$cf_save_LDFLAGS])
4050                 if test "$cf_cv_ldflags_search_paths_first" = yes; then
4051                         LDFLAGS="$LDFLAGS -Wl,-search_paths_first"
4052                 fi
4053                 ;;
4054         (haiku*)
4055                 CF_SHARED_SONAME
4056                 MK_SHARED_LIB='${CC} ${LDFLAGS} ${CFLAGS} -shared -Wl,-soname,'$cf_cv_shared_soname',-stats,-lc -o $[@]'
4057                 ;;
4058         (hpux[[7-8]]*)
4059                 # HP-UX 8.07 ld lacks "+b" option used for libdir search-list
4060                 if test "$GCC" != yes; then
4061                         CC_SHARED_OPTS='+Z'
4062                 fi
4063                 MK_SHARED_LIB='${LD} ${LDFLAGS} -b -o $[@]'
4064                 INSTALL_LIB="-m 555"
4065                 ;;
4066         (hpux*)
4067                 # (tested with gcc 2.7.2 -- I don't have c89)
4068                 if test "$GCC" = yes; then
4069                         LD_SHARED_OPTS='-Xlinker +b -Xlinker ${libdir}'
4070                 else
4071                         CC_SHARED_OPTS='+Z'
4072                         LD_SHARED_OPTS='-Wl,+b,${libdir}'
4073                 fi
4074                 MK_SHARED_LIB='${LD} ${LDFLAGS} +b ${libdir} -b -o $[@]'
4075                 # HP-UX shared libraries must be executable, and should be
4076                 # readonly to exploit a quirk in the memory manager.
4077                 INSTALL_LIB="-m 555"
4078                 ;;
4079         (interix*)
4080                 test "$cf_cv_shlib_version" = auto && cf_cv_shlib_version=rel
4081                 if test "$cf_cv_shlib_version" = rel; then
4082                         cf_shared_soname='`basename $[@] .${REL_VERSION}`.${ABI_VERSION}'
4083                 else
4084                         cf_shared_soname='`basename $[@]`'
4085                 fi
4086                 CC_SHARED_OPTS=
4087                 MK_SHARED_LIB='${CC} ${LDFLAGS} ${CFLAGS} -shared -Wl,-rpath,${RPATH_LIST} -Wl,-h,'$cf_shared_soname' -o $[@]'
4088                 ;;
4089         (irix*)
4090                 if test "$cf_cv_enable_rpath" = yes ; then
4091                         EXTRA_LDFLAGS="${cf_ld_rpath_opt}\${RPATH_LIST} $EXTRA_LDFLAGS"
4092                 fi
4093                 # tested with IRIX 5.2 and 'cc'.
4094                 if test "$GCC" != yes; then
4095                         CC_SHARED_OPTS='-KPIC'
4096                         MK_SHARED_LIB='${CC} ${LDFLAGS} ${CFLAGS} -shared -rdata_shared -soname `basename $[@]` -o $[@]'
4097                 else
4098                         MK_SHARED_LIB='${CC} ${LDFLAGS} ${CFLAGS} -shared -Wl,-soname,`basename $[@]` -o $[@]'
4099                 fi
4100                 cf_cv_rm_so_locs=yes
4101                 ;;
4102         (linux*|gnu*|k*bsd*-gnu)
4103                 if test "$DFT_LWR_MODEL" = "shared" && test -n "$LD_RPATH_OPT" ; then
4104                         LOCAL_LDFLAGS="${LD_RPATH_OPT}\$(LOCAL_LIBDIR)"
4105                         LOCAL_LDFLAGS2="$LOCAL_LDFLAGS"
4106                 fi
4107                 if test "$cf_cv_enable_rpath" = yes ; then
4108                         EXTRA_LDFLAGS="${cf_ld_rpath_opt}\${RPATH_LIST} $EXTRA_LDFLAGS"
4109                 fi
4110                 CF_SHARED_SONAME
4111                 MK_SHARED_LIB='${CC} ${LDFLAGS} ${CFLAGS} -shared -Wl,-soname,'$cf_cv_shared_soname',-stats,-lc -o $[@]'
4112                 ;;
4113         (mingw*msvc*)
4114                 cf_cv_shlib_version=msvcdll
4115                 cf_cv_shlib_version_infix=msvcdll
4116                 shlibdir=$bindir
4117                 MAKE_DLLS=
4118                 if test "$DFT_LWR_MODEL" = "shared" ; then
4119                         LOCAL_LDFLAGS="-link -dll"
4120                         LOCAL_LDFLAGS2="$LOCAL_LDFLAGS"
4121                         EXTRA_LDFLAGS="-link -dll $EXTRA_LDFLAGS"
4122                 fi
4123                 CC_SHARED_OPTS=
4124                 MK_SHARED_LIB=$SHELL' '$rel_builddir'/mk_shared_lib.sh [$]@ ${LD} [$]{CFLAGS}'
4125                 RM_SHARED_OPTS="$RM_SHARED_OPTS $rel_builddir/mk_shared_lib.sh *.dll.lib"
4126                 cat >mk_shared_lib.sh <<-CF_EOF
4127                 #!$SHELL
4128                 SHARED_LIB=\[$]1
4129                 IMPORT_LIB=\`echo "\[$]1" | sed -e 's/[[0-9]]*\.dll[$]/.dll.lib/'\`
4130                 shift
4131                 my_ld=\[$]1
4132                 shift
4133                 cat <<-EOF
4134                 Linking shared library
4135                 ** SHARED LIB \$SHARED_LIB
4136                 ** IMPORT_LIB \$IMPORT_LIB
4137 EOF
4138                 args=\$(echo \[$]* | sed -E "s#-l(\w*)#\1.dll.lib#g" | sed -E "s#-L(\w*)#-LIBPATH:\1#g")
4139                 exec \$my_ld -DLL -IMPLIB:"\${IMPORT_LIB}" -OUT:"\${SHARED_LIB}" ${LDFLAGS} \$args
4140                 mv "\${IMPORT_LIB}" "\${IMPORT_LIB}"
4141 CF_EOF
4142                 chmod +x mk_shared_lib.sh
4143                 cat >mk_prog.sh <<-CF_EOF
4144                 #!$SHELL
4145                 shift
4146                 # Ignore first argument (compiler) and use LD (link.exe) unconditionally
4147                 LD="[$]LD"
4148                 clopts=()
4149                 ldopts=("/subsystem:console")
4150                 libs=()
4151                 isdll=0
4152                 while test \[$]# -gt 0; do
4153                         case "\[$]1" in
4154                                 -link)
4155                                         # ignore -link argument
4156                                         ;;
4157                                 -M[[TD]] | -M[[TD]]d)
4158                                         # ignore runtime-library option
4159                                         ;;
4160                                 -dll)
4161                                         isdll=1
4162                                         ;;
4163                                 -W* | -w*)
4164                                         # ignore warnings
4165                                         ;;
4166                                 -D*)
4167                                         clopts+=("\[$]1")
4168                                         ;;
4169                                 -I*)
4170                                         clopts+=("\[$]1")
4171                                         ;;
4172                                 -l*)
4173                                         libs+=("\`echo \"\[$]1\" | sed \"s/^-l//\"\`")
4174                                         ;;
4175                                 -L*)
4176                                         ldopts+=("\`echo \"\[$]1\" | sed \"s/^-L/-LIBPATH:/\"\`")
4177                                         ;;
4178                                 *.obj | *.o)
4179                                         ldopts+=("\[$]1")
4180                                         ;;
4181                                 -Wl,*)
4182                                         for linkarg in \`echo '\[$]1' | sed -e 's/-Wl,//' -e 's/,/ /'\`; do
4183                                                 ldopts+=("\[$]{linkarg}")
4184                                         done
4185                                         ;;
4186                                 *.lib)
4187                                         ldopts+=("\[$]1")
4188                                         ;;
4189                                 -o)
4190                                         shift
4191                                         ldopts+=("-out:\[$]1")
4192                                         ;;
4193                                 *)
4194                                         clopts+=("\[$]1")
4195                                         ldopts+=("\[$]1")
4196                                         ;;
4197                         esac
4198                         shift
4199                 done
4200                 if [[ "\$isdll" -ne 0 ]]; then
4201                         for lib in \[$]{libs[[*]]}; do
4202                                 ldopts+=("\[$]lib.dll.lib")
4203                         done
4204                 else
4205                         for lib in \[$]{libs[[*]]}; do
4206                                 ldopts+=("\[$]lib.lib")
4207                         done
4208                 fi
4209                 cat <<-EOF
4210                 Creating program
4211                 ** ld options:   "\[$]{ldopts[[@]]}"
4212 EOF
4213                 exec \[$]LD \[$]{ldopts[[@]]}
4214 CF_EOF
4215                 chmod +x mk_prog.sh
4216                 LINK_PROGS="$SHELL ${rel_builddir}/mk_prog.sh"
4217                 LINK_TESTS="$SHELL ${rel_builddir}/mk_prog.sh"
4218                 ;;
4219         (mingw*)
4220                 cf_cv_shlib_version=mingw
4221                 cf_cv_shlib_version_infix=mingw
4222                 shlibdir=$bindir
4223                 MAKE_DLLS=
4224                 if test "$DFT_LWR_MODEL" = "shared" ; then
4225                         LOCAL_LDFLAGS="-Wl,--enable-auto-import"
4226                         LOCAL_LDFLAGS2="$LOCAL_LDFLAGS"
4227                         EXTRA_LDFLAGS="-Wl,--enable-auto-import $EXTRA_LDFLAGS"
4228                 fi
4229                 CC_SHARED_OPTS=
4230                 MK_SHARED_LIB=$SHELL' '$rel_builddir'/mk_shared_lib.sh [$]@ [$]{CC} [$]{CFLAGS}'
4231                 RM_SHARED_OPTS="$RM_SHARED_OPTS $rel_builddir/mk_shared_lib.sh *.dll.a"
4232                 cat >mk_shared_lib.sh <<-CF_EOF
4233                 #!$SHELL
4234                 SHARED_LIB=\[$]1
4235                 IMPORT_LIB=\`echo "\[$]1" | sed -e 's/[[0-9]]*\.dll[$]/.dll.a/'\`
4236                 shift
4237                 cat <<-EOF
4238                 Linking shared library
4239                 ** SHARED_LIB \[$]SHARED_LIB
4240                 ** IMPORT_LIB \[$]IMPORT_LIB
4241 EOF
4242                 exec \[$]* ${LDFLAGS} -shared -Wl,--enable-auto-import,--out-implib=\[$]{IMPORT_LIB} -Wl,--export-all-symbols -o \[$]{SHARED_LIB}
4243 CF_EOF
4244                 chmod +x mk_shared_lib.sh
4245                 ;;
4246         (openbsd[[2-9]].*|mirbsd*)
4247                 if test "$DFT_LWR_MODEL" = "shared" && test -n "$LD_RPATH_OPT" ; then
4248                         LOCAL_LDFLAGS="${LD_RPATH_OPT}\$(LOCAL_LIBDIR)"
4249                         LOCAL_LDFLAGS2="$LOCAL_LDFLAGS"
4250                 fi
4251                 if test "$cf_cv_enable_rpath" = yes ; then
4252                         EXTRA_LDFLAGS="${cf_ld_rpath_opt}\${RPATH_LIST} $EXTRA_LDFLAGS"
4253                 fi
4254                 CC_SHARED_OPTS="$CC_SHARED_OPTS -DPIC"
4255                 CF_SHARED_SONAME
4256                 MK_SHARED_LIB='${CC} ${LDFLAGS} ${CFLAGS} -shared -Wl,-Bshareable,-soname,'$cf_cv_shared_soname',-stats,-lc -o $[@]'
4257                 ;;
4258         (nskJ*)
4259                 CC_SHARED_OPTS=
4260                 MK_SHARED_LIB='${LD} -Wshared -Weld=-export_all -o $[@]'
4261                 ;;
4262         (nskL*)
4263                 CC_SHARED_OPTS=
4264                 MK_SHARED_LIB='${LD} -Wshared -Wxld=-export_all -o $[@]'
4265                 ;;
4266         (nto-qnx*|openbsd*|freebsd[[12]].*)
4267                 CC_SHARED_OPTS="$CC_SHARED_OPTS -DPIC"
4268                 MK_SHARED_LIB='${LD} ${LDFLAGS} -Bshareable -o $[@]'
4269                 test "$cf_cv_shlib_version" = auto && cf_cv_shlib_version=rel
4270                 ;;
4271         (dragonfly*|freebsd*)
4272                 CC_SHARED_OPTS="$CC_SHARED_OPTS -DPIC"
4273                 if test "$DFT_LWR_MODEL" = "shared" && test "$cf_cv_enable_rpath" = yes ; then
4274                         LOCAL_LDFLAGS="${cf_ld_rpath_opt}\$(LOCAL_LIBDIR)"
4275                         LOCAL_LDFLAGS2="${cf_ld_rpath_opt}\${RPATH_LIST} $LOCAL_LDFLAGS"
4276                         EXTRA_LDFLAGS="${cf_ld_rpath_opt}\${RPATH_LIST} $EXTRA_LDFLAGS"
4277                 fi
4278                 CF_SHARED_SONAME
4279                 MK_SHARED_LIB='${CC} ${LDFLAGS} ${CFLAGS} -shared -Wl,-soname,'$cf_cv_shared_soname',-stats,-lc -o $[@]'
4280                 ;;
4281         (netbsd*)
4282                 CC_SHARED_OPTS="$CC_SHARED_OPTS -DPIC"
4283                 if test "$DFT_LWR_MODEL" = "shared" && test "$cf_cv_enable_rpath" = yes ; then
4284                         LOCAL_LDFLAGS="${cf_ld_rpath_opt}\$(LOCAL_LIBDIR)"
4285                         LOCAL_LDFLAGS2="$LOCAL_LDFLAGS"
4286                         EXTRA_LDFLAGS="${cf_ld_rpath_opt}\${RPATH_LIST} $EXTRA_LDFLAGS"
4287                         if test "$cf_cv_shlib_version" = auto; then
4288                         if test -f /usr/libexec/ld.elf_so; then
4289                                 cf_cv_shlib_version=abi
4290                         else
4291                                 cf_cv_shlib_version=rel
4292                         fi
4293                         fi
4294                         CF_SHARED_SONAME
4295                         MK_SHARED_LIB='${CC} ${LDFLAGS} ${CFLAGS} -shared -Wl,-soname,'$cf_cv_shared_soname' -o $[@]'
4296                 else
4297                         MK_SHARED_LIB='${CC} ${LDFLAGS} ${CFLAGS} -shared -o $[@]'
4298                 fi
4299                 ;;
4300         (osf*|mls+*)
4301                 # tested with OSF/1 V3.2 and 'cc'
4302                 # tested with OSF/1 V3.2 and gcc 2.6.3 (but the c++ demo didn't
4303                 # link with shared libs).
4304                 MK_SHARED_LIB='${LD} ${LDFLAGS} -set_version ${REL_VERSION}:${ABI_VERSION} -expect_unresolved "*" -shared -soname `basename $[@]`'
4305                 case "$host_os" in
4306                 (osf4*)
4307                         MK_SHARED_LIB="${MK_SHARED_LIB} -msym"
4308                         ;;
4309                 esac
4310                 MK_SHARED_LIB="${MK_SHARED_LIB}"' -o $[@]'
4311                 if test "$DFT_LWR_MODEL" = "shared" && test -n "$LD_RPATH_OPT" ; then
4312                         LOCAL_LDFLAGS="${LD_RPATH_OPT}\$(LOCAL_LIBDIR)"
4313                         LOCAL_LDFLAGS2="$LOCAL_LDFLAGS"
4314                 fi
4315                 cf_cv_rm_so_locs=yes
4316                 ;;
4317         (sco3.2v5*)  # also uw2* and UW7: hops 13-Apr-98
4318                 # tested with osr5.0.5
4319                 if test "$GCC" != yes; then
4320                         CC_SHARED_OPTS='-belf -KPIC'
4321                 fi
4322                 MK_SHARED_LIB='${LD} ${LDFLAGS} -dy -G -h `basename $[@] .${REL_VERSION}`.${ABI_VERSION} -o [$]@'
4323                 if test "$cf_cv_enable_rpath" = yes ; then
4324                         # only way is to set LD_RUN_PATH but no switch for it
4325                         RUN_PATH=$libdir
4326                 fi
4327                 test "$cf_cv_shlib_version" = auto && cf_cv_shlib_version=rel
4328                 LINK_PROGS='LD_RUN_PATH=${libdir}'
4329                 LINK_TESTS='Pwd=`pwd`;LD_RUN_PATH=`dirname $${Pwd}`/lib'
4330                 ;;
4331         (sunos4*)
4332                 # tested with SunOS 4.1.1 and gcc 2.7.0
4333                 if test "$GCC" != yes; then
4334                         CC_SHARED_OPTS='-KPIC'
4335                 fi
4336                 MK_SHARED_LIB='${LD} ${LDFLAGS} -assert pure-text -o $[@]'
4337                 test "$cf_cv_shlib_version" = auto && cf_cv_shlib_version=rel
4338                 ;;
4339         (solaris2*)
4340                 # tested with SunOS 5.5.1 (solaris 2.5.1) and gcc 2.7.2
4341                 # tested with SunOS 5.10 (solaris 10) and gcc 3.4.3
4342                 if test "$DFT_LWR_MODEL" = "shared" ; then
4343                         LOCAL_LDFLAGS="-R \$(LOCAL_LIBDIR):\${libdir}"
4344                         LOCAL_LDFLAGS2="$LOCAL_LDFLAGS"
4345                 fi
4346                 if test "$cf_cv_enable_rpath" = yes ; then
4347                         EXTRA_LDFLAGS="-R \${libdir} $EXTRA_LDFLAGS"
4348                 fi
4349                 CF_SHARED_SONAME
4350                 if test "$GCC" != yes; then
4351                         cf_save_CFLAGS="$CFLAGS"
4352                         for cf_shared_opts in -xcode=pic32 -xcode=pic13 -KPIC -Kpic -O
4353                         do
4354                                 CFLAGS="$cf_shared_opts $cf_save_CFLAGS"
4355                                 AC_TRY_COMPILE([#include <stdio.h>],[printf("Hello\\n");],[break])
4356                         done
4357                         CFLAGS="$cf_save_CFLAGS"
4358                         CC_SHARED_OPTS=$cf_shared_opts
4359                         MK_SHARED_LIB='${CC} ${LDFLAGS} ${CFLAGS} -dy -G -h '$cf_cv_shared_soname' -o $[@]'
4360                 else
4361                         MK_SHARED_LIB='${CC} ${LDFLAGS} ${CFLAGS} -shared -dy -G -h '$cf_cv_shared_soname' -o $[@]'
4362                 fi
4363                 ;;
4364         (sysv5uw7*|unix_sv*)
4365                 # tested with UnixWare 7.1.0 (gcc 2.95.2 and cc)
4366                 if test "$GCC" != yes; then
4367                         CC_SHARED_OPTS='-KPIC'
4368                 fi
4369                 MK_SHARED_LIB='${LD} ${LDFLAGS} -d y -G -o [$]@'
4370                 ;;
4371         (*)
4372                 CC_SHARED_OPTS='unknown'
4373                 MK_SHARED_LIB='echo unknown'
4374                 ;;
4375         esac
4376
4377         # This works if the last tokens in $MK_SHARED_LIB are the -o target.
4378         case "$cf_cv_shlib_version" in
4379         (rel|abi)
4380                 case "$MK_SHARED_LIB" in
4381                 (*'-o $[@]')
4382                         test "$cf_cv_do_symlinks" = no && cf_cv_do_symlinks=yes
4383                         ;;
4384                 (*)
4385                         AC_MSG_WARN(ignored --with-shlib-version)
4386                         ;;
4387                 esac
4388                 ;;
4389         esac
4390
4391         if test -n "$cf_try_cflags"
4392         then
4393 cat > conftest.$ac_ext <<EOF
4394 #line __oline__ "${as_me:-configure}"
4395 #include <stdio.h>
4396 int main(int argc, char *argv[[]])
4397 {
4398         printf("hello\\n");
4399         return (argv[[argc-1]] == 0) ;
4400 }
4401 EOF
4402                 cf_save_CFLAGS="$CFLAGS"
4403                 for cf_opt in $cf_try_cflags
4404                 do
4405                         CFLAGS="$cf_save_CFLAGS -$cf_opt"
4406                         AC_MSG_CHECKING(if CFLAGS option -$cf_opt works)
4407                         if AC_TRY_EVAL(ac_compile); then
4408                                 AC_MSG_RESULT(yes)
4409                                 cf_save_CFLAGS="$CFLAGS"
4410                         else
4411                                 AC_MSG_RESULT(no)
4412                         fi
4413                 done
4414                 CFLAGS="$cf_save_CFLAGS"
4415         fi
4416
4417
4418         # RPATH_LIST is a colon-separated list of directories
4419         test -n "$cf_ld_rpath_opt" && MK_SHARED_LIB="$MK_SHARED_LIB $cf_ld_rpath_opt\${RPATH_LIST}"
4420         test -z "$RPATH_LIST" && RPATH_LIST="\${libdir}"
4421
4422         test "$cf_cv_rm_so_locs" = yes && RM_SHARED_OPTS="$RM_SHARED_OPTS so_locations"
4423
4424         CF_VERBOSE(CC_SHARED_OPTS: $CC_SHARED_OPTS)
4425         CF_VERBOSE(MK_SHARED_LIB:  $MK_SHARED_LIB)
4426
4427         AC_SUBST(CC_SHARED_OPTS)
4428         AC_SUBST(LD_RPATH_OPT)
4429         AC_SUBST(LD_SHARED_OPTS)
4430         AC_SUBST(MK_SHARED_LIB)
4431         AC_SUBST(RM_SHARED_OPTS)
4432
4433         AC_SUBST(LINK_PROGS)
4434         AC_SUBST(LINK_TESTS)
4435
4436         AC_SUBST(EXTRA_LDFLAGS)
4437         AC_SUBST(LOCAL_LDFLAGS)
4438         AC_SUBST(LOCAL_LDFLAGS2)
4439
4440         AC_SUBST(INSTALL_LIB)
4441         AC_SUBST(RPATH_LIST)
4442 ])dnl
4443 dnl ---------------------------------------------------------------------------
4444 dnl CF_SHARED_SONAME version: 3 updated: 2008/09/08 18:34:43
4445 dnl ----------------
4446 dnl utility macro for CF_SHARED_OPTS, constructs "$cf_cv_shared_soname" for
4447 dnl substitution into MK_SHARED_LIB string for the "-soname" (or similar)
4448 dnl option.
4449 dnl
4450 dnl $1 is the default that should be used for "$cf_cv_shlib_version".
4451 dnl If missing, use "rel".
4452 define([CF_SHARED_SONAME],
4453 [
4454         test "$cf_cv_shlib_version" = auto && cf_cv_shlib_version=ifelse($1,,rel,$1)
4455         if test "$cf_cv_shlib_version" = rel; then
4456                 cf_cv_shared_soname='`basename $[@] .${REL_VERSION}`.${ABI_VERSION}'
4457         else
4458                 cf_cv_shared_soname='`basename $[@]`'
4459         fi
4460 ])
4461 dnl ---------------------------------------------------------------------------
4462 dnl CF_STRIP_G_OPT version: 4 updated: 2021/01/02 09:31:20
4463 dnl --------------
4464 dnl     Remove "-g" option from the compiler options
4465 AC_DEFUN([CF_STRIP_G_OPT],
4466 [$1=`echo "${$1}" | CF__SED_TRIMBLANKS(-e 's%-g %%' -e 's%-g$%%')`])dnl
4467 dnl ---------------------------------------------------------------------------
4468 dnl CF_SUBDIR_PATH version: 7 updated: 2014/12/04 04:33:06
4469 dnl --------------
4470 dnl Construct a search-list for a nonstandard header/lib-file
4471 dnl     $1 = the variable to return as result
4472 dnl     $2 = the package name
4473 dnl     $3 = the subdirectory, e.g., bin, include or lib
4474 AC_DEFUN([CF_SUBDIR_PATH],
4475 [
4476 $1=
4477
4478 CF_ADD_SUBDIR_PATH($1,$2,$3,$prefix,NONE)
4479
4480 for cf_subdir_prefix in \
4481         /usr \
4482         /usr/local \
4483         /usr/pkg \
4484         /opt \
4485         /opt/local \
4486         [$]HOME
4487 do
4488         CF_ADD_SUBDIR_PATH($1,$2,$3,$cf_subdir_prefix,$prefix)
4489 done
4490 ])dnl
4491 dnl ---------------------------------------------------------------------------
4492 dnl CF_TERM_HEADER version: 6 updated: 2021/01/02 09:31:20
4493 dnl --------------
4494 dnl Look for term.h, which is part of X/Open curses.  It defines the interface
4495 dnl to terminfo database.  Usually it is in the same include-path as curses.h,
4496 dnl but some packagers change this, breaking various applications.
4497 AC_DEFUN([CF_TERM_HEADER],[
4498 AC_CACHE_CHECK(for terminfo header, cf_cv_term_header,[
4499 case "${cf_cv_ncurses_header}" in
4500 (*/ncurses.h|*/ncursesw.h)
4501         cf_term_header=`echo "$cf_cv_ncurses_header" | sed -e 's%ncurses[[^.]]*\.h$%term.h%'`
4502         ;;
4503 (*)
4504         cf_term_header=term.h
4505         ;;
4506 esac
4507
4508 for cf_test in $cf_term_header "ncurses/term.h" "ncursesw/term.h"
4509 do
4510 AC_TRY_COMPILE([#include <stdio.h>
4511 #include <${cf_cv_ncurses_header:-curses.h}>
4512 #include <$cf_test>
4513 ],[int x = auto_left_margin; (void)x],[
4514         cf_cv_term_header="$cf_test"],[
4515         cf_cv_term_header=unknown
4516         ])
4517         test "$cf_cv_term_header" != unknown && break
4518 done
4519 ])
4520
4521 # Set definitions to allow ifdef'ing to accommodate subdirectories
4522
4523 case "$cf_cv_term_header" in
4524 (*term.h)
4525         AC_DEFINE(HAVE_TERM_H,1,[Define to 1 if we have term.h])
4526         ;;
4527 esac
4528
4529 case "$cf_cv_term_header" in
4530 (ncurses/term.h)
4531         AC_DEFINE(HAVE_NCURSES_TERM_H,1,[Define to 1 if we have ncurses/term.h])
4532         ;;
4533 (ncursesw/term.h)
4534         AC_DEFINE(HAVE_NCURSESW_TERM_H,1,[Define to 1 if we have ncursesw/term.h])
4535         ;;
4536 esac
4537 ])dnl
4538 dnl ---------------------------------------------------------------------------
4539 dnl CF_TOP_BUILDDIR version: 2 updated: 2013/07/27 17:38:32
4540 dnl ---------------
4541 dnl Define a top_builddir symbol, for applications that need an absolute path.
4542 AC_DEFUN([CF_TOP_BUILDDIR],
4543 [
4544 top_builddir=ifelse($1,,`pwd`,$1)
4545 AC_SUBST(top_builddir)
4546 ])dnl
4547 dnl ---------------------------------------------------------------------------
4548 dnl CF_TRY_XOPEN_SOURCE version: 4 updated: 2022/09/10 15:16:16
4549 dnl -------------------
4550 dnl If _XOPEN_SOURCE is not defined in the compile environment, check if we
4551 dnl can define it successfully.
4552 AC_DEFUN([CF_TRY_XOPEN_SOURCE],[
4553 AC_CACHE_CHECK(if we should define _XOPEN_SOURCE,cf_cv_xopen_source,[
4554         AC_TRY_COMPILE(CF__XOPEN_SOURCE_HEAD,CF__XOPEN_SOURCE_BODY,
4555         [cf_cv_xopen_source=no],
4556         [cf_save="$CPPFLAGS"
4557          CF_APPEND_TEXT(CPPFLAGS,-D_XOPEN_SOURCE=$cf_XOPEN_SOURCE)
4558          AC_TRY_COMPILE(CF__XOPEN_SOURCE_HEAD,CF__XOPEN_SOURCE_BODY,
4559                 [cf_cv_xopen_source=no],
4560                 [cf_cv_xopen_source=$cf_XOPEN_SOURCE])
4561                 CPPFLAGS="$cf_save"
4562         ])
4563 ])
4564
4565 if test "$cf_cv_xopen_source" != no ; then
4566         CF_REMOVE_DEFINE(CFLAGS,$CFLAGS,_XOPEN_SOURCE)
4567         CF_REMOVE_DEFINE(CPPFLAGS,$CPPFLAGS,_XOPEN_SOURCE)
4568         cf_temp_xopen_source="-D_XOPEN_SOURCE=$cf_cv_xopen_source"
4569         CF_APPEND_CFLAGS($cf_temp_xopen_source)
4570 fi
4571 ])
4572 dnl ---------------------------------------------------------------------------
4573 dnl CF_UPPER version: 5 updated: 2001/01/29 23:40:59
4574 dnl --------
4575 dnl Make an uppercase version of a variable
4576 dnl $1=uppercase($2)
4577 AC_DEFUN([CF_UPPER],
4578 [
4579 $1=`echo "$2" | sed y%abcdefghijklmnopqrstuvwxyz./-%ABCDEFGHIJKLMNOPQRSTUVWXYZ___%`
4580 ])dnl
4581 dnl ---------------------------------------------------------------------------
4582 dnl CF_UTF8_LIB version: 10 updated: 2023/01/11 04:05:23
4583 dnl -----------
4584 dnl Check for multibyte support, and if not found, utf8 compatibility library
4585 AC_DEFUN([CF_UTF8_LIB],
4586 [
4587 AC_HAVE_HEADERS(wchar.h)
4588 AC_CACHE_CHECK(for multibyte character support,cf_cv_utf8_lib,[
4589         cf_save_LIBS="$LIBS"
4590         AC_TRY_LINK([
4591 $ac_includes_default
4592 #ifdef HAVE_WCHAR_H
4593 #include <wchar.h>
4594 #endif
4595 ],[putwc(0,0);],
4596         [cf_cv_utf8_lib=yes],
4597         [CF_FIND_LINKAGE([
4598 #include <libutf8.h>],[putwc(0,0);],utf8,
4599                 [cf_cv_utf8_lib=add-on],
4600                 [cf_cv_utf8_lib=no])
4601 ])])
4602
4603 # HAVE_LIBUTF8_H is used by ncurses if curses.h is shared between
4604 # ncurses/ncursesw:
4605 if test "$cf_cv_utf8_lib" = "add-on" ; then
4606         AC_DEFINE(HAVE_LIBUTF8_H,1,[Define to 1 if we should include libutf8.h])
4607         CF_ADD_INCDIR($cf_cv_header_path_utf8)
4608         CF_ADD_LIBDIR($cf_cv_library_path_utf8)
4609         CF_ADD_LIBS($cf_cv_library_file_utf8)
4610 fi
4611 ])dnl
4612 dnl ---------------------------------------------------------------------------
4613 dnl CF_VERBOSE version: 3 updated: 2007/07/29 09:55:12
4614 dnl ----------
4615 dnl Use AC_VERBOSE w/o the warnings
4616 AC_DEFUN([CF_VERBOSE],
4617 [test -n "$verbose" && echo "   $1" 1>&AC_FD_MSG
4618 CF_MSG_LOG([$1])
4619 ])dnl
4620 dnl ---------------------------------------------------------------------------
4621 dnl CF_WEAK_SYMBOLS version: 1 updated: 2008/08/16 19:18:06
4622 dnl ---------------
4623 dnl Check for compiler-support for weak symbols.
4624 dnl This works with "recent" gcc.
4625 AC_DEFUN([CF_WEAK_SYMBOLS],[
4626 AC_CACHE_CHECK(if $CC supports weak symbols,cf_cv_weak_symbols,[
4627
4628 AC_TRY_COMPILE([
4629 #include <stdio.h>],
4630 [
4631 #if defined(__GNUC__)
4632 #  if defined __USE_ISOC99
4633 #    define _cat_pragma(exp)    _Pragma(#exp)
4634 #    define _weak_pragma(exp)   _cat_pragma(weak name)
4635 #  else
4636 #    define _weak_pragma(exp)
4637 #  endif
4638 #  define _declare(name)        __extension__ extern __typeof__(name) name
4639 #  define weak_symbol(name)     _weak_pragma(name) _declare(name) __attribute__((weak))
4640 #endif
4641
4642 weak_symbol(fopen);
4643 ],[cf_cv_weak_symbols=yes],[cf_cv_weak_symbols=no])
4644 ])
4645 ])dnl
4646 dnl ---------------------------------------------------------------------------
4647 dnl CF_WITH_ADA_COMPILER version: 2 updated: 2010/06/26 17:35:58
4648 dnl --------------------
4649 dnl Command-line option to specify the Ada95 compiler.
4650 AC_DEFUN([CF_WITH_ADA_COMPILER],[
4651 AC_MSG_CHECKING(for ada-compiler)
4652 AC_ARG_WITH(ada-compiler,
4653         [  --with-ada-compiler=CMD specify Ada95 compiler command (default gnatmake)],
4654         [cf_ada_compiler=$withval],
4655         [cf_ada_compiler=gnatmake])
4656 AC_SUBST(cf_ada_compiler)
4657 AC_MSG_RESULT($cf_ada_compiler)
4658 ])dnl
4659 dnl ---------------------------------------------------------------------------
4660 dnl CF_WITH_ADA_INCLUDE version: 2 updated: 2010/06/26 17:35:58
4661 dnl -------------------
4662 dnl Command-line option to specify where Ada includes will install.
4663 AC_DEFUN([CF_WITH_ADA_INCLUDE],[
4664 AC_MSG_CHECKING(for ada-include)
4665 CF_WITH_PATH(ada-include,
4666    [  --with-ada-include=DIR  Ada includes are in DIR],
4667    ADA_INCLUDE,
4668    PREFIX/share/ada/adainclude,
4669    [$]prefix/share/ada/adainclude)
4670 AC_SUBST(ADA_INCLUDE)
4671 AC_MSG_RESULT($ADA_INCLUDE)
4672 ])dnl
4673 dnl ---------------------------------------------------------------------------
4674 dnl CF_WITH_ADA_LIBNAME version: 1 updated: 2019/09/07 18:59:41
4675 dnl -------------------
4676 dnl CF_WITH_ADA_LIBNAME
4677 dnl -------------------
4678 dnl Command-line option to specify how to name the resulting Ada library.
4679 dnl $1 = default value
4680 AC_DEFUN([CF_WITH_ADA_LIBNAME],[
4681 AC_MSG_CHECKING(for ada-libname)
4682 AC_ARG_WITH(ada-libname,
4683    [  --with-ada-libname=XXX  override default Ada library-name],
4684    ADA_LIBNAME=[$]withval,
4685    ADA_LIBNAME=$1)
4686 case "x$ADA_LIBNAME" in
4687 (x|xyes|xno)
4688         ADA_LIBNAME=$1
4689         ;;
4690 esac
4691 AC_SUBST(ADA_LIBNAME)
4692 AC_MSG_RESULT($ADA_LIBNAME)
4693 ])dnl
4694 dnl ---------------------------------------------------------------------------
4695 dnl CF_WITH_ADA_OBJECTS version: 2 updated: 2010/06/26 17:35:58
4696 dnl -------------------
4697 dnl Command-line option to specify where Ada objects will install.
4698 AC_DEFUN([CF_WITH_ADA_OBJECTS],[
4699 AC_MSG_CHECKING(for ada-objects)
4700 CF_WITH_PATH(ada-objects,
4701    [  --with-ada-objects=DIR  Ada objects are in DIR],
4702    ADA_OBJECTS,
4703    PREFIX/lib/ada/adalib,
4704    [$]prefix/lib/ada/adalib)
4705 AC_SUBST(ADA_OBJECTS)
4706 AC_MSG_RESULT($ADA_OBJECTS)
4707 ])dnl
4708 dnl ---------------------------------------------------------------------------
4709 dnl CF_WITH_ADA_SHAREDLIB version: 5 updated: 2018/07/21 19:10:35
4710 dnl ---------------------
4711 dnl Command-line option to specify if an Ada95 shared-library should be built,
4712 dnl and optionally what its soname should be.
4713 AC_DEFUN([CF_WITH_ADA_SHAREDLIB],[
4714 AC_REQUIRE([CF_GNAT_PROJECTS])
4715 AC_MSG_CHECKING(if an Ada95 shared-library should be built)
4716 AC_ARG_WITH(ada-sharedlib,
4717         [  --with-ada-sharedlib=soname build shared-library (requires GNAT projects)],
4718         [with_ada_sharedlib=$withval],
4719         [with_ada_sharedlib=no])
4720 AC_MSG_RESULT($with_ada_sharedlib)
4721
4722 if test "x$with_ada_sharedlib" != xno
4723 then
4724         if test "x$cf_gnat_projects" != xyes
4725         then
4726                 AC_MSG_WARN(disabling shared-library since GNAT projects are not supported)
4727                 with_ada_sharedlib=no
4728         fi
4729 fi
4730
4731 ADA_SHAREDLIB='lib$(LIB_NAME).so.1'
4732 MAKE_ADA_SHAREDLIB="#"
4733
4734 if test "x$with_ada_sharedlib" != xno
4735 then
4736         MAKE_ADA_SHAREDLIB=
4737         if test "x$with_ada_sharedlib" != xyes
4738         then
4739                 ADA_SHAREDLIB="$with_ada_sharedlib"
4740         fi
4741 fi
4742
4743 AC_SUBST(ADA_SHAREDLIB)
4744 AC_SUBST(MAKE_ADA_SHAREDLIB)
4745 ])dnl
4746 dnl ---------------------------------------------------------------------------
4747 dnl CF_WITH_CURSES_DIR version: 4 updated: 2021/01/02 19:22:58
4748 dnl ------------------
4749 dnl Wrapper for AC_ARG_WITH to specify directory under which to look for curses
4750 dnl libraries.
4751 AC_DEFUN([CF_WITH_CURSES_DIR],[
4752
4753 AC_MSG_CHECKING(for specific curses-directory)
4754 AC_ARG_WITH(curses-dir,
4755         [  --with-curses-dir=DIR   directory in which (n)curses is installed],
4756         [cf_cv_curses_dir=$withval],
4757         [cf_cv_curses_dir=no])
4758 AC_MSG_RESULT($cf_cv_curses_dir)
4759
4760 if test -n "$cf_cv_curses_dir" && test "$cf_cv_curses_dir" != "no"
4761 then
4762         CF_PATH_SYNTAX(withval)
4763         if test -d "$cf_cv_curses_dir"
4764         then
4765                 CF_ADD_INCDIR($cf_cv_curses_dir/include)
4766                 CF_ADD_LIBDIR($cf_cv_curses_dir/lib)
4767         fi
4768 fi
4769 ])dnl
4770 dnl ---------------------------------------------------------------------------
4771 dnl CF_WITH_LIB_PREFIX version: 2 updated: 2021/01/01 16:53:59
4772 dnl ------------------
4773 dnl Allow the library-prefix to be overridden.  OS/2 EMX originally had no
4774 dnl "lib" prefix, e.g., because it used the dll naming convention.
4775 dnl
4776 dnl $1 = variable to set
4777 AC_DEFUN([CF_WITH_LIB_PREFIX],
4778 [
4779 AC_MSG_CHECKING(if you want to have a library-prefix)
4780 AC_ARG_WITH(lib-prefix,
4781         [  --with-lib-prefix       override library-prefix],
4782         [with_lib_prefix=$withval],
4783         [with_lib_prefix=auto])
4784 AC_MSG_RESULT($with_lib_prefix)
4785
4786 if test "$with_lib_prefix" = auto
4787 then
4788         CF_LIB_PREFIX($1)
4789 elif test "$with_lib_prefix" = no
4790 then
4791         LIB_PREFIX=
4792 else
4793         LIB_PREFIX=$with_lib_prefix
4794 fi
4795 ])dnl
4796 dnl ---------------------------------------------------------------------------
4797 dnl CF_WITH_PATH version: 12 updated: 2021/09/04 06:35:04
4798 dnl ------------
4799 dnl Wrapper for AC_ARG_WITH to ensure that user supplies a pathname, not just
4800 dnl defaulting to yes/no.
4801 dnl
4802 dnl $1 = option name
4803 dnl $2 = help-text
4804 dnl $3 = environment variable to set
4805 dnl $4 = default value, shown in the help-message, must be a constant
4806 dnl $5 = default value, if it is an expression & cannot be in the help-message
4807 dnl
4808 AC_DEFUN([CF_WITH_PATH],
4809 [AC_ARG_WITH($1,[$2 ](default: ifelse([$4],,empty,[$4])),,
4810 ifelse([$4],,[withval="${$3}"],[withval="${$3:-ifelse([$5],,[$4],[$5])}"]))dnl
4811 if ifelse([$5],,true,[test -n "$5"]) ; then
4812 CF_PATH_SYNTAX(withval)
4813 fi
4814 eval $3="$withval"
4815 AC_SUBST($3)dnl
4816 ])dnl
4817 dnl ---------------------------------------------------------------------------
4818 dnl CF_WITH_PKG_CONFIG_LIBDIR version: 21 updated: 2023/01/22 13:37:42
4819 dnl -------------------------
4820 dnl Allow the choice of the pkg-config library directory to be overridden.
4821 dnl
4822 dnl pkg-config uses a search-list built from these colon-separated lists of
4823 dnl directories:
4824 dnl a) $PKG_CONFIG_PATH (tested first, added if set)
4825 dnl b) $PKG_CONFIG_LIBDIR (tested second, added if set)
4826 dnl c) builtin-list (added if $PKG_CONFIG_LIBDIR is not set)
4827 dnl
4828 dnl pkgconf (used with some systems such as FreeBSD in place of pkg-config)
4829 dnl optionally ignores $PKG_CONFIG_LIBDIR.  Very old versions of pkg-config,
4830 dnl e.g., Solaris 10 also do not recognize $PKG_CONFIG_LIBDIR.
4831 AC_DEFUN([CF_WITH_PKG_CONFIG_LIBDIR],[
4832
4833 case "$PKG_CONFIG" in
4834 (no|none|yes)
4835         AC_MSG_CHECKING(for pkg-config library directory)
4836         ;;
4837 (*)
4838         AC_MSG_CHECKING(for $PKG_CONFIG library directory)
4839         ;;
4840 esac
4841
4842 # if $PKG_CONFIG_LIBDIR is set, try to use that
4843 if test -n "$PKG_CONFIG_PATH"; then
4844         cf_search_path=`echo "$PKG_CONFIG_PATH" | sed -e 's/:/ /g' -e 's,^[[    ]]*,,' -e 's,[[         ]]*$,,'`
4845 elif test -n "$PKG_CONFIG_LIBDIR"; then
4846         cf_search_path=`echo "$PKG_CONFIG_LIBDIR" | sed -e 's/:/ /g' -e 's,^[[  ]]*,,' -e 's,[[         ]]*$,,'`
4847 else
4848         cf_search_path=auto
4849 fi
4850
4851 # if the option is used, let that override.  otherwise default to "libdir"
4852 AC_ARG_WITH(pkg-config-libdir,
4853         [  --with-pkg-config-libdir=XXX use given directory for installing pc-files],
4854         [cf_search_path=$withval],
4855         [test "x$PKG_CONFIG" != xnone && test -z "$cf_search_path" && cf_search_path=libdir])
4856
4857 case "x$cf_search_path" in
4858 (xlibdir)
4859         PKG_CONFIG_LIBDIR='${libdir}/pkgconfig'
4860         AC_MSG_RESULT($PKG_CONFIG_LIBDIR)
4861         cf_search_path=
4862         ;;
4863 (x)
4864         ;;
4865 (x/*\ *)
4866         PKG_CONFIG_LIBDIR=
4867         ;;
4868 (x/*)
4869         PKG_CONFIG_LIBDIR="$cf_search_path"
4870         AC_MSG_RESULT($PKG_CONFIG_LIBDIR)
4871         cf_search_path=
4872         ;;
4873 (xyes|xauto)
4874         AC_MSG_RESULT(auto)
4875         cf_search_path=
4876         # Look for the library directory using the same prefix as the executable
4877         AC_MSG_CHECKING(for search-list)
4878         if test "x$PKG_CONFIG" != xnone
4879         then
4880                 # works for pkg-config since version 0.24 (2009)
4881                 # works for pkgconf since version 0.8.3 (2012)
4882                 for cf_pkg_program in \
4883                         `echo "$PKG_CONFIG" | sed -e 's,^.*/,,'` \
4884                         pkg-config \
4885                         pkgconf
4886                 do
4887                         cf_search_path=`"$PKG_CONFIG" --variable=pc_path "$cf_pkg_program" 2>/dev/null | tr : ' '`
4888                         test -n "$cf_search_path" && break
4889                 done
4890
4891                 # works for pkg-config since import in 2005 of original 2001 HP code.
4892                 test -z "$cf_search_path" && \
4893                 cf_search_path=`
4894                 "$PKG_CONFIG" --debug --exists no-such-package 2>&1 | $AWK "\
4895 /^Scanning directory (#[1-9][0-9]* )?'.*'$/{ \
4896         sub(\"^[[^']]*'\",\"\"); \
4897         sub(\"'.*\",\"\"); \
4898         printf \" %s\", \\[$]0; } \
4899 { next; } \
4900 "`
4901         fi
4902
4903         AC_MSG_RESULT($cf_search_path)
4904         ;;
4905 (*)
4906         AC_MSG_ERROR(Unexpected option value: $cf_search_path)
4907         ;;
4908 esac
4909
4910 if test -n "$cf_search_path"
4911 then
4912         AC_MSG_CHECKING(for first directory)
4913         cf_pkg_config_path=none
4914         for cf_config in $cf_search_path
4915         do
4916                 if test -d "$cf_config"
4917                 then
4918                         cf_pkg_config_path=$cf_config
4919                         break
4920                 fi
4921         done
4922         AC_MSG_RESULT($cf_pkg_config_path)
4923
4924         if test "x$cf_pkg_config_path" != xnone ; then
4925                 # limit this to the first directory found
4926                 PKG_CONFIG_LIBDIR="$cf_pkg_config_path"
4927         fi
4928
4929         if test -z "$PKG_CONFIG_LIBDIR" && test -n "$cf_search_path"
4930         then
4931                 AC_MSG_CHECKING(for workaround)
4932                 if test "$prefix" = "NONE" ; then
4933                         cf_prefix="$ac_default_prefix"
4934                 else
4935                         cf_prefix="$prefix"
4936                 fi
4937                 eval cf_libdir=$libdir
4938                 cf_libdir=`echo "$cf_libdir" | sed -e "s,^NONE,$cf_prefix,"`
4939                 cf_backup=
4940                 for cf_config in $cf_search_path
4941                 do
4942                         case $cf_config in
4943                         $cf_libdir/pkgconfig)
4944                                 PKG_CONFIG_LIBDIR=$cf_libdir/pkgconfig
4945                                 break
4946                                 ;;
4947                         *)
4948                                 test -z "$cf_backup" && cf_backup=$cf_config
4949                                 ;;
4950                         esac
4951                 done
4952                 test -z "$PKG_CONFIG_LIBDIR" && PKG_CONFIG_LIBDIR=$cf_backup
4953                 AC_MSG_RESULT($PKG_CONFIG_LIBDIR)
4954         fi
4955 fi
4956
4957 AC_SUBST(PKG_CONFIG_LIBDIR)
4958 ])dnl
4959 dnl ---------------------------------------------------------------------------
4960 dnl CF_WITH_PTHREAD version: 7 updated: 2015/04/18 08:56:57
4961 dnl ---------------
4962 dnl Check for POSIX thread library.
4963 AC_DEFUN([CF_WITH_PTHREAD],
4964 [
4965 AC_MSG_CHECKING(if you want to link with the pthread library)
4966 AC_ARG_WITH(pthread,
4967         [  --with-pthread          use POSIX thread library],
4968         [with_pthread=$withval],
4969         [with_pthread=no])
4970 AC_MSG_RESULT($with_pthread)
4971
4972 if test "$with_pthread" != no ; then
4973         AC_CHECK_HEADER(pthread.h,[
4974         AC_DEFINE(HAVE_PTHREADS_H,1,[Define to 1 if we have pthreads.h header])
4975
4976         for cf_lib_pthread in pthread c_r
4977         do
4978             AC_MSG_CHECKING(if we can link with the $cf_lib_pthread library)
4979             cf_save_LIBS="$LIBS"
4980             CF_ADD_LIB($cf_lib_pthread)
4981             AC_TRY_LINK([
4982 #include <pthread.h>
4983 ],[
4984                 int rc = pthread_create(0,0,0,0);
4985                 int r2 = pthread_mutexattr_settype(0, 0);
4986 ],[with_pthread=yes],[with_pthread=no])
4987             LIBS="$cf_save_LIBS"
4988             AC_MSG_RESULT($with_pthread)
4989             test "$with_pthread" = yes && break
4990         done
4991
4992         if test "$with_pthread" = yes ; then
4993             CF_ADD_LIB($cf_lib_pthread)
4994             AC_DEFINE(HAVE_LIBPTHREADS,1,[Define to 1 if we have pthreads library])
4995         else
4996             AC_MSG_ERROR(Cannot link with pthread library)
4997         fi
4998         ])
4999 fi
5000 ])
5001 dnl ---------------------------------------------------------------------------
5002 dnl CF_WITH_SYSTYPE version: 1 updated: 2013/01/26 16:26:12
5003 dnl ---------------
5004 dnl For testing, override the derived host system-type which is used to decide
5005 dnl things such as the linker commands used to build shared libraries.  This is
5006 dnl normally chosen automatically based on the type of system which you are
5007 dnl building on.  We use it for testing the configure script.
5008 dnl
5009 dnl This is different from the --host option: it is used only for testing parts
5010 dnl of the configure script which would not be reachable with --host since that
5011 dnl relies on the build environment being real, rather than mocked up.
5012 AC_DEFUN([CF_WITH_SYSTYPE],[
5013 CF_CHECK_CACHE([AC_CANONICAL_SYSTEM])
5014 AC_ARG_WITH(system-type,
5015         [  --with-system-type=XXX  test: override derived host system-type],
5016 [AC_MSG_WARN(overriding system type to $withval)
5017         cf_cv_system_name=$withval
5018         host_os=$withval
5019 ])
5020 ])dnl
5021 dnl ---------------------------------------------------------------------------
5022 dnl CF_XOPEN_SOURCE version: 63 updated: 2022/12/29 10:10:26
5023 dnl ---------------
5024 dnl Try to get _XOPEN_SOURCE defined properly that we can use POSIX functions,
5025 dnl or adapt to the vendor's definitions to get equivalent functionality,
5026 dnl without losing the common non-POSIX features.
5027 dnl
5028 dnl Parameters:
5029 dnl     $1 is the nominal value for _XOPEN_SOURCE
5030 dnl     $2 is the nominal value for _POSIX_C_SOURCE
5031 AC_DEFUN([CF_XOPEN_SOURCE],[
5032 AC_REQUIRE([AC_CANONICAL_HOST])
5033 AC_REQUIRE([CF_POSIX_VISIBLE])
5034
5035 if test "$cf_cv_posix_visible" = no; then
5036
5037 cf_XOPEN_SOURCE=ifelse([$1],,500,[$1])
5038 cf_POSIX_C_SOURCE=ifelse([$2],,199506L,[$2])
5039 cf_xopen_source=
5040
5041 case "$host_os" in
5042 (aix[[4-7]]*)
5043         cf_xopen_source="-D_ALL_SOURCE"
5044         ;;
5045 (msys)
5046         cf_XOPEN_SOURCE=600
5047         ;;
5048 (darwin[[0-8]].*)
5049         cf_xopen_source="-D_APPLE_C_SOURCE"
5050         ;;
5051 (darwin*)
5052         cf_xopen_source="-D_DARWIN_C_SOURCE"
5053         cf_XOPEN_SOURCE=
5054         ;;
5055 (freebsd*|dragonfly*|midnightbsd*)
5056         # 5.x headers associate
5057         #       _XOPEN_SOURCE=600 with _POSIX_C_SOURCE=200112L
5058         #       _XOPEN_SOURCE=500 with _POSIX_C_SOURCE=199506L
5059         cf_POSIX_C_SOURCE=200112L
5060         cf_XOPEN_SOURCE=600
5061         cf_xopen_source="-D_BSD_TYPES -D__BSD_VISIBLE -D_POSIX_C_SOURCE=$cf_POSIX_C_SOURCE -D_XOPEN_SOURCE=$cf_XOPEN_SOURCE"
5062         ;;
5063 (hpux11*)
5064         cf_xopen_source="-D_HPUX_SOURCE -D_XOPEN_SOURCE=500"
5065         ;;
5066 (hpux*)
5067         cf_xopen_source="-D_HPUX_SOURCE"
5068         ;;
5069 (irix[[56]].*)
5070         cf_xopen_source="-D_SGI_SOURCE"
5071         cf_XOPEN_SOURCE=
5072         ;;
5073 (linux*gnu|linux*gnuabi64|linux*gnuabin32|linux*gnueabi|linux*gnueabihf|linux*gnux32|uclinux*|gnu*|mint*|k*bsd*-gnu|cygwin)
5074         CF_GNU_SOURCE($cf_XOPEN_SOURCE)
5075         ;;
5076 (minix*)
5077         cf_xopen_source="-D_NETBSD_SOURCE" # POSIX.1-2001 features are ifdef'd with this...
5078         ;;
5079 (mirbsd*)
5080         # setting _XOPEN_SOURCE or _POSIX_SOURCE breaks <sys/select.h> and other headers which use u_int / u_short types
5081         cf_XOPEN_SOURCE=
5082         CF_POSIX_C_SOURCE($cf_POSIX_C_SOURCE)
5083         ;;
5084 (netbsd*)
5085         cf_xopen_source="-D_NETBSD_SOURCE" # setting _XOPEN_SOURCE breaks IPv6 for lynx on NetBSD 1.6, breaks xterm, is not needed for ncursesw
5086         ;;
5087 (openbsd[[6-9]]*)
5088         # OpenBSD 6.x has broken locale support, both compile-time and runtime.
5089         # see https://www.mail-archive.com/bugs@openbsd.org/msg13200.html
5090         # Abusing the conformance level is a workaround.
5091         AC_MSG_WARN(this system does not provide usable locale support)
5092         cf_xopen_source="-D_BSD_SOURCE"
5093         cf_XOPEN_SOURCE=700
5094         ;;
5095 (openbsd[[4-5]]*)
5096         # setting _XOPEN_SOURCE lower than 500 breaks g++ compile with wchar.h, needed for ncursesw
5097         cf_xopen_source="-D_BSD_SOURCE"
5098         cf_XOPEN_SOURCE=600
5099         ;;
5100 (openbsd*)
5101         # setting _XOPEN_SOURCE breaks xterm on OpenBSD 2.8, is not needed for ncursesw
5102         ;;
5103 (osf[[45]]*)
5104         cf_xopen_source="-D_OSF_SOURCE"
5105         ;;
5106 (nto-qnx*)
5107         cf_xopen_source="-D_QNX_SOURCE"
5108         ;;
5109 (sco*)
5110         # setting _XOPEN_SOURCE breaks Lynx on SCO Unix / OpenServer
5111         ;;
5112 (solaris2.*)
5113         cf_xopen_source="-D__EXTENSIONS__"
5114         cf_cv_xopen_source=broken
5115         ;;
5116 (sysv4.2uw2.*) # Novell/SCO UnixWare 2.x (tested on 2.1.2)
5117         cf_XOPEN_SOURCE=
5118         cf_POSIX_C_SOURCE=
5119         ;;
5120 (*)
5121         CF_TRY_XOPEN_SOURCE
5122         cf_save_xopen_cppflags="$CPPFLAGS"
5123         CF_POSIX_C_SOURCE($cf_POSIX_C_SOURCE)
5124         # Some of these niche implementations use copy/paste, double-check...
5125         if test "$cf_cv_xopen_source" != no ; then
5126                 CF_VERBOSE(checking if _POSIX_C_SOURCE inteferes)
5127                 AC_TRY_COMPILE(CF__XOPEN_SOURCE_HEAD,CF__XOPEN_SOURCE_BODY,,[
5128                         AC_MSG_WARN(_POSIX_C_SOURCE definition is not usable)
5129                         CPPFLAGS="$cf_save_xopen_cppflags"])
5130         fi
5131         ;;
5132 esac
5133
5134 if test -n "$cf_xopen_source" ; then
5135         CF_APPEND_CFLAGS($cf_xopen_source,true)
5136 fi
5137
5138 dnl In anything but the default case, we may have system-specific setting
5139 dnl which is still not guaranteed to provide all of the entrypoints that
5140 dnl _XOPEN_SOURCE would yield.
5141 if test -n "$cf_XOPEN_SOURCE" && test -z "$cf_cv_xopen_source" ; then
5142         AC_MSG_CHECKING(if _XOPEN_SOURCE really is set)
5143         AC_TRY_COMPILE([#include <stdlib.h>],[
5144 #ifndef _XOPEN_SOURCE
5145 make an error
5146 #endif],
5147         [cf_XOPEN_SOURCE_set=yes],
5148         [cf_XOPEN_SOURCE_set=no])
5149         AC_MSG_RESULT($cf_XOPEN_SOURCE_set)
5150         if test "$cf_XOPEN_SOURCE_set" = yes
5151         then
5152                 AC_TRY_COMPILE([#include <stdlib.h>],[
5153 #if (_XOPEN_SOURCE - 0) < $cf_XOPEN_SOURCE
5154 make an error
5155 #endif],
5156                 [cf_XOPEN_SOURCE_set_ok=yes],
5157                 [cf_XOPEN_SOURCE_set_ok=no])
5158                 if test "$cf_XOPEN_SOURCE_set_ok" = no
5159                 then
5160                         AC_MSG_WARN(_XOPEN_SOURCE is lower than requested)
5161                 fi
5162         else
5163                 CF_TRY_XOPEN_SOURCE
5164         fi
5165 fi
5166 fi # cf_cv_posix_visible
5167 ])
5168 dnl ---------------------------------------------------------------------------
5169 dnl CF__SED_TRIMBLANKS version: 1 updated: 2021/01/02 09:31:20
5170 dnl ------------------
5171 dnl Trim something using sed, then trim extra whitespace
5172 dnl $1 = extra parameters, e.g., in CF_STRIP_G_OPT
5173 define([CF__SED_TRIMBLANKS],[sed ifelse($1,,,[$1] )-e 's%[[     ]]% %g' -e 's% [[ ]]*% %g' -e 's%^ %%' -e 's% [$]%%'])dnl
5174 dnl ---------------------------------------------------------------------------
5175 dnl CF__XOPEN_SOURCE_BODY version: 1 updated: 2022/09/10 15:17:35
5176 dnl ---------------------
5177 dnl body of test when test-compiling for _XOPEN_SOURCE check
5178 define([CF__XOPEN_SOURCE_BODY],
5179 [
5180 #ifndef _XOPEN_SOURCE
5181 make an error
5182 #endif
5183 ])
5184 dnl ---------------------------------------------------------------------------
5185 dnl CF__XOPEN_SOURCE_HEAD version: 1 updated: 2022/09/10 15:17:03
5186 dnl ---------------------
5187 dnl headers to include when test-compiling for _XOPEN_SOURCE check
5188 define([CF__XOPEN_SOURCE_HEAD],
5189 [
5190 #include <stdlib.h>
5191 #include <string.h>
5192 #include <sys/types.h>
5193 ])