ncurses 5.7 - patch 20100327
[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.499 2010/03/28 00:14:25 tom Exp $
32 dnl Macros used in NCURSES auto-configuration script.
33 dnl
34 dnl These macros are maintained separately from NCURSES.  The copyright on
35 dnl this file applies to the aggregation of macros and does not affect use of
36 dnl these macros in other applications.
37 dnl
38 dnl See http://invisible-island.net/autoconf/ for additional information.
39 dnl
40 dnl ---------------------------------------------------------------------------
41 dnl ---------------------------------------------------------------------------
42 dnl AM_LANGINFO_CODESET version: 3 updated: 2002/10/27 23:21:42
43 dnl -------------------
44 dnl Inserted as requested by gettext 0.10.40
45 dnl File from /usr/share/aclocal
46 dnl codeset.m4
47 dnl ====================
48 dnl serial AM1
49 dnl
50 dnl From Bruno Haible.
51 AC_DEFUN([AM_LANGINFO_CODESET],
52 [
53   AC_CACHE_CHECK([for nl_langinfo and CODESET], am_cv_langinfo_codeset,
54     [AC_TRY_LINK([#include <langinfo.h>],
55       [char* cs = nl_langinfo(CODESET);],
56       am_cv_langinfo_codeset=yes,
57       am_cv_langinfo_codeset=no)
58     ])
59   if test $am_cv_langinfo_codeset = yes; then
60     AC_DEFINE(HAVE_LANGINFO_CODESET, 1,
61       [Define if you have <langinfo.h> and nl_langinfo(CODESET).])
62   fi
63 ])dnl
64 dnl ---------------------------------------------------------------------------
65 dnl CF_ADA_INCLUDE_DIRS version: 6 updated: 2010/02/26 19:52:07
66 dnl -------------------
67 dnl Construct the list of include-options for the C programs in the Ada95
68 dnl binding.
69 AC_DEFUN([CF_ADA_INCLUDE_DIRS],
70 [
71 ACPPFLAGS="-I. -I../include -I../../include $ACPPFLAGS"
72 if test "$srcdir" != "."; then
73         ACPPFLAGS="-I\${srcdir}/../../include $ACPPFLAGS"
74 fi
75 if test "$GCC" != yes; then
76         ACPPFLAGS="$ACPPFLAGS -I\${includedir}"
77 elif test "$includedir" != "/usr/include"; then
78         if test "$includedir" = '${prefix}/include' ; then
79                 if test $prefix != /usr ; then
80                         ACPPFLAGS="$ACPPFLAGS -I\${includedir}"
81                 fi
82         else
83                 ACPPFLAGS="$ACPPFLAGS -I\${includedir}"
84         fi
85 fi
86 AC_SUBST(ACPPFLAGS)
87 ])dnl
88 dnl ---------------------------------------------------------------------------
89 dnl CF_ADD_CFLAGS version: 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: 5 updated: 2010/03/13 15:14:55
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         [if test "x$enableval" = xno; then with_no_leaks=yes; else with_no_leaks=no; fi],
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: 2 updated: 2010/03/27 18:39:42
1011 dnl ---------------
1012 dnl Check if the rpath option should be used, setting cache variable
1013 dnl cf_cv_enable_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_enable_rpath=$enableval],
1020 [cf_cv_enable_rpath=no])
1021 AC_MSG_RESULT($cf_cv_enable_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: 14 updated: 2010/03/21 14:34:38
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 ],[
1094
1095 cf_save_LIBS="$LIBS"
1096 LIBS="-l$3 $7 $cf_save_LIBS"
1097
1098 AC_TRY_LINK([$1],[$2],[
1099         cf_cv_find_linkage_$3=yes
1100 ],[
1101     cf_cv_find_linkage_$3=no
1102         LIBS="$cf_save_LIBS"
1103
1104     CF_VERBOSE(find linkage for $3 library)
1105     CF_MSG_LOG([Searching for headers in [FIND_LINKAGE]($3,$6)])
1106
1107     cf_save_CPPFLAGS="$CPPFLAGS"
1108     cf_test_CPPFLAGS="$CPPFLAGS"
1109
1110     CF_HEADER_PATH(cf_search,ifelse([$6],,[$3],[$6]))
1111     for cf_cv_header_path_$3 in $cf_search
1112     do
1113       if test -d $cf_cv_header_path_$3 ; then
1114         CF_VERBOSE(... testing $cf_cv_header_path_$3)
1115         CPPFLAGS="$cf_save_CPPFLAGS -I$cf_cv_header_path_$3"
1116         AC_TRY_COMPILE([$1],[$2],[
1117             CF_VERBOSE(... found $3 headers in $cf_cv_header_path_$3)
1118             cf_cv_find_linkage_$3=maybe
1119             cf_test_CPPFLAGS="$CPPFLAGS"
1120             break],[
1121             CPPFLAGS="$cf_save_CPPFLAGS"
1122             ])
1123       fi
1124     done
1125
1126     if test "$cf_cv_find_linkage_$3" = maybe ; then
1127
1128       CF_MSG_LOG([Searching for $3 library in [FIND_LINKAGE]($3,$6)])
1129
1130       cf_save_LIBS="$LIBS"
1131       cf_save_LDFLAGS="$LDFLAGS"
1132
1133       ifelse([$6],,,[
1134         CPPFLAGS="$cf_test_CPPFLAGS"
1135         LIBS="-l$3 $7 $cf_save_LIBS"
1136         AC_TRY_LINK([$1],[$2],[
1137             CF_VERBOSE(... found $3 library in system)
1138             cf_cv_find_linkage_$3=yes])
1139             CPPFLAGS="$cf_save_CPPFLAGS"
1140             LIBS="$cf_save_LIBS"
1141             ])
1142
1143       if test "$cf_cv_find_linkage_$3" != yes ; then
1144         CF_LIBRARY_PATH(cf_search,$3)
1145         for cf_cv_library_path_$3 in $cf_search
1146         do
1147           if test -d $cf_cv_library_path_$3 ; then
1148             CF_VERBOSE(... testing $cf_cv_library_path_$3)
1149             CPPFLAGS="$cf_test_CPPFLAGS"
1150             LIBS="-l$3 $7 $cf_save_LIBS"
1151             LDFLAGS="$cf_save_LDFLAGS -L$cf_cv_library_path_$3"
1152             AC_TRY_LINK([$1],[$2],[
1153                 CF_VERBOSE(... found $3 library in $cf_cv_library_path_$3)
1154                 cf_cv_find_linkage_$3=yes
1155                 cf_cv_library_file_$3="-l$3"
1156                 break],[
1157                 CPPFLAGS="$cf_save_CPPFLAGS"
1158                 LIBS="$cf_save_LIBS"
1159                 LDFLAGS="$cf_save_LDFLAGS"
1160                 ])
1161           fi
1162         done
1163         LIBS="$cf_save_LIBS"
1164         CPPFLAGS="$cf_save_CPPFLAGS"
1165         LDFLAGS="$cf_save_LDFLAGS"
1166       fi
1167
1168     else
1169       cf_cv_find_linkage_$3=no
1170     fi
1171     ],$7)
1172 ])
1173
1174 if test "$cf_cv_find_linkage_$3" = yes ; then
1175 ifelse([$4],,[
1176   CF_ADD_INCDIR($cf_cv_header_path_$3)
1177   CF_ADD_LIBDIR($cf_cv_library_path_$3)
1178   LIBS="-l$3 $LIBS"
1179 ],[$4])
1180 else
1181 ifelse([$5],,AC_MSG_WARN(Cannot find $3 library),[$5])
1182 fi
1183 ])dnl
1184 dnl ---------------------------------------------------------------------------
1185 dnl CF_FUNC_DLSYM version: 1 updated: 2004/06/16 20:52:45
1186 dnl -------------
1187 dnl Test for dlsym() and related functions, as well as libdl.
1188 dnl
1189 dnl Sets
1190 dnl     $cf_have_dlsym
1191 dnl     $cf_have_libdl
1192 AC_DEFUN([CF_FUNC_DLSYM],[
1193 cf_have_dlsym=no
1194 AC_CHECK_FUNC(dlsym,cf_have_dlsym=yes,[
1195
1196 cf_have_libdl=no
1197 AC_CHECK_LIB(dl,dlsym,[
1198         cf_have_dlsym=yes
1199         cf_have_libdl=yes])])
1200
1201 if test "$cf_have_dlsym" = yes ; then
1202         test "$cf_have_libdl" = yes && LIBS="-ldl $LIBS"
1203
1204         AC_MSG_CHECKING(whether able to link to dl*() functions)
1205         AC_TRY_LINK([#include <dlfcn.h>],[
1206                 void *obj;
1207                 if ((obj = dlopen("filename", 0)) != 0) {
1208                         if (dlsym(obj, "symbolname") == 0) {
1209                         dlclose(obj);
1210                         }
1211                 }],[
1212                 AC_DEFINE(HAVE_LIBDL)],[
1213                 AC_MSG_ERROR(Cannot link test program for libdl)])
1214         AC_MSG_RESULT(ok)
1215 else
1216         AC_MSG_ERROR(Cannot find dlsym function)
1217 fi
1218 ])
1219 dnl ---------------------------------------------------------------------------
1220 dnl CF_FUNC_MEMMOVE version: 7 updated: 2006/12/16 12:33:30
1221 dnl ---------------
1222 dnl Check for memmove, or a bcopy that can handle overlapping copy.  If neither
1223 dnl is found, add our own version of memmove to the list of objects.
1224 AC_DEFUN([CF_FUNC_MEMMOVE],
1225 [
1226 AC_CHECK_FUNC(memmove,,[
1227 AC_CHECK_FUNC(bcopy,[
1228         AC_CACHE_CHECK(if bcopy does overlapping moves,cf_cv_good_bcopy,[
1229                 AC_TRY_RUN([
1230 int main() {
1231         static char data[] = "abcdefghijklmnopqrstuwwxyz";
1232         char temp[40];
1233         bcopy(data, temp, sizeof(data));
1234         bcopy(temp+10, temp, 15);
1235         bcopy(temp+5, temp+15, 10);
1236         ${cf_cv_main_return:-return} (strcmp(temp, "klmnopqrstuwwxypqrstuwwxyz"));
1237 }
1238                 ],
1239                 [cf_cv_good_bcopy=yes],
1240                 [cf_cv_good_bcopy=no],
1241                 [cf_cv_good_bcopy=unknown])
1242                 ])
1243         ],[cf_cv_good_bcopy=no])
1244         if test "$cf_cv_good_bcopy" = yes ; then
1245                 AC_DEFINE(USE_OK_BCOPY)
1246         else
1247                 AC_DEFINE(USE_MY_MEMMOVE)
1248         fi
1249 ])])dnl
1250 dnl ---------------------------------------------------------------------------
1251 dnl CF_FUNC_NANOSLEEP version: 3 updated: 2006/12/16 12:33:30
1252 dnl -----------------
1253 dnl Check for existence of workable nanosleep() function.  Some systems, e.g.,
1254 dnl AIX 4.x, provide a non-working version.
1255 AC_DEFUN([CF_FUNC_NANOSLEEP],[
1256 AC_CACHE_CHECK(if nanosleep really works,cf_cv_func_nanosleep,[
1257 AC_TRY_RUN([
1258 #include <stdio.h>
1259 #include <errno.h>
1260 #include <time.h>
1261
1262 #ifdef HAVE_SYS_TIME_H
1263 #include <sys/time.h>
1264 #endif
1265
1266 int main() {
1267         struct timespec ts1, ts2;
1268         int code;
1269         ts1.tv_sec  = 0;
1270         ts1.tv_nsec = 750000000;
1271         ts2.tv_sec  = 0;
1272         ts2.tv_nsec = 0;
1273         errno = 0;
1274         code = nanosleep(&ts1, &ts2); /* on failure errno is ENOSYS. */
1275         ${cf_cv_main_return:-return}(code != 0);
1276 }
1277 ],
1278         [cf_cv_func_nanosleep=yes],
1279         [cf_cv_func_nanosleep=no],
1280         [cf_cv_func_nanosleep=unknown])])
1281
1282 test "$cf_cv_func_nanosleep" = "yes" && AC_DEFINE(HAVE_NANOSLEEP)
1283 ])
1284 dnl ---------------------------------------------------------------------------
1285 dnl CF_FUNC_OPENPTY version: 2 updated: 2008/04/12 19:49:01
1286 dnl ---------------
1287 dnl Check for openpty() function, along with <pty.h> header.  It may need the
1288 dnl "util" library as well.
1289 AC_DEFUN([CF_FUNC_OPENPTY],
1290 [
1291 AC_CHECK_LIB(util,openpty,cf_cv_lib_util=yes,cf_cv_lib_util=no)
1292 AC_CACHE_CHECK(for openpty header,cf_cv_func_openpty,[
1293     cf_save_LIBS="$LIBS"
1294     test $cf_cv_lib_util = yes && LIBS="-lutil $LIBS"
1295     for cf_header in pty.h libutil.h util.h
1296     do
1297     AC_TRY_LINK([
1298 #include <$cf_header>
1299 ],[
1300     int x = openpty((int *)0, (int *)0, (char *)0,
1301                    (struct termios *)0, (struct winsize *)0);
1302 ],[
1303         cf_cv_func_openpty=$cf_header
1304         break
1305 ],[
1306         cf_cv_func_openpty=no
1307 ])
1308     done
1309     LIBS="$cf_save_LIBS"
1310 ])
1311 ])dnl
1312 dnl ---------------------------------------------------------------------------
1313 dnl CF_FUNC_POLL version: 4 updated: 2006/12/16 12:33:30
1314 dnl ------------
1315 dnl See if the poll function really works.  Some platforms have poll(), but
1316 dnl it does not work for terminals or files.
1317 AC_DEFUN([CF_FUNC_POLL],[
1318 AC_CACHE_CHECK(if poll really works,cf_cv_working_poll,[
1319 AC_TRY_RUN([
1320 #include <stdio.h>
1321 #ifdef HAVE_POLL_H
1322 #include <poll.h>
1323 #else
1324 #include <sys/poll.h>
1325 #endif
1326 int main() {
1327         struct pollfd myfds;
1328         int ret;
1329
1330         myfds.fd = 0;
1331         myfds.events = POLLIN;
1332
1333         ret = poll(&myfds, 1, 100);
1334         ${cf_cv_main_return:-return}(ret != 0);
1335 }],
1336         [cf_cv_working_poll=yes],
1337         [cf_cv_working_poll=no],
1338         [cf_cv_working_poll=unknown])])
1339 test "$cf_cv_working_poll" = "yes" && AC_DEFINE(HAVE_WORKING_POLL)
1340 ])dnl
1341 dnl ---------------------------------------------------------------------------
1342 dnl CF_FUNC_TERMIOS version: 2 updated: 2000/07/22 23:37:24
1343 dnl ---------------
1344 dnl Some old/broken variations define tcgetattr() only as a macro in
1345 dnl termio(s).h
1346 AC_DEFUN([CF_FUNC_TERMIOS],[
1347 AC_REQUIRE([CF_STRUCT_TERMIOS])
1348 AC_CACHE_CHECK(for tcgetattr, cf_cv_have_tcgetattr,[
1349 AC_TRY_LINK([
1350 #include <sys/types.h>
1351 #ifdef HAVE_UNISTD_H
1352 #include <unistd.h>
1353 #endif
1354 #ifdef HAVE_TERMIOS_H
1355 #include <termios.h>
1356 #define TTY struct termios
1357 #else
1358 #ifdef HAVE_TERMIO_H
1359 #include <termio.h>
1360 #define TTY struct termio
1361 #endif
1362 #endif
1363 ],[
1364 TTY foo;
1365 tcgetattr(1, &foo);],
1366 [cf_cv_have_tcgetattr=yes],
1367 [cf_cv_have_tcgetattr=no])])
1368 test "$cf_cv_have_tcgetattr" = yes && AC_DEFINE(HAVE_TCGETATTR)
1369 ])dnl
1370 dnl ---------------------------------------------------------------------------
1371 dnl CF_FUNC_VSSCANF version: 3 updated: 2001/12/19 00:50:10
1372 dnl ---------------
1373 dnl Check for vsscanf() function, which is in c9x but generally not in earlier
1374 dnl versions of C.  It is in the GNU C library, and can often be simulated by
1375 dnl other functions.
1376 AC_DEFUN([CF_FUNC_VSSCANF],
1377 [
1378 AC_CACHE_CHECK(for vsscanf function or workaround,cf_cv_func_vsscanf,[
1379 AC_TRY_LINK([
1380 #include <stdarg.h>
1381 #include <stdio.h>],[
1382         va_list ap;
1383         vsscanf("from", "%d", ap)],[cf_cv_func_vsscanf=vsscanf],[
1384 AC_TRY_LINK([
1385 #include <stdarg.h>
1386 #include <stdio.h>],[
1387     FILE strbuf;
1388     char *str = "from";
1389
1390     strbuf._flag = _IOREAD;
1391     strbuf._ptr = strbuf._base = (unsigned char *) str;
1392     strbuf._cnt = strlen(str);
1393     strbuf._file = _NFILE;
1394     return (vfscanf(&strbuf, "%d", ap))],[cf_cv_func_vsscanf=vfscanf],[
1395 AC_TRY_LINK([
1396 #include <stdarg.h>
1397 #include <stdio.h>],[
1398     FILE strbuf;
1399     char *str = "from";
1400
1401     strbuf._flag = _IOREAD;
1402     strbuf._ptr = strbuf._base = (unsigned char *) str;
1403     strbuf._cnt = strlen(str);
1404     strbuf._file = _NFILE;
1405     return (_doscan(&strbuf, "%d", ap))],[cf_cv_func_vsscanf=_doscan],[
1406 cf_cv_func_vsscanf=no])])])])
1407
1408 case $cf_cv_func_vsscanf in #(vi
1409 vsscanf) AC_DEFINE(HAVE_VSSCANF);; #(vi
1410 vfscanf) AC_DEFINE(HAVE_VFSCANF);; #(vi
1411 _doscan) AC_DEFINE(HAVE__DOSCAN);;
1412 esac
1413
1414 ])dnl
1415 dnl ---------------------------------------------------------------------------
1416 dnl CF_GCC_ATTRIBUTES version: 13 updated: 2009/08/11 20:19:56
1417 dnl -----------------
1418 dnl Test for availability of useful gcc __attribute__ directives to quiet
1419 dnl compiler warnings.  Though useful, not all are supported -- and contrary
1420 dnl to documentation, unrecognized directives cause older compilers to barf.
1421 AC_DEFUN([CF_GCC_ATTRIBUTES],
1422 [
1423 if test "$GCC" = yes
1424 then
1425 cat > conftest.i <<EOF
1426 #ifndef GCC_PRINTF
1427 #define GCC_PRINTF 0
1428 #endif
1429 #ifndef GCC_SCANF
1430 #define GCC_SCANF 0
1431 #endif
1432 #ifndef GCC_NORETURN
1433 #define GCC_NORETURN /* nothing */
1434 #endif
1435 #ifndef GCC_UNUSED
1436 #define GCC_UNUSED /* nothing */
1437 #endif
1438 EOF
1439 if test "$GCC" = yes
1440 then
1441         AC_CHECKING([for $CC __attribute__ directives])
1442 cat > conftest.$ac_ext <<EOF
1443 #line __oline__ "${as_me-configure}"
1444 #include "confdefs.h"
1445 #include "conftest.h"
1446 #include "conftest.i"
1447 #if     GCC_PRINTF
1448 #define GCC_PRINTFLIKE(fmt,var) __attribute__((format(printf,fmt,var)))
1449 #else
1450 #define GCC_PRINTFLIKE(fmt,var) /*nothing*/
1451 #endif
1452 #if     GCC_SCANF
1453 #define GCC_SCANFLIKE(fmt,var)  __attribute__((format(scanf,fmt,var)))
1454 #else
1455 #define GCC_SCANFLIKE(fmt,var)  /*nothing*/
1456 #endif
1457 extern void wow(char *,...) GCC_SCANFLIKE(1,2);
1458 extern void oops(char *,...) GCC_PRINTFLIKE(1,2) GCC_NORETURN;
1459 extern void foo(void) GCC_NORETURN;
1460 int main(int argc GCC_UNUSED, char *argv[[]] GCC_UNUSED) { return 0; }
1461 EOF
1462         cf_printf_attribute=no
1463         cf_scanf_attribute=no
1464         for cf_attribute in scanf printf unused noreturn
1465         do
1466                 CF_UPPER(cf_ATTRIBUTE,$cf_attribute)
1467                 cf_directive="__attribute__(($cf_attribute))"
1468                 echo "checking for $CC $cf_directive" 1>&AC_FD_CC
1469
1470                 case $cf_attribute in #(vi
1471                 printf) #(vi
1472                         cf_printf_attribute=yes
1473                         cat >conftest.h <<EOF
1474 #define GCC_$cf_ATTRIBUTE 1
1475 EOF
1476                         ;;
1477                 scanf) #(vi
1478                         cf_scanf_attribute=yes
1479                         cat >conftest.h <<EOF
1480 #define GCC_$cf_ATTRIBUTE 1
1481 EOF
1482                         ;;
1483                 *) #(vi
1484                         cat >conftest.h <<EOF
1485 #define GCC_$cf_ATTRIBUTE $cf_directive
1486 EOF
1487                         ;;
1488                 esac
1489
1490                 if AC_TRY_EVAL(ac_compile); then
1491                         test -n "$verbose" && AC_MSG_RESULT(... $cf_attribute)
1492                         cat conftest.h >>confdefs.h
1493                         case $cf_attribute in #(vi
1494                         printf) #(vi
1495                                 if test "$cf_printf_attribute" = no ; then
1496                                         cat >>confdefs.h <<EOF
1497 #define GCC_PRINTFLIKE(fmt,var) /* nothing */
1498 EOF
1499                                 else
1500                                         cat >>confdefs.h <<EOF
1501 #define GCC_PRINTFLIKE(fmt,var) __attribute__((format(printf,fmt,var)))
1502 EOF
1503                                 fi
1504                                 ;;
1505                         scanf) #(vi
1506                                 if test "$cf_scanf_attribute" = no ; then
1507                                         cat >>confdefs.h <<EOF
1508 #define GCC_SCANFLIKE(fmt,var) /* nothing */
1509 EOF
1510                                 else
1511                                         cat >>confdefs.h <<EOF
1512 #define GCC_SCANFLIKE(fmt,var)  __attribute__((format(scanf,fmt,var)))
1513 EOF
1514                                 fi
1515                                 ;;
1516                         esac
1517                 fi
1518         done
1519 else
1520         fgrep define conftest.i >>confdefs.h
1521 fi
1522 rm -rf conftest*
1523 fi
1524 ])dnl
1525 dnl ---------------------------------------------------------------------------
1526 dnl CF_GCC_VERSION version: 4 updated: 2005/08/27 09:53:42
1527 dnl --------------
1528 dnl Find version of gcc
1529 AC_DEFUN([CF_GCC_VERSION],[
1530 AC_REQUIRE([AC_PROG_CC])
1531 GCC_VERSION=none
1532 if test "$GCC" = yes ; then
1533         AC_MSG_CHECKING(version of $CC)
1534         GCC_VERSION="`${CC} --version| sed -e '2,$d' -e 's/^.*(GCC) //' -e 's/^[[^0-9.]]*//' -e 's/[[^0-9.]].*//'`"
1535         test -z "$GCC_VERSION" && GCC_VERSION=unknown
1536         AC_MSG_RESULT($GCC_VERSION)
1537 fi
1538 ])dnl
1539 dnl ---------------------------------------------------------------------------
1540 dnl CF_GCC_WARNINGS version: 24 updated: 2009/02/01 15:21:00
1541 dnl ---------------
1542 dnl Check if the compiler supports useful warning options.  There's a few that
1543 dnl we don't use, simply because they're too noisy:
1544 dnl
1545 dnl     -Wconversion (useful in older versions of gcc, but not in gcc 2.7.x)
1546 dnl     -Wredundant-decls (system headers make this too noisy)
1547 dnl     -Wtraditional (combines too many unrelated messages, only a few useful)
1548 dnl     -Wwrite-strings (too noisy, but should review occasionally).  This
1549 dnl             is enabled for ncurses using "--enable-const".
1550 dnl     -pedantic
1551 dnl
1552 dnl Parameter:
1553 dnl     $1 is an optional list of gcc warning flags that a particular
1554 dnl             application might want to use, e.g., "no-unused" for
1555 dnl             -Wno-unused
1556 dnl Special:
1557 dnl     If $with_ext_const is "yes", add a check for -Wwrite-strings
1558 dnl
1559 AC_DEFUN([CF_GCC_WARNINGS],
1560 [
1561 AC_REQUIRE([CF_GCC_VERSION])
1562 CF_INTEL_COMPILER(GCC,INTEL_COMPILER,CFLAGS)
1563
1564 cat > conftest.$ac_ext <<EOF
1565 #line __oline__ "${as_me-configure}"
1566 int main(int argc, char *argv[[]]) { return (argv[[argc-1]] == 0) ; }
1567 EOF
1568
1569 if test "$INTEL_COMPILER" = yes
1570 then
1571 # The "-wdXXX" options suppress warnings:
1572 # remark #1419: external declaration in primary source file
1573 # remark #1683: explicit conversion of a 64-bit integral type to a smaller integral type (potential portability problem)
1574 # remark #1684: conversion from pointer to same-sized integral type (potential portability problem)
1575 # remark #193: zero used for undefined preprocessing identifier
1576 # remark #593: variable "curs_sb_left_arrow" was set but never used
1577 # remark #810: conversion from "int" to "Dimension={unsigned short}" may lose significant bits
1578 # remark #869: parameter "tw" was never referenced
1579 # remark #981: operands are evaluated in unspecified order
1580 # warning #279: controlling expression is constant
1581
1582         AC_CHECKING([for $CC warning options])
1583         cf_save_CFLAGS="$CFLAGS"
1584         EXTRA_CFLAGS="-Wall"
1585         for cf_opt in \
1586                 wd1419 \
1587                 wd1683 \
1588                 wd1684 \
1589                 wd193 \
1590                 wd593 \
1591                 wd279 \
1592                 wd810 \
1593                 wd869 \
1594                 wd981
1595         do
1596                 CFLAGS="$cf_save_CFLAGS $EXTRA_CFLAGS -$cf_opt"
1597                 if AC_TRY_EVAL(ac_compile); then
1598                         test -n "$verbose" && AC_MSG_RESULT(... -$cf_opt)
1599                         EXTRA_CFLAGS="$EXTRA_CFLAGS -$cf_opt"
1600                 fi
1601         done
1602         CFLAGS="$cf_save_CFLAGS"
1603
1604 elif test "$GCC" = yes
1605 then
1606         AC_CHECKING([for $CC warning options])
1607         cf_save_CFLAGS="$CFLAGS"
1608         EXTRA_CFLAGS="-W -Wall"
1609         cf_warn_CONST=""
1610         test "$with_ext_const" = yes && cf_warn_CONST="Wwrite-strings"
1611         for cf_opt in \
1612                 Wbad-function-cast \
1613                 Wcast-align \
1614                 Wcast-qual \
1615                 Winline \
1616                 Wmissing-declarations \
1617                 Wmissing-prototypes \
1618                 Wnested-externs \
1619                 Wpointer-arith \
1620                 Wshadow \
1621                 Wstrict-prototypes \
1622                 Wundef $cf_warn_CONST $1
1623         do
1624                 CFLAGS="$cf_save_CFLAGS $EXTRA_CFLAGS -$cf_opt"
1625                 if AC_TRY_EVAL(ac_compile); then
1626                         test -n "$verbose" && AC_MSG_RESULT(... -$cf_opt)
1627                         case $cf_opt in #(vi
1628                         Wcast-qual) #(vi
1629                                 CPPFLAGS="$CPPFLAGS -DXTSTRINGDEFINES"
1630                                 ;;
1631                         Winline) #(vi
1632                                 case $GCC_VERSION in
1633                                 [[34]].*)
1634                                         CF_VERBOSE(feature is broken in gcc $GCC_VERSION)
1635                                         continue;;
1636                                 esac
1637                                 ;;
1638                         esac
1639                         EXTRA_CFLAGS="$EXTRA_CFLAGS -$cf_opt"
1640                 fi
1641         done
1642         CFLAGS="$cf_save_CFLAGS"
1643 fi
1644 rm -f conftest*
1645
1646 AC_SUBST(EXTRA_CFLAGS)
1647 ])dnl
1648 dnl ---------------------------------------------------------------------------
1649 dnl CF_GNAT_TRY_LINK version: 1 updated: 2004/08/21 19:02:08
1650 dnl ----------------
1651 dnl Verify that a test program compiles/links with GNAT.
1652 dnl $cf_ada_make is set to the program that compiles/links
1653 dnl $ADAFLAGS may be set to the GNAT flags.
1654 dnl
1655 dnl $1 is the text of the spec
1656 dnl $2 is the text of the body
1657 dnl $3 is the shell command to execute if successful
1658 dnl $4 is the shell command to execute if not successful
1659 AC_DEFUN([CF_GNAT_TRY_LINK],
1660 [
1661 rm -f conftest*
1662 cat >>conftest.ads <<CF_EOF
1663 $1
1664 CF_EOF
1665 cat >>conftest.adb <<CF_EOF
1666 $2
1667 CF_EOF
1668 if ( $cf_ada_make $ADAFLAGS conftest 1>&AC_FD_CC 2>&1 ) ; then
1669 ifelse($3,,      :,[      $3])
1670 ifelse($4,,,[else
1671    $4])
1672 fi
1673 rm -f conftest*
1674 ])dnl
1675 dnl ---------------------------------------------------------------------------
1676 dnl CF_GNAT_TRY_RUN version: 3 updated: 2004/08/21 19:02:08
1677 dnl ---------------
1678 dnl Verify that a test program compiles and runs with GNAT
1679 dnl $cf_ada_make is set to the program that compiles/links
1680 dnl $ADAFLAGS may be set to the GNAT flags.
1681 dnl
1682 dnl $1 is the text of the spec
1683 dnl $2 is the text of the body
1684 dnl $3 is the shell command to execute if successful
1685 dnl $4 is the shell command to execute if not successful
1686 AC_DEFUN([CF_GNAT_TRY_RUN],
1687 [
1688 rm -f conftest*
1689 cat >>conftest.ads <<CF_EOF
1690 $1
1691 CF_EOF
1692 cat >>conftest.adb <<CF_EOF
1693 $2
1694 CF_EOF
1695 if ( $cf_ada_make $ADAFLAGS conftest 1>&AC_FD_CC 2>&1 ) ; then
1696    if ( ./conftest 1>&AC_FD_CC 2>&1 ) ; then
1697 ifelse($3,,      :,[      $3])
1698 ifelse($4,,,[   else
1699       $4])
1700    fi
1701 ifelse($4,,,[else
1702    $4])
1703 fi
1704 rm -f conftest*
1705 ])dnl
1706 dnl ---------------------------------------------------------------------------
1707 dnl CF_GNAT_VERSION version: 12 updated: 2006/10/14 15:23:15
1708 dnl ---------------
1709 dnl Verify version of GNAT.
1710 AC_DEFUN([CF_GNAT_VERSION],
1711 [
1712 AC_MSG_CHECKING(for gnat version)
1713 cf_gnat_version=`${cf_ada_make-gnatmake} -v 2>&1 | grep '[[0-9]].[[0-9]][[0-9]]*' |\
1714   sed -e '2,$d' -e 's/[[^0-9 \.]]//g' -e 's/^[[ ]]*//' -e 's/ .*//'`
1715 AC_MSG_RESULT($cf_gnat_version)
1716
1717 case $cf_gnat_version in
1718   3.1[[1-9]]*|3.[[2-9]]*|[[4-9]].*)
1719     cf_cv_prog_gnat_correct=yes
1720     ;;
1721   *) echo Unsupported GNAT version $cf_gnat_version. Required is 3.11 or better. Disabling Ada95 binding.
1722      cf_cv_prog_gnat_correct=no
1723      ;;
1724 esac
1725 case $cf_gnat_version in
1726   3.[[1-9]]*|[[4-9]].*)
1727       cf_compile_generics=generics
1728       cf_generic_objects="\${GENOBJS}"
1729       ;;
1730   *)  cf_compile_generics=
1731       cf_generic_objects=
1732       ;;
1733 esac
1734 ])
1735 dnl ---------------------------------------------------------------------------
1736 dnl CF_GNU_SOURCE version: 6 updated: 2005/07/09 13:23:07
1737 dnl -------------
1738 dnl Check if we must define _GNU_SOURCE to get a reasonable value for
1739 dnl _XOPEN_SOURCE, upon which many POSIX definitions depend.  This is a defect
1740 dnl (or misfeature) of glibc2, which breaks portability of many applications,
1741 dnl since it is interwoven with GNU extensions.
1742 dnl
1743 dnl Well, yes we could work around it...
1744 AC_DEFUN([CF_GNU_SOURCE],
1745 [
1746 AC_CACHE_CHECK(if we must define _GNU_SOURCE,cf_cv_gnu_source,[
1747 AC_TRY_COMPILE([#include <sys/types.h>],[
1748 #ifndef _XOPEN_SOURCE
1749 make an error
1750 #endif],
1751         [cf_cv_gnu_source=no],
1752         [cf_save="$CPPFLAGS"
1753          CPPFLAGS="$CPPFLAGS -D_GNU_SOURCE"
1754          AC_TRY_COMPILE([#include <sys/types.h>],[
1755 #ifdef _XOPEN_SOURCE
1756 make an error
1757 #endif],
1758         [cf_cv_gnu_source=no],
1759         [cf_cv_gnu_source=yes])
1760         CPPFLAGS="$cf_save"
1761         ])
1762 ])
1763 test "$cf_cv_gnu_source" = yes && CPPFLAGS="$CPPFLAGS -D_GNU_SOURCE"
1764 ])dnl
1765 dnl ---------------------------------------------------------------------------
1766 dnl CF_GPP_LIBRARY version: 9 updated: 2009/12/19 13:46:49
1767 dnl --------------
1768 dnl If we're trying to use g++, test if libg++ is installed (a rather common
1769 dnl problem :-).  If we have the compiler but no library, we'll be able to
1770 dnl configure, but won't be able to build the c++ demo program.
1771 AC_DEFUN([CF_GPP_LIBRARY],
1772 [
1773 cf_cxx_library=unknown
1774 case $cf_cv_system_name in #(vi
1775 os2*) #(vi
1776         cf_gpp_libname=gpp
1777         ;;
1778 *)
1779         cf_gpp_libname=g++
1780         ;;
1781 esac
1782 if test "$GXX" = yes; then
1783         AC_MSG_CHECKING([for lib$cf_gpp_libname])
1784         cf_save="$LIBS"
1785         LIBS="-l$cf_gpp_libname $LIBS"
1786         AC_TRY_LINK([
1787 #include <$cf_gpp_libname/builtin.h>
1788         ],
1789         [two_arg_error_handler_t foo2 = lib_error_handler],
1790         [cf_cxx_library=yes
1791          CXXLIBS="$CXXLIBS -l$cf_gpp_libname"
1792          if test "$cf_gpp_libname" = cpp ; then
1793             AC_DEFINE(HAVE_GPP_BUILTIN_H)
1794          else
1795             AC_DEFINE(HAVE_GXX_BUILTIN_H)
1796          fi],
1797         [AC_TRY_LINK([
1798 #include <builtin.h>
1799         ],
1800         [two_arg_error_handler_t foo2 = lib_error_handler],
1801         [cf_cxx_library=yes
1802          CXXLIBS="$CXXLIBS -l$cf_gpp_libname"
1803          AC_DEFINE(HAVE_BUILTIN_H)],
1804         [cf_cxx_library=no])])
1805         LIBS="$cf_save"
1806         AC_MSG_RESULT($cf_cxx_library)
1807 fi
1808 ])dnl
1809 dnl ---------------------------------------------------------------------------
1810 dnl CF_GXX_VERSION version: 5 updated: 2005/08/27 09:53:42
1811 dnl --------------
1812 dnl Check for version of g++
1813 AC_DEFUN([CF_GXX_VERSION],[
1814 AC_REQUIRE([AC_PROG_CPP])
1815 GXX_VERSION=none
1816 if test "$GXX" = yes; then
1817         AC_MSG_CHECKING(version of g++)
1818         GXX_VERSION="`${CXX-g++} --version| sed -e '2,$d' -e 's/^.*(GCC) //' -e 's/^[[^0-9.]]*//' -e 's/[[^0-9.]].*//'`"
1819         test -z "$GXX_VERSION" && GXX_VERSION=unknown
1820         AC_MSG_RESULT($GXX_VERSION)
1821 fi
1822 ])dnl
1823 dnl ---------------------------------------------------------------------------
1824 dnl CF_GXX_WARNINGS version: 5 updated: 2005/08/13 14:54:38
1825 dnl ---------------
1826 dnl Check if the compiler supports useful warning options.
1827 dnl
1828 dnl Most of gcc's options apply to g++, except:
1829 dnl     -Wbad-function-cast
1830 dnl     -Wmissing-declarations
1831 dnl     -Wnested-externs
1832 dnl
1833 dnl Omit a few (for now):
1834 dnl     -Winline
1835 dnl
1836 dnl Parameter:
1837 dnl     $1 is an optional list of g++ warning flags that a particular
1838 dnl             application might want to use, e.g., "no-unused" for
1839 dnl             -Wno-unused
1840 dnl Special:
1841 dnl     If $with_ext_const is "yes", add a check for -Wwrite-strings
1842 dnl
1843 AC_DEFUN([CF_GXX_WARNINGS],
1844 [
1845
1846 CF_INTEL_COMPILER(GXX,INTEL_CPLUSPLUS,CXXFLAGS)
1847
1848 AC_REQUIRE([CF_GXX_VERSION])
1849
1850 AC_LANG_SAVE
1851 AC_LANG_CPLUSPLUS
1852
1853 cat > conftest.$ac_ext <<EOF
1854 #line __oline__ "configure"
1855 int main(int argc, char *argv[[]]) { return (argv[[argc-1]] == 0) ; }
1856 EOF
1857
1858 if test "$INTEL_CPLUSPLUS" = yes
1859 then
1860 # The "-wdXXX" options suppress warnings:
1861 # remark #1419: external declaration in primary source file
1862 # remark #1682: implicit conversion of a 64-bit integral type to a smaller integral type (potential portability problem)
1863 # remark #1683: explicit conversion of a 64-bit integral type to a smaller integral type (potential portability problem)
1864 # remark #1684: conversion from pointer to same-sized integral type (potential portability problem)
1865 # remark #193: zero used for undefined preprocessing identifier
1866 # remark #593: variable "curs_sb_left_arrow" was set but never used
1867 # remark #810: conversion from "int" to "Dimension={unsigned short}" may lose significant bits
1868 # remark #869: parameter "tw" was never referenced
1869 # remark #981: operands are evaluated in unspecified order
1870 # warning #269: invalid format string conversion
1871
1872         AC_CHECKING([for $CC warning options])
1873         cf_save_CXXFLAGS="$CXXFLAGS"
1874         EXTRA_CXXFLAGS="-Wall"
1875         for cf_opt in \
1876                 wd1419 \
1877                 wd1682 \
1878                 wd1683 \
1879                 wd1684 \
1880                 wd193 \
1881                 wd279 \
1882                 wd593 \
1883                 wd810 \
1884                 wd869 \
1885                 wd981
1886         do
1887                 CXXFLAGS="$cf_save_CXXFLAGS $EXTRA_CXXFLAGS -$cf_opt"
1888                 if AC_TRY_EVAL(ac_compile); then
1889                         test -n "$verbose" && AC_MSG_RESULT(... -$cf_opt)
1890                         EXTRA_CXXFLAGS="$EXTRA_CXXFLAGS -$cf_opt"
1891                 fi
1892         done
1893         CXXFLAGS="$cf_save_CXXFLAGS"
1894
1895 elif test "$GXX" = yes
1896 then
1897         AC_CHECKING([for $CXX warning options])
1898         cf_save_CXXFLAGS="$CXXFLAGS"
1899         EXTRA_CXXFLAGS="-W -Wall"
1900         cf_gxx_extra_warnings=""
1901         test "$with_ext_const" = yes && cf_gxx_extra_warnings="Wwrite-strings"
1902         case "$GCC_VERSION" in
1903         [[1-2]].*)
1904                 ;;
1905         *)
1906                 cf_gxx_extra_warnings="$cf_gxx_extra_warnings Weffc++"
1907                 ;;
1908         esac
1909         for cf_opt in \
1910                 Wabi \
1911                 fabi-version=0 \
1912                 Woverloaded-virtual \
1913                 Wsign-promo \
1914                 Wsynth \
1915                 Wold-style-cast \
1916                 Wcast-align \
1917                 Wcast-qual \
1918                 Wmissing-prototypes \
1919                 Wpointer-arith \
1920                 Wshadow \
1921                 Wstrict-prototypes \
1922                 Wundef $cf_gxx_extra_warnings $1
1923         do
1924                 CXXFLAGS="$cf_save_CXXFLAGS $EXTRA_CXXFLAGS -Werror -$cf_opt"
1925                 if AC_TRY_EVAL(ac_compile); then
1926                         test -n "$verbose" && AC_MSG_RESULT(... -$cf_opt)
1927                         EXTRA_CXXFLAGS="$EXTRA_CXXFLAGS -$cf_opt"
1928                 else
1929                         test -n "$verbose" && AC_MSG_RESULT(... no -$cf_opt)
1930                 fi
1931         done
1932         CXXFLAGS="$cf_save_CXXFLAGS"
1933 fi
1934
1935 rm -f conftest*
1936 AC_LANG_RESTORE
1937 AC_SUBST(EXTRA_CXXFLAGS)
1938 ])dnl
1939 dnl ---------------------------------------------------------------------------
1940 dnl CF_HASHED_DB version: 3 updated: 2007/11/24 17:43:37
1941 dnl ------------
1942 dnl Look for an instance of the Berkeley hashed database.
1943 dnl
1944 dnl $1 = optional parameter, to specify install-prefix for the database.
1945 AC_DEFUN([CF_HASHED_DB],
1946 [
1947 ifelse([$1],,,[
1948 case $1 in #(vi
1949 yes|*able*) #(vi
1950     ;;
1951 *)
1952     if test -d "$1" ; then
1953         CF_ADD_INCDIR($1/include)
1954         CF_ADD_LIBDIR($1/lib)
1955     fi
1956 esac
1957 ])
1958 AC_CHECK_HEADER(db.h,[
1959 CF_HASHED_DB_VERSION
1960 if test "$cf_cv_hashed_db_version" = unknown ; then
1961         AC_MSG_ERROR(Cannot determine version of db)
1962 else
1963         CF_HASHED_DB_LIBS
1964         if test "$cf_cv_hashed_db_libs" = unknown ; then
1965                 AC_MSG_ERROR(Cannot determine library for db)
1966         elif test "$cf_cv_hashed_db_libs" != default ; then
1967                 LIBS="-l$cf_cv_hashed_db_libs $LIBS"
1968         fi
1969 fi
1970 ],[
1971         AC_MSG_ERROR(Cannot find db.h)
1972 ])
1973 ])dnl
1974 dnl ---------------------------------------------------------------------------
1975 dnl CF_HASHED_DB_LIBS version: 8 updated: 2008/08/04 06:18:06
1976 dnl -----------------
1977 dnl Given that we have the header and version for hashed database, find the
1978 dnl library information.
1979 AC_DEFUN([CF_HASHED_DB_LIBS],
1980 [
1981 AC_CACHE_CHECK(for db libraries, cf_cv_hashed_db_libs,[
1982 cf_cv_hashed_db_libs=unknown
1983 for cf_db_libs in "" db$cf_cv_hashed_db_version db-$cf_cv_hashed_db_version db ''
1984 do
1985         cf_save_libs="$LIBS"
1986         if test -n "$cf_db_libs"; then
1987                 LIBS="-l$cf_db_libs $LIBS"
1988         fi
1989         CF_MSG_LOG(checking for library "$cf_db_libs")
1990         AC_TRY_LINK([
1991 $ac_includes_default
1992 #include <db.h>
1993 ],[
1994         char *path = "/tmp/foo";
1995 #ifdef DB_VERSION_MAJOR
1996 #if DB_VERSION_MAJOR >= 4
1997         DB *result = 0;
1998         db_create(&result, NULL, 0);
1999         result->open(result,
2000                 NULL,
2001                 path,
2002                 path,
2003                 DB_HASH,
2004                 DB_CREATE,
2005                 0644);
2006 #elif DB_VERSION_MAJOR >= 3
2007         DB *result = 0;
2008         db_create(&result, NULL, 0);
2009         result->open(result,
2010                 path,
2011                 path,
2012                 DB_HASH,
2013                 DB_CREATE,
2014                 0644);
2015 #elif DB_VERSION_MAJOR >= 2
2016         DB *result = 0;
2017         db_open(path,
2018                 DB_HASH,
2019                 DB_CREATE,
2020                 0644,
2021                 (DB_ENV *) 0,
2022                 (DB_INFO *) 0,
2023                 &result);
2024 #endif /* DB_VERSION_MAJOR */
2025 #else
2026         DB *result = dbopen(path,
2027                      2,
2028                      0644,
2029                      DB_HASH,
2030                      0);
2031 #endif
2032         ${cf_cv_main_return:-return}(result != 0)
2033 ],[
2034         if test -n "$cf_db_libs" ; then
2035                 cf_cv_hashed_db_libs=$cf_db_libs
2036         else
2037                 cf_cv_hashed_db_libs=default
2038         fi
2039         LIBS="$cf_save_libs"
2040         break
2041 ])
2042         LIBS="$cf_save_libs"
2043 done
2044 ])
2045 ])dnl
2046 dnl ---------------------------------------------------------------------------
2047 dnl CF_HASHED_DB_VERSION version: 3 updated: 2007/12/01 15:01:37
2048 dnl --------------------
2049 dnl Given that we have the header file for hashed database, find the version
2050 dnl information.
2051 AC_DEFUN([CF_HASHED_DB_VERSION],
2052 [
2053 AC_CACHE_CHECK(for version of db, cf_cv_hashed_db_version,[
2054 cf_cv_hashed_db_version=unknown
2055
2056 for cf_db_version in 1 2 3 4 5
2057 do
2058         CF_MSG_LOG(checking for db version $cf_db_version)
2059         AC_TRY_COMPILE([
2060 $ac_includes_default
2061 #include <db.h>
2062
2063 #ifdef DB_VERSION_MAJOR
2064         /* db2 (DB_VERSION_MAJOR=2) has also DB_VERSION_MINOR, tested with 7 */
2065 #if $cf_db_version == DB_VERSION_MAJOR
2066         /* ok */
2067 #else
2068         make an error
2069 #endif
2070 #else
2071 #if $cf_db_version == 1
2072         /* ok: assuming this is DB 1.8.5 */
2073 #else
2074         make an error
2075 #endif
2076 #endif
2077 ],[DBT *foo = 0],[
2078         cf_cv_hashed_db_version=$cf_db_version
2079         break
2080         ])
2081 done
2082 ])
2083 ])dnl
2084 dnl ---------------------------------------------------------------------------
2085 dnl CF_HEADER_PATH version: 10 updated: 2010/01/17 20:36:17
2086 dnl --------------
2087 dnl Construct a search-list of directories for a nonstandard header-file
2088 dnl
2089 dnl Parameters
2090 dnl     $1 = the variable to return as result
2091 dnl     $2 = the package name
2092 AC_DEFUN([CF_HEADER_PATH],
2093 [
2094 $1=
2095 cf_header_path_list=""
2096 if test -n "${CFLAGS}${CPPFLAGS}" ; then
2097         for cf_header_path in $CPPFLAGS $CFLAGS
2098         do
2099                 case $cf_header_path in #(vi
2100                 -I*)
2101                         cf_header_path=`echo ".$cf_header_path" |sed -e 's/^...//' -e 's,/include$,,'`
2102                         CF_ADD_SUBDIR_PATH($1,$2,include,$cf_header_path,NONE)
2103                         cf_header_path_list="$cf_header_path_list [$]$1"
2104                         ;;
2105                 esac
2106         done
2107 fi
2108
2109 CF_SUBDIR_PATH($1,$2,include)
2110
2111 test "$includedir" != NONE && \
2112 test "$includedir" != "/usr/include" && \
2113 test -d "$includedir" && {
2114         test -d $includedir &&    $1="[$]$1 $includedir"
2115         test -d $includedir/$2 && $1="[$]$1 $includedir/$2"
2116 }
2117
2118 test "$oldincludedir" != NONE && \
2119 test "$oldincludedir" != "/usr/include" && \
2120 test -d "$oldincludedir" && {
2121         test -d $oldincludedir    && $1="[$]$1 $oldincludedir"
2122         test -d $oldincludedir/$2 && $1="[$]$1 $oldincludedir/$2"
2123 }
2124
2125 $1="$cf_header_path_list [$]$1"
2126 ])dnl
2127 dnl ---------------------------------------------------------------------------
2128 dnl CF_HELP_MESSAGE version: 3 updated: 1998/01/14 10:56:23
2129 dnl ---------------
2130 dnl Insert text into the help-message, for readability, from AC_ARG_WITH.
2131 AC_DEFUN([CF_HELP_MESSAGE],
2132 [AC_DIVERT_HELP([$1])dnl
2133 ])dnl
2134 dnl ---------------------------------------------------------------------------
2135 dnl CF_INCLUDE_DIRS version: 6 updated: 2009/01/06 19:37:40
2136 dnl ---------------
2137 dnl Construct the list of include-options according to whether we're building
2138 dnl in the source directory or using '--srcdir=DIR' option.  If we're building
2139 dnl with gcc, don't append the includedir if it happens to be /usr/include,
2140 dnl since that usually breaks gcc's shadow-includes.
2141 AC_DEFUN([CF_INCLUDE_DIRS],
2142 [
2143 CPPFLAGS="$CPPFLAGS -I. -I../include"
2144 if test "$srcdir" != "."; then
2145         CPPFLAGS="$CPPFLAGS -I\${srcdir}/../include"
2146 fi
2147 if test "$GCC" != yes; then
2148         CPPFLAGS="$CPPFLAGS -I\${includedir}"
2149 elif test "$includedir" != "/usr/include"; then
2150         if test "$includedir" = '${prefix}/include' ; then
2151                 if test $prefix != /usr ; then
2152                         CPPFLAGS="$CPPFLAGS -I\${includedir}"
2153                 fi
2154         else
2155                 CPPFLAGS="$CPPFLAGS -I\${includedir}"
2156         fi
2157 fi
2158 AC_SUBST(CPPFLAGS)
2159 ])dnl
2160 dnl ---------------------------------------------------------------------------
2161 dnl CF_INTEL_COMPILER version: 3 updated: 2005/08/06 18:37:29
2162 dnl -----------------
2163 dnl Check if the given compiler is really the Intel compiler for Linux.  It
2164 dnl tries to imitate gcc, but does not return an error when it finds a mismatch
2165 dnl between prototypes, e.g., as exercised by CF_MISSING_CHECK.
2166 dnl
2167 dnl This macro should be run "soon" after AC_PROG_CC or AC_PROG_CPLUSPLUS, to
2168 dnl ensure that it is not mistaken for gcc/g++.  It is normally invoked from
2169 dnl the wrappers for gcc and g++ warnings.
2170 dnl
2171 dnl $1 = GCC (default) or GXX
2172 dnl $2 = INTEL_COMPILER (default) or INTEL_CPLUSPLUS
2173 dnl $3 = CFLAGS (default) or CXXFLAGS
2174 AC_DEFUN([CF_INTEL_COMPILER],[
2175 ifelse($2,,INTEL_COMPILER,[$2])=no
2176
2177 if test "$ifelse($1,,[$1],GCC)" = yes ; then
2178         case $host_os in
2179         linux*|gnu*)
2180                 AC_MSG_CHECKING(if this is really Intel ifelse($1,GXX,C++,C) compiler)
2181                 cf_save_CFLAGS="$ifelse($3,,CFLAGS,[$3])"
2182                 ifelse($3,,CFLAGS,[$3])="$ifelse($3,,CFLAGS,[$3]) -no-gcc"
2183                 AC_TRY_COMPILE([],[
2184 #ifdef __INTEL_COMPILER
2185 #else
2186 make an error
2187 #endif
2188 ],[ifelse($2,,INTEL_COMPILER,[$2])=yes
2189 cf_save_CFLAGS="$cf_save_CFLAGS -we147 -no-gcc"
2190 ],[])
2191                 ifelse($3,,CFLAGS,[$3])="$cf_save_CFLAGS"
2192                 AC_MSG_RESULT($ifelse($2,,INTEL_COMPILER,[$2]))
2193                 ;;
2194         esac
2195 fi
2196 ])dnl
2197 dnl ---------------------------------------------------------------------------
2198 dnl CF_ISASCII version: 3 updated: 2000/08/12 23:18:52
2199 dnl ----------
2200 dnl Check if we have either a function or macro for 'isascii()'.
2201 AC_DEFUN([CF_ISASCII],
2202 [
2203 AC_MSG_CHECKING(for isascii)
2204 AC_CACHE_VAL(cf_cv_have_isascii,[
2205         AC_TRY_LINK([#include <ctype.h>],[int x = isascii(' ')],
2206         [cf_cv_have_isascii=yes],
2207         [cf_cv_have_isascii=no])
2208 ])dnl
2209 AC_MSG_RESULT($cf_cv_have_isascii)
2210 test "$cf_cv_have_isascii" = yes && AC_DEFINE(HAVE_ISASCII)
2211 ])dnl
2212 dnl ---------------------------------------------------------------------------
2213 dnl CF_LARGEFILE version: 7 updated: 2007/06/02 11:58:50
2214 dnl ------------
2215 dnl Add checks for large file support.
2216 AC_DEFUN([CF_LARGEFILE],[
2217 ifdef([AC_FUNC_FSEEKO],[
2218     AC_SYS_LARGEFILE
2219     if test "$enable_largefile" != no ; then
2220         AC_FUNC_FSEEKO
2221
2222         # Normally we would collect these definitions in the config.h,
2223         # but (like _XOPEN_SOURCE), some environments rely on having these
2224         # defined before any of the system headers are included.  Another
2225         # case comes up with C++, e.g., on AIX the compiler compiles the
2226         # header files by themselves before looking at the body files it is
2227         # told to compile.  For ncurses, those header files do not include
2228         # the config.h
2229         test "$ac_cv_sys_large_files"      != no && CPPFLAGS="$CPPFLAGS -D_LARGE_FILES "
2230         test "$ac_cv_sys_largefile_source" != no && CPPFLAGS="$CPPFLAGS -D_LARGEFILE_SOURCE "
2231         test "$ac_cv_sys_file_offset_bits" != no && CPPFLAGS="$CPPFLAGS -D_FILE_OFFSET_BITS=$ac_cv_sys_file_offset_bits "
2232
2233         AC_CACHE_CHECK(whether to use struct dirent64, cf_cv_struct_dirent64,[
2234                 AC_TRY_COMPILE([
2235 #include <sys/types.h>
2236 #include <dirent.h>
2237                 ],[
2238                 /* if transitional largefile support is setup, this is true */
2239                 extern struct dirent64 * readdir(DIR *);
2240                 struct dirent64 *x = readdir((DIR *)0);
2241                 struct dirent *y = readdir((DIR *)0);
2242                 int z = x - y;
2243                 ],
2244                 [cf_cv_struct_dirent64=yes],
2245                 [cf_cv_struct_dirent64=no])
2246         ])
2247         test "$cf_cv_struct_dirent64" = yes && AC_DEFINE(HAVE_STRUCT_DIRENT64)
2248     fi
2249 ])
2250 ])
2251 dnl ---------------------------------------------------------------------------
2252 dnl CF_LDFLAGS_STATIC version: 7 updated: 2009/04/04 18:31:04
2253 dnl -----------------
2254 dnl Check for compiler/linker flags used to temporarily force usage of static
2255 dnl libraries.  This depends on the compiler and platform.  Use this to help
2256 dnl ensure that the linker picks up a given library based on its position in
2257 dnl the list of linker options and libraries.
2258 AC_DEFUN([CF_LDFLAGS_STATIC],[
2259
2260 if test "$GCC" = yes ; then
2261         case $cf_cv_system_name in #(
2262         OS/2*|os2*|aix[[4]]*|solaris2.1[[0-9]]|darwin*)         #( vi
2263                 LDFLAGS_STATIC=
2264                 LDFLAGS_SHARED=
2265                 ;;
2266     *)  #( normally, except when broken
2267         LDFLAGS_STATIC=-static
2268         LDFLAGS_SHARED=-dynamic
2269         ;;
2270     esac
2271 else
2272         case $cf_cv_system_name in #(
2273         aix[[456]]*)    #( from ld manpage
2274                 LDFLAGS_STATIC=-bstatic
2275                 LDFLAGS_SHARED=-bdynamic
2276                 ;;
2277         hpux*)          #( from ld manpage for hpux10.20, hpux11.11
2278                 # We could also use just "archive" and "shared".
2279                 LDFLAGS_STATIC=-Wl,-a,archive_shared
2280                 LDFLAGS_SHARED=-Wl,-a,shared_archive
2281                 ;;
2282         irix*)          #( from ld manpage IRIX64
2283                 LDFLAGS_STATIC=-Bstatic
2284                 LDFLAGS_SHARED=-Bdynamic
2285                 ;;
2286         osf[[45]]*)     #( from ld manpage osf4.0d, osf5.1
2287                 # alternative "-oldstyle_liblookup" (not in cc manpage)
2288                 LDFLAGS_STATIC=-noso
2289                 LDFLAGS_SHARED=-so_archive
2290                 ;;
2291         solaris2*)
2292                 LDFLAGS_STATIC=-Bstatic
2293                 LDFLAGS_SHARED=-Bdynamic
2294                 ;;
2295         esac
2296 fi
2297
2298 AC_SUBST(LDFLAGS_STATIC)
2299 AC_SUBST(LDFLAGS_SHARED)
2300 ])
2301 dnl ---------------------------------------------------------------------------
2302 dnl CF_LD_RPATH_OPT version: 2 updated: 2010/03/27 19:27:54
2303 dnl ---------------
2304 dnl For the given system and compiler, find the compiler flags to pass to the
2305 dnl loader to use the "rpath" feature.
2306 AC_DEFUN([CF_LD_RPATH_OPT],
2307 [
2308 AC_REQUIRE([CF_CHECK_CACHE])
2309
2310 LD_RPATH_OPT=
2311 AC_MSG_CHECKING(for an rpath option)
2312 case $cf_cv_system_name in #(vi
2313 irix*) #(vi
2314         if test "$GCC" = yes; then
2315                 LD_RPATH_OPT="-Wl,-rpath,"
2316         else
2317                 LD_RPATH_OPT="-rpath "
2318         fi
2319         ;;
2320 linux*|gnu*|k*bsd*-gnu) #(vi
2321         LD_RPATH_OPT="-Wl,-rpath,"
2322         ;;
2323 openbsd[[2-9]].*) #(vi
2324         LD_RPATH_OPT="-Wl,-rpath,"
2325         ;;
2326 freebsd*) #(vi
2327         LD_RPATH_OPT="-rpath "
2328         ;;
2329 netbsd*) #(vi
2330         LD_RPATH_OPT="-Wl,-rpath,"
2331         ;;
2332 osf*|mls+*) #(vi
2333         LD_RPATH_OPT="-rpath "
2334         ;;
2335 solaris2*) #(vi
2336         LD_RPATH_OPT="-R"
2337         ;;
2338 *)
2339         ;;
2340 esac
2341 AC_MSG_RESULT($LD_RPATH_OPT)
2342
2343 case "x$LD_RPATH_OPT" in #(vi
2344 x-R*)
2345         AC_MSG_CHECKING(if we need a space after rpath option)
2346         cf_save_LIBS="$LIBS"
2347         LIBS="${LD_RPATH_OPT}$libdir $LIBS"
2348         AC_TRY_LINK(, , cf_rpath_space=no, cf_rpath_space=yes)
2349         LIBS="$cf_save_LIBS"
2350         AC_MSG_RESULT($cf_rpath_space)
2351         test "$cf_rpath_space" = yes && LD_RPATH_OPT="$LD_RPATH_OPT "
2352         ;;
2353 esac
2354 ])dnl
2355 dnl ---------------------------------------------------------------------------
2356 dnl CF_LIBRARY_PATH version: 8 updated: 2008/12/07 19:38:31
2357 dnl ---------------
2358 dnl Construct a search-list of directories for a nonstandard library-file
2359 dnl
2360 dnl Parameters
2361 dnl     $1 = the variable to return as result
2362 dnl     $2 = the package name
2363 AC_DEFUN([CF_LIBRARY_PATH],
2364 [
2365 cf_library_path_list=""
2366 if test -n "${LDFLAGS}${LIBS}" ; then
2367         for cf_library_path in $LDFLAGS $LIBS
2368         do
2369                 case $cf_library_path in #(vi
2370                 -L*)
2371                         cf_library_path=`echo ".$cf_library_path" |sed -e 's/^...//' -e 's,/lib$,,'`
2372                         CF_ADD_SUBDIR_PATH($1,$2,lib,$cf_library_path,NONE)
2373                         cf_library_path_list="$cf_library_path_list [$]$1"
2374                         ;;
2375                 esac
2376         done
2377 fi
2378
2379 CF_SUBDIR_PATH($1,$2,lib)
2380
2381 $1="$cf_library_path_list [$]$1"
2382 ])dnl
2383 dnl ---------------------------------------------------------------------------
2384 dnl CF_LIB_PREFIX version: 8 updated: 2008/09/13 11:34:16
2385 dnl -------------
2386 dnl Compute the library-prefix for the given host system
2387 dnl $1 = variable to set
2388 AC_DEFUN([CF_LIB_PREFIX],
2389 [
2390         case $cf_cv_system_name in #(vi
2391         OS/2*|os2*) #(vi
2392         LIB_PREFIX=''
2393         ;;
2394         *)      LIB_PREFIX='lib'
2395         ;;
2396         esac
2397 ifelse($1,,,[$1=$LIB_PREFIX])
2398         AC_SUBST(LIB_PREFIX)
2399 ])dnl
2400 dnl ---------------------------------------------------------------------------
2401 dnl CF_LIB_RULES version: 55 updated: 2008/12/13 16:17:38
2402 dnl ------------
2403 dnl Append definitions and rules for the given models to the subdirectory
2404 dnl Makefiles, and the recursion rule for the top-level Makefile.  If the
2405 dnl subdirectory is a library-source directory, modify the LIBS_TO_MAKE list in
2406 dnl the corresponding makefile to list the models that we'll generate.
2407 dnl
2408 dnl For shared libraries, make a list of symbolic links to construct when
2409 dnl generating each library.  The convention used for Linux is the simplest
2410 dnl one:
2411 dnl     lib<name>.so    ->
2412 dnl     lib<name>.so.<major>    ->
2413 dnl     lib<name>.so.<maj>.<minor>
2414 AC_DEFUN([CF_LIB_RULES],
2415 [
2416 CF_LIB_PREFIX(cf_prefix)
2417 AC_REQUIRE([CF_SUBST_NCURSES_VERSION])
2418
2419 if test $cf_cv_shlib_version = cygdll ; then
2420         TINFO_NAME=$TINFO_ARG_SUFFIX
2421         TINFO_SUFFIX=.dll
2422 fi
2423
2424 for cf_dir in $SRC_SUBDIRS
2425 do
2426         if test ! -d $srcdir/$cf_dir ; then
2427                 continue
2428         elif test -f $srcdir/$cf_dir/modules; then
2429
2430                 SHARED_LIB=
2431                 LIBS_TO_MAKE=
2432                 for cf_item in $cf_LIST_MODELS
2433                 do
2434                         CF_LIB_SUFFIX($cf_item,cf_suffix,cf_depsuf)
2435                         if test $cf_item = shared ; then
2436                         if test "$cf_cv_do_symlinks" = yes ; then
2437                                 case "$cf_cv_shlib_version" in #(vi
2438                                 rel) #(vi
2439                                         case "$cf_cv_system_name" in #(vi
2440                                         darwin*)
2441                                         case .${LIB_SUFFIX} in
2442                                         .w*)
2443                                                 cf_suffix=`echo $cf_suffix | sed 's/^w//'`
2444                                                 cf_suffix=w'.${REL_VERSION}'"$cf_suffix"
2445                                                 ;;
2446                                         *)
2447                                                 cf_suffix='.${REL_VERSION}'"$cf_suffix"
2448                                                 ;;
2449                                         esac
2450                                         ;; #(vi
2451                                         *) cf_suffix="$cf_suffix"'.${REL_VERSION}' ;;
2452                                         esac
2453                                         ;;
2454                                 abi)
2455                                         case "$cf_cv_system_name" in #(vi
2456                                         darwin*)
2457                                         case .${LIB_SUFFIX} in
2458                                         .w*)
2459                                                 cf_suffix=`echo $cf_suffix | sed 's/^w//'`
2460                                                 cf_suffix=w'.${ABI_VERSION}'"$cf_suffix"
2461                                                 ;;
2462                                         *)
2463                                                 cf_suffix='.${ABI_VERSION}'"$cf_suffix"
2464                                                 ;;
2465                                         esac
2466                                         ;; #(vi
2467                                         *) cf_suffix="$cf_suffix"'.${ABI_VERSION}' ;;
2468                                         esac
2469                                         ;;
2470                                 esac
2471                         fi
2472                         # cygwin needs import library, and has unique naming convention
2473                         # use autodetected ${cf_prefix} for import lib and static lib, but
2474                         # use 'cyg' prefix for shared lib.
2475                         if test $cf_cv_shlib_version = cygdll ; then
2476                                 cf_cygsuf=`echo "$cf_suffix" | sed -e 's/\.dll/\${ABI_VERSION}.dll/'`
2477                                 LIBS_TO_MAKE="$LIBS_TO_MAKE ../lib/cyg${cf_dir}${cf_cygsuf}"
2478                                 continue
2479                         fi
2480                         fi
2481                         LIBS_TO_MAKE="$LIBS_TO_MAKE ../lib/${cf_prefix}${cf_dir}${cf_suffix}"
2482                 done
2483
2484                 if test $cf_dir = ncurses ; then
2485                         cf_subsets="$LIB_SUBSETS"
2486                         cf_r_parts="$cf_subsets"
2487                         cf_liblist="$LIBS_TO_MAKE"
2488
2489                         while test -n "$cf_r_parts"
2490                         do
2491                                 cf_l_parts=`echo "$cf_r_parts" |sed -e 's/ .*$//'`
2492                                 cf_r_parts=`echo "$cf_r_parts" |sed -e 's/^[[^ ]]* //'`
2493                                 if test "$cf_l_parts" != "$cf_r_parts" ; then
2494                                         cf_item=
2495                                         case $cf_l_parts in #(vi
2496                                         *termlib*) #(vi
2497                                                 cf_item=`echo $cf_liblist |sed -e s%${LIB_NAME}${LIB_SUFFIX}%${TINFO_LIB_SUFFIX}%g`
2498                                                 ;;
2499                                         *ticlib*)
2500                                                 cf_item=`echo $cf_liblist |sed -e s%${LIB_NAME}${LIB_SUFFIX}%${TICS_LIB_SUFFIX}%g`
2501                                                 ;;
2502                                         *)
2503                                                 break
2504                                                 ;;
2505                                         esac
2506                                         if test -n "$cf_item"; then
2507                                                 LIBS_TO_MAKE="$cf_item $LIBS_TO_MAKE"
2508                                         fi
2509                                 else
2510                                         break
2511                                 fi
2512                         done
2513                 else
2514                         cf_subsets=`echo "$LIB_SUBSETS" | sed -e 's/^termlib.* //'`
2515                 fi
2516
2517                 sed -e "s%@LIBS_TO_MAKE@%$LIBS_TO_MAKE%" \
2518                     -e "s%@SHARED_LIB@%$SHARED_LIB%" \
2519                         $cf_dir/Makefile >$cf_dir/Makefile.out
2520                 mv $cf_dir/Makefile.out $cf_dir/Makefile
2521
2522                 $AWK -f $srcdir/mk-0th.awk \
2523                         libname="${cf_dir}${LIB_SUFFIX}" subsets="$LIB_SUBSETS" \
2524                         $srcdir/$cf_dir/modules >>$cf_dir/Makefile
2525
2526                 for cf_subset in $cf_subsets
2527                 do
2528                         cf_subdirs=
2529                         for cf_item in $cf_LIST_MODELS
2530                         do
2531                         echo "Appending rules for ${cf_item} model (${cf_dir}: ${cf_subset})"
2532                         CF_UPPER(cf_ITEM,$cf_item)
2533                         CF_LIB_SUFFIX($cf_item,cf_suffix,cf_depsuf)
2534                         CF_OBJ_SUBDIR($cf_item,cf_subdir)
2535
2536                         # Test for case where we build libtinfo with a different name.
2537                         cf_libname=$cf_dir
2538                         if test $cf_dir = ncurses ; then
2539                                 case $cf_subset in
2540                                 *base*)
2541                                         cf_libname=${cf_libname}$LIB_SUFFIX
2542                                         ;;
2543                                 *termlib*)
2544                                         cf_libname=$TINFO_LIB_SUFFIX
2545                                         ;;
2546                                 ticlib*)
2547                                         cf_libname=$TICS_LIB_SUFFIX
2548                                         ;;
2549                                 esac
2550                         else
2551                                 cf_libname=${cf_libname}$LIB_SUFFIX
2552                         fi
2553                         if test -n "${DFT_ARG_SUFFIX}" ; then
2554                                 # undo $LIB_SUFFIX add-on in CF_LIB_SUFFIX
2555                                 cf_suffix=`echo $cf_suffix |sed -e "s%^${LIB_SUFFIX}%%"`
2556                         fi
2557
2558                         # These dependencies really are for development, not
2559                         # builds, but they are useful in porting, too.
2560                         cf_depend="../include/ncurses_cfg.h"
2561                         if test "$srcdir" = "."; then
2562                                 cf_reldir="."
2563                         else
2564                                 cf_reldir="\${srcdir}"
2565                         fi
2566
2567                         if test -f $srcdir/$cf_dir/$cf_dir.priv.h; then
2568                                 cf_depend="$cf_depend $cf_reldir/$cf_dir.priv.h"
2569                         elif test -f $srcdir/$cf_dir/curses.priv.h; then
2570                                 cf_depend="$cf_depend $cf_reldir/curses.priv.h"
2571                         fi
2572
2573                         cf_dir_suffix=
2574                         old_cf_suffix="$cf_suffix"
2575                         if test "$cf_cv_shlib_version_infix" = yes ; then
2576                         if test -n "$LIB_SUFFIX" ; then
2577                                 case $LIB_SUFFIX in
2578                                 w*)
2579                                         cf_libname=`echo $cf_libname | sed 's/w$//'`
2580                                         cf_suffix=`echo $cf_suffix | sed 's/^w//'`
2581                                         cf_dir_suffix=w
2582                                         ;;
2583                                 esac
2584                         fi
2585                         fi
2586
2587                         $AWK -f $srcdir/mk-1st.awk \
2588                                 name=${cf_libname}${cf_dir_suffix} \
2589                                 traces=$LIB_TRACING \
2590                                 MODEL=$cf_ITEM \
2591                                 model=$cf_subdir \
2592                                 prefix=$cf_prefix \
2593                                 suffix=$cf_suffix \
2594                                 subset=$cf_subset \
2595                                 TermlibRoot=$TINFO_NAME \
2596                                 TermlibSuffix=$TINFO_SUFFIX \
2597                                 ShlibVer=$cf_cv_shlib_version \
2598                                 ShlibVerInfix=$cf_cv_shlib_version_infix \
2599                                 ReLink=${cf_cv_do_relink-no} \
2600                                 DoLinks=$cf_cv_do_symlinks \
2601                                 rmSoLocs=$cf_cv_rm_so_locs \
2602                                 ldconfig="$LDCONFIG" \
2603                                 overwrite=$WITH_OVERWRITE \
2604                                 depend="$cf_depend" \
2605                                 host="$host" \
2606                                 $srcdir/$cf_dir/modules >>$cf_dir/Makefile
2607
2608                         cf_suffix="$old_cf_suffix"
2609
2610                         for cf_subdir2 in $cf_subdirs lib
2611                         do
2612                                 test $cf_subdir = $cf_subdir2 && break
2613                         done
2614                         test "${cf_subset}.${cf_subdir2}" != "${cf_subset}.${cf_subdir}" && \
2615                         $AWK -f $srcdir/mk-2nd.awk \
2616                                 name=$cf_dir \
2617                                 traces=$LIB_TRACING \
2618                                 MODEL=$cf_ITEM \
2619                                 model=$cf_subdir \
2620                                 subset=$cf_subset \
2621                                 srcdir=$srcdir \
2622                                 echo=$WITH_ECHO \
2623                                 crenames=$cf_cv_prog_CC_c_o \
2624                                 cxxrenames=$cf_cv_prog_CXX_c_o \
2625                                 $srcdir/$cf_dir/modules >>$cf_dir/Makefile
2626                         cf_subdirs="$cf_subdirs $cf_subdir"
2627                         done
2628                 done
2629         fi
2630
2631         echo '  cd '$cf_dir' && ${MAKE} ${CF_MFLAGS} [$]@' >>Makefile
2632 done
2633
2634 for cf_dir in $SRC_SUBDIRS
2635 do
2636         if test ! -d $srcdir/$cf_dir ; then
2637                 continue
2638         fi
2639
2640         if test -f $cf_dir/Makefile ; then
2641                 case "$cf_dir" in
2642                 Ada95) #(vi
2643                         echo 'libs \' >> Makefile
2644                         echo 'install.libs \' >> Makefile
2645                         echo 'uninstall.libs ::' >> Makefile
2646                         echo '  cd '$cf_dir' && ${MAKE} ${CF_MFLAGS} [$]@' >> Makefile
2647                         ;;
2648                 esac
2649         fi
2650
2651         if test -f $srcdir/$cf_dir/modules; then
2652                 echo >> Makefile
2653                 if test -f $srcdir/$cf_dir/headers; then
2654 cat >> Makefile <<CF_EOF
2655 install.includes \\
2656 uninstall.includes \\
2657 CF_EOF
2658                 fi
2659 if test "$cf_dir" != "c++" ; then
2660 echo 'lint \' >> Makefile
2661 fi
2662 cat >> Makefile <<CF_EOF
2663 libs \\
2664 lintlib \\
2665 install.libs \\
2666 uninstall.libs \\
2667 install.$cf_dir \\
2668 uninstall.$cf_dir ::
2669         cd $cf_dir && \${MAKE} \${CF_MFLAGS} \[$]@
2670 CF_EOF
2671         elif test -f $srcdir/$cf_dir/headers; then
2672 cat >> Makefile <<CF_EOF
2673
2674 libs \\
2675 install.libs \\
2676 uninstall.libs \\
2677 install.includes \\
2678 uninstall.includes ::
2679         cd $cf_dir && \${MAKE} \${CF_MFLAGS} \[$]@
2680 CF_EOF
2681 fi
2682 done
2683
2684 cat >> Makefile <<CF_EOF
2685
2686 install.libs uninstall.libs \\
2687 install.data uninstall.data ::
2688 $MAKE_TERMINFO  cd misc && \${MAKE} \${CF_MFLAGS} \[$]@
2689 CF_EOF
2690
2691 if test "x$cf_with_manpages" = xyes; then
2692 cat >> Makefile <<CF_EOF
2693
2694 install.man \\
2695 uninstall.man ::
2696         cd man && \${MAKE} \${CF_MFLAGS} \[$]@
2697 CF_EOF
2698 fi
2699
2700 cat >> Makefile <<CF_EOF
2701
2702 distclean ::
2703         rm -f config.cache config.log config.status Makefile include/ncurses_cfg.h
2704         rm -f headers.sh headers.sed mk_shared_lib.sh
2705         rm -f edit_man.* man_alias.*
2706         rm -rf \${DIRS_TO_MAKE}
2707 CF_EOF
2708
2709 # Special case: tack's manpage lives in its own directory.
2710 if test "x$cf_with_manpages" = xyes; then
2711 if test -d tack ; then
2712 if test -f $srcdir/$tack.h; then
2713 cat >> Makefile <<CF_EOF
2714
2715 install.man \\
2716 uninstall.man ::
2717         cd tack && \${MAKE} \${CF_MFLAGS} \[$]@
2718 CF_EOF
2719 fi
2720 fi
2721 fi
2722
2723 dnl If we're installing into a subdirectory of /usr/include, etc., we should
2724 dnl prepend the subdirectory's name to the "#include" paths.  It won't hurt
2725 dnl anything, and will make it more standardized.  It's awkward to decide this
2726 dnl at configuration because of quoting, so we'll simply make all headers
2727 dnl installed via a script that can do the right thing.
2728
2729 rm -f headers.sed headers.sh
2730
2731 dnl ( generating this script makes the makefiles a little tidier :-)
2732 echo creating headers.sh
2733 cat >headers.sh <<CF_EOF
2734 #! /bin/sh
2735 # This shell script is generated by the 'configure' script.  It is invoked in a
2736 # subdirectory of the build tree.  It generates a sed-script in the parent
2737 # directory that is used to adjust includes for header files that reside in a
2738 # subdirectory of /usr/include, etc.
2739 PRG=""
2740 while test \[$]# != 3
2741 do
2742 PRG="\$PRG \[$]1"; shift
2743 done
2744 DST=\[$]1
2745 REF=\[$]2
2746 SRC=\[$]3
2747 TMPSRC=\${TMPDIR-/tmp}/\`basename \$SRC\`\$\$
2748 TMPSED=\${TMPDIR-/tmp}/headers.sed\$\$
2749 echo installing \$SRC in \$DST
2750 CF_EOF
2751
2752 if test $WITH_CURSES_H = yes; then
2753         cat >>headers.sh <<CF_EOF
2754 case \$DST in
2755 /*/include/*)
2756         END=\`basename \$DST\`
2757         for i in \`cat \$REF/../*/headers |fgrep -v "#"\`
2758         do
2759                 NAME=\`basename \$i\`
2760                 echo "s/<\$NAME>/<\$END\/\$NAME>/" >> \$TMPSED
2761         done
2762         ;;
2763 *)
2764         echo "" >> \$TMPSED
2765         ;;
2766 esac
2767 CF_EOF
2768
2769 else
2770         cat >>headers.sh <<CF_EOF
2771 case \$DST in
2772 /*/include/*)
2773         END=\`basename \$DST\`
2774         for i in \`cat \$REF/../*/headers |fgrep -v "#"\`
2775         do
2776                 NAME=\`basename \$i\`
2777                 if test "\$NAME" = "curses.h"
2778                 then
2779                         echo "s/<curses.h>/<ncurses.h>/" >> \$TMPSED
2780                         NAME=ncurses.h
2781                 fi
2782                 echo "s/<\$NAME>/<\$END\/\$NAME>/" >> \$TMPSED
2783         done
2784         ;;
2785 *)
2786         echo "s/<curses.h>/<ncurses.h>/" >> \$TMPSED
2787         ;;
2788 esac
2789 CF_EOF
2790 fi
2791 cat >>headers.sh <<CF_EOF
2792 rm -f \$TMPSRC
2793 sed -f \$TMPSED \$SRC > \$TMPSRC
2794 NAME=\`basename \$SRC\`
2795 CF_EOF
2796 if test $WITH_CURSES_H != yes; then
2797         cat >>headers.sh <<CF_EOF
2798 test "\$NAME" = "curses.h" && NAME=ncurses.h
2799 CF_EOF
2800 fi
2801 cat >>headers.sh <<CF_EOF
2802 # Just in case someone gzip'd manpages, remove the conflicting copy.
2803 test -f \$DST/\$NAME.gz && rm -f \$DST/\$NAME.gz
2804
2805 eval \$PRG \$TMPSRC \$DST/\$NAME
2806 rm -f \$TMPSRC \$TMPSED
2807 CF_EOF
2808
2809 chmod 0755 headers.sh
2810
2811 for cf_dir in $SRC_SUBDIRS
2812 do
2813         if test ! -d $srcdir/$cf_dir ; then
2814                 continue
2815         fi
2816
2817         if test -f $srcdir/$cf_dir/headers; then
2818                 $AWK -f $srcdir/mk-hdr.awk \
2819                         subset="$LIB_SUBSETS" \
2820                         compat="$WITH_CURSES_H" \
2821                         $srcdir/$cf_dir/headers >>$cf_dir/Makefile
2822         fi
2823
2824         if test -f $srcdir/$cf_dir/modules; then
2825                 if test "$cf_dir" != "c++" ; then
2826                         cat >>$cf_dir/Makefile <<"CF_EOF"
2827 depend : ${AUTO_SRC}
2828         makedepend -- ${CPPFLAGS} -- ${C_SRC}
2829
2830 # DO NOT DELETE THIS LINE -- make depend depends on it.
2831 CF_EOF
2832                 fi
2833         fi
2834 done
2835
2836 ])dnl
2837 dnl ---------------------------------------------------------------------------
2838 dnl CF_LIB_SONAME version: 3 updated: 2006/12/16 15:55:46
2839 dnl -------------
2840 dnl Find the and soname for the given shared library.  Set the cache variable
2841 dnl cf_cv_$3_soname to this, unless it is not found.  Then set the cache
2842 dnl variable to "unknown".
2843 dnl
2844 dnl $1 = headers
2845 dnl $2 = code
2846 dnl $3 = library name
2847 AC_DEFUN([CF_LIB_SONAME],
2848 [
2849 AC_CACHE_CHECK(for soname of $3 library,cf_cv_$3_soname,[
2850
2851 cf_cv_$3_soname=unknown
2852 if test "$cross_compiling" != yes ; then
2853 cat >conftest.$ac_ext <<CF_EOF
2854 $1
2855 int main()
2856 {
2857 $2
2858         ${cf_cv_main_return:-return}(0);
2859 }
2860 CF_EOF
2861 cf_save_LIBS="$LIBS"
2862         LIBS="-l$3 $LIBS"
2863         if AC_TRY_EVAL(ac_compile) ; then
2864                 if AC_TRY_EVAL(ac_link) ; then
2865                         cf_cv_$3_soname=`ldd conftest$ac_exeext 2>/dev/null | sed -e 's,^.*/,,' -e 's, .*$,,' | fgrep lib$3.`
2866                         test -z "$cf_cv_$3_soname" && cf_cv_$3_soname=unknown
2867                 fi
2868         fi
2869 rm -f conftest*
2870 LIBS="$cf_save_LIBS"
2871 fi
2872 ])
2873 ])
2874 dnl ---------------------------------------------------------------------------
2875 dnl CF_LIB_SUFFIX version: 16 updated: 2008/12/27 12:30:03
2876 dnl -------------
2877 dnl Compute the library file-suffix from the given model name
2878 dnl $1 = model name
2879 dnl $2 = variable to set (the nominal library suffix)
2880 dnl $3 = dependency variable to set (actual filename)
2881 dnl The variable $LIB_SUFFIX, if set, prepends the variable to set.
2882 AC_DEFUN([CF_LIB_SUFFIX],
2883 [
2884         AC_REQUIRE([CF_SUBST_NCURSES_VERSION])
2885         case $1 in #(vi
2886         libtool) #(vi
2887                 $2='.la'
2888                 $3=[$]$2
2889                 ;;
2890         normal) #(vi
2891                 $2='.a'
2892                 $3=[$]$2
2893                 ;;
2894         debug) #(vi
2895                 $2='_g.a'
2896                 $3=[$]$2
2897                 ;;
2898         profile) #(vi
2899                 $2='_p.a'
2900                 $3=[$]$2
2901                 ;;
2902         shared) #(vi
2903                 case $cf_cv_system_name in
2904                 aix[[56]]*) #(vi
2905                         $2='.a'
2906                         $3=[$]$2
2907                         ;;
2908                 cygwin*) #(vi
2909                         $2='.dll'
2910                         $3='.dll.a'
2911                         ;;
2912                 darwin*) #(vi
2913                         $2='.dylib'
2914                         $3=[$]$2
2915                         ;;
2916                 hpux*) #(vi
2917                         case $target in
2918                         ia64*) #(vi
2919                                 $2='.so'
2920                                 $3=[$]$2
2921                                 ;;
2922                         *) #(vi
2923                                 $2='.sl'
2924                                 $3=[$]$2
2925                                 ;;
2926                         esac
2927                         ;;
2928                 *)      $2='.so'
2929                         $3=[$]$2
2930                         ;;
2931                 esac
2932         esac
2933         test -n "$LIB_SUFFIX" && $2="${LIB_SUFFIX}[$]{$2}"
2934         test -n "$LIB_SUFFIX" && $3="${LIB_SUFFIX}[$]{$3}"
2935 ])dnl
2936 dnl ---------------------------------------------------------------------------
2937 dnl CF_LIB_TYPE version: 4 updated: 2000/10/20 22:57:49
2938 dnl -----------
2939 dnl Compute the string to append to -library from the given model name
2940 dnl $1 = model name
2941 dnl $2 = variable to set
2942 dnl The variable $LIB_SUFFIX, if set, prepends the variable to set.
2943 AC_DEFUN([CF_LIB_TYPE],
2944 [
2945         case $1 in
2946         libtool) $2=''   ;;
2947         normal)  $2=''   ;;
2948         debug)   $2='_g' ;;
2949         profile) $2='_p' ;;
2950         shared)  $2=''   ;;
2951         esac
2952         test -n "$LIB_SUFFIX" && $2="${LIB_SUFFIX}[$]{$2}"
2953 ])dnl
2954 dnl ---------------------------------------------------------------------------
2955 dnl CF_LINK_DATAONLY version: 9 updated: 2009/01/01 20:21:38
2956 dnl ----------------
2957 dnl Some systems have a non-ANSI linker that doesn't pull in modules that have
2958 dnl only data (i.e., no functions), for example NeXT.  On those systems we'll
2959 dnl have to provide wrappers for global tables to ensure they're linked
2960 dnl properly.
2961 AC_DEFUN([CF_LINK_DATAONLY],
2962 [
2963 AC_MSG_CHECKING([if data-only library module links])
2964 AC_CACHE_VAL(cf_cv_link_dataonly,[
2965         rm -f conftest.a
2966         cat >conftest.$ac_ext <<EOF
2967 #line __oline__ "configure"
2968 int     testdata[[3]] = { 123, 456, 789 };
2969 EOF
2970         if AC_TRY_EVAL(ac_compile) ; then
2971                 mv conftest.o data.o && \
2972                 ( $AR $ARFLAGS conftest.a data.o ) 2>&AC_FD_CC 1>/dev/null
2973         fi
2974         rm -f conftest.$ac_ext data.o
2975         cat >conftest.$ac_ext <<EOF
2976 #line __oline__ "configure"
2977 int     testfunc()
2978 {
2979 #if defined(NeXT)
2980         ${cf_cv_main_return:-return}(1);        /* I'm told this linker is broken */
2981 #else
2982         extern int testdata[[3]];
2983         return testdata[[0]] == 123
2984            &&  testdata[[1]] == 456
2985            &&  testdata[[2]] == 789;
2986 #endif
2987 }
2988 EOF
2989         if AC_TRY_EVAL(ac_compile); then
2990                 mv conftest.o func.o && \
2991                 ( $AR $ARFLAGS conftest.a func.o ) 2>&AC_FD_CC 1>/dev/null
2992         fi
2993         rm -f conftest.$ac_ext func.o
2994         ( eval $RANLIB conftest.a ) 2>&AC_FD_CC >/dev/null
2995         cf_saveLIBS="$LIBS"
2996         LIBS="conftest.a $LIBS"
2997         AC_TRY_RUN([
2998         int main()
2999         {
3000                 extern int testfunc();
3001                 ${cf_cv_main_return:-return} (!testfunc());
3002         }
3003         ],
3004         [cf_cv_link_dataonly=yes],
3005         [cf_cv_link_dataonly=no],
3006         [cf_cv_link_dataonly=unknown])
3007         LIBS="$cf_saveLIBS"
3008         ])
3009 AC_MSG_RESULT($cf_cv_link_dataonly)
3010
3011 if test "$cf_cv_link_dataonly" = no ; then
3012         AC_DEFINE(BROKEN_LINKER)
3013         BROKEN_LINKER=1
3014 fi
3015
3016 ])dnl
3017 dnl ---------------------------------------------------------------------------
3018 dnl CF_LINK_FUNCS version: 7 updated: 2006/12/16 12:33:30
3019 dnl -------------
3020 dnl Most Unix systems have both link and symlink, a few don't have symlink.
3021 dnl A few non-Unix systems implement symlink, but not link.
3022 dnl A few non-systems implement neither (or have nonfunctional versions).
3023 AC_DEFUN([CF_LINK_FUNCS],
3024 [
3025 AC_CHECK_FUNCS( \
3026         remove \
3027         unlink )
3028
3029 if test "$cross_compiling" = yes ; then
3030         AC_CHECK_FUNCS( \
3031                 link \
3032                 symlink )
3033 else
3034         AC_CACHE_CHECK(if link/symlink functions work,cf_cv_link_funcs,[
3035                 cf_cv_link_funcs=
3036                 for cf_func in link symlink ; do
3037                         AC_TRY_RUN([
3038 #include <sys/types.h>
3039 #include <sys/stat.h>
3040 #ifdef HAVE_UNISTD_H
3041 #include <unistd.h>
3042 #endif
3043 int main()
3044 {
3045         int fail = 0;
3046         char *src = "config.log";
3047         char *dst = "conftest.chk";
3048         struct stat src_sb;
3049         struct stat dst_sb;
3050
3051         stat(src, &src_sb);
3052         fail = ($cf_func("config.log", "conftest.chk") < 0)
3053             || (stat(dst, &dst_sb) < 0)
3054             || (dst_sb.st_mtime != src_sb.st_mtime);
3055 #ifdef HAVE_UNLINK
3056         unlink(dst);
3057 #else
3058         remove(dst);
3059 #endif
3060         ${cf_cv_main_return:-return} (fail);
3061 }
3062                         ],[
3063                         cf_cv_link_funcs="$cf_cv_link_funcs $cf_func"
3064                         eval 'ac_cv_func_'$cf_func'=yes'],[
3065                         eval 'ac_cv_func_'$cf_func'=no'],[
3066                         eval 'ac_cv_func_'$cf_func'=error'])
3067                 done
3068                 test -z "$cf_cv_link_funcs" && cf_cv_link_funcs=no
3069         ])
3070         test "$ac_cv_func_link"    = yes && AC_DEFINE(HAVE_LINK)
3071         test "$ac_cv_func_symlink" = yes && AC_DEFINE(HAVE_SYMLINK)
3072 fi
3073 ])dnl
3074 dnl ---------------------------------------------------------------------------
3075 dnl CF_MAIN_RETURN version: 1 updated: 2006/12/10 09:51:54
3076 dnl --------------
3077 dnl Check if a return from main to the shell actually returns the same exit
3078 dnl code.  This is true for almost any POSIX environment.
3079 dnl
3080 dnl Some very old environments did not flush stdout, etc., on an exit.  That
3081 dnl would be a useful case to test for also.
3082 AC_DEFUN([CF_MAIN_RETURN],
3083 [
3084 cf_cv_main_return=return
3085 ])dnl
3086 dnl ---------------------------------------------------------------------------
3087 dnl CF_MAKEFLAGS version: 12 updated: 2006/10/21 08:27:03
3088 dnl ------------
3089 dnl Some 'make' programs support ${MAKEFLAGS}, some ${MFLAGS}, to pass 'make'
3090 dnl options to lower-levels.  It's very useful for "make -n" -- if we have it.
3091 dnl (GNU 'make' does both, something POSIX 'make', which happens to make the
3092 dnl ${MAKEFLAGS} variable incompatible because it adds the assignments :-)
3093 AC_DEFUN([CF_MAKEFLAGS],
3094 [
3095 AC_CACHE_CHECK(for makeflags variable, cf_cv_makeflags,[
3096         cf_cv_makeflags=''
3097         for cf_option in '-${MAKEFLAGS}' '${MFLAGS}'
3098         do
3099                 cat >cf_makeflags.tmp <<CF_EOF
3100 SHELL = /bin/sh
3101 all :
3102         @ echo '.$cf_option'
3103 CF_EOF
3104                 cf_result=`${MAKE-make} -k -f cf_makeflags.tmp 2>/dev/null | sed -e 's,[[       ]]*$,,'`
3105                 case "$cf_result" in
3106                 .*k)
3107                         cf_result=`${MAKE-make} -k -f cf_makeflags.tmp CC=cc 2>/dev/null`
3108                         case "$cf_result" in
3109                         .*CC=*) cf_cv_makeflags=
3110                                 ;;
3111                         *)      cf_cv_makeflags=$cf_option
3112                                 ;;
3113                         esac
3114                         break
3115                         ;;
3116                 .-)     ;;
3117                 *)      echo "given option \"$cf_option\", no match \"$cf_result\""
3118                         ;;
3119                 esac
3120         done
3121         rm -f cf_makeflags.tmp
3122 ])
3123
3124 AC_SUBST(cf_cv_makeflags)
3125 ])dnl
3126 dnl ---------------------------------------------------------------------------
3127 dnl CF_MAKE_TAGS version: 2 updated: 2000/10/04 09:18:40
3128 dnl ------------
3129 dnl Generate tags/TAGS targets for makefiles.  Do not generate TAGS if we have
3130 dnl a monocase filesystem.
3131 AC_DEFUN([CF_MAKE_TAGS],[
3132 AC_REQUIRE([CF_MIXEDCASE_FILENAMES])
3133 AC_CHECK_PROG(MAKE_LOWER_TAGS, ctags, yes, no)
3134
3135 if test "$cf_cv_mixedcase" = yes ; then
3136         AC_CHECK_PROG(MAKE_UPPER_TAGS, etags, yes, no)
3137 else
3138         MAKE_UPPER_TAGS=no
3139 fi
3140
3141 if test "$MAKE_UPPER_TAGS" = yes ; then
3142         MAKE_UPPER_TAGS=
3143 else
3144         MAKE_UPPER_TAGS="#"
3145 fi
3146 AC_SUBST(MAKE_UPPER_TAGS)
3147
3148 if test "$MAKE_LOWER_TAGS" = yes ; then
3149         MAKE_LOWER_TAGS=
3150 else
3151         MAKE_LOWER_TAGS="#"
3152 fi
3153 AC_SUBST(MAKE_LOWER_TAGS)
3154 ])dnl
3155 dnl ---------------------------------------------------------------------------
3156 dnl CF_MANPAGE_FORMAT version: 8 updated: 2009/01/11 20:30:50
3157 dnl -----------------
3158 dnl Option to allow user to override automatic configuration of manpage format.
3159 dnl There are several special cases:
3160 dnl
3161 dnl     gzip - man checks for, can display gzip'd files
3162 dnl     compress - man checks for, can display compressed files
3163 dnl     BSDI - files in the cat-directories are suffixed ".0"
3164 dnl     formatted - installer should format (put files in cat-directory)
3165 dnl     catonly - installer should only format, e.g., for a turnkey system.
3166 dnl
3167 dnl There are other configurations which this macro does not test, e.g., HPUX's
3168 dnl compressed manpages (but uncompressed manpages are fine, and HPUX's naming
3169 dnl convention would not match our use).
3170 AC_DEFUN([CF_MANPAGE_FORMAT],
3171 [
3172 AC_REQUIRE([CF_PATHSEP])
3173 AC_MSG_CHECKING(format of man-pages)
3174
3175 AC_ARG_WITH(manpage-format,
3176         [  --with-manpage-format   specify manpage-format: gzip/compress/BSDI/normal and
3177                           optionally formatted/catonly, e.g., gzip,formatted],
3178         [MANPAGE_FORMAT=$withval],
3179         [MANPAGE_FORMAT=unknown])
3180
3181 test -z "$MANPAGE_FORMAT" && MANPAGE_FORMAT=unknown
3182 MANPAGE_FORMAT=`echo "$MANPAGE_FORMAT" | sed -e 's/,/ /g'`
3183
3184 cf_unknown=
3185
3186 case $MANPAGE_FORMAT in
3187 unknown)
3188   if test -z "$MANPATH" ; then
3189     MANPATH="/usr/man:/usr/share/man"
3190   fi
3191
3192   # look for the 'date' man-page (it's most likely to be installed!)
3193   MANPAGE_FORMAT=
3194   cf_preform=no
3195   cf_catonly=yes
3196   cf_example=date
3197
3198   IFS="${IFS=   }"; ac_save_ifs="$IFS"; IFS="${IFS}${PATH_SEPARATOR}"
3199   for cf_dir in $MANPATH; do
3200     test -z "$cf_dir" && cf_dir=/usr/man
3201     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
3202     do
3203       cf_test=`echo $cf_name | sed -e 's/*//'`
3204       if test "x$cf_test" = "x$cf_name" ; then
3205
3206         case "$cf_name" in
3207         *.gz) MANPAGE_FORMAT="$MANPAGE_FORMAT gzip";;
3208         *.Z)  MANPAGE_FORMAT="$MANPAGE_FORMAT compress";;
3209         *.0)    MANPAGE_FORMAT="$MANPAGE_FORMAT BSDI";;
3210         *)    MANPAGE_FORMAT="$MANPAGE_FORMAT normal";;
3211         esac
3212
3213         case "$cf_name" in
3214         $cf_dir/man*)
3215           cf_catonly=no
3216           ;;
3217         $cf_dir/cat*)
3218           cf_preform=yes
3219           ;;
3220         esac
3221         break
3222       fi
3223
3224       # if we found a match in either man* or cat*, stop looking
3225       if test -n "$MANPAGE_FORMAT" ; then
3226         cf_found=no
3227         test "$cf_preform" = yes && MANPAGE_FORMAT="$MANPAGE_FORMAT formatted"
3228         test "$cf_catonly" = yes && MANPAGE_FORMAT="$MANPAGE_FORMAT catonly"
3229         case "$cf_name" in
3230         $cf_dir/cat*)
3231           cf_found=yes
3232           ;;
3233         esac
3234         test $cf_found=yes && break
3235       fi
3236     done
3237     # only check the first directory in $MANPATH where we find manpages
3238     if test -n "$MANPAGE_FORMAT" ; then
3239        break
3240     fi
3241   done
3242   # if we did not find the example, just assume it is normal
3243   test -z "$MANPAGE_FORMAT" && MANPAGE_FORMAT=normal
3244   IFS="$ac_save_ifs"
3245   ;;
3246 *)
3247   for cf_option in $MANPAGE_FORMAT; do
3248      case $cf_option in #(vi
3249      gzip|compress|BSDI|normal|formatted|catonly)
3250        ;;
3251      *)
3252        cf_unknown="$cf_unknown $cf_option"
3253        ;;
3254      esac
3255   done
3256   ;;
3257 esac
3258
3259 AC_MSG_RESULT($MANPAGE_FORMAT)
3260 if test -n "$cf_unknown" ; then
3261   AC_MSG_WARN(Unexpected manpage-format $cf_unknown)
3262 fi
3263 ])dnl
3264 dnl ---------------------------------------------------------------------------
3265 dnl CF_MANPAGE_RENAMES version: 7 updated: 2005/06/18 18:51:57
3266 dnl ------------------
3267 dnl The Debian people have their own naming convention for manpages.  This
3268 dnl option lets us override the name of the file containing renaming, or
3269 dnl disable it altogether.
3270 AC_DEFUN([CF_MANPAGE_RENAMES],
3271 [
3272 AC_MSG_CHECKING(for manpage renaming)
3273
3274 AC_ARG_WITH(manpage-renames,
3275         [  --with-manpage-renames  specify manpage-renaming],
3276         [MANPAGE_RENAMES=$withval],
3277         [MANPAGE_RENAMES=yes])
3278
3279 case ".$MANPAGE_RENAMES" in #(vi
3280 .no) #(vi
3281   ;;
3282 .|.yes)
3283   # Debian 'man' program?
3284   if test -f /etc/debian_version ; then
3285     MANPAGE_RENAMES=`cd $srcdir && pwd`/man/man_db.renames
3286   else
3287     MANPAGE_RENAMES=no
3288   fi
3289   ;;
3290 esac
3291
3292 if test "$MANPAGE_RENAMES" != no ; then
3293   if test -f $srcdir/man/$MANPAGE_RENAMES ; then
3294     MANPAGE_RENAMES=`cd $srcdir/man && pwd`/$MANPAGE_RENAMES
3295   elif test ! -f $MANPAGE_RENAMES ; then
3296     AC_MSG_ERROR(not a filename: $MANPAGE_RENAMES)
3297   fi
3298
3299   test ! -d man && mkdir man
3300
3301   # Construct a sed-script to perform renaming within man-pages
3302   if test -n "$MANPAGE_RENAMES" ; then
3303     test ! -d man && mkdir man
3304     sh $srcdir/man/make_sed.sh $MANPAGE_RENAMES >./edit_man.sed
3305   fi
3306 fi
3307
3308 AC_MSG_RESULT($MANPAGE_RENAMES)
3309 AC_SUBST(MANPAGE_RENAMES)
3310 ])dnl
3311 dnl ---------------------------------------------------------------------------
3312 dnl CF_MANPAGE_SYMLINKS version: 4 updated: 2003/12/13 18:01:58
3313 dnl -------------------
3314 dnl Some people expect each tool to make all aliases for manpages in the
3315 dnl man-directory.  This accommodates the older, less-capable implementations
3316 dnl of 'man', and is optional.
3317 AC_DEFUN([CF_MANPAGE_SYMLINKS],
3318 [
3319 AC_MSG_CHECKING(if manpage aliases will be installed)
3320
3321 AC_ARG_WITH(manpage-aliases,
3322         [  --with-manpage-aliases  specify manpage-aliases using .so],
3323         [MANPAGE_ALIASES=$withval],
3324         [MANPAGE_ALIASES=yes])
3325
3326 AC_MSG_RESULT($MANPAGE_ALIASES)
3327
3328 if test "$LN_S" = "ln -s"; then
3329         cf_use_symlinks=yes
3330 else
3331         cf_use_symlinks=no
3332 fi
3333
3334 MANPAGE_SYMLINKS=no
3335 if test "$MANPAGE_ALIASES" = yes ; then
3336 AC_MSG_CHECKING(if manpage symlinks should be used)
3337
3338 AC_ARG_WITH(manpage-symlinks,
3339         [  --with-manpage-symlinks specify manpage-aliases using symlinks],
3340         [MANPAGE_SYMLINKS=$withval],
3341         [MANPAGE_SYMLINKS=$cf_use_symlinks])
3342
3343 if test "$$cf_use_symlinks" = no; then
3344 if test "$MANPAGE_SYMLINKS" = yes ; then
3345         AC_MSG_WARN(cannot make symlinks, will use .so files)
3346         MANPAGE_SYMLINKS=no
3347 fi
3348 fi
3349
3350 AC_MSG_RESULT($MANPAGE_SYMLINKS)
3351 fi
3352
3353 ])dnl
3354 dnl ---------------------------------------------------------------------------
3355 dnl CF_MANPAGE_TBL version: 3 updated: 2002/01/19 22:51:32
3356 dnl --------------
3357 dnl This option causes manpages to be run through tbl(1) to generate tables
3358 dnl correctly.
3359 AC_DEFUN([CF_MANPAGE_TBL],
3360 [
3361 AC_MSG_CHECKING(for manpage tbl)
3362
3363 AC_ARG_WITH(manpage-tbl,
3364         [  --with-manpage-tbl      specify manpage processing with tbl],
3365         [MANPAGE_TBL=$withval],
3366         [MANPAGE_TBL=no])
3367
3368 AC_MSG_RESULT($MANPAGE_TBL)
3369 ])dnl
3370 dnl ---------------------------------------------------------------------------
3371 dnl CF_MAN_PAGES version: 36 updated: 2010/03/13 13:41:01
3372 dnl ------------
3373 dnl Try to determine if the man-pages on the system are compressed, and if
3374 dnl so, what format is used.  Use this information to construct a script that
3375 dnl will install man-pages.
3376 AC_DEFUN([CF_MAN_PAGES],
3377 [
3378 CF_HELP_MESSAGE(Options to Specify How Manpages are Installed:)
3379 CF_MANPAGE_FORMAT
3380 CF_MANPAGE_RENAMES
3381 CF_MANPAGE_SYMLINKS
3382 CF_MANPAGE_TBL
3383
3384   if test "$prefix" = "NONE" ; then
3385      cf_prefix="$ac_default_prefix"
3386   else
3387      cf_prefix="$prefix"
3388   fi
3389
3390   case "$MANPAGE_FORMAT" in # (vi
3391   *catonly*) # (vi
3392     cf_format=yes
3393     cf_inboth=no
3394     ;;
3395   *formatted*) # (vi
3396     cf_format=yes
3397     cf_inboth=yes
3398     ;;
3399   *)
3400     cf_format=no
3401     cf_inboth=no
3402     ;;
3403   esac
3404
3405 test ! -d man && mkdir man
3406
3407 cf_so_strip=
3408 cf_compress=
3409 case "$MANPAGE_FORMAT" in #(vi
3410 *compress*) #(vi
3411         cf_so_strip="Z"
3412         cf_compress=compress
3413   ;;
3414 *gzip*) #(vi
3415         cf_so_strip="gz"
3416         cf_compress=gzip
3417   ;;
3418 esac
3419
3420 cf_edit_man=./edit_man.sh
3421 cf_man_alias=`pwd`/man_alias.sed
3422
3423 cat >$cf_edit_man <<CF_EOF
3424 #! /bin/sh
3425 # this script is generated by the configure-script CF_MAN_PAGES macro.
3426
3427 prefix="$cf_prefix"
3428 datadir="$datadir"
3429
3430 NCURSES_MAJOR="$NCURSES_MAJOR"
3431 NCURSES_MINOR="$NCURSES_MINOR"
3432 NCURSES_PATCH="$NCURSES_PATCH"
3433
3434 NCURSES_OSPEED="$NCURSES_OSPEED"
3435 TERMINFO="$TERMINFO"
3436
3437 MKDIRS="sh `cd $srcdir && pwd`/mkdirs.sh"
3438
3439 INSTALL="$INSTALL"
3440 INSTALL_DATA="$INSTALL_DATA"
3441
3442 transform="$program_transform_name"
3443
3444 TMP=\${TMPDIR-/tmp}/man\$\$
3445 trap "rm -f \$TMP" 0 1 2 5 15
3446
3447 form=\[$]1
3448 shift || exit 1
3449
3450 verb=\[$]1
3451 shift || exit 1
3452
3453 mandir=\[$]1
3454 shift || exit 1
3455
3456 srcdir=\[$]1
3457 top_srcdir=\[$]srcdir/..
3458 shift || exit 1
3459
3460 if test "\$form" = normal ; then
3461         if test "$cf_format" = yes ; then
3462         if test "$cf_inboth" = no ; then
3463                 sh \[$]0 format \$verb \$mandir \$srcdir \[$]*
3464                 exit $?
3465         fi
3466         fi
3467         cf_subdir=\$mandir/man
3468         cf_tables=$MANPAGE_TBL
3469 else
3470         cf_subdir=\$mandir/cat
3471         cf_tables=yes
3472 fi
3473
3474 # process the list of source-files
3475 for i in \[$]* ; do
3476 case \$i in #(vi
3477 *.orig|*.rej) ;; #(vi
3478 *.[[0-9]]*)
3479         section=\`expr "\$i" : '.*\\.\\([[0-9]]\\)[[xm]]*'\`;
3480         if test \$verb = installing ; then
3481         if test ! -d \$cf_subdir\${section} ; then
3482                 \$MKDIRS \$cf_subdir\$section
3483         fi
3484         fi
3485
3486         # replace variables in man page
3487         if test ! -f $cf_man_alias ; then
3488 cat >>$cf_man_alias <<-CF_EOF2
3489                 s,@DATADIR@,\$datadir,g
3490                 s,@TERMINFO@,\$TERMINFO,g
3491                 s,@NCURSES_MAJOR@,\$NCURSES_MAJOR,g
3492                 s,@NCURSES_MINOR@,\$NCURSES_MINOR,g
3493                 s,@NCURSES_PATCH@,\$NCURSES_PATCH,g
3494                 s,@NCURSES_OSPEED@,\$NCURSES_OSPEED,g
3495 CF_EOF
3496         ifelse($1,,,[
3497         for cf_name in $1
3498         do
3499                 cf_NAME=`echo "$cf_name" | sed y%abcdefghijklmnopqrstuvwxyz./-%ABCDEFGHIJKLMNOPQRSTUVWXYZ___%`
3500                 cf_name=`echo $cf_name|sed "$program_transform_name"`
3501 cat >>$cf_edit_man <<-CF_EOF
3502                 s,@$cf_NAME@,$cf_name,g
3503 CF_EOF
3504         done
3505         ])
3506 cat >>$cf_edit_man <<CF_EOF
3507 CF_EOF2
3508                 echo "...made $cf_man_alias"
3509         fi
3510
3511         aliases=
3512         cf_source=\`basename \$i\`
3513         inalias=\$cf_source
3514         test ! -f \$inalias && inalias="\$srcdir/\$inalias"
3515         if test ! -f \$inalias ; then
3516                 echo .. skipped \$cf_source
3517                 continue
3518         fi
3519 CF_EOF
3520
3521 if test "$MANPAGE_ALIASES" != no ; then
3522 cat >>$cf_edit_man <<CF_EOF
3523         aliases=\`sed -f \$top_srcdir/man/manlinks.sed \$inalias |sed -f $cf_man_alias | sort -u\`
3524 CF_EOF
3525 fi
3526
3527 if test "$MANPAGE_RENAMES" = no ; then
3528 cat >>$cf_edit_man <<CF_EOF
3529         # perform program transformations for section 1 man pages
3530         if test \$section = 1 ; then
3531                 cf_target=\$cf_subdir\${section}/\`echo \$cf_source|sed "\${transform}"\`
3532         else
3533                 cf_target=\$cf_subdir\${section}/\$cf_source
3534         fi
3535 CF_EOF
3536 else
3537 cat >>$cf_edit_man <<CF_EOF
3538         cf_target=\`grep "^\$cf_source" $MANPAGE_RENAMES | $AWK '{print \[$]2}'\`
3539         if test -z "\$cf_target" ; then
3540                 echo '? missing rename for '\$cf_source
3541                 cf_target="\$cf_source"
3542         fi
3543         cf_target="\$cf_subdir\${section}/\${cf_target}"
3544
3545 CF_EOF
3546 fi
3547
3548 cat >>$cf_edit_man <<CF_EOF
3549         sed     -f $cf_man_alias \\
3550 CF_EOF
3551
3552 if test -f $MANPAGE_RENAMES ; then
3553 cat >>$cf_edit_man <<CF_EOF
3554                 < \$i | sed -f `pwd`/edit_man.sed >\$TMP
3555 CF_EOF
3556 else
3557 cat >>$cf_edit_man <<CF_EOF
3558                 < \$i >\$TMP
3559 CF_EOF
3560 fi
3561
3562 cat >>$cf_edit_man <<CF_EOF
3563 if test \$cf_tables = yes ; then
3564         tbl \$TMP >\$TMP.out
3565         mv \$TMP.out \$TMP
3566 fi
3567 CF_EOF
3568
3569 if test $with_curses_h != yes ; then
3570 cat >>$cf_edit_man <<CF_EOF
3571         sed -e "/\#[    ]*include/s,curses.h,ncurses.h," < \$TMP >\$TMP.out
3572         mv \$TMP.out \$TMP
3573 CF_EOF
3574 fi
3575
3576 cat >>$cf_edit_man <<CF_EOF
3577         if test \$form = format ; then
3578                 nroff -man \$TMP >\$TMP.out
3579                 mv \$TMP.out \$TMP
3580         fi
3581 CF_EOF
3582
3583 if test -n "$cf_compress" ; then
3584 cat >>$cf_edit_man <<CF_EOF
3585         if test \$verb = installing ; then
3586         if ( $cf_compress -f \$TMP )
3587         then
3588                 mv \$TMP.$cf_so_strip \$TMP
3589         fi
3590         fi
3591         cf_target="\$cf_target.$cf_so_strip"
3592 CF_EOF
3593 fi
3594
3595 case "$MANPAGE_FORMAT" in #(vi
3596 *BSDI*)
3597 cat >>$cf_edit_man <<CF_EOF
3598         if test \$form = format ; then
3599                 # BSDI installs only .0 suffixes in the cat directories
3600                 cf_target="\`echo \$cf_target|sed -e 's/\.[[1-9]]\+[[a-z]]*/.0/'\`"
3601         fi
3602 CF_EOF
3603   ;;
3604 esac
3605
3606 cat >>$cf_edit_man <<CF_EOF
3607         suffix=\`basename \$cf_target | sed -e 's%^[[^.]]*%%'\`
3608         if test \$verb = installing ; then
3609                 echo \$verb \$cf_target
3610                 \$INSTALL_DATA \$TMP \$cf_target
3611                 test -d \$cf_subdir\${section} &&
3612                 test -n "\$aliases" && (
3613                         cd \$cf_subdir\${section} && (
3614                                 cf_source=\`echo \$cf_target |sed -e 's%^.*/\([[^/]][[^/]]*/[[^/]][[^/]]*$\)%\1%'\`
3615                                 test -n "$cf_so_strip" && cf_source=\`echo \$cf_source |sed -e 's%\.$cf_so_strip\$%%'\`
3616                                 cf_target=\`basename \$cf_target\`
3617                                 for cf_alias in \$aliases
3618                                 do
3619                                         if test \$section = 1 ; then
3620                                                 cf_alias=\`echo \$cf_alias|sed "\${transform}"\`
3621                                         fi
3622
3623                                         if test "$MANPAGE_SYMLINKS" = yes ; then
3624                                                 if test -f \$cf_alias\${suffix} ; then
3625                                                         if ( cmp -s \$cf_target \$cf_alias\${suffix} )
3626                                                         then
3627                                                                 continue
3628                                                         fi
3629                                                 fi
3630                                                 echo .. \$verb alias \$cf_alias\${suffix}
3631                                                 rm -f \$cf_alias\${suffix}
3632                                                 $LN_S \$cf_target \$cf_alias\${suffix}
3633                                         elif test "\$cf_target" != "\$cf_alias\${suffix}" ; then
3634                                                 echo ".so \$cf_source" >\$TMP
3635 CF_EOF
3636 if test -n "$cf_compress" ; then
3637 cat >>$cf_edit_man <<CF_EOF
3638                                                 if test -n "$cf_so_strip" ; then
3639                                                         $cf_compress -f \$TMP
3640                                                         mv \$TMP.$cf_so_strip \$TMP
3641                                                 fi
3642 CF_EOF
3643 fi
3644 cat >>$cf_edit_man <<CF_EOF
3645                                                 echo .. \$verb alias \$cf_alias\${suffix}
3646                                                 rm -f \$cf_alias\${suffix}
3647                                                 \$INSTALL_DATA \$TMP \$cf_alias\${suffix}
3648                                         fi
3649                                 done
3650                         )
3651                 )
3652         elif test \$verb = removing ; then
3653                 test -f \$cf_target && (
3654                         echo \$verb \$cf_target
3655                         rm -f \$cf_target
3656                 )
3657                 test -d \$cf_subdir\${section} &&
3658                 test -n "\$aliases" && (
3659                         cd \$cf_subdir\${section} && (
3660                                 for cf_alias in \$aliases
3661                                 do
3662                                         if test \$section = 1 ; then
3663                                                 cf_alias=\`echo \$cf_alias|sed "\${transform}"\`
3664                                         fi
3665
3666                                         echo .. \$verb alias \$cf_alias\${suffix}
3667                                         rm -f \$cf_alias\${suffix}
3668                                 done
3669                         )
3670                 )
3671         else
3672 #               echo ".hy 0"
3673                 cat \$TMP
3674         fi
3675         ;;
3676 esac
3677 done
3678
3679 if test $cf_inboth = yes ; then
3680 if test \$form != format ; then
3681         sh \[$]0 format \$verb \$mandir \$srcdir \[$]*
3682 fi
3683 fi
3684
3685 exit 0
3686 CF_EOF
3687 chmod 755 $cf_edit_man
3688
3689 ])dnl
3690 dnl ---------------------------------------------------------------------------
3691 dnl CF_MATH_LIB version: 6 updated: 2009/12/19 13:46:49
3692 dnl -----------
3693 dnl Checks for libraries.  At least one UNIX system, Apple Macintosh
3694 dnl Rhapsody 5.5, does not have -lm.  We cannot use the simpler
3695 dnl AC_CHECK_LIB(m,sin), because that fails for C++.
3696 AC_DEFUN([CF_MATH_LIB],
3697 [
3698 AC_CACHE_CHECK(if -lm needed for math functions,
3699         cf_cv_need_libm,[
3700         AC_TRY_LINK([
3701         #include <stdio.h>
3702         #include <math.h>
3703         ],
3704         [double x = rand(); printf("result = %g\n", ]ifelse($2,,sin(x),$2)[)],
3705         [cf_cv_need_libm=no],
3706         [cf_cv_need_libm=yes])])
3707 if test "$cf_cv_need_libm" = yes
3708 then
3709 ifelse($1,,[
3710         LIBS="-lm $LIBS"
3711 ],[$1=-lm])
3712 fi
3713 ])
3714 dnl ---------------------------------------------------------------------------
3715 dnl CF_MIXEDCASE_FILENAMES version: 3 updated: 2003/09/20 17:07:55
3716 dnl ----------------------
3717 dnl Check if the file-system supports mixed-case filenames.  If we're able to
3718 dnl create a lowercase name and see it as uppercase, it doesn't support that.
3719 AC_DEFUN([CF_MIXEDCASE_FILENAMES],
3720 [
3721 AC_CACHE_CHECK(if filesystem supports mixed-case filenames,cf_cv_mixedcase,[
3722 if test "$cross_compiling" = yes ; then
3723         case $target_alias in #(vi
3724         *-os2-emx*|*-msdosdjgpp*|*-cygwin*|*-mingw32*|*-uwin*) #(vi
3725                 cf_cv_mixedcase=no
3726                 ;;
3727         *)
3728                 cf_cv_mixedcase=yes
3729                 ;;
3730         esac
3731 else
3732         rm -f conftest CONFTEST
3733         echo test >conftest
3734         if test -f CONFTEST ; then
3735                 cf_cv_mixedcase=no
3736         else
3737                 cf_cv_mixedcase=yes
3738         fi
3739         rm -f conftest CONFTEST
3740 fi
3741 ])
3742 test "$cf_cv_mixedcase" = yes && AC_DEFINE(MIXEDCASE_FILENAMES)
3743 ])dnl
3744 dnl ---------------------------------------------------------------------------
3745 dnl CF_MKSTEMP version: 5 updated: 2006/12/16 12:33:30
3746 dnl ----------
3747 dnl Check for a working mkstemp.  This creates two files, checks that they are
3748 dnl successfully created and distinct (AmigaOS apparently fails on the last).
3749 AC_DEFUN([CF_MKSTEMP],[
3750 AC_CACHE_CHECK(for working mkstemp, cf_cv_func_mkstemp,[
3751 rm -f conftest*
3752 AC_TRY_RUN([
3753 #include <sys/types.h>
3754 #include <stdlib.h>
3755 #include <stdio.h>
3756 #include <string.h>
3757 #include <sys/stat.h>
3758 int main()
3759 {
3760         char *tmpl = "conftestXXXXXX";
3761         char name[2][80];
3762         int n;
3763         int result = 0;
3764         int fd;