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