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