1 dnl***************************************************************************
2 dnl Copyright (c) 1998-2006,2007 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.425 2007/02/24 23:59:46 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_ANSI_CC_CHECK version: 9 updated: 2001/12/30 17:53:34
173 dnl This is adapted from the macros 'fp_PROG_CC_STDC' and 'fp_C_PROTOTYPES'
174 dnl in the sharutils 4.2 distribution.
175 AC_DEFUN([CF_ANSI_CC_CHECK],
177 AC_CACHE_CHECK(for ${CC-cc} option to accept ANSI C, cf_cv_ansi_cc,[
179 cf_save_CFLAGS="$CFLAGS"
180 cf_save_CPPFLAGS="$CPPFLAGS"
181 # Don't try gcc -ansi; that turns off useful extensions and
182 # breaks some systems' header files.
184 # Ultrix and OSF/1 -std1
185 # HP-UX -Aa -D_HPUX_SOURCE
187 # UnixWare 1.2 (cannot use -Xc, since ANSI/POSIX clashes)
188 for cf_arg in "-DCC_HAS_PROTOS" \
193 "-Aa -D_HPUX_SOURCE" \
196 CF_ADD_CFLAGS($cf_arg)
199 #ifndef CC_HAS_PROTOS
200 #if !defined(__STDC__) || (__STDC__ != 1)
205 int test (int i, double x);
206 struct s1 {int (*f) (int a);};
207 struct s2 {int (*f) (double a);};],
208 [cf_cv_ansi_cc="$cf_arg"; break])
210 CFLAGS="$cf_save_CFLAGS"
211 CPPFLAGS="$cf_save_CPPFLAGS"
214 if test "$cf_cv_ansi_cc" != "no"; then
215 if test ".$cf_cv_ansi_cc" != ".-DCC_HAS_PROTOS"; then
216 CF_ADD_CFLAGS($cf_cv_ansi_cc)
218 AC_DEFINE(CC_HAS_PROTOS)
222 dnl ---------------------------------------------------------------------------
223 dnl CF_ANSI_CC_REQD version: 3 updated: 1997/09/06 13:40:44
225 dnl For programs that must use an ANSI compiler, obtain compiler options that
226 dnl will make it recognize prototypes. We'll do preprocessor checks in other
227 dnl macros, since tools such as unproto can fake prototypes, but only part of
228 dnl the preprocessor.
229 AC_DEFUN([CF_ANSI_CC_REQD],
230 [AC_REQUIRE([CF_ANSI_CC_CHECK])
231 if test "$cf_cv_ansi_cc" = "no"; then
233 [Your compiler does not appear to recognize prototypes.
234 You have the following choices:
235 a. adjust your compiler options
236 b. get an up-to-date compiler
237 c. use a wrapper such as unproto])
240 dnl ---------------------------------------------------------------------------
241 dnl CF_BOOL_DECL version: 8 updated: 2004/01/30 15:51:18
243 dnl Test if 'bool' is a builtin type in the configured C++ compiler. Some
244 dnl older compilers (e.g., gcc 2.5.8) don't support 'bool' directly; gcc
245 dnl 2.6.3 does, in anticipation of the ANSI C++ standard.
247 dnl Treat the configuration-variable specially here, since we're directly
248 dnl substituting its value (i.e., 1/0).
250 dnl $1 is the shell variable to store the result in, if not $cv_cv_builtin_bool
251 AC_DEFUN([CF_BOOL_DECL],
253 AC_MSG_CHECKING(if we should include stdbool.h)
255 AC_CACHE_VAL(cf_cv_header_stdbool_h,[
256 AC_TRY_COMPILE([],[bool foo = false],
257 [cf_cv_header_stdbool_h=0],
262 ],[bool foo = false],
263 [cf_cv_header_stdbool_h=1],
264 [cf_cv_header_stdbool_h=0])])])
266 if test "$cf_cv_header_stdbool_h" = 1
267 then AC_MSG_RESULT(yes)
268 else AC_MSG_RESULT(no)
271 AC_MSG_CHECKING([for builtin bool type])
273 AC_CACHE_VAL(ifelse($1,,cf_cv_builtin_bool,[$1]),[
276 #include <sys/types.h>
278 [ifelse($1,,cf_cv_builtin_bool,[$1])=1],
279 [ifelse($1,,cf_cv_builtin_bool,[$1])=0])
282 if test "$ifelse($1,,cf_cv_builtin_bool,[$1])" = 1
283 then AC_MSG_RESULT(yes)
284 else AC_MSG_RESULT(no)
287 dnl ---------------------------------------------------------------------------
288 dnl CF_BOOL_SIZE version: 12 updated: 2006/12/16 12:33:30
290 dnl Test for the size of 'bool' in the configured C++ compiler (e.g., a type).
291 dnl Don't bother looking for bool.h, since it's been deprecated.
293 dnl If the current compiler is C rather than C++, we get the bool definition
294 dnl from <stdbool.h>.
295 AC_DEFUN([CF_BOOL_SIZE],
297 AC_MSG_CHECKING([for size of bool])
298 AC_CACHE_VAL(cf_cv_type_of_bool,[
304 #if defined(__cplusplus)
306 #ifdef HAVE_GXX_BUILTIN_H
307 #include <g++/builtin.h>
308 #elif HAVE_GPP_BUILTIN_H
309 #include <gpp/builtin.h>
316 #if $cf_cv_header_stdbool_h
324 FILE *fp = fopen("cf_test.out", "w");
328 fputs("unsigned ", fp);
329 if (sizeof(x) == sizeof(int)) fputs("int", fp);
330 else if (sizeof(x) == sizeof(char)) fputs("char", fp);
331 else if (sizeof(x) == sizeof(short))fputs("short",fp);
332 else if (sizeof(x) == sizeof(long)) fputs("long", fp);
335 ${cf_cv_main_return:-return}(0);
338 [cf_cv_type_of_bool=`cat cf_test.out`
339 if test -z "$cf_cv_type_of_bool"; then
340 cf_cv_type_of_bool=unknown
342 [cf_cv_type_of_bool=unknown],
343 [cf_cv_type_of_bool=unknown])
346 AC_MSG_RESULT($cf_cv_type_of_bool)
347 if test "$cf_cv_type_of_bool" = unknown ; then
348 case .$NCURSES_BOOL in #(vi
349 .auto|.) NCURSES_BOOL=unsigned;;
351 AC_MSG_WARN(Assuming $NCURSES_BOOL for type of bool)
352 cf_cv_type_of_bool=$NCURSES_BOOL
355 dnl ---------------------------------------------------------------------------
356 dnl CF_BUILD_CC version: 6 updated: 2006/10/14 15:23:15
358 dnl If we're cross-compiling, allow the user to override the tools and their
359 dnl options. The configure script is oriented toward identifying the host
360 dnl compiler, etc., but we need a build compiler to generate parts of the
363 dnl $1 = default for $CPPFLAGS
364 dnl $2 = default for $LIBS
365 AC_DEFUN([CF_BUILD_CC],[
366 AC_REQUIRE([CF_PROG_EXT])
367 if test "$cross_compiling" = yes ; then
369 # defaults that we might want to override
370 : ${BUILD_CFLAGS:=''}
371 : ${BUILD_CPPFLAGS:='ifelse([$1],,,[$1])'}
372 : ${BUILD_LDFLAGS:=''}
373 : ${BUILD_LIBS:='ifelse([$2],,,[$2])'}
374 : ${BUILD_EXEEXT:='$x'}
375 : ${BUILD_OBJEXT:='o'}
377 AC_ARG_WITH(build-cc,
378 [ --with-build-cc=XXX the build C compiler ($BUILD_CC)],
379 [BUILD_CC="$withval"],
380 [AC_CHECK_PROGS(BUILD_CC, gcc cc cl)])
381 AC_MSG_CHECKING(for native build C compiler)
382 AC_MSG_RESULT($BUILD_CC)
384 AC_MSG_CHECKING(for native build C preprocessor)
385 AC_ARG_WITH(build-cpp,
386 [ --with-build-cpp=XXX the build C preprocessor ($BUILD_CPP)],
387 [BUILD_CPP="$withval"],
388 [BUILD_CPP='${BUILD_CC} -E'])
389 AC_MSG_RESULT($BUILD_CPP)
391 AC_MSG_CHECKING(for native build C flags)
392 AC_ARG_WITH(build-cflags,
393 [ --with-build-cflags=XXX the build C compiler-flags ($BUILD_CFLAGS)],
394 [BUILD_CFLAGS="$withval"])
395 AC_MSG_RESULT($BUILD_CFLAGS)
397 AC_MSG_CHECKING(for native build C preprocessor-flags)
398 AC_ARG_WITH(build-cppflags,
399 [ --with-build-cppflags=XXX the build C preprocessor-flags ($BUILD_CPPFLAGS)],
400 [BUILD_CPPFLAGS="$withval"])
401 AC_MSG_RESULT($BUILD_CPPFLAGS)
403 AC_MSG_CHECKING(for native build linker-flags)
404 AC_ARG_WITH(build-ldflags,
405 [ --with-build-ldflags=XXX the build linker-flags ($BUILD_LDFLAGS)],
406 [BUILD_LDFLAGS="$withval"])
407 AC_MSG_RESULT($BUILD_LDFLAGS)
409 AC_MSG_CHECKING(for native build linker-libraries)
410 AC_ARG_WITH(build-libs,
411 [ --with-build-libs=XXX the build libraries (${BUILD_LIBS})],
412 [BUILD_LIBS="$withval"])
413 AC_MSG_RESULT($BUILD_LIBS)
415 # this assumes we're on Unix.
419 : ${BUILD_CC:='${CC}'}
421 if ( test "$BUILD_CC" = "$CC" || test "$BUILD_CC" = '${CC}' ) ; then
422 AC_MSG_ERROR([Cross-build requires two compilers.
423 Use --with-build-cc to specify the native compiler.])
427 : ${BUILD_CC:='${CC}'}
428 : ${BUILD_CPP:='${CPP}'}
429 : ${BUILD_CFLAGS:='${CFLAGS}'}
430 : ${BUILD_CPPFLAGS:='${CPPFLAGS}'}
431 : ${BUILD_LDFLAGS:='${LDFLAGS}'}
432 : ${BUILD_LIBS:='${LIBS}'}
433 : ${BUILD_EXEEXT:='$x'}
434 : ${BUILD_OBJEXT:='o'}
439 AC_SUBST(BUILD_CFLAGS)
440 AC_SUBST(BUILD_CPPFLAGS)
441 AC_SUBST(BUILD_LDFLAGS)
443 AC_SUBST(BUILD_EXEEXT)
444 AC_SUBST(BUILD_OBJEXT)
446 dnl ---------------------------------------------------------------------------
447 dnl CF_CFG_DEFAULTS version: 7 updated: 2005/09/24 16:15:00
449 dnl Determine the default configuration into which we'll install ncurses. This
450 dnl can be overridden by the user's command-line options. There's two items to
452 dnl 1. the prefix (e.g., /usr)
453 dnl 2. the header files (e.g., /usr/include/ncurses)
454 dnl We'll look for a previous installation of ncurses and use the same defaults.
456 dnl We don't use AC_PREFIX_DEFAULT, because it gets evaluated too soon, and
457 dnl we don't use AC_PREFIX_PROGRAM, because we cannot distinguish ncurses's
458 dnl programs from a vendor's.
459 AC_DEFUN([CF_CFG_DEFAULTS],
461 AC_MSG_CHECKING(for prefix)
462 if test "x$prefix" = "xNONE" ; then
463 case "$cf_cv_system_name" in
464 # non-vendor systems don't have a conflict
465 openbsd*|freebsd*|linux*|cygwin*|k*bsd*-gnu)
468 *) prefix=$ac_default_prefix
472 AC_MSG_RESULT($prefix)
474 if test "x$prefix" = "xNONE" ; then
475 AC_MSG_CHECKING(for default include-directory)
476 test -n "$verbose" && echo 1>&AC_FD_MSG
479 $includedir/ncurses \
481 $prefix/include/ncurses \
483 /usr/local/include/ncurses \
487 cf_dir=`eval echo $cf_symbol`
488 if test -f $cf_dir/curses.h ; then
489 if ( fgrep NCURSES_VERSION $cf_dir/curses.h 2>&1 >/dev/null ) ; then
490 includedir="$cf_symbol"
491 test -n "$verbose" && echo $ac_n " found " 1>&AC_FD_MSG
495 test -n "$verbose" && echo " tested $cf_dir" 1>&AC_FD_MSG
497 AC_MSG_RESULT($includedir)
500 dnl ---------------------------------------------------------------------------
501 dnl CF_CGETENT version: 3 updated: 2000/08/12 23:18:52
503 dnl Check if the terminal-capability database functions are available. If not,
504 dnl ncurses has a much-reduced version.
505 AC_DEFUN([CF_CGETENT],[
506 AC_MSG_CHECKING(for terminal-capability database functions)
507 AC_CACHE_VAL(cf_cv_cgetent,[
509 #include <stdlib.h>],[
512 char *db_array = temp;
513 cgetent(&buf, /* int *, */ &db_array, "vt100");
514 cgetcap(buf, "tc", '=');
515 cgetmatch(buf, "tc");
520 AC_MSG_RESULT($cf_cv_cgetent)
521 test "$cf_cv_cgetent" = yes && AC_DEFINE(HAVE_BSD_CGETENT)
523 dnl ---------------------------------------------------------------------------
524 dnl CF_CHECK_CACHE version: 10 updated: 2004/05/23 13:03:31
526 dnl Check if we're accidentally using a cache from a different machine.
527 dnl Derive the system name, as a check for reusing the autoconf cache.
529 dnl If we've packaged config.guess and config.sub, run that (since it does a
530 dnl better job than uname). Normally we'll use AC_CANONICAL_HOST, but allow
531 dnl an extra parameter that we may override, e.g., for AC_CANONICAL_SYSTEM
532 dnl which is useful in cross-compiles.
534 dnl Note: we would use $ac_config_sub, but that is one of the places where
535 dnl autoconf 2.5x broke compatibility with autoconf 2.13
536 AC_DEFUN([CF_CHECK_CACHE],
538 if test -f $srcdir/config.guess || test -f $ac_aux_dir/config.guess ; then
539 ifelse([$1],,[AC_CANONICAL_HOST],[$1])
540 system_name="$host_os"
542 system_name="`(uname -s -r) 2>/dev/null`"
543 if test -z "$system_name" ; then
544 system_name="`(hostname) 2>/dev/null`"
547 test -n "$system_name" && AC_DEFINE_UNQUOTED(SYSTEM_NAME,"$system_name")
548 AC_CACHE_VAL(cf_cv_system_name,[cf_cv_system_name="$system_name"])
550 test -z "$system_name" && system_name="$cf_cv_system_name"
551 test -n "$cf_cv_system_name" && AC_MSG_RESULT(Configuring for $cf_cv_system_name)
553 if test ".$system_name" != ".$cf_cv_system_name" ; then
554 AC_MSG_RESULT(Cached system name ($system_name) does not agree with actual ($cf_cv_system_name))
555 AC_ERROR("Please remove config.cache and try again.")
558 dnl ---------------------------------------------------------------------------
559 dnl CF_CHECK_ERRNO version: 9 updated: 2001/12/30 18:03:23
561 dnl Check for data that is usually declared in <stdio.h> or <errno.h>, e.g.,
562 dnl the 'errno' variable. Define a DECL_xxx symbol if we must declare it
565 dnl $1 = the name to check
566 AC_DEFUN([CF_CHECK_ERRNO],
568 AC_CACHE_CHECK(if external $1 is declared, cf_cv_dcl_$1,[
574 #include <sys/types.h>
575 #include <errno.h> ],
576 [long x = (long) $1],
581 if test "$cf_cv_dcl_$1" = no ; then
582 CF_UPPER(cf_result,decl_$1)
583 AC_DEFINE_UNQUOTED($cf_result)
586 # It's possible (for near-UNIX clones) that the data doesn't exist
587 CF_CHECK_EXTERN_DATA($1,int)
589 dnl ---------------------------------------------------------------------------
590 dnl CF_CHECK_EXTERN_DATA version: 3 updated: 2001/12/30 18:03:23
591 dnl --------------------
592 dnl Check for existence of external data in the current set of libraries. If
593 dnl we can modify it, it's real enough.
594 dnl $1 = the name to check
596 AC_DEFUN([CF_CHECK_EXTERN_DATA],
598 AC_CACHE_CHECK(if external $1 exists, cf_cv_have_$1,[
608 if test "$cf_cv_have_$1" = yes ; then
609 CF_UPPER(cf_result,have_$1)
610 AC_DEFINE_UNQUOTED($cf_result)
614 dnl ---------------------------------------------------------------------------
615 dnl CF_CPP_PARAM_INIT version: 4 updated: 2001/04/07 22:31:18
616 dnl -----------------
617 dnl Check if the C++ compiler accepts duplicate parameter initialization. This
618 dnl is a late feature for the standard and is not in some recent compilers
620 AC_DEFUN([CF_CPP_PARAM_INIT],
622 if test -n "$CXX"; then
623 AC_CACHE_CHECK(if $CXX accepts parameter initialization,cf_cv_cpp_param_init,[
635 TEST::TEST(int x = 1) // some compilers do not like second initializer
641 [cf_cv_cpp_param_init=yes],
642 [cf_cv_cpp_param_init=no],
643 [cf_cv_cpp_param_init=unknown])
647 test "$cf_cv_cpp_param_init" = yes && AC_DEFINE(CPP_HAS_PARAM_INIT)
649 dnl ---------------------------------------------------------------------------
650 dnl CF_CPP_STATIC_CAST version: 1 updated: 2005/07/23 16:52:43
651 dnl ------------------
652 dnl Check if the C++ compiler accepts static_cast in generics. This appears to
653 dnl not be supported in g++ before 3.0
654 AC_DEFUN([CF_CPP_STATIC_CAST],
656 if test -n "$CXX"; then
658 AC_CACHE_CHECK(if $CXX accepts static_cast,cf_cv_cpp_static_cast,[
666 NCursesPanel(int nlines,
676 template<class T> class NCursesUserPanel : public NCursesPanel
679 NCursesUserPanel (int nlines,
683 const T* p_UserData = static_cast<T*>(0))
684 : NCursesPanel (nlines, ncols, begin_y, begin_x)
687 NCursesUserPanel(const T* p_UserData = static_cast<T*>(0)) : NCursesPanel()
691 virtual ~NCursesUserPanel() {};
694 const char* p_UserData = static_cast<char*>(0)],
695 [cf_cv_cpp_static_cast=yes],
696 [cf_cv_cpp_static_cast=no])
703 test "$cf_cv_cpp_static_cast" = yes && AC_DEFINE(CPP_HAS_STATIC_CAST)
705 dnl ---------------------------------------------------------------------------
706 dnl CF_DIRNAME version: 4 updated: 2002/12/21 19:25:52
708 dnl "dirname" is not portable, so we fake it with a shell script.
709 AC_DEFUN([CF_DIRNAME],[$1=`echo $2 | sed -e 's%/[[^/]]*$%%'`])dnl
710 dnl ---------------------------------------------------------------------------
711 dnl CF_DIRS_TO_MAKE version: 3 updated: 2002/02/23 20:38:31
713 AC_DEFUN([CF_DIRS_TO_MAKE],
716 for cf_item in $cf_list_models
718 CF_OBJ_SUBDIR($cf_item,cf_subdir)
719 for cf_item2 in $DIRS_TO_MAKE
721 test $cf_item2 = $cf_subdir && break
723 test ".$cf_item2" != ".$cf_subdir" && DIRS_TO_MAKE="$DIRS_TO_MAKE $cf_subdir"
725 for cf_dir in $DIRS_TO_MAKE
727 test ! -d $cf_dir && mkdir $cf_dir
729 AC_SUBST(DIRS_TO_MAKE)
731 dnl ---------------------------------------------------------------------------
732 dnl CF_DISABLE_LEAKS version: 4 updated: 2006/12/16 15:10:42
734 dnl Combine no-leak checks with the libraries or tools that are used for the
736 AC_DEFUN([CF_DISABLE_LEAKS],[
738 AC_REQUIRE([CF_WITH_DMALLOC])
739 AC_REQUIRE([CF_WITH_DBMALLOC])
740 AC_REQUIRE([CF_WITH_VALGRIND])
742 AC_MSG_CHECKING(if you want to perform memory-leak testing)
744 [ --disable-leaks test: free permanent memory, analyze leaks],
746 : ${with_no_leaks:=no})
747 AC_MSG_RESULT($with_no_leaks)
749 if test "$with_no_leaks" = yes ; then
753 dnl ---------------------------------------------------------------------------
754 dnl CF_ERRNO version: 5 updated: 1997/11/30 12:44:39
756 dnl Check if 'errno' is declared in <errno.h>
759 CF_CHECK_ERRNO(errno)
761 dnl ---------------------------------------------------------------------------
762 dnl CF_ETIP_DEFINES version: 3 updated: 2003/03/22 19:13:43
764 dnl Test for conflicting definitions of exception in gcc 2.8.0, etc., between
765 dnl math.h and builtin.h, only for ncurses
766 AC_DEFUN([CF_ETIP_DEFINES],
768 AC_MSG_CHECKING(for special defines needed for etip.h)
769 cf_save_CXXFLAGS="$CXXFLAGS"
771 for cf_math in "" MATH_H
773 for cf_excp in "" MATH_EXCEPTION
775 CXXFLAGS="$cf_save_CXXFLAGS -I${srcdir}/c++ -I${srcdir}/menu -I${srcdir}/include"
776 test -n "$cf_math" && CXXFLAGS="$CXXFLAGS -DETIP_NEEDS_${cf_math}"
777 test -n "$cf_excp" && CXXFLAGS="$CXXFLAGS -DETIP_NEEDS_${cf_excp}"
781 test -n "$cf_math" && AC_DEFINE_UNQUOTED(ETIP_NEEDS_${cf_math})
782 test -n "$cf_excp" && AC_DEFINE_UNQUOTED(ETIP_NEEDS_${cf_excp})
783 cf_result="$cf_math $cf_excp"
788 AC_MSG_RESULT($cf_result)
789 CXXFLAGS="$cf_save_CXXFLAGS"
791 dnl ---------------------------------------------------------------------------
792 dnl CF_FUNC_DLSYM version: 1 updated: 2004/06/16 20:52:45
794 dnl Test for dlsym() and related functions, as well as libdl.
799 AC_DEFUN([CF_FUNC_DLSYM],[
801 AC_CHECK_FUNC(dlsym,cf_have_dlsym=yes,[
804 AC_CHECK_LIB(dl,dlsym,[
806 cf_have_libdl=yes])])
808 if test "$cf_have_dlsym" = yes ; then
809 test "$cf_have_libdl" = yes && LIBS="-ldl $LIBS"
811 AC_MSG_CHECKING(whether able to link to dl*() functions)
812 AC_TRY_LINK([#include <dlfcn.h>],[
814 if ((obj = dlopen("filename", 0)) != 0) {
815 if (dlsym(obj, "symbolname") == 0) {
819 AC_DEFINE(HAVE_LIBDL)],[
820 AC_MSG_ERROR(Cannot link test program for libdl)])
823 AC_MSG_ERROR(Cannot find dlsym function)
826 dnl ---------------------------------------------------------------------------
827 dnl CF_FUNC_MEMMOVE version: 7 updated: 2006/12/16 12:33:30
829 dnl Check for memmove, or a bcopy that can handle overlapping copy. If neither
830 dnl is found, add our own version of memmove to the list of objects.
831 AC_DEFUN([CF_FUNC_MEMMOVE],
833 AC_CHECK_FUNC(memmove,,[
834 AC_CHECK_FUNC(bcopy,[
835 AC_CACHE_CHECK(if bcopy does overlapping moves,cf_cv_good_bcopy,[
838 static char data[] = "abcdefghijklmnopqrstuwwxyz";
840 bcopy(data, temp, sizeof(data));
841 bcopy(temp+10, temp, 15);
842 bcopy(temp+5, temp+15, 10);
843 ${cf_cv_main_return:-return} (strcmp(temp, "klmnopqrstuwwxypqrstuwwxyz"));
846 [cf_cv_good_bcopy=yes],
847 [cf_cv_good_bcopy=no],
848 [cf_cv_good_bcopy=unknown])
850 ],[cf_cv_good_bcopy=no])
851 if test "$cf_cv_good_bcopy" = yes ; then
852 AC_DEFINE(USE_OK_BCOPY)
854 AC_DEFINE(USE_MY_MEMMOVE)
857 dnl ---------------------------------------------------------------------------
858 dnl CF_FUNC_NANOSLEEP version: 3 updated: 2006/12/16 12:33:30
859 dnl -----------------
860 dnl Check for existence of workable nanosleep() function. Some systems, e.g.,
861 dnl AIX 4.x, provide a non-working version.
862 AC_DEFUN([CF_FUNC_NANOSLEEP],[
863 AC_CACHE_CHECK(if nanosleep really works,cf_cv_func_nanosleep,[
869 #ifdef HAVE_SYS_TIME_H
870 #include <sys/time.h>
874 struct timespec ts1, ts2;
877 ts1.tv_nsec = 750000000;
881 code = nanosleep(&ts1, &ts2); /* on failure errno is ENOSYS. */
882 ${cf_cv_main_return:-return}(code != 0);
885 [cf_cv_func_nanosleep=yes],
886 [cf_cv_func_nanosleep=no],
887 [cf_cv_func_nanosleep=unknown])])
889 test "$cf_cv_func_nanosleep" = "yes" && AC_DEFINE(HAVE_NANOSLEEP)
891 dnl ---------------------------------------------------------------------------
892 dnl CF_FUNC_POLL version: 4 updated: 2006/12/16 12:33:30
894 dnl See if the poll function really works. Some platforms have poll(), but
895 dnl it does not work for terminals or files.
896 AC_DEFUN([CF_FUNC_POLL],[
897 AC_CACHE_CHECK(if poll really works,cf_cv_working_poll,[
903 #include <sys/poll.h>
910 myfds.events = POLLIN;
912 ret = poll(&myfds, 1, 100);
913 ${cf_cv_main_return:-return}(ret != 0);
915 [cf_cv_working_poll=yes],
916 [cf_cv_working_poll=no],
917 [cf_cv_working_poll=unknown])])
918 test "$cf_cv_working_poll" = "yes" && AC_DEFINE(HAVE_WORKING_POLL)
920 dnl ---------------------------------------------------------------------------
921 dnl CF_FUNC_TERMIOS version: 2 updated: 2000/07/22 23:37:24
923 dnl Some old/broken variations define tcgetattr() only as a macro in
925 AC_DEFUN([CF_FUNC_TERMIOS],[
926 AC_REQUIRE([CF_STRUCT_TERMIOS])
927 AC_CACHE_CHECK(for tcgetattr, cf_cv_have_tcgetattr,[
929 #include <sys/types.h>
933 #ifdef HAVE_TERMIOS_H
935 #define TTY struct termios
939 #define TTY struct termio
944 tcgetattr(1, &foo);],
945 [cf_cv_have_tcgetattr=yes],
946 [cf_cv_have_tcgetattr=no])])
947 test "$cf_cv_have_tcgetattr" = yes && AC_DEFINE(HAVE_TCGETATTR)
949 dnl ---------------------------------------------------------------------------
950 dnl CF_FUNC_VSSCANF version: 3 updated: 2001/12/19 00:50:10
952 dnl Check for vsscanf() function, which is in c9x but generally not in earlier
953 dnl versions of C. It is in the GNU C library, and can often be simulated by
955 AC_DEFUN([CF_FUNC_VSSCANF],
957 AC_CACHE_CHECK(for vsscanf function or workaround,cf_cv_func_vsscanf,[
960 #include <stdio.h>],[
962 vsscanf("from", "%d", ap)],[cf_cv_func_vsscanf=vsscanf],[
965 #include <stdio.h>],[
969 strbuf._flag = _IOREAD;
970 strbuf._ptr = strbuf._base = (unsigned char *) str;
971 strbuf._cnt = strlen(str);
972 strbuf._file = _NFILE;
973 return (vfscanf(&strbuf, "%d", ap))],[cf_cv_func_vsscanf=vfscanf],[
976 #include <stdio.h>],[
980 strbuf._flag = _IOREAD;
981 strbuf._ptr = strbuf._base = (unsigned char *) str;
982 strbuf._cnt = strlen(str);
983 strbuf._file = _NFILE;
984 return (_doscan(&strbuf, "%d", ap))],[cf_cv_func_vsscanf=_doscan],[
985 cf_cv_func_vsscanf=no])])])])
987 case $cf_cv_func_vsscanf in #(vi
988 vsscanf) AC_DEFINE(HAVE_VSSCANF);; #(vi
989 vfscanf) AC_DEFINE(HAVE_VFSCANF);; #(vi
990 _doscan) AC_DEFINE(HAVE__DOSCAN);;
994 dnl ---------------------------------------------------------------------------
995 dnl CF_GCC_ATTRIBUTES version: 10 updated: 2005/05/28 13:16:28
996 dnl -----------------
997 dnl Test for availability of useful gcc __attribute__ directives to quiet
998 dnl compiler warnings. Though useful, not all are supported -- and contrary
999 dnl to documentation, unrecognized directives cause older compilers to barf.
1000 AC_DEFUN([CF_GCC_ATTRIBUTES],
1002 if test "$GCC" = yes
1004 cat > conftest.i <<EOF
1006 #define GCC_PRINTF 0
1011 #ifndef GCC_NORETURN
1012 #define GCC_NORETURN /* nothing */
1015 #define GCC_UNUSED /* nothing */
1018 if test "$GCC" = yes
1020 AC_CHECKING([for $CC __attribute__ directives])
1021 cat > conftest.$ac_ext <<EOF
1022 #line __oline__ "configure"
1023 #include "confdefs.h"
1024 #include "conftest.h"
1025 #include "conftest.i"
1027 #define GCC_PRINTFLIKE(fmt,var) __attribute__((format(printf,fmt,var)))
1029 #define GCC_PRINTFLIKE(fmt,var) /*nothing*/
1032 #define GCC_SCANFLIKE(fmt,var) __attribute__((format(scanf,fmt,var)))
1034 #define GCC_SCANFLIKE(fmt,var) /*nothing*/
1036 extern void wow(char *,...) GCC_SCANFLIKE(1,2);
1037 extern void oops(char *,...) GCC_PRINTFLIKE(1,2) GCC_NORETURN;
1038 extern void foo(void) GCC_NORETURN;
1039 int main(int argc GCC_UNUSED, char *argv[[]] GCC_UNUSED) { return 0; }
1041 for cf_attribute in scanf printf unused noreturn
1043 CF_UPPER(cf_ATTRIBUTE,$cf_attribute)
1044 cf_directive="__attribute__(($cf_attribute))"
1045 echo "checking for $CC $cf_directive" 1>&AC_FD_CC
1046 case $cf_attribute in
1048 cat >conftest.h <<EOF
1049 #define GCC_$cf_ATTRIBUTE 1
1053 cat >conftest.h <<EOF
1054 #define GCC_$cf_ATTRIBUTE $cf_directive
1058 if AC_TRY_EVAL(ac_compile); then
1059 test -n "$verbose" && AC_MSG_RESULT(... $cf_attribute)
1060 cat conftest.h >>confdefs.h
1064 fgrep define conftest.i >>confdefs.h
1069 dnl ---------------------------------------------------------------------------
1070 dnl CF_GCC_VERSION version: 4 updated: 2005/08/27 09:53:42
1072 dnl Find version of gcc
1073 AC_DEFUN([CF_GCC_VERSION],[
1074 AC_REQUIRE([AC_PROG_CC])
1076 if test "$GCC" = yes ; then
1077 AC_MSG_CHECKING(version of $CC)
1078 GCC_VERSION="`${CC} --version| sed -e '2,$d' -e 's/^.*(GCC) //' -e 's/^[[^0-9.]]*//' -e 's/[[^0-9.]].*//'`"
1079 test -z "$GCC_VERSION" && GCC_VERSION=unknown
1080 AC_MSG_RESULT($GCC_VERSION)
1083 dnl ---------------------------------------------------------------------------
1084 dnl CF_GCC_WARNINGS version: 20 updated: 2005/08/06 18:37:29
1086 dnl Check if the compiler supports useful warning options. There's a few that
1087 dnl we don't use, simply because they're too noisy:
1089 dnl -Wconversion (useful in older versions of gcc, but not in gcc 2.7.x)
1090 dnl -Wredundant-decls (system headers make this too noisy)
1091 dnl -Wtraditional (combines too many unrelated messages, only a few useful)
1092 dnl -Wwrite-strings (too noisy, but should review occasionally). This
1093 dnl is enabled for ncurses using "--enable-const".
1097 dnl $1 is an optional list of gcc warning flags that a particular
1098 dnl application might want to use, e.g., "no-unused" for
1101 dnl If $with_ext_const is "yes", add a check for -Wwrite-strings
1103 AC_DEFUN([CF_GCC_WARNINGS],
1105 AC_REQUIRE([CF_GCC_VERSION])
1106 CF_INTEL_COMPILER(GCC,INTEL_COMPILER,CFLAGS)
1108 cat > conftest.$ac_ext <<EOF
1109 #line __oline__ "configure"
1110 int main(int argc, char *argv[[]]) { return (argv[[argc-1]] == 0) ; }
1113 if test "$INTEL_COMPILER" = yes
1115 # The "-wdXXX" options suppress warnings:
1116 # remark #1419: external declaration in primary source file
1117 # remark #1682: implicit conversion of a 64-bit integral type to a smaller integral type (potential portability problem)
1118 # remark #1683: explicit conversion of a 64-bit integral type to a smaller integral type (potential portability problem)
1119 # remark #1684: conversion from pointer to same-sized integral type (potential portability problem)
1120 # remark #193: zero used for undefined preprocessing identifier
1121 # remark #593: variable "curs_sb_left_arrow" was set but never used
1122 # remark #810: conversion from "int" to "Dimension={unsigned short}" may lose significant bits
1123 # remark #869: parameter "tw" was never referenced
1124 # remark #981: operands are evaluated in unspecified order
1125 # warning #269: invalid format string conversion
1127 AC_CHECKING([for $CC warning options])
1128 cf_save_CFLAGS="$CFLAGS"
1129 EXTRA_CFLAGS="-Wall"
1142 CFLAGS="$cf_save_CFLAGS $EXTRA_CFLAGS -$cf_opt"
1143 if AC_TRY_EVAL(ac_compile); then
1144 test -n "$verbose" && AC_MSG_RESULT(... -$cf_opt)
1145 EXTRA_CFLAGS="$EXTRA_CFLAGS -$cf_opt"
1148 CFLAGS="$cf_save_CFLAGS"
1150 elif test "$GCC" = yes
1152 AC_CHECKING([for $CC warning options])
1153 cf_save_CFLAGS="$CFLAGS"
1154 EXTRA_CFLAGS="-W -Wall"
1156 test "$with_ext_const" = yes && cf_warn_CONST="Wwrite-strings"
1158 Wbad-function-cast \
1162 Wmissing-declarations \
1163 Wmissing-prototypes \
1167 Wstrict-prototypes \
1168 Wundef $cf_warn_CONST $1
1170 CFLAGS="$cf_save_CFLAGS $EXTRA_CFLAGS -$cf_opt"
1171 if AC_TRY_EVAL(ac_compile); then
1172 test -n "$verbose" && AC_MSG_RESULT(... -$cf_opt)
1173 case $cf_opt in #(vi
1175 CPPFLAGS="$CPPFLAGS -DXTSTRINGDEFINES"
1178 case $GCC_VERSION in
1180 CF_VERBOSE(feature is broken in gcc $GCC_VERSION)
1185 EXTRA_CFLAGS="$EXTRA_CFLAGS -$cf_opt"
1188 CFLAGS="$cf_save_CFLAGS"
1192 AC_SUBST(EXTRA_CFLAGS)
1194 dnl ---------------------------------------------------------------------------
1195 dnl CF_GNAT_TRY_LINK version: 1 updated: 2004/08/21 19:02:08
1196 dnl ----------------
1197 dnl Verify that a test program compiles/links with GNAT.
1198 dnl $cf_ada_make is set to the program that compiles/links
1199 dnl $ADAFLAGS may be set to the GNAT flags.
1201 dnl $1 is the text of the spec
1202 dnl $2 is the text of the body
1203 dnl $3 is the shell command to execute if successful
1204 dnl $4 is the shell command to execute if not successful
1205 AC_DEFUN([CF_GNAT_TRY_LINK],
1208 cat >>conftest.ads <<CF_EOF
1211 cat >>conftest.adb <<CF_EOF
1214 if ( $cf_ada_make $ADAFLAGS conftest 1>&AC_FD_CC 2>&1 ) ; then
1215 ifelse($3,, :,[ $3])
1221 dnl ---------------------------------------------------------------------------
1222 dnl CF_GNAT_TRY_RUN version: 3 updated: 2004/08/21 19:02:08
1224 dnl Verify that a test program compiles and runs with GNAT
1225 dnl $cf_ada_make is set to the program that compiles/links
1226 dnl $ADAFLAGS may be set to the GNAT flags.
1228 dnl $1 is the text of the spec
1229 dnl $2 is the text of the body
1230 dnl $3 is the shell command to execute if successful
1231 dnl $4 is the shell command to execute if not successful
1232 AC_DEFUN([CF_GNAT_TRY_RUN],
1235 cat >>conftest.ads <<CF_EOF
1238 cat >>conftest.adb <<CF_EOF
1241 if ( $cf_ada_make $ADAFLAGS conftest 1>&AC_FD_CC 2>&1 ) ; then
1242 if ( ./conftest 1>&AC_FD_CC 2>&1 ) ; then
1243 ifelse($3,, :,[ $3])
1252 dnl ---------------------------------------------------------------------------
1253 dnl CF_GNAT_VERSION version: 12 updated: 2006/10/14 15:23:15
1255 dnl Verify version of GNAT.
1256 AC_DEFUN([CF_GNAT_VERSION],
1258 AC_MSG_CHECKING(for gnat version)
1259 cf_gnat_version=`${cf_ada_make-gnatmake} -v 2>&1 | grep '[[0-9]].[[0-9]][[0-9]]*' |\
1260 sed -e '2,$d' -e 's/[[^0-9 \.]]//g' -e 's/^[[ ]]*//' -e 's/ .*//'`
1261 AC_MSG_RESULT($cf_gnat_version)
1263 case $cf_gnat_version in
1264 3.1[[1-9]]*|3.[[2-9]]*|[[4-9]].*)
1265 cf_cv_prog_gnat_correct=yes
1267 *) echo Unsupported GNAT version $cf_gnat_version. Required is 3.11 or better. Disabling Ada95 binding.
1268 cf_cv_prog_gnat_correct=no
1271 case $cf_gnat_version in
1272 3.[[1-9]]*|[[4-9]].*)
1273 cf_compile_generics=generics
1274 cf_generic_objects="\${GENOBJS}"
1276 *) cf_compile_generics=
1281 dnl ---------------------------------------------------------------------------
1282 dnl CF_GNU_SOURCE version: 6 updated: 2005/07/09 13:23:07
1284 dnl Check if we must define _GNU_SOURCE to get a reasonable value for
1285 dnl _XOPEN_SOURCE, upon which many POSIX definitions depend. This is a defect
1286 dnl (or misfeature) of glibc2, which breaks portability of many applications,
1287 dnl since it is interwoven with GNU extensions.
1289 dnl Well, yes we could work around it...
1290 AC_DEFUN([CF_GNU_SOURCE],
1292 AC_CACHE_CHECK(if we must define _GNU_SOURCE,cf_cv_gnu_source,[
1293 AC_TRY_COMPILE([#include <sys/types.h>],[
1294 #ifndef _XOPEN_SOURCE
1297 [cf_cv_gnu_source=no],
1298 [cf_save="$CPPFLAGS"
1299 CPPFLAGS="$CPPFLAGS -D_GNU_SOURCE"
1300 AC_TRY_COMPILE([#include <sys/types.h>],[
1301 #ifdef _XOPEN_SOURCE
1304 [cf_cv_gnu_source=no],
1305 [cf_cv_gnu_source=yes])
1309 test "$cf_cv_gnu_source" = yes && CPPFLAGS="$CPPFLAGS -D_GNU_SOURCE"
1311 dnl ---------------------------------------------------------------------------
1312 dnl CF_GPP_LIBRARY version: 8 updated: 2003/02/02 01:41:46
1314 dnl If we're trying to use g++, test if libg++ is installed (a rather common
1315 dnl problem :-). If we have the compiler but no library, we'll be able to
1316 dnl configure, but won't be able to build the c++ demo program.
1317 AC_DEFUN([CF_GPP_LIBRARY],
1319 cf_cxx_library=unknown
1320 case $cf_cv_system_name in #(vi
1328 if test "$GXX" = yes; then
1329 AC_MSG_CHECKING([for lib$cf_gpp_libname])
1331 LIBS="$LIBS -l$cf_gpp_libname"
1333 #include <$cf_gpp_libname/builtin.h>
1335 [two_arg_error_handler_t foo2 = lib_error_handler],
1337 CXXLIBS="$CXXLIBS -l$cf_gpp_libname"
1338 if test "$cf_gpp_libname" = cpp ; then
1339 AC_DEFINE(HAVE_GPP_BUILTIN_H)
1341 AC_DEFINE(HAVE_GXX_BUILTIN_H)
1344 #include <builtin.h>
1346 [two_arg_error_handler_t foo2 = lib_error_handler],
1348 CXXLIBS="$CXXLIBS -l$cf_gpp_libname"
1349 AC_DEFINE(HAVE_BUILTIN_H)],
1350 [cf_cxx_library=no])])
1352 AC_MSG_RESULT($cf_cxx_library)
1355 dnl ---------------------------------------------------------------------------
1356 dnl CF_GXX_VERSION version: 5 updated: 2005/08/27 09:53:42
1358 dnl Check for version of g++
1359 AC_DEFUN([CF_GXX_VERSION],[
1360 AC_REQUIRE([AC_PROG_CPP])
1362 if test "$GXX" = yes; then
1363 AC_MSG_CHECKING(version of g++)
1364 GXX_VERSION="`${CXX-g++} --version| sed -e '2,$d' -e 's/^.*(GCC) //' -e 's/^[[^0-9.]]*//' -e 's/[[^0-9.]].*//'`"
1365 test -z "$GXX_VERSION" && GXX_VERSION=unknown
1366 AC_MSG_RESULT($GXX_VERSION)
1369 dnl ---------------------------------------------------------------------------
1370 dnl CF_GXX_WARNINGS version: 5 updated: 2005/08/13 14:54:38
1372 dnl Check if the compiler supports useful warning options.
1374 dnl Most of gcc's options apply to g++, except:
1375 dnl -Wbad-function-cast
1376 dnl -Wmissing-declarations
1377 dnl -Wnested-externs
1379 dnl Omit a few (for now):
1383 dnl $1 is an optional list of g++ warning flags that a particular
1384 dnl application might want to use, e.g., "no-unused" for
1387 dnl If $with_ext_const is "yes", add a check for -Wwrite-strings
1389 AC_DEFUN([CF_GXX_WARNINGS],
1392 CF_INTEL_COMPILER(GXX,INTEL_CPLUSPLUS,CXXFLAGS)
1394 AC_REQUIRE([CF_GXX_VERSION])
1399 cat > conftest.$ac_ext <<EOF
1400 #line __oline__ "configure"
1401 int main(int argc, char *argv[[]]) { return (argv[[argc-1]] == 0) ; }
1404 if test "$INTEL_CPLUSPLUS" = yes
1406 # The "-wdXXX" options suppress warnings:
1407 # remark #1419: external declaration in primary source file
1408 # remark #1682: implicit conversion of a 64-bit integral type to a smaller integral type (potential portability problem)
1409 # remark #1683: explicit conversion of a 64-bit integral type to a smaller integral type (potential portability problem)
1410 # remark #1684: conversion from pointer to same-sized integral type (potential portability problem)
1411 # remark #193: zero used for undefined preprocessing identifier
1412 # remark #593: variable "curs_sb_left_arrow" was set but never used
1413 # remark #810: conversion from "int" to "Dimension={unsigned short}" may lose significant bits
1414 # remark #869: parameter "tw" was never referenced
1415 # remark #981: operands are evaluated in unspecified order
1416 # warning #269: invalid format string conversion
1418 AC_CHECKING([for $CC warning options])
1419 cf_save_CXXFLAGS="$CXXFLAGS"
1420 EXTRA_CXXFLAGS="-Wall"
1433 CXXFLAGS="$cf_save_CXXFLAGS $EXTRA_CXXFLAGS -$cf_opt"
1434 if AC_TRY_EVAL(ac_compile); then
1435 test -n "$verbose" && AC_MSG_RESULT(... -$cf_opt)
1436 EXTRA_CXXFLAGS="$EXTRA_CXXFLAGS -$cf_opt"
1439 CXXFLAGS="$cf_save_CXXFLAGS"
1441 elif test "$GXX" = yes
1443 AC_CHECKING([for $CXX warning options])
1444 cf_save_CXXFLAGS="$CXXFLAGS"
1445 EXTRA_CXXFLAGS="-W -Wall"
1446 cf_gxx_extra_warnings=""
1447 test "$with_ext_const" = yes && cf_gxx_extra_warnings="Wwrite-strings"
1448 case "$GCC_VERSION" in
1452 cf_gxx_extra_warnings="$cf_gxx_extra_warnings Weffc++"
1458 Woverloaded-virtual \
1464 Wmissing-prototypes \
1467 Wstrict-prototypes \
1468 Wundef $cf_gxx_extra_warnings $1
1470 CXXFLAGS="$cf_save_CXXFLAGS $EXTRA_CXXFLAGS -Werror -$cf_opt"
1471 if AC_TRY_EVAL(ac_compile); then
1472 test -n "$verbose" && AC_MSG_RESULT(... -$cf_opt)
1473 EXTRA_CXXFLAGS="$EXTRA_CXXFLAGS -$cf_opt"
1475 test -n "$verbose" && AC_MSG_RESULT(... no -$cf_opt)
1478 CXXFLAGS="$cf_save_CXXFLAGS"
1483 AC_SUBST(EXTRA_CXXFLAGS)
1485 dnl ---------------------------------------------------------------------------
1486 dnl CF_HASHED_DB version: 1 updated: 2006/08/19 09:16:14
1488 dnl Look for an instance of the Berkeley hashed database.
1489 AC_DEFUN([CF_HASHED_DB],
1491 AC_CHECK_HEADER(db.h,[
1492 CF_HASHED_DB_VERSION
1493 if test "$cf_cv_hashed_db_version" = unknown ; then
1494 AC_MSG_ERROR(Cannot determine version of db)
1497 if test "$cf_cv_hashed_db_libs" = unknown ; then
1498 AC_MSG_ERROR(Cannot determine library for db)
1499 elif test "$cf_cv_hashed_db_libs" != default ; then
1500 LIBS="-l$cf_cv_hashed_db_libs $LIBS"
1504 AC_MSG_ERROR(Cannot find db.h)
1507 dnl ---------------------------------------------------------------------------
1508 dnl CF_HASHED_DB_LIBS version: 6 updated: 2006/12/16 12:33:30
1509 dnl -----------------
1510 dnl Given that we have the header and version for hashed database, find the
1511 dnl library information.
1512 AC_DEFUN([CF_HASHED_DB_LIBS],
1514 AC_CACHE_CHECK(for db libraries, cf_cv_hashed_db_libs,[
1515 cf_cv_hashed_db_libs=unknown
1516 for cf_db_libs in db$cf_cv_hashed_db_version db ''
1518 cf_save_libs="$LIBS"
1519 if test -n "$cf_db_libs"; then
1520 LIBS="-l$cf_db_libs $LIBS"
1522 CF_MSG_LOG(checking for library "$cf_db_libs")
1524 $ac_includes_default
1527 char *path = "/tmp/foo";
1528 #ifdef DB_VERSION_MAJOR
1529 #if DB_VERSION_MAJOR >= 4
1531 db_create(&result, NULL, 0);
1532 result->open(result,
1539 #elif DB_VERSION_MAJOR >= 3
1541 db_create(&result, NULL, 0);
1542 result->open(result,
1548 #elif DB_VERSION_MAJOR >= 2
1557 #endif /* DB_VERSION_MAJOR */
1559 DB *result = dbopen(path,
1565 ${cf_cv_main_return:-return}(result != 0)
1567 if test -n "$cf_db_libs" ; then
1568 cf_cv_hashed_db_libs=$cf_db_libs
1570 cf_cv_hashed_db_libs=default
1572 LIBS="$cf_save_libs"
1575 LIBS="$cf_save_libs"
1579 dnl ---------------------------------------------------------------------------
1580 dnl CF_HASHED_DB_VERSION version: 2 updated: 2006/08/19 15:12:49
1581 dnl --------------------
1582 dnl Given that we have the header file for hashed database, find the version
1584 AC_DEFUN([CF_HASHED_DB_VERSION],
1586 AC_CACHE_CHECK(for version of db, cf_cv_hashed_db_version,[
1587 cf_cv_hashed_db_version=unknown
1589 for cf_db_version in 1 2 3 4
1591 CF_MSG_LOG(checking for db version $cf_db_version)
1593 $ac_includes_default
1596 #ifdef DB_VERSION_MAJOR
1597 /* db2 (DB_VERSION_MAJOR=2) has also DB_VERSION_MINOR, tested with 7 */
1598 #if $cf_db_version == DB_VERSION_MAJOR
1604 #if $cf_db_version == 1
1605 /* ok: assuming this is DB 1.8.5 */
1611 cf_cv_hashed_db_version=$cf_db_version
1617 dnl ---------------------------------------------------------------------------
1618 dnl CF_HELP_MESSAGE version: 3 updated: 1998/01/14 10:56:23
1620 dnl Insert text into the help-message, for readability, from AC_ARG_WITH.
1621 AC_DEFUN([CF_HELP_MESSAGE],
1622 [AC_DIVERT_HELP([$1])dnl
1624 dnl ---------------------------------------------------------------------------
1625 dnl CF_INCLUDE_DIRS version: 5 updated: 2006/10/14 15:23:15
1627 dnl Construct the list of include-options according to whether we're building
1628 dnl in the source directory or using '--srcdir=DIR' option. If we're building
1629 dnl with gcc, don't append the includedir if it happens to be /usr/include,
1630 dnl since that usually breaks gcc's shadow-includes.
1631 AC_DEFUN([CF_INCLUDE_DIRS],
1633 CPPFLAGS="-I. -I../include $CPPFLAGS"
1634 if test "$srcdir" != "."; then
1635 CPPFLAGS="-I\${srcdir}/../include $CPPFLAGS"
1637 if test "$GCC" != yes; then
1638 CPPFLAGS="$CPPFLAGS -I\${includedir}"
1639 elif test "$includedir" != "/usr/include"; then
1640 if test "$includedir" = '${prefix}/include' ; then
1641 if test $prefix != /usr ; then
1642 CPPFLAGS="$CPPFLAGS -I\${includedir}"
1645 CPPFLAGS="$CPPFLAGS -I\${includedir}"
1650 dnl ---------------------------------------------------------------------------
1651 dnl CF_INTEL_COMPILER version: 3 updated: 2005/08/06 18:37:29
1652 dnl -----------------
1653 dnl Check if the given compiler is really the Intel compiler for Linux. It
1654 dnl tries to imitate gcc, but does not return an error when it finds a mismatch
1655 dnl between prototypes, e.g., as exercised by CF_MISSING_CHECK.
1657 dnl This macro should be run "soon" after AC_PROG_CC or AC_PROG_CPLUSPLUS, to
1658 dnl ensure that it is not mistaken for gcc/g++. It is normally invoked from
1659 dnl the wrappers for gcc and g++ warnings.
1661 dnl $1 = GCC (default) or GXX
1662 dnl $2 = INTEL_COMPILER (default) or INTEL_CPLUSPLUS
1663 dnl $3 = CFLAGS (default) or CXXFLAGS
1664 AC_DEFUN([CF_INTEL_COMPILER],[
1665 ifelse($2,,INTEL_COMPILER,[$2])=no
1667 if test "$ifelse($1,,[$1],GCC)" = yes ; then
1670 AC_MSG_CHECKING(if this is really Intel ifelse($1,GXX,C++,C) compiler)
1671 cf_save_CFLAGS="$ifelse($3,,CFLAGS,[$3])"
1672 ifelse($3,,CFLAGS,[$3])="$ifelse($3,,CFLAGS,[$3]) -no-gcc"
1674 #ifdef __INTEL_COMPILER
1678 ],[ifelse($2,,INTEL_COMPILER,[$2])=yes
1679 cf_save_CFLAGS="$cf_save_CFLAGS -we147 -no-gcc"
1681 ifelse($3,,CFLAGS,[$3])="$cf_save_CFLAGS"
1682 AC_MSG_RESULT($ifelse($2,,INTEL_COMPILER,[$2]))
1687 dnl ---------------------------------------------------------------------------
1688 dnl CF_ISASCII version: 3 updated: 2000/08/12 23:18:52
1690 dnl Check if we have either a function or macro for 'isascii()'.
1691 AC_DEFUN([CF_ISASCII],
1693 AC_MSG_CHECKING(for isascii)
1694 AC_CACHE_VAL(cf_cv_have_isascii,[
1695 AC_TRY_LINK([#include <ctype.h>],[int x = isascii(' ')],
1696 [cf_cv_have_isascii=yes],
1697 [cf_cv_have_isascii=no])
1699 AC_MSG_RESULT($cf_cv_have_isascii)
1700 test "$cf_cv_have_isascii" = yes && AC_DEFINE(HAVE_ISASCII)
1702 dnl ---------------------------------------------------------------------------
1703 dnl CF_LARGEFILE version: 6 updated: 2006/09/23 19:07:52
1705 dnl Add checks for large file support.
1706 AC_DEFUN([CF_LARGEFILE],[
1707 ifdef([AC_FUNC_FSEEKO],[
1709 if test "$enable_largefile" != no ; then
1712 # Normally we would collect these definitions in the config.h,
1713 # but (like _XOPEN_SOURCE), some environments rely on having these
1714 # defined before any of the system headers are included. Another
1715 # case comes up with C++, e.g., on AIX the compiler compiles the
1716 # header files by themselves before looking at the body files it is
1717 # told to compile. For ncurses, those header files do not include
1719 test "$ac_cv_sys_large_files" != no && CPPFLAGS="$CPPFLAGS -D_LARGE_FILES "
1720 test "$ac_cv_sys_largefile_source" != no && CPPFLAGS="$CPPFLAGS -D_LARGEFILE_SOURCE "
1722 AC_CACHE_CHECK(whether to use struct dirent64, cf_cv_struct_dirent64,[
1724 #include <sys/types.h>
1727 /* if transitional largefile support is setup, this is true */
1728 extern struct dirent64 * readdir(DIR *);
1729 struct dirent64 *x = readdir((DIR *)0);
1730 struct dirent *y = readdir((DIR *)0);
1733 [cf_cv_struct_dirent64=yes],
1734 [cf_cv_struct_dirent64=no])
1736 test "$cf_cv_struct_dirent64" = yes && AC_DEFINE(HAVE_STRUCT_DIRENT64)
1740 dnl ---------------------------------------------------------------------------
1741 dnl CF_LIBUTF8 version: 2 updated: 2002/01/19 22:51:32
1743 dnl Check for libutf8
1744 AC_DEFUN([CF_LIBUTF8],
1746 AC_CACHE_CHECK(for putwc in libutf8,cf_cv_libutf8,[
1747 cf_save_LIBS="$LIBS"
1750 #include <libutf8.h>],[putwc(0,0);],
1751 [cf_cv_libutf8=yes],
1753 LIBS="$cf_save_LIBS"
1756 if test "$cf_cv_libutf8" = yes ; then
1757 AC_DEFINE(HAVE_LIBUTF8_H)
1761 dnl ---------------------------------------------------------------------------
1762 dnl CF_LIB_PREFIX version: 7 updated: 2001/01/12 01:23:48
1764 dnl Compute the library-prefix for the given host system
1765 dnl $1 = variable to set
1766 AC_DEFUN([CF_LIB_PREFIX],
1768 case $cf_cv_system_name in
1769 OS/2*) LIB_PREFIX='' ;;
1770 os2*) LIB_PREFIX='' ;;
1771 *) LIB_PREFIX='lib' ;;
1773 ifelse($1,,,[$1=$LIB_PREFIX])
1774 AC_SUBST(LIB_PREFIX)
1776 dnl ---------------------------------------------------------------------------
1777 dnl CF_LIB_RULES version: 49 updated: 2007/02/24 17:12:45
1779 dnl Append definitions and rules for the given models to the subdirectory
1780 dnl Makefiles, and the recursion rule for the top-level Makefile. If the
1781 dnl subdirectory is a library-source directory, modify the LIBS_TO_MAKE list in
1782 dnl the corresponding makefile to list the models that we'll generate.
1784 dnl For shared libraries, make a list of symbolic links to construct when
1785 dnl generating each library. The convention used for Linux is the simplest
1788 dnl lib<name>.so.<major> ->
1789 dnl lib<name>.so.<maj>.<minor>
1790 AC_DEFUN([CF_LIB_RULES],
1792 CF_LIB_PREFIX(cf_prefix)
1793 AC_REQUIRE([CF_SUBST_NCURSES_VERSION])
1794 for cf_dir in $SRC_SUBDIRS
1796 if test ! -d $srcdir/$cf_dir ; then
1798 elif test -f $srcdir/$cf_dir/modules; then
1802 for cf_item in $cf_LIST_MODELS
1804 CF_LIB_SUFFIX($cf_item,cf_suffix)
1805 if test $cf_item = shared ; then
1806 if test "$cf_cv_do_symlinks" = yes ; then
1807 case "$cf_cv_shlib_version" in #(vi
1809 case "$cf_cv_system_name" in #(vi
1811 case .${LIB_SUFFIX} in
1813 cf_suffix=`echo $cf_suffix | sed 's/^w//'`
1814 cf_suffix=w'.${REL_VERSION}'"$cf_suffix"
1817 cf_suffix='.${REL_VERSION}'"$cf_suffix"
1821 *) cf_suffix="$cf_suffix"'.${REL_VERSION}' ;;
1825 case "$cf_cv_system_name" in #(vi
1827 case .${LIB_SUFFIX} in
1829 cf_suffix=`echo $cf_suffix | sed 's/^w//'`
1830 cf_suffix=w'.${ABI_VERSION}'"$cf_suffix"
1833 cf_suffix='.${ABI_VERSION}'"$cf_suffix"
1837 *) cf_suffix="$cf_suffix"'.${ABI_VERSION}' ;;
1842 # cygwin needs import library, and has unique naming convention
1843 # use autodetected ${cf_prefix} for import lib and static lib, but
1844 # use 'cyg' prefix for shared lib.
1845 if test $cf_cv_shlib_version = cygdll ; then
1846 LIBS_TO_MAKE="$LIBS_TO_MAKE ../lib/cyg${cf_dir}\${ABI_VERSION}.dll"
1850 LIBS_TO_MAKE="$LIBS_TO_MAKE ../lib/${cf_prefix}${cf_dir}${cf_suffix}"
1853 if test $cf_dir = ncurses ; then
1854 cf_subsets="$LIB_SUBSETS"
1855 cf_r_parts="$cf_subsets"
1857 while test -n "$cf_r_parts"
1859 cf_l_parts=`echo "$cf_r_parts" |sed -e 's/ .*$//'`
1860 cf_r_parts=`echo "$cf_r_parts" |sed -e 's/^[[^ ]]* //'`
1861 if test "$cf_l_parts" != "$cf_r_parts" ; then
1862 case $cf_l_parts in #(vi
1864 cf_item=`echo $LIBS_TO_MAKE |sed -e s%${LIB_NAME}${LIB_SUFFIX}%${TINFO_LIB_SUFFIX}%g`
1867 cf_item=`echo $LIBS_TO_MAKE |sed -e s%${LIB_NAME}${LIB_SUFFIX}%${TICS_LIB_SUFFIX}%g`
1873 LIBS_TO_MAKE="$cf_item $LIBS_TO_MAKE"
1879 cf_subsets=`echo "$LIB_SUBSETS" | sed -e 's/^termlib.* //'`
1882 sed -e "s%@LIBS_TO_MAKE@%$LIBS_TO_MAKE%" \
1883 -e "s%@SHARED_LIB@%$SHARED_LIB%" \
1884 $cf_dir/Makefile >$cf_dir/Makefile.out
1885 mv $cf_dir/Makefile.out $cf_dir/Makefile
1887 $AWK -f $srcdir/mk-0th.awk \
1888 libname="${cf_dir}${LIB_SUFFIX}" subsets="$LIB_SUBSETS" \
1889 $srcdir/$cf_dir/modules >>$cf_dir/Makefile
1891 for cf_subset in $cf_subsets
1894 for cf_item in $cf_LIST_MODELS
1896 echo "Appending rules for ${cf_item} model (${cf_dir}: ${cf_subset})"
1897 CF_UPPER(cf_ITEM,$cf_item)
1898 CF_LIB_SUFFIX($cf_item,cf_suffix)
1899 CF_OBJ_SUBDIR($cf_item,cf_subdir)
1901 # Test for case where we build libtinfo with a different name.
1903 if test $cf_dir = ncurses ; then
1908 cf_libname=$TINFO_LIB_SUFFIX
1909 if test -n "${DFT_ARG_SUFFIX}" ; then
1910 # undo $LIB_SUFFIX add-on in CF_LIB_SUFFIX
1911 cf_suffix=`echo $cf_suffix |sed -e "s%^${LIB_SUFFIX}%%"`
1915 cf_libname=$TICS_LIB_SUFFIX
1916 if test -n "${DFT_ARG_SUFFIX}" ; then
1917 # undo $LIB_SUFFIX add-on in CF_LIB_SUFFIX
1918 cf_suffix=`echo $cf_suffix |sed -e "s%^${LIB_SUFFIX}%%"`
1924 # These dependencies really are for development, not
1925 # builds, but they are useful in porting, too.
1926 cf_depend="../include/ncurses_cfg.h"
1927 if test "$srcdir" = "."; then
1930 cf_reldir="\${srcdir}"
1933 if test -f $srcdir/$cf_dir/$cf_dir.priv.h; then
1934 cf_depend="$cf_depend $cf_reldir/$cf_dir.priv.h"
1935 elif test -f $srcdir/$cf_dir/curses.priv.h; then
1936 cf_depend="$cf_depend $cf_reldir/curses.priv.h"
1940 old_cf_suffix="$cf_suffix"
1941 if test "$cf_cv_shlib_version_infix" = yes ; then
1942 if test -n "$LIB_SUFFIX" ; then
1945 cf_libname=`echo $cf_libname | sed 's/w$//'`
1946 cf_suffix=`echo $cf_suffix | sed 's/^w//'`
1953 $AWK -f $srcdir/mk-1st.awk \
1954 name=${cf_libname}${cf_dir_suffix} \
1955 traces=$LIB_TRACING \
1961 TermlibRoot=$TINFO_ARG_SUFFIX \
1962 ShlibVer=$cf_cv_shlib_version \
1963 ShlibVerInfix=$cf_cv_shlib_version_infix \
1964 ReLink=${cf_cv_do_relink-no} \
1965 DoLinks=$cf_cv_do_symlinks \
1966 rmSoLocs=$cf_cv_rm_so_locs \
1967 ldconfig="$LDCONFIG" \
1968 overwrite=$WITH_OVERWRITE \
1969 depend="$cf_depend" \
1971 $srcdir/$cf_dir/modules >>$cf_dir/Makefile
1973 cf_suffix="$old_cf_suffix"
1975 for cf_subdir2 in $cf_subdirs lib
1977 test $cf_subdir = $cf_subdir2 && break
1979 test "${cf_subset}.${cf_subdir2}" != "${cf_subset}.${cf_subdir}" && \
1980 $AWK -f $srcdir/mk-2nd.awk \
1982 traces=$LIB_TRACING \
1988 crenames=$cf_cv_prog_CC_c_o \
1989 cxxrenames=$cf_cv_prog_CXX_c_o \
1990 $srcdir/$cf_dir/modules >>$cf_dir/Makefile
1991 cf_subdirs="$cf_subdirs $cf_subdir"
1996 echo ' cd '$cf_dir' && ${MAKE} ${CF_MFLAGS} [$]@' >>Makefile
1999 for cf_dir in $SRC_SUBDIRS
2001 if test ! -d $srcdir/$cf_dir ; then
2005 if test -f $cf_dir/Makefile ; then
2008 echo 'libs \' >> Makefile
2009 echo 'install.libs \' >> Makefile
2010 echo 'uninstall.libs ::' >> Makefile
2011 echo ' cd '$cf_dir' && ${MAKE} ${CF_MFLAGS} [$]@' >> Makefile
2016 if test -f $srcdir/$cf_dir/modules; then
2018 if test -f $srcdir/$cf_dir/headers; then
2019 cat >> Makefile <<CF_EOF
2021 uninstall.includes \\
2024 if test "$cf_dir" != "c++" ; then
2025 echo 'lint \' >> Makefile
2027 cat >> Makefile <<CF_EOF
2033 uninstall.$cf_dir ::
2034 cd $cf_dir && \${MAKE} \${CF_MFLAGS} \[$]@
2036 elif test -f $srcdir/$cf_dir/headers; then
2037 cat >> Makefile <<CF_EOF
2043 uninstall.includes ::
2044 cd $cf_dir && \${MAKE} \${CF_MFLAGS} \[$]@
2049 cat >> Makefile <<CF_EOF
2051 install.libs uninstall.libs \\
2052 install.data uninstall.data ::
2053 $MAKE_TERMINFO cd misc && \${MAKE} \${CF_MFLAGS} \[$]@
2057 cd man && \${MAKE} \${CF_MFLAGS} \[$]@
2060 rm -f config.cache config.log config.status Makefile include/ncurses_cfg.h
2061 rm -f headers.sh headers.sed mk_shared_lib.sh
2062 rm -rf \${DIRS_TO_MAKE}
2065 # Special case: tack's manpage lives in its own directory.
2066 if test -d tack ; then
2067 if test -f $srcdir/$tack.h; then
2068 cat >> Makefile <<CF_EOF
2072 cd tack && \${MAKE} \${CF_MFLAGS} \[$]@
2077 dnl If we're installing into a subdirectory of /usr/include, etc., we should
2078 dnl prepend the subdirectory's name to the "#include" paths. It won't hurt
2079 dnl anything, and will make it more standardized. It's awkward to decide this
2080 dnl at configuration because of quoting, so we'll simply make all headers
2081 dnl installed via a script that can do the right thing.
2083 rm -f headers.sed headers.sh
2085 dnl ( generating this script makes the makefiles a little tidier :-)
2086 echo creating headers.sh
2087 cat >headers.sh <<CF_EOF
2089 # This shell script is generated by the 'configure' script. It is invoked in a
2090 # subdirectory of the build tree. It generates a sed-script in the parent
2091 # directory that is used to adjust includes for header files that reside in a
2092 # subdirectory of /usr/include, etc.
2094 while test \[$]# != 3
2096 PRG="\$PRG \[$]1"; shift
2101 TMPSRC=\${TMPDIR-/tmp}/\`basename \$SRC\`\$\$
2102 TMPSED=\${TMPDIR-/tmp}/headers.sed\$\$
2103 echo installing \$SRC in \$DST
2106 if test $WITH_CURSES_H = yes; then
2107 cat >>headers.sh <<CF_EOF
2110 END=\`basename \$DST\`
2111 for i in \`cat \$REF/../*/headers |fgrep -v "#"\`
2113 NAME=\`basename \$i\`
2114 echo "s/<\$NAME>/<\$END\/\$NAME>/" >> \$TMPSED
2124 cat >>headers.sh <<CF_EOF
2127 END=\`basename \$DST\`
2128 for i in \`cat \$REF/../*/headers |fgrep -v "#"\`
2130 NAME=\`basename \$i\`
2131 if test "\$NAME" = "curses.h"
2133 echo "s/<curses.h>/<ncurses.h>/" >> \$TMPSED
2136 echo "s/<\$NAME>/<\$END\/\$NAME>/" >> \$TMPSED
2140 echo "s/<curses.h>/<ncurses.h>/" >> \$TMPSED
2145 cat >>headers.sh <<CF_EOF
2147 sed -f \$TMPSED \$SRC > \$TMPSRC
2148 NAME=\`basename \$SRC\`
2150 if test $WITH_CURSES_H != yes; then
2151 cat >>headers.sh <<CF_EOF
2152 test "\$NAME" = "curses.h" && NAME=ncurses.h
2155 cat >>headers.sh <<CF_EOF
2156 # Just in case someone gzip'd manpages, remove the conflicting copy.
2157 test -f \$DST/\$NAME.gz && rm -f \$DST/\$NAME.gz
2159 eval \$PRG \$TMPSRC \$DST/\$NAME
2160 rm -f \$TMPSRC \$TMPSED
2163 chmod 0755 headers.sh
2165 for cf_dir in $SRC_SUBDIRS
2167 if test ! -d $srcdir/$cf_dir ; then
2171 if test -f $srcdir/$cf_dir/headers; then
2172 $AWK -f $srcdir/mk-hdr.awk \
2173 subset="$LIB_SUBSETS" \
2174 compat="$WITH_CURSES_H" \
2175 $srcdir/$cf_dir/headers >>$cf_dir/Makefile
2178 if test -f $srcdir/$cf_dir/modules; then
2179 if test "$cf_dir" != "c++" ; then
2180 cat >>$cf_dir/Makefile <<"CF_EOF"
2181 depend : ${AUTO_SRC}
2182 makedepend -- ${CPPFLAGS} -- ${C_SRC}
2184 # DO NOT DELETE THIS LINE -- make depend depends on it.
2191 dnl ---------------------------------------------------------------------------
2192 dnl CF_LIB_SONAME version: 3 updated: 2006/12/16 15:55:46
2194 dnl Find the and soname for the given shared library. Set the cache variable
2195 dnl cf_cv_$3_soname to this, unless it is not found. Then set the cache
2196 dnl variable to "unknown".
2200 dnl $3 = library name
2201 AC_DEFUN([CF_LIB_SONAME],
2203 AC_CACHE_CHECK(for soname of $3 library,cf_cv_$3_soname,[
2205 cf_cv_$3_soname=unknown
2206 if test "$cross_compiling" != yes ; then
2207 cat >conftest.$ac_ext <<CF_EOF
2212 ${cf_cv_main_return:-return}(0);
2215 cf_save_LIBS="$LIBS"
2217 if AC_TRY_EVAL(ac_compile) ; then
2218 if AC_TRY_EVAL(ac_link) ; then
2219 cf_cv_$3_soname=`ldd conftest$ac_exeext 2>/dev/null | sed -e 's,^.*/,,' -e 's, .*$,,' | fgrep lib$3.`
2220 test -z "$cf_cv_$3_soname" && cf_cv_$3_soname=unknown
2224 LIBS="$cf_save_LIBS"
2228 dnl ---------------------------------------------------------------------------
2229 dnl CF_LIB_SUFFIX version: 13 updated: 2003/11/01 16:09:07
2231 dnl Compute the library file-suffix from the given model name
2233 dnl $2 = variable to set
2234 dnl The variable $LIB_SUFFIX, if set, prepends the variable to set.
2235 AC_DEFUN([CF_LIB_SUFFIX],
2237 AC_REQUIRE([CF_SUBST_NCURSES_VERSION])
2239 libtool) $2='.la' ;;
2242 profile) $2='_p.a' ;;
2244 case $cf_cv_system_name in
2245 cygwin*) $2='.dll' ;;
2246 darwin*) $2='.dylib' ;;
2256 test -n "$LIB_SUFFIX" && $2="${LIB_SUFFIX}[$]{$2}"
2258 dnl ---------------------------------------------------------------------------
2259 dnl CF_LIB_TYPE version: 4 updated: 2000/10/20 22:57:49
2261 dnl Compute the string to append to -library from the given model name
2263 dnl $2 = variable to set
2264 dnl The variable $LIB_SUFFIX, if set, prepends the variable to set.
2265 AC_DEFUN([CF_LIB_TYPE],
2274 test -n "$LIB_SUFFIX" && $2="${LIB_SUFFIX}[$]{$2}"
2276 dnl ---------------------------------------------------------------------------
2277 dnl CF_LINK_DATAONLY version: 8 updated: 2006/12/16 12:33:30
2278 dnl ----------------
2279 dnl Some systems have a non-ANSI linker that doesn't pull in modules that have
2280 dnl only data (i.e., no functions), for example NeXT. On those systems we'll
2281 dnl have to provide wrappers for global tables to ensure they're linked
2283 AC_DEFUN([CF_LINK_DATAONLY],
2285 AC_MSG_CHECKING([if data-only library module links])
2286 AC_CACHE_VAL(cf_cv_link_dataonly,[
2288 cat >conftest.$ac_ext <<EOF
2289 #line __oline__ "configure"
2290 int testdata[[3]] = { 123, 456, 789 };
2292 if AC_TRY_EVAL(ac_compile) ; then
2293 mv conftest.o data.o && \
2294 ( $AR $AR_OPTS conftest.a data.o ) 2>&AC_FD_CC 1>/dev/null
2296 rm -f conftest.$ac_ext data.o
2297 cat >conftest.$ac_ext <<EOF
2298 #line __oline__ "configure"
2302 ${cf_cv_main_return:-return}(1); /* I'm told this linker is broken */
2304 extern int testdata[[3]];
2305 return testdata[[0]] == 123
2306 && testdata[[1]] == 456
2307 && testdata[[2]] == 789;
2311 if AC_TRY_EVAL(ac_compile); then
2312 mv conftest.o func.o && \
2313 ( $AR $AR_OPTS conftest.a func.o ) 2>&AC_FD_CC 1>/dev/null
2315 rm -f conftest.$ac_ext func.o
2316 ( eval $RANLIB conftest.a ) 2>&AC_FD_CC >/dev/null
2318 LIBS="conftest.a $LIBS"
2322 extern int testfunc();
2323 ${cf_cv_main_return:-return} (!testfunc());
2326 [cf_cv_link_dataonly=yes],
2327 [cf_cv_link_dataonly=no],
2328 [cf_cv_link_dataonly=unknown])
2331 AC_MSG_RESULT($cf_cv_link_dataonly)
2333 if test "$cf_cv_link_dataonly" = no ; then
2334 AC_DEFINE(BROKEN_LINKER)
2339 dnl ---------------------------------------------------------------------------
2340 dnl CF_LINK_FUNCS version: 7 updated: 2006/12/16 12:33:30
2342 dnl Most Unix systems have both link and symlink, a few don't have symlink.
2343 dnl A few non-Unix systems implement symlink, but not link.
2344 dnl A few non-systems implement neither (or have nonfunctional versions).
2345 AC_DEFUN([CF_LINK_FUNCS],
2351 if test "$cross_compiling" = yes ; then
2356 AC_CACHE_CHECK(if link/symlink functions work,cf_cv_link_funcs,[
2358 for cf_func in link symlink ; do
2360 #include <sys/types.h>
2361 #include <sys/stat.h>
2362 #ifdef HAVE_UNISTD_H
2368 char *src = "config.log";
2369 char *dst = "conftest.chk";
2374 fail = ($cf_func("config.log", "conftest.chk") < 0)
2375 || (stat(dst, &dst_sb) < 0)
2376 || (dst_sb.st_mtime != src_sb.st_mtime);
2382 ${cf_cv_main_return:-return} (fail);
2385 cf_cv_link_funcs="$cf_cv_link_funcs $cf_func"
2386 eval 'ac_cv_func_'$cf_func'=yes'],[
2387 eval 'ac_cv_func_'$cf_func'=no'],[
2388 eval 'ac_cv_func_'$cf_func'=error'])
2390 test -z "$cf_cv_link_funcs" && cf_cv_link_funcs=no
2392 test "$ac_cv_func_link" = yes && AC_DEFINE(HAVE_LINK)
2393 test "$ac_cv_func_symlink" = yes && AC_DEFINE(HAVE_SYMLINK)
2396 dnl ---------------------------------------------------------------------------
2397 dnl CF_MAIN_RETURN version: 1 updated: 2006/12/10 09:51:54
2399 dnl Check if a return from main to the shell actually returns the same exit
2400 dnl code. This is true for almost any POSIX environment.
2402 dnl Some very old environments did not flush stdout, etc., on an exit. That
2403 dnl would be a useful case to test for also.
2404 AC_DEFUN([CF_MAIN_RETURN],
2406 cf_cv_main_return=return
2408 dnl ---------------------------------------------------------------------------
2409 dnl CF_MAKEFLAGS version: 12 updated: 2006/10/21 08:27:03
2411 dnl Some 'make' programs support ${MAKEFLAGS}, some ${MFLAGS}, to pass 'make'
2412 dnl options to lower-levels. It's very useful for "make -n" -- if we have it.
2413 dnl (GNU 'make' does both, something POSIX 'make', which happens to make the
2414 dnl ${MAKEFLAGS} variable incompatible because it adds the assignments :-)
2415 AC_DEFUN([CF_MAKEFLAGS],
2417 AC_CACHE_CHECK(for makeflags variable, cf_cv_makeflags,[
2419 for cf_option in '-${MAKEFLAGS}' '${MFLAGS}'
2421 cat >cf_makeflags.tmp <<CF_EOF
2424 @ echo '.$cf_option'
2426 cf_result=`${MAKE-make} -k -f cf_makeflags.tmp 2>/dev/null | sed -e 's,[[ ]]*$,,'`
2427 case "$cf_result" in
2429 cf_result=`${MAKE-make} -k -f cf_makeflags.tmp CC=cc 2>/dev/null`
2430 case "$cf_result" in
2431 .*CC=*) cf_cv_makeflags=
2433 *) cf_cv_makeflags=$cf_option
2439 *) echo "given option \"$cf_option\", no match \"$cf_result\""
2443 rm -f cf_makeflags.tmp
2446 AC_SUBST(cf_cv_makeflags)
2448 dnl ---------------------------------------------------------------------------
2449 dnl CF_MAKE_TAGS version: 2 updated: 2000/10/04 09:18:40
2451 dnl Generate tags/TAGS targets for makefiles. Do not generate TAGS if we have
2452 dnl a monocase filesystem.
2453 AC_DEFUN([CF_MAKE_TAGS],[
2454 AC_REQUIRE([CF_MIXEDCASE_FILENAMES])
2455 AC_CHECK_PROG(MAKE_LOWER_TAGS, ctags, yes, no)
2457 if test "$cf_cv_mixedcase" = yes ; then
2458 AC_CHECK_PROG(MAKE_UPPER_TAGS, etags, yes, no)
2463 if test "$MAKE_UPPER_TAGS" = yes ; then
2468 AC_SUBST(MAKE_UPPER_TAGS)
2470 if test "$MAKE_LOWER_TAGS" = yes ; then
2475 AC_SUBST(MAKE_LOWER_TAGS)
2477 dnl ---------------------------------------------------------------------------
2478 dnl CF_MANPAGE_FORMAT version: 7 updated: 2003/12/20 19:30:34
2479 dnl -----------------
2480 dnl Option to allow user to override automatic configuration of manpage format.
2481 dnl There are several special cases:
2483 dnl gzip - man checks for, can display gzip'd files
2484 dnl compress - man checks for, can display compressed files
2485 dnl BSDI - files in the cat-directories are suffixed ".0"
2486 dnl formatted - installer should format (put files in cat-directory)
2487 dnl catonly - installer should only format, e.g., for a turnkey system.
2489 dnl There are other configurations which this macro does not test, e.g., HPUX's
2490 dnl compressed manpages (but uncompressed manpages are fine, and HPUX's naming
2491 dnl convention would not match our use).
2492 AC_DEFUN([CF_MANPAGE_FORMAT],
2494 AC_REQUIRE([CF_PATHSEP])
2495 AC_MSG_CHECKING(format of man-pages)
2497 AC_ARG_WITH(manpage-format,
2498 [ --with-manpage-format specify manpage-format: gzip/compress/BSDI/normal and
2499 optionally formatted/catonly, e.g., gzip,formatted],
2500 [MANPAGE_FORMAT=$withval],
2501 [MANPAGE_FORMAT=unknown])
2503 test -z "$MANPAGE_FORMAT" && MANPAGE_FORMAT=unknown
2504 MANPAGE_FORMAT=`echo "$MANPAGE_FORMAT" | sed -e 's/,/ /g'`
2508 case $MANPAGE_FORMAT in
2510 if test -z "$MANPATH" ; then
2511 MANPATH="/usr/man:/usr/share/man"
2514 # look for the 'date' man-page (it's most likely to be installed!)
2520 IFS="${IFS= }"; ac_save_ifs="$IFS"; IFS="${IFS}${PATHSEP}"
2521 for cf_dir in $MANPATH; do
2522 test -z "$cf_dir" && cf_dir=/usr/man
2523 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
2525 cf_test=`echo $cf_name | sed -e 's/*//'`
2526 if test "x$cf_test" = "x$cf_name" ; then
2529 *.gz) MANPAGE_FORMAT="$MANPAGE_FORMAT gzip";;
2530 *.Z) MANPAGE_FORMAT="$MANPAGE_FORMAT compress";;
2531 *.0) MANPAGE_FORMAT="$MANPAGE_FORMAT BSDI";;
2532 *) MANPAGE_FORMAT="$MANPAGE_FORMAT normal";;
2546 # if we found a match in either man* or cat*, stop looking
2547 if test -n "$MANPAGE_FORMAT" ; then
2549 test "$cf_preform" = yes && MANPAGE_FORMAT="$MANPAGE_FORMAT formatted"
2550 test "$cf_catonly" = yes && MANPAGE_FORMAT="$MANPAGE_FORMAT catonly"
2556 test $cf_found=yes && break
2559 # only check the first directory in $MANPATH where we find manpages
2560 if test -n "$MANPAGE_FORMAT" ; then
2564 # if we did not find the example, just assume it is normal
2565 test -z "$MANPAGE_FORMAT" && MANPAGE_FORMAT=normal
2569 for cf_option in $MANPAGE_FORMAT; do
2570 case $cf_option in #(vi
2571 gzip|compress|BSDI|normal|formatted|catonly)
2574 cf_unknown="$cf_unknown $cf_option"
2581 AC_MSG_RESULT($MANPAGE_FORMAT)
2582 if test -n "$cf_unknown" ; then
2583 AC_MSG_WARN(Unexpected manpage-format $cf_unknown)
2586 dnl ---------------------------------------------------------------------------
2587 dnl CF_MANPAGE_RENAMES version: 7 updated: 2005/06/18 18:51:57
2588 dnl ------------------
2589 dnl The Debian people have their own naming convention for manpages. This
2590 dnl option lets us override the name of the file containing renaming, or
2591 dnl disable it altogether.
2592 AC_DEFUN([CF_MANPAGE_RENAMES],
2594 AC_MSG_CHECKING(for manpage renaming)
2596 AC_ARG_WITH(manpage-renames,
2597 [ --with-manpage-renames specify manpage-renaming],
2598 [MANPAGE_RENAMES=$withval],
2599 [MANPAGE_RENAMES=yes])
2601 case ".$MANPAGE_RENAMES" in #(vi
2605 # Debian 'man' program?
2606 if test -f /etc/debian_version ; then
2607 MANPAGE_RENAMES=`cd $srcdir && pwd`/man/man_db.renames
2614 if test "$MANPAGE_RENAMES" != no ; then
2615 if test -f $srcdir/man/$MANPAGE_RENAMES ; then
2616 MANPAGE_RENAMES=`cd $srcdir/man && pwd`/$MANPAGE_RENAMES
2617 elif test ! -f $MANPAGE_RENAMES ; then
2618 AC_MSG_ERROR(not a filename: $MANPAGE_RENAMES)
2621 test ! -d man && mkdir man
2623 # Construct a sed-script to perform renaming within man-pages
2624 if test -n "$MANPAGE_RENAMES" ; then
2625 test ! -d man && mkdir man
2626 sh $srcdir/man/make_sed.sh $MANPAGE_RENAMES >./edit_man.sed
2630 AC_MSG_RESULT($MANPAGE_RENAMES)
2631 AC_SUBST(MANPAGE_RENAMES)
2633 dnl ---------------------------------------------------------------------------
2634 dnl CF_MANPAGE_SYMLINKS version: 4 updated: 2003/12/13 18:01:58
2635 dnl -------------------
2636 dnl Some people expect each tool to make all aliases for manpages in the
2637 dnl man-directory. This accommodates the older, less-capable implementations
2638 dnl of 'man', and is optional.
2639 AC_DEFUN([CF_MANPAGE_SYMLINKS],
2641 AC_MSG_CHECKING(if manpage aliases will be installed)
2643 AC_ARG_WITH(manpage-aliases,
2644 [ --with-manpage-aliases specify manpage-aliases using .so],
2645 [MANPAGE_ALIASES=$withval],
2646 [MANPAGE_ALIASES=yes])
2648 AC_MSG_RESULT($MANPAGE_ALIASES)
2650 if test "$LN_S" = "ln -s"; then
2657 if test "$MANPAGE_ALIASES" = yes ; then
2658 AC_MSG_CHECKING(if manpage symlinks should be used)
2660 AC_ARG_WITH(manpage-symlinks,
2661 [ --with-manpage-symlinks specify manpage-aliases using symlinks],
2662 [MANPAGE_SYMLINKS=$withval],
2663 [MANPAGE_SYMLINKS=$cf_use_symlinks])
2665 if test "$$cf_use_symlinks" = no; then
2666 if test "$MANPAGE_SYMLINKS" = yes ; then
2667 AC_MSG_WARN(cannot make symlinks, will use .so files)
2672 AC_MSG_RESULT($MANPAGE_SYMLINKS)
2676 dnl ---------------------------------------------------------------------------
2677 dnl CF_MANPAGE_TBL version: 3 updated: 2002/01/19 22:51:32
2679 dnl This option causes manpages to be run through tbl(1) to generate tables
2681 AC_DEFUN([CF_MANPAGE_TBL],
2683 AC_MSG_CHECKING(for manpage tbl)
2685 AC_ARG_WITH(manpage-tbl,
2686 [ --with-manpage-tbl specify manpage processing with tbl],
2687 [MANPAGE_TBL=$withval],
2690 AC_MSG_RESULT($MANPAGE_TBL)
2692 dnl ---------------------------------------------------------------------------
2693 dnl CF_MAN_PAGES version: 33 updated: 2007/02/24 14:42:36
2695 dnl Try to determine if the man-pages on the system are compressed, and if
2696 dnl so, what format is used. Use this information to construct a script that
2697 dnl will install man-pages.
2698 AC_DEFUN([CF_MAN_PAGES],
2700 CF_HELP_MESSAGE(Options to Specify How Manpages are Installed:)
2706 if test "$prefix" = "NONE" ; then
2707 cf_prefix="$ac_default_prefix"
2712 case "$MANPAGE_FORMAT" in # (vi
2727 test ! -d man && mkdir man
2731 case "$MANPAGE_FORMAT" in #(vi
2734 cf_compress=compress
2742 cf_edit_man=./edit_man.sh
2743 cf_man_alias=`pwd`/man_alias.sed
2745 cat >$cf_edit_man <<CF_EOF
2747 # this script is generated by the configure-script CF_MAN_PAGES macro.
2752 NCURSES_MAJOR="$NCURSES_MAJOR"
2753 NCURSES_MINOR="$NCURSES_MINOR"
2754 NCURSES_PATCH="$NCURSES_PATCH"
2756 NCURSES_OSPEED="$NCURSES_OSPEED"
2757 TERMINFO="$TERMINFO"
2759 MKDIRS="sh `cd $srcdir && pwd`/mkinstalldirs"
2762 INSTALL_DATA="$INSTALL_DATA"
2764 transform="$program_transform_name"
2766 TMP=\${TMPDIR-/tmp}/man\$\$
2767 trap "rm -f \$TMP" 0 1 2 5 15
2779 top_srcdir=\[$]srcdir/..
2782 if test "\$form" = normal ; then
2783 if test "$cf_format" = yes ; then
2784 if test "$cf_inboth" = no ; then
2785 sh \[$]0 format \$verb \$mandir \$srcdir \[$]*
2789 cf_subdir=\$mandir/man
2790 cf_tables=$MANPAGE_TBL
2792 cf_subdir=\$mandir/cat
2796 # process the list of source-files
2799 *.orig|*.rej) ;; #(vi
2801 section=\`expr "\$i" : '.*\\.\\([[0-9]]\\)[[xm]]*'\`;
2802 if test \$verb = installing ; then
2803 if test ! -d \$cf_subdir\${section} ; then
2804 \$MKDIRS \$cf_subdir\$section
2808 # replace variables in man page
2809 if test ! -f $cf_man_alias ; then
2810 cat >>$cf_man_alias <<-CF_EOF2
2811 s,@DATADIR@,\$datadir,
2812 s,@TERMINFO@,\$TERMINFO,
2813 s,@NCURSES_MAJOR@,\$NCURSES_MAJOR,
2814 s,@NCURSES_MINOR@,\$NCURSES_MINOR,
2815 s,@NCURSES_PATCH@,\$NCURSES_PATCH,
2816 s,@NCURSES_OSPEED@,\$NCURSES_OSPEED,
2821 cf_NAME=`echo "$cf_name" | sed y%abcdefghijklmnopqrstuvwxyz./-%ABCDEFGHIJKLMNOPQRSTUVWXYZ___%`
2822 cf_name=`echo $cf_name|sed "$program_transform_name"`
2823 cat >>$cf_edit_man <<-CF_EOF
2824 s,@$cf_NAME@,$cf_name,
2828 cat >>$cf_edit_man <<CF_EOF
2830 echo "...made $cf_man_alias"
2834 cf_source=\`basename \$i\`
2836 test ! -f \$inalias && inalias="\$srcdir/\$inalias"
2837 if test ! -f \$inalias ; then
2838 echo .. skipped \$cf_source
2843 if test "$MANPAGE_ALIASES" != no ; then
2844 cat >>$cf_edit_man <<CF_EOF
2845 aliases=\`sed -f \$top_srcdir/man/manlinks.sed \$inalias |sed -f $cf_man_alias | sort -u\`
2849 if test "$MANPAGE_RENAMES" = no ; then
2850 cat >>$cf_edit_man <<CF_EOF
2851 # perform program transformations for section 1 man pages
2852 if test \$section = 1 ; then
2853 cf_target=\$cf_subdir\${section}/\`echo \$cf_source|sed "\${transform}"\`
2855 cf_target=\$cf_subdir\${section}/\$cf_source
2859 cat >>$cf_edit_man <<CF_EOF
2860 cf_target=\`grep "^\$cf_source" $MANPAGE_RENAMES | $AWK '{print \[$]2}'\`
2861 if test -z "\$cf_target" ; then
2862 echo '? missing rename for '\$cf_source
2863 cf_target="\$cf_source"
2865 cf_target="\$cf_subdir\${section}/\${cf_target}"
2870 cat >>$cf_edit_man <<CF_EOF
2871 sed -f $cf_man_alias \\
2874 if test -f $MANPAGE_RENAMES ; then
2875 cat >>$cf_edit_man <<CF_EOF
2876 < \$i | sed -f `pwd`/edit_man.sed >\$TMP
2879 cat >>$cf_edit_man <<CF_EOF
2884 cat >>$cf_edit_man <<CF_EOF
2885 if test \$cf_tables = yes ; then
2886 tbl \$TMP >\$TMP.out
2891 if test $with_curses_h != yes ; then
2892 cat >>$cf_edit_man <<CF_EOF
2893 sed -e "/\#[ ]*include/s,curses.h,ncurses.h," < \$TMP >\$TMP.out
2898 cat >>$cf_edit_man <<CF_EOF
2899 if test \$form = format ; then
2900 nroff -man \$TMP >\$TMP.out
2905 if test -n "$cf_compress" ; then
2906 cat >>$cf_edit_man <<CF_EOF
2907 if test \$verb = installing ; then
2908 if ( $cf_compress -f \$TMP )
2910 mv \$TMP.$cf_so_strip \$TMP
2913 cf_target="\$cf_target.$cf_so_strip"
2917 case "$MANPAGE_FORMAT" in #(vi
2919 cat >>$cf_edit_man <<CF_EOF
2920 if test \$form = format ; then
2921 # BSDI installs only .0 suffixes in the cat directories
2922 cf_target="\`echo \$cf_target|sed -e 's/\.[[1-9]]\+[[a-z]]*/.0/'\`"
2928 cat >>$cf_edit_man <<CF_EOF
2929 suffix=\`basename \$cf_target | sed -e 's%^[[^.]]*%%'\`
2930 if test \$verb = installing ; then
2931 echo \$verb \$cf_target
2932 \$INSTALL_DATA \$TMP \$cf_target
2933 test -d \$cf_subdir\${section} &&
2934 test -n "\$aliases" && (
2935 cd \$cf_subdir\${section} && (
2936 cf_source=\`echo \$cf_target |sed -e 's%^.*/\([[^/]][[^/]]*/[[^/]][[^/]]*$\)%\1%'\`
2937 test -n "$cf_so_strip" && cf_source=\`echo \$cf_source |sed -e 's%\.$cf_so_strip\$%%'\`
2938 cf_target=\`basename \$cf_target\`
2939 for cf_alias in \$aliases
2941 if test \$section = 1 ; then
2942 cf_alias=\`echo \$cf_alias|sed "\${transform}"\`
2945 if test "$MANPAGE_SYMLINKS" = yes ; then
2946 if test -f \$cf_alias\${suffix} ; then
2947 if ( cmp -s \$cf_target \$cf_alias\${suffix} )
2952 echo .. \$verb alias \$cf_alias\${suffix}
2953 rm -f \$cf_alias\${suffix}
2954 $LN_S \$cf_target \$cf_alias\${suffix}
2955 elif test "\$cf_target" != "\$cf_alias\${suffix}" ; then
2956 echo ".so \$cf_source" >\$TMP
2958 if test -n "$cf_compress" ; then
2959 cat >>$cf_edit_man <<CF_EOF
2960 if test -n "$cf_so_strip" ; then
2961 $cf_compress -f \$TMP
2962 mv \$TMP.$cf_so_strip \$TMP
2966 cat >>$cf_edit_man <<CF_EOF
2967 echo .. \$verb alias \$cf_alias\${suffix}
2968 rm -f \$cf_alias\${suffix}
2969 \$INSTALL_DATA \$TMP \$cf_alias\${suffix}
2974 elif test \$verb = removing ; then
2975 test -f \$cf_target && (
2976 echo \$verb \$cf_target
2979 test -d \$cf_subdir\${section} &&
2980 test -n "\$aliases" && (
2981 cd \$cf_subdir\${section} && (
2982 for cf_alias in \$aliases
2984 if test \$section = 1 ; then
2985 cf_alias=\`echo \$cf_alias|sed "\${transform}"\`
2988 echo .. \$verb alias \$cf_alias\${suffix}
2989 rm -f \$cf_alias\${suffix}
3001 if test $cf_inboth = yes ; then
3002 if test \$form != format ; then
3003 sh \[$]0 format \$verb \$mandir \$srcdir \[$]*
3009 chmod 755 $cf_edit_man
3012 dnl ---------------------------------------------------------------------------
3013 dnl CF_MATH_LIB version: 5 updated: 2000/05/28 01:39:10
3015 dnl Checks for libraries. At least one UNIX system, Apple Macintosh
3016 dnl Rhapsody 5.5, does not have -lm. We cannot use the simpler
3017 dnl AC_CHECK_LIB(m,sin), because that fails for C++.
3018 AC_DEFUN([CF_MATH_LIB],
3020 AC_CACHE_CHECK(if -lm needed for math functions,
3026 [double x = rand(); printf("result = %g\n", ]ifelse($2,,sin(x),$2)[)],
3027 [cf_cv_need_libm=no],
3028 [cf_cv_need_libm=yes])])
3029 if test "$cf_cv_need_libm" = yes
3036 dnl ---------------------------------------------------------------------------
3037 dnl CF_MIXEDCASE_FILENAMES version: 3 updated: 2003/09/20 17:07:55
3038 dnl ----------------------
3039 dnl Check if the file-system supports mixed-case filenames. If we're able to
3040 dnl create a lowercase name and see it as uppercase, it doesn't support that.
3041 AC_DEFUN([CF_MIXEDCASE_FILENAMES],
3043 AC_CACHE_CHECK(if filesystem supports mixed-case filenames,cf_cv_mixedcase,[
3044 if test "$cross_compiling" = yes ; then
3045 case $target_alias in #(vi
3046 *-os2-emx*|*-msdosdjgpp*|*-cygwin*|*-mingw32*|*-uwin*) #(vi
3054 rm -f conftest CONFTEST
3056 if test -f CONFTEST ; then
3061 rm -f conftest CONFTEST
3064 test "$cf_cv_mixedcase" = yes && AC_DEFINE(MIXEDCASE_FILENAMES)
3066 dnl ---------------------------------------------------------------------------
3067 dnl CF_MKSTEMP version: 5 updated: 2006/12/16 12:33:30
3069 dnl Check for a working mkstemp. This creates two files, checks that they are
3070 dnl successfully created and distinct (AmigaOS apparently fails on the last).
3071 AC_DEFUN([CF_MKSTEMP],[
3072 AC_CACHE_CHECK(for working mkstemp, cf_cv_func_mkstemp,[
3075 #include <sys/types.h>
3079 #include <sys/stat.h>
3082 char *tmpl = "conftestXXXXXX";
3090 for (n = 0; n < 2; ++n) {
3091 strcpy(name[n], tmpl);
3092 if ((fd = mkstemp(name[n])) >= 0) {
3093 if (!strcmp(name[n], tmpl)
3094 || stat(name[n], &sb) != 0
3095 || (sb.st_mode & S_IFMT) != S_IFREG
3096 || (sb.st_mode & 077) != 0) {
3103 && !strcmp(name[0], name[1]))
3105 ${cf_cv_main_return:-return}(result);
3107 ],[cf_cv_func_mkstemp=yes
3108 ],[cf_cv_func_mkstemp=no
3109 ],[AC_CHECK_FUNC(mkstemp)
3112 if test "$cf_cv_func_mkstemp" = yes ; then
3113 AC_DEFINE(HAVE_MKSTEMP)
3116 dnl ---------------------------------------------------------------------------
3117 dnl CF_MSG_LOG version: 3 updated: 1997/09/07 14:05:52
3119 dnl Write a debug message to config.log, along with the line number in the
3120 dnl configure script.
3121 AC_DEFUN([CF_MSG_LOG],[
3122 echo "(line __oline__) testing $* ..." 1>&AC_FD_CC
3124 dnl ---------------------------------------------------------------------------
3125 dnl CF_NCURSES_ABI_6 version: 1 updated: 2005/09/17 18:42:49
3126 dnl ----------------
3127 dnl Set ncurses' ABI to 6 unless overridden by explicit configure option, and
3128 dnl warn about this.
3129 AC_DEFUN([CF_NCURSES_ABI_6],[
3130 if test "${with_abi_version+set}" != set; then
3131 case $cf_cv_rel_version in
3133 cf_cv_rel_version=6.0
3135 AC_MSG_WARN(Overriding ABI version to $cf_cv_abi_version)
3140 dnl ---------------------------------------------------------------------------
3141 dnl CF_NO_LEAKS_OPTION version: 4 updated: 2006/12/16 14:24:05
3142 dnl ------------------
3143 dnl see CF_WITH_NO_LEAKS
3144 AC_DEFUN([CF_NO_LEAKS_OPTION],[
3145 AC_MSG_CHECKING(if you want to use $1 for testing)
3148 [AC_DEFINE($3)ifelse([$4],,[
3151 : ${with_cflags:=-g}
3152 : ${with_no_leaks:=yes}
3155 AC_MSG_RESULT(${with_$1:-no})
3157 case .$with_cflags in #(vi
3159 case .$CFLAGS in #(vi
3169 dnl ---------------------------------------------------------------------------
3170 dnl CF_NUMBER_SYNTAX version: 1 updated: 2003/09/20 18:12:49
3171 dnl ----------------
3172 dnl Check if the given variable is a number. If not, report an error.
3173 dnl $1 is the variable
3174 dnl $2 is the message
3175 AC_DEFUN([CF_NUMBER_SYNTAX],[
3176 if test -n "$1" ; then
3181 AC_MSG_ERROR($2 is not a number: $1)
3185 AC_MSG_ERROR($2 value is empty)
3188 dnl ---------------------------------------------------------------------------
3189 dnl CF_OBJ_SUBDIR version: 4 updated: 2002/02/23 20:38:31
3191 dnl Compute the object-directory name from the given model name
3192 AC_DEFUN([CF_OBJ_SUBDIR],
3195 libtool) $2='obj_lo' ;;
3196 normal) $2='objects' ;;
3197 debug) $2='obj_g' ;;
3198 profile) $2='obj_p' ;;
3200 case $cf_cv_system_name in #(vi
3208 dnl ---------------------------------------------------------------------------
3209 dnl CF_PATHSEP version: 3 updated: 2001/01/12 01:23:53
3211 dnl Provide a value for the $PATH and similar separator
3212 AC_DEFUN([CF_PATHSEP],
3214 case $cf_cv_system_name in
3215 os2*) PATHSEP=';' ;;
3218 ifelse($1,,,[$1=$PATHSEP])
3221 dnl ---------------------------------------------------------------------------
3222 dnl CF_PATH_SYNTAX version: 11 updated: 2006/09/02 08:55:46
3224 dnl Check the argument to see that it looks like a pathname. Rewrite it if it
3225 dnl begins with one of the prefix/exec_prefix variables, and then again if the
3226 dnl result begins with 'NONE'. This is necessary to work around autoconf's
3227 dnl delayed evaluation of those symbols.
3228 AC_DEFUN([CF_PATH_SYNTAX],[
3229 if test "x$prefix" != xNONE; then
3230 cf_path_syntax="$prefix"
3232 cf_path_syntax="$ac_default_prefix"
3235 case ".[$]$1" in #(vi
3236 .\[$]\(*\)*|.\'*\'*) #(vi
3240 .[[a-zA-Z]]:[[\\/]]*) #(vi OS/2 EMX
3242 .\[$]{*prefix}*) #(vi
3244 case ".[$]$1" in #(vi
3246 $1=`echo [$]$1 | sed -e s%NONE%$cf_path_syntax%`
3251 $1=`echo [$]$1 | sed -e s%NONE%$cf_path_syntax%`
3254 ifelse($2,,[AC_ERROR([expected a pathname, not \"[$]$1\"])],$2)
3258 dnl ---------------------------------------------------------------------------
3259 dnl CF_POSIX_C_SOURCE version: 6 updated: 2005/07/14 20:25:10
3260 dnl -----------------
3261 dnl Define _POSIX_C_SOURCE to the given level, and _POSIX_SOURCE if needed.
3263 dnl POSIX.1-1990 _POSIX_SOURCE
3264 dnl POSIX.1-1990 and _POSIX_SOURCE and
3265 dnl POSIX.2-1992 C-Language _POSIX_C_SOURCE=2
3267 dnl POSIX.1b-1993 _POSIX_C_SOURCE=199309L
3268 dnl POSIX.1c-1996 _POSIX_C_SOURCE=199506L
3269 dnl X/Open 2000 _POSIX_C_SOURCE=200112L
3272 dnl $1 is the nominal value for _POSIX_C_SOURCE
3273 AC_DEFUN([CF_POSIX_C_SOURCE],
3275 cf_POSIX_C_SOURCE=ifelse($1,,199506L,$1)
3277 cf_save_CFLAGS="$CFLAGS"
3278 cf_save_CPPFLAGS="$CPPFLAGS"
3280 CF_REMOVE_DEFINE(cf_trim_CFLAGS,$cf_save_CFLAGS,_POSIX_C_SOURCE)
3281 CF_REMOVE_DEFINE(cf_trim_CPPFLAGS,$cf_save_CPPFLAGS,_POSIX_C_SOURCE)
3283 AC_CACHE_CHECK(if we should define _POSIX_C_SOURCE,cf_cv_posix_c_source,[
3284 CF_MSG_LOG(if the symbol is already defined go no further)
3285 AC_TRY_COMPILE([#include <sys/types.h>],[
3286 #ifndef _POSIX_C_SOURCE
3289 [cf_cv_posix_c_source=no],
3290 [cf_want_posix_source=no
3291 case .$cf_POSIX_C_SOURCE in #(vi
3293 cf_cv_posix_c_source="-D_POSIX_C_SOURCE=$cf_POSIX_C_SOURCE"
3296 cf_cv_posix_c_source="-D_POSIX_C_SOURCE=$cf_POSIX_C_SOURCE"
3297 cf_want_posix_source=yes
3300 cf_want_posix_source=yes
3303 if test "$cf_want_posix_source" = yes ; then
3304 AC_TRY_COMPILE([#include <sys/types.h>],[
3305 #ifdef _POSIX_SOURCE
3308 cf_cv_posix_c_source="$cf_cv_posix_c_source -D_POSIX_SOURCE")
3310 CF_MSG_LOG(ifdef from value $cf_POSIX_C_SOURCE)
3311 CFLAGS="$cf_trim_CFLAGS"
3312 CPPFLAGS="$cf_trim_CPPFLAGS $cf_cv_posix_c_source"
3313 CF_MSG_LOG(if the second compile does not leave our definition intact error)
3314 AC_TRY_COMPILE([#include <sys/types.h>],[
3315 #ifndef _POSIX_C_SOURCE
3318 [cf_cv_posix_c_source=no])
3319 CFLAGS="$cf_save_CFLAGS"
3320 CPPFLAGS="$cf_save_CPPFLAGS"
3324 if test "$cf_cv_posix_c_source" != no ; then
3325 CFLAGS="$cf_trim_CFLAGS"
3326 CPPFLAGS="$cf_trim_CPPFLAGS"
3327 if test "$cf_cv_cc_u_d_options" = yes ; then
3328 cf_temp_posix_c_source=`echo "$cf_cv_posix_c_source" | \
3329 sed -e 's/-D/-U/g' -e 's/=[[^ ]]*//g'`
3330 CPPFLAGS="$CPPFLAGS $cf_temp_posix_c_source"
3332 CPPFLAGS="$CPPFLAGS $cf_cv_posix_c_source"
3336 dnl ---------------------------------------------------------------------------
3337 dnl CF_PREDEFINE version: 1 updated: 2003/07/26 17:53:56
3339 dnl Add definitions to CPPFLAGS to ensure they're predefined for all compiles.
3341 dnl $1 = symbol to test
3342 dnl $2 = value (if any) to use for a predefinition
3343 AC_DEFUN([CF_PREDEFINE],
3345 AC_MSG_CHECKING(if we must define $1)
3346 AC_TRY_COMPILE([#include <sys/types.h>
3350 #endif],[cf_result=no],[cf_result=yes])
3351 AC_MSG_RESULT($cf_result)
3353 if test "$cf_result" = yes ; then
3354 CPPFLAGS="$CPPFLAGS ifelse($2,,-D$1,[-D$1=$2])"
3355 elif test "x$2" != "x" ; then
3356 AC_MSG_CHECKING(checking for compatible value versus $2)
3357 AC_TRY_COMPILE([#include <sys/types.h>
3361 #endif],[cf_result=yes],[cf_result=no])
3362 AC_MSG_RESULT($cf_result)
3363 if test "$cf_result" = no ; then
3364 # perhaps we can override it - try...
3365 CPPFLAGS="$CPPFLAGS -D$1=$2"
3369 dnl ---------------------------------------------------------------------------
3370 dnl CF_PRG_RULES version: 1 updated: 2006/06/03 11:45:08
3372 dnl Append definitions and rules for the given programs to the subdirectory
3373 dnl Makefiles, and the recursion rule for the top-level Makefile.
3376 dnl $1 = script to run
3377 dnl $2 = list of subdirectories
3381 AC_DEFUN([CF_PRG_RULES],
3385 if test ! -d $srcdir/$cf_dir; then
3387 elif test -f $srcdir/$cf_dir/programs; then
3388 $AWK -f $1 $srcdir/$cf_dir/programs >>$cf_dir/Makefile
3393 dnl ---------------------------------------------------------------------------
3394 dnl CF_PROG_AWK version: 1 updated: 2006/09/16 11:40:59
3396 dnl Check for awk, ensure that the check found something.
3397 AC_DEFUN([CF_PROG_AWK],
3400 test -z "$AWK" && AC_MSG_ERROR(No awk program found)
3402 dnl ---------------------------------------------------------------------------
3403 dnl CF_PROG_CC_C_O version: 2 updated: 2006/12/16 15:55:46
3405 dnl Analogous to AC_PROG_CC_C_O, but more useful: tests only $CC, ensures that
3406 dnl the output file can be renamed, and allows for a shell variable that can
3407 dnl be used later. The parameter is either CC or CXX. The result is the
3409 dnl $cf_cv_prog_CC_c_o
3410 dnl $cf_cv_prog_CXX_c_o
3411 AC_DEFUN([CF_PROG_CC_C_O],
3412 [AC_REQUIRE([AC_PROG_CC])dnl
3413 AC_MSG_CHECKING([whether [$]$1 understands -c and -o together])
3414 AC_CACHE_VAL(cf_cv_prog_$1_c_o,
3416 cat > conftest.$ac_ext <<CF_EOF
3420 ${cf_cv_main_return:-return}(0);
3423 # We do the test twice because some compilers refuse to overwrite an
3424 # existing .o file with -o, though they will create one.
3425 ac_try='[$]$1 -c conftest.$ac_ext -o conftest2.$ac_objext >&AC_FD_CC'
3426 if AC_TRY_EVAL(ac_try) &&
3427 test -f conftest2.$ac_objext && AC_TRY_EVAL(ac_try);
3429 eval cf_cv_prog_$1_c_o=yes
3431 eval cf_cv_prog_$1_c_o=no
3435 if test $cf_cv_prog_$1_c_o = yes; then
3436 AC_MSG_RESULT([yes])
3441 dnl ---------------------------------------------------------------------------
3442 dnl CF_PROG_CC_U_D version: 1 updated: 2005/07/14 16:59:30
3444 dnl Check if C (preprocessor) -U and -D options are processed in the order
3445 dnl given rather than by type of option. Some compilers insist on apply all
3446 dnl of the -U options after all of the -D options. Others allow mixing them,
3447 dnl and may predefine symbols that conflict with those we define.
3448 AC_DEFUN([CF_PROG_CC_U_D],
3450 AC_CACHE_CHECK(if $CC -U and -D options work together,cf_cv_cc_u_d_options,[
3451 cf_save_CPPFLAGS="$CPPFLAGS"
3452 CPPFLAGS="-UU_D_OPTIONS -DU_D_OPTIONS -DD_U_OPTIONS -UD_U_OPTIONS"
3455 make an undefined-error
3458 make a defined-error
3461 cf_cv_cc_u_d_options=yes],[
3462 cf_cv_cc_u_d_options=no])
3463 CPPFLAGS="$cf_save_CPPFLAGS"
3466 dnl ---------------------------------------------------------------------------
3467 dnl CF_PROG_EGREP version: 1 updated: 2006/09/16 11:40:59
3469 dnl AC_PROG_EGREP was introduced in autoconf 2.53.
3470 dnl This macro adds a check to ensure the script found something.
3471 AC_DEFUN([CF_PROG_EGREP],
3472 [AC_CACHE_CHECK([for egrep], [ac_cv_prog_egrep],
3473 [if echo a | (grep -E '(a|b)') >/dev/null 2>&1
3474 then ac_cv_prog_egrep='grep -E'
3475 else ac_cv_prog_egrep='egrep'
3477 EGREP=$ac_cv_prog_egrep
3479 test -z "$EGREP" && AC_MSG_ERROR(No egrep program found)
3481 dnl ---------------------------------------------------------------------------
3482 dnl CF_PROG_EXT version: 10 updated: 2004/01/03 19:28:18
3484 dnl Compute $PROG_EXT, used for non-Unix ports, such as OS/2 EMX.
3485 AC_DEFUN([CF_PROG_EXT],
3487 AC_REQUIRE([CF_CHECK_CACHE])
3488 case $cf_cv_system_name in
3490 CFLAGS="$CFLAGS -Zmt"
3491 CPPFLAGS="$CPPFLAGS -D__ST_MT_ERRNO__"
3492 CXXFLAGS="$CXXFLAGS -Zmt"
3493 # autoconf's macro sets -Zexe and suffix both, which conflict:w
3494 LDFLAGS="$LDFLAGS -Zmt -Zcrtdll"
3504 test -n "$PROG_EXT" && AC_DEFINE_UNQUOTED(PROG_EXT,"$PROG_EXT")
3506 dnl ---------------------------------------------------------------------------
3507 dnl CF_PROG_INSTALL version: 5 updated: 2002/12/21 22:46:07
3509 dnl Force $INSTALL to be an absolute-path. Otherwise, edit_man.sh and the
3510 dnl misc/tabset install won't work properly. Usually this happens only when
3511 dnl using the fallback mkinstalldirs script
3512 AC_DEFUN([CF_PROG_INSTALL],
3518 CF_DIRNAME(cf_dir,$INSTALL)
3519 test -z "$cf_dir" && cf_dir=.
3520 INSTALL=`cd $cf_dir && pwd`/`echo $INSTALL | sed -e 's%^.*/%%'`
3524 dnl ---------------------------------------------------------------------------
3525 dnl CF_PROG_LDCONFIG version: 1 updated: 2003/09/20 17:07:55
3526 dnl ----------------
3527 dnl Check for ldconfig, needed to fixup shared libraries that would be built
3528 dnl and then used in the install.
3529 AC_DEFUN([CF_PROG_LDCONFIG],[
3530 if test "$cross_compiling" = yes ; then
3533 case "$cf_cv_system_name" in #(vi
3535 test -z "$LDCONFIG" && LDCONFIG="/sbin/ldconfig -R"
3537 *) LDPATH=$PATH:/sbin:/usr/sbin
3538 AC_PATH_PROG(LDCONFIG,ldconfig,,$LDPATH)
3544 dnl ---------------------------------------------------------------------------
3545 dnl CF_PROG_LINT version: 1 updated: 2006/09/16 11:40:59
3547 AC_DEFUN([CF_PROG_LINT],
3549 AC_CHECK_PROGS(LINT, tdlint lint alint)
3552 dnl ---------------------------------------------------------------------------
3553 dnl CF_REGEX version: 3 updated: 1997/11/01 14:26:01
3555 dnl Attempt to determine if we've got one of the flavors of regular-expression
3556 dnl code that we can support.
3557 AC_DEFUN([CF_REGEX],
3559 AC_MSG_CHECKING([for regular-expression headers])
3560 AC_CACHE_VAL(cf_cv_regex,[
3561 AC_TRY_LINK([#include <sys/types.h>
3562 #include <regex.h>],[
3564 int x = regcomp(p, "", 0);
3565 int y = regexec(p, "", 0, 0, 0);
3567 ],[cf_cv_regex="regex.h"],[
3568 AC_TRY_LINK([#include <regexp.h>],[
3569 char *p = compile("", "", "", 0);
3570 int x = step("", "");
3571 ],[cf_cv_regex="regexp.h"],[
3572 cf_save_LIBS="$LIBS"
3574 AC_TRY_LINK([#include <regexpr.h>],[
3575 char *p = compile("", "", "");
3576 int x = step("", "");
3577 ],[cf_cv_regex="regexpr.h"],[LIBS="$cf_save_LIBS"])])])
3579 AC_MSG_RESULT($cf_cv_regex)
3580 case $cf_cv_regex in
3581 regex.h) AC_DEFINE(HAVE_REGEX_H_FUNCS) ;;
3582 regexp.h) AC_DEFINE(HAVE_REGEXP_H_FUNCS) ;;
3583 regexpr.h) AC_DEFINE(HAVE_REGEXPR_H_FUNCS) ;;
3586 dnl ---------------------------------------------------------------------------
3587 dnl CF_REMOVE_DEFINE version: 2 updated: 2005/07/09 16:12:18
3588 dnl ----------------
3589 dnl Remove all -U and -D options that refer to the given symbol from a list
3590 dnl of C compiler options. This works around the problem that not all
3591 dnl compilers process -U and -D options from left-to-right, so a -U option
3592 dnl cannot be used to cancel the effect of a preceding -D option.
3594 dnl $1 = target (which could be the same as the source variable)
3595 dnl $2 = source (including '$')
3596 dnl $3 = symbol to remove
3597 define([CF_REMOVE_DEFINE],
3599 # remove $3 symbol from $2
3601 sed -e 's/-[[UD]]$3\(=[[^ ]]*\)\?[[ ]]/ /g' \
3602 -e 's/-[[UD]]$3\(=[[^ ]]*\)\?[$]//g'`
3604 dnl ---------------------------------------------------------------------------
3605 dnl CF_REMOVE_LIB version: 1 updated: 2007/02/17 14:11:52
3607 dnl Remove the given library from the symbol
3609 dnl $1 = target (which could be the same as the source variable)
3610 dnl $2 = source (including '$')
3611 dnl $3 = library to remove
3612 define([CF_REMOVE_LIB],
3614 # remove $3 library from $2
3615 $1=`echo "$2" | sed -e 's/-l$3[[ ]]//g' -e 's/-l$3[$]//'`
3617 dnl ---------------------------------------------------------------------------
3618 dnl CF_SHARED_OPTS version: 46 updated: 2007/02/24 18:58:09
3621 dnl Attempt to determine the appropriate CC/LD options for creating a shared
3624 dnl Note: ${LOCAL_LDFLAGS} is used to link executables that will run within the
3625 dnl build-tree, i.e., by making use of the libraries that are compiled in ../lib
3626 dnl We avoid compiling-in a ../lib path for the shared library since that can
3627 dnl lead to unexpected results at runtime.
3628 dnl ${LOCAL_LDFLAGS2} has the same intention but assumes that the shared libraries
3629 dnl are compiled in ../../lib
3631 dnl The variable 'cf_cv_do_symlinks' is used to control whether we configure
3632 dnl to install symbolic links to the rel/abi versions of shared libraries.
3634 dnl The variable 'cf_cv_shlib_version' controls whether we use the rel or abi
3635 dnl version when making symbolic links.
3637 dnl The variable 'cf_cv_shlib_version_infix' controls whether shared library
3638 dnl version numbers are infix (ex: libncurses.<ver>.dylib) or postfix
3639 dnl (ex: libncurses.so.<ver>).
3641 dnl Some loaders leave 'so_locations' lying around. It's nice to clean up.
3642 AC_DEFUN([CF_SHARED_OPTS],
3644 AC_REQUIRE([CF_SUBST_NCURSES_VERSION])
3648 INSTALL_LIB="-m 644"
3650 cf_cv_do_symlinks=no
3652 AC_MSG_CHECKING(if release/abi version should be used for shared libs)
3653 AC_ARG_WITH(shlib-version,
3654 [ --with-shlib-version=X Specify rel or abi version for shared libs],
3655 [test -z "$withval" && withval=auto
3656 case $withval in #(vi
3658 cf_cv_shlib_version=auto
3660 rel|abi|auto|no) #(vi
3661 cf_cv_shlib_version=$withval
3664 AC_ERROR([option value must be one of: rel, abi, auto or no])
3667 ],[cf_cv_shlib_version=auto])
3668 AC_MSG_RESULT($cf_cv_shlib_version)
3672 # Some less-capable ports of gcc support only -fpic
3674 if test "$GCC" = yes
3676 AC_MSG_CHECKING(which $CC option to use)
3677 cf_save_CFLAGS="$CFLAGS"
3678 for CC_SHARED_OPTS in -fPIC -fpic ''
3680 CFLAGS="$cf_save_CFLAGS $CC_SHARED_OPTS"
3681 AC_TRY_COMPILE([#include <stdio.h>],[int x = 1],[break],[])
3683 AC_MSG_RESULT($CC_SHARED_OPTS)
3684 CFLAGS="$cf_save_CFLAGS"
3687 cf_cv_shlib_version_infix=no
3689 case $cf_cv_system_name in
3691 MK_SHARED_LIB='${CC} ${CFLAGS} -o $[@] -Xlinker -soname=`basename $[@]` -nostart -e 0'
3695 MK_SHARED_LIB='sh ../mk_shared_lib.sh [$]@ [$]{CC} [$]{CFLAGS}'
3696 cf_cv_shlib_version=cygdll
3697 cf_cv_shlib_version_infix=cygdll
3698 cat >mk_shared_lib.sh <<-CF_EOF
3701 IMPORT_LIB=\`echo "\[$]1" | sed -e 's/cyg/lib/' -e 's/[[0-9]]*\.dll[$]/.dll.a/'\`
3704 Linking shared library
3705 ** SHARED_LIB \[$]SHARED_LIB
3706 ** IMPORT_LIB \[$]IMPORT_LIB
3708 exec \[$]* -shared -Wl,--out-implib=../lib/\[$]{IMPORT_LIB} -Wl,--export-all-symbols -o ../lib/\[$]{SHARED_LIB}
3710 chmod +x mk_shared_lib.sh
3713 EXTRA_CFLAGS="-no-cpp-precomp"
3714 CC_SHARED_OPTS="-dynamic"
3715 MK_SHARED_LIB='${CC} ${CFLAGS} -dynamiclib -install_name ${libdir}/`basename $[@]` -compatibility_version ${ABI_VERSION} -current_version ${ABI_VERSION} -o $[@]'
3716 test "$cf_cv_shlib_version" = auto && cf_cv_shlib_version=abi
3717 cf_cv_shlib_version_infix=yes
3718 AC_CACHE_CHECK([if ld -search_paths_first works], cf_cv_ldflags_search_paths_first, [
3719 cf_save_LDFLAGS=$LDFLAGS
3720 LDFLAGS="$LDFLAGS -Wl,-search_paths_first"
3721 AC_TRY_LINK(, [int i;], cf_cv_ldflags_search_paths_first=yes, cf_cv_ldflags_search_paths_first=no)
3722 LDFLAGS=$cf_save_LDFLAGS])
3723 if test $cf_cv_ldflags_search_paths_first = yes; then
3724 LDFLAGS="$LDFLAGS -Wl,-search_paths_first"
3728 # (tested with gcc 2.7.2 -- I don't have c89)
3729 if test "$GCC" = yes; then
3730 LD_SHARED_OPTS='-Xlinker +b -Xlinker ${libdir}'
3733 LD_SHARED_OPTS='-Wl,+b,${libdir}'
3735 MK_SHARED_LIB='${LD} +b ${libdir} -b -o $[@]'
3736 # HP-UX shared libraries must be executable, and should be
3737 # readonly to exploit a quirk in the memory manager.
3738 INSTALL_LIB="-m 555"
3741 if test "$cf_cv_ld_rpath" = yes ; then
3742 if test "$GCC" = yes; then
3743 cf_ld_rpath_opt="-Wl,-rpath,"
3744 EXTRA_LDFLAGS="-Wl,-rpath,\${libdir} $EXTRA_LDFLAGS"
3746 cf_ld_rpath_opt="-rpath "
3747 EXTRA_LDFLAGS="-rpath \${libdir} $EXTRA_LDFLAGS"
3750 # tested with IRIX 5.2 and 'cc'.
3751 if test "$GCC" != yes; then
3752 CC_SHARED_OPTS='-KPIC'
3754 MK_SHARED_LIB='${CC} -shared -rdata_shared -soname `basename $[@]` -o $[@]'
3755 cf_cv_rm_so_locs=yes
3757 linux*|gnu*|k*bsd*-gnu)
3758 if test "$DFT_LWR_MODEL" = "shared" ; then
3759 LOCAL_LDFLAGS="-Wl,-rpath,\$(LOCAL_LIBDIR)"
3760 LOCAL_LDFLAGS2="$LOCAL_LDFLAGS"
3762 if test "$cf_cv_ld_rpath" = yes ; then
3763 cf_ld_rpath_opt="-Wl,-rpath,"
3764 EXTRA_LDFLAGS="-Wl,-rpath,\${libdir} $EXTRA_LDFLAGS"
3767 MK_SHARED_LIB='${CC} ${CFLAGS} -shared -Wl,-soname,'$cf_shared_soname',-stats,-lc -o $[@]'
3770 CC_SHARED_OPTS="$CC_SHARED_OPTS -DPIC"
3771 MK_SHARED_LIB='${LD} -Bshareable -soname,`basename $[@].${ABI_VERSION}` -o $[@]'
3773 openbsd*|freebsd[[12]].*)
3774 CC_SHARED_OPTS="$CC_SHARED_OPTS -DPIC"
3775 MK_SHARED_LIB='${LD} -Bshareable -o $[@]'
3776 test "$cf_cv_shlib_version" = auto && cf_cv_shlib_version=rel
3779 CC_SHARED_OPTS="$CC_SHARED_OPTS -DPIC"
3780 if test "$DFT_LWR_MODEL" = "shared" && test "$cf_cv_ld_rpath" = yes ; then
3781 LOCAL_LDFLAGS="-rpath \$(LOCAL_LIBDIR)"
3782 LOCAL_LDFLAGS2="-rpath \${libdir} $LOCAL_LDFLAGS"
3783 cf_ld_rpath_opt="-rpath "
3784 EXTRA_LDFLAGS="-rpath \${libdir} $EXTRA_LDFLAGS"
3787 MK_SHARED_LIB='${LD} -Bshareable -soname=`basename $[@]` -o $[@]'
3790 CC_SHARED_OPTS="$CC_SHARED_OPTS -DPIC"
3791 test "$cf_cv_ld_rpath" = yes && cf_ld_rpath_opt="-Wl,-rpath,"
3792 if test "$DFT_LWR_MODEL" = "shared" && test "$cf_cv_ld_rpath" = yes ; then
3793 LOCAL_LDFLAGS="-Wl,-rpath,\$(LOCAL_LIBDIR)"
3794 LOCAL_LDFLAGS2="$LOCAL_LDFLAGS"
3795 EXTRA_LDFLAGS="-Wl,-rpath,\${libdir} $EXTRA_LDFLAGS"
3796 if test "$cf_cv_shlib_version" = auto; then
3797 if test -f /usr/libexec/ld.elf_so; then
3798 cf_cv_shlib_version=abi
3800 cf_cv_shlib_version=rel
3804 MK_SHARED_LIB='${CC} ${CFLAGS} -shared -Wl,-soname,'$cf_shared_soname' -o $[@]'
3806 MK_SHARED_LIB='${LD} -Bshareable -o $[@]'
3810 # tested with OSF/1 V3.2 and 'cc'
3811 # tested with OSF/1 V3.2 and gcc 2.6.3 (but the c++ demo didn't
3812 # link with shared libs).
3813 MK_SHARED_LIB='${LD} -set_version ${REL_VERSION}:${ABI_VERSION} -expect_unresolved "*" -shared -soname `basename $[@]`'
3816 MK_SHARED_LIB="${MK_SHARED_LIB} -msym"
3819 MK_SHARED_LIB="${MK_SHARED_LIB}"' -o $[@]'
3820 if test "$DFT_LWR_MODEL" = "shared" ; then
3821 LOCAL_LDFLAGS="-Wl,-rpath,\$(LOCAL_LIBDIR)"
3822 LOCAL_LDFLAGS2="$LOCAL_LDFLAGS"
3824 if test "$cf_cv_ld_rpath" = yes ; then
3825 cf_ld_rpath_opt="-rpath"
3826 # EXTRA_LDFLAGS="$LOCAL_LDFLAGS $EXTRA_LDFLAGS"
3828 cf_cv_rm_so_locs=yes
3830 sco3.2v5*) # (also uw2* and UW7) hops 13-Apr-98
3831 # tested with osr5.0.5
3832 if test "$GCC" != yes; then
3833 CC_SHARED_OPTS='-belf -KPIC'
3835 MK_SHARED_LIB='${LD} -dy -G -h `basename $[@] .${REL_VERSION}`.${ABI_VERSION} -o [$]@'
3836 if test "$cf_cv_ld_rpath" = yes ; then
3837 # only way is to set LD_RUN_PATH but no switch for it
3840 test "$cf_cv_shlib_version" = auto && cf_cv_shlib_version=rel
3841 LINK_PROGS='LD_RUN_PATH=${libdir}'
3842 LINK_TESTS='Pwd=`pwd`;LD_RUN_PATH=`dirname $${Pwd}`/lib'
3845 # tested with SunOS 4.1.1 and gcc 2.7.0
3846 if test "$GCC" != yes; then
3847 CC_SHARED_OPTS='-KPIC'
3849 MK_SHARED_LIB='${LD} -assert pure-text -o $[@]'
3850 test "$cf_cv_shlib_version" = auto && cf_cv_shlib_version=rel
3853 # tested with SunOS 5.5.1 (solaris 2.5.1) and gcc 2.7.2
3854 if test "$GCC" != yes; then
3855 CC_SHARED_OPTS='-KPIC'
3857 if test "$DFT_LWR_MODEL" = "shared" ; then
3858 LOCAL_LDFLAGS="-R \$(LOCAL_LIBDIR):\${libdir}"
3859 LOCAL_LDFLAGS2="$LOCAL_LDFLAGS"
3861 if test "$cf_cv_ld_rpath" = yes ; then
3862 cf_ld_rpath_opt="-R"
3863 EXTRA_LDFLAGS="$LOCAL_LDFLAGS $EXTRA_LDFLAGS"
3866 MK_SHARED_LIB='${CC} -dy -G -h '$cf_shared_soname' -o $[@]'
3869 # tested with UnixWare 7.1.0 (gcc 2.95.2 and cc)
3870 if test "$GCC" != yes; then
3871 CC_SHARED_OPTS='-KPIC'
3873 MK_SHARED_LIB='${LD} -d y -G -o [$]@'
3876 CC_SHARED_OPTS='unknown'
3877 MK_SHARED_LIB='echo unknown'
3881 # This works if the last tokens in $MK_SHARED_LIB are the -o target.
3882 case "$cf_cv_shlib_version" in #(vi
3884 case "$MK_SHARED_LIB" in #(vi
3886 test "$cf_cv_do_symlinks" = no && cf_cv_do_symlinks=yes
3889 AC_MSG_WARN(ignored --with-shlib-version)
3895 if test -n "$cf_ld_rpath_opt" ; then
3896 AC_MSG_CHECKING(if we need a space after rpath option)
3897 cf_save_LIBS="$LIBS"
3898 LIBS="$LIBS ${cf_ld_rpath_opt}$libdir"
3899 AC_TRY_LINK(, , cf_rpath_space=no, cf_rpath_space=yes)
3900 LIBS="$cf_save_LIBS"
3901 AC_MSG_RESULT($cf_rpath_space)
3902 test "$cf_rpath_space" = yes && cf_ld_rpath_opt="$cf_ld_rpath_opt "
3903 MK_SHARED_LIB="$MK_SHARED_LIB $cf_ld_rpath_opt\${libdir}"
3906 AC_SUBST(CC_SHARED_OPTS)
3907 AC_SUBST(LD_SHARED_OPTS)
3908 AC_SUBST(MK_SHARED_LIB)
3909 AC_SUBST(LINK_PROGS)
3910 AC_SUBST(LINK_TESTS)
3911 AC_SUBST(EXTRA_LDFLAGS)
3912 AC_SUBST(LOCAL_LDFLAGS)
3913 AC_SUBST(LOCAL_LDFLAGS2)
3914 AC_SUBST(INSTALL_LIB)
3916 dnl ---------------------------------------------------------------------------
3917 dnl CF_SHARED_SONAME version: 2 updated: 2006/10/21 12:33:41
3918 dnl ----------------
3919 dnl utility macro for CF_SHARED_OPTS, constructs "$cf_shared_soname" for
3920 dnl substitution into MK_SHARED_LIB string for the "-soname" (or similar)
3923 dnl $1 is the default that should be used for "$cf_cv_shlib_version".
3924 dnl If missing, use "rel".
3925 define([CF_SHARED_SONAME],
3927 test "$cf_cv_shlib_version" = auto && cf_cv_shlib_version=ifelse($1,,rel,$1)
3928 if test "$cf_cv_shlib_version" = rel; then
3929 cf_shared_soname='`basename $[@] .${REL_VERSION}`.${ABI_VERSION}'
3931 cf_shared_soname='`basename $[@]`'
3934 dnl ---------------------------------------------------------------------------
3935 dnl CF_SIGWINCH version: 1 updated: 2006/04/02 16:41:09
3937 dnl Use this macro after CF_XOPEN_SOURCE, but do not require it (not all
3938 dnl programs need this test).
3940 dnl This is really a MacOS X 10.4.3 workaround. Defining _POSIX_C_SOURCE
3941 dnl forces SIGWINCH to be undefined (breaks xterm, ncurses). Oddly, the struct
3942 dnl winsize declaration is left alone - we may revisit this if Apple choose to
3943 dnl break that part of the interface as well.
3944 AC_DEFUN([CF_SIGWINCH],
3946 AC_CACHE_CHECK(if SIGWINCH is defined,cf_cv_define_sigwinch,[
3948 #include <sys/types.h>
3949 #include <sys/signal.h>
3950 ],[int x = SIGWINCH],
3951 [cf_cv_define_sigwinch=yes],
3953 #undef _XOPEN_SOURCE
3954 #undef _POSIX_SOURCE
3955 #undef _POSIX_C_SOURCE
3956 #include <sys/types.h>
3957 #include <sys/signal.h>
3958 ],[int x = SIGWINCH],
3959 [cf_cv_define_sigwinch=maybe],
3960 [cf_cv_define_sigwinch=no])
3964 if test "$cf_cv_define_sigwinch" = maybe ; then
3965 AC_CACHE_CHECK(for actual SIGWINCH definition,cf_cv_fixup_sigwinch,[
3966 cf_cv_fixup_sigwinch=unknown
3968 while test $cf_sigwinch != 1
3971 #undef _XOPEN_SOURCE
3972 #undef _POSIX_SOURCE
3973 #undef _POSIX_C_SOURCE
3974 #include <sys/types.h>
3975 #include <sys/signal.h>
3977 #if SIGWINCH != $cf_sigwinch
3981 [cf_cv_fixup_sigwinch=$cf_sigwinch
3984 cf_sigwinch=`expr $cf_sigwinch - 1`
3988 if test "$cf_cv_fixup_sigwinch" != unknown ; then
3989 CPPFLAGS="$CPPFLAGS -DSIGWINCH=$cf_cv_fixup_sigwinch"
3993 dnl ---------------------------------------------------------------------------
3994 dnl CF_SIZECHANGE version: 8 updated: 2000/11/04 12:22:16
3996 dnl Check for definitions & structures needed for window size-changing
3997 dnl FIXME: check that this works with "snake" (HP-UX 10.x)
3998 AC_DEFUN([CF_SIZECHANGE],
4000 AC_REQUIRE([CF_STRUCT_TERMIOS])
4001 AC_CACHE_CHECK(declaration of size-change, cf_cv_sizechange,[
4002 cf_cv_sizechange=unknown
4003 cf_save_CPPFLAGS="$CPPFLAGS"
4005 for cf_opts in "" "NEED_PTEM_H"
4008 CPPFLAGS="$cf_save_CPPFLAGS"
4009 test -n "$cf_opts" && CPPFLAGS="$CPPFLAGS -D$cf_opts"
4010 AC_TRY_COMPILE([#include <sys/types.h>
4011 #ifdef HAVE_TERMIOS_H
4012 #include <termios.h>
4014 #ifdef HAVE_TERMIO_H
4019 /* This is a workaround for SCO: they neglected to define struct winsize in
4020 * termios.h -- it's only in termio.h and ptem.h
4022 #include <sys/stream.h>
4023 #include <sys/ptem.h>
4025 #if !defined(sun) || !defined(HAVE_TERMIOS_H)
4026 #include <sys/ioctl.h>
4030 struct ttysize win; /* FIXME: what system is this? */
4031 int y = win.ts_lines;
4032 int x = win.ts_cols;
4039 no TIOCGSIZE or TIOCGWINSZ
4040 #endif /* TIOCGWINSZ */
4041 #endif /* TIOCGSIZE */
4043 [cf_cv_sizechange=yes],
4044 [cf_cv_sizechange=no])
4046 CPPFLAGS="$cf_save_CPPFLAGS"
4047 if test "$cf_cv_sizechange" = yes ; then
4048 echo "size-change succeeded ($cf_opts)" >&AC_FD_CC
4049 test -n "$cf_opts" && cf_cv_sizechange="$cf_opts"
4054 if test "$cf_cv_sizechange" != no ; then
4055 AC_DEFINE(HAVE_SIZECHANGE)
4056 case $cf_cv_sizechange in #(vi
4058 AC_DEFINE_UNQUOTED($cf_cv_sizechange )
4063 dnl ---------------------------------------------------------------------------
4064 dnl CF_SRC_MODULES version: 18 updated: 2005/05/28 12:58:54
4066 dnl For each parameter, test if the source-directory exists, and if it contains
4067 dnl a 'modules' file. If so, add to the list $cf_cv_src_modules which we'll
4068 dnl use in CF_LIB_RULES.
4070 dnl This uses the configured value to make the lists SRC_SUBDIRS and
4071 dnl SUB_MAKEFILES which are used in the makefile-generation scheme.
4072 AC_DEFUN([CF_SRC_MODULES],
4074 AC_MSG_CHECKING(for src modules)
4076 # dependencies and linker-arguments for test-programs
4077 TEST_DEPS="${LIB_DIR}/${LIB_PREFIX}${LIB_NAME}${DFT_DEP_SUFFIX} $TEST_DEPS"
4078 TEST_DEP2="${LIB_2ND}/${LIB_PREFIX}${LIB_NAME}${DFT_DEP_SUFFIX} $TEST_DEP2"
4079 if test "$DFT_LWR_MODEL" = "libtool"; then
4080 TEST_ARGS="${TEST_DEPS}"
4081 TEST_ARG2="${TEST_DEP2}"
4083 TEST_ARGS="-l${LIB_NAME}${DFT_ARG_SUFFIX} $TEST_ARGS"
4084 TEST_ARG2="-l${LIB_NAME}${DFT_ARG_SUFFIX} $TEST_ARG2"
4090 if test -f $srcdir/$cf_dir/modules; then
4092 # We may/may not have tack in the distribution, though the
4094 if test $cf_dir = tack ; then
4095 if test ! -f $srcdir/${cf_dir}/${cf_dir}.h; then
4100 if test -z "$cf_cv_src_modules"; then
4101 cf_cv_src_modules=$cf_dir
4103 cf_cv_src_modules="$cf_cv_src_modules $cf_dir"
4106 # Make the ncurses_cfg.h file record the library interface files as
4107 # well. These are header files that are the same name as their
4108 # directory. Ncurses is the only library that does not follow
4110 if test $cf_dir = tack ; then
4112 elif test -f $srcdir/${cf_dir}/${cf_dir}.h; then
4113 CF_UPPER(cf_have_include,$cf_dir)
4114 AC_DEFINE_UNQUOTED(HAVE_${cf_have_include}_H)
4115 AC_DEFINE_UNQUOTED(HAVE_LIB${cf_have_include})
4116 TEST_DEPS="${LIB_DIR}/${LIB_PREFIX}${cf_dir}${DFT_DEP_SUFFIX} $TEST_DEPS"
4117 TEST_DEP2="${LIB_2ND}/${LIB_PREFIX}${cf_dir}${DFT_DEP_SUFFIX} $TEST_DEP2"
4118 if test "$DFT_LWR_MODEL" = "libtool"; then
4119 TEST_ARGS="${TEST_DEPS}"
4120 TEST_ARG2="${TEST_DEP2}"
4122 TEST_ARGS="-l${cf_dir}${DFT_ARG_SUFFIX} $TEST_ARGS"
4123 TEST_ARG2="-l${cf_dir}${DFT_ARG_SUFFIX} $TEST_ARG2"
4128 AC_MSG_RESULT($cf_cv_src_modules)
4130 TEST_ARGS="-L${LIB_DIR} $TEST_ARGS"
4131 TEST_ARG2="-L${LIB_2ND} $TEST_ARG2"
4139 SRC_SUBDIRS="man include"
4140 for cf_dir in $cf_cv_src_modules
4142 SRC_SUBDIRS="$SRC_SUBDIRS $cf_dir"
4144 SRC_SUBDIRS="$SRC_SUBDIRS test"
4145 test -z "$MAKE_TERMINFO" && SRC_SUBDIRS="$SRC_SUBDIRS misc"
4146 test "$cf_with_cxx_binding" != no && SRC_SUBDIRS="$SRC_SUBDIRS c++"
4149 if test "$cf_cv_prog_gnat_correct" = yes && test -f $srcdir/Ada95/Makefile.in; then
4150 SRC_SUBDIRS="$SRC_SUBDIRS Ada95"
4151 ADA_SUBDIRS="gen src samples"
4155 for cf_dir in $SRC_SUBDIRS
4157 SUB_MAKEFILES="$SUB_MAKEFILES $cf_dir/Makefile"
4160 if test -n "$ADA_SUBDIRS"; then
4161 for cf_dir in $ADA_SUBDIRS
4163 SUB_MAKEFILES="$SUB_MAKEFILES Ada95/$cf_dir/Makefile"
4165 AC_SUBST(ADA_SUBDIRS)
4168 dnl ---------------------------------------------------------------------------
4169 dnl CF_STDCPP_LIBRARY version: 5 updated: 2000/08/12 23:18:52
4170 dnl -----------------
4171 dnl Check for -lstdc++, which is GNU's standard C++ library.
4172 AC_DEFUN([CF_STDCPP_LIBRARY],
4174 if test -n "$GXX" ; then
4175 case $cf_cv_system_name in #(vi
4177 cf_stdcpp_libname=stdcpp
4180 cf_stdcpp_libname=stdc++
4183 AC_CACHE_CHECK(for library $cf_stdcpp_libname,cf_cv_libstdcpp,[
4185 LIBS="$LIBS -l$cf_stdcpp_libname"
4187 #include <strstream.h>],[
4189 strstreambuf foo(buf, sizeof(buf))
4191 [cf_cv_libstdcpp=yes],
4192 [cf_cv_libstdcpp=no])
4195 test "$cf_cv_libstdcpp" = yes && CXXLIBS="$CXXLIBS -l$cf_stdcpp_libname"
4198 dnl ---------------------------------------------------------------------------
4199 dnl CF_STRIP_G_OPT version: 3 updated: 2002/12/21 19:25:52
4201 dnl Remove "-g" option from the compiler options
4202 AC_DEFUN([CF_STRIP_G_OPT],
4203 [$1=`echo ${$1} | sed -e 's%-g %%' -e 's%-g$%%'`])dnl
4204 dnl ---------------------------------------------------------------------------
4205 dnl CF_STRUCT_SIGACTION version: 3 updated: 2000/08/12 23:18:52
4206 dnl -------------------
4207 dnl Check if we need _POSIX_SOURCE defined to use struct sigaction. We'll only
4208 dnl do this if we've found the sigaction function.
4210 dnl If needed, define SVR4_ACTION.
4211 AC_DEFUN([CF_STRUCT_SIGACTION],[
4212 if test "$ac_cv_func_sigaction" = yes; then
4213 AC_MSG_CHECKING(whether sigaction needs _POSIX_SOURCE)
4215 #include <sys/types.h>
4216 #include <signal.h>],
4217 [struct sigaction act],
4221 #define _POSIX_SOURCE
4222 #include <sys/types.h>
4223 #include <signal.h>],
4224 [struct sigaction act],
4226 AC_DEFINE(SVR4_ACTION)],
4227 [sigact_bad=unknown])])
4228 AC_MSG_RESULT($sigact_bad)
4231 dnl ---------------------------------------------------------------------------
4232 dnl CF_STRUCT_TERMIOS version: 5 updated: 2000/11/04 12:22:46
4233 dnl -----------------
4234 dnl Some machines require _POSIX_SOURCE to completely define struct termios.
4235 dnl If so, define SVR4_TERMIO
4236 AC_DEFUN([CF_STRUCT_TERMIOS],[
4242 if test "$ISC" = yes ; then
4243 AC_CHECK_HEADERS( sys/termio.h )
4245 if test "$ac_cv_header_termios_h" = yes ; then
4246 case "$CFLAGS $CPPFLAGS" in
4248 termios_bad=dunno ;;
4249 *) termios_bad=maybe ;;
4251 if test "$termios_bad" = maybe ; then
4252 AC_MSG_CHECKING(whether termios.h needs _POSIX_SOURCE)
4253 AC_TRY_COMPILE([#include <termios.h>],
4254 [struct termios foo; int x = foo.c_iflag],
4257 #define _POSIX_SOURCE
4258 #include <termios.h>],
4259 [struct termios foo; int x = foo.c_iflag],
4260 termios_bad=unknown,
4261 termios_bad=yes AC_DEFINE(SVR4_TERMIO))
4263 AC_MSG_RESULT($termios_bad)
4267 dnl ---------------------------------------------------------------------------
4268 dnl CF_SUBST version: 4 updated: 2006/06/17 12:33:03
4270 dnl Shorthand macro for substituting things that the user may override
4271 dnl with an environment variable.
4273 dnl $1 = long/descriptive name
4274 dnl $2 = environment variable
4275 dnl $3 = default value
4276 AC_DEFUN([CF_SUBST],
4277 [AC_CACHE_VAL(cf_cv_subst_$2,[
4278 AC_MSG_CHECKING(for $1 (symbol $2))
4279 CF_SUBST_IF([-z "[$]$2"], [$2], [$3])
4280 cf_cv_subst_$2=[$]$2
4281 AC_MSG_RESULT([$]$2)
4284 dnl ---------------------------------------------------------------------------
4285 dnl CF_SUBST_IF version: 2 updated: 2006/06/17 12:33:03
4287 dnl Shorthand macro for substituting things that the user may override
4288 dnl with an environment variable.
4290 dnl $1 = condition to pass to "test"
4291 dnl $2 = environment variable
4292 dnl $3 = value if the test succeeds
4293 dnl $4 = value if the test fails
4294 AC_DEFUN([CF_SUBST_IF],
4303 dnl ---------------------------------------------------------------------------
4304 dnl CF_SUBST_NCURSES_VERSION version: 8 updated: 2006/09/16 11:40:59
4305 dnl ------------------------
4306 dnl Get the version-number for use in shared-library naming, etc.
4307 AC_DEFUN([CF_SUBST_NCURSES_VERSION],
4309 AC_REQUIRE([CF_PROG_EGREP])
4310 NCURSES_MAJOR="`$ac_cv_prog_egrep '^NCURSES_MAJOR[[ ]]*=' $srcdir/dist.mk | sed -e 's/^[[^0-9]]*//'`"
4311 NCURSES_MINOR="`$ac_cv_prog_egrep '^NCURSES_MINOR[[ ]]*=' $srcdir/dist.mk | sed -e 's/^[[^0-9]]*//'`"
4312 NCURSES_PATCH="`$ac_cv_prog_egrep '^NCURSES_PATCH[[ ]]*=' $srcdir/dist.mk | sed -e 's/^[[^0-9]]*//'`"
4313 cf_cv_abi_version=${NCURSES_MAJOR}
4314 cf_cv_rel_version=${NCURSES_MAJOR}.${NCURSES_MINOR}
4315 dnl Show the computed version, for logging
4316 cf_cv_timestamp=`date`
4317 AC_MSG_RESULT(Configuring NCURSES $cf_cv_rel_version ABI $cf_cv_abi_version ($cf_cv_timestamp))
4318 dnl We need these values in the generated headers
4319 AC_SUBST(NCURSES_MAJOR)
4320 AC_SUBST(NCURSES_MINOR)
4321 AC_SUBST(NCURSES_PATCH)
4322 dnl We need these values in the generated makefiles
4323 AC_SUBST(cf_cv_rel_version)
4324 AC_SUBST(cf_cv_abi_version)
4325 AC_SUBST(cf_cv_builtin_bool)
4326 AC_SUBST(cf_cv_header_stdbool_h)
4327 AC_SUBST(cf_cv_type_of_bool)dnl
4329 dnl ---------------------------------------------------------------------------
4330 dnl CF_SYS_TIME_SELECT version: 4 updated: 2000/10/04 09:18:40
4331 dnl ------------------
4332 dnl Check if we can include <sys/time.h> with <sys/select.h>; this breaks on
4333 dnl older SCO configurations.
4334 AC_DEFUN([CF_SYS_TIME_SELECT],
4336 AC_MSG_CHECKING(if sys/time.h works with sys/select.h)
4337 AC_CACHE_VAL(cf_cv_sys_time_select,[
4339 #include <sys/types.h>
4340 #ifdef HAVE_SYS_TIME_H
4341 #include <sys/time.h>
4343 #ifdef HAVE_SYS_SELECT_H
4344 #include <sys/select.h>
4346 ],[],[cf_cv_sys_time_select=yes],
4347 [cf_cv_sys_time_select=no])
4349 AC_MSG_RESULT($cf_cv_sys_time_select)
4350 test "$cf_cv_sys_time_select" = yes && AC_DEFINE(HAVE_SYS_TIME_SELECT)
4352 dnl ---------------------------------------------------------------------------
4353 dnl CF_TOP_BUILDDIR version: 1 updated: 2006/10/15 16:33:23
4355 dnl Define a top_builddir symbol, for applications that need an absolute path.
4356 AC_DEFUN([CF_TOP_BUILDDIR],
4359 AC_SUBST(top_builddir)
4361 dnl ---------------------------------------------------------------------------
4362 dnl CF_TYPEOF_CHTYPE version: 8 updated: 2006/12/16 12:33:30
4363 dnl ----------------
4364 dnl Determine the type we should use for chtype (and attr_t, which is treated
4365 dnl as the same thing). We want around 32 bits, so on most machines want a
4366 dnl long, but on newer 64-bit machines, probably want an int. If we're using
4367 dnl wide characters, we have to have a type compatible with that, as well.
4368 AC_DEFUN([CF_TYPEOF_CHTYPE],
4370 AC_MSG_CHECKING([for type of chtype])
4371 AC_CACHE_VAL(cf_cv_typeof_chtype,[
4373 #define WANT_BITS 31
4377 FILE *fp = fopen("cf_test.out", "w");
4379 char *result = "long";
4380 if (sizeof(unsigned long) > sizeof(unsigned int)) {
4383 for (n = 0; n < WANT_BITS; n++) {
4386 if (y != 1 || x == 0) {
4392 * If x is nonzero, an int is big enough for the bits
4395 result = (x != 0) ? "int" : "long";
4400 ${cf_cv_main_return:-return}(0);
4403 [cf_cv_typeof_chtype=`cat cf_test.out`],
4404 [cf_cv_typeof_chtype=long],
4405 [cf_cv_typeof_chtype=long])
4408 AC_MSG_RESULT($cf_cv_typeof_chtype)
4410 AC_SUBST(cf_cv_typeof_chtype)
4411 AC_DEFINE_UNQUOTED(TYPEOF_CHTYPE,$cf_cv_typeof_chtype)
4413 dnl ---------------------------------------------------------------------------
4414 dnl CF_TYPE_SIGACTION version: 3 updated: 2000/08/12 23:18:52
4415 dnl -----------------
4417 AC_DEFUN([CF_TYPE_SIGACTION],
4419 AC_MSG_CHECKING([for type sigaction_t])
4420 AC_CACHE_VAL(cf_cv_type_sigaction,[
4422 #include <signal.h>],
4424 [cf_cv_type_sigaction=yes],
4425 [cf_cv_type_sigaction=no])])
4426 AC_MSG_RESULT($cf_cv_type_sigaction)
4427 test "$cf_cv_type_sigaction" = yes && AC_DEFINE(HAVE_TYPE_SIGACTION)
4429 dnl ---------------------------------------------------------------------------
4430 dnl CF_UNSIGNED_LITERALS version: 2 updated: 1998/02/07 22:10:16
4431 dnl --------------------
4432 dnl Test if the compiler supports 'U' and 'L' suffixes. Only old compilers
4433 dnl won't, but they're still there.
4434 AC_DEFUN([CF_UNSIGNED_LITERALS],
4436 AC_MSG_CHECKING([if unsigned literals are legal])
4437 AC_CACHE_VAL(cf_cv_unsigned_literals,[
4438 AC_TRY_COMPILE([],[long x = 1L + 1UL + 1U + 1],
4439 [cf_cv_unsigned_literals=yes],
4440 [cf_cv_unsigned_literals=no])
4442 AC_MSG_RESULT($cf_cv_unsigned_literals)
4444 dnl ---------------------------------------------------------------------------
4445 dnl CF_UPPER version: 5 updated: 2001/01/29 23:40:59
4447 dnl Make an uppercase version of a variable
4448 dnl $1=uppercase($2)
4449 AC_DEFUN([CF_UPPER],
4451 $1=`echo "$2" | sed y%abcdefghijklmnopqrstuvwxyz./-%ABCDEFGHIJKLMNOPQRSTUVWXYZ___%`
4453 dnl ---------------------------------------------------------------------------
4454 dnl CF_VERBOSE version: 2 updated: 1997/09/05 10:45:14
4456 dnl Use AC_VERBOSE w/o the warnings
4457 AC_DEFUN([CF_VERBOSE],
4458 [test -n "$verbose" && echo " $1" 1>&AC_FD_MSG
4460 dnl ---------------------------------------------------------------------------
4461 dnl CF_WCHAR_TYPE version: 2 updated: 2004/01/17 19:18:20
4463 dnl Check if type wide-character type $1 is declared, and if so, which header
4464 dnl file is needed. The second parameter is used to set a shell variable when
4465 dnl the type is not found. The first parameter sets a shell variable for the
4467 AC_DEFUN([CF_WCHAR_TYPE],
4469 # This is needed on Tru64 5.0 to declare $1
4470 AC_CACHE_CHECK(if we must include wchar.h to declare $1,cf_cv_$1,[
4475 #ifdef HAVE_LIBUTF8_H
4476 #include <libutf8.h>
4485 #ifdef HAVE_LIBUTF8_H
4486 #include <libutf8.h>
4490 [cf_cv_$1=unknown])])])
4492 if test "$cf_cv_$1" = yes ; then
4493 AC_DEFINE(NEED_WCHAR_H)
4498 # if we do not find $1 in either place, use substitution to provide a fallback.
4499 if test "$cf_cv_$1" = unknown ; then
4504 # if we find $1 in either place, use substitution to provide a fallback.
4505 if test "$cf_cv_$1" != unknown ; then
4510 dnl ---------------------------------------------------------------------------
4511 dnl CF_WITH_ABI_VERSION version: 1 updated: 2003/09/20 18:12:49
4512 dnl -------------------
4513 dnl Allow library's ABI to be overridden. Generally this happens when a
4514 dnl packager has incremented the ABI past that used in the original package,
4515 dnl and wishes to keep doing this.
4517 dnl $1 is the package name, if any, to derive a corresponding {package}_ABI
4519 AC_DEFUN([CF_WITH_ABI_VERSION],[
4520 test -z "$cf_cv_abi_version" && cf_cv_abi_version=0
4521 AC_ARG_WITH(abi-version,
4522 [ --with-abi-version=XXX override derived ABI version],
4523 [AC_MSG_WARN(overriding ABI version $cf_cv_abi_version to $withval)
4524 cf_cv_abi_version=$withval])
4525 CF_NUMBER_SYNTAX($cf_cv_abi_version,ABI version)
4527 $1_ABI=$cf_cv_abi_version
4530 dnl ---------------------------------------------------------------------------
4531 dnl CF_WITH_DBMALLOC version: 6 updated: 2006/12/16 14:24:05
4532 dnl ----------------
4533 dnl Configure-option for dbmalloc. The optional parameter is used to override
4534 dnl the updating of $LIBS, e.g., to avoid conflict with subsequent tests.
4535 AC_DEFUN([CF_WITH_DBMALLOC],[
4536 CF_NO_LEAKS_OPTION(dbmalloc,
4537 [ --with-dbmalloc test: use Conor Cahill's dbmalloc library],
4540 if test "$with_dbmalloc" = yes ; then
4541 AC_CHECK_HEADER(dbmalloc.h,
4542 [AC_CHECK_LIB(dbmalloc,[debug_malloc]ifelse($1,,[],[,$1]))])
4545 dnl ---------------------------------------------------------------------------
4546 dnl CF_WITH_DMALLOC version: 6 updated: 2006/12/16 14:24:05
4548 dnl Configure-option for dmalloc. The optional parameter is used to override
4549 dnl the updating of $LIBS, e.g., to avoid conflict with subsequent tests.
4550 AC_DEFUN([CF_WITH_DMALLOC],[
4551 CF_NO_LEAKS_OPTION(dmalloc,
4552 [ --with-dmalloc test: use Gray Watson's dmalloc library],
4555 if test "$with_dmalloc" = yes ; then
4556 AC_CHECK_HEADER(dmalloc.h,
4557 [AC_CHECK_LIB(dmalloc,[dmalloc_debug]ifelse($1,,[],[,$1]))])
4560 dnl ---------------------------------------------------------------------------
4561 dnl CF_WITH_GPM version: 6 updated: 2006/12/17 11:12:09
4564 dnl The option parameter (if neither yes/no) is assumed to be the name of
4565 dnl the gpm library, e.g., for dynamic loading.
4566 AC_DEFUN([CF_WITH_GPM],
4568 AC_MSG_CHECKING(if you want to link with the GPM mouse library)
4570 [ --with-gpm use Alessandro Rubini's GPM library],
4571 [with_gpm=$withval],
4573 AC_MSG_RESULT($with_gpm)
4575 if test "$with_gpm" != no ; then
4576 AC_CHECK_HEADER(gpm.h,[
4577 AC_DEFINE(HAVE_GPM_H)
4578 if test "$with_gpm" != yes && test "$with_gpm" != maybe ; then
4579 CF_VERBOSE(assuming we really have GPM library)
4580 AC_DEFINE(HAVE_LIBGPM)
4582 AC_CHECK_LIB(gpm,Gpm_Open,[:],[
4583 AC_ERROR(Cannot link with GPM library)
4588 test "$with_gpm" != maybe && AC_MSG_WARN(Cannot find GPM header)
4593 dnl ---------------------------------------------------------------------------
4594 dnl CF_WITH_LIBTOOL version: 13 updated: 2007/01/27 17:52:16
4596 dnl Provide a configure option to incorporate libtool. Define several useful
4597 dnl symbols for the makefile rules.
4599 dnl The reference to AC_PROG_LIBTOOL does not normally work, since it uses
4600 dnl macros from libtool.m4 which is in the aclocal directory of automake.
4601 dnl Following is a simple script which turns on the AC_PROG_LIBTOOL macro.
4602 dnl But that still does not work properly since the macro is expanded outside
4603 dnl the CF_WITH_LIBTOOL macro:
4606 dnl ACLOCAL=`aclocal --print-ac-dir`
4607 dnl if test -z "$ACLOCAL" ; then
4608 dnl echo cannot find aclocal directory
4610 dnl elif test ! -f $ACLOCAL/libtool.m4 ; then
4611 dnl echo cannot find libtool.m4 file
4615 dnl LOCAL=aclocal.m4
4616 dnl ORIG=aclocal.m4.orig
4618 dnl trap "mv $ORIG $LOCAL" 0 1 2 5 15
4622 dnl # sed the LIBTOOL= assignment to omit the current directory?
4623 dnl sed -e 's/^LIBTOOL=.*/LIBTOOL=${LIBTOOL-libtool}/' $ACLOCAL/libtool.m4 >>$LOCAL
4624 dnl cat $ORIG >>$LOCAL
4628 AC_DEFUN([CF_WITH_LIBTOOL],
4630 ifdef([AC_PROG_LIBTOOL],,[
4633 # common library maintenance symbols that are convenient for libtool scripts:
4634 LIB_CREATE='${AR} -cr'
4635 LIB_OBJECT='${OBJECTS}'
4639 # symbols used to prop libtool up to enable it to determine what it should be
4647 AC_MSG_CHECKING(if you want to build libraries with libtool)
4648 AC_ARG_WITH(libtool,
4649 [ --with-libtool generate libraries with libtool],
4650 [with_libtool=$withval],
4652 AC_MSG_RESULT($with_libtool)
4653 if test "$with_libtool" != "no"; then
4654 ifdef([AC_PROG_LIBTOOL],[
4655 # missing_content_AC_PROG_LIBTOOL{{
4657 # missing_content_AC_PROG_LIBTOOL}}
4659 if test "$with_libtool" != "yes" ; then
4660 CF_PATH_SYNTAX(with_libtool)
4661 LIBTOOL=$with_libtool
4663 AC_PATH_PROG(LIBTOOL,libtool)
4665 if test -z "$LIBTOOL" ; then
4666 AC_MSG_ERROR(Cannot find libtool)
4669 LIB_CREATE='${LIBTOOL} --mode=link ${CC} -rpath ${DESTDIR}${libdir} -version-info `cut -f1 ${srcdir}/VERSION` -o'
4670 LIB_OBJECT='${OBJECTS}.o=.lo)'
4672 LIB_CLEAN='${LIBTOOL} --mode=clean'
4673 LIB_COMPILE='${LIBTOOL} --mode=compile'
4674 LIB_LINK='${LIBTOOL} --mode=link'
4675 LIB_INSTALL='${LIBTOOL} --mode=install'
4676 LIB_UNINSTALL='${LIBTOOL} --mode=uninstall'
4679 # Show the version of libtool
4680 AC_MSG_CHECKING(version of libtool)
4682 # Save the version in a cache variable - this is not entirely a good
4683 # thing, but the version string from libtool is very ugly, and for
4684 # bug reports it might be useful to have the original string.
4685 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.]].*//'`
4686 AC_MSG_RESULT($cf_cv_libtool_version)
4687 if test -z "$cf_cv_libtool_version" ; then
4688 AC_MSG_ERROR(This is not libtool)
4691 # special hack to add --tag option for C++ compiler
4692 case $cf_cv_libtool_version in
4693 1.[[5-9]]*|[[2-9]]*)
4694 LIBTOOL_CXX="$LIBTOOL --tag=CXX"
4697 LIBTOOL_CXX="$LIBTOOL"
4705 test -z "$LIBTOOL" && ECHO_LT=
4708 AC_SUBST(LIBTOOL_CXX)
4710 AC_SUBST(LIB_CREATE)
4711 AC_SUBST(LIB_OBJECT)
4712 AC_SUBST(LIB_SUFFIX)
4716 AC_SUBST(LIB_COMPILE)
4718 AC_SUBST(LIB_INSTALL)
4719 AC_SUBST(LIB_UNINSTALL)
4722 dnl ---------------------------------------------------------------------------
4723 dnl CF_WITH_PATH version: 7 updated: 2006/08/03 15:20:08
4725 dnl Wrapper for AC_ARG_WITH to ensure that user supplies a pathname, not just
4726 dnl defaulting to yes/no.
4728 dnl $1 = option name
4730 dnl $3 = environment variable to set
4731 dnl $4 = default value, shown in the help-message, must be a constant
4732 dnl $5 = default value, if it's an expression & cannot be in the help-message
4734 AC_DEFUN([CF_WITH_PATH],
4735 [AC_ARG_WITH($1,[$2 ](default: ifelse($4,,empty,$4)),,
4736 ifelse($4,,[withval="${$3}"],[withval="${$3-ifelse($5,,$4,$5)}"]))dnl
4737 CF_PATH_SYNTAX(withval)
4741 dnl ---------------------------------------------------------------------------
4742 dnl CF_WITH_PATHLIST version: 5 updated: 2001/12/10 01:28:30
4743 dnl ----------------
4744 dnl Process an option specifying a list of colon-separated paths.
4746 dnl $1 = option name
4748 dnl $3 = environment variable to set
4749 dnl $4 = default value, shown in the help-message, must be a constant
4750 dnl $5 = default value, if it's an expression & cannot be in the help-message
4751 dnl $6 = flag to tell if we want to define or substitute
4753 AC_DEFUN([CF_WITH_PATHLIST],[
4754 AC_REQUIRE([CF_PATHSEP])
4755 AC_ARG_WITH($1,[$2 ](default: ifelse($4,,empty,$4)),,
4756 ifelse($4,,[withval=${$3}],[withval=${$3-ifelse($5,,$4,$5)}]))dnl
4758 IFS="${IFS= }"; ac_save_ifs="$IFS"; IFS="${PATHSEP}"
4760 for cf_src_path in $withval
4762 CF_PATH_SYNTAX(cf_src_path)
4763 test -n "$cf_dst_path" && cf_dst_path="${cf_dst_path}:"
4764 cf_dst_path="${cf_dst_path}${cf_src_path}"
4769 # Strip single quotes from the value, e.g., when it was supplied as a literal
4771 case $cf_dst_path in #(vi
4773 cf_dst_path=`echo $cf_dst_path |sed -e s/\'// -e s/\'\$//`
4776 cf_dst_path=`echo "$cf_dst_path" | sed -e 's/\\\\/\\\\\\\\/g'`
4779 eval '$3="$cf_dst_path"'
4783 dnl ---------------------------------------------------------------------------
4784 dnl CF_WITH_REL_VERSION version: 1 updated: 2003/09/20 18:12:49
4785 dnl -------------------
4786 dnl Allow library's release-version to be overridden. Generally this happens when a
4787 dnl packager has incremented the release-version past that used in the original package,
4788 dnl and wishes to keep doing this.
4790 dnl $1 is the package name, if any, to derive corresponding {package}_MAJOR
4791 dnl and {package}_MINOR symbols
4793 AC_DEFUN([CF_WITH_REL_VERSION],[
4794 test -z "$cf_cv_rel_version" && cf_cv_rel_version=0.0
4795 AC_ARG_WITH(rel-version,
4796 [ --with-rel-version=XXX override derived release version],
4797 [AC_MSG_WARN(overriding release version $cf_cv_rel_version to $withval)
4798 cf_cv_rel_version=$withval])
4800 CF_NUMBER_SYNTAX($cf_cv_rel_version,Release version)
4802 $1_MAJOR=`echo "$cf_cv_rel_version" | sed -e 's/\..*//'`
4803 $1_MINOR=`echo "$cf_cv_rel_version" | sed -e 's/^[[^.]]*//' -e 's/^\.//' -e 's/\..*//'`
4804 CF_NUMBER_SYNTAX([$]$1_MAJOR,Release major-version)
4805 CF_NUMBER_SYNTAX([$]$1_MINOR,Release minor-version)
4808 dnl ---------------------------------------------------------------------------
4809 dnl CF_WITH_SYSMOUSE version: 2 updated: 2003/03/22 19:13:43
4810 dnl ----------------
4811 dnl If we can compile with sysmouse, make it available unless it is not wanted.
4812 AC_DEFUN([CF_WITH_SYSMOUSE],[
4813 # not everyone has "test -c"
4814 if test -c /dev/sysmouse 2>/dev/null ; then
4815 AC_MSG_CHECKING(if you want to use sysmouse)
4816 AC_ARG_WITH(sysmouse,
4817 [ --with-sysmouse use sysmouse (FreeBSD console)],
4818 [cf_with_sysmouse=$withval],
4819 [cf_with_sysmouse=maybe])
4820 if test "$cf_with_sysmouse" != no ; then
4822 #include <osreldate.h>
4823 #if (__FreeBSD_version >= 400017)
4824 #include <sys/consio.h>
4825 #include <sys/fbio.h>
4827 #include <machine/console.h>
4830 struct mouse_info the_mouse;
4831 ioctl(0, CONS_MOUSECTL, &the_mouse);
4832 ],[cf_with_sysmouse=yes],[cf_with_sysmouse=no])
4834 AC_MSG_RESULT($cf_with_sysmouse)
4835 test "$cf_with_sysmouse" = yes && AC_DEFINE(USE_SYSMOUSE)
4838 dnl ---------------------------------------------------------------------------
4839 dnl CF_WITH_VALGRIND version: 1 updated: 2006/12/14 18:00:21
4840 dnl ----------------
4841 AC_DEFUN([CF_WITH_VALGRIND],[
4842 CF_NO_LEAKS_OPTION(valgrind,
4843 [ --with-valgrind test: use valgrind],
4846 dnl ---------------------------------------------------------------------------
4847 dnl CF_XOPEN_SOURCE version: 25 updated: 2007/01/29 18:36:38
4849 dnl Try to get _XOPEN_SOURCE defined properly that we can use POSIX functions,
4850 dnl or adapt to the vendor's definitions to get equivalent functionality,
4851 dnl without losing the common non-POSIX features.
4854 dnl $1 is the nominal value for _XOPEN_SOURCE
4855 dnl $2 is the nominal value for _POSIX_C_SOURCE
4856 AC_DEFUN([CF_XOPEN_SOURCE],[
4858 AC_REQUIRE([CF_PROG_CC_U_D])
4860 cf_XOPEN_SOURCE=ifelse($1,,500,$1)
4861 cf_POSIX_C_SOURCE=ifelse($2,,199506L,$2)
4863 case $host_os in #(vi
4865 CPPFLAGS="$CPPFLAGS -D_ALL_SOURCE"
4868 # 5.x headers associate
4869 # _XOPEN_SOURCE=600 with _POSIX_C_SOURCE=200112L
4870 # _XOPEN_SOURCE=500 with _POSIX_C_SOURCE=199506L
4871 cf_POSIX_C_SOURCE=200112L
4873 CPPFLAGS="$CPPFLAGS -D_BSD_TYPES -D__BSD_VISIBLE -D_POSIX_C_SOURCE=$cf_POSIX_C_SOURCE -D_XOPEN_SOURCE=$cf_XOPEN_SOURCE"
4876 CPPFLAGS="$CPPFLAGS -D_HPUX_SOURCE"
4879 CPPFLAGS="$CPPFLAGS -D_SGI_SOURCE"
4881 linux*|gnu*|k*bsd*-gnu) #(vi
4885 # setting _XOPEN_SOURCE or _POSIX_SOURCE breaks <arpa/inet.h>
4888 # setting _XOPEN_SOURCE breaks IPv6 for lynx on NetBSD 1.6, breaks xterm, is not needed for ncursesw
4891 # setting _XOPEN_SOURCE breaks xterm on OpenBSD 2.8, is not needed for ncursesw
4894 CPPFLAGS="$CPPFLAGS -D_OSF_SOURCE"
4897 CPPFLAGS="$CPPFLAGS -D_QNX_SOURCE"
4900 # setting _XOPEN_SOURCE breaks Lynx on SCO Unix / OpenServer
4903 CPPFLAGS="$CPPFLAGS -D__EXTENSIONS__"
4906 AC_CACHE_CHECK(if we should define _XOPEN_SOURCE,cf_cv_xopen_source,[
4907 AC_TRY_COMPILE([#include <sys/types.h>],[
4908 #ifndef _XOPEN_SOURCE
4911 [cf_cv_xopen_source=no],
4912 [cf_save="$CPPFLAGS"
4913 CPPFLAGS="$CPPFLAGS -D_XOPEN_SOURCE=$cf_XOPEN_SOURCE"
4914 AC_TRY_COMPILE([#include <sys/types.h>],[
4915 #ifdef _XOPEN_SOURCE
4918 [cf_cv_xopen_source=no],
4919 [cf_cv_xopen_source=$cf_XOPEN_SOURCE])
4923 if test "$cf_cv_xopen_source" != no ; then
4924 CF_REMOVE_DEFINE(CFLAGS,$CFLAGS,_XOPEN_SOURCE)
4925 CF_REMOVE_DEFINE(CPPFLAGS,$CPPFLAGS,_XOPEN_SOURCE)
4926 test "$cf_cv_cc_u_d_options" = yes && \
4927 CPPFLAGS="$CPPFLAGS -U_XOPEN_SOURCE"
4928 CPPFLAGS="$CPPFLAGS -D_XOPEN_SOURCE=$cf_cv_xopen_source"
4930 CF_POSIX_C_SOURCE($cf_POSIX_C_SOURCE)