ncurses 5.6 - patch 20070812
[ncurses.git] / aclocal.m4
1 dnl***************************************************************************
2 dnl Copyright (c) 1998-2006,2007 Free Software Foundation, Inc.              *
3 dnl                                                                          *
4 dnl Permission is hereby granted, free of charge, to any person obtaining a  *
5 dnl copy of this software and associated documentation files (the            *
6 dnl "Software"), to deal in the Software without restriction, including      *
7 dnl without limitation the rights to use, copy, modify, merge, publish,      *
8 dnl distribute, distribute with modifications, sublicense, and/or sell       *
9 dnl copies of the Software, and to permit persons to whom the Software is    *
10 dnl furnished to do so, subject to the following conditions:                 *
11 dnl                                                                          *
12 dnl The above copyright notice and this permission notice shall be included  *
13 dnl in all copies or substantial portions of the Software.                   *
14 dnl                                                                          *
15 dnl THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS  *
16 dnl OR IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF               *
17 dnl MERCHANTABILITY, FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT.   *
18 dnl IN NO EVENT SHALL THE ABOVE COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM,   *
19 dnl DAMAGES OR OTHER LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR    *
20 dnl OTHERWISE, ARISING FROM, OUT OF OR IN CONNECTION WITH THE SOFTWARE OR    *
21 dnl THE USE OR OTHER DEALINGS IN THE SOFTWARE.                               *
22 dnl                                                                          *
23 dnl Except as contained in this notice, the name(s) of the above copyright   *
24 dnl holders shall not be used in advertising or otherwise to promote the     *
25 dnl sale, use or other dealings in this Software without prior written       *
26 dnl authorization.                                                           *
27 dnl***************************************************************************
28 dnl
29 dnl Author: Thomas E. Dickey 1995-on
30 dnl
31 dnl $Id: aclocal.m4,v 1.436 2007/08/11 18:12:19 tom Exp $
32 dnl Macros used in NCURSES auto-configuration script.
33 dnl
34 dnl These macros are maintained separately from NCURSES.  The copyright on
35 dnl this file applies to the aggregation of macros and does not affect use of
36 dnl these macros in other applications.
37 dnl
38 dnl See http://invisible-island.net/autoconf/ for additional information.
39 dnl
40 dnl ---------------------------------------------------------------------------
41 dnl ---------------------------------------------------------------------------
42 dnl AM_LANGINFO_CODESET version: 3 updated: 2002/10/27 23:21:42
43 dnl -------------------
44 dnl Inserted as requested by gettext 0.10.40
45 dnl File from /usr/share/aclocal
46 dnl codeset.m4
47 dnl ====================
48 dnl serial AM1
49 dnl
50 dnl From Bruno Haible.
51 AC_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
64 dnl ---------------------------------------------------------------------------
65 dnl CF_ADA_INCLUDE_DIRS version: 5 updated: 2006/10/14 15:23:15
66 dnl -------------------
67 dnl Construct the list of include-options for the C programs in the Ada95
68 dnl binding.
69 AC_DEFUN([CF_ADA_INCLUDE_DIRS],
70 [
71 ACPPFLAGS="-I. -I../../include $ACPPFLAGS"
72 if test "$srcdir" != "."; then
73         ACPPFLAGS="-I\${srcdir}/../../include $ACPPFLAGS"
74 fi
75 if test "$GCC" != yes; then
76         ACPPFLAGS="$ACPPFLAGS -I\${includedir}"
77 elif test "$includedir" != "/usr/include"; then
78         if test "$includedir" = '${prefix}/include' ; then
79                 if test $prefix != /usr ; then
80                         ACPPFLAGS="$ACPPFLAGS -I\${includedir}"
81                 fi
82         else
83                 ACPPFLAGS="$ACPPFLAGS -I\${includedir}"
84         fi
85 fi
86 AC_SUBST(ACPPFLAGS)
87 ])dnl
88 dnl ---------------------------------------------------------------------------
89 dnl CF_ADD_CFLAGS version: 7 updated: 2004/04/25 17:48:30
90 dnl -------------
91 dnl Copy non-preprocessor flags to $CFLAGS, preprocessor flags to $CPPFLAGS
92 dnl The second parameter if given makes this macro verbose.
93 dnl
94 dnl Put any preprocessor definitions that use quoted strings in $EXTRA_CPPFLAGS,
95 dnl to simplify use of $CPPFLAGS in compiler checks, etc., that are easily
96 dnl confused by the quotes (which require backslashes to keep them usable).
97 AC_DEFUN([CF_ADD_CFLAGS],
98 [
99 cf_fix_cppflags=no
100 cf_new_cflags=
101 cf_new_cppflags=
102 cf_new_extra_cppflags=
103
104 for cf_add_cflags in $1
105 do
106 case $cf_fix_cppflags in
107 no)
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         ;;
140 yes)
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         ;;
149 esac
150 done
151
152 if test -n "$cf_new_cflags" ; then
153         ifelse($2,,,[CF_VERBOSE(add to \$CFLAGS $cf_new_cflags)])
154         CFLAGS="$CFLAGS $cf_new_cflags"
155 fi
156
157 if test -n "$cf_new_cppflags" ; then
158         ifelse($2,,,[CF_VERBOSE(add to \$CPPFLAGS $cf_new_cppflags)])
159         CPPFLAGS="$cf_new_cppflags $CPPFLAGS"
160 fi
161
162 if test -n "$cf_new_extra_cppflags" ; then
163         ifelse($2,,,[CF_VERBOSE(add to \$EXTRA_CPPFLAGS $cf_new_extra_cppflags)])
164         EXTRA_CPPFLAGS="$cf_new_extra_cppflags $EXTRA_CPPFLAGS"
165 fi
166
167 AC_SUBST(EXTRA_CPPFLAGS)
168
169 ])dnl
170 dnl ---------------------------------------------------------------------------
171 dnl CF_ANSI_CC_CHECK version: 9 updated: 2001/12/30 17:53:34
172 dnl ----------------
173 dnl This is adapted from the macros 'fp_PROG_CC_STDC' and 'fp_C_PROTOTYPES'
174 dnl in the sharutils 4.2 distribution.
175 AC_DEFUN([CF_ANSI_CC_CHECK],
176 [
177 AC_CACHE_CHECK(for ${CC-cc} option to accept ANSI C, cf_cv_ansi_cc,[
178 cf_cv_ansi_cc=no
179 cf_save_CFLAGS="$CFLAGS"
180 cf_save_CPPFLAGS="$CPPFLAGS"
181 # Don't try gcc -ansi; that turns off useful extensions and
182 # breaks some systems' header files.
183 # AIX                   -qlanglvl=ansi
184 # Ultrix and OSF/1      -std1
185 # HP-UX                 -Aa -D_HPUX_SOURCE
186 # SVR4                  -Xc
187 # UnixWare 1.2          (cannot use -Xc, since ANSI/POSIX clashes)
188 for cf_arg in "-DCC_HAS_PROTOS" \
189         "" \
190         -qlanglvl=ansi \
191         -std1 \
192         -Ae \
193         "-Aa -D_HPUX_SOURCE" \
194         -Xc
195 do
196         CF_ADD_CFLAGS($cf_arg)
197         AC_TRY_COMPILE(
198 [
199 #ifndef CC_HAS_PROTOS
200 #if !defined(__STDC__) || (__STDC__ != 1)
201 choke me
202 #endif
203 #endif
204 ],[
205         int test (int i, double x);
206         struct s1 {int (*f) (int a);};
207         struct s2 {int (*f) (double a);};],
208         [cf_cv_ansi_cc="$cf_arg"; break])
209 done
210 CFLAGS="$cf_save_CFLAGS"
211 CPPFLAGS="$cf_save_CPPFLAGS"
212 ])
213
214 if test "$cf_cv_ansi_cc" != "no"; then
215 if test ".$cf_cv_ansi_cc" != ".-DCC_HAS_PROTOS"; then
216         CF_ADD_CFLAGS($cf_cv_ansi_cc)
217 else
218         AC_DEFINE(CC_HAS_PROTOS)
219 fi
220 fi
221 ])dnl
222 dnl ---------------------------------------------------------------------------
223 dnl CF_ANSI_CC_REQD version: 3 updated: 1997/09/06 13:40:44
224 dnl ---------------
225 dnl For programs that must use an ANSI compiler, obtain compiler options that
226 dnl will make it recognize prototypes.  We'll do preprocessor checks in other
227 dnl macros, since tools such as unproto can fake prototypes, but only part of
228 dnl the preprocessor.
229 AC_DEFUN([CF_ANSI_CC_REQD],
230 [AC_REQUIRE([CF_ANSI_CC_CHECK])
231 if test "$cf_cv_ansi_cc" = "no"; then
232         AC_ERROR(
233 [Your compiler does not appear to recognize prototypes.
234 You have the following choices:
235         a. adjust your compiler options
236         b. get an up-to-date compiler
237         c. use a wrapper such as unproto])
238 fi
239 ])dnl
240 dnl ---------------------------------------------------------------------------
241 dnl CF_BOOL_DECL version: 8 updated: 2004/01/30 15:51:18
242 dnl ------------
243 dnl Test if 'bool' is a builtin type in the configured C++ compiler.  Some
244 dnl older compilers (e.g., gcc 2.5.8) don't support 'bool' directly; gcc
245 dnl 2.6.3 does, in anticipation of the ANSI C++ standard.
246 dnl
247 dnl Treat the configuration-variable specially here, since we're directly
248 dnl substituting its value (i.e., 1/0).
249 dnl
250 dnl $1 is the shell variable to store the result in, if not $cv_cv_builtin_bool
251 AC_DEFUN([CF_BOOL_DECL],
252 [
253 AC_MSG_CHECKING(if we should include stdbool.h)
254
255 AC_CACHE_VAL(cf_cv_header_stdbool_h,[
256         AC_TRY_COMPILE([],[bool foo = false],
257                 [cf_cv_header_stdbool_h=0],
258                 [AC_TRY_COMPILE([
259 #ifndef __BEOS__
260 #include <stdbool.h>
261 #endif
262 ],[bool foo = false],
263                         [cf_cv_header_stdbool_h=1],
264                         [cf_cv_header_stdbool_h=0])])])
265
266 if test "$cf_cv_header_stdbool_h" = 1
267 then    AC_MSG_RESULT(yes)
268 else    AC_MSG_RESULT(no)
269 fi
270
271 AC_MSG_CHECKING([for builtin bool type])
272
273 AC_CACHE_VAL(ifelse($1,,cf_cv_builtin_bool,[$1]),[
274         AC_TRY_COMPILE([
275 #include <stdio.h>
276 #include <sys/types.h>
277 ],[bool x = false],
278                 [ifelse($1,,cf_cv_builtin_bool,[$1])=1],
279                 [ifelse($1,,cf_cv_builtin_bool,[$1])=0])
280         ])
281
282 if test "$ifelse($1,,cf_cv_builtin_bool,[$1])" = 1
283 then    AC_MSG_RESULT(yes)
284 else    AC_MSG_RESULT(no)
285 fi
286 ])dnl
287 dnl ---------------------------------------------------------------------------
288 dnl CF_BOOL_SIZE version: 12 updated: 2006/12/16 12:33:30
289 dnl ------------
290 dnl Test for the size of 'bool' in the configured C++ compiler (e.g., a type).
291 dnl Don't bother looking for bool.h, since it's been deprecated.
292 dnl
293 dnl If the current compiler is C rather than C++, we get the bool definition
294 dnl from <stdbool.h>.
295 AC_DEFUN([CF_BOOL_SIZE],
296 [
297 AC_MSG_CHECKING([for size of bool])
298 AC_CACHE_VAL(cf_cv_type_of_bool,[
299         rm -f cf_test.out
300         AC_TRY_RUN([
301 #include <stdlib.h>
302 #include <stdio.h>
303
304 #if defined(__cplusplus)
305
306 #ifdef HAVE_GXX_BUILTIN_H
307 #include <g++/builtin.h>
308 #elif HAVE_GPP_BUILTIN_H
309 #include <gpp/builtin.h>
310 #elif HAVE_BUILTIN_H
311 #include <builtin.h>
312 #endif
313
314 #else
315
316 #if $cf_cv_header_stdbool_h
317 #include <stdbool.h>
318 #endif
319
320 #endif
321
322 main()
323 {
324         FILE *fp = fopen("cf_test.out", "w");
325         if (fp != 0) {
326                 bool x = true;
327                 if ((bool)(-x) >= 0)
328                         fputs("unsigned ", fp);
329                 if (sizeof(x) == sizeof(int))       fputs("int",  fp);
330                 else if (sizeof(x) == sizeof(char)) fputs("char", fp);
331                 else if (sizeof(x) == sizeof(short))fputs("short",fp);
332                 else if (sizeof(x) == sizeof(long)) fputs("long", fp);
333                 fclose(fp);
334         }
335         ${cf_cv_main_return:-return}(0);
336 }
337                 ],
338                 [cf_cv_type_of_bool=`cat cf_test.out`
339                  if test -z "$cf_cv_type_of_bool"; then
340                    cf_cv_type_of_bool=unknown
341                  fi],
342                 [cf_cv_type_of_bool=unknown],
343                 [cf_cv_type_of_bool=unknown])
344         ])
345         rm -f cf_test.out
346 AC_MSG_RESULT($cf_cv_type_of_bool)
347 if test "$cf_cv_type_of_bool" = unknown ; then
348         case .$NCURSES_BOOL in #(vi
349         .auto|.) NCURSES_BOOL=unsigned;;
350         esac
351         AC_MSG_WARN(Assuming $NCURSES_BOOL for type of bool)
352         cf_cv_type_of_bool=$NCURSES_BOOL
353 fi
354 ])dnl
355 dnl ---------------------------------------------------------------------------
356 dnl CF_BUILD_CC version: 6 updated: 2006/10/14 15:23:15
357 dnl -----------
358 dnl If we're cross-compiling, allow the user to override the tools and their
359 dnl options.  The configure script is oriented toward identifying the host
360 dnl compiler, etc., but we need a build compiler to generate parts of the
361 dnl source.
362 dnl
363 dnl $1 = default for $CPPFLAGS
364 dnl $2 = default for $LIBS
365 AC_DEFUN([CF_BUILD_CC],[
366 AC_REQUIRE([CF_PROG_EXT])
367 if test "$cross_compiling" = yes ; then
368
369         # defaults that we might want to override
370         : ${BUILD_CFLAGS:=''}
371         : ${BUILD_CPPFLAGS:='ifelse([$1],,,[$1])'}
372         : ${BUILD_LDFLAGS:=''}
373         : ${BUILD_LIBS:='ifelse([$2],,,[$2])'}
374         : ${BUILD_EXEEXT:='$x'}
375         : ${BUILD_OBJEXT:='o'}
376
377         AC_ARG_WITH(build-cc,
378                 [  --with-build-cc=XXX     the build C compiler ($BUILD_CC)],
379                 [BUILD_CC="$withval"],
380                 [AC_CHECK_PROGS(BUILD_CC, gcc cc cl)])
381         AC_MSG_CHECKING(for native build C compiler)
382         AC_MSG_RESULT($BUILD_CC)
383
384         AC_MSG_CHECKING(for native build C preprocessor)
385         AC_ARG_WITH(build-cpp,
386                 [  --with-build-cpp=XXX    the build C preprocessor ($BUILD_CPP)],
387                 [BUILD_CPP="$withval"],
388                 [BUILD_CPP='${BUILD_CC} -E'])
389         AC_MSG_RESULT($BUILD_CPP)
390
391         AC_MSG_CHECKING(for native build C flags)
392         AC_ARG_WITH(build-cflags,
393                 [  --with-build-cflags=XXX the build C compiler-flags ($BUILD_CFLAGS)],
394                 [BUILD_CFLAGS="$withval"])
395         AC_MSG_RESULT($BUILD_CFLAGS)
396
397         AC_MSG_CHECKING(for native build C preprocessor-flags)
398         AC_ARG_WITH(build-cppflags,
399                 [  --with-build-cppflags=XXX the build C preprocessor-flags ($BUILD_CPPFLAGS)],
400                 [BUILD_CPPFLAGS="$withval"])
401         AC_MSG_RESULT($BUILD_CPPFLAGS)
402
403         AC_MSG_CHECKING(for native build linker-flags)
404         AC_ARG_WITH(build-ldflags,
405                 [  --with-build-ldflags=XXX the build linker-flags ($BUILD_LDFLAGS)],
406                 [BUILD_LDFLAGS="$withval"])
407         AC_MSG_RESULT($BUILD_LDFLAGS)
408
409         AC_MSG_CHECKING(for native build linker-libraries)
410         AC_ARG_WITH(build-libs,
411                 [  --with-build-libs=XXX   the build libraries (${BUILD_LIBS})],
412                 [BUILD_LIBS="$withval"])
413         AC_MSG_RESULT($BUILD_LIBS)
414
415         # this assumes we're on Unix.
416         BUILD_EXEEXT=
417         BUILD_OBJEXT=o
418
419         : ${BUILD_CC:='${CC}'}
420
421         if ( test "$BUILD_CC" = "$CC" || test "$BUILD_CC" = '${CC}' ) ; then
422                 AC_MSG_ERROR([Cross-build requires two compilers.
423 Use --with-build-cc to specify the native compiler.])
424         fi
425
426 else
427         : ${BUILD_CC:='${CC}'}
428         : ${BUILD_CPP:='${CPP}'}
429         : ${BUILD_CFLAGS:='${CFLAGS}'}
430         : ${BUILD_CPPFLAGS:='${CPPFLAGS}'}
431         : ${BUILD_LDFLAGS:='${LDFLAGS}'}
432         : ${BUILD_LIBS:='${LIBS}'}
433         : ${BUILD_EXEEXT:='$x'}
434         : ${BUILD_OBJEXT:='o'}
435 fi
436
437 AC_SUBST(BUILD_CC)
438 AC_SUBST(BUILD_CPP)
439 AC_SUBST(BUILD_CFLAGS)
440 AC_SUBST(BUILD_CPPFLAGS)
441 AC_SUBST(BUILD_LDFLAGS)
442 AC_SUBST(BUILD_LIBS)
443 AC_SUBST(BUILD_EXEEXT)
444 AC_SUBST(BUILD_OBJEXT)
445 ])dnl
446 dnl ---------------------------------------------------------------------------
447 dnl CF_CFG_DEFAULTS version: 7 updated: 2005/09/24 16:15:00
448 dnl ---------------
449 dnl Determine the default configuration into which we'll install ncurses.  This
450 dnl can be overridden by the user's command-line options.  There's two items to
451 dnl look for:
452 dnl     1. the prefix (e.g., /usr)
453 dnl     2. the header files (e.g., /usr/include/ncurses)
454 dnl We'll look for a previous installation of ncurses and use the same defaults.
455 dnl
456 dnl We don't use AC_PREFIX_DEFAULT, because it gets evaluated too soon, and
457 dnl we don't use AC_PREFIX_PROGRAM, because we cannot distinguish ncurses's
458 dnl programs from a vendor's.
459 AC_DEFUN([CF_CFG_DEFAULTS],
460 [
461 AC_MSG_CHECKING(for prefix)
462 if test "x$prefix" = "xNONE" ; then
463         case "$cf_cv_system_name" in
464                 # non-vendor systems don't have a conflict
465         openbsd*|freebsd*|linux*|cygwin*|k*bsd*-gnu)
466                 prefix=/usr
467                 ;;
468         *)      prefix=$ac_default_prefix
469                 ;;
470         esac
471 fi
472 AC_MSG_RESULT($prefix)
473
474 if test "x$prefix" = "xNONE" ; then
475 AC_MSG_CHECKING(for default include-directory)
476 test -n "$verbose" && echo 1>&AC_FD_MSG
477 for cf_symbol in \
478         $includedir \
479         $includedir/ncurses \
480         $prefix/include \
481         $prefix/include/ncurses \
482         /usr/local/include \
483         /usr/local/include/ncurses \
484         /usr/include \
485         /usr/include/ncurses
486 do
487         cf_dir=`eval echo $cf_symbol`
488         if test -f $cf_dir/curses.h ; then
489         if ( fgrep NCURSES_VERSION $cf_dir/curses.h 2>&1 >/dev/null ) ; then
490                 includedir="$cf_symbol"
491                 test -n "$verbose"  && echo $ac_n "     found " 1>&AC_FD_MSG
492                 break
493         fi
494         fi
495         test -n "$verbose"  && echo "   tested $cf_dir" 1>&AC_FD_MSG
496 done
497 AC_MSG_RESULT($includedir)
498 fi
499 ])dnl
500 dnl ---------------------------------------------------------------------------
501 dnl CF_CGETENT version: 3 updated: 2000/08/12 23:18:52
502 dnl ----------
503 dnl Check if the terminal-capability database functions are available.  If not,
504 dnl ncurses has a much-reduced version.
505 AC_DEFUN([CF_CGETENT],[
506 AC_MSG_CHECKING(for terminal-capability database functions)
507 AC_CACHE_VAL(cf_cv_cgetent,[
508 AC_TRY_LINK([
509 #include <stdlib.h>],[
510         char temp[128];
511         char *buf = temp;
512         char *db_array = temp;
513         cgetent(&buf, /* int *, */ &db_array, "vt100");
514         cgetcap(buf, "tc", '=');
515         cgetmatch(buf, "tc");
516         ],
517         [cf_cv_cgetent=yes],
518         [cf_cv_cgetent=no])
519 ])
520 AC_MSG_RESULT($cf_cv_cgetent)
521 test "$cf_cv_cgetent" = yes && AC_DEFINE(HAVE_BSD_CGETENT)
522 ])dnl
523 dnl ---------------------------------------------------------------------------
524 dnl CF_CHECK_CACHE version: 10 updated: 2004/05/23 13:03:31
525 dnl --------------
526 dnl Check if we're accidentally using a cache from a different machine.
527 dnl Derive the system name, as a check for reusing the autoconf cache.
528 dnl
529 dnl If we've packaged config.guess and config.sub, run that (since it does a
530 dnl better job than uname).  Normally we'll use AC_CANONICAL_HOST, but allow
531 dnl an extra parameter that we may override, e.g., for AC_CANONICAL_SYSTEM
532 dnl which is useful in cross-compiles.
533 dnl
534 dnl Note: we would use $ac_config_sub, but that is one of the places where
535 dnl autoconf 2.5x broke compatibility with autoconf 2.13
536 AC_DEFUN([CF_CHECK_CACHE],
537 [
538 if test -f $srcdir/config.guess || test -f $ac_aux_dir/config.guess ; then
539         ifelse([$1],,[AC_CANONICAL_HOST],[$1])
540         system_name="$host_os"
541 else
542         system_name="`(uname -s -r) 2>/dev/null`"
543         if test -z "$system_name" ; then
544                 system_name="`(hostname) 2>/dev/null`"
545         fi
546 fi
547 test -n "$system_name" && AC_DEFINE_UNQUOTED(SYSTEM_NAME,"$system_name")
548 AC_CACHE_VAL(cf_cv_system_name,[cf_cv_system_name="$system_name"])
549
550 test -z "$system_name" && system_name="$cf_cv_system_name"
551 test -n "$cf_cv_system_name" && AC_MSG_RESULT(Configuring for $cf_cv_system_name)
552
553 if test ".$system_name" != ".$cf_cv_system_name" ; then
554         AC_MSG_RESULT(Cached system name ($system_name) does not agree with actual ($cf_cv_system_name))
555         AC_ERROR("Please remove config.cache and try again.")
556 fi
557 ])dnl
558 dnl ---------------------------------------------------------------------------
559 dnl CF_CHECK_ERRNO version: 9 updated: 2001/12/30 18:03:23
560 dnl --------------
561 dnl Check for data that is usually declared in <stdio.h> or <errno.h>, e.g.,
562 dnl the 'errno' variable.  Define a DECL_xxx symbol if we must declare it
563 dnl ourselves.
564 dnl
565 dnl $1 = the name to check
566 AC_DEFUN([CF_CHECK_ERRNO],
567 [
568 AC_CACHE_CHECK(if external $1 is declared, cf_cv_dcl_$1,[
569     AC_TRY_COMPILE([
570 #ifdef HAVE_STDLIB_H
571 #include <stdlib.h>
572 #endif
573 #include <stdio.h>
574 #include <sys/types.h>
575 #include <errno.h> ],
576     [long x = (long) $1],
577     [cf_cv_dcl_$1=yes],
578     [cf_cv_dcl_$1=no])
579 ])
580
581 if test "$cf_cv_dcl_$1" = no ; then
582     CF_UPPER(cf_result,decl_$1)
583     AC_DEFINE_UNQUOTED($cf_result)
584 fi
585
586 # It's possible (for near-UNIX clones) that the data doesn't exist
587 CF_CHECK_EXTERN_DATA($1,int)
588 ])dnl
589 dnl ---------------------------------------------------------------------------
590 dnl CF_CHECK_EXTERN_DATA version: 3 updated: 2001/12/30 18:03:23
591 dnl --------------------
592 dnl Check for existence of external data in the current set of libraries.  If
593 dnl we can modify it, it's real enough.
594 dnl $1 = the name to check
595 dnl $2 = its type
596 AC_DEFUN([CF_CHECK_EXTERN_DATA],
597 [
598 AC_CACHE_CHECK(if external $1 exists, cf_cv_have_$1,[
599     AC_TRY_LINK([
600 #undef $1
601 extern $2 $1;
602 ],
603     [$1 = 2],
604     [cf_cv_have_$1=yes],
605     [cf_cv_have_$1=no])
606 ])
607
608 if test "$cf_cv_have_$1" = yes ; then
609     CF_UPPER(cf_result,have_$1)
610     AC_DEFINE_UNQUOTED($cf_result)
611 fi
612
613 ])dnl
614 dnl ---------------------------------------------------------------------------
615 dnl CF_CHECK_GPM_WGETCH version: 1 updated: 2007/04/28 14:38:06
616 dnl -------------------
617 dnl Check if GPM is already linked with curses.  If so - and if the linkage
618 dnl is not "weak" - warn about this because it can create problems linking
619 dnl applications with ncurses.
620 AC_DEFUN([CF_CHECK_GPM_WGETCH],[
621 AC_CHECK_LIB(gpm,Gpm_Wgetch,[
622
623 AC_CACHE_CHECK(if GPM is weakly bound to curses library, cf_cv_check_gpm_wgetch,[
624 cf_cv_check_gpm_wgetch=unknown
625 if test "$cross_compiling" != yes ; then
626
627 cat >conftest.$ac_ext <<CF_EOF
628 #include <gpm.h>
629 int main()
630 {
631         Gpm_Wgetch();
632         ${cf_cv_main_return:-return}(0);
633 }
634 CF_EOF
635
636         cf_save_LIBS="$LIBS"
637         # This only works if we can look at the symbol table.  If a shared
638         # library is stripped for install, we cannot use that.  So we're forced
639         # to rely on the static library, noting that some packagers may not
640         # include it.
641         LIBS="-static -lgpm -dynamic $LIBS"
642         if AC_TRY_EVAL(ac_compile) ; then
643                 if AC_TRY_EVAL(ac_link) ; then
644                         cf_cv_check_gpm_wgetch=`nm conftest$ac_exeext | egrep '\<wgetch\>' | egrep '\<[[vVwW]]\>'`
645                         test -n "$cf_cv_check_gpm_wgetch" && cf_cv_check_gpm_wgetch=yes
646                         test -z "$cf_cv_check_gpm_wgetch" && cf_cv_check_gpm_wgetch=no
647                 fi
648         fi
649         rm -f conftest*
650         LIBS="$cf_save_LIBS"
651 fi
652 ])
653
654 if test "$cf_cv_check_gpm_wgetch" != yes ; then
655         AC_MSG_WARN(GPM library is already linked with curses - read the FAQ)
656 fi
657 ])])dnl
658 dnl ---------------------------------------------------------------------------
659 dnl CF_CPP_PARAM_INIT version: 4 updated: 2001/04/07 22:31:18
660 dnl -----------------
661 dnl Check if the C++ compiler accepts duplicate parameter initialization.  This
662 dnl is a late feature for the standard and is not in some recent compilers
663 dnl (1999/9/11).
664 AC_DEFUN([CF_CPP_PARAM_INIT],
665 [
666 if test -n "$CXX"; then
667 AC_CACHE_CHECK(if $CXX accepts parameter initialization,cf_cv_cpp_param_init,[
668         AC_LANG_SAVE
669         AC_LANG_CPLUSPLUS
670         AC_TRY_RUN([
671 class TEST {
672 private:
673         int value;
674 public:
675         TEST(int x = 1);
676         ~TEST();
677 };
678
679 TEST::TEST(int x = 1)   // some compilers do not like second initializer
680 {
681         value = x;
682 }
683 void main() { }
684 ],
685         [cf_cv_cpp_param_init=yes],
686         [cf_cv_cpp_param_init=no],
687         [cf_cv_cpp_param_init=unknown])
688         AC_LANG_RESTORE
689 ])
690 fi
691 test "$cf_cv_cpp_param_init" = yes && AC_DEFINE(CPP_HAS_PARAM_INIT)
692 ])dnl
693 dnl ---------------------------------------------------------------------------
694 dnl CF_CPP_STATIC_CAST version: 1 updated: 2005/07/23 16:52:43
695 dnl ------------------
696 dnl Check if the C++ compiler accepts static_cast in generics.  This appears to
697 dnl not be supported in g++ before 3.0
698 AC_DEFUN([CF_CPP_STATIC_CAST],
699 [
700 if test -n "$CXX"; then
701
702 AC_CACHE_CHECK(if $CXX accepts static_cast,cf_cv_cpp_static_cast,[
703         AC_LANG_SAVE
704         AC_LANG_CPLUSPLUS
705
706         AC_TRY_COMPILE([
707 class NCursesPanel
708 {
709 public:
710   NCursesPanel(int nlines,
711                int ncols,
712                int begin_y = 0,
713                int begin_x = 0)
714   {
715   }
716
717   ~NCursesPanel();
718 };
719
720 template<class T> class NCursesUserPanel : public NCursesPanel
721 {
722 public:
723   NCursesUserPanel (int nlines,
724                     int ncols,
725                     int begin_y = 0,
726                     int begin_x = 0,
727                     const T* p_UserData = static_cast<T*>(0))
728     : NCursesPanel (nlines, ncols, begin_y, begin_x)
729   {
730   };
731   NCursesUserPanel(const T* p_UserData = static_cast<T*>(0)) : NCursesPanel()
732   {
733   };
734
735   virtual ~NCursesUserPanel() {};
736 };
737 ],[
738         const char* p_UserData = static_cast<char*>(0)],
739         [cf_cv_cpp_static_cast=yes],
740         [cf_cv_cpp_static_cast=no])
741
742         AC_LANG_RESTORE
743 ])
744
745 fi
746
747 test "$cf_cv_cpp_static_cast" = yes && AC_DEFINE(CPP_HAS_STATIC_CAST)
748 ])dnl
749 dnl ---------------------------------------------------------------------------
750 dnl CF_C_INLINE version: 2 updated: 2007/08/11 14:09:50
751 dnl -----------
752 dnl Check if the C compiler supports "inline".
753 dnl $1 is the name of a shell variable to set if inline is supported
754 dnl $2 is the threshold for gcc 4.x's option controlling maximum inline size
755 AC_DEFUN([CF_C_INLINE],[
756 AC_C_INLINE
757 $1=
758 if test "$ac_cv_c_inline" != no ; then
759   $1=inline
760   if test "$INTEL_COMPILER" = yes
761   then
762     :
763   elif test "$GCC" = yes
764   then
765     AC_CACHE_CHECK(if gcc supports options to tune inlining,cf_cv_gcc_inline,[
766       cf_save_CFLAGS=$CFLAGS
767       CFLAGS="$CFLAGS --param max-inline-insns-single=$2"
768       AC_TRY_COMPILE([inline int foo(void) { return 1; }],
769       [${cf_cv_main_return:-return} foo()],
770       [cf_cv_gcc_inline=yes],
771       [cf_cv_gcc_inline=no])
772       CFLAGS=$cf_save_CFLAGS
773     ])
774     if test "$cf_cv_gcc_inline" = yes ; then
775         CF_ADD_CFLAGS([--param max-inline-insns-single=$2])
776     fi
777   fi
778 fi
779 AC_SUBST($1)
780 ])dnl
781 dnl ---------------------------------------------------------------------------
782 dnl CF_DIRNAME version: 4 updated: 2002/12/21 19:25:52
783 dnl ----------
784 dnl "dirname" is not portable, so we fake it with a shell script.
785 AC_DEFUN([CF_DIRNAME],[$1=`echo $2 | sed -e 's%/[[^/]]*$%%'`])dnl
786 dnl ---------------------------------------------------------------------------
787 dnl CF_DIRS_TO_MAKE version: 3 updated: 2002/02/23 20:38:31
788 dnl ---------------
789 AC_DEFUN([CF_DIRS_TO_MAKE],
790 [
791 DIRS_TO_MAKE="lib"
792 for cf_item in $cf_list_models
793 do
794         CF_OBJ_SUBDIR($cf_item,cf_subdir)
795         for cf_item2 in $DIRS_TO_MAKE
796         do
797                 test $cf_item2 = $cf_subdir && break
798         done
799         test ".$cf_item2" != ".$cf_subdir" && DIRS_TO_MAKE="$DIRS_TO_MAKE $cf_subdir"
800 done
801 for cf_dir in $DIRS_TO_MAKE
802 do
803         test ! -d $cf_dir && mkdir $cf_dir
804 done
805 AC_SUBST(DIRS_TO_MAKE)
806 ])dnl
807 dnl ---------------------------------------------------------------------------
808 dnl CF_DISABLE_LEAKS version: 4 updated: 2006/12/16 15:10:42
809 dnl ----------------
810 dnl Combine no-leak checks with the libraries or tools that are used for the
811 dnl checks.
812 AC_DEFUN([CF_DISABLE_LEAKS],[
813
814 AC_REQUIRE([CF_WITH_DMALLOC])
815 AC_REQUIRE([CF_WITH_DBMALLOC])
816 AC_REQUIRE([CF_WITH_VALGRIND])
817
818 AC_MSG_CHECKING(if you want to perform memory-leak testing)
819 AC_ARG_ENABLE(leaks,
820         [  --disable-leaks         test: free permanent memory, analyze leaks],
821         [with_no_leaks=yes],
822         : ${with_no_leaks:=no})
823 AC_MSG_RESULT($with_no_leaks)
824
825 if test "$with_no_leaks" = yes ; then
826         AC_DEFINE(NO_LEAKS)
827 fi
828 ])dnl
829 dnl ---------------------------------------------------------------------------
830 dnl CF_ERRNO version: 5 updated: 1997/11/30 12:44:39
831 dnl --------
832 dnl Check if 'errno' is declared in <errno.h>
833 AC_DEFUN([CF_ERRNO],
834 [
835 CF_CHECK_ERRNO(errno)
836 ])dnl
837 dnl ---------------------------------------------------------------------------
838 dnl CF_ETIP_DEFINES version: 3 updated: 2003/03/22 19:13:43
839 dnl ---------------
840 dnl Test for conflicting definitions of exception in gcc 2.8.0, etc., between
841 dnl math.h and builtin.h, only for ncurses
842 AC_DEFUN([CF_ETIP_DEFINES],
843 [
844 AC_MSG_CHECKING(for special defines needed for etip.h)
845 cf_save_CXXFLAGS="$CXXFLAGS"
846 cf_result="none"
847 for cf_math in "" MATH_H
848 do
849 for cf_excp in "" MATH_EXCEPTION
850 do
851         CXXFLAGS="$cf_save_CXXFLAGS -I${srcdir}/c++ -I${srcdir}/menu -I${srcdir}/include"
852         test -n "$cf_math" && CXXFLAGS="$CXXFLAGS -DETIP_NEEDS_${cf_math}"
853         test -n "$cf_excp" && CXXFLAGS="$CXXFLAGS -DETIP_NEEDS_${cf_excp}"
854 AC_TRY_COMPILE([
855 #include <etip.h.in>
856 ],[],[
857         test -n "$cf_math" && AC_DEFINE_UNQUOTED(ETIP_NEEDS_${cf_math})
858         test -n "$cf_excp" && AC_DEFINE_UNQUOTED(ETIP_NEEDS_${cf_excp})
859         cf_result="$cf_math $cf_excp"
860         break
861 ],[])
862 done
863 done
864 AC_MSG_RESULT($cf_result)
865 CXXFLAGS="$cf_save_CXXFLAGS"
866 ])
867 dnl ---------------------------------------------------------------------------
868 dnl CF_FUNC_DLSYM version: 1 updated: 2004/06/16 20:52:45
869 dnl -------------
870 dnl Test for dlsym() and related functions, as well as libdl.
871 dnl
872 dnl Sets
873 dnl     $cf_have_dlsym
874 dnl     $cf_have_libdl
875 AC_DEFUN([CF_FUNC_DLSYM],[
876 cf_have_dlsym=no
877 AC_CHECK_FUNC(dlsym,cf_have_dlsym=yes,[
878
879 cf_have_libdl=no
880 AC_CHECK_LIB(dl,dlsym,[
881         cf_have_dlsym=yes
882         cf_have_libdl=yes])])
883
884 if test "$cf_have_dlsym" = yes ; then
885         test "$cf_have_libdl" = yes && LIBS="-ldl $LIBS"
886
887         AC_MSG_CHECKING(whether able to link to dl*() functions)
888         AC_TRY_LINK([#include <dlfcn.h>],[
889                 void *obj;
890                 if ((obj = dlopen("filename", 0)) != 0) {
891                         if (dlsym(obj, "symbolname") == 0) {
892                         dlclose(obj);
893                         }
894                 }],[
895                 AC_DEFINE(HAVE_LIBDL)],[
896                 AC_MSG_ERROR(Cannot link test program for libdl)])
897         AC_MSG_RESULT(ok)
898 else
899         AC_MSG_ERROR(Cannot find dlsym function)
900 fi
901 ])
902 dnl ---------------------------------------------------------------------------
903 dnl CF_FUNC_MEMMOVE version: 7 updated: 2006/12/16 12:33:30
904 dnl ---------------
905 dnl Check for memmove, or a bcopy that can handle overlapping copy.  If neither
906 dnl is found, add our own version of memmove to the list of objects.
907 AC_DEFUN([CF_FUNC_MEMMOVE],
908 [
909 AC_CHECK_FUNC(memmove,,[
910 AC_CHECK_FUNC(bcopy,[
911         AC_CACHE_CHECK(if bcopy does overlapping moves,cf_cv_good_bcopy,[
912                 AC_TRY_RUN([
913 int main() {
914         static char data[] = "abcdefghijklmnopqrstuwwxyz";
915         char temp[40];
916         bcopy(data, temp, sizeof(data));
917         bcopy(temp+10, temp, 15);
918         bcopy(temp+5, temp+15, 10);
919         ${cf_cv_main_return:-return} (strcmp(temp, "klmnopqrstuwwxypqrstuwwxyz"));
920 }
921                 ],
922                 [cf_cv_good_bcopy=yes],
923                 [cf_cv_good_bcopy=no],
924                 [cf_cv_good_bcopy=unknown])
925                 ])
926         ],[cf_cv_good_bcopy=no])
927         if test "$cf_cv_good_bcopy" = yes ; then
928                 AC_DEFINE(USE_OK_BCOPY)
929         else
930                 AC_DEFINE(USE_MY_MEMMOVE)
931         fi
932 ])])dnl
933 dnl ---------------------------------------------------------------------------
934 dnl CF_FUNC_NANOSLEEP version: 3 updated: 2006/12/16 12:33:30
935 dnl -----------------
936 dnl Check for existence of workable nanosleep() function.  Some systems, e.g.,
937 dnl AIX 4.x, provide a non-working version.
938 AC_DEFUN([CF_FUNC_NANOSLEEP],[
939 AC_CACHE_CHECK(if nanosleep really works,cf_cv_func_nanosleep,[
940 AC_TRY_RUN([
941 #include <stdio.h>
942 #include <errno.h>
943 #include <time.h>
944
945 #ifdef HAVE_SYS_TIME_H
946 #include <sys/time.h>
947 #endif
948
949 int main() {
950         struct timespec ts1, ts2;
951         int code;
952         ts1.tv_sec  = 0;
953         ts1.tv_nsec = 750000000;
954         ts2.tv_sec  = 0;
955         ts2.tv_nsec = 0;
956         errno = 0;
957         code = nanosleep(&ts1, &ts2); /* on failure errno is ENOSYS. */
958         ${cf_cv_main_return:-return}(code != 0);
959 }
960 ],
961         [cf_cv_func_nanosleep=yes],
962         [cf_cv_func_nanosleep=no],
963         [cf_cv_func_nanosleep=unknown])])
964
965 test "$cf_cv_func_nanosleep" = "yes" && AC_DEFINE(HAVE_NANOSLEEP)
966 ])
967 dnl ---------------------------------------------------------------------------
968 dnl CF_FUNC_POLL version: 4 updated: 2006/12/16 12:33:30
969 dnl ------------
970 dnl See if the poll function really works.  Some platforms have poll(), but
971 dnl it does not work for terminals or files.
972 AC_DEFUN([CF_FUNC_POLL],[
973 AC_CACHE_CHECK(if poll really works,cf_cv_working_poll,[
974 AC_TRY_RUN([
975 #include <stdio.h>
976 #ifdef HAVE_POLL_H
977 #include <poll.h>
978 #else
979 #include <sys/poll.h>
980 #endif
981 int main() {
982         struct pollfd myfds;
983         int ret;
984
985         myfds.fd = 0;
986         myfds.events = POLLIN;
987
988         ret = poll(&myfds, 1, 100);
989         ${cf_cv_main_return:-return}(ret != 0);
990 }],
991         [cf_cv_working_poll=yes],
992         [cf_cv_working_poll=no],
993         [cf_cv_working_poll=unknown])])
994 test "$cf_cv_working_poll" = "yes" && AC_DEFINE(HAVE_WORKING_POLL)
995 ])dnl
996 dnl ---------------------------------------------------------------------------
997 dnl CF_FUNC_TERMIOS version: 2 updated: 2000/07/22 23:37:24
998 dnl ---------------
999 dnl Some old/broken variations define tcgetattr() only as a macro in
1000 dnl termio(s).h
1001 AC_DEFUN([CF_FUNC_TERMIOS],[
1002 AC_REQUIRE([CF_STRUCT_TERMIOS])
1003 AC_CACHE_CHECK(for tcgetattr, cf_cv_have_tcgetattr,[
1004 AC_TRY_LINK([
1005 #include <sys/types.h>
1006 #ifdef HAVE_UNISTD_H
1007 #include <unistd.h>
1008 #endif
1009 #ifdef HAVE_TERMIOS_H
1010 #include <termios.h>
1011 #define TTY struct termios
1012 #else
1013 #ifdef HAVE_TERMIO_H
1014 #include <termio.h>
1015 #define TTY struct termio
1016 #endif
1017 #endif
1018 ],[
1019 TTY foo;
1020 tcgetattr(1, &foo);],
1021 [cf_cv_have_tcgetattr=yes],
1022 [cf_cv_have_tcgetattr=no])])
1023 test "$cf_cv_have_tcgetattr" = yes && AC_DEFINE(HAVE_TCGETATTR)
1024 ])dnl
1025 dnl ---------------------------------------------------------------------------
1026 dnl CF_FUNC_VSSCANF version: 3 updated: 2001/12/19 00:50:10
1027 dnl ---------------
1028 dnl Check for vsscanf() function, which is in c9x but generally not in earlier
1029 dnl versions of C.  It is in the GNU C library, and can often be simulated by
1030 dnl other functions.
1031 AC_DEFUN([CF_FUNC_VSSCANF],
1032 [
1033 AC_CACHE_CHECK(for vsscanf function or workaround,cf_cv_func_vsscanf,[
1034 AC_TRY_LINK([
1035 #include <stdarg.h>
1036 #include <stdio.h>],[
1037         va_list ap;
1038         vsscanf("from", "%d", ap)],[cf_cv_func_vsscanf=vsscanf],[
1039 AC_TRY_LINK([
1040 #include <stdarg.h>
1041 #include <stdio.h>],[
1042     FILE strbuf;
1043     char *str = "from";
1044
1045     strbuf._flag = _IOREAD;
1046     strbuf._ptr = strbuf._base = (unsigned char *) str;
1047     strbuf._cnt = strlen(str);
1048     strbuf._file = _NFILE;
1049     return (vfscanf(&strbuf, "%d", ap))],[cf_cv_func_vsscanf=vfscanf],[
1050 AC_TRY_LINK([
1051 #include <stdarg.h>
1052 #include <stdio.h>],[
1053     FILE strbuf;
1054     char *str = "from";
1055
1056     strbuf._flag = _IOREAD;
1057     strbuf._ptr = strbuf._base = (unsigned char *) str;
1058     strbuf._cnt = strlen(str);
1059     strbuf._file = _NFILE;
1060     return (_doscan(&strbuf, "%d", ap))],[cf_cv_func_vsscanf=_doscan],[
1061 cf_cv_func_vsscanf=no])])])])
1062
1063 case $cf_cv_func_vsscanf in #(vi
1064 vsscanf) AC_DEFINE(HAVE_VSSCANF);; #(vi
1065 vfscanf) AC_DEFINE(HAVE_VFSCANF);; #(vi
1066 _doscan) AC_DEFINE(HAVE__DOSCAN);;
1067 esac
1068
1069 ])dnl
1070 dnl ---------------------------------------------------------------------------
1071 dnl CF_GCC_ATTRIBUTES version: 11 updated: 2007/07/29 09:55:12
1072 dnl -----------------
1073 dnl Test for availability of useful gcc __attribute__ directives to quiet
1074 dnl compiler warnings.  Though useful, not all are supported -- and contrary
1075 dnl to documentation, unrecognized directives cause older compilers to barf.
1076 AC_DEFUN([CF_GCC_ATTRIBUTES],
1077 [
1078 if test "$GCC" = yes
1079 then
1080 cat > conftest.i <<EOF
1081 #ifndef GCC_PRINTF
1082 #define GCC_PRINTF 0
1083 #endif
1084 #ifndef GCC_SCANF
1085 #define GCC_SCANF 0
1086 #endif
1087 #ifndef GCC_NORETURN
1088 #define GCC_NORETURN /* nothing */
1089 #endif
1090 #ifndef GCC_UNUSED
1091 #define GCC_UNUSED /* nothing */
1092 #endif
1093 EOF
1094 if test "$GCC" = yes
1095 then
1096         AC_CHECKING([for $CC __attribute__ directives])
1097 cat > conftest.$ac_ext <<EOF
1098 #line __oline__ "${as_me-configure}"
1099 #include "confdefs.h"
1100 #include "conftest.h"
1101 #include "conftest.i"
1102 #if     GCC_PRINTF
1103 #define GCC_PRINTFLIKE(fmt,var) __attribute__((format(printf,fmt,var)))
1104 #else
1105 #define GCC_PRINTFLIKE(fmt,var) /*nothing*/
1106 #endif
1107 #if     GCC_SCANF
1108 #define GCC_SCANFLIKE(fmt,var)  __attribute__((format(scanf,fmt,var)))
1109 #else
1110 #define GCC_SCANFLIKE(fmt,var)  /*nothing*/
1111 #endif
1112 extern void wow(char *,...) GCC_SCANFLIKE(1,2);
1113 extern void oops(char *,...) GCC_PRINTFLIKE(1,2) GCC_NORETURN;
1114 extern void foo(void) GCC_NORETURN;
1115 int main(int argc GCC_UNUSED, char *argv[[]] GCC_UNUSED) { return 0; }
1116 EOF
1117         for cf_attribute in scanf printf unused noreturn
1118         do
1119                 CF_UPPER(cf_ATTRIBUTE,$cf_attribute)
1120                 cf_directive="__attribute__(($cf_attribute))"
1121                 echo "checking for $CC $cf_directive" 1>&AC_FD_CC
1122                 case $cf_attribute in
1123                 scanf|printf)
1124                 cat >conftest.h <<EOF
1125 #define GCC_$cf_ATTRIBUTE 1
1126 EOF
1127                         ;;
1128                 *)
1129                 cat >conftest.h <<EOF
1130 #define GCC_$cf_ATTRIBUTE $cf_directive
1131 EOF
1132                         ;;
1133                 esac
1134                 if AC_TRY_EVAL(ac_compile); then
1135                         test -n "$verbose" && AC_MSG_RESULT(... $cf_attribute)
1136                         cat conftest.h >>confdefs.h
1137                 fi
1138         done
1139 else
1140         fgrep define conftest.i >>confdefs.h
1141 fi
1142 rm -rf conftest*
1143 fi
1144 ])dnl
1145 dnl ---------------------------------------------------------------------------
1146 dnl CF_GCC_VERSION version: 4 updated: 2005/08/27 09:53:42
1147 dnl --------------
1148 dnl Find version of gcc
1149 AC_DEFUN([CF_GCC_VERSION],[
1150 AC_REQUIRE([AC_PROG_CC])
1151 GCC_VERSION=none
1152 if test "$GCC" = yes ; then
1153         AC_MSG_CHECKING(version of $CC)
1154         GCC_VERSION="`${CC} --version| sed -e '2,$d' -e 's/^.*(GCC) //' -e 's/^[[^0-9.]]*//' -e 's/[[^0-9.]].*//'`"
1155         test -z "$GCC_VERSION" && GCC_VERSION=unknown
1156         AC_MSG_RESULT($GCC_VERSION)
1157 fi
1158 ])dnl
1159 dnl ---------------------------------------------------------------------------
1160 dnl CF_GCC_WARNINGS version: 22 updated: 2007/07/29 09:55:12
1161 dnl ---------------
1162 dnl Check if the compiler supports useful warning options.  There's a few that
1163 dnl we don't use, simply because they're too noisy:
1164 dnl
1165 dnl     -Wconversion (useful in older versions of gcc, but not in gcc 2.7.x)
1166 dnl     -Wredundant-decls (system headers make this too noisy)
1167 dnl     -Wtraditional (combines too many unrelated messages, only a few useful)
1168 dnl     -Wwrite-strings (too noisy, but should review occasionally).  This
1169 dnl             is enabled for ncurses using "--enable-const".
1170 dnl     -pedantic
1171 dnl
1172 dnl Parameter:
1173 dnl     $1 is an optional list of gcc warning flags that a particular
1174 dnl             application might want to use, e.g., "no-unused" for
1175 dnl             -Wno-unused
1176 dnl Special:
1177 dnl     If $with_ext_const is "yes", add a check for -Wwrite-strings
1178 dnl
1179 AC_DEFUN([CF_GCC_WARNINGS],
1180 [
1181 AC_REQUIRE([CF_GCC_VERSION])
1182 CF_INTEL_COMPILER(GCC,INTEL_COMPILER,CFLAGS)
1183
1184 cat > conftest.$ac_ext <<EOF
1185 #line __oline__ "${as_me-configure}"
1186 int main(int argc, char *argv[[]]) { return (argv[[argc-1]] == 0) ; }
1187 EOF
1188
1189 if test "$INTEL_COMPILER" = yes
1190 then
1191 # The "-wdXXX" options suppress warnings:
1192 # remark #1419: external declaration in primary source file
1193 # remark #1682: implicit conversion of a 64-bit integral type to a smaller integral type (potential portability problem)
1194 # remark #1683: explicit conversion of a 64-bit integral type to a smaller integral type (potential portability problem)
1195 # remark #1684: conversion from pointer to same-sized integral type (potential portability problem)
1196 # remark #193: zero used for undefined preprocessing identifier
1197 # remark #593: variable "curs_sb_left_arrow" was set but never used
1198 # remark #810: conversion from "int" to "Dimension={unsigned short}" may lose significant bits
1199 # remark #869: parameter "tw" was never referenced
1200 # remark #981: operands are evaluated in unspecified order
1201 # warning #269: invalid format string conversion
1202
1203         AC_CHECKING([for $CC warning options])
1204         cf_save_CFLAGS="$CFLAGS"
1205         EXTRA_CFLAGS="-Wall"
1206         for cf_opt in \
1207                 wd1419 \
1208                 wd1682 \
1209                 wd1683 \
1210                 wd1684 \
1211                 wd193 \
1212                 wd279 \
1213                 wd593 \
1214                 wd810 \
1215                 wd869 \
1216                 wd981
1217         do
1218                 CFLAGS="$cf_save_CFLAGS $EXTRA_CFLAGS -$cf_opt"
1219                 if AC_TRY_EVAL(ac_compile); then
1220                         test -n "$verbose" && AC_MSG_RESULT(... -$cf_opt)
1221                         EXTRA_CFLAGS="$EXTRA_CFLAGS -$cf_opt"
1222                 fi
1223         done
1224         CFLAGS="$cf_save_CFLAGS"
1225
1226 elif test "$GCC" = yes
1227 then
1228         AC_CHECKING([for $CC warning options])
1229         cf_save_CFLAGS="$CFLAGS"
1230         EXTRA_CFLAGS="-W -Wall"
1231         cf_warn_CONST=""
1232         test "$with_ext_const" = yes && cf_warn_CONST="Wwrite-strings"
1233         for cf_opt in \
1234                 Wbad-function-cast \
1235                 Wcast-align \
1236                 Wcast-qual \
1237                 Winline \
1238                 Wmissing-declarations \
1239                 Wmissing-prototypes \
1240                 Wnested-externs \
1241                 Wpointer-arith \
1242                 Wshadow \
1243                 Wstrict-prototypes \
1244                 Wundef $cf_warn_CONST $1
1245         do
1246                 CFLAGS="$cf_save_CFLAGS $EXTRA_CFLAGS -$cf_opt"
1247                 if AC_TRY_EVAL(ac_compile); then
1248                         test -n "$verbose" && AC_MSG_RESULT(... -$cf_opt)
1249                         case $cf_opt in #(vi
1250                         Wcast-qual) #(vi
1251                                 CPPFLAGS="$CPPFLAGS -DXTSTRINGDEFINES"
1252                                 ;;
1253                         Winline) #(vi
1254                                 case $GCC_VERSION in
1255                                 3.3*)
1256                                         CF_VERBOSE(feature is broken in gcc $GCC_VERSION)
1257                                         continue;;
1258                                 esac
1259                                 ;;
1260                         esac
1261                         EXTRA_CFLAGS="$EXTRA_CFLAGS -$cf_opt"
1262                 fi
1263         done
1264         CFLAGS="$cf_save_CFLAGS"
1265 fi
1266 rm -f conftest*
1267
1268 AC_SUBST(EXTRA_CFLAGS)
1269 ])dnl
1270 dnl ---------------------------------------------------------------------------
1271 dnl CF_GNAT_TRY_LINK version: 1 updated: 2004/08/21 19:02:08
1272 dnl ----------------
1273 dnl Verify that a test program compiles/links with GNAT.
1274 dnl $cf_ada_make is set to the program that compiles/links
1275 dnl $ADAFLAGS may be set to the GNAT flags.
1276 dnl
1277 dnl $1 is the text of the spec
1278 dnl $2 is the text of the body
1279 dnl $3 is the shell command to execute if successful
1280 dnl $4 is the shell command to execute if not successful
1281 AC_DEFUN([CF_GNAT_TRY_LINK],
1282 [
1283 rm -f conftest*
1284 cat >>conftest.ads <<CF_EOF
1285 $1
1286 CF_EOF
1287 cat >>conftest.adb <<CF_EOF
1288 $2
1289 CF_EOF
1290 if ( $cf_ada_make $ADAFLAGS conftest 1>&AC_FD_CC 2>&1 ) ; then
1291 ifelse($3,,      :,[      $3])
1292 ifelse($4,,,[else
1293    $4])
1294 fi
1295 rm -f conftest*
1296 ])dnl
1297 dnl ---------------------------------------------------------------------------
1298 dnl CF_GNAT_TRY_RUN version: 3 updated: 2004/08/21 19:02:08
1299 dnl ---------------
1300 dnl Verify that a test program compiles and runs with GNAT
1301 dnl $cf_ada_make is set to the program that compiles/links
1302 dnl $ADAFLAGS may be set to the GNAT flags.
1303 dnl
1304 dnl $1 is the text of the spec
1305 dnl $2 is the text of the body
1306 dnl $3 is the shell command to execute if successful
1307 dnl $4 is the shell command to execute if not successful
1308 AC_DEFUN([CF_GNAT_TRY_RUN],
1309 [
1310 rm -f conftest*
1311 cat >>conftest.ads <<CF_EOF
1312 $1
1313 CF_EOF
1314 cat >>conftest.adb <<CF_EOF
1315 $2
1316 CF_EOF
1317 if ( $cf_ada_make $ADAFLAGS conftest 1>&AC_FD_CC 2>&1 ) ; then
1318    if ( ./conftest 1>&AC_FD_CC 2>&1 ) ; then
1319 ifelse($3,,      :,[      $3])
1320 ifelse($4,,,[   else
1321       $4])
1322    fi
1323 ifelse($4,,,[else
1324    $4])
1325 fi
1326 rm -f conftest*
1327 ])dnl
1328 dnl ---------------------------------------------------------------------------
1329 dnl CF_GNAT_VERSION version: 12 updated: 2006/10/14 15:23:15
1330 dnl ---------------
1331 dnl Verify version of GNAT.
1332 AC_DEFUN([CF_GNAT_VERSION],
1333 [
1334 AC_MSG_CHECKING(for gnat version)
1335 cf_gnat_version=`${cf_ada_make-gnatmake} -v 2>&1 | grep '[[0-9]].[[0-9]][[0-9]]*' |\
1336   sed -e '2,$d' -e 's/[[^0-9 \.]]//g' -e 's/^[[ ]]*//' -e 's/ .*//'`
1337 AC_MSG_RESULT($cf_gnat_version)
1338
1339 case $cf_gnat_version in
1340   3.1[[1-9]]*|3.[[2-9]]*|[[4-9]].*)
1341     cf_cv_prog_gnat_correct=yes
1342     ;;
1343   *) echo Unsupported GNAT version $cf_gnat_version. Required is 3.11 or better. Disabling Ada95 binding.
1344      cf_cv_prog_gnat_correct=no
1345      ;;
1346 esac
1347 case $cf_gnat_version in
1348   3.[[1-9]]*|[[4-9]].*)
1349       cf_compile_generics=generics
1350       cf_generic_objects="\${GENOBJS}"
1351       ;;
1352   *)  cf_compile_generics=
1353       cf_generic_objects=
1354       ;;
1355 esac
1356 ])
1357 dnl ---------------------------------------------------------------------------
1358 dnl CF_GNU_SOURCE version: 6 updated: 2005/07/09 13:23:07
1359 dnl -------------
1360 dnl Check if we must define _GNU_SOURCE to get a reasonable value for
1361 dnl _XOPEN_SOURCE, upon which many POSIX definitions depend.  This is a defect
1362 dnl (or misfeature) of glibc2, which breaks portability of many applications,
1363 dnl since it is interwoven with GNU extensions.
1364 dnl
1365 dnl Well, yes we could work around it...
1366 AC_DEFUN([CF_GNU_SOURCE],
1367 [
1368 AC_CACHE_CHECK(if we must define _GNU_SOURCE,cf_cv_gnu_source,[
1369 AC_TRY_COMPILE([#include <sys/types.h>],[
1370 #ifndef _XOPEN_SOURCE
1371 make an error
1372 #endif],
1373         [cf_cv_gnu_source=no],
1374         [cf_save="$CPPFLAGS"
1375          CPPFLAGS="$CPPFLAGS -D_GNU_SOURCE"
1376          AC_TRY_COMPILE([#include <sys/types.h>],[
1377 #ifdef _XOPEN_SOURCE
1378 make an error
1379 #endif],
1380         [cf_cv_gnu_source=no],
1381         [cf_cv_gnu_source=yes])
1382         CPPFLAGS="$cf_save"
1383         ])
1384 ])
1385 test "$cf_cv_gnu_source" = yes && CPPFLAGS="$CPPFLAGS -D_GNU_SOURCE"
1386 ])dnl
1387 dnl ---------------------------------------------------------------------------
1388 dnl CF_GPP_LIBRARY version: 8 updated: 2003/02/02 01:41:46
1389 dnl --------------
1390 dnl If we're trying to use g++, test if libg++ is installed (a rather common
1391 dnl problem :-).  If we have the compiler but no library, we'll be able to
1392 dnl configure, but won't be able to build the c++ demo program.
1393 AC_DEFUN([CF_GPP_LIBRARY],
1394 [
1395 cf_cxx_library=unknown
1396 case $cf_cv_system_name in #(vi
1397 os2*) #(vi
1398         cf_gpp_libname=gpp
1399         ;;
1400 *)
1401         cf_gpp_libname=g++
1402         ;;
1403 esac
1404 if test "$GXX" = yes; then
1405         AC_MSG_CHECKING([for lib$cf_gpp_libname])
1406         cf_save="$LIBS"
1407         LIBS="$LIBS -l$cf_gpp_libname"
1408         AC_TRY_LINK([
1409 #include <$cf_gpp_libname/builtin.h>
1410         ],
1411         [two_arg_error_handler_t foo2 = lib_error_handler],
1412         [cf_cxx_library=yes
1413          CXXLIBS="$CXXLIBS -l$cf_gpp_libname"
1414          if test "$cf_gpp_libname" = cpp ; then
1415             AC_DEFINE(HAVE_GPP_BUILTIN_H)
1416          else
1417             AC_DEFINE(HAVE_GXX_BUILTIN_H)
1418          fi],
1419         [AC_TRY_LINK([
1420 #include <builtin.h>
1421         ],
1422         [two_arg_error_handler_t foo2 = lib_error_handler],
1423         [cf_cxx_library=yes
1424          CXXLIBS="$CXXLIBS -l$cf_gpp_libname"
1425          AC_DEFINE(HAVE_BUILTIN_H)],
1426         [cf_cxx_library=no])])
1427         LIBS="$cf_save"
1428         AC_MSG_RESULT($cf_cxx_library)
1429 fi
1430 ])dnl
1431 dnl ---------------------------------------------------------------------------
1432 dnl CF_GXX_VERSION version: 5 updated: 2005/08/27 09:53:42
1433 dnl --------------
1434 dnl Check for version of g++
1435 AC_DEFUN([CF_GXX_VERSION],[
1436 AC_REQUIRE([AC_PROG_CPP])
1437 GXX_VERSION=none
1438 if test "$GXX" = yes; then
1439         AC_MSG_CHECKING(version of g++)
1440         GXX_VERSION="`${CXX-g++} --version| sed -e '2,$d' -e 's/^.*(GCC) //' -e 's/^[[^0-9.]]*//' -e 's/[[^0-9.]].*//'`"
1441         test -z "$GXX_VERSION" && GXX_VERSION=unknown
1442         AC_MSG_RESULT($GXX_VERSION)
1443 fi
1444 ])dnl
1445 dnl ---------------------------------------------------------------------------
1446 dnl CF_GXX_WARNINGS version: 5 updated: 2005/08/13 14:54:38
1447 dnl ---------------
1448 dnl Check if the compiler supports useful warning options.
1449 dnl
1450 dnl Most of gcc's options apply to g++, except:
1451 dnl     -Wbad-function-cast
1452 dnl     -Wmissing-declarations
1453 dnl     -Wnested-externs
1454 dnl
1455 dnl Omit a few (for now):
1456 dnl     -Winline
1457 dnl
1458 dnl Parameter:
1459 dnl     $1 is an optional list of g++ warning flags that a particular
1460 dnl             application might want to use, e.g., "no-unused" for
1461 dnl             -Wno-unused
1462 dnl Special:
1463 dnl     If $with_ext_const is "yes", add a check for -Wwrite-strings
1464 dnl
1465 AC_DEFUN([CF_GXX_WARNINGS],
1466 [
1467
1468 CF_INTEL_COMPILER(GXX,INTEL_CPLUSPLUS,CXXFLAGS)
1469
1470 AC_REQUIRE([CF_GXX_VERSION])
1471
1472 AC_LANG_SAVE
1473 AC_LANG_CPLUSPLUS
1474
1475 cat > conftest.$ac_ext <<EOF
1476 #line __oline__ "configure"
1477 int main(int argc, char *argv[[]]) { return (argv[[argc-1]] == 0) ; }
1478 EOF
1479
1480 if test "$INTEL_CPLUSPLUS" = yes
1481 then
1482 # The "-wdXXX" options suppress warnings:
1483 # remark #1419: external declaration in primary source file
1484 # remark #1682: implicit conversion of a 64-bit integral type to a smaller integral type (potential portability problem)
1485 # remark #1683: explicit conversion of a 64-bit integral type to a smaller integral type (potential portability problem)
1486 # remark #1684: conversion from pointer to same-sized integral type (potential portability problem)
1487 # remark #193: zero used for undefined preprocessing identifier
1488 # remark #593: variable "curs_sb_left_arrow" was set but never used
1489 # remark #810: conversion from "int" to "Dimension={unsigned short}" may lose significant bits
1490 # remark #869: parameter "tw" was never referenced
1491 # remark #981: operands are evaluated in unspecified order
1492 # warning #269: invalid format string conversion
1493
1494         AC_CHECKING([for $CC warning options])
1495         cf_save_CXXFLAGS="$CXXFLAGS"
1496         EXTRA_CXXFLAGS="-Wall"
1497         for cf_opt in \
1498                 wd1419 \
1499                 wd1682 \
1500                 wd1683 \
1501                 wd1684 \
1502                 wd193 \
1503                 wd279 \
1504                 wd593 \
1505                 wd810 \
1506                 wd869 \
1507                 wd981
1508         do
1509                 CXXFLAGS="$cf_save_CXXFLAGS $EXTRA_CXXFLAGS -$cf_opt"
1510                 if AC_TRY_EVAL(ac_compile); then
1511                         test -n "$verbose" && AC_MSG_RESULT(... -$cf_opt)
1512                         EXTRA_CXXFLAGS="$EXTRA_CXXFLAGS -$cf_opt"
1513                 fi
1514         done
1515         CXXFLAGS="$cf_save_CXXFLAGS"
1516
1517 elif test "$GXX" = yes
1518 then
1519         AC_CHECKING([for $CXX warning options])
1520         cf_save_CXXFLAGS="$CXXFLAGS"
1521         EXTRA_CXXFLAGS="-W -Wall"
1522         cf_gxx_extra_warnings=""
1523         test "$with_ext_const" = yes && cf_gxx_extra_warnings="Wwrite-strings"
1524         case "$GCC_VERSION" in
1525         [[1-2]].*)
1526                 ;;
1527         *)
1528                 cf_gxx_extra_warnings="$cf_gxx_extra_warnings Weffc++"
1529                 ;;
1530         esac
1531         for cf_opt in \
1532                 Wabi \
1533                 fabi-version=0 \
1534                 Woverloaded-virtual \
1535                 Wsign-promo \
1536                 Wsynth \
1537                 Wold-style-cast \
1538                 Wcast-align \
1539                 Wcast-qual \
1540                 Wmissing-prototypes \
1541                 Wpointer-arith \
1542                 Wshadow \
1543                 Wstrict-prototypes \
1544                 Wundef $cf_gxx_extra_warnings $1
1545         do
1546                 CXXFLAGS="$cf_save_CXXFLAGS $EXTRA_CXXFLAGS -Werror -$cf_opt"
1547                 if AC_TRY_EVAL(ac_compile); then
1548                         test -n "$verbose" && AC_MSG_RESULT(... -$cf_opt)
1549                         EXTRA_CXXFLAGS="$EXTRA_CXXFLAGS -$cf_opt"
1550                 else
1551                         test -n "$verbose" && AC_MSG_RESULT(... no -$cf_opt)
1552                 fi
1553         done
1554         CXXFLAGS="$cf_save_CXXFLAGS"
1555 fi
1556
1557 rm -f conftest*
1558 AC_LANG_RESTORE
1559 AC_SUBST(EXTRA_CXXFLAGS)
1560 ])dnl
1561 dnl ---------------------------------------------------------------------------
1562 dnl CF_HASHED_DB version: 1 updated: 2006/08/19 09:16:14
1563 dnl ------------
1564 dnl Look for an instance of the Berkeley hashed database.
1565 AC_DEFUN([CF_HASHED_DB],
1566 [
1567 AC_CHECK_HEADER(db.h,[
1568 CF_HASHED_DB_VERSION
1569 if test "$cf_cv_hashed_db_version" = unknown ; then
1570         AC_MSG_ERROR(Cannot determine version of db)
1571 else
1572         CF_HASHED_DB_LIBS
1573         if test "$cf_cv_hashed_db_libs" = unknown ; then
1574                 AC_MSG_ERROR(Cannot determine library for db)
1575         elif test "$cf_cv_hashed_db_libs" != default ; then
1576                 LIBS="-l$cf_cv_hashed_db_libs $LIBS"
1577         fi
1578 fi
1579 ],[
1580         AC_MSG_ERROR(Cannot find db.h)
1581 ])
1582 ])dnl
1583 dnl ---------------------------------------------------------------------------
1584 dnl CF_HASHED_DB_LIBS version: 6 updated: 2006/12/16 12:33:30
1585 dnl -----------------
1586 dnl Given that we have the header and version for hashed database, find the
1587 dnl library information.
1588 AC_DEFUN([CF_HASHED_DB_LIBS],
1589 [
1590 AC_CACHE_CHECK(for db libraries, cf_cv_hashed_db_libs,[
1591 cf_cv_hashed_db_libs=unknown
1592 for cf_db_libs in db$cf_cv_hashed_db_version db ''
1593 do
1594         cf_save_libs="$LIBS"
1595         if test -n "$cf_db_libs"; then
1596                 LIBS="-l$cf_db_libs $LIBS"
1597         fi
1598         CF_MSG_LOG(checking for library "$cf_db_libs")
1599         AC_TRY_LINK([
1600 $ac_includes_default
1601 #include <db.h>
1602 ],[
1603         char *path = "/tmp/foo";
1604 #ifdef DB_VERSION_MAJOR
1605 #if DB_VERSION_MAJOR >= 4
1606         DB *result = 0;
1607         db_create(&result, NULL, 0);
1608         result->open(result,
1609                 NULL,
1610                 path,
1611                 path,
1612                 DB_HASH,
1613                 DB_CREATE,
1614                 0644);
1615 #elif DB_VERSION_MAJOR >= 3
1616         DB *result = 0;
1617         db_create(&result, NULL, 0);
1618         result->open(result,
1619                 path,
1620                 path,
1621                 DB_HASH,
1622                 DB_CREATE,
1623                 0644);
1624 #elif DB_VERSION_MAJOR >= 2
1625         DB *result = 0;
1626         db_open(path,
1627                 DB_HASH,
1628                 DB_CREATE,
1629                 0644,
1630                 (DB_ENV *) 0,
1631                 (DB_INFO *) 0,
1632                 &result);
1633 #endif /* DB_VERSION_MAJOR */
1634 #else
1635         DB *result = dbopen(path,
1636                      2,
1637                      0644,
1638                      DB_HASH,
1639                      0);
1640 #endif
1641         ${cf_cv_main_return:-return}(result != 0)
1642 ],[
1643         if test -n "$cf_db_libs" ; then
1644                 cf_cv_hashed_db_libs=$cf_db_libs
1645         else
1646                 cf_cv_hashed_db_libs=default
1647         fi
1648         LIBS="$cf_save_libs"
1649         break
1650 ])
1651         LIBS="$cf_save_libs"
1652 done
1653 ])
1654 ])dnl
1655 dnl ---------------------------------------------------------------------------
1656 dnl CF_HASHED_DB_VERSION version: 2 updated: 2006/08/19 15:12:49
1657 dnl --------------------
1658 dnl Given that we have the header file for hashed database, find the version
1659 dnl information.
1660 AC_DEFUN([CF_HASHED_DB_VERSION],
1661 [
1662 AC_CACHE_CHECK(for version of db, cf_cv_hashed_db_version,[
1663 cf_cv_hashed_db_version=unknown
1664
1665 for cf_db_version in 1 2 3 4
1666 do
1667         CF_MSG_LOG(checking for db version $cf_db_version)
1668         AC_TRY_COMPILE([
1669 $ac_includes_default
1670 #include <db.h>
1671
1672 #ifdef DB_VERSION_MAJOR
1673         /* db2 (DB_VERSION_MAJOR=2) has also DB_VERSION_MINOR, tested with 7 */
1674 #if $cf_db_version == DB_VERSION_MAJOR
1675         /* ok */
1676 #else
1677         make an error
1678 #endif
1679 #else
1680 #if $cf_db_version == 1
1681         /* ok: assuming this is DB 1.8.5 */
1682 #else
1683         make an error
1684 #endif
1685 #endif
1686 ],[DBT *foo = 0],[
1687         cf_cv_hashed_db_version=$cf_db_version
1688         break
1689         ])
1690 done
1691 ])
1692 ])dnl
1693 dnl ---------------------------------------------------------------------------
1694 dnl CF_HELP_MESSAGE version: 3 updated: 1998/01/14 10:56:23
1695 dnl ---------------
1696 dnl Insert text into the help-message, for readability, from AC_ARG_WITH.
1697 AC_DEFUN([CF_HELP_MESSAGE],
1698 [AC_DIVERT_HELP([$1])dnl
1699 ])dnl
1700 dnl ---------------------------------------------------------------------------
1701 dnl CF_INCLUDE_DIRS version: 5 updated: 2006/10/14 15:23:15
1702 dnl ---------------
1703 dnl Construct the list of include-options according to whether we're building
1704 dnl in the source directory or using '--srcdir=DIR' option.  If we're building
1705 dnl with gcc, don't append the includedir if it happens to be /usr/include,
1706 dnl since that usually breaks gcc's shadow-includes.
1707 AC_DEFUN([CF_INCLUDE_DIRS],
1708 [
1709 CPPFLAGS="-I. -I../include $CPPFLAGS"
1710 if test "$srcdir" != "."; then
1711         CPPFLAGS="-I\${srcdir}/../include $CPPFLAGS"
1712 fi
1713 if test "$GCC" != yes; then
1714         CPPFLAGS="$CPPFLAGS -I\${includedir}"
1715 elif test "$includedir" != "/usr/include"; then
1716         if test "$includedir" = '${prefix}/include' ; then
1717                 if test $prefix != /usr ; then
1718                         CPPFLAGS="$CPPFLAGS -I\${includedir}"
1719                 fi
1720         else
1721                 CPPFLAGS="$CPPFLAGS -I\${includedir}"
1722         fi
1723 fi
1724 AC_SUBST(CPPFLAGS)
1725 ])dnl
1726 dnl ---------------------------------------------------------------------------
1727 dnl CF_INTEL_COMPILER version: 3 updated: 2005/08/06 18:37:29
1728 dnl -----------------
1729 dnl Check if the given compiler is really the Intel compiler for Linux.  It
1730 dnl tries to imitate gcc, but does not return an error when it finds a mismatch
1731 dnl between prototypes, e.g., as exercised by CF_MISSING_CHECK.
1732 dnl
1733 dnl This macro should be run "soon" after AC_PROG_CC or AC_PROG_CPLUSPLUS, to
1734 dnl ensure that it is not mistaken for gcc/g++.  It is normally invoked from
1735 dnl the wrappers for gcc and g++ warnings.
1736 dnl
1737 dnl $1 = GCC (default) or GXX
1738 dnl $2 = INTEL_COMPILER (default) or INTEL_CPLUSPLUS
1739 dnl $3 = CFLAGS (default) or CXXFLAGS
1740 AC_DEFUN([CF_INTEL_COMPILER],[
1741 ifelse($2,,INTEL_COMPILER,[$2])=no
1742
1743 if test "$ifelse($1,,[$1],GCC)" = yes ; then
1744         case $host_os in
1745         linux*|gnu*)
1746                 AC_MSG_CHECKING(if this is really Intel ifelse($1,GXX,C++,C) compiler)
1747                 cf_save_CFLAGS="$ifelse($3,,CFLAGS,[$3])"
1748                 ifelse($3,,CFLAGS,[$3])="$ifelse($3,,CFLAGS,[$3]) -no-gcc"
1749                 AC_TRY_COMPILE([],[
1750 #ifdef __INTEL_COMPILER
1751 #else
1752 make an error
1753 #endif
1754 ],[ifelse($2,,INTEL_COMPILER,[$2])=yes
1755 cf_save_CFLAGS="$cf_save_CFLAGS -we147 -no-gcc"
1756 ],[])
1757                 ifelse($3,,CFLAGS,[$3])="$cf_save_CFLAGS"
1758                 AC_MSG_RESULT($ifelse($2,,INTEL_COMPILER,[$2]))
1759                 ;;
1760         esac
1761 fi
1762 ])dnl
1763 dnl ---------------------------------------------------------------------------
1764 dnl CF_ISASCII version: 3 updated: 2000/08/12 23:18:52
1765 dnl ----------
1766 dnl Check if we have either a function or macro for 'isascii()'.
1767 AC_DEFUN([CF_ISASCII],
1768 [
1769 AC_MSG_CHECKING(for isascii)
1770 AC_CACHE_VAL(cf_cv_have_isascii,[
1771         AC_TRY_LINK([#include <ctype.h>],[int x = isascii(' ')],
1772         [cf_cv_have_isascii=yes],
1773         [cf_cv_have_isascii=no])
1774 ])dnl
1775 AC_MSG_RESULT($cf_cv_have_isascii)
1776 test "$cf_cv_have_isascii" = yes && AC_DEFINE(HAVE_ISASCII)
1777 ])dnl
1778 dnl ---------------------------------------------------------------------------
1779 dnl CF_LARGEFILE version: 7 updated: 2007/06/02 11:58:50
1780 dnl ------------
1781 dnl Add checks for large file support.
1782 AC_DEFUN([CF_LARGEFILE],[
1783 ifdef([AC_FUNC_FSEEKO],[
1784     AC_SYS_LARGEFILE
1785     if test "$enable_largefile" != no ; then
1786         AC_FUNC_FSEEKO
1787
1788         # Normally we would collect these definitions in the config.h,
1789         # but (like _XOPEN_SOURCE), some environments rely on having these
1790         # defined before any of the system headers are included.  Another
1791         # case comes up with C++, e.g., on AIX the compiler compiles the
1792         # header files by themselves before looking at the body files it is
1793         # told to compile.  For ncurses, those header files do not include
1794         # the config.h
1795         test "$ac_cv_sys_large_files"      != no && CPPFLAGS="$CPPFLAGS -D_LARGE_FILES "
1796         test "$ac_cv_sys_largefile_source" != no && CPPFLAGS="$CPPFLAGS -D_LARGEFILE_SOURCE "
1797         test "$ac_cv_sys_file_offset_bits" != no && CPPFLAGS="$CPPFLAGS -D_FILE_OFFSET_BITS=$ac_cv_sys_file_offset_bits "
1798
1799         AC_CACHE_CHECK(whether to use struct dirent64, cf_cv_struct_dirent64,[
1800                 AC_TRY_COMPILE([
1801 #include <sys/types.h>
1802 #include <dirent.h>
1803                 ],[
1804                 /* if transitional largefile support is setup, this is true */
1805                 extern struct dirent64 * readdir(DIR *);
1806                 struct dirent64 *x = readdir((DIR *)0);
1807                 struct dirent *y = readdir((DIR *)0);
1808                 int z = x - y;
1809                 ],
1810                 [cf_cv_struct_dirent64=yes],
1811                 [cf_cv_struct_dirent64=no])
1812         ])
1813         test "$cf_cv_struct_dirent64" = yes && AC_DEFINE(HAVE_STRUCT_DIRENT64)
1814     fi
1815 ])
1816 ])
1817 dnl ---------------------------------------------------------------------------
1818 dnl CF_LDFLAGS_STATIC version: 2 updated: 2007/04/28 15:25:27
1819 dnl -----------------
1820 dnl Check for compiler/linker flags used to temporarily force usage of static
1821 dnl libraries.  This depends on the compiler and platform.  Use this to help
1822 dnl ensure that the linker picks up a given library based on its position in
1823 dnl the list of linker options and libraries.
1824 AC_DEFUN([CF_LDFLAGS_STATIC],[
1825
1826 if test "$GCC" = yes ; then
1827         LDFLAGS_STATIC=-static
1828         LDFLAGS_SHARED=-dynamic
1829 else
1830         case $cf_cv_system_name in #(
1831         aix[[45]]*)     #( from ld manpage
1832                 LDFLAGS_STATIC=-bstatic
1833                 LDFLAGS_SHARED=-bdynamic
1834                 ;;
1835         hpux*)          #( from ld manpage for hpux10.20, hpux11.11
1836                 # We could also use just "archive" and "shared".
1837                 LDFLAGS_STATIC=-Wl,-a,archive_shared
1838                 LDFLAGS_SHARED=-Wl,-a,shared_archive
1839                 ;;
1840         irix*)          #( from ld manpage IRIX64
1841                 LDFLAGS_STATIC=-Bstatic
1842                 LDFLAGS_SHARED=-Bdynamic
1843                 ;;
1844         osf[[45]]*)     #( from ld manpage osf4.0d, osf5.1
1845                 # alternative "-oldstyle_liblookup" (not in cc manpage)
1846                 LDFLAGS_STATIC=-noso 
1847                 LDFLAGS_SHARED=-so_archive
1848                 ;;
1849         solaris2*)
1850                 LDFLAGS_STATIC=-Bstatic
1851                 LDFLAGS_SHARED=-Bdynamic
1852                 ;;
1853         esac
1854 fi
1855
1856 AC_SUBST(LDFLAGS_STATIC)
1857 AC_SUBST(LDFLAGS_SHARED)
1858 ])
1859 dnl ---------------------------------------------------------------------------
1860 dnl CF_LIBUTF8 version: 2 updated: 2002/01/19 22:51:32
1861 dnl ----------
1862 dnl Check for libutf8
1863 AC_DEFUN([CF_LIBUTF8],
1864 [
1865 AC_CACHE_CHECK(for putwc in libutf8,cf_cv_libutf8,[
1866         cf_save_LIBS="$LIBS"
1867         LIBS="-lutf8 $LIBS"
1868 AC_TRY_LINK([
1869 #include <libutf8.h>],[putwc(0,0);],
1870         [cf_cv_libutf8=yes],
1871         [cf_cv_libutf8=no])
1872         LIBS="$cf_save_LIBS"
1873 ])
1874
1875 if test "$cf_cv_libutf8" = yes ; then
1876         AC_DEFINE(HAVE_LIBUTF8_H)
1877         LIBS="-lutf8 $LIBS"
1878 fi
1879 ])dnl
1880 dnl ---------------------------------------------------------------------------
1881 dnl CF_LIB_PREFIX version: 7 updated: 2001/01/12 01:23:48
1882 dnl -------------
1883 dnl Compute the library-prefix for the given host system
1884 dnl $1 = variable to set
1885 AC_DEFUN([CF_LIB_PREFIX],
1886 [
1887         case $cf_cv_system_name in
1888         OS/2*)  LIB_PREFIX=''     ;;
1889         os2*)   LIB_PREFIX=''     ;;
1890         *)      LIB_PREFIX='lib'  ;;
1891         esac
1892 ifelse($1,,,[$1=$LIB_PREFIX])
1893         AC_SUBST(LIB_PREFIX)
1894 ])dnl
1895 dnl ---------------------------------------------------------------------------
1896 dnl CF_LIB_RULES version: 50 updated: 2007/03/24 18:26:59
1897 dnl ------------
1898 dnl Append definitions and rules for the given models to the subdirectory
1899 dnl Makefiles, and the recursion rule for the top-level Makefile.  If the
1900 dnl subdirectory is a library-source directory, modify the LIBS_TO_MAKE list in
1901 dnl the corresponding makefile to list the models that we'll generate.
1902 dnl
1903 dnl For shared libraries, make a list of symbolic links to construct when
1904 dnl generating each library.  The convention used for Linux is the simplest
1905 dnl one:
1906 dnl     lib<name>.so    ->
1907 dnl     lib<name>.so.<major>    ->
1908 dnl     lib<name>.so.<maj>.<minor>
1909 AC_DEFUN([CF_LIB_RULES],
1910 [
1911 CF_LIB_PREFIX(cf_prefix)
1912 AC_REQUIRE([CF_SUBST_NCURSES_VERSION])
1913 for cf_dir in $SRC_SUBDIRS
1914 do
1915         if test ! -d $srcdir/$cf_dir ; then
1916                 continue
1917         elif test -f $srcdir/$cf_dir/modules; then
1918
1919                 SHARED_LIB=
1920                 LIBS_TO_MAKE=
1921                 for cf_item in $cf_LIST_MODELS
1922                 do
1923                         CF_LIB_SUFFIX($cf_item,cf_suffix)
1924                         if test $cf_item = shared ; then
1925                         if test "$cf_cv_do_symlinks" = yes ; then
1926                                 case "$cf_cv_shlib_version" in #(vi
1927                                 rel) #(vi
1928                                         case "$cf_cv_system_name" in #(vi
1929                                         darwin*)
1930                                         case .${LIB_SUFFIX} in
1931                                         .w*)
1932                                                 cf_suffix=`echo $cf_suffix | sed 's/^w//'`
1933                                                 cf_suffix=w'.${REL_VERSION}'"$cf_suffix"
1934                                                 ;;
1935                                         *)
1936                                                 cf_suffix='.${REL_VERSION}'"$cf_suffix"
1937                                                 ;;
1938                                         esac
1939                                         ;; #(vi
1940                                         *) cf_suffix="$cf_suffix"'.${REL_VERSION}' ;;
1941                                         esac
1942                                         ;;
1943                                 abi)
1944                                         case "$cf_cv_system_name" in #(vi
1945                                         darwin*)
1946                                         case .${LIB_SUFFIX} in
1947                                         .w*)
1948                                                 cf_suffix=`echo $cf_suffix | sed 's/^w//'`
1949                                                 cf_suffix=w'.${ABI_VERSION}'"$cf_suffix"
1950                                                 ;;
1951                                         *)
1952                                                 cf_suffix='.${ABI_VERSION}'"$cf_suffix"
1953                                                 ;;
1954                                         esac
1955                                         ;; #(vi
1956                                         *) cf_suffix="$cf_suffix"'.${ABI_VERSION}' ;;
1957                                         esac
1958                                         ;;
1959                                 esac
1960                         fi
1961                         # cygwin needs import library, and has unique naming convention
1962                         # use autodetected ${cf_prefix} for import lib and static lib, but
1963                         # use 'cyg' prefix for shared lib.
1964                         if test $cf_cv_shlib_version = cygdll ; then
1965                                 LIBS_TO_MAKE="$LIBS_TO_MAKE ../lib/cyg${cf_dir}\${ABI_VERSION}.dll"
1966                                 continue
1967                         fi
1968                         fi
1969                         LIBS_TO_MAKE="$LIBS_TO_MAKE ../lib/${cf_prefix}${cf_dir}${cf_suffix}"
1970                 done
1971
1972                 if test $cf_dir = ncurses ; then
1973                         cf_subsets="$LIB_SUBSETS"
1974                         cf_r_parts="$cf_subsets"
1975
1976                         while test -n "$cf_r_parts"
1977                         do
1978                                 cf_l_parts=`echo "$cf_r_parts" |sed -e 's/ .*$//'`
1979                                 cf_r_parts=`echo "$cf_r_parts" |sed -e 's/^[[^ ]]* //'`
1980                                 if test "$cf_l_parts" != "$cf_r_parts" ; then
1981                                         case $cf_l_parts in #(vi
1982                                         *termlib*) #(vi
1983                                                 cf_item=`echo $LIBS_TO_MAKE |sed -e s%${LIB_NAME}${LIB_SUFFIX}%${TINFO_LIB_SUFFIX}%g`
1984                                                 ;;
1985                                         *ticlib*)
1986                                                 cf_item=`echo $LIBS_TO_MAKE |sed -e s%${LIB_NAME}${LIB_SUFFIX}%${TICS_LIB_SUFFIX}%g`
1987                                                 ;;
1988                                         *)
1989                                                 break
1990                                                 ;;
1991                                         esac
1992                                         LIBS_TO_MAKE="$cf_item $LIBS_TO_MAKE"
1993                                 else
1994                                         break
1995                                 fi
1996                         done
1997                 else
1998                         cf_subsets=`echo "$LIB_SUBSETS" | sed -e 's/^termlib.* //'`
1999                 fi
2000
2001                 sed -e "s%@LIBS_TO_MAKE@%$LIBS_TO_MAKE%" \
2002                     -e "s%@SHARED_LIB@%$SHARED_LIB%" \
2003                         $cf_dir/Makefile >$cf_dir/Makefile.out
2004                 mv $cf_dir/Makefile.out $cf_dir/Makefile
2005
2006                 $AWK -f $srcdir/mk-0th.awk \
2007                         libname="${cf_dir}${LIB_SUFFIX}" subsets="$LIB_SUBSETS" \
2008                         $srcdir/$cf_dir/modules >>$cf_dir/Makefile
2009
2010                 for cf_subset in $cf_subsets
2011                 do
2012                         cf_subdirs=
2013                         for cf_item in $cf_LIST_MODELS
2014                         do
2015                         echo "Appending rules for ${cf_item} model (${cf_dir}: ${cf_subset})"
2016                         CF_UPPER(cf_ITEM,$cf_item)
2017                         CF_LIB_SUFFIX($cf_item,cf_suffix)
2018                         CF_OBJ_SUBDIR($cf_item,cf_subdir)
2019
2020                         # Test for case where we build libtinfo with a different name.
2021                         cf_libname=$cf_dir
2022                         if test $cf_dir = ncurses ; then
2023                                 case $cf_subset in
2024                                 *base*)
2025                                         ;;
2026                                 *termlib*)
2027                                         cf_libname=$TINFO_LIB_SUFFIX
2028                                         if test -n "${DFT_ARG_SUFFIX}" ; then
2029                                                 # undo $LIB_SUFFIX add-on in CF_LIB_SUFFIX
2030                                                 cf_suffix=`echo $cf_suffix |sed -e "s%^${LIB_SUFFIX}%%"`
2031                                         fi
2032                                         ;;
2033                                 ticlib*)
2034                                         cf_libname=$TICS_LIB_SUFFIX
2035                                         if test -n "${DFT_ARG_SUFFIX}" ; then
2036                                                 # undo $LIB_SUFFIX add-on in CF_LIB_SUFFIX
2037                                                 cf_suffix=`echo $cf_suffix |sed -e "s%^${LIB_SUFFIX}%%"`
2038                                         fi
2039                                         ;;
2040                                 esac
2041                         fi
2042
2043                         # These dependencies really are for development, not
2044                         # builds, but they are useful in porting, too.
2045                         cf_depend="../include/ncurses_cfg.h"
2046                         if test "$srcdir" = "."; then
2047                                 cf_reldir="."
2048                         else
2049                                 cf_reldir="\${srcdir}"
2050                         fi
2051
2052                         if test -f $srcdir/$cf_dir/$cf_dir.priv.h; then
2053                                 cf_depend="$cf_depend $cf_reldir/$cf_dir.priv.h"
2054                         elif test -f $srcdir/$cf_dir/curses.priv.h; then
2055                                 cf_depend="$cf_depend $cf_reldir/curses.priv.h"
2056                         fi
2057
2058                         cf_dir_suffix=
2059                         old_cf_suffix="$cf_suffix"
2060                         if test "$cf_cv_shlib_version_infix" = yes ; then
2061                         if test -n "$LIB_SUFFIX" ; then
2062                                 case $LIB_SUFFIX in
2063                                 w*)
2064                                         cf_libname=`echo $cf_libname | sed 's/w$//'`
2065                                         cf_suffix=`echo $cf_suffix | sed 's/^w//'`
2066                                         cf_dir_suffix=w
2067                                         ;;
2068                                 esac
2069                         fi
2070                         fi
2071
2072                         $AWK -f $srcdir/mk-1st.awk \
2073                                 name=${cf_libname}${cf_dir_suffix} \
2074                                 traces=$LIB_TRACING \
2075                                 MODEL=$cf_ITEM \
2076                                 model=$cf_subdir \
2077                                 prefix=$cf_prefix \
2078                                 suffix=$cf_suffix \
2079                                 subset=$cf_subset \
2080                                 TermlibRoot=$TINFO_NAME \
2081                                 TermlibSuffix=$TINFO_SUFFIX \
2082                                 ShlibVer=$cf_cv_shlib_version \
2083                                 ShlibVerInfix=$cf_cv_shlib_version_infix \
2084                                 ReLink=${cf_cv_do_relink-no} \
2085                                 DoLinks=$cf_cv_do_symlinks \
2086                                 rmSoLocs=$cf_cv_rm_so_locs \
2087                                 ldconfig="$LDCONFIG" \
2088                                 overwrite=$WITH_OVERWRITE \
2089                                 depend="$cf_depend" \
2090                                 host="$host" \
2091                                 $srcdir/$cf_dir/modules >>$cf_dir/Makefile
2092
2093                         cf_suffix="$old_cf_suffix"
2094
2095                         for cf_subdir2 in $cf_subdirs lib
2096                         do
2097                                 test $cf_subdir = $cf_subdir2 && break
2098                         done
2099                         test "${cf_subset}.${cf_subdir2}" != "${cf_subset}.${cf_subdir}" && \
2100                         $AWK -f $srcdir/mk-2nd.awk \
2101                                 name=$cf_dir \
2102                                 traces=$LIB_TRACING \
2103                                 MODEL=$cf_ITEM \
2104                                 model=$cf_subdir \
2105                                 subset=$cf_subset \
2106                                 srcdir=$srcdir \
2107                                 echo=$WITH_ECHO \
2108                                 crenames=$cf_cv_prog_CC_c_o \
2109                                 cxxrenames=$cf_cv_prog_CXX_c_o \
2110                                 $srcdir/$cf_dir/modules >>$cf_dir/Makefile
2111                         cf_subdirs="$cf_subdirs $cf_subdir"
2112                         done
2113                 done
2114         fi
2115
2116         echo '  cd '$cf_dir' && ${MAKE} ${CF_MFLAGS} [$]@' >>Makefile
2117 done
2118
2119 for cf_dir in $SRC_SUBDIRS
2120 do
2121         if test ! -d $srcdir/$cf_dir ; then
2122                 continue
2123         fi
2124
2125         if test -f $cf_dir/Makefile ; then
2126                 case "$cf_dir" in
2127                 Ada95) #(vi
2128                         echo 'libs \' >> Makefile
2129                         echo 'install.libs \' >> Makefile
2130                         echo 'uninstall.libs ::' >> Makefile
2131                         echo '  cd '$cf_dir' && ${MAKE} ${CF_MFLAGS} [$]@' >> Makefile
2132                         ;;
2133                 esac
2134         fi
2135
2136         if test -f $srcdir/$cf_dir/modules; then
2137                 echo >> Makefile
2138                 if test -f $srcdir/$cf_dir/headers; then
2139 cat >> Makefile <<CF_EOF
2140 install.includes \\
2141 uninstall.includes \\
2142 CF_EOF
2143                 fi
2144 if test "$cf_dir" != "c++" ; then
2145 echo 'lint \' >> Makefile
2146 fi
2147 cat >> Makefile <<CF_EOF
2148 libs \\
2149 lintlib \\
2150 install.libs \\
2151 uninstall.libs \\
2152 install.$cf_dir \\
2153 uninstall.$cf_dir ::
2154         cd $cf_dir && \${MAKE} \${CF_MFLAGS} \[$]@
2155 CF_EOF
2156         elif test -f $srcdir/$cf_dir/headers; then
2157 cat >> Makefile <<CF_EOF
2158
2159 libs \\
2160 install.libs \\
2161 uninstall.libs \\
2162 install.includes \\
2163 uninstall.includes ::
2164         cd $cf_dir && \${MAKE} \${CF_MFLAGS} \[$]@
2165 CF_EOF
2166 fi
2167 done
2168
2169 cat >> Makefile <<CF_EOF
2170
2171 install.libs uninstall.libs \\
2172 install.data uninstall.data ::
2173 $MAKE_TERMINFO  cd misc && \${MAKE} \${CF_MFLAGS} \[$]@
2174
2175 install.man \\
2176 uninstall.man ::
2177         cd man && \${MAKE} \${CF_MFLAGS} \[$]@
2178
2179 distclean ::
2180         rm -f config.cache config.log config.status Makefile include/ncurses_cfg.h
2181         rm -f headers.sh headers.sed mk_shared_lib.sh
2182         rm -rf \${DIRS_TO_MAKE}
2183 CF_EOF
2184
2185 # Special case: tack's manpage lives in its own directory.
2186 if test -d tack ; then
2187 if test -f $srcdir/$tack.h; then
2188 cat >> Makefile <<CF_EOF
2189
2190 install.man \\
2191 uninstall.man ::
2192         cd tack && \${MAKE} \${CF_MFLAGS} \[$]@
2193 CF_EOF
2194 fi
2195 fi
2196
2197 dnl If we're installing into a subdirectory of /usr/include, etc., we should
2198 dnl prepend the subdirectory's name to the "#include" paths.  It won't hurt
2199 dnl anything, and will make it more standardized.  It's awkward to decide this
2200 dnl at configuration because of quoting, so we'll simply make all headers
2201 dnl installed via a script that can do the right thing.
2202
2203 rm -f headers.sed headers.sh
2204
2205 dnl ( generating this script makes the makefiles a little tidier :-)
2206 echo creating headers.sh
2207 cat >headers.sh <<CF_EOF
2208 #! /bin/sh
2209 # This shell script is generated by the 'configure' script.  It is invoked in a
2210 # subdirectory of the build tree.  It generates a sed-script in the parent
2211 # directory that is used to adjust includes for header files that reside in a
2212 # subdirectory of /usr/include, etc.
2213 PRG=""
2214 while test \[$]# != 3
2215 do
2216 PRG="\$PRG \[$]1"; shift
2217 done
2218 DST=\[$]1
2219 REF=\[$]2
2220 SRC=\[$]3
2221 TMPSRC=\${TMPDIR-/tmp}/\`basename \$SRC\`\$\$
2222 TMPSED=\${TMPDIR-/tmp}/headers.sed\$\$
2223 echo installing \$SRC in \$DST
2224 CF_EOF
2225
2226 if test $WITH_CURSES_H = yes; then
2227         cat >>headers.sh <<CF_EOF
2228 case \$DST in
2229 /*/include/*)
2230         END=\`basename \$DST\`
2231         for i in \`cat \$REF/../*/headers |fgrep -v "#"\`
2232         do
2233                 NAME=\`basename \$i\`
2234                 echo "s/<\$NAME>/<\$END\/\$NAME>/" >> \$TMPSED
2235         done
2236         ;;
2237 *)
2238         echo "" >> \$TMPSED
2239         ;;
2240 esac
2241 CF_EOF
2242
2243 else
2244         cat >>headers.sh <<CF_EOF
2245 case \$DST in
2246 /*/include/*)
2247         END=\`basename \$DST\`
2248         for i in \`cat \$REF/../*/headers |fgrep -v "#"\`
2249         do
2250                 NAME=\`basename \$i\`
2251                 if test "\$NAME" = "curses.h"
2252                 then
2253                         echo "s/<curses.h>/<ncurses.h>/" >> \$TMPSED
2254                         NAME=ncurses.h
2255                 fi
2256                 echo "s/<\$NAME>/<\$END\/\$NAME>/" >> \$TMPSED
2257         done
2258         ;;
2259 *)
2260         echo "s/<curses.h>/<ncurses.h>/" >> \$TMPSED
2261         ;;
2262 esac
2263 CF_EOF
2264 fi
2265 cat >>headers.sh <<CF_EOF
2266 rm -f \$TMPSRC
2267 sed -f \$TMPSED \$SRC > \$TMPSRC
2268 NAME=\`basename \$SRC\`
2269 CF_EOF
2270 if test $WITH_CURSES_H != yes; then
2271         cat >>headers.sh <<CF_EOF
2272 test "\$NAME" = "curses.h" && NAME=ncurses.h
2273 CF_EOF
2274 fi
2275 cat >>headers.sh <<CF_EOF
2276 # Just in case someone gzip'd manpages, remove the conflicting copy.
2277 test -f \$DST/\$NAME.gz && rm -f \$DST/\$NAME.gz
2278
2279 eval \$PRG \$TMPSRC \$DST/\$NAME
2280 rm -f \$TMPSRC \$TMPSED
2281 CF_EOF
2282
2283 chmod 0755 headers.sh
2284
2285 for cf_dir in $SRC_SUBDIRS
2286 do
2287         if test ! -d $srcdir/$cf_dir ; then
2288                 continue
2289         fi
2290
2291         if test -f $srcdir/$cf_dir/headers; then
2292                 $AWK -f $srcdir/mk-hdr.awk \
2293                         subset="$LIB_SUBSETS" \
2294                         compat="$WITH_CURSES_H" \
2295                         $srcdir/$cf_dir/headers >>$cf_dir/Makefile
2296         fi
2297
2298         if test -f $srcdir/$cf_dir/modules; then
2299                 if test "$cf_dir" != "c++" ; then
2300                         cat >>$cf_dir/Makefile <<"CF_EOF"
2301 depend : ${AUTO_SRC}
2302         makedepend -- ${CPPFLAGS} -- ${C_SRC}
2303
2304 # DO NOT DELETE THIS LINE -- make depend depends on it.
2305 CF_EOF
2306                 fi
2307         fi
2308 done
2309
2310 ])dnl
2311 dnl ---------------------------------------------------------------------------
2312 dnl CF_LIB_SONAME version: 3 updated: 2006/12/16 15:55:46
2313 dnl -------------
2314 dnl Find the and soname for the given shared library.  Set the cache variable
2315 dnl cf_cv_$3_soname to this, unless it is not found.  Then set the cache
2316 dnl variable to "unknown".
2317 dnl
2318 dnl $1 = headers
2319 dnl $2 = code
2320 dnl $3 = library name
2321 AC_DEFUN([CF_LIB_SONAME],
2322 [
2323 AC_CACHE_CHECK(for soname of $3 library,cf_cv_$3_soname,[
2324
2325 cf_cv_$3_soname=unknown
2326 if test "$cross_compiling" != yes ; then
2327 cat >conftest.$ac_ext <<CF_EOF
2328 $1
2329 int main()
2330 {
2331 $2
2332         ${cf_cv_main_return:-return}(0);
2333 }
2334 CF_EOF
2335 cf_save_LIBS="$LIBS"
2336         LIBS="-l$3 $LIBS"
2337         if AC_TRY_EVAL(ac_compile) ; then
2338                 if AC_TRY_EVAL(ac_link) ; then
2339                         cf_cv_$3_soname=`ldd conftest$ac_exeext 2>/dev/null | sed -e 's,^.*/,,' -e 's, .*$,,' | fgrep lib$3.`
2340                         test -z "$cf_cv_$3_soname" && cf_cv_$3_soname=unknown
2341                 fi
2342         fi
2343 rm -f conftest*
2344 LIBS="$cf_save_LIBS"
2345 fi
2346 ])
2347 ])
2348 dnl ---------------------------------------------------------------------------
2349 dnl CF_LIB_SUFFIX version: 13 updated: 2003/11/01 16:09:07
2350 dnl -------------
2351 dnl Compute the library file-suffix from the given model name
2352 dnl $1 = model name
2353 dnl $2 = variable to set
2354 dnl The variable $LIB_SUFFIX, if set, prepends the variable to set.
2355 AC_DEFUN([CF_LIB_SUFFIX],
2356 [
2357         AC_REQUIRE([CF_SUBST_NCURSES_VERSION])
2358         case $1 in
2359         libtool) $2='.la'  ;;
2360         normal)  $2='.a'   ;;
2361         debug)   $2='_g.a' ;;
2362         profile) $2='_p.a' ;;
2363         shared)
2364                 case $cf_cv_system_name in
2365                 cygwin*) $2='.dll' ;;
2366                 darwin*) $2='.dylib' ;;
2367                 hpux*)
2368                         case $target in
2369                         ia64*)  $2='.so' ;;
2370                         *)      $2='.sl' ;;
2371                         esac
2372                         ;;
2373                 *)      $2='.so'  ;;
2374                 esac
2375         esac
2376         test -n "$LIB_SUFFIX" && $2="${LIB_SUFFIX}[$]{$2}"
2377 ])dnl
2378 dnl ---------------------------------------------------------------------------
2379 dnl CF_LIB_TYPE version: 4 updated: 2000/10/20 22:57:49
2380 dnl -----------
2381 dnl Compute the string to append to -library from the given model name
2382 dnl $1 = model name
2383 dnl $2 = variable to set
2384 dnl The variable $LIB_SUFFIX, if set, prepends the variable to set.
2385 AC_DEFUN([CF_LIB_TYPE],
2386 [
2387         case $1 in
2388         libtool) $2=''   ;;
2389         normal)  $2=''   ;;
2390         debug)   $2='_g' ;;
2391         profile) $2='_p' ;;
2392         shared)  $2=''   ;;
2393         esac
2394         test -n "$LIB_SUFFIX" && $2="${LIB_SUFFIX}[$]{$2}"
2395 ])dnl
2396 dnl ---------------------------------------------------------------------------
2397 dnl CF_LINK_DATAONLY version: 8 updated: 2006/12/16 12:33:30
2398 dnl ----------------
2399 dnl Some systems have a non-ANSI linker that doesn't pull in modules that have
2400 dnl only data (i.e., no functions), for example NeXT.  On those systems we'll
2401 dnl have to provide wrappers for global tables to ensure they're linked
2402 dnl properly.
2403 AC_DEFUN([CF_LINK_DATAONLY],
2404 [
2405 AC_MSG_CHECKING([if data-only library module links])
2406 AC_CACHE_VAL(cf_cv_link_dataonly,[
2407         rm -f conftest.a
2408         cat >conftest.$ac_ext <<EOF
2409 #line __oline__ "configure"
2410 int     testdata[[3]] = { 123, 456, 789 };
2411 EOF
2412         if AC_TRY_EVAL(ac_compile) ; then
2413                 mv conftest.o data.o && \
2414                 ( $AR $AR_OPTS conftest.a data.o ) 2>&AC_FD_CC 1>/dev/null
2415         fi
2416         rm -f conftest.$ac_ext data.o
2417         cat >conftest.$ac_ext <<EOF
2418 #line __oline__ "configure"
2419 int     testfunc()
2420 {
2421 #if defined(NeXT)
2422         ${cf_cv_main_return:-return}(1);        /* I'm told this linker is broken */
2423 #else
2424         extern int testdata[[3]];
2425         return testdata[[0]] == 123
2426            &&  testdata[[1]] == 456
2427            &&  testdata[[2]] == 789;
2428 #endif
2429 }
2430 EOF
2431         if AC_TRY_EVAL(ac_compile); then
2432                 mv conftest.o func.o && \
2433                 ( $AR $AR_OPTS conftest.a func.o ) 2>&AC_FD_CC 1>/dev/null
2434         fi
2435         rm -f conftest.$ac_ext func.o
2436         ( eval $RANLIB conftest.a ) 2>&AC_FD_CC >/dev/null
2437         cf_saveLIBS="$LIBS"
2438         LIBS="conftest.a $LIBS"
2439         AC_TRY_RUN([
2440         int main()
2441         {
2442                 extern int testfunc();
2443                 ${cf_cv_main_return:-return} (!testfunc());
2444         }
2445         ],
2446         [cf_cv_link_dataonly=yes],
2447         [cf_cv_link_dataonly=no],
2448         [cf_cv_link_dataonly=unknown])
2449         LIBS="$cf_saveLIBS"
2450         ])
2451 AC_MSG_RESULT($cf_cv_link_dataonly)
2452
2453 if test "$cf_cv_link_dataonly" = no ; then
2454         AC_DEFINE(BROKEN_LINKER)
2455         BROKEN_LINKER=1
2456 fi
2457
2458 ])dnl
2459 dnl ---------------------------------------------------------------------------
2460 dnl CF_LINK_FUNCS version: 7 updated: 2006/12/16 12:33:30
2461 dnl -------------
2462 dnl Most Unix systems have both link and symlink, a few don't have symlink.
2463 dnl A few non-Unix systems implement symlink, but not link.
2464 dnl A few non-systems implement neither (or have nonfunctional versions).
2465 AC_DEFUN([CF_LINK_FUNCS],
2466 [
2467 AC_CHECK_FUNCS( \
2468         remove \
2469         unlink )
2470
2471 if test "$cross_compiling" = yes ; then
2472         AC_CHECK_FUNCS( \
2473                 link \
2474                 symlink )
2475 else
2476         AC_CACHE_CHECK(if link/symlink functions work,cf_cv_link_funcs,[
2477                 cf_cv_link_funcs=
2478                 for cf_func in link symlink ; do
2479                         AC_TRY_RUN([
2480 #include <sys/types.h>
2481 #include <sys/stat.h>
2482 #ifdef HAVE_UNISTD_H
2483 #include <unistd.h>
2484 #endif
2485 int main()
2486 {
2487         int fail = 0;
2488         char *src = "config.log";
2489         char *dst = "conftest.chk";
2490         struct stat src_sb;
2491         struct stat dst_sb;
2492
2493         stat(src, &src_sb);
2494         fail = ($cf_func("config.log", "conftest.chk") < 0)
2495             || (stat(dst, &dst_sb) < 0)
2496             || (dst_sb.st_mtime != src_sb.st_mtime);
2497 #ifdef HAVE_UNLINK
2498         unlink(dst);
2499 #else
2500         remove(dst);
2501 #endif
2502         ${cf_cv_main_return:-return} (fail);
2503 }
2504                         ],[
2505                         cf_cv_link_funcs="$cf_cv_link_funcs $cf_func"
2506                         eval 'ac_cv_func_'$cf_func'=yes'],[
2507                         eval 'ac_cv_func_'$cf_func'=no'],[
2508                         eval 'ac_cv_func_'$cf_func'=error'])
2509                 done
2510                 test -z "$cf_cv_link_funcs" && cf_cv_link_funcs=no
2511         ])
2512         test "$ac_cv_func_link"    = yes && AC_DEFINE(HAVE_LINK)
2513         test "$ac_cv_func_symlink" = yes && AC_DEFINE(HAVE_SYMLINK)
2514 fi
2515 ])dnl
2516 dnl ---------------------------------------------------------------------------
2517 dnl CF_MAIN_RETURN version: 1 updated: 2006/12/10 09:51:54
2518 dnl --------------
2519 dnl Check if a return from main to the shell actually returns the same exit
2520 dnl code.  This is true for almost any POSIX environment.
2521 dnl
2522 dnl Some very old environments did not flush stdout, etc., on an exit.  That
2523 dnl would be a useful case to test for also.
2524 AC_DEFUN([CF_MAIN_RETURN],
2525 [
2526 cf_cv_main_return=return
2527 ])dnl
2528 dnl ---------------------------------------------------------------------------
2529 dnl CF_MAKEFLAGS version: 12 updated: 2006/10/21 08:27:03
2530 dnl ------------
2531 dnl Some 'make' programs support ${MAKEFLAGS}, some ${MFLAGS}, to pass 'make'
2532 dnl options to lower-levels.  It's very useful for "make -n" -- if we have it.
2533 dnl (GNU 'make' does both, something POSIX 'make', which happens to make the
2534 dnl ${MAKEFLAGS} variable incompatible because it adds the assignments :-)
2535 AC_DEFUN([CF_MAKEFLAGS],
2536 [
2537 AC_CACHE_CHECK(for makeflags variable, cf_cv_makeflags,[
2538         cf_cv_makeflags=''
2539         for cf_option in '-${MAKEFLAGS}' '${MFLAGS}'
2540         do
2541                 cat >cf_makeflags.tmp <<CF_EOF
2542 SHELL = /bin/sh
2543 all :
2544         @ echo '.$cf_option'
2545 CF_EOF
2546                 cf_result=`${MAKE-make} -k -f cf_makeflags.tmp 2>/dev/null | sed -e 's,[[       ]]*$,,'`
2547                 case "$cf_result" in
2548                 .*k)
2549                         cf_result=`${MAKE-make} -k -f cf_makeflags.tmp CC=cc 2>/dev/null`
2550                         case "$cf_result" in
2551                         .*CC=*) cf_cv_makeflags=
2552                                 ;;
2553                         *)      cf_cv_makeflags=$cf_option
2554                                 ;;
2555                         esac
2556                         break
2557                         ;;
2558                 .-)     ;;
2559                 *)      echo "given option \"$cf_option\", no match \"$cf_result\""
2560                         ;;
2561                 esac
2562         done
2563         rm -f cf_makeflags.tmp
2564 ])
2565
2566 AC_SUBST(cf_cv_makeflags)
2567 ])dnl
2568 dnl ---------------------------------------------------------------------------
2569 dnl CF_MAKE_TAGS version: 2 updated: 2000/10/04 09:18:40
2570 dnl ------------
2571 dnl Generate tags/TAGS targets for makefiles.  Do not generate TAGS if we have
2572 dnl a monocase filesystem.
2573 AC_DEFUN([CF_MAKE_TAGS],[
2574 AC_REQUIRE([CF_MIXEDCASE_FILENAMES])
2575 AC_CHECK_PROG(MAKE_LOWER_TAGS, ctags, yes, no)
2576
2577 if test "$cf_cv_mixedcase" = yes ; then
2578         AC_CHECK_PROG(MAKE_UPPER_TAGS, etags, yes, no)
2579 else
2580         MAKE_UPPER_TAGS=no
2581 fi
2582
2583 if test "$MAKE_UPPER_TAGS" = yes ; then
2584         MAKE_UPPER_TAGS=
2585 else
2586         MAKE_UPPER_TAGS="#"
2587 fi
2588 AC_SUBST(MAKE_UPPER_TAGS)
2589
2590 if test "$MAKE_LOWER_TAGS" = yes ; then
2591         MAKE_LOWER_TAGS=
2592 else
2593         MAKE_LOWER_TAGS="#"
2594 fi
2595 AC_SUBST(MAKE_LOWER_TAGS)
2596 ])dnl
2597 dnl ---------------------------------------------------------------------------
2598 dnl CF_MANPAGE_FORMAT version: 7 updated: 2003/12/20 19:30:34
2599 dnl -----------------
2600 dnl Option to allow user to override automatic configuration of manpage format.
2601 dnl There are several special cases:
2602 dnl
2603 dnl     gzip - man checks for, can display gzip'd files
2604 dnl     compress - man checks for, can display compressed files
2605 dnl     BSDI - files in the cat-directories are suffixed ".0"
2606 dnl     formatted - installer should format (put files in cat-directory)
2607 dnl     catonly - installer should only format, e.g., for a turnkey system.
2608 dnl
2609 dnl There are other configurations which this macro does not test, e.g., HPUX's
2610 dnl compressed manpages (but uncompressed manpages are fine, and HPUX's naming
2611 dnl convention would not match our use).
2612 AC_DEFUN([CF_MANPAGE_FORMAT],
2613 [
2614 AC_REQUIRE([CF_PATHSEP])
2615 AC_MSG_CHECKING(format of man-pages)
2616
2617 AC_ARG_WITH(manpage-format,
2618         [  --with-manpage-format   specify manpage-format: gzip/compress/BSDI/normal and
2619                           optionally formatted/catonly, e.g., gzip,formatted],
2620         [MANPAGE_FORMAT=$withval],
2621         [MANPAGE_FORMAT=unknown])
2622
2623 test -z "$MANPAGE_FORMAT" && MANPAGE_FORMAT=unknown
2624 MANPAGE_FORMAT=`echo "$MANPAGE_FORMAT" | sed -e 's/,/ /g'`
2625
2626 cf_unknown=
2627
2628 case $MANPAGE_FORMAT in
2629 unknown)
2630   if test -z "$MANPATH" ; then
2631     MANPATH="/usr/man:/usr/share/man"
2632   fi
2633
2634   # look for the 'date' man-page (it's most likely to be installed!)
2635   MANPAGE_FORMAT=
2636   cf_preform=no
2637   cf_catonly=yes
2638   cf_example=date
2639
2640   IFS="${IFS=   }"; ac_save_ifs="$IFS"; IFS="${IFS}${PATHSEP}"
2641   for cf_dir in $MANPATH; do
2642     test -z "$cf_dir" && cf_dir=/usr/man
2643     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
2644     do
2645       cf_test=`echo $cf_name | sed -e 's/*//'`
2646       if test "x$cf_test" = "x$cf_name" ; then
2647
2648         case "$cf_name" in
2649         *.gz) MANPAGE_FORMAT="$MANPAGE_FORMAT gzip";;
2650         *.Z)  MANPAGE_FORMAT="$MANPAGE_FORMAT compress";;
2651         *.0)    MANPAGE_FORMAT="$MANPAGE_FORMAT BSDI";;
2652         *)    MANPAGE_FORMAT="$MANPAGE_FORMAT normal";;
2653         esac
2654
2655         case "$cf_name" in
2656         $cf_dir/man*)
2657           cf_catonly=no
2658           ;;
2659         $cf_dir/cat*)
2660           cf_preform=yes
2661           ;;
2662         esac
2663         break
2664       fi
2665
2666       # if we found a match in either man* or cat*, stop looking
2667       if test -n "$MANPAGE_FORMAT" ; then
2668         cf_found=no
2669         test "$cf_preform" = yes && MANPAGE_FORMAT="$MANPAGE_FORMAT formatted"
2670         test "$cf_catonly" = yes && MANPAGE_FORMAT="$MANPAGE_FORMAT catonly"
2671         case "$cf_name" in
2672         $cf_dir/cat*)
2673           cf_found=yes
2674           ;;
2675         esac
2676         test $cf_found=yes && break
2677       fi
2678     done
2679     # only check the first directory in $MANPATH where we find manpages
2680     if test -n "$MANPAGE_FORMAT" ; then
2681        break
2682     fi
2683   done
2684   # if we did not find the example, just assume it is normal
2685   test -z "$MANPAGE_FORMAT" && MANPAGE_FORMAT=normal
2686   IFS="$ac_save_ifs"
2687   ;;
2688 *)
2689   for cf_option in $MANPAGE_FORMAT; do
2690      case $cf_option in #(vi
2691      gzip|compress|BSDI|normal|formatted|catonly)
2692        ;;
2693      *)
2694        cf_unknown="$cf_unknown $cf_option"
2695        ;;
2696      esac
2697   done
2698   ;;
2699 esac
2700
2701 AC_MSG_RESULT($MANPAGE_FORMAT)
2702 if test -n "$cf_unknown" ; then
2703   AC_MSG_WARN(Unexpected manpage-format $cf_unknown)
2704 fi
2705 ])dnl
2706 dnl ---------------------------------------------------------------------------
2707 dnl CF_MANPAGE_RENAMES version: 7 updated: 2005/06/18 18:51:57
2708 dnl ------------------
2709 dnl The Debian people have their own naming convention for manpages.  This
2710 dnl option lets us override the name of the file containing renaming, or
2711 dnl disable it altogether.
2712 AC_DEFUN([CF_MANPAGE_RENAMES],
2713 [
2714 AC_MSG_CHECKING(for manpage renaming)
2715
2716 AC_ARG_WITH(manpage-renames,
2717         [  --with-manpage-renames  specify manpage-renaming],
2718         [MANPAGE_RENAMES=$withval],
2719         [MANPAGE_RENAMES=yes])
2720
2721 case ".$MANPAGE_RENAMES" in #(vi
2722 .no) #(vi
2723   ;;
2724 .|.yes)
2725   # Debian 'man' program?
2726   if test -f /etc/debian_version ; then
2727     MANPAGE_RENAMES=`cd $srcdir && pwd`/man/man_db.renames
2728   else
2729     MANPAGE_RENAMES=no
2730   fi
2731   ;;
2732 esac
2733
2734 if test "$MANPAGE_RENAMES" != no ; then
2735   if test -f $srcdir/man/$MANPAGE_RENAMES ; then
2736     MANPAGE_RENAMES=`cd $srcdir/man && pwd`/$MANPAGE_RENAMES
2737   elif test ! -f $MANPAGE_RENAMES ; then
2738     AC_MSG_ERROR(not a filename: $MANPAGE_RENAMES)
2739   fi
2740
2741   test ! -d man && mkdir man
2742
2743   # Construct a sed-script to perform renaming within man-pages
2744   if test -n "$MANPAGE_RENAMES" ; then
2745     test ! -d man && mkdir man
2746     sh $srcdir/man/make_sed.sh $MANPAGE_RENAMES >./edit_man.sed
2747   fi
2748 fi
2749
2750 AC_MSG_RESULT($MANPAGE_RENAMES)
2751 AC_SUBST(MANPAGE_RENAMES)
2752 ])dnl
2753 dnl ---------------------------------------------------------------------------
2754 dnl CF_MANPAGE_SYMLINKS version: 4 updated: 2003/12/13 18:01:58
2755 dnl -------------------
2756 dnl Some people expect each tool to make all aliases for manpages in the
2757 dnl man-directory.  This accommodates the older, less-capable implementations
2758 dnl of 'man', and is optional.
2759 AC_DEFUN([CF_MANPAGE_SYMLINKS],
2760 [
2761 AC_MSG_CHECKING(if manpage aliases will be installed)
2762
2763 AC_ARG_WITH(manpage-aliases,
2764         [  --with-manpage-aliases  specify manpage-aliases using .so],
2765         [MANPAGE_ALIASES=$withval],
2766         [MANPAGE_ALIASES=yes])
2767
2768 AC_MSG_RESULT($MANPAGE_ALIASES)
2769
2770 if test "$LN_S" = "ln -s"; then
2771         cf_use_symlinks=yes
2772 else
2773         cf_use_symlinks=no
2774 fi
2775
2776 MANPAGE_SYMLINKS=no
2777 if test "$MANPAGE_ALIASES" = yes ; then
2778 AC_MSG_CHECKING(if manpage symlinks should be used)
2779
2780 AC_ARG_WITH(manpage-symlinks,
2781         [  --with-manpage-symlinks specify manpage-aliases using symlinks],
2782         [MANPAGE_SYMLINKS=$withval],
2783         [MANPAGE_SYMLINKS=$cf_use_symlinks])
2784
2785 if test "$$cf_use_symlinks" = no; then
2786 if test "$MANPAGE_SYMLINKS" = yes ; then
2787         AC_MSG_WARN(cannot make symlinks, will use .so files)
2788         MANPAGE_SYMLINKS=no
2789 fi
2790 fi
2791
2792 AC_MSG_RESULT($MANPAGE_SYMLINKS)
2793 fi
2794
2795 ])dnl
2796 dnl ---------------------------------------------------------------------------
2797 dnl CF_MANPAGE_TBL version: 3 updated: 2002/01/19 22:51:32
2798 dnl --------------
2799 dnl This option causes manpages to be run through tbl(1) to generate tables
2800 dnl correctly.
2801 AC_DEFUN([CF_MANPAGE_TBL],
2802 [
2803 AC_MSG_CHECKING(for manpage tbl)
2804
2805 AC_ARG_WITH(manpage-tbl,
2806         [  --with-manpage-tbl      specify manpage processing with tbl],
2807         [MANPAGE_TBL=$withval],
2808         [MANPAGE_TBL=no])
2809
2810 AC_MSG_RESULT($MANPAGE_TBL)
2811 ])dnl
2812 dnl ---------------------------------------------------------------------------
2813 dnl CF_MAN_PAGES version: 35 updated: 2007/03/31 11:47:29
2814 dnl ------------
2815 dnl Try to determine if the man-pages on the system are compressed, and if
2816 dnl so, what format is used.  Use this information to construct a script that
2817 dnl will install man-pages.
2818 AC_DEFUN([CF_MAN_PAGES],
2819 [
2820 CF_HELP_MESSAGE(Options to Specify How Manpages are Installed:)
2821 CF_MANPAGE_FORMAT
2822 CF_MANPAGE_RENAMES
2823 CF_MANPAGE_SYMLINKS
2824 CF_MANPAGE_TBL
2825
2826   if test "$prefix" = "NONE" ; then
2827      cf_prefix="$ac_default_prefix"
2828   else
2829      cf_prefix="$prefix"
2830   fi
2831
2832   case "$MANPAGE_FORMAT" in # (vi
2833   *catonly*) # (vi
2834     cf_format=yes
2835     cf_inboth=no
2836     ;;
2837   *formatted*) # (vi
2838     cf_format=yes
2839     cf_inboth=yes
2840     ;;
2841   *)
2842     cf_format=no
2843     cf_inboth=no
2844     ;;
2845   esac
2846
2847 test ! -d man && mkdir man
2848
2849 cf_so_strip=
2850 cf_compress=
2851 case "$MANPAGE_FORMAT" in #(vi
2852 *compress*) #(vi
2853         cf_so_strip="Z"
2854         cf_compress=compress
2855   ;;
2856 *gzip*) #(vi
2857         cf_so_strip="gz"
2858         cf_compress=gzip
2859   ;;
2860 esac
2861
2862 cf_edit_man=./edit_man.sh
2863 cf_man_alias=`pwd`/man_alias.sed
2864
2865 cat >$cf_edit_man <<CF_EOF
2866 #! /bin/sh
2867 # this script is generated by the configure-script CF_MAN_PAGES macro.
2868
2869 prefix="$cf_prefix"
2870 datadir="$datadir"
2871
2872 NCURSES_MAJOR="$NCURSES_MAJOR"
2873 NCURSES_MINOR="$NCURSES_MINOR"
2874 NCURSES_PATCH="$NCURSES_PATCH"
2875
2876 NCURSES_OSPEED="$NCURSES_OSPEED"
2877 TERMINFO="$TERMINFO"
2878
2879 MKDIRS="sh `cd $srcdir && pwd`/mkdirs.sh"
2880
2881 INSTALL="$INSTALL"
2882 INSTALL_DATA="$INSTALL_DATA"
2883
2884 transform="$program_transform_name"
2885
2886 TMP=\${TMPDIR-/tmp}/man\$\$
2887 trap "rm -f \$TMP" 0 1 2 5 15
2888
2889 form=\[$]1
2890 shift || exit 1
2891
2892 verb=\[$]1
2893 shift || exit 1
2894
2895 mandir=\[$]1
2896 shift || exit 1
2897
2898 srcdir=\[$]1
2899 top_srcdir=\[$]srcdir/..
2900 shift || exit 1
2901
2902 if test "\$form" = normal ; then
2903         if test "$cf_format" = yes ; then
2904         if test "$cf_inboth" = no ; then
2905                 sh \[$]0 format \$verb \$mandir \$srcdir \[$]*
2906                 exit $?
2907         fi
2908         fi
2909         cf_subdir=\$mandir/man
2910         cf_tables=$MANPAGE_TBL
2911 else
2912         cf_subdir=\$mandir/cat
2913         cf_tables=yes
2914 fi
2915
2916 # process the list of source-files
2917 for i in \[$]* ; do
2918 case \$i in #(vi
2919 *.orig|*.rej) ;; #(vi
2920 *.[[0-9]]*)
2921         section=\`expr "\$i" : '.*\\.\\([[0-9]]\\)[[xm]]*'\`;
2922         if test \$verb = installing ; then
2923         if test ! -d \$cf_subdir\${section} ; then
2924                 \$MKDIRS \$cf_subdir\$section
2925         fi
2926         fi
2927
2928         # replace variables in man page
2929         if test ! -f $cf_man_alias ; then
2930 cat >>$cf_man_alias <<-CF_EOF2
2931                 s,@DATADIR@,\$datadir,g
2932                 s,@TERMINFO@,\$TERMINFO,g
2933                 s,@NCURSES_MAJOR@,\$NCURSES_MAJOR,g
2934                 s,@NCURSES_MINOR@,\$NCURSES_MINOR,g
2935                 s,@NCURSES_PATCH@,\$NCURSES_PATCH,g
2936                 s,@NCURSES_OSPEED@,\$NCURSES_OSPEED,g
2937 CF_EOF
2938         ifelse($1,,,[
2939         for cf_name in $1
2940         do
2941                 cf_NAME=`echo "$cf_name" | sed y%abcdefghijklmnopqrstuvwxyz./-%ABCDEFGHIJKLMNOPQRSTUVWXYZ___%`
2942                 cf_name=`echo $cf_name|sed "$program_transform_name"`
2943 cat >>$cf_edit_man <<-CF_EOF
2944                 s,@$cf_NAME@,$cf_name,
2945 CF_EOF
2946         done
2947         ])
2948 cat >>$cf_edit_man <<CF_EOF
2949 CF_EOF2
2950                 echo "...made $cf_man_alias"
2951         fi
2952
2953         aliases=
2954         cf_source=\`basename \$i\`
2955         inalias=\$cf_source
2956         test ! -f \$inalias && inalias="\$srcdir/\$inalias"
2957         if test ! -f \$inalias ; then
2958                 echo .. skipped \$cf_source
2959                 continue
2960         fi
2961 CF_EOF
2962
2963 if test "$MANPAGE_ALIASES" != no ; then
2964 cat >>$cf_edit_man <<CF_EOF
2965         aliases=\`sed -f \$top_srcdir/man/manlinks.sed \$inalias |sed -f $cf_man_alias | sort -u\`
2966 CF_EOF
2967 fi
2968
2969 if test "$MANPAGE_RENAMES" = no ; then
2970 cat >>$cf_edit_man <<CF_EOF
2971         # perform program transformations for section 1 man pages
2972         if test \$section = 1 ; then
2973                 cf_target=\$cf_subdir\${section}/\`echo \$cf_source|sed "\${transform}"\`
2974         else
2975                 cf_target=\$cf_subdir\${section}/\$cf_source
2976         fi
2977 CF_EOF
2978 else
2979 cat >>$cf_edit_man <<CF_EOF
2980         cf_target=\`grep "^\$cf_source" $MANPAGE_RENAMES | $AWK '{print \[$]2}'\`
2981         if test -z "\$cf_target" ; then
2982                 echo '? missing rename for '\$cf_source
2983                 cf_target="\$cf_source"
2984         fi
2985         cf_target="\$cf_subdir\${section}/\${cf_target}"
2986
2987 CF_EOF
2988 fi
2989
2990 cat >>$cf_edit_man <<CF_EOF
2991         sed     -f $cf_man_alias \\
2992 CF_EOF
2993
2994 if test -f $MANPAGE_RENAMES ; then
2995 cat >>$cf_edit_man <<CF_EOF
2996                 < \$i | sed -f `pwd`/edit_man.sed >\$TMP
2997 CF_EOF
2998 else
2999 cat >>$cf_edit_man <<CF_EOF
3000                 < \$i >\$TMP
3001 CF_EOF
3002 fi
3003
3004 cat >>$cf_edit_man <<CF_EOF
3005 if test \$cf_tables = yes ; then
3006         tbl \$TMP >\$TMP.out
3007         mv \$TMP.out \$TMP
3008 fi
3009 CF_EOF
3010
3011 if test $with_curses_h != yes ; then
3012 cat >>$cf_edit_man <<CF_EOF
3013         sed -e "/\#[    ]*include/s,curses.h,ncurses.h," < \$TMP >\$TMP.out
3014         mv \$TMP.out \$TMP
3015 CF_EOF
3016 fi
3017
3018 cat >>$cf_edit_man <<CF_EOF
3019         if test \$form = format ; then
3020                 nroff -man \$TMP >\$TMP.out
3021                 mv \$TMP.out \$TMP
3022         fi
3023 CF_EOF
3024
3025 if test -n "$cf_compress" ; then
3026 cat >>$cf_edit_man <<CF_EOF
3027         if test \$verb = installing ; then
3028         if ( $cf_compress -f \$TMP )
3029         then
3030                 mv \$TMP.$cf_so_strip \$TMP
3031         fi
3032         fi
3033         cf_target="\$cf_target.$cf_so_strip"
3034 CF_EOF
3035 fi
3036
3037 case "$MANPAGE_FORMAT" in #(vi
3038 *BSDI*)
3039 cat >>$cf_edit_man <<CF_EOF
3040         if test \$form = format ; then
3041                 # BSDI installs only .0 suffixes in the cat directories
3042                 cf_target="\`echo \$cf_target|sed -e 's/\.[[1-9]]\+[[a-z]]*/.0/'\`"
3043         fi
3044 CF_EOF
3045   ;;
3046 esac
3047
3048 cat >>$cf_edit_man <<CF_EOF
3049         suffix=\`basename \$cf_target | sed -e 's%^[[^.]]*%%'\`
3050         if test \$verb = installing ; then
3051                 echo \$verb \$cf_target
3052                 \$INSTALL_DATA \$TMP \$cf_target
3053                 test -d \$cf_subdir\${section} &&
3054                 test -n "\$aliases" && (
3055                         cd \$cf_subdir\${section} && (
3056                                 cf_source=\`echo \$cf_target |sed -e 's%^.*/\([[^/]][[^/]]*/[[^/]][[^/]]*$\)%\1%'\`
3057                                 test -n "$cf_so_strip" && cf_source=\`echo \$cf_source |sed -e 's%\.$cf_so_strip\$%%'\`
3058                                 cf_target=\`basename \$cf_target\`
3059                                 for cf_alias in \$aliases
3060                                 do
3061                                         if test \$section = 1 ; then
3062                                                 cf_alias=\`echo \$cf_alias|sed "\${transform}"\`
3063                                         fi
3064
3065                                         if test "$MANPAGE_SYMLINKS" = yes ; then
3066                                                 if test -f \$cf_alias\${suffix} ; then
3067                                                         if ( cmp -s \$cf_target \$cf_alias\${suffix} )
3068                                                         then
3069                                                                 continue
3070                                                         fi
3071                                                 fi
3072                                                 echo .. \$verb alias \$cf_alias\${suffix}
3073                                                 rm -f \$cf_alias\${suffix}
3074                                                 $LN_S \$cf_target \$cf_alias\${suffix}
3075                                         elif test "\$cf_target" != "\$cf_alias\${suffix}" ; then
3076                                                 echo ".so \$cf_source" >\$TMP
3077 CF_EOF
3078 if test -n "$cf_compress" ; then
3079 cat >>$cf_edit_man <<CF_EOF
3080                                                 if test -n "$cf_so_strip" ; then
3081                                                         $cf_compress -f \$TMP
3082                                                         mv \$TMP.$cf_so_strip \$TMP
3083                                                 fi
3084 CF_EOF
3085 fi
3086 cat >>$cf_edit_man <<CF_EOF
3087                                                 echo .. \$verb alias \$cf_alias\${suffix}
3088                                                 rm -f \$cf_alias\${suffix}
3089                                                 \$INSTALL_DATA \$TMP \$cf_alias\${suffix}
3090                                         fi
3091                                 done
3092                         )
3093                 )
3094         elif test \$verb = removing ; then
3095                 test -f \$cf_target && (
3096                         echo \$verb \$cf_target
3097                         rm -f \$cf_target
3098                 )
3099                 test -d \$cf_subdir\${section} &&
3100                 test -n "\$aliases" && (
3101                         cd \$cf_subdir\${section} && (
3102                                 for cf_alias in \$aliases
3103                                 do
3104                                         if test \$section = 1 ; then
3105                                                 cf_alias=\`echo \$cf_alias|sed "\${transform}"\`
3106                                         fi
3107
3108                                         echo .. \$verb alias \$cf_alias\${suffix}
3109                                         rm -f \$cf_alias\${suffix}
3110                                 done
3111                         )
3112                 )
3113         else
3114 #               echo ".hy 0"
3115                 cat \$TMP
3116         fi
3117         ;;
3118 esac
3119 done
3120
3121 if test $cf_inboth = yes ; then
3122 if test \$form != format ; then
3123         sh \[$]0 format \$verb \$mandir \$srcdir \[$]*
3124 fi
3125 fi
3126
3127 exit 0
3128 CF_EOF
3129 chmod 755 $cf_edit_man
3130
3131 ])dnl
3132 dnl ---------------------------------------------------------------------------
3133 dnl CF_MATH_LIB version: 5 updated: 2000/05/28 01:39:10
3134 dnl -----------
3135 dnl Checks for libraries.  At least one UNIX system, Apple Macintosh
3136 dnl Rhapsody 5.5, does not have -lm.  We cannot use the simpler
3137 dnl AC_CHECK_LIB(m,sin), because that fails for C++.
3138 AC_DEFUN([CF_MATH_LIB],
3139 [
3140 AC_CACHE_CHECK(if -lm needed for math functions,
3141         cf_cv_need_libm,[
3142         AC_TRY_LINK([
3143         #include <stdio.h>
3144         #include <math.h>
3145         ],
3146         [double x = rand(); printf("result = %g\n", ]ifelse($2,,sin(x),$2)[)],
3147         [cf_cv_need_libm=no],
3148         [cf_cv_need_libm=yes])])
3149 if test "$cf_cv_need_libm" = yes
3150 then
3151 ifelse($1,,[
3152         LIBS="$LIBS -lm"
3153 ],[$1=-lm])
3154 fi
3155 ])
3156 dnl ---------------------------------------------------------------------------
3157 dnl CF_MIXEDCASE_FILENAMES version: 3 updated: 2003/09/20 17:07:55
3158 dnl ----------------------
3159 dnl Check if the file-system supports mixed-case filenames.  If we're able to
3160 dnl create a lowercase name and see it as uppercase, it doesn't support that.
3161 AC_DEFUN([CF_MIXEDCASE_FILENAMES],
3162 [
3163 AC_CACHE_CHECK(if filesystem supports mixed-case filenames,cf_cv_mixedcase,[
3164 if test "$cross_compiling" = yes ; then
3165         case $target_alias in #(vi
3166         *-os2-emx*|*-msdosdjgpp*|*-cygwin*|*-mingw32*|*-uwin*) #(vi
3167                 cf_cv_mixedcase=no
3168                 ;;
3169         *)
3170                 cf_cv_mixedcase=yes
3171                 ;;
3172         esac
3173 else
3174         rm -f conftest CONFTEST
3175         echo test >conftest
3176         if test -f CONFTEST ; then
3177                 cf_cv_mixedcase=no
3178         else
3179                 cf_cv_mixedcase=yes
3180         fi
3181         rm -f conftest CONFTEST
3182 fi
3183 ])
3184 test "$cf_cv_mixedcase" = yes && AC_DEFINE(MIXEDCASE_FILENAMES)
3185 ])dnl
3186 dnl ---------------------------------------------------------------------------
3187 dnl CF_MKSTEMP version: 5 updated: 2006/12/16 12:33:30
3188 dnl ----------
3189 dnl Check for a working mkstemp.  This creates two files, checks that they are
3190 dnl successfully created and distinct (AmigaOS apparently fails on the last).
3191 AC_DEFUN([CF_MKSTEMP],[
3192 AC_CACHE_CHECK(for working mkstemp, cf_cv_func_mkstemp,[
3193 rm -f conftest*
3194 AC_TRY_RUN([
3195 #include <sys/types.h>
3196 #include <stdlib.h>
3197 #include <stdio.h>
3198 #include <string.h>
3199 #include <sys/stat.h>
3200 int main()
3201 {
3202         char *tmpl = "conftestXXXXXX";
3203         char name[2][80];
3204         int n;
3205         int result = 0;
3206         int fd;
3207         struct stat sb;
3208
3209         umask(077);
3210         for (n = 0; n < 2; ++n) {
3211                 strcpy(name[n], tmpl);
3212                 if ((fd = mkstemp(name[n])) >= 0) {
3213                         if (!strcmp(name[n], tmpl)
3214                          || stat(name[n], &sb) != 0
3215                          || (sb.st_mode & S_IFMT) != S_IFREG
3216                          || (sb.st_mode & 077) != 0) {
3217                                 result = 1;
3218                         }
3219                         close(fd);
3220                 }
3221         }
3222         if (result == 0
3223          && !strcmp(name[0], name[1]))
3224                 result = 1;
3225         ${cf_cv_main_return:-return}(result);
3226 }
3227 ],[cf_cv_func_mkstemp=yes
3228 ],[cf_cv_func_mkstemp=no
3229 ],[AC_CHECK_FUNC(mkstemp)
3230 ])
3231 ])
3232 if test "$cf_cv_func_mkstemp" = yes ; then
3233         AC_DEFINE(HAVE_MKSTEMP)
3234 fi
3235 ])dnl
3236 dnl ---------------------------------------------------------------------------
3237 dnl CF_MSG_LOG version: 4 updated: 2007/07/29 09:55:12
3238 dnl ----------
3239 dnl Write a debug message to config.log, along with the line number in the
3240 dnl configure script.
3241 AC_DEFUN([CF_MSG_LOG],[
3242 echo "${as_me-configure}:__oline__: testing $* ..." 1>&AC_FD_CC
3243 ])dnl
3244 dnl ---------------------------------------------------------------------------
3245 dnl CF_NCURSES_ABI_6 version: 1 updated: 2005/09/17 18:42:49
3246 dnl ----------------
3247 dnl Set ncurses' ABI to 6 unless overridden by explicit configure option, and
3248 dnl warn about this.
3249 AC_DEFUN([CF_NCURSES_ABI_6],[
3250 if test "${with_abi_version+set}" != set; then
3251         case $cf_cv_rel_version in
3252         5.*)
3253                 cf_cv_rel_version=6.0
3254                 cf_cv_abi_version=6
3255                 AC_MSG_WARN(Overriding ABI version to $cf_cv_abi_version)
3256                 ;;
3257         esac
3258 fi
3259 ])dnl
3260 dnl ---------------------------------------------------------------------------
3261 dnl CF_NO_LEAKS_OPTION version: 4 updated: 2006/12/16 14:24:05
3262 dnl ------------------
3263 dnl see CF_WITH_NO_LEAKS
3264 AC_DEFUN([CF_NO_LEAKS_OPTION],[
3265 AC_MSG_CHECKING(if you want to use $1 for testing)
3266 AC_ARG_WITH($1,
3267         [$2],
3268         [AC_DEFINE($3)ifelse([$4],,[
3269          $4
3270 ])
3271         : ${with_cflags:=-g}
3272         : ${with_no_leaks:=yes}
3273          with_$1=yes],
3274         [with_$1=])
3275 AC_MSG_RESULT(${with_$1:-no})
3276
3277 case .$with_cflags in #(vi
3278 .*-g*)
3279         case .$CFLAGS in #(vi
3280         .*-g*) #(vi
3281                 ;;
3282         *)
3283                 CF_ADD_CFLAGS([-g])
3284                 ;;
3285         esac
3286         ;;
3287 esac
3288 ])dnl
3289 dnl ---------------------------------------------------------------------------
3290 dnl CF_NUMBER_SYNTAX version: 1 updated: 2003/09/20 18:12:49
3291 dnl ----------------
3292 dnl Check if the given variable is a number.  If not, report an error.
3293 dnl $1 is the variable
3294 dnl $2 is the message
3295 AC_DEFUN([CF_NUMBER_SYNTAX],[
3296 if test -n "$1" ; then
3297   case $1 in #(vi
3298   [[0-9]]*) #(vi
3299         ;;
3300   *)
3301         AC_MSG_ERROR($2 is not a number: $1)
3302         ;;
3303   esac
3304 else
3305   AC_MSG_ERROR($2 value is empty)
3306 fi
3307 ])dnl
3308 dnl ---------------------------------------------------------------------------
3309 dnl CF_OBJ_SUBDIR version: 4 updated: 2002/02/23 20:38:31
3310 dnl -------------
3311 dnl Compute the object-directory name from the given model name
3312 AC_DEFUN([CF_OBJ_SUBDIR],
3313 [
3314         case $1 in
3315         libtool) $2='obj_lo'  ;;
3316         normal)  $2='objects' ;;
3317         debug)   $2='obj_g' ;;
3318         profile) $2='obj_p' ;;
3319         shared)
3320                 case $cf_cv_system_name in #(vi
3321                 cygwin) #(vi
3322                         $2='objects' ;;
3323                 *)
3324                         $2='obj_s' ;;
3325                 esac
3326         esac
3327 ])dnl
3328 dnl ---------------------------------------------------------------------------
3329 dnl CF_PATHSEP version: 3 updated: 2001/01/12 01:23:53
3330 dnl ----------
3331 dnl Provide a value for the $PATH and similar separator
3332 AC_DEFUN([CF_PATHSEP],
3333 [
3334         case $cf_cv_system_name in
3335         os2*)   PATHSEP=';'  ;;
3336         *)      PATHSEP=':'  ;;
3337         esac
3338 ifelse($1,,,[$1=$PATHSEP])
3339         AC_SUBST(PATHSEP)
3340 ])dnl
3341 dnl ---------------------------------------------------------------------------
3342 dnl CF_PATH_SYNTAX version: 11 updated: 2006/09/02 08:55:46
3343 dnl --------------
3344 dnl Check the argument to see that it looks like a pathname.  Rewrite it if it
3345 dnl begins with one of the prefix/exec_prefix variables, and then again if the
3346 dnl result begins with 'NONE'.  This is necessary to work around autoconf's
3347 dnl delayed evaluation of those symbols.
3348 AC_DEFUN([CF_PATH_SYNTAX],[
3349 if test "x$prefix" != xNONE; then
3350   cf_path_syntax="$prefix"
3351 else
3352   cf_path_syntax="$ac_default_prefix"
3353 fi
3354
3355 case ".[$]$1" in #(vi
3356 .\[$]\(*\)*|.\'*\'*) #(vi
3357   ;;
3358 ..|./*|.\\*) #(vi
3359   ;;
3360 .[[a-zA-Z]]:[[\\/]]*) #(vi OS/2 EMX
3361   ;;
3362 .\[$]{*prefix}*) #(vi
3363   eval $1="[$]$1"
3364   case ".[$]$1" in #(vi
3365   .NONE/*)
3366     $1=`echo [$]$1 | sed -e s%NONE%$cf_path_syntax%`
3367     ;;
3368   esac
3369   ;; #(vi
3370 .no|.NONE/*)
3371   $1=`echo [$]$1 | sed -e s%NONE%$cf_path_syntax%`
3372   ;;
3373 *)
3374   ifelse($2,,[AC_ERROR([expected a pathname, not \"[$]$1\"])],$2)
3375   ;;
3376 esac
3377 ])dnl
3378 dnl ---------------------------------------------------------------------------
3379 dnl CF_POSIX_C_SOURCE version: 6 updated: 2005/07/14 20:25:10
3380 dnl -----------------
3381 dnl Define _POSIX_C_SOURCE to the given level, and _POSIX_SOURCE if needed.
3382 dnl
3383 dnl     POSIX.1-1990                            _POSIX_SOURCE
3384 dnl     POSIX.1-1990 and                        _POSIX_SOURCE and
3385 dnl             POSIX.2-1992 C-Language                 _POSIX_C_SOURCE=2
3386 dnl             Bindings Option
3387 dnl     POSIX.1b-1993                           _POSIX_C_SOURCE=199309L
3388 dnl     POSIX.1c-1996                           _POSIX_C_SOURCE=199506L
3389 dnl     X/Open 2000                             _POSIX_C_SOURCE=200112L
3390 dnl
3391 dnl Parameters:
3392 dnl     $1 is the nominal value for _POSIX_C_SOURCE
3393 AC_DEFUN([CF_POSIX_C_SOURCE],
3394 [
3395 cf_POSIX_C_SOURCE=ifelse($1,,199506L,$1)
3396
3397 cf_save_CFLAGS="$CFLAGS"
3398 cf_save_CPPFLAGS="$CPPFLAGS"
3399
3400 CF_REMOVE_DEFINE(cf_trim_CFLAGS,$cf_save_CFLAGS,_POSIX_C_SOURCE)
3401 CF_REMOVE_DEFINE(cf_trim_CPPFLAGS,$cf_save_CPPFLAGS,_POSIX_C_SOURCE)
3402
3403 AC_CACHE_CHECK(if we should define _POSIX_C_SOURCE,cf_cv_posix_c_source,[
3404         CF_MSG_LOG(if the symbol is already defined go no further)
3405         AC_TRY_COMPILE([#include <sys/types.h>],[
3406 #ifndef _POSIX_C_SOURCE
3407 make an error
3408 #endif],
3409         [cf_cv_posix_c_source=no],
3410         [cf_want_posix_source=no
3411          case .$cf_POSIX_C_SOURCE in #(vi
3412          .[[12]]??*) #(vi
3413                 cf_cv_posix_c_source="-D_POSIX_C_SOURCE=$cf_POSIX_C_SOURCE"
3414                 ;;
3415          .2) #(vi
3416                 cf_cv_posix_c_source="-D_POSIX_C_SOURCE=$cf_POSIX_C_SOURCE"
3417                 cf_want_posix_source=yes
3418                 ;;
3419          .*)
3420                 cf_want_posix_source=yes
3421                 ;;
3422          esac
3423          if test "$cf_want_posix_source" = yes ; then
3424                 AC_TRY_COMPILE([#include <sys/types.h>],[
3425 #ifdef _POSIX_SOURCE
3426 make an error
3427 #endif],[],
3428                 cf_cv_posix_c_source="$cf_cv_posix_c_source -D_POSIX_SOURCE")
3429          fi
3430          CF_MSG_LOG(ifdef from value $cf_POSIX_C_SOURCE)
3431          CFLAGS="$cf_trim_CFLAGS"
3432          CPPFLAGS="$cf_trim_CPPFLAGS $cf_cv_posix_c_source"
3433          CF_MSG_LOG(if the second compile does not leave our definition intact error)
3434          AC_TRY_COMPILE([#include <sys/types.h>],[
3435 #ifndef _POSIX_C_SOURCE
3436 make an error
3437 #endif],,
3438          [cf_cv_posix_c_source=no])
3439          CFLAGS="$cf_save_CFLAGS"
3440          CPPFLAGS="$cf_save_CPPFLAGS"
3441         ])
3442 ])
3443
3444 if test "$cf_cv_posix_c_source" != no ; then
3445         CFLAGS="$cf_trim_CFLAGS"
3446         CPPFLAGS="$cf_trim_CPPFLAGS"
3447         if test "$cf_cv_cc_u_d_options" = yes ; then
3448                 cf_temp_posix_c_source=`echo "$cf_cv_posix_c_source" | \
3449                                 sed -e 's/-D/-U/g' -e 's/=[[^   ]]*//g'`
3450                 CPPFLAGS="$CPPFLAGS $cf_temp_posix_c_source"
3451         fi
3452         CPPFLAGS="$CPPFLAGS $cf_cv_posix_c_source"
3453 fi
3454
3455 ])dnl
3456 dnl ---------------------------------------------------------------------------
3457 dnl CF_PREDEFINE version: 1 updated: 2003/07/26 17:53:56
3458 dnl ------------
3459 dnl Add definitions to CPPFLAGS to ensure they're predefined for all compiles.
3460 dnl
3461 dnl $1 = symbol to test
3462 dnl $2 = value (if any) to use for a predefinition
3463 AC_DEFUN([CF_PREDEFINE],
3464 [
3465 AC_MSG_CHECKING(if we must define $1)
3466 AC_TRY_COMPILE([#include <sys/types.h>
3467 ],[
3468 #ifndef $1
3469 make an error
3470 #endif],[cf_result=no],[cf_result=yes])
3471 AC_MSG_RESULT($cf_result)
3472
3473 if test "$cf_result" = yes ; then
3474         CPPFLAGS="$CPPFLAGS ifelse($2,,-D$1,[-D$1=$2])"
3475 elif test "x$2" != "x" ; then
3476         AC_MSG_CHECKING(checking for compatible value versus $2)
3477         AC_TRY_COMPILE([#include <sys/types.h>
3478 ],[
3479 #if $1-$2 < 0
3480 make an error
3481 #endif],[cf_result=yes],[cf_result=no])
3482         AC_MSG_RESULT($cf_result)
3483         if test "$cf_result" = no ; then
3484                 # perhaps we can override it - try...
3485                 CPPFLAGS="$CPPFLAGS -D$1=$2"
3486         fi
3487 fi
3488 ])dnl
3489 dnl ---------------------------------------------------------------------------
3490 dnl CF_PRG_RULES version: 1 updated: 2006/06/03 11:45:08
3491 dnl ------------
3492 dnl Append definitions and rules for the given programs to the subdirectory
3493 dnl Makefiles, and the recursion rule for the top-level Makefile.
3494 dnl
3495 dnl parameters
3496 dnl     $1 = script to run
3497 dnl     $2 = list of subdirectories
3498 dnl
3499 dnl variables
3500 dnl     $AWK
3501 AC_DEFUN([CF_PRG_RULES],
3502 [
3503 for cf_dir in $2
3504 do
3505         if test ! -d $srcdir/$cf_dir; then
3506                 continue
3507         elif test -f $srcdir/$cf_dir/programs; then
3508                 $AWK -f $1 $srcdir/$cf_dir/programs >>$cf_dir/Makefile
3509         fi
3510 done
3511
3512 ])dnl
3513 dnl ---------------------------------------------------------------------------
3514 dnl CF_PROG_AWK version: 1 updated: 2006/09/16 11:40:59
3515 dnl -----------
3516 dnl Check for awk, ensure that the check found something.
3517 AC_DEFUN([CF_PROG_AWK],
3518 [
3519 AC_PROG_AWK
3520 test -z "$AWK" && AC_MSG_ERROR(No awk program found)
3521 ])dnl
3522 dnl ---------------------------------------------------------------------------
3523 dnl CF_PROG_CC_C_O version: 2 updated: 2006/12/16 15:55:46
3524 dnl --------------
3525 dnl Analogous to AC_PROG_CC_C_O, but more useful: tests only $CC, ensures that
3526 dnl the output file can be renamed, and allows for a shell variable that can
3527 dnl be used later.  The parameter is either CC or CXX.  The result is the
3528 dnl cache variable:
3529 dnl     $cf_cv_prog_CC_c_o
3530 dnl     $cf_cv_prog_CXX_c_o
3531 AC_DEFUN([CF_PROG_CC_C_O],
3532 [AC_REQUIRE([AC_PROG_CC])dnl
3533 AC_MSG_CHECKING([whether [$]$1 understands -c and -o together])
3534 AC_CACHE_VAL(cf_cv_prog_$1_c_o,
3535 [
3536 cat > conftest.$ac_ext <<CF_EOF
3537 #include <stdio.h>
3538 int main()
3539 {
3540         ${cf_cv_main_return:-return}(0);
3541 }
3542 CF_EOF
3543 # We do the test twice because some compilers refuse to overwrite an
3544 # existing .o file with -o, though they will create one.
3545 ac_try='[$]$1 -c conftest.$ac_ext -o conftest2.$ac_objext >&AC_FD_CC'
3546 if AC_TRY_EVAL(ac_try) &&
3547   test -f conftest2.$ac_objext && AC_TRY_EVAL(ac_try);
3548 then
3549   eval cf_cv_prog_$1_c_o=yes
3550 else
3551   eval cf_cv_prog_$1_c_o=no
3552 fi
3553 rm -f conftest*
3554 ])dnl
3555 if test $cf_cv_prog_$1_c_o = yes; then
3556   AC_MSG_RESULT([yes])
3557 else
3558   AC_MSG_RESULT([no])
3559 fi
3560 ])dnl
3561 dnl ---------------------------------------------------------------------------
3562 dnl CF_PROG_CC_U_D version: 1 updated: 2005/07/14 16:59:30
3563 dnl --------------
3564 dnl Check if C (preprocessor) -U and -D options are processed in the order
3565 dnl given rather than by type of option.  Some compilers insist on apply all
3566 dnl of the -U options after all of the -D options.  Others allow mixing them,
3567 dnl and may predefine symbols that conflict with those we define.
3568 AC_DEFUN([CF_PROG_CC_U_D],
3569 [
3570 AC_CACHE_CHECK(if $CC -U and -D options work together,cf_cv_cc_u_d_options,[
3571         cf_save_CPPFLAGS="$CPPFLAGS"
3572         CPPFLAGS="-UU_D_OPTIONS -DU_D_OPTIONS -DD_U_OPTIONS -UD_U_OPTIONS"
3573         AC_TRY_COMPILE([],[
3574 #ifndef U_D_OPTIONS
3575 make an undefined-error
3576 #endif
3577 #ifdef  D_U_OPTIONS
3578 make a defined-error
3579 #endif
3580         ],[
3581         cf_cv_cc_u_d_options=yes],[
3582         cf_cv_cc_u_d_options=no])
3583         CPPFLAGS="$cf_save_CPPFLAGS"
3584 ])
3585 ])dnl
3586 dnl ---------------------------------------------------------------------------
3587 dnl CF_PROG_EGREP version: 1 updated: 2006/09/16 11:40:59
3588 dnl -------------
3589 dnl AC_PROG_EGREP was introduced in autoconf 2.53.
3590 dnl This macro adds a check to ensure the script found something.
3591 AC_DEFUN([CF_PROG_EGREP],
3592 [AC_CACHE_CHECK([for egrep], [ac_cv_prog_egrep],
3593    [if echo a | (grep -E '(a|b)') >/dev/null 2>&1
3594     then ac_cv_prog_egrep='grep -E'
3595     else ac_cv_prog_egrep='egrep'
3596     fi])
3597  EGREP=$ac_cv_prog_egrep
3598  AC_SUBST([EGREP])
3599 test -z "$EGREP" && AC_MSG_ERROR(No egrep program found)
3600 ])dnl
3601 dnl ---------------------------------------------------------------------------
3602 dnl CF_PROG_EXT version: 10 updated: 2004/01/03 19:28:18
3603 dnl -----------
3604 dnl Compute $PROG_EXT, used for non-Unix ports, such as OS/2 EMX.
3605 AC_DEFUN([CF_PROG_EXT],
3606 [
3607 AC_REQUIRE([CF_CHECK_CACHE])
3608 case $cf_cv_system_name in
3609 os2*)
3610     CFLAGS="$CFLAGS -Zmt"
3611     CPPFLAGS="$CPPFLAGS -D__ST_MT_ERRNO__"
3612     CXXFLAGS="$CXXFLAGS -Zmt"
3613     # autoconf's macro sets -Zexe and suffix both, which conflict:w
3614     LDFLAGS="$LDFLAGS -Zmt -Zcrtdll"
3615     ac_cv_exeext=.exe
3616     ;;
3617 esac
3618
3619 AC_EXEEXT
3620 AC_OBJEXT
3621
3622 PROG_EXT="$EXEEXT"
3623 AC_SUBST(PROG_EXT)
3624 test -n "$PROG_EXT" && AC_DEFINE_UNQUOTED(PROG_EXT,"$PROG_EXT")
3625 ])dnl
3626 dnl ---------------------------------------------------------------------------
3627 dnl CF_PROG_INSTALL version: 5 updated: 2002/12/21 22:46:07
3628 dnl ---------------
3629 dnl Force $INSTALL to be an absolute-path.  Otherwise, edit_man.sh and the
3630 dnl misc/tabset install won't work properly.  Usually this happens only when
3631 dnl using the fallback mkinstalldirs script
3632 AC_DEFUN([CF_PROG_INSTALL],
3633 [AC_PROG_INSTALL
3634 case $INSTALL in
3635 /*)
3636   ;;
3637 *)
3638   CF_DIRNAME(cf_dir,$INSTALL)
3639   test -z "$cf_dir" && cf_dir=.
3640   INSTALL=`cd $cf_dir && pwd`/`echo $INSTALL | sed -e 's%^.*/%%'`
3641   ;;
3642 esac
3643 ])dnl
3644 dnl ---------------------------------------------------------------------------
3645 dnl CF_PROG_LDCONFIG version: 1 updated: 2003/09/20 17:07:55
3646 dnl ----------------
3647 dnl Check for ldconfig, needed to fixup shared libraries that would be built
3648 dnl and then used in the install.
3649 AC_DEFUN([CF_PROG_LDCONFIG],[
3650 if test "$cross_compiling" = yes ; then
3651   LDCONFIG=:
3652 else
3653 case "$cf_cv_system_name" in #(vi
3654 freebsd*) #(vi
3655   test -z "$LDCONFIG" && LDCONFIG="/sbin/ldconfig -R"
3656   ;;
3657 *) LDPATH=$PATH:/sbin:/usr/sbin
3658   AC_PATH_PROG(LDCONFIG,ldconfig,,$LDPATH)
3659   ;;
3660 esac
3661 fi
3662 AC_SUBST(LDCONFIG)
3663 ])dnl
3664 dnl ---------------------------------------------------------------------------
3665 dnl CF_PROG_LINT version: 1 updated: 2006/09/16 11:40:59
3666 dnl ------------
3667 AC_DEFUN([CF_PROG_LINT],
3668 [
3669 AC_CHECK_PROGS(LINT, tdlint lint alint)
3670 AC_SUBST(LINT_OPTS)
3671 ])dnl
3672 dnl ---------------------------------------------------------------------------
3673 dnl CF_REGEX version: 3 updated: 1997/11/01 14:26:01
3674 dnl --------
3675 dnl Attempt to determine if we've got one of the flavors of regular-expression
3676 dnl code that we can support.
3677 AC_DEFUN([CF_REGEX],
3678 [
3679 AC_MSG_CHECKING([for regular-expression headers])
3680 AC_CACHE_VAL(cf_cv_regex,[
3681 AC_TRY_LINK([#include <sys/types.h>
3682 #include <regex.h>],[
3683         regex_t *p;
3684         int x = regcomp(p, "", 0);
3685         int y = regexec(p, "", 0, 0, 0);
3686         regfree(p);
3687         ],[cf_cv_regex="regex.h"],[
3688         AC_TRY_LINK([#include <regexp.h>],[
3689                 char *p = compile("", "", "", 0);
3690                 int x = step("", "");
3691         ],[cf_cv_regex="regexp.h"],[
3692                 cf_save_LIBS="$LIBS"
3693                 LIBS="-lgen $LIBS"
3694                 AC_TRY_LINK([#include <regexpr.h>],[
3695                         char *p = compile("", "", "");
3696                         int x = step("", "");
3697                 ],[cf_cv_regex="regexpr.h"],[LIBS="$cf_save_LIBS"])])])
3698 ])
3699 AC_MSG_RESULT($cf_cv_regex)
3700 case $cf_cv_regex in
3701         regex.h)   AC_DEFINE(HAVE_REGEX_H_FUNCS) ;;
3702         regexp.h)  AC_DEFINE(HAVE_REGEXP_H_FUNCS) ;;
3703         regexpr.h) AC_DEFINE(HAVE_REGEXPR_H_FUNCS) ;;
3704 esac
3705 ])dnl
3706 dnl ---------------------------------------------------------------------------
3707 dnl CF_REMOVE_DEFINE version: 2 updated: 2005/07/09 16:12:18
3708 dnl ----------------
3709 dnl Remove all -U and -D options that refer to the given symbol from a list
3710 dnl of C compiler options.  This works around the problem that not all
3711 dnl compilers process -U and -D options from left-to-right, so a -U option
3712 dnl cannot be used to cancel the effect of a preceding -D option.
3713 dnl
3714 dnl $1 = target (which could be the same as the source variable)
3715 dnl $2 = source (including '$')
3716 dnl $3 = symbol to remove
3717 define([CF_REMOVE_DEFINE],
3718 [
3719 # remove $3 symbol from $2
3720 $1=`echo "$2" | \
3721         sed     -e 's/-[[UD]]$3\(=[[^   ]]*\)\?[[       ]]/ /g' \
3722                 -e 's/-[[UD]]$3\(=[[^   ]]*\)\?[$]//g'`
3723 ])dnl
3724 dnl ---------------------------------------------------------------------------
3725 dnl CF_REMOVE_LIB version: 1 updated: 2007/02/17 14:11:52
3726 dnl -------------
3727 dnl Remove the given library from the symbol
3728 dnl
3729 dnl $1 = target (which could be the same as the source variable)
3730 dnl $2 = source (including '$')
3731 dnl $3 = library to remove
3732 define([CF_REMOVE_LIB],
3733 [
3734 # remove $3 library from $2
3735 $1=`echo "$2" | sed -e 's/-l$3[[        ]]//g' -e 's/-l$3[$]//'`
3736 ])dnl
3737 dnl ---------------------------------------------------------------------------
3738 dnl CF_SHARED_OPTS version: 46 updated: 2007/02/24 18:58:09
3739 dnl --------------
3740 dnl --------------
3741 dnl Attempt to determine the appropriate CC/LD options for creating a shared
3742 dnl library.
3743 dnl
3744 dnl Note: ${LOCAL_LDFLAGS} is used to link executables that will run within the
3745 dnl build-tree, i.e., by making use of the libraries that are compiled in ../lib
3746 dnl We avoid compiling-in a ../lib path for the shared library since that can
3747 dnl lead to unexpected results at runtime.
3748 dnl ${LOCAL_LDFLAGS2} has the same intention but assumes that the shared libraries
3749 dnl are compiled in ../../lib
3750 dnl
3751 dnl The variable 'cf_cv_do_symlinks' is used to control whether we configure
3752 dnl to install symbolic links to the rel/abi versions of shared libraries.
3753 dnl
3754 dnl The variable 'cf_cv_shlib_version' controls whether we use the rel or abi
3755 dnl version when making symbolic links.
3756 dnl
3757 dnl The variable 'cf_cv_shlib_version_infix' controls whether shared library
3758 dnl version numbers are infix (ex: libncurses.<ver>.dylib) or postfix
3759 dnl (ex: libncurses.so.<ver>).
3760 dnl
3761 dnl Some loaders leave 'so_locations' lying around.  It's nice to clean up.
3762 AC_DEFUN([CF_SHARED_OPTS],
3763 [
3764         AC_REQUIRE([CF_SUBST_NCURSES_VERSION])
3765         LOCAL_LDFLAGS=
3766         LOCAL_LDFLAGS2=
3767         LD_SHARED_OPTS=
3768         INSTALL_LIB="-m 644"
3769
3770         cf_cv_do_symlinks=no
3771
3772         AC_MSG_CHECKING(if release/abi version should be used for shared libs)
3773         AC_ARG_WITH(shlib-version,
3774         [  --with-shlib-version=X  Specify rel or abi version for shared libs],
3775         [test -z "$withval" && withval=auto
3776         case $withval in #(vi
3777         yes) #(vi
3778                 cf_cv_shlib_version=auto
3779                 ;;
3780         rel|abi|auto|no) #(vi
3781                 cf_cv_shlib_version=$withval
3782                 ;;
3783         *)
3784                 AC_ERROR([option value must be one of: rel, abi, auto or no])
3785                 ;;
3786         esac
3787         ],[cf_cv_shlib_version=auto])
3788         AC_MSG_RESULT($cf_cv_shlib_version)
3789
3790         cf_cv_rm_so_locs=no
3791
3792         # Some less-capable ports of gcc support only -fpic
3793         CC_SHARED_OPTS=
3794         if test "$GCC" = yes
3795         then
3796                 AC_MSG_CHECKING(which $CC option to use)
3797                 cf_save_CFLAGS="$CFLAGS"
3798                 for CC_SHARED_OPTS in -fPIC -fpic ''
3799                 do
3800                         CFLAGS="$cf_save_CFLAGS $CC_SHARED_OPTS"
3801                         AC_TRY_COMPILE([#include <stdio.h>],[int x = 1],[break],[])
3802                 done
3803                 AC_MSG_RESULT($CC_SHARED_OPTS)
3804                 CFLAGS="$cf_save_CFLAGS"
3805         fi
3806 </