555f773938b00a7b38f823af60279fc0bf8edf54
[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.416 2007/02/03 16:35:13 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: 44 updated: 2007/01/28 11:40:44
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 LIBRARIES 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                 IMPORT_LIB=
1801                 SHARED_LIB=
1802                 LIBS_TO_MAKE=
1803                 for cf_item in $cf_LIST_MODELS
1804                 do
1805                         CF_LIB_SUFFIX($cf_item,cf_suffix)
1806                         if test $cf_item = shared ; then
1807                         if test "$cf_cv_do_symlinks" = yes ; then
1808                                 case "$cf_cv_shlib_version" in #(vi
1809                                 rel) #(vi
1810                                         case "$cf_cv_system_name" in #(vi
1811                                         darwin*)
1812                                         case .${LIB_SUFFIX} in
1813                                         .w*)
1814                                                 cf_suffix=`echo $cf_suffix | sed 's/^w//'`
1815                                                 cf_suffix=w'.${REL_VERSION}'"$cf_suffix"
1816                                                 ;;
1817                                         *)
1818                                                 cf_suffix='.${REL_VERSION}'"$cf_suffix"
1819                                                 ;;
1820                                         esac
1821                                         ;; #(vi
1822                                         *) cf_suffix="$cf_suffix"'.${REL_VERSION}' ;;
1823                                         esac
1824                                         ;;
1825                                 abi)
1826                                         case "$cf_cv_system_name" in #(vi
1827                                         darwin*)
1828                                         case .${LIB_SUFFIX} in
1829                                         .w*)
1830                                                 cf_suffix=`echo $cf_suffix | sed 's/^w//'`
1831                                                 cf_suffix=w'.${ABI_VERSION}'"$cf_suffix"
1832                                                 ;;
1833                                         *)
1834                                                 cf_suffix='.${ABI_VERSION}'"$cf_suffix"
1835                                                 ;;
1836                                         esac
1837                                         ;; #(vi
1838                                         *) cf_suffix="$cf_suffix"'.${ABI_VERSION}' ;;
1839                                         esac
1840                                         ;;
1841                                 esac
1842                         fi
1843                         # cygwin needs import library, and has unique naming convention
1844                         # use autodetected ${cf_prefix} for import lib and static lib, but
1845                         # use 'cyg' prefix for shared lib.
1846                         if test $cf_cv_shlib_version = cygdll ; then
1847                                 SHARED_LIB="cyg${cf_dir}\${ABI_VERSION}.dll"
1848                                 IMPORT_LIB="${cf_prefix}${cf_dir}.dll.a"
1849                                 LIBS_TO_MAKE="$LIBS_TO_MAKE ../lib/\${SHARED_LIB} ../lib/\${IMPORT_LIB}"
1850                                 continue
1851                         fi
1852                         fi
1853                         LIBS_TO_MAKE="$LIBS_TO_MAKE ../lib/${cf_prefix}${cf_dir}${cf_suffix}"
1854                 done
1855
1856                 if test $cf_dir = ncurses ; then
1857                         cf_subsets="$LIB_SUBSETS"
1858                         cf_r_parts="$cf_subsets"
1859
1860                         while test -n "$cf_r_parts"
1861                         do
1862                                 cf_l_parts=`echo "$cf_r_parts" |sed -e 's/ .*$//'`
1863                                 cf_r_parts=`echo "$cf_r_parts" |sed -e 's/^[[^ ]]* //'`
1864                                 if test "$cf_l_parts" != "$cf_r_parts" ; then
1865                                         case $cf_l_parts in #(vi
1866                                         *termlib*) #(vi
1867                                                 cf_item=`echo $LIBS_TO_MAKE |sed -e s%${LIB_NAME}${LIB_SUFFIX}%${TINFO_LIB_SUFFIX}%g`
1868                                                 ;;
1869                                         *ticlib*)
1870                                                 cf_item=`echo $LIBS_TO_MAKE |sed -e s%${LIB_NAME}${LIB_SUFFIX}%${TICS_LIB_SUFFIX}%g`
1871                                                 ;;
1872                                         *)
1873                                                 break
1874                                                 ;;
1875                                         esac
1876                                         LIBS_TO_MAKE="$cf_item $LIBS_TO_MAKE"
1877                                 else
1878                                         break
1879                                 fi
1880                         done
1881                 else
1882                         cf_subsets=`echo "$LIB_SUBSETS" | sed -e 's/^termlib.* //'`
1883                 fi
1884
1885                 sed -e "s%@LIBS_TO_MAKE@%$LIBS_TO_MAKE%" \
1886                     -e "s%@IMPORT_LIB@%$IMPORT_LIB%" \
1887                     -e "s%@SHARED_LIB@%$SHARED_LIB%" \
1888                         $cf_dir/Makefile >$cf_dir/Makefile.out
1889                 mv $cf_dir/Makefile.out $cf_dir/Makefile
1890
1891                 $AWK -f $srcdir/mk-0th.awk \
1892                         libname="${cf_dir}${LIB_SUFFIX}" subsets="$LIB_SUBSETS" \
1893                         $srcdir/$cf_dir/modules >>$cf_dir/Makefile
1894
1895                 for cf_subset in $cf_subsets
1896                 do
1897                         cf_subdirs=
1898                         for cf_item in $cf_LIST_MODELS
1899                         do
1900                         echo "Appending rules for ${cf_item} model (${cf_dir}: ${cf_subset})"
1901                         CF_UPPER(cf_ITEM,$cf_item)
1902                         CF_LIB_SUFFIX($cf_item,cf_suffix)
1903                         CF_OBJ_SUBDIR($cf_item,cf_subdir)
1904
1905                         # Test for case where we build libtinfo with a different name.
1906                         cf_libname=$cf_dir
1907                         if test $cf_dir = ncurses ; then
1908                                 case $cf_subset in
1909                                 *base*)
1910                                         ;;
1911                                 *termlib*)
1912                                         cf_libname=$TINFO_LIB_SUFFIX
1913                                         if test -n "${DFT_ARG_SUFFIX}" ; then
1914                                                 # undo $LIB_SUFFIX add-on in CF_LIB_SUFFIX
1915                                                 cf_suffix=`echo $cf_suffix |sed -e "s%^${LIB_SUFFIX}%%"`
1916                                         fi
1917                                         ;;
1918                                 ticlib*)
1919                                         cf_libname=$TICS_LIB_SUFFIX
1920                                         if test -n "${DFT_ARG_SUFFIX}" ; then
1921                                                 # undo $LIB_SUFFIX add-on in CF_LIB_SUFFIX
1922                                                 cf_suffix=`echo $cf_suffix |sed -e "s%^${LIB_SUFFIX}%%"`
1923                                         fi
1924                                         ;;
1925                                 esac
1926                         fi
1927
1928                         # These dependencies really are for development, not
1929                         # builds, but they are useful in porting, too.
1930                         cf_depend="../include/ncurses_cfg.h"
1931                         if test "$srcdir" = "."; then
1932                                 cf_reldir="."
1933                         else
1934                                 cf_reldir="\${srcdir}"
1935                         fi
1936
1937                         if test -f $srcdir/$cf_dir/$cf_dir.priv.h; then
1938                                 cf_depend="$cf_depend $cf_reldir/$cf_dir.priv.h"
1939                         elif test -f $srcdir/$cf_dir/curses.priv.h; then
1940                                 cf_depend="$cf_depend $cf_reldir/curses.priv.h"
1941                         fi
1942
1943                         cf_dir_suffix=
1944                         old_cf_suffix="$cf_suffix"
1945                         if test "$cf_cv_shlib_version_infix" = yes ; then
1946                         if test -n "$LIB_SUFFIX" ; then
1947                                 case $LIB_SUFFIX in
1948                                 w*)
1949                                         cf_libname=`echo $cf_libname | sed 's/w$//'`
1950                                         cf_suffix=`echo $cf_suffix | sed 's/^w//'`
1951                                         cf_dir_suffix=w
1952                                         ;;
1953                                 esac
1954                         fi
1955                         fi
1956
1957                         $AWK -f $srcdir/mk-1st.awk \
1958                                 name=${cf_libname}${cf_dir_suffix} \
1959                                 traces=$LIB_TRACING \
1960                                 MODEL=$cf_ITEM \
1961                                 model=$cf_subdir \
1962                                 prefix=$cf_prefix \
1963                                 suffix=$cf_suffix \
1964                                 subset=$cf_subset \
1965                                 ShlibVer=$cf_cv_shlib_version \
1966                                 ShlibVerInfix=$cf_cv_shlib_version_infix \
1967                                 DoLinks=$cf_cv_do_symlinks \
1968                                 rmSoLocs=$cf_cv_rm_so_locs \
1969                                 ldconfig="$LDCONFIG" \
1970                                 overwrite=$WITH_OVERWRITE \
1971                                 depend="$cf_depend" \
1972                                 host="$host" \
1973                                 $srcdir/$cf_dir/modules >>$cf_dir/Makefile
1974
1975                         cf_suffix="$old_cf_suffix"
1976
1977                         for cf_subdir2 in $cf_subdirs lib
1978                         do
1979                                 test $cf_subdir = $cf_subdir2 && break
1980                         done
1981                         test "${cf_subset}.${cf_subdir2}" != "${cf_subset}.${cf_subdir}" && \
1982                         $AWK -f $srcdir/mk-2nd.awk \
1983                                 name=$cf_dir \
1984                                 traces=$LIB_TRACING \
1985                                 MODEL=$cf_ITEM \
1986                                 model=$cf_subdir \
1987                                 subset=$cf_subset \
1988                                 srcdir=$srcdir \
1989                                 echo=$WITH_ECHO \
1990                                 crenames=$cf_cv_prog_CC_c_o \
1991                                 cxxrenames=$cf_cv_prog_CXX_c_o \
1992                                 $srcdir/$cf_dir/modules >>$cf_dir/Makefile
1993                         cf_subdirs="$cf_subdirs $cf_subdir"
1994                         done
1995                 done
1996         fi
1997
1998         echo '  cd '$cf_dir' && ${MAKE} ${CF_MFLAGS} [$]@' >>Makefile
1999 done
2000
2001 for cf_dir in $SRC_SUBDIRS
2002 do
2003         if test ! -d $srcdir/$cf_dir ; then
2004                 continue
2005         fi
2006
2007         if test -f $cf_dir/Makefile ; then
2008                 case "$cf_dir" in
2009                 Ada95) #(vi
2010                         echo 'libs \' >> Makefile
2011                         echo 'install.libs \' >> Makefile
2012                         echo 'uninstall.libs ::' >> Makefile
2013                         echo '  cd '$cf_dir' && ${MAKE} ${CF_MFLAGS} [$]@' >> Makefile
2014                         ;;
2015                 esac
2016         fi
2017
2018         if test -f $srcdir/$cf_dir/modules; then
2019                 echo >> Makefile
2020                 if test -f $srcdir/$cf_dir/headers; then
2021 cat >> Makefile <<CF_EOF
2022 install.includes \\
2023 uninstall.includes \\
2024 CF_EOF
2025                 fi
2026 if test "$cf_dir" != "c++" ; then
2027 echo 'lint \' >> Makefile
2028 fi
2029 cat >> Makefile <<CF_EOF
2030 libs \\
2031 lintlib \\
2032 install.libs \\
2033 uninstall.libs \\
2034 install.$cf_dir \\
2035 uninstall.$cf_dir ::
2036         cd $cf_dir && \${MAKE} \${CF_MFLAGS} \[$]@
2037 CF_EOF
2038         elif test -f $srcdir/$cf_dir/headers; then
2039 cat >> Makefile <<CF_EOF
2040
2041 libs \\
2042 install.libs \\
2043 uninstall.libs \\
2044 install.includes \\
2045 uninstall.includes ::
2046         cd $cf_dir && \${MAKE} \${CF_MFLAGS} \[$]@
2047 CF_EOF
2048 fi
2049 done
2050
2051 cat >> Makefile <<CF_EOF
2052
2053 install.libs uninstall.libs \\
2054 install.data uninstall.data ::
2055 $MAKE_TERMINFO  cd misc && \${MAKE} \${CF_MFLAGS} \[$]@
2056
2057 install.man \\
2058 uninstall.man ::
2059         cd man && \${MAKE} \${CF_MFLAGS} \[$]@
2060
2061 distclean ::
2062         rm -f config.cache config.log config.status Makefile include/ncurses_cfg.h
2063         rm -f headers.sh headers.sed
2064         rm -rf \${DIRS_TO_MAKE}
2065 CF_EOF
2066
2067 # Special case: tack's manpage lives in its own directory.
2068 if test -d tack ; then
2069 if test -f $srcdir/$tack.h; then
2070 cat >> Makefile <<CF_EOF
2071
2072 install.man \\
2073 uninstall.man ::
2074         cd tack && \${MAKE} \${CF_MFLAGS} \[$]@
2075 CF_EOF
2076 fi
2077 fi
2078
2079 dnl If we're installing into a subdirectory of /usr/include, etc., we should
2080 dnl prepend the subdirectory's name to the "#include" paths.  It won't hurt
2081 dnl anything, and will make it more standardized.  It's awkward to decide this
2082 dnl at configuration because of quoting, so we'll simply make all headers
2083 dnl installed via a script that can do the right thing.
2084
2085 rm -f headers.sed headers.sh
2086
2087 dnl ( generating this script makes the makefiles a little tidier :-)
2088 echo creating headers.sh
2089 cat >headers.sh <<CF_EOF
2090 #! /bin/sh
2091 # This shell script is generated by the 'configure' script.  It is invoked in a
2092 # subdirectory of the build tree.  It generates a sed-script in the parent
2093 # directory that is used to adjust includes for header files that reside in a
2094 # subdirectory of /usr/include, etc.
2095 PRG=""
2096 while test \[$]# != 3
2097 do
2098 PRG="\$PRG \[$]1"; shift
2099 done
2100 DST=\[$]1
2101 REF=\[$]2
2102 SRC=\[$]3
2103 TMPSRC=\${TMPDIR-/tmp}/\`basename \$SRC\`\$\$
2104 TMPSED=\${TMPDIR-/tmp}/headers.sed\$\$
2105 echo installing \$SRC in \$DST
2106 CF_EOF
2107
2108 if test $WITH_CURSES_H = yes; then
2109         cat >>headers.sh <<CF_EOF
2110 case \$DST in
2111 /*/include/*)
2112         END=\`basename \$DST\`
2113         for i in \`cat \$REF/../*/headers |fgrep -v "#"\`
2114         do
2115                 NAME=\`basename \$i\`
2116                 echo "s/<\$NAME>/<\$END\/\$NAME>/" >> \$TMPSED
2117         done
2118         ;;
2119 *)
2120         echo "" >> \$TMPSED
2121         ;;
2122 esac
2123 CF_EOF
2124
2125 else
2126         cat >>headers.sh <<CF_EOF
2127 case \$DST in
2128 /*/include/*)
2129         END=\`basename \$DST\`
2130         for i in \`cat \$REF/../*/headers |fgrep -v "#"\`
2131         do
2132                 NAME=\`basename \$i\`
2133                 if test "\$NAME" = "curses.h"
2134                 then
2135                         echo "s/<curses.h>/<ncurses.h>/" >> \$TMPSED
2136                         NAME=ncurses.h
2137                 fi
2138                 echo "s/<\$NAME>/<\$END\/\$NAME>/" >> \$TMPSED
2139         done
2140         ;;
2141 *)
2142         echo "s/<curses.h>/<ncurses.h>/" >> \$TMPSED
2143         ;;
2144 esac
2145 CF_EOF
2146 fi
2147 cat >>headers.sh <<CF_EOF
2148 rm -f \$TMPSRC
2149 sed -f \$TMPSED \$SRC > \$TMPSRC
2150 NAME=\`basename \$SRC\`
2151 CF_EOF
2152 if test $WITH_CURSES_H != yes; then
2153         cat >>headers.sh <<CF_EOF
2154 test "\$NAME" = "curses.h" && NAME=ncurses.h
2155 CF_EOF
2156 fi
2157 cat >>headers.sh <<CF_EOF
2158 # Just in case someone gzip'd manpages, remove the conflicting copy.
2159 test -f \$DST/\$NAME.gz && rm -f \$DST/\$NAME.gz
2160
2161 eval \$PRG \$TMPSRC \$DST/\$NAME
2162 rm -f \$TMPSRC \$TMPSED
2163 CF_EOF
2164
2165 chmod 0755 headers.sh
2166
2167 for cf_dir in $SRC_SUBDIRS
2168 do
2169         if test ! -d $srcdir/$cf_dir ; then
2170                 continue
2171         fi
2172
2173         if test -f $srcdir/$cf_dir/headers; then
2174                 $AWK -f $srcdir/mk-hdr.awk \
2175                         subset="$LIB_SUBSETS" \
2176                         compat="$WITH_CURSES_H" \
2177                         $srcdir/$cf_dir/headers >>$cf_dir/Makefile
2178         fi
2179
2180         if test -f $srcdir/$cf_dir/modules; then
2181                 if test "$cf_dir" != "c++" ; then
2182                         cat >>$cf_dir/Makefile <<"CF_EOF"
2183 depend : ${AUTO_SRC}
2184         makedepend -- ${CPPFLAGS} -- ${C_SRC}
2185
2186 # DO NOT DELETE THIS LINE -- make depend depends on it.
2187 CF_EOF
2188                 fi
2189         fi
2190 done
2191
2192 ])dnl
2193 dnl ---------------------------------------------------------------------------
2194 dnl CF_LIB_SONAME version: 3 updated: 2006/12/16 15:55:46
2195 dnl -------------
2196 dnl Find the and soname for the given shared library.  Set the cache variable
2197 dnl cf_cv_$3_soname to this, unless it is not found.  Then set the cache
2198 dnl variable to "unknown".
2199 dnl
2200 dnl $1 = headers
2201 dnl $2 = code
2202 dnl $3 = library name
2203 AC_DEFUN([CF_LIB_SONAME],
2204 [
2205 AC_CACHE_CHECK(for soname of $3 library,cf_cv_$3_soname,[
2206
2207 cf_cv_$3_soname=unknown
2208 if test "$cross_compiling" != yes ; then
2209 cat >conftest.$ac_ext <<CF_EOF
2210 $1
2211 int main()
2212 {
2213 $2
2214         ${cf_cv_main_return:-return}(0);
2215 }
2216 CF_EOF
2217 cf_save_LIBS="$LIBS"
2218         LIBS="-l$3 $LIBS"
2219         if AC_TRY_EVAL(ac_compile) ; then
2220                 if AC_TRY_EVAL(ac_link) ; then
2221                         cf_cv_$3_soname=`ldd conftest$ac_exeext 2>/dev/null | sed -e 's,^.*/,,' -e 's, .*$,,' | fgrep lib$3.`
2222                         test -z "$cf_cv_$3_soname" && cf_cv_$3_soname=unknown
2223                 fi
2224         fi
2225 rm -f conftest*
2226 LIBS="$cf_save_LIBS"
2227 fi
2228 ])
2229 ])
2230 dnl ---------------------------------------------------------------------------
2231 dnl CF_LIB_SUFFIX version: 13 updated: 2003/11/01 16:09:07
2232 dnl -------------
2233 dnl Compute the library file-suffix from the given model name
2234 dnl $1 = model name
2235 dnl $2 = variable to set
2236 dnl The variable $LIB_SUFFIX, if set, prepends the variable to set.
2237 AC_DEFUN([CF_LIB_SUFFIX],
2238 [
2239         AC_REQUIRE([CF_SUBST_NCURSES_VERSION])
2240         case $1 in
2241         libtool) $2='.la'  ;;
2242         normal)  $2='.a'   ;;
2243         debug)   $2='_g.a' ;;
2244         profile) $2='_p.a' ;;
2245         shared)
2246                 case $cf_cv_system_name in
2247                 cygwin*) $2='.dll' ;;
2248                 darwin*) $2='.dylib' ;;
2249                 hpux*)
2250                         case $target in
2251                         ia64*)  $2='.so' ;;
2252                         *)      $2='.sl' ;;
2253                         esac
2254                         ;;
2255                 *)      $2='.so'  ;;
2256                 esac
2257         esac
2258         test -n "$LIB_SUFFIX" && $2="${LIB_SUFFIX}[$]{$2}"
2259 ])dnl
2260 dnl ---------------------------------------------------------------------------
2261 dnl CF_LIB_TYPE version: 4 updated: 2000/10/20 22:57:49
2262 dnl -----------
2263 dnl Compute the string to append to -library from the given model name
2264 dnl $1 = model name
2265 dnl $2 = variable to set
2266 dnl The variable $LIB_SUFFIX, if set, prepends the variable to set.
2267 AC_DEFUN([CF_LIB_TYPE],
2268 [
2269         case $1 in
2270         libtool) $2=''   ;;
2271         normal)  $2=''   ;;
2272         debug)   $2='_g' ;;
2273         profile) $2='_p' ;;
2274         shared)  $2=''   ;;
2275         esac
2276         test -n "$LIB_SUFFIX" && $2="${LIB_SUFFIX}[$]{$2}"
2277 ])dnl
2278 dnl ---------------------------------------------------------------------------
2279 dnl CF_LINK_DATAONLY version: 8 updated: 2006/12/16 12:33:30
2280 dnl ----------------
2281 dnl Some systems have a non-ANSI linker that doesn't pull in modules that have
2282 dnl only data (i.e., no functions), for example NeXT.  On those systems we'll
2283 dnl have to provide wrappers for global tables to ensure they're linked
2284 dnl properly.
2285 AC_DEFUN([CF_LINK_DATAONLY],
2286 [
2287 AC_MSG_CHECKING([if data-only library module links])
2288 AC_CACHE_VAL(cf_cv_link_dataonly,[
2289         rm -f conftest.a
2290         cat >conftest.$ac_ext <<EOF
2291 #line __oline__ "configure"
2292 int     testdata[[3]] = { 123, 456, 789 };
2293 EOF
2294         if AC_TRY_EVAL(ac_compile) ; then
2295                 mv conftest.o data.o && \
2296                 ( $AR $AR_OPTS conftest.a data.o ) 2>&AC_FD_CC 1>/dev/null
2297         fi
2298         rm -f conftest.$ac_ext data.o
2299         cat >conftest.$ac_ext <<EOF
2300 #line __oline__ "configure"
2301 int     testfunc()
2302 {
2303 #if defined(NeXT)
2304         ${cf_cv_main_return:-return}(1);        /* I'm told this linker is broken */
2305 #else
2306         extern int testdata[[3]];
2307         return testdata[[0]] == 123
2308            &&  testdata[[1]] == 456
2309            &&  testdata[[2]] == 789;
2310 #endif
2311 }
2312 EOF
2313         if AC_TRY_EVAL(ac_compile); then
2314                 mv conftest.o func.o && \
2315                 ( $AR $AR_OPTS conftest.a func.o ) 2>&AC_FD_CC 1>/dev/null
2316         fi
2317         rm -f conftest.$ac_ext func.o
2318         ( eval $RANLIB conftest.a ) 2>&AC_FD_CC >/dev/null
2319         cf_saveLIBS="$LIBS"
2320         LIBS="conftest.a $LIBS"
2321         AC_TRY_RUN([
2322         int main()
2323         {
2324                 extern int testfunc();
2325                 ${cf_cv_main_return:-return} (!testfunc());
2326         }
2327         ],
2328         [cf_cv_link_dataonly=yes],
2329         [cf_cv_link_dataonly=no],
2330         [cf_cv_link_dataonly=unknown])
2331         LIBS="$cf_saveLIBS"
2332         ])
2333 AC_MSG_RESULT($cf_cv_link_dataonly)
2334
2335 if test "$cf_cv_link_dataonly" = no ; then
2336         AC_DEFINE(BROKEN_LINKER)
2337         BROKEN_LINKER=1
2338 fi
2339
2340 ])dnl
2341 dnl ---------------------------------------------------------------------------
2342 dnl CF_LINK_FUNCS version: 7 updated: 2006/12/16 12:33:30
2343 dnl -------------
2344 dnl Most Unix systems have both link and symlink, a few don't have symlink.
2345 dnl A few non-Unix systems implement symlink, but not link.
2346 dnl A few non-systems implement neither (or have nonfunctional versions).
2347 AC_DEFUN([CF_LINK_FUNCS],
2348 [
2349 AC_CHECK_FUNCS( \
2350         remove \
2351         unlink )
2352
2353 if test "$cross_compiling" = yes ; then
2354         AC_CHECK_FUNCS( \
2355                 link \
2356                 symlink )
2357 else
2358         AC_CACHE_CHECK(if link/symlink functions work,cf_cv_link_funcs,[
2359                 cf_cv_link_funcs=
2360                 for cf_func in link symlink ; do
2361                         AC_TRY_RUN([
2362 #include <sys/types.h>
2363 #include <sys/stat.h>
2364 #ifdef HAVE_UNISTD_H
2365 #include <unistd.h>
2366 #endif
2367 int main()
2368 {
2369         int fail = 0;
2370         char *src = "config.log";
2371         char *dst = "conftest.chk";
2372         struct stat src_sb;
2373         struct stat dst_sb;
2374
2375         stat(src, &src_sb);
2376         fail = ($cf_func("config.log", "conftest.chk") < 0)
2377             || (stat(dst, &dst_sb) < 0)
2378             || (dst_sb.st_mtime != src_sb.st_mtime);
2379 #ifdef HAVE_UNLINK
2380         unlink(dst);
2381 #else
2382         remove(dst);
2383 #endif
2384         ${cf_cv_main_return:-return} (fail);
2385 }
2386                         ],[
2387                         cf_cv_link_funcs="$cf_cv_link_funcs $cf_func"
2388                         eval 'ac_cv_func_'$cf_func'=yes'],[
2389                         eval 'ac_cv_func_'$cf_func'=no'],[
2390                         eval 'ac_cv_func_'$cf_func'=error'])
2391                 done
2392                 test -z "$cf_cv_link_funcs" && cf_cv_link_funcs=no
2393         ])
2394         test "$ac_cv_func_link"    = yes && AC_DEFINE(HAVE_LINK)
2395         test "$ac_cv_func_symlink" = yes && AC_DEFINE(HAVE_SYMLINK)
2396 fi
2397 ])dnl
2398 dnl ---------------------------------------------------------------------------
2399 dnl CF_MAIN_RETURN version: 1 updated: 2006/12/10 09:51:54
2400 dnl --------------
2401 dnl Check if a return from main to the shell actually returns the same exit
2402 dnl code.  This is true for almost any POSIX environment.
2403 dnl
2404 dnl Some very old environments did not flush stdout, etc., on an exit.  That
2405 dnl would be a useful case to test for also.
2406 AC_DEFUN([CF_MAIN_RETURN],
2407 [
2408 cf_cv_main_return=return
2409 ])dnl
2410 dnl ---------------------------------------------------------------------------
2411 dnl CF_MAKEFLAGS version: 12 updated: 2006/10/21 08:27:03
2412 dnl ------------
2413 dnl Some 'make' programs support ${MAKEFLAGS}, some ${MFLAGS}, to pass 'make'
2414 dnl options to lower-levels.  It's very useful for "make -n" -- if we have it.
2415 dnl (GNU 'make' does both, something POSIX 'make', which happens to make the
2416 dnl ${MAKEFLAGS} variable incompatible because it adds the assignments :-)
2417 AC_DEFUN([CF_MAKEFLAGS],
2418 [
2419 AC_CACHE_CHECK(for makeflags variable, cf_cv_makeflags,[
2420         cf_cv_makeflags=''
2421         for cf_option in '-${MAKEFLAGS}' '${MFLAGS}'
2422         do
2423                 cat >cf_makeflags.tmp <<CF_EOF
2424 SHELL = /bin/sh
2425 all :
2426         @ echo '.$cf_option'
2427 CF_EOF
2428                 cf_result=`${MAKE-make} -k -f cf_makeflags.tmp 2>/dev/null | sed -e 's,[[       ]]*$,,'`
2429                 case "$cf_result" in
2430                 .*k)
2431                         cf_result=`${MAKE-make} -k -f cf_makeflags.tmp CC=cc 2>/dev/null`
2432                         case "$cf_result" in
2433                         .*CC=*) cf_cv_makeflags=
2434                                 ;;
2435                         *)      cf_cv_makeflags=$cf_option
2436                                 ;;
2437                         esac
2438                         break
2439                         ;;
2440                 .-)     ;;
2441                 *)      echo "given option \"$cf_option\", no match \"$cf_result\""
2442                         ;;
2443                 esac
2444         done
2445         rm -f cf_makeflags.tmp
2446 ])
2447
2448 AC_SUBST(cf_cv_makeflags)
2449 ])dnl
2450 dnl ---------------------------------------------------------------------------
2451 dnl CF_MAKE_TAGS version: 2 updated: 2000/10/04 09:18:40
2452 dnl ------------
2453 dnl Generate tags/TAGS targets for makefiles.  Do not generate TAGS if we have
2454 dnl a monocase filesystem.
2455 AC_DEFUN([CF_MAKE_TAGS],[
2456 AC_REQUIRE([CF_MIXEDCASE_FILENAMES])
2457 AC_CHECK_PROG(MAKE_LOWER_TAGS, ctags, yes, no)
2458
2459 if test "$cf_cv_mixedcase" = yes ; then
2460         AC_CHECK_PROG(MAKE_UPPER_TAGS, etags, yes, no)
2461 else
2462         MAKE_UPPER_TAGS=no
2463 fi
2464
2465 if test "$MAKE_UPPER_TAGS" = yes ; then
2466         MAKE_UPPER_TAGS=
2467 else
2468         MAKE_UPPER_TAGS="#"
2469 fi
2470 AC_SUBST(MAKE_UPPER_TAGS)
2471
2472 if test "$MAKE_LOWER_TAGS" = yes ; then
2473         MAKE_LOWER_TAGS=
2474 else
2475         MAKE_LOWER_TAGS="#"
2476 fi
2477 AC_SUBST(MAKE_LOWER_TAGS)
2478 ])dnl
2479 dnl ---------------------------------------------------------------------------
2480 dnl CF_MANPAGE_FORMAT version: 7 updated: 2003/12/20 19:30:34
2481 dnl -----------------
2482 dnl Option to allow user to override automatic configuration of manpage format.
2483 dnl There are several special cases:
2484 dnl
2485 dnl     gzip - man checks for, can display gzip'd files
2486 dnl     compress - man checks for, can display compressed files
2487 dnl     BSDI - files in the cat-directories are suffixed ".0"
2488 dnl     formatted - installer should format (put files in cat-directory)
2489 dnl     catonly - installer should only format, e.g., for a turnkey system.
2490 dnl
2491 dnl There are other configurations which this macro does not test, e.g., HPUX's
2492 dnl compressed manpages (but uncompressed manpages are fine, and HPUX's naming
2493 dnl convention would not match our use).
2494 AC_DEFUN([CF_MANPAGE_FORMAT],
2495 [
2496 AC_REQUIRE([CF_PATHSEP])
2497 AC_MSG_CHECKING(format of man-pages)
2498
2499 AC_ARG_WITH(manpage-format,
2500         [  --with-manpage-format   specify manpage-format: gzip/compress/BSDI/normal and
2501                           optionally formatted/catonly, e.g., gzip,formatted],
2502         [MANPAGE_FORMAT=$withval],
2503         [MANPAGE_FORMAT=unknown])
2504
2505 test -z "$MANPAGE_FORMAT" && MANPAGE_FORMAT=unknown
2506 MANPAGE_FORMAT=`echo "$MANPAGE_FORMAT" | sed -e 's/,/ /g'`
2507
2508 cf_unknown=
2509
2510 case $MANPAGE_FORMAT in
2511 unknown)
2512   if test -z "$MANPATH" ; then
2513     MANPATH="/usr/man:/usr/share/man"
2514   fi
2515
2516   # look for the 'date' man-page (it's most likely to be installed!)
2517   MANPAGE_FORMAT=
2518   cf_preform=no
2519   cf_catonly=yes
2520   cf_example=date
2521
2522   IFS="${IFS=   }"; ac_save_ifs="$IFS"; IFS="${IFS}${PATHSEP}"
2523   for cf_dir in $MANPATH; do
2524     test -z "$cf_dir" && cf_dir=/usr/man
2525     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
2526     do
2527       cf_test=`echo $cf_name | sed -e 's/*//'`
2528       if test "x$cf_test" = "x$cf_name" ; then
2529
2530         case "$cf_name" in
2531         *.gz) MANPAGE_FORMAT="$MANPAGE_FORMAT gzip";;
2532         *.Z)  MANPAGE_FORMAT="$MANPAGE_FORMAT compress";;
2533         *.0)    MANPAGE_FORMAT="$MANPAGE_FORMAT BSDI";;
2534         *)    MANPAGE_FORMAT="$MANPAGE_FORMAT normal";;
2535         esac
2536
2537         case "$cf_name" in
2538         $cf_dir/man*)
2539           cf_catonly=no
2540           ;;
2541         $cf_dir/cat*)
2542           cf_preform=yes
2543           ;;
2544         esac
2545         break
2546       fi
2547
2548       # if we found a match in either man* or cat*, stop looking
2549       if test -n "$MANPAGE_FORMAT" ; then
2550         cf_found=no
2551         test "$cf_preform" = yes && MANPAGE_FORMAT="$MANPAGE_FORMAT formatted"
2552         test "$cf_catonly" = yes && MANPAGE_FORMAT="$MANPAGE_FORMAT catonly"
2553         case "$cf_name" in
2554         $cf_dir/cat*)
2555           cf_found=yes
2556           ;;
2557         esac
2558         test $cf_found=yes && break
2559       fi
2560     done
2561     # only check the first directory in $MANPATH where we find manpages
2562     if test -n "$MANPAGE_FORMAT" ; then
2563        break
2564     fi
2565   done
2566   # if we did not find the example, just assume it is normal
2567   test -z "$MANPAGE_FORMAT" && MANPAGE_FORMAT=normal
2568   IFS="$ac_save_ifs"
2569   ;;
2570 *)
2571   for cf_option in $MANPAGE_FORMAT; do
2572      case $cf_option in #(vi
2573      gzip|compress|BSDI|normal|formatted|catonly)
2574        ;;
2575      *)
2576        cf_unknown="$cf_unknown $cf_option"
2577        ;;
2578      esac
2579   done
2580   ;;
2581 esac
2582
2583 AC_MSG_RESULT($MANPAGE_FORMAT)
2584 if test -n "$cf_unknown" ; then
2585   AC_MSG_WARN(Unexpected manpage-format $cf_unknown)
2586 fi
2587 ])dnl
2588 dnl ---------------------------------------------------------------------------
2589 dnl CF_MANPAGE_RENAMES version: 7 updated: 2005/06/18 18:51:57
2590 dnl ------------------
2591 dnl The Debian people have their own naming convention for manpages.  This
2592 dnl option lets us override the name of the file containing renaming, or
2593 dnl disable it altogether.
2594 AC_DEFUN([CF_MANPAGE_RENAMES],
2595 [
2596 AC_MSG_CHECKING(for manpage renaming)
2597
2598 AC_ARG_WITH(manpage-renames,
2599         [  --with-manpage-renames  specify manpage-renaming],
2600         [MANPAGE_RENAMES=$withval],
2601         [MANPAGE_RENAMES=yes])
2602
2603 case ".$MANPAGE_RENAMES" in #(vi
2604 .no) #(vi
2605   ;;
2606 .|.yes)
2607   # Debian 'man' program?
2608   if test -f /etc/debian_version ; then
2609     MANPAGE_RENAMES=`cd $srcdir && pwd`/man/man_db.renames
2610   else
2611     MANPAGE_RENAMES=no
2612   fi
2613   ;;
2614 esac
2615
2616 if test "$MANPAGE_RENAMES" != no ; then
2617   if test -f $srcdir/man/$MANPAGE_RENAMES ; then
2618     MANPAGE_RENAMES=`cd $srcdir/man && pwd`/$MANPAGE_RENAMES
2619   elif test ! -f $MANPAGE_RENAMES ; then
2620     AC_MSG_ERROR(not a filename: $MANPAGE_RENAMES)
2621   fi
2622
2623   test ! -d man && mkdir man
2624
2625   # Construct a sed-script to perform renaming within man-pages
2626   if test -n "$MANPAGE_RENAMES" ; then
2627     test ! -d man && mkdir man
2628     sh $srcdir/man/make_sed.sh $MANPAGE_RENAMES >./edit_man.sed
2629   fi
2630 fi
2631
2632 AC_MSG_RESULT($MANPAGE_RENAMES)
2633 AC_SUBST(MANPAGE_RENAMES)
2634 ])dnl
2635 dnl ---------------------------------------------------------------------------
2636 dnl CF_MANPAGE_SYMLINKS version: 4 updated: 2003/12/13 18:01:58
2637 dnl -------------------
2638 dnl Some people expect each tool to make all aliases for manpages in the
2639 dnl man-directory.  This accommodates the older, less-capable implementations
2640 dnl of 'man', and is optional.
2641 AC_DEFUN([CF_MANPAGE_SYMLINKS],
2642 [
2643 AC_MSG_CHECKING(if manpage aliases will be installed)
2644
2645 AC_ARG_WITH(manpage-aliases,
2646         [  --with-manpage-aliases  specify manpage-aliases using .so],
2647         [MANPAGE_ALIASES=$withval],
2648         [MANPAGE_ALIASES=yes])
2649
2650 AC_MSG_RESULT($MANPAGE_ALIASES)
2651
2652 if test "$LN_S" = "ln -s"; then
2653         cf_use_symlinks=yes
2654 else
2655         cf_use_symlinks=no
2656 fi
2657
2658 MANPAGE_SYMLINKS=no
2659 if test "$MANPAGE_ALIASES" = yes ; then
2660 AC_MSG_CHECKING(if manpage symlinks should be used)
2661
2662 AC_ARG_WITH(manpage-symlinks,
2663         [  --with-manpage-symlinks specify manpage-aliases using symlinks],
2664         [MANPAGE_SYMLINKS=$withval],
2665         [MANPAGE_SYMLINKS=$cf_use_symlinks])
2666
2667 if test "$$cf_use_symlinks" = no; then
2668 if test "$MANPAGE_SYMLINKS" = yes ; then
2669         AC_MSG_WARN(cannot make symlinks, will use .so files)
2670         MANPAGE_SYMLINKS=no
2671 fi
2672 fi
2673
2674 AC_MSG_RESULT($MANPAGE_SYMLINKS)
2675 fi
2676
2677 ])dnl
2678 dnl ---------------------------------------------------------------------------
2679 dnl CF_MANPAGE_TBL version: 3 updated: 2002/01/19 22:51:32
2680 dnl --------------
2681 dnl This option causes manpages to be run through tbl(1) to generate tables
2682 dnl correctly.
2683 AC_DEFUN([CF_MANPAGE_TBL],
2684 [
2685 AC_MSG_CHECKING(for manpage tbl)
2686
2687 AC_ARG_WITH(manpage-tbl,
2688         [  --with-manpage-tbl      specify manpage processing with tbl],
2689         [MANPAGE_TBL=$withval],
2690         [MANPAGE_TBL=no])
2691
2692 AC_MSG_RESULT($MANPAGE_TBL)
2693 ])dnl
2694 dnl ---------------------------------------------------------------------------
2695 dnl CF_MAN_PAGES version: 32 updated: 2006/12/24 15:18:27
2696 dnl ------------
2697 dnl Try to determine if the man-pages on the system are compressed, and if
2698 dnl so, what format is used.  Use this information to construct a script that
2699 dnl will install man-pages.
2700 AC_DEFUN([CF_MAN_PAGES],
2701 [
2702 CF_HELP_MESSAGE(Options to Specify How Manpages are Installed:)
2703 CF_MANPAGE_FORMAT
2704 CF_MANPAGE_RENAMES
2705 CF_MANPAGE_SYMLINKS
2706 CF_MANPAGE_TBL
2707
2708   if test "$prefix" = "NONE" ; then
2709      cf_prefix="$ac_default_prefix"
2710   else
2711      cf_prefix="$prefix"
2712   fi
2713
2714   case "$MANPAGE_FORMAT" in # (vi
2715   *catonly*) # (vi
2716     cf_format=yes
2717     cf_inboth=no
2718     ;;
2719   *formatted*) # (vi
2720     cf_format=yes
2721     cf_inboth=yes
2722     ;;
2723   *)
2724     cf_format=no
2725     cf_inboth=no
2726     ;;
2727   esac
2728
2729 test ! -d man && mkdir man
2730
2731 cf_so_strip=
2732 cf_compress=
2733 case "$MANPAGE_FORMAT" in #(vi
2734 *compress*) #(vi
2735         cf_so_strip="Z"
2736         cf_compress=compress
2737   ;;
2738 *gzip*) #(vi
2739         cf_so_strip="gz"
2740         cf_compress=gzip
2741   ;;
2742 esac
2743
2744 cf_edit_man=./edit_man.sh
2745 cf_man_alias=`pwd`/man_alias.sed
2746
2747 cat >$cf_edit_man <<CF_EOF
2748 #! /bin/sh
2749 # this script is generated by the configure-script CF_MAN_PAGES macro.
2750
2751 prefix="$cf_prefix"
2752 datadir="$datadir"
2753
2754 NCURSES_MAJOR="$NCURSES_MAJOR"
2755 NCURSES_MINOR="$NCURSES_MINOR"
2756 NCURSES_PATCH="$NCURSES_PATCH"
2757
2758 NCURSES_OSPEED="$NCURSES_OSPEED"
2759 TERMINFO="$TERMINFO"
2760
2761 MKDIRS="sh `cd $srcdir && pwd`/mkinstalldirs"
2762
2763 INSTALL="$INSTALL"
2764 INSTALL_DATA="$INSTALL_DATA"
2765
2766 transform="$program_transform_name"
2767
2768 TMP=\${TMPDIR-/tmp}/man\$\$
2769 trap "rm -f \$TMP" 0 1 2 5 15
2770
2771 form=\[$]1
2772 shift || exit 1
2773
2774 verb=\[$]1
2775 shift || exit 1
2776
2777 mandir=\[$]1
2778 shift || exit 1
2779
2780 srcdir=\[$]1
2781 top_srcdir=\[$]srcdir/..
2782 shift || exit 1
2783
2784 if test "\$form" = normal ; then
2785         if test "$cf_format" = yes ; then
2786         if test "$cf_inboth" = no ; then
2787                 sh \[$]0 format \$verb \$mandir \$srcdir \[$]*
2788                 exit $?
2789         fi
2790         fi
2791         cf_subdir=\$mandir/man
2792         cf_tables=$MANPAGE_TBL
2793 else
2794         cf_subdir=\$mandir/cat
2795         cf_tables=yes
2796 fi
2797
2798 # process the list of source-files
2799 for i in \[$]* ; do
2800 case \$i in #(vi
2801 *.orig|*.rej) ;; #(vi
2802 *.[[0-9]]*)
2803         section=\`expr "\$i" : '.*\\.\\([[0-9]]\\)[[xm]]*'\`;
2804         if test \$verb = installing ; then
2805         if test ! -d \$cf_subdir\${section} ; then
2806                 \$MKDIRS \$cf_subdir\$section
2807         fi
2808         fi
2809
2810         # replace variables in man page
2811         if test ! -f $cf_man_alias ; then
2812 cat >>$cf_man_alias <<-CF_EOF2
2813                 s,@DATADIR@,\$datadir,
2814                 s,@TERMINFO@,\$TERMINFO,
2815                 s,@NCURSES_MAJOR@,\$NCURSES_MAJOR,
2816                 s,@NCURSES_MINOR@,\$NCURSES_MINOR,
2817                 s,@NCURSES_PATCH@,\$NCURSES_PATCH,
2818                 s,@NCURSES_OSPEED@,\$NCURSES_OSPEED,
2819 CF_EOF
2820         ifelse($1,,,[
2821         for cf_name in $1
2822         do
2823                 cf_NAME=`echo "$cf_name" | sed y%abcdefghijklmnopqrstuvwxyz./-%ABCDEFGHIJKLMNOPQRSTUVWXYZ___%`
2824                 cf_name=`echo $cf_name|sed "$program_transform_name"`
2825 cat >>$cf_edit_man <<-CF_EOF
2826                 s,@$cf_NAME@,$cf_name,
2827 CF_EOF
2828         done
2829         ])
2830 cat >>$cf_edit_man <<CF_EOF
2831 CF_EOF2
2832                 echo "...made $cf_man_alias"
2833         fi
2834
2835         aliases=
2836         cf_source=\`basename \$i\`
2837         inalias=\$cf_source
2838         test ! -f \$inalias && inalias="\$srcdir/\$inalias"
2839         if test ! -f \$inalias ; then
2840                 echo .. skipped \$cf_source
2841                 continue
2842         fi
2843 CF_EOF
2844
2845 if test "$MANPAGE_ALIASES" != no ; then
2846 cat >>$cf_edit_man <<CF_EOF
2847         aliases=\`sed -f \$top_srcdir/man/manlinks.sed \$inalias |sed -f $cf_man_alias | sort -u\`
2848 CF_EOF
2849 fi
2850
2851 if test "$MANPAGE_RENAMES" = no ; then
2852 cat >>$cf_edit_man <<CF_EOF
2853         # perform program transformations for section 1 man pages
2854         if test \$section = 1 ; then
2855                 cf_target=\$cf_subdir\${section}/\`echo \$cf_source|sed "\${transform}"\`
2856         else
2857                 cf_target=\$cf_subdir\${section}/\$cf_source
2858         fi
2859 CF_EOF
2860 else
2861 cat >>$cf_edit_man <<CF_EOF
2862         cf_target=\`grep "^\$cf_source" $MANPAGE_RENAMES | $AWK '{print \[$]2}'\`
2863         if test -z "\$cf_target" ; then
2864                 echo '? missing rename for '\$cf_source
2865                 cf_target="\$cf_source"
2866         fi
2867         cf_target="\$cf_subdir\${section}/\${cf_target}"
2868
2869 CF_EOF
2870 fi
2871
2872 cat >>$cf_edit_man <<CF_EOF
2873         sed     -f $cf_man_alias \\
2874 CF_EOF
2875
2876 if test -f $MANPAGE_RENAMES ; then
2877 cat >>$cf_edit_man <<CF_EOF
2878                 < \$i | sed -f `pwd`/edit_man.sed >\$TMP
2879 CF_EOF
2880 else
2881 cat >>$cf_edit_man <<CF_EOF
2882                 < \$i >\$TMP
2883 CF_EOF
2884 fi
2885
2886 cat >>$cf_edit_man <<CF_EOF
2887 if test \$cf_tables = yes ; then
2888         tbl \$TMP >\$TMP.out
2889         mv \$TMP.out \$TMP
2890 fi
2891 CF_EOF
2892
2893 if test $with_curses_h != yes ; then
2894 cat >>$cf_edit_man <<CF_EOF
2895         sed -e "/\#[    ]*include/s,curses.h,ncurses.h," < \$TMP >\$TMP.out
2896         mv \$TMP.out \$TMP
2897 CF_EOF
2898 fi
2899
2900 cat >>$cf_edit_man <<CF_EOF
2901         if test \$form = format ; then
2902                 nroff -man \$TMP >\$TMP.out
2903                 mv \$TMP.out \$TMP
2904         fi
2905 CF_EOF
2906
2907 if test -n "$cf_compress" ; then
2908 cat >>$cf_edit_man <<CF_EOF
2909         if test \$verb = installing ; then
2910         if ( $cf_compress -f \$TMP )
2911         then
2912                 mv \$TMP.$cf_so_strip \$TMP
2913         fi
2914         fi
2915         cf_target="\$cf_target.$cf_so_strip"
2916 CF_EOF
2917 fi
2918
2919 case "$MANPAGE_FORMAT" in #(vi
2920 *BSDI*)
2921 cat >>$cf_edit_man <<CF_EOF
2922         if test \$form = format ; then
2923                 # BSDI installs only .0 suffixes in the cat directories
2924                 cf_target="\`echo \$cf_target|sed -e 's/\.[[1-9]]\+[[a-z]]*/.0/'\`"
2925         fi
2926 CF_EOF
2927   ;;
2928 esac
2929
2930 cat >>$cf_edit_man <<CF_EOF
2931         suffix=\`basename \$cf_target | sed -e 's%^[[^.]]*%%'\`
2932         if test \$verb = installing ; then
2933                 echo \$verb \$cf_target
2934                 \$INSTALL_DATA \$TMP \$cf_target
2935                 test -n "\$aliases" && (
2936                         cd \$cf_subdir\${section} && (
2937                                 cf_source=\`echo \$cf_target |sed -e 's%^.*/\([[^/]][[^/]]*/[[^/]][[^/]]*$\)%\1%'\`
2938                                 test -n "$cf_so_strip" && cf_source=\`echo \$cf_source |sed -e 's%\.$cf_so_strip\$%%'\`
2939                                 cf_target=\`basename \$cf_target\`
2940                                 for cf_alias in \$aliases
2941                                 do
2942                                         if test \$section = 1 ; then
2943                                                 cf_alias=\`echo \$cf_alias|sed "\${transform}"\`
2944                                         fi
2945
2946                                         if test "$MANPAGE_SYMLINKS" = yes ; then
2947                                                 if test -f \$cf_alias\${suffix} ; then
2948                                                         if ( cmp -s \$cf_target \$cf_alias\${suffix} )
2949                                                         then
2950                                                                 continue
2951                                                         fi
2952                                                 fi
2953                                                 echo .. \$verb alias \$cf_alias\${suffix}
2954                                                 rm -f \$cf_alias\${suffix}
2955                                                 $LN_S \$cf_target \$cf_alias\${suffix}
2956                                         elif test "\$cf_target" != "\$cf_alias\${suffix}" ; then
2957                                                 echo ".so \$cf_source" >\$TMP
2958 CF_EOF
2959 if test -n "$cf_compress" ; then
2960 cat >>$cf_edit_man <<CF_EOF
2961                                                 if test -n "$cf_so_strip" ; then
2962                                                         $cf_compress -f \$TMP
2963                                                         mv \$TMP.$cf_so_strip \$TMP
2964                                                 fi
2965 CF_EOF
2966 fi
2967 cat >>$cf_edit_man <<CF_EOF
2968                                                 echo .. \$verb alias \$cf_alias\${suffix}
2969                                                 rm -f \$cf_alias\${suffix}
2970                                                 \$INSTALL_DATA \$TMP \$cf_alias\${suffix}
2971                                         fi
2972                                 done
2973                         )
2974                 )
2975         elif test \$verb = removing ; then
2976                 echo \$verb \$cf_target
2977                 rm -f \$cf_target
2978                 test -n "\$aliases" && (
2979                         cd \$cf_subdir\${section} && (
2980                                 for cf_alias in \$aliases
2981                                 do
2982                                         if test \$section = 1 ; then
2983                                                 cf_alias=\`echo \$cf_alias|sed "\${transform}"\`
2984                                         fi
2985
2986                                         echo .. \$verb alias \$cf_alias\${suffix}
2987                                         rm -f \$cf_alias\${suffix}
2988                                 done
2989                         )
2990                 )
2991         else
2992 #               echo ".hy 0"
2993                 cat \$TMP
2994         fi
2995         ;;
2996 esac
2997 done
2998
2999 if test $cf_inboth = yes ; then
3000 if test \$form != format ; then
3001         sh \[$]0 format \$verb \$mandir \$srcdir \[$]*
3002 fi
3003 fi
3004
3005 exit 0
3006 CF_EOF
3007 chmod 755 $cf_edit_man
3008
3009 ])dnl
3010 dnl ---------------------------------------------------------------------------
3011 dnl CF_MATH_LIB version: 5 updated: 2000/05/28 01:39:10
3012 dnl -----------
3013 dnl Checks for libraries.  At least one UNIX system, Apple Macintosh
3014 dnl Rhapsody 5.5, does not have -lm.  We cannot use the simpler
3015 dnl AC_CHECK_LIB(m,sin), because that fails for C++.
3016 AC_DEFUN([CF_MATH_LIB],
3017 [
3018 AC_CACHE_CHECK(if -lm needed for math functions,
3019         cf_cv_need_libm,[
3020         AC_TRY_LINK([
3021         #include <stdio.h>
3022         #include <math.h>
3023         ],
3024         [double x = rand(); printf("result = %g\n", ]ifelse($2,,sin(x),$2)[)],
3025         [cf_cv_need_libm=no],
3026         [cf_cv_need_libm=yes])])
3027 if test "$cf_cv_need_libm" = yes
3028 then
3029 ifelse($1,,[
3030         LIBS="$LIBS -lm"
3031 ],[$1=-lm])
3032 fi
3033 ])
3034 dnl ---------------------------------------------------------------------------
3035 dnl CF_MIXEDCASE_FILENAMES version: 3 updated: 2003/09/20 17:07:55
3036 dnl ----------------------
3037 dnl Check if the file-system supports mixed-case filenames.  If we're able to
3038 dnl create a lowercase name and see it as uppercase, it doesn't support that.
3039 AC_DEFUN([CF_MIXEDCASE_FILENAMES],
3040 [
3041 AC_CACHE_CHECK(if filesystem supports mixed-case filenames,cf_cv_mixedcase,[
3042 if test "$cross_compiling" = yes ; then
3043         case $target_alias in #(vi
3044         *-os2-emx*|*-msdosdjgpp*|*-cygwin*|*-mingw32*|*-uwin*) #(vi
3045                 cf_cv_mixedcase=no
3046                 ;;
3047         *)
3048                 cf_cv_mixedcase=yes
3049                 ;;
3050         esac
3051 else
3052         rm -f conftest CONFTEST
3053         echo test >conftest
3054         if test -f CONFTEST ; then
3055                 cf_cv_mixedcase=no
3056         else
3057                 cf_cv_mixedcase=yes
3058         fi
3059         rm -f conftest CONFTEST
3060 fi
3061 ])
3062 test "$cf_cv_mixedcase" = yes && AC_DEFINE(MIXEDCASE_FILENAMES)
3063 ])dnl
3064 dnl ---------------------------------------------------------------------------
3065 dnl CF_MKSTEMP version: 5 updated: 2006/12/16 12:33:30
3066 dnl ----------
3067 dnl Check for a working mkstemp.  This creates two files, checks that they are
3068 dnl successfully created and distinct (AmigaOS apparently fails on the last).
3069 AC_DEFUN([CF_MKSTEMP],[
3070 AC_CACHE_CHECK(for working mkstemp, cf_cv_func_mkstemp,[
3071 rm -f conftest*
3072 AC_TRY_RUN([
3073 #include <sys/types.h>
3074 #include <stdlib.h>
3075 #include <stdio.h>
3076 #include <string.h>
3077 #include <sys/stat.h>
3078 int main()
3079 {
3080         char *tmpl = "conftestXXXXXX";
3081         char name[2][80];
3082         int n;
3083         int result = 0;
3084         int fd;
3085         struct stat sb;
3086
3087         umask(077);
3088         for (n = 0; n < 2; ++n) {
3089                 strcpy(name[n], tmpl);
3090                 if ((fd = mkstemp(name[n])) >= 0) {
3091                         if (!strcmp(name[n], tmpl)
3092                          || stat(name[n], &sb) != 0
3093                          || (sb.st_mode & S_IFMT) != S_IFREG
3094                          || (sb.st_mode & 077) != 0) {
3095                                 result = 1;
3096                         }
3097                         close(fd);
3098                 }
3099         }
3100         if (result == 0
3101          && !strcmp(name[0], name[1]))
3102                 result = 1;
3103         ${cf_cv_main_return:-return}(result);
3104 }
3105 ],[cf_cv_func_mkstemp=yes
3106 ],[cf_cv_func_mkstemp=no
3107 ],[AC_CHECK_FUNC(mkstemp)
3108 ])
3109 ])
3110 if test "$cf_cv_func_mkstemp" = yes ; then
3111         AC_DEFINE(HAVE_MKSTEMP)
3112 fi
3113 ])dnl
3114 dnl ---------------------------------------------------------------------------
3115 dnl CF_MSG_LOG version: 3 updated: 1997/09/07 14:05:52
3116 dnl ----------
3117 dnl Write a debug message to config.log, along with the line number in the
3118 dnl configure script.
3119 AC_DEFUN([CF_MSG_LOG],[
3120 echo "(line __oline__) testing $* ..." 1>&AC_FD_CC
3121 ])dnl
3122 dnl ---------------------------------------------------------------------------
3123 dnl CF_NCURSES_ABI_6 version: 1 updated: 2005/09/17 18:42:49
3124 dnl ----------------
3125 dnl Set ncurses' ABI to 6 unless overridden by explicit configure option, and
3126 dnl warn about this.
3127 AC_DEFUN([CF_NCURSES_ABI_6],[
3128 if test "${with_abi_version+set}" != set; then
3129         case $cf_cv_rel_version in
3130         5.*)
3131                 cf_cv_rel_version=6.0
3132                 cf_cv_abi_version=6
3133                 AC_MSG_WARN(Overriding ABI version to $cf_cv_abi_version)
3134                 ;;
3135         esac
3136 fi
3137 ])dnl
3138 dnl ---------------------------------------------------------------------------
3139 dnl CF_NO_LEAKS_OPTION version: 4 updated: 2006/12/16 14:24:05
3140 dnl ------------------
3141 dnl see CF_WITH_NO_LEAKS
3142 AC_DEFUN([CF_NO_LEAKS_OPTION],[
3143 AC_MSG_CHECKING(if you want to use $1 for testing)
3144 AC_ARG_WITH($1,
3145         [$2],
3146         [AC_DEFINE($3)ifelse([$4],,[
3147          $4
3148 ])
3149         : ${with_cflags:=-g}
3150         : ${with_no_leaks:=yes}
3151          with_$1=yes],
3152         [with_$1=])
3153 AC_MSG_RESULT(${with_$1:-no})
3154
3155 case .$with_cflags in #(vi
3156 .*-g*)
3157         case .$CFLAGS in #(vi
3158         .*-g*) #(vi
3159                 ;;
3160         *)
3161                 CF_ADD_CFLAGS([-g])
3162                 ;;
3163         esac
3164         ;;
3165 esac
3166 ])dnl
3167 dnl ---------------------------------------------------------------------------
3168 dnl CF_NUMBER_SYNTAX version: 1 updated: 2003/09/20 18:12:49
3169 dnl ----------------
3170 dnl Check if the given variable is a number.  If not, report an error.
3171 dnl $1 is the variable
3172 dnl $2 is the message
3173 AC_DEFUN([CF_NUMBER_SYNTAX],[
3174 if test -n "$1" ; then
3175   case $1 in #(vi
3176   [[0-9]]*) #(vi
3177         ;;
3178   *)
3179         AC_MSG_ERROR($2 is not a number: $1)
3180         ;;
3181   esac
3182 else
3183   AC_MSG_ERROR($2 value is empty)
3184 fi
3185 ])dnl
3186 dnl ---------------------------------------------------------------------------
3187 dnl CF_OBJ_SUBDIR version: 4 updated: 2002/02/23 20:38:31
3188 dnl -------------
3189 dnl Compute the object-directory name from the given model name
3190 AC_DEFUN([CF_OBJ_SUBDIR],
3191 [
3192         case $1 in
3193         libtool) $2='obj_lo'  ;;
3194         normal)  $2='objects' ;;
3195         debug)   $2='obj_g' ;;
3196         profile) $2='obj_p' ;;
3197         shared)
3198                 case $cf_cv_system_name in #(vi
3199                 cygwin) #(vi
3200                         $2='objects' ;;
3201                 *)
3202                         $2='obj_s' ;;
3203                 esac
3204         esac
3205 ])dnl
3206 dnl ---------------------------------------------------------------------------
3207 dnl CF_PATHSEP version: 3 updated: 2001/01/12 01:23:53
3208 dnl ----------
3209 dnl Provide a value for the $PATH and similar separator
3210 AC_DEFUN([CF_PATHSEP],
3211 [
3212         case $cf_cv_system_name in
3213         os2*)   PATHSEP=';'  ;;
3214         *)      PATHSEP=':'  ;;
3215         esac
3216 ifelse($1,,,[$1=$PATHSEP])
3217         AC_SUBST(PATHSEP)
3218 ])dnl
3219 dnl ---------------------------------------------------------------------------
3220 dnl CF_PATH_SYNTAX version: 11 updated: 2006/09/02 08:55:46
3221 dnl --------------
3222 dnl Check the argument to see that it looks like a pathname.  Rewrite it if it
3223 dnl begins with one of the prefix/exec_prefix variables, and then again if the
3224 dnl result begins with 'NONE'.  This is necessary to work around autoconf's
3225 dnl delayed evaluation of those symbols.
3226 AC_DEFUN([CF_PATH_SYNTAX],[
3227 if test "x$prefix" != xNONE; then
3228   cf_path_syntax="$prefix"
3229 else
3230   cf_path_syntax="$ac_default_prefix"
3231 fi
3232
3233 case ".[$]$1" in #(vi
3234 .\[$]\(*\)*|.\'*\'*) #(vi
3235   ;;
3236 ..|./*|.\\*) #(vi
3237   ;;
3238 .[[a-zA-Z]]:[[\\/]]*) #(vi OS/2 EMX
3239   ;;
3240 .\[$]{*prefix}*) #(vi
3241   eval $1="[$]$1"
3242   case ".[$]$1" in #(vi
3243   .NONE/*)
3244     $1=`echo [$]$1 | sed -e s%NONE%$cf_path_syntax%`
3245     ;;
3246   esac
3247   ;; #(vi
3248 .no|.NONE/*)
3249   $1=`echo [$]$1 | sed -e s%NONE%$cf_path_syntax%`
3250   ;;
3251 *)
3252   ifelse($2,,[AC_ERROR([expected a pathname, not \"[$]$1\"])],$2)
3253   ;;
3254 esac
3255 ])dnl
3256 dnl ---------------------------------------------------------------------------
3257 dnl CF_POSIX_C_SOURCE version: 6 updated: 2005/07/14 20:25:10
3258 dnl -----------------
3259 dnl Define _POSIX_C_SOURCE to the given level, and _POSIX_SOURCE if needed.
3260 dnl
3261 dnl     POSIX.1-1990                            _POSIX_SOURCE
3262 dnl     POSIX.1-1990 and                        _POSIX_SOURCE and
3263 dnl             POSIX.2-1992 C-Language                 _POSIX_C_SOURCE=2
3264 dnl             Bindings Option
3265 dnl     POSIX.1b-1993                           _POSIX_C_SOURCE=199309L
3266 dnl     POSIX.1c-1996                           _POSIX_C_SOURCE=199506L
3267 dnl     X/Open 2000                             _POSIX_C_SOURCE=200112L
3268 dnl
3269 dnl Parameters:
3270 dnl     $1 is the nominal value for _POSIX_C_SOURCE
3271 AC_DEFUN([CF_POSIX_C_SOURCE],
3272 [
3273 cf_POSIX_C_SOURCE=ifelse($1,,199506L,$1)
3274
3275 cf_save_CFLAGS="$CFLAGS"
3276 cf_save_CPPFLAGS="$CPPFLAGS"
3277
3278 CF_REMOVE_DEFINE(cf_trim_CFLAGS,$cf_save_CFLAGS,_POSIX_C_SOURCE)
3279 CF_REMOVE_DEFINE(cf_trim_CPPFLAGS,$cf_save_CPPFLAGS,_POSIX_C_SOURCE)
3280
3281 AC_CACHE_CHECK(if we should define _POSIX_C_SOURCE,cf_cv_posix_c_source,[
3282         CF_MSG_LOG(if the symbol is already defined go no further)
3283         AC_TRY_COMPILE([#include <sys/types.h>],[
3284 #ifndef _POSIX_C_SOURCE
3285 make an error
3286 #endif],
3287         [cf_cv_posix_c_source=no],
3288         [cf_want_posix_source=no
3289          case .$cf_POSIX_C_SOURCE in #(vi
3290          .[[12]]??*) #(vi
3291                 cf_cv_posix_c_source="-D_POSIX_C_SOURCE=$cf_POSIX_C_SOURCE"
3292                 ;;
3293          .2) #(vi
3294                 cf_cv_posix_c_source="-D_POSIX_C_SOURCE=$cf_POSIX_C_SOURCE"
3295                 cf_want_posix_source=yes
3296                 ;;
3297          .*)
3298                 cf_want_posix_source=yes
3299                 ;;
3300          esac
3301          if test "$cf_want_posix_source" = yes ; then
3302                 AC_TRY_COMPILE([#include <sys/types.h>],[
3303 #ifdef _POSIX_SOURCE
3304 make an error
3305 #endif],[],
3306                 cf_cv_posix_c_source="$cf_cv_posix_c_source -D_POSIX_SOURCE")
3307          fi
3308          CF_MSG_LOG(ifdef from value $cf_POSIX_C_SOURCE)
3309          CFLAGS="$cf_trim_CFLAGS"
3310          CPPFLAGS="$cf_trim_CPPFLAGS $cf_cv_posix_c_source"
3311          CF_MSG_LOG(if the second compile does not leave our definition intact error)
3312          AC_TRY_COMPILE([#include <sys/types.h>],[
3313 #ifndef _POSIX_C_SOURCE
3314 make an error
3315 #endif],,
3316          [cf_cv_posix_c_source=no])
3317          CFLAGS="$cf_save_CFLAGS"
3318          CPPFLAGS="$cf_save_CPPFLAGS"
3319         ])
3320 ])
3321
3322 if test "$cf_cv_posix_c_source" != no ; then
3323         CFLAGS="$cf_trim_CFLAGS"
3324         CPPFLAGS="$cf_trim_CPPFLAGS"
3325         if test "$cf_cv_cc_u_d_options" = yes ; then
3326                 cf_temp_posix_c_source=`echo "$cf_cv_posix_c_source" | \
3327                                 sed -e 's/-D/-U/g' -e 's/=[[^   ]]*//g'`
3328                 CPPFLAGS="$CPPFLAGS $cf_temp_posix_c_source"
3329         fi
3330         CPPFLAGS="$CPPFLAGS $cf_cv_posix_c_source"
3331 fi
3332
3333 ])dnl
3334 dnl ---------------------------------------------------------------------------
3335 dnl CF_PREDEFINE version: 1 updated: 2003/07/26 17:53:56
3336 dnl ------------
3337 dnl Add definitions to CPPFLAGS to ensure they're predefined for all compiles.
3338 dnl
3339 dnl $1 = symbol to test
3340 dnl $2 = value (if any) to use for a predefinition
3341 AC_DEFUN([CF_PREDEFINE],
3342 [
3343 AC_MSG_CHECKING(if we must define $1)
3344 AC_TRY_COMPILE([#include <sys/types.h>
3345 ],[
3346 #ifndef $1
3347 make an error
3348 #endif],[cf_result=no],[cf_result=yes])
3349 AC_MSG_RESULT($cf_result)
3350
3351 if test "$cf_result" = yes ; then
3352         CPPFLAGS="$CPPFLAGS ifelse($2,,-D$1,[-D$1=$2])"
3353 elif test "x$2" != "x" ; then
3354         AC_MSG_CHECKING(checking for compatible value versus $2)
3355         AC_TRY_COMPILE([#include <sys/types.h>
3356 ],[
3357 #if $1-$2 < 0
3358 make an error
3359 #endif],[cf_result=yes],[cf_result=no])
3360         AC_MSG_RESULT($cf_result)
3361         if test "$cf_result" = no ; then
3362                 # perhaps we can override it - try...
3363                 CPPFLAGS="$CPPFLAGS -D$1=$2"
3364         fi
3365 fi
3366 ])dnl
3367 dnl ---------------------------------------------------------------------------
3368 dnl CF_PRG_RULES version: 1 updated: 2006/06/03 11:45:08
3369 dnl ------------
3370 dnl Append definitions and rules for the given programs to the subdirectory
3371 dnl Makefiles, and the recursion rule for the top-level Makefile.
3372 dnl
3373 dnl parameters
3374 dnl     $1 = script to run
3375 dnl     $2 = list of subdirectories
3376 dnl
3377 dnl variables
3378 dnl     $AWK
3379 AC_DEFUN([CF_PRG_RULES],
3380 [
3381 for cf_dir in $2
3382 do
3383         if test ! -d $srcdir/$cf_dir; then
3384                 continue
3385         elif test -f $srcdir/$cf_dir/programs; then
3386                 $AWK -f $1 $srcdir/$cf_dir/programs >>$cf_dir/Makefile
3387         fi
3388 done
3389
3390 ])dnl
3391 dnl ---------------------------------------------------------------------------
3392 dnl CF_PROG_AWK version: 1 updated: 2006/09/16 11:40:59
3393 dnl -----------
3394 dnl Check for awk, ensure that the check found something.
3395 AC_DEFUN([CF_PROG_AWK],
3396 [
3397 AC_PROG_AWK
3398 test -z "$AWK" && AC_MSG_ERROR(No awk program found)
3399 ])dnl
3400 dnl ---------------------------------------------------------------------------
3401 dnl CF_PROG_CC_C_O version: 2 updated: 2006/12/16 15:55:46
3402 dnl --------------
3403 dnl Analogous to AC_PROG_CC_C_O, but more useful: tests only $CC, ensures that
3404 dnl the output file can be renamed, and allows for a shell variable that can
3405 dnl be used later.  The parameter is either CC or CXX.  The result is the
3406 dnl cache variable:
3407 dnl     $cf_cv_prog_CC_c_o
3408 dnl     $cf_cv_prog_CXX_c_o
3409 AC_DEFUN([CF_PROG_CC_C_O],
3410 [AC_REQUIRE([AC_PROG_CC])dnl
3411 AC_MSG_CHECKING([whether [$]$1 understands -c and -o together])
3412 AC_CACHE_VAL(cf_cv_prog_$1_c_o,
3413 [
3414 cat > conftest.$ac_ext <<CF_EOF
3415 #include <stdio.h>
3416 int main()
3417 {
3418         ${cf_cv_main_return:-return}(0);
3419 }
3420 CF_EOF
3421 # We do the test twice because some compilers refuse to overwrite an
3422 # existing .o file with -o, though they will create one.
3423 ac_try='[$]$1 -c conftest.$ac_ext -o conftest2.$ac_objext >&AC_FD_CC'
3424 if AC_TRY_EVAL(ac_try) &&
3425   test -f conftest2.$ac_objext && AC_TRY_EVAL(ac_try);
3426 then
3427   eval cf_cv_prog_$1_c_o=yes
3428 else
3429   eval cf_cv_prog_$1_c_o=no
3430 fi
3431 rm -f conftest*
3432 ])dnl
3433 if test $cf_cv_prog_$1_c_o = yes; then
3434   AC_MSG_RESULT([yes])
3435 else
3436   AC_MSG_RESULT([no])
3437 fi
3438 ])dnl
3439 dnl ---------------------------------------------------------------------------
3440 dnl CF_PROG_CC_U_D version: 1 updated: 2005/07/14 16:59:30
3441 dnl --------------
3442 dnl Check if C (preprocessor) -U and -D options are processed in the order
3443 dnl given rather than by type of option.  Some compilers insist on apply all
3444 dnl of the -U options after all of the -D options.  Others allow mixing them,
3445 dnl and may predefine symbols that conflict with those we define.
3446 AC_DEFUN([CF_PROG_CC_U_D],
3447 [
3448 AC_CACHE_CHECK(if $CC -U and -D options work together,cf_cv_cc_u_d_options,[
3449         cf_save_CPPFLAGS="$CPPFLAGS"
3450         CPPFLAGS="-UU_D_OPTIONS -DU_D_OPTIONS -DD_U_OPTIONS -UD_U_OPTIONS"
3451         AC_TRY_COMPILE([],[
3452 #ifndef U_D_OPTIONS
3453 make an undefined-error
3454 #endif
3455 #ifdef  D_U_OPTIONS
3456 make a defined-error
3457 #endif
3458         ],[
3459         cf_cv_cc_u_d_options=yes],[
3460         cf_cv_cc_u_d_options=no])
3461         CPPFLAGS="$cf_save_CPPFLAGS"
3462 ])
3463 ])dnl
3464 dnl ---------------------------------------------------------------------------
3465 dnl CF_PROG_EGREP version: 1 updated: 2006/09/16 11:40:59
3466 dnl -------------
3467 dnl AC_PROG_EGREP was introduced in autoconf 2.53.
3468 dnl This macro adds a check to ensure the script found something.
3469 AC_DEFUN([CF_PROG_EGREP],
3470 [AC_CACHE_CHECK([for egrep], [ac_cv_prog_egrep],
3471    [if echo a | (grep -E '(a|b)') >/dev/null 2>&1
3472     then ac_cv_prog_egrep='grep -E'
3473     else ac_cv_prog_egrep='egrep'
3474     fi])
3475  EGREP=$ac_cv_prog_egrep
3476  AC_SUBST([EGREP])
3477 test -z "$EGREP" && AC_MSG_ERROR(No egrep program found)
3478 ])dnl
3479 dnl ---------------------------------------------------------------------------
3480 dnl CF_PROG_EXT version: 10 updated: 2004/01/03 19:28:18
3481 dnl -----------
3482 dnl Compute $PROG_EXT, used for non-Unix ports, such as OS/2 EMX.
3483 AC_DEFUN([CF_PROG_EXT],
3484 [
3485 AC_REQUIRE([CF_CHECK_CACHE])
3486 case $cf_cv_system_name in
3487 os2*)
3488     CFLAGS="$CFLAGS -Zmt"
3489     CPPFLAGS="$CPPFLAGS -D__ST_MT_ERRNO__"
3490     CXXFLAGS="$CXXFLAGS -Zmt"
3491     # autoconf's macro sets -Zexe and suffix both, which conflict:w
3492     LDFLAGS="$LDFLAGS -Zmt -Zcrtdll"
3493     ac_cv_exeext=.exe
3494     ;;
3495 esac
3496
3497 AC_EXEEXT
3498 AC_OBJEXT
3499
3500 PROG_EXT="$EXEEXT"
3501 AC_SUBST(PROG_EXT)
3502 test -n "$PROG_EXT" && AC_DEFINE_UNQUOTED(PROG_EXT,"$PROG_EXT")
3503 ])dnl
3504 dnl ---------------------------------------------------------------------------
3505 dnl CF_PROG_INSTALL version: 5 updated: 2002/12/21 22:46:07
3506 dnl ---------------
3507 dnl Force $INSTALL to be an absolute-path.  Otherwise, edit_man.sh and the
3508 dnl misc/tabset install won't work properly.  Usually this happens only when
3509 dnl using the fallback mkinstalldirs script
3510 AC_DEFUN([CF_PROG_INSTALL],
3511 [AC_PROG_INSTALL
3512 case $INSTALL in
3513 /*)
3514   ;;
3515 *)
3516   CF_DIRNAME(cf_dir,$INSTALL)
3517   test -z "$cf_dir" && cf_dir=.
3518   INSTALL=`cd $cf_dir && pwd`/`echo $INSTALL | sed -e 's%^.*/%%'`
3519   ;;
3520 esac
3521 ])dnl
3522 dnl ---------------------------------------------------------------------------
3523 dnl CF_PROG_LDCONFIG version: 1 updated: 2003/09/20 17:07:55
3524 dnl ----------------
3525 dnl Check for ldconfig, needed to fixup shared libraries that would be built
3526 dnl and then used in the install.
3527 AC_DEFUN([CF_PROG_LDCONFIG],[
3528 if test "$cross_compiling" = yes ; then
3529   LDCONFIG=:
3530 else
3531 case "$cf_cv_system_name" in #(vi
3532 freebsd*) #(vi
3533   test -z "$LDCONFIG" && LDCONFIG="/sbin/ldconfig -R"
3534   ;;
3535 *) LDPATH=$PATH:/sbin:/usr/sbin
3536   AC_PATH_PROG(LDCONFIG,ldconfig,,$LDPATH)
3537   ;;
3538 esac
3539 fi
3540 AC_SUBST(LDCONFIG)
3541 ])dnl
3542 dnl ---------------------------------------------------------------------------
3543 dnl CF_PROG_LINT version: 1 updated: 2006/09/16 11:40:59
3544 dnl ------------
3545 AC_DEFUN([CF_PROG_LINT],
3546 [
3547 AC_CHECK_PROGS(LINT, tdlint lint alint)
3548 AC_SUBST(LINT_OPTS)
3549 ])dnl
3550 dnl ---------------------------------------------------------------------------
3551 dnl CF_REGEX version: 3 updated: 1997/11/01 14:26:01
3552 dnl --------
3553 dnl Attempt to determine if we've got one of the flavors of regular-expression
3554 dnl code that we can support.
3555 AC_DEFUN([CF_REGEX],
3556 [
3557 AC_MSG_CHECKING([for regular-expression headers])
3558 AC_CACHE_VAL(cf_cv_regex,[
3559 AC_TRY_LINK([#include <sys/types.h>
3560 #include <regex.h>],[
3561         regex_t *p;
3562         int x = regcomp(p, "", 0);
3563         int y = regexec(p, "", 0, 0, 0);
3564         regfree(p);
3565         ],[cf_cv_regex="regex.h"],[
3566         AC_TRY_LINK([#include <regexp.h>],[
3567                 char *p = compile("", "", "", 0);
3568                 int x = step("", "");
3569         ],[cf_cv_regex="regexp.h"],[
3570                 cf_save_LIBS="$LIBS"
3571                 LIBS="-lgen $LIBS"
3572                 AC_TRY_LINK([#include <regexpr.h>],[
3573                         char *p = compile("", "", "");
3574                         int x = step("", "");
3575                 ],[cf_cv_regex="regexpr.h"],[LIBS="$cf_save_LIBS"])])])
3576 ])
3577 AC_MSG_RESULT($cf_cv_regex)
3578 case $cf_cv_regex in
3579         regex.h)   AC_DEFINE(HAVE_REGEX_H_FUNCS) ;;
3580         regexp.h)  AC_DEFINE(HAVE_REGEXP_H_FUNCS) ;;
3581         regexpr.h) AC_DEFINE(HAVE_REGEXPR_H_FUNCS) ;;
3582 esac
3583 ])dnl
3584 dnl ---------------------------------------------------------------------------
3585 dnl CF_REMOVE_DEFINE version: 2 updated: 2005/07/09 16:12:18
3586 dnl ----------------
3587 dnl Remove all -U and -D options that refer to the given symbol from a list
3588 dnl of C compiler options.  This works around the problem that not all
3589 dnl compilers process -U and -D options from left-to-right, so a -U option
3590 dnl cannot be used to cancel the effect of a preceding -D option.
3591 dnl
3592 dnl $1 = target (which could be the same as the source variable)
3593 dnl $2 = source (including '$')
3594 dnl $3 = symbol to remove
3595 define([CF_REMOVE_DEFINE],
3596 [
3597 # remove $3 symbol from $2
3598 $1=`echo "$2" | \
3599         sed     -e 's/-[[UD]]$3\(=[[^   ]]*\)\?[[       ]]/ /g' \
3600                 -e 's/-[[UD]]$3\(=[[^   ]]*\)\?[$]//g'`
3601 ])dnl
3602 dnl ---------------------------------------------------------------------------
3603 dnl CF_SHARED_OPTS version: 42 updated: 2006/12/23 18:04:51
3604 dnl --------------
3605 dnl --------------
3606 dnl Attempt to determine the appropriate CC/LD options for creating a shared
3607 dnl library.
3608 dnl
3609 dnl Note: ${LOCAL_LDFLAGS} is used to link executables that will run within the
3610 dnl build-tree, i.e., by making use of the libraries that are compiled in ../lib
3611 dnl We avoid compiling-in a ../lib path for the shared library since that can
3612 dnl lead to unexpected results at runtime.
3613 dnl ${LOCAL_LDFLAGS2} has the same intention but assumes that the shared libraries
3614 dnl are compiled in ../../lib
3615 dnl
3616 dnl The variable 'cf_cv_do_symlinks' is used to control whether we configure
3617 dnl to install symbolic links to the rel/abi versions of shared libraries.
3618 dnl
3619 dnl The variable 'cf_cv_shlib_version' controls whether we use the rel or abi
3620 dnl version when making symbolic links.
3621 dnl
3622 dnl The variable 'cf_cv_shlib_version_infix' controls whether shared library
3623 dnl version numbers are infix (ex: libncurses.<ver>.dylib) or postfix
3624 dnl (ex: libncurses.so.<ver>).
3625 dnl
3626 dnl Some loaders leave 'so_locations' lying around.  It's nice to clean up.
3627 AC_DEFUN([CF_SHARED_OPTS],
3628 [
3629         AC_REQUIRE([CF_SUBST_NCURSES_VERSION])
3630         LOCAL_LDFLAGS=
3631         LOCAL_LDFLAGS2=
3632         LD_SHARED_OPTS=
3633         INSTALL_LIB="-m 644"
3634
3635         cf_cv_do_symlinks=no
3636
3637         AC_MSG_CHECKING(if release/abi version should be used for shared libs)
3638         AC_ARG_WITH(shlib-version,
3639         [  --with-shlib-version=X  Specify rel or abi version for shared libs],
3640         [test -z "$withval" && withval=auto
3641         case $withval in #(vi
3642         yes) #(vi
3643                 cf_cv_shlib_version=auto
3644                 ;;
3645         rel|abi|auto|no) #(vi
3646                 cf_cv_shlib_version=$withval
3647                 ;;
3648         *)
3649                 AC_ERROR([option value must be one of: rel, abi, auto or no])
3650                 ;;
3651         esac
3652         ],[cf_cv_shlib_version=auto])
3653         AC_MSG_RESULT($cf_cv_shlib_version)
3654
3655         cf_cv_rm_so_locs=no
3656
3657         # Some less-capable ports of gcc support only -fpic
3658         CC_SHARED_OPTS=
3659         if test "$GCC" = yes
3660         then
3661                 AC_MSG_CHECKING(which $CC option to use)
3662                 cf_save_CFLAGS="$CFLAGS"
3663                 for CC_SHARED_OPTS in -fPIC -fpic ''
3664                 do
3665                         CFLAGS="$cf_save_CFLAGS $CC_SHARED_OPTS"
3666                         AC_TRY_COMPILE([#include <stdio.h>],[int x = 1],[break],[])
3667                 done
3668                 AC_MSG_RESULT($CC_SHARED_OPTS)
3669                 CFLAGS="$cf_save_CFLAGS"
3670         fi
3671
3672         cf_cv_shlib_version_infix=no
3673
3674         case $cf_cv_system_name in
3675         beos*)
3676                 MK_SHARED_LIB='${CC} ${CFLAGS} -o $[@] -Xlinker -soname=`basename $[@]` -nostart -e 0'
3677                 ;;
3678         cygwin*)
3679                 CC_SHARED_OPTS=
3680                 MK_SHARED_LIB='${CC} ${CFLAGS} -shared -Wl,--out-implib=../lib/${IMPORT_LIB} -Wl,--export-all-symbols -o ../lib/${SHARED_LIB}'
3681                 cf_cv_shlib_version=cygdll
3682                 cf_cv_shlib_version_infix=cygdll
3683                 ;;
3684         darwin*)
3685                 EXTRA_CFLAGS="-no-cpp-precomp"
3686                 CC_SHARED_OPTS="-dynamic"
3687                 MK_SHARED_LIB='${CC} ${CFLAGS} -dynamiclib -install_name ${DESTDIR}${libdir}/`basename $[@]` -compatibility_version ${ABI_VERSION} -current_version ${ABI_VERSION} -o $[@]'
3688                 test "$cf_cv_shlib_version" = auto && cf_cv_shlib_version=abi
3689                 cf_cv_shlib_version_infix=yes
3690                 AC_CACHE_CHECK([if ld -search_paths_first works], cf_cv_ldflags_search_paths_first, [
3691                         cf_save_LDFLAGS=$LDFLAGS
3692                         LDFLAGS="$LDFLAGS -Wl,-search_paths_first"
3693                         AC_TRY_LINK(, [int i;], cf_cv_ldflags_search_paths_first=yes, cf_cv_ldflags_search_paths_first=no)
3694                                 LDFLAGS=$cf_save_LDFLAGS])
3695                 if test $cf_cv_ldflags_search_paths_first = yes; then
3696                         LDFLAGS="$LDFLAGS -Wl,-search_paths_first"
3697                 fi
3698                 ;;
3699         hpux*)
3700                 # (tested with gcc 2.7.2 -- I don't have c89)
3701                 if test "$GCC" = yes; then
3702                         LD_SHARED_OPTS='-Xlinker +b -Xlinker ${libdir}'
3703                 else
3704                         CC_SHARED_OPTS='+Z'
3705                         LD_SHARED_OPTS='-Wl,+b,${libdir}'
3706                 fi
3707                 MK_SHARED_LIB='${LD} +b ${libdir} -b -o $[@]'
3708                 # HP-UX shared libraries must be executable, and should be
3709                 # readonly to exploit a quirk in the memory manager.
3710                 INSTALL_LIB="-m 555"
3711                 ;;
3712         irix*)
3713                 if test "$cf_cv_ld_rpath" = yes ; then
3714                         if test "$GCC" = yes; then
3715                                 cf_ld_rpath_opt="-Wl,-rpath,"
3716                                 EXTRA_LDFLAGS="-Wl,-rpath,\${libdir} $EXTRA_LDFLAGS"
3717                         else
3718                                 cf_ld_rpath_opt="-rpath "
3719                                 EXTRA_LDFLAGS="-rpath \${libdir} $EXTRA_LDFLAGS"
3720                         fi
3721                 fi
3722                 # tested with IRIX 5.2 and 'cc'.
3723                 if test "$GCC" != yes; then
3724                         CC_SHARED_OPTS='-KPIC'
3725                 fi
3726                 MK_SHARED_LIB='${CC} -shared -rdata_shared -soname `basename $[@]` -o $[@]'
3727                 cf_cv_rm_so_locs=yes
3728                 ;;
3729         linux*|gnu*|k*bsd*-gnu)
3730                 if test "$DFT_LWR_MODEL" = "shared" ; then
3731                         LOCAL_LDFLAGS="-Wl,-rpath,\$(LOCAL_LIBDIR)"
3732                         LOCAL_LDFLAGS2="$LOCAL_LDFLAGS"
3733                 fi
3734                 if test "$cf_cv_ld_rpath" = yes ; then
3735                         cf_ld_rpath_opt="-Wl,-rpath,"
3736                         EXTRA_LDFLAGS="-Wl,-rpath,\${libdir} $EXTRA_LDFLAGS"
3737                 fi
3738                 CF_SHARED_SONAME
3739                 MK_SHARED_LIB='${CC} ${CFLAGS} -shared -Wl,-soname,'$cf_shared_soname',-stats,-lc -o $[@]'
3740                 ;;
3741         openbsd[[2-9]].*)
3742                 CC_SHARED_OPTS="$CC_SHARED_OPTS -DPIC"
3743                 MK_SHARED_LIB='${LD} -Bshareable -soname,`basename $[@].${ABI_VERSION}` -o $[@]'
3744                 ;;
3745         openbsd*|freebsd[[12]].*)
3746                 CC_SHARED_OPTS="$CC_SHARED_OPTS -DPIC"
3747                 MK_SHARED_LIB='${LD} -Bshareable -o $[@]'
3748                 test "$cf_cv_shlib_version" = auto && cf_cv_shlib_version=rel
3749                 ;;
3750         freebsd*)
3751                 CC_SHARED_OPTS="$CC_SHARED_OPTS -DPIC"
3752                 if test "$DFT_LWR_MODEL" = "shared" && test "$cf_cv_ld_rpath" = yes ; then
3753                         LOCAL_LDFLAGS="-rpath \$(LOCAL_LIBDIR)"
3754                         LOCAL_LDFLAGS2="-rpath \${libdir} $LOCAL_LDFLAGS"
3755                         cf_ld_rpath_opt="-rpath "
3756                         EXTRA_LDFLAGS="-rpath \${libdir} $EXTRA_LDFLAGS"
3757                 fi
3758                 CF_SHARED_SONAME
3759                 MK_SHARED_LIB='${LD} -Bshareable -soname=`basename $[@]` -o $[@]'
3760                 ;;
3761         netbsd*)
3762                 CC_SHARED_OPTS="$CC_SHARED_OPTS -DPIC"
3763                 test "$cf_cv_ld_rpath" = yes && cf_ld_rpath_opt="-Wl,-rpath,"
3764                 if test "$DFT_LWR_MODEL" = "shared" && test "$cf_cv_ld_rpath" = yes ; then
3765                         LOCAL_LDFLAGS="-Wl,-rpath,\$(LOCAL_LIBDIR)"
3766                         LOCAL_LDFLAGS2="$LOCAL_LDFLAGS"
3767                         EXTRA_LDFLAGS="-Wl,-rpath,\${libdir} $EXTRA_LDFLAGS"
3768                         if test "$cf_cv_shlib_version" = auto; then
3769                         if test -f /usr/libexec/ld.elf_so; then
3770                                 cf_cv_shlib_version=abi
3771                         else
3772                                 cf_cv_shlib_version=rel
3773                         fi
3774                         fi
3775                         CF_SHARED_SONAME
3776                         MK_SHARED_LIB='${CC} ${CFLAGS} -shared -Wl,-soname,'$cf_shared_soname' -o $[@]'
3777                 else
3778                         MK_SHARED_LIB='${LD} -Bshareable -o $[@]'
3779                 fi
3780         &nb