aclocal.m4

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