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