aclocal.m4

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