b27fb9a5147a96661d8408a218b027d5f2aff1c4
[ncurses.git] / Ada95 / aclocal.m4
1 dnl***************************************************************************
2 dnl Copyright (c) 2010,2011 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
30 dnl
31 dnl $Id: aclocal.m4,v 1.22 2011/03/24 00:31:33 tom Exp $
32 dnl Macros used in NCURSES Ada95 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 CF_ADA_INCLUDE_DIRS version: 6 updated: 2010/02/26 19:52:07
43 dnl -------------------
44 dnl Construct the list of include-options for the C programs in the Ada95
45 dnl binding.
46 AC_DEFUN([CF_ADA_INCLUDE_DIRS],
47 [
48 ACPPFLAGS="-I. -I../include -I../../include $ACPPFLAGS"
49 if test "$srcdir" != "."; then
50         ACPPFLAGS="-I\${srcdir}/../../include $ACPPFLAGS"
51 fi
52 if test "$GCC" != yes; then
53         ACPPFLAGS="$ACPPFLAGS -I\${includedir}"
54 elif test "$includedir" != "/usr/include"; then
55         if test "$includedir" = '${prefix}/include' ; then
56                 if test $prefix != /usr ; then
57                         ACPPFLAGS="$ACPPFLAGS -I\${includedir}"
58                 fi
59         else
60                 ACPPFLAGS="$ACPPFLAGS -I\${includedir}"
61         fi
62 fi
63 AC_SUBST(ACPPFLAGS)
64 ])dnl
65 dnl ---------------------------------------------------------------------------
66 dnl CF_ADD_ADAFLAGS version: 1 updated: 2010/06/19 15:22:18
67 dnl ---------------
68 dnl Add to $ADAFLAGS, which is substituted into makefile and scripts.
69 AC_DEFUN([CF_ADD_ADAFLAGS],[
70         ADAFLAGS="$ADAFLAGS $1"
71         AC_SUBST(ADAFLAGS)
72 ])dnl
73 dnl ---------------------------------------------------------------------------
74 dnl CF_ADD_CFLAGS version: 10 updated: 2010/05/26 05:38:42
75 dnl -------------
76 dnl Copy non-preprocessor flags to $CFLAGS, preprocessor flags to $CPPFLAGS
77 dnl The second parameter if given makes this macro verbose.
78 dnl
79 dnl Put any preprocessor definitions that use quoted strings in $EXTRA_CPPFLAGS,
80 dnl to simplify use of $CPPFLAGS in compiler checks, etc., that are easily
81 dnl confused by the quotes (which require backslashes to keep them usable).
82 AC_DEFUN([CF_ADD_CFLAGS],
83 [
84 cf_fix_cppflags=no
85 cf_new_cflags=
86 cf_new_cppflags=
87 cf_new_extra_cppflags=
88
89 for cf_add_cflags in $1
90 do
91 case $cf_fix_cppflags in
92 no)
93         case $cf_add_cflags in #(vi
94         -undef|-nostdinc*|-I*|-D*|-U*|-E|-P|-C) #(vi
95                 case $cf_add_cflags in
96                 -D*)
97                         cf_tst_cflags=`echo ${cf_add_cflags} |sed -e 's/^-D[[^=]]*='\''\"[[^"]]*//'`
98
99                         test "${cf_add_cflags}" != "${cf_tst_cflags}" \
100                                 && test -z "${cf_tst_cflags}" \
101                                 && cf_fix_cppflags=yes
102
103                         if test $cf_fix_cppflags = yes ; then
104                                 cf_new_extra_cppflags="$cf_new_extra_cppflags $cf_add_cflags"
105                                 continue
106                         elif test "${cf_tst_cflags}" = "\"'" ; then
107                                 cf_new_extra_cppflags="$cf_new_extra_cppflags $cf_add_cflags"
108                                 continue
109                         fi
110                         ;;
111                 esac
112                 case "$CPPFLAGS" in
113                 *$cf_add_cflags) #(vi
114                         ;;
115                 *) #(vi
116                         case $cf_add_cflags in #(vi
117                         -D*)
118                                 cf_tst_cppflags=`echo "x$cf_add_cflags" | sed -e 's/^...//' -e 's/=.*//'`
119                                 CF_REMOVE_DEFINE(CPPFLAGS,$CPPFLAGS,$cf_tst_cppflags)
120                                 ;;
121                         esac
122                         cf_new_cppflags="$cf_new_cppflags $cf_add_cflags"
123                         ;;
124                 esac
125                 ;;
126         *)
127                 cf_new_cflags="$cf_new_cflags $cf_add_cflags"
128                 ;;
129         esac
130         ;;
131 yes)
132         cf_new_extra_cppflags="$cf_new_extra_cppflags $cf_add_cflags"
133
134         cf_tst_cflags=`echo ${cf_add_cflags} |sed -e 's/^[[^"]]*"'\''//'`
135
136         test "${cf_add_cflags}" != "${cf_tst_cflags}" \
137                 && test -z "${cf_tst_cflags}" \
138                 && cf_fix_cppflags=no
139         ;;
140 esac
141 done
142
143 if test -n "$cf_new_cflags" ; then
144         ifelse([$2],,,[CF_VERBOSE(add to \$CFLAGS $cf_new_cflags)])
145         CFLAGS="$CFLAGS $cf_new_cflags"
146 fi
147
148 if test -n "$cf_new_cppflags" ; then
149         ifelse([$2],,,[CF_VERBOSE(add to \$CPPFLAGS $cf_new_cppflags)])
150         CPPFLAGS="$CPPFLAGS $cf_new_cppflags"
151 fi
152
153 if test -n "$cf_new_extra_cppflags" ; then
154         ifelse([$2],,,[CF_VERBOSE(add to \$EXTRA_CPPFLAGS $cf_new_extra_cppflags)])
155         EXTRA_CPPFLAGS="$cf_new_extra_cppflags $EXTRA_CPPFLAGS"
156 fi
157
158 AC_SUBST(EXTRA_CPPFLAGS)
159
160 ])dnl
161 dnl ---------------------------------------------------------------------------
162 dnl CF_ADD_INCDIR version: 13 updated: 2010/05/26 16:44:57
163 dnl -------------
164 dnl Add an include-directory to $CPPFLAGS.  Don't add /usr/include, since it's
165 dnl redundant.  We don't normally need to add -I/usr/local/include for gcc,
166 dnl but old versions (and some misinstalled ones) need that.  To make things
167 dnl worse, gcc 3.x may give error messages if -I/usr/local/include is added to
168 dnl the include-path).
169 AC_DEFUN([CF_ADD_INCDIR],
170 [
171 if test -n "$1" ; then
172   for cf_add_incdir in $1
173   do
174         while test $cf_add_incdir != /usr/include
175         do
176           if test -d $cf_add_incdir
177           then
178                 cf_have_incdir=no
179                 if test -n "$CFLAGS$CPPFLAGS" ; then
180                   # a loop is needed to ensure we can add subdirs of existing dirs
181                   for cf_test_incdir in $CFLAGS $CPPFLAGS ; do
182                         if test ".$cf_test_incdir" = ".-I$cf_add_incdir" ; then
183                           cf_have_incdir=yes; break
184                         fi
185                   done
186                 fi
187
188                 if test "$cf_have_incdir" = no ; then
189                   if test "$cf_add_incdir" = /usr/local/include ; then
190                         if test "$GCC" = yes
191                         then
192                           cf_save_CPPFLAGS=$CPPFLAGS
193                           CPPFLAGS="$CPPFLAGS -I$cf_add_incdir"
194                           AC_TRY_COMPILE([#include <stdio.h>],
195                                   [printf("Hello")],
196                                   [],
197                                   [cf_have_incdir=yes])
198                           CPPFLAGS=$cf_save_CPPFLAGS
199                         fi
200                   fi
201                 fi
202
203                 if test "$cf_have_incdir" = no ; then
204                   CF_VERBOSE(adding $cf_add_incdir to include-path)
205                   ifelse([$2],,CPPFLAGS,[$2])="$ifelse([$2],,CPPFLAGS,[$2]) -I$cf_add_incdir"
206
207                   cf_top_incdir=`echo $cf_add_incdir | sed -e 's%/include/.*$%/include%'`
208                   test "$cf_top_incdir" = "$cf_add_incdir" && break
209                   cf_add_incdir="$cf_top_incdir"
210                 else
211                   break
212                 fi
213           fi
214         done
215   done
216 fi
217 ])dnl
218 dnl ---------------------------------------------------------------------------
219 dnl CF_ADD_LIB version: 2 updated: 2010/06/02 05:03:05
220 dnl ----------
221 dnl Add a library, used to enforce consistency.
222 dnl
223 dnl $1 = library to add, without the "-l"
224 dnl $2 = variable to update (default $LIBS)
225 AC_DEFUN([CF_ADD_LIB],[CF_ADD_LIBS(-l$1,ifelse($2,,LIBS,[$2]))])dnl
226 dnl ---------------------------------------------------------------------------
227 dnl CF_ADD_LIBDIR version: 9 updated: 2010/05/26 16:44:57
228 dnl -------------
229 dnl     Adds to the library-path
230 dnl
231 dnl     Some machines have trouble with multiple -L options.
232 dnl
233 dnl $1 is the (list of) directory(s) to add
234 dnl $2 is the optional name of the variable to update (default LDFLAGS)
235 dnl
236 AC_DEFUN([CF_ADD_LIBDIR],
237 [
238 if test -n "$1" ; then
239   for cf_add_libdir in $1
240   do
241     if test $cf_add_libdir = /usr/lib ; then
242       :
243     elif test -d $cf_add_libdir
244     then
245       cf_have_libdir=no
246       if test -n "$LDFLAGS$LIBS" ; then
247         # a loop is needed to ensure we can add subdirs of existing dirs
248         for cf_test_libdir in $LDFLAGS $LIBS ; do
249           if test ".$cf_test_libdir" = ".-L$cf_add_libdir" ; then
250             cf_have_libdir=yes; break
251           fi
252         done
253       fi
254       if test "$cf_have_libdir" = no ; then
255         CF_VERBOSE(adding $cf_add_libdir to library-path)
256         ifelse([$2],,LDFLAGS,[$2])="-L$cf_add_libdir $ifelse([$2],,LDFLAGS,[$2])"
257       fi
258     fi
259   done
260 fi
261 ])dnl
262 dnl ---------------------------------------------------------------------------
263 dnl CF_ADD_LIBS version: 1 updated: 2010/06/02 05:03:05
264 dnl -----------
265 dnl Add one or more libraries, used to enforce consistency.
266 dnl
267 dnl $1 = libraries to add, with the "-l", etc.
268 dnl $2 = variable to update (default $LIBS)
269 AC_DEFUN([CF_ADD_LIBS],[ifelse($2,,LIBS,[$2])="$1 [$]ifelse($2,,LIBS,[$2])"])dnl
270 dnl ---------------------------------------------------------------------------
271 dnl CF_ADD_SUBDIR_PATH version: 3 updated: 2010/07/03 20:58:12
272 dnl ------------------
273 dnl Append to a search-list for a nonstandard header/lib-file
274 dnl     $1 = the variable to return as result
275 dnl     $2 = the package name
276 dnl     $3 = the subdirectory, e.g., bin, include or lib
277 dnl $4 = the directory under which we will test for subdirectories
278 dnl $5 = a directory that we do not want $4 to match
279 AC_DEFUN([CF_ADD_SUBDIR_PATH],
280 [
281 test "$4" != "$5" && \
282 test -d "$4" && \
283 ifelse([$5],NONE,,[(test $5 = NONE || test "$4" != "$5") &&]) {
284         test -n "$verbose" && echo "    ... testing for $3-directories under $4"
285         test -d $4/$3 &&          $1="[$]$1 $4/$3"
286         test -d $4/$3/$2 &&       $1="[$]$1 $4/$3/$2"
287         test -d $4/$3/$2/$3 &&    $1="[$]$1 $4/$3/$2/$3"
288         test -d $4/$2/$3 &&       $1="[$]$1 $4/$2/$3"
289         test -d $4/$2/$3/$2 &&    $1="[$]$1 $4/$2/$3/$2"
290 }
291 ])dnl
292 dnl ---------------------------------------------------------------------------
293 dnl CF_ANSI_CC_CHECK version: 10 updated: 2010/10/23 15:52:32
294 dnl ----------------
295 dnl This is adapted from the macros 'fp_PROG_CC_STDC' and 'fp_C_PROTOTYPES'
296 dnl in the sharutils 4.2 distribution.
297 AC_DEFUN([CF_ANSI_CC_CHECK],
298 [
299 AC_CACHE_CHECK(for ${CC:-cc} option to accept ANSI C, cf_cv_ansi_cc,[
300 cf_cv_ansi_cc=no
301 cf_save_CFLAGS="$CFLAGS"
302 cf_save_CPPFLAGS="$CPPFLAGS"
303 # Don't try gcc -ansi; that turns off useful extensions and
304 # breaks some systems' header files.
305 # AIX                   -qlanglvl=ansi
306 # Ultrix and OSF/1      -std1
307 # HP-UX                 -Aa -D_HPUX_SOURCE
308 # SVR4                  -Xc
309 # UnixWare 1.2          (cannot use -Xc, since ANSI/POSIX clashes)
310 for cf_arg in "-DCC_HAS_PROTOS" \
311         "" \
312         -qlanglvl=ansi \
313         -std1 \
314         -Ae \
315         "-Aa -D_HPUX_SOURCE" \
316         -Xc
317 do
318         CF_ADD_CFLAGS($cf_arg)
319         AC_TRY_COMPILE(
320 [
321 #ifndef CC_HAS_PROTOS
322 #if !defined(__STDC__) || (__STDC__ != 1)
323 choke me
324 #endif
325 #endif
326 ],[
327         int test (int i, double x);
328         struct s1 {int (*f) (int a);};
329         struct s2 {int (*f) (double a);};],
330         [cf_cv_ansi_cc="$cf_arg"; break])
331 done
332 CFLAGS="$cf_save_CFLAGS"
333 CPPFLAGS="$cf_save_CPPFLAGS"
334 ])
335
336 if test "$cf_cv_ansi_cc" != "no"; then
337 if test ".$cf_cv_ansi_cc" != ".-DCC_HAS_PROTOS"; then
338         CF_ADD_CFLAGS($cf_cv_ansi_cc)
339 else
340         AC_DEFINE(CC_HAS_PROTOS)
341 fi
342 fi
343 ])dnl
344 dnl ---------------------------------------------------------------------------
345 dnl CF_ANSI_CC_REQD version: 4 updated: 2008/03/23 14:48:54
346 dnl ---------------
347 dnl For programs that must use an ANSI compiler, obtain compiler options that
348 dnl will make it recognize prototypes.  We'll do preprocessor checks in other
349 dnl macros, since tools such as unproto can fake prototypes, but only part of
350 dnl the preprocessor.
351 AC_DEFUN([CF_ANSI_CC_REQD],
352 [AC_REQUIRE([CF_ANSI_CC_CHECK])
353 if test "$cf_cv_ansi_cc" = "no"; then
354         AC_MSG_ERROR(
355 [Your compiler does not appear to recognize prototypes.
356 You have the following choices:
357         a. adjust your compiler options
358         b. get an up-to-date compiler
359         c. use a wrapper such as unproto])
360 fi
361 ])dnl
362 dnl ---------------------------------------------------------------------------
363 dnl CF_AR_FLAGS version: 5 updated: 2010/05/20 20:24:29
364 dnl -----------
365 dnl Check for suitable "ar" (archiver) options for updating an archive.
366 AC_DEFUN([CF_AR_FLAGS],[
367 AC_REQUIRE([CF_PROG_AR])
368
369 AC_CACHE_CHECK(for options to update archives, cf_cv_ar_flags,[
370         cf_cv_ar_flags=unknown
371         for cf_ar_flags in -curv curv -crv crv -cqv cqv -rv rv
372         do
373
374                 # check if $ARFLAGS already contains this choice
375                 if test "x$ARFLAGS" != "x" ; then
376                         cf_check_ar_flags=`echo "x$ARFLAGS" | sed -e "s/$cf_ar_flags\$//" -e "s/$cf_ar_flags / /"`
377                         if test "x$ARFLAGS" != "$cf_check_ar_flags" ; then
378                                 cf_cv_ar_flags=
379                                 break
380                         fi
381                 fi
382
383                 rm -f conftest.$ac_cv_objext
384                 rm -f conftest.a
385
386                 cat >conftest.$ac_ext <<EOF
387 #line __oline__ "configure"
388 int     testdata[[3]] = { 123, 456, 789 };
389 EOF
390                 if AC_TRY_EVAL(ac_compile) ; then
391                         echo "$AR $ARFLAGS $cf_ar_flags conftest.a conftest.$ac_cv_objext" >&AC_FD_CC
392                         $AR $ARFLAGS $cf_ar_flags conftest.a conftest.$ac_cv_objext 2>&AC_FD_CC 1>/dev/null
393                         if test -f conftest.a ; then
394                                 cf_cv_ar_flags=$cf_ar_flags
395                                 break
396                         fi
397                 else
398                         CF_VERBOSE(cannot compile test-program)
399                         break
400                 fi
401         done
402         rm -f conftest.a conftest.$ac_ext conftest.$ac_cv_objext
403 ])
404
405 if test -n "$ARFLAGS" ; then
406         if test -n "$cf_cv_ar_flags" ; then
407                 ARFLAGS="$ARFLAGS $cf_cv_ar_flags"
408         fi
409 else
410         ARFLAGS=$cf_cv_ar_flags
411 fi
412
413 AC_SUBST(ARFLAGS)
414 ])
415 dnl ---------------------------------------------------------------------------
416 dnl CF_BUILD_CC version: 6 updated: 2006/10/14 15:23:15
417 dnl -----------
418 dnl If we're cross-compiling, allow the user to override the tools and their
419 dnl options.  The configure script is oriented toward identifying the host
420 dnl compiler, etc., but we need a build compiler to generate parts of the
421 dnl source.
422 dnl
423 dnl $1 = default for $CPPFLAGS
424 dnl $2 = default for $LIBS
425 AC_DEFUN([CF_BUILD_CC],[
426 AC_REQUIRE([CF_PROG_EXT])
427 if test "$cross_compiling" = yes ; then
428
429         # defaults that we might want to override
430         : ${BUILD_CFLAGS:=''}
431         : ${BUILD_CPPFLAGS:='ifelse([$1],,,[$1])'}
432         : ${BUILD_LDFLAGS:=''}
433         : ${BUILD_LIBS:='ifelse([$2],,,[$2])'}
434         : ${BUILD_EXEEXT:='$x'}
435         : ${BUILD_OBJEXT:='o'}
436
437         AC_ARG_WITH(build-cc,
438                 [  --with-build-cc=XXX     the build C compiler ($BUILD_CC)],
439                 [BUILD_CC="$withval"],
440                 [AC_CHECK_PROGS(BUILD_CC, gcc cc cl)])
441         AC_MSG_CHECKING(for native build C compiler)
442         AC_MSG_RESULT($BUILD_CC)
443
444         AC_MSG_CHECKING(for native build C preprocessor)
445         AC_ARG_WITH(build-cpp,
446                 [  --with-build-cpp=XXX    the build C preprocessor ($BUILD_CPP)],
447                 [BUILD_CPP="$withval"],
448                 [BUILD_CPP='${BUILD_CC} -E'])
449         AC_MSG_RESULT($BUILD_CPP)
450
451         AC_MSG_CHECKING(for native build C flags)
452         AC_ARG_WITH(build-cflags,
453                 [  --with-build-cflags=XXX the build C compiler-flags ($BUILD_CFLAGS)],
454                 [BUILD_CFLAGS="$withval"])
455         AC_MSG_RESULT($BUILD_CFLAGS)
456
457         AC_MSG_CHECKING(for native build C preprocessor-flags)
458         AC_ARG_WITH(build-cppflags,
459                 [  --with-build-cppflags=XXX the build C preprocessor-flags ($BUILD_CPPFLAGS)],
460                 [BUILD_CPPFLAGS="$withval"])
461         AC_MSG_RESULT($BUILD_CPPFLAGS)
462
463         AC_MSG_CHECKING(for native build linker-flags)
464         AC_ARG_WITH(build-ldflags,
465                 [  --with-build-ldflags=XXX the build linker-flags ($BUILD_LDFLAGS)],
466                 [BUILD_LDFLAGS="$withval"])
467         AC_MSG_RESULT($BUILD_LDFLAGS)
468
469         AC_MSG_CHECKING(for native build linker-libraries)
470         AC_ARG_WITH(build-libs,
471                 [  --with-build-libs=XXX   the build libraries (${BUILD_LIBS})],
472                 [BUILD_LIBS="$withval"])
473         AC_MSG_RESULT($BUILD_LIBS)
474
475         # this assumes we're on Unix.
476         BUILD_EXEEXT=
477         BUILD_OBJEXT=o
478
479         : ${BUILD_CC:='${CC}'}
480
481         if ( test "$BUILD_CC" = "$CC" || test "$BUILD_CC" = '${CC}' ) ; then
482                 AC_MSG_ERROR([Cross-build requires two compilers.
483 Use --with-build-cc to specify the native compiler.])
484         fi
485
486 else
487         : ${BUILD_CC:='${CC}'}
488         : ${BUILD_CPP:='${CPP}'}
489         : ${BUILD_CFLAGS:='${CFLAGS}'}
490         : ${BUILD_CPPFLAGS:='${CPPFLAGS}'}
491         : ${BUILD_LDFLAGS:='${LDFLAGS}'}
492         : ${BUILD_LIBS:='${LIBS}'}
493         : ${BUILD_EXEEXT:='$x'}
494         : ${BUILD_OBJEXT:='o'}
495 fi
496
497 AC_SUBST(BUILD_CC)
498 AC_SUBST(BUILD_CPP)
499 AC_SUBST(BUILD_CFLAGS)
500 AC_SUBST(BUILD_CPPFLAGS)
501 AC_SUBST(BUILD_LDFLAGS)
502 AC_SUBST(BUILD_LIBS)
503 AC_SUBST(BUILD_EXEEXT)
504 AC_SUBST(BUILD_OBJEXT)
505 ])dnl
506 dnl ---------------------------------------------------------------------------
507 dnl CF_CFG_DEFAULTS version: 7 updated: 2005/09/24 16:15:00
508 dnl ---------------
509 dnl Determine the default configuration into which we'll install ncurses.  This
510 dnl can be overridden by the user's command-line options.  There's two items to
511 dnl look for:
512 dnl     1. the prefix (e.g., /usr)
513 dnl     2. the header files (e.g., /usr/include/ncurses)
514 dnl We'll look for a previous installation of ncurses and use the same defaults.
515 dnl
516 dnl We don't use AC_PREFIX_DEFAULT, because it gets evaluated too soon, and
517 dnl we don't use AC_PREFIX_PROGRAM, because we cannot distinguish ncurses's
518 dnl programs from a vendor's.
519 AC_DEFUN([CF_CFG_DEFAULTS],
520 [
521 AC_MSG_CHECKING(for prefix)
522 if test "x$prefix" = "xNONE" ; then
523         case "$cf_cv_system_name" in
524                 # non-vendor systems don't have a conflict
525         openbsd*|freebsd*|linux*|cygwin*|k*bsd*-gnu)
526                 prefix=/usr
527                 ;;
528         *)      prefix=$ac_default_prefix
529                 ;;
530         esac
531 fi
532 AC_MSG_RESULT($prefix)
533
534 if test "x$prefix" = "xNONE" ; then
535 AC_MSG_CHECKING(for default include-directory)
536 test -n "$verbose" && echo 1>&AC_FD_MSG
537 for cf_symbol in \
538         $includedir \
539         $includedir/ncurses \
540         $prefix/include \
541         $prefix/include/ncurses \
542         /usr/local/include \
543         /usr/local/include/ncurses \
544         /usr/include \
545         /usr/include/ncurses
546 do
547         cf_dir=`eval echo $cf_symbol`
548         if test -f $cf_dir/curses.h ; then
549         if ( fgrep NCURSES_VERSION $cf_dir/curses.h 2>&1 >/dev/null ) ; then
550                 includedir="$cf_symbol"
551                 test -n "$verbose"  && echo $ac_n "     found " 1>&AC_FD_MSG
552                 break
553         fi
554         fi
555         test -n "$verbose"  && echo "   tested $cf_dir" 1>&AC_FD_MSG
556 done
557 AC_MSG_RESULT($includedir)
558 fi
559 ])dnl
560 dnl ---------------------------------------------------------------------------
561 dnl CF_CHECK_CACHE version: 11 updated: 2008/03/23 14:45:59
562 dnl --------------
563 dnl Check if we're accidentally using a cache from a different machine.
564 dnl Derive the system name, as a check for reusing the autoconf cache.
565 dnl
566 dnl If we've packaged config.guess and config.sub, run that (since it does a
567 dnl better job than uname).  Normally we'll use AC_CANONICAL_HOST, but allow
568 dnl an extra parameter that we may override, e.g., for AC_CANONICAL_SYSTEM
569 dnl which is useful in cross-compiles.
570 dnl
571 dnl Note: we would use $ac_config_sub, but that is one of the places where
572 dnl autoconf 2.5x broke compatibility with autoconf 2.13
573 AC_DEFUN([CF_CHECK_CACHE],
574 [
575 if test -f $srcdir/config.guess || test -f $ac_aux_dir/config.guess ; then
576         ifelse([$1],,[AC_CANONICAL_HOST],[$1])
577         system_name="$host_os"
578 else
579         system_name="`(uname -s -r) 2>/dev/null`"
580         if test -z "$system_name" ; then
581                 system_name="`(hostname) 2>/dev/null`"
582         fi
583 fi
584 test -n "$system_name" && AC_DEFINE_UNQUOTED(SYSTEM_NAME,"$system_name")
585 AC_CACHE_VAL(cf_cv_system_name,[cf_cv_system_name="$system_name"])
586
587 test -z "$system_name" && system_name="$cf_cv_system_name"
588 test -n "$cf_cv_system_name" && AC_MSG_RESULT(Configuring for $cf_cv_system_name)
589
590 if test ".$system_name" != ".$cf_cv_system_name" ; then
591         AC_MSG_RESULT(Cached system name ($system_name) does not agree with actual ($cf_cv_system_name))
592         AC_MSG_ERROR("Please remove config.cache and try again.")
593 fi
594 ])dnl
595 dnl ---------------------------------------------------------------------------
596 dnl CF_CURSES_HEADER version: 2 updated: 2010/04/28 06:02:16
597 dnl ----------------
598 dnl Find a "curses" header file, e.g,. "curses.h", or one of the more common
599 dnl variations of ncurses' installs.
600 dnl
601 dnl $1 = ncurses when looking for ncurses, or is empty
602 AC_DEFUN([CF_CURSES_HEADER],[
603 AC_CACHE_CHECK(if we have identified curses headers,cf_cv_ncurses_header,[
604 cf_cv_ncurses_header=none
605 for cf_header in ifelse($1,,,[ \
606     $1/curses.h \
607         $1/ncurses.h]) \
608         curses.h \
609         ncurses.h ifelse($1,,[ncurses/curses.h ncurses/ncurses.h])
610 do
611 AC_TRY_COMPILE([#include <${cf_header}>],
612         [initscr(); tgoto("?", 0,0)],
613         [cf_cv_ncurses_header=$cf_header; break],[])
614 done
615 ])
616
617 if test "$cf_cv_ncurses_header" = none ; then
618         AC_MSG_ERROR(No curses header-files found)
619 fi
620
621 # cheat, to get the right #define's for HAVE_NCURSES_H, etc.
622 AC_CHECK_HEADERS($cf_cv_ncurses_header)
623 ])dnl
624 dnl ---------------------------------------------------------------------------
625 dnl CF_DIRNAME version: 4 updated: 2002/12/21 19:25:52
626 dnl ----------
627 dnl "dirname" is not portable, so we fake it with a shell script.
628 AC_DEFUN([CF_DIRNAME],[$1=`echo $2 | sed -e 's%/[[^/]]*$%%'`])dnl
629 dnl ---------------------------------------------------------------------------
630 dnl CF_FIND_LIBRARY version: 9 updated: 2008/03/23 14:48:54
631 dnl ---------------
632 dnl Look for a non-standard library, given parameters for AC_TRY_LINK.  We
633 dnl prefer a standard location, and use -L options only if we do not find the
634 dnl library in the standard library location(s).
635 dnl     $1 = library name
636 dnl     $2 = library class, usually the same as library name
637 dnl     $3 = includes
638 dnl     $4 = code fragment to compile/link
639 dnl     $5 = corresponding function-name
640 dnl     $6 = flag, nonnull if failure should not cause an error-exit
641 dnl
642 dnl Sets the variable "$cf_libdir" as a side-effect, so we can see if we had
643 dnl to use a -L option.
644 AC_DEFUN([CF_FIND_LIBRARY],
645 [
646         eval 'cf_cv_have_lib_'$1'=no'
647         cf_libdir=""
648         AC_CHECK_FUNC($5,
649                 eval 'cf_cv_have_lib_'$1'=yes',[
650                 cf_save_LIBS="$LIBS"
651                 AC_MSG_CHECKING(for $5 in -l$1)
652                 LIBS="-l$1 $LIBS"
653                 AC_TRY_LINK([$3],[$4],
654                         [AC_MSG_RESULT(yes)
655                          eval 'cf_cv_have_lib_'$1'=yes'
656                         ],
657                         [AC_MSG_RESULT(no)
658                         CF_LIBRARY_PATH(cf_search,$2)
659                         for cf_libdir in $cf_search
660                         do
661                                 AC_MSG_CHECKING(for -l$1 in $cf_libdir)
662                                 LIBS="-L$cf_libdir -l$1 $cf_save_LIBS"
663                                 AC_TRY_LINK([$3],[$4],
664                                         [AC_MSG_RESULT(yes)
665                                          eval 'cf_cv_have_lib_'$1'=yes'
666                                          break],
667                                         [AC_MSG_RESULT(no)
668                                          LIBS="$cf_save_LIBS"])
669                         done
670                         ])
671                 ])
672 eval 'cf_found_library=[$]cf_cv_have_lib_'$1
673 ifelse($6,,[
674 if test $cf_found_library = no ; then
675         AC_MSG_ERROR(Cannot link $1 library)
676 fi
677 ])
678 ])dnl
679 dnl ---------------------------------------------------------------------------
680 dnl CF_FIND_LINKAGE version: 19 updated: 2010/05/29 16:31:02
681 dnl ---------------
682 dnl Find a library (specifically the linkage used in the code fragment),
683 dnl searching for it if it is not already in the library path.
684 dnl See also CF_ADD_SEARCHPATH.
685 dnl
686 dnl Parameters (4-on are optional):
687 dnl     $1 = headers for library entrypoint
688 dnl     $2 = code fragment for library entrypoint
689 dnl     $3 = the library name without the "-l" option or ".so" suffix.
690 dnl     $4 = action to perform if successful (default: update CPPFLAGS, etc)
691 dnl     $5 = action to perform if not successful
692 dnl     $6 = module name, if not the same as the library name
693 dnl     $7 = extra libraries
694 dnl
695 dnl Sets these variables:
696 dnl     $cf_cv_find_linkage_$3 - yes/no according to whether linkage is found
697 dnl     $cf_cv_header_path_$3 - include-directory if needed
698 dnl     $cf_cv_library_path_$3 - library-directory if needed
699 dnl     $cf_cv_library_file_$3 - library-file if needed, e.g., -l$3
700 AC_DEFUN([CF_FIND_LINKAGE],[
701
702 # If the linkage is not already in the $CPPFLAGS/$LDFLAGS configuration, these
703 # will be set on completion of the AC_TRY_LINK below.
704 cf_cv_header_path_$3=
705 cf_cv_library_path_$3=
706
707 CF_MSG_LOG([Starting [FIND_LINKAGE]($3,$6)])
708
709 cf_save_LIBS="$LIBS"
710
711 AC_TRY_LINK([$1],[$2],[
712         cf_cv_find_linkage_$3=yes
713         cf_cv_header_path_$3=/usr/include
714         cf_cv_library_path_$3=/usr/lib
715 ],[
716
717 LIBS="-l$3 $7 $cf_save_LIBS"
718
719 AC_TRY_LINK([$1],[$2],[
720         cf_cv_find_linkage_$3=yes
721         cf_cv_header_path_$3=/usr/include
722         cf_cv_library_path_$3=/usr/lib
723         cf_cv_library_file_$3="-l$3"
724 ],[
725         cf_cv_find_linkage_$3=no
726         LIBS="$cf_save_LIBS"
727
728     CF_VERBOSE(find linkage for $3 library)
729     CF_MSG_LOG([Searching for headers in [FIND_LINKAGE]($3,$6)])
730
731     cf_save_CPPFLAGS="$CPPFLAGS"
732     cf_test_CPPFLAGS="$CPPFLAGS"
733
734     CF_HEADER_PATH(cf_search,ifelse([$6],,[$3],[$6]))
735     for cf_cv_header_path_$3 in $cf_search
736     do
737       if test -d $cf_cv_header_path_$3 ; then
738         CF_VERBOSE(... testing $cf_cv_header_path_$3)
739         CPPFLAGS="$cf_save_CPPFLAGS -I$cf_cv_header_path_$3"
740         AC_TRY_COMPILE([$1],[$2],[
741             CF_VERBOSE(... found $3 headers in $cf_cv_header_path_$3)
742             cf_cv_find_linkage_$3=maybe
743             cf_test_CPPFLAGS="$CPPFLAGS"
744             break],[
745             CPPFLAGS="$cf_save_CPPFLAGS"
746             ])
747       fi
748     done
749
750     if test "$cf_cv_find_linkage_$3" = maybe ; then
751
752       CF_MSG_LOG([Searching for $3 library in [FIND_LINKAGE]($3,$6)])
753
754       cf_save_LIBS="$LIBS"
755       cf_save_LDFLAGS="$LDFLAGS"
756
757       ifelse([$6],,,[
758         CPPFLAGS="$cf_test_CPPFLAGS"
759         LIBS="-l$3 $7 $cf_save_LIBS"
760         AC_TRY_LINK([$1],[$2],[
761             CF_VERBOSE(... found $3 library in system)
762             cf_cv_find_linkage_$3=yes])
763             CPPFLAGS="$cf_save_CPPFLAGS"
764             LIBS="$cf_save_LIBS"
765             ])
766
767       if test "$cf_cv_find_linkage_$3" != yes ; then
768         CF_LIBRARY_PATH(cf_search,$3)
769         for cf_cv_library_path_$3 in $cf_search
770         do
771           if test -d $cf_cv_library_path_$3 ; then
772             CF_VERBOSE(... testing $cf_cv_library_path_$3)
773             CPPFLAGS="$cf_test_CPPFLAGS"
774             LIBS="-l$3 $7 $cf_save_LIBS"
775             LDFLAGS="$cf_save_LDFLAGS -L$cf_cv_library_path_$3"
776             AC_TRY_LINK([$1],[$2],[
777                 CF_VERBOSE(... found $3 library in $cf_cv_library_path_$3)
778                 cf_cv_find_linkage_$3=yes
779                 cf_cv_library_file_$3="-l$3"
780                 break],[
781                 CPPFLAGS="$cf_save_CPPFLAGS"
782                 LIBS="$cf_save_LIBS"
783                 LDFLAGS="$cf_save_LDFLAGS"
784                 ])
785           fi
786         done
787         CPPFLAGS="$cf_save_CPPFLAGS"
788         LDFLAGS="$cf_save_LDFLAGS"
789       fi
790
791     else
792       cf_cv_find_linkage_$3=no
793     fi
794     ],$7)
795 ])
796
797 LIBS="$cf_save_LIBS"
798
799 if test "$cf_cv_find_linkage_$3" = yes ; then
800 ifelse([$4],,[
801         CF_ADD_INCDIR($cf_cv_header_path_$3)
802         CF_ADD_LIBDIR($cf_cv_library_path_$3)
803         CF_ADD_LIB($3)
804 ],[$4])
805 else
806 ifelse([$5],,AC_MSG_WARN(Cannot find $3 library),[$5])
807 fi
808 ])dnl
809 dnl ---------------------------------------------------------------------------
810 dnl CF_GCC_ATTRIBUTES version: 14 updated: 2010/10/23 15:52:32
811 dnl -----------------
812 dnl Test for availability of useful gcc __attribute__ directives to quiet
813 dnl compiler warnings.  Though useful, not all are supported -- and contrary
814 dnl to documentation, unrecognized directives cause older compilers to barf.
815 AC_DEFUN([CF_GCC_ATTRIBUTES],
816 [
817 if test "$GCC" = yes
818 then
819 cat > conftest.i <<EOF
820 #ifndef GCC_PRINTF
821 #define GCC_PRINTF 0
822 #endif
823 #ifndef GCC_SCANF
824 #define GCC_SCANF 0
825 #endif
826 #ifndef GCC_NORETURN
827 #define GCC_NORETURN /* nothing */
828 #endif
829 #ifndef GCC_UNUSED
830 #define GCC_UNUSED /* nothing */
831 #endif
832 EOF
833 if test "$GCC" = yes
834 then
835         AC_CHECKING([for $CC __attribute__ directives])
836 cat > conftest.$ac_ext <<EOF
837 #line __oline__ "${as_me:-configure}"
838 #include "confdefs.h"
839 #include "conftest.h"
840 #include "conftest.i"
841 #if     GCC_PRINTF
842 #define GCC_PRINTFLIKE(fmt,var) __attribute__((format(printf,fmt,var)))
843 #else
844 #define GCC_PRINTFLIKE(fmt,var) /*nothing*/
845 #endif
846 #if     GCC_SCANF
847 #define GCC_SCANFLIKE(fmt,var)  __attribute__((format(scanf,fmt,var)))
848 #else
849 #define GCC_SCANFLIKE(fmt,var)  /*nothing*/
850 #endif
851 extern void wow(char *,...) GCC_SCANFLIKE(1,2);
852 extern void oops(char *,...) GCC_PRINTFLIKE(1,2) GCC_NORETURN;
853 extern void foo(void) GCC_NORETURN;
854 int main(int argc GCC_UNUSED, char *argv[[]] GCC_UNUSED) { return 0; }
855 EOF
856         cf_printf_attribute=no
857         cf_scanf_attribute=no
858         for cf_attribute in scanf printf unused noreturn
859         do
860                 CF_UPPER(cf_ATTRIBUTE,$cf_attribute)
861                 cf_directive="__attribute__(($cf_attribute))"
862                 echo "checking for $CC $cf_directive" 1>&AC_FD_CC
863
864                 case $cf_attribute in #(vi
865                 printf) #(vi
866                         cf_printf_attribute=yes
867                         cat >conftest.h <<EOF
868 #define GCC_$cf_ATTRIBUTE 1
869 EOF
870                         ;;
871                 scanf) #(vi
872                         cf_scanf_attribute=yes
873                         cat >conftest.h <<EOF
874 #define GCC_$cf_ATTRIBUTE 1
875 EOF
876                         ;;
877                 *) #(vi
878                         cat >conftest.h <<EOF
879 #define GCC_$cf_ATTRIBUTE $cf_directive
880 EOF
881                         ;;
882                 esac
883
884                 if AC_TRY_EVAL(ac_compile); then
885                         test -n "$verbose" && AC_MSG_RESULT(... $cf_attribute)
886                         cat conftest.h >>confdefs.h
887                         case $cf_attribute in #(vi
888                         printf) #(vi
889                                 if test "$cf_printf_attribute" = no ; then
890                                         cat >>confdefs.h <<EOF
891 #define GCC_PRINTFLIKE(fmt,var) /* nothing */
892 EOF
893                                 else
894                                         cat >>confdefs.h <<EOF
895 #define GCC_PRINTFLIKE(fmt,var) __attribute__((format(printf,fmt,var)))
896 EOF
897                                 fi
898                                 ;;
899                         scanf) #(vi
900                                 if test "$cf_scanf_attribute" = no ; then
901                                         cat >>confdefs.h <<EOF
902 #define GCC_SCANFLIKE(fmt,var) /* nothing */
903 EOF
904                                 else
905                                         cat >>confdefs.h <<EOF
906 #define GCC_SCANFLIKE(fmt,var)  __attribute__((format(scanf,fmt,var)))
907 EOF
908                                 fi
909                                 ;;
910                         esac
911                 fi
912         done
913 else
914         fgrep define conftest.i >>confdefs.h
915 fi
916 rm -rf conftest*
917 fi
918 ])dnl
919 dnl ---------------------------------------------------------------------------
920 dnl CF_GCC_VERSION version: 5 updated: 2010/04/24 11:02:31
921 dnl --------------
922 dnl Find version of gcc
923 AC_DEFUN([CF_GCC_VERSION],[
924 AC_REQUIRE([AC_PROG_CC])
925 GCC_VERSION=none
926 if test "$GCC" = yes ; then
927         AC_MSG_CHECKING(version of $CC)
928         GCC_VERSION="`${CC} --version 2>/dev/null | sed -e '2,$d' -e 's/^.*(GCC) //' -e 's/^[[^0-9.]]*//' -e 's/[[^0-9.]].*//'`"
929         test -z "$GCC_VERSION" && GCC_VERSION=unknown
930         AC_MSG_RESULT($GCC_VERSION)
931 fi
932 ])dnl
933 dnl ---------------------------------------------------------------------------
934 dnl CF_GCC_WARNINGS version: 27 updated: 2010/10/23 15:52:32
935 dnl ---------------
936 dnl Check if the compiler supports useful warning options.  There's a few that
937 dnl we don't use, simply because they're too noisy:
938 dnl
939 dnl     -Wconversion (useful in older versions of gcc, but not in gcc 2.7.x)
940 dnl     -Wredundant-decls (system headers make this too noisy)
941 dnl     -Wtraditional (combines too many unrelated messages, only a few useful)
942 dnl     -Wwrite-strings (too noisy, but should review occasionally).  This
943 dnl             is enabled for ncurses using "--enable-const".
944 dnl     -pedantic
945 dnl
946 dnl Parameter:
947 dnl     $1 is an optional list of gcc warning flags that a particular
948 dnl             application might want to use, e.g., "no-unused" for
949 dnl             -Wno-unused
950 dnl Special:
951 dnl     If $with_ext_const is "yes", add a check for -Wwrite-strings
952 dnl
953 AC_DEFUN([CF_GCC_WARNINGS],
954 [
955 AC_REQUIRE([CF_GCC_VERSION])
956 CF_INTEL_COMPILER(GCC,INTEL_COMPILER,CFLAGS)
957
958 cat > conftest.$ac_ext <<EOF
959 #line __oline__ "${as_me:-configure}"
960 int main(int argc, char *argv[[]]) { return (argv[[argc-1]] == 0) ; }
961 EOF
962
963 if test "$INTEL_COMPILER" = yes
964 then
965 # The "-wdXXX" options suppress warnings:
966 # remark #1419: external declaration in primary source file
967 # remark #1683: explicit conversion of a 64-bit integral type to a smaller integral type (potential portability problem)
968 # remark #1684: conversion from pointer to same-sized integral type (potential portability problem)
969 # remark #193: zero used for undefined preprocessing identifier
970 # remark #593: variable "curs_sb_left_arrow" was set but never used
971 # remark #810: conversion from "int" to "Dimension={unsigned short}" may lose significant bits
972 # remark #869: parameter "tw" was never referenced
973 # remark #981: operands are evaluated in unspecified order
974 # warning #279: controlling expression is constant
975
976         AC_CHECKING([for $CC warning options])
977         cf_save_CFLAGS="$CFLAGS"
978         EXTRA_CFLAGS="-Wall"
979         for cf_opt in \
980                 wd1419 \
981                 wd1683 \
982                 wd1684 \
983                 wd193 \
984                 wd593 \
985                 wd279 \
986                 wd810 \
987                 wd869 \
988                 wd981
989         do
990                 CFLAGS="$cf_save_CFLAGS $EXTRA_CFLAGS -$cf_opt"
991                 if AC_TRY_EVAL(ac_compile); then
992                         test -n "$verbose" && AC_MSG_RESULT(... -$cf_opt)
993                         EXTRA_CFLAGS="$EXTRA_CFLAGS -$cf_opt"
994                 fi
995         done
996         CFLAGS="$cf_save_CFLAGS"
997
998 elif test "$GCC" = yes
999 then
1000         AC_CHECKING([for $CC warning options])
1001         cf_save_CFLAGS="$CFLAGS"
1002         EXTRA_CFLAGS=
1003         cf_warn_CONST=""
1004         test "$with_ext_const" = yes && cf_warn_CONST="Wwrite-strings"
1005         for cf_opt in W Wall \
1006                 Wbad-function-cast \
1007                 Wcast-align \
1008                 Wcast-qual \
1009                 Winline \
1010                 Wmissing-declarations \
1011                 Wmissing-prototypes \
1012                 Wnested-externs \
1013                 Wpointer-arith \
1014                 Wshadow \
1015                 Wstrict-prototypes \
1016                 Wundef $cf_warn_CONST $1
1017         do
1018                 CFLAGS="$cf_save_CFLAGS $EXTRA_CFLAGS -$cf_opt"
1019                 if AC_TRY_EVAL(ac_compile); then
1020                         test -n "$verbose" && AC_MSG_RESULT(... -$cf_opt)
1021                         case $cf_opt in #(vi
1022                         Wcast-qual) #(vi
1023                                 CPPFLAGS="$CPPFLAGS -DXTSTRINGDEFINES"
1024                                 ;;
1025                         Winline) #(vi
1026                                 case $GCC_VERSION in
1027                                 [[34]].*)
1028                                         CF_VERBOSE(feature is broken in gcc $GCC_VERSION)
1029                                         continue;;
1030                                 esac
1031                                 ;;
1032                         esac
1033                         EXTRA_CFLAGS="$EXTRA_CFLAGS -$cf_opt"
1034                 fi
1035         done
1036         CFLAGS="$cf_save_CFLAGS"
1037 fi
1038 rm -rf conftest*
1039
1040 AC_SUBST(EXTRA_CFLAGS)
1041 ])dnl
1042 dnl ---------------------------------------------------------------------------
1043 dnl CF_GNAT_GENERICS version: 2 updated: 2011/03/23 20:24:41
1044 dnl ----------------
1045 AC_DEFUN([CF_GNAT_GENERICS],
1046 [
1047 AC_REQUIRE([CF_GNAT_VERSION])
1048
1049 AC_MSG_CHECKING(if GNAT supports generics)
1050 case $cf_gnat_version in #(vi
1051 3.[[1-9]]*|[[4-9]].*) #(vi
1052         cf_gnat_generics=yes
1053         ;;
1054 *)
1055         cf_gnat_generics=no
1056         ;;
1057 esac
1058 AC_MSG_RESULT($cf_gnat_generics)
1059
1060 if test "$cf_gnat_generics" = yes
1061 then
1062         cf_compile_generics=generics
1063         cf_generic_objects="\${GENOBJS}"
1064 else
1065         cf_compile_generics=
1066         cf_generic_objects=
1067 fi
1068
1069 AC_SUBST(cf_compile_generics)
1070 AC_SUBST(cf_generic_objects)
1071 ])dnl
1072 dnl ---------------------------------------------------------------------------
1073 dnl CF_GNAT_PRAGMA_UNREF version: 1 updated: 2010/06/19 15:22:18
1074 dnl --------------------
1075 dnl Check if the gnat pragma "Unreferenced" works.
1076 AC_DEFUN([CF_GNAT_PRAGMA_UNREF],[
1077 AC_CACHE_CHECK(if GNAT pragma Unreferenced works,cf_cv_pragma_unreferenced,[
1078 CF_GNAT_TRY_LINK([procedure conftest;],
1079 [with Text_IO;
1080 with GNAT.OS_Lib;
1081 procedure conftest is
1082    test : Integer;
1083    pragma Unreferenced (test);
1084 begin
1085    test := 1;
1086    Text_IO.Put ("Hello World");
1087    Text_IO.New_Line;
1088    GNAT.OS_Lib.OS_Exit (0);
1089 end conftest;],
1090         [cf_cv_pragma_unreferenced=yes],
1091         [cf_cv_pragma_unreferenced=no])])
1092
1093 # if the pragma is supported, use it (needed in the Trace code).
1094 if test $cf_cv_pragma_unreferenced = yes ; then
1095         PRAGMA_UNREF=TRUE
1096 else
1097         PRAGMA_UNREF=FALSE
1098 fi
1099 AC_SUBST(PRAGMA_UNREF)
1100 ])dnl
1101 dnl ---------------------------------------------------------------------------
1102 dnl CF_GNAT_PROJECTS version: 2 updated: 2011/03/23 20:24:41
1103 dnl ----------------
1104 dnl GNAT projects are configured with ".gpr" project files.
1105 dnl GNAT libraries are a further development, using the project feature.
1106 AC_DEFUN([CF_GNAT_PROJECTS],
1107 [
1108 AC_REQUIRE([CF_GNAT_VERSION])
1109
1110 cf_gnat_libraries=no
1111 cf_gnat_projects=no
1112
1113 AC_MSG_CHECKING(if GNAT supports project files)
1114 case $cf_gnat_version in #(vi
1115 3.[[0-9]]*) #(vi
1116         ;;
1117 *)
1118         case $cf_cv_system_name in #(vi
1119         cygwin*) #(vi
1120                 ;;
1121         *)
1122                 mkdir conftest.src conftest.bin conftest.lib
1123                 cd conftest.src
1124                 rm -rf conftest* *~conftest*
1125                 cat >>library.gpr <<CF_EOF
1126 project Library is
1127   Kind := External ("LIB_KIND");
1128   for Library_Name use "ConfTest";
1129   for Object_Dir use ".";
1130   for Library_ALI_Dir use External("LIBRARY_DIR");
1131   for Library_Version use External ("SONAME");
1132   for Library_Kind use Kind;
1133   for Library_Dir use External("BUILD_DIR");
1134   Source_Dir := External ("SOURCE_DIR");
1135   for Source_Dirs use (Source_Dir);
1136   package Compiler is
1137      for Default_Switches ("Ada") use
1138        ("-g",
1139         "-O2",
1140         "-gnatafno",
1141         "-gnatVa",   -- All validity checks
1142         "-gnatwa");  -- Activate all optional errors
1143   end Compiler;
1144 end Library;
1145 CF_EOF
1146                 cat >>confpackage.ads <<CF_EOF
1147 package ConfPackage is
1148    procedure conftest;
1149 end ConfPackage;
1150 CF_EOF
1151                 cat >>confpackage.adb <<CF_EOF
1152 with Text_IO;
1153 package body ConfPackage is
1154    procedure conftest is
1155    begin
1156       Text_IO.Put ("Hello World");
1157       Text_IO.New_Line;
1158    end conftest;
1159 end ConfPackage;
1160 CF_EOF
1161                 if ( $cf_ada_make $ADAFLAGS \
1162                                 -Plibrary.gpr \
1163                                 -XBUILD_DIR=`cd ../conftest.bin;pwd` \
1164                                 -XLIBRARY_DIR=`cd ../conftest.lib;pwd` \
1165                                 -XSOURCE_DIR=`pwd` \
1166                                 -XSONAME=libConfTest.so.1 \
1167                                 -XLIB_KIND=static 1>&AC_FD_CC 2>&1 ) ; then
1168                         cf_gnat_projects=yes
1169                 fi
1170                 cd ..
1171                 if test -f conftest.lib/confpackage.ali
1172                 then
1173                         cf_gnat_libraries=yes
1174                 fi
1175                 rm -rf conftest* *~conftest*
1176                 ;;
1177         esac
1178         ;;
1179 esac
1180 AC_MSG_RESULT($cf_gnat_projects)
1181
1182 if test $cf_gnat_projects = yes
1183 then
1184         AC_MSG_CHECKING(if GNAT supports libraries)
1185         AC_MSG_RESULT($cf_gnat_libraries)
1186 fi
1187
1188 if test "$cf_gnat_projects" = yes
1189 then
1190         USE_OLD_MAKERULES="#"
1191         USE_GNAT_PROJECTS=""
1192 else
1193         USE_OLD_MAKERULES=""
1194         USE_GNAT_PROJECTS="#"
1195 fi
1196
1197 if test "$cf_gnat_libraries" = yes
1198 then
1199         USE_GNAT_LIBRARIES=""
1200 else
1201         USE_GNAT_LIBRARIES="#"
1202 fi
1203
1204 AC_SUBST(USE_OLD_MAKERULES)
1205 AC_SUBST(USE_GNAT_PROJECTS)
1206 AC_SUBST(USE_GNAT_LIBRARIES)
1207 ])dnl
1208 dnl ---------------------------------------------------------------------------
1209 dnl CF_GNAT_TRY_LINK version: 3 updated: 2011/03/19 14:47:45
1210 dnl ----------------
1211 dnl Verify that a test program compiles/links with GNAT.
1212 dnl $cf_ada_make is set to the program that compiles/links
1213 dnl $ADAFLAGS may be set to the GNAT flags.
1214 dnl
1215 dnl $1 is the text of the spec
1216 dnl $2 is the text of the body
1217 dnl $3 is the shell command to execute if successful
1218 dnl $4 is the shell command to execute if not successful
1219 AC_DEFUN([CF_GNAT_TRY_LINK],
1220 [
1221 rm -rf conftest* *~conftest*
1222 cat >>conftest.ads <<CF_EOF
1223 $1
1224 CF_EOF
1225 cat >>conftest.adb <<CF_EOF
1226 $2
1227 CF_EOF
1228 if ( $cf_ada_make $ADAFLAGS conftest 1>&AC_FD_CC 2>&1 ) ; then
1229 ifelse($3,,      :,[      $3])
1230 ifelse($4,,,[else
1231    $4])
1232 fi
1233 rm -rf conftest* *~conftest*
1234 ])dnl
1235 dnl ---------------------------------------------------------------------------
1236 dnl CF_GNAT_TRY_RUN version: 5 updated: 2011/03/19 14:47:45
1237 dnl ---------------
1238 dnl Verify that a test program compiles and runs with GNAT
1239 dnl $cf_ada_make is set to the program that compiles/links
1240 dnl $ADAFLAGS may be set to the GNAT flags.
1241 dnl
1242 dnl $1 is the text of the spec
1243 dnl $2 is the text of the body
1244 dnl $3 is the shell command to execute if successful
1245 dnl $4 is the shell command to execute if not successful
1246 AC_DEFUN([CF_GNAT_TRY_RUN],
1247 [
1248 rm -rf conftest* *~conftest*
1249 cat >>conftest.ads <<CF_EOF
1250 $1
1251 CF_EOF
1252 cat >>conftest.adb <<CF_EOF
1253 $2
1254 CF_EOF
1255 if ( $cf_ada_make $ADAFLAGS conftest 1>&AC_FD_CC 2>&1 ) ; then
1256    if ( ./conftest 1>&AC_FD_CC 2>&1 ) ; then
1257 ifelse($3,,      :,[      $3])
1258 ifelse($4,,,[   else
1259       $4])
1260    fi
1261 ifelse($4,,,[else
1262    $4])
1263 fi
1264 rm -rf conftest* *~conftest*
1265 ])dnl
1266 dnl ---------------------------------------------------------------------------
1267 dnl CF_GNAT_VERSION version: 17 updated: 2011/03/23 20:24:41
1268 dnl ---------------
1269 dnl Verify version of GNAT.
1270 AC_DEFUN([CF_GNAT_VERSION],
1271 [
1272 AC_MSG_CHECKING(for gnat version)
1273 cf_gnat_version=`${cf_ada_make:-gnatmake} -v 2>&1 | \
1274         grep '[[0-9]].[[0-9]][[0-9]]*' |\
1275     sed -e '2,$d' -e 's/[[^0-9 \.]]//g' -e 's/^[[ ]]*//' -e 's/ .*//'`
1276 AC_MSG_RESULT($cf_gnat_version)
1277
1278 case $cf_gnat_version in #(vi
1279 3.1[[1-9]]*|3.[[2-9]]*|[[4-9]].*) #(vi
1280         cf_cv_prog_gnat_correct=yes
1281         ;;
1282 *)
1283         AC_MSG_WARN(Unsupported GNAT version $cf_gnat_version. We require 3.11 or better. Disabling Ada95 binding.)
1284         cf_cv_prog_gnat_correct=no
1285         ;;
1286 esac
1287 ])
1288 dnl ---------------------------------------------------------------------------
1289 dnl CF_GNU_SOURCE version: 6 updated: 2005/07/09 13:23:07
1290 dnl -------------
1291 dnl Check if we must define _GNU_SOURCE to get a reasonable value for
1292 dnl _XOPEN_SOURCE, upon which many POSIX definitions depend.  This is a defect
1293 dnl (or misfeature) of glibc2, which breaks portability of many applications,
1294 dnl since it is interwoven with GNU extensions.
1295 dnl
1296 dnl Well, yes we could work around it...
1297 AC_DEFUN([CF_GNU_SOURCE],
1298 [
1299 AC_CACHE_CHECK(if we must define _GNU_SOURCE,cf_cv_gnu_source,[
1300 AC_TRY_COMPILE([#include <sys/types.h>],[
1301 #ifndef _XOPEN_SOURCE
1302 make an error
1303 #endif],
1304         [cf_cv_gnu_source=no],
1305         [cf_save="$CPPFLAGS"
1306          CPPFLAGS="$CPPFLAGS -D_GNU_SOURCE"
1307          AC_TRY_COMPILE([#include <sys/types.h>],[
1308 #ifdef _XOPEN_SOURCE
1309 make an error
1310 #endif],
1311         [cf_cv_gnu_source=no],
1312         [cf_cv_gnu_source=yes])
1313         CPPFLAGS="$cf_save"
1314         ])
1315 ])
1316 test "$cf_cv_gnu_source" = yes && CPPFLAGS="$CPPFLAGS -D_GNU_SOURCE"
1317 ])dnl
1318 dnl ---------------------------------------------------------------------------
1319 dnl CF_HEADER_PATH version: 12 updated: 2010/05/05 05:22:40
1320 dnl --------------
1321 dnl Construct a search-list of directories for a nonstandard header-file
1322 dnl
1323 dnl Parameters
1324 dnl     $1 = the variable to return as result
1325 dnl     $2 = the package name
1326 AC_DEFUN([CF_HEADER_PATH],
1327 [
1328 $1=
1329
1330 # collect the current set of include-directories from compiler flags
1331 cf_header_path_list=""
1332 if test -n "${CFLAGS}${CPPFLAGS}" ; then
1333         for cf_header_path in $CPPFLAGS $CFLAGS
1334         do
1335                 case $cf_header_path in #(vi
1336                 -I*)
1337                         cf_header_path=`echo ".$cf_header_path" |sed -e 's/^...//' -e 's,/include$,,'`
1338                         CF_ADD_SUBDIR_PATH($1,$2,include,$cf_header_path,NONE)
1339                         cf_header_path_list="$cf_header_path_list [$]$1"
1340                         ;;
1341                 esac
1342         done
1343 fi
1344
1345 # add the variations for the package we are looking for
1346 CF_SUBDIR_PATH($1,$2,include)
1347
1348 test "$includedir" != NONE && \
1349 test "$includedir" != "/usr/include" && \
1350 test -d "$includedir" && {
1351         test -d $includedir &&    $1="[$]$1 $includedir"
1352         test -d $includedir/$2 && $1="[$]$1 $includedir/$2"
1353 }
1354
1355 test "$oldincludedir" != NONE && \
1356 test "$oldincludedir" != "/usr/include" && \
1357 test -d "$oldincludedir" && {
1358         test -d $oldincludedir    && $1="[$]$1 $oldincludedir"
1359         test -d $oldincludedir/$2 && $1="[$]$1 $oldincludedir/$2"
1360 }
1361
1362 $1="[$]$1 $cf_header_path_list"
1363 ])dnl
1364 dnl ---------------------------------------------------------------------------
1365 dnl CF_HELP_MESSAGE version: 3 updated: 1998/01/14 10:56:23
1366 dnl ---------------
1367 dnl Insert text into the help-message, for readability, from AC_ARG_WITH.
1368 AC_DEFUN([CF_HELP_MESSAGE],
1369 [AC_DIVERT_HELP([$1])dnl
1370 ])dnl
1371 dnl ---------------------------------------------------------------------------
1372 dnl CF_INCLUDE_DIRS version: 6 updated: 2009/01/06 19:37:40
1373 dnl ---------------
1374 dnl Construct the list of include-options according to whether we're building
1375 dnl in the source directory or using '--srcdir=DIR' option.  If we're building
1376 dnl with gcc, don't append the includedir if it happens to be /usr/include,
1377 dnl since that usually breaks gcc's shadow-includes.
1378 AC_DEFUN([CF_INCLUDE_DIRS],
1379 [
1380 CPPFLAGS="$CPPFLAGS -I. -I../include"
1381 if test "$srcdir" != "."; then
1382         CPPFLAGS="$CPPFLAGS -I\${srcdir}/../include"
1383 fi
1384 if test "$GCC" != yes; then
1385         CPPFLAGS="$CPPFLAGS -I\${includedir}"
1386 elif test "$includedir" != "/usr/include"; then
1387         if test "$includedir" = '${prefix}/include' ; then
1388                 if test $prefix != /usr ; then
1389                         CPPFLAGS="$CPPFLAGS -I\${includedir}"
1390                 fi
1391         else
1392                 CPPFLAGS="$CPPFLAGS -I\${includedir}"
1393         fi
1394 fi
1395 AC_SUBST(CPPFLAGS)
1396 ])dnl
1397 dnl ---------------------------------------------------------------------------
1398 dnl CF_INTEL_COMPILER version: 4 updated: 2010/05/26 05:38:42
1399 dnl -----------------
1400 dnl Check if the given compiler is really the Intel compiler for Linux.  It
1401 dnl tries to imitate gcc, but does not return an error when it finds a mismatch
1402 dnl between prototypes, e.g., as exercised by CF_MISSING_CHECK.
1403 dnl
1404 dnl This macro should be run "soon" after AC_PROG_CC or AC_PROG_CPLUSPLUS, to
1405 dnl ensure that it is not mistaken for gcc/g++.  It is normally invoked from
1406 dnl the wrappers for gcc and g++ warnings.
1407 dnl
1408 dnl $1 = GCC (default) or GXX
1409 dnl $2 = INTEL_COMPILER (default) or INTEL_CPLUSPLUS
1410 dnl $3 = CFLAGS (default) or CXXFLAGS
1411 AC_DEFUN([CF_INTEL_COMPILER],[
1412 ifelse([$2],,INTEL_COMPILER,[$2])=no
1413
1414 if test "$ifelse([$1],,[$1],GCC)" = yes ; then
1415         case $host_os in
1416         linux*|gnu*)
1417                 AC_MSG_CHECKING(if this is really Intel ifelse([$1],GXX,C++,C) compiler)
1418                 cf_save_CFLAGS="$ifelse([$3],,CFLAGS,[$3])"
1419                 ifelse([$3],,CFLAGS,[$3])="$ifelse([$3],,CFLAGS,[$3]) -no-gcc"
1420                 AC_TRY_COMPILE([],[
1421 #ifdef __INTEL_COMPILER
1422 #else
1423 make an error
1424 #endif
1425 ],[ifelse([$2],,INTEL_COMPILER,[$2])=yes
1426 cf_save_CFLAGS="$cf_save_CFLAGS -we147 -no-gcc"
1427 ],[])
1428                 ifelse([$3],,CFLAGS,[$3])="$cf_save_CFLAGS"
1429                 AC_MSG_RESULT($ifelse([$2],,INTEL_COMPILER,[$2]))
1430                 ;;
1431         esac
1432 fi
1433 ])dnl
1434 dnl ---------------------------------------------------------------------------
1435 dnl CF_LARGEFILE version: 7 updated: 2007/06/02 11:58:50
1436 dnl ------------
1437 dnl Add checks for large file support.
1438 AC_DEFUN([CF_LARGEFILE],[
1439 ifdef([AC_FUNC_FSEEKO],[
1440     AC_SYS_LARGEFILE
1441     if test "$enable_largefile" != no ; then
1442         AC_FUNC_FSEEKO
1443
1444         # Normally we would collect these definitions in the config.h,
1445         # but (like _XOPEN_SOURCE), some environments rely on having these
1446         # defined before any of the system headers are included.  Another
1447         # case comes up with C++, e.g., on AIX the compiler compiles the
1448         # header files by themselves before looking at the body files it is
1449         # told to compile.  For ncurses, those header files do not include
1450         # the config.h
1451         test "$ac_cv_sys_large_files"      != no && CPPFLAGS="$CPPFLAGS -D_LARGE_FILES "
1452         test "$ac_cv_sys_largefile_source" != no && CPPFLAGS="$CPPFLAGS -D_LARGEFILE_SOURCE "
1453         test "$ac_cv_sys_file_offset_bits" != no && CPPFLAGS="$CPPFLAGS -D_FILE_OFFSET_BITS=$ac_cv_sys_file_offset_bits "
1454
1455         AC_CACHE_CHECK(whether to use struct dirent64, cf_cv_struct_dirent64,[
1456                 AC_TRY_COMPILE([
1457 #include <sys/types.h>
1458 #include <dirent.h>
1459                 ],[
1460                 /* if transitional largefile support is setup, this is true */
1461                 extern struct dirent64 * readdir(DIR *);
1462                 struct dirent64 *x = readdir((DIR *)0);
1463                 struct dirent *y = readdir((DIR *)0);
1464                 int z = x - y;
1465                 ],
1466                 [cf_cv_struct_dirent64=yes],
1467                 [cf_cv_struct_dirent64=no])
1468         ])
1469         test "$cf_cv_struct_dirent64" = yes && AC_DEFINE(HAVE_STRUCT_DIRENT64)
1470     fi
1471 ])
1472 ])
1473 dnl ---------------------------------------------------------------------------
1474 dnl CF_LD_RPATH_OPT version: 3 updated: 2010/06/02 05:03:05
1475 dnl ---------------
1476 dnl For the given system and compiler, find the compiler flags to pass to the
1477 dnl loader to use the "rpath" feature.
1478 AC_DEFUN([CF_LD_RPATH_OPT],
1479 [
1480 AC_REQUIRE([CF_CHECK_CACHE])
1481
1482 LD_RPATH_OPT=
1483 AC_MSG_CHECKING(for an rpath option)
1484 case $cf_cv_system_name in #(vi
1485 irix*) #(vi
1486         if test "$GCC" = yes; then
1487                 LD_RPATH_OPT="-Wl,-rpath,"
1488         else
1489                 LD_RPATH_OPT="-rpath "
1490         fi
1491         ;;
1492 linux*|gnu*|k*bsd*-gnu) #(vi
1493         LD_RPATH_OPT="-Wl,-rpath,"
1494         ;;
1495 openbsd[[2-9]].*) #(vi
1496         LD_RPATH_OPT="-Wl,-rpath,"
1497         ;;
1498 freebsd*) #(vi
1499         LD_RPATH_OPT="-rpath "
1500         ;;
1501 netbsd*) #(vi
1502         LD_RPATH_OPT="-Wl,-rpath,"
1503         ;;
1504 osf*|mls+*) #(vi
1505         LD_RPATH_OPT="-rpath "
1506         ;;
1507 solaris2*) #(vi
1508         LD_RPATH_OPT="-R"
1509         ;;
1510 *)
1511         ;;
1512 esac
1513 AC_MSG_RESULT($LD_RPATH_OPT)
1514
1515 case "x$LD_RPATH_OPT" in #(vi
1516 x-R*)
1517         AC_MSG_CHECKING(if we need a space after rpath option)
1518         cf_save_LIBS="$LIBS"
1519         CF_ADD_LIBS(${LD_RPATH_OPT}$libdir)
1520         AC_TRY_LINK(, , cf_rpath_space=no, cf_rpath_space=yes)
1521         LIBS="$cf_save_LIBS"
1522         AC_MSG_RESULT($cf_rpath_space)
1523         test "$cf_rpath_space" = yes && LD_RPATH_OPT="$LD_RPATH_OPT "
1524         ;;
1525 esac
1526 ])dnl
1527 dnl ---------------------------------------------------------------------------
1528 dnl CF_LIBRARY_PATH version: 9 updated: 2010/03/28 12:52:50
1529 dnl ---------------
1530 dnl Construct a search-list of directories for a nonstandard library-file
1531 dnl
1532 dnl Parameters
1533 dnl     $1 = the variable to return as result
1534 dnl     $2 = the package name
1535 AC_DEFUN([CF_LIBRARY_PATH],
1536 [
1537 $1=
1538 cf_library_path_list=""
1539 if test -n "${LDFLAGS}${LIBS}" ; then
1540         for cf_library_path in $LDFLAGS $LIBS
1541         do
1542                 case $cf_library_path in #(vi
1543                 -L*)
1544                         cf_library_path=`echo ".$cf_library_path" |sed -e 's/^...//' -e 's,/lib$,,'`
1545                         CF_ADD_SUBDIR_PATH($1,$2,lib,$cf_library_path,NONE)
1546                         cf_library_path_list="$cf_library_path_list [$]$1"
1547                         ;;
1548                 esac
1549         done
1550 fi
1551
1552 CF_SUBDIR_PATH($1,$2,lib)
1553
1554 $1="$cf_library_path_list [$]$1"
1555 ])dnl
1556 dnl ---------------------------------------------------------------------------
1557 dnl CF_LIB_PREFIX version: 8 updated: 2008/09/13 11:34:16
1558 dnl -------------
1559 dnl Compute the library-prefix for the given host system
1560 dnl $1 = variable to set
1561 AC_DEFUN([CF_LIB_PREFIX],
1562 [
1563         case $cf_cv_system_name in #(vi
1564         OS/2*|os2*) #(vi
1565         LIB_PREFIX=''
1566         ;;
1567         *)      LIB_PREFIX='lib'
1568         ;;
1569         esac
1570 ifelse($1,,,[$1=$LIB_PREFIX])
1571         AC_SUBST(LIB_PREFIX)
1572 ])dnl
1573 dnl ---------------------------------------------------------------------------
1574 dnl CF_LIB_SONAME version: 5 updated: 2010/08/14 18:25:37
1575 dnl -------------
1576 dnl Find the and soname for the given shared library.  Set the cache variable
1577 dnl cf_cv_$3_soname to this, unless it is not found.  Then set the cache
1578 dnl variable to "unknown".
1579 dnl
1580 dnl $1 = headers
1581 dnl $2 = code
1582 dnl $3 = library name
1583 AC_DEFUN([CF_LIB_SONAME],
1584 [
1585 AC_CACHE_CHECK(for soname of $3 library,cf_cv_$3_soname,[
1586
1587 cf_cv_$3_soname=unknown
1588 if test "$cross_compiling" != yes ; then
1589 cat >conftest.$ac_ext <<CF_EOF
1590 $1
1591 int main()
1592 {
1593 $2
1594         ${cf_cv_main_return:-return}(0);
1595 }
1596 CF_EOF
1597 cf_save_LIBS="$LIBS"
1598         CF_ADD_LIB($3)
1599         if AC_TRY_EVAL(ac_compile) ; then
1600                 if AC_TRY_EVAL(ac_link) ; then
1601                         cf_cv_$3_soname=`ldd conftest$ac_exeext 2>/dev/null | sed -e 's,^.*/,,' -e 's, .*$,,' | fgrep lib$3.`
1602                         test -z "$cf_cv_$3_soname" && cf_cv_$3_soname=unknown
1603                 fi
1604         fi
1605 rm -rf conftest*
1606 LIBS="$cf_save_LIBS"
1607 fi
1608 ])
1609 ])
1610 dnl ---------------------------------------------------------------------------
1611 dnl CF_LIB_SUFFIX version: 16 updated: 2008/12/27 12:30:03
1612 dnl -------------
1613 dnl Compute the library file-suffix from the given model name
1614 dnl $1 = model name
1615 dnl $2 = variable to set (the nominal library suffix)
1616 dnl $3 = dependency variable to set (actual filename)
1617 dnl The variable $LIB_SUFFIX, if set, prepends the variable to set.
1618 AC_DEFUN([CF_LIB_SUFFIX],
1619 [
1620         AC_REQUIRE([CF_SUBST_NCURSES_VERSION])
1621         case $1 in #(vi
1622         libtool) #(vi
1623                 $2='.la'
1624                 $3=[$]$2
1625                 ;;
1626         normal) #(vi
1627                 $2='.a'
1628                 $3=[$]$2
1629                 ;;
1630         debug) #(vi
1631                 $2='_g.a'
1632                 $3=[$]$2
1633                 ;;
1634         profile) #(vi
1635                 $2='_p.a'
1636                 $3=[$]$2
1637                 ;;
1638         shared) #(vi
1639                 case $cf_cv_system_name in
1640                 aix[[56]]*) #(vi
1641                         $2='.a'
1642                         $3=[$]$2
1643                         ;;
1644                 cygwin*) #(vi
1645                         $2='.dll'
1646                         $3='.dll.a'
1647                         ;;
1648                 darwin*) #(vi
1649                         $2='.dylib'
1650                         $3=[$]$2
1651                         ;;
1652                 hpux*) #(vi
1653                         case $target in
1654                         ia64*) #(vi
1655                                 $2='.so'
1656                                 $3=[$]$2
1657                                 ;;
1658                         *) #(vi
1659                                 $2='.sl'
1660                                 $3=[$]$2
1661                                 ;;
1662                         esac
1663                         ;;
1664                 *)      $2='.so'
1665                         $3=[$]$2
1666                         ;;
1667                 esac
1668         esac
1669         test -n "$LIB_SUFFIX" && $2="${LIB_SUFFIX}[$]{$2}"
1670         test -n "$LIB_SUFFIX" && $3="${LIB_SUFFIX}[$]{$3}"
1671 ])dnl
1672 dnl ---------------------------------------------------------------------------
1673 dnl CF_LIB_TYPE version: 4 updated: 2000/10/20 22:57:49
1674 dnl -----------
1675 dnl Compute the string to append to -library from the given model name
1676 dnl $1 = model name
1677 dnl $2 = variable to set
1678 dnl The variable $LIB_SUFFIX, if set, prepends the variable to set.
1679 AC_DEFUN([CF_LIB_TYPE],
1680 [
1681         case $1 in
1682         libtool) $2=''   ;;
1683         normal)  $2=''   ;;
1684         debug)   $2='_g' ;;
1685         profile) $2='_p' ;;
1686         shared)  $2=''   ;;
1687         esac
1688         test -n "$LIB_SUFFIX" && $2="${LIB_SUFFIX}[$]{$2}"
1689 ])dnl
1690 dnl ---------------------------------------------------------------------------
1691 dnl CF_LINK_DATAONLY version: 9 updated: 2009/01/01 20:21:38
1692 dnl ----------------
1693 dnl Some systems have a non-ANSI linker that doesn't pull in modules that have
1694 dnl only data (i.e., no functions), for example NeXT.  On those systems we'll
1695 dnl have to provide wrappers for global tables to ensure they're linked
1696 dnl properly.
1697 AC_DEFUN([CF_LINK_DATAONLY],
1698 [
1699 AC_MSG_CHECKING([if data-only library module links])
1700 AC_CACHE_VAL(cf_cv_link_dataonly,[
1701         rm -f conftest.a
1702         cat >conftest.$ac_ext <<EOF
1703 #line __oline__ "configure"
1704 int     testdata[[3]] = { 123, 456, 789 };
1705 EOF
1706         if AC_TRY_EVAL(ac_compile) ; then
1707                 mv conftest.o data.o && \
1708                 ( $AR $ARFLAGS conftest.a data.o ) 2>&AC_FD_CC 1>/dev/null
1709         fi
1710         rm -f conftest.$ac_ext data.o
1711         cat >conftest.$ac_ext <<EOF
1712 #line __oline__ "configure"
1713 int     testfunc()
1714 {
1715 #if defined(NeXT)
1716         ${cf_cv_main_return:-return}(1);        /* I'm told this linker is broken */
1717 #else
1718         extern int testdata[[3]];
1719         return testdata[[0]] == 123
1720            &&  testdata[[1]] == 456
1721            &&  testdata[[2]] == 789;
1722 #endif
1723 }
1724 EOF
1725         if AC_TRY_EVAL(ac_compile); then
1726                 mv conftest.o func.o && \
1727                 ( $AR $ARFLAGS conftest.a func.o ) 2>&AC_FD_CC 1>/dev/null
1728         fi
1729         rm -f conftest.$ac_ext func.o
1730         ( eval $RANLIB conftest.a ) 2>&AC_FD_CC >/dev/null
1731         cf_saveLIBS="$LIBS"
1732         LIBS="conftest.a $LIBS"
1733         AC_TRY_RUN([
1734         int main()
1735         {
1736                 extern int testfunc();
1737                 ${cf_cv_main_return:-return} (!testfunc());
1738         }
1739         ],
1740         [cf_cv_link_dataonly=yes],
1741         [cf_cv_link_dataonly=no],
1742         [cf_cv_link_dataonly=unknown])
1743         LIBS="$cf_saveLIBS"
1744         ])
1745 AC_MSG_RESULT($cf_cv_link_dataonly)
1746
1747 if test "$cf_cv_link_dataonly" = no ; then
1748         AC_DEFINE(BROKEN_LINKER)
1749         BROKEN_LINKER=1
1750 fi
1751
1752 ])dnl
1753 dnl ---------------------------------------------------------------------------
1754 dnl CF_LINK_FUNCS version: 7 updated: 2006/12/16 12:33:30
1755 dnl -------------
1756 dnl Most Unix systems have both link and symlink, a few don't have symlink.
1757 dnl A few non-Unix systems implement symlink, but not link.
1758 dnl A few non-systems implement neither (or have nonfunctional versions).
1759 AC_DEFUN([CF_LINK_FUNCS],
1760 [
1761 AC_CHECK_FUNCS( \
1762         remove \
1763         unlink )
1764
1765 if test "$cross_compiling" = yes ; then
1766         AC_CHECK_FUNCS( \
1767                 link \
1768                 symlink )
1769 else
1770         AC_CACHE_CHECK(if link/symlink functions work,cf_cv_link_funcs,[
1771                 cf_cv_link_funcs=
1772                 for cf_func in link symlink ; do
1773                         AC_TRY_RUN([
1774 #include <sys/types.h>
1775 #include <sys/stat.h>
1776 #ifdef HAVE_UNISTD_H
1777 #include <unistd.h>
1778 #endif
1779 int main()
1780 {
1781         int fail = 0;
1782         char *src = "config.log";
1783         char *dst = "conftest.chk";
1784         struct stat src_sb;
1785         struct stat dst_sb;
1786
1787         stat(src, &src_sb);
1788         fail = ($cf_func("config.log", "conftest.chk") < 0)
1789             || (stat(dst, &dst_sb) < 0)
1790             || (dst_sb.st_mtime != src_sb.st_mtime);
1791 #ifdef HAVE_UNLINK
1792         unlink(dst);
1793 #else
1794         remove(dst);
1795 #endif
1796         ${cf_cv_main_return:-return} (fail);
1797 }
1798                         ],[
1799                         cf_cv_link_funcs="$cf_cv_link_funcs $cf_func"
1800                         eval 'ac_cv_func_'$cf_func'=yes'],[
1801                         eval 'ac_cv_func_'$cf_func'=no'],[
1802                         eval 'ac_cv_func_'$cf_func'=error'])
1803                 done
1804                 test -z "$cf_cv_link_funcs" && cf_cv_link_funcs=no
1805         ])
1806         test "$ac_cv_func_link"    = yes && AC_DEFINE(HAVE_LINK)
1807         test "$ac_cv_func_symlink" = yes && AC_DEFINE(HAVE_SYMLINK)
1808 fi
1809 ])dnl
1810 dnl ---------------------------------------------------------------------------
1811 dnl CF_MAIN_RETURN version: 1 updated: 2006/12/10 09:51:54
1812 dnl --------------
1813 dnl Check if a return from main to the shell actually returns the same exit
1814 dnl code.  This is true for almost any POSIX environment.
1815 dnl
1816 dnl Some very old environments did not flush stdout, etc., on an exit.  That
1817 dnl would be a useful case to test for also.
1818 AC_DEFUN([CF_MAIN_RETURN],
1819 [
1820 cf_cv_main_return=return
1821 ])dnl
1822 dnl ---------------------------------------------------------------------------
1823 dnl CF_MAKEFLAGS version: 13 updated: 2010/10/23 15:52:32
1824 dnl ------------
1825 dnl Some 'make' programs support ${MAKEFLAGS}, some ${MFLAGS}, to pass 'make'
1826 dnl options to lower-levels.  It's very useful for "make -n" -- if we have it.
1827 dnl (GNU 'make' does both, something POSIX 'make', which happens to make the
1828 dnl ${MAKEFLAGS} variable incompatible because it adds the assignments :-)
1829 AC_DEFUN([CF_MAKEFLAGS],
1830 [
1831 AC_CACHE_CHECK(for makeflags variable, cf_cv_makeflags,[
1832         cf_cv_makeflags=''
1833         for cf_option in '-${MAKEFLAGS}' '${MFLAGS}'
1834         do
1835                 cat >cf_makeflags.tmp <<CF_EOF
1836 SHELL = /bin/sh
1837 all :
1838         @ echo '.$cf_option'
1839 CF_EOF
1840                 cf_result=`${MAKE:-make} -k -f cf_makeflags.tmp 2>/dev/null | sed -e 's,[[      ]]*$,,'`
1841                 case "$cf_result" in
1842                 .*k)
1843                         cf_result=`${MAKE:-make} -k -f cf_makeflags.tmp CC=cc 2>/dev/null`
1844                         case "$cf_result" in
1845                         .*CC=*) cf_cv_makeflags=
1846                                 ;;
1847                         *)      cf_cv_makeflags=$cf_option
1848                                 ;;
1849                         esac
1850                         break
1851                         ;;
1852                 .-)     ;;
1853                 *)      echo "given option \"$cf_option\", no match \"$cf_result\""
1854                         ;;
1855                 esac
1856         done
1857         rm -f cf_makeflags.tmp
1858 ])
1859
1860 AC_SUBST(cf_cv_makeflags)
1861 ])dnl
1862 dnl ---------------------------------------------------------------------------
1863 dnl CF_MAKE_TAGS version: 6 updated: 2010/10/23 15:52:32
1864 dnl ------------
1865 dnl Generate tags/TAGS targets for makefiles.  Do not generate TAGS if we have
1866 dnl a monocase filesystem.
1867 AC_DEFUN([CF_MAKE_TAGS],[
1868 AC_REQUIRE([CF_MIXEDCASE_FILENAMES])
1869
1870 AC_CHECK_PROGS(CTAGS, exctags ctags)
1871 AC_CHECK_PROGS(ETAGS, exetags etags)
1872
1873 AC_CHECK_PROG(MAKE_LOWER_TAGS, ${CTAGS:-ctags}, yes, no)
1874
1875 if test "$cf_cv_mixedcase" = yes ; then
1876         AC_CHECK_PROG(MAKE_UPPER_TAGS, ${ETAGS:-etags}, yes, no)
1877 else
1878         MAKE_UPPER_TAGS=no
1879 fi
1880
1881 if test "$MAKE_UPPER_TAGS" = yes ; then
1882         MAKE_UPPER_TAGS=
1883 else
1884         MAKE_UPPER_TAGS="#"
1885 fi
1886
1887 if test "$MAKE_LOWER_TAGS" = yes ; then
1888         MAKE_LOWER_TAGS=
1889 else
1890         MAKE_LOWER_TAGS="#"
1891 fi
1892
1893 AC_SUBST(CTAGS)
1894 AC_SUBST(ETAGS)
1895
1896 AC_SUBST(MAKE_UPPER_TAGS)
1897 AC_SUBST(MAKE_LOWER_TAGS)
1898 ])dnl
1899 dnl ---------------------------------------------------------------------------
1900 dnl CF_MIXEDCASE_FILENAMES version: 3 updated: 2003/09/20 17:07:55
1901 dnl ----------------------
1902 dnl Check if the file-system supports mixed-case filenames.  If we're able to
1903 dnl create a lowercase name and see it as uppercase, it doesn't support that.
1904 AC_DEFUN([CF_MIXEDCASE_FILENAMES],
1905 [
1906 AC_CACHE_CHECK(if filesystem supports mixed-case filenames,cf_cv_mixedcase,[
1907 if test "$cross_compiling" = yes ; then
1908         case $target_alias in #(vi
1909         *-os2-emx*|*-msdosdjgpp*|*-cygwin*|*-mingw32*|*-uwin*) #(vi
1910                 cf_cv_mixedcase=no
1911                 ;;
1912         *)
1913                 cf_cv_mixedcase=yes
1914                 ;;
1915         esac
1916 else
1917         rm -f conftest CONFTEST
1918         echo test >conftest
1919         if test -f CONFTEST ; then
1920                 cf_cv_mixedcase=no
1921         else
1922                 cf_cv_mixedcase=yes
1923         fi
1924         rm -f conftest CONFTEST
1925 fi
1926 ])
1927 test "$cf_cv_mixedcase" = yes && AC_DEFINE(MIXEDCASE_FILENAMES)
1928 ])dnl
1929 dnl ---------------------------------------------------------------------------
1930 dnl CF_MKSTEMP version: 7 updated: 2010/08/14 18:25:37
1931 dnl ----------
1932 dnl Check for a working mkstemp.  This creates two files, checks that they are
1933 dnl successfully created and distinct (AmigaOS apparently fails on the last).
1934 AC_DEFUN([CF_MKSTEMP],[
1935 AC_CACHE_CHECK(for working mkstemp, cf_cv_func_mkstemp,[
1936 rm -rf conftest*
1937 AC_TRY_RUN([
1938 #include <sys/types.h>
1939 #include <stdlib.h>
1940 #include <stdio.h>
1941 #include <string.h>
1942 #include <sys/stat.h>
1943 int main()
1944 {
1945         char *tmpl = "conftestXXXXXX";
1946         char name[2][80];
1947         int n;
1948         int result = 0;
1949         int fd;
1950         struct stat sb;
1951
1952         umask(077);
1953         for (n = 0; n < 2; ++n) {
1954                 strcpy(name[n], tmpl);
1955                 if ((fd = mkstemp(name[n])) >= 0) {
1956                         if (!strcmp(name[n], tmpl)
1957                          || stat(name[n], &sb) != 0
1958                          || (sb.st_mode & S_IFMT) != S_IFREG
1959                          || (sb.st_mode & 077) != 0) {
1960                                 result = 1;
1961                         }
1962                         close(fd);
1963                 }
1964         }
1965         if (result == 0
1966          && !strcmp(name[0], name[1]))
1967                 result = 1;
1968         ${cf_cv_main_return:-return}(result);
1969 }
1970 ],[cf_cv_func_mkstemp=yes
1971 ],[cf_cv_func_mkstemp=no
1972 ],[AC_CHECK_FUNC(mkstemp)
1973 ])
1974 ])
1975 if test "x$cf_cv_func_mkstemp" = xyes || test "x$ac_cv_func_mkstemp" = xyes ; then
1976         AC_DEFINE(HAVE_MKSTEMP)
1977 fi
1978 ])dnl
1979 dnl ---------------------------------------------------------------------------
1980 dnl CF_MSG_LOG version: 5 updated: 2010/10/23 15:52:32
1981 dnl ----------
1982 dnl Write a debug message to config.log, along with the line number in the
1983 dnl configure script.
1984 AC_DEFUN([CF_MSG_LOG],[
1985 echo "${as_me:-configure}:__oline__: testing $* ..." 1>&AC_FD_CC
1986 ])dnl
1987 dnl ---------------------------------------------------------------------------
1988 dnl CF_NCURSES_ADDON version: 3 updated: 2010/10/23 15:54:49
1989 dnl ----------------
1990 dnl Configure an ncurses add-on, built outside the ncurses tree.
1991 AC_DEFUN([CF_NCURSES_ADDON],[
1992
1993 AC_PROVIDE([CF_SUBST_NCURSES_VERSION])
1994
1995 AC_MSG_CHECKING(if you want wide-character code)
1996 AC_ARG_ENABLE(widec,
1997         [  --enable-widec          compile with wide-char/UTF-8 code],
1998         [with_widec=$enableval],
1999         [with_widec=no])
2000 AC_MSG_RESULT($with_widec)
2001 if test "$with_widec" = yes ; then
2002         CF_UTF8_LIB 
2003         CF_NCURSES_CONFIG(ncursesw)
2004 else
2005         CF_NCURSES_CONFIG(ncurses)
2006 fi
2007
2008 if test "$NCURSES_CONFIG" != none ; then
2009
2010 cf_version=`$NCURSES_CONFIG --version`
2011
2012 NCURSES_MAJOR=`echo "$cf_version" | sed -e 's/\..*//'`
2013 NCURSES_MINOR=`echo "$cf_version" | sed -e 's/^[[0-9]]\+\.//' -e 's/\..*//'`
2014 NCURSES_PATCH=`echo "$cf_version" | sed -e 's/^[[0-9]]\+\.[[0-9]]\+\.//'`
2015
2016 # ABI version is not available from headers
2017 cf_cv_abi_version=`$NCURSES_CONFIG --abi-version`
2018
2019 else
2020
2021 for cf_name in MAJOR MINOR PATCH
2022 do
2023 cat >conftest.$ac_ext <<CF_EOF
2024 #include <${cf_cv_ncurses_header:-curses.h}>
2025 AUTOCONF_$cf_name NCURSES_VERSION_$cf_name
2026 CF_EOF
2027         cf_try="$ac_cpp conftest.$ac_ext 2>&5 | fgrep AUTOCONF_$cf_name >conftest.out"
2028         AC_TRY_EVAL(cf_try)
2029         if test -f conftest.out ; then
2030                 cf_result=`cat conftest.out | sed -e "s/^.*AUTOCONF_$cf_name[[  ]]\+//"`
2031                 eval NCURSES_$cf_name=$cf_result
2032                 cat conftest.$ac_ext
2033                 cat conftest.out
2034         fi
2035 done
2036
2037 cf_cv_abi_version=${NCURSES_MAJOR}
2038
2039 fi
2040
2041 cf_cv_rel_version=${NCURSES_MAJOR}.${NCURSES_MINOR}
2042
2043 dnl Show the computed version, for logging
2044 cf_cv_timestamp=`date`
2045
2046 AC_MSG_RESULT(Configuring NCURSES $cf_cv_rel_version ABI $cf_cv_abi_version ($cf_cv_timestamp))
2047
2048 dnl We need these values in the generated headers
2049 AC_SUBST(NCURSES_MAJOR)
2050 AC_SUBST(NCURSES_MINOR)
2051 AC_SUBST(NCURSES_PATCH)
2052
2053 dnl We need these values in the generated makefiles
2054 AC_SUBST(cf_cv_rel_version)
2055 AC_SUBST(cf_cv_abi_version)
2056
2057 dnl FIXME - not needed for Ada95
2058 AC_SUBST(cf_cv_builtin_bool)
2059 AC_SUBST(cf_cv_header_stdbool_h)
2060 AC_SUBST(cf_cv_type_of_bool)dnl
2061
2062 ])
2063 dnl ---------------------------------------------------------------------------
2064 dnl CF_NCURSES_CC_CHECK version: 4 updated: 2007/07/29 10:39:05
2065 dnl -------------------
2066 dnl Check if we can compile with ncurses' header file
2067 dnl $1 is the cache variable to set
2068 dnl $2 is the header-file to include
2069 dnl $3 is the root name (ncurses or ncursesw)
2070 AC_DEFUN([CF_NCURSES_CC_CHECK],[
2071         AC_TRY_COMPILE([
2072 ]ifelse($3,ncursesw,[
2073 #define _XOPEN_SOURCE_EXTENDED
2074 #undef  HAVE_LIBUTF8_H  /* in case we used CF_UTF8_LIB */
2075 #define HAVE_LIBUTF8_H  /* to force ncurses' header file to use cchar_t */
2076 ])[
2077 #include <$2>],[
2078 #ifdef NCURSES_VERSION
2079 ]ifelse($3,ncursesw,[
2080 #ifndef WACS_BSSB
2081         make an error
2082 #endif
2083 ])[
2084 printf("%s\n", NCURSES_VERSION);
2085 #else
2086 #ifdef __NCURSES_H
2087 printf("old\n");
2088 #else
2089         make an error
2090 #endif
2091 #endif
2092         ]
2093         ,[$1=$2]
2094         ,[$1=no])
2095 ])dnl
2096 dnl ---------------------------------------------------------------------------
2097 dnl CF_NCURSES_CONFIG version: 8 updated: 2010/07/08 05:17:30
2098 dnl -----------------
2099 dnl Tie together the configure-script macros for ncurses.
2100 dnl Prefer the "-config" script from ncurses 6.x, to simplify analysis.
2101 dnl Allow that to be overridden using the $NCURSES_CONFIG environment variable.
2102 dnl
2103 dnl $1 is the root library name (default: "ncurses")
2104 AC_DEFUN([CF_NCURSES_CONFIG],
2105 [
2106 cf_ncuconfig_root=ifelse($1,,ncurses,$1)
2107
2108 echo "Looking for ${cf_ncuconfig_root}-config"
2109 AC_PATH_PROGS(NCURSES_CONFIG,${cf_ncuconfig_root}6-config ${cf_ncuconfig_root}5-config,none)
2110
2111 if test "$NCURSES_CONFIG" != none ; then
2112
2113 CPPFLAGS="$CPPFLAGS `$NCURSES_CONFIG --cflags`"
2114 CF_ADD_LIBS(`$NCURSES_CONFIG --libs`)
2115
2116 # even with config script, some packages use no-override for curses.h
2117 CF_CURSES_HEADER(ifelse($1,,ncurses,$1))
2118
2119 dnl like CF_NCURSES_CPPFLAGS
2120 AC_DEFINE(NCURSES)
2121
2122 dnl like CF_NCURSES_LIBS
2123 CF_UPPER(cf_nculib_ROOT,HAVE_LIB$cf_ncuconfig_root)
2124 AC_DEFINE_UNQUOTED($cf_nculib_ROOT)
2125
2126 dnl like CF_NCURSES_VERSION
2127 cf_cv_ncurses_version=`$NCURSES_CONFIG --version`
2128
2129 else
2130
2131 CF_NCURSES_CPPFLAGS(ifelse($1,,ncurses,$1))
2132 CF_NCURSES_LIBS(ifelse($1,,ncurses,$1))
2133
2134 fi
2135 ])dnl
2136 dnl ---------------------------------------------------------------------------
2137 dnl CF_NCURSES_CPPFLAGS version: 20 updated: 2010/11/20 17:02:38
2138 dnl -------------------
2139 dnl Look for the SVr4 curses clone 'ncurses' in the standard places, adjusting
2140 dnl the CPPFLAGS variable so we can include its header.
2141 dnl
2142 dnl The header files may be installed as either curses.h, or ncurses.h (would
2143 dnl be obsolete, except that some packagers prefer this name to distinguish it
2144 dnl from a "native" curses implementation).  If not installed for overwrite,
2145 dnl the curses.h file would be in an ncurses subdirectory (e.g.,
2146 dnl /usr/include/ncurses), but someone may have installed overwriting the
2147 dnl vendor's curses.  Only very old versions (pre-1.9.2d, the first autoconf'd
2148 dnl version) of ncurses don't define either __NCURSES_H or NCURSES_VERSION in
2149 dnl the header.
2150 dnl
2151 dnl If the installer has set $CFLAGS or $CPPFLAGS so that the ncurses header
2152 dnl is already in the include-path, don't even bother with this, since we cannot
2153 dnl easily determine which file it is.  In this case, it has to be <curses.h>.
2154 dnl
2155 dnl The optional parameter gives the root name of the library, in case it is
2156 dnl not installed as the default curses library.  That is how the
2157 dnl wide-character version of ncurses is installed.
2158 AC_DEFUN([CF_NCURSES_CPPFLAGS],
2159 [AC_REQUIRE([CF_WITH_CURSES_DIR])
2160
2161 AC_PROVIDE([CF_CURSES_CPPFLAGS])dnl
2162 cf_ncuhdr_root=ifelse($1,,ncurses,$1)
2163
2164 test -n "$cf_cv_curses_dir" && \
2165 test "$cf_cv_curses_dir" != "no" && { \
2166   CF_ADD_INCDIR($cf_cv_curses_dir/include/$cf_ncuhdr_root)
2167 }
2168
2169 AC_CACHE_CHECK(for $cf_ncuhdr_root header in include-path, cf_cv_ncurses_h,[
2170         cf_header_list="$cf_ncuhdr_root/curses.h $cf_ncuhdr_root/ncurses.h"
2171         ( test "$cf_ncuhdr_root" = ncurses || test "$cf_ncuhdr_root" = ncursesw ) && cf_header_list="$cf_header_list curses.h ncurses.h"
2172         for cf_header in $cf_header_list
2173         do
2174                 CF_NCURSES_CC_CHECK(cf_cv_ncurses_h,$cf_header,$1)
2175                 test "$cf_cv_ncurses_h" != no && break
2176         done
2177 ])
2178
2179 CF_NCURSES_HEADER
2180 CF_TERM_HEADER
2181
2182 # some applications need this, but should check for NCURSES_VERSION
2183 AC_DEFINE(NCURSES)
2184
2185 CF_NCURSES_VERSION
2186 ])dnl
2187 dnl ---------------------------------------------------------------------------
2188 dnl CF_NCURSES_HEADER version: 2 updated: 2008/03/23 14:48:54
2189 dnl -----------------
2190 dnl Find a "curses" header file, e.g,. "curses.h", or one of the more common
2191 dnl variations of ncurses' installs.
2192 dnl
2193 dnl See also CF_CURSES_HEADER, which sets the same cache variable.
2194 AC_DEFUN([CF_NCURSES_HEADER],[
2195
2196 if test "$cf_cv_ncurses_h" != no ; then
2197         cf_cv_ncurses_header=$cf_cv_ncurses_h
2198 else
2199
2200 AC_CACHE_CHECK(for $cf_ncuhdr_root include-path, cf_cv_ncurses_h2,[
2201         test -n "$verbose" && echo
2202         CF_HEADER_PATH(cf_search,$cf_ncuhdr_root)
2203         test -n "$verbose" && echo search path $cf_search
2204         cf_save2_CPPFLAGS="$CPPFLAGS"
2205         for cf_incdir in $cf_search
2206         do
2207                 CF_ADD_INCDIR($cf_incdir)
2208                 for cf_header in \
2209                         ncurses.h \
2210                         curses.h
2211                 do
2212                         CF_NCURSES_CC_CHECK(cf_cv_ncurses_h2,$cf_header,$1)
2213                         if test "$cf_cv_ncurses_h2" != no ; then
2214                                 cf_cv_ncurses_h2=$cf_incdir/$cf_header
2215                                 test -n "$verbose" && echo $ac_n "      ... found $ac_c" 1>&AC_FD_MSG
2216                                 break
2217                         fi
2218                         test -n "$verbose" && echo "    ... tested $cf_incdir/$cf_header" 1>&AC_FD_MSG
2219                 done
2220                 CPPFLAGS="$cf_save2_CPPFLAGS"
2221                 test "$cf_cv_ncurses_h2" != no && break
2222         done
2223         test "$cf_cv_ncurses_h2" = no && AC_MSG_ERROR(not found)
2224         ])
2225
2226         CF_DIRNAME(cf_1st_incdir,$cf_cv_ncurses_h2)
2227         cf_cv_ncurses_header=`basename $cf_cv_ncurses_h2`
2228         if test `basename $cf_1st_incdir` = $cf_ncuhdr_root ; then
2229                 cf_cv_ncurses_header=$cf_ncuhdr_root/$cf_cv_ncurses_header
2230         fi
2231         CF_ADD_INCDIR($cf_1st_incdir)
2232
2233 fi
2234
2235 # Set definitions to allow ifdef'ing for ncurses.h
2236
2237 case $cf_cv_ncurses_header in # (vi
2238 *ncurses.h)
2239         AC_DEFINE(HAVE_NCURSES_H)
2240         ;;
2241 esac
2242
2243 case $cf_cv_ncurses_header in # (vi
2244 ncurses/curses.h|ncurses/ncurses.h)
2245         AC_DEFINE(HAVE_NCURSES_NCURSES_H)
2246         ;;
2247 ncursesw/curses.h|ncursesw/ncurses.h)
2248         AC_DEFINE(HAVE_NCURSESW_NCURSES_H)
2249         ;;
2250 esac
2251
2252 ])dnl
2253 dnl ---------------------------------------------------------------------------
2254 dnl CF_NCURSES_LIBS version: 16 updated: 2010/11/20 17:02:38
2255 dnl ---------------
2256 dnl Look for the ncurses library.  This is a little complicated on Linux,
2257 dnl because it may be linked with the gpm (general purpose mouse) library.
2258 dnl Some distributions have gpm linked with (bsd) curses, which makes it
2259 dnl unusable with ncurses.  However, we don't want to link with gpm unless
2260 dnl ncurses has a dependency, since gpm is normally set up as a shared library,
2261 dnl and the linker will record a dependency.
2262 dnl
2263 dnl The optional parameter gives the root name of the library, in case it is
2264 dnl not installed as the default curses library.  That is how the
2265 dnl wide-character version of ncurses is installed.
2266 AC_DEFUN([CF_NCURSES_LIBS],
2267 [AC_REQUIRE([CF_NCURSES_CPPFLAGS])
2268
2269 cf_nculib_root=ifelse($1,,ncurses,$1)
2270         # This works, except for the special case where we find gpm, but
2271         # ncurses is in a nonstandard location via $LIBS, and we really want
2272         # to link gpm.
2273 cf_ncurses_LIBS=""
2274 cf_ncurses_SAVE="$LIBS"
2275 AC_CHECK_LIB(gpm,Gpm_Open,
2276         [AC_CHECK_LIB(gpm,initscr,
2277                 [LIBS="$cf_ncurses_SAVE"],
2278                 [cf_ncurses_LIBS="-lgpm"])])
2279
2280 case $host_os in #(vi
2281 freebsd*)
2282         # This is only necessary if you are linking against an obsolete
2283         # version of ncurses (but it should do no harm, since it's static).
2284         if test "$cf_nculib_root" = ncurses ; then
2285                 AC_CHECK_LIB(mytinfo,tgoto,[cf_ncurses_LIBS="-lmytinfo $cf_ncurses_LIBS"])
2286         fi
2287         ;;
2288 esac
2289
2290 CF_ADD_LIBS($cf_ncurses_LIBS)
2291
2292 if ( test -n "$cf_cv_curses_dir" && test "$cf_cv_curses_dir" != "no" )
2293 then
2294         CF_ADD_LIBS(-l$cf_nculib_root)
2295 else
2296         CF_FIND_LIBRARY($cf_nculib_root,$cf_nculib_root,
2297                 [#include <${cf_cv_ncurses_header:-curses.h}>],
2298                 [initscr()],
2299                 initscr)
2300 fi
2301
2302 if test -n "$cf_ncurses_LIBS" ; then
2303         AC_MSG_CHECKING(if we can link $cf_nculib_root without $cf_ncurses_LIBS)
2304         cf_ncurses_SAVE="$LIBS"
2305         for p in $cf_ncurses_LIBS ; do
2306                 q=`echo $LIBS | sed -e "s%$p %%" -e "s%$p$%%"`
2307                 if test "$q" != "$LIBS" ; then
2308                         LIBS="$q"
2309                 fi
2310         done
2311         AC_TRY_LINK([#include <${cf_cv_ncurses_header:-curses.h}>],
2312                 [initscr(); mousemask(0,0); tgoto((char *)0, 0, 0);],
2313                 [AC_MSG_RESULT(yes)],
2314                 [AC_MSG_RESULT(no)
2315                  LIBS="$cf_ncurses_SAVE"])
2316 fi
2317
2318 CF_UPPER(cf_nculib_ROOT,HAVE_LIB$cf_nculib_root)
2319 AC_DEFINE_UNQUOTED($cf_nculib_ROOT)
2320 ])dnl
2321 dnl ---------------------------------------------------------------------------
2322 dnl CF_NCURSES_VERSION version: 13 updated: 2010/10/23 15:54:49
2323 dnl ------------------
2324 dnl Check for the version of ncurses, to aid in reporting bugs, etc.
2325 dnl Call CF_CURSES_CPPFLAGS first, or CF_NCURSES_CPPFLAGS.  We don't use
2326 dnl AC_REQUIRE since that does not work with the shell's if/then/else/fi.
2327 AC_DEFUN([CF_NCURSES_VERSION],
2328 [
2329 AC_REQUIRE([CF_CURSES_CPPFLAGS])dnl
2330 AC_CACHE_CHECK(for ncurses version, cf_cv_ncurses_version,[
2331         cf_cv_ncurses_version=no
2332         cf_tempfile=out$$
2333         rm -f $cf_tempfile
2334         AC_TRY_RUN([
2335 #include <${cf_cv_ncurses_header:-curses.h}>
2336 #include <stdio.h>
2337 int main()
2338 {
2339         FILE *fp = fopen("$cf_tempfile", "w");
2340 #ifdef NCURSES_VERSION
2341 # ifdef NCURSES_VERSION_PATCH
2342         fprintf(fp, "%s.%d\n", NCURSES_VERSION, NCURSES_VERSION_PATCH);
2343 # else
2344         fprintf(fp, "%s\n", NCURSES_VERSION);
2345 # endif
2346 #else
2347 # ifdef __NCURSES_H
2348         fprintf(fp, "old\n");
2349 # else
2350         make an error
2351 # endif
2352 #endif
2353         ${cf_cv_main_return:-return}(0);
2354 }],[
2355         cf_cv_ncurses_version=`cat $cf_tempfile`],,[
2356
2357         # This will not work if the preprocessor splits the line after the
2358         # Autoconf token.  The 'unproto' program does that.
2359         cat > conftest.$ac_ext <<EOF
2360 #include <${cf_cv_ncurses_header:-curses.h}>
2361 #undef Autoconf
2362 #ifdef NCURSES_VERSION
2363 Autoconf NCURSES_VERSION
2364 #else
2365 #ifdef __NCURSES_H
2366 Autoconf "old"
2367 #endif
2368 ;
2369 #endif
2370 EOF
2371         cf_try="$ac_cpp conftest.$ac_ext 2>&AC_FD_CC | grep '^Autoconf ' >conftest.out"
2372         AC_TRY_EVAL(cf_try)
2373         if test -f conftest.out ; then
2374                 cf_out=`cat conftest.out | sed -e 's%^Autoconf %%' -e 's%^[[^"]]*"%%' -e 's%".*%%'`
2375                 test -n "$cf_out" && cf_cv_ncurses_version="$cf_out"
2376                 rm -f conftest.out
2377         fi
2378 ])
2379         rm -f $cf_tempfile
2380 ])
2381 test "$cf_cv_ncurses_version" = no || AC_DEFINE(NCURSES)
2382 ])dnl
2383 dnl ---------------------------------------------------------------------------
2384 dnl CF_NO_LEAKS_OPTION version: 4 updated: 2006/12/16 14:24:05
2385 dnl ------------------
2386 dnl see CF_WITH_NO_LEAKS
2387 AC_DEFUN([CF_NO_LEAKS_OPTION],[
2388 AC_MSG_CHECKING(if you want to use $1 for testing)
2389 AC_ARG_WITH($1,
2390         [$2],
2391         [AC_DEFINE($3)ifelse([$4],,[
2392          $4
2393 ])
2394         : ${with_cflags:=-g}
2395         : ${with_no_leaks:=yes}
2396          with_$1=yes],
2397         [with_$1=])
2398 AC_MSG_RESULT(${with_$1:-no})
2399
2400 case .$with_cflags in #(vi
2401 .*-g*)
2402         case .$CFLAGS in #(vi
2403         .*-g*) #(vi
2404                 ;;
2405         *)
2406                 CF_ADD_CFLAGS([-g])
2407                 ;;
2408         esac
2409         ;;
2410 esac
2411 ])dnl
2412 dnl ---------------------------------------------------------------------------
2413 dnl CF_NUMBER_SYNTAX version: 1 updated: 2003/09/20 18:12:49
2414 dnl ----------------
2415 dnl Check if the given variable is a number.  If not, report an error.
2416 dnl $1 is the variable
2417 dnl $2 is the message
2418 AC_DEFUN([CF_NUMBER_SYNTAX],[
2419 if test -n "$1" ; then
2420   case $1 in #(vi
2421   [[0-9]]*) #(vi
2422         ;;
2423   *)
2424         AC_MSG_ERROR($2 is not a number: $1)
2425         ;;
2426   esac
2427 else
2428   AC_MSG_ERROR($2 value is empty)
2429 fi
2430 ])dnl
2431 dnl ---------------------------------------------------------------------------
2432 dnl CF_OBJ_SUBDIR version: 4 updated: 2002/02/23 20:38:31
2433 dnl -------------
2434 dnl Compute the object-directory name from the given model name
2435 AC_DEFUN([CF_OBJ_SUBDIR],
2436 [
2437         case $1 in
2438         libtool) $2='obj_lo'  ;;
2439         normal)  $2='objects' ;;
2440         debug)   $2='obj_g' ;;
2441         profile) $2='obj_p' ;;
2442         shared)
2443                 case $cf_cv_system_name in #(vi
2444                 cygwin) #(vi
2445                         $2='objects' ;;
2446                 *)
2447                         $2='obj_s' ;;
2448                 esac
2449         esac
2450 ])dnl
2451 dnl ---------------------------------------------------------------------------
2452 dnl CF_PATHSEP version: 5 updated: 2010/05/26 05:38:42
2453 dnl ----------
2454 dnl Provide a value for the $PATH and similar separator
2455 AC_DEFUN([CF_PATHSEP],
2456 [
2457         case $cf_cv_system_name in
2458         os2*)   PATH_SEPARATOR=';'  ;;
2459         *)      PATH_SEPARATOR=':'  ;;
2460         esac
2461 ifelse([$1],,,[$1=$PATH_SEPARATOR])
2462         AC_SUBST(PATH_SEPARATOR)
2463 ])dnl
2464 dnl ---------------------------------------------------------------------------
2465 dnl CF_PATH_SYNTAX version: 13 updated: 2010/05/26 05:38:42
2466 dnl --------------
2467 dnl Check the argument to see that it looks like a pathname.  Rewrite it if it
2468 dnl begins with one of the prefix/exec_prefix variables, and then again if the
2469 dnl result begins with 'NONE'.  This is necessary to work around autoconf's
2470 dnl delayed evaluation of those symbols.
2471 AC_DEFUN([CF_PATH_SYNTAX],[
2472 if test "x$prefix" != xNONE; then
2473   cf_path_syntax="$prefix"
2474 else
2475   cf_path_syntax="$ac_default_prefix"
2476 fi
2477
2478 case ".[$]$1" in #(vi
2479 .\[$]\(*\)*|.\'*\'*) #(vi
2480   ;;
2481 ..|./*|.\\*) #(vi
2482   ;;
2483 .[[a-zA-Z]]:[[\\/]]*) #(vi OS/2 EMX
2484   ;;
2485 .\[$]{*prefix}*) #(vi
2486   eval $1="[$]$1"
2487   case ".[$]$1" in #(vi
2488   .NONE/*)
2489     $1=`echo [$]$1 | sed -e s%NONE%$cf_path_syntax%`
2490     ;;
2491   esac
2492   ;; #(vi
2493 .no|.NONE/*)
2494   $1=`echo [$]$1 | sed -e s%NONE%$cf_path_syntax%`
2495   ;;
2496 *)
2497   ifelse([$2],,[AC_MSG_ERROR([expected a pathname, not \"[$]$1\"])],$2)
2498   ;;
2499 esac
2500 ])dnl
2501 dnl ---------------------------------------------------------------------------
2502 dnl CF_PKG_CONFIG version: 4 updated: 2011/02/18 20:26:24
2503 dnl -------------
2504 dnl Check for the package-config program, unless disabled by command-line.
2505 AC_DEFUN([CF_PKG_CONFIG],
2506 [
2507 AC_MSG_CHECKING(if you want to use pkg-config)
2508 AC_ARG_WITH(pkg-config,
2509         [  --with-pkg-config{=path} enable/disable use of pkg-config],
2510         [cf_pkg_config=$withval],
2511         [cf_pkg_config=yes])
2512 AC_MSG_RESULT($cf_pkg_config)
2513
2514 case $cf_pkg_config in #(vi
2515 no) #(vi
2516         PKG_CONFIG=none
2517         ;;
2518 yes) #(vi
2519         AC_PATH_TOOL(PKG_CONFIG, pkg-config, none)
2520         ;;
2521 *)
2522         PKG_CONFIG=$withval
2523         ;;
2524 esac
2525
2526 test -z "$PKG_CONFIG" && PKG_CONFIG=none
2527 if test "$PKG_CONFIG" != none ; then
2528         CF_PATH_SYNTAX(PKG_CONFIG)
2529 fi
2530
2531 AC_SUBST(PKG_CONFIG)
2532 ])dnl
2533 dnl ---------------------------------------------------------------------------
2534 dnl CF_POSIX_C_SOURCE version: 8 updated: 2010/05/26 05:38:42
2535 dnl -----------------
2536 dnl Define _POSIX_C_SOURCE to the given level, and _POSIX_SOURCE if needed.
2537 dnl
2538 dnl     POSIX.1-1990                            _POSIX_SOURCE
2539 dnl     POSIX.1-1990 and                        _POSIX_SOURCE and
2540 dnl             POSIX.2-1992 C-Language                 _POSIX_C_SOURCE=2
2541 dnl             Bindings Option
2542 dnl     POSIX.1b-1993                           _POSIX_C_SOURCE=199309L
2543 dnl     POSIX.1c-1996                           _POSIX_C_SOURCE=199506L
2544 dnl     X/Open 2000                             _POSIX_C_SOURCE=200112L
2545 dnl
2546 dnl Parameters:
2547 dnl     $1 is the nominal value for _POSIX_C_SOURCE
2548 AC_DEFUN([CF_POSIX_C_SOURCE],
2549 [
2550 cf_POSIX_C_SOURCE=ifelse([$1],,199506L,[$1])
2551
2552 cf_save_CFLAGS="$CFLAGS"
2553 cf_save_CPPFLAGS="$CPPFLAGS"
2554
2555 CF_REMOVE_DEFINE(cf_trim_CFLAGS,$cf_save_CFLAGS,_POSIX_C_SOURCE)
2556 CF_REMOVE_DEFINE(cf_trim_CPPFLAGS,$cf_save_CPPFLAGS,_POSIX_C_SOURCE)
2557
2558 AC_CACHE_CHECK(if we should define _POSIX_C_SOURCE,cf_cv_posix_c_source,[
2559         CF_MSG_LOG(if the symbol is already defined go no further)
2560         AC_TRY_COMPILE([#include <sys/types.h>],[
2561 #ifndef _POSIX_C_SOURCE
2562 make an error
2563 #endif],
2564         [cf_cv_posix_c_source=no],
2565         [cf_want_posix_source=no
2566          case .$cf_POSIX_C_SOURCE in #(vi
2567          .[[12]]??*) #(vi
2568                 cf_cv_posix_c_source="-D_POSIX_C_SOURCE=$cf_POSIX_C_SOURCE"
2569                 ;;
2570          .2) #(vi
2571                 cf_cv_posix_c_source="-D_POSIX_C_SOURCE=$cf_POSIX_C_SOURCE"
2572                 cf_want_posix_source=yes
2573                 ;;
2574          .*)
2575                 cf_want_posix_source=yes
2576                 ;;
2577          esac
2578          if test "$cf_want_posix_source" = yes ; then
2579                 AC_TRY_COMPILE([#include <sys/types.h>],[
2580 #ifdef _POSIX_SOURCE
2581 make an error
2582 #endif],[],
2583                 cf_cv_posix_c_source="$cf_cv_posix_c_source -D_POSIX_SOURCE")
2584          fi
2585          CF_MSG_LOG(ifdef from value $cf_POSIX_C_SOURCE)
2586          CFLAGS="$cf_trim_CFLAGS"
2587          CPPFLAGS="$cf_trim_CPPFLAGS $cf_cv_posix_c_source"
2588          CF_MSG_LOG(if the second compile does not leave our definition intact error)
2589          AC_TRY_COMPILE([#include <sys/types.h>],[
2590 #ifndef _POSIX_C_SOURCE
2591 make an error
2592 #endif],,
2593          [cf_cv_posix_c_source=no])
2594          CFLAGS="$cf_save_CFLAGS"
2595          CPPFLAGS="$cf_save_CPPFLAGS"
2596         ])
2597 ])
2598
2599 if test "$cf_cv_posix_c_source" != no ; then
2600         CFLAGS="$cf_trim_CFLAGS"
2601         CPPFLAGS="$cf_trim_CPPFLAGS"
2602         CF_ADD_CFLAGS($cf_cv_posix_c_source)
2603 fi
2604
2605 ])dnl
2606 dnl ---------------------------------------------------------------------------
2607 dnl CF_PROG_AR version: 1 updated: 2009/01/01 20:15:22
2608 dnl ----------
2609 dnl Check for archiver "ar".
2610 AC_DEFUN([CF_PROG_AR],[
2611 AC_CHECK_TOOL(AR, ar, ar)
2612 ])
2613 dnl ---------------------------------------------------------------------------
2614 dnl CF_PROG_AWK version: 1 updated: 2006/09/16 11:40:59
2615 dnl -----------
2616 dnl Check for awk, ensure that the check found something.
2617 AC_DEFUN([CF_PROG_AWK],
2618 [
2619 AC_PROG_AWK
2620 test -z "$AWK" && AC_MSG_ERROR(No awk program found)
2621 ])dnl
2622 dnl ---------------------------------------------------------------------------
2623 dnl CF_PROG_CC_C_O version: 3 updated: 2010/08/14 18:25:37
2624 dnl --------------
2625 dnl Analogous to AC_PROG_CC_C_O, but more useful: tests only $CC, ensures that
2626 dnl the output file can be renamed, and allows for a shell variable that can
2627 dnl be used later.  The parameter is either CC or CXX.  The result is the
2628 dnl cache variable:
2629 dnl     $cf_cv_prog_CC_c_o
2630 dnl     $cf_cv_prog_CXX_c_o
2631 AC_DEFUN([CF_PROG_CC_C_O],
2632 [AC_REQUIRE([AC_PROG_CC])dnl
2633 AC_MSG_CHECKING([whether [$]$1 understands -c and -o together])
2634 AC_CACHE_VAL(cf_cv_prog_$1_c_o,
2635 [
2636 cat > conftest.$ac_ext <<CF_EOF
2637 #include <stdio.h>
2638 int main()
2639 {
2640         ${cf_cv_main_return:-return}(0);
2641 }
2642 CF_EOF
2643 # We do the test twice because some compilers refuse to overwrite an
2644 # existing .o file with -o, though they will create one.
2645 ac_try='[$]$1 -c conftest.$ac_ext -o conftest2.$ac_objext >&AC_FD_CC'
2646 if AC_TRY_EVAL(ac_try) &&
2647   test -f conftest2.$ac_objext && AC_TRY_EVAL(ac_try);
2648 then
2649   eval cf_cv_prog_$1_c_o=yes
2650 else
2651   eval cf_cv_prog_$1_c_o=no
2652 fi
2653 rm -rf conftest*
2654 ])dnl
2655 if test $cf_cv_prog_$1_c_o = yes; then
2656   AC_MSG_RESULT([yes])
2657 else
2658   AC_MSG_RESULT([no])
2659 fi
2660 ])dnl
2661 dnl ---------------------------------------------------------------------------
2662 dnl CF_PROG_EGREP version: 1 updated: 2006/09/16 11:40:59
2663 dnl -------------
2664 dnl AC_PROG_EGREP was introduced in autoconf 2.53.
2665 dnl This macro adds a check to ensure the script found something.
2666 AC_DEFUN([CF_PROG_EGREP],
2667 [AC_CACHE_CHECK([for egrep], [ac_cv_prog_egrep],
2668    [if echo a | (grep -E '(a|b)') >/dev/null 2>&1
2669     then ac_cv_prog_egrep='grep -E'
2670     else ac_cv_prog_egrep='egrep'
2671     fi])
2672  EGREP=$ac_cv_prog_egrep
2673  AC_SUBST([EGREP])
2674 test -z "$EGREP" && AC_MSG_ERROR(No egrep program found)
2675 ])dnl
2676 dnl ---------------------------------------------------------------------------
2677 dnl CF_PROG_EXT version: 10 updated: 2004/01/03 19:28:18
2678 dnl -----------
2679 dnl Compute $PROG_EXT, used for non-Unix ports, such as OS/2 EMX.
2680 AC_DEFUN([CF_PROG_EXT],
2681 [
2682 AC_REQUIRE([CF_CHECK_CACHE])
2683 case $cf_cv_system_name in
2684 os2*)
2685     CFLAGS="$CFLAGS -Zmt"
2686     CPPFLAGS="$CPPFLAGS -D__ST_MT_ERRNO__"
2687     CXXFLAGS="$CXXFLAGS -Zmt"
2688     # autoconf's macro sets -Zexe and suffix both, which conflict:w
2689     LDFLAGS="$LDFLAGS -Zmt -Zcrtdll"
2690     ac_cv_exeext=.exe
2691     ;;
2692 esac
2693
2694 AC_EXEEXT
2695 AC_OBJEXT
2696
2697 PROG_EXT="$EXEEXT"
2698 AC_SUBST(PROG_EXT)
2699 test -n "$PROG_EXT" && AC_DEFINE_UNQUOTED(PROG_EXT,"$PROG_EXT")
2700 ])dnl
2701 dnl ---------------------------------------------------------------------------
2702 dnl CF_PROG_GNAT version: 1 updated: 2010/06/19 15:22:18
2703 dnl ------------
2704 dnl Check for gnatmake, ensure that it is complete.
2705 AC_DEFUN([CF_PROG_GNAT],[
2706 cf_ada_make=gnatmake
2707 AC_CHECK_PROG(gnat_exists, $cf_ada_make, yes, no)
2708 if test "$ac_cv_prog_gnat_exists" = no; then
2709    cf_ada_make=
2710 else
2711    CF_GNAT_VERSION
2712    AC_CHECK_PROG(M4_exists, m4, yes, no)
2713    if test "$ac_cv_prog_M4_exists" = no; then
2714       cf_cv_prog_gnat_correct=no
2715       echo Ada95 binding required program m4 not found. Ada95 binding disabled.
2716    fi
2717    if test "$cf_cv_prog_gnat_correct" = yes; then
2718       AC_MSG_CHECKING(if GNAT works)
2719       CF_GNAT_TRY_RUN([procedure conftest;],
2720 [with Text_IO;
2721 with GNAT.OS_Lib;
2722 procedure conftest is
2723 begin
2724    Text_IO.Put ("Hello World");
2725    Text_IO.New_Line;
2726    GNAT.OS_Lib.OS_Exit (0);
2727 end conftest;],[cf_cv_prog_gnat_correct=yes],[cf_cv_prog_gnat_correct=no])
2728       AC_MSG_RESULT($cf_cv_prog_gnat_correct)
2729    fi
2730 fi
2731
2732 AC_SUBST(cf_ada_make)
2733 ])dnl
2734 dnl ---------------------------------------------------------------------------
2735 dnl CF_PROG_LN_S version: 2 updated: 2010/08/14 18:25:37
2736 dnl ------------
2737 dnl Combine checks for "ln -s" and "ln -sf", updating $LN_S to include "-f"
2738 dnl option if it is supported.
2739 AC_DEFUN([CF_PROG_LN_S],[
2740 AC_PROG_LN_S
2741 AC_MSG_CHECKING(if $LN_S -f options work)
2742
2743 rm -f conf$$.src conf$$dst
2744 echo >conf$$.dst
2745 echo first >conf$$.src
2746 if $LN_S -f conf$$.src conf$$.dst 2>/dev/null; then
2747         cf_prog_ln_sf=yes
2748 else
2749         cf_prog_ln_sf=no
2750 fi
2751 rm -f conf$$.dst conf$$src
2752 AC_MSG_RESULT($cf_prog_ln_sf)
2753
2754 test "$cf_prog_ln_sf" = yes && LN_S="$LN_S -f"
2755 ])dnl
2756 dnl ---------------------------------------------------------------------------
2757 dnl CF_REMOVE_DEFINE version: 3 updated: 2010/01/09 11:05:50
2758 dnl ----------------
2759 dnl Remove all -U and -D options that refer to the given symbol from a list
2760 dnl of C compiler options.  This works around the problem that not all
2761 dnl compilers process -U and -D options from left-to-right, so a -U option
2762 dnl cannot be used to cancel the effect of a preceding -D option.
2763 dnl
2764 dnl $1 = target (which could be the same as the source variable)
2765 dnl $2 = source (including '$')
2766 dnl $3 = symbol to remove
2767 define([CF_REMOVE_DEFINE],
2768 [
2769 $1=`echo "$2" | \
2770         sed     -e 's/-[[UD]]'"$3"'\(=[[^       ]]*\)\?[[       ]]/ /g' \
2771                 -e 's/-[[UD]]'"$3"'\(=[[^       ]]*\)\?[$]//g'`
2772 ])dnl
2773 dnl ---------------------------------------------------------------------------
2774 dnl CF_REMOVE_LIB version: 1 updated: 2007/02/17 14:11:52
2775 dnl -------------
2776 dnl Remove the given library from the symbol
2777 dnl
2778 dnl $1 = target (which could be the same as the source variable)
2779 dnl $2 = source (including '$')
2780 dnl $3 = library to remove
2781 define([CF_REMOVE_LIB],
2782 [
2783 # remove $3 library from $2
2784 $1=`echo "$2" | sed -e 's/-l$3[[        ]]//g' -e 's/-l$3[$]//'`
2785 ])dnl
2786 dnl ---------------------------------------------------------------------------
2787 dnl CF_SHARED_OPTS version: 64 updated: 2010/06/05 16:51:16
2788 dnl --------------
2789 dnl --------------
2790 dnl Attempt to determine the appropriate CC/LD options for creating a shared
2791 dnl library.
2792 dnl
2793 dnl Note: ${LOCAL_LDFLAGS} is used to link executables that will run within the
2794 dnl build-tree, i.e., by making use of the libraries that are compiled in ../lib
2795 dnl We avoid compiling-in a ../lib path for the shared library since that can
2796 dnl lead to unexpected results at runtime.
2797 dnl ${LOCAL_LDFLAGS2} has the same intention but assumes that the shared libraries
2798 dnl are compiled in ../../lib
2799 dnl
2800 dnl The variable 'cf_cv_do_symlinks' is used to control whether we configure
2801 dnl to install symbolic links to the rel/abi versions of shared libraries.
2802 dnl
2803 dnl The variable 'cf_cv_shlib_version' controls whether we use the rel or abi
2804 dnl version when making symbolic links.
2805 dnl
2806 dnl The variable 'cf_cv_shlib_version_infix' controls whether shared library
2807 dnl version numbers are infix (ex: libncurses.<ver>.dylib) or postfix
2808 dnl (ex: libncurses.so.<ver>).
2809 dnl
2810 dnl Some loaders leave 'so_locations' lying around.  It's nice to clean up.
2811 AC_DEFUN([CF_SHARED_OPTS],
2812 [
2813         AC_REQUIRE([CF_SUBST_NCURSES_VERSION])
2814         AC_REQUIRE([CF_LD_RPATH_OPT])
2815         LOCAL_LDFLAGS=
2816         LOCAL_LDFLAGS2=
2817         LD_SHARED_OPTS=
2818         INSTALL_LIB="-m 644"
2819
2820         cf_cv_do_symlinks=no
2821         cf_ld_rpath_opt=
2822         test "$cf_cv_enable_rpath" = yes && cf_ld_rpath_opt="$LD_RPATH_OPT"
2823
2824         AC_MSG_CHECKING(if release/abi version should be used for shared libs)
2825         AC_ARG_WITH(shlib-version,
2826         [  --with-shlib-version=X  Specify rel or abi version for shared libs],
2827         [test -z "$withval" && withval=auto
2828         case $withval in #(vi
2829         yes) #(vi
2830                 cf_cv_shlib_version=auto
2831                 ;;
2832         rel|abi|auto|no) #(vi
2833                 cf_cv_shlib_version=$withval
2834                 ;;
2835         *)
2836                 AC_MSG_ERROR([option value must be one of: rel, abi, auto or no])
2837                 ;;
2838         esac
2839         ],[cf_cv_shlib_version=auto])
2840         AC_MSG_RESULT($cf_cv_shlib_version)
2841
2842         cf_cv_rm_so_locs=no
2843
2844         # Some less-capable ports of gcc support only -fpic
2845         CC_SHARED_OPTS=
2846         if test "$GCC" = yes
2847         then
2848                 AC_MSG_CHECKING(which $CC option to use)
2849                 cf_save_CFLAGS="$CFLAGS"
2850                 for CC_SHARED_OPTS in -fPIC -fpic ''
2851                 do
2852                         CFLAGS="$cf_save_CFLAGS $CC_SHARED_OPTS"
2853                         AC_TRY_COMPILE([#include <stdio.h>],[int x = 1],[break],[])
2854                 done
2855                 AC_MSG_RESULT($CC_SHARED_OPTS)
2856                 CFLAGS="$cf_save_CFLAGS"
2857         fi
2858
2859         cf_cv_shlib_version_infix=no
2860
2861         case $cf_cv_system_name in #(vi
2862         aix[[56]]*) #(vi
2863                 if test "$GCC" = yes; then
2864                         CC_SHARED_OPTS=
2865                         MK_SHARED_LIB='$(CC) -shared'
2866                 fi
2867                 ;;
2868         beos*) #(vi
2869                 MK_SHARED_LIB='${CC} ${CFLAGS} -o $[@] -Xlinker -soname=`basename $[@]` -nostart -e 0'
2870                 ;;
2871         cygwin*) #(vi
2872                 CC_SHARED_OPTS=
2873                 MK_SHARED_LIB='sh ../mk_shared_lib.sh [$]@ [$]{CC} [$]{CFLAGS}'
2874                 cf_cv_shlib_version=cygdll
2875                 cf_cv_shlib_version_infix=cygdll
2876                 cat >mk_shared_lib.sh <<-CF_EOF
2877                 #!/bin/sh
2878                 SHARED_LIB=\[$]1
2879                 IMPORT_LIB=\`echo "\[$]1" | sed -e 's/cyg/lib/' -e 's/[[0-9]]*\.dll[$]/.dll.a/'\`
2880                 shift
2881                 cat <<-EOF
2882                 Linking shared library
2883                 ** SHARED_LIB \[$]SHARED_LIB
2884                 ** IMPORT_LIB \[$]IMPORT_LIB
2885 EOF
2886                 exec \[$]* -shared -Wl,--out-implib=../lib/\[$]{IMPORT_LIB} -Wl,--export-all-symbols -o ../lib/\[$]{SHARED_LIB}
2887 CF_EOF
2888                 chmod +x mk_shared_lib.sh
2889                 ;;
2890         darwin*) #(vi
2891                 EXTRA_CFLAGS="-no-cpp-precomp"
2892                 CC_SHARED_OPTS="-dynamic"
2893                 MK_SHARED_LIB='${CC} ${CFLAGS} -dynamiclib -install_name ${libdir}/`basename $[@]` -compatibility_version ${ABI_VERSION} -current_version ${ABI_VERSION} -o $[@]'
2894                 test "$cf_cv_shlib_version" = auto && cf_cv_shlib_version=abi
2895                 cf_cv_shlib_version_infix=yes
2896                 AC_CACHE_CHECK([if ld -search_paths_first works], cf_cv_ldflags_search_paths_first, [
2897                         cf_save_LDFLAGS=$LDFLAGS
2898                         LDFLAGS="$LDFLAGS -Wl,-search_paths_first"
2899                         AC_TRY_LINK(, [int i;], cf_cv_ldflags_search_paths_first=yes, cf_cv_ldflags_search_paths_first=no)
2900                                 LDFLAGS=$cf_save_LDFLAGS])
2901                 if test $cf_cv_ldflags_search_paths_first = yes; then
2902                         LDFLAGS="$LDFLAGS -Wl,-search_paths_first"
2903                 fi
2904                 ;;
2905         hpux*) #(vi
2906                 # (tested with gcc 2.7.2 -- I don't have c89)
2907                 if test "$GCC" = yes; then
2908                         LD_SHARED_OPTS='-Xlinker +b -Xlinker ${libdir}'
2909                 else
2910                         CC_SHARED_OPTS='+Z'
2911                         LD_SHARED_OPTS='-Wl,+b,${libdir}'
2912                 fi
2913                 MK_SHARED_LIB='${LD} +b ${libdir} -b -o $[@]'
2914                 # HP-UX shared libraries must be executable, and should be
2915                 # readonly to exploit a quirk in the memory manager.
2916                 INSTALL_LIB="-m 555"
2917                 ;;
2918         irix*) #(vi
2919                 if test "$cf_cv_enable_rpath" = yes ; then
2920                         EXTRA_LDFLAGS="${cf_ld_rpath_opt}\${libdir} $EXTRA_LDFLAGS"
2921                 fi
2922                 # tested with IRIX 5.2 and 'cc'.
2923                 if test "$GCC" != yes; then
2924                         CC_SHARED_OPTS='-KPIC'
2925                         MK_SHARED_LIB='${CC} -shared -rdata_shared -soname `basename $[@]` -o $[@]'
2926                 else
2927                         MK_SHARED_LIB='${CC} -shared -Wl,-soname,`basename $[@]` -o $[@]'
2928                 fi
2929                 cf_cv_rm_so_locs=yes
2930                 ;;
2931         linux*|gnu*|k*bsd*-gnu) #(vi
2932                 if test "$DFT_LWR_MODEL" = "shared" ; then
2933                         LOCAL_LDFLAGS="${LD_RPATH_OPT}\$(LOCAL_LIBDIR)"
2934                         LOCAL_LDFLAGS2="$LOCAL_LDFLAGS"
2935                 fi
2936                 if test "$cf_cv_enable_rpath" = yes ; then
2937                         EXTRA_LDFLAGS="${cf_ld_rpath_opt}\${libdir} $EXTRA_LDFLAGS"
2938                 fi
2939                 CF_SHARED_SONAME
2940                 MK_SHARED_LIB='${CC} ${CFLAGS} -shared -Wl,-soname,'$cf_cv_shared_soname',-stats,-lc -o $[@]'
2941                 ;;
2942         openbsd[[2-9]].*) #(vi
2943                 if test "$DFT_LWR_MODEL" = "shared" ; then
2944                         LOCAL_LDFLAGS="${LD_RPATH_OPT}\$(LOCAL_LIBDIR)"
2945                         LOCAL_LDFLAGS2="$LOCAL_LDFLAGS"
2946                 fi
2947                 if test "$cf_cv_enable_rpath" = yes ; then
2948                         EXTRA_LDFLAGS="${cf_ld_rpath_opt}\${libdir} $EXTRA_LDFLAGS"
2949                 fi
2950                 CC_SHARED_OPTS="$CC_SHARED_OPTS -DPIC"
2951                 CF_SHARED_SONAME
2952                 MK_SHARED_LIB='${CC} ${CFLAGS} -shared -Wl,-Bshareable,-soname,'$cf_cv_shared_soname',-stats,-lc -o $[@]'
2953                 ;;
2954         nto-qnx*|openbsd*|freebsd[[12]].*) #(vi
2955                 CC_SHARED_OPTS="$CC_SHARED_OPTS -DPIC"
2956                 MK_SHARED_LIB='${LD} -Bshareable -o $[@]'
2957                 test "$cf_cv_shlib_version" = auto && cf_cv_shlib_version=rel
2958                 ;;
2959         freebsd*) #(vi
2960                 CC_SHARED_OPTS="$CC_SHARED_OPTS -DPIC"
2961                 if test "$DFT_LWR_MODEL" = "shared" && test "$cf_cv_enable_rpath" = yes ; then
2962                         LOCAL_LDFLAGS="${cf_ld_rpath_opt}\$(LOCAL_LIBDIR)"
2963                         LOCAL_LDFLAGS2="${cf_ld_rpath_opt}\${libdir} $LOCAL_LDFLAGS"
2964                         EXTRA_LDFLAGS="${cf_ld_rpath_opt}\${libdir} $EXTRA_LDFLAGS"
2965                 fi
2966                 CF_SHARED_SONAME
2967                 MK_SHARED_LIB='${LD} -shared -Bshareable -soname=`basename $[@]` -o $[@]'
2968                 ;;
2969         netbsd*) #(vi
2970                 CC_SHARED_OPTS="$CC_SHARED_OPTS -DPIC"
2971                 if test "$DFT_LWR_MODEL" = "shared" && test "$cf_cv_enable_rpath" = yes ; then
2972                         LOCAL_LDFLAGS="${cf_ld_rpath_opt}\$(LOCAL_LIBDIR)"
2973                         LOCAL_LDFLAGS2="$LOCAL_LDFLAGS"
2974                         EXTRA_LDFLAGS="${cf_ld_rpath_opt}\${libdir} $EXTRA_LDFLAGS"
2975                         if test "$cf_cv_shlib_version" = auto; then
2976                         if test -f /usr/libexec/ld.elf_so; then
2977                                 cf_cv_shlib_version=abi
2978                         else
2979                                 cf_cv_shlib_version=rel
2980                         fi
2981                         fi
2982                         CF_SHARED_SONAME
2983                         MK_SHARED_LIB='${CC} ${CFLAGS} -shared -Wl,-soname,'$cf_cv_shared_soname' -o $[@]'
2984                 else
2985                         MK_SHARED_LIB='${LD} -shared -Bshareable -o $[@]'
2986                 fi
2987                 ;;
2988         osf*|mls+*) #(vi
2989                 # tested with OSF/1 V3.2 and 'cc'
2990                 # tested with OSF/1 V3.2 and gcc 2.6.3 (but the c++ demo didn't
2991                 # link with shared libs).
2992                 MK_SHARED_LIB='${LD} -set_version ${REL_VERSION}:${ABI_VERSION} -expect_unresolved "*" -shared -soname `basename $[@]`'
2993                 case $host_os in #(vi
2994                 osf4*)
2995                         MK_SHARED_LIB="${MK_SHARED_LIB} -msym"
2996                         ;;
2997                 esac
2998                 MK_SHARED_LIB="${MK_SHARED_LIB}"' -o $[@]'
2999                 if test "$DFT_LWR_MODEL" = "shared" ; then
3000                         LOCAL_LDFLAGS="${LD_RPATH_OPT}\$(LOCAL_LIBDIR)"
3001                         LOCAL_LDFLAGS2="$LOCAL_LDFLAGS"
3002                 fi
3003                 cf_cv_rm_so_locs=yes
3004                 ;;
3005         sco3.2v5*)  # (also uw2* and UW7: hops 13-Apr-98
3006                 # tested with osr5.0.5
3007                 if test "$GCC" != yes; then
3008                         CC_SHARED_OPTS='-belf -KPIC'
3009                 fi
3010                 MK_SHARED_LIB='${LD} -dy -G -h `basename $[@] .${REL_VERSION}`.${ABI_VERSION} -o [$]@'
3011                 if test "$cf_cv_enable_rpath" = yes ; then
3012                         # only way is to set LD_RUN_PATH but no switch for it
3013                         RUN_PATH=$libdir
3014                 fi
3015                 test "$cf_cv_shlib_version" = auto && cf_cv_shlib_version=rel
3016                 LINK_PROGS='LD_RUN_PATH=${libdir}'
3017                 LINK_TESTS='Pwd=`pwd`;LD_RUN_PATH=`dirname $${Pwd}`/lib'
3018                 ;;
3019         sunos4*) #(vi
3020                 # tested with SunOS 4.1.1 and gcc 2.7.0
3021                 if test "$GCC" != yes; then
3022                         CC_SHARED_OPTS='-KPIC'
3023                 fi
3024                 MK_SHARED_LIB='${LD} -assert pure-text -o $[@]'
3025                 test "$cf_cv_shlib_version" = auto && cf_cv_shlib_version=rel
3026                 ;;
3027         solaris2*) #(vi
3028                 # tested with SunOS 5.5.1 (solaris 2.5.1) and gcc 2.7.2
3029                 # tested with SunOS 5.10 (solaris 10) and gcc 3.4.3
3030                 if test "$DFT_LWR_MODEL" = "shared" ; then
3031                         LOCAL_LDFLAGS="-R \$(LOCAL_LIBDIR):\${libdir}"
3032                         LOCAL_LDFLAGS2="$LOCAL_LDFLAGS"
3033                 fi
3034                 if test "$cf_cv_enable_rpath" = yes ; then
3035                         EXTRA_LDFLAGS="-R \${libdir} $EXTRA_LDFLAGS"
3036                 fi
3037                 CF_SHARED_SONAME
3038                 if test "$GCC" != yes; then
3039                         cf_save_CFLAGS="$CFLAGS"
3040                         for cf_shared_opts in -xcode=pic32 -xcode=pic13 -KPIC -Kpic -O
3041                         do
3042                                 CFLAGS="$cf_shared_opts $cf_save_CFLAGS"
3043                                 AC_TRY_COMPILE([#include <stdio.h>],[printf("Hello\n");],[break])
3044                         done
3045                         CFLAGS="$cf_save_CFLAGS"
3046                         CC_SHARED_OPTS=$cf_shared_opts
3047                         MK_SHARED_LIB='${CC} -dy -G -h '$cf_cv_shared_soname' -o $[@]'
3048                 else
3049                         MK_SHARED_LIB='${CC} -shared -dy -G -h '$cf_cv_shared_soname' -o $[@]'
3050                 fi
3051                 ;;
3052         sysv5uw7*|unix_sv*) #(vi
3053                 # tested with UnixWare 7.1.0 (gcc 2.95.2 and cc)
3054                 if test "$GCC" != yes; then
3055                         CC_SHARED_OPTS='-KPIC'
3056                 fi
3057                 MK_SHARED_LIB='${LD} -d y -G -o [$]@'
3058                 ;;
3059         *)
3060                 CC_SHARED_OPTS='unknown'
3061                 MK_SHARED_LIB='echo unknown'
3062                 ;;
3063         esac
3064
3065         # This works if the last tokens in $MK_SHARED_LIB are the -o target.
3066         case "$cf_cv_shlib_version" in #(vi
3067         rel|abi)
3068                 case "$MK_SHARED_LIB" in #(vi
3069                 *'-o $[@]') #(vi
3070                         test "$cf_cv_do_symlinks" = no && cf_cv_do_symlinks=yes
3071                         ;;
3072                 *)
3073                         AC_MSG_WARN(ignored --with-shlib-version)
3074                         ;;
3075                 esac
3076                 ;;
3077         esac
3078
3079         if test -n "$cf_ld_rpath_opt" ; then
3080                 MK_SHARED_LIB="$MK_SHARED_LIB $cf_ld_rpath_opt\${libdir}"
3081         fi
3082
3083         AC_SUBST(CC_SHARED_OPTS)
3084         AC_SUBST(LD_RPATH_OPT)
3085         AC_SUBST(LD_SHARED_OPTS)
3086         AC_SUBST(MK_SHARED_LIB)
3087         AC_SUBST(LINK_PROGS)
3088         AC_SUBST(LINK_TESTS)
3089         AC_SUBST(EXTRA_LDFLAGS)
3090         AC_SUBST(LOCAL_LDFLAGS)
3091         AC_SUBST(LOCAL_LDFLAGS2)
3092         AC_SUBST(INSTALL_LIB)
3093 ])dnl
3094 dnl ---------------------------------------------------------------------------
3095 dnl CF_SHARED_SONAME version: 3 updated: 2008/09/08 18:34:43
3096 dnl ----------------
3097 dnl utility macro for CF_SHARED_OPTS, constructs "$cf_cv_shared_soname" for
3098 dnl substitution into MK_SHARED_LIB string for the "-soname" (or similar)
3099 dnl option.
3100 dnl
3101 dnl $1 is the default that should be used for "$cf_cv_shlib_version".
3102 dnl If missing, use "rel".
3103 define([CF_SHARED_SONAME],
3104 [
3105         test "$cf_cv_shlib_version" = auto && cf_cv_shlib_version=ifelse($1,,rel,$1)
3106         if test "$cf_cv_shlib_version" = rel; then
3107                 cf_cv_shared_soname='`basename $[@] .${REL_VERSION}`.${ABI_VERSION}'
3108         else
3109                 cf_cv_shared_soname='`basename $[@]`'
3110         fi
3111 ])
3112 dnl ---------------------------------------------------------------------------
3113 dnl CF_STRIP_G_OPT version: 3 updated: 2002/12/21 19:25:52
3114 dnl --------------
3115 dnl     Remove "-g" option from the compiler options
3116 AC_DEFUN([CF_STRIP_G_OPT],
3117 [$1=`echo ${$1} | sed -e 's%-g %%' -e 's%-g$%%'`])dnl
3118 dnl ---------------------------------------------------------------------------
3119 dnl CF_SUBDIR_PATH version: 6 updated: 2010/04/21 06:20:50
3120 dnl --------------
3121 dnl Construct a search-list for a nonstandard header/lib-file
3122 dnl     $1 = the variable to return as result
3123 dnl     $2 = the package name
3124 dnl     $3 = the subdirectory, e.g., bin, include or lib
3125 AC_DEFUN([CF_SUBDIR_PATH],
3126 [
3127 $1=
3128
3129 CF_ADD_SUBDIR_PATH($1,$2,$3,/usr,$prefix)
3130 CF_ADD_SUBDIR_PATH($1,$2,$3,$prefix,NONE)
3131 CF_ADD_SUBDIR_PATH($1,$2,$3,/usr/local,$prefix)
3132 CF_ADD_SUBDIR_PATH($1,$2,$3,/opt,$prefix)
3133 CF_ADD_SUBDIR_PATH($1,$2,$3,[$]HOME,$prefix)
3134 ])dnl
3135 dnl ---------------------------------------------------------------------------
3136 dnl CF_SUBST version: 4 updated: 2006/06/17 12:33:03
3137 dnl --------
3138 dnl     Shorthand macro for substituting things that the user may override
3139 dnl     with an environment variable.
3140 dnl
3141 dnl     $1 = long/descriptive name
3142 dnl     $2 = environment variable
3143 dnl     $3 = default value
3144 AC_DEFUN([CF_SUBST],
3145 [AC_CACHE_VAL(cf_cv_subst_$2,[
3146 AC_MSG_CHECKING(for $1 (symbol $2))
3147 CF_SUBST_IF([-z "[$]$2"], [$2], [$3])
3148 cf_cv_subst_$2=[$]$2
3149 AC_MSG_RESULT([$]$2)
3150 ])
3151 ])dnl
3152 dnl ---------------------------------------------------------------------------
3153 dnl CF_TERM_HEADER version: 2 updated: 2010/10/23 15:54:49
3154 dnl --------------
3155 dnl Look for term.h, which is part of X/Open curses.  It defines the interface
3156 dnl to terminfo database.  Usually it is in the same include-path as curses.h,
3157 dnl but some packagers change this, breaking various applications.
3158 AC_DEFUN([CF_TERM_HEADER],[
3159 AC_CACHE_CHECK(for terminfo header, cf_cv_term_header,[
3160 case ${cf_cv_ncurses_header} in #(vi
3161 */ncurses.h|*/ncursesw.h) #(vi
3162         cf_term_header=`echo "$cf_cv_ncurses_header" | sed -e 's%ncurses[[^.]]*\.h$%term.h%'`
3163         ;;
3164 *)
3165         cf_term_header=term.h
3166         ;;
3167 esac
3168
3169 for cf_test in $cf_term_header "ncurses/term.h" "ncursesw/term.h"
3170 do
3171 AC_TRY_COMPILE([#include <stdio.h>
3172 #include <${cf_cv_ncurses_header:-curses.h}>
3173 #include <$cf_test>
3174 ],[int x = auto_left_margin],[
3175         cf_cv_term_header="$cf_test"],[
3176         cf_cv_term_header=unknown
3177         ])
3178         test "$cf_cv_term_header" != unknown && break
3179 done
3180 ])
3181
3182 # Set definitions to allow ifdef'ing to accommodate subdirectories
3183
3184 case $cf_cv_term_header in # (vi
3185 *term.h)
3186         AC_DEFINE(HAVE_TERM_H)
3187         ;;
3188 esac
3189
3190 case $cf_cv_term_header in # (vi
3191 ncurses/term.h) #(vi
3192         AC_DEFINE(HAVE_NCURSES_TERM_H)
3193         ;;
3194 ncursesw/term.h)
3195         AC_DEFINE(HAVE_NCURSESW_TERM_H)
3196         ;;
3197 esac
3198 ])dnl
3199 dnl ---------------------------------------------------------------------------
3200 dnl CF_TOP_BUILDDIR version: 1 updated: 2006/10/15 16:33:23
3201 dnl ---------------
3202 dnl Define a top_builddir symbol, for applications that need an absolute path.
3203 AC_DEFUN([CF_TOP_BUILDDIR],
3204 [
3205 top_builddir=`pwd`
3206 AC_SUBST(top_builddir)
3207 ])dnl
3208 dnl ---------------------------------------------------------------------------
3209 dnl CF_UPPER version: 5 updated: 2001/01/29 23:40:59
3210 dnl --------
3211 dnl Make an uppercase version of a variable
3212 dnl $1=uppercase($2)
3213 AC_DEFUN([CF_UPPER],
3214 [
3215 $1=`echo "$2" | sed y%abcdefghijklmnopqrstuvwxyz./-%ABCDEFGHIJKLMNOPQRSTUVWXYZ___%`
3216 ])dnl
3217 dnl ---------------------------------------------------------------------------
3218 dnl CF_UTF8_LIB version: 7 updated: 2010/06/20 09:24:28
3219 dnl -----------
3220 dnl Check for multibyte support, and if not found, utf8 compatibility library
3221 AC_DEFUN([CF_UTF8_LIB],
3222 [
3223 AC_CACHE_CHECK(for multibyte character support,cf_cv_utf8_lib,[
3224         cf_save_LIBS="$LIBS"
3225         AC_TRY_LINK([
3226 #include <stdlib.h>],[putwc(0,0);],
3227         [cf_cv_utf8_lib=yes],
3228         [CF_FIND_LINKAGE([
3229 #include <libutf8.h>],[putwc(0,0);],utf8,
3230                 [cf_cv_utf8_lib=add-on],
3231                 [cf_cv_utf8_lib=no])
3232 ])])
3233
3234 # HAVE_LIBUTF8_H is used by ncurses if curses.h is shared between
3235 # ncurses/ncursesw:
3236 if test "$cf_cv_utf8_lib" = "add-on" ; then
3237         AC_DEFINE(HAVE_LIBUTF8_H)
3238         CF_ADD_INCDIR($cf_cv_header_path_utf8)
3239         CF_ADD_LIBDIR($cf_cv_library_path_utf8)
3240         CF_ADD_LIBS($cf_cv_library_file_utf8)
3241 fi
3242 ])dnl
3243 dnl ---------------------------------------------------------------------------
3244 dnl CF_VERBOSE version: 3 updated: 2007/07/29 09:55:12
3245 dnl ----------
3246 dnl Use AC_VERBOSE w/o the warnings
3247 AC_DEFUN([CF_VERBOSE],
3248 [test -n "$verbose" && echo "   $1" 1>&AC_FD_MSG
3249 CF_MSG_LOG([$1])
3250 ])dnl
3251 dnl ---------------------------------------------------------------------------
3252 dnl CF_WEAK_SYMBOLS version: 1 updated: 2008/08/16 19:18:06
3253 dnl ---------------
3254 dnl Check for compiler-support for weak symbols.
3255 dnl This works with "recent" gcc.
3256 AC_DEFUN([CF_WEAK_SYMBOLS],[
3257 AC_CACHE_CHECK(if $CC supports weak symbols,cf_cv_weak_symbols,[
3258
3259 AC_TRY_COMPILE([
3260 #include <stdio.h>],
3261 [
3262 #if defined(__GNUC__)
3263 #  if defined __USE_ISOC99
3264 #    define _cat_pragma(exp)    _Pragma(#exp)
3265 #    define _weak_pragma(exp)   _cat_pragma(weak name)
3266 #  else
3267 #    define _weak_pragma(exp)
3268 #  endif
3269 #  define _declare(name)        __extension__ extern __typeof__(name) name
3270 #  define weak_symbol(name)     _weak_pragma(name) _declare(name) __attribute__((weak))
3271 #endif
3272
3273 weak_symbol(fopen);
3274 ],[cf_cv_weak_symbols=yes],[cf_cv_weak_symbols=no])
3275 ])
3276 ])dnl
3277 dnl ---------------------------------------------------------------------------
3278 dnl CF_WITH_ADA_COMPILER version: 2 updated: 2010/06/26 17:35:58
3279 dnl --------------------
3280 dnl Command-line option to specify the Ada95 compiler.
3281 AC_DEFUN([CF_WITH_ADA_COMPILER],[
3282 AC_MSG_CHECKING(for ada-compiler)
3283 AC_ARG_WITH(ada-compiler,
3284         [  --with-ada-compiler=CMD specify Ada95 compiler command (default gnatmake)],
3285         [cf_ada_compiler=$withval],
3286         [cf_ada_compiler=gnatmake])
3287 AC_SUBST(cf_ada_compiler)
3288 AC_MSG_RESULT($cf_ada_compiler)
3289 ])dnl
3290 dnl ---------------------------------------------------------------------------
3291 dnl CF_WITH_ADA_INCLUDE version: 2 updated: 2010/06/26 17:35:58
3292 dnl -------------------
3293 dnl Command-line option to specify where Ada includes will install.
3294 AC_DEFUN([CF_WITH_ADA_INCLUDE],[
3295 AC_MSG_CHECKING(for ada-include)
3296 CF_WITH_PATH(ada-include,
3297    [  --with-ada-include=DIR  Ada includes are in DIR],
3298    ADA_INCLUDE,
3299    PREFIX/share/ada/adainclude,
3300    [$]prefix/share/ada/adainclude)
3301 AC_SUBST(ADA_INCLUDE)
3302 AC_MSG_RESULT($ADA_INCLUDE)
3303 ])dnl
3304 dnl ---------------------------------------------------------------------------
3305 dnl CF_WITH_ADA_OBJECTS version: 2 updated: 2010/06/26 17:35:58
3306 dnl -------------------
3307 dnl Command-line option to specify where Ada objects will install.
3308 AC_DEFUN([CF_WITH_ADA_OBJECTS],[
3309 AC_MSG_CHECKING(for ada-objects)
3310 CF_WITH_PATH(ada-objects,
3311    [  --with-ada-objects=DIR  Ada objects are in DIR],
3312    ADA_OBJECTS,
3313    PREFIX/lib/ada/adalib,
3314    [$]prefix/lib/ada/adalib)
3315 AC_SUBST(ADA_OBJECTS)
3316 AC_MSG_RESULT($ADA_OBJECTS)
3317 ])dnl
3318 dnl ---------------------------------------------------------------------------
3319 dnl CF_WITH_ADA_SHAREDLIB version: 2 updated: 2010/06/26 17:35:58
3320 dnl ---------------------
3321 dnl Command-line option to specify if an Ada95 shared-library should be built,
3322 dnl and optionally what its soname should be.
3323 AC_DEFUN([CF_WITH_ADA_SHAREDLIB],[
3324 AC_MSG_CHECKING(if an Ada95 shared-library should be built)
3325 AC_ARG_WITH(ada-sharedlib,
3326         [  --with-ada-sharedlib=XX build Ada95 shared-library],
3327         [with_ada_sharedlib=$withval],
3328         [with_ada_sharedlib=no])
3329 AC_MSG_RESULT($with_ada_sharedlib)
3330
3331 ADA_SHAREDLIB='lib$(LIB_NAME).so.1'
3332 MAKE_ADA_SHAREDLIB="#"
3333
3334 if test "x$with_ada_sharedlib" != xno
3335 then
3336         MAKE_ADA_SHAREDLIB=
3337         if test "x$with_ada_sharedlib" != xyes
3338         then
3339                 ADA_SHAREDLIB="$with_ada_sharedlib"
3340         fi
3341 fi
3342
3343 AC_SUBST(ADA_SHAREDLIB)
3344 AC_SUBST(MAKE_ADA_SHAREDLIB)
3345 ])dnl
3346 dnl ---------------------------------------------------------------------------
3347 dnl CF_WITH_CURSES_DIR version: 3 updated: 2010/11/20 17:02:38
3348 dnl ------------------
3349 dnl Wrapper for AC_ARG_WITH to specify directory under which to look for curses
3350 dnl libraries.
3351 AC_DEFUN([CF_WITH_CURSES_DIR],[
3352
3353 AC_MSG_CHECKING(for specific curses-directory)
3354 AC_ARG_WITH(curses-dir,
3355         [  --with-curses-dir=DIR   directory in which (n)curses is installed],
3356         [cf_cv_curses_dir=$withval],
3357         [cf_cv_curses_dir=no])
3358 AC_MSG_RESULT($cf_cv_curses_dir)
3359
3360 if ( test -n "$cf_cv_curses_dir" && test "$cf_cv_curses_dir" != "no" )
3361 then
3362         CF_PATH_SYNTAX(withval)
3363         if test -d "$cf_cv_curses_dir"
3364         then
3365                 CF_ADD_INCDIR($cf_cv_curses_dir/include)
3366                 CF_ADD_LIBDIR($cf_cv_curses_dir/lib)
3367         fi
3368 fi
3369 ])dnl
3370 dnl ---------------------------------------------------------------------------
3371 dnl CF_WITH_PATH version: 10 updated: 2010/10/23 15:44:18
3372 dnl ------------
3373 dnl Wrapper for AC_ARG_WITH to ensure that user supplies a pathname, not just
3374 dnl defaulting to yes/no.
3375 dnl
3376 dnl $1 = option name
3377 dnl $2 = help-text
3378 dnl $3 = environment variable to set
3379 dnl $4 = default value, shown in the help-message, must be a constant
3380 dnl $5 = default value, if it's an expression & cannot be in the help-message
3381 dnl
3382 AC_DEFUN([CF_WITH_PATH],
3383 [AC_ARG_WITH($1,[$2 ](default: ifelse([$4],,empty,[$4])),,
3384 ifelse([$4],,[withval="${$3}"],[withval="${$3:-ifelse([$5],,[$4],[$5])}"]))dnl
3385 if ifelse([$5],,true,[test -n "$5"]) ; then
3386 CF_PATH_SYNTAX(withval)
3387 fi
3388 $3="$withval"
3389 AC_SUBST($3)dnl
3390 ])dnl
3391 dnl ---------------------------------------------------------------------------
3392 dnl CF_WITH_PTHREAD version: 3 updated: 2010/05/29 16:31:02
3393 dnl ---------------
3394 dnl Check for POSIX thread library.
3395 AC_DEFUN([CF_WITH_PTHREAD],
3396 [
3397 AC_MSG_CHECKING(if you want to link with the pthread library)
3398 AC_ARG_WITH(pthread,
3399     [  --with-pthread          use POSIX thread library],
3400     [with_pthread=$withval],
3401     [with_pthread=no])
3402 AC_MSG_RESULT($with_pthread)
3403
3404 if test "$with_pthread" != no ; then
3405     AC_CHECK_HEADER(pthread.h,[
3406         AC_DEFINE(HAVE_PTHREADS_H)
3407
3408         AC_MSG_CHECKING(if we can link with the pthread library)
3409         cf_save_LIBS="$LIBS"
3410         CF_ADD_LIB(pthread)
3411         AC_TRY_LINK([
3412 #include <pthread.h>
3413 ],[
3414         int rc = pthread_create(0,0,0,0);
3415 ],[with_pthread=yes],[with_pthread=no])
3416         LIBS="$cf_save_LIBS"
3417         AC_MSG_RESULT($with_pthread)
3418
3419         if test "$with_pthread" = yes ; then
3420             CF_ADD_LIB(pthread)
3421             AC_DEFINE(HAVE_LIBPTHREADS)
3422         else
3423             AC_MSG_ERROR(Cannot link with pthread library)
3424         fi
3425     ])
3426 fi
3427 ])
3428 dnl ---------------------------------------------------------------------------
3429 dnl CF_XOPEN_SOURCE version: 35 updated: 2011/02/20 20:37:37
3430 dnl ---------------
3431 dnl Try to get _XOPEN_SOURCE defined properly that we can use POSIX functions,
3432 dnl or adapt to the vendor's definitions to get equivalent functionality,
3433 dnl without losing the common non-POSIX features.
3434 dnl
3435 dnl Parameters:
3436 dnl     $1 is the nominal value for _XOPEN_SOURCE
3437 dnl     $2 is the nominal value for _POSIX_C_SOURCE
3438 AC_DEFUN([CF_XOPEN_SOURCE],[
3439
3440 cf_XOPEN_SOURCE=ifelse([$1],,500,[$1])
3441 cf_POSIX_C_SOURCE=ifelse([$2],,199506L,[$2])
3442 cf_xopen_source=
3443
3444 case $host_os in #(vi
3445 aix[[456]]*) #(vi
3446         cf_xopen_source="-D_ALL_SOURCE"
3447         ;;
3448 cygwin) #(vi
3449         cf_XOPEN_SOURCE=600
3450         ;;
3451 darwin[[0-8]].*) #(vi
3452         cf_xopen_source="-D_APPLE_C_SOURCE"
3453         ;;
3454 darwin*) #(vi
3455         cf_xopen_source="-D_DARWIN_C_SOURCE"
3456         ;;
3457 freebsd*|dragonfly*) #(vi
3458         # 5.x headers associate
3459         #       _XOPEN_SOURCE=600 with _POSIX_C_SOURCE=200112L
3460         #       _XOPEN_SOURCE=500 with _POSIX_C_SOURCE=199506L
3461         cf_POSIX_C_SOURCE=200112L
3462         cf_XOPEN_SOURCE=600
3463         cf_xopen_source="-D_BSD_TYPES -D__BSD_VISIBLE -D_POSIX_C_SOURCE=$cf_POSIX_C_SOURCE -D_XOPEN_SOURCE=$cf_XOPEN_SOURCE"
3464         ;;
3465 hpux11*) #(vi
3466         cf_xopen_source="-D_HPUX_SOURCE -D_XOPEN_SOURCE=500"
3467         ;;
3468 hpux*) #(vi
3469         cf_xopen_source="-D_HPUX_SOURCE"
3470         ;;
3471 irix[[56]].*) #(vi
3472         cf_xopen_source="-D_SGI_SOURCE"
3473         ;;
3474 linux*|gnu*|mint*|k*bsd*-gnu) #(vi
3475         CF_GNU_SOURCE
3476         ;;
3477 mirbsd*) #(vi
3478         # setting _XOPEN_SOURCE or _POSIX_SOURCE breaks <arpa/inet.h>
3479         ;;
3480 netbsd*) #(vi
3481         # setting _XOPEN_SOURCE breaks IPv6 for lynx on NetBSD 1.6, breaks xterm, is not needed for ncursesw
3482         ;;
3483 openbsd*) #(vi
3484         # setting _XOPEN_SOURCE breaks xterm on OpenBSD 2.8, is not needed for ncursesw
3485         ;;
3486 osf[[45]]*) #(vi
3487         cf_xopen_source="-D_OSF_SOURCE"
3488         ;;
3489 nto-qnx*) #(vi
3490         cf_xopen_source="-D_QNX_SOURCE"
3491         ;;
3492 sco*) #(vi
3493         # setting _XOPEN_SOURCE breaks Lynx on SCO Unix / OpenServer
3494         ;;
3495 solaris2.1[[0-9]]) #(vi
3496         cf_xopen_source="-D__EXTENSIONS__ -D_XOPEN_SOURCE=$cf_XOPEN_SOURCE"
3497         ;;
3498 solaris2.[[1-9]]) #(vi
3499         cf_xopen_source="-D__EXTENSIONS__"
3500         ;;
3501 *)
3502         AC_CACHE_CHECK(if we should define _XOPEN_SOURCE,cf_cv_xopen_source,[
3503         AC_TRY_COMPILE([#include <sys/types.h>],[
3504 #ifndef _XOPEN_SOURCE
3505 make an error
3506 #endif],
3507         [cf_cv_xopen_source=no],
3508         [cf_save="$CPPFLAGS"
3509          CPPFLAGS="$CPPFLAGS -D_XOPEN_SOURCE=$cf_XOPEN_SOURCE"
3510          AC_TRY_COMPILE([#include <sys/types.h>],[
3511 #ifdef _XOPEN_SOURCE
3512 make an error
3513 #endif],
3514         [cf_cv_xopen_source=no],
3515         [cf_cv_xopen_source=$cf_XOPEN_SOURCE])
3516         CPPFLAGS="$cf_save"
3517         ])
3518 ])
3519         if test "$cf_cv_xopen_source" != no ; then
3520                 CF_REMOVE_DEFINE(CFLAGS,$CFLAGS,_XOPEN_SOURCE)
3521                 CF_REMOVE_DEFINE(CPPFLAGS,$CPPFLAGS,_XOPEN_SOURCE)
3522                 cf_temp_xopen_source="-D_XOPEN_SOURCE=$cf_cv_xopen_source"
3523                 CF_ADD_CFLAGS($cf_temp_xopen_source)
3524         fi
3525         CF_POSIX_C_SOURCE($cf_POSIX_C_SOURCE)
3526         ;;
3527 esac
3528
3529 if test -n "$cf_xopen_source" ; then
3530         CF_ADD_CFLAGS($cf_xopen_source)
3531 fi
3532 ])