aclocal.m4

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