aclocal.m4

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