Ada95/aclocal.m4

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