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