1 dnl***************************************************************************
2 dnl Copyright (c) 1998-2007,2008 Free Software Foundation, Inc. *
4 dnl Permission is hereby granted, free of charge, to any person obtaining a *
5 dnl copy of this software and associated documentation files (the *
6 dnl "Software"), to deal in the Software without restriction, including *
7 dnl without limitation the rights to use, copy, modify, merge, publish, *
8 dnl distribute, distribute with modifications, sublicense, and/or sell *
9 dnl copies of the Software, and to permit persons to whom the Software is *
10 dnl furnished to do so, subject to the following conditions: *
12 dnl The above copyright notice and this permission notice shall be included *
13 dnl in all copies or substantial portions of the Software. *
15 dnl THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS *
16 dnl OR IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF *
17 dnl MERCHANTABILITY, FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. *
18 dnl IN NO EVENT SHALL THE ABOVE COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, *
19 dnl DAMAGES OR OTHER LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR *
20 dnl OTHERWISE, ARISING FROM, OUT OF OR IN CONNECTION WITH THE SOFTWARE OR *
21 dnl THE USE OR OTHER DEALINGS IN THE SOFTWARE. *
23 dnl Except as contained in this notice, the name(s) of the above copyright *
24 dnl holders shall not be used in advertising or otherwise to promote the *
25 dnl sale, use or other dealings in this Software without prior written *
27 dnl***************************************************************************
29 dnl Author: Thomas E. Dickey 1995-on
31 dnl $Id: aclocal.m4,v 1.450 2008/07/26 21:57:19 tom Exp $
32 dnl Macros used in NCURSES auto-configuration script.
34 dnl These macros are maintained separately from NCURSES. The copyright on
35 dnl this file applies to the aggregation of macros and does not affect use of
36 dnl these macros in other applications.
38 dnl See http://invisible-island.net/autoconf/ for additional information.
40 dnl ---------------------------------------------------------------------------
41 dnl ---------------------------------------------------------------------------
42 dnl AM_LANGINFO_CODESET version: 3 updated: 2002/10/27 23:21:42
43 dnl -------------------
44 dnl Inserted as requested by gettext 0.10.40
45 dnl File from /usr/share/aclocal
47 dnl ====================
50 dnl From Bruno Haible.
51 AC_DEFUN([AM_LANGINFO_CODESET],
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)
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).])
64 dnl ---------------------------------------------------------------------------
65 dnl CF_ADA_INCLUDE_DIRS version: 5 updated: 2006/10/14 15:23:15
66 dnl -------------------
67 dnl Construct the list of include-options for the C programs in the Ada95
69 AC_DEFUN([CF_ADA_INCLUDE_DIRS],
71 ACPPFLAGS="-I. -I../../include $ACPPFLAGS"
72 if test "$srcdir" != "."; then
73 ACPPFLAGS="-I\${srcdir}/../../include $ACPPFLAGS"
75 if test "$GCC" != yes; then
76 ACPPFLAGS="$ACPPFLAGS -I\${includedir}"
77 elif test "$includedir" != "/usr/include"; then
78 if test "$includedir" = '${prefix}/include' ; then
79 if test $prefix != /usr ; then
80 ACPPFLAGS="$ACPPFLAGS -I\${includedir}"
83 ACPPFLAGS="$ACPPFLAGS -I\${includedir}"
88 dnl ---------------------------------------------------------------------------
89 dnl CF_ADD_CFLAGS version: 7 updated: 2004/04/25 17:48:30
91 dnl Copy non-preprocessor flags to $CFLAGS, preprocessor flags to $CPPFLAGS
92 dnl The second parameter if given makes this macro verbose.
94 dnl Put any preprocessor definitions that use quoted strings in $EXTRA_CPPFLAGS,
95 dnl to simplify use of $CPPFLAGS in compiler checks, etc., that are easily
96 dnl confused by the quotes (which require backslashes to keep them usable).
97 AC_DEFUN([CF_ADD_CFLAGS],
102 cf_new_extra_cppflags=
104 for cf_add_cflags in $1
106 case $cf_fix_cppflags in
108 case $cf_add_cflags in #(vi
109 -undef|-nostdinc*|-I*|-D*|-U*|-E|-P|-C) #(vi
110 case $cf_add_cflags in
112 cf_tst_cflags=`echo ${cf_add_cflags} |sed -e 's/^-D[[^=]]*='\''\"[[^"]]*//'`
114 test "${cf_add_cflags}" != "${cf_tst_cflags}" \
115 && test -z "${cf_tst_cflags}" \
116 && cf_fix_cppflags=yes
118 if test $cf_fix_cppflags = yes ; then
119 cf_new_extra_cppflags="$cf_new_extra_cppflags $cf_add_cflags"
121 elif test "${cf_tst_cflags}" = "\"'" ; then
122 cf_new_extra_cppflags="$cf_new_extra_cppflags $cf_add_cflags"
128 *$cf_add_cflags) #(vi
131 cf_new_cppflags="$cf_new_cppflags $cf_add_cflags"
136 cf_new_cflags="$cf_new_cflags $cf_add_cflags"
141 cf_new_extra_cppflags="$cf_new_extra_cppflags $cf_add_cflags"
143 cf_tst_cflags=`echo ${cf_add_cflags} |sed -e 's/^[[^"]]*"'\''//'`
145 test "${cf_add_cflags}" != "${cf_tst_cflags}" \
146 && test -z "${cf_tst_cflags}" \
147 && cf_fix_cppflags=no
152 if test -n "$cf_new_cflags" ; then
153 ifelse($2,,,[CF_VERBOSE(add to \$CFLAGS $cf_new_cflags)])
154 CFLAGS="$CFLAGS $cf_new_cflags"
157 if test -n "$cf_new_cppflags" ; then
158 ifelse($2,,,[CF_VERBOSE(add to \$CPPFLAGS $cf_new_cppflags)])
159 CPPFLAGS="$cf_new_cppflags $CPPFLAGS"
162 if test -n "$cf_new_extra_cppflags" ; then
163 ifelse($2,,,[CF_VERBOSE(add to \$EXTRA_CPPFLAGS $cf_new_extra_cppflags)])
164 EXTRA_CPPFLAGS="$cf_new_extra_cppflags $EXTRA_CPPFLAGS"
167 AC_SUBST(EXTRA_CPPFLAGS)
170 dnl ---------------------------------------------------------------------------
171 dnl CF_ADD_INCDIR version: 9 updated: 2008/02/09 13:15:34
173 dnl Add an include-directory to $CPPFLAGS. Don't add /usr/include, since it's
174 dnl redundant. We don't normally need to add -I/usr/local/include for gcc,
175 dnl but old versions (and some misinstalled ones) need that. To make things
176 dnl worse, gcc 3.x may give error messages if -I/usr/local/include is added to
177 dnl the include-path).
178 AC_DEFUN([CF_ADD_INCDIR],
180 if test -n "$1" ; then
181 for cf_add_incdir in $1
183 while test $cf_add_incdir != /usr/include
185 if test -d $cf_add_incdir
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
197 if test "$cf_have_incdir" = no ; then
198 if test "$cf_add_incdir" = /usr/local/include ; then
201 cf_save_CPPFLAGS=$CPPFLAGS
202 CPPFLAGS="$CPPFLAGS -I$cf_add_incdir"
203 AC_TRY_COMPILE([#include <stdio.h>],
206 [cf_have_incdir=yes])
207 CPPFLAGS=$cf_save_CPPFLAGS
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)"
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"
227 dnl ---------------------------------------------------------------------------
228 dnl CF_ADD_LIBDIR version: 6 updated: 2008/02/09 13:15:34
230 dnl Adds to the library-path
232 dnl Some machines have trouble with multiple -L options.
234 dnl $1 is the (list of) directory(s) to add
235 dnl $2 is the optional name of the variable to update (default LDFLAGS)
237 AC_DEFUN([CF_ADD_LIBDIR],
239 if test -n "$1" ; then
240 for cf_add_libdir in $1
242 if test $cf_add_libdir = /usr/lib ; then
244 elif test -d $cf_add_libdir
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
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)"
263 dnl ---------------------------------------------------------------------------
264 dnl CF_ANSI_CC_CHECK version: 9 updated: 2001/12/30 17:53:34
266 dnl This is adapted from the macros 'fp_PROG_CC_STDC' and 'fp_C_PROTOTYPES'
267 dnl in the sharutils 4.2 distribution.
268 AC_DEFUN([CF_ANSI_CC_CHECK],
270 AC_CACHE_CHECK(for ${CC-cc} option to accept ANSI C, cf_cv_ansi_cc,[
272 cf_save_CFLAGS="$CFLAGS"
273 cf_save_CPPFLAGS="$CPPFLAGS"
274 # Don't try gcc -ansi; that turns off useful extensions and
275 # breaks some systems' header files.
277 # Ultrix and OSF/1 -std1
278 # HP-UX -Aa -D_HPUX_SOURCE
280 # UnixWare 1.2 (cannot use -Xc, since ANSI/POSIX clashes)
281 for cf_arg in "-DCC_HAS_PROTOS" \
286 "-Aa -D_HPUX_SOURCE" \
289 CF_ADD_CFLAGS($cf_arg)
292 #ifndef CC_HAS_PROTOS
293 #if !defined(__STDC__) || (__STDC__ != 1)
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])
303 CFLAGS="$cf_save_CFLAGS"
304 CPPFLAGS="$cf_save_CPPFLAGS"
307 if test "$cf_cv_ansi_cc" != "no"; then
308 if test ".$cf_cv_ansi_cc" != ".-DCC_HAS_PROTOS"; then
309 CF_ADD_CFLAGS($cf_cv_ansi_cc)
311 AC_DEFINE(CC_HAS_PROTOS)
315 dnl ---------------------------------------------------------------------------
316 dnl CF_ANSI_CC_REQD version: 4 updated: 2008/03/23 14:48:54
318 dnl For programs that must use an ANSI compiler, obtain compiler options that
319 dnl will make it recognize prototypes. We'll do preprocessor checks in other
320 dnl macros, since tools such as unproto can fake prototypes, but only part of
321 dnl the preprocessor.
322 AC_DEFUN([CF_ANSI_CC_REQD],
323 [AC_REQUIRE([CF_ANSI_CC_CHECK])
324 if test "$cf_cv_ansi_cc" = "no"; then
326 [Your compiler does not appear to recognize prototypes.
327 You 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])
333 dnl ---------------------------------------------------------------------------
334 dnl CF_BOOL_DECL version: 8 updated: 2004/01/30 15:51:18
336 dnl Test if 'bool' is a builtin type in the configured C++ compiler. Some
337 dnl older compilers (e.g., gcc 2.5.8) don't support 'bool' directly; gcc
338 dnl 2.6.3 does, in anticipation of the ANSI C++ standard.
340 dnl Treat the configuration-variable specially here, since we're directly
341 dnl substituting its value (i.e., 1/0).
343 dnl $1 is the shell variable to store the result in, if not $cv_cv_builtin_bool
344 AC_DEFUN([CF_BOOL_DECL],
346 AC_MSG_CHECKING(if we should include stdbool.h)
348 AC_CACHE_VAL(cf_cv_header_stdbool_h,[
349 AC_TRY_COMPILE([],[bool foo = false],
350 [cf_cv_header_stdbool_h=0],
355 ],[bool foo = false],
356 [cf_cv_header_stdbool_h=1],
357 [cf_cv_header_stdbool_h=0])])])
359 if test "$cf_cv_header_stdbool_h" = 1
360 then AC_MSG_RESULT(yes)
361 else AC_MSG_RESULT(no)
364 AC_MSG_CHECKING([for builtin bool type])
366 AC_CACHE_VAL(ifelse($1,,cf_cv_builtin_bool,[$1]),[
369 #include <sys/types.h>
371 [ifelse($1,,cf_cv_builtin_bool,[$1])=1],
372 [ifelse($1,,cf_cv_builtin_bool,[$1])=0])
375 if test "$ifelse($1,,cf_cv_builtin_bool,[$1])" = 1
376 then AC_MSG_RESULT(yes)
377 else AC_MSG_RESULT(no)
380 dnl ---------------------------------------------------------------------------
381 dnl CF_BOOL_SIZE version: 12 updated: 2006/12/16 12:33:30
383 dnl Test for the size of 'bool' in the configured C++ compiler (e.g., a type).
384 dnl Don't bother looking for bool.h, since it's been deprecated.
386 dnl If the current compiler is C rather than C++, we get the bool definition
387 dnl from <stdbool.h>.
388 AC_DEFUN([CF_BOOL_SIZE],
390 AC_MSG_CHECKING([for size of bool])
391 AC_CACHE_VAL(cf_cv_type_of_bool,[
397 #if defined(__cplusplus)
399 #ifdef HAVE_GXX_BUILTIN_H
400 #include <g++/builtin.h>
401 #elif HAVE_GPP_BUILTIN_H
402 #include <gpp/builtin.h>
409 #if $cf_cv_header_stdbool_h
417 FILE *fp = fopen("cf_test.out", "w");
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);
428 ${cf_cv_main_return:-return}(0);
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
435 [cf_cv_type_of_bool=unknown],
436 [cf_cv_type_of_bool=unknown])
439 AC_MSG_RESULT($cf_cv_type_of_bool)
440 if test "$cf_cv_type_of_bool" = unknown ; then
441 case .$NCURSES_BOOL in #(vi
442 .auto|.) NCURSES_BOOL=unsigned;;
444 AC_MSG_WARN(Assuming $NCURSES_BOOL for type of bool)
445 cf_cv_type_of_bool=$NCURSES_BOOL
448 dnl ---------------------------------------------------------------------------
449 dnl CF_BUILD_CC version: 6 updated: 2006/10/14 15:23:15
451 dnl If we're cross-compiling, allow the user to override the tools and their
452 dnl options. The configure script is oriented toward identifying the host
453 dnl compiler, etc., but we need a build compiler to generate parts of the
456 dnl $1 = default for $CPPFLAGS
457 dnl $2 = default for $LIBS
458 AC_DEFUN([CF_BUILD_CC],[
459 AC_REQUIRE([CF_PROG_EXT])
460 if test "$cross_compiling" = yes ; then
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'}
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)
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)
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)
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)
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)
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)
508 # this assumes we're on Unix.
512 : ${BUILD_CC:='${CC}'}
514 if ( test "$BUILD_CC" = "$CC" || test "$BUILD_CC" = '${CC}' ) ; then
515 AC_MSG_ERROR([Cross-build requires two compilers.
516 Use --with-build-cc to specify the native compiler.])
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'}
532 AC_SUBST(BUILD_CFLAGS)
533 AC_SUBST(BUILD_CPPFLAGS)
534 AC_SUBST(BUILD_LDFLAGS)
536 AC_SUBST(BUILD_EXEEXT)
537 AC_SUBST(BUILD_OBJEXT)
539 dnl ---------------------------------------------------------------------------
540 dnl CF_CFG_DEFAULTS version: 7 updated: 2005/09/24 16:15:00
542 dnl Determine the default configuration into which we'll install ncurses. This
543 dnl can be overridden by the user's command-line options. There's two items to
545 dnl 1. the prefix (e.g., /usr)
546 dnl 2. the header files (e.g., /usr/include/ncurses)
547 dnl We'll look for a previous installation of ncurses and use the same defaults.
549 dnl We don't use AC_PREFIX_DEFAULT, because it gets evaluated too soon, and
550 dnl we don't use AC_PREFIX_PROGRAM, because we cannot distinguish ncurses's
551 dnl programs from a vendor's.
552 AC_DEFUN([CF_CFG_DEFAULTS],
554 AC_MSG_CHECKING(for prefix)
555 if 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)
561 *) prefix=$ac_default_prefix
565 AC_MSG_RESULT($prefix)
567 if test "x$prefix" = "xNONE" ; then
568 AC_MSG_CHECKING(for default include-directory)
569 test -n "$verbose" && echo 1>&AC_FD_MSG
572 $includedir/ncurses \
574 $prefix/include/ncurses \
576 /usr/local/include/ncurses \
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
588 test -n "$verbose" && echo " tested $cf_dir" 1>&AC_FD_MSG
590 AC_MSG_RESULT($includedir)
593 dnl ---------------------------------------------------------------------------
594 dnl CF_CGETENT version: 3 updated: 2000/08/12 23:18:52
596 dnl Check if the terminal-capability database functions are available. If not,
597 dnl ncurses has a much-reduced version.
598 AC_DEFUN([CF_CGETENT],[
599 AC_MSG_CHECKING(for terminal-capability database functions)
600 AC_CACHE_VAL(cf_cv_cgetent,[
602 #include <stdlib.h>],[
605 char *db_array = temp;
606 cgetent(&buf, /* int *, */ &db_array, "vt100");
607 cgetcap(buf, "tc", '=');
608 cgetmatch(buf, "tc");
613 AC_MSG_RESULT($cf_cv_cgetent)
614 test "$cf_cv_cgetent" = yes && AC_DEFINE(HAVE_BSD_CGETENT)
616 dnl ---------------------------------------------------------------------------
617 dnl CF_CHECK_CACHE version: 11 updated: 2008/03/23 14:45:59
619 dnl Check if we're accidentally using a cache from a different machine.
620 dnl Derive the system name, as a check for reusing the autoconf cache.
622 dnl If we've packaged config.guess and config.sub, run that (since it does a
623 dnl better job than uname). Normally we'll use AC_CANONICAL_HOST, but allow
624 dnl an extra parameter that we may override, e.g., for AC_CANONICAL_SYSTEM
625 dnl which is useful in cross-compiles.
627 dnl Note: we would use $ac_config_sub, but that is one of the places where
628 dnl autoconf 2.5x broke compatibility with autoconf 2.13
629 AC_DEFUN([CF_CHECK_CACHE],
631 if 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"
635 system_name="`(uname -s -r) 2>/dev/null`"
636 if test -z "$system_name" ; then
637 system_name="`(hostname) 2>/dev/null`"
640 test -n "$system_name" && AC_DEFINE_UNQUOTED(SYSTEM_NAME,"$system_name")
641 AC_CACHE_VAL(cf_cv_system_name,[cf_cv_system_name="$system_name"])
643 test -z "$system_name" && system_name="$cf_cv_system_name"
644 test -n "$cf_cv_system_name" && AC_MSG_RESULT(Configuring for $cf_cv_system_name)
646 if 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.")
651 dnl ---------------------------------------------------------------------------
652 dnl CF_CHECK_ERRNO version: 9 updated: 2001/12/30 18:03:23
654 dnl Check for data that is usually declared in <stdio.h> or <errno.h>, e.g.,
655 dnl the 'errno' variable. Define a DECL_xxx symbol if we must declare it
658 dnl $1 = the name to check
659 AC_DEFUN([CF_CHECK_ERRNO],
661 AC_CACHE_CHECK(if external $1 is declared, cf_cv_dcl_$1,[
667 #include <sys/types.h>
668 #include <errno.h> ],
669 [long x = (long) $1],
674 if test "$cf_cv_dcl_$1" = no ; then
675 CF_UPPER(cf_result,decl_$1)
676 AC_DEFINE_UNQUOTED($cf_result)
679 # It's possible (for near-UNIX clones) that the data doesn't exist
680 CF_CHECK_EXTERN_DATA($1,int)
682 dnl ---------------------------------------------------------------------------
683 dnl CF_CHECK_EXTERN_DATA version: 3 updated: 2001/12/30 18:03:23
684 dnl --------------------
685 dnl Check for existence of external data in the current set of libraries. If
686 dnl we can modify it, it's real enough.
687 dnl $1 = the name to check
689 AC_DEFUN([CF_CHECK_EXTERN_DATA],
691 AC_CACHE_CHECK(if external $1 exists, cf_cv_have_$1,[
701 if test "$cf_cv_have_$1" = yes ; then
702 CF_UPPER(cf_result,have_$1)
703 AC_DEFINE_UNQUOTED($cf_result)
707 dnl ---------------------------------------------------------------------------
708 dnl CF_CHECK_GPM_WGETCH version: 1 updated: 2007/04/28 14:38:06
709 dnl -------------------
710 dnl Check if GPM is already linked with curses. If so - and if the linkage
711 dnl is not "weak" - warn about this because it can create problems linking
712 dnl applications with ncurses.
713 AC_DEFUN([CF_CHECK_GPM_WGETCH],[
714 AC_CHECK_LIB(gpm,Gpm_Wgetch,[
716 AC_CACHE_CHECK(if GPM is weakly bound to curses library, cf_cv_check_gpm_wgetch,[
717 cf_cv_check_gpm_wgetch=unknown
718 if test "$cross_compiling" != yes ; then
720 cat >conftest.$ac_ext <<CF_EOF
725 ${cf_cv_main_return:-return}(0);
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
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
747 if test "$cf_cv_check_gpm_wgetch" != yes ; then
748 AC_MSG_WARN(GPM library is already linked with curses - read the FAQ)
751 dnl ---------------------------------------------------------------------------
752 dnl CF_CPP_PARAM_INIT version: 4 updated: 2001/04/07 22:31:18
753 dnl -----------------
754 dnl Check if the C++ compiler accepts duplicate parameter initialization. This
755 dnl is a late feature for the standard and is not in some recent compilers
757 AC_DEFUN([CF_CPP_PARAM_INIT],
759 if test -n "$CXX"; then
760 AC_CACHE_CHECK(if $CXX accepts parameter initialization,cf_cv_cpp_param_init,[
772 TEST::TEST(int x = 1) // some compilers do not like second initializer
778 [cf_cv_cpp_param_init=yes],
779 [cf_cv_cpp_param_init=no],
780 [cf_cv_cpp_param_init=unknown])
784 test "$cf_cv_cpp_param_init" = yes && AC_DEFINE(CPP_HAS_PARAM_INIT)
786 dnl ---------------------------------------------------------------------------
787 dnl CF_CPP_STATIC_CAST version: 1 updated: 2005/07/23 16:52:43
788 dnl ------------------
789 dnl Check if the C++ compiler accepts static_cast in generics. This appears to
790 dnl not be supported in g++ before 3.0
791 AC_DEFUN([CF_CPP_STATIC_CAST],
793 if test -n "$CXX"; then
795 AC_CACHE_CHECK(if $CXX accepts static_cast,cf_cv_cpp_static_cast,[
803 NCursesPanel(int nlines,
813 template<class T> class NCursesUserPanel : public NCursesPanel
816 NCursesUserPanel (int nlines,
820 const T* p_UserData = static_cast<T*>(0))
821 : NCursesPanel (nlines, ncols, begin_y, begin_x)
824 NCursesUserPanel(const T* p_UserData = static_cast<T*>(0)) : NCursesPanel()
828 virtual ~NCursesUserPanel() {};
831 const char* p_UserData = static_cast<char*>(0)],
832 [cf_cv_cpp_static_cast=yes],
833 [cf_cv_cpp_static_cast=no])
840 test "$cf_cv_cpp_static_cast" = yes && AC_DEFINE(CPP_HAS_STATIC_CAST)
842 dnl ---------------------------------------------------------------------------
843 dnl CF_C_INLINE version: 2 updated: 2007/08/11 14:09:50
845 dnl Check if the C compiler supports "inline".
846 dnl $1 is the name of a shell variable to set if inline is supported
847 dnl $2 is the threshold for gcc 4.x's option controlling maximum inline size
848 AC_DEFUN([CF_C_INLINE],[
851 if test "$ac_cv_c_inline" != no ; then
853 if test "$INTEL_COMPILER" = yes
856 elif test "$GCC" = yes
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
867 if test "$cf_cv_gcc_inline" = yes ; then
868 CF_ADD_CFLAGS([--param max-inline-insns-single=$2])
874 dnl ---------------------------------------------------------------------------
875 dnl CF_DIRNAME version: 4 updated: 2002/12/21 19:25:52
877 dnl "dirname" is not portable, so we fake it with a shell script.
878 AC_DEFUN([CF_DIRNAME],[$1=`echo $2 | sed -e 's%/[[^/]]*$%%'`])dnl
879 dnl ---------------------------------------------------------------------------
880 dnl CF_DIRS_TO_MAKE version: 3 updated: 2002/02/23 20:38:31
882 AC_DEFUN([CF_DIRS_TO_MAKE],
885 for cf_item in $cf_list_models
887 CF_OBJ_SUBDIR($cf_item,cf_subdir)
888 for cf_item2 in $DIRS_TO_MAKE
890 test $cf_item2 = $cf_subdir && break
892 test ".$cf_item2" != ".$cf_subdir" && DIRS_TO_MAKE="$DIRS_TO_MAKE $cf_subdir"
894 for cf_dir in $DIRS_TO_MAKE
896 test ! -d $cf_dir && mkdir $cf_dir
898 AC_SUBST(DIRS_TO_MAKE)
900 dnl ---------------------------------------------------------------------------
901 dnl CF_DISABLE_LEAKS version: 4 updated: 2006/12/16 15:10:42
903 dnl Combine no-leak checks with the libraries or tools that are used for the
905 AC_DEFUN([CF_DISABLE_LEAKS],[
907 AC_REQUIRE([CF_WITH_DMALLOC])
908 AC_REQUIRE([CF_WITH_DBMALLOC])
909 AC_REQUIRE([CF_WITH_VALGRIND])
911 AC_MSG_CHECKING(if you want to perform memory-leak testing)
913 [ --disable-leaks test: free permanent memory, analyze leaks],
915 : ${with_no_leaks:=no})
916 AC_MSG_RESULT($with_no_leaks)
918 if test "$with_no_leaks" = yes ; then
922 dnl ---------------------------------------------------------------------------
923 dnl CF_ERRNO version: 5 updated: 1997/11/30 12:44:39
925 dnl Check if 'errno' is declared in <errno.h>
928 CF_CHECK_ERRNO(errno)
930 dnl ---------------------------------------------------------------------------
931 dnl CF_ETIP_DEFINES version: 3 updated: 2003/03/22 19:13:43
933 dnl Test for conflicting definitions of exception in gcc 2.8.0, etc., between
934 dnl math.h and builtin.h, only for ncurses
935 AC_DEFUN([CF_ETIP_DEFINES],
937 AC_MSG_CHECKING(for special defines needed for etip.h)
938 cf_save_CXXFLAGS="$CXXFLAGS"
940 for cf_math in "" MATH_H
942 for cf_excp in "" MATH_EXCEPTION
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}"
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"
957 AC_MSG_RESULT($cf_result)
958 CXXFLAGS="$cf_save_CXXFLAGS"
960 dnl ---------------------------------------------------------------------------
961 dnl CF_FUNC_DLSYM version: 1 updated: 2004/06/16 20:52:45
963 dnl Test for dlsym() and related functions, as well as libdl.
968 AC_DEFUN([CF_FUNC_DLSYM],[
970 AC_CHECK_FUNC(dlsym,cf_have_dlsym=yes,[
973 AC_CHECK_LIB(dl,dlsym,[
975 cf_have_libdl=yes])])
977 if test "$cf_have_dlsym" = yes ; then
978 test "$cf_have_libdl" = yes && LIBS="-ldl $LIBS"
980 AC_MSG_CHECKING(whether able to link to dl*() functions)
981 AC_TRY_LINK([#include <dlfcn.h>],[
983 if ((obj = dlopen("filename", 0)) != 0) {
984 if (dlsym(obj, "symbolname") == 0) {
988 AC_DEFINE(HAVE_LIBDL)],[
989 AC_MSG_ERROR(Cannot link test program for libdl)])
992 AC_MSG_ERROR(Cannot find dlsym function)
995 dnl ---------------------------------------------------------------------------
996 dnl CF_FUNC_MEMMOVE version: 7 updated: 2006/12/16 12:33:30
998 dnl Check for memmove, or a bcopy that can handle overlapping copy. If neither
999 dnl is found, add our own version of memmove to the list of objects.
1000 AC_DEFUN([CF_FUNC_MEMMOVE],
1002 AC_CHECK_FUNC(memmove,,[
1003 AC_CHECK_FUNC(bcopy,[
1004 AC_CACHE_CHECK(if bcopy does overlapping moves,cf_cv_good_bcopy,[
1007 static char data[] = "abcdefghijklmnopqrstuwwxyz";
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"));
1015 [cf_cv_good_bcopy=yes],
1016 [cf_cv_good_bcopy=no],
1017 [cf_cv_good_bcopy=unknown])
1019 ],[cf_cv_good_bcopy=no])
1020 if test "$cf_cv_good_bcopy" = yes ; then
1021 AC_DEFINE(USE_OK_BCOPY)
1023 AC_DEFINE(USE_MY_MEMMOVE)
1026 dnl ---------------------------------------------------------------------------
1027 dnl CF_FUNC_NANOSLEEP version: 3 updated: 2006/12/16 12:33:30
1028 dnl -----------------
1029 dnl Check for existence of workable nanosleep() function. Some systems, e.g.,
1030 dnl AIX 4.x, provide a non-working version.
1031 AC_DEFUN([CF_FUNC_NANOSLEEP],[
1032 AC_CACHE_CHECK(if nanosleep really works,cf_cv_func_nanosleep,[
1038 #ifdef HAVE_SYS_TIME_H
1039 #include <sys/time.h>
1043 struct timespec ts1, ts2;
1046 ts1.tv_nsec = 750000000;
1050 code = nanosleep(&ts1, &ts2); /* on failure errno is ENOSYS. */
1051 ${cf_cv_main_return:-return}(code != 0);
1054 [cf_cv_func_nanosleep=yes],
1055 [cf_cv_func_nanosleep=no],
1056 [cf_cv_func_nanosleep=unknown])])
1058 test "$cf_cv_func_nanosleep" = "yes" && AC_DEFINE(HAVE_NANOSLEEP)
1060 dnl ---------------------------------------------------------------------------
1061 dnl CF_FUNC_OPENPTY version: 2 updated: 2008/04/12 19:49:01
1063 dnl Check for openpty() function, along with <pty.h> header. It may need the
1064 dnl "util" library as well.
1065 AC_DEFUN([CF_FUNC_OPENPTY],
1067 AC_CHECK_LIB(util,openpty,cf_cv_lib_util=yes,cf_cv_lib_util=no)
1068 AC_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
1074 #include <$cf_header>
1076 int x = openpty((int *)0, (int *)0, (char *)0,
1077 (struct termios *)0, (struct winsize *)0);
1079 cf_cv_func_openpty=$cf_header
1082 cf_cv_func_openpty=no
1085 LIBS="$cf_save_LIBS"
1088 dnl ---------------------------------------------------------------------------
1089 dnl CF_FUNC_POLL version: 4 updated: 2006/12/16 12:33:30
1091 dnl See if the poll function really works. Some platforms have poll(), but
1092 dnl it does not work for terminals or files.
1093 AC_DEFUN([CF_FUNC_POLL],[
1094 AC_CACHE_CHECK(if poll really works,cf_cv_working_poll,[
1100 #include <sys/poll.h>
1103 struct pollfd myfds;
1107 myfds.events = POLLIN;
1109 ret = poll(&myfds, 1, 100);
1110 ${cf_cv_main_return:-return}(ret != 0);
1112 [cf_cv_working_poll=yes],
1113 [cf_cv_working_poll=no],
1114 [cf_cv_working_poll=unknown])])
1115 test "$cf_cv_working_poll" = "yes" && AC_DEFINE(HAVE_WORKING_POLL)
1117 dnl ---------------------------------------------------------------------------
1118 dnl CF_FUNC_TERMIOS version: 2 updated: 2000/07/22 23:37:24
1120 dnl Some old/broken variations define tcgetattr() only as a macro in
1122 AC_DEFUN([CF_FUNC_TERMIOS],[
1123 AC_REQUIRE([CF_STRUCT_TERMIOS])
1124 AC_CACHE_CHECK(for tcgetattr, cf_cv_have_tcgetattr,[
1126 #include <sys/types.h>
1127 #ifdef HAVE_UNISTD_H
1130 #ifdef HAVE_TERMIOS_H
1131 #include <termios.h>
1132 #define TTY struct termios
1134 #ifdef HAVE_TERMIO_H
1136 #define TTY struct termio
1141 tcgetattr(1, &foo);],
1142 [cf_cv_have_tcgetattr=yes],
1143 [cf_cv_have_tcgetattr=no])])
1144 test "$cf_cv_have_tcgetattr" = yes && AC_DEFINE(HAVE_TCGETATTR)
1146 dnl ---------------------------------------------------------------------------
1147 dnl CF_FUNC_VSSCANF version: 3 updated: 2001/12/19 00:50:10
1149 dnl Check for vsscanf() function, which is in c9x but generally not in earlier
1150 dnl versions of C. It is in the GNU C library, and can often be simulated by
1151 dnl other functions.
1152 AC_DEFUN([CF_FUNC_VSSCANF],
1154 AC_CACHE_CHECK(for vsscanf function or workaround,cf_cv_func_vsscanf,[
1157 #include <stdio.h>],[
1159 vsscanf("from", "%d", ap)],[cf_cv_func_vsscanf=vsscanf],[
1162 #include <stdio.h>],[
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],[
1173 #include <stdio.h>],[
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],[
1182 cf_cv_func_vsscanf=no])])])])
1184 case $cf_cv_func_vsscanf in #(vi
1185 vsscanf) AC_DEFINE(HAVE_VSSCANF);; #(vi
1186 vfscanf) AC_DEFINE(HAVE_VFSCANF);; #(vi
1187 _doscan) AC_DEFINE(HAVE__DOSCAN);;
1191 dnl ---------------------------------------------------------------------------
1192 dnl CF_GCC_ATTRIBUTES version: 11 updated: 2007/07/29 09:55:12
1193 dnl -----------------
1194 dnl Test for availability of useful gcc __attribute__ directives to quiet
1195 dnl compiler warnings. Though useful, not all are supported -- and contrary
1196 dnl to documentation, unrecognized directives cause older compilers to barf.
1197 AC_DEFUN([CF_GCC_ATTRIBUTES],
1199 if test "$GCC" = yes
1201 cat > conftest.i <<EOF
1203 #define GCC_PRINTF 0
1208 #ifndef GCC_NORETURN
1209 #define GCC_NORETURN /* nothing */
1212 #define GCC_UNUSED /* nothing */
1215 if test "$GCC" = yes
1217 AC_CHECKING([for $CC __attribute__ directives])
1218 cat > conftest.$ac_ext <<EOF
1219 #line __oline__ "${as_me-configure}"
1220 #include "confdefs.h"
1221 #include "conftest.h"
1222 #include "conftest.i"
1224 #define GCC_PRINTFLIKE(fmt,var) __attribute__((format(printf,fmt,var)))
1226 #define GCC_PRINTFLIKE(fmt,var) /*nothing*/
1229 #define GCC_SCANFLIKE(fmt,var) __attribute__((format(scanf,fmt,var)))
1231 #define GCC_SCANFLIKE(fmt,var) /*nothing*/
1233 extern void wow(char *,...) GCC_SCANFLIKE(1,2);
1234 extern void oops(char *,...) GCC_PRINTFLIKE(1,2) GCC_NORETURN;
1235 extern void foo(void) GCC_NORETURN;
1236 int main(int argc GCC_UNUSED, char *argv[[]] GCC_UNUSED) { return 0; }
1238 for cf_attribute in scanf printf unused noreturn
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
1245 cat >conftest.h <<EOF
1246 #define GCC_$cf_ATTRIBUTE 1
1250 cat >conftest.h <<EOF
1251 #define GCC_$cf_ATTRIBUTE $cf_directive
1255 if AC_TRY_EVAL(ac_compile); then
1256 test -n "$verbose" && AC_MSG_RESULT(... $cf_attribute)
1257 cat conftest.h >>confdefs.h
1261 fgrep define conftest.i >>confdefs.h
1266 dnl ---------------------------------------------------------------------------
1267 dnl CF_GCC_VERSION version: 4 updated: 2005/08/27 09:53:42
1269 dnl Find version of gcc
1270 AC_DEFUN([CF_GCC_VERSION],[
1271 AC_REQUIRE([AC_PROG_CC])
1273 if 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)
1280 dnl ---------------------------------------------------------------------------
1281 dnl CF_GCC_WARNINGS version: 23 updated: 2008/07/26 17:54:02
1283 dnl Check if the compiler supports useful warning options. There's a few that
1284 dnl we don't use, simply because they're too noisy:
1286 dnl -Wconversion (useful in older versions of gcc, but not in gcc 2.7.x)
1287 dnl -Wredundant-decls (system headers make this too noisy)
1288 dnl -Wtraditional (combines too many unrelated messages, only a few useful)
1289 dnl -Wwrite-strings (too noisy, but should review occasionally). This
1290 dnl is enabled for ncurses using "--enable-const".
1294 dnl $1 is an optional list of gcc warning flags that a particular
1295 dnl application might want to use, e.g., "no-unused" for
1298 dnl If $with_ext_const is "yes", add a check for -Wwrite-strings
1300 AC_DEFUN([CF_GCC_WARNINGS],
1302 AC_REQUIRE([CF_GCC_VERSION])
1303 CF_INTEL_COMPILER(GCC,INTEL_COMPILER,CFLAGS)
1305 cat > conftest.$ac_ext <<EOF
1306 #line __oline__ "${as_me-configure}"
1307 int main(int argc, char *argv[[]]) { return (argv[[argc-1]] == 0) ; }
1310 if test "$INTEL_COMPILER" = yes
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
1324 AC_CHECKING([for $CC warning options])
1325 cf_save_CFLAGS="$CFLAGS"
1326 EXTRA_CFLAGS="-Wall"
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"
1345 CFLAGS="$cf_save_CFLAGS"
1347 elif test "$GCC" = yes
1349 AC_CHECKING([for $CC warning options])
1350 cf_save_CFLAGS="$CFLAGS"
1351 EXTRA_CFLAGS="-W -Wall"
1353 test "$with_ext_const" = yes && cf_warn_CONST="Wwrite-strings"
1355 Wbad-function-cast \
1359 Wmissing-declarations \
1360 Wmissing-prototypes \
1364 Wstrict-prototypes \
1365 Wundef $cf_warn_CONST $1
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
1372 CPPFLAGS="$CPPFLAGS -DXTSTRINGDEFINES"
1375 case $GCC_VERSION in
1377 CF_VERBOSE(feature is broken in gcc $GCC_VERSION)
1382 EXTRA_CFLAGS="$EXTRA_CFLAGS -$cf_opt"
1385 CFLAGS="$cf_save_CFLAGS"
1389 AC_SUBST(EXTRA_CFLAGS)
1391 dnl ---------------------------------------------------------------------------
1392 dnl CF_GNAT_TRY_LINK version: 1 updated: 2004/08/21 19:02:08
1393 dnl ----------------
1394 dnl Verify that a test program compiles/links with GNAT.
1395 dnl $cf_ada_make is set to the program that compiles/links
1396 dnl $ADAFLAGS may be set to the GNAT flags.
1398 dnl $1 is the text of the spec
1399 dnl $2 is the text of the body
1400 dnl $3 is the shell command to execute if successful
1401 dnl $4 is the shell command to execute if not successful
1402 AC_DEFUN([CF_GNAT_TRY_LINK],
1405 cat >>conftest.ads <<CF_EOF
1408 cat >>conftest.adb <<CF_EOF
1411 if ( $cf_ada_make $ADAFLAGS conftest 1>&AC_FD_CC 2>&1 ) ; then
1412 ifelse($3,, :,[ $3])
1418 dnl ---------------------------------------------------------------------------
1419 dnl CF_GNAT_TRY_RUN version: 3 updated: 2004/08/21 19:02:08
1421 dnl Verify that a test program compiles and runs with GNAT
1422 dnl $cf_ada_make is set to the program that compiles/links
1423 dnl $ADAFLAGS may be set to the GNAT flags.
1425 dnl $1 is the text of the spec
1426 dnl $2 is the text of the body
1427 dnl $3 is the shell command to execute if successful
1428 dnl $4 is the shell command to execute if not successful
1429 AC_DEFUN([CF_GNAT_TRY_RUN],
1432 cat >>conftest.ads <<CF_EOF
1435 cat >>conftest.adb <<CF_EOF
1438 if ( $cf_ada_make $ADAFLAGS conftest 1>&AC_FD_CC 2>&1 ) ; then
1439 if ( ./conftest 1>&AC_FD_CC 2>&1 ) ; then
1440 ifelse($3,, :,[ $3])
1449 dnl ---------------------------------------------------------------------------
1450 dnl CF_GNAT_VERSION version: 12 updated: 2006/10/14 15:23:15
1452 dnl Verify version of GNAT.
1453 AC_DEFUN([CF_GNAT_VERSION],
1455 AC_MSG_CHECKING(for gnat version)
1456 cf_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/ .*//'`
1458 AC_MSG_RESULT($cf_gnat_version)
1460 case $cf_gnat_version in
1461 3.1[[1-9]]*|3.[[2-9]]*|[[4-9]].*)
1462 cf_cv_prog_gnat_correct=yes
1464 *) echo Unsupported GNAT version $cf_gnat_version. Required is 3.11 or better. Disabling Ada95 binding.
1465 cf_cv_prog_gnat_correct=no
1468 case $cf_gnat_version in
1469 3.[[1-9]]*|[[4-9]].*)
1470 cf_compile_generics=generics
1471 cf_generic_objects="\${GENOBJS}"
1473 *) cf_compile_generics=
1478 dnl ---------------------------------------------------------------------------
1479 dnl CF_GNU_SOURCE version: 6 updated: 2005/07/09 13:23:07
1481 dnl Check if we must define _GNU_SOURCE to get a reasonable value for
1482 dnl _XOPEN_SOURCE, upon which many POSIX definitions depend. This is a defect
1483 dnl (or misfeature) of glibc2, which breaks portability of many applications,
1484 dnl since it is interwoven with GNU extensions.
1486 dnl Well, yes we could work around it...
1487 AC_DEFUN([CF_GNU_SOURCE],
1489 AC_CACHE_CHECK(if we must define _GNU_SOURCE,cf_cv_gnu_source,[
1490 AC_TRY_COMPILE([#include <sys/types.h>],[
1491 #ifndef _XOPEN_SOURCE
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
1501 [cf_cv_gnu_source=no],
1502 [cf_cv_gnu_source=yes])
1506 test "$cf_cv_gnu_source" = yes && CPPFLAGS="$CPPFLAGS -D_GNU_SOURCE"
1508 dnl ---------------------------------------------------------------------------
1509 dnl CF_GPP_LIBRARY version: 8 updated: 2003/02/02 01:41:46
1511 dnl If we're trying to use g++, test if libg++ is installed (a rather common
1512 dnl problem :-). If we have the compiler but no library, we'll be able to
1513 dnl configure, but won't be able to build the c++ demo program.
1514 AC_DEFUN([CF_GPP_LIBRARY],
1516 cf_cxx_library=unknown
1517 case $cf_cv_system_name in #(vi
1525 if test "$GXX" = yes; then
1526 AC_MSG_CHECKING([for lib$cf_gpp_libname])
1528 LIBS="$LIBS -l$cf_gpp_libname"
1530 #include <$cf_gpp_libname/builtin.h>
1532 [two_arg_error_handler_t foo2 = lib_error_handler],
1534 CXXLIBS="$CXXLIBS -l$cf_gpp_libname"
1535 if test "$cf_gpp_libname" = cpp ; then
1536 AC_DEFINE(HAVE_GPP_BUILTIN_H)
1538 AC_DEFINE(HAVE_GXX_BUILTIN_H)
1541 #include <builtin.h>
1543 [two_arg_error_handler_t foo2 = lib_error_handler],
1545 CXXLIBS="$CXXLIBS -l$cf_gpp_libname"
1546 AC_DEFINE(HAVE_BUILTIN_H)],
1547 [cf_cxx_library=no])])
1549 AC_MSG_RESULT($cf_cxx_library)
1552 dnl ---------------------------------------------------------------------------
1553 dnl CF_GXX_VERSION version: 5 updated: 2005/08/27 09:53:42
1555 dnl Check for version of g++
1556 AC_DEFUN([CF_GXX_VERSION],[
1557 AC_REQUIRE([AC_PROG_CPP])
1559 if 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)
1566 dnl ---------------------------------------------------------------------------
1567 dnl CF_GXX_WARNINGS version: 5 updated: 2005/08/13 14:54:38
1569 dnl Check if the compiler supports useful warning options.
1571 dnl Most of gcc's options apply to g++, except:
1572 dnl -Wbad-function-cast
1573 dnl -Wmissing-declarations
1574 dnl -Wnested-externs
1576 dnl Omit a few (for now):
1580 dnl $1 is an optional list of g++ warning flags that a particular
1581 dnl application might want to use, e.g., "no-unused" for
1584 dnl If $with_ext_const is "yes", add a check for -Wwrite-strings
1586 AC_DEFUN([CF_GXX_WARNINGS],
1589 CF_INTEL_COMPILER(GXX,INTEL_CPLUSPLUS,CXXFLAGS)
1591 AC_REQUIRE([CF_GXX_VERSION])
1596 cat > conftest.$ac_ext <<EOF
1597 #line __oline__ "configure"
1598 int main(int argc, char *argv[[]]) { return (argv[[argc-1]] == 0) ; }
1601 if test "$INTEL_CPLUSPLUS" = yes
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
1615 AC_CHECKING([for $CC warning options])
1616 cf_save_CXXFLAGS="$CXXFLAGS"
1617 EXTRA_CXXFLAGS="-Wall"
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"
1636 CXXFLAGS="$cf_save_CXXFLAGS"
1638 elif test "$GXX" = yes
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
1649 cf_gxx_extra_warnings="$cf_gxx_extra_warnings Weffc++"
1655 Woverloaded-virtual \
1661 Wmissing-prototypes \
1664 Wstrict-prototypes \
1665 Wundef $cf_gxx_extra_warnings $1
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"
1672 test -n "$verbose" && AC_MSG_RESULT(... no -$cf_opt)
1675 CXXFLAGS="$cf_save_CXXFLAGS"
1680 AC_SUBST(EXTRA_CXXFLAGS)
1682 dnl ---------------------------------------------------------------------------
1683 dnl CF_HASHED_DB version: 3 updated: 2007/11/24 17:43:37
1685 dnl Look for an instance of the Berkeley hashed database.
1687 dnl $1 = optional parameter, to specify install-prefix for the database.
1688 AC_DEFUN([CF_HASHED_DB],
1695 if test -d "$1" ; then
1696 CF_ADD_INCDIR($1/include)
1697 CF_ADD_LIBDIR($1/lib)
1701 AC_CHECK_HEADER(db.h,[
1702 CF_HASHED_DB_VERSION
1703 if test "$cf_cv_hashed_db_version" = unknown ; then
1704 AC_MSG_ERROR(Cannot determine version of db)
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"
1714 AC_MSG_ERROR(Cannot find db.h)
1717 dnl ---------------------------------------------------------------------------
1718 dnl CF_HASHED_DB_LIBS version: 7 updated: 2007/12/01 15:01:37
1719 dnl -----------------
1720 dnl Given that we have the header and version for hashed database, find the
1721 dnl library information.
1722 AC_DEFUN([CF_HASHED_DB_LIBS],
1724 AC_CACHE_CHECK(for db libraries, cf_cv_hashed_db_libs,[
1725 cf_cv_hashed_db_libs=unknown
1726 for cf_db_libs in db$cf_cv_hashed_db_version db-$cf_cv_hashed_db_version db ''
1728 cf_save_libs="$LIBS"
1729 if test -n "$cf_db_libs"; then
1730 LIBS="-l$cf_db_libs $LIBS"
1732 CF_MSG_LOG(checking for library "$cf_db_libs")
1734 $ac_includes_default
1737 char *path = "/tmp/foo";
1738 #ifdef DB_VERSION_MAJOR
1739 #if DB_VERSION_MAJOR >= 4
1741 db_create(&result, NULL, 0);
1742 result->open(result,
1749 #elif DB_VERSION_MAJOR >= 3
1751 db_create(&result, NULL, 0);
1752 result->open(result,
1758 #elif DB_VERSION_MAJOR >= 2
1767 #endif /* DB_VERSION_MAJOR */
1769 DB *result = dbopen(path,
1775 ${cf_cv_main_return:-return}(result != 0)
1777 if test -n "$cf_db_libs" ; then
1778 cf_cv_hashed_db_libs=$cf_db_libs
1780 cf_cv_hashed_db_libs=default
1782 LIBS="$cf_save_libs"
1785 LIBS="$cf_save_libs"
1789 dnl ---------------------------------------------------------------------------
1790 dnl CF_HASHED_DB_VERSION version: 3 updated: 2007/12/01 15:01:37
1791 dnl --------------------
1792 dnl Given that we have the header file for hashed database, find the version
1794 AC_DEFUN([CF_HASHED_DB_VERSION],
1796 AC_CACHE_CHECK(for version of db, cf_cv_hashed_db_version,[
1797 cf_cv_hashed_db_version=unknown
1799 for cf_db_version in 1 2 3 4 5
1801 CF_MSG_LOG(checking for db version $cf_db_version)
1803 $ac_includes_default
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
1814 #if $cf_db_version == 1
1815 /* ok: assuming this is DB 1.8.5 */
1821 cf_cv_hashed_db_version=$cf_db_version
1827 dnl ---------------------------------------------------------------------------
1828 dnl CF_HELP_MESSAGE version: 3 updated: 1998/01/14 10:56:23
1830 dnl Insert text into the help-message, for readability, from AC_ARG_WITH.
1831 AC_DEFUN([CF_HELP_MESSAGE],
1832 [AC_DIVERT_HELP([$1])dnl
1834 dnl ---------------------------------------------------------------------------
1835 dnl CF_INCLUDE_DIRS version: 5 updated: 2006/10/14 15:23:15
1837 dnl Construct the list of include-options according to whether we're building
1838 dnl in the source directory or using '--srcdir=DIR' option. If we're building
1839 dnl with gcc, don't append the includedir if it happens to be /usr/include,
1840 dnl since that usually breaks gcc's shadow-includes.
1841 AC_DEFUN([CF_INCLUDE_DIRS],
1843 CPPFLAGS="-I. -I../include $CPPFLAGS"
1844 if test "$srcdir" != "."; then
1845 CPPFLAGS="-I\${srcdir}/../include $CPPFLAGS"
1847 if test "$GCC" != yes; then
1848 CPPFLAGS="$CPPFLAGS -I\${includedir}"
1849 elif test "$includedir" != "/usr/include"; then
1850 if test "$includedir" = '${prefix}/include' ; then
1851 if test $prefix != /usr ; then
1852 CPPFLAGS="$CPPFLAGS -I\${includedir}"
1855 CPPFLAGS="$CPPFLAGS -I\${includedir}"
1860 dnl ---------------------------------------------------------------------------
1861 dnl CF_INTEL_COMPILER version: 3 updated: 2005/08/06 18:37:29
1862 dnl -----------------
1863 dnl Check if the given compiler is really the Intel compiler for Linux. It
1864 dnl tries to imitate gcc, but does not return an error when it finds a mismatch
1865 dnl between prototypes, e.g., as exercised by CF_MISSING_CHECK.
1867 dnl This macro should be run "soon" after AC_PROG_CC or AC_PROG_CPLUSPLUS, to
1868 dnl ensure that it is not mistaken for gcc/g++. It is normally invoked from
1869 dnl the wrappers for gcc and g++ warnings.
1871 dnl $1 = GCC (default) or GXX
1872 dnl $2 = INTEL_COMPILER (default) or INTEL_CPLUSPLUS
1873 dnl $3 = CFLAGS (default) or CXXFLAGS
1874 AC_DEFUN([CF_INTEL_COMPILER],[
1875 ifelse($2,,INTEL_COMPILER,[$2])=no
1877 if test "$ifelse($1,,[$1],GCC)" = yes ; then
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"
1884 #ifdef __INTEL_COMPILER
1888 ],[ifelse($2,,INTEL_COMPILER,[$2])=yes
1889 cf_save_CFLAGS="$cf_save_CFLAGS -we147 -no-gcc"
1891 ifelse($3,,CFLAGS,[$3])="$cf_save_CFLAGS"
1892 AC_MSG_RESULT($ifelse($2,,INTEL_COMPILER,[$2]))
1897 dnl ---------------------------------------------------------------------------
1898 dnl CF_ISASCII version: 3 updated: 2000/08/12 23:18:52
1900 dnl Check if we have either a function or macro for 'isascii()'.
1901 AC_DEFUN([CF_ISASCII],
1903 AC_MSG_CHECKING(for isascii)
1904 AC_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])
1909 AC_MSG_RESULT($cf_cv_have_isascii)
1910 test "$cf_cv_have_isascii" = yes && AC_DEFINE(HAVE_ISASCII)
1912 dnl ---------------------------------------------------------------------------
1913 dnl CF_LARGEFILE version: 7 updated: 2007/06/02 11:58:50
1915 dnl Add checks for large file support.
1916 AC_DEFUN([CF_LARGEFILE],[
1917 ifdef([AC_FUNC_FSEEKO],[
1919 if test "$enable_largefile" != no ; then
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
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 "
1933 AC_CACHE_CHECK(whether to use struct dirent64, cf_cv_struct_dirent64,[
1935 #include <sys/types.h>
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);
1944 [cf_cv_struct_dirent64=yes],
1945 [cf_cv_struct_dirent64=no])
1947 test "$cf_cv_struct_dirent64" = yes && AC_DEFINE(HAVE_STRUCT_DIRENT64)
1951 dnl ---------------------------------------------------------------------------
1952 dnl CF_LDFLAGS_STATIC version: 3 updated: 2008/07/05 13:56:40
1953 dnl -----------------
1954 dnl Check for compiler/linker flags used to temporarily force usage of static
1955 dnl libraries. This depends on the compiler and platform. Use this to help
1956 dnl ensure that the linker picks up a given library based on its position in
1957 dnl the list of linker options and libraries.
1958 AC_DEFUN([CF_LDFLAGS_STATIC],[
1960 if test "$GCC" = yes ; then
1961 case $cf_cv_system_name in #(
1962 aix[[45]]*) #( gcc 4.2.4 linkage on AIX is broken
1966 *) #( normally, except when broken
1967 LDFLAGS_STATIC=-static
1968 LDFLAGS_SHARED=-dynamic
1972 case $cf_cv_system_name in #(
1973 aix[[45]]*) #( from ld manpage
1974 LDFLAGS_STATIC=-bstatic
1975 LDFLAGS_SHARED=-bdynamic
1977 hpux*) #( from ld manpage for hpux10.20, hpux11.11
1978 # We could also use just "archive" and "shared".
1979 LDFLAGS_STATIC=-Wl,-a,archive_shared
1980 LDFLAGS_SHARED=-Wl,-a,shared_archive
1982 irix*) #( from ld manpage IRIX64
1983 LDFLAGS_STATIC=-Bstatic
1984 LDFLAGS_SHARED=-Bdynamic
1986 osf[[45]]*) #( from ld manpage osf4.0d, osf5.1
1987 # alternative "-oldstyle_liblookup" (not in cc manpage)
1988 LDFLAGS_STATIC=-noso
1989 LDFLAGS_SHARED=-so_archive
1992 LDFLAGS_STATIC=-Bstatic
1993 LDFLAGS_SHARED=-Bdynamic
1998 AC_SUBST(LDFLAGS_STATIC)
1999 AC_SUBST(LDFLAGS_SHARED)
2001 dnl ---------------------------------------------------------------------------
2002 dnl CF_LIBUTF8 version: 2 updated: 2002/01/19 22:51:32
2004 dnl Check for libutf8
2005 AC_DEFUN([CF_LIBUTF8],
2007 AC_CACHE_CHECK(for putwc in libutf8,cf_cv_libutf8,[
2008 cf_save_LIBS="$LIBS"
2011 #include <libutf8.h>],[putwc(0,0);],
2012 [cf_cv_libutf8=yes],
2014 LIBS="$cf_save_LIBS"
2017 if test "$cf_cv_libutf8" = yes ; then
2018 AC_DEFINE(HAVE_LIBUTF8_H)
2022 dnl ---------------------------------------------------------------------------
2023 dnl CF_LIB_PREFIX version: 7 updated: 2001/01/12 01:23:48
2025 dnl Compute the library-prefix for the given host system
2026 dnl $1 = variable to set
2027 AC_DEFUN([CF_LIB_PREFIX],
2029 case $cf_cv_system_name in
2030 OS/2*) LIB_PREFIX='' ;;
2031 os2*) LIB_PREFIX='' ;;
2032 *) LIB_PREFIX='lib' ;;
2034 ifelse($1,,,[$1=$LIB_PREFIX])
2035 AC_SUBST(LIB_PREFIX)
2037 dnl ---------------------------------------------------------------------------
2038 dnl CF_LIB_RULES version: 50 updated: 2007/03/24 18:26:59
2040 dnl Append definitions and rules for the given models to the subdirectory
2041 dnl Makefiles, and the recursion rule for the top-level Makefile. If the
2042 dnl subdirectory is a library-source directory, modify the LIBS_TO_MAKE list in
2043 dnl the corresponding makefile to list the models that we'll generate.
2045 dnl For shared libraries, make a list of symbolic links to construct when
2046 dnl generating each library. The convention used for Linux is the simplest
2049 dnl lib<name>.so.<major> ->
2050 dnl lib<name>.so.<maj>.<minor>
2051 AC_DEFUN([CF_LIB_RULES],
2053 CF_LIB_PREFIX(cf_prefix)
2054 AC_REQUIRE([CF_SUBST_NCURSES_VERSION])
2055 for cf_dir in $SRC_SUBDIRS
2057 if test ! -d $srcdir/$cf_dir ; then
2059 elif test -f $srcdir/$cf_dir/modules; then
2063 for cf_item in $cf_LIST_MODELS
2065 CF_LIB_SUFFIX($cf_item,cf_suffix)
2066 if test $cf_item = shared ; then
2067 if test "$cf_cv_do_symlinks" = yes ; then
2068 case "$cf_cv_shlib_version" in #(vi
2070 case "$cf_cv_system_name" in #(vi
2072 case .${LIB_SUFFIX} in
2074 cf_suffix=`echo $cf_suffix | sed 's/^w//'`
2075 cf_suffix=w'.${REL_VERSION}'"$cf_suffix"
2078 cf_suffix='.${REL_VERSION}'"$cf_suffix"
2082 *) cf_suffix="$cf_suffix"'.${REL_VERSION}' ;;
2086 case "$cf_cv_system_name" in #(vi
2088 case .${LIB_SUFFIX} in
2090 cf_suffix=`echo $cf_suffix | sed 's/^w//'`
2091 cf_suffix=w'.${ABI_VERSION}'"$cf_suffix"
2094 cf_suffix='.${ABI_VERSION}'"$cf_suffix"
2098 *) cf_suffix="$cf_suffix"'.${ABI_VERSION}' ;;
2103 # cygwin needs import library, and has unique naming convention
2104 # use autodetected ${cf_prefix} for import lib and static lib, but
2105 # use 'cyg' prefix for shared lib.
2106 if test $cf_cv_shlib_version = cygdll ; then
2107 LIBS_TO_MAKE="$LIBS_TO_MAKE ../lib/cyg${cf_dir}\${ABI_VERSION}.dll"
2111 LIBS_TO_MAKE="$LIBS_TO_MAKE ../lib/${cf_prefix}${cf_dir}${cf_suffix}"
2114 if test $cf_dir = ncurses ; then
2115 cf_subsets="$LIB_SUBSETS"
2116 cf_r_parts="$cf_subsets"
2118 while test -n "$cf_r_parts"
2120 cf_l_parts=`echo "$cf_r_parts" |sed -e 's/ .*$//'`
2121 cf_r_parts=`echo "$cf_r_parts" |sed -e 's/^[[^ ]]* //'`
2122 if test "$cf_l_parts" != "$cf_r_parts" ; then
2123 case $cf_l_parts in #(vi
2125 cf_item=`echo $LIBS_TO_MAKE |sed -e s%${LIB_NAME}${LIB_SUFFIX}%${TINFO_LIB_SUFFIX}%g`
2128 cf_item=`echo $LIBS_TO_MAKE |sed -e s%${LIB_NAME}${LIB_SUFFIX}%${TICS_LIB_SUFFIX}%g`
2134 LIBS_TO_MAKE="$cf_item $LIBS_TO_MAKE"
2140 cf_subsets=`echo "$LIB_SUBSETS" | sed -e 's/^termlib.* //'`
2143 sed -e "s%@LIBS_TO_MAKE@%$LIBS_TO_MAKE%" \
2144 -e "s%@SHARED_LIB@%$SHARED_LIB%" \
2145 $cf_dir/Makefile >$cf_dir/Makefile.out
2146 mv $cf_dir/Makefile.out $cf_dir/Makefile
2148 $AWK -f $srcdir/mk-0th.awk \
2149 libname="${cf_dir}${LIB_SUFFIX}" subsets="$LIB_SUBSETS" \
2150 $srcdir/$cf_dir/modules >>$cf_dir/Makefile
2152 for cf_subset in $cf_subsets
2155 for cf_item in $cf_LIST_MODELS
2157 echo "Appending rules for ${cf_item} model (${cf_dir}: ${cf_subset})"
2158 CF_UPPER(cf_ITEM,$cf_item)
2159 CF_LIB_SUFFIX($cf_item,cf_suffix)
2160 CF_OBJ_SUBDIR($cf_item,cf_subdir)
2162 # Test for case where we build libtinfo with a different name.
2164 if test $cf_dir = ncurses ; then
2169 cf_libname=$TINFO_LIB_SUFFIX
2170 if test -n "${DFT_ARG_SUFFIX}" ; then
2171 # undo $LIB_SUFFIX add-on in CF_LIB_SUFFIX
2172 cf_suffix=`echo $cf_suffix |sed -e "s%^${LIB_SUFFIX}%%"`
2176 cf_libname=$TICS_LIB_SUFFIX
2177 if test -n "${DFT_ARG_SUFFIX}" ; then
2178 # undo $LIB_SUFFIX add-on in CF_LIB_SUFFIX
2179 cf_suffix=`echo $cf_suffix |sed -e "s%^${LIB_SUFFIX}%%"`
2185 # These dependencies really are for development, not
2186 # builds, but they are useful in porting, too.
2187 cf_depend="../include/ncurses_cfg.h"
2188 if test "$srcdir" = "."; then
2191 cf_reldir="\${srcdir}"
2194 if test -f $srcdir/$cf_dir/$cf_dir.priv.h; then
2195 cf_depend="$cf_depend $cf_reldir/$cf_dir.priv.h"
2196 elif test -f $srcdir/$cf_dir/curses.priv.h; then
2197 cf_depend="$cf_depend $cf_reldir/curses.priv.h"
2201 old_cf_suffix="$cf_suffix"
2202 if test "$cf_cv_shlib_version_infix" = yes ; then
2203 if test -n "$LIB_SUFFIX" ; then
2206 cf_libname=`echo $cf_libname | sed 's/w$//'`
2207 cf_suffix=`echo $cf_suffix | sed 's/^w//'`
2214 $AWK -f $srcdir/mk-1st.awk \
2215 name=${cf_libname}${cf_dir_suffix} \
2216 traces=$LIB_TRACING \
2222 TermlibRoot=$TINFO_NAME \
2223 TermlibSuffix=$TINFO_SUFFIX \
2224 ShlibVer=$cf_cv_shlib_version \
2225 ShlibVerInfix=$cf_cv_shlib_version_infix \
2226 ReLink=${cf_cv_do_relink-no} \
2227 DoLinks=$cf_cv_do_symlinks \
2228 rmSoLocs=$cf_cv_rm_so_locs \
2229 ldconfig="$LDCONFIG" \
2230 overwrite=$WITH_OVERWRITE \
2231 depend="$cf_depend" \
2233 $srcdir/$cf_dir/modules >>$cf_dir/Makefile
2235 cf_suffix="$old_cf_suffix"
2237 for cf_subdir2 in $cf_subdirs lib
2239 test $cf_subdir = $cf_subdir2 && break
2241 test "${cf_subset}.${cf_subdir2}" != "${cf_subset}.${cf_subdir}" && \
2242 $AWK -f $srcdir/mk-2nd.awk \
2244 traces=$LIB_TRACING \
2250 crenames=$cf_cv_prog_CC_c_o \
2251 cxxrenames=$cf_cv_prog_CXX_c_o \
2252 $srcdir/$cf_dir/modules >>$cf_dir/Makefile
2253 cf_subdirs="$cf_subdirs $cf_subdir"
2258 echo ' cd '$cf_dir' && ${MAKE} ${CF_MFLAGS} [$]@' >>Makefile
2261 for cf_dir in $SRC_SUBDIRS
2263 if test ! -d $srcdir/$cf_dir ; then
2267 if test -f $cf_dir/Makefile ; then
2270 echo 'libs \' >> Makefile
2271 echo 'install.libs \' >> Makefile
2272 echo 'uninstall.libs ::' >> Makefile
2273 echo ' cd '$cf_dir' && ${MAKE} ${CF_MFLAGS} [$]@' >> Makefile
2278 if test -f $srcdir/$cf_dir/modules; then
2280 if test -f $srcdir/$cf_dir/headers; then
2281 cat >> Makefile <<CF_EOF
2283 uninstall.includes \\
2286 if test "$cf_dir" != "c++" ; then
2287 echo 'lint \' >> Makefile
2289 cat >> Makefile <<CF_EOF
2295 uninstall.$cf_dir ::
2296 cd $cf_dir && \${MAKE} \${CF_MFLAGS} \[$]@
2298 elif test -f $srcdir/$cf_dir/headers; then
2299 cat >> Makefile <<CF_EOF
2305 uninstall.includes ::
2306 cd $cf_dir && \${MAKE} \${CF_MFLAGS} \[$]@
2311 cat >> Makefile <<CF_EOF
2313 install.libs uninstall.libs \\
2314 install.data uninstall.data ::
2315 $MAKE_TERMINFO cd misc && \${MAKE} \${CF_MFLAGS} \[$]@
2319 cd man && \${MAKE} \${CF_MFLAGS} \[$]@
2322 rm -f config.cache config.log config.status Makefile include/ncurses_cfg.h
2323 rm -f headers.sh headers.sed mk_shared_lib.sh
2324 rm -rf \${DIRS_TO_MAKE}
2327 # Special case: tack's manpage lives in its own directory.
2328 if test -d tack ; then
2329 if test -f $srcdir/$tack.h; then
2330 cat >> Makefile <<CF_EOF
2334 cd tack && \${MAKE} \${CF_MFLAGS} \[$]@
2339 dnl If we're installing into a subdirectory of /usr/include, etc., we should
2340 dnl prepend the subdirectory's name to the "#include" paths. It won't hurt
2341 dnl anything, and will make it more standardized. It's awkward to decide this
2342 dnl at configuration because of quoting, so we'll simply make all headers
2343 dnl installed via a script that can do the right thing.
2345 rm -f headers.sed headers.sh
2347 dnl ( generating this script makes the makefiles a little tidier :-)
2348 echo creating headers.sh
2349 cat >headers.sh <<CF_EOF
2351 # This shell script is generated by the 'configure' script. It is invoked in a
2352 # subdirectory of the build tree. It generates a sed-script in the parent
2353 # directory that is used to adjust includes for header files that reside in a
2354 # subdirectory of /usr/include, etc.
2356 while test \[$]# != 3
2358 PRG="\$PRG \[$]1"; shift
2363 TMPSRC=\${TMPDIR-/tmp}/\`basename \$SRC\`\$\$
2364 TMPSED=\${TMPDIR-/tmp}/headers.sed\$\$
2365 echo installing \$SRC in \$DST
2368 if test $WITH_CURSES_H = yes; then
2369 cat >>headers.sh <<CF_EOF
2372 END=\`basename \$DST\`
2373 for i in \`cat \$REF/../*/headers |fgrep -v "#"\`
2375 NAME=\`basename \$i\`
2376 echo "s/<\$NAME>/<\$END\/\$NAME>/" >> \$TMPSED
2386 cat >>headers.sh <<CF_EOF
2389 END=\`basename \$DST\`
2390 for i in \`cat \$REF/../*/headers |fgrep -v "#"\`
2392 NAME=\`basename \$i\`
2393 if test "\$NAME" = "curses.h"
2395 echo "s/<curses.h>/<ncurses.h>/" >> \$TMPSED
2398 echo "s/<\$NAME>/<\$END\/\$NAME>/" >> \$TMPSED
2402 echo "s/<curses.h>/<ncurses.h>/" >> \$TMPSED
2407 cat >>headers.sh <<CF_EOF
2409 sed -f \$TMPSED \$SRC > \$TMPSRC
2410 NAME=\`basename \$SRC\`
2412 if test $WITH_CURSES_H != yes; then
2413 cat >>headers.sh <<CF_EOF
2414 test "\$NAME" = "curses.h" && NAME=ncurses.h
2417 cat >>headers.sh <<CF_EOF
2418 # Just in case someone gzip'd manpages, remove the conflicting copy.
2419 test -f \$DST/\$NAME.gz && rm -f \$DST/\$NAME.gz
2421 eval \$PRG \$TMPSRC \$DST/\$NAME
2422 rm -f \$TMPSRC \$TMPSED
2425 chmod 0755 headers.sh
2427 for cf_dir in $SRC_SUBDIRS
2429 if test ! -d $srcdir/$cf_dir ; then
2433 if test -f $srcdir/$cf_dir/headers; then
2434 $AWK -f $srcdir/mk-hdr.awk \
2435 subset="$LIB_SUBSETS" \
2436 compat="$WITH_CURSES_H" \
2437 $srcdir/$cf_dir/headers >>$cf_dir/Makefile
2440 if test -f $srcdir/$cf_dir/modules; then
2441 if test "$cf_dir" != "c++" ; then
2442 cat >>$cf_dir/Makefile <<"CF_EOF"
2443 depend : ${AUTO_SRC}
2444 makedepend -- ${CPPFLAGS} -- ${C_SRC}
2446 # DO NOT DELETE THIS LINE -- make depend depends on it.
2453 dnl ---------------------------------------------------------------------------
2454 dnl CF_LIB_SONAME version: 3 updated: 2006/12/16 15:55:46
2456 dnl Find the and soname for the given shared library. Set the cache variable
2457 dnl cf_cv_$3_soname to this, unless it is not found. Then set the cache
2458 dnl variable to "unknown".
2462 dnl $3 = library name
2463 AC_DEFUN([CF_LIB_SONAME],
2465 AC_CACHE_CHECK(for soname of $3 library,cf_cv_$3_soname,[
2467 cf_cv_$3_soname=unknown
2468 if test "$cross_compiling" != yes ; then
2469 cat >conftest.$ac_ext <<CF_EOF
2474 ${cf_cv_main_return:-return}(0);
2477 cf_save_LIBS="$LIBS"
2479 if AC_TRY_EVAL(ac_compile) ; then
2480 if AC_TRY_EVAL(ac_link) ; then
2481 cf_cv_$3_soname=`ldd conftest$ac_exeext 2>/dev/null | sed -e 's,^.*/,,' -e 's, .*$,,' | fgrep lib$3.`
2482 test -z "$cf_cv_$3_soname" && cf_cv_$3_soname=unknown
2486 LIBS="$cf_save_LIBS"
2490 dnl ---------------------------------------------------------------------------
2491 dnl CF_LIB_SUFFIX version: 13 updated: 2003/11/01 16:09:07
2493 dnl Compute the library file-suffix from the given model name
2495 dnl $2 = variable to set
2496 dnl The variable $LIB_SUFFIX, if set, prepends the variable to set.
2497 AC_DEFUN([CF_LIB_SUFFIX],
2499 AC_REQUIRE([CF_SUBST_NCURSES_VERSION])
2501 libtool) $2='.la' ;;
2504 profile) $2='_p.a' ;;
2506 case $cf_cv_system_name in
2507 cygwin*) $2='.dll' ;;
2508 darwin*) $2='.dylib' ;;
2518 test -n "$LIB_SUFFIX" && $2="${LIB_SUFFIX}[$]{$2}"
2520 dnl ---------------------------------------------------------------------------
2521 dnl CF_LIB_TYPE version: 4 updated: 2000/10/20 22:57:49
2523 dnl Compute the string to append to -library from the given model name
2525 dnl $2 = variable to set
2526 dnl The variable $LIB_SUFFIX, if set, prepends the variable to set.
2527 AC_DEFUN([CF_LIB_TYPE],
2536 test -n "$LIB_SUFFIX" && $2="${LIB_SUFFIX}[$]{$2}"
2538 dnl ---------------------------------------------------------------------------
2539 dnl CF_LINK_DATAONLY version: 8 updated: 2006/12/16 12:33:30
2540 dnl ----------------
2541 dnl Some systems have a non-ANSI linker that doesn't pull in modules that have
2542 dnl only data (i.e., no functions), for example NeXT. On those systems we'll
2543 dnl have to provide wrappers for global tables to ensure they're linked
2545 AC_DEFUN([CF_LINK_DATAONLY],
2547 AC_MSG_CHECKING([if data-only library module links])
2548 AC_CACHE_VAL(cf_cv_link_dataonly,[
2550 cat >conftest.$ac_ext <<EOF
2551 #line __oline__ "configure"
2552 int testdata[[3]] = { 123, 456, 789 };
2554 if AC_TRY_EVAL(ac_compile) ; then
2555 mv conftest.o data.o && \
2556 ( $AR $AR_OPTS conftest.a data.o ) 2>&AC_FD_CC 1>/dev/null
2558 rm -f conftest.$ac_ext data.o
2559 cat >conftest.$ac_ext <<EOF
2560 #line __oline__ "configure"
2564 ${cf_cv_main_return:-return}(1); /* I'm told this linker is broken */
2566 extern int testdata[[3]];
2567 return testdata[[0]] == 123
2568 && testdata[[1]] == 456
2569 && testdata[[2]] == 789;
2573 if AC_TRY_EVAL(ac_compile); then
2574 mv conftest.o func.o && \
2575 ( $AR $AR_OPTS conftest.a func.o ) 2>&AC_FD_CC 1>/dev/null
2577 rm -f conftest.$ac_ext func.o
2578 ( eval $RANLIB conftest.a ) 2>&AC_FD_CC >/dev/null
2580 LIBS="conftest.a $LIBS"
2584 extern int testfunc();
2585 ${cf_cv_main_return:-return} (!testfunc());
2588 [cf_cv_link_dataonly=yes],
2589 [cf_cv_link_dataonly=no],
2590 [cf_cv_link_dataonly=unknown])
2593 AC_MSG_RESULT($cf_cv_link_dataonly)
2595 if test "$cf_cv_link_dataonly" = no ; then
2596 AC_DEFINE(BROKEN_LINKER)
2601 dnl ---------------------------------------------------------------------------
2602 dnl CF_LINK_FUNCS version: 7 updated: 2006/12/16 12:33:30
2604 dnl Most Unix systems have both link and symlink, a few don't have symlink.
2605 dnl A few non-Unix systems implement symlink, but not link.
2606 dnl A few non-systems implement neither (or have nonfunctional versions).
2607 AC_DEFUN([CF_LINK_FUNCS],
2613 if test "$cross_compiling" = yes ; then
2618 AC_CACHE_CHECK(if link/symlink functions work,cf_cv_link_funcs,[
2620 for cf_func in link symlink ; do
2622 #include <sys/types.h>
2623 #include <sys/stat.h>
2624 #ifdef HAVE_UNISTD_H
2630 char *src = "config.log";
2631 char *dst = "conftest.chk";
2636 fail = ($cf_func("config.log", "conftest.chk") < 0)
2637 || (stat(dst, &dst_sb) < 0)
2638 || (dst_sb.st_mtime != src_sb.st_mtime);
2644 ${cf_cv_main_return:-return} (fail);
2647 cf_cv_link_funcs="$cf_cv_link_funcs $cf_func"
2648 eval 'ac_cv_func_'$cf_func'=yes'],[
2649 eval 'ac_cv_func_'$cf_func'=no'],[
2650 eval 'ac_cv_func_'$cf_func'=error'])
2652 test -z "$cf_cv_link_funcs" && cf_cv_link_funcs=no
2654 test "$ac_cv_func_link" = yes && AC_DEFINE(HAVE_LINK)
2655 test "$ac_cv_func_symlink" = yes && AC_DEFINE(HAVE_SYMLINK)
2658 dnl ---------------------------------------------------------------------------
2659 dnl CF_MAIN_RETURN version: 1 updated: 2006/12/10 09:51:54
2661 dnl Check if a return from main to the shell actually returns the same exit
2662 dnl code. This is true for almost any POSIX environment.
2664 dnl Some very old environments did not flush stdout, etc., on an exit. That
2665 dnl would be a useful case to test for also.
2666 AC_DEFUN([CF_MAIN_RETURN],
2668 cf_cv_main_return=return
2670 dnl ---------------------------------------------------------------------------
2671 dnl CF_MAKEFLAGS version: 12 updated: 2006/10/21 08:27:03
2673 dnl Some 'make' programs support ${MAKEFLAGS}, some ${MFLAGS}, to pass 'make'
2674 dnl options to lower-levels. It's very useful for "make -n" -- if we have it.
2675 dnl (GNU 'make' does both, something POSIX 'make', which happens to make the
2676 dnl ${MAKEFLAGS} variable incompatible because it adds the assignments :-)
2677 AC_DEFUN([CF_MAKEFLAGS],
2679 AC_CACHE_CHECK(for makeflags variable, cf_cv_makeflags,[
2681 for cf_option in '-${MAKEFLAGS}' '${MFLAGS}'
2683 cat >cf_makeflags.tmp <<CF_EOF
2686 @ echo '.$cf_option'
2688 cf_result=`${MAKE-make} -k -f cf_makeflags.tmp 2>/dev/null | sed -e 's,[[ ]]*$,,'`
2689 case "$cf_result" in
2691 cf_result=`${MAKE-make} -k -f cf_makeflags.tmp CC=cc 2>/dev/null`
2692 case "$cf_result" in
2693 .*CC=*) cf_cv_makeflags=
2695 *) cf_cv_makeflags=$cf_option
2701 *) echo "given option \"$cf_option\", no match \"$cf_result\""
2705 rm -f cf_makeflags.tmp
2708 AC_SUBST(cf_cv_makeflags)
2710 dnl ---------------------------------------------------------------------------
2711 dnl CF_MAKE_TAGS version: 2 updated: 2000/10/04 09:18:40
2713 dnl Generate tags/TAGS targets for makefiles. Do not generate TAGS if we have
2714 dnl a monocase filesystem.
2715 AC_DEFUN([CF_MAKE_TAGS],[
2716 AC_REQUIRE([CF_MIXEDCASE_FILENAMES])
2717 AC_CHECK_PROG(MAKE_LOWER_TAGS, ctags, yes, no)
2719 if test "$cf_cv_mixedcase" = yes ; then
2720 AC_CHECK_PROG(MAKE_UPPER_TAGS, etags, yes, no)
2725 if test "$MAKE_UPPER_TAGS" = yes ; then
2730 AC_SUBST(MAKE_UPPER_TAGS)
2732 if test "$MAKE_LOWER_TAGS" = yes ; then
2737 AC_SUBST(MAKE_LOWER_TAGS)
2739 dnl ---------------------------------------------------------------------------
2740 dnl CF_MANPAGE_FORMAT version: 7 updated: 2003/12/20 19:30:34
2741 dnl -----------------
2742 dnl Option to allow user to override automatic configuration of manpage format.
2743 dnl There are several special cases:
2745 dnl gzip - man checks for, can display gzip'd files
2746 dnl compress - man checks for, can display compressed files
2747 dnl BSDI - files in the cat-directories are suffixed ".0"
2748 dnl formatted - installer should format (put files in cat-directory)
2749 dnl catonly - installer should only format, e.g., for a turnkey system.
2751 dnl There are other configurations which this macro does not test, e.g., HPUX's
2752 dnl compressed manpages (but uncompressed manpages are fine, and HPUX's naming
2753 dnl convention would not match our use).
2754 AC_DEFUN([CF_MANPAGE_FORMAT],
2756 AC_REQUIRE([CF_PATHSEP])
2757 AC_MSG_CHECKING(format of man-pages)
2759 AC_ARG_WITH(manpage-format,
2760 [ --with-manpage-format specify manpage-format: gzip/compress/BSDI/normal and
2761 optionally formatted/catonly, e.g., gzip,formatted],
2762 [MANPAGE_FORMAT=$withval],
2763 [MANPAGE_FORMAT=unknown])
2765 test -z "$MANPAGE_FORMAT" && MANPAGE_FORMAT=unknown
2766 MANPAGE_FORMAT=`echo "$MANPAGE_FORMAT" | sed -e 's/,/ /g'`
2770 case $MANPAGE_FORMAT in
2772 if test -z "$MANPATH" ; then
2773 MANPATH="/usr/man:/usr/share/man"
2776 # look for the 'date' man-page (it's most likely to be installed!)
2782 IFS="${IFS= }"; ac_save_ifs="$IFS"; IFS="${IFS}${PATHSEP}"
2783 for cf_dir in $MANPATH; do
2784 test -z "$cf_dir" && cf_dir=/usr/man
2785 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
2787 cf_test=`echo $cf_name | sed -e 's/*//'`
2788 if test "x$cf_test" = "x$cf_name" ; then
2791 *.gz) MANPAGE_FORMAT="$MANPAGE_FORMAT gzip";;
2792 *.Z) MANPAGE_FORMAT="$MANPAGE_FORMAT compress";;
2793 *.0) MANPAGE_FORMAT="$MANPAGE_FORMAT BSDI";;
2794 *) MANPAGE_FORMAT="$MANPAGE_FORMAT normal";;
2808 # if we found a match in either man* or cat*, stop looking
2809 if test -n "$MANPAGE_FORMAT" ; then
2811 test "$cf_preform" = yes && MANPAGE_FORMAT="$MANPAGE_FORMAT formatted"
2812 test "$cf_catonly" = yes && MANPAGE_FORMAT="$MANPAGE_FORMAT catonly"
2818 test $cf_found=yes && break
2821 # only check the first directory in $MANPATH where we find manpages
2822 if test -n "$MANPAGE_FORMAT" ; then
2826 # if we did not find the example, just assume it is normal
2827 test -z "$MANPAGE_FORMAT" && MANPAGE_FORMAT=normal
2831 for cf_option in $MANPAGE_FORMAT; do
2832 case $cf_option in #(vi
2833 gzip|compress|BSDI|normal|formatted|catonly)
2836 cf_unknown="$cf_unknown $cf_option"
2843 AC_MSG_RESULT($MANPAGE_FORMAT)
2844 if test -n "$cf_unknown" ; then
2845 AC_MSG_WARN(Unexpected manpage-format $cf_unknown)
2848 dnl ---------------------------------------------------------------------------
2849 dnl CF_MANPAGE_RENAMES version: 7 updated: 2005/06/18 18:51:57
2850 dnl ------------------
2851 dnl The Debian people have their own naming convention for manpages. This
2852 dnl option lets us override the name of the file containing renaming, or
2853 dnl disable it altogether.
2854 AC_DEFUN([CF_MANPAGE_RENAMES],
2856 AC_MSG_CHECKING(for manpage renaming)
2858 AC_ARG_WITH(manpage-renames,
2859 [ --with-manpage-renames specify manpage-renaming],
2860 [MANPAGE_RENAMES=$withval],
2861 [MANPAGE_RENAMES=yes])
2863 case ".$MANPAGE_RENAMES" in #(vi
2867 # Debian 'man' program?
2868 if test -f /etc/debian_version ; then
2869 MANPAGE_RENAMES=`cd $srcdir && pwd`/man/man_db.renames
2876 if test "$MANPAGE_RENAMES" != no ; then
2877 if test -f $srcdir/man/$MANPAGE_RENAMES ; then
2878 MANPAGE_RENAMES=`cd $srcdir/man && pwd`/$MANPAGE_RENAMES
2879 elif test ! -f $MANPAGE_RENAMES ; then
2880 AC_MSG_ERROR(not a filename: $MANPAGE_RENAMES)
2883 test ! -d man && mkdir man
2885 # Construct a sed-script to perform renaming within man-pages
2886 if test -n "$MANPAGE_RENAMES" ; then
2887 test ! -d man && mkdir man
2888 sh $srcdir/man/make_sed.sh $MANPAGE_RENAMES >./edit_man.sed
2892 AC_MSG_RESULT($MANPAGE_RENAMES)
2893 AC_SUBST(MANPAGE_RENAMES)
2895 dnl ---------------------------------------------------------------------------
2896 dnl CF_MANPAGE_SYMLINKS version: 4 updated: 2003/12/13 18:01:58
2897 dnl -------------------
2898 dnl Some people expect each tool to make all aliases for manpages in the
2899 dnl man-directory. This accommodates the older, less-capable implementations
2900 dnl of 'man', and is optional.
2901 AC_DEFUN([CF_MANPAGE_SYMLINKS],
2903 AC_MSG_CHECKING(if manpage aliases will be installed)
2905 AC_ARG_WITH(manpage-aliases,
2906 [ --with-manpage-aliases specify manpage-aliases using .so],
2907 [MANPAGE_ALIASES=$withval],
2908 [MANPAGE_ALIASES=yes])
2910 AC_MSG_RESULT($MANPAGE_ALIASES)
2912 if test "$LN_S" = "ln -s"; then
2919 if test "$MANPAGE_ALIASES" = yes ; then
2920 AC_MSG_CHECKING(if manpage symlinks should be used)
2922 AC_ARG_WITH(manpage-symlinks,
2923 [ --with-manpage-symlinks specify manpage-aliases using symlinks],
2924 [MANPAGE_SYMLINKS=$withval],
2925 [MANPAGE_SYMLINKS=$cf_use_symlinks])
2927 if test "$$cf_use_symlinks" = no; then
2928 if test "$MANPAGE_SYMLINKS" = yes ; then
2929 AC_MSG_WARN(cannot make symlinks, will use .so files)
2934 AC_MSG_RESULT($MANPAGE_SYMLINKS)
2938 dnl ---------------------------------------------------------------------------
2939 dnl CF_MANPAGE_TBL version: 3 updated: 2002/01/19 22:51:32
2941 dnl This option causes manpages to be run through tbl(1) to generate tables
2943 AC_DEFUN([CF_MANPAGE_TBL],
2945 AC_MSG_CHECKING(for manpage tbl)
2947 AC_ARG_WITH(manpage-tbl,
2948 [ --with-manpage-tbl specify manpage processing with tbl],
2949 [MANPAGE_TBL=$withval],
2952 AC_MSG_RESULT($MANPAGE_TBL)
2954 dnl ---------------------------------------------------------------------------
2955 dnl CF_MAN_PAGES version: 35 updated: 2007/03/31 11:47:29
2957 dnl Try to determine if the man-pages on the system are compressed, and if
2958 dnl so, what format is used. Use this information to construct a script that
2959 dnl will install man-pages.
2960 AC_DEFUN([CF_MAN_PAGES],
2962 CF_HELP_MESSAGE(Options to Specify How Manpages are Installed:)
2968 if test "$prefix" = "NONE" ; then
2969 cf_prefix="$ac_default_prefix"
2974 case "$MANPAGE_FORMAT" in # (vi
2989 test ! -d man && mkdir man
2993 case "$MANPAGE_FORMAT" in #(vi
2996 cf_compress=compress
3004 cf_edit_man=./edit_man.sh
3005 cf_man_alias=`pwd`/man_alias.sed
3007 cat >$cf_edit_man <<CF_EOF
3009 # this script is generated by the configure-script CF_MAN_PAGES macro.
3014 NCURSES_MAJOR="$NCURSES_MAJOR"
3015 NCURSES_MINOR="$NCURSES_MINOR"
3016 NCURSES_PATCH="$NCURSES_PATCH"
3018 NCURSES_OSPEED="$NCURSES_OSPEED"
3019 TERMINFO="$TERMINFO"
3021 MKDIRS="sh `cd $srcdir && pwd`/mkdirs.sh"
3024 INSTALL_DATA="$INSTALL_DATA"
3026 transform="$program_transform_name"
3028 TMP=\${TMPDIR-/tmp}/man\$\$
3029 trap "rm -f \$TMP" 0 1 2 5 15
3041 top_srcdir=\[$]srcdir/..
3044 if test "\$form" = normal ; then
3045 if test "$cf_format" = yes ; then
3046 if test "$cf_inboth" = no ; then
3047 sh \[$]0 format \$verb \$mandir \$srcdir \[$]*
3051 cf_subdir=\$mandir/man
3052 cf_tables=$MANPAGE_TBL
3054 cf_subdir=\$mandir/cat
3058 # process the list of source-files
3061 *.orig|*.rej) ;; #(vi
3063 section=\`expr "\$i" : '.*\\.\\([[0-9]]\\)[[xm]]*'\`;
3064 if test \$verb = installing ; then
3065 if test ! -d \$cf_subdir\${section} ; then
3066 \$MKDIRS \$cf_subdir\$section
3070 # replace variables in man page
3071 if test ! -f $cf_man_alias ; then
3072 cat >>$cf_man_alias <<-CF_EOF2
3073 s,@DATADIR@,\$datadir,g
3074 s,@TERMINFO@,\$TERMINFO,g
3075 s,@NCURSES_MAJOR@,\$NCURSES_MAJOR,g
3076 s,@NCURSES_MINOR@,\$NCURSES_MINOR,g
3077 s,@NCURSES_PATCH@,\$NCURSES_PATCH,g
3078 s,@NCURSES_OSPEED@,\$NCURSES_OSPEED,g
3083 cf_NAME=`echo "$cf_name" | sed y%abcdefghijklmnopqrstuvwxyz./-%ABCDEFGHIJKLMNOPQRSTUVWXYZ___%`
3084 cf_name=`echo $cf_name|sed "$program_transform_name"`
3085 cat >>$cf_edit_man <<-CF_EOF
3086 s,@$cf_NAME@,$cf_name,
3090 cat >>$cf_edit_man <<CF_EOF
3092 echo "...made $cf_man_alias"
3096 cf_source=\`basename \$i\`
3098 test ! -f \$inalias && inalias="\$srcdir/\$inalias"
3099 if test ! -f \$inalias ; then
3100 echo .. skipped \$cf_source
3105 if test "$MANPAGE_ALIASES" != no ; then
3106 cat >>$cf_edit_man <<CF_EOF
3107 aliases=\`sed -f \$top_srcdir/man/manlinks.sed \$inalias |sed -f $cf_man_alias | sort -u\`
3111 if test "$MANPAGE_RENAMES" = no ; then
3112 cat >>$cf_edit_man <<CF_EOF
3113 # perform program transformations for section 1 man pages
3114 if test \$section = 1 ; then
3115 cf_target=\$cf_subdir\${section}/\`echo \$cf_source|sed "\${transform}"\`
3117 cf_target=\$cf_subdir\${section}/\$cf_source
3121 cat >>$cf_edit_man <<CF_EOF
3122 cf_target=\`grep "^\$cf_source" $MANPAGE_RENAMES | $AWK '{print \[$]2}'\`
3123 if test -z "\$cf_target" ; then
3124 echo '? missing rename for '\$cf_source
3125 cf_target="\$cf_source"
3127 cf_target="\$cf_subdir\${section}/\${cf_target}"
3132 cat >>$cf_edit_man <<CF_EOF
3133 sed -f $cf_man_alias \\
3136 if test -f $MANPAGE_RENAMES ; then
3137 cat >>$cf_edit_man <<CF_EOF
3138 < \$i | sed -f `pwd`/edit_man.sed >\$TMP
3141 cat >>$cf_edit_man <<CF_EOF
3146 cat >>$cf_edit_man <<CF_EOF
3147 if test \$cf_tables = yes ; then
3148 tbl \$TMP >\$TMP.out
3153 if test $with_curses_h != yes ; then
3154 cat >>$cf_edit_man <<CF_EOF
3155 sed -e "/\#[ ]*include/s,curses.h,ncurses.h," < \$TMP >\$TMP.out
3160 cat >>$cf_edit_man <<CF_EOF
3161 if test \$form = format ; then
3162 nroff -man \$TMP >\$TMP.out
3167 if test -n "$cf_compress" ; then
3168 cat >>$cf_edit_man <<CF_EOF
3169 if test \$verb = installing ; then
3170 if ( $cf_compress -f \$TMP )
3172 mv \$TMP.$cf_so_strip \$TMP
3175 cf_target="\$cf_target.$cf_so_strip"
3179 case "$MANPAGE_FORMAT" in #(vi
3181 cat >>$cf_edit_man <<CF_EOF
3182 if test \$form = format ; then
3183 # BSDI installs only .0 suffixes in the cat directories
3184 cf_target="\`echo \$cf_target|sed -e 's/\.[[1-9]]\+[[a-z]]*/.0/'\`"
3190 cat >>$cf_edit_man <<CF_EOF
3191 suffix=\`basename \$cf_target | sed -e 's%^[[^.]]*%%'\`
3192 if test \$verb = installing ; then
3193 echo \$verb \$cf_target
3194 \$INSTALL_DATA \$TMP \$cf_target
3195 test -d \$cf_subdir\${section} &&
3196 test -n "\$aliases" && (
3197 cd \$cf_subdir\${section} && (
3198 cf_source=\`echo \$cf_target |sed -e 's%^.*/\([[^/]][[^/]]*/[[^/]][[^/]]*$\)%\1%'\`
3199 test -n "$cf_so_strip" && cf_source=\`echo \$cf_source |sed -e 's%\.$cf_so_strip\$%%'\`
3200 cf_target=\`basename \$cf_target\`
3201 for cf_alias in \$aliases
3203 if test \$section = 1 ; then
3204 cf_alias=\`echo \$cf_alias|sed "\${transform}"\`
3207 if test "$MANPAGE_SYMLINKS" = yes ; then
3208 if test -f \$cf_alias\${suffix} ; then
3209 if ( cmp -s \$cf_target \$cf_alias\${suffix} )
3214 echo .. \$verb alias \$cf_alias\${suffix}
3215 rm -f \$cf_alias\${suffix}
3216 $LN_S \$cf_target \$cf_alias\${suffix}
3217 elif test "\$cf_target" != "\$cf_alias\${suffix}" ; then
3218 echo ".so \$cf_source" >\$TMP
3220 if test -n "$cf_compress" ; then
3221 cat >>$cf_edit_man <<CF_EOF
3222 if test -n "$cf_so_strip" ; then
3223 $cf_compress -f \$TMP
3224 mv \$TMP.$cf_so_strip \$TMP
3228 cat >>$cf_edit_man <<CF_EOF
3229 echo .. \$verb alias \$cf_alias\${suffix}
3230 rm -f \$cf_alias\${suffix}
3231 \$INSTALL_DATA \$TMP \$cf_alias\${suffix}
3236 elif test \$verb = removing ; then
3237 test -f \$cf_target && (
3238 echo \$verb \$cf_target
3241 test -d \$cf_subdir\${section} &&
3242 test -n "\$aliases" && (
3243 cd \$cf_subdir\${section} && (
3244 for cf_alias in \$aliases
3246 if test \$section = 1 ; then
3247 cf_alias=\`echo \$cf_alias|sed "\${transform}"\`
3250 echo .. \$verb alias \$cf_alias\${suffix}
3251 rm -f \$cf_alias\${suffix}
3263 if test $cf_inboth = yes ; then
3264 if test \$form != format ; then
3265 sh \[$]0 format \$verb \$mandir \$srcdir \[$]*
3271 chmod 755 $cf_edit_man
3274 dnl ---------------------------------------------------------------------------
3275 dnl CF_MATH_LIB version: 5 updated: 2000/05/28 01:39:10
3277 dnl Checks for libraries. At least one UNIX system, Apple Macintosh
3278 dnl Rhapsody 5.5, does not have -lm. We cannot use the simpler
3279 dnl AC_CHECK_LIB(m,sin), because that fails for C++.
3280 AC_DEFUN([CF_MATH_LIB],
3282 AC_CACHE_CHECK(if -lm needed for math functions,
3288 [double x = rand(); printf("result = %g\n", ]ifelse($2,,sin(x),$2)[)],
3289 [cf_cv_need_libm=no],
3290 [cf_cv_need_libm=yes])])
3291 if test "$cf_cv_need_libm" = yes
3298 dnl ---------------------------------------------------------------------------
3299 dnl CF_MIXEDCASE_FILENAMES version: 3 updated: 2003/09/20 17:07:55
3300 dnl ----------------------
3301 dnl Check if the file-system supports mixed-case filenames. If we're able to
3302 dnl create a lowercase name and see it as uppercase, it doesn't support that.
3303 AC_DEFUN([CF_MIXEDCASE_FILENAMES],
3305 AC_CACHE_CHECK(if filesystem supports mixed-case filenames,cf_cv_mixedcase,[
3306 if test "$cross_compiling" = yes ; then
3307 case $target_alias in #(vi
3308 *-os2-emx*|*-msdosdjgpp*|*-cygwin*|*-mingw32*|*-uwin*) #(vi
3316 rm -f conftest CONFTEST
3318 if test -f CONFTEST ; then
3323 rm -f conftest CONFTEST
3326 test "$cf_cv_mixedcase" = yes && AC_DEFINE(MIXEDCASE_FILENAMES)
3328 dnl ---------------------------------------------------------------------------
3329 dnl CF_MKSTEMP version: 5 updated: 2006/12/16 12:33:30
3331 dnl Check for a working mkstemp. This creates two files, checks that they are
3332 dnl successfully created and distinct (AmigaOS apparently fails on the last).
3333 AC_DEFUN([CF_MKSTEMP],[
3334 AC_CACHE_CHECK(for working mkstemp, cf_cv_func_mkstemp,[
3337 #include <sys/types.h>
3341 #include <sys/stat.h>
3344 char *tmpl = "conftestXXXXXX";
3352 for (n = 0; n < 2; ++n) {
3353 strcpy(name[n], tmpl);
3354 if ((fd = mkstemp(name[n])) >= 0) {
3355 if (!strcmp(name[n], tmpl)
3356 || stat(name[n], &sb) != 0
3357 || (sb.st_mode & S_IFMT) != S_IFREG
3358 || (sb.st_mode & 077) != 0) {
3365 && !strcmp(name[0], name[1]))
3367 ${cf_cv_main_return:-return}(result);
3369 ],[cf_cv_func_mkstemp=yes
3370 ],[cf_cv_func_mkstemp=no
3371 ],[AC_CHECK_FUNC(mkstemp)
3374 if test "$cf_cv_func_mkstemp" = yes ; then
3375 AC_DEFINE(HAVE_MKSTEMP)
3378 dnl ---------------------------------------------------------------------------
3379 dnl CF_MSG_LOG version: 4 updated: 2007/07/29 09:55:12
3381 dnl Write a debug message to config.log, along with the line number in the
3382 dnl configure script.
3383 AC_DEFUN([CF_MSG_LOG],[
3384 echo "${as_me-configure}:__oline__: testing $* ..." 1>&AC_FD_CC
3386 dnl ---------------------------------------------------------------------------
3387 dnl CF_NCURSES_ABI_6 version: 1 updated: 2005/09/17 18:42:49
3388 dnl ----------------
3389 dnl Set ncurses' ABI to 6 unless overridden by explicit configure option, and
3390 dnl warn about this.
3391 AC_DEFUN([CF_NCURSES_ABI_6],[
3392 if test "${with_abi_version+set}" != set; then
3393 case $cf_cv_rel_version in
3395 cf_cv_rel_version=6.0
3397 AC_MSG_WARN(Overriding ABI version to $cf_cv_abi_version)
3402 dnl ---------------------------------------------------------------------------
3403 dnl CF_NO_LEAKS_OPTION version: 4 updated: 2006/12/16 14:24:05
3404 dnl ------------------
3405 dnl see CF_WITH_NO_LEAKS
3406 AC_DEFUN([CF_NO_LEAKS_OPTION],[
3407 AC_MSG_CHECKING(if you want to use $1 for testing)
3410 [AC_DEFINE($3)ifelse([$4],,[
3413 : ${with_cflags:=-g}
3414 : ${with_no_leaks:=yes}
3417 AC_MSG_RESULT(${with_$1:-no})
3419 case .$with_cflags in #(vi
3421 case .$CFLAGS in #(vi
3431 dnl ---------------------------------------------------------------------------
3432 dnl CF_NUMBER_SYNTAX version: 1 updated: 2003/09/20 18:12:49
3433 dnl ----------------
3434 dnl Check if the given variable is a number. If not, report an error.
3435 dnl $1 is the variable
3436 dnl $2 is the message
3437 AC_DEFUN([CF_NUMBER_SYNTAX],[
3438 if test -n "$1" ; then
3443 AC_MSG_ERROR($2 is not a number: $1)
3447 AC_MSG_ERROR($2 value is empty)
3450 dnl ---------------------------------------------------------------------------
3451 dnl CF_OBJ_SUBDIR version: 4 updated: 2002/02/23 20:38:31
3453 dnl Compute the object-directory name from the given model name
3454 AC_DEFUN([CF_OBJ_SUBDIR],
3457 libtool) $2='obj_lo' ;;
3458 normal) $2='objects' ;;
3459 debug) $2='obj_g' ;;
3460 profile) $2='obj_p' ;;
3462 case $cf_cv_system_name in #(vi
3470 dnl ---------------------------------------------------------------------------
3471 dnl CF_PATHSEP version: 3 updated: 2001/01/12 01:23:53
3473 dnl Provide a value for the $PATH and similar separator
3474 AC_DEFUN([CF_PATHSEP],
3476 case $cf_cv_system_name in
3477 os2*) PATHSEP=';' ;;
3480 ifelse($1,,,[$1=$PATHSEP])
3483 dnl ---------------------------------------------------------------------------
3484 dnl CF_PATH_SYNTAX version: 12 updated: 2008/03/23 14:45:59
3486 dnl Check the argument to see that it looks like a pathname. Rewrite it if it
3487 dnl begins with one of the prefix/exec_prefix variables, and then again if the
3488 dnl result begins with 'NONE'. This is necessary to work around autoconf's
3489 dnl delayed evaluation of those symbols.
3490 AC_DEFUN([CF_PATH_SYNTAX],[
3491 if test "x$prefix" != xNONE; then
3492 cf_path_syntax="$prefix"
3494 cf_path_syntax="$ac_default_prefix"
3497 case ".[$]$1" in #(vi
3498 .\[$]\(*\)*|.\'*\'*) #(vi
3502 .[[a-zA-Z]]:[[\\/]]*) #(vi OS/2 EMX
3504 .\[$]{*prefix}*) #(vi
3506 case ".[$]$1" in #(vi
3508 $1=`echo [$]$1 | sed -e s%NONE%$cf_path_syntax%`
3513 $1=`echo [$]$1 | sed -e s%NONE%$cf_path_syntax%`
3516 ifelse($2,,[AC_MSG_ERROR([expected a pathname, not \"[$]$1\"])],$2)
3520 dnl ---------------------------------------------------------------------------
3521 dnl CF_POSIX_C_SOURCE version: 6 updated: 2005/07/14 20:25:10
3522 dnl -----------------
3523 dnl Define _POSIX_C_SOURCE to the given level, and _POSIX_SOURCE if needed.
3525 dnl POSIX.1-1990 _POSIX_SOURCE
3526 dnl POSIX.1-1990 and _POSIX_SOURCE and
3527 dnl POSIX.2-1992 C-Language _POSIX_C_SOURCE=2
3529 dnl POSIX.1b-1993 _POSIX_C_SOURCE=199309L
3530 dnl POSIX.1c-1996 _POSIX_C_SOURCE=199506L
3531 dnl X/Open 2000 _POSIX_C_SOURCE=200112L
3534 dnl $1 is the nominal value for _POSIX_C_SOURCE
3535 AC_DEFUN([CF_POSIX_C_SOURCE],
3537 cf_POSIX_C_SOURCE=ifelse($1,,199506L,$1)
3539 cf_save_CFLAGS="$CFLAGS"
3540 cf_save_CPPFLAGS="$CPPFLAGS"
3542 CF_REMOVE_DEFINE(cf_trim_CFLAGS,$cf_save_CFLAGS,_POSIX_C_SOURCE)
3543 CF_REMOVE_DEFINE(cf_trim_CPPFLAGS,$cf_save_CPPFLAGS,_POSIX_C_SOURCE)
3545 AC_CACHE_CHECK(if we should define _POSIX_C_SOURCE,cf_cv_posix_c_source,[
3546 CF_MSG_LOG(if the symbol is already defined go no further)
3547 AC_TRY_COMPILE([#include <sys/types.h>],[
3548 #ifndef _POSIX_C_SOURCE
3551 [cf_cv_posix_c_source=no],
3552 [cf_want_posix_source=no
3553 case .$cf_POSIX_C_SOURCE in #(vi
3555 cf_cv_posix_c_source="-D_POSIX_C_SOURCE=$cf_POSIX_C_SOURCE"
3558 cf_cv_posix_c_source="-D_POSIX_C_SOURCE=$cf_POSIX_C_SOURCE"
3559 cf_want_posix_source=yes
3562 cf_want_posix_source=yes
3565 if test "$cf_want_posix_source" = yes ; then
3566 AC_TRY_COMPILE([#include <sys/types.h>],[
3567 #ifdef _POSIX_SOURCE
3570 cf_cv_posix_c_source="$cf_cv_posix_c_source -D_POSIX_SOURCE")
3572 CF_MSG_LOG(ifdef from value $cf_POSIX_C_SOURCE)
3573 CFLAGS="$cf_trim_CFLAGS"
3574 CPPFLAGS="$cf_trim_CPPFLAGS $cf_cv_posix_c_source"
3575 CF_MSG_LOG(if the second compile does not leave our definition intact error)
3576 AC_TRY_COMPILE([#include <sys/types.h>],[
3577 #ifndef _POSIX_C_SOURCE
3580 [cf_cv_posix_c_source=no])
3581 CFLAGS="$cf_save_CFLAGS"
3582 CPPFLAGS="$cf_save_CPPFLAGS"
3586 if test "$cf_cv_posix_c_source" != no ; then
3587 CFLAGS="$cf_trim_CFLAGS"
3588 CPPFLAGS="$cf_trim_CPPFLAGS"
3589 if test "$cf_cv_cc_u_d_options" = yes ; then
3590 cf_temp_posix_c_source=`echo "$cf_cv_posix_c_source" | \
3591 sed -e 's/-D/-U/g' -e 's/=[[^ ]]*//g'`
3592 CPPFLAGS="$CPPFLAGS $cf_temp_posix_c_source"
3594 CPPFLAGS="$CPPFLAGS $cf_cv_posix_c_source"
3598 dnl ---------------------------------------------------------------------------
3599 dnl CF_PREDEFINE version: 1 updated: 2003/07/26 17:53:56
3601 dnl Add definitions to CPPFLAGS to ensure they're predefined for all compiles.
3603 dnl $1 = symbol to test
3604 dnl $2 = value (if any) to use for a predefinition
3605 AC_DEFUN([CF_PREDEFINE],
3607 AC_MSG_CHECKING(if we must define $1)
3608 AC_TRY_COMPILE([#include <sys/types.h>
3612 #endif],[cf_result=no],[cf_result=yes])
3613 AC_MSG_RESULT($cf_result)
3615 if test "$cf_result" = yes ; then
3616 CPPFLAGS="$CPPFLAGS ifelse($2,,-D$1,[-D$1=$2])"
3617 elif test "x$2" != "x" ; then
3618 AC_MSG_CHECKING(checking for compatible value versus $2)
3619 AC_TRY_COMPILE([#include <sys/types.h>
3623 #endif],[cf_result=yes],[cf_result=no])
3624 AC_MSG_RESULT($cf_result)
3625 if test "$cf_result" = no ; then
3626 # perhaps we can override it - try...
3627 CPPFLAGS="$CPPFLAGS -D$1=$2"
3631 dnl ---------------------------------------------------------------------------
3632 dnl CF_PRG_RULES version: 1 updated: 2006/06/03 11:45:08
3634 dnl Append definitions and rules for the given programs to the subdirectory
3635 dnl Makefiles, and the recursion rule for the top-level Makefile.
3638 dnl $1 = script to run
3639 dnl $2 = list of subdirectories
3643 AC_DEFUN([CF_PRG_RULES],
3647 if test ! -d $srcdir/$cf_dir; then
3649 elif test -f $srcdir/$cf_dir/programs; then
3650 $AWK -f $1 $srcdir/$cf_dir/programs >>$cf_dir/Makefile
3655 dnl ---------------------------------------------------------------------------
3656 dnl CF_PROG_AWK version: 1 updated: 2006/09/16 11:40:59
3658 dnl Check for awk, ensure that the check found something.
3659 AC_DEFUN([CF_PROG_AWK],
3662 test -z "$AWK" && AC_MSG_ERROR(No awk program found)
3664 dnl ---------------------------------------------------------------------------
3665 dnl CF_PROG_CC_C_O version: 2 updated: 2006/12/16 15:55:46
3667 dnl Analogous to AC_PROG_CC_C_O, but more useful: tests only $CC, ensures that
3668 dnl the output file can be renamed, and allows for a shell variable that can
3669 dnl be used later. The parameter is either CC or CXX. The result is the
3671 dnl $cf_cv_prog_CC_c_o
3672 dnl $cf_cv_prog_CXX_c_o
3673 AC_DEFUN([CF_PROG_CC_C_O],
3674 [AC_REQUIRE([AC_PROG_CC])dnl
3675 AC_MSG_CHECKING([whether [$]$1 understands -c and -o together])
3676 AC_CACHE_VAL(cf_cv_prog_$1_c_o,
3678 cat > conftest.$ac_ext <<CF_EOF
3682 ${cf_cv_main_return:-return}(0);
3685 # We do the test twice because some compilers refuse to overwrite an
3686 # existing .o file with -o, though they will create one.
3687 ac_try='[$]$1 -c conftest.$ac_ext -o conftest2.$ac_objext >&AC_FD_CC'
3688 if AC_TRY_EVAL(ac_try) &&
3689 test -f conftest2.$ac_objext && AC_TRY_EVAL(ac_try);
3691 eval cf_cv_prog_$1_c_o=yes
3693 eval cf_cv_prog_$1_c_o=no
3697 if test $cf_cv_prog_$1_c_o = yes; then
3698 AC_MSG_RESULT([yes])
3703 dnl ---------------------------------------------------------------------------
3704 dnl CF_PROG_CC_U_D version: 1 updated: 2005/07/14 16:59:30
3706 dnl Check if C (preprocessor) -U and -D options are processed in the order
3707 dnl given rather than by type of option. Some compilers insist on apply all
3708 dnl of the -U options after all of the -D options. Others allow mixing them,
3709 dnl and may predefine symbols that conflict with those we define.
3710 AC_DEFUN([CF_PROG_CC_U_D],
3712 AC_CACHE_CHECK(if $CC -U and -D options work together,cf_cv_cc_u_d_options,[
3713 cf_save_CPPFLAGS="$CPPFLAGS"
3714 CPPFLAGS="-UU_D_OPTIONS -DU_D_OPTIONS -DD_U_OPTIONS -UD_U_OPTIONS"
3717 make an undefined-error
3720 make a defined-error
3723 cf_cv_cc_u_d_options=yes],[
3724 cf_cv_cc_u_d_options=no])
3725 CPPFLAGS="$cf_save_CPPFLAGS"
3728 dnl ---------------------------------------------------------------------------
3729 dnl CF_PROG_EGREP version: 1 updated: 2006/09/16 11:40:59
3731 dnl AC_PROG_EGREP was introduced in autoconf 2.53.
3732 dnl This macro adds a check to ensure the script found something.
3733 AC_DEFUN([CF_PROG_EGREP],
3734 [AC_CACHE_CHECK([for egrep], [ac_cv_prog_egrep],
3735 [if echo a | (grep -E '(a|b)') >/dev/null 2>&1
3736 then ac_cv_prog_egrep='grep -E'
3737 else ac_cv_prog_egrep='egrep'
3739 EGREP=$ac_cv_prog_egrep
3741 test -z "$EGREP" && AC_MSG_ERROR(No egrep program found)
3743 dnl ---------------------------------------------------------------------------
3744 dnl CF_PROG_EXT version: 10 updated: 2004/01/03 19:28:18
3746 dnl Compute $PROG_EXT, used for non-Unix ports, such as OS/2 EMX.
3747 AC_DEFUN([CF_PROG_EXT],
3749 AC_REQUIRE([CF_CHECK_CACHE])
3750 case $cf_cv_system_name in
3752 CFLAGS="$CFLAGS -Zmt"
3753 CPPFLAGS="$CPPFLAGS -D__ST_MT_ERRNO__"
3754 CXXFLAGS="$CXXFLAGS -Zmt"
3755 # autoconf's macro sets -Zexe and suffix both, which conflict:w
3756 LDFLAGS="$LDFLAGS -Zmt -Zcrtdll"
3766 test -n "$PROG_EXT" && AC_DEFINE_UNQUOTED(PROG_EXT,"$PROG_EXT")
3768 dnl ---------------------------------------------------------------------------
3769 dnl CF_PROG_INSTALL version: 5 updated: 2002/12/21 22:46:07
3771 dnl Force $INSTALL to be an absolute-path. Otherwise, edit_man.sh and the
3772 dnl misc/tabset install won't work properly. Usually this happens only when
3773 dnl using the fallback mkinstalldirs script
3774 AC_DEFUN([CF_PROG_INSTALL],
3780 CF_DIRNAME(cf_dir,$INSTALL)
3781 test -z "$cf_dir" && cf_dir=.
3782 INSTALL=`cd $cf_dir && pwd`/`echo $INSTALL | sed -e 's%^.*/%%'`
3786 dnl ---------------------------------------------------------------------------
3787 dnl CF_PROG_LDCONFIG version: 1 updated: 2003/09/20 17:07:55
3788 dnl ----------------
3789 dnl Check for ldconfig, needed to fixup shared libraries that would be built
3790 dnl and then used in the install.
3791 AC_DEFUN([CF_PROG_LDCONFIG],[
3792 if test "$cross_compiling" = yes ; then
3795 case "$cf_cv_system_name" in #(vi
3797 test -z "$LDCONFIG" && LDCONFIG="/sbin/ldconfig -R"
3799 *) LDPATH=$PATH:/sbin:/usr/sbin
3800 AC_PATH_PROG(LDCONFIG,ldconfig,,$LDPATH)
3806 dnl ---------------------------------------------------------------------------
3807 dnl CF_PROG_LINT version: 1 updated: 2006/09/16 11:40:59
3809 AC_DEFUN([CF_PROG_LINT],
3811 AC_CHECK_PROGS(LINT, tdlint lint alint)
3814 dnl ---------------------------------------------------------------------------
3815 dnl CF_REGEX version: 3 updated: 1997/11/01 14:26:01
3817 dnl Attempt to determine if we've got one of the flavors of regular-expression
3818 dnl code that we can support.
3819 AC_DEFUN([CF_REGEX],
3821 AC_MSG_CHECKING([for regular-expression headers])
3822 AC_CACHE_VAL(cf_cv_regex,[
3823 AC_TRY_LINK([#include <sys/types.h>
3824 #include <regex.h>],[
3826 int x = regcomp(p, "", 0);
3827 int y = regexec(p, "", 0, 0, 0);
3829 ],[cf_cv_regex="regex.h"],[
3830 AC_TRY_LINK([#include <regexp.h>],[
3831 char *p = compile("", "", "", 0);
3832 int x = step("", "");
3833 ],[cf_cv_regex="regexp.h"],[
3834 cf_save_LIBS="$LIBS"
3836 AC_TRY_LINK([#include <regexpr.h>],[
3837 char *p = compile("", "", "");
3838 int x = step("", "");
3839 ],[cf_cv_regex="regexpr.h"],[LIBS="$cf_save_LIBS"])])])
3841 AC_MSG_RESULT($cf_cv_regex)
3842 case $cf_cv_regex in
3843 regex.h) AC_DEFINE(HAVE_REGEX_H_FUNCS) ;;
3844 regexp.h) AC_DEFINE(HAVE_REGEXP_H_FUNCS) ;;
3845 regexpr.h) AC_DEFINE(HAVE_REGEXPR_H_FUNCS) ;;
3848 dnl ---------------------------------------------------------------------------
3849 dnl CF_REMOVE_DEFINE version: 2 updated: 2005/07/09 16:12:18
3850 dnl ----------------
3851 dnl Remove all -U and -D options that refer to the given symbol from a list
3852 dnl of C compiler options. This works around the problem that not all
3853 dnl compilers process -U and -D options from left-to-right, so a -U option
3854 dnl cannot be used to cancel the effect of a preceding -D option.
3856 dnl $1 = target (which could be the same as the source variable)
3857 dnl $2 = source (including '$')
3858 dnl $3 = symbol to remove
3859 define([CF_REMOVE_DEFINE],
3861 # remove $3 symbol from $2
3863 sed -e 's/-[[UD]]$3\(=[[^ ]]*\)\?[[ ]]/ /g' \
3864 -e 's/-[[UD]]$3\(=[[^ ]]*\)\?[$]//g'`
3866 dnl ---------------------------------------------------------------------------
3867 dnl CF_REMOVE_LIB version: 1 updated: 2007/02/17 14:11:52
3869 dnl Remove the given library from the symbol
3871 dnl $1 = target (which could be the same as the source variable)
3872 dnl $2 = source (including '$')
3873 dnl $3 = library to remove
3874 define([CF_REMOVE_LIB],
3876 # remove $3 library from $2
3877 $1=`echo "$2" | sed -e 's/-l$3[[ ]]//g' -e 's/-l$3[$]//'`
3879 dnl ---------------------------------------------------------------------------
3880 dnl CF_RPATH_HACK version: 3 updated: 2007/12/01 11:14:13
3882 AC_DEFUN([CF_RPATH_HACK],
3884 AC_REQUIRE([CF_SHARED_OPTS])
3885 AC_MSG_CHECKING(for updated LDFLAGS)
3886 if test -n "$LDFLAGS" ; then
3887 AC_MSG_RESULT(maybe)
3888 CF_VERBOSE(...checking LDFLAGS $LDFLAGS)
3889 CF_VERBOSE(...checking EXTRA_LDFLAGS $EXTRA_LDFLAGS)
3890 case "$EXTRA_LDFLAGS" in #(vi
3892 cf_rpath_hack="-Wl,-rpath,"
3904 if test -n "$cf_rpath_hack" ; then
3906 for cf_rpath_src in $LDFLAGS
3908 CF_VERBOSE(Filtering $cf_rpath_src)
3909 case $cf_rpath_src in #(vi
3911 if test "$cf_rpath_hack" = "-R " ; then
3912 cf_rpath_tmp=`echo "$cf_rpath_src" |sed -e 's%-L%-R %'`
3914 cf_rpath_tmp=`echo "$cf_rpath_src" |sed -e s%-L%$cf_rpath_hack%`
3916 CF_VERBOSE(...Filter $cf_rpath_tmp)
3917 EXTRA_LDFLAGS="$cf_rpath_tmp $EXTRA_LDFLAGS"
3920 cf_rpath_dst="$cf_rpath_dst $cf_rpath_src"
3924 LDFLAGS=$cf_rpath_dst
3925 CF_VERBOSE(...checked LDFLAGS $LDFLAGS)
3926 CF_VERBOSE(...checked EXTRA_LDFLAGS $EXTRA_LDFLAGS)
3932 dnl ---------------------------------------------------------------------------
3933 dnl CF_SHARED_OPTS version: 48 updated: 2008/06/14 15:08:17
3936 dnl Attempt to determine the appropriate CC/LD options for creating a shared
3939 dnl Note: ${LOCAL_LDFLAGS} is used to link executables that will run within the
3940 dnl build-tree, i.e., by making use of the libraries that are compiled in ../lib
3941 dnl We avoid compiling-in a ../lib path for the shared library since that can
3942 dnl lead to unexpected results at runtime.
3943 dnl ${LOCAL_LDFLAGS2} has the same intention but assumes that the shared libraries
3944 dnl are compiled in ../../lib
3946 dnl The variable 'cf_cv_do_symlinks' is used to control whether we configure
3947 dnl to install symbolic links to the rel/abi versions of shared libraries.
3949 dnl The variable 'cf_cv_shlib_version' controls whether we use the rel or abi
3950 dnl version when making symbolic links.
3952 dnl The variable 'cf_cv_shlib_version_infix' controls whether shared library
3953 dnl version numbers are infix (ex: libncurses.<ver>.dylib) or postfix
3954 dnl (ex: libncurses.so.<ver>).
3956 dnl Some loaders leave 'so_locations' lying around. It's nice to clean up.
3957 AC_DEFUN([CF_SHARED_OPTS],
3959 AC_REQUIRE([CF_SUBST_NCURSES_VERSION])
3963 INSTALL_LIB="-m 644"
3965 cf_cv_do_symlinks=no
3967 AC_MSG_CHECKING(if release/abi version should be used for shared libs)
3968 AC_ARG_WITH(shlib-version,
3969 [ --with-shlib-version=X Specify rel or abi version for shared libs],
3970 [test -z "$withval" && withval=auto
3971 case $withval in #(vi
3973 cf_cv_shlib_version=auto
3975 rel|abi|auto|no) #(vi
3976 cf_cv_shlib_version=$withval
3979 AC_MSG_ERROR([option value must be one of: rel, abi, auto or no])
3982 ],[cf_cv_shlib_version=auto])
3983 AC_MSG_RESULT($cf_cv_shlib_version)
3987 # Some less-capable ports of gcc support only -fpic
3989 if test "$GCC" = yes
3991 AC_MSG_CHECKING(which $CC option to use)
3992 cf_save_CFLAGS="$CFLAGS"
3993 for CC_SHARED_OPTS in -fPIC -fpic ''
3995 CFLAGS="$cf_save_CFLAGS $CC_SHARED_OPTS"
3996 AC_TRY_COMPILE([#include <stdio.h>],[int x = 1],[break],[])
3998 AC_MSG_RESULT($CC_SHARED_OPTS)
3999 CFLAGS="$cf_save_CFLAGS"
4002 cf_cv_shlib_version_infix=no
4004 case $cf_cv_system_name in
4006 MK_SHARED_LIB='${CC} ${CFLAGS} -o $[@] -Xlinker -soname=`basename $[@]` -nostart -e 0'
4010 MK_SHARED_LIB='sh ../mk_shared_lib.sh [$]@ [$]{CC} [$]{CFLAGS}'
4011 cf_cv_shlib_version=cygdll
4012 cf_cv_shlib_version_infix=cygdll
4013 cat >mk_shared_lib.sh <<-CF_EOF
4016 IMPORT_LIB=\`echo "\[$]1" | sed -e 's/cyg/lib/' -e 's/[[0-9]]*\.dll[$]/.dll.a/'\`
4019 Linking shared library
4020 ** SHARED_LIB \[$]SHARED_LIB
4021 ** IMPORT_LIB \[$]IMPORT_LIB
4023 exec \[$]* -shared -Wl,--out-implib=../lib/\[$]{IMPORT_LIB} -Wl,--export-all-symbols -o ../lib/\[$]{SHARED_LIB}
4025 chmod +x mk_shared_lib.sh
4028 EXTRA_CFLAGS="-no-cpp-precomp"
4029 CC_SHARED_OPTS="-dynamic"
4030 MK_SHARED_LIB='${CC} ${CFLAGS} -dynamiclib -install_name ${libdir}/`basename $[@]` -compatibility_version ${ABI_VERSION} -current_version ${ABI_VERSION} -o $[@]'
4031 test "$cf_cv_shlib_version" = auto && cf_cv_shlib_version=abi
4032 cf_cv_shlib_version_infix=yes
4033 AC_CACHE_CHECK([if ld -search_paths_first works], cf_cv_ldflags_search_paths_first, [
4034 cf_save_LDFLAGS=$LDFLAGS
4035 LDFLAGS="$LDFLAGS -Wl,-search_paths_first"
4036 AC_TRY_LINK(, [int i;], cf_cv_ldflags_search_paths_first=yes, cf_cv_ldflags_search_paths_first=no)
4037 LDFLAGS=$cf_save_LDFLAGS])
4038 if test $cf_cv_ldflags_search_paths_first = yes; then
4039 LDFLAGS="$LDFLAGS -Wl,-search_paths_first"
4043 # (tested with gcc 2.7.2 -- I don't have c89)
4044 if test "$GCC" = yes; then
4045 LD_SHARED_OPTS='-Xlinker +b -Xlinker ${libdir}'
4048 LD_SHARED_OPTS='-Wl,+b,${libdir}'
4050 MK_SHARED_LIB='${LD} +b ${libdir} -b -o $[@]'
4051 # HP-UX shared libraries must be executable, and should be
4052 # readonly to exploit a quirk in the memory manager.
4053 INSTALL_LIB="-m 555"
4056 if test "$cf_cv_ld_rpath" = yes ; then
4057 if test "$GCC" = yes; then
4058 cf_ld_rpath_opt="-Wl,-rpath,"
4059 EXTRA_LDFLAGS="-Wl,-rpath,\${libdir} $EXTRA_LDFLAGS"
4061 cf_ld_rpath_opt="-rpath "
4062 EXTRA_LDFLAGS="-rpath \${libdir} $EXTRA_LDFLAGS"
4065 # tested with IRIX 5.2 and 'cc'.
4066 if test "$GCC" != yes; then
4067 CC_SHARED_OPTS='-KPIC'
4069 MK_SHARED_LIB='${CC} -shared -rdata_shared -soname `basename $[@]` -o $[@]'
4070 cf_cv_rm_so_locs=yes
4072 linux*|gnu*|k*bsd*-gnu)
4073 if test "$DFT_LWR_MODEL" = "shared" ; then
4074 LOCAL_LDFLAGS="-Wl,-rpath,\$(LOCAL_LIBDIR)"
4075 LOCAL_LDFLAGS2="$LOCAL_LDFLAGS"
4077 if test "$cf_cv_ld_rpath" = yes ; then
4078 cf_ld_rpath_opt="-Wl,-rpath,"
4079 EXTRA_LDFLAGS="-Wl,-rpath,\${libdir} $EXTRA_LDFLAGS"
4082 MK_SHARED_LIB='${CC} ${CFLAGS} -shared -Wl,-soname,'$cf_shared_soname',-stats,-lc -o $[@]'
4085 CC_SHARED_OPTS="$CC_SHARED_OPTS -DPIC"
4086 MK_SHARED_LIB='${LD} -Bshareable -soname,`basename $[@].${ABI_VERSION}` -o $[@]'
4088 openbsd*|freebsd[[12]].*)
4089 CC_SHARED_OPTS="$CC_SHARED_OPTS -DPIC"
4090 MK_SHARED_LIB='${LD} -Bshareable -o $[@]'
4091 test "$cf_cv_shlib_version" = auto && cf_cv_shlib_version=rel
4094 CC_SHARED_OPTS="$CC_SHARED_OPTS -DPIC"
4095 if test "$DFT_LWR_MODEL" = "shared" && test "$cf_cv_ld_rpath" = yes ; then
4096 LOCAL_LDFLAGS="-rpath \$(LOCAL_LIBDIR)"
4097 LOCAL_LDFLAGS2="-rpath \${libdir} $LOCAL_LDFLAGS"
4098 cf_ld_rpath_opt="-rpath "
4099 EXTRA_LDFLAGS="-rpath \${libdir} $EXTRA_LDFLAGS"
4102 MK_SHARED_LIB='${LD} -Bshareable -soname=`basename $[@]` -o $[@]'
4105 CC_SHARED_OPTS="$CC_SHARED_OPTS -DPIC"
4106 test "$cf_cv_ld_rpath" = yes && cf_ld_rpath_opt="-Wl,-rpath,"
4107 if test "$DFT_LWR_MODEL" = "shared" && test "$cf_cv_ld_rpath" = yes ; then
4108 LOCAL_LDFLAGS="-Wl,-rpath,\$(LOCAL_LIBDIR)"
4109 LOCAL_LDFLAGS2="$LOCAL_LDFLAGS"
4110 EXTRA_LDFLAGS="-Wl,-rpath,\${libdir} $EXTRA_LDFLAGS"
4111 if test "$cf_cv_shlib_version" = auto; then
4112 if test -f /usr/libexec/ld.elf_so; then
4113 cf_cv_shlib_version=abi
4115 cf_cv_shlib_version=rel
4119 MK_SHARED_LIB='${CC} ${CFLAGS} -shared -Wl,-soname,'$cf_shared_soname' -o $[@]'
4121 MK_SHARED_LIB='${LD} -Bshareable -o $[@]'
4125 # tested with OSF/1 V3.2 and 'cc'
4126 # tested with OSF/1 V3.2 and gcc 2.6.3 (but the c++ demo didn't
4127 # link with shared libs).
4128 MK_SHARED_LIB='${LD} -set_version ${REL_VERSION}:${ABI_VERSION} -expect_unresolved "*" -shared -soname `basename $[@]`'
4131 MK_SHARED_LIB="${MK_SHARED_LIB} -msym"
4134 MK_SHARED_LIB="${MK_SHARED_LIB}"' -o $[@]'
4135 if test "$DFT_LWR_MODEL" = "shared" ; then
4136 LOCAL_LDFLAGS="-Wl,-rpath,\$(LOCAL_LIBDIR)"
4137 LOCAL_LDFLAGS2="$LOCAL_LDFLAGS"
4139 if test "$cf_cv_ld_rpath" = yes ; then
4140 cf_ld_rpath_opt="-rpath"
4141 # EXTRA_LDFLAGS="$LOCAL_LDFLAGS $EXTRA_LDFLAGS"
4143 cf_cv_rm_so_locs=yes
4145 sco3.2v5*) # (also uw2* and UW7) hops 13-Apr-98
4146 # tested with osr5.0.5
4147 if test "$GCC" != yes; then
4148 CC_SHARED_OPTS='-belf -KPIC'
4150 MK_SHARED_LIB='${LD} -dy -G -h `basename $[@] .${REL_VERSION}`.${ABI_VERSION} -o [$]@'
4151 if test "$cf_cv_ld_rpath" = yes ; then
4152 # only way is to set LD_RUN_PATH but no switch for it
4155 test "$cf_cv_shlib_version" = auto && cf_cv_shlib_version=rel
4156 LINK_PROGS='LD_RUN_PATH=${libdir}'
4157 LINK_TESTS='Pwd=`pwd`;LD_RUN_PATH=`dirname $${Pwd}`/lib'
4160 # tested with SunOS 4.1.1 and gcc 2.7.0
4161 if test "$GCC" != yes; then
4162 CC_SHARED_OPTS='-KPIC'
4164 MK_SHARED_LIB='${LD} -assert pure-text -o $[@]'
4165 test "$cf_cv_shlib_version" = auto && cf_cv_shlib_version=rel
4168 # tested with SunOS 5.5.1 (solaris 2.5.1) and gcc 2.7.2
4169 # tested with SunOS 5.10 (solaris 10) and gcc 3.4.3
4170 if test "$DFT_LWR_MODEL" = "shared" ; then
4171 LOCAL_LDFLAGS="-R \$(LOCAL_LIBDIR):\${libdir}"
4172 LOCAL_LDFLAGS2="$LOCAL_LDFLAGS"
4174 if test "$cf_cv_ld_rpath" = yes ; then
4175 cf_ld_rpath_opt="-R"
4176 EXTRA_LDFLAGS="$LOCAL_LDFLAGS $EXTRA_LDFLAGS"
4179 if test "$GCC" != yes; then
4180 CC_SHARED_OPTS='-xcode=pic32'
4181 MK_SHARED_LIB='${CC} -dy -G -h '$cf_shared_soname' -o $[@]'
4183 MK_SHARED_LIB='${CC} -shared -dy -G -h '$cf_shared_soname' -o $[@]'
4187 # tested with UnixWare 7.1.0 (gcc 2.95.2 and cc)
4188 if test "$GCC" != yes; then
4189 CC_SHARED_OPTS='-KPIC'
4191 MK_SHARED_LIB='${LD} -d y -G -o [$]@'
4194 CC_SHARED_OPTS='unknown'
4195 MK_SHARED_LIB='echo unknown'
4199 # This works if the last tokens in $MK_SHARED_LIB are the -o target.
4200 case "$cf_cv_shlib_version" in #(vi
4202 case "$MK_SHARED_LIB" in #(vi
4204 test "$cf_cv_do_symlinks" = no && cf_cv_do_symlinks=yes
4207 AC_MSG_WARN(ignored --with-shlib-version)
4213 if test -n "$cf_ld_rpath_opt" ; then
4214 AC_MSG_CHECKING(if we need a space after rpath option)
4215 cf_save_LIBS="$LIBS"
4216 LIBS="$LIBS ${cf_ld_rpath_opt}$libdir"
4217 AC_TRY_LINK(, , cf_rpath_space=no, cf_rpath_space=yes)
4218 LIBS="$cf_save_LIBS"
4219 AC_MSG_RESULT($cf_rpath_space)
4220 test "$cf_rpath_space" = yes && cf_ld_rpath_opt="$cf_ld_rpath_opt "
4221 MK_SHARED_LIB="$MK_SHARED_LIB $cf_ld_rpath_opt\${libdir}"
4224 AC_SUBST(CC_SHARED_OPTS)
4225 AC_SUBST(LD_SHARED_OPTS)
4226 AC_SUBST(MK_SHARED_LIB)
4227 AC_SUBST(LINK_PROGS)
4228 AC_SUBST(LINK_TESTS)
4229 AC_SUBST(EXTRA_LDFLAGS)
4230 AC_SUBST(LOCAL_LDFLAGS)
4231 AC_SUBST(LOCAL_LDFLAGS2)
4232 AC_SUBST(INSTALL_LIB)
4234 dnl ---------------------------------------------------------------------------
4235 dnl CF_SHARED_SONAME version: 2 updated: 2006/10/21 12:33:41
4236 dnl ----------------
4237 dnl utility macro for CF_SHARED_OPTS, constructs "$cf_shared_soname" for
4238 dnl substitution into MK_SHARED_LIB string for the "-soname" (or similar)
4241 dnl $1 is the default that should be used for "$cf_cv_shlib_version".
4242 dnl If missing, use "rel".
4243 define([CF_SHARED_SONAME],
4245 test "$cf_cv_shlib_version" = auto && cf_cv_shlib_version=ifelse($1,,rel,$1)
4246 if test "$cf_cv_shlib_version" = rel; then
4247 cf_shared_soname='`basename $[@] .${REL_VERSION}`.${ABI_VERSION}'
4249 cf_shared_soname='`basename $[@]`'
4252 dnl ---------------------------------------------------------------------------
4253 dnl CF_SIGWINCH version: 1 updated: 2006/04/02 16:41:09
4255 dnl Use this macro after CF_XOPEN_SOURCE, but do not require it (not all
4256 dnl programs need this test).
4258 dnl This is really a MacOS X 10.4.3 workaround. Defining _POSIX_C_SOURCE
4259 dnl forces SIGWINCH to be undefined (breaks xterm, ncurses). Oddly, the struct
4260 dnl winsize declaration is left alone - we may revisit this if Apple choose to
4261 dnl break that part of the interface as well.
4262 AC_DEFUN([CF_SIGWINCH],
4264 AC_CACHE_CHECK(if SIGWINCH is defined,cf_cv_define_sigwinch,[
4266 #include <sys/types.h>
4267 #include <sys/signal.h>
4268 ],[int x = SIGWINCH],
4269 [cf_cv_define_sigwinch=yes],
4271 #undef _XOPEN_SOURCE
4272 #undef _POSIX_SOURCE
4273 #undef _POSIX_C_SOURCE
4274 #include <sys/types.h>
4275 #include <sys/signal.h>
4276 ],[int x = SIGWINCH],
4277 [cf_cv_define_sigwinch=maybe],
4278 [cf_cv_define_sigwinch=no])
4282 if test "$cf_cv_define_sigwinch" = maybe ; then
4283 AC_CACHE_CHECK(for actual SIGWINCH definition,cf_cv_fixup_sigwinch,[
4284 cf_cv_fixup_sigwinch=unknown
4286 while test $cf_sigwinch != 1
4289 #undef _XOPEN_SOURCE
4290 #undef _POSIX_SOURCE
4291 #undef _POSIX_C_SOURCE
4292 #include <sys/types.h>
4293 #include <sys/signal.h>
4295 #if SIGWINCH != $cf_sigwinch
4299 [cf_cv_fixup_sigwinch=$cf_sigwinch
4302 cf_sigwinch=`expr $cf_sigwinch - 1`
4306 if test "$cf_cv_fixup_sigwinch" != unknown ; then
4307 CPPFLAGS="$CPPFLAGS -DSIGWINCH=$cf_cv_fixup_sigwinch"
4311 dnl ---------------------------------------------------------------------------
4312 dnl CF_SIG_ATOMIC_T version: 2 updated: 2005/09/18 17:27:12
4314 dnl signal handler, but there are some gcc depedencies in that recommendation.
4316 AC_DEFUN([CF_SIG_ATOMIC_T],
4318 AC_MSG_CHECKING(for signal global datatype)
4319 AC_CACHE_VAL(cf_cv_sig_atomic_t,[
4321 "volatile sig_atomic_t" \
4326 #include <sys/types.h>
4332 static void handler(int sig)
4336 [signal(SIGINT, handler);
4338 [cf_cv_sig_atomic_t=$cf_type],
4339 [cf_cv_sig_atomic_t=no])
4340 test "$cf_cv_sig_atomic_t" != no && break
4343 AC_MSG_RESULT($cf_cv_sig_atomic_t)
4344 test "$cf_cv_sig_atomic_t" != no && AC_DEFINE_UNQUOTED(SIG_ATOMIC_T, $cf_cv_sig_atomic_t)
4346 dnl ---------------------------------------------------------------------------
4347 dnl CF_SIZECHANGE version: 8 updated: 2000/11/04 12:22:16
4349 dnl Check for definitions & structures needed for window size-changing
4350 dnl FIXME: check that this works with "snake" (HP-UX 10.x)
4351 AC_DEFUN([CF_SIZECHANGE],
4353 AC_REQUIRE([CF_STRUCT_TERMIOS])
4354 AC_CACHE_CHECK(declaration of size-change, cf_cv_sizechange,[
4355 cf_cv_sizechange=unknown
4356 cf_save_CPPFLAGS="$CPPFLAGS"
4358 for cf_opts in "" "NEED_PTEM_H"
4361 CPPFLAGS="$cf_save_CPPFLAGS"
4362 test -n "$cf_opts" && CPPFLAGS="$CPPFLAGS -D$cf_opts"
4363 AC_TRY_COMPILE([#include <sys/types.h>
4364 #ifdef HAVE_TERMIOS_H
4365 #include <termios.h>
4367 #ifdef HAVE_TERMIO_H
4372 /* This is a workaround for SCO: they neglected to define struct winsize in
4373 * termios.h -- it's only in termio.h and ptem.h
4375 #include <sys/stream.h>
4376 #include <sys/ptem.h>
4378 #if !defined(sun) || !defined(HAVE_TERMIOS_H)
4379 #include <sys/ioctl.h>
4383 struct ttysize win; /* FIXME: what system is this? */
4384 int y = win.ts_lines;
4385 int x = win.ts_cols;
4392 no TIOCGSIZE or TIOCGWINSZ
4393 #endif /* TIOCGWINSZ */
4394 #endif /* TIOCGSIZE */
4396 [cf_cv_sizechange=yes],
4397 [cf_cv_sizechange=no])
4399 CPPFLAGS="$cf_save_CPPFLAGS"
4400 if test "$cf_cv_sizechange" = yes ; then
4401 echo "size-change succeeded ($cf_opts)" >&AC_FD_CC
4402 test -n "$cf_opts" && cf_cv_sizechange="$cf_opts"
4407 if test "$cf_cv_sizechange" != no ; then
4408 AC_DEFINE(HAVE_SIZECHANGE)
4409 case $cf_cv_sizechange in #(vi
4411 AC_DEFINE_UNQUOTED($cf_cv_sizechange )
4416 dnl ---------------------------------------------------------------------------
4417 dnl CF_SRC_MODULES version: 18 updated: 2005/05/28 12:58:54
4419 dnl For each parameter, test if the source-directory exists, and if it contains
4420 dnl a 'modules' file. If so, add to the list $cf_cv_src_modules which we'll
4421 dnl use in CF_LIB_RULES.
4423 dnl This uses the configured value to make the lists SRC_SUBDIRS and
4424 dnl SUB_MAKEFILES which are used in the makefile-generation scheme.
4425 AC_DEFUN([CF_SRC_MODULES],
4427 AC_MSG_CHECKING(for src modules)
4429 # dependencies and linker-arguments for test-programs
4430 TEST_DEPS="${LIB_DIR}/${LIB_PREFIX}${LIB_NAME}${DFT_DEP_SUFFIX} $TEST_DEPS"
4431 TEST_DEP2="${LIB_2ND}/${LIB_PREFIX}${LIB_NAME}${DFT_DEP_SUFFIX} $TEST_DEP2"
4432 if test "$DFT_LWR_MODEL" = "libtool"; then
4433 TEST_ARGS="${TEST_DEPS}"
4434 TEST_ARG2="${TEST_DEP2}"
4436 TEST_ARGS="-l${LIB_NAME}${DFT_ARG_SUFFIX} $TEST_ARGS"
4437 TEST_ARG2="-l${LIB_NAME}${DFT_ARG_SUFFIX} $TEST_ARG2"
4443 if test -f $srcdir/$cf_dir/modules; then
4445 # We may/may not have tack in the distribution, though the
4447 if test $cf_dir = tack ; then
4448 if test ! -f $srcdir/${cf_dir}/${cf_dir}.h; then
4453 if test -z "$cf_cv_src_modules"; then
4454 cf_cv_src_modules=$cf_dir
4456 cf_cv_src_modules="$cf_cv_src_modules $cf_dir"
4459 # Make the ncurses_cfg.h file record the library interface files as
4460 # well. These are header files that are the same name as their
4461 # directory. Ncurses is the only library that does not follow
4463 if test $cf_dir = tack ; then
4465 elif test -f $srcdir/${cf_dir}/${cf_dir}.h; then
4466 CF_UPPER(cf_have_include,$cf_dir)
4467 AC_DEFINE_UNQUOTED(HAVE_${cf_have_include}_H)
4468 AC_DEFINE_UNQUOTED(HAVE_LIB${cf_have_include})
4469 TEST_DEPS="${LIB_DIR}/${LIB_PREFIX}${cf_dir}${DFT_DEP_SUFFIX} $TEST_DEPS"
4470 TEST_DEP2="${LIB_2ND}/${LIB_PREFIX}${cf_dir}${DFT_DEP_SUFFIX} $TEST_DEP2"
4471 if test "$DFT_LWR_MODEL" = "libtool"; then
4472 TEST_ARGS="${TEST_DEPS}"
4473 TEST_ARG2="${TEST_DEP2}"
4475 TEST_ARGS="-l${cf_dir}${DFT_ARG_SUFFIX} $TEST_ARGS"
4476 TEST_ARG2="-l${cf_dir}${DFT_ARG_SUFFIX} $TEST_ARG2"
4481 AC_MSG_RESULT($cf_cv_src_modules)
4483 TEST_ARGS="-L${LIB_DIR} $TEST_ARGS"
4484 TEST_ARG2="-L${LIB_2ND} $TEST_ARG2"
4492 SRC_SUBDIRS="man include"
4493 for cf_dir in $cf_cv_src_modules
4495 SRC_SUBDIRS="$SRC_SUBDIRS $cf_dir"
4497 SRC_SUBDIRS="$SRC_SUBDIRS test"
4498 test -z "$MAKE_TERMINFO" && SRC_SUBDIRS="$SRC_SUBDIRS misc"
4499 test "$cf_with_cxx_binding" != no && SRC_SUBDIRS="$SRC_SUBDIRS c++"
4502 if test "$cf_cv_prog_gnat_correct" = yes && test -f $srcdir/Ada95/Makefile.in; then
4503 SRC_SUBDIRS="$SRC_SUBDIRS Ada95"
4504 ADA_SUBDIRS="gen src samples"
4508 for cf_dir in $SRC_SUBDIRS
4510 SUB_MAKEFILES="$SUB_MAKEFILES $cf_dir/Makefile"
4513 if test -n "$ADA_SUBDIRS"; then
4514 for cf_dir in $ADA_SUBDIRS
4516 SUB_MAKEFILES="$SUB_MAKEFILES Ada95/$cf_dir/Makefile"
4518 AC_SUBST(ADA_SUBDIRS)
4521 dnl ---------------------------------------------------------------------------
4522 dnl CF_STDCPP_LIBRARY version: 5 updated: 2000/08/12 23:18:52
4523 dnl -----------------
4524 dnl Check for -lstdc++, which is GNU's standard C++ library.
4525 AC_DEFUN([CF_STDCPP_LIBRARY],
4527 if test -n "$GXX" ; then
4528 case $cf_cv_system_name in #(vi
4530 cf_stdcpp_libname=stdcpp
4533 cf_stdcpp_libname=stdc++
4536 AC_CACHE_CHECK(for library $cf_stdcpp_libname,cf_cv_libstdcpp,[
4538 LIBS="$LIBS -l$cf_stdcpp_libname"
4540 #include <strstream.h>],[
4542 strstreambuf foo(buf, sizeof(buf))
4544 [cf_cv_libstdcpp=yes],
4545 [cf_cv_libstdcpp=no])
4548 test "$cf_cv_libstdcpp" = yes && CXXLIBS="$CXXLIBS -l$cf_stdcpp_libname"
4551 dnl ---------------------------------------------------------------------------
4552 dnl CF_STRIP_G_OPT version: 3 updated: 2002/12/21 19:25:52
4554 dnl Remove "-g" option from the compiler options
4555 AC_DEFUN([CF_STRIP_G_OPT],
4556 [$1=`echo ${$1} | sed -e 's%-g %%' -e 's%-g$%%'`])dnl
4557 dnl ---------------------------------------------------------------------------
4558 dnl CF_STRUCT_SIGACTION version: 3 updated: 2000/08/12 23:18:52
4559 dnl -------------------
4560 dnl Check if we need _POSIX_SOURCE defined to use struct sigaction. We'll only
4561 dnl do this if we've found the sigaction function.
4563 dnl If needed, define SVR4_ACTION.
4564 AC_DEFUN([CF_STRUCT_SIGACTION],[
4565 if test "$ac_cv_func_sigaction" = yes; then
4566 AC_MSG_CHECKING(whether sigaction needs _POSIX_SOURCE)
4568 #include <sys/types.h>
4569 #include <signal.h>],
4570 [struct sigaction act],
4574 #define _POSIX_SOURCE
4575 #include <sys/types.h>
4576 #include <signal.h>],
4577 [struct sigaction act],
4579 AC_DEFINE(SVR4_ACTION)],
4580 [sigact_bad=unknown])])
4581 AC_MSG_RESULT($sigact_bad)
4584 dnl ---------------------------------------------------------------------------
4585 dnl CF_STRUCT_TERMIOS version: 5 updated: 2000/11/04 12:22:46
4586 dnl -----------------
4587 dnl Some machines require _POSIX_SOURCE to completely define struct termios.
4588 dnl If so, define SVR4_TERMIO
4589 AC_DEFUN([CF_STRUCT_TERMIOS],[
4595 if test "$ISC" = yes ; then
4596 AC_CHECK_HEADERS( sys/termio.h )
4598 if test "$ac_cv_header_termios_h" = yes ; then
4599 case "$CFLAGS $CPPFLAGS" in
4601 termios_bad=dunno ;;
4602 *) termios_bad=maybe ;;
4604 if test "$termios_bad" = maybe ; then
4605 AC_MSG_CHECKING(whether termios.h needs _POSIX_SOURCE)
4606 AC_TRY_COMPILE([#include <termios.h>],
4607 [struct termios foo; int x = foo.c_iflag],
4610 #define _POSIX_SOURCE
4611 #include <termios.h>],
4612 [struct termios foo; int x = foo.c_iflag],
4613 termios_bad=unknown,
4614 termios_bad=yes AC_DEFINE(SVR4_TERMIO))
4616 AC_MSG_RESULT($termios_bad)
4620 dnl ---------------------------------------------------------------------------
4621 dnl CF_SUBST version: 4 updated: 2006/06/17 12:33:03
4623 dnl Shorthand macro for substituting things that the user may override
4624 dnl with an environment variable.
4626 dnl $1 = long/descriptive name
4627 dnl $2 = environment variable
4628 dnl $3 = default value
4629 AC_DEFUN([CF_SUBST],
4630 [AC_CACHE_VAL(cf_cv_subst_$2,[
4631 AC_MSG_CHECKING(for $1 (symbol $2))
4632 CF_SUBST_IF([-z "[$]$2"], [$2], [$3])
4633 cf_cv_subst_$2=[$]$2
4634 AC_MSG_RESULT([$]$2)
4637 dnl ---------------------------------------------------------------------------
4638 dnl CF_SUBST_IF version: 2 updated: 2006/06/17 12:33:03
4640 dnl Shorthand macro for substituting things that the user may override
4641 dnl with an environment variable.
4643 dnl $1 = condition to pass to "test"
4644 dnl $2 = environment variable
4645 dnl $3 = value if the test succeeds
4646 dnl $4 = value if the test fails
4647 AC_DEFUN([CF_SUBST_IF],
4656 dnl ---------------------------------------------------------------------------
4657 dnl CF_SUBST_NCURSES_VERSION version: 8 updated: 2006/09/16 11:40:59
4658 dnl ------------------------
4659 dnl Get the version-number for use in shared-library naming, etc.
4660 AC_DEFUN([CF_SUBST_NCURSES_VERSION],
4662 AC_REQUIRE([CF_PROG_EGREP])
4663 NCURSES_MAJOR="`$ac_cv_prog_egrep '^NCURSES_MAJOR[[ ]]*=' $srcdir/dist.mk | sed -e 's/^[[^0-9]]*//'`"
4664 NCURSES_MINOR="`$ac_cv_prog_egrep '^NCURSES_MINOR[[ ]]*=' $srcdir/dist.mk | sed -e 's/^[[^0-9]]*//'`"
4665 NCURSES_PATCH="`$ac_cv_prog_egrep '^NCURSES_PATCH[[ ]]*=' $srcdir/dist.mk | sed -e 's/^[[^0-9]]*//'`"
4666 cf_cv_abi_version=${NCURSES_MAJOR}
4667 cf_cv_rel_version=${NCURSES_MAJOR}.${NCURSES_MINOR}
4668 dnl Show the computed version, for logging
4669 cf_cv_timestamp=`date`
4670 AC_MSG_RESULT(Configuring NCURSES $cf_cv_rel_version ABI $cf_cv_abi_version ($cf_cv_timestamp))
4671 dnl We need these values in the generated headers
4672 AC_SUBST(NCURSES_MAJOR)
4673 AC_SUBST(NCURSES_MINOR)
4674 AC_SUBST(NCURSES_PATCH)
4675 dnl We need these values in the generated makefiles
4676 AC_SUBST(cf_cv_rel_version)
4677 AC_SUBST(cf_cv_abi_version)
4678 AC_SUBST(cf_cv_builtin_bool)
4679 AC_SUBST(cf_cv_header_stdbool_h)
4680 AC_SUBST(cf_cv_type_of_bool)dnl
4682 dnl ---------------------------------------------------------------------------
4683 dnl CF_SYS_TIME_SELECT version: 4 updated: 2000/10/04 09:18:40
4684 dnl ------------------
4685 dnl Check if we can include <sys/time.h> with <sys/select.h>; this breaks on
4686 dnl older SCO configurations.
4687 AC_DEFUN([CF_SYS_TIME_SELECT],
4689 AC_MSG_CHECKING(if sys/time.h works with sys/select.h)
4690 AC_CACHE_VAL(cf_cv_sys_time_select,[
4692 #include <sys/types.h>
4693 #ifdef HAVE_SYS_TIME_H
4694 #include <sys/time.h>
4696 #ifdef HAVE_SYS_SELECT_H
4697 #include <sys/select.h>
4699 ],[],[cf_cv_sys_time_select=yes],
4700 [cf_cv_sys_time_select=no])
4702 AC_MSG_RESULT($cf_cv_sys_time_select)
4703 test "$cf_cv_sys_time_select" = yes && AC_DEFINE(HAVE_SYS_TIME_SELECT)
4705 dnl ---------------------------------------------------------------------------
4706 dnl CF_TOP_BUILDDIR version: 1 updated: 2006/10/15 16:33:23
4708 dnl Define a top_builddir symbol, for applications that need an absolute path.
4709 AC_DEFUN([CF_TOP_BUILDDIR],
4712 AC_SUBST(top_builddir)
4714 dnl ---------------------------------------------------------------------------
4715 dnl CF_TYPEOF_CHTYPE version: 8 updated: 2006/12/16 12:33:30
4716 dnl ----------------
4717 dnl Determine the type we should use for chtype (and attr_t, which is treated
4718 dnl as the same thing). We want around 32 bits, so on most machines want a
4719 dnl long, but on newer 64-bit machines, probably want an int. If we're using
4720 dnl wide characters, we have to have a type compatible with that, as well.
4721 AC_DEFUN([CF_TYPEOF_CHTYPE],
4723 AC_MSG_CHECKING([for type of chtype])
4724 AC_CACHE_VAL(cf_cv_typeof_chtype,[
4726 #define WANT_BITS 31
4730 FILE *fp = fopen("cf_test.out", "w");
4732 char *result = "long";
4733 if (sizeof(unsigned long) > sizeof(unsigned int)) {
4736 for (n = 0; n < WANT_BITS; n++) {
4739 if (y != 1 || x == 0) {
4745 * If x is nonzero, an int is big enough for the bits
4748 result = (x != 0) ? "int" : "long";
4753 ${cf_cv_main_return:-return}(0);
4756 [cf_cv_typeof_chtype=`cat cf_test.out`],
4757 [cf_cv_typeof_chtype=long],
4758 [cf_cv_typeof_chtype=long])
4761 AC_MSG_RESULT($cf_cv_typeof_chtype)
4763 AC_SUBST(cf_cv_typeof_chtype)
4764 AC_DEFINE_UNQUOTED(TYPEOF_CHTYPE,$cf_cv_typeof_chtype)
4766 dnl ---------------------------------------------------------------------------
4767 dnl CF_TYPE_SIGACTION version: 3 updated: 2000/08/12 23:18:52
4768 dnl -----------------
4770 AC_DEFUN([CF_TYPE_SIGACTION],
4772 AC_MSG_CHECKING([for type sigaction_t])
4773 AC_CACHE_VAL(cf_cv_type_sigaction,[
4775 #include <signal.h>],
4777 [cf_cv_type_sigaction=yes],
4778 [cf_cv_type_sigaction=no])])
4779 AC_MSG_RESULT($cf_cv_type_sigaction)
4780 test "$cf_cv_type_sigaction" = yes && AC_DEFINE(HAVE_TYPE_SIGACTION)
4782 dnl ---------------------------------------------------------------------------
4783 dnl CF_UNSIGNED_LITERALS version: 2 updated: 1998/02/07 22:10:16
4784 dnl --------------------
4785 dnl Test if the compiler supports 'U' and 'L' suffixes. Only old compilers
4786 dnl won't, but they're still there.
4787 AC_DEFUN([CF_UNSIGNED_LITERALS],
4789 AC_MSG_CHECKING([if unsigned literals are legal])
4790 AC_CACHE_VAL(cf_cv_unsigned_literals,[
4791 AC_TRY_COMPILE([],[long x = 1L + 1UL + 1U + 1],
4792 [cf_cv_unsigned_literals=yes],
4793 [cf_cv_unsigned_literals=no])
4795 AC_MSG_RESULT($cf_cv_unsigned_literals)
4797 dnl ---------------------------------------------------------------------------
4798 dnl CF_UPPER version: 5 updated: 2001/01/29 23:40:59
4800 dnl Make an uppercase version of a variable
4801 dnl $1=uppercase($2)
4802 AC_DEFUN([CF_UPPER],
4804 $1=`echo "$2" | sed y%abcdefghijklmnopqrstuvwxyz./-%ABCDEFGHIJKLMNOPQRSTUVWXYZ___%`
4806 dnl ---------------------------------------------------------------------------
4807 dnl CF_VERBOSE version: 3 updated: 2007/07/29 09:55:12
4809 dnl Use AC_VERBOSE w/o the warnings
4810 AC_DEFUN([CF_VERBOSE],
4811 [test -n "$verbose" && echo " $1" 1>&AC_FD_MSG
4814 dnl ---------------------------------------------------------------------------
4815 dnl CF_WCHAR_TYPE version: 2 updated: 2004/01/17 19:18:20
4817 dnl Check if type wide-character type $1 is declared, and if so, which header
4818 dnl file is needed. The second parameter is used to set a shell variable when
4819 dnl the type is not found. The first parameter sets a shell variable for the
4821 AC_DEFUN([CF_WCHAR_TYPE],
4823 # This is needed on Tru64 5.0 to declare $1
4824 AC_CACHE_CHECK(if we must include wchar.h to declare $1,cf_cv_$1,[
4829 #ifdef HAVE_LIBUTF8_H
4830 #include <libutf8.h>
4839 #ifdef HAVE_LIBUTF8_H
4840 #include <libutf8.h>
4844 [cf_cv_$1=unknown])])])
4846 if test "$cf_cv_$1" = yes ; then
4847 AC_DEFINE(NEED_WCHAR_H)
4852 # if we do not find $1 in either place, use substitution to provide a fallback.
4853 if test "$cf_cv_$1" = unknown ; then
4858 # if we find $1 in either place, use substitution to provide a fallback.
4859 if test "$cf_cv_$1" != unknown ; then
4864 dnl ---------------------------------------------------------------------------
4865 dnl CF_WITH_ABI_VERSION version: 1 updated: 2003/09/20 18:12:49
4866 dnl -------------------
4867 dnl Allow library's ABI to be overridden. Generally this happens when a
4868 dnl packager has incremented the ABI past that used in the original package,
4869 dnl and wishes to keep doing this.
4871 dnl $1 is the package name, if any, to derive a corresponding {package}_ABI
4873 AC_DEFUN([CF_WITH_ABI_VERSION],[
4874 test -z "$cf_cv_abi_version" && cf_cv_abi_version=0
4875 AC_ARG_WITH(abi-version,
4876 [ --with-abi-version=XXX override derived ABI version],
4877 [AC_MSG_WARN(overriding ABI version $cf_cv_abi_version to $withval)
4878 cf_cv_abi_version=$withval])
4879 CF_NUMBER_SYNTAX($cf_cv_abi_version,ABI version)
4881 $1_ABI=$cf_cv_abi_version
4884 dnl ---------------------------------------------------------------------------
4885 dnl CF_WITH_DBMALLOC version: 6 updated: 2006/12/16 14:24:05
4886 dnl ----------------
4887 dnl Configure-option for dbmalloc. The optional parameter is used to override
4888 dnl the updating of $LIBS, e.g., to avoid conflict with subsequent tests.
4889 AC_DEFUN([CF_WITH_DBMALLOC],[
4890 CF_NO_LEAKS_OPTION(dbmalloc,
4891 [ --with-dbmalloc test: use Conor Cahill's dbmalloc library],
4894 if test "$with_dbmalloc" = yes ; then
4895 AC_CHECK_HEADER(dbmalloc.h,
4896 [AC_CHECK_LIB(dbmalloc,[debug_malloc]ifelse($1,,[],[,$1]))])
4899 dnl ---------------------------------------------------------------------------
4900 dnl CF_WITH_DMALLOC version: 6 updated: 2006/12/16 14:24:05
4902 dnl Configure-option for dmalloc. The optional parameter is used to override
4903 dnl the updating of $LIBS, e.g., to avoid conflict with subsequent tests.
4904 AC_DEFUN([CF_WITH_DMALLOC],[
4905 CF_NO_LEAKS_OPTION(dmalloc,
4906 [ --with-dmalloc test: use Gray Watson's dmalloc library],
4909 if test "$with_dmalloc" = yes ; then
4910 AC_CHECK_HEADER(dmalloc.h,
4911 [AC_CHECK_LIB(dmalloc,[dmalloc_debug]ifelse($1,,[],[,$1]))])
4914 dnl ---------------------------------------------------------------------------
4915 dnl CF_WITH_GPM version: 7 updated: 2008/03/23 14:48:54
4918 dnl The option parameter (if neither yes/no) is assumed to be the name of
4919 dnl the gpm library, e.g., for dynamic loading.
4920 AC_DEFUN([CF_WITH_GPM],
4922 AC_MSG_CHECKING(if you want to link with the GPM mouse library)
4924 [ --with-gpm use Alessandro Rubini's GPM library],
4925 [with_gpm=$withval],
4927 AC_MSG_RESULT($with_gpm)
4929 if test "$with_gpm" != no ; then
4930 AC_CHECK_HEADER(gpm.h,[
4931 AC_DEFINE(HAVE_GPM_H)
4932 if test "$with_gpm" != yes && test "$with_gpm" != maybe ; then
4933 CF_VERBOSE(assuming we really have GPM library)
4934 AC_DEFINE(HAVE_LIBGPM)
4936 AC_CHECK_LIB(gpm,Gpm_Open,[:],[
4937 AC_MSG_ERROR(Cannot link with GPM library)
4942 test "$with_gpm" != maybe && AC_MSG_WARN(Cannot find GPM header)
4947 dnl ---------------------------------------------------------------------------
4948 dnl CF_WITH_LIBTOOL version: 19 updated: 2008/03/29 15:46:43
4950 dnl Provide a configure option to incorporate libtool. Define several useful
4951 dnl symbols for the makefile rules.
4953 dnl The reference to AC_PROG_LIBTOOL does not normally work, since it uses
4954 dnl macros from libtool.m4 which is in the aclocal directory of automake.
4955 dnl Following is a simple script which turns on the AC_PROG_LIBTOOL macro.
4956 dnl But that still does not work properly since the macro is expanded outside
4957 dnl the CF_WITH_LIBTOOL macro:
4960 dnl ACLOCAL=`aclocal --print-ac-dir`
4961 dnl if test -z "$ACLOCAL" ; then
4962 dnl echo cannot find aclocal directory
4964 dnl elif test ! -f $ACLOCAL/libtool.m4 ; then
4965 dnl echo cannot find libtool.m4 file
4969 dnl LOCAL=aclocal.m4
4970 dnl ORIG=aclocal.m4.orig
4972 dnl trap "mv $ORIG $LOCAL" 0 1 2 5 15
4976 dnl # sed the LIBTOOL= assignment to omit the current directory?
4977 dnl sed -e 's/^LIBTOOL=.*/LIBTOOL=${LIBTOOL-libtool}/' $ACLOCAL/libtool.m4 >>$LOCAL
4978 dnl cat $ORIG >>$LOCAL
4982 AC_DEFUN([CF_WITH_LIBTOOL],
4984 ifdef([AC_PROG_LIBTOOL],,[
4987 # common library maintenance symbols that are convenient for libtool scripts:
4988 LIB_CREATE='${AR} -cr'
4989 LIB_OBJECT='${OBJECTS}'
4993 # symbols used to prop libtool up to enable it to determine what it should be
5001 AC_MSG_CHECKING(if you want to build libraries with libtool)
5002 AC_ARG_WITH(libtool,
5003 [ --with-libtool generate libraries with libtool],
5004 [with_libtool=$withval],
5006 AC_MSG_RESULT($with_libtool)
5007 if test "$with_libtool" != "no"; then
5008 ifdef([AC_PROG_LIBTOOL],[
5009 # missing_content_AC_PROG_LIBTOOL{{
5011 # missing_content_AC_PROG_LIBTOOL}}
5013 if test "$with_libtool" != "yes" ; then
5014 CF_PATH_SYNTAX(with_libtool)
5015 LIBTOOL=$with_libtool
5017 AC_PATH_PROG(LIBTOOL,libtool)
5019 if test -z "$LIBTOOL" ; then
5020 AC_MSG_ERROR(Cannot find libtool)
5023 LIB_CREATE='${LIBTOOL} --mode=link ${CC} -rpath ${DESTDIR}${libdir} -version-info `cut -f1 ${srcdir}/VERSION` ${LIBTOOL_OPTS} -o'
5024 LIB_OBJECT='${OBJECTS:.o=.lo}'
5026 LIB_CLEAN='${LIBTOOL} --mode=clean'
5027 LIB_COMPILE='${LIBTOOL} --mode=compile'
5028 LIB_LINK='${LIBTOOL} --mode=link ${CC} ${LIBTOOL_OPTS}'
5029 LIB_INSTALL='${LIBTOOL} --mode=install'
5030 LIB_UNINSTALL='${LIBTOOL} --mode=uninstall'
5033 # Show the version of libtool
5034 AC_MSG_CHECKING(version of libtool)
5036 # Save the version in a cache variable - this is not entirely a good
5037 # thing, but the version string from libtool is very ugly, and for
5038 # bug reports it might be useful to have the original string.
5039 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.]].*//'`
5040 AC_MSG_RESULT($cf_cv_libtool_version)
5041 if test -z "$cf_cv_libtool_version" ; then
5042 AC_MSG_ERROR(This is not GNU libtool)
5045 # special hack to add --tag option for C++ compiler
5046 case $cf_cv_libtool_version in
5047 1.[[5-9]]*|[[2-9]]*)
5048 LIBTOOL_CXX="$LIBTOOL --tag=CXX"
5049 LIBTOOL="$LIBTOOL --tag=CC"
5052 LIBTOOL_CXX="$LIBTOOL"
5060 test -z "$LIBTOOL" && ECHO_LT=
5063 AC_SUBST(LIBTOOL_CXX)
5064 AC_SUBST(LIBTOOL_OPTS)
5066 AC_SUBST(LIB_CREATE)
5067 AC_SUBST(LIB_OBJECT)
5068 AC_SUBST(LIB_SUFFIX)
5072 AC_SUBST(LIB_COMPILE)
5074 AC_SUBST(LIB_INSTALL)
5075 AC_SUBST(LIB_UNINSTALL)
5078 dnl ---------------------------------------------------------------------------
5079 dnl CF_WITH_PATH version: 8 updated: 2007/05/13 13:16:35
5081 dnl Wrapper for AC_ARG_WITH to ensure that user supplies a pathname, not just
5082 dnl defaulting to yes/no.
5084 dnl $1 = option name
5086 dnl $3 = environment variable to set
5087 dnl $4 = default value, shown in the help-message, must be a constant
5088 dnl $5 = default value, if it's an expression & cannot be in the help-message
5090 AC_DEFUN([CF_WITH_PATH],
5091 [AC_ARG_WITH($1,[$2 ](default: ifelse($4,,empty,$4)),,
5092 ifelse($4,,[withval="${$3}"],[withval="${$3-ifelse($5,,$4,$5)}"]))dnl
5093 if ifelse($5,,true,[test -n "$5"]) ; then
5094 CF_PATH_SYNTAX(withval)
5099 dnl ---------------------------------------------------------------------------
5100 dnl CF_WITH_PATHLIST version: 5 updated: 2001/12/10 01:28:30
5101 dnl ----------------
5102 dnl Process an option specifying a list of colon-separated paths.
5104 dnl $1 = option name
5106 dnl $3 = environment variable to set
5107 dnl $4 = default value, shown in the help-message, must be a constant
5108 dnl $5 = default value, if it's an expression & cannot be in the help-message
5109 dnl $6 = flag to tell if we want to define or substitute
5111 AC_DEFUN([CF_WITH_PATHLIST],[
5112 AC_REQUIRE([CF_PATHSEP])
5113 AC_ARG_WITH($1,[$2 ](default: ifelse($4,,empty,$4)),,
5114 ifelse($4,,[withval=${$3}],[withval=${$3-ifelse($5,,$4,$5)}]))dnl
5116 IFS="${IFS= }"; ac_save_ifs="$IFS"; IFS="${PATHSEP}"
5118 for cf_src_path in $withval
5120 CF_PATH_SYNTAX(cf_src_path)
5121 test -n "$cf_dst_path" && cf_dst_path="${cf_dst_path}:"
5122 cf_dst_path="${cf_dst_path}${cf_src_path}"
5127 # Strip single quotes from the value, e.g., when it was supplied as a literal
5129 case $cf_dst_path in #(vi
5131 cf_dst_path=`echo $cf_dst_path |sed -e s/\'// -e s/\'\$//`
5134 cf_dst_path=`echo "$cf_dst_path" | sed -e 's/\\\\/\\\\\\\\/g'`
5137 eval '$3="$cf_dst_path"'
5141 dnl ---------------------------------------------------------------------------
5142 dnl CF_WITH_PTHREAD version: 1 updated: 2008/03/29 13:42:21
5144 dnl Check for POSIX thread library.
5145 AC_DEFUN([CF_WITH_PTHREAD],
5147 AC_MSG_CHECKING(if you want to link with the pthread library)
5148 AC_ARG_WITH(pthread,
5149 [ --with-pthread use POSIX thread library],
5150 [with_pthread=$withval],
5152 AC_MSG_RESULT($with_pthread)
5154 if test "$with_pthread" != no ; then
5155 AC_CHECK_HEADER(pthread.h,[
5156 AC_DEFINE(HAVE_PTHREADS_H)
5157 AC_CHECK_LIB(pthread,pthread_create,[
5158 LIBS="-lpthread $LIBS"
5159 AC_DEFINE(HAVE_LIBPTHREADS)
5162 AC_MSG_ERROR(Cannot link with pthread library)
5167 dnl ---------------------------------------------------------------------------
5168 dnl CF_WITH_REL_VERSION version: 1 updated: 2003/09/20 18:12:49
5169 dnl -------------------
5170 dnl Allow library's release-version to be overridden. Generally this happens when a
5171 dnl packager has incremented the release-version past that used in the original package,
5172 dnl and wishes to keep doing this.
5174 dnl $1 is the package name, if any, to derive corresponding {package}_MAJOR
5175 dnl and {package}_MINOR symbols
5177 AC_DEFUN([CF_WITH_REL_VERSION],[
5178 test -z "$cf_cv_rel_version" && cf_cv_rel_version=0.0
5179 AC_ARG_WITH(rel-version,
5180 [ --with-rel-version=XXX override derived release version],
5181 [AC_MSG_WARN(overriding release version $cf_cv_rel_version to $withval)
5182 cf_cv_rel_version=$withval])
5184 CF_NUMBER_SYNTAX($cf_cv_rel_version,Release version)
5186 $1_MAJOR=`echo "$cf_cv_rel_version" | sed -e 's/\..*//'`
5187 $1_MINOR=`echo "$cf_cv_rel_version" | sed -e 's/^[[^.]]*//' -e 's/^\.//' -e 's/\..*//'`
5188 CF_NUMBER_SYNTAX([$]$1_MAJOR,Release major-version)
5189 CF_NUMBER_SYNTAX([$]$1_MINOR,Release minor-version)
5192 dnl ---------------------------------------------------------------------------
5193 dnl CF_WITH_SYSMOUSE version: 2 updated: 2003/03/22 19:13:43
5194 dnl ----------------
5195 dnl If we can compile with sysmouse, make it available unless it is not wanted.
5196 AC_DEFUN([CF_WITH_SYSMOUSE],[
5197 # not everyone has "test -c"
5198 if test -c /dev/sysmouse 2>/dev/null ; then
5199 AC_MSG_CHECKING(if you want to use sysmouse)
5200 AC_ARG_WITH(sysmouse,
5201 [ --with-sysmouse use sysmouse (FreeBSD console)],
5202 [cf_with_sysmouse=$withval],
5203 [cf_with_sysmouse=maybe])
5204 if test "$cf_with_sysmouse" != no ; then
5206 #include <osreldate.h>
5207 #if (__FreeBSD_version >= 400017)
5208 #include <sys/consio.h>
5209 #include <sys/fbio.h>
5211 #include <machine/console.h>
5214 struct mouse_info the_mouse;
5215 ioctl(0, CONS_MOUSECTL, &the_mouse);
5216 ],[cf_with_sysmouse=yes],[cf_with_sysmouse=no])
5218 AC_MSG_RESULT($cf_with_sysmouse)
5219 test "$cf_with_sysmouse" = yes && AC_DEFINE(USE_SYSMOUSE)
5222 dnl ---------------------------------------------------------------------------
5223 dnl CF_WITH_VALGRIND version: 1 updated: 2006/12/14 18:00:21
5224 dnl ----------------
5225 AC_DEFUN([CF_WITH_VALGRIND],[
5226 CF_NO_LEAKS_OPTION(valgrind,
5227 [ --with-valgrind test: use valgrind],
5230 dnl ---------------------------------------------------------------------------
5231 dnl CF_XOPEN_SOURCE version: 25 updated: 2007/01/29 18:36:38
5233 dnl Try to get _XOPEN_SOURCE defined properly that we can use POSIX functions,
5234 dnl or adapt to the vendor's definitions to get equivalent functionality,
5235 dnl without losing the common non-POSIX features.
5238 dnl $1 is the nominal value for _XOPEN_SOURCE
5239 dnl $2 is the nominal value for _POSIX_C_SOURCE
5240 AC_DEFUN([CF_XOPEN_SOURCE],[
5242 AC_REQUIRE([CF_PROG_CC_U_D])
5244 cf_XOPEN_SOURCE=ifelse($1,,500,$1)
5245 cf_POSIX_C_SOURCE=ifelse($2,,199506L,$2)
5247 case $host_os in #(vi
5249 CPPFLAGS="$CPPFLAGS -D_ALL_SOURCE"
5252 # 5.x headers associate
5253 # _XOPEN_SOURCE=600 with _POSIX_C_SOURCE=200112L
5254 # _XOPEN_SOURCE=500 with _POSIX_C_SOURCE=199506L
5255 cf_POSIX_C_SOURCE=200112L
5257 CPPFLAGS="$CPPFLAGS -D_BSD_TYPES -D__BSD_VISIBLE -D_POSIX_C_SOURCE=$cf_POSIX_C_SOURCE -D_XOPEN_SOURCE=$cf_XOPEN_SOURCE"
5260 CPPFLAGS="$CPPFLAGS -D_HPUX_SOURCE"
5263 CPPFLAGS="$CPPFLAGS -D_SGI_SOURCE"
5265 linux*|gnu*|k*bsd*-gnu) #(vi
5269 # setting _XOPEN_SOURCE or _POSIX_SOURCE breaks <arpa/inet.h>
5272 # setting _XOPEN_SOURCE breaks IPv6 for lynx on NetBSD 1.6, breaks xterm, is not needed for ncursesw
5275 # setting _XOPEN_SOURCE breaks xterm on OpenBSD 2.8, is not needed for ncursesw
5278 CPPFLAGS="$CPPFLAGS -D_OSF_SOURCE"
5281 CPPFLAGS="$CPPFLAGS -D_QNX_SOURCE"
5284 # setting _XOPEN_SOURCE breaks Lynx on SCO Unix / OpenServer
5287 CPPFLAGS="$CPPFLAGS -D__EXTENSIONS__"
5290 AC_CACHE_CHECK(if we should define _XOPEN_SOURCE,cf_cv_xopen_source,[
5291 AC_TRY_COMPILE([#include <sys/types.h>],[
5292 #ifndef _XOPEN_SOURCE
5295 [cf_cv_xopen_source=no],
5296 [cf_save="$CPPFLAGS"
5297 CPPFLAGS="$CPPFLAGS -D_XOPEN_SOURCE=$cf_XOPEN_SOURCE"
5298 AC_TRY_COMPILE([#include <sys/types.h>],[
5299 #ifdef _XOPEN_SOURCE
5302 [cf_cv_xopen_source=no],
5303 [cf_cv_xopen_source=$cf_XOPEN_SOURCE])
5307 if test "$cf_cv_xopen_source" != no ; then
5308 CF_REMOVE_DEFINE(CFLAGS,$CFLAGS,_XOPEN_SOURCE)
5309 CF_REMOVE_DEFINE(CPPFLAGS,$CPPFLAGS,_XOPEN_SOURCE)
5310 test "$cf_cv_cc_u_d_options" = yes && \
5311 CPPFLAGS="$CPPFLAGS -U_XOPEN_SOURCE"
5312 CPPFLAGS="$CPPFLAGS -D_XOPEN_SOURCE=$cf_cv_xopen_source"
5314 CF_POSIX_C_SOURCE($cf_POSIX_C_SOURCE)