aclocal.m4

   1 dnl***************************************************************************
   2 dnl Copyright (c) 1998-2008,2009 Free Software Foundation, Inc.              *
   3 dnl                                                                          *
   4 dnl Permission is hereby granted, free of charge, to any person obtaining a  *
   5 dnl copy of this software and associated documentation files (the            *
   6 dnl "Software"), to deal in the Software without restriction, including      *
   7 dnl without limitation the rights to use, copy, modify, merge, publish,      *
   8 dnl distribute, distribute with modifications, sublicense, and/or sell       *
   9 dnl copies of the Software, and to permit persons to whom the Software is    *
  10 dnl furnished to do so, subject to the following conditions:                 *
  11 dnl                                                                          *
  12 dnl The above copyright notice and this permission notice shall be included  *
  13 dnl in all copies or substantial portions of the Software.                   *
  14 dnl                                                                          *
  15 dnl THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS  *
  16 dnl OR IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF               *
  17 dnl MERCHANTABILITY, FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT.   *
  18 dnl IN NO EVENT SHALL THE ABOVE COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM,   *
  19 dnl DAMAGES OR OTHER LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR    *
  20 dnl OTHERWISE, ARISING FROM, OUT OF OR IN CONNECTION WITH THE SOFTWARE OR    *
  21 dnl THE USE OR OTHER DEALINGS IN THE SOFTWARE.                               *
  22 dnl                                                                          *
  23 dnl Except as contained in this notice, the name(s) of the above copyright   *
  24 dnl holders shall not be used in advertising or otherwise to promote the     *
  25 dnl sale, use or other dealings in this Software without prior written       *
  26 dnl authorization.                                                           *
  27 dnl***************************************************************************
  28 dnl
  29 dnl Author: Thomas E. Dickey 1995-on
  30 dnl
  31 dnl $Id: aclocal.m4,v 1.489 2009/11/21 17:49:12 tom Exp $
  32 dnl Macros used in NCURSES auto-configuration script.
  33 dnl
  34 dnl These macros are maintained separately from NCURSES.  The copyright on
  35 dnl this file applies to the aggregation of macros and does not affect use of
  36 dnl these macros in other applications.
  37 dnl
  38 dnl See http://invisible-island.net/autoconf/ for additional information.
  39 dnl
  40 dnl ---------------------------------------------------------------------------
  41 dnl ---------------------------------------------------------------------------
  42 dnl AM_LANGINFO_CODESET version: 3 updated: 2002/10/27 23:21:42
  43 dnl -------------------
  44 dnl Inserted as requested by gettext 0.10.40
  45 dnl File from /usr/share/aclocal
  46 dnl codeset.m4
  47 dnl ====================
  48 dnl serial AM1
  49 dnl
  50 dnl From Bruno Haible.
  51 AC_DEFUN([AM_LANGINFO_CODESET],
  52 [
  53   AC_CACHE_CHECK([for nl_langinfo and CODESET], am_cv_langinfo_codeset,
  54     [AC_TRY_LINK([#include <langinfo.h>],
  55       [char* cs = nl_langinfo(CODESET);],
  56       am_cv_langinfo_codeset=yes,
  57       am_cv_langinfo_codeset=no)
  58     ])
  59   if test $am_cv_langinfo_codeset = yes; then
  60     AC_DEFINE(HAVE_LANGINFO_CODESET, 1,
  61       [Define if you have <langinfo.h> and nl_langinfo(CODESET).])
  62   fi
  63 ])dnl
  64 dnl ---------------------------------------------------------------------------
  65 dnl CF_ADA_INCLUDE_DIRS version: 5 updated: 2006/10/14 15:23:15
  66 dnl -------------------
  67 dnl Construct the list of include-options for the C programs in the Ada95
  68 dnl binding.
  69 AC_DEFUN([CF_ADA_INCLUDE_DIRS],
  70 [
  71 ACPPFLAGS="-I. -I../../include $ACPPFLAGS"
  72 if test "$srcdir" != "."; then
  73         ACPPFLAGS="-I\${srcdir}/../../include $ACPPFLAGS"
  74 fi
  75 if test "$GCC" != yes; then
  76         ACPPFLAGS="$ACPPFLAGS -I\${includedir}"
  77 elif test "$includedir" != "/usr/include"; then
  78         if test "$includedir" = '${prefix}/include' ; then
  79                 if test $prefix != /usr ; then
  80                         ACPPFLAGS="$ACPPFLAGS -I\${includedir}"
  81                 fi
  82         else
  83                 ACPPFLAGS="$ACPPFLAGS -I\${includedir}"
  84         fi
  85 fi
  86 AC_SUBST(ACPPFLAGS)
  87 ])dnl
  88 dnl ---------------------------------------------------------------------------
  89 dnl CF_ADD_CFLAGS version: 8 updated: 2009/01/06 19:33:30
  90 dnl -------------
  91 dnl Copy non-preprocessor flags to $CFLAGS, preprocessor flags to $CPPFLAGS
  92 dnl The second parameter if given makes this macro verbose.
  93 dnl
  94 dnl Put any preprocessor definitions that use quoted strings in $EXTRA_CPPFLAGS,
  95 dnl to simplify use of $CPPFLAGS in compiler checks, etc., that are easily
  96 dnl confused by the quotes (which require backslashes to keep them usable).
  97 AC_DEFUN([CF_ADD_CFLAGS],
  98 [
  99 cf_fix_cppflags=no
 100 cf_new_cflags=
 101 cf_new_cppflags=
 102 cf_new_extra_cppflags=
 103
 104 for cf_add_cflags in $1
 105 do
 106 case $cf_fix_cppflags in
 107 no)
 108         case $cf_add_cflags in #(vi
 109         -undef|-nostdinc*|-I*|-D*|-U*|-E|-P|-C) #(vi
 110                 case $cf_add_cflags in
 111                 -D*)
 112                         cf_tst_cflags=`echo ${cf_add_cflags} |sed -e 's/^-D[[^=]]*='\''\"[[^"]]*//'`
 113
 114                         test "${cf_add_cflags}" != "${cf_tst_cflags}" \
 115                         && test -z "${cf_tst_cflags}" \
 116                         && cf_fix_cppflags=yes
 117
 118                         if test $cf_fix_cppflags = yes ; then
 119                                 cf_new_extra_cppflags="$cf_new_extra_cppflags $cf_add_cflags"
 120                                 continue
 121                         elif test "${cf_tst_cflags}" = "\"'" ; then
 122                                 cf_new_extra_cppflags="$cf_new_extra_cppflags $cf_add_cflags"
 123                                 continue
 124                         fi
 125                         ;;
 126                 esac
 127                 case "$CPPFLAGS" in
 128                 *$cf_add_cflags) #(vi
 129                         ;;
 130                 *) #(vi
 131                         cf_new_cppflags="$cf_new_cppflags $cf_add_cflags"
 132                         ;;
 133                 esac
 134                 ;;
 135         *)
 136                 cf_new_cflags="$cf_new_cflags $cf_add_cflags"
 137                 ;;
 138         esac
 139         ;;
 140 yes)
 141         cf_new_extra_cppflags="$cf_new_extra_cppflags $cf_add_cflags"
 142
 143         cf_tst_cflags=`echo ${cf_add_cflags} |sed -e 's/^[[^"]]*"'\''//'`
 144
 145         test "${cf_add_cflags}" != "${cf_tst_cflags}" \
 146         && test -z "${cf_tst_cflags}" \
 147         && cf_fix_cppflags=no
 148         ;;
 149 esac
 150 done
 151
 152 if test -n "$cf_new_cflags" ; then
 153         ifelse($2,,,[CF_VERBOSE(add to \$CFLAGS $cf_new_cflags)])
 154         CFLAGS="$CFLAGS $cf_new_cflags"
 155 fi
 156
 157 if test -n "$cf_new_cppflags" ; then
 158         ifelse($2,,,[CF_VERBOSE(add to \$CPPFLAGS $cf_new_cppflags)])
 159         CPPFLAGS="$CPPFLAGS $cf_new_cppflags"
 160 fi
 161
 162 if test -n "$cf_new_extra_cppflags" ; then
 163         ifelse($2,,,[CF_VERBOSE(add to \$EXTRA_CPPFLAGS $cf_new_extra_cppflags)])
 164         EXTRA_CPPFLAGS="$cf_new_extra_cppflags $EXTRA_CPPFLAGS"
 165 fi
 166
 167 AC_SUBST(EXTRA_CPPFLAGS)
 168
 169 ])dnl
 170 dnl ---------------------------------------------------------------------------
 171 dnl CF_ADD_INCDIR version: 12 updated: 2009/01/18 10:00:47
 172 dnl -------------
 173 dnl Add an include-directory to $CPPFLAGS.  Don't add /usr/include, since it's
 174 dnl redundant.  We don't normally need to add -I/usr/local/include for gcc,
 175 dnl but old versions (and some misinstalled ones) need that.  To make things
 176 dnl worse, gcc 3.x may give error messages if -I/usr/local/include is added to
 177 dnl the include-path).
 178 AC_DEFUN([CF_ADD_INCDIR],
 179 [
 180 if test -n "$1" ; then
 181   for cf_add_incdir in $1
 182   do
 183         while test $cf_add_incdir != /usr/include
 184         do
 185           if test -d $cf_add_incdir
 186           then
 187                 cf_have_incdir=no
 188                 if test -n "$CFLAGS$CPPFLAGS" ; then
 189                   # a loop is needed to ensure we can add subdirs of existing dirs
 190                   for cf_test_incdir in $CFLAGS $CPPFLAGS ; do
 191                         if test ".$cf_test_incdir" = ".-I$cf_add_incdir" ; then
 192                           cf_have_incdir=yes; break
 193                         fi
 194                   done
 195                 fi
 196
 197                 if test "$cf_have_incdir" = no ; then
 198                   if test "$cf_add_incdir" = /usr/local/include ; then
 199                         if test "$GCC" = yes
 200                         then
 201                           cf_save_CPPFLAGS=$CPPFLAGS
 202                           CPPFLAGS="$CPPFLAGS -I$cf_add_incdir"
 203                           AC_TRY_COMPILE([#include <stdio.h>],
 204                                   [printf("Hello")],
 205                                   [],
 206                                   [cf_have_incdir=yes])
 207                           CPPFLAGS=$cf_save_CPPFLAGS
 208                         fi
 209                   fi
 210                 fi
 211
 212                 if test "$cf_have_incdir" = no ; then
 213                   CF_VERBOSE(adding $cf_add_incdir to include-path)
 214                   ifelse($2,,CPPFLAGS,$2)="$ifelse($2,,CPPFLAGS,$2) -I$cf_add_incdir"
 215
 216                   cf_top_incdir=`echo $cf_add_incdir | sed -e 's%/include/.*$%/include%'`
 217                   test "$cf_top_incdir" = "$cf_add_incdir" && break
 218                   cf_add_incdir="$cf_top_incdir"
 219                 else
 220                   break
 221                 fi
 222           fi
 223         done
 224   done
 225 fi
 226 ])dnl
 227 dnl ---------------------------------------------------------------------------
 228 dnl CF_ADD_LIBDIR version: 8 updated: 2009/01/18 10:01:08
 229 dnl -------------
 230 dnl     Adds to the library-path
 231 dnl
 232 dnl     Some machines have trouble with multiple -L options.
 233 dnl
 234 dnl $1 is the (list of) directory(s) to add
 235 dnl $2 is the optional name of the variable to update (default LDFLAGS)
 236 dnl
 237 AC_DEFUN([CF_ADD_LIBDIR],
 238 [
 239 if test -n "$1" ; then
 240   for cf_add_libdir in $1
 241   do
 242     if test $cf_add_libdir = /usr/lib ; then
 243       :
 244     elif test -d $cf_add_libdir
 245     then
 246       cf_have_libdir=no
 247       if test -n "$LDFLAGS$LIBS" ; then
 248         # a loop is needed to ensure we can add subdirs of existing dirs
 249         for cf_test_libdir in $LDFLAGS $LIBS ; do
 250           if test ".$cf_test_libdir" = ".-L$cf_add_libdir" ; then
 251             cf_have_libdir=yes; break
 252           fi
 253         done
 254       fi
 255       if test "$cf_have_libdir" = no ; then
 256         CF_VERBOSE(adding $cf_add_libdir to library-path)
 257         ifelse($2,,LDFLAGS,$2)="-L$cf_add_libdir $ifelse($2,,LDFLAGS,$2)"
 258       fi
 259     fi
 260   done
 261 fi
 262 ])dnl
 263 dnl ---------------------------------------------------------------------------
 264 dnl CF_ADD_SUBDIR_PATH version: 2 updated: 2007/07/29 10:12:59
 265 dnl ------------------
 266 dnl Append to a search-list for a nonstandard header/lib-file
 267 dnl     $1 = the variable to return as result
 268 dnl     $2 = the package name
 269 dnl     $3 = the subdirectory, e.g., bin, include or lib
 270 dnl $4 = the directory under which we will test for subdirectories
 271 dnl $5 = a directory that we do not want $4 to match
 272 AC_DEFUN([CF_ADD_SUBDIR_PATH],
 273 [
 274 test "$4" != "$5" && \
 275 test -d "$4" && \
 276 ifelse([$5],NONE,,[(test $5 = NONE || test -d $5) &&]) {
 277         test -n "$verbose" && echo "    ... testing for $3-directories under $4"
 278         test -d $4/$3 &&          $1="[$]$1 $4/$3"
 279         test -d $4/$3/$2 &&       $1="[$]$1 $4/$3/$2"
 280         test -d $4/$3/$2/$3 &&    $1="[$]$1 $4/$3/$2/$3"
 281         test -d $4/$2/$3 &&       $1="[$]$1 $4/$2/$3"
 282         test -d $4/$2/$3/$2 &&    $1="[$]$1 $4/$2/$3/$2"
 283 }
 284 ])dnl
 285 dnl ---------------------------------------------------------------------------
 286 dnl CF_ANSI_CC_CHECK version: 9 updated: 2001/12/30 17:53:34
 287 dnl ----------------
 288 dnl This is adapted from the macros 'fp_PROG_CC_STDC' and 'fp_C_PROTOTYPES'
 289 dnl in the sharutils 4.2 distribution.
 290 AC_DEFUN([CF_ANSI_CC_CHECK],
 291 [
 292 AC_CACHE_CHECK(for ${CC-cc} option to accept ANSI C, cf_cv_ansi_cc,[
 293 cf_cv_ansi_cc=no
 294 cf_save_CFLAGS="$CFLAGS"
 295 cf_save_CPPFLAGS="$CPPFLAGS"
 296 # Don't try gcc -ansi; that turns off useful extensions and
 297 # breaks some systems' header files.
 298 # AIX                   -qlanglvl=ansi
 299 # Ultrix and OSF/1      -std1
 300 # HP-UX                 -Aa -D_HPUX_SOURCE
 301 # SVR4                  -Xc
 302 # UnixWare 1.2          (cannot use -Xc, since ANSI/POSIX clashes)
 303 for cf_arg in "-DCC_HAS_PROTOS" \
 304         "" \
 305         -qlanglvl=ansi \
 306         -std1 \
 307         -Ae \
 308         "-Aa -D_HPUX_SOURCE" \
 309         -Xc
 310 do
 311         CF_ADD_CFLAGS($cf_arg)
 312         AC_TRY_COMPILE(
 313 [
 314 #ifndef CC_HAS_PROTOS
 315 #if !defined(__STDC__) || (__STDC__ != 1)
 316 choke me
 317 #endif
 318 #endif
 319 ],[
 320         int test (int i, double x);
 321         struct s1 {int (*f) (int a);};
 322         struct s2 {int (*f) (double a);};],
 323         [cf_cv_ansi_cc="$cf_arg"; break])
 324 done
 325 CFLAGS="$cf_save_CFLAGS"
 326 CPPFLAGS="$cf_save_CPPFLAGS"
 327 ])
 328
 329 if test "$cf_cv_ansi_cc" != "no"; then
 330 if test ".$cf_cv_ansi_cc" != ".-DCC_HAS_PROTOS"; then
 331         CF_ADD_CFLAGS($cf_cv_ansi_cc)
 332 else
 333         AC_DEFINE(CC_HAS_PROTOS)
 334 fi
 335 fi
 336 ])dnl
 337 dnl ---------------------------------------------------------------------------
 338 dnl CF_ANSI_CC_REQD version: 4 updated: 2008/03/23 14:48:54
 339 dnl ---------------
 340 dnl For programs that must use an ANSI compiler, obtain compiler options that
 341 dnl will make it recognize prototypes.  We'll do preprocessor checks in other
 342 dnl macros, since tools such as unproto can fake prototypes, but only part of
 343 dnl the preprocessor.
 344 AC_DEFUN([CF_ANSI_CC_REQD],
 345 [AC_REQUIRE([CF_ANSI_CC_CHECK])
 346 if test "$cf_cv_ansi_cc" = "no"; then
 347         AC_MSG_ERROR(
 348 [Your compiler does not appear to recognize prototypes.
 349 You have the following choices:
 350         a. adjust your compiler options
 351         b. get an up-to-date compiler
 352         c. use a wrapper such as unproto])
 353 fi
 354 ])dnl
 355 dnl ---------------------------------------------------------------------------
 356 dnl CF_AR_FLAGS version: 4 updated: 2009/02/07 13:42:23
 357 dnl -----------
 358 dnl Check for suitable "ar" (archiver) options for updating an archive.
 359 AC_DEFUN([CF_AR_FLAGS],[
 360 AC_REQUIRE([CF_PROG_AR])
 361
 362 AC_CACHE_CHECK(for options to update archives, cf_cv_ar_flags,[
 363         cf_cv_ar_flags=unknown
 364         for cf_ar_flags in -curv curv -crv crv -cqv cqv -rv rv
 365         do
 366                 rm -f conftest.$ac_cv_objext
 367                 rm -f conftest.a
 368
 369                 cat >conftest.$ac_ext <<EOF
 370 #line __oline__ "configure"
 371 int     testdata[[3]] = { 123, 456, 789 };
 372 EOF
 373                 if AC_TRY_EVAL(ac_compile) ; then
 374                         $AR $cf_ar_flags conftest.a conftest.$ac_cv_objext 2>&AC_FD_CC 1>/dev/null
 375                         if test -f conftest.a ; then
 376                                 cf_cv_ar_flags=$cf_ar_flags
 377                                 break
 378                         fi
 379                 else
 380                         CF_VERBOSE(cannot compile test-program)
 381                         break
 382                 fi
 383         done
 384         rm -f conftest.a conftest.$ac_ext conftest.$ac_cv_objext
 385 ])
 386 test -z "$ARFLAGS" && ARFLAGS=$cf_cv_ar_flags
 387 AC_SUBST(ARFLAGS,$cf_cv_ar_flags)
 388 ])
 389 dnl ---------------------------------------------------------------------------
 390 dnl CF_AWK_BIG_PRINTF version: 3 updated: 2008/12/27 12:30:03
 391 dnl -----------------
 392 dnl Check if awk can handle big strings using printf.  Some older versions of
 393 dnl awk choke on large strings passed via "%s".
 394 dnl
 395 dnl $1 = desired string size
 396 dnl $2 = variable to set with result
 397 AC_DEFUN([CF_AWK_BIG_PRINTF],
 398 [
 399         case x$AWK in #(vi
 400         x)
 401                 eval $2=no
 402                 ;;
 403         *) #(vi
 404                 if ( ${AWK} 'BEGIN { xx = "x"; while (length(xx) < $1) { xx = xx "x"; }; printf("%s\n", xx); }' \
 405                         | $AWK '{ printf "%d\n", length([$]0); }' | $AWK 'BEGIN { eqls=0; recs=0; } { recs++; if ([$]0 == 12000) eqls++; } END { if (recs != 1 || eqls != 1) exit 1; }' 2>/dev/null >/dev/null ) ; then
 406                         eval $2=yes
 407                 else
 408                         eval $2=no
 409                 fi
 410                 ;;
 411         esac
 412 ])dnl
 413 dnl ---------------------------------------------------------------------------
 414 dnl CF_BOOL_DECL version: 8 updated: 2004/01/30 15:51:18
 415 dnl ------------
 416 dnl Test if 'bool' is a builtin type in the configured C++ compiler.  Some
 417 dnl older compilers (e.g., gcc 2.5.8) don't support 'bool' directly; gcc
 418 dnl 2.6.3 does, in anticipation of the ANSI C++ standard.
 419 dnl
 420 dnl Treat the configuration-variable specially here, since we're directly
 421 dnl substituting its value (i.e., 1/0).
 422 dnl
 423 dnl $1 is the shell variable to store the result in, if not $cv_cv_builtin_bool
 424 AC_DEFUN([CF_BOOL_DECL],
 425 [
 426 AC_MSG_CHECKING(if we should include stdbool.h)
 427
 428 AC_CACHE_VAL(cf_cv_header_stdbool_h,[
 429         AC_TRY_COMPILE([],[bool foo = false],
 430                 [cf_cv_header_stdbool_h=0],
 431                 [AC_TRY_COMPILE([
 432 #ifndef __BEOS__
 433 #include <stdbool.h>
 434 #endif
 435 ],[bool foo = false],
 436                         [cf_cv_header_stdbool_h=1],
 437                         [cf_cv_header_stdbool_h=0])])])
 438
 439 if test "$cf_cv_header_stdbool_h" = 1
 440 then    AC_MSG_RESULT(yes)
 441 else    AC_MSG_RESULT(no)
 442 fi
 443
 444 AC_MSG_CHECKING([for builtin bool type])
 445
 446 AC_CACHE_VAL(ifelse($1,,cf_cv_builtin_bool,[$1]),[
 447         AC_TRY_COMPILE([
 448 #include <stdio.h>
 449 #include <sys/types.h>
 450 ],[bool x = false],
 451                 [ifelse($1,,cf_cv_builtin_bool,[$1])=1],
 452                 [ifelse($1,,cf_cv_builtin_bool,[$1])=0])
 453         ])
 454
 455 if test "$ifelse($1,,cf_cv_builtin_bool,[$1])" = 1
 456 then    AC_MSG_RESULT(yes)
 457 else    AC_MSG_RESULT(no)
 458 fi
 459 ])dnl
 460 dnl ---------------------------------------------------------------------------
 461 dnl CF_BOOL_SIZE version: 12 updated: 2006/12/16 12:33:30
 462 dnl ------------
 463 dnl Test for the size of 'bool' in the configured C++ compiler (e.g., a type).
 464 dnl Don't bother looking for bool.h, since it's been deprecated.
 465 dnl
 466 dnl If the current compiler is C rather than C++, we get the bool definition
 467 dnl from <stdbool.h>.
 468 AC_DEFUN([CF_BOOL_SIZE],
 469 [
 470 AC_MSG_CHECKING([for size of bool])
 471 AC_CACHE_VAL(cf_cv_type_of_bool,[
 472         rm -f cf_test.out
 473         AC_TRY_RUN([
 474 #include <stdlib.h>
 475 #include <stdio.h>
 476
 477 #if defined(__cplusplus)
 478
 479 #ifdef HAVE_GXX_BUILTIN_H
 480 #include <g++/builtin.h>
 481 #elif HAVE_GPP_BUILTIN_H
 482 #include <gpp/builtin.h>
 483 #elif HAVE_BUILTIN_H
 484 #include <builtin.h>
 485 #endif
 486
 487 #else
 488
 489 #if $cf_cv_header_stdbool_h
 490 #include <stdbool.h>
 491 #endif
 492
 493 #endif
 494
 495 main()
 496 {
 497         FILE *fp = fopen("cf_test.out", "w");
 498         if (fp != 0) {
 499                 bool x = true;
 500                 if ((bool)(-x) >= 0)
 501                         fputs("unsigned ", fp);
 502                 if (sizeof(x) == sizeof(int))       fputs("int",  fp);
 503                 else if (sizeof(x) == sizeof(char)) fputs("char", fp);
 504                 else if (sizeof(x) == sizeof(short))fputs("short",fp);
 505                 else if (sizeof(x) == sizeof(long)) fputs("long", fp);
 506                 fclose(fp);
 507         }
 508         ${cf_cv_main_return:-return}(0);
 509 }
 510                 ],
 511                 [cf_cv_type_of_bool=`cat cf_test.out`
 512                  if test -z "$cf_cv_type_of_bool"; then
 513                    cf_cv_type_of_bool=unknown
 514                  fi],
 515                 [cf_cv_type_of_bool=unknown],
 516                 [cf_cv_type_of_bool=unknown])
 517         ])
 518         rm -f cf_test.out
 519 AC_MSG_RESULT($cf_cv_type_of_bool)
 520 if test "$cf_cv_type_of_bool" = unknown ; then
 521         case .$NCURSES_BOOL in #(vi
 522         .auto|.) NCURSES_BOOL=unsigned;;
 523         esac
 524         AC_MSG_WARN(Assuming $NCURSES_BOOL for type of bool)
 525         cf_cv_type_of_bool=$NCURSES_BOOL
 526 fi
 527 ])dnl
 528 dnl ---------------------------------------------------------------------------
 529 dnl CF_BUILD_CC version: 6 updated: 2006/10/14 15:23:15
 530 dnl -----------
 531 dnl If we're cross-compiling, allow the user to override the tools and their
 532 dnl options.  The configure script is oriented toward identifying the host
 533 dnl compiler, etc., but we need a build compiler to generate parts of the
 534 dnl source.
 535 dnl
 536 dnl $1 = default for $CPPFLAGS
 537 dnl $2 = default for $LIBS
 538 AC_DEFUN([CF_BUILD_CC],[
 539 AC_REQUIRE([CF_PROG_EXT])
 540 if test "$cross_compiling" = yes ; then
 541
 542         # defaults that we might want to override
 543         : ${BUILD_CFLAGS:=''}
 544         : ${BUILD_CPPFLAGS:='ifelse([$1],,,[$1])'}
 545         : ${BUILD_LDFLAGS:=''}
 546         : ${BUILD_LIBS:='ifelse([$2],,,[$2])'}
 547         : ${BUILD_EXEEXT:='$x'}
 548         : ${BUILD_OBJEXT:='o'}
 549
 550         AC_ARG_WITH(build-cc,
 551                 [  --with-build-cc=XXX     the build C compiler ($BUILD_CC)],
 552                 [BUILD_CC="$withval"],
 553                 [AC_CHECK_PROGS(BUILD_CC, gcc cc cl)])
 554         AC_MSG_CHECKING(for native build C compiler)
 555         AC_MSG_RESULT($BUILD_CC)
 556
 557         AC_MSG_CHECKING(for native build C preprocessor)
 558         AC_ARG_WITH(build-cpp,
 559                 [  --with-build-cpp=XXX    the build C preprocessor ($BUILD_CPP)],
 560                 [BUILD_CPP="$withval"],
 561                 [BUILD_CPP='${BUILD_CC} -E'])
 562         AC_MSG_RESULT($BUILD_CPP)
 563
 564         AC_MSG_CHECKING(for native build C flags)
 565         AC_ARG_WITH(build-cflags,
 566                 [  --with-build-cflags=XXX the build C compiler-flags ($BUILD_CFLAGS)],
 567                 [BUILD_CFLAGS="$withval"])
 568         AC_MSG_RESULT($BUILD_CFLAGS)
 569
 570         AC_MSG_CHECKING(for native build C preprocessor-flags)
 571         AC_ARG_WITH(build-cppflags,
 572                 [  --with-build-cppflags=XXX the build C preprocessor-flags ($BUILD_CPPFLAGS)],
 573                 [BUILD_CPPFLAGS="$withval"])
 574         AC_MSG_RESULT($BUILD_CPPFLAGS)
 575
 576         AC_MSG_CHECKING(for native build linker-flags)
 577         AC_ARG_WITH(build-ldflags,
 578                 [  --with-build-ldflags=XXX the build linker-flags ($BUILD_LDFLAGS)],
 579                 [BUILD_LDFLAGS="$withval"])
 580         AC_MSG_RESULT($BUILD_LDFLAGS)
 581
 582         AC_MSG_CHECKING(for native build linker-libraries)
 583         AC_ARG_WITH(build-libs,
 584                 [  --with-build-libs=XXX   the build libraries (${BUILD_LIBS})],
 585                 [BUILD_LIBS="$withval"])
 586         AC_MSG_RESULT($BUILD_LIBS)
 587
 588         # this assumes we're on Unix.
 589         BUILD_EXEEXT=
 590         BUILD_OBJEXT=o
 591
 592         : ${BUILD_CC:='${CC}'}
 593
 594         if ( test "$BUILD_CC" = "$CC" || test "$BUILD_CC" = '${CC}' ) ; then
 595                 AC_MSG_ERROR([Cross-build requires two compilers.
 596 Use --with-build-cc to specify the native compiler.])
 597         fi
 598
 599 else
 600         : ${BUILD_CC:='${CC}'}
 601         : ${BUILD_CPP:='${CPP}'}
 602         : ${BUILD_CFLAGS:='${CFLAGS}'}
 603         : ${BUILD_CPPFLAGS:='${CPPFLAGS}'}
 604         : ${BUILD_LDFLAGS:='${LDFLAGS}'}
 605         : ${BUILD_LIBS:='${LIBS}'}
 606         : ${BUILD_EXEEXT:='$x'}
 607         : ${BUILD_OBJEXT:='o'}
 608 fi
 609
 610 AC_SUBST(BUILD_CC)
 611 AC_SUBST(BUILD_CPP)
 612 AC_SUBST(BUILD_CFLAGS)
 613 AC_SUBST(BUILD_CPPFLAGS)
 614 AC_SUBST(BUILD_LDFLAGS)
 615 AC_SUBST(BUILD_LIBS)
 616 AC_SUBST(BUILD_EXEEXT)
 617 AC_SUBST(BUILD_OBJEXT)
 618 ])dnl
 619 dnl ---------------------------------------------------------------------------
 620 dnl CF_CFG_DEFAULTS version: 7 updated: 2005/09/24 16:15:00
 621 dnl ---------------
 622 dnl Determine the default configuration into which we'll install ncurses.  This
 623 dnl can be overridden by the user's command-line options.  There's two items to
 624 dnl look for:
 625 dnl     1. the prefix (e.g., /usr)
 626 dnl     2. the header files (e.g., /usr/include/ncurses)
 627 dnl We'll look for a previous installation of ncurses and use the same defaults.
 628 dnl
 629 dnl We don't use AC_PREFIX_DEFAULT, because it gets evaluated too soon, and
 630 dnl we don't use AC_PREFIX_PROGRAM, because we cannot distinguish ncurses's
 631 dnl programs from a vendor's.
 632 AC_DEFUN([CF_CFG_DEFAULTS],
 633 [
 634 AC_MSG_CHECKING(for prefix)
 635 if test "x$prefix" = "xNONE" ; then
 636         case "$cf_cv_system_name" in
 637                 # non-vendor systems don't have a conflict
 638         openbsd*|freebsd*|linux*|cygwin*|k*bsd*-gnu)
 639                 prefix=/usr
 640                 ;;
 641         *)      prefix=$ac_default_prefix
 642                 ;;
 643         esac
 644 fi
 645 AC_MSG_RESULT($prefix)
 646
 647 if test "x$prefix" = "xNONE" ; then
 648 AC_MSG_CHECKING(for default include-directory)
 649 test -n "$verbose" && echo 1>&AC_FD_MSG
 650 for cf_symbol in \
 651         $includedir \
 652         $includedir/ncurses \
 653         $prefix/include \
 654         $prefix/include/ncurses \
 655         /usr/local/include \
 656         /usr/local/include/ncurses \
 657         /usr/include \
 658         /usr/include/ncurses
 659 do
 660         cf_dir=`eval echo $cf_symbol`
 661         if test -f $cf_dir/curses.h ; then
 662         if ( fgrep NCURSES_VERSION $cf_dir/curses.h 2>&1 >/dev/null ) ; then
 663                 includedir="$cf_symbol"
 664                 test -n "$verbose"  && echo $ac_n "     found " 1>&AC_FD_MSG
 665                 break
 666         fi
 667         fi
 668         test -n "$verbose"  && echo "   tested $cf_dir" 1>&AC_FD_MSG
 669 done
 670 AC_MSG_RESULT($includedir)
 671 fi
 672 ])dnl
 673 dnl ---------------------------------------------------------------------------
 674 dnl CF_CGETENT version: 3 updated: 2000/08/12 23:18:52
 675 dnl ----------
 676 dnl Check if the terminal-capability database functions are available.  If not,
 677 dnl ncurses has a much-reduced version.
 678 AC_DEFUN([CF_CGETENT],[
 679 AC_MSG_CHECKING(for terminal-capability database functions)
 680 AC_CACHE_VAL(cf_cv_cgetent,[
 681 AC_TRY_LINK([
 682 #include <stdlib.h>],[
 683         char temp[128];
 684         char *buf = temp;
 685         char *db_array = temp;
 686         cgetent(&buf, /* int *, */ &db_array, "vt100");
 687         cgetcap(buf, "tc", '=');
 688         cgetmatch(buf, "tc");
 689         ],
 690         [cf_cv_cgetent=yes],
 691         [cf_cv_cgetent=no])
 692 ])
 693 AC_MSG_RESULT($cf_cv_cgetent)
 694 test "$cf_cv_cgetent" = yes && AC_DEFINE(HAVE_BSD_CGETENT)
 695 ])dnl
 696 dnl ---------------------------------------------------------------------------
 697 dnl CF_CHECK_CACHE version: 11 updated: 2008/03/23 14:45:59
 698 dnl --------------
 699 dnl Check if we're accidentally using a cache from a different machine.
 700 dnl Derive the system name, as a check for reusing the autoconf cache.
 701 dnl
 702 dnl If we've packaged config.guess and config.sub, run that (since it does a
 703 dnl better job than uname).  Normally we'll use AC_CANONICAL_HOST, but allow
 704 dnl an extra parameter that we may override, e.g., for AC_CANONICAL_SYSTEM
 705 dnl which is useful in cross-compiles.
 706 dnl
 707 dnl Note: we would use $ac_config_sub, but that is one of the places where
 708 dnl autoconf 2.5x broke compatibility with autoconf 2.13
 709 AC_DEFUN([CF_CHECK_CACHE],
 710 [
 711 if test -f $srcdir/config.guess || test -f $ac_aux_dir/config.guess ; then
 712         ifelse([$1],,[AC_CANONICAL_HOST],[$1])
 713         system_name="$host_os"
 714 else
 715         system_name="`(uname -s -r) 2>/dev/null`"
 716         if test -z "$system_name" ; then
 717                 system_name="`(hostname) 2>/dev/null`"
 718         fi
 719 fi
 720 test -n "$system_name" && AC_DEFINE_UNQUOTED(SYSTEM_NAME,"$system_name")
 721 AC_CACHE_VAL(cf_cv_system_name,[cf_cv_system_name="$system_name"])
 722
 723 test -z "$system_name" && system_name="$cf_cv_system_name"
 724 test -n "$cf_cv_system_name" && AC_MSG_RESULT(Configuring for $cf_cv_system_name)
 725
 726 if test ".$system_name" != ".$cf_cv_system_name" ; then
 727         AC_MSG_RESULT(Cached system name ($system_name) does not agree with actual ($cf_cv_system_name))
 728         AC_MSG_ERROR("Please remove config.cache and try again.")
 729 fi
 730 ])dnl
 731 dnl ---------------------------------------------------------------------------
 732 dnl CF_CHECK_ERRNO version: 10 updated: 2008/08/22 16:33:22
 733 dnl --------------
 734 dnl Check for data that is usually declared in <stdio.h> or <errno.h>, e.g.,
 735 dnl the 'errno' variable.  Define a DECL_xxx symbol if we must declare it
 736 dnl ourselves.
 737 dnl
 738 dnl $1 = the name to check
 739 dnl $2 = the assumed type
 740 AC_DEFUN([CF_CHECK_ERRNO],
 741 [
 742 AC_CACHE_CHECK(if external $1 is declared, cf_cv_dcl_$1,[
 743     AC_TRY_COMPILE([
 744 #ifdef HAVE_STDLIB_H
 745 #include <stdlib.h>
 746 #endif
 747 #include <stdio.h>
 748 #include <sys/types.h>
 749 #include <errno.h> ],
 750     ifelse($2,,int,$2) x = (ifelse($2,,int,$2)) $1,
 751     [cf_cv_dcl_$1=yes],
 752     [cf_cv_dcl_$1=no])
 753 ])
 754
 755 if test "$cf_cv_dcl_$1" = no ; then
 756     CF_UPPER(cf_result,decl_$1)
 757     AC_DEFINE_UNQUOTED($cf_result)
 758 fi
 759
 760 # It's possible (for near-UNIX clones) that the data doesn't exist
 761 CF_CHECK_EXTERN_DATA($1,ifelse($2,,int,$2))
 762 ])dnl
 763 dnl ---------------------------------------------------------------------------
 764 dnl CF_CHECK_EXTERN_DATA version: 3 updated: 2001/12/30 18:03:23
 765 dnl --------------------
 766 dnl Check for existence of external data in the current set of libraries.  If
 767 dnl we can modify it, it's real enough.
 768 dnl $1 = the name to check
 769 dnl $2 = its type
 770 AC_DEFUN([CF_CHECK_EXTERN_DATA],
 771 [
 772 AC_CACHE_CHECK(if external $1 exists, cf_cv_have_$1,[
 773     AC_TRY_LINK([
 774 #undef $1
 775 extern $2 $1;
 776 ],
 777     [$1 = 2],
 778     [cf_cv_have_$1=yes],
 779     [cf_cv_have_$1=no])
 780 ])
 781
 782 if test "$cf_cv_have_$1" = yes ; then
 783     CF_UPPER(cf_result,have_$1)
 784     AC_DEFINE_UNQUOTED($cf_result)
 785 fi
 786
 787 ])dnl
 788 dnl ---------------------------------------------------------------------------
 789 dnl CF_CHECK_GPM_WGETCH version: 1 updated: 2007/04/28 14:38:06
 790 dnl -------------------
 791 dnl Check if GPM is already linked with curses.  If so - and if the linkage
 792 dnl is not "weak" - warn about this because it can create problems linking
 793 dnl applications with ncurses.
 794 AC_DEFUN([CF_CHECK_GPM_WGETCH],[
 795 AC_CHECK_LIB(gpm,Gpm_Wgetch,[
 796
 797 AC_CACHE_CHECK(if GPM is weakly bound to curses library, cf_cv_check_gpm_wgetch,[
 798 cf_cv_check_gpm_wgetch=unknown
 799 if test "$cross_compiling" != yes ; then
 800
 801 cat >conftest.$ac_ext <<CF_EOF
 802 #include <gpm.h>
 803 int main()
 804 {
 805         Gpm_Wgetch();
 806         ${cf_cv_main_return:-return}(0);
 807 }
 808 CF_EOF
 809
 810         cf_save_LIBS="$LIBS"
 811         # This only works if we can look at the symbol table.  If a shared
 812         # library is stripped for install, we cannot use that.  So we're forced
 813         # to rely on the static library, noting that some packagers may not
 814         # include it.
 815         LIBS="-static -lgpm -dynamic $LIBS"
 816         if AC_TRY_EVAL(ac_compile) ; then
 817                 if AC_TRY_EVAL(ac_link) ; then
 818                         cf_cv_check_gpm_wgetch=`nm conftest$ac_exeext | egrep '\<wgetch\>' | egrep '\<[[vVwW]]\>'`
 819                         test -n "$cf_cv_check_gpm_wgetch" && cf_cv_check_gpm_wgetch=yes
 820                         test -z "$cf_cv_check_gpm_wgetch" && cf_cv_check_gpm_wgetch=no
 821                 fi
 822         fi
 823         rm -f conftest*
 824         LIBS="$cf_save_LIBS"
 825 fi
 826 ])
 827
 828 if test "$cf_cv_check_gpm_wgetch" != yes ; then
 829         AC_MSG_WARN(GPM library is already linked with curses - read the FAQ)
 830 fi
 831 ])])dnl
 832 dnl ---------------------------------------------------------------------------
 833 dnl CF_CPP_PARAM_INIT version: 4 updated: 2001/04/07 22:31:18
 834 dnl -----------------
 835 dnl Check if the C++ compiler accepts duplicate parameter initialization.  This
 836 dnl is a late feature for the standard and is not in some recent compilers
 837 dnl (1999/9/11).
 838 AC_DEFUN([CF_CPP_PARAM_INIT],
 839 [
 840 if test -n "$CXX"; then
 841 AC_CACHE_CHECK(if $CXX accepts parameter initialization,cf_cv_cpp_param_init,[
 842         AC_LANG_SAVE
 843         AC_LANG_CPLUSPLUS
 844         AC_TRY_RUN([
 845 class TEST {
 846 private:
 847         int value;
 848 public:
 849         TEST(int x = 1);
 850         ~TEST();
 851 };
 852
 853 TEST::TEST(int x = 1)   // some compilers do not like second initializer
 854 {
 855         value = x;
 856 }
 857 void main() { }
 858 ],
 859         [cf_cv_cpp_param_init=yes],
 860         [cf_cv_cpp_param_init=no],
 861         [cf_cv_cpp_param_init=unknown])
 862         AC_LANG_RESTORE
 863 ])
 864 fi
 865 test "$cf_cv_cpp_param_init" = yes && AC_DEFINE(CPP_HAS_PARAM_INIT)
 866 ])dnl
 867 dnl ---------------------------------------------------------------------------
 868 dnl CF_CPP_STATIC_CAST version: 1 updated: 2005/07/23 16:52:43
 869 dnl ------------------
 870 dnl Check if the C++ compiler accepts static_cast in generics.  This appears to
 871 dnl not be supported in g++ before 3.0
 872 AC_DEFUN([CF_CPP_STATIC_CAST],
 873 [
 874 if test -n "$CXX"; then
 875
 876 AC_CACHE_CHECK(if $CXX accepts static_cast,cf_cv_cpp_static_cast,[
 877         AC_LANG_SAVE
 878         AC_LANG_CPLUSPLUS
 879
 880         AC_TRY_COMPILE([
 881 class NCursesPanel
 882 {
 883 public:
 884   NCursesPanel(int nlines,
 885                int ncols,
 886                int begin_y = 0,
 887                int begin_x = 0)
 888   {
 889   }
 890
 891   ~NCursesPanel();
 892 };
 893
 894 template<class T> class NCursesUserPanel : public NCursesPanel
 895 {
 896 public:
 897   NCursesUserPanel (int nlines,
 898                     int ncols,
 899                     int begin_y = 0,
 900                     int begin_x = 0,
 901                     const T* p_UserData = static_cast<T*>(0))
 902     : NCursesPanel (nlines, ncols, begin_y, begin_x)
 903   {
 904   };
 905   NCursesUserPanel(const T* p_UserData = static_cast<T*>(0)) : NCursesPanel()
 906   {
 907   };
 908
 909   virtual ~NCursesUserPanel() {};
 910 };
 911 ],[
 912         const char* p_UserData = static_cast<char*>(0)],
 913         [cf_cv_cpp_static_cast=yes],
 914         [cf_cv_cpp_static_cast=no])
 915
 916         AC_LANG_RESTORE
 917 ])
 918
 919 fi
 920
 921 test "$cf_cv_cpp_static_cast" = yes && AC_DEFINE(CPP_HAS_STATIC_CAST)
 922 ])dnl
 923 dnl ---------------------------------------------------------------------------
 924 dnl CF_C_INLINE version: 2 updated: 2007/08/11 14:09:50
 925 dnl -----------
 926 dnl Check if the C compiler supports "inline".
 927 dnl $1 is the name of a shell variable to set if inline is supported
 928 dnl $2 is the threshold for gcc 4.x's option controlling maximum inline size
 929 AC_DEFUN([CF_C_INLINE],[
 930 AC_C_INLINE
 931 $1=
 932 if test "$ac_cv_c_inline" != no ; then
 933   $1=inline
 934   if test "$INTEL_COMPILER" = yes
 935   then
 936     :
 937   elif test "$GCC" = yes
 938   then
 939     AC_CACHE_CHECK(if gcc supports options to tune inlining,cf_cv_gcc_inline,[
 940       cf_save_CFLAGS=$CFLAGS
 941       CFLAGS="$CFLAGS --param max-inline-insns-single=$2"
 942       AC_TRY_COMPILE([inline int foo(void) { return 1; }],
 943       [${cf_cv_main_return:-return} foo()],
 944       [cf_cv_gcc_inline=yes],
 945       [cf_cv_gcc_inline=no])
 946       CFLAGS=$cf_save_CFLAGS
 947     ])
 948     if test "$cf_cv_gcc_inline" = yes ; then
 949         CF_ADD_CFLAGS([--param max-inline-insns-single=$2])
 950     fi
 951   fi
 952 fi
 953 AC_SUBST($1)
 954 ])dnl
 955 dnl ---------------------------------------------------------------------------
 956 dnl CF_DIRNAME version: 4 updated: 2002/12/21 19:25:52
 957 dnl ----------
 958 dnl "dirname" is not portable, so we fake it with a shell script.
 959 AC_DEFUN([CF_DIRNAME],[$1=`echo $2 | sed -e 's%/[[^/]]*$%%'`])dnl
 960 dnl ---------------------------------------------------------------------------
 961 dnl CF_DIRS_TO_MAKE version: 3 updated: 2002/02/23 20:38:31
 962 dnl ---------------
 963 AC_DEFUN([CF_DIRS_TO_MAKE],
 964 [
 965 DIRS_TO_MAKE="lib"
 966 for cf_item in $cf_list_models
 967 do
 968         CF_OBJ_SUBDIR($cf_item,cf_subdir)
 969         for cf_item2 in $DIRS_TO_MAKE
 970         do
 971                 test $cf_item2 = $cf_subdir && break
 972         done
 973         test ".$cf_item2" != ".$cf_subdir" && DIRS_TO_MAKE="$DIRS_TO_MAKE $cf_subdir"
 974 done
 975 for cf_dir in $DIRS_TO_MAKE
 976 do
 977         test ! -d $cf_dir && mkdir $cf_dir
 978 done
 979 AC_SUBST(DIRS_TO_MAKE)
 980 ])dnl
 981 dnl ---------------------------------------------------------------------------
 982 dnl CF_DISABLE_LEAKS version: 4 updated: 2006/12/16 15:10:42
 983 dnl ----------------
 984 dnl Combine no-leak checks with the libraries or tools that are used for the
 985 dnl checks.
 986 AC_DEFUN([CF_DISABLE_LEAKS],[
 987
 988 AC_REQUIRE([CF_WITH_DMALLOC])
 989 AC_REQUIRE([CF_WITH_DBMALLOC])
 990 AC_REQUIRE([CF_WITH_VALGRIND])
 991
 992 AC_MSG_CHECKING(if you want to perform memory-leak testing)
 993 AC_ARG_ENABLE(leaks,
 994         [  --disable-leaks         test: free permanent memory, analyze leaks],
 995         [with_no_leaks=yes],
 996         : ${with_no_leaks:=no})
 997 AC_MSG_RESULT($with_no_leaks)
 998
 999 if test "$with_no_leaks" = yes ; then
1000         AC_DEFINE(NO_LEAKS)
1001 fi
1002 ])dnl
1003 dnl ---------------------------------------------------------------------------
1004 dnl CF_ENABLE_RPATH version: 1 updated: 2008/09/13 10:22:30
1005 dnl ---------------
1006 dnl Check if the rpath option should be used, setting cache variable
1007 dnl cf_cv_ld_rpath if so.
1008 AC_DEFUN([CF_ENABLE_RPATH],
1009 [
1010 AC_MSG_CHECKING(if rpath option should be used)
1011 AC_ARG_ENABLE(rpath,
1012 [  --enable-rpath          use rpath option when generating shared libraries],
1013 [cf_cv_ld_rpath=$enableval],
1014 [cf_cv_ld_rpath=no])
1015 AC_MSG_RESULT($cf_cv_ld_rpath)
1016 ])dnl
1017 dnl ---------------------------------------------------------------------------
1018 dnl CF_ERRNO version: 5 updated: 1997/11/30 12:44:39
1019 dnl --------
1020 dnl Check if 'errno' is declared in <errno.h>
1021 AC_DEFUN([CF_ERRNO],
1022 [
1023 CF_CHECK_ERRNO(errno)
1024 ])dnl
1025 dnl ---------------------------------------------------------------------------
1026 dnl CF_ETIP_DEFINES version: 3 updated: 2003/03/22 19:13:43
1027 dnl ---------------
1028 dnl Test for conflicting definitions of exception in gcc 2.8.0, etc., between
1029 dnl math.h and builtin.h, only for ncurses
1030 AC_DEFUN([CF_ETIP_DEFINES],
1031 [
1032 AC_MSG_CHECKING(for special defines needed for etip.h)
1033 cf_save_CXXFLAGS="$CXXFLAGS"
1034 cf_result="none"
1035 for cf_math in "" MATH_H
1036 do
1037 for cf_excp in "" MATH_EXCEPTION
1038 do
1039         CXXFLAGS="$cf_save_CXXFLAGS -I${srcdir}/c++ -I${srcdir}/menu -I${srcdir}/include"
1040         test -n "$cf_math" && CXXFLAGS="$CXXFLAGS -DETIP_NEEDS_${cf_math}"
1041         test -n "$cf_excp" && CXXFLAGS="$CXXFLAGS -DETIP_NEEDS_${cf_excp}"
1042 AC_TRY_COMPILE([
1043 #include <etip.h.in>
1044 ],[],[
1045         test -n "$cf_math" && AC_DEFINE_UNQUOTED(ETIP_NEEDS_${cf_math})
1046         test -n "$cf_excp" && AC_DEFINE_UNQUOTED(ETIP_NEEDS_${cf_excp})
1047         cf_result="$cf_math $cf_excp"
1048         break
1049 ],[])
1050 done
1051 done
1052 AC_MSG_RESULT($cf_result)
1053 CXXFLAGS="$cf_save_CXXFLAGS"
1054 ])
1055 dnl ---------------------------------------------------------------------------
1056 dnl CF_FIND_LINKAGE version: 13 updated: 2008/12/24 07:59:55
1057 dnl ---------------
1058 dnl Find a library (specifically the linkage used in the code fragment),
1059 dnl searching for it if it is not already in the library path.
1060 dnl See also CF_ADD_SEARCHPATH.
1061 dnl
1062 dnl Parameters (4-on are optional):
1063 dnl     $1 = headers for library entrypoint
1064 dnl     $2 = code fragment for library entrypoint
1065 dnl     $3 = the library name without the "-l" option or ".so" suffix.
1066 dnl     $4 = action to perform if successful (default: update CPPFLAGS, etc)
1067 dnl     $5 = action to perform if not successful
1068 dnl     $6 = module name, if not the same as the library name
1069 dnl     $7 = extra libraries
1070 dnl
1071 dnl Sets these variables:
1072 dnl     $cf_cv_find_linkage_$3 - yes/no according to whether linkage is found
1073 dnl     $cf_cv_header_path_$3 - include-directory if needed
1074 dnl     $cf_cv_library_path_$3 - library-directory if needed
1075 dnl     $cf_cv_library_file_$3 - library-file if needed, e.g., -l$3
1076 AC_DEFUN([CF_FIND_LINKAGE],[
1077
1078 # If the linkage is not already in the $CPPFLAGS/$LDFLAGS configuration, these
1079 # will be set on completion of the AC_TRY_LINK below.
1080 cf_cv_header_path_$3=
1081 cf_cv_library_path_$3=
1082
1083 CF_MSG_LOG([Starting [FIND_LINKAGE]($3,$6)])
1084
1085 AC_TRY_LINK([$1],[$2],
1086     cf_cv_find_linkage_$3=yes,[
1087     cf_cv_find_linkage_$3=no
1088
1089     CF_VERBOSE(find linkage for $3 library)
1090     CF_MSG_LOG([Searching for headers in [FIND_LINKAGE]($3,$6)])
1091
1092     cf_save_CPPFLAGS="$CPPFLAGS"
1093     cf_test_CPPFLAGS="$CPPFLAGS"
1094
1095     CF_HEADER_PATH(cf_search,ifelse([$6],,[$3],[$6]))
1096     for cf_cv_header_path_$3 in $cf_search
1097     do
1098       if test -d $cf_cv_header_path_$3 ; then
1099         CF_VERBOSE(... testing $cf_cv_header_path_$3)
1100         CPPFLAGS="$cf_save_CPPFLAGS -I$cf_cv_header_path_$3"
1101         AC_TRY_COMPILE([$1],[$2],[
1102             CF_VERBOSE(... found $3 headers in $cf_cv_header_path_$3)
1103             cf_cv_find_linkage_$3=maybe
1104             cf_test_CPPFLAGS="$CPPFLAGS"
1105             break],[
1106             CPPFLAGS="$cf_save_CPPFLAGS"
1107             ])
1108       fi
1109     done
1110
1111     if test "$cf_cv_find_linkage_$3" = maybe ; then
1112
1113       CF_MSG_LOG([Searching for $3 library in [FIND_LINKAGE]($3,$6)])
1114
1115       cf_save_LIBS="$LIBS"
1116       cf_save_LDFLAGS="$LDFLAGS"
1117
1118       ifelse([$6],,,[
1119         CPPFLAGS="$cf_test_CPPFLAGS"
1120         LIBS="-l$3 $7 $cf_save_LIBS"
1121         AC_TRY_LINK([$1],[$2],[
1122             CF_VERBOSE(... found $3 library in system)
1123             cf_cv_find_linkage_$3=yes])
1124             CPPFLAGS="$cf_save_CPPFLAGS"
1125             LIBS="$cf_save_LIBS"
1126             ])
1127
1128       if test "$cf_cv_find_linkage_$3" != yes ; then
1129         CF_LIBRARY_PATH(cf_search,$3)
1130         for cf_cv_library_path_$3 in $cf_search
1131         do
1132           if test -d $cf_cv_library_path_$3 ; then
1133             CF_VERBOSE(... testing $cf_cv_library_path_$3)
1134             CPPFLAGS="$cf_test_CPPFLAGS"
1135             LIBS="-l$3 $7 $cf_save_LIBS"
1136             LDFLAGS="$cf_save_LDFLAGS -L$cf_cv_library_path_$3"
1137             AC_TRY_LINK([$1],[$2],[
1138                 CF_VERBOSE(... found $3 library in $cf_cv_library_path_$3)
1139                 cf_cv_find_linkage_$3=yes
1140                 cf_cv_library_file_$3="-l$3"
1141                 break],[
1142                 CPPFLAGS="$cf_save_CPPFLAGS"
1143                 LIBS="$cf_save_LIBS"
1144                 LDFLAGS="$cf_save_LDFLAGS"
1145                 ])
1146           fi
1147         done
1148         LIBS="$cf_save_LIBS"
1149         CPPFLAGS="$cf_save_CPPFLAGS"
1150         LDFLAGS="$cf_save_LDFLAGS"
1151       fi
1152
1153     else
1154       cf_cv_find_linkage_$3=no
1155     fi
1156     ],$7)
1157
1158 if test "$cf_cv_find_linkage_$3" = yes ; then
1159 ifelse([$4],,[
1160   CF_ADD_INCDIR($cf_cv_header_path_$3)
1161   CF_ADD_LIBDIR($cf_cv_library_path_$3)
1162   LIBS="-l$3 $LIBS"
1163 ],[$4])
1164 else
1165 ifelse([$5],,AC_MSG_WARN(Cannot find $3 library),[$5])
1166 fi
1167 ])dnl
1168 dnl ---------------------------------------------------------------------------
1169 dnl CF_FUNC_DLSYM version: 1 updated: 2004/06/16 20:52:45
1170 dnl -------------
1171 dnl Test for dlsym() and related functions, as well as libdl.
1172 dnl
1173 dnl Sets
1174 dnl     $cf_have_dlsym
1175 dnl     $cf_have_libdl
1176 AC_DEFUN([CF_FUNC_DLSYM],[
1177 cf_have_dlsym=no
1178 AC_CHECK_FUNC(dlsym,cf_have_dlsym=yes,[
1179
1180 cf_have_libdl=no
1181 AC_CHECK_LIB(dl,dlsym,[
1182         cf_have_dlsym=yes
1183         cf_have_libdl=yes])])
1184
1185 if test "$cf_have_dlsym" = yes ; then
1186         test "$cf_have_libdl" = yes && LIBS="-ldl $LIBS"
1187
1188         AC_MSG_CHECKING(whether able to link to dl*() functions)
1189         AC_TRY_LINK([#include <dlfcn.h>],[
1190                 void *obj;
1191                 if ((obj = dlopen("filename", 0)) != 0) {
1192                         if (dlsym(obj, "symbolname") == 0) {
1193                         dlclose(obj);
1194                         }
1195                 }],[
1196                 AC_DEFINE(HAVE_LIBDL)],[
1197                 AC_MSG_ERROR(Cannot link test program for libdl)])
1198         AC_MSG_RESULT(ok)
1199 else
1200         AC_MSG_ERROR(Cannot find dlsym function)
1201 fi
1202 ])
1203 dnl ---------------------------------------------------------------------------
1204 dnl CF_FUNC_MEMMOVE version: 7 updated: 2006/12/16 12:33:30
1205 dnl ---------------
1206 dnl Check for memmove, or a bcopy that can handle overlapping copy.  If neither
1207 dnl is found, add our own version of memmove to the list of objects.
1208 AC_DEFUN([CF_FUNC_MEMMOVE],
1209 [
1210 AC_CHECK_FUNC(memmove,,[
1211 AC_CHECK_FUNC(bcopy,[
1212         AC_CACHE_CHECK(if bcopy does overlapping moves,cf_cv_good_bcopy,[
1213                 AC_TRY_RUN([
1214 int main() {
1215         static char data[] = "abcdefghijklmnopqrstuwwxyz";
1216         char temp[40];
1217         bcopy(data, temp, sizeof(data));
1218         bcopy(temp+10, temp, 15);
1219         bcopy(temp+5, temp+15, 10);
1220         ${cf_cv_main_return:-return} (strcmp(temp, "klmnopqrstuwwxypqrstuwwxyz"));
1221 }
1222                 ],
1223                 [cf_cv_good_bcopy=yes],
1224                 [cf_cv_good_bcopy=no],
1225                 [cf_cv_good_bcopy=unknown])
1226                 ])
1227         ],[cf_cv_good_bcopy=no])
1228         if test "$cf_cv_good_bcopy" = yes ; then
1229                 AC_DEFINE(USE_OK_BCOPY)
1230         else
1231                 AC_DEFINE(USE_MY_MEMMOVE)
1232         fi
1233 ])])dnl
1234 dnl ---------------------------------------------------------------------------
1235 dnl CF_FUNC_NANOSLEEP version: 3 updated: 2006/12/16 12:33:30
1236 dnl -----------------
1237 dnl Check for existence of workable nanosleep() function.  Some systems, e.g.,
1238 dnl AIX 4.x, provide a non-working version.
1239 AC_DEFUN([CF_FUNC_NANOSLEEP],[
1240 AC_CACHE_CHECK(if nanosleep really works,cf_cv_func_nanosleep,[
1241 AC_TRY_RUN([
1242 #include <stdio.h>
1243 #include <errno.h>
1244 #include <time.h>
1245
1246 #ifdef HAVE_SYS_TIME_H
1247 #include <sys/time.h>
1248 #endif
1249
1250 int main() {
1251         struct timespec ts1, ts2;
1252         int code;
1253         ts1.tv_sec  = 0;
1254         ts1.tv_nsec = 750000000;
1255         ts2.tv_sec  = 0;
1256         ts2.tv_nsec = 0;
1257         errno = 0;
1258         code = nanosleep(&ts1, &ts2); /* on failure errno is ENOSYS. */
1259         ${cf_cv_main_return:-return}(code != 0);
1260 }
1261 ],
1262         [cf_cv_func_nanosleep=yes],
1263         [cf_cv_func_nanosleep=no],
1264         [cf_cv_func_nanosleep=unknown])])
1265
1266 test "$cf_cv_func_nanosleep" = "yes" && AC_DEFINE(HAVE_NANOSLEEP)
1267 ])
1268 dnl ---------------------------------------------------------------------------
1269 dnl CF_FUNC_OPENPTY version: 2 updated: 2008/04/12 19:49:01
1270 dnl ---------------
1271 dnl Check for openpty() function, along with <pty.h> header.  It may need the
1272 dnl "util" library as well.
1273 AC_DEFUN([CF_FUNC_OPENPTY],
1274 [
1275 AC_CHECK_LIB(util,openpty,cf_cv_lib_util=yes,cf_cv_lib_util=no)
1276 AC_CACHE_CHECK(for openpty header,cf_cv_func_openpty,[
1277     cf_save_LIBS="$LIBS"
1278     test $cf_cv_lib_util = yes && LIBS="-lutil $LIBS"
1279     for cf_header in pty.h libutil.h util.h
1280     do
1281     AC_TRY_LINK([
1282 #include <$cf_header>
1283 ],[
1284     int x = openpty((int *)0, (int *)0, (char *)0,
1285                    (struct termios *)0, (struct winsize *)0);
1286 ],[
1287         cf_cv_func_openpty=$cf_header
1288         break
1289 ],[
1290         cf_cv_func_openpty=no
1291 ])
1292     done
1293     LIBS="$cf_save_LIBS"
1294 ])
1295 ])dnl
1296 dnl ---------------------------------------------------------------------------
1297 dnl CF_FUNC_POLL version: 4 updated: 2006/12/16 12:33:30
1298 dnl ------------
1299 dnl See if the poll function really works.  Some platforms have poll(), but
1300 dnl it does not work for terminals or files.
1301 AC_DEFUN([CF_FUNC_POLL],[
1302 AC_CACHE_CHECK(if poll really works,cf_cv_working_poll,[
1303 AC_TRY_RUN([
1304 #include <stdio.h>
1305 #ifdef HAVE_POLL_H
1306 #include <poll.h>
1307 #else
1308 #include <sys/poll.h>
1309 #endif
1310 int main() {
1311         struct pollfd myfds;
1312         int ret;
1313
1314         myfds.fd = 0;
1315         myfds.events = POLLIN;
1316
1317         ret = poll(&myfds, 1, 100);
1318         ${cf_cv_main_return:-return}(ret != 0);
1319 }],
1320         [cf_cv_working_poll=yes],
1321         [cf_cv_working_poll=no],
1322         [cf_cv_working_poll=unknown])])
1323 test "$cf_cv_working_poll" = "yes" && AC_DEFINE(HAVE_WORKING_POLL)
1324 ])dnl
1325 dnl ---------------------------------------------------------------------------
1326 dnl CF_FUNC_TERMIOS version: 2 updated: 2000/07/22 23:37:24
1327 dnl ---------------
1328 dnl Some old/broken variations define tcgetattr() only as a macro in
1329 dnl termio(s).h
1330 AC_DEFUN([CF_FUNC_TERMIOS],[
1331 AC_REQUIRE([CF_STRUCT_TERMIOS])
1332 AC_CACHE_CHECK(for tcgetattr, cf_cv_have_tcgetattr,[
1333 AC_TRY_LINK([
1334 #include <sys/types.h>
1335 #ifdef HAVE_UNISTD_H
1336 #include <unistd.h>
1337 #endif
1338 #ifdef HAVE_TERMIOS_H
1339 #include <termios.h>
1340 #define TTY struct termios
1341 #else
1342 #ifdef HAVE_TERMIO_H
1343 #include <termio.h>
1344 #define TTY struct termio
1345 #endif
1346 #endif
1347 ],[
1348 TTY foo;
1349 tcgetattr(1, &foo);],
1350 [cf_cv_have_tcgetattr=yes],
1351 [cf_cv_have_tcgetattr=no])])
1352 test "$cf_cv_have_tcgetattr" = yes && AC_DEFINE(HAVE_TCGETATTR)
1353 ])dnl
1354 dnl ---------------------------------------------------------------------------
1355 dnl CF_FUNC_VSSCANF version: 3 updated: 2001/12/19 00:50:10
1356 dnl ---------------
1357 dnl Check for vsscanf() function, which is in c9x but generally not in earlier
1358 dnl versions of C.  It is in the GNU C library, and can often be simulated by
1359 dnl other functions.
1360 AC_DEFUN([CF_FUNC_VSSCANF],
1361 [
1362 AC_CACHE_CHECK(for vsscanf function or workaround,cf_cv_func_vsscanf,[
1363 AC_TRY_LINK([
1364 #include <stdarg.h>
1365 #include <stdio.h>],[
1366         va_list ap;
1367         vsscanf("from", "%d", ap)],[cf_cv_func_vsscanf=vsscanf],[
1368 AC_TRY_LINK([
1369 #include <stdarg.h>
1370 #include <stdio.h>],[
1371     FILE strbuf;
1372     char *str = "from";
1373
1374     strbuf._flag = _IOREAD;
1375     strbuf._ptr = strbuf._base = (unsigned char *) str;
1376     strbuf._cnt = strlen(str);
1377     strbuf._file = _NFILE;
1378     return (vfscanf(&strbuf, "%d", ap))],[cf_cv_func_vsscanf=vfscanf],[
1379 AC_TRY_LINK([
1380 #include <stdarg.h>
1381 #include <stdio.h>],[
1382     FILE strbuf;
1383     char *str = "from";
1384
1385     strbuf._flag = _IOREAD;
1386     strbuf._ptr = strbuf._base = (unsigned char *) str;
1387     strbuf._cnt = strlen(str);
1388     strbuf._file = _NFILE;
1389     return (_doscan(&strbuf, "%d", ap))],[cf_cv_func_vsscanf=_doscan],[
1390 cf_cv_func_vsscanf=no])])])])
1391
1392 case $cf_cv_func_vsscanf in #(vi
1393 vsscanf) AC_DEFINE(HAVE_VSSCANF);; #(vi
1394 vfscanf) AC_DEFINE(HAVE_VFSCANF);; #(vi
1395 _doscan) AC_DEFINE(HAVE__DOSCAN);;
1396 esac
1397
1398 ])dnl
1399 dnl ---------------------------------------------------------------------------
1400 dnl CF_GCC_ATTRIBUTES version: 13 updated: 2009/08/11 20:19:56
1401 dnl -----------------
1402 dnl Test for availability of useful gcc __attribute__ directives to quiet
1403 dnl compiler warnings.  Though useful, not all are supported -- and contrary
1404 dnl to documentation, unrecognized directives cause older compilers to barf.
1405 AC_DEFUN([CF_GCC_ATTRIBUTES],
1406 [
1407 if test "$GCC" = yes
1408 then
1409 cat > conftest.i <<EOF
1410 #ifndef GCC_PRINTF
1411 #define GCC_PRINTF 0
1412 #endif
1413 #ifndef GCC_SCANF
1414 #define GCC_SCANF 0
1415 #endif
1416 #ifndef GCC_NORETURN
1417 #define GCC_NORETURN /* nothing */
1418 #endif
1419 #ifndef GCC_UNUSED
1420 #define GCC_UNUSED /* nothing */
1421 #endif
1422 EOF
1423 if test "$GCC" = yes
1424 then
1425         AC_CHECKING([for $CC __attribute__ directives])
1426 cat > conftest.$ac_ext <<EOF
1427 #line __oline__ "${as_me-configure}"
1428 #include "confdefs.h"
1429 #include "conftest.h"
1430 #include "conftest.i"
1431 #if     GCC_PRINTF
1432 #define GCC_PRINTFLIKE(fmt,var) __attribute__((format(printf,fmt,var)))
1433 #else
1434 #define GCC_PRINTFLIKE(fmt,var) /*nothing*/
1435 #endif
1436 #if     GCC_SCANF
1437 #define GCC_SCANFLIKE(fmt,var)  __attribute__((format(scanf,fmt,var)))
1438 #else
1439 #define GCC_SCANFLIKE(fmt,var)  /*nothing*/
1440 #endif
1441 extern void wow(char *,...) GCC_SCANFLIKE(1,2);
1442 extern void oops(char *,...) GCC_PRINTFLIKE(1,2) GCC_NORETURN;
1443 extern void foo(void) GCC_NORETURN;
1444 int main(int argc GCC_UNUSED, char *argv[[]] GCC_UNUSED) { return 0; }
1445 EOF
1446         cf_printf_attribute=no
1447         cf_scanf_attribute=no
1448         for cf_attribute in scanf printf unused noreturn
1449         do
1450                 CF_UPPER(cf_ATTRIBUTE,$cf_attribute)
1451                 cf_directive="__attribute__(($cf_attribute))"
1452                 echo "checking for $CC $cf_directive" 1>&AC_FD_CC
1453
1454                 case $cf_attribute in #(vi
1455                 printf) #(vi
1456                         cf_printf_attribute=yes
1457                         cat >conftest.h <<EOF
1458 #define GCC_$cf_ATTRIBUTE 1
1459 EOF
1460                         ;;
1461                 scanf) #(vi
1462                         cf_scanf_attribute=yes
1463                         cat >conftest.h <<EOF
1464 #define GCC_$cf_ATTRIBUTE 1
1465 EOF
1466                         ;;
1467                 *) #(vi
1468                         cat >conftest.h <<EOF
1469 #define GCC_$cf_ATTRIBUTE $cf_directive
1470 EOF
1471                         ;;
1472                 esac
1473
1474                 if AC_TRY_EVAL(ac_compile); then
1475                         test -n "$verbose" && AC_MSG_RESULT(... $cf_attribute)
1476                         cat conftest.h >>confdefs.h
1477                         case $cf_attribute in #(vi
1478                         printf) #(vi
1479                                 if test "$cf_printf_attribute" = no ; then
1480                                         cat >>confdefs.h <<EOF
1481 #define GCC_PRINTFLIKE(fmt,var) /* nothing */
1482 EOF
1483                                 else
1484                                         cat >>confdefs.h <<EOF
1485 #define GCC_PRINTFLIKE(fmt,var) __attribute__((format(printf,fmt,var)))
1486 EOF
1487                                 fi
1488                                 ;;
1489                         scanf) #(vi
1490                                 if test "$cf_scanf_attribute" = no ; then
1491                                         cat >>confdefs.h <<EOF
1492 #define GCC_SCANFLIKE(fmt,var) /* nothing */
1493 EOF
1494                                 else
1495                                         cat >>confdefs.h <<EOF
1496 #define GCC_SCANFLIKE(fmt,var)  __attribute__((format(scanf,fmt,var)))
1497 EOF
1498                                 fi
1499                                 ;;
1500                         esac
1501                 fi
1502         done
1503 else
1504         fgrep define conftest.i >>confdefs.h
1505 fi
1506 rm -rf conftest*
1507 fi
1508 ])dnl
1509 dnl ---------------------------------------------------------------------------
1510 dnl CF_GCC_VERSION version: 4 updated: 2005/08/27 09:53:42
1511 dnl --------------
1512 dnl Find version of gcc
1513 AC_DEFUN([CF_GCC_VERSION],[
1514 AC_REQUIRE([AC_PROG_CC])
1515 GCC_VERSION=none
1516 if test "$GCC" = yes ; then
1517         AC_MSG_CHECKING(version of $CC)
1518         GCC_VERSION="`${CC} --version| sed -e '2,$d' -e 's/^.*(GCC) //' -e 's/^[[^0-9.]]*//' -e 's/[[^0-9.]].*//'`"
1519         test -z "$GCC_VERSION" && GCC_VERSION=unknown
1520         AC_MSG_RESULT($GCC_VERSION)
1521 fi
1522 ])dnl
1523 dnl ---------------------------------------------------------------------------
1524 dnl CF_GCC_WARNINGS version: 24 updated: 2009/02/01 15:21:00
1525 dnl ---------------
1526 dnl Check if the compiler supports useful warning options.  There's a few that
1527 dnl we don't use, simply because they're too noisy:
1528 dnl
1529 dnl     -Wconversion (useful in older versions of gcc, but not in gcc 2.7.x)
1530 dnl     -Wredundant-decls (system headers make this too noisy)
1531 dnl     -Wtraditional (combines too many unrelated messages, only a few useful)
1532 dnl     -Wwrite-strings (too noisy, but should review occasionally).  This
1533 dnl             is enabled for ncurses using "--enable-const".
1534 dnl     -pedantic
1535 dnl
1536 dnl Parameter:
1537 dnl     $1 is an optional list of gcc warning flags that a particular
1538 dnl             application might want to use, e.g., "no-unused" for
1539 dnl             -Wno-unused
1540 dnl Special:
1541 dnl     If $with_ext_const is "yes", add a check for -Wwrite-strings
1542 dnl
1543 AC_DEFUN([CF_GCC_WARNINGS],
1544 [
1545 AC_REQUIRE([CF_GCC_VERSION])
1546 CF_INTEL_COMPILER(GCC,INTEL_COMPILER,CFLAGS)
1547
1548 cat > conftest.$ac_ext <<EOF
1549 #line __oline__ "${as_me-configure}"
1550 int main(int argc, char *argv[[]]) { return (argv[[argc-1]] == 0) ; }
1551 EOF
1552
1553 if test "$INTEL_COMPILER" = yes
1554 then
1555 # The "-wdXXX" options suppress warnings:
1556 # remark #1419: external declaration in primary source file
1557 # remark #1683: explicit conversion of a 64-bit integral type to a smaller integral type (potential portability problem)
1558 # remark #1684: conversion from pointer to same-sized integral type (potential portability problem)
1559 # remark #193: zero used for undefined preprocessing identifier
1560 # remark #593: variable "curs_sb_left_arrow" was set but never used
1561 # remark #810: conversion from "int" to "Dimension={unsigned short}" may lose significant bits
1562 # remark #869: parameter "tw" was never referenced
1563 # remark #981: operands are evaluated in unspecified order
1564 # warning #279: controlling expression is constant
1565
1566         AC_CHECKING([for $CC warning options])
1567         cf_save_CFLAGS="$CFLAGS"
1568         EXTRA_CFLAGS="-Wall"
1569         for cf_opt in \
1570                 wd1419 \
1571                 wd1683 \
1572                 wd1684 \
1573                 wd193 \
1574                 wd593 \
1575                 wd279 \
1576                 wd810 \
1577                 wd869 \
1578                 wd981
1579         do
1580                 CFLAGS="$cf_save_CFLAGS $EXTRA_CFLAGS -$cf_opt"
1581                 if AC_TRY_EVAL(ac_compile); then
1582                         test -n "$verbose" && AC_MSG_RESULT(... -$cf_opt)
1583                         EXTRA_CFLAGS="$EXTRA_CFLAGS -$cf_opt"
1584                 fi
1585         done
1586         CFLAGS="$cf_save_CFLAGS"
1587
1588 elif test "$GCC" = yes
1589 then
1590         AC_CHECKING([for $CC warning options])
1591         cf_save_CFLAGS="$CFLAGS"
1592         EXTRA_CFLAGS="-W -Wall"
1593         cf_warn_CONST=""
1594         test "$with_ext_const" = yes && cf_warn_CONST="Wwrite-strings"
1595         for cf_opt in \
1596                 Wbad-function-cast \
1597                 Wcast-align \
1598                 Wcast-qual \
1599                 Winline \
1600                 Wmissing-declarations \
1601                 Wmissing-prototypes \
1602                 Wnested-externs \
1603                 Wpointer-arith \
1604                 Wshadow \
1605                 Wstrict-prototypes \
1606                 Wundef $cf_warn_CONST $1
1607         do
1608                 CFLAGS="$cf_save_CFLAGS $EXTRA_CFLAGS -$cf_opt"
1609                 if AC_TRY_EVAL(ac_compile); then
1610                         test -n "$verbose" && AC_MSG_RESULT(... -$cf_opt)
1611                         case $cf_opt in #(vi
1612                         Wcast-qual) #(vi
1613                                 CPPFLAGS="$CPPFLAGS -DXTSTRINGDEFINES"
1614                                 ;;
1615                         Winline) #(vi
1616                                 case $GCC_VERSION in
1617                                 [[34]].*)
1618                                         CF_VERBOSE(feature is broken in gcc $GCC_VERSION)
1619                                         continue;;
1620                                 esac
1621                                 ;;
1622                         esac
1623                         EXTRA_CFLAGS="$EXTRA_CFLAGS -$cf_opt"
1624                 fi
1625         done
1626         CFLAGS="$cf_save_CFLAGS"
1627 fi
1628 rm -f conftest*
1629
1630 AC_SUBST(EXTRA_CFLAGS)
1631 ])dnl
1632 dnl ---------------------------------------------------------------------------
1633 dnl CF_GNAT_TRY_LINK version: 1 updated: 2004/08/21 19:02:08
1634 dnl ----------------
1635 dnl Verify that a test program compiles/links with GNAT.
1636 dnl $cf_ada_make is set to the program that compiles/links
1637 dnl $ADAFLAGS may be set to the GNAT flags.
1638 dnl
1639 dnl $1 is the text of the spec
1640 dnl $2 is the text of the body
1641 dnl $3 is the shell command to execute if successful
1642 dnl $4 is the shell command to execute if not successful
1643 AC_DEFUN([CF_GNAT_TRY_LINK],
1644 [
1645 rm -f conftest*
1646 cat >>conftest.ads <<CF_EOF
1647 $1
1648 CF_EOF
1649 cat >>conftest.adb <<CF_EOF
1650 $2
1651 CF_EOF
1652 if ( $cf_ada_make $ADAFLAGS conftest 1>&AC_FD_CC 2>&1 ) ; then
1653 ifelse($3,,      :,[      $3])
1654 ifelse($4,,,[else
1655    $4])
1656 fi
1657 rm -f conftest*
1658 ])dnl
1659 dnl ---------------------------------------------------------------------------
1660 dnl CF_GNAT_TRY_RUN version: 3 updated: 2004/08/21 19:02:08
1661 dnl ---------------
1662 dnl Verify that a test program compiles and runs with GNAT
1663 dnl $cf_ada_make is set to the program that compiles/links
1664 dnl $ADAFLAGS may be set to the GNAT flags.
1665 dnl
1666 dnl $1 is the text of the spec
1667 dnl $2 is the text of the body
1668 dnl $3 is the shell command to execute if successful
1669 dnl $4 is the shell command to execute if not successful
1670 AC_DEFUN([CF_GNAT_TRY_RUN],
1671 [
1672 rm -f conftest*
1673 cat >>conftest.ads <<CF_EOF
1674 $1
1675 CF_EOF
1676 cat >>conftest.adb <<CF_EOF
1677 $2
1678 CF_EOF
1679 if ( $cf_ada_make $ADAFLAGS conftest 1>&AC_FD_CC 2>&1 ) ; then
1680    if ( ./conftest 1>&AC_FD_CC 2>&1 ) ; then
1681 ifelse($3,,      :,[      $3])
1682 ifelse($4,,,[   else
1683       $4])
1684    fi
1685 ifelse($4,,,[else
1686    $4])
1687 fi
1688 rm -f conftest*
1689 ])dnl
1690 dnl ---------------------------------------------------------------------------
1691 dnl CF_GNAT_VERSION version: 12 updated: 2006/10/14 15:23:15
1692 dnl ---------------
1693 dnl Verify version of GNAT.
1694 AC_DEFUN([CF_GNAT_VERSION],
1695 [
1696 AC_MSG_CHECKING(for gnat version)
1697 cf_gnat_version=`${cf_ada_make-gnatmake} -v 2>&1 | grep '[[0-9]].[[0-9]][[0-9]]*' |\
1698   sed -e '2,$d' -e 's/[[^0-9 \.]]//g' -e 's/^[[ ]]*//' -e 's/ .*//'`
1699 AC_MSG_RESULT($cf_gnat_version)
1700
1701 case $cf_gnat_version in
1702   3.1[[1-9]]*|3.[[2-9]]*|[[4-9]].*)
1703     cf_cv_prog_gnat_correct=yes
1704     ;;
1705   *) echo Unsupported GNAT version $cf_gnat_version. Required is 3.11 or better. Disabling Ada95 binding.
1706      cf_cv_prog_gnat_correct=no
1707      ;;
1708 esac
1709 case $cf_gnat_version in
1710   3.[[1-9]]*|[[4-9]].*)
1711       cf_compile_generics=generics
1712       cf_generic_objects="\${GENOBJS}"
1713       ;;
1714   *)  cf_compile_generics=
1715       cf_generic_objects=
1716       ;;
1717 esac
1718 ])
1719 dnl ---------------------------------------------------------------------------
1720 dnl CF_GNU_SOURCE version: 6 updated: 2005/07/09 13:23:07
1721 dnl -------------
1722 dnl Check if we must define _GNU_SOURCE to get a reasonable value for
1723 dnl _XOPEN_SOURCE, upon which many POSIX definitions depend.  This is a defect
1724 dnl (or misfeature) of glibc2, which breaks portability of many applications,
1725 dnl since it is interwoven with GNU extensions.
1726 dnl
1727 dnl Well, yes we could work around it...
1728 AC_DEFUN([CF_GNU_SOURCE],
1729 [
1730 AC_CACHE_CHECK(if we must define _GNU_SOURCE,cf_cv_gnu_source,[
1731 AC_TRY_COMPILE([#include <sys/types.h>],[
1732 #ifndef _XOPEN_SOURCE
1733 make an error
1734 #endif],
1735         [cf_cv_gnu_source=no],
1736         [cf_save="$CPPFLAGS"
1737          CPPFLAGS="$CPPFLAGS -D_GNU_SOURCE"
1738          AC_TRY_COMPILE([#include <sys/types.h>],[
1739 #ifdef _XOPEN_SOURCE
1740 make an error
1741 #endif],
1742         [cf_cv_gnu_source=no],
1743         [cf_cv_gnu_source=yes])
1744         CPPFLAGS="$cf_save"
1745         ])
1746 ])
1747 test "$cf_cv_gnu_source" = yes && CPPFLAGS="$CPPFLAGS -D_GNU_SOURCE"
1748 ])dnl
1749 dnl ---------------------------------------------------------------------------
1750 dnl CF_GPP_LIBRARY version: 8 updated: 2003/02/02 01:41:46
1751 dnl --------------
1752 dnl If we're trying to use g++, test if libg++ is installed (a rather common
1753 dnl problem :-).  If we have the compiler but no library, we'll be able to
1754 dnl configure, but won't be able to build the c++ demo program.
1755 AC_DEFUN([CF_GPP_LIBRARY],
1756 [
1757 cf_cxx_library=unknown
1758 case $cf_cv_system_name in #(vi
1759 os2*) #(vi
1760         cf_gpp_libname=gpp
1761         ;;
1762 *)
1763         cf_gpp_libname=g++
1764         ;;
1765 esac
1766 if test "$GXX" = yes; then
1767         AC_MSG_CHECKING([for lib$cf_gpp_libname])
1768         cf_save="$LIBS"
1769         LIBS="$LIBS -l$cf_gpp_libname"
1770         AC_TRY_LINK([
1771 #include <$cf_gpp_libname/builtin.h>
1772         ],
1773         [two_arg_error_handler_t foo2 = lib_error_handler],
1774         [cf_cxx_library=yes
1775          CXXLIBS="$CXXLIBS -l$cf_gpp_libname"
1776          if test "$cf_gpp_libname" = cpp ; then
1777             AC_DEFINE(HAVE_GPP_BUILTIN_H)
1778          else
1779             AC_DEFINE(HAVE_GXX_BUILTIN_H)
1780          fi],
1781         [AC_TRY_LINK([
1782 #include <builtin.h>
1783         ],
1784         [two_arg_error_handler_t foo2 = lib_error_handler],
1785         [cf_cxx_library=yes
1786          CXXLIBS="$CXXLIBS -l$cf_gpp_libname"
1787          AC_DEFINE(HAVE_BUILTIN_H)],
1788         [cf_cxx_library=no])])
1789         LIBS="$cf_save"
1790         AC_MSG_RESULT($cf_cxx_library)
1791 fi
1792 ])dnl
1793 dnl ---------------------------------------------------------------------------
1794 dnl CF_GXX_VERSION version: 5 updated: 2005/08/27 09:53:42
1795 dnl --------------
1796 dnl Check for version of g++
1797 AC_DEFUN([CF_GXX_VERSION],[
1798 AC_REQUIRE([AC_PROG_CPP])
1799 GXX_VERSION=none
1800 if test "$GXX" = yes; then
1801         AC_MSG_CHECKING(version of g++)
1802         GXX_VERSION="`${CXX-g++} --version| sed -e '2,$d' -e 's/^.*(GCC) //' -e 's/^[[^0-9.]]*//' -e 's/[[^0-9.]].*//'`"
1803         test -z "$GXX_VERSION" && GXX_VERSION=unknown
1804         AC_MSG_RESULT($GXX_VERSION)
1805 fi
1806 ])dnl
1807 dnl ---------------------------------------------------------------------------
1808 dnl CF_GXX_WARNINGS version: 5 updated: 2005/08/13 14:54:38
1809 dnl ---------------
1810 dnl Check if the compiler supports useful warning options.
1811 dnl
1812 dnl Most of gcc's options apply to g++, except:
1813 dnl     -Wbad-function-cast
1814 dnl     -Wmissing-declarations
1815 dnl     -Wnested-externs
1816 dnl
1817 dnl Omit a few (for now):
1818 dnl     -Winline
1819 dnl
1820 dnl Parameter:
1821 dnl     $1 is an optional list of g++ warning flags that a particular
1822 dnl             application might want to use, e.g., "no-unused" for
1823 dnl             -Wno-unused
1824 dnl Special:
1825 dnl     If $with_ext_const is "yes", add a check for -Wwrite-strings
1826 dnl
1827 AC_DEFUN([CF_GXX_WARNINGS],
1828 [
1829
1830 CF_INTEL_COMPILER(GXX,INTEL_CPLUSPLUS,CXXFLAGS)
1831
1832 AC_REQUIRE([CF_GXX_VERSION])
1833
1834 AC_LANG_SAVE
1835 AC_LANG_CPLUSPLUS
1836
1837 cat > conftest.$ac_ext <<EOF
1838 #line __oline__ "configure"
1839 int main(int argc, char *argv[[]]) { return (argv[[argc-1]] == 0) ; }
1840 EOF
1841
1842 if test "$INTEL_CPLUSPLUS" = yes
1843 then
1844 # The "-wdXXX" options suppress warnings:
1845 # remark #1419: external declaration in primary source file
1846 # remark #1682: implicit conversion of a 64-bit integral type to a smaller integral type (potential portability problem)
1847 # remark #1683: explicit conversion of a 64-bit integral type to a smaller integral type (potential portability problem)
1848 # remark #1684: conversion from pointer to same-sized integral type (potential portability problem)
1849 # remark #193: zero used for undefined preprocessing identifier
1850 # remark #593: variable "curs_sb_left_arrow" was set but never used
1851 # remark #810: conversion from "int" to "Dimension={unsigned short}" may lose significant bits
1852 # remark #869: parameter "tw" was never referenced
1853 # remark #981: operands are evaluated in unspecified order
1854 # warning #269: invalid format string conversion
1855
1856         AC_CHECKING([for $CC warning options])
1857         cf_save_CXXFLAGS="$CXXFLAGS"
1858         EXTRA_CXXFLAGS="-Wall"
1859         for cf_opt in \
1860                 wd1419 \
1861                 wd1682 \
1862                 wd1683 \
1863                 wd1684 \
1864                 wd193 \
1865                 wd279 \
1866                 wd593 \
1867                 wd810 \
1868                 wd869 \
1869                 wd981
1870         do
1871                 CXXFLAGS="$cf_save_CXXFLAGS $EXTRA_CXXFLAGS -$cf_opt"
1872                 if AC_TRY_EVAL(ac_compile); then
1873                         test -n "$verbose" && AC_MSG_RESULT(... -$cf_opt)
1874                         EXTRA_CXXFLAGS="$EXTRA_CXXFLAGS -$cf_opt"
1875                 fi
1876         done
1877         CXXFLAGS="$cf_save_CXXFLAGS"
1878
1879 elif test "$GXX" = yes
1880 then
1881         AC_CHECKING([for $CXX warning options])
1882         cf_save_CXXFLAGS="$CXXFLAGS"
1883         EXTRA_CXXFLAGS="-W -Wall"
1884         cf_gxx_extra_warnings=""
1885         test "$with_ext_const" = yes && cf_gxx_extra_warnings="Wwrite-strings"
1886         case "$GCC_VERSION" in
1887         [[1-2]].*)
1888                 ;;
1889         *)
1890                 cf_gxx_extra_warnings="$cf_gxx_extra_warnings Weffc++"
1891                 ;;
1892         esac
1893         for cf_opt in \
1894                 Wabi \
1895                 fabi-version=0 \
1896                 Woverloaded-virtual \
1897                 Wsign-promo \
1898                 Wsynth \
1899                 Wold-style-cast \
1900                 Wcast-align \
1901                 Wcast-qual \
1902                 Wmissing-prototypes \
1903                 Wpointer-arith \
1904                 Wshadow \
1905                 Wstrict-prototypes \
1906                 Wundef $cf_gxx_extra_warnings $1
1907         do
1908                 CXXFLAGS="$cf_save_CXXFLAGS $EXTRA_CXXFLAGS -Werror -$cf_opt"
1909                 if AC_TRY_EVAL(ac_compile); then
1910                         test -n "$verbose" && AC_MSG_RESULT(... -$cf_opt)
1911                         EXTRA_CXXFLAGS="$EXTRA_CXXFLAGS -$cf_opt"
1912                 else
1913                         test -n "$verbose" && AC_MSG_RESULT(... no -$cf_opt)
1914                 fi
1915         done
1916         CXXFLAGS="$cf_save_CXXFLAGS"
1917 fi
1918
1919 rm -f conftest*
1920 AC_LANG_RESTORE
1921 AC_SUBST(EXTRA_CXXFLAGS)
1922 ])dnl
1923 dnl ---------------------------------------------------------------------------
1924 dnl CF_HASHED_DB version: 3 updated: 2007/11/24 17:43:37
1925 dnl ------------
1926 dnl Look for an instance of the Berkeley hashed database.
1927 dnl
1928 dnl $1 = optional parameter, to specify install-prefix for the database.
1929 AC_DEFUN([CF_HASHED_DB],
1930 [
1931 ifelse([$1],,,[
1932 case $1 in #(vi
1933 yes|*able*) #(vi
1934     ;;
1935 *)
1936     if test -d "$1" ; then
1937         CF_ADD_INCDIR($1/include)
1938         CF_ADD_LIBDIR($1/lib)
1939     fi
1940 esac
1941 ])
1942 AC_CHECK_HEADER(db.h,[
1943 CF_HASHED_DB_VERSION
1944 if test "$cf_cv_hashed_db_version" = unknown ; then
1945         AC_MSG_ERROR(Cannot determine version of db)
1946 else
1947         CF_HASHED_DB_LIBS
1948         if test "$cf_cv_hashed_db_libs" = unknown ; then
1949                 AC_MSG_ERROR(Cannot determine library for db)
1950         elif test "$cf_cv_hashed_db_libs" != default ; then
1951                 LIBS="-l$cf_cv_hashed_db_libs $LIBS"
1952         fi
1953 fi
1954 ],[
1955         AC_MSG_ERROR(Cannot find db.h)
1956 ])
1957 ])dnl
1958 dnl ---------------------------------------------------------------------------
1959 dnl CF_HASHED_DB_LIBS version: 8 updated: 2008/08/04 06:18:06
1960 dnl -----------------
1961 dnl Given that we have the header and version for hashed database, find the
1962 dnl library information.
1963 AC_DEFUN([CF_HASHED_DB_LIBS],
1964 [
1965 AC_CACHE_CHECK(for db libraries, cf_cv_hashed_db_libs,[
1966 cf_cv_hashed_db_libs=unknown
1967 for cf_db_libs in "" db$cf_cv_hashed_db_version db-$cf_cv_hashed_db_version db ''
1968 do
1969         cf_save_libs="$LIBS"
1970         if test -n "$cf_db_libs"; then
1971                 LIBS="-l$cf_db_libs $LIBS"
1972         fi
1973         CF_MSG_LOG(checking for library "$cf_db_libs")
1974         AC_TRY_LINK([
1975 $ac_includes_default
1976 #include <db.h>
1977 ],[
1978         char *path = "/tmp/foo";
1979 #ifdef DB_VERSION_MAJOR
1980 #if DB_VERSION_MAJOR >= 4
1981         DB *result = 0;
1982         db_create(&result, NULL, 0);
1983         result->open(result,
1984                 NULL,
1985                 path,
1986                 path,
1987                 DB_HASH,
1988                 DB_CREATE,
1989                 0644);
1990 #elif DB_VERSION_MAJOR >= 3
1991         DB *result = 0;
1992         db_create(&result, NULL, 0);
1993         result->open(result,
1994                 path,
1995                 path,
1996                 DB_HASH,
1997                 DB_CREATE,
1998                 0644);
1999 #elif DB_VERSION_MAJOR >= 2
2000         DB *result = 0;
2001         db_open(path,
2002                 DB_HASH,
2003                 DB_CREATE,
2004                 0644,
2005                 (DB_ENV *) 0,
2006                 (DB_INFO *) 0,
2007                 &result);
2008 #endif /* DB_VERSION_MAJOR */
2009 #else
2010         DB *result = dbopen(path,
2011                      2,
2012                      0644,
2013                      DB_HASH,
2014                      0);
2015 #endif
2016         ${cf_cv_main_return:-return}(result != 0)
2017 ],[
2018         if test -n "$cf_db_libs" ; then
2019                 cf_cv_hashed_db_libs=$cf_db_libs
2020         else
2021                 cf_cv_hashed_db_libs=default
2022         fi
2023         LIBS="$cf_save_libs"
2024         break
2025 ])
2026         LIBS="$cf_save_libs"
2027 done
2028 ])
2029 ])dnl
2030 dnl ---------------------------------------------------------------------------
2031 dnl CF_HASHED_DB_VERSION version: 3 updated: 2007/12/01 15:01:37
2032 dnl --------------------
2033 dnl Given that we have the header file for hashed database, find the version
2034 dnl information.
2035 AC_DEFUN([CF_HASHED_DB_VERSION],
2036 [
2037 AC_CACHE_CHECK(for version of db, cf_cv_hashed_db_version,[
2038 cf_cv_hashed_db_version=unknown
2039
2040 for cf_db_version in 1 2 3 4 5
2041 do
2042         CF_MSG_LOG(checking for db version $cf_db_version)
2043         AC_TRY_COMPILE([
2044 $ac_includes_default
2045 #include <db.h>
2046
2047 #ifdef DB_VERSION_MAJOR
2048         /* db2 (DB_VERSION_MAJOR=2) has also DB_VERSION_MINOR, tested with 7 */
2049 #if $cf_db_version == DB_VERSION_MAJOR
2050         /* ok */
2051 #else
2052         make an error
2053 #endif
2054 #else
2055 #if $cf_db_version == 1
2056         /* ok: assuming this is DB 1.8.5 */
2057 #else
2058         make an error
2059 #endif
2060 #endif
2061 ],[DBT *foo = 0],[
2062         cf_cv_hashed_db_version=$cf_db_version
2063         break
2064         ])
2065 done
2066 ])
2067 ])dnl
2068 dnl ---------------------------------------------------------------------------
2069 dnl CF_HEADER_PATH version: 9 updated: 2008/12/07 19:38:31
2070 dnl --------------
2071 dnl Construct a search-list of directories for a nonstandard header-file
2072 dnl
2073 dnl Parameters
2074 dnl     $1 = the variable to return as result
2075 dnl     $2 = the package name
2076 AC_DEFUN([CF_HEADER_PATH],
2077 [
2078 cf_header_path_list=""
2079 if test -n "${CFLAGS}${CPPFLAGS}" ; then
2080         for cf_header_path in $CPPFLAGS $CFLAGS
2081         do
2082                 case $cf_header_path in #(vi
2083                 -I*)
2084                         cf_header_path=`echo ".$cf_header_path" |sed -e 's/^...//' -e 's,/include$,,'`
2085                         CF_ADD_SUBDIR_PATH($1,$2,include,$cf_header_path,NONE)
2086                         cf_header_path_list="$cf_header_path_list [$]$1"
2087                         ;;
2088                 esac
2089         done
2090 fi
2091
2092 CF_SUBDIR_PATH($1,$2,include)
2093
2094 test "$includedir" != NONE && \
2095 test "$includedir" != "/usr/include" && \
2096 test -d "$includedir" && {
2097         test -d $includedir &&    $1="[$]$1 $includedir"
2098         test -d $includedir/$2 && $1="[$]$1 $includedir/$2"
2099 }
2100
2101 test "$oldincludedir" != NONE && \
2102 test "$oldincludedir" != "/usr/include" && \
2103 test -d "$oldincludedir" && {
2104         test -d $oldincludedir    && $1="[$]$1 $oldincludedir"
2105         test -d $oldincludedir/$2 && $1="[$]$1 $oldincludedir/$2"
2106 }
2107
2108 $1="$cf_header_path_list [$]$1"
2109 ])dnl
2110 dnl ---------------------------------------------------------------------------
2111 dnl CF_HELP_MESSAGE version: 3 updated: 1998/01/14 10:56:23
2112 dnl ---------------
2113 dnl Insert text into the help-message, for readability, from AC_ARG_WITH.
2114 AC_DEFUN([CF_HELP_MESSAGE],
2115 [AC_DIVERT_HELP([$1])dnl
2116 ])dnl
2117 dnl ---------------------------------------------------------------------------
2118 dnl CF_INCLUDE_DIRS version: 6 updated: 2009/01/06 19:37:40
2119 dnl ---------------
2120 dnl Construct the list of include-options according to whether we're building
2121 dnl in the source directory or using '--srcdir=DIR' option.  If we're building
2122 dnl with gcc, don't append the includedir if it happens to be /usr/include,
2123 dnl since that usually breaks gcc's shadow-includes.
2124 AC_DEFUN([CF_INCLUDE_DIRS],
2125 [
2126 CPPFLAGS="$CPPFLAGS -I. -I../include"
2127 if test "$srcdir" != "."; then
2128         CPPFLAGS="$CPPFLAGS -I\${srcdir}/../include"
2129 fi
2130 if test "$GCC" != yes; then
2131         CPPFLAGS="$CPPFLAGS -I\${includedir}"
2132 elif test "$includedir" != "/usr/include"; then
2133         if test "$includedir" = '${prefix}/include' ; then
2134                 if test $prefix != /usr ; then
2135                         CPPFLAGS="$CPPFLAGS -I\${includedir}"
2136                 fi
2137         else
2138                 CPPFLAGS="$CPPFLAGS -I\${includedir}"
2139         fi
2140 fi
2141 AC_SUBST(CPPFLAGS)
2142 ])dnl
2143 dnl ---------------------------------------------------------------------------
2144 dnl CF_INTEL_COMPILER version: 3 updated: 2005/08/06 18:37:29
2145 dnl -----------------
2146 dnl Check if the given compiler is really the Intel compiler for Linux.  It
2147 dnl tries to imitate gcc, but does not return an error when it finds a mismatch
2148 dnl between prototypes, e.g., as exercised by CF_MISSING_CHECK.
2149 dnl
2150 dnl This macro should be run "soon" after AC_PROG_CC or AC_PROG_CPLUSPLUS, to
2151 dnl ensure that it is not mistaken for gcc/g++.  It is normally invoked from
2152 dnl the wrappers for gcc and g++ warnings.
2153 dnl
2154 dnl $1 = GCC (default) or GXX
2155 dnl $2 = INTEL_COMPILER (default) or INTEL_CPLUSPLUS
2156 dnl $3 = CFLAGS (default) or CXXFLAGS
2157 AC_DEFUN([CF_INTEL_COMPILER],[
2158 ifelse($2,,INTEL_COMPILER,[$2])=no
2159
2160 if test "$ifelse($1,,[$1],GCC)" = yes ; then
2161         case $host_os in
2162         linux*|gnu*)
2163                 AC_MSG_CHECKING(if this is really Intel ifelse($1,GXX,C++,C) compiler)
2164                 cf_save_CFLAGS="$ifelse($3,,CFLAGS,[$3])"
2165                 ifelse($3,,CFLAGS,[$3])="$ifelse($3,,CFLAGS,[$3]) -no-gcc"
2166                 AC_TRY_COMPILE([],[
2167 #ifdef __INTEL_COMPILER
2168 #else
2169 make an error
2170 #endif
2171 ],[ifelse($2,,INTEL_COMPILER,[$2])=yes
2172 cf_save_CFLAGS="$cf_save_CFLAGS -we147 -no-gcc"
2173 ],[])
2174                 ifelse($3,,CFLAGS,[$3])="$cf_save_CFLAGS"
2175                 AC_MSG_RESULT($ifelse($2,,INTEL_COMPILER,[$2]))
2176                 ;;
2177         esac
2178 fi
2179 ])dnl
2180 dnl ---------------------------------------------------------------------------
2181 dnl CF_ISASCII version: 3 updated: 2000/08/12 23:18:52
2182 dnl ----------
2183 dnl Check if we have either a function or macro for 'isascii()'.
2184 AC_DEFUN([CF_ISASCII],
2185 [
2186 AC_MSG_CHECKING(for isascii)
2187 AC_CACHE_VAL(cf_cv_have_isascii,[
2188         AC_TRY_LINK([#include <ctype.h>],[int x = isascii(' ')],
2189         [cf_cv_have_isascii=yes],
2190         [cf_cv_have_isascii=no])
2191 ])dnl
2192 AC_MSG_RESULT($cf_cv_have_isascii)
2193 test "$cf_cv_have_isascii" = yes && AC_DEFINE(HAVE_ISASCII)
2194 ])dnl
2195 dnl ---------------------------------------------------------------------------
2196 dnl CF_LARGEFILE version: 7 updated: 2007/06/02 11:58:50
2197 dnl ------------
2198 dnl Add checks for large file support.
2199 AC_DEFUN([CF_LARGEFILE],[
2200 ifdef([AC_FUNC_FSEEKO],[
2201     AC_SYS_LARGEFILE
2202     if test "$enable_largefile" != no ; then
2203         AC_FUNC_FSEEKO
2204
2205         # Normally we would collect these definitions in the config.h,
2206         # but (like _XOPEN_SOURCE), some environments rely on having these
2207         # defined before any of the system headers are included.  Another
2208         # case comes up with C++, e.g., on AIX the compiler compiles the
2209         # header files by themselves before looking at the body files it is
2210         # told to compile.  For ncurses, those header files do not include
2211         # the config.h
2212         test "$ac_cv_sys_large_files"      != no && CPPFLAGS="$CPPFLAGS -D_LARGE_FILES "
2213         test "$ac_cv_sys_largefile_source" != no && CPPFLAGS="$CPPFLAGS -D_LARGEFILE_SOURCE "
2214         test "$ac_cv_sys_file_offset_bits" != no && CPPFLAGS="$CPPFLAGS -D_FILE_OFFSET_BITS=$ac_cv_sys_file_offset_bits "
2215
2216         AC_CACHE_CHECK(whether to use struct dirent64, cf_cv_struct_dirent64,[
2217                 AC_TRY_COMPILE([
2218 #include <sys/types.h>
2219 #include <dirent.h>
2220                 ],[
2221                 /* if transitional largefile support is setup, this is true */
2222                 extern struct dirent64 * readdir(DIR *);
2223                 struct dirent64 *x = readdir((DIR *)0);
2224                 struct dirent *y = readdir((DIR *)0);
2225                 int z = x - y;
2226                 ],
2227                 [cf_cv_struct_dirent64=yes],
2228                 [cf_cv_struct_dirent64=no])
2229         ])
2230         test "$cf_cv_struct_dirent64" = yes && AC_DEFINE(HAVE_STRUCT_DIRENT64)
2231     fi
2232 ])
2233 ])
2234 dnl ---------------------------------------------------------------------------
2235 dnl CF_LDFLAGS_STATIC version: 7 updated: 2009/04/04 18:31:04
2236 dnl -----------------
2237 dnl Check for compiler/linker flags used to temporarily force usage of static
2238 dnl libraries.  This depends on the compiler and platform.  Use this to help
2239 dnl ensure that the linker picks up a given library based on its position in
2240 dnl the list of linker options and libraries.
2241 AC_DEFUN([CF_LDFLAGS_STATIC],[
2242
2243 if test "$GCC" = yes ; then
2244         case $cf_cv_system_name in #(
2245         OS/2*|os2*|aix[[4]]*|solaris2.1[[0-9]]|darwin*)         #( vi
2246                 LDFLAGS_STATIC=
2247                 LDFLAGS_SHARED=
2248                 ;;
2249     *)  #( normally, except when broken
2250         LDFLAGS_STATIC=-static
2251         LDFLAGS_SHARED=-dynamic
2252         ;;
2253     esac
2254 else
2255         case $cf_cv_system_name in #(
2256         aix[[456]]*)    #( from ld manpage
2257                 LDFLAGS_STATIC=-bstatic
2258                 LDFLAGS_SHARED=-bdynamic
2259                 ;;
2260         hpux*)          #( from ld manpage for hpux10.20, hpux11.11
2261                 # We could also use just "archive" and "shared".
2262                 LDFLAGS_STATIC=-Wl,-a,archive_shared
2263                 LDFLAGS_SHARED=-Wl,-a,shared_archive
2264                 ;;
2265         irix*)          #( from ld manpage IRIX64
2266                 LDFLAGS_STATIC=-Bstatic
2267                 LDFLAGS_SHARED=-Bdynamic
2268                 ;;
2269         osf[[45]]*)     #( from ld manpage osf4.0d, osf5.1
2270                 # alternative "-oldstyle_liblookup" (not in cc manpage)
2271                 LDFLAGS_STATIC=-noso
2272                 LDFLAGS_SHARED=-so_archive
2273                 ;;
2274         solaris2*)
2275                 LDFLAGS_STATIC=-Bstatic
2276                 LDFLAGS_SHARED=-Bdynamic
2277                 ;;
2278         esac
2279 fi
2280
2281 AC_SUBST(LDFLAGS_STATIC)
2282 AC_SUBST(LDFLAGS_SHARED)
2283 ])
2284 dnl ---------------------------------------------------------------------------
2285 dnl CF_LIBRARY_PATH version: 8 updated: 2008/12/07 19:38:31
2286 dnl ---------------
2287 dnl Construct a search-list of directories for a nonstandard library-file
2288 dnl
2289 dnl Parameters
2290 dnl     $1 = the variable to return as result
2291 dnl     $2 = the package name
2292 AC_DEFUN([CF_LIBRARY_PATH],
2293 [
2294 cf_library_path_list=""
2295 if test -n "${LDFLAGS}${LIBS}" ; then
2296         for cf_library_path in $LDFLAGS $LIBS
2297         do
2298                 case $cf_library_path in #(vi
2299                 -L*)
2300                         cf_library_path=`echo ".$cf_library_path" |sed -e 's/^...//' -e 's,/lib$,,'`
2301                         CF_ADD_SUBDIR_PATH($1,$2,lib,$cf_library_path,NONE)
2302                         cf_library_path_list="$cf_library_path_list [$]$1"
2303                         ;;
2304                 esac
2305         done
2306 fi
2307
2308 CF_SUBDIR_PATH($1,$2,lib)
2309
2310 $1="$cf_library_path_list [$]$1"
2311 ])dnl
2312 dnl ---------------------------------------------------------------------------
2313 dnl CF_LIB_PREFIX version: 8 updated: 2008/09/13 11:34:16
2314 dnl -------------
2315 dnl Compute the library-prefix for the given host system
2316 dnl $1 = variable to set
2317 AC_DEFUN([CF_LIB_PREFIX],
2318 [
2319         case $cf_cv_system_name in #(vi
2320         OS/2*|os2*) #(vi
2321         LIB_PREFIX=''
2322         ;;
2323         *)      LIB_PREFIX='lib'
2324         ;;
2325         esac
2326 ifelse($1,,,[$1=$LIB_PREFIX])
2327         AC_SUBST(LIB_PREFIX)
2328 ])dnl
2329 dnl ---------------------------------------------------------------------------
2330 dnl CF_LIB_RULES version: 55 updated: 2008/12/13 16:17:38
2331 dnl ------------
2332 dnl Append definitions and rules for the given models to the subdirectory
2333 dnl Makefiles, and the recursion rule for the top-level Makefile.  If the
2334 dnl subdirectory is a library-source directory, modify the LIBS_TO_MAKE list in
2335 dnl the corresponding makefile to list the models that we'll generate.
2336 dnl
2337 dnl For shared libraries, make a list of symbolic links to construct when
2338 dnl generating each library.  The convention used for Linux is the simplest
2339 dnl one:
2340 dnl     lib<name>.so    ->
2341 dnl     lib<name>.so.<major>    ->
2342 dnl     lib<name>.so.<maj>.<minor>
2343 AC_DEFUN([CF_LIB_RULES],
2344 [
2345 CF_LIB_PREFIX(cf_prefix)
2346 AC_REQUIRE([CF_SUBST_NCURSES_VERSION])
2347
2348 if test $cf_cv_shlib_version = cygdll ; then
2349         TINFO_NAME=$TINFO_ARG_SUFFIX
2350         TINFO_SUFFIX=.dll
2351 fi
2352
2353 for cf_dir in $SRC_SUBDIRS
2354 do
2355         if test ! -d $srcdir/$cf_dir ; then
2356                 continue
2357         elif test -f $srcdir/$cf_dir/modules; then
2358
2359                 SHARED_LIB=
2360                 LIBS_TO_MAKE=
2361                 for cf_item in $cf_LIST_MODELS
2362                 do
2363                         CF_LIB_SUFFIX($cf_item,cf_suffix,cf_depsuf)
2364                         if test $cf_item = shared ; then
2365                         if test "$cf_cv_do_symlinks" = yes ; then
2366                                 case "$cf_cv_shlib_version" in #(vi
2367                                 rel) #(vi
2368                                         case "$cf_cv_system_name" in #(vi
2369                                         darwin*)
2370                                         case .${LIB_SUFFIX} in
2371                                         .w*)
2372                                                 cf_suffix=`echo $cf_suffix | sed 's/^w//'`
2373                                                 cf_suffix=w'.${REL_VERSION}'"$cf_suffix"
2374                                                 ;;
2375                                         *)
2376                                                 cf_suffix='.${REL_VERSION}'"$cf_suffix"
2377                                                 ;;
2378                                         esac
2379                                         ;; #(vi
2380                                         *) cf_suffix="$cf_suffix"'.${REL_VERSION}' ;;
2381                                         esac
2382                                         ;;
2383                                 abi)
2384                                         case "$cf_cv_system_name" in #(vi
2385                                         darwin*)
2386                                         case .${LIB_SUFFIX} in
2387                                         .w*)
2388                                                 cf_suffix=`echo $cf_suffix | sed 's/^w//'`
2389                                                 cf_suffix=w'.${ABI_VERSION}'"$cf_suffix"
2390                                                 ;;
2391                                         *)
2392                                                 cf_suffix='.${ABI_VERSION}'"$cf_suffix"
2393                                                 ;;
2394                                         esac
2395                                         ;; #(vi
2396                                         *) cf_suffix="$cf_suffix"'.${ABI_VERSION}' ;;
2397                                         esac
2398                                         ;;
2399                                 esac
2400                         fi
2401                         # cygwin needs import library, and has unique naming convention
2402                         # use autodetected ${cf_prefix} for import lib and static lib, but
2403                         # use 'cyg' prefix for shared lib.
2404                         if test $cf_cv_shlib_version = cygdll ; then
2405                                 cf_cygsuf=`echo "$cf_suffix" | sed -e 's/\.dll/\${ABI_VERSION}.dll/'`
2406                                 LIBS_TO_MAKE="$LIBS_TO_MAKE ../lib/cyg${cf_dir}${cf_cygsuf}"
2407                                 continue
2408                         fi
2409                         fi
2410                         LIBS_TO_MAKE="$LIBS_TO_MAKE ../lib/${cf_prefix}${cf_dir}${cf_suffix}"
2411                 done
2412
2413                 if test $cf_dir = ncurses ; then
2414                         cf_subsets="$LIB_SUBSETS"
2415                         cf_r_parts="$cf_subsets"
2416                         cf_liblist="$LIBS_TO_MAKE"
2417
2418                         while test -n "$cf_r_parts"
2419                         do
2420                                 cf_l_parts=`echo "$cf_r_parts" |sed -e 's/ .*$//'`
2421                                 cf_r_parts=`echo "$cf_r_parts" |sed -e 's/^[[^ ]]* //'`
2422                                 if test "$cf_l_parts" != "$cf_r_parts" ; then
2423                                         cf_item=
2424                                         case $cf_l_parts in #(vi
2425                                         *termlib*) #(vi
2426                                                 cf_item=`echo $cf_liblist |sed -e s%${LIB_NAME}${LIB_SUFFIX}%${TINFO_LIB_SUFFIX}%g`
2427                                                 ;;
2428                                         *ticlib*)
2429                                                 cf_item=`echo $cf_liblist |sed -e s%${LIB_NAME}${LIB_SUFFIX}%${TICS_LIB_SUFFIX}%g`
2430                                                 ;;
2431                                         *)
2432                                                 break
2433                                                 ;;
2434                                         esac
2435                                         if test -n "$cf_item"; then
2436                                                 LIBS_TO_MAKE="$cf_item $LIBS_TO_MAKE"
2437                                         fi
2438                                 else
2439                                         break
2440                                 fi
2441                         done
2442                 else
2443                         cf_subsets=`echo "$LIB_SUBSETS" | sed -e 's/^termlib.* //'`
2444                 fi
2445
2446                 sed -e "s%@LIBS_TO_MAKE@%$LIBS_TO_MAKE%" \
2447                     -e "s%@SHARED_LIB@%$SHARED_LIB%" \
2448                         $cf_dir/Makefile >$cf_dir/Makefile.out
2449                 mv $cf_dir/Makefile.out $cf_dir/Makefile
2450
2451                 $AWK -f $srcdir/mk-0th.awk \
2452                         libname="${cf_dir}${LIB_SUFFIX}" subsets="$LIB_SUBSETS" \
2453                         $srcdir/$cf_dir/modules >>$cf_dir/Makefile
2454
2455                 for cf_subset in $cf_subsets
2456                 do
2457                         cf_subdirs=
2458                         for cf_item in $cf_LIST_MODELS
2459                         do
2460                         echo "Appending rules for ${cf_item} model (${cf_dir}: ${cf_subset})"
2461                         CF_UPPER(cf_ITEM,$cf_item)
2462                         CF_LIB_SUFFIX($cf_item,cf_suffix,cf_depsuf)
2463                         CF_OBJ_SUBDIR($cf_item,cf_subdir)
2464
2465                         # Test for case where we build libtinfo with a different name.
2466                         cf_libname=$cf_dir
2467                         if test $cf_dir = ncurses ; then
2468                                 case $cf_subset in
2469                                 *base*)
2470                                         cf_libname=${cf_libname}$LIB_SUFFIX
2471                                         ;;
2472                                 *termlib*)
2473                                         cf_libname=$TINFO_LIB_SUFFIX
2474                                         ;;
2475                                 ticlib*)
2476                                         cf_libname=$TICS_LIB_SUFFIX
2477                                         ;;
2478                                 esac
2479                         else
2480                                 cf_libname=${cf_libname}$LIB_SUFFIX
2481                         fi
2482                         if test -n "${DFT_ARG_SUFFIX}" ; then
2483                                 # undo $LIB_SUFFIX add-on in CF_LIB_SUFFIX
2484                                 cf_suffix=`echo $cf_suffix |sed -e "s%^${LIB_SUFFIX}%%"`
2485                         fi
2486
2487                         # These dependencies really are for development, not
2488                         # builds, but they are useful in porting, too.
2489                         cf_depend="../include/ncurses_cfg.h"
2490                         if test "$srcdir" = "."; then
2491                                 cf_reldir="."
2492                         else
2493                                 cf_reldir="\${srcdir}"
2494                         fi
2495
2496                         if test -f $srcdir/$cf_dir/$cf_dir.priv.h; then
2497                                 cf_depend="$cf_depend $cf_reldir/$cf_dir.priv.h"
2498                         elif test -f $srcdir/$cf_dir/curses.priv.h; then
2499                                 cf_depend="$cf_depend $cf_reldir/curses.priv.h"
2500                         fi
2501
2502                         cf_dir_suffix=
2503                         old_cf_suffix="$cf_suffix"
2504                         if test "$cf_cv_shlib_version_infix" = yes ; then
2505                         if test -n "$LIB_SUFFIX" ; then
2506                                 case $LIB_SUFFIX in
2507                                 w*)
2508                                         cf_libname=`echo $cf_libname | sed 's/w$//'`
2509                                         cf_suffix=`echo $cf_suffix | sed 's/^w//'`
2510                                         cf_dir_suffix=w
2511                                         ;;
2512                                 esac
2513                         fi
2514                         fi
2515
2516                         $AWK -f $srcdir/mk-1st.awk \
2517                                 name=${cf_libname}${cf_dir_suffix} \
2518                                 traces=$LIB_TRACING \
2519                                 MODEL=$cf_ITEM \
2520                                 model=$cf_subdir \
2521                                 prefix=$cf_prefix \
2522                                 suffix=$cf_suffix \
2523                                 subset=$cf_subset \
2524                                 TermlibRoot=$TINFO_NAME \
2525                                 TermlibSuffix=$TINFO_SUFFIX \
2526                                 ShlibVer=$cf_cv_shlib_version \
2527                                 ShlibVerInfix=$cf_cv_shlib_version_infix \
2528                                 ReLink=${cf_cv_do_relink-no} \
2529                                 DoLinks=$cf_cv_do_symlinks \
2530                                 rmSoLocs=$cf_cv_rm_so_locs \
2531                                 ldconfig="$LDCONFIG" \
2532                                 overwrite=$WITH_OVERWRITE \
2533                                 depend="$cf_depend" \
2534                                 host="$host" \
2535                                 $srcdir/$cf_dir/modules >>$cf_dir/Makefile
2536
2537                         cf_suffix="$old_cf_suffix"
2538
2539                         for cf_subdir2 in $cf_subdirs lib
2540                         do
2541                                 test $cf_subdir = $cf_subdir2 && break
2542                         done
2543                         test "${cf_subset}.${cf_subdir2}" != "${cf_subset}.${cf_subdir}" && \
2544                         $AWK -f $srcdir/mk-2nd.awk \
2545                                 name=$cf_dir \
2546                                 traces=$LIB_TRACING \
2547                                 MODEL=$cf_ITEM \
2548                                 model=$cf_subdir \
2549                                 subset=$cf_subset \
2550                                 srcdir=$srcdir \
2551                                 echo=$WITH_ECHO \
2552                                 crenames=$cf_cv_prog_CC_c_o \
2553                                 cxxrenames=$cf_cv_prog_CXX_c_o \
2554                                 $srcdir/$cf_dir/modules >>$cf_dir/Makefile
2555                         cf_subdirs="$cf_subdirs $cf_subdir"
2556                         done
2557                 done
2558         fi
2559
2560         echo '  cd '$cf_dir' && ${MAKE} ${CF_MFLAGS} [$]@' >>Makefile
2561 done
2562
2563 for cf_dir in $SRC_SUBDIRS
2564 do
2565         if test ! -d $srcdir/$cf_dir ; then
2566                 continue
2567         fi
2568
2569         if test -f $cf_dir/Makefile ; then
2570                 case "$cf_dir" in
2571                 Ada95) #(vi
2572                         echo 'libs \' >> Makefile
2573                         echo 'install.libs \' >> Makefile
2574                         echo 'uninstall.libs ::' >> Makefile
2575                         echo '  cd '$cf_dir' && ${MAKE} ${CF_MFLAGS} [$]@' >> Makefile
2576                         ;;
2577                 esac
2578         fi
2579
2580         if test -f $srcdir/$cf_dir/modules; then
2581                 echo >> Makefile
2582                 if test -f $srcdir/$cf_dir/headers; then
2583 cat >> Makefile <<CF_EOF
2584 install.includes \\
2585 uninstall.includes \\
2586 CF_EOF
2587                 fi
2588 if test "$cf_dir" != "c++" ; then
2589 echo 'lint \' >> Makefile
2590 fi
2591 cat >> Makefile <<CF_EOF
2592 libs \\
2593 lintlib \\
2594 install.libs \\
2595 uninstall.libs \\
2596 install.$cf_dir \\
2597 uninstall.$cf_dir ::
2598         cd $cf_dir && \${MAKE} \${CF_MFLAGS} \[$]@
2599 CF_EOF
2600         elif test -f $srcdir/$cf_dir/headers; then
2601 cat >> Makefile <<CF_EOF
2602
2603 libs \\
2604 install.libs \\
2605 uninstall.libs \\
2606 install.includes \\
2607 uninstall.includes ::
2608         cd $cf_dir && \${MAKE} \${CF_MFLAGS} \[$]@
2609 CF_EOF
2610 fi
2611 done
2612
2613 cat >> Makefile <<CF_EOF
2614
2615 install.libs uninstall.libs \\
2616 install.data uninstall.data ::
2617 $MAKE_TERMINFO  cd misc && \${MAKE} \${CF_MFLAGS} \[$]@
2618 CF_EOF
2619
2620 if test "x$cf_with_manpages" = xyes; then
2621 cat >> Makefile <<CF_EOF
2622
2623 install.man \\
2624 uninstall.man ::
2625         cd man && \${MAKE} \${CF_MFLAGS} \[$]@
2626 CF_EOF
2627 fi
2628
2629 cat >> Makefile <<CF_EOF
2630
2631 distclean ::
2632         rm -f config.cache config.log config.status Makefile include/ncurses_cfg.h
2633         rm -f headers.sh headers.sed mk_shared_lib.sh
2634         rm -f edit_man.* man_alias.*
2635         rm -rf \${DIRS_TO_MAKE}
2636 CF_EOF
2637
2638 # Special case: tack's manpage lives in its own directory.
2639 if test "x$cf_with_manpages" = xyes; then
2640 if test -d tack ; then
2641 if test -f $srcdir/$tack.h; then
2642 cat >> Makefile <<CF_EOF
2643
2644 install.man \\
2645 uninstall.man ::
2646         cd tack && \${MAKE} \${CF_MFLAGS} \[$]@
2647 CF_EOF
2648 fi
2649 fi
2650 fi
2651
2652 dnl If we're installing into a subdirectory of /usr/include, etc., we should
2653 dnl prepend the subdirectory's name to the "#include" paths.  It won't hurt
2654 dnl anything, and will make it more standardized.  It's awkward to decide this
2655 dnl at configuration because of quoting, so we'll simply make all headers
2656 dnl installed via a script that can do the right thing.
2657
2658 rm -f headers.sed headers.sh
2659
2660 dnl ( generating this script makes the makefiles a little tidier :-)
2661 echo creating headers.sh
2662 cat >headers.sh <<CF_EOF
2663 #! /bin/sh
2664 # This shell script is generated by the 'configure' script.  It is invoked in a
2665 # subdirectory of the build tree.  It generates a sed-script in the parent
2666 # directory that is used to adjust includes for header files that reside in a
2667 # subdirectory of /usr/include, etc.
2668 PRG=""
2669 while test \[$]# != 3
2670 do
2671 PRG="\$PRG \[$]1"; shift
2672 done
2673 DST=\[$]1
2674 REF=\[$]2
2675 SRC=\[$]3
2676 TMPSRC=\${TMPDIR-/tmp}/\`basename \$SRC\`\$\$
2677 TMPSED=\${TMPDIR-/tmp}/headers.sed\$\$
2678 echo installing \$SRC in \$DST
2679 CF_EOF
2680
2681 if test $WITH_CURSES_H = yes; then
2682         cat >>headers.sh <<CF_EOF
2683 case \$DST in
2684 /*/include/*)
2685         END=\`basename \$DST\`
2686         for i in \`cat \$REF/../*/headers |fgrep -v "#"\`
2687         do
2688                 NAME=\`basename \$i\`
2689                 echo "s/<\$NAME>/<\$END\/\$NAME>/" >> \$TMPSED
2690         done
2691         ;;
2692 *)
2693         echo "" >> \$TMPSED
2694         ;;
2695 esac
2696 CF_EOF
2697
2698 else
2699         cat >>headers.sh <<CF_EOF
2700 case \$DST in
2701 /*/include/*)
2702         END=\`basename \$DST\`
2703         for i in \`cat \$REF/../*/headers |fgrep -v "#"\`
2704         do
2705                 NAME=\`basename \$i\`
2706                 if test "\$NAME" = "curses.h"
2707                 then
2708                         echo "s/<curses.h>/<ncurses.h>/" >> \$TMPSED
2709                         NAME=ncurses.h
2710                 fi
2711                 echo "s/<\$NAME>/<\$END\/\$NAME>/" >> \$TMPSED
2712         done
2713         ;;
2714 *)
2715         echo "s/<curses.h>/<ncurses.h>/" >> \$TMPSED
2716         ;;
2717 esac
2718 CF_EOF
2719 fi
2720 cat >>headers.sh <<CF_EOF
2721 rm -f \$TMPSRC
2722 sed -f \$TMPSED \$SRC > \$TMPSRC
2723 NAME=\`basename \$SRC\`
2724 CF_EOF
2725 if test $WITH_CURSES_H != yes; then
2726         cat >>headers.sh <<CF_EOF
2727 test "\$NAME" = "curses.h" && NAME=ncurses.h
2728 CF_EOF
2729 fi
2730 cat >>headers.sh <<CF_EOF
2731 # Just in case someone gzip'd manpages, remove the conflicting copy.
2732 test -f \$DST/\$NAME.gz && rm -f \$DST/\$NAME.gz
2733
2734 eval \$PRG \$TMPSRC \$DST/\$NAME
2735 rm -f \$TMPSRC \$TMPSED
2736 CF_EOF
2737
2738 chmod 0755 headers.sh
2739
2740 for cf_dir in $SRC_SUBDIRS
2741 do
2742         if test ! -d $srcdir/$cf_dir ; then
2743                 continue
2744         fi
2745
2746         if test -f $srcdir/$cf_dir/headers; then
2747                 $AWK -f $srcdir/mk-hdr.awk \
2748                         subset="$LIB_SUBSETS" \
2749                         compat="$WITH_CURSES_H" \
2750                         $srcdir/$cf_dir/headers >>$cf_dir/Makefile
2751         fi
2752
2753         if test -f $srcdir/$cf_dir/modules; then
2754                 if test "$cf_dir" != "c++" ; then
2755                         cat >>$cf_dir/Makefile <<"CF_EOF"
2756 depend : ${AUTO_SRC}
2757         makedepend -- ${CPPFLAGS} -- ${C_SRC}
2758
2759 # DO NOT DELETE THIS LINE -- make depend depends on it.
2760 CF_EOF
2761                 fi
2762         fi
2763 done
2764
2765 ])dnl
2766 dnl ---------------------------------------------------------------------------
2767 dnl CF_LIB_SONAME version: 3 updated: 2006/12/16 15:55:46
2768 dnl -------------
2769 dnl Find the and soname for the given shared library.  Set the cache variable
2770 dnl cf_cv_$3_soname to this, unless it is not found.  Then set the cache
2771 dnl variable to "unknown".
2772 dnl
2773 dnl $1 = headers
2774 dnl $2 = code
2775 dnl $3 = library name
2776 AC_DEFUN([CF_LIB_SONAME],
2777 [
2778 AC_CACHE_CHECK(for soname of $3 library,cf_cv_$3_soname,[
2779
2780 cf_cv_$3_soname=unknown
2781 if test "$cross_compiling" != yes ; then
2782 cat >conftest.$ac_ext <<CF_EOF
2783 $1
2784 int main()
2785 {
2786 $2
2787         ${cf_cv_main_return:-return}(0);
2788 }
2789 CF_EOF
2790 cf_save_LIBS="$LIBS"
2791         LIBS="-l$3 $LIBS"
2792         if AC_TRY_EVAL(ac_compile) ; then
2793                 if AC_TRY_EVAL(ac_link) ; then
2794                         cf_cv_$3_soname=`ldd conftest$ac_exeext 2>/dev/null | sed -e 's,^.*/,,' -e 's, .*$,,' | fgrep lib$3.`
2795                         test -z "$cf_cv_$3_soname" && cf_cv_$3_soname=unknown
2796                 fi
2797         fi
2798 rm -f conftest*
2799 LIBS="$cf_save_LIBS"
2800 fi
2801 ])
2802 ])
2803 dnl ---------------------------------------------------------------------------
2804 dnl CF_LIB_SUFFIX version: 16 updated: 2008/12/27 12:30:03
2805 dnl -------------
2806 dnl Compute the library file-suffix from the given model name
2807 dnl $1 = model name
2808 dnl $2 = variable to set (the nominal library suffix)
2809 dnl $3 = dependency variable to set (actual filename)
2810 dnl The variable $LIB_SUFFIX, if set, prepends the variable to set.
2811 AC_DEFUN([CF_LIB_SUFFIX],
2812 [
2813         AC_REQUIRE([CF_SUBST_NCURSES_VERSION])
2814         case $1 in #(vi
2815         libtool) #(vi
2816                 $2='.la'
2817                 $3=[$]$2
2818                 ;;
2819         normal) #(vi
2820                 $2='.a'
2821                 $3=[$]$2
2822                 ;;
2823         debug) #(vi
2824                 $2='_g.a'
2825                 $3=[$]$2
2826                 ;;
2827         profile) #(vi
2828                 $2='_p.a'
2829                 $3=[$]$2
2830                 ;;
2831         shared) #(vi
2832                 case $cf_cv_system_name in
2833                 aix[[56]]*) #(vi
2834                         $2='.a'
2835                         $3=[$]$2
2836                         ;;
2837                 cygwin*) #(vi
2838                         $2='.dll'
2839                         $3='.dll.a'
2840                         ;;
2841                 darwin*) #(vi
2842                         $2='.dylib'
2843                         $3=[$]$2
2844                         ;;
2845                 hpux*) #(vi
2846                         case $target in
2847                         ia64*) #(vi
2848                                 $2='.so'
2849                                 $3=[$]$2
2850                                 ;;
2851                         *) #(vi
2852                                 $2='.sl'
2853                                 $3=[$]$2
2854                                 ;;
2855                         esac
2856                         ;;
2857                 *)      $2='.so'
2858                         $3=[$]$2
2859                         ;;
2860                 esac
2861         esac
2862         test -n "$LIB_SUFFIX" && $2="${LIB_SUFFIX}[$]{$2}"
2863         test -n "$LIB_SUFFIX" && $3="${LIB_SUFFIX}[$]{$3}"
2864 ])dnl
2865 dnl ---------------------------------------------------------------------------
2866 dnl CF_LIB_TYPE version: 4 updated: 2000/10/20 22:57:49
2867 dnl -----------
2868 dnl Compute the string to append to -library from the given model name
2869 dnl $1 = model name
2870 dnl $2 = variable to set
2871 dnl The variable $LIB_SUFFIX, if set, prepends the variable to set.
2872 AC_DEFUN([CF_LIB_TYPE],
2873 [
2874         case $1 in
2875         libtool) $2=''   ;;
2876         normal)  $2=''   ;;
2877         debug)   $2='_g' ;;
2878         profile) $2='_p' ;;
2879         shared)  $2=''   ;;
2880         esac
2881         test -n "$LIB_SUFFIX" && $2="${LIB_SUFFIX}[$]{$2}"
2882 ])dnl
2883 dnl ---------------------------------------------------------------------------
2884 dnl CF_LINK_DATAONLY version: 9 updated: 2009/01/01 20:21:38
2885 dnl ----------------
2886 dnl Some systems have a non-ANSI linker that doesn't pull in modules that have
2887 dnl only data (i.e., no functions), for example NeXT.  On those systems we'll
2888 dnl have to provide wrappers for global tables to ensure they're linked
2889 dnl properly.
2890 AC_DEFUN([CF_LINK_DATAONLY],
2891 [
2892 AC_MSG_CHECKING([if data-only library module links])
2893 AC_CACHE_VAL(cf_cv_link_dataonly,[
2894         rm -f conftest.a
2895         cat >conftest.$ac_ext <<EOF
2896 #line __oline__ "configure"
2897 int     testdata[[3]] = { 123, 456, 789 };
2898 EOF
2899         if AC_TRY_EVAL(ac_compile) ; then
2900                 mv conftest.o data.o && \
2901                 ( $AR $ARFLAGS conftest.a data.o ) 2>&AC_FD_CC 1>/dev/null
2902         fi
2903         rm -f conftest.$ac_ext data.o
2904         cat >conftest.$ac_ext <<EOF
2905 #line __oline__ "configure"
2906 int     testfunc()
2907 {
2908 #if defined(NeXT)
2909         ${cf_cv_main_return:-return}(1);        /* I'm told this linker is broken */
2910 #else
2911         extern int testdata[[3]];
2912         return testdata[[0]] == 123
2913            &&  testdata[[1]] == 456
2914            &&  testdata[[2]] == 789;
2915 #endif
2916 }
2917 EOF
2918         if AC_TRY_EVAL(ac_compile); then
2919                 mv conftest.o func.o && \
2920                 ( $AR $ARFLAGS conftest.a func.o ) 2>&AC_FD_CC 1>/dev/null
2921         fi
2922         rm -f conftest.$ac_ext func.o
2923         ( eval $RANLIB conftest.a ) 2>&AC_FD_CC >/dev/null
2924         cf_saveLIBS="$LIBS"
2925         LIBS="conftest.a $LIBS"
2926         AC_TRY_RUN([
2927         int main()
2928         {
2929                 extern int testfunc();
2930                 ${cf_cv_main_return:-return} (!testfunc());
2931         }
2932         ],
2933         [cf_cv_link_dataonly=yes],
2934         [cf_cv_link_dataonly=no],
2935         [cf_cv_link_dataonly=unknown])
2936         LIBS="$cf_saveLIBS"
2937         ])
2938 AC_MSG_RESULT($cf_cv_link_dataonly)
2939
2940 if test "$cf_cv_link_dataonly" = no ; then
2941         AC_DEFINE(BROKEN_LINKER)
2942         BROKEN_LINKER=1
2943 fi
2944
2945 ])dnl
2946 dnl ---------------------------------------------------------------------------
2947 dnl CF_LINK_FUNCS version: 7 updated: 2006/12/16 12:33:30
2948 dnl -------------
2949 dnl Most Unix systems have both link and symlink, a few don't have symlink.
2950 dnl A few non-Unix systems implement symlink, but not link.
2951 dnl A few non-systems implement neither (or have nonfunctional versions).
2952 AC_DEFUN([CF_LINK_FUNCS],
2953 [
2954 AC_CHECK_FUNCS( \
2955         remove \
2956         unlink )
2957
2958 if test "$cross_compiling" = yes ; then
2959         AC_CHECK_FUNCS( \
2960                 link \
2961                 symlink )
2962 else
2963         AC_CACHE_CHECK(if link/symlink functions work,cf_cv_link_funcs,[
2964                 cf_cv_link_funcs=
2965                 for cf_func in link symlink ; do
2966                         AC_TRY_RUN([
2967 #include <sys/types.h>
2968 #include <sys/stat.h>
2969 #ifdef HAVE_UNISTD_H
2970 #include <unistd.h>
2971 #endif
2972 int main()
2973 {
2974         int fail = 0;
2975         char *src = "config.log";
2976         char *dst = "conftest.chk";
2977         struct stat src_sb;
2978         struct stat dst_sb;
2979
2980         stat(src, &src_sb);
2981         fail = ($cf_func("config.log", "conftest.chk") < 0)
2982             || (stat(dst, &dst_sb) < 0)
2983             || (dst_sb.st_mtime != src_sb.st_mtime);
2984 #ifdef HAVE_UNLINK
2985         unlink(dst);
2986 #else
2987         remove(dst);
2988 #endif
2989         ${cf_cv_main_return:-return} (fail);
2990 }
2991                         ],[
2992                         cf_cv_link_funcs="$cf_cv_link_funcs $cf_func"
2993                         eval 'ac_cv_func_'$cf_func'=yes'],[
2994                         eval 'ac_cv_func_'$cf_func'=no'],[
2995                         eval 'ac_cv_func_'$cf_func'=error'])
2996                 done
2997                 test -z "$cf_cv_link_funcs" && cf_cv_link_funcs=no
2998         ])
2999         test "$ac_cv_func_link"    = yes && AC_DEFINE(HAVE_LINK)
3000         test "$ac_cv_func_symlink" = yes && AC_DEFINE(HAVE_SYMLINK)
3001 fi
3002 ])dnl
3003 dnl ---------------------------------------------------------------------------
3004 dnl CF_MAIN_RETURN version: 1 updated: 2006/12/10 09:51:54
3005 dnl --------------
3006 dnl Check if a return from main to the shell actually returns the same exit
3007 dnl code.  This is true for almost any POSIX environment.
3008 dnl
3009 dnl Some very old environments did not flush stdout, etc., on an exit.  That
3010 dnl would be a useful case to test for also.
3011 AC_DEFUN([CF_MAIN_RETURN],
3012 [
3013 cf_cv_main_return=return
3014 ])dnl
3015 dnl ---------------------------------------------------------------------------
3016 dnl CF_MAKEFLAGS version: 12 updated: 2006/10/21 08:27:03
3017 dnl ------------
3018 dnl Some 'make' programs support ${MAKEFLAGS}, some ${MFLAGS}, to pass 'make'
3019 dnl options to lower-levels.  It's very useful for "make -n" -- if we have it.
3020 dnl (GNU 'make' does both, something POSIX 'make', which happens to make the
3021 dnl ${MAKEFLAGS} variable incompatible because it adds the assignments :-)
3022 AC_DEFUN([CF_MAKEFLAGS],
3023 [
3024 AC_CACHE_CHECK(for makeflags variable, cf_cv_makeflags,[
3025         cf_cv_makeflags=''
3026         for cf_option in '-${MAKEFLAGS}' '${MFLAGS}'
3027         do
3028                 cat >cf_makeflags.tmp <<CF_EOF
3029 SHELL = /bin/sh
3030 all :
3031         @ echo '.$cf_option'
3032 CF_EOF
3033                 cf_result=`${MAKE-make} -k -f cf_makeflags.tmp 2>/dev/null | sed -e 's,[[       ]]*$,,'`
3034                 case "$cf_result" in
3035                 .*k)
3036                         cf_result=`${MAKE-make} -k -f cf_makeflags.tmp CC=cc 2>/dev/null`
3037                         case "$cf_result" in
3038                         .*CC=*) cf_cv_makeflags=
3039                                 ;;
3040                         *)      cf_cv_makeflags=$cf_option
3041                                 ;;
3042                         esac
3043                         break
3044                         ;;
3045                 .-)     ;;
3046                 *)      echo "given option \"$cf_option\", no match \"$cf_result\""
3047                         ;;
3048                 esac
3049         done
3050         rm -f cf_makeflags.tmp
3051 ])
3052
3053 AC_SUBST(cf_cv_makeflags)
3054 ])dnl
3055 dnl ---------------------------------------------------------------------------
3056 dnl CF_MAKE_TAGS version: 2 updated: 2000/10/04 09:18:40
3057 dnl ------------
3058 dnl Generate tags/TAGS targets for makefiles.  Do not generate TAGS if we have
3059 dnl a monocase filesystem.
3060 AC_DEFUN([CF_MAKE_TAGS],[
3061 AC_REQUIRE([CF_MIXEDCASE_FILENAMES])
3062 AC_CHECK_PROG(MAKE_LOWER_TAGS, ctags, yes, no)
3063
3064 if test "$cf_cv_mixedcase" = yes ; then
3065         AC_CHECK_PROG(MAKE_UPPER_TAGS, etags, yes, no)
3066 else
3067         MAKE_UPPER_TAGS=no
3068 fi
3069
3070 if test "$MAKE_UPPER_TAGS" = yes ; then
3071         MAKE_UPPER_TAGS=
3072 else
3073         MAKE_UPPER_TAGS="#"
3074 fi
3075 AC_SUBST(MAKE_UPPER_TAGS)
3076
3077 if test "$MAKE_LOWER_TAGS" = yes ; then
3078         MAKE_LOWER_TAGS=
3079 else
3080         MAKE_LOWER_TAGS="#"
3081 fi
3082 AC_SUBST(MAKE_LOWER_TAGS)
3083 ])dnl
3084 dnl ---------------------------------------------------------------------------
3085 dnl CF_MANPAGE_FORMAT version: 8 updated: 2009/01/11 20:30:50
3086 dnl -----------------
3087 dnl Option to allow user to override automatic configuration of manpage format.
3088 dnl There are several special cases:
3089 dnl
3090 dnl     gzip - man checks for, can display gzip'd files
3091 dnl     compress - man checks for, can display compressed files
3092 dnl     BSDI - files in the cat-directories are suffixed ".0"
3093 dnl     formatted - installer should format (put files in cat-directory)
3094 dnl     catonly - installer should only format, e.g., for a turnkey system.
3095 dnl
3096 dnl There are other configurations which this macro does not test, e.g., HPUX's
3097 dnl compressed manpages (but uncompressed manpages are fine, and HPUX's naming
3098 dnl convention would not match our use).
3099 AC_DEFUN([CF_MANPAGE_FORMAT],
3100 [
3101 AC_REQUIRE([CF_PATHSEP])
3102 AC_MSG_CHECKING(format of man-pages)
3103
3104 AC_ARG_WITH(manpage-format,
3105         [  --with-manpage-format   specify manpage-format: gzip/compress/BSDI/normal and
3106                           optionally formatted/catonly, e.g., gzip,formatted],
3107         [MANPAGE_FORMAT=$withval],
3108         [MANPAGE_FORMAT=unknown])
3109
3110 test -z "$MANPAGE_FORMAT" && MANPAGE_FORMAT=unknown
3111 MANPAGE_FORMAT=`echo "$MANPAGE_FORMAT" | sed -e 's/,/ /g'`
3112
3113 cf_unknown=
3114
3115 case $MANPAGE_FORMAT in
3116 unknown)
3117   if test -z "$MANPATH" ; then
3118     MANPATH="/usr/man:/usr/share/man"
3119   fi
3120
3121   # look for the 'date' man-page (it's most likely to be installed!)
3122   MANPAGE_FORMAT=
3123   cf_preform=no
3124   cf_catonly=yes
3125   cf_example=date
3126
3127   IFS="${IFS=   }"; ac_save_ifs="$IFS"; IFS="${IFS}${PATH_SEPARATOR}"
3128   for cf_dir in $MANPATH; do
3129     test -z "$cf_dir" && cf_dir=/usr/man
3130     for cf_name in $cf_dir/man*/$cf_example.[[01]]* $cf_dir/cat*/$cf_example.[[01]]* $cf_dir/man*/$cf_example $cf_dir/cat*/$cf_example
3131     do
3132       cf_test=`echo $cf_name | sed -e 's/*//'`
3133       if test "x$cf_test" = "x$cf_name" ; then
3134
3135         case "$cf_name" in
3136         *.gz) MANPAGE_FORMAT="$MANPAGE_FORMAT gzip";;
3137         *.Z)  MANPAGE_FORMAT="$MANPAGE_FORMAT compress";;
3138         *.0)    MANPAGE_FORMAT="$MANPAGE_FORMAT BSDI";;
3139         *)    MANPAGE_FORMAT="$MANPAGE_FORMAT normal";;
3140         esac
3141
3142         case "$cf_name" in
3143         $cf_dir/man*)
3144           cf_catonly=no
3145           ;;
3146         $cf_dir/cat*)
3147           cf_preform=yes
3148           ;;
3149         esac
3150         break
3151       fi
3152
3153       # if we found a match in either man* or cat*, stop looking
3154       if test -n "$MANPAGE_FORMAT" ; then
3155         cf_found=no
3156         test "$cf_preform" = yes && MANPAGE_FORMAT="$MANPAGE_FORMAT formatted"
3157         test "$cf_catonly" = yes && MANPAGE_FORMAT="$MANPAGE_FORMAT catonly"
3158         case "$cf_name" in
3159         $cf_dir/cat*)
3160           cf_found=yes
3161           ;;
3162         esac
3163         test $cf_found=yes && break
3164       fi
3165     done
3166     # only check the first directory in $MANPATH where we find manpages
3167     if test -n "$MANPAGE_FORMAT" ; then
3168        break
3169     fi
3170   done
3171   # if we did not find the example, just assume it is normal
3172   test -z "$MANPAGE_FORMAT" && MANPAGE_FORMAT=normal
3173   IFS="$ac_save_ifs"
3174   ;;
3175 *)
3176   for cf_option in $MANPAGE_FORMAT; do
3177      case $cf_option in #(vi
3178      gzip|compress|BSDI|normal|formatted|catonly)
3179        ;;
3180      *)
3181        cf_unknown="$cf_unknown $cf_option"
3182        ;;
3183      esac
3184   done
3185   ;;
3186 esac
3187
3188 AC_MSG_RESULT($MANPAGE_FORMAT)
3189 if test -n "$cf_unknown" ; then
3190   AC_MSG_WARN(Unexpected manpage-format $cf_unknown)
3191 fi
3192 ])dnl
3193 dnl ---------------------------------------------------------------------------
3194 dnl CF_MANPAGE_RENAMES version: 7 updated: 2005/06/18 18:51:57
3195 dnl ------------------
3196 dnl The Debian people have their own naming convention for manpages.  This
3197 dnl option lets us override the name of the file containing renaming, or
3198 dnl disable it altogether.
3199 AC_DEFUN([CF_MANPAGE_RENAMES],
3200 [
3201 AC_MSG_CHECKING(for manpage renaming)
3202
3203 AC_ARG_WITH(manpage-renames,
3204         [  --with-manpage-renames  specify manpage-renaming],
3205         [MANPAGE_RENAMES=$withval],
3206         [MANPAGE_RENAMES=yes])
3207
3208 case ".$MANPAGE_RENAMES" in #(vi
3209 .no) #(vi
3210   ;;
3211 .|.yes)
3212   # Debian 'man' program?
3213   if test -f /etc/debian_version ; then
3214     MANPAGE_RENAMES=`cd $srcdir && pwd`/man/man_db.renames
3215   else
3216     MANPAGE_RENAMES=no
3217   fi
3218   ;;
3219 esac
3220
3221 if test "$MANPAGE_RENAMES" != no ; then
3222   if test -f $srcdir/man/$MANPAGE_RENAMES ; then
3223     MANPAGE_RENAMES=`cd $srcdir/man && pwd`/$MANPAGE_RENAMES
3224   elif test ! -f $MANPAGE_RENAMES ; then
3225     AC_MSG_ERROR(not a filename: $MANPAGE_RENAMES)
3226   fi
3227
3228   test ! -d man && mkdir man
3229
3230   # Construct a sed-script to perform renaming within man-pages
3231   if test -n "$MANPAGE_RENAMES" ; then
3232     test ! -d man && mkdir man
3233     sh $srcdir/man/make_sed.sh $MANPAGE_RENAMES >./edit_man.sed
3234   fi
3235 fi
3236
3237 AC_MSG_RESULT($MANPAGE_RENAMES)
3238 AC_SUBST(MANPAGE_RENAMES)
3239 ])dnl
3240 dnl ---------------------------------------------------------------------------
3241 dnl CF_MANPAGE_SYMLINKS version: 4 updated: 2003/12/13 18:01:58
3242 dnl -------------------
3243 dnl Some people expect each tool to make all aliases for manpages in the
3244 dnl man-directory.  This accommodates the older, less-capable implementations
3245 dnl of 'man', and is optional.
3246 AC_DEFUN([CF_MANPAGE_SYMLINKS],
3247 [
3248 AC_MSG_CHECKING(if manpage aliases will be installed)
3249
3250 AC_ARG_WITH(manpage-aliases,
3251         [  --with-manpage-aliases  specify manpage-aliases using .so],
3252         [MANPAGE_ALIASES=$withval],
3253         [MANPAGE_ALIASES=yes])
3254
3255 AC_MSG_RESULT($MANPAGE_ALIASES)
3256
3257 if test "$LN_S" = "ln -s"; then
3258         cf_use_symlinks=yes
3259 else
3260         cf_use_symlinks=no
3261 fi
3262
3263 MANPAGE_SYMLINKS=no
3264 if test "$MANPAGE_ALIASES" = yes ; then
3265 AC_MSG_CHECKING(if manpage symlinks should be used)
3266
3267 AC_ARG_WITH(manpage-symlinks,
3268         [  --with-manpage-symlinks specify manpage-aliases using symlinks],
3269         [MANPAGE_SYMLINKS=$withval],
3270         [MANPAGE_SYMLINKS=$cf_use_symlinks])
3271
3272 if test "$$cf_use_symlinks" = no; then
3273 if test "$MANPAGE_SYMLINKS" = yes ; then
3274         AC_MSG_WARN(cannot make symlinks, will use .so files)
3275         MANPAGE_SYMLINKS=no
3276 fi
3277 fi
3278
3279 AC_MSG_RESULT($MANPAGE_SYMLINKS)
3280 fi
3281
3282 ])dnl
3283 dnl ---------------------------------------------------------------------------
3284 dnl CF_MANPAGE_TBL version: 3 updated: 2002/01/19 22:51:32
3285 dnl --------------
3286 dnl This option causes manpages to be run through tbl(1) to generate tables
3287 dnl correctly.
3288 AC_DEFUN([CF_MANPAGE_TBL],
3289 [
3290 AC_MSG_CHECKING(for manpage tbl)
3291
3292 AC_ARG_WITH(manpage-tbl,
3293         [  --with-manpage-tbl      specify manpage processing with tbl],
3294         [MANPAGE_TBL=$withval],
3295         [MANPAGE_TBL=no])
3296
3297 AC_MSG_RESULT($MANPAGE_TBL)
3298 ])dnl
3299 dnl ---------------------------------------------------------------------------
3300 dnl CF_MAN_PAGES version: 35 updated: 2007/03/31 11:47:29
3301 dnl ------------
3302 dnl Try to determine if the man-pages on the system are compressed, and if
3303 dnl so, what format is used.  Use this information to construct a script that
3304 dnl will install man-pages.
3305 AC_DEFUN([CF_MAN_PAGES],
3306 [
3307 CF_HELP_MESSAGE(Options to Specify How Manpages are Installed:)
3308 CF_MANPAGE_FORMAT
3309 CF_MANPAGE_RENAMES
3310 CF_MANPAGE_SYMLINKS
3311 CF_MANPAGE_TBL
3312
3313   if test "$prefix" = "NONE" ; then
3314      cf_prefix="$ac_default_prefix"
3315   else
3316      cf_prefix="$prefix"
3317   fi
3318
3319   case "$MANPAGE_FORMAT" in # (vi
3320   *catonly*) # (vi
3321     cf_format=yes
3322     cf_inboth=no
3323     ;;
3324   *formatted*) # (vi
3325     cf_format=yes
3326     cf_inboth=yes
3327     ;;
3328   *)
3329     cf_format=no
3330     cf_inboth=no
3331     ;;
3332   esac
3333
3334 test ! -d man && mkdir man
3335
3336 cf_so_strip=
3337 cf_compress=
3338 case "$MANPAGE_FORMAT" in #(vi
3339 *compress*) #(vi
3340         cf_so_strip="Z"
3341         cf_compress=compress
3342   ;;
3343 *gzip*) #(vi
3344         cf_so_strip="gz"
3345         cf_compress=gzip
3346   ;;
3347 esac
3348
3349 cf_edit_man=./edit_man.sh
3350 cf_man_alias=`pwd`/man_alias.sed
3351
3352 cat >$cf_edit_man <<CF_EOF
3353 #! /bin/sh
3354 # this script is generated by the configure-script CF_MAN_PAGES macro.
3355
3356 prefix="$cf_prefix"
3357 datadir="$datadir"
3358
3359 NCURSES_MAJOR="$NCURSES_MAJOR"
3360 NCURSES_MINOR="$NCURSES_MINOR"
3361 NCURSES_PATCH="$NCURSES_PATCH"
3362
3363 NCURSES_OSPEED="$NCURSES_OSPEED"
3364 TERMINFO="$TERMINFO"
3365
3366 MKDIRS="sh `cd $srcdir && pwd`/mkdirs.sh"
3367
3368 INSTALL="$INSTALL"
3369 INSTALL_DATA="$INSTALL_DATA"
3370
3371 transform="$program_transform_name"
3372
3373 TMP=\${TMPDIR-/tmp}/man\$\$
3374 trap "rm -f \$TMP" 0 1 2 5 15
3375
3376 form=\[$]1
3377 shift || exit 1
3378
3379 verb=\[$]1
3380 shift || exit 1
3381
3382 mandir=\[$]1
3383 shift || exit 1
3384
3385 srcdir=\[$]1
3386 top_srcdir=\[$]srcdir/..
3387 shift || exit 1
3388
3389 if test "\$form" = normal ; then
3390         if test "$cf_format" = yes ; then
3391         if test "$cf_inboth" = no ; then
3392                 sh \[$]0 format \$verb \$mandir \$srcdir \[$]*
3393                 exit $?
3394         fi
3395         fi
3396         cf_subdir=\$mandir/man
3397         cf_tables=$MANPAGE_TBL
3398 else
3399         cf_subdir=\$mandir/cat
3400         cf_tables=yes
3401 fi
3402
3403 # process the list of source-files
3404 for i in \[$]* ; do
3405 case \$i in #(vi
3406 *.orig|*.rej) ;; #(vi
3407 *.[[0-9]]*)
3408         section=\`expr "\$i" : '.*\\.\\([[0-9]]\\)[[xm]]*'\`;
3409         if test \$verb = installing ; then
3410         if test ! -d \$cf_subdir\${section} ; then
3411                 \$MKDIRS \$cf_subdir\$section
3412         fi
3413         fi
3414
3415         # replace variables in man page
3416         if test ! -f $cf_man_alias ; then
3417 cat >>$cf_man_alias <<-CF_EOF2
3418                 s,@DATADIR@,\$datadir,g
3419                 s,@TERMINFO@,\$TERMINFO,g
3420                 s,@NCURSES_MAJOR@,\$NCURSES_MAJOR,g
3421                 s,@NCURSES_MINOR@,\$NCURSES_MINOR,g
3422                 s,@NCURSES_PATCH@,\$NCURSES_PATCH,g
3423                 s,@NCURSES_OSPEED@,\$NCURSES_OSPEED,g
3424 CF_EOF
3425         ifelse($1,,,[
3426         for cf_name in $1
3427         do
3428                 cf_NAME=`echo "$cf_name" | sed y%abcdefghijklmnopqrstuvwxyz./-%ABCDEFGHIJKLMNOPQRSTUVWXYZ___%`
3429                 cf_name=`echo $cf_name|sed "$program_transform_name"`
3430 cat >>$cf_edit_man <<-CF_EOF
3431                 s,@$cf_NAME@,$cf_name,
3432 CF_EOF
3433         done
3434         ])
3435 cat >>$cf_edit_man <<CF_EOF
3436 CF_EOF2
3437                 echo "...made $cf_man_alias"
3438         fi
3439
3440         aliases=
3441         cf_source=\`basename \$i\`
3442         inalias=\$cf_source
3443         test ! -f \$inalias && inalias="\$srcdir/\$inalias"
3444         if test ! -f \$inalias ; then
3445                 echo .. skipped \$cf_source
3446                 continue
3447         fi
3448 CF_EOF
3449
3450 if test "$MANPAGE_ALIASES" != no ; then
3451 cat >>$cf_edit_man <<CF_EOF
3452         aliases=\`sed -f \$top_srcdir/man/manlinks.sed \$inalias |sed -f $cf_man_alias | sort -u\`
3453 CF_EOF
3454 fi
3455
3456 if test "$MANPAGE_RENAMES" = no ; then
3457 cat >>$cf_edit_man <<CF_EOF
3458         # perform program transformations for section 1 man pages
3459         if test \$section = 1 ; then
3460                 cf_target=\$cf_subdir\${section}/\`echo \$cf_source|sed "\${transform}"\`
3461         else
3462                 cf_target=\$cf_subdir\${section}/\$cf_source
3463         fi
3464 CF_EOF
3465 else
3466 cat >>$cf_edit_man <<CF_EOF
3467         cf_target=\`grep "^\$cf_source" $MANPAGE_RENAMES | $AWK '{print \[$]2}'\`
3468         if test -z "\$cf_target" ; then
3469                 echo '? missing rename for '\$cf_source
3470                 cf_target="\$cf_source"
3471         fi
3472         cf_target="\$cf_subdir\${section}/\${cf_target}"
3473
3474 CF_EOF
3475 fi
3476
3477 cat >>$cf_edit_man <<CF_EOF
3478         sed     -f $cf_man_alias \\
3479 CF_EOF
3480
3481 if test -f $MANPAGE_RENAMES ; then
3482 cat >>$cf_edit_man <<CF_EOF
3483                 < \$i | sed -f `pwd`/edit_man.sed >\$TMP
3484 CF_EOF
3485 else
3486 cat >>$cf_edit_man <<CF_EOF
3487                 < \$i >\$TMP
3488 CF_EOF
3489 fi
3490
3491 cat >>$cf_edit_man <<CF_EOF
3492 if test \$cf_tables = yes ; then
3493         tbl \$TMP >\$TMP.out
3494         mv \$TMP.out \$TMP
3495 fi
3496 CF_EOF
3497
3498 if test $with_curses_h != yes ; then
3499 cat >>$cf_edit_man <<CF_EOF
3500         sed -e "/\#[    ]*include/s,curses.h,ncurses.h," < \$TMP >\$TMP.out
3501         mv \$TMP.out \$TMP
3502 CF_EOF
3503 fi
3504
3505 cat >>$cf_edit_man <<CF_EOF
3506         if test \$form = format ; then
3507                 nroff -man \$TMP >\$TMP.out
3508                 mv \$TMP.out \$TMP
3509         fi
3510 CF_EOF
3511
3512 if test -n "$cf_compress" ; then
3513 cat >>$cf_edit_man <<CF_EOF
3514         if test \$verb = installing ; then
3515         if ( $cf_compress -f \$TMP )
3516         then
3517                 mv \$TMP.$cf_so_strip \$TMP
3518         fi
3519         fi
3520         cf_target="\$cf_target.$cf_so_strip"
3521 CF_EOF
3522 fi
3523
3524 case "$MANPAGE_FORMAT" in #(vi
3525 *BSDI*)
3526 cat >>$cf_edit_man <<CF_EOF
3527         if test \$form = format ; then
3528                 # BSDI installs only .0 suffixes in the cat directories
3529                 cf_target="\`echo \$cf_target|sed -e 's/\.[[1-9]]\+[[a-z]]*/.0/'\`"
3530         fi
3531 CF_EOF
3532   ;;
3533 esac
3534
3535 cat >>$cf_edit_man <<CF_EOF
3536         suffix=\`basename \$cf_target | sed -e 's%^[[^.]]*%%'\`
3537         if test \$verb = installing ; then
3538                 echo \$verb \$cf_target
3539                 \$INSTALL_DATA \$TMP \$cf_target
3540                 test -d \$cf_subdir\${section} &&
3541                 test -n "\$aliases" && (
3542                         cd \$cf_subdir\${section} && (
3543                                 cf_source=\`echo \$cf_target |sed -e 's%^.*/\([[^/]][[^/]]*/[[^/]][[^/]]*$\)%\1%'\`
3544                                 test -n "$cf_so_strip" && cf_source=\`echo \$cf_source |sed -e 's%\.$cf_so_strip\$%%'\`
3545                                 cf_target=\`basename \$cf_target\`
3546                                 for cf_alias in \$aliases
3547                                 do
3548                                         if test \$section = 1 ; then
3549                                                 cf_alias=\`echo \$cf_alias|sed "\${transform}"\`
3550                                         fi
3551
3552                                         if test "$MANPAGE_SYMLINKS" = yes ; then
3553                                                 if test -f \$cf_alias\${suffix} ; then
3554                                                         if ( cmp -s \$cf_target \$cf_alias\${suffix} )
3555                                                         then
3556                                                                 continue
3557                                                         fi
3558                                                 fi
3559                                                 echo .. \$verb alias \$cf_alias\${suffix}
3560                                                 rm -f \$cf_alias\${suffix}
3561                                                 $LN_S \$cf_target \$cf_alias\${suffix}
3562                                         elif test "\$cf_target" != "\$cf_alias\${suffix}" ; then
3563                                                 echo ".so \$cf_source" >\$TMP
3564 CF_EOF
3565 if test -n "$cf_compress" ; then
3566 cat >>$cf_edit_man <<CF_EOF
3567                                                 if test -n "$cf_so_strip" ; then
3568                                                         $cf_compress -f \$TMP
3569                                                         mv \$TMP.$cf_so_strip \$TMP
3570                                                 fi
3571 CF_EOF
3572 fi
3573 cat >>$cf_edit_man <<CF_EOF
3574                                                 echo .. \$verb alias \$cf_alias\${suffix}
3575                                                 rm -f \$cf_alias\${suffix}
3576                                                 \$INSTALL_DATA \$TMP \$cf_alias\${suffix}
3577                                         fi
3578                                 done
3579                         )
3580                 )
3581         elif test \$verb = removing ; then
3582                 test -f \$cf_target && (
3583                         echo \$verb \$cf_target
3584                         rm -f \$cf_target
3585                 )
3586                 test -d \$cf_subdir\${section} &&
3587                 test -n "\$aliases" && (
3588                         cd \$cf_subdir\${section} && (
3589                                 for cf_alias in \$aliases
3590                                 do
3591                                         if test \$section = 1 ; then
3592                                                 cf_alias=\`echo \$cf_alias|sed "\${transform}"\`
3593                                         fi
3594
3595                                         echo .. \$verb alias \$cf_alias\${suffix}
3596                                         rm -f \$cf_alias\${suffix}
3597                                 done
3598                         )
3599                 )
3600         else
3601 #               echo ".hy 0"
3602                 cat \$TMP
3603         fi
3604         ;;
3605 esac
3606 done
3607
3608 if test $cf_inboth = yes ; then
3609 if test \$form != format ; then
3610         sh \[$]0 format \$verb \$mandir \$srcdir \[$]*
3611 fi
3612 fi
3613
3614 exit 0
3615 CF_EOF
3616 chmod 755 $cf_edit_man
3617
3618 ])dnl
3619 dnl ---------------------------------------------------------------------------
3620 dnl CF_MATH_LIB version: 5 updated: 2000/05/28 01:39:10
3621 dnl -----------
3622 dnl Checks for libraries.  At least one UNIX system, Apple Macintosh
3623 dnl Rhapsody 5.5, does not have -lm.  We cannot use the simpler
3624 dnl AC_CHECK_LIB(m,sin), because that fails for C++.
3625 AC_DEFUN([CF_MATH_LIB],
3626 [
3627 AC_CACHE_CHECK(if -lm needed for math functions,
3628         cf_cv_need_libm,[
3629         AC_TRY_LINK([
3630         #include <stdio.h>
3631         #include <math.h>
3632         ],
3633         [double x = rand(); printf("result = %g\n", ]ifelse($2,,sin(x),$2)[)],
3634         [cf_cv_need_libm=no],
3635         [cf_cv_need_libm=yes])])
3636 if test "$cf_cv_need_libm" = yes
3637 then
3638 ifelse($1,,[
3639         LIBS="$LIBS -lm"
3640 ],[$1=-lm])
3641 fi
3642 ])
3643 dnl ---------------------------------------------------------------------------
3644 dnl CF_MIXEDCASE_FILENAMES version: 3 updated: 2003/09/20 17:07:55
3645 dnl ----------------------
3646 dnl Check if the file-system supports mixed-case filenames.  If we're able to
3647 dnl create a lowercase name and see it as uppercase, it doesn't support that.
3648 AC_DEFUN([CF_MIXEDCASE_FILENAMES],
3649 [
3650 AC_CACHE_CHECK(if filesystem supports mixed-case filenames,cf_cv_mixedcase,[
3651 if test "$cross_compiling" = yes ; then
3652         case $target_alias in #(vi
3653         *-os2-emx*|*-msdosdjgpp*|*-cygwin*|*-mingw32*|*-uwin*) #(vi
3654                 cf_cv_mixedcase=no
3655                 ;;
3656         *)
3657                 cf_cv_mixedcase=yes
3658                 ;;
3659         esac
3660 else
3661         rm -f conftest CONFTEST
3662         echo test >conftest
3663         if test -f CONFTEST ; then
3664                 cf_cv_mixedcase=no
3665         else
3666                 cf_cv_mixedcase=yes
3667         fi
3668         rm -f conftest CONFTEST
3669 fi
3670 ])
3671 test "$cf_cv_mixedcase" = yes && AC_DEFINE(MIXEDCASE_FILENAMES)
3672 ])dnl
3673 dnl ---------------------------------------------------------------------------
3674 dnl CF_MKSTEMP version: 5 updated: 2006/12/16 12:33:30
3675 dnl ----------
3676 dnl Check for a working mkstemp.  This creates two files, checks that they are
3677 dnl successfully created and distinct (AmigaOS apparently fails on the last).
3678 AC_DEFUN([CF_MKSTEMP],[
3679 AC_CACHE_CHECK(for working mkstemp, cf_cv_func_mkstemp,[
3680 rm -f conftest*
3681 AC_TRY_RUN([
3682 #include <sys/types.h>
3683 #include <stdlib.h>
3684 #include <stdio.h>
3685 #include <string.h>
3686 #include <sys/stat.h>
3687 int main()
3688 {
3689         char *tmpl = "conftestXXXXXX";
3690         char name[2][80];
3691         int n;
3692         int result = 0;
3693         int fd;
3694         struct stat sb;
3695
3696         umask(077);
3697         for (n = 0; n < 2; ++n) {
3698                 strcpy(name[n], tmpl);
3699                 if ((fd = mkstemp(name[n])) >= 0) {
3700                         if (!strcmp(name[n], tmpl)
3701                          || stat(name[n], &sb) != 0
3702                          || (sb.st_mode & S_IFMT) != S_IFREG
3703                          || (sb.st_mode & 077) != 0) {
3704                                 result = 1;
3705                         }
3706                         close(fd);
3707                 }
3708         }
3709         if (result == 0
3710          && !strcmp(name[0], name[1]))
3711                 result = 1;
3712         ${cf_cv_main_return:-return}(result);
3713 }
3714 ],[cf_cv_func_mkstemp=yes
3715 ],[cf_cv_func_mkstemp=no
3716 ],[AC_CHECK_FUNC(mkstemp)
3717 ])
3718 ])
3719 if test "$cf_cv_func_mkstemp" = yes ; then
3720         AC_DEFINE(HAVE_MKSTEMP)
3721 fi
3722 ])dnl
3723 dnl ---------------------------------------------------------------------------
3724 dnl CF_MSG_LOG version: 4 updated: 2007/07/29 09:55:12
3725 dnl ----------
3726 dnl Write a debug message to config.log, along with the line number in the
3727 dnl configure script.
3728 AC_DEFUN([CF_MSG_LOG],[
3729 echo "${as_me-configure}:__oline__: testing $* ..." 1>&AC_FD_CC
3730 ])dnl
3731 dnl ---------------------------------------------------------------------------
3732 dnl CF_NCURSES_ABI_6 version: 1 updated: 2005/09/17 18:42:49
3733 dnl ----------------
3734 dnl Set ncurses' ABI to 6 unless overridden by explicit configure option, and
3735 dnl warn about this.
3736 AC_DEFUN([CF_NCURSES_ABI_6],[
3737 if test "${with_abi_version+set}" != set; then
3738         case $cf_cv_rel_version in
3739         5.*)
3740                 cf_cv_rel_version=6.0
3741                 cf_cv_abi_version=6
3742                 AC_MSG_WARN(Overriding ABI version to $cf_cv_abi_version)
3743                 ;;
3744         esac
3745 fi
3746 ])dnl
3747 dnl ---------------------------------------------------------------------------
3748 dnl CF_NO_LEAKS_OPTION version: 4 updated: 2006/12/16 14:24:05
3749 dnl ------------------
3750 dnl see CF_WITH_NO_LEAKS
3751 AC_DEFUN([CF_NO_LEAKS_OPTION],[
3752 AC_MSG_CHECKING(if you want to use $1 for testing)
3753 AC_ARG_WITH($1,
3754         [$2],
3755         [AC_DEFINE($3)ifelse([$4],,[
3756          $4
3757 ])
3758         : ${with_cflags:=-g}
3759         : ${with_no_leaks:=yes}
3760          with_$1=yes],
3761         [with_$1=])
3762 AC_MSG_RESULT(${with_$1:-no})
3763
3764 case .$with_cflags in #(vi
3765 .*-g*)
3766         case .$CFLAGS in #(vi
3767         .*-g*) #(vi
3768                 ;;
3769         *)
3770                 CF_ADD_CFLAGS([-g])
3771                 ;;
3772         esac
3773         ;;
3774 esac
3775 ])dnl
3776 dnl ---------------------------------------------------------------------------
3777 dnl CF_NUMBER_SYNTAX version: 1 updated: 2003/09/20 18:12:49
3778 dnl ----------------
3779 dnl Check if the given variable is a number.  If not, report an error.
3780 dnl $1 is the variable
3781 dnl $2 is the message
3782 AC_DEFUN([CF_NUMBER_SYNTAX],[
3783 if test -n "$1" ; then
3784   case $1 in #(vi
3785   [[0-9]]*) #(vi
3786         ;;
3787   *)
3788         AC_MSG_ERROR($2 is not a number: $1)
3789         ;;
3790   esac
3791 else
3792   AC_MSG_ERROR($2 value is empty)
3793 fi
3794 ])dnl
3795 dnl ---------------------------------------------------------------------------
3796 dnl CF_OBJ_SUBDIR version: 4 updated: 2002/02/23 20:38:31
3797 dnl -------------
3798 dnl Compute the object-directory name from the given model name
3799 AC_DEFUN([CF_OBJ_SUBDIR],
3800 [
3801         case $1 in
3802         libtool) $2='obj_lo'  ;;
3803         normal)  $2='objects' ;;
3804         debug)   $2='obj_g' ;;
3805         profile) $2='obj_p' ;;
3806         shared)
3807                 case $cf_cv_system_name in #(vi
3808                 cygwin) #(vi
3809                         $2='objects' ;;
3810                 *)
3811                         $2='obj_s' ;;
3812                 esac
3813         esac
3814 ])dnl
3815 dnl ---------------------------------------------------------------------------
3816 dnl CF_PATHSEP version: 4 updated: 2009/01/11 20:30:23
3817 dnl ----------
3818 dnl Provide a value for the $PATH and similar separator
3819 AC_DEFUN([CF_PATHSEP],
3820 [
3821         case $cf_cv_system_name in
3822         os2*)   PATH_SEPARATOR=';'  ;;
3823         *)      PATH_SEPARATOR=':'  ;;
3824         esac
3825 ifelse($1,,,[$1=$PATH_SEPARATOR])
3826         AC_SUBST(PATH_SEPARATOR)
3827 ])dnl
3828 dnl ---------------------------------------------------------------------------
3829 dnl CF_PATH_SYNTAX version: 12 updated: 2008/03/23 14:45:59
3830 dnl --------------
3831 dnl Check the argument to see that it looks like a pathname.  Rewrite it if it
3832 dnl begins with one of the prefix/exec_prefix variables, and then again if the
3833 dnl result begins with 'NONE'.  This is necessary to work around autoconf's
3834 dnl delayed evaluation of those symbols.
3835 AC_DEFUN([CF_PATH_SYNTAX],[
3836 if test "x$prefix" != xNONE; then
3837   cf_path_syntax="$prefix"
3838 else
3839   cf_path_syntax="$ac_default_prefix"
3840 fi
3841
3842 case ".[$]$1" in #(vi
3843 .\[$]\(*\)*|.\'*\'*) #(vi
3844   ;;
3845 ..|./*|.\\*) #(vi
3846   ;;
3847 .[[a-zA-Z]]:[[\\/]]*) #(vi OS/2 EMX
3848   ;;
3849 .\[$]{*prefix}*) #(vi
3850   eval $1="[$]$1"
3851   case ".[$]$1" in #(vi
3852   .NONE/*)
3853     $1=`echo [$]$1 | sed -e s%NONE%$cf_path_syntax%`
3854     ;;
3855   esac
3856   ;; #(vi
3857 .no|.NONE/*)
3858   $1=`echo [$]$1 | sed -e s%NONE%$cf_path_syntax%`
3859   ;;
3860 *)
3861   ifelse($2,,[AC_MSG_ERROR([expected a pathname, not \"[$]$1\"])],$2)
3862   ;;
3863 esac
3864 ])dnl
3865 dnl ---------------------------------------------------------------------------
3866 dnl CF_PKG_CONFIG version: 3 updated: 2009/01/25 10:55:09
3867 dnl -------------
3868 dnl Check for the package-config program, unless disabled by command-line.
3869 AC_DEFUN([CF_PKG_CONFIG],
3870 [
3871 AC_MSG_CHECKING(if you want to use pkg-config)
3872 AC_ARG_WITH(pkg-config,
3873         [  --with-pkg-config{=path} enable/disable use of pkg-config],
3874         [cf_pkg_config=$withval],
3875         [cf_pkg_config=yes])
3876 AC_MSG_RESULT($cf_pkg_config)
3877
3878 case $cf_pkg_config in #(vi
3879 no) #(vi
3880         PKG_CONFIG=none
3881         ;;
3882 yes) #(vi
3883         AC_PATH_PROG(PKG_CONFIG, pkg-config, none)
3884         ;;
3885 *)
3886         PKG_CONFIG=$withval
3887         ;;
3888 esac
3889
3890 test -z "$PKG_CONFIG" && PKG_CONFIG=none
3891 if test "$PKG_CONFIG" != none ; then
3892         CF_PATH_SYNTAX(PKG_CONFIG)
3893 fi
3894
3895 AC_SUBST(PKG_CONFIG)
3896 ])dnl
3897 dnl ---------------------------------------------------------------------------
3898 dnl CF_POSIX_C_SOURCE version: 6 updated: 2005/07/14 20:25:10
3899 dnl -----------------
3900 dnl Define _POSIX_C_SOURCE to the given level, and _POSIX_SOURCE if needed.
3901 dnl
3902 dnl     POSIX.1-1990                            _POSIX_SOURCE
3903 dnl     POSIX.1-1990 and                        _POSIX_SOURCE and
3904 dnl             POSIX.2-1992 C-Language                 _POSIX_C_SOURCE=2
3905 dnl             Bindings Option
3906 dnl     POSIX.1b-1993                           _POSIX_C_SOURCE=199309L
3907 dnl     POSIX.1c-1996                           _POSIX_C_SOURCE=199506L
3908 dnl     X/Open 2000                             _POSIX_C_SOURCE=200112L
3909 dnl
3910 dnl Parameters:
3911 dnl     $1 is the nominal value for _POSIX_C_SOURCE
3912 AC_DEFUN([CF_POSIX_C_SOURCE],
3913 [
3914 cf_POSIX_C_SOURCE=ifelse($1,,199506L,$1)
3915
3916 cf_save_CFLAGS="$CFLAGS"
3917 cf_save_CPPFLAGS="$CPPFLAGS"
3918
3919 CF_REMOVE_DEFINE(cf_trim_CFLAGS,$cf_save_CFLAGS,_POSIX_C_SOURCE)
3920 CF_REMOVE_DEFINE(cf_trim_CPPFLAGS,$cf_save_CPPFLAGS,_POSIX_C_SOURCE)
3921
3922 AC_CACHE_CHECK(if we should define _POSIX_C_SOURCE,cf_cv_posix_c_source,[
3923         CF_MSG_LOG(if the symbol is already defined go no further)
3924         AC_TRY_COMPILE([#include <sys/types.h>],[
3925 #ifndef _POSIX_C_SOURCE
3926 make an error
3927 #endif],
3928         [cf_cv_posix_c_source=no],
3929         [cf_want_posix_source=no
3930          case .$cf_POSIX_C_SOURCE in #(vi
3931          .[[12]]??*) #(vi
3932                 cf_cv_posix_c_source="-D_POSIX_C_SOURCE=$cf_POSIX_C_SOURCE"
3933                 ;;
3934          .2) #(vi
3935                 cf_cv_posix_c_source="-D_POSIX_C_SOURCE=$cf_POSIX_C_SOURCE"
3936                 cf_want_posix_source=yes
3937                 ;;
3938          .*)
3939                 cf_want_posix_source=yes
3940                 ;;
3941          esac
3942          if test "$cf_want_posix_source" = yes ; then
3943                 AC_TRY_COMPILE([#include <sys/types.h>],[
3944 #ifdef _POSIX_SOURCE
3945 make an error
3946 #endif],[],
3947                 cf_cv_posix_c_source="$cf_cv_posix_c_source -D_POSIX_SOURCE")
3948          fi
3949          CF_MSG_LOG(ifdef from value $cf_POSIX_C_SOURCE)
3950          CFLAGS="$cf_trim_CFLAGS"
3951          CPPFLAGS="$cf_trim_CPPFLAGS $cf_cv_posix_c_source"
3952          CF_MSG_LOG(if the second compile does not leave our definition intact error)
3953          AC_TRY_COMPILE([#include <sys/types.h>],[
3954 #ifndef _POSIX_C_SOURCE
3955 make an error
3956 #endif],,
3957          [cf_cv_posix_c_source=no])
3958          CFLAGS="$cf_save_CFLAGS"
3959          CPPFLAGS="$cf_save_CPPFLAGS"
3960         ])
3961 ])
3962
3963 if test "$cf_cv_posix_c_source" != no ; then
3964         CFLAGS="$cf_trim_CFLAGS"
3965         CPPFLAGS="$cf_trim_CPPFLAGS"
3966         if test "$cf_cv_cc_u_d_options" = yes ; then
3967                 cf_temp_posix_c_source=`echo "$cf_cv_posix_c_source" | \
3968                                 sed -e 's/-D/-U/g' -e 's/=[[^   ]]*//g'`
3969                 CPPFLAGS="$CPPFLAGS $cf_temp_posix_c_source"
3970         fi
3971         CPPFLAGS="$CPPFLAGS $cf_cv_posix_c_source"
3972 fi
3973
3974 ])dnl
3975 dnl ---------------------------------------------------------------------------
3976 dnl CF_PREDEFINE version: 1 updated: 2003/07/26 17:53:56
3977 dnl ------------
3978 dnl Add definitions to CPPFLAGS to ensure they're predefined for all compiles.
3979 dnl
3980 dnl $1 = symbol to test
3981 dnl $2 = value (if any) to use for a predefinition
3982 AC_DEFUN([CF_PREDEFINE],
3983 [
3984 AC_MSG_CHECKING(if we must define $1)
3985 AC_TRY_COMPILE([#include <sys/types.h>
3986 ],[
3987 #ifndef $1
3988 make an error
3989 #endif],[cf_result=no],[cf_result=yes])
3990 AC_MSG_RESULT($cf_result)
3991
3992 if test "$cf_result" = yes ; then
3993         CPPFLAGS="$CPPFLAGS ifelse($2,,-D$1,[-D$1=$2])"
3994 elif test "x$2" != "x" ; then
3995         AC_MSG_CHECKING(checking for compatible value versus $2)
3996         AC_TRY_COMPILE([#include <sys/types.h>
3997 ],[
3998 #if $1-$2 < 0
3999 make an error
4000 #endif],[cf_result=yes],[cf_result=no])
4001         AC_MSG_RESULT($cf_result)
4002         if test "$cf_result" = no ; then
4003                 # perhaps we can override it - try...
4004                 CPPFLAGS="$CPPFLAGS -D$1=$2"
4005         fi
4006 fi
4007 ])dnl
4008 dnl ---------------------------------------------------------------------------
4009 dnl CF_PRG_RULES version: 1 updated: 2006/06/03 11:45:08
4010 dnl ------------
4011 dnl Append definitions and rules for the given programs to the subdirectory
4012 dnl Makefiles, and the recursion rule for the top-level Makefile.
4013 dnl
4014 dnl parameters
4015 dnl     $1 = script to run
4016 dnl     $2 = list of subdirectories
4017 dnl
4018 dnl variables
4019 dnl     $AWK
4020 AC_DEFUN([CF_PRG_RULES],
4021 [
4022 for cf_dir in $2
4023 do
4024         if test ! -d $srcdir/$cf_dir; then
4025                 continue
4026         elif test -f $srcdir/$cf_dir/programs; then
4027                 $AWK -f $1 $srcdir/$cf_dir/programs >>$cf_dir/Makefile
4028         fi
4029 done
4030
4031 ])dnl
4032 dnl ---------------------------------------------------------------------------
4033 dnl CF_PROG_AR version: 1 updated: 2009/01/01 20:15:22
4034 dnl ----------
4035 dnl Check for archiver "ar".
4036 AC_DEFUN([CF_PROG_AR],[
4037 AC_CHECK_TOOL(AR, ar, ar)
4038 ])
4039 dnl ---------------------------------------------------------------------------
4040 dnl CF_PROG_AWK version: 1 updated: 2006/09/16 11:40:59
4041 dnl -----------
4042 dnl Check for awk, ensure that the check found something.
4043 AC_DEFUN([CF_PROG_AWK],
4044 [
4045 AC_PROG_AWK
4046 test -z "$AWK" && AC_MSG_ERROR(No awk program found)
4047 ])dnl
4048 dnl ---------------------------------------------------------------------------
4049 dnl CF_PROG_CC_C_O version: 2 updated: 2006/12/16 15:55:46
4050 dnl --------------
4051 dnl Analogous to AC_PROG_CC_C_O, but more useful: tests only $CC, ensures that
4052 dnl the output file can be renamed, and allows for a shell variable that can
4053 dnl be used later.  The parameter is either CC or CXX.  The result is the
4054 dnl cache variable:
4055 dnl     $cf_cv_prog_CC_c_o
4056 dnl     $cf_cv_prog_CXX_c_o
4057 AC_DEFUN([CF_PROG_CC_C_O],
4058 [AC_REQUIRE([AC_PROG_CC])dnl
4059 AC_MSG_CHECKING([whether [$]$1 understands -c and -o together])
4060 AC_CACHE_VAL(cf_cv_prog_$1_c_o,
4061 [
4062 cat > conftest.$ac_ext <<CF_EOF
4063 #include <stdio.h>
4064 int main()
4065 {
4066         ${cf_cv_main_return:-return}(0);
4067 }
4068 CF_EOF
4069 # We do the test twice because some compilers refuse to overwrite an
4070 # existing .o file with -o, though they will create one.
4071 ac_try='[$]$1 -c conftest.$ac_ext -o conftest2.$ac_objext >&AC_FD_CC'
4072 if AC_TRY_EVAL(ac_try) &&
4073   test -f conftest2.$ac_objext && AC_TRY_EVAL(ac_try);
4074 then
4075   eval cf_cv_prog_$1_c_o=yes
4076 else
4077   eval cf_cv_prog_$1_c_o=no
4078 fi
4079 rm -f conftest*
4080 ])dnl
4081 if test $cf_cv_prog_$1_c_o = yes; then
4082   AC_MSG_RESULT([yes])
4083 else
4084   AC_MSG_RESULT([no])
4085 fi
4086 ])dnl
4087 dnl ---------------------------------------------------------------------------
4088 dnl CF_PROG_CC_U_D version: 1 updated: 2005/07/14 16:59:30
4089 dnl --------------
4090 dnl Check if C (preprocessor) -U and -D options are processed in the order
4091 dnl given rather than by type of option.  Some compilers insist on apply all
4092 dnl of the -U options after all of the -D options.  Others allow mixing them,
4093 dnl and may predefine symbols that conflict with those we define.
4094 AC_DEFUN([CF_PROG_CC_U_D],
4095 [
4096 AC_CACHE_CHECK(if $CC -U and -D options work together,cf_cv_cc_u_d_options,[
4097         cf_save_CPPFLAGS="$CPPFLAGS"
4098         CPPFLAGS="-UU_D_OPTIONS -DU_D_OPTIONS -DD_U_OPTIONS -UD_U_OPTIONS"
4099         AC_TRY_COMPILE([],[
4100 #ifndef U_D_OPTIONS
4101 make an undefined-error
4102 #endif
4103 #ifdef  D_U_OPTIONS
4104 make a defined-error
4105 #endif
4106         ],[
4107         cf_cv_cc_u_d_options=yes],[
4108         cf_cv_cc_u_d_options=no])
4109         CPPFLAGS="$cf_save_CPPFLAGS"
4110 ])
4111 ])dnl
4112 dnl ---------------------------------------------------------------------------
4113 dnl CF_PROG_EGREP version: 1 updated: 2006/09/16 11:40:59
4114 dnl -------------
4115 dnl AC_PROG_EGREP was introduced in autoconf 2.53.
4116 dnl This macro adds a check to ensure the script found something.
4117 AC_DEFUN([CF_PROG_EGREP],
4118 [AC_CACHE_CHECK([for egrep], [ac_cv_prog_egrep],
4119    [if echo a | (grep -E '(a|b)') >/dev/null 2>&1
4120     then ac_cv_prog_egrep='grep -E'
4121     else ac_cv_prog_egrep='egrep'
4122     fi])
4123  EGREP=$ac_cv_prog_egrep
4124  AC_SUBST([EGREP])
4125 test -z "$EGREP" && AC_MSG_ERROR(No egrep program found)
4126 ])dnl
4127 dnl ---------------------------------------------------------------------------
4128 dnl CF_PROG_EXT version: 10 updated: 2004/01/03 19:28:18
4129 dnl -----------
4130 dnl Compute $PROG_EXT, used for non-Unix ports, such as OS/2 EMX.
4131 AC_DEFUN([CF_PROG_EXT],
4132 [
4133 AC_REQUIRE([CF_CHECK_CACHE])
4134 case $cf_cv_system_name in
4135 os2*)
4136     CFLAGS="$CFLAGS -Zmt"
4137     CPPFLAGS="$CPPFLAGS -D__ST_MT_ERRNO__"
4138     CXXFLAGS="$CXXFLAGS -Zmt"
4139     # autoconf's macro sets -Zexe and suffix both, which conflict:w
4140     LDFLAGS="$LDFLAGS -Zmt -Zcrtdll"
4141     ac_cv_exeext=.exe
4142     ;;
4143 esac
4144
4145 AC_EXEEXT
4146 AC_OBJEXT
4147
4148 PROG_EXT="$EXEEXT"
4149 AC_SUBST(PROG_EXT)
4150 test -n "$PROG_EXT" && AC_DEFINE_UNQUOTED(PROG_EXT,"$PROG_EXT")
4151 ])dnl
4152 dnl ---------------------------------------------------------------------------
4153 dnl CF_PROG_INSTALL version: 5 updated: 2002/12/21 22:46:07
4154 dnl ---------------
4155 dnl Force $INSTALL to be an absolute-path.  Otherwise, edit_man.sh and the
4156 dnl misc/tabset install won't work properly.  Usually this happens only when
4157 dnl using the fallback mkinstalldirs script
4158 AC_DEFUN([CF_PROG_INSTALL],
4159 [AC_PROG_INSTALL
4160 case $INSTALL in
4161 /*)
4162   ;;
4163 *)
4164   CF_DIRNAME(cf_dir,$INSTALL)
4165   test -z "$cf_dir" && cf_dir=.
4166   INSTALL=`cd $cf_dir && pwd`/`echo $INSTALL | sed -e 's%^.*/%%'`
4167   ;;
4168 esac
4169 ])dnl
4170 dnl ---------------------------------------------------------------------------
4171 dnl CF_PROG_LDCONFIG version: 2 updated: 2008/12/13 14:08:40
4172 dnl ----------------
4173 dnl Check for ldconfig, needed to fixup shared libraries that would be built
4174 dnl and then used in the install.
4175 AC_DEFUN([CF_PROG_LDCONFIG],[
4176 if test "$cross_compiling" = yes ; then
4177   LDCONFIG=:
4178 else
4179 case "$cf_cv_system_name" in #(vi
4180 dragonfly*|freebsd*) #(vi
4181   test -z "$LDCONFIG" && LDCONFIG="/sbin/ldconfig -R"
4182   ;;
4183 *) LDPATH=$PATH:/sbin:/usr/sbin
4184   AC_PATH_PROG(LDCONFIG,ldconfig,,$LDPATH)
4185   ;;
4186 esac
4187 fi
4188 AC_SUBST(LDCONFIG)
4189 ])dnl
4190 dnl ---------------------------------------------------------------------------
4191 dnl CF_PROG_LINT version: 2 updated: 2009/08/12 04:43:14
4192 dnl ------------
4193 AC_DEFUN([CF_PROG_LINT],
4194 [
4195 AC_CHECK_PROGS(LINT, tdlint lint alint splint lclint)
4196 AC_SUBST(LINT_OPTS)
4197 ])dnl
4198 dnl ---------------------------------------------------------------------------
4199 dnl CF_REGEX version: 3 updated: 1997/11/01 14:26:01
4200 dnl --------
4201 dnl Attempt to determine if we've got one of the flavors of regular-expression
4202 dnl code that we can support.
4203 AC_DEFUN([CF_REGEX],
4204 [
4205 AC_MSG_CHECKING([for regular-expression headers])
4206 AC_CACHE_VAL(cf_cv_regex,[
4207 AC_TRY_LINK([#include <sys/types.h>
4208 #include <regex.h>],[
4209         regex_t *p;
4210         int x = regcomp(p, "", 0);
4211         int y = regexec(p, "", 0, 0, 0);
4212         regfree(p);
4213         ],[cf_cv_regex="regex.h"],[
4214         AC_TRY_LINK([#include <regexp.h>],[
4215                 char *p = compile("", "", "", 0);
4216                 int x = step("", "");
4217         ],[cf_cv_regex="regexp.h"],[
4218                 cf_save_LIBS="$LIBS"
4219                 LIBS="-lgen $LIBS"
4220                 AC_TRY_LINK([#include <regexpr.h>],[
4221                         char *p = compile("", "", "");
4222                         int x = step("", "");
4223                 ],[cf_cv_regex="regexpr.h"],[LIBS="$cf_save_LIBS"])])])
4224 ])
4225 AC_MSG_RESULT($cf_cv_regex)
4226 case $cf_cv_regex in
4227         regex.h)   AC_DEFINE(HAVE_REGEX_H_FUNCS) ;;
4228         regexp.h)  AC_DEFINE(HAVE_REGEXP_H_FUNCS) ;;
4229         regexpr.h) AC_DEFINE(HAVE_REGEXPR_H_FUNCS) ;;
4230 esac
4231 ])dnl
4232 dnl ---------------------------------------------------------------------------
4233 dnl CF_REMOVE_DEFINE version: 2 updated: 2005/07/09 16:12:18
4234 dnl ----------------
4235 dnl Remove all -U and -D options that refer to the given symbol from a list
4236 dnl of C compiler options.  This works around the problem that not all
4237 dnl compilers process -U and -D options from left-to-right, so a -U option
4238 dnl cannot be used to cancel the effect of a preceding -D option.
4239 dnl
4240 dnl $1 = target (which could be the same as the source variable)
4241 dnl $2 = source (including '$')
4242 dnl $3 = symbol to remove
4243 define([CF_REMOVE_DEFINE],
4244 [
4245 # remove $3 symbol from $2
4246 $1=`echo "$2" | \
4247         sed     -e 's/-[[UD]]$3\(=[[^   ]]*\)\?[[       ]]/ /g' \
4248                 -e 's/-[[UD]]$3\(=[[^   ]]*\)\?[$]//g'`
4249 ])dnl
4250 dnl ---------------------------------------------------------------------------
4251 dnl CF_REMOVE_LIB version: 1 updated: 2007/02/17 14:11:52
4252 dnl -------------
4253 dnl Remove the given library from the symbol
4254 dnl
4255 dnl $1 = target (which could be the same as the source variable)
4256 dnl $2 = source (including '$')
4257 dnl $3 = library to remove
4258 define([CF_REMOVE_LIB],
4259 [
4260 # remove $3 library from $2
4261 $1=`echo "$2" | sed -e 's/-l$3[[        ]]//g' -e 's/-l$3[$]//'`
4262 ])dnl
4263 dnl ---------------------------------------------------------------------------
4264 dnl CF_RPATH_HACK version: 4 updated: 2008/09/13 12:53:26
4265 dnl -------------
4266 AC_DEFUN([CF_RPATH_HACK],
4267 [
4268 AC_REQUIRE([CF_SHARED_OPTS])
4269 AC_MSG_CHECKING(for updated LDFLAGS)
4270 if test -n "$LDFLAGS" ; then
4271 AC_MSG_RESULT(maybe)
4272 CF_VERBOSE(...checking LDFLAGS $LDFLAGS)
4273 CF_VERBOSE(...checking EXTRA_LDFLAGS $EXTRA_LDFLAGS)
4274 case "$EXTRA_LDFLAGS" in #(vi
4275 -Wl,-rpath,*) #(vi
4276         cf_rpath_hack="-Wl,-rpath,"
4277         ;;
4278 -R\ *)
4279         cf_rpath_hack="-R "
4280         ;;
4281 -R*)
4282         cf_rpath_hack="-R"
4283         ;;
4284 *)
4285         cf_rpath_hack=
4286         ;;
4287 esac
4288 if test -n "$cf_rpath_hack" ; then
4289         cf_rpath_dst=
4290         for cf_rpath_src in $LDFLAGS
4291         do
4292                 CF_VERBOSE(Filtering $cf_rpath_src)
4293                 case $cf_rpath_src in #(vi
4294                 -L*) #(vi
4295                         if test "$cf_rpath_hack" = "-R " ; then
4296                                 cf_rpath_tmp=`echo "$cf_rpath_src" |sed -e 's%-L%-R %'`
4297                         else
4298                                 cf_rpath_tmp=`echo "$cf_rpath_src" |sed -e s%-L%$cf_rpath_hack%`
4299                         fi
4300                         CF_VERBOSE(...Filter $cf_rpath_tmp)
4301                         EXTRA_LDFLAGS="$cf_rpath_tmp $EXTRA_LDFLAGS"
4302                         ;;
4303                 esac
4304                 cf_rpath_dst="$cf_rpath_dst $cf_rpath_src"
4305         done
4306         LDFLAGS=$cf_rpath_dst
4307         CF_VERBOSE(...checked LDFLAGS $LDFLAGS)
4308         CF_VERBOSE(...checked EXTRA_LDFLAGS $EXTRA_LDFLAGS)
4309 fi
4310 else
4311 AC_MSG_RESULT(no)
4312 fi
4313 ])dnl
4314 dnl ---------------------------------------------------------------------------
4315 dnl CF_SHARED_OPTS version: 57 updated: 2009/01/17 16:10:05
4316 dnl --------------
4317 dnl --------------
4318 dnl Attempt to determine the appropriate CC/LD options for creating a shared
4319 dnl library.
4320 dnl
4321 dnl Note: ${LOCAL_LDFLAGS} is used to link executables that will run within the
4322 dnl build-tree, i.e., by making use of the libraries that are compiled in ../lib
4323 dnl We avoid compiling-in a ../lib path for the shared library since that can
4324 dnl lead to unexpected results at runtime.
4325 dnl ${LOCAL_LDFLAGS2} has the same intention but assumes that the shared libraries
4326 dnl are compiled in ../../lib
4327 dnl
4328 dnl The variable 'cf_cv_do_symlinks' is used to control whether we configure
4329 dnl to install symbolic links to the rel/abi versions of shared libraries.
4330 dnl
4331 dnl The variable 'cf_cv_shlib_version' controls whether we use the rel or abi
4332 dnl version when making symbolic links.
4333 dnl
4334 dnl The variable 'cf_cv_shlib_version_infix' controls whether shared library
4335 dnl version numbers are infix (ex: libncurses.<ver>.dylib) or postfix
4336 dnl (ex: libncurses.so.<ver>).
4337 dnl
4338 dnl Some loaders leave 'so_locations' lying around.  It's nice to clean up.
4339 AC_DEFUN([CF_SHARED_OPTS],
4340 [
4341         AC_REQUIRE([CF_SUBST_NCURSES_VERSION])
4342         LOCAL_LDFLAGS=
4343         LOCAL_LDFLAGS2=
4344         LD_RPATH_OPT=
4345         LD_SHARED_OPTS=
4346         INSTALL_LIB="-m 644"
4347
4348         cf_cv_do_symlinks=no
4349
4350         AC_MSG_CHECKING(if release/abi version should be used for shared libs)
4351         AC_ARG_WITH(shlib-version,
4352         [  --with-shlib-version=X  Specify rel or abi version for shared libs],
4353         [test -z "$withval" && withval=auto
4354         case $withval in #(vi
4355         yes) #(vi
4356                 cf_cv_shlib_version=auto
4357                 ;;
4358         rel|abi|auto|no) #(vi
4359                 cf_cv_shlib_version=$withval
4360                 ;;
4361         *)
4362                 AC_MSG_ERROR([option value must be one of: rel, abi, auto or no])
4363                 ;;
4364         esac
4365         ],[cf_cv_shlib_version=auto])
4366         AC_MSG_RESULT($cf_cv_shlib_version)
4367
4368         cf_cv_rm_so_locs=no
4369
4370         # Some less-capable ports of gcc support only -fpic
4371         CC_SHARED_OPTS=
4372         if test "$GCC" = yes
4373         then
4374                 AC_MSG_CHECKING(which $CC option to use)
4375                 cf_save_CFLAGS="$CFLAGS"
4376                 for CC_SHARED_OPTS in -fPIC -fpic ''
4377                 do
4378                         CFLAGS="$cf_save_CFLAGS $CC_SHARED_OPTS"
4379                         AC_TRY_COMPILE([#include <stdio.h>],[int x = 1],[break],[])
4380                 done
4381                 AC_MSG_RESULT($CC_SHARED_OPTS)
4382                 CFLAGS="$cf_save_CFLAGS"
4383         fi
4384
4385         cf_cv_shlib_version_infix=no
4386
4387         case $cf_cv_system_name in
4388         aix[[56]]*)
4389                 if test "$GCC" = yes; then
4390                         CC_SHARED_OPTS=
4391                         MK_SHARED_LIB="$(CC) -shared"
4392                 fi
4393                 ;;
4394         beos*)
4395                 MK_SHARED_LIB='${CC} ${CFLAGS} -o $[@] -Xlinker -soname=`basename $[@]` -nostart -e 0'
4396                 ;;
4397         cygwin*)
4398                 CC_SHARED_OPTS=
4399                 MK_SHARED_LIB='sh ../mk_shared_lib.sh [$]@ [$]{CC} [$]{CFLAGS}'
4400                 cf_cv_shlib_version=cygdll
4401                 cf_cv_shlib_version_infix=cygdll
4402                 cat >mk_shared_lib.sh <<-CF_EOF
4403                 #!/bin/sh
4404                 SHARED_LIB=\[$]1
4405                 IMPORT_LIB=\`echo "\[$]1" | sed -e 's/cyg/lib/' -e 's/[[0-9]]*\.dll[$]/.dll.a/'\`
4406                 shift
4407                 cat <<-EOF
4408                 Linking shared library
4409                 ** SHARED_LIB \[$]SHARED_LIB
4410                 ** IMPORT_LIB \[$]IMPORT_LIB
4411 EOF
4412                 exec \[$]* -shared -Wl,--out-implib=../lib/\[$]{IMPORT_LIB} -Wl,--export-all-symbols -o ../lib/\[$]{SHARED_LIB}
4413 CF_EOF
4414                 chmod +x mk_shared_lib.sh
4415                 ;;
4416         darwin*)
4417                 EXTRA_CFLAGS="-no-cpp-precomp"
4418                 CC_SHARED_OPTS="-dynamic"
4419                 MK_SHARED_LIB='${CC} ${CFLAGS} -dynamiclib -install_name ${libdir}/`basename $[@]` -compatibility_version ${ABI_VERSION} -current_version ${ABI_VERSION} -o $[@]'
4420                 test "$cf_cv_shlib_version" = auto && cf_cv_shlib_version=abi
4421                 cf_cv_shlib_version_infix=yes
4422                 AC_CACHE_CHECK([if ld -search_paths_first works], cf_cv_ldflags_search_paths_first, [
4423                         cf_save_LDFLAGS=$LDFLAGS
4424                         LDFLAGS="$LDFLAGS -Wl,-search_paths_first"
4425                         AC_TRY_LINK(, [int i;], cf_cv_ldflags_search_paths_first=yes, cf_cv_ldflags_search_paths_first=no)
4426                                 LDFLAGS=$cf_save_LDFLAGS])
4427                 if test $cf_cv_ldflags_search_paths_first = yes; then
4428                         LDFLAGS="$LDFLAGS -Wl,-search_paths_first"
4429                 fi
4430                 ;;
4431         hpux*)
4432                 # (tested with gcc 2.7.2 -- I don't have c89)
4433                 if test "$GCC" = yes; then
4434                         LD_SHARED_OPTS='-Xlinker +b -Xlinker ${libdir}'
4435                 else
4436                         CC_SHARED_OPTS='+Z'
4437                         LD_SHARED_OPTS='-Wl,+b,${libdir}'
4438                 fi
4439                 MK_SHARED_LIB='${LD} +b ${libdir} -b -o $[@]'
4440                 # HP-UX shared libraries must be executable, and should be
4441                 # readonly to exploit a quirk in the memory manager.
4442                 INSTALL_LIB="-m 555"
4443                 ;;
4444         irix*)
4445                 if test "$cf_cv_ld_rpath" = yes ; then
4446                         if test "$GCC" = yes; then
4447                                 LD_RPATH_OPT="-Wl,-rpath,"
4448                                 EXTRA_LDFLAGS="-Wl,-rpath,\${libdir} $EXTRA_LDFLAGS"
4449                         else
4450                                 LD_RPATH_OPT="-rpath "
4451                                 EXTRA_LDFLAGS="-rpath \${libdir} $EXTRA_LDFLAGS"
4452                         fi
4453                 fi
4454                 # tested with IRIX 5.2 and 'cc'.
4455                 if test "$GCC" != yes; then
4456                         CC_SHARED_OPTS='-KPIC'
4457                         MK_SHARED_LIB='${CC} -shared -rdata_shared -soname `basename $[@]` -o $[@]'
4458                 else
4459                         MK_SHARED_LIB='${CC} -shared -Wl,-soname,`basename $[@]` -o $[@]'
4460                 fi
4461                 cf_cv_rm_so_locs=yes
4462                 ;;
4463         linux*|gnu*|k*bsd*-gnu)
4464                 if test "$DFT_LWR_MODEL" = "shared" ; then
4465                         LOCAL_LDFLAGS="-Wl,-rpath,\$(LOCAL_LIBDIR)"
4466                         LOCAL_LDFLAGS2="$LOCAL_LDFLAGS"
4467                 fi
4468                 if test "$cf_cv_ld_rpath" = yes ; then
4469                         LD_RPATH_OPT="-Wl,-rpath,"
4470                         EXTRA_LDFLAGS="-Wl,-rpath,\${libdir} $EXTRA_LDFLAGS"
4471                 fi
4472                 CF_SHARED_SONAME
4473                 MK_SHARED_LIB='${CC} ${CFLAGS} -shared -Wl,-soname,'$cf_cv_shared_soname',-stats,-lc -o $[@]'
4474                 ;;
4475         openbsd[[2-9]].*)
4476                 if test "$DFT_LWR_MODEL" = "shared" ; then
4477                         LOCAL_LDFLAGS="-Wl,-rpath,\$(LOCAL_LIBDIR)"
4478                         LOCAL_LDFLAGS2="$LOCAL_LDFLAGS"
4479                 fi
4480                 if test "$cf_cv_ld_rpath" = yes ; then
4481                         LD_RPATH_OPT="-Wl,-rpath,"
4482                         EXTRA_LDFLAGS="-Wl,-rpath,\${libdir} $EXTRA_LDFLAGS"
4483                 fi
4484                 CC_SHARED_OPTS="$CC_SHARED_OPTS -DPIC"
4485                 CF_SHARED_SONAME
4486                 MK_SHARED_LIB='${CC} ${CFLAGS} -shared -Wl,-Bshareable,-soname,'$cf_cv_shared_soname',-stats,-lc -o $[@]'
4487                 ;;
4488         nto-qnx*|openbsd*|freebsd[[12]].*)
4489                 CC_SHARED_OPTS="$CC_SHARED_OPTS -DPIC"
4490                 MK_SHARED_LIB='${LD} -Bshareable -o $[@]'
4491                 test "$cf_cv_shlib_version" = auto && cf_cv_shlib_version=rel
4492                 ;;
4493         freebsd*)
4494                 CC_SHARED_OPTS="$CC_SHARED_OPTS -DPIC"
4495                 if test "$DFT_LWR_MODEL" = "shared" && test "$cf_cv_ld_rpath" = yes ; then
4496                         LOCAL_LDFLAGS="-rpath \$(LOCAL_LIBDIR)"
4497                         LOCAL_LDFLAGS2="-rpath \${libdir} $LOCAL_LDFLAGS"
4498                         LD_RPATH_OPT="-rpath "
4499                         EXTRA_LDFLAGS="-rpath \${libdir} $EXTRA_LDFLAGS"
4500                 fi
4501                 CF_SHARED_SONAME
4502                 MK_SHARED_LIB='${LD} -shared -Bshareable -soname=`basename $[@]` -o $[@]'
4503                 ;;
4504         netbsd*)
4505                 CC_SHARED_OPTS="$CC_SHARED_OPTS -DPIC"
4506                 test "$cf_cv_ld_rpath" = yes && LD_RPATH_OPT="-Wl,-rpath,"
4507                 if test "$DFT_LWR_MODEL" = "shared" && test "$cf_cv_ld_rpath" = yes ; then
4508                         LOCAL_LDFLAGS="-Wl,-rpath,\$(LOCAL_LIBDIR)"
4509                         LOCAL_LDFLAGS2="$LOCAL_LDFLAGS"
4510                         EXTRA_LDFLAGS="-Wl,-rpath,\${libdir} $EXTRA_LDFLAGS"
4511                         if test "$cf_cv_shlib_version" = auto; then
4512                         if test -f /usr/libexec/ld.elf_so; then
4513                                 cf_cv_shlib_version=abi
4514                         else
4515                                 cf_cv_shlib_version=rel
4516                         fi
4517                         fi
4518                         CF_SHARED_SONAME
4519                         MK_SHARED_LIB='${CC} ${CFLAGS} -shared -Wl,-soname,'$cf_cv_shared_soname' -o $[@]'
4520                 else
4521                         MK_SHARED_LIB='${LD} -shared -Bshareable -o $[@]'
4522                 fi
4523                 ;;
4524         osf*|mls+*)
4525                 # tested with OSF/1 V3.2 and 'cc'
4526                 # tested with OSF/1 V3.2 and gcc 2.6.3 (but the c++ demo didn't
4527                 # link with shared libs).
4528                 MK_SHARED_LIB='${LD} -set_version ${REL_VERSION}:${ABI_VERSION} -expect_unresolved "*" -shared -soname `basename $[@]`'
4529                 case $host_os in
4530                 osf4*)
4531                         MK_SHARED_LIB="${MK_SHARED_LIB} -msym"
4532                         ;;
4533                 esac
4534                 MK_SHARED_LIB="${MK_SHARED_LIB}"' -o $[@]'
4535                 if test "$DFT_LWR_MODEL" = "shared" ; then
4536                         LOCAL_LDFLAGS="-Wl,-rpath,\$(LOCAL_LIBDIR)"
4537                         LOCAL_LDFLAGS2="$LOCAL_LDFLAGS"
4538                 fi
4539                 if test "$cf_cv_ld_rpath" = yes ; then
4540                         LD_RPATH_OPT="-rpath"
4541                         # EXTRA_LDFLAGS="$LOCAL_LDFLAGS $EXTRA_LDFLAGS"
4542                 fi
4543                 cf_cv_rm_so_locs=yes
4544                 ;;
4545         sco3.2v5*)  # (also uw2* and UW7) hops 13-Apr-98
4546                 # tested with osr5.0.5
4547                 if test "$GCC" != yes; then
4548                         CC_SHARED_OPTS='-belf -KPIC'
4549                 fi
4550                 MK_SHARED_LIB='${LD} -dy -G -h `basename $[@] .${REL_VERSION}`.${ABI_VERSION} -o [$]@'
4551                 if test "$cf_cv_ld_rpath" = yes ; then
4552                         # only way is to set LD_RUN_PATH but no switch for it
4553                         RUN_PATH=$libdir
4554                 fi
4555                 test "$cf_cv_shlib_version" = auto && cf_cv_shlib_version=rel
4556                 LINK_PROGS='LD_RUN_PATH=${libdir}'
4557                 LINK_TESTS='Pwd=`pwd`;LD_RUN_PATH=`dirname $${Pwd}`/lib'
4558                 ;;
4559         sunos4*)
4560                 # tested with SunOS 4.1.1 and gcc 2.7.0
4561                 if test "$GCC" != yes; then
4562                         CC_SHARED_OPTS='-KPIC'
4563                 fi
4564                 MK_SHARED_LIB='${LD} -assert pure-text -o $[@]'
4565                 test "$cf_cv_shlib_version" = auto && cf_cv_shlib_version=rel
4566                 ;;
4567         solaris2*)
4568                 # tested with SunOS 5.5.1 (solaris 2.5.1) and gcc 2.7.2
4569                 # tested with SunOS 5.10 (solaris 10) and gcc 3.4.3
4570                 if test "$DFT_LWR_MODEL" = "shared" ; then
4571                         LOCAL_LDFLAGS="-R \$(LOCAL_LIBDIR):\${libdir}"
4572                         LOCAL_LDFLAGS2="$LOCAL_LDFLAGS"
4573                 fi
4574                 if test "$cf_cv_ld_rpath" = yes ; then
4575                         LD_RPATH_OPT="-R"
4576                         EXTRA_LDFLAGS="$LOCAL_LDFLAGS $EXTRA_LDFLAGS"
4577                 fi
4578                 CF_SHARED_SONAME
4579                 if test "$GCC" != yes; then
4580                         cf_save_CFLAGS="$CFLAGS"
4581                         for cf_shared_opts in -xcode=pic13 -xcode=pic32 -Kpic -KPIC -O
4582                         do
4583                                 CFLAGS="$cf_shared_opts $cf_save_CFLAGS"
4584                                 AC_TRY_COMPILE([#include <stdio.h>],[printf("Hello\n");],[break])
4585                         done
4586                         CFLAGS="$cf_save_CFLAGS"
4587                         CC_SHARED_OPTS=$cf_shared_opts
4588                         MK_SHARED_LIB='${CC} -dy -G -h '$cf_cv_shared_soname' -o $[@]'
4589                 else
4590                         MK_SHARED_LIB='${CC} -shared -dy -G -h '$cf_cv_shared_soname' -o $[@]'
4591                 fi
4592                 ;;
4593         sysv5uw7*|unix_sv*)
4594                 # tested with UnixWare 7.1.0 (gcc 2.95.2 and cc)
4595                 if test "$GCC" != yes; then
4596                         CC_SHARED_OPTS='-KPIC'
4597                 fi
4598                 MK_SHARED_LIB='${LD} -d y -G -o [$]@'
4599                 ;;
4600         *)
4601                 CC_SHARED_OPTS='unknown'
4602                 MK_SHARED_LIB='echo unknown'
4603                 ;;
4604         esac
4605
4606         # This works if the last tokens in $MK_SHARED_LIB are the -o target.
4607         case "$cf_cv_shlib_version" in #(vi
4608         rel|abi)
4609                 case "$MK_SHARED_LIB" in #(vi
4610                 *'-o $[@]')
4611                         test "$cf_cv_do_symlinks" = no && cf_cv_do_symlinks=yes
4612                         ;;
4613                 *)
4614                         AC_MSG_WARN(ignored --with-shlib-version)
4615                         ;;
4616                 esac
4617                 ;;
4618         esac
4619
4620         if test -n "$LD_RPATH_OPT" ; then
4621                 AC_MSG_CHECKING(if we need a space after rpath option)
4622                 cf_save_LIBS="$LIBS"
4623                 LIBS="$LIBS ${LD_RPATH_OPT}$libdir"
4624                 AC_TRY_LINK(, , cf_rpath_space=no, cf_rpath_space=yes)
4625                 LIBS="$cf_save_LIBS"
4626                 AC_MSG_RESULT($cf_rpath_space)
4627                 test "$cf_rpath_space" = yes && LD_RPATH_OPT="$LD_RPATH_OPT "
4628                 MK_SHARED_LIB="$MK_SHARED_LIB $LD_RPATH_OPT\${libdir}"
4629         fi
4630
4631         AC_SUBST(CC_SHARED_OPTS)
4632         AC_SUBST(LD_RPATH_OPT)
4633         AC_SUBST(LD_SHARED_OPTS)
4634         AC_SUBST(MK_SHARED_LIB)
4635         AC_SUBST(LINK_PROGS)
4636         AC_SUBST(LINK_TESTS)
4637         AC_SUBST(EXTRA_LDFLAGS)
4638         AC_SUBST(LOCAL_LDFLAGS)
4639         AC_SUBST(LOCAL_LDFLAGS2)
4640         AC_SUBST(INSTALL_LIB)
4641 ])dnl
4642 dnl ---------------------------------------------------------------------------
4643 dnl CF_SHARED_SONAME version: 3 updated: 2008/09/08 18:34:43
4644 dnl ----------------
4645 dnl utility macro for CF_SHARED_OPTS, constructs "$cf_cv_shared_soname" for
4646 dnl substitution into MK_SHARED_LIB string for the "-soname" (or similar)
4647 dnl option.
4648 dnl
4649 dnl $1 is the default that should be used for "$cf_cv_shlib_version".
4650 dnl If missing, use "rel".
4651 define([CF_SHARED_SONAME],
4652 [
4653         test "$cf_cv_shlib_version" = auto && cf_cv_shlib_version=ifelse($1,,rel,$1)
4654         if test "$cf_cv_shlib_version" = rel; then
4655                 cf_cv_shared_soname='`basename $[@] .${REL_VERSION}`.${ABI_VERSION}'
4656         else
4657                 cf_cv_shared_soname='`basename $[@]`'
4658         fi
4659 ])
4660 dnl ---------------------------------------------------------------------------
4661 dnl CF_SIGWINCH version: 1 updated: 2006/04/02 16:41:09
4662 dnl -----------
4663 dnl Use this macro after CF_XOPEN_SOURCE, but do not require it (not all
4664 dnl programs need this test).
4665 dnl
4666 dnl This is really a MacOS X 10.4.3 workaround.  Defining _POSIX_C_SOURCE
4667 dnl forces SIGWINCH to be undefined (breaks xterm, ncurses).  Oddly, the struct
4668 dnl winsize declaration is left alone - we may revisit this if Apple choose to
4669 dnl break that part of the interface as well.
4670 AC_DEFUN([CF_SIGWINCH],
4671 [
4672 AC_CACHE_CHECK(if SIGWINCH is defined,cf_cv_define_sigwinch,[
4673         AC_TRY_COMPILE([
4674 #include <sys/types.h>
4675 #include <sys/signal.h>
4676 ],[int x = SIGWINCH],
4677         [cf_cv_define_sigwinch=yes],
4678         [AC_TRY_COMPILE([
4679 #undef _XOPEN_SOURCE
4680 #undef _POSIX_SOURCE
4681 #undef _POSIX_C_SOURCE
4682 #include <sys/types.h>
4683 #include <sys/signal.h>
4684 ],[int x = SIGWINCH],
4685         [cf_cv_define_sigwinch=maybe],
4686         [cf_cv_define_sigwinch=no])
4687 ])
4688 ])
4689
4690 if test "$cf_cv_define_sigwinch" = maybe ; then
4691 AC_CACHE_CHECK(for actual SIGWINCH definition,cf_cv_fixup_sigwinch,[
4692 cf_cv_fixup_sigwinch=unknown
4693 cf_sigwinch=32
4694 while test $cf_sigwinch != 1
4695 do
4696         AC_TRY_COMPILE([
4697 #undef _XOPEN_SOURCE
4698 #undef _POSIX_SOURCE
4699 #undef _POSIX_C_SOURCE
4700 #include <sys/types.h>
4701 #include <sys/signal.h>
4702 ],[
4703 #if SIGWINCH != $cf_sigwinch
4704 make an error
4705 #endif
4706 int x = SIGWINCH],
4707         [cf_cv_fixup_sigwinch=$cf_sigwinch
4708          break])
4709
4710 cf_sigwinch=`expr $cf_sigwinch - 1`
4711 done
4712 ])
4713
4714         if test "$cf_cv_fixup_sigwinch" != unknown ; then
4715                 CPPFLAGS="$CPPFLAGS -DSIGWINCH=$cf_cv_fixup_sigwinch"
4716         fi
4717 fi
4718 ])dnl
4719 dnl ---------------------------------------------------------------------------
4720 dnl CF_SIG_ATOMIC_T version: 2 updated: 2005/09/18 17:27:12
4721 dnl ---------------
4722 dnl signal handler, but there are some gcc depedencies in that recommendation.
4723 dnl Try anyway.
4724 AC_DEFUN([CF_SIG_ATOMIC_T],
4725 [
4726 AC_MSG_CHECKING(for signal global datatype)
4727 AC_CACHE_VAL(cf_cv_sig_atomic_t,[
4728         for cf_type in \
4729                 "volatile sig_atomic_t" \
4730                 "sig_atomic_t" \
4731                 "int"
4732         do
4733         AC_TRY_COMPILE([
4734 #include <sys/types.h>
4735 #include <signal.h>
4736 #include <stdio.h>
4737
4738 extern $cf_type x;
4739 $cf_type x;
4740 static void handler(int sig)
4741 {
4742         x = 5;
4743 }],
4744                 [signal(SIGINT, handler);
4745                  x = 1],
4746                 [cf_cv_sig_atomic_t=$cf_type],
4747                 [cf_cv_sig_atomic_t=no])
4748                 test "$cf_cv_sig_atomic_t" != no && break
4749         done
4750         ])
4751 AC_MSG_RESULT($cf_cv_sig_atomic_t)
4752 test "$cf_cv_sig_atomic_t" != no && AC_DEFINE_UNQUOTED(SIG_ATOMIC_T, $cf_cv_sig_atomic_t)
4753 ])dnl
4754 dnl ---------------------------------------------------------------------------
4755 dnl CF_SIZECHANGE version: 8 updated: 2000/11/04 12:22:16
4756 dnl -------------
4757 dnl Check for definitions & structures needed for window size-changing
4758 dnl FIXME: check that this works with "snake" (HP-UX 10.x)
4759 AC_DEFUN([CF_SIZECHANGE],
4760 [
4761 AC_REQUIRE([CF_STRUCT_TERMIOS])
4762 AC_CACHE_CHECK(declaration of size-change, cf_cv_sizechange,[
4763     cf_cv_sizechange=unknown
4764     cf_save_CPPFLAGS="$CPPFLAGS"
4765
4766 for cf_opts in "" "NEED_PTEM_H"
4767 do
4768
4769     CPPFLAGS="$cf_save_CPPFLAGS"
4770     test -n "$cf_opts" && CPPFLAGS="$CPPFLAGS -D$cf_opts"
4771     AC_TRY_COMPILE([#include <sys/types.h>
4772 #ifdef HAVE_TERMIOS_H
4773 #include <termios.h>
4774 #else
4775 #ifdef HAVE_TERMIO_H
4776 #include <termio.h>
4777 #endif
4778 #endif
4779 #ifdef NEED_PTEM_H
4780 /* This is a workaround for SCO:  they neglected to define struct winsize in
4781  * termios.h -- it's only in termio.h and ptem.h
4782  */
4783 #include        <sys/stream.h>
4784 #include        <sys/ptem.h>
4785 #endif
4786 #if !defined(sun) || !defined(HAVE_TERMIOS_H)
4787 #include <sys/ioctl.h>
4788 #endif
4789 ],[
4790 #ifdef TIOCGSIZE
4791         struct ttysize win;     /* FIXME: what system is this? */
4792         int y = win.ts_lines;
4793         int x = win.ts_cols;
4794 #else
4795 #ifdef TIOCGWINSZ
4796         struct winsize win;
4797         int y = win.ws_row;
4798         int x = win.ws_col;
4799 #else
4800         no TIOCGSIZE or TIOCGWINSZ
4801 #endif /* TIOCGWINSZ */
4802 #endif /* TIOCGSIZE */
4803         ],
4804         [cf_cv_sizechange=yes],
4805         [cf_cv_sizechange=no])
4806
4807         CPPFLAGS="$cf_save_CPPFLAGS"
4808         if test "$cf_cv_sizechange" = yes ; then
4809                 echo "size-change succeeded ($cf_opts)" >&AC_FD_CC
4810                 test -n "$cf_opts" && cf_cv_sizechange="$cf_opts"
4811                 break
4812         fi
4813 done
4814 ])
4815 if test "$cf_cv_sizechange" != no ; then
4816         AC_DEFINE(HAVE_SIZECHANGE)
4817         case $cf_cv_sizechange in #(vi
4818         NEED*)
4819                 AC_DEFINE_UNQUOTED($cf_cv_sizechange )
4820                 ;;
4821         esac
4822 fi
4823 ])dnl
4824 dnl ---------------------------------------------------------------------------
4825 dnl CF_SRC_MODULES version: 20 updated: 2008/12/27 12:30:03
4826 dnl --------------
4827 dnl For each parameter, test if the source-directory exists, and if it contains
4828 dnl a 'modules' file.  If so, add to the list $cf_cv_src_modules which we'll
4829 dnl use in CF_LIB_RULES.
4830 dnl
4831 dnl This uses the configured value to make the lists SRC_SUBDIRS and
4832 dnl SUB_MAKEFILES which are used in the makefile-generation scheme.
4833 AC_DEFUN([CF_SRC_MODULES],
4834 [
4835 AC_MSG_CHECKING(for src modules)
4836
4837 # dependencies and linker-arguments for test-programs
4838 TEST_DEPS="${LIB_DIR}/${LIB_PREFIX}${LIB_NAME}${DFT_DEP_SUFFIX} $TEST_DEPS"
4839 TEST_DEP2="${LIB_2ND}/${LIB_PREFIX}${LIB_NAME}${DFT_DEP_SUFFIX} $TEST_DEP2"
4840 if test "$DFT_LWR_MODEL" = "libtool"; then
4841         TEST_ARGS="${TEST_DEPS}"
4842         TEST_ARG2="${TEST_DEP2}"
4843 else
4844         TEST_ARGS="-l${LIB_NAME}${DFT_ARG_SUFFIX} $TEST_ARGS"
4845         TEST_ARG2="-l${LIB_NAME}${DFT_ARG_SUFFIX} $TEST_ARG2"
4846 fi
4847
4848 cf_cv_src_modules=
4849 for cf_dir in $1
4850 do
4851         if test -f $srcdir/$cf_dir/modules; then
4852
4853                 # We may/may not have tack in the distribution, though the
4854                 # makefile is.
4855                 if test $cf_dir = tack ; then
4856                         if test ! -f $srcdir/${cf_dir}/${cf_dir}.h; then
4857                                 continue
4858                         fi
4859                 fi
4860
4861                 if test -z "$cf_cv_src_modules"; then
4862                         cf_cv_src_modules=$cf_dir
4863                 else
4864                         cf_cv_src_modules="$cf_cv_src_modules $cf_dir"
4865                 fi
4866
4867                 # Make the ncurses_cfg.h file record the library interface files as
4868                 # well.  These are header files that are the same name as their
4869                 # directory.  Ncurses is the only library that does not follow
4870                 # that pattern.
4871                 if test $cf_dir = tack ; then
4872                         continue
4873                 elif test -f $srcdir/${cf_dir}/${cf_dir}.h; then
4874                         CF_UPPER(cf_have_include,$cf_dir)
4875                         AC_DEFINE_UNQUOTED(HAVE_${cf_have_include}_H)
4876                         AC_DEFINE_UNQUOTED(HAVE_LIB${cf_have_include})
4877                         TEST_DEPS="${LIB_DIR}/${LIB_PREFIX}${cf_dir}${DFT_DEP_SUFFIX} $TEST_DEPS"
4878                         TEST_DEP2="${LIB_2ND}/${LIB_PREFIX}${cf_dir}${DFT_DEP_SUFFIX} $TEST_DEP2"
4879                         if test "$DFT_LWR_MODEL" = "libtool"; then
4880                                 TEST_ARGS="${TEST_DEPS}"
4881                                 TEST_ARG2="${TEST_DEP2}"
4882                         else
4883                                 TEST_ARGS="-l${cf_dir}${DFT_ARG_SUFFIX} $TEST_ARGS"
4884                                 TEST_ARG2="-l${cf_dir}${DFT_ARG_SUFFIX} $TEST_ARG2"
4885                         fi
4886                 fi
4887         fi
4888 done
4889 AC_MSG_RESULT($cf_cv_src_modules)
4890
4891 TEST_ARGS="-L${LIB_DIR} $TEST_ARGS"
4892 TEST_ARG2="-L${LIB_2ND} $TEST_ARG2"
4893
4894 AC_SUBST(TEST_ARGS)
4895 AC_SUBST(TEST_DEPS)
4896
4897 AC_SUBST(TEST_ARG2)
4898 AC_SUBST(TEST_DEP2)
4899
4900 SRC_SUBDIRS=
4901 if test "x$cf_with_manpages" != xno ; then
4902         SRC_SUBDIRS="$SRC_SUBDIRS man"
4903 fi
4904 SRC_SUBDIRS="$SRC_SUBDIRS include"
4905 for cf_dir in $cf_cv_src_modules
4906 do
4907         SRC_SUBDIRS="$SRC_SUBDIRS $cf_dir"
4908 done
4909 SRC_SUBDIRS="$SRC_SUBDIRS test"
4910 test -z "$MAKE_TERMINFO" && SRC_SUBDIRS="$SRC_SUBDIRS misc"
4911 test "$cf_with_cxx_binding" != no && SRC_SUBDIRS="$SRC_SUBDIRS c++"
4912
4913 ADA_SUBDIRS=
4914 if test "$cf_cv_prog_gnat_correct" = yes && test -f $srcdir/Ada95/Makefile.in; then
4915         SRC_SUBDIRS="$SRC_SUBDIRS Ada95"
4916         ADA_SUBDIRS="gen src samples"
4917 fi
4918
4919 SUB_MAKEFILES=
4920 for cf_dir in $SRC_SUBDIRS
4921 do
4922         SUB_MAKEFILES="$SUB_MAKEFILES $cf_dir/Makefile"
4923 done
4924
4925 if test -n "$ADA_SUBDIRS"; then
4926         for cf_dir in $ADA_SUBDIRS
4927         do
4928                 SUB_MAKEFILES="$SUB_MAKEFILES Ada95/$cf_dir/Makefile"
4929         done
4930         AC_SUBST(ADA_SUBDIRS)
4931 fi
4932 ])dnl
4933 dnl ---------------------------------------------------------------------------
4934 dnl CF_STDCPP_LIBRARY version: 5 updated: 2000/08/12 23:18:52
4935 dnl -----------------
4936 dnl Check for -lstdc++, which is GNU's standard C++ library.
4937 AC_DEFUN([CF_STDCPP_LIBRARY],
4938 [
4939 if test -n "$GXX" ; then
4940 case $cf_cv_system_name in #(vi
4941 os2*) #(vi
4942         cf_stdcpp_libname=stdcpp
4943         ;;
4944 *)
4945         cf_stdcpp_libname=stdc++
4946         ;;
4947 esac
4948 AC_CACHE_CHECK(for library $cf_stdcpp_libname,cf_cv_libstdcpp,[
4949         cf_save="$LIBS"
4950         LIBS="$LIBS -l$cf_stdcpp_libname"
4951 AC_TRY_LINK([
4952 #include <strstream.h>],[
4953 char buf[80];
4954 strstreambuf foo(buf, sizeof(buf))
4955 ],
4956         [cf_cv_libstdcpp=yes],
4957         [cf_cv_libstdcpp=no])
4958         LIBS="$cf_save"
4959 ])
4960 test "$cf_cv_libstdcpp" = yes && CXXLIBS="$CXXLIBS -l$cf_stdcpp_libname"
4961 fi
4962 ])dnl
4963 dnl ---------------------------------------------------------------------------
4964 dnl CF_STRIP_G_OPT version: 3 updated: 2002/12/21 19:25:52
4965 dnl --------------
4966 dnl     Remove "-g" option from the compiler options
4967 AC_DEFUN([CF_STRIP_G_OPT],
4968 [$1=`echo ${$1} | sed -e 's%-g %%' -e 's%-g$%%'`])dnl
4969 dnl ---------------------------------------------------------------------------
4970 dnl CF_STRUCT_SIGACTION version: 3 updated: 2000/08/12 23:18:52
4971 dnl -------------------
4972 dnl Check if we need _POSIX_SOURCE defined to use struct sigaction.  We'll only
4973 dnl do this if we've found the sigaction function.
4974 dnl
4975 dnl If needed, define SVR4_ACTION.
4976 AC_DEFUN([CF_STRUCT_SIGACTION],[
4977 if test "$ac_cv_func_sigaction" = yes; then
4978 AC_MSG_CHECKING(whether sigaction needs _POSIX_SOURCE)
4979 AC_TRY_COMPILE([
4980 #include <sys/types.h>
4981 #include <signal.h>],
4982         [struct sigaction act],
4983         [sigact_bad=no],
4984         [
4985 AC_TRY_COMPILE([
4986 #define _POSIX_SOURCE
4987 #include <sys/types.h>
4988 #include <signal.h>],
4989         [struct sigaction act],
4990         [sigact_bad=yes
4991          AC_DEFINE(SVR4_ACTION)],
4992          [sigact_bad=unknown])])
4993 AC_MSG_RESULT($sigact_bad)
4994 fi
4995 ])dnl
4996 dnl ---------------------------------------------------------------------------
4997 dnl CF_STRUCT_TERMIOS version: 5 updated: 2000/11/04 12:22:46
4998 dnl -----------------
4999 dnl Some machines require _POSIX_SOURCE to completely define struct termios.
5000 dnl If so, define SVR4_TERMIO
5001 AC_DEFUN([CF_STRUCT_TERMIOS],[
5002 AC_CHECK_HEADERS( \
5003 termio.h \
5004 termios.h \
5005 unistd.h \
5006 )
5007 if test "$ISC" = yes ; then
5008         AC_CHECK_HEADERS( sys/termio.h )
5009 fi
5010 if test "$ac_cv_header_termios_h" = yes ; then
5011         case "$CFLAGS $CPPFLAGS" in
5012         *-D_POSIX_SOURCE*)
5013                 termios_bad=dunno ;;
5014         *)      termios_bad=maybe ;;
5015         esac
5016         if test "$termios_bad" = maybe ; then
5017         AC_MSG_CHECKING(whether termios.h needs _POSIX_SOURCE)
5018         AC_TRY_COMPILE([#include <termios.h>],
5019                 [struct termios foo; int x = foo.c_iflag],
5020                 termios_bad=no, [
5021                 AC_TRY_COMPILE([
5022 #define _POSIX_SOURCE
5023 #include <termios.h>],
5024                         [struct termios foo; int x = foo.c_iflag],
5025                         termios_bad=unknown,
5026                         termios_bad=yes AC_DEFINE(SVR4_TERMIO))
5027                         ])
5028         AC_MSG_RESULT($termios_bad)
5029         fi
5030 fi
5031 ])dnl
5032 dnl ---------------------------------------------------------------------------
5033 dnl CF_SUBDIR_PATH version: 5 updated: 2007/07/29 09:55:12
5034 dnl --------------
5035 dnl Construct a search-list for a nonstandard header/lib-file
5036 dnl     $1 = the variable to return as result
5037 dnl     $2 = the package name
5038 dnl     $3 = the subdirectory, e.g., bin, include or lib
5039 AC_DEFUN([CF_SUBDIR_PATH],
5040 [$1=""
5041
5042 CF_ADD_SUBDIR_PATH($1,$2,$3,/usr,$prefix)
5043 CF_ADD_SUBDIR_PATH($1,$2,$3,$prefix,NONE)
5044 CF_ADD_SUBDIR_PATH($1,$2,$3,/usr/local,$prefix)
5045 CF_ADD_SUBDIR_PATH($1,$2,$3,/opt,$prefix)
5046 CF_ADD_SUBDIR_PATH($1,$2,$3,[$]HOME,$prefix)
5047 ])dnl
5048 dnl ---------------------------------------------------------------------------
5049 dnl CF_SUBST version: 4 updated: 2006/06/17 12:33:03
5050 dnl --------
5051 dnl     Shorthand macro for substituting things that the user may override
5052 dnl     with an environment variable.
5053 dnl
5054 dnl     $1 = long/descriptive name
5055 dnl     $2 = environment variable
5056 dnl     $3 = default value
5057 AC_DEFUN([CF_SUBST],
5058 [AC_CACHE_VAL(cf_cv_subst_$2,[
5059 AC_MSG_CHECKING(for $1 (symbol $2))
5060 CF_SUBST_IF([-z "[$]$2"], [$2], [$3])
5061 cf_cv_subst_$2=[$]$2
5062 AC_MSG_RESULT([$]$2)
5063 ])
5064 ])dnl
5065 dnl ---------------------------------------------------------------------------
5066 dnl CF_SUBST_IF version: 2 updated: 2006/06/17 12:33:03
5067 dnl -----------
5068 dnl     Shorthand macro for substituting things that the user may override
5069 dnl     with an environment variable.
5070 dnl
5071 dnl     $1 = condition to pass to "test"
5072 dnl     $2 = environment variable
5073 dnl     $3 = value if the test succeeds
5074 dnl     $4 = value if the test fails
5075 AC_DEFUN([CF_SUBST_IF],
5076 [
5077 if test $1 ; then
5078         $2=$3
5079 ifelse($4,,,[else
5080         $2=$4])
5081 fi
5082 AC_SUBST($2)
5083 ])dnl
5084 dnl ---------------------------------------------------------------------------
5085 dnl CF_SUBST_NCURSES_VERSION version: 8 updated: 2006/09/16 11:40:59
5086 dnl ------------------------
5087 dnl Get the version-number for use in shared-library naming, etc.
5088 AC_DEFUN([CF_SUBST_NCURSES_VERSION],
5089 [
5090 AC_REQUIRE([CF_PROG_EGREP])
5091 NCURSES_MAJOR="`$ac_cv_prog_egrep '^NCURSES_MAJOR[[     ]]*=' $srcdir/dist.mk | sed -e 's/^[[^0-9]]*//'`"
5092 NCURSES_MINOR="`$ac_cv_prog_egrep '^NCURSES_MINOR[[     ]]*=' $srcdir/dist.mk | sed -e 's/^[[^0-9]]*//'`"
5093 NCURSES_PATCH="`$ac_cv_prog_egrep '^NCURSES_PATCH[[     ]]*=' $srcdir/dist.mk | sed -e 's/^[[^0-9]]*//'`"
5094 cf_cv_abi_version=${NCURSES_MAJOR}
5095 cf_cv_rel_version=${NCURSES_MAJOR}.${NCURSES_MINOR}
5096 dnl Show the computed version, for logging
5097 cf_cv_timestamp=`date`
5098 AC_MSG_RESULT(Configuring NCURSES $cf_cv_rel_version ABI $cf_cv_abi_version ($cf_cv_timestamp))
5099 dnl We need these values in the generated headers
5100 AC_SUBST(NCURSES_MAJOR)
5101 AC_SUBST(NCURSES_MINOR)
5102 AC_SUBST(NCURSES_PATCH)
5103 dnl We need these values in the generated makefiles
5104 AC_SUBST(cf_cv_rel_version)
5105 AC_SUBST(cf_cv_abi_version)
5106 AC_SUBST(cf_cv_builtin_bool)
5107 AC_SUBST(cf_cv_header_stdbool_h)
5108 AC_SUBST(cf_cv_type_of_bool)dnl
5109 ])dnl
5110 dnl ---------------------------------------------------------------------------
5111 dnl CF_SYS_TIME_SELECT version: 4 updated: 2000/10/04 09:18:40
5112 dnl ------------------
5113 dnl Check if we can include <sys/time.h> with <sys/select.h>; this breaks on
5114 dnl older SCO configurations.
5115 AC_DEFUN([CF_SYS_TIME_SELECT],
5116 [
5117 AC_MSG_CHECKING(if sys/time.h works with sys/select.h)
5118 AC_CACHE_VAL(cf_cv_sys_time_select,[
5119 AC_TRY_COMPILE([
5120 #include <sys/types.h>
5121 #ifdef HAVE_SYS_TIME_H
5122 #include <sys/time.h>
5123 #endif
5124 #ifdef HAVE_SYS_SELECT_H
5125 #include <sys/select.h>
5126 #endif
5127 ],[],[cf_cv_sys_time_select=yes],
5128      [cf_cv_sys_time_select=no])
5129      ])
5130 AC_MSG_RESULT($cf_cv_sys_time_select)
5131 test "$cf_cv_sys_time_select" = yes && AC_DEFINE(HAVE_SYS_TIME_SELECT)
5132 ])dnl
5133 dnl ---------------------------------------------------------------------------
5134 dnl CF_TOP_BUILDDIR version: 1 updated: 2006/10/15 16:33:23
5135 dnl ---------------
5136 dnl Define a top_builddir symbol, for applications that need an absolute path.
5137 AC_DEFUN([CF_TOP_BUILDDIR],
5138 [
5139 top_builddir=`pwd`
5140 AC_SUBST(top_builddir)
5141 ])dnl
5142 dnl ---------------------------------------------------------------------------
5143 dnl CF_TYPEOF_CHTYPE version: 8 updated: 2006/12/16 12:33:30
5144 dnl ----------------
5145 dnl Determine the type we should use for chtype (and attr_t, which is treated
5146 dnl as the same thing).  We want around 32 bits, so on most machines want a
5147 dnl long, but on newer 64-bit machines, probably want an int.  If we're using
5148 dnl wide characters, we have to have a type compatible with that, as well.
5149 AC_DEFUN([CF_TYPEOF_CHTYPE],
5150 [
5151 AC_MSG_CHECKING([for type of chtype])
5152 AC_CACHE_VAL(cf_cv_typeof_chtype,[
5153                 AC_TRY_RUN([
5154 #define WANT_BITS 31
5155 #include <stdio.h>
5156 int main()
5157 {
5158         FILE *fp = fopen("cf_test.out", "w");
5159         if (fp != 0) {
5160                 char *result = "long";
5161                 if (sizeof(unsigned long) > sizeof(unsigned int)) {
5162                         int n;
5163                         unsigned int x, y;
5164                         for (n = 0; n < WANT_BITS; n++) {
5165                                 x = (1 << n);
5166                                 y = (x >> n);
5167                                 if (y != 1 || x == 0) {
5168                                         x = 0;
5169                                         break;
5170                                 }
5171                         }
5172                         /*
5173                          * If x is nonzero, an int is big enough for the bits
5174                          * that we want.
5175                          */
5176                         result = (x != 0) ? "int" : "long";
5177                 }
5178                 fputs(result, fp);
5179                 fclose(fp);
5180         }
5181         ${cf_cv_main_return:-return}(0);
5182 }
5183                 ],
5184                 [cf_cv_typeof_chtype=`cat cf_test.out`],
5185                 [cf_cv_typeof_chtype=long],
5186                 [cf_cv_typeof_chtype=long])
5187                 rm -f cf_test.out
5188         ])
5189 AC_MSG_RESULT($cf_cv_typeof_chtype)
5190
5191 AC_SUBST(cf_cv_typeof_chtype)
5192 AC_DEFINE_UNQUOTED(TYPEOF_CHTYPE,$cf_cv_typeof_chtype)
5193 ])dnl
5194 dnl ---------------------------------------------------------------------------
5195 dnl CF_TYPE_SIGACTION version: 3 updated: 2000/08/12 23:18:52
5196 dnl -----------------
5197 dnl
5198 AC_DEFUN([CF_TYPE_SIGACTION],
5199 [
5200 AC_MSG_CHECKING([for type sigaction_t])
5201 AC_CACHE_VAL(cf_cv_type_sigaction,[
5202         AC_TRY_COMPILE([
5203 #include <signal.h>],
5204                 [sigaction_t x],
5205                 [cf_cv_type_sigaction=yes],
5206                 [cf_cv_type_sigaction=no])])
5207 AC_MSG_RESULT($cf_cv_type_sigaction)
5208 test "$cf_cv_type_sigaction" = yes && AC_DEFINE(HAVE_TYPE_SIGACTION)
5209 ])dnl
5210 dnl ---------------------------------------------------------------------------
5211 dnl CF_UNSIGNED_LITERALS version: 2 updated: 1998/02/07 22:10:16
5212 dnl --------------------
5213 dnl Test if the compiler supports 'U' and 'L' suffixes.  Only old compilers
5214 dnl won't, but they're still there.
5215 AC_DEFUN([CF_UNSIGNED_LITERALS],
5216 [
5217 AC_MSG_CHECKING([if unsigned literals are legal])
5218 AC_CACHE_VAL(cf_cv_unsigned_literals,[
5219         AC_TRY_COMPILE([],[long x = 1L + 1UL + 1U + 1],
5220                 [cf_cv_unsigned_literals=yes],
5221                 [cf_cv_unsigned_literals=no])
5222         ])
5223 AC_MSG_RESULT($cf_cv_unsigned_literals)
5224 ])dnl
5225 dnl ---------------------------------------------------------------------------
5226 dnl CF_UPPER version: 5 updated: 2001/01/29 23:40:59
5227 dnl --------
5228 dnl Make an uppercase version of a variable
5229 dnl $1=uppercase($2)
5230 AC_DEFUN([CF_UPPER],
5231 [
5232 $1=`echo "$2" | sed y%abcdefghijklmnopqrstuvwxyz./-%ABCDEFGHIJKLMNOPQRSTUVWXYZ___%`
5233 ])dnl
5234 dnl ---------------------------------------------------------------------------
5235 dnl CF_UTF8_LIB version: 5 updated: 2008/10/17 19:37:52
5236 dnl -----------
5237 dnl Check for multibyte support, and if not found, utf8 compatibility library
5238 AC_DEFUN([CF_UTF8_LIB],
5239 [
5240 AC_CACHE_CHECK(for multibyte character support,cf_cv_utf8_lib,[
5241         cf_save_LIBS="$LIBS"
5242         AC_TRY_LINK([
5243 #include <stdlib.h>],[putwc(0,0);],
5244         [cf_cv_utf8_lib=yes],
5245         [CF_FIND_LINKAGE([
5246 #include <libutf8.h>],[putwc(0,0);],utf8,
5247                 [cf_cv_utf8_lib=add-on],
5248                 [cf_cv_utf8_lib=no])
5249 ])])
5250
5251 # HAVE_LIBUTF8_H is used by ncurses if curses.h is shared between
5252 # ncurses/ncursesw:
5253 if test "$cf_cv_utf8_lib" = "add-on" ; then
5254         AC_DEFINE(HAVE_LIBUTF8_H)
5255         CF_ADD_INCDIR($cf_cv_header_path_utf8)
5256         CF_ADD_LIBDIR($cf_cv_library_path_utf8)
5257         LIBS="-lutf8 $LIBS"
5258 fi
5259 ])dnl
5260 dnl ---------------------------------------------------------------------------
5261 dnl CF_VERBOSE version: 3 updated: 2007/07/29 09:55:12
5262 dnl ----------
5263 dnl Use AC_VERBOSE w/o the warnings
5264 AC_DEFUN([CF_VERBOSE],
5265 [test -n "$verbose" && echo "   $1" 1>&AC_FD_MSG
5266 CF_MSG_LOG([$1])
5267 ])dnl
5268 dnl ---------------------------------------------------------------------------
5269 dnl CF_WCHAR_TYPE version: 2 updated: 2004/01/17 19:18:20
5270 dnl -------------
5271 dnl Check if type wide-character type $1 is declared, and if so, which header
5272 dnl file is needed.  The second parameter is used to set a shell variable when
5273 dnl the type is not found.  The first parameter sets a shell variable for the
5274 dnl opposite sense.
5275 AC_DEFUN([CF_WCHAR_TYPE],
5276 [
5277 # This is needed on Tru64 5.0 to declare $1
5278 AC_CACHE_CHECK(if we must include wchar.h to declare $1,cf_cv_$1,[
5279 AC_TRY_COMPILE([
5280 #include <stdlib.h>
5281 #include <stdarg.h>
5282 #include <stdio.h>
5283 #ifdef HAVE_LIBUTF8_H
5284 #include <libutf8.h>
5285 #endif],
5286         [$1 state],
5287         [cf_cv_$1=no],
5288         [AC_TRY_COMPILE([
5289 #include <stdlib.h>
5290 #include <stdarg.h>
5291 #include <stdio.h>
5292 #include <wchar.h>
5293 #ifdef HAVE_LIBUTF8_H
5294 #include <libutf8.h>
5295 #endif],
5296         [$1 value],
5297         [cf_cv_$1=yes],
5298         [cf_cv_$1=unknown])])])
5299
5300 if test "$cf_cv_$1" = yes ; then
5301         AC_DEFINE(NEED_WCHAR_H)
5302         NEED_WCHAR_H=1
5303 fi
5304
5305 ifelse($2,,,[
5306 # if we do not find $1 in either place, use substitution to provide a fallback.
5307 if test "$cf_cv_$1" = unknown ; then
5308         $2=1
5309 fi
5310 ])
5311 ifelse($3,,,[
5312 # if we find $1 in either place, use substitution to provide a fallback.
5313 if test "$cf_cv_$1" != unknown ; then
5314         $3=1
5315 fi
5316 ])
5317 ])dnl
5318 dnl ---------------------------------------------------------------------------
5319 dnl CF_WEAK_SYMBOLS version: 1 updated: 2008/08/16 19:18:06
5320 dnl ---------------
5321 dnl Check for compiler-support for weak symbols.
5322 dnl This works with "recent" gcc.
5323 AC_DEFUN([CF_WEAK_SYMBOLS],[
5324 AC_CACHE_CHECK(if $CC supports weak symbols,cf_cv_weak_symbols,[
5325
5326 AC_TRY_COMPILE([
5327 #include <stdio.h>],
5328 [
5329 #if defined(__GNUC__)
5330 #  if defined __USE_ISOC99
5331 #    define _cat_pragma(exp)    _Pragma(#exp)
5332 #    define _weak_pragma(exp)   _cat_pragma(weak name)
5333 #  else
5334 #    define _weak_pragma(exp)
5335 #  endif
5336 #  define _declare(name)        __extension__ extern __typeof__(name) name
5337 #  define weak_symbol(name)     _weak_pragma(name) _declare(name) __attribute__((weak))
5338 #endif
5339
5340 weak_symbol(fopen);
5341 ],[cf_cv_weak_symbols=yes],[cf_cv_weak_symbols=no])
5342 ])
5343 ])dnl
5344 dnl ---------------------------------------------------------------------------
5345 dnl CF_WITH_ABI_VERSION version: 1 updated: 2003/09/20 18:12:49
5346 dnl -------------------
5347 dnl Allow library's ABI to be overridden.  Generally this happens when a
5348 dnl packager has incremented the ABI past that used in the original package,
5349 dnl and wishes to keep doing this.
5350 dnl
5351 dnl $1 is the package name, if any, to derive a corresponding {package}_ABI
5352 dnl symbol.
5353 AC_DEFUN([CF_WITH_ABI_VERSION],[
5354 test -z "$cf_cv_abi_version" && cf_cv_abi_version=0
5355 AC_ARG_WITH(abi-version,
5356 [  --with-abi-version=XXX  override derived ABI version],
5357 [AC_MSG_WARN(overriding ABI version $cf_cv_abi_version to $withval)
5358  cf_cv_abi_version=$withval])
5359  CF_NUMBER_SYNTAX($cf_cv_abi_version,ABI version)
5360 ifelse($1,,,[
5361 $1_ABI=$cf_cv_abi_version
5362 ])
5363 ])dnl
5364 dnl ---------------------------------------------------------------------------
5365 dnl CF_WITH_DBMALLOC version: 6 updated: 2006/12/16 14:24:05
5366 dnl ----------------
5367 dnl Configure-option for dbmalloc.  The optional parameter is used to override
5368 dnl the updating of $LIBS, e.g., to avoid conflict with subsequent tests.
5369 AC_DEFUN([CF_WITH_DBMALLOC],[
5370 CF_NO_LEAKS_OPTION(dbmalloc,
5371         [  --with-dbmalloc         test: use Conor Cahill's dbmalloc library],
5372         [USE_DBMALLOC])
5373
5374 if test "$with_dbmalloc" = yes ; then
5375         AC_CHECK_HEADER(dbmalloc.h,
5376                 [AC_CHECK_LIB(dbmalloc,[debug_malloc]ifelse($1,,[],[,$1]))])
5377 fi
5378 ])dnl
5379 dnl ---------------------------------------------------------------------------
5380 dnl CF_WITH_DMALLOC version: 6 updated: 2006/12/16 14:24:05
5381 dnl ---------------
5382 dnl Configure-option for dmalloc.  The optional parameter is used to override
5383 dnl the updating of $LIBS, e.g., to avoid conflict with subsequent tests.
5384 AC_DEFUN([CF_WITH_DMALLOC],[
5385 CF_NO_LEAKS_OPTION(dmalloc,
5386         [  --with-dmalloc          test: use Gray Watson's dmalloc library],
5387         [USE_DMALLOC])
5388
5389 if test "$with_dmalloc" = yes ; then
5390         AC_CHECK_HEADER(dmalloc.h,
5391                 [AC_CHECK_LIB(dmalloc,[dmalloc_debug]ifelse($1,,[],[,$1]))])
5392 fi
5393 ])dnl
5394 dnl ---------------------------------------------------------------------------
5395 dnl CF_WITH_GPM version: 7 updated: 2008/03/23 14:48:54
5396 dnl -----------
5397 dnl
5398 dnl The option parameter (if neither yes/no) is assumed to be the name of
5399 dnl the gpm library, e.g., for dynamic loading.
5400 AC_DEFUN([CF_WITH_GPM],
5401 [
5402 AC_MSG_CHECKING(if you want to link with the GPM mouse library)
5403 AC_ARG_WITH(gpm,
5404         [  --with-gpm              use Alessandro Rubini's GPM library],
5405         [with_gpm=$withval],
5406         [with_gpm=maybe])
5407 AC_MSG_RESULT($with_gpm)
5408
5409 if test "$with_gpm" != no ; then
5410         AC_CHECK_HEADER(gpm.h,[
5411                 AC_DEFINE(HAVE_GPM_H)
5412                 if test "$with_gpm" != yes && test "$with_gpm" != maybe ; then
5413                         CF_VERBOSE(assuming we really have GPM library)
5414                         AC_DEFINE(HAVE_LIBGPM)
5415                 else
5416                         AC_CHECK_LIB(gpm,Gpm_Open,[:],[
5417                                 AC_MSG_ERROR(Cannot link with GPM library)
5418                 fi
5419                 with_gpm=yes
5420                 ])
5421         ],[
5422                 test "$with_gpm" != maybe && AC_MSG_WARN(Cannot find GPM header)
5423                 with_gpm=no
5424         ])
5425 fi
5426 ])
5427 dnl ---------------------------------------------------------------------------
5428 dnl CF_WITH_LIBTOOL version: 23 updated: 2009/03/28 14:26:27
5429 dnl ---------------
5430 dnl Provide a configure option to incorporate libtool.  Define several useful
5431 dnl symbols for the makefile rules.
5432 dnl
5433 dnl The reference to AC_PROG_LIBTOOL does not normally work, since it uses
5434 dnl macros from libtool.m4 which is in the aclocal directory of automake.
5435 dnl Following is a simple script which turns on the AC_PROG_LIBTOOL macro.
5436 dnl But that still does not work properly since the macro is expanded outside
5437 dnl the CF_WITH_LIBTOOL macro:
5438 dnl
5439 dnl     #!/bin/sh
5440 dnl     ACLOCAL=`aclocal --print-ac-dir`
5441 dnl     if test -z "$ACLOCAL" ; then
5442 dnl             echo cannot find aclocal directory
5443 dnl             exit 1
5444 dnl     elif test ! -f $ACLOCAL/libtool.m4 ; then
5445 dnl             echo cannot find libtool.m4 file
5446 dnl             exit 1
5447 dnl     fi
5448 dnl
5449 dnl     LOCAL=aclocal.m4
5450 dnl     ORIG=aclocal.m4.orig
5451 dnl
5452 dnl     trap "mv $ORIG $LOCAL" 0 1 2 5 15
5453 dnl     rm -f $ORIG
5454 dnl     mv $LOCAL $ORIG
5455 dnl
5456 dnl     # sed the LIBTOOL= assignment to omit the current directory?
5457 dnl     sed -e 's/^LIBTOOL=.*/LIBTOOL=${LIBTOOL-libtool}/' $ACLOCAL/libtool.m4 >>$LOCAL
5458 dnl     cat $ORIG >>$LOCAL
5459 dnl
5460 dnl     autoconf-257 $*
5461 dnl
5462 AC_DEFUN([CF_WITH_LIBTOOL],
5463 [
5464 ifdef([AC_PROG_LIBTOOL],,[
5465 LIBTOOL=
5466 ])
5467 # common library maintenance symbols that are convenient for libtool scripts:
5468 LIB_CREATE='${AR} -cr'
5469 LIB_OBJECT='${OBJECTS}'
5470 LIB_SUFFIX=.a
5471 LIB_PREP="$RANLIB"
5472
5473 # symbols used to prop libtool up to enable it to determine what it should be
5474 # doing:
5475 LIB_CLEAN=
5476 LIB_COMPILE=
5477 LIB_LINK='${CC}'
5478 LIB_INSTALL=
5479 LIB_UNINSTALL=
5480
5481 AC_MSG_CHECKING(if you want to build libraries with libtool)
5482 AC_ARG_WITH(libtool,
5483         [  --with-libtool          generate libraries with libtool],
5484         [with_libtool=$withval],
5485         [with_libtool=no])
5486 AC_MSG_RESULT($with_libtool)
5487 if test "$with_libtool" != "no"; then
5488 ifdef([AC_PROG_LIBTOOL],[
5489         # missing_content_AC_PROG_LIBTOOL{{
5490         AC_PROG_LIBTOOL
5491         # missing_content_AC_PROG_LIBTOOL}}
5492 ],[
5493         if test "$with_libtool" != "yes" ; then
5494                 CF_PATH_SYNTAX(with_libtool)
5495                 LIBTOOL=$with_libtool
5496         else
5497                 AC_PATH_PROG(LIBTOOL,libtool)
5498         fi
5499         if test -z "$LIBTOOL" ; then
5500                 AC_MSG_ERROR(Cannot find libtool)
5501         fi
5502 ])dnl
5503         LIB_CREATE='${LIBTOOL} --mode=link ${CC} -rpath ${DESTDIR}${libdir} -version-info `cut -f1 ${srcdir}/VERSION` ${LIBTOOL_OPTS} ${LT_UNDEF} -o'
5504         LIB_OBJECT='${OBJECTS:.o=.lo}'
5505         LIB_SUFFIX=.la
5506         LIB_CLEAN='${LIBTOOL} --mode=clean'
5507         LIB_COMPILE='${LIBTOOL} --mode=compile'
5508         LIB_LINK='${LIBTOOL} --mode=link ${CC} ${LIBTOOL_OPTS}'
5509         LIB_INSTALL='${LIBTOOL} --mode=install'
5510         LIB_UNINSTALL='${LIBTOOL} --mode=uninstall'
5511         LIB_PREP=:
5512
5513         # Show the version of libtool
5514         AC_MSG_CHECKING(version of libtool)
5515
5516         # Save the version in a cache variable - this is not entirely a good
5517         # thing, but the version string from libtool is very ugly, and for
5518         # bug reports it might be useful to have the original string. "("
5519         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.]].*//'`
5520         AC_MSG_RESULT($cf_cv_libtool_version)
5521         if test -z "$cf_cv_libtool_version" ; then
5522                 AC_MSG_ERROR(This is not GNU libtool)
5523         fi
5524
5525         # special hack to add -no-undefined (which libtool should do for itself)
5526         LT_UNDEF=
5527         case "$cf_cv_system_name" in #(vi
5528         cygwin*|mingw32*|uwin*|aix[[456]]) #(vi
5529                 LT_UNDEF=-no-undefined
5530                 ;;
5531         esac
5532         AC_SUBST([LT_UNDEF])
5533
5534         # special hack to add --tag option for C++ compiler
5535         case $cf_cv_libtool_version in #(vi
5536         1.[[5-9]]*|[[2-9]].[[0-9.a-z]]*) #(vi
5537                 LIBTOOL_CXX="$LIBTOOL --tag=CXX"
5538                 LIBTOOL="$LIBTOOL --tag=CC"
5539                 ;;
5540         *)
5541                 LIBTOOL_CXX="$LIBTOOL"
5542                 ;;
5543         esac
5544 else
5545         LIBTOOL=""
5546         LIBTOOL_CXX=""
5547 fi
5548
5549 test -z "$LIBTOOL" && ECHO_LT=
5550
5551 AC_SUBST(LIBTOOL)
5552 AC_SUBST(LIBTOOL_CXX)
5553 AC_SUBST(LIBTOOL_OPTS)
5554
5555 AC_SUBST(LIB_CREATE)
5556 AC_SUBST(LIB_OBJECT)
5557 AC_SUBST(LIB_SUFFIX)
5558 AC_SUBST(LIB_PREP)
5559
5560 AC_SUBST(LIB_CLEAN)
5561 AC_SUBST(LIB_COMPILE)
5562 AC_SUBST(LIB_LINK)
5563 AC_SUBST(LIB_INSTALL)
5564 AC_SUBST(LIB_UNINSTALL)
5565
5566 ])dnl
5567 dnl ---------------------------------------------------------------------------
5568 dnl CF_WITH_PATH version: 8 updated: 2007/05/13 13:16:35
5569 dnl ------------
5570 dnl Wrapper for AC_ARG_WITH to ensure that user supplies a pathname, not just
5571 dnl defaulting to yes/no.
5572 dnl
5573 dnl $1 = option name
5574 dnl $2 = help-text
5575 dnl $3 = environment variable to set
5576 dnl $4 = default value, shown in the help-message, must be a constant
5577 dnl $5 = default value, if it's an expression & cannot be in the help-message
5578 dnl
5579 AC_DEFUN([CF_WITH_PATH],
5580 [AC_ARG_WITH($1,[$2 ](default: ifelse($4,,empty,$4)),,
5581 ifelse($4,,[withval="${$3}"],[withval="${$3-ifelse($5,,$4,$5)}"]))dnl
5582 if ifelse($5,,true,[test -n "$5"]) ; then
5583 CF_PATH_SYNTAX(withval)
5584 fi
5585 $3="$withval"
5586 AC_SUBST($3)dnl
5587 ])dnl
5588 dnl ---------------------------------------------------------------------------
5589 dnl CF_WITH_PATHLIST version: 6 updated: 2009/01/11 20:30:23
5590 dnl ----------------
5591 dnl Process an option specifying a list of colon-separated paths.
5592 dnl
5593 dnl $1 = option name
5594 dnl $2 = help-text
5595 dnl $3 = environment variable to set
5596 dnl $4 = default value, shown in the help-message, must be a constant
5597 dnl $5 = default value, if it's an expression & cannot be in the help-message
5598 dnl $6 = flag to tell if we want to define or substitute
5599 dnl
5600 AC_DEFUN([CF_WITH_PATHLIST],[
5601 AC_REQUIRE([CF_PATHSEP])
5602 AC_ARG_WITH($1,[$2 ](default: ifelse($4,,empty,$4)),,
5603 ifelse($4,,[withval=${$3}],[withval=${$3-ifelse($5,,$4,$5)}]))dnl
5604
5605 IFS="${IFS=     }"; ac_save_ifs="$IFS"; IFS="${PATH_SEPARATOR}"
5606 cf_dst_path=
5607 for cf_src_path in $withval
5608 do
5609   CF_PATH_SYNTAX(cf_src_path)
5610   test -n "$cf_dst_path" && cf_dst_path="${cf_dst_path}:"
5611   cf_dst_path="${cf_dst_path}${cf_src_path}"
5612 done
5613 IFS="$ac_save_ifs"
5614
5615 ifelse($6,define,[
5616 # Strip single quotes from the value, e.g., when it was supplied as a literal
5617 # for $4 or $5.
5618 case $cf_dst_path in #(vi
5619 \'*)
5620   cf_dst_path=`echo $cf_dst_path |sed -e s/\'// -e s/\'\$//`
5621   ;;
5622 esac
5623 cf_dst_path=`echo "$cf_dst_path" | sed -e 's/\\\\/\\\\\\\\/g'`
5624 ])
5625
5626 eval '$3="$cf_dst_path"'
5627 AC_SUBST($3)dnl
5628
5629 ])dnl
5630 dnl ---------------------------------------------------------------------------
5631 dnl CF_WITH_PTHREAD version: 2 updated: 2008/08/23 18:26:05
5632 dnl ---------------
5633 dnl Check for POSIX thread library.
5634 AC_DEFUN([CF_WITH_PTHREAD],
5635 [
5636 AC_MSG_CHECKING(if you want to link with the pthread library)
5637 AC_ARG_WITH(pthread,
5638     [  --with-pthread          use POSIX thread library],
5639     [with_pthread=$withval],
5640     [with_pthread=no])
5641 AC_MSG_RESULT($with_pthread)
5642
5643 if test "$with_pthread" != no ; then
5644     AC_CHECK_HEADER(pthread.h,[
5645         AC_DEFINE(HAVE_PTHREADS_H)
5646
5647         AC_MSG_CHECKING(if we can link with the pthread library)
5648         cf_save_LIBS="$LIBS"
5649         LIBS="-lpthread $LIBS"
5650         AC_TRY_LINK([
5651 #include <pthread.h>
5652 ],[
5653         int rc = pthread_create(0,0,0,0);
5654 ],[with_pthread=yes],[with_pthread=no])
5655         LIBS="$cf_save_LIBS"
5656         AC_MSG_RESULT($with_pthread)
5657
5658         if test "$with_pthread" = yes ; then
5659             LIBS="-lpthread $LIBS"
5660             AC_DEFINE(HAVE_LIBPTHREADS)
5661         else
5662             AC_MSG_ERROR(Cannot link with pthread library)
5663         fi
5664     ])
5665 fi
5666 ])
5667 dnl ---------------------------------------------------------------------------
5668 dnl CF_WITH_REL_VERSION version: 1 updated: 2003/09/20 18:12:49
5669 dnl -------------------
5670 dnl Allow library's release-version to be overridden.  Generally this happens when a
5671 dnl packager has incremented the release-version past that used in the original package,
5672 dnl and wishes to keep doing this.
5673 dnl
5674 dnl $1 is the package name, if any, to derive corresponding {package}_MAJOR
5675 dnl and {package}_MINOR symbols
5676 dnl symbol.
5677 AC_DEFUN([CF_WITH_REL_VERSION],[
5678 test -z "$cf_cv_rel_version" && cf_cv_rel_version=0.0
5679 AC_ARG_WITH(rel-version,
5680 [  --with-rel-version=XXX  override derived release version],
5681 [AC_MSG_WARN(overriding release version $cf_cv_rel_version to $withval)
5682  cf_cv_rel_version=$withval])
5683 ifelse($1,,[
5684  CF_NUMBER_SYNTAX($cf_cv_rel_version,Release version)
5685 ],[
5686  $1_MAJOR=`echo "$cf_cv_rel_version" | sed -e 's/\..*//'`
5687  $1_MINOR=`echo "$cf_cv_rel_version" | sed -e 's/^[[^.]]*//' -e 's/^\.//' -e 's/\..*//'`
5688  CF_NUMBER_SYNTAX([$]$1_MAJOR,Release major-version)
5689  CF_NUMBER_SYNTAX([$]$1_MINOR,Release minor-version)
5690 ])
5691 ])dnl
5692 dnl ---------------------------------------------------------------------------
5693 dnl CF_WITH_SYSMOUSE version: 2 updated: 2003/03/22 19:13:43
5694 dnl ----------------
5695 dnl If we can compile with sysmouse, make it available unless it is not wanted.
5696 AC_DEFUN([CF_WITH_SYSMOUSE],[
5697 # not everyone has "test -c"
5698 if test -c /dev/sysmouse 2>/dev/null ; then
5699 AC_MSG_CHECKING(if you want to use sysmouse)
5700 AC_ARG_WITH(sysmouse,
5701         [  --with-sysmouse         use sysmouse (FreeBSD console)],
5702         [cf_with_sysmouse=$withval],
5703         [cf_with_sysmouse=maybe])
5704         if test "$cf_with_sysmouse" != no ; then
5705         AC_TRY_COMPILE([
5706 #include <osreldate.h>
5707 #if (__FreeBSD_version >= 400017)
5708 #include <sys/consio.h>
5709 #include <sys/fbio.h>
5710 #else
5711 #include <machine/console.h>
5712 #endif
5713 ],[
5714         struct mouse_info the_mouse;
5715         ioctl(0, CONS_MOUSECTL, &the_mouse);
5716 ],[cf_with_sysmouse=yes],[cf_with_sysmouse=no])
5717         fi
5718 AC_MSG_RESULT($cf_with_sysmouse)
5719 test "$cf_with_sysmouse" = yes && AC_DEFINE(USE_SYSMOUSE)
5720 fi
5721 ])dnl
5722 dnl ---------------------------------------------------------------------------
5723 dnl CF_WITH_VALGRIND version: 1 updated: 2006/12/14 18:00:21
5724 dnl ----------------
5725 AC_DEFUN([CF_WITH_VALGRIND],[
5726 CF_NO_LEAKS_OPTION(valgrind,
5727         [  --with-valgrind         test: use valgrind],
5728         [USE_VALGRIND])
5729 ])dnl
5730 dnl ---------------------------------------------------------------------------
5731 dnl CF_XOPEN_SOURCE version: 29 updated: 2009/07/16 21:07:04
5732 dnl ---------------
5733 dnl Try to get _XOPEN_SOURCE defined properly that we can use POSIX functions,
5734 dnl or adapt to the vendor's definitions to get equivalent functionality,
5735 dnl without losing the common non-POSIX features.
5736 dnl
5737 dnl Parameters:
5738 dnl     $1 is the nominal value for _XOPEN_SOURCE
5739 dnl     $2 is the nominal value for _POSIX_C_SOURCE
5740 AC_DEFUN([CF_XOPEN_SOURCE],[
5741
5742 AC_REQUIRE([CF_PROG_CC_U_D])
5743
5744 cf_XOPEN_SOURCE=ifelse($1,,500,$1)
5745 cf_POSIX_C_SOURCE=ifelse($2,,199506L,$2)
5746
5747 case $host_os in #(vi
5748 aix[[456]]*) #(vi
5749         CPPFLAGS="$CPPFLAGS -D_ALL_SOURCE"
5750         ;;
5751 freebsd*|dragonfly*) #(vi
5752         # 5.x headers associate
5753         #       _XOPEN_SOURCE=600 with _POSIX_C_SOURCE=200112L
5754         #       _XOPEN_SOURCE=500 with _POSIX_C_SOURCE=199506L
5755         cf_POSIX_C_SOURCE=200112L
5756         cf_XOPEN_SOURCE=600
5757         CPPFLAGS="$CPPFLAGS -D_BSD_TYPES -D__BSD_VISIBLE -D_POSIX_C_SOURCE=$cf_POSIX_C_SOURCE -D_XOPEN_SOURCE=$cf_XOPEN_SOURCE"
5758         ;;
5759 hpux11*) #(vi
5760         CPPFLAGS="$CPPFLAGS -D_HPUX_SOURCE -D_XOPEN_SOURCE=500"
5761         ;;
5762 hpux*) #(vi
5763         CPPFLAGS="$CPPFLAGS -D_HPUX_SOURCE"
5764         ;;
5765 irix[[56]].*) #(vi
5766         CPPFLAGS="$CPPFLAGS -D_SGI_SOURCE"
5767         ;;
5768 linux*|gnu*|mint*|k*bsd*-gnu) #(vi
5769         CF_GNU_SOURCE
5770         ;;
5771 mirbsd*) #(vi
5772         # setting _XOPEN_SOURCE or _POSIX_SOURCE breaks <arpa/inet.h>
5773         ;;
5774 netbsd*) #(vi
5775         # setting _XOPEN_SOURCE breaks IPv6 for lynx on NetBSD 1.6, breaks xterm, is not needed for ncursesw
5776         ;;
5777 openbsd*) #(vi
5778         # setting _XOPEN_SOURCE breaks xterm on OpenBSD 2.8, is not needed for ncursesw
5779         ;;
5780 osf[[45]]*) #(vi
5781         CPPFLAGS="$CPPFLAGS -D_OSF_SOURCE"
5782         ;;
5783 nto-qnx*) #(vi
5784         CPPFLAGS="$CPPFLAGS -D_QNX_SOURCE"
5785         ;;
5786 sco*) #(vi
5787         # setting _XOPEN_SOURCE breaks Lynx on SCO Unix / OpenServer
5788         ;;
5789 solaris*) #(vi
5790         CPPFLAGS="$CPPFLAGS -D__EXTENSIONS__"
5791         ;;
5792 *)
5793         AC_CACHE_CHECK(if we should define _XOPEN_SOURCE,cf_cv_xopen_source,[
5794         AC_TRY_COMPILE([#include <sys/types.h>],[
5795 #ifndef _XOPEN_SOURCE
5796 make an error
5797 #endif],
5798         [cf_cv_xopen_source=no],
5799         [cf_save="$CPPFLAGS"
5800          CPPFLAGS="$CPPFLAGS -D_XOPEN_SOURCE=$cf_XOPEN_SOURCE"
5801          AC_TRY_COMPILE([#include <sys/types.h>],[
5802 #ifdef _XOPEN_SOURCE
5803 make an error
5804 #endif],
5805         [cf_cv_xopen_source=no],
5806         [cf_cv_xopen_source=$cf_XOPEN_SOURCE])
5807         CPPFLAGS="$cf_save"
5808         ])
5809 ])
5810         if test "$cf_cv_xopen_source" != no ; then
5811                 CF_REMOVE_DEFINE(CFLAGS,$CFLAGS,_XOPEN_SOURCE)
5812                 CF_REMOVE_DEFINE(CPPFLAGS,$CPPFLAGS,_XOPEN_SOURCE)
5813                 test "$cf_cv_cc_u_d_options" = yes && \
5814                         CPPFLAGS="$CPPFLAGS -U_XOPEN_SOURCE"
5815                 CPPFLAGS="$CPPFLAGS -D_XOPEN_SOURCE=$cf_cv_xopen_source"
5816         fi
5817         CF_POSIX_C_SOURCE($cf_POSIX_C_SOURCE)
5818         ;;
5819 esac
5820 ])