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