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.433 2007/04/28 19:26:13 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_CHECK_GPM_WGETCH version: 1 updated: 2007/04/28 14:38:06
616 dnl -------------------
617 dnl Check if GPM is already linked with curses. If so - and if the linkage
618 dnl is not "weak" - warn about this because it can create problems linking
619 dnl applications with ncurses.
620 AC_DEFUN([CF_CHECK_GPM_WGETCH],[
621 AC_CHECK_LIB(gpm,Gpm_Wgetch,[
623 AC_CACHE_CHECK(if GPM is weakly bound to curses library, cf_cv_check_gpm_wgetch,[
624 cf_cv_check_gpm_wgetch=unknown
625 if test "$cross_compiling" != yes ; then
627 cat >conftest.$ac_ext <<CF_EOF
632 ${cf_cv_main_return:-return}(0);
637 # This only works if we can look at the symbol table. If a shared
638 # library is stripped for install, we cannot use that. So we're forced
639 # to rely on the static library, noting that some packagers may not
641 LIBS="-static -lgpm -dynamic $LIBS"
642 if AC_TRY_EVAL(ac_compile) ; then
643 if AC_TRY_EVAL(ac_link) ; then
644 cf_cv_check_gpm_wgetch=`nm conftest$ac_exeext | egrep '\<wgetch\>' | egrep '\<[[vVwW]]\>'`
645 test -n "$cf_cv_check_gpm_wgetch" && cf_cv_check_gpm_wgetch=yes
646 test -z "$cf_cv_check_gpm_wgetch" && cf_cv_check_gpm_wgetch=no
654 if test "$cf_cv_check_gpm_wgetch" != yes ; then
655 AC_MSG_WARN(GPM library is already linked with curses - read the FAQ)
658 dnl ---------------------------------------------------------------------------
659 dnl CF_CPP_PARAM_INIT version: 4 updated: 2001/04/07 22:31:18
660 dnl -----------------
661 dnl Check if the C++ compiler accepts duplicate parameter initialization. This
662 dnl is a late feature for the standard and is not in some recent compilers
664 AC_DEFUN([CF_CPP_PARAM_INIT],
666 if test -n "$CXX"; then
667 AC_CACHE_CHECK(if $CXX accepts parameter initialization,cf_cv_cpp_param_init,[
679 TEST::TEST(int x = 1) // some compilers do not like second initializer
685 [cf_cv_cpp_param_init=yes],
686 [cf_cv_cpp_param_init=no],
687 [cf_cv_cpp_param_init=unknown])
691 test "$cf_cv_cpp_param_init" = yes && AC_DEFINE(CPP_HAS_PARAM_INIT)
693 dnl ---------------------------------------------------------------------------
694 dnl CF_CPP_STATIC_CAST version: 1 updated: 2005/07/23 16:52:43
695 dnl ------------------
696 dnl Check if the C++ compiler accepts static_cast in generics. This appears to
697 dnl not be supported in g++ before 3.0
698 AC_DEFUN([CF_CPP_STATIC_CAST],
700 if test -n "$CXX"; then
702 AC_CACHE_CHECK(if $CXX accepts static_cast,cf_cv_cpp_static_cast,[
710 NCursesPanel(int nlines,
720 template<class T> class NCursesUserPanel : public NCursesPanel
723 NCursesUserPanel (int nlines,
727 const T* p_UserData = static_cast<T*>(0))
728 : NCursesPanel (nlines, ncols, begin_y, begin_x)
731 NCursesUserPanel(const T* p_UserData = static_cast<T*>(0)) : NCursesPanel()
735 virtual ~NCursesUserPanel() {};
738 const char* p_UserData = static_cast<char*>(0)],
739 [cf_cv_cpp_static_cast=yes],
740 [cf_cv_cpp_static_cast=no])
747 test "$cf_cv_cpp_static_cast" = yes && AC_DEFINE(CPP_HAS_STATIC_CAST)
749 dnl ---------------------------------------------------------------------------
750 dnl CF_C_INLINE version: 1 updated: 2007/04/28 15:03:44
752 dnl Check if the C compiler supports "inline".
753 dnl $1 is the name of a shell variable to set if inline is supported
754 dnl $2 is the threshold for gcc 4.x's option controlling maximum inline size
755 AC_DEFUN([CF_C_INLINE],[
758 if test "$ac_cv_c_inline" != no ; then
762 AC_CACHE_CHECK(if gcc supports options to tune inlining,cf_cv_gcc_inline,[
763 cf_save_CFLAGS=$CFLAGS
764 CFLAGS="$CFLAGS --param max-inline-insns-single=$2"
765 AC_TRY_COMPILE([inline int foo(void) { return 1; }],
766 [${cf_cv_main_return:-return} foo()],
767 [cf_cv_gcc_inline=yes],
768 [cf_cv_gcc_inline=no])
769 CFLAGS=$cf_save_CFLAGS
771 if test "$cf_cv_gcc_inline" = yes ; then
772 CF_ADD_CFLAGS([--param max-inline-insns-single=$2])
778 dnl ---------------------------------------------------------------------------
779 dnl CF_DIRNAME version: 4 updated: 2002/12/21 19:25:52
781 dnl "dirname" is not portable, so we fake it with a shell script.
782 AC_DEFUN([CF_DIRNAME],[$1=`echo $2 | sed -e 's%/[[^/]]*$%%'`])dnl
783 dnl ---------------------------------------------------------------------------
784 dnl CF_DIRS_TO_MAKE version: 3 updated: 2002/02/23 20:38:31
786 AC_DEFUN([CF_DIRS_TO_MAKE],
789 for cf_item in $cf_list_models
791 CF_OBJ_SUBDIR($cf_item,cf_subdir)
792 for cf_item2 in $DIRS_TO_MAKE
794 test $cf_item2 = $cf_subdir && break
796 test ".$cf_item2" != ".$cf_subdir" && DIRS_TO_MAKE="$DIRS_TO_MAKE $cf_subdir"
798 for cf_dir in $DIRS_TO_MAKE
800 test ! -d $cf_dir && mkdir $cf_dir
802 AC_SUBST(DIRS_TO_MAKE)
804 dnl ---------------------------------------------------------------------------
805 dnl CF_DISABLE_LEAKS version: 4 updated: 2006/12/16 15:10:42
807 dnl Combine no-leak checks with the libraries or tools that are used for the
809 AC_DEFUN([CF_DISABLE_LEAKS],[
811 AC_REQUIRE([CF_WITH_DMALLOC])
812 AC_REQUIRE([CF_WITH_DBMALLOC])
813 AC_REQUIRE([CF_WITH_VALGRIND])
815 AC_MSG_CHECKING(if you want to perform memory-leak testing)
817 [ --disable-leaks test: free permanent memory, analyze leaks],
819 : ${with_no_leaks:=no})
820 AC_MSG_RESULT($with_no_leaks)
822 if test "$with_no_leaks" = yes ; then
826 dnl ---------------------------------------------------------------------------
827 dnl CF_ERRNO version: 5 updated: 1997/11/30 12:44:39
829 dnl Check if 'errno' is declared in <errno.h>
832 CF_CHECK_ERRNO(errno)
834 dnl ---------------------------------------------------------------------------
835 dnl CF_ETIP_DEFINES version: 3 updated: 2003/03/22 19:13:43
837 dnl Test for conflicting definitions of exception in gcc 2.8.0, etc., between
838 dnl math.h and builtin.h, only for ncurses
839 AC_DEFUN([CF_ETIP_DEFINES],
841 AC_MSG_CHECKING(for special defines needed for etip.h)
842 cf_save_CXXFLAGS="$CXXFLAGS"
844 for cf_math in "" MATH_H
846 for cf_excp in "" MATH_EXCEPTION
848 CXXFLAGS="$cf_save_CXXFLAGS -I${srcdir}/c++ -I${srcdir}/menu -I${srcdir}/include"
849 test -n "$cf_math" && CXXFLAGS="$CXXFLAGS -DETIP_NEEDS_${cf_math}"
850 test -n "$cf_excp" && CXXFLAGS="$CXXFLAGS -DETIP_NEEDS_${cf_excp}"
854 test -n "$cf_math" && AC_DEFINE_UNQUOTED(ETIP_NEEDS_${cf_math})
855 test -n "$cf_excp" && AC_DEFINE_UNQUOTED(ETIP_NEEDS_${cf_excp})
856 cf_result="$cf_math $cf_excp"
861 AC_MSG_RESULT($cf_result)
862 CXXFLAGS="$cf_save_CXXFLAGS"
864 dnl ---------------------------------------------------------------------------
865 dnl CF_FUNC_DLSYM version: 1 updated: 2004/06/16 20:52:45
867 dnl Test for dlsym() and related functions, as well as libdl.
872 AC_DEFUN([CF_FUNC_DLSYM],[
874 AC_CHECK_FUNC(dlsym,cf_have_dlsym=yes,[
877 AC_CHECK_LIB(dl,dlsym,[
879 cf_have_libdl=yes])])
881 if test "$cf_have_dlsym" = yes ; then
882 test "$cf_have_libdl" = yes && LIBS="-ldl $LIBS"
884 AC_MSG_CHECKING(whether able to link to dl*() functions)
885 AC_TRY_LINK([#include <dlfcn.h>],[
887 if ((obj = dlopen("filename", 0)) != 0) {
888 if (dlsym(obj, "symbolname") == 0) {
892 AC_DEFINE(HAVE_LIBDL)],[
893 AC_MSG_ERROR(Cannot link test program for libdl)])
896 AC_MSG_ERROR(Cannot find dlsym function)
899 dnl ---------------------------------------------------------------------------
900 dnl CF_FUNC_MEMMOVE version: 7 updated: 2006/12/16 12:33:30
902 dnl Check for memmove, or a bcopy that can handle overlapping copy. If neither
903 dnl is found, add our own version of memmove to the list of objects.
904 AC_DEFUN([CF_FUNC_MEMMOVE],
906 AC_CHECK_FUNC(memmove,,[
907 AC_CHECK_FUNC(bcopy,[
908 AC_CACHE_CHECK(if bcopy does overlapping moves,cf_cv_good_bcopy,[
911 static char data[] = "abcdefghijklmnopqrstuwwxyz";
913 bcopy(data, temp, sizeof(data));
914 bcopy(temp+10, temp, 15);
915 bcopy(temp+5, temp+15, 10);
916 ${cf_cv_main_return:-return} (strcmp(temp, "klmnopqrstuwwxypqrstuwwxyz"));
919 [cf_cv_good_bcopy=yes],
920 [cf_cv_good_bcopy=no],
921 [cf_cv_good_bcopy=unknown])
923 ],[cf_cv_good_bcopy=no])
924 if test "$cf_cv_good_bcopy" = yes ; then
925 AC_DEFINE(USE_OK_BCOPY)
927 AC_DEFINE(USE_MY_MEMMOVE)
930 dnl ---------------------------------------------------------------------------
931 dnl CF_FUNC_NANOSLEEP version: 3 updated: 2006/12/16 12:33:30
932 dnl -----------------
933 dnl Check for existence of workable nanosleep() function. Some systems, e.g.,
934 dnl AIX 4.x, provide a non-working version.
935 AC_DEFUN([CF_FUNC_NANOSLEEP],[
936 AC_CACHE_CHECK(if nanosleep really works,cf_cv_func_nanosleep,[
942 #ifdef HAVE_SYS_TIME_H
943 #include <sys/time.h>
947 struct timespec ts1, ts2;
950 ts1.tv_nsec = 750000000;
954 code = nanosleep(&ts1, &ts2); /* on failure errno is ENOSYS. */
955 ${cf_cv_main_return:-return}(code != 0);
958 [cf_cv_func_nanosleep=yes],
959 [cf_cv_func_nanosleep=no],
960 [cf_cv_func_nanosleep=unknown])])
962 test "$cf_cv_func_nanosleep" = "yes" && AC_DEFINE(HAVE_NANOSLEEP)
964 dnl ---------------------------------------------------------------------------
965 dnl CF_FUNC_POLL version: 4 updated: 2006/12/16 12:33:30
967 dnl See if the poll function really works. Some platforms have poll(), but
968 dnl it does not work for terminals or files.
969 AC_DEFUN([CF_FUNC_POLL],[
970 AC_CACHE_CHECK(if poll really works,cf_cv_working_poll,[
976 #include <sys/poll.h>
983 myfds.events = POLLIN;
985 ret = poll(&myfds, 1, 100);
986 ${cf_cv_main_return:-return}(ret != 0);
988 [cf_cv_working_poll=yes],
989 [cf_cv_working_poll=no],
990 [cf_cv_working_poll=unknown])])
991 test "$cf_cv_working_poll" = "yes" && AC_DEFINE(HAVE_WORKING_POLL)
993 dnl ---------------------------------------------------------------------------
994 dnl CF_FUNC_TERMIOS version: 2 updated: 2000/07/22 23:37:24
996 dnl Some old/broken variations define tcgetattr() only as a macro in
998 AC_DEFUN([CF_FUNC_TERMIOS],[
999 AC_REQUIRE([CF_STRUCT_TERMIOS])
1000 AC_CACHE_CHECK(for tcgetattr, cf_cv_have_tcgetattr,[
1002 #include <sys/types.h>
1003 #ifdef HAVE_UNISTD_H
1006 #ifdef HAVE_TERMIOS_H
1007 #include <termios.h>
1008 #define TTY struct termios
1010 #ifdef HAVE_TERMIO_H
1012 #define TTY struct termio
1017 tcgetattr(1, &foo);],
1018 [cf_cv_have_tcgetattr=yes],
1019 [cf_cv_have_tcgetattr=no])])
1020 test "$cf_cv_have_tcgetattr" = yes && AC_DEFINE(HAVE_TCGETATTR)
1022 dnl ---------------------------------------------------------------------------
1023 dnl CF_FUNC_VSSCANF version: 3 updated: 2001/12/19 00:50:10
1025 dnl Check for vsscanf() function, which is in c9x but generally not in earlier
1026 dnl versions of C. It is in the GNU C library, and can often be simulated by
1027 dnl other functions.
1028 AC_DEFUN([CF_FUNC_VSSCANF],
1030 AC_CACHE_CHECK(for vsscanf function or workaround,cf_cv_func_vsscanf,[
1033 #include <stdio.h>],[
1035 vsscanf("from", "%d", ap)],[cf_cv_func_vsscanf=vsscanf],[
1038 #include <stdio.h>],[
1042 strbuf._flag = _IOREAD;
1043 strbuf._ptr = strbuf._base = (unsigned char *) str;
1044 strbuf._cnt = strlen(str);
1045 strbuf._file = _NFILE;
1046 return (vfscanf(&strbuf, "%d", ap))],[cf_cv_func_vsscanf=vfscanf],[
1049 #include <stdio.h>],[
1053 strbuf._flag = _IOREAD;
1054 strbuf._ptr = strbuf._base = (unsigned char *) str;
1055 strbuf._cnt = strlen(str);
1056 strbuf._file = _NFILE;
1057 return (_doscan(&strbuf, "%d", ap))],[cf_cv_func_vsscanf=_doscan],[
1058 cf_cv_func_vsscanf=no])])])])
1060 case $cf_cv_func_vsscanf in #(vi
1061 vsscanf) AC_DEFINE(HAVE_VSSCANF);; #(vi
1062 vfscanf) AC_DEFINE(HAVE_VFSCANF);; #(vi
1063 _doscan) AC_DEFINE(HAVE__DOSCAN);;
1067 dnl ---------------------------------------------------------------------------
1068 dnl CF_GCC_ATTRIBUTES version: 10 updated: 2005/05/28 13:16:28
1069 dnl -----------------
1070 dnl Test for availability of useful gcc __attribute__ directives to quiet
1071 dnl compiler warnings. Though useful, not all are supported -- and contrary
1072 dnl to documentation, unrecognized directives cause older compilers to barf.
1073 AC_DEFUN([CF_GCC_ATTRIBUTES],
1075 if test "$GCC" = yes
1077 cat > conftest.i <<EOF
1079 #define GCC_PRINTF 0
1084 #ifndef GCC_NORETURN
1085 #define GCC_NORETURN /* nothing */
1088 #define GCC_UNUSED /* nothing */
1091 if test "$GCC" = yes
1093 AC_CHECKING([for $CC __attribute__ directives])
1094 cat > conftest.$ac_ext <<EOF
1095 #line __oline__ "configure"
1096 #include "confdefs.h"
1097 #include "conftest.h"
1098 #include "conftest.i"
1100 #define GCC_PRINTFLIKE(fmt,var) __attribute__((format(printf,fmt,var)))
1102 #define GCC_PRINTFLIKE(fmt,var) /*nothing*/
1105 #define GCC_SCANFLIKE(fmt,var) __attribute__((format(scanf,fmt,var)))
1107 #define GCC_SCANFLIKE(fmt,var) /*nothing*/
1109 extern void wow(char *,...) GCC_SCANFLIKE(1,2);
1110 extern void oops(char *,...) GCC_PRINTFLIKE(1,2) GCC_NORETURN;
1111 extern void foo(void) GCC_NORETURN;
1112 int main(int argc GCC_UNUSED, char *argv[[]] GCC_UNUSED) { return 0; }
1114 for cf_attribute in scanf printf unused noreturn
1116 CF_UPPER(cf_ATTRIBUTE,$cf_attribute)
1117 cf_directive="__attribute__(($cf_attribute))"
1118 echo "checking for $CC $cf_directive" 1>&AC_FD_CC
1119 case $cf_attribute in
1121 cat >conftest.h <<EOF
1122 #define GCC_$cf_ATTRIBUTE 1
1126 cat >conftest.h <<EOF
1127 #define GCC_$cf_ATTRIBUTE $cf_directive
1131 if AC_TRY_EVAL(ac_compile); then
1132 test -n "$verbose" && AC_MSG_RESULT(... $cf_attribute)
1133 cat conftest.h >>confdefs.h
1137 fgrep define conftest.i >>confdefs.h
1142 dnl ---------------------------------------------------------------------------
1143 dnl CF_GCC_VERSION version: 4 updated: 2005/08/27 09:53:42
1145 dnl Find version of gcc
1146 AC_DEFUN([CF_GCC_VERSION],[
1147 AC_REQUIRE([AC_PROG_CC])
1149 if test "$GCC" = yes ; then
1150 AC_MSG_CHECKING(version of $CC)
1151 GCC_VERSION="`${CC} --version| sed -e '2,$d' -e 's/^.*(GCC) //' -e 's/^[[^0-9.]]*//' -e 's/[[^0-9.]].*//'`"
1152 test -z "$GCC_VERSION" && GCC_VERSION=unknown
1153 AC_MSG_RESULT($GCC_VERSION)
1156 dnl ---------------------------------------------------------------------------
1157 dnl CF_GCC_WARNINGS version: 20 updated: 2005/08/06 18:37:29
1159 dnl Check if the compiler supports useful warning options. There's a few that
1160 dnl we don't use, simply because they're too noisy:
1162 dnl -Wconversion (useful in older versions of gcc, but not in gcc 2.7.x)
1163 dnl -Wredundant-decls (system headers make this too noisy)
1164 dnl -Wtraditional (combines too many unrelated messages, only a few useful)
1165 dnl -Wwrite-strings (too noisy, but should review occasionally). This
1166 dnl is enabled for ncurses using "--enable-const".
1170 dnl $1 is an optional list of gcc warning flags that a particular
1171 dnl application might want to use, e.g., "no-unused" for
1174 dnl If $with_ext_const is "yes", add a check for -Wwrite-strings
1176 AC_DEFUN([CF_GCC_WARNINGS],
1178 AC_REQUIRE([CF_GCC_VERSION])
1179 CF_INTEL_COMPILER(GCC,INTEL_COMPILER,CFLAGS)
1181 cat > conftest.$ac_ext <<EOF
1182 #line __oline__ "configure"
1183 int main(int argc, char *argv[[]]) { return (argv[[argc-1]] == 0) ; }
1186 if test "$INTEL_COMPILER" = yes
1188 # The "-wdXXX" options suppress warnings:
1189 # remark #1419: external declaration in primary source file
1190 # remark #1682: implicit conversion of a 64-bit integral type to a smaller integral type (potential portability problem)
1191 # remark #1683: explicit conversion of a 64-bit integral type to a smaller integral type (potential portability problem)
1192 # remark #1684: conversion from pointer to same-sized integral type (potential portability problem)
1193 # remark #193: zero used for undefined preprocessing identifier
1194 # remark #593: variable "curs_sb_left_arrow" was set but never used
1195 # remark #810: conversion from "int" to "Dimension={unsigned short}" may lose significant bits
1196 # remark #869: parameter "tw" was never referenced
1197 # remark #981: operands are evaluated in unspecified order
1198 # warning #269: invalid format string conversion
1200 AC_CHECKING([for $CC warning options])
1201 cf_save_CFLAGS="$CFLAGS"
1202 EXTRA_CFLAGS="-Wall"
1215 CFLAGS="$cf_save_CFLAGS $EXTRA_CFLAGS -$cf_opt"
1216 if AC_TRY_EVAL(ac_compile); then
1217 test -n "$verbose" && AC_MSG_RESULT(... -$cf_opt)
1218 EXTRA_CFLAGS="$EXTRA_CFLAGS -$cf_opt"
1221 CFLAGS="$cf_save_CFLAGS"
1223 elif test "$GCC" = yes
1225 AC_CHECKING([for $CC warning options])
1226 cf_save_CFLAGS="$CFLAGS"
1227 EXTRA_CFLAGS="-W -Wall"
1229 test "$with_ext_const" = yes && cf_warn_CONST="Wwrite-strings"
1231 Wbad-function-cast \
1235 Wmissing-declarations \
1236 Wmissing-prototypes \
1240 Wstrict-prototypes \
1241 Wundef $cf_warn_CONST $1
1243 CFLAGS="$cf_save_CFLAGS $EXTRA_CFLAGS -$cf_opt"
1244 if AC_TRY_EVAL(ac_compile); then
1245 test -n "$verbose" && AC_MSG_RESULT(... -$cf_opt)
1246 case $cf_opt in #(vi
1248 CPPFLAGS="$CPPFLAGS -DXTSTRINGDEFINES"
1251 case $GCC_VERSION in
1253 CF_VERBOSE(feature is broken in gcc $GCC_VERSION)
1258 EXTRA_CFLAGS="$EXTRA_CFLAGS -$cf_opt"
1261 CFLAGS="$cf_save_CFLAGS"
1265 AC_SUBST(EXTRA_CFLAGS)
1267 dnl ---------------------------------------------------------------------------
1268 dnl CF_GNAT_TRY_LINK version: 1 updated: 2004/08/21 19:02:08
1269 dnl ----------------
1270 dnl Verify that a test program compiles/links with GNAT.
1271 dnl $cf_ada_make is set to the program that compiles/links
1272 dnl $ADAFLAGS may be set to the GNAT flags.
1274 dnl $1 is the text of the spec
1275 dnl $2 is the text of the body
1276 dnl $3 is the shell command to execute if successful
1277 dnl $4 is the shell command to execute if not successful
1278 AC_DEFUN([CF_GNAT_TRY_LINK],
1281 cat >>conftest.ads <<CF_EOF
1284 cat >>conftest.adb <<CF_EOF
1287 if ( $cf_ada_make $ADAFLAGS conftest 1>&AC_FD_CC 2>&1 ) ; then
1288 ifelse($3,, :,[ $3])
1294 dnl ---------------------------------------------------------------------------
1295 dnl CF_GNAT_TRY_RUN version: 3 updated: 2004/08/21 19:02:08
1297 dnl Verify that a test program compiles and runs with GNAT
1298 dnl $cf_ada_make is set to the program that compiles/links
1299 dnl $ADAFLAGS may be set to the GNAT flags.
1301 dnl $1 is the text of the spec
1302 dnl $2 is the text of the body
1303 dnl $3 is the shell command to execute if successful
1304 dnl $4 is the shell command to execute if not successful
1305 AC_DEFUN([CF_GNAT_TRY_RUN],
1308 cat >>conftest.ads <<CF_EOF
1311 cat >>conftest.adb <<CF_EOF
1314 if ( $cf_ada_make $ADAFLAGS conftest 1>&AC_FD_CC 2>&1 ) ; then
1315 if ( ./conftest 1>&AC_FD_CC 2>&1 ) ; then
1316 ifelse($3,, :,[ $3])
1325 dnl ---------------------------------------------------------------------------
1326 dnl CF_GNAT_VERSION version: 12 updated: 2006/10/14 15:23:15
1328 dnl Verify version of GNAT.
1329 AC_DEFUN([CF_GNAT_VERSION],
1331 AC_MSG_CHECKING(for gnat version)
1332 cf_gnat_version=`${cf_ada_make-gnatmake} -v 2>&1 | grep '[[0-9]].[[0-9]][[0-9]]*' |\
1333 sed -e '2,$d' -e 's/[[^0-9 \.]]//g' -e 's/^[[ ]]*//' -e 's/ .*//'`
1334 AC_MSG_RESULT($cf_gnat_version)
1336 case $cf_gnat_version in
1337 3.1[[1-9]]*|3.[[2-9]]*|[[4-9]].*)
1338 cf_cv_prog_gnat_correct=yes
1340 *) echo Unsupported GNAT version $cf_gnat_version. Required is 3.11 or better. Disabling Ada95 binding.
1341 cf_cv_prog_gnat_correct=no
1344 case $cf_gnat_version in
1345 3.[[1-9]]*|[[4-9]].*)
1346 cf_compile_generics=generics
1347 cf_generic_objects="\${GENOBJS}"
1349 *) cf_compile_generics=
1354 dnl ---------------------------------------------------------------------------
1355 dnl CF_GNU_SOURCE version: 6 updated: 2005/07/09 13:23:07
1357 dnl Check if we must define _GNU_SOURCE to get a reasonable value for
1358 dnl _XOPEN_SOURCE, upon which many POSIX definitions depend. This is a defect
1359 dnl (or misfeature) of glibc2, which breaks portability of many applications,
1360 dnl since it is interwoven with GNU extensions.
1362 dnl Well, yes we could work around it...
1363 AC_DEFUN([CF_GNU_SOURCE],
1365 AC_CACHE_CHECK(if we must define _GNU_SOURCE,cf_cv_gnu_source,[
1366 AC_TRY_COMPILE([#include <sys/types.h>],[
1367 #ifndef _XOPEN_SOURCE
1370 [cf_cv_gnu_source=no],
1371 [cf_save="$CPPFLAGS"
1372 CPPFLAGS="$CPPFLAGS -D_GNU_SOURCE"
1373 AC_TRY_COMPILE([#include <sys/types.h>],[
1374 #ifdef _XOPEN_SOURCE
1377 [cf_cv_gnu_source=no],
1378 [cf_cv_gnu_source=yes])
1382 test "$cf_cv_gnu_source" = yes && CPPFLAGS="$CPPFLAGS -D_GNU_SOURCE"
1384 dnl ---------------------------------------------------------------------------
1385 dnl CF_GPP_LIBRARY version: 8 updated: 2003/02/02 01:41:46
1387 dnl If we're trying to use g++, test if libg++ is installed (a rather common
1388 dnl problem :-). If we have the compiler but no library, we'll be able to
1389 dnl configure, but won't be able to build the c++ demo program.
1390 AC_DEFUN([CF_GPP_LIBRARY],
1392 cf_cxx_library=unknown
1393 case $cf_cv_system_name in #(vi
1401 if test "$GXX" = yes; then
1402 AC_MSG_CHECKING([for lib$cf_gpp_libname])
1404 LIBS="$LIBS -l$cf_gpp_libname"
1406 #include <$cf_gpp_libname/builtin.h>
1408 [two_arg_error_handler_t foo2 = lib_error_handler],
1410 CXXLIBS="$CXXLIBS -l$cf_gpp_libname"
1411 if test "$cf_gpp_libname" = cpp ; then
1412 AC_DEFINE(HAVE_GPP_BUILTIN_H)
1414 AC_DEFINE(HAVE_GXX_BUILTIN_H)
1417 #include <builtin.h>
1419 [two_arg_error_handler_t foo2 = lib_error_handler],
1421 CXXLIBS="$CXXLIBS -l$cf_gpp_libname"
1422 AC_DEFINE(HAVE_BUILTIN_H)],
1423 [cf_cxx_library=no])])
1425 AC_MSG_RESULT($cf_cxx_library)
1428 dnl ---------------------------------------------------------------------------
1429 dnl CF_GXX_VERSION version: 5 updated: 2005/08/27 09:53:42
1431 dnl Check for version of g++
1432 AC_DEFUN([CF_GXX_VERSION],[
1433 AC_REQUIRE([AC_PROG_CPP])
1435 if test "$GXX" = yes; then
1436 AC_MSG_CHECKING(version of g++)
1437 GXX_VERSION="`${CXX-g++} --version| sed -e '2,$d' -e 's/^.*(GCC) //' -e 's/^[[^0-9.]]*//' -e 's/[[^0-9.]].*//'`"
1438 test -z "$GXX_VERSION" && GXX_VERSION=unknown
1439 AC_MSG_RESULT($GXX_VERSION)
1442 dnl ---------------------------------------------------------------------------
1443 dnl CF_GXX_WARNINGS version: 5 updated: 2005/08/13 14:54:38
1445 dnl Check if the compiler supports useful warning options.
1447 dnl Most of gcc's options apply to g++, except:
1448 dnl -Wbad-function-cast
1449 dnl -Wmissing-declarations
1450 dnl -Wnested-externs
1452 dnl Omit a few (for now):
1456 dnl $1 is an optional list of g++ warning flags that a particular
1457 dnl application might want to use, e.g., "no-unused" for
1460 dnl If $with_ext_const is "yes", add a check for -Wwrite-strings
1462 AC_DEFUN([CF_GXX_WARNINGS],
1465 CF_INTEL_COMPILER(GXX,INTEL_CPLUSPLUS,CXXFLAGS)
1467 AC_REQUIRE([CF_GXX_VERSION])
1472 cat > conftest.$ac_ext <<EOF
1473 #line __oline__ "configure"
1474 int main(int argc, char *argv[[]]) { return (argv[[argc-1]] == 0) ; }
1477 if test "$INTEL_CPLUSPLUS" = yes
1479 # The "-wdXXX" options suppress warnings:
1480 # remark #1419: external declaration in primary source file
1481 # remark #1682: implicit conversion of a 64-bit integral type to a smaller integral type (potential portability problem)
1482 # remark #1683: explicit conversion of a 64-bit integral type to a smaller integral type (potential portability problem)
1483 # remark #1684: conversion from pointer to same-sized integral type (potential portability problem)
1484 # remark #193: zero used for undefined preprocessing identifier
1485 # remark #593: variable "curs_sb_left_arrow" was set but never used
1486 # remark #810: conversion from "int" to "Dimension={unsigned short}" may lose significant bits
1487 # remark #869: parameter "tw" was never referenced
1488 # remark #981: operands are evaluated in unspecified order
1489 # warning #269: invalid format string conversion
1491 AC_CHECKING([for $CC warning options])
1492 cf_save_CXXFLAGS="$CXXFLAGS"
1493 EXTRA_CXXFLAGS="-Wall"
1506 CXXFLAGS="$cf_save_CXXFLAGS $EXTRA_CXXFLAGS -$cf_opt"
1507 if AC_TRY_EVAL(ac_compile); then
1508 test -n "$verbose" && AC_MSG_RESULT(... -$cf_opt)
1509 EXTRA_CXXFLAGS="$EXTRA_CXXFLAGS -$cf_opt"
1512 CXXFLAGS="$cf_save_CXXFLAGS"
1514 elif test "$GXX" = yes
1516 AC_CHECKING([for $CXX warning options])
1517 cf_save_CXXFLAGS="$CXXFLAGS"
1518 EXTRA_CXXFLAGS="-W -Wall"
1519 cf_gxx_extra_warnings=""
1520 test "$with_ext_const" = yes && cf_gxx_extra_warnings="Wwrite-strings"
1521 case "$GCC_VERSION" in
1525 cf_gxx_extra_warnings="$cf_gxx_extra_warnings Weffc++"
1531 Woverloaded-virtual \
1537 Wmissing-prototypes \
1540 Wstrict-prototypes \
1541 Wundef $cf_gxx_extra_warnings $1
1543 CXXFLAGS="$cf_save_CXXFLAGS $EXTRA_CXXFLAGS -Werror -$cf_opt"
1544 if AC_TRY_EVAL(ac_compile); then
1545 test -n "$verbose" && AC_MSG_RESULT(... -$cf_opt)
1546 EXTRA_CXXFLAGS="$EXTRA_CXXFLAGS -$cf_opt"
1548 test -n "$verbose" && AC_MSG_RESULT(... no -$cf_opt)
1551 CXXFLAGS="$cf_save_CXXFLAGS"
1556 AC_SUBST(EXTRA_CXXFLAGS)
1558 dnl ---------------------------------------------------------------------------
1559 dnl CF_HASHED_DB version: 1 updated: 2006/08/19 09:16:14
1561 dnl Look for an instance of the Berkeley hashed database.
1562 AC_DEFUN([CF_HASHED_DB],
1564 AC_CHECK_HEADER(db.h,[
1565 CF_HASHED_DB_VERSION
1566 if test "$cf_cv_hashed_db_version" = unknown ; then
1567 AC_MSG_ERROR(Cannot determine version of db)
1570 if test "$cf_cv_hashed_db_libs" = unknown ; then
1571 AC_MSG_ERROR(Cannot determine library for db)
1572 elif test "$cf_cv_hashed_db_libs" != default ; then
1573 LIBS="-l$cf_cv_hashed_db_libs $LIBS"
1577 AC_MSG_ERROR(Cannot find db.h)
1580 dnl ---------------------------------------------------------------------------
1581 dnl CF_HASHED_DB_LIBS version: 6 updated: 2006/12/16 12:33:30
1582 dnl -----------------
1583 dnl Given that we have the header and version for hashed database, find the
1584 dnl library information.
1585 AC_DEFUN([CF_HASHED_DB_LIBS],
1587 AC_CACHE_CHECK(for db libraries, cf_cv_hashed_db_libs,[
1588 cf_cv_hashed_db_libs=unknown
1589 for cf_db_libs in db$cf_cv_hashed_db_version db ''
1591 cf_save_libs="$LIBS"
1592 if test -n "$cf_db_libs"; then
1593 LIBS="-l$cf_db_libs $LIBS"
1595 CF_MSG_LOG(checking for library "$cf_db_libs")
1597 $ac_includes_default
1600 char *path = "/tmp/foo";
1601 #ifdef DB_VERSION_MAJOR
1602 #if DB_VERSION_MAJOR >= 4
1604 db_create(&result, NULL, 0);
1605 result->open(result,
1612 #elif DB_VERSION_MAJOR >= 3
1614 db_create(&result, NULL, 0);
1615 result->open(result,
1621 #elif DB_VERSION_MAJOR >= 2
1630 #endif /* DB_VERSION_MAJOR */
1632 DB *result = dbopen(path,
1638 ${cf_cv_main_return:-return}(result != 0)
1640 if test -n "$cf_db_libs" ; then
1641 cf_cv_hashed_db_libs=$cf_db_libs
1643 cf_cv_hashed_db_libs=default
1645 LIBS="$cf_save_libs"
1648 LIBS="$cf_save_libs"
1652 dnl ---------------------------------------------------------------------------
1653 dnl CF_HASHED_DB_VERSION version: 2 updated: 2006/08/19 15:12:49
1654 dnl --------------------
1655 dnl Given that we have the header file for hashed database, find the version
1657 AC_DEFUN([CF_HASHED_DB_VERSION],
1659 AC_CACHE_CHECK(for version of db, cf_cv_hashed_db_version,[
1660 cf_cv_hashed_db_version=unknown
1662 for cf_db_version in 1 2 3 4
1664 CF_MSG_LOG(checking for db version $cf_db_version)
1666 $ac_includes_default
1669 #ifdef DB_VERSION_MAJOR
1670 /* db2 (DB_VERSION_MAJOR=2) has also DB_VERSION_MINOR, tested with 7 */
1671 #if $cf_db_version == DB_VERSION_MAJOR
1677 #if $cf_db_version == 1
1678 /* ok: assuming this is DB 1.8.5 */
1684 cf_cv_hashed_db_version=$cf_db_version
1690 dnl ---------------------------------------------------------------------------
1691 dnl CF_HELP_MESSAGE version: 3 updated: 1998/01/14 10:56:23
1693 dnl Insert text into the help-message, for readability, from AC_ARG_WITH.
1694 AC_DEFUN([CF_HELP_MESSAGE],
1695 [AC_DIVERT_HELP([$1])dnl
1697 dnl ---------------------------------------------------------------------------
1698 dnl CF_INCLUDE_DIRS version: 5 updated: 2006/10/14 15:23:15
1700 dnl Construct the list of include-options according to whether we're building
1701 dnl in the source directory or using '--srcdir=DIR' option. If we're building
1702 dnl with gcc, don't append the includedir if it happens to be /usr/include,
1703 dnl since that usually breaks gcc's shadow-includes.
1704 AC_DEFUN([CF_INCLUDE_DIRS],
1706 CPPFLAGS="-I. -I../include $CPPFLAGS"
1707 if test "$srcdir" != "."; then
1708 CPPFLAGS="-I\${srcdir}/../include $CPPFLAGS"
1710 if test "$GCC" != yes; then
1711 CPPFLAGS="$CPPFLAGS -I\${includedir}"
1712 elif test "$includedir" != "/usr/include"; then
1713 if test "$includedir" = '${prefix}/include' ; then
1714 if test $prefix != /usr ; then
1715 CPPFLAGS="$CPPFLAGS -I\${includedir}"
1718 CPPFLAGS="$CPPFLAGS -I\${includedir}"
1723 dnl ---------------------------------------------------------------------------
1724 dnl CF_INTEL_COMPILER version: 3 updated: 2005/08/06 18:37:29
1725 dnl -----------------
1726 dnl Check if the given compiler is really the Intel compiler for Linux. It
1727 dnl tries to imitate gcc, but does not return an error when it finds a mismatch
1728 dnl between prototypes, e.g., as exercised by CF_MISSING_CHECK.
1730 dnl This macro should be run "soon" after AC_PROG_CC or AC_PROG_CPLUSPLUS, to
1731 dnl ensure that it is not mistaken for gcc/g++. It is normally invoked from
1732 dnl the wrappers for gcc and g++ warnings.
1734 dnl $1 = GCC (default) or GXX
1735 dnl $2 = INTEL_COMPILER (default) or INTEL_CPLUSPLUS
1736 dnl $3 = CFLAGS (default) or CXXFLAGS
1737 AC_DEFUN([CF_INTEL_COMPILER],[
1738 ifelse($2,,INTEL_COMPILER,[$2])=no
1740 if test "$ifelse($1,,[$1],GCC)" = yes ; then
1743 AC_MSG_CHECKING(if this is really Intel ifelse($1,GXX,C++,C) compiler)
1744 cf_save_CFLAGS="$ifelse($3,,CFLAGS,[$3])"
1745 ifelse($3,,CFLAGS,[$3])="$ifelse($3,,CFLAGS,[$3]) -no-gcc"
1747 #ifdef __INTEL_COMPILER
1751 ],[ifelse($2,,INTEL_COMPILER,[$2])=yes
1752 cf_save_CFLAGS="$cf_save_CFLAGS -we147 -no-gcc"
1754 ifelse($3,,CFLAGS,[$3])="$cf_save_CFLAGS"
1755 AC_MSG_RESULT($ifelse($2,,INTEL_COMPILER,[$2]))
1760 dnl ---------------------------------------------------------------------------
1761 dnl CF_ISASCII version: 3 updated: 2000/08/12 23:18:52
1763 dnl Check if we have either a function or macro for 'isascii()'.
1764 AC_DEFUN([CF_ISASCII],
1766 AC_MSG_CHECKING(for isascii)
1767 AC_CACHE_VAL(cf_cv_have_isascii,[
1768 AC_TRY_LINK([#include <ctype.h>],[int x = isascii(' ')],
1769 [cf_cv_have_isascii=yes],
1770 [cf_cv_have_isascii=no])
1772 AC_MSG_RESULT($cf_cv_have_isascii)
1773 test "$cf_cv_have_isascii" = yes && AC_DEFINE(HAVE_ISASCII)
1775 dnl ---------------------------------------------------------------------------
1776 dnl CF_LARGEFILE version: 6 updated: 2006/09/23 19:07:52
1778 dnl Add checks for large file support.
1779 AC_DEFUN([CF_LARGEFILE],[
1780 ifdef([AC_FUNC_FSEEKO],[
1782 if test "$enable_largefile" != no ; then
1785 # Normally we would collect these definitions in the config.h,
1786 # but (like _XOPEN_SOURCE), some environments rely on having these
1787 # defined before any of the system headers are included. Another
1788 # case comes up with C++, e.g., on AIX the compiler compiles the
1789 # header files by themselves before looking at the body files it is
1790 # told to compile. For ncurses, those header files do not include
1792 test "$ac_cv_sys_large_files" != no && CPPFLAGS="$CPPFLAGS -D_LARGE_FILES "
1793 test "$ac_cv_sys_largefile_source" != no && CPPFLAGS="$CPPFLAGS -D_LARGEFILE_SOURCE "
1795 AC_CACHE_CHECK(whether to use struct dirent64, cf_cv_struct_dirent64,[
1797 #include <sys/types.h>
1800 /* if transitional largefile support is setup, this is true */
1801 extern struct dirent64 * readdir(DIR *);
1802 struct dirent64 *x = readdir((DIR *)0);
1803 struct dirent *y = readdir((DIR *)0);
1806 [cf_cv_struct_dirent64=yes],
1807 [cf_cv_struct_dirent64=no])
1809 test "$cf_cv_struct_dirent64" = yes && AC_DEFINE(HAVE_STRUCT_DIRENT64)
1813 dnl ---------------------------------------------------------------------------
1814 dnl CF_LDFLAGS_STATIC version: 2 updated: 2007/04/28 15:25:27
1815 dnl -----------------
1816 dnl Check for compiler/linker flags used to temporarily force usage of static
1817 dnl libraries. This depends on the compiler and platform. Use this to help
1818 dnl ensure that the linker picks up a given library based on its position in
1819 dnl the list of linker options and libraries.
1820 AC_DEFUN([CF_LDFLAGS_STATIC],[
1822 if test "$GCC" = yes ; then
1823 LDFLAGS_STATIC=-static
1824 LDFLAGS_SHARED=-dynamic
1826 case $cf_cv_system_name in #(
1827 aix[[45]]*) #( from ld manpage
1828 LDFLAGS_STATIC=-bstatic
1829 LDFLAGS_SHARED=-bdynamic
1831 hpux*) #( from ld manpage for hpux10.20, hpux11.11
1832 # We could also use just "archive" and "shared".
1833 LDFLAGS_STATIC=-Wl,-a,archive_shared
1834 LDFLAGS_SHARED=-Wl,-a,shared_archive
1836 irix*) #( from ld manpage IRIX64
1837 LDFLAGS_STATIC=-Bstatic
1838 LDFLAGS_SHARED=-Bdynamic
1840 osf[[45]]*) #( from ld manpage osf4.0d, osf5.1
1841 # alternative "-oldstyle_liblookup" (not in cc manpage)
1842 LDFLAGS_STATIC=-noso
1843 LDFLAGS_SHARED=-so_archive
1846 LDFLAGS_STATIC=-Bstatic
1847 LDFLAGS_SHARED=-Bdynamic
1852 AC_SUBST(LDFLAGS_STATIC)
1853 AC_SUBST(LDFLAGS_SHARED)
1855 dnl ---------------------------------------------------------------------------
1856 dnl CF_LIBUTF8 version: 2 updated: 2002/01/19 22:51:32
1858 dnl Check for libutf8
1859 AC_DEFUN([CF_LIBUTF8],
1861 AC_CACHE_CHECK(for putwc in libutf8,cf_cv_libutf8,[
1862 cf_save_LIBS="$LIBS"
1865 #include <libutf8.h>],[putwc(0,0);],
1866 [cf_cv_libutf8=yes],
1868 LIBS="$cf_save_LIBS"
1871 if test "$cf_cv_libutf8" = yes ; then
1872 AC_DEFINE(HAVE_LIBUTF8_H)
1876 dnl ---------------------------------------------------------------------------
1877 dnl CF_LIB_PREFIX version: 7 updated: 2001/01/12 01:23:48
1879 dnl Compute the library-prefix for the given host system
1880 dnl $1 = variable to set
1881 AC_DEFUN([CF_LIB_PREFIX],
1883 case $cf_cv_system_name in
1884 OS/2*) LIB_PREFIX='' ;;
1885 os2*) LIB_PREFIX='' ;;
1886 *) LIB_PREFIX='lib' ;;
1888 ifelse($1,,,[$1=$LIB_PREFIX])
1889 AC_SUBST(LIB_PREFIX)
1891 dnl ---------------------------------------------------------------------------
1892 dnl CF_LIB_RULES version: 50 updated: 2007/03/24 18:26:59
1894 dnl Append definitions and rules for the given models to the subdirectory
1895 dnl Makefiles, and the recursion rule for the top-level Makefile. If the
1896 dnl subdirectory is a library-source directory, modify the LIBS_TO_MAKE list in
1897 dnl the corresponding makefile to list the models that we'll generate.
1899 dnl For shared libraries, make a list of symbolic links to construct when
1900 dnl generating each library. The convention used for Linux is the simplest
1903 dnl lib<name>.so.<major> ->
1904 dnl lib<name>.so.<maj>.<minor>
1905 AC_DEFUN([CF_LIB_RULES],
1907 CF_LIB_PREFIX(cf_prefix)
1908 AC_REQUIRE([CF_SUBST_NCURSES_VERSION])
1909 for cf_dir in $SRC_SUBDIRS
1911 if test ! -d $srcdir/$cf_dir ; then
1913 elif test -f $srcdir/$cf_dir/modules; then
1917 for cf_item in $cf_LIST_MODELS
1919 CF_LIB_SUFFIX($cf_item,cf_suffix)
1920 if test $cf_item = shared ; then
1921 if test "$cf_cv_do_symlinks" = yes ; then
1922 case "$cf_cv_shlib_version" in #(vi
1924 case "$cf_cv_system_name" in #(vi
1926 case .${LIB_SUFFIX} in
1928 cf_suffix=`echo $cf_suffix | sed 's/^w//'`
1929 cf_suffix=w'.${REL_VERSION}'"$cf_suffix"
1932 cf_suffix='.${REL_VERSION}'"$cf_suffix"
1936 *) cf_suffix="$cf_suffix"'.${REL_VERSION}' ;;
1940 case "$cf_cv_system_name" in #(vi
1942 case .${LIB_SUFFIX} in
1944 cf_suffix=`echo $cf_suffix | sed 's/^w//'`
1945 cf_suffix=w'.${ABI_VERSION}'"$cf_suffix"
1948 cf_suffix='.${ABI_VERSION}'"$cf_suffix"
1952 *) cf_suffix="$cf_suffix"'.${ABI_VERSION}' ;;
1957 # cygwin needs import library, and has unique naming convention
1958 # use autodetected ${cf_prefix} for import lib and static lib, but
1959 # use 'cyg' prefix for shared lib.
1960 if test $cf_cv_shlib_version = cygdll ; then
1961 LIBS_TO_MAKE="$LIBS_TO_MAKE ../lib/cyg${cf_dir}\${ABI_VERSION}.dll"
1965 LIBS_TO_MAKE="$LIBS_TO_MAKE ../lib/${cf_prefix}${cf_dir}${cf_suffix}"
1968 if test $cf_dir = ncurses ; then
1969 cf_subsets="$LIB_SUBSETS"
1970 cf_r_parts="$cf_subsets"
1972 while test -n "$cf_r_parts"
1974 cf_l_parts=`echo "$cf_r_parts" |sed -e 's/ .*$//'`
1975 cf_r_parts=`echo "$cf_r_parts" |sed -e 's/^[[^ ]]* //'`
1976 if test "$cf_l_parts" != "$cf_r_parts" ; then
1977 case $cf_l_parts in #(vi
1979 cf_item=`echo $LIBS_TO_MAKE |sed -e s%${LIB_NAME}${LIB_SUFFIX}%${TINFO_LIB_SUFFIX}%g`
1982 cf_item=`echo $LIBS_TO_MAKE |sed -e s%${LIB_NAME}${LIB_SUFFIX}%${TICS_LIB_SUFFIX}%g`
1988 LIBS_TO_MAKE="$cf_item $LIBS_TO_MAKE"
1994 cf_subsets=`echo "$LIB_SUBSETS" | sed -e 's/^termlib.* //'`
1997 sed -e "s%@LIBS_TO_MAKE@%$LIBS_TO_MAKE%" \
1998 -e "s%@SHARED_LIB@%$SHARED_LIB%" \
1999 $cf_dir/Makefile >$cf_dir/Makefile.out
2000 mv $cf_dir/Makefile.out $cf_dir/Makefile
2002 $AWK -f $srcdir/mk-0th.awk \
2003 libname="${cf_dir}${LIB_SUFFIX}" subsets="$LIB_SUBSETS" \
2004 $srcdir/$cf_dir/modules >>$cf_dir/Makefile
2006 for cf_subset in $cf_subsets
2009 for cf_item in $cf_LIST_MODELS
2011 echo "Appending rules for ${cf_item} model (${cf_dir}: ${cf_subset})"
2012 CF_UPPER(cf_ITEM,$cf_item)
2013 CF_LIB_SUFFIX($cf_item,cf_suffix)
2014 CF_OBJ_SUBDIR($cf_item,cf_subdir)
2016 # Test for case where we build libtinfo with a different name.
2018 if test $cf_dir = ncurses ; then
2023 cf_libname=$TINFO_LIB_SUFFIX
2024 if test -n "${DFT_ARG_SUFFIX}" ; then
2025 # undo $LIB_SUFFIX add-on in CF_LIB_SUFFIX
2026 cf_suffix=`echo $cf_suffix |sed -e "s%^${LIB_SUFFIX}%%"`
2030 cf_libname=$TICS_LIB_SUFFIX
2031 if test -n "${DFT_ARG_SUFFIX}" ; then
2032 # undo $LIB_SUFFIX add-on in CF_LIB_SUFFIX
2033 cf_suffix=`echo $cf_suffix |sed -e "s%^${LIB_SUFFIX}%%"`
2039 # These dependencies really are for development, not
2040 # builds, but they are useful in porting, too.
2041 cf_depend="../include/ncurses_cfg.h"
2042 if test "$srcdir" = "."; then
2045 cf_reldir="\${srcdir}"
2048 if test -f $srcdir/$cf_dir/$cf_dir.priv.h; then
2049 cf_depend="$cf_depend $cf_reldir/$cf_dir.priv.h"
2050 elif test -f $srcdir/$cf_dir/curses.priv.h; then
2051 cf_depend="$cf_depend $cf_reldir/curses.priv.h"
2055 old_cf_suffix="$cf_suffix"
2056 if test "$cf_cv_shlib_version_infix" = yes ; then
2057 if test -n "$LIB_SUFFIX" ; then
2060 cf_libname=`echo $cf_libname | sed 's/w$//'`
2061 cf_suffix=`echo $cf_suffix | sed 's/^w//'`
2068 $AWK -f $srcdir/mk-1st.awk \
2069 name=${cf_libname}${cf_dir_suffix} \
2070 traces=$LIB_TRACING \
2076 TermlibRoot=$TINFO_NAME \
2077 TermlibSuffix=$TINFO_SUFFIX \
2078 ShlibVer=$cf_cv_shlib_version \
2079 ShlibVerInfix=$cf_cv_shlib_version_infix \
2080 ReLink=${cf_cv_do_relink-no} \
2081 DoLinks=$cf_cv_do_symlinks \
2082 rmSoLocs=$cf_cv_rm_so_locs \
2083 ldconfig="$LDCONFIG" \
2084 overwrite=$WITH_OVERWRITE \
2085 depend="$cf_depend" \
2087 $srcdir/$cf_dir/modules >>$cf_dir/Makefile
2089 cf_suffix="$old_cf_suffix"
2091 for cf_subdir2 in $cf_subdirs lib
2093 test $cf_subdir = $cf_subdir2 && break
2095 test "${cf_subset}.${cf_subdir2}" != "${cf_subset}.${cf_subdir}" && \
2096 $AWK -f $srcdir/mk-2nd.awk \
2098 traces=$LIB_TRACING \
2104 crenames=$cf_cv_prog_CC_c_o \
2105 cxxrenames=$cf_cv_prog_CXX_c_o \
2106 $srcdir/$cf_dir/modules >>$cf_dir/Makefile
2107 cf_subdirs="$cf_subdirs $cf_subdir"
2112 echo ' cd '$cf_dir' && ${MAKE} ${CF_MFLAGS} [$]@' >>Makefile
2115 for cf_dir in $SRC_SUBDIRS
2117 if test ! -d $srcdir/$cf_dir ; then
2121 if test -f $cf_dir/Makefile ; then
2124 echo 'libs \' >> Makefile
2125 echo 'install.libs \' >> Makefile
2126 echo 'uninstall.libs ::' >> Makefile
2127 echo ' cd '$cf_dir' && ${MAKE} ${CF_MFLAGS} [$]@' >> Makefile
2132 if test -f $srcdir/$cf_dir/modules; then
2134 if test -f $srcdir/$cf_dir/headers; then
2135 cat >> Makefile <<CF_EOF
2137 uninstall.includes \\
2140 if test "$cf_dir" != "c++" ; then
2141 echo 'lint \' >> Makefile
2143 cat >> Makefile <<CF_EOF
2149 uninstall.$cf_dir ::
2150 cd $cf_dir && \${MAKE} \${CF_MFLAGS} \[$]@
2152 elif test -f $srcdir/$cf_dir/headers; then
2153 cat >> Makefile <<CF_EOF
2159 uninstall.includes ::
2160 cd $cf_dir && \${MAKE} \${CF_MFLAGS} \[$]@
2165 cat >> Makefile <<CF_EOF
2167 install.libs uninstall.libs \\
2168 install.data uninstall.data ::
2169 $MAKE_TERMINFO cd misc && \${MAKE} \${CF_MFLAGS} \[$]@
2173 cd man && \${MAKE} \${CF_MFLAGS} \[$]@
2176 rm -f config.cache config.log config.status Makefile include/ncurses_cfg.h
2177 rm -f headers.sh headers.sed mk_shared_lib.sh
2178 rm -rf \${DIRS_TO_MAKE}
2181 # Special case: tack's manpage lives in its own directory.
2182 if test -d tack ; then
2183 if test -f $srcdir/$tack.h; then
2184 cat >> Makefile <<CF_EOF
2188 cd tack && \${MAKE} \${CF_MFLAGS} \[$]@
2193 dnl If we're installing into a subdirectory of /usr/include, etc., we should
2194 dnl prepend the subdirectory's name to the "#include" paths. It won't hurt
2195 dnl anything, and will make it more standardized. It's awkward to decide this
2196 dnl at configuration because of quoting, so we'll simply make all headers
2197 dnl installed via a script that can do the right thing.
2199 rm -f headers.sed headers.sh
2201 dnl ( generating this script makes the makefiles a little tidier :-)
2202 echo creating headers.sh
2203 cat >headers.sh <<CF_EOF
2205 # This shell script is generated by the 'configure' script. It is invoked in a
2206 # subdirectory of the build tree. It generates a sed-script in the parent
2207 # directory that is used to adjust includes for header files that reside in a
2208 # subdirectory of /usr/include, etc.
2210 while test \[$]# != 3
2212 PRG="\$PRG \[$]1"; shift
2217 TMPSRC=\${TMPDIR-/tmp}/\`basename \$SRC\`\$\$
2218 TMPSED=\${TMPDIR-/tmp}/headers.sed\$\$
2219 echo installing \$SRC in \$DST
2222 if test $WITH_CURSES_H = yes; then
2223 cat >>headers.sh <<CF_EOF
2226 END=\`basename \$DST\`
2227 for i in \`cat \$REF/../*/headers |fgrep -v "#"\`
2229 NAME=\`basename \$i\`
2230 echo "s/<\$NAME>/<\$END\/\$NAME>/" >> \$TMPSED
2240 cat >>headers.sh <<CF_EOF
2243 END=\`basename \$DST\`
2244 for i in \`cat \$REF/../*/headers |fgrep -v "#"\`
2246 NAME=\`basename \$i\`
2247 if test "\$NAME" = "curses.h"
2249 echo "s/<curses.h>/<ncurses.h>/" >> \$TMPSED
2252 echo "s/<\$NAME>/<\$END\/\$NAME>/" >> \$TMPSED
2256 echo "s/<curses.h>/<ncurses.h>/" >> \$TMPSED
2261 cat >>headers.sh <<CF_EOF
2263 sed -f \$TMPSED \$SRC > \$TMPSRC
2264 NAME=\`basename \$SRC\`
2266 if test $WITH_CURSES_H != yes; then
2267 cat >>headers.sh <<CF_EOF
2268 test "\$NAME" = "curses.h" && NAME=ncurses.h
2271 cat >>headers.sh <<CF_EOF
2272 # Just in case someone gzip'd manpages, remove the conflicting copy.
2273 test -f \$DST/\$NAME.gz && rm -f \$DST/\$NAME.gz
2275 eval \$PRG \$TMPSRC \$DST/\$NAME
2276 rm -f \$TMPSRC \$TMPSED
2279 chmod 0755 headers.sh
2281 for cf_dir in $SRC_SUBDIRS
2283 if test ! -d $srcdir/$cf_dir ; then
2287 if test -f $srcdir/$cf_dir/headers; then
2288 $AWK -f $srcdir/mk-hdr.awk \
2289 subset="$LIB_SUBSETS" \
2290 compat="$WITH_CURSES_H" \
2291 $srcdir/$cf_dir/headers >>$cf_dir/Makefile
2294 if test -f $srcdir/$cf_dir/modules; then
2295 if test "$cf_dir" != "c++" ; then
2296 cat >>$cf_dir/Makefile <<"CF_EOF"
2297 depend : ${AUTO_SRC}
2298 makedepend -- ${CPPFLAGS} -- ${C_SRC}
2300 # DO NOT DELETE THIS LINE -- make depend depends on it.
2307 dnl ---------------------------------------------------------------------------
2308 dnl CF_LIB_SONAME version: 3 updated: 2006/12/16 15:55:46
2310 dnl Find the and soname for the given shared library. Set the cache variable
2311 dnl cf_cv_$3_soname to this, unless it is not found. Then set the cache
2312 dnl variable to "unknown".
2316 dnl $3 = library name
2317 AC_DEFUN([CF_LIB_SONAME],
2319 AC_CACHE_CHECK(for soname of $3 library,cf_cv_$3_soname,[
2321 cf_cv_$3_soname=unknown
2322 if test "$cross_compiling" != yes ; then
2323 cat >conftest.$ac_ext <<CF_EOF
2328 ${cf_cv_main_return:-return}(0);
2331 cf_save_LIBS="$LIBS"
2333 if AC_TRY_EVAL(ac_compile) ; then
2334 if AC_TRY_EVAL(ac_link) ; then
2335 cf_cv_$3_soname=`ldd conftest$ac_exeext 2>/dev/null | sed -e 's,^.*/,,' -e 's, .*$,,' | fgrep lib$3.`
2336 test -z "$cf_cv_$3_soname" && cf_cv_$3_soname=unknown
2340 LIBS="$cf_save_LIBS"
2344 dnl ---------------------------------------------------------------------------
2345 dnl CF_LIB_SUFFIX version: 13 updated: 2003/11/01 16:09:07
2347 dnl Compute the library file-suffix from the given model name
2349 dnl $2 = variable to set
2350 dnl The variable $LIB_SUFFIX, if set, prepends the variable to set.
2351 AC_DEFUN([CF_LIB_SUFFIX],
2353 AC_REQUIRE([CF_SUBST_NCURSES_VERSION])
2355 libtool) $2='.la' ;;
2358 profile) $2='_p.a' ;;
2360 case $cf_cv_system_name in
2361 cygwin*) $2='.dll' ;;
2362 darwin*) $2='.dylib' ;;
2372 test -n "$LIB_SUFFIX" && $2="${LIB_SUFFIX}[$]{$2}"
2374 dnl ---------------------------------------------------------------------------
2375 dnl CF_LIB_TYPE version: 4 updated: 2000/10/20 22:57:49
2377 dnl Compute the string to append to -library from the given model name
2379 dnl $2 = variable to set
2380 dnl The variable $LIB_SUFFIX, if set, prepends the variable to set.
2381 AC_DEFUN([CF_LIB_TYPE],
2390 test -n "$LIB_SUFFIX" && $2="${LIB_SUFFIX}[$]{$2}"
2392 dnl ---------------------------------------------------------------------------
2393 dnl CF_LINK_DATAONLY version: 8 updated: 2006/12/16 12:33:30
2394 dnl ----------------
2395 dnl Some systems have a non-ANSI linker that doesn't pull in modules that have
2396 dnl only data (i.e., no functions), for example NeXT. On those systems we'll
2397 dnl have to provide wrappers for global tables to ensure they're linked
2399 AC_DEFUN([CF_LINK_DATAONLY],
2401 AC_MSG_CHECKING([if data-only library module links])
2402 AC_CACHE_VAL(cf_cv_link_dataonly,[
2404 cat >conftest.$ac_ext <<EOF
2405 #line __oline__ "configure"
2406 int testdata[[3]] = { 123, 456, 789 };
2408 if AC_TRY_EVAL(ac_compile) ; then
2409 mv conftest.o data.o && \
2410 ( $AR $AR_OPTS conftest.a data.o ) 2>&AC_FD_CC 1>/dev/null
2412 rm -f conftest.$ac_ext data.o
2413 cat >conftest.$ac_ext <<EOF
2414 #line __oline__ "configure"
2418 ${cf_cv_main_return:-return}(1); /* I'm told this linker is broken */
2420 extern int testdata[[3]];
2421 return testdata[[0]] == 123
2422 && testdata[[1]] == 456
2423 && testdata[[2]] == 789;
2427 if AC_TRY_EVAL(ac_compile); then
2428 mv conftest.o func.o && \
2429 ( $AR $AR_OPTS conftest.a func.o ) 2>&AC_FD_CC 1>/dev/null
2431 rm -f conftest.$ac_ext func.o
2432 ( eval $RANLIB conftest.a ) 2>&AC_FD_CC >/dev/null
2434 LIBS="conftest.a $LIBS"
2438 extern int testfunc();
2439 ${cf_cv_main_return:-return} (!testfunc());
2442 [cf_cv_link_dataonly=yes],
2443 [cf_cv_link_dataonly=no],
2444 [cf_cv_link_dataonly=unknown])
2447 AC_MSG_RESULT($cf_cv_link_dataonly)
2449 if test "$cf_cv_link_dataonly" = no ; then
2450 AC_DEFINE(BROKEN_LINKER)
2455 dnl ---------------------------------------------------------------------------
2456 dnl CF_LINK_FUNCS version: 7 updated: 2006/12/16 12:33:30
2458 dnl Most Unix systems have both link and symlink, a few don't have symlink.
2459 dnl A few non-Unix systems implement symlink, but not link.
2460 dnl A few non-systems implement neither (or have nonfunctional versions).
2461 AC_DEFUN([CF_LINK_FUNCS],
2467 if test "$cross_compiling" = yes ; then
2472 AC_CACHE_CHECK(if link/symlink functions work,cf_cv_link_funcs,[
2474 for cf_func in link symlink ; do
2476 #include <sys/types.h>
2477 #include <sys/stat.h>
2478 #ifdef HAVE_UNISTD_H
2484 char *src = "config.log";
2485 char *dst = "conftest.chk";
2490 fail = ($cf_func("config.log", "conftest.chk") < 0)
2491 || (stat(dst, &dst_sb) < 0)
2492 || (dst_sb.st_mtime != src_sb.st_mtime);
2498 ${cf_cv_main_return:-return} (fail);
2501 cf_cv_link_funcs="$cf_cv_link_funcs $cf_func"
2502 eval 'ac_cv_func_'$cf_func'=yes'],[
2503 eval 'ac_cv_func_'$cf_func'=no'],[
2504 eval 'ac_cv_func_'$cf_func'=error'])
2506 test -z "$cf_cv_link_funcs" && cf_cv_link_funcs=no
2508 test "$ac_cv_func_link" = yes && AC_DEFINE(HAVE_LINK)
2509 test "$ac_cv_func_symlink" = yes && AC_DEFINE(HAVE_SYMLINK)
2512 dnl ---------------------------------------------------------------------------
2513 dnl CF_MAIN_RETURN version: 1 updated: 2006/12/10 09:51:54
2515 dnl Check if a return from main to the shell actually returns the same exit
2516 dnl code. This is true for almost any POSIX environment.
2518 dnl Some very old environments did not flush stdout, etc., on an exit. That
2519 dnl would be a useful case to test for also.
2520 AC_DEFUN([CF_MAIN_RETURN],
2522 cf_cv_main_return=return
2524 dnl ---------------------------------------------------------------------------
2525 dnl CF_MAKEFLAGS version: 12 updated: 2006/10/21 08:27:03
2527 dnl Some 'make' programs support ${MAKEFLAGS}, some ${MFLAGS}, to pass 'make'
2528 dnl options to lower-levels. It's very useful for "make -n" -- if we have it.
2529 dnl (GNU 'make' does both, something POSIX 'make', which happens to make the
2530 dnl ${MAKEFLAGS} variable incompatible because it adds the assignments :-)
2531 AC_DEFUN([CF_MAKEFLAGS],
2533 AC_CACHE_CHECK(for makeflags variable, cf_cv_makeflags,[
2535 for cf_option in '-${MAKEFLAGS}' '${MFLAGS}'
2537 cat >cf_makeflags.tmp <<CF_EOF
2540 @ echo '.$cf_option'
2542 cf_result=`${MAKE-make} -k -f cf_makeflags.tmp 2>/dev/null | sed -e 's,[[ ]]*$,,'`
2543 case "$cf_result" in
2545 cf_result=`${MAKE-make} -k -f cf_makeflags.tmp CC=cc 2>/dev/null`
2546 case "$cf_result" in
2547 .*CC=*) cf_cv_makeflags=
2549 *) cf_cv_makeflags=$cf_option
2555 *) echo "given option \"$cf_option\", no match \"$cf_result\""
2559 rm -f cf_makeflags.tmp
2562 AC_SUBST(cf_cv_makeflags)
2564 dnl ---------------------------------------------------------------------------
2565 dnl CF_MAKE_TAGS version: 2 updated: 2000/10/04 09:18:40
2567 dnl Generate tags/TAGS targets for makefiles. Do not generate TAGS if we have
2568 dnl a monocase filesystem.
2569 AC_DEFUN([CF_MAKE_TAGS],[
2570 AC_REQUIRE([CF_MIXEDCASE_FILENAMES])
2571 AC_CHECK_PROG(MAKE_LOWER_TAGS, ctags, yes, no)
2573 if test "$cf_cv_mixedcase" = yes ; then
2574 AC_CHECK_PROG(MAKE_UPPER_TAGS, etags, yes, no)
2579 if test "$MAKE_UPPER_TAGS" = yes ; then
2584 AC_SUBST(MAKE_UPPER_TAGS)
2586 if test "$MAKE_LOWER_TAGS" = yes ; then
2591 AC_SUBST(MAKE_LOWER_TAGS)
2593 dnl ---------------------------------------------------------------------------
2594 dnl CF_MANPAGE_FORMAT version: 7 updated: 2003/12/20 19:30:34
2595 dnl -----------------
2596 dnl Option to allow user to override automatic configuration of manpage format.
2597 dnl There are several special cases:
2599 dnl gzip - man checks for, can display gzip'd files
2600 dnl compress - man checks for, can display compressed files
2601 dnl BSDI - files in the cat-directories are suffixed ".0"
2602 dnl formatted - installer should format (put files in cat-directory)
2603 dnl catonly - installer should only format, e.g., for a turnkey system.
2605 dnl There are other configurations which this macro does not test, e.g., HPUX's
2606 dnl compressed manpages (but uncompressed manpages are fine, and HPUX's naming
2607 dnl convention would not match our use).
2608 AC_DEFUN([CF_MANPAGE_FORMAT],
2610 AC_REQUIRE([CF_PATHSEP])
2611 AC_MSG_CHECKING(format of man-pages)
2613 AC_ARG_WITH(manpage-format,
2614 [ --with-manpage-format specify manpage-format: gzip/compress/BSDI/normal and
2615 optionally formatted/catonly, e.g., gzip,formatted],
2616 [MANPAGE_FORMAT=$withval],
2617 [MANPAGE_FORMAT=unknown])
2619 test -z "$MANPAGE_FORMAT" && MANPAGE_FORMAT=unknown
2620 MANPAGE_FORMAT=`echo "$MANPAGE_FORMAT" | sed -e 's/,/ /g'`
2624 case $MANPAGE_FORMAT in
2626 if test -z "$MANPATH" ; then
2627 MANPATH="/usr/man:/usr/share/man"
2630 # look for the 'date' man-page (it's most likely to be installed!)
2636 IFS="${IFS= }"; ac_save_ifs="$IFS"; IFS="${IFS}${PATHSEP}"
2637 for cf_dir in $MANPATH; do
2638 test -z "$cf_dir" && cf_dir=/usr/man
2639 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
2641 cf_test=`echo $cf_name | sed -e 's/*//'`
2642 if test "x$cf_test" = "x$cf_name" ; then
2645 *.gz) MANPAGE_FORMAT="$MANPAGE_FORMAT gzip";;
2646 *.Z) MANPAGE_FORMAT="$MANPAGE_FORMAT compress";;
2647 *.0) MANPAGE_FORMAT="$MANPAGE_FORMAT BSDI";;
2648 *) MANPAGE_FORMAT="$MANPAGE_FORMAT normal";;
2662 # if we found a match in either man* or cat*, stop looking
2663 if test -n "$MANPAGE_FORMAT" ; then
2665 test "$cf_preform" = yes && MANPAGE_FORMAT="$MANPAGE_FORMAT formatted"
2666 test "$cf_catonly" = yes && MANPAGE_FORMAT="$MANPAGE_FORMAT catonly"
2672 test $cf_found=yes && break
2675 # only check the first directory in $MANPATH where we find manpages
2676 if test -n "$MANPAGE_FORMAT" ; then
2680 # if we did not find the example, just assume it is normal
2681 test -z "$MANPAGE_FORMAT" && MANPAGE_FORMAT=normal
2685 for cf_option in $MANPAGE_FORMAT; do
2686 case $cf_option in #(vi
2687 gzip|compress|BSDI|normal|formatted|catonly)
2690 cf_unknown="$cf_unknown $cf_option"
2697 AC_MSG_RESULT($MANPAGE_FORMAT)
2698 if test -n "$cf_unknown" ; then
2699 AC_MSG_WARN(Unexpected manpage-format $cf_unknown)
2702 dnl ---------------------------------------------------------------------------
2703 dnl CF_MANPAGE_RENAMES version: 7 updated: 2005/06/18 18:51:57
2704 dnl ------------------
2705 dnl The Debian people have their own naming convention for manpages. This
2706 dnl option lets us override the name of the file containing renaming, or
2707 dnl disable it altogether.
2708 AC_DEFUN([CF_MANPAGE_RENAMES],
2710 AC_MSG_CHECKING(for manpage renaming)
2712 AC_ARG_WITH(manpage-renames,
2713 [ --with-manpage-renames specify manpage-renaming],
2714 [MANPAGE_RENAMES=$withval],
2715 [MANPAGE_RENAMES=yes])
2717 case ".$MANPAGE_RENAMES" in #(vi
2721 # Debian 'man' program?
2722 if test -f /etc/debian_version ; then
2723 MANPAGE_RENAMES=`cd $srcdir && pwd`/man/man_db.renames
2730 if test "$MANPAGE_RENAMES" != no ; then
2731 if test -f $srcdir/man/$MANPAGE_RENAMES ; then
2732 MANPAGE_RENAMES=`cd $srcdir/man && pwd`/$MANPAGE_RENAMES
2733 elif test ! -f $MANPAGE_RENAMES ; then
2734 AC_MSG_ERROR(not a filename: $MANPAGE_RENAMES)
2737 test ! -d man && mkdir man
2739 # Construct a sed-script to perform renaming within man-pages
2740 if test -n "$MANPAGE_RENAMES" ; then
2741 test ! -d man && mkdir man
2742 sh $srcdir/man/make_sed.sh $MANPAGE_RENAMES >./edit_man.sed
2746 AC_MSG_RESULT($MANPAGE_RENAMES)
2747 AC_SUBST(MANPAGE_RENAMES)
2749 dnl ---------------------------------------------------------------------------
2750 dnl CF_MANPAGE_SYMLINKS version: 4 updated: 2003/12/13 18:01:58
2751 dnl -------------------
2752 dnl Some people expect each tool to make all aliases for manpages in the
2753 dnl man-directory. This accommodates the older, less-capable implementations
2754 dnl of 'man', and is optional.
2755 AC_DEFUN([CF_MANPAGE_SYMLINKS],
2757 AC_MSG_CHECKING(if manpage aliases will be installed)
2759 AC_ARG_WITH(manpage-aliases,
2760 [ --with-manpage-aliases specify manpage-aliases using .so],
2761 [MANPAGE_ALIASES=$withval],
2762 [MANPAGE_ALIASES=yes])
2764 AC_MSG_RESULT($MANPAGE_ALIASES)
2766 if test "$LN_S" = "ln -s"; then
2773 if test "$MANPAGE_ALIASES" = yes ; then
2774 AC_MSG_CHECKING(if manpage symlinks should be used)
2776 AC_ARG_WITH(manpage-symlinks,
2777 [ --with-manpage-symlinks specify manpage-aliases using symlinks],
2778 [MANPAGE_SYMLINKS=$withval],
2779 [MANPAGE_SYMLINKS=$cf_use_symlinks])
2781 if test "$$cf_use_symlinks" = no; then
2782 if test "$MANPAGE_SYMLINKS" = yes ; then
2783 AC_MSG_WARN(cannot make symlinks, will use .so files)
2788 AC_MSG_RESULT($MANPAGE_SYMLINKS)
2792 dnl ---------------------------------------------------------------------------
2793 dnl CF_MANPAGE_TBL version: 3 updated: 2002/01/19 22:51:32
2795 dnl This option causes manpages to be run through tbl(1) to generate tables
2797 AC_DEFUN([CF_MANPAGE_TBL],
2799 AC_MSG_CHECKING(for manpage tbl)
2801 AC_ARG_WITH(manpage-tbl,
2802 [ --with-manpage-tbl specify manpage processing with tbl],
2803 [MANPAGE_TBL=$withval],
2806 AC_MSG_RESULT($MANPAGE_TBL)
2808 dnl ---------------------------------------------------------------------------
2809 dnl CF_MAN_PAGES version: 35 updated: 2007/03/31 11:47:29
2811 dnl Try to determine if the man-pages on the system are compressed, and if
2812 dnl so, what format is used. Use this information to construct a script that
2813 dnl will install man-pages.
2814 AC_DEFUN([CF_MAN_PAGES],
2816 CF_HELP_MESSAGE(Options to Specify How Manpages are Installed:)
2822 if test "$prefix" = "NONE" ; then
2823 cf_prefix="$ac_default_prefix"
2828 case "$MANPAGE_FORMAT" in # (vi
2843 test ! -d man && mkdir man
2847 case "$MANPAGE_FORMAT" in #(vi
2850 cf_compress=compress
2858 cf_edit_man=./edit_man.sh
2859 cf_man_alias=`pwd`/man_alias.sed
2861 cat >$cf_edit_man <<CF_EOF
2863 # this script is generated by the configure-script CF_MAN_PAGES macro.
2868 NCURSES_MAJOR="$NCURSES_MAJOR"
2869 NCURSES_MINOR="$NCURSES_MINOR"
2870 NCURSES_PATCH="$NCURSES_PATCH"
2872 NCURSES_OSPEED="$NCURSES_OSPEED"
2873 TERMINFO="$TERMINFO"
2875 MKDIRS="sh `cd $srcdir && pwd`/mkdirs.sh"
2878 INSTALL_DATA="$INSTALL_DATA"
2880 transform="$program_transform_name"
2882 TMP=\${TMPDIR-/tmp}/man\$\$
2883 trap "rm -f \$TMP" 0 1 2 5 15
2895 top_srcdir=\[$]srcdir/..
2898 if test "\$form" = normal ; then
2899 if test "$cf_format" = yes ; then
2900 if test "$cf_inboth" = no ; then
2901 sh \[$]0 format \$verb \$mandir \$srcdir \[$]*
2905 cf_subdir=\$mandir/man
2906 cf_tables=$MANPAGE_TBL
2908 cf_subdir=\$mandir/cat
2912 # process the list of source-files
2915 *.orig|*.rej) ;; #(vi
2917 section=\`expr "\$i" : '.*\\.\\([[0-9]]\\)[[xm]]*'\`;
2918 if test \$verb = installing ; then
2919 if test ! -d \$cf_subdir\${section} ; then
2920 \$MKDIRS \$cf_subdir\$section
2924 # replace variables in man page
2925 if test ! -f $cf_man_alias ; then
2926 cat >>$cf_man_alias <<-CF_EOF2
2927 s,@DATADIR@,\$datadir,g
2928 s,@TERMINFO@,\$TERMINFO,g
2929 s,@NCURSES_MAJOR@,\$NCURSES_MAJOR,g
2930 s,@NCURSES_MINOR@,\$NCURSES_MINOR,g
2931 s,@NCURSES_PATCH@,\$NCURSES_PATCH,g
2932 s,@NCURSES_OSPEED@,\$NCURSES_OSPEED,g
2937 cf_NAME=`echo "$cf_name" | sed y%abcdefghijklmnopqrstuvwxyz./-%ABCDEFGHIJKLMNOPQRSTUVWXYZ___%`
2938 cf_name=`echo $cf_name|sed "$program_transform_name"`
2939 cat >>$cf_edit_man <<-CF_EOF
2940 s,@$cf_NAME@,$cf_name,
2944 cat >>$cf_edit_man <<CF_EOF
2946 echo "...made $cf_man_alias"
2950 cf_source=\`basename \$i\`
2952 test ! -f \$inalias && inalias="\$srcdir/\$inalias"
2953 if test ! -f \$inalias ; then
2954 echo .. skipped \$cf_source
2959 if test "$MANPAGE_ALIASES" != no ; then
2960 cat >>$cf_edit_man <<CF_EOF
2961 aliases=\`sed -f \$top_srcdir/man/manlinks.sed \$inalias |sed -f $cf_man_alias | sort -u\`
2965 if test "$MANPAGE_RENAMES" = no ; then
2966 cat >>$cf_edit_man <<CF_EOF
2967 # perform program transformations for section 1 man pages
2968 if test \$section = 1 ; then
2969 cf_target=\$cf_subdir\${section}/\`echo \$cf_source|sed "\${transform}"\`
2971 cf_target=\$cf_subdir\${section}/\$cf_source
2975 cat >>$cf_edit_man <<CF_EOF
2976 cf_target=\`grep "^\$cf_source" $MANPAGE_RENAMES | $AWK '{print \[$]2}'\`
2977 if test -z "\$cf_target" ; then
2978 echo '? missing rename for '\$cf_source
2979 cf_target="\$cf_source"
2981 cf_target="\$cf_subdir\${section}/\${cf_target}"
2986 cat >>$cf_edit_man <<CF_EOF
2987 sed -f $cf_man_alias \\
2990 if test -f $MANPAGE_RENAMES ; then
2991 cat >>$cf_edit_man <<CF_EOF
2992 < \$i | sed -f `pwd`/edit_man.sed >\$TMP
2995 cat >>$cf_edit_man <<CF_EOF
3000 cat >>$cf_edit_man <<CF_EOF
3001 if test \$cf_tables = yes ; then
3002 tbl \$TMP >\$TMP.out
3007 if test $with_curses_h != yes ; then
3008 cat >>$cf_edit_man <<CF_EOF
3009 sed -e "/\#[ ]*include/s,curses.h,ncurses.h," < \$TMP >\$TMP.out
3014 cat >>$cf_edit_man <<CF_EOF
3015 if test \$form = format ; then
3016 nroff -man \$TMP >\$TMP.out
3021 if test -n "$cf_compress" ; then
3022 cat >>$cf_edit_man <<CF_EOF
3023 if test \$verb = installing ; then
3024 if ( $cf_compress -f \$TMP )
3026 mv \$TMP.$cf_so_strip \$TMP
3029 cf_target="\$cf_target.$cf_so_strip"
3033 case "$MANPAGE_FORMAT" in #(vi
3035 cat >>$cf_edit_man <<CF_EOF
3036 if test \$form = format ; then
3037 # BSDI installs only .0 suffixes in the cat directories
3038 cf_target="\`echo \$cf_target|sed -e 's/\.[[1-9]]\+[[a-z]]*/.0/'\`"
3044 cat >>$cf_edit_man <<CF_EOF
3045 suffix=\`basename \$cf_target | sed -e 's%^[[^.]]*%%'\`
3046 if test \$verb = installing ; then
3047 echo \$verb \$cf_target
3048 \$INSTALL_DATA \$TMP \$cf_target
3049 test -d \$cf_subdir\${section} &&
3050 test -n "\$aliases" && (
3051 cd \$cf_subdir\${section} && (
3052 cf_source=\`echo \$cf_target |sed -e 's%^.*/\([[^/]][[^/]]*/[[^/]][[^/]]*$\)%\1%'\`
3053 test -n "$cf_so_strip" && cf_source=\`echo \$cf_source |sed -e 's%\.$cf_so_strip\$%%'\`
3054 cf_target=\`basename \$cf_target\`
3055 for cf_alias in \$aliases
3057 if test \$section = 1 ; then
3058 cf_alias=\`echo \$cf_alias|sed "\${transform}"\`
3061 if test "$MANPAGE_SYMLINKS" = yes ; then
3062 if test -f \$cf_alias\${suffix} ; then
3063 if ( cmp -s \$cf_target \$cf_alias\${suffix} )
3068 echo .. \$verb alias \$cf_alias\${suffix}
3069 rm -f \$cf_alias\${suffix}
3070 $LN_S \$cf_target \$cf_alias\${suffix}
3071 elif test "\$cf_target" != "\$cf_alias\${suffix}" ; then
3072 echo ".so \$cf_source" >\$TMP
3074 if test -n "$cf_compress" ; then
3075 cat >>$cf_edit_man <<CF_EOF
3076 if test -n "$cf_so_strip" ; then
3077 $cf_compress -f \$TMP
3078 mv \$TMP.$cf_so_strip \$TMP
3082 cat >>$cf_edit_man <<CF_EOF
3083 echo .. \$verb alias \$cf_alias\${suffix}
3084 rm -f \$cf_alias\${suffix}
3085 \$INSTALL_DATA \$TMP \$cf_alias\${suffix}
3090 elif test \$verb = removing ; then
3091 test -f \$cf_target && (
3092 echo \$verb \$cf_target
3095 test -d \$cf_subdir\${section} &&
3096 test -n "\$aliases" && (
3097 cd \$cf_subdir\${section} && (
3098 for cf_alias in \$aliases
3100 if test \$section = 1 ; then
3101 cf_alias=\`echo \$cf_alias|sed "\${transform}"\`
3104 echo .. \$verb alias \$cf_alias\${suffix}
3105 rm -f \$cf_alias\${suffix}
3117 if test $cf_inboth = yes ; then
3118 if test \$form != format ; then
3119 sh \[$]0 format \$verb \$mandir \$srcdir \[$]*
3125 chmod 755 $cf_edit_man
3128 dnl ---------------------------------------------------------------------------
3129 dnl CF_MATH_LIB version: 5 updated: 2000/05/28 01:39:10
3131 dnl Checks for libraries. At least one UNIX system, Apple Macintosh
3132 dnl Rhapsody 5.5, does not have -lm. We cannot use the simpler
3133 dnl AC_CHECK_LIB(m,sin), because that fails for C++.
3134 AC_DEFUN([CF_MATH_LIB],
3136 AC_CACHE_CHECK(if -lm needed for math functions,
3142 [double x = rand(); printf("result = %g\n", ]ifelse($2,,sin(x),$2)[)],
3143 [cf_cv_need_libm=no],
3144 [cf_cv_need_libm=yes])])
3145 if test "$cf_cv_need_libm" = yes
3152 dnl ---------------------------------------------------------------------------
3153 dnl CF_MIXEDCASE_FILENAMES version: 3 updated: 2003/09/20 17:07:55
3154 dnl ----------------------
3155 dnl Check if the file-system supports mixed-case filenames. If we're able to
3156 dnl create a lowercase name and see it as uppercase, it doesn't support that.
3157 AC_DEFUN([CF_MIXEDCASE_FILENAMES],
3159 AC_CACHE_CHECK(if filesystem supports mixed-case filenames,cf_cv_mixedcase,[
3160 if test "$cross_compiling" = yes ; then
3161 case $target_alias in #(vi
3162 *-os2-emx*|*-msdosdjgpp*|*-cygwin*|*-mingw32*|*-uwin*) #(vi
3170 rm -f conftest CONFTEST
3172 if test -f CONFTEST ; then
3177 rm -f conftest CONFTEST
3180 test "$cf_cv_mixedcase" = yes && AC_DEFINE(MIXEDCASE_FILENAMES)
3182 dnl ---------------------------------------------------------------------------
3183 dnl CF_MKSTEMP version: 5 updated: 2006/12/16 12:33:30
3185 dnl Check for a working mkstemp. This creates two files, checks that they are
3186 dnl successfully created and distinct (AmigaOS apparently fails on the last).
3187 AC_DEFUN([CF_MKSTEMP],[
3188 AC_CACHE_CHECK(for working mkstemp, cf_cv_func_mkstemp,[
3191 #include <sys/types.h>
3195 #include <sys/stat.h>
3198 char *tmpl = "conftestXXXXXX";
3206 for (n = 0; n < 2; ++n) {
3207 strcpy(name[n], tmpl);
3208 if ((fd = mkstemp(name[n])) >= 0) {
3209 if (!strcmp(name[n], tmpl)
3210 || stat(name[n], &sb) != 0
3211 || (sb.st_mode & S_IFMT) != S_IFREG
3212 || (sb.st_mode & 077) != 0) {
3219 && !strcmp(name[0], name[1]))
3221 ${cf_cv_main_return:-return}(result);
3223 ],[cf_cv_func_mkstemp=yes
3224 ],[cf_cv_func_mkstemp=no
3225 ],[AC_CHECK_FUNC(mkstemp)
3228 if test "$cf_cv_func_mkstemp" = yes ; then
3229 AC_DEFINE(HAVE_MKSTEMP)
3232 dnl ---------------------------------------------------------------------------
3233 dnl CF_MSG_LOG version: 3 updated: 1997/09/07 14:05:52
3235 dnl Write a debug message to config.log, along with the line number in the
3236 dnl configure script.
3237 AC_DEFUN([CF_MSG_LOG],[
3238 echo "(line __oline__) testing $* ..." 1>&AC_FD_CC
3240 dnl ---------------------------------------------------------------------------
3241 dnl CF_NCURSES_ABI_6 version: 1 updated: 2005/09/17 18:42:49
3242 dnl ----------------
3243 dnl Set ncurses' ABI to 6 unless overridden by explicit configure option, and
3244 dnl warn about this.
3245 AC_DEFUN([CF_NCURSES_ABI_6],[
3246 if test "${with_abi_version+set}" != set; then
3247 case $cf_cv_rel_version in
3249 cf_cv_rel_version=6.0
3251 AC_MSG_WARN(Overriding ABI version to $cf_cv_abi_version)
3256 dnl ---------------------------------------------------------------------------
3257 dnl CF_NO_LEAKS_OPTION version: 4 updated: 2006/12/16 14:24:05
3258 dnl ------------------
3259 dnl see CF_WITH_NO_LEAKS
3260 AC_DEFUN([CF_NO_LEAKS_OPTION],[
3261 AC_MSG_CHECKING(if you want to use $1 for testing)
3264 [AC_DEFINE($3)ifelse([$4],,[
3267 : ${with_cflags:=-g}
3268 : ${with_no_leaks:=yes}
3271 AC_MSG_RESULT(${with_$1:-no})
3273 case .$with_cflags in #(vi
3275 case .$CFLAGS in #(vi
3285 dnl ---------------------------------------------------------------------------
3286 dnl CF_NUMBER_SYNTAX version: 1 updated: 2003/09/20 18:12:49
3287 dnl ----------------
3288 dnl Check if the given variable is a number. If not, report an error.
3289 dnl $1 is the variable
3290 dnl $2 is the message
3291 AC_DEFUN([CF_NUMBER_SYNTAX],[
3292 if test -n "$1" ; then
3297 AC_MSG_ERROR($2 is not a number: $1)
3301 AC_MSG_ERROR($2 value is empty)
3304 dnl ---------------------------------------------------------------------------
3305 dnl CF_OBJ_SUBDIR version: 4 updated: 2002/02/23 20:38:31
3307 dnl Compute the object-directory name from the given model name
3308 AC_DEFUN([CF_OBJ_SUBDIR],
3311 libtool) $2='obj_lo' ;;
3312 normal) $2='objects' ;;
3313 debug) $2='obj_g' ;;
3314 profile) $2='obj_p' ;;
3316 case $cf_cv_system_name in #(vi
3324 dnl ---------------------------------------------------------------------------
3325 dnl CF_PATHSEP version: 3 updated: 2001/01/12 01:23:53
3327 dnl Provide a value for the $PATH and similar separator
3328 AC_DEFUN([CF_PATHSEP],
3330 case $cf_cv_system_name in
3331 os2*) PATHSEP=';' ;;
3334 ifelse($1,,,[$1=$PATHSEP])
3337 dnl ---------------------------------------------------------------------------
3338 dnl CF_PATH_SYNTAX version: 11 updated: 2006/09/02 08:55:46
3340 dnl Check the argument to see that it looks like a pathname. Rewrite it if it
3341 dnl begins with one of the prefix/exec_prefix variables, and then again if the
3342 dnl result begins with 'NONE'. This is necessary to work around autoconf's
3343 dnl delayed evaluation of those symbols.
3344 AC_DEFUN([CF_PATH_SYNTAX],[
3345 if test "x$prefix" != xNONE; then
3346 cf_path_syntax="$prefix"
3348 cf_path_syntax="$ac_default_prefix"
3351 case ".[$]$1" in #(vi
3352 .\[$]\(*\)*|.\'*\'*) #(vi
3356 .[[a-zA-Z]]:[[\\/]]*) #(vi OS/2 EMX
3358 .\[$]{*prefix}*) #(vi
3360 case ".[$]$1" in #(vi
3362 $1=`echo [$]$1 | sed -e s%NONE%$cf_path_syntax%`
3367 $1=`echo [$]$1 | sed -e s%NONE%$cf_path_syntax%`
3370 ifelse($2,,[AC_ERROR([expected a pathname, not \"[$]$1\"])],$2)
3374 dnl ---------------------------------------------------------------------------
3375 dnl CF_POSIX_C_SOURCE version: 6 updated: 2005/07/14 20:25:10
3376 dnl -----------------
3377 dnl Define _POSIX_C_SOURCE to the given level, and _POSIX_SOURCE if needed.
3379 dnl POSIX.1-1990 _POSIX_SOURCE
3380 dnl POSIX.1-1990 and _POSIX_SOURCE and
3381 dnl POSIX.2-1992 C-Language _POSIX_C_SOURCE=2
3383 dnl POSIX.1b-1993 _POSIX_C_SOURCE=199309L
3384 dnl POSIX.1c-1996 _POSIX_C_SOURCE=199506L
3385 dnl X/Open 2000 _POSIX_C_SOURCE=200112L
3388 dnl $1 is the nominal value for _POSIX_C_SOURCE
3389 AC_DEFUN([CF_POSIX_C_SOURCE],
3391 cf_POSIX_C_SOURCE=ifelse($1,,199506L,$1)
3393 cf_save_CFLAGS="$CFLAGS"
3394 cf_save_CPPFLAGS="$CPPFLAGS"
3396 CF_REMOVE_DEFINE(cf_trim_CFLAGS,$cf_save_CFLAGS,_POSIX_C_SOURCE)
3397 CF_REMOVE_DEFINE(cf_trim_CPPFLAGS,$cf_save_CPPFLAGS,_POSIX_C_SOURCE)
3399 AC_CACHE_CHECK(if we should define _POSIX_C_SOURCE,cf_cv_posix_c_source,[
3400 CF_MSG_LOG(if the symbol is already defined go no further)
3401 AC_TRY_COMPILE([#include <sys/types.h>],[
3402 #ifndef _POSIX_C_SOURCE
3405 [cf_cv_posix_c_source=no],
3406 [cf_want_posix_source=no
3407 case .$cf_POSIX_C_SOURCE in #(vi
3409 cf_cv_posix_c_source="-D_POSIX_C_SOURCE=$cf_POSIX_C_SOURCE"
3412 cf_cv_posix_c_source="-D_POSIX_C_SOURCE=$cf_POSIX_C_SOURCE"
3413 cf_want_posix_source=yes
3416 cf_want_posix_source=yes
3419 if test "$cf_want_posix_source" = yes ; then
3420 AC_TRY_COMPILE([#include <sys/types.h>],[
3421 #ifdef _POSIX_SOURCE
3424 cf_cv_posix_c_source="$cf_cv_posix_c_source -D_POSIX_SOURCE")
3426 CF_MSG_LOG(ifdef from value $cf_POSIX_C_SOURCE)
3427 CFLAGS="$cf_trim_CFLAGS"
3428 CPPFLAGS="$cf_trim_CPPFLAGS $cf_cv_posix_c_source"
3429 CF_MSG_LOG(if the second compile does not leave our definition intact error)
3430 AC_TRY_COMPILE([#include <sys/types.h>],[
3431 #ifndef _POSIX_C_SOURCE
3434 [cf_cv_posix_c_source=no])
3435 CFLAGS="$cf_save_CFLAGS"
3436 CPPFLAGS="$cf_save_CPPFLAGS"
3440 if test "$cf_cv_posix_c_source" != no ; then
3441 CFLAGS="$cf_trim_CFLAGS"
3442 CPPFLAGS="$cf_trim_CPPFLAGS"
3443 if test "$cf_cv_cc_u_d_options" = yes ; then
3444 cf_temp_posix_c_source=`echo "$cf_cv_posix_c_source" | \
3445 sed -e 's/-D/-U/g' -e 's/=[[^ ]]*//g'`
3446 CPPFLAGS="$CPPFLAGS $cf_temp_posix_c_source"
3448 CPPFLAGS="$CPPFLAGS $cf_cv_posix_c_source"
3452 dnl ---------------------------------------------------------------------------
3453 dnl CF_PREDEFINE version: 1 updated: 2003/07/26 17:53:56
3455 dnl Add definitions to CPPFLAGS to ensure they're predefined for all compiles.
3457 dnl $1 = symbol to test
3458 dnl $2 = value (if any) to use for a predefinition
3459 AC_DEFUN([CF_PREDEFINE],
3461 AC_MSG_CHECKING(if we must define $1)
3462 AC_TRY_COMPILE([#include <sys/types.h>
3466 #endif],[cf_result=no],[cf_result=yes])
3467 AC_MSG_RESULT($cf_result)
3469 if test "$cf_result" = yes ; then
3470 CPPFLAGS="$CPPFLAGS ifelse($2,,-D$1,[-D$1=$2])"
3471 elif test "x$2" != "x" ; then
3472 AC_MSG_CHECKING(checking for compatible value versus $2)
3473 AC_TRY_COMPILE([#include <sys/types.h>
3477 #endif],[cf_result=yes],[cf_result=no])
3478 AC_MSG_RESULT($cf_result)
3479 if test "$cf_result" = no ; then
3480 # perhaps we can override it - try...
3481 CPPFLAGS="$CPPFLAGS -D$1=$2"
3485 dnl ---------------------------------------------------------------------------
3486 dnl CF_PRG_RULES version: 1 updated: 2006/06/03 11:45:08
3488 dnl Append definitions and rules for the given programs to the subdirectory
3489 dnl Makefiles, and the recursion rule for the top-level Makefile.
3492 dnl $1 = script to run
3493 dnl $2 = list of subdirectories
3497 AC_DEFUN([CF_PRG_RULES],
3501 if test ! -d $srcdir/$cf_dir; then
3503 elif test -f $srcdir/$cf_dir/programs; then
3504 $AWK -f $1 $srcdir/$cf_dir/programs >>$cf_dir/Makefile
3509 dnl ---------------------------------------------------------------------------
3510 dnl CF_PROG_AWK version: 1 updated: 2006/09/16 11:40:59
3512 dnl Check for awk, ensure that the check found something.
3513 AC_DEFUN([CF_PROG_AWK],
3516 test -z "$AWK" && AC_MSG_ERROR(No awk program found)
3518 dnl ---------------------------------------------------------------------------
3519 dnl CF_PROG_CC_C_O version: 2 updated: 2006/12/16 15:55:46
3521 dnl Analogous to AC_PROG_CC_C_O, but more useful: tests only $CC, ensures that
3522 dnl the output file can be renamed, and allows for a shell variable that can
3523 dnl be used later. The parameter is either CC or CXX. The result is the
3525 dnl $cf_cv_prog_CC_c_o
3526 dnl $cf_cv_prog_CXX_c_o
3527 AC_DEFUN([CF_PROG_CC_C_O],
3528 [AC_REQUIRE([AC_PROG_CC])dnl
3529 AC_MSG_CHECKING([whether [$]$1 understands -c and -o together])
3530 AC_CACHE_VAL(cf_cv_prog_$1_c_o,
3532 cat > conftest.$ac_ext <<CF_EOF
3536 ${cf_cv_main_return:-return}(0);
3539 # We do the test twice because some compilers refuse to overwrite an
3540 # existing .o file with -o, though they will create one.
3541 ac_try='[$]$1 -c conftest.$ac_ext -o conftest2.$ac_objext >&AC_FD_CC'
3542 if AC_TRY_EVAL(ac_try) &&
3543 test -f conftest2.$ac_objext && AC_TRY_EVAL(ac_try);
3545 eval cf_cv_prog_$1_c_o=yes
3547 eval cf_cv_prog_$1_c_o=no
3551 if test $cf_cv_prog_$1_c_o = yes; then
3552 AC_MSG_RESULT([yes])
3557 dnl ---------------------------------------------------------------------------
3558 dnl CF_PROG_CC_U_D version: 1 updated: 2005/07/14 16:59:30
3560 dnl Check if C (preprocessor) -U and -D options are processed in the order
3561 dnl given rather than by type of option. Some compilers insist on apply all
3562 dnl of the -U options after all of the -D options. Others allow mixing them,
3563 dnl and may predefine symbols that conflict with those we define.
3564 AC_DEFUN([CF_PROG_CC_U_D],
3566 AC_CACHE_CHECK(if $CC -U and -D options work together,cf_cv_cc_u_d_options,[
3567 cf_save_CPPFLAGS="$CPPFLAGS"
3568 CPPFLAGS="-UU_D_OPTIONS -DU_D_OPTIONS -DD_U_OPTIONS -UD_U_OPTIONS"
3571 make an undefined-error
3574 make a defined-error
3577 cf_cv_cc_u_d_options=yes],[
3578 cf_cv_cc_u_d_options=no])
3579 CPPFLAGS="$cf_save_CPPFLAGS"
3582 dnl ---------------------------------------------------------------------------
3583 dnl CF_PROG_EGREP version: 1 updated: 2006/09/16 11:40:59
3585 dnl AC_PROG_EGREP was introduced in autoconf 2.53.
3586 dnl This macro adds a check to ensure the script found something.
3587 AC_DEFUN([CF_PROG_EGREP],
3588 [AC_CACHE_CHECK([for egrep], [ac_cv_prog_egrep],
3589 [if echo a | (grep -E '(a|b)') >/dev/null 2>&1
3590 then ac_cv_prog_egrep='grep -E'
3591 else ac_cv_prog_egrep='egrep'
3593 EGREP=$ac_cv_prog_egrep
3595 test -z "$EGREP" && AC_MSG_ERROR(No egrep program found)
3597 dnl ---------------------------------------------------------------------------
3598 dnl CF_PROG_EXT version: 10 updated: 2004/01/03 19:28:18
3600 dnl Compute $PROG_EXT, used for non-Unix ports, such as OS/2 EMX.
3601 AC_DEFUN([CF_PROG_EXT],
3603 AC_REQUIRE([CF_CHECK_CACHE])
3604 case $cf_cv_system_name in
3606 CFLAGS="$CFLAGS -Zmt"
3607 CPPFLAGS="$CPPFLAGS -D__ST_MT_ERRNO__"
3608 CXXFLAGS="$CXXFLAGS -Zmt"
3609 # autoconf's macro sets -Zexe and suffix both, which conflict:w
3610 LDFLAGS="$LDFLAGS -Zmt -Zcrtdll"
3620 test -n "$PROG_EXT" && AC_DEFINE_UNQUOTED(PROG_EXT,"$PROG_EXT")
3622 dnl ---------------------------------------------------------------------------
3623 dnl CF_PROG_INSTALL version: 5 updated: 2002/12/21 22:46:07
3625 dnl Force $INSTALL to be an absolute-path. Otherwise, edit_man.sh and the
3626 dnl misc/tabset install won't work properly. Usually this happens only when
3627 dnl using the fallback mkinstalldirs script
3628 AC_DEFUN([CF_PROG_INSTALL],
3634 CF_DIRNAME(cf_dir,$INSTALL)
3635 test -z "$cf_dir" && cf_dir=.
3636 INSTALL=`cd $cf_dir && pwd`/`echo $INSTALL | sed -e 's%^.*/%%'`
3640 dnl ---------------------------------------------------------------------------
3641 dnl CF_PROG_LDCONFIG version: 1 updated: 2003/09/20 17:07:55
3642 dnl ----------------
3643 dnl Check for ldconfig, needed to fixup shared libraries that would be built
3644 dnl and then used in the install.
3645 AC_DEFUN([CF_PROG_LDCONFIG],[
3646 if test "$cross_compiling" = yes ; then
3649 case "$cf_cv_system_name" in #(vi
3651 test -z "$LDCONFIG" && LDCONFIG="/sbin/ldconfig -R"
3653 *) LDPATH=$PATH:/sbin:/usr/sbin
3654 AC_PATH_PROG(LDCONFIG,ldconfig,,$LDPATH)
3660 dnl ---------------------------------------------------------------------------
3661 dnl CF_PROG_LINT version: 1 updated: 2006/09/16 11:40:59
3663 AC_DEFUN([CF_PROG_LINT],
3665 AC_CHECK_PROGS(LINT, tdlint lint alint)
3668 dnl ---------------------------------------------------------------------------
3669 dnl CF_REGEX version: 3 updated: 1997/11/01 14:26:01
3671 dnl Attempt to determine if we've got one of the flavors of regular-expression
3672 dnl code that we can support.
3673 AC_DEFUN([CF_REGEX],
3675 AC_MSG_CHECKING([for regular-expression headers])
3676 AC_CACHE_VAL(cf_cv_regex,[
3677 AC_TRY_LINK([#include <sys/types.h>
3678 #include <regex.h>],[
3680 int x = regcomp(p, "", 0);
3681 int y = regexec(p, "", 0, 0, 0);
3683 ],[cf_cv_regex="regex.h"],[
3684 AC_TRY_LINK([#include <regexp.h>],[
3685 char *p = compile("", "", "", 0);
3686 int x = step("", "");
3687 ],[cf_cv_regex="regexp.h"],[
3688 cf_save_LIBS="$LIBS"
3690 AC_TRY_LINK([#include <regexpr.h>],[
3691 char *p = compile("", "", "");
3692 int x = step("", "");
3693 ],[cf_cv_regex="regexpr.h"],[LIBS="$cf_save_LIBS"])])])
3695 AC_MSG_RESULT($cf_cv_regex)
3696 case $cf_cv_regex in
3697 regex.h) AC_DEFINE(HAVE_REGEX_H_FUNCS) ;;
3698 regexp.h) AC_DEFINE(HAVE_REGEXP_H_FUNCS) ;;
3699 regexpr.h) AC_DEFINE(HAVE_REGEXPR_H_FUNCS) ;;
3702 dnl ---------------------------------------------------------------------------
3703 dnl CF_REMOVE_DEFINE version: 2 updated: 2005/07/09 16:12:18
3704 dnl ----------------
3705 dnl Remove all -U and -D options that refer to the given symbol from a list
3706 dnl of C compiler options. This works around the problem that not all
3707 dnl compilers process -U and -D options from left-to-right, so a -U option
3708 dnl cannot be used to cancel the effect of a preceding -D option.
3710 dnl $1 = target (which could be the same as the source variable)
3711 dnl $2 = source (including '$')
3712 dnl $3 = symbol to remove
3713 define([CF_REMOVE_DEFINE],
3715 # remove $3 symbol from $2
3717 sed -e 's/-[[UD]]$3\(=[[^ ]]*\)\?[[ ]]/ /g' \
3718 -e 's/-[[UD]]$3\(=[[^ ]]*\)\?[$]//g'`
3720 dnl ---------------------------------------------------------------------------
3721 dnl CF_REMOVE_LIB version: 1 updated: 2007/02/17 14:11:52
3723 dnl Remove the given library from the symbol
3725 dnl $1 = target (which could be the same as the source variable)
3726 dnl $2 = source (including '$')
3727 dnl $3 = library to remove
3728 define([CF_REMOVE_LIB],
3730 # remove $3 library from $2
3731 $1=`echo "$2" | sed -e 's/-l$3[[ ]]//g' -e 's/-l$3[$]//'`
3733 dnl ---------------------------------------------------------------------------
3734 dnl CF_SHARED_OPTS version: 46 updated: 2007/02/24 18:58:09
3737 dnl Attempt to determine the appropriate CC/LD options for creating a shared
3740 dnl Note: ${LOCAL_LDFLAGS} is used to link executables that will run within the
3741 dnl build-tree, i.e., by making use of the libraries that are compiled in ../lib
3742 dnl We avoid compiling-in a ../lib path for the shared library since that can
3743 dnl lead to unexpected results at runtime.
3744 dnl ${LOCAL_LDFLAGS2} has the same intention but assumes that the shared libraries
3745 dnl are compiled in ../../lib
3747 dnl The variable 'cf_cv_do_symlinks' is used to control whether we configure
3748 dnl to install symbolic links to the rel/abi versions of shared libraries.
3750 dnl The variable 'cf_cv_shlib_version' controls whether we use the rel or abi
3751 dnl version when making symbolic links.
3753 dnl The variable 'cf_cv_shlib_version_infix' controls whether shared library
3754 dnl version numbers are infix (ex: libncurses.<ver>.dylib) or postfix
3755 dnl (ex: libncurses.so.<ver>).
3757 dnl Some loaders leave 'so_locations' lying around. It's nice to clean up.
3758 AC_DEFUN([CF_SHARED_OPTS],
3760 AC_REQUIRE([CF_SUBST_NCURSES_VERSION])
3764 INSTALL_LIB="-m 644"
3766 cf_cv_do_symlinks=no
3768 AC_MSG_CHECKING(if release/abi version should be used for shared libs)
3769 AC_ARG_WITH(shlib-version,
3770 [ --with-shlib-version=X Specify rel or abi version for shared libs],
3771 [test -z "$withval" && withval=auto
3772 case $withval in #(vi
3774 cf_cv_shlib_version=auto
3776 rel|abi|auto|no) #(vi
3777 cf_cv_shlib_version=$withval
3780 AC_ERROR([option value must be one of: rel, abi, auto or no])
3783 ],[cf_cv_shlib_version=auto])
3784 AC_MSG_RESULT($cf_cv_shlib_version)
3788 # Some less-capable ports of gcc support only -fpic
3790 if test "$GCC" = yes
3792 AC_MSG_CHECKING(which $CC option to use)
3793 cf_save_CFLAGS="$CFLAGS"
3794 for CC_SHARED_OPTS in -fPIC -fpic ''
3796 CFLAGS="$cf_save_CFLAGS $CC_SHARED_OPTS"
3797 AC_TRY_COMPILE([#include <stdio.h>],[int x = 1],[break],[])
3799 AC_MSG_RESULT($CC_SHARED_OPTS)
3800 CFLAGS="$cf_save_CFLAGS"
3803 cf_cv_shlib_version_infix=no
3805 case $cf_cv_system_name in
3807 MK_SHARED_LIB='${CC} ${CFLAGS} -o $[@] -Xlinker -soname=`basename $[@]` -nostart -e 0'
3811 MK_SHARED_LIB='sh ../mk_shared_lib.sh [$]@ [$]{CC} [$]{CFLAGS}'
3812 cf_cv_shlib_version=cygdll
3813 cf_cv_shlib_version_infix=cygdll
3814 cat >mk_shared_lib.sh <<-CF_EOF
3817 IMPORT_LIB=\`echo "\[$]1" | sed -e 's/cyg/lib/' -e 's/[[0-9]]*\.dll[$]/.dll.a/'\`
3820 Linking shared library
3821 ** SHARED_LIB \[$]SHARED_LIB
3822 ** IMPORT_LIB \[$]IMPORT_LIB
3824 exec \[$]* -shared -Wl,--out-implib=../lib/\[$]{IMPORT_LIB} -Wl,--export-all-symbols -o ../lib/\[$]{SHARED_LIB}
3826 chmod +x mk_shared_lib.sh
3829 EXTRA_CFLAGS="-no-cpp-precomp"
3830 CC_SHARED_OPTS="-dynamic"
3831 MK_SHARED_LIB='${CC} ${CFLAGS} -dynamiclib -install_name ${libdir}/`basename $[@]` -compatibility_version ${ABI_VERSION} -current_version ${ABI_VERSION} -o $[@]'
3832 test "$cf_cv_shlib_version" = auto && cf_cv_shlib_version=abi
3833 cf_cv_shlib_version_infix=yes
3834 AC_CACHE_CHECK([if ld -search_paths_first works], cf_cv_ldflags_search_paths_first, [
3835 cf_save_LDFLAGS=$LDFLAGS
3836 LDFLAGS="$LDFLAGS -Wl,-search_paths_first"
3837 AC_TRY_LINK(, [int i;], cf_cv_ldflags_search_paths_first=yes, cf_cv_ldflags_search_paths_first=no)
3838 LDFLAGS=$cf_save_LDFLAGS])
3839 if test $cf_cv_ldflags_search_paths_first = yes; then
3840 LDFLAGS="$LDFLAGS -Wl,-search_paths_first"
3844 # (tested with gcc 2.7.2 -- I don't have c89)
3845 if test "$GCC" = yes; then
3846 LD_SHARED_OPTS='-Xlinker +b -Xlinker ${libdir}'
3849 LD_SHARED_OPTS='-Wl,+b,${libdir}'
3851 MK_SHARED_LIB='${LD} +b ${libdir} -b -o $[@]'
3852 # HP-UX shared libraries must be executable, and should be
3853 # readonly to exploit a quirk in the memory manager.
3854 INSTALL_LIB="-m 555"
3857 if test "$cf_cv_ld_rpath" = yes ; then
3858 if test "$GCC" = yes; then
3859 cf_ld_rpath_opt="-Wl,-rpath,"
3860 EXTRA_LDFLAGS="-Wl,-rpath,\${libdir} $EXTRA_LDFLAGS"
3862 cf_ld_rpath_opt="-rpath "
3863 EXTRA_LDFLAGS="-rpath \${libdir} $EXTRA_LDFLAGS"
3866 # tested with IRIX 5.2 and 'cc'.
3867 if test "$GCC" != yes; then
3868 CC_SHARED_OPTS='-KPIC'
3870 MK_SHARED_LIB='${CC} -shared -rdata_shared -soname `basename $[@]` -o $[@]'
3871 cf_cv_rm_so_locs=yes
3873 linux*|gnu*|k*bsd*-gnu)
3874 if test "$DFT_LWR_MODEL" = "shared" ; then
3875 LOCAL_LDFLAGS="-Wl,-rpath,\$(LOCAL_LIBDIR)"
3876 LOCAL_LDFLAGS2="$LOCAL_LDFLAGS"
3878 if test "$cf_cv_ld_rpath" = yes ; then
3879 cf_ld_rpath_opt="-Wl,-rpath,"
3880 EXTRA_LDFLAGS="-Wl,-rpath,\${libdir} $EXTRA_LDFLAGS"
3883 MK_SHARED_LIB='${CC} ${CFLAGS} -shared -Wl,-soname,'$cf_shared_soname',-stats,-lc -o $[@]'
3886 CC_SHARED_OPTS="$CC_SHARED_OPTS -DPIC"
3887 MK_SHARED_LIB='${LD} -Bshareable -soname,`basename $[@].${ABI_VERSION}` -o $[@]'
3889 openbsd*|freebsd[[12]].*)
3890 CC_SHARED_OPTS="$CC_SHARED_OPTS -DPIC"
3891 MK_SHARED_LIB='${LD} -Bshareable -o $[@]'
3892 test "$cf_cv_shlib_version" = auto && cf_cv_shlib_version=rel
3895 CC_SHARED_OPTS="$CC_SHARED_OPTS -DPIC"
3896 if test "$DFT_LWR_MODEL" = "shared" && test "$cf_cv_ld_rpath" = yes ; then
3897 LOCAL_LDFLAGS="-rpath \$(LOCAL_LIBDIR)"
3898 LOCAL_LDFLAGS2="-rpath \${libdir} $LOCAL_LDFLAGS"
3899 cf_ld_rpath_opt="-rpath "
3900 EXTRA_LDFLAGS="-rpath \${libdir} $EXTRA_LDFLAGS"
3903 MK_SHARED_LIB='${LD} -Bshareable -soname=`basename $[@]` -o $[@]'
3906 CC_SHARED_OPTS="$CC_SHARED_OPTS -DPIC"
3907 test "$cf_cv_ld_rpath" = yes && cf_ld_rpath_opt="-Wl,-rpath,"
3908 if test "$DFT_LWR_MODEL" = "shared" && test "$cf_cv_ld_rpath" = yes ; then
3909 LOCAL_LDFLAGS="-Wl,-rpath,\$(LOCAL_LIBDIR)"
3910 LOCAL_LDFLAGS2="$LOCAL_LDFLAGS"
3911 EXTRA_LDFLAGS="-Wl,-rpath,\${libdir} $EXTRA_LDFLAGS"
3912 if test "$cf_cv_shlib_version" = auto; then
3913 if test -f /usr/libexec/ld.elf_so; then
3914 cf_cv_shlib_version=abi
3916 cf_cv_shlib_version=rel
3920 MK_SHARED_LIB='${CC} ${CFLAGS} -shared -Wl,-soname,'$cf_shared_soname' -o $[@]'
3922 MK_SHARED_LIB='${LD} -Bshareable -o $[@]'
3926 # tested with OSF/1 V3.2 and 'cc'
3927 # tested with OSF/1 V3.2 and gcc 2.6.3 (but the c++ demo didn't
3928 # link with shared libs).
3929 MK_SHARED_LIB='${LD} -set_version ${REL_VERSION}:${ABI_VERSION} -expect_unresolved "*" -shared -soname `basename $[@]`'
3932 MK_SHARED_LIB="${MK_SHARED_LIB} -msym"
3935 MK_SHARED_LIB="${MK_SHARED_LIB}"' -o $[@]'
3936 if test "$DFT_LWR_MODEL" = "shared" ; then
3937 LOCAL_LDFLAGS="-Wl,-rpath,\$(LOCAL_LIBDIR)"
3938 LOCAL_LDFLAGS2="$LOCAL_LDFLAGS"
3940 if test "$cf_cv_ld_rpath" = yes ; then
3941 cf_ld_rpath_opt="-rpath"
3942 # EXTRA_LDFLAGS="$LOCAL_LDFLAGS $EXTRA_LDFLAGS"
3944 cf_cv_rm_so_locs=yes
3946 sco3.2v5*) # (also uw2* and UW7) hops 13-Apr-98
3947 # tested with osr5.0.5
3948 if test "$GCC" != yes; then
3949 CC_SHARED_OPTS='-belf -KPIC'
3951 MK_SHARED_LIB='${LD} -dy -G -h `basename $[@] .${REL_VERSION}`.${ABI_VERSION} -o [$]@'
3952 if test "$cf_cv_ld_rpath" = yes ; then
3953 # only way is to set LD_RUN_PATH but no switch for it
3956 test "$cf_cv_shlib_version" = auto && cf_cv_shlib_version=rel
3957 LINK_PROGS='LD_RUN_PATH=${libdir}'
3958 LINK_TESTS='Pwd=`pwd`;LD_RUN_PATH=`dirname $${Pwd}`/lib'
3961 # tested with SunOS 4.1.1 and gcc 2.7.0
3962 if test "$GCC" != yes; then
3963 CC_SHARED_OPTS='-KPIC'
3965 MK_SHARED_LIB='${LD} -assert pure-text -o $[@]'
3966 test "$cf_cv_shlib_version" = auto && cf_cv_shlib_version=rel
3969 # tested with SunOS 5.5.1 (solaris 2.5.1) and gcc 2.7.2
3970 if test "$GCC" != yes; then
3971 CC_SHARED_OPTS='-KPIC'
3973 if test "$DFT_LWR_MODEL" = "shared" ; then
3974 LOCAL_LDFLAGS="-R \$(LOCAL_LIBDIR):\${libdir}"
3975 LOCAL_LDFLAGS2="$LOCAL_LDFLAGS"
3977 if test "$cf_cv_ld_rpath" = yes ; then
3978 cf_ld_rpath_opt="-R"
3979 EXTRA_LDFLAGS="$LOCAL_LDFLAGS $EXTRA_LDFLAGS"
3982 MK_SHARED_LIB='${CC} -dy -G -h '$cf_shared_soname' -o $[@]'
3985 # tested with UnixWare 7.1.0 (gcc 2.95.2 and cc)
3986 if test "$GCC" != yes; then
3987 CC_SHARED_OPTS='-KPIC'
3989 MK_SHARED_LIB='${LD} -d y -G -o [$]@'
3992 CC_SHARED_OPTS='unknown'
3993 MK_SHARED_LIB='echo unknown'
3997 # This works if the last tokens in $MK_SHARED_LIB are the -o target.
3998 case "$cf_cv_shlib_version" in #(vi
4000 case "$MK_SHARED_LIB" in #(vi
4002 test "$cf_cv_do_symlinks" = no && cf_cv_do_symlinks=yes
4005 AC_MSG_WARN(ignored --with-shlib-version)
4011 if test -n "$cf_ld_rpath_opt" ; then
4012 AC_MSG_CHECKING(if we need a space after rpath option)
4013 cf_save_LIBS="$LIBS"
4014 LIBS="$LIBS ${cf_ld_rpath_opt}$libdir"
4015 AC_TRY_LINK(, , cf_rpath_space=no, cf_rpath_space=yes)
4016 LIBS="$cf_save_LIBS"
4017 AC_MSG_RESULT($cf_rpath_space)
4018 test "$cf_rpath_space" = yes && cf_ld_rpath_opt="$cf_ld_rpath_opt "
4019 MK_SHARED_LIB="$MK_SHARED_LIB $cf_ld_rpath_opt\${libdir}"
4022 AC_SUBST(CC_SHARED_OPTS)
4023 AC_SUBST(LD_SHARED_OPTS)
4024 AC_SUBST(MK_SHARED_LIB)
4025 AC_SUBST(LINK_PROGS)
4026 AC_SUBST(LINK_TESTS)
4027 AC_SUBST(EXTRA_LDFLAGS)
4028 AC_SUBST(LOCAL_LDFLAGS)
4029 AC_SUBST(LOCAL_LDFLAGS2)
4030 AC_SUBST(INSTALL_LIB)
4032 dnl ---------------------------------------------------------------------------
4033 dnl CF_SHARED_SONAME version: 2 updated: 2006/10/21 12:33:41
4034 dnl ----------------
4035 dnl utility macro for CF_SHARED_OPTS, constructs "$cf_shared_soname" for
4036 dnl substitution into MK_SHARED_LIB string for the "-soname" (or similar)
4039 dnl $1 is the default that should be used for "$cf_cv_shlib_version".
4040 dnl If missing, use "rel".
4041 define([CF_SHARED_SONAME],
4043 test "$cf_cv_shlib_version" = auto && cf_cv_shlib_version=ifelse($1,,rel,$1)
4044 if test "$cf_cv_shlib_version" = rel; then
4045 cf_shared_soname='`basename $[@] .${REL_VERSION}`.${ABI_VERSION}'
4047 cf_shared_soname='`basename $[@]`'
4050 dnl ---------------------------------------------------------------------------
4051 dnl CF_SIGWINCH version: 1 updated: 2006/04/02 16:41:09
4053 dnl Use this macro after CF_XOPEN_SOURCE, but do not require it (not all
4054 dnl programs need this test).
4056 dnl This is really a MacOS X 10.4.3 workaround. Defining _POSIX_C_SOURCE
4057 dnl forces SIGWINCH to be undefined (breaks xterm, ncurses). Oddly, the struct
4058 dnl winsize declaration is left alone - we may revisit this if Apple choose to
4059 dnl break that part of the interface as well.
4060 AC_DEFUN([CF_SIGWINCH],
4062 AC_CACHE_CHECK(if SIGWINCH is defined,cf_cv_define_sigwinch,[
4064 #include <sys/types.h>
4065 #include <sys/signal.h>
4066 ],[int x = SIGWINCH],
4067 [cf_cv_define_sigwinch=yes],
4069 #undef _XOPEN_SOURCE
4070 #undef _POSIX_SOURCE
4071 #undef _POSIX_C_SOURCE
4072 #include <sys/types.h>
4073 #include <sys/signal.h>
4074 ],[int x = SIGWINCH],
4075 [cf_cv_define_sigwinch=maybe],
4076 [cf_cv_define_sigwinch=no])
4080 if test "$cf_cv_define_sigwinch" = maybe ; then
4081 AC_CACHE_CHECK(for actual SIGWINCH definition,cf_cv_fixup_sigwinch,[
4082 cf_cv_fixup_sigwinch=unknown
4084 while test $cf_sigwinch != 1
4087 #undef _XOPEN_SOURCE
4088 #undef _POSIX_SOURCE
4089 #undef _POSIX_C_SOURCE
4090 #include <sys/types.h>
4091 #include <sys/signal.h>
4093 #if SIGWINCH != $cf_sigwinch
4097 [cf_cv_fixup_sigwinch=$cf_sigwinch
4100 cf_sigwinch=`expr $cf_sigwinch - 1`
4104 if test "$cf_cv_fixup_sigwinch" != unknown ; then
4105 CPPFLAGS="$CPPFLAGS -DSIGWINCH=$cf_cv_fixup_sigwinch"
4109 dnl ---------------------------------------------------------------------------
4110 dnl CF_SIG_ATOMIC_T version: 2 updated: 2005/09/18 17:27:12
4112 dnl signal handler, but there are some gcc depedencies in that recommendation.
4114 AC_DEFUN([CF_SIG_ATOMIC_T],
4116 AC_MSG_CHECKING(for signal global datatype)
4117 AC_CACHE_VAL(cf_cv_sig_atomic_t,[
4119 "volatile sig_atomic_t" \
4124 #include <sys/types.h>
4130 static void handler(int sig)
4134 [signal(SIGINT, handler);
4136 [cf_cv_sig_atomic_t=$cf_type],
4137 [cf_cv_sig_atomic_t=no])
4138 test "$cf_cv_sig_atomic_t" != no && break
4141 AC_MSG_RESULT($cf_cv_sig_atomic_t)
4142 test "$cf_cv_sig_atomic_t" != no && AC_DEFINE_UNQUOTED(SIG_ATOMIC_T, $cf_cv_sig_atomic_t)
4144 dnl ---------------------------------------------------------------------------
4145 dnl CF_SIZECHANGE version: 8 updated: 2000/11/04 12:22:16
4147 dnl Check for definitions & structures needed for window size-changing
4148 dnl FIXME: check that this works with "snake" (HP-UX 10.x)
4149 AC_DEFUN([CF_SIZECHANGE],
4151 AC_REQUIRE([CF_STRUCT_TERMIOS])
4152 AC_CACHE_CHECK(declaration of size-change, cf_cv_sizechange,[
4153 cf_cv_sizechange=unknown
4154 cf_save_CPPFLAGS="$CPPFLAGS"
4156 for cf_opts in "" "NEED_PTEM_H"
4159 CPPFLAGS="$cf_save_CPPFLAGS"
4160 test -n "$cf_opts" && CPPFLAGS="$CPPFLAGS -D$cf_opts"
4161 AC_TRY_COMPILE([#include <sys/types.h>
4162 #ifdef HAVE_TERMIOS_H
4163 #include <termios.h>
4165 #ifdef HAVE_TERMIO_H
4170 /* This is a workaround for SCO: they neglected to define struct winsize in
4171 * termios.h -- it's only in termio.h and ptem.h
4173 #include <sys/stream.h>
4174 #include <sys/ptem.h>
4176 #if !defined(sun) || !defined(HAVE_TERMIOS_H)
4177 #include <sys/ioctl.h>
4181 struct ttysize win; /* FIXME: what system is this? */
4182 int y = win.ts_lines;
4183 int x = win.ts_cols;
4190 no TIOCGSIZE or TIOCGWINSZ
4191 #endif /* TIOCGWINSZ */
4192 #endif /* TIOCGSIZE */
4194 [cf_cv_sizechange=yes],
4195 [cf_cv_sizechange=no])
4197 CPPFLAGS="$cf_save_CPPFLAGS"
4198 if test "$cf_cv_sizechange" = yes ; then
4199 echo "size-change succeeded ($cf_opts)" >&AC_FD_CC
4200 test -n "$cf_opts" && cf_cv_sizechange="$cf_opts"
4205 if test "$cf_cv_sizechange" != no ; then
4206 AC_DEFINE(HAVE_SIZECHANGE)
4207 case $cf_cv_sizechange in #(vi
4209 AC_DEFINE_UNQUOTED($cf_cv_sizechange )
4214 dnl ---------------------------------------------------------------------------
4215 dnl CF_SRC_MODULES version: 18 updated: 2005/05/28 12:58:54
4217 dnl For each parameter, test if the source-directory exists, and if it contains
4218 dnl a 'modules' file. If so, add to the list $cf_cv_src_modules which we'll
4219 dnl use in CF_LIB_RULES.
4221 dnl This uses the configured value to make the lists SRC_SUBDIRS and
4222 dnl SUB_MAKEFILES which are used in the makefile-generation scheme.
4223 AC_DEFUN([CF_SRC_MODULES],
4225 AC_MSG_CHECKING(for src modules)
4227 # dependencies and linker-arguments for test-programs
4228 TEST_DEPS="${LIB_DIR}/${LIB_PREFIX}${LIB_NAME}${DFT_DEP_SUFFIX} $TEST_DEPS"
4229 TEST_DEP2="${LIB_2ND}/${LIB_PREFIX}${LIB_NAME}${DFT_DEP_SUFFIX} $TEST_DEP2"
4230 if test "$DFT_LWR_MODEL" = "libtool"; then
4231 TEST_ARGS="${TEST_DEPS}"
4232 TEST_ARG2="${TEST_DEP2}"
4234 TEST_ARGS="-l${LIB_NAME}${DFT_ARG_SUFFIX} $TEST_ARGS"
4235 TEST_ARG2="-l${LIB_NAME}${DFT_ARG_SUFFIX} $TEST_ARG2"
4241 if test -f $srcdir/$cf_dir/modules; then
4243 # We may/may not have tack in the distribution, though the
4245 if test $cf_dir = tack ; then
4246 if test ! -f $srcdir/${cf_dir}/${cf_dir}.h; then
4251 if test -z "$cf_cv_src_modules"; then
4252 cf_cv_src_modules=$cf_dir
4254 cf_cv_src_modules="$cf_cv_src_modules $cf_dir"
4257 # Make the ncurses_cfg.h file record the library interface files as
4258 # well. These are header files that are the same name as their
4259 # directory. Ncurses is the only library that does not follow
4261 if test $cf_dir = tack ; then
4263 elif test -f $srcdir/${cf_dir}/${cf_dir}.h; then
4264 CF_UPPER(cf_have_include,$cf_dir)
4265 AC_DEFINE_UNQUOTED(HAVE_${cf_have_include}_H)
4266 AC_DEFINE_UNQUOTED(HAVE_LIB${cf_have_include})
4267 TEST_DEPS="${LIB_DIR}/${LIB_PREFIX}${cf_dir}${DFT_DEP_SUFFIX} $TEST_DEPS"
4268 TEST_DEP2="${LIB_2ND}/${LIB_PREFIX}${cf_dir}${DFT_DEP_SUFFIX} $TEST_DEP2"
4269 if test "$DFT_LWR_MODEL" = "libtool"; then
4270 TEST_ARGS="${TEST_DEPS}"
4271 TEST_ARG2="${TEST_DEP2}"
4273 TEST_ARGS="-l${cf_dir}${DFT_ARG_SUFFIX} $TEST_ARGS"
4274 TEST_ARG2="-l${cf_dir}${DFT_ARG_SUFFIX} $TEST_ARG2"
4279 AC_MSG_RESULT($cf_cv_src_modules)
4281 TEST_ARGS="-L${LIB_DIR} $TEST_ARGS"
4282 TEST_ARG2="-L${LIB_2ND} $TEST_ARG2"
4290 SRC_SUBDIRS="man include"
4291 for cf_dir in $cf_cv_src_modules
4293 SRC_SUBDIRS="$SRC_SUBDIRS $cf_dir"
4295 SRC_SUBDIRS="$SRC_SUBDIRS test"
4296 test -z "$MAKE_TERMINFO" && SRC_SUBDIRS="$SRC_SUBDIRS misc"
4297 test "$cf_with_cxx_binding" != no && SRC_SUBDIRS="$SRC_SUBDIRS c++"
4300 if test "$cf_cv_prog_gnat_correct" = yes && test -f $srcdir/Ada95/Makefile.in; then
4301 SRC_SUBDIRS="$SRC_SUBDIRS Ada95"
4302 ADA_SUBDIRS="gen src samples"
4306 for cf_dir in $SRC_SUBDIRS
4308 SUB_MAKEFILES="$SUB_MAKEFILES $cf_dir/Makefile"
4311 if test -n "$ADA_SUBDIRS"; then
4312 for cf_dir in $ADA_SUBDIRS
4314 SUB_MAKEFILES="$SUB_MAKEFILES Ada95/$cf_dir/Makefile"
4316 AC_SUBST(ADA_SUBDIRS)
4319 dnl ---------------------------------------------------------------------------
4320 dnl CF_STDCPP_LIBRARY version: 5 updated: 2000/08/12 23:18:52
4321 dnl -----------------
4322 dnl Check for -lstdc++, which is GNU's standard C++ library.
4323 AC_DEFUN([CF_STDCPP_LIBRARY],
4325 if test -n "$GXX" ; then
4326 case $cf_cv_system_name in #(vi
4328 cf_stdcpp_libname=stdcpp
4331 cf_stdcpp_libname=stdc++
4334 AC_CACHE_CHECK(for library $cf_stdcpp_libname,cf_cv_libstdcpp,[
4336 LIBS="$LIBS -l$cf_stdcpp_libname"
4338 #include <strstream.h>],[
4340 strstreambuf foo(buf, sizeof(buf))
4342 [cf_cv_libstdcpp=yes],
4343 [cf_cv_libstdcpp=no])
4346 test "$cf_cv_libstdcpp" = yes && CXXLIBS="$CXXLIBS -l$cf_stdcpp_libname"
4349 dnl ---------------------------------------------------------------------------
4350 dnl CF_STRIP_G_OPT version: 3 updated: 2002/12/21 19:25:52
4352 dnl Remove "-g" option from the compiler options
4353 AC_DEFUN([CF_STRIP_G_OPT],
4354 [$1=`echo ${$1} | sed -e 's%-g %%' -e 's%-g$%%'`])dnl
4355 dnl ---------------------------------------------------------------------------
4356 dnl CF_STRUCT_SIGACTION version: 3 updated: 2000/08/12 23:18:52
4357 dnl -------------------
4358 dnl Check if we need _POSIX_SOURCE defined to use struct sigaction. We'll only
4359 dnl do this if we've found the sigaction function.
4361 dnl If needed, define SVR4_ACTION.
4362 AC_DEFUN([CF_STRUCT_SIGACTION],[
4363 if test "$ac_cv_func_sigaction" = yes; then
4364 AC_MSG_CHECKING(whether sigaction needs _POSIX_SOURCE)
4366 #include <sys/types.h>
4367 #include <signal.h>],
4368 [struct sigaction act],
4372 #define _POSIX_SOURCE
4373 #include <sys/types.h>
4374 #include <signal.h>],
4375 [struct sigaction act],
4377 AC_DEFINE(SVR4_ACTION)],
4378 [sigact_bad=unknown])])
4379 AC_MSG_RESULT($sigact_bad)
4382 dnl ---------------------------------------------------------------------------
4383 dnl CF_STRUCT_TERMIOS version: 5 updated: 2000/11/04 12:22:46
4384 dnl -----------------
4385 dnl Some machines require _POSIX_SOURCE to completely define struct termios.
4386 dnl If so, define SVR4_TERMIO
4387 AC_DEFUN([CF_STRUCT_TERMIOS],[
4393 if test "$ISC" = yes ; then
4394 AC_CHECK_HEADERS( sys/termio.h )
4396 if test "$ac_cv_header_termios_h" = yes ; then
4397 case "$CFLAGS $CPPFLAGS" in
4399 termios_bad=dunno ;;
4400 *) termios_bad=maybe ;;
4402 if test "$termios_bad" = maybe ; then
4403 AC_MSG_CHECKING(whether termios.h needs _POSIX_SOURCE)
4404 AC_TRY_COMPILE([#include <termios.h>],
4405 [struct termios foo; int x = foo.c_iflag],
4408 #define _POSIX_SOURCE
4409 #include <termios.h>],
4410 [struct termios foo; int x = foo.c_iflag],
4411 termios_bad=unknown,
4412 termios_bad=yes AC_DEFINE(SVR4_TERMIO))
4414 AC_MSG_RESULT($termios_bad)
4418 dnl ---------------------------------------------------------------------------
4419 dnl CF_SUBST version: 4 updated: 2006/06/17 12:33:03
4421 dnl Shorthand macro for substituting things that the user may override
4422 dnl with an environment variable.
4424 dnl $1 = long/descriptive name
4425 dnl $2 = environment variable
4426 dnl $3 = default value
4427 AC_DEFUN([CF_SUBST],
4428 [AC_CACHE_VAL(cf_cv_subst_$2,[
4429 AC_MSG_CHECKING(for $1 (symbol $2))
4430 CF_SUBST_IF([-z "[$]$2"], [$2], [$3])
4431 cf_cv_subst_$2=[$]$2
4432 AC_MSG_RESULT([$]$2)
4435 dnl ---------------------------------------------------------------------------
4436 dnl CF_SUBST_IF version: 2 updated: 2006/06/17 12:33:03
4438 dnl Shorthand macro for substituting things that the user may override
4439 dnl with an environment variable.
4441 dnl $1 = condition to pass to "test"
4442 dnl $2 = environment variable
4443 dnl $3 = value if the test succeeds
4444 dnl $4 = value if the test fails
4445 AC_DEFUN([CF_SUBST_IF],
4454 dnl ---------------------------------------------------------------------------
4455 dnl CF_SUBST_NCURSES_VERSION version: 8 updated: 2006/09/16 11:40:59
4456 dnl ------------------------
4457 dnl Get the version-number for use in shared-library naming, etc.
4458 AC_DEFUN([CF_SUBST_NCURSES_VERSION],
4460 AC_REQUIRE([CF_PROG_EGREP])
4461 NCURSES_MAJOR="`$ac_cv_prog_egrep '^NCURSES_MAJOR[[ ]]*=' $srcdir/dist.mk | sed -e 's/^[[^0-9]]*//'`"
4462 NCURSES_MINOR="`$ac_cv_prog_egrep '^NCURSES_MINOR[[ ]]*=' $srcdir/dist.mk | sed -e 's/^[[^0-9]]*//'`"
4463 NCURSES_PATCH="`$ac_cv_prog_egrep '^NCURSES_PATCH[[ ]]*=' $srcdir/dist.mk | sed -e 's/^[[^0-9]]*//'`"
4464 cf_cv_abi_version=${NCURSES_MAJOR}
4465 cf_cv_rel_version=${NCURSES_MAJOR}.${NCURSES_MINOR}
4466 dnl Show the computed version, for logging
4467 cf_cv_timestamp=`date`
4468 AC_MSG_RESULT(Configuring NCURSES $cf_cv_rel_version ABI $cf_cv_abi_version ($cf_cv_timestamp))
4469 dnl We need these values in the generated headers
4470 AC_SUBST(NCURSES_MAJOR)
4471 AC_SUBST(NCURSES_MINOR)
4472 AC_SUBST(NCURSES_PATCH)
4473 dnl We need these values in the generated makefiles
4474 AC_SUBST(cf_cv_rel_version)
4475 AC_SUBST(cf_cv_abi_version)
4476 AC_SUBST(cf_cv_builtin_bool)
4477 AC_SUBST(cf_cv_header_stdbool_h)
4478 AC_SUBST(cf_cv_type_of_bool)dnl
4480 dnl ---------------------------------------------------------------------------
4481 dnl CF_SYS_TIME_SELECT version: 4 updated: 2000/10/04 09:18:40
4482 dnl ------------------
4483 dnl Check if we can include <sys/time.h> with <sys/select.h>; this breaks on
4484 dnl older SCO configurations.
4485 AC_DEFUN([CF_SYS_TIME_SELECT],
4487 AC_MSG_CHECKING(if sys/time.h works with sys/select.h)
4488 AC_CACHE_VAL(cf_cv_sys_time_select,[
4490 #include <sys/types.h>
4491 #ifdef HAVE_SYS_TIME_H
4492 #include <sys/time.h>
4494 #ifdef HAVE_SYS_SELECT_H
4495 #include <sys/select.h>
4497 ],[],[cf_cv_sys_time_select=yes],
4498 [cf_cv_sys_time_select=no])
4500 AC_MSG_RESULT($cf_cv_sys_time_select)
4501 test "$cf_cv_sys_time_select" = yes && AC_DEFINE(HAVE_SYS_TIME_SELECT)
4503 dnl ---------------------------------------------------------------------------
4504 dnl CF_TOP_BUILDDIR version: 1 updated: 2006/10/15 16:33:23
4506 dnl Define a top_builddir symbol, for applications that need an absolute path.
4507 AC_DEFUN([CF_TOP_BUILDDIR],
4510 AC_SUBST(top_builddir)
4512 dnl ---------------------------------------------------------------------------
4513 dnl CF_TYPEOF_CHTYPE version: 8 updated: 2006/12/16 12:33:30
4514 dnl ----------------
4515 dnl Determine the type we should use for chtype (and attr_t, which is treated
4516 dnl as the same thing). We want around 32 bits, so on most machines want a
4517 dnl long, but on newer 64-bit machines, probably want an int. If we're using
4518 dnl wide characters, we have to have a type compatible with that, as well.
4519 AC_DEFUN([CF_TYPEOF_CHTYPE],
4521 AC_MSG_CHECKING([for type of chtype])
4522 AC_CACHE_VAL(cf_cv_typeof_chtype,[
4524 #define WANT_BITS 31
4528 FILE *fp = fopen("cf_test.out", "w");
4530 char *result = "long";
4531 if (sizeof(unsigned long) > sizeof(unsigned int)) {
4534 for (n = 0; n < WANT_BITS; n++) {
4537 if (y != 1 || x == 0) {
4543 * If x is nonzero, an int is big enough for the bits
4546 result = (x != 0) ? "int" : "long";
4551 ${cf_cv_main_return:-return}(0);
4554 [cf_cv_typeof_chtype=`cat cf_test.out`],
4555 [cf_cv_typeof_chtype=long],
4556 [cf_cv_typeof_chtype=long])
4559 AC_MSG_RESULT($cf_cv_typeof_chtype)
4561 AC_SUBST(cf_cv_typeof_chtype)
4562 AC_DEFINE_UNQUOTED(TYPEOF_CHTYPE,$cf_cv_typeof_chtype)
4564 dnl ---------------------------------------------------------------------------
4565 dnl CF_TYPE_SIGACTION version: 3 updated: 2000/08/12 23:18:52
4566 dnl -----------------
4568 AC_DEFUN([CF_TYPE_SIGACTION],
4570 AC_MSG_CHECKING([for type sigaction_t])
4571 AC_CACHE_VAL(cf_cv_type_sigaction,[
4573 #include <signal.h>],
4575 [cf_cv_type_sigaction=yes],
4576 [cf_cv_type_sigaction=no])])
4577 AC_MSG_RESULT($cf_cv_type_sigaction)
4578 test "$cf_cv_type_sigaction" = yes && AC_DEFINE(HAVE_TYPE_SIGACTION)
4580 dnl ---------------------------------------------------------------------------
4581 dnl CF_UNSIGNED_LITERALS version: 2 updated: 1998/02/07 22:10:16
4582 dnl --------------------
4583 dnl Test if the compiler supports 'U' and 'L' suffixes. Only old compilers
4584 dnl won't, but they're still there.
4585 AC_DEFUN([CF_UNSIGNED_LITERALS],
4587 AC_MSG_CHECKING([if unsigned literals are legal])
4588 AC_CACHE_VAL(cf_cv_unsigned_literals,[
4589 AC_TRY_COMPILE([],[long x = 1L + 1UL + 1U + 1],
4590 [cf_cv_unsigned_literals=yes],
4591 [cf_cv_unsigned_literals=no])
4593 AC_MSG_RESULT($cf_cv_unsigned_literals)
4595 dnl ---------------------------------------------------------------------------
4596 dnl CF_UPPER version: 5 updated: 2001/01/29 23:40:59
4598 dnl Make an uppercase version of a variable
4599 dnl $1=uppercase($2)
4600 AC_DEFUN([CF_UPPER],
4602 $1=`echo "$2" | sed y%abcdefghijklmnopqrstuvwxyz./-%ABCDEFGHIJKLMNOPQRSTUVWXYZ___%`
4604 dnl ---------------------------------------------------------------------------
4605 dnl CF_VERBOSE version: 2 updated: 1997/09/05 10:45:14
4607 dnl Use AC_VERBOSE w/o the warnings
4608 AC_DEFUN([CF_VERBOSE],
4609 [test -n "$verbose" && echo " $1" 1>&AC_FD_MSG
4611 dnl ---------------------------------------------------------------------------
4612 dnl CF_WCHAR_TYPE version: 2 updated: 2004/01/17 19:18:20
4614 dnl Check if type wide-character type $1 is declared, and if so, which header
4615 dnl file is needed. The second parameter is used to set a shell variable when
4616 dnl the type is not found. The first parameter sets a shell variable for the
4618 AC_DEFUN([CF_WCHAR_TYPE],
4620 # This is needed on Tru64 5.0 to declare $1
4621 AC_CACHE_CHECK(if we must include wchar.h to declare $1,cf_cv_$1,[
4626 #ifdef HAVE_LIBUTF8_H
4627 #include <libutf8.h>
4636 #ifdef HAVE_LIBUTF8_H
4637 #include <libutf8.h>
4641 [cf_cv_$1=unknown])])])
4643 if test "$cf_cv_$1" = yes ; then
4644 AC_DEFINE(NEED_WCHAR_H)
4649 # if we do not find $1 in either place, use substitution to provide a fallback.
4650 if test "$cf_cv_$1" = unknown ; then
4655 # if we find $1 in either place, use substitution to provide a fallback.
4656 if test "$cf_cv_$1" != unknown ; then
4661 dnl ---------------------------------------------------------------------------
4662 dnl CF_WITH_ABI_VERSION version: 1 updated: 2003/09/20 18:12:49
4663 dnl -------------------
4664 dnl Allow library's ABI to be overridden. Generally this happens when a
4665 dnl packager has incremented the ABI past that used in the original package,
4666 dnl and wishes to keep doing this.
4668 dnl $1 is the package name, if any, to derive a corresponding {package}_ABI
4670 AC_DEFUN([CF_WITH_ABI_VERSION],[
4671 test -z "$cf_cv_abi_version" && cf_cv_abi_version=0
4672 AC_ARG_WITH(abi-version,
4673 [ --with-abi-version=XXX override derived ABI version],
4674 [AC_MSG_WARN(overriding ABI version $cf_cv_abi_version to $withval)
4675 cf_cv_abi_version=$withval])
4676 CF_NUMBER_SYNTAX($cf_cv_abi_version,ABI version)
4678 $1_ABI=$cf_cv_abi_version
4681 dnl ---------------------------------------------------------------------------
4682 dnl CF_WITH_DBMALLOC version: 6 updated: 2006/12/16 14:24:05
4683 dnl ----------------
4684 dnl Configure-option for dbmalloc. The optional parameter is used to override
4685 dnl the updating of $LIBS, e.g., to avoid conflict with subsequent tests.
4686 AC_DEFUN([CF_WITH_DBMALLOC],[
4687 CF_NO_LEAKS_OPTION(dbmalloc,
4688 [ --with-dbmalloc test: use Conor Cahill's dbmalloc library],
4691 if test "$with_dbmalloc" = yes ; then
4692 AC_CHECK_HEADER(dbmalloc.h,
4693 [AC_CHECK_LIB(dbmalloc,[debug_malloc]ifelse($1,,[],[,$1]))])
4696 dnl ---------------------------------------------------------------------------
4697 dnl CF_WITH_DMALLOC version: 6 updated: 2006/12/16 14:24:05
4699 dnl Configure-option for dmalloc. The optional parameter is used to override
4700 dnl the updating of $LIBS, e.g., to avoid conflict with subsequent tests.
4701 AC_DEFUN([CF_WITH_DMALLOC],[
4702 CF_NO_LEAKS_OPTION(dmalloc,
4703 [ --with-dmalloc test: use Gray Watson's dmalloc library],
4706 if test "$with_dmalloc" = yes ; then
4707 AC_CHECK_HEADER(dmalloc.h,
4708 [AC_CHECK_LIB(dmalloc,[dmalloc_debug]ifelse($1,,[],[,$1]))])
4711 dnl ---------------------------------------------------------------------------
4712 dnl CF_WITH_GPM version: 6 updated: 2006/12/17 11:12:09
4715 dnl The option parameter (if neither yes/no) is assumed to be the name of
4716 dnl the gpm library, e.g., for dynamic loading.
4717 AC_DEFUN([CF_WITH_GPM],
4719 AC_MSG_CHECKING(if you want to link with the GPM mouse library)
4721 [ --with-gpm use Alessandro Rubini's GPM library],
4722 [with_gpm=$withval],
4724 AC_MSG_RESULT($with_gpm)
4726 if test "$with_gpm" != no ; then
4727 AC_CHECK_HEADER(gpm.h,[
4728 AC_DEFINE(HAVE_GPM_H)
4729 if test "$with_gpm" != yes && test "$with_gpm" != maybe ; then
4730 CF_VERBOSE(assuming we really have GPM library)
4731 AC_DEFINE(HAVE_LIBGPM)
4733 AC_CHECK_LIB(gpm,Gpm_Open,[:],[
4734 AC_ERROR(Cannot link with GPM library)
4739 test "$with_gpm" != maybe && AC_MSG_WARN(Cannot find GPM header)
4744 dnl ---------------------------------------------------------------------------
4745 dnl CF_WITH_LIBTOOL version: 18 updated: 2007/04/08 20:02:38
4747 dnl Provide a configure option to incorporate libtool. Define several useful
4748 dnl symbols for the makefile rules.
4750 dnl The reference to AC_PROG_LIBTOOL does not normally work, since it uses
4751 dnl macros from libtool.m4 which is in the aclocal directory of automake.
4752 dnl Following is a simple script which turns on the AC_PROG_LIBTOOL macro.
4753 dnl But that still does not work properly since the macro is expanded outside
4754 dnl the CF_WITH_LIBTOOL macro:
4757 dnl ACLOCAL=`aclocal --print-ac-dir`
4758 dnl if test -z "$ACLOCAL" ; then
4759 dnl echo cannot find aclocal directory
4761 dnl elif test ! -f $ACLOCAL/libtool.m4 ; then
4762 dnl echo cannot find libtool.m4 file
4766 dnl LOCAL=aclocal.m4
4767 dnl ORIG=aclocal.m4.orig
4769 dnl trap "mv $ORIG $LOCAL" 0 1 2 5 15
4773 dnl # sed the LIBTOOL= assignment to omit the current directory?
4774 dnl sed -e 's/^LIBTOOL=.*/LIBTOOL=${LIBTOOL-libtool}/' $ACLOCAL/libtool.m4 >>$LOCAL
4775 dnl cat $ORIG >>$LOCAL
4779 AC_DEFUN([CF_WITH_LIBTOOL],
4781 ifdef([AC_PROG_LIBTOOL],,[
4784 # common library maintenance symbols that are convenient for libtool scripts:
4785 LIB_CREATE='${AR} -cr'
4786 LIB_OBJECT='${OBJECTS}'
4790 # symbols used to prop libtool up to enable it to determine what it should be
4798 AC_MSG_CHECKING(if you want to build libraries with libtool)
4799 AC_ARG_WITH(libtool,
4800 [ --with-libtool generate libraries with libtool],
4801 [with_libtool=$withval],
4803 AC_MSG_RESULT($with_libtool)
4804 if test "$with_libtool" != "no"; then
4805 ifdef([AC_PROG_LIBTOOL],[
4806 # missing_content_AC_PROG_LIBTOOL{{
4808 # missing_content_AC_PROG_LIBTOOL}}
4810 if test "$with_libtool" != "yes" ; then
4811 CF_PATH_SYNTAX(with_libtool)
4812 LIBTOOL=$with_libtool
4814 AC_PATH_PROG(LIBTOOL,libtool)
4816 if test -z "$LIBTOOL" ; then
4817 AC_MSG_ERROR(Cannot find libtool)
4820 LIB_CREATE='${LIBTOOL} --mode=link ${CC} -rpath ${DESTDIR}${libdir} -version-info `cut -f1 ${srcdir}/VERSION` ${LIBTOOL_OPTS} -o'
4821 LIB_OBJECT='${OBJECTS:.o=.lo}'
4823 LIB_CLEAN='${LIBTOOL} --mode=clean'
4824 LIB_COMPILE='${LIBTOOL} --mode=compile'
4825 LIB_LINK='${LIBTOOL} --mode=link ${CC} ${LIBTOOL_OPTS}'
4826 LIB_INSTALL='${LIBTOOL} --mode=install'
4827 LIB_UNINSTALL='${LIBTOOL} --mode=uninstall'
4830 # Show the version of libtool
4831 AC_MSG_CHECKING(version of libtool)
4833 # Save the version in a cache variable - this is not entirely a good
4834 # thing, but the version string from libtool is very ugly, and for
4835 # bug reports it might be useful to have the original string.
4836 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.]].*//'`
4837 AC_MSG_RESULT($cf_cv_libtool_version)
4838 if test -z "$cf_cv_libtool_version" ; then
4839 AC_MSG_ERROR(This is not GNU libtool)
4842 # special hack to add --tag option for C++ compiler
4843 case $cf_cv_libtool_version in
4844 1.[[5-9]]*|[[2-9]]*)
4845 LIBTOOL_CXX="$LIBTOOL --tag=CXX"
4848 LIBTOOL_CXX="$LIBTOOL"
4856 test -z "$LIBTOOL" && ECHO_LT=
4859 AC_SUBST(LIBTOOL_CXX)
4860 AC_SUBST(LIBTOOL_OPTS)
4862 AC_SUBST(LIB_CREATE)
4863 AC_SUBST(LIB_OBJECT)
4864 AC_SUBST(LIB_SUFFIX)
4868 AC_SUBST(LIB_COMPILE)
4870 AC_SUBST(LIB_INSTALL)
4871 AC_SUBST(LIB_UNINSTALL)
4874 dnl ---------------------------------------------------------------------------
4875 dnl CF_WITH_PATH version: 7 updated: 2006/08/03 15:20:08
4877 dnl Wrapper for AC_ARG_WITH to ensure that user supplies a pathname, not just
4878 dnl defaulting to yes/no.
4880 dnl $1 = option name
4882 dnl $3 = environment variable to set
4883 dnl $4 = default value, shown in the help-message, must be a constant
4884 dnl $5 = default value, if it's an expression & cannot be in the help-message
4886 AC_DEFUN([CF_WITH_PATH],
4887 [AC_ARG_WITH($1,[$2 ](default: ifelse($4,,empty,$4)),,
4888 ifelse($4,,[withval="${$3}"],[withval="${$3-ifelse($5,,$4,$5)}"]))dnl
4889 CF_PATH_SYNTAX(withval)
4893 dnl ---------------------------------------------------------------------------
4894 dnl CF_WITH_PATHLIST version: 5 updated: 2001/12/10 01:28:30
4895 dnl ----------------
4896 dnl Process an option specifying a list of colon-separated paths.
4898 dnl $1 = option name
4900 dnl $3 = environment variable to set
4901 dnl $4 = default value, shown in the help-message, must be a constant
4902 dnl $5 = default value, if it's an expression & cannot be in the help-message
4903 dnl $6 = flag to tell if we want to define or substitute
4905 AC_DEFUN([CF_WITH_PATHLIST],[
4906 AC_REQUIRE([CF_PATHSEP])
4907 AC_ARG_WITH($1,[$2 ](default: ifelse($4,,empty,$4)),,
4908 ifelse($4,,[withval=${$3}],[withval=${$3-ifelse($5,,$4,$5)}]))dnl
4910 IFS="${IFS= }"; ac_save_ifs="$IFS"; IFS="${PATHSEP}"
4912 for cf_src_path in $withval
4914 CF_PATH_SYNTAX(cf_src_path)
4915 test -n "$cf_dst_path" && cf_dst_path="${cf_dst_path}:"
4916 cf_dst_path="${cf_dst_path}${cf_src_path}"
4921 # Strip single quotes from the value, e.g., when it was supplied as a literal
4923 case $cf_dst_path in #(vi
4925 cf_dst_path=`echo $cf_dst_path |sed -e s/\'// -e s/\'\$//`
4928 cf_dst_path=`echo "$cf_dst_path" | sed -e 's/\\\\/\\\\\\\\/g'`
4931 eval '$3="$cf_dst_path"'
4935 dnl ---------------------------------------------------------------------------
4936 dnl CF_WITH_REL_VERSION version: 1 updated: 2003/09/20 18:12:49
4937 dnl -------------------
4938 dnl Allow library's release-version to be overridden. Generally this happens when a
4939 dnl packager has incremented the release-version past that used in the original package,
4940 dnl and wishes to keep doing this.
4942 dnl $1 is the package name, if any, to derive corresponding {package}_MAJOR
4943 dnl and {package}_MINOR symbols
4945 AC_DEFUN([CF_WITH_REL_VERSION],[
4946 test -z "$cf_cv_rel_version" && cf_cv_rel_version=0.0
4947 AC_ARG_WITH(rel-version,
4948 [ --with-rel-version=XXX override derived release version],
4949 [AC_MSG_WARN(overriding release version $cf_cv_rel_version to $withval)
4950 cf_cv_rel_version=$withval])
4952 CF_NUMBER_SYNTAX($cf_cv_rel_version,Release version)
4954 $1_MAJOR=`echo "$cf_cv_rel_version" | sed -e 's/\..*//'`
4955 $1_MINOR=`echo "$cf_cv_rel_version" | sed -e 's/^[[^.]]*//' -e 's/^\.//' -e 's/\..*//'`
4956 CF_NUMBER_SYNTAX([$]$1_MAJOR,Release major-version)
4957 CF_NUMBER_SYNTAX([$]$1_MINOR,Release minor-version)
4960 dnl ---------------------------------------------------------------------------
4961 dnl CF_WITH_SYSMOUSE version: 2 updated: 2003/03/22 19:13:43
4962 dnl ----------------
4963 dnl If we can compile with sysmouse, make it available unless it is not wanted.
4964 AC_DEFUN([CF_WITH_SYSMOUSE],[
4965 # not everyone has "test -c"
4966 if test -c /dev/sysmouse 2>/dev/null ; then
4967 AC_MSG_CHECKING(if you want to use sysmouse)
4968 AC_ARG_WITH(sysmouse,
4969 [ --with-sysmouse use sysmouse (FreeBSD console)],
4970 [cf_with_sysmouse=$withval],
4971 [cf_with_sysmouse=maybe])
4972 if test "$cf_with_sysmouse" != no ; then
4974 #include <osreldate.h>
4975 #if (__FreeBSD_version >= 400017)
4976 #include <sys/consio.h>
4977 #include <sys/fbio.h>
4979 #include <machine/console.h>
4982 struct mouse_info the_mouse;
4983 ioctl(0, CONS_MOUSECTL, &the_mouse);
4984 ],[cf_with_sysmouse=yes],[cf_with_sysmouse=no])
4986 AC_MSG_RESULT($cf_with_sysmouse)
4987 test "$cf_with_sysmouse" = yes && AC_DEFINE(USE_SYSMOUSE)
4990 dnl ---------------------------------------------------------------------------
4991 dnl CF_WITH_VALGRIND version: 1 updated: 2006/12/14 18:00:21
4992 dnl ----------------
4993 AC_DEFUN([CF_WITH_VALGRIND],[
4994 CF_NO_LEAKS_OPTION(valgrind,
4995 [ --with-valgrind test: use valgrind],
4998 dnl ---------------------------------------------------------------------------
4999 dnl CF_XOPEN_SOURCE version: 25 updated: 2007/01/29 18:36:38
5001 dnl Try to get _XOPEN_SOURCE defined properly that we can use POSIX functions,
5002 dnl or adapt to the vendor's definitions to get equivalent functionality,
5003 dnl without losing the common non-POSIX features.
5006 dnl $1 is the nominal value for _XOPEN_SOURCE
5007 dnl $2 is the nominal value for _POSIX_C_SOURCE
5008 AC_DEFUN([CF_XOPEN_SOURCE],[
5010 AC_REQUIRE([CF_PROG_CC_U_D])
5012 cf_XOPEN_SOURCE=ifelse($1,,500,$1)
5013 cf_POSIX_C_SOURCE=ifelse($2,,199506L,$2)
5015 case $host_os in #(vi
5017 CPPFLAGS="$CPPFLAGS -D_ALL_SOURCE"
5020 # 5.x headers associate
5021 # _XOPEN_SOURCE=600 with _POSIX_C_SOURCE=200112L
5022 # _XOPEN_SOURCE=500 with _POSIX_C_SOURCE=199506L
5023 cf_POSIX_C_SOURCE=200112L
5025 CPPFLAGS="$CPPFLAGS -D_BSD_TYPES -D__BSD_VISIBLE -D_POSIX_C_SOURCE=$cf_POSIX_C_SOURCE -D_XOPEN_SOURCE=$cf_XOPEN_SOURCE"
5028 CPPFLAGS="$CPPFLAGS -D_HPUX_SOURCE"
5031 CPPFLAGS="$CPPFLAGS -D_SGI_SOURCE"
5033 linux*|gnu*|k*bsd*-gnu) #(vi
5037 # setting _XOPEN_SOURCE or _POSIX_SOURCE breaks <arpa/inet.h>
5040 # setting _XOPEN_SOURCE breaks IPv6 for lynx on NetBSD 1.6, breaks xterm, is not needed for ncursesw
5043 # setting _XOPEN_SOURCE breaks xterm on OpenBSD 2.8, is not needed for ncursesw
5046 CPPFLAGS="$CPPFLAGS -D_OSF_SOURCE"
5049 CPPFLAGS="$CPPFLAGS -D_QNX_SOURCE"
5052 # setting _XOPEN_SOURCE breaks Lynx on SCO Unix / OpenServer
5055 CPPFLAGS="$CPPFLAGS -D__EXTENSIONS__"
5058 AC_CACHE_CHECK(if we should define _XOPEN_SOURCE,cf_cv_xopen_source,[
5059 AC_TRY_COMPILE([#include <sys/types.h>],[
5060 #ifndef _XOPEN_SOURCE
5063 [cf_cv_xopen_source=no],
5064 [cf_save="$CPPFLAGS"
5065 CPPFLAGS="$CPPFLAGS -D_XOPEN_SOURCE=$cf_XOPEN_SOURCE"
5066 AC_TRY_COMPILE([#include <sys/types.h>],[
5067 #ifdef _XOPEN_SOURCE
5070 [cf_cv_xopen_source=no],
5071 [cf_cv_xopen_source=$cf_XOPEN_SOURCE])
5075 if test "$cf_cv_xopen_source" != no ; then
5076 CF_REMOVE_DEFINE(CFLAGS,$CFLAGS,_XOPEN_SOURCE)
5077 CF_REMOVE_DEFINE(CPPFLAGS,$CPPFLAGS,_XOPEN_SOURCE)
5078 test "$cf_cv_cc_u_d_options" = yes && \
5079 CPPFLAGS="$CPPFLAGS -U_XOPEN_SOURCE"
5080 CPPFLAGS="$CPPFLAGS -D_XOPEN_SOURCE=$cf_cv_xopen_source"
5082 CF_POSIX_C_SOURCE($cf_POSIX_C_SOURCE)