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