ncurses 5.6 - patch 20061230
[ncurses.git] / aclocal.m4
1 dnl***************************************************************************
2 dnl Copyright (c) 1998-2005,2006 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.411 2006/12/31 00:00:26 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_CPP_PARAM_INIT version: 4 updated: 2001/04/07 22:31:18
616 dnl -----------------
617 dnl Check if the C++ compiler accepts duplicate parameter initialization.  This
618 dnl is a late feature for the standard and is not in some recent compilers
619 dnl (1999/9/11).
620 AC_DEFUN([CF_CPP_PARAM_INIT],
621 [
622 if test -n "$CXX"; then
623 AC_CACHE_CHECK(if $CXX accepts parameter initialization,cf_cv_cpp_param_init,[
624         AC_LANG_SAVE
625         AC_LANG_CPLUSPLUS
626         AC_TRY_RUN([
627 class TEST {
628 private:
629         int value;
630 public:
631         TEST(int x = 1);
632         ~TEST();
633 };
634
635 TEST::TEST(int x = 1)   // some compilers do not like second initializer
636 {
637         value = x;
638 }
639 void main() { }
640 ],
641         [cf_cv_cpp_param_init=yes],
642         [cf_cv_cpp_param_init=no],
643         [cf_cv_cpp_param_init=unknown])
644         AC_LANG_RESTORE
645 ])
646 fi
647 test "$cf_cv_cpp_param_init" = yes && AC_DEFINE(CPP_HAS_PARAM_INIT)
648 ])dnl
649 dnl ---------------------------------------------------------------------------
650 dnl CF_CPP_STATIC_CAST version: 1 updated: 2005/07/23 16:52:43
651 dnl ------------------
652 dnl Check if the C++ compiler accepts static_cast in generics.  This appears to
653 dnl not be supported in g++ before 3.0
654 AC_DEFUN([CF_CPP_STATIC_CAST],
655 [
656 if test -n "$CXX"; then
657
658 AC_CACHE_CHECK(if $CXX accepts static_cast,cf_cv_cpp_static_cast,[
659         AC_LANG_SAVE
660         AC_LANG_CPLUSPLUS
661
662         AC_TRY_COMPILE([
663 class NCursesPanel
664 {
665 public:
666   NCursesPanel(int nlines,
667                int ncols,
668                int begin_y = 0,
669                int begin_x = 0)
670   {
671   }
672
673   ~NCursesPanel();
674 };
675
676 template<class T> class NCursesUserPanel : public NCursesPanel
677 {
678 public:
679   NCursesUserPanel (int nlines,
680                     int ncols,
681                     int begin_y = 0,
682                     int begin_x = 0,
683                     const T* p_UserData = static_cast<T*>(0))
684     : NCursesPanel (nlines, ncols, begin_y, begin_x)
685   {
686   };
687   NCursesUserPanel(const T* p_UserData = static_cast<T*>(0)) : NCursesPanel()
688   {
689   };
690
691   virtual ~NCursesUserPanel() {};
692 };
693 ],[
694         const char* p_UserData = static_cast<char*>(0)],
695         [cf_cv_cpp_static_cast=yes],
696         [cf_cv_cpp_static_cast=no])
697
698         AC_LANG_RESTORE
699 ])
700
701 fi
702
703 test "$cf_cv_cpp_static_cast" = yes && AC_DEFINE(CPP_HAS_STATIC_CAST)
704 ])dnl
705 dnl ---------------------------------------------------------------------------
706 dnl CF_CPP_VSCAN_FUNC version: 5 updated: 2001/12/02 01:39:28
707 dnl -----------------
708 dnl Check if the g++ compiler supports vscan function (not a standard feature).
709 AC_DEFUN([CF_CPP_VSCAN_FUNC],
710 [
711 if test -n "$CXX"; then
712
713 AC_LANG_SAVE
714 AC_LANG_CPLUSPLUS
715 AC_CHECK_HEADERS(strstream.h)
716
717 AC_CACHE_CHECK(if $CXX supports vscan function,cf_cv_cpp_vscan_func,[
718         for cf_vscan_func in strstream strstream_cast stdio
719         do
720         case $cf_vscan_func in #(vi
721         stdio)          cf_vscan_defs=USE_STDIO_VSCAN ;; #(vi
722         strstream)      cf_vscan_defs=USE_STRSTREAM_VSCAN ;;
723         strstream_cast) cf_vscan_defs=USE_STRSTREAM_VSCAN_CAST ;;
724         esac
725         AC_TRY_LINK([
726 #include <stdio.h>
727 #include <stdarg.h>
728 #define $cf_vscan_defs 1
729 #if defined(USE_STDIO_VSCAN)
730 #elif defined(HAVE_STRSTREAM_H) && defined(USE_STRSTREAM_VSCAN)
731 #include <strstream.h>
732 #endif
733
734 int scanw(const char* fmt, ...)
735 {
736     int result = -1;
737     char buf[BUFSIZ];
738
739     va_list args;
740     va_start(args, fmt);
741 #if defined(USE_STDIO_VSCAN)
742     if (::vsscanf(buf, fmt, args) != -1)
743         result = 0;
744 #elif defined(USE_STRSTREAM_VSCAN)
745     strstreambuf ss(buf, sizeof(buf));
746     if (ss.vscan(fmt, args) != -1)
747         result = 0;
748 #elif defined(USE_STRSTREAM_VSCAN_CAST)
749     strstreambuf ss(buf, sizeof(buf));
750     if (ss.vscan(fmt, (_IO_va_list)args) != -1)
751         result = 0;
752 #else
753 #error case $cf_vscan_func failed
754 #endif
755     va_end(args);
756     return result;
757 }
758 ],[int tmp, foo = scanw("%d", &tmp)],
759         [cf_cv_cpp_vscan_func=$cf_vscan_func; break],
760         [cf_cv_cpp_vscan_func=no])
761         test "$cf_cv_cpp_vscan_func" != no && break
762         done
763 ])
764
765 AC_LANG_RESTORE
766 fi
767
768 case $cf_cv_cpp_vscan_func in #(vi
769 stdio) #(vi
770         AC_DEFINE(CPP_HAS_VSCAN_FUNC)
771         AC_DEFINE(USE_STDIO_VSCAN)
772         ;;
773 strstream)
774         AC_DEFINE(CPP_HAS_VSCAN_FUNC)
775         AC_DEFINE(USE_STRSTREAM_VSCAN)
776         ;;
777 strstream_cast)
778         AC_DEFINE(CPP_HAS_VSCAN_FUNC)
779         AC_DEFINE(USE_STRSTREAM_VSCAN_CAST)
780         ;;
781 esac
782 ])dnl
783 dnl ---------------------------------------------------------------------------
784 dnl CF_DIRNAME version: 4 updated: 2002/12/21 19:25:52
785 dnl ----------
786 dnl "dirname" is not portable, so we fake it with a shell script.
787 AC_DEFUN([CF_DIRNAME],[$1=`echo $2 | sed -e 's%/[[^/]]*$%%'`])dnl
788 dnl ---------------------------------------------------------------------------
789 dnl CF_DIRS_TO_MAKE version: 3 updated: 2002/02/23 20:38:31
790 dnl ---------------
791 AC_DEFUN([CF_DIRS_TO_MAKE],
792 [
793 DIRS_TO_MAKE="lib"
794 for cf_item in $cf_list_models
795 do
796         CF_OBJ_SUBDIR($cf_item,cf_subdir)
797         for cf_item2 in $DIRS_TO_MAKE
798         do
799                 test $cf_item2 = $cf_subdir && break
800         done
801         test ".$cf_item2" != ".$cf_subdir" && DIRS_TO_MAKE="$DIRS_TO_MAKE $cf_subdir"
802 done
803 for cf_dir in $DIRS_TO_MAKE
804 do
805         test ! -d $cf_dir && mkdir $cf_dir
806 done
807 AC_SUBST(DIRS_TO_MAKE)
808 ])dnl
809 dnl ---------------------------------------------------------------------------
810 dnl CF_DISABLE_LEAKS version: 4 updated: 2006/12/16 15:10:42
811 dnl ----------------
812 dnl Combine no-leak checks with the libraries or tools that are used for the
813 dnl checks.
814 AC_DEFUN([CF_DISABLE_LEAKS],[
815
816 AC_REQUIRE([CF_WITH_DMALLOC])
817 AC_REQUIRE([CF_WITH_DBMALLOC])
818 AC_REQUIRE([CF_WITH_VALGRIND])
819
820 AC_MSG_CHECKING(if you want to perform memory-leak testing)
821 AC_ARG_ENABLE(leaks,
822         [  --disable-leaks         test: free permanent memory, analyze leaks],
823         [with_no_leaks=yes],
824         : ${with_no_leaks:=no})
825 AC_MSG_RESULT($with_no_leaks)
826
827 if test "$with_no_leaks" = yes ; then
828         AC_DEFINE(NO_LEAKS)
829 fi
830 ])dnl
831 dnl ---------------------------------------------------------------------------
832 dnl CF_ERRNO version: 5 updated: 1997/11/30 12:44:39
833 dnl --------
834 dnl Check if 'errno' is declared in <errno.h>
835 AC_DEFUN([CF_ERRNO],
836 [
837 CF_CHECK_ERRNO(errno)
838 ])dnl
839 dnl ---------------------------------------------------------------------------
840 dnl CF_ETIP_DEFINES version: 3 updated: 2003/03/22 19:13:43
841 dnl ---------------
842 dnl Test for conflicting definitions of exception in gcc 2.8.0, etc., between
843 dnl math.h and builtin.h, only for ncurses
844 AC_DEFUN([CF_ETIP_DEFINES],
845 [
846 AC_MSG_CHECKING(for special defines needed for etip.h)
847 cf_save_CXXFLAGS="$CXXFLAGS"
848 cf_result="none"
849 for cf_math in "" MATH_H
850 do
851 for cf_excp in "" MATH_EXCEPTION
852 do
853         CXXFLAGS="$cf_save_CXXFLAGS -I${srcdir}/c++ -I${srcdir}/menu -I${srcdir}/include"
854         test -n "$cf_math" && CXXFLAGS="$CXXFLAGS -DETIP_NEEDS_${cf_math}"
855         test -n "$cf_excp" && CXXFLAGS="$CXXFLAGS -DETIP_NEEDS_${cf_excp}"
856 AC_TRY_COMPILE([
857 #include <etip.h.in>
858 ],[],[
859         test -n "$cf_math" && AC_DEFINE_UNQUOTED(ETIP_NEEDS_${cf_math})
860         test -n "$cf_excp" && AC_DEFINE_UNQUOTED(ETIP_NEEDS_${cf_excp})
861         cf_result="$cf_math $cf_excp"
862         break
863 ],[])
864 done
865 done
866 AC_MSG_RESULT($cf_result)
867 CXXFLAGS="$cf_save_CXXFLAGS"
868 ])
869 dnl ---------------------------------------------------------------------------
870 dnl CF_FUNC_DLSYM version: 1 updated: 2004/06/16 20:52:45
871 dnl -------------
872 dnl Test for dlsym() and related functions, as well as libdl.
873 dnl
874 dnl Sets
875 dnl     $cf_have_dlsym
876 dnl     $cf_have_libdl
877 AC_DEFUN([CF_FUNC_DLSYM],[
878 cf_have_dlsym=no
879 AC_CHECK_FUNC(dlsym,cf_have_dlsym=yes,[
880
881 cf_have_libdl=no
882 AC_CHECK_LIB(dl,dlsym,[
883         cf_have_dlsym=yes
884         cf_have_libdl=yes])])
885
886 if test "$cf_have_dlsym" = yes ; then
887         test "$cf_have_libdl" = yes && LIBS="-ldl $LIBS"
888
889         AC_MSG_CHECKING(whether able to link to dl*() functions)
890         AC_TRY_LINK([#include <dlfcn.h>],[
891                 void *obj;
892                 if ((obj = dlopen("filename", 0)) != 0) {
893                         if (dlsym(obj, "symbolname") == 0) {
894                         dlclose(obj);
895                         }
896                 }],[
897                 AC_DEFINE(HAVE_LIBDL)],[
898                 AC_MSG_ERROR(Cannot link test program for libdl)])
899         AC_MSG_RESULT(ok)
900 else
901         AC_MSG_ERROR(Cannot find dlsym function)
902 fi
903 ])
904 dnl ---------------------------------------------------------------------------
905 dnl CF_FUNC_MEMMOVE version: 7 updated: 2006/12/16 12:33:30
906 dnl ---------------
907 dnl Check for memmove, or a bcopy that can handle overlapping copy.  If neither
908 dnl is found, add our own version of memmove to the list of objects.
909 AC_DEFUN([CF_FUNC_MEMMOVE],
910 [
911 AC_CHECK_FUNC(memmove,,[
912 AC_CHECK_FUNC(bcopy,[
913         AC_CACHE_CHECK(if bcopy does overlapping moves,cf_cv_good_bcopy,[
914                 AC_TRY_RUN([
915 int main() {
916         static char data[] = "abcdefghijklmnopqrstuwwxyz";
917         char temp[40];
918         bcopy(data, temp, sizeof(data));
919         bcopy(temp+10, temp, 15);
920         bcopy(temp+5, temp+15, 10);
921         ${cf_cv_main_return:-return} (strcmp(temp, "klmnopqrstuwwxypqrstuwwxyz"));
922 }
923                 ],
924                 [cf_cv_good_bcopy=yes],
925                 [cf_cv_good_bcopy=no],
926                 [cf_cv_good_bcopy=unknown])
927                 ])
928         ],[cf_cv_good_bcopy=no])
929         if test "$cf_cv_good_bcopy" = yes ; then
930                 AC_DEFINE(USE_OK_BCOPY)
931         else
932                 AC_DEFINE(USE_MY_MEMMOVE)
933         fi
934 ])])dnl
935 dnl ---------------------------------------------------------------------------
936 dnl CF_FUNC_NANOSLEEP version: 3 updated: 2006/12/16 12:33:30
937 dnl -----------------
938 dnl Check for existence of workable nanosleep() function.  Some systems, e.g.,
939 dnl AIX 4.x, provide a non-working version.
940 AC_DEFUN([CF_FUNC_NANOSLEEP],[
941 AC_CACHE_CHECK(if nanosleep really works,cf_cv_func_nanosleep,[
942 AC_TRY_RUN([
943 #include <stdio.h>
944 #include <errno.h>
945 #include <time.h>
946
947 #ifdef HAVE_SYS_TIME_H
948 #include <sys/time.h>
949 #endif
950
951 int main() {
952         struct timespec ts1, ts2;
953         int code;
954         ts1.tv_sec  = 0;
955         ts1.tv_nsec = 750000000;
956         ts2.tv_sec  = 0;
957         ts2.tv_nsec = 0;
958         errno = 0;
959         code = nanosleep(&ts1, &ts2); /* on failure errno is ENOSYS. */
960         ${cf_cv_main_return:-return}(code != 0);
961 }
962 ],
963         [cf_cv_func_nanosleep=yes],
964         [cf_cv_func_nanosleep=no],
965         [cf_cv_func_nanosleep=unknown])])
966
967 test "$cf_cv_func_nanosleep" = "yes" && AC_DEFINE(HAVE_NANOSLEEP)
968 ])
969 dnl ---------------------------------------------------------------------------
970 dnl CF_FUNC_POLL version: 4 updated: 2006/12/16 12:33:30
971 dnl ------------
972 dnl See if the poll function really works.  Some platforms have poll(), but
973 dnl it does not work for terminals or files.
974 AC_DEFUN([CF_FUNC_POLL],[
975 AC_CACHE_CHECK(if poll really works,cf_cv_working_poll,[
976 AC_TRY_RUN([
977 #include <stdio.h>
978 #ifdef HAVE_POLL_H
979 #include <poll.h>
980 #else
981 #include <sys/poll.h>
982 #endif
983 int main() {
984         struct pollfd myfds;
985         int ret;
986
987         myfds.fd = 0;
988         myfds.events = POLLIN;
989
990         ret = poll(&myfds, 1, 100);
991         ${cf_cv_main_return:-return}(ret != 0);
992 }],
993         [cf_cv_working_poll=yes],
994         [cf_cv_working_poll=no],
995         [cf_cv_working_poll=unknown])])
996 test "$cf_cv_working_poll" = "yes" && AC_DEFINE(HAVE_WORKING_POLL)
997 ])dnl
998 dnl ---------------------------------------------------------------------------
999 dnl CF_FUNC_TERMIOS version: 2 updated: 2000/07/22 23:37:24
1000 dnl ---------------
1001 dnl Some old/broken variations define tcgetattr() only as a macro in
1002 dnl termio(s).h
1003 AC_DEFUN([CF_FUNC_TERMIOS],[
1004 AC_REQUIRE([CF_STRUCT_TERMIOS])
1005 AC_CACHE_CHECK(for tcgetattr, cf_cv_have_tcgetattr,[
1006 AC_TRY_LINK([
1007 #include <sys/types.h>
1008 #ifdef HAVE_UNISTD_H
1009 #include <unistd.h>
1010 #endif
1011 #ifdef HAVE_TERMIOS_H
1012 #include <termios.h>
1013 #define TTY struct termios
1014 #else
1015 #ifdef HAVE_TERMIO_H
1016 #include <termio.h>
1017 #define TTY struct termio
1018 #endif
1019 #endif
1020 ],[
1021 TTY foo;
1022 tcgetattr(1, &foo);],
1023 [cf_cv_have_tcgetattr=yes],
1024 [cf_cv_have_tcgetattr=no])])
1025 test "$cf_cv_have_tcgetattr" = yes && AC_DEFINE(HAVE_TCGETATTR)
1026 ])dnl
1027 dnl ---------------------------------------------------------------------------
1028 dnl CF_FUNC_VSSCANF version: 3 updated: 2001/12/19 00:50:10
1029 dnl ---------------
1030 dnl Check for vsscanf() function, which is in c9x but generally not in earlier
1031 dnl versions of C.  It is in the GNU C library, and can often be simulated by
1032 dnl other functions.
1033 AC_DEFUN([CF_FUNC_VSSCANF],
1034 [
1035 AC_CACHE_CHECK(for vsscanf function or workaround,cf_cv_func_vsscanf,[
1036 AC_TRY_LINK([
1037 #include <stdarg.h>
1038 #include <stdio.h>],[
1039         va_list ap;
1040         vsscanf("from", "%d", ap)],[cf_cv_func_vsscanf=vsscanf],[
1041 AC_TRY_LINK([
1042 #include <stdarg.h>
1043 #include <stdio.h>],[
1044     FILE strbuf;
1045     char *str = "from";
1046
1047     strbuf._flag = _IOREAD;
1048     strbuf._ptr = strbuf._base = (unsigned char *) str;
1049     strbuf._cnt = strlen(str);
1050     strbuf._file = _NFILE;
1051     return (vfscanf(&strbuf, "%d", ap))],[cf_cv_func_vsscanf=vfscanf],[
1052 AC_TRY_LINK([
1053 #include <stdarg.h>
1054 #include <stdio.h>],[
1055     FILE strbuf;
1056     char *str = "from";
1057
1058     strbuf._flag = _IOREAD;
1059     strbuf._ptr = strbuf._base = (unsigned char *) str;
1060     strbuf._cnt = strlen(str);
1061     strbuf._file = _NFILE;
1062     return (_doscan(&strbuf, "%d", ap))],[cf_cv_func_vsscanf=_doscan],[
1063 cf_cv_func_vsscanf=no])])])])
1064
1065 case $cf_cv_func_vsscanf in #(vi
1066 vsscanf) AC_DEFINE(HAVE_VSSCANF);; #(vi
1067 vfscanf) AC_DEFINE(HAVE_VFSCANF);; #(vi
1068 _doscan) AC_DEFINE(HAVE__DOSCAN);;
1069 esac
1070
1071 ])dnl
1072 dnl ---------------------------------------------------------------------------
1073 dnl CF_GCC_ATTRIBUTES version: 10 updated: 2005/05/28 13:16:28
1074 dnl -----------------
1075 dnl Test for availability of useful gcc __attribute__ directives to quiet
1076 dnl compiler warnings.  Though useful, not all are supported -- and contrary
1077 dnl to documentation, unrecognized directives cause older compilers to barf.
1078 AC_DEFUN([CF_GCC_ATTRIBUTES],
1079 [
1080 if test "$GCC" = yes
1081 then
1082 cat > conftest.i <<EOF
1083 #ifndef GCC_PRINTF
1084 #define GCC_PRINTF 0
1085 #endif
1086 #ifndef GCC_SCANF
1087 #define GCC_SCANF 0
1088 #endif
1089 #ifndef GCC_NORETURN
1090 #define GCC_NORETURN /* nothing */
1091 #endif
1092 #ifndef GCC_UNUSED
1093 #define GCC_UNUSED /* nothing */
1094 #endif
1095 EOF
1096 if test "$GCC" = yes
1097 then
1098         AC_CHECKING([for $CC __attribute__ directives])
1099 cat > conftest.$ac_ext <<EOF
1100 #line __oline__ "configure"
1101 #include "confdefs.h"
1102 #include "conftest.h"
1103 #include "conftest.i"
1104 #if     GCC_PRINTF
1105 #define GCC_PRINTFLIKE(fmt,var) __attribute__((format(printf,fmt,var)))
1106 #else
1107 #define GCC_PRINTFLIKE(fmt,var) /*nothing*/
1108 #endif
1109 #if     GCC_SCANF
1110 #define GCC_SCANFLIKE(fmt,var)  __attribute__((format(scanf,fmt,var)))
1111 #else
1112 #define GCC_SCANFLIKE(fmt,var)  /*nothing*/
1113 #endif
1114 extern void wow(char *,...) GCC_SCANFLIKE(1,2);
1115 extern void oops(char *,...) GCC_PRINTFLIKE(1,2) GCC_NORETURN;
1116 extern void foo(void) GCC_NORETURN;
1117 int main(int argc GCC_UNUSED, char *argv[[]] GCC_UNUSED) { return 0; }
1118 EOF
1119         for cf_attribute in scanf printf unused noreturn
1120         do
1121                 CF_UPPER(cf_ATTRIBUTE,$cf_attribute)
1122                 cf_directive="__attribute__(($cf_attribute))"
1123                 echo "checking for $CC $cf_directive" 1>&AC_FD_CC
1124                 case $cf_attribute in
1125                 scanf|printf)
1126                 cat >conftest.h <<EOF
1127 #define GCC_$cf_ATTRIBUTE 1
1128 EOF
1129                         ;;
1130                 *)
1131                 cat >conftest.h <<EOF
1132 #define GCC_$cf_ATTRIBUTE $cf_directive
1133 EOF
1134                         ;;
1135                 esac
1136                 if AC_TRY_EVAL(ac_compile); then
1137                         test -n "$verbose" && AC_MSG_RESULT(... $cf_attribute)
1138                         cat conftest.h >>confdefs.h
1139                 fi
1140         done
1141 else
1142         fgrep define conftest.i >>confdefs.h
1143 fi
1144 rm -rf conftest*
1145 fi
1146 ])dnl
1147 dnl ---------------------------------------------------------------------------
1148 dnl CF_GCC_VERSION version: 4 updated: 2005/08/27 09:53:42
1149 dnl --------------
1150 dnl Find version of gcc
1151 AC_DEFUN([CF_GCC_VERSION],[
1152 AC_REQUIRE([AC_PROG_CC])
1153 GCC_VERSION=none
1154 if test "$GCC" = yes ; then
1155         AC_MSG_CHECKING(version of $CC)
1156         GCC_VERSION="`${CC} --version| sed -e '2,$d' -e 's/^.*(GCC) //' -e 's/^[[^0-9.]]*//' -e 's/[[^0-9.]].*//'`"
1157         test -z "$GCC_VERSION" && GCC_VERSION=unknown
1158         AC_MSG_RESULT($GCC_VERSION)
1159 fi
1160 ])dnl
1161 dnl ---------------------------------------------------------------------------
1162 dnl CF_GCC_WARNINGS version: 20 updated: 2005/08/06 18:37:29
1163 dnl ---------------
1164 dnl Check if the compiler supports useful warning options.  There's a few that
1165 dnl we don't use, simply because they're too noisy:
1166 dnl
1167 dnl     -Wconversion (useful in older versions of gcc, but not in gcc 2.7.x)
1168 dnl     -Wredundant-decls (system headers make this too noisy)
1169 dnl     -Wtraditional (combines too many unrelated messages, only a few useful)
1170 dnl     -Wwrite-strings (too noisy, but should review occasionally).  This
1171 dnl             is enabled for ncurses using "--enable-const".
1172 dnl     -pedantic
1173 dnl
1174 dnl Parameter:
1175 dnl     $1 is an optional list of gcc warning flags that a particular
1176 dnl             application might want to use, e.g., "no-unused" for
1177 dnl             -Wno-unused
1178 dnl Special:
1179 dnl     If $with_ext_const is "yes", add a check for -Wwrite-strings
1180 dnl
1181 AC_DEFUN([CF_GCC_WARNINGS],
1182 [
1183 AC_REQUIRE([CF_GCC_VERSION])
1184 CF_INTEL_COMPILER(GCC,INTEL_COMPILER,CFLAGS)
1185
1186 cat > conftest.$ac_ext <<EOF
1187 #line __oline__ "configure"
1188 int main(int argc, char *argv[[]]) { return (argv[[argc-1]] == 0) ; }
1189 EOF
1190
1191 if test "$INTEL_COMPILER" = yes
1192 then
1193 # The "-wdXXX" options suppress warnings:
1194 # remark #1419: external declaration in primary source file
1195 # remark #1682: implicit conversion of a 64-bit integral type to a smaller integral type (potential portability problem)
1196 # remark #1683: explicit conversion of a 64-bit integral type to a smaller integral type (potential portability problem)
1197 # remark #1684: conversion from pointer to same-sized integral type (potential portability problem)
1198 # remark #193: zero used for undefined preprocessing identifier
1199 # remark #593: variable "curs_sb_left_arrow" was set but never used
1200 # remark #810: conversion from "int" to "Dimension={unsigned short}" may lose significant bits
1201 # remark #869: parameter "tw" was never referenced
1202 # remark #981: operands are evaluated in unspecified order
1203 # warning #269: invalid format string conversion
1204
1205         AC_CHECKING([for $CC warning options])
1206         cf_save_CFLAGS="$CFLAGS"
1207         EXTRA_CFLAGS="-Wall"
1208         for cf_opt in $1 \
1209                 wd1419 \
1210                 wd1682 \
1211                 wd1683 \
1212                 wd1684 \
1213                 wd193 \
1214                 wd279 \
1215                 wd593 \
1216                 wd810 \
1217                 wd869 \
1218                 wd981
1219         do
1220                 CFLAGS="$cf_save_CFLAGS $EXTRA_CFLAGS -$cf_opt"
1221                 if AC_TRY_EVAL(ac_compile); then
1222                         test -n "$verbose" && AC_MSG_RESULT(... -$cf_opt)
1223                         EXTRA_CFLAGS="$EXTRA_CFLAGS -$cf_opt"
1224                 fi
1225         done
1226         CFLAGS="$cf_save_CFLAGS"
1227
1228 elif test "$GCC" = yes
1229 then
1230         AC_CHECKING([for $CC warning options])
1231         cf_save_CFLAGS="$CFLAGS"
1232         EXTRA_CFLAGS="-W -Wall"
1233         cf_warn_CONST=""
1234         test "$with_ext_const" = yes && cf_warn_CONST="Wwrite-strings"
1235         for cf_opt in \
1236                 Wbad-function-cast \
1237                 Wcast-align \
1238                 Wcast-qual \
1239                 Winline \
1240                 Wmissing-declarations \
1241                 Wmissing-prototypes \
1242                 Wnested-externs \
1243                 Wpointer-arith \
1244                 Wshadow \
1245                 Wstrict-prototypes \
1246                 Wundef $cf_warn_CONST $1
1247         do
1248                 CFLAGS="$cf_save_CFLAGS $EXTRA_CFLAGS -$cf_opt"
1249                 if AC_TRY_EVAL(ac_compile); then
1250                         test -n "$verbose" && AC_MSG_RESULT(... -$cf_opt)
1251                         case $cf_opt in #(vi
1252                         Wcast-qual) #(vi
1253                                 CPPFLAGS="$CPPFLAGS -DXTSTRINGDEFINES"
1254                                 ;;
1255                         Winline) #(vi
1256                                 case $GCC_VERSION in
1257                                 3.3*)
1258                                         CF_VERBOSE(feature is broken in gcc $GCC_VERSION)
1259                                         continue;;
1260                                 esac
1261                                 ;;
1262                         esac
1263                         EXTRA_CFLAGS="$EXTRA_CFLAGS -$cf_opt"
1264                 fi
1265         done
1266         CFLAGS="$cf_save_CFLAGS"
1267 fi
1268 rm -f conftest*
1269
1270 AC_SUBST(EXTRA_CFLAGS)
1271 ])dnl
1272 dnl ---------------------------------------------------------------------------
1273 dnl CF_GNAT_TRY_LINK version: 1 updated: 2004/08/21 19:02:08
1274 dnl ----------------
1275 dnl Verify that a test program compiles/links with GNAT.
1276 dnl $cf_ada_make is set to the program that compiles/links
1277 dnl $ADAFLAGS may be set to the GNAT flags.
1278 dnl
1279 dnl $1 is the text of the spec
1280 dnl $2 is the text of the body
1281 dnl $3 is the shell command to execute if successful
1282 dnl $4 is the shell command to execute if not successful
1283 AC_DEFUN([CF_GNAT_TRY_LINK],
1284 [
1285 rm -f conftest*
1286 cat >>conftest.ads <<CF_EOF
1287 $1
1288 CF_EOF
1289 cat >>conftest.adb <<CF_EOF
1290 $2
1291 CF_EOF
1292 if ( $cf_ada_make $ADAFLAGS conftest 1>&AC_FD_CC 2>&1 ) ; then
1293 ifelse($3,,      :,[      $3])
1294 ifelse($4,,,[else
1295    $4])
1296 fi
1297 rm -f conftest*
1298 ])dnl
1299 dnl ---------------------------------------------------------------------------
1300 dnl CF_GNAT_TRY_RUN version: 3 updated: 2004/08/21 19:02:08
1301 dnl ---------------
1302 dnl Verify that a test program compiles and runs with GNAT
1303 dnl $cf_ada_make is set to the program that compiles/links
1304 dnl $ADAFLAGS may be set to the GNAT flags.
1305 dnl
1306 dnl $1 is the text of the spec
1307 dnl $2 is the text of the body
1308 dnl $3 is the shell command to execute if successful
1309 dnl $4 is the shell command to execute if not successful
1310 AC_DEFUN([CF_GNAT_TRY_RUN],
1311 [
1312 rm -f conftest*
1313 cat >>conftest.ads <<CF_EOF
1314 $1
1315 CF_EOF
1316 cat >>conftest.adb <<CF_EOF
1317 $2
1318 CF_EOF
1319 if ( $cf_ada_make $ADAFLAGS conftest 1>&AC_FD_CC 2>&1 ) ; then
1320    if ( ./conftest 1>&AC_FD_CC 2>&1 ) ; then
1321 ifelse($3,,      :,[      $3])
1322 ifelse($4,,,[   else
1323       $4])
1324    fi
1325 ifelse($4,,,[else
1326    $4])
1327 fi
1328 rm -f conftest*
1329 ])dnl
1330 dnl ---------------------------------------------------------------------------
1331 dnl CF_GNAT_VERSION version: 12 updated: 2006/10/14 15:23:15
1332 dnl ---------------
1333 dnl Verify version of GNAT.
1334 AC_DEFUN([CF_GNAT_VERSION],
1335 [
1336 AC_MSG_CHECKING(for gnat version)
1337 cf_gnat_version=`${cf_ada_make-gnatmake} -v 2>&1 | grep '[[0-9]].[[0-9]][[0-9]]*' |\
1338   sed -e '2,$d' -e 's/[[^0-9 \.]]//g' -e 's/^[[ ]]*//' -e 's/ .*//'`
1339 AC_MSG_RESULT($cf_gnat_version)
1340
1341 case $cf_gnat_version in
1342   3.1[[1-9]]*|3.[[2-9]]*|[[4-9]].*)
1343     cf_cv_prog_gnat_correct=yes
1344     ;;
1345   *) echo Unsupported GNAT version $cf_gnat_version. Required is 3.11 or better. Disabling Ada95 binding.
1346      cf_cv_prog_gnat_correct=no
1347      ;;
1348 esac
1349 case $cf_gnat_version in
1350   3.[[1-9]]*|[[4-9]].*)
1351       cf_compile_generics=generics
1352       cf_generic_objects="\${GENOBJS}"
1353       ;;
1354   *)  cf_compile_generics=
1355       cf_generic_objects=
1356       ;;
1357 esac
1358 ])
1359 dnl ---------------------------------------------------------------------------
1360 dnl CF_GNU_SOURCE version: 6 updated: 2005/07/09 13:23:07
1361 dnl -------------
1362 dnl Check if we must define _GNU_SOURCE to get a reasonable value for
1363 dnl _XOPEN_SOURCE, upon which many POSIX definitions depend.  This is a defect
1364 dnl (or misfeature) of glibc2, which breaks portability of many applications,
1365 dnl since it is interwoven with GNU extensions.
1366 dnl
1367 dnl Well, yes we could work around it...
1368 AC_DEFUN([CF_GNU_SOURCE],
1369 [
1370 AC_CACHE_CHECK(if we must define _GNU_SOURCE,cf_cv_gnu_source,[
1371 AC_TRY_COMPILE([#include <sys/types.h>],[
1372 #ifndef _XOPEN_SOURCE
1373 make an error
1374 #endif],
1375         [cf_cv_gnu_source=no],
1376         [cf_save="$CPPFLAGS"
1377          CPPFLAGS="$CPPFLAGS -D_GNU_SOURCE"
1378          AC_TRY_COMPILE([#include <sys/types.h>],[
1379 #ifdef _XOPEN_SOURCE
1380 make an error
1381 #endif],
1382         [cf_cv_gnu_source=no],
1383         [cf_cv_gnu_source=yes])
1384         CPPFLAGS="$cf_save"
1385         ])
1386 ])
1387 test "$cf_cv_gnu_source" = yes && CPPFLAGS="$CPPFLAGS -D_GNU_SOURCE"
1388 ])dnl
1389 dnl ---------------------------------------------------------------------------
1390 dnl CF_GPP_LIBRARY version: 8 updated: 2003/02/02 01:41:46
1391 dnl --------------
1392 dnl If we're trying to use g++, test if libg++ is installed (a rather common
1393 dnl problem :-).  If we have the compiler but no library, we'll be able to
1394 dnl configure, but won't be able to build the c++ demo program.
1395 AC_DEFUN([CF_GPP_LIBRARY],
1396 [
1397 cf_cxx_library=unknown
1398 case $cf_cv_system_name in #(vi
1399 os2*) #(vi
1400         cf_gpp_libname=gpp
1401         ;;
1402 *)
1403         cf_gpp_libname=g++
1404         ;;
1405 esac
1406 if test "$GXX" = yes; then
1407         AC_MSG_CHECKING([for lib$cf_gpp_libname])
1408         cf_save="$LIBS"
1409         LIBS="$LIBS -l$cf_gpp_libname"
1410         AC_TRY_LINK([
1411 #include <$cf_gpp_libname/builtin.h>
1412         ],
1413         [two_arg_error_handler_t foo2 = lib_error_handler],
1414         [cf_cxx_library=yes
1415          CXXLIBS="$CXXLIBS -l$cf_gpp_libname"
1416          if test "$cf_gpp_libname" = cpp ; then
1417             AC_DEFINE(HAVE_GPP_BUILTIN_H)
1418          else
1419             AC_DEFINE(HAVE_GXX_BUILTIN_H)
1420          fi],
1421         [AC_TRY_LINK([
1422 #include <builtin.h>
1423         ],
1424         [two_arg_error_handler_t foo2 = lib_error_handler],
1425         [cf_cxx_library=yes
1426          CXXLIBS="$CXXLIBS -l$cf_gpp_libname"
1427          AC_DEFINE(HAVE_BUILTIN_H)],
1428         [cf_cxx_library=no])])
1429         LIBS="$cf_save"
1430         AC_MSG_RESULT($cf_cxx_library)
1431 fi
1432 ])dnl
1433 dnl ---------------------------------------------------------------------------
1434 dnl CF_GXX_VERSION version: 5 updated: 2005/08/27 09:53:42
1435 dnl --------------
1436 dnl Check for version of g++
1437 AC_DEFUN([CF_GXX_VERSION],[
1438 AC_REQUIRE([AC_PROG_CPP])
1439 GXX_VERSION=none
1440 if test "$GXX" = yes; then
1441         AC_MSG_CHECKING(version of g++)
1442         GXX_VERSION="`${CXX-g++} --version| sed -e '2,$d' -e 's/^.*(GCC) //' -e 's/^[[^0-9.]]*//' -e 's/[[^0-9.]].*//'`"
1443         test -z "$GXX_VERSION" && GXX_VERSION=unknown
1444         AC_MSG_RESULT($GXX_VERSION)
1445 fi
1446 ])dnl
1447 dnl ---------------------------------------------------------------------------
1448 dnl CF_GXX_WARNINGS version: 5 updated: 2005/08/13 14:54:38
1449 dnl ---------------
1450 dnl Check if the compiler supports useful warning options.
1451 dnl
1452 dnl Most of gcc's options apply to g++, except:
1453 dnl     -Wbad-function-cast
1454 dnl     -Wmissing-declarations
1455 dnl     -Wnested-externs
1456 dnl
1457 dnl Omit a few (for now):
1458 dnl     -Winline
1459 dnl
1460 dnl Parameter:
1461 dnl     $1 is an optional list of g++ warning flags that a particular
1462 dnl             application might want to use, e.g., "no-unused" for
1463 dnl             -Wno-unused
1464 dnl Special:
1465 dnl     If $with_ext_const is "yes", add a check for -Wwrite-strings
1466 dnl
1467 AC_DEFUN([CF_GXX_WARNINGS],
1468 [
1469
1470 CF_INTEL_COMPILER(GXX,INTEL_CPLUSPLUS,CXXFLAGS)
1471
1472 AC_REQUIRE([CF_GXX_VERSION])
1473
1474 AC_LANG_SAVE
1475 AC_LANG_CPLUSPLUS
1476
1477 cat > conftest.$ac_ext <<EOF
1478 #line __oline__ "configure"
1479 int main(int argc, char *argv[[]]) { return (argv[[argc-1]] == 0) ; }
1480 EOF
1481
1482 if test "$INTEL_CPLUSPLUS" = yes
1483 then
1484 # The "-wdXXX" options suppress warnings:
1485 # remark #1419: external declaration in primary source file
1486 # remark #1682: implicit conversion of a 64-bit integral type to a smaller integral type (potential portability problem)
1487 # remark #1683: explicit conversion of a 64-bit integral type to a smaller integral type (potential portability problem)
1488 # remark #1684: conversion from pointer to same-sized integral type (potential portability problem)
1489 # remark #193: zero used for undefined preprocessing identifier
1490 # remark #593: variable "curs_sb_left_arrow" was set but never used
1491 # remark #810: conversion from "int" to "Dimension={unsigned short}" may lose significant bits
1492 # remark #869: parameter "tw" was never referenced
1493 # remark #981: operands are evaluated in unspecified order
1494 # warning #269: invalid format string conversion
1495
1496         AC_CHECKING([for $CC warning options])
1497         cf_save_CXXFLAGS="$CXXFLAGS"
1498         EXTRA_CXXFLAGS="-Wall"
1499         for cf_opt in \
1500                 wd1419 \
1501                 wd1682 \
1502                 wd1683 \
1503                 wd1684 \
1504                 wd193 \
1505                 wd279 \
1506                 wd593 \
1507                 wd810 \
1508                 wd869 \
1509                 wd981
1510         do
1511                 CXXFLAGS="$cf_save_CXXFLAGS $EXTRA_CXXFLAGS -$cf_opt"
1512                 if AC_TRY_EVAL(ac_compile); then
1513                         test -n "$verbose" && AC_MSG_RESULT(... -$cf_opt)
1514                         EXTRA_CXXFLAGS="$EXTRA_CXXFLAGS -$cf_opt"
1515                 fi
1516         done
1517         CXXFLAGS="$cf_save_CXXFLAGS"
1518
1519 elif test "$GXX" = yes
1520 then
1521         AC_CHECKING([for $CXX warning options])
1522         cf_save_CXXFLAGS="$CXXFLAGS"
1523         EXTRA_CXXFLAGS="-W -Wall"
1524         cf_gxx_extra_warnings=""
1525         test "$with_ext_const" = yes && cf_gxx_extra_warnings="Wwrite-strings"
1526         case "$GCC_VERSION" in
1527         [[1-2]].*)
1528                 ;;
1529         *)
1530                 cf_gxx_extra_warnings="$cf_gxx_extra_warnings Weffc++"
1531                 ;;
1532         esac
1533         for cf_opt in \
1534                 Wabi \
1535                 fabi-version=0 \
1536                 Woverloaded-virtual \
1537                 Wsign-promo \
1538                 Wsynth \
1539                 Wold-style-cast \
1540                 Wcast-align \
1541                 Wcast-qual \
1542                 Wmissing-prototypes \
1543                 Wpointer-arith \
1544                 Wshadow \
1545                 Wstrict-prototypes \
1546                 Wundef $cf_gxx_extra_warnings $1
1547         do
1548                 CXXFLAGS="$cf_save_CXXFLAGS $EXTRA_CXXFLAGS -Werror -$cf_opt"
1549                 if AC_TRY_EVAL(ac_compile); then
1550                         test -n "$verbose" && AC_MSG_RESULT(... -$cf_opt)
1551                         EXTRA_CXXFLAGS="$EXTRA_CXXFLAGS -$cf_opt"
1552                 else
1553                         test -n "$verbose" && AC_MSG_RESULT(... no -$cf_opt)
1554                 fi
1555         done
1556         CXXFLAGS="$cf_save_CXXFLAGS"
1557 fi
1558
1559 rm -f conftest*
1560 AC_LANG_RESTORE
1561 AC_SUBST(EXTRA_CXXFLAGS)
1562 ])dnl
1563 dnl ---------------------------------------------------------------------------
1564 dnl CF_HASHED_DB version: 1 updated: 2006/08/19 09:16:14
1565 dnl ------------
1566 dnl Look for an instance of the Berkeley hashed database.
1567 AC_DEFUN([CF_HASHED_DB],
1568 [
1569 AC_CHECK_HEADER(db.h,[
1570 CF_HASHED_DB_VERSION
1571 if test "$cf_cv_hashed_db_version" = unknown ; then
1572         AC_MSG_ERROR(Cannot determine version of db)
1573 else
1574         CF_HASHED_DB_LIBS
1575         if test "$cf_cv_hashed_db_libs" = unknown ; then
1576                 AC_MSG_ERROR(Cannot determine library for db)
1577         elif test "$cf_cv_hashed_db_libs" != default ; then
1578                 LIBS="-l$cf_cv_hashed_db_libs $LIBS"
1579         fi
1580 fi
1581 ],[
1582         AC_MSG_ERROR(Cannot find db.h)
1583 ])
1584 ])dnl
1585 dnl ---------------------------------------------------------------------------
1586 dnl CF_HASHED_DB_LIBS version: 6 updated: 2006/12/16 12:33:30
1587 dnl -----------------
1588 dnl Given that we have the header and version for hashed database, find the
1589 dnl library information.
1590 AC_DEFUN([CF_HASHED_DB_LIBS],
1591 [
1592 AC_CACHE_CHECK(for db libraries, cf_cv_hashed_db_libs,[
1593 cf_cv_hashed_db_libs=unknown
1594 for cf_db_libs in db$cf_cv_hashed_db_version db ''
1595 do
1596         cf_save_libs="$LIBS"
1597         if test -n "$cf_db_libs"; then
1598                 LIBS="-l$cf_db_libs $LIBS"
1599         fi
1600         CF_MSG_LOG(checking for library "$cf_db_libs")
1601         AC_TRY_LINK([
1602 $ac_includes_default
1603 #include <db.h>
1604 ],[
1605         char *path = "/tmp/foo";
1606 #ifdef DB_VERSION_MAJOR
1607 #if DB_VERSION_MAJOR >= 4
1608         DB *result = 0;
1609         db_create(&result, NULL, 0);
1610         result->open(result,
1611                 NULL,
1612                 path,
1613                 path,
1614                 DB_HASH,
1615                 DB_CREATE,
1616                 0644);
1617 #elif DB_VERSION_MAJOR >= 3
1618         DB *result = 0;
1619         db_create(&result, NULL, 0);
1620         result->open(result,
1621                 path,
1622                 path,
1623                 DB_HASH,
1624                 DB_CREATE,
1625                 0644);
1626 #elif DB_VERSION_MAJOR >= 2
1627         DB *result = 0;
1628         db_open(path,
1629                 DB_HASH,
1630                 DB_CREATE,
1631                 0644,
1632                 (DB_ENV *) 0,
1633                 (DB_INFO *) 0,
1634                 &result);
1635 #endif /* DB_VERSION_MAJOR */
1636 #else
1637         DB *result = dbopen(path,
1638                      2,
1639                      0644,
1640                      DB_HASH,
1641                      0);
1642 #endif
1643         ${cf_cv_main_return:-return}(result != 0)
1644 ],[
1645         if test -n "$cf_db_libs" ; then
1646                 cf_cv_hashed_db_libs=$cf_db_libs
1647         else
1648                 cf_cv_hashed_db_libs=default
1649         fi
1650         LIBS="$cf_save_libs"
1651         break
1652 ])
1653         LIBS="$cf_save_libs"
1654 done
1655 ])
1656 ])dnl
1657 dnl ---------------------------------------------------------------------------
1658 dnl CF_HASHED_DB_VERSION version: 2 updated: 2006/08/19 15:12:49
1659 dnl --------------------
1660 dnl Given that we have the header file for hashed database, find the version
1661 dnl information.
1662 AC_DEFUN([CF_HASHED_DB_VERSION],
1663 [
1664 AC_CACHE_CHECK(for version of db, cf_cv_hashed_db_version,[
1665 cf_cv_hashed_db_version=unknown
1666
1667 for cf_db_version in 1 2 3 4
1668 do
1669         CF_MSG_LOG(checking for db version $cf_db_version)
1670         AC_TRY_COMPILE([
1671 $ac_includes_default
1672 #include <db.h>
1673
1674 #ifdef DB_VERSION_MAJOR
1675         /* db2 (DB_VERSION_MAJOR=2) has also DB_VERSION_MINOR, tested with 7 */
1676 #if $cf_db_version == DB_VERSION_MAJOR
1677         /* ok */
1678 #else
1679         make an error
1680 #endif
1681 #else
1682 #if $cf_db_version == 1
1683         /* ok: assuming this is DB 1.8.5 */
1684 #else
1685         make an error
1686 #endif
1687 #endif
1688 ],[DBT *foo = 0],[
1689         cf_cv_hashed_db_version=$cf_db_version
1690         break
1691         ])
1692 done
1693 ])
1694 ])dnl
1695 dnl ---------------------------------------------------------------------------
1696 dnl CF_HELP_MESSAGE version: 3 updated: 1998/01/14 10:56:23
1697 dnl ---------------
1698 dnl Insert text into the help-message, for readability, from AC_ARG_WITH.
1699 AC_DEFUN([CF_HELP_MESSAGE],
1700 [AC_DIVERT_HELP([$1])dnl
1701 ])dnl
1702 dnl ---------------------------------------------------------------------------
1703 dnl CF_INCLUDE_DIRS version: 5 updated: 2006/10/14 15:23:15
1704 dnl ---------------
1705 dnl Construct the list of include-options according to whether we're building
1706 dnl in the source directory or using '--srcdir=DIR' option.  If we're building
1707 dnl with gcc, don't append the includedir if it happens to be /usr/include,
1708 dnl since that usually breaks gcc's shadow-includes.
1709 AC_DEFUN([CF_INCLUDE_DIRS],
1710 [
1711 CPPFLAGS="-I. -I../include $CPPFLAGS"
1712 if test "$srcdir" != "."; then
1713         CPPFLAGS="-I\${srcdir}/../include $CPPFLAGS"
1714 fi
1715 if test "$GCC" != yes; then
1716         CPPFLAGS="$CPPFLAGS -I\${includedir}"
1717 elif test "$includedir" != "/usr/include"; then
1718         if test "$includedir" = '${prefix}/include' ; then
1719                 if test $prefix != /usr ; then
1720                         CPPFLAGS="$CPPFLAGS -I\${includedir}"
1721                 fi
1722         else
1723                 CPPFLAGS="$CPPFLAGS -I\${includedir}"
1724         fi
1725 fi
1726 AC_SUBST(CPPFLAGS)
1727 ])dnl
1728 dnl ---------------------------------------------------------------------------
1729 dnl CF_INTEL_COMPILER version: 3 updated: 2005/08/06 18:37:29
1730 dnl -----------------
1731 dnl Check if the given compiler is really the Intel compiler for Linux.  It
1732 dnl tries to imitate gcc, but does not return an error when it finds a mismatch
1733 dnl between prototypes, e.g., as exercised by CF_MISSING_CHECK.
1734 dnl
1735 dnl This macro should be run "soon" after AC_PROG_CC or AC_PROG_CPLUSPLUS, to
1736 dnl ensure that it is not mistaken for gcc/g++.  It is normally invoked from
1737 dnl the wrappers for gcc and g++ warnings.
1738 dnl
1739 dnl $1 = GCC (default) or GXX
1740 dnl $2 = INTEL_COMPILER (default) or INTEL_CPLUSPLUS
1741 dnl $3 = CFLAGS (default) or CXXFLAGS
1742 AC_DEFUN([CF_INTEL_COMPILER],[
1743 ifelse($2,,INTEL_COMPILER,[$2])=no
1744
1745 if test "$ifelse($1,,[$1],GCC)" = yes ; then
1746         case $host_os in
1747         linux*|gnu*)
1748                 AC_MSG_CHECKING(if this is really Intel ifelse($1,GXX,C++,C) compiler)
1749                 cf_save_CFLAGS="$ifelse($3,,CFLAGS,[$3])"
1750                 ifelse($3,,CFLAGS,[$3])="$ifelse($3,,CFLAGS,[$3]) -no-gcc"
1751                 AC_TRY_COMPILE([],[
1752 #ifdef __INTEL_COMPILER
1753 #else
1754 make an error
1755 #endif
1756 ],[ifelse($2,,INTEL_COMPILER,[$2])=yes
1757 cf_save_CFLAGS="$cf_save_CFLAGS -we147 -no-gcc"
1758 ],[])
1759                 ifelse($3,,CFLAGS,[$3])="$cf_save_CFLAGS"
1760                 AC_MSG_RESULT($ifelse($2,,INTEL_COMPILER,[$2]))
1761                 ;;
1762         esac
1763 fi
1764 ])dnl
1765 dnl ---------------------------------------------------------------------------
1766 dnl CF_ISASCII version: 3 updated: 2000/08/12 23:18:52
1767 dnl ----------
1768 dnl Check if we have either a function or macro for 'isascii()'.
1769 AC_DEFUN([CF_ISASCII],
1770 [
1771 AC_MSG_CHECKING(for isascii)
1772 AC_CACHE_VAL(cf_cv_have_isascii,[
1773         AC_TRY_LINK([#include <ctype.h>],[int x = isascii(' ')],
1774         [cf_cv_have_isascii=yes],
1775         [cf_cv_have_isascii=no])
1776 ])dnl
1777 AC_MSG_RESULT($cf_cv_have_isascii)
1778 test "$cf_cv_have_isascii" = yes && AC_DEFINE(HAVE_ISASCII)
1779 ])dnl
1780 dnl ---------------------------------------------------------------------------
1781 dnl CF_LARGEFILE version: 6 updated: 2006/09/23 19:07:52
1782 dnl ------------
1783 dnl Add checks for large file support.
1784 AC_DEFUN([CF_LARGEFILE],[
1785 ifdef([AC_FUNC_FSEEKO],[
1786     AC_SYS_LARGEFILE
1787     if test "$enable_largefile" != no ; then
1788         AC_FUNC_FSEEKO
1789
1790         # Normally we would collect these definitions in the config.h,
1791         # but (like _XOPEN_SOURCE), some environments rely on having these
1792         # defined before any of the system headers are included.  Another
1793         # case comes up with C++, e.g., on AIX the compiler compiles the
1794         # header files by themselves before looking at the body files it is
1795         # told to compile.  For ncurses, those header files do not include
1796         # the config.h
1797         test "$ac_cv_sys_large_files"      != no && CPPFLAGS="$CPPFLAGS -D_LARGE_FILES "
1798         test "$ac_cv_sys_largefile_source" != no && CPPFLAGS="$CPPFLAGS -D_LARGEFILE_SOURCE "
1799
1800         AC_CACHE_CHECK(whether to use struct dirent64, cf_cv_struct_dirent64,[
1801                 AC_TRY_COMPILE([
1802 #include <sys/types.h>
1803 #include <dirent.h>
1804                 ],[
1805                 /* if transitional largefile support is setup, this is true */
1806                 extern struct dirent64 * readdir(DIR *);
1807                 struct dirent64 *x = readdir((DIR *)0);
1808                 struct dirent *y = readdir((DIR *)0);
1809                 int z = x - y;
1810                 ],
1811                 [cf_cv_struct_dirent64=yes],
1812                 [cf_cv_struct_dirent64=no])
1813         ])
1814         test "$cf_cv_struct_dirent64" = yes && AC_DEFINE(HAVE_STRUCT_DIRENT64)
1815     fi
1816 ])
1817 ])
1818 dnl ---------------------------------------------------------------------------
1819 dnl CF_LIBUTF8 version: 2 updated: 2002/01/19 22:51:32
1820 dnl ----------
1821 dnl Check for libutf8
1822 AC_DEFUN([CF_LIBUTF8],
1823 [
1824 AC_CACHE_CHECK(for putwc in libutf8,cf_cv_libutf8,[
1825         cf_save_LIBS="$LIBS"
1826         LIBS="-lutf8 $LIBS"
1827 AC_TRY_LINK([
1828 #include <libutf8.h>],[putwc(0,0);],
1829         [cf_cv_libutf8=yes],
1830         [cf_cv_libutf8=no])
1831         LIBS="$cf_save_LIBS"
1832 ])
1833
1834 if test "$cf_cv_libutf8" = yes ; then
1835         AC_DEFINE(HAVE_LIBUTF8_H)
1836         LIBS="-lutf8 $LIBS"
1837 fi
1838 ])dnl
1839 dnl ---------------------------------------------------------------------------
1840 dnl CF_LIB_PREFIX version: 7 updated: 2001/01/12 01:23:48
1841 dnl -------------
1842 dnl Compute the library-prefix for the given host system
1843 dnl $1 = variable to set
1844 AC_DEFUN([CF_LIB_PREFIX],
1845 [
1846         case $cf_cv_system_name in
1847         OS/2*)  LIB_PREFIX=''     ;;
1848         os2*)   LIB_PREFIX=''     ;;
1849         *)      LIB_PREFIX='lib'  ;;
1850         esac
1851 ifelse($1,,,[$1=$LIB_PREFIX])
1852         AC_SUBST(LIB_PREFIX)
1853 ])dnl
1854 dnl ---------------------------------------------------------------------------
1855 dnl CF_LIB_RULES version: 41 updated: 2006/12/23 18:04:51
1856 dnl ------------
1857 dnl Append definitions and rules for the given models to the subdirectory
1858 dnl Makefiles, and the recursion rule for the top-level Makefile.  If the
1859 dnl subdirectory is a library-source directory, modify the LIBRARIES list in
1860 dnl the corresponding makefile to list the models that we'll generate.
1861 dnl
1862 dnl For shared libraries, make a list of symbolic links to construct when
1863 dnl generating each library.  The convention used for Linux is the simplest
1864 dnl one:
1865 dnl     lib<name>.so    ->
1866 dnl     lib<name>.so.<major>    ->
1867 dnl     lib<name>.so.<maj>.<minor>
1868 AC_DEFUN([CF_LIB_RULES],
1869 [
1870 CF_LIB_PREFIX(cf_prefix)
1871 AC_REQUIRE([CF_SUBST_NCURSES_VERSION])
1872 for cf_dir in $SRC_SUBDIRS
1873 do
1874         if test ! -d $srcdir/$cf_dir ; then
1875                 continue
1876         elif test -f $srcdir/$cf_dir/modules; then
1877
1878                 IMPORT_LIB=
1879                 SHARED_LIB=
1880                 LIBS_TO_MAKE=
1881                 for cf_item in $cf_LIST_MODELS
1882                 do
1883                         CF_LIB_SUFFIX($cf_item,cf_suffix)
1884                         if test $cf_item = shared ; then
1885                         if test "$cf_cv_do_symlinks" = yes ; then
1886                                 case "$cf_cv_shlib_version" in #(vi
1887                                 rel) #(vi
1888                                         case "$cf_cv_system_name" in #(vi
1889                                         darwin*)
1890                                         case .${LIB_SUFFIX} in
1891                                         .w*)
1892                                                 cf_suffix=`echo $cf_suffix | sed 's/^w//'`
1893                                                 cf_suffix=w'.${REL_VERSION}'"$cf_suffix"
1894                                                 ;;
1895                                         *)
1896                                                 cf_suffix='.${REL_VERSION}'"$cf_suffix"
1897                                                 ;;
1898                                         esac
1899                                         ;; #(vi
1900                                         *) cf_suffix="$cf_suffix"'.${REL_VERSION}' ;;
1901                                         esac
1902                                         ;;
1903                                 abi)
1904                                         case "$cf_cv_system_name" in #(vi
1905                                         darwin*)
1906                                         case .${LIB_SUFFIX} in
1907                                         .w*)
1908                                                 cf_suffix=`echo $cf_suffix | sed 's/^w//'`
1909                                                 cf_suffix=w'.${ABI_VERSION}'"$cf_suffix"
1910                                                 ;;
1911                                         *)
1912                                                 cf_suffix='.${ABI_VERSION}'"$cf_suffix"
1913                                                 ;;
1914                                         esac
1915                                         ;; #(vi
1916                                         *) cf_suffix="$cf_suffix"'.${ABI_VERSION}' ;;
1917                                         esac
1918                                         ;;
1919                                 esac
1920                         fi
1921                         # cygwin needs import library, and has unique naming convention
1922                         # use autodetected ${cf_prefix} for import lib and static lib, but
1923                         # use 'cyg' prefix for shared lib.
1924                         if test $cf_cv_shlib_version = cygdll ; then
1925                                 SHARED_LIB="cyg${cf_dir}\${ABI_VERSION}.dll"
1926                                 IMPORT_LIB="${cf_prefix}${cf_dir}.dll.a"
1927                                 LIBS_TO_MAKE="$LIBS_TO_MAKE ../lib/\${SHARED_LIB} ../lib/\${IMPORT_LIB}"
1928                                 continue
1929                         fi
1930                         fi
1931                         LIBS_TO_MAKE="$LIBS_TO_MAKE ../lib/${cf_prefix}${cf_dir}${cf_suffix}"
1932                 done
1933
1934                 if test $cf_dir = ncurses ; then
1935                         cf_subsets="$LIB_SUBSETS"
1936                         cf_termlib=`echo "$cf_subsets" |sed -e 's/ .*$//'`
1937                         if test "$cf_termlib" != "$cf_subsets" ; then
1938                                 cf_item=`echo $LIBS_TO_MAKE |sed -e s%${LIB_NAME}${LIB_SUFFIX}%${TINFO_LIB_SUFFIX}%g`
1939                                 LIBS_TO_MAKE="$cf_item $LIBS_TO_MAKE"
1940                         fi
1941                 else
1942                         cf_subsets=`echo "$LIB_SUBSETS" | sed -e 's/^termlib.* //'`
1943                 fi
1944
1945                 sed -e "s%@LIBS_TO_MAKE@%$LIBS_TO_MAKE%" \
1946                     -e "s%@IMPORT_LIB@%$IMPORT_LIB%" \
1947                     -e "s%@SHARED_LIB@%$SHARED_LIB%" \
1948                         $cf_dir/Makefile >$cf_dir/Makefile.out
1949                 mv $cf_dir/Makefile.out $cf_dir/Makefile
1950
1951                 $AWK -f $srcdir/mk-0th.awk \
1952                         libname="${cf_dir}${LIB_SUFFIX}" subsets="$LIB_SUBSETS" \
1953                         $srcdir/$cf_dir/modules >>$cf_dir/Makefile
1954
1955                 for cf_subset in $cf_subsets
1956                 do
1957                         cf_subdirs=
1958                         for cf_item in $cf_LIST_MODELS
1959                         do
1960                         echo "Appending rules for ${cf_item} model (${cf_dir}: ${cf_subset})"
1961                         CF_UPPER(cf_ITEM,$cf_item)
1962                         CF_LIB_SUFFIX($cf_item,cf_suffix)
1963                         CF_OBJ_SUBDIR($cf_item,cf_subdir)
1964
1965                         # Test for case where we build libtinfo with a different name.
1966                         cf_libname=$cf_dir
1967                         if test $cf_dir = ncurses ; then
1968                                 case $cf_subset in
1969                                 *base*)
1970                                         ;;
1971                                 termlib*)
1972                                         cf_libname=$TINFO_LIB_SUFFIX
1973                                         if test -n "${DFT_ARG_SUFFIX}" ; then
1974                                                 # undo $LIB_SUFFIX add-on in CF_LIB_SUFFIX
1975                                                 cf_suffix=`echo $cf_suffix |sed -e "s%^${LIB_SUFFIX}%%"`
1976                                         fi
1977                                 ;;
1978                                 esac
1979                         fi
1980
1981                         # These dependencies really are for development, not
1982                         # builds, but they are useful in porting, too.
1983                         cf_depend="../include/ncurses_cfg.h"
1984                         if test "$srcdir" = "."; then
1985                                 cf_reldir="."
1986                         else
1987                                 cf_reldir="\${srcdir}"
1988                         fi
1989
1990                         if test -f $srcdir/$cf_dir/$cf_dir.priv.h; then
1991                                 cf_depend="$cf_depend $cf_reldir/$cf_dir.priv.h"
1992                         elif test -f $srcdir/$cf_dir/curses.priv.h; then
1993                                 cf_depend="$cf_depend $cf_reldir/curses.priv.h"
1994                         fi
1995
1996                         cf_dir_suffix=
1997                         old_cf_suffix="$cf_suffix"
1998                         if test "$cf_cv_shlib_version_infix" = yes ; then
1999                         if test -n "$LIB_SUFFIX" ; then
2000                                 case $LIB_SUFFIX in
2001                                 w*)
2002                                         cf_libname=`echo $cf_libname | sed 's/w$//'`
2003                                         cf_suffix=`echo $cf_suffix | sed 's/^w//'`
2004                                         cf_dir_suffix=w
2005                                         ;;
2006                                 esac
2007                         fi
2008                         fi
2009
2010                         $AWK -f $srcdir/mk-1st.awk \
2011                                 name=${cf_libname}${cf_dir_suffix} \
2012                                 traces=$LIB_TRACING \
2013                                 MODEL=$cf_ITEM \
2014                                 model=$cf_subdir \
2015                                 prefix=$cf_prefix \
2016                                 suffix=$cf_suffix \
2017                                 subset=$cf_subset \
2018                                 ShlibVer=$cf_cv_shlib_version \
2019                                 ShlibVerInfix=$cf_cv_shlib_version_infix \
2020                                 DoLinks=$cf_cv_do_symlinks \
2021                                 rmSoLocs=$cf_cv_rm_so_locs \
2022                                 ldconfig="$LDCONFIG" \
2023                                 overwrite=$WITH_OVERWRITE \
2024                                 depend="$cf_depend" \
2025                                 host="$host" \
2026                                 $srcdir/$cf_dir/modules >>$cf_dir/Makefile
2027
2028                         cf_suffix="$old_cf_suffix"
2029
2030                         for cf_subdir2 in $cf_subdirs lib
2031                         do
2032                                 test $cf_subdir = $cf_subdir2 && break
2033                         done
2034                         test "${cf_subset}.${cf_subdir2}" != "${cf_subset}.${cf_subdir}" && \
2035                         $AWK -f $srcdir/mk-2nd.awk \
2036                                 name=$cf_dir \
2037                                 traces=$LIB_TRACING \
2038                                 MODEL=$cf_ITEM \
2039                                 model=$cf_subdir \
2040                                 subset=$cf_subset \
2041                                 srcdir=$srcdir \
2042                                 echo=$WITH_ECHO \
2043                                 crenames=$cf_cv_prog_CC_c_o \
2044                                 cxxrenames=$cf_cv_prog_CXX_c_o \
2045                                 $srcdir/$cf_dir/modules >>$cf_dir/Makefile
2046                         cf_subdirs="$cf_subdirs $cf_subdir"
2047                         done
2048                 done
2049         fi
2050
2051         echo '  cd '$cf_dir' && ${MAKE} ${CF_MFLAGS} [$]@' >>Makefile
2052 done
2053
2054 for cf_dir in $SRC_SUBDIRS
2055 do
2056         if test ! -d $srcdir/$cf_dir ; then
2057                 continue
2058         fi
2059
2060         if test -f $cf_dir/Makefile ; then
2061                 case "$cf_dir" in
2062                 Ada95) #(vi
2063                         echo 'libs \' >> Makefile
2064                         echo 'install.libs \' >> Makefile
2065                         echo 'uninstall.libs ::' >> Makefile
2066                         echo '  cd '$cf_dir' && ${MAKE} ${CF_MFLAGS} [$]@' >> Makefile
2067                         ;;
2068                 esac
2069         fi
2070
2071         if test -f $srcdir/$cf_dir/modules; then
2072                 echo >> Makefile
2073                 if test -f $srcdir/$cf_dir/headers; then
2074 cat >> Makefile <<CF_EOF
2075 install.includes \\
2076 uninstall.includes \\
2077 CF_EOF
2078                 fi
2079 if test "$cf_dir" != "c++" ; then
2080 echo 'lint \' >> Makefile
2081 fi
2082 cat >> Makefile <<CF_EOF
2083 libs \\
2084 lintlib \\
2085 install.libs \\
2086 uninstall.libs \\
2087 install.$cf_dir \\
2088 uninstall.$cf_dir ::
2089         cd $cf_dir && \${MAKE} \${CF_MFLAGS} \[$]@
2090 CF_EOF
2091         elif test -f $srcdir/$cf_dir/headers; then
2092 cat >> Makefile <<CF_EOF
2093
2094 libs \\
2095 install.libs \\
2096 uninstall.libs \\
2097 install.includes \\
2098 uninstall.includes ::
2099         cd $cf_dir && \${MAKE} \${CF_MFLAGS} \[$]@
2100 CF_EOF
2101 fi
2102 done
2103
2104 cat >> Makefile <<CF_EOF
2105
2106 install.libs uninstall.libs \\
2107 install.data uninstall.data ::
2108 $MAKE_TERMINFO  cd misc && \${MAKE} \${CF_MFLAGS} \[$]@
2109
2110 install.man \\
2111 uninstall.man ::
2112         cd man && \${MAKE} \${CF_MFLAGS} \[$]@
2113
2114 distclean ::
2115         rm -f config.cache config.log config.status Makefile include/ncurses_cfg.h
2116         rm -f headers.sh headers.sed
2117         rm -rf \${DIRS_TO_MAKE}
2118 CF_EOF
2119
2120 # Special case: tack's manpage lives in its own directory.
2121 if test -d tack ; then
2122 if test -f $srcdir/$tack.h; then
2123 cat >> Makefile <<CF_EOF
2124
2125 install.man \\
2126 uninstall.man ::
2127         cd tack && \${MAKE} \${CF_MFLAGS} \[$]@
2128 CF_EOF
2129 fi
2130 fi
2131
2132 dnl If we're installing into a subdirectory of /usr/include, etc., we should
2133 dnl prepend the subdirectory's name to the "#include" paths.  It won't hurt
2134 dnl anything, and will make it more standardized.  It's awkward to decide this
2135 dnl at configuration because of quoting, so we'll simply make all headers
2136 dnl installed via a script that can do the right thing.
2137
2138 rm -f headers.sed headers.sh
2139
2140 dnl ( generating this script makes the makefiles a little tidier :-)
2141 echo creating headers.sh
2142 cat >headers.sh <<CF_EOF
2143 #! /bin/sh
2144 # This shell script is generated by the 'configure' script.  It is invoked in a
2145 # subdirectory of the build tree.  It generates a sed-script in the parent
2146 # directory that is used to adjust includes for header files that reside in a
2147 # subdirectory of /usr/include, etc.
2148 PRG=""
2149 while test \[$]# != 3
2150 do
2151 PRG="\$PRG \[$]1"; shift
2152 done
2153 DST=\[$]1
2154 REF=\[$]2
2155 SRC=\[$]3
2156 TMPSRC=\${TMPDIR-/tmp}/\`basename \$SRC\`\$\$
2157 TMPSED=\${TMPDIR-/tmp}/headers.sed\$\$
2158 echo installing \$SRC in \$DST
2159 CF_EOF
2160
2161 if test $WITH_CURSES_H = yes; then
2162         cat >>headers.sh <<CF_EOF
2163 case \$DST in
2164 /*/include/*)
2165         END=\`basename \$DST\`
2166         for i in \`cat \$REF/../*/headers |fgrep -v "#"\`
2167         do
2168                 NAME=\`basename \$i\`
2169                 echo "s/<\$NAME>/<\$END\/\$NAME>/" >> \$TMPSED
2170         done
2171         ;;
2172 *)
2173         echo "" >> \$TMPSED
2174         ;;
2175 esac
2176 CF_EOF
2177
2178 else
2179         cat >>headers.sh <<CF_EOF
2180 case \$DST in
2181 /*/include/*)
2182         END=\`basename \$DST\`
2183         for i in \`cat \$REF/../*/headers |fgrep -v "#"\`
2184         do
2185                 NAME=\`basename \$i\`
2186                 if test "\$NAME" = "curses.h"
2187                 then
2188                         echo "s/<curses.h>/<ncurses.h>/" >> \$TMPSED
2189                         NAME=ncurses.h
2190                 fi
2191                 echo "s/<\$NAME>/<\$END\/\$NAME>/" >> \$TMPSED
2192         done
2193         ;;
2194 *)
2195         echo "s/<curses.h>/<ncurses.h>/" >> \$TMPSED
2196         ;;
2197 esac
2198 CF_EOF
2199 fi
2200 cat >>headers.sh <<CF_EOF
2201 rm -f \$TMPSRC
2202 sed -f \$TMPSED \$SRC > \$TMPSRC
2203 NAME=\`basename \$SRC\`
2204 CF_EOF
2205 if test $WITH_CURSES_H != yes; then
2206         cat >>headers.sh <<CF_EOF
2207 test "\$NAME" = "curses.h" && NAME=ncurses.h
2208 CF_EOF
2209 fi
2210 cat >>headers.sh <<CF_EOF
2211 # Just in case someone gzip'd manpages, remove the conflicting copy.
2212 test -f \$DST/\$NAME.gz && rm -f \$DST/\$NAME.gz
2213
2214 eval \$PRG \$TMPSRC \$DST/\$NAME
2215 rm -f \$TMPSRC \$TMPSED
2216 CF_EOF
2217
2218 chmod 0755 headers.sh
2219
2220 for cf_dir in $SRC_SUBDIRS
2221 do
2222         if test ! -d $srcdir/$cf_dir ; then
2223                 continue
2224         fi
2225
2226         if test -f $srcdir/$cf_dir/headers; then
2227         cat >>$cf_dir/Makefile <<CF_EOF
2228 \${DESTDIR}\${includedir} :
2229         sh \${srcdir}/../mkinstalldirs \[$]@
2230
2231 install \\
2232 install.libs \\
2233 install.includes :: \${AUTO_SRC} \${DESTDIR}\${includedir} \\
2234 CF_EOF
2235                 j=""
2236                 for i in `cat $srcdir/$cf_dir/headers |fgrep -v "#"`
2237                 do
2238                         test -n "$j" && echo "          $j \\" >>$cf_dir/Makefile
2239                         j=$i
2240                 done
2241
2242                 echo "          $j" >>$cf_dir/Makefile
2243
2244                 for i in `cat $srcdir/$cf_dir/headers |fgrep -v "#"`
2245                 do
2246                         echo "  @ (cd \${DESTDIR}\${includedir} && rm -f `basename $i`) ; ../headers.sh \${INSTALL_DATA} \${DESTDIR}\${includedir} \${srcdir} $i" >>$cf_dir/Makefile
2247                         test $i = curses.h && test $WITH_CURSES_H = yes && echo "       @ (cd \${DESTDIR}\${includedir} && rm -f ncurses.h && \${LN_S} curses.h ncurses.h)" >>$cf_dir/Makefile
2248                 done
2249
2250         cat >>$cf_dir/Makefile <<CF_EOF
2251
2252 uninstall \\
2253 uninstall.libs \\
2254 uninstall.includes ::
2255 CF_EOF
2256                 for i in `cat $srcdir/$cf_dir/headers |fgrep -v "#"`
2257                 do
2258                         i=`basename $i`
2259                         echo "  -@ (cd \${DESTDIR}\${includedir} && rm -f $i)" >>$cf_dir/Makefile
2260                         test $i = curses.h && echo "    -@ (cd \${DESTDIR}\${includedir} && rm -f ncurses.h)" >>$cf_dir/Makefile
2261                 done
2262         fi
2263
2264         if test -f $srcdir/$cf_dir/modules; then
2265                 if test "$cf_dir" != "c++" ; then
2266                         cat >>$cf_dir/Makefile <<"CF_EOF"
2267 depend : ${AUTO_SRC}
2268         makedepend -- ${CPPFLAGS} -- ${C_SRC}
2269
2270 # DO NOT DELETE THIS LINE -- make depend depends on it.
2271 CF_EOF
2272                 fi
2273         fi
2274 done
2275
2276 ])dnl
2277 dnl ---------------------------------------------------------------------------
2278 dnl CF_LIB_SONAME version: 3 updated: 2006/12/16 15:55:46
2279 dnl -------------
2280 dnl Find the and soname for the given shared library.  Set the cache variable
2281 dnl cf_cv_$3_soname to this, unless it is not found.  Then set the cache
2282 dnl variable to "unknown".
2283 dnl
2284 dnl $1 = headers
2285 dnl $2 = code
2286 dnl $3 = library name
2287 AC_DEFUN([CF_LIB_SONAME],
2288 [
2289 AC_CACHE_CHECK(for soname of $3 library,cf_cv_$3_soname,[
2290
2291 cf_cv_$3_soname=unknown
2292 if test "$cross_compiling" != yes ; then
2293 cat >conftest.$ac_ext <<CF_EOF
2294 $1
2295 int main()
2296 {
2297 $2
2298         ${cf_cv_main_return:-return}(0);
2299 }
2300 CF_EOF
2301 cf_save_LIBS="$LIBS"
2302         LIBS="-l$3 $LIBS"
2303         if AC_TRY_EVAL(ac_compile) ; then
2304                 if AC_TRY_EVAL(ac_link) ; then
2305                         cf_cv_$3_soname=`ldd conftest$ac_exeext 2>/dev/null | sed -e 's,^.*/,,' -e 's, .*$,,' | fgrep lib$3.`
2306                         test -z "$cf_cv_$3_soname" && cf_cv_$3_soname=unknown
2307                 fi
2308         fi
2309 rm -f conftest*
2310 LIBS="$cf_save_LIBS"
2311 fi
2312 ])
2313 ])
2314 dnl ---------------------------------------------------------------------------
2315 dnl CF_LIB_SUFFIX version: 13 updated: 2003/11/01 16:09:07
2316 dnl -------------
2317 dnl Compute the library file-suffix from the given model name
2318 dnl $1 = model name
2319 dnl $2 = variable to set
2320 dnl The variable $LIB_SUFFIX, if set, prepends the variable to set.
2321 AC_DEFUN([CF_LIB_SUFFIX],
2322 [
2323         AC_REQUIRE([CF_SUBST_NCURSES_VERSION])
2324         case $1 in
2325         libtool) $2='.la'  ;;
2326         normal)  $2='.a'   ;;
2327         debug)   $2='_g.a' ;;
2328         profile) $2='_p.a' ;;
2329         shared)
2330                 case $cf_cv_system_name in
2331                 cygwin*) $2='.dll' ;;
2332                 darwin*) $2='.dylib' ;;
2333                 hpux*)
2334                         case $target in
2335                         ia64*)  $2='.so' ;;
2336                         *)      $2='.sl' ;;
2337                         esac
2338                         ;;
2339                 *)      $2='.so'  ;;
2340                 esac
2341         esac
2342         test -n "$LIB_SUFFIX" && $2="${LIB_SUFFIX}[$]{$2}"
2343 ])dnl
2344 dnl ---------------------------------------------------------------------------
2345 dnl CF_LIB_TYPE version: 4 updated: 2000/10/20 22:57:49
2346 dnl -----------
2347 dnl Compute the string to append to -library from the given model name
2348 dnl $1 = model name
2349 dnl $2 = variable to set
2350 dnl The variable $LIB_SUFFIX, if set, prepends the variable to set.
2351 AC_DEFUN([CF_LIB_TYPE],
2352 [
2353         case $1 in
2354         libtool) $2=''   ;;
2355         normal)  $2=''   ;;
2356         debug)   $2='_g' ;;
2357         profile) $2='_p' ;;
2358         shared)  $2=''   ;;
2359         esac
2360         test -n "$LIB_SUFFIX" && $2="${LIB_SUFFIX}[$]{$2}"
2361 ])dnl
2362 dnl ---------------------------------------------------------------------------
2363 dnl CF_LINK_DATAONLY version: 8 updated: 2006/12/16 12:33:30
2364 dnl ----------------
2365 dnl Some systems have a non-ANSI linker that doesn't pull in modules that have
2366 dnl only data (i.e., no functions), for example NeXT.  On those systems we'll
2367 dnl have to provide wrappers for global tables to ensure they're linked
2368 dnl properly.
2369 AC_DEFUN([CF_LINK_DATAONLY],
2370 [
2371 AC_MSG_CHECKING([if data-only library module links])
2372 AC_CACHE_VAL(cf_cv_link_dataonly,[
2373         rm -f conftest.a
2374         cat >conftest.$ac_ext <<EOF
2375 #line __oline__ "configure"
2376 int     testdata[[3]] = { 123, 456, 789 };
2377 EOF
2378         if AC_TRY_EVAL(ac_compile) ; then
2379                 mv conftest.o data.o && \
2380                 ( $AR $AR_OPTS conftest.a data.o ) 2>&AC_FD_CC 1>/dev/null
2381         fi
2382         rm -f conftest.$ac_ext data.o
2383         cat >conftest.$ac_ext <<EOF
2384 #line __oline__ "configure"
2385 int     testfunc()
2386 {
2387 #if defined(NeXT)
2388         ${cf_cv_main_return:-return}(1);        /* I'm told this linker is broken */
2389 #else
2390         extern int testdata[[3]];
2391         return testdata[[0]] == 123
2392            &&  testdata[[1]] == 456
2393            &&  testdata[[2]] == 789;
2394 #endif
2395 }
2396 EOF
2397         if AC_TRY_EVAL(ac_compile); then
2398                 mv conftest.o func.o && \
2399                 ( $AR $AR_OPTS conftest.a func.o ) 2>&AC_FD_CC 1>/dev/null
2400         fi
2401         rm -f conftest.$ac_ext func.o
2402         ( eval $RANLIB conftest.a ) 2>&AC_FD_CC >/dev/null
2403         cf_saveLIBS="$LIBS"
2404         LIBS="conftest.a $LIBS"
2405         AC_TRY_RUN([
2406         int main()
2407         {
2408                 extern int testfunc();
2409                 ${cf_cv_main_return:-return} (!testfunc());
2410         }
2411         ],
2412         [cf_cv_link_dataonly=yes],
2413         [cf_cv_link_dataonly=no],
2414         [cf_cv_link_dataonly=unknown])
2415         LIBS="$cf_saveLIBS"
2416         ])
2417 AC_MSG_RESULT($cf_cv_link_dataonly)
2418
2419 if test "$cf_cv_link_dataonly" = no ; then
2420         AC_DEFINE(BROKEN_LINKER)
2421         BROKEN_LINKER=1
2422 fi
2423
2424 ])dnl
2425 dnl ---------------------------------------------------------------------------
2426 dnl CF_LINK_FUNCS version: 7 updated: 2006/12/16 12:33:30
2427 dnl -------------
2428 dnl Most Unix systems have both link and symlink, a few don't have symlink.
2429 dnl A few non-Unix systems implement symlink, but not link.
2430 dnl A few non-systems implement neither (or have nonfunctional versions).
2431 AC_DEFUN([CF_LINK_FUNCS],
2432 [
2433 AC_CHECK_FUNCS( \
2434         remove \
2435         unlink )
2436
2437 if test "$cross_compiling" = yes ; then
2438         AC_CHECK_FUNCS( \
2439                 link \
2440                 symlink )
2441 else
2442         AC_CACHE_CHECK(if link/symlink functions work,cf_cv_link_funcs,[
2443                 cf_cv_link_funcs=
2444                 for cf_func in link symlink ; do
2445                         AC_TRY_RUN([
2446 #include <sys/types.h>
2447 #include <sys/stat.h>
2448 #ifdef HAVE_UNISTD_H
2449 #include <unistd.h>
2450 #endif
2451 int main()
2452 {
2453         int fail = 0;
2454         char *src = "config.log";
2455         char *dst = "conftest.chk";
2456         struct stat src_sb;
2457         struct stat dst_sb;
2458
2459         stat(src, &src_sb);
2460         fail = ($cf_func("config.log", "conftest.chk") < 0)
2461             || (stat(dst, &dst_sb) < 0)
2462             || (dst_sb.st_mtime != src_sb.st_mtime);
2463 #ifdef HAVE_UNLINK
2464         unlink(dst);
2465 #else
2466         remove(dst);
2467 #endif
2468         ${cf_cv_main_return:-return} (fail);
2469 }
2470                         ],[
2471                         cf_cv_link_funcs="$cf_cv_link_funcs $cf_func"
2472                         eval 'ac_cv_func_'$cf_func'=yes'],[
2473                         eval 'ac_cv_func_'$cf_func'=no'],[
2474                         eval 'ac_cv_func_'$cf_func'=error'])
2475                 done
2476                 test -z "$cf_cv_link_funcs" && cf_cv_link_funcs=no
2477         ])
2478         test "$ac_cv_func_link"    = yes && AC_DEFINE(HAVE_LINK)
2479         test "$ac_cv_func_symlink" = yes && AC_DEFINE(HAVE_SYMLINK)
2480 fi
2481 ])dnl
2482 dnl ---------------------------------------------------------------------------
2483 dnl CF_MAIN_RETURN version: 1 updated: 2006/12/10 09:51:54
2484 dnl --------------
2485 dnl Check if a return from main to the shell actually returns the same exit
2486 dnl code.  This is true for almost any POSIX environment.
2487 dnl
2488 dnl Some very old environments did not flush stdout, etc., on an exit.  That
2489 dnl would be a useful case to test for also.
2490 AC_DEFUN([CF_MAIN_RETURN],
2491 [
2492 cf_cv_main_return=return
2493 ])dnl
2494 dnl ---------------------------------------------------------------------------
2495 dnl CF_MAKEFLAGS version: 12 updated: 2006/10/21 08:27:03
2496 dnl ------------
2497 dnl Some 'make' programs support ${MAKEFLAGS}, some ${MFLAGS}, to pass 'make'
2498 dnl options to lower-levels.  It's very useful for "make -n" -- if we have it.
2499 dnl (GNU 'make' does both, something POSIX 'make', which happens to make the
2500 dnl ${MAKEFLAGS} variable incompatible because it adds the assignments :-)
2501 AC_DEFUN([CF_MAKEFLAGS],
2502 [
2503 AC_CACHE_CHECK(for makeflags variable, cf_cv_makeflags,[
2504         cf_cv_makeflags=''
2505         for cf_option in '-${MAKEFLAGS}' '${MFLAGS}'
2506         do
2507                 cat >cf_makeflags.tmp <<CF_EOF
2508 SHELL = /bin/sh
2509 all :
2510         @ echo '.$cf_option'
2511 CF_EOF
2512                 cf_result=`${MAKE-make} -k -f cf_makeflags.tmp 2>/dev/null | sed -e 's,[[       ]]*$,,'`
2513                 case "$cf_result" in
2514                 .*k)
2515                         cf_result=`${MAKE-make} -k -f cf_makeflags.tmp CC=cc 2>/dev/null`
2516                         case "$cf_result" in
2517                         .*CC=*) cf_cv_makeflags=
2518                                 ;;
2519                         *)      cf_cv_makeflags=$cf_option
2520                                 ;;
2521                         esac
2522                         break
2523                         ;;
2524                 .-)     ;;
2525                 *)      echo "given option \"$cf_option\", no match \"$cf_result\""
2526                         ;;
2527                 esac
2528         done
2529         rm -f cf_makeflags.tmp
2530 ])
2531
2532 AC_SUBST(cf_cv_makeflags)
2533 ])dnl
2534 dnl ---------------------------------------------------------------------------
2535 dnl CF_MAKE_TAGS version: 2 updated: 2000/10/04 09:18:40
2536 dnl ------------
2537 dnl Generate tags/TAGS targets for makefiles.  Do not generate TAGS if we have
2538 dnl a monocase filesystem.
2539 AC_DEFUN([CF_MAKE_TAGS],[
2540 AC_REQUIRE([CF_MIXEDCASE_FILENAMES])
2541 AC_CHECK_PROG(MAKE_LOWER_TAGS, ctags, yes, no)
2542
2543 if test "$cf_cv_mixedcase" = yes ; then
2544         AC_CHECK_PROG(MAKE_UPPER_TAGS, etags, yes, no)
2545 else
2546         MAKE_UPPER_TAGS=no
2547 fi
2548
2549 if test "$MAKE_UPPER_TAGS" = yes ; then
2550         MAKE_UPPER_TAGS=
2551 else
2552         MAKE_UPPER_TAGS="#"
2553 fi
2554 AC_SUBST(MAKE_UPPER_TAGS)
2555
2556 if test "$MAKE_LOWER_TAGS" = yes ; then
2557         MAKE_LOWER_TAGS=
2558 else
2559         MAKE_LOWER_TAGS="#"
2560 fi
2561 AC_SUBST(MAKE_LOWER_TAGS)
2562 ])dnl
2563 dnl ---------------------------------------------------------------------------
2564 dnl CF_MANPAGE_FORMAT version: 7 updated: 2003/12/20 19:30:34
2565 dnl -----------------
2566 dnl Option to allow user to override automatic configuration of manpage format.
2567 dnl There are several special cases:
2568 dnl
2569 dnl     gzip - man checks for, can display gzip'd files
2570 dnl     compress - man checks for, can display compressed files
2571 dnl     BSDI - files in the cat-directories are suffixed ".0"
2572 dnl     formatted - installer should format (put files in cat-directory)
2573 dnl     catonly - installer should only format, e.g., for a turnkey system.
2574 dnl
2575 dnl There are other configurations which this macro does not test, e.g., HPUX's
2576 dnl compressed manpages (but uncompressed manpages are fine, and HPUX's naming
2577 dnl convention would not match our use).
2578 AC_DEFUN([CF_MANPAGE_FORMAT],
2579 [
2580 AC_REQUIRE([CF_PATHSEP])
2581 AC_MSG_CHECKING(format of man-pages)
2582
2583 AC_ARG_WITH(manpage-format,
2584         [  --with-manpage-format   specify manpage-format: gzip/compress/BSDI/normal and
2585                           optionally formatted/catonly, e.g., gzip,formatted],
2586         [MANPAGE_FORMAT=$withval],
2587         [MANPAGE_FORMAT=unknown])
2588
2589 test -z "$MANPAGE_FORMAT" && MANPAGE_FORMAT=unknown
2590 MANPAGE_FORMAT=`echo "$MANPAGE_FORMAT" | sed -e 's/,/ /g'`
2591
2592 cf_unknown=
2593
2594 case $MANPAGE_FORMAT in
2595 unknown)
2596   if test -z "$MANPATH" ; then
2597     MANPATH="/usr/man:/usr/share/man"
2598   fi
2599
2600   # look for the 'date' man-page (it's most likely to be installed!)
2601   MANPAGE_FORMAT=
2602   cf_preform=no
2603   cf_catonly=yes
2604   cf_example=date
2605
2606   IFS="${IFS=   }"; ac_save_ifs="$IFS"; IFS="${IFS}${PATHSEP}"
2607   for cf_dir in $MANPATH; do
2608     test -z "$cf_dir" && cf_dir=/usr/man
2609     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
2610     do
2611       cf_test=`echo $cf_name | sed -e 's/*//'`
2612       if test "x$cf_test" = "x$cf_name" ; then
2613
2614         case "$cf_name" in
2615         *.gz) MANPAGE_FORMAT="$MANPAGE_FORMAT gzip";;
2616         *.Z)  MANPAGE_FORMAT="$MANPAGE_FORMAT compress";;
2617         *.0)    MANPAGE_FORMAT="$MANPAGE_FORMAT BSDI";;
2618         *)    MANPAGE_FORMAT="$MANPAGE_FORMAT normal";;
2619         esac
2620
2621         case "$cf_name" in
2622         $cf_dir/man*)
2623           cf_catonly=no
2624           ;;
2625         $cf_dir/cat*)
2626           cf_preform=yes
2627           ;;
2628         esac
2629         break
2630       fi
2631
2632       # if we found a match in either man* or cat*, stop looking
2633       if test -n "$MANPAGE_FORMAT" ; then
2634         cf_found=no
2635         test "$cf_preform" = yes && MANPAGE_FORMAT="$MANPAGE_FORMAT formatted"
2636         test "$cf_catonly" = yes && MANPAGE_FORMAT="$MANPAGE_FORMAT catonly"
2637         case "$cf_name" in
2638         $cf_dir/cat*)
2639           cf_found=yes
2640           ;;
2641         esac
2642         test $cf_found=yes && break
2643       fi
2644     done
2645     # only check the first directory in $MANPATH where we find manpages
2646     if test -n "$MANPAGE_FORMAT" ; then
2647        break
2648     fi
2649   done
2650   # if we did not find the example, just assume it is normal
2651   test -z "$MANPAGE_FORMAT" && MANPAGE_FORMAT=normal
2652   IFS="$ac_save_ifs"
2653   ;;
2654 *)
2655   for cf_option in $MANPAGE_FORMAT; do
2656      case $cf_option in #(vi
2657      gzip|compress|BSDI|normal|formatted|catonly)
2658        ;;
2659      *)
2660        cf_unknown="$cf_unknown $cf_option"
2661        ;;
2662      esac
2663   done
2664   ;;
2665 esac
2666
2667 AC_MSG_RESULT($MANPAGE_FORMAT)
2668 if test -n "$cf_unknown" ; then
2669   AC_MSG_WARN(Unexpected manpage-format $cf_unknown)
2670 fi
2671 ])dnl
2672 dnl ---------------------------------------------------------------------------
2673 dnl CF_MANPAGE_RENAMES version: 7 updated: 2005/06/18 18:51:57
2674 dnl ------------------
2675 dnl The Debian people have their own naming convention for manpages.  This
2676 dnl option lets us override the name of the file containing renaming, or
2677 dnl disable it altogether.
2678 AC_DEFUN([CF_MANPAGE_RENAMES],
2679 [
2680 AC_MSG_CHECKING(for manpage renaming)
2681
2682 AC_ARG_WITH(manpage-renames,
2683         [  --with-manpage-renames  specify manpage-renaming],
2684         [MANPAGE_RENAMES=$withval],
2685         [MANPAGE_RENAMES=yes])
2686
2687 case ".$MANPAGE_RENAMES" in #(vi
2688 .no) #(vi
2689   ;;
2690 .|.yes)
2691   # Debian 'man' program?
2692   if test -f /etc/debian_version ; then
2693     MANPAGE_RENAMES=`cd $srcdir && pwd`/man/man_db.renames
2694   else
2695     MANPAGE_RENAMES=no
2696   fi
2697   ;;
2698 esac
2699
2700 if test "$MANPAGE_RENAMES" != no ; then
2701   if test -f $srcdir/man/$MANPAGE_RENAMES ; then
2702     MANPAGE_RENAMES=`cd $srcdir/man && pwd`/$MANPAGE_RENAMES
2703   elif test ! -f $MANPAGE_RENAMES ; then
2704     AC_MSG_ERROR(not a filename: $MANPAGE_RENAMES)
2705   fi
2706
2707   test ! -d man && mkdir man
2708
2709   # Construct a sed-script to perform renaming within man-pages
2710   if test -n "$MANPAGE_RENAMES" ; then
2711     test ! -d man && mkdir man
2712     sh $srcdir/man/make_sed.sh $MANPAGE_RENAMES >./edit_man.sed
2713   fi
2714 fi
2715
2716 AC_MSG_RESULT($MANPAGE_RENAMES)
2717 AC_SUBST(MANPAGE_RENAMES)
2718 ])dnl
2719 dnl ---------------------------------------------------------------------------
2720 dnl CF_MANPAGE_SYMLINKS version: 4 updated: 2003/12/13 18:01:58
2721 dnl -------------------
2722 dnl Some people expect each tool to make all aliases for manpages in the
2723 dnl man-directory.  This accommodates the older, less-capable implementations
2724 dnl of 'man', and is optional.
2725 AC_DEFUN([CF_MANPAGE_SYMLINKS],
2726 [
2727 AC_MSG_CHECKING(if manpage aliases will be installed)
2728
2729 AC_ARG_WITH(manpage-aliases,
2730         [  --with-manpage-aliases  specify manpage-aliases using .so],
2731         [MANPAGE_ALIASES=$withval],
2732         [MANPAGE_ALIASES=yes])
2733
2734 AC_MSG_RESULT($MANPAGE_ALIASES)
2735
2736 if test "$LN_S" = "ln -s"; then
2737         cf_use_symlinks=yes
2738 else
2739         cf_use_symlinks=no
2740 fi
2741
2742 MANPAGE_SYMLINKS=no
2743 if test "$MANPAGE_ALIASES" = yes ; then
2744 AC_MSG_CHECKING(if manpage symlinks should be used)
2745
2746 AC_ARG_WITH(manpage-symlinks,
2747         [  --with-manpage-symlinks specify manpage-aliases using symlinks],
2748         [MANPAGE_SYMLINKS=$withval],
2749         [MANPAGE_SYMLINKS=$cf_use_symlinks])
2750
2751 if test "$$cf_use_symlinks" = no; then
2752 if test "$MANPAGE_SYMLINKS" = yes ; then
2753         AC_MSG_WARN(cannot make symlinks, will use .so files)
2754         MANPAGE_SYMLINKS=no
2755 fi
2756 fi
2757
2758 AC_MSG_RESULT($MANPAGE_SYMLINKS)
2759 fi
2760
2761 ])dnl
2762 dnl ---------------------------------------------------------------------------
2763 dnl CF_MANPAGE_TBL version: 3 updated: 2002/01/19 22:51:32
2764 dnl --------------
2765 dnl This option causes manpages to be run through tbl(1) to generate tables
2766 dnl correctly.
2767 AC_DEFUN([CF_MANPAGE_TBL],
2768 [
2769 AC_MSG_CHECKING(for manpage tbl)
2770
2771 AC_ARG_WITH(manpage-tbl,
2772         [  --with-manpage-tbl      specify manpage processing with tbl],
2773         [MANPAGE_TBL=$withval],
2774         [MANPAGE_TBL=no])
2775
2776 AC_MSG_RESULT($MANPAGE_TBL)
2777 ])dnl
2778 dnl ---------------------------------------------------------------------------
2779 dnl CF_MAN_PAGES version: 32 updated: 2006/12/24 15:18:27
2780 dnl ------------
2781 dnl Try to determine if the man-pages on the system are compressed, and if
2782 dnl so, what format is used.  Use this information to construct a script that
2783 dnl will install man-pages.
2784 AC_DEFUN([CF_MAN_PAGES],
2785 [
2786 CF_HELP_MESSAGE(Options to Specify How Manpages are Installed:)
2787 CF_MANPAGE_FORMAT
2788 CF_MANPAGE_RENAMES
2789 CF_MANPAGE_SYMLINKS
2790 CF_MANPAGE_TBL
2791
2792   if test "$prefix" = "NONE" ; then
2793      cf_prefix="$ac_default_prefix"
2794   else
2795      cf_prefix="$prefix"
2796   fi
2797
2798   case "$MANPAGE_FORMAT" in # (vi
2799   *catonly*) # (vi
2800     cf_format=yes
2801     cf_inboth=no
2802     ;;
2803   *formatted*) # (vi
2804     cf_format=yes
2805     cf_inboth=yes
2806     ;;
2807   *)
2808     cf_format=no
2809     cf_inboth=no
2810     ;;
2811   esac
2812
2813 test ! -d man && mkdir man
2814
2815 cf_so_strip=
2816 cf_compress=
2817 case "$MANPAGE_FORMAT" in #(vi
2818 *compress*) #(vi
2819         cf_so_strip="Z"
2820         cf_compress=compress
2821   ;;
2822 *gzip*) #(vi
2823         cf_so_strip="gz"
2824         cf_compress=gzip
2825   ;;
2826 esac
2827
2828 cf_edit_man=./edit_man.sh
2829 cf_man_alias=`pwd`/man_alias.sed
2830
2831 cat >$cf_edit_man <<CF_EOF
2832 #! /bin/sh
2833 # this script is generated by the configure-script CF_MAN_PAGES macro.
2834
2835 prefix="$cf_prefix"
2836 datadir="$datadir"
2837
2838 NCURSES_MAJOR="$NCURSES_MAJOR"
2839 NCURSES_MINOR="$NCURSES_MINOR"
2840 NCURSES_PATCH="$NCURSES_PATCH"
2841
2842 NCURSES_OSPEED="$NCURSES_OSPEED"
2843 TERMINFO="$TERMINFO"
2844
2845 MKDIRS="sh `cd $srcdir && pwd`/mkinstalldirs"
2846
2847 INSTALL="$INSTALL"
2848 INSTALL_DATA="$INSTALL_DATA"
2849
2850 transform="$program_transform_name"
2851
2852 TMP=\${TMPDIR-/tmp}/man\$\$
2853 trap "rm -f \$TMP" 0 1 2 5 15
2854
2855 form=\[$]1
2856 shift || exit 1
2857
2858 verb=\[$]1
2859 shift || exit 1
2860
2861 mandir=\[$]1
2862 shift || exit 1
2863
2864 srcdir=\[$]1
2865 top_srcdir=\[$]srcdir/..
2866 shift || exit 1
2867
2868 if test "\$form" = normal ; then
2869         if test "$cf_format" = yes ; then
2870         if test "$cf_inboth" = no ; then
2871                 sh \[$]0 format \$verb \$mandir \$srcdir \[$]*
2872                 exit $?
2873         fi
2874         fi
2875         cf_subdir=\$mandir/man
2876         cf_tables=$MANPAGE_TBL
2877 else
2878         cf_subdir=\$mandir/cat
2879         cf_tables=yes
2880 fi
2881
2882 # process the list of source-files
2883 for i in \[$]* ; do
2884 case \$i in #(vi
2885 *.orig|*.rej) ;; #(vi
2886 *.[[0-9]]*)
2887         section=\`expr "\$i" : '.*\\.\\([[0-9]]\\)[[xm]]*'\`;
2888         if test \$verb = installing ; then
2889         if test ! -d \$cf_subdir\${section} ; then
2890                 \$MKDIRS \$cf_subdir\$section
2891         fi
2892         fi
2893
2894         # replace variables in man page
2895         if test ! -f $cf_man_alias ; then
2896 cat >>$cf_man_alias <<-CF_EOF2
2897                 s,@DATADIR@,\$datadir,
2898                 s,@TERMINFO@,\$TERMINFO,
2899                 s,@NCURSES_MAJOR@,\$NCURSES_MAJOR,
2900                 s,@NCURSES_MINOR@,\$NCURSES_MINOR,
2901                 s,@NCURSES_PATCH@,\$NCURSES_PATCH,
2902                 s,@NCURSES_OSPEED@,\$NCURSES_OSPEED,
2903 CF_EOF
2904         ifelse($1,,,[
2905         for cf_name in $1
2906         do
2907                 cf_NAME=`echo "$cf_name" | sed y%abcdefghijklmnopqrstuvwxyz./-%ABCDEFGHIJKLMNOPQRSTUVWXYZ___%`
2908                 cf_name=`echo $cf_name|sed "$program_transform_name"`
2909 cat >>$cf_edit_man <<-CF_EOF
2910                 s,@$cf_NAME@,$cf_name,
2911 CF_EOF
2912         done
2913         ])
2914 cat >>$cf_edit_man <<CF_EOF
2915 CF_EOF2
2916                 echo "...made $cf_man_alias"
2917         fi
2918
2919         aliases=
2920         cf_source=\`basename \$i\`
2921         inalias=\$cf_source
2922         test ! -f \$inalias && inalias="\$srcdir/\$inalias"
2923         if test ! -f \$inalias ; then
2924                 echo .. skipped \$cf_source
2925                 continue
2926         fi
2927 CF_EOF
2928
2929 if test "$MANPAGE_ALIASES" != no ; then
2930 cat >>$cf_edit_man <<CF_EOF
2931         aliases=\`sed -f \$top_srcdir/man/manlinks.sed \$inalias |sed -f $cf_man_alias | sort -u\`
2932 CF_EOF
2933 fi
2934
2935 if test "$MANPAGE_RENAMES" = no ; then
2936 cat >>$cf_edit_man <<CF_EOF
2937         # perform program transformations for section 1 man pages
2938         if test \$section = 1 ; then
2939                 cf_target=\$cf_subdir\${section}/\`echo \$cf_source|sed "\${transform}"\`
2940         else
2941                 cf_target=\$cf_subdir\${section}/\$cf_source
2942         fi
2943 CF_EOF
2944 else
2945 cat >>$cf_edit_man <<CF_EOF
2946         cf_target=\`grep "^\$cf_source" $MANPAGE_RENAMES | $AWK '{print \[$]2}'\`
2947         if test -z "\$cf_target" ; then
2948                 echo '? missing rename for '\$cf_source
2949                 cf_target="\$cf_source"
2950         fi
2951         cf_target="\$cf_subdir\${section}/\${cf_target}"
2952
2953 CF_EOF
2954 fi
2955
2956 cat >>$cf_edit_man <<CF_EOF
2957         sed     -f $cf_man_alias \\
2958 CF_EOF
2959
2960 if test -f $MANPAGE_RENAMES ; then
2961 cat >>$cf_edit_man <<CF_EOF
2962                 < \$i | sed -f `pwd`/edit_man.sed >\$TMP
2963 CF_EOF
2964 else
2965 cat >>$cf_edit_man <<CF_EOF
2966                 < \$i >\$TMP
2967 CF_EOF
2968 fi
2969
2970 cat >>$cf_edit_man <<CF_EOF
2971 if test \$cf_tables = yes ; then
2972         tbl \$TMP >\$TMP.out
2973         mv \$TMP.out \$TMP
2974 fi
2975 CF_EOF
2976
2977 if test $with_curses_h != yes ; then
2978 cat >>$cf_edit_man <<CF_EOF
2979         sed -e "/\#[    ]*include/s,curses.h,ncurses.h," < \$TMP >\$TMP.out
2980         mv \$TMP.out \$TMP
2981 CF_EOF
2982 fi
2983
2984 cat >>$cf_edit_man <<CF_EOF
2985         if test \$form = format ; then
2986                 nroff -man \$TMP >\$TMP.out
2987                 mv \$TMP.out \$TMP
2988         fi
2989 CF_EOF
2990
2991 if test -n "$cf_compress" ; then
2992 cat >>$cf_edit_man <<CF_EOF
2993         if test \$verb = installing ; then
2994         if ( $cf_compress -f \$TMP )
2995         then
2996                 mv \$TMP.$cf_so_strip \$TMP
2997         fi
2998         fi
2999         cf_target="\$cf_target.$cf_so_strip"
3000 CF_EOF
3001 fi
3002
3003 case "$MANPAGE_FORMAT" in #(vi
3004 *BSDI*)
3005 cat >>$cf_edit_man <<CF_EOF
3006         if test \$form = format ; then
3007                 # BSDI installs only .0 suffixes in the cat directories
3008                 cf_target="\`echo \$cf_target|sed -e 's/\.[[1-9]]\+[[a-z]]*/.0/'\`"
3009         fi
3010 CF_EOF
3011   ;;
3012 esac
3013
3014 cat >>$cf_edit_man <<CF_EOF
3015         suffix=\`basename \$cf_target | sed -e 's%^[[^.]]*%%'\`
3016         if test \$verb = installing ; then
3017                 echo \$verb \$cf_target
3018                 \$INSTALL_DATA \$TMP \$cf_target
3019                 test -n "\$aliases" && (
3020                         cd \$cf_subdir\${section} && (
3021                                 cf_source=\`echo \$cf_target |sed -e 's%^.*/\([[^/]][[^/]]*/[[^/]][[^/]]*$\)%\1%'\`
3022                                 test -n "$cf_so_strip" && cf_source=\`echo \$cf_source |sed -e 's%\.$cf_so_strip\$%%'\`
3023                                 cf_target=\`basename \$cf_target\`
3024                                 for cf_alias in \$aliases
3025                                 do
3026                                         if test \$section = 1 ; then
3027                                                 cf_alias=\`echo \$cf_alias|sed "\${transform}"\`
3028                                         fi
3029
3030                                         if test "$MANPAGE_SYMLINKS" = yes ; then
3031                                                 if test -f \$cf_alias\${suffix} ; then
3032                                                         if ( cmp -s \$cf_target \$cf_alias\${suffix} )
3033                                                         then
3034                                                                 continue
3035                                                         fi
3036                                                 fi
3037                                                 echo .. \$verb alias \$cf_alias\${suffix}
3038                                                 rm -f \$cf_alias\${suffix}
3039                                                 $LN_S \$cf_target \$cf_alias\${suffix}
3040                                         elif test "\$cf_target" != "\$cf_alias\${suffix}" ; then
3041                                                 echo ".so \$cf_source" >\$TMP
3042 CF_EOF
3043 if test -n "$cf_compress" ; then
3044 cat >>$cf_edit_man <<CF_EOF
3045                                                 if test -n "$cf_so_strip" ; then
3046                                                         $cf_compress -f \$TMP
3047                                                         mv \$TMP.$cf_so_strip \$TMP
3048                                                 fi
3049 CF_EOF
3050 fi
3051 cat >>$cf_edit_man <<CF_EOF
3052                                                 echo .. \$verb alias \$cf_alias\${suffix}
3053                                                 rm -f \$cf_alias\${suffix}
3054                                                 \$INSTALL_DATA \$TMP \$cf_alias\${suffix}
3055                                         fi
3056                                 done
3057                         )
3058                 )
3059         elif test \$verb = removing ; then
3060                 echo \$verb \$cf_target
3061                 rm -f \$cf_target
3062                 test -n "\$aliases" && (
3063                         cd \$cf_subdir\${section} && (
3064                                 for cf_alias in \$aliases
3065                                 do
3066                                         if test \$section = 1 ; then
3067                                                 cf_alias=\`echo \$cf_alias|sed "\${transform}"\`
3068                                         fi
3069
3070                                         echo .. \$verb alias \$cf_alias\${suffix}
3071                                         rm -f \$cf_alias\${suffix}
3072                                 done
3073                         )
3074                 )
3075         else
3076 #               echo ".hy 0"
3077                 cat \$TMP
3078         fi
3079         ;;
3080 esac
3081 done
3082
3083 if test $cf_inboth = yes ; then
3084 if test \$form != format ; then
3085         sh \[$]0 format \$verb \$mandir \$srcdir \[$]*
3086 fi
3087 fi
3088
3089 exit 0
3090 CF_EOF
3091 chmod 755 $cf_edit_man
3092
3093 ])dnl
3094 dnl ---------------------------------------------------------------------------
3095 dnl CF_MATH_LIB version: 5 updated: 2000/05/28 01:39:10
3096 dnl -----------
3097 dnl Checks for libraries.  At least one UNIX system, Apple Macintosh
3098 dnl Rhapsody 5.5, does not have -lm.  We cannot use the simpler
3099 dnl AC_CHECK_LIB(m,sin), because that fails for C++.
3100 AC_DEFUN([CF_MATH_LIB],
3101 [
3102 AC_CACHE_CHECK(if -lm needed for math functions,
3103         cf_cv_need_libm,[
3104         AC_TRY_LINK([
3105         #include <stdio.h>
3106         #include <math.h>
3107         ],
3108         [double x = rand(); printf("result = %g\n", ]ifelse($2,,sin(x),$2)[)],
3109         [cf_cv_need_libm=no],
3110         [cf_cv_need_libm=yes])])
3111 if test "$cf_cv_need_libm" = yes
3112 then
3113 ifelse($1,,[
3114         LIBS="$LIBS -lm"
3115 ],[$1=-lm])
3116 fi
3117 ])
3118 dnl ---------------------------------------------------------------------------
3119 dnl CF_MIXEDCASE_FILENAMES version: 3 updated: 2003/09/20 17:07:55
3120 dnl ----------------------
3121 dnl Check if the file-system supports mixed-case filenames.  If we're able to
3122 dnl create a lowercase name and see it as uppercase, it doesn't support that.
3123 AC_DEFUN([CF_MIXEDCASE_FILENAMES],
3124 [
3125 AC_CACHE_CHECK(if filesystem supports mixed-case filenames,cf_cv_mixedcase,[
3126 if test "$cross_compiling" = yes ; then
3127         case $target_alias in #(vi
3128         *-os2-emx*|*-msdosdjgpp*|*-cygwin*|*-mingw32*|*-uwin*) #(vi
3129                 cf_cv_mixedcase=no
3130                 ;;
3131         *)
3132                 cf_cv_mixedcase=yes
3133                 ;;
3134         esac
3135 else
3136         rm -f conftest CONFTEST
3137         echo test >conftest
3138         if test -f CONFTEST ; then
3139                 cf_cv_mixedcase=no
3140         else
3141                 cf_cv_mixedcase=yes
3142         fi
3143         rm -f conftest CONFTEST
3144 fi
3145 ])
3146 test "$cf_cv_mixedcase" = yes && AC_DEFINE(MIXEDCASE_FILENAMES)
3147 ])dnl
3148 dnl ---------------------------------------------------------------------------
3149 dnl CF_MKSTEMP version: 5 updated: 2006/12/16 12:33:30
3150 dnl ----------
3151 dnl Check for a working mkstemp.  This creates two files, checks that they are
3152 dnl successfully created and distinct (AmigaOS apparently fails on the last).
3153 AC_DEFUN([CF_MKSTEMP],[
3154 AC_CACHE_CHECK(for working mkstemp, cf_cv_func_mkstemp,[
3155 rm -f conftest*
3156 AC_TRY_RUN([
3157 #include <sys/types.h>
3158 #include <stdlib.h>
3159 #include <stdio.h>
3160 #include <string.h>
3161 #include <sys/stat.h>
3162 int main()
3163 {
3164         char *tmpl = "conftestXXXXXX";
3165         char name[2][80];
3166         int n;
3167         int result = 0;
3168         int fd;
3169         struct stat sb;
3170
3171         umask(077);
3172         for (n = 0; n < 2; ++n) {
3173                 strcpy(name[n], tmpl);
3174                 if ((fd = mkstemp(name[n])) >= 0) {
3175                         if (!strcmp(name[n], tmpl)
3176                          || stat(name[n], &sb) != 0
3177                          || (sb.st_mode & S_IFMT) != S_IFREG
3178                          || (sb.st_mode & 077) != 0) {
3179                                 result = 1;
3180                         }
3181                         close(fd);
3182                 }
3183         }
3184         if (result == 0
3185          && !strcmp(name[0], name[1]))
3186                 result = 1;
3187         ${cf_cv_main_return:-return}(result);
3188 }
3189 ],[cf_cv_func_mkstemp=yes
3190 ],[cf_cv_func_mkstemp=no
3191 ],[AC_CHECK_FUNC(mkstemp)
3192 ])
3193 ])
3194 if test "$cf_cv_func_mkstemp" = yes ; then
3195         AC_DEFINE(HAVE_MKSTEMP)
3196 fi
3197 ])dnl
3198 dnl ---------------------------------------------------------------------------
3199 dnl CF_MSG_LOG version: 3 updated: 1997/09/07 14:05:52
3200 dnl ----------
3201 dnl Write a debug message to config.log, along with the line number in the
3202 dnl configure script.
3203 AC_DEFUN([CF_MSG_LOG],[
3204 echo "(line __oline__) testing $* ..." 1>&AC_FD_CC
3205 ])dnl
3206 dnl ---------------------------------------------------------------------------
3207 dnl CF_NCURSES_ABI_6 version: 1 updated: 2005/09/17 18:42:49
3208 dnl ----------------
3209 dnl Set ncurses' ABI to 6 unless overridden by explicit configure option, and
3210 dnl warn about this.
3211 AC_DEFUN([CF_NCURSES_ABI_6],[
3212 if test "${with_abi_version+set}" != set; then
3213         case $cf_cv_rel_version in
3214         5.*)
3215                 cf_cv_rel_version=6.0
3216                 cf_cv_abi_version=6
3217                 AC_MSG_WARN(Overriding ABI version to $cf_cv_abi_version)
3218                 ;;
3219         esac
3220 fi
3221 ])dnl
3222 dnl ---------------------------------------------------------------------------
3223 dnl CF_NO_LEAKS_OPTION version: 4 updated: 2006/12/16 14:24:05
3224 dnl ------------------
3225 dnl see CF_WITH_NO_LEAKS
3226 AC_DEFUN([CF_NO_LEAKS_OPTION],[
3227 AC_MSG_CHECKING(if you want to use $1 for testing)
3228 AC_ARG_WITH($1,
3229         [$2],
3230         [AC_DEFINE($3)ifelse([$4],,[
3231          $4
3232 ])
3233         : ${with_cflags:=-g}
3234         : ${with_no_leaks:=yes}
3235          with_$1=yes],
3236         [with_$1=])
3237 AC_MSG_RESULT(${with_$1:-no})
3238
3239 case .$with_cflags in #(vi
3240 .*-g*)
3241         case .$CFLAGS in #(vi
3242         .*-g*) #(vi
3243                 ;;
3244         *)
3245                 CF_ADD_CFLAGS([-g])
3246                 ;;
3247         esac
3248         ;;
3249 esac
3250 ])dnl
3251 dnl ---------------------------------------------------------------------------
3252 dnl CF_NUMBER_SYNTAX version: 1 updated: 2003/09/20 18:12:49
3253 dnl ----------------
3254 dnl Check if the given variable is a number.  If not, report an error.
3255 dnl $1 is the variable
3256 dnl $2 is the message
3257 AC_DEFUN([CF_NUMBER_SYNTAX],[
3258 if test -n "$1" ; then
3259   case $1 in #(vi
3260   [[0-9]]*) #(vi
3261         ;;
3262   *)
3263         AC_MSG_ERROR($2 is not a number: $1)
3264         ;;
3265   esac
3266 else
3267   AC_MSG_ERROR($2 value is empty)
3268 fi
3269 ])dnl
3270 dnl ---------------------------------------------------------------------------
3271 dnl CF_OBJ_SUBDIR version: 4 updated: 2002/02/23 20:38:31
3272 dnl -------------
3273 dnl Compute the object-directory name from the given model name
3274 AC_DEFUN([CF_OBJ_SUBDIR],
3275 [
3276         case $1 in
3277         libtool) $2='obj_lo'  ;;
3278         normal)  $2='objects' ;;
3279         debug)   $2='obj_g' ;;
3280         profile) $2='obj_p' ;;
3281         shared)
3282                 case $cf_cv_system_name in #(vi
3283                 cygwin) #(vi
3284                         $2='objects' ;;
3285                 *)
3286                         $2='obj_s' ;;
3287                 esac
3288         esac
3289 ])dnl
3290 dnl ---------------------------------------------------------------------------
3291 dnl CF_PATHSEP version: 3 updated: 2001/01/12 01:23:53
3292 dnl ----------
3293 dnl Provide a value for the $PATH and similar separator
3294 AC_DEFUN([CF_PATHSEP],
3295 [
3296         case $cf_cv_system_name in
3297         os2*)   PATHSEP=';'  ;;
3298         *)      PATHSEP=':'  ;;
3299         esac
3300 ifelse($1,,,[$1=$PATHSEP])
3301         AC_SUBST(PATHSEP)
3302 ])dnl
3303 dnl ---------------------------------------------------------------------------
3304 dnl CF_PATH_SYNTAX version: 11 updated: 2006/09/02 08:55:46
3305 dnl --------------
3306 dnl Check the argument to see that it looks like a pathname.  Rewrite it if it
3307 dnl begins with one of the prefix/exec_prefix variables, and then again if the
3308 dnl result begins with 'NONE'.  This is necessary to work around autoconf's
3309 dnl delayed evaluation of those symbols.
3310 AC_DEFUN([CF_PATH_SYNTAX],[
3311 if test "x$prefix" != xNONE; then
3312   cf_path_syntax="$prefix"
3313 else
3314   cf_path_syntax="$ac_default_prefix"
3315 fi
3316
3317 case ".[$]$1" in #(vi
3318 .\[$]\(*\)*|.\'*\'*) #(vi
3319   ;;
3320 ..|./*|.\\*) #(vi
3321   ;;
3322 .[[a-zA-Z]]:[[\\/]]*) #(vi OS/2 EMX
3323   ;;
3324 .\[$]{*prefix}*) #(vi
3325   eval $1="[$]$1"
3326   case ".[$]$1" in #(vi
3327   .NONE/*)
3328     $1=`echo [$]$1 | sed -e s%NONE%$cf_path_syntax%`
3329     ;;
3330   esac
3331   ;; #(vi
3332 .no|.NONE/*)
3333   $1=`echo [$]$1 | sed -e s%NONE%$cf_path_syntax%`
3334   ;;
3335 *)
3336   ifelse($2,,[AC_ERROR([expected a pathname, not \"[$]$1\"])],$2)
3337   ;;
3338 esac
3339 ])dnl
3340 dnl ---------------------------------------------------------------------------
3341 dnl CF_POSIX_C_SOURCE version: 6 updated: 2005/07/14 20:25:10
3342 dnl -----------------
3343 dnl Define _POSIX_C_SOURCE to the given level, and _POSIX_SOURCE if needed.
3344 dnl
3345 dnl     POSIX.1-1990                            _POSIX_SOURCE
3346 dnl     POSIX.1-1990 and                        _POSIX_SOURCE and
3347 dnl             POSIX.2-1992 C-Language                 _POSIX_C_SOURCE=2
3348 dnl             Bindings Option
3349 dnl     POSIX.1b-1993                           _POSIX_C_SOURCE=199309L
3350 dnl     POSIX.1c-1996                           _POSIX_C_SOURCE=199506L
3351 dnl     X/Open 2000                             _POSIX_C_SOURCE=200112L
3352 dnl
3353 dnl Parameters:
3354 dnl     $1 is the nominal value for _POSIX_C_SOURCE
3355 AC_DEFUN([CF_POSIX_C_SOURCE],
3356 [
3357 cf_POSIX_C_SOURCE=ifelse($1,,199506L,$1)
3358
3359 cf_save_CFLAGS="$CFLAGS"
3360 cf_save_CPPFLAGS="$CPPFLAGS"
3361
3362 CF_REMOVE_DEFINE(cf_trim_CFLAGS,$cf_save_CFLAGS,_POSIX_C_SOURCE)
3363 CF_REMOVE_DEFINE(cf_trim_CPPFLAGS,$cf_save_CPPFLAGS,_POSIX_C_SOURCE)
3364
3365 AC_CACHE_CHECK(if we should define _POSIX_C_SOURCE,cf_cv_posix_c_source,[
3366         CF_MSG_LOG(if the symbol is already defined go no further)
3367         AC_TRY_COMPILE([#include <sys/types.h>],[
3368 #ifndef _POSIX_C_SOURCE
3369 make an error
3370 #endif],
3371         [cf_cv_posix_c_source=no],
3372         [cf_want_posix_source=no
3373          case .$cf_POSIX_C_SOURCE in #(vi
3374          .[[12]]??*) #(vi
3375                 cf_cv_posix_c_source="-D_POSIX_C_SOURCE=$cf_POSIX_C_SOURCE"
3376                 ;;
3377          .2) #(vi
3378                 cf_cv_posix_c_source="-D_POSIX_C_SOURCE=$cf_POSIX_C_SOURCE"
3379                 cf_want_posix_source=yes
3380                 ;;
3381          .*)
3382                 cf_want_posix_source=yes
3383                 ;;
3384          esac
3385          if test "$cf_want_posix_source" = yes ; then
3386                 AC_TRY_COMPILE([#include <sys/types.h>],[
3387 #ifdef _POSIX_SOURCE
3388 make an error
3389 #endif],[],
3390                 cf_cv_posix_c_source="$cf_cv_posix_c_source -D_POSIX_SOURCE")
3391          fi
3392          CF_MSG_LOG(ifdef from value $cf_POSIX_C_SOURCE)
3393          CFLAGS="$cf_trim_CFLAGS"
3394          CPPFLAGS="$cf_trim_CPPFLAGS $cf_cv_posix_c_source"
3395          CF_MSG_LOG(if the second compile does not leave our definition intact error)
3396          AC_TRY_COMPILE([#include <sys/types.h>],[
3397 #ifndef _POSIX_C_SOURCE
3398 make an error
3399 #endif],,
3400          [cf_cv_posix_c_source=no])
3401          CFLAGS="$cf_save_CFLAGS"
3402          CPPFLAGS="$cf_save_CPPFLAGS"
3403         ])
3404 ])
3405
3406 if test "$cf_cv_posix_c_source" != no ; then
3407         CFLAGS="$cf_trim_CFLAGS"
3408         CPPFLAGS="$cf_trim_CPPFLAGS"
3409         if test "$cf_cv_cc_u_d_options" = yes ; then
3410                 cf_temp_posix_c_source=`echo "$cf_cv_posix_c_source" | \
3411                                 sed -e 's/-D/-U/g' -e 's/=[[^   ]]*//g'`
3412                 CPPFLAGS="$CPPFLAGS $cf_temp_posix_c_source"
3413         fi
3414         CPPFLAGS="$CPPFLAGS $cf_cv_posix_c_source"
3415 fi
3416
3417 ])dnl
3418 dnl ---------------------------------------------------------------------------
3419 dnl CF_PREDEFINE version: 1 updated: 2003/07/26 17:53:56
3420 dnl ------------
3421 dnl Add definitions to CPPFLAGS to ensure they're predefined for all compiles.
3422 dnl
3423 dnl $1 = symbol to test
3424 dnl $2 = value (if any) to use for a predefinition
3425 AC_DEFUN([CF_PREDEFINE],
3426 [
3427 AC_MSG_CHECKING(if we must define $1)
3428 AC_TRY_COMPILE([#include <sys/types.h>
3429 ],[
3430 #ifndef $1
3431 make an error
3432 #endif],[cf_result=no],[cf_result=yes])
3433 AC_MSG_RESULT($cf_result)
3434
3435 if test "$cf_result" = yes ; then
3436         CPPFLAGS="$CPPFLAGS ifelse($2,,-D$1,[-D$1=$2])"
3437 elif test "x$2" != "x" ; then
3438         AC_MSG_CHECKING(checking for compatible value versus $2)
3439         AC_TRY_COMPILE([#include <sys/types.h>
3440 ],[
3441 #if $1-$2 < 0
3442 make an error
3443 #endif],[cf_result=yes],[cf_result=no])
3444         AC_MSG_RESULT($cf_result)
3445         if test "$cf_result" = no ; then
3446                 # perhaps we can override it - try...
3447                 CPPFLAGS="$CPPFLAGS -D$1=$2"
3448         fi
3449 fi
3450 ])dnl
3451 dnl ---------------------------------------------------------------------------
3452 dnl CF_PRG_RULES version: 1 updated: 2006/06/03 11:45:08
3453 dnl ------------
3454 dnl Append definitions and rules for the given programs to the subdirectory
3455 dnl Makefiles, and the recursion rule for the top-level Makefile.
3456 dnl
3457 dnl parameters
3458 dnl     $1 = script to run
3459 dnl     $2 = list of subdirectories
3460 dnl
3461 dnl variables
3462 dnl     $AWK
3463 AC_DEFUN([CF_PRG_RULES],
3464 [
3465 for cf_dir in $2
3466 do
3467         if test ! -d $srcdir/$cf_dir; then
3468                 continue
3469         elif test -f $srcdir/$cf_dir/programs; then
3470                 $AWK -f $1 $srcdir/$cf_dir/programs >>$cf_dir/Makefile
3471         fi
3472 done
3473
3474 ])dnl
3475 dnl ---------------------------------------------------------------------------
3476 dnl CF_PROG_AWK version: 1 updated: 2006/09/16 11:40:59
3477 dnl -----------
3478 dnl Check for awk, ensure that the check found something.
3479 AC_DEFUN([CF_PROG_AWK],
3480 [
3481 AC_PROG_AWK
3482 test -z "$AWK" && AC_MSG_ERROR(No awk program found)
3483 ])dnl
3484 dnl ---------------------------------------------------------------------------
3485 dnl CF_PROG_CC_C_O version: 2 updated: 2006/12/16 15:55:46
3486 dnl --------------
3487 dnl Analogous to AC_PROG_CC_C_O, but more useful: tests only $CC, ensures that
3488 dnl the output file can be renamed, and allows for a shell variable that can
3489 dnl be used later.  The parameter is either CC or CXX.  The result is the
3490 dnl cache variable:
3491 dnl     $cf_cv_prog_CC_c_o
3492 dnl     $cf_cv_prog_CXX_c_o
3493 AC_DEFUN([CF_PROG_CC_C_O],
3494 [AC_REQUIRE([AC_PROG_CC])dnl
3495 AC_MSG_CHECKING([whether [$]$1 understands -c and -o together])
3496 AC_CACHE_VAL(cf_cv_prog_$1_c_o,
3497 [
3498 cat > conftest.$ac_ext <<CF_EOF
3499 #include <stdio.h>
3500 int main()
3501 {
3502         ${cf_cv_main_return:-return}(0);
3503 }
3504 CF_EOF
3505 # We do the test twice because some compilers refuse to overwrite an
3506 # existing .o file with -o, though they will create one.
3507 ac_try='[$]$1 -c conftest.$ac_ext -o conftest2.$ac_objext >&AC_FD_CC'
3508 if AC_TRY_EVAL(ac_try) &&
3509   test -f conftest2.$ac_objext && AC_TRY_EVAL(ac_try);
3510 then
3511   eval cf_cv_prog_$1_c_o=yes
3512 else
3513   eval cf_cv_prog_$1_c_o=no
3514 fi
3515 rm -f conftest*
3516 ])dnl
3517 if test $cf_cv_prog_$1_c_o = yes; then
3518   AC_MSG_RESULT([yes])
3519 else
3520   AC_MSG_RESULT([no])
3521 fi
3522 ])dnl
3523 dnl ---------------------------------------------------------------------------
3524 dnl CF_PROG_CC_U_D version: 1 updated: 2005/07/14 16:59:30
3525 dnl --------------
3526 dnl Check if C (preprocessor) -U and -D options are processed in the order
3527 dnl given rather than by type of option.  Some compilers insist on apply all
3528 dnl of the -U options after all of the -D options.  Others allow mixing them,
3529 dnl and may predefine symbols that conflict with those we define.
3530 AC_DEFUN([CF_PROG_CC_U_D],
3531 [
3532 AC_CACHE_CHECK(if $CC -U and -D options work together,cf_cv_cc_u_d_options,[
3533         cf_save_CPPFLAGS="$CPPFLAGS"
3534         CPPFLAGS="-UU_D_OPTIONS -DU_D_OPTIONS -DD_U_OPTIONS -UD_U_OPTIONS"
3535         AC_TRY_COMPILE([],[
3536 #ifndef U_D_OPTIONS
3537 make an undefined-error
3538 #endif
3539 #ifdef  D_U_OPTIONS
3540 make a defined-error
3541 #endif
3542         ],[
3543         cf_cv_cc_u_d_options=yes],[
3544         cf_cv_cc_u_d_options=no])
3545         CPPFLAGS="$cf_save_CPPFLAGS"
3546 ])
3547 ])dnl
3548 dnl ---------------------------------------------------------------------------
3549 dnl CF_PROG_EGREP version: 1 updated: 2006/09/16 11:40:59
3550 dnl -------------
3551 dnl AC_PROG_EGREP was introduced in autoconf 2.53.
3552 dnl This macro adds a check to ensure the script found something.
3553 AC_DEFUN([CF_PROG_EGREP],
3554 [AC_CACHE_CHECK([for egrep], [ac_cv_prog_egrep],
3555    [if echo a | (grep -E '(a|b)') >/dev/null 2>&1
3556     then ac_cv_prog_egrep='grep -E'
3557     else ac_cv_prog_egrep='egrep'
3558     fi])
3559  EGREP=$ac_cv_prog_egrep
3560  AC_SUBST([EGREP])
3561 test -z "$EGREP" && AC_MSG_ERROR(No egrep program found)
3562 ])dnl
3563 dnl ---------------------------------------------------------------------------
3564 dnl CF_PROG_EXT version: 10 updated: 2004/01/03 19:28:18
3565 dnl -----------
3566 dnl Compute $PROG_EXT, used for non-Unix ports, such as OS/2 EMX.
3567 AC_DEFUN([CF_PROG_EXT],
3568 [
3569 AC_REQUIRE([CF_CHECK_CACHE])
3570 case $cf_cv_system_name in
3571 os2*)
3572     CFLAGS="$CFLAGS -Zmt"
3573     CPPFLAGS="$CPPFLAGS -D__ST_MT_ERRNO__"
3574     CXXFLAGS="$CXXFLAGS -Zmt"
3575     # autoconf's macro sets -Zexe and suffix both, which conflict:w
3576     LDFLAGS="$LDFLAGS -Zmt -Zcrtdll"
3577     ac_cv_exeext=.exe
3578     ;;
3579 esac
3580
3581 AC_EXEEXT
3582 AC_OBJEXT
3583
3584 PROG_EXT="$EXEEXT"
3585 AC_SUBST(PROG_EXT)
3586 test -n "$PROG_EXT" && AC_DEFINE_UNQUOTED(PROG_EXT,"$PROG_EXT")
3587 ])dnl
3588 dnl ---------------------------------------------------------------------------
3589 dnl CF_PROG_INSTALL version: 5 updated: 2002/12/21 22:46:07
3590 dnl ---------------
3591 dnl Force $INSTALL to be an absolute-path.  Otherwise, edit_man.sh and the
3592 dnl misc/tabset install won't work properly.  Usually this happens only when
3593 dnl using the fallback mkinstalldirs script
3594 AC_DEFUN([CF_PROG_INSTALL],
3595 [AC_PROG_INSTALL
3596 case $INSTALL in
3597 /*)
3598   ;;
3599 *)
3600   CF_DIRNAME(cf_dir,$INSTALL)
3601   test -z "$cf_dir" && cf_dir=.
3602   INSTALL=`cd $cf_dir && pwd`/`echo $INSTALL | sed -e 's%^.*/%%'`
3603   ;;
3604 esac
3605 ])dnl
3606 dnl ---------------------------------------------------------------------------
3607 dnl CF_PROG_LDCONFIG version: 1 updated: 2003/09/20 17:07:55
3608 dnl ----------------
3609 dnl Check for ldconfig, needed to fixup shared libraries that would be built
3610 dnl and then used in the install.
3611 AC_DEFUN([CF_PROG_LDCONFIG],[
3612 if test "$cross_compiling" = yes ; then
3613   LDCONFIG=:
3614 else
3615 case "$cf_cv_system_name" in #(vi
3616 freebsd*) #(vi
3617   test -z "$LDCONFIG" && LDCONFIG="/sbin/ldconfig -R"
3618   ;;
3619 *) LDPATH=$PATH:/sbin:/usr/sbin
3620   AC_PATH_PROG(LDCONFIG,ldconfig,,$LDPATH)
3621   ;;
3622 esac
3623 fi
3624 AC_SUBST(LDCONFIG)
3625 ])dnl
3626 dnl ---------------------------------------------------------------------------
3627 dnl CF_PROG_LINT version: 1 updated: 2006/09/16 11:40:59
3628 dnl ------------
3629 AC_DEFUN([CF_PROG_LINT],
3630 [
3631 AC_CHECK_PROGS(LINT, tdlint lint alint)
3632 AC_SUBST(LINT_OPTS)
3633 ])dnl
3634 dnl ---------------------------------------------------------------------------
3635 dnl CF_REGEX version: 3 updated: 1997/11/01 14:26:01
3636 dnl --------
3637 dnl Attempt to determine if we've got one of the flavors of regular-expression
3638 dnl code that we can support.
3639 AC_DEFUN([CF_REGEX],
3640 [
3641 AC_MSG_CHECKING([for regular-expression headers])
3642 AC_CACHE_VAL(cf_cv_regex,[
3643 AC_TRY_LINK([#include <sys/types.h>
3644 #include <regex.h>],[
3645         regex_t *p;
3646         int x = regcomp(p, "", 0);
3647         int y = regexec(p, "", 0, 0, 0);
3648         regfree(p);
3649         ],[cf_cv_regex="regex.h"],[
3650         AC_TRY_LINK([#include <regexp.h>],[
3651                 char *p = compile("", "", "", 0);
3652                 int x = step("", "");
3653         ],[cf_cv_regex="regexp.h"],[
3654                 cf_save_LIBS="$LIBS"
3655                 LIBS="-lgen $LIBS"
3656                 AC_TRY_LINK([#include <regexpr.h>],[
3657                         char *p = compile("", "", "");
3658                         int x = step("", "");
3659                 ],[cf_cv_regex="regexpr.h"],[LIBS="$cf_save_LIBS"])])])
3660 ])
3661 AC_MSG_RESULT($cf_cv_regex)
3662 case $cf_cv_regex in
3663         regex.h)   AC_DEFINE(HAVE_REGEX_H_FUNCS) ;;
3664         regexp.h)  AC_DEFINE(HAVE_REGEXP_H_FUNCS) ;;
3665         regexpr.h) AC_DEFINE(HAVE_REGEXPR_H_FUNCS) ;;
3666 esac
3667 ])dnl
3668 dnl ---------------------------------------------------------------------------
3669 dnl CF_REMOVE_DEFINE version: 2 updated: 2005/07/09 16:12:18
3670 dnl ----------------
3671 dnl Remove all -U and -D options that refer to the given symbol from a list
3672 dnl of C compiler options.  This works around the problem that not all
3673 dnl compilers process -U and -D options from left-to-right, so a -U option
3674 dnl cannot be used to cancel the effect of a preceding -D option.
3675 dnl
3676 dnl $1 = target (which could be the same as the source variable)
3677 dnl $2 = source (including '$')
3678 dnl $3 = symbol to remove
3679 define([CF_REMOVE_DEFINE],
3680 [
3681 # remove $3 symbol from $2
3682 $1=`echo "$2" | \
3683         sed     -e 's/-[[UD]]$3\(=[[^   ]]*\)\?[[       ]]/ /g' \
3684                 -e 's/-[[UD]]$3\(=[[^   ]]*\)\?[$]//g'`
3685 ])dnl
3686 dnl ---------------------------------------------------------------------------
3687 dnl CF_SHARED_OPTS version: 42 updated: 2006/12/23 18:04:51
3688 dnl --------------
3689 dnl --------------
3690 dnl Attempt to determine the appropriate CC/LD options for creating a shared
3691 dnl library.
3692 dnl
3693 dnl Note: ${LOCAL_LDFLAGS} is used to link executables that will run within the
3694 dnl build-tree, i.e., by making use of the libraries that are compiled in ../lib
3695 dnl We avoid compiling-in a ../lib path for the shared library since that can
3696 dnl lead to unexpected results at runtime.
3697 dnl ${LOCAL_LDFLAGS2} has the same intention but assumes that the shared libraries
3698 dnl are compiled in ../../lib
3699 dnl
3700 dnl The variable 'cf_cv_do_symlinks' is used to control whether we configure
3701 dnl to install symbolic links to the rel/abi versions of shared libraries.
3702 dnl
3703 dnl The variable 'cf_cv_shlib_version' controls whether we use the rel or abi
3704 dnl version when making symbolic links.
3705 dnl
3706 dnl The variable 'cf_cv_shlib_version_infix' controls whether shared library
3707 dnl version numbers are infix (ex: libncurses.<ver>.dylib) or postfix
3708 dnl (ex: libncurses.so.<ver>).
3709 dnl
3710 dnl Some loaders leave 'so_locations' lying around.  It's nice to clean up.
3711 AC_DEFUN([CF_SHARED_OPTS],
3712 [
3713         AC_REQUIRE([CF_SUBST_NCURSES_VERSION])
3714         LOCAL_LDFLAGS=
3715         LOCAL_LDFLAGS2=
3716         LD_SHARED_OPTS=
3717         INSTALL_LIB="-m 644"
3718
3719         cf_cv_do_symlinks=no
3720
3721         AC_MSG_CHECKING(if release/abi version should be used for shared libs)
3722         AC_ARG_WITH(shlib-version,
3723         [  --with-shlib-version=X  Specify rel or abi version for shared libs],
3724         [test -z "$withval" && withval=auto
3725         case $withval in #(vi
3726         yes) #(vi
3727                 cf_cv_shlib_version=auto
3728                 ;;
3729         rel|abi|auto|no) #(vi
3730                 cf_cv_shlib_version=$withval
3731                 ;;
3732         *)
3733                 AC_ERROR([option value must be one of: rel, abi, auto or no])
3734                 ;;
3735         esac
3736         ],[cf_cv_shlib_version=auto])
3737         AC_MSG_RESULT($cf_cv_shlib_version)
3738
3739         cf_cv_rm_so_locs=no
3740
3741         # Some less-capable ports of gcc support only -fpic
3742         CC_SHARED_OPTS=
3743         if test "$GCC" = yes
3744         then
3745                 AC_MSG_CHECKING(which $CC option to use)
3746                 cf_save_CFLAGS="$CFLAGS"
3747                 for CC_SHARED_OPTS in -fPIC -fpic ''
3748                 do
3749                         CFLAGS="$cf_save_CFLAGS $CC_SHARED_OPTS"
3750                         AC_TRY_COMPILE([#include <stdio.h>],[int x = 1],[break],[])
3751                 done
3752                 AC_MSG_RESULT($CC_SHARED_OPTS)
3753                 CFLAGS="$cf_save_CFLAGS"
3754         fi
3755
3756         cf_cv_shlib_version_infix=no
3757
3758         case $cf_cv_system_name in
3759         beos*)
3760                 MK_SHARED_LIB='${CC} ${CFLAGS} -o $[@] -Xlinker -soname=`basename $[@]` -nostart -e 0'
3761                 ;;
3762         cygwin*)
3763                 CC_SHARED_OPTS=
3764                 MK_SHARED_LIB='${CC} ${CFLAGS} -shared -Wl,--out-implib=../lib/${IMPORT_LIB} -Wl,--export-all-symbols -o ../lib/${SHARED_LIB}'
3765                 cf_cv_shlib_version=cygdll
3766                 cf_cv_shlib_version_infix=cygdll
3767                 ;;
3768         darwin*)
3769                 EXTRA_CFLAGS="-no-cpp-precomp"
3770                 CC_SHARED_OPTS="-dynamic"
3771                 MK_SHARED_LIB='${CC} ${CFLAGS} -dynamiclib -install_name ${DESTDIR}${libdir}/`basename $[@]` -compatibility_version ${ABI_VERSION} -current_version ${ABI_VERSION} -o $[@]'
3772                 test "$cf_cv_shlib_version" = auto && cf_cv_shlib_version=abi
3773                 cf_cv_shlib_version_infix=yes
3774                 AC_CACHE_CHECK([if ld -search_paths_first works], cf_cv_ldflags_search_paths_first, [
3775                         cf_save_LDFLAGS=$LDFLAGS
3776                         LDFLAGS="$LDFLAGS -Wl,-search_paths_first"
3777                         AC_TRY_LINK(, [int i;], cf_cv_ldflags_search_paths_first=yes, cf_cv_ldflags_search_paths_first=no)
3778                                 LDFLAGS=$cf_save_LDFLAGS])
3779                 if test $cf_cv_ldflags_search_paths_first = yes; then
3780                         LDFLAGS="$LDFLAGS -Wl,-search_paths_first"
3781                 fi
3782                 ;;
3783         hpux*)
3784                 # (tested with gcc 2.7.2 -- I don't have c89)
3785                 if test "$GCC" = yes; then
3786                         LD_SHARED_OPTS='-Xlinker +b -Xlinker ${libdir}'
3787                 else
3788                         CC_SHARED_OPTS='+Z'
3789                         LD_SHARED_OPTS='-Wl,+b,${libdir}'
3790                 fi
3791                 MK_SHARED_LIB='${LD} +b ${libdir} -b -o $[@]'
3792                 # HP-UX shared libraries must be executable, and should be
3793                 # readonly to exploit a quirk in the memory manager.
3794                 INSTALL_LIB="-m 555"
3795                 ;;
3796         irix*)
3797                 if test "$cf_cv_ld_rpath" = yes ; then
3798                         if test "$GCC" = yes; then
3799                                 cf_ld_rpath_opt="-Wl,-rpath,"
3800                                 EXTRA_LDFLAGS="-Wl,-rpath,\${libdir} $EXTRA_LDFLAGS"
3801                         else
3802                                 cf_ld_rpath_opt="-rpath "
3803                                 EXTRA_LDFLAGS="-rpath \${libdir} $EXTRA_LDFLAGS"
3804                         fi
3805                 fi
3806                 # tested with IRIX 5.2 and 'cc'.
3807                 if test "$GCC" != yes; then
3808                         CC_SHARED_OPTS='-KPIC'
3809                 fi
3810                 MK_SHARED_LIB='${CC} -shared -rdata_shared -soname `basename $[@]` -o $[@]'
3811                 cf_cv_rm_so_locs=yes
3812                 ;;
3813         linux*|gnu*|k*bsd*-gnu)
3814                 if test "$DFT_LWR_MODEL" = "shared" ; then
3815                         LOCAL_LDFLAGS="-Wl,-rpath,\$(LOCAL_LIBDIR)"
3816                         LOCAL_LDFLAGS2="$LOCAL_LDFLAGS"
3817                 fi
3818                 if test "$cf_cv_ld_rpath" = yes ; then
3819                         cf_ld_rpath_opt="-Wl,-rpath,"
3820                         EXTRA_LDFLAGS="-Wl,-rpath,\${libdir} $EXTRA_LDFLAGS"
3821                 fi
3822                 CF_SHARED_SONAME
3823                 MK_SHARED_LIB='${CC} ${CFLAGS} -shared -Wl,-soname,'$cf_shared_soname',-stats,-lc -o $[@]'
3824                 ;;
3825         openbsd[[2-9]].*)
3826                 CC_SHARED_OPTS="$CC_SHARED_OPTS -DPIC"
3827                 MK_SHARED_LIB='${LD} -Bshareable -soname,`basename $[@].${ABI_VERSION}` -o $[@]'
3828                 ;;
3829         openbsd*|freebsd[[12]].*)
3830                 CC_SHARED_OPTS="$CC_SHARED_OPTS -DPIC"
3831                 MK_SHARED_LIB='${LD} -Bshareable -o $[@]'
3832                 test "$cf_cv_shlib_version" = auto && cf_cv_shlib_version=rel
3833                 ;;
3834         freebsd*)
3835                 CC_SHARED_OPTS="$CC_SHARED_OPTS -DPIC"
3836                 if test "$DFT_LWR_MODEL" = "shared" && test "$cf_cv_ld_rpath" = yes ; then
3837                         LOCAL_LDFLAGS="-rpath \$(LOCAL_LIBDIR)"
3838                         LOCAL_LDFLAGS2="-rpath \${libdir} $LOCAL_LDFLAGS"
3839                         cf_ld_rpath_opt="-rpath "
3840                         EXTRA_LDFLAGS="-rpath \${libdir} $EXTRA_LDFLAGS"
3841                 fi
3842                 CF_SHARED_SONAME
3843                 MK_SHARED_LIB='${LD} -Bshareable -soname=`basename $[@]` -o $[@]'
3844                 ;;
3845         netbsd*)
3846                 CC_SHARED_OPTS="$CC_SHARED_OPTS -DPIC"
3847                 test "$cf_cv_ld_rpath" = yes && cf_ld_rpath_opt="-Wl,-rpath,"
3848                 if test "$DFT_LWR_MODEL" = "shared" && test "$cf_cv_ld_rpath" = yes ; then
3849                         LOCAL_LDFLAGS="-Wl,-rpath,\$(LOCAL_LIBDIR)"
3850                         LOCAL_LDFLAGS2="$LOCAL_LDFLAGS"
3851                         EXTRA_LDFLAGS="-Wl,-rpath,\${libdir} $EXTRA_LDFLAGS"
3852                         if test "$cf_cv_shlib_version" = auto; then
3853                         if test -f /usr/libexec/ld.elf_so; then
3854                                 cf_cv_shlib_version=abi
3855                         else
3856                                 cf_cv_shlib_version=rel
3857                         fi
3858                         fi
3859                         CF_SHARED_SONAME
3860                         MK_SHARED_LIB='${CC} ${CFLAGS} -shared -Wl,-soname,'$cf_shared_soname' -o $[@]'
3861                 else
3862                         MK_SHARED_LIB='${LD} -Bshareable -o $[@]'
3863                 fi
3864                 ;;
3865         osf*|mls+*)
3866                 # tested with OSF/1 V3.2 and 'cc'
3867                 # tested with OSF/1 V3.2 and gcc 2.6.3 (but the c++ demo didn't
3868                 # link with shared libs).
3869                 MK_SHARED_LIB='${LD} -set_version ${REL_VERSION}:${ABI_VERSION} -expect_unresolved "*" -shared -soname `basename $[@]`'
3870                 case $host_os in
3871                 osf4*)
3872                         MK_SHARED_LIB="${MK_SHARED_LIB} -msym"
3873                         ;;
3874                 esac
3875                 MK_SHARED_LIB="${MK_SHARED_LIB}"' -o $[@]'
3876                 if test "$DFT_LWR_MODEL" = "shared" ; then
3877                         LOCAL_LDFLAGS="-Wl,-rpath,\$(LOCAL_LIBDIR)"
3878                         LOCAL_LDFLAGS2="$LOCAL_LDFLAGS"
3879                 fi
3880                 if test "$cf_cv_ld_rpath" = yes ; then
3881                         cf_ld_rpath_opt="-rpath"
3882                         # EXTRA_LDFLAGS="$LOCAL_LDFLAGS $EXTRA_LDFLAGS"
3883                 fi
3884                 cf_cv_rm_so_locs=yes
3885                 ;;
3886         sco3.2v5*)  # (also uw2* and UW7) hops 13-Apr-98
3887                 # tested with osr5.0.5
3888                 if test "$GCC" != yes; then
3889                         CC_SHARED_OPTS='-belf -KPIC'
3890                 fi
3891                 MK_SHARED_LIB='${LD} -dy -G -h `basename $[@] .${REL_VERSION}`.${ABI_VERSION} -o [$]@'
3892                 if test "$cf_cv_ld_rpath" = yes ; then
3893                         # only way is to set LD_RUN_PATH but no switch for it
3894                         RUN_PATH=$libdir
3895                 fi
3896                 test "$cf_cv_shlib_version" = auto && cf_cv_shlib_version=rel
3897                 LINK_PROGS='LD_RUN_PATH=${libdir}'
3898                 LINK_TESTS='Pwd=`pwd`;LD_RUN_PATH=`dirname $${Pwd}`/lib'
3899                 ;;
3900         sunos4*)
3901                 # tested with SunOS 4.1.1 and gcc 2.7.0
3902                 if test "$GCC" != yes; then
3903                         CC_SHARED_OPTS='-KPIC'
3904                 fi
3905                 MK_SHARED_LIB='${LD} -assert pure-text -o $[@]'
3906                 test "$cf_cv_shlib_version" = auto && cf_cv_shlib_version=rel
3907                 ;;
3908         solaris2*)
3909                 # tested with SunOS 5.5.1 (solaris 2.5.1) and gcc 2.7.2
3910                 if test "$GCC" != yes; then
3911                         CC_SHARED_OPTS='-KPIC'
3912                 fi
3913                 if test "$DFT_LWR_MODEL" = "shared" ; then
3914                         LOCAL_LDFLAGS="-R \$(LOCAL_LIBDIR):\${libdir}"
3915                         LOCAL_LDFLAGS2="$LOCAL_LDFLAGS"
3916                 fi
3917                 if test "$cf_cv_ld_rpath" = yes ; then
3918                         cf_ld_rpath_opt="-R"
3919                         EXTRA_LDFLAGS="$LOCAL_LDFLAGS $EXTRA_LDFLAGS"
3920                 fi
3921                 CF_SHARED_SONAME
3922                 MK_SHARED_LIB='${CC} -dy -G -h '$cf_shared_soname' -o $[@]'
3923                 ;;
3924         sysv5uw7*|unix_sv*)
3925                 # tested with UnixWare 7.1.0 (gcc 2.95.2 and cc)
3926                 if test "$GCC" != yes; then
3927                         CC_SHARED_OPTS='-KPIC'
3928                 fi
3929                 MK_SHARED_LIB='${LD} -d y -G -o [$]@'
3930                 ;;
3931         *)
3932                 CC_SHARED_OPTS='unknown'
3933                 MK_SHARED_LIB='echo unknown'
3934                 ;;
3935         esac
3936
3937         # This works if the last tokens in $MK_SHARED_LIB are the -o target.
3938         case "$cf_cv_shlib_version" in #(vi
3939         rel|abi)
3940                 case "$MK_SHARED_LIB" in #(vi
3941                 *'-o $[@]')
3942                         test "$cf_cv_do_symlinks" = no && cf_cv_do_symlinks=yes
3943                         ;;
3944                 *)
3945                         AC_MSG_WARN(ignored --with-shlib-version)
3946                         ;;
3947                 esac
3948                 ;;
3949         esac
3950
3951         if test -n "$cf_ld_rpath_opt" ; then
3952                 AC_MSG_CHECKING(if we need a space after rpath option)
3953                 cf_save_LIBS="$LIBS"
3954                 LIBS="$LIBS ${cf_ld_rpath_opt}$libdir"
3955                 AC_TRY_LINK(, , cf_rpath_space=no, cf_rpath_space=yes)
3956                 LIBS="$cf_save_LIBS"
3957                 AC_MSG_RESULT($cf_rpath_space)
3958                 test "$cf_rpath_space" = yes && cf_ld_rpath_opt="$cf_ld_rpath_opt "
3959                 MK_SHARED_LIB="$MK_SHARED_LIB $cf_ld_rpath_opt\${libdir}"
3960         fi
3961
3962         AC_SUBST(CC_SHARED_OPTS)
3963         AC_SUBST(LD_SHARED_OPTS)
3964         AC_SUBST(MK_SHARED_LIB)
3965         AC_SUBST(LINK_PROGS)
3966         AC_SUBST(LINK_TESTS)
3967         AC_SUBST(EXTRA_LDFLAGS)
3968         AC_SUBST(LOCAL_LDFLAGS)
3969         AC_SUBST(LOCAL_LDFLAGS2)
3970         AC_SUBST(INSTALL_LIB)
3971 ])dnl
3972 dnl ---------------------------------------------------------------------------
3973 dnl CF_SHARED_SONAME version: 2 updated: 2006/10/21 12:33:41
3974 dnl ----------------
3975 dnl utility macro for CF_SHARED_OPTS, constructs "$cf_shared_soname" for
3976 dnl substitution into MK_SHARED_LIB string for the "-soname" (or similar)
3977 dnl option.
3978 dnl
3979 dnl $1 is the default that should be used for "$cf_cv_shlib_version".
3980 dnl If missing, use "rel".
3981 define([CF_SHARED_SONAME],
3982 [
3983         test "$cf_cv_shlib_version" = auto && cf_cv_shlib_version=ifelse($1,,rel,$1)
3984         if test "$cf_cv_shlib_version" = rel; then
3985                 cf_shared_soname='`basename $[@] .${REL_VERSION}`.${ABI_VERSION}'
3986         else
3987                 cf_shared_soname='`basename $[@]`'
3988         fi
3989 ])
3990 dnl ---------------------------------------------------------------------------
3991 dnl CF_SIGWINCH version: 1 updated: 2006/04/02 16:41:09
3992 dnl -----------
3993 dnl Use this macro after CF_XOPEN_SOURCE, but do not require it (not all
3994 dnl programs need this test).
3995 dnl
3996 dnl This is really a MacOS X 10.4.3 workaround.  Defining _POSIX_C_SOURCE
3997 dnl forces SIGWINCH to be undefined (breaks xterm, ncurses).  Oddly, the struct
3998 dnl winsize declaration is left alone - we may revisit this if Apple choose to
3999 dnl break that part of the interface as well.
4000 AC_DEFUN([CF_SIGWINCH],
4001 [
4002 AC_CACHE_CHECK(if SIGWINCH is defined,cf_cv_define_sigwinch,[
4003         AC_TRY_COMPILE([
4004 #include <sys/types.h>
4005 #include <sys/signal.h>
4006 ],[int x = SIGWINCH],
4007         [cf_cv_define_sigwinch=yes],
4008         [AC_TRY_COMPILE([
4009 #undef _XOPEN_SOURCE
4010 #undef _POSIX_SOURCE
4011 #undef _POSIX_C_SOURCE
4012 #include <sys/types.h>
4013 #include <sys/signal.h>
4014 ],[int x = SIGWINCH],
4015         [cf_cv_define_sigwinch=maybe],
4016         [cf_cv_define_sigwinch=no])
4017 ])
4018 ])
4019
4020 if test "$cf_cv_define_sigwinch" = maybe ; then
4021 AC_CACHE_CHECK(for actual SIGWINCH definition,cf_cv_fixup_sigwinch,[
4022 cf_cv_fixup_sigwinch=unknown
4023 cf_sigwinch=32
4024 while test $cf_sigwinch != 1
4025 do
4026         AC_TRY_COMPILE([
4027 #undef _XOPEN_SOURCE
4028 #undef _POSIX_SOURCE
4029 #undef _POSIX_C_SOURCE
4030 #include <sys/types.h>
4031 #include <sys/signal.h>
4032 ],[
4033 #if SIGWINCH != $cf_sigwinch
4034 make an error
4035 #endif
4036 int x = SIGWINCH],
4037         [cf_cv_fixup_sigwinch=$cf_sigwinch
4038          break])
4039
4040 cf_sigwinch=`expr $cf_sigwinch - 1`
4041 done
4042 ])
4043
4044         if test "$cf_cv_fixup_sigwinch" != unknown ; then
4045                 CPPFLAGS="$CPPFLAGS -DSIGWINCH=$cf_cv_fixup_sigwinch"
4046         fi
4047 fi
4048 ])dnl
4049 dnl ---------------------------------------------------------------------------
4050 dnl CF_SIZECHANGE version: 8 updated: 2000/11/04 12:22:16
4051 dnl -------------
4052 dnl Check for definitions & structures needed for window size-changing
4053 dnl FIXME: check that this works with "snake" (HP-UX 10.x)
4054 AC_DEFUN([CF_SIZECHANGE],
4055 [
4056 AC_REQUIRE([CF_STRUCT_TERMIOS])
4057 AC_CACHE_CHECK(declaration of size-change, cf_cv_sizechange,[
4058     cf_cv_sizechange=unknown
4059     cf_save_CPPFLAGS="$CPPFLAGS"
4060
4061 for cf_opts in "" "NEED_PTEM_H"
4062 do
4063
4064     CPPFLAGS="$cf_save_CPPFLAGS"
4065     test -n "$cf_opts" && CPPFLAGS="$CPPFLAGS -D$cf_opts"
4066     AC_TRY_COMPILE([#include <sys/types.h>
4067 #ifdef HAVE_TERMIOS_H
4068 #include <termios.h>
4069 #else
4070 #ifdef HAVE_TERMIO_H
4071 #include <termio.h>
4072 #endif
4073 #endif
4074 #ifdef NEED_PTEM_H
4075 /* This is a workaround for SCO:  they neglected to define struct winsize in
4076  * termios.h -- it's only in termio.h and ptem.h
4077  */
4078 #include        <sys/stream.h>
4079 #include        <sys/ptem.h>
4080 #endif
4081 #if !defined(sun) || !defined(HAVE_TERMIOS_H)
4082 #include <sys/ioctl.h>
4083 #endif
4084 ],[
4085 #ifdef TIOCGSIZE
4086         struct ttysize win;     /* FIXME: what system is this? */
4087         int y = win.ts_lines;
4088         int x = win.ts_cols;
4089 #else
4090 #ifdef TIOCGWINSZ
4091         struct winsize win;
4092         int y = win.ws_row;
4093         int x = win.ws_col;
4094 #else
4095         no TIOCGSIZE or TIOCGWINSZ
4096 #endif /* TIOCGWINSZ */
4097 #endif /* TIOCGSIZE */
4098         ],
4099         [cf_cv_sizechange=yes],
4100         [cf_cv_sizechange=no])
4101
4102         CPPFLAGS="$cf_save_CPPFLAGS"
4103         if test "$cf_cv_sizechange" = yes ; then
4104                 echo "size-change succeeded ($cf_opts)" >&AC_FD_CC
4105                 test -n "$cf_opts" && cf_cv_sizechange="$cf_opts"
4106                 break
4107         fi
4108 done
4109 ])
4110 if test "$cf_cv_sizechange" != no ; then
4111         AC_DEFINE(HAVE_SIZECHANGE)
4112         case $cf_cv_sizechange in #(vi
4113         NEED*)
4114                 AC_DEFINE_UNQUOTED($cf_cv_sizechange )
4115                 ;;
4116         esac
4117 fi
4118 ])dnl
4119 dnl ---------------------------------------------------------------------------
4120 dnl CF_SRC_MODULES version: 18 updated: 2005/05/28 12:58:54
4121 dnl --------------
4122 dnl For each parameter, test if the source-directory exists, and if it contains
4123 dnl a 'modules' file.  If so, add to the list $cf_cv_src_modules which we'll
4124 dnl use in CF_LIB_RULES.
4125 dnl
4126 dnl This uses the configured value to make the lists SRC_SUBDIRS and
4127 dnl SUB_MAKEFILES which are used in the makefile-generation scheme.
4128 AC_DEFUN([CF_SRC_MODULES],
4129 [
4130 AC_MSG_CHECKING(for src modules)
4131
4132 # dependencies and linker-arguments for test-programs
4133 TEST_DEPS="${LIB_DIR}/${LIB_PREFIX}${LIB_NAME}${DFT_DEP_SUFFIX} $TEST_DEPS"
4134 TEST_DEP2="${LIB_2ND}/${LIB_PREFIX}${LIB_NAME}${DFT_DEP_SUFFIX} $TEST_DEP2"
4135 if test "$DFT_LWR_MODEL" = "libtool"; then
4136         TEST_ARGS="${TEST_DEPS}"
4137         TEST_ARG2="${TEST_DEP2}"
4138 else
4139         TEST_ARGS="-l${LIB_NAME}${DFT_ARG_SUFFIX} $TEST_ARGS"
4140         TEST_ARG2="-l${LIB_NAME}${DFT_ARG_SUFFIX} $TEST_ARG2"
4141 fi
4142
4143 cf_cv_src_modules=
4144 for cf_dir in $1
4145 do
4146         if test -f $srcdir/$cf_dir/modules; then
4147
4148                 # We may/may not have tack in the distribution, though the
4149                 # makefile is.
4150                 if test $cf_dir = tack ; then
4151                         if test ! -f $srcdir/${cf_dir}/${cf_dir}.h; then
4152                                 continue
4153                         fi
4154                 fi
4155
4156                 if test -z "$cf_cv_src_modules"; then
4157                         cf_cv_src_modules=$cf_dir
4158                 else
4159                         cf_cv_src_modules="$cf_cv_src_modules $cf_dir"
4160                 fi
4161
4162                 # Make the ncurses_cfg.h file record the library interface files as
4163                 # well.  These are header files that are the same name as their
4164                 # directory.  Ncurses is the only library that does not follow
4165                 # that pattern.
4166                 if test $cf_dir = tack ; then
4167                         continue
4168                 elif test -f $srcdir/${cf_dir}/${cf_dir}.h; then
4169                         CF_UPPER(cf_have_include,$cf_dir)
4170                         AC_DEFINE_UNQUOTED(HAVE_${cf_have_include}_H)
4171                         AC_DEFINE_UNQUOTED(HAVE_LIB${cf_have_include})
4172                         TEST_DEPS="${LIB_DIR}/${LIB_PREFIX}${cf_dir}${DFT_DEP_SUFFIX} $TEST_DEPS"
4173                         TEST_DEP2="${LIB_2ND}/${LIB_PREFIX}${cf_dir}${DFT_DEP_SUFFIX} $TEST_DEP2"
4174                         if test "$DFT_LWR_MODEL" = "libtool"; then
4175                                 TEST_ARGS="${TEST_DEPS}"
4176                                 TEST_ARG2="${TEST_DEP2}"
4177                         else
4178                                 TEST_ARGS="-l${cf_dir}${DFT_ARG_SUFFIX} $TEST_ARGS"
4179                                 TEST_ARG2="-l${cf_dir}${DFT_ARG_SUFFIX} $TEST_ARG2"
4180                         fi
4181                 fi
4182         fi
4183 done
4184 AC_MSG_RESULT($cf_cv_src_modules)
4185
4186 TEST_ARGS="-L${LIB_DIR} $TEST_ARGS"
4187 TEST_ARG2="-L${LIB_2ND} $TEST_ARG2"
4188
4189 AC_SUBST(TEST_ARGS)
4190 AC_SUBST(TEST_DEPS)
4191
4192 AC_SUBST(TEST_ARG2)
4193 AC_SUBST(TEST_DEP2)
4194
4195 SRC_SUBDIRS="man include"
4196 for cf_dir in $cf_cv_src_modules
4197 do
4198         SRC_SUBDIRS="$SRC_SUBDIRS $cf_dir"
4199 done
4200 SRC_SUBDIRS="$SRC_SUBDIRS test"
4201 test -z "$MAKE_TERMINFO" && SRC_SUBDIRS="$SRC_SUBDIRS misc"
4202 test "$cf_with_cxx_binding" != no && SRC_SUBDIRS="$SRC_SUBDIRS c++"
4203
4204 ADA_SUBDIRS=
4205 if test "$cf_cv_prog_gnat_correct" = yes && test -f $srcdir/Ada95/Makefile.in; then
4206    SRC_SUBDIRS="$SRC_SUBDIRS Ada95"
4207    ADA_SUBDIRS="gen src samples"
4208 fi
4209
4210 SUB_MAKEFILES=
4211 for cf_dir in $SRC_SUBDIRS
4212 do
4213         SUB_MAKEFILES="$SUB_MAKEFILES $cf_dir/Makefile"
4214 done
4215
4216 if test -n "$ADA_SUBDIRS"; then
4217    for cf_dir in $ADA_SUBDIRS
4218    do
4219       SUB_MAKEFILES="$SUB_MAKEFILES Ada95/$cf_dir/Makefile"
4220    done
4221    AC_SUBST(ADA_SUBDIRS)
4222 fi
4223 ])dnl
4224 dnl ---------------------------------------------------------------------------
4225 dnl CF_STDCPP_LIBRARY version: 5 updated: 2000/08/12 23:18:52
4226 dnl -----------------
4227 dnl Check for -lstdc++, which is GNU's standard C++ library.
4228 AC_DEFUN([CF_STDCPP_LIBRARY],
4229 [
4230 if test -n "$GXX" ; then
4231 case $cf_cv_system_name in #(vi
4232 os2*) #(vi
4233         cf_stdcpp_libname=stdcpp
4234         ;;
4235 *)
4236         cf_stdcpp_libname=stdc++
4237         ;;
4238 esac
4239 AC_CACHE_CHECK(for library $cf_stdcpp_libname,cf_cv_libstdcpp,[
4240         cf_save="$LIBS"
4241         LIBS="$LIBS -l$cf_stdcpp_libname"
4242 AC_TRY_LINK([
4243 #include <strstream.h>],[
4244 char buf[80];
4245 strstreambuf foo(buf, sizeof(buf))
4246 ],
4247         [cf_cv_libstdcpp=yes],
4248         [cf_cv_libstdcpp=no])
4249         LIBS="$cf_save"
4250 ])
4251 test "$cf_cv_libstdcpp" = yes && CXXLIBS="$CXXLIBS -l$cf_stdcpp_libname"
4252 fi
4253 ])dnl
4254 dnl ---------------------------------------------------------------------------
4255 dnl CF_STRIP_G_OPT version: 3 updated: 2002/12/21 19:25:52
4256 dnl --------------
4257 dnl     Remove "-g" option from the compiler options
4258 AC_DEFUN([CF_STRIP_G_OPT],
4259 [$1=`echo ${$1} | sed -e 's%-g %%' -e 's%-g$%%'`])dnl
4260 dnl ---------------------------------------------------------------------------
4261 dnl CF_STRUCT_SIGACTION version: 3 updated: 2000/08/12 23:18:52
4262 dnl -------------------
4263 dnl Check if we need _POSIX_SOURCE defined to use struct sigaction.  We'll only
4264 dnl do this if we've found the sigaction function.
4265 dnl
4266 dnl If needed, define SVR4_ACTION.
4267 AC_DEFUN([CF_STRUCT_SIGACTION],[
4268 if test "$ac_cv_func_sigaction" = yes; then
4269 AC_MSG_CHECKING(whether sigaction needs _POSIX_SOURCE)
4270 AC_TRY_COMPILE([
4271 #include <sys/types.h>
4272 #include <signal.h>],
4273         [struct sigaction act],
4274         [sigact_bad=no],
4275         [
4276 AC_TRY_COMPILE([
4277 #define _POSIX_SOURCE
4278 #include <sys/types.h>
4279 #include <signal.h>],
4280         [struct sigaction act],
4281         [sigact_bad=yes
4282          AC_DEFINE(SVR4_ACTION)],
4283          [sigact_bad=unknown])])
4284 AC_MSG_RESULT($sigact_bad)
4285 fi
4286 ])dnl
4287 dnl ---------------------------------------------------------------------------
4288 dnl CF_STRUCT_TERMIOS version: 5 updated: 2000/11/04 12:22:46
4289 dnl -----------------
4290 dnl Some machines require _POSIX_SOURCE to completely define struct termios.
4291 dnl If so, define SVR4_TERMIO
4292 AC_DEFUN([CF_STRUCT_TERMIOS],[
4293 AC_CHECK_HEADERS( \
4294 termio.h \
4295 termios.h \
4296 unistd.h \
4297 )
4298 if test "$ISC" = yes ; then
4299         AC_CHECK_HEADERS( sys/termio.h )
4300 fi
4301 if test "$ac_cv_header_termios_h" = yes ; then
4302         case "$CFLAGS $CPPFLAGS" in
4303         *-D_POSIX_SOURCE*)
4304                 termios_bad=dunno ;;
4305         *)      termios_bad=maybe ;;
4306         esac
4307         if test "$termios_bad" = maybe ; then
4308         AC_MSG_CHECKING(whether termios.h needs _POSIX_SOURCE)
4309         AC_TRY_COMPILE([#include <termios.h>],
4310                 [struct termios foo; int x = foo.c_iflag],
4311                 termios_bad=no, [
4312                 AC_TRY_COMPILE([
4313 #define _POSIX_SOURCE
4314 #include <termios.h>],
4315                         [struct termios foo; int x = foo.c_iflag],
4316                         termios_bad=unknown,
4317                         termios_bad=yes AC_DEFINE(SVR4_TERMIO))
4318                         ])
4319         AC_MSG_RESULT($termios_bad)
4320         fi
4321 fi
4322 ])dnl
4323 dnl ---------------------------------------------------------------------------
4324 dnl CF_SUBST version: 4 updated: 2006/06/17 12:33:03
4325 dnl --------
4326 dnl     Shorthand macro for substituting things that the user may override
4327 dnl     with an environment variable.
4328 dnl
4329 dnl     $1 = long/descriptive name
4330 dnl     $2 = environment variable
4331 dnl     $3 = default value
4332 AC_DEFUN([CF_SUBST],
4333 [AC_CACHE_VAL(cf_cv_subst_$2,[
4334 AC_MSG_CHECKING(for $1 (symbol $2))
4335 CF_SUBST_IF([-z "[$]$2"], [$2], [$3])
4336 cf_cv_subst_$2=[$]$2
4337 AC_MSG_RESULT([$]$2)
4338 ])
4339 ])dnl
4340 dnl ---------------------------------------------------------------------------
4341 dnl CF_SUBST_IF version: 2 updated: 2006/06/17 12:33:03
4342 dnl -----------
4343 dnl     Shorthand macro for substituting things that the user may override
4344 dnl     with an environment variable.
4345 dnl
4346 dnl     $1 = condition to pass to "test"
4347 dnl     $2 = environment variable
4348 dnl     $3 = value if the test succeeds
4349 dnl     $4 = value if the test fails
4350 AC_DEFUN([CF_SUBST_IF],
4351 [
4352 if test $1 ; then
4353         $2=$3
4354 ifelse($4,,,[else
4355         $2=$4])
4356 fi
4357 AC_SUBST($2)
4358 ])dnl
4359 dnl ---------------------------------------------------------------------------
4360 dnl CF_SUBST_NCURSES_VERSION version: 8 updated: 2006/09/16 11:40:59
4361 dnl ------------------------
4362 dnl Get the version-number for use in shared-library naming, etc.
4363 AC_DEFUN([CF_SUBST_NCURSES_VERSION],
4364 [
4365 AC_REQUIRE([CF_PROG_EGREP])
4366 NCURSES_MAJOR="`$ac_cv_prog_egrep '^NCURSES_MAJOR[[     ]]*=' $srcdir/dist.mk | sed -e 's/^[[^0-9]]*//'`"
4367 NCURSES_MINOR="`$ac_cv_prog_egrep '^NCURSES_MINOR[[     ]]*=' $srcdir/dist.mk | sed -e 's/^[[^0-9]]*//'`"
4368 NCURSES_PATCH="`$ac_cv_prog_egrep '^NCURSES_PATCH[[     ]]*=' $srcdir/dist.mk | sed -e 's/^[[^0-9]]*//'`"
4369 cf_cv_abi_version=${NCURSES_MAJOR}
4370 cf_cv_rel_version=${NCURSES_MAJOR}.${NCURSES_MINOR}
4371 dnl Show the computed version, for logging
4372 cf_cv_timestamp=`date`
4373 AC_MSG_RESULT(Configuring NCURSES $cf_cv_rel_version ABI $cf_cv_abi_version ($cf_cv_timestamp))
4374 dnl We need these values in the generated headers
4375 AC_SUBST(NCURSES_MAJOR)
4376 AC_SUBST(NCURSES_MINOR)
4377 AC_SUBST(NCURSES_PATCH)
4378 dnl We need these values in the generated makefiles
4379 AC_SUBST(cf_cv_rel_version)
4380 AC_SUBST(cf_cv_abi_version)
4381 AC_SUBST(cf_cv_builtin_bool)
4382 AC_SUBST(cf_cv_header_stdbool_h)
4383 AC_SUBST(cf_cv_type_of_bool)dnl
4384 ])dnl
4385 dnl ---------------------------------------------------------------------------
4386 dnl CF_SYS_TIME_SELECT version: 4 updated: 2000/10/04 09:18:40
4387 dnl ------------------
4388 dnl Check if we can include <sys/time.h> with <sys/select.h>; this breaks on
4389 dnl older SCO configurations.
4390 AC_DEFUN([CF_SYS_TIME_SELECT],
4391 [
4392 AC_MSG_CHECKING(if sys/time.h works with sys/select.h)
4393 AC_CACHE_VAL(cf_cv_sys_time_select,[
4394 AC_TRY_COMPILE([
4395 #include <sys/types.h>
4396 #ifdef HAVE_SYS_TIME_H
4397 #include <sys/time.h>
4398 #endif
4399 #ifdef HAVE_SYS_SELECT_H
4400 #include <sys/select.h>
4401 #endif
4402 ],[],[cf_cv_sys_time_select=yes],
4403      [cf_cv_sys_time_select=no])
4404      ])
4405 AC_MSG_RESULT($cf_cv_sys_time_select)
4406 test "$cf_cv_sys_time_select" = yes && AC_DEFINE(HAVE_SYS_TIME_SELECT)
4407 ])dnl
4408 dnl ---------------------------------------------------------------------------
4409 dnl CF_TOP_BUILDDIR version: 1 updated: 2006/10/15 16:33:23
4410 dnl ---------------
4411 dnl Define a top_builddir symbol, for applications that need an absolute path.
4412 AC_DEFUN([CF_TOP_BUILDDIR],
4413 [
4414 top_builddir=`pwd`
4415 AC_SUBST(top_builddir)
4416 ])dnl
4417 dnl ---------------------------------------------------------------------------
4418 dnl CF_TYPEOF_CHTYPE version: 8 updated: 2006/12/16 12:33:30
4419 dnl ----------------
4420 dnl Determine the type we should use for chtype (and attr_t, which is treated
4421 dnl as the same thing).  We want around 32 bits, so on most machines want a
4422 dnl long, but on newer 64-bit machines, probably want an int.  If we're using
4423 dnl wide characters, we have to have a type compatible with that, as well.
4424 AC_DEFUN([CF_TYPEOF_CHTYPE],
4425 [
4426 AC_MSG_CHECKING([for type of chtype])
4427 AC_CACHE_VAL(cf_cv_typeof_chtype,[
4428                 AC_TRY_RUN([
4429 #define WANT_BITS 31
4430 #include <stdio.h>
4431 int main()
4432 {
4433         FILE *fp = fopen("cf_test.out", "w");
4434         if (fp != 0) {
4435                 char *result = "long";
4436                 if (sizeof(unsigned long) > sizeof(unsigned int)) {
4437                         int n;
4438                         unsigned int x, y;
4439                         for (n = 0; n < WANT_BITS; n++) {
4440                                 x = (1 << n);
4441                                 y = (x >> n);
4442                                 if (y != 1 || x == 0) {
4443                                         x = 0;
4444                                         break;
4445                                 }
4446                         }
4447                         /*
4448                          * If x is nonzero, an int is big enough for the bits
4449                          * that we want.
4450                          */
4451                         result = (x != 0) ? "int" : "long";
4452                 }
4453                 fputs(result, fp);
4454                 fclose(fp);
4455         }
4456         ${cf_cv_main_return:-return}(0);
4457 }
4458                 ],
4459                 [cf_cv_typeof_chtype=`cat cf_test.out`],
4460                 [cf_cv_typeof_chtype=long],
4461                 [cf_cv_typeof_chtype=long])
4462                 rm -f cf_test.out
4463         ])
4464 AC_MSG_RESULT($cf_cv_typeof_chtype)
4465
4466 AC_SUBST(cf_cv_typeof_chtype)
4467 AC_DEFINE_UNQUOTED(TYPEOF_CHTYPE,$cf_cv_typeof_chtype)
4468 ])dnl
4469 dnl ---------------------------------------------------------------------------
4470 dnl CF_TYPE_SIGACTION version: 3 updated: 2000/08/12 23:18:52
4471 dnl -----------------
4472 dnl
4473 AC_DEFUN([CF_TYPE_SIGACTION],
4474 [
4475 AC_MSG_CHECKING([for type sigaction_t])
4476 AC_CACHE_VAL(cf_cv_type_sigaction,[
4477         AC_TRY_COMPILE([
4478 #include <signal.h>],
4479                 [sigaction_t x],
4480                 [cf_cv_type_sigaction=yes],
4481                 [cf_cv_type_sigaction=no])])
4482 AC_MSG_RESULT($cf_cv_type_sigaction)
4483 test "$cf_cv_type_sigaction" = yes && AC_DEFINE(HAVE_TYPE_SIGACTION)
4484 ])dnl
4485 dnl ---------------------------------------------------------------------------
4486 dnl CF_UNSIGNED_LITERALS version: 2 updated: 1998/02/07 22:10:16
4487 dnl --------------------
4488 dnl Test if the compiler supports 'U' and 'L' suffixes.  Only old compilers
4489 dnl won't, but they're still there.
4490 AC_DEFUN([CF_UNSIGNED_LITERALS],
4491 [
4492 AC_MSG_CHECKING([if unsigned literals are legal])
4493 AC_CACHE_VAL(cf_cv_unsigned_literals,[
4494         AC_TRY_COMPILE([],[long x = 1L + 1UL + 1U + 1],
4495                 [cf_cv_unsigned_literals=yes],
4496                 [cf_cv_unsigned_literals=no])