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