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