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