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