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