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