aclocal.m4

   1 dnl***************************************************************************
   2 dnl Copyright 2018-2019,2020 Thomas E. Dickey                                *
   3 dnl Copyright 1998-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 1995-on
  31 dnl
  32 dnl $Id: aclocal.m4,v 1.931 2020/09/12 22:30:53 tom Exp $
  33 dnl Macros used in NCURSES 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 AM_LANGINFO_CODESET version: 5 updated: 2020/03/10 18:53:47
  46 dnl -------------------
  47 dnl Inserted as requested by gettext 0.10.40
  48 dnl File from /usr/share/aclocal
  49 dnl codeset.m4
  50 dnl ====================
  51 dnl serial AM1
  52 dnl
  53 dnl From Bruno Haible.
  54 AC_DEFUN([AM_LANGINFO_CODESET],
  55 [
  56 AC_CACHE_CHECK([for nl_langinfo and CODESET], am_cv_langinfo_codeset,
  57         [AC_TRY_LINK([#include <langinfo.h>],
  58         [char* cs = nl_langinfo(CODESET); (void)cs],
  59         am_cv_langinfo_codeset=yes,
  60         am_cv_langinfo_codeset=no)
  61         ])
  62         if test $am_cv_langinfo_codeset = yes; then
  63                 AC_DEFINE(HAVE_LANGINFO_CODESET, 1,
  64                 [Define if you have <langinfo.h> and nl_langinfo(CODESET).])
  65         fi
  66 ])dnl
  67 dnl ---------------------------------------------------------------------------
  68 dnl CF_ABI_DEFAULTS version: 2 updated: 2015/06/06 13:49:58
  69 dnl ---------------
  70 dnl Provide configure-script defaults for different ncurses ABIs.
  71 AC_DEFUN([CF_ABI_DEFAULTS],[
  72 AC_REQUIRE([CF_NCURSES_WITH_ABI_VERSION])
  73 case x$cf_cv_abi_version in
  74 (x[[6789]])
  75         cf_dft_ext_colors=yes
  76         cf_dft_ext_const=yes
  77         cf_dft_ext_mouse=yes
  78         cf_dft_ext_putwin=yes
  79         cf_dft_ext_spfuncs=yes
  80         cf_dft_filter_syms=yes
  81         cf_dft_chtype=uint32_t
  82         cf_dft_mmask_t=uint32_t
  83         cf_dft_interop=yes
  84         cf_dft_tparm_arg=intptr_t
  85         cf_dft_with_lp64=yes
  86         ;;
  87 (*)
  88         cf_dft_ext_colors=no
  89         cf_dft_ext_const=no
  90         cf_dft_ext_mouse=no
  91         cf_dft_ext_putwin=no
  92         cf_dft_ext_spfuncs=no
  93         cf_dft_filter_syms=no
  94         cf_dft_chtype=auto
  95         cf_dft_mmask_t=auto
  96         cf_dft_interop=no
  97         cf_dft_tparm_arg=long
  98         cf_dft_with_lp64=no
  99         ;;
 100 esac
 101 ])dnl
 102 dnl ---------------------------------------------------------------------------
 103 dnl CF_ACVERSION_CHECK version: 5 updated: 2014/06/04 19:11:49
 104 dnl ------------------
 105 dnl Conditionally generate script according to whether we're using a given autoconf.
 106 dnl
 107 dnl $1 = version to compare against
 108 dnl $2 = code to use if AC_ACVERSION is at least as high as $1.
 109 dnl $3 = code to use if AC_ACVERSION is older than $1.
 110 define([CF_ACVERSION_CHECK],
 111 [
 112 ifdef([AC_ACVERSION], ,[ifdef([AC_AUTOCONF_VERSION],[m4_copy([AC_AUTOCONF_VERSION],[AC_ACVERSION])],[m4_copy([m4_PACKAGE_VERSION],[AC_ACVERSION])])])dnl
 113 ifdef([m4_version_compare],
 114 [m4_if(m4_version_compare(m4_defn([AC_ACVERSION]), [$1]), -1, [$3], [$2])],
 115 [CF_ACVERSION_COMPARE(
 116 AC_PREREQ_CANON(AC_PREREQ_SPLIT([$1])),
 117 AC_PREREQ_CANON(AC_PREREQ_SPLIT(AC_ACVERSION)), AC_ACVERSION, [$2], [$3])])])dnl
 118 dnl ---------------------------------------------------------------------------
 119 dnl CF_ACVERSION_COMPARE version: 3 updated: 2012/10/03 18:39:53
 120 dnl --------------------
 121 dnl CF_ACVERSION_COMPARE(MAJOR1, MINOR1, TERNARY1,
 122 dnl                      MAJOR2, MINOR2, TERNARY2,
 123 dnl                      PRINTABLE2, not FOUND, FOUND)
 124 define([CF_ACVERSION_COMPARE],
 125 [ifelse(builtin([eval], [$2 < $5]), 1,
 126 [ifelse([$8], , ,[$8])],
 127 [ifelse([$9], , ,[$9])])])dnl
 128 dnl ---------------------------------------------------------------------------
 129 dnl CF_ADA_INCLUDE_DIRS version: 8 updated: 2013/10/14 04:24:07
 130 dnl -------------------
 131 dnl Construct the list of include-options for the C programs in the Ada95
 132 dnl binding.
 133 AC_DEFUN([CF_ADA_INCLUDE_DIRS],
 134 [
 135 ACPPFLAGS="-I. -I../include -I../../include $ACPPFLAGS"
 136 if test "$srcdir" != "."; then
 137         ACPPFLAGS="-I\${srcdir}/../../include $ACPPFLAGS"
 138 fi
 139 if test "$GCC" != yes; then
 140         ACPPFLAGS="$ACPPFLAGS -I\${includedir}"
 141 elif test "$includedir" != "/usr/include"; then
 142         if test "$includedir" = '${prefix}/include' ; then
 143                 if test x$prefix != x/usr ; then
 144                         ACPPFLAGS="$ACPPFLAGS -I\${includedir}"
 145                 fi
 146         else
 147                 ACPPFLAGS="$ACPPFLAGS -I\${includedir}"
 148         fi
 149 fi
 150 AC_SUBST(ACPPFLAGS)
 151 ])dnl
 152 dnl ---------------------------------------------------------------------------
 153 dnl CF_ADD_ADAFLAGS version: 1 updated: 2010/06/19 15:22:18
 154 dnl ---------------
 155 dnl Add to $ADAFLAGS, which is substituted into makefile and scripts.
 156 AC_DEFUN([CF_ADD_ADAFLAGS],[
 157         ADAFLAGS="$ADAFLAGS $1"
 158         AC_SUBST(ADAFLAGS)
 159 ])dnl
 160 dnl ---------------------------------------------------------------------------
 161 dnl CF_ADD_CFLAGS version: 14 updated: 2020/04/04 16:16:13
 162 dnl -------------
 163 dnl Copy non-preprocessor flags to $CFLAGS, preprocessor flags to $CPPFLAGS
 164 dnl $1 = flags to add
 165 dnl $2 = if given makes this macro verbose.
 166 dnl
 167 dnl Put any preprocessor definitions that use quoted strings in $EXTRA_CPPFLAGS,
 168 dnl to simplify use of $CPPFLAGS in compiler checks, etc., that are easily
 169 dnl confused by the quotes (which require backslashes to keep them usable).
 170 AC_DEFUN([CF_ADD_CFLAGS],
 171 [
 172 cf_fix_cppflags=no
 173 cf_new_cflags=
 174 cf_new_cppflags=
 175 cf_new_extra_cppflags=
 176
 177 for cf_add_cflags in $1
 178 do
 179 case $cf_fix_cppflags in
 180 (no)
 181         case $cf_add_cflags in
 182         (-undef|-nostdinc*|-I*|-D*|-U*|-E|-P|-C)
 183                 case $cf_add_cflags in
 184                 (-D*)
 185                         cf_tst_cflags=`echo ${cf_add_cflags} |sed -e 's/^-D[[^=]]*='\''\"[[^"]]*//'`
 186
 187                         test "x${cf_add_cflags}" != "x${cf_tst_cflags}" \
 188                                 && test -z "${cf_tst_cflags}" \
 189                                 && cf_fix_cppflags=yes
 190
 191                         if test $cf_fix_cppflags = yes ; then
 192                                 CF_APPEND_TEXT(cf_new_extra_cppflags,$cf_add_cflags)
 193                                 continue
 194                         elif test "${cf_tst_cflags}" = "\"'" ; then
 195                                 CF_APPEND_TEXT(cf_new_extra_cppflags,$cf_add_cflags)
 196                                 continue
 197                         fi
 198                         ;;
 199                 esac
 200                 case "$CPPFLAGS" in
 201                 (*$cf_add_cflags)
 202                         ;;
 203                 (*)
 204                         case $cf_add_cflags in
 205                         (-D*)
 206                                 cf_tst_cppflags=`echo "x$cf_add_cflags" | sed -e 's/^...//' -e 's/=.*//'`
 207                                 CF_REMOVE_DEFINE(CPPFLAGS,$CPPFLAGS,$cf_tst_cppflags)
 208                                 ;;
 209                         esac
 210                         CF_APPEND_TEXT(cf_new_cppflags,$cf_add_cflags)
 211                         ;;
 212                 esac
 213                 ;;
 214         (*)
 215                 CF_APPEND_TEXT(cf_new_cflags,$cf_add_cflags)
 216                 ;;
 217         esac
 218         ;;
 219 (yes)
 220         CF_APPEND_TEXT(cf_new_extra_cppflags,$cf_add_cflags)
 221
 222         cf_tst_cflags=`echo ${cf_add_cflags} |sed -e 's/^[[^"]]*"'\''//'`
 223
 224         test "x${cf_add_cflags}" != "x${cf_tst_cflags}" \
 225                 && test -z "${cf_tst_cflags}" \
 226                 && cf_fix_cppflags=no
 227         ;;
 228 esac
 229 done
 230
 231 if test -n "$cf_new_cflags" ; then
 232         ifelse([$2],,,[CF_VERBOSE(add to \$CFLAGS $cf_new_cflags)])
 233         CF_APPEND_TEXT(CFLAGS,$cf_new_cflags)
 234 fi
 235
 236 if test -n "$cf_new_cppflags" ; then
 237         ifelse([$2],,,[CF_VERBOSE(add to \$CPPFLAGS $cf_new_cppflags)])
 238         CF_APPEND_TEXT(CPPFLAGS,$cf_new_cppflags)
 239 fi
 240
 241 if test -n "$cf_new_extra_cppflags" ; then
 242         ifelse([$2],,,[CF_VERBOSE(add to \$EXTRA_CPPFLAGS $cf_new_extra_cppflags)])
 243         CF_APPEND_TEXT(EXTRA_CPPFLAGS,$cf_new_extra_cppflags)
 244 fi
 245
 246 AC_SUBST(EXTRA_CPPFLAGS)
 247
 248 ])dnl
 249 dnl ---------------------------------------------------------------------------
 250 dnl CF_ADD_CXXFLAGS version: 1 updated: 2020/04/04 16:16:13
 251 dnl ---------------
 252 dnl Copy non-preprocessor flags to $CXXFLAGS, preprocessor flags to $CPPFLAGS
 253 dnl The second parameter if given makes this macro verbose.
 254 dnl
 255 dnl Put any preprocessor definitions that use quoted strings in $EXTRA_CPPFLAGS,
 256 dnl to simplify use of $CPPFLAGS in compiler checks, etc., that are easily
 257 dnl confused by the quotes (which require backslashes to keep them usable).
 258 AC_DEFUN([CF_ADD_CXXFLAGS],
 259 [
 260 cf_save_CXXFLAGS="$CFLAGS"
 261 CFLAGS="$CXXFLAGS"
 262 CF_ADD_CFLAGS($1 ifelse($2,,,[,$2]))
 263 CXXFLAGS="$CFLAGS"
 264 CFLAGS="$cf_save_CXXFLAGS"
 265 ])dnl
 266 dnl ---------------------------------------------------------------------------
 267 dnl CF_ADD_INCDIR version: 15 updated: 2018/06/20 20:23:13
 268 dnl -------------
 269 dnl Add an include-directory to $CPPFLAGS.  Don't add /usr/include, since it's
 270 dnl redundant.  We don't normally need to add -I/usr/local/include for gcc,
 271 dnl but old versions (and some misinstalled ones) need that.  To make things
 272 dnl worse, gcc 3.x may give error messages if -I/usr/local/include is added to
 273 dnl the include-path).
 274 AC_DEFUN([CF_ADD_INCDIR],
 275 [
 276 if test -n "$1" ; then
 277   for cf_add_incdir in $1
 278   do
 279         while test $cf_add_incdir != /usr/include
 280         do
 281           if test -d $cf_add_incdir
 282           then
 283                 cf_have_incdir=no
 284                 if test -n "$CFLAGS$CPPFLAGS" ; then
 285                   # a loop is needed to ensure we can add subdirs of existing dirs
 286                   for cf_test_incdir in $CFLAGS $CPPFLAGS ; do
 287                         if test ".$cf_test_incdir" = ".-I$cf_add_incdir" ; then
 288                           cf_have_incdir=yes; break
 289                         fi
 290                   done
 291                 fi
 292
 293                 if test "$cf_have_incdir" = no ; then
 294                   if test "$cf_add_incdir" = /usr/local/include ; then
 295                         if test "$GCC" = yes
 296                         then
 297                           cf_save_CPPFLAGS=$CPPFLAGS
 298                           CF_APPEND_TEXT(CPPFLAGS,-I$cf_add_incdir)
 299                           AC_TRY_COMPILE([#include <stdio.h>],
 300                                   [printf("Hello")],
 301                                   [],
 302                                   [cf_have_incdir=yes])
 303                           CPPFLAGS=$cf_save_CPPFLAGS
 304                         fi
 305                   fi
 306                 fi
 307
 308                 if test "$cf_have_incdir" = no ; then
 309                   CF_VERBOSE(adding $cf_add_incdir to include-path)
 310                   ifelse([$2],,CPPFLAGS,[$2])="$ifelse([$2],,CPPFLAGS,[$2]) -I$cf_add_incdir"
 311
 312                   cf_top_incdir=`echo $cf_add_incdir | sed -e 's%/include/.*$%/include%'`
 313                   test "$cf_top_incdir" = "$cf_add_incdir" && break
 314                   cf_add_incdir="$cf_top_incdir"
 315                 else
 316                   break
 317                 fi
 318           else
 319                 break
 320           fi
 321         done
 322   done
 323 fi
 324 ])dnl
 325 dnl ---------------------------------------------------------------------------
 326 dnl CF_ADD_LIB version: 2 updated: 2010/06/02 05:03:05
 327 dnl ----------
 328 dnl Add a library, used to enforce consistency.
 329 dnl
 330 dnl $1 = library to add, without the "-l"
 331 dnl $2 = variable to update (default $LIBS)
 332 AC_DEFUN([CF_ADD_LIB],[CF_ADD_LIBS(-l$1,ifelse($2,,LIBS,[$2]))])dnl
 333 dnl ---------------------------------------------------------------------------
 334 dnl CF_ADD_LIBDIR version: 10 updated: 2015/04/18 08:56:57
 335 dnl -------------
 336 dnl     Adds to the library-path
 337 dnl
 338 dnl     Some machines have trouble with multiple -L options.
 339 dnl
 340 dnl $1 is the (list of) directory(s) to add
 341 dnl $2 is the optional name of the variable to update (default LDFLAGS)
 342 dnl
 343 AC_DEFUN([CF_ADD_LIBDIR],
 344 [
 345 if test -n "$1" ; then
 346         for cf_add_libdir in $1
 347         do
 348                 if test $cf_add_libdir = /usr/lib ; then
 349                         :
 350                 elif test -d $cf_add_libdir
 351                 then
 352                         cf_have_libdir=no
 353                         if test -n "$LDFLAGS$LIBS" ; then
 354                                 # a loop is needed to ensure we can add subdirs of existing dirs
 355                                 for cf_test_libdir in $LDFLAGS $LIBS ; do
 356                                         if test ".$cf_test_libdir" = ".-L$cf_add_libdir" ; then
 357                                                 cf_have_libdir=yes; break
 358                                         fi
 359                                 done
 360                         fi
 361                         if test "$cf_have_libdir" = no ; then
 362                                 CF_VERBOSE(adding $cf_add_libdir to library-path)
 363                                 ifelse([$2],,LDFLAGS,[$2])="-L$cf_add_libdir $ifelse([$2],,LDFLAGS,[$2])"
 364                         fi
 365                 fi
 366         done
 367 fi
 368 ])dnl
 369 dnl ---------------------------------------------------------------------------
 370 dnl CF_ADD_LIBS version: 3 updated: 2019/11/02 16:47:33
 371 dnl -----------
 372 dnl Add one or more libraries, used to enforce consistency.  Libraries are
 373 dnl prepended to an existing list, since their dependencies are assumed to
 374 dnl already exist in the list.
 375 dnl
 376 dnl $1 = libraries to add, with the "-l", etc.
 377 dnl $2 = variable to update (default $LIBS)
 378 AC_DEFUN([CF_ADD_LIBS],[
 379 cf_add_libs="[$]ifelse($2,,LIBS,[$2])"
 380 # reverse order
 381 cf_add_0lib=
 382 for cf_add_1lib in $1; do cf_add_0lib="$cf_add_1lib $cf_add_0lib"; done
 383 # filter duplicates
 384 for cf_add_1lib in $cf_add_0lib; do
 385         for cf_add_2lib in $cf_add_libs; do
 386                 if test "x$cf_add_1lib" = "x$cf_add_2lib"; then
 387                         cf_add_1lib=
 388                         break
 389                 fi
 390         done
 391         test -n "$cf_add_1lib" && cf_add_libs="$cf_add_1lib $cf_add_libs"
 392 done
 393 ifelse($2,,LIBS,[$2])="$cf_add_libs"
 394 ])dnl
 395 dnl ---------------------------------------------------------------------------
 396 dnl CF_ADD_SUBDIR_PATH version: 4 updated: 2013/10/08 17:47:05
 397 dnl ------------------
 398 dnl Append to a search-list for a nonstandard header/lib-file
 399 dnl     $1 = the variable to return as result
 400 dnl     $2 = the package name
 401 dnl     $3 = the subdirectory, e.g., bin, include or lib
 402 dnl $4 = the directory under which we will test for subdirectories
 403 dnl $5 = a directory that we do not want $4 to match
 404 AC_DEFUN([CF_ADD_SUBDIR_PATH],
 405 [
 406 test "x$4" != "x$5" && \
 407 test -d "$4" && \
 408 ifelse([$5],NONE,,[(test -z "$5" || test x$5 = xNONE || test "x$4" != "x$5") &&]) {
 409         test -n "$verbose" && echo "    ... testing for $3-directories under $4"
 410         test -d $4/$3 &&          $1="[$]$1 $4/$3"
 411         test -d $4/$3/$2 &&       $1="[$]$1 $4/$3/$2"
 412         test -d $4/$3/$2/$3 &&    $1="[$]$1 $4/$3/$2/$3"
 413         test -d $4/$2/$3 &&       $1="[$]$1 $4/$2/$3"
 414         test -d $4/$2/$3/$2 &&    $1="[$]$1 $4/$2/$3/$2"
 415 }
 416 ])dnl
 417 dnl ---------------------------------------------------------------------------
 418 dnl CF_APPEND_TEXT version: 1 updated: 2017/02/25 18:58:55
 419 dnl --------------
 420 dnl use this macro for appending text without introducing an extra blank at
 421 dnl the beginning
 422 define([CF_APPEND_TEXT],
 423 [
 424         test -n "[$]$1" && $1="[$]$1 "
 425         $1="[$]{$1}$2"
 426 ])dnl
 427 dnl ---------------------------------------------------------------------------
 428 dnl CF_ARG_DISABLE version: 3 updated: 1999/03/30 17:24:31
 429 dnl --------------
 430 dnl Allow user to disable a normally-on option.
 431 AC_DEFUN([CF_ARG_DISABLE],
 432 [CF_ARG_OPTION($1,[$2],[$3],[$4],yes)])dnl
 433 dnl ---------------------------------------------------------------------------
 434 dnl CF_ARG_ENABLE version: 3 updated: 1999/03/30 17:24:31
 435 dnl -------------
 436 dnl Allow user to enable a normally-off option.
 437 AC_DEFUN([CF_ARG_ENABLE],
 438 [CF_ARG_OPTION($1,[$2],[$3],[$4],no)])dnl
 439 dnl ---------------------------------------------------------------------------
 440 dnl CF_ARG_OPTION version: 5 updated: 2015/05/10 19:52:14
 441 dnl -------------
 442 dnl Restricted form of AC_ARG_ENABLE that ensures user doesn't give bogus
 443 dnl values.
 444 dnl
 445 dnl Parameters:
 446 dnl $1 = option name
 447 dnl $2 = help-string
 448 dnl $3 = action to perform if option is not default
 449 dnl $4 = action if perform if option is default
 450 dnl $5 = default option value (either 'yes' or 'no')
 451 AC_DEFUN([CF_ARG_OPTION],
 452 [AC_ARG_ENABLE([$1],[$2],[test "$enableval" != ifelse([$5],no,yes,no) && enableval=ifelse([$5],no,no,yes)
 453         if test "$enableval" != "$5" ; then
 454 ifelse([$3],,[    :]dnl
 455 ,[    $3]) ifelse([$4],,,[
 456         else
 457                 $4])
 458         fi],[enableval=$5 ifelse([$4],,,[
 459         $4
 460 ])dnl
 461 ])])dnl
 462 dnl ---------------------------------------------------------------------------
 463 dnl CF_AR_FLAGS version: 7 updated: 2020/04/04 11:37:29
 464 dnl -----------
 465 dnl Check for suitable "ar" (archiver) options for updating an archive.
 466 dnl
 467 dnl In particular, handle some obsolete cases where the "-" might be omitted,
 468 dnl as well as a workaround for breakage of make's archive rules by the GNU
 469 dnl binutils "ar" program.
 470 AC_DEFUN([CF_AR_FLAGS],[
 471 AC_REQUIRE([CF_PROG_AR])
 472
 473 AC_CACHE_CHECK(for options to update archives, cf_cv_ar_flags,[
 474         case $cf_cv_system_name in
 475         (*-msvc*)
 476                 cf_cv_ar_flags=''
 477                 cat >mk_static_lib.sh <<-EOF
 478                 #!$SHELL
 479                 MSVC_BIN="[$]AR"
 480                 out="\[$]1"
 481                 shift
 482                 exec \[$]MSVC_BIN -out:"\[$]out" \[$]@
 483                 EOF
 484                 chmod +x mk_static_lib.sh
 485                 AR=`pwd`/mk_static_lib.sh
 486                 ;;
 487         (*)
 488                 cf_cv_ar_flags=unknown
 489                 for cf_ar_flags in -curvU -curv curv -crv crv -cqv cqv -rv rv
 490                 do
 491
 492                         # check if $ARFLAGS already contains this choice
 493                         if test "x$ARFLAGS" != "x" ; then
 494                                 cf_check_ar_flags=`echo "x$ARFLAGS" | sed -e "s/$cf_ar_flags\$//" -e "s/$cf_ar_flags / /"`
 495                                 if test "x$ARFLAGS" != "$cf_check_ar_flags" ; then
 496                                         cf_cv_ar_flags=
 497                                         break
 498                                 fi
 499                         fi
 500
 501                         rm -f conftest.$ac_cv_objext
 502                         rm -f conftest.a
 503
 504                         cat >conftest.$ac_ext <<EOF
 505 #line __oline__ "configure"
 506 int     testdata[[3]] = { 123, 456, 789 };
 507 EOF
 508                         if AC_TRY_EVAL(ac_compile) ; then
 509                                 echo "$AR $ARFLAGS $cf_ar_flags conftest.a conftest.$ac_cv_objext" >&AC_FD_CC
 510                                 $AR $ARFLAGS $cf_ar_flags conftest.a conftest.$ac_cv_objext 2>&AC_FD_CC 1>/dev/null
 511                                 if test -f conftest.a ; then
 512                                         cf_cv_ar_flags=$cf_ar_flags
 513                                         break
 514                                 fi
 515                         else
 516                                 CF_VERBOSE(cannot compile test-program)
 517                                 break
 518                         fi
 519                 done
 520                 rm -f conftest.a conftest.$ac_ext conftest.$ac_cv_objext
 521                 ;;
 522         esac
 523 ])
 524
 525 if test -n "$ARFLAGS" ; then
 526         if test -n "$cf_cv_ar_flags" ; then
 527                 ARFLAGS="$ARFLAGS $cf_cv_ar_flags"
 528         fi
 529 else
 530         ARFLAGS=$cf_cv_ar_flags
 531 fi
 532
 533 AC_SUBST(ARFLAGS)
 534 ])
 535 dnl ---------------------------------------------------------------------------
 536 dnl CF_AWK_BIG_PRINTF version: 5 updated: 2015/04/17 21:13:04
 537 dnl -----------------
 538 dnl Check if awk can handle big strings using printf.  Some older versions of
 539 dnl awk choke on large strings passed via "%s".
 540 dnl
 541 dnl $1 = desired string size
 542 dnl $2 = variable to set with result
 543 AC_DEFUN([CF_AWK_BIG_PRINTF],
 544 [
 545         case x$AWK in
 546         (x)
 547                 eval $2=no
 548                 ;;
 549         (*)
 550                 if ( ${AWK} 'BEGIN { xx = "x"; while (length(xx) < $1) { xx = xx "x"; }; printf("%s\n", xx); }' 2>/dev/null \
 551                         | $AWK '{ printf "%d\n", length([$]0); }' 2>/dev/null | $AWK 'BEGIN { eqls=0; recs=0; } { recs++; if ([$]0 == 12000) eqls++; } END { if (recs != 1 || eqls != 1) exit 1; }' 2>/dev/null >/dev/null ) ; then
 552                         eval $2=yes
 553                 else
 554                         eval $2=no
 555                 fi
 556                 ;;
 557         esac
 558 ])dnl
 559 dnl ---------------------------------------------------------------------------
 560 dnl CF_BOOL_DECL version: 8 updated: 2004/01/30 15:51:18
 561 dnl ------------
 562 dnl Test if 'bool' is a builtin type in the configured C++ compiler.  Some
 563 dnl older compilers (e.g., gcc 2.5.8) don't support 'bool' directly; gcc
 564 dnl 2.6.3 does, in anticipation of the ANSI C++ standard.
 565 dnl
 566 dnl Treat the configuration-variable specially here, since we're directly
 567 dnl substituting its value (i.e., 1/0).
 568 dnl
 569 dnl $1 is the shell variable to store the result in, if not $cv_cv_builtin_bool
 570 AC_DEFUN([CF_BOOL_DECL],
 571 [
 572 AC_MSG_CHECKING(if we should include stdbool.h)
 573
 574 AC_CACHE_VAL(cf_cv_header_stdbool_h,[
 575         AC_TRY_COMPILE([],[bool foo = false],
 576                 [cf_cv_header_stdbool_h=0],
 577                 [AC_TRY_COMPILE([
 578 #ifndef __BEOS__
 579 #include <stdbool.h>
 580 #endif
 581 ],[bool foo = false],
 582                         [cf_cv_header_stdbool_h=1],
 583                         [cf_cv_header_stdbool_h=0])])])
 584
 585 if test "$cf_cv_header_stdbool_h" = 1
 586 then    AC_MSG_RESULT(yes)
 587 else    AC_MSG_RESULT(no)
 588 fi
 589
 590 AC_MSG_CHECKING([for builtin bool type])
 591
 592 AC_CACHE_VAL(ifelse($1,,cf_cv_builtin_bool,[$1]),[
 593         AC_TRY_COMPILE([
 594 #include <stdio.h>
 595 #include <sys/types.h>
 596 ],[bool x = false],
 597                 [ifelse($1,,cf_cv_builtin_bool,[$1])=1],
 598                 [ifelse($1,,cf_cv_builtin_bool,[$1])=0])
 599         ])
 600
 601 if test "$ifelse($1,,cf_cv_builtin_bool,[$1])" = 1
 602 then    AC_MSG_RESULT(yes)
 603 else    AC_MSG_RESULT(no)
 604 fi
 605 ])dnl
 606 dnl ---------------------------------------------------------------------------
 607 dnl CF_BOOL_SIZE version: 15 updated: 2017/01/21 11:06:25
 608 dnl ------------
 609 dnl Test for the size of 'bool' in the configured C++ compiler (e.g., a type).
 610 dnl Don't bother looking for bool.h, since it's been deprecated.
 611 dnl
 612 dnl If the current compiler is C rather than C++, we get the bool definition
 613 dnl from <stdbool.h>.
 614 AC_DEFUN([CF_BOOL_SIZE],
 615 [
 616 AC_MSG_CHECKING([for size of bool])
 617 AC_CACHE_VAL(cf_cv_type_of_bool,[
 618         rm -f cf_test.out
 619         AC_TRY_RUN([
 620 #include <stdlib.h>
 621 #include <stdio.h>
 622
 623 #if defined(__cplusplus)
 624
 625 #ifdef HAVE_GXX_BUILTIN_H
 626 #include <g++/builtin.h>
 627 #elif HAVE_GPP_BUILTIN_H
 628 #include <gpp/builtin.h>
 629 #elif HAVE_BUILTIN_H
 630 #include <builtin.h>
 631 #endif
 632
 633 #else
 634
 635 #if $cf_cv_header_stdbool_h
 636 #include <stdbool.h>
 637 #endif
 638
 639 #endif
 640
 641 int main(void)
 642 {
 643         FILE *fp = fopen("cf_test.out", "w");
 644         if (fp != 0) {
 645                 bool x = true;
 646                 if ((bool)(-x) >= 0)
 647                         fputs("unsigned ", fp);
 648                 if (sizeof(x) == sizeof(int))       fputs("int",  fp);
 649                 else if (sizeof(x) == sizeof(char)) fputs("char", fp);
 650                 else if (sizeof(x) == sizeof(short))fputs("short",fp);
 651                 else if (sizeof(x) == sizeof(long)) fputs("long", fp);
 652                 fclose(fp);
 653         }
 654         ${cf_cv_main_return:-return}(0);
 655 }
 656                 ],
 657                 [cf_cv_type_of_bool=`cat cf_test.out`
 658                  if test -z "$cf_cv_type_of_bool"; then
 659                    cf_cv_type_of_bool=unknown
 660                  fi],
 661                 [cf_cv_type_of_bool=unknown],
 662                 [cf_cv_type_of_bool=unknown])
 663         ])
 664         rm -f cf_test.out
 665 AC_MSG_RESULT($cf_cv_type_of_bool)
 666 if test "$cf_cv_type_of_bool" = unknown ; then
 667         case .$NCURSES_BOOL in
 668         (.auto|.) NCURSES_BOOL=unsigned;;
 669         esac
 670         AC_MSG_WARN(Assuming $NCURSES_BOOL for type of bool)
 671         cf_cv_type_of_bool=$NCURSES_BOOL
 672 fi
 673 ])dnl
 674 dnl ---------------------------------------------------------------------------
 675 dnl CF_BUILD_CC version: 8 updated: 2018/01/04 20:31:04
 676 dnl -----------
 677 dnl If we're cross-compiling, allow the user to override the tools and their
 678 dnl options.  The configure script is oriented toward identifying the host
 679 dnl compiler, etc., but we need a build compiler to generate parts of the
 680 dnl source.
 681 dnl
 682 dnl $1 = default for $CPPFLAGS
 683 dnl $2 = default for $LIBS
 684 AC_DEFUN([CF_BUILD_CC],[
 685 CF_ACVERSION_CHECK(2.52,,
 686         [AC_REQUIRE([CF_PROG_EXT])])
 687 if test "$cross_compiling" = yes ; then
 688
 689         # defaults that we might want to override
 690         : ${BUILD_CFLAGS:=''}
 691         : ${BUILD_CPPFLAGS:='ifelse([$1],,,[$1])'}
 692         : ${BUILD_LDFLAGS:=''}
 693         : ${BUILD_LIBS:='ifelse([$2],,,[$2])'}
 694         : ${BUILD_EXEEXT:='$x'}
 695         : ${BUILD_OBJEXT:='o'}
 696
 697         AC_ARG_WITH(build-cc,
 698                 [  --with-build-cc=XXX     the build C compiler ($BUILD_CC)],
 699                 [BUILD_CC="$withval"],
 700                 [AC_CHECK_PROGS(BUILD_CC, [gcc clang c99 c89 cc cl],none)])
 701         AC_MSG_CHECKING(for native build C compiler)
 702         AC_MSG_RESULT($BUILD_CC)
 703
 704         AC_MSG_CHECKING(for native build C preprocessor)
 705         AC_ARG_WITH(build-cpp,
 706                 [  --with-build-cpp=XXX    the build C preprocessor ($BUILD_CPP)],
 707                 [BUILD_CPP="$withval"],
 708                 [BUILD_CPP='${BUILD_CC} -E'])
 709         AC_MSG_RESULT($BUILD_CPP)
 710
 711         AC_MSG_CHECKING(for native build C flags)
 712         AC_ARG_WITH(build-cflags,
 713                 [  --with-build-cflags=XXX the build C compiler-flags ($BUILD_CFLAGS)],
 714                 [BUILD_CFLAGS="$withval"])
 715         AC_MSG_RESULT($BUILD_CFLAGS)
 716
 717         AC_MSG_CHECKING(for native build C preprocessor-flags)
 718         AC_ARG_WITH(build-cppflags,
 719                 [  --with-build-cppflags=XXX the build C preprocessor-flags ($BUILD_CPPFLAGS)],
 720                 [BUILD_CPPFLAGS="$withval"])
 721         AC_MSG_RESULT($BUILD_CPPFLAGS)
 722
 723         AC_MSG_CHECKING(for native build linker-flags)
 724         AC_ARG_WITH(build-ldflags,
 725                 [  --with-build-ldflags=XXX the build linker-flags ($BUILD_LDFLAGS)],
 726                 [BUILD_LDFLAGS="$withval"])
 727         AC_MSG_RESULT($BUILD_LDFLAGS)
 728
 729         AC_MSG_CHECKING(for native build linker-libraries)
 730         AC_ARG_WITH(build-libs,
 731                 [  --with-build-libs=XXX   the build libraries (${BUILD_LIBS})],
 732                 [BUILD_LIBS="$withval"])
 733         AC_MSG_RESULT($BUILD_LIBS)
 734
 735         # this assumes we're on Unix.
 736         BUILD_EXEEXT=
 737         BUILD_OBJEXT=o
 738
 739         : ${BUILD_CC:='${CC}'}
 740
 741         if ( test "$BUILD_CC" = "$CC" || test "$BUILD_CC" = '${CC}' ) ; then
 742                 AC_MSG_ERROR([Cross-build requires two compilers.
 743 Use --with-build-cc to specify the native compiler.])
 744         fi
 745
 746 else
 747         : ${BUILD_CC:='${CC}'}
 748         : ${BUILD_CPP:='${CPP}'}
 749         : ${BUILD_CFLAGS:='${CFLAGS}'}
 750         : ${BUILD_CPPFLAGS:='${CPPFLAGS}'}
 751         : ${BUILD_LDFLAGS:='${LDFLAGS}'}
 752         : ${BUILD_LIBS:='${LIBS}'}
 753         : ${BUILD_EXEEXT:='$x'}
 754         : ${BUILD_OBJEXT:='o'}
 755 fi
 756
 757 AC_SUBST(BUILD_CC)
 758 AC_SUBST(BUILD_CPP)
 759 AC_SUBST(BUILD_CFLAGS)
 760 AC_SUBST(BUILD_CPPFLAGS)
 761 AC_SUBST(BUILD_LDFLAGS)
 762 AC_SUBST(BUILD_LIBS)
 763 AC_SUBST(BUILD_EXEEXT)
 764 AC_SUBST(BUILD_OBJEXT)
 765 ])dnl
 766 dnl ---------------------------------------------------------------------------
 767 dnl CF_CC_ENV_FLAGS version: 9 updated: 2018/07/29 18:03:26
 768 dnl ---------------
 769 dnl Check for user's environment-breakage by stuffing CFLAGS/CPPFLAGS content
 770 dnl into CC.  This will not help with broken scripts that wrap the compiler
 771 dnl with options, but eliminates a more common category of user confusion.
 772 dnl
 773 dnl In particular, it addresses the problem of being able to run the C
 774 dnl preprocessor in a consistent manner.
 775 dnl
 776 dnl Caveat: this also disallows blanks in the pathname for the compiler, but
 777 dnl the nuisance of having inconsistent settings for compiler and preprocessor
 778 dnl outweighs that limitation.
 779 AC_DEFUN([CF_CC_ENV_FLAGS],
 780 [
 781 # This should have been defined by AC_PROG_CC
 782 : ${CC:=cc}
 783
 784 AC_MSG_CHECKING(\$CFLAGS variable)
 785 case "x$CFLAGS" in
 786 (*-[[IUD]]*)
 787         AC_MSG_RESULT(broken)
 788         AC_MSG_WARN(your environment uses the CFLAGS variable to hold CPPFLAGS options)
 789         cf_flags="$CFLAGS"
 790         CFLAGS=
 791         for cf_arg in $cf_flags
 792         do
 793                 CF_ADD_CFLAGS($cf_arg)
 794         done
 795         ;;
 796 (*)
 797         AC_MSG_RESULT(ok)
 798         ;;
 799 esac
 800
 801 AC_MSG_CHECKING(\$CC variable)
 802 case "$CC" in
 803 (*[[\ \ ]]-*)
 804         AC_MSG_RESULT(broken)
 805         AC_MSG_WARN(your environment uses the CC variable to hold CFLAGS/CPPFLAGS options)
 806         # humor him...
 807         cf_prog=`echo "$CC" | sed -e 's/        / /g' -e 's/[[ ]]* / /g' -e 's/[[ ]]*[[ ]]-[[^ ]].*//'`
 808         cf_flags=`echo "$CC" | ${AWK:-awk} -v prog="$cf_prog" '{ printf("%s", [substr]([$]0,1+length(prog))); }'`
 809         CC="$cf_prog"
 810         for cf_arg in $cf_flags
 811         do
 812                 case "x$cf_arg" in
 813                 (x-[[IUDfgOW]]*)
 814                         CF_ADD_CFLAGS($cf_arg)
 815                         ;;
 816                 (*)
 817                         CC="$CC $cf_arg"
 818                         ;;
 819                 esac
 820         done
 821         CF_VERBOSE(resulting CC: '$CC')
 822         CF_VERBOSE(resulting CFLAGS: '$CFLAGS')
 823         CF_VERBOSE(resulting CPPFLAGS: '$CPPFLAGS')
 824         ;;
 825 (*)
 826         AC_MSG_RESULT(ok)
 827         ;;
 828 esac
 829 ])dnl
 830 dnl ---------------------------------------------------------------------------
 831 dnl CF_CFG_DEFAULTS version: 11 updated: 2015/04/17 21:13:04
 832 dnl ---------------
 833 dnl Determine the default configuration into which we'll install ncurses.  This
 834 dnl can be overridden by the user's command-line options.  There's two items to
 835 dnl look for:
 836 dnl     1. the prefix (e.g., /usr)
 837 dnl     2. the header files (e.g., /usr/include/ncurses)
 838 dnl We'll look for a previous installation of ncurses and use the same defaults.
 839 dnl
 840 dnl We don't use AC_PREFIX_DEFAULT, because it gets evaluated too soon, and
 841 dnl we don't use AC_PREFIX_PROGRAM, because we cannot distinguish ncurses's
 842 dnl programs from a vendor's.
 843 AC_DEFUN([CF_CFG_DEFAULTS],
 844 [
 845 AC_MSG_CHECKING(for prefix)
 846 if test "x$prefix" = "xNONE" ; then
 847         case "$cf_cv_system_name" in
 848                 # non-vendor systems don't have a conflict
 849         (openbsd*|freebsd*|mirbsd*|linux*|cygwin*|msys*|k*bsd*-gnu|mingw*)
 850                 prefix=/usr
 851                 ;;
 852         (*)     prefix=$ac_default_prefix
 853                 ;;
 854         esac
 855 fi
 856 AC_MSG_RESULT($prefix)
 857
 858 if test "x$prefix" = "xNONE" ; then
 859 AC_MSG_CHECKING(for default include-directory)
 860 test -n "$verbose" && echo 1>&AC_FD_MSG
 861 for cf_symbol in \
 862         $includedir \
 863         $includedir/ncurses \
 864         $prefix/include \
 865         $prefix/include/ncurses \
 866         /usr/local/include \
 867         /usr/local/include/ncurses \
 868         /usr/include \
 869         /usr/include/ncurses
 870 do
 871         cf_dir=`eval echo $cf_symbol`
 872         if test -f $cf_dir/curses.h ; then
 873         if ( fgrep NCURSES_VERSION $cf_dir/curses.h 2>&1 >/dev/null ) ; then
 874                 includedir="$cf_symbol"
 875                 test -n "$verbose"  && echo $ac_n "     found " 1>&AC_FD_MSG
 876                 break
 877         fi
 878         fi
 879         test -n "$verbose"  && echo "   tested $cf_dir" 1>&AC_FD_MSG
 880 done
 881 AC_MSG_RESULT($includedir)
 882 fi
 883 ])dnl
 884 dnl ---------------------------------------------------------------------------
 885 dnl CF_CGETENT version: 6 updated: 2017/01/21 11:06:25
 886 dnl ----------
 887 dnl Check if the terminal-capability database functions are available.  If not,
 888 dnl ncurses has a much-reduced version.
 889 AC_DEFUN([CF_CGETENT],[
 890 AC_CACHE_CHECK(for terminal-capability database functions,cf_cv_cgetent,[
 891 AC_TRY_LINK([
 892 #include <stdlib.h>],[
 893         char temp[128];
 894         char *buf = temp;
 895         char *db_array = temp;
 896         cgetent(&buf, &db_array, "vt100");
 897         cgetcap(buf, "tc", '=');
 898         cgetmatch(buf, "tc");
 899         ],
 900         [cf_cv_cgetent=yes],
 901         [cf_cv_cgetent=no])
 902 ])
 903
 904 if test "$cf_cv_cgetent" = yes
 905 then
 906         AC_DEFINE(HAVE_BSD_CGETENT,1,[Define to 1 if we have BSD cgetent])
 907 AC_CACHE_CHECK(if cgetent uses const parameter,cf_cv_cgetent_const,[
 908 AC_TRY_LINK([
 909 #pragma GCC diagnostic error "-Wincompatible-pointer-types-discards-qualifiers"
 910 #include <stdlib.h>],[
 911         char temp[128];
 912         char *buf = temp;
 913 #ifndef _NETBSD_SOURCE                  /* given, since April 2004 in stdlib.h */
 914         const char *db_array = temp;
 915         cgetent(&buf, &db_array, "vt100");
 916 #endif
 917         cgetcap(buf, "tc", '=');
 918         cgetmatch(buf, "tc");
 919         ],
 920         [cf_cv_cgetent_const=yes],
 921         [cf_cv_cgetent_const=no])
 922 ])
 923         if test "$cf_cv_cgetent_const" = yes
 924         then
 925                 AC_DEFINE_UNQUOTED(CGETENT_CONST,const,[Define to const if needed for some BSD cgetent variations])
 926         fi
 927 fi
 928 ])dnl
 929 dnl ---------------------------------------------------------------------------
 930 dnl CF_CHECK_CACHE version: 12 updated: 2012/10/02 20:55:03
 931 dnl --------------
 932 dnl Check if we're accidentally using a cache from a different machine.
 933 dnl Derive the system name, as a check for reusing the autoconf cache.
 934 dnl
 935 dnl If we've packaged config.guess and config.sub, run that (since it does a
 936 dnl better job than uname).  Normally we'll use AC_CANONICAL_HOST, but allow
 937 dnl an extra parameter that we may override, e.g., for AC_CANONICAL_SYSTEM
 938 dnl which is useful in cross-compiles.
 939 dnl
 940 dnl Note: we would use $ac_config_sub, but that is one of the places where
 941 dnl autoconf 2.5x broke compatibility with autoconf 2.13
 942 AC_DEFUN([CF_CHECK_CACHE],
 943 [
 944 if test -f $srcdir/config.guess || test -f $ac_aux_dir/config.guess ; then
 945         ifelse([$1],,[AC_CANONICAL_HOST],[$1])
 946         system_name="$host_os"
 947 else
 948         system_name="`(uname -s -r) 2>/dev/null`"
 949         if test -z "$system_name" ; then
 950                 system_name="`(hostname) 2>/dev/null`"
 951         fi
 952 fi
 953 test -n "$system_name" && AC_DEFINE_UNQUOTED(SYSTEM_NAME,"$system_name",[Define to the system name.])
 954 AC_CACHE_VAL(cf_cv_system_name,[cf_cv_system_name="$system_name"])
 955
 956 test -z "$system_name" && system_name="$cf_cv_system_name"
 957 test -n "$cf_cv_system_name" && AC_MSG_RESULT(Configuring for $cf_cv_system_name)
 958
 959 if test ".$system_name" != ".$cf_cv_system_name" ; then
 960         AC_MSG_RESULT(Cached system name ($system_name) does not agree with actual ($cf_cv_system_name))
 961         AC_MSG_ERROR("Please remove config.cache and try again.")
 962 fi
 963 ])dnl
 964 dnl ---------------------------------------------------------------------------
 965 dnl CF_CHECK_ENVIRON version: 3 updated: 2010/05/26 16:44:57
 966 dnl ----------------
 967 dnl Check for data that is usually declared in <unistd.h>, e.g., the 'environ'
 968 dnl variable.  Define a DECL_xxx symbol if we must declare it ourselves.
 969 dnl
 970 dnl $1 = the name to check
 971 dnl $2 = the assumed type
 972 AC_DEFUN([CF_CHECK_ENVIRON],
 973 [
 974 AC_CACHE_CHECK(if external $1 is declared, cf_cv_dcl_$1,[
 975     AC_TRY_COMPILE([
 976 #ifdef HAVE_STDLIB_H
 977 #include <stdlib.h>
 978 #endif
 979 #include <unistd.h> ],
 980     ifelse([$2],,int,[$2]) x = (ifelse([$2],,int,[$2])) $1,
 981     [cf_cv_dcl_$1=yes],
 982     [cf_cv_dcl_$1=no])
 983 ])
 984
 985 if test "$cf_cv_dcl_$1" = no ; then
 986     CF_UPPER(cf_result,decl_$1)
 987     AC_DEFINE_UNQUOTED($cf_result)
 988 fi
 989
 990 # It's possible (for near-UNIX clones) that the data doesn't exist
 991 CF_CHECK_EXTERN_DATA($1,ifelse([$2],,int,[$2]))
 992 ])dnl
 993 dnl ---------------------------------------------------------------------------
 994 dnl CF_CHECK_ERRNO version: 13 updated: 2020/03/10 18:53:47
 995 dnl --------------
 996 dnl Check for data that is usually declared in <stdio.h> or <errno.h>, e.g.,
 997 dnl the 'errno' variable.  Define a DECL_xxx symbol if we must declare it
 998 dnl ourselves.
 999 dnl
1000 dnl $1 = the name to check
1001 dnl $2 = the assumed type
1002 AC_DEFUN([CF_CHECK_ERRNO],
1003 [
1004 AC_CACHE_CHECK(if external $1 is declared, cf_cv_dcl_$1,[
1005         AC_TRY_COMPILE([
1006 #ifdef HAVE_STDLIB_H
1007 #include <stdlib.h>
1008 #endif
1009 #include <stdio.h>
1010 #include <sys/types.h>
1011 #include <errno.h> ],
1012         ifelse([$2],,int,[$2]) x = (ifelse([$2],,int,[$2])) $1; (void)x,
1013         [cf_cv_dcl_$1=yes],
1014         [cf_cv_dcl_$1=no])
1015 ])
1016
1017 if test "$cf_cv_dcl_$1" = no ; then
1018         CF_UPPER(cf_result,decl_$1)
1019         AC_DEFINE_UNQUOTED($cf_result)
1020 fi
1021
1022 # It's possible (for near-UNIX clones) that the data doesn't exist
1023 CF_CHECK_EXTERN_DATA($1,ifelse([$2],,int,[$2]))
1024 ])dnl
1025 dnl ---------------------------------------------------------------------------
1026 dnl CF_CHECK_EXTERN_DATA version: 4 updated: 2015/04/18 08:56:57
1027 dnl --------------------
1028 dnl Check for existence of external data in the current set of libraries.  If
1029 dnl we can modify it, it's real enough.
1030 dnl $1 = the name to check
1031 dnl $2 = its type
1032 AC_DEFUN([CF_CHECK_EXTERN_DATA],
1033 [
1034 AC_CACHE_CHECK(if external $1 exists, cf_cv_have_$1,[
1035         AC_TRY_LINK([
1036 #undef $1
1037 extern $2 $1;
1038 ],
1039         [$1 = 2],
1040         [cf_cv_have_$1=yes],
1041         [cf_cv_have_$1=no])
1042 ])
1043
1044 if test "$cf_cv_have_$1" = yes ; then
1045         CF_UPPER(cf_result,have_$1)
1046         AC_DEFINE_UNQUOTED($cf_result)
1047 fi
1048
1049 ])dnl
1050 dnl ---------------------------------------------------------------------------
1051 dnl CF_CHECK_FVISIBILITY version: 2 updated: 2020/04/04 16:16:13
1052 dnl --------------------
1053 dnl Check whether the compiler understands -fvisibility=hidden
1054 dnl
1055 dnl $1 = compiler
1056 dnl $2 = compiler-flags variable name
1057 dnl $3 = cache variable to set
1058 AC_DEFUN([CF_CHECK_FVISIBILITY],[
1059 AC_CACHE_CHECK(if $1 -fvisibility=hidden option works,$3,[
1060     cf_save_cflags="[$]$2"
1061     $2="[$]$2 -fvisibility=hidden"
1062     AC_TRY_LINK([
1063 __attribute__ ((visibility("default"))) int somefunc() {return 42;}
1064         ],[
1065         if (somefunc()) return 1;
1066 ],
1067     [$3=yes],
1068     [$3=no])
1069     $2=$cf_save_cflags
1070 ])
1071 ])dnl
1072 dnl ---------------------------------------------------------------------------
1073 dnl CF_CHECK_GETENV version: 1 updated: 2019/06/23 15:28:15
1074 dnl ---------------
1075 dnl Check if repeated getenv calls return the same pointer, e.g., it does not
1076 dnl discard the previous pointer when returning a new one.
1077 AC_DEFUN([CF_CHECK_GETENV],
1078 [
1079 AC_REQUIRE([CF_CHECK_ENVIRON])
1080 AC_CHECK_FUNC( getenv, ,, AC_MSG_ERROR(getenv not found) )
1081 AC_CHECK_FUNCS( putenv setenv strdup )
1082 AC_CACHE_CHECK(if getenv returns consistent values,cf_cv_consistent_getenv,[
1083 AC_TRY_RUN([
1084 #include <stdlib.h>
1085 #include <unistd.h>
1086 #include <stdio.h>
1087 #include <string.h>
1088 #include <sys/types.h>
1089
1090 #if defined(HAVE_ENVIRON) && defined(DECL_ENVIRON) && !defined(environ)
1091 extern char **environ;  /* POSIX, but some systems are not... */
1092 #endif
1093
1094 #if defined(HAVE_STRDUP)
1095 #define str_alloc(s) strdup(s)
1096 #else
1097 #define str_alloc(s) strcpy(malloc(strlen(s) + 1, s))
1098 #endif
1099
1100 static void set_value(const char *name, const char *value)
1101 {
1102 #if defined(HAVE_SETENV)
1103         setenv(name, value, 1);
1104 #elif defined(HAVE_PUTENV)
1105         char buffer[1024];
1106         sprintf(buffer, "%s=%s", name, value);
1107         putenv(str_alloc(buffer));
1108 #else
1109 #error neither putenv/setenv found
1110 #endif
1111 }
1112 int main(void)
1113 {
1114         int pass;
1115         size_t numenv, limit, j;
1116         char **mynames;
1117         char **myvalues;
1118         char **mypointer;
1119         char *equals;
1120         for (numenv = 0; environ[numenv]; ++numenv) ;
1121         limit = numenv + 10;
1122         mynames = (char **) calloc(limit + 1, sizeof(char *));
1123         myvalues = (char **) calloc(limit + 1, sizeof(char *));
1124         mypointer = (char **) calloc(limit + 1, sizeof(char *));
1125 #if defined(HAVE_ENVIRON)
1126         for (j = 0; environ[j]; ++j) {
1127                 mynames[j] = str_alloc(environ[j]);
1128                 equals = strchr(mynames[j], '=');
1129                 if (equals != 0) {
1130                         *equals++ = '\0';
1131                         myvalues[j] = str_alloc(equals);
1132                 } else {
1133                         myvalues[j] = str_alloc("");
1134                 }
1135         }
1136 #endif
1137         for (j = numenv; j < limit; ++j) {
1138                 char name[80];
1139                 char value[80];
1140                 size_t found;
1141                 size_t k = 0;
1142                 do {
1143                         size_t jk;
1144                         found = 0;
1145                         sprintf(name, "TERM%lu", (unsigned long) k);
1146                         for (jk = 0; jk < j; ++jk) {
1147                                 if (!strcmp(name, mynames[jk])) {
1148                                         found = 1;
1149                                         ++k;
1150                                         break;
1151                                 }
1152                         }
1153                 } while (found);
1154                 sprintf(value, "%lu:%p", (unsigned long) k, &mynames[j]);
1155                 set_value(name, value);
1156                 mynames[j] = str_alloc(name);
1157                 myvalues[j] = str_alloc(value);
1158         }
1159         for (pass = 0; pass < 3; ++pass) {
1160                 for (j = 0; j < limit; ++j) {
1161                         char *value = getenv(mynames[j]);
1162                         if (pass) {
1163                                 if (value == 0) {
1164                                         fprintf(stderr, "getenv returned null for %s\n", mynames[j]);
1165                                         ${cf_cv_main_return:-return}(1);
1166                                 } else if (value != mypointer[j]) {
1167                                         fprintf(stderr, "getenv returned different pointer for %s\n", mynames[j]);
1168                                         ${cf_cv_main_return:-return}(1);
1169                                 } else if (strcmp(value, myvalues[j])) {
1170                                         fprintf(stderr, "getenv returned different value for %s\n", mynames[j]);
1171                                         ${cf_cv_main_return:-return}(1);
1172                                 }
1173                         } else {
1174                                 size_t k;
1175                                 mypointer[j] = value;
1176                                 for (k = 0; k < j; ++k) {
1177                                         if (mypointer[j] == mypointer[k]) {
1178                                                 fprintf(stderr, "getenv returned same pointer for %s and %s\n", mynames[j], mynames[k]);
1179                                                 ${cf_cv_main_return:-return}(1);
1180                                         }
1181                                 }
1182                         }
1183                 }
1184         }
1185         ${cf_cv_main_return:-return}(0);
1186 }
1187 ],
1188 [cf_cv_consistent_getenv=yes],
1189 [cf_cv_consistent_getenv=no],
1190 [cf_cv_consistent_getenv=unknown])
1191 ])
1192
1193 if test "x$cf_cv_consistent_getenv" = xno
1194 then
1195         AC_DEFINE(HAVE_CONSISTENT_GETENV,1,[Define to 1 if getenv repeatably returns the same value for a given name])
1196 fi
1197 ])dnl
1198 dnl ---------------------------------------------------------------------------
1199 dnl CF_CHECK_GNAT_VERSION version: 3 updated: 2020/05/23 19:39:36
1200 dnl ---------------------
1201 AC_DEFUN([CF_CHECK_GNAT_VERSION],
1202 [
1203 AC_REQUIRE([CF_GNAT_VERSION])
1204 case $cf_cv_gnat_version in
1205 (3.1[[1-9]]*|3.[[2-9]]*|[[4-9]].*|[[1-9]][[0-9]].[[0-9]]*|20[[0-9]][[0-9]])
1206         cf_cv_prog_gnat_correct=yes
1207         ;;
1208 (*)
1209         AC_MSG_WARN(Unsupported GNAT version $cf_cv_gnat_version. We require 3.11 or better. Disabling Ada95 binding.)
1210         cf_cv_prog_gnat_correct=no
1211         ;;
1212 esac
1213 ])
1214 dnl ---------------------------------------------------------------------------
1215 dnl CF_CHECK_GPM_WGETCH version: 3 updated: 2017/01/21 11:06:25
1216 dnl -------------------
1217 dnl Check if GPM is already linked with curses.  If so - and if the linkage
1218 dnl is not "weak" - warn about this because it can create problems linking
1219 dnl applications with ncurses.
1220 AC_DEFUN([CF_CHECK_GPM_WGETCH],[
1221 AC_CHECK_LIB(gpm,Gpm_Wgetch,[
1222
1223 AC_CACHE_CHECK(if GPM is weakly bound to curses library, cf_cv_check_gpm_wgetch,[
1224 cf_cv_check_gpm_wgetch=unknown
1225 if test "$cross_compiling" != yes ; then
1226
1227 cat >conftest.$ac_ext <<CF_EOF
1228 #include <gpm.h>
1229 int main(void)
1230 {
1231         Gpm_Wgetch();
1232         ${cf_cv_main_return:-return}(0);
1233 }
1234 CF_EOF
1235
1236         cf_save_LIBS="$LIBS"
1237         # This only works if we can look at the symbol table.  If a shared
1238         # library is stripped for install, we cannot use that.  So we're forced
1239         # to rely on the static library, noting that some packagers may not
1240         # include it.
1241         LIBS="-static -lgpm -dynamic $LIBS"
1242         if AC_TRY_EVAL(ac_compile) ; then
1243                 if AC_TRY_EVAL(ac_link) ; then
1244                         cf_cv_check_gpm_wgetch=`nm conftest$ac_exeext | egrep '\<wgetch\>' | egrep '\<[[vVwW]]\>'`
1245                         test -n "$cf_cv_check_gpm_wgetch" && cf_cv_check_gpm_wgetch=yes
1246                         test -z "$cf_cv_check_gpm_wgetch" && cf_cv_check_gpm_wgetch=no
1247                 fi
1248         fi
1249         rm -rf conftest*
1250         LIBS="$cf_save_LIBS"
1251 fi
1252 ])
1253
1254 if test "$cf_cv_check_gpm_wgetch" != yes ; then
1255         AC_MSG_WARN(GPM library is already linked with curses - read the FAQ)
1256 fi
1257 ])])dnl
1258 dnl ---------------------------------------------------------------------------
1259 dnl CF_CHECK_LIBTOOL_VERSION version: 1 updated: 2013/04/06 18:03:09
1260 dnl ------------------------
1261 dnl Show the version of libtool
1262 dnl
1263 dnl Save the version in a cache variable - this is not entirely a good thing,
1264 dnl but the version string from libtool is very ugly, and for bug reports it
1265 dnl might be useful to have the original string.
1266 AC_DEFUN([CF_CHECK_LIBTOOL_VERSION],[
1267 if test -n "$LIBTOOL" && test "$LIBTOOL" != none
1268 then
1269         AC_MSG_CHECKING(version of $LIBTOOL)
1270         CF_LIBTOOL_VERSION
1271         AC_MSG_RESULT($cf_cv_libtool_version)
1272         if test -z "$cf_cv_libtool_version" ; then
1273                 AC_MSG_ERROR(This is not GNU libtool)
1274         fi
1275 else
1276         AC_MSG_ERROR(GNU libtool has not been found)
1277 fi
1278 ])dnl
1279 dnl ---------------------------------------------------------------------------
1280 dnl CF_CHECK_WCHAR_H version: 2 updated: 2017/01/21 11:06:25
1281 dnl ----------------
1282 dnl Check if wchar.h can be used, i.e., without defining _XOPEN_SOURCE_EXTENDED
1283 AC_DEFUN([CF_CHECK_WCHAR_H],[
1284 AC_CHECK_HEADERS( \
1285 wchar.h \
1286 wctype.h \
1287 )
1288 AC_CACHE_CHECK(if wchar.h can be used as is,cf_cv_wchar_h_okay,[
1289 AC_TRY_COMPILE(
1290 [
1291 #include <stdlib.h>
1292 #ifdef HAVE_WCHAR_H
1293 #include <wchar.h>
1294 #endif
1295 #ifdef HAVE_WCTYPE_H
1296 #include <wctype.h>
1297 #endif
1298 ],[
1299         wint_t foo = 0;
1300         int bar = iswpunct(foo)],
1301         [cf_cv_wchar_h_okay=yes],
1302         [cf_cv_wchar_h_okay=no])])
1303
1304 if test $cf_cv_wchar_h_okay = no
1305 then
1306         CF_PREDEFINE(_XOPEN_SOURCE_EXTENDED)
1307 fi
1308 ])dnl
1309 dnl ---------------------------------------------------------------------------
1310 dnl CF_CHECK_WCWIDTH_GRAPHICS version: 1 updated: 2015/12/19 17:47:56
1311 dnl -------------------------
1312 dnl Most "modern" terminal emulators are based to some degree on VT100, and
1313 dnl should support line-drawing.  Even with Unicode.  There is a problem.
1314 dnl
1315 dnl While most of the VT100 graphics characters were incorporated into Unicode,
1316 dnl all of those were combined into a page of useful graphics characters.
1317 dnl
1318 dnl So far, so good.
1319 dnl
1320 dnl However, while they are useful, there are other considerations.  CJK
1321 dnl is (because of poor device resolution) often rendered as double-width
1322 dnl characters.  So... for these generally-useful characters, what should
1323 dnl be the width (to make them consistent with adjacent characters)?
1324 dnl
1325 dnl The obvious choice would have been to make this locale-dependent, and use
1326 dnl wcwidth() to tell applications what the actual width is.  That was too
1327 dnl obvious.  Instead, we have a slew of "ambiguous-width" characters.
1328 dnl See for example
1329 dnl             http://www.unicode.org/reports/tr11/tr11-29.html
1330 dnl             http://www.cl.cam.ac.uk/~mgk25/ucs/scw-proposal.html
1331 dnl
1332 dnl The EastAsianWidth-6.2.0.txt file from the Unicode organization lists
1333 dnl more than 22,000 characters, with 1281 of those as ambiguous-width.  For
1334 dnl instance, it lists half (44/96) of the Latin-1 characters as
1335 dnl ambiguous-width.  Also, all of the box-characters at 0x2500 are ambiguous.
1336 dnl
1337 dnl What this means for the implementor is that on some systems wcwidth() can
1338 dnl give bad advice.  On Solaris, some of the ambiguous widths are returned as
1339 dnl 1 (the Latin-1 characters), while others are returned as 2 (line-drawing
1340 dnl characters).  These do not necessarily match the behavior of the terminal
1341 dnl emulator.  xterm, for instance, does an optional startup check to find if
1342 dnl this problem (or similar) exists with the system's locale tables, rejecting
1343 dnl them if they are too unreliable.
1344 AC_DEFUN([CF_CHECK_WCWIDTH_GRAPHICS],[
1345 AC_CACHE_CHECK(if wcwidth agrees graphics are single-width, cf_cv_wcwidth_graphics,[
1346 cat >conftest.in <<CF_EOF
1347 -       VT100 symbols
1348 0x250c  upper left corner
1349 0x2514  lower left corner
1350 0x2510  upper right corner
1351 0x2518  lower right corner
1352 0x251c  tee pointing left
1353 0x2524  tee pointing right
1354 0x2534  tee pointing up
1355 0x252c  tee pointing down
1356 0x2500  horizontal line
1357 0x2502  vertical line
1358 0x253c  large plus or crossover
1359 0x23ba  scan line 1
1360 0x23bd  scan line 9
1361 0x25c6  diamond
1362 0x2592  checker board (stipple)
1363 0x00b0  degree symbol
1364 0x00b1  plus/minus
1365 0x00b7  bullet
1366 -       Teletype 5410v1 symbols
1367 0x2190  arrow pointing left
1368 0x2192  arrow pointing right
1369 0x2193  arrow pointing down
1370 0x2191  arrow pointing up
1371 0x2592  board of squares
1372 0x2603  lantern symbol
1373 0x25ae  solid square block
1374 -       these defaults were invented for ncurses
1375 0x23bb  scan line 3
1376 0x23bc  scan line 7
1377 0x2264  less-than-or-equal-to
1378 0x2265  greater-than-or-equal-to
1379 0x03c0  greek pi
1380 0x2260  not-equal
1381 0x00a3  pound-sterling symbol
1382 -       thick-line-drawing
1383 0x250f  upper left corner
1384 0x2517  lower left corner
1385 0x2513  upper right corner
1386 0x251b  lower right corner
1387 0x2523  tee pointing left
1388 0x252b  tee pointing right
1389 0x253b  tee pointing up
1390 0x2533  tee pointing down
1391 0x2501  horizontal line
1392 0x2503  vertical line
1393 0x254b  large plus or crossover
1394 -       double-line-drawing
1395 0x2554  upper left corner
1396 0x255a  lower left corner
1397 0x2557  upper right corner
1398 0x255d  lower right corner
1399 0x2563  tee pointing left
1400 0x2560  tee pointing right
1401 0x2569  tee pointing up
1402 0x2566  tee pointing down
1403 0x2550  horizontal line
1404 0x2551  vertical line
1405 0x256c  large plus or crossover
1406 CF_EOF
1407 AC_TRY_RUN([
1408 #include <locale.h>
1409 #include <stdio.h>
1410 #include <wchar.h>
1411
1412 #define MY_LEN 80
1413
1414 int
1415 main(void)
1416 {
1417         FILE *fp;
1418         int value;
1419         char buffer[MY_LEN + 1];
1420         char notes[MY_LEN + 1];
1421         int totals = 0;
1422         int passed = 0;
1423
1424         if (setlocale(LC_ALL, "en_US.UTF8") ||
1425                 setlocale(LC_ALL, "en_US.UTF-8") ||
1426                 setlocale(LC_ALL, "en_US.utf8") ||
1427                 setlocale(LC_ALL, "en_US.utf-8")) {
1428                 if ((fp = fopen("conftest.in", "r")) != 0) {
1429                         while (fgets(buffer, MY_LEN, fp) != 0) {
1430                                 if (*buffer == '-') {
1431                                         fprintf(stderr, "\t%s", buffer);
1432                                 } else if (sscanf(buffer, "%x %s", &value, notes) == 2) {
1433                                         ++totals;
1434                                         if (wcwidth(value) == 1)
1435                                                 ++passed;
1436                                         fprintf(stderr, "%d\t%s", wcwidth(value), buffer);
1437                                 } else {
1438                                         fprintf(stderr, "?\t%s", buffer);
1439                                 }
1440                         }
1441                 }
1442         }
1443         fprintf(stderr, "%d/%d passed wcwidth/graphics check\n", passed, totals);
1444         return (totals == passed) ? 0 : 1;
1445 }
1446 ],
1447 [cf_cv_wcwidth_graphics=yes],
1448 [cf_cv_wcwidth_graphics=no],
1449 [cf_cv_wcwidth_graphics=unknown])
1450 ])
1451 ])dnl
1452 dnl ---------------------------------------------------------------------------
1453 dnl CF_CLANG_COMPILER version: 3 updated: 2020/08/28 04:10:22
1454 dnl -----------------
1455 dnl Check if the given compiler is really clang.  clang's C driver defines
1456 dnl __GNUC__ (fooling the configure script into setting $GCC to yes) but does
1457 dnl not ignore some gcc options.
1458 dnl
1459 dnl This macro should be run "soon" after AC_PROG_CC or AC_PROG_CPLUSPLUS, to
1460 dnl ensure that it is not mistaken for gcc/g++.  It is normally invoked from
1461 dnl the wrappers for gcc and g++ warnings.
1462 dnl
1463 dnl $1 = GCC (default) or GXX
1464 dnl $2 = CLANG_COMPILER (default)
1465 dnl $3 = CFLAGS (default) or CXXFLAGS
1466 AC_DEFUN([CF_CLANG_COMPILER],[
1467 ifelse([$2],,CLANG_COMPILER,[$2])=no
1468
1469 if test "$ifelse([$1],,[$1],GCC)" = yes ; then
1470         AC_MSG_CHECKING(if this is really Clang ifelse([$1],GXX,C++,C) compiler)
1471         cf_save_CFLAGS="$ifelse([$3],,CFLAGS,[$3])"
1472         ifelse([$3],,CFLAGS,[$3])="$ifelse([$3],,CFLAGS,[$3]) -Qunused-arguments"
1473         AC_TRY_COMPILE([],[
1474 #ifdef __clang__
1475 #else
1476 make an error
1477 #endif
1478 ],[ifelse([$2],,CLANG_COMPILER,[$2])=yes
1479 cf_save_CFLAGS="$cf_save_CFLAGS -Qunused-arguments"
1480 ],[])
1481         ifelse([$3],,CFLAGS,[$3])="$cf_save_CFLAGS"
1482         AC_MSG_RESULT($ifelse([$2],,CLANG_COMPILER,[$2]))
1483 fi
1484
1485 if test "x$CLANG_COMPILER" = "xyes" ; then
1486         CF_APPEND_TEXT(CFLAGS,-Wno-error=implicit-function-declaration)
1487 fi
1488 ])
1489 dnl ---------------------------------------------------------------------------
1490 dnl CF_CONST_X_STRING version: 4 updated: 2020/03/10 18:53:47
1491 dnl -----------------
1492 dnl The X11R4-X11R6 Xt specification uses an ambiguous String type for most
1493 dnl character-strings.
1494 dnl
1495 dnl It is ambiguous because the specification accommodated the pre-ANSI
1496 dnl compilers bundled by more than one vendor in lieu of providing a standard C
1497 dnl compiler other than by costly add-ons.  Because of this, the specification
1498 dnl did not take into account the use of const for telling the compiler that
1499 dnl string literals would be in readonly memory.
1500 dnl
1501 dnl As a workaround, one could (starting with X11R5) define XTSTRINGDEFINES, to
1502 dnl let the compiler decide how to represent Xt's strings which were #define'd.
1503 dnl That does not solve the problem of using the block of Xt's strings which
1504 dnl are compiled into the library (and is less efficient than one might want).
1505 dnl
1506 dnl Xt specification 7 introduces the _CONST_X_STRING symbol which is used both
1507 dnl when compiling the library and compiling using the library, to tell the
1508 dnl compiler that String is const.
1509 AC_DEFUN([CF_CONST_X_STRING],
1510 [
1511 AC_REQUIRE([AC_PATH_XTRA])
1512
1513 CF_SAVE_XTRA_FLAGS([CF_CONST_X_STRING])
1514
1515 AC_TRY_COMPILE(
1516 [
1517 #include <stdlib.h>
1518 #include <X11/Intrinsic.h>
1519 ],
1520 [String foo = malloc(1); (void)foo],[
1521
1522 AC_CACHE_CHECK(for X11/Xt const-feature,cf_cv_const_x_string,[
1523         AC_TRY_COMPILE(
1524                 [
1525 #define _CONST_X_STRING /* X11R7.8 (perhaps) */
1526 #undef  XTSTRINGDEFINES /* X11R5 and later */
1527 #include <stdlib.h>
1528 #include <X11/Intrinsic.h>
1529                 ],[String foo = malloc(1); *foo = 0],[
1530                         cf_cv_const_x_string=no
1531                 ],[
1532                         cf_cv_const_x_string=yes
1533                 ])
1534 ])
1535
1536 CF_RESTORE_XTRA_FLAGS([CF_CONST_X_STRING])
1537
1538 case $cf_cv_const_x_string in
1539 (no)
1540         CF_APPEND_TEXT(CPPFLAGS,-DXTSTRINGDEFINES)
1541         ;;
1542 (*)
1543         CF_APPEND_TEXT(CPPFLAGS,-D_CONST_X_STRING)
1544         ;;
1545 esac
1546
1547 ])
1548 ])dnl
1549 dnl ---------------------------------------------------------------------------
1550 dnl CF_CPP_PARAM_INIT version: 7 updated: 2017/01/21 11:06:25
1551 dnl -----------------
1552 dnl Check if the C++ compiler accepts duplicate parameter initialization.  This
1553 dnl is a late feature for the standard and is not in some recent compilers
1554 dnl (1999/9/11).
1555 AC_DEFUN([CF_CPP_PARAM_INIT],
1556 [
1557 if test -n "$CXX"; then
1558 AC_CACHE_CHECK(if $CXX accepts parameter initialization,cf_cv_cpp_param_init,[
1559         AC_LANG_SAVE
1560         AC_LANG_CPLUSPLUS
1561         AC_TRY_RUN([
1562 class TEST {
1563 private:
1564         int value;
1565 public:
1566         TEST(int x = 1);
1567         ~TEST();
1568 };
1569
1570 TEST::TEST(int x = 1)   // some compilers do not like second initializer
1571 {
1572         value = x;
1573 }
1574 int main(void) { }
1575 ],
1576         [cf_cv_cpp_param_init=yes],
1577         [cf_cv_cpp_param_init=no],
1578         [cf_cv_cpp_param_init=unknown])
1579         AC_LANG_RESTORE
1580 ])
1581 fi
1582 test "$cf_cv_cpp_param_init" = yes && AC_DEFINE(CPP_HAS_PARAM_INIT,1,[Define to 1 if C++ has parameter initialization])
1583 ])dnl
1584 dnl ---------------------------------------------------------------------------
1585 dnl CF_CPP_STATIC_CAST version: 3 updated: 2013/04/13 18:03:21
1586 dnl ------------------
1587 dnl Check if the C++ compiler accepts static_cast in generics.  This appears to
1588 dnl not be supported in g++ before 3.0
1589 AC_DEFUN([CF_CPP_STATIC_CAST],
1590 [
1591 if test -n "$CXX"; then
1592
1593 AC_CACHE_CHECK(if $CXX accepts static_cast,cf_cv_cpp_static_cast,[
1594         AC_LANG_SAVE
1595         AC_LANG_CPLUSPLUS
1596
1597         AC_TRY_COMPILE([
1598 class NCursesPanel
1599 {
1600 public:
1601   NCursesPanel(int nlines,
1602                int ncols,
1603                int begin_y = 0,
1604                int begin_x = 0)
1605   {
1606   }
1607   NCursesPanel();
1608   ~NCursesPanel();
1609 };
1610
1611 template<class T> class NCursesUserPanel : public NCursesPanel
1612 {
1613 public:
1614   NCursesUserPanel (int nlines,
1615                     int ncols,
1616                     int begin_y = 0,
1617                     int begin_x = 0,
1618                     const T* p_UserData = static_cast<T*>(0))
1619     : NCursesPanel (nlines, ncols, begin_y, begin_x)
1620   {
1621   };
1622   NCursesUserPanel(const T* p_UserData = static_cast<T*>(0)) : NCursesPanel()
1623   {
1624   };
1625
1626   virtual ~NCursesUserPanel() {};
1627 };
1628 ],[
1629         const char* p_UserData = static_cast<char*>(0)],
1630         [cf_cv_cpp_static_cast=yes],
1631         [cf_cv_cpp_static_cast=no])
1632
1633         AC_LANG_RESTORE
1634 ])
1635
1636 fi
1637
1638 test "$cf_cv_cpp_static_cast" = yes && AC_DEFINE(CPP_HAS_STATIC_CAST,1,[Define to 1 if C++ has static_cast])
1639 ])dnl
1640 dnl ---------------------------------------------------------------------------
1641 dnl CF_CXX_AR_FLAGS version: 2 updated: 2015/04/17 21:13:04
1642 dnl ---------------
1643 dnl Setup special archiver flags for given compilers.
1644 AC_DEFUN([CF_CXX_AR_FLAGS],[
1645         CXX_AR='$(AR)'
1646         CXX_ARFLAGS='$(ARFLAGS)'
1647         case $cf_cv_system_name in
1648         (irix*)
1649             if test "$GXX" != yes ; then
1650                 CXX_AR='$(CXX)'
1651                 CXX_ARFLAGS='-ar -o'
1652             fi
1653             ;;
1654         (sco3.2v5*)
1655             CXXLDFLAGS="-u main"
1656             ;;
1657         (solaris2*)
1658             if test "$GXX" != yes ; then
1659                 CXX_AR='$(CXX)'
1660                 CXX_ARFLAGS='-xar -o'
1661             fi
1662             ;;
1663         esac
1664         AC_SUBST(CXXLDFLAGS)
1665         AC_SUBST(CXX_AR)
1666         AC_SUBST(CXX_ARFLAGS)
1667 ])dnl
1668 dnl ---------------------------------------------------------------------------
1669 dnl CF_CXX_IOSTREAM_NAMESPACE version: 2 updated: 2012/10/06 17:56:13
1670 dnl -------------------------
1671 dnl For c++, check if iostream uses "std::" namespace.
1672 AC_DEFUN([CF_CXX_IOSTREAM_NAMESPACE],[
1673 AC_CHECK_HEADERS(iostream)
1674 if test x"$ac_cv_header_iostream" = xyes ; then
1675         AC_MSG_CHECKING(if iostream uses std-namespace)
1676         AC_TRY_COMPILE([
1677 #include <iostream>
1678 using std::endl;
1679 using std::cerr;],[
1680 cerr << "testing" << endl;
1681 ],[cf_iostream_namespace=yes],[cf_iostream_namespace=no])
1682         AC_MSG_RESULT($cf_iostream_namespace)
1683         if test "$cf_iostream_namespace" = yes ; then
1684                 AC_DEFINE(IOSTREAM_NAMESPACE,1,[Define to 1 if C++ has namespace iostream])
1685         fi
1686 fi
1687 ])dnl
1688 dnl ---------------------------------------------------------------------------
1689 dnl CF_C_INLINE version: 6 updated: 2019/09/07 13:38:36
1690 dnl -----------
1691 dnl Check if the C compiler supports "inline".
1692 dnl $1 is the name of a shell variable to set if inline is supported
1693 dnl $2 is the threshold for gcc 4.x's option controlling maximum inline size
1694 AC_DEFUN([CF_C_INLINE],[
1695 AC_REQUIRE([CF_GCC_VERSION])
1696 AC_C_INLINE
1697 $1=
1698 if test "$ac_cv_c_inline" != no ; then
1699         $1=inline
1700         if test "$INTEL_COMPILER" = yes
1701         then
1702                 :
1703         elif test "$CLANG_COMPILER" = yes
1704         then
1705                 :
1706         elif test "$GCC" = yes
1707         then
1708                 AC_CACHE_CHECK(if $CC supports options to tune inlining,cf_cv_gcc_inline,[
1709                 cf_save_CFLAGS=$CFLAGS
1710                 CFLAGS="$CFLAGS --param max-inline-insns-single=$2"
1711                 AC_TRY_COMPILE([inline int foo(void) { return 1; }],
1712                 [${cf_cv_main_return:-return} foo()],
1713                 [cf_cv_gcc_inline=yes],
1714                 [cf_cv_gcc_inline=no])
1715                 CFLAGS=$cf_save_CFLAGS
1716                 ])
1717                 if test "$cf_cv_gcc_inline" = yes ; then
1718                         CF_ADD_CFLAGS([--param max-inline-insns-single=$2])
1719                 fi
1720         fi
1721 fi
1722 AC_SUBST($1)
1723 ])dnl
1724 dnl ---------------------------------------------------------------------------
1725 dnl CF_DIRNAME version: 4 updated: 2002/12/21 19:25:52
1726 dnl ----------
1727 dnl "dirname" is not portable, so we fake it with a shell script.
1728 AC_DEFUN([CF_DIRNAME],[$1=`echo $2 | sed -e 's%/[[^/]]*$%%'`])dnl
1729 dnl ---------------------------------------------------------------------------
1730 dnl CF_DIRS_TO_MAKE version: 3 updated: 2002/02/23 20:38:31
1731 dnl ---------------
1732 AC_DEFUN([CF_DIRS_TO_MAKE],
1733 [
1734 DIRS_TO_MAKE="lib"
1735 for cf_item in $cf_list_models
1736 do
1737         CF_OBJ_SUBDIR($cf_item,cf_subdir)
1738         for cf_item2 in $DIRS_TO_MAKE
1739         do
1740                 test $cf_item2 = $cf_subdir && break
1741         done
1742         test ".$cf_item2" != ".$cf_subdir" && DIRS_TO_MAKE="$DIRS_TO_MAKE $cf_subdir"
1743 done
1744 for cf_dir in $DIRS_TO_MAKE
1745 do
1746         test ! -d $cf_dir && mkdir $cf_dir
1747 done
1748 AC_SUBST(DIRS_TO_MAKE)
1749 ])dnl
1750 dnl ---------------------------------------------------------------------------
1751 dnl CF_DISABLE_ECHO version: 13 updated: 2015/04/18 08:56:57
1752 dnl ---------------
1753 dnl You can always use "make -n" to see the actual options, but it's hard to
1754 dnl pick out/analyze warning messages when the compile-line is long.
1755 dnl
1756 dnl Sets:
1757 dnl     ECHO_LT - symbol to control if libtool is verbose
1758 dnl     ECHO_LD - symbol to prefix "cc -o" lines
1759 dnl     RULE_CC - symbol to put before implicit "cc -c" lines (e.g., .c.o)
1760 dnl     SHOW_CC - symbol to put before explicit "cc -c" lines
1761 dnl     ECHO_CC - symbol to put before any "cc" line
1762 dnl
1763 AC_DEFUN([CF_DISABLE_ECHO],[
1764 AC_MSG_CHECKING(if you want to see long compiling messages)
1765 CF_ARG_DISABLE(echo,
1766         [  --disable-echo          do not display "compiling" commands],
1767         [
1768         ECHO_LT='--silent'
1769         ECHO_LD='@echo linking [$]@;'
1770         RULE_CC='@echo compiling [$]<'
1771         SHOW_CC='@echo compiling [$]@'
1772         ECHO_CC='@'
1773 ],[
1774         ECHO_LT=''
1775         ECHO_LD=''
1776         RULE_CC=''
1777         SHOW_CC=''
1778         ECHO_CC=''
1779 ])
1780 AC_MSG_RESULT($enableval)
1781 AC_SUBST(ECHO_LT)
1782 AC_SUBST(ECHO_LD)
1783 AC_SUBST(RULE_CC)
1784 AC_SUBST(SHOW_CC)
1785 AC_SUBST(ECHO_CC)
1786 ])dnl
1787 dnl ---------------------------------------------------------------------------
1788 dnl CF_DISABLE_GNAT_PROJECTS version: 1 updated: 2014/06/01 11:34:00
1789 dnl ------------------------
1790 AC_DEFUN([CF_DISABLE_GNAT_PROJECTS],[
1791 AC_MSG_CHECKING(if we want to use GNAT projects)
1792 CF_ARG_DISABLE(gnat-projects,
1793         [  --disable-gnat-projects test: disable GNAT projects even if usable],
1794         [enable_gnat_projects=no],
1795         [enable_gnat_projects=yes])
1796 AC_MSG_RESULT($enable_gnat_projects)
1797 ])dnl
1798 dnl ---------------------------------------------------------------------------
1799 dnl CF_DISABLE_LEAKS version: 7 updated: 2012/10/02 20:55:03
1800 dnl ----------------
1801 dnl Combine no-leak checks with the libraries or tools that are used for the
1802 dnl checks.
1803 AC_DEFUN([CF_DISABLE_LEAKS],[
1804
1805 AC_REQUIRE([CF_WITH_DMALLOC])
1806 AC_REQUIRE([CF_WITH_DBMALLOC])
1807 AC_REQUIRE([CF_WITH_VALGRIND])
1808
1809 AC_MSG_CHECKING(if you want to perform memory-leak testing)
1810 AC_ARG_ENABLE(leaks,
1811         [  --disable-leaks         test: free permanent memory, analyze leaks],
1812         [if test "x$enableval" = xno; then with_no_leaks=yes; else with_no_leaks=no; fi],
1813         : ${with_no_leaks:=no})
1814 AC_MSG_RESULT($with_no_leaks)
1815
1816 if test "$with_no_leaks" = yes ; then
1817         AC_DEFINE(NO_LEAKS,1,[Define to 1 if you want to perform memory-leak testing.])
1818         AC_DEFINE(YY_NO_LEAKS,1,[Define to 1 if you want to perform memory-leak testing.])
1819 fi
1820 ])dnl
1821 dnl ---------------------------------------------------------------------------
1822 dnl CF_DISABLE_LIBTOOL_VERSION version: 3 updated: 2015/04/17 21:13:04
1823 dnl --------------------------
1824 dnl Check if we should use the libtool 1.5 feature "-version-number" instead of
1825 dnl the older "-version-info" feature.  The newer feature allows us to use
1826 dnl version numbering on shared libraries which make them compatible with
1827 dnl various systems.
1828 AC_DEFUN([CF_DISABLE_LIBTOOL_VERSION],
1829 [
1830 AC_MSG_CHECKING(if libtool -version-number should be used)
1831 CF_ARG_DISABLE(libtool-version,
1832         [  --disable-libtool-version  enable to use libtool's incompatible naming scheme],
1833         [cf_libtool_version=no],
1834         [cf_libtool_version=yes])
1835 AC_MSG_RESULT($cf_libtool_version)
1836
1837 if test "$cf_libtool_version" = yes ; then
1838         LIBTOOL_VERSION="-version-number"
1839 else
1840         LIBTOOL_VERSION="-version-info"
1841         case "x$VERSION" in
1842         (x)
1843                 AC_MSG_WARN(VERSION was not set)
1844                 ;;
1845         (x*.*.*)
1846                 ABI_VERSION="$VERSION"
1847                 CF_VERBOSE(ABI_VERSION: $ABI_VERSION)
1848                 ;;
1849         (x*:*:*)
1850                 ABI_VERSION=`echo "$VERSION" | sed -e 's/:/./g'`
1851                 CF_VERBOSE(ABI_VERSION: $ABI_VERSION)
1852                 ;;
1853         (*)
1854                 AC_MSG_WARN(unexpected VERSION value: $VERSION)
1855                 ;;
1856         esac
1857 fi
1858
1859 AC_SUBST(ABI_VERSION)
1860 AC_SUBST(LIBTOOL_VERSION)
1861 ])dnl
1862 dnl ---------------------------------------------------------------------------
1863 dnl CF_DISABLE_RPATH_HACK version: 2 updated: 2011/02/13 13:31:33
1864 dnl ---------------------
1865 dnl The rpath-hack makes it simpler to build programs, particularly with the
1866 dnl *BSD ports which may have essential libraries in unusual places.  But it
1867 dnl can interfere with building an executable for the base system.  Use this
1868 dnl option in that case.
1869 AC_DEFUN([CF_DISABLE_RPATH_HACK],
1870 [
1871 AC_MSG_CHECKING(if rpath-hack should be disabled)
1872 CF_ARG_DISABLE(rpath-hack,
1873         [  --disable-rpath-hack    don't add rpath options for additional libraries],
1874         [cf_disable_rpath_hack=yes],
1875         [cf_disable_rpath_hack=no])
1876 AC_MSG_RESULT($cf_disable_rpath_hack)
1877 if test "$cf_disable_rpath_hack" = no ; then
1878         CF_RPATH_HACK
1879 fi
1880 ])
1881 dnl ---------------------------------------------------------------------------
1882 dnl CF_ENABLE_BROKEN_LINKER version: 1 updated: 2020/02/08 15:59:30
1883 dnl -----------------------
1884 dnl Some linkers cannot reference a data-only object.  Cygwin used to be one.
1885 dnl This usually follows CF_LINK_DATAONLY, but is not required in case we need
1886 dnl an unconditional feature.
1887 AC_DEFUN([CF_ENABLE_BROKEN_LINKER],[
1888
1889 AC_MSG_CHECKING(if you want broken-linker support code)
1890 AC_ARG_ENABLE(broken_linker,
1891         [  --enable-broken_linker  compile with broken-linker support code],
1892         [with_broken_linker=$enableval],
1893         [with_broken_linker=no])
1894 AC_MSG_RESULT($with_broken_linker)
1895
1896 : ${BROKEN_LINKER:=0}
1897 if test "x$with_broken_linker" = xyes ; then
1898         AC_DEFINE(BROKEN_LINKER,1,[Define to 1 to work around linkers which cannot link data-only modules])
1899         BROKEN_LINKER=1
1900 fi
1901 AC_SUBST(BROKEN_LINKER)
1902 ])dnl
1903 dnl ---------------------------------------------------------------------------
1904 dnl CF_ENABLE_PC_FILES version: 13 updated: 2015/11/01 05:27:39
1905 dnl ------------------
1906 dnl This is the "--enable-pc-files" option, which is available if there is a
1907 dnl pkg-config configuration on the local machine.
1908 AC_DEFUN([CF_ENABLE_PC_FILES],[
1909 AC_REQUIRE([CF_PKG_CONFIG])
1910 AC_REQUIRE([CF_WITH_PKG_CONFIG_LIBDIR])
1911
1912 if test "x$PKG_CONFIG" != xnone
1913 then
1914         AC_MSG_CHECKING(if we should install .pc files for $PKG_CONFIG)
1915 else
1916         AC_MSG_CHECKING(if we should install .pc files)
1917 fi
1918
1919 AC_ARG_ENABLE(pc-files,
1920         [  --enable-pc-files       generate and install .pc files for pkg-config],
1921         [enable_pc_files=$enableval],
1922         [enable_pc_files=no])
1923 AC_MSG_RESULT($enable_pc_files)
1924
1925 if test "x$enable_pc_files" != xno
1926 then
1927         MAKE_PC_FILES=
1928         case "x$PKG_CONFIG_LIBDIR" in
1929         (xno|xyes)
1930                 AC_MSG_WARN(no PKG_CONFIG_LIBDIR was found)
1931                 ;;
1932         (*)
1933                 CF_PATH_SYNTAX(PKG_CONFIG_LIBDIR)
1934                 ;;
1935         esac
1936 else
1937         MAKE_PC_FILES="#"
1938 fi
1939 AC_SUBST(MAKE_PC_FILES)
1940 ])dnl
1941 dnl ---------------------------------------------------------------------------
1942 dnl CF_ENABLE_RPATH version: 2 updated: 2010/03/27 18:39:42
1943 dnl ---------------
1944 dnl Check if the rpath option should be used, setting cache variable
1945 dnl cf_cv_enable_rpath if so.
1946 AC_DEFUN([CF_ENABLE_RPATH],
1947 [
1948 AC_MSG_CHECKING(if rpath option should be used)
1949 AC_ARG_ENABLE(rpath,
1950 [  --enable-rpath          use rpath option when generating shared libraries],
1951 [cf_cv_enable_rpath=$enableval],
1952 [cf_cv_enable_rpath=no])
1953 AC_MSG_RESULT($cf_cv_enable_rpath)
1954 ])dnl
1955 dnl ---------------------------------------------------------------------------
1956 dnl CF_ENABLE_STRING_HACKS version: 5 updated: 2016/10/08 17:34:11
1957 dnl ----------------------
1958 dnl On a few platforms, the compiler and/or loader nags with untruthful
1959 dnl comments stating that "most" uses of strcat/strcpy/sprintf are incorrect,
1960 dnl and implying that most uses of the recommended alternatives are correct.
1961 dnl
1962 dnl Factually speaking, no one has actually counted the number of uses of these
1963 dnl functions versus the total of incorrect uses.  Samples of a few thousand
1964 dnl instances are meaningless compared to the hundreds of millions of lines of
1965 dnl existing C code.
1966 dnl
1967 dnl strlcat/strlcpy are (as of 2012) non-standard, and are available on some
1968 dnl platforms, in implementations of varying quality.  Likewise, snprintf is
1969 dnl standard - but evolved through phases, and older implementations are likely
1970 dnl to yield surprising results, as documented in manpages on various systems.
1971 AC_DEFUN([CF_ENABLE_STRING_HACKS],
1972 [
1973 AC_MSG_CHECKING(if you want to work around bogus compiler/loader warnings)
1974 AC_ARG_ENABLE(string-hacks,
1975         [  --enable-string-hacks   work around bogus compiler/loader warnings],
1976         [with_string_hacks=$enableval],
1977         [with_string_hacks=no])
1978 AC_MSG_RESULT($with_string_hacks)
1979
1980 if test "x$with_string_hacks" = "xyes"; then
1981         AC_DEFINE(USE_STRING_HACKS,1,[Define to 1 to work around bogus compiler/loader warnings])
1982         AC_MSG_WARN(enabling string-hacks to work around bogus compiler/loader warnings)
1983         AC_CHECK_FUNC(strlcat,[
1984                 AC_DEFINE(HAVE_STRLCAT,1,[Define to 1 if we have strlcat function])
1985                 ],[
1986                 AC_CHECK_LIB(bsd,strlcat,[
1987                         CF_ADD_LIB(bsd)
1988                         AC_CHECK_HEADERS(bsd/string.h)
1989                         AC_DEFINE(HAVE_STRLCAT,1,[Define to 1 if we have strlcat function])
1990                         ])
1991                 ])
1992         AC_CHECK_FUNCS( strlcpy snprintf )
1993 fi
1994 ])dnl
1995 dnl ---------------------------------------------------------------------------
1996 dnl CF_ENABLE_WARNINGS version: 7 updated: 2020/08/29 09:05:21
1997 dnl ------------------
1998 dnl Configure-option to enable gcc warnings
1999 dnl
2000 dnl $1 = extra options to add, if supported
2001 dnl $2 = option for checking attributes.  By default, this is done when
2002 dnl      warnings are enabled.  For other values:
2003 dnl      yes: always do this, e.g., to use in generated library-headers
2004 dnl      no: never do this
2005 AC_DEFUN([CF_ENABLE_WARNINGS],[
2006 if ( test "$GCC" = yes || test "$GXX" = yes )
2007 then
2008 CF_FIX_WARNINGS(CFLAGS)
2009 CF_FIX_WARNINGS(CPPFLAGS)
2010 CF_FIX_WARNINGS(LDFLAGS)
2011 AC_MSG_CHECKING(if you want to turn on gcc warnings)
2012 CF_ARG_ENABLE(warnings,
2013         [  --enable-warnings       test: turn on gcc compiler warnings],
2014         [with_warnings=yes],
2015         [with_warnings=no])
2016 AC_MSG_RESULT($with_warnings)
2017 if test "$with_warnings" = "yes"
2018 then
2019         ifelse($2,,[CF_GCC_ATTRIBUTES])
2020         CF_GCC_WARNINGS($1)
2021 fi
2022 ifelse($2,yes,[CF_GCC_ATTRIBUTES])
2023 fi
2024 ])dnl
2025 dnl ---------------------------------------------------------------------------
2026 dnl CF_ERRNO version: 5 updated: 1997/11/30 12:44:39
2027 dnl --------
2028 dnl Check if 'errno' is declared in <errno.h>
2029 AC_DEFUN([CF_ERRNO],
2030 [
2031 CF_CHECK_ERRNO(errno)
2032 ])dnl
2033 dnl ---------------------------------------------------------------------------
2034 dnl CF_ETIP_DEFINES version: 5 updated: 2012/02/18 17:51:07
2035 dnl ---------------
2036 dnl Test for conflicting definitions of exception in gcc 2.8.0, etc., between
2037 dnl math.h and builtin.h, only for ncurses
2038 AC_DEFUN([CF_ETIP_DEFINES],
2039 [
2040 AC_MSG_CHECKING(for special defines needed for etip.h)
2041 cf_save_CXXFLAGS="$CXXFLAGS"
2042 cf_result="none"
2043
2044 # etip.h includes ncurses.h which includes ncurses_dll.h
2045 # But ncurses_dll.h is generated - fix here.
2046 test -d include || mkdir include
2047 test -f include/ncurses_dll.h || sed -e 's/@NCURSES_WRAP_PREFIX@/'$NCURSES_WRAP_PREFIX'/g' ${srcdir}/include/ncurses_dll.h.in >include/ncurses_dll.h
2048
2049 for cf_math in "" MATH_H
2050 do
2051 for cf_excp in "" MATH_EXCEPTION
2052 do
2053         CXXFLAGS="$cf_save_CXXFLAGS -I${srcdir}/c++ -I${srcdir}/menu -Iinclude -I${srcdir}/include"
2054         test -n "$cf_math" && CXXFLAGS="$CXXFLAGS -DETIP_NEEDS_${cf_math}"
2055         test -n "$cf_excp" && CXXFLAGS="$CXXFLAGS -DETIP_NEEDS_${cf_excp}"
2056 AC_TRY_COMPILE([
2057 #include <etip.h.in>
2058 ],[],[
2059         test -n "$cf_math" && AC_DEFINE_UNQUOTED(ETIP_NEEDS_${cf_math})
2060         test -n "$cf_excp" && AC_DEFINE_UNQUOTED(ETIP_NEEDS_${cf_excp})
2061         cf_result="$cf_math $cf_excp"
2062         break 2
2063 ],[])
2064 done
2065 done
2066 AC_MSG_RESULT($cf_result)
2067 CXXFLAGS="$cf_save_CXXFLAGS"
2068 ])
2069 dnl ---------------------------------------------------------------------------
2070 dnl CF_FIND_LINKAGE version: 21 updated: 2018/06/20 20:23:13
2071 dnl ---------------
2072 dnl Find a library (specifically the linkage used in the code fragment),
2073 dnl searching for it if it is not already in the library path.
2074 dnl See also CF_ADD_SEARCHPATH.
2075 dnl
2076 dnl Parameters (4-on are optional):
2077 dnl     $1 = headers for library entrypoint
2078 dnl     $2 = code fragment for library entrypoint
2079 dnl     $3 = the library name without the "-l" option or ".so" suffix.
2080 dnl     $4 = action to perform if successful (default: update CPPFLAGS, etc)
2081 dnl     $5 = action to perform if not successful
2082 dnl     $6 = module name, if not the same as the library name
2083 dnl     $7 = extra libraries
2084 dnl
2085 dnl Sets these variables:
2086 dnl     $cf_cv_find_linkage_$3 - yes/no according to whether linkage is found
2087 dnl     $cf_cv_header_path_$3 - include-directory if needed
2088 dnl     $cf_cv_library_path_$3 - library-directory if needed
2089 dnl     $cf_cv_library_file_$3 - library-file if needed, e.g., -l$3
2090 AC_DEFUN([CF_FIND_LINKAGE],[
2091
2092 # If the linkage is not already in the $CPPFLAGS/$LDFLAGS configuration, these
2093 # will be set on completion of the AC_TRY_LINK below.
2094 cf_cv_header_path_$3=
2095 cf_cv_library_path_$3=
2096
2097 CF_MSG_LOG([Starting [FIND_LINKAGE]($3,$6)])
2098
2099 cf_save_LIBS="$LIBS"
2100
2101 AC_TRY_LINK([$1],[$2],[
2102         cf_cv_find_linkage_$3=yes
2103         cf_cv_header_path_$3=/usr/include
2104         cf_cv_library_path_$3=/usr/lib
2105 ],[
2106
2107 LIBS="-l$3 $7 $cf_save_LIBS"
2108
2109 AC_TRY_LINK([$1],[$2],[
2110         cf_cv_find_linkage_$3=yes
2111         cf_cv_header_path_$3=/usr/include
2112         cf_cv_library_path_$3=/usr/lib
2113         cf_cv_library_file_$3="-l$3"
2114 ],[
2115         cf_cv_find_linkage_$3=no
2116         LIBS="$cf_save_LIBS"
2117
2118         CF_VERBOSE(find linkage for $3 library)
2119         CF_MSG_LOG([Searching for headers in [FIND_LINKAGE]($3,$6)])
2120
2121         cf_save_CPPFLAGS="$CPPFLAGS"
2122         cf_test_CPPFLAGS="$CPPFLAGS"
2123
2124         CF_HEADER_PATH(cf_search,ifelse([$6],,[$3],[$6]))
2125         for cf_cv_header_path_$3 in $cf_search
2126         do
2127                 if test -d $cf_cv_header_path_$3 ; then
2128                         CF_VERBOSE(... testing $cf_cv_header_path_$3)
2129                         CPPFLAGS="$cf_save_CPPFLAGS"
2130                         CF_APPEND_TEXT(CPPFLAGS,-I$cf_cv_header_path_$3)
2131                         AC_TRY_COMPILE([$1],[$2],[
2132                                 CF_VERBOSE(... found $3 headers in $cf_cv_header_path_$3)
2133                                 cf_cv_find_linkage_$3=maybe
2134                                 cf_test_CPPFLAGS="$CPPFLAGS"
2135                                 break],[
2136                                 CPPFLAGS="$cf_save_CPPFLAGS"
2137                                 ])
2138                 fi
2139         done
2140
2141         if test "$cf_cv_find_linkage_$3" = maybe ; then
2142
2143                 CF_MSG_LOG([Searching for $3 library in [FIND_LINKAGE]($3,$6)])
2144
2145                 cf_save_LIBS="$LIBS"
2146                 cf_save_LDFLAGS="$LDFLAGS"
2147
2148                 ifelse([$6],,,[
2149                 CPPFLAGS="$cf_test_CPPFLAGS"
2150                 LIBS="-l$3 $7 $cf_save_LIBS"
2151                 AC_TRY_LINK([$1],[$2],[
2152                         CF_VERBOSE(... found $3 library in system)
2153                         cf_cv_find_linkage_$3=yes])
2154                         CPPFLAGS="$cf_save_CPPFLAGS"
2155                         LIBS="$cf_save_LIBS"
2156                         ])
2157
2158                 if test "$cf_cv_find_linkage_$3" != yes ; then
2159                         CF_LIBRARY_PATH(cf_search,$3)
2160                         for cf_cv_library_path_$3 in $cf_search
2161                         do
2162                                 if test -d $cf_cv_library_path_$3 ; then
2163                                         CF_VERBOSE(... testing $cf_cv_library_path_$3)
2164                                         CPPFLAGS="$cf_test_CPPFLAGS"
2165                                         LIBS="-l$3 $7 $cf_save_LIBS"
2166                                         LDFLAGS="$cf_save_LDFLAGS -L$cf_cv_library_path_$3"
2167                                         AC_TRY_LINK([$1],[$2],[
2168                                         CF_VERBOSE(... found $3 library in $cf_cv_library_path_$3)
2169                                         cf_cv_find_linkage_$3=yes
2170                                         cf_cv_library_file_$3="-l$3"
2171                                         break],[
2172                                         CPPFLAGS="$cf_save_CPPFLAGS"
2173                                         LIBS="$cf_save_LIBS"
2174                                         LDFLAGS="$cf_save_LDFLAGS"
2175                                         ])
2176                                 fi
2177                         done
2178                         CPPFLAGS="$cf_save_CPPFLAGS"
2179                         LDFLAGS="$cf_save_LDFLAGS"
2180                 fi
2181
2182         else
2183                 cf_cv_find_linkage_$3=no
2184         fi
2185         ],$7)
2186 ])
2187
2188 LIBS="$cf_save_LIBS"
2189
2190 if test "$cf_cv_find_linkage_$3" = yes ; then
2191 ifelse([$4],,[
2192         CF_ADD_INCDIR($cf_cv_header_path_$3)
2193         CF_ADD_LIBDIR($cf_cv_library_path_$3)
2194         CF_ADD_LIB($3)
2195 ],[$4])
2196 else
2197 ifelse([$5],,AC_MSG_WARN(Cannot find $3 library),[$5])
2198 fi
2199 ])dnl
2200 dnl ---------------------------------------------------------------------------
2201 dnl CF_FIND_SUB_INCDIR version: 2 updated: 2015/04/17 21:13:04
2202 dnl ------------------
2203 dnl Find an include-directory with the given leaf-name.  This is useful for
2204 dnl example with FreeBSD ports, which use this convention to distinguish
2205 dnl different versions of the same port.
2206 AC_DEFUN([CF_FIND_SUB_INCDIR],[
2207         CF_SUBDIR_PATH(cf_search,$1,include)
2208         for cf_item in $cf_search
2209         do
2210                 case $cf_item in
2211                 (*/$1)
2212                         CF_ADD_INCDIR($cf_item)
2213                         ;;
2214                 esac
2215         done
2216 ])dnl
2217 dnl ---------------------------------------------------------------------------
2218 dnl CF_FIND_SUB_LIBDIR version: 2 updated: 2015/04/17 21:13:04
2219 dnl ------------------
2220 dnl Find a library-directory with the given leaf-name.  This is useful for
2221 dnl example with FreeBSD ports, which use this convention to distinguish
2222 dnl different versions of the same port.
2223 AC_DEFUN([CF_FIND_SUB_LIBDIR],[
2224         CF_SUBDIR_PATH(cf_search,$1,lib)
2225         for cf_item in $cf_search
2226         do
2227                 case $cf_item in
2228                 (*/$1)
2229                         CF_ADD_LIBDIR($cf_item)
2230                         ;;
2231                 esac
2232         done
2233 ])dnl
2234 dnl ---------------------------------------------------------------------------
2235 dnl CF_FIXUP_ADAFLAGS version: 2 updated: 2015/04/17 21:13:04
2236 dnl -----------------
2237 dnl make ADAFLAGS consistent with CFLAGS
2238 AC_DEFUN([CF_FIXUP_ADAFLAGS],[
2239         AC_MSG_CHECKING(optimization options for ADAFLAGS)
2240         case "$CFLAGS" in
2241         (*-g*)
2242                 CF_ADD_ADAFLAGS(-g)
2243                 ;;
2244         esac
2245         case "$CFLAGS" in
2246         (*-O*)
2247                 cf_O_flag=`echo "$CFLAGS" |sed -e 's/^.*-O/-O/' -e 's/[[        ]].*//'`
2248                 CF_ADD_ADAFLAGS($cf_O_flag)
2249                 ;;
2250         esac
2251         AC_MSG_RESULT($ADAFLAGS)
2252 ])dnl
2253 dnl ---------------------------------------------------------------------------
2254 dnl CF_FIX_WARNINGS version: 2 updated: 2020/08/28 15:08:28
2255 dnl ---------------
2256 dnl Warning flags do not belong in CFLAGS, CPPFLAGS, etc.  Any of gcc's
2257 dnl "-Werror" flags can interfere with configure-checks.  Those go into
2258 dnl EXTRA_CFLAGS.
2259 dnl
2260 dnl $1 = variable name to repair
2261 define([CF_FIX_WARNINGS],[
2262 if ( test "$GCC" = yes || test "$GXX" = yes )
2263 then
2264         case [$]$1 in
2265         (*-Werror=*)
2266                 CF_VERBOSE(repairing $1: [$]$1)
2267                 cf_temp_flags=
2268                 for cf_temp_scan in [$]$1
2269                 do
2270                         case "x$cf_temp_scan" in
2271                         (x-Werror=*)
2272                                 CF_APPEND_TEXT(EXTRA_CFLAGS,"$cf_temp_scan")
2273                                 ;;
2274                         (*)
2275                                 CF_APPEND_TEXT(cf_temp_flags,"$cf_temp_scan")
2276                                 ;;
2277                         esac
2278                 done
2279                 $1="$cf_temp_flags"
2280                 CF_VERBOSE(... fixed [$]$1)
2281                 CF_VERBOSE(... extra $EXTRA_CFLAGS)
2282                 ;;
2283         esac
2284 fi
2285 AC_SUBST(EXTRA_CFLAGS)
2286 ])dnl
2287 dnl ---------------------------------------------------------------------------
2288 dnl CF_FOPEN_BIN_R version: 2 updated: 2019/12/31 08:53:54
2289 dnl --------------
2290 dnl Check if fopen works when the "b" (binary) flag is added to the mode
2291 dnl parameter.  POSIX ignores the "b", which c89 specified.  Some very old
2292 dnl systems do not accept it.
2293 AC_DEFUN([CF_FOPEN_BIN_R],[
2294 AC_CACHE_CHECK(if fopen accepts explicit binary mode,cf_cv_fopen_bin_r,[
2295         AC_TRY_RUN([
2296 #include <stdio.h>
2297 int main(void) {
2298         FILE *fp = fopen("conftest.tmp", "wb");
2299         int rc = 0;
2300         if (fp != 0) {
2301                 int p, q;
2302                 for (p = 0; p < 256; ++p) {
2303                         fputc(p, fp);
2304                 }
2305                 fclose(fp);
2306                 fp = fopen("conftest.tmp", "rb");
2307                 if (fp != 0) {
2308                         for (p = 0; p < 256; ++p) {
2309                                 q = fgetc(fp);
2310                                 if (q != p) {
2311                                         rc = 1;
2312                                         break;
2313                                 }
2314                         }
2315                 } else {
2316                         rc = 1;
2317                 }
2318         } else {
2319                 rc = 1;
2320         }
2321         ${cf_cv_main_return:-return} (rc);
2322 }
2323 ],
2324                 [cf_cv_fopen_bin_r=yes],
2325                 [cf_cv_fopen_bin_r=no],
2326                 [cf_cv_fopen_bin_r=unknown])
2327 ])
2328 test "x$cf_cv_fopen_bin_r" != xno && AC_DEFINE(USE_FOPEN_BIN_R,1,[Define to 1 if fopen accepts explicit binary mode])
2329 ])dnl
2330 dnl ---------------------------------------------------------------------------
2331 dnl CF_FORGET_TOOL version: 1 updated: 2013/04/06 18:03:09
2332 dnl --------------
2333 dnl Forget that we saw the given tool.
2334 AC_DEFUN([CF_FORGET_TOOL],[
2335 unset ac_cv_prog_ac_ct_$1
2336 unset ac_ct_$1
2337 unset $1
2338 ])dnl
2339 dnl ---------------------------------------------------------------------------
2340 dnl CF_FUNC_DLSYM version: 4 updated: 2015/09/12 14:46:44
2341 dnl -------------
2342 dnl Test for dlsym() and related functions, as well as libdl.
2343 dnl
2344 dnl Sets
2345 dnl     $cf_have_dlsym
2346 dnl     $cf_have_libdl
2347 AC_DEFUN([CF_FUNC_DLSYM],[
2348 cf_have_dlsym=no
2349 AC_CHECK_FUNC(dlsym,cf_have_dlsym=yes,[
2350
2351 cf_have_libdl=no
2352 AC_CHECK_LIB(dl,dlsym,[
2353         cf_have_dlsym=yes
2354         cf_have_libdl=yes])])
2355
2356 if test "$cf_have_dlsym" = yes ; then
2357         test "$cf_have_libdl" = yes && { CF_ADD_LIB(dl) }
2358
2359         AC_MSG_CHECKING(whether able to link to dl*() functions)
2360         AC_TRY_LINK([#include <dlfcn.h>],[
2361                 void *obj;
2362                 if ((obj = dlopen("filename", 0)) != 0) {
2363                         if (dlsym(obj, "symbolname") == 0) {
2364                         dlclose(obj);
2365                         }
2366                 }],[
2367                 AC_DEFINE(HAVE_LIBDL,1,[Define to 1 if we have dl library])],[
2368                 AC_MSG_ERROR(Cannot link test program for libdl)])
2369         AC_MSG_RESULT(ok)
2370 else
2371         AC_MSG_ERROR(Cannot find dlsym function)
2372 fi
2373 ])
2374 dnl ---------------------------------------------------------------------------
2375 dnl CF_FUNC_MEMMOVE version: 9 updated: 2017/01/21 11:06:25
2376 dnl ---------------
2377 dnl Check for memmove, or a bcopy that can handle overlapping copy.  If neither
2378 dnl is found, add our own version of memmove to the list of objects.
2379 AC_DEFUN([CF_FUNC_MEMMOVE],
2380 [
2381 AC_CHECK_FUNC(memmove,,[
2382 AC_CHECK_FUNC(bcopy,[
2383         AC_CACHE_CHECK(if bcopy does overlapping moves,cf_cv_good_bcopy,[
2384                 AC_TRY_RUN([
2385 int main(void) {
2386         static char data[] = "abcdefghijklmnopqrstuwwxyz";
2387         char temp[40];
2388         bcopy(data, temp, sizeof(data));
2389         bcopy(temp+10, temp, 15);
2390         bcopy(temp+5, temp+15, 10);
2391         ${cf_cv_main_return:-return} (strcmp(temp, "klmnopqrstuwwxypqrstuwwxyz"));
2392 }
2393                 ],
2394                 [cf_cv_good_bcopy=yes],
2395                 [cf_cv_good_bcopy=no],
2396                 [cf_cv_good_bcopy=unknown])
2397                 ])
2398         ],[cf_cv_good_bcopy=no])
2399         if test "$cf_cv_good_bcopy" = yes ; then
2400                 AC_DEFINE(USE_OK_BCOPY,1,[Define to 1 to use bcopy when memmove is unavailable])
2401         else
2402                 AC_DEFINE(USE_MY_MEMMOVE,1,[Define to 1 to use replacement function when memmove is unavailable])
2403         fi
2404 ])])dnl
2405 dnl ---------------------------------------------------------------------------
2406 dnl CF_FUNC_NANOSLEEP version: 5 updated: 2017/01/21 11:06:25
2407 dnl -----------------
2408 dnl Check for existence of workable nanosleep() function.  Some systems, e.g.,
2409 dnl AIX 4.x, provide a non-working version.
2410 AC_DEFUN([CF_FUNC_NANOSLEEP],[
2411 AC_CACHE_CHECK(if nanosleep really works,cf_cv_func_nanosleep,[
2412 AC_TRY_RUN([
2413 #include <stdio.h>
2414 #include <errno.h>
2415 #include <time.h>
2416
2417 #ifdef HAVE_SYS_TIME_H
2418 #include <sys/time.h>
2419 #endif
2420
2421 int main(void) {
2422         struct timespec ts1, ts2;
2423         int code;
2424         ts1.tv_sec  = 0;
2425         ts1.tv_nsec = 750000000;
2426         ts2.tv_sec  = 0;
2427         ts2.tv_nsec = 0;
2428         errno = 0;
2429         code = nanosleep(&ts1, &ts2); /* on failure errno is ENOSYS. */
2430         ${cf_cv_main_return:-return}(code != 0);
2431 }
2432 ],
2433         [cf_cv_func_nanosleep=yes],
2434         [cf_cv_func_nanosleep=no],
2435         [cf_cv_func_nanosleep=unknown])])
2436
2437 test "$cf_cv_func_nanosleep" = "yes" && AC_DEFINE(HAVE_NANOSLEEP,1,[Define to 1 if we have nanosleep()])
2438 ])
2439 dnl ---------------------------------------------------------------------------
2440 dnl CF_FUNC_OPENPTY version: 5 updated: 2015/09/12 14:46:50
2441 dnl ---------------
2442 dnl Check for openpty() function, along with <pty.h> header.  It may need the
2443 dnl "util" library as well.
2444 AC_DEFUN([CF_FUNC_OPENPTY],
2445 [
2446 AC_CHECK_LIB(util,openpty,cf_cv_lib_util=yes,cf_cv_lib_util=no)
2447 AC_CACHE_CHECK(for openpty header,cf_cv_func_openpty,[
2448         cf_save_LIBS="$LIBS"
2449         test $cf_cv_lib_util = yes && { CF_ADD_LIB(util) }
2450         for cf_header in pty.h libutil.h util.h
2451         do
2452         AC_TRY_LINK([
2453 #include <$cf_header>
2454 ],[
2455         int x = openpty((int *)0, (int *)0, (char *)0,
2456                                    (struct termios *)0, (struct winsize *)0);
2457 ],[
2458                 cf_cv_func_openpty=$cf_header
2459                 break
2460 ],[
2461                 cf_cv_func_openpty=no
2462 ])
2463         done
2464         LIBS="$cf_save_LIBS"
2465 ])
2466 ])dnl
2467 dnl ---------------------------------------------------------------------------
2468 dnl CF_FUNC_POLL version: 9 updated: 2015/10/10 13:27:32
2469 dnl ------------
2470 dnl See if the poll function really works.  Some platforms have poll(), but
2471 dnl it does not work for terminals or files.
2472 AC_DEFUN([CF_FUNC_POLL],[
2473 tty 2>&1 >/dev/null || { AC_CHECK_FUNCS(posix_openpt) }
2474 AC_CACHE_CHECK(if poll really works,cf_cv_working_poll,[
2475 AC_TRY_RUN([
2476 #include <stdlib.h>
2477 #include <stdio.h>
2478 #include <unistd.h>
2479 #include <fcntl.h>
2480 #ifdef HAVE_POLL_H
2481 #include <poll.h>
2482 #else
2483 #include <sys/poll.h>
2484 #endif
2485 int main(void) {
2486         struct pollfd myfds;
2487         int ret;
2488
2489         /* check for Darwin bug with respect to "devices" */
2490         myfds.fd = open("/dev/null", 1);        /* O_WRONLY */
2491         if (myfds.fd < 0)
2492                 myfds.fd = 0;
2493         myfds.events = POLLIN;
2494         myfds.revents = 0;
2495
2496         ret = poll(&myfds, 1, 100);
2497
2498         if (ret < 0 || (myfds.revents & POLLNVAL)) {
2499                 ret = -1;
2500         } else {
2501                 int fd = 0;
2502                 if (!isatty(fd)) {
2503                         fd = open("/dev/tty", 2);       /* O_RDWR */
2504                 }
2505 #ifdef HAVE_POSIX_OPENPT
2506                 if (fd < 0) {
2507                         fd = posix_openpt(O_RDWR);
2508                 }
2509 #endif
2510
2511                 if (fd >= 0) {
2512                         /* also check with standard input */
2513                         myfds.fd = fd;
2514                         myfds.events = POLLIN;
2515                         myfds.revents = 0;
2516                         ret = poll(&myfds, 1, 100);
2517                 } else {
2518                         ret = -1;
2519                 }
2520         }
2521         ${cf_cv_main_return:-return}(ret < 0);
2522 }],
2523         [cf_cv_working_poll=yes],
2524         [cf_cv_working_poll=no],
2525         [cf_cv_working_poll=unknown])])
2526 test "$cf_cv_working_poll" = "yes" && AC_DEFINE(HAVE_WORKING_POLL,1,[Define to 1 if the poll function seems to work])
2527 ])dnl
2528 dnl ---------------------------------------------------------------------------
2529 dnl CF_FUNC_TERMIOS version: 3 updated: 2012/10/06 17:56:13
2530 dnl ---------------
2531 dnl Some old/broken variations define tcgetattr() only as a macro in
2532 dnl termio(s).h
2533 AC_DEFUN([CF_FUNC_TERMIOS],[
2534 AC_REQUIRE([CF_STRUCT_TERMIOS])
2535 AC_CACHE_CHECK(for tcgetattr, cf_cv_have_tcgetattr,[
2536 AC_TRY_LINK([
2537 #include <sys/types.h>
2538 #ifdef HAVE_UNISTD_H
2539 #include <unistd.h>
2540 #endif
2541 #ifdef HAVE_TERMIOS_H
2542 #include <termios.h>
2543 #define TTY struct termios
2544 #else
2545 #ifdef HAVE_TERMIO_H
2546 #include <termio.h>
2547 #define TTY struct termio
2548 #endif
2549 #endif
2550 ],[
2551 TTY foo;
2552 tcgetattr(1, &foo);],
2553 [cf_cv_have_tcgetattr=yes],
2554 [cf_cv_have_tcgetattr=no])])
2555 test "$cf_cv_have_tcgetattr" = yes && AC_DEFINE(HAVE_TCGETATTR,1,[Define to 1 if we have tcgetattr])
2556 ])dnl
2557 dnl ---------------------------------------------------------------------------
2558 dnl CF_FUNC_VSSCANF version: 6 updated: 2015/04/18 08:56:57
2559 dnl ---------------
2560 dnl Check for vsscanf() function, which is in c9x but generally not in earlier
2561 dnl versions of C.  It is in the GNU C library, and can often be simulated by
2562 dnl other functions.
2563 AC_DEFUN([CF_FUNC_VSSCANF],
2564 [
2565 AC_CACHE_CHECK(for vsscanf function or workaround,cf_cv_func_vsscanf,[
2566 AC_TRY_LINK([
2567 #include <stdarg.h>
2568 #include <stdio.h>],[
2569         va_list ap;
2570         vsscanf("from", "%d", ap)],[cf_cv_func_vsscanf=vsscanf],[
2571 AC_TRY_LINK([
2572 #include <stdarg.h>
2573 #include <stdio.h>],[
2574         FILE strbuf;
2575         char *str = "from";
2576
2577         strbuf._flag = _IOREAD;
2578         strbuf._ptr = strbuf._base = (unsigned char *) str;
2579         strbuf._cnt = strlen(str);
2580         strbuf._file = _NFILE;
2581         return (vfscanf(&strbuf, "%d", ap))],[cf_cv_func_vsscanf=vfscanf],[
2582 AC_TRY_LINK([
2583 #include <stdarg.h>
2584 #include <stdio.h>],[
2585         FILE strbuf;
2586         char *str = "from";
2587
2588         strbuf._flag = _IOREAD;
2589         strbuf._ptr = strbuf._base = (unsigned char *) str;
2590         strbuf._cnt = strlen(str);
2591         strbuf._file = _NFILE;
2592         return (_doscan(&strbuf, "%d", ap))],[cf_cv_func_vsscanf=_doscan],[
2593 cf_cv_func_vsscanf=no])])])])
2594
2595 case $cf_cv_func_vsscanf in
2596 (vsscanf) AC_DEFINE(HAVE_VSSCANF,1,[Define to 1 if we have vsscanf]);;
2597 (vfscanf) AC_DEFINE(HAVE_VFSCANF,1,[Define to 1 if we have vfscanf]);;
2598 (_doscan) AC_DEFINE(HAVE__DOSCAN,1,[Define to 1 if we have _doscan]);;
2599 esac
2600
2601 ])dnl
2602 dnl ---------------------------------------------------------------------------
2603 dnl CF_GCC_ATTRIBUTES version: 19 updated: 2020/08/29 09:05:21
2604 dnl -----------------
2605 dnl Test for availability of useful gcc __attribute__ directives to quiet
2606 dnl compiler warnings.  Though useful, not all are supported -- and contrary
2607 dnl to documentation, unrecognized directives cause older compilers to barf.
2608 AC_DEFUN([CF_GCC_ATTRIBUTES],
2609 [
2610 if ( test "$GCC" = yes || test "$GXX" = yes )
2611 then
2612 cat > conftest.i <<EOF
2613 #ifndef GCC_PRINTF
2614 #define GCC_PRINTF 0
2615 #endif
2616 #ifndef GCC_SCANF
2617 #define GCC_SCANF 0
2618 #endif
2619 #ifndef GCC_NORETURN
2620 #define GCC_NORETURN /* nothing */
2621 #endif
2622 #ifndef GCC_UNUSED
2623 #define GCC_UNUSED /* nothing */
2624 #endif
2625 EOF
2626 if test "$GCC" = yes
2627 then
2628         AC_CHECKING([for $CC __attribute__ directives])
2629 cat > conftest.$ac_ext <<EOF
2630 #line __oline__ "${as_me:-configure}"
2631 #include "confdefs.h"
2632 #include "conftest.h"
2633 #include "conftest.i"
2634 #if     GCC_PRINTF
2635 #define GCC_PRINTFLIKE(fmt,var) __attribute__((format(printf,fmt,var)))
2636 #else
2637 #define GCC_PRINTFLIKE(fmt,var) /*nothing*/
2638 #endif
2639 #if     GCC_SCANF
2640 #define GCC_SCANFLIKE(fmt,var)  __attribute__((format(scanf,fmt,var)))
2641 #else
2642 #define GCC_SCANFLIKE(fmt,var)  /*nothing*/
2643 #endif
2644 extern void wow(char *,...) GCC_SCANFLIKE(1,2);
2645 extern void oops(char *,...) GCC_PRINTFLIKE(1,2) GCC_NORETURN;
2646 extern void foo(void) GCC_NORETURN;
2647 int main(int argc GCC_UNUSED, char *argv[[]] GCC_UNUSED) { (void)argc; (void)argv; return 0; }
2648 EOF
2649         cf_printf_attribute=no
2650         cf_scanf_attribute=no
2651         for cf_attribute in scanf printf unused noreturn
2652         do
2653                 CF_UPPER(cf_ATTRIBUTE,$cf_attribute)
2654                 cf_directive="__attribute__(($cf_attribute))"
2655                 echo "checking for $CC $cf_directive" 1>&AC_FD_CC
2656
2657                 case $cf_attribute in
2658                 (printf)
2659                         cf_printf_attribute=yes
2660                         cat >conftest.h <<EOF
2661 #define GCC_$cf_ATTRIBUTE 1
2662 EOF
2663                         ;;
2664                 (scanf)
2665                         cf_scanf_attribute=yes
2666                         cat >conftest.h <<EOF
2667 #define GCC_$cf_ATTRIBUTE 1
2668 EOF
2669                         ;;
2670                 (*)
2671                         cat >conftest.h <<EOF
2672 #define GCC_$cf_ATTRIBUTE $cf_directive
2673 EOF
2674                         ;;
2675                 esac
2676
2677                 if AC_TRY_EVAL(ac_compile); then
2678                         test -n "$verbose" && AC_MSG_RESULT(... $cf_attribute)
2679                         cat conftest.h >>confdefs.h
2680                         case $cf_attribute in
2681                         (noreturn)
2682                                 AC_DEFINE_UNQUOTED(GCC_NORETURN,$cf_directive,[Define to noreturn-attribute for gcc])
2683                                 ;;
2684                         (printf)
2685                                 cf_value='/* nothing */'
2686                                 if test "$cf_printf_attribute" != no ; then
2687                                         cf_value='__attribute__((format(printf,fmt,var)))'
2688                                         AC_DEFINE(GCC_PRINTF,1,[Define to 1 if the compiler supports gcc-like printf attribute.])
2689                                 fi
2690                                 AC_DEFINE_UNQUOTED(GCC_PRINTFLIKE(fmt,var),$cf_value,[Define to printf-attribute for gcc])
2691                                 ;;
2692                         (scanf)
2693                                 cf_value='/* nothing */'
2694                                 if test "$cf_scanf_attribute" != no ; then
2695                                         cf_value='__attribute__((format(scanf,fmt,var)))'
2696                                         AC_DEFINE(GCC_SCANF,1,[Define to 1 if the compiler supports gcc-like scanf attribute.])
2697                                 fi
2698                                 AC_DEFINE_UNQUOTED(GCC_SCANFLIKE(fmt,var),$cf_value,[Define to sscanf-attribute for gcc])
2699                                 ;;
2700                         (unused)
2701                                 AC_DEFINE_UNQUOTED(GCC_UNUSED,$cf_directive,[Define to unused-attribute for gcc])
2702                                 ;;
2703                         esac
2704                 fi
2705         done
2706 else
2707         fgrep define conftest.i >>confdefs.h
2708 fi
2709 rm -rf conftest*
2710 fi
2711 ])dnl
2712 dnl ---------------------------------------------------------------------------
2713 dnl CF_GCC_VERSION version: 8 updated: 2019/09/07 13:38:36
2714 dnl --------------
2715 dnl Find version of gcc, and (because icc/clang pretend to be gcc without being
2716 dnl compatible), attempt to determine if icc/clang is actually used.
2717 AC_DEFUN([CF_GCC_VERSION],[
2718 AC_REQUIRE([AC_PROG_CC])
2719 GCC_VERSION=none
2720 if test "$GCC" = yes ; then
2721         AC_MSG_CHECKING(version of $CC)
2722         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.]].*//'`"
2723         test -z "$GCC_VERSION" && GCC_VERSION=unknown
2724         AC_MSG_RESULT($GCC_VERSION)
2725 fi
2726 CF_INTEL_COMPILER(GCC,INTEL_COMPILER,CFLAGS)
2727 CF_CLANG_COMPILER(GCC,CLANG_COMPILER,CFLAGS)
2728 ])dnl
2729 dnl ---------------------------------------------------------------------------
2730 dnl CF_GCC_WARNINGS version: 38 updated: 2020/08/28 15:08:28
2731 dnl ---------------
2732 dnl Check if the compiler supports useful warning options.  There's a few that
2733 dnl we don't use, simply because they're too noisy:
2734 dnl
2735 dnl     -Wconversion (useful in older versions of gcc, but not in gcc 2.7.x)
2736 dnl     -Winline (usually not worthwhile)
2737 dnl     -Wredundant-decls (system headers make this too noisy)
2738 dnl     -Wtraditional (combines too many unrelated messages, only a few useful)
2739 dnl     -Wwrite-strings (too noisy, but should review occasionally).  This
2740 dnl             is enabled for ncurses using "--enable-const".
2741 dnl     -pedantic
2742 dnl
2743 dnl Parameter:
2744 dnl     $1 is an optional list of gcc warning flags that a particular
2745 dnl             application might want to use, e.g., "no-unused" for
2746 dnl             -Wno-unused
2747 dnl Special:
2748 dnl     If $with_ext_const is "yes", add a check for -Wwrite-strings
2749 dnl
2750 AC_DEFUN([CF_GCC_WARNINGS],
2751 [
2752 AC_REQUIRE([CF_GCC_VERSION])
2753 if test "x$have_x" = xyes; then CF_CONST_X_STRING fi
2754 cat > conftest.$ac_ext <<EOF
2755 #line __oline__ "${as_me:-configure}"
2756 int main(int argc, char *argv[[]]) { return (argv[[argc-1]] == 0) ; }
2757 EOF
2758 if test "$INTEL_COMPILER" = yes
2759 then
2760 # The "-wdXXX" options suppress warnings:
2761 # remark #1419: external declaration in primary source file
2762 # remark #1683: explicit conversion of a 64-bit integral type to a smaller integral type (potential portability problem)
2763 # remark #1684: conversion from pointer to same-sized integral type (potential portability problem)
2764 # remark #193: zero used for undefined preprocessing identifier
2765 # remark #593: variable "curs_sb_left_arrow" was set but never used
2766 # remark #810: conversion from "int" to "Dimension={unsigned short}" may lose significant bits
2767 # remark #869: parameter "tw" was never referenced
2768 # remark #981: operands are evaluated in unspecified order
2769 # warning #279: controlling expression is constant
2770
2771         AC_CHECKING([for $CC warning options])
2772         cf_save_CFLAGS="$CFLAGS"
2773         EXTRA_CFLAGS="$EXTRA_CFLAGS -Wall"
2774         for cf_opt in \
2775                 wd1419 \
2776                 wd1683 \
2777                 wd1684 \
2778                 wd193 \
2779                 wd593 \
2780                 wd279 \
2781                 wd810 \
2782                 wd869 \
2783                 wd981
2784         do
2785                 CFLAGS="$cf_save_CFLAGS $EXTRA_CFLAGS -$cf_opt"
2786                 if AC_TRY_EVAL(ac_compile); then
2787                         test -n "$verbose" && AC_MSG_RESULT(... -$cf_opt)
2788                         EXTRA_CFLAGS="$EXTRA_CFLAGS -$cf_opt"
2789                 fi
2790         done
2791         CFLAGS="$cf_save_CFLAGS"
2792 elif test "$GCC" = yes && test "$GCC_VERSION" != "unknown"
2793 then
2794         AC_CHECKING([for $CC warning options])
2795         cf_save_CFLAGS="$CFLAGS"
2796         cf_warn_CONST=""
2797         test "$with_ext_const" = yes && cf_warn_CONST="Wwrite-strings"
2798         cf_gcc_warnings="Wignored-qualifiers Wlogical-op Wvarargs"
2799         test "x$CLANG_COMPILER" = xyes && cf_gcc_warnings=
2800         for cf_opt in W Wall \
2801                 Wbad-function-cast \
2802                 Wcast-align \
2803                 Wcast-qual \
2804                 Wdeclaration-after-statement \
2805                 Wextra \
2806                 Winline \
2807                 Wmissing-declarations \
2808                 Wmissing-prototypes \
2809                 Wnested-externs \
2810                 Wpointer-arith \
2811                 Wshadow \
2812                 Wstrict-prototypes \
2813                 Wundef Wno-inline $cf_gcc_warnings $cf_warn_CONST $1
2814         do
2815                 CFLAGS="$cf_save_CFLAGS $EXTRA_CFLAGS -$cf_opt"
2816                 if AC_TRY_EVAL(ac_compile); then
2817                         test -n "$verbose" && AC_MSG_RESULT(... -$cf_opt)
2818                         case $cf_opt in
2819                         (Winline)
2820                                 case $GCC_VERSION in
2821                                 ([[34]].*)
2822                                         CF_VERBOSE(feature is broken in gcc $GCC_VERSION)
2823                                         continue;;
2824                                 esac
2825                                 ;;
2826                         (Wpointer-arith)
2827                                 case $GCC_VERSION in
2828                                 ([[12]].*)
2829                                         CF_VERBOSE(feature is broken in gcc $GCC_VERSION)
2830                                         continue;;
2831                                 esac
2832                                 ;;
2833                         esac
2834                         EXTRA_CFLAGS="$EXTRA_CFLAGS -$cf_opt"
2835                 fi
2836         done
2837         CFLAGS="$cf_save_CFLAGS"
2838 fi
2839 rm -rf conftest*
2840
2841 AC_SUBST(EXTRA_CFLAGS)
2842 ])dnl
2843 dnl ---------------------------------------------------------------------------
2844 dnl CF_GETOPT_HEADER version: 6 updated: 2014/07/22 14:45:54
2845 dnl ----------------
2846 dnl Check for getopt's variables which are commonly defined in stdlib.h,
2847 dnl unistd.h or (nonstandard) in getopt.h
2848 AC_DEFUN([CF_GETOPT_HEADER],
2849 [
2850 AC_HAVE_HEADERS(unistd.h getopt.h)
2851 AC_CACHE_CHECK(for header declaring getopt variables,cf_cv_getopt_header,[
2852 cf_cv_getopt_header=none
2853 for cf_header in stdio.h stdlib.h unistd.h getopt.h
2854 do
2855 AC_TRY_COMPILE([
2856 #include <$cf_header>],
2857 [int x = optind; char *y = optarg],
2858 [cf_cv_getopt_header=$cf_header
2859  break])
2860 done
2861 ])
2862 if test $cf_cv_getopt_header != none ; then
2863         AC_DEFINE(HAVE_GETOPT_HEADER,1,[Define to 1 if getopt variables are declared in header])
2864 fi
2865 if test $cf_cv_getopt_header = getopt.h ; then
2866         AC_DEFINE(NEED_GETOPT_H,1,[Define to 1 if we must include getopt.h])
2867 fi
2868 ])dnl
2869 dnl ---------------------------------------------------------------------------
2870 dnl CF_GNATPREP_OPT_T version: 1 updated: 2014/08/02 18:37:25
2871 dnl -----------------
2872 AC_DEFUN([CF_GNATPREP_OPT_T],[
2873 AC_CACHE_CHECK(if GNATPREP supports -T option,cf_cv_gnatprep_opt_t,[
2874 cf_cv_gnatprep_opt_t=no
2875 gnatprep -T 2>/dev/null >/dev/null && cf_cv_gnatprep_opt_t=yes
2876 ])
2877 test "$cf_cv_gnatprep_opt_t" = yes && GNATPREP_OPTS="-T $GNATPREP_OPTS"
2878 AC_SUBST(GNATPREP_OPTS)
2879 ])dnl
2880 dnl ---------------------------------------------------------------------------
2881 dnl CF_GNAT_GENERICS version: 6 updated: 2020/07/04 19:30:27
2882 dnl ----------------
2883 AC_DEFUN([CF_GNAT_GENERICS],
2884 [
2885 AC_REQUIRE([CF_GNAT_VERSION])
2886
2887 AC_MSG_CHECKING(if GNAT supports generics)
2888 case $cf_cv_gnat_version in
2889 (3.1[[1-9]]*|3.[[2-9]]*|[[4-9]].*|[[1-9]][[0-9]].[[0-9]]*|20[[0-9]][[0-9]])
2890         cf_gnat_generics=yes
2891         ;;
2892 (*)
2893         cf_gnat_generics=no
2894         ;;
2895 esac
2896 AC_MSG_RESULT($cf_gnat_generics)
2897
2898 if test "$cf_gnat_generics" = yes
2899 then
2900         cf_compile_generics=generics
2901         cf_generic_objects="\${GENOBJS}"
2902 else
2903         cf_compile_generics=
2904         cf_generic_objects=
2905 fi
2906
2907 AC_SUBST(cf_compile_generics)
2908 AC_SUBST(cf_generic_objects)
2909 ])dnl
2910 dnl ---------------------------------------------------------------------------
2911 dnl CF_GNAT_PROJECTS version: 10 updated: 2019/12/31 08:53:54
2912 dnl ----------------
2913 dnl GNAT projects are configured with ".gpr" project files.
2914 dnl GNAT libraries are a further development, using the project feature.
2915 AC_DEFUN([CF_GNAT_PROJECTS],
2916 [
2917 AC_REQUIRE([CF_GNAT_VERSION])
2918 AC_REQUIRE([CF_DISABLE_GNAT_PROJECTS])
2919
2920 cf_gnat_libraries=no
2921 cf_gnat_projects=no
2922
2923 if test "$enable_gnat_projects" != no ; then
2924 AC_MSG_CHECKING(if GNAT supports project files)
2925 case $cf_cv_gnat_version in
2926 (3.[[0-9]]*)
2927         ;;
2928 (*)
2929         case $cf_cv_system_name in
2930         (cygwin*|msys*)
2931                 ;;
2932         (*)
2933                 rm -rf conftest* *~conftest*
2934                 if mkdir conftest.src conftest.bin conftest.lib
2935                 then
2936                         cd conftest.src
2937                         rm -rf conftest* *~conftest*
2938                         cat >>library.gpr <<CF_EOF
2939 project Library is
2940   Kind := External ("LIB_KIND");
2941   for Library_Name use "ConfTest";
2942   for Object_Dir use ".";
2943   for Library_ALI_Dir use External("LIBRARY_DIR");
2944   for Library_Version use External ("SONAME");
2945   for Library_Kind use Kind;
2946   for Library_Dir use External("BUILD_DIR");
2947   Source_Dir := External ("SOURCE_DIR");
2948   for Source_Dirs use (Source_Dir);
2949 end Library;
2950 CF_EOF
2951                         cat >>confpackage.ads <<CF_EOF
2952 package ConfPackage is
2953    procedure conftest;
2954 end ConfPackage;
2955 CF_EOF
2956                         cat >>confpackage.adb <<CF_EOF
2957 with Text_IO;
2958 package body ConfPackage is
2959    procedure conftest is
2960    begin
2961       Text_IO.Put ("Hello World");
2962       Text_IO.New_Line;
2963    end conftest;
2964 end ConfPackage;
2965 CF_EOF
2966                         if ( $cf_ada_make $ADAFLAGS \
2967                                         -Plibrary.gpr \
2968                                         -XBUILD_DIR=`cd ../conftest.bin;pwd` \
2969                                         -XLIBRARY_DIR=`cd ../conftest.lib;pwd` \
2970                                         -XSOURCE_DIR=`pwd` \
2971                                         -XSONAME=libConfTest.so.1 \
2972                                         -XLIB_KIND=static 1>&AC_FD_CC 2>&1 ) ; then
2973                                 cf_gnat_projects=yes
2974                         fi
2975                         cd ..
2976                 fi
2977                 if test -f conftest.lib/confpackage.ali
2978                 then
2979                         cf_gnat_libraries=yes
2980                 fi
2981                 rm -rf conftest* *~conftest*
2982                 ;;
2983         esac
2984         ;;
2985 esac
2986 AC_MSG_RESULT($cf_gnat_projects)
2987 fi # enable_gnat_projects
2988
2989 if test $cf_gnat_projects = yes
2990 then
2991         AC_MSG_CHECKING(if GNAT supports libraries)
2992         AC_MSG_RESULT($cf_gnat_libraries)
2993 fi
2994
2995 if test "$cf_gnat_projects" = yes
2996 then
2997         USE_OLD_MAKERULES="#"
2998         USE_GNAT_PROJECTS=""
2999 else
3000         USE_OLD_MAKERULES=""
3001         USE_GNAT_PROJECTS="#"
3002 fi
3003
3004 if test "$cf_gnat_libraries" = yes
3005 then
3006         USE_GNAT_LIBRARIES=""
3007 else
3008         USE_GNAT_LIBRARIES="#"
3009 fi
3010
3011 AC_SUBST(USE_OLD_MAKERULES)
3012 AC_SUBST(USE_GNAT_PROJECTS)
3013 AC_SUBST(USE_GNAT_LIBRARIES)
3014 ])dnl
3015 dnl ---------------------------------------------------------------------------
3016 dnl CF_GNAT_SIGINT version: 1 updated: 2011/03/27 20:07:59
3017 dnl --------------
3018 dnl Check if gnat supports SIGINT, and presumably tasking.  For the latter, it
3019 dnl is noted that gnat may compile a tasking unit even for configurations which
3020 dnl fail at runtime.
3021 AC_DEFUN([CF_GNAT_SIGINT],[
3022 AC_CACHE_CHECK(if GNAT supports SIGINT,cf_cv_gnat_sigint,[
3023 CF_GNAT_TRY_LINK([with Ada.Interrupts.Names;
3024
3025 package ConfTest is
3026
3027    pragma Warnings (Off);  --  the next pragma exists since 3.11p
3028    pragma Unreserve_All_Interrupts;
3029    pragma Warnings (On);
3030
3031    protected Process is
3032       procedure Stop;
3033       function Continue return Boolean;
3034       pragma Attach_Handler (Stop, Ada.Interrupts.Names.SIGINT);
3035    private
3036       Done : Boolean := False;
3037    end Process;
3038
3039 end ConfTest;],
3040 [package body ConfTest is
3041    protected body Process is
3042       procedure Stop is
3043       begin
3044          Done := True;
3045       end Stop;
3046       function Continue return Boolean is
3047       begin
3048          return not Done;
3049       end Continue;
3050    end Process;
3051 end ConfTest;],
3052         [cf_cv_gnat_sigint=yes],
3053         [cf_cv_gnat_sigint=no])])
3054
3055 if test $cf_cv_gnat_sigint = yes ; then
3056         USE_GNAT_SIGINT=""
3057 else
3058         USE_GNAT_SIGINT="#"
3059 fi
3060 AC_SUBST(USE_GNAT_SIGINT)
3061 ])dnl
3062 dnl ---------------------------------------------------------------------------
3063 dnl CF_GNAT_TRY_LINK version: 3 updated: 2011/03/19 14:47:45
3064 dnl ----------------
3065 dnl Verify that a test program compiles/links with GNAT.
3066 dnl $cf_ada_make is set to the program that compiles/links
3067 dnl $ADAFLAGS may be set to the GNAT flags.
3068 dnl
3069 dnl $1 is the text of the spec
3070 dnl $2 is the text of the body
3071 dnl $3 is the shell command to execute if successful
3072 dnl $4 is the shell command to execute if not successful
3073 AC_DEFUN([CF_GNAT_TRY_LINK],
3074 [
3075 rm -rf conftest* *~conftest*
3076 cat >>conftest.ads <<CF_EOF
3077 $1
3078 CF_EOF
3079 cat >>conftest.adb <<CF_EOF
3080 $2
3081 CF_EOF
3082 if ( $cf_ada_make $ADAFLAGS conftest 1>&AC_FD_CC 2>&1 ) ; then
3083 ifelse($3,,      :,[      $3])
3084 ifelse($4,,,[else
3085    $4])
3086 fi
3087 rm -rf conftest* *~conftest*
3088 ])dnl
3089 dnl ---------------------------------------------------------------------------
3090 dnl CF_GNAT_TRY_RUN version: 5 updated: 2011/03/19 14:47:45
3091 dnl ---------------
3092 dnl Verify that a test program compiles and runs with GNAT
3093 dnl $cf_ada_make is set to the program that compiles/links
3094 dnl $ADAFLAGS may be set to the GNAT flags.
3095 dnl
3096 dnl $1 is the text of the spec
3097 dnl $2 is the text of the body
3098 dnl $3 is the shell command to execute if successful
3099 dnl $4 is the shell command to execute if not successful
3100 AC_DEFUN([CF_GNAT_TRY_RUN],
3101 [
3102 rm -rf conftest* *~conftest*
3103 cat >>conftest.ads <<CF_EOF
3104 $1
3105 CF_EOF
3106 cat >>conftest.adb <<CF_EOF
3107 $2
3108 CF_EOF
3109 if ( $cf_ada_make $ADAFLAGS conftest 1>&AC_FD_CC 2>&1 ) ; then
3110    if ( ./conftest 1>&AC_FD_CC 2>&1 ) ; then
3111 ifelse($3,,      :,[      $3])
3112 ifelse($4,,,[   else
3113       $4])
3114    fi
3115 ifelse($4,,,[else
3116    $4])
3117 fi
3118 rm -rf conftest* *~conftest*
3119 ])dnl
3120 dnl ---------------------------------------------------------------------------
3121 dnl CF_GNAT_VERSION version: 22 updated: 2019/12/31 08:53:54
3122 dnl ---------------
3123 dnl $1 = cache variable to update
3124 dnl $2 = program name
3125 dnl Verify version of GNAT or related tool
3126 AC_DEFUN([CF_GNAT_VERSION],
3127 [
3128 AC_CACHE_CHECK(for ifelse($2,,gnat,$2) version, cf_cv_gnat_version,[
3129 cf_cv_gnat_version=`ifelse($2,,${cf_ada_make:-gnatmake},$2) --version 2>&1 | \
3130         grep '[[0-9]].[[0-9]][[0-9]]*' |\
3131         sed -e '2,$d' -e 's/[[^0-9 \.]]//g' -e 's/^[[ ]]*//' -e 's/ .*//'`
3132 ])
3133 test -z "$cf_cv_gnat_version" && cf_cv_gnat_version=no
3134 ifelse($1,,,[eval $1=$cf_cv_gnat_version; unset cf_cv_gnat_version])
3135 ])dnl
3136 dnl ---------------------------------------------------------------------------
3137 dnl CF_GNU_SOURCE version: 10 updated: 2018/12/10 20:09:41
3138 dnl -------------
3139 dnl Check if we must define _GNU_SOURCE to get a reasonable value for
3140 dnl _XOPEN_SOURCE, upon which many POSIX definitions depend.  This is a defect
3141 dnl (or misfeature) of glibc2, which breaks portability of many applications,
3142 dnl since it is interwoven with GNU extensions.
3143 dnl
3144 dnl Well, yes we could work around it...
3145 dnl
3146 dnl Parameters:
3147 dnl     $1 is the nominal value for _XOPEN_SOURCE
3148 AC_DEFUN([CF_GNU_SOURCE],
3149 [
3150 cf_gnu_xopen_source=ifelse($1,,500,$1)
3151
3152 AC_CACHE_CHECK(if this is the GNU C library,cf_cv_gnu_library,[
3153 AC_TRY_COMPILE([#include <sys/types.h>],[
3154         #if __GLIBC__ > 0 && __GLIBC_MINOR__ >= 0
3155                 return 0;
3156         #elif __NEWLIB__ > 0 && __NEWLIB_MINOR__ >= 0
3157                 return 0;
3158         #else
3159         #       error not GNU C library
3160         #endif],
3161         [cf_cv_gnu_library=yes],
3162         [cf_cv_gnu_library=no])
3163 ])
3164
3165 if test x$cf_cv_gnu_library = xyes; then
3166
3167         # With glibc 2.19 (13 years after this check was begun), _DEFAULT_SOURCE
3168         # was changed to help a little.  newlib incorporated the change about 4
3169         # years later.
3170         AC_CACHE_CHECK(if _DEFAULT_SOURCE can be used as a basis,cf_cv_gnu_library_219,[
3171                 cf_save="$CPPFLAGS"
3172                 CF_APPEND_TEXT(CPPFLAGS,-D_DEFAULT_SOURCE)
3173                 AC_TRY_COMPILE([#include <sys/types.h>],[
3174                         #if (__GLIBC__ == 2 && __GLIBC_MINOR__ >= 19) || (__GLIBC__ > 2)
3175                                 return 0;
3176                         #elif (__NEWLIB__ == 2 && __NEWLIB_MINOR__ >= 4) || (__GLIBC__ > 3)
3177                                 return 0;
3178                         #else
3179                         #       error GNU C library __GLIBC__.__GLIBC_MINOR__ is too old
3180                         #endif],
3181                         [cf_cv_gnu_library_219=yes],
3182                         [cf_cv_gnu_library_219=no])
3183                 CPPFLAGS="$cf_save"
3184         ])
3185
3186         if test "x$cf_cv_gnu_library_219" = xyes; then
3187                 cf_save="$CPPFLAGS"
3188                 AC_CACHE_CHECK(if _XOPEN_SOURCE=$cf_gnu_xopen_source works with _DEFAULT_SOURCE,cf_cv_gnu_dftsrc_219,[
3189                         CF_ADD_CFLAGS(-D_DEFAULT_SOURCE -D_XOPEN_SOURCE=$cf_gnu_xopen_source)
3190                         AC_TRY_COMPILE([
3191                                 #include <limits.h>
3192                                 #include <sys/types.h>
3193                                 ],[
3194                                 #if (_XOPEN_SOURCE >= $cf_gnu_xopen_source) && (MB_LEN_MAX > 1)
3195                                         return 0;
3196                                 #else
3197                                 #       error GNU C library is too old
3198                                 #endif],
3199                                 [cf_cv_gnu_dftsrc_219=yes],
3200                                 [cf_cv_gnu_dftsrc_219=no])
3201                         ])
3202                 test "x$cf_cv_gnu_dftsrc_219" = "xyes" || CPPFLAGS="$cf_save"
3203         else
3204                 cf_cv_gnu_dftsrc_219=maybe
3205         fi
3206
3207         if test "x$cf_cv_gnu_dftsrc_219" != xyes; then
3208
3209                 AC_CACHE_CHECK(if we must define _GNU_SOURCE,cf_cv_gnu_source,[
3210                 AC_TRY_COMPILE([#include <sys/types.h>],[
3211                         #ifndef _XOPEN_SOURCE
3212                         #error  expected _XOPEN_SOURCE to be defined
3213                         #endif],
3214                         [cf_cv_gnu_source=no],
3215                         [cf_save="$CPPFLAGS"
3216                          CF_ADD_CFLAGS(-D_GNU_SOURCE)
3217                          AC_TRY_COMPILE([#include <sys/types.h>],[
3218                                 #ifdef _XOPEN_SOURCE
3219                                 #error  expected _XOPEN_SOURCE to be undefined
3220                                 #endif],
3221                                 [cf_cv_gnu_source=no],
3222                                 [cf_cv_gnu_source=yes])
3223                         CPPFLAGS="$cf_save"
3224                         ])
3225                 ])
3226
3227                 if test "$cf_cv_gnu_source" = yes
3228                 then
3229                 AC_CACHE_CHECK(if we should also define _DEFAULT_SOURCE,cf_cv_default_source,[
3230                         CF_APPEND_TEXT(CPPFLAGS,-D_GNU_SOURCE)
3231                         AC_TRY_COMPILE([#include <sys/types.h>],[
3232                                 #ifdef _DEFAULT_SOURCE
3233                                 #error  expected _DEFAULT_SOURCE to be undefined
3234                                 #endif],
3235                                 [cf_cv_default_source=no],
3236                                 [cf_cv_default_source=yes])
3237                         ])
3238                         if test "$cf_cv_default_source" = yes
3239                         then
3240                                 CF_APPEND_TEXT(CPPFLAGS,-D_DEFAULT_SOURCE)
3241                         fi
3242                 fi
3243         fi
3244
3245 fi
3246 ])dnl
3247 dnl ---------------------------------------------------------------------------
3248 dnl CF_GPP_LIBRARY version: 12 updated: 2015/04/17 21:13:04
3249 dnl --------------
3250 dnl If we're trying to use g++, test if libg++ is installed (a rather common
3251 dnl problem :-).  If we have the compiler but no library, we'll be able to
3252 dnl configure, but won't be able to build the c++ demo program.
3253 AC_DEFUN([CF_GPP_LIBRARY],
3254 [
3255 cf_cxx_library=unknown
3256 case $cf_cv_system_name in
3257 (os2*)
3258         cf_gpp_libname=gpp
3259         ;;
3260 (*)
3261         cf_gpp_libname=g++
3262         ;;
3263 esac
3264 if test "$GXX" = yes; then
3265         AC_MSG_CHECKING([for lib$cf_gpp_libname])
3266         cf_save="$LIBS"
3267         CF_ADD_LIB($cf_gpp_libname)
3268         AC_TRY_LINK([
3269 #include <$cf_gpp_libname/builtin.h>
3270         ],
3271         [two_arg_error_handler_t foo2 = lib_error_handler],
3272         [cf_cxx_library=yes
3273          CF_ADD_LIB($cf_gpp_libname,CXXLIBS)
3274          if test "$cf_gpp_libname" = cpp ; then
3275             AC_DEFINE(HAVE_GPP_BUILTIN_H,1,[Define to 1 if we have gpp builtin.h])
3276          else
3277             AC_DEFINE(HAVE_GXX_BUILTIN_H,1,[Define to 1 if we have g++ builtin.h])
3278          fi],
3279         [AC_TRY_LINK([
3280 #include <builtin.h>
3281         ],
3282         [two_arg_error_handler_t foo2 = lib_error_handler],
3283         [cf_cxx_library=yes
3284          CF_ADD_LIB($cf_gpp_libname,CXXLIBS)
3285          AC_DEFINE(HAVE_BUILTIN_H,1,[Define to 1 if we have builtin.h])],
3286         [cf_cxx_library=no])])
3287         LIBS="$cf_save"
3288         AC_MSG_RESULT($cf_cxx_library)
3289 fi
3290 ])dnl
3291 dnl ---------------------------------------------------------------------------
3292 dnl CF_GXX_VERSION version: 8 updated: 2017/02/11 14:48:57
3293 dnl --------------
3294 dnl Check for version of g++
3295 AC_DEFUN([CF_GXX_VERSION],[
3296 AC_REQUIRE([AC_PROG_CPP])
3297 GXX_VERSION=none
3298 if test "$GXX" = yes; then
3299         AC_MSG_CHECKING(version of ${CXX:-g++})
3300         GXX_VERSION="`${CXX:-g++} --version| sed -e '2,$d' -e 's/^.*(GCC) //' -e 's/^[[^0-9.]]*//' -e 's/[[^0-9.]].*//'`"
3301         if test -z "$GXX_VERSION"
3302         then
3303                 GXX_VERSION=unknown
3304                 GXX=no
3305         fi
3306         AC_MSG_RESULT($GXX_VERSION)
3307 fi
3308 ])dnl
3309 dnl ---------------------------------------------------------------------------
3310 dnl CF_GXX_WARNINGS version: 9 updated: 2015/04/17 21:13:04
3311 dnl ---------------
3312 dnl Check if the compiler supports useful warning options.
3313 dnl
3314 dnl Most of gcc's options apply to g++, except:
3315 dnl     -Wbad-function-cast
3316 dnl     -Wmissing-declarations
3317 dnl     -Wnested-externs
3318 dnl
3319 dnl Omit a few (for now):
3320 dnl     -Winline
3321 dnl
3322 dnl Parameter:
3323 dnl     $1 is an optional list of g++ warning flags that a particular
3324 dnl             application might want to use, e.g., "no-unused" for
3325 dnl             -Wno-unused
3326 dnl Special:
3327 dnl     If $with_ext_const is "yes", add a check for -Wwrite-strings
3328 dnl
3329 AC_DEFUN([CF_GXX_WARNINGS],
3330 [
3331
3332 CF_INTEL_COMPILER(GXX,INTEL_CPLUSPLUS,CXXFLAGS)
3333 CF_CLANG_COMPILER(GXX,CLANG_CPLUSPLUS,CXXFLAGS)
3334
3335 AC_REQUIRE([CF_GXX_VERSION])
3336
3337 AC_LANG_SAVE
3338 AC_LANG_CPLUSPLUS
3339
3340 cat > conftest.$ac_ext <<EOF
3341 #line __oline__ "configure"
3342 int main(int argc, char *argv[[]]) { return (argv[[argc-1]] == 0) ; }
3343 EOF
3344
3345 if test "$INTEL_CPLUSPLUS" = yes
3346 then
3347 # The "-wdXXX" options suppress warnings:
3348 # remark #1419: external declaration in primary source file
3349 # remark #1682: implicit conversion of a 64-bit integral type to a smaller integral type (potential portability problem)
3350 # remark #1683: explicit conversion of a 64-bit integral type to a smaller integral type (potential portability problem)
3351 # remark #1684: conversion from pointer to same-sized integral type (potential portability problem)
3352 # remark #193: zero used for undefined preprocessing identifier
3353 # remark #593: variable "curs_sb_left_arrow" was set but never used
3354 # remark #810: conversion from "int" to "Dimension={unsigned short}" may lose significant bits
3355 # remark #869: parameter "tw" was never referenced
3356 # remark #981: operands are evaluated in unspecified order
3357 # warning #269: invalid format string conversion
3358
3359         AC_CHECKING([for $CC warning options])
3360         cf_save_CXXFLAGS="$CXXFLAGS"
3361         EXTRA_CXXFLAGS="-Wall"
3362         for cf_opt in \
3363                 wd1419 \
3364                 wd1682 \
3365                 wd1683 \
3366                 wd1684 \
3367                 wd193 \
3368                 wd279 \
3369                 wd593 \
3370                 wd810 \
3371                 wd869 \
3372                 wd981
3373         do
3374                 CXXFLAGS="$cf_save_CXXFLAGS $EXTRA_CXXFLAGS -$cf_opt"
3375                 if AC_TRY_EVAL(ac_compile); then
3376                         test -n "$verbose" && AC_MSG_RESULT(... -$cf_opt)
3377                         EXTRA_CXXFLAGS="$EXTRA_CXXFLAGS -$cf_opt"
3378                 fi
3379         done
3380         CXXFLAGS="$cf_save_CXXFLAGS"
3381
3382 elif test "$GXX" = yes
3383 then
3384         AC_CHECKING([for $CXX warning options])
3385         cf_save_CXXFLAGS="$CXXFLAGS"
3386         EXTRA_CXXFLAGS="-W -Wall"
3387         cf_gxx_extra_warnings=""
3388         test "$with_ext_const" = yes && cf_gxx_extra_warnings="Wwrite-strings"
3389         case "$GCC_VERSION" in
3390         ([[1-2]].*)
3391                 ;;
3392         (*)
3393                 cf_gxx_extra_warnings="$cf_gxx_extra_warnings Weffc++"
3394                 ;;
3395         esac
3396         for cf_opt in \
3397                 Wabi \
3398                 fabi-version=0 \
3399                 Wextra \
3400                 Wignored-qualifiers \
3401                 Wlogical-op \
3402                 Woverloaded-virtual \
3403                 Wsign-promo \
3404                 Wsynth \
3405                 Wold-style-cast \
3406                 Wcast-align \
3407                 Wcast-qual \
3408                 Wpointer-arith \
3409                 Wshadow \
3410                 Wundef $cf_gxx_extra_warnings $1
3411         do
3412                 CXXFLAGS="$cf_save_CXXFLAGS $EXTRA_CXXFLAGS -Werror -$cf_opt"
3413                 if AC_TRY_EVAL(ac_compile); then
3414                         test -n "$verbose" && AC_MSG_RESULT(... -$cf_opt)
3415                         EXTRA_CXXFLAGS="$EXTRA_CXXFLAGS -$cf_opt"
3416                 else
3417                         test -n "$verbose" && AC_MSG_RESULT(... no -$cf_opt)
3418                 fi
3419         done
3420         CXXFLAGS="$cf_save_CXXFLAGS"
3421 fi
3422
3423 rm -rf conftest*
3424 AC_LANG_RESTORE
3425 AC_SUBST(EXTRA_CXXFLAGS)
3426 ])dnl
3427 dnl ---------------------------------------------------------------------------
3428 dnl CF_HASHED_DB version: 7 updated: 2015/04/18 08:56:57
3429 dnl ------------
3430 dnl Look for an instance of the Berkeley hashed database.
3431 dnl
3432 dnl $1 = optional parameter, to specify install-prefix for the database.
3433 AC_DEFUN([CF_HASHED_DB],
3434 [
3435 ifelse([$1],,,[
3436 case $1 in
3437 (yes|*able*)
3438         ;;
3439 (*)
3440         if test -d "$1" ; then
3441                 CF_ADD_INCDIR($1/include)
3442                 CF_ADD_LIBDIR($1/lib)
3443         else
3444                 case "$1" in
3445                 (./*|../*|/*)
3446                         AC_MSG_WARN(no such directory $1)
3447                         ;;
3448                 (*)
3449                         CF_FIND_SUB_INCDIR($1)
3450                         CF_FIND_SUB_LIBDIR($1)
3451                         ;;
3452                 esac
3453         fi
3454 esac
3455 ])
3456 AC_CHECK_HEADER(db.h,[
3457 CF_HASHED_DB_VERSION
3458 if test "$cf_cv_hashed_db_version" = unknown ; then
3459         AC_MSG_ERROR(Cannot determine version of db)
3460 else
3461         CF_HASHED_DB_LIBS
3462         if test "$cf_cv_hashed_db_libs" = unknown ; then
3463                 AC_MSG_ERROR(Cannot determine library for db)
3464         elif test "$cf_cv_hashed_db_libs" != default ; then
3465                 CF_ADD_LIB($cf_cv_hashed_db_libs)
3466         fi
3467 fi
3468 ],[
3469         AC_MSG_ERROR(Cannot find db.h)
3470 ])
3471 ])dnl
3472 dnl ---------------------------------------------------------------------------
3473 dnl CF_HASHED_DB_LIBS version: 9 updated: 2010/05/29 16:31:02
3474 dnl -----------------
3475 dnl Given that we have the header and version for hashed database, find the
3476 dnl library information.
3477 AC_DEFUN([CF_HASHED_DB_LIBS],
3478 [
3479 AC_CACHE_CHECK(for db libraries, cf_cv_hashed_db_libs,[
3480 cf_cv_hashed_db_libs=unknown
3481 for cf_db_libs in "" db$cf_cv_hashed_db_version db-$cf_cv_hashed_db_version db ''
3482 do
3483         cf_save_libs="$LIBS"
3484         if test -n "$cf_db_libs"; then
3485                 CF_ADD_LIB($cf_db_libs)
3486         fi
3487         CF_MSG_LOG(checking for library "$cf_db_libs")
3488         AC_TRY_LINK([
3489 $ac_includes_default
3490 #include <db.h>
3491 ],[
3492         char *path = "/tmp/foo";
3493 #ifdef DB_VERSION_MAJOR
3494 #if DB_VERSION_MAJOR >= 4
3495         DB *result = 0;
3496         db_create(&result, NULL, 0);
3497         result->open(result,
3498                 NULL,
3499                 path,
3500                 path,
3501                 DB_HASH,
3502                 DB_CREATE,
3503                 0644);
3504 #elif DB_VERSION_MAJOR >= 3
3505         DB *result = 0;
3506         db_create(&result, NULL, 0);
3507         result->open(result,
3508                 path,
3509                 path,
3510                 DB_HASH,
3511                 DB_CREATE,
3512                 0644);
3513 #elif DB_VERSION_MAJOR >= 2
3514         DB *result = 0;
3515         db_open(path,
3516                 DB_HASH,
3517                 DB_CREATE,
3518                 0644,
3519                 (DB_ENV *) 0,
3520                 (DB_INFO *) 0,
3521                 &result);
3522 #endif /* DB_VERSION_MAJOR */
3523 #else
3524         DB *result = dbopen(path,
3525                      2,
3526                      0644,
3527                      DB_HASH,
3528                      0);
3529 #endif
3530         ${cf_cv_main_return:-return}(result != 0)
3531 ],[
3532         if test -n "$cf_db_libs" ; then
3533                 cf_cv_hashed_db_libs=$cf_db_libs
3534         else
3535                 cf_cv_hashed_db_libs=default
3536         fi
3537         LIBS="$cf_save_libs"
3538         break
3539 ])
3540         LIBS="$cf_save_libs"
3541 done
3542 ])
3543 ])dnl
3544 dnl ---------------------------------------------------------------------------
3545 dnl CF_HASHED_DB_VERSION version: 4 updated: 2014/04/12 16:47:01
3546 dnl --------------------
3547 dnl Given that we have the header file for hashed database, find the version
3548 dnl information.
3549 AC_DEFUN([CF_HASHED_DB_VERSION],
3550 [
3551 AC_CACHE_CHECK(for version of db, cf_cv_hashed_db_version,[
3552 cf_cv_hashed_db_version=unknown
3553
3554 for cf_db_version in 1 2 3 4 5 6
3555 do
3556         CF_MSG_LOG(checking for db version $cf_db_version)
3557         AC_TRY_COMPILE([
3558 $ac_includes_default
3559 #include <db.h>
3560
3561 #ifdef DB_VERSION_MAJOR
3562         /* db2 (DB_VERSION_MAJOR=2) has also DB_VERSION_MINOR, tested with 7 */
3563 #if $cf_db_version == DB_VERSION_MAJOR
3564         /* ok */
3565 #else
3566         make an error
3567 #endif
3568 #else
3569 #if $cf_db_version == 1
3570         /* ok: assuming this is DB 1.8.5 */
3571 #else
3572         make an error
3573 #endif
3574 #endif
3575 ],[DBT *foo = 0],[
3576         cf_cv_hashed_db_version=$cf_db_version
3577         break
3578         ])
3579 done
3580 ])
3581 ])dnl
3582 dnl ---------------------------------------------------------------------------
3583 dnl CF_HEADER_PATH version: 13 updated: 2015/04/15 19:08:48
3584 dnl --------------
3585 dnl Construct a search-list of directories for a nonstandard header-file
3586 dnl
3587 dnl Parameters
3588 dnl     $1 = the variable to return as result
3589 dnl     $2 = the package name
3590 AC_DEFUN([CF_HEADER_PATH],
3591 [
3592 $1=
3593
3594 # collect the current set of include-directories from compiler flags
3595 cf_header_path_list=""
3596 if test -n "${CFLAGS}${CPPFLAGS}" ; then
3597         for cf_header_path in $CPPFLAGS $CFLAGS
3598         do
3599                 case $cf_header_path in
3600                 (-I*)
3601                         cf_header_path=`echo ".$cf_header_path" |sed -e 's/^...//' -e 's,/include$,,'`
3602                         CF_ADD_SUBDIR_PATH($1,$2,include,$cf_header_path,NONE)
3603                         cf_header_path_list="$cf_header_path_list [$]$1"
3604                         ;;
3605                 esac
3606         done
3607 fi
3608
3609 # add the variations for the package we are looking for
3610 CF_SUBDIR_PATH($1,$2,include)
3611
3612 test "$includedir" != NONE && \
3613 test "$includedir" != "/usr/include" && \
3614 test -d "$includedir" && {
3615         test -d $includedir &&    $1="[$]$1 $includedir"
3616         test -d $includedir/$2 && $1="[$]$1 $includedir/$2"
3617 }
3618
3619 test "$oldincludedir" != NONE && \
3620 test "$oldincludedir" != "/usr/include" && \
3621 test -d "$oldincludedir" && {
3622         test -d $oldincludedir    && $1="[$]$1 $oldincludedir"
3623         test -d $oldincludedir/$2 && $1="[$]$1 $oldincludedir/$2"
3624 }
3625
3626 $1="[$]$1 $cf_header_path_list"
3627 ])dnl
3628 dnl ---------------------------------------------------------------------------
3629 dnl CF_HELP_MESSAGE version: 4 updated: 2019/12/31 08:53:54
3630 dnl ---------------
3631 dnl Insert text into the help-message, for readability, from AC_ARG_WITH.
3632 AC_DEFUN([CF_HELP_MESSAGE],
3633 [CF_ACVERSION_CHECK(2.53,[],[
3634 AC_DIVERT_HELP($1)])dnl
3635 ])dnl
3636 dnl ---------------------------------------------------------------------------
3637 dnl CF_INCLUDE_DIRS version: 10 updated: 2014/09/19 20:58:42
3638 dnl ---------------
3639 dnl Construct the list of include-options according to whether we're building
3640 dnl in the source directory or using '--srcdir=DIR' option.
3641 AC_DEFUN([CF_INCLUDE_DIRS],
3642 [
3643 if test "$srcdir" != "."; then
3644         CPPFLAGS="-I\${srcdir}/../include $CPPFLAGS"
3645 fi
3646 CPPFLAGS="-I../include $CPPFLAGS"
3647 if test "$srcdir" != "."; then
3648         CPPFLAGS="-I\${srcdir} $CPPFLAGS"
3649 fi
3650 CPPFLAGS="-I. $CPPFLAGS"
3651 AC_SUBST(CPPFLAGS)
3652 ])dnl
3653 dnl ---------------------------------------------------------------------------
3654 dnl CF_INSTALL_OPTS version: 2 updated: 2018/08/18 12:19:21
3655 dnl ---------------
3656 dnl prompt for/fill-in useful install-program options
3657 AC_DEFUN([CF_INSTALL_OPTS],
3658 [
3659 CF_INSTALL_OPT_S
3660 CF_INSTALL_OPT_P
3661 CF_INSTALL_OPT_O
3662 ])dnl
3663 dnl ---------------------------------------------------------------------------
3664 dnl CF_INSTALL_OPT_O version: 2 updated: 2015/05/15 19:45:35
3665 dnl ----------------
3666 dnl Almost all "install" programs default to the current user's ownership.
3667 dnl Almost - MINIX is an exception.
3668 AC_DEFUN([CF_INSTALL_OPT_O],
3669 [
3670 AC_MSG_CHECKING(if install needs to be told about ownership)
3671 case `$ac_config_guess` in
3672 (*minix)
3673         with_install_o=yes
3674         ;;
3675 (*)
3676         with_install_o=no
3677         ;;
3678 esac
3679
3680 AC_MSG_RESULT($with_install_o)
3681 if test "x$with_install_o" = xyes
3682 then
3683         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'`
3684 else
3685         INSTALL_OPT_O=
3686 fi
3687
3688 AC_SUBST(INSTALL_OPT_O)
3689 ])dnl
3690 dnl ---------------------------------------------------------------------------
3691 dnl CF_INSTALL_OPT_P version: 1 updated: 2018/08/18 12:19:21
3692 dnl ----------------
3693 dnl Some install-programs accept a "-p" option to preserve file modification
3694 dnl timestamps.  That can be useful as an install option, as well as a way to
3695 dnl avoid the need for ranlib after copying a static archive.
3696 AC_DEFUN([CF_INSTALL_OPT_P],
3697 [
3698 : ${INSTALL:=install}
3699 AC_CACHE_CHECK(if install accepts -p option, cf_cv_install_p,[
3700         rm -rf conftest*
3701         date >conftest.in
3702         mkdir conftest.out
3703         sleep 3
3704         if $INSTALL -p conftest.in conftest.out 2>/dev/null
3705         then
3706                 if test -f conftest.out/conftest.in
3707                 then
3708                         test conftest.in -nt conftest.out/conftest.in 2>conftest.err && \
3709                         test conftest.out/conftest.in -nt conftest.in 2>conftest.err
3710                         if test -s conftest.err
3711                         then
3712                                 cf_cv_install_p=no
3713                         else
3714                                 cf_cv_install_p=yes
3715                         fi
3716                 else
3717                         cf_cv_install_p=no
3718                 fi
3719         else
3720                 cf_cv_install_p=no
3721         fi
3722         rm -rf conftest*
3723 ])
3724 ])dnl
3725 dnl ---------------------------------------------------------------------------
3726 dnl CF_INSTALL_OPT_S version: 2 updated: 2018/08/18 12:19:21
3727 dnl ----------------
3728 dnl By default, we should strip executables which are installed, but leave the
3729 dnl ability to suppress that for unit-testing.
3730 AC_DEFUN([CF_INSTALL_OPT_S],
3731 [
3732 AC_MSG_CHECKING(if you want to install stripped executables)
3733 CF_ARG_DISABLE(stripping,
3734         [  --disable-stripping     do not strip (debug info) installed executables],
3735         [with_stripping=no],
3736         [with_stripping=yes])
3737 AC_MSG_RESULT($with_stripping)
3738
3739 if test "$with_stripping" = yes
3740 then
3741         INSTALL_OPT_S="-s"
3742 else
3743         INSTALL_OPT_S=
3744 fi
3745 AC_SUBST(INSTALL_OPT_S)
3746 ])dnl
3747 dnl ---------------------------------------------------------------------------
3748 dnl CF_INTEL_COMPILER version: 7 updated: 2015/04/12 15:39:00
3749 dnl -----------------
3750 dnl Check if the given compiler is really the Intel compiler for Linux.  It
3751 dnl tries to imitate gcc, but does not return an error when it finds a mismatch
3752 dnl between prototypes, e.g., as exercised by CF_MISSING_CHECK.
3753 dnl
3754 dnl This macro should be run "soon" after AC_PROG_CC or AC_PROG_CPLUSPLUS, to
3755 dnl ensure that it is not mistaken for gcc/g++.  It is normally invoked from
3756 dnl the wrappers for gcc and g++ warnings.
3757 dnl
3758 dnl $1 = GCC (default) or GXX
3759 dnl $2 = INTEL_COMPILER (default) or INTEL_CPLUSPLUS
3760 dnl $3 = CFLAGS (default) or CXXFLAGS
3761 AC_DEFUN([CF_INTEL_COMPILER],[
3762 AC_REQUIRE([AC_CANONICAL_HOST])
3763 ifelse([$2],,INTEL_COMPILER,[$2])=no