Ada95/aclocal.m4

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