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.483 2009/02/07 19:12:17 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: 11 updated: 2007/07/29 09:55:12
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         for cf_attribute in scanf printf unused noreturn
1447         do
1448                 CF_UPPER(cf_ATTRIBUTE,$cf_attribute)
1449                 cf_directive="__attribute__(($cf_attribute))"
1450                 echo "checking for $CC $cf_directive" 1>&AC_FD_CC
1451                 case $cf_attribute in
1452                 scanf|printf)
1453                 cat >conftest.h <<EOF
1454 #define GCC_$cf_ATTRIBUTE 1
1455 EOF
1456                         ;;
1457                 *)
1458                 cat >conftest.h <<EOF
1459 #define GCC_$cf_ATTRIBUTE $cf_directive
1460 EOF
1461                         ;;
1462                 esac
1463                 if AC_TRY_EVAL(ac_compile); then
1464                         test -n "$verbose" && AC_MSG_RESULT(... $cf_attribute)
1465                         cat conftest.h >>confdefs.h
1466                 fi
1467         done
1468 else
1469         fgrep define conftest.i >>confdefs.h
1470 fi
1471 rm -rf conftest*
1472 fi
1473 ])dnl
1474 dnl ---------------------------------------------------------------------------
1475 dnl CF_GCC_VERSION version: 4 updated: 2005/08/27 09:53:42
1476 dnl --------------
1477 dnl Find version of gcc
1478 AC_DEFUN([CF_GCC_VERSION],[
1479 AC_REQUIRE([AC_PROG_CC])
1480 GCC_VERSION=none
1481 if test "$GCC" = yes ; then
1482         AC_MSG_CHECKING(version of $CC)
1483         GCC_VERSION="`${CC} --version| sed -e '2,$d' -e 's/^.*(GCC) //' -e 's/^[[^0-9.]]*//' -e 's/[[^0-9.]].*//'`"
1484         test -z "$GCC_VERSION" && GCC_VERSION=unknown
1485         AC_MSG_RESULT($GCC_VERSION)
1486 fi
1487 ])dnl
1488 dnl ---------------------------------------------------------------------------
1489 dnl CF_GCC_WARNINGS version: 23 updated: 2008/07/26 17:54:02
1490 dnl ---------------
1491 dnl Check if the compiler supports useful warning options.  There's a few that
1492 dnl we don't use, simply because they're too noisy:
1493 dnl
1494 dnl     -Wconversion (useful in older versions of gcc, but not in gcc 2.7.x)
1495 dnl     -Wredundant-decls (system headers make this too noisy)
1496 dnl     -Wtraditional (combines too many unrelated messages, only a few useful)
1497 dnl     -Wwrite-strings (too noisy, but should review occasionally).  This
1498 dnl             is enabled for ncurses using "--enable-const".
1499 dnl     -pedantic
1500 dnl
1501 dnl Parameter:
1502 dnl     $1 is an optional list of gcc warning flags that a particular
1503 dnl             application might want to use, e.g., "no-unused" for
1504 dnl             -Wno-unused
1505 dnl Special:
1506 dnl     If $with_ext_const is "yes", add a check for -Wwrite-strings
1507 dnl
1508 AC_DEFUN([CF_GCC_WARNINGS],
1509 [
1510 AC_REQUIRE([CF_GCC_VERSION])
1511 CF_INTEL_COMPILER(GCC,INTEL_COMPILER,CFLAGS)
1512
1513 cat > conftest.$ac_ext <<EOF
1514 #line __oline__ "${as_me-configure}"
1515 int main(int argc, char *argv[[]]) { return (argv[[argc-1]] == 0) ; }
1516 EOF
1517
1518 if test "$INTEL_COMPILER" = yes
1519 then
1520 # The "-wdXXX" options suppress warnings:
1521 # remark #1419: external declaration in primary source file
1522 # remark #1682: implicit conversion of a 64-bit integral type to a smaller integral type (potential portability problem)
1523 # remark #1683: explicit conversion of a 64-bit integral type to a smaller integral type (potential portability problem)
1524 # remark #1684: conversion from pointer to same-sized integral type (potential portability problem)
1525 # remark #193: zero used for undefined preprocessing identifier
1526 # remark #593: variable "curs_sb_left_arrow" was set but never used
1527 # remark #810: conversion from "int" to "Dimension={unsigned short}" may lose significant bits
1528 # remark #869: parameter "tw" was never referenced
1529 # remark #981: operands are evaluated in unspecified order
1530 # warning #269: invalid format string conversion
1531
1532         AC_CHECKING([for $CC warning options])
1533         cf_save_CFLAGS="$CFLAGS"
1534         EXTRA_CFLAGS="-Wall"
1535         for cf_opt in \
1536                 wd1419 \
1537                 wd1682 \
1538                 wd1683 \
1539                 wd1684 \
1540                 wd193 \
1541                 wd279 \
1542                 wd593 \
1543                 wd810 \
1544                 wd869 \
1545                 wd981
1546         do
1547                 CFLAGS="$cf_save_CFLAGS $EXTRA_CFLAGS -$cf_opt"
1548                 if AC_TRY_EVAL(ac_compile); then
1549                         test -n "$verbose" && AC_MSG_RESULT(... -$cf_opt)
1550                         EXTRA_CFLAGS="$EXTRA_CFLAGS -$cf_opt"
1551                 fi
1552         done
1553         CFLAGS="$cf_save_CFLAGS"
1554
1555 elif test "$GCC" = yes
1556 then
1557         AC_CHECKING([for $CC warning options])
1558         cf_save_CFLAGS="$CFLAGS"
1559         EXTRA_CFLAGS="-W -Wall"
1560         cf_warn_CONST=""
1561         test "$with_ext_const" = yes && cf_warn_CONST="Wwrite-strings"
1562         for cf_opt in \
1563                 Wbad-function-cast \
1564                 Wcast-align \
1565                 Wcast-qual \
1566                 Winline \
1567                 Wmissing-declarations \
1568                 Wmissing-prototypes \
1569                 Wnested-externs \
1570                 Wpointer-arith \
1571                 Wshadow \
1572                 Wstrict-prototypes \
1573                 Wundef $cf_warn_CONST $1
1574         do
1575                 CFLAGS="$cf_save_CFLAGS $EXTRA_CFLAGS -$cf_opt"
1576                 if AC_TRY_EVAL(ac_compile); then
1577                         test -n "$verbose" && AC_MSG_RESULT(... -$cf_opt)
1578                         case $cf_opt in #(vi
1579                         Wcast-qual) #(vi
1580                                 CPPFLAGS="$CPPFLAGS -DXTSTRINGDEFINES"
1581                                 ;;
1582                         Winline) #(vi
1583                                 case $GCC_VERSION in
1584                                 [[34]].*)
1585                                         CF_VERBOSE(feature is broken in gcc $GCC_VERSION)
1586                                         continue;;
1587                                 esac
1588                                 ;;
1589                         esac
1590                         EXTRA_CFLAGS="$EXTRA_CFLAGS -$cf_opt"
1591                 fi
1592         done
1593         CFLAGS="$cf_save_CFLAGS"
1594 fi
1595 rm -f conftest*
1596
1597 AC_SUBST(EXTRA_CFLAGS)
1598 ])dnl
1599 dnl ---------------------------------------------------------------------------
1600 dnl CF_GNAT_TRY_LINK version: 1 updated: 2004/08/21 19:02:08
1601 dnl ----------------
1602 dnl Verify that a test program compiles/links with GNAT.
1603 dnl $cf_ada_make is set to the program that compiles/links
1604 dnl $ADAFLAGS may be set to the GNAT flags.
1605 dnl
1606 dnl $1 is the text of the spec
1607 dnl $2 is the text of the body
1608 dnl $3 is the shell command to execute if successful
1609 dnl $4 is the shell command to execute if not successful
1610 AC_DEFUN([CF_GNAT_TRY_LINK],
1611 [
1612 rm -f conftest*
1613 cat >>conftest.ads <<CF_EOF
1614 $1
1615 CF_EOF
1616 cat >>conftest.adb <<CF_EOF
1617 $2
1618 CF_EOF
1619 if ( $cf_ada_make $ADAFLAGS conftest 1>&AC_FD_CC 2>&1 ) ; then
1620 ifelse($3,,      :,[      $3])
1621 ifelse($4,,,[else
1622    $4])
1623 fi
1624 rm -f conftest*
1625 ])dnl
1626 dnl ---------------------------------------------------------------------------
1627 dnl CF_GNAT_TRY_RUN version: 3 updated: 2004/08/21 19:02:08
1628 dnl ---------------
1629 dnl Verify that a test program compiles and runs with GNAT
1630 dnl $cf_ada_make is set to the program that compiles/links
1631 dnl $ADAFLAGS may be set to the GNAT flags.
1632 dnl
1633 dnl $1 is the text of the spec
1634 dnl $2 is the text of the body
1635 dnl $3 is the shell command to execute if successful
1636 dnl $4 is the shell command to execute if not successful
1637 AC_DEFUN([CF_GNAT_TRY_RUN],
1638 [
1639 rm -f conftest*
1640 cat >>conftest.ads <<CF_EOF
1641 $1
1642 CF_EOF
1643 cat >>conftest.adb <<CF_EOF
1644 $2
1645 CF_EOF
1646 if ( $cf_ada_make $ADAFLAGS conftest 1>&AC_FD_CC 2>&1 ) ; then
1647    if ( ./conftest 1>&AC_FD_CC 2>&1 ) ; then
1648 ifelse($3,,      :,[      $3])
1649 ifelse($4,,,[   else
1650       $4])
1651    fi
1652 ifelse($4,,,[else
1653    $4])
1654 fi
1655 rm -f conftest*
1656 ])dnl
1657 dnl ---------------------------------------------------------------------------
1658 dnl CF_GNAT_VERSION version: 12 updated: 2006/10/14 15:23:15
1659 dnl ---------------
1660 dnl Verify version of GNAT.
1661 AC_DEFUN([CF_GNAT_VERSION],
1662 [
1663 AC_MSG_CHECKING(for gnat version)
1664 cf_gnat_version=`${cf_ada_make-gnatmake} -v 2>&1 | grep '[[0-9]].[[0-9]][[0-9]]*' |\
1665   sed -e '2,$d' -e 's/[[^0-9 \.]]//g' -e 's/^[[ ]]*//' -e 's/ .*//'`
1666 AC_MSG_RESULT($cf_gnat_version)
1667
1668 case $cf_gnat_version in
1669   3.1[[1-9]]*|3.[[2-9]]*|[[4-9]].*)
1670     cf_cv_prog_gnat_correct=yes
1671     ;;
1672   *) echo Unsupported GNAT version $cf_gnat_version. Required is 3.11 or better. Disabling Ada95 binding.
1673      cf_cv_prog_gnat_correct=no
1674      ;;
1675 esac
1676 case $cf_gnat_version in
1677   3.[[1-9]]*|[[4-9]].*)
1678       cf_compile_generics=generics
1679       cf_generic_objects="\${GENOBJS}"
1680       ;;
1681   *)  cf_compile_generics=
1682       cf_generic_objects=
1683       ;;
1684 esac
1685 ])
1686 dnl ---------------------------------------------------------------------------
1687 dnl CF_GNU_SOURCE version: 6 updated: 2005/07/09 13:23:07
1688 dnl -------------
1689 dnl Check if we must define _GNU_SOURCE to get a reasonable value for
1690 dnl _XOPEN_SOURCE, upon which many POSIX definitions depend.  This is a defect
1691 dnl (or misfeature) of glibc2, which breaks portability of many applications,
1692 dnl since it is interwoven with GNU extensions.
1693 dnl
1694 dnl Well, yes we could work around it...
1695 AC_DEFUN([CF_GNU_SOURCE],
1696 [
1697 AC_CACHE_CHECK(if we must define _GNU_SOURCE,cf_cv_gnu_source,[
1698 AC_TRY_COMPILE([#include <sys/types.h>],[
1699 #ifndef _XOPEN_SOURCE
1700 make an error
1701 #endif],
1702         [cf_cv_gnu_source=no],
1703         [cf_save="$CPPFLAGS"
1704          CPPFLAGS="$CPPFLAGS -D_GNU_SOURCE"
1705          AC_TRY_COMPILE([#include <sys/types.h>],[
1706 #ifdef _XOPEN_SOURCE
1707 make an error
1708 #endif],
1709         [cf_cv_gnu_source=no],
1710         [cf_cv_gnu_source=yes])
1711         CPPFLAGS="$cf_save"
1712         ])
1713 ])
1714 test "$cf_cv_gnu_source" = yes && CPPFLAGS="$CPPFLAGS -D_GNU_SOURCE"
1715 ])dnl
1716 dnl ---------------------------------------------------------------------------
1717 dnl CF_GPP_LIBRARY version: 8 updated: 2003/02/02 01:41:46
1718 dnl --------------
1719 dnl If we're trying to use g++, test if libg++ is installed (a rather common
1720 dnl problem :-).  If we have the compiler but no library, we'll be able to
1721 dnl configure, but won't be able to build the c++ demo program.
1722 AC_DEFUN([CF_GPP_LIBRARY],
1723 [
1724 cf_cxx_library=unknown
1725 case $cf_cv_system_name in #(vi
1726 os2*) #(vi
1727         cf_gpp_libname=gpp
1728         ;;
1729 *)
1730         cf_gpp_libname=g++
1731         ;;
1732 esac
1733 if test "$GXX" = yes; then
1734         AC_MSG_CHECKING([for lib$cf_gpp_libname])
1735         cf_save="$LIBS"
1736         LIBS="$LIBS -l$cf_gpp_libname"
1737         AC_TRY_LINK([
1738 #include <$cf_gpp_libname/builtin.h>
1739         ],
1740         [two_arg_error_handler_t foo2 = lib_error_handler],
1741         [cf_cxx_library=yes
1742          CXXLIBS="$CXXLIBS -l$cf_gpp_libname"
1743          if test "$cf_gpp_libname" = cpp ; then
1744             AC_DEFINE(HAVE_GPP_BUILTIN_H)
1745          else
1746             AC_DEFINE(HAVE_GXX_BUILTIN_H)
1747          fi],
1748         [AC_TRY_LINK([
1749 #include <builtin.h>
1750         ],
1751         [two_arg_error_handler_t foo2 = lib_error_handler],
1752         [cf_cxx_library=yes
1753          CXXLIBS="$CXXLIBS -l$cf_gpp_libname"
1754          AC_DEFINE(HAVE_BUILTIN_H)],
1755         [cf_cxx_library=no])])
1756         LIBS="$cf_save"
1757         AC_MSG_RESULT($cf_cxx_library)
1758 fi
1759 ])dnl
1760 dnl ---------------------------------------------------------------------------
1761 dnl CF_GXX_VERSION version: 5 updated: 2005/08/27 09:53:42
1762 dnl --------------
1763 dnl Check for version of g++
1764 AC_DEFUN([CF_GXX_VERSION],[
1765 AC_REQUIRE([AC_PROG_CPP])
1766 GXX_VERSION=none
1767 if test "$GXX" = yes; then
1768         AC_MSG_CHECKING(version of g++)
1769         GXX_VERSION="`${CXX-g++} --version| sed -e '2,$d' -e 's/^.*(GCC) //' -e 's/^[[^0-9.]]*//' -e 's/[[^0-9.]].*//'`"
1770         test -z "$GXX_VERSION" && GXX_VERSION=unknown
1771         AC_MSG_RESULT($GXX_VERSION)
1772 fi
1773 ])dnl
1774 dnl ---------------------------------------------------------------------------
1775 dnl CF_GXX_WARNINGS version: 5 updated: 2005/08/13 14:54:38
1776 dnl ---------------
1777 dnl Check if the compiler supports useful warning options.
1778 dnl
1779 dnl Most of gcc's options apply to g++, except:
1780 dnl     -Wbad-function-cast
1781 dnl     -Wmissing-declarations
1782 dnl     -Wnested-externs
1783 dnl
1784 dnl Omit a few (for now):
1785 dnl     -Winline
1786 dnl
1787 dnl Parameter:
1788 dnl     $1 is an optional list of g++ warning flags that a particular
1789 dnl             application might want to use, e.g., "no-unused" for
1790 dnl             -Wno-unused
1791 dnl Special:
1792 dnl     If $with_ext_const is "yes", add a check for -Wwrite-strings
1793 dnl
1794 AC_DEFUN([CF_GXX_WARNINGS],
1795 [
1796
1797 CF_INTEL_COMPILER(GXX,INTEL_CPLUSPLUS,CXXFLAGS)
1798
1799 AC_REQUIRE([CF_GXX_VERSION])
1800
1801 AC_LANG_SAVE
1802 AC_LANG_CPLUSPLUS
1803
1804 cat > conftest.$ac_ext <<EOF
1805 #line __oline__ "configure"
1806 int main(int argc, char *argv[[]]) { return (argv[[argc-1]] == 0) ; }
1807 EOF
1808
1809 if test "$INTEL_CPLUSPLUS" = yes
1810 then
1811 # The "-wdXXX" options suppress warnings:
1812 # remark #1419: external declaration in primary source file
1813 # remark #1682: implicit conversion of a 64-bit integral type to a smaller integral type (potential portability problem)
1814 # remark #1683: explicit conversion of a 64-bit integral type to a smaller integral type (potential portability problem)
1815 # remark #1684: conversion from pointer to same-sized integral type (potential portability problem)
1816 # remark #193: zero used for undefined preprocessing identifier
1817 # remark #593: variable "curs_sb_left_arrow" was set but never used
1818 # remark #810: conversion from "int" to "Dimension={unsigned short}" may lose significant bits
1819 # remark #869: parameter "tw" was never referenced
1820 # remark #981: operands are evaluated in unspecified order
1821 # warning #269: invalid format string conversion
1822
1823         AC_CHECKING([for $CC warning options])
1824         cf_save_CXXFLAGS="$CXXFLAGS"
1825         EXTRA_CXXFLAGS="-Wall"
1826         for cf_opt in \
1827                 wd1419 \
1828                 wd1682 \
1829                 wd1683 \
1830                 wd1684 \
1831                 wd193 \
1832                 wd279 \
1833                 wd593 \
1834                 wd810 \
1835                 wd869 \
1836                 wd981
1837         do
1838                 CXXFLAGS="$cf_save_CXXFLAGS $EXTRA_CXXFLAGS -$cf_opt"
1839                 if AC_TRY_EVAL(ac_compile); then
1840                         test -n "$verbose" && AC_MSG_RESULT(... -$cf_opt)
1841                         EXTRA_CXXFLAGS="$EXTRA_CXXFLAGS -$cf_opt"
1842                 fi
1843         done
1844         CXXFLAGS="$cf_save_CXXFLAGS"
1845
1846 elif test "$GXX" = yes
1847 then
1848         AC_CHECKING([for $CXX warning options])
1849         cf_save_CXXFLAGS="$CXXFLAGS"
1850         EXTRA_CXXFLAGS="-W -Wall"
1851         cf_gxx_extra_warnings=""
1852         test "$with_ext_const" = yes && cf_gxx_extra_warnings="Wwrite-strings"
1853         case "$GCC_VERSION" in
1854         [[1-2]].*)
1855                 ;;
1856         *)
1857                 cf_gxx_extra_warnings="$cf_gxx_extra_warnings Weffc++"
1858                 ;;
1859         esac
1860         for cf_opt in \
1861                 Wabi \
1862                 fabi-version=0 \
1863                 Woverloaded-virtual \
1864                 Wsign-promo \
1865                 Wsynth \
1866                 Wold-style-cast \
1867                 Wcast-align \
1868                 Wcast-qual \
1869                 Wmissing-prototypes \
1870                 Wpointer-arith \
1871                 Wshadow \
1872                 Wstrict-prototypes \
1873                 Wundef $cf_gxx_extra_warnings $1
1874         do
1875                 CXXFLAGS="$cf_save_CXXFLAGS $EXTRA_CXXFLAGS -Werror -$cf_opt"
1876                 if AC_TRY_EVAL(ac_compile); then
1877                         test -n "$verbose" && AC_MSG_RESULT(... -$cf_opt)
1878                         EXTRA_CXXFLAGS="$EXTRA_CXXFLAGS -$cf_opt"
1879                 else
1880                         test -n "$verbose" && AC_MSG_RESULT(... no -$cf_opt)
1881                 fi
1882         done
1883         CXXFLAGS="$cf_save_CXXFLAGS"
1884 fi
1885
1886 rm -f conftest*
1887 AC_LANG_RESTORE
1888 AC_SUBST(EXTRA_CXXFLAGS)
1889 ])dnl
1890 dnl ---------------------------------------------------------------------------
1891 dnl CF_HASHED_DB version: 3 updated: 2007/11/24 17:43:37
1892 dnl ------------
1893 dnl Look for an instance of the Berkeley hashed database.
1894 dnl
1895 dnl $1 = optional parameter, to specify install-prefix for the database.
1896 AC_DEFUN([CF_HASHED_DB],
1897 [
1898 ifelse([$1],,,[
1899 case $1 in #(vi
1900 yes|*able*) #(vi
1901     ;;
1902 *)
1903     if test -d "$1" ; then
1904         CF_ADD_INCDIR($1/include)
1905         CF_ADD_LIBDIR($1/lib)
1906     fi
1907 esac
1908 ])
1909 AC_CHECK_HEADER(db.h,[
1910 CF_HASHED_DB_VERSION
1911 if test "$cf_cv_hashed_db_version" = unknown ; then
1912         AC_MSG_ERROR(Cannot determine version of db)
1913 else
1914         CF_HASHED_DB_LIBS
1915         if test "$cf_cv_hashed_db_libs" = unknown ; then
1916                 AC_MSG_ERROR(Cannot determine library for db)
1917         elif test "$cf_cv_hashed_db_libs" != default ; then
1918                 LIBS="-l$cf_cv_hashed_db_libs $LIBS"
1919         fi
1920 fi
1921 ],[
1922         AC_MSG_ERROR(Cannot find db.h)
1923 ])
1924 ])dnl
1925 dnl ---------------------------------------------------------------------------
1926 dnl CF_HASHED_DB_LIBS version: 8 updated: 2008/08/04 06:18:06
1927 dnl -----------------
1928 dnl Given that we have the header and version for hashed database, find the
1929 dnl library information.
1930 AC_DEFUN([CF_HASHED_DB_LIBS],
1931 [
1932 AC_CACHE_CHECK(for db libraries, cf_cv_hashed_db_libs,[
1933 cf_cv_hashed_db_libs=unknown
1934 for cf_db_libs in "" db$cf_cv_hashed_db_version db-$cf_cv_hashed_db_version db ''
1935 do
1936         cf_save_libs="$LIBS"
1937         if test -n "$cf_db_libs"; then
1938                 LIBS="-l$cf_db_libs $LIBS"
1939         fi
1940         CF_MSG_LOG(checking for library "$cf_db_libs")
1941         AC_TRY_LINK([
1942 $ac_includes_default
1943 #include <db.h>
1944 ],[
1945         char *path = "/tmp/foo";
1946 #ifdef DB_VERSION_MAJOR
1947 #if DB_VERSION_MAJOR >= 4
1948         DB *result = 0;
1949         db_create(&result, NULL, 0);
1950         result->open(result,
1951                 NULL,
1952                 path,
1953                 path,
1954                 DB_HASH,
1955                 DB_CREATE,
1956                 0644);
1957 #elif DB_VERSION_MAJOR >= 3
1958         DB *result = 0;
1959         db_create(&result, NULL, 0);
1960         result->open(result,
1961                 path,
1962                 path,
1963                 DB_HASH,
1964                 DB_CREATE,
1965                 0644);
1966 #elif DB_VERSION_MAJOR >= 2
1967         DB *result = 0;
1968         db_open(path,
1969                 DB_HASH,
1970                 DB_CREATE,
1971                 0644,
1972                 (DB_ENV *) 0,
1973                 (DB_INFO *) 0,
1974                 &result);
1975 #endif /* DB_VERSION_MAJOR */
1976 #else
1977         DB *result = dbopen(path,
1978                      2,
1979                      0644,
1980                      DB_HASH,
1981                      0);
1982 #endif
1983         ${cf_cv_main_return:-return}(result != 0)
1984 ],[
1985         if test -n "$cf_db_libs" ; then
1986                 cf_cv_hashed_db_libs=$cf_db_libs
1987         else
1988                 cf_cv_hashed_db_libs=default
1989         fi
1990         LIBS="$cf_save_libs"
1991         break
1992 ])
1993         LIBS="$cf_save_libs"
1994 done
1995 ])
1996 ])dnl
1997 dnl ---------------------------------------------------------------------------
1998 dnl CF_HASHED_DB_VERSION version: 3 updated: 2007/12/01 15:01:37
1999 dnl --------------------
2000 dnl Given that we have the header file for hashed database, find the version
2001 dnl information.
2002 AC_DEFUN([CF_HASHED_DB_VERSION],
2003 [
2004 AC_CACHE_CHECK(for version of db, cf_cv_hashed_db_version,[
2005 cf_cv_hashed_db_version=unknown
2006
2007 for cf_db_version in 1 2 3 4 5
2008 do
2009         CF_MSG_LOG(checking for db version $cf_db_version)
2010         AC_TRY_COMPILE([
2011 $ac_includes_default
2012 #include <db.h>
2013
2014 #ifdef DB_VERSION_MAJOR
2015         /* db2 (DB_VERSION_MAJOR=2) has also DB_VERSION_MINOR, tested with 7 */
2016 #if $cf_db_version == DB_VERSION_MAJOR
2017         /* ok */
2018 #else
2019         make an error
2020 #endif
2021 #else
2022 #if $cf_db_version == 1
2023         /* ok: assuming this is DB 1.8.5 */
2024 #else
2025         make an error
2026 #endif
2027 #endif
2028 ],[DBT *foo = 0],[
2029         cf_cv_hashed_db_version=$cf_db_version
2030         break
2031         ])
2032 done
2033 ])
2034 ])dnl
2035 dnl ---------------------------------------------------------------------------
2036 dnl CF_HEADER_PATH version: 9 updated: 2008/12/07 19:38:31
2037 dnl --------------
2038 dnl Construct a search-list of directories for a nonstandard header-file
2039 dnl
2040 dnl Parameters
2041 dnl     $1 = the variable to return as result
2042 dnl     $2 = the package name
2043 AC_DEFUN([CF_HEADER_PATH],
2044 [
2045 cf_header_path_list=""
2046 if test -n "${CFLAGS}${CPPFLAGS}" ; then
2047         for cf_header_path in $CPPFLAGS $CFLAGS
2048         do
2049                 case $cf_header_path in #(vi
2050                 -I*)
2051                         cf_header_path=`echo ".$cf_header_path" |sed -e 's/^...//' -e 's,/include$,,'`
2052                         CF_ADD_SUBDIR_PATH($1,$2,include,$cf_header_path,NONE)
2053                         cf_header_path_list="$cf_header_path_list [$]$1"
2054                         ;;
2055                 esac
2056         done
2057 fi
2058
2059 CF_SUBDIR_PATH($1,$2,include)
2060
2061 test "$includedir" != NONE && \
2062 test "$includedir" != "/usr/include" && \
2063 test -d "$includedir" && {
2064         test -d $includedir &&    $1="[$]$1 $includedir"
2065         test -d $includedir/$2 && $1="[$]$1 $includedir/$2"
2066 }
2067
2068 test "$oldincludedir" != NONE && \
2069 test "$oldincludedir" != "/usr/include" && \
2070 test -d "$oldincludedir" && {
2071         test -d $oldincludedir    && $1="[$]$1 $oldincludedir"
2072         test -d $oldincludedir/$2 && $1="[$]$1 $oldincludedir/$2"
2073 }
2074
2075 $1="$cf_header_path_list [$]$1"
2076 ])dnl
2077 dnl ---------------------------------------------------------------------------
2078 dnl CF_HELP_MESSAGE version: 3 updated: 1998/01/14 10:56:23
2079 dnl ---------------
2080 dnl Insert text into the help-message, for readability, from AC_ARG_WITH.
2081 AC_DEFUN([CF_HELP_MESSAGE],
2082 [AC_DIVERT_HELP([$1])dnl
2083 ])dnl
2084 dnl ---------------------------------------------------------------------------
2085 dnl CF_INCLUDE_DIRS version: 6 updated: 2009/01/06 19:37:40
2086 dnl ---------------
2087 dnl Construct the list of include-options according to whether we're building
2088 dnl in the source directory or using '--srcdir=DIR' option.  If we're building
2089 dnl with gcc, don't append the includedir if it happens to be /usr/include,
2090 dnl since that usually breaks gcc's shadow-includes.
2091 AC_DEFUN([CF_INCLUDE_DIRS],
2092 [
2093 CPPFLAGS="$CPPFLAGS -I. -I../include"
2094 if test "$srcdir" != "."; then
2095         CPPFLAGS="$CPPFLAGS -I\${srcdir}/../include"
2096 fi
2097 if test "$GCC" != yes; then
2098         CPPFLAGS="$CPPFLAGS -I\${includedir}"
2099 elif test "$includedir" != "/usr/include"; then
2100         if test "$includedir" = '${prefix}/include' ; then
2101                 if test $prefix != /usr ; then
2102                         CPPFLAGS="$CPPFLAGS -I\${includedir}"
2103                 fi
2104         else
2105                 CPPFLAGS="$CPPFLAGS -I\${includedir}"
2106         fi
2107 fi
2108 AC_SUBST(CPPFLAGS)
2109 ])dnl
2110 dnl ---------------------------------------------------------------------------
2111 dnl CF_INTEL_COMPILER version: 3 updated: 2005/08/06 18:37:29
2112 dnl -----------------
2113 dnl Check if the given compiler is really the Intel compiler for Linux.  It
2114 dnl tries to imitate gcc, but does not return an error when it finds a mismatch
2115 dnl between prototypes, e.g., as exercised by CF_MISSING_CHECK.
2116 dnl
2117 dnl This macro should be run "soon" after AC_PROG_CC or AC_PROG_CPLUSPLUS, to
2118 dnl ensure that it is not mistaken for gcc/g++.  It is normally invoked from
2119 dnl the wrappers for gcc and g++ warnings.
2120 dnl
2121 dnl $1 = GCC (default) or GXX
2122 dnl $2 = INTEL_COMPILER (default) or INTEL_CPLUSPLUS
2123 dnl $3 = CFLAGS (default) or CXXFLAGS
2124 AC_DEFUN([CF_INTEL_COMPILER],[
2125 ifelse($2,,INTEL_COMPILER,[$2])=no
2126
2127 if test "$ifelse($1,,[$1],GCC)" = yes ; then
2128         case $host_os in
2129         linux*|gnu*)
2130                 AC_MSG_CHECKING(if this is really Intel ifelse($1,GXX,C++,C) compiler)
2131                 cf_save_CFLAGS="$ifelse($3,,CFLAGS,[$3])"
2132                 ifelse($3,,CFLAGS,[$3])="$ifelse($3,,CFLAGS,[$3]) -no-gcc"
2133                 AC_TRY_COMPILE([],[
2134 #ifdef __INTEL_COMPILER
2135 #else
2136 make an error
2137 #endif
2138 ],[ifelse($2,,INTEL_COMPILER,[$2])=yes
2139 cf_save_CFLAGS="$cf_save_CFLAGS -we147 -no-gcc"
2140 ],[])
2141                 ifelse($3,,CFLAGS,[$3])="$cf_save_CFLAGS"
2142                 AC_MSG_RESULT($ifelse($2,,INTEL_COMPILER,[$2]))
2143                 ;;
2144         esac
2145 fi
2146 ])dnl
2147 dnl ---------------------------------------------------------------------------
2148 dnl CF_ISASCII version: 3 updated: 2000/08/12 23:18:52
2149 dnl ----------
2150 dnl Check if we have either a function or macro for 'isascii()'.
2151 AC_DEFUN([CF_ISASCII],
2152 [
2153 AC_MSG_CHECKING(for isascii)
2154 AC_CACHE_VAL(cf_cv_have_isascii,[
2155         AC_TRY_LINK([#include <ctype.h>],[int x = isascii(' ')],
2156         [cf_cv_have_isascii=yes],
2157         [cf_cv_have_isascii=no])
2158 ])dnl
2159 AC_MSG_RESULT($cf_cv_have_isascii)
2160 test "$cf_cv_have_isascii" = yes && AC_DEFINE(HAVE_ISASCII)
2161 ])dnl
2162 dnl ---------------------------------------------------------------------------
2163 dnl CF_LARGEFILE version: 7 updated: 2007/06/02 11:58:50
2164 dnl ------------
2165 dnl Add checks for large file support.
2166 AC_DEFUN([CF_LARGEFILE],[
2167 ifdef([AC_FUNC_FSEEKO],[
2168     AC_SYS_LARGEFILE
2169     if test "$enable_largefile" != no ; then
2170         AC_FUNC_FSEEKO
2171
2172         # Normally we would collect these definitions in the config.h,
2173         # but (like _XOPEN_SOURCE), some environments rely on having these
2174         # defined before any of the system headers are included.  Another
2175         # case comes up with C++, e.g., on AIX the compiler compiles the
2176         # header files by themselves before looking at the body files it is
2177         # told to compile.  For ncurses, those header files do not include
2178         # the config.h
2179         test "$ac_cv_sys_large_files"      != no && CPPFLAGS="$CPPFLAGS -D_LARGE_FILES "
2180         test "$ac_cv_sys_largefile_source" != no && CPPFLAGS="$CPPFLAGS -D_LARGEFILE_SOURCE "
2181         test "$ac_cv_sys_file_offset_bits" != no && CPPFLAGS="$CPPFLAGS -D_FILE_OFFSET_BITS=$ac_cv_sys_file_offset_bits "
2182
2183         AC_CACHE_CHECK(whether to use struct dirent64, cf_cv_struct_dirent64,[
2184                 AC_TRY_COMPILE([
2185 #include <sys/types.h>
2186 #include <dirent.h>
2187                 ],[
2188                 /* if transitional largefile support is setup, this is true */
2189                 extern struct dirent64 * readdir(DIR *);
2190                 struct dirent64 *x = readdir((DIR *)0);
2191                 struct dirent *y = readdir((DIR *)0);
2192                 int z = x - y;
2193                 ],
2194                 [cf_cv_struct_dirent64=yes],
2195                 [cf_cv_struct_dirent64=no])
2196         ])
2197         test "$cf_cv_struct_dirent64" = yes && AC_DEFINE(HAVE_STRUCT_DIRENT64)
2198     fi
2199 ])
2200 ])
2201 dnl ---------------------------------------------------------------------------
2202 dnl CF_LDFLAGS_STATIC version: 5 updated: 2008/12/27 12:30:03
2203 dnl -----------------
2204 dnl Check for compiler/linker flags used to temporarily force usage of static
2205 dnl libraries.  This depends on the compiler and platform.  Use this to help
2206 dnl ensure that the linker picks up a given library based on its position in
2207 dnl the list of linker options and libraries.
2208 AC_DEFUN([CF_LDFLAGS_STATIC],[
2209
2210 if test "$GCC" = yes ; then
2211         case $cf_cv_system_name in #(
2212         OS/2*|os2*|aix[[4]]*)   #( vi
2213                 LDFLAGS_STATIC=
2214                 LDFLAGS_SHARED=
2215                 ;;
2216     *)  #( normally, except when broken
2217         LDFLAGS_STATIC=-static
2218         LDFLAGS_SHARED=-dynamic
2219         ;;
2220     esac
2221 else
2222         case $cf_cv_system_name in #(
2223         aix[[456]]*)    #( from ld manpage
2224                 LDFLAGS_STATIC=-bstatic
2225                 LDFLAGS_SHARED=-bdynamic
2226                 ;;
2227         hpux*)          #( from ld manpage for hpux10.20, hpux11.11
2228                 # We could also use just "archive" and "shared".
2229                 LDFLAGS_STATIC=-Wl,-a,archive_shared
2230                 LDFLAGS_SHARED=-Wl,-a,shared_archive
2231                 ;;
2232         irix*)          #( from ld manpage IRIX64
2233                 LDFLAGS_STATIC=-Bstatic
2234                 LDFLAGS_SHARED=-Bdynamic
2235                 ;;
2236         osf[[45]]*)     #( from ld manpage osf4.0d, osf5.1
2237                 # alternative "-oldstyle_liblookup" (not in cc manpage)
2238                 LDFLAGS_STATIC=-noso
2239                 LDFLAGS_SHARED=-so_archive
2240                 ;;
2241         solaris2*)
2242                 LDFLAGS_STATIC=-Bstatic
2243                 LDFLAGS_SHARED=-Bdynamic
2244                 ;;
2245         esac
2246 fi
2247
2248 AC_SUBST(LDFLAGS_STATIC)
2249 AC_SUBST(LDFLAGS_SHARED)
2250 ])
2251 dnl ---------------------------------------------------------------------------
2252 dnl CF_LIBRARY_PATH version: 8 updated: 2008/12/07 19:38:31
2253 dnl ---------------
2254 dnl Construct a search-list of directories for a nonstandard library-file
2255 dnl
2256 dnl Parameters
2257 dnl     $1 = the variable to return as result
2258 dnl     $2 = the package name
2259 AC_DEFUN([CF_LIBRARY_PATH],
2260 [
2261 cf_library_path_list=""
2262 if test -n "${LDFLAGS}${LIBS}" ; then
2263         for cf_library_path in $LDFLAGS $LIBS
2264         do
2265                 case $cf_library_path in #(vi
2266                 -L*)
2267                         cf_library_path=`echo ".$cf_library_path" |sed -e 's/^...//' -e 's,/lib$,,'`
2268                         CF_ADD_SUBDIR_PATH($1,$2,lib,$cf_library_path,NONE)
2269                         cf_library_path_list="$cf_library_path_list [$]$1"
2270                         ;;
2271                 esac
2272         done
2273 fi
2274
2275 CF_SUBDIR_PATH($1,$2,lib)
2276
2277 $1="$cf_library_path_list [$]$1"
2278 ])dnl
2279 dnl ---------------------------------------------------------------------------
2280 dnl CF_LIB_PREFIX version: 8 updated: 2008/09/13 11:34:16
2281 dnl -------------
2282 dnl Compute the library-prefix for the given host system
2283 dnl $1 = variable to set
2284 AC_DEFUN([CF_LIB_PREFIX],
2285 [
2286         case $cf_cv_system_name in #(vi
2287         OS/2*|os2*) #(vi
2288         LIB_PREFIX=''
2289         ;;
2290         *)      LIB_PREFIX='lib'
2291         ;;
2292         esac
2293 ifelse($1,,,[$1=$LIB_PREFIX])
2294         AC_SUBST(LIB_PREFIX)
2295 ])dnl
2296 dnl ---------------------------------------------------------------------------
2297 dnl CF_LIB_RULES version: 55 updated: 2008/12/13 16:17:38
2298 dnl ------------
2299 dnl Append definitions and rules for the given models to the subdirectory
2300 dnl Makefiles, and the recursion rule for the top-level Makefile.  If the
2301 dnl subdirectory is a library-source directory, modify the LIBS_TO_MAKE list in
2302 dnl the corresponding makefile to list the models that we'll generate.
2303 dnl
2304 dnl For shared libraries, make a list of symbolic links to construct when
2305 dnl generating each library.  The convention used for Linux is the simplest
2306 dnl one:
2307 dnl     lib<name>.so    ->
2308 dnl     lib<name>.so.<major>    ->
2309 dnl     lib<name>.so.<maj>.<minor>
2310 AC_DEFUN([CF_LIB_RULES],
2311 [
2312 CF_LIB_PREFIX(cf_prefix)
2313 AC_REQUIRE([CF_SUBST_NCURSES_VERSION])
2314
2315 if test $cf_cv_shlib_version = cygdll ; then
2316         TINFO_NAME=$TINFO_ARG_SUFFIX
2317         TINFO_SUFFIX=.dll
2318 fi
2319
2320 for cf_dir in $SRC_SUBDIRS
2321 do
2322         if test ! -d $srcdir/$cf_dir ; then
2323                 continue
2324         elif test -f $srcdir/$cf_dir/modules; then
2325
2326                 SHARED_LIB=
2327                 LIBS_TO_MAKE=
2328                 for cf_item in $cf_LIST_MODELS
2329                 do
2330                         CF_LIB_SUFFIX($cf_item,cf_suffix,cf_depsuf)
2331                         if test $cf_item = shared ; then
2332                         if test "$cf_cv_do_symlinks" = yes ; then
2333                                 case "$cf_cv_shlib_version" in #(vi
2334                                 rel) #(vi
2335                                         case "$cf_cv_system_name" in #(vi
2336                                         darwin*)
2337                                         case .${LIB_SUFFIX} in
2338                                         .w*)
2339                                                 cf_suffix=`echo $cf_suffix | sed 's/^w//'`
2340                                                 cf_suffix=w'.${REL_VERSION}'"$cf_suffix"
2341                                                 ;;
2342                                         *)
2343                                                 cf_suffix='.${REL_VERSION}'"$cf_suffix"
2344                                                 ;;
2345                                         esac
2346                                         ;; #(vi
2347                                         *) cf_suffix="$cf_suffix"'.${REL_VERSION}' ;;
2348                                         esac
2349                                         ;;
2350                                 abi)
2351                                         case "$cf_cv_system_name" in #(vi
2352                                         darwin*)
2353                                         case .${LIB_SUFFIX} in
2354                                         .w*)
2355                                                 cf_suffix=`echo $cf_suffix | sed 's/^w//'`
2356                                                 cf_suffix=w'.${ABI_VERSION}'"$cf_suffix"
2357                                                 ;;
2358                                         *)
2359                                                 cf_suffix='.${ABI_VERSION}'"$cf_suffix"
2360                                                 ;;
2361                                         esac
2362                                         ;; #(vi
2363                                         *) cf_suffix="$cf_suffix"'.${ABI_VERSION}' ;;
2364                                         esac
2365                                         ;;
2366                                 esac
2367                         fi
2368                         # cygwin needs import library, and has unique naming convention
2369                         # use autodetected ${cf_prefix} for import lib and static lib, but
2370                         # use 'cyg' prefix for shared lib.
2371                         if test $cf_cv_shlib_version = cygdll ; then
2372                                 cf_cygsuf=`echo "$cf_suffix" | sed -e 's/\.dll/\${ABI_VERSION}.dll/'`
2373                                 LIBS_TO_MAKE="$LIBS_TO_MAKE ../lib/cyg${cf_dir}${cf_cygsuf}"
2374                                 continue
2375                         fi
2376                         fi
2377                         LIBS_TO_MAKE="$LIBS_TO_MAKE ../lib/${cf_prefix}${cf_dir}${cf_suffix}"
2378                 done
2379
2380                 if test $cf_dir = ncurses ; then
2381                         cf_subsets="$LIB_SUBSETS"
2382                         cf_r_parts="$cf_subsets"
2383                         cf_liblist="$LIBS_TO_MAKE"
2384
2385                         while test -n "$cf_r_parts"
2386                         do
2387                                 cf_l_parts=`echo "$cf_r_parts" |sed -e 's/ .*$//'`
2388                                 cf_r_parts=`echo "$cf_r_parts" |sed -e 's/^[[^ ]]* //'`
2389                                 if test "$cf_l_parts" != "$cf_r_parts" ; then
2390                                         cf_item=
2391                                         case $cf_l_parts in #(vi
2392                                         *termlib*) #(vi
2393                                                 cf_item=`echo $cf_liblist |sed -e s%${LIB_NAME}${LIB_SUFFIX}%${TINFO_LIB_SUFFIX}%g`
2394                                                 ;;
2395                                         *ticlib*)
2396                                                 cf_item=`echo $cf_liblist |sed -e s%${LIB_NAME}${LIB_SUFFIX}%${TICS_LIB_SUFFIX}%g`
2397                                                 ;;
2398                                         *)
2399                                                 break
2400                                                 ;;
2401                                         esac
2402                                         if test -n "$cf_item"; then
2403                                                 LIBS_TO_MAKE="$cf_item $LIBS_TO_MAKE"
2404                                         fi
2405                                 else
2406                                         break
2407                                 fi
2408                         done
2409                 else
2410                         cf_subsets=`echo "$LIB_SUBSETS" | sed -e 's/^termlib.* //'`
2411                 fi
2412
2413                 sed -e "s%@LIBS_TO_MAKE@%$LIBS_TO_MAKE%" \
2414                     -e "s%@SHARED_LIB@%$SHARED_LIB%" \
2415                         $cf_dir/Makefile >$cf_dir/Makefile.out
2416                 mv $cf_dir/Makefile.out $cf_dir/Makefile
2417
2418                 $AWK -f $srcdir/mk-0th.awk \
2419                         libname="${cf_dir}${LIB_SUFFIX}" subsets="$LIB_SUBSETS" \
2420                         $srcdir/$cf_dir/modules >>$cf_dir/Makefile
2421
2422                 for cf_subset in $cf_subsets
2423                 do
2424                         cf_subdirs=
2425                         for cf_item in $cf_LIST_MODELS
2426                         do
2427                         echo "Appending rules for ${cf_item} model (${cf_dir}: ${cf_subset})"
2428                         CF_UPPER(cf_ITEM,$cf_item)
2429                         CF_LIB_SUFFIX($cf_item,cf_suffix,cf_depsuf)
2430                         CF_OBJ_SUBDIR($cf_item,cf_subdir)
2431
2432                         # Test for case where we build libtinfo with a different name.
2433                         cf_libname=$cf_dir
2434                         if test $cf_dir = ncurses ; then
2435                                 case $cf_subset in
2436                                 *base*)
2437                                         cf_libname=${cf_libname}$LIB_SUFFIX
2438                                         ;;
2439                                 *termlib*)
2440                                         cf_libname=$TINFO_LIB_SUFFIX
2441                                         ;;
2442                                 ticlib*)
2443                                         cf_libname=$TICS_LIB_SUFFIX
2444                                         ;;
2445                                 esac
2446                         else
2447                                 cf_libname=${cf_libname}$LIB_SUFFIX
2448                         fi
2449                         if test -n "${DFT_ARG_SUFFIX}" ; then
2450                                 # undo $LIB_SUFFIX add-on in CF_LIB_SUFFIX
2451                                 cf_suffix=`echo $cf_suffix |sed -e "s%^${LIB_SUFFIX}%%"`
2452                         fi
2453
2454                         # These dependencies really are for development, not
2455                         # builds, but they are useful in porting, too.
2456                         cf_depend="../include/ncurses_cfg.h"
2457                         if test "$srcdir" = "."; then
2458                                 cf_reldir="."
2459                         else
2460                                 cf_reldir="\${srcdir}"
2461                         fi
2462
2463                         if test -f $srcdir/$cf_dir/$cf_dir.priv.h; then
2464                                 cf_depend="$cf_depend $cf_reldir/$cf_dir.priv.h"
2465                         elif test -f $srcdir/$cf_dir/curses.priv.h; then
2466                                 cf_depend="$cf_depend $cf_reldir/curses.priv.h"
2467                         fi
2468
2469                         cf_dir_suffix=
2470                         old_cf_suffix="$cf_suffix"
2471                         if test "$cf_cv_shlib_version_infix" = yes ; then
2472                         if test -n "$LIB_SUFFIX" ; then
2473                                 case $LIB_SUFFIX in
2474                                 w*)
2475                                         cf_libname=`echo $cf_libname | sed 's/w$//'`
2476                                         cf_suffix=`echo $cf_suffix | sed 's/^w//'`
2477                                         cf_dir_suffix=w
2478                                         ;;
2479                                 esac
2480                         fi
2481                         fi
2482
2483                         $AWK -f $srcdir/mk-1st.awk \
2484                                 name=${cf_libname}${cf_dir_suffix} \
2485                                 traces=$LIB_TRACING \
2486                                 MODEL=$cf_ITEM \
2487                                 model=$cf_subdir \
2488                                 prefix=$cf_prefix \
2489                                 suffix=$cf_suffix \
2490                                 subset=$cf_subset \
2491                                 TermlibRoot=$TINFO_NAME \
2492                                 TermlibSuffix=$TINFO_SUFFIX \
2493                                 ShlibVer=$cf_cv_shlib_version \
2494                                 ShlibVerInfix=$cf_cv_shlib_version_infix \
2495                                 ReLink=${cf_cv_do_relink-no} \
2496                                 DoLinks=$cf_cv_do_symlinks \
2497                                 rmSoLocs=$cf_cv_rm_so_locs \
2498                                 ldconfig="$LDCONFIG" \
2499                                 overwrite=$WITH_OVERWRITE \
2500                                 depend="$cf_depend" \
2501                                 host="$host" \
2502                                 $srcdir/$cf_dir/modules >>$cf_dir/Makefile
2503
2504                         cf_suffix="$old_cf_suffix"
2505
2506                         for cf_subdir2 in $cf_subdirs lib
2507                         do
2508                                 test $cf_subdir = $cf_subdir2 && break
2509                         done
2510                         test "${cf_subset}.${cf_subdir2}" != "${cf_subset}.${cf_subdir}" && \
2511                         $AWK -f $srcdir/mk-2nd.awk \
2512                                 name=$cf_dir \
2513                                 traces=$LIB_TRACING \
2514                                 MODEL=$cf_ITEM \
2515                                 model=$cf_subdir \
2516                                 subset=$cf_subset \
2517                                 srcdir=$srcdir \
2518                                 echo=$WITH_ECHO \
2519                                 crenames=$cf_cv_prog_CC_c_o \
2520                                 cxxrenames=$cf_cv_prog_CXX_c_o \
2521                                 $srcdir/$cf_dir/modules >>$cf_dir/Makefile
2522                         cf_subdirs="$cf_subdirs $cf_subdir"
2523                         done
2524                 done
2525         fi
2526
2527         echo '  cd '$cf_dir' && ${MAKE} ${CF_MFLAGS} [$]@' >>Makefile
2528 done
2529
2530 for cf_dir in $SRC_SUBDIRS
2531 do
2532         if test ! -d $srcdir/$cf_dir ; then
2533                 continue
2534         fi
2535
2536         if test -f $cf_dir/Makefile ; then
2537                 case "$cf_dir" in
2538                 Ada95) #(vi
2539                         echo 'libs \' >> Makefile
2540                         echo 'install.libs \' >> Makefile
2541                         echo 'uninstall.libs ::' >> Makefile
2542                         echo '  cd '$cf_dir' && ${MAKE} ${CF_MFLAGS} [$]@' >> Makefile
2543                         ;;
2544                 esac
2545         fi
2546
2547         if test -f $srcdir/$cf_dir/modules; then
2548                 echo >> Makefile
2549                 if test -f $srcdir/$cf_dir/headers; then
2550 cat >> Makefile <<CF_EOF
2551 install.includes \\
2552 uninstall.includes \\
2553 CF_EOF
2554                 fi
2555 if test "$cf_dir" != "c++" ; then
2556 echo 'lint \' >> Makefile
2557 fi
2558 cat >> Makefile <<CF_EOF
2559 libs \\
2560 lintlib \\
2561 install.libs \\
2562 uninstall.libs \\
2563 install.$cf_dir \\
2564 uninstall.$cf_dir ::
2565         cd $cf_dir && \${MAKE} \${CF_MFLAGS} \[$]@
2566 CF_EOF
2567         elif test -f $srcdir/$cf_dir/headers; then
2568 cat >> Makefile <<CF_EOF
2569
2570 libs \\
2571 install.libs \\
2572 uninstall.libs \\
2573 install.includes \\
2574 uninstall.includes ::
2575         cd $cf_dir && \${MAKE} \${CF_MFLAGS} \[$]@
2576 CF_EOF
2577 fi
2578 done
2579
2580 cat >> Makefile <<CF_EOF
2581
2582 install.libs uninstall.libs \\
2583 install.data uninstall.data ::
2584 $MAKE_TERMINFO  cd misc && \${MAKE} \${CF_MFLAGS} \[$]@
2585 CF_EOF
2586
2587 if test "x$cf_with_manpages" = xyes; then
2588 cat >> Makefile <<CF_EOF
2589
2590 install.man \\
2591 uninstall.man ::
2592         cd man && \${MAKE} \${CF_MFLAGS} \[$]@
2593 CF_EOF
2594 fi
2595
2596 cat >> Makefile <<CF_EOF
2597
2598 distclean ::
2599         rm -f config.cache config.log config.status Makefile include/ncurses_cfg.h
2600         rm -f headers.sh headers.sed mk_shared_lib.sh
2601         rm -f edit_man.* man_alias.*
2602         rm -rf \${DIRS_TO_MAKE}
2603 CF_EOF
2604
2605 # Special case: tack's manpage lives in its own directory.
2606 if test "x$cf_with_manpages" = xyes; then
2607 if test -d tack ; then
2608 if test -f $srcdir/$tack.h; then
2609 cat >> Makefile <<CF_EOF
2610
2611 install.man \\
2612 uninstall.man ::
2613         cd tack && \${MAKE} \${CF_MFLAGS} \[$]@
2614 CF_EOF
2615 fi
2616 fi
2617 fi
2618
2619 dnl If we're installing into a subdirectory of /usr/include, etc., we should
2620 dnl prepend the subdirectory's name to the "#include" paths.  It won't hurt
2621 dnl anything, and will make it more standardized.  It's awkward to decide this
2622 dnl at configuration because of quoting, so we'll simply make all headers
2623 dnl installed via a script that can do the right thing.
2624
2625 rm -f headers.sed headers.sh
2626
2627 dnl ( generating this script makes the makefiles a little tidier :-)
2628 echo creating headers.sh
2629 cat >headers.sh <<CF_EOF
2630 #! /bin/sh
2631 # This shell script is generated by the 'configure' script.  It is invoked in a
2632 # subdirectory of the build tree.  It generates a sed-script in the parent
2633 # directory that is used to adjust includes for header files that reside in a
2634 # subdirectory of /usr/include, etc.
2635 PRG=""
2636 while test \[$]# != 3
2637 do
2638 PRG="\$PRG \[$]1"; shift
2639 done
2640 DST=\[$]1
2641 REF=\[$]2
2642 SRC=\[$]3
2643 TMPSRC=\${TMPDIR-/tmp}/\`basename \$SRC\`\$\$
2644 TMPSED=\${TMPDIR-/tmp}/headers.sed\$\$
2645 echo installing \$SRC in \$DST
2646 CF_EOF
2647
2648 if test $WITH_CURSES_H = yes; then
2649         cat >>headers.sh <<CF_EOF
2650 case \$DST in
2651 /*/include/*)
2652         END=\`basename \$DST\`
2653         for i in \`cat \$REF/../*/headers |fgrep -v "#"\`
2654         do
2655                 NAME=\`basename \$i\`
2656                 echo "s/<\$NAME>/<\$END\/\$NAME>/" >> \$TMPSED
2657         done
2658         ;;
2659 *)
2660         echo "" >> \$TMPSED
2661         ;;
2662 esac
2663 CF_EOF
2664
2665 else
2666         cat >>headers.sh <<CF_EOF
2667 case \$DST in
2668 /*/include/*)
2669         END=\`basename \$DST\`
2670         for i in \`cat \$REF/../*/headers |fgrep -v "#"\`
2671         do
2672                 NAME=\`basename \$i\`
2673                 if test "\$NAME" = "curses.h"
2674                 then
2675                         echo "s/<curses.h>/<ncurses.h>/" >> \$TMPSED
2676                         NAME=ncurses.h
2677                 fi
2678                 echo "s/<\$NAME>/<\$END\/\$NAME>/" >> \$TMPSED
2679         done
2680         ;;
2681 *)
2682         echo "s/<curses.h>/<ncurses.h>/" >> \$TMPSED
2683         ;;
2684 esac
2685 CF_EOF
2686 fi
2687 cat >>headers.sh <<CF_EOF
2688 rm -f \$TMPSRC
2689 sed -f \$TMPSED \$SRC > \$TMPSRC
2690 NAME=\`basename \$SRC\`
2691 CF_EOF
2692 if test $WITH_CURSES_H != yes; then
2693         cat >>headers.sh <<CF_EOF
2694 test "\$NAME" = "curses.h" && NAME=ncurses.h
2695 CF_EOF
2696 fi
2697 cat >>headers.sh <<CF_EOF
2698 # Just in case someone gzip'd manpages, remove the conflicting copy.
2699 test -f \$DST/\$NAME.gz && rm -f \$DST/\$NAME.gz
2700
2701 eval \$PRG \$TMPSRC \$DST/\$NAME
2702 rm -f \$TMPSRC \$TMPSED
2703 CF_EOF
2704
2705 chmod 0755 headers.sh
2706
2707 for cf_dir in $SRC_SUBDIRS
2708 do
2709         if test ! -d $srcdir/$cf_dir ; then
2710                 continue
2711         fi
2712
2713         if test -f $srcdir/$cf_dir/headers; then
2714                 $AWK -f $srcdir/mk-hdr.awk \
2715                         subset="$LIB_SUBSETS" \
2716                         compat="$WITH_CURSES_H" \
2717                         $srcdir/$cf_dir/headers >>$cf_dir/Makefile
2718         fi
2719
2720         if test -f $srcdir/$cf_dir/modules; then
2721                 if test "$cf_dir" != "c++" ; then
2722                         cat >>$cf_dir/Makefile <<"CF_EOF"
2723 depend : ${AUTO_SRC}
2724         makedepend -- ${CPPFLAGS} -- ${C_SRC}
2725
2726 # DO NOT DELETE THIS LINE -- make depend depends on it.
2727 CF_EOF
2728                 fi
2729         fi
2730 done
2731
2732 ])dnl
2733 dnl ---------------------------------------------------------------------------
2734 dnl CF_LIB_SONAME version: 3 updated: 2006/12/16 15:55:46
2735 dnl -------------
2736 dnl Find the and soname for the given shared library.  Set the cache variable
2737 dnl cf_cv_$3_soname to this, unless it is not found.  Then set the cache
2738 dnl variable to "unknown".
2739 dnl
2740 dnl $1 = headers
2741 dnl $2 = code
2742 dnl $3 = library name
2743 AC_DEFUN([CF_LIB_SONAME],
2744 [
2745 AC_CACHE_CHECK(for soname of $3 library,cf_cv_$3_soname,[
2746
2747 cf_cv_$3_soname=unknown
2748 if test "$cross_compiling" != yes ; then
2749 cat >conftest.$ac_ext <<CF_EOF
2750 $1
2751 int main()
2752 {
2753 $2
2754         ${cf_cv_main_return:-return}(0);
2755 }
2756 CF_EOF
2757 cf_save_LIBS="$LIBS"
2758         LIBS="-l$3 $LIBS"
2759         if AC_TRY_EVAL(ac_compile) ; then
2760                 if AC_TRY_EVAL(ac_link) ; then
2761                         cf_cv_$3_soname=`ldd conftest$ac_exeext 2>/dev/null | sed -e 's,^.*/,,' -e 's, .*$,,' | fgrep lib$3.`
2762                         test -z "$cf_cv_$3_soname" && cf_cv_$3_soname=unknown
2763                 fi
2764         fi
2765 rm -f conftest*
2766 LIBS="$cf_save_LIBS"
2767 fi
2768 ])
2769 ])
2770 dnl ---------------------------------------------------------------------------
2771 dnl CF_LIB_SUFFIX version: 16 updated: 2008/12/27 12:30:03
2772 dnl -------------
2773 dnl Compute the library file-suffix from the given model name
2774 dnl $1 = model name
2775 dnl $2 = variable to set (the nominal library suffix)
2776 dnl $3 = dependency variable to set (actual filename)
2777 dnl The variable $LIB_SUFFIX, if set, prepends the variable to set.
2778 AC_DEFUN([CF_LIB_SUFFIX],
2779 [
2780         AC_REQUIRE([CF_SUBST_NCURSES_VERSION])
2781         case $1 in #(vi
2782         libtool) #(vi
2783                 $2='.la'
2784                 $3=[$]$2
2785                 ;;
2786         normal) #(vi
2787                 $2='.a'
2788                 $3=[$]$2
2789                 ;;
2790         debug) #(vi
2791                 $2='_g.a'
2792                 $3=[$]$2
2793                 ;;
2794         profile) #(vi
2795                 $2='_p.a'
2796                 $3=[$]$2
2797                 ;;
2798         shared) #(vi
2799                 case $cf_cv_system_name in
2800                 aix[[56]]*) #(vi
2801                         $2='.a'
2802                         $3=[$]$2
2803                         ;;
2804                 cygwin*) #(vi
2805                         $2='.dll'
2806                         $3='.dll.a'
2807                         ;;
2808                 darwin*) #(vi
2809                         $2='.dylib'
2810                         $3=[$]$2
2811                         ;;
2812                 hpux*) #(vi
2813                         case $target in
2814                         ia64*) #(vi
2815                                 $2='.so'
2816                                 $3=[$]$2
2817                                 ;;
2818                         *) #(vi
2819                                 $2='.sl'
2820                                 $3=[$]$2
2821                                 ;;
2822                         esac
2823                         ;;
2824                 *)      $2='.so'
2825                         $3=[$]$2
2826                         ;;
2827                 esac
2828         esac
2829         test -n "$LIB_SUFFIX" && $2="${LIB_SUFFIX}[$]{$2}"
2830         test -n "$LIB_SUFFIX" && $3="${LIB_SUFFIX}[$]{$3}"
2831 ])dnl
2832 dnl ---------------------------------------------------------------------------
2833 dnl CF_LIB_TYPE version: 4 updated: 2000/10/20 22:57:49
2834 dnl -----------
2835 dnl Compute the string to append to -library from the given model name
2836 dnl $1 = model name
2837 dnl $2 = variable to set
2838 dnl The variable $LIB_SUFFIX, if set, prepends the variable to set.
2839 AC_DEFUN([CF_LIB_TYPE],
2840 [
2841         case $1 in
2842         libtool) $2=''   ;;
2843         normal)  $2=''   ;;
2844         debug)   $2='_g' ;;
2845         profile) $2='_p' ;;
2846         shared)  $2=''   ;;
2847         esac
2848         test -n "$LIB_SUFFIX" && $2="${LIB_SUFFIX}[$]{$2}"
2849 ])dnl
2850 dnl ---------------------------------------------------------------------------
2851 dnl CF_LINK_DATAONLY version: 9 updated: 2009/01/01 20:21:38
2852 dnl ----------------
2853 dnl Some systems have a non-ANSI linker that doesn't pull in modules that have
2854 dnl only data (i.e., no functions), for example NeXT.  On those systems we'll
2855 dnl have to provide wrappers for global tables to ensure they're linked
2856 dnl properly.
2857 AC_DEFUN([CF_LINK_DATAONLY],
2858 [
2859 AC_MSG_CHECKING([if data-only library module links])
2860 AC_CACHE_VAL(cf_cv_link_dataonly,[
2861         rm -f conftest.a
2862         cat >conftest.$ac_ext <<EOF
2863 #line __oline__ "configure"
2864 int     testdata[[3]] = { 123, 456, 789 };
2865 EOF
2866         if AC_TRY_EVAL(ac_compile) ; then
2867                 mv conftest.o data.o && \
2868                 ( $AR $ARFLAGS conftest.a data.o ) 2>&AC_FD_CC 1>/dev/null
2869         fi
2870         rm -f conftest.$ac_ext data.o
2871         cat >conftest.$ac_ext <<EOF
2872 #line __oline__ "configure"
2873 int     testfunc()
2874 {
2875 #if defined(NeXT)
2876         ${cf_cv_main_return:-return}(1);        /* I'm told this linker is broken */
2877 #else
2878         extern int testdata[[3]];
2879         return testdata[[0]] == 123
2880            &&  testdata[[1]] == 456
2881            &&  testdata[[2]] == 789;
2882 #endif
2883 }
2884 EOF
2885         if AC_TRY_EVAL(ac_compile); then
2886                 mv conftest.o func.o && \
2887                 ( $AR $ARFLAGS conftest.a func.o ) 2>&AC_FD_CC 1>/dev/null
2888         fi
2889         rm -f conftest.$ac_ext func.o
2890         ( eval $RANLIB conftest.a ) 2>&AC_FD_CC >/dev/null
2891         cf_saveLIBS="$LIBS"
2892         LIBS="conftest.a $LIBS"
2893         AC_TRY_RUN([
2894         int main()
2895         {
2896                 extern int testfunc();
2897                 ${cf_cv_main_return:-return} (!testfunc());
2898         }
2899         ],
2900         [cf_cv_link_dataonly=yes],
2901         [cf_cv_link_dataonly=no],
2902         [cf_cv_link_dataonly=unknown])
2903         LIBS="$cf_saveLIBS"
2904         ])
2905 AC_MSG_RESULT($cf_cv_link_dataonly)
2906
2907 if test "$cf_cv_link_dataonly" = no ; then
2908         AC_DEFINE(BROKEN_LINKER)
2909         BROKEN_LINKER=1
2910 fi
2911
2912 ])dnl
2913 dnl ---------------------------------------------------------------------------
2914 dnl CF_LINK_FUNCS version: 7 updated: 2006/12/16 12:33:30
2915 dnl -------------
2916 dnl Most Unix systems have both link and symlink, a few don't have symlink.
2917 dnl A few non-Unix systems implement symlink, but not link.
2918 dnl A few non-systems implement neither (or have nonfunctional versions).
2919 AC_DEFUN([CF_LINK_FUNCS],
2920 [
2921 AC_CHECK_FUNCS( \
2922         remove \
2923         unlink )
2924
2925 if test "$cross_compiling" = yes ; then
2926         AC_CHECK_FUNCS( \
2927                 link \
2928                 symlink )
2929 else
2930         AC_CACHE_CHECK(if link/symlink functions work,cf_cv_link_funcs,[
2931                 cf_cv_link_funcs=
2932                 for cf_func in link symlink ; do
2933                         AC_TRY_RUN([
2934 #include <sys/types.h>
2935 #include <sys/stat.h>
2936 #ifdef HAVE_UNISTD_H
2937 #include <unistd.h>
2938 #endif
2939 int main()
2940 {
2941         int fail = 0;
2942         char *src = "config.log";
2943         char *dst = "conftest.chk";
2944         struct stat src_sb;
2945         struct stat dst_sb;
2946
2947         stat(src, &src_sb);
2948         fail = ($cf_func("config.log", "conftest.chk") < 0)
2949             || (stat(dst, &dst_sb) < 0)
2950             || (dst_sb.st_mtime != src_sb.st_mtime);
2951 #ifdef HAVE_UNLINK
2952         unlink(dst);
2953 #else
2954         remove(dst);
2955 #endif
2956         ${cf_cv_main_return:-return} (fail);
2957 }
2958                         ],[
2959                         cf_cv_link_funcs="$cf_cv_link_funcs $cf_func"
2960                         eval 'ac_cv_func_'$cf_func'=yes'],[
2961                         eval 'ac_cv_func_'$cf_func'=no'],[
2962                         eval 'ac_cv_func_'$cf_func'=error'])
2963                 done
2964                 test -z "$cf_cv_link_funcs" && cf_cv_link_funcs=no
2965         ])
2966         test "$ac_cv_func_link"    = yes && AC_DEFINE(HAVE_LINK)
2967         test "$ac_cv_func_symlink" = yes && AC_DEFINE(HAVE_SYMLINK)
2968 fi
2969 ])dnl
2970 dnl ---------------------------------------------------------------------------
2971 dnl CF_MAIN_RETURN version: 1 updated: 2006/12/10 09:51:54
2972 dnl --------------
2973 dnl Check if a return from main to the shell actually returns the same exit
2974 dnl code.  This is true for almost any POSIX environment.
2975 dnl
2976 dnl Some very old environments did not flush stdout, etc., on an exit.  That
2977 dnl would be a useful case to test for also.
2978 AC_DEFUN([CF_MAIN_RETURN],
2979 [
2980 cf_cv_main_return=return
2981 ])dnl
2982 dnl ---------------------------------------------------------------------------
2983 dnl CF_MAKEFLAGS version: 12 updated: 2006/10/21 08:27:03
2984 dnl ------------
2985 dnl Some 'make' programs support ${MAKEFLAGS}, some ${MFLAGS}, to pass 'make'
2986 dnl options to lower-levels.  It's very useful for "make -n" -- if we have it.
2987 dnl (GNU 'make' does both, something POSIX 'make', which happens to make the
2988 dnl ${MAKEFLAGS} variable incompatible because it adds the assignments :-)
2989 AC_DEFUN([CF_MAKEFLAGS],
2990 [
2991 AC_CACHE_CHECK(for makeflags variable, cf_cv_makeflags,[
2992         cf_cv_makeflags=''
2993         for cf_option in '-${MAKEFLAGS}' '${MFLAGS}'
2994         do
2995                 cat >cf_makeflags.tmp <<CF_EOF
2996 SHELL = /bin/sh
2997 all :
2998         @ echo '.$cf_option'
2999 CF_EOF
3000                 cf_result=`${MAKE-make} -k -f cf_makeflags.tmp 2>/dev/null | sed -e 's,[[       ]]*$,,'`
3001                 case "$cf_result" in
3002                 .*k)
3003                         cf_result=`${MAKE-make} -k -f cf_makeflags.tmp CC=cc 2>/dev/null`
3004                         case "$cf_result" in
3005                         .*CC=*) cf_cv_makeflags=
3006                                 ;;
3007                         *)      cf_cv_makeflags=$cf_option
3008                                 ;;
3009                         esac
3010                         break
3011                         ;;
3012                 .-)     ;;
3013                 *)      echo "given option \"$cf_option\", no match \"$cf_result\""
3014                         ;;
3015                 esac
3016         done
3017         rm -f cf_makeflags.tmp
3018 ])
3019
3020 AC_SUBST(cf_cv_makeflags)
3021 ])dnl
3022 dnl ---------------------------------------------------------------------------
3023 dnl CF_MAKE_TAGS version: 2 updated: 2000/10/04 09:18:40
3024 dnl ------------
3025 dnl Generate tags/TAGS targets for makefiles.  Do not generate TAGS if we have
3026 dnl a monocase filesystem.
3027 AC_DEFUN([CF_MAKE_TAGS],[
3028 AC_REQUIRE([CF_MIXEDCASE_FILENAMES])
3029 AC_CHECK_PROG(MAKE_LOWER_TAGS, ctags, yes, no)
3030
3031 if test "$cf_cv_mixedcase" = yes ; then
3032         AC_CHECK_PROG(MAKE_UPPER_TAGS, etags, yes, no)
3033 else
3034         MAKE_UPPER_TAGS=no
3035 fi
3036
3037 if test "$MAKE_UPPER_TAGS" = yes ; then
3038         MAKE_UPPER_TAGS=
3039 else
3040         MAKE_UPPER_TAGS="#"
3041 fi
3042 AC_SUBST(MAKE_UPPER_TAGS)
3043
3044 if test "$MAKE_LOWER_TAGS" = yes ; then
3045         MAKE_LOWER_TAGS=
3046 else
3047         MAKE_LOWER_TAGS="#"
3048 fi
3049 AC_SUBST(MAKE_LOWER_TAGS)
3050 ])dnl
3051 dnl ---------------------------------------------------------------------------
3052 dnl CF_MANPAGE_FORMAT version: 8 updated: 2009/01/11 20:30:50
3053 dnl -----------------
3054 dnl Option to allow user to override automatic configuration of manpage format.
3055 dnl There are several special cases:
3056 dnl
3057 dnl     gzip - man checks for, can display gzip'd files
3058 dnl     compress - man checks for, can display compressed files
3059 dnl     BSDI - files in the cat-directories are suffixed ".0"
3060 dnl     formatted - installer should format (put files in cat-directory)
3061 dnl     catonly - installer should only format, e.g., for a turnkey system.
3062 dnl
3063 dnl There are other configurations which this macro does not test, e.g., HPUX's
3064 dnl compressed manpages (but uncompressed manpages are fine, and HPUX's naming
3065 dnl convention would not match our use).
3066 AC_DEFUN([CF_MANPAGE_FORMAT],
3067 [
3068 AC_REQUIRE([CF_PATHSEP])
3069 AC_MSG_CHECKING(format of man-pages)
3070
3071 AC_ARG_WITH(manpage-format,
3072         [  --with-manpage-format   specify manpage-format: gzip/compress/BSDI/normal and
3073                           optionally formatted/catonly, e.g., gzip,formatted],
3074         [MANPAGE_FORMAT=$withval],
3075         [MANPAGE_FORMAT=unknown])
3076
3077 test -z "$MANPAGE_FORMAT" && MANPAGE_FORMAT=unknown
3078 MANPAGE_FORMAT=`echo "$MANPAGE_FORMAT" | sed -e 's/,/ /g'`
3079
3080 cf_unknown=
3081
3082 case $MANPAGE_FORMAT in
3083 unknown)
3084   if test -z "$MANPATH" ; then
3085     MANPATH="/usr/man:/usr/share/man"
3086   fi
3087
3088   # look for the 'date' man-page (it's most likely to be installed!)
3089   MANPAGE_FORMAT=
3090   cf_preform=no
3091   cf_catonly=yes
3092   cf_example=date
3093
3094   IFS="${IFS=   }"; ac_save_ifs="$IFS"; IFS="${IFS}${PATH_SEPARATOR}"
3095   for cf_dir in $MANPATH; do
3096     test -z "$cf_dir" && cf_dir=/usr/man
3097     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
3098     do
3099       cf_test=`echo $cf_name | sed -e 's/*//'`
3100       if test "x$cf_test" = "x$cf_name" ; then
3101
3102         case "$cf_name" in
3103         *.gz) MANPAGE_FORMAT="$MANPAGE_FORMAT gzip";;
3104         *.Z)  MANPAGE_FORMAT="$MANPAGE_FORMAT compress";;
3105         *.0)    MANPAGE_FORMAT="$MANPAGE_FORMAT BSDI";;
3106         *)    MANPAGE_FORMAT="$MANPAGE_FORMAT normal";;
3107         esac
3108
3109         case "$cf_name" in
3110         $cf_dir/man*)
3111           cf_catonly=no
3112           ;;
3113         $cf_dir/cat*)
3114           cf_preform=yes
3115           ;;
3116         esac
3117         break
3118       fi
3119
3120       # if we found a match in either man* or cat*, stop looking
3121       if test -n "$MANPAGE_FORMAT" ; then
3122         cf_found=no
3123         test "$cf_preform" = yes && MANPAGE_FORMAT="$MANPAGE_FORMAT formatted"
3124         test "$cf_catonly" = yes && MANPAGE_FORMAT="$MANPAGE_FORMAT catonly"
3125         case "$cf_name" in
3126         $cf_dir/cat*)
3127           cf_found=yes
3128           ;;
3129         esac
3130         test $cf_found=yes && break
3131       fi
3132     done
3133     # only check the first directory in $MANPATH where we find manpages
3134     if test -n "$MANPAGE_FORMAT" ; then
3135        break
3136     fi
3137   done
3138   # if we did not find the example, just assume it is normal
3139   test -z "$MANPAGE_FORMAT" && MANPAGE_FORMAT=normal
3140   IFS="$ac_save_ifs"
3141   ;;
3142 *)
3143   for cf_option in $MANPAGE_FORMAT; do
3144      case $cf_option in #(vi
3145      gzip|compress|BSDI|normal|formatted|catonly)
3146        ;;
3147      *)
3148        cf_unknown="$cf_unknown $cf_option"
3149        ;;
3150      esac
3151   done
3152   ;;
3153 esac
3154
3155 AC_MSG_RESULT($MANPAGE_FORMAT)
3156 if test -n "$cf_unknown" ; then
3157   AC_MSG_WARN(Unexpected manpage-format $cf_unknown)
3158 fi
3159 ])dnl
3160 dnl ---------------------------------------------------------------------------
3161 dnl CF_MANPAGE_RENAMES version: 7 updated: 2005/06/18 18:51:57
3162 dnl ------------------
3163 dnl The Debian people have their own naming convention for manpages.  This
3164 dnl option lets us override the name of the file containing renaming, or
3165 dnl disable it altogether.
3166 AC_DEFUN([CF_MANPAGE_RENAMES],
3167 [
3168 AC_MSG_CHECKING(for manpage renaming)
3169
3170 AC_ARG_WITH(manpage-renames,
3171         [  --with-manpage-renames  specify manpage-renaming],
3172         [MANPAGE_RENAMES=$withval],
3173         [MANPAGE_RENAMES=yes])
3174
3175 case ".$MANPAGE_RENAMES" in #(vi
3176 .no) #(vi
3177   ;;
3178 .|.yes)
3179   # Debian 'man' program?
3180   if test -f /etc/debian_version ; then
3181     MANPAGE_RENAMES=`cd $srcdir && pwd`/man/man_db.renames
3182   else
3183     MANPAGE_RENAMES=no
3184   fi
3185   ;;
3186 esac
3187
3188 if test "$MANPAGE_RENAMES" != no ; then
3189   if test -f $srcdir/man/$MANPAGE_RENAMES ; then
3190     MANPAGE_RENAMES=`cd $srcdir/man && pwd`/$MANPAGE_RENAMES
3191   elif test ! -f $MANPAGE_RENAMES ; then
3192     AC_MSG_ERROR(not a filename: $MANPAGE_RENAMES)
3193   fi
3194
3195   test ! -d man && mkdir man
3196
3197   # Construct a sed-script to perform renaming within man-pages
3198   if test -n "$MANPAGE_RENAMES" ; then
3199     test ! -d man && mkdir man
3200     sh $srcdir/man/make_sed.sh $MANPAGE_RENAMES >./edit_man.sed
3201   fi
3202 fi
3203
3204 AC_MSG_RESULT($MANPAGE_RENAMES)
3205 AC_SUBST(MANPAGE_RENAMES)
3206 ])dnl
3207 dnl ---------------------------------------------------------------------------
3208 dnl CF_MANPAGE_SYMLINKS version: 4 updated: 2003/12/13 18:01:58
3209 dnl -------------------
3210 dnl Some people expect each tool to make all aliases for manpages in the
3211 dnl man-directory.  This accommodates the older, less-capable implementations
3212 dnl of 'man', and is optional.
3213 AC_DEFUN([CF_MANPAGE_SYMLINKS],
3214 [
3215 AC_MSG_CHECKING(if manpage aliases will be installed)
3216
3217 AC_ARG_WITH(manpage-aliases,
3218         [  --with-manpage-aliases  specify manpage-aliases using .so],
3219         [MANPAGE_ALIASES=$withval],
3220         [MANPAGE_ALIASES=yes])
3221
3222 AC_MSG_RESULT($MANPAGE_ALIASES)
3223
3224 if test "$LN_S" = "ln -s"; then
3225         cf_use_symlinks=yes
3226 else
3227         cf_use_symlinks=no
3228 fi
3229
3230 MANPAGE_SYMLINKS=no
3231 if test "$MANPAGE_ALIASES" = yes ; then
3232 AC_MSG_CHECKING(if manpage symlinks should be used)
3233
3234 AC_ARG_WITH(manpage-symlinks,
3235         [  --with-manpage-symlinks specify manpage-aliases using symlinks],
3236         [MANPAGE_SYMLINKS=$withval],
3237         [MANPAGE_SYMLINKS=$cf_use_symlinks])
3238
3239 if test "$$cf_use_symlinks" = no; then
3240 if test "$MANPAGE_SYMLINKS" = yes ; then
3241         AC_MSG_WARN(cannot make symlinks, will use .so files)
3242         MANPAGE_SYMLINKS=no
3243 fi
3244 fi
3245
3246 AC_MSG_RESULT($MANPAGE_SYMLINKS)
3247 fi
3248
3249 ])dnl
3250 dnl ---------------------------------------------------------------------------
3251 dnl CF_MANPAGE_TBL version: 3 updated: 2002/01/19 22:51:32
3252 dnl --------------
3253 dnl This option causes manpages to be run through tbl(1) to generate tables
3254 dnl correctly.
3255 AC_DEFUN([CF_MANPAGE_TBL],
3256 [
3257 AC_MSG_CHECKING(for manpage tbl)
3258
3259 AC_ARG_WITH(manpage-tbl,
3260         [  --with-manpage-tbl      specify manpage processing with tbl],
3261         [MANPAGE_TBL=$withval],
3262         [MANPAGE_TBL=no])
3263
3264 AC_MSG_RESULT($MANPAGE_TBL)
3265 ])dnl
3266 dnl ---------------------------------------------------------------------------
3267 dnl CF_MAN_PAGES version: 35 updated: 2007/03/31 11:47:29
3268 dnl ------------
3269 dnl Try to determine if the man-pages on the system are compressed, and if
3270 dnl so, what format is used.  Use this information to construct a script that
3271 dnl will install man-pages.
3272 AC_DEFUN([CF_MAN_PAGES],
3273 [
3274 CF_HELP_MESSAGE(Options to Specify How Manpages are Installed:)
3275 CF_MANPAGE_FORMAT
3276 CF_MANPAGE_RENAMES
3277 CF_MANPAGE_SYMLINKS
3278 CF_MANPAGE_TBL
3279
3280   if test "$prefix" = "NONE" ; then
3281      cf_prefix="$ac_default_prefix"
3282   else
3283      cf_prefix="$prefix"
3284   fi
3285
3286   case "$MANPAGE_FORMAT" in # (vi
3287   *catonly*) # (vi
3288     cf_format=yes
3289     cf_inboth=no
3290     ;;
3291   *formatted*) # (vi
3292     cf_format=yes
3293     cf_inboth=yes
3294     ;;
3295   *)
3296     cf_format=no
3297     cf_inboth=no
3298     ;;
3299   esac
3300
3301 test ! -d man && mkdir man
3302
3303 cf_so_strip=
3304 cf_compress=
3305 case "$MANPAGE_FORMAT" in #(vi
3306 *compress*) #(vi
3307         cf_so_strip="Z"
3308         cf_compress=compress
3309   ;;
3310 *gzip*) #(vi
3311         cf_so_strip="gz"
3312         cf_compress=gzip
3313   ;;
3314 esac
3315
3316 cf_edit_man=./edit_man.sh
3317 cf_man_alias=`pwd`/man_alias.sed
3318
3319 cat >$cf_edit_man <<CF_EOF
3320 #! /bin/sh
3321 # this script is generated by the configure-script CF_MAN_PAGES macro.
3322
3323 prefix="$cf_prefix"
3324 datadir="$datadir"
3325
3326 NCURSES_MAJOR="$NCURSES_MAJOR"
3327 NCURSES_MINOR="$NCURSES_MINOR"
3328 NCURSES_PATCH="$NCURSES_PATCH"
3329
3330 NCURSES_OSPEED="$NCURSES_OSPEED"
3331 TERMINFO="$TERMINFO"
3332
3333 MKDIRS="sh `cd $srcdir && pwd`/mkdirs.sh"
3334
3335 INSTALL="$INSTALL"
3336 INSTALL_DATA="$INSTALL_DATA"
3337
3338 transform="$program_transform_name"
3339
3340 TMP=\${TMPDIR-/tmp}/man\$\$
3341 trap "rm -f \$TMP" 0 1 2 5 15
3342
3343 form=\[$]1
3344 shift || exit 1
3345
3346 verb=\[$]1
3347 shift || exit 1
3348
3349 mandir=\[$]1
3350 shift || exit 1
3351
3352 srcdir=\[$]1
3353 top_srcdir=\[$]srcdir/..
3354 shift || exit 1
3355
3356 if test "\$form" = normal ; then
3357         if test "$cf_format" = yes ; then
3358         if test "$cf_inboth" = no ; then
3359                 sh \[$]0 format \$verb \$mandir \$srcdir \[$]*
3360                 exit $?
3361         fi
3362         fi
3363         cf_subdir=\$mandir/man
3364         cf_tables=$MANPAGE_TBL
3365 else
3366         cf_subdir=\$mandir/cat
3367         cf_tables=yes
3368 fi
3369
3370 # process the list of source-files
3371 for i in \[$]* ; do
3372 case \$i in #(vi
3373 *.orig|*.rej) ;; #(vi
3374 *.[[0-9]]*)
3375         section=\`expr "\$i" : '.*\\.\\([[0-9]]\\)[[xm]]*'\`;
3376         if test \$verb = installing ; then
3377         if test ! -d \$cf_subdir\${section} ; then
3378                 \$MKDIRS \$cf_subdir\$section
3379         fi
3380         fi
3381
3382         # replace variables in man page
3383         if test ! -f $cf_man_alias ; then
3384 cat >>$cf_man_alias <<-CF_EOF2
3385                 s,@DATADIR@,\$datadir,g
3386                 s,@TERMINFO@,\$TERMINFO,g
3387                 s,@NCURSES_MAJOR@,\$NCURSES_MAJOR,g
3388                 s,@NCURSES_MINOR@,\$NCURSES_MINOR,g
3389                 s,@NCURSES_PATCH@,\$NCURSES_PATCH,g
3390                 s,@NCURSES_OSPEED@,\$NCURSES_OSPEED,g
3391 CF_EOF
3392         ifelse($1,,,[
3393         for cf_name in $1
3394         do
3395                 cf_NAME=`echo "$cf_name" | sed y%abcdefghijklmnopqrstuvwxyz./-%ABCDEFGHIJKLMNOPQRSTUVWXYZ___%`
3396                 cf_name=`echo $cf_name|sed "$program_transform_name"`
3397 cat >>$cf_edit_man <<-CF_EOF
3398                 s,@$cf_NAME@,$cf_name,
3399 CF_EOF
3400         done
3401         ])
3402 cat >>$cf_edit_man <<CF_EOF
3403 CF_EOF2
3404                 echo "...made $cf_man_alias"
3405         fi
3406
3407         aliases=
3408         cf_source=\`basename \$i\`
3409         inalias=\$cf_source
3410         test ! -f \$inalias && inalias="\$srcdir/\$inalias"
3411         if test ! -f \$inalias ; then
3412                 echo .. skipped \$cf_source
3413                 continue
3414         fi
3415 CF_EOF
3416
3417 if test "$MANPAGE_ALIASES" != no ; then
3418 cat >>$cf_edit_man <<CF_EOF
3419         aliases=\`sed -f \$top_srcdir/man/manlinks.sed \$inalias |sed -f $cf_man_alias | sort -u\`
3420 CF_EOF
3421 fi
3422
3423 if test "$MANPAGE_RENAMES" = no ; then
3424 cat >>$cf_edit_man <<CF_EOF
3425         # perform program transformations for section 1 man pages
3426         if test \$section = 1 ; then
3427                 cf_target=\$cf_subdir\${section}/\`echo \$cf_source|sed "\${transform}"\`
3428         else
3429                 cf_target=\$cf_subdir\${section}/\$cf_source
3430         fi
3431 CF_EOF
3432 else
3433 cat >>$cf_edit_man <<CF_EOF
3434         cf_target=\`grep "^\$cf_source" $MANPAGE_RENAMES | $AWK '{print \[$]2}'\`
3435         if test -z "\$cf_target" ; then
3436                 echo '? missing rename for '\$cf_source
3437                 cf_target="\$cf_source"
3438         fi
3439         cf_target="\$cf_subdir\${section}/\${cf_target}"
3440
3441 CF_EOF
3442 fi
3443
3444 cat >>$cf_edit_man <<CF_EOF
3445         sed     -f $cf_man_alias \\
3446 CF_EOF
3447
3448 if test -f $MANPAGE_RENAMES ; then
3449 cat >>$cf_edit_man <<CF_EOF
3450                 < \$i | sed -f `pwd`/edit_man.sed >\$TMP
3451 CF_EOF
3452 else
3453 cat >>$cf_edit_man <<CF_EOF
3454                 < \$i >\$TMP
3455 CF_EOF
3456 fi
3457
3458 cat >>$cf_edit_man <<CF_EOF
3459 if test \$cf_tables = yes ; then
3460         tbl \$TMP >\$TMP.out
3461         mv \$TMP.out \$TMP
3462 fi
3463 CF_EOF
3464
3465 if test $with_curses_h != yes ; then
3466 cat >>$cf_edit_man <<CF_EOF
3467         sed -e "/\#[    ]*include/s,curses.h,ncurses.h," < \$TMP >\$TMP.out
3468         mv \$TMP.out \$TMP
3469 CF_EOF
3470 fi
3471
3472 cat >>$cf_edit_man <<CF_EOF
3473         if test \$form = format ; then
3474                 nroff -man \$TMP >\$TMP.out
3475                 mv \$TMP.out \$TMP
3476         fi
3477 CF_EOF
3478
3479 if test -n "$cf_compress" ; then
3480 cat >>$cf_edit_man <<CF_EOF
3481         if test \$verb = installing ; then
3482         if ( $cf_compress -f \$TMP )
3483         then
3484                 mv \$TMP.$cf_so_strip \$TMP
3485         fi
3486         fi
3487         cf_target="\$cf_target.$cf_so_strip"
3488 CF_EOF
3489 fi
3490
3491 case "$MANPAGE_FORMAT" in #(vi
3492 *BSDI*)
3493 cat >>$cf_edit_man <<CF_EOF
3494         if test \$form = format ; then
3495                 # BSDI installs only .0 suffixes in the cat directories
3496                 cf_target="\`echo \$cf_target|sed -e 's/\.[[1-9]]\+[[a-z]]*/.0/'\`"
3497         fi
3498 CF_EOF
3499   ;;
3500 esac
3501
3502 cat >>$cf_edit_man <<CF_EOF
3503         suffix=\`basename \$cf_target | sed -e 's%^[[^.]]*%%'\`
3504         if test \$verb = installing ; then
3505                 echo \$verb \$cf_target
3506                 \$INSTALL_DATA \$TMP \$cf_target
3507                 test -d \$cf_subdir\${section} &&
3508                 test -n "\$aliases" && (
3509                         cd \$cf_subdir\${section} && (
3510                                 cf_source=\`echo \$cf_target |sed -e 's%^.*/\([[^/]][[^/]]*/[[^/]][[^/]]*$\)%\1%'\`
3511                                 test -n "$cf_so_strip" && cf_source=\`echo \$cf_source |sed -e 's%\.$cf_so_strip\$%%'\`
3512                                 cf_target=\`basename \$cf_target\`
3513                                 for cf_alias in \$aliases
3514                                 do
3515                                         if test \$section = 1 ; then
3516                                                 cf_alias=\`echo \$cf_alias|sed "\${transform}"\`
3517                                         fi
3518
3519                                         if test "$MANPAGE_SYMLINKS" = yes ; then
3520                                                 if test -f \$cf_alias\${suffix} ; then
3521                                                         if ( cmp -s \$cf_target \$cf_alias\${suffix} )
3522                                                         then
3523                                                                 continue
3524                                                         fi
3525                                                 fi
3526                                                 echo .. \$verb alias \$cf_alias\${suffix}
3527                                                 rm -f \$cf_alias\${suffix}
3528                                                 $LN_S \$cf_target \$cf_alias\${suffix}
3529                                         elif test "\$cf_target" != "\$cf_alias\${suffix}" ; then
3530                                                 echo ".so \$cf_source" >\$TMP
3531 CF_EOF
3532 if test -n "$cf_compress" ; then
3533 cat >>$cf_edit_man <<CF_EOF
3534                                                 if test -n "$cf_so_strip" ; then
3535                                                         $cf_compress -f \$TMP
3536                                                         mv \$TMP.$cf_so_strip \$TMP
3537                                                 fi
3538 CF_EOF
3539 fi
3540 cat >>$cf_edit_man <<CF_EOF
3541                                                 echo .. \$verb alias \$cf_alias\${suffix}
3542                                                 rm -f \$cf_alias\${suffix}
3543                                                 \$INSTALL_DATA \$TMP \$cf_alias\${suffix}
3544                                         fi
3545                                 done
3546                         )
3547                 )
3548         elif test \$verb = removing ; then
3549                 test -f \$cf_target && (
3550                         echo \$verb \$cf_target
3551                         rm -f \$cf_target
3552                 )
3553                 test -d \$cf_subdir\${section} &&
3554                 test -n "\$aliases" && (
3555                         cd \$cf_subdir\${section} && (
3556                                 for cf_alias in \$aliases
3557                                 do
3558                                         if test \$section = 1 ; then
3559                                                 cf_alias=\`echo \$cf_alias|sed "\${transform}"\`
3560                                         fi
3561
3562                                         echo .. \$verb alias \$cf_alias\${suffix}
3563                                         rm -f \$cf_alias\${suffix}
3564                                 done
3565                         )
3566                 )
3567         else
3568 #               echo ".hy 0"
3569                 cat \$TMP
3570         fi
3571         ;;
3572 esac
3573 done
3574
3575 if test $cf_inboth = yes ; then
3576 if test \$form != format ; then
3577         sh \[$]0 format \$verb \$mandir \$srcdir \[$]*
3578 fi
3579 fi
3580
3581 exit 0
3582 CF_EOF
3583 chmod 755 $cf_edit_man
3584
3585 ])dnl
3586 dnl ---------------------------------------------------------------------------
3587 dnl CF_MATH_LIB version: 5 updated: 2000/05/28 01:39:10
3588 dnl -----------
3589 dnl Checks for libraries.  At least one UNIX system, Apple Macintosh
3590 dnl Rhapsody 5.5, does not have -lm.  We cannot use the simpler
3591 dnl AC_CHECK_LIB(m,sin), because that fails for C++.
3592 AC_DEFUN([CF_MATH_LIB],
3593 [
3594 AC_CACHE_CHECK(if -lm needed for math functions,
3595         cf_cv_need_libm,[
3596         AC_TRY_LINK([
3597         #include <stdio.h>
3598         #include <math.h>
3599         ],
3600         [double x = rand(); printf("result = %g\n", ]ifelse($2,,sin(x),$2)[)],
3601         [cf_cv_need_libm=no],
3602         [cf_cv_need_libm=yes])])
3603 if test "$cf_cv_need_libm" = yes
3604 then
3605 ifelse($1,,[
3606         LIBS="$LIBS -lm"
3607 ],[$1=-lm])
3608 fi
3609 ])
3610 dnl ---------------------------------------------------------------------------
3611 dnl CF_MIXEDCASE_FILENAMES version: 3 updated: 2003/09/20 17:07:55
3612 dnl ----------------------
3613 dnl Check if the file-system supports mixed-case filenames.  If we're able to
3614 dnl create a lowercase name and see it as uppercase, it doesn't support that.
3615 AC_DEFUN([CF_MIXEDCASE_FILENAMES],
3616 [
3617 AC_CACHE_CHECK(if filesystem supports mixed-case filenames,cf_cv_mixedcase,[
3618 if test "$cross_compiling" = yes ; then
3619         case $target_alias in #(vi
3620         *-os2-emx*|*-msdosdjgpp*|*-cygwin*|*-mingw32*|*-uwin*) #(vi
3621                 cf_cv_mixedcase=no
3622                 ;;
3623         *)
3624                 cf_cv_mixedcase=yes
3625                 ;;
3626         esac
3627 else
3628         rm -f conftest CONFTEST
3629         echo test >conftest
3630         if test -f CONFTEST ; then
3631                 cf_cv_mixedcase=no
3632         else
3633                 cf_cv_mixedcase=yes
3634         fi
3635         rm -f conftest CONFTEST
3636 fi
3637 ])
3638 test "$cf_cv_mixedcase" = yes && AC_DEFINE(MIXEDCASE_FILENAMES)
3639 ])dnl
3640 dnl ---------------------------------------------------------------------------
3641 dnl CF_MKSTEMP version: 5 updated: 2006/12/16 12:33:30
3642 dnl ----------
3643 dnl Check for a working mkstemp.  This creates two files, checks that they are
3644 dnl successfully created and distinct (AmigaOS apparently fails on the last).
3645 AC_DEFUN([CF_MKSTEMP],[
3646 AC_CACHE_CHECK(for working mkstemp, cf_cv_func_mkstemp,[
3647 rm -f conftest*
3648 AC_TRY_RUN([
3649 #include <sys/types.h>
3650 #include <stdlib.h>
3651 #include <stdio.h>
3652 #include <string.h>
3653 #include <sys/stat.h>
3654 int main()
3655 {
3656         char *tmpl = "conftestXXXXXX";
3657         char name[2][80];
3658         int n;
3659         int result = 0;
3660         int fd;
3661         struct stat sb;
3662
3663         umask(077);
3664         for (n = 0; n < 2; ++n) {
3665                 strcpy(name[n], tmpl);
3666                 if ((fd = mkstemp(name[n])) >= 0) {
3667                         if (!strcmp(name[n], tmpl)
3668                          || stat(name[n], &sb) != 0
3669                          || (sb.st_mode & S_IFMT) != S_IFREG
3670                          || (sb.st_mode & 077) != 0) {
3671                                 result = 1;
3672                         }
3673                         close(fd);
3674                 }
3675         }
3676         if (result == 0
3677          && !strcmp(name[0], name[1]))
3678                 result = 1;
3679         ${cf_cv_main_return:-return}(result);
3680 }
3681 ],[cf_cv_func_mkstemp=yes
3682 ],[cf_cv_func_mkstemp=no
3683 ],[AC_CHECK_FUNC(mkstemp)
3684 ])
3685 ])
3686 if test "$cf_cv_func_mkstemp" = yes ; then
3687         AC_DEFINE(HAVE_MKSTEMP)
3688 fi
3689 ])dnl
3690 dnl ---------------------------------------------------------------------------
3691 dnl CF_MSG_LOG version: 4 updated: 2007/07/29 09:55:12
3692 dnl ----------
3693 dnl Write a debug message to config.log, along with the line number in the
3694 dnl configure script.
3695 AC_DEFUN([CF_MSG_LOG],[
3696 echo "${as_me-configure}:__oline__: testing $* ..." 1>&AC_FD_CC
3697 ])dnl
3698 dnl ---------------------------------------------------------------------------
3699 dnl CF_NCURSES_ABI_6 version: 1 updated: 2005/09/17 18:42:49
3700 dnl ----------------
3701 dnl Set ncurses' ABI to 6 unless overridden by explicit configure option, and
3702 dnl warn about this.
3703 AC_DEFUN([CF_NCURSES_ABI_6],[
3704 if test "${with_abi_version+set}" != set; then
3705         case $cf_cv_rel_version in
3706         5.*)
3707                 cf_cv_rel_version=6.0
3708                 cf_cv_abi_version=6
3709                 AC_MSG_WARN(Overriding ABI version to $cf_cv_abi_version)
3710                 ;;
3711         esac
3712 fi
3713 ])dnl
3714 dnl ---------------------------------------------------------------------------
3715 dnl CF_NO_LEAKS_OPTION version: 4 updated: 2006/12/16 14:24:05
3716 dnl ------------------
3717 dnl see CF_WITH_NO_LEAKS
3718 AC_DEFUN([CF_NO_LEAKS_OPTION],[
3719 AC_MSG_CHECKING(if you want to use $1 for testing)
3720 AC_ARG_WITH($1,
3721         [$2],
3722         [AC_DEFINE($3)ifelse([$4],,[
3723          $4
3724 ])
3725         : ${with_cflags:=-g}
3726         : ${with_no_leaks:=yes}
3727          with_$1=yes],
3728         [with_$1=])
3729 AC_MSG_RESULT(${with_$1:-no})
3730
3731 case .$with_cflags in #(vi
3732 .*-g*)
3733         case .$CFLAGS in #(vi
3734         .*-g*) #(vi
3735                 ;;
3736         *)
3737                 CF_ADD_CFLAGS([-g])
3738                 ;;
3739         esac
3740         ;;
3741 esac
3742 ])dnl
3743 dnl ---------------------------------------------------------------------------
3744 dnl CF_NUMBER_SYNTAX version: 1 updated: 2003/09/20 18:12:49
3745 dnl ----------------
3746 dnl Check if the given variable is a number.  If not, report an error.
3747 dnl $1 is the variable
3748 dnl $2 is the message
3749 AC_DEFUN([CF_NUMBER_SYNTAX],[
3750 if test -n "$1" ; then
3751   case $1 in #(vi
3752   [[0-9]]*) #(vi
3753         ;;
3754   *)
3755         AC_MSG_ERROR($2 is not a number: $1)
3756         ;;
3757   esac
3758 else
3759   AC_MSG_ERROR($2 value is empty)
3760 fi
3761 ])dnl
3762 dnl ---------------------------------------------------------------------------
3763 dnl CF_OBJ_SUBDIR version: 4 updated: 2002/02/23 20:38:31
3764 dnl -------------
3765 dnl Compute the object-directory name from the given model name
3766 AC_DEFUN([CF_OBJ_SUBDIR],
3767 [
3768         case $1 in
3769         libtool) $2='obj_lo'  ;;
3770         normal)  $2='objects' ;;
3771         debug)   $2='obj_g' ;;
3772         profile) $2='obj_p' ;;
3773         shared)
3774                 case $cf_cv_system_name in #(vi
3775                 cygwin) #(vi
3776                         $2='objects' ;;
3777                 *)
3778                         $2='obj_s' ;;
3779                 esac
3780         esac
3781 ])dnl
3782 dnl ---------------------------------------------------------------------------
3783 dnl CF_PATHSEP version: 4 updated: 2009/01/11 20:30:23
3784 dnl ----------
3785 dnl Provide a value for the $PATH and similar separator
3786 AC_DEFUN([CF_PATHSEP],
3787 [
3788         case $cf_cv_system_name in
3789         os2*)   PATH_SEPARATOR=';'  ;;
3790         *)      PATH_SEPARATOR=':'  ;;
3791         esac
3792 ifelse($1,,,[$1=$PATH_SEPARATOR])
3793         AC_SUBST(PATH_SEPARATOR)
3794 ])dnl
3795 dnl ---------------------------------------------------------------------------
3796 dnl CF_PATH_SYNTAX version: 12 updated: 2008/03/23 14:45:59
3797 dnl --------------
3798 dnl Check the argument to see that it looks like a pathname.  Rewrite it if it
3799 dnl begins with one of the prefix/exec_prefix variables, and then again if the
3800 dnl result begins with 'NONE'.  This is necessary to work around autoconf's
3801 dnl delayed evaluation of those symbols.
3802 AC_DEFUN([CF_PATH_SYNTAX],[
3803 if test "x$prefix" != xNONE; then
3804   cf_path_syntax="$prefix"
3805 else
3806   cf_path_syntax="$ac_default_prefix"
3807 fi
3808
3809 case ".[$]$1" in #(vi
3810 .\[$]\(*\)*|.\'*\'*) #(vi
3811   ;;
3812 ..|./*|.\\*) #(vi
3813   ;;
3814 .[[a-zA-Z]]:[[\\/]]*) #(vi OS/2 EMX
3815   ;;
3816 .\[$]{*prefix}*) #(vi
3817   eval $1="[$]$1"
3818   case ".[$]$1" in #(vi
3819   .NONE/*)
3820     $1=`echo [$]$1 | sed -e s%NONE%$cf_path_syntax%`
3821     ;;
3822   esac
3823   ;; #(vi
3824 .no|.NONE/*)
3825   $1=`echo [$]$1 | sed -e s%NONE%$cf_path_syntax%`
3826   ;;
3827 *)
3828   ifelse($2,,[AC_MSG_ERROR([expected a pathname, not \"[$]$1\"])],$2)
3829   ;;
3830 esac
3831 ])dnl
3832 dnl ---------------------------------------------------------------------------
3833 dnl CF_PKG_CONFIG version: 3 updated: 2009/01/25 10:55:09
3834 dnl -------------
3835 dnl Check for the package-config program, unless disabled by command-line.
3836 AC_DEFUN([CF_PKG_CONFIG],
3837 [
3838 AC_MSG_CHECKING(if you want to use pkg-config)
3839 AC_ARG_WITH(pkg-config,
3840         [  --with-pkg-config{=path} enable/disable use of pkg-config],
3841         [cf_pkg_config=$withval],
3842         [cf_pkg_config=yes])
3843 AC_MSG_RESULT($cf_pkg_config)
3844
3845 case $cf_pkg_config in #(vi
3846 no) #(vi
3847         PKG_CONFIG=none
3848         ;;
3849 yes) #(vi
3850         AC_PATH_PROG(PKG_CONFIG, pkg-config, none)
3851         ;;
3852 *)
3853         PKG_CONFIG=$withval
3854         ;;
3855 esac
3856
3857 test -z "$PKG_CONFIG" && PKG_CONFIG=none
3858 if test "$PKG_CONFIG" != none ; then
3859         CF_PATH_SYNTAX(PKG_CONFIG)
3860 fi
3861
3862 AC_SUBST(PKG_CONFIG)
3863 ])dnl
3864 dnl ---------------------------------------------------------------------------
3865 dnl CF_POSIX_C_SOURCE version: 6 updated: 2005/07/14 20:25:10
3866 dnl -----------------
3867 dnl Define _POSIX_C_SOURCE to the given level, and _POSIX_SOURCE if needed.
3868 dnl
3869 dnl     POSIX.1-1990                            _POSIX_SOURCE
3870 dnl     POSIX.1-1990 and                        _POSIX_SOURCE and
3871 dnl             POSIX.2-1992 C-Language                 _POSIX_C_SOURCE=2
3872 dnl             Bindings Option
3873 dnl     POSIX.1b-1993                           _POSIX_C_SOURCE=199309L
3874 dnl     POSIX.1c-1996                           _POSIX_C_SOURCE=199506L
3875 dnl     X/Open 2000                             _POSIX_C_SOURCE=200112L
3876 dnl
3877 dnl Parameters:
3878 dnl     $1 is the nominal value for _POSIX_C_SOURCE
3879 AC_DEFUN([CF_POSIX_C_SOURCE],
3880 [
3881 cf_POSIX_C_SOURCE=ifelse($1,,199506L,$1)
3882
3883 cf_save_CFLAGS="$CFLAGS"
3884 cf_save_CPPFLAGS="$CPPFLAGS"
3885
3886 CF_REMOVE_DEFINE(cf_trim_CFLAGS,$cf_save_CFLAGS,_POSIX_C_SOURCE)
3887 CF_REMOVE_DEFINE(cf_trim_CPPFLAGS,$cf_save_CPPFLAGS,_POSIX_C_SOURCE)
3888
3889 AC_CACHE_CHECK(if we should define _POSIX_C_SOURCE,cf_cv_posix_c_source,[
3890         CF_MSG_LOG(if the symbol is already defined go no further)
3891         AC_TRY_COMPILE([#include <sys/types.h>],[
3892 #ifndef _POSIX_C_SOURCE
3893 make an error
3894 #endif],
3895         [cf_cv_posix_c_source=no],
3896         [cf_want_posix_source=no
3897          case .$cf_POSIX_C_SOURCE in #(vi
3898          .[[12]]??*) #(vi
3899                 cf_cv_posix_c_source="-D_POSIX_C_SOURCE=$cf_POSIX_C_SOURCE"
3900                 ;;
3901          .2) #(vi
3902                 cf_cv_posix_c_source="-D_POSIX_C_SOURCE=$cf_POSIX_C_SOURCE"
3903                 cf_want_posix_source=yes
3904                 ;;
3905          .*)
3906                 cf_want_posix_source=yes
3907                 ;;
3908          esac
3909          if test "$cf_want_posix_source" = yes ; then
3910                 AC_TRY_COMPILE([#include <sys/types.h>],[
3911 #ifdef _POSIX_SOURCE
3912 make an error
3913 #endif],[],
3914                 cf_cv_posix_c_source="$cf_cv_posix_c_source -D_POSIX_SOURCE")
3915          fi
3916          CF_MSG_LOG(ifdef from value $cf_POSIX_C_SOURCE)
3917          CFLAGS="$cf_trim_CFLAGS"
3918          CPPFLAGS="$cf_trim_CPPFLAGS $cf_cv_posix_c_source"
3919          CF_MSG_LOG(if the second compile does not leave our definition intact error)
3920          AC_TRY_COMPILE([#include <sys/types.h>],[
3921 #ifndef _POSIX_C_SOURCE
3922 make an error
3923 #endif],,
3924          [cf_cv_posix_c_source=no])
3925          CFLAGS="$cf_save_CFLAGS"
3926          CPPFLAGS="$cf_save_CPPFLAGS"
3927         ])
3928 ])
3929
3930 if test "$cf_cv_posix_c_source" != no ; then
3931         CFLAGS="$cf_trim_CFLAGS"
3932         CPPFLAGS="$cf_trim_CPPFLAGS"
3933         if test "$cf_cv_cc_u_d_options" = yes ; then
3934                 cf_temp_posix_c_source=`echo "$cf_cv_posix_c_source" | \
3935                                 sed -e 's/-D/-U/g' -e 's/=[[^   ]]*//g'`
3936                 CPPFLAGS="$CPPFLAGS $cf_temp_posix_c_source"
3937         fi
3938         CPPFLAGS="$CPPFLAGS $cf_cv_posix_c_source"
3939 fi
3940
3941 ])dnl
3942 dnl ---------------------------------------------------------------------------
3943 dnl CF_PREDEFINE version: 1 updated: 2003/07/26 17:53:56
3944 dnl ------------
3945 dnl Add definitions to CPPFLAGS to ensure they're predefined for all compiles.
3946 dnl
3947 dnl $1 = symbol to test
3948 dnl $2 = value (if any) to use for a predefinition
3949 AC_DEFUN([CF_PREDEFINE],
3950 [
3951 AC_MSG_CHECKING(if we must define $1)
3952 AC_TRY_COMPILE([#include <sys/types.h>
3953 ],[
3954 #ifndef $1
3955 make an error
3956 #endif],[cf_result=no],[cf_result=yes])
3957 AC_MSG_RESULT($cf_result)
3958
3959 if test "$cf_result" = yes ; then
3960         CPPFLAGS="$CPPFLAGS ifelse($2,,-D$1,[-D$1=$2])"
3961 elif test "x$2" != "x" ; then
3962         AC_MSG_CHECKING(checking for compatible value versus $2)
3963         AC_TRY_COMPILE([#include <sys/types.h>
3964 ],[
3965 #if $1-$2 < 0
3966 make an error
3967 #endif],[cf_result=yes],[cf_result=no])
3968         AC_MSG_RESULT($cf_result)
3969         if test "$cf_result" = no ; then
3970                 # perhaps we can override it - try...
3971                 CPPFLAGS="$CPPFLAGS -D$1=$2"
3972         fi
3973 fi
3974 ])dnl
3975 dnl ---------------------------------------------------------------------------
3976 dnl CF_PRG_RULES version: 1 updated: 2006/06/03 11:45:08
3977 dnl ------------
3978 dnl Append definitions and rules for the given programs to the subdirectory
3979 dnl Makefiles, and the recursion rule for the top-level Makefile.
3980 dnl
3981 dnl parameters
3982 dnl     $1 = script to run
3983 dnl     $2 = list of subdirectories
3984 dnl
3985 dnl variables
3986 dnl     $AWK
3987 AC_DEFUN([CF_PRG_RULES],
3988 [
3989 for cf_dir in $2
3990 do
3991         if test ! -d $srcdir/$cf_dir; then
3992                 continue
3993         elif test -f $srcdir/$cf_dir/programs; then
3994                 $AWK -f $1 $srcdir/$cf_dir/programs >>$cf_dir/Makefile
3995         fi
3996 done
3997
3998 ])dnl
3999 dnl ---------------------------------------------------------------------------
4000 dnl CF_PROG_AR version: 1 updated: 2009/01/01 20:15:22
4001 dnl ----------
4002 dnl Check for archiver "ar".
4003 AC_DEFUN([CF_PROG_AR],[
4004 AC_CHECK_TOOL(AR, ar, ar)
4005 ])
4006 dnl ---------------------------------------------------------------------------
4007 dnl CF_PROG_AWK version: 1 updated: 2006/09/16 11:40:59
4008 dnl -----------
4009 dnl Check for awk, ensure that the check found something.
4010 AC_DEFUN([CF_PROG_AWK],
4011 [
4012 AC_PROG_AWK
4013 test -z "$AWK" && AC_MSG_ERROR(No awk program found)
4014 ])dnl
4015 dnl ---------------------------------------------------------------------------
4016 dnl CF_PROG_CC_C_O version: 2 updated: 2006/12/16 15:55:46
4017 dnl --------------
4018 dnl Analogous to AC_PROG_CC_C_O, but more useful: tests only $CC, ensures that
4019 dnl the output file can be renamed, and allows for a shell variable that can
4020 dnl be used later.  The parameter is either CC or CXX.  The result is the
4021 dnl cache variable:
4022 dnl     $cf_cv_prog_CC_c_o
4023 dnl     $cf_cv_prog_CXX_c_o
4024 AC_DEFUN([CF_PROG_CC_C_O],
4025 [AC_REQUIRE([AC_PROG_CC])dnl
4026 AC_MSG_CHECKING([whether [$]$1 understands -c and -o together])
4027 AC_CACHE_VAL(cf_cv_prog_$1_c_o,
4028 [
4029 cat > conftest.$ac_ext <<CF_EOF
4030 #include <stdio.h>
4031 int main()
4032 {
4033         ${cf_cv_main_return:-return}(0);
4034 }
4035 CF_EOF
4036 # We do the test twice because some compilers refuse to overwrite an
4037 # existing .o file with -o, though they will create one.
4038 ac_try='[$]$1 -c conftest.$ac_ext -o conftest2.$ac_objext >&AC_FD_CC'
4039 if AC_TRY_EVAL(ac_try) &&
4040   test -f conftest2.$ac_objext && AC_TRY_EVAL(ac_try);
4041 then
4042   eval cf_cv_prog_$1_c_o=yes
4043 else
4044   eval cf_cv_prog_$1_c_o=no
4045 fi
4046 rm -f conftest*
4047 ])dnl
4048 if test $cf_cv_prog_$1_c_o = yes; then
4049   AC_MSG_RESULT([yes])
4050 else
4051   AC_MSG_RESULT([no])
4052 fi
4053 ])dnl
4054 dnl ---------------------------------------------------------------------------
4055 dnl CF_PROG_CC_U_D version: 1 updated: 2005/07/14 16:59:30
4056 dnl --------------
4057 dnl Check if C (preprocessor) -U and -D options are processed in the order
4058 dnl given rather than by type of option.  Some compilers insist on apply all
4059 dnl of the -U options after all of the -D options.  Others allow mixing them,
4060 dnl and may predefine symbols that conflict with those we define.
4061 AC_DEFUN([CF_PROG_CC_U_D],
4062 [
4063 AC_CACHE_CHECK(if $CC -U and -D options work together,cf_cv_cc_u_d_options,[
4064         cf_save_CPPFLAGS="$CPPFLAGS"
4065         CPPFLAGS="-UU_D_OPTIONS -DU_D_OPTIONS -DD_U_OPTIONS -UD_U_OPTIONS"
4066         AC_TRY_COMPILE([],[
4067 #ifndef U_D_OPTIONS
4068 make an undefined-error
4069 #endif
4070 #ifdef  D_U_OPTIONS
4071 make a defined-error
4072 #endif
4073         ],[
4074         cf_cv_cc_u_d_options=yes],[
4075         cf_cv_cc_u_d_options=no])
4076         CPPFLAGS="$cf_save_CPPFLAGS"
4077 ])
4078 ])dnl
4079 dnl ---------------------------------------------------------------------------
4080 dnl CF_PROG_EGREP version: 1 updated: 2006/09/16 11:40:59
4081 dnl -------------
4082 dnl AC_PROG_EGREP was introduced in autoconf 2.53.
4083 dnl This macro adds a check to ensure the script found something.
4084 AC_DEFUN([CF_PROG_EGREP],
4085 [AC_CACHE_CHECK([for egrep], [ac_cv_prog_egrep],
4086    [if echo a | (grep -E '(a|b)') >/dev/null 2>&1
4087     then ac_cv_prog_egrep='grep -E'
4088     else ac_cv_prog_egrep='egrep'
4089     fi])
4090  EGREP=$ac_cv_prog_egrep
4091  AC_SUBST([EGREP])
4092 test -z "$EGREP" && AC_MSG_ERROR(No egrep program found)
4093 ])dnl
4094 dnl ---------------------------------------------------------------------------
4095 dnl CF_PROG_EXT version: 10 updated: 2004/01/03 19:28:18
4096 dnl -----------
4097 dnl Compute $PROG_EXT, used for non-Unix ports, such as OS/2 EMX.
4098 AC_DEFUN([CF_PROG_EXT],
4099 [
4100 AC_REQUIRE([CF_CHECK_CACHE])
4101 case $cf_cv_system_name in
4102 os2*)
4103     CFLAGS="$CFLAGS -Zmt"
4104     CPPFLAGS="$CPPFLAGS -D__ST_MT_ERRNO__"
4105     CXXFLAGS="$CXXFLAGS -Zmt"
4106     # autoconf's macro sets -Zexe and suffix both, which conflict:w
4107     LDFLAGS="$LDFLAGS -Zmt -Zcrtdll"
4108     ac_cv_exeext=.exe
4109     ;;
4110 esac
4111
4112 AC_EXEEXT
4113 AC_OBJEXT
4114
4115 PROG_EXT="$EXEEXT"
4116 AC_SUBST(PROG_EXT)
4117 test -n "$PROG_EXT" && AC_DEFINE_UNQUOTED(PROG_EXT,"$PROG_EXT")
4118 ])dnl
4119 dnl ---------------------------------------------------------------------------
4120 dnl CF_PROG_INSTALL version: 5 updated: 2002/12/21 22:46:07
4121 dnl ---------------
4122 dnl Force $INSTALL to be an absolute-path.  Otherwise, edit_man.sh and the
4123 dnl misc/tabset install won't work properly.  Usually this happens only when
4124 dnl using the fallback mkinstalldirs script
4125 AC_DEFUN([CF_PROG_INSTALL],
4126 [AC_PROG_INSTALL
4127 case $INSTALL in
4128 /*)
4129   ;;
4130 *)
4131   CF_DIRNAME(cf_dir,$INSTALL)
4132   test -z "$cf_dir" && cf_dir=.
4133   INSTALL=`cd $cf_dir && pwd`/`echo $INSTALL | sed -e 's%^.*/%%'`
4134   ;;
4135 esac
4136 ])dnl
4137 dnl ---------------------------------------------------------------------------
4138 dnl CF_PROG_LDCONFIG version: 2 updated: 2008/12/13 14:08:40
4139 dnl ----------------
4140 dnl Check for ldconfig, needed to fixup shared libraries that would be built
4141 dnl and then used in the install.
4142 AC_DEFUN([CF_PROG_LDCONFIG],[
4143 if test "$cross_compiling" = yes ; then
4144   LDCONFIG=:
4145 else
4146 case "$cf_cv_system_name" in #(vi
4147 dragonfly*|freebsd*) #(vi
4148   test -z "$LDCONFIG" && LDCONFIG="/sbin/ldconfig -R"
4149   ;;
4150 *) LDPATH=$PATH:/sbin:/usr/sbin
4151   AC_PATH_PROG(LDCONFIG,ldconfig,,$LDPATH)
4152   ;;
4153 esac
4154 fi
4155 AC_SUBST(LDCONFIG)
4156 ])dnl
4157 dnl ---------------------------------------------------------------------------
4158 dnl CF_PROG_LINT version: 1 updated: 2006/09/16 11:40:59
4159 dnl ------------
4160 AC_DEFUN([CF_PROG_LINT],
4161 [
4162 AC_CHECK_PROGS(LINT, tdlint lint alint)
4163 AC_SUBST(LINT_OPTS)
4164 ])dnl
4165 dnl ---------------------------------------------------------------------------
4166 dnl CF_REGEX version: 3 updated: 1997/11/01 14:26:01
4167 dnl --------
4168 dnl Attempt to determine if we've got one of the flavors of regular-expression
4169 dnl code that we can support.
4170 AC_DEFUN([CF_REGEX],
4171 [
4172 AC_MSG_CHECKING([for regular-expression headers])
4173 AC_CACHE_VAL(cf_cv_regex,[
4174 AC_TRY_LINK([#include <sys/types.h>
4175 #include <regex.h>],[
4176         regex_t *p;
4177         int x = regcomp(p, "", 0);
4178         int y = regexec(p, "", 0, 0, 0);
4179         regfree(p);
4180         ],[cf_cv_regex="regex.h"],[
4181         AC_TRY_LINK([#include <regexp.h>],[
4182                 char *p = compile("", "", "", 0);
4183                 int x = step("", "");
4184         ],[cf_cv_regex="regexp.h"],[
4185                 cf_save_LIBS="$LIBS"
4186                 LIBS="-lgen $LIBS"
4187                 AC_TRY_LINK([#include <regexpr.h>],[
4188                         char *p = compile("", "", "");
4189                         int x = step("", "");
4190                 ],[cf_cv_regex="regexpr.h"],[LIBS="$cf_save_LIBS"])])])
4191 ])
4192 AC_MSG_RESULT($cf_cv_regex)
4193 case $cf_cv_regex in
4194         regex.h)   AC_DEFINE(HAVE_REGEX_H_FUNCS) ;;
4195         regexp.h)  AC_DEFINE(HAVE_REGEXP_H_FUNCS) ;;
4196         regexpr.h) AC_DEFINE(HAVE_REGEXPR_H_FUNCS) ;;
4197 esac
4198 ])dnl
4199 dnl ---------------------------------------------------------------------------
4200 dnl CF_REMOVE_DEFINE version: 2 updated: 2005/07/09 16:12:18
4201 dnl ----------------
4202 dnl Remove all -U and -D options that refer to the given symbol from a list
4203 dnl of C compiler options.  This works around the problem that not all
4204 dnl compilers process -U and -D options from left-to-right, so a -U option
4205 dnl cannot be used to cancel the effect of a preceding -D option.
4206 dnl
4207 dnl $1 = target (which could be the same as the source variable)
4208 dnl $2 = source (including '$')
4209 dnl $3 = symbol to remove
4210 define([CF_REMOVE_DEFINE],
4211 [
4212 # remove $3 symbol from $2
4213 $1=`echo "$2" | \
4214         sed     -e 's/-[[UD]]$3\(=[[^   ]]*\)\?[[       ]]/ /g' \
4215                 -e 's/-[[UD]]$3\(=[[^   ]]*\)\?[$]//g'`
4216 ])dnl
4217 dnl ---------------------------------------------------------------------------
4218 dnl CF_REMOVE_LIB version: 1 updated: 2007/02/17 14:11:52
4219 dnl -------------
4220 dnl Remove the given library from the symbol
4221 dnl
4222 dnl $1 = target (which could be the same as the source variable)
4223 dnl $2 = source (including '$')
4224 dnl $3 = library to remove
4225 define([CF_REMOVE_LIB],
4226 [
4227 # remove $3 library from $2
4228 $1=`echo "$2" | sed -e 's/-l$3[[        ]]//g' -e 's/-l$3[$]//'`
4229 ])dnl
4230 dnl ---------------------------------------------------------------------------
4231 dnl CF_RPATH_HACK version: 4 updated: 2008/09/13 12:53:26
4232 dnl -------------
4233 AC_DEFUN([CF_RPATH_HACK],
4234 [
4235 AC_REQUIRE([CF_SHARED_OPTS])
4236 AC_MSG_CHECKING(for updated LDFLAGS)
4237 if test -n "$LDFLAGS" ; then
4238 AC_MSG_RESULT(maybe)
4239 CF_VERBOSE(...checking LDFLAGS $LDFLAGS)
4240 CF_VERBOSE(...checking EXTRA_LDFLAGS $EXTRA_LDFLAGS)
4241 case "$EXTRA_LDFLAGS" in #(vi
4242 -Wl,-rpath,*) #(vi
4243         cf_rpath_hack="-Wl,-rpath,"
4244         ;;
4245 -R\ *)
4246         cf_rpath_hack="-R "
4247         ;;
4248 -R*)
4249         cf_rpath_hack="-R"
4250         ;;
4251 *)
4252         cf_rpath_hack=
4253         ;;
4254 esac
4255 if test -n "$cf_rpath_hack" ; then
4256         cf_rpath_dst=
4257         for cf_rpath_src in $LDFLAGS
4258         do
4259                 CF_VERBOSE(Filtering $cf_rpath_src)
4260                 case $cf_rpath_src in #(vi
4261                 -L*) #(vi
4262                         if test "$cf_rpath_hack" = "-R " ; then
4263                                 cf_rpath_tmp=`echo "$cf_rpath_src" |sed -e 's%-L%-R %'`
4264                         else
4265                                 cf_rpath_tmp=`echo "$cf_rpath_src" |sed -e s%-L%$cf_rpath_hack%`
4266                         fi
4267                         CF_VERBOSE(...Filter $cf_rpath_tmp)
4268                         EXTRA_LDFLAGS="$cf_rpath_tmp $EXTRA_LDFLAGS"
4269                         ;;
4270                 esac
4271                 cf_rpath_dst="$cf_rpath_dst $cf_rpath_src"
4272         done
4273         LDFLAGS=$cf_rpath_dst
4274         CF_VERBOSE(...checked LDFLAGS $LDFLAGS)
4275         CF_VERBOSE(...checked EXTRA_LDFLAGS $EXTRA_LDFLAGS)
4276 fi
4277 else
4278 AC_MSG_RESULT(no)
4279 fi
4280 ])dnl
4281 dnl ---------------------------------------------------------------------------
4282 dnl CF_SHARED_OPTS version: 57 updated: 2009/01/17 16:10:05
4283 dnl --------------
4284 dnl --------------
4285 dnl Attempt to determine the appropriate CC/LD options for creating a shared
4286 dnl library.
4287 dnl
4288 dnl Note: ${LOCAL_LDFLAGS} is used to link executables that will run within the
4289 dnl build-tree, i.e., by making use of the libraries that are compiled in ../lib
4290 dnl We avoid compiling-in a ../lib path for the shared library since that can
4291 dnl lead to unexpected results at runtime.
4292 dnl ${LOCAL_LDFLAGS2} has the same intention but assumes that the shared libraries
4293 dnl are compiled in ../../lib
4294 dnl
4295 dnl The variable 'cf_cv_do_symlinks' is used to control whether we configure
4296 dnl to install symbolic links to the rel/abi versions of shared libraries.
4297 dnl
4298 dnl The variable 'cf_cv_shlib_version' controls whether we use the rel or abi
4299 dnl version when making symbolic links.
4300 dnl
4301 dnl The variable 'cf_cv_shlib_version_infix' controls whether shared library
4302 dnl version numbers are infix (ex: libncurses.<ver>.dylib) or postfix
4303 dnl (ex: libncurses.so.<ver>).
4304 dnl
4305 dnl Some loaders leave 'so_locations' lying around.  It's nice to clean up.
4306 AC_DEFUN([CF_SHARED_OPTS],
4307 [
4308         AC_REQUIRE([CF_SUBST_NCURSES_VERSION])
4309         LOCAL_LDFLAGS=
4310         LOCAL_LDFLAGS2=
4311         LD_RPATH_OPT=
4312         LD_SHARED_OPTS=
4313         INSTALL_LIB="-m 644"
4314
4315         cf_cv_do_symlinks=no
4316
4317         AC_MSG_CHECKING(if release/abi version should be used for shared libs)
4318         AC_ARG_WITH(shlib-version,
4319         [  --with-shlib-version=X  Specify rel or abi version for shared libs],
4320         [test -z "$withval" && withval=auto
4321         case $withval in #(vi
4322         yes) #(vi
4323                 cf_cv_shlib_version=auto
4324                 ;;
4325         rel|abi|auto|no) #(vi
4326                 cf_cv_shlib_version=$withval
4327                 ;;
4328         *)
4329                 AC_MSG_ERROR([option value must be one of: rel, abi, auto or no])
4330                 ;;
4331         esac
4332         ],[cf_cv_shlib_version=auto])
4333         AC_MSG_RESULT($cf_cv_shlib_version)
4334
4335         cf_cv_rm_so_locs=no
4336
4337         # Some less-capable ports of gcc support only -fpic
4338         CC_SHARED_OPTS=
4339         if test "$GCC" = yes
4340         then
4341                 AC_MSG_CHECKING(which $CC option to use)
4342                 cf_save_CFLAGS="$CFLAGS"
4343                 for CC_SHARED_OPTS in -fPIC -fpic ''
4344                 do
4345                         CFLAGS="$cf_save_CFLAGS $CC_SHARED_OPTS"
4346                         AC_TRY_COMPILE([#include <stdio.h>],[int x = 1],[break],[])
4347                 done
4348                 AC_MSG_RESULT($CC_SHARED_OPTS)
4349                 CFLAGS="$cf_save_CFLAGS"
4350         fi
4351
4352         cf_cv_shlib_version_infix=no
4353
4354         case $cf_cv_system_name in
4355         aix[[56]]*)
4356                 if test "$GCC" = yes; then
4357                         CC_SHARED_OPTS=
4358                         MK_SHARED_LIB="$(CC) -shared"
4359                 fi
4360                 ;;
4361         beos*)
4362                 MK_SHARED_LIB='${CC} ${CFLAGS} -o $[@] -Xlinker -soname=`basename $[@]` -nostart -e 0'
4363                 ;;
4364         cygwin*)
4365                 CC_SHARED_OPTS=
4366                 MK_SHARED_LIB='sh ../mk_shared_lib.sh [$]@ [$]{CC} [$]{CFLAGS}'
4367                 cf_cv_shlib_version=cygdll
4368                 cf_cv_shlib_version_infix=cygdll
4369                 cat >mk_shared_lib.sh <<-CF_EOF
4370                 #!/bin/sh
4371                 SHARED_LIB=\[$]1
4372                 IMPORT_LIB=\`echo "\[$]1" | sed -e 's/cyg/lib/' -e 's/[[0-9]]*\.dll[$]/.dll.a/'\`
4373                 shift
4374                 cat <<-EOF
4375                 Linking shared library
4376                 ** SHARED_LIB \[$]SHARED_LIB
4377                 ** IMPORT_LIB \[$]IMPORT_LIB
4378 EOF
4379                 exec \[$]* -shared -Wl,--out-implib=../lib/\[$]{IMPORT_LIB} -Wl,--export-all-symbols -o ../lib/\[$]{SHARED_LIB}
4380 CF_EOF
4381                 chmod +x mk_shared_lib.sh
4382                 ;;
4383         darwin*)
4384                 EXTRA_CFLAGS="-no-cpp-precomp"
4385                 CC_SHARED_OPTS="-dynamic"
4386                 MK_SHARED_LIB='${CC} ${CFLAGS} -dynamiclib -install_name ${libdir}/`basename $[@]` -compatibility_version ${ABI_VERSION} -current_version ${ABI_VERSION} -o $[@]'
4387                 test "$cf_cv_shlib_version" = auto && cf_cv_shlib_version=abi
4388                 cf_cv_shlib_version_infix=yes
4389                 AC_CACHE_CHECK([if ld -search_paths_first works], cf_cv_ldflags_search_paths_first, [
4390                         cf_save_LDFLAGS=$LDFLAGS
4391                         LDFLAGS="$LDFLAGS -Wl,-search_paths_first"
4392                         AC_TRY_LINK(, [int i;], cf_cv_ldflags_search_paths_first=yes, cf_cv_ldflags_search_paths_first=no)
4393                                 LDFLAGS=$cf_save_LDFLAGS])
4394                 if test $cf_cv_ldflags_search_paths_first = yes; then
4395                         LDFLAGS="$LDFLAGS -Wl,-search_paths_first"
4396                 fi
4397                 ;;
4398         hpux*)
4399                 # (tested with gcc 2.7.2 -- I don't have c89)
4400                 if test "$GCC" = yes; then
4401                         LD_SHARED_OPTS='-Xlinker +b -Xlinker ${libdir}'
4402                 else
4403                         CC_SHARED_OPTS='+Z'
4404                         LD_SHARED_OPTS='-Wl,+b,${libdir}'
4405                 fi
4406                 MK_SHARED_LIB='${LD} +b ${libdir} -b -o $[@]'
4407                 # HP-UX shared libraries must be executable, and should be
4408                 # readonly to exploit a quirk in the memory manager.
4409                 INSTALL_LIB="-m 555"
4410                 ;;
4411         irix*)
4412                 if test "$cf_cv_ld_rpath" = yes ; then
4413                         if test "$GCC" = yes; then
4414                                 LD_RPATH_OPT="-Wl,-rpath,"
4415                                 EXTRA_LDFLAGS="-Wl,-rpath,\${libdir} $EXTRA_LDFLAGS"
4416                         else
4417                                 LD_RPATH_OPT="-rpath "
4418                                 EXTRA_LDFLAGS="-rpath \${libdir} $EXTRA_LDFLAGS"
4419                         fi
4420                 fi
4421                 # tested with IRIX 5.2 and 'cc'.
4422                 if test "$GCC" != yes; then
4423                         CC_SHARED_OPTS='-KPIC'
4424                         MK_SHARED_LIB='${CC} -shared -rdata_shared -soname `basename $[@]` -o $[@]'
4425                 else
4426                         MK_SHARED_LIB='${CC} -shared -Wl,-soname,`basename $[@]` -o $[@]'
4427                 fi
4428                 cf_cv_rm_so_locs=yes
4429                 ;;
4430         linux*|gnu*|k*bsd*-gnu)
4431                 if test "$DFT_LWR_MODEL" = "shared" ; then
4432                         LOCAL_LDFLAGS="-Wl,-rpath,\$(LOCAL_LIBDIR)"
4433                         LOCAL_LDFLAGS2="$LOCAL_LDFLAGS"
4434                 fi
4435                 if test "$cf_cv_ld_rpath" = yes ; then
4436                         LD_RPATH_OPT="-Wl,-rpath,"
4437                         EXTRA_LDFLAGS="-Wl,-rpath,\${libdir} $EXTRA_LDFLAGS"
4438                 fi
4439                 CF_SHARED_SONAME
4440                 MK_SHARED_LIB='${CC} ${CFLAGS} -shared -Wl,-soname,'$cf_cv_shared_soname',-stats,-lc -o $[@]'
4441                 ;;
4442         openbsd[[2-9]].*)
4443                 if test "$DFT_LWR_MODEL" = "shared" ; then
4444                         LOCAL_LDFLAGS="-Wl,-rpath,\$(LOCAL_LIBDIR)"
4445                         LOCAL_LDFLAGS2="$LOCAL_LDFLAGS"
4446                 fi
4447                 if test "$cf_cv_ld_rpath" = yes ; then
4448                         LD_RPATH_OPT="-Wl,-rpath,"
4449                         EXTRA_LDFLAGS="-Wl,-rpath,\${libdir} $EXTRA_LDFLAGS"
4450                 fi
4451                 CC_SHARED_OPTS="$CC_SHARED_OPTS -DPIC"
4452                 CF_SHARED_SONAME
4453                 MK_SHARED_LIB='${CC} ${CFLAGS} -shared -Wl,-Bshareable,-soname,'$cf_cv_shared_soname',-stats,-lc -o $[@]'
4454                 ;;
4455         nto-qnx*|openbsd*|freebsd[[12]].*)
4456                 CC_SHARED_OPTS="$CC_SHARED_OPTS -DPIC"
4457                 MK_SHARED_LIB='${LD} -Bshareable -o $[@]'
4458                 test "$cf_cv_shlib_version" = auto && cf_cv_shlib_version=rel
4459                 ;;
4460         freebsd*)
4461                 CC_SHARED_OPTS="$CC_SHARED_OPTS -DPIC"
4462                 if test "$DFT_LWR_MODEL" = "shared" && test "$cf_cv_ld_rpath" = yes ; then
4463                         LOCAL_LDFLAGS="-rpath \$(LOCAL_LIBDIR)"
4464                         LOCAL_LDFLAGS2="-rpath \${libdir} $LOCAL_LDFLAGS"
4465                         LD_RPATH_OPT="-rpath "
4466                         EXTRA_LDFLAGS="-rpath \${libdir} $EXTRA_LDFLAGS"
4467                 fi
4468                 CF_SHARED_SONAME
4469                 MK_SHARED_LIB='${LD} -shared -Bshareable -soname=`basename $[@]` -o $[@]'
4470                 ;;
4471         netbsd*)
4472                 CC_SHARED_OPTS="$CC_SHARED_OPTS -DPIC"
4473                 test "$cf_cv_ld_rpath" = yes && LD_RPATH_OPT="-Wl,-rpath,"
4474                 if test "$DFT_LWR_MODEL" = "shared" && test "$cf_cv_ld_rpath" = yes ; then
4475                         LOCAL_LDFLAGS="-Wl,-rpath,\$(LOCAL_LIBDIR)"
4476                         LOCAL_LDFLAGS2="$LOCAL_LDFLAGS"
4477                         EXTRA_LDFLAGS="-Wl,-rpath,\${libdir} $EXTRA_LDFLAGS"
4478                         if test "$cf_cv_shlib_version" = auto; then
4479                         if test -f /usr/libexec/ld.elf_so; then
4480                                 cf_cv_shlib_version=abi
4481                         else
4482                                 cf_cv_shlib_version=rel
4483                         fi
4484                         fi
4485                         CF_SHARED_SONAME
4486                         MK_SHARED_LIB='${CC} ${CFLAGS} -shared -Wl,-soname,'$cf_cv_shared_soname' -o $[@]'
4487                 else
4488                         MK_SHARED_LIB='${LD} -shared -Bshareable -o $[@]'
4489                 fi
4490                 ;;
4491         osf*|mls+*)
4492                 # tested with OSF/1 V3.2 and 'cc'
4493                 # tested with OSF/1 V3.2 and gcc 2.6.3 (but the c++ demo didn't
4494                 # link with shared libs).
4495                 MK_SHARED_LIB='${LD} -set_version ${REL_VERSION}:${ABI_VERSION} -expect_unresolved "*" -shared -soname `basename $[@]`'
4496                 case $host_os in
4497                 osf4*)
4498                         MK_SHARED_LIB="${MK_SHARED_LIB} -msym"
4499                         ;;
4500                 esac
4501                 MK_SHARED_LIB="${MK_SHARED_LIB}"' -o $[@]'
4502                 if test "$DFT_LWR_MODEL" = "shared" ; then
4503                         LOCAL_LDFLAGS="-Wl,-rpath,\$(LOCAL_LIBDIR)"
4504                         LOCAL_LDFLAGS2="$LOCAL_LDFLAGS"
4505                 fi
4506                 if test "$cf_cv_ld_rpath" = yes ; then
4507                         LD_RPATH_OPT="-rpath"
4508                         # EXTRA_LDFLAGS="$LOCAL_LDFLAGS $EXTRA_LDFLAGS"
4509                 fi
4510                 cf_cv_rm_so_locs=yes
4511                 ;;
4512         sco3.2v5*)  # (also uw2* and UW7) hops 13-Apr-98
4513                 # tested with osr5.0.5
4514                 if test "$GCC" != yes; then
4515                         CC_SHARED_OPTS='-belf -KPIC'
4516                 fi
4517                 MK_SHARED_LIB='${LD} -dy -G -h `basename $[@] .${REL_VERSION}`.${ABI_VERSION} -o [$]@'
4518                 if test "$cf_cv_ld_rpath" = yes ; then
4519                         # only way is to set LD_RUN_PATH but no switch for it
4520                         RUN_PATH=$libdir
4521                 fi
4522                 test "$cf_cv_shlib_version" = auto && cf_cv_shlib_version=rel
4523                 LINK_PROGS='LD_RUN_PATH=${libdir}'
4524                 LINK_TESTS='Pwd=`pwd`;LD_RUN_PATH=`dirname $${Pwd}`/lib'
4525                 ;;
4526         sunos4*)
4527                 # tested with SunOS 4.1.1 and gcc 2.7.0
4528                 if test "$GCC" != yes; then
4529                         CC_SHARED_OPTS='-KPIC'
4530                 fi
4531                 MK_SHARED_LIB='${LD} -assert pure-text -o $[@]'
4532                 test "$cf_cv_shlib_version" = auto && cf_cv_shlib_version=rel
4533                 ;;
4534         solaris2*)
4535                 # tested with SunOS 5.5.1 (solaris 2.5.1) and gcc 2.7.2
4536                 # tested with SunOS 5.10 (solaris 10) and gcc 3.4.3
4537                 if test "$DFT_LWR_MODEL" = "shared" ; then
4538                         LOCAL_LDFLAGS="-R \$(LOCAL_LIBDIR):\${libdir}"
4539                         LOCAL_LDFLAGS2="$LOCAL_LDFLAGS"
4540                 fi
4541                 if test "$cf_cv_ld_rpath" = yes ; then
4542                         LD_RPATH_OPT="-R"
4543                         EXTRA_LDFLAGS="$LOCAL_LDFLAGS $EXTRA_LDFLAGS"
4544                 fi
4545                 CF_SHARED_SONAME
4546                 if test "$GCC" != yes; then
4547                         cf_save_CFLAGS="$CFLAGS"
4548                         for cf_shared_opts in -xcode=pic13 -xcode=pic32 -Kpic -KPIC -O
4549                         do
4550                                 CFLAGS="$cf_shared_opts $cf_save_CFLAGS"
4551                                 AC_TRY_COMPILE([#include <stdio.h>],[printf("Hello\n");],[break])
4552                         done
4553                         CFLAGS="$cf_save_CFLAGS"
4554                         CC_SHARED_OPTS=$cf_shared_opts
4555                         MK_SHARED_LIB='${CC} -dy -G -h '$cf_cv_shared_soname' -o $[@]'
4556                 else
4557                         MK_SHARED_LIB='${CC} -shared -dy -G -h '$cf_cv_shared_soname' -o $[@]'
4558                 fi
4559                 ;;
4560         sysv5uw7*|unix_sv*)
4561                 # tested with UnixWare 7.1.0 (gcc 2.95.2 and cc)
4562                 if test "$GCC" != yes; then
4563                         CC_SHARED_OPTS='-KPIC'
4564                 fi
4565                 MK_SHARED_LIB='${LD} -d y -G -o [$]@'
4566                 ;;
4567         *)
4568                 CC_SHARED_OPTS='unknown'
4569                 MK_SHARED_LIB='echo unknown'
4570                 ;;
4571         esac
4572
4573         # This works if the last tokens in $MK_SHARED_LIB are the -o target.
4574         case "$cf_cv_shlib_version" in #(vi
4575         rel|abi)
4576                 case "$MK_SHARED_LIB" in #(vi
4577                 *'-o $[@]')
4578                         test "$cf_cv_do_symlinks" = no && cf_cv_do_symlinks=yes
4579                         ;;
4580                 *)
4581                         AC_MSG_WARN(ignored --with-shlib-version)
4582                         ;;
4583                 esac
4584                 ;;
4585         esac
4586
4587         if test -n "$LD_RPATH_OPT" ; then
4588                 AC_MSG_CHECKING(if we need a space after rpath option)
4589                 cf_save_LIBS="$LIBS"
4590                 LIBS="$LIBS ${LD_RPATH_OPT}$libdir"
4591                 AC_TRY_LINK(, , cf_rpath_space=no, cf_rpath_space=yes)
4592                 LIBS="$cf_save_LIBS"
4593                 AC_MSG_RESULT($cf_rpath_space)
4594                 test "$cf_rpath_space" = yes && LD_RPATH_OPT="$LD_RPATH_OPT "
4595                 MK_SHARED_LIB="$MK_SHARED_LIB $LD_RPATH_OPT\${libdir}"
4596         fi
4597
4598         AC_SUBST(CC_SHARED_OPTS)
4599         AC_SUBST(LD_RPATH_OPT)
4600         AC_SUBST(LD_SHARED_OPTS)
4601         AC_SUBST(MK_SHARED_LIB)
4602         AC_SUBST(LINK_PROGS)
4603         AC_SUBST(LINK_TESTS)
4604         AC_SUBST(EXTRA_LDFLAGS)
4605         AC_SUBST(LOCAL_LDFLAGS)
4606         AC_SUBST(LOCAL_LDFLAGS2)
4607         AC_SUBST(INSTALL_LIB)
4608 ])dnl
4609 dnl ---------------------------------------------------------------------------
4610 dnl CF_SHARED_SONAME version: 3 updated: 2008/09/08 18:34:43
4611 dnl ----------------
4612 dnl utility macro for CF_SHARED_OPTS, constructs "$cf_cv_shared_soname" for
4613 dnl substitution into MK_SHARED_LIB string for the "-soname" (or similar)
4614 dnl option.
4615 dnl
4616 dnl $1 is the default that should be used for "$cf_cv_shlib_version".
4617 dnl If missing, use "rel".
4618 define([CF_SHARED_SONAME],
4619 [
4620         test "$cf_cv_shlib_version" = auto && cf_cv_shlib_version=ifelse($1,,rel,$1)
4621         if test "$cf_cv_shlib_version" = rel; then
4622                 cf_cv_shared_soname='`basename $[@] .${REL_VERSION}`.${ABI_VERSION}'
4623         else
4624                 cf_cv_shared_soname='`basename $[@]`'
4625         fi
4626 ])
4627 dnl ---------------------------------------------------------------------------
4628 dnl CF_SIGWINCH version: 1 updated: 2006/04/02 16:41:09
4629 dnl -----------
4630 dnl Use this macro after CF_XOPEN_SOURCE, but do not require it (not all
4631 dnl programs need this test).
4632 dnl
4633 dnl This is really a MacOS X 10.4.3 workaround.  Defining _POSIX_C_SOURCE
4634 dnl forces SIGWINCH to be undefined (breaks xterm, ncurses).  Oddly, the struct
4635 dnl winsize declaration is left alone - we may revisit this if Apple choose to
4636 dnl break that part of the interface as well.
4637 AC_DEFUN([CF_SIGWINCH],
4638 [
4639 AC_CACHE_CHECK(if SIGWINCH is defined,cf_cv_define_sigwinch,[
4640         AC_TRY_COMPILE([
4641 #include <sys/types.h>
4642 #include <sys/signal.h>
4643 ],[int x = SIGWINCH],
4644         [cf_cv_define_sigwinch=yes],
4645         [AC_TRY_COMPILE([
4646 #undef _XOPEN_SOURCE
4647 #undef _POSIX_SOURCE
4648 #undef _POSIX_C_SOURCE
4649 #include <sys/types.h>
4650 #include <sys/signal.h>
4651 ],[int x = SIGWINCH],
4652         [cf_cv_define_sigwinch=maybe],
4653         [cf_cv_define_sigwinch=no])
4654 ])
4655 ])
4656
4657 if test "$cf_cv_define_sigwinch" = maybe ; then
4658 AC_CACHE_CHECK(for actual SIGWINCH definition,cf_cv_fixup_sigwinch,[
4659 cf_cv_fixup_sigwinch=unknown
4660 cf_sigwinch=32
4661 while test $cf_sigwinch != 1
4662 do
4663         AC_TRY_COMPILE([
4664 #undef _XOPEN_SOURCE
4665 #undef _POSIX_SOURCE
4666 #undef _POSIX_C_SOURCE
4667 #include <sys/types.h>
4668 #include <sys/signal.h>
4669 ],[
4670 #if SIGWINCH != $cf_sigwinch
4671 make an error
4672 #endif
4673 int x = SIGWINCH],
4674         [cf_cv_fixup_sigwinch=$cf_sigwinch
4675          break])
4676
4677 cf_sigwinch=`expr $cf_sigwinch - 1`
4678 done
4679 ])
4680
4681         if test "$cf_cv_fixup_sigwinch" != unknown ; then
4682                 CPPFLAGS="$CPPFLAGS -DSIGWINCH=$cf_cv_fixup_sigwinch"
4683         fi
4684 fi
4685 ])dnl
4686 dnl ---------------------------------------------------------------------------
4687 dnl CF_SIG_ATOMIC_T version: 2 updated: 2005/09/18 17:27:12
4688 dnl ---------------
4689 dnl signal handler, but there are some gcc depedencies in that recommendation.
4690 dnl Try anyway.
4691 AC_DEFUN([CF_SIG_ATOMIC_T],
4692 [
4693 AC_MSG_CHECKING(for signal global datatype)
4694 AC_CACHE_VAL(cf_cv_sig_atomic_t,[
4695         for cf_type in \
4696                 "volatile sig_atomic_t" \
4697                 "sig_atomic_t" \
4698                 "int"
4699         do
4700         AC_TRY_COMPILE([
4701 #include <sys/types.h>
4702 #include <signal.h>
4703 #include <stdio.h>
4704
4705 extern $cf_type x;
4706 $cf_type x;
4707 static void handler(int sig)
4708 {
4709         x = 5;
4710 }],
4711                 [signal(SIGINT, handler);
4712                  x = 1],
4713                 [cf_cv_sig_atomic_t=$cf_type],
4714                 [cf_cv_sig_atomic_t=no])
4715                 test "$cf_cv_sig_atomic_t" != no && break
4716         done
4717         ])
4718 AC_MSG_RESULT($cf_cv_sig_atomic_t)
4719 test "$cf_cv_sig_atomic_t" != no && AC_DEFINE_UNQUOTED(SIG_ATOMIC_T, $cf_cv_sig_atomic_t)
4720 ])dnl
4721 dnl ---------------------------------------------------------------------------
4722 dnl CF_SIZECHANGE version: 8 updated: 2000/11/04 12:22:16
4723 dnl -------------
4724 dnl Check for definitions & structures needed for window size-changing
4725 dnl FIXME: check that this works with "snake" (HP-UX 10.x)
4726 AC_DEFUN([CF_SIZECHANGE],
4727 [
4728 AC_REQUIRE([CF_STRUCT_TERMIOS])
4729 AC_CACHE_CHECK(declaration of size-change, cf_cv_sizechange,[
4730     cf_cv_sizechange=unknown
4731     cf_save_CPPFLAGS="$CPPFLAGS"
4732
4733 for cf_opts in "" "NEED_PTEM_H"
4734 do
4735
4736     CPPFLAGS="$cf_save_CPPFLAGS"
4737     test -n "$cf_opts" && CPPFLAGS="$CPPFLAGS -D$cf_opts"
4738     AC_TRY_COMPILE([#include <sys/types.h>
4739 #ifdef HAVE_TERMIOS_H
4740 #include <termios.h>
4741 #else
4742 #ifdef HAVE_TERMIO_H
4743 #include <termio.h>
4744 #endif
4745 #endif
4746 #ifdef NEED_PTEM_H
4747 /* This is a workaround for SCO:  they neglected to define struct winsize in
4748  * termios.h -- it's only in termio.h and ptem.h
4749  */
4750 #include        <sys/stream.h>
4751 #include        <sys/ptem.h>
4752 #endif
4753 #if !defined(sun) || !defined(HAVE_TERMIOS_H)
4754 #include <sys/ioctl.h>
4755 #endif
4756 ],[
4757 #ifdef TIOCGSIZE
4758         struct ttysize win;     /* FIXME: what system is this? */
4759         int y = win.ts_lines;
4760         int x = win.ts_cols;
4761 #else
4762 #ifdef TIOCGWINSZ
4763         struct winsize win;
4764         int y = win.ws_row;
4765         int x = win.ws_col;
4766 #else
4767         no TIOCGSIZE or TIOCGWINSZ
4768 #endif /* TIOCGWINSZ */
4769 #endif /* TIOCGSIZE */
4770         ],
4771         [cf_cv_sizechange=yes],
4772         [cf_cv_sizechange=no])
4773
4774         CPPFLAGS="$cf_save_CPPFLAGS"
4775         if test "$cf_cv_sizechange" = yes ; then
4776                 echo "size-change succeeded ($cf_opts)" >&AC_FD_CC
4777                 test -n "$cf_opts" && cf_cv_sizechange="$cf_opts"
4778                 break
4779         fi
4780 done
4781 ])
4782 if test "$cf_cv_sizechange" != no ; then
4783         AC_DEFINE(HAVE_SIZECHANGE)
4784         case $cf_cv_sizechange in #(vi
4785         NEED*)
4786                 AC_DEFINE_UNQUOTED($cf_cv_sizechange )
4787                 ;;
4788         esac
4789 fi
4790 ])dnl
4791 dnl ---------------------------------------------------------------------------
4792 dnl CF_SRC_MODULES version: 20 updated: 2008/12/27 12:30:03
4793 dnl --------------
4794 dnl For each parameter, test if the source-directory exists, and if it contains
4795 dnl a 'modules' file.  If so, add to the list $cf_cv_src_modules which we'll
4796 dnl use in CF_LIB_RULES.
4797 dnl
4798 dnl This uses the configured value to make the lists SRC_SUBDIRS and
4799 dnl SUB_MAKEFILES which are used in the makefile-generation scheme.
4800 AC_DEFUN([CF_SRC_MODULES],
4801 [
4802 AC_MSG_CHECKING(for src modules)
4803
4804 # dependencies and linker-arguments for test-programs
4805 TEST_DEPS="${LIB_DIR}/${LIB_PREFIX}${LIB_NAME}${DFT_DEP_SUFFIX} $TEST_DEPS"
4806 TEST_DEP2="${LIB_2ND}/${LIB_PREFIX}${LIB_NAME}${DFT_DEP_SUFFIX} $TEST_DEP2"
4807 if test "$DFT_LWR_MODEL" = "libtool"; then
4808         TEST_ARGS="${TEST_DEPS}"
4809         TEST_ARG2="${TEST_DEP2}"
4810 else
4811         TEST_ARGS="-l${LIB_NAME}${DFT_ARG_SUFFIX} $TEST_ARGS"
4812         TEST_ARG2="-l${LIB_NAME}${DFT_ARG_SUFFIX} $TEST_ARG2"
4813 fi
4814
4815 cf_cv_src_modules=
4816 for cf_dir in $1
4817 do
4818         if test -f $srcdir/$cf_dir/modules; then
4819
4820                 # We may/may not have tack in the distribution, though the
4821                 # makefile is.
4822                 if test $cf_dir = tack ; then
4823                         if test ! -f $srcdir/${cf_dir}/${cf_dir}.h; then
4824                                 continue
4825                         fi
4826                 fi
4827
4828                 if test -z "$cf_cv_src_modules"; then
4829                         cf_cv_src_modules=$cf_dir
4830                 else
4831                         cf_cv_src_modules="$cf_cv_src_modules $cf_dir"
4832                 fi
4833
4834                 # Make the ncurses_cfg.h file record the library interface files as
4835                 # well.  These are header files that are the same name as their
4836                 # directory.  Ncurses is the only library that does not follow
4837                 # that pattern.
4838                 if test $cf_dir = tack ; then
4839                         continue
4840                 elif test -f $srcdir/${cf_dir}/${cf_dir}.h; then
4841                         CF_UPPER(cf_have_include,$cf_dir)
4842                         AC_DEFINE_UNQUOTED(HAVE_${cf_have_include}_H)
4843                         AC_DEFINE_UNQUOTED(HAVE_LIB${cf_have_include})
4844                         TEST_DEPS="${LIB_DIR}/${LIB_PREFIX}${cf_dir}${DFT_DEP_SUFFIX} $TEST_DEPS"
4845                         TEST_DEP2="${LIB_2ND}/${LIB_PREFIX}${cf_dir}${DFT_DEP_SUFFIX} $TEST_DEP2"
4846                         if test "$DFT_LWR_MODEL" = "libtool"; then
4847                                 TEST_ARGS="${TEST_DEPS}"
4848                                 TEST_ARG2="${TEST_DEP2}"
4849                         else
4850                                 TEST_ARGS="-l${cf_dir}${DFT_ARG_SUFFIX} $TEST_ARGS"
4851                                 TEST_ARG2="-l${cf_dir}${DFT_ARG_SUFFIX} $TEST_ARG2"
4852                         fi
4853                 fi
4854         fi
4855 done
4856 AC_MSG_RESULT($cf_cv_src_modules)
4857
4858 TEST_ARGS="-L${LIB_DIR} $TEST_ARGS"
4859 TEST_ARG2="-L${LIB_2ND} $TEST_ARG2"
4860
4861 AC_SUBST(TEST_ARGS)
4862 AC_SUBST(TEST_DEPS)
4863
4864 AC_SUBST(TEST_ARG2)
4865 AC_SUBST(TEST_DEP2)
4866
4867 SRC_SUBDIRS=
4868 if test "x$cf_with_manpages" != xno ; then
4869         SRC_SUBDIRS="$SRC_SUBDIRS man"
4870 fi
4871 SRC_SUBDIRS="$SRC_SUBDIRS include"
4872 for cf_dir in $cf_cv_src_modules
4873 do
4874         SRC_SUBDIRS="$SRC_SUBDIRS $cf_dir"
4875 done
4876 SRC_SUBDIRS="$SRC_SUBDIRS test"
4877 test -z "$MAKE_TERMINFO" && SRC_SUBDIRS="$SRC_SUBDIRS misc"
4878 test "$cf_with_cxx_binding" != no && SRC_SUBDIRS="$SRC_SUBDIRS c++"
4879
4880 ADA_SUBDIRS=
4881 if test "$cf_cv_prog_gnat_correct" = yes && test -f $srcdir/Ada95/Makefile.in; then
4882         SRC_SUBDIRS="$SRC_SUBDIRS Ada95"
4883         ADA_SUBDIRS="gen src samples"
4884 fi
4885
4886 SUB_MAKEFILES=
4887 for cf_dir in $SRC_SUBDIRS
4888 do
4889         SUB_MAKEFILES="$SUB_MAKEFILES $cf_dir/Makefile"
4890 done
4891
4892 if test -n "$ADA_SUBDIRS"; then
4893         for cf_dir in $ADA_SUBDIRS
4894         do
4895                 SUB_MAKEFILES="$SUB_MAKEFILES Ada95/$cf_dir/Makefile"
4896         done
4897         AC_SUBST(ADA_SUBDIRS)
4898 fi
4899 ])dnl
4900 dnl ---------------------------------------------------------------------------
4901 dnl CF_STDCPP_LIBRARY version: 5 updated: 2000/08/12 23:18:52
4902 dnl -----------------
4903 dnl Check for -lstdc++, which is GNU's standard C++ library.
4904 AC_DEFUN([CF_STDCPP_LIBRARY],
4905 [
4906 if test -n "$GXX" ; then
4907 case $cf_cv_system_name in #(vi
4908 os2*) #(vi
4909         cf_stdcpp_libname=stdcpp
4910         ;;
4911 *)
4912         cf_stdcpp_libname=stdc++
4913         ;;
4914 esac
4915 AC_CACHE_CHECK(for library $cf_stdcpp_libname,cf_cv_libstdcpp,[
4916         cf_save="$LIBS"
4917         LIBS="$LIBS -l$cf_stdcpp_libname"
4918 AC_TRY_LINK([
4919 #include <strstream.h>],[
4920 char buf[80];
4921 strstreambuf foo(buf, sizeof(buf))
4922 ],
4923         [cf_cv_libstdcpp=yes],
4924         [cf_cv_libstdcpp=no])
4925         LIBS="$cf_save"
4926 ])
4927 test "$cf_cv_libstdcpp" = yes && CXXLIBS="$CXXLIBS -l$cf_stdcpp_libname"
4928 fi
4929 ])dnl
4930 dnl ---------------------------------------------------------------------------
4931 dnl CF_STRIP_G_OPT version: 3 updated: 2002/12/21 19:25:52
4932 dnl --------------
4933 dnl     Remove "-g" option from the compiler options
4934 AC_DEFUN([CF_STRIP_G_OPT],
4935 [$1=`echo ${$1} | sed -e 's%-g %%' -e 's%-g$%%'`])dnl
4936 dnl ---------------------------------------------------------------------------
4937 dnl CF_STRUCT_SIGACTION version: 3 updated: 2000/08/12 23:18:52
4938 dnl -------------------
4939 dnl Check if we need _POSIX_SOURCE defined to use struct sigaction.  We'll only
4940 dnl do this if we've found the sigaction function.
4941 dnl
4942 dnl If needed, define SVR4_ACTION.
4943 AC_DEFUN([CF_STRUCT_SIGACTION],[
4944 if test "$ac_cv_func_sigaction" = yes; then
4945 AC_MSG_CHECKING(whether sigaction needs _POSIX_SOURCE)
4946 AC_TRY_COMPILE([
4947 #include <sys/types.h>
4948 #include <signal.h>],
4949         [struct sigaction act],
4950         [sigact_bad=no],
4951         [
4952 AC_TRY_COMPILE([
4953 #define _POSIX_SOURCE
4954 #include <sys/types.h>
4955 #include <signal.h>],
4956         [struct sigaction act],
4957         [sigact_bad=yes
4958          AC_DEFINE(SVR4_ACTION)],
4959          [sigact_bad=unknown])])
4960 AC_MSG_RESULT($sigact_bad)
4961 fi
4962 ])dnl
4963 dnl ---------------------------------------------------------------------------
4964 dnl CF_STRUCT_TERMIOS version: 5 updated: 2000/11/04 12:22:46
4965 dnl -----------------
4966 dnl Some machines require _POSIX_SOURCE to completely define struct termios.
4967 dnl If so, define SVR4_TERMIO
4968 AC_DEFUN([CF_STRUCT_TERMIOS],[
4969 AC_CHECK_HEADERS( \
4970 termio.h \
4971 termios.h \
4972 unistd.h \
4973 )
4974 if test "$ISC" = yes ; then
4975         AC_CHECK_HEADERS( sys/termio.h )
4976 fi
4977 if test "$ac_cv_header_termios_h" = yes ; then
4978         case "$CFLAGS $CPPFLAGS" in
4979         *-D_POSIX_SOURCE*)
4980                 termios_bad=dunno ;;
4981         *)      termios_bad=maybe ;;
4982         esac
4983         if test "$termios_bad" = maybe ; then
4984         AC_MSG_CHECKING(whether termios.h needs _POSIX_SOURCE)
4985         AC_TRY_COMPILE([#include <termios.h>],
4986                 [struct termios foo; int x = foo.c_iflag],
4987                 termios_bad=no, [
4988                 AC_TRY_COMPILE([
4989 #define _POSIX_SOURCE
4990 #include <termios.h>],
4991                         [struct termios foo; int x = foo.c_iflag],
4992                         termios_bad=unknown,
4993                         termios_bad=yes AC_DEFINE(SVR4_TERMIO))
4994                         ])
4995         AC_MSG_RESULT($termios_bad)
4996         fi
4997 fi
4998 ])dnl
4999 dnl ---------------------------------------------------------------------------
5000 dnl CF_SUBDIR_PATH version: 5 updated: 2007/07/29 09:55:12
5001 dnl --------------
5002 dnl Construct a search-list for a nonstandard header/lib-file
5003 dnl     $1 = the variable to return as result
5004 dnl     $2 = the package name
5005 dnl     $3 = the subdirectory, e.g., bin, include or lib
5006 AC_DEFUN([CF_SUBDIR_PATH],
5007 [$1=""
5008
5009 CF_ADD_SUBDIR_PATH($1,$2,$3,/usr,$prefix)
5010 CF_ADD_SUBDIR_PATH($1,$2,$3,$prefix,NONE)
5011 CF_ADD_SUBDIR_PATH($1,$2,$3,/usr/local,$prefix)
5012 CF_ADD_SUBDIR_PATH($1,$2,$3,/opt,$prefix)
5013 CF_ADD_SUBDIR_PATH($1,$2,$3,[$]HOME,$prefix)
5014 ])dnl
5015 dnl ---------------------------------------------------------------------------
5016 dnl CF_SUBST version: 4 updated: 2006/06/17 12:33:03
5017 dnl --------
5018 dnl     Shorthand macro for substituting things that the user may override
5019 dnl     with an environment variable.
5020 dnl
5021 dnl     $1 = long/descriptive name
5022 dnl     $2 = environment variable
5023 dnl     $3 = default value
5024 AC_DEFUN([CF_SUBST],
5025 [AC_CACHE_VAL(cf_cv_subst_$2,[
5026 AC_MSG_CHECKING(for $1 (symbol $2))
5027 CF_SUBST_IF([-z "[$]$2"], [$2], [$3])
5028 cf_cv_subst_$2=[$]$2
5029 AC_MSG_RESULT([$]$2)
5030 ])
5031 ])dnl
5032 dnl ---------------------------------------------------------------------------
5033 dnl CF_SUBST_IF version: 2 updated: 2006/06/17 12:33:03
5034 dnl -----------
5035 dnl     Shorthand macro for substituting things that the user may override
5036 dnl     with an environment variable.
5037 dnl
5038 dnl     $1 = condition to pass to "test"
5039 dnl     $2 = environment variable
5040 dnl     $3 = value if the test succeeds
5041 dnl     $4 = value if the test fails
5042 AC_DEFUN([CF_SUBST_IF],
5043 [
5044 if test $1 ; then
5045         $2=$3
5046 ifelse($4,,,[else
5047         $2=$4])
5048 fi
5049 AC_SUBST($2)
5050 ])dnl
5051 dnl ---------------------------------------------------------------------------
5052 dnl CF_SUBST_NCURSES_VERSION version: 8 updated: 2006/09/16 11:40:59
5053 dnl ------------------------
5054 dnl Get the version-number for use in shared-library naming, etc.
5055 AC_DEFUN([CF_SUBST_NCURSES_VERSION],
5056 [
5057 AC_REQUIRE([CF_PROG_EGREP])
5058 NCURSES_MAJOR="`$ac_cv_prog_egrep '^NCURSES_MAJOR[[     ]]*=' $srcdir/dist.mk | sed -e 's/^[[^0-9]]*//'`"
5059 NCURSES_MINOR="`$ac_cv_prog_egrep '^NCURSES_MINOR[[     ]]*=' $srcdir/dist.mk | sed -e 's/^[[^0-9]]*//'`"
5060 NCURSES_PATCH="`$ac_cv_prog_egrep '^NCURSES_PATCH[[     ]]*=' $srcdir/dist.mk | sed -e 's/^[[^0-9]]*//'`"
5061 cf_cv_abi_version=${NCURSES_MAJOR}
5062 cf_cv_rel_version=${NCURSES_MAJOR}.${NCURSES_MINOR}
5063 dnl Show the computed version, for logging
5064 cf_cv_timestamp=`date`
5065 AC_MSG_RESULT(Configuring NCURSES $cf_cv_rel_version ABI $cf_cv_abi_version ($cf_cv_timestamp))
5066 dnl We need these values in the generated headers
5067 AC_SUBST(NCURSES_MAJOR)
5068 AC_SUBST(NCURSES_MINOR)
5069 AC_SUBST(NCURSES_PATCH)
5070 dnl We need these values in the generated makefiles
5071 AC_SUBST(cf_cv_rel_version)
5072 AC_SUBST(cf_cv_abi_version)
5073 AC_SUBST(cf_cv_builtin_bool)
5074 AC_SUBST(cf_cv_header_stdbool_h)
5075 AC_SUBST(cf_cv_type_of_bool)dnl
5076 ])dnl
5077 dnl ---------------------------------------------------------------------------
5078 dnl CF_SYS_TIME_SELECT version: 4 updated: 2000/10/04 09:18:40
5079 dnl ------------------
5080 dnl Check if we can include <sys/time.h> with <sys/select.h>; this breaks on
5081 dnl older SCO configurations.
5082 AC_DEFUN([CF_SYS_TIME_SELECT],
5083 [
5084 AC_MSG_CHECKING(if sys/time.h works with sys/select.h)
5085 AC_CACHE_VAL(cf_cv_sys_time_select,[
5086 AC_TRY_COMPILE([
5087 #include <sys/types.h>
5088 #ifdef HAVE_SYS_TIME_H
5089 #include <sys/time.h>
5090 #endif
5091 #ifdef HAVE_SYS_SELECT_H
5092 #include <sys/select.h>
5093 #endif
5094 ],[],[cf_cv_sys_time_select=yes],
5095      [cf_cv_sys_time_select=no])
5096      ])
5097 AC_MSG_RESULT($cf_cv_sys_time_select)
5098 test "$cf_cv_sys_time_select" = yes && AC_DEFINE(HAVE_SYS_TIME_SELECT)
5099 ])dnl
5100 dnl ---------------------------------------------------------------------------
5101 dnl CF_TOP_BUILDDIR version: 1 updated: 2006/10/15 16:33:23
5102 dnl ---------------
5103 dnl Define a top_builddir symbol, for applications that need an absolute path.
5104 AC_DEFUN([CF_TOP_BUILDDIR],
5105 [
5106 top_builddir=`pwd`
5107 AC_SUBST(top_builddir)
5108 ])dnl
5109 dnl ---------------------------------------------------------------------------
5110 dnl CF_TYPEOF_CHTYPE version: 8 updated: 2006/12/16 12:33:30
5111 dnl ----------------
5112 dnl Determine the type we should use for chtype (and attr_t, which is treated
5113 dnl as the same thing).  We want around 32 bits, so on most machines want a
5114 dnl long, but on newer 64-bit machines, probably want an int.  If we're using
5115 dnl wide characters, we have to have a type compatible with that, as well.
5116 AC_DEFUN([CF_TYPEOF_CHTYPE],
5117 [
5118 AC_MSG_CHECKING([for type of chtype])
5119 AC_CACHE_VAL(cf_cv_typeof_chtype,[
5120                 AC_TRY_RUN([
5121 #define WANT_BITS 31
5122 #include <stdio.h>
5123 int main()
5124 {
5125         FILE *fp = fopen("cf_test.out", "w");
5126         if (fp != 0) {
5127                 char *result = "long";
5128                 if (sizeof(unsigned long) > sizeof(unsigned int)) {
5129                         int n;
5130                         unsigned int x, y;
5131                         for (n = 0; n < WANT_BITS; n++) {
5132                                 x = (1 << n);
5133                                 y = (x >> n);
5134                                 if (y != 1 || x == 0) {
5135                                         x = 0;
5136                                         break;
5137                                 }
5138                         }
5139                         /*
5140                          * If x is nonzero, an int is big enough for the bits
5141                          * that we want.
5142                          */
5143                         result = (x != 0) ? "int" : "long";
5144                 }
5145                 fputs(result, fp);
5146                 fclose(fp);
5147         }
5148         ${cf_cv_main_return:-return}(0);
5149 }
5150                 ],
5151                 [cf_cv_typeof_chtype=`cat cf_test.out`],
5152                 [cf_cv_typeof_chtype=long],
5153                 [cf_cv_typeof_chtype=long])
5154                 rm -f cf_test.out
5155         ])
5156 AC_MSG_RESULT($cf_cv_typeof_chtype)
5157
5158 AC_SUBST(cf_cv_typeof_chtype)
5159 AC_DEFINE_UNQUOTED(TYPEOF_CHTYPE,$cf_cv_typeof_chtype)
5160 ])dnl
5161 dnl ---------------------------------------------------------------------------
5162 dnl CF_TYPE_SIGACTION version: 3 updated: 2000/08/12 23:18:52
5163 dnl -----------------
5164 dnl
5165 AC_DEFUN([CF_TYPE_SIGACTION],
5166 [
5167 AC_MSG_CHECKING([for type sigaction_t])
5168 AC_CACHE_VAL(cf_cv_type_sigaction,[
5169         AC_TRY_COMPILE([
5170 #include <signal.h>],
5171                 [sigaction_t x],
5172                 [cf_cv_type_sigaction=yes],
5173                 [cf_cv_type_sigaction=no])])
5174 AC_MSG_RESULT($cf_cv_type_sigaction)
5175 test "$cf_cv_type_sigaction" = yes && AC_DEFINE(HAVE_TYPE_SIGACTION)
5176 ])dnl
5177 dnl ---------------------------------------------------------------------------
5178 dnl CF_UNSIGNED_LITERALS version: 2 updated: 1998/02/07 22:10:16
5179 dnl --------------------
5180 dnl Test if the compiler supports 'U' and 'L' suffixes.  Only old compilers
5181 dnl won't, but they're still there.
5182 AC_DEFUN([CF_UNSIGNED_LITERALS],
5183 [
5184 AC_MSG_CHECKING([if unsigned literals are legal])
5185 AC_CACHE_VAL(cf_cv_unsigned_literals,[
5186         AC_TRY_COMPILE([],[long x = 1L + 1UL + 1U + 1],
5187                 [cf_cv_unsigned_literals=yes],
5188                 [cf_cv_unsigned_literals=no])
5189         ])
5190 AC_MSG_RESULT($cf_cv_unsigned_literals)
5191 ])dnl
5192 dnl ---------------------------------------------------------------------------
5193 dnl CF_UPPER version: 5 updated: 2001/01/29 23:40:59
5194 dnl --------
5195 dnl Make an uppercase version of a variable
5196 dnl $1=uppercase($2)
5197 AC_DEFUN([CF_UPPER],
5198 [
5199 $1=`echo "$2" | sed y%abcdefghijklmnopqrstuvwxyz./-%ABCDEFGHIJKLMNOPQRSTUVWXYZ___%`
5200 ])dnl
5201 dnl ---------------------------------------------------------------------------
5202 dnl CF_UTF8_LIB version: 5 updated: 2008/10/17 19:37:52
5203 dnl -----------
5204 dnl Check for multibyte support, and if not found, utf8 compatibility library
5205 AC_DEFUN([CF_UTF8_LIB],
5206 [
5207 AC_CACHE_CHECK(for multibyte character support,cf_cv_utf8_lib,[
5208         cf_save_LIBS="$LIBS"
5209         AC_TRY_LINK([
5210 #include <stdlib.h>],[putwc(0,0);],
5211         [cf_cv_utf8_lib=yes],
5212         [CF_FIND_LINKAGE([
5213 #include <libutf8.h>],[putwc(0,0);],utf8,
5214                 [cf_cv_utf8_lib=add-on],
5215                 [cf_cv_utf8_lib=no])
5216 ])])
5217
5218 # HAVE_LIBUTF8_H is used by ncurses if curses.h is shared between
5219 # ncurses/ncursesw:
5220 if test "$cf_cv_utf8_lib" = "add-on" ; then
5221         AC_DEFINE(HAVE_LIBUTF8_H)
5222         CF_ADD_INCDIR($cf_cv_header_path_utf8)
5223         CF_ADD_LIBDIR($cf_cv_library_path_utf8)
5224         LIBS="-lutf8 $LIBS"
5225 fi
5226 ])dnl
5227 dnl ---------------------------------------------------------------------------
5228 dnl CF_VERBOSE version: 3 updated: 2007/07/29 09:55:12
5229 dnl ----------
5230 dnl Use AC_VERBOSE w/o the warnings
5231 AC_DEFUN([CF_VERBOSE],
5232 [test -n "$verbose" && echo "   $1" 1>&AC_FD_MSG
5233 CF_MSG_LOG([$1])
5234 ])dnl
5235 dnl ---------------------------------------------------------------------------
5236 dnl CF_WCHAR_TYPE version: 2 updated: 2004/01/17 19:18:20
5237 dnl -------------
5238 dnl Check if type wide-character type $1 is declared, and if so, which header
5239 dnl file is needed.  The second parameter is used to set a shell variable when
5240 dnl the type is not found.  The first parameter sets a shell variable for the
5241 dnl opposite sense.
5242 AC_DEFUN([CF_WCHAR_TYPE],
5243 [
5244 # This is needed on Tru64 5.0 to declare $1
5245 AC_CACHE_CHECK(if we must include wchar.h to declare $1,cf_cv_$1,[
5246 AC_TRY_COMPILE([
5247 #include <stdlib.h>
5248 #include <stdarg.h>
5249 #include <stdio.h>
5250 #ifdef HAVE_LIBUTF8_H
5251 #include <libutf8.h>
5252 #endif],
5253         [$1 state],
5254         [cf_cv_$1=no],
5255         [AC_TRY_COMPILE([
5256 #include <stdlib.h>
5257 #include <stdarg.h>
5258 #include <stdio.h>
5259 #include <wchar.h>
5260 #ifdef HAVE_LIBUTF8_H
5261 #include <libutf8.h>
5262 #endif],
5263         [$1 value],
5264         [cf_cv_$1=yes],
5265         [cf_cv_$1=unknown])])])
5266
5267 if test "$cf_cv_$1" = yes ; then
5268         AC_DEFINE(NEED_WCHAR_H)
5269         NEED_WCHAR_H=1
5270 fi
5271
5272 ifelse($2,,,[
5273 # if we do not find $1 in either place, use substitution to provide a fallback.
5274 if test "$cf_cv_$1" = unknown ; then
5275         $2=1
5276 fi
5277 ])
5278 ifelse($3,,,[
5279 # if we find $1 in either place, use substitution to provide a fallback.
5280 if test "$cf_cv_$1" != unknown ; then
5281         $3=1
5282 fi
5283 ])
5284 ])dnl
5285 dnl ---------------------------------------------------------------------------
5286 dnl CF_WEAK_SYMBOLS version: 1 updated: 2008/08/16 19:18:06
5287 dnl ---------------
5288 dnl Check for compiler-support for weak symbols.
5289 dnl This works with "recent" gcc.
5290 AC_DEFUN([CF_WEAK_SYMBOLS],[
5291 AC_CACHE_CHECK(if $CC supports weak symbols,cf_cv_weak_symbols,[
5292
5293 AC_TRY_COMPILE([
5294 #include <stdio.h>],
5295 [
5296 #if defined(__GNUC__)
5297 #  if defined __USE_ISOC99
5298 #    define _cat_pragma(exp)    _Pragma(#exp)
5299 #    define _weak_pragma(exp)   _cat_pragma(weak name)
5300 #  else
5301 #    define _weak_pragma(exp)
5302 #  endif
5303 #  define _declare(name)        __extension__ extern __typeof__(name) name
5304 #  define weak_symbol(name)     _weak_pragma(name) _declare(name) __attribute__((weak))
5305 #endif
5306
5307 weak_symbol(fopen);
5308 ],[cf_cv_weak_symbols=yes],[cf_cv_weak_symbols=no])
5309 ])
5310 ])dnl
5311 dnl ---------------------------------------------------------------------------
5312 dnl CF_WITH_ABI_VERSION version: 1 updated: 2003/09/20 18:12:49
5313 dnl -------------------
5314 dnl Allow library's ABI to be overridden.  Generally this happens when a
5315 dnl packager has incremented the ABI past that used in the original package,
5316 dnl and wishes to keep doing this.
5317 dnl
5318 dnl $1 is the package name, if any, to derive a corresponding {package}_ABI
5319 dnl symbol.
5320 AC_DEFUN([CF_WITH_ABI_VERSION],[
5321 test -z "$cf_cv_abi_version" && cf_cv_abi_version=0
5322 AC_ARG_WITH(abi-version,
5323 [  --with-abi-version=XXX  override derived ABI version],
5324 [AC_MSG_WARN(overriding ABI version $cf_cv_abi_version to $withval)
5325  cf_cv_abi_version=$withval])
5326  CF_NUMBER_SYNTAX($cf_cv_abi_version,ABI version)
5327 ifelse($1,,,[
5328 $1_ABI=$cf_cv_abi_version
5329 ])
5330 ])dnl
5331 dnl ---------------------------------------------------------------------------
5332 dnl CF_WITH_DBMALLOC version: 6 updated: 2006/12/16 14:24:05
5333 dnl ----------------
5334 dnl Configure-option for dbmalloc.  The optional parameter is used to override
5335 dnl the updating of $LIBS, e.g., to avoid conflict with subsequent tests.
5336 AC_DEFUN([CF_WITH_DBMALLOC],[
5337 CF_NO_LEAKS_OPTION(dbmalloc,
5338         [  --with-dbmalloc         test: use Conor Cahill's dbmalloc library],
5339         [USE_DBMALLOC])
5340
5341 if test "$with_dbmalloc" = yes ; then
5342         AC_CHECK_HEADER(dbmalloc.h,
5343                 [AC_CHECK_LIB(dbmalloc,[debug_malloc]ifelse($1,,[],[,$1]))])
5344 fi
5345 ])dnl
5346 dnl ---------------------------------------------------------------------------
5347 dnl CF_WITH_DMALLOC version: 6 updated: 2006/12/16 14:24:05
5348 dnl ---------------
5349 dnl Configure-option for dmalloc.  The optional parameter is used to override
5350 dnl the updating of $LIBS, e.g., to avoid conflict with subsequent tests.
5351 AC_DEFUN([CF_WITH_DMALLOC],[
5352 CF_NO_LEAKS_OPTION(dmalloc,
5353         [  --with-dmalloc          test: use Gray Watson's dmalloc library],
5354         [USE_DMALLOC])
5355
5356 if test "$with_dmalloc" = yes ; then
5357         AC_CHECK_HEADER(dmalloc.h,
5358                 [AC_CHECK_LIB(dmalloc,[dmalloc_debug]ifelse($1,,[],[,$1]))])
5359 fi
5360 ])dnl
5361 dnl ---------------------------------------------------------------------------
5362 dnl CF_WITH_GPM version: 7 updated: 2008/03/23 14:48:54
5363 dnl -----------
5364 dnl
5365 dnl The option parameter (if neither yes/no) is assumed to be the name of
5366 dnl the gpm library, e.g., for dynamic loading.
5367 AC_DEFUN([CF_WITH_GPM],
5368 [
5369 AC_MSG_CHECKING(if you want to link with the GPM mouse library)
5370 AC_ARG_WITH(gpm,
5371         [  --with-gpm              use Alessandro Rubini's GPM library],
5372         [with_gpm=$withval],
5373         [with_gpm=maybe])
5374 AC_MSG_RESULT($with_gpm)
5375
5376 if test "$with_gpm" != no ; then
5377         AC_CHECK_HEADER(gpm.h,[
5378                 AC_DEFINE(HAVE_GPM_H)
5379                 if test "$with_gpm" != yes && test "$with_gpm" != maybe ; then
5380                         CF_VERBOSE(assuming we really have GPM library)
5381                         AC_DEFINE(HAVE_LIBGPM)
5382                 else
5383                         AC_CHECK_LIB(gpm,Gpm_Open,[:],[
5384                                 AC_MSG_ERROR(Cannot link with GPM library)
5385                 fi
5386                 with_gpm=yes
5387                 ])
5388         ],[
5389                 test "$with_gpm" != maybe && AC_MSG_WARN(Cannot find GPM header)
5390                 with_gpm=no
5391         ])
5392 fi
5393 ])
5394 dnl ---------------------------------------------------------------------------
5395 dnl CF_WITH_LIBTOOL version: 20 updated: 2008/12/27 12:31:39
5396 dnl ---------------
5397 dnl Provide a configure option to incorporate libtool.  Define several useful
5398 dnl symbols for the makefile rules.
5399 dnl
5400 dnl The reference to AC_PROG_LIBTOOL does not normally work, since it uses
5401 dnl macros from libtool.m4 which is in the aclocal directory of automake.
5402 dnl Following is a simple script which turns on the AC_PROG_LIBTOOL macro.
5403 dnl But that still does not work properly since the macro is expanded outside
5404 dnl the CF_WITH_LIBTOOL macro:
5405 dnl
5406 dnl     #!/bin/sh
5407 dnl     ACLOCAL=`aclocal --print-ac-dir`
5408 dnl     if test -z "$ACLOCAL" ; then
5409 dnl             echo cannot find aclocal directory
5410 dnl             exit 1
5411 dnl     elif test ! -f $ACLOCAL/libtool.m4 ; then
5412 dnl             echo cannot find libtool.m4 file
5413 dnl             exit 1
5414 dnl     fi
5415 dnl
5416 dnl     LOCAL=aclocal.m4
5417 dnl     ORIG=aclocal.m4.orig
5418 dnl
5419 dnl     trap "mv $ORIG $LOCAL" 0 1 2 5 15
5420 dnl     rm -f $ORIG
5421 dnl     mv $LOCAL $ORIG
5422 dnl
5423 dnl     # sed the LIBTOOL= assignment to omit the current directory?
5424 dnl     sed -e 's/^LIBTOOL=.*/LIBTOOL=${LIBTOOL-libtool}/' $ACLOCAL/libtool.m4 >>$LOCAL
5425 dnl     cat $ORIG >>$LOCAL
5426 dnl
5427 dnl     autoconf-257 $*
5428 dnl
5429 AC_DEFUN([CF_WITH_LIBTOOL],
5430 [
5431 ifdef([AC_PROG_LIBTOOL],,[
5432 LIBTOOL=
5433 ])
5434 # common library maintenance symbols that are convenient for libtool scripts:
5435 LIB_CREATE='${AR} -cr'
5436 LIB_OBJECT='${OBJECTS}'
5437 LIB_SUFFIX=.a
5438 LIB_PREP="$RANLIB"
5439
5440 # symbols used to prop libtool up to enable it to determine what it should be
5441 # doing:
5442 LIB_CLEAN=
5443 LIB_COMPILE=
5444 LIB_LINK='${CC}'
5445 LIB_INSTALL=
5446 LIB_UNINSTALL=
5447
5448 AC_MSG_CHECKING(if you want to build libraries with libtool)
5449 AC_ARG_WITH(libtool,
5450         [  --with-libtool          generate libraries with libtool],
5451         [with_libtool=$withval],
5452         [with_libtool=no])
5453 AC_MSG_RESULT($with_libtool)
5454 if test "$with_libtool" != "no"; then
5455 ifdef([AC_PROG_LIBTOOL],[
5456         # missing_content_AC_PROG_LIBTOOL{{
5457         AC_PROG_LIBTOOL
5458         # missing_content_AC_PROG_LIBTOOL}}
5459 ],[
5460         if test "$with_libtool" != "yes" ; then
5461                 CF_PATH_SYNTAX(with_libtool)
5462                 LIBTOOL=$with_libtool
5463         else
5464                 AC_PATH_PROG(LIBTOOL,libtool)
5465         fi
5466         if test -z "$LIBTOOL" ; then
5467                 AC_MSG_ERROR(Cannot find libtool)
5468         fi
5469 ])dnl
5470         LIB_CREATE='${LIBTOOL} --mode=link ${CC} -rpath ${DESTDIR}${libdir} -version-info `cut -f1 ${srcdir}/VERSION` ${LIBTOOL_OPTS} -o'
5471         LIB_OBJECT='${OBJECTS:.o=.lo}'
5472         LIB_SUFFIX=.la
5473         LIB_CLEAN='${LIBTOOL} --mode=clean'
5474         LIB_COMPILE='${LIBTOOL} --mode=compile'
5475         LIB_LINK='${LIBTOOL} --mode=link ${CC} ${LIBTOOL_OPTS}'
5476         LIB_INSTALL='${LIBTOOL} --mode=install'
5477         LIB_UNINSTALL='${LIBTOOL} --mode=uninstall'
5478         LIB_PREP=:
5479
5480         # Show the version of libtool
5481         AC_MSG_CHECKING(version of libtool)
5482
5483         # Save the version in a cache variable - this is not entirely a good
5484         # thing, but the version string from libtool is very ugly, and for
5485         # bug reports it might be useful to have the original string.
5486         cf_cv_libtool_version=`$LIBTOOL --version 2>&1 | sed -e '/^$/d' |sed -e '2,$d' -e 's/([[^)]]*)//g' -e 's/^[[^1-9]]*//' -e 's/[[^0-9.]].*//'`
5487         AC_MSG_RESULT($cf_cv_libtool_version)
5488         if test -z "$cf_cv_libtool_version" ; then
5489                 AC_MSG_ERROR(This is not GNU libtool)
5490         fi
5491
5492         # special hack to add --tag option for C++ compiler
5493         case $cf_cv_libtool_version in
5494         1.[[5-9]]*|[[2-9]]*)
5495                 LIBTOOL_CXX="$LIBTOOL --tag=CXX"
5496                 LIBTOOL="$LIBTOOL --tag=CC"
5497                 ;;
5498         *)
5499                 LIBTOOL_CXX="$LIBTOOL"
5500                 ;;
5501         esac
5502 else
5503         LIBTOOL=""
5504         LIBTOOL_CXX=""
5505 fi
5506
5507 test -z "$LIBTOOL" && ECHO_LT=
5508
5509 AC_SUBST(LIBTOOL)
5510 AC_SUBST(LIBTOOL_CXX)
5511 AC_SUBST(LIBTOOL_OPTS)
5512
5513 AC_SUBST(LIB_CREATE)
5514 AC_SUBST(LIB_OBJECT)
5515 AC_SUBST(LIB_SUFFIX)
5516 AC_SUBST(LIB_PREP)
5517
5518 AC_SUBST(LIB_CLEAN)
5519 AC_SUBST(LIB_COMPILE)
5520 AC_SUBST(LIB_LINK)
5521 AC_SUBST(LIB_INSTALL)
5522 AC_SUBST(LIB_UNINSTALL)
5523
5524 ])dnl
5525 dnl ---------------------------------------------------------------------------
5526 dnl CF_WITH_PATH version: 8 updated: 2007/05/13 13:16:35
5527 dnl ------------
5528 dnl Wrapper for AC_ARG_WITH to ensure that user supplies a pathname, not just
5529 dnl defaulting to yes/no.
5530 dnl
5531 dnl $1 = option name
5532 dnl $2 = help-text
5533 dnl $3 = environment variable to set
5534 dnl $4 = default value, shown in the help-message, must be a constant
5535 dnl $5 = default value, if it's an expression & cannot be in the help-message
5536 dnl
5537 AC_DEFUN([CF_WITH_PATH],
5538 [AC_ARG_WITH($1,[$2 ](default: ifelse($4,,empty,$4)),,
5539 ifelse($4,,[withval="${$3}"],[withval="${$3-ifelse($5,,$4,$5)}"]))dnl
5540 if ifelse($5,,true,[test -n "$5"]) ; then
5541 CF_PATH_SYNTAX(withval)
5542 fi
5543 $3="$withval"
5544 AC_SUBST($3)dnl
5545 ])dnl
5546 dnl ---------------------------------------------------------------------------
5547 dnl CF_WITH_PATHLIST version: 6 updated: 2009/01/11 20:30:23
5548 dnl ----------------
5549 dnl Process an option specifying a list of colon-separated paths.
5550 dnl
5551 dnl $1 = option name
5552 dnl $2 = help-text
5553 dnl $3 = environment variable to set
5554 dnl $4 = default value, shown in the help-message, must be a constant
5555 dnl $5 = default value, if it's an expression & cannot be in the help-message
5556 dnl $6 = flag to tell if we want to define or substitute
5557 dnl
5558 AC_DEFUN([CF_WITH_PATHLIST],[
5559 AC_REQUIRE([CF_PATHSEP])
5560 AC_ARG_WITH($1,[$2 ](default: ifelse($4,,empty,$4)),,
5561 ifelse($4,,[withval=${$3}],[withval=${$3-ifelse($5,,$4,$5)}]))dnl
5562
5563 IFS="${IFS=     }"; ac_save_ifs="$IFS"; IFS="${PATH_SEPARATOR}"
5564 cf_dst_path=
5565 for cf_src_path in $withval
5566 do
5567   CF_PATH_SYNTAX(cf_src_path)
5568   test -n "$cf_dst_path" && cf_dst_path="${cf_dst_path}:"
5569   cf_dst_path="${cf_dst_path}${cf_src_path}"
5570 done
5571 IFS="$ac_save_ifs"
5572
5573 ifelse($6,define,[
5574 # Strip single quotes from the value, e.g., when it was supplied as a literal
5575 # for $4 or $5.
5576 case $cf_dst_path in #(vi
5577 \'*)
5578   cf_dst_path=`echo $cf_dst_path |sed -e s/\'// -e s/\'\$//`
5579   ;;
5580 esac
5581 cf_dst_path=`echo "$cf_dst_path" | sed -e 's/\\\\/\\\\\\\\/g'`
5582 ])
5583
5584 eval '$3="$cf_dst_path"'
5585 AC_SUBST($3)dnl
5586
5587 ])dnl
5588 dnl ---------------------------------------------------------------------------
5589 dnl CF_WITH_PTHREAD version: 2 updated: 2008/08/23 18:26:05
5590 dnl ---------------
5591 dnl Check for POSIX thread library.
5592 AC_DEFUN([CF_WITH_PTHREAD],
5593 [
5594 AC_MSG_CHECKING(if you want to link with the pthread library)
5595 AC_ARG_WITH(pthread,
5596     [  --with-pthread          use POSIX thread library],
5597     [with_pthread=$withval],
5598     [with_pthread=no])
5599 AC_MSG_RESULT($with_pthread)
5600
5601 if test "$with_pthread" != no ; then
5602     AC_CHECK_HEADER(pthread.h,[
5603         AC_DEFINE(HAVE_PTHREADS_H)
5604
5605         AC_MSG_CHECKING(if we can link with the pthread library)
5606         cf_save_LIBS="$LIBS"
5607         LIBS="-lpthread $LIBS"
5608         AC_TRY_LINK([
5609 #include <pthread.h>
5610 ],[
5611         int rc = pthread_create(0,0,0,0);
5612 ],[with_pthread=yes],[with_pthread=no])
5613         LIBS="$cf_save_LIBS"
5614         AC_MSG_RESULT($with_pthread)
5615
5616         if test "$with_pthread" = yes ; then
5617             LIBS="-lpthread $LIBS"
5618             AC_DEFINE(HAVE_LIBPTHREADS)
5619         else
5620             AC_MSG_ERROR(Cannot link with pthread library)
5621         fi
5622     ])
5623 fi
5624 ])
5625 dnl ---------------------------------------------------------------------------
5626 dnl CF_WITH_REL_VERSION version: 1 updated: 2003/09/20 18:12:49
5627 dnl -------------------
5628 dnl Allow library's release-version to be overridden.  Generally this happens when a
5629 dnl packager has incremented the release-version past that used in the original package,
5630 dnl and wishes to keep doing this.
5631 dnl
5632 dnl $1 is the package name, if any, to derive corresponding {package}_MAJOR
5633 dnl and {package}_MINOR symbols
5634 dnl symbol.
5635 AC_DEFUN([CF_WITH_REL_VERSION],[
5636 test -z "$cf_cv_rel_version" && cf_cv_rel_version=0.0
5637 AC_ARG_WITH(rel-version,
5638 [  --with-rel-version=XXX  override derived release version],
5639 [AC_MSG_WARN(overriding release version $cf_cv_rel_version to $withval)
5640  cf_cv_rel_version=$withval])
5641 ifelse($1,,[
5642  CF_NUMBER_SYNTAX($cf_cv_rel_version,Release version)
5643 ],[
5644  $1_MAJOR=`echo "$cf_cv_rel_version" | sed -e 's/\..*//'`
5645  $1_MINOR=`echo "$cf_cv_rel_version" | sed -e 's/^[[^.]]*//' -e 's/^\.//' -e 's/\..*//'`
5646  CF_NUMBER_SYNTAX([$]$1_MAJOR,Release major-version)
5647  CF_NUMBER_SYNTAX([$]$1_MINOR,Release minor-version)
5648 ])
5649 ])dnl
5650 dnl ---------------------------------------------------------------------------
5651 dnl CF_WITH_SYSMOUSE version: 2 updated: 2003/03/22 19:13:43
5652 dnl ----------------
5653 dnl If we can compile with sysmouse, make it available unless it is not wanted.
5654 AC_DEFUN([CF_WITH_SYSMOUSE],[
5655 # not everyone has "test -c"
5656 if test -c /dev/sysmouse 2>/dev/null ; then
5657 AC_MSG_CHECKING(if you want to use sysmouse)
5658 AC_ARG_WITH(sysmouse,
5659         [  --with-sysmouse         use sysmouse (FreeBSD console)],
5660         [cf_with_sysmouse=$withval],
5661         [cf_with_sysmouse=maybe])
5662         if test "$cf_with_sysmouse" != no ; then
5663         AC_TRY_COMPILE([
5664 #include <osreldate.h>
5665 #if (__FreeBSD_version >= 400017)
5666 #include <sys/consio.h>
5667 #include <sys/fbio.h>
5668 #else
5669 #include <machine/console.h>
5670 #endif
5671 ],[
5672         struct mouse_info the_mouse;
5673         ioctl(0, CONS_MOUSECTL, &the_mouse);
5674 ],[cf_with_sysmouse=yes],[cf_with_sysmouse=no])
5675         fi
5676 AC_MSG_RESULT($cf_with_sysmouse)
5677 test "$cf_with_sysmouse" = yes && AC_DEFINE(USE_SYSMOUSE)
5678 fi
5679 ])dnl
5680 dnl ---------------------------------------------------------------------------
5681 dnl CF_WITH_VALGRIND version: 1 updated: 2006/12/14 18:00:21
5682 dnl ----------------
5683 AC_DEFUN([CF_WITH_VALGRIND],[
5684 CF_NO_LEAKS_OPTION(valgrind,
5685         [  --with-valgrind         test: use valgrind],
5686         [USE_VALGRIND])
5687 ])dnl
5688 dnl ---------------------------------------------------------------------------
5689 dnl CF_XOPEN_SOURCE version: 28 updated: 2008/12/27 12:30:03
5690 dnl ---------------
5691 dnl Try to get _XOPEN_SOURCE defined properly that we can use POSIX functions,
5692 dnl or adapt to the vendor's definitions to get equivalent functionality,
5693 dnl without losing the common non-POSIX features.
5694 dnl
5695 dnl Parameters:
5696 dnl     $1 is the nominal value for _XOPEN_SOURCE
5697 dnl     $2 is the nominal value for _POSIX_C_SOURCE
5698 AC_DEFUN([CF_XOPEN_SOURCE],[
5699
5700 AC_REQUIRE([CF_PROG_CC_U_D])
5701
5702 cf_XOPEN_SOURCE=ifelse($1,,500,$1)
5703 cf_POSIX_C_SOURCE=ifelse($2,,199506L,$2)
5704
5705 case $host_os in #(vi
5706 aix[[456]]*) #(vi
5707         CPPFLAGS="$CPPFLAGS -D_ALL_SOURCE"
5708         ;;
5709 freebsd*|dragonfly*) #(vi
5710         # 5.x headers associate
5711         #       _XOPEN_SOURCE=600 with _POSIX_C_SOURCE=200112L
5712         #       _XOPEN_SOURCE=500 with _POSIX_C_SOURCE=199506L
5713         cf_POSIX_C_SOURCE=200112L
5714         cf_XOPEN_SOURCE=600
5715         CPPFLAGS="$CPPFLAGS -D_BSD_TYPES -D__BSD_VISIBLE -D_POSIX_C_SOURCE=$cf_POSIX_C_SOURCE -D_XOPEN_SOURCE=$cf_XOPEN_SOURCE"
5716         ;;
5717 hpux*) #(vi
5718         CPPFLAGS="$CPPFLAGS -D_HPUX_SOURCE"
5719         ;;
5720 irix[[56]].*) #(vi
5721         CPPFLAGS="$CPPFLAGS -D_SGI_SOURCE"
5722         ;;
5723 linux*|gnu*|mint*|k*bsd*-gnu) #(vi
5724         CF_GNU_SOURCE
5725         ;;
5726 mirbsd*) #(vi
5727         # setting _XOPEN_SOURCE or _POSIX_SOURCE breaks <arpa/inet.h>
5728         ;;
5729 netbsd*) #(vi
5730         # setting _XOPEN_SOURCE breaks IPv6 for lynx on NetBSD 1.6, breaks xterm, is not needed for ncursesw
5731         ;;
5732 openbsd*) #(vi
5733         # setting _XOPEN_SOURCE breaks xterm on OpenBSD 2.8, is not needed for ncursesw
5734         ;;
5735 osf[[45]]*) #(vi
5736         CPPFLAGS="$CPPFLAGS -D_OSF_SOURCE"
5737         ;;
5738 nto-qnx*) #(vi
5739         CPPFLAGS="$CPPFLAGS -D_QNX_SOURCE"
5740         ;;
5741 sco*) #(vi
5742         # setting _XOPEN_SOURCE breaks Lynx on SCO Unix / OpenServer
5743         ;;
5744 solaris*) #(vi
5745         CPPFLAGS="$CPPFLAGS -D__EXTENSIONS__"
5746         ;;
5747 *)
5748         AC_CACHE_CHECK(if we should define _XOPEN_SOURCE,cf_cv_xopen_source,[
5749         AC_TRY_COMPILE([#include <sys/types.h>],[
5750 #ifndef _XOPEN_SOURCE
5751 make an error
5752 #endif],
5753         [cf_cv_xopen_source=no],
5754         [cf_save="$CPPFLAGS"
5755          CPPFLAGS="$CPPFLAGS -D_XOPEN_SOURCE=$cf_XOPEN_SOURCE"
5756          AC_TRY_COMPILE([#include <sys/types.h>],[
5757 #ifdef _XOPEN_SOURCE
5758 make an error
5759 #endif],
5760         [cf_cv_xopen_source=no],
5761         [cf_cv_xopen_source=$cf_XOPEN_SOURCE])
5762         CPPFLAGS="$cf_save"
5763         ])
5764 ])
5765         if test "$cf_cv_xopen_source" != no ; then
5766                 CF_REMOVE_DEFINE(CFLAGS,$CFLAGS,_XOPEN_SOURCE)
5767                 CF_REMOVE_DEFINE(CPPFLAGS,$CPPFLAGS,_XOPEN_SOURCE)
5768                 test "$cf_cv_cc_u_d_options" = yes && \
5769                         CPPFLAGS="$CPPFLAGS -U_XOPEN_SOURCE"
5770                 CPPFLAGS="$CPPFLAGS -D_XOPEN_SOURCE=$cf_cv_xopen_source"
5771         fi
5772         CF_POSIX_C_SOURCE($cf_POSIX_C_SOURCE)
5773         ;;
5774 esac
5775 ])