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