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