aclocal.m4

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