ncurses 6.0 - patch 20170930
[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.120 2017/09/30 19:48:36 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: 8 updated: 2017/09/23 08:50:24
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: 12 updated: 2017/07/23 17:46:07
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(void)
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: 18 updated: 2017/07/23 18:30:00
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                 CF_TERM_HEADER
2277
2278         else
2279                 AC_MSG_RESULT(no)
2280                 NCURSES_CONFIG_PKG=none
2281         fi
2282 else
2283         NCURSES_CONFIG_PKG=none
2284 fi
2285
2286 if test "x$cf_have_ncuconfig" = "xno"; then
2287         echo "Looking for ${cf_ncuconfig_root}-config"
2288
2289         CF_ACVERSION_CHECK(2.52,
2290                 [AC_CHECK_TOOLS(NCURSES_CONFIG, ${cf_ncuconfig_root}-config ${cf_ncuconfig_root}6-config ${cf_ncuconfig_root}5-config, none)],
2291                 [AC_PATH_PROGS(NCURSES_CONFIG,  ${cf_ncuconfig_root}-config ${cf_ncuconfig_root}6-config ${cf_ncuconfig_root}5-config, none)])
2292
2293         if test "$NCURSES_CONFIG" != none ; then
2294
2295                 CPPFLAGS="$CPPFLAGS `$NCURSES_CONFIG --cflags`"
2296                 CF_ADD_LIBS(`$NCURSES_CONFIG --libs`)
2297
2298                 # even with config script, some packages use no-override for curses.h
2299                 CF_CURSES_HEADER(ifelse($1,,ncurses,$1))
2300
2301                 dnl like CF_NCURSES_CPPFLAGS
2302                 AC_DEFINE(NCURSES,1,[Define to 1 if we are using ncurses headers/libraries])
2303
2304                 dnl like CF_NCURSES_LIBS
2305                 CF_UPPER(cf_nculib_ROOT,HAVE_LIB$cf_ncuconfig_root)
2306                 AC_DEFINE_UNQUOTED($cf_nculib_ROOT)
2307
2308                 dnl like CF_NCURSES_VERSION
2309                 cf_cv_ncurses_version=`$NCURSES_CONFIG --version`
2310
2311         else
2312
2313                 CF_NCURSES_CPPFLAGS(ifelse($1,,ncurses,$1))
2314                 CF_NCURSES_LIBS(ifelse($1,,ncurses,$1))
2315
2316         fi
2317 else
2318         NCURSES_CONFIG=none
2319 fi
2320 ])dnl
2321 dnl ---------------------------------------------------------------------------
2322 dnl CF_NCURSES_CPPFLAGS version: 21 updated: 2012/10/06 08:57:51
2323 dnl -------------------
2324 dnl Look for the SVr4 curses clone 'ncurses' in the standard places, adjusting
2325 dnl the CPPFLAGS variable so we can include its header.
2326 dnl
2327 dnl The header files may be installed as either curses.h, or ncurses.h (would
2328 dnl be obsolete, except that some packagers prefer this name to distinguish it
2329 dnl from a "native" curses implementation).  If not installed for overwrite,
2330 dnl the curses.h file would be in an ncurses subdirectory (e.g.,
2331 dnl /usr/include/ncurses), but someone may have installed overwriting the
2332 dnl vendor's curses.  Only very old versions (pre-1.9.2d, the first autoconf'd
2333 dnl version) of ncurses don't define either __NCURSES_H or NCURSES_VERSION in
2334 dnl the header.
2335 dnl
2336 dnl If the installer has set $CFLAGS or $CPPFLAGS so that the ncurses header
2337 dnl is already in the include-path, don't even bother with this, since we cannot
2338 dnl easily determine which file it is.  In this case, it has to be <curses.h>.
2339 dnl
2340 dnl The optional parameter gives the root name of the library, in case it is
2341 dnl not installed as the default curses library.  That is how the
2342 dnl wide-character version of ncurses is installed.
2343 AC_DEFUN([CF_NCURSES_CPPFLAGS],
2344 [AC_REQUIRE([CF_WITH_CURSES_DIR])
2345
2346 AC_PROVIDE([CF_CURSES_CPPFLAGS])dnl
2347 cf_ncuhdr_root=ifelse($1,,ncurses,$1)
2348
2349 test -n "$cf_cv_curses_dir" && \
2350 test "$cf_cv_curses_dir" != "no" && { \
2351   CF_ADD_INCDIR($cf_cv_curses_dir/include/$cf_ncuhdr_root)
2352 }
2353
2354 AC_CACHE_CHECK(for $cf_ncuhdr_root header in include-path, cf_cv_ncurses_h,[
2355         cf_header_list="$cf_ncuhdr_root/curses.h $cf_ncuhdr_root/ncurses.h"
2356         ( test "$cf_ncuhdr_root" = ncurses || test "$cf_ncuhdr_root" = ncursesw ) && cf_header_list="$cf_header_list curses.h ncurses.h"
2357         for cf_header in $cf_header_list
2358         do
2359                 CF_NCURSES_CC_CHECK(cf_cv_ncurses_h,$cf_header,$1)
2360                 test "$cf_cv_ncurses_h" != no && break
2361         done
2362 ])
2363
2364 CF_NCURSES_HEADER
2365 CF_TERM_HEADER
2366
2367 # some applications need this, but should check for NCURSES_VERSION
2368 AC_DEFINE(NCURSES,1,[Define to 1 if we are using ncurses headers/libraries])
2369
2370 CF_NCURSES_VERSION
2371 ])dnl
2372 dnl ---------------------------------------------------------------------------
2373 dnl CF_NCURSES_HEADER version: 4 updated: 2015/04/15 19:08:48
2374 dnl -----------------
2375 dnl Find a "curses" header file, e.g,. "curses.h", or one of the more common
2376 dnl variations of ncurses' installs.
2377 dnl
2378 dnl See also CF_CURSES_HEADER, which sets the same cache variable.
2379 AC_DEFUN([CF_NCURSES_HEADER],[
2380
2381 if test "$cf_cv_ncurses_h" != no ; then
2382         cf_cv_ncurses_header=$cf_cv_ncurses_h
2383 else
2384
2385 AC_CACHE_CHECK(for $cf_ncuhdr_root include-path, cf_cv_ncurses_h2,[
2386         test -n "$verbose" && echo
2387         CF_HEADER_PATH(cf_search,$cf_ncuhdr_root)
2388         test -n "$verbose" && echo search path $cf_search
2389         cf_save2_CPPFLAGS="$CPPFLAGS"
2390         for cf_incdir in $cf_search
2391         do
2392                 CF_ADD_INCDIR($cf_incdir)
2393                 for cf_header in \
2394                         ncurses.h \
2395                         curses.h
2396                 do
2397                         CF_NCURSES_CC_CHECK(cf_cv_ncurses_h2,$cf_header,$1)
2398                         if test "$cf_cv_ncurses_h2" != no ; then
2399                                 cf_cv_ncurses_h2=$cf_incdir/$cf_header
2400                                 test -n "$verbose" && echo $ac_n "      ... found $ac_c" 1>&AC_FD_MSG
2401                                 break
2402                         fi
2403                         test -n "$verbose" && echo "    ... tested $cf_incdir/$cf_header" 1>&AC_FD_MSG
2404                 done
2405                 CPPFLAGS="$cf_save2_CPPFLAGS"
2406                 test "$cf_cv_ncurses_h2" != no && break
2407         done
2408         test "$cf_cv_ncurses_h2" = no && AC_MSG_ERROR(not found)
2409         ])
2410
2411         CF_DIRNAME(cf_1st_incdir,$cf_cv_ncurses_h2)
2412         cf_cv_ncurses_header=`basename $cf_cv_ncurses_h2`
2413         if test `basename $cf_1st_incdir` = $cf_ncuhdr_root ; then
2414                 cf_cv_ncurses_header=$cf_ncuhdr_root/$cf_cv_ncurses_header
2415         fi
2416         CF_ADD_INCDIR($cf_1st_incdir)
2417
2418 fi
2419
2420 # Set definitions to allow ifdef'ing for ncurses.h
2421
2422 case $cf_cv_ncurses_header in
2423 (*ncurses.h)
2424         AC_DEFINE(HAVE_NCURSES_H,1,[Define to 1 if we have ncurses.h])
2425         ;;
2426 esac
2427
2428 case $cf_cv_ncurses_header in
2429 (ncurses/curses.h|ncurses/ncurses.h)
2430         AC_DEFINE(HAVE_NCURSES_NCURSES_H,1,[Define to 1 if we have ncurses/ncurses.h])
2431         ;;
2432 (ncursesw/curses.h|ncursesw/ncurses.h)
2433         AC_DEFINE(HAVE_NCURSESW_NCURSES_H,1,[Define to 1 if we have ncursesw/ncurses.h])
2434         ;;
2435 esac
2436
2437 ])dnl
2438 dnl ---------------------------------------------------------------------------
2439 dnl CF_NCURSES_LIBS version: 17 updated: 2015/04/15 19:08:48
2440 dnl ---------------
2441 dnl Look for the ncurses library.  This is a little complicated on Linux,
2442 dnl because it may be linked with the gpm (general purpose mouse) library.
2443 dnl Some distributions have gpm linked with (bsd) curses, which makes it
2444 dnl unusable with ncurses.  However, we don't want to link with gpm unless
2445 dnl ncurses has a dependency, since gpm is normally set up as a shared library,
2446 dnl and the linker will record a dependency.
2447 dnl
2448 dnl The optional parameter gives the root name of the library, in case it is
2449 dnl not installed as the default curses library.  That is how the
2450 dnl wide-character version of ncurses is installed.
2451 AC_DEFUN([CF_NCURSES_LIBS],
2452 [AC_REQUIRE([CF_NCURSES_CPPFLAGS])
2453
2454 cf_nculib_root=ifelse($1,,ncurses,$1)
2455         # This works, except for the special case where we find gpm, but
2456         # ncurses is in a nonstandard location via $LIBS, and we really want
2457         # to link gpm.
2458 cf_ncurses_LIBS=""
2459 cf_ncurses_SAVE="$LIBS"
2460 AC_CHECK_LIB(gpm,Gpm_Open,
2461         [AC_CHECK_LIB(gpm,initscr,
2462                 [LIBS="$cf_ncurses_SAVE"],
2463                 [cf_ncurses_LIBS="-lgpm"])])
2464
2465 case $host_os in
2466 (freebsd*)
2467         # This is only necessary if you are linking against an obsolete
2468         # version of ncurses (but it should do no harm, since it's static).
2469         if test "$cf_nculib_root" = ncurses ; then
2470                 AC_CHECK_LIB(mytinfo,tgoto,[cf_ncurses_LIBS="-lmytinfo $cf_ncurses_LIBS"])
2471         fi
2472         ;;
2473 esac
2474
2475 CF_ADD_LIBS($cf_ncurses_LIBS)
2476
2477 if ( test -n "$cf_cv_curses_dir" && test "$cf_cv_curses_dir" != "no" )
2478 then
2479         CF_ADD_LIBS(-l$cf_nculib_root)
2480 else
2481         CF_FIND_LIBRARY($cf_nculib_root,$cf_nculib_root,
2482                 [#include <${cf_cv_ncurses_header:-curses.h}>],
2483                 [initscr()],
2484                 initscr)
2485 fi
2486
2487 if test -n "$cf_ncurses_LIBS" ; then
2488         AC_MSG_CHECKING(if we can link $cf_nculib_root without $cf_ncurses_LIBS)
2489         cf_ncurses_SAVE="$LIBS"
2490         for p in $cf_ncurses_LIBS ; do
2491                 q=`echo $LIBS | sed -e "s%$p %%" -e "s%$p$%%"`
2492                 if test "$q" != "$LIBS" ; then
2493                         LIBS="$q"
2494                 fi
2495         done
2496         AC_TRY_LINK([#include <${cf_cv_ncurses_header:-curses.h}>],
2497                 [initscr(); mousemask(0,0); tgoto((char *)0, 0, 0);],
2498                 [AC_MSG_RESULT(yes)],
2499                 [AC_MSG_RESULT(no)
2500                  LIBS="$cf_ncurses_SAVE"])
2501 fi
2502
2503 CF_UPPER(cf_nculib_ROOT,HAVE_LIB$cf_nculib_root)
2504 AC_DEFINE_UNQUOTED($cf_nculib_ROOT)
2505 ])dnl
2506 dnl ---------------------------------------------------------------------------
2507 dnl CF_NCURSES_VERSION version: 15 updated: 2017/05/09 19:26:10
2508 dnl ------------------
2509 dnl Check for the version of ncurses, to aid in reporting bugs, etc.
2510 dnl Call CF_CURSES_CPPFLAGS first, or CF_NCURSES_CPPFLAGS.  We don't use
2511 dnl AC_REQUIRE since that does not work with the shell's if/then/else/fi.
2512 AC_DEFUN([CF_NCURSES_VERSION],
2513 [
2514 AC_REQUIRE([CF_CURSES_CPPFLAGS])dnl
2515 AC_CACHE_CHECK(for ncurses version, cf_cv_ncurses_version,[
2516         cf_cv_ncurses_version=no
2517         cf_tempfile=out$$
2518         rm -f $cf_tempfile
2519         AC_TRY_RUN([
2520 #include <${cf_cv_ncurses_header:-curses.h}>
2521 #include <stdio.h>
2522 int main(void)
2523 {
2524         FILE *fp = fopen("$cf_tempfile", "w");
2525 #ifdef NCURSES_VERSION
2526 # ifdef NCURSES_VERSION_PATCH
2527         fprintf(fp, "%s.%d\n", NCURSES_VERSION, NCURSES_VERSION_PATCH);
2528 # else
2529         fprintf(fp, "%s\n", NCURSES_VERSION);
2530 # endif
2531 #else
2532 # ifdef __NCURSES_H
2533         fprintf(fp, "old\n");
2534 # else
2535         make an error
2536 # endif
2537 #endif
2538         ${cf_cv_main_return:-return}(0);
2539 }],[
2540         cf_cv_ncurses_version=`cat $cf_tempfile`],,[
2541
2542         # This will not work if the preprocessor splits the line after the
2543         # Autoconf token.  The 'unproto' program does that.
2544         cat > conftest.$ac_ext <<EOF
2545 #include <${cf_cv_ncurses_header:-curses.h}>
2546 #undef Autoconf
2547 #ifdef NCURSES_VERSION
2548 Autoconf NCURSES_VERSION
2549 #else
2550 #ifdef __NCURSES_H
2551 Autoconf "old"
2552 #endif
2553 ;
2554 #endif
2555 EOF
2556         cf_try="$ac_cpp conftest.$ac_ext 2>&AC_FD_CC | grep '^Autoconf ' >conftest.out"
2557         AC_TRY_EVAL(cf_try)
2558         if test -f conftest.out ; then
2559                 cf_out=`cat conftest.out | sed -e 's%^Autoconf %%' -e 's%^[[^"]]*"%%' -e 's%".*%%'`
2560                 test -n "$cf_out" && cf_cv_ncurses_version="$cf_out"
2561                 rm -f conftest.out
2562         fi
2563 ])
2564         rm -f $cf_tempfile
2565 ])
2566 test "$cf_cv_ncurses_version" = no || AC_DEFINE(NCURSES,1,[Define to 1 if we are using ncurses headers/libraries])
2567 ])dnl
2568 dnl ---------------------------------------------------------------------------
2569 dnl CF_OBJ_SUBDIR version: 7 updated: 2015/04/17 21:13:04
2570 dnl -------------
2571 dnl Compute the object-directory name from the given model name
2572 AC_DEFUN([CF_OBJ_SUBDIR],
2573 [
2574         case $1 in
2575         (libtool) $2='obj_lo'  ;;
2576         (normal)  $2='objects' ;;
2577         (debug)   $2='obj_g' ;;
2578         (profile) $2='obj_p' ;;
2579         (shared)
2580                 case $cf_cv_system_name in
2581                 (cygwin|msys)
2582                         $2='objects' ;;
2583                 (*)
2584                         $2='obj_s' ;;
2585                 esac
2586         esac
2587 ])dnl
2588 dnl ---------------------------------------------------------------------------
2589 dnl CF_PATHSEP version: 7 updated: 2015/04/12 15:39:00
2590 dnl ----------
2591 dnl Provide a value for the $PATH and similar separator (or amend the value
2592 dnl as provided in autoconf 2.5x).
2593 AC_DEFUN([CF_PATHSEP],
2594 [
2595         AC_MSG_CHECKING(for PATH separator)
2596         case $cf_cv_system_name in
2597         (os2*)  PATH_SEPARATOR=';'  ;;
2598         (*)     ${PATH_SEPARATOR:=':'}  ;;
2599         esac
2600 ifelse([$1],,,[$1=$PATH_SEPARATOR])
2601         AC_SUBST(PATH_SEPARATOR)
2602         AC_MSG_RESULT($PATH_SEPARATOR)
2603 ])dnl
2604 dnl ---------------------------------------------------------------------------
2605 dnl CF_PATH_SYNTAX version: 16 updated: 2015/04/18 08:56:57
2606 dnl --------------
2607 dnl Check the argument to see that it looks like a pathname.  Rewrite it if it
2608 dnl begins with one of the prefix/exec_prefix variables, and then again if the
2609 dnl result begins with 'NONE'.  This is necessary to work around autoconf's
2610 dnl delayed evaluation of those symbols.
2611 AC_DEFUN([CF_PATH_SYNTAX],[
2612 if test "x$prefix" != xNONE; then
2613         cf_path_syntax="$prefix"
2614 else
2615         cf_path_syntax="$ac_default_prefix"
2616 fi
2617
2618 case ".[$]$1" in
2619 (.\[$]\(*\)*|.\'*\'*)
2620         ;;
2621 (..|./*|.\\*)
2622         ;;
2623 (.[[a-zA-Z]]:[[\\/]]*) # OS/2 EMX
2624         ;;
2625 (.\[$]{*prefix}*|.\[$]{*dir}*)
2626         eval $1="[$]$1"
2627         case ".[$]$1" in
2628         (.NONE/*)
2629                 $1=`echo [$]$1 | sed -e s%NONE%$cf_path_syntax%`
2630                 ;;
2631         esac
2632         ;;
2633 (.no|.NONE/*)
2634         $1=`echo [$]$1 | sed -e s%NONE%$cf_path_syntax%`
2635         ;;
2636 (*)
2637         ifelse([$2],,[AC_MSG_ERROR([expected a pathname, not \"[$]$1\"])],$2)
2638         ;;
2639 esac
2640 ])dnl
2641 dnl ---------------------------------------------------------------------------
2642 dnl CF_PKG_CONFIG version: 10 updated: 2015/04/26 18:06:58
2643 dnl -------------
2644 dnl Check for the package-config program, unless disabled by command-line.
2645 AC_DEFUN([CF_PKG_CONFIG],
2646 [
2647 AC_MSG_CHECKING(if you want to use pkg-config)
2648 AC_ARG_WITH(pkg-config,
2649         [  --with-pkg-config{=path} enable/disable use of pkg-config],
2650         [cf_pkg_config=$withval],
2651         [cf_pkg_config=yes])
2652 AC_MSG_RESULT($cf_pkg_config)
2653
2654 case $cf_pkg_config in
2655 (no)
2656         PKG_CONFIG=none
2657         ;;
2658 (yes)
2659         CF_ACVERSION_CHECK(2.52,
2660                 [AC_PATH_TOOL(PKG_CONFIG, pkg-config, none)],
2661                 [AC_PATH_PROG(PKG_CONFIG, pkg-config, none)])
2662         ;;
2663 (*)
2664         PKG_CONFIG=$withval
2665         ;;
2666 esac
2667
2668 test -z "$PKG_CONFIG" && PKG_CONFIG=none
2669 if test "$PKG_CONFIG" != none ; then
2670         CF_PATH_SYNTAX(PKG_CONFIG)
2671 elif test "x$cf_pkg_config" != xno ; then
2672         AC_MSG_WARN(pkg-config is not installed)
2673 fi
2674
2675 AC_SUBST(PKG_CONFIG)
2676 ])dnl
2677 dnl ---------------------------------------------------------------------------
2678 dnl CF_POSIX_C_SOURCE version: 9 updated: 2015/04/12 15:39:00
2679 dnl -----------------
2680 dnl Define _POSIX_C_SOURCE to the given level, and _POSIX_SOURCE if needed.
2681 dnl
2682 dnl     POSIX.1-1990                            _POSIX_SOURCE
2683 dnl     POSIX.1-1990 and                        _POSIX_SOURCE and
2684 dnl             POSIX.2-1992 C-Language                 _POSIX_C_SOURCE=2
2685 dnl             Bindings Option
2686 dnl     POSIX.1b-1993                           _POSIX_C_SOURCE=199309L
2687 dnl     POSIX.1c-1996                           _POSIX_C_SOURCE=199506L
2688 dnl     X/Open 2000                             _POSIX_C_SOURCE=200112L
2689 dnl
2690 dnl Parameters:
2691 dnl     $1 is the nominal value for _POSIX_C_SOURCE
2692 AC_DEFUN([CF_POSIX_C_SOURCE],
2693 [
2694 cf_POSIX_C_SOURCE=ifelse([$1],,199506L,[$1])
2695
2696 cf_save_CFLAGS="$CFLAGS"
2697 cf_save_CPPFLAGS="$CPPFLAGS"
2698
2699 CF_REMOVE_DEFINE(cf_trim_CFLAGS,$cf_save_CFLAGS,_POSIX_C_SOURCE)
2700 CF_REMOVE_DEFINE(cf_trim_CPPFLAGS,$cf_save_CPPFLAGS,_POSIX_C_SOURCE)
2701
2702 AC_CACHE_CHECK(if we should define _POSIX_C_SOURCE,cf_cv_posix_c_source,[
2703         CF_MSG_LOG(if the symbol is already defined go no further)
2704         AC_TRY_COMPILE([#include <sys/types.h>],[
2705 #ifndef _POSIX_C_SOURCE
2706 make an error
2707 #endif],
2708         [cf_cv_posix_c_source=no],
2709         [cf_want_posix_source=no
2710          case .$cf_POSIX_C_SOURCE in
2711          (.[[12]]??*)
2712                 cf_cv_posix_c_source="-D_POSIX_C_SOURCE=$cf_POSIX_C_SOURCE"
2713                 ;;
2714          (.2)
2715                 cf_cv_posix_c_source="-D_POSIX_C_SOURCE=$cf_POSIX_C_SOURCE"
2716                 cf_want_posix_source=yes
2717                 ;;
2718          (.*)
2719                 cf_want_posix_source=yes
2720                 ;;
2721          esac
2722          if test "$cf_want_posix_source" = yes ; then
2723                 AC_TRY_COMPILE([#include <sys/types.h>],[
2724 #ifdef _POSIX_SOURCE
2725 make an error
2726 #endif],[],
2727                 cf_cv_posix_c_source="$cf_cv_posix_c_source -D_POSIX_SOURCE")
2728          fi
2729          CF_MSG_LOG(ifdef from value $cf_POSIX_C_SOURCE)
2730          CFLAGS="$cf_trim_CFLAGS"
2731          CPPFLAGS="$cf_trim_CPPFLAGS $cf_cv_posix_c_source"
2732          CF_MSG_LOG(if the second compile does not leave our definition intact error)
2733          AC_TRY_COMPILE([#include <sys/types.h>],[
2734 #ifndef _POSIX_C_SOURCE
2735 make an error
2736 #endif],,
2737          [cf_cv_posix_c_source=no])
2738          CFLAGS="$cf_save_CFLAGS"
2739          CPPFLAGS="$cf_save_CPPFLAGS"
2740         ])
2741 ])
2742
2743 if test "$cf_cv_posix_c_source" != no ; then
2744         CFLAGS="$cf_trim_CFLAGS"
2745         CPPFLAGS="$cf_trim_CPPFLAGS"
2746         CF_ADD_CFLAGS($cf_cv_posix_c_source)
2747 fi
2748
2749 ])dnl
2750 dnl ---------------------------------------------------------------------------
2751 dnl CF_PROG_AR version: 1 updated: 2009/01/01 20:15:22
2752 dnl ----------
2753 dnl Check for archiver "ar".
2754 AC_DEFUN([CF_PROG_AR],[
2755 AC_CHECK_TOOL(AR, ar, ar)
2756 ])
2757 dnl ---------------------------------------------------------------------------
2758 dnl CF_PROG_AWK version: 1 updated: 2006/09/16 11:40:59
2759 dnl -----------
2760 dnl Check for awk, ensure that the check found something.
2761 AC_DEFUN([CF_PROG_AWK],
2762 [
2763 AC_PROG_AWK
2764 test -z "$AWK" && AC_MSG_ERROR(No awk program found)
2765 ])dnl
2766 dnl ---------------------------------------------------------------------------
2767 dnl CF_PROG_CC version: 4 updated: 2014/07/12 18:57:58
2768 dnl ----------
2769 dnl standard check for CC, plus followup sanity checks
2770 dnl $1 = optional parameter to pass to AC_PROG_CC to specify compiler name
2771 AC_DEFUN([CF_PROG_CC],[
2772 ifelse($1,,[AC_PROG_CC],[AC_PROG_CC($1)])
2773 CF_GCC_VERSION
2774 CF_ACVERSION_CHECK(2.52,
2775         [AC_PROG_CC_STDC],
2776         [CF_ANSI_CC_REQD])
2777 CF_CC_ENV_FLAGS
2778 ])dnl
2779 dnl ---------------------------------------------------------------------------
2780 dnl CF_PROG_CC_C_O version: 5 updated: 2017/01/21 11:06:25
2781 dnl --------------
2782 dnl Analogous to AC_PROG_CC_C_O, but more useful: tests only $CC, ensures that
2783 dnl the output file can be renamed, and allows for a shell variable that can
2784 dnl be used later.  The parameter is either CC or CXX.  The result is the
2785 dnl cache variable:
2786 dnl     $cf_cv_prog_CC_c_o
2787 dnl     $cf_cv_prog_CXX_c_o
2788 dnl
2789 dnl $1 = compiler
2790 dnl $2 = compiler options, if any
2791 AC_DEFUN([CF_PROG_CC_C_O],
2792 [AC_REQUIRE([AC_PROG_CC])dnl
2793 AC_MSG_CHECKING([whether [$]$1 understands -c and -o together])
2794 AC_CACHE_VAL(cf_cv_prog_$1_c_o,
2795 [
2796 cat > conftest.$ac_ext <<CF_EOF
2797 int main(void)
2798 {
2799         ${cf_cv_main_return:-return}(0);
2800 }
2801 CF_EOF
2802 # We do the test twice because some compilers refuse to overwrite an
2803 # existing .o file with -o, though they will create one.
2804 ac_try='[$]$1 $2 -c conftest.$ac_ext -o conftest2.$ac_objext >&AC_FD_CC'
2805 if AC_TRY_EVAL(ac_try) &&
2806   test -f conftest2.$ac_objext && AC_TRY_EVAL(ac_try);
2807 then
2808   eval cf_cv_prog_$1_c_o=yes
2809 else
2810   eval cf_cv_prog_$1_c_o=no
2811 fi
2812 rm -rf conftest*
2813 ])dnl
2814 if test $cf_cv_prog_$1_c_o = yes; then
2815   AC_MSG_RESULT([yes])
2816 else
2817   AC_MSG_RESULT([no])
2818 fi
2819 ])dnl
2820 dnl ---------------------------------------------------------------------------
2821 dnl CF_PROG_EGREP version: 2 updated: 2015/04/18 08:56:57
2822 dnl -------------
2823 dnl AC_PROG_EGREP was introduced in autoconf 2.53.
2824 dnl This macro adds a check to ensure the script found something.
2825 AC_DEFUN([CF_PROG_EGREP],
2826 [AC_CACHE_CHECK([for egrep], [ac_cv_prog_egrep],
2827         [if echo a | (grep -E '(a|b)') >/dev/null 2>&1
2828                 then ac_cv_prog_egrep='grep -E'
2829                 else ac_cv_prog_egrep='egrep'
2830         fi])
2831         EGREP=$ac_cv_prog_egrep
2832         AC_SUBST([EGREP])
2833         test -z "$EGREP" && AC_MSG_ERROR(No egrep program found)
2834 ])dnl
2835 dnl ---------------------------------------------------------------------------
2836 dnl CF_PROG_EXT version: 13 updated: 2015/04/18 09:03:58
2837 dnl -----------
2838 dnl Compute $PROG_EXT, used for non-Unix ports, such as OS/2 EMX.
2839 AC_DEFUN([CF_PROG_EXT],
2840 [
2841 AC_REQUIRE([CF_CHECK_CACHE])
2842 case $cf_cv_system_name in
2843 (os2*)
2844         CFLAGS="$CFLAGS -Zmt"
2845         CPPFLAGS="$CPPFLAGS -D__ST_MT_ERRNO__"
2846         CXXFLAGS="$CXXFLAGS -Zmt"
2847         # autoconf's macro sets -Zexe and suffix both, which conflict:w
2848         LDFLAGS="$LDFLAGS -Zmt -Zcrtdll"
2849         ac_cv_exeext=.exe
2850         ;;
2851 esac
2852
2853 AC_EXEEXT
2854 AC_OBJEXT
2855
2856 PROG_EXT="$EXEEXT"
2857 AC_SUBST(PROG_EXT)
2858 test -n "$PROG_EXT" && AC_DEFINE_UNQUOTED(PROG_EXT,"$PROG_EXT",[Define to the program extension (normally blank)])
2859 ])dnl
2860 dnl ---------------------------------------------------------------------------
2861 dnl CF_PROG_GNAT version: 3 updated: 2015/04/18 08:56:57
2862 dnl ------------
2863 dnl Check for gnatmake, ensure that it is complete.
2864 AC_DEFUN([CF_PROG_GNAT],[
2865 cf_ada_make=gnatmake
2866 AC_CHECK_PROG(gnat_exists, $cf_ada_make, yes, no)
2867 if test "$ac_cv_prog_gnat_exists" = no; then
2868         cf_ada_make=
2869         cf_cv_prog_gnat_correct=no
2870 else
2871         CF_GNAT_VERSION
2872         AC_CHECK_PROG(M4_exists, m4, yes, no)
2873         if test "$ac_cv_prog_M4_exists" = no; then
2874                 cf_cv_prog_gnat_correct=no
2875                 echo Ada95 binding required program m4 not found. Ada95 binding disabled.
2876         fi
2877         if test "$cf_cv_prog_gnat_correct" = yes; then
2878                 AC_MSG_CHECKING(if GNAT works)
2879                 CF_GNAT_TRY_RUN([procedure conftest;],
2880 [with Text_IO;
2881 with GNAT.OS_Lib;
2882 procedure conftest is
2883 begin
2884    Text_IO.Put ("Hello World");
2885    Text_IO.New_Line;
2886    GNAT.OS_Lib.OS_Exit (0);
2887 end conftest;],[cf_cv_prog_gnat_correct=yes],[cf_cv_prog_gnat_correct=no])
2888                 AC_MSG_RESULT($cf_cv_prog_gnat_correct)
2889         fi
2890 fi
2891
2892 AC_SUBST(cf_ada_make)
2893 ])dnl
2894 dnl ---------------------------------------------------------------------------
2895 dnl CF_PROG_LN_S version: 2 updated: 2010/08/14 18:25:37
2896 dnl ------------
2897 dnl Combine checks for "ln -s" and "ln -sf", updating $LN_S to include "-f"
2898 dnl option if it is supported.
2899 AC_DEFUN([CF_PROG_LN_S],[
2900 AC_PROG_LN_S
2901 AC_MSG_CHECKING(if $LN_S -f options work)
2902
2903 rm -f conf$$.src conf$$dst
2904 echo >conf$$.dst
2905 echo first >conf$$.src
2906 if $LN_S -f conf$$.src conf$$.dst 2>/dev/null; then
2907         cf_prog_ln_sf=yes
2908 else
2909         cf_prog_ln_sf=no
2910 fi
2911 rm -f conf$$.dst conf$$src
2912 AC_MSG_RESULT($cf_prog_ln_sf)
2913
2914 test "$cf_prog_ln_sf" = yes && LN_S="$LN_S -f"
2915 ])dnl
2916 dnl ---------------------------------------------------------------------------
2917 dnl CF_REMOVE_DEFINE version: 3 updated: 2010/01/09 11:05:50
2918 dnl ----------------
2919 dnl Remove all -U and -D options that refer to the given symbol from a list
2920 dnl of C compiler options.  This works around the problem that not all
2921 dnl compilers process -U and -D options from left-to-right, so a -U option
2922 dnl cannot be used to cancel the effect of a preceding -D option.
2923 dnl
2924 dnl $1 = target (which could be the same as the source variable)
2925 dnl $2 = source (including '$')
2926 dnl $3 = symbol to remove
2927 define([CF_REMOVE_DEFINE],
2928 [
2929 $1=`echo "$2" | \
2930         sed     -e 's/-[[UD]]'"$3"'\(=[[^       ]]*\)\?[[       ]]/ /g' \
2931                 -e 's/-[[UD]]'"$3"'\(=[[^       ]]*\)\?[$]//g'`
2932 ])dnl
2933 dnl ---------------------------------------------------------------------------
2934 dnl CF_REMOVE_LIB version: 1 updated: 2007/02/17 14:11:52
2935 dnl -------------
2936 dnl Remove the given library from the symbol
2937 dnl
2938 dnl $1 = target (which could be the same as the source variable)
2939 dnl $2 = source (including '$')
2940 dnl $3 = library to remove
2941 define([CF_REMOVE_LIB],
2942 [
2943 # remove $3 library from $2
2944 $1=`echo "$2" | sed -e 's/-l$3[[        ]]//g' -e 's/-l$3[$]//'`
2945 ])dnl
2946 dnl ---------------------------------------------------------------------------
2947 dnl CF_SHARED_OPTS version: 90 updated: 2017/02/11 14:48:57
2948 dnl --------------
2949 dnl --------------
2950 dnl Attempt to determine the appropriate CC/LD options for creating a shared
2951 dnl library.
2952 dnl
2953 dnl Notes:
2954 dnl a) ${LOCAL_LDFLAGS} is used to link executables that will run within
2955 dnl the build-tree, i.e., by making use of the libraries that are compiled in
2956 dnl $rel_builddir/lib We avoid compiling-in a $rel_builddir/lib path for the
2957 dnl shared library since that can lead to unexpected results at runtime.
2958 dnl b) ${LOCAL_LDFLAGS2} has the same intention but assumes that the shared
2959 dnl libraries are compiled in ../../lib
2960 dnl
2961 dnl The variable 'cf_cv_do_symlinks' is used to control whether we configure
2962 dnl to install symbolic links to the rel/abi versions of shared libraries.
2963 dnl
2964 dnl The variable 'cf_cv_shlib_version' controls whether we use the rel or abi
2965 dnl version when making symbolic links.
2966 dnl
2967 dnl The variable 'cf_cv_shlib_version_infix' controls whether shared library
2968 dnl version numbers are infix (ex: libncurses.<ver>.dylib) or postfix
2969 dnl (ex: libncurses.so.<ver>).
2970 dnl
2971 dnl Some loaders leave 'so_locations' lying around.  It's nice to clean up.
2972 AC_DEFUN([CF_SHARED_OPTS],
2973 [
2974         AC_REQUIRE([CF_LD_RPATH_OPT])
2975         RM_SHARED_OPTS=
2976         LOCAL_LDFLAGS=
2977         LOCAL_LDFLAGS2=
2978         LD_SHARED_OPTS=
2979         INSTALL_LIB="-m 644"
2980         : ${rel_builddir:=.}
2981
2982         shlibdir=$libdir
2983         AC_SUBST(shlibdir)
2984
2985         MAKE_DLLS="#"
2986         AC_SUBST(MAKE_DLLS)
2987
2988         cf_cv_do_symlinks=no
2989         cf_ld_rpath_opt=
2990         test "$cf_cv_enable_rpath" = yes && cf_ld_rpath_opt="$LD_RPATH_OPT"
2991
2992         AC_MSG_CHECKING(if release/abi version should be used for shared libs)
2993         AC_ARG_WITH(shlib-version,
2994         [  --with-shlib-version=X  Specify rel or abi version for shared libs],
2995         [test -z "$withval" && withval=auto
2996         case $withval in
2997         (yes)
2998                 cf_cv_shlib_version=auto
2999                 ;;
3000         (rel|abi|auto)
3001                 cf_cv_shlib_version=$withval
3002                 ;;
3003         (*)
3004                 AC_MSG_RESULT($withval)
3005                 AC_MSG_ERROR([option value must be one of: rel, abi, or auto])
3006                 ;;
3007         esac
3008         ],[cf_cv_shlib_version=auto])
3009         AC_MSG_RESULT($cf_cv_shlib_version)
3010
3011         cf_cv_rm_so_locs=no
3012         cf_try_cflags=
3013
3014         # Some less-capable ports of gcc support only -fpic
3015         CC_SHARED_OPTS=
3016
3017         cf_try_fPIC=no
3018         if test "$GCC" = yes
3019         then
3020                 cf_try_fPIC=yes
3021         else
3022                 case $cf_cv_system_name in
3023                 (*linux*)       # e.g., PGI compiler
3024                         cf_try_fPIC=yes
3025                         ;;
3026                 esac
3027         fi
3028
3029         if test "$cf_try_fPIC" = yes
3030         then
3031                 AC_MSG_CHECKING(which $CC option to use)
3032                 cf_save_CFLAGS="$CFLAGS"
3033                 for CC_SHARED_OPTS in -fPIC -fpic ''
3034                 do
3035                         CFLAGS="$cf_save_CFLAGS $CC_SHARED_OPTS"
3036                         AC_TRY_COMPILE([#include <stdio.h>],[int x = 1],[break],[])
3037                 done
3038                 AC_MSG_RESULT($CC_SHARED_OPTS)
3039                 CFLAGS="$cf_save_CFLAGS"
3040         fi
3041
3042         cf_cv_shlib_version_infix=no
3043
3044         case $cf_cv_system_name in
3045         (aix4.[3-9]*|aix[[5-7]]*)
3046                 if test "$GCC" = yes; then
3047                         CC_SHARED_OPTS='-Wl,-brtl'
3048                         MK_SHARED_LIB='${CC} -shared -Wl,-brtl -Wl,-blibpath:${RPATH_LIST}:/usr/lib -o [$]@'
3049                 else
3050                         CC_SHARED_OPTS='-brtl'
3051                         # as well as '-qpic=large -G' or perhaps "-bM:SRE -bnoentry -bexpall"
3052                         MK_SHARED_LIB='${CC} -G -Wl,-brtl -Wl,-blibpath:${RPATH_LIST}:/usr/lib -o [$]@'
3053                 fi
3054                 ;;
3055         (beos*)
3056                 MK_SHARED_LIB='${CC} ${CFLAGS} -o $[@] -Xlinker -soname=`basename $[@]` -nostart -e 0'
3057                 ;;
3058         (cygwin*)
3059                 CC_SHARED_OPTS=
3060                 MK_SHARED_LIB=$SHELL' '$rel_builddir'/mk_shared_lib.sh [$]@ [$]{CC} [$]{CFLAGS}'
3061                 RM_SHARED_OPTS="$RM_SHARED_OPTS $rel_builddir/mk_shared_lib.sh *.dll.a"
3062                 cf_cv_shlib_version=cygdll
3063                 cf_cv_shlib_version_infix=cygdll
3064                 shlibdir=$bindir
3065                 MAKE_DLLS=
3066                 cat >mk_shared_lib.sh <<-CF_EOF
3067                 #!$SHELL
3068                 SHARED_LIB=\[$]1
3069                 IMPORT_LIB=\`echo "\[$]1" | sed -e 's/cyg/lib/' -e 's/[[0-9]]*\.dll[$]/.dll.a/'\`
3070                 shift
3071                 cat <<-EOF
3072                 Linking shared library
3073                 ** SHARED_LIB \[$]SHARED_LIB
3074                 ** IMPORT_LIB \[$]IMPORT_LIB
3075 EOF
3076                 exec \[$]* -shared -Wl,--out-implib=\[$]{IMPORT_LIB} -Wl,--export-all-symbols -o \[$]{SHARED_LIB}
3077 CF_EOF
3078                 chmod +x mk_shared_lib.sh
3079                 ;;
3080         (msys*)
3081                 CC_SHARED_OPTS=
3082                 MK_SHARED_LIB=$SHELL' '$rel_builddir'/mk_shared_lib.sh [$]@ [$]{CC} [$]{CFLAGS}'
3083                 RM_SHARED_OPTS="$RM_SHARED_OPTS $rel_builddir/mk_shared_lib.sh *.dll.a"
3084                 cf_cv_shlib_version=msysdll
3085                 cf_cv_shlib_version_infix=msysdll
3086                 shlibdir=$bindir
3087                 MAKE_DLLS=
3088                 cat >mk_shared_lib.sh <<-CF_EOF
3089                 #!$SHELL
3090                 SHARED_LIB=\[$]1
3091                 IMPORT_LIB=\`echo "\[$]1" | sed -e 's/msys-/lib/' -e 's/[[0-9]]*\.dll[$]/.dll.a/'\`
3092                 shift
3093                 cat <<-EOF
3094                 Linking shared library
3095                 ** SHARED_LIB \[$]SHARED_LIB
3096                 ** IMPORT_LIB \[$]IMPORT_LIB
3097 EOF
3098                 exec \[$]* -shared -Wl,--out-implib=\[$]{IMPORT_LIB} -Wl,--export-all-symbols -o \[$]{SHARED_LIB}
3099 CF_EOF
3100                 chmod +x mk_shared_lib.sh
3101                 ;;
3102         (darwin*)
3103                 cf_try_cflags="no-cpp-precomp"
3104                 CC_SHARED_OPTS="-dynamic"
3105                 MK_SHARED_LIB='${CC} ${CFLAGS} -dynamiclib -install_name ${libdir}/`basename $[@]` -compatibility_version ${ABI_VERSION} -current_version ${ABI_VERSION} -o $[@]'
3106                 test "$cf_cv_shlib_version" = auto && cf_cv_shlib_version=abi
3107                 cf_cv_shlib_version_infix=yes
3108                 AC_CACHE_CHECK([if ld -search_paths_first works], cf_cv_ldflags_search_paths_first, [
3109                         cf_save_LDFLAGS=$LDFLAGS
3110                         LDFLAGS="$LDFLAGS -Wl,-search_paths_first"
3111                         AC_TRY_LINK(, [int i;], cf_cv_ldflags_search_paths_first=yes, cf_cv_ldflags_search_paths_first=no)
3112                                 LDFLAGS=$cf_save_LDFLAGS])
3113                 if test $cf_cv_ldflags_search_paths_first = yes; then
3114                         LDFLAGS="$LDFLAGS -Wl,-search_paths_first"
3115                 fi
3116                 ;;
3117         (hpux[[7-8]]*)
3118                 # HP-UX 8.07 ld lacks "+b" option used for libdir search-list
3119                 if test "$GCC" != yes; then
3120                         CC_SHARED_OPTS='+Z'
3121                 fi
3122                 MK_SHARED_LIB='${LD} -b -o $[@]'
3123                 INSTALL_LIB="-m 555"
3124                 ;;
3125         (hpux*)
3126                 # (tested with gcc 2.7.2 -- I don't have c89)
3127                 if test "$GCC" = yes; then
3128                         LD_SHARED_OPTS='-Xlinker +b -Xlinker ${libdir}'
3129                 else
3130                         CC_SHARED_OPTS='+Z'
3131                         LD_SHARED_OPTS='-Wl,+b,${libdir}'
3132                 fi
3133                 MK_SHARED_LIB='${LD} +b ${libdir} -b -o $[@]'
3134                 # HP-UX shared libraries must be executable, and should be
3135                 # readonly to exploit a quirk in the memory manager.
3136                 INSTALL_LIB="-m 555"
3137                 ;;
3138         (interix*)
3139                 test "$cf_cv_shlib_version" = auto && cf_cv_shlib_version=rel
3140                 if test "$cf_cv_shlib_version" = rel; then
3141                         cf_shared_soname='`basename $@ .${REL_VERSION}`.${ABI_VERSION}'
3142                 else
3143                         cf_shared_soname='`basename $@`'
3144                 fi
3145                 CC_SHARED_OPTS=
3146                 MK_SHARED_LIB='${CC} -shared -Wl,-rpath,${RPATH_LIST} -Wl,-h,'$cf_shared_soname' -o $@'
3147                 ;;
3148         (irix*)
3149                 if test "$cf_cv_enable_rpath" = yes ; then
3150                         EXTRA_LDFLAGS="${cf_ld_rpath_opt}\${RPATH_LIST} $EXTRA_LDFLAGS"
3151                 fi
3152                 # tested with IRIX 5.2 and 'cc'.
3153                 if test "$GCC" != yes; then
3154                         CC_SHARED_OPTS='-KPIC'
3155                         MK_SHARED_LIB='${CC} -shared -rdata_shared -soname `basename $[@]` -o $[@]'
3156                 else
3157                         MK_SHARED_LIB='${CC} -shared -Wl,-soname,`basename $[@]` -o $[@]'
3158                 fi
3159                 cf_cv_rm_so_locs=yes
3160                 ;;
3161         (linux*|gnu*|k*bsd*-gnu)
3162                 if test "$DFT_LWR_MODEL" = "shared" ; then
3163                         LOCAL_LDFLAGS="${LD_RPATH_OPT}\$(LOCAL_LIBDIR)"
3164                         LOCAL_LDFLAGS2="$LOCAL_LDFLAGS"
3165                 fi
3166                 if test "$cf_cv_enable_rpath" = yes ; then
3167                         EXTRA_LDFLAGS="${cf_ld_rpath_opt}\${RPATH_LIST} $EXTRA_LDFLAGS"
3168                 fi
3169                 CF_SHARED_SONAME
3170                 MK_SHARED_LIB='${CC} ${CFLAGS} -shared -Wl,-soname,'$cf_cv_shared_soname',-stats,-lc -o $[@]'
3171                 ;;
3172         (mingw*)
3173                 cf_cv_shlib_version=mingw
3174                 cf_cv_shlib_version_infix=mingw
3175                 shlibdir=$bindir
3176                 MAKE_DLLS=
3177                 if test "$DFT_LWR_MODEL" = "shared" ; then
3178                         LOCAL_LDFLAGS="-Wl,--enable-auto-import"
3179                         LOCAL_LDFLAGS2="$LOCAL_LDFLAGS"
3180                         EXTRA_LDFLAGS="-Wl,--enable-auto-import $EXTRA_LDFLAGS"
3181                 fi
3182                 CC_SHARED_OPTS=
3183                 MK_SHARED_LIB=$SHELL' '$rel_builddir'/mk_shared_lib.sh [$]@ [$]{CC} [$]{CFLAGS}'
3184                 RM_SHARED_OPTS="$RM_SHARED_OPTS $rel_builddir/mk_shared_lib.sh *.dll.a"
3185                 cat >mk_shared_lib.sh <<-CF_EOF
3186                 #!$SHELL
3187                 SHARED_LIB=\[$]1
3188                 IMPORT_LIB=\`echo "\[$]1" | sed -e 's/[[0-9]]*\.dll[$]/.dll.a/'\`
3189                 shift
3190                 cat <<-EOF
3191                 Linking shared library
3192                 ** SHARED_LIB \[$]SHARED_LIB
3193                 ** IMPORT_LIB \[$]IMPORT_LIB
3194 EOF
3195                 exec \[$]* -shared -Wl,--enable-auto-import,--out-implib=\[$]{IMPORT_LIB} -Wl,--export-all-symbols -o \[$]{SHARED_LIB}
3196 CF_EOF
3197                 chmod +x mk_shared_lib.sh
3198                 ;;
3199         (openbsd[[2-9]].*|mirbsd*)
3200                 if test "$DFT_LWR_MODEL" = "shared" ; then
3201                         LOCAL_LDFLAGS="${LD_RPATH_OPT}\$(LOCAL_LIBDIR)"
3202                         LOCAL_LDFLAGS2="$LOCAL_LDFLAGS"
3203                 fi
3204                 if test "$cf_cv_enable_rpath" = yes ; then
3205                         EXTRA_LDFLAGS="${cf_ld_rpath_opt}\${RPATH_LIST} $EXTRA_LDFLAGS"
3206                 fi
3207                 CC_SHARED_OPTS="$CC_SHARED_OPTS -DPIC"
3208                 CF_SHARED_SONAME
3209                 MK_SHARED_LIB='${CC} ${CFLAGS} -shared -Wl,-Bshareable,-soname,'$cf_cv_shared_soname',-stats,-lc -o $[@]'
3210                 ;;
3211         (nto-qnx*|openbsd*|freebsd[[12]].*)
3212                 CC_SHARED_OPTS="$CC_SHARED_OPTS -DPIC"
3213                 MK_SHARED_LIB='${LD} -Bshareable -o $[@]'
3214                 test "$cf_cv_shlib_version" = auto && cf_cv_shlib_version=rel
3215                 ;;
3216         (dragonfly*|freebsd*)
3217                 CC_SHARED_OPTS="$CC_SHARED_OPTS -DPIC"
3218                 if test "$DFT_LWR_MODEL" = "shared" && test "$cf_cv_enable_rpath" = yes ; then
3219                         LOCAL_LDFLAGS="${cf_ld_rpath_opt}\$(LOCAL_LIBDIR)"
3220                         LOCAL_LDFLAGS2="${cf_ld_rpath_opt}\${RPATH_LIST} $LOCAL_LDFLAGS"
3221                         EXTRA_LDFLAGS="${cf_ld_rpath_opt}\${RPATH_LIST} $EXTRA_LDFLAGS"
3222                 fi
3223                 CF_SHARED_SONAME
3224                 MK_SHARED_LIB='${CC} ${CFLAGS} -shared -Wl,-soname,'$cf_cv_shared_soname',-stats,-lc -o $[@]'
3225                 ;;
3226         (netbsd*)
3227                 CC_SHARED_OPTS="$CC_SHARED_OPTS -DPIC"
3228                 if test "$DFT_LWR_MODEL" = "shared" && test "$cf_cv_enable_rpath" = yes ; then
3229                         LOCAL_LDFLAGS="${cf_ld_rpath_opt}\$(LOCAL_LIBDIR)"
3230                         LOCAL_LDFLAGS2="$LOCAL_LDFLAGS"
3231                         EXTRA_LDFLAGS="${cf_ld_rpath_opt}\${RPATH_LIST} $EXTRA_LDFLAGS"
3232                         if test "$cf_cv_shlib_version" = auto; then
3233                         if test -f /usr/libexec/ld.elf_so; then
3234                                 cf_cv_shlib_version=abi
3235                         else
3236                                 cf_cv_shlib_version=rel
3237                         fi
3238                         fi
3239                         CF_SHARED_SONAME
3240                         MK_SHARED_LIB='${CC} ${CFLAGS} -shared -Wl,-soname,'$cf_cv_shared_soname' -o $[@]'
3241                 else
3242                         MK_SHARED_LIB='${CC} -Wl,-shared -Wl,-Bshareable -o $[@]'
3243                 fi
3244                 ;;
3245         (osf*|mls+*)
3246                 # tested with OSF/1 V3.2 and 'cc'
3247                 # tested with OSF/1 V3.2 and gcc 2.6.3 (but the c++ demo didn't
3248                 # link with shared libs).
3249                 MK_SHARED_LIB='${LD} -set_version ${REL_VERSION}:${ABI_VERSION} -expect_unresolved "*" -shared -soname `basename $[@]`'
3250                 case $host_os in
3251                 (osf4*)
3252                         MK_SHARED_LIB="${MK_SHARED_LIB} -msym"
3253                         ;;
3254                 esac
3255                 MK_SHARED_LIB="${MK_SHARED_LIB}"' -o $[@]'
3256                 if test "$DFT_LWR_MODEL" = "shared" ; then
3257                         LOCAL_LDFLAGS="${LD_RPATH_OPT}\$(LOCAL_LIBDIR)"
3258                         LOCAL_LDFLAGS2="$LOCAL_LDFLAGS"
3259                 fi
3260                 cf_cv_rm_so_locs=yes
3261                 ;;
3262         (sco3.2v5*)  # also uw2* and UW7: hops 13-Apr-98
3263                 # tested with osr5.0.5
3264                 if test "$GCC" != yes; then
3265                         CC_SHARED_OPTS='-belf -KPIC'
3266                 fi
3267                 MK_SHARED_LIB='${LD} -dy -G -h `basename $[@] .${REL_VERSION}`.${ABI_VERSION} -o [$]@'
3268                 if test "$cf_cv_enable_rpath" = yes ; then
3269                         # only way is to set LD_RUN_PATH but no switch for it
3270                         RUN_PATH=$libdir
3271                 fi
3272                 test "$cf_cv_shlib_version" = auto && cf_cv_shlib_version=rel
3273                 LINK_PROGS='LD_RUN_PATH=${libdir}'
3274                 LINK_TESTS='Pwd=`pwd`;LD_RUN_PATH=`dirname $${Pwd}`/lib'
3275                 ;;
3276         (sunos4*)
3277                 # tested with SunOS 4.1.1 and gcc 2.7.0
3278                 if test "$GCC" != yes; then
3279                         CC_SHARED_OPTS='-KPIC'
3280                 fi
3281                 MK_SHARED_LIB='${LD} -assert pure-text -o $[@]'
3282                 test "$cf_cv_shlib_version" = auto && cf_cv_shlib_version=rel
3283                 ;;
3284         (solaris2*)
3285                 # tested with SunOS 5.5.1 (solaris 2.5.1) and gcc 2.7.2
3286                 # tested with SunOS 5.10 (solaris 10) and gcc 3.4.3
3287                 if test "$DFT_LWR_MODEL" = "shared" ; then
3288                         LOCAL_LDFLAGS="-R \$(LOCAL_LIBDIR):\${libdir}"
3289                         LOCAL_LDFLAGS2="$LOCAL_LDFLAGS"
3290                 fi
3291                 if test "$cf_cv_enable_rpath" = yes ; then
3292                         EXTRA_LDFLAGS="-R \${libdir} $EXTRA_LDFLAGS"
3293                 fi
3294                 CF_SHARED_SONAME
3295                 if test "$GCC" != yes; then
3296                         cf_save_CFLAGS="$CFLAGS"
3297                         for cf_shared_opts in -xcode=pic32 -xcode=pic13 -KPIC -Kpic -O
3298                         do
3299                                 CFLAGS="$cf_shared_opts $cf_save_CFLAGS"
3300                                 AC_TRY_COMPILE([#include <stdio.h>],[printf("Hello\n");],[break])
3301                         done
3302                         CFLAGS="$cf_save_CFLAGS"
3303                         CC_SHARED_OPTS=$cf_shared_opts
3304                         MK_SHARED_LIB='${CC} -dy -G -h '$cf_cv_shared_soname' -o $[@]'
3305                 else
3306                         MK_SHARED_LIB='${CC} -shared -dy -G -h '$cf_cv_shared_soname' -o $[@]'
3307                 fi
3308                 ;;
3309         (sysv5uw7*|unix_sv*)
3310                 # tested with UnixWare 7.1.0 (gcc 2.95.2 and cc)
3311                 if test "$GCC" != yes; then
3312                         CC_SHARED_OPTS='-KPIC'
3313                 fi
3314                 MK_SHARED_LIB='${LD} -d y -G -o [$]@'
3315                 ;;
3316         (*)
3317                 CC_SHARED_OPTS='unknown'
3318                 MK_SHARED_LIB='echo unknown'
3319                 ;;
3320         esac
3321
3322         # This works if the last tokens in $MK_SHARED_LIB are the -o target.
3323         case "$cf_cv_shlib_version" in
3324         (rel|abi)
3325                 case "$MK_SHARED_LIB" in
3326                 (*'-o $[@]')
3327                         test "$cf_cv_do_symlinks" = no && cf_cv_do_symlinks=yes
3328                         ;;
3329                 (*)
3330                         AC_MSG_WARN(ignored --with-shlib-version)
3331                         ;;
3332                 esac
3333                 ;;
3334         esac
3335
3336         if test -n "$cf_try_cflags"
3337         then
3338 cat > conftest.$ac_ext <<EOF
3339 #line __oline__ "${as_me:-configure}"
3340 #include <stdio.h>
3341 int main(int argc, char *argv[[]])
3342 {
3343         printf("hello\n");
3344         return (argv[[argc-1]] == 0) ;
3345 }
3346 EOF
3347                 cf_save_CFLAGS="$CFLAGS"
3348                 for cf_opt in $cf_try_cflags
3349                 do
3350                         CFLAGS="$cf_save_CFLAGS -$cf_opt"
3351                         AC_MSG_CHECKING(if CFLAGS option -$cf_opt works)
3352                         if AC_TRY_EVAL(ac_compile); then
3353                                 AC_MSG_RESULT(yes)
3354                                 cf_save_CFLAGS="$CFLAGS"
3355                         else
3356                                 AC_MSG_RESULT(no)
3357                         fi
3358                 done
3359                 CFLAGS="$cf_save_CFLAGS"
3360         fi
3361
3362
3363         # RPATH_LIST is a colon-separated list of directories
3364         test -n "$cf_ld_rpath_opt" && MK_SHARED_LIB="$MK_SHARED_LIB $cf_ld_rpath_opt\${RPATH_LIST}"
3365         test -z "$RPATH_LIST" && RPATH_LIST="\${libdir}"
3366
3367         test $cf_cv_rm_so_locs = yes && RM_SHARED_OPTS="$RM_SHARED_OPTS so_locations"
3368
3369         CF_VERBOSE(CC_SHARED_OPTS: $CC_SHARED_OPTS)
3370         CF_VERBOSE(MK_SHARED_LIB:  $MK_SHARED_LIB)
3371
3372         AC_SUBST(CC_SHARED_OPTS)
3373         AC_SUBST(LD_RPATH_OPT)
3374         AC_SUBST(LD_SHARED_OPTS)
3375         AC_SUBST(MK_SHARED_LIB)
3376         AC_SUBST(RM_SHARED_OPTS)
3377
3378         AC_SUBST(LINK_PROGS)
3379         AC_SUBST(LINK_TESTS)
3380
3381         AC_SUBST(EXTRA_LDFLAGS)
3382         AC_SUBST(LOCAL_LDFLAGS)
3383         AC_SUBST(LOCAL_LDFLAGS2)
3384
3385         AC_SUBST(INSTALL_LIB)
3386         AC_SUBST(RPATH_LIST)
3387 ])dnl
3388 dnl ---------------------------------------------------------------------------
3389 dnl CF_SHARED_SONAME version: 3 updated: 2008/09/08 18:34:43
3390 dnl ----------------
3391 dnl utility macro for CF_SHARED_OPTS, constructs "$cf_cv_shared_soname" for
3392 dnl substitution into MK_SHARED_LIB string for the "-soname" (or similar)
3393 dnl option.
3394 dnl
3395 dnl $1 is the default that should be used for "$cf_cv_shlib_version".
3396 dnl If missing, use "rel".
3397 define([CF_SHARED_SONAME],
3398 [
3399         test "$cf_cv_shlib_version" = auto && cf_cv_shlib_version=ifelse($1,,rel,$1)
3400         if test "$cf_cv_shlib_version" = rel; then
3401                 cf_cv_shared_soname='`basename $[@] .${REL_VERSION}`.${ABI_VERSION}'
3402         else
3403                 cf_cv_shared_soname='`basename $[@]`'
3404         fi
3405 ])
3406 dnl ---------------------------------------------------------------------------
3407 dnl CF_STRIP_G_OPT version: 3 updated: 2002/12/21 19:25:52
3408 dnl --------------
3409 dnl     Remove "-g" option from the compiler options
3410 AC_DEFUN([CF_STRIP_G_OPT],
3411 [$1=`echo ${$1} | sed -e 's%-g %%' -e 's%-g$%%'`])dnl
3412 dnl ---------------------------------------------------------------------------
3413 dnl CF_SUBDIR_PATH version: 7 updated: 2014/12/04 04:33:06
3414 dnl --------------
3415 dnl Construct a search-list for a nonstandard header/lib-file
3416 dnl     $1 = the variable to return as result
3417 dnl     $2 = the package name
3418 dnl     $3 = the subdirectory, e.g., bin, include or lib
3419 AC_DEFUN([CF_SUBDIR_PATH],
3420 [
3421 $1=
3422
3423 CF_ADD_SUBDIR_PATH($1,$2,$3,$prefix,NONE)
3424
3425 for cf_subdir_prefix in \
3426         /usr \
3427         /usr/local \
3428         /usr/pkg \
3429         /opt \
3430         /opt/local \
3431         [$]HOME
3432 do
3433         CF_ADD_SUBDIR_PATH($1,$2,$3,$cf_subdir_prefix,$prefix)
3434 done
3435 ])dnl
3436 dnl ---------------------------------------------------------------------------
3437 dnl CF_TERM_HEADER version: 4 updated: 2015/04/15 19:08:48
3438 dnl --------------
3439 dnl Look for term.h, which is part of X/Open curses.  It defines the interface
3440 dnl to terminfo database.  Usually it is in the same include-path as curses.h,
3441 dnl but some packagers change this, breaking various applications.
3442 AC_DEFUN([CF_TERM_HEADER],[
3443 AC_CACHE_CHECK(for terminfo header, cf_cv_term_header,[
3444 case ${cf_cv_ncurses_header} in
3445 (*/ncurses.h|*/ncursesw.h)
3446         cf_term_header=`echo "$cf_cv_ncurses_header" | sed -e 's%ncurses[[^.]]*\.h$%term.h%'`
3447         ;;
3448 (*)
3449         cf_term_header=term.h
3450         ;;
3451 esac
3452
3453 for cf_test in $cf_term_header "ncurses/term.h" "ncursesw/term.h"
3454 do
3455 AC_TRY_COMPILE([#include <stdio.h>
3456 #include <${cf_cv_ncurses_header:-curses.h}>
3457 #include <$cf_test>
3458 ],[int x = auto_left_margin],[
3459         cf_cv_term_header="$cf_test"],[
3460         cf_cv_term_header=unknown
3461         ])
3462         test "$cf_cv_term_header" != unknown && break
3463 done
3464 ])
3465
3466 # Set definitions to allow ifdef'ing to accommodate subdirectories
3467
3468 case $cf_cv_term_header in
3469 (*term.h)
3470         AC_DEFINE(HAVE_TERM_H,1,[Define to 1 if we have term.h])
3471         ;;
3472 esac
3473
3474 case $cf_cv_term_header in
3475 (ncurses/term.h)
3476         AC_DEFINE(HAVE_NCURSES_TERM_H,1,[Define to 1 if we have ncurses/term.h])
3477         ;;
3478 (ncursesw/term.h)
3479         AC_DEFINE(HAVE_NCURSESW_TERM_H,1,[Define to 1 if we have ncursesw/term.h])
3480         ;;
3481 esac
3482 ])dnl
3483 dnl ---------------------------------------------------------------------------
3484 dnl CF_TOP_BUILDDIR version: 2 updated: 2013/07/27 17:38:32
3485 dnl ---------------
3486 dnl Define a top_builddir symbol, for applications that need an absolute path.
3487 AC_DEFUN([CF_TOP_BUILDDIR],
3488 [
3489 top_builddir=ifelse($1,,`pwd`,$1)
3490 AC_SUBST(top_builddir)
3491 ])dnl
3492 dnl ---------------------------------------------------------------------------
3493 dnl CF_TRY_XOPEN_SOURCE version: 1 updated: 2011/10/30 17:09:50
3494 dnl -------------------
3495 dnl If _XOPEN_SOURCE is not defined in the compile environment, check if we
3496 dnl can define it successfully.
3497 AC_DEFUN([CF_TRY_XOPEN_SOURCE],[
3498 AC_CACHE_CHECK(if we should define _XOPEN_SOURCE,cf_cv_xopen_source,[
3499         AC_TRY_COMPILE([
3500 #include <stdlib.h>
3501 #include <string.h>
3502 #include <sys/types.h>
3503 ],[
3504 #ifndef _XOPEN_SOURCE
3505 make an error
3506 #endif],
3507         [cf_cv_xopen_source=no],
3508         [cf_save="$CPPFLAGS"
3509          CPPFLAGS="$CPPFLAGS -D_XOPEN_SOURCE=$cf_XOPEN_SOURCE"
3510          AC_TRY_COMPILE([
3511 #include <stdlib.h>
3512 #include <string.h>
3513 #include <sys/types.h>
3514 ],[
3515 #ifdef _XOPEN_SOURCE
3516 make an error
3517 #endif],
3518         [cf_cv_xopen_source=no],
3519         [cf_cv_xopen_source=$cf_XOPEN_SOURCE])
3520         CPPFLAGS="$cf_save"
3521         ])
3522 ])
3523
3524 if test "$cf_cv_xopen_source" != no ; then
3525         CF_REMOVE_DEFINE(CFLAGS,$CFLAGS,_XOPEN_SOURCE)
3526         CF_REMOVE_DEFINE(CPPFLAGS,$CPPFLAGS,_XOPEN_SOURCE)
3527         cf_temp_xopen_source="-D_XOPEN_SOURCE=$cf_cv_xopen_source"
3528         CF_ADD_CFLAGS($cf_temp_xopen_source)
3529 fi
3530 ])
3531 dnl ---------------------------------------------------------------------------
3532 dnl CF_UPPER version: 5 updated: 2001/01/29 23:40:59
3533 dnl --------
3534 dnl Make an uppercase version of a variable
3535 dnl $1=uppercase($2)
3536 AC_DEFUN([CF_UPPER],
3537 [
3538 $1=`echo "$2" | sed y%abcdefghijklmnopqrstuvwxyz./-%ABCDEFGHIJKLMNOPQRSTUVWXYZ___%`
3539 ])dnl
3540 dnl ---------------------------------------------------------------------------
3541 dnl CF_UTF8_LIB version: 8 updated: 2012/10/06 08:57:51
3542 dnl -----------
3543 dnl Check for multibyte support, and if not found, utf8 compatibility library
3544 AC_DEFUN([CF_UTF8_LIB],
3545 [
3546 AC_CACHE_CHECK(for multibyte character support,cf_cv_utf8_lib,[
3547         cf_save_LIBS="$LIBS"
3548         AC_TRY_LINK([
3549 #include <stdlib.h>],[putwc(0,0);],
3550         [cf_cv_utf8_lib=yes],
3551         [CF_FIND_LINKAGE([
3552 #include <libutf8.h>],[putwc(0,0);],utf8,
3553                 [cf_cv_utf8_lib=add-on],
3554                 [cf_cv_utf8_lib=no])
3555 ])])
3556
3557 # HAVE_LIBUTF8_H is used by ncurses if curses.h is shared between
3558 # ncurses/ncursesw:
3559 if test "$cf_cv_utf8_lib" = "add-on" ; then
3560         AC_DEFINE(HAVE_LIBUTF8_H,1,[Define to 1 if we should include libutf8.h])
3561         CF_ADD_INCDIR($cf_cv_header_path_utf8)
3562         CF_ADD_LIBDIR($cf_cv_library_path_utf8)
3563         CF_ADD_LIBS($cf_cv_library_file_utf8)
3564 fi
3565 ])dnl
3566 dnl ---------------------------------------------------------------------------
3567 dnl CF_VERBOSE version: 3 updated: 2007/07/29 09:55:12
3568 dnl ----------
3569 dnl Use AC_VERBOSE w/o the warnings
3570 AC_DEFUN([CF_VERBOSE],
3571 [test -n "$verbose" && echo "   $1" 1>&AC_FD_MSG
3572 CF_MSG_LOG([$1])
3573 ])dnl
3574 dnl ---------------------------------------------------------------------------
3575 dnl CF_WEAK_SYMBOLS version: 1 updated: 2008/08/16 19:18:06
3576 dnl ---------------
3577 dnl Check for compiler-support for weak symbols.
3578 dnl This works with "recent" gcc.
3579 AC_DEFUN([CF_WEAK_SYMBOLS],[
3580 AC_CACHE_CHECK(if $CC supports weak symbols,cf_cv_weak_symbols,[
3581
3582 AC_TRY_COMPILE([
3583 #include <stdio.h>],
3584 [
3585 #if defined(__GNUC__)
3586 #  if defined __USE_ISOC99
3587 #    define _cat_pragma(exp)    _Pragma(#exp)
3588 #    define _weak_pragma(exp)   _cat_pragma(weak name)
3589 #  else
3590 #    define _weak_pragma(exp)
3591 #  endif
3592 #  define _declare(name)        __extension__ extern __typeof__(name) name
3593 #  define weak_symbol(name)     _weak_pragma(name) _declare(name) __attribute__((weak))
3594 #endif
3595
3596 weak_symbol(fopen);
3597 ],[cf_cv_weak_symbols=yes],[cf_cv_weak_symbols=no])
3598 ])
3599 ])dnl
3600 dnl ---------------------------------------------------------------------------
3601 dnl CF_WITH_ADA_COMPILER version: 2 updated: 2010/06/26 17:35:58
3602 dnl --------------------
3603 dnl Command-line option to specify the Ada95 compiler.
3604 AC_DEFUN([CF_WITH_ADA_COMPILER],[
3605 AC_MSG_CHECKING(for ada-compiler)
3606 AC_ARG_WITH(ada-compiler,
3607         [  --with-ada-compiler=CMD specify Ada95 compiler command (default gnatmake)],
3608         [cf_ada_compiler=$withval],
3609         [cf_ada_compiler=gnatmake])
3610 AC_SUBST(cf_ada_compiler)
3611 AC_MSG_RESULT($cf_ada_compiler)
3612 ])dnl
3613 dnl ---------------------------------------------------------------------------
3614 dnl CF_WITH_ADA_INCLUDE version: 2 updated: 2010/06/26 17:35:58
3615 dnl -------------------
3616 dnl Command-line option to specify where Ada includes will install.
3617 AC_DEFUN([CF_WITH_ADA_INCLUDE],[
3618 AC_MSG_CHECKING(for ada-include)
3619 CF_WITH_PATH(ada-include,
3620    [  --with-ada-include=DIR  Ada includes are in DIR],
3621    ADA_INCLUDE,
3622    PREFIX/share/ada/adainclude,
3623    [$]prefix/share/ada/adainclude)
3624 AC_SUBST(ADA_INCLUDE)
3625 AC_MSG_RESULT($ADA_INCLUDE)
3626 ])dnl
3627 dnl ---------------------------------------------------------------------------
3628 dnl CF_WITH_ADA_OBJECTS version: 2 updated: 2010/06/26 17:35:58
3629 dnl -------------------
3630 dnl Command-line option to specify where Ada objects will install.
3631 AC_DEFUN([CF_WITH_ADA_OBJECTS],[
3632 AC_MSG_CHECKING(for ada-objects)
3633 CF_WITH_PATH(ada-objects,
3634    [  --with-ada-objects=DIR  Ada objects are in DIR],
3635    ADA_OBJECTS,
3636    PREFIX/lib/ada/adalib,
3637    [$]prefix/lib/ada/adalib)
3638 AC_SUBST(ADA_OBJECTS)
3639 AC_MSG_RESULT($ADA_OBJECTS)
3640 ])dnl
3641 dnl ---------------------------------------------------------------------------
3642 dnl CF_WITH_ADA_SHAREDLIB version: 4 updated: 2014/05/31 21:08:37
3643 dnl ---------------------
3644 dnl Command-line option to specify if an Ada95 shared-library should be built,
3645 dnl and optionally what its soname should be.
3646 AC_DEFUN([CF_WITH_ADA_SHAREDLIB],[
3647 AC_MSG_CHECKING(if an Ada95 shared-library should be built)
3648 AC_ARG_WITH(ada-sharedlib,
3649         [  --with-ada-sharedlib=soname build shared-library (requires GNAT projects)],
3650         [with_ada_sharedlib=$withval],
3651         [with_ada_sharedlib=no])
3652 AC_MSG_RESULT($with_ada_sharedlib)
3653
3654 ADA_SHAREDLIB='lib$(LIB_NAME).so.1'
3655 MAKE_ADA_SHAREDLIB="#"
3656
3657 if test "x$with_ada_sharedlib" != xno
3658 then
3659         MAKE_ADA_SHAREDLIB=
3660         if test "x$with_ada_sharedlib" != xyes
3661         then
3662                 ADA_SHAREDLIB="$with_ada_sharedlib"
3663         fi
3664 fi
3665
3666 AC_SUBST(ADA_SHAREDLIB)
3667 AC_SUBST(MAKE_ADA_SHAREDLIB)
3668 ])dnl
3669 dnl ---------------------------------------------------------------------------
3670 dnl CF_WITH_CURSES_DIR version: 3 updated: 2010/11/20 17:02:38
3671 dnl ------------------
3672 dnl Wrapper for AC_ARG_WITH to specify directory under which to look for curses
3673 dnl libraries.
3674 AC_DEFUN([CF_WITH_CURSES_DIR],[
3675
3676 AC_MSG_CHECKING(for specific curses-directory)
3677 AC_ARG_WITH(curses-dir,
3678         [  --with-curses-dir=DIR   directory in which (n)curses is installed],
3679         [cf_cv_curses_dir=$withval],
3680         [cf_cv_curses_dir=no])
3681 AC_MSG_RESULT($cf_cv_curses_dir)
3682
3683 if ( test -n "$cf_cv_curses_dir" && test "$cf_cv_curses_dir" != "no" )
3684 then
3685         CF_PATH_SYNTAX(withval)
3686         if test -d "$cf_cv_curses_dir"
3687         then
3688                 CF_ADD_INCDIR($cf_cv_curses_dir/include)
3689                 CF_ADD_LIBDIR($cf_cv_curses_dir/lib)
3690         fi
3691 fi
3692 ])dnl
3693 dnl ---------------------------------------------------------------------------
3694 dnl CF_WITH_LIB_PREFIX version: 1 updated: 2012/01/21 19:28:10
3695 dnl ------------------
3696 dnl Allow the library-prefix to be overridden.  OS/2 EMX originally had no
3697 dnl "lib" prefix, e.g., because it used the dll naming convention.
3698 dnl
3699 dnl $1 = variable to set
3700 AC_DEFUN([CF_WITH_LIB_PREFIX],
3701 [
3702 AC_MSG_CHECKING(if you want to have a library-prefix)
3703 AC_ARG_WITH(lib-prefix,
3704         [  --with-lib-prefix       override library-prefix],
3705         [with_lib_prefix=$withval],
3706         [with_lib_prefix=auto])
3707 AC_MSG_RESULT($with_lib_prefix)
3708
3709 if test $with_lib_prefix = auto
3710 then
3711         CF_LIB_PREFIX($1)
3712 elif test $with_lib_prefix = no
3713 then
3714         LIB_PREFIX=
3715 else
3716         LIB_PREFIX=$with_lib_prefix
3717 fi
3718 ])dnl
3719 dnl ---------------------------------------------------------------------------
3720 dnl CF_WITH_PATH version: 11 updated: 2012/09/29 15:04:19
3721 dnl ------------
3722 dnl Wrapper for AC_ARG_WITH to ensure that user supplies a pathname, not just
3723 dnl defaulting to yes/no.
3724 dnl
3725 dnl $1 = option name
3726 dnl $2 = help-text
3727 dnl $3 = environment variable to set
3728 dnl $4 = default value, shown in the help-message, must be a constant
3729 dnl $5 = default value, if it's an expression & cannot be in the help-message
3730 dnl
3731 AC_DEFUN([CF_WITH_PATH],
3732 [AC_ARG_WITH($1,[$2 ](default: ifelse([$4],,empty,[$4])),,
3733 ifelse([$4],,[withval="${$3}"],[withval="${$3:-ifelse([$5],,[$4],[$5])}"]))dnl
3734 if ifelse([$5],,true,[test -n "$5"]) ; then
3735 CF_PATH_SYNTAX(withval)
3736 fi
3737 eval $3="$withval"
3738 AC_SUBST($3)dnl
3739 ])dnl
3740 dnl ---------------------------------------------------------------------------
3741 dnl CF_WITH_PKG_CONFIG_LIBDIR version: 10 updated: 2015/08/22 17:10:56
3742 dnl -------------------------
3743 dnl Allow the choice of the pkg-config library directory to be overridden.
3744 AC_DEFUN([CF_WITH_PKG_CONFIG_LIBDIR],[
3745
3746 case $PKG_CONFIG in
3747 (no|none|yes)
3748         AC_MSG_CHECKING(for pkg-config library directory)
3749         ;;
3750 (*)
3751         AC_MSG_CHECKING(for $PKG_CONFIG library directory)
3752         ;;
3753 esac
3754
3755 PKG_CONFIG_LIBDIR=no
3756 AC_ARG_WITH(pkg-config-libdir,
3757         [  --with-pkg-config-libdir=XXX use given directory for installing pc-files],
3758         [PKG_CONFIG_LIBDIR=$withval],
3759         [test "x$PKG_CONFIG" != xnone && PKG_CONFIG_LIBDIR=yes])
3760
3761 case x$PKG_CONFIG_LIBDIR in
3762 (x/*)
3763         ;;
3764 (xyes)
3765         # Look for the library directory using the same prefix as the executable
3766         if test "x$PKG_CONFIG" = xnone
3767         then
3768                 cf_path=$prefix
3769         else
3770                 cf_path=`echo "$PKG_CONFIG" | sed -e 's,/[[^/]]*/[[^/]]*$,,'`
3771         fi
3772
3773         # If you don't like using the default architecture, you have to specify the
3774         # intended library directory and corresponding compiler/linker options.
3775         #
3776         # This case allows for Debian's 2014-flavor of multiarch, along with the
3777         # most common variations before that point.  Some other variants spell the
3778         # directory differently, e.g., "pkg-config", and put it in unusual places.
3779         # pkg-config has always been poorly standardized, which is ironic...
3780         case x`(arch) 2>/dev/null` in
3781         (*64)
3782                 cf_search_path="\
3783                         $cf_path/lib/*64-linux-gnu \
3784                         $cf_path/share \
3785                         $cf_path/lib64 \
3786                         $cf_path/lib32 \
3787                         $cf_path/lib"
3788                 ;;
3789         (*)
3790                 cf_search_path="\
3791                         $cf_path/lib/*-linux-gnu \
3792                         $cf_path/share \
3793                         $cf_path/lib32 \
3794                         $cf_path/lib \
3795                         $cf_path/libdata"
3796                 ;;
3797         esac
3798
3799         CF_VERBOSE(list...)
3800         for cf_config in $cf_search_path
3801         do
3802                 CF_VERBOSE(checking $cf_config/pkgconfig)
3803                 if test -d $cf_config/pkgconfig
3804                 then
3805                         PKG_CONFIG_LIBDIR=$cf_config/pkgconfig
3806                         AC_MSG_CHECKING(done)
3807                         break
3808                 fi
3809         done
3810         ;;
3811 (*)
3812         ;;
3813 esac
3814
3815 if test "x$PKG_CONFIG_LIBDIR" != xno ; then
3816         AC_MSG_RESULT($PKG_CONFIG_LIBDIR)
3817 fi
3818
3819 AC_SUBST(PKG_CONFIG_LIBDIR)
3820 ])dnl
3821 dnl ---------------------------------------------------------------------------
3822 dnl CF_WITH_PTHREAD version: 7 updated: 2015/04/18 08:56:57
3823 dnl ---------------
3824 dnl Check for POSIX thread library.
3825 AC_DEFUN([CF_WITH_PTHREAD],
3826 [
3827 AC_MSG_CHECKING(if you want to link with the pthread library)
3828 AC_ARG_WITH(pthread,
3829         [  --with-pthread          use POSIX thread library],
3830         [with_pthread=$withval],
3831         [with_pthread=no])
3832 AC_MSG_RESULT($with_pthread)
3833
3834 if test "$with_pthread" != no ; then
3835         AC_CHECK_HEADER(pthread.h,[
3836         AC_DEFINE(HAVE_PTHREADS_H,1,[Define to 1 if we have pthreads.h header])
3837
3838         for cf_lib_pthread in pthread c_r
3839         do
3840             AC_MSG_CHECKING(if we can link with the $cf_lib_pthread library)
3841             cf_save_LIBS="$LIBS"
3842             CF_ADD_LIB($cf_lib_pthread)
3843             AC_TRY_LINK([
3844 #include <pthread.h>
3845 ],[
3846                 int rc = pthread_create(0,0,0,0);
3847                 int r2 = pthread_mutexattr_settype(0, 0);
3848 ],[with_pthread=yes],[with_pthread=no])
3849             LIBS="$cf_save_LIBS"
3850             AC_MSG_RESULT($with_pthread)
3851             test "$with_pthread" = yes && break
3852         done
3853
3854         if test "$with_pthread" = yes ; then
3855             CF_ADD_LIB($cf_lib_pthread)
3856             AC_DEFINE(HAVE_LIBPTHREADS,1,[Define to 1 if we have pthreads library])
3857         else
3858             AC_MSG_ERROR(Cannot link with pthread library)
3859         fi
3860         ])
3861 fi
3862 ])
3863 dnl ---------------------------------------------------------------------------
3864 dnl CF_WITH_SYSTYPE version: 1 updated: 2013/01/26 16:26:12
3865 dnl ---------------
3866 dnl For testing, override the derived host system-type which is used to decide
3867 dnl things such as the linker commands used to build shared libraries.  This is
3868 dnl normally chosen automatically based on the type of system which you are
3869 dnl building on.  We use it for testing the configure script.
3870 dnl
3871 dnl This is different from the --host option: it is used only for testing parts
3872 dnl of the configure script which would not be reachable with --host since that
3873 dnl relies on the build environment being real, rather than mocked up.
3874 AC_DEFUN([CF_WITH_SYSTYPE],[
3875 CF_CHECK_CACHE([AC_CANONICAL_SYSTEM])
3876 AC_ARG_WITH(system-type,
3877         [  --with-system-type=XXX  test: override derived host system-type],
3878 [AC_MSG_WARN(overriding system type to $withval)
3879         cf_cv_system_name=$withval
3880         host_os=$withval
3881 ])
3882 ])dnl
3883 dnl ---------------------------------------------------------------------------
3884 dnl CF_XOPEN_SOURCE version: 52 updated: 2016/08/27 12:21:42
3885 dnl ---------------
3886 dnl Try to get _XOPEN_SOURCE defined properly that we can use POSIX functions,
3887 dnl or adapt to the vendor's definitions to get equivalent functionality,
3888 dnl without losing the common non-POSIX features.
3889 dnl
3890 dnl Parameters:
3891 dnl     $1 is the nominal value for _XOPEN_SOURCE
3892 dnl     $2 is the nominal value for _POSIX_C_SOURCE
3893 AC_DEFUN([CF_XOPEN_SOURCE],[
3894 AC_REQUIRE([AC_CANONICAL_HOST])
3895
3896 cf_XOPEN_SOURCE=ifelse([$1],,500,[$1])
3897 cf_POSIX_C_SOURCE=ifelse([$2],,199506L,[$2])
3898 cf_xopen_source=
3899
3900 case $host_os in
3901 (aix[[4-7]]*)
3902         cf_xopen_source="-D_ALL_SOURCE"
3903         ;;
3904 (msys)
3905         cf_XOPEN_SOURCE=600
3906         ;;
3907 (darwin[[0-8]].*)
3908         cf_xopen_source="-D_APPLE_C_SOURCE"
3909         ;;
3910 (darwin*)
3911         cf_xopen_source="-D_DARWIN_C_SOURCE"
3912         cf_XOPEN_SOURCE=
3913         ;;
3914 (freebsd*|dragonfly*)
3915         # 5.x headers associate
3916         #       _XOPEN_SOURCE=600 with _POSIX_C_SOURCE=200112L
3917         #       _XOPEN_SOURCE=500 with _POSIX_C_SOURCE=199506L
3918         cf_POSIX_C_SOURCE=200112L
3919         cf_XOPEN_SOURCE=600
3920         cf_xopen_source="-D_BSD_TYPES -D__BSD_VISIBLE -D_POSIX_C_SOURCE=$cf_POSIX_C_SOURCE -D_XOPEN_SOURCE=$cf_XOPEN_SOURCE"
3921         ;;
3922 (hpux11*)
3923         cf_xopen_source="-D_HPUX_SOURCE -D_XOPEN_SOURCE=500"
3924         ;;
3925 (hpux*)
3926         cf_xopen_source="-D_HPUX_SOURCE"
3927         ;;
3928 (irix[[56]].*)
3929         cf_xopen_source="-D_SGI_SOURCE"
3930         cf_XOPEN_SOURCE=
3931         ;;
3932 (linux*|uclinux*|gnu*|mint*|k*bsd*-gnu|cygwin)
3933         CF_GNU_SOURCE
3934         ;;
3935 (minix*)
3936         cf_xopen_source="-D_NETBSD_SOURCE" # POSIX.1-2001 features are ifdef'd with this...
3937         ;;
3938 (mirbsd*)
3939         # setting _XOPEN_SOURCE or _POSIX_SOURCE breaks <sys/select.h> and other headers which use u_int / u_short types
3940         cf_XOPEN_SOURCE=
3941         CF_POSIX_C_SOURCE($cf_POSIX_C_SOURCE)
3942         ;;
3943 (netbsd*)
3944         cf_xopen_source="-D_NETBSD_SOURCE" # setting _XOPEN_SOURCE breaks IPv6 for lynx on NetBSD 1.6, breaks xterm, is not needed for ncursesw
3945         ;;
3946 (openbsd[[4-9]]*)
3947         # setting _XOPEN_SOURCE lower than 500 breaks g++ compile with wchar.h, needed for ncursesw
3948         cf_xopen_source="-D_BSD_SOURCE"
3949         cf_XOPEN_SOURCE=600
3950         ;;
3951 (openbsd*)
3952         # setting _XOPEN_SOURCE breaks xterm on OpenBSD 2.8, is not needed for ncursesw
3953         ;;
3954 (osf[[45]]*)
3955         cf_xopen_source="-D_OSF_SOURCE"
3956         ;;
3957 (nto-qnx*)
3958         cf_xopen_source="-D_QNX_SOURCE"
3959         ;;
3960 (sco*)
3961         # setting _XOPEN_SOURCE breaks Lynx on SCO Unix / OpenServer
3962         ;;
3963 (solaris2.*)
3964         cf_xopen_source="-D__EXTENSIONS__"
3965         cf_cv_xopen_source=broken
3966         ;;
3967 (sysv4.2uw2.*) # Novell/SCO UnixWare 2.x (tested on 2.1.2)
3968         cf_XOPEN_SOURCE=
3969         cf_POSIX_C_SOURCE=
3970         ;;
3971 (*)
3972         CF_TRY_XOPEN_SOURCE
3973         CF_POSIX_C_SOURCE($cf_POSIX_C_SOURCE)
3974         ;;
3975 esac
3976
3977 if test -n "$cf_xopen_source" ; then
3978         CF_ADD_CFLAGS($cf_xopen_source,true)
3979 fi
3980
3981 dnl In anything but the default case, we may have system-specific setting
3982 dnl which is still not guaranteed to provide all of the entrypoints that
3983 dnl _XOPEN_SOURCE would yield.
3984 if test -n "$cf_XOPEN_SOURCE" && test -z "$cf_cv_xopen_source" ; then
3985         AC_MSG_CHECKING(if _XOPEN_SOURCE really is set)
3986         AC_TRY_COMPILE([#include <stdlib.h>],[
3987 #ifndef _XOPEN_SOURCE
3988 make an error
3989 #endif],
3990         [cf_XOPEN_SOURCE_set=yes],
3991         [cf_XOPEN_SOURCE_set=no])
3992         AC_MSG_RESULT($cf_XOPEN_SOURCE_set)
3993         if test $cf_XOPEN_SOURCE_set = yes
3994         then
3995                 AC_TRY_COMPILE([#include <stdlib.h>],[
3996 #if (_XOPEN_SOURCE - 0) < $cf_XOPEN_SOURCE
3997 make an error
3998 #endif],
3999                 [cf_XOPEN_SOURCE_set_ok=yes],
4000                 [cf_XOPEN_SOURCE_set_ok=no])
4001                 if test $cf_XOPEN_SOURCE_set_ok = no
4002                 then
4003                         AC_MSG_WARN(_XOPEN_SOURCE is lower than requested)
4004                 fi
4005         else
4006                 CF_TRY_XOPEN_SOURCE
4007         fi
4008 fi
4009 ])