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