aclocal.m4

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