aclocal.m4

   1 dnl***************************************************************************
   2 dnl Copyright (c) 1998-2013,2014 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.718 2014/11/16 00:08:34 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: 3 updated: 2002/10/27 23:21:42
  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_ACVERSION_CHECK version: 5 updated: 2014/06/04 19:11:49
  66 dnl ------------------
  67 dnl Conditionally generate script according to whether we're using a given autoconf.
  68 dnl
  69 dnl $1 = version to compare against
  70 dnl $2 = code to use if AC_ACVERSION is at least as high as $1.
  71 dnl $3 = code to use if AC_ACVERSION is older than $1.
  72 define([CF_ACVERSION_CHECK],
  73 [
  74 ifdef([AC_ACVERSION], ,[ifdef([AC_AUTOCONF_VERSION],[m4_copy([AC_AUTOCONF_VERSION],[AC_ACVERSION])],[m4_copy([m4_PACKAGE_VERSION],[AC_ACVERSION])])])dnl
  75 ifdef([m4_version_compare],
  76 [m4_if(m4_version_compare(m4_defn([AC_ACVERSION]), [$1]), -1, [$3], [$2])],
  77 [CF_ACVERSION_COMPARE(
  78 AC_PREREQ_CANON(AC_PREREQ_SPLIT([$1])),
  79 AC_PREREQ_CANON(AC_PREREQ_SPLIT(AC_ACVERSION)), AC_ACVERSION, [$2], [$3])])])dnl
  80 dnl ---------------------------------------------------------------------------
  81 dnl CF_ACVERSION_COMPARE version: 3 updated: 2012/10/03 18:39:53
  82 dnl --------------------
  83 dnl CF_ACVERSION_COMPARE(MAJOR1, MINOR1, TERNARY1,
  84 dnl                      MAJOR2, MINOR2, TERNARY2,
  85 dnl                      PRINTABLE2, not FOUND, FOUND)
  86 define([CF_ACVERSION_COMPARE],
  87 [ifelse(builtin([eval], [$2 < $5]), 1,
  88 [ifelse([$8], , ,[$8])],
  89 [ifelse([$9], , ,[$9])])])dnl
  90 dnl ---------------------------------------------------------------------------
  91 dnl CF_ADA_INCLUDE_DIRS version: 8 updated: 2013/10/14 04:24:07
  92 dnl -------------------
  93 dnl Construct the list of include-options for the C programs in the Ada95
  94 dnl binding.
  95 AC_DEFUN([CF_ADA_INCLUDE_DIRS],
  96 [
  97 ACPPFLAGS="-I. -I../include -I../../include $ACPPFLAGS"
  98 if test "$srcdir" != "."; then
  99         ACPPFLAGS="-I\${srcdir}/../../include $ACPPFLAGS"
 100 fi
 101 if test "$GCC" != yes; then
 102         ACPPFLAGS="$ACPPFLAGS -I\${includedir}"
 103 elif test "$includedir" != "/usr/include"; then
 104         if test "$includedir" = '${prefix}/include' ; then
 105                 if test x$prefix != x/usr ; then
 106                         ACPPFLAGS="$ACPPFLAGS -I\${includedir}"
 107                 fi
 108         else
 109                 ACPPFLAGS="$ACPPFLAGS -I\${includedir}"
 110         fi
 111 fi
 112 AC_SUBST(ACPPFLAGS)
 113 ])dnl
 114 dnl ---------------------------------------------------------------------------
 115 dnl CF_ADD_ADAFLAGS version: 1 updated: 2010/06/19 15:22:18
 116 dnl ---------------
 117 dnl Add to $ADAFLAGS, which is substituted into makefile and scripts.
 118 AC_DEFUN([CF_ADD_ADAFLAGS],[
 119         ADAFLAGS="$ADAFLAGS $1"
 120         AC_SUBST(ADAFLAGS)
 121 ])dnl
 122 dnl ---------------------------------------------------------------------------
 123 dnl CF_ADD_CFLAGS version: 11 updated: 2014/07/22 05:32:57
 124 dnl -------------
 125 dnl Copy non-preprocessor flags to $CFLAGS, preprocessor flags to $CPPFLAGS
 126 dnl The second parameter if given makes this macro verbose.
 127 dnl
 128 dnl Put any preprocessor definitions that use quoted strings in $EXTRA_CPPFLAGS,
 129 dnl to simplify use of $CPPFLAGS in compiler checks, etc., that are easily
 130 dnl confused by the quotes (which require backslashes to keep them usable).
 131 AC_DEFUN([CF_ADD_CFLAGS],
 132 [
 133 cf_fix_cppflags=no
 134 cf_new_cflags=
 135 cf_new_cppflags=
 136 cf_new_extra_cppflags=
 137
 138 for cf_add_cflags in $1
 139 do
 140 case $cf_fix_cppflags in
 141 no)
 142         case $cf_add_cflags in #(vi
 143         -undef|-nostdinc*|-I*|-D*|-U*|-E|-P|-C) #(vi
 144                 case $cf_add_cflags in
 145                 -D*)
 146                         cf_tst_cflags=`echo ${cf_add_cflags} |sed -e 's/^-D[[^=]]*='\''\"[[^"]]*//'`
 147
 148                         test "x${cf_add_cflags}" != "x${cf_tst_cflags}" \
 149                                 && test -z "${cf_tst_cflags}" \
 150                                 && cf_fix_cppflags=yes
 151
 152                         if test $cf_fix_cppflags = yes ; then
 153                                 cf_new_extra_cppflags="$cf_new_extra_cppflags $cf_add_cflags"
 154                                 continue
 155                         elif test "${cf_tst_cflags}" = "\"'" ; then
 156                                 cf_new_extra_cppflags="$cf_new_extra_cppflags $cf_add_cflags"
 157                                 continue
 158                         fi
 159                         ;;
 160                 esac
 161                 case "$CPPFLAGS" in
 162                 *$cf_add_cflags) #(vi
 163                         ;;
 164                 *) #(vi
 165                         case $cf_add_cflags in #(vi
 166                         -D*)
 167                                 cf_tst_cppflags=`echo "x$cf_add_cflags" | sed -e 's/^...//' -e 's/=.*//'`
 168                                 CF_REMOVE_DEFINE(CPPFLAGS,$CPPFLAGS,$cf_tst_cppflags)
 169                                 ;;
 170                         esac
 171                         cf_new_cppflags="$cf_new_cppflags $cf_add_cflags"
 172                         ;;
 173                 esac
 174                 ;;
 175         *)
 176                 cf_new_cflags="$cf_new_cflags $cf_add_cflags"
 177                 ;;
 178         esac
 179         ;;
 180 yes)
 181         cf_new_extra_cppflags="$cf_new_extra_cppflags $cf_add_cflags"
 182
 183         cf_tst_cflags=`echo ${cf_add_cflags} |sed -e 's/^[[^"]]*"'\''//'`
 184
 185         test "x${cf_add_cflags}" != "x${cf_tst_cflags}" \
 186                 && test -z "${cf_tst_cflags}" \
 187                 && cf_fix_cppflags=no
 188         ;;
 189 esac
 190 done
 191
 192 if test -n "$cf_new_cflags" ; then
 193         ifelse([$2],,,[CF_VERBOSE(add to \$CFLAGS $cf_new_cflags)])
 194         CFLAGS="$CFLAGS $cf_new_cflags"
 195 fi
 196
 197 if test -n "$cf_new_cppflags" ; then
 198         ifelse([$2],,,[CF_VERBOSE(add to \$CPPFLAGS $cf_new_cppflags)])
 199         CPPFLAGS="$CPPFLAGS $cf_new_cppflags"
 200 fi
 201
 202 if test -n "$cf_new_extra_cppflags" ; then
 203         ifelse([$2],,,[CF_VERBOSE(add to \$EXTRA_CPPFLAGS $cf_new_extra_cppflags)])
 204         EXTRA_CPPFLAGS="$cf_new_extra_cppflags $EXTRA_CPPFLAGS"
 205 fi
 206
 207 AC_SUBST(EXTRA_CPPFLAGS)
 208
 209 ])dnl
 210 dnl ---------------------------------------------------------------------------
 211 dnl CF_ADD_INCDIR version: 13 updated: 2010/05/26 16:44:57
 212 dnl -------------
 213 dnl Add an include-directory to $CPPFLAGS.  Don't add /usr/include, since it's
 214 dnl redundant.  We don't normally need to add -I/usr/local/include for gcc,
 215 dnl but old versions (and some misinstalled ones) need that.  To make things
 216 dnl worse, gcc 3.x may give error messages if -I/usr/local/include is added to
 217 dnl the include-path).
 218 AC_DEFUN([CF_ADD_INCDIR],
 219 [
 220 if test -n "$1" ; then
 221   for cf_add_incdir in $1
 222   do
 223         while test $cf_add_incdir != /usr/include
 224         do
 225           if test -d $cf_add_incdir
 226           then
 227                 cf_have_incdir=no
 228                 if test -n "$CFLAGS$CPPFLAGS" ; then
 229                   # a loop is needed to ensure we can add subdirs of existing dirs
 230                   for cf_test_incdir in $CFLAGS $CPPFLAGS ; do
 231                         if test ".$cf_test_incdir" = ".-I$cf_add_incdir" ; then
 232                           cf_have_incdir=yes; break
 233                         fi
 234                   done
 235                 fi
 236
 237                 if test "$cf_have_incdir" = no ; then
 238                   if test "$cf_add_incdir" = /usr/local/include ; then
 239                         if test "$GCC" = yes
 240                         then
 241                           cf_save_CPPFLAGS=$CPPFLAGS
 242                           CPPFLAGS="$CPPFLAGS -I$cf_add_incdir"
 243                           AC_TRY_COMPILE([#include <stdio.h>],
 244                                   [printf("Hello")],
 245                                   [],
 246                                   [cf_have_incdir=yes])
 247                           CPPFLAGS=$cf_save_CPPFLAGS
 248                         fi
 249                   fi
 250                 fi
 251
 252                 if test "$cf_have_incdir" = no ; then
 253                   CF_VERBOSE(adding $cf_add_incdir to include-path)
 254                   ifelse([$2],,CPPFLAGS,[$2])="$ifelse([$2],,CPPFLAGS,[$2]) -I$cf_add_incdir"
 255
 256                   cf_top_incdir=`echo $cf_add_incdir | sed -e 's%/include/.*$%/include%'`
 257                   test "$cf_top_incdir" = "$cf_add_incdir" && break
 258                   cf_add_incdir="$cf_top_incdir"
 259                 else
 260                   break
 261                 fi
 262           fi
 263         done
 264   done
 265 fi
 266 ])dnl
 267 dnl ---------------------------------------------------------------------------
 268 dnl CF_ADD_LIB version: 2 updated: 2010/06/02 05:03:05
 269 dnl ----------
 270 dnl Add a library, used to enforce consistency.
 271 dnl
 272 dnl $1 = library to add, without the "-l"
 273 dnl $2 = variable to update (default $LIBS)
 274 AC_DEFUN([CF_ADD_LIB],[CF_ADD_LIBS(-l$1,ifelse($2,,LIBS,[$2]))])dnl
 275 dnl ---------------------------------------------------------------------------
 276 dnl CF_ADD_LIBDIR version: 9 updated: 2010/05/26 16:44:57
 277 dnl -------------
 278 dnl     Adds to the library-path
 279 dnl
 280 dnl     Some machines have trouble with multiple -L options.
 281 dnl
 282 dnl $1 is the (list of) directory(s) to add
 283 dnl $2 is the optional name of the variable to update (default LDFLAGS)
 284 dnl
 285 AC_DEFUN([CF_ADD_LIBDIR],
 286 [
 287 if test -n "$1" ; then
 288   for cf_add_libdir in $1
 289   do
 290     if test $cf_add_libdir = /usr/lib ; then
 291       :
 292     elif test -d $cf_add_libdir
 293     then
 294       cf_have_libdir=no
 295       if test -n "$LDFLAGS$LIBS" ; then
 296         # a loop is needed to ensure we can add subdirs of existing dirs
 297         for cf_test_libdir in $LDFLAGS $LIBS ; do
 298           if test ".$cf_test_libdir" = ".-L$cf_add_libdir" ; then
 299             cf_have_libdir=yes; break
 300           fi
 301         done
 302       fi
 303       if test "$cf_have_libdir" = no ; then
 304         CF_VERBOSE(adding $cf_add_libdir to library-path)
 305         ifelse([$2],,LDFLAGS,[$2])="-L$cf_add_libdir $ifelse([$2],,LDFLAGS,[$2])"
 306       fi
 307     fi
 308   done
 309 fi
 310 ])dnl
 311 dnl ---------------------------------------------------------------------------
 312 dnl CF_ADD_LIBS version: 2 updated: 2014/07/13 14:33:27
 313 dnl -----------
 314 dnl Add one or more libraries, used to enforce consistency.  Libraries are
 315 dnl prepended to an existing list, since their dependencies are assumed to
 316 dnl already exist in the list.
 317 dnl
 318 dnl $1 = libraries to add, with the "-l", etc.
 319 dnl $2 = variable to update (default $LIBS)
 320 AC_DEFUN([CF_ADD_LIBS],[
 321 cf_add_libs="$1"
 322 # Filter out duplicates - this happens with badly-designed ".pc" files...
 323 for cf_add_1lib in [$]ifelse($2,,LIBS,[$2])
 324 do
 325         for cf_add_2lib in $cf_add_libs
 326         do
 327                 if test "x$cf_add_1lib" = "x$cf_add_2lib"
 328                 then
 329                         cf_add_1lib=
 330                         break
 331                 fi
 332         done
 333         test -n "$cf_add_1lib" && cf_add_libs="$cf_add_libs $cf_add_1lib"
 334 done
 335 ifelse($2,,LIBS,[$2])="$cf_add_libs"
 336 ])dnl
 337 dnl ---------------------------------------------------------------------------
 338 dnl CF_ADD_SUBDIR_PATH version: 4 updated: 2013/10/08 17:47:05
 339 dnl ------------------
 340 dnl Append to a search-list for a nonstandard header/lib-file
 341 dnl     $1 = the variable to return as result
 342 dnl     $2 = the package name
 343 dnl     $3 = the subdirectory, e.g., bin, include or lib
 344 dnl $4 = the directory under which we will test for subdirectories
 345 dnl $5 = a directory that we do not want $4 to match
 346 AC_DEFUN([CF_ADD_SUBDIR_PATH],
 347 [
 348 test "x$4" != "x$5" && \
 349 test -d "$4" && \
 350 ifelse([$5],NONE,,[(test -z "$5" || test x$5 = xNONE || test "x$4" != "x$5") &&]) {
 351         test -n "$verbose" && echo "    ... testing for $3-directories under $4"
 352         test -d $4/$3 &&          $1="[$]$1 $4/$3"
 353         test -d $4/$3/$2 &&       $1="[$]$1 $4/$3/$2"
 354         test -d $4/$3/$2/$3 &&    $1="[$]$1 $4/$3/$2/$3"
 355         test -d $4/$2/$3 &&       $1="[$]$1 $4/$2/$3"
 356         test -d $4/$2/$3/$2 &&    $1="[$]$1 $4/$2/$3/$2"
 357 }
 358 ])dnl
 359 dnl ---------------------------------------------------------------------------
 360 dnl CF_ARG_DISABLE version: 3 updated: 1999/03/30 17:24:31
 361 dnl --------------
 362 dnl Allow user to disable a normally-on option.
 363 AC_DEFUN([CF_ARG_DISABLE],
 364 [CF_ARG_OPTION($1,[$2],[$3],[$4],yes)])dnl
 365 dnl ---------------------------------------------------------------------------
 366 dnl CF_ARG_OPTION version: 4 updated: 2010/05/26 05:38:42
 367 dnl -------------
 368 dnl Restricted form of AC_ARG_ENABLE that ensures user doesn't give bogus
 369 dnl values.
 370 dnl
 371 dnl Parameters:
 372 dnl $1 = option name
 373 dnl $2 = help-string
 374 dnl $3 = action to perform if option is not default
 375 dnl $4 = action if perform if option is default
 376 dnl $5 = default option value (either 'yes' or 'no')
 377 AC_DEFUN([CF_ARG_OPTION],
 378 [AC_ARG_ENABLE([$1],[$2],[test "$enableval" != ifelse([$5],no,yes,no) && enableval=ifelse([$5],no,no,yes)
 379   if test "$enableval" != "$5" ; then
 380 ifelse([$3],,[    :]dnl
 381 ,[    $3]) ifelse([$4],,,[
 382   else
 383     $4])
 384   fi],[enableval=$5 ifelse([$4],,,[
 385   $4
 386 ])dnl
 387   ])])dnl
 388 dnl ---------------------------------------------------------------------------
 389 dnl CF_AR_FLAGS version: 5 updated: 2010/05/20 20:24:29
 390 dnl -----------
 391 dnl Check for suitable "ar" (archiver) options for updating an archive.
 392 AC_DEFUN([CF_AR_FLAGS],[
 393 AC_REQUIRE([CF_PROG_AR])
 394
 395 AC_CACHE_CHECK(for options to update archives, cf_cv_ar_flags,[
 396         cf_cv_ar_flags=unknown
 397         for cf_ar_flags in -curv curv -crv crv -cqv cqv -rv rv
 398         do
 399
 400                 # check if $ARFLAGS already contains this choice
 401                 if test "x$ARFLAGS" != "x" ; then
 402                         cf_check_ar_flags=`echo "x$ARFLAGS" | sed -e "s/$cf_ar_flags\$//" -e "s/$cf_ar_flags / /"`
 403                         if test "x$ARFLAGS" != "$cf_check_ar_flags" ; then
 404                                 cf_cv_ar_flags=
 405                                 break
 406                         fi
 407                 fi
 408
 409                 rm -f conftest.$ac_cv_objext
 410                 rm -f conftest.a
 411
 412                 cat >conftest.$ac_ext <<EOF
 413 #line __oline__ "configure"
 414 int     testdata[[3]] = { 123, 456, 789 };
 415 EOF
 416                 if AC_TRY_EVAL(ac_compile) ; then
 417                         echo "$AR $ARFLAGS $cf_ar_flags conftest.a conftest.$ac_cv_objext" >&AC_FD_CC
 418                         $AR $ARFLAGS $cf_ar_flags conftest.a conftest.$ac_cv_objext 2>&AC_FD_CC 1>/dev/null
 419                         if test -f conftest.a ; then
 420                                 cf_cv_ar_flags=$cf_ar_flags
 421                                 break
 422                         fi
 423                 else
 424                         CF_VERBOSE(cannot compile test-program)
 425                         break
 426                 fi
 427         done
 428         rm -f conftest.a conftest.$ac_ext conftest.$ac_cv_objext
 429 ])
 430
 431 if test -n "$ARFLAGS" ; then
 432         if test -n "$cf_cv_ar_flags" ; then
 433                 ARFLAGS="$ARFLAGS $cf_cv_ar_flags"
 434         fi
 435 else
 436         ARFLAGS=$cf_cv_ar_flags
 437 fi
 438
 439 AC_SUBST(ARFLAGS)
 440 ])
 441 dnl ---------------------------------------------------------------------------
 442 dnl CF_AWK_BIG_PRINTF version: 4 updated: 2011/10/30 17:09:50
 443 dnl -----------------
 444 dnl Check if awk can handle big strings using printf.  Some older versions of
 445 dnl awk choke on large strings passed via "%s".
 446 dnl
 447 dnl $1 = desired string size
 448 dnl $2 = variable to set with result
 449 AC_DEFUN([CF_AWK_BIG_PRINTF],
 450 [
 451         case x$AWK in #(vi
 452         x)
 453                 eval $2=no
 454                 ;;
 455         *) #(vi
 456                 if ( ${AWK} 'BEGIN { xx = "x"; while (length(xx) < $1) { xx = xx "x"; }; printf("%s\n", xx); }' 2>/dev/null \
 457                         | $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
 458                         eval $2=yes
 459                 else
 460                         eval $2=no
 461                 fi
 462                 ;;
 463         esac
 464 ])dnl
 465 dnl ---------------------------------------------------------------------------
 466 dnl CF_BOOL_DECL version: 8 updated: 2004/01/30 15:51:18
 467 dnl ------------
 468 dnl Test if 'bool' is a builtin type in the configured C++ compiler.  Some
 469 dnl older compilers (e.g., gcc 2.5.8) don't support 'bool' directly; gcc
 470 dnl 2.6.3 does, in anticipation of the ANSI C++ standard.
 471 dnl
 472 dnl Treat the configuration-variable specially here, since we're directly
 473 dnl substituting its value (i.e., 1/0).
 474 dnl
 475 dnl $1 is the shell variable to store the result in, if not $cv_cv_builtin_bool
 476 AC_DEFUN([CF_BOOL_DECL],
 477 [
 478 AC_MSG_CHECKING(if we should include stdbool.h)
 479
 480 AC_CACHE_VAL(cf_cv_header_stdbool_h,[
 481         AC_TRY_COMPILE([],[bool foo = false],
 482                 [cf_cv_header_stdbool_h=0],
 483                 [AC_TRY_COMPILE([
 484 #ifndef __BEOS__
 485 #include <stdbool.h>
 486 #endif
 487 ],[bool foo = false],
 488                         [cf_cv_header_stdbool_h=1],
 489                         [cf_cv_header_stdbool_h=0])])])
 490
 491 if test "$cf_cv_header_stdbool_h" = 1
 492 then    AC_MSG_RESULT(yes)
 493 else    AC_MSG_RESULT(no)
 494 fi
 495
 496 AC_MSG_CHECKING([for builtin bool type])
 497
 498 AC_CACHE_VAL(ifelse($1,,cf_cv_builtin_bool,[$1]),[
 499         AC_TRY_COMPILE([
 500 #include <stdio.h>
 501 #include <sys/types.h>
 502 ],[bool x = false],
 503                 [ifelse($1,,cf_cv_builtin_bool,[$1])=1],
 504                 [ifelse($1,,cf_cv_builtin_bool,[$1])=0])
 505         ])
 506
 507 if test "$ifelse($1,,cf_cv_builtin_bool,[$1])" = 1
 508 then    AC_MSG_RESULT(yes)
 509 else    AC_MSG_RESULT(no)
 510 fi
 511 ])dnl
 512 dnl ---------------------------------------------------------------------------
 513 dnl CF_BOOL_SIZE version: 13 updated: 2013/04/13 18:03:21
 514 dnl ------------
 515 dnl Test for the size of 'bool' in the configured C++ compiler (e.g., a type).
 516 dnl Don't bother looking for bool.h, since it's been deprecated.
 517 dnl
 518 dnl If the current compiler is C rather than C++, we get the bool definition
 519 dnl from <stdbool.h>.
 520 AC_DEFUN([CF_BOOL_SIZE],
 521 [
 522 AC_MSG_CHECKING([for size of bool])
 523 AC_CACHE_VAL(cf_cv_type_of_bool,[
 524         rm -f cf_test.out
 525         AC_TRY_RUN([
 526 #include <stdlib.h>
 527 #include <stdio.h>
 528
 529 #if defined(__cplusplus)
 530
 531 #ifdef HAVE_GXX_BUILTIN_H
 532 #include <g++/builtin.h>
 533 #elif HAVE_GPP_BUILTIN_H
 534 #include <gpp/builtin.h>
 535 #elif HAVE_BUILTIN_H
 536 #include <builtin.h>
 537 #endif
 538
 539 #else
 540
 541 #if $cf_cv_header_stdbool_h
 542 #include <stdbool.h>
 543 #endif
 544
 545 #endif
 546
 547 int main()
 548 {
 549         FILE *fp = fopen("cf_test.out", "w");
 550         if (fp != 0) {
 551                 bool x = true;
 552                 if ((bool)(-x) >= 0)
 553                         fputs("unsigned ", fp);
 554                 if (sizeof(x) == sizeof(int))       fputs("int",  fp);
 555                 else if (sizeof(x) == sizeof(char)) fputs("char", fp);
 556                 else if (sizeof(x) == sizeof(short))fputs("short",fp);
 557                 else if (sizeof(x) == sizeof(long)) fputs("long", fp);
 558                 fclose(fp);
 559         }
 560         ${cf_cv_main_return:-return}(0);
 561 }
 562                 ],
 563                 [cf_cv_type_of_bool=`cat cf_test.out`
 564                  if test -z "$cf_cv_type_of_bool"; then
 565                    cf_cv_type_of_bool=unknown
 566                  fi],
 567                 [cf_cv_type_of_bool=unknown],
 568                 [cf_cv_type_of_bool=unknown])
 569         ])
 570         rm -f cf_test.out
 571 AC_MSG_RESULT($cf_cv_type_of_bool)
 572 if test "$cf_cv_type_of_bool" = unknown ; then
 573         case .$NCURSES_BOOL in #(vi
 574         .auto|.) NCURSES_BOOL=unsigned;;
 575         esac
 576         AC_MSG_WARN(Assuming $NCURSES_BOOL for type of bool)
 577         cf_cv_type_of_bool=$NCURSES_BOOL
 578 fi
 579 ])dnl
 580 dnl ---------------------------------------------------------------------------
 581 dnl CF_BUILD_CC version: 7 updated: 2012/10/06 15:31:55
 582 dnl -----------
 583 dnl If we're cross-compiling, allow the user to override the tools and their
 584 dnl options.  The configure script is oriented toward identifying the host
 585 dnl compiler, etc., but we need a build compiler to generate parts of the
 586 dnl source.
 587 dnl
 588 dnl $1 = default for $CPPFLAGS
 589 dnl $2 = default for $LIBS
 590 AC_DEFUN([CF_BUILD_CC],[
 591 CF_ACVERSION_CHECK(2.52,,
 592         [AC_REQUIRE([CF_PROG_EXT])])
 593 if test "$cross_compiling" = yes ; then
 594
 595         # defaults that we might want to override
 596         : ${BUILD_CFLAGS:=''}
 597         : ${BUILD_CPPFLAGS:='ifelse([$1],,,[$1])'}
 598         : ${BUILD_LDFLAGS:=''}
 599         : ${BUILD_LIBS:='ifelse([$2],,,[$2])'}
 600         : ${BUILD_EXEEXT:='$x'}
 601         : ${BUILD_OBJEXT:='o'}
 602
 603         AC_ARG_WITH(build-cc,
 604                 [  --with-build-cc=XXX     the build C compiler ($BUILD_CC)],
 605                 [BUILD_CC="$withval"],
 606                 [AC_CHECK_PROGS(BUILD_CC, gcc cc cl)])
 607         AC_MSG_CHECKING(for native build C compiler)
 608         AC_MSG_RESULT($BUILD_CC)
 609
 610         AC_MSG_CHECKING(for native build C preprocessor)
 611         AC_ARG_WITH(build-cpp,
 612                 [  --with-build-cpp=XXX    the build C preprocessor ($BUILD_CPP)],
 613                 [BUILD_CPP="$withval"],
 614                 [BUILD_CPP='${BUILD_CC} -E'])
 615         AC_MSG_RESULT($BUILD_CPP)
 616
 617         AC_MSG_CHECKING(for native build C flags)
 618         AC_ARG_WITH(build-cflags,
 619                 [  --with-build-cflags=XXX the build C compiler-flags ($BUILD_CFLAGS)],
 620                 [BUILD_CFLAGS="$withval"])
 621         AC_MSG_RESULT($BUILD_CFLAGS)
 622
 623         AC_MSG_CHECKING(for native build C preprocessor-flags)
 624         AC_ARG_WITH(build-cppflags,
 625                 [  --with-build-cppflags=XXX the build C preprocessor-flags ($BUILD_CPPFLAGS)],
 626                 [BUILD_CPPFLAGS="$withval"])
 627         AC_MSG_RESULT($BUILD_CPPFLAGS)
 628
 629         AC_MSG_CHECKING(for native build linker-flags)
 630         AC_ARG_WITH(build-ldflags,
 631                 [  --with-build-ldflags=XXX the build linker-flags ($BUILD_LDFLAGS)],
 632                 [BUILD_LDFLAGS="$withval"])
 633         AC_MSG_RESULT($BUILD_LDFLAGS)
 634
 635         AC_MSG_CHECKING(for native build linker-libraries)
 636         AC_ARG_WITH(build-libs,
 637                 [  --with-build-libs=XXX   the build libraries (${BUILD_LIBS})],
 638                 [BUILD_LIBS="$withval"])
 639         AC_MSG_RESULT($BUILD_LIBS)
 640
 641         # this assumes we're on Unix.
 642         BUILD_EXEEXT=
 643         BUILD_OBJEXT=o
 644
 645         : ${BUILD_CC:='${CC}'}
 646
 647         if ( test "$BUILD_CC" = "$CC" || test "$BUILD_CC" = '${CC}' ) ; then
 648                 AC_MSG_ERROR([Cross-build requires two compilers.
 649 Use --with-build-cc to specify the native compiler.])
 650         fi
 651
 652 else
 653         : ${BUILD_CC:='${CC}'}
 654         : ${BUILD_CPP:='${CPP}'}
 655         : ${BUILD_CFLAGS:='${CFLAGS}'}
 656         : ${BUILD_CPPFLAGS:='${CPPFLAGS}'}
 657         : ${BUILD_LDFLAGS:='${LDFLAGS}'}
 658         : ${BUILD_LIBS:='${LIBS}'}
 659         : ${BUILD_EXEEXT:='$x'}
 660         : ${BUILD_OBJEXT:='o'}
 661 fi
 662
 663 AC_SUBST(BUILD_CC)
 664 AC_SUBST(BUILD_CPP)
 665 AC_SUBST(BUILD_CFLAGS)
 666 AC_SUBST(BUILD_CPPFLAGS)
 667 AC_SUBST(BUILD_LDFLAGS)
 668 AC_SUBST(BUILD_LIBS)
 669 AC_SUBST(BUILD_EXEEXT)
 670 AC_SUBST(BUILD_OBJEXT)
 671 ])dnl
 672 dnl ---------------------------------------------------------------------------
 673 dnl CF_CC_ENV_FLAGS version: 1 updated: 2012/10/03 05:25:49
 674 dnl ---------------
 675 dnl Check for user's environment-breakage by stuffing CFLAGS/CPPFLAGS content
 676 dnl into CC.  This will not help with broken scripts that wrap the compiler with
 677 dnl options, but eliminates a more common category of user confusion.
 678 AC_DEFUN([CF_CC_ENV_FLAGS],
 679 [
 680 # This should have been defined by AC_PROG_CC
 681 : ${CC:=cc}
 682
 683 AC_MSG_CHECKING(\$CC variable)
 684 case "$CC" in #(vi
 685 *[[\ \  ]]-[[IUD]]*)
 686         AC_MSG_RESULT(broken)
 687         AC_MSG_WARN(your environment misuses the CC variable to hold CFLAGS/CPPFLAGS options)
 688         # humor him...
 689         cf_flags=`echo "$CC" | sed -e 's/^[[^   ]]*[[   ]]//'`
 690         CC=`echo "$CC" | sed -e 's/[[   ]].*//'`
 691         CF_ADD_CFLAGS($cf_flags)
 692         ;;
 693 *)
 694         AC_MSG_RESULT(ok)
 695         ;;
 696 esac
 697 ])dnl
 698 dnl ---------------------------------------------------------------------------
 699 dnl CF_CFG_DEFAULTS version: 10 updated: 2013/09/07 13:54:05
 700 dnl ---------------
 701 dnl Determine the default configuration into which we'll install ncurses.  This
 702 dnl can be overridden by the user's command-line options.  There's two items to
 703 dnl look for:
 704 dnl     1. the prefix (e.g., /usr)
 705 dnl     2. the header files (e.g., /usr/include/ncurses)
 706 dnl We'll look for a previous installation of ncurses and use the same defaults.
 707 dnl
 708 dnl We don't use AC_PREFIX_DEFAULT, because it gets evaluated too soon, and
 709 dnl we don't use AC_PREFIX_PROGRAM, because we cannot distinguish ncurses's
 710 dnl programs from a vendor's.
 711 AC_DEFUN([CF_CFG_DEFAULTS],
 712 [
 713 AC_MSG_CHECKING(for prefix)
 714 if test "x$prefix" = "xNONE" ; then
 715         case "$cf_cv_system_name" in
 716                 # non-vendor systems don't have a conflict
 717         openbsd*|freebsd*|mirbsd*|linux*|cygwin*|msys*|k*bsd*-gnu|mingw*)
 718                 prefix=/usr
 719                 ;;
 720         *)      prefix=$ac_default_prefix
 721                 ;;
 722         esac
 723 fi
 724 AC_MSG_RESULT($prefix)
 725
 726 if test "x$prefix" = "xNONE" ; then
 727 AC_MSG_CHECKING(for default include-directory)
 728 test -n "$verbose" && echo 1>&AC_FD_MSG
 729 for cf_symbol in \
 730         $includedir \
 731         $includedir/ncurses \
 732         $prefix/include \
 733         $prefix/include/ncurses \
 734         /usr/local/include \
 735         /usr/local/include/ncurses \
 736         /usr/include \
 737         /usr/include/ncurses
 738 do
 739         cf_dir=`eval echo $cf_symbol`
 740         if test -f $cf_dir/curses.h ; then
 741         if ( fgrep NCURSES_VERSION $cf_dir/curses.h 2>&1 >/dev/null ) ; then
 742                 includedir="$cf_symbol"
 743                 test -n "$verbose"  && echo $ac_n "     found " 1>&AC_FD_MSG
 744                 break
 745         fi
 746         fi
 747         test -n "$verbose"  && echo "   tested $cf_dir" 1>&AC_FD_MSG
 748 done
 749 AC_MSG_RESULT($includedir)
 750 fi
 751 ])dnl
 752 dnl ---------------------------------------------------------------------------
 753 dnl CF_CGETENT version: 5 updated: 2012/10/06 17:56:13
 754 dnl ----------
 755 dnl Check if the terminal-capability database functions are available.  If not,
 756 dnl ncurses has a much-reduced version.
 757 AC_DEFUN([CF_CGETENT],[
 758 AC_CACHE_CHECK(for terminal-capability database functions,cf_cv_cgetent,[
 759 AC_TRY_LINK([
 760 #include <stdlib.h>],[
 761         char temp[128];
 762         char *buf = temp;
 763         char *db_array = temp;
 764         cgetent(&buf, &db_array, "vt100");
 765         cgetcap(buf, "tc", '=');
 766         cgetmatch(buf, "tc");
 767         ],
 768         [cf_cv_cgetent=yes],
 769         [cf_cv_cgetent=no])
 770 ])
 771
 772 if test "$cf_cv_cgetent" = yes
 773 then
 774         AC_DEFINE(HAVE_BSD_CGETENT,1,[Define to 1 if we have BSD cgetent])
 775 AC_CACHE_CHECK(if cgetent uses const parameter,cf_cv_cgetent_const,[
 776 AC_TRY_LINK([
 777 #include <stdlib.h>],[
 778         char temp[128];
 779         char *buf = temp;
 780 #ifndef _NETBSD_SOURCE                  /* given, since April 2004 in stdlib.h */
 781         const char *db_array = temp;
 782         cgetent(&buf, &db_array, "vt100");
 783 #endif
 784         cgetcap(buf, "tc", '=');
 785         cgetmatch(buf, "tc");
 786         ],
 787         [cf_cv_cgetent_const=yes],
 788         [cf_cv_cgetent_const=no])
 789 ])
 790         if test "$cf_cv_cgetent_const" = yes
 791         then
 792                 AC_DEFINE_UNQUOTED(CGETENT_CONST,const,[Define to const if needed for some BSD cgetent variations])
 793         fi
 794 fi
 795 ])dnl
 796 dnl ---------------------------------------------------------------------------
 797 dnl CF_CHECK_CACHE version: 12 updated: 2012/10/02 20:55:03
 798 dnl --------------
 799 dnl Check if we're accidentally using a cache from a different machine.
 800 dnl Derive the system name, as a check for reusing the autoconf cache.
 801 dnl
 802 dnl If we've packaged config.guess and config.sub, run that (since it does a
 803 dnl better job than uname).  Normally we'll use AC_CANONICAL_HOST, but allow
 804 dnl an extra parameter that we may override, e.g., for AC_CANONICAL_SYSTEM
 805 dnl which is useful in cross-compiles.
 806 dnl
 807 dnl Note: we would use $ac_config_sub, but that is one of the places where
 808 dnl autoconf 2.5x broke compatibility with autoconf 2.13
 809 AC_DEFUN([CF_CHECK_CACHE],
 810 [
 811 if test -f $srcdir/config.guess || test -f $ac_aux_dir/config.guess ; then
 812         ifelse([$1],,[AC_CANONICAL_HOST],[$1])
 813         system_name="$host_os"
 814 else
 815         system_name="`(uname -s -r) 2>/dev/null`"
 816         if test -z "$system_name" ; then
 817                 system_name="`(hostname) 2>/dev/null`"
 818         fi
 819 fi
 820 test -n "$system_name" && AC_DEFINE_UNQUOTED(SYSTEM_NAME,"$system_name",[Define to the system name.])
 821 AC_CACHE_VAL(cf_cv_system_name,[cf_cv_system_name="$system_name"])
 822
 823 test -z "$system_name" && system_name="$cf_cv_system_name"
 824 test -n "$cf_cv_system_name" && AC_MSG_RESULT(Configuring for $cf_cv_system_name)
 825
 826 if test ".$system_name" != ".$cf_cv_system_name" ; then
 827         AC_MSG_RESULT(Cached system name ($system_name) does not agree with actual ($cf_cv_system_name))
 828         AC_MSG_ERROR("Please remove config.cache and try again.")
 829 fi
 830 ])dnl
 831 dnl ---------------------------------------------------------------------------
 832 dnl CF_CHECK_ERRNO version: 11 updated: 2010/05/26 05:38:42
 833 dnl --------------
 834 dnl Check for data that is usually declared in <stdio.h> or <errno.h>, e.g.,
 835 dnl the 'errno' variable.  Define a DECL_xxx symbol if we must declare it
 836 dnl ourselves.
 837 dnl
 838 dnl $1 = the name to check
 839 dnl $2 = the assumed type
 840 AC_DEFUN([CF_CHECK_ERRNO],
 841 [
 842 AC_CACHE_CHECK(if external $1 is declared, cf_cv_dcl_$1,[
 843     AC_TRY_COMPILE([
 844 #ifdef HAVE_STDLIB_H
 845 #include <stdlib.h>
 846 #endif
 847 #include <stdio.h>
 848 #include <sys/types.h>
 849 #include <errno.h> ],
 850     ifelse([$2],,int,[$2]) x = (ifelse([$2],,int,[$2])) $1,
 851     [cf_cv_dcl_$1=yes],
 852     [cf_cv_dcl_$1=no])
 853 ])
 854
 855 if test "$cf_cv_dcl_$1" = no ; then
 856     CF_UPPER(cf_result,decl_$1)
 857     AC_DEFINE_UNQUOTED($cf_result)
 858 fi
 859
 860 # It's possible (for near-UNIX clones) that the data doesn't exist
 861 CF_CHECK_EXTERN_DATA($1,ifelse([$2],,int,[$2]))
 862 ])dnl
 863 dnl ---------------------------------------------------------------------------
 864 dnl CF_CHECK_EXTERN_DATA version: 3 updated: 2001/12/30 18:03:23
 865 dnl --------------------
 866 dnl Check for existence of external data in the current set of libraries.  If
 867 dnl we can modify it, it's real enough.
 868 dnl $1 = the name to check
 869 dnl $2 = its type
 870 AC_DEFUN([CF_CHECK_EXTERN_DATA],
 871 [
 872 AC_CACHE_CHECK(if external $1 exists, cf_cv_have_$1,[
 873     AC_TRY_LINK([
 874 #undef $1
 875 extern $2 $1;
 876 ],
 877     [$1 = 2],
 878     [cf_cv_have_$1=yes],
 879     [cf_cv_have_$1=no])
 880 ])
 881
 882 if test "$cf_cv_have_$1" = yes ; then
 883     CF_UPPER(cf_result,have_$1)
 884     AC_DEFINE_UNQUOTED($cf_result)
 885 fi
 886
 887 ])dnl
 888 dnl ---------------------------------------------------------------------------
 889 dnl CF_CHECK_GPM_WGETCH version: 2 updated: 2010/08/14 18:25:37
 890 dnl -------------------
 891 dnl Check if GPM is already linked with curses.  If so - and if the linkage
 892 dnl is not "weak" - warn about this because it can create problems linking
 893 dnl applications with ncurses.
 894 AC_DEFUN([CF_CHECK_GPM_WGETCH],[
 895 AC_CHECK_LIB(gpm,Gpm_Wgetch,[
 896
 897 AC_CACHE_CHECK(if GPM is weakly bound to curses library, cf_cv_check_gpm_wgetch,[
 898 cf_cv_check_gpm_wgetch=unknown
 899 if test "$cross_compiling" != yes ; then
 900
 901 cat >conftest.$ac_ext <<CF_EOF
 902 #include <gpm.h>
 903 int main()
 904 {
 905         Gpm_Wgetch();
 906         ${cf_cv_main_return:-return}(0);
 907 }
 908 CF_EOF
 909
 910         cf_save_LIBS="$LIBS"
 911         # This only works if we can look at the symbol table.  If a shared
 912         # library is stripped for install, we cannot use that.  So we're forced
 913         # to rely on the static library, noting that some packagers may not
 914         # include it.
 915         LIBS="-static -lgpm -dynamic $LIBS"
 916         if AC_TRY_EVAL(ac_compile) ; then
 917                 if AC_TRY_EVAL(ac_link) ; then
 918                         cf_cv_check_gpm_wgetch=`nm conftest$ac_exeext | egrep '\<wgetch\>' | egrep '\<[[vVwW]]\>'`
 919                         test -n "$cf_cv_check_gpm_wgetch" && cf_cv_check_gpm_wgetch=yes
 920                         test -z "$cf_cv_check_gpm_wgetch" && cf_cv_check_gpm_wgetch=no
 921                 fi
 922         fi
 923         rm -rf conftest*
 924         LIBS="$cf_save_LIBS"
 925 fi
 926 ])
 927
 928 if test "$cf_cv_check_gpm_wgetch" != yes ; then
 929         AC_MSG_WARN(GPM library is already linked with curses - read the FAQ)
 930 fi
 931 ])])dnl
 932 dnl ---------------------------------------------------------------------------
 933 dnl CF_CHECK_LIBTOOL_VERSION version: 1 updated: 2013/04/06 18:03:09
 934 dnl ------------------------
 935 dnl Show the version of libtool
 936 dnl
 937 dnl Save the version in a cache variable - this is not entirely a good thing,
 938 dnl but the version string from libtool is very ugly, and for bug reports it
 939 dnl might be useful to have the original string.
 940 AC_DEFUN([CF_CHECK_LIBTOOL_VERSION],[
 941 if test -n "$LIBTOOL" && test "$LIBTOOL" != none
 942 then
 943         AC_MSG_CHECKING(version of $LIBTOOL)
 944         CF_LIBTOOL_VERSION
 945         AC_MSG_RESULT($cf_cv_libtool_version)
 946         if test -z "$cf_cv_libtool_version" ; then
 947                 AC_MSG_ERROR(This is not GNU libtool)
 948         fi
 949 else
 950         AC_MSG_ERROR(GNU libtool has not been found)
 951 fi
 952 ])dnl
 953 dnl ---------------------------------------------------------------------------
 954 dnl CF_CHECK_WCHAR_H version: 1 updated: 2011/10/29 15:01:05
 955 dnl ----------------
 956 dnl Check if wchar.h can be used, i.e., without defining _XOPEN_SOURCE_EXTENDED
 957 AC_DEFUN([CF_CHECK_WCHAR_H],[
 958 AC_CACHE_CHECK(if wchar.h can be used as is,cf_cv_wchar_h_okay,[
 959 AC_TRY_COMPILE(
 960 [
 961 #include <stdlib.h>
 962 #include <wchar.h>
 963 ],[
 964         wint_t foo = 0;
 965         int bar = iswpunct(foo)],
 966         [cf_cv_wchar_h_okay=yes],
 967         [cf_cv_wchar_h_okay=no])])
 968
 969 if test $cf_cv_wchar_h_okay = no
 970 then
 971         CF_PREDEFINE(_XOPEN_SOURCE_EXTENDED)
 972 fi
 973 ])dnl
 974 dnl ---------------------------------------------------------------------------
 975 dnl CF_CLANG_COMPILER version: 2 updated: 2013/11/19 19:23:35
 976 dnl -----------------
 977 dnl Check if the given compiler is really clang.  clang's C driver defines
 978 dnl __GNUC__ (fooling the configure script into setting $GCC to yes) but does
 979 dnl not ignore some gcc options.
 980 dnl
 981 dnl This macro should be run "soon" after AC_PROG_CC or AC_PROG_CPLUSPLUS, to
 982 dnl ensure that it is not mistaken for gcc/g++.  It is normally invoked from
 983 dnl the wrappers for gcc and g++ warnings.
 984 dnl
 985 dnl $1 = GCC (default) or GXX
 986 dnl $2 = CLANG_COMPILER (default)
 987 dnl $3 = CFLAGS (default) or CXXFLAGS
 988 AC_DEFUN([CF_CLANG_COMPILER],[
 989 ifelse([$2],,CLANG_COMPILER,[$2])=no
 990
 991 if test "$ifelse([$1],,[$1],GCC)" = yes ; then
 992         AC_MSG_CHECKING(if this is really Clang ifelse([$1],GXX,C++,C) compiler)
 993         cf_save_CFLAGS="$ifelse([$3],,CFLAGS,[$3])"
 994         ifelse([$3],,CFLAGS,[$3])="$ifelse([$3],,CFLAGS,[$3]) -Qunused-arguments"
 995         AC_TRY_COMPILE([],[
 996 #ifdef __clang__
 997 #else
 998 make an error
 999 #endif
1000 ],[ifelse([$2],,CLANG_COMPILER,[$2])=yes
1001 cf_save_CFLAGS="$cf_save_CFLAGS -Qunused-arguments"
1002 ],[])
1003         ifelse([$3],,CFLAGS,[$3])="$cf_save_CFLAGS"
1004         AC_MSG_RESULT($ifelse([$2],,CLANG_COMPILER,[$2]))
1005 fi
1006 ])
1007 dnl ---------------------------------------------------------------------------
1008 dnl CF_CPP_PARAM_INIT version: 6 updated: 2012/10/06 17:56:13
1009 dnl -----------------
1010 dnl Check if the C++ compiler accepts duplicate parameter initialization.  This
1011 dnl is a late feature for the standard and is not in some recent compilers
1012 dnl (1999/9/11).
1013 AC_DEFUN([CF_CPP_PARAM_INIT],
1014 [
1015 if test -n "$CXX"; then
1016 AC_CACHE_CHECK(if $CXX accepts parameter initialization,cf_cv_cpp_param_init,[
1017         AC_LANG_SAVE
1018         AC_LANG_CPLUSPLUS
1019         AC_TRY_RUN([
1020 class TEST {
1021 private:
1022         int value;
1023 public:
1024         TEST(int x = 1);
1025         ~TEST();
1026 };
1027
1028 TEST::TEST(int x = 1)   // some compilers do not like second initializer
1029 {
1030         value = x;
1031 }
1032 int main() { }
1033 ],
1034         [cf_cv_cpp_param_init=yes],
1035         [cf_cv_cpp_param_init=no],
1036         [cf_cv_cpp_param_init=unknown])
1037         AC_LANG_RESTORE
1038 ])
1039 fi
1040 test "$cf_cv_cpp_param_init" = yes && AC_DEFINE(CPP_HAS_PARAM_INIT,1,[Define to 1 if C++ has parameter initialization])
1041 ])dnl
1042 dnl ---------------------------------------------------------------------------
1043 dnl CF_CPP_STATIC_CAST version: 3 updated: 2013/04/13 18:03:21
1044 dnl ------------------
1045 dnl Check if the C++ compiler accepts static_cast in generics.  This appears to
1046 dnl not be supported in g++ before 3.0
1047 AC_DEFUN([CF_CPP_STATIC_CAST],
1048 [
1049 if test -n "$CXX"; then
1050
1051 AC_CACHE_CHECK(if $CXX accepts static_cast,cf_cv_cpp_static_cast,[
1052         AC_LANG_SAVE
1053         AC_LANG_CPLUSPLUS
1054
1055         AC_TRY_COMPILE([
1056 class NCursesPanel
1057 {
1058 public:
1059   NCursesPanel(int nlines,
1060                int ncols,
1061                int begin_y = 0,
1062                int begin_x = 0)
1063   {
1064   }
1065   NCursesPanel();
1066   ~NCursesPanel();
1067 };
1068
1069 template<class T> class NCursesUserPanel : public NCursesPanel
1070 {
1071 public:
1072   NCursesUserPanel (int nlines,
1073                     int ncols,
1074                     int begin_y = 0,
1075                     int begin_x = 0,
1076                     const T* p_UserData = static_cast<T*>(0))
1077     : NCursesPanel (nlines, ncols, begin_y, begin_x)
1078   {
1079   };
1080   NCursesUserPanel(const T* p_UserData = static_cast<T*>(0)) : NCursesPanel()
1081   {
1082   };
1083
1084   virtual ~NCursesUserPanel() {};
1085 };
1086 ],[
1087         const char* p_UserData = static_cast<char*>(0)],
1088         [cf_cv_cpp_static_cast=yes],
1089         [cf_cv_cpp_static_cast=no])
1090
1091         AC_LANG_RESTORE
1092 ])
1093
1094 fi
1095
1096 test "$cf_cv_cpp_static_cast" = yes && AC_DEFINE(CPP_HAS_STATIC_CAST,1,[Define to 1 if C++ has static_cast])
1097 ])dnl
1098 dnl ---------------------------------------------------------------------------
1099 dnl CF_CXX_AR_FLAGS version: 1 updated: 2011/10/29 08:35:34
1100 dnl ---------------
1101 dnl Setup special archiver flags for given compilers.
1102 AC_DEFUN([CF_CXX_AR_FLAGS],[
1103         CXX_AR='$(AR)'
1104         CXX_ARFLAGS='$(ARFLAGS)'
1105         case $cf_cv_system_name in #(vi
1106         irix*) #(vi
1107             if test "$GXX" != yes ; then
1108                 CXX_AR='$(CXX)'
1109                 CXX_ARFLAGS='-ar -o'
1110             fi
1111             ;;
1112         sco3.2v5*) #(vi
1113             CXXLDFLAGS="-u main"
1114             ;;
1115         solaris2*)
1116             if test "$GXX" != yes ; then
1117                 CXX_AR='$(CXX)'
1118                 CXX_ARFLAGS='-xar -o'
1119             fi
1120             ;;
1121         esac
1122         AC_SUBST(CXXLDFLAGS)
1123         AC_SUBST(CXX_AR)
1124         AC_SUBST(CXX_ARFLAGS)
1125 ])dnl
1126 dnl ---------------------------------------------------------------------------
1127 dnl CF_CXX_IOSTREAM_NAMESPACE version: 2 updated: 2012/10/06 17:56:13
1128 dnl -------------------------
1129 dnl For c++, check if iostream uses "std::" namespace.
1130 AC_DEFUN([CF_CXX_IOSTREAM_NAMESPACE],[
1131 AC_CHECK_HEADERS(iostream)
1132 if test x"$ac_cv_header_iostream" = xyes ; then
1133         AC_MSG_CHECKING(if iostream uses std-namespace)
1134         AC_TRY_COMPILE([
1135 #include <iostream>
1136 using std::endl;
1137 using std::cerr;],[
1138 cerr << "testing" << endl;
1139 ],[cf_iostream_namespace=yes],[cf_iostream_namespace=no])
1140         AC_MSG_RESULT($cf_iostream_namespace)
1141         if test "$cf_iostream_namespace" = yes ; then
1142                 AC_DEFINE(IOSTREAM_NAMESPACE,1,[Define to 1 if C++ has namespace iostream])
1143         fi
1144 fi
1145 ])dnl
1146 dnl ---------------------------------------------------------------------------
1147 dnl CF_C_INLINE version: 4 updated: 2012/06/16 14:55:39
1148 dnl -----------
1149 dnl Check if the C compiler supports "inline".
1150 dnl $1 is the name of a shell variable to set if inline is supported
1151 dnl $2 is the threshold for gcc 4.x's option controlling maximum inline size
1152 AC_DEFUN([CF_C_INLINE],[
1153 AC_C_INLINE
1154 $1=
1155 if test "$ac_cv_c_inline" != no ; then
1156   $1=inline
1157   if test "$INTEL_COMPILER" = yes
1158   then
1159     :
1160   elif test "$CLANG_COMPILER" = yes
1161   then
1162     :
1163   elif test "$GCC" = yes
1164   then
1165     AC_CACHE_CHECK(if $CC supports options to tune inlining,cf_cv_gcc_inline,[
1166       cf_save_CFLAGS=$CFLAGS
1167       CFLAGS="$CFLAGS --param max-inline-insns-single=$2"
1168       AC_TRY_COMPILE([inline int foo(void) { return 1; }],
1169       [${cf_cv_main_return:-return} foo()],
1170       [cf_cv_gcc_inline=yes],
1171       [cf_cv_gcc_inline=no])
1172       CFLAGS=$cf_save_CFLAGS
1173     ])
1174     if test "$cf_cv_gcc_inline" = yes ; then
1175         CF_ADD_CFLAGS([--param max-inline-insns-single=$2])
1176     fi
1177   fi
1178 fi
1179 AC_SUBST($1)
1180 ])dnl
1181 dnl ---------------------------------------------------------------------------
1182 dnl CF_DIRNAME version: 4 updated: 2002/12/21 19:25:52
1183 dnl ----------
1184 dnl "dirname" is not portable, so we fake it with a shell script.
1185 AC_DEFUN([CF_DIRNAME],[$1=`echo $2 | sed -e 's%/[[^/]]*$%%'`])dnl
1186 dnl ---------------------------------------------------------------------------
1187 dnl CF_DIRS_TO_MAKE version: 3 updated: 2002/02/23 20:38:31
1188 dnl ---------------
1189 AC_DEFUN([CF_DIRS_TO_MAKE],
1190 [
1191 DIRS_TO_MAKE="lib"
1192 for cf_item in $cf_list_models
1193 do
1194         CF_OBJ_SUBDIR($cf_item,cf_subdir)
1195         for cf_item2 in $DIRS_TO_MAKE
1196         do
1197                 test $cf_item2 = $cf_subdir && break
1198         done
1199         test ".$cf_item2" != ".$cf_subdir" && DIRS_TO_MAKE="$DIRS_TO_MAKE $cf_subdir"
1200 done
1201 for cf_dir in $DIRS_TO_MAKE
1202 do
1203         test ! -d $cf_dir && mkdir $cf_dir
1204 done
1205 AC_SUBST(DIRS_TO_MAKE)
1206 ])dnl
1207 dnl ---------------------------------------------------------------------------
1208 dnl CF_DISABLE_ECHO version: 12 updated: 2012/10/06 16:30:28
1209 dnl ---------------
1210 dnl You can always use "make -n" to see the actual options, but it's hard to
1211 dnl pick out/analyze warning messages when the compile-line is long.
1212 dnl
1213 dnl Sets:
1214 dnl     ECHO_LT - symbol to control if libtool is verbose
1215 dnl     ECHO_LD - symbol to prefix "cc -o" lines
1216 dnl     RULE_CC - symbol to put before implicit "cc -c" lines (e.g., .c.o)
1217 dnl     SHOW_CC - symbol to put before explicit "cc -c" lines
1218 dnl     ECHO_CC - symbol to put before any "cc" line
1219 dnl
1220 AC_DEFUN([CF_DISABLE_ECHO],[
1221 AC_MSG_CHECKING(if you want to see long compiling messages)
1222 CF_ARG_DISABLE(echo,
1223         [  --disable-echo          do not display "compiling" commands],
1224         [
1225     ECHO_LT='--silent'
1226     ECHO_LD='@echo linking [$]@;'
1227     RULE_CC='@echo compiling [$]<'
1228     SHOW_CC='@echo compiling [$]@'
1229     ECHO_CC='@'
1230 ],[
1231     ECHO_LT=''
1232     ECHO_LD=''
1233     RULE_CC=''
1234     SHOW_CC=''
1235     ECHO_CC=''
1236 ])
1237 AC_MSG_RESULT($enableval)
1238 AC_SUBST(ECHO_LT)
1239 AC_SUBST(ECHO_LD)
1240 AC_SUBST(RULE_CC)
1241 AC_SUBST(SHOW_CC)
1242 AC_SUBST(ECHO_CC)
1243 ])dnl
1244 dnl ---------------------------------------------------------------------------
1245 dnl CF_DISABLE_GNAT_PROJECTS version: 1 updated: 2014/06/01 11:34:00
1246 dnl ------------------------
1247 AC_DEFUN([CF_DISABLE_GNAT_PROJECTS],[
1248 AC_MSG_CHECKING(if we want to use GNAT projects)
1249 CF_ARG_DISABLE(gnat-projects,
1250         [  --disable-gnat-projects test: disable GNAT projects even if usable],
1251         [enable_gnat_projects=no],
1252         [enable_gnat_projects=yes])
1253 AC_MSG_RESULT($enable_gnat_projects)
1254 ])dnl
1255 dnl ---------------------------------------------------------------------------
1256 dnl CF_DISABLE_LEAKS version: 7 updated: 2012/10/02 20:55:03
1257 dnl ----------------
1258 dnl Combine no-leak checks with the libraries or tools that are used for the
1259 dnl checks.
1260 AC_DEFUN([CF_DISABLE_LEAKS],[
1261
1262 AC_REQUIRE([CF_WITH_DMALLOC])
1263 AC_REQUIRE([CF_WITH_DBMALLOC])
1264 AC_REQUIRE([CF_WITH_VALGRIND])
1265
1266 AC_MSG_CHECKING(if you want to perform memory-leak testing)
1267 AC_ARG_ENABLE(leaks,
1268         [  --disable-leaks         test: free permanent memory, analyze leaks],
1269         [if test "x$enableval" = xno; then with_no_leaks=yes; else with_no_leaks=no; fi],
1270         : ${with_no_leaks:=no})
1271 AC_MSG_RESULT($with_no_leaks)
1272
1273 if test "$with_no_leaks" = yes ; then
1274         AC_DEFINE(NO_LEAKS,1,[Define to 1 if you want to perform memory-leak testing.])
1275         AC_DEFINE(YY_NO_LEAKS,1,[Define to 1 if you want to perform memory-leak testing.])
1276 fi
1277 ])dnl
1278 dnl ---------------------------------------------------------------------------
1279 dnl CF_DISABLE_LIBTOOL_VERSION version: 2 updated: 2014/11/15 19:05:29
1280 dnl --------------------------
1281 dnl Check if we should use the libtool 1.5 feature "-version-number" instead of
1282 dnl the older "-version-info" feature.  The newer feature allows us to use
1283 dnl version numbering on shared libraries which make them compatible with
1284 dnl various systems.
1285 AC_DEFUN([CF_DISABLE_LIBTOOL_VERSION],
1286 [
1287 AC_MSG_CHECKING(if libtool -version-number should be used)
1288 CF_ARG_DISABLE(libtool-version,
1289         [  --disable-libtool-version  enable to use libtool's incompatible naming scheme],
1290         [cf_libtool_version=no],
1291         [cf_libtool_version=yes])
1292 AC_MSG_RESULT($cf_libtool_version)
1293
1294 if test "$cf_libtool_version" = yes ; then
1295         LIBTOOL_VERSION="-version-number"
1296 else
1297         LIBTOOL_VERSION="-version-info"
1298         case "x$VERSION" in #(vi
1299         x) #(vi
1300                 AC_MSG_WARN(VERSION was not set)
1301                 ;;
1302         x*.*.*)
1303                 ABI_VERSION="$VERSION"
1304                 CF_VERBOSE(ABI_VERSION: $ABI_VERSION)
1305                 ;;
1306         x*:*:*)
1307                 ABI_VERSION=`echo "$VERSION" | sed -e 's/:/./g'`
1308                 CF_VERBOSE(ABI_VERSION: $ABI_VERSION)
1309                 ;;
1310         *)
1311                 AC_MSG_WARN(unexpected VERSION value: $VERSION)
1312                 ;;
1313         esac
1314 fi
1315
1316 AC_SUBST(ABI_VERSION)
1317 AC_SUBST(LIBTOOL_VERSION)
1318 ])dnl
1319 dnl ---------------------------------------------------------------------------
1320 dnl CF_DISABLE_RPATH_HACK version: 2 updated: 2011/02/13 13:31:33
1321 dnl ---------------------
1322 dnl The rpath-hack makes it simpler to build programs, particularly with the
1323 dnl *BSD ports which may have essential libraries in unusual places.  But it
1324 dnl can interfere with building an executable for the base system.  Use this
1325 dnl option in that case.
1326 AC_DEFUN([CF_DISABLE_RPATH_HACK],
1327 [
1328 AC_MSG_CHECKING(if rpath-hack should be disabled)
1329 CF_ARG_DISABLE(rpath-hack,
1330         [  --disable-rpath-hack    don't add rpath options for additional libraries],
1331         [cf_disable_rpath_hack=yes],
1332         [cf_disable_rpath_hack=no])
1333 AC_MSG_RESULT($cf_disable_rpath_hack)
1334 if test "$cf_disable_rpath_hack" = no ; then
1335         CF_RPATH_HACK
1336 fi
1337 ])
1338 dnl ---------------------------------------------------------------------------
1339 dnl CF_ENABLE_PC_FILES version: 9 updated: 2012/08/04 13:59:54
1340 dnl ------------------
1341 dnl This is the "--enable-pc-files" option, which is available if there is a
1342 dnl pkg-config configuration on the local machine.
1343 AC_DEFUN([CF_ENABLE_PC_FILES],[
1344 AC_REQUIRE([CF_PKG_CONFIG])
1345 AC_REQUIRE([CF_WITH_PKG_CONFIG_LIBDIR])
1346
1347 if test "$PKG_CONFIG" != none ; then
1348         AC_MSG_CHECKING(if we should install .pc files for $PKG_CONFIG)
1349         AC_ARG_ENABLE(pc-files,
1350                 [  --enable-pc-files       generate and install .pc files for pkg-config],
1351                 [enable_pc_files=$enableval],
1352                 [enable_pc_files=no])
1353         AC_MSG_RESULT($enable_pc_files)
1354         if test "$enable_pc_files" != no
1355         then
1356                 CF_PATH_SYNTAX(PKG_CONFIG_LIBDIR)
1357         fi
1358 else
1359         enable_pc_files=no
1360 fi
1361 ])dnl
1362 dnl ---------------------------------------------------------------------------
1363 dnl CF_ENABLE_RPATH version: 2 updated: 2010/03/27 18:39:42
1364 dnl ---------------
1365 dnl Check if the rpath option should be used, setting cache variable
1366 dnl cf_cv_enable_rpath if so.
1367 AC_DEFUN([CF_ENABLE_RPATH],
1368 [
1369 AC_MSG_CHECKING(if rpath option should be used)
1370 AC_ARG_ENABLE(rpath,
1371 [  --enable-rpath          use rpath option when generating shared libraries],
1372 [cf_cv_enable_rpath=$enableval],
1373 [cf_cv_enable_rpath=no])
1374 AC_MSG_RESULT($cf_cv_enable_rpath)
1375 ])dnl
1376 dnl ---------------------------------------------------------------------------
1377 dnl CF_ENABLE_STRING_HACKS version: 3 updated: 2013/01/26 16:26:12
1378 dnl ----------------------
1379 dnl On a few platforms, the compiler and/or loader nags with untruthful
1380 dnl comments stating that "most" uses of strcat/strcpy/sprintf are incorrect,
1381 dnl and implying that most uses of the recommended alternatives are correct.
1382 dnl
1383 dnl Factually speaking, no one has actually counted the number of uses of these
1384 dnl functions versus the total of incorrect uses.  Samples of a few thousand
1385 dnl instances are meaningless compared to the hundreds of millions of lines of
1386 dnl existing C code.
1387 dnl
1388 dnl strlcat/strlcpy are (as of 2012) non-standard, and are available on some
1389 dnl platforms, in implementations of varying quality.  Likewise, snprintf is
1390 dnl standard - but evolved through phases, and older implementations are likely
1391 dnl to yield surprising results, as documented in manpages on various systems.
1392 AC_DEFUN([CF_ENABLE_STRING_HACKS],
1393 [
1394 AC_MSG_CHECKING(if you want to work around bogus compiler/loader warnings)
1395 AC_ARG_ENABLE(string-hacks,
1396         [  --enable-string-hacks   work around bogus compiler/loader warnings],
1397         [with_string_hacks=$enableval],
1398         [with_string_hacks=no])
1399 AC_MSG_RESULT($with_string_hacks)
1400
1401 if test "x$with_string_hacks" = "xyes"; then
1402         AC_DEFINE(USE_STRING_HACKS,1,[Define to 1 to work around bogus compiler/loader warnings])
1403         AC_MSG_WARN(enabling string-hacks to work around bogus compiler/loader warnings)
1404         AC_CHECK_FUNCS( strlcat strlcpy snprintf )
1405 fi
1406 ])dnl
1407 dnl ---------------------------------------------------------------------------
1408 dnl CF_ERRNO version: 5 updated: 1997/11/30 12:44:39
1409 dnl --------
1410 dnl Check if 'errno' is declared in <errno.h>
1411 AC_DEFUN([CF_ERRNO],
1412 [
1413 CF_CHECK_ERRNO(errno)
1414 ])dnl
1415 dnl ---------------------------------------------------------------------------
1416 dnl CF_ETIP_DEFINES version: 5 updated: 2012/02/18 17:51:07
1417 dnl ---------------
1418 dnl Test for conflicting definitions of exception in gcc 2.8.0, etc., between
1419 dnl math.h and builtin.h, only for ncurses
1420 AC_DEFUN([CF_ETIP_DEFINES],
1421 [
1422 AC_MSG_CHECKING(for special defines needed for etip.h)
1423 cf_save_CXXFLAGS="$CXXFLAGS"
1424 cf_result="none"
1425
1426 # etip.h includes ncurses.h which includes ncurses_dll.h
1427 # But ncurses_dll.h is generated - fix here.
1428 test -d include || mkdir include
1429 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
1430
1431 for cf_math in "" MATH_H
1432 do
1433 for cf_excp in "" MATH_EXCEPTION
1434 do
1435         CXXFLAGS="$cf_save_CXXFLAGS -I${srcdir}/c++ -I${srcdir}/menu -Iinclude -I${srcdir}/include"
1436         test -n "$cf_math" && CXXFLAGS="$CXXFLAGS -DETIP_NEEDS_${cf_math}"
1437         test -n "$cf_excp" && CXXFLAGS="$CXXFLAGS -DETIP_NEEDS_${cf_excp}"
1438 AC_TRY_COMPILE([
1439 #include <etip.h.in>
1440 ],[],[
1441         test -n "$cf_math" && AC_DEFINE_UNQUOTED(ETIP_NEEDS_${cf_math})
1442         test -n "$cf_excp" && AC_DEFINE_UNQUOTED(ETIP_NEEDS_${cf_excp})
1443         cf_result="$cf_math $cf_excp"
1444         break 2
1445 ],[])
1446 done
1447 done
1448 AC_MSG_RESULT($cf_result)
1449 CXXFLAGS="$cf_save_CXXFLAGS"
1450 ])
1451 dnl ---------------------------------------------------------------------------
1452 dnl CF_FIND_LINKAGE version: 19 updated: 2010/05/29 16:31:02
1453 dnl ---------------
1454 dnl Find a library (specifically the linkage used in the code fragment),
1455 dnl searching for it if it is not already in the library path.
1456 dnl See also CF_ADD_SEARCHPATH.
1457 dnl
1458 dnl Parameters (4-on are optional):
1459 dnl     $1 = headers for library entrypoint
1460 dnl     $2 = code fragment for library entrypoint
1461 dnl     $3 = the library name without the "-l" option or ".so" suffix.
1462 dnl     $4 = action to perform if successful (default: update CPPFLAGS, etc)
1463 dnl     $5 = action to perform if not successful
1464 dnl     $6 = module name, if not the same as the library name
1465 dnl     $7 = extra libraries
1466 dnl
1467 dnl Sets these variables:
1468 dnl     $cf_cv_find_linkage_$3 - yes/no according to whether linkage is found
1469 dnl     $cf_cv_header_path_$3 - include-directory if needed
1470 dnl     $cf_cv_library_path_$3 - library-directory if needed
1471 dnl     $cf_cv_library_file_$3 - library-file if needed, e.g., -l$3
1472 AC_DEFUN([CF_FIND_LINKAGE],[
1473
1474 # If the linkage is not already in the $CPPFLAGS/$LDFLAGS configuration, these
1475 # will be set on completion of the AC_TRY_LINK below.
1476 cf_cv_header_path_$3=
1477 cf_cv_library_path_$3=
1478
1479 CF_MSG_LOG([Starting [FIND_LINKAGE]($3,$6)])
1480
1481 cf_save_LIBS="$LIBS"
1482
1483 AC_TRY_LINK([$1],[$2],[
1484         cf_cv_find_linkage_$3=yes
1485         cf_cv_header_path_$3=/usr/include
1486         cf_cv_library_path_$3=/usr/lib
1487 ],[
1488
1489 LIBS="-l$3 $7 $cf_save_LIBS"
1490
1491 AC_TRY_LINK([$1],[$2],[
1492         cf_cv_find_linkage_$3=yes
1493         cf_cv_header_path_$3=/usr/include
1494         cf_cv_library_path_$3=/usr/lib
1495         cf_cv_library_file_$3="-l$3"
1496 ],[
1497         cf_cv_find_linkage_$3=no
1498         LIBS="$cf_save_LIBS"
1499
1500     CF_VERBOSE(find linkage for $3 library)
1501     CF_MSG_LOG([Searching for headers in [FIND_LINKAGE]($3,$6)])
1502
1503     cf_save_CPPFLAGS="$CPPFLAGS"
1504     cf_test_CPPFLAGS="$CPPFLAGS"
1505
1506     CF_HEADER_PATH(cf_search,ifelse([$6],,[$3],[$6]))
1507     for cf_cv_header_path_$3 in $cf_search
1508     do
1509       if test -d $cf_cv_header_path_$3 ; then
1510         CF_VERBOSE(... testing $cf_cv_header_path_$3)
1511         CPPFLAGS="$cf_save_CPPFLAGS -I$cf_cv_header_path_$3"
1512         AC_TRY_COMPILE([$1],[$2],[
1513             CF_VERBOSE(... found $3 headers in $cf_cv_header_path_$3)
1514             cf_cv_find_linkage_$3=maybe
1515             cf_test_CPPFLAGS="$CPPFLAGS"
1516             break],[
1517             CPPFLAGS="$cf_save_CPPFLAGS"
1518             ])
1519       fi
1520     done
1521
1522     if test "$cf_cv_find_linkage_$3" = maybe ; then
1523
1524       CF_MSG_LOG([Searching for $3 library in [FIND_LINKAGE]($3,$6)])
1525
1526       cf_save_LIBS="$LIBS"
1527       cf_save_LDFLAGS="$LDFLAGS"
1528
1529       ifelse([$6],,,[
1530         CPPFLAGS="$cf_test_CPPFLAGS"
1531         LIBS="-l$3 $7 $cf_save_LIBS"
1532         AC_TRY_LINK([$1],[$2],[
1533             CF_VERBOSE(... found $3 library in system)
1534             cf_cv_find_linkage_$3=yes])
1535             CPPFLAGS="$cf_save_CPPFLAGS"
1536             LIBS="$cf_save_LIBS"
1537             ])
1538
1539       if test "$cf_cv_find_linkage_$3" != yes ; then
1540         CF_LIBRARY_PATH(cf_search,$3)
1541         for cf_cv_library_path_$3 in $cf_search
1542         do
1543           if test -d $cf_cv_library_path_$3 ; then
1544             CF_VERBOSE(... testing $cf_cv_library_path_$3)
1545             CPPFLAGS="$cf_test_CPPFLAGS"
1546             LIBS="-l$3 $7 $cf_save_LIBS"
1547             LDFLAGS="$cf_save_LDFLAGS -L$cf_cv_library_path_$3"
1548             AC_TRY_LINK([$1],[$2],[
1549                 CF_VERBOSE(... found $3 library in $cf_cv_library_path_$3)
1550                 cf_cv_find_linkage_$3=yes
1551                 cf_cv_library_file_$3="-l$3"
1552                 break],[
1553                 CPPFLAGS="$cf_save_CPPFLAGS"
1554                 LIBS="$cf_save_LIBS"
1555                 LDFLAGS="$cf_save_LDFLAGS"
1556                 ])
1557           fi
1558         done
1559         CPPFLAGS="$cf_save_CPPFLAGS"
1560         LDFLAGS="$cf_save_LDFLAGS"
1561       fi
1562
1563     else
1564       cf_cv_find_linkage_$3=no
1565     fi
1566     ],$7)
1567 ])
1568
1569 LIBS="$cf_save_LIBS"
1570
1571 if test "$cf_cv_find_linkage_$3" = yes ; then
1572 ifelse([$4],,[
1573         CF_ADD_INCDIR($cf_cv_header_path_$3)
1574         CF_ADD_LIBDIR($cf_cv_library_path_$3)
1575         CF_ADD_LIB($3)
1576 ],[$4])
1577 else
1578 ifelse([$5],,AC_MSG_WARN(Cannot find $3 library),[$5])
1579 fi
1580 ])dnl
1581 dnl ---------------------------------------------------------------------------
1582 dnl CF_FIND_SUB_INCDIR version: 1 updated: 2014/04/12 16:47:01
1583 dnl ------------------
1584 dnl Find an include-directory with the given leaf-name.  This is useful for
1585 dnl example with FreeBSD ports, which use this convention to distinguish
1586 dnl different versions of the same port.
1587 AC_DEFUN([CF_FIND_SUB_INCDIR],[
1588         CF_SUBDIR_PATH(cf_search,$1,include)
1589         for cf_item in $cf_search
1590         do
1591                 case $cf_item in #(vi
1592                 */$1)
1593                         CF_ADD_INCDIR($cf_item)
1594                         ;;
1595                 esac
1596         done
1597 ])dnl
1598 dnl ---------------------------------------------------------------------------
1599 dnl CF_FIND_SUB_LIBDIR version: 1 updated: 2014/04/12 16:47:01
1600 dnl ------------------
1601 dnl Find a library-directory with the given leaf-name.  This is useful for
1602 dnl example with FreeBSD ports, which use this convention to distinguish
1603 dnl different versions of the same port.
1604 AC_DEFUN([CF_FIND_SUB_LIBDIR],[
1605         CF_SUBDIR_PATH(cf_search,$1,lib)
1606         for cf_item in $cf_search
1607         do
1608                 case $cf_item in #(vi
1609                 */$1)
1610                         CF_ADD_LIBDIR($cf_item)
1611                         ;;
1612                 esac
1613         done
1614 ])dnl
1615 dnl ---------------------------------------------------------------------------
1616 dnl CF_FIXUP_ADAFLAGS version: 1 updated: 2012/03/31 18:48:10
1617 dnl -----------------
1618 dnl make ADAFLAGS consistent with CFLAGS
1619 AC_DEFUN([CF_FIXUP_ADAFLAGS],[
1620         AC_MSG_CHECKING(optimization options for ADAFLAGS)
1621         case "$CFLAGS" in
1622         *-g*)
1623                 CF_ADD_ADAFLAGS(-g)
1624                 ;;
1625         esac
1626         case "$CFLAGS" in
1627         *-O*)
1628                 cf_O_flag=`echo "$CFLAGS" |sed -e 's/^.*-O/-O/' -e 's/[[        ]].*//'`
1629                 CF_ADD_ADAFLAGS($cf_O_flag)
1630                 ;;
1631         esac
1632         AC_MSG_RESULT($ADAFLAGS)
1633 ])dnl
1634 dnl ---------------------------------------------------------------------------
1635 dnl CF_FORGET_TOOL version: 1 updated: 2013/04/06 18:03:09
1636 dnl --------------
1637 dnl Forget that we saw the given tool.
1638 AC_DEFUN([CF_FORGET_TOOL],[
1639 unset ac_cv_prog_ac_ct_$1
1640 unset ac_ct_$1
1641 unset $1
1642 ])dnl
1643 dnl ---------------------------------------------------------------------------
1644 dnl CF_FUNC_DLSYM version: 3 updated: 2012/10/06 11:17:15
1645 dnl -------------
1646 dnl Test for dlsym() and related functions, as well as libdl.
1647 dnl
1648 dnl Sets
1649 dnl     $cf_have_dlsym
1650 dnl     $cf_have_libdl
1651 AC_DEFUN([CF_FUNC_DLSYM],[
1652 cf_have_dlsym=no
1653 AC_CHECK_FUNC(dlsym,cf_have_dlsym=yes,[
1654
1655 cf_have_libdl=no
1656 AC_CHECK_LIB(dl,dlsym,[
1657         cf_have_dlsym=yes
1658         cf_have_libdl=yes])])
1659
1660 if test "$cf_have_dlsym" = yes ; then
1661         test "$cf_have_libdl" = yes && CF_ADD_LIB(dl)
1662
1663         AC_MSG_CHECKING(whether able to link to dl*() functions)
1664         AC_TRY_LINK([#include <dlfcn.h>],[
1665                 void *obj;
1666                 if ((obj = dlopen("filename", 0)) != 0) {
1667                         if (dlsym(obj, "symbolname") == 0) {
1668                         dlclose(obj);
1669                         }
1670                 }],[
1671                 AC_DEFINE(HAVE_LIBDL,1,[Define to 1 if we have dl library])],[
1672                 AC_MSG_ERROR(Cannot link test program for libdl)])
1673         AC_MSG_RESULT(ok)
1674 else
1675         AC_MSG_ERROR(Cannot find dlsym function)
1676 fi
1677 ])
1678 dnl ---------------------------------------------------------------------------
1679 dnl CF_FUNC_MEMMOVE version: 8 updated: 2012/10/04 20:12:20
1680 dnl ---------------
1681 dnl Check for memmove, or a bcopy that can handle overlapping copy.  If neither
1682 dnl is found, add our own version of memmove to the list of objects.
1683 AC_DEFUN([CF_FUNC_MEMMOVE],
1684 [
1685 AC_CHECK_FUNC(memmove,,[
1686 AC_CHECK_FUNC(bcopy,[
1687         AC_CACHE_CHECK(if bcopy does overlapping moves,cf_cv_good_bcopy,[
1688                 AC_TRY_RUN([
1689 int main() {
1690         static char data[] = "abcdefghijklmnopqrstuwwxyz";
1691         char temp[40];
1692         bcopy(data, temp, sizeof(data));
1693         bcopy(temp+10, temp, 15);
1694         bcopy(temp+5, temp+15, 10);
1695         ${cf_cv_main_return:-return} (strcmp(temp, "klmnopqrstuwwxypqrstuwwxyz"));
1696 }
1697                 ],
1698                 [cf_cv_good_bcopy=yes],
1699                 [cf_cv_good_bcopy=no],
1700                 [cf_cv_good_bcopy=unknown])
1701                 ])
1702         ],[cf_cv_good_bcopy=no])
1703         if test "$cf_cv_good_bcopy" = yes ; then
1704                 AC_DEFINE(USE_OK_BCOPY,1,[Define to 1 to use bcopy when memmove is unavailable])
1705         else
1706                 AC_DEFINE(USE_MY_MEMMOVE,1,[Define to 1 to use replacement function when memmove is unavailable])
1707         fi
1708 ])])dnl
1709 dnl ---------------------------------------------------------------------------
1710 dnl CF_FUNC_NANOSLEEP version: 4 updated: 2012/10/06 17:56:13
1711 dnl -----------------
1712 dnl Check for existence of workable nanosleep() function.  Some systems, e.g.,
1713 dnl AIX 4.x, provide a non-working version.
1714 AC_DEFUN([CF_FUNC_NANOSLEEP],[
1715 AC_CACHE_CHECK(if nanosleep really works,cf_cv_func_nanosleep,[
1716 AC_TRY_RUN([
1717 #include <stdio.h>
1718 #include <errno.h>
1719 #include <time.h>
1720
1721 #ifdef HAVE_SYS_TIME_H
1722 #include <sys/time.h>
1723 #endif
1724
1725 int main() {
1726         struct timespec ts1, ts2;
1727         int code;
1728         ts1.tv_sec  = 0;
1729         ts1.tv_nsec = 750000000;
1730         ts2.tv_sec  = 0;
1731         ts2.tv_nsec = 0;
1732         errno = 0;
1733         code = nanosleep(&ts1, &ts2); /* on failure errno is ENOSYS. */
1734         ${cf_cv_main_return:-return}(code != 0);
1735 }
1736 ],
1737         [cf_cv_func_nanosleep=yes],
1738         [cf_cv_func_nanosleep=no],
1739         [cf_cv_func_nanosleep=unknown])])
1740
1741 test "$cf_cv_func_nanosleep" = "yes" && AC_DEFINE(HAVE_NANOSLEEP,1,[Define to 1 if we have nanosleep()])
1742 ])
1743 dnl ---------------------------------------------------------------------------
1744 dnl CF_FUNC_OPENPTY version: 3 updated: 2010/05/29 16:31:02
1745 dnl ---------------
1746 dnl Check for openpty() function, along with <pty.h> header.  It may need the
1747 dnl "util" library as well.
1748 AC_DEFUN([CF_FUNC_OPENPTY],
1749 [
1750 AC_CHECK_LIB(util,openpty,cf_cv_lib_util=yes,cf_cv_lib_util=no)
1751 AC_CACHE_CHECK(for openpty header,cf_cv_func_openpty,[
1752     cf_save_LIBS="$LIBS"
1753     test $cf_cv_lib_util = yes && CF_ADD_LIB(util)
1754     for cf_header in pty.h libutil.h util.h
1755     do
1756     AC_TRY_LINK([
1757 #include <$cf_header>
1758 ],[
1759     int x = openpty((int *)0, (int *)0, (char *)0,
1760                    (struct termios *)0, (struct winsize *)0);
1761 ],[
1762         cf_cv_func_openpty=$cf_header
1763         break
1764 ],[
1765         cf_cv_func_openpty=no
1766 ])
1767     done
1768     LIBS="$cf_save_LIBS"
1769 ])
1770 ])dnl
1771 dnl ---------------------------------------------------------------------------
1772 dnl CF_FUNC_POLL version: 8 updated: 2012/10/04 05:24:07
1773 dnl ------------
1774 dnl See if the poll function really works.  Some platforms have poll(), but
1775 dnl it does not work for terminals or files.
1776 AC_DEFUN([CF_FUNC_POLL],[
1777 AC_CACHE_CHECK(if poll really works,cf_cv_working_poll,[
1778 AC_TRY_RUN([
1779 #include <stdlib.h>
1780 #include <stdio.h>
1781 #include <unistd.h>
1782 #include <fcntl.h>
1783 #ifdef HAVE_POLL_H
1784 #include <poll.h>
1785 #else
1786 #include <sys/poll.h>
1787 #endif
1788 int main() {
1789         struct pollfd myfds;
1790         int ret;
1791
1792         /* check for Darwin bug with respect to "devices" */
1793         myfds.fd = open("/dev/null", 1);        /* O_WRONLY */
1794         if (myfds.fd < 0)
1795                 myfds.fd = 0;
1796         myfds.events = POLLIN;
1797         myfds.revents = 0;
1798
1799         ret = poll(&myfds, 1, 100);
1800
1801         if (ret < 0 || (myfds.revents & POLLNVAL)) {
1802                 ret = -1;
1803         } else {
1804                 int fd = 0;
1805                 if (!isatty(fd)) {
1806                         fd = open("/dev/tty", 2);       /* O_RDWR */
1807                 }
1808
1809                 if (fd >= 0) {
1810                         /* also check with standard input */
1811                         myfds.fd = fd;
1812                         myfds.events = POLLIN;
1813                         myfds.revents = 0;
1814                         ret = poll(&myfds, 1, 100);
1815                 } else {
1816                         ret = -1;
1817                 }
1818         }
1819         ${cf_cv_main_return:-return}(ret < 0);
1820 }],
1821         [cf_cv_working_poll=yes],
1822         [cf_cv_working_poll=no],
1823         [cf_cv_working_poll=unknown])])
1824 test "$cf_cv_working_poll" = "yes" && AC_DEFINE(HAVE_WORKING_POLL,1,[Define to 1 if the poll function seems to work])
1825 ])dnl
1826 dnl ---------------------------------------------------------------------------
1827 dnl CF_FUNC_TERMIOS version: 3 updated: 2012/10/06 17:56:13
1828 dnl ---------------
1829 dnl Some old/broken variations define tcgetattr() only as a macro in
1830 dnl termio(s).h
1831 AC_DEFUN([CF_FUNC_TERMIOS],[
1832 AC_REQUIRE([CF_STRUCT_TERMIOS])
1833 AC_CACHE_CHECK(for tcgetattr, cf_cv_have_tcgetattr,[
1834 AC_TRY_LINK([
1835 #include <sys/types.h>
1836 #ifdef HAVE_UNISTD_H
1837 #include <unistd.h>
1838 #endif
1839 #ifdef HAVE_TERMIOS_H
1840 #include <termios.h>
1841 #define TTY struct termios
1842 #else
1843 #ifdef HAVE_TERMIO_H
1844 #include <termio.h>
1845 #define TTY struct termio
1846 #endif
1847 #endif
1848 ],[
1849 TTY foo;
1850 tcgetattr(1, &foo);],
1851 [cf_cv_have_tcgetattr=yes],
1852 [cf_cv_have_tcgetattr=no])])
1853 test "$cf_cv_have_tcgetattr" = yes && AC_DEFINE(HAVE_TCGETATTR,1,[Define to 1 if we have tcgetattr])
1854 ])dnl
1855 dnl ---------------------------------------------------------------------------
1856 dnl CF_FUNC_VSSCANF version: 4 updated: 2012/10/06 17:56:13
1857 dnl ---------------
1858 dnl Check for vsscanf() function, which is in c9x but generally not in earlier
1859 dnl versions of C.  It is in the GNU C library, and can often be simulated by
1860 dnl other functions.
1861 AC_DEFUN([CF_FUNC_VSSCANF],
1862 [
1863 AC_CACHE_CHECK(for vsscanf function or workaround,cf_cv_func_vsscanf,[
1864 AC_TRY_LINK([
1865 #include <stdarg.h>
1866 #include <stdio.h>],[
1867         va_list ap;
1868         vsscanf("from", "%d", ap)],[cf_cv_func_vsscanf=vsscanf],[
1869 AC_TRY_LINK([
1870 #include <stdarg.h>
1871 #include <stdio.h>],[
1872     FILE strbuf;
1873     char *str = "from";
1874
1875     strbuf._flag = _IOREAD;
1876     strbuf._ptr = strbuf._base = (unsigned char *) str;
1877     strbuf._cnt = strlen(str);
1878     strbuf._file = _NFILE;
1879     return (vfscanf(&strbuf, "%d", ap))],[cf_cv_func_vsscanf=vfscanf],[
1880 AC_TRY_LINK([
1881 #include <stdarg.h>
1882 #include <stdio.h>],[
1883     FILE strbuf;
1884     char *str = "from";
1885
1886     strbuf._flag = _IOREAD;
1887     strbuf._ptr = strbuf._base = (unsigned char *) str;
1888     strbuf._cnt = strlen(str);
1889     strbuf._file = _NFILE;
1890     return (_doscan(&strbuf, "%d", ap))],[cf_cv_func_vsscanf=_doscan],[
1891 cf_cv_func_vsscanf=no])])])])
1892
1893 case $cf_cv_func_vsscanf in #(vi
1894 vsscanf) AC_DEFINE(HAVE_VSSCANF,1,[Define to 1 if we have vsscanf]);; #(vi
1895 vfscanf) AC_DEFINE(HAVE_VFSCANF,1,[Define to 1 if we have vfscanf]);; #(vi
1896 _doscan) AC_DEFINE(HAVE__DOSCAN,1,[Define to 1 if we have _doscan]);;
1897 esac
1898
1899 ])dnl
1900 dnl ---------------------------------------------------------------------------
1901 dnl CF_GCC_ATTRIBUTES version: 16 updated: 2012/10/02 20:55:03
1902 dnl -----------------
1903 dnl Test for availability of useful gcc __attribute__ directives to quiet
1904 dnl compiler warnings.  Though useful, not all are supported -- and contrary
1905 dnl to documentation, unrecognized directives cause older compilers to barf.
1906 AC_DEFUN([CF_GCC_ATTRIBUTES],
1907 [
1908 if test "$GCC" = yes
1909 then
1910 cat > conftest.i <<EOF
1911 #ifndef GCC_PRINTF
1912 #define GCC_PRINTF 0
1913 #endif
1914 #ifndef GCC_SCANF
1915 #define GCC_SCANF 0
1916 #endif
1917 #ifndef GCC_NORETURN
1918 #define GCC_NORETURN /* nothing */
1919 #endif
1920 #ifndef GCC_UNUSED
1921 #define GCC_UNUSED /* nothing */
1922 #endif
1923 EOF
1924 if test "$GCC" = yes
1925 then
1926         AC_CHECKING([for $CC __attribute__ directives])
1927 cat > conftest.$ac_ext <<EOF
1928 #line __oline__ "${as_me:-configure}"
1929 #include "confdefs.h"
1930 #include "conftest.h"
1931 #include "conftest.i"
1932 #if     GCC_PRINTF
1933 #define GCC_PRINTFLIKE(fmt,var) __attribute__((format(printf,fmt,var)))
1934 #else
1935 #define GCC_PRINTFLIKE(fmt,var) /*nothing*/
1936 #endif
1937 #if     GCC_SCANF
1938 #define GCC_SCANFLIKE(fmt,var)  __attribute__((format(scanf,fmt,var)))
1939 #else
1940 #define GCC_SCANFLIKE(fmt,var)  /*nothing*/
1941 #endif
1942 extern void wow(char *,...) GCC_SCANFLIKE(1,2);
1943 extern void oops(char *,...) GCC_PRINTFLIKE(1,2) GCC_NORETURN;
1944 extern void foo(void) GCC_NORETURN;
1945 int main(int argc GCC_UNUSED, char *argv[[]] GCC_UNUSED) { return 0; }
1946 EOF
1947         cf_printf_attribute=no
1948         cf_scanf_attribute=no
1949         for cf_attribute in scanf printf unused noreturn
1950         do
1951                 CF_UPPER(cf_ATTRIBUTE,$cf_attribute)
1952                 cf_directive="__attribute__(($cf_attribute))"
1953                 echo "checking for $CC $cf_directive" 1>&AC_FD_CC
1954
1955                 case $cf_attribute in #(vi
1956                 printf) #(vi
1957                         cf_printf_attribute=yes
1958                         cat >conftest.h <<EOF
1959 #define GCC_$cf_ATTRIBUTE 1
1960 EOF
1961                         ;;
1962                 scanf) #(vi
1963                         cf_scanf_attribute=yes
1964                         cat >conftest.h <<EOF
1965 #define GCC_$cf_ATTRIBUTE 1
1966 EOF
1967                         ;;
1968                 *) #(vi
1969                         cat >conftest.h <<EOF
1970 #define GCC_$cf_ATTRIBUTE $cf_directive
1971 EOF
1972                         ;;
1973                 esac
1974
1975                 if AC_TRY_EVAL(ac_compile); then
1976                         test -n "$verbose" && AC_MSG_RESULT(... $cf_attribute)
1977                         cat conftest.h >>confdefs.h
1978                         case $cf_attribute in #(vi
1979                         noreturn) #(vi
1980                                 AC_DEFINE_UNQUOTED(GCC_NORETURN,$cf_directive,[Define to noreturn-attribute for gcc])
1981                                 ;;
1982                         printf) #(vi
1983                                 cf_value='/* nothing */'
1984                                 if test "$cf_printf_attribute" != no ; then
1985                                         cf_value='__attribute__((format(printf,fmt,var)))'
1986                                         AC_DEFINE(GCC_PRINTF,1,[Define to 1 if the compiler supports gcc-like printf attribute.])
1987                                 fi
1988                                 AC_DEFINE_UNQUOTED(GCC_PRINTFLIKE(fmt,var),$cf_value,[Define to printf-attribute for gcc])
1989                                 ;;
1990                         scanf) #(vi
1991                                 cf_value='/* nothing */'
1992                                 if test "$cf_scanf_attribute" != no ; then
1993                                         cf_value='__attribute__((format(scanf,fmt,var)))'
1994                                         AC_DEFINE(GCC_SCANF,1,[Define to 1 if the compiler supports gcc-like scanf attribute.])
1995                                 fi
1996                                 AC_DEFINE_UNQUOTED(GCC_SCANFLIKE(fmt,var),$cf_value,[Define to sscanf-attribute for gcc])
1997                                 ;;
1998                         unused) #(vi
1999                                 AC_DEFINE_UNQUOTED(GCC_UNUSED,$cf_directive,[Define to unused-attribute for gcc])
2000                                 ;;
2001                         esac
2002                 fi
2003         done
2004 else
2005         fgrep define conftest.i >>confdefs.h
2006 fi
2007 rm -rf conftest*
2008 fi
2009 ])dnl
2010 dnl ---------------------------------------------------------------------------
2011 dnl CF_GCC_VERSION version: 7 updated: 2012/10/18 06:46:33
2012 dnl --------------
2013 dnl Find version of gcc
2014 AC_DEFUN([CF_GCC_VERSION],[
2015 AC_REQUIRE([AC_PROG_CC])
2016 GCC_VERSION=none
2017 if test "$GCC" = yes ; then
2018         AC_MSG_CHECKING(version of $CC)
2019         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.]].*//'`"
2020         test -z "$GCC_VERSION" && GCC_VERSION=unknown
2021         AC_MSG_RESULT($GCC_VERSION)
2022 fi
2023 ])dnl
2024 dnl ---------------------------------------------------------------------------
2025 dnl CF_GCC_WARNINGS version: 31 updated: 2013/11/19 19:23:35
2026 dnl ---------------
2027 dnl Check if the compiler supports useful warning options.  There's a few that
2028 dnl we don't use, simply because they're too noisy:
2029 dnl
2030 dnl     -Wconversion (useful in older versions of gcc, but not in gcc 2.7.x)
2031 dnl     -Wredundant-decls (system headers make this too noisy)
2032 dnl     -Wtraditional (combines too many unrelated messages, only a few useful)
2033 dnl     -Wwrite-strings (too noisy, but should review occasionally).  This
2034 dnl             is enabled for ncurses using "--enable-const".
2035 dnl     -pedantic
2036 dnl
2037 dnl Parameter:
2038 dnl     $1 is an optional list of gcc warning flags that a particular
2039 dnl             application might want to use, e.g., "no-unused" for
2040 dnl             -Wno-unused
2041 dnl Special:
2042 dnl     If $with_ext_const is "yes", add a check for -Wwrite-strings
2043 dnl
2044 AC_DEFUN([CF_GCC_WARNINGS],
2045 [
2046 AC_REQUIRE([CF_GCC_VERSION])
2047 CF_INTEL_COMPILER(GCC,INTEL_COMPILER,CFLAGS)
2048 CF_CLANG_COMPILER(GCC,CLANG_COMPILER,CFLAGS)
2049
2050 cat > conftest.$ac_ext <<EOF
2051 #line __oline__ "${as_me:-configure}"
2052 int main(int argc, char *argv[[]]) { return (argv[[argc-1]] == 0) ; }
2053 EOF
2054
2055 if test "$INTEL_COMPILER" = yes
2056 then
2057 # The "-wdXXX" options suppress warnings:
2058 # remark #1419: external declaration in primary source file
2059 # remark #1683: explicit conversion of a 64-bit integral type to a smaller integral type (potential portability problem)
2060 # remark #1684: conversion from pointer to same-sized integral type (potential portability problem)
2061 # remark #193: zero used for undefined preprocessing identifier
2062 # remark #593: variable "curs_sb_left_arrow" was set but never used
2063 # remark #810: conversion from "int" to "Dimension={unsigned short}" may lose significant bits
2064 # remark #869: parameter "tw" was never referenced
2065 # remark #981: operands are evaluated in unspecified order
2066 # warning #279: controlling expression is constant
2067
2068         AC_CHECKING([for $CC warning options])
2069         cf_save_CFLAGS="$CFLAGS"
2070         EXTRA_CFLAGS="-Wall"
2071         for cf_opt in \
2072                 wd1419 \
2073                 wd1683 \
2074                 wd1684 \
2075                 wd193 \
2076                 wd593 \
2077                 wd279 \
2078                 wd810 \
2079                 wd869 \
2080                 wd981
2081         do
2082                 CFLAGS="$cf_save_CFLAGS $EXTRA_CFLAGS -$cf_opt"
2083                 if AC_TRY_EVAL(ac_compile); then
2084                         test -n "$verbose" && AC_MSG_RESULT(... -$cf_opt)
2085                         EXTRA_CFLAGS="$EXTRA_CFLAGS -$cf_opt"
2086                 fi
2087         done
2088         CFLAGS="$cf_save_CFLAGS"
2089
2090 elif test "$GCC" = yes
2091 then
2092         AC_CHECKING([for $CC warning options])
2093         cf_save_CFLAGS="$CFLAGS"
2094         EXTRA_CFLAGS=
2095         cf_warn_CONST=""
2096         test "$with_ext_const" = yes && cf_warn_CONST="Wwrite-strings"
2097         cf_gcc_warnings="Wignored-qualifiers Wlogical-op Wvarargs"
2098         test "x$CLANG_COMPILER" = xyes && cf_gcc_warnings=
2099         for cf_opt in W Wall \
2100                 Wbad-function-cast \
2101                 Wcast-align \
2102                 Wcast-qual \
2103                 Wdeclaration-after-statement \
2104                 Wextra \
2105                 Winline \
2106                 Wmissing-declarations \
2107                 Wmissing-prototypes \
2108                 Wnested-externs \
2109                 Wpointer-arith \
2110                 Wshadow \
2111                 Wstrict-prototypes \
2112                 Wundef $cf_gcc_warnings $cf_warn_CONST $1
2113         do
2114                 CFLAGS="$cf_save_CFLAGS $EXTRA_CFLAGS -$cf_opt"
2115                 if AC_TRY_EVAL(ac_compile); then
2116                         test -n "$verbose" && AC_MSG_RESULT(... -$cf_opt)
2117                         case $cf_opt in #(vi
2118                         Wcast-qual) #(vi
2119                                 CPPFLAGS="$CPPFLAGS -DXTSTRINGDEFINES"
2120                                 ;;
2121                         Winline) #(vi
2122                                 case $GCC_VERSION in
2123                                 [[34]].*)
2124                                         CF_VERBOSE(feature is broken in gcc $GCC_VERSION)
2125                                         continue;;
2126                                 esac
2127                                 ;;
2128                         Wpointer-arith) #(vi
2129                                 case $GCC_VERSION in
2130                                 [[12]].*)
2131                                         CF_VERBOSE(feature is broken in gcc $GCC_VERSION)
2132                                         continue;;
2133                                 esac
2134                                 ;;
2135                         esac
2136                         EXTRA_CFLAGS="$EXTRA_CFLAGS -$cf_opt"
2137                 fi
2138         done
2139         CFLAGS="$cf_save_CFLAGS"
2140 fi
2141 rm -rf conftest*
2142
2143 AC_SUBST(EXTRA_CFLAGS)
2144 ])dnl
2145 dnl ---------------------------------------------------------------------------
2146 dnl CF_GETOPT_HEADER version: 6 updated: 2014/07/22 14:45:54
2147 dnl ----------------
2148 dnl Check for getopt's variables which are commonly defined in stdlib.h,
2149 dnl unistd.h or (nonstandard) in getopt.h
2150 AC_DEFUN([CF_GETOPT_HEADER],
2151 [
2152 AC_HAVE_HEADERS(unistd.h getopt.h)
2153 AC_CACHE_CHECK(for header declaring getopt variables,cf_cv_getopt_header,[
2154 cf_cv_getopt_header=none
2155 for cf_header in stdio.h stdlib.h unistd.h getopt.h
2156 do
2157 AC_TRY_COMPILE([
2158 #include <$cf_header>],
2159 [int x = optind; char *y = optarg],
2160 [cf_cv_getopt_header=$cf_header
2161  break])
2162 done
2163 ])
2164 if test $cf_cv_getopt_header != none ; then
2165         AC_DEFINE(HAVE_GETOPT_HEADER,1,[Define to 1 if getopt variables are declared in header])
2166 fi
2167 if test $cf_cv_getopt_header = getopt.h ; then
2168         AC_DEFINE(NEED_GETOPT_H,1,[Define to 1 if we must include getopt.h])
2169 fi
2170 ])dnl
2171 dnl ---------------------------------------------------------------------------
2172 dnl CF_GNATPREP_OPT_T version: 1 updated: 2014/08/02 18:37:25
2173 dnl -----------------
2174 AC_DEFUN([CF_GNATPREP_OPT_T],[
2175 AC_CACHE_CHECK(if GNATPREP supports -T option,cf_cv_gnatprep_opt_t,[
2176 cf_cv_gnatprep_opt_t=no
2177 gnatprep -T 2>/dev/null >/dev/null && cf_cv_gnatprep_opt_t=yes
2178 ])
2179 test "$cf_cv_gnatprep_opt_t" = yes && GNATPREP_OPTS="-T $GNATPREP_OPTS"
2180 AC_SUBST(GNATPREP_OPTS)
2181 ])dnl
2182 dnl ---------------------------------------------------------------------------
2183 dnl CF_GNAT_GENERICS version: 2 updated: 2011/03/23 20:24:41
2184 dnl ----------------
2185 AC_DEFUN([CF_GNAT_GENERICS],
2186 [
2187 AC_REQUIRE([CF_GNAT_VERSION])
2188
2189 AC_MSG_CHECKING(if GNAT supports generics)
2190 case $cf_gnat_version in #(vi
2191 3.[[1-9]]*|[[4-9]].*) #(vi
2192         cf_gnat_generics=yes
2193         ;;
2194 *)
2195         cf_gnat_generics=no
2196         ;;
2197 esac
2198 AC_MSG_RESULT($cf_gnat_generics)
2199
2200 if test "$cf_gnat_generics" = yes
2201 then
2202         cf_compile_generics=generics
2203         cf_generic_objects="\${GENOBJS}"
2204 else
2205         cf_compile_generics=
2206         cf_generic_objects=
2207 fi
2208
2209 AC_SUBST(cf_compile_generics)
2210 AC_SUBST(cf_generic_objects)
2211 ])dnl
2212 dnl ---------------------------------------------------------------------------
2213 dnl CF_GNAT_PROJECTS version: 7 updated: 2014/06/01 10:46:34
2214 dnl ----------------
2215 dnl GNAT projects are configured with ".gpr" project files.
2216 dnl GNAT libraries are a further development, using the project feature.
2217 AC_DEFUN([CF_GNAT_PROJECTS],
2218 [
2219 AC_REQUIRE([CF_GNAT_VERSION])
2220 AC_REQUIRE([CF_DISABLE_GNAT_PROJECTS])
2221
2222 cf_gnat_libraries=no
2223 cf_gnat_projects=no
2224
2225 if test "$enable_gnat_projects" != no ; then
2226 AC_MSG_CHECKING(if GNAT supports project files)
2227 case $cf_gnat_version in #(vi
2228 3.[[0-9]]*) #(vi
2229         ;;
2230 *)
2231         case $cf_cv_system_name in #(vi
2232         cygwin*|msys*) #(vi
2233                 ;;
2234         *)
2235                 mkdir conftest.src conftest.bin conftest.lib
2236                 cd conftest.src
2237                 rm -rf conftest* *~conftest*
2238                 cat >>library.gpr <<CF_EOF
2239 project Library is
2240   Kind := External ("LIB_KIND");
2241   for Library_Name use "ConfTest";
2242   for Object_Dir use ".";
2243   for Library_ALI_Dir use External("LIBRARY_DIR");
2244   for Library_Version use External ("SONAME");
2245   for Library_Kind use Kind;
2246   for Library_Dir use External("BUILD_DIR");
2247   Source_Dir := External ("SOURCE_DIR");
2248   for Source_Dirs use (Source_Dir);
2249 end Library;
2250 CF_EOF
2251                 cat >>confpackage.ads <<CF_EOF
2252 package ConfPackage is
2253    procedure conftest;
2254 end ConfPackage;
2255 CF_EOF
2256                 cat >>confpackage.adb <<CF_EOF
2257 with Text_IO;
2258 package body ConfPackage is
2259    procedure conftest is
2260    begin
2261       Text_IO.Put ("Hello World");
2262       Text_IO.New_Line;
2263    end conftest;
2264 end ConfPackage;
2265 CF_EOF
2266                 if ( $cf_ada_make $ADAFLAGS \
2267                                 -Plibrary.gpr \
2268                                 -XBUILD_DIR=`cd ../conftest.bin;pwd` \
2269                                 -XLIBRARY_DIR=`cd ../conftest.lib;pwd` \
2270                                 -XSOURCE_DIR=`pwd` \
2271                                 -XSONAME=libConfTest.so.1 \
2272                                 -XLIB_KIND=static 1>&AC_FD_CC 2>&1 ) ; then
2273                         cf_gnat_projects=yes
2274                 fi
2275                 cd ..
2276                 if test -f conftest.lib/confpackage.ali
2277                 then
2278                         cf_gnat_libraries=yes
2279                 fi
2280                 rm -rf conftest* *~conftest*
2281                 ;;
2282         esac
2283         ;;
2284 esac
2285 AC_MSG_RESULT($cf_gnat_projects)
2286 fi # enable_gnat_projects
2287
2288 if test $cf_gnat_projects = yes
2289 then
2290         AC_MSG_CHECKING(if GNAT supports libraries)
2291         AC_MSG_RESULT($cf_gnat_libraries)
2292 fi
2293
2294 if test "$cf_gnat_projects" = yes
2295 then
2296         USE_OLD_MAKERULES="#"
2297         USE_GNAT_PROJECTS=""
2298 else
2299         USE_OLD_MAKERULES=""
2300         USE_GNAT_PROJECTS="#"
2301 fi
2302
2303 if test "$cf_gnat_libraries" = yes
2304 then
2305         USE_GNAT_LIBRARIES=""
2306 else
2307         USE_GNAT_LIBRARIES="#"
2308 fi
2309
2310 AC_SUBST(USE_OLD_MAKERULES)
2311 AC_SUBST(USE_GNAT_PROJECTS)
2312 AC_SUBST(USE_GNAT_LIBRARIES)
2313 ])dnl
2314 dnl ---------------------------------------------------------------------------
2315 dnl CF_GNAT_SIGINT version: 1 updated: 2011/03/27 20:07:59
2316 dnl --------------
2317 dnl Check if gnat supports SIGINT, and presumably tasking.  For the latter, it
2318 dnl is noted that gnat may compile a tasking unit even for configurations which
2319 dnl fail at runtime.
2320 AC_DEFUN([CF_GNAT_SIGINT],[
2321 AC_CACHE_CHECK(if GNAT supports SIGINT,cf_cv_gnat_sigint,[
2322 CF_GNAT_TRY_LINK([with Ada.Interrupts.Names;
2323
2324 package ConfTest is
2325
2326    pragma Warnings (Off);  --  the next pragma exists since 3.11p
2327    pragma Unreserve_All_Interrupts;
2328    pragma Warnings (On);
2329
2330    protected Process is
2331       procedure Stop;
2332       function Continue return Boolean;
2333       pragma Attach_Handler (Stop, Ada.Interrupts.Names.SIGINT);
2334    private
2335       Done : Boolean := False;
2336    end Process;
2337
2338 end ConfTest;],
2339 [package body ConfTest is
2340    protected body Process is
2341       procedure Stop is
2342       begin
2343          Done := True;
2344       end Stop;
2345       function Continue return Boolean is
2346       begin
2347          return not Done;
2348       end Continue;
2349    end Process;
2350 end ConfTest;],
2351         [cf_cv_gnat_sigint=yes],
2352         [cf_cv_gnat_sigint=no])])
2353
2354 if test $cf_cv_gnat_sigint = yes ; then
2355         USE_GNAT_SIGINT=""
2356 else
2357         USE_GNAT_SIGINT="#"
2358 fi
2359 AC_SUBST(USE_GNAT_SIGINT)
2360 ])dnl
2361 dnl ---------------------------------------------------------------------------
2362 dnl CF_GNAT_TRY_LINK version: 3 updated: 2011/03/19 14:47:45
2363 dnl ----------------
2364 dnl Verify that a test program compiles/links with GNAT.
2365 dnl $cf_ada_make is set to the program that compiles/links
2366 dnl $ADAFLAGS may be set to the GNAT flags.
2367 dnl
2368 dnl $1 is the text of the spec
2369 dnl $2 is the text of the body
2370 dnl $3 is the shell command to execute if successful
2371 dnl $4 is the shell command to execute if not successful
2372 AC_DEFUN([CF_GNAT_TRY_LINK],
2373 [
2374 rm -rf conftest* *~conftest*
2375 cat >>conftest.ads <<CF_EOF
2376 $1
2377 CF_EOF
2378 cat >>conftest.adb <<CF_EOF
2379 $2
2380 CF_EOF
2381 if ( $cf_ada_make $ADAFLAGS conftest 1>&AC_FD_CC 2>&1 ) ; then
2382 ifelse($3,,      :,[      $3])
2383 ifelse($4,,,[else
2384    $4])
2385 fi
2386 rm -rf conftest* *~conftest*
2387 ])dnl
2388 dnl ---------------------------------------------------------------------------
2389 dnl CF_GNAT_TRY_RUN version: 5 updated: 2011/03/19 14:47:45
2390 dnl ---------------
2391 dnl Verify that a test program compiles and runs with GNAT
2392 dnl $cf_ada_make is set to the program that compiles/links
2393 dnl $ADAFLAGS may be set to the GNAT flags.
2394 dnl
2395 dnl $1 is the text of the spec
2396 dnl $2 is the text of the body
2397 dnl $3 is the shell command to execute if successful
2398 dnl $4 is the shell command to execute if not successful
2399 AC_DEFUN([CF_GNAT_TRY_RUN],
2400 [
2401 rm -rf conftest* *~conftest*
2402 cat >>conftest.ads <<CF_EOF
2403 $1
2404 CF_EOF
2405 cat >>conftest.adb <<CF_EOF
2406 $2
2407 CF_EOF
2408 if ( $cf_ada_make $ADAFLAGS conftest 1>&AC_FD_CC 2>&1 ) ; then
2409    if ( ./conftest 1>&AC_FD_CC 2>&1 ) ; then
2410 ifelse($3,,      :,[      $3])
2411 ifelse($4,,,[   else
2412       $4])
2413    fi
2414 ifelse($4,,,[else
2415    $4])
2416 fi
2417 rm -rf conftest* *~conftest*
2418 ])dnl
2419 dnl ---------------------------------------------------------------------------
2420 dnl CF_GNAT_VERSION version: 18 updated: 2012/01/21 19:28:10
2421 dnl ---------------
2422 dnl Verify version of GNAT.
2423 AC_DEFUN([CF_GNAT_VERSION],
2424 [
2425 AC_MSG_CHECKING(for gnat version)
2426 cf_gnat_version=`${cf_ada_make:-gnatmake} -v 2>&1 | \
2427         grep '[[0-9]].[[0-9]][[0-9]]*' |\
2428     sed -e '2,$d' -e 's/[[^0-9 \.]]//g' -e 's/^[[ ]]*//' -e 's/ .*//'`
2429 AC_MSG_RESULT($cf_gnat_version)
2430
2431 case $cf_gnat_version in #(vi
2432 3.1[[1-9]]*|3.[[2-9]]*|[[4-9]].*|20[[0-9]][[0-9]]) #(vi
2433         cf_cv_prog_gnat_correct=yes
2434         ;;
2435 *)
2436         AC_MSG_WARN(Unsupported GNAT version $cf_gnat_version. We require 3.11 or better. Disabling Ada95 binding.)
2437         cf_cv_prog_gnat_correct=no
2438         ;;
2439 esac
2440 ])
2441 dnl ---------------------------------------------------------------------------
2442 dnl CF_GNU_SOURCE version: 6 updated: 2005/07/09 13:23:07
2443 dnl -------------
2444 dnl Check if we must define _GNU_SOURCE to get a reasonable value for
2445 dnl _XOPEN_SOURCE, upon which many POSIX definitions depend.  This is a defect
2446 dnl (or misfeature) of glibc2, which breaks portability of many applications,
2447 dnl since it is interwoven with GNU extensions.
2448 dnl
2449 dnl Well, yes we could work around it...
2450 AC_DEFUN([CF_GNU_SOURCE],
2451 [
2452 AC_CACHE_CHECK(if we must define _GNU_SOURCE,cf_cv_gnu_source,[
2453 AC_TRY_COMPILE([#include <sys/types.h>],[
2454 #ifndef _XOPEN_SOURCE
2455 make an error
2456 #endif],
2457         [cf_cv_gnu_source=no],
2458         [cf_save="$CPPFLAGS"
2459          CPPFLAGS="$CPPFLAGS -D_GNU_SOURCE"
2460          AC_TRY_COMPILE([#include <sys/types.h>],[
2461 #ifdef _XOPEN_SOURCE
2462 make an error
2463 #endif],
2464         [cf_cv_gnu_source=no],
2465         [cf_cv_gnu_source=yes])
2466         CPPFLAGS="$cf_save"
2467         ])
2468 ])
2469 test "$cf_cv_gnu_source" = yes && CPPFLAGS="$CPPFLAGS -D_GNU_SOURCE"
2470 ])dnl
2471 dnl ---------------------------------------------------------------------------
2472 dnl CF_GPP_LIBRARY version: 11 updated: 2012/10/06 17:56:13
2473 dnl --------------
2474 dnl If we're trying to use g++, test if libg++ is installed (a rather common
2475 dnl problem :-).  If we have the compiler but no library, we'll be able to
2476 dnl configure, but won't be able to build the c++ demo program.
2477 AC_DEFUN([CF_GPP_LIBRARY],
2478 [
2479 cf_cxx_library=unknown
2480 case $cf_cv_system_name in #(vi
2481 os2*) #(vi
2482         cf_gpp_libname=gpp
2483         ;;
2484 *)
2485         cf_gpp_libname=g++
2486         ;;
2487 esac
2488 if test "$GXX" = yes; then
2489         AC_MSG_CHECKING([for lib$cf_gpp_libname])
2490         cf_save="$LIBS"
2491         CF_ADD_LIB($cf_gpp_libname)
2492         AC_TRY_LINK([
2493 #include <$cf_gpp_libname/builtin.h>
2494         ],
2495         [two_arg_error_handler_t foo2 = lib_error_handler],
2496         [cf_cxx_library=yes
2497          CF_ADD_LIB($cf_gpp_libname,CXXLIBS)
2498          if test "$cf_gpp_libname" = cpp ; then
2499             AC_DEFINE(HAVE_GPP_BUILTIN_H,1,[Define to 1 if we have gpp builtin.h])
2500          else
2501             AC_DEFINE(HAVE_GXX_BUILTIN_H,1,[Define to 1 if we have g++ builtin.h])
2502          fi],
2503         [AC_TRY_LINK([
2504 #include <builtin.h>
2505         ],
2506         [two_arg_error_handler_t foo2 = lib_error_handler],
2507         [cf_cxx_library=yes
2508          CF_ADD_LIB($cf_gpp_libname,CXXLIBS)
2509          AC_DEFINE(HAVE_BUILTIN_H,1,[Define to 1 if we have builtin.h])],
2510         [cf_cxx_library=no])])
2511         LIBS="$cf_save"
2512         AC_MSG_RESULT($cf_cxx_library)
2513 fi
2514 ])dnl
2515 dnl ---------------------------------------------------------------------------
2516 dnl CF_GXX_VERSION version: 7 updated: 2012/06/16 14:55:39
2517 dnl --------------
2518 dnl Check for version of g++
2519 AC_DEFUN([CF_GXX_VERSION],[
2520 AC_REQUIRE([AC_PROG_CPP])
2521 GXX_VERSION=none
2522 if test "$GXX" = yes; then
2523         AC_MSG_CHECKING(version of ${CXX:-g++})
2524         GXX_VERSION="`${CXX:-g++} --version| sed -e '2,$d' -e 's/^.*(GCC) //' -e 's/^[[^0-9.]]*//' -e 's/[[^0-9.]].*//'`"
2525         test -z "$GXX_VERSION" && GXX_VERSION=unknown
2526         AC_MSG_RESULT($GXX_VERSION)
2527 fi
2528 ])dnl
2529 dnl ---------------------------------------------------------------------------
2530 dnl CF_GXX_WARNINGS version: 8 updated: 2013/11/16 14:27:53
2531 dnl ---------------
2532 dnl Check if the compiler supports useful warning options.
2533 dnl
2534 dnl Most of gcc's options apply to g++, except:
2535 dnl     -Wbad-function-cast
2536 dnl     -Wmissing-declarations
2537 dnl     -Wnested-externs
2538 dnl
2539 dnl Omit a few (for now):
2540 dnl     -Winline
2541 dnl
2542 dnl Parameter:
2543 dnl     $1 is an optional list of g++ warning flags that a particular
2544 dnl             application might want to use, e.g., "no-unused" for
2545 dnl             -Wno-unused
2546 dnl Special:
2547 dnl     If $with_ext_const is "yes", add a check for -Wwrite-strings
2548 dnl
2549 AC_DEFUN([CF_GXX_WARNINGS],
2550 [
2551
2552 CF_INTEL_COMPILER(GXX,INTEL_CPLUSPLUS,CXXFLAGS)
2553 CF_CLANG_COMPILER(GXX,CLANG_CPLUSPLUS,CXXFLAGS)
2554
2555 AC_REQUIRE([CF_GXX_VERSION])
2556
2557 AC_LANG_SAVE
2558 AC_LANG_CPLUSPLUS
2559
2560 cat > conftest.$ac_ext <<EOF
2561 #line __oline__ "configure"
2562 int main(int argc, char *argv[[]]) { return (argv[[argc-1]] == 0) ; }
2563 EOF
2564
2565 if test "$INTEL_CPLUSPLUS" = yes
2566 then
2567 # The "-wdXXX" options suppress warnings:
2568 # remark #1419: external declaration in primary source file
2569 # remark #1682: implicit conversion of a 64-bit integral type to a smaller integral type (potential portability problem)
2570 # remark #1683: explicit conversion of a 64-bit integral type to a smaller integral type (potential portability problem)
2571 # remark #1684: conversion from pointer to same-sized integral type (potential portability problem)
2572 # remark #193: zero used for undefined preprocessing identifier
2573 # remark #593: variable "curs_sb_left_arrow" was set but never used
2574 # remark #810: conversion from "int" to "Dimension={unsigned short}" may lose significant bits
2575 # remark #869: parameter "tw" was never referenced
2576 # remark #981: operands are evaluated in unspecified order
2577 # warning #269: invalid format string conversion
2578
2579         AC_CHECKING([for $CC warning options])
2580         cf_save_CXXFLAGS="$CXXFLAGS"
2581         EXTRA_CXXFLAGS="-Wall"
2582         for cf_opt in \
2583                 wd1419 \
2584                 wd1682 \
2585                 wd1683 \
2586                 wd1684 \
2587                 wd193 \
2588                 wd279 \
2589                 wd593 \
2590                 wd810 \
2591                 wd869 \
2592                 wd981
2593         do
2594                 CXXFLAGS="$cf_save_CXXFLAGS $EXTRA_CXXFLAGS -$cf_opt"
2595                 if AC_TRY_EVAL(ac_compile); then
2596                         test -n "$verbose" && AC_MSG_RESULT(... -$cf_opt)
2597                         EXTRA_CXXFLAGS="$EXTRA_CXXFLAGS -$cf_opt"
2598                 fi
2599         done
2600         CXXFLAGS="$cf_save_CXXFLAGS"
2601
2602 elif test "$GXX" = yes
2603 then
2604         AC_CHECKING([for $CXX warning options])
2605         cf_save_CXXFLAGS="$CXXFLAGS"
2606         EXTRA_CXXFLAGS="-W -Wall"
2607         cf_gxx_extra_warnings=""
2608         test "$with_ext_const" = yes && cf_gxx_extra_warnings="Wwrite-strings"
2609         case "$GCC_VERSION" in
2610         [[1-2]].*)
2611                 ;;
2612         *)
2613                 cf_gxx_extra_warnings="$cf_gxx_extra_warnings Weffc++"
2614                 ;;
2615         esac
2616         for cf_opt in \
2617                 Wabi \
2618                 fabi-version=0 \
2619                 Wextra \
2620                 Wignored-qualifiers \
2621                 Wlogical-op \
2622                 Woverloaded-virtual \
2623                 Wsign-promo \
2624                 Wsynth \
2625                 Wold-style-cast \
2626                 Wcast-align \
2627                 Wcast-qual \
2628                 Wpointer-arith \
2629                 Wshadow \
2630                 Wundef $cf_gxx_extra_warnings $1
2631         do
2632                 CXXFLAGS="$cf_save_CXXFLAGS $EXTRA_CXXFLAGS -Werror -$cf_opt"
2633                 if AC_TRY_EVAL(ac_compile); then
2634                         test -n "$verbose" && AC_MSG_RESULT(... -$cf_opt)
2635                         EXTRA_CXXFLAGS="$EXTRA_CXXFLAGS -$cf_opt"
2636                 else
2637                         test -n "$verbose" && AC_MSG_RESULT(... no -$cf_opt)
2638                 fi
2639         done
2640         CXXFLAGS="$cf_save_CXXFLAGS"
2641 fi
2642
2643 rm -rf conftest*
2644 AC_LANG_RESTORE
2645 AC_SUBST(EXTRA_CXXFLAGS)
2646 ])dnl
2647 dnl ---------------------------------------------------------------------------
2648 dnl CF_HASHED_DB version: 5 updated: 2014/04/12 16:47:01
2649 dnl ------------
2650 dnl Look for an instance of the Berkeley hashed database.
2651 dnl
2652 dnl $1 = optional parameter, to specify install-prefix for the database.
2653 AC_DEFUN([CF_HASHED_DB],
2654 [
2655 ifelse([$1],,,[
2656 case $1 in #(vi
2657 yes|*able*) #(vi
2658     ;;
2659 *)
2660     if test -d "$1" ; then
2661         CF_ADD_INCDIR($1/include)
2662         CF_ADD_LIBDIR($1/lib)
2663         else
2664                 case "$1" in #(vi
2665                 ./*|../*|/*)
2666                         AC_MSG_WARN(no such directory $1)
2667                         ;; #(vi
2668                 *)
2669                         CF_FIND_SUB_INCDIR($1)
2670                         CF_FIND_SUB_LIBDIR($1)
2671                         ;;
2672                 esac
2673     fi
2674 esac
2675 ])
2676 AC_CHECK_HEADER(db.h,[
2677 CF_HASHED_DB_VERSION
2678 if test "$cf_cv_hashed_db_version" = unknown ; then
2679         AC_MSG_ERROR(Cannot determine version of db)
2680 else
2681         CF_HASHED_DB_LIBS
2682         if test "$cf_cv_hashed_db_libs" = unknown ; then
2683                 AC_MSG_ERROR(Cannot determine library for db)
2684         elif test "$cf_cv_hashed_db_libs" != default ; then
2685                 CF_ADD_LIB($cf_cv_hashed_db_libs)
2686         fi
2687 fi
2688 ],[
2689         AC_MSG_ERROR(Cannot find db.h)
2690 ])
2691 ])dnl
2692 dnl ---------------------------------------------------------------------------
2693 dnl CF_HASHED_DB_LIBS version: 9 updated: 2010/05/29 16:31:02
2694 dnl -----------------
2695 dnl Given that we have the header and version for hashed database, find the
2696 dnl library information.
2697 AC_DEFUN([CF_HASHED_DB_LIBS],
2698 [
2699 AC_CACHE_CHECK(for db libraries, cf_cv_hashed_db_libs,[
2700 cf_cv_hashed_db_libs=unknown
2701 for cf_db_libs in "" db$cf_cv_hashed_db_version db-$cf_cv_hashed_db_version db ''
2702 do
2703         cf_save_libs="$LIBS"
2704         if test -n "$cf_db_libs"; then
2705                 CF_ADD_LIB($cf_db_libs)
2706         fi
2707         CF_MSG_LOG(checking for library "$cf_db_libs")
2708         AC_TRY_LINK([
2709 $ac_includes_default
2710 #include <db.h>
2711 ],[
2712         char *path = "/tmp/foo";
2713 #ifdef DB_VERSION_MAJOR
2714 #if DB_VERSION_MAJOR >= 4
2715         DB *result = 0;
2716         db_create(&result, NULL, 0);
2717         result->open(result,
2718                 NULL,
2719                 path,
2720                 path,
2721                 DB_HASH,
2722                 DB_CREATE,
2723                 0644);
2724 #elif DB_VERSION_MAJOR >= 3
2725         DB *result = 0;
2726         db_create(&result, NULL, 0);
2727         result->open(result,
2728                 path,
2729                 path,
2730                 DB_HASH,
2731                 DB_CREATE,
2732                 0644);
2733 #elif DB_VERSION_MAJOR >= 2
2734         DB *result = 0;
2735         db_open(path,
2736                 DB_HASH,
2737                 DB_CREATE,
2738                 0644,
2739                 (DB_ENV *) 0,
2740                 (DB_INFO *) 0,
2741                 &result);
2742 #endif /* DB_VERSION_MAJOR */
2743 #else
2744         DB *result = dbopen(path,
2745                      2,
2746                      0644,
2747                      DB_HASH,
2748                      0);
2749 #endif
2750         ${cf_cv_main_return:-return}(result != 0)
2751 ],[
2752         if test -n "$cf_db_libs" ; then
2753                 cf_cv_hashed_db_libs=$cf_db_libs
2754         else
2755                 cf_cv_hashed_db_libs=default
2756         fi
2757         LIBS="$cf_save_libs"
2758         break
2759 ])
2760         LIBS="$cf_save_libs"
2761 done
2762 ])
2763 ])dnl
2764 dnl ---------------------------------------------------------------------------
2765 dnl CF_HASHED_DB_VERSION version: 4 updated: 2014/04/12 16:47:01
2766 dnl --------------------
2767 dnl Given that we have the header file for hashed database, find the version
2768 dnl information.
2769 AC_DEFUN([CF_HASHED_DB_VERSION],
2770 [
2771 AC_CACHE_CHECK(for version of db, cf_cv_hashed_db_version,[
2772 cf_cv_hashed_db_version=unknown
2773
2774 for cf_db_version in 1 2 3 4 5 6
2775 do
2776         CF_MSG_LOG(checking for db version $cf_db_version)
2777         AC_TRY_COMPILE([
2778 $ac_includes_default
2779 #include <db.h>
2780
2781 #ifdef DB_VERSION_MAJOR
2782         /* db2 (DB_VERSION_MAJOR=2) has also DB_VERSION_MINOR, tested with 7 */
2783 #if $cf_db_version == DB_VERSION_MAJOR
2784         /* ok */
2785 #else
2786         make an error
2787 #endif
2788 #else
2789 #if $cf_db_version == 1
2790         /* ok: assuming this is DB 1.8.5 */
2791 #else
2792         make an error
2793 #endif
2794 #endif
2795 ],[DBT *foo = 0],[
2796         cf_cv_hashed_db_version=$cf_db_version
2797         break
2798         ])
2799 done
2800 ])
2801 ])dnl
2802 dnl ---------------------------------------------------------------------------
2803 dnl CF_HEADER_PATH version: 12 updated: 2010/05/05 05:22:40
2804 dnl --------------
2805 dnl Construct a search-list of directories for a nonstandard header-file
2806 dnl
2807 dnl Parameters
2808 dnl     $1 = the variable to return as result
2809 dnl     $2 = the package name
2810 AC_DEFUN([CF_HEADER_PATH],
2811 [
2812 $1=
2813
2814 # collect the current set of include-directories from compiler flags
2815 cf_header_path_list=""
2816 if test -n "${CFLAGS}${CPPFLAGS}" ; then
2817         for cf_header_path in $CPPFLAGS $CFLAGS
2818         do
2819                 case $cf_header_path in #(vi
2820                 -I*)
2821                         cf_header_path=`echo ".$cf_header_path" |sed -e 's/^...//' -e 's,/include$,,'`
2822                         CF_ADD_SUBDIR_PATH($1,$2,include,$cf_header_path,NONE)
2823                         cf_header_path_list="$cf_header_path_list [$]$1"
2824                         ;;
2825                 esac
2826         done
2827 fi
2828
2829 # add the variations for the package we are looking for
2830 CF_SUBDIR_PATH($1,$2,include)
2831
2832 test "$includedir" != NONE && \
2833 test "$includedir" != "/usr/include" && \
2834 test -d "$includedir" && {
2835         test -d $includedir &&    $1="[$]$1 $includedir"
2836         test -d $includedir/$2 && $1="[$]$1 $includedir/$2"
2837 }
2838
2839 test "$oldincludedir" != NONE && \
2840 test "$oldincludedir" != "/usr/include" && \
2841 test -d "$oldincludedir" && {
2842         test -d $oldincludedir    && $1="[$]$1 $oldincludedir"
2843         test -d $oldincludedir/$2 && $1="[$]$1 $oldincludedir/$2"
2844 }
2845
2846 $1="[$]$1 $cf_header_path_list"
2847 ])dnl
2848 dnl ---------------------------------------------------------------------------
2849 dnl CF_HELP_MESSAGE version: 3 updated: 1998/01/14 10:56:23
2850 dnl ---------------
2851 dnl Insert text into the help-message, for readability, from AC_ARG_WITH.
2852 AC_DEFUN([CF_HELP_MESSAGE],
2853 [AC_DIVERT_HELP([$1])dnl
2854 ])dnl
2855 dnl ---------------------------------------------------------------------------
2856 dnl CF_INCLUDE_DIRS version: 10 updated: 2014/09/19 20:58:42
2857 dnl ---------------
2858 dnl Construct the list of include-options according to whether we're building
2859 dnl in the source directory or using '--srcdir=DIR' option.
2860 AC_DEFUN([CF_INCLUDE_DIRS],
2861 [
2862 if test "$srcdir" != "."; then
2863         CPPFLAGS="-I\${srcdir}/../include $CPPFLAGS"
2864 fi
2865 CPPFLAGS="-I../include $CPPFLAGS"
2866 if test "$srcdir" != "."; then
2867         CPPFLAGS="-I\${srcdir} $CPPFLAGS"
2868 fi
2869 CPPFLAGS="-I. $CPPFLAGS"
2870 AC_SUBST(CPPFLAGS)
2871 ])dnl
2872 dnl ---------------------------------------------------------------------------
2873 dnl CF_INTEL_COMPILER version: 6 updated: 2014/03/17 13:13:07
2874 dnl -----------------
2875 dnl Check if the given compiler is really the Intel compiler for Linux.  It
2876 dnl tries to imitate gcc, but does not return an error when it finds a mismatch
2877 dnl between prototypes, e.g., as exercised by CF_MISSING_CHECK.
2878 dnl
2879 dnl This macro should be run "soon" after AC_PROG_CC or AC_PROG_CPLUSPLUS, to
2880 dnl ensure that it is not mistaken for gcc/g++.  It is normally invoked from
2881 dnl the wrappers for gcc and g++ warnings.
2882 dnl
2883 dnl $1 = GCC (default) or GXX
2884 dnl $2 = INTEL_COMPILER (default) or INTEL_CPLUSPLUS
2885 dnl $3 = CFLAGS (default) or CXXFLAGS
2886 AC_DEFUN([CF_INTEL_COMPILER],[
2887 AC_REQUIRE([AC_CANONICAL_HOST])
2888 ifelse([$2],,INTEL_COMPILER,[$2])=no
2889
2890 if test "$ifelse([$1],,[$1],GCC)" = yes ; then
2891         case $host_os in
2892         linux*|gnu*)
2893                 AC_MSG_CHECKING(if this is really Intel ifelse([$1],GXX,C++,C) compiler)
2894                 cf_save_CFLAGS="$ifelse([$3],,CFLAGS,[$3])"
2895                 ifelse([$3],,CFLAGS,[$3])="$ifelse([$3],,CFLAGS,[$3]) -no-gcc"
2896                 AC_TRY_COMPILE([],[
2897 #ifdef __INTEL_COMPILER
2898 #else
2899 make an error
2900 #endif
2901 ],[ifelse([$2],,INTEL_COMPILER,[$2])=yes
2902 cf_save_CFLAGS="$cf_save_CFLAGS -we147"
2903 ],[])
2904                 ifelse([$3],,CFLAGS,[$3])="$cf_save_CFLAGS"
2905                 AC_MSG_RESULT($ifelse([$2],,INTEL_COMPILER,[$2]))
2906                 ;;
2907         esac
2908 fi
2909 ])dnl
2910 dnl ---------------------------------------------------------------------------
2911 dnl CF_ISASCII version: 4 updated: 2012/10/06 17:56:13
2912 dnl ----------
2913 dnl Check if we have either a function or macro for 'isascii()'.
2914 AC_DEFUN([CF_ISASCII],
2915 [
2916 AC_MSG_CHECKING(for isascii)
2917 AC_CACHE_VAL(cf_cv_have_isascii,[
2918         AC_TRY_LINK([#include <ctype.h>],[int x = isascii(' ')],
2919         [cf_cv_have_isascii=yes],
2920         [cf_cv_have_isascii=no])
2921 ])dnl
2922 AC_MSG_RESULT($cf_cv_have_isascii)
2923 test "$cf_cv_have_isascii" = yes && AC_DEFINE(HAVE_ISASCII,1,[Define to 1 if we have isascii()])
2924 ])dnl
2925 dnl ---------------------------------------------------------------------------
2926 dnl CF_LARGEFILE version: 8 updated: 2012/10/06 08:57:51
2927 dnl ------------
2928 dnl Add checks for large file support.
2929 AC_DEFUN([CF_LARGEFILE],[
2930 ifdef([AC_FUNC_FSEEKO],[
2931     AC_SYS_LARGEFILE
2932     if test "$enable_largefile" != no ; then
2933         AC_FUNC_FSEEKO
2934
2935         # Normally we would collect these definitions in the config.h,
2936         # but (like _XOPEN_SOURCE), some environments rely on having these
2937         # defined before any of the system headers are included.  Another
2938         # case comes up with C++, e.g., on AIX the compiler compiles the
2939         # header files by themselves before looking at the body files it is
2940         # told to compile.  For ncurses, those header files do not include
2941         # the config.h
2942         test "$ac_cv_sys_large_files"      != no && CPPFLAGS="$CPPFLAGS -D_LARGE_FILES "
2943         test "$ac_cv_sys_largefile_source" != no && CPPFLAGS="$CPPFLAGS -D_LARGEFILE_SOURCE "
2944         test "$ac_cv_sys_file_offset_bits" != no && CPPFLAGS="$CPPFLAGS -D_FILE_OFFSET_BITS=$ac_cv_sys_file_offset_bits "
2945
2946         AC_CACHE_CHECK(whether to use struct dirent64, cf_cv_struct_dirent64,[
2947                 AC_TRY_COMPILE([
2948 #include <sys/types.h>
2949 #include <dirent.h>
2950                 ],[
2951                 /* if transitional largefile support is setup, this is true */
2952                 extern struct dirent64 * readdir(DIR *);
2953                 struct dirent64 *x = readdir((DIR *)0);
2954                 struct dirent *y = readdir((DIR *)0);
2955                 int z = x - y;
2956                 ],
2957                 [cf_cv_struct_dirent64=yes],
2958                 [cf_cv_struct_dirent64=no])
2959         ])
2960         test "$cf_cv_struct_dirent64" = yes && AC_DEFINE(HAVE_STRUCT_DIRENT64,1,[Define to 1 if we have struct dirent64])
2961     fi
2962 ])
2963 ])
2964 dnl ---------------------------------------------------------------------------
2965 dnl CF_LDFLAGS_STATIC version: 10 updated: 2011/09/24 12:51:48
2966 dnl -----------------
2967 dnl Check for compiler/linker flags used to temporarily force usage of static
2968 dnl libraries.  This depends on the compiler and platform.  Use this to help
2969 dnl ensure that the linker picks up a given library based on its position in
2970 dnl the list of linker options and libraries.
2971 AC_DEFUN([CF_LDFLAGS_STATIC],[
2972
2973 if test "$GCC" = yes ; then
2974         case $cf_cv_system_name in #(
2975         OS/2*|os2*|aix[[4]]*|solaris2.1[[0-9]]|darwin*)         #( vi
2976                 LDFLAGS_STATIC=
2977                 LDFLAGS_SHARED=
2978                 ;;
2979     *)  #( normally, except when broken
2980         LDFLAGS_STATIC=-static
2981         LDFLAGS_SHARED=-dynamic
2982         ;;
2983     esac
2984 else
2985         case $cf_cv_system_name in #(
2986         aix[[4-7]]*)    #( from ld manpage
2987                 LDFLAGS_STATIC=-bstatic
2988                 LDFLAGS_SHARED=-bdynamic
2989                 ;;
2990         hpux*)          #( from ld manpage for hpux10.20, hpux11.11
2991                 # We could also use just "archive" and "shared".
2992                 LDFLAGS_STATIC=-Wl,-a,archive_shared
2993                 LDFLAGS_SHARED=-Wl,-a,shared_archive
2994                 ;;
2995         irix*)          #( from ld manpage IRIX64
2996                 LDFLAGS_STATIC=-Bstatic
2997                 LDFLAGS_SHARED=-Bdynamic
2998                 ;;
2999         osf[[45]]*)     #( from ld manpage osf4.0d, osf5.1
3000                 # alternative "-oldstyle_liblookup" (not in cc manpage)
3001                 LDFLAGS_STATIC=-noso
3002                 LDFLAGS_SHARED=-so_archive
3003                 ;;
3004         solaris2*)
3005                 LDFLAGS_STATIC=-Bstatic
3006                 LDFLAGS_SHARED=-Bdynamic
3007                 ;;
3008         esac
3009 fi
3010
3011 if test -n "$LDFLAGS_STATIC" && test -n "$LDFLAGS_SHARED"
3012 then
3013         AC_MSG_CHECKING(if linker supports switching between static/dynamic)
3014
3015         rm -f libconftest.a
3016         cat >conftest.$ac_ext <<EOF
3017 #line __oline__ "configure"
3018 #include <stdio.h>
3019 int cf_ldflags_static(FILE *fp) { return fflush(fp); }
3020 EOF
3021         if AC_TRY_EVAL(ac_compile) ; then
3022                 ( $AR $ARFLAGS libconftest.a conftest.o ) 2>&AC_FD_CC 1>/dev/null
3023                 ( eval $RANLIB libconftest.a ) 2>&AC_FD_CC >/dev/null
3024         fi
3025         rm -f conftest.*
3026
3027         cf_save_LIBS="$LIBS"
3028
3029         LIBS="$LDFLAGS_STATIC -L`pwd` -lconftest $LDFLAGS_DYNAMIC $LIBS"
3030         AC_TRY_LINK([
3031 #line __oline__ "configure"
3032 #include <stdio.h>
3033 int cf_ldflags_static(FILE *fp);
3034 ],[
3035         return cf_ldflags_static(stdin);
3036 ],[
3037         # some linkers simply ignore the -dynamic
3038         case x`file conftest$ac_exeext 2>/dev/null` in #(vi
3039         *static*) # (vi
3040                 cf_ldflags_static=no
3041                 ;;
3042         *)
3043                 cf_ldflags_static=yes
3044                 ;;
3045         esac
3046 ],[cf_ldflags_static=no])
3047
3048         rm -f libconftest.*
3049         LIBS="$cf_save_LIBS"
3050
3051         AC_MSG_RESULT($cf_ldflags_static)
3052
3053         if test $cf_ldflags_static != yes
3054         then
3055                 LDFLAGS_STATIC=
3056                 LDFLAGS_SHARED=
3057         fi
3058 else
3059         LDFLAGS_STATIC=
3060         LDFLAGS_SHARED=
3061 fi
3062
3063 AC_SUBST(LDFLAGS_STATIC)
3064 AC_SUBST(LDFLAGS_SHARED)
3065 ])
3066 dnl ---------------------------------------------------------------------------
3067 dnl CF_LD_RPATH_OPT version: 5 updated: 2011/07/17 14:48:41
3068 dnl ---------------
3069 dnl For the given system and compiler, find the compiler flags to pass to the
3070 dnl loader to use the "rpath" feature.
3071 AC_DEFUN([CF_LD_RPATH_OPT],
3072 [
3073 AC_REQUIRE([CF_CHECK_CACHE])
3074
3075 LD_RPATH_OPT=
3076 AC_MSG_CHECKING(for an rpath option)
3077 case $cf_cv_system_name in #(vi
3078 irix*) #(vi
3079         if test "$GCC" = yes; then
3080                 LD_RPATH_OPT="-Wl,-rpath,"
3081         else
3082                 LD_RPATH_OPT="-rpath "
3083         fi
3084         ;;
3085 linux*|gnu*|k*bsd*-gnu) #(vi
3086         LD_RPATH_OPT="-Wl,-rpath,"
3087         ;;
3088 openbsd[[2-9]].*|mirbsd*) #(vi
3089         LD_RPATH_OPT="-Wl,-rpath,"
3090         ;;
3091 dragonfly*|freebsd*) #(vi
3092         LD_RPATH_OPT="-rpath "
3093         ;;
3094 netbsd*) #(vi
3095         LD_RPATH_OPT="-Wl,-rpath,"
3096         ;;
3097 osf*|mls+*) #(vi
3098         LD_RPATH_OPT="-rpath "
3099         ;;
3100 solaris2*) #(vi
3101         LD_RPATH_OPT="-R"
3102         ;;
3103 *)
3104         ;;
3105 esac
3106 AC_MSG_RESULT($LD_RPATH_OPT)
3107
3108 case "x$LD_RPATH_OPT" in #(vi
3109 x-R*)
3110         AC_MSG_CHECKING(if we need a space after rpath option)
3111         cf_save_LIBS="$LIBS"
3112         CF_ADD_LIBS(${LD_RPATH_OPT}$libdir)
3113         AC_TRY_LINK(, , cf_rpath_space=no, cf_rpath_space=yes)
3114         LIBS="$cf_save_LIBS"
3115         AC_MSG_RESULT($cf_rpath_space)
3116         test "$cf_rpath_space" = yes && LD_RPATH_OPT="$LD_RPATH_OPT "
3117         ;;
3118 esac
3119 ])dnl
3120 dnl ---------------------------------------------------------------------------
3121 dnl CF_LIBRARY_PATH version: 9 updated: 2010/03/28 12:52:50
3122 dnl ---------------
3123 dnl Construct a search-list of directories for a nonstandard library-file
3124 dnl
3125 dnl Parameters
3126 dnl     $1 = the variable to return as result
3127 dnl     $2 = the package name
3128 AC_DEFUN([CF_LIBRARY_PATH],
3129 [
3130 $1=
3131 cf_library_path_list=""
3132 if test -n "${LDFLAGS}${LIBS}" ; then
3133         for cf_library_path in $LDFLAGS $LIBS
3134         do
3135                 case $cf_library_path in #(vi
3136                 -L*)
3137                         cf_library_path=`echo ".$cf_library_path" |sed -e 's/^...//' -e 's,/lib$,,'`
3138                         CF_ADD_SUBDIR_PATH($1,$2,lib,$cf_library_path,NONE)
3139                         cf_library_path_list="$cf_library_path_list [$]$1"
3140                         ;;
3141                 esac
3142         done
3143 fi
3144
3145 CF_SUBDIR_PATH($1,$2,lib)
3146
3147 $1="$cf_library_path_list [$]$1"
3148 ])dnl
3149 dnl ---------------------------------------------------------------------------
3150 dnl CF_LIBTOOL_VERSION version: 1 updated: 2013/04/06 18:03:09
3151 dnl ------------------
3152 AC_DEFUN([CF_LIBTOOL_VERSION],[
3153 if test -n "$LIBTOOL" && test "$LIBTOOL" != none
3154 then
3155         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.]].*//'`
3156 else
3157         cf_cv_libtool_version=
3158 fi
3159 test -z "$cf_cv_libtool_version" && unset cf_cv_libtool_version
3160 ])dnl
3161 dnl ---------------------------------------------------------------------------
3162 dnl CF_LIB_PREFIX version: 9 updated: 2012/01/21 19:28:10
3163 dnl -------------
3164 dnl Compute the library-prefix for the given host system
3165 dnl $1 = variable to set
3166 define([CF_LIB_PREFIX],
3167 [
3168         case $cf_cv_system_name in #(vi
3169         OS/2*|os2*) #(vi
3170         LIB_PREFIX=''
3171         ;;
3172         *)      LIB_PREFIX='lib'
3173         ;;
3174         esac
3175 ifelse($1,,,[$1=$LIB_PREFIX])
3176         AC_SUBST(LIB_PREFIX)
3177 ])dnl
3178 dnl ---------------------------------------------------------------------------
3179 dnl CF_LIB_RULES version: 75 updated: 2014/09/20 20:16:32
3180 dnl ------------
3181 dnl Append definitions and rules for the given models to the subdirectory
3182 dnl Makefiles, and the recursion rule for the top-level Makefile.  If the
3183 dnl subdirectory is a library-source directory, modify the Libs_To_Make list in
3184 dnl the corresponding makefile to list the models that we'll generate.
3185 dnl
3186 dnl For shared libraries, make a list of symbolic links to construct when
3187 dnl generating each library.  The convention used for Linux is the simplest
3188 dnl one:
3189 dnl     lib<name>.so    ->
3190 dnl     lib<name>.so.<major>    ->
3191 dnl     lib<name>.so.<maj>.<minor>
3192 dnl
3193 dnl Note: Libs_To_Make is mixed case, since it is not a pure autoconf variable.
3194 AC_DEFUN([CF_LIB_RULES],
3195 [
3196 cf_prefix=$LIB_PREFIX
3197 AC_REQUIRE([CF_SUBST_NCURSES_VERSION])
3198
3199 case $cf_cv_shlib_version in #(vi
3200 cygdll|msysdll|mingw)
3201         TINFO_NAME=$TINFO_ARG_SUFFIX
3202         TINFO_SUFFIX=.dll
3203         ;;
3204 esac
3205
3206 if test -n "$TINFO_SUFFIX" ; then
3207         case $TINFO_SUFFIX in
3208         tw*)
3209                 TINFO_NAME="${TINFO_NAME}tw"
3210                 TINFO_SUFFIX=`echo $TINFO_SUFFIX | sed 's/^tw//'`
3211                 ;;
3212         t*)
3213                 TINFO_NAME="${TINFO_NAME}t"
3214                 TINFO_SUFFIX=`echo $TINFO_SUFFIX | sed 's/^t//'`
3215                 ;;
3216         w*)
3217                 TINFO_NAME="${TINFO_NAME}w"
3218                 TINFO_SUFFIX=`echo $TINFO_SUFFIX | sed 's/^w//'`
3219                 ;;
3220         esac
3221 fi
3222
3223 for cf_dir in $SRC_SUBDIRS
3224 do
3225         if test ! -d $srcdir/$cf_dir ; then
3226                 continue
3227         elif test -f $srcdir/$cf_dir/modules; then
3228
3229                 SHARED_LIB=
3230                 Libs_To_Make=
3231                 for cf_item in $cf_LIST_MODELS
3232                 do
3233                         CF_LIB_SUFFIX($cf_item,cf_suffix,cf_depsuf)
3234                         cf_libname=$cf_dir
3235                         test "$cf_dir" = c++ && cf_libname=ncurses++
3236                         if test $cf_item = shared ; then
3237                                 if test -n "${LIB_SUFFIX}"
3238                                 then
3239                                         cf_shared_suffix=`echo "$cf_suffix" | sed 's/^'"${LIB_SUFFIX}"'//'`
3240                                 else
3241                                         cf_shared_suffix="$cf_suffix"
3242                                 fi
3243                                 if test "$cf_cv_do_symlinks" = yes ; then
3244                                         cf_version_name=
3245
3246                                         case "$cf_cv_shlib_version" in #(vi
3247                                         rel) #(vi
3248                                                 cf_version_name=REL_VERSION
3249                                                 ;;
3250                                         abi)
3251                                                 cf_version_name=ABI_VERSION
3252                                                 ;;
3253                                         esac
3254
3255                                         if test -n "$cf_version_name"
3256                                         then
3257                                                 case "$cf_cv_system_name" in #(vi
3258                                                 darwin*)
3259                                                         # "w", etc?
3260                                                         cf_suffix="${LIB_SUFFIX}"'.${'$cf_version_name'}'"$cf_shared_suffix"
3261                                                         ;; #(vi
3262                                                 *)
3263                                                         cf_suffix="$cf_suffix"'.${'$cf_version_name'}'
3264                                                         ;;
3265                                                 esac
3266                                         fi
3267                                         if test -n "${LIB_SUFFIX}"
3268                                         then
3269                                                 cf_shared_suffix=`echo "$cf_suffix" | sed 's/^'"${LIB_SUFFIX}"'//'`
3270                                         else
3271                                                 cf_shared_suffix="$cf_suffix"
3272                                         fi
3273                                 fi
3274                                 # cygwin needs import library, and has unique naming convention
3275                                 # use autodetected ${cf_prefix} for import lib and static lib, but
3276                                 # use 'cyg' prefix for shared lib.
3277                                 case $cf_cv_shlib_version in #(vi
3278                                 cygdll) #(vi
3279                                         cf_cygsuf=`echo "$cf_suffix" | sed -e 's/\.dll/\${ABI_VERSION}.dll/'`
3280                                         Libs_To_Make="$Libs_To_Make ../lib/cyg${cf_libname}${cf_cygsuf}"
3281                                         continue
3282                                         ;;
3283                                 msysdll) #(vi
3284                                         cf_cygsuf=`echo "$cf_suffix" | sed -e 's/\.dll/\${ABI_VERSION}.dll/'`
3285                                         Libs_To_Make="$Libs_To_Make ../lib/msys-${cf_libname}${cf_cygsuf}"
3286                                         continue
3287                                         ;;
3288                                 mingw)
3289                                         cf_cygsuf=`echo "$cf_suffix" | sed -e 's/\.dll/\${ABI_VERSION}.dll/'`
3290                                         Libs_To_Make="$Libs_To_Make ../lib/lib${cf_libname}${cf_cygsuf}"
3291                                         continue
3292                                         ;;
3293                                 esac
3294                         fi
3295                         Libs_To_Make="$Libs_To_Make ../lib/${cf_prefix}${cf_libname}${cf_suffix}"
3296                 done
3297
3298                 if test $cf_dir = ncurses ; then
3299                         cf_subsets="$LIB_SUBSETS"
3300                         cf_r_parts="$cf_subsets"
3301                         cf_liblist="$Libs_To_Make"
3302
3303                         while test -n "$cf_r_parts"
3304                         do
3305                                 cf_l_parts=`echo "$cf_r_parts" |sed -e 's/ .*$//'`
3306                                 cf_r_parts=`echo "$cf_r_parts" |sed -e 's/^[[^ ]]* //'`
3307                                 if test "$cf_l_parts" != "$cf_r_parts" ; then
3308                                         cf_item=
3309                                         case $cf_l_parts in #(vi
3310                                         *termlib*) #(vi
3311                                                 cf_item=`echo $cf_liblist |sed -e s%${LIB_NAME}${LIB_SUFFIX}%${TINFO_LIB_SUFFIX}%g`
3312                                                 ;;
3313                                         *ticlib*)
3314                                                 cf_item=`echo $cf_liblist |sed -e s%${LIB_NAME}${LIB_SUFFIX}%${TICS_LIB_SUFFIX}%g`
3315                                                 ;;
3316                                         *)
3317                                                 break
3318                                                 ;;
3319                                         esac
3320                                         if test -n "$cf_item"; then
3321                                                 Libs_To_Make="$cf_item $Libs_To_Make"
3322                                         fi
3323                                 else
3324                                         break
3325                                 fi
3326                         done
3327                 else
3328                         cf_subsets=`echo "$LIB_SUBSETS" | sed -e 's/^termlib.* //'`
3329                 fi
3330
3331                 if test $cf_dir = c++; then
3332                         if test "x$with_shared_cxx" != xyes && test -n "$cf_shared_suffix"; then
3333                                 cf_list=
3334                                 for cf_item in $Libs_To_Make
3335                                 do
3336                                         case $cf_item in
3337                                         *.a)
3338                                                 ;;
3339                                         *)
3340                                                 cf_item=`echo "$cf_item" | sed -e "s,"$cf_shared_suffix",.a,"`
3341                                                 ;;
3342                                         esac
3343                                         for cf_test in $cf_list
3344                                         do
3345                                                 if test "$cf_test" = "$cf_item"
3346                                                 then
3347                                                         cf_LIST_MODELS=`echo "$cf_LIST_MODELS" | sed -e 's/normal//'`
3348                                                         cf_item=
3349                                                         break
3350                                                 fi
3351                                         done
3352                                         test -n "$cf_item" && cf_list="$cf_list $cf_item"
3353                                 done
3354                                 Libs_To_Make="$cf_list"
3355                         fi
3356                 fi
3357
3358                 sed -e "s%@Libs_To_Make@%$Libs_To_Make%" \
3359                     -e "s%@SHARED_LIB@%$SHARED_LIB%" \
3360                         $cf_dir/Makefile >$cf_dir/Makefile.out
3361                 mv $cf_dir/Makefile.out $cf_dir/Makefile
3362
3363                 $AWK -f $srcdir/mk-0th.awk \
3364                         libname="${cf_dir}${LIB_SUFFIX}" subsets="$LIB_SUBSETS" ticlib="$TICS_LIB_SUFFIX" termlib="$TINFO_LIB_SUFFIX" \
3365                         $srcdir/$cf_dir/modules >>$cf_dir/Makefile
3366
3367                 for cf_subset in $cf_subsets
3368                 do
3369                         cf_subdirs=
3370                         for cf_item in $cf_LIST_MODELS
3371                         do
3372
3373                         echo "Appending rules for ${cf_item} model (${cf_dir}: ${cf_subset})"
3374                         CF_UPPER(cf_ITEM,$cf_item)
3375
3376                         CXX_MODEL=$cf_ITEM
3377                         if test "$CXX_MODEL" = SHARED; then
3378                                 case $cf_cv_shlib_version in #(vi
3379                                 cygdll|msysdll|mingw) #(vi
3380                                         test "x$with_shared_cxx" = xno && CF_VERBOSE(overriding CXX_MODEL to SHARED)
3381                                         with_shared_cxx=yes
3382                                         ;;
3383                                 *)
3384                                         test "x$with_shared_cxx" = xno && CXX_MODEL=NORMAL
3385                                         ;;
3386                                 esac
3387                         fi
3388
3389                         CF_LIB_SUFFIX($cf_item,cf_suffix,cf_depsuf)
3390                         CF_OBJ_SUBDIR($cf_item,cf_subdir)
3391
3392                         # Test for case where we build libtinfo with a different name.
3393                         cf_libname=$cf_dir
3394                         if test $cf_dir = ncurses ; then
3395                                 case $cf_subset in
3396                                 *base*)
3397                                         cf_libname=${cf_libname}$LIB_SUFFIX
3398                                         ;;
3399                                 *termlib*)
3400                                         cf_libname=$TINFO_LIB_SUFFIX
3401                                         ;;
3402                                 ticlib*)
3403                                         cf_libname=$TICS_LIB_SUFFIX
3404                                         ;;
3405                                 esac
3406                         elif test $cf_dir = c++ ; then
3407                                 cf_libname=ncurses++$LIB_SUFFIX
3408                         else
3409                                 cf_libname=${cf_libname}$LIB_SUFFIX
3410                         fi
3411                         if test -n "${DFT_ARG_SUFFIX}" ; then
3412                                 # undo $LIB_SUFFIX add-on in CF_LIB_SUFFIX
3413                                 cf_suffix=`echo $cf_suffix |sed -e "s%^${LIB_SUFFIX}%%"`
3414                         fi
3415
3416                         # These dependencies really are for development, not
3417                         # builds, but they are useful in porting, too.
3418                         cf_depend="../include/ncurses_cfg.h"
3419                         if test "$srcdir" = "."; then
3420                                 cf_reldir="."
3421                         else
3422                                 cf_reldir="\${srcdir}"
3423                         fi
3424
3425                         if test -f $srcdir/$cf_dir/$cf_dir.priv.h; then
3426                                 cf_depend="$cf_depend $cf_reldir/$cf_dir.priv.h"
3427                         elif test -f $srcdir/$cf_dir/curses.priv.h; then
3428                                 cf_depend="$cf_depend $cf_reldir/curses.priv.h"
3429                         fi
3430
3431                         cf_dir_suffix=
3432                         old_cf_suffix="$cf_suffix"
3433                         if test "$cf_cv_shlib_version_infix" = yes ; then
3434                         if test -n "$LIB_SUFFIX" ; then
3435                                 case $LIB_SUFFIX in
3436                                 tw*)
3437                                         cf_libname=`echo $cf_libname | sed 's/tw$//'`
3438                                         cf_suffix=`echo $cf_suffix | sed 's/^tw//'`
3439                                         cf_dir_suffix=tw
3440                                         ;;
3441                                 t*)
3442                                         cf_libname=`echo $cf_libname | sed 's/t$//'`
3443                                         cf_suffix=`echo $cf_suffix | sed 's/^t//'`
3444                                         cf_dir_suffix=t
3445                                         ;;
3446                                 w*)
3447                                         cf_libname=`echo $cf_libname | sed 's/w$//'`
3448                                         cf_suffix=`echo $cf_suffix | sed 's/^w//'`
3449                                         cf_dir_suffix=w
3450                                         ;;
3451                                 esac
3452                         fi
3453                         fi
3454
3455                         $AWK -f $srcdir/mk-1st.awk \
3456                                 name=${cf_libname}${cf_dir_suffix} \
3457                                 traces=$LIB_TRACING \
3458                                 MODEL=$cf_ITEM \
3459                                 CXX_MODEL=$CXX_MODEL \
3460                                 model=$cf_subdir \
3461                                 prefix=$cf_prefix \
3462                                 suffix=$cf_suffix \
3463                                 subset=$cf_subset \
3464                                 driver=$cf_cv_term_driver \
3465                                 SymLink="$LN_S" \
3466                                 TermlibRoot=$TINFO_NAME \
3467                                 TermlibSuffix=$TINFO_SUFFIX \
3468                                 ShlibVer=$cf_cv_shlib_version \
3469                                 ShlibVerInfix=$cf_cv_shlib_version_infix \
3470                                 ReLink=${cf_cv_do_relink:-no} \
3471                                 DoLinks=$cf_cv_do_symlinks \
3472                                 rmSoLocs=$cf_cv_rm_so_locs \
3473                                 ldconfig="$LDCONFIG" \
3474                                 overwrite=$WITH_OVERWRITE \
3475                                 depend="$cf_depend" \
3476                                 host="$host" \
3477                                 libtool_version="$LIBTOOL_VERSION" \
3478                                 $srcdir/$cf_dir/modules >>$cf_dir/Makefile
3479
3480                         cf_suffix="$old_cf_suffix"
3481
3482                         for cf_subdir2 in $cf_subdirs lib
3483                         do
3484                                 test $cf_subdir = $cf_subdir2 && break
3485                         done
3486                         test "${cf_subset}.${cf_subdir2}" != "${cf_subset}.${cf_subdir}" && \
3487                         $AWK -f $srcdir/mk-2nd.awk \
3488                                 name=$cf_dir \
3489                                 traces=$LIB_TRACING \
3490                                 MODEL=$cf_ITEM \
3491                                 model=$cf_subdir \
3492                                 subset=$cf_subset \
3493                                 srcdir=$srcdir \
3494                                 echo=$WITH_ECHO \
3495                                 crenames=$cf_cv_prog_CC_c_o \
3496                                 cxxrenames=$cf_cv_prog_CXX_c_o \
3497                                 $srcdir/$cf_dir/modules >>$cf_dir/Makefile
3498                         cf_subdirs="$cf_subdirs $cf_subdir"
3499                         done
3500                 done
3501         fi
3502
3503         echo '  cd '$cf_dir' && ${MAKE} ${TOP_MFLAGS} [$]@' >>Makefile
3504 done
3505
3506 for cf_dir in $SRC_SUBDIRS
3507 do
3508         if test ! -d $srcdir/$cf_dir ; then
3509                 continue
3510         fi
3511
3512         if test -f $cf_dir/Makefile ; then
3513                 case "$cf_dir" in
3514                 Ada95) #(vi
3515                         echo 'libs \' >> Makefile
3516                         echo 'install.libs \' >> Makefile
3517                         echo 'uninstall.libs ::' >> Makefile
3518                         echo '  cd '$cf_dir' && ${MAKE} ${TOP_MFLAGS} [$]@' >> Makefile
3519                         ;;
3520                 esac
3521         fi
3522
3523         if test -f $srcdir/$cf_dir/modules; then
3524                 echo >> Makefile
3525                 if test -f $srcdir/$cf_dir/headers; then
3526 cat >> Makefile <<CF_EOF
3527 install.includes \\
3528 uninstall.includes \\
3529 CF_EOF
3530                 fi
3531 if test "$cf_dir" != "c++" ; then
3532 echo 'lint \' >> Makefile
3533 fi
3534 cat >> Makefile <<CF_EOF
3535 libs \\
3536 lintlib \\
3537 install.libs \\
3538 uninstall.libs \\
3539 install.$cf_dir \\
3540 uninstall.$cf_dir ::
3541         cd $cf_dir && \${MAKE} \${TOP_MFLAGS} \[$]@
3542 CF_EOF
3543         elif test -f $srcdir/$cf_dir/headers; then
3544 cat >> Makefile <<CF_EOF
3545
3546 libs \\
3547 install.libs \\
3548 uninstall.libs \\
3549 install.includes \\
3550 uninstall.includes ::
3551         cd $cf_dir && \${MAKE} \${TOP_MFLAGS} \[$]@
3552 CF_EOF
3553 fi
3554 done
3555
3556 if test "x$cf_with_db_install" = xyes; then
3557 cat >> Makefile <<CF_EOF
3558
3559 install.libs uninstall.libs \\
3560 install.data uninstall.data ::
3561 $MAKE_TERMINFO  cd misc && \${MAKE} \${TOP_MFLAGS} \[$]@
3562 CF_EOF
3563 else
3564 cat >> Makefile <<CF_EOF
3565
3566 install.libs uninstall.libs ::
3567         cd misc && \${MAKE} \${TOP_MFLAGS} \[$]@
3568 CF_EOF
3569 fi
3570
3571 if test "x$cf_with_manpages" = xyes; then
3572 cat >> Makefile <<CF_EOF
3573
3574 install.man \\
3575 uninstall.man ::
3576         cd man && \${MAKE} \${TOP_MFLAGS} \[$]@
3577 CF_EOF
3578 fi
3579
3580 cat >> Makefile <<CF_EOF
3581
3582 distclean ::
3583         rm -f config.cache config.log config.status Makefile include/ncurses_cfg.h
3584         rm -f headers.sh headers.sed mk_shared_lib.sh
3585         rm -f edit_man.* man_alias.*
3586         rm -rf \${DIRS_TO_MAKE}
3587 CF_EOF
3588
3589 # Special case: tack's manpage lives in its own directory.
3590 if test "x$cf_with_manpages" = xyes; then
3591 if test -d tack ; then
3592 if test -f $srcdir/$tack.h; then
3593 cat >> Makefile <<CF_EOF
3594
3595 install.man \\
3596 uninstall.man ::
3597         cd tack && \${MAKE} \${TOP_MFLAGS} \[$]@
3598 CF_EOF
3599 fi
3600 fi
3601 fi
3602
3603 dnl If we're installing into a subdirectory of /usr/include, etc., we should
3604 dnl prepend the subdirectory's name to the "#include" paths.  It won't hurt
3605 dnl anything, and will make it more standardized.  It's awkward to decide this
3606 dnl at configuration because of quoting, so we'll simply make all headers
3607 dnl installed via a script that can do the right thing.
3608
3609 rm -f headers.sed headers.sh
3610
3611 dnl ( generating this script makes the makefiles a little tidier :-)
3612 echo creating headers.sh
3613 cat >headers.sh <<CF_EOF
3614 #! /bin/sh
3615 # This shell script is generated by the 'configure' script.  It is invoked in a
3616 # subdirectory of the build tree.  It generates a sed-script in the parent
3617 # directory that is used to adjust includes for header files that reside in a
3618 # subdirectory of /usr/include, etc.
3619 PRG=""
3620 while test \[$]# != 3
3621 do
3622 PRG="\$PRG \[$]1"; shift
3623 done
3624 DST=\[$]1
3625 REF=\[$]2
3626 SRC=\[$]3
3627 TMPSRC=\${TMPDIR:-/tmp}/\`basename \$SRC\`\$\$
3628 TMPSED=\${TMPDIR:-/tmp}/headers.sed\$\$
3629 echo installing \$SRC in \$DST
3630 CF_EOF
3631
3632 if test $WITH_CURSES_H = yes; then
3633         cat >>headers.sh <<CF_EOF
3634 case \$DST in
3635 /*/include/*)
3636         END=\`basename \$DST\`
3637         for i in \`cat \$REF/../*/headers |fgrep -v "#"\`
3638         do
3639                 NAME=\`basename \$i\`
3640                 echo "s/<\$NAME>/<\$END\/\$NAME>/" >> \$TMPSED
3641         done
3642         ;;
3643 *)
3644         echo "" >> \$TMPSED
3645         ;;
3646 esac
3647 CF_EOF
3648
3649 else
3650         cat >>headers.sh <<CF_EOF
3651 case \$DST in
3652 /*/include/*)
3653         END=\`basename \$DST\`
3654         for i in \`cat \$REF/../*/headers |fgrep -v "#"\`
3655         do
3656                 NAME=\`basename \$i\`
3657                 if test "\$NAME" = "curses.h"
3658                 then
3659                         echo "s/<curses.h>/<ncurses.h>/" >> \$TMPSED
3660                         NAME=ncurses.h
3661                 fi
3662                 echo "s/<\$NAME>/<\$END\/\$NAME>/" >> \$TMPSED
3663         done
3664         ;;
3665 *)
3666         echo "s/<curses.h>/<ncurses.h>/" >> \$TMPSED
3667         ;;
3668 esac
3669 CF_EOF
3670 fi
3671 cat >>headers.sh <<CF_EOF
3672 rm -f \$TMPSRC
3673 sed -f \$TMPSED \$SRC > \$TMPSRC
3674 NAME=\`basename \$SRC\`
3675 CF_EOF
3676 if test $WITH_CURSES_H != yes; then
3677         cat >>headers.sh <<CF_EOF
3678 test "\$NAME" = "curses.h" && NAME=ncurses.h
3679 CF_EOF
3680 fi
3681 cat >>headers.sh <<CF_EOF
3682 # Just in case someone gzip'd manpages, remove the conflicting copy.
3683 test -f \$DST/\$NAME.gz && rm -f \$DST/\$NAME.gz
3684
3685 eval \$PRG \$TMPSRC \$DST/\$NAME
3686 rm -f \$TMPSRC \$TMPSED
3687 CF_EOF
3688
3689 chmod 0755 headers.sh
3690
3691 for cf_dir in $SRC_SUBDIRS
3692 do
3693         if test ! -d $srcdir/$cf_dir ; then
3694                 continue
3695         fi
3696
3697         if test -f $srcdir/$cf_dir/headers; then
3698                 $AWK -f $srcdir/mk-hdr.awk \
3699                         subset="$LIB_SUBSETS" \
3700                         compat="$WITH_CURSES_H" \
3701                         $srcdir/$cf_dir/headers >>$cf_dir/Makefile
3702         fi
3703
3704         if test -f $srcdir/$cf_dir/modules; then
3705                 if test "$cf_dir" != "c++" ; then
3706                         cat >>$cf_dir/Makefile <<"CF_EOF"
3707 depend : ${AUTO_SRC}
3708         makedepend -- ${CPPFLAGS} -- ${C_SRC}
3709
3710 # DO NOT DELETE THIS LINE -- make depend depends on it.
3711 CF_EOF
3712                 fi
3713         fi
3714 done
3715 AC_SUBST(Libs_To_Make)
3716 ])dnl
3717 dnl ---------------------------------------------------------------------------
3718 dnl CF_LIB_SONAME version: 5 updated: 2010/08/14 18:25:37
3719 dnl -------------
3720 dnl Find the and soname for the given shared library.  Set the cache variable
3721 dnl cf_cv_$3_soname to this, unless it is not found.  Then set the cache
3722 dnl variable to "unknown".
3723 dnl
3724 dnl $1 = headers
3725 dnl $2 = code
3726 dnl $3 = library name
3727 AC_DEFUN([CF_LIB_SONAME],
3728 [
3729 AC_CACHE_CHECK(for soname of $3 library,cf_cv_$3_soname,[
3730
3731 cf_cv_$3_soname=unknown
3732 if test "$cross_compiling" != yes ; then
3733 cat >conftest.$ac_ext <<CF_EOF
3734 $1
3735 int main()
3736 {
3737 $2
3738         ${cf_cv_main_return:-return}(0);
3739 }
3740 CF_EOF
3741 cf_save_LIBS="$LIBS"
3742         CF_ADD_LIB($3)
3743         if AC_TRY_EVAL(ac_compile) ; then
3744                 if AC_TRY_EVAL(ac_link) ; then
3745                         cf_cv_$3_soname=`ldd conftest$ac_exeext 2>/dev/null | sed -e 's,^.*/,,' -e 's, .*$,,' | fgrep lib$3.`
3746                         test -z "$cf_cv_$3_soname" && cf_cv_$3_soname=unknown
3747                 fi
3748         fi
3749 rm -rf conftest*
3750 LIBS="$cf_save_LIBS"
3751 fi
3752 ])
3753 ])
3754 dnl ---------------------------------------------------------------------------
3755 dnl CF_LIB_SUFFIX version: 23 updated: 2014/06/21 17:47:12
3756 dnl -------------
3757 dnl Compute the library file-suffix from the given model name
3758 dnl $1 = model name
3759 dnl $2 = variable to set (the nominal library suffix)
3760 dnl $3 = dependency variable to set (actual filename)
3761 dnl The variable $LIB_SUFFIX, if set, prepends the variable to set.
3762 AC_DEFUN([CF_LIB_SUFFIX],
3763 [
3764         case X$1 in #(vi
3765         Xlibtool) #(vi
3766                 $2='.la'
3767                 $3=[$]$2
3768                 ;;
3769         Xdebug) #(vi
3770                 $2='_g.a'
3771                 $3=[$]$2
3772                 ;;
3773         Xprofile) #(vi
3774                 $2='_p.a'
3775                 $3=[$]$2
3776                 ;;
3777         Xshared) #(vi
3778                 case $cf_cv_system_name in
3779                 aix[[5-7]]*) #(vi
3780                         $2='.so'
3781                         $3=[$]$2
3782                         ;;
3783                 cygwin*|msys*|mingw*) #(vi
3784                         $2='.dll'
3785                         $3='.dll.a'
3786                         ;;
3787                 darwin*) #(vi
3788                         $2='.dylib'
3789                         $3=[$]$2
3790                         ;;
3791                 hpux*) #(vi
3792                         case $target in
3793                         ia64*) #(vi
3794                                 $2='.so'
3795                                 $3=[$]$2
3796                                 ;;
3797                         *) #(vi
3798                                 $2='.sl'
3799                                 $3=[$]$2
3800                                 ;;
3801                         esac
3802                         ;;
3803                 *) #(vi
3804                         $2='.so'
3805                         $3=[$]$2
3806                         ;;
3807                 esac
3808                 ;;
3809         *)
3810                 $2='.a'
3811                 $3=[$]$2
3812                 ;;
3813         esac
3814         test -n "$LIB_SUFFIX" && $2="${LIB_SUFFIX}[$]{$2}"
3815         test -n "$LIB_SUFFIX" && $3="${LIB_SUFFIX}[$]{$3}"
3816 ])dnl
3817 dnl ---------------------------------------------------------------------------
3818 dnl CF_LIB_TYPE version: 4 updated: 2000/10/20 22:57:49
3819 dnl -----------
3820 dnl Compute the string to append to -library from the given model name
3821 dnl $1 = model name
3822 dnl $2 = variable to set
3823 dnl The variable $LIB_SUFFIX, if set, prepends the variable to set.
3824 AC_DEFUN([CF_LIB_TYPE],
3825 [
3826         case $1 in
3827         libtool) $2=''   ;;
3828         normal)  $2=''   ;;
3829         debug)   $2='_g' ;;
3830         profile) $2='_p' ;;
3831         shared)  $2=''   ;;
3832         esac
3833         test -n "$LIB_SUFFIX" && $2="${LIB_SUFFIX}[$]{$2}"
3834 ])dnl
3835 dnl ---------------------------------------------------------------------------
3836 dnl CF_LINK_DATAONLY version: 10 updated: 2012/10/06 17:41:51
3837 dnl ----------------
3838 dnl Some systems have a non-ANSI linker that doesn't pull in modules that have
3839 dnl only data (i.e., no functions), for example NeXT.  On those systems we'll
3840 dnl have to provide wrappers for global tables to ensure they're linked
3841 dnl properly.
3842 AC_DEFUN([CF_LINK_DATAONLY],
3843 [
3844 AC_MSG_CHECKING([if data-only library module links])
3845 AC_CACHE_VAL(cf_cv_link_dataonly,[
3846         rm -f conftest.a
3847         cat >conftest.$ac_ext <<EOF
3848 #line __oline__ "configure"
3849 int     testdata[[3]] = { 123, 456, 789 };
3850 EOF
3851         if AC_TRY_EVAL(ac_compile) ; then
3852                 mv conftest.o data.o && \
3853                 ( $AR $ARFLAGS conftest.a data.o ) 2>&AC_FD_CC 1>/dev/null
3854         fi
3855         rm -f conftest.$ac_ext data.o
3856         cat >conftest.$ac_ext <<EOF
3857 #line __oline__ "configure"
3858 int     testfunc()
3859 {
3860 #if defined(NeXT)
3861         ${cf_cv_main_return:-return}(1);        /* I'm told this linker is broken */
3862 #else
3863         extern int testdata[[3]];
3864         return testdata[[0]] == 123
3865            &&  testdata[[1]] == 456
3866            &&  testdata[[2]] == 789;
3867 #endif
3868 }
3869 EOF
3870         if AC_TRY_EVAL(ac_compile); then
3871                 mv conftest.o func.o && \
3872                 ( $AR $ARFLAGS conftest.a func.o ) 2>&AC_FD_CC 1>/dev/null
3873         fi
3874         rm -f conftest.$ac_ext func.o
3875         ( eval $RANLIB conftest.a ) 2>&AC_FD_CC >/dev/null
3876         cf_saveLIBS="$LIBS"
3877         LIBS="conftest.a $LIBS"
3878         AC_TRY_RUN([
3879         int main()
3880         {
3881                 extern int testfunc();
3882                 ${cf_cv_main_return:-return} (!testfunc());
3883         }
3884         ],
3885         [cf_cv_link_dataonly=yes],
3886         [cf_cv_link_dataonly=no],
3887         [cf_cv_link_dataonly=unknown])
3888         LIBS="$cf_saveLIBS"
3889         ])
3890 AC_MSG_RESULT($cf_cv_link_dataonly)
3891
3892 if test "$cf_cv_link_dataonly" = no ; then
3893         AC_DEFINE(BROKEN_LINKER,1,[if data-only library module does not link])
3894         BROKEN_LINKER=1
3895 fi
3896
3897 ])dnl
3898 dnl ---------------------------------------------------------------------------
3899 dnl CF_LINK_FUNCS version: 8 updated: 2012/10/06 17:56:13
3900 dnl -------------
3901 dnl Most Unix systems have both link and symlink, a few don't have symlink.
3902 dnl A few non-Unix systems implement symlink, but not link.
3903 dnl A few non-systems implement neither (or have nonfunctional versions).
3904 AC_DEFUN([CF_LINK_FUNCS],
3905 [
3906 AC_CHECK_FUNCS( \
3907         remove \
3908         unlink )
3909
3910 if test "$cross_compiling" = yes ; then
3911         AC_CHECK_FUNCS( \
3912                 link \
3913                 symlink )
3914 else
3915         AC_CACHE_CHECK(if link/symlink functions work,cf_cv_link_funcs,[
3916                 cf_cv_link_funcs=
3917                 for cf_func in link symlink ; do
3918                         AC_TRY_RUN([
3919 #include <sys/types.h>
3920 #include <sys/stat.h>
3921 #ifdef HAVE_UNISTD_H
3922 #include <unistd.h>
3923 #endif
3924 int main()
3925 {
3926         int fail = 0;
3927         char *src = "config.log";
3928         char *dst = "conftest.chk";
3929         struct stat src_sb;
3930         struct stat dst_sb;
3931
3932         stat(src, &src_sb);
3933         fail = ($cf_func("config.log", "conftest.chk") < 0)
3934             || (stat(dst, &dst_sb) < 0)
3935             || (dst_sb.st_mtime != src_sb.st_mtime);
3936 #ifdef HAVE_UNLINK
3937         unlink(dst);
3938 #else
3939         remove(dst);
3940 #endif
3941         ${cf_cv_main_return:-return} (fail);
3942 }
3943                         ],[
3944                         cf_cv_link_funcs="$cf_cv_link_funcs $cf_func"
3945                         eval 'ac_cv_func_'$cf_func'=yes'],[
3946                         eval 'ac_cv_func_'$cf_func'=no'],[
3947                         eval 'ac_cv_func_'$cf_func'=error'])
3948                 done
3949                 test -z "$cf_cv_link_funcs" && cf_cv_link_funcs=no
3950         ])
3951         test "$ac_cv_func_link"    = yes && AC_DEFINE(HAVE_LINK,1,[Define to 1 if we have link() function])
3952         test "$ac_cv_func_symlink" = yes && AC_DEFINE(HAVE_SYMLINK,1,[Define to 1 if we have symlink() function])
3953 fi
3954 ])dnl
3955 dnl ---------------------------------------------------------------------------
3956 dnl CF_MAKEFLAGS version: 15 updated: 2014/05/10 16:43:23
3957 dnl ------------
3958 dnl Some 'make' programs support ${MAKEFLAGS}, some ${MFLAGS}, to pass 'make'
3959 dnl options to lower-levels.  It's very useful for "make -n" -- if we have it.
3960 dnl (GNU 'make' does both, something POSIX 'make', which happens to make the
3961 dnl ${MAKEFLAGS} variable incompatible because it adds the assignments :-)
3962 AC_DEFUN([CF_MAKEFLAGS],
3963 [
3964 AC_CACHE_CHECK(for makeflags variable, cf_cv_makeflags,[
3965         cf_cv_makeflags=''
3966         for cf_option in '-${MAKEFLAGS}' '${MFLAGS}'
3967         do
3968                 cat >cf_makeflags.tmp <<CF_EOF
3969 SHELL = /bin/sh
3970 all :
3971         @ echo '.$cf_option'
3972 CF_EOF
3973                 cf_result=`${MAKE:-make} -k -f cf_makeflags.tmp 2>/dev/null | fgrep -v "ing directory" | sed -e 's,[[   ]]*$,,'`
3974                 case "$cf_result" in
3975                 .*k|.*kw)
3976                         cf_result=`${MAKE:-make} -k -f cf_makeflags.tmp CC=cc 2>/dev/null`
3977                         case "$cf_result" in
3978                         .*CC=*) cf_cv_makeflags=
3979                                 ;;
3980                         *)      cf_cv_makeflags=$cf_option
3981                                 ;;
3982                         esac
3983                         break
3984                         ;;
3985                 .-)     ;;
3986                 *)      echo "given option \"$cf_option\", no match \"$cf_result\""
3987                         ;;
3988                 esac
3989         done
3990         rm -f cf_makeflags.tmp
3991 ])
3992
3993 AC_SUBST(cf_cv_makeflags)
3994 ])dnl
3995 dnl ---------------------------------------------------------------------------
3996 dnl CF_MAKE_TAGS version: 6 updated: 2010/10/23 15:52:32
3997 dnl ------------
3998 dnl Generate tags/TAGS targets for makefiles.  Do not generate TAGS if we have
3999 dnl a monocase filesystem.
4000 AC_DEFUN([CF_MAKE_TAGS],[
4001 AC_REQUIRE([CF_MIXEDCASE_FILENAMES])
4002
4003 AC_CHECK_PROGS(CTAGS, exctags ctags)
4004 AC_CHECK_PROGS(ETAGS, exetags etags)
4005
4006 AC_CHECK_PROG(MAKE_LOWER_TAGS, ${CTAGS:-ctags}, yes, no)
4007
4008 if test "$cf_cv_mixedcase" = yes ; then
4009         AC_CHECK_PROG(MAKE_UPPER_TAGS, ${ETAGS:-etags}, yes, no)
4010 else
4011         MAKE_UPPER_TAGS=no
4012 fi
4013
4014 if test "$MAKE_UPPER_TAGS" = yes ; then
4015         MAKE_UPPER_TAGS=
4016 else
4017         MAKE_UPPER_TAGS="#"
4018 fi
4019
4020 if test "$MAKE_LOWER_TAGS" = yes ; then
4021         MAKE_LOWER_TAGS=
4022 else
4023         MAKE_LOWER_TAGS="#"
4024 fi
4025
4026 AC_SUBST(CTAGS)
4027 AC_SUBST(ETAGS)
4028
4029 AC_SUBST(MAKE_UPPER_TAGS)
4030 AC_SUBST(MAKE_LOWER_TAGS)
4031 ])dnl
4032 dnl ---------------------------------------------------------------------------
4033 dnl CF_MANPAGE_FORMAT version: 9 updated: 2010/10/23 16:10:30
4034 dnl -----------------
4035 dnl Option to allow user to override automatic configuration of manpage format.
4036 dnl There are several special cases:
4037 dnl
4038 dnl     gzip - man checks for, can display gzip'd files
4039 dnl     compress - man checks for, can display compressed files
4040 dnl     BSDI - files in the cat-directories are suffixed ".0"
4041 dnl     formatted - installer should format (put files in cat-directory)
4042 dnl     catonly - installer should only format, e.g., for a turnkey system.
4043 dnl
4044 dnl There are other configurations which this macro does not test, e.g., HPUX's
4045 dnl compressed manpages (but uncompressed manpages are fine, and HPUX's naming
4046 dnl convention would not match our use).
4047 AC_DEFUN([CF_MANPAGE_FORMAT],
4048 [
4049 AC_REQUIRE([CF_PATHSEP])
4050 AC_MSG_CHECKING(format of man-pages)
4051
4052 AC_ARG_WITH(manpage-format,
4053         [  --with-manpage-format   specify manpage-format: gzip/compress/BSDI/normal and
4054                           optionally formatted/catonly, e.g., gzip,formatted],
4055         [MANPAGE_FORMAT=$withval],
4056         [MANPAGE_FORMAT=unknown])
4057
4058 test -z "$MANPAGE_FORMAT" && MANPAGE_FORMAT=unknown
4059 MANPAGE_FORMAT=`echo "$MANPAGE_FORMAT" | sed -e 's/,/ /g'`
4060
4061 cf_unknown=
4062
4063 case $MANPAGE_FORMAT in
4064 unknown)
4065   if test -z "$MANPATH" ; then
4066     MANPATH="/usr/man:/usr/share/man"
4067   fi
4068
4069   # look for the 'date' man-page (it's most likely to be installed!)
4070   MANPAGE_FORMAT=
4071   cf_preform=no
4072   cf_catonly=yes
4073   cf_example=date
4074
4075   IFS="${IFS:-  }"; ac_save_ifs="$IFS"; IFS="${IFS}${PATH_SEPARATOR}"
4076   for cf_dir in $MANPATH; do
4077     test -z "$cf_dir" && cf_dir=/usr/man
4078     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
4079     do
4080       cf_test=`echo $cf_name | sed -e 's/*//'`
4081       if test "x$cf_test" = "x$cf_name" ; then
4082
4083         case "$cf_name" in
4084         *.gz) MANPAGE_FORMAT="$MANPAGE_FORMAT gzip";;
4085         *.Z)  MANPAGE_FORMAT="$MANPAGE_FORMAT compress";;
4086         *.0)    MANPAGE_FORMAT="$MANPAGE_FORMAT BSDI";;
4087         *)    MANPAGE_FORMAT="$MANPAGE_FORMAT normal";;
4088         esac
4089
4090         case "$cf_name" in
4091         $cf_dir/man*)
4092           cf_catonly=no
4093           ;;
4094         $cf_dir/cat*)
4095           cf_preform=yes
4096           ;;
4097         esac
4098         break
4099       fi
4100
4101       # if we found a match in either man* or cat*, stop looking
4102       if test -n "$MANPAGE_FORMAT" ; then
4103         cf_found=no
4104         test "$cf_preform" = yes && MANPAGE_FORMAT="$MANPAGE_FORMAT formatted"
4105         test "$cf_catonly" = yes && MANPAGE_FORMAT="$MANPAGE_FORMAT catonly"
4106         case "$cf_name" in
4107         $cf_dir/cat*)
4108           cf_found=yes
4109           ;;
4110         esac
4111         test $cf_found=yes && break
4112       fi
4113     done
4114     # only check the first directory in $MANPATH where we find manpages
4115     if test -n "$MANPAGE_FORMAT" ; then
4116        break
4117     fi
4118   done
4119   # if we did not find the example, just assume it is normal
4120   test -z "$MANPAGE_FORMAT" && MANPAGE_FORMAT=normal
4121   IFS="$ac_save_ifs"
4122   ;;
4123 *)
4124   for cf_option in $MANPAGE_FORMAT; do
4125      case $cf_option in #(vi
4126      gzip|compress|BSDI|normal|formatted|catonly)
4127        ;;
4128      *)
4129        cf_unknown="$cf_unknown $cf_option"
4130        ;;
4131      esac
4132   done
4133   ;;
4134 esac
4135
4136 AC_MSG_RESULT($MANPAGE_FORMAT)
4137 if test -n "$cf_unknown" ; then
4138   AC_MSG_WARN(Unexpected manpage-format $cf_unknown)
4139 fi
4140 ])dnl
4141 dnl ---------------------------------------------------------------------------
4142 dnl CF_MANPAGE_RENAMES version: 7 updated: 2005/06/18 18:51:57
4143 dnl ------------------
4144 dnl The Debian people have their own naming convention for manpages.  This
4145 dnl option lets us override the name of the file containing renaming, or
4146 dnl disable it altogether.
4147 AC_DEFUN([CF_MANPAGE_RENAMES],
4148 [
4149 AC_MSG_CHECKING(for manpage renaming)
4150
4151 AC_ARG_WITH(manpage-renames,
4152         [  --with-manpage-renames  specify manpage-renaming],
4153         [MANPAGE_RENAMES=$withval],
4154         [MANPAGE_RENAMES=yes])
4155
4156 case ".$MANPAGE_RENAMES" in #(vi
4157 .no) #(vi
4158   ;;
4159 .|.yes)
4160   # Debian 'man' program?
4161   if test -f /etc/debian_version ; then
4162     MANPAGE_RENAMES=`cd $srcdir && pwd`/man/man_db.renames
4163   else
4164     MANPAGE_RENAMES=no
4165   fi
4166   ;;
4167 esac
4168
4169 if test "$MANPAGE_RENAMES" != no ; then
4170   if test -f $srcdir/man/$MANPAGE_RENAMES ; then
4171     MANPAGE_RENAMES=`cd $srcdir/man && pwd`/$MANPAGE_RENAMES
4172   elif test ! -f $MANPAGE_RENAMES ; then
4173     AC_MSG_ERROR(not a filename: $MANPAGE_RENAMES)
4174   fi
4175
4176   test ! -d man && mkdir man
4177
4178   # Construct a sed-script to perform renaming within man-pages
4179   if test -n "$MANPAGE_RENAMES" ; then
4180     test ! -d man && mkdir man
4181     sh $srcdir/man/make_sed.sh $MANPAGE_RENAMES >./edit_man.sed
4182   fi
4183 fi
4184
4185 AC_MSG_RESULT($MANPAGE_RENAMES)
4186 AC_SUBST(MANPAGE_RENAMES)
4187 ])dnl
4188 dnl ---------------------------------------------------------------------------
4189 dnl CF_MANPAGE_SYMLINKS version: 5 updated: 2010/07/24 17:12:40
4190 dnl -------------------
4191 dnl Some people expect each tool to make all aliases for manpages in the
4192 dnl man-directory.  This accommodates the older, less-capable implementations
4193 dnl of 'man', and is optional.
4194 AC_DEFUN([CF_MANPAGE_SYMLINKS],
4195 [
4196 AC_MSG_CHECKING(if manpage aliases will be installed)
4197
4198 AC_ARG_WITH(manpage-aliases,
4199         [  --with-manpage-aliases  specify manpage-aliases using .so],
4200         [MANPAGE_ALIASES=$withval],
4201         [MANPAGE_ALIASES=yes])
4202
4203 AC_MSG_RESULT($MANPAGE_ALIASES)
4204
4205 case "x$LN_S" in #(vi
4206 xln*) #(vi
4207         cf_use_symlinks=yes
4208         ;;
4209 *)
4210         cf_use_symlinks=no
4211         ;;
4212 esac
4213
4214 MANPAGE_SYMLINKS=no
4215 if test "$MANPAGE_ALIASES" = yes ; then
4216 AC_MSG_CHECKING(if manpage symlinks should be used)
4217
4218 AC_ARG_WITH(manpage-symlinks,
4219         [  --with-manpage-symlinks specify manpage-aliases using symlinks],
4220         [MANPAGE_SYMLINKS=$withval],
4221         [MANPAGE_SYMLINKS=$cf_use_symlinks])
4222
4223 if test "$$cf_use_symlinks" = no; then
4224 if test "$MANPAGE_SYMLINKS" = yes ; then
4225         AC_MSG_WARN(cannot make symlinks, will use .so files)
4226         MANPAGE_SYMLINKS=no
4227 fi
4228 fi
4229
4230 AC_MSG_RESULT($MANPAGE_SYMLINKS)
4231 fi
4232
4233 ])dnl
4234 dnl ---------------------------------------------------------------------------
4235 dnl CF_MANPAGE_TBL version: 3 updated: 2002/01/19 22:51:32
4236 dnl --------------
4237 dnl This option causes manpages to be run through tbl(1) to generate tables
4238 dnl correctly.
4239 AC_DEFUN([CF_MANPAGE_TBL],
4240 [
4241 AC_MSG_CHECKING(for manpage tbl)
4242
4243 AC_ARG_WITH(manpage-tbl,
4244         [  --with-manpage-tbl      specify manpage processing with tbl],
4245         [MANPAGE_TBL=$withval],
4246         [MANPAGE_TBL=no])
4247
4248 AC_MSG_RESULT($MANPAGE_TBL)
4249 ])dnl
4250 dnl ---------------------------------------------------------------------------
4251 dnl CF_MAN_PAGES version: 43 updated: 2013/02/09 12:53:45
4252 dnl ------------
4253 dnl Try to determine if the man-pages on the system are compressed, and if
4254 dnl so, what format is used.  Use this information to construct a script that
4255 dnl will install man-pages.
4256 AC_DEFUN([CF_MAN_PAGES],
4257 [
4258 CF_HELP_MESSAGE(Options to Specify How Manpages are Installed:)
4259 CF_MANPAGE_FORMAT
4260 CF_MANPAGE_RENAMES
4261 CF_MANPAGE_SYMLINKS
4262 CF_MANPAGE_TBL
4263
4264   if test "$prefix" = "NONE" ; then
4265      cf_prefix="$ac_default_prefix"
4266   else
4267      cf_prefix="$prefix"
4268   fi
4269
4270   case "$MANPAGE_FORMAT" in # (vi
4271   *catonly*) # (vi
4272     cf_format=yes
4273     cf_inboth=no
4274     ;;
4275   *formatted*) # (vi
4276     cf_format=yes
4277     cf_inboth=yes
4278     ;;
4279   *)
4280     cf_format=no
4281     cf_inboth=no
4282     ;;
4283   esac
4284
4285 test ! -d man && mkdir man
4286
4287 cf_so_strip=
4288 cf_compress=
4289 case "$MANPAGE_FORMAT" in #(vi
4290 *compress*) #(vi
4291         cf_so_strip="Z"
4292         cf_compress=compress
4293   ;;
4294 *gzip*)
4295         cf_so_strip="gz"
4296         cf_compress=gzip
4297   ;;
4298 esac
4299
4300 cf_edit_man=./edit_man.sh
4301 cf_man_alias=`pwd`/man_alias.sed
4302
4303 cat >$cf_edit_man <<CF_EOF
4304 #! /bin/sh
4305 # this script is generated by the configure-script CF_MAN_PAGES macro.
4306
4307 prefix="$cf_prefix"
4308 datarootdir="$datarootdir"
4309 datadir="$datadir"
4310
4311 NCURSES_MAJOR="$NCURSES_MAJOR"
4312 NCURSES_MINOR="$NCURSES_MINOR"
4313 NCURSES_PATCH="$NCURSES_PATCH"
4314
4315 NCURSES_OSPEED="$NCURSES_OSPEED"
4316 TERMINFO="$TERMINFO"
4317
4318 INSTALL="$INSTALL"
4319 INSTALL_DATA="$INSTALL_DATA"
4320
4321 transform="$program_transform_name"
4322
4323 TMP=\${TMPDIR:=/tmp}/man\$\$
4324 trap "rm -f \$TMP" 0 1 2 5 15
4325
4326 form=\[$]1
4327 shift || exit 1
4328
4329 verb=\[$]1
4330 shift || exit 1
4331
4332 mandir=\[$]1
4333 shift || exit 1
4334
4335 srcdir=\[$]1
4336 top_srcdir=\[$]srcdir/..
4337 shift || exit 1
4338
4339 if test "\$form" = normal ; then
4340         if test "$cf_format" = yes ; then
4341         if test "$cf_inboth" = no ; then
4342                 sh \[$]0 format \$verb \$mandir \$srcdir \[$]*
4343                 exit $?
4344         fi
4345         fi
4346         cf_subdir=\$mandir/man
4347         cf_tables=$MANPAGE_TBL
4348 else
4349         cf_subdir=\$mandir/cat
4350         cf_tables=yes
4351 fi
4352
4353 # process the list of source-files
4354 for i in \[$]* ; do
4355 case \$i in #(vi
4356 *.orig|*.rej) ;; #(vi
4357 *.[[0-9]]*)
4358         section=\`expr "\$i" : '.*\\.\\([[0-9]]\\)[[xm]]*'\`;
4359         if test \$verb = installing ; then
4360         if test ! -d \$cf_subdir\${section} ; then
4361                 mkdir -p \$cf_subdir\$section
4362         fi
4363         fi
4364
4365         # replace variables in man page
4366         if test ! -f $cf_man_alias ; then
4367 cat >>$cf_man_alias <<-CF_EOF2
4368                 s,@DATADIR@,\$datadir,g
4369                 s,@TERMINFO@,\${TERMINFO:="no default value"},g
4370                 s,@TERMINFO_DIRS@,\${TERMINFO_DIRS:="no default value"},g
4371                 s,@NCURSES_MAJOR@,\${NCURSES_MAJOR:="no default value"},g
4372                 s,@NCURSES_MINOR@,\${NCURSES_MINOR:="no default value"},g
4373                 s,@NCURSES_PATCH@,\${NCURSES_PATCH:="no default value"},g
4374                 s,@NCURSES_OSPEED@,\${NCURSES_OSPEED:="no default value"},g
4375 CF_EOF
4376         ifelse($1,,,[
4377         for cf_name in $1
4378         do
4379                 cf_NAME=`echo "$cf_name" | sed y%abcdefghijklmnopqrstuvwxyz./-%ABCDEFGHIJKLMNOPQRSTUVWXYZ___%`
4380                 cf_name=`echo $cf_name|sed "$program_transform_name"`
4381 cat >>$cf_edit_man <<-CF_EOF
4382                 s,@$cf_NAME@,$cf_name,g
4383 CF_EOF
4384         done
4385         ])
4386 cat >>$cf_edit_man <<CF_EOF
4387 CF_EOF2
4388                 echo "...made $cf_man_alias"
4389         fi
4390
4391         aliases=
4392         cf_source=\`basename \$i\`
4393         inalias=\$cf_source
4394         test ! -f \$inalias && inalias="\$srcdir/\$inalias"
4395         if test ! -f \$inalias ; then
4396                 echo .. skipped \$cf_source
4397                 continue
4398         fi
4399 CF_EOF
4400
4401 if test "$MANPAGE_ALIASES" != no ; then
4402 cat >>$cf_edit_man <<CF_EOF
4403         nCurses=ignore.3x
4404         test $with_curses_h = yes && nCurses=ncurses.3x
4405         aliases=\`sed -f \$top_srcdir/man/manlinks.sed \$inalias |sed -f $cf_man_alias | sort -u; test \$inalias = \$nCurses && echo curses\`
4406 CF_EOF
4407 fi
4408
4409 if test "$MANPAGE_RENAMES" = no ; then
4410 cat >>$cf_edit_man <<CF_EOF
4411         # perform program transformations for section 1 man pages
4412         if test \$section = 1 ; then
4413                 cf_target=\$cf_subdir\${section}/\`echo \$cf_source|sed "\${transform}"\`
4414         else
4415                 cf_target=\$cf_subdir\${section}/\$cf_source
4416         fi
4417 CF_EOF
4418 else
4419 cat >>$cf_edit_man <<CF_EOF
4420         cf_target=\`grep "^\$cf_source" $MANPAGE_RENAMES | $AWK '{print \[$]2}'\`
4421         if test -z "\$cf_target" ; then
4422                 echo '? missing rename for '\$cf_source
4423                 cf_target="\$cf_source"
4424         fi
4425         cf_target="\$cf_subdir\${section}/\${cf_target}"
4426
4427 CF_EOF
4428 fi
4429
4430 cat >>$cf_edit_man <<CF_EOF
4431         sed     -f $cf_man_alias \\
4432 CF_EOF
4433
4434 if test -f $MANPAGE_RENAMES ; then
4435 cat >>$cf_edit_man <<CF_EOF
4436                 < \$i | sed -f `pwd`/edit_man.sed >\$TMP
4437 CF_EOF
4438 else
4439 cat >>$cf_edit_man <<CF_EOF
4440                 < \$i >\$TMP
4441 CF_EOF
4442 fi
4443
4444 cat >>$cf_edit_man <<CF_EOF
4445 if test \$cf_tables = yes ; then
4446         tbl \$TMP >\$TMP.out
4447         mv \$TMP.out \$TMP
4448 fi
4449 CF_EOF
4450
4451 if test $with_overwrite != yes ; then
4452 cat >>$cf_edit_man <<CF_EOF
4453         sed -e "/\#[    ]*include/s,<curses.h,<ncurses$LIB_SUFFIX/curses.h," < \$TMP >\$TMP.out
4454         mv \$TMP.out \$TMP
4455 CF_EOF
4456 fi
4457
4458 if test $with_curses_h != yes ; then
4459 cat >>$cf_edit_man <<CF_EOF
4460         sed -e "/\#[    ]*include/s,curses.h,ncurses.h," < \$TMP >\$TMP.out
4461         mv \$TMP.out \$TMP
4462 CF_EOF
4463 fi
4464
4465 cat >>$cf_edit_man <<CF_EOF
4466         if test \$form = format ; then
4467                 nroff -man \$TMP >\$TMP.out
4468                 mv \$TMP.out \$TMP
4469         fi
4470 CF_EOF
4471
4472 if test -n "$cf_compress" ; then
4473 cat >>$cf_edit_man <<CF_EOF
4474         if test \$verb = installing ; then
4475         if ( $cf_compress -f \$TMP )
4476         then
4477                 mv \$TMP.$cf_so_strip \$TMP
4478         fi
4479         fi
4480         cf_target="\$cf_target.$cf_so_strip"
4481 CF_EOF
4482 fi
4483
4484 case "$MANPAGE_FORMAT" in #(vi
4485 *BSDI*)
4486 cat >>$cf_edit_man <<CF_EOF
4487         if test \$form = format ; then
4488                 # BSDI installs only .0 suffixes in the cat directories
4489                 cf_target="\`echo \$cf_target|sed -e 's/\.[[1-9]]\+[[a-z]]*/.0/'\`"
4490         fi
4491 CF_EOF
4492   ;;
4493 esac
4494
4495 cat >>$cf_edit_man <<CF_EOF
4496         suffix=\`basename \$cf_target | sed -e 's%^[[^.]]*%%'\`
4497         if test \$verb = installing ; then
4498                 echo \$verb \$cf_target
4499                 \$INSTALL_DATA \$TMP \$cf_target
4500                 test -d \$cf_subdir\${section} &&
4501                 test -n "\$aliases" && (
4502                         cd \$cf_subdir\${section} && (
4503                                 cf_source=\`echo \$cf_target |sed -e 's%^.*/\([[^/]][[^/]]*/[[^/]][[^/]]*$\)%\1%'\`
4504                                 test -n "$cf_so_strip" && cf_source=\`echo \$cf_source |sed -e 's%\.$cf_so_strip\$%%'\`
4505                                 cf_target=\`basename \$cf_target\`
4506                                 for cf_alias in \$aliases
4507                                 do
4508                                         if test \$section = 1 ; then
4509                                                 cf_alias=\`echo \$cf_alias|sed "\${transform}"\`
4510                                         fi
4511
4512                                         if test "$MANPAGE_SYMLINKS" = yes ; then
4513                                                 if test -f \$cf_alias\${suffix} ; then
4514                                                         if ( cmp -s \$cf_target \$cf_alias\${suffix} )
4515                                                         then
4516                                                                 continue
4517                                                         fi
4518                                                 fi
4519                                                 echo .. \$verb alias \$cf_alias\${suffix}
4520 CF_EOF
4521 case "x$LN_S" in #(vi
4522 *-f) #(vi
4523 cat >>$cf_edit_man <<CF_EOF
4524                                                 $LN_S \$cf_target \$cf_alias\${suffix}
4525 CF_EOF
4526         ;;
4527 *)
4528 cat >>$cf_edit_man <<CF_EOF
4529                                                 rm -f \$cf_alias\${suffix}
4530                                                 $LN_S \$cf_target \$cf_alias\${suffix}
4531 CF_EOF
4532         ;;
4533 esac
4534 cat >>$cf_edit_man <<CF_EOF
4535                                         elif test "\$cf_target" != "\$cf_alias\${suffix}" ; then
4536                                                 echo ".so \$cf_source" >\$TMP
4537 CF_EOF
4538 if test -n "$cf_compress" ; then
4539 cat >>$cf_edit_man <<CF_EOF
4540                                                 if test -n "$cf_so_strip" ; then
4541                                                         $cf_compress -f \$TMP
4542                                                         mv \$TMP.$cf_so_strip \$TMP
4543                                                 fi
4544 CF_EOF
4545 fi
4546 cat >>$cf_edit_man <<CF_EOF
4547                                                 echo .. \$verb alias \$cf_alias\${suffix}
4548                                                 rm -f \$cf_alias\${suffix}
4549                                                 \$INSTALL_DATA \$TMP \$cf_alias\${suffix}
4550                                         fi
4551                                 done
4552                         )
4553                 )
4554         elif test \$verb = removing ; then
4555                 test -f \$cf_target && (
4556                         echo \$verb \$cf_target
4557                         rm -f \$cf_target
4558                 )
4559                 test -d \$cf_subdir\${section} &&
4560                 test -n "\$aliases" && (
4561                         cd \$cf_subdir\${section} && (
4562                                 for cf_alias in \$aliases
4563                                 do
4564                                         if test \$section = 1 ; then
4565                                                 cf_alias=\`echo \$cf_alias|sed "\${transform}"\`
4566                                         fi
4567
4568                                         echo .. \$verb alias \$cf_alias\${suffix}
4569                                         rm -f \$cf_alias\${suffix}
4570                                 done
4571                         )
4572                 )
4573         else
4574 #               echo ".hy 0"
4575                 cat \$TMP
4576         fi
4577         ;;
4578 esac
4579 done
4580
4581 if test $cf_inboth = yes ; then
4582 if test \$form != format ; then
4583         sh \[$]0 format \$verb \$mandir \$srcdir \[$]*
4584 fi
4585 fi
4586
4587 exit 0
4588 CF_EOF
4589 chmod 755 $cf_edit_man
4590
4591 ])dnl
4592 dnl ---------------------------------------------------------------------------
4593 dnl CF_MATH_LIB version: 8 updated: 2010/05/29 16:31:02
4594 dnl -----------
4595 dnl Checks for libraries.  At least one UNIX system, Apple Macintosh
4596 dnl Rhapsody 5.5, does not have -lm.  We cannot use the simpler
4597 dnl AC_CHECK_LIB(m,sin), because that fails for C++.
4598 AC_DEFUN([CF_MATH_LIB],
4599 [
4600 AC_CACHE_CHECK(if -lm needed for math functions,
4601         cf_cv_need_libm,[
4602         AC_TRY_LINK([
4603         #include <stdio.h>
4604         #include <math.h>
4605         ],
4606         [double x = rand(); printf("result = %g\n", ]ifelse([$2],,sin(x),$2)[)],
4607         [cf_cv_need_libm=no],
4608         [cf_cv_need_libm=yes])])
4609 if test "$cf_cv_need_libm" = yes
4610 then
4611 ifelse($1,,[
4612         CF_ADD_LIB(m)
4613 ],[$1=-lm])
4614 fi
4615 ])
4616 dnl ---------------------------------------------------------------------------
4617 dnl CF_MIXEDCASE_FILENAMES version: 6 updated: 2013/10/08 17:47:05
4618 dnl ----------------------
4619 dnl Check if the file-system supports mixed-case filenames.  If we're able to
4620 dnl create a lowercase name and see it as uppercase, it doesn't support that.
4621 AC_DEFUN([CF_MIXEDCASE_FILENAMES],
4622 [
4623 AC_CACHE_CHECK(if filesystem supports mixed-case filenames,cf_cv_mixedcase,[
4624 if test "$cross_compiling" = yes ; then
4625         case $target_alias in #(vi
4626         *-os2-emx*|*-msdosdjgpp*|*-cygwin*|*-msys*|*-mingw*|*-uwin*) #(vi
4627                 cf_cv_mixedcase=no
4628                 ;;
4629         *)
4630                 cf_cv_mixedcase=yes
4631                 ;;
4632         esac
4633 else
4634         rm -f conftest CONFTEST
4635         echo test >conftest
4636         if test -f CONFTEST ; then
4637                 cf_cv_mixedcase=no
4638         else
4639                 cf_cv_mixedcase=yes
4640         fi
4641         rm -f conftest CONFTEST
4642 fi
4643 ])
4644 test "$cf_cv_mixedcase" = yes && AC_DEFINE(MIXEDCASE_FILENAMES,1,[Define to 1 if filesystem supports mixed-case filenames.])
4645 ])dnl
4646 dnl ---------------------------------------------------------------------------
4647 dnl CF_MKSTEMP version: 9 updated: 2012/10/03 04:34:49
4648 dnl ----------
4649 dnl Check for a working mkstemp.  This creates two files, checks that they are
4650 dnl successfully created and distinct (AmigaOS apparently fails on the last).
4651 AC_DEFUN([CF_MKSTEMP],[
4652 AC_CACHE_CHECK(for working mkstemp, cf_cv_func_mkstemp,[
4653 rm -rf conftest*
4654 AC_TRY_RUN([
4655 #include <sys/types.h>
4656 #include <stdlib.h>
4657 #include <stdio.h>
4658 #include <string.h>
4659 #include <sys/stat.h>
4660 int main()
4661 {
4662         char *tmpl = "conftestXXXXXX";
4663         char name[2][80];
4664         int n;
4665         int result = 0;
4666         int fd;
4667         struct stat sb;
4668
4669         umask(077);
4670         for (n = 0; n < 2; ++n) {
4671                 strcpy(name[n], tmpl);
4672                 if ((fd = mkstemp(name[n])) >= 0) {
4673                         if (!strcmp(name[n], tmpl)
4674                          || stat(name[n], &sb) != 0
4675                          || (sb.st_mode & S_IFMT) != S_IFREG
4676                          || (sb.st_mode & 077) != 0) {
4677                                 result = 1;
4678                         }
4679                         close(fd);
4680                 }
4681         }
4682         if (result == 0
4683          && !strcmp(name[0], name[1]))
4684                 result = 1;
4685         ${cf_cv_main_return:-return}(result);
4686 }
4687 ],[cf_cv_func_mkstemp=yes
4688 ],[cf_cv_func_mkstemp=no
4689 ],[cf_cv_func_mkstemp=maybe])
4690 ])
4691 if test "x$cf_cv_func_mkstemp" = xmaybe ; then
4692         AC_CHECK_FUNC(mkstemp)
4693 fi
4694 if test "x$cf_cv_func_mkstemp" = xyes || test "x$ac_cv_func_mkstemp" = xyes ; then
4695         AC_DEFINE(HAVE_MKSTEMP,1,[Define to 1 if mkstemp() is available and working.])
4696 fi
4697 ])dnl
4698 dnl ---------------------------------------------------------------------------
4699 dnl CF_MSG_LOG version: 5 updated: 2010/10/23 15:52:32
4700 dnl ----------
4701 dnl Write a debug message to config.log, along with the line number in the
4702 dnl configure script.
4703 AC_DEFUN([CF_MSG_LOG],[
4704 echo "${as_me:-configure}:__oline__: testing $* ..." 1>&AC_FD_CC
4705 ])dnl
4706 dnl ---------------------------------------------------------------------------
4707 dnl CF_NCURSES_ABI_6 version: 1 updated: 2005/09/17 18:42:49
4708 dnl ----------------
4709 dnl Set ncurses' ABI to 6 unless overridden by explicit configure option, and
4710 dnl warn about this.
4711 AC_DEFUN([CF_NCURSES_ABI_6],[
4712 if test "${with_abi_version+set}" != set; then
4713         case $cf_cv_rel_version in
4714         5.*)
4715                 cf_cv_rel_version=6.0
4716                 cf_cv_abi_version=6
4717                 AC_MSG_WARN(Overriding ABI version to $cf_cv_abi_version)
4718                 ;;
4719         esac
4720 fi
4721 ])dnl
4722 dnl ---------------------------------------------------------------------------
4723 dnl CF_NO_LEAKS_OPTION version: 5 updated: 2012/10/02 20:55:03
4724 dnl ------------------
4725 dnl see CF_WITH_NO_LEAKS
4726 AC_DEFUN([CF_NO_LEAKS_OPTION],[
4727 AC_MSG_CHECKING(if you want to use $1 for testing)
4728 AC_ARG_WITH($1,
4729         [$2],
4730         [AC_DEFINE_UNQUOTED($3,1,"Define to 1 if you want to use $1 for testing.")ifelse([$4],,[
4731          $4
4732 ])
4733         : ${with_cflags:=-g}
4734         : ${with_no_leaks:=yes}
4735          with_$1=yes],
4736         [with_$1=])
4737 AC_MSG_RESULT(${with_$1:-no})
4738
4739 case .$with_cflags in #(vi
4740 .*-g*)
4741         case .$CFLAGS in #(vi
4742         .*-g*) #(vi
4743                 ;;
4744         *)
4745                 CF_ADD_CFLAGS([-g])
4746                 ;;
4747         esac
4748         ;;
4749 esac
4750 ])dnl
4751 dnl ---------------------------------------------------------------------------
4752 dnl CF_NUMBER_SYNTAX version: 1 updated: 2003/09/20 18:12:49
4753 dnl ----------------
4754 dnl Check if the given variable is a number.  If not, report an error.
4755 dnl $1 is the variable
4756 dnl $2 is the message
4757 AC_DEFUN([CF_NUMBER_SYNTAX],[
4758 if test -n "$1" ; then
4759   case $1 in #(vi
4760   [[0-9]]*) #(vi
4761         ;;
4762   *)
4763         AC_MSG_ERROR($2 is not a number: $1)
4764         ;;
4765   esac
4766 else
4767   AC_MSG_ERROR($2 value is empty)
4768 fi
4769 ])dnl
4770 dnl ---------------------------------------------------------------------------
4771 dnl CF_OBJ_SUBDIR version: 6 updated: 2013/09/07 14:06:10
4772 dnl -------------
4773 dnl Compute the object-directory name from the given model name
4774 AC_DEFUN([CF_OBJ_SUBDIR],
4775 [
4776         case $1 in
4777         libtool) $2='obj_lo'  ;;
4778         normal)  $2='objects' ;;
4779         debug)   $2='obj_g' ;;
4780         profile) $2='obj_p' ;;
4781         shared)
4782                 case $cf_cv_system_name in #(vi
4783                 cygwin|msys) #(vi
4784                         $2='objects' ;;
4785                 *)
4786                         $2='obj_s' ;;
4787                 esac
4788         esac
4789 ])dnl
4790 dnl ---------------------------------------------------------------------------
4791 dnl CF_PATHSEP version: 6 updated: 2012/09/29 18:38:12
4792 dnl ----------
4793 dnl Provide a value for the $PATH and similar separator (or amend the value
4794 dnl as provided in autoconf 2.5x).
4795 AC_DEFUN([CF_PATHSEP],
4796 [
4797         AC_MSG_CHECKING(for PATH separator)
4798         case $cf_cv_system_name in
4799         os2*)   PATH_SEPARATOR=';'  ;;
4800         *)      ${PATH_SEPARATOR:=':'}  ;;
4801         esac
4802 ifelse([$1],,,[$1=$PATH_SEPARATOR])
4803         AC_SUBST(PATH_SEPARATOR)
4804         AC_MSG_RESULT($PATH_SEPARATOR)
4805 ])dnl
4806 dnl ---------------------------------------------------------------------------
4807 dnl CF_PATH_SYNTAX version: 14 updated: 2012/06/19 20:58:54
4808 dnl --------------
4809 dnl Check the argument to see that it looks like a pathname.  Rewrite it if it
4810 dnl begins with one of the prefix/exec_prefix variables, and then again if the
4811 dnl result begins with 'NONE'.  This is necessary to work around autoconf's
4812 dnl delayed evaluation of those symbols.
4813 AC_DEFUN([CF_PATH_SYNTAX],[
4814 if test "x$prefix" != xNONE; then
4815   cf_path_syntax="$prefix"
4816 else
4817   cf_path_syntax="$ac_default_prefix"
4818 fi
4819
4820 case ".[$]$1" in #(vi
4821 .\[$]\(*\)*|.\'*\'*) #(vi
4822   ;;
4823 ..|./*|.\\*) #(vi
4824   ;;
4825 .[[a-zA-Z]]:[[\\/]]*) #(vi OS/2 EMX
4826   ;;
4827 .\[$]{*prefix}*|.\[$]{*dir}*) #(vi
4828   eval $1="[$]$1"
4829   case ".[$]$1" in #(vi
4830   .NONE/*)
4831     $1=`echo [$]$1 | sed -e s%NONE%$cf_path_syntax%`
4832     ;;
4833   esac
4834   ;; #(vi
4835 .no|.NONE/*)
4836   $1=`echo [$]$1 | sed -e s%NONE%$cf_path_syntax%`
4837   ;;
4838 *)
4839   ifelse([$2],,[AC_MSG_ERROR([expected a pathname, not \"[$]$1\"])],$2)
4840   ;;
4841 esac
4842 ])dnl
4843 dnl ---------------------------------------------------------------------------
4844 dnl CF_PKG_CONFIG version: 7 updated: 2011/04/29 04:53:22
4845 dnl -------------
4846 dnl Check for the package-config program, unless disabled by command-line.
4847 AC_DEFUN([CF_PKG_CONFIG],
4848 [
4849 AC_MSG_CHECKING(if you want to use pkg-config)
4850 AC_ARG_WITH(pkg-config,
4851         [  --with-pkg-config{=path} enable/disable use of pkg-config],
4852         [cf_pkg_config=$withval],
4853         [cf_pkg_config=yes])
4854 AC_MSG_RESULT($cf_pkg_config)
4855
4856 case $cf_pkg_config in #(vi
4857 no) #(vi
4858         PKG_CONFIG=none
4859         ;;
4860 yes) #(vi
4861         CF_ACVERSION_CHECK(2.52,
4862                 [AC_PATH_TOOL(PKG_CONFIG, pkg-config, none)],
4863                 [AC_PATH_PROG(PKG_CONFIG, pkg-config, none)])
4864         ;;
4865 *)
4866         PKG_CONFIG=$withval
4867         ;;
4868 esac
4869
4870 test -z "$PKG_CONFIG" && PKG_CONFIG=none
4871 if test "$PKG_CONFIG" != none ; then
4872         CF_PATH_SYNTAX(PKG_CONFIG)
4873 fi
4874
4875 AC_SUBST(PKG_CONFIG)
4876 ])dnl
4877 dnl ---------------------------------------------------------------------------
4878 dnl CF_POSIX_C_SOURCE version: 8 updated: 2010/05/26 05:38:42
4879 dnl -----------------
4880 dnl Define _POSIX_C_SOURCE to the given level, and _POSIX_SOURCE if needed.
4881 dnl
4882 dnl     POSIX.1-1990                            _POSIX_SOURCE
4883 dnl     POSIX.1-1990 and                        _POSIX_SOURCE and
4884 dnl             POSIX.2-1992 C-Language                 _POSIX_C_SOURCE=2
4885 dnl             Bindings Option
4886 dnl     POSIX.1b-1993                           _POSIX_C_SOURCE=199309L
4887 dnl     POSIX.1c-1996                           _POSIX_C_SOURCE=199506L
4888 dnl     X/Open 2000                             _POSIX_C_SOURCE=200112L
4889 dnl
4890 dnl Parameters:
4891 dnl     $1 is the nominal value for _POSIX_C_SOURCE
4892 AC_DEFUN([CF_POSIX_C_SOURCE],
4893 [
4894 cf_POSIX_C_SOURCE=ifelse([$1],,199506L,[$1])
4895
4896 cf_save_CFLAGS="$CFLAGS"
4897 cf_save_CPPFLAGS="$CPPFLAGS"
4898
4899 CF_REMOVE_DEFINE(cf_trim_CFLAGS,$cf_save_CFLAGS,_POSIX_C_SOURCE)
4900 CF_REMOVE_DEFINE(cf_trim_CPPFLAGS,$cf_save_CPPFLAGS,_POSIX_C_SOURCE)
4901
4902 AC_CACHE_CHECK(if we should define _POSIX_C_SOURCE,cf_cv_posix_c_source,[
4903         CF_MSG_LOG(if the symbol is already defined go no further)
4904         AC_TRY_COMPILE([#include <sys/types.h>],[
4905 #ifndef _POSIX_C_SOURCE
4906 make an error
4907 #endif],
4908         [cf_cv_posix_c_source=no],
4909         [cf_want_posix_source=no
4910          case .$cf_POSIX_C_SOURCE in #(vi
4911          .[[12]]??*) #(vi
4912                 cf_cv_posix_c_source="-D_POSIX_C_SOURCE=$cf_POSIX_C_SOURCE"
4913                 ;;
4914          .2) #(vi
4915                 cf_cv_posix_c_source="-D_POSIX_C_SOURCE=$cf_POSIX_C_SOURCE"
4916                 cf_want_posix_source=yes
4917                 ;;
4918          .*)
4919                 cf_want_posix_source=yes
4920                 ;;
4921          esac
4922          if test "$cf_want_posix_source" = yes ; then
4923                 AC_TRY_COMPILE([#include <sys/types.h>],[
4924 #ifdef _POSIX_SOURCE
4925 make an error
4926 #endif],[],
4927                 cf_cv_posix_c_source="$cf_cv_posix_c_source -D_POSIX_SOURCE")
4928          fi
4929          CF_MSG_LOG(ifdef from value $cf_POSIX_C_SOURCE)
4930          CFLAGS="$cf_trim_CFLAGS"
4931          CPPFLAGS="$cf_trim_CPPFLAGS $cf_cv_posix_c_source"
4932          CF_MSG_LOG(if the second compile does not leave our definition intact error)
4933          AC_TRY_COMPILE([#include <sys/types.h>],[
4934 #ifndef _POSIX_C_SOURCE
4935 make an error
4936 #endif],,
4937          [cf_cv_posix_c_source=no])
4938          CFLAGS="$cf_save_CFLAGS"
4939          CPPFLAGS="$cf_save_CPPFLAGS"
4940         ])
4941 ])
4942
4943 if test "$cf_cv_posix_c_source" != no ; then
4944         CFLAGS="$cf_trim_CFLAGS"
4945         CPPFLAGS="$cf_trim_CPPFLAGS"
4946         CF_ADD_CFLAGS($cf_cv_posix_c_source)
4947 fi
4948
4949 ])dnl
4950 dnl ---------------------------------------------------------------------------
4951 dnl CF_PREDEFINE version: 2 updated: 2010/05/26 16:44:57
4952 dnl ------------
4953 dnl Add definitions to CPPFLAGS to ensure they're predefined for all compiles.
4954 dnl
4955 dnl $1 = symbol to test
4956 dnl $2 = value (if any) to use for a predefinition
4957 AC_DEFUN([CF_PREDEFINE],
4958 [
4959 AC_MSG_CHECKING(if we must define $1)
4960 AC_TRY_COMPILE([#include <sys/types.h>
4961 ],[
4962 #ifndef $1
4963 make an error
4964 #endif],[cf_result=no],[cf_result=yes])
4965 AC_MSG_RESULT($cf_result)
4966
4967 if test "$cf_result" = yes ; then
4968         CPPFLAGS="$CPPFLAGS ifelse([$2],,-D$1,[-D$1=$2])"
4969 elif test "x$2" != "x" ; then
4970         AC_MSG_CHECKING(checking for compatible value versus $2)
4971         AC_TRY_COMPILE([#include <sys/types.h>
4972 ],[
4973 #if $1-$2 < 0
4974 make an error
4975 #endif],[cf_result=yes],[cf_result=no])
4976         AC_MSG_RESULT($cf_result)
4977         if test "$cf_result" = no ; then
4978                 # perhaps we can override it - try...
4979                 CPPFLAGS="$CPPFLAGS -D$1=$2"
4980         fi
4981 fi
4982 ])dnl
4983 dnl ---------------------------------------------------------------------------
4984 dnl CF_PRG_RULES version: 1 updated: 2006/06/03 11:45:08
4985 dnl ------------
4986 dnl Append definitions and rules for the given programs to the subdirectory
4987 dnl Makefiles, and the recursion rule for the top-level Makefile.
4988 dnl
4989 dnl parameters
4990 dnl     $1 = script to run
4991 dnl     $2 = list of subdirectories
4992 dnl
4993 dnl variables
4994 dnl     $AWK
4995 AC_DEFUN([CF_PRG_RULES],
4996 [
4997 for cf_dir in $2
4998 do
4999         if test ! -d $srcdir/$cf_dir; then
5000                 continue
5001         elif test -f $srcdir/$cf_dir/programs; then
5002                 $AWK -f $1 $srcdir/$cf_dir/programs >>$cf_dir/Makefile
5003         fi
5004 done
5005
5006 ])dnl
5007 dnl ---------------------------------------------------------------------------
5008 dnl CF_PROG_AR version: 1 updated: 2009/01/01 20:15:22
5009 dnl ----------
5010 dnl Check for archiver "ar".
5011 AC_DEFUN([CF_PROG_AR],[
5012 AC_CHECK_TOOL(AR, ar, ar)
5013 ])
5014 dnl ---------------------------------------------------------------------------
5015 dnl CF_PROG_AWK version: 1 updated: 2006/09/16 11:40:59
5016 dnl -----------
5017 dnl Check for awk, ensure that the check found something.
5018 AC_DEFUN([CF_PROG_AWK],
5019 [
5020 AC_PROG_AWK
5021 test -z "$AWK" && AC_MSG_ERROR(No awk program found)
5022 ])dnl
5023 dnl ---------------------------------------------------------------------------
5024 dnl CF_PROG_CC version: 4 updated: 2014/07/12 18:57:58
5025 dnl ----------
5026 dnl standard check for CC, plus followup sanity checks
5027 dnl $1 = optional parameter to pass to AC_PROG_CC to specify compiler name
5028 AC_DEFUN([CF_PROG_CC],[
5029 ifelse($1,,[AC_PROG_CC],[AC_PROG_CC($1)])
5030 CF_GCC_VERSION
5031 CF_ACVERSION_CHECK(2.52,
5032         [AC_PROG_CC_STDC],
5033         [CF_ANSI_CC_REQD])
5034 CF_CC_ENV_FLAGS
5035 ])dnl
5036 dnl ---------------------------------------------------------------------------
5037 dnl CF_PROG_CC_C_O version: 3 updated: 2010/08/14 18:25:37
5038 dnl --------------
5039 dnl Analogous to AC_PROG_CC_C_O, but more useful: tests only $CC, ensures that
5040 dnl the output file can be renamed, and allows for a shell variable that can
5041 dnl be used later.  The parameter is either CC or CXX.  The result is the
5042 dnl cache variable:
5043 dnl     $cf_cv_prog_CC_c_o
5044 dnl     $cf_cv_prog_CXX_c_o
5045 AC_DEFUN([CF_PROG_CC_C_O],
5046 [AC_REQUIRE([AC_PROG_CC])dnl
5047 AC_MSG_CHECKING([whether [$]$1 understands -c and -o together])
5048 AC_CACHE_VAL(cf_cv_prog_$1_c_o,
5049 [
5050 cat > conftest.$ac_ext <<CF_EOF
5051 #include <stdio.h>
5052 int main()
5053 {
5054         ${cf_cv_main_return:-return}(0);
5055 }
5056 CF_EOF
5057 # We do the test twice because some compilers refuse to overwrite an
5058 # existing .o file with -o, though they will create one.
5059 ac_try='[$]$1 -c conftest.$ac_ext -o conftest2.$ac_objext >&AC_FD_CC'
5060 if AC_TRY_EVAL(ac_try) &&
5061   test -f conftest2.$ac_objext && AC_TRY_EVAL(ac_try);
5062 then
5063   eval cf_cv_prog_$1_c_o=yes
5064 else
5065   eval cf_cv_prog_$1_c_o=no
5066 fi
5067 rm -rf conftest*
5068 ])dnl
5069 if test $cf_cv_prog_$1_c_o = yes; then
5070   AC_MSG_RESULT([yes])
5071 else
5072   AC_MSG_RESULT([no])
5073 fi
5074 ])dnl
5075 dnl ---------------------------------------------------------------------------
5076 dnl CF_PROG_EGREP version: 1 updated: 2006/09/16 11:40:59
5077 dnl -------------
5078 dnl AC_PROG_EGREP was introduced in autoconf 2.53.
5079 dnl This macro adds a check to ensure the script found something.
5080 AC_DEFUN([CF_PROG_EGREP],
5081 [AC_CACHE_CHECK([for egrep], [ac_cv_prog_egrep],
5082    [if echo a | (grep -E '(a|b)') >/dev/null 2>&1
5083     then ac_cv_prog_egrep='grep -E'
5084     else ac_cv_prog_egrep='egrep'
5085     fi])
5086  EGREP=$ac_cv_prog_egrep
5087  AC_SUBST([EGREP])
5088 test -z "$EGREP" && AC_MSG_ERROR(No egrep program found)
5089 ])dnl
5090 dnl ---------------------------------------------------------------------------
5091 dnl CF_PROG_GNAT version: 2 updated: 2011/10/22 14:01:47
5092 dnl ------------
5093 dnl Check for gnatmake, ensure that it is complete.
5094 AC_DEFUN([CF_PROG_GNAT],[
5095 cf_ada_make=gnatmake
5096 AC_CHECK_PROG(gnat_exists, $cf_ada_make, yes, no)
5097 if test "$ac_cv_prog_gnat_exists" = no; then
5098    cf_ada_make=
5099    cf_cv_prog_gnat_correct=no
5100 else
5101    CF_GNAT_VERSION
5102    AC_CHECK_PROG(M4_exists, m4, yes, no)
5103    if test "$ac_cv_prog_M4_exists" = no; then
5104       cf_cv_prog_gnat_correct=no
5105       echo Ada95 binding required program m4 not found. Ada95 binding disabled.
5106    fi
5107    if test "$cf_cv_prog_gnat_correct" = yes; then
5108       AC_MSG_CHECKING(if GNAT works)
5109       CF_GNAT_TRY_RUN([procedure conftest;],
5110 [with Text_IO;
5111 with GNAT.OS_Lib;
5112 procedure conftest is
5113 begin
5114    Text_IO.Put ("Hello World");
5115    Text_IO.New_Line;
5116    GNAT.OS_Lib.OS_Exit (0);
5117 end conftest;],[cf_cv_prog_gnat_correct=yes],[cf_cv_prog_gnat_correct=no])
5118       AC_MSG_RESULT($cf_cv_prog_gnat_correct)
5119    fi
5120 fi
5121
5122 AC_SUBST(cf_ada_make)
5123 ])dnl
5124 dnl ---------------------------------------------------------------------------
5125 dnl CF_PROG_INSTALL version: 5 updated: 2002/12/21 22:46:07
5126 dnl ---------------
5127 dnl Force $INSTALL to be an absolute-path.  Otherwise, edit_man.sh and the
5128 dnl misc/tabset install won't work properly.  Usually this happens only when
5129 dnl using the fallback mkinstalldirs script
5130 AC_DEFUN([CF_PROG_INSTALL],
5131 [AC_PROG_INSTALL
5132 case $INSTALL in
5133 /*)
5134   ;;
5135 *)
5136   CF_DIRNAME(cf_dir,$INSTALL)
5137   test -z "$cf_dir" && cf_dir=.
5138   INSTALL=`cd $cf_dir && pwd`/`echo $INSTALL | sed -e 's%^.*/%%'`
5139   ;;
5140 esac
5141 ])dnl
5142 dnl ---------------------------------------------------------------------------
5143 dnl CF_PROG_LDCONFIG version: 3 updated: 2011/06/04 20:09:13
5144 dnl ----------------
5145 dnl Check for ldconfig, needed to fixup shared libraries that would be built
5146 dnl and then used in the install.
5147 AC_DEFUN([CF_PROG_LDCONFIG],[
5148 if test "$cross_compiling" = yes ; then
5149   LDCONFIG=:
5150 else
5151 case "$cf_cv_system_name" in #(vi
5152 dragonfly*|mirbsd*|freebsd*) #(vi
5153   test -z "$LDCONFIG" && LDCONFIG="/sbin/ldconfig -R"
5154   ;;
5155 *) LDPATH=$PATH:/sbin:/usr/sbin
5156   AC_PATH_PROG(LDCONFIG,ldconfig,,$LDPATH)
5157   ;;
5158 esac
5159 fi
5160 AC_SUBST(LDCONFIG)
5161 ])dnl
5162 dnl ---------------------------------------------------------------------------
5163 dnl CF_PROG_LINT version: 2 updated: 2009/08/12 04:43:14
5164 dnl ------------
5165 AC_DEFUN([CF_PROG_LINT],
5166 [
5167 AC_CHECK_PROGS(LINT, tdlint lint alint splint lclint)
5168 AC_SUBST(LINT_OPTS)
5169 ])dnl
5170 dnl ---------------------------------------------------------------------------
5171 dnl CF_PROG_LN_S version: 2 updated: 2010/08/14 18:25:37
5172 dnl ------------
5173 dnl Combine checks for "ln -s" and "ln -sf", updating $LN_S to include "-f"
5174 dnl option if it is supported.
5175 AC_DEFUN([CF_PROG_LN_S],[
5176 AC_PROG_LN_S
5177 AC_MSG_CHECKING(if $LN_S -f options work)
5178
5179 rm -f conf$$.src conf$$dst
5180 echo >conf$$.dst
5181 echo first >conf$$.src
5182 if $LN_S -f conf$$.src conf$$.dst 2>/dev/null; then
5183         cf_prog_ln_sf=yes
5184 else
5185         cf_prog_ln_sf=no
5186 fi
5187 rm -f conf$$.dst conf$$src
5188 AC_MSG_RESULT($cf_prog_ln_sf)
5189
5190 test "$cf_prog_ln_sf" = yes && LN_S="$LN_S -f"
5191 ])dnl
5192 dnl ---------------------------------------------------------------------------
5193 dnl CF_REGEX version: 10 updated: 2012/10/04 20:12:20
5194 dnl --------
5195 dnl Attempt to determine if we've got one of the flavors of regular-expression
5196 dnl code that we can support.
5197 AC_DEFUN([CF_REGEX],
5198 [
5199
5200 cf_regex_func=no
5201
5202 cf_regex_libs="regex re"
5203 case $host_os in #(vi
5204 mingw*)
5205         cf_regex_libs="gnurx $cf_regex_libs"
5206         ;;
5207 esac
5208
5209 AC_CHECK_FUNC(regcomp,[cf_regex_func=regcomp],[
5210         for cf_regex_lib in $cf_regex_libs
5211         do
5212                 AC_CHECK_LIB($cf_regex_lib,regcomp,[
5213                                 CF_ADD_LIB($cf_regex_lib)
5214                                 cf_regex_func=regcomp
5215                                 break])
5216         done
5217 ])
5218
5219 if test "$cf_regex_func" = no ; then
5220         AC_CHECK_FUNC(compile,[cf_regex_func=compile],[
5221                 AC_CHECK_LIB(gen,compile,[
5222                                 CF_ADD_LIB(gen)
5223                                 cf_regex_func=compile])])
5224 fi
5225
5226 if test "$cf_regex_func" = no ; then
5227         AC_MSG_WARN(cannot find regular expression library)
5228 fi
5229
5230 AC_CACHE_CHECK(for regular-expression headers,cf_cv_regex_hdrs,[
5231
5232 cf_cv_regex_hdrs=no
5233 case $cf_regex_func in #(vi
5234 compile) #(vi
5235         for cf_regex_hdr in regexp.h regexpr.h
5236         do
5237                 AC_TRY_LINK([#include <$cf_regex_hdr>],[
5238                         char *p = compile("", "", "", 0);
5239                         int x = step("", "");
5240                 ],[
5241                         cf_cv_regex_hdrs=$cf_regex_hdr
5242                         break
5243                 ])
5244         done
5245         ;;
5246 *)
5247         for cf_regex_hdr in regex.h
5248         do
5249                 AC_TRY_LINK([#include <sys/types.h>
5250 #include <$cf_regex_hdr>],[
5251                         regex_t *p;
5252                         int x = regcomp(p, "", 0);
5253                         int y = regexec(p, "", 0, 0, 0);
5254                         regfree(p);
5255                 ],[
5256                         cf_cv_regex_hdrs=$cf_regex_hdr
5257                         break
5258                 ])
5259         done
5260         ;;
5261 esac
5262
5263 ])
5264
5265 case $cf_cv_regex_hdrs in #(vi
5266     no)        AC_MSG_WARN(no regular expression header found) ;; #(vi
5267     regex.h)   AC_DEFINE(HAVE_REGEX_H_FUNCS,1,[Define to 1 to include regex.h for regular expressions]) ;; #(vi
5268     regexp.h)  AC_DEFINE(HAVE_REGEXP_H_FUNCS,1,[Define to 1 to include regexp.h for regular expressions]) ;; #(vi
5269     regexpr.h) AC_DEFINE(HAVE_REGEXPR_H_FUNCS,1,[Define to 1 to include regexpr.h for regular expressions]) ;;
5270 esac
5271 ])dnl
5272 dnl ---------------------------------------------------------------------------
5273 dnl CF_REMOVE_DEFINE version: 3 updated: 2010/01/09 11:05:50
5274 dnl ----------------
5275 dnl Remove all -U and -D options that refer to the given symbol from a list
5276 dnl of C compiler options.  This works around the problem that not all
5277 dnl compilers process -U and -D options from left-to-right, so a -U option
5278 dnl cannot be used to cancel the effect of a preceding -D option.
5279 dnl
5280 dnl $1 = target (which could be the same as the source variable)
5281 dnl $2 = source (including '$')
5282 dnl $3 = symbol to remove
5283 define([CF_REMOVE_DEFINE],
5284 [
5285 $1=`echo "$2" | \
5286         sed     -e 's/-[[UD]]'"$3"'\(=[[^       ]]*\)\?[[       ]]/ /g' \
5287                 -e 's/-[[UD]]'"$3"'\(=[[^       ]]*\)\?[$]//g'`
5288 ])dnl
5289 dnl ---------------------------------------------------------------------------
5290 dnl CF_REMOVE_LIB version: 1 updated: 2007/02/17 14:11:52
5291 dnl -------------
5292 dnl Remove the given library from the symbol
5293 dnl
5294 dnl $1 = target (which could be the same as the source variable)
5295 dnl $2 = source (including '$')
5296 dnl $3 = library to remove
5297 define([CF_REMOVE_LIB],
5298 [
5299 # remove $3 library from $2
5300 $1=`echo "$2" | sed -e 's/-l$3[[        ]]//g' -e 's/-l$3[$]//'`
5301 ])dnl
5302 dnl ---------------------------------------------------------------------------
5303 dnl CF_RPATH_HACK version: 11 updated: 2013/09/01 13:02:00
5304 dnl -------------
5305 AC_DEFUN([CF_RPATH_HACK],
5306 [
5307 AC_REQUIRE([CF_LD_RPATH_OPT])
5308 AC_MSG_CHECKING(for updated LDFLAGS)
5309 if test -n "$LD_RPATH_OPT" ; then
5310         AC_MSG_RESULT(maybe)
5311
5312         AC_CHECK_PROGS(cf_ldd_prog,ldd,no)
5313         cf_rpath_list="/usr/lib /lib"
5314         if test "$cf_ldd_prog" != no
5315         then
5316                 cf_rpath_oops=
5317
5318 AC_TRY_LINK([#include <stdio.h>],
5319                 [printf("Hello");],
5320                 [cf_rpath_oops=`$cf_ldd_prog conftest$ac_exeext | fgrep ' not found' | sed -e 's% =>.*$%%' |sort | uniq`
5321                  cf_rpath_list=`$cf_ldd_prog conftest$ac_exeext | fgrep / | sed -e 's%^.*[[     ]]/%/%' -e 's%/[[^/]][[^/]]*$%%' |sort | uniq`])
5322
5323                 # If we passed the link-test, but get a "not found" on a given library,
5324                 # this could be due to inept reconfiguration of gcc to make it only
5325                 # partly honor /usr/local/lib (or whatever).  Sometimes this behavior
5326                 # is intentional, e.g., installing gcc in /usr/bin and suppressing the
5327                 # /usr/local libraries.
5328                 if test -n "$cf_rpath_oops"
5329                 then
5330                         for cf_rpath_src in $cf_rpath_oops
5331                         do
5332                                 for cf_rpath_dir in \
5333                                         /usr/local \
5334                                         /usr/pkg \
5335                                         /opt/sfw
5336                                 do
5337                                         if test -f $cf_rpath_dir/lib/$cf_rpath_src
5338                                         then
5339                                                 CF_VERBOSE(...adding -L$cf_rpath_dir/lib to LDFLAGS for $cf_rpath_src)
5340                                                 LDFLAGS="$LDFLAGS -L$cf_rpath_dir/lib"
5341                                                 break
5342                                         fi
5343                                 done
5344                         done
5345                 fi
5346         fi
5347
5348         CF_VERBOSE(...checking EXTRA_LDFLAGS $EXTRA_LDFLAGS)
5349
5350         CF_RPATH_HACK_2(LDFLAGS)
5351         CF_RPATH_HACK_2(LIBS)
5352
5353         CF_VERBOSE(...checked EXTRA_LDFLAGS $EXTRA_LDFLAGS)
5354 else
5355         AC_MSG_RESULT(no)
5356 fi
5357 AC_SUBST(EXTRA_LDFLAGS)
5358 ])dnl
5359 dnl ---------------------------------------------------------------------------
5360 dnl CF_RPATH_HACK_2 version: 6 updated: 2010/04/17 16:31:24
5361 dnl ---------------
5362 dnl Do one set of substitutions for CF_RPATH_HACK, adding an rpath option to
5363 dnl EXTRA_LDFLAGS for each -L option found.
5364 dnl
5365 dnl $cf_rpath_list contains a list of directories to ignore.
5366 dnl
5367 dnl $1 = variable name to update.  The LDFLAGS variable should be the only one,
5368 dnl      but LIBS often has misplaced -L options.
5369 AC_DEFUN([CF_RPATH_HACK_2],
5370 [
5371 CF_VERBOSE(...checking $1 [$]$1)
5372
5373 cf_rpath_dst=
5374 for cf_rpath_src in [$]$1
5375 do
5376         case $cf_rpath_src in #(vi
5377         -L*) #(vi
5378
5379                 # check if this refers to a directory which we will ignore
5380                 cf_rpath_skip=no
5381                 if test -n "$cf_rpath_list"
5382                 then
5383                         for cf_rpath_item in $cf_rpath_list
5384                         do
5385                                 if test "x$cf_rpath_src" = "x-L$cf_rpath_item"
5386                                 then
5387                                         cf_rpath_skip=yes
5388                                         break
5389                                 fi
5390                         done
5391                 fi
5392
5393                 if test "$cf_rpath_skip" = no
5394                 then
5395                         # transform the option
5396                         if test "$LD_RPATH_OPT" = "-R " ; then
5397                                 cf_rpath_tmp=`echo "$cf_rpath_src" |sed -e "s%-L%-R %"`
5398                         else
5399                                 cf_rpath_tmp=`echo "$cf_rpath_src" |sed -e "s%-L%$LD_RPATH_OPT%"`
5400                         fi
5401
5402                         # if we have not already added this, add it now
5403                         cf_rpath_tst=`echo "$EXTRA_LDFLAGS" | sed -e "s%$cf_rpath_tmp %%"`
5404                         if test "x$cf_rpath_tst" = "x$EXTRA_LDFLAGS"
5405                         then
5406                                 CF_VERBOSE(...Filter $cf_rpath_src ->$cf_rpath_tmp)
5407                                 EXTRA_LDFLAGS="$cf_rpath_tmp $EXTRA_LDFLAGS"
5408                         fi
5409                 fi
5410                 ;;
5411         esac
5412         cf_rpath_dst="$cf_rpath_dst $cf_rpath_src"
5413 done
5414 $1=$cf_rpath_dst
5415
5416 CF_VERBOSE(...checked $1 [$]$1)
5417 AC_SUBST(EXTRA_LDFLAGS)
5418 ])dnl
5419 dnl ---------------------------------------------------------------------------
5420 dnl CF_SHARED_OPTS version: 84 updated: 2013/11/03 06:26:10
5421 dnl --------------
5422 dnl --------------
5423 dnl Attempt to determine the appropriate CC/LD options for creating a shared
5424 dnl library.
5425 dnl
5426 dnl Notes:
5427 dnl a) ${LOCAL_LDFLAGS} is used to link executables that will run within
5428 dnl the build-tree, i.e., by making use of the libraries that are compiled in
5429 dnl $rel_builddir/lib We avoid compiling-in a $rel_builddir/lib path for the
5430 dnl shared library since that can lead to unexpected results at runtime.
5431 dnl b) ${LOCAL_LDFLAGS2} has the same intention but assumes that the shared
5432 dnl libraries are compiled in ../../lib
5433 dnl
5434 dnl The variable 'cf_cv_do_symlinks' is used to control whether we configure
5435 dnl to install symbolic links to the rel/abi versions of shared libraries.
5436 dnl
5437 dnl The variable 'cf_cv_shlib_version' controls whether we use the rel or abi
5438 dnl version when making symbolic links.
5439 dnl
5440 dnl The variable 'cf_cv_shlib_version_infix' controls whether shared library
5441 dnl version numbers are infix (ex: libncurses.<ver>.dylib) or postfix
5442 dnl (ex: libncurses.so.<ver>).
5443 dnl
5444 dnl Some loaders leave 'so_locations' lying around.  It's nice to clean up.
5445 AC_DEFUN([CF_SHARED_OPTS],
5446 [
5447         AC_REQUIRE([CF_LD_RPATH_OPT])
5448         RM_SHARED_OPTS=
5449         LOCAL_LDFLAGS=
5450         LOCAL_LDFLAGS2=
5451         LD_SHARED_OPTS=
5452         INSTALL_LIB="-m 644"
5453         : ${rel_builddir:=.}
5454
5455         shlibdir=$libdir
5456         AC_SUBST(shlibdir)
5457
5458         MAKE_DLLS="#"
5459         AC_SUBST(MAKE_DLLS)
5460
5461         cf_cv_do_symlinks=no
5462         cf_ld_rpath_opt=
5463         test "$cf_cv_enable_rpath" = yes && cf_ld_rpath_opt="$LD_RPATH_OPT"
5464
5465         AC_MSG_CHECKING(if release/abi version should be used for shared libs)
5466         AC_ARG_WITH(shlib-version,
5467         [  --with-shlib-version=X  Specify rel or abi version for shared libs],
5468         [test -z "$withval" && withval=auto
5469         case $withval in #(vi
5470         yes) #(vi
5471                 cf_cv_shlib_version=auto
5472                 ;;
5473         rel|abi|auto|no) #(vi
5474                 cf_cv_shlib_version=$withval
5475                 ;;
5476         *)
5477                 AC_MSG_ERROR([option value must be one of: rel, abi, auto or no])
5478                 ;;
5479         esac
5480         ],[cf_cv_shlib_version=auto])
5481         AC_MSG_RESULT($cf_cv_shlib_version)
5482
5483         cf_cv_rm_so_locs=no
5484         cf_try_cflags=
5485
5486         # Some less-capable ports of gcc support only -fpic
5487         CC_SHARED_OPTS=
5488         if test "$GCC" = yes
5489         then
5490                 AC_MSG_CHECKING(which $CC option to use)
5491                 cf_save_CFLAGS="$CFLAGS"
5492                 for CC_SHARED_OPTS in -fPIC -fpic ''
5493                 do
5494                         CFLAGS="$cf_save_CFLAGS $CC_SHARED_OPTS"
5495                         AC_TRY_COMPILE([#include <stdio.h>],[int x = 1],[break],[])
5496                 done
5497                 AC_MSG_RESULT($CC_SHARED_OPTS)
5498                 CFLAGS="$cf_save_CFLAGS"
5499         fi
5500
5501         cf_cv_shlib_version_infix=no
5502
5503         case $cf_cv_system_name in #(vi
5504         aix4.[3-9]*|aix[[5-7]]*) #(vi
5505                 if test "$GCC" = yes; then
5506                         CC_SHARED_OPTS=
5507                         MK_SHARED_LIB='${CC} -shared -Wl,-brtl -Wl,-blibpath:${RPATH_LIST}:/usr/lib -o [$]@'
5508                 else
5509                         # CC_SHARED_OPTS='-qpic=large -G'
5510                         # perhaps "-bM:SRE -bnoentry -bexpall"
5511                         MK_SHARED_LIB='${CC} -G -Wl,-brtl -Wl,-blibpath:${RPATH_LIST}:/usr/lib -o [$]@'
5512                 fi
5513                 ;;
5514         beos*) #(vi
5515                 MK_SHARED_LIB='${CC} ${CFLAGS} -o $[@] -Xlinker -soname=`basename $[@]` -nostart -e 0'
5516                 ;;
5517         cygwin*) #(vi
5518                 CC_SHARED_OPTS=
5519                 MK_SHARED_LIB='sh '$rel_builddir'/mk_shared_lib.sh [$]@ [$]{CC} [$]{CFLAGS}'
5520                 RM_SHARED_OPTS="$RM_SHARED_OPTS $rel_builddir/mk_shared_lib.sh *.dll.a"
5521                 cf_cv_shlib_version=cygdll
5522                 cf_cv_shlib_version_infix=cygdll
5523                 shlibdir=$bindir
5524                 MAKE_DLLS=
5525                 cat >mk_shared_lib.sh <<-CF_EOF
5526                 #!/bin/sh
5527                 SHARED_LIB=\[$]1
5528                 IMPORT_LIB=\`echo "\[$]1" | sed -e 's/cyg/lib/' -e 's/[[0-9]]*\.dll[$]/.dll.a/'\`
5529                 shift
5530                 cat <<-EOF
5531                 Linking shared library
5532                 ** SHARED_LIB \[$]SHARED_LIB
5533                 ** IMPORT_LIB \[$]IMPORT_LIB
5534 EOF
5535                 exec \[$]* -shared -Wl,--out-implib=\[$]{IMPORT_LIB} -Wl,--export-all-symbols -o \[$]{SHARED_LIB}
5536 CF_EOF
5537                 chmod +x mk_shared_lib.sh
5538                 ;;
5539         msys*) #(vi
5540                 CC_SHARED_OPTS=
5541                 MK_SHARED_LIB='sh '$rel_builddir'/mk_shared_lib.sh [$]@ [$]{CC} [$]{CFLAGS}'
5542                 RM_SHARED_OPTS="$RM_SHARED_OPTS $rel_builddir/mk_shared_lib.sh *.dll.a"
5543                 cf_cv_shlib_version=msysdll
5544                 cf_cv_shlib_version_infix=msysdll
5545                 shlibdir=$bindir
5546                 MAKE_DLLS=
5547                 cat >mk_shared_lib.sh <<-CF_EOF
5548                 #!/bin/sh
5549                 SHARED_LIB=\[$]1
5550                 IMPORT_LIB=\`echo "\[$]1" | sed -e 's/msys-/lib/' -e 's/[[0-9]]*\.dll[$]/.dll.a/'\`
5551                 shift
5552                 cat <<-EOF
5553                 Linking shared library
5554                 ** SHARED_LIB \[$]SHARED_LIB
5555                 ** IMPORT_LIB \[$]IMPORT_LIB
5556 EOF
5557                 exec \[$]* -shared -Wl,--out-implib=\[$]{IMPORT_LIB} -Wl,--export-all-symbols -o \[$]{SHARED_LIB}
5558 CF_EOF
5559                 chmod +x mk_shared_lib.sh
5560                 ;;
5561         darwin*) #(vi
5562                 cf_try_cflags="no-cpp-precomp"
5563                 CC_SHARED_OPTS="-dynamic"
5564                 MK_SHARED_LIB='${CC} ${CFLAGS} -dynamiclib -install_name ${libdir}/`basename $[@]` -compatibility_version ${ABI_VERSION} -current_version ${ABI_VERSION} -o $[@]'
5565                 test "$cf_cv_shlib_version" = auto && cf_cv_shlib_version=abi
5566                 cf_cv_shlib_version_infix=yes
5567                 AC_CACHE_CHECK([if ld -search_paths_first works], cf_cv_ldflags_search_paths_first, [
5568                         cf_save_LDFLAGS=$LDFLAGS
5569                         LDFLAGS="$LDFLAGS -Wl,-search_paths_first"
5570                         AC_TRY_LINK(, [int i;], cf_cv_ldflags_search_paths_first=yes, cf_cv_ldflags_search_paths_first=no)
5571                                 LDFLAGS=$cf_save_LDFLAGS])
5572                 if test $cf_cv_ldflags_search_paths_first = yes; then
5573                         LDFLAGS="$LDFLAGS -Wl,-search_paths_first"
5574                 fi
5575                 ;;
5576         hpux[[7-8]]*) #(vi
5577                 # HP-UX 8.07 ld lacks "+b" option used for libdir search-list
5578                 if test "$GCC" != yes; then
5579                         CC_SHARED_OPTS='+Z'
5580                 fi
5581                 MK_SHARED_LIB='${LD} -b -o $[@]'
5582                 INSTALL_LIB="-m 555"
5583                 ;;
5584         hpux*) #(vi
5585                 # (tested with gcc 2.7.2 -- I don't have c89)
5586                 if test "$GCC" = yes; then
5587                         LD_SHARED_OPTS='-Xlinker +b -Xlinker ${libdir}'
5588                 else
5589                         CC_SHARED_OPTS='+Z'
5590                         LD_SHARED_OPTS='-Wl,+b,${libdir}'
5591                 fi
5592                 MK_SHARED_LIB='${LD} +b ${libdir} -b -o $[@]'
5593                 # HP-UX shared libraries must be executable, and should be
5594                 # readonly to exploit a quirk in the memory manager.
5595                 INSTALL_LIB="-m 555"
5596                 ;;
5597         interix*)
5598                 test "$cf_cv_shlib_version" = auto && cf_cv_shlib_version=rel
5599                 if test "$cf_cv_shlib_version" = rel; then
5600                         cf_shared_soname='`basename $@ .${REL_VERSION}`.${ABI_VERSION}'
5601                 else
5602                         cf_shared_soname='`basename $@`'
5603                 fi
5604                 CC_SHARED_OPTS=
5605                 MK_SHARED_LIB='${CC} -shared -Wl,-rpath,${RPATH_LIST} -Wl,-h,'$cf_shared_soname' -o $@'
5606                 ;;
5607         irix*) #(vi
5608                 if test "$cf_cv_enable_rpath" = yes ; then
5609                         EXTRA_LDFLAGS="${cf_ld_rpath_opt}\${RPATH_LIST} $EXTRA_LDFLAGS"
5610                 fi
5611                 # tested with IRIX 5.2 and 'cc'.
5612                 if test "$GCC" != yes; then
5613                         CC_SHARED_OPTS='-KPIC'
5614                         MK_SHARED_LIB='${CC} -shared -rdata_shared -soname `basename $[@]` -o $[@]'
5615                 else
5616                         MK_SHARED_LIB='${CC} -shared -Wl,-soname,`basename $[@]` -o $[@]'
5617                 fi
5618                 cf_cv_rm_so_locs=yes
5619                 ;;
5620         linux*|gnu*|k*bsd*-gnu) #(vi
5621                 if test "$DFT_LWR_MODEL" = "shared" ; then
5622                         LOCAL_LDFLAGS="${LD_RPATH_OPT}\$(LOCAL_LIBDIR)"
5623                         LOCAL_LDFLAGS2="$LOCAL_LDFLAGS"
5624                 fi
5625                 if test "$cf_cv_enable_rpath" = yes ; then
5626                         EXTRA_LDFLAGS="${cf_ld_rpath_opt}\${RPATH_LIST} $EXTRA_LDFLAGS"
5627                 fi
5628                 CF_SHARED_SONAME
5629                 MK_SHARED_LIB='${CC} ${CFLAGS} -shared -Wl,-soname,'$cf_cv_shared_soname',-stats,-lc -o $[@]'
5630                 ;;
5631         mingw*) #(vi
5632                 cf_cv_shlib_version=mingw
5633                 cf_cv_shlib_version_infix=mingw
5634                 shlibdir=$bindir
5635                 MAKE_DLLS=
5636                 if test "$DFT_LWR_MODEL" = "shared" ; then
5637                         LOCAL_LDFLAGS="-Wl,--enable-auto-import"
5638                         LOCAL_LDFLAGS2="$LOCAL_LDFLAGS"
5639                         EXTRA_LDFLAGS="-Wl,--enable-auto-import $EXTRA_LDFLAGS"
5640                 fi
5641                 CC_SHARED_OPTS=
5642                 MK_SHARED_LIB='sh '$rel_builddir'/mk_shared_lib.sh [$]@ [$]{CC} [$]{CFLAGS}'
5643                 RM_SHARED_OPTS="$RM_SHARED_OPTS $rel_builddir/mk_shared_lib.sh *.dll.a"
5644                 cat >mk_shared_lib.sh <<-CF_EOF
5645                 #!/bin/sh
5646                 SHARED_LIB=\[$]1
5647                 IMPORT_LIB=\`echo "\[$]1" | sed -e 's/[[0-9]]*\.dll[$]/.dll.a/'\`
5648                 shift
5649                 cat <<-EOF
5650                 Linking shared library
5651                 ** SHARED_LIB \[$]SHARED_LIB
5652                 ** IMPORT_LIB \[$]IMPORT_LIB
5653 EOF
5654                 exec \[$]* -shared -Wl,--enable-auto-import,--out-implib=\[$]{IMPORT_LIB} -Wl,--export-all-symbols -o \[$]{SHARED_LIB}
5655 CF_EOF
5656                 chmod +x mk_shared_lib.sh
5657                 ;;
5658         openbsd[[2-9]].*|mirbsd*) #(vi
5659                 if test "$DFT_LWR_MODEL" = "shared" ; then
5660                         LOCAL_LDFLAGS="${LD_RPATH_OPT}\$(LOCAL_LIBDIR)"
5661                         LOCAL_LDFLAGS2="$LOCAL_LDFLAGS"
5662                 fi
5663                 if test "$cf_cv_enable_rpath" = yes ; then
5664                         EXTRA_LDFLAGS="${cf_ld_rpath_opt}\${RPATH_LIST} $EXTRA_LDFLAGS"
5665                 fi
5666                 CC_SHARED_OPTS="$CC_SHARED_OPTS -DPIC"
5667                 CF_SHARED_SONAME
5668                 MK_SHARED_LIB='${CC} ${CFLAGS} -shared -Wl,-Bshareable,-soname,'$cf_cv_shared_soname',-stats,-lc -o $[@]'
5669                 ;;
5670         nto-qnx*|openbsd*|freebsd[[12]].*) #(vi
5671                 CC_SHARED_OPTS="$CC_SHARED_OPTS -DPIC"
5672                 MK_SHARED_LIB='${LD} -Bshareable -o $[@]'
5673                 test "$cf_cv_shlib_version" = auto && cf_cv_shlib_version=rel
5674                 ;;
5675         dragonfly*|freebsd*) #(vi
5676                 CC_SHARED_OPTS="$CC_SHARED_OPTS -DPIC"
5677                 if test "$DFT_LWR_MODEL" = "shared" && test "$cf_cv_enable_rpath" = yes ; then
5678                         LOCAL_LDFLAGS="${cf_ld_rpath_opt}\$(LOCAL_LIBDIR)"
5679                         LOCAL_LDFLAGS2="${cf_ld_rpath_opt}\${RPATH_LIST} $LOCAL_LDFLAGS"
5680                         EXTRA_LDFLAGS="${cf_ld_rpath_opt}\${RPATH_LIST} $EXTRA_LDFLAGS"
5681                 fi
5682                 CF_SHARED_SONAME
5683                 MK_SHARED_LIB='${LD} -shared -Bshareable -soname=`basename $[@]` -o $[@]'
5684                 ;;
5685         netbsd*) #(vi
5686                 CC_SHARED_OPTS="$CC_SHARED_OPTS -DPIC"
5687                 if test "$DFT_LWR_MODEL" = "shared" && test "$cf_cv_enable_rpath" = yes ; then
5688                         LOCAL_LDFLAGS="${cf_ld_rpath_opt}\$(LOCAL_LIBDIR)"
5689                         LOCAL_LDFLAGS2="$LOCAL_LDFLAGS"
5690                         EXTRA_LDFLAGS="${cf_ld_rpath_opt}\${RPATH_LIST} $EXTRA_LDFLAGS"
5691                         if test "$cf_cv_shlib_version" = auto; then
5692                         if test -f /usr/libexec/ld.elf_so; then
5693                                 cf_cv_shlib_version=abi
5694                         else
5695                                 cf_cv_shlib_version=rel
5696                         fi
5697                         fi
5698                         CF_SHARED_SONAME
5699                         MK_SHARED_LIB='${CC} ${CFLAGS} -shared -Wl,-soname,'$cf_cv_shared_soname' -o $[@]'
5700                 else
5701                         MK_SHARED_LIB='${CC} -Wl,-shared -Wl,-Bshareable -o $[@]'
5702                 fi
5703                 ;;
5704         osf*|mls+*) #(vi
5705                 # tested with OSF/1 V3.2 and 'cc'
5706                 # tested with OSF/1 V3.2 and gcc 2.6.3 (but the c++ demo didn't
5707                 # link with shared libs).
5708                 MK_SHARED_LIB='${LD} -set_version ${REL_VERSION}:${ABI_VERSION} -expect_unresolved "*" -shared -soname `basename $[@]`'
5709                 case $host_os in #(vi
5710                 osf4*)
5711                         MK_SHARED_LIB="${MK_SHARED_LIB} -msym"
5712                         ;;
5713                 esac
5714                 MK_SHARED_LIB="${MK_SHARED_LIB}"' -o $[@]'
5715                 if test "$DFT_LWR_MODEL" = "shared" ; then
5716                         LOCAL_LDFLAGS="${LD_RPATH_OPT}\$(LOCAL_LIBDIR)"
5717                         LOCAL_LDFLAGS2="$LOCAL_LDFLAGS"
5718                 fi
5719                 cf_cv_rm_so_locs=yes
5720                 ;;
5721         sco3.2v5*)  # (also uw2* and UW7: hops 13-Apr-98
5722                 # tested with osr5.0.5
5723                 if test "$GCC" != yes; then
5724                         CC_SHARED_OPTS='-belf -KPIC'
5725                 fi
5726                 MK_SHARED_LIB='${LD} -dy -G -h `basename $[@] .${REL_VERSION}`.${ABI_VERSION} -o [$]@'
5727                 if test "$cf_cv_enable_rpath" = yes ; then
5728                         # only way is to set LD_RUN_PATH but no switch for it
5729                         RUN_PATH=$libdir
5730                 fi
5731                 test "$cf_cv_shlib_version" = auto && cf_cv_shlib_version=rel
5732                 LINK_PROGS='LD_RUN_PATH=${libdir}'
5733                 LINK_TESTS='Pwd=`pwd`;LD_RUN_PATH=`dirname $${Pwd}`/lib'
5734                 ;;
5735         sunos4*) #(vi
5736                 # tested with SunOS 4.1.1 and gcc 2.7.0
5737                 if test "$GCC" != yes; then
5738                         CC_SHARED_OPTS='-KPIC'
5739                 fi
5740                 MK_SHARED_LIB='${LD} -assert pure-text -o $[@]'
5741                 test "$cf_cv_shlib_version" = auto && cf_cv_shlib_version=rel
5742                 ;;
5743         solaris2*) #(vi
5744                 # tested with SunOS 5.5.1 (solaris 2.5.1) and gcc 2.7.2
5745                 # tested with SunOS 5.10 (solaris 10) and gcc 3.4.3
5746                 if test "$DFT_LWR_MODEL" = "shared" ; then
5747                         LOCAL_LDFLAGS="-R \$(LOCAL_LIBDIR):\${libdir}"
5748                         LOCAL_LDFLAGS2="$LOCAL_LDFLAGS"
5749                 fi
5750                 if test "$cf_cv_enable_rpath" = yes ; then
5751                         EXTRA_LDFLAGS="-R \${libdir} $EXTRA_LDFLAGS"
5752                 fi
5753                 CF_SHARED_SONAME
5754                 if test "$GCC" != yes; then
5755                         cf_save_CFLAGS="$CFLAGS"
5756                         for cf_shared_opts in -xcode=pic32 -xcode=pic13 -KPIC -Kpic -O
5757                         do
5758                                 CFLAGS="$cf_shared_opts $cf_save_CFLAGS"
5759                                 AC_TRY_COMPILE([#include <stdio.h>],[printf("Hello\n");],[break])
5760                         done
5761                         CFLAGS="$cf_save_CFLAGS"
5762                         CC_SHARED_OPTS=$cf_shared_opts
5763                         MK_SHARED_LIB='${CC} -dy -G -h '$cf_cv_shared_soname' -o $[@]'
5764                 else
5765                         MK_SHARED_LIB='${CC} -shared -dy -G -h '$cf_cv_shared_soname' -o $[@]'
5766                 fi
5767                 ;;
5768         sysv5uw7*|unix_sv*) #(vi
5769                 # tested with UnixWare 7.1.0 (gcc 2.95.2 and cc)
5770                 if test "$GCC" != yes; then
5771                         CC_SHARED_OPTS='-KPIC'
5772                 fi
5773                 MK_SHARED_LIB='${LD} -d y -G -o [$]@'
5774                 ;;
5775         *)
5776                 CC_SHARED_OPTS='unknown'
5777                 MK_SHARED_LIB='echo unknown'
5778                 ;;
5779         esac
5780
5781         # This works if the last tokens in $MK_SHARED_LIB are the -o target.
5782         case "$cf_cv_shlib_version" in #(vi
5783         rel|abi)
5784                 case "$MK_SHARED_LIB" in #(vi
5785                 *'-o $[@]') #(vi
5786                         test "$cf_cv_do_symlinks" = no && cf_cv_do_symlinks=yes
5787                         ;;
5788                 *)
5789                         AC_MSG_WARN(ignored --with-shlib-version)
5790                         ;;
5791                 esac
5792                 ;;
5793         esac
5794
5795         if test -n "$cf_try_cflags"
5796         then
5797 cat > conftest.$ac_ext <<EOF
5798 #line __oline__ "${as_me:-configure}"
5799 #include <stdio.h>
5800 int main(int argc, char *argv[[]])
5801 {
5802         printf("hello\n");
5803         return (argv[[argc-1]] == 0) ;
5804 }
5805 EOF
5806                 cf_save_CFLAGS="$CFLAGS"
5807                 for cf_opt in $cf_try_cflags
5808                 do
5809                         CFLAGS="$cf_save_CFLAGS -$cf_opt"
5810                         AC_MSG_CHECKING(if CFLAGS option -$cf_opt works)
5811                         if AC_TRY_EVAL(ac_compile); then
5812                                 AC_MSG_RESULT(yes)
5813                                 cf_save_CFLAGS="$CFLAGS"
5814                         else
5815                                 AC_MSG_RESULT(no)
5816                         fi
5817                 done
5818                 CFLAGS="$cf_save_CFLAGS"
5819         fi
5820
5821
5822         # RPATH_LIST is a colon-separated list of directories
5823         test -n "$cf_ld_rpath_opt" && MK_SHARED_LIB="$MK_SHARED_LIB $cf_ld_rpath_opt\${RPATH_LIST}"
5824         test -z "$RPATH_LIST" && RPATH_LIST="\${libdir}"
5825
5826         test $cf_cv_rm_so_locs = yes && RM_SHARED_OPTS="$RM_SHARED_OPTS so_locations"
5827
5828         CF_VERBOSE(CC_SHARED_OPTS: $CC_SHARED_OPTS)
5829         CF_VERBOSE(MK_SHARED_LIB:  $MK_SHARED_LIB)
5830
5831         AC_SUBST(CC_SHARED_OPTS)
5832         AC_SUBST(LD_RPATH_OPT)
5833         AC_SUBST(LD_SHARED_OPTS)
5834         AC_SUBST(MK_SHARED_LIB)
5835         AC_SUBST(RM_SHARED_OPTS)
5836
5837         AC_SUBST(LINK_PROGS)
5838         AC_SUBST(LINK_TESTS)
5839
5840         AC_SUBST(EXTRA_LDFLAGS)
5841         AC_SUBST(LOCAL_LDFLAGS)
5842         AC_SUBST(LOCAL_LDFLAGS2)
5843
5844         AC_SUBST(INSTALL_LIB)
5845         AC_SUBST(RPATH_LIST)
5846 ])dnl
5847 dnl ---------------------------------------------------------------------------
5848 dnl CF_SHARED_SONAME version: 3 updated: 2008/09/08 18:34:43
5849 dnl ----------------
5850 dnl utility macro for CF_SHARED_OPTS, constructs "$cf_cv_shared_soname" for
5851 dnl substitution into MK_SHARED_LIB string for the "-soname" (or similar)
5852 dnl option.
5853 dnl
5854 dnl $1 is the default that should be used for "$cf_cv_shlib_version".
5855 dnl If missing, use "rel".
5856 define([CF_SHARED_SONAME],
5857 [
5858         test "$cf_cv_shlib_version" = auto && cf_cv_shlib_version=ifelse($1,,rel,$1)
5859         if test "$cf_cv_shlib_version" = rel; then
5860                 cf_cv_shared_soname='`basename $[@] .${REL_VERSION}`.${ABI_VERSION}'
5861         else
5862                 cf_cv_shared_soname='`basename $[@]`'
5863         fi
5864 ])
5865 dnl ---------------------------------------------------------------------------
5866 dnl CF_SIGWINCH version: 1 updated: 2006/04/02 16:41:09
5867 dnl -----------
5868 dnl Use this macro after CF_XOPEN_SOURCE, but do not require it (not all
5869 dnl programs need this test).
5870 dnl
5871 dnl This is really a MacOS X 10.4.3 workaround.  Defining _POSIX_C_SOURCE
5872 dnl forces SIGWINCH to be undefined (breaks xterm, ncurses).  Oddly, the struct
5873 dnl winsize declaration is left alone - we may revisit this if Apple choose to
5874 dnl break that part of the interface as well.
5875 AC_DEFUN([CF_SIGWINCH],
5876 [
5877 AC_CACHE_CHECK(if SIGWINCH is defined,cf_cv_define_sigwinch,[
5878         AC_TRY_COMPILE([
5879 #include <sys/types.h>
5880 #include <sys/signal.h>
5881 ],[int x = SIGWINCH],
5882         [cf_cv_define_sigwinch=yes],
5883         [AC_TRY_COMPILE([
5884 #undef _XOPEN_SOURCE
5885 #undef _POSIX_SOURCE
5886 #undef _POSIX_C_SOURCE
5887 #include <sys/types.h>
5888 #include <sys/signal.h>
5889 ],[int x = SIGWINCH],
5890         [cf_cv_define_sigwinch=maybe],
5891         [cf_cv_define_sigwinch=no])
5892 ])
5893 ])
5894
5895 if test "$cf_cv_define_sigwinch" = maybe ; then
5896 AC_CACHE_CHECK(for actual SIGWINCH definition,cf_cv_fixup_sigwinch,[
5897 cf_cv_fixup_sigwinch=unknown
5898 cf_sigwinch=32
5899 while test $cf_sigwinch != 1
5900 do
5901         AC_TRY_COMPILE([
5902 #undef _XOPEN_SOURCE
5903 #undef _POSIX_SOURCE
5904 #undef _POSIX_C_SOURCE
5905 #include <sys/types.h>
5906 #include <sys/signal.h>
5907 ],[
5908 #if SIGWINCH != $cf_sigwinch
5909 make an error
5910 #endif
5911 int x = SIGWINCH],
5912         [cf_cv_fixup_sigwinch=$cf_sigwinch
5913          break])
5914
5915 cf_sigwinch=`expr $cf_sigwinch - 1`
5916 done
5917 ])
5918
5919         if test "$cf_cv_fixup_sigwinch" != unknown ; then
5920                 CPPFLAGS="$CPPFLAGS -DSIGWINCH=$cf_cv_fixup_sigwinch"
5921         fi
5922 fi
5923 ])dnl
5924 dnl ---------------------------------------------------------------------------
5925 dnl CF_SIG_ATOMIC_T version: 3 updated: 2012/10/04 20:12:20
5926 dnl ---------------
5927 dnl signal handler, but there are some gcc depedencies in that recommendation.
5928 dnl Try anyway.
5929 AC_DEFUN([CF_SIG_ATOMIC_T],
5930 [
5931 AC_MSG_CHECKING(for signal global datatype)
5932 AC_CACHE_VAL(cf_cv_sig_atomic_t,[
5933         for cf_type in \
5934                 "volatile sig_atomic_t" \
5935                 "sig_atomic_t" \
5936                 "int"
5937         do
5938         AC_TRY_COMPILE([
5939 #include <sys/types.h>
5940 #include <signal.h>
5941 #include <stdio.h>
5942
5943 extern $cf_type x;
5944 $cf_type x;
5945 static void handler(int sig)
5946 {
5947         x = 5;
5948 }],
5949                 [signal(SIGINT, handler);
5950                  x = 1],
5951                 [cf_cv_sig_atomic_t=$cf_type],
5952                 [cf_cv_sig_atomic_t=no])
5953                 test "$cf_cv_sig_atomic_t" != no && break
5954         done
5955         ])
5956 AC_MSG_RESULT($cf_cv_sig_atomic_t)
5957 test "$cf_cv_sig_atomic_t" != no && AC_DEFINE_UNQUOTED(SIG_ATOMIC_T, $cf_cv_sig_atomic_t,[Define to signal global datatype])
5958 ])dnl
5959 dnl ---------------------------------------------------------------------------
5960 dnl CF_SIZECHANGE version: 9 updated: 2012/10/06 11:17:15
5961 dnl -------------
5962 dnl Check for definitions & structures needed for window size-changing
5963 dnl FIXME: check that this works with "snake" (HP-UX 10.x)
5964 AC_DEFUN([CF_SIZECHANGE],
5965 [
5966 AC_REQUIRE([CF_STRUCT_TERMIOS])
5967 AC_CACHE_CHECK(declaration of size-change, cf_cv_sizechange,[
5968     cf_cv_sizechange=unknown
5969     cf_save_CPPFLAGS="$CPPFLAGS"
5970
5971 for cf_opts in "" "NEED_PTEM_H"
5972 do
5973
5974     CPPFLAGS="$cf_save_CPPFLAGS"
5975     test -n "$cf_opts" && CPPFLAGS="$CPPFLAGS -D$cf_opts"
5976     AC_TRY_COMPILE([#include <sys/types.h>
5977 #ifdef HAVE_TERMIOS_H
5978 #include <termios.h>
5979 #else
5980 #ifdef HAVE_TERMIO_H
5981 #include <termio.h>
5982 #endif
5983 #endif
5984 #ifdef NEED_PTEM_H
5985 /* This is a workaround for SCO:  they neglected to define struct winsize in
5986  * termios.h -- it's only in termio.h and ptem.h
5987  */
5988 #include        <sys/stream.h>
5989 #include        <sys/ptem.h>
5990 #endif
5991 #if !defined(sun) || !defined(HAVE_TERMIOS_H)
5992 #include <sys/ioctl.h>
5993 #endif
5994 ],[
5995 #ifdef TIOCGSIZE
5996         struct ttysize win;     /* FIXME: what system is this? */
5997         int y = win.ts_lines;
5998         int x = win.ts_cols;
5999 #else
6000 #ifdef TIOCGWINSZ
6001         struct winsize win;
6002         int y = win.ws_row;
6003         int x = win.ws_col;
6004 #else
6005         no TIOCGSIZE or TIOCGWINSZ
6006 #endif /* TIOCGWINSZ */
6007 #endif /* TIOCGSIZE */
6008         ],
6009         [cf_cv_sizechange=yes],
6010         [cf_cv_sizechange=no])
6011
6012         CPPFLAGS="$cf_save_CPPFLAGS"
6013         if test "$cf_cv_sizechange" = yes ; then
6014                 echo "size-change succeeded ($cf_opts)" >&AC_FD_CC
6015                 test -n "$cf_opts" && cf_cv_sizechange="$cf_opts"
6016                 break
6017         fi
6018 done
6019 ])
6020 if test "$cf_cv_sizechange" != no ; then
6021         AC_DEFINE(HAVE_SIZECHANGE,1,[Define to 1 if sizechar declarations are provided])
6022         case $cf_cv_sizechange in #(vi
6023         NEED*)
6024                 AC_DEFINE_UNQUOTED($cf_cv_sizechange )
6025                 ;;
6026         esac
6027 fi
6028 ])dnl
6029 dnl ---------------------------------------------------------------------------
6030 dnl CF_SRC_MODULES version: 28 updated: 2014/09/20 20:16:32
6031 dnl --------------
6032 dnl For each parameter, test if the source-directory exists, and if it contains
6033 dnl a 'modules' file.  If so, add to the list $cf_cv_src_modules which we'll
6034 dnl use in CF_LIB_RULES.
6035 dnl
6036 dnl This uses the configured value to make the lists SRC_SUBDIRS and
6037 dnl SUB_MAKEFILES which are used in the makefile-generation scheme.
6038 AC_DEFUN([CF_SRC_MODULES],
6039 [
6040 AC_MSG_CHECKING(for src modules)
6041
6042 # dependencies and linker-arguments for test-programs
6043 TEST_DEPS="${LIB_DIR}/${LIB_PREFIX}${LIB_NAME}${DFT_DEP_SUFFIX} $TEST_DEPS"
6044 TEST_DEP2="${LIB_2ND}/${LIB_PREFIX}${LIB_NAME}${DFT_DEP_SUFFIX} $TEST_DEP2"
6045 if test "$DFT_LWR_MODEL" = "libtool"; then
6046         TEST_ARGS="${TEST_DEPS}"
6047         TEST_ARG2="${TEST_DEP2}"
6048 else
6049         TEST_ARGS="-l${LIB_NAME}${DFT_ARG_SUFFIX} $TEST_ARGS"
6050         TEST_ARG2="-l${LIB_NAME}${DFT_ARG_SUFFIX} $TEST_ARG2"
6051 fi
6052
6053 PC_MODULES_TO_MAKE="ncurses${DFT_ARG_SUFFIX}"
6054 cf_cv_src_modules=
6055 for cf_dir in $1
6056 do
6057         if test -f $srcdir/$cf_dir/modules; then
6058
6059                 # We may/may not have tack in the distribution, though the
6060                 # makefile is.
6061                 if test $cf_dir = tack ; then
6062                         if test ! -f $srcdir/${cf_dir}/${cf_dir}.h; then
6063                                 continue
6064                         fi
6065                 fi
6066
6067                 if test -z "$cf_cv_src_modules"; then
6068                         cf_cv_src_modules=$cf_dir
6069                 else
6070                         cf_cv_src_modules="$cf_cv_src_modules $cf_dir"
6071                 fi
6072
6073                 # Make the ncurses_cfg.h file record the library interface files as
6074                 # well.  These are header files that are the same name as their
6075                 # directory.  Ncurses is the only library that does not follow
6076                 # that pattern.
6077                 if test $cf_dir = tack ; then
6078                         continue
6079                 elif test -f $srcdir/${cf_dir}/${cf_dir}.h; then
6080                         CF_UPPER(cf_have_include,$cf_dir)
6081                         AC_DEFINE_UNQUOTED(HAVE_${cf_have_include}_H)
6082                         AC_DEFINE_UNQUOTED(HAVE_LIB${cf_have_include})
6083                         TEST_DEPS="${LIB_DIR}/${LIB_PREFIX}${cf_dir}${DFT_DEP_SUFFIX} $TEST_DEPS"
6084                         TEST_DEP2="${LIB_2ND}/${LIB_PREFIX}${cf_dir}${DFT_DEP_SUFFIX} $TEST_DEP2"
6085                         if test "$DFT_LWR_MODEL" = "libtool"; then
6086                                 TEST_ARGS="${TEST_DEPS}"
6087                                 TEST_ARG2="${TEST_DEP2}"
6088                         else
6089                                 TEST_ARGS="-l${cf_dir}${DFT_ARG_SUFFIX} $TEST_ARGS"
6090                                 TEST_ARG2="-l${cf_dir}${DFT_ARG_SUFFIX} $TEST_ARG2"
6091                         fi
6092                         PC_MODULES_TO_MAKE="${PC_MODULES_TO_MAKE} ${cf_dir}${DFT_ARG_SUFFIX}"
6093                 fi
6094         fi
6095 done
6096 AC_MSG_RESULT($cf_cv_src_modules)
6097
6098 TEST_ARGS="-L${LIB_DIR} $TEST_ARGS"
6099 TEST_ARG2="-L${LIB_2ND} $TEST_ARG2"
6100
6101 AC_SUBST(TEST_ARGS)
6102 AC_SUBST(TEST_DEPS)
6103
6104 AC_SUBST(TEST_ARG2)
6105 AC_SUBST(TEST_DEP2)
6106
6107 SRC_SUBDIRS=
6108 if test "x$cf_with_manpages" != xno ; then
6109         SRC_SUBDIRS="$SRC_SUBDIRS man"
6110 fi
6111 SRC_SUBDIRS="$SRC_SUBDIRS include"
6112 for cf_dir in $cf_cv_src_modules
6113 do
6114         SRC_SUBDIRS="$SRC_SUBDIRS $cf_dir"
6115 done
6116 if test "x$cf_with_tests" != "xno" ; then
6117         SRC_SUBDIRS="$SRC_SUBDIRS test"
6118 fi
6119 # always make this, to install the ncurses-config script
6120 SRC_SUBDIRS="$SRC_SUBDIRS misc"
6121 if test "$cf_with_cxx_binding" != no; then
6122         PC_MODULES_TO_MAKE="${PC_MODULES_TO_MAKE} ncurses++${DFT_ARG_SUFFIX}"
6123         SRC_SUBDIRS="$SRC_SUBDIRS c++"
6124 fi
6125
6126 test "x$with_termlib" != xno && PC_MODULES_TO_MAKE="$PC_MODULES_TO_MAKE $TINFO_ARG_SUFFIX"
6127 test "x$with_ticlib" != xno && PC_MODULES_TO_MAKE="$PC_MODULES_TO_MAKE $TICS_ARG_SUFFIX"
6128
6129 AC_SUBST(PC_MODULES_TO_MAKE)
6130
6131 ADA_SUBDIRS=
6132 if test "x$cf_with_ada" = "xyes" && test "x$cf_cv_prog_gnat_correct" = xyes && test -f $srcdir/Ada95/Makefile.in; then
6133         SRC_SUBDIRS="$SRC_SUBDIRS Ada95"
6134         ADA_SUBDIRS="gen src"
6135         if test "x$cf_with_tests" != "xno" ; then
6136                 ADA_SUBDIRS="$ADA_SUBDIRS samples"
6137         fi
6138 fi
6139
6140 SUB_MAKEFILES=
6141 for cf_dir in $SRC_SUBDIRS
6142 do
6143         SUB_MAKEFILES="$SUB_MAKEFILES $cf_dir/Makefile"
6144 done
6145
6146 if test -n "$ADA_SUBDIRS"; then
6147         for cf_dir in $ADA_SUBDIRS
6148         do
6149                 SUB_MAKEFILES="$SUB_MAKEFILES Ada95/$cf_dir/Makefile"
6150         done
6151         AC_SUBST(ADA_SUBDIRS)
6152 fi
6153 ])dnl
6154 dnl ---------------------------------------------------------------------------
6155 dnl CF_STDCPP_LIBRARY version: 7 updated: 2010/05/29 16:31:02
6156 dnl -----------------
6157 dnl Check for -lstdc++, which is GNU's standard C++ library.
6158 AC_DEFUN([CF_STDCPP_LIBRARY],
6159 [
6160 if test -n "$GXX" ; then
6161 case $cf_cv_system_name in #(vi
6162 os2*) #(vi
6163         cf_stdcpp_libname=stdcpp
6164         ;;
6165 *)
6166         cf_stdcpp_libname=stdc++
6167         ;;
6168 esac
6169 AC_CACHE_CHECK(for library $cf_stdcpp_libname,cf_cv_libstdcpp,[
6170         cf_save="$LIBS"
6171         CF_ADD_LIB($cf_stdcpp_libname)
6172 AC_TRY_LINK([
6173 #include <strstream.h>],[
6174 char buf[80];
6175 strstreambuf foo(buf, sizeof(buf))
6176 ],
6177         [cf_cv_libstdcpp=yes],
6178         [cf_cv_libstdcpp=no])
6179         LIBS="$cf_save"
6180 ])
6181 test "$cf_cv_libstdcpp" = yes && CF_ADD_LIB($cf_stdcpp_libname,CXXLIBS)
6182 fi
6183 ])dnl
6184 dnl ---------------------------------------------------------------------------
6185 dnl CF_STRIP_G_OPT version: 3 updated: 2002/12/21 19:25:52
6186 dnl --------------
6187 dnl     Remove "-g" option from the compiler options
6188 AC_DEFUN([CF_STRIP_G_OPT],
6189 [$1=`echo ${$1} | sed -e 's%-g %%' -e 's%-g$%%'`])dnl
6190 dnl ---------------------------------------------------------------------------
6191 dnl CF_STRUCT_SIGACTION version: 5 updated: 2012/10/06 17:56:13
6192 dnl -------------------
6193 dnl Check if we need _POSIX_SOURCE defined to use struct sigaction.  We'll only
6194 dnl do this if we've found the sigaction function.
6195 AC_DEFUN([CF_STRUCT_SIGACTION],[
6196 AC_REQUIRE([CF_XOPEN_SOURCE])
6197
6198 if test "$ac_cv_func_sigaction" = yes; then
6199 AC_MSG_CHECKING(whether sigaction needs _POSIX_SOURCE)
6200 AC_TRY_COMPILE([
6201 #include <sys/types.h>
6202 #include <signal.h>],
6203         [struct sigaction act],
6204         [sigact_bad=no],
6205         [
6206 AC_TRY_COMPILE([
6207 #define _POSIX_SOURCE
6208 #include <sys/types.h>
6209 #include <signal.h>],
6210         [struct sigaction act],
6211         [sigact_bad=yes
6212          AC_DEFINE(_POSIX_SOURCE,1,[Define to 1 if we must define _POSIX_SOURCE])],
6213          [sigact_bad=unknown])])
6214 AC_MSG_RESULT($sigact_bad)
6215 fi
6216 ])dnl
6217 dnl ---------------------------------------------------------------------------
6218 dnl CF_STRUCT_TERMIOS version: 7 updated: 2012/10/06 17:56:13
6219 dnl -----------------
6220 dnl Some machines require _POSIX_SOURCE to completely define struct termios.
6221 AC_DEFUN([CF_STRUCT_TERMIOS],[
6222 AC_REQUIRE([CF_XOPEN_SOURCE])
6223
6224 AC_CHECK_HEADERS( \
6225 termio.h \
6226 termios.h \
6227 unistd.h \
6228 )
6229
6230 if test "$ISC" = yes ; then
6231         AC_CHECK_HEADERS( sys/termio.h )
6232 fi
6233 if test "$ac_cv_header_termios_h" = yes ; then
6234         case "$CFLAGS $CPPFLAGS" in
6235         *-D_POSIX_SOURCE*)
6236                 termios_bad=dunno ;;
6237         *)      termios_bad=maybe ;;
6238         esac
6239         if test "$termios_bad" = maybe ; then
6240         AC_MSG_CHECKING(whether termios.h needs _POSIX_SOURCE)
6241         AC_TRY_COMPILE([#include <termios.h>],
6242                 [struct termios foo; int x = foo.c_iflag],
6243                 termios_bad=no, [
6244                 AC_TRY_COMPILE([
6245 #define _POSIX_SOURCE
6246 #include <termios.h>],
6247                         [struct termios foo; int x = foo.c_iflag],
6248                         termios_bad=unknown,
6249                         termios_bad=yes AC_DEFINE(_POSIX_SOURCE,1,[Define to 1 if we must define _POSIX_SOURCE]))
6250                         ])
6251         AC_MSG_RESULT($termios_bad)
6252         fi
6253 fi
6254 ])dnl
6255 dnl ---------------------------------------------------------------------------
6256 dnl CF_SUBDIR_PATH version: 6 updated: 2010/04/21 06:20:50
6257 dnl --------------
6258 dnl Construct a search-list for a nonstandard header/lib-file
6259 dnl     $1 = the variable to return as result
6260 dnl     $2 = the package name
6261 dnl     $3 = the subdirectory, e.g., bin, include or lib
6262 AC_DEFUN([CF_SUBDIR_PATH],
6263 [
6264 $1=
6265
6266 CF_ADD_SUBDIR_PATH($1,$2,$3,/usr,$prefix)
6267 CF_ADD_SUBDIR_PATH($1,$2,$3,$prefix,NONE)
6268 CF_ADD_SUBDIR_PATH($1,$2,$3,/usr/local,$prefix)
6269 CF_ADD_SUBDIR_PATH($1,$2,$3,/opt,$prefix)
6270 CF_ADD_SUBDIR_PATH($1,$2,$3,[$]HOME,$prefix)
6271 ])dnl
6272 dnl ---------------------------------------------------------------------------
6273 dnl CF_SUBST_IF version: 2 updated: 2006/06/17 12:33:03
6274 dnl -----------
6275 dnl     Shorthand macro for substituting things that the user may override
6276 dnl     with an environment variable.
6277 dnl
6278 dnl     $1 = condition to pass to "test"
6279 dnl     $2 = environment variable
6280 dnl     $3 = value if the test succeeds
6281 dnl     $4 = value if the test fails
6282 AC_DEFUN([CF_SUBST_IF],
6283 [
6284 if test $1 ; then
6285         $2=$3
6286 ifelse($4,,,[else
6287         $2=$4])
6288 fi
6289 AC_SUBST($2)
6290 ])dnl
6291 dnl ---------------------------------------------------------------------------
6292 dnl CF_SUBST_NCURSES_VERSION version: 8 updated: 2006/09/16 11:40:59
6293 dnl ------------------------
6294 dnl Get the version-number for use in shared-library naming, etc.
6295 AC_DEFUN([CF_SUBST_NCURSES_VERSION],
6296 [
6297 AC_REQUIRE([CF_PROG_EGREP])
6298 NCURSES_MAJOR="`$ac_cv_prog_egrep '^NCURSES_MAJOR[[     ]]*=' $srcdir/dist.mk | sed -e 's/^[[^0-9]]*//'`"
6299 NCURSES_MINOR="`$ac_cv_prog_egrep '^NCURSES_MINOR[[     ]]*=' $srcdir/dist.mk | sed -e 's/^[[^0-9]]*//'`"
6300 NCURSES_PATCH="`$ac_cv_prog_egrep '^NCURSES_PATCH[[     ]]*=' $srcdir/dist.mk | sed -e 's/^[[^0-9]]*//'`"
6301 cf_cv_abi_version=${NCURSES_MAJOR}
6302 cf_cv_rel_version=${NCURSES_MAJOR}.${NCURSES_MINOR}
6303 dnl Show the computed version, for logging
6304 cf_cv_timestamp=`date`
6305 AC_MSG_RESULT(Configuring NCURSES $cf_cv_rel_version ABI $cf_cv_abi_version ($cf_cv_timestamp))
6306 dnl We need these values in the generated headers
6307 AC_SUBST(NCURSES_MAJOR)
6308 AC_SUBST(NCURSES_MINOR)
6309 AC_SUBST(NCURSES_PATCH)
6310 dnl We need these values in the generated makefiles
6311 AC_SUBST(cf_cv_rel_version)
6312 AC_SUBST(cf_cv_abi_version)
6313 AC_SUBST(cf_cv_builtin_bool)
6314 AC_SUBST(cf_cv_header_stdbool_h)
6315 AC_SUBST(cf_cv_type_of_bool)dnl
6316 ])dnl
6317 dnl ---------------------------------------------------------------------------
6318 dnl CF_SYS_TIME_SELECT version: 5 updated: 2012/10/04 05:24:07
6319 dnl ------------------
6320 dnl Check if we can include <sys/time.h> with <sys/select.h>; this breaks on
6321 dnl older SCO configurations.
6322 AC_DEFUN([CF_SYS_TIME_SELECT],
6323 [
6324 AC_MSG_CHECKING(if sys/time.h works with sys/select.h)
6325 AC_CACHE_VAL(cf_cv_sys_time_select,[
6326 AC_TRY_COMPILE([
6327 #include <sys/types.h>
6328 #ifdef HAVE_SYS_TIME_H
6329 #include <sys/time.h>
6330 #endif
6331 #ifdef HAVE_SYS_SELECT_H
6332 #include <sys/select.h>
6333 #endif
6334 ],[],[cf_cv_sys_time_select=yes],
6335      [cf_cv_sys_time_select=no])
6336      ])
6337 AC_MSG_RESULT($cf_cv_sys_time_select)
6338 test "$cf_cv_sys_time_select" = yes && AC_DEFINE(HAVE_SYS_TIME_SELECT,1,[Define to 1 if we can include <sys/time.h> with <sys/select.h>])
6339 ])dnl
6340 dnl ---------------------------------------------------------------------------
6341 dnl CF_TOP_BUILDDIR version: 2 updated: 2013/07/27 17:38:32
6342 dnl ---------------
6343 dnl Define a top_builddir symbol, for applications that need an absolute path.
6344 AC_DEFUN([CF_TOP_BUILDDIR],
6345 [
6346 top_builddir=ifelse($1,,`pwd`,$1)
6347 AC_SUBST(top_builddir)
6348 ])dnl
6349 dnl ---------------------------------------------------------------------------
6350 dnl CF_TRY_XOPEN_SOURCE version: 1 updated: 2011/10/30 17:09:50
6351 dnl -------------------
6352 dnl If _XOPEN_SOURCE is not defined in the compile environment, check if we
6353 dnl can define it successfully.
6354 AC_DEFUN([CF_TRY_XOPEN_SOURCE],[
6355 AC_CACHE_CHECK(if we should define _XOPEN_SOURCE,cf_cv_xopen_source,[
6356         AC_TRY_COMPILE([
6357 #include <stdlib.h>
6358 #include <string.h>
6359 #include <sys/types.h>
6360 ],[
6361 #ifndef _XOPEN_SOURCE
6362 make an error
6363 #endif],
6364         [cf_cv_xopen_source=no],
6365         [cf_save="$CPPFLAGS"
6366          CPPFLAGS="$CPPFLAGS -D_XOPEN_SOURCE=$cf_XOPEN_SOURCE"
6367          AC_TRY_COMPILE([
6368 #include <stdlib.h>
6369 #include <string.h>
6370 #include <sys/types.h>
6371 ],[
6372 #ifdef _XOPEN_SOURCE
6373 make an error
6374 #endif],
6375         [cf_cv_xopen_source=no],
6376         [cf_cv_xopen_source=$cf_XOPEN_SOURCE])
6377         CPPFLAGS="$cf_save"
6378         ])
6379 ])
6380
6381 if test "$cf_cv_xopen_source" != no ; then
6382         CF_REMOVE_DEFINE(CFLAGS,$CFLAGS,_XOPEN_SOURCE)
6383         CF_REMOVE_DEFINE(CPPFLAGS,$CPPFLAGS,_XOPEN_SOURCE)
6384         cf_temp_xopen_source="-D_XOPEN_SOURCE=$cf_cv_xopen_source"
6385         CF_ADD_CFLAGS($cf_temp_xopen_source)
6386 fi
6387 ])
6388 dnl ---------------------------------------------------------------------------
6389 dnl CF_TYPEOF_CHTYPE version: 9 updated: 2012/10/06 17:56:13
6390 dnl ----------------
6391 dnl Determine the type we should use for chtype (and attr_t, which is treated
6392 dnl as the same thing).  We want around 32 bits, so on most machines want a
6393 dnl long, but on newer 64-bit machines, probably want an int.  If we're using
6394 dnl wide characters, we have to have a type compatible with that, as well.
6395 AC_DEFUN([CF_TYPEOF_CHTYPE],
6396 [
6397 AC_MSG_CHECKING([for type of chtype])
6398 AC_CACHE_VAL(cf_cv_typeof_chtype,[
6399                 AC_TRY_RUN([
6400 #define WANT_BITS 31
6401 #include <stdio.h>
6402 int main()
6403 {
6404         FILE *fp = fopen("cf_test.out", "w");
6405         if (fp != 0) {
6406                 char *result = "long";
6407                 if (sizeof(unsigned long) > sizeof(unsigned int)) {
6408                         int n;
6409                         unsigned int x, y;
6410                         for (n = 0; n < WANT_BITS; n++) {
6411                                 x = (1 << n);
6412                                 y = (x >> n);
6413                                 if (y != 1 || x == 0) {
6414                                         x = 0;
6415                                         break;
6416                                 }
6417                         }
6418                         /*
6419                          * If x is nonzero, an int is big enough for the bits
6420                          * that we want.
6421                          */
6422                         result = (x != 0) ? "int" : "long";
6423                 }
6424                 fputs(result, fp);
6425                 fclose(fp);
6426         }
6427         ${cf_cv_main_return:-return}(0);
6428 }
6429                 ],
6430                 [cf_cv_typeof_chtype=`cat cf_test.out`],
6431                 [cf_cv_typeof_chtype=long],
6432                 [cf_cv_typeof_chtype=long])
6433                 rm -f cf_test.out
6434         ])
6435 AC_MSG_RESULT($cf_cv_typeof_chtype)
6436
6437 AC_SUBST(cf_cv_typeof_chtype)
6438 AC_DEFINE_UNQUOTED(TYPEOF_CHTYPE,$cf_cv_typeof_chtype,[Define to actual type if needed for chtype])
6439 ])dnl
6440 dnl ---------------------------------------------------------------------------
6441 dnl CF_TYPE_SIGACTION version: 4 updated: 2012/10/06 17:56:13
6442 dnl -----------------
6443 dnl
6444 AC_DEFUN([CF_TYPE_SIGACTION],
6445 [
6446 AC_MSG_CHECKING([for type sigaction_t])
6447 AC_CACHE_VAL(cf_cv_type_sigaction,[
6448         AC_TRY_COMPILE([
6449 #include <signal.h>],
6450                 [sigaction_t x],
6451                 [cf_cv_type_sigaction=yes],
6452                 [cf_cv_type_sigaction=no])])
6453 AC_MSG_RESULT($cf_cv_type_sigaction)
6454 test "$cf_cv_type_sigaction" = yes && AC_DEFINE(HAVE_TYPE_SIGACTION,1,[Define to 1 if we have the sigaction_t type])
6455 ])dnl
6456 dnl ---------------------------------------------------------------------------
6457 dnl CF_UNSIGNED_LITERALS version: 2 updated: 1998/02/07 22:10:16
6458 dnl --------------------
6459 dnl Test if the compiler supports 'U' and 'L' suffixes.  Only old compilers
6460 dnl won't, but they're still there.
6461 AC_DEFUN([CF_UNSIGNED_LITERALS],
6462 [
6463 AC_MSG_CHECKING([if unsigned literals are legal])
6464 AC_CACHE_VAL(cf_cv_unsigned_literals,[
6465         AC_TRY_COMPILE([],[long x = 1L + 1UL + 1U + 1],
6466                 [cf_cv_unsigned_literals=yes],
6467                 [cf_cv_unsigned_literals=no])
6468         ])
6469 AC_MSG_RESULT($cf_cv_unsigned_literals)
6470 ])dnl
6471 dnl ---------------------------------------------------------------------------
6472 dnl CF_UPPER version: 5 updated: 2001/01/29 23:40:59
6473 dnl --------
6474 dnl Make an uppercase version of a variable
6475 dnl $1=uppercase($2)
6476 AC_DEFUN([CF_UPPER],
6477 [
6478 $1=`echo "$2" | sed y%abcdefghijklmnopqrstuvwxyz./-%ABCDEFGHIJKLMNOPQRSTUVWXYZ___%`
6479 ])dnl
6480 dnl ---------------------------------------------------------------------------
6481 dnl CF_UTF8_LIB version: 8 updated: 2012/10/06 08:57:51
6482 dnl -----------
6483 dnl Check for multibyte support, and if not found, utf8 compatibility library
6484 AC_DEFUN([CF_UTF8_LIB],
6485 [
6486 AC_CACHE_CHECK(for multibyte character support,cf_cv_utf8_lib,[
6487         cf_save_LIBS="$LIBS"
6488         AC_TRY_LINK([
6489 #include <stdlib.h>],[putwc(0,0);],
6490         [cf_cv_utf8_lib=yes],
6491         [CF_FIND_LINKAGE([
6492 #include <libutf8.h>],[putwc(0,0);],utf8,
6493                 [cf_cv_utf8_lib=add-on],
6494                 [cf_cv_utf8_lib=no])
6495 ])])
6496
6497 # HAVE_LIBUTF8_H is used by ncurses if curses.h is shared between
6498 # ncurses/ncursesw:
6499 if test "$cf_cv_utf8_lib" = "add-on" ; then
6500         AC_DEFINE(HAVE_LIBUTF8_H,1,[Define to 1 if we should include libutf8.h])
6501         CF_ADD_INCDIR($cf_cv_header_path_utf8)
6502         CF_ADD_LIBDIR($cf_cv_library_path_utf8)
6503         CF_ADD_LIBS($cf_cv_library_file_utf8)
6504 fi
6505 ])dnl
6506 dnl ---------------------------------------------------------------------------
6507 dnl CF_VA_COPY version: 3 updated: 2012/10/06 11:17:15
6508 dnl ----------
6509 dnl check for va_copy, part of stdarg.h
6510 dnl Also, workaround for glibc's __va_copy, by checking for both.
6511 AC_DEFUN([CF_VA_COPY],[
6512 AC_CACHE_CHECK(for va_copy, cf_cv_have_va_copy,[
6513 AC_TRY_LINK([
6514 #include <stdarg.h>
6515 ],[
6516         static va_list dst;
6517         static va_list src;
6518         va_copy(dst, src)],
6519         cf_cv_have_va_copy=yes,
6520         cf_cv_have_va_copy=no)])
6521
6522 test "$cf_cv_have_va_copy" = yes && AC_DEFINE(HAVE_VA_COPY,1,[Define to 1 if we have va_copy])
6523
6524 AC_CACHE_CHECK(for __va_copy, cf_cv_have___va_copy,[
6525 AC_TRY_LINK([
6526 #include <stdarg.h>
6527 ],[
6528         static va_list dst;
6529         static va_list src;
6530         __va_copy(dst, src)],
6531         cf_cv_have___va_copy=yes,
6532         cf_cv_have___va_copy=no)])
6533
6534 test "$cf_cv_have___va_copy" = yes && AC_DEFINE(HAVE___VA_COPY,1,[Define to 1 if we have __va_copy])
6535 ])
6536 dnl ---------------------------------------------------------------------------
6537 dnl CF_VERBOSE version: 3 updated: 2007/07/29 09:55:12
6538 dnl ----------
6539 dnl Use AC_VERBOSE w/o the warnings
6540 AC_DEFUN([CF_VERBOSE],
6541 [test -n "$verbose" && echo "   $1" 1>&AC_FD_MSG
6542 CF_MSG_LOG([$1])
6543 ])dnl
6544 dnl ---------------------------------------------------------------------------
6545 dnl CF_VERSION_INFO version: 6 updated: 2013/06/16 10:25:53
6546 dnl ---------------
6547 dnl Define several useful symbols derived from the VERSION file.  A separate
6548 dnl file is preferred to embedding the version numbers in various scripts.
6549 dnl (automake is a textbook-example of why the latter is a bad idea, but there
6550 dnl are others).
6551 dnl
6552 dnl The file contents are:
6553 dnl     libtool-version release-version patch-version
6554 dnl or
6555 dnl     release-version
6556 dnl where
6557 dnl     libtool-version (see ?) consists of 3 integers separated by '.'
6558 dnl     release-version consists of a major version and minor version
6559 dnl             separated by '.', optionally followed by a patch-version
6560 dnl             separated by '-'.  The minor version need not be an
6561 dnl             integer (but it is preferred).
6562 dnl     patch-version is an integer in the form yyyymmdd, so ifdef's and
6563 dnl             scripts can easily compare versions.
6564 dnl
6565 dnl If libtool is used, the first form is required, since CF_WITH_LIBTOOL
6566 dnl simply extracts the first field using 'cut -f1'.
6567 dnl
6568 dnl Optional parameters:
6569 dnl $1 = internal name for package
6570 dnl $2 = external name for package
6571 AC_DEFUN([CF_VERSION_INFO],
6572 [
6573 if test -f $srcdir/VERSION ; then
6574         AC_MSG_CHECKING(for package version)
6575
6576         # if there are not enough fields, cut returns the last one...
6577         cf_field1=`sed -e '2,$d' $srcdir/VERSION|cut -f1`
6578         cf_field2=`sed -e '2,$d' $srcdir/VERSION|cut -f2`
6579         cf_field3=`sed -e '2,$d' $srcdir/VERSION|cut -f3`
6580
6581         # this is how CF_BUNDLED_INTL uses $VERSION:
6582         VERSION="$cf_field1"
6583
6584         VERSION_MAJOR=`echo "$cf_field2" | sed -e 's/\..*//'`
6585         test -z "$VERSION_MAJOR" && AC_MSG_ERROR(missing major-version)
6586
6587         VERSION_MINOR=`echo "$cf_field2" | sed -e 's/^[[^.]]*\.//' -e 's/-.*//'`
6588         test -z "$VERSION_MINOR" && AC_MSG_ERROR(missing minor-version)
6589
6590         AC_MSG_RESULT(${VERSION_MAJOR}.${VERSION_MINOR})
6591
6592         AC_MSG_CHECKING(for package patch date)
6593         VERSION_PATCH=`echo "$cf_field3" | sed -e 's/^[[^-]]*-//'`
6594         case .$VERSION_PATCH in
6595         .)
6596                 AC_MSG_ERROR(missing patch-date $VERSION_PATCH)
6597                 ;;
6598         .[[0-9]][[0-9]][[0-9]][[0-9]][[0-9]][[0-9]][[0-9]][[0-9]])
6599                 ;;
6600         *)
6601                 AC_MSG_ERROR(illegal patch-date $VERSION_PATCH)
6602                 ;;
6603         esac
6604         AC_MSG_RESULT($VERSION_PATCH)
6605 else
6606         AC_MSG_ERROR(did not find $srcdir/VERSION)
6607 fi
6608
6609 # show the actual data that we have for versions:
6610 CF_VERBOSE(ABI VERSION $VERSION)
6611 CF_VERBOSE(VERSION_MAJOR $VERSION_MAJOR)
6612 CF_VERBOSE(VERSION_MINOR $VERSION_MINOR)
6613 CF_VERBOSE(VERSION_PATCH $VERSION_PATCH)
6614
6615 AC_SUBST(VERSION)
6616 AC_SUBST(VERSION_MAJOR)
6617 AC_SUBST(VERSION_MINOR)
6618 AC_SUBST(VERSION_PATCH)
6619
6620 dnl if a package name is given, define its corresponding version info.  We
6621 dnl need the package name to ensure that the defined symbols are unique.
6622 ifelse($1,,,[
6623         cf_PACKAGE=$1
6624         PACKAGE=ifelse($2,,$1,$2)
6625         AC_DEFINE_UNQUOTED(PACKAGE, "$PACKAGE",[Define to the package-name])
6626         AC_SUBST(PACKAGE)
6627         CF_UPPER(cf_PACKAGE,$cf_PACKAGE)
6628         AC_DEFINE_UNQUOTED(${cf_PACKAGE}_VERSION,"${VERSION_MAJOR}.${VERSION_MINOR}")
6629         AC_DEFINE_UNQUOTED(${cf_PACKAGE}_PATCHDATE,${VERSION_PATCH})
6630 ])
6631 ])dnl
6632 dnl ---------------------------------------------------------------------------
6633 dnl CF_WCHAR_TYPE version: 4 updated: 2012/10/06 16:39:58
6634 dnl -------------
6635 dnl Check if type wide-character type $1 is declared, and if so, which header
6636 dnl file is needed.  The second parameter is used to set a shell variable when
6637 dnl the type is not found.  The first parameter sets a shell variable for the
6638 dnl opposite sense.
6639 AC_DEFUN([CF_WCHAR_TYPE],
6640 [
6641 # This is needed on Tru64 5.0 to declare $1
6642 AC_CACHE_CHECK(if we must include wchar.h to declare $1,cf_cv_$1,[
6643 AC_TRY_COMPILE([
6644 #include <stdlib.h>
6645 #include <stdarg.h>
6646 #include <stdio.h>
6647 #ifdef HAVE_LIBUTF8_H
6648 #include <libutf8.h>
6649 #endif],
6650         [$1 state],
6651         [cf_cv_$1=no],
6652         [AC_TRY_COMPILE([
6653 #include <stdlib.h>
6654 #include <stdarg.h>
6655 #include <stdio.h>
6656 #include <wchar.h>
6657 #ifdef HAVE_LIBUTF8_H
6658 #include <libutf8.h>
6659 #endif],
6660         [$1 value],
6661         [cf_cv_$1=yes],
6662         [cf_cv_$1=unknown])])])
6663
6664 if test "$cf_cv_$1" = yes ; then
6665         AC_DEFINE(NEED_WCHAR_H,1,[Define to 1 if we must include wchar.h])
6666         NEED_WCHAR_H=1
6667 fi
6668
6669 ifelse([$2],,,[
6670 # if we do not find $1 in either place, use substitution to provide a fallback.
6671 if test "$cf_cv_$1" = unknown ; then
6672         $2=1
6673 fi
6674 ])
6675 ifelse($3,,,[
6676 # if we find $1 in either place, use substitution to provide a fallback.
6677 if test "$cf_cv_$1" != unknown ; then
6678         $3=1
6679 fi
6680 ])
6681 ])dnl
6682 dnl ---------------------------------------------------------------------------
6683 dnl CF_WEAK_SYMBOLS version: 1 updated: 2008/08/16 19:18:06
6684 dnl ---------------
6685 dnl Check for compiler-support for weak symbols.
6686 dnl This works with "recent" gcc.
6687 AC_DEFUN([CF_WEAK_SYMBOLS],[
6688 AC_CACHE_CHECK(if $CC supports weak symbols,cf_cv_weak_symbols,[
6689
6690 AC_TRY_COMPILE([
6691 #include <stdio.h>],
6692 [
6693 #if defined(__GNUC__)
6694 #  if defined __USE_ISOC99
6695 #    define _cat_pragma(exp)    _Pragma(#exp)
6696 #    define _weak_pragma(exp)   _cat_pragma(weak name)
6697 #  else
6698 #    define _weak_pragma(exp)
6699 #  endif
6700 #  define _declare(name)        __extension__ extern __typeof__(name) name
6701 #  define weak_symbol(name)     _weak_pragma(name) _declare(name) __attribute__((weak))
6702 #endif
6703
6704 weak_symbol(fopen);
6705 ],[cf_cv_weak_symbols=yes],[cf_cv_weak_symbols=no])
6706 ])
6707 ])dnl
6708 dnl ---------------------------------------------------------------------------
6709 dnl CF_WITH_ABI_VERSION version: 1 updated: 2003/09/20 18:12:49
6710 dnl -------------------
6711 dnl Allow library's ABI to be overridden.  Generally this happens when a
6712 dnl packager has incremented the ABI past that used in the original package,
6713 dnl and wishes to keep doing this.
6714 dnl
6715 dnl $1 is the package name, if any, to derive a corresponding {package}_ABI
6716 dnl symbol.
6717 AC_DEFUN([CF_WITH_ABI_VERSION],[
6718 test -z "$cf_cv_abi_version" && cf_cv_abi_version=0
6719 AC_ARG_WITH(abi-version,
6720 [  --with-abi-version=XXX  override derived ABI version],
6721 [AC_MSG_WARN(overriding ABI version $cf_cv_abi_version to $withval)
6722  cf_cv_abi_version=$withval])
6723  CF_NUMBER_SYNTAX($cf_cv_abi_version,ABI version)
6724 ifelse($1,,,[
6725 $1_ABI=$cf_cv_abi_version
6726 ])
6727 ])dnl
6728 dnl ---------------------------------------------------------------------------
6729 dnl CF_WITH_ADA_COMPILER version: 2 updated: 2010/06/26 17:35:58
6730 dnl --------------------
6731 dnl Command-line option to specify the Ada95 compiler.
6732 AC_DEFUN([CF_WITH_ADA_COMPILER],[
6733 AC_MSG_CHECKING(for ada-compiler)
6734 AC_ARG_WITH(ada-compiler,
6735         [  --with-ada-compiler=CMD specify Ada95 compiler command (default gnatmake)],
6736         [cf_ada_compiler=$withval],
6737         [cf_ada_compiler=gnatmake])
6738 AC_SUBST(cf_ada_compiler)
6739 AC_MSG_RESULT($cf_ada_compiler)
6740 ])dnl
6741 dnl ---------------------------------------------------------------------------
6742 dnl CF_WITH_ADA_INCLUDE version: 2 updated: 2010/06/26 17:35:58
6743 dnl -------------------
6744 dnl Command-line option to specify where Ada includes will install.
6745 AC_DEFUN([CF_WITH_ADA_INCLUDE],[
6746 AC_MSG_CHECKING(for ada-include)
6747 CF_WITH_PATH(ada-include,
6748    [  --with-ada-include=DIR  Ada includes are in DIR],
6749    ADA_INCLUDE,
6750    PREFIX/share/ada/adainclude,
6751    [$]prefix/share/ada/adainclude)
6752 AC_SUBST(ADA_INCLUDE)
6753 AC_MSG_RESULT($ADA_INCLUDE)
6754 ])dnl
6755 dnl ---------------------------------------------------------------------------
6756 dnl CF_WITH_ADA_OBJECTS version: 2 updated: 2010/06/26 17:35:58
6757 dnl -------------------
6758 dnl Command-line option to specify where Ada objects will install.
6759 AC_DEFUN([CF_WITH_ADA_OBJECTS],[
6760 AC_MSG_CHECKING(for ada-objects)
6761 CF_WITH_PATH(ada-objects,
6762    [  --with-ada-objects=DIR  Ada objects are in DIR],
6763    ADA_OBJECTS,
6764    PREFIX/lib/ada/adalib,
6765    [$]prefix/lib/ada/adalib)
6766 AC_SUBST(ADA_OBJECTS)
6767 AC_MSG_RESULT($ADA_OBJECTS)
6768 ])dnl
6769 dnl ---------------------------------------------------------------------------
6770 dnl CF_WITH_ADA_SHAREDLIB version: 4 updated: 2014/05/31 21:08:37
6771 dnl ---------------------
6772 dnl Command-line option to specify if an Ada95 shared-library should be built,
6773 dnl and optionally what its soname should be.
6774 AC_DEFUN([CF_WITH_ADA_SHAREDLIB],[
6775 AC_MSG_CHECKING(if an Ada95 shared-library should be built)
6776 AC_ARG_WITH(ada-sharedlib,
6777         [  --with-ada-sharedlib=soname build shared-library (requires GNAT projects)],
6778         [with_ada_sharedlib=$withval],
6779         [with_ada_sharedlib=no])
6780 AC_MSG_RESULT($with_ada_sharedlib)
6781
6782 ADA_SHAREDLIB='lib$(LIB_NAME).so.1'
6783 MAKE_ADA_SHAREDLIB="#"
6784
6785 if test "x$with_ada_sharedlib" != xno
6786 then
6787         MAKE_ADA_SHAREDLIB=
6788         if test "x$with_ada_sharedlib" != xyes
6789         then
6790                 ADA_SHAREDLIB="$with_ada_sharedlib"
6791         fi
6792 fi
6793
6794 AC_SUBST(ADA_SHAREDLIB)
6795 AC_SUBST(MAKE_ADA_SHAREDLIB)
6796 ])dnl
6797 dnl ---------------------------------------------------------------------------
6798 dnl CF_WITH_DBMALLOC version: 7 updated: 2010/06/21 17:26:47
6799 dnl ----------------
6800 dnl Configure-option for dbmalloc.  The optional parameter is used to override
6801 dnl the updating of $LIBS, e.g., to avoid conflict with subsequent tests.
6802 AC_DEFUN([CF_WITH_DBMALLOC],[
6803 CF_NO_LEAKS_OPTION(dbmalloc,
6804         [  --with-dbmalloc         test: use Conor Cahill's dbmalloc library],
6805         [USE_DBMALLOC])
6806
6807 if test "$with_dbmalloc" = yes ; then
6808         AC_CHECK_HEADER(dbmalloc.h,
6809                 [AC_CHECK_LIB(dbmalloc,[debug_malloc]ifelse([$1],,[],[,$1]))])
6810 fi
6811 ])dnl
6812 dnl ---------------------------------------------------------------------------
6813 dnl CF_WITH_DMALLOC version: 7 updated: 2010/06/21 17:26:47
6814 dnl ---------------
6815 dnl Configure-option for dmalloc.  The optional parameter is used to override
6816 dnl the updating of $LIBS, e.g., to avoid conflict with subsequent tests.
6817 AC_DEFUN([CF_WITH_DMALLOC],[
6818 CF_NO_LEAKS_OPTION(dmalloc,
6819         [  --with-dmalloc          test: use Gray Watson's dmalloc library],
6820         [USE_DMALLOC])
6821
6822 if test "$with_dmalloc" = yes ; then
6823         AC_CHECK_HEADER(dmalloc.h,
6824                 [AC_CHECK_LIB(dmalloc,[dmalloc_debug]ifelse([$1],,[],[,$1]))])
6825 fi
6826 ])dnl
6827 dnl ---------------------------------------------------------------------------
6828 dnl CF_WITH_EXPORT_SYMS version: 2 updated: 2014/11/15 19:05:29
6829 dnl -------------------
6830 dnl Use this with libtool to specify the list of symbols that may be exported.
6831 dnl The input file contains one symbol per line; comments work with "#".
6832 dnl
6833 dnl $1 = basename of the ".sym" file (default $PACKAGE)
6834 AC_DEFUN([CF_WITH_EXPORT_SYMS],
6835 [
6836 AC_MSG_CHECKING(if exported-symbols file should be used)
6837 AC_ARG_WITH(export-syms,
6838         [  --with-export-syms=XXX  limit exported symbols using libtool],
6839         [with_export_syms=$withval],
6840         [with_export_syms=no])
6841 if test "x$with_export_syms" = xyes
6842 then
6843         with_export_syms='${top_srcdir}/package/ifelse($1,,${PACKAGE},[$1]).sym'
6844         AC_SUBST(PACKAGE)
6845 fi
6846 AC_MSG_RESULT($with_export_syms)
6847 if test "x$with_export_syms" != xno
6848 then
6849         EXPORT_SYMS="$EXPORT_SYMS -export-symbols $with_export_syms"
6850         AC_SUBST(EXPORT_SYMS)
6851 fi
6852 ])dnl
6853 dnl ---------------------------------------------------------------------------
6854 dnl CF_WITH_GPM version: 8 updated: 2012/10/06 17:56:13
6855 dnl -----------
6856 dnl
6857 dnl The option parameter (if neither yes/no) is assumed to be the name of
6858 dnl the gpm library, e.g., for dynamic loading.
6859 AC_DEFUN([CF_WITH_GPM],
6860 [
6861 AC_MSG_CHECKING(if you want to link with the GPM mouse library)
6862 AC_ARG_WITH(gpm,
6863         [  --with-gpm              use Alessandro Rubini's GPM library],
6864         [with_gpm=$withval],
6865         [with_gpm=maybe])
6866 AC_MSG_RESULT($with_gpm)
6867
6868 if test "$with_gpm" != no ; then
6869         AC_CHECK_HEADER(gpm.h,[
6870                 AC_DEFINE(HAVE_GPM_H,1,[Define to 1 if we have gpm.h header])
6871                 if test "$with_gpm" != yes && test "$with_gpm" != maybe ; then
6872                         CF_VERBOSE(assuming we really have GPM library)
6873                         AC_DEFINE(HAVE_LIBGPM,1,[Define to 1 if we have the gpm library])
6874                 else
6875                         AC_CHECK_LIB(gpm,Gpm_Open,[:],[
6876                                 AC_MSG_ERROR(Cannot link with GPM library)
6877                 fi
6878                 with_gpm=yes
6879                 ])
6880         ],[
6881                 test "$with_gpm" != maybe && AC_MSG_WARN(Cannot find GPM header)
6882                 with_gpm=no
6883         ])
6884 fi
6885 ])
6886 dnl ---------------------------------------------------------------------------
6887 dnl CF_WITH_LIBTOOL version: 31 updated: 2014/11/15 19:05:29
6888 dnl ---------------
6889 dnl Provide a configure option to incorporate libtool.  Define several useful
6890 dnl symbols for the makefile rules.
6891 dnl
6892 dnl The reference to AC_PROG_LIBTOOL does not normally work, since it uses
6893 dnl macros from libtool.m4 which is in the aclocal directory of automake.
6894 dnl Following is a simple script which turns on the AC_PROG_LIBTOOL macro.
6895 dnl But that still does not work properly since the macro is expanded outside
6896 dnl the CF_WITH_LIBTOOL macro:
6897 dnl
6898 dnl     #!/bin/sh
6899 dnl     ACLOCAL=`aclocal --print-ac-dir`
6900 dnl     if test -z "$ACLOCAL" ; then
6901 dnl             echo cannot find aclocal directory
6902 dnl             exit 1
6903 dnl     elif test ! -f $ACLOCAL/libtool.m4 ; then
6904 dnl             echo cannot find libtool.m4 file
6905 dnl             exit 1
6906 dnl     fi
6907 dnl
6908 dnl     LOCAL=aclocal.m4
6909 dnl     ORIG=aclocal.m4.orig
6910 dnl
6911 dnl     trap "mv $ORIG $LOCAL" 0 1 2 5 15
6912 dnl     rm -f $ORIG
6913 dnl     mv $LOCAL $ORIG
6914 dnl
6915 dnl     # sed the LIBTOOL= assignment to omit the current directory?
6916 dnl     sed -e 's/^LIBTOOL=.*/LIBTOOL=${LIBTOOL:-libtool}/' $ACLOCAL/libtool.m4 >>$LOCAL
6917 dnl     cat $ORIG >>$LOCAL
6918 dnl
6919 dnl     autoconf-257 $*
6920 dnl
6921 AC_DEFUN([CF_WITH_LIBTOOL],
6922 [
6923 AC_REQUIRE([CF_DISABLE_LIBTOOL_VERSION])
6924 ifdef([AC_PROG_LIBTOOL],,[
6925 LIBTOOL=
6926 ])
6927 # common library maintenance symbols that are convenient for libtool scripts:
6928 LIB_CREATE='${AR} -cr'
6929 LIB_OBJECT='${OBJECTS}'
6930 LIB_SUFFIX=.a
6931 LIB_PREP="$RANLIB"
6932
6933 # symbols used to prop libtool up to enable it to determine what it should be
6934 # doing:
6935 LIB_CLEAN=
6936 LIB_COMPILE=
6937 LIB_LINK='${CC}'
6938 LIB_INSTALL=
6939 LIB_UNINSTALL=
6940
6941 AC_MSG_CHECKING(if you want to build libraries with libtool)
6942 AC_ARG_WITH(libtool,
6943         [  --with-libtool          generate libraries with libtool],
6944         [with_libtool=$withval],
6945         [with_libtool=no])
6946 AC_MSG_RESULT($with_libtool)
6947 if test "$with_libtool" != "no"; then
6948 ifdef([AC_PROG_LIBTOOL],[
6949         # missing_content_AC_PROG_LIBTOOL{{
6950         AC_PROG_LIBTOOL
6951         # missing_content_AC_PROG_LIBTOOL}}
6952 ],[
6953         if test "$with_libtool" != "yes" ; then
6954                 CF_PATH_SYNTAX(with_libtool)
6955                 LIBTOOL=$with_libtool
6956         else
6957                 AC_CHECK_TOOLS(LIBTOOL,[libtool glibtool],none)
6958                 CF_LIBTOOL_VERSION
6959                 if test -z "$cf_cv_libtool_version" && test "$LIBTOOL" = libtool
6960                 then
6961                         CF_FORGET_TOOL(LIBTOOL)
6962                         AC_CHECK_TOOLS(LIBTOOL,[glibtool],none)
6963                         CF_LIBTOOL_VERSION
6964                 fi
6965         fi
6966         if test -z "$LIBTOOL" ; then
6967                 AC_MSG_ERROR(Cannot find libtool)
6968         fi
6969 ])dnl
6970         LIB_CREATE='${LIBTOOL} --mode=link ${CC} -rpath ${DESTDIR}${libdir} ${LIBTOOL_VERSION} `cut -f1 ${top_srcdir}/VERSION` ${LIBTOOL_OPTS} ${LT_UNDEF} $(LIBS) -o'
6971         LIB_OBJECT='${OBJECTS:.o=.lo}'
6972         LIB_SUFFIX=.la
6973         LIB_CLEAN='${LIBTOOL} --mode=clean'
6974         LIB_COMPILE='${LIBTOOL} --mode=compile'
6975         LIB_LINK='${LIBTOOL} --mode=link ${CC} ${LIBTOOL_OPTS}'
6976         LIB_INSTALL='${LIBTOOL} --mode=install'
6977         LIB_UNINSTALL='${LIBTOOL} --mode=uninstall'
6978         LIB_PREP=:
6979
6980         CF_CHECK_LIBTOOL_VERSION
6981
6982         # special hack to add -no-undefined (which libtool should do for itself)
6983         LT_UNDEF=
6984         case "$cf_cv_system_name" in #(vi
6985         cygwin*|msys*|mingw32*|uwin*|aix[[4-7]]) #(vi
6986                 LT_UNDEF=-no-undefined
6987                 ;;
6988         esac
6989         AC_SUBST([LT_UNDEF])
6990
6991         # special hack to add --tag option for C++ compiler
6992         case $cf_cv_libtool_version in #(vi
6993         1.[[5-9]]*|[[2-9]].[[0-9.a-z]]*) #(vi
6994                 LIBTOOL_CXX="$LIBTOOL --tag=CXX"
6995                 LIBTOOL="$LIBTOOL --tag=CC"
6996                 ;;
6997         *)
6998                 LIBTOOL_CXX="$LIBTOOL"
6999                 ;;
7000         esac
7001 else
7002         LIBTOOL=""
7003         LIBTOOL_CXX=""
7004 fi
7005
7006 test -z "$LIBTOOL" && ECHO_LT=
7007
7008 AC_SUBST(LIBTOOL)
7009 AC_SUBST(LIBTOOL_CXX)
7010 AC_SUBST(LIBTOOL_OPTS)
7011
7012 AC_SUBST(LIB_CREATE)
7013 AC_SUBST(LIB_OBJECT)
7014 AC_SUBST(LIB_SUFFIX)
7015 AC_SUBST(LIB_PREP)
7016
7017 AC_SUBST(LIB_CLEAN)
7018 AC_SUBST(LIB_COMPILE)
7019 AC_SUBST(LIB_LINK)
7020 AC_SUBST(LIB_INSTALL)
7021 AC_SUBST(LIB_UNINSTALL)
7022
7023 ])dnl
7024 dnl ---------------------------------------------------------------------------
7025 dnl CF_WITH_LIBTOOL_OPTS version: 3 updated: 2014/11/02 16:11:49
7026 dnl --------------------
7027 dnl Allow user to pass additional libtool options into the library creation
7028 dnl and link steps.  The main use for this is to do something like
7029 dnl     ./configure --with-libtool-opts=-static
7030 dnl to get the same behavior as automake-flavored
7031 dnl     ./configure --enable-static
7032 AC_DEFUN([CF_WITH_LIBTOOL_OPTS],[
7033 AC_MSG_CHECKING(for additional libtool options)
7034 AC_ARG_WITH(libtool-opts,
7035         [  --with-libtool-opts=XXX specify additional libtool options],
7036         [with_libtool_opts=$withval],
7037         [with_libtool_opts=no])
7038 AC_MSG_RESULT($with_libtool_opts)
7039
7040 case .$with_libtool_opts in
7041 .yes|.no|.)
7042         ;;
7043 *)
7044         LIBTOOL_OPTS="$LIBTOOL_OPTS $with_libtool_opts"
7045         ;;
7046 esac
7047
7048 AC_SUBST(LIBTOOL_OPTS)
7049 ])dnl
7050 dnl ---------------------------------------------------------------------------
7051 dnl CF_WITH_LIB_PREFIX version: 1 updated: 2012/01/21 19:28:10
7052 dnl ------------------
7053 dnl Allow the library-prefix to be overridden.  OS/2 EMX originally had no
7054 dnl "lib" prefix, e.g., because it used the dll naming convention.
7055 dnl
7056 dnl $1 = variable to set
7057 AC_DEFUN([CF_WITH_LIB_PREFIX],
7058 [
7059 AC_MSG_CHECKING(if you want to have a library-prefix)
7060 AC_ARG_WITH(lib-prefix,
7061         [  --with-lib-prefix       override library-prefix],
7062         [with_lib_prefix=$withval],
7063         [with_lib_prefix=auto])
7064 AC_MSG_RESULT($with_lib_prefix)
7065
7066 if test $with_lib_prefix = auto
7067 then
7068         CF_LIB_PREFIX($1)
7069 elif test $with_lib_prefix = no
7070 then
7071         LIB_PREFIX=
7072 else
7073         LIB_PREFIX=$with_lib_prefix
7074 fi
7075 ])dnl
7076 dnl ---------------------------------------------------------------------------
7077 dnl CF_WITH_PATH version: 11 updated: 2012/09/29 15:04:19
7078 dnl ------------
7079 dnl Wrapper for AC_ARG_WITH to ensure that user supplies a pathname, not just
7080 dnl defaulting to yes/no.
7081 dnl
7082 dnl $1 = option name
7083 dnl $2 = help-text
7084 dnl $3 = environment variable to set
7085 dnl $4 = default value, shown in the help-message, must be a constant
7086 dnl $5 = default value, if it's an expression & cannot be in the help-message
7087 dnl
7088 AC_DEFUN([CF_WITH_PATH],
7089 [AC_ARG_WITH($1,[$2 ](default: ifelse([$4],,empty,[$4])),,
7090 ifelse([$4],,[withval="${$3}"],[withval="${$3:-ifelse([$5],,[$4],[$5])}"]))dnl
7091 if ifelse([$5],,true,[test -n "$5"]) ; then
7092 CF_PATH_SYNTAX(withval)
7093 fi
7094 eval $3="$withval"
7095 AC_SUBST($3)dnl
7096 ])dnl
7097 dnl ---------------------------------------------------------------------------
7098 dnl CF_WITH_PATHLIST version: 9 updated: 2012/10/18 05:05:24
7099 dnl ----------------
7100 dnl Process an option specifying a list of colon-separated paths.
7101 dnl
7102 dnl $1 = option name
7103 dnl $2 = help-text
7104 dnl $3 = environment variable to set
7105 dnl $4 = default value, shown in the help-message, must be a constant
7106 dnl $5 = default value, if it's an expression & cannot be in the help-message
7107 dnl $6 = flag to tell if we want to define or substitute
7108 dnl
7109 AC_DEFUN([CF_WITH_PATHLIST],[
7110 AC_REQUIRE([CF_PATHSEP])
7111 AC_ARG_WITH($1,[$2 ](default: ifelse($4,,empty,$4)),,
7112 ifelse($4,,[withval=${$3}],[withval=${$3:-ifelse($5,,$4,$5)}]))dnl
7113
7114 IFS="${IFS:-    }"; ac_save_ifs="$IFS"; IFS="${PATH_SEPARATOR}"
7115 cf_dst_path=
7116 for cf_src_path in $withval
7117 do
7118   CF_PATH_SYNTAX(cf_src_path)
7119   test -n "$cf_dst_path" && cf_dst_path="${cf_dst_path}$PATH_SEPARATOR"
7120   cf_dst_path="${cf_dst_path}${cf_src_path}"
7121 done
7122 IFS="$ac_save_ifs"
7123
7124 ifelse($6,define,[
7125 # Strip single quotes from the value, e.g., when it was supplied as a literal
7126 # for $4 or $5.
7127 case $cf_dst_path in #(vi
7128 \'*)
7129   cf_dst_path=`echo $cf_dst_path |sed -e s/\'// -e s/\'\$//`
7130   ;;
7131 esac
7132 cf_dst_path=`echo "$cf_dst_path" | sed -e 's/\\\\/\\\\\\\\/g'`
7133 ])
7134
7135 # This may use the prefix/exec_prefix symbols which will only yield "NONE"
7136 # so we have to check/work around.  We do prefer the result of "eval"...
7137 eval cf_dst_eval="$cf_dst_path"
7138 case "x$cf_dst_eval" in #(vi
7139 xNONE*) #(vi
7140         $3=$cf_dst_path
7141         ;;
7142 *)
7143         $3="$cf_dst_eval"
7144         ;;
7145 esac
7146 AC_SUBST($3)dnl
7147
7148 ])dnl
7149 dnl ---------------------------------------------------------------------------
7150 dnl CF_WITH_PKG_CONFIG_LIBDIR version: 2 updated: 2011/12/10 18:58:47
7151 dnl -------------------------
7152 dnl Allow the choice of the pkg-config library directory to be overridden.
7153 AC_DEFUN([CF_WITH_PKG_CONFIG_LIBDIR],[
7154 if test "$PKG_CONFIG" != none ; then
7155         AC_MSG_CHECKING(for $PKG_CONFIG library directory)
7156         AC_ARG_WITH(pkg-config-libdir,
7157                 [  --with-pkg-config-libdir=XXX use given directory for installing pc-files],
7158                 [PKG_CONFIG_LIBDIR=$withval],
7159                 [PKG_CONFIG_LIBDIR=yes])
7160
7161         case x$PKG_CONFIG_LIBDIR in #(vi
7162         x/*) #(vi
7163                 ;;
7164         xyes) #(vi
7165                 # look for the library directory using the same prefix as the executable
7166                 cf_path=`echo "$PKG_CONFIG" | sed -e 's,/[[^/]]*/[[^/]]*$,,'`
7167                 case x`(arch) 2>/dev/null` in #(vi
7168                 *64) #(vi
7169                         for cf_config in $cf_path/share $cf_path/lib64 $cf_path/lib32 $cf_path/lib
7170                         do
7171                                 if test -d $cf_config/pkgconfig
7172                                 then
7173                                         PKG_CONFIG_LIBDIR=$cf_config/pkgconfig
7174                                         break
7175                                 fi
7176                         done
7177                         ;;
7178                 *)
7179                         PKG_CONFIG_LIBDIR=$cf_path/lib/pkgconfig
7180                         ;;
7181                 esac
7182                 ;;
7183         *)
7184                 ;;
7185         esac
7186
7187         AC_MSG_RESULT($PKG_CONFIG_LIBDIR)
7188 fi
7189
7190 AC_SUBST(PKG_CONFIG_LIBDIR)
7191 ])dnl
7192 dnl ---------------------------------------------------------------------------
7193 dnl CF_WITH_PTHREAD version: 6 updated: 2012/10/06 17:41:51
7194 dnl ---------------
7195 dnl Check for POSIX thread library.
7196 AC_DEFUN([CF_WITH_PTHREAD],
7197 [
7198 AC_MSG_CHECKING(if you want to link with the pthread library)
7199 AC_ARG_WITH(pthread,
7200     [  --with-pthread          use POSIX thread library],
7201     [with_pthread=$withval],
7202     [with_pthread=no])
7203 AC_MSG_RESULT($with_pthread)
7204
7205 if test "$with_pthread" != no ; then
7206     AC_CHECK_HEADER(pthread.h,[
7207         AC_DEFINE(HAVE_PTHREADS_H,1,[Define to 1 if we have pthreads.h header])
7208
7209         for cf_lib_pthread in pthread c_r
7210         do
7211             AC_MSG_CHECKING(if we can link with the $cf_lib_pthread library)
7212             cf_save_LIBS="$LIBS"
7213             CF_ADD_LIB($cf_lib_pthread)
7214             AC_TRY_LINK([
7215 #include <pthread.h>
7216 ],[
7217                 int rc = pthread_create(0,0,0,0);
7218                 int r2 = pthread_mutexattr_settype(0, 0);
7219 ],[with_pthread=yes],[with_pthread=no])
7220             LIBS="$cf_save_LIBS"
7221             AC_MSG_RESULT($with_pthread)
7222             test "$with_pthread" = yes && break
7223         done
7224
7225         if test "$with_pthread" = yes ; then
7226             CF_ADD_LIB($cf_lib_pthread)
7227             AC_DEFINE(HAVE_LIBPTHREADS,1,[Define to 1 if we have pthreads library])
7228         else
7229             AC_MSG_ERROR(Cannot link with pthread library)
7230         fi
7231     ])
7232 fi
7233 ])
7234 dnl ---------------------------------------------------------------------------
7235 dnl CF_WITH_REL_VERSION version: 1 updated: 2003/09/20 18:12:49
7236 dnl -------------------
7237 dnl Allow library's release-version to be overridden.  Generally this happens when a
7238 dnl packager has incremented the release-version past that used in the original package,
7239 dnl and wishes to keep doing this.
7240 dnl
7241 dnl $1 is the package name, if any, to derive corresponding {package}_MAJOR
7242 dnl and {package}_MINOR symbols
7243 dnl symbol.
7244 AC_DEFUN([CF_WITH_REL_VERSION],[
7245 test -z "$cf_cv_rel_version" && cf_cv_rel_version=0.0
7246 AC_ARG_WITH(rel-version,
7247 [  --with-rel-version=XXX  override derived release version],
7248 [AC_MSG_WARN(overriding release version $cf_cv_rel_version to $withval)
7249  cf_cv_rel_version=$withval])
7250 ifelse($1,,[
7251  CF_NUMBER_SYNTAX($cf_cv_rel_version,Release version)
7252 ],[
7253  $1_MAJOR=`echo "$cf_cv_rel_version" | sed -e 's/\..*//'`
7254  $1_MINOR=`echo "$cf_cv_rel_version" | sed -e 's/^[[^.]]*//' -e 's/^\.//' -e 's/\..*//'`
7255  CF_NUMBER_SYNTAX([$]$1_MAJOR,Release major-version)
7256  CF_NUMBER_SYNTAX([$]$1_MINOR,Release minor-version)
7257 ])
7258 ])dnl
7259 dnl ---------------------------------------------------------------------------
7260 dnl CF_WITH_SYSMOUSE version: 3 updated: 2012/10/06 17:56:13
7261 dnl ----------------
7262 dnl If we can compile with sysmouse, make it available unless it is not wanted.
7263 AC_DEFUN([CF_WITH_SYSMOUSE],[
7264 # not everyone has "test -c"
7265 if test -c /dev/sysmouse 2>/dev/null ; then
7266 AC_MSG_CHECKING(if you want to use sysmouse)
7267 AC_ARG_WITH(sysmouse,
7268         [  --with-sysmouse         use sysmouse (FreeBSD console)],
7269         [cf_with_sysmouse=$withval],
7270         [cf_with_sysmouse=maybe])
7271         if test "$cf_with_sysmouse" != no ; then
7272         AC_TRY_COMPILE([
7273 #include <osreldate.h>
7274 #if (__FreeBSD_version >= 400017)
7275 #include <sys/consio.h>
7276 #include <sys/fbio.h>
7277 #else
7278 #include <machine/console.h>
7279 #endif
7280 ],[
7281         struct mouse_info the_mouse;
7282         ioctl(0, CONS_MOUSECTL, &the_mouse);
7283 ],[cf_with_sysmouse=yes],[cf_with_sysmouse=no])
7284         fi
7285 AC_MSG_RESULT($cf_with_sysmouse)
7286 test "$cf_with_sysmouse" = yes && AC_DEFINE(USE_SYSMOUSE,1,[Define to 1 if we can/should use the sysmouse interface])
7287 fi
7288 ])dnl
7289 dnl ---------------------------------------------------------------------------
7290 dnl CF_WITH_SYSTYPE version: 1 updated: 2013/01/26 16:26:12
7291 dnl ---------------
7292 dnl For testing, override the derived host system-type which is used to decide
7293 dnl things such as the linker commands used to build shared libraries.  This is
7294 dnl normally chosen automatically based on the type of system which you are
7295 dnl building on.  We use it for testing the configure script.
7296 dnl
7297 dnl This is different from the --host option: it is used only for testing parts
7298 dnl of the configure script which would not be reachable with --host since that
7299 dnl relies on the build environment being real, rather than mocked up.
7300 AC_DEFUN([CF_WITH_SYSTYPE],[
7301 CF_CHECK_CACHE([AC_CANONICAL_SYSTEM])
7302 AC_ARG_WITH(system-type,
7303         [  --with-system-type=XXX  test: override derived host system-type],
7304 [AC_MSG_WARN(overriding system type to $withval)
7305         cf_cv_system_name=$withval
7306         host_os=$withval
7307 ])
7308 ])dnl
7309 dnl ---------------------------------------------------------------------------
7310 dnl CF_WITH_VALGRIND version: 1 updated: 2006/12/14 18:00:21
7311 dnl ----------------
7312 AC_DEFUN([CF_WITH_VALGRIND],[
7313 CF_NO_LEAKS_OPTION(valgrind,
7314         [  --with-valgrind         test: use valgrind],
7315         [USE_VALGRIND])
7316 ])dnl
7317 dnl ---------------------------------------------------------------------------
7318 dnl CF_WITH_VERSIONED_SYMS version: 2 updated: 2014/11/15 19:05:29
7319 dnl ----------------------
7320 dnl Use this when building shared library with ELF, to markup symbols with the
7321 dnl version identifier from the given input file.  Generally that identifier is
7322 dnl the same as the SONAME at which the symbol was first introduced.
7323 dnl
7324 dnl $1 = basename of the ".sym" file (default $PACKAGE)
7325 AC_DEFUN([CF_WITH_VERSIONED_SYMS],
7326 [
7327 AC_MSG_CHECKING(if versioned-symbols file should be used)
7328 AC_ARG_WITH(versioned-syms,
7329         [  --with-versioned-syms=X markup versioned symbols using ld],
7330         [with_versioned_syms=$withval],
7331         [with_versioned_syms=no])
7332 if test "x$with_versioned_syms" = xyes
7333 then
7334         with_versioned_syms='${top_srcdir}/package/ifelse($1,,${PACKAGE},[$1]).map'
7335         AC_SUBST(PACKAGE)
7336 fi
7337 AC_MSG_RESULT($with_versioned_syms)
7338
7339 if test "x$with_versioned_syms" != xno
7340 then
7341         AC_SUBST(VERSIONED_SYMS)
7342         case "x$MK_SHARED_LIB" in
7343         *-Wl,*) #(vi
7344                 VERSIONED_SYMS="-Wl,--version-script,$with_versioned_syms"
7345                 MK_SHARED_LIB=`echo "$MK_SHARED_LIB" | sed -e "s%-Wl,%\\[$]{VERSIONED_SYMS} -Wl,%"`
7346                 CF_VERBOSE(MK_SHARED_LIB:  $MK_SHARED_LIB)
7347                 ;;
7348         *-dy*) #(vi
7349                 VERSIONED_SYMS="-Wl,-M,$with_versioned_syms"
7350                 MK_SHARED_LIB=`echo "$MK_SHARED_LIB" | sed -e "s%-dy%\\[$]{VERSIONED_SYMS} -dy%"`
7351                 CF_VERBOSE(MK_SHARED_LIB:  $MK_SHARED_LIB)
7352                 ;;
7353         *)
7354                 AC_MSG_WARN(this system does not support versioned-symbols)
7355                 ;;
7356         esac
7357 fi
7358 ])dnl
7359 dnl ---------------------------------------------------------------------------
7360 dnl CF_XOPEN_SOURCE version: 48 updated: 2014/09/01 12:29:14
7361 dnl ---------------
7362 dnl Try to get _XOPEN_SOURCE defined properly that we can use POSIX functions,
7363 dnl or adapt to the vendor's definitions to get equivalent functionality,
7364 dnl without losing the common non-POSIX features.
7365 dnl
7366 dnl Parameters:
7367 dnl     $1 is the nominal value for _XOPEN_SOURCE
7368 dnl     $2 is the nominal value for _POSIX_C_SOURCE
7369 AC_DEFUN([CF_XOPEN_SOURCE],[
7370 AC_REQUIRE([AC_CANONICAL_HOST])
7371
7372 cf_XOPEN_SOURCE=ifelse([$1],,500,[$1])
7373 cf_POSIX_C_SOURCE=ifelse([$2],,199506L,[$2])
7374 cf_xopen_source=
7375
7376 case $host_os in #(vi
7377 aix[[4-7]]*) #(vi
7378         cf_xopen_source="-D_ALL_SOURCE"
7379         ;;
7380 cygwin|msys) #(vi
7381         cf_XOPEN_SOURCE=600
7382         ;;
7383 darwin[[0-8]].*) #(vi
7384         cf_xopen_source="-D_APPLE_C_SOURCE"
7385         ;;
7386 darwin*) #(vi
7387         cf_xopen_source="-D_DARWIN_C_SOURCE"
7388         cf_XOPEN_SOURCE=
7389         ;;
7390 freebsd*|dragonfly*) #(vi
7391         # 5.x headers associate
7392         #       _XOPEN_SOURCE=600 with _POSIX_C_SOURCE=200112L
7393         #       _XOPEN_SOURCE=500 with _POSIX_C_SOURCE=199506L
7394         cf_POSIX_C_SOURCE=200112L
7395         cf_XOPEN_SOURCE=600
7396         cf_xopen_source="-D_BSD_TYPES -D__BSD_VISIBLE -D_POSIX_C_SOURCE=$cf_POSIX_C_SOURCE -D_XOPEN_SOURCE=$cf_XOPEN_SOURCE"
7397         ;;
7398 hpux11*) #(vi
7399         cf_xopen_source="-D_HPUX_SOURCE -D_XOPEN_SOURCE=500"
7400         ;;
7401 hpux*) #(vi
7402         cf_xopen_source="-D_HPUX_SOURCE"
7403         ;;
7404 irix[[56]].*) #(vi
7405         cf_xopen_source="-D_SGI_SOURCE"
7406         cf_XOPEN_SOURCE=
7407         ;;
7408 linux*|gnu*|mint*|k*bsd*-gnu) #(vi
7409         CF_GNU_SOURCE
7410         ;;
7411 minix*) #(vi
7412         cf_xopen_source="-D_NETBSD_SOURCE" # POSIX.1-2001 features are ifdef'd with this...
7413         ;;
7414 mirbsd*) #(vi
7415         # setting _XOPEN_SOURCE or _POSIX_SOURCE breaks <sys/select.h> and other headers which use u_int / u_short types
7416         cf_XOPEN_SOURCE=
7417         CF_POSIX_C_SOURCE($cf_POSIX_C_SOURCE)
7418         ;;
7419 netbsd*) #(vi
7420         cf_xopen_source="-D_NETBSD_SOURCE" # setting _XOPEN_SOURCE breaks IPv6 for lynx on NetBSD 1.6, breaks xterm, is not needed for ncursesw
7421         ;;
7422 openbsd[[4-9]]*) #(vi
7423         # setting _XOPEN_SOURCE lower than 500 breaks g++ compile with wchar.h, needed for ncursesw
7424         cf_xopen_source="-D_BSD_SOURCE"
7425         cf_XOPEN_SOURCE=600
7426         ;;
7427 openbsd*) #(vi
7428         # setting _XOPEN_SOURCE breaks xterm on OpenBSD 2.8, is not needed for ncursesw
7429         ;;
7430 osf[[45]]*) #(vi
7431         cf_xopen_source="-D_OSF_SOURCE"
7432         ;;
7433 nto-qnx*) #(vi
7434         cf_xopen_source="-D_QNX_SOURCE"
7435         ;;
7436 sco*) #(vi
7437         # setting _XOPEN_SOURCE breaks Lynx on SCO Unix / OpenServer
7438         ;;
7439 solaris2.*) #(vi
7440         cf_xopen_source="-D__EXTENSIONS__"
7441         cf_cv_xopen_source=broken
7442         ;;
7443 sysv4.2uw2.*) # Novell/SCO UnixWare 2.x (tested on 2.1.2)
7444         cf_XOPEN_SOURCE=
7445         cf_POSIX_C_SOURCE=
7446         ;;
7447 *)
7448         CF_TRY_XOPEN_SOURCE
7449         CF_POSIX_C_SOURCE($cf_POSIX_C_SOURCE)
7450         ;;
7451 esac
7452
7453 if test -n "$cf_xopen_source" ; then
7454         CF_ADD_CFLAGS($cf_xopen_source,true)
7455 fi
7456
7457 dnl In anything but the default case, we may have system-specific setting
7458 dnl which is still not guaranteed to provide all of the entrypoints that
7459 dnl _XOPEN_SOURCE would yield.
7460 if test -n "$cf_XOPEN_SOURCE" && test -z "$cf_cv_xopen_source" ; then
7461         AC_MSG_CHECKING(if _XOPEN_SOURCE really is set)
7462         AC_TRY_COMPILE([#include <stdlib.h>],[
7463 #ifndef _XOPEN_SOURCE
7464 make an error
7465 #endif],
7466         [cf_XOPEN_SOURCE_set=yes],
7467         [cf_XOPEN_SOURCE_set=no])
7468         AC_MSG_RESULT($cf_XOPEN_SOURCE_set)
7469         if test $cf_XOPEN_SOURCE_set = yes
7470         then
7471                 AC_TRY_COMPILE([#include <stdlib.h>],[
7472 #if (_XOPEN_SOURCE - 0) < $cf_XOPEN_SOURCE
7473 make an error
7474 #endif],
7475                 [cf_XOPEN_SOURCE_set_ok=yes],
7476                 [cf_XOPEN_SOURCE_set_ok=no])
7477                 if test $cf_XOPEN_SOURCE_set_ok = no
7478                 then
7479                         AC_MSG_WARN(_XOPEN_SOURCE is lower than requested)
7480                 fi
7481         else
7482                 CF_TRY_XOPEN_SOURCE
7483         fi
7484 fi
7485 ])