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