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