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