Ada95/aclocal.m4

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