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