ncurses 5.9 - patch 20141115
[ncurses.git] / aclocal.m4
1 dnl***************************************************************************
2 dnl Copyright (c) 1998-2013,2014 Free Software Foundation, Inc.              *
3 dnl                                                                          *
4 dnl Permission is hereby granted, free of charge, to any person obtaining a  *
5 dnl copy of this software and associated documentation files (the            *
6 dnl "Software"), to deal in the Software without restriction, including      *
7 dnl without limitation the rights to use, copy, modify, merge, publish,      *
8 dnl distribute, distribute with modifications, sublicense, and/or sell       *
9 dnl copies of the Software, and to permit persons to whom the Software is    *
10 dnl furnished to do so, subject to the following conditions:                 *
11 dnl                                                                          *
12 dnl The above copyright notice and this permission notice shall be included  *
13 dnl in all copies or substantial portions of the Software.                   *
14 dnl                                                                          *
15 dnl THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS  *
16 dnl OR IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF               *
17 dnl MERCHANTABILITY, FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT.   *
18 dnl IN NO EVENT SHALL THE ABOVE COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM,   *
19 dnl DAMAGES OR OTHER LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR    *
20 dnl OTHERWISE, ARISING FROM, OUT OF OR IN CONNECTION WITH THE SOFTWARE OR    *
21 dnl THE USE OR OTHER DEALINGS IN THE SOFTWARE.                               *
22 dnl                                                                          *
23 dnl Except as contained in this notice, the name(s) of the above copyright   *
24 dnl holders shall not be used in advertising or otherwise to promote the     *
25 dnl sale, use or other dealings in this Software without prior written       *
26 dnl authorization.                                                           *
27 dnl***************************************************************************
28 dnl
29 dnl Author: Thomas E. Dickey 1995-on
30 dnl
31 dnl $Id: aclocal.m4,v 1.718 2014/11/16 00:08:34 tom Exp $
32 dnl Macros used in NCURSES auto-configuration script.
33 dnl
34 dnl These macros are maintained separately from NCURSES.  The copyright on
35 dnl this file applies to the aggregation of macros and does not affect use of
36 dnl these macros in other applications.
37 dnl
38 dnl See http://invisible-island.net/autoconf/ for additional information.
39 dnl
40 dnl ---------------------------------------------------------------------------
41 dnl ---------------------------------------------------------------------------
42 dnl AM_LANGINFO_CODESET version: 3 updated: 2002/10/27 23:21:42
43 dnl -------------------
44 dnl Inserted as requested by gettext 0.10.40
45 dnl File from /usr/share/aclocal
46 dnl codeset.m4
47 dnl ====================
48 dnl serial AM1
49 dnl
50 dnl From Bruno Haible.
51 AC_DEFUN([AM_LANGINFO_CODESET],
52 [
53   AC_CACHE_CHECK([for nl_langinfo and CODESET], am_cv_langinfo_codeset,
54     [AC_TRY_LINK([#include <langinfo.h>],
55       [char* cs = nl_langinfo(CODESET);],
56       am_cv_langinfo_codeset=yes,
57       am_cv_langinfo_codeset=no)
58     ])
59   if test $am_cv_langinfo_codeset = yes; then
60     AC_DEFINE(HAVE_LANGINFO_CODESET, 1,
61       [Define if you have <langinfo.h> and nl_langinfo(CODESET).])
62   fi
63 ])dnl
64 dnl ---------------------------------------------------------------------------
65 dnl CF_ACVERSION_CHECK version: 5 updated: 2014/06/04 19:11:49
66 dnl ------------------
67 dnl Conditionally generate script according to whether we're using a given autoconf.
68 dnl
69 dnl $1 = version to compare against
70 dnl $2 = code to use if AC_ACVERSION is at least as high as $1.
71 dnl $3 = code to use if AC_ACVERSION is older than $1.
72 define([CF_ACVERSION_CHECK],
73 [
74 ifdef([AC_ACVERSION], ,[ifdef([AC_AUTOCONF_VERSION],[m4_copy([AC_AUTOCONF_VERSION],[AC_ACVERSION])],[m4_copy([m4_PACKAGE_VERSION],[AC_ACVERSION])])])dnl
75 ifdef([m4_version_compare],
76 [m4_if(m4_version_compare(m4_defn([AC_ACVERSION]), [$1]), -1, [$3], [$2])],
77 [CF_ACVERSION_COMPARE(
78 AC_PREREQ_CANON(AC_PREREQ_SPLIT([$1])),
79 AC_PREREQ_CANON(AC_PREREQ_SPLIT(AC_ACVERSION)), AC_ACVERSION, [$2], [$3])])])dnl
80 dnl ---------------------------------------------------------------------------
81 dnl CF_ACVERSION_COMPARE version: 3 updated: 2012/10/03 18:39:53
82 dnl --------------------
83 dnl CF_ACVERSION_COMPARE(MAJOR1, MINOR1, TERNARY1,
84 dnl                      MAJOR2, MINOR2, TERNARY2,
85 dnl                      PRINTABLE2, not FOUND, FOUND)
86 define([CF_ACVERSION_COMPARE],
87 [ifelse(builtin([eval], [$2 < $5]), 1,
88 [ifelse([$8], , ,[$8])],
89 [ifelse([$9], , ,[$9])])])dnl
90 dnl ---------------------------------------------------------------------------
91 dnl CF_ADA_INCLUDE_DIRS version: 8 updated: 2013/10/14 04:24:07
92 dnl -------------------
93 dnl Construct the list of include-options for the C programs in the Ada95
94 dnl binding.
95 AC_DEFUN([CF_ADA_INCLUDE_DIRS],
96 [
97 ACPPFLAGS="-I. -I../include -I../../include $ACPPFLAGS"
98 if test "$srcdir" != "."; then
99         ACPPFLAGS="-I\${srcdir}/../../include $ACPPFLAGS"
100 fi
101 if test "$GCC" != yes; then
102         ACPPFLAGS="$ACPPFLAGS -I\${includedir}"
103 elif test "$includedir" != "/usr/include"; then
104         if test "$includedir" = '${prefix}/include' ; then
105                 if test x$prefix != x/usr ; then
106                         ACPPFLAGS="$ACPPFLAGS -I\${includedir}"
107                 fi
108         else
109                 ACPPFLAGS="$ACPPFLAGS -I\${includedir}"
110         fi
111 fi
112 AC_SUBST(ACPPFLAGS)
113 ])dnl
114 dnl ---------------------------------------------------------------------------
115 dnl CF_ADD_ADAFLAGS version: 1 updated: 2010/06/19 15:22:18
116 dnl ---------------
117 dnl Add to $ADAFLAGS, which is substituted into makefile and scripts.
118 AC_DEFUN([CF_ADD_ADAFLAGS],[
119         ADAFLAGS="$ADAFLAGS $1"
120         AC_SUBST(ADAFLAGS)
121 ])dnl
122 dnl ---------------------------------------------------------------------------
123 dnl CF_ADD_CFLAGS version: 11 updated: 2014/07/22 05:32:57
124 dnl -------------
125 dnl Copy non-preprocessor flags to $CFLAGS, preprocessor flags to $CPPFLAGS
126 dnl The second parameter if given makes this macro verbose.
127 dnl
128 dnl Put any preprocessor definitions that use quoted strings in $EXTRA_CPPFLAGS,
129 dnl to simplify use of $CPPFLAGS in compiler checks, etc., that are easily
130 dnl confused by the quotes (which require backslashes to keep them usable).
131 AC_DEFUN([CF_ADD_CFLAGS],
132 [
133 cf_fix_cppflags=no
134 cf_new_cflags=
135 cf_new_cppflags=
136 cf_new_extra_cppflags=
137
138 for cf_add_cflags in $1
139 do
140 case $cf_fix_cppflags in
141 no)
142         case $cf_add_cflags in #(vi
143         -undef|-nostdinc*|-I*|-D*|-U*|-E|-P|-C) #(vi
144                 case $cf_add_cflags in
145                 -D*)
146                         cf_tst_cflags=`echo ${cf_add_cflags} |sed -e 's/^-D[[^=]]*='\''\"[[^"]]*//'`
147
148                         test "x${cf_add_cflags}" != "x${cf_tst_cflags}" \
149                                 && test -z "${cf_tst_cflags}" \
150                                 && cf_fix_cppflags=yes
151
152                         if test $cf_fix_cppflags = yes ; then
153                                 cf_new_extra_cppflags="$cf_new_extra_cppflags $cf_add_cflags"
154                                 continue
155                         elif test "${cf_tst_cflags}" = "\"'" ; then
156                                 cf_new_extra_cppflags="$cf_new_extra_cppflags $cf_add_cflags"
157                                 continue
158                         fi
159                         ;;
160                 esac
161                 case "$CPPFLAGS" in
162                 *$cf_add_cflags) #(vi
163                         ;;
164                 *) #(vi
165                         case $cf_add_cflags in #(vi
166                         -D*)
167                                 cf_tst_cppflags=`echo "x$cf_add_cflags" | sed -e 's/^...//' -e 's/=.*//'`
168                                 CF_REMOVE_DEFINE(CPPFLAGS,$CPPFLAGS,$cf_tst_cppflags)
169                                 ;;
170                         esac
171                         cf_new_cppflags="$cf_new_cppflags $cf_add_cflags"
172                         ;;
173                 esac
174                 ;;
175         *)
176                 cf_new_cflags="$cf_new_cflags $cf_add_cflags"
177                 ;;
178         esac
179         ;;
180 yes)
181         cf_new_extra_cppflags="$cf_new_extra_cppflags $cf_add_cflags"
182
183         cf_tst_cflags=`echo ${cf_add_cflags} |sed -e 's/^[[^"]]*"'\''//'`
184
185         test "x${cf_add_cflags}" != "x${cf_tst_cflags}" \
186                 && test -z "${cf_tst_cflags}" \
187                 && cf_fix_cppflags=no
188         ;;
189 esac
190 done
191
192 if test -n "$cf_new_cflags" ; then
193         ifelse([$2],,,[CF_VERBOSE(add to \$CFLAGS $cf_new_cflags)])
194         CFLAGS="$CFLAGS $cf_new_cflags"
195 fi
196
197 if test -n "$cf_new_cppflags" ; then
198         ifelse([$2],,,[CF_VERBOSE(add to \$CPPFLAGS $cf_new_cppflags)])
199         CPPFLAGS="$CPPFLAGS $cf_new_cppflags"
200 fi
201
202 if test -n "$cf_new_extra_cppflags" ; then
203         ifelse([$2],,,[CF_VERBOSE(add to \$EXTRA_CPPFLAGS $cf_new_extra_cppflags)])
204         EXTRA_CPPFLAGS="$cf_new_extra_cppflags $EXTRA_CPPFLAGS"
205 fi
206
207 AC_SUBST(EXTRA_CPPFLAGS)
208
209 ])dnl
210 dnl ---------------------------------------------------------------------------
211 dnl CF_ADD_INCDIR version: 13 updated: 2010/05/26 16:44:57
212 dnl -------------
213 dnl Add an include-directory to $CPPFLAGS.  Don't add /usr/include, since it's
214 dnl redundant.  We don't normally need to add -I/usr/local/include for gcc,
215 dnl but old versions (and some misinstalled ones) need that.  To make things
216 dnl worse, gcc 3.x may give error messages if -I/usr/local/include is added to
217 dnl the include-path).
218 AC_DEFUN([CF_ADD_INCDIR],
219 [
220 if test -n "$1" ; then
221   for cf_add_incdir in $1
222   do
223         while test $cf_add_incdir != /usr/include
224         do
225           if test -d $cf_add_incdir
226           then
227                 cf_have_incdir=no
228                 if test -n "$CFLAGS$CPPFLAGS" ; then
229                   # a loop is needed to ensure we can add subdirs of existing dirs
230                   for cf_test_incdir in $CFLAGS $CPPFLAGS ; do
231                         if test ".$cf_test_incdir" = ".-I$cf_add_incdir" ; then
232                           cf_have_incdir=yes; break
233                         fi
234                   done
235                 fi
236
237                 if test "$cf_have_incdir" = no ; then
238                   if test "$cf_add_incdir" = /usr/local/include ; then
239                         if test "$GCC" = yes
240                         then
241                           cf_save_CPPFLAGS=$CPPFLAGS
242                           CPPFLAGS="$CPPFLAGS -I$cf_add_incdir"
243                           AC_TRY_COMPILE([#include <stdio.h>],
244                                   [printf("Hello")],
245                                   [],
246                                   [cf_have_incdir=yes])
247                           CPPFLAGS=$cf_save_CPPFLAGS
248                         fi
249                   fi
250                 fi
251
252                 if test "$cf_have_incdir" = no ; then
253                   CF_VERBOSE(adding $cf_add_incdir to include-path)
254                   ifelse([$2],,CPPFLAGS,[$2])="$ifelse([$2],,CPPFLAGS,[$2]) -I$cf_add_incdir"
255
256                   cf_top_incdir=`echo $cf_add_incdir | sed -e 's%/include/.*$%/include%'`
257                   test "$cf_top_incdir" = "$cf_add_incdir" && break
258                   cf_add_incdir="$cf_top_incdir"
259                 else
260                   break
261                 fi
262           fi
263         done
264   done
265 fi
266 ])dnl
267 dnl ---------------------------------------------------------------------------
268 dnl CF_ADD_LIB version: 2 updated: 2010/06/02 05:03:05
269 dnl ----------
270 dnl Add a library, used to enforce consistency.
271 dnl
272 dnl $1 = library to add, without the "-l"
273 dnl $2 = variable to update (default $LIBS)
274 AC_DEFUN([CF_ADD_LIB],[CF_ADD_LIBS(-l$1,ifelse($2,,LIBS,[$2]))])dnl
275 dnl ---------------------------------------------------------------------------
276 dnl CF_ADD_LIBDIR version: 9 updated: 2010/05/26 16:44:57
277 dnl -------------
278 dnl     Adds to the library-path
279 dnl
280 dnl     Some machines have trouble with multiple -L options.
281 dnl
282 dnl $1 is the (list of) directory(s) to add
283 dnl $2 is the optional name of the variable to update (default LDFLAGS)
284 dnl
285 AC_DEFUN([CF_ADD_LIBDIR],
286 [
287 if test -n "$1" ; then
288   for cf_add_libdir in $1
289   do
290     if test $cf_add_libdir = /usr/lib ; then
291       :
292     elif test -d $cf_add_libdir
293     then
294       cf_have_libdir=no
295       if test -n "$LDFLAGS$LIBS" ; then
296         # a loop is needed to ensure we can add subdirs of existing dirs
297         for cf_test_libdir in $LDFLAGS $LIBS ; do
298           if test ".$cf_test_libdir" = ".-L$cf_add_libdir" ; then
299             cf_have_libdir=yes; break
300           fi
301         done
302       fi
303       if test "$cf_have_libdir" = no ; then
304         CF_VERBOSE(adding $cf_add_libdir to library-path)
305         ifelse([$2],,LDFLAGS,[$2])="-L$cf_add_libdir $ifelse([$2],,LDFLAGS,[$2])"
306       fi
307     fi
308   done
309 fi
310 ])dnl
311 dnl ---------------------------------------------------------------------------
312 dnl CF_ADD_LIBS version: 2 updated: 2014/07/13 14:33:27
313 dnl -----------
314 dnl Add one or more libraries, used to enforce consistency.  Libraries are
315 dnl prepended to an existing list, since their dependencies are assumed to
316 dnl already exist in the list.
317 dnl
318 dnl $1 = libraries to add, with the "-l", etc.
319 dnl $2 = variable to update (default $LIBS)
320 AC_DEFUN([CF_ADD_LIBS],[
321 cf_add_libs="$1"
322 # Filter out duplicates - this happens with badly-designed ".pc" files...
323 for cf_add_1lib in [$]ifelse($2,,LIBS,[$2])
324 do
325         for cf_add_2lib in $cf_add_libs
326         do
327                 if test "x$cf_add_1lib" = "x$cf_add_2lib"
328                 then
329                         cf_add_1lib=
330                         break
331                 fi
332         done
333         test -n "$cf_add_1lib" && cf_add_libs="$cf_add_libs $cf_add_1lib"
334 done
335 ifelse($2,,LIBS,[$2])="$cf_add_libs"
336 ])dnl
337 dnl ---------------------------------------------------------------------------
338 dnl CF_ADD_SUBDIR_PATH version: 4 updated: 2013/10/08 17:47:05
339 dnl ------------------
340 dnl Append to a search-list for a nonstandard header/lib-file
341 dnl     $1 = the variable to return as result
342 dnl     $2 = the package name
343 dnl     $3 = the subdirectory, e.g., bin, include or lib
344 dnl $4 = the directory under which we will test for subdirectories
345 dnl $5 = a directory that we do not want $4 to match
346 AC_DEFUN([CF_ADD_SUBDIR_PATH],
347 [
348 test "x$4" != "x$5" && \
349 test -d "$4" && \
350 ifelse([$5],NONE,,[(test -z "$5" || test x$5 = xNONE || test "x$4" != "x$5") &&]) {
351         test -n "$verbose" && echo "    ... testing for $3-directories under $4"
352         test -d $4/$3 &&          $1="[$]$1 $4/$3"
353         test -d $4/$3/$2 &&       $1="[$]$1 $4/$3/$2"
354         test -d $4/$3/$2/$3 &&    $1="[$]$1 $4/$3/$2/$3"
355         test -d $4/$2/$3 &&       $1="[$]$1 $4/$2/$3"
356         test -d $4/$2/$3/$2 &&    $1="[$]$1 $4/$2/$3/$2"
357 }
358 ])dnl
359 dnl ---------------------------------------------------------------------------
360 dnl CF_ARG_DISABLE version: 3 updated: 1999/03/30 17:24:31
361 dnl --------------
362 dnl Allow user to disable a normally-on option.
363 AC_DEFUN([CF_ARG_DISABLE],
364 [CF_ARG_OPTION($1,[$2],[$3],[$4],yes)])dnl
365 dnl ---------------------------------------------------------------------------
366 dnl CF_ARG_OPTION version: 4 updated: 2010/05/26 05:38:42
367 dnl -------------
368 dnl Restricted form of AC_ARG_ENABLE that ensures user doesn't give bogus
369 dnl values.
370 dnl
371 dnl Parameters:
372 dnl $1 = option name
373 dnl $2 = help-string
374 dnl $3 = action to perform if option is not default
375 dnl $4 = action if perform if option is default
376 dnl $5 = default option value (either 'yes' or 'no')
377 AC_DEFUN([CF_ARG_OPTION],
378 [AC_ARG_ENABLE([$1],[$2],[test "$enableval" != ifelse([$5],no,yes,no) && enableval=ifelse([$5],no,no,yes)
379   if test "$enableval" != "$5" ; then
380 ifelse([$3],,[    :]dnl
381 ,[    $3]) ifelse([$4],,,[
382   else
383     $4])
384   fi],[enableval=$5 ifelse([$4],,,[
385   $4
386 ])dnl
387   ])])dnl
388 dnl ---------------------------------------------------------------------------
389 dnl CF_AR_FLAGS version: 5 updated: 2010/05/20 20:24:29
390 dnl -----------
391 dnl Check for suitable "ar" (archiver) options for updating an archive.
392 AC_DEFUN([CF_AR_FLAGS],[
393 AC_REQUIRE([CF_PROG_AR])
394
395 AC_CACHE_CHECK(for options to update archives, cf_cv_ar_flags,[
396         cf_cv_ar_flags=unknown
397         for cf_ar_flags in -curv curv -crv crv -cqv cqv -rv rv
398         do
399
400                 # check if $ARFLAGS already contains this choice
401                 if test "x$ARFLAGS" != "x" ; then
402                         cf_check_ar_flags=`echo "x$ARFLAGS" | sed -e "s/$cf_ar_flags\$//" -e "s/$cf_ar_flags / /"`
403                         if test "x$ARFLAGS" != "$cf_check_ar_flags" ; then
404                                 cf_cv_ar_flags=
405                                 break
406                         fi
407                 fi
408
409                 rm -f conftest.$ac_cv_objext
410                 rm -f conftest.a
411
412                 cat >conftest.$ac_ext <<EOF
413 #line __oline__ "configure"
414 int     testdata[[3]] = { 123, 456, 789 };
415 EOF
416                 if AC_TRY_EVAL(ac_compile) ; then
417                         echo "$AR $ARFLAGS $cf_ar_flags conftest.a conftest.$ac_cv_objext" >&AC_FD_CC
418                         $AR $ARFLAGS $cf_ar_flags conftest.a conftest.$ac_cv_objext 2>&AC_FD_CC 1>/dev/null
419                         if test -f conftest.a ; then
420                                 cf_cv_ar_flags=$cf_ar_flags
421                                 break
422                         fi
423                 else
424                         CF_VERBOSE(cannot compile test-program)
425                         break
426                 fi
427         done
428         rm -f conftest.a conftest.$ac_ext conftest.$ac_cv_objext
429 ])
430
431 if test -n "$ARFLAGS" ; then
432         if test -n "$cf_cv_ar_flags" ; then
433                 ARFLAGS="$ARFLAGS $cf_cv_ar_flags"
434         fi
435 else
436         ARFLAGS=$cf_cv_ar_flags
437 fi
438
439 AC_SUBST(ARFLAGS)
440 ])
441 dnl ---------------------------------------------------------------------------
442 dnl CF_AWK_BIG_PRINTF version: 4 updated: 2011/10/30 17:09:50
443 dnl -----------------
444 dnl Check if awk can handle big strings using printf.  Some older versions of
445 dnl awk choke on large strings passed via "%s".
446 dnl
447 dnl $1 = desired string size
448 dnl $2 = variable to set with result
449 AC_DEFUN([CF_AWK_BIG_PRINTF],
450 [
451         case x$AWK in #(vi
452         x)
453                 eval $2=no
454                 ;;
455         *) #(vi
456                 if ( ${AWK} 'BEGIN { xx = "x"; while (length(xx) < $1) { xx = xx "x"; }; printf("%s\n", xx); }' 2>/dev/null \
457                         | $AWK '{ printf "%d\n", length([$]0); }' 2>/dev/null | $AWK 'BEGIN { eqls=0; recs=0; } { recs++; if ([$]0 == 12000) eqls++; } END { if (recs != 1 || eqls != 1) exit 1; }' 2>/dev/null >/dev/null ) ; then
458                         eval $2=yes
459                 else
460                         eval $2=no
461                 fi
462                 ;;
463         esac
464 ])dnl
465 dnl ---------------------------------------------------------------------------
466 dnl CF_BOOL_DECL version: 8 updated: 2004/01/30 15:51:18
467 dnl ------------
468 dnl Test if 'bool' is a builtin type in the configured C++ compiler.  Some
469 dnl older compilers (e.g., gcc 2.5.8) don't support 'bool' directly; gcc
470 dnl 2.6.3 does, in anticipation of the ANSI C++ standard.
471 dnl
472 dnl Treat the configuration-variable specially here, since we're directly
473 dnl substituting its value (i.e., 1/0).
474 dnl
475 dnl $1 is the shell variable to store the result in, if not $cv_cv_builtin_bool
476 AC_DEFUN([CF_BOOL_DECL],
477 [
478 AC_MSG_CHECKING(if we should include stdbool.h)
479
480 AC_CACHE_VAL(cf_cv_header_stdbool_h,[
481         AC_TRY_COMPILE([],[bool foo = false],
482                 [cf_cv_header_stdbool_h=0],
483                 [AC_TRY_COMPILE([
484 #ifndef __BEOS__
485 #include <stdbool.h>
486 #endif
487 ],[bool foo = false],
488                         [cf_cv_header_stdbool_h=1],
489                         [cf_cv_header_stdbool_h=0])])])
490
491 if test "$cf_cv_header_stdbool_h" = 1
492 then    AC_MSG_RESULT(yes)
493 else    AC_MSG_RESULT(no)
494 fi
495
496 AC_MSG_CHECKING([for builtin bool type])
497
498 AC_CACHE_VAL(ifelse($1,,cf_cv_builtin_bool,[$1]),[
499         AC_TRY_COMPILE([
500 #include <stdio.h>
501 #include <sys/types.h>
502 ],[bool x = false],
503                 [ifelse($1,,cf_cv_builtin_bool,[$1])=1],
504                 [ifelse($1,,cf_cv_builtin_bool,[$1])=0])
505         ])
506
507 if test "$ifelse($1,,cf_cv_builtin_bool,[$1])" = 1
508 then    AC_MSG_RESULT(yes)
509 else    AC_MSG_RESULT(no)
510 fi
511 ])dnl
512 dnl ---------------------------------------------------------------------------
513 dnl CF_BOOL_SIZE version: 13 updated: 2013/04/13 18:03:21
514 dnl ------------
515 dnl Test for the size of 'bool' in the configured C++ compiler (e.g., a type).
516 dnl Don't bother looking for bool.h, since it's been deprecated.
517 dnl
518 dnl If the current compiler is C rather than C++, we get the bool definition
519 dnl from <stdbool.h>.
520 AC_DEFUN([CF_BOOL_SIZE],
521 [
522 AC_MSG_CHECKING([for size of bool])
523 AC_CACHE_VAL(cf_cv_type_of_bool,[
524         rm -f cf_test.out
525         AC_TRY_RUN([
526 #include <stdlib.h>
527 #include <stdio.h>
528
529 #if defined(__cplusplus)
530
531 #ifdef HAVE_GXX_BUILTIN_H
532 #include <g++/builtin.h>
533 #elif HAVE_GPP_BUILTIN_H
534 #include <gpp/builtin.h>
535 #elif HAVE_BUILTIN_H
536 #include <builtin.h>
537 #endif
538
539 #else
540
541 #if $cf_cv_header_stdbool_h
542 #include <stdbool.h>
543 #endif
544
545 #endif
546
547 int main()
548 {
549         FILE *fp = fopen("cf_test.out", "w");
550         if (fp != 0) {
551                 bool x = true;
552                 if ((bool)(-x) >= 0)
553                         fputs("unsigned ", fp);
554                 if (sizeof(x) == sizeof(int))       fputs("int",  fp);
555                 else if (sizeof(x) == sizeof(char)) fputs("char", fp);
556                 else if (sizeof(x) == sizeof(short))fputs("short",fp);
557                 else if (sizeof(x) == sizeof(long)) fputs("long", fp);
558                 fclose(fp);
559         }
560         ${cf_cv_main_return:-return}(0);
561 }
562                 ],
563                 [cf_cv_type_of_bool=`cat cf_test.out`
564                  if test -z "$cf_cv_type_of_bool"; then
565                    cf_cv_type_of_bool=unknown
566                  fi],
567                 [cf_cv_type_of_bool=unknown],
568                 [cf_cv_type_of_bool=unknown])
569         ])
570         rm -f cf_test.out
571 AC_MSG_RESULT($cf_cv_type_of_bool)
572 if test "$cf_cv_type_of_bool" = unknown ; then
573         case .$NCURSES_BOOL in #(vi
574         .auto|.) NCURSES_BOOL=unsigned;;
575         esac
576         AC_MSG_WARN(Assuming $NCURSES_BOOL for type of bool)
577         cf_cv_type_of_bool=$NCURSES_BOOL
578 fi
579 ])dnl
580 dnl ---------------------------------------------------------------------------
581 dnl CF_BUILD_CC version: 7 updated: 2012/10/06 15:31:55
582 dnl -----------
583 dnl If we're cross-compiling, allow the user to override the tools and their
584 dnl options.  The configure script is oriented toward identifying the host
585 dnl compiler, etc., but we need a build compiler to generate parts of the
586 dnl source.
587 dnl
588 dnl $1 = default for $CPPFLAGS
589 dnl $2 = default for $LIBS
590 AC_DEFUN([CF_BUILD_CC],[
591 CF_ACVERSION_CHECK(2.52,,
592         [AC_REQUIRE([CF_PROG_EXT])])
593 if test "$cross_compiling" = yes ; then
594
595         # defaults that we might want to override
596         : ${BUILD_CFLAGS:=''}
597         : ${BUILD_CPPFLAGS:='ifelse([$1],,,[$1])'}
598         : ${BUILD_LDFLAGS:=''}
599         : ${BUILD_LIBS:='ifelse([$2],,,[$2])'}
600         : ${BUILD_EXEEXT:='$x'}
601         : ${BUILD_OBJEXT:='o'}
602
603         AC_ARG_WITH(build-cc,
604                 [  --with-build-cc=XXX     the build C compiler ($BUILD_CC)],
605                 [BUILD_CC="$withval"],
606                 [AC_CHECK_PROGS(BUILD_CC, gcc cc cl)])
607         AC_MSG_CHECKING(for native build C compiler)
608         AC_MSG_RESULT($BUILD_CC)
609
610         AC_MSG_CHECKING(for native build C preprocessor)
611         AC_ARG_WITH(build-cpp,
612                 [  --with-build-cpp=XXX    the build C preprocessor ($BUILD_CPP)],
613                 [BUILD_CPP="$withval"],
614                 [BUILD_CPP='${BUILD_CC} -E'])
615         AC_MSG_RESULT($BUILD_CPP)
616
617         AC_MSG_CHECKING(for native build C flags)
618         AC_ARG_WITH(build-cflags,
619                 [  --with-build-cflags=XXX the build C compiler-flags ($BUILD_CFLAGS)],
620                 [BUILD_CFLAGS="$withval"])
621         AC_MSG_RESULT($BUILD_CFLAGS)
622
623         AC_MSG_CHECKING(for native build C preprocessor-flags)
624         AC_ARG_WITH(build-cppflags,
625                 [  --with-build-cppflags=XXX the build C preprocessor-flags ($BUILD_CPPFLAGS)],
626                 [BUILD_CPPFLAGS="$withval"])
627         AC_MSG_RESULT($BUILD_CPPFLAGS)
628
629         AC_MSG_CHECKING(for native build linker-flags)
630         AC_ARG_WITH(build-ldflags,
631                 [  --with-build-ldflags=XXX the build linker-flags ($BUILD_LDFLAGS)],
632                 [BUILD_LDFLAGS="$withval"])
633         AC_MSG_RESULT($BUILD_LDFLAGS)
634
635         AC_MSG_CHECKING(for native build linker-libraries)
636         AC_ARG_WITH(build-libs,
637                 [  --with-build-libs=XXX   the build libraries (${BUILD_LIBS})],
638                 [BUILD_LIBS="$withval"])
639         AC_MSG_RESULT($BUILD_LIBS)
640
641         # this assumes we're on Unix.
642         BUILD_EXEEXT=
643         BUILD_OBJEXT=o
644
645         : ${BUILD_CC:='${CC}'}
646
647         if ( test "$BUILD_CC" = "$CC" || test "$BUILD_CC" = '${CC}' ) ; then
648                 AC_MSG_ERROR([Cross-build requires two compilers.
649 Use --with-build-cc to specify the native compiler.])
650         fi
651
652 else
653         : ${BUILD_CC:='${CC}'}
654         : ${BUILD_CPP:='${CPP}'}
655         : ${BUILD_CFLAGS:='${CFLAGS}'}
656         : ${BUILD_CPPFLAGS:='${CPPFLAGS}'}
657         : ${BUILD_LDFLAGS:='${LDFLAGS}'}
658         : ${BUILD_LIBS:='${LIBS}'}
659         : ${BUILD_EXEEXT:='$x'}
660         : ${BUILD_OBJEXT:='o'}
661 fi
662
663 AC_SUBST(BUILD_CC)
664 AC_SUBST(BUILD_CPP)
665 AC_SUBST(BUILD_CFLAGS)
666 AC_SUBST(BUILD_CPPFLAGS)
667 AC_SUBST(BUILD_LDFLAGS)
668 AC_SUBST(BUILD_LIBS)
669 AC_SUBST(BUILD_EXEEXT)
670 AC_SUBST(BUILD_OBJEXT)
671 ])dnl
672 dnl ---------------------------------------------------------------------------
673 dnl CF_CC_ENV_FLAGS version: 1 updated: 2012/10/03 05:25:49
674 dnl ---------------
675 dnl Check for user's environment-breakage by stuffing CFLAGS/CPPFLAGS content
676 dnl into CC.  This will not help with broken scripts that wrap the compiler with
677 dnl options, but eliminates a more common category of user confusion.
678 AC_DEFUN([CF_CC_ENV_FLAGS],
679 [
680 # This should have been defined by AC_PROG_CC
681 : ${CC:=cc}
682
683 AC_MSG_CHECKING(\$CC variable)
684 case "$CC" in #(vi
685 *[[\ \  ]]-[[IUD]]*)
686         AC_MSG_RESULT(broken)
687         AC_MSG_WARN(your environment misuses the CC variable to hold CFLAGS/CPPFLAGS options)
688         # humor him...
689         cf_flags=`echo "$CC" | sed -e 's/^[[^   ]]*[[   ]]//'`
690         CC=`echo "$CC" | sed -e 's/[[   ]].*//'`
691         CF_ADD_CFLAGS($cf_flags)
692         ;;
693 *)
694         AC_MSG_RESULT(ok)
695         ;;
696 esac
697 ])dnl
698 dnl ---------------------------------------------------------------------------
699 dnl CF_CFG_DEFAULTS version: 10 updated: 2013/09/07 13:54:05
700 dnl ---------------
701 dnl Determine the default configuration into which we'll install ncurses.  This
702 dnl can be overridden by the user's command-line options.  There's two items to
703 dnl look for:
704 dnl     1. the prefix (e.g., /usr)
705 dnl     2. the header files (e.g., /usr/include/ncurses)
706 dnl We'll look for a previous installation of ncurses and use the same defaults.
707 dnl
708 dnl We don't use AC_PREFIX_DEFAULT, because it gets evaluated too soon, and
709 dnl we don't use AC_PREFIX_PROGRAM, because we cannot distinguish ncurses's
710 dnl programs from a vendor's.
711 AC_DEFUN([CF_CFG_DEFAULTS],
712 [
713 AC_MSG_CHECKING(for prefix)
714 if test "x$prefix" = "xNONE" ; then
715         case "$cf_cv_system_name" in
716                 # non-vendor systems don't have a conflict
717         openbsd*|freebsd*|mirbsd*|linux*|cygwin*|msys*|k*bsd*-gnu|mingw*)
718                 prefix=/usr
719                 ;;
720         *)      prefix=$ac_default_prefix
721                 ;;
722         esac
723 fi
724 AC_MSG_RESULT($prefix)
725
726 if test "x$prefix" = "xNONE" ; then
727 AC_MSG_CHECKING(for default include-directory)
728 test -n "$verbose" && echo 1>&AC_FD_MSG
729 for cf_symbol in \
730         $includedir \
731         $includedir/ncurses \
732         $prefix/include \
733         $prefix/include/ncurses \
734         /usr/local/include \
735         /usr/local/include/ncurses \
736         /usr/include \
737         /usr/include/ncurses
738 do
739         cf_dir=`eval echo $cf_symbol`
740         if test -f $cf_dir/curses.h ; then
741         if ( fgrep NCURSES_VERSION $cf_dir/curses.h 2>&1 >/dev/null ) ; then
742                 includedir="$cf_symbol"
743                 test -n "$verbose"  && echo $ac_n "     found " 1>&AC_FD_MSG
744                 break
745         fi
746         fi
747         test -n "$verbose"  && echo "   tested $cf_dir" 1>&AC_FD_MSG
748 done
749 AC_MSG_RESULT($includedir)
750 fi
751 ])dnl
752 dnl ---------------------------------------------------------------------------
753 dnl CF_CGETENT version: 5 updated: 2012/10/06 17:56:13
754 dnl ----------
755 dnl Check if the terminal-capability database functions are available.  If not,
756 dnl ncurses has a much-reduced version.
757 AC_DEFUN([CF_CGETENT],[
758 AC_CACHE_CHECK(for terminal-capability database functions,cf_cv_cgetent,[
759 AC_TRY_LINK([
760 #include <stdlib.h>],[
761         char temp[128];
762         char *buf = temp;
763         char *db_array = temp;
764         cgetent(&buf, &db_array, "vt100");
765         cgetcap(buf, "tc", '=');
766         cgetmatch(buf, "tc");
767         ],
768         [cf_cv_cgetent=yes],
769         [cf_cv_cgetent=no])
770 ])
771
772 if test "$cf_cv_cgetent" = yes
773 then
774         AC_DEFINE(HAVE_BSD_CGETENT,1,[Define to 1 if we have BSD cgetent])
775 AC_CACHE_CHECK(if cgetent uses const parameter,cf_cv_cgetent_const,[
776 AC_TRY_LINK([
777 #include <stdlib.h>],[
778         char temp[128];
779         char *buf = temp;
780 #ifndef _NETBSD_SOURCE                  /* given, since April 2004 in stdlib.h */
781         const char *db_array = temp;
782         cgetent(&buf, &db_array, "vt100");
783 #endif
784         cgetcap(buf, "tc", '=');
785         cgetmatch(buf, "tc");
786         ],
787         [cf_cv_cgetent_const=yes],
788         [cf_cv_cgetent_const=no])
789 ])
790         if test "$cf_cv_cgetent_const" = yes
791         then
792                 AC_DEFINE_UNQUOTED(CGETENT_CONST,const,[Define to const if needed for some BSD cgetent variations])
793         fi
794 fi
795 ])dnl
796 dnl ---------------------------------------------------------------------------
797 dnl CF_CHECK_CACHE version: 12 updated: 2012/10/02 20:55:03
798 dnl --------------
799 dnl Check if we're accidentally using a cache from a different machine.
800 dnl Derive the system name, as a check for reusing the autoconf cache.
801 dnl
802 dnl If we've packaged config.guess and config.sub, run that (since it does a
803 dnl better job than uname).  Normally we'll use AC_CANONICAL_HOST, but allow
804 dnl an extra parameter that we may override, e.g., for AC_CANONICAL_SYSTEM
805 dnl which is useful in cross-compiles.
806 dnl
807 dnl Note: we would use $ac_config_sub, but that is one of the places where
808 dnl autoconf 2.5x broke compatibility with autoconf 2.13
809 AC_DEFUN([CF_CHECK_CACHE],
810 [
811 if test -f $srcdir/config.guess || test -f $ac_aux_dir/config.guess ; then
812         ifelse([$1],,[AC_CANONICAL_HOST],[$1])
813         system_name="$host_os"
814 else
815         system_name="`(uname -s -r) 2>/dev/null`"
816         if test -z "$system_name" ; then
817                 system_name="`(hostname) 2>/dev/null`"
818         fi
819 fi
820 test -n "$system_name" && AC_DEFINE_UNQUOTED(SYSTEM_NAME,"$system_name",[Define to the system name.])
821 AC_CACHE_VAL(cf_cv_system_name,[cf_cv_system_name="$system_name"])
822
823 test -z "$system_name" && system_name="$cf_cv_system_name"
824 test -n "$cf_cv_system_name" && AC_MSG_RESULT(Configuring for $cf_cv_system_name)
825
826 if test ".$system_name" != ".$cf_cv_system_name" ; then
827         AC_MSG_RESULT(Cached system name ($system_name) does not agree with actual ($cf_cv_system_name))
828         AC_MSG_ERROR("Please remove config.cache and try again.")
829 fi
830 ])dnl
831 dnl ---------------------------------------------------------------------------
832 dnl CF_CHECK_ERRNO version: 11 updated: 2010/05/26 05:38:42
833 dnl --------------
834 dnl Check for data that is usually declared in <stdio.h> or <errno.h>, e.g.,
835 dnl the 'errno' variable.  Define a DECL_xxx symbol if we must declare it
836 dnl ourselves.
837 dnl
838 dnl $1 = the name to check
839 dnl $2 = the assumed type
840 AC_DEFUN([CF_CHECK_ERRNO],
841 [
842 AC_CACHE_CHECK(if external $1 is declared, cf_cv_dcl_$1,[
843     AC_TRY_COMPILE([
844 #ifdef HAVE_STDLIB_H
845 #include <stdlib.h>
846 #endif
847 #include <stdio.h>
848 #include <sys/types.h>
849 #include <errno.h> ],
850     ifelse([$2],,int,[$2]) x = (ifelse([$2],,int,[$2])) $1,
851     [cf_cv_dcl_$1=yes],
852     [cf_cv_dcl_$1=no])
853 ])
854
855 if test "$cf_cv_dcl_$1" = no ; then
856     CF_UPPER(cf_result,decl_$1)
857     AC_DEFINE_UNQUOTED($cf_result)
858 fi
859
860 # It's possible (for near-UNIX clones) that the data doesn't exist
861 CF_CHECK_EXTERN_DATA($1,ifelse([$2],,int,[$2]))
862 ])dnl
863 dnl ---------------------------------------------------------------------------
864 dnl CF_CHECK_EXTERN_DATA version: 3 updated: 2001/12/30 18:03:23
865 dnl --------------------
866 dnl Check for existence of external data in the current set of libraries.  If
867 dnl we can modify it, it's real enough.
868 dnl $1 = the name to check
869 dnl $2 = its type
870 AC_DEFUN([CF_CHECK_EXTERN_DATA],
871 [
872 AC_CACHE_CHECK(if external $1 exists, cf_cv_have_$1,[
873     AC_TRY_LINK([
874 #undef $1
875 extern $2 $1;
876 ],
877     [$1 = 2],
878     [cf_cv_have_$1=yes],
879     [cf_cv_have_$1=no])
880 ])
881
882 if test "$cf_cv_have_$1" = yes ; then
883     CF_UPPER(cf_result,have_$1)
884     AC_DEFINE_UNQUOTED($cf_result)
885 fi
886
887 ])dnl
888 dnl ---------------------------------------------------------------------------
889 dnl CF_CHECK_GPM_WGETCH version: 2 updated: 2010/08/14 18:25:37
890 dnl -------------------
891 dnl Check if GPM is already linked with curses.  If so - and if the linkage
892 dnl is not "weak" - warn about this because it can create problems linking
893 dnl applications with ncurses.
894 AC_DEFUN([CF_CHECK_GPM_WGETCH],[
895 AC_CHECK_LIB(gpm,Gpm_Wgetch,[
896
897 AC_CACHE_CHECK(if GPM is weakly bound to curses library, cf_cv_check_gpm_wgetch,[
898 cf_cv_check_gpm_wgetch=unknown
899 if test "$cross_compiling" != yes ; then
900
901 cat >conftest.$ac_ext <<CF_EOF
902 #include <gpm.h>
903 int main()
904 {
905         Gpm_Wgetch();
906         ${cf_cv_main_return:-return}(0);
907 }
908 CF_EOF
909
910         cf_save_LIBS="$LIBS"
911         # This only works if we can look at the symbol table.  If a shared
912         # library is stripped for install, we cannot use that.  So we're forced
913         # to rely on the static library, noting that some packagers may not
914         # include it.
915         LIBS="-static -lgpm -dynamic $LIBS"
916         if AC_TRY_EVAL(ac_compile) ; then
917                 if AC_TRY_EVAL(ac_link) ; then
918                         cf_cv_check_gpm_wgetch=`nm conftest$ac_exeext | egrep '\<wgetch\>' | egrep '\<[[vVwW]]\>'`
919                         test -n "$cf_cv_check_gpm_wgetch" && cf_cv_check_gpm_wgetch=yes
920                         test -z "$cf_cv_check_gpm_wgetch" && cf_cv_check_gpm_wgetch=no
921                 fi
922         fi
923         rm -rf conftest*
924         LIBS="$cf_save_LIBS"
925 fi
926 ])
927
928 if test "$cf_cv_check_gpm_wgetch" != yes ; then
929         AC_MSG_WARN(GPM library is already linked with curses - read the FAQ)
930 fi
931 ])])dnl
932 dnl ---------------------------------------------------------------------------
933 dnl CF_CHECK_LIBTOOL_VERSION version: 1 updated: 2013/04/06 18:03:09
934 dnl ------------------------
935 dnl Show the version of libtool
936 dnl
937 dnl Save the version in a cache variable - this is not entirely a good thing,
938 dnl but the version string from libtool is very ugly, and for bug reports it
939 dnl might be useful to have the original string.
940 AC_DEFUN([CF_CHECK_LIBTOOL_VERSION],[
941 if test -n "$LIBTOOL" && test "$LIBTOOL" != none
942 then
943         AC_MSG_CHECKING(version of $LIBTOOL)
944         CF_LIBTOOL_VERSION
945         AC_MSG_RESULT($cf_cv_libtool_version)
946         if test -z "$cf_cv_libtool_version" ; then
947                 AC_MSG_ERROR(This is not GNU libtool)
948         fi
949 else
950         AC_MSG_ERROR(GNU libtool has not been found)
951 fi
952 ])dnl
953 dnl ---------------------------------------------------------------------------
954 dnl CF_CHECK_WCHAR_H version: 1 updated: 2011/10/29 15:01:05
955 dnl ----------------
956 dnl Check if wchar.h can be used, i.e., without defining _XOPEN_SOURCE_EXTENDED
957 AC_DEFUN([CF_CHECK_WCHAR_H],[
958 AC_CACHE_CHECK(if wchar.h can be used as is,cf_cv_wchar_h_okay,[
959 AC_TRY_COMPILE(
960 [
961 #include <stdlib.h>
962 #include <wchar.h>
963 ],[
964         wint_t foo = 0;
965         int bar = iswpunct(foo)],
966         [cf_cv_wchar_h_okay=yes],
967         [cf_cv_wchar_h_okay=no])])
968
969 if test $cf_cv_wchar_h_okay = no
970 then
971         CF_PREDEFINE(_XOPEN_SOURCE_EXTENDED)
972 fi
973 ])dnl
974 dnl ---------------------------------------------------------------------------
975 dnl CF_CLANG_COMPILER version: 2 updated: 2013/11/19 19:23:35
976 dnl -----------------
977 dnl Check if the given compiler is really clang.  clang's C driver defines
978 dnl __GNUC__ (fooling the configure script into setting $GCC to yes) but does
979 dnl not ignore some gcc options.
980 dnl
981 dnl This macro should be run "soon" after AC_PROG_CC or AC_PROG_CPLUSPLUS, to
982 dnl ensure that it is not mistaken for gcc/g++.  It is normally invoked from
983 dnl the wrappers for gcc and g++ warnings.
984 dnl
985 dnl $1 = GCC (default) or GXX
986 dnl $2 = CLANG_COMPILER (default)
987 dnl $3 = CFLAGS (default) or CXXFLAGS
988 AC_DEFUN([CF_CLANG_COMPILER],[
989 ifelse([$2],,CLANG_COMPILER,[$2])=no
990
991 if test "$ifelse([$1],,[$1],GCC)" = yes ; then
992         AC_MSG_CHECKING(if this is really Clang ifelse([$1],GXX,C++,C) compiler)
993         cf_save_CFLAGS="$ifelse([$3],,CFLAGS,[$3])"
994         ifelse([$3],,CFLAGS,[$3])="$ifelse([$3],,CFLAGS,[$3]) -Qunused-arguments"
995         AC_TRY_COMPILE([],[
996 #ifdef __clang__
997 #else
998 make an error
999 #endif
1000 ],[ifelse([$2],,CLANG_COMPILER,[$2])=yes
1001 cf_save_CFLAGS="$cf_save_CFLAGS -Qunused-arguments"
1002 ],[])
1003         ifelse([$3],,CFLAGS,[$3])="$cf_save_CFLAGS"
1004         AC_MSG_RESULT($ifelse([$2],,CLANG_COMPILER,[$2]))
1005 fi
1006 ])
1007 dnl ---------------------------------------------------------------------------
1008 dnl CF_CPP_PARAM_INIT version: 6 updated: 2012/10/06 17:56:13
1009 dnl -----------------
1010 dnl Check if the C++ compiler accepts duplicate parameter initialization.  This
1011 dnl is a late feature for the standard and is not in some recent compilers
1012 dnl (1999/9/11).
1013 AC_DEFUN([CF_CPP_PARAM_INIT],
1014 [
1015 if test -n "$CXX"; then
1016 AC_CACHE_CHECK(if $CXX accepts parameter initialization,cf_cv_cpp_param_init,[
1017         AC_LANG_SAVE
1018         AC_LANG_CPLUSPLUS
1019         AC_TRY_RUN([
1020 class TEST {
1021 private:
1022         int value;
1023 public:
1024         TEST(int x = 1);
1025         ~TEST();
1026 };
1027
1028 TEST::TEST(int x = 1)   // some compilers do not like second initializer
1029 {
1030         value = x;
1031 }
1032 int main() { }
1033 ],
1034         [cf_cv_cpp_param_init=yes],
1035         [cf_cv_cpp_param_init=no],
1036         [cf_cv_cpp_param_init=unknown])
1037         AC_LANG_RESTORE
1038 ])
1039 fi
1040 test "$cf_cv_cpp_param_init" = yes && AC_DEFINE(CPP_HAS_PARAM_INIT,1,[Define to 1 if C++ has parameter initialization])
1041 ])dnl
1042 dnl ---------------------------------------------------------------------------
1043 dnl CF_CPP_STATIC_CAST version: 3 updated: 2013/04/13 18:03:21
1044 dnl ------------------
1045 dnl Check if the C++ compiler accepts static_cast in generics.  This appears to
1046 dnl not be supported in g++ before 3.0
1047 AC_DEFUN([CF_CPP_STATIC_CAST],
1048 [
1049 if test -n "$CXX"; then
1050
1051 AC_CACHE_CHECK(if $CXX accepts static_cast,cf_cv_cpp_static_cast,[
1052         AC_LANG_SAVE
1053         AC_LANG_CPLUSPLUS
1054
1055         AC_TRY_COMPILE([
1056 class NCursesPanel
1057 {
1058 public:
1059   NCursesPanel(int nlines,
1060                int ncols,
1061                int begin_y = 0,
1062                int begin_x = 0)
1063   {
1064   }
1065   NCursesPanel();
1066   ~NCursesPanel();
1067 };
1068
1069 template<class T> class NCursesUserPanel : public NCursesPanel
1070 {
1071 public:
1072   NCursesUserPanel (int nlines,
1073                     int ncols,
1074                     int begin_y = 0,
1075                     int begin_x = 0,
1076                     const T* p_UserData = static_cast<T*>(0))
1077     : NCursesPanel (nlines, ncols, begin_y, begin_x)
1078   {
1079   };
1080   NCursesUserPanel(const T* p_UserData = static_cast<T*>(0)) : NCursesPanel()
1081   {
1082   };
1083
1084   virtual ~NCursesUserPanel() {};
1085 };
1086 ],[
1087         const char* p_UserData = static_cast<char*>(0)],
1088         [cf_cv_cpp_static_cast=yes],
1089         [cf_cv_cpp_static_cast=no])
1090
1091         AC_LANG_RESTORE
1092 ])
1093
1094 fi
1095
1096 test "$cf_cv_cpp_static_cast" = yes && AC_DEFINE(CPP_HAS_STATIC_CAST,1,[Define to 1 if C++ has static_cast])
1097 ])dnl
1098 dnl ---------------------------------------------------------------------------
1099 dnl CF_CXX_AR_FLAGS version: 1 updated: 2011/10/29 08:35:34
1100 dnl ---------------
1101 dnl Setup special archiver flags for given compilers.
1102 AC_DEFUN([CF_CXX_AR_FLAGS],[
1103         CXX_AR='$(AR)'
1104         CXX_ARFLAGS='$(ARFLAGS)'
1105         case $cf_cv_system_name in #(vi
1106         irix*) #(vi
1107             if test "$GXX" != yes ; then
1108                 CXX_AR='$(CXX)'
1109                 CXX_ARFLAGS='-ar -o'
1110             fi
1111             ;;
1112         sco3.2v5*) #(vi
1113             CXXLDFLAGS="-u main"
1114             ;;
1115         solaris2*)
1116             if test "$GXX" != yes ; then
1117                 CXX_AR='$(CXX)'
1118                 CXX_ARFLAGS='-xar -o'
1119             fi
1120             ;;
1121         esac
1122         AC_SUBST(CXXLDFLAGS)
1123         AC_SUBST(CXX_AR)
1124         AC_SUBST(CXX_ARFLAGS)
1125 ])dnl
1126 dnl ---------------------------------------------------------------------------
1127 dnl CF_CXX_IOSTREAM_NAMESPACE version: 2 updated: 2012/10/06 17:56:13
1128 dnl -------------------------
1129 dnl For c++, check if iostream uses "std::" namespace.
1130 AC_DEFUN([CF_CXX_IOSTREAM_NAMESPACE],[
1131 AC_CHECK_HEADERS(iostream)
1132 if test x"$ac_cv_header_iostream" = xyes ; then
1133         AC_MSG_CHECKING(if iostream uses std-namespace)
1134         AC_TRY_COMPILE([
1135 #include <iostream>
1136 using std::endl;
1137 using std::cerr;],[
1138 cerr << "testing" << endl;
1139 ],[cf_iostream_namespace=yes],[cf_iostream_namespace=no])
1140         AC_MSG_RESULT($cf_iostream_namespace)
1141         if test "$cf_iostream_namespace" = yes ; then
1142                 AC_DEFINE(IOSTREAM_NAMESPACE,1,[Define to 1 if C++ has namespace iostream])
1143         fi
1144 fi
1145 ])dnl
1146 dnl ---------------------------------------------------------------------------
1147 dnl CF_C_INLINE version: 4 updated: 2012/06/16 14:55:39
1148 dnl -----------
1149 dnl Check if the C compiler supports "inline".
1150 dnl $1 is the name of a shell variable to set if inline is supported
1151 dnl $2 is the threshold for gcc 4.x's option controlling maximum inline size
1152 AC_DEFUN([CF_C_INLINE],[
1153 AC_C_INLINE
1154 $1=
1155 if test "$ac_cv_c_inline" != no ; then
1156   $1=inline
1157   if test "$INTEL_COMPILER" = yes
1158   then
1159     :
1160   elif test "$CLANG_COMPILER" = yes
1161   then
1162     :
1163   elif test "$GCC" = yes
1164   then
1165     AC_CACHE_CHECK(if $CC supports options to tune inlining,cf_cv_gcc_inline,[
1166       cf_save_CFLAGS=$CFLAGS
1167       CFLAGS="$CFLAGS --param max-inline-insns-single=$2"
1168       AC_TRY_COMPILE([inline int foo(void) { return 1; }],
1169       [${cf_cv_main_return:-return} foo()],
1170       [cf_cv_gcc_inline=yes],
1171       [cf_cv_gcc_inline=no])
1172       CFLAGS=$cf_save_CFLAGS
1173     ])
1174     if test "$cf_cv_gcc_inline" = yes ; then
1175         CF_ADD_CFLAGS([--param max-inline-insns-single=$2])
1176     fi
1177   fi
1178 fi
1179 AC_SUBST($1)
1180 ])dnl
1181 dnl ---------------------------------------------------------------------------
1182 dnl CF_DIRNAME version: 4 updated: 2002/12/21 19:25:52
1183 dnl ----------
1184 dnl "dirname" is not portable, so we fake it with a shell script.
1185 AC_DEFUN([CF_DIRNAME],[$1=`echo $2 | sed -e 's%/[[^/]]*$%%'`])dnl
1186 dnl ---------------------------------------------------------------------------
1187 dnl CF_DIRS_TO_MAKE version: 3 updated: 2002/02/23 20:38:31
1188 dnl ---------------
1189 AC_DEFUN([CF_DIRS_TO_MAKE],
1190 [
1191 DIRS_TO_MAKE="lib"
1192 for cf_item in $cf_list_models
1193 do
1194         CF_OBJ_SUBDIR($cf_item,cf_subdir)
1195         for cf_item2 in $DIRS_TO_MAKE
1196         do
1197                 test $cf_item2 = $cf_subdir && break
1198         done
1199         test ".$cf_item2" != ".$cf_subdir" && DIRS_TO_MAKE="$DIRS_TO_MAKE $cf_subdir"
1200 done
1201 for cf_dir in $DIRS_TO_MAKE
1202 do
1203         test ! -d $cf_dir && mkdir $cf_dir
1204 done
1205 AC_SUBST(DIRS_TO_MAKE)
1206 ])dnl
1207 dnl ---------------------------------------------------------------------------
1208 dnl CF_DISABLE_ECHO version: 12 updated: 2012/10/06 16:30:28
1209 dnl ---------------
1210 dnl You can always use "make -n" to see the actual options, but it's hard to
1211 dnl pick out/analyze warning messages when the compile-line is long.
1212 dnl
1213 dnl Sets:
1214 dnl     ECHO_LT - symbol to control if libtool is verbose
1215 dnl     ECHO_LD - symbol to prefix "cc -o" lines
1216 dnl     RULE_CC - symbol to put before implicit "cc -c" lines (e.g., .c.o)
1217 dnl     SHOW_CC - symbol to put before explicit "cc -c" lines
1218 dnl     ECHO_CC - symbol to put before any "cc" line
1219 dnl
1220 AC_DEFUN([CF_DISABLE_ECHO],[
1221 AC_MSG_CHECKING(if you want to see long compiling messages)
1222 CF_ARG_DISABLE(echo,
1223         [  --disable-echo          do not display "compiling" commands],
1224         [
1225     ECHO_LT='--silent'
1226     ECHO_LD='@echo linking [$]@;'
1227     RULE_CC='@echo compiling [$]<'
1228     SHOW_CC='@echo compiling [$]@'
1229     ECHO_CC='@'
1230 ],[
1231     ECHO_LT=''
1232     ECHO_LD=''
1233     RULE_CC=''
1234     SHOW_CC=''
1235     ECHO_CC=''
1236 ])
1237 AC_MSG_RESULT($enableval)
1238 AC_SUBST(ECHO_LT)
1239 AC_SUBST(ECHO_LD)
1240 AC_SUBST(RULE_CC)
1241 AC_SUBST(SHOW_CC)
1242 AC_SUBST(ECHO_CC)
1243 ])dnl
1244 dnl ---------------------------------------------------------------------------
1245 dnl CF_DISABLE_GNAT_PROJECTS version: 1 updated: 2014/06/01 11:34:00
1246 dnl ------------------------
1247 AC_DEFUN([CF_DISABLE_GNAT_PROJECTS],[
1248 AC_MSG_CHECKING(if we want to use GNAT projects)
1249 CF_ARG_DISABLE(gnat-projects,
1250         [  --disable-gnat-projects test: disable GNAT projects even if usable],
1251         [enable_gnat_projects=no],
1252         [enable_gnat_projects=yes])
1253 AC_MSG_RESULT($enable_gnat_projects)
1254 ])dnl
1255 dnl ---------------------------------------------------------------------------
1256 dnl CF_DISABLE_LEAKS version: 7 updated: 2012/10/02 20:55:03
1257 dnl ----------------
1258 dnl Combine no-leak checks with the libraries or tools that are used for the
1259 dnl checks.
1260 AC_DEFUN([CF_DISABLE_LEAKS],[
1261
1262 AC_REQUIRE([CF_WITH_DMALLOC])
1263 AC_REQUIRE([CF_WITH_DBMALLOC])
1264 AC_REQUIRE([CF_WITH_VALGRIND])
1265
1266 AC_MSG_CHECKING(if you want to perform memory-leak testing)
1267 AC_ARG_ENABLE(leaks,
1268         [  --disable-leaks         test: free permanent memory, analyze leaks],
1269         [if test "x$enableval" = xno; then with_no_leaks=yes; else with_no_leaks=no; fi],
1270         : ${with_no_leaks:=no})
1271 AC_MSG_RESULT($with_no_leaks)
1272
1273 if test "$with_no_leaks" = yes ; then
1274         AC_DEFINE(NO_LEAKS,1,[Define to 1 if you want to perform memory-leak testing.])
1275         AC_DEFINE(YY_NO_LEAKS,1,[Define to 1 if you want to perform memory-leak testing.])
1276 fi
1277 ])dnl
1278 dnl ---------------------------------------------------------------------------
1279 dnl CF_DISABLE_LIBTOOL_VERSION version: 2 updated: 2014/11/15 19:05:29
1280 dnl --------------------------
1281 dnl Check if we should use the libtool 1.5 feature "-version-number" instead of
1282 dnl the older "-version-info" feature.  The newer feature allows us to use
1283 dnl version numbering on shared libraries which make them compatible with
1284 dnl various systems.
1285 AC_DEFUN([CF_DISABLE_LIBTOOL_VERSION],
1286 [
1287 AC_MSG_CHECKING(if libtool -version-number should be used)
1288 CF_ARG_DISABLE(libtool-version,
1289         [  --disable-libtool-version  enable to use libtool's incompatible naming scheme],
1290         [cf_libtool_version=no],
1291         [cf_libtool_version=yes])
1292 AC_MSG_RESULT($cf_libtool_version)
1293
1294 if test "$cf_libtool_version" = yes ; then
1295         LIBTOOL_VERSION="-version-number"
1296 else
1297         LIBTOOL_VERSION="-version-info"
1298         case "x$VERSION" in #(vi
1299         x) #(vi
1300                 AC_MSG_WARN(VERSION was not set)
1301                 ;;
1302         x*.*.*)
1303                 ABI_VERSION="$VERSION"
1304                 CF_VERBOSE(ABI_VERSION: $ABI_VERSION)
1305                 ;;
1306         x*:*:*)
1307                 ABI_VERSION=`echo "$VERSION" | sed -e 's/:/./g'`
1308                 CF_VERBOSE(ABI_VERSION: $ABI_VERSION)
1309                 ;;
1310         *)
1311                 AC_MSG_WARN(unexpected VERSION value: $VERSION)
1312                 ;;
1313         esac
1314 fi
1315
1316 AC_SUBST(ABI_VERSION)
1317 AC_SUBST(LIBTOOL_VERSION)
1318 ])dnl
1319 dnl ---------------------------------------------------------------------------
1320 dnl CF_DISABLE_RPATH_HACK version: 2 updated: 2011/02/13 13:31:33
1321 dnl ---------------------
1322 dnl The rpath-hack makes it simpler to build programs, particularly with the
1323 dnl *BSD ports which may have essential libraries in unusual places.  But it
1324 dnl can interfere with building an executable for the base system.  Use this
1325 dnl option in that case.
1326 AC_DEFUN([CF_DISABLE_RPATH_HACK],
1327 [
1328 AC_MSG_CHECKING(if rpath-hack should be disabled)
1329 CF_ARG_DISABLE(rpath-hack,
1330         [  --disable-rpath-hack    don't add rpath options for additional libraries],
1331         [cf_disable_rpath_hack=yes],
1332         [cf_disable_rpath_hack=no])
1333 AC_MSG_RESULT($cf_disable_rpath_hack)
1334 if test "$cf_disable_rpath_hack" = no ; then
1335         CF_RPATH_HACK
1336 fi
1337 ])
1338 dnl ---------------------------------------------------------------------------
1339 dnl CF_ENABLE_PC_FILES version: 9 updated: 2012/08/04 13:59:54
1340 dnl ------------------
1341 dnl This is the "--enable-pc-files" option, which is available if there is a
1342 dnl pkg-config configuration on the local machine.
1343 AC_DEFUN([CF_ENABLE_PC_FILES],[
1344 AC_REQUIRE([CF_PKG_CONFIG])
1345 AC_REQUIRE([CF_WITH_PKG_CONFIG_LIBDIR])
1346
1347 if test "$PKG_CONFIG" != none ; then
1348         AC_MSG_CHECKING(if we should install .pc files for $PKG_CONFIG)
1349         AC_ARG_ENABLE(pc-files,
1350                 [  --enable-pc-files       generate and install .pc files for pkg-config],
1351                 [enable_pc_files=$enableval],
1352                 [enable_pc_files=no])
1353         AC_MSG_RESULT($enable_pc_files)
1354         if test "$enable_pc_files" != no
1355         then
1356                 CF_PATH_SYNTAX(PKG_CONFIG_LIBDIR)
1357         fi
1358 else
1359         enable_pc_files=no
1360 fi
1361 ])dnl
1362 dnl ---------------------------------------------------------------------------
1363 dnl CF_ENABLE_RPATH version: 2 updated: 2010/03/27 18:39:42
1364 dnl ---------------
1365 dnl Check if the rpath option should be used, setting cache variable
1366 dnl cf_cv_enable_rpath if so.
1367 AC_DEFUN([CF_ENABLE_RPATH],
1368 [
1369 AC_MSG_CHECKING(if rpath option should be used)
1370 AC_ARG_ENABLE(rpath,
1371 [  --enable-rpath          use rpath option when generating shared libraries],
1372 [cf_cv_enable_rpath=$enableval],
1373 [cf_cv_enable_rpath=no])
1374 AC_MSG_RESULT($cf_cv_enable_rpath)
1375 ])dnl
1376 dnl ---------------------------------------------------------------------------
1377 dnl CF_ENABLE_STRING_HACKS version: 3 updated: 2013/01/26 16:26:12
1378 dnl ----------------------
1379 dnl On a few platforms, the compiler and/or loader nags with untruthful
1380 dnl comments stating that "most" uses of strcat/strcpy/sprintf are incorrect,
1381 dnl and implying that most uses of the recommended alternatives are correct.
1382 dnl
1383 dnl Factually speaking, no one has actually counted the number of uses of these
1384 dnl functions versus the total of incorrect uses.  Samples of a few thousand
1385 dnl instances are meaningless compared to the hundreds of millions of lines of
1386 dnl existing C code.
1387 dnl
1388 dnl strlcat/strlcpy are (as of 2012) non-standard, and are available on some
1389 dnl platforms, in implementations of varying quality.  Likewise, snprintf is
1390 dnl standard - but evolved through phases, and older implementations are likely
1391 dnl to yield surprising results, as documented in manpages on various systems.
1392 AC_DEFUN([CF_ENABLE_STRING_HACKS],
1393 [
1394 AC_MSG_CHECKING(if you want to work around bogus compiler/loader warnings)
1395 AC_ARG_ENABLE(string-hacks,
1396         [  --enable-string-hacks   work around bogus compiler/loader warnings],
1397         [with_string_hacks=$enableval],
1398         [with_string_hacks=no])
1399 AC_MSG_RESULT($with_string_hacks)
1400
1401 if test "x$with_string_hacks" = "xyes"; then
1402         AC_DEFINE(USE_STRING_HACKS,1,[Define to 1 to work around bogus compiler/loader warnings])
1403         AC_MSG_WARN(enabling string-hacks to work around bogus compiler/loader warnings)
1404         AC_CHECK_FUNCS( strlcat strlcpy snprintf )
1405 fi
1406 ])dnl
1407 dnl ---------------------------------------------------------------------------
1408 dnl CF_ERRNO version: 5 updated: 1997/11/30 12:44:39
1409 dnl --------
1410 dnl Check if 'errno' is declared in <errno.h>
1411 AC_DEFUN([CF_ERRNO],
1412 [
1413 CF_CHECK_ERRNO(errno)
1414 ])dnl
1415 dnl ---------------------------------------------------------------------------
1416 dnl CF_ETIP_DEFINES version: 5 updated: 2012/02/18 17:51:07
1417 dnl ---------------
1418 dnl Test for conflicting definitions of exception in gcc 2.8.0, etc., between
1419 dnl math.h and builtin.h, only for ncurses
1420 AC_DEFUN([CF_ETIP_DEFINES],
1421 [
1422 AC_MSG_CHECKING(for special defines needed for etip.h)
1423 cf_save_CXXFLAGS="$CXXFLAGS"
1424 cf_result="none"
1425
1426 # etip.h includes ncurses.h which includes ncurses_dll.h
1427 # But ncurses_dll.h is generated - fix here.
1428 test -d include || mkdir include
1429 test -f include/ncurses_dll.h || sed -e 's/@NCURSES_WRAP_PREFIX@/'$NCURSES_WRAP_PREFIX'/g' ${srcdir}/include/ncurses_dll.h.in >include/ncurses_dll.h
1430
1431 for cf_math in "" MATH_H
1432 do
1433 for cf_excp in "" MATH_EXCEPTION
1434 do
1435         CXXFLAGS="$cf_save_CXXFLAGS -I${srcdir}/c++ -I${srcdir}/menu -Iinclude -I${srcdir}/include"
1436         test -n "$cf_math" && CXXFLAGS="$CXXFLAGS -DETIP_NEEDS_${cf_math}"
1437         test -n "$cf_excp" && CXXFLAGS="$CXXFLAGS -DETIP_NEEDS_${cf_excp}"
1438 AC_TRY_COMPILE([
1439 #include <etip.h.in>
1440 ],[],[
1441         test -n "$cf_math" && AC_DEFINE_UNQUOTED(ETIP_NEEDS_${cf_math})
1442         test -n "$cf_excp" && AC_DEFINE_UNQUOTED(ETIP_NEEDS_${cf_excp})
1443         cf_result="$cf_math $cf_excp"
1444         break 2
1445 ],[])
1446 done
1447 done
1448 AC_MSG_RESULT($cf_result)
1449 CXXFLAGS="$cf_save_CXXFLAGS"
1450 ])
1451 dnl ---------------------------------------------------------------------------
1452 dnl CF_FIND_LINKAGE version: 19 updated: 2010/05/29 16:31:02
1453 dnl ---------------
1454 dnl Find a library (specifically the linkage used in the code fragment),
1455 dnl searching for it if it is not already in the library path.
1456 dnl See also CF_ADD_SEARCHPATH.
1457 dnl
1458 dnl Parameters (4-on are optional):
1459 dnl     $1 = headers for library entrypoint
1460 dnl     $2 = code fragment for library entrypoint
1461 dnl     $3 = the library name without the "-l" option or ".so" suffix.
1462 dnl     $4 = action to perform if successful (default: update CPPFLAGS, etc)
1463 dnl     $5 = action to perform if not successful
1464 dnl     $6 = module name, if not the same as the library name
1465 dnl     $7 = extra libraries
1466 dnl
1467 dnl Sets these variables:
1468 dnl     $cf_cv_find_linkage_$3 - yes/no according to whether linkage is found
1469 dnl     $cf_cv_header_path_$3 - include-directory if needed
1470 dnl     $cf_cv_library_path_$3 - library-directory if needed
1471 dnl     $cf_cv_library_file_$3 - library-file if needed, e.g., -l$3
1472 AC_DEFUN([CF_FIND_LINKAGE],[
1473
1474 # If the linkage is not already in the $CPPFLAGS/$LDFLAGS configuration, these
1475 # will be set on completion of the AC_TRY_LINK below.
1476 cf_cv_header_path_$3=
1477 cf_cv_library_path_$3=
1478
1479 CF_MSG_LOG([Starting [FIND_LINKAGE]($3,$6)])
1480
1481 cf_save_LIBS="$LIBS"
1482
1483 AC_TRY_LINK([$1],[$2],[
1484         cf_cv_find_linkage_$3=yes
1485         cf_cv_header_path_$3=/usr/include
1486         cf_cv_library_path_$3=/usr/lib
1487 ],[
1488
1489 LIBS="-l$3 $7 $cf_save_LIBS"
1490
1491 AC_TRY_LINK([$1],[$2],[
1492         cf_cv_find_linkage_$3=yes
1493         cf_cv_header_path_$3=/usr/include
1494         cf_cv_library_path_$3=/usr/lib
1495         cf_cv_library_file_$3="-l$3"
1496 ],[
1497         cf_cv_find_linkage_$3=no
1498         LIBS="$cf_save_LIBS"
1499
1500     CF_VERBOSE(find linkage for $3 library)
1501     CF_MSG_LOG([Searching for headers in [FIND_LINKAGE]($3,$6)])
1502
1503     cf_save_CPPFLAGS="$CPPFLAGS"
1504     cf_test_CPPFLAGS="$CPPFLAGS"
1505
1506     CF_HEADER_PATH(cf_search,ifelse([$6],,[$3],[$6]))
1507     for cf_cv_header_path_$3 in $cf_search
1508     do
1509       if test -d $cf_cv_header_path_$3 ; then
1510         CF_VERBOSE(... testing $cf_cv_header_path_$3)
1511         CPPFLAGS="$cf_save_CPPFLAGS -I$cf_cv_header_path_$3"
1512         AC_TRY_COMPILE([$1],[$2],[
1513             CF_VERBOSE(... found $3 headers in $cf_cv_header_path_$3)
1514             cf_cv_find_linkage_$3=maybe
1515             cf_test_CPPFLAGS="$CPPFLAGS"
1516             break],[
1517             CPPFLAGS="$cf_save_CPPFLAGS"
1518             ])
1519       fi
1520     done
1521
1522     if test "$cf_cv_find_linkage_$3" = maybe ; then
1523
1524       CF_MSG_LOG([Searching for $3 library in [FIND_LINKAGE]($3,$6)])
1525
1526       cf_save_LIBS="$LIBS"
1527       cf_save_LDFLAGS="$LDFLAGS"
1528
1529       ifelse([$6],,,[
1530         CPPFLAGS="$cf_test_CPPFLAGS"
1531         LIBS="-l$3 $7 $cf_save_LIBS"
1532         AC_TRY_LINK([$1],[$2],[
1533             CF_VERBOSE(... found $3 library in system)
1534             cf_cv_find_linkage_$3=yes])
1535             CPPFLAGS="$cf_save_CPPFLAGS"
1536             LIBS="$cf_save_LIBS"
1537             ])
1538
1539       if test "$cf_cv_find_linkage_$3" != yes ; then
1540         CF_LIBRARY_PATH(cf_search,$3)
1541         for cf_cv_library_path_$3 in $cf_search
1542         do
1543           if test -d $cf_cv_library_path_$3 ; then
1544             CF_VERBOSE(... testing $cf_cv_library_path_$3)
1545             CPPFLAGS="$cf_test_CPPFLAGS"
1546             LIBS="-l$3 $7 $cf_save_LIBS"
1547             LDFLAGS="$cf_save_LDFLAGS -L$cf_cv_library_path_$3"
1548             AC_TRY_LINK([$1],[$2],[
1549                 CF_VERBOSE(... found $3 library in $cf_cv_library_path_$3)
1550                 cf_cv_find_linkage_$3=yes
1551                 cf_cv_library_file_$3="-l$3"
1552                 break],[
1553                 CPPFLAGS="$cf_save_CPPFLAGS"
1554                 LIBS="$cf_save_LIBS"
1555                 LDFLAGS="$cf_save_LDFLAGS"
1556                 ])
1557           fi
1558         done
1559         CPPFLAGS="$cf_save_CPPFLAGS"
1560         LDFLAGS="$cf_save_LDFLAGS"
1561       fi
1562
1563     else
1564       cf_cv_find_linkage_$3=no
1565     fi
1566     ],$7)
1567 ])
1568
1569 LIBS="$cf_save_LIBS"
1570
1571 if test "$cf_cv_find_linkage_$3" = yes ; then
1572 ifelse([$4],,[
1573         CF_ADD_INCDIR($cf_cv_header_path_$3)
1574         CF_ADD_LIBDIR($cf_cv_library_path_$3)
1575         CF_ADD_LIB($3)
1576 ],[$4])
1577 else
1578 ifelse([$5],,AC_MSG_WARN(Cannot find $3 library),[$5])
1579 fi
1580 ])dnl
1581 dnl ---------------------------------------------------------------------------
1582 dnl CF_FIND_SUB_INCDIR version: 1 updated: 2014/04/12 16:47:01
1583 dnl ------------------
1584 dnl Find an include-directory with the given leaf-name.  This is useful for
1585 dnl example with FreeBSD ports, which use this convention to distinguish
1586 dnl different versions of the same port.
1587 AC_DEFUN([CF_FIND_SUB_INCDIR],[
1588         CF_SUBDIR_PATH(cf_search,$1,include)
1589         for cf_item in $cf_search
1590         do
1591                 case $cf_item in #(vi
1592                 */$1)
1593                         CF_ADD_INCDIR($cf_item)
1594                         ;;
1595                 esac
1596         done
1597 ])dnl
1598 dnl ---------------------------------------------------------------------------
1599 dnl CF_FIND_SUB_LIBDIR version: 1 updated: 2014/04/12 16:47:01
1600 dnl ------------------
1601 dnl Find a library-directory with the given leaf-name.  This is useful for
1602 dnl example with FreeBSD ports, which use this convention to distinguish
1603 dnl different versions of the same port.
1604 AC_DEFUN([CF_FIND_SUB_LIBDIR],[
1605         CF_SUBDIR_PATH(cf_search,$1,lib)
1606         for cf_item in $cf_search
1607         do
1608                 case $cf_item in #(vi
1609                 */$1)
1610                         CF_ADD_LIBDIR($cf_item)
1611                         ;;
1612                 esac
1613         done
1614 ])dnl
1615 dnl ---------------------------------------------------------------------------
1616 dnl CF_FIXUP_ADAFLAGS version: 1 updated: 2012/03/31 18:48:10
1617 dnl -----------------
1618 dnl make ADAFLAGS consistent with CFLAGS
1619 AC_DEFUN([CF_FIXUP_ADAFLAGS],[
1620         AC_MSG_CHECKING(optimization options for ADAFLAGS)
1621         case "$CFLAGS" in
1622         *-g*)
1623                 CF_ADD_ADAFLAGS(-g)
1624                 ;;
1625         esac
1626         case "$CFLAGS" in
1627         *-O*)
1628                 cf_O_flag=`echo "$CFLAGS" |sed -e 's/^.*-O/-O/' -e 's/[[        ]].*//'`
1629                 CF_ADD_ADAFLAGS($cf_O_flag)
1630                 ;;
1631         esac
1632         AC_MSG_RESULT($ADAFLAGS)
1633 ])dnl
1634 dnl ---------------------------------------------------------------------------
1635 dnl CF_FORGET_TOOL version: 1 updated: 2013/04/06 18:03:09
1636 dnl --------------
1637 dnl Forget that we saw the given tool.
1638 AC_DEFUN([CF_FORGET_TOOL],[
1639 unset ac_cv_prog_ac_ct_$1
1640 unset ac_ct_$1
1641 unset $1
1642 ])dnl
1643 dnl ---------------------------------------------------------------------------
1644 dnl CF_FUNC_DLSYM version: 3 updated: 2012/10/06 11:17:15
1645 dnl -------------
1646 dnl Test for dlsym() and related functions, as well as libdl.
1647 dnl
1648 dnl Sets
1649 dnl     $cf_have_dlsym
1650 dnl     $cf_have_libdl
1651 AC_DEFUN([CF_FUNC_DLSYM],[
1652 cf_have_dlsym=no
1653 AC_CHECK_FUNC(dlsym,cf_have_dlsym=yes,[
1654
1655 cf_have_libdl=no
1656 AC_CHECK_LIB(dl,dlsym,[
1657         cf_have_dlsym=yes
1658         cf_have_libdl=yes])])
1659
1660 if test "$cf_have_dlsym" = yes ; then
1661         test "$cf_have_libdl" = yes && CF_ADD_LIB(dl)
1662
1663         AC_MSG_CHECKING(whether able to link to dl*() functions)
1664         AC_TRY_LINK([#include <dlfcn.h>],[
1665                 void *obj;
1666                 if ((obj = dlopen("filename", 0)) != 0) {
1667                         if (dlsym(obj, "symbolname") == 0) {
1668                         dlclose(obj);
1669                         }
1670                 }],[
1671                 AC_DEFINE(HAVE_LIBDL,1,[Define to 1 if we have dl library])],[
1672                 AC_MSG_ERROR(Cannot link test program for libdl)])
1673         AC_MSG_RESULT(ok)
1674 else
1675         AC_MSG_ERROR(Cannot find dlsym function)
1676 fi
1677 ])
1678 dnl ---------------------------------------------------------------------------
1679 dnl CF_FUNC_MEMMOVE version: 8 updated: 2012/10/04 20:12:20
1680 dnl ---------------
1681 dnl Check for memmove, or a bcopy that can handle overlapping copy.  If neither
1682 dnl is found, add our own version of memmove to the list of objects.
1683 AC_DEFUN([CF_FUNC_MEMMOVE],
1684 [
1685 AC_CHECK_FUNC(memmove,,[
1686 AC_CHECK_FUNC(bcopy,[
1687         AC_CACHE_CHECK(if bcopy does overlapping moves,cf_cv_good_bcopy,[
1688                 AC_TRY_RUN([
1689 int main() {
1690         static char data[] = "abcdefghijklmnopqrstuwwxyz";
1691         char temp[40];
1692         bcopy(data, temp, sizeof(data));
1693         bcopy(temp+10, temp, 15);
1694         bcopy(temp+5, temp+15, 10);
1695         ${cf_cv_main_return:-return} (strcmp(temp, "klmnopqrstuwwxypqrstuwwxyz"));
1696 }
1697                 ],
1698                 [cf_cv_good_bcopy=yes],
1699                 [cf_cv_good_bcopy=no],
1700                 [cf_cv_good_bcopy=unknown])
1701                 ])
1702         ],[cf_cv_good_bcopy=no])
1703         if test "$cf_cv_good_bcopy" = yes ; then
1704                 AC_DEFINE(USE_OK_BCOPY,1,[Define to 1 to use bcopy when memmove is unavailable])
1705         else
1706                 AC_DEFINE(USE_MY_MEMMOVE,1,[Define to 1 to use replacement function when memmove is unavailable])
1707         fi
1708 ])])dnl
1709 dnl ---------------------------------------------------------------------------
1710 dnl CF_FUNC_NANOSLEEP version: 4 updated: 2012/10/06 17:56:13
1711 dnl -----------------
1712 dnl Check for existence of workable nanosleep() function.  Some systems, e.g.,
1713 dnl AIX 4.x, provide a non-working version.
1714 AC_DEFUN([CF_FUNC_NANOSLEEP],[
1715 AC_CACHE_CHECK(if nanosleep really works,cf_cv_func_nanosleep,[
1716 AC_TRY_RUN([
1717 #include <stdio.h>
1718 #include <errno.h>
1719 #include <time.h>
1720
1721 #ifdef HAVE_SYS_TIME_H
1722 #include <sys/time.h>
1723 #endif
1724
1725 int main() {
1726         struct timespec ts1, ts2;
1727         int code;
1728         ts1.tv_sec  = 0;
1729         ts1.tv_nsec = 750000000;
1730         ts2.tv_sec  = 0;
1731         ts2.tv_nsec = 0;
1732         errno = 0;
1733         code = nanosleep(&ts1, &ts2); /* on failure errno is ENOSYS. */
1734         ${cf_cv_main_return:-return}(code != 0);
1735 }
1736 ],
1737         [cf_cv_func_nanosleep=yes],
1738         [cf_cv_func_nanosleep=no],
1739         [cf_cv_func_nanosleep=unknown])])
1740
1741 test "$cf_cv_func_nanosleep" = "yes" && AC_DEFINE(HAVE_NANOSLEEP,1,[Define to 1 if we have nanosleep()])
1742 ])
1743 dnl ---------------------------------------------------------------------------
1744 dnl CF_FUNC_OPENPTY version: 3 updated: 2010/05/29 16:31:02
1745 dnl ---------------
1746 dnl Check for openpty() function, along with <pty.h> header.  It may need the
1747 dnl "util" library as well.
1748 AC_DEFUN([CF_FUNC_OPENPTY],
1749 [
1750 AC_CHECK_LIB(util,openpty,cf_cv_lib_util=yes,cf_cv_lib_util=no)
1751 AC_CACHE_CHECK(for openpty header,cf_cv_func_openpty,[
1752     cf_save_LIBS="$LIBS"
1753     test $cf_cv_lib_util = yes && CF_ADD_LIB(util)
1754     for cf_header in pty.h libutil.h util.h
1755     do
1756     AC_TRY_LINK([
1757 #include <$cf_header>
1758 ],[
1759     int x = openpty((int *)0, (int *)0, (char *)0,
1760                    (struct termios *)0, (struct winsize *)0);
1761 ],[
1762         cf_cv_func_openpty=$cf_header
1763         break
1764 ],[
1765         cf_cv_func_openpty=no
1766 ])
1767     done
1768     LIBS="$cf_save_LIBS"
1769 ])
1770 ])dnl
1771 dnl ---------------------------------------------------------------------------
1772 dnl CF_FUNC_POLL version: 8 updated: 2012/10/04 05:24:07
1773 dnl ------------
1774 dnl See if the poll function really works.  Some platforms have poll(), but
1775 dnl it does not work for terminals or files.
1776 AC_DEFUN([CF_FUNC_POLL],[
1777 AC_CACHE_CHECK(if poll really works,cf_cv_working_poll,[
1778 AC_TRY_RUN([
1779 #include <stdlib.h>
1780 #include <stdio.h>
1781 #include <unistd.h>
1782 #include <fcntl.h>
1783 #ifdef HAVE_POLL_H
1784 #include <poll.h>
1785 #else
1786 #include <sys/poll.h>
1787 #endif
1788 int main() {
1789         struct pollfd myfds;
1790         int ret;
1791
1792         /* check for Darwin bug with respect to "devices" */
1793         myfds.fd = open("/dev/null", 1);        /* O_WRONLY */
1794         if (myfds.fd < 0)
1795                 myfds.fd = 0;
1796         myfds.events = POLLIN;
1797         myfds.revents = 0;
1798
1799         ret = poll(&myfds, 1, 100);
1800
1801         if (ret < 0 || (myfds.revents & POLLNVAL)) {
1802                 ret = -1;
1803         } else {
1804                 int fd = 0;
1805                 if (!isatty(fd)) {
1806                         fd = open("/dev/tty", 2);       /* O_RDWR */
1807                 }
1808
1809                 if (fd >= 0) {
1810                         /* also check with standard input */
1811                         myfds.fd = fd;
1812                         myfds.events = POLLIN;
1813                         myfds.revents = 0;
1814                         ret = poll(&myfds, 1, 100);
1815                 } else {
1816                         ret = -1;
1817                 }
1818         }
1819         ${cf_cv_main_return:-return}(ret < 0);
1820 }],
1821         [cf_cv_working_poll=yes],
1822         [cf_cv_working_poll=no],
1823         [cf_cv_working_poll=unknown])])
1824 test "$cf_cv_working_poll" = "yes" && AC_DEFINE(HAVE_WORKING_POLL,1,[Define to 1 if the poll function seems to work])
1825 ])dnl
1826 dnl ---------------------------------------------------------------------------
1827 dnl CF_FUNC_TERMIOS version: 3 updated: 2012/10/06 17:56:13
1828 dnl ---------------
1829 dnl Some old/broken variations define tcgetattr() only as a macro in
1830 dnl termio(s).h
1831 AC_DEFUN([CF_FUNC_TERMIOS],[
1832 AC_REQUIRE([CF_STRUCT_TERMIOS])
1833 AC_CACHE_CHECK(for tcgetattr, cf_cv_have_tcgetattr,[
1834 AC_TRY_LINK([
1835 #include <sys/types.h>
1836 #ifdef HAVE_UNISTD_H
1837 #include <unistd.h>
1838 #endif
1839 #ifdef HAVE_TERMIOS_H
1840 #include <termios.h>
1841 #define TTY struct termios
1842 #else
1843 #ifdef HAVE_TERMIO_H
1844 #include <termio.h>
1845 #define TTY struct termio
1846 #endif
1847 #endif
1848 ],[
1849 TTY foo;
1850 tcgetattr(1, &foo);],
1851 [cf_cv_have_tcgetattr=yes],
1852 [cf_cv_have_tcgetattr=no])])
1853 test "$cf_cv_have_tcgetattr" = yes && AC_DEFINE(HAVE_TCGETATTR,1,[Define to 1 if we have tcgetattr])
1854 ])dnl
1855 dnl ---------------------------------------------------------------------------
1856 dnl CF_FUNC_VSSCANF version: 4 updated: 2012/10/06 17:56:13
1857 dnl ---------------
1858 dnl Check for vsscanf() function, which is in c9x but generally not in earlier
1859 dnl versions of C.  It is in the GNU C library, and can often be simulated by
1860 dnl other functions.
1861 AC_DEFUN([CF_FUNC_VSSCANF],
1862 [
1863 AC_CACHE_CHECK(for vsscanf function or workaround,cf_cv_func_vsscanf,[
1864 AC_TRY_LINK([
1865 #include <stdarg.h>
1866 #include <stdio.h>],[
1867         va_list ap;
1868         vsscanf("from", "%d", ap)],[cf_cv_func_vsscanf=vsscanf],[
1869 AC_TRY_LINK([
1870 #include <stdarg.h>
1871 #include <stdio.h>],[
1872     FILE strbuf;
1873     char *str = "from";
1874
1875     strbuf._flag = _IOREAD;
1876     strbuf._ptr = strbuf._base = (unsigned char *) str;
1877     strbuf._cnt = strlen(str);
1878     strbuf._file = _NFILE;
1879     return (vfscanf(&strbuf, "%d", ap))],[cf_cv_func_vsscanf=vfscanf],[
1880 AC_TRY_LINK([
1881 #include <stdarg.h>
1882 #include <stdio.h>],[
1883     FILE strbuf;
1884     char *str = "from";
1885
1886     strbuf._flag = _IOREAD;
1887     strbuf._ptr = strbuf._base = (unsigned char *) str;
1888     strbuf._cnt = strlen(str);
1889     strbuf._file = _NFILE;
1890     return (_doscan(&strbuf, "%d", ap))],[cf_cv_func_vsscanf=_doscan],[
1891 cf_cv_func_vsscanf=no])])])])
1892
1893 case $cf_cv_func_vsscanf in #(vi
1894 vsscanf) AC_DEFINE(HAVE_VSSCANF,1,[Define to 1 if we have vsscanf]);; #(vi
1895 vfscanf) AC_DEFINE(HAVE_VFSCANF,1,[Define to 1 if we have vfscanf]);; #(vi
1896 _doscan) AC_DEFINE(HAVE__DOSCAN,1,[Define to 1 if we have _doscan]);;
1897 esac
1898
1899 ])dnl
1900 dnl ---------------------------------------------------------------------------
1901 dnl CF_GCC_ATTRIBUTES version: 16 updated: 2012/10/02 20:55:03
1902 dnl -----------------
1903 dnl Test for availability of useful gcc __attribute__ directives to quiet
1904 dnl compiler warnings.  Though useful, not all are supported -- and contrary
1905 dnl to documentation, unrecognized directives cause older compilers to barf.
1906 AC_DEFUN([CF_GCC_ATTRIBUTES],
1907 [
1908 if test "$GCC" = yes
1909 then
1910 cat > conftest.i <<EOF
1911 #ifndef GCC_PRINTF
1912 #define GCC_PRINTF 0
1913 #endif
1914 #ifndef GCC_SCANF
1915 #define GCC_SCANF 0
1916 #endif
1917 #ifndef GCC_NORETURN
1918 #define GCC_NORETURN /* nothing */
1919 #endif
1920 #ifndef GCC_UNUSED
1921 #define GCC_UNUSED /* nothing */
1922 #endif
1923 EOF
1924 if test "$GCC" = yes
1925 then
1926         AC_CHECKING([for $CC __attribute__ directives])
1927 cat > conftest.$ac_ext <<EOF
1928 #line __oline__ "${as_me:-configure}"
1929 #include "confdefs.h"
1930 #include "conftest.h"
1931 #include "conftest.i"
1932 #if     GCC_PRINTF
1933 #define GCC_PRINTFLIKE(fmt,var) __attribute__((format(printf,fmt,var)))
1934 #else
1935 #define GCC_PRINTFLIKE(fmt,var) /*nothing*/
1936 #endif
1937 #if     GCC_SCANF
1938 #define GCC_SCANFLIKE(fmt,var)  __attribute__((format(scanf,fmt,var)))
1939 #else
1940 #define GCC_SCANFLIKE(fmt,var)  /*nothing*/
1941 #endif
1942 extern void wow(char *,...) GCC_SCANFLIKE(1,2);
1943 extern void oops(char *,...) GCC_PRINTFLIKE(1,2) GCC_NORETURN;
1944 extern void foo(void) GCC_NORETURN;
1945 int main(int argc GCC_UNUSED, char *argv[[]] GCC_UNUSED) { return 0; }
1946 EOF
1947         cf_printf_attribute=no
1948         cf_scanf_attribute=no
1949         for cf_attribute in scanf printf unused noreturn
1950         do
1951                 CF_UPPER(cf_ATTRIBUTE,$cf_attribute)
1952                 cf_directive="__attribute__(($cf_attribute))"
1953                 echo "checking for $CC $cf_directive" 1>&AC_FD_CC
1954
1955                 case $cf_attribute in #(vi
1956                 printf) #(vi
1957                         cf_printf_attribute=yes
1958                         cat >conftest.h <<EOF
1959 #define GCC_$cf_ATTRIBUTE 1
1960 EOF
1961                         ;;
1962                 scanf) #(vi
1963                         cf_scanf_attribute=yes
1964                         cat >conftest.h <<EOF
1965 #define GCC_$cf_ATTRIBUTE 1
1966 EOF
1967                         ;;
1968                 *) #(vi
1969                         cat >conftest.h <<EOF
1970 #define GCC_$cf_ATTRIBUTE $cf_directive
1971 EOF
1972                         ;;
1973                 esac
1974
1975                 if AC_TRY_EVAL(ac_compile); then
1976                         test -n "$verbose" && AC_MSG_RESULT(... $cf_attribute)
1977                         cat conftest.h >>confdefs.h
1978                         case $cf_attribute in #(vi
1979                         noreturn) #(vi
1980                                 AC_DEFINE_UNQUOTED(GCC_NORETURN,$cf_directive,[Define to noreturn-attribute for gcc])
1981                                 ;;
1982                         printf) #(vi
1983                                 cf_value='/* nothing */'
1984                                 if test "$cf_printf_attribute" != no ; then
1985                                         cf_value='__attribute__((format(printf,fmt,var)))'
1986                                         AC_DEFINE(GCC_PRINTF,1,[Define to 1 if the compiler supports gcc-like printf attribute.])
1987                                 fi
1988                                 AC_DEFINE_UNQUOTED(GCC_PRINTFLIKE(fmt,var),$cf_value,[Define to printf-attribute for gcc])
1989                                 ;;
1990                         scanf) #(vi
1991                                 cf_value='/* nothing */'
1992                                 if test "$cf_scanf_attribute" != no ; then
1993                                         cf_value='__attribute__((format(scanf,fmt,var)))'
1994                                         AC_DEFINE(GCC_SCANF,1,[Define to 1 if the compiler supports gcc-like scanf attribute.])
1995                                 fi
1996                                 AC_DEFINE_UNQUOTED(GCC_SCANFLIKE(fmt,var),$cf_value,[Define to sscanf-attribute for gcc])
1997                                 ;;
1998                         unused) #(vi
1999                                 AC_DEFINE_UNQUOTED(GCC_UNUSED,$cf_directive,[Define to unused-attribute for gcc])
2000                                 ;;
2001                         esac
2002                 fi
2003         done
2004 else
2005         fgrep define conftest.i >>confdefs.h
2006 fi
2007 rm -rf conftest*
2008 fi
2009 ])dnl
2010 dnl ---------------------------------------------------------------------------
2011 dnl CF_GCC_VERSION version: 7 updated: 2012/10/18 06:46:33
2012 dnl --------------
2013 dnl Find version of gcc
2014 AC_DEFUN([CF_GCC_VERSION],[
2015 AC_REQUIRE([AC_PROG_CC])
2016 GCC_VERSION=none
2017 if test "$GCC" = yes ; then
2018         AC_MSG_CHECKING(version of $CC)
2019         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.]].*//'`"
2020         test -z "$GCC_VERSION" && GCC_VERSION=unknown
2021         AC_MSG_RESULT($GCC_VERSION)
2022 fi
2023 ])dnl
2024 dnl ---------------------------------------------------------------------------
2025 dnl CF_GCC_WARNINGS version: 31 updated: 2013/11/19 19:23:35
2026 dnl ---------------
2027 dnl Check if the compiler supports useful warning options.  There's a few that
2028 dnl we don't use, simply because they're too noisy:
2029 dnl
2030 dnl     -Wconversion (useful in older versions of gcc, but not in gcc 2.7.x)
2031 dnl     -Wredundant-decls (system headers make this too noisy)
2032 dnl     -Wtraditional (combines too many unrelated messages, only a few useful)
2033 dnl     -Wwrite-strings (too noisy, but should review occasionally).  This
2034 dnl             is enabled for ncurses using "--enable-const".
2035 dnl     -pedantic
2036 dnl
2037 dnl Parameter:
2038 dnl     $1 is an optional list of gcc warning flags that a particular
2039 dnl             application might want to use, e.g., "no-unused" for
2040 dnl             -Wno-unused
2041 dnl Special:
2042 dnl     If $with_ext_const is "yes", add a check for -Wwrite-strings
2043 dnl
2044 AC_DEFUN([CF_GCC_WARNINGS],
2045 [
2046 AC_REQUIRE([CF_GCC_VERSION])
2047 CF_INTEL_COMPILER(GCC,INTEL_COMPILER,CFLAGS)
2048 CF_CLANG_COMPILER(GCC,CLANG_COMPILER,CFLAGS)
2049
2050 cat > conftest.$ac_ext <<EOF
2051 #line __oline__ "${as_me:-configure}"
2052 int main(int argc, char *argv[[]]) { return (argv[[argc-1]] == 0) ; }
2053 EOF
2054
2055 if test "$INTEL_COMPILER" = yes
2056 then
2057 # The "-wdXXX" options suppress warnings:
2058 # remark #1419: external declaration in primary source file
2059 # remark #1683: explicit conversion of a 64-bit integral type to a smaller integral type (potential portability problem)
2060 # remark #1684: conversion from pointer to same-sized integral type (potential portability problem)
2061 # remark #193: zero used for undefined preprocessing identifier
2062 # remark #593: variable "curs_sb_left_arrow" was set but never used
2063 # remark #810: conversion from "int" to "Dimension={unsigned short}" may lose significant bits
2064 # remark #869: parameter "tw" was never referenced
2065 # remark #981: operands are evaluated in unspecified order
2066 # warning #279: controlling expression is constant
2067
2068         AC_CHECKING([for $CC warning options])
2069         cf_save_CFLAGS="$CFLAGS"
2070         EXTRA_CFLAGS="-Wall"
2071         for cf_opt in \
2072                 wd1419 \
2073                 wd1683 \
2074                 wd1684 \
2075                 wd193 \
2076                 wd593 \
2077                 wd279 \
2078                 wd810 \
2079                 wd869 \
2080                 wd981
2081         do
2082                 CFLAGS="$cf_save_CFLAGS $EXTRA_CFLAGS -$cf_opt"
2083                 if AC_TRY_EVAL(ac_compile); then
2084                         test -n "$verbose" && AC_MSG_RESULT(... -$cf_opt)
2085                         EXTRA_CFLAGS="$EXTRA_CFLAGS -$cf_opt"
2086                 fi
2087         done
2088         CFLAGS="$cf_save_CFLAGS"
2089
2090 elif test "$GCC" = yes
2091 then
2092         AC_CHECKING([for $CC warning options])
2093         cf_save_CFLAGS="$CFLAGS"
2094         EXTRA_CFLAGS=
2095         cf_warn_CONST=""
2096         test "$with_ext_const" = yes && cf_warn_CONST="Wwrite-strings"
2097         cf_gcc_warnings="Wignored-qualifiers Wlogical-op Wvarargs"
2098         test "x$CLANG_COMPILER" = xyes && cf_gcc_warnings=
2099         for cf_opt in W Wall \
2100                 Wbad-function-cast \
2101                 Wcast-align \
2102                 Wcast-qual \
2103                 Wdeclaration-after-statement \
2104                 Wextra \
2105                 Winline \
2106                 Wmissing-declarations \
2107                 Wmissing-prototypes \
2108                 Wnested-externs \
2109                 Wpointer-arith \
2110                 Wshadow \
2111                 Wstrict-prototypes \
2112                 Wundef $cf_gcc_warnings $cf_warn_CONST $1
2113         do
2114                 CFLAGS="$cf_save_CFLAGS $EXTRA_CFLAGS -$cf_opt"
2115                 if AC_TRY_EVAL(ac_compile); then
2116                         test -n "$verbose" && AC_MSG_RESULT(... -$cf_opt)
2117                         case $cf_opt in #(vi
2118                         Wcast-qual) #(vi
2119                                 CPPFLAGS="$CPPFLAGS -DXTSTRINGDEFINES"
2120                                 ;;
2121                         Winline) #(vi
2122                                 case $GCC_VERSION in
2123                                 [[34]].*)
2124                                         CF_VERBOSE(feature is broken in gcc $GCC_VERSION)
2125                                         continue;;
2126                                 esac
2127                                 ;;
2128                         Wpointer-arith) #(vi
2129                                 case $GCC_VERSION in
2130                                 [[12]].*)
2131                                         CF_VERBOSE(feature is broken in gcc $GCC_VERSION)
2132                                         continue;;
2133                                 esac
2134                                 ;;
2135                         esac
2136                         EXTRA_CFLAGS="$EXTRA_CFLAGS -$cf_opt"
2137                 fi
2138         done
2139         CFLAGS="$cf_save_CFLAGS"
2140 fi
2141 rm -rf conftest*
2142
2143 AC_SUBST(EXTRA_CFLAGS)
2144 ])dnl
2145 dnl ---------------------------------------------------------------------------
2146 dnl CF_GETOPT_HEADER version: 6 updated: 2014/07/22 14:45:54
2147 dnl ----------------
2148 dnl Check for getopt's variables which are commonly defined in stdlib.h,
2149 dnl unistd.h or (nonstandard) in getopt.h
2150 AC_DEFUN([CF_GETOPT_HEADER],
2151 [
2152 AC_HAVE_HEADERS(unistd.h getopt.h)
2153 AC_CACHE_CHECK(for header declaring getopt variables,cf_cv_getopt_header,[
2154 cf_cv_getopt_header=none
2155 for cf_header in stdio.h stdlib.h unistd.h getopt.h
2156 do
2157 AC_TRY_COMPILE([
2158 #include <$cf_header>],
2159 [int x = optind; char *y = optarg],
2160 [cf_cv_getopt_header=$cf_header
2161  break])
2162 done
2163 ])
2164 if test $cf_cv_getopt_header != none ; then
2165         AC_DEFINE(HAVE_GETOPT_HEADER,1,[Define to 1 if getopt variables are declared in header])
2166 fi
2167 if test $cf_cv_getopt_header = getopt.h ; then
2168         AC_DEFINE(NEED_GETOPT_H,1,[Define to 1 if we must include getopt.h])
2169 fi
2170 ])dnl
2171 dnl ---------------------------------------------------------------------------
2172 dnl CF_GNATPREP_OPT_T version: 1 updated: 2014/08/02 18:37:25
2173 dnl -----------------
2174 AC_DEFUN([CF_GNATPREP_OPT_T],[
2175 AC_CACHE_CHECK(if GNATPREP supports -T option,cf_cv_gnatprep_opt_t,[
2176 cf_cv_gnatprep_opt_t=no
2177 gnatprep -T 2>/dev/null >/dev/null && cf_cv_gnatprep_opt_t=yes
2178 ])
2179 test "$cf_cv_gnatprep_opt_t" = yes && GNATPREP_OPTS="-T $GNATPREP_OPTS"
2180 AC_SUBST(GNATPREP_OPTS)
2181 ])dnl
2182 dnl ---------------------------------------------------------------------------
2183 dnl CF_GNAT_GENERICS version: 2 updated: 2011/03/23 20:24:41
2184 dnl ----------------
2185 AC_DEFUN([CF_GNAT_GENERICS],
2186 [
2187 AC_REQUIRE([CF_GNAT_VERSION])
2188
2189 AC_MSG_CHECKING(if GNAT supports generics)
2190 case $cf_gnat_version in #(vi
2191 3.[[1-9]]*|[[4-9]].*) #(vi
2192         cf_gnat_generics=yes
2193         ;;
2194 *)
2195         cf_gnat_generics=no
2196         ;;
2197 esac
2198 AC_MSG_RESULT($cf_gnat_generics)
2199
2200 if test "$cf_gnat_generics" = yes
2201 then
2202         cf_compile_generics=generics
2203         cf_generic_objects="\${GENOBJS}"
2204 else
2205         cf_compile_generics=
2206         cf_generic_objects=
2207 fi
2208
2209 AC_SUBST(cf_compile_generics)
2210 AC_SUBST(cf_generic_objects)
2211 ])dnl
2212 dnl ---------------------------------------------------------------------------
2213 dnl CF_GNAT_PROJECTS version: 7 updated: 2014/06/01 10:46:34
2214 dnl ----------------
2215 dnl GNAT projects are configured with ".gpr" project files.
2216 dnl GNAT libraries are a further development, using the project feature.
2217 AC_DEFUN([CF_GNAT_PROJECTS],
2218 [
2219 AC_REQUIRE([CF_GNAT_VERSION])
2220 AC_REQUIRE([CF_DISABLE_GNAT_PROJECTS])
2221
2222 cf_gnat_libraries=no
2223 cf_gnat_projects=no
2224
2225 if test "$enable_gnat_projects" != no ; then
2226 AC_MSG_CHECKING(if GNAT supports project files)
2227 case $cf_gnat_version in #(vi
2228 3.[[0-9]]*) #(vi
2229         ;;
2230 *)
2231         case $cf_cv_system_name in #(vi
2232         cygwin*|msys*) #(vi
2233                 ;;
2234         *)
2235                 mkdir conftest.src conftest.bin conftest.lib
2236                 cd conftest.src
2237                 rm -rf conftest* *~conftest*
2238                 cat >>library.gpr <<CF_EOF
2239 project Library is
2240   Kind := External ("LIB_KIND");
2241   for Library_Name use "ConfTest";
2242   for Object_Dir use ".";
2243   for Library_ALI_Dir use External("LIBRARY_DIR");
2244   for Library_Version use External ("SONAME");
2245   for Library_Kind use Kind;
2246   for Library_Dir use External("BUILD_DIR");
2247   Source_Dir := External ("SOURCE_DIR");
2248   for Source_Dirs use (Source_Dir);
2249 end Library;
2250 CF_EOF
2251                 cat >>confpackage.ads <<CF_EOF
2252 package ConfPackage is
2253    procedure conftest;
2254 end ConfPackage;
2255 CF_EOF
2256                 cat >>confpackage.adb <<CF_EOF
2257 with Text_IO;
2258 package body ConfPackage is
2259    procedure conftest is
2260    begin
2261       Text_IO.Put ("Hello World");
2262       Text_IO.New_Line;
2263    end conftest;
2264 end ConfPackage;
2265 CF_EOF
2266                 if ( $cf_ada_make $ADAFLAGS \
2267                                 -Plibrary.gpr \
2268                                 -XBUILD_DIR=`cd ../conftest.bin;pwd` \
2269                                 -XLIBRARY_DIR=`cd ../conftest.lib;pwd` \
2270                                 -XSOURCE_DIR=`pwd` \
2271                                 -XSONAME=libConfTest.so.1 \
2272                                 -XLIB_KIND=static 1>&AC_FD_CC 2>&1 ) ; then
2273                         cf_gnat_projects=yes
2274                 fi
2275                 cd ..
2276                 if test -f conftest.lib/confpackage.ali
2277                 then
2278                         cf_gnat_libraries=yes
2279                 fi
2280                 rm -rf conftest* *~conftest*
2281                 ;;
2282         esac
2283         ;;
2284 esac
2285 AC_MSG_RESULT($cf_gnat_projects)
2286 fi # enable_gnat_projects
2287
2288 if test $cf_gnat_projects = yes
2289 then
2290         AC_MSG_CHECKING(if GNAT supports libraries)
2291         AC_MSG_RESULT($cf_gnat_libraries)
2292 fi
2293
2294 if test "$cf_gnat_projects" = yes
2295 then
2296         USE_OLD_MAKERULES="#"
2297         USE_GNAT_PROJECTS=""
2298 else
2299         USE_OLD_MAKERULES=""
2300         USE_GNAT_PROJECTS="#"
2301 fi
2302
2303 if test "$cf_gnat_libraries" = yes
2304 then
2305         USE_GNAT_LIBRARIES=""
2306 else
2307         USE_GNAT_LIBRARIES="#"
2308 fi
2309
2310 AC_SUBST(USE_OLD_MAKERULES)
2311 AC_SUBST(USE_GNAT_PROJECTS)
2312 AC_SUBST(USE_GNAT_LIBRARIES)
2313 ])dnl
2314 dnl ---------------------------------------------------------------------------
2315 dnl CF_GNAT_SIGINT version: 1 updated: 2011/03/27 20:07:59
2316 dnl --------------
2317 dnl Check if gnat supports SIGINT, and presumably tasking.  For the latter, it
2318 dnl is noted that gnat may compile a tasking unit even for configurations which
2319 dnl fail at runtime.
2320 AC_DEFUN([CF_GNAT_SIGINT],[
2321 AC_CACHE_CHECK(if GNAT supports SIGINT,cf_cv_gnat_sigint,[
2322 CF_GNAT_TRY_LINK([with Ada.Interrupts.Names;
2323
2324 package ConfTest is
2325
2326    pragma Warnings (Off);  --  the next pragma exists since 3.11p
2327    pragma Unreserve_All_Interrupts;
2328    pragma Warnings (On);
2329
2330    protected Process is
2331       procedure Stop;
2332       function Continue return Boolean;
2333       pragma Attach_Handler (Stop, Ada.Interrupts.Names.SIGINT);
2334    private
2335       Done : Boolean := False;
2336    end Process;
2337
2338 end ConfTest;],
2339 [package body ConfTest is
2340    protected body Process is
2341       procedure Stop is
2342       begin
2343          Done := True;
2344       end Stop;
2345       function Continue return Boolean is
2346       begin
2347          return not Done;
2348       end Continue;
2349    end Process;
2350 end ConfTest;],
2351         [cf_cv_gnat_sigint=yes],
2352         [cf_cv_gnat_sigint=no])])
2353
2354 if test $cf_cv_gnat_sigint = yes ; then
2355         USE_GNAT_SIGINT=""
2356 else
2357         USE_GNAT_SIGINT="#"
2358 fi
2359 AC_SUBST(USE_GNAT_SIGINT)
2360 ])dnl
2361 dnl ---------------------------------------------------------------------------
2362 dnl CF_GNAT_TRY_LINK version: 3 updated: 2011/03/19 14:47:45
2363 dnl ----------------
2364 dnl Verify that a test program compiles/links with GNAT.
2365 dnl $cf_ada_make is set to the program that compiles/links
2366 dnl $ADAFLAGS may be set to the GNAT flags.
2367 dnl
2368 dnl $1 is the text of the spec
2369 dnl $2 is the text of the body
2370 dnl $3 is the shell command to execute if successful
2371 dnl $4 is the shell command to execute if not successful
2372 AC_DEFUN([CF_GNAT_TRY_LINK],
2373 [
2374 rm -rf conftest* *~conftest*
2375 cat >>conftest.ads <<CF_EOF
2376 $1
2377 CF_EOF
2378 cat >>conftest.adb <<CF_EOF
2379 $2
2380 CF_EOF
2381 if ( $cf_ada_make $ADAFLAGS conftest 1>&AC_FD_CC 2>&1 ) ; then
2382 ifelse($3,,      :,[      $3])
2383 ifelse($4,,,[else
2384    $4])
2385 fi
2386 rm -rf conftest* *~conftest*
2387 ])dnl
2388 dnl ---------------------------------------------------------------------------
2389 dnl CF_GNAT_TRY_RUN version: 5 updated: 2011/03/19 14:47:45
2390 dnl ---------------
2391 dnl Verify that a test program compiles and runs with GNAT
2392 dnl $cf_ada_make is set to the program that compiles/links
2393 dnl $ADAFLAGS may be set to the GNAT flags.
2394 dnl
2395 dnl $1 is the text of the spec
2396 dnl $2 is the text of the body
2397 dnl $3 is the shell command to execute if successful
2398 dnl $4 is the shell command to execute if not successful
2399 AC_DEFUN([CF_GNAT_TRY_RUN],
2400 [
2401 rm -rf conftest* *~conftest*
2402 cat >>conftest.ads <<CF_EOF
2403 $1
2404 CF_EOF
2405 cat >>conftest.adb <<CF_EOF
2406 $2
2407 CF_EOF
2408 if ( $cf_ada_make $ADAFLAGS conftest 1>&AC_FD_CC 2>&1 ) ; then
2409    if ( ./conftest 1>&AC_FD_CC 2>&1 ) ; then
2410 ifelse($3,,      :,[      $3])
2411 ifelse($4,,,[   else
2412       $4])
2413    fi
2414 ifelse($4,,,[else
2415    $4])
2416 fi
2417 rm -rf conftest* *~conftest*
2418 ])dnl
2419 dnl ---------------------------------------------------------------------------
2420 dnl CF_GNAT_VERSION version: 18 updated: 2012/01/21 19:28:10
2421 dnl ---------------
2422 dnl Verify version of GNAT.
2423 AC_DEFUN([CF_GNAT_VERSION],
2424 [
2425 AC_MSG_CHECKING(for gnat version)
2426 cf_gnat_version=`${cf_ada_make:-gnatmake} -v 2>&1 | \
2427         grep '[[0-9]].[[0-9]][[0-9]]*' |\
2428     sed -e '2,$d' -e 's/[[^0-9 \.]]//g' -e 's/^[[ ]]*//' -e 's/ .*//'`
2429 AC_MSG_RESULT($cf_gnat_version)
2430
2431 case $cf_gnat_version in #(vi
2432 3.1[[1-9]]*|3.[[2-9]]*|[[4-9]].*|20[[0-9]][[0-9]]) #(vi
2433         cf_cv_prog_gnat_correct=yes
2434         ;;
2435 *)
2436         AC_MSG_WARN(Unsupported GNAT version $cf_gnat_version. We require 3.11 or better. Disabling Ada95 binding.)
2437         cf_cv_prog_gnat_correct=no
2438         ;;
2439 esac
2440 ])
2441 dnl ---------------------------------------------------------------------------
2442 dnl CF_GNU_SOURCE version: 6 updated: 2005/07/09 13:23:07
2443 dnl -------------
2444 dnl Check if we must define _GNU_SOURCE to get a reasonable value for
2445 dnl _XOPEN_SOURCE, upon which many POSIX definitions depend.  This is a defect
2446 dnl (or misfeature) of glibc2, which breaks portability of many applications,
2447 dnl since it is interwoven with GNU extensions.
2448 dnl
2449 dnl Well, yes we could work around it...
2450 AC_DEFUN([CF_GNU_SOURCE],
2451 [
2452 AC_CACHE_CHECK(if we must define _GNU_SOURCE,cf_cv_gnu_source,[
2453 AC_TRY_COMPILE([#include <sys/types.h>],[
2454 #ifndef _XOPEN_SOURCE
2455 make an error
2456 #endif],
2457         [cf_cv_gnu_source=no],
2458         [cf_save="$CPPFLAGS"
2459          CPPFLAGS="$CPPFLAGS -D_GNU_SOURCE"
2460          AC_TRY_COMPILE([#include <sys/types.h>],[
2461 #ifdef _XOPEN_SOURCE
2462 make an error
2463 #endif],
2464         [cf_cv_gnu_source=no],
2465         [cf_cv_gnu_source=yes])
2466         CPPFLAGS="$cf_save"
2467         ])
2468 ])
2469 test "$cf_cv_gnu_source" = yes && CPPFLAGS="$CPPFLAGS -D_GNU_SOURCE"
2470 ])dnl
2471 dnl ---------------------------------------------------------------------------
2472 dnl CF_GPP_LIBRARY version: 11 updated: 2012/10/06 17:56:13
2473 dnl --------------
2474 dnl If we're trying to use g++, test if libg++ is installed (a rather common
2475 dnl problem :-).  If we have the compiler but no library, we'll be able to
2476 dnl configure, but won't be able to build the c++ demo program.
2477 AC_DEFUN([CF_GPP_LIBRARY],
2478 [
2479 cf_cxx_library=unknown
2480 case $cf_cv_system_name in #(vi
2481 os2*) #(vi
2482         cf_gpp_libname=gpp
2483         ;;
2484 *)
2485         cf_gpp_libname=g++
2486         ;;
2487 esac
2488 if test "$GXX" = yes; then
2489         AC_MSG_CHECKING([for lib$cf_gpp_libname])
2490         cf_save="$LIBS"
2491         CF_ADD_LIB($cf_gpp_libname)
2492         AC_TRY_LINK([
2493 #include <$cf_gpp_libname/builtin.h>
2494         ],
2495         [two_arg_error_handler_t foo2 = lib_error_handler],
2496         [cf_cxx_library=yes
2497          CF_ADD_LIB($cf_gpp_libname,CXXLIBS)
2498          if test "$cf_gpp_libname" = cpp ; then
2499             AC_DEFINE(HAVE_GPP_BUILTIN_H,1,[Define to 1 if we have gpp builtin.h])
2500          else
2501             AC_DEFINE(HAVE_GXX_BUILTIN_H,1,[Define to 1 if we have g++ builtin.h])
2502          fi],
2503         [AC_TRY_LINK([
2504 #include <builtin.h>
2505         ],
2506         [two_arg_error_handler_t foo2 = lib_error_handler],
2507         [cf_cxx_library=yes
2508          CF_ADD_LIB($cf_gpp_libname,CXXLIBS)
2509          AC_DEFINE(HAVE_BUILTIN_H,1,[Define to 1 if we have builtin.h])],
2510         [cf_cxx_library=no])])
2511         LIBS="$cf_save"
2512         AC_MSG_RESULT($cf_cxx_library)
2513 fi
2514 ])dnl
2515 dnl ---------------------------------------------------------------------------
2516 dnl CF_GXX_VERSION version: 7 updated: 2012/06/16 14:55:39
2517 dnl --------------
2518 dnl Check for version of g++
2519 AC_DEFUN([CF_GXX_VERSION],[
2520 AC_REQUIRE([AC_PROG_CPP])
2521 GXX_VERSION=none
2522 if test "$GXX" = yes; then
2523         AC_MSG_CHECKING(version of ${CXX:-g++})
2524         GXX_VERSION="`${CXX:-g++} --version| sed -e '2,$d' -e 's/^.*(GCC) //' -e 's/^[[^0-9.]]*//' -e 's/[[^0-9.]].*//'`"
2525         test -z "$GXX_VERSION" && GXX_VERSION=unknown
2526         AC_MSG_RESULT($GXX_VERSION)
2527 fi
2528 ])dnl
2529 dnl ---------------------------------------------------------------------------
2530 dnl CF_GXX_WARNINGS version: 8 updated: 2013/11/16 14:27:53
2531 dnl ---------------
2532 dnl Check if the compiler supports useful warning options.
2533 dnl
2534 dnl Most of gcc's options apply to g++, except:
2535 dnl     -Wbad-function-cast
2536 dnl     -Wmissing-declarations
2537 dnl     -Wnested-externs
2538 dnl
2539 dnl Omit a few (for now):
2540 dnl     -Winline
2541 dnl
2542 dnl Parameter:
2543 dnl     $1 is an optional list of g++ warning flags that a particular
2544 dnl             application might want to use, e.g., "no-unused" for
2545 dnl             -Wno-unused
2546 dnl Special:
2547 dnl     If $with_ext_const is "yes", add a check for -Wwrite-strings
2548 dnl
2549 AC_DEFUN([CF_GXX_WARNINGS],
2550 [
2551
2552 CF_INTEL_COMPILER(GXX,INTEL_CPLUSPLUS,CXXFLAGS)
2553 CF_CLANG_COMPILER(GXX,CLANG_CPLUSPLUS,CXXFLAGS)
2554
2555 AC_REQUIRE([CF_GXX_VERSION])
2556
2557 AC_LANG_SAVE
2558 AC_LANG_CPLUSPLUS
2559
2560 cat > conftest.$ac_ext <<EOF
2561 #line __oline__ "configure"
2562 int main(int argc, char *argv[[]]) { return (argv[[argc-1]] == 0) ; }
2563 EOF
2564
2565 if test "$INTEL_CPLUSPLUS" = yes
2566 then
2567 # The "-wdXXX" options suppress warnings:
2568 # remark #1419: external declaration in primary source file
2569 # remark #1682: implicit conversion of a 64-bit integral type to a smaller integral type (potential portability problem)
2570 # remark #1683: explicit conversion of a 64-bit integral type to a smaller integral type (potential portability problem)
2571 # remark #1684: conversion from pointer to same-sized integral type (potential portability problem)
2572 # remark #193: zero used for undefined preprocessing identifier
2573 # remark #593: variable "curs_sb_left_arrow" was set but never used
2574 # remark #810: conversion from "int" to "Dimension={unsigned short}" may lose significant bits
2575 # remark #869: parameter "tw" was never referenced
2576 # remark #981: operands are evaluated in unspecified order
2577 # warning #269: invalid format string conversion
2578
2579         AC_CHECKING([for $CC warning options])
2580         cf_save_CXXFLAGS="$CXXFLAGS"
2581         EXTRA_CXXFLAGS="-Wall"
2582         for cf_opt in \
2583                 wd1419 \
2584                 wd1682 \
2585                 wd1683 \
2586                 wd1684 \
2587                 wd193 \
2588                 wd279 \
2589                 wd593 \
2590                 wd810 \
2591                 wd869 \
2592                 wd981
2593         do
2594                 CXXFLAGS="$cf_save_CXXFLAGS $EXTRA_CXXFLAGS -$cf_opt"
2595                 if AC_TRY_EVAL(ac_compile); then
2596                         test -n "$verbose" && AC_MSG_RESULT(... -$cf_opt)
2597                         EXTRA_CXXFLAGS="$EXTRA_CXXFLAGS -$cf_opt"
2598                 fi
2599         done
2600         CXXFLAGS="$cf_save_CXXFLAGS"
2601
2602 elif test "$GXX" = yes
2603 then
2604         AC_CHECKING([for $CXX warning options])
2605         cf_save_CXXFLAGS="$CXXFLAGS"
2606         EXTRA_CXXFLAGS="-W -Wall"
2607         cf_gxx_extra_warnings=""
2608         test "$with_ext_const" = yes && cf_gxx_extra_warnings="Wwrite-strings"
2609         case "$GCC_VERSION" in
2610         [[1-2]].*)
2611                 ;;
2612         *)
2613                 cf_gxx_extra_warnings="$cf_gxx_extra_warnings Weffc++"
2614                 ;;
2615         esac
2616         for cf_opt in \
2617                 Wabi \
2618                 fabi-version=0 \
2619                 Wextra \
2620                 Wignored-qualifiers \
2621                 Wlogical-op \
2622                 Woverloaded-virtual \
2623                 Wsign-promo \
2624                 Wsynth \
2625                 Wold-style-cast \
2626                 Wcast-align \
2627                 Wcast-qual \
2628                 Wpointer-arith \
2629                 Wshadow \
2630                 Wundef $cf_gxx_extra_warnings $1
2631         do
2632                 CXXFLAGS="$cf_save_CXXFLAGS $EXTRA_CXXFLAGS -Werror -$cf_opt"
2633                 if AC_TRY_EVAL(ac_compile); then
2634                         test -n "$verbose" && AC_MSG_RESULT(... -$cf_opt)
2635                         EXTRA_CXXFLAGS="$EXTRA_CXXFLAGS -$cf_opt"
2636                 else
2637                         test -n "$verbose" && AC_MSG_RESULT(... no -$cf_opt)
2638                 fi
2639         done
2640         CXXFLAGS="$cf_save_CXXFLAGS"
2641 fi
2642
2643 rm -rf conftest*
2644 AC_LANG_RESTORE
2645 AC_SUBST(EXTRA_CXXFLAGS)
2646 ])dnl
2647 dnl ---------------------------------------------------------------------------
2648 dnl CF_HASHED_DB version: 5 updated: 2014/04/12 16:47:01
2649 dnl ------------
2650 dnl Look for an instance of the Berkeley hashed database.
2651 dnl
2652 dnl $1 = optional parameter, to specify install-prefix for the database.
2653 AC_DEFUN([CF_HASHED_DB],
2654 [
2655 ifelse([$1],,,[
2656 case $1 in #(vi
2657 yes|*able*) #(vi
2658     ;;
2659 *)
2660     if test -d "$1" ; then
2661         CF_ADD_INCDIR($1/include)
2662         CF_ADD_LIBDIR($1/lib)
2663         else
2664                 case "$1" in #(vi
2665                 ./*|../*|/*)
2666                         AC_MSG_WARN(no such directory $1)
2667                         ;; #(vi
2668                 *)
2669                         CF_FIND_SUB_INCDIR($1)
2670                         CF_FIND_SUB_LIBDIR($1)
2671                         ;;
2672                 esac
2673     fi
2674 esac
2675 ])
2676 AC_CHECK_HEADER(db.h,[
2677 CF_HASHED_DB_VERSION
2678 if test "$cf_cv_hashed_db_version" = unknown ; then
2679         AC_MSG_ERROR(Cannot determine version of db)
2680 else
2681         CF_HASHED_DB_LIBS
2682         if test "$cf_cv_hashed_db_libs" = unknown ; then
2683                 AC_MSG_ERROR(Cannot determine library for db)
2684         elif test "$cf_cv_hashed_db_libs" != default ; then
2685                 CF_ADD_LIB($cf_cv_hashed_db_libs)
2686         fi
2687 fi
2688 ],[
2689         AC_MSG_ERROR(Cannot find db.h)
2690 ])
2691 ])dnl
2692 dnl ---------------------------------------------------------------------------
2693 dnl CF_HASHED_DB_LIBS version: 9 updated: 2010/05/29 16:31:02
2694 dnl -----------------
2695 dnl Given that we have the header and version for hashed database, find the
2696 dnl library information.
2697 AC_DEFUN([CF_HASHED_DB_LIBS],
2698 [
2699 AC_CACHE_CHECK(for db libraries, cf_cv_hashed_db_libs,[
2700 cf_cv_hashed_db_libs=unknown
2701 for cf_db_libs in "" db$cf_cv_hashed_db_version db-$cf_cv_hashed_db_version db ''
2702 do
2703         cf_save_libs="$LIBS"
2704         if test -n "$cf_db_libs"; then
2705                 CF_ADD_LIB($cf_db_libs)
2706         fi
2707         CF_MSG_LOG(checking for library "$cf_db_libs")
2708         AC_TRY_LINK([
2709 $ac_includes_default
2710 #include <db.h>
2711 ],[
2712         char *path = "/tmp/foo";
2713 #ifdef DB_VERSION_MAJOR
2714 #if DB_VERSION_MAJOR >= 4
2715         DB *result = 0;
2716         db_create(&result, NULL, 0);
2717         result->open(result,
2718                 NULL,
2719                 path,
2720                 path,
2721                 DB_HASH,
2722                 DB_CREATE,
2723                 0644);
2724 #elif DB_VERSION_MAJOR >= 3
2725         DB *result = 0;
2726         db_create(&result, NULL, 0);
2727         result->open(result,
2728                 path,
2729                 path,
2730                 DB_HASH,
2731                 DB_CREATE,
2732                 0644);
2733 #elif DB_VERSION_MAJOR >= 2
2734         DB *result = 0;
2735         db_open(path,
2736                 DB_HASH,
2737                 DB_CREATE,
2738                 0644,
2739                 (DB_ENV *) 0,
2740                 (DB_INFO *) 0,
2741                 &result);
2742 #endif /* DB_VERSION_MAJOR */
2743 #else
2744         DB *result = dbopen(path,
2745                      2,
2746                      0644,
2747                      DB_HASH,
2748                      0);
2749 #endif
2750         ${cf_cv_main_return:-return}(result != 0)
2751 ],[
2752         if test -n "$cf_db_libs" ; then
2753                 cf_cv_hashed_db_libs=$cf_db_libs
2754         else
2755                 cf_cv_hashed_db_libs=default
2756         fi
2757         LIBS="$cf_save_libs"
2758         break
2759 ])
2760         LIBS="$cf_save_libs"
2761 done
2762 ])
2763 ])dnl
2764 dnl ---------------------------------------------------------------------------
2765 dnl CF_HASHED_DB_VERSION version: 4 updated: 2014/04/12 16:47:01
2766 dnl --------------------
2767 dnl Given that we have the header file for hashed database, find the version
2768 dnl information.
2769 AC_DEFUN([CF_HASHED_DB_VERSION],
2770 [
2771 AC_CACHE_CHECK(for version of db, cf_cv_hashed_db_version,[
2772 cf_cv_hashed_db_version=unknown
2773
2774 for cf_db_version in 1 2 3 4 5 6
2775 do
2776         CF_MSG_LOG(checking for db version $cf_db_version)
2777         AC_TRY_COMPILE([
2778 $ac_includes_default
2779 #include <db.h>
2780
2781 #ifdef DB_VERSION_MAJOR
2782         /* db2 (DB_VERSION_MAJOR=2) has also DB_VERSION_MINOR, tested with 7 */
2783 #if $cf_db_version == DB_VERSION_MAJOR
2784         /* ok */
2785 #else
2786         make an error
2787 #endif
2788 #else
2789 #if $cf_db_version == 1
2790         /* ok: assuming this is DB 1.8.5 */
2791 #else
2792         make an error
2793 #endif
2794 #endif
2795 ],[DBT *foo = 0],[
2796         cf_cv_hashed_db_version=$cf_db_version
2797         break
2798         ])
2799 done
2800 ])
2801 ])dnl
2802 dnl ---------------------------------------------------------------------------
2803 dnl CF_HEADER_PATH version: 12 updated: 2010/05/05 05:22:40
2804 dnl --------------
2805 dnl Construct a search-list of directories for a nonstandard header-file
2806 dnl
2807 dnl Parameters
2808 dnl     $1 = the variable to return as result
2809 dnl     $2 = the package name
2810 AC_DEFUN([CF_HEADER_PATH],
2811 [
2812 $1=
2813
2814 # collect the current set of include-directories from compiler flags
2815 cf_header_path_list=""
2816 if test -n "${CFLAGS}${CPPFLAGS}" ; then
2817         for cf_header_path in $CPPFLAGS $CFLAGS
2818         do
2819                 case $cf_header_path in #(vi
2820                 -I*)
2821                         cf_header_path=`echo ".$cf_header_path" |sed -e 's/^...//' -e 's,/include$,,'`
2822                         CF_ADD_SUBDIR_PATH($1,$2,include,$cf_header_path,NONE)
2823                         cf_header_path_list="$cf_header_path_list [$]$1"
2824                         ;;
2825                 esac
2826         done
2827 fi
2828
2829 # add the variations for the package we are looking for
2830 CF_SUBDIR_PATH($1,$2,include)
2831
2832 test "$includedir" != NONE && \
2833 test "$includedir" != "/usr/include" && \
2834 test -d "$includedir" && {
2835         test -d $includedir &&    $1="[$]$1 $includedir"
2836         test -d $includedir/$2 && $1="[$]$1 $includedir/$2"
2837 }
2838
2839 test "$oldincludedir" != NONE && \
2840 test "$oldincludedir" != "/usr/include" && \
2841 test -d "$oldincludedir" && {
2842         test -d $oldincludedir    && $1="[$]$1 $oldincludedir"
2843         test -d $oldincludedir/$2 && $1="[$]$1 $oldincludedir/$2"
2844 }
2845
2846 $1="[$]$1 $cf_header_path_list"
2847 ])dnl
2848 dnl ---------------------------------------------------------------------------
2849 dnl CF_HELP_MESSAGE version: 3 updated: 1998/01/14 10:56:23
2850 dnl ---------------
2851 dnl Insert text into the help-message, for readability, from AC_ARG_WITH.
2852 AC_DEFUN([CF_HELP_MESSAGE],
2853 [AC_DIVERT_HELP([$1])dnl
2854 ])dnl
2855 dnl ---------------------------------------------------------------------------
2856 dnl CF_INCLUDE_DIRS version: 10 updated: 2014/09/19 20:58:42
2857 dnl ---------------
2858 dnl Construct the list of include-options according to whether we're building
2859 dnl in the source directory or using '--srcdir=DIR' option.
2860 AC_DEFUN([CF_INCLUDE_DIRS],
2861 [
2862 if test "$srcdir" != "."; then
2863         CPPFLAGS="-I\${srcdir}/../include $CPPFLAGS"
2864 fi
2865 CPPFLAGS="-I../include $CPPFLAGS"
2866 if test "$srcdir" != "."; then
2867         CPPFLAGS="-I\${srcdir} $CPPFLAGS"
2868 fi
2869 CPPFLAGS="-I. $CPPFLAGS"
2870 AC_SUBST(CPPFLAGS)
2871 ])dnl
2872 dnl ---------------------------------------------------------------------------
2873 dnl CF_INTEL_COMPILER version: 6 updated: 2014/03/17 13:13:07
2874 dnl -----------------
2875 dnl Check if the given compiler is really the Intel compiler for Linux.  It
2876 dnl tries to imitate gcc, but does not return an error when it finds a mismatch
2877 dnl between prototypes, e.g., as exercised by CF_MISSING_CHECK.
2878 dnl
2879 dnl This macro should be run "soon" after AC_PROG_CC or AC_PROG_CPLUSPLUS, to
2880 dnl ensure that it is not mistaken for gcc/g++.  It is normally invoked from
2881 dnl the wrappers for gcc and g++ warnings.
2882 dnl
2883 dnl $1 = GCC (default) or GXX
2884 dnl $2 = INTEL_COMPILER (default) or INTEL_CPLUSPLUS
2885 dnl $3 = CFLAGS (default) or CXXFLAGS
2886 AC_DEFUN([CF_INTEL_COMPILER],[
2887 AC_REQUIRE([AC_CANONICAL_HOST])
2888 ifelse([$2],,INTEL_COMPILER,[$2])=no
2889
2890 if test "$ifelse([$1],,[$1],GCC)" = yes ; then
2891         case $host_os in
2892         linux*|gnu*)
2893                 AC_MSG_CHECKING(if this is really Intel ifelse([$1],GXX,C++,C) compiler)
2894                 cf_save_CFLAGS="$ifelse([$3],,CFLAGS,[$3])"
2895                 ifelse([$3],,CFLAGS,[$3])="$ifelse([$3],,CFLAGS,[$3]) -no-gcc"
2896                 AC_TRY_COMPILE([],[
2897 #ifdef __INTEL_COMPILER
2898 #else
2899 make an error
2900 #endif
2901 ],[ifelse([$2],,INTEL_COMPILER,[$2])=yes
2902 cf_save_CFLAGS="$cf_save_CFLAGS -we147"
2903 ],[])
2904                 ifelse([$3],,CFLAGS,[$3])="$cf_save_CFLAGS"
2905                 AC_MSG_RESULT($ifelse([$2],,INTEL_COMPILER,[$2]))
2906                 ;;
2907         esac
2908 fi
2909 ])dnl
2910 dnl ---------------------------------------------------------------------------
2911 dnl CF_ISASCII version: 4 updated: 2012/10/06 17:56:13
2912 dnl ----------
2913 dnl Check if we have either a function or macro for 'isascii()'.
2914 AC_DEFUN([CF_ISASCII],
2915 [
2916 AC_MSG_CHECKING(for isascii)
2917 AC_CACHE_VAL(cf_cv_have_isascii,[
2918         AC_TRY_LINK([#include <ctype.h>],[int x = isascii(' ')],
2919         [cf_cv_have_isascii=yes],
2920         [cf_cv_have_isascii=no])
2921 ])dnl
2922 AC_MSG_RESULT($cf_cv_have_isascii)
2923 test "$cf_cv_have_isascii" = yes && AC_DEFINE(HAVE_ISASCII,1,[Define to 1 if we have isascii()])
2924 ])dnl
2925 dnl ---------------------------------------------------------------------------
2926 dnl CF_LARGEFILE version: 8 updated: 2012/10/06 08:57:51
2927 dnl ------------
2928 dnl Add checks for large file support.
2929 AC_DEFUN([CF_LARGEFILE],[
2930 ifdef([AC_FUNC_FSEEKO],[
2931     AC_SYS_LARGEFILE
2932     if test "$enable_largefile" != no ; then
2933         AC_FUNC_FSEEKO
2934
2935         # Normally we would collect these definitions in the config.h,
2936         # but (like _XOPEN_SOURCE), some environments rely on having these
2937         # defined before any of the system headers are included.  Another
2938         # case comes up with C++, e.g., on AIX the compiler compiles the
2939         # header files by themselves before looking at the body files it is
2940         # told to compile.  For ncurses, those header files do not include
2941         # the config.h
2942         test "$ac_cv_sys_large_files"      != no && CPPFLAGS="$CPPFLAGS -D_LARGE_FILES "
2943         test "$ac_cv_sys_largefile_source" != no && CPPFLAGS="$CPPFLAGS -D_LARGEFILE_SOURCE "
2944         test "$ac_cv_sys_file_offset_bits" != no && CPPFLAGS="$CPPFLAGS -D_FILE_OFFSET_BITS=$ac_cv_sys_file_offset_bits "
2945
2946         AC_CACHE_CHECK(whether to use struct dirent64, cf_cv_struct_dirent64,[
2947                 AC_TRY_COMPILE([
2948 #include <sys/types.h>
2949 #include <dirent.h>
2950                 ],[
2951                 /* if transitional largefile support is setup, this is true */
2952                 extern struct dirent64 * readdir(DIR *);
2953                 struct dirent64 *x = readdir((DIR *)0);
2954                 struct dirent *y = readdir((DIR *)0);
2955                 int z = x - y;
2956                 ],
2957                 [cf_cv_struct_dirent64=yes],
2958                 [cf_cv_struct_dirent64=no])
2959         ])
2960         test "$cf_cv_struct_dirent64" = yes && AC_DEFINE(HAVE_STRUCT_DIRENT64,1,[Define to 1 if we have struct dirent64])
2961     fi
2962 ])
2963 ])
2964 dnl ---------------------------------------------------------------------------
2965 dnl CF_LDFLAGS_STATIC version: 10 updated: 2011/09/24 12:51:48
2966 dnl -----------------
2967 dnl Check for compiler/linker flags used to temporarily force usage of static
2968 dnl libraries.  This depends on the compiler and platform.  Use this to help
2969 dnl ensure that the linker picks up a given library based on its position in
2970 dnl the list of linker options and libraries.
2971 AC_DEFUN([CF_LDFLAGS_STATIC],[
2972
2973 if test "$GCC" = yes ; then
2974         case $cf_cv_system_name in #(
2975         OS/2*|os2*|aix[[4]]*|solaris2.1[[0-9]]|darwin*)         #( vi
2976                 LDFLAGS_STATIC=
2977                 LDFLAGS_SHARED=
2978                 ;;
2979     *)  #( normally, except when broken
2980         LDFLAGS_STATIC=-static
2981         LDFLAGS_SHARED=-dynamic
2982         ;;
2983     esac
2984 else
2985         case $cf_cv_system_name in #(
2986         aix[[4-7]]*)    #( from ld manpage
2987                 LDFLAGS_STATIC=-bstatic
2988                 LDFLAGS_SHARED=-bdynamic
2989                 ;;
2990         hpux*)          #( from ld manpage for hpux10.20, hpux11.11
2991                 # We could also use just "archive" and "shared".
2992                 LDFLAGS_STATIC=-Wl,-a,archive_shared
2993                 LDFLAGS_SHARED=-Wl,-a,shared_archive
2994                 ;;
2995         irix*)          #( from ld manpage IRIX64
2996                 LDFLAGS_STATIC=-Bstatic
2997                 LDFLAGS_SHARED=-Bdynamic
2998                 ;;
2999         osf[[45]]*)     #( from ld manpage osf4.0d, osf5.1
3000                 # alternative "-oldstyle_liblookup" (not in cc manpage)
3001                 LDFLAGS_STATIC=-noso
3002                 LDFLAGS_SHARED=-so_archive
3003                 ;;
3004         solaris2*)
3005                 LDFLAGS_STATIC=-Bstatic
3006                 LDFLAGS_SHARED=-Bdynamic
3007                 ;;
3008         esac
3009 fi
3010
3011 if test -n "$LDFLAGS_STATIC" && test -n "$LDFLAGS_SHARED"
3012 then
3013         AC_MSG_CHECKING(if linker supports switching between static/dynamic)
3014
3015         rm -f libconftest.a
3016         cat >conftest.$ac_ext <<EOF
3017 #line __oline__ "configure"
3018 #include <stdio.h>
3019 int cf_ldflags_static(FILE *fp) { return fflush(fp); }
3020 EOF
3021         if AC_TRY_EVAL(ac_compile) ; then
3022                 ( $AR $ARFLAGS libconftest.a conftest.o ) 2>&AC_FD_CC 1>/dev/null
3023                 ( eval $RANLIB libconftest.a ) 2>&AC_FD_CC >/dev/null
3024         fi
3025         rm -f conftest.*
3026
3027         cf_save_LIBS="$LIBS"
3028
3029         LIBS="$LDFLAGS_STATIC -L`pwd` -lconftest $LDFLAGS_DYNAMIC $LIBS"
3030         AC_TRY_LINK([
3031 #line __oline__ "configure"
3032 #include <stdio.h>
3033 int cf_ldflags_static(FILE *fp);
3034 ],[
3035         return cf_ldflags_static(stdin);
3036 ],[
3037         # some linkers simply ignore the -dynamic
3038         case x`file conftest$ac_exeext 2>/dev/null` in #(vi
3039         *static*) # (vi
3040                 cf_ldflags_static=no
3041                 ;;
3042         *)
3043                 cf_ldflags_static=yes
3044                 ;;
3045         esac
3046 ],[cf_ldflags_static=no])
3047
3048         rm -f libconftest.*
3049         LIBS="$cf_save_LIBS"
3050
3051         AC_MSG_RESULT($cf_ldflags_static)
3052
3053         if test $cf_ldflags_static != yes
3054         then
3055                 LDFLAGS_STATIC=
3056                 LDFLAGS_SHARED=
3057         fi
3058 else
3059         LDFLAGS_STATIC=
3060         LDFLAGS_SHARED=
3061 fi
3062
3063 AC_SUBST(LDFLAGS_STATIC)
3064 AC_SUBST(LDFLAGS_SHARED)
3065 ])
3066 dnl ---------------------------------------------------------------------------
3067 dnl CF_LD_RPATH_OPT version: 5 updated: 2011/07/17 14:48:41
3068 dnl ---------------
3069 dnl For the given system and compiler, find the compiler flags to pass to the
3070 dnl loader to use the "rpath" feature.
3071 AC_DEFUN([CF_LD_RPATH_OPT],
3072 [
3073 AC_REQUIRE([CF_CHECK_CACHE])
3074
3075 LD_RPATH_OPT=
3076 AC_MSG_CHECKING(for an rpath option)
3077 case $cf_cv_system_name in #(vi
3078 irix*) #(vi
3079         if test "$GCC" = yes; then
3080                 LD_RPATH_OPT="-Wl,-rpath,"
3081         else
3082                 LD_RPATH_OPT="-rpath "
3083         fi
3084         ;;
3085 linux*|gnu*|k*bsd*-gnu) #(vi
3086         LD_RPATH_OPT="-Wl,-rpath,"
3087         ;;
3088 openbsd[[2-9]].*|mirbsd*) #(vi
3089         LD_RPATH_OPT="-Wl,-rpath,"
3090         ;;
3091 dragonfly*|freebsd*) #(vi
3092         LD_RPATH_OPT="-rpath "
3093         ;;
3094 netbsd*) #(vi
3095         LD_RPATH_OPT="-Wl,-rpath,"
3096         ;;
3097 osf*|mls+*) #(vi
3098         LD_RPATH_OPT="-rpath "
3099         ;;
3100 solaris2*) #(vi
3101         LD_RPATH_OPT="-R"
3102         ;;
3103 *)
3104         ;;
3105 esac
3106 AC_MSG_RESULT($LD_RPATH_OPT)
3107
3108 case "x$LD_RPATH_OPT" in #(vi
3109 x-R*)
3110         AC_MSG_CHECKING(if we need a space after rpath option)
3111         cf_save_LIBS="$LIBS"
3112         CF_ADD_LIBS(${LD_RPATH_OPT}$libdir)
3113         AC_TRY_LINK(, , cf_rpath_space=no, cf_rpath_space=yes)
3114         LIBS="$cf_save_LIBS"
3115         AC_MSG_RESULT($cf_rpath_space)
3116         test "$cf_rpath_space" = yes && LD_RPATH_OPT="$LD_RPATH_OPT "
3117         ;;
3118 esac
3119 ])dnl
3120 dnl ---------------------------------------------------------------------------
3121 dnl CF_LIBRARY_PATH version: 9 updated: 2010/03/28 12:52:50
3122 dnl ---------------
3123 dnl Construct a search-list of directories for a nonstandard library-file
3124 dnl
3125 dnl Parameters
3126 dnl     $1 = the variable to return as result
3127 dnl     $2 = the package name
3128 AC_DEFUN([CF_LIBRARY_PATH],
3129 [
3130 $1=
3131 cf_library_path_list=""
3132 if test -n "${LDFLAGS}${LIBS}" ; then
3133         for cf_library_path in $LDFLAGS $LIBS
3134         do
3135                 case $cf_library_path in #(vi
3136                 -L*)
3137                         cf_library_path=`echo ".$cf_library_path" |sed -e 's/^...//' -e 's,/lib$,,'`
3138                         CF_ADD_SUBDIR_PATH($1,$2,lib,$cf_library_path,NONE)
3139                         cf_library_path_list="$cf_library_path_list [$]$1"
3140                         ;;
3141                 esac
3142         done
3143 fi
3144
3145 CF_SUBDIR_PATH($1,$2,lib)
3146
3147 $1="$cf_library_path_list [$]$1"
3148 ])dnl
3149 dnl ---------------------------------------------------------------------------
3150 dnl CF_LIBTOOL_VERSION version: 1 updated: 2013/04/06 18:03:09
3151 dnl ------------------
3152 AC_DEFUN([CF_LIBTOOL_VERSION],[
3153 if test -n "$LIBTOOL" && test "$LIBTOOL" != none
3154 then
3155         cf_cv_libtool_version=`$LIBTOOL --version 2>&1 | sed -e '/^$/d' |sed -e '2,$d' -e 's/([[^)]]*)//g' -e 's/^[[^1-9]]*//' -e 's/[[^0-9.]].*//'`
3156 else
3157         cf_cv_libtool_version=
3158 fi
3159 test -z "$cf_cv_libtool_version" && unset cf_cv_libtool_version
3160 ])dnl
3161 dnl ---------------------------------------------------------------------------
3162 dnl CF_LIB_PREFIX version: 9 updated: 2012/01/21 19:28:10
3163 dnl -------------
3164 dnl Compute the library-prefix for the given host system
3165 dnl $1 = variable to set
3166 define([CF_LIB_PREFIX],
3167 [
3168         case $cf_cv_system_name in #(vi
3169         OS/2*|os2*) #(vi
3170         LIB_PREFIX=''
3171         ;;
3172         *)      LIB_PREFIX='lib'
3173         ;;
3174         esac
3175 ifelse($1,,,[$1=$LIB_PREFIX])
3176         AC_SUBST(LIB_PREFIX)
3177 ])dnl
3178 dnl ---------------------------------------------------------------------------
3179 dnl CF_LIB_RULES version: 75 updated: 2014/09/20 20:16:32
3180 dnl ------------
3181 dnl Append definitions and rules for the given models to the subdirectory
3182 dnl Makefiles, and the recursion rule for the top-level Makefile.  If the
3183 dnl subdirectory is a library-source directory, modify the Libs_To_Make list in
3184 dnl the corresponding makefile to list the models that we'll generate.
3185 dnl
3186 dnl For shared libraries, make a list of symbolic links to construct when
3187 dnl generating each library.  The convention used for Linux is the simplest
3188 dnl one:
3189 dnl     lib<name>.so    ->
3190 dnl     lib<name>.so.<major>    ->
3191 dnl     lib<name>.so.<maj>.<minor>
3192 dnl
3193 dnl Note: Libs_To_Make is mixed case, since it is not a pure autoconf variable.
3194 AC_DEFUN([CF_LIB_RULES],
3195 [
3196 cf_prefix=$LIB_PREFIX
3197 AC_REQUIRE([CF_SUBST_NCURSES_VERSION])
3198
3199 case $cf_cv_shlib_version in #(vi
3200 cygdll|msysdll|mingw)
3201         TINFO_NAME=$TINFO_ARG_SUFFIX
3202         TINFO_SUFFIX=.dll
3203         ;;
3204 esac
3205
3206 if test -n "$TINFO_SUFFIX" ; then
3207         case $TINFO_SUFFIX in
3208         tw*)
3209                 TINFO_NAME="${TINFO_NAME}tw"
3210                 TINFO_SUFFIX=`echo $TINFO_SUFFIX | sed 's/^tw//'`
3211                 ;;
3212         t*)
3213                 TINFO_NAME="${TINFO_NAME}t"
3214                 TINFO_SUFFIX=`echo $TINFO_SUFFIX | sed 's/^t//'`
3215                 ;;
3216         w*)
3217                 TINFO_NAME="${TINFO_NAME}w"
3218                 TINFO_SUFFIX=`echo $TINFO_SUFFIX | sed 's/^w//'`
3219                 ;;
3220         esac
3221 fi
3222
3223 for cf_dir in $SRC_SUBDIRS
3224 do
3225         if test ! -d $srcdir/$cf_dir ; then
3226                 continue
3227         elif test -f $srcdir/$cf_dir/modules; then
3228
3229                 SHARED_LIB=
3230                 Libs_To_Make=
3231                 for cf_item in $cf_LIST_MODELS
3232                 do
3233                         CF_LIB_SUFFIX($cf_item,cf_suffix,cf_depsuf)
3234                         cf_libname=$cf_dir
3235                         test "$cf_dir" = c++ && cf_libname=ncurses++
3236                         if test $cf_item = shared ; then
3237                                 if test -n "${LIB_SUFFIX}"
3238                                 then
3239                                         cf_shared_suffix=`echo "$cf_suffix" | sed 's/^'"${LIB_SUFFIX}"'//'`
3240                                 else
3241                                         cf_shared_suffix="$cf_suffix"
3242                                 fi
3243                                 if test "$cf_cv_do_symlinks" = yes ; then
3244                                         cf_version_name=
3245
3246                                         case "$cf_cv_shlib_version" in #(vi
3247                                         rel) #(vi
3248                                                 cf_version_name=REL_VERSION
3249                                                 ;;
3250                                         abi)
3251                                                 cf_version_name=ABI_VERSION
3252                                                 ;;
3253                                         esac
3254
3255                                         if test -n "$cf_version_name"
3256                                         then
3257                                                 case "$cf_cv_system_name" in #(vi
3258                                                 darwin*)
3259                                                         # "w", etc?
3260                                                         cf_suffix="${LIB_SUFFIX}"'.${'$cf_version_name'}'"$cf_shared_suffix"
3261                                                         ;; #(vi
3262                                                 *)
3263                                                         cf_suffix="$cf_suffix"'.${'$cf_version_name'}'
3264                                                         ;;
3265                                                 esac
3266                                         fi
3267                                         if test -n "${LIB_SUFFIX}"
3268                                         then
3269                                                 cf_shared_suffix=`echo "$cf_suffix" | sed 's/^'"${LIB_SUFFIX}"'//'`
3270                                         else
3271                                                 cf_shared_suffix="$cf_suffix"
3272                                         fi
3273                                 fi
3274                                 # cygwin needs import library, and has unique naming convention
3275                                 # use autodetected ${cf_prefix} for import lib and static lib, but
3276                                 # use 'cyg' prefix for shared lib.
3277                                 case $cf_cv_shlib_version in #(vi
3278                                 cygdll) #(vi
3279                                         cf_cygsuf=`echo "$cf_suffix" | sed -e 's/\.dll/\${ABI_VERSION}.dll/'`
3280                                         Libs_To_Make="$Libs_To_Make ../lib/cyg${cf_libname}${cf_cygsuf}"
3281                                         continue
3282                                         ;;
3283                                 msysdll) #(vi
3284                                         cf_cygsuf=`echo "$cf_suffix" | sed -e 's/\.dll/\${ABI_VERSION}.dll/'`
3285                                         Libs_To_Make="$Libs_To_Make ../lib/msys-${cf_libname}${cf_cygsuf}"
3286                                         continue
3287                                         ;;
3288                                 mingw)
3289                                         cf_cygsuf=`echo "$cf_suffix" | sed -e 's/\.dll/\${ABI_VERSION}.dll/'`
3290                                         Libs_To_Make="$Libs_To_Make ../lib/lib${cf_libname}${cf_cygsuf}"
3291                                         continue
3292                                         ;;
3293                                 esac
3294                         fi
3295                         Libs_To_Make="$Libs_To_Make ../lib/${cf_prefix}${cf_libname}${cf_suffix}"
3296                 done
3297
3298                 if test $cf_dir = ncurses ; then
3299                         cf_subsets="$LIB_SUBSETS"
3300                         cf_r_parts="$cf_subsets"
3301                         cf_liblist="$Libs_To_Make"
3302
3303                         while test -n "$cf_r_parts"
3304                         do
3305                                 cf_l_parts=`echo "$cf_r_parts" |sed -e 's/ .*$//'`
3306                                 cf_r_parts=`echo "$cf_r_parts" |sed -e 's/^[[^ ]]* //'`
3307                                 if test "$cf_l_parts" != "$cf_r_parts" ; then
3308                                         cf_item=
3309                                         case $cf_l_parts in #(vi
3310                                         *termlib*) #(vi
3311                                                 cf_item=`echo $cf_liblist |sed -e s%${LIB_NAME}${LIB_SUFFIX}%${TINFO_LIB_SUFFIX}%g`
3312                                                 ;;
3313                                         *ticlib*)
3314                                                 cf_item=`echo $cf_liblist |sed -e s%${LIB_NAME}${LIB_SUFFIX}%${TICS_LIB_SUFFIX}%g`
3315                                                 ;;
3316                                         *)
3317                                                 break
3318                                                 ;;
3319                                         esac
3320                                         if test -n "$cf_item"; then
3321                                                 Libs_To_Make="$cf_item $Libs_To_Make"
3322                                         fi
3323                                 else
3324                                         break
3325                                 fi
3326                         done
3327                 else
3328                         cf_subsets=`echo "$LIB_SUBSETS" | sed -e 's/^termlib.* //'`
3329                 fi
3330
3331                 if test $cf_dir = c++; then
3332                         if test "x$with_shared_cxx" != xyes && test -n "$cf_shared_suffix"; then
3333                                 cf_list=
3334                                 for cf_item in $Libs_To_Make
3335                                 do
3336                                         case $cf_item in
3337                                         *.a)
3338                                                 ;;
3339                                         *)
3340                                                 cf_item=`echo "$cf_item" | sed -e "s,"$cf_shared_suffix",.a,"`
3341                                                 ;;
3342                                         esac
3343                                         for cf_test in $cf_list
3344                                         do
3345                                                 if test "$cf_test" = "$cf_item"
3346                                                 then
3347                                                         cf_LIST_MODELS=`echo "$cf_LIST_MODELS" | sed -e 's/normal//'`
3348                                                         cf_item=
3349                                                         break
3350                                                 fi
3351                                         done
3352                                         test -n "$cf_item" && cf_list="$cf_list $cf_item"
3353                                 done
3354                                 Libs_To_Make="$cf_list"
3355                         fi
3356                 fi
3357
3358                 sed -e "s%@Libs_To_Make@%$Libs_To_Make%" \
3359                     -e "s%@SHARED_LIB@%$SHARED_LIB%" \
3360                         $cf_dir/Makefile >$cf_dir/Makefile.out
3361                 mv $cf_dir/Makefile.out $cf_dir/Makefile
3362
3363                 $AWK -f $srcdir/mk-0th.awk \
3364                         libname="${cf_dir}${LIB_SUFFIX}" subsets="$LIB_SUBSETS" ticlib="$TICS_LIB_SUFFIX" termlib="$TINFO_LIB_SUFFIX" \
3365                         $srcdir/$cf_dir/modules >>$cf_dir/Makefile
3366
3367                 for cf_subset in $cf_subsets
3368                 do
3369                         cf_subdirs=
3370                         for cf_item in $cf_LIST_MODELS
3371                         do
3372
3373                         echo "Appending rules for ${cf_item} model (${cf_dir}: ${cf_subset})"
3374                         CF_UPPER(cf_ITEM,$cf_item)
3375
3376                         CXX_MODEL=$cf_ITEM
3377                         if test "$CXX_MODEL" = SHARED; then
3378                                 case $cf_cv_shlib_version in #(vi
3379                                 cygdll|msysdll|mingw) #(vi
3380                                         test "x$with_shared_cxx" = xno && CF_VERBOSE(overriding CXX_MODEL to SHARED)
3381                                         with_shared_cxx=yes
3382                                         ;;
3383                                 *)
3384                                         test "x$with_shared_cxx" = xno && CXX_MODEL=NORMAL
3385                                         ;;
3386                                 esac
3387                         fi
3388
3389                         CF_LIB_SUFFIX($cf_item,cf_suffix,cf_depsuf)
3390                         CF_OBJ_SUBDIR($cf_item,cf_subdir)
3391
3392                         # Test for case where we build libtinfo with a different name.
3393                         cf_libname=$cf_dir
3394                         if test $cf_dir = ncurses ; then
3395                                 case $cf_subset in
3396                                 *base*)
3397                                         cf_libname=${cf_libname}$LIB_SUFFIX
3398                                         ;;
3399                                 *termlib*)
3400                                         cf_libname=$TINFO_LIB_SUFFIX
3401                                         ;;
3402                                 ticlib*)
3403                                         cf_libname=$TICS_LIB_SUFFIX
3404                                         ;;
3405                                 esac
3406                         elif test $cf_dir = c++ ; then
3407                                 cf_libname=ncurses++$LIB_SUFFIX
3408                         else
3409                                 cf_libname=${cf_libname}$LIB_SUFFIX
3410                         fi
3411                         if test -n "${DFT_ARG_SUFFIX}" ; then
3412                                 # undo $LIB_SUFFIX add-on in CF_LIB_SUFFIX
3413                                 cf_suffix=`echo $cf_suffix |sed -e "s%^${LIB_SUFFIX}%%"`
3414                         fi
3415
3416                         # These dependencies really are for development, not
3417                         # builds, but they are useful in porting, too.
3418                         cf_depend="../include/ncurses_cfg.h"
3419                         if test "$srcdir" = "."; then
3420                                 cf_reldir="."
3421                         else
3422                                 cf_reldir="\${srcdir}"
3423                         fi
3424
3425                         if test -f $srcdir/$cf_dir/$cf_dir.priv.h; then
3426                                 cf_depend="$cf_depend $cf_reldir/$cf_dir.priv.h"
3427                         elif test -f $srcdir/$cf_dir/curses.priv.h; then
3428                                 cf_depend="$cf_depend $cf_reldir/curses.priv.h"
3429                         fi
3430
3431                         cf_dir_suffix=
3432                         old_cf_suffix="$cf_suffix"
3433                         if test "$cf_cv_shlib_version_infix" = yes ; then
3434                         if test -n "$LIB_SUFFIX" ; then
3435                                 case $LIB_SUFFIX in
3436                                 tw*)
3437                                         cf_libname=`echo $cf_libname | sed 's/tw$//'`
3438                                         cf_suffix=`echo $cf_suffix | sed 's/^tw//'`
3439                                         cf_dir_suffix=tw
3440                                         ;;
3441                                 t*)
3442                                         cf_libname=`echo $cf_libname | sed 's/t$//'`
3443                                         cf_suffix=`echo $cf_suffix | sed 's/^t//'`
3444                                         cf_dir_suffix=t
3445                                         ;;
3446                                 w*)
3447                                         cf_libname=`echo $cf_libname | sed 's/w$//'`
3448                                         cf_suffix=`echo $cf_suffix | sed 's/^w//'`
3449                                         cf_dir_suffix=w
3450                                         ;;
3451                                 esac
3452                         fi
3453                         fi
3454
3455                         $AWK -f $srcdir/mk-1st.awk \
3456                                 name=${cf_libname}${cf_dir_suffix} \
3457                                 traces=$LIB_TRACING \
3458                                 MODEL=$cf_ITEM \
3459                                 CXX_MODEL=$CXX_MODEL \
3460                                 model=$cf_subdir \
3461                                 prefix=$cf_prefix \
3462                                 suffix=$cf_suffix \
3463                                 subset=$cf_subset \
3464                                 driver=$cf_cv_term_driver \
3465                                 SymLink="$LN_S" \
3466                                 TermlibRoot=$TINFO_NAME \
3467                                 TermlibSuffix=$TINFO_SUFFIX \
3468                                 ShlibVer=$cf_cv_shlib_version \
3469                                 ShlibVerInfix=$cf_cv_shlib_version_infix \
3470                                 ReLink=${cf_cv_do_relink:-no} \
3471                                 DoLinks=$cf_cv_do_symlinks \
3472                                 rmSoLocs=$cf_cv_rm_so_locs \
3473                                 ldconfig="$LDCONFIG" \
3474                                 overwrite=$WITH_OVERWRITE \
3475                                 depend="$cf_depend" \
3476                                 host="$host" \
3477                                 libtool_version="$LIBTOOL_VERSION" \
3478                                 $srcdir/$cf_dir/modules >>$cf_dir/Makefile
3479
3480                         cf_suffix="$old_cf_suffix"
3481
3482                         for cf_subdir2 in $cf_subdirs lib
3483                         do
3484                                 test $cf_subdir = $cf_subdir2 && break
3485                         done
3486                         test "${cf_subset}.${cf_subdir2}" != "${cf_subset}.${cf_subdir}" && \
3487                         $AWK -f $srcdir/mk-2nd.awk \
3488                                 name=$cf_dir \
3489                                 traces=$LIB_TRACING \
3490                                 MODEL=$cf_ITEM \
3491                                 model=$cf_subdir \
3492                                 subset=$cf_subset \
3493                                 srcdir=$srcdir \
3494                                 echo=$WITH_ECHO \
3495                                 crenames=$cf_cv_prog_CC_c_o \
3496                                 cxxrenames=$cf_cv_prog_CXX_c_o \
3497                                 $srcdir/$cf_dir/modules >>$cf_dir/Makefile
3498                         cf_subdirs="$cf_subdirs $cf_subdir"
3499                         done
3500                 done
3501         fi
3502
3503         echo '  cd '$cf_dir' && ${MAKE} ${TOP_MFLAGS} [$]@' >>Makefile
3504 done
3505
3506 for cf_dir in $SRC_SUBDIRS
3507 do
3508         if test ! -d $srcdir/$cf_dir ; then
3509                 continue
3510         fi
3511
3512         if test -f $cf_dir/Makefile ; then
3513                 case "$cf_dir" in
3514                 Ada95) #(vi
3515                         echo 'libs \' >> Makefile
3516                         echo 'install.libs \' >> Makefile
3517                         echo 'uninstall.libs ::' >> Makefile
3518                         echo '  cd '$cf_dir' && ${MAKE} ${TOP_MFLAGS} [$]@' >> Makefile
3519                         ;;
3520                 esac
3521         fi
3522
3523         if test -f $srcdir/$cf_dir/modules; then
3524                 echo >> Makefile
3525                 if test -f $srcdir/$cf_dir/headers; then
3526 cat >> Makefile <<CF_EOF
3527 install.includes \\
3528 uninstall.includes \\
3529 CF_EOF
3530                 fi
3531 if test "$cf_dir" != "c++" ; then
3532 echo 'lint \' >> Makefile
3533 fi
3534 cat >> Makefile <<CF_EOF
3535 libs \\
3536 lintlib \\
3537 install.libs \\
3538 uninstall.libs \\
3539 install.$cf_dir \\
3540 uninstall.$cf_dir ::
3541         cd $cf_dir && \${MAKE} \${TOP_MFLAGS} \[$]@
3542 CF_EOF
3543         elif test -f $srcdir/$cf_dir/headers; then
3544 cat >> Makefile <<CF_EOF
3545
3546 libs \\
3547 install.libs \\
3548 uninstall.libs \\
3549 install.includes \\
3550 uninstall.includes ::
3551         cd $cf_dir && \${MAKE} \${TOP_MFLAGS} \[$]@
3552 CF_EOF
3553 fi
3554 done
3555
3556 if test "x$cf_with_db_install" = xyes; then
3557 cat >> Makefile <<CF_EOF
3558
3559 install.libs uninstall.libs \\
3560 install.data uninstall.data ::
3561 $MAKE_TERMINFO  cd misc && \${MAKE} \${TOP_MFLAGS} \[$]@
3562 CF_EOF
3563 else
3564 cat >> Makefile <<CF_EOF
3565
3566 install.libs uninstall.libs ::
3567         cd misc && \${MAKE} \${TOP_MFLAGS} \[$]@
3568 CF_EOF
3569 fi
3570
3571 if test "x$cf_with_manpages" = xyes; then
3572 cat >> Makefile <<CF_EOF
3573
3574 install.man \\
3575 uninstall.man ::
3576         cd man && \${MAKE} \${TOP_MFLAGS} \[$]@
3577 CF_EOF
3578 fi
3579
3580 cat >> Makefile <<CF_EOF
3581
3582 distclean ::
3583         rm -f config.cache config.log config.status Makefile include/ncurses_cfg.h
3584         rm -f headers.sh headers.sed mk_shared_lib.sh
3585         rm -f edit_man.* man_alias.*
3586         rm -rf \${DIRS_TO_MAKE}
3587 CF_EOF
3588
3589 # Special case: tack's manpage lives in its own directory.
3590 if test "x$cf_with_manpages" = xyes; then
3591 if test -d tack ; then
3592 if test -f $srcdir/$tack.h; then
3593 cat >> Makefile <<CF_EOF
3594
3595 install.man \\
3596 uninstall.man ::
3597         cd tack && \${MAKE} \${TOP_MFLAGS} \[$]@
3598 CF_EOF
3599 fi
3600 fi
3601 fi
3602
3603 dnl If we're installing into a subdirectory of /usr/include, etc., we should
3604 dnl prepend the subdirectory's name to the "#include" paths.  It won't hurt
3605 dnl anything, and will make it more standardized.  It's awkward to decide this
3606 dnl at configuration because of quoting, so we'll simply make all headers
3607 dnl installed via a script that can do the right thing.
3608
3609 rm -f headers.sed headers.sh
3610
3611 dnl ( generating this script makes the makefiles a little tidier :-)
3612 echo creating headers.sh
3613 cat >headers.sh <<CF_EOF
3614 #! /bin/sh
3615 # This shell script is generated by the 'configure' script.  It is invoked in a
3616 # subdirectory of the build tree.  It generates a sed-script in the parent
3617 # directory that is used to adjust includes for header files that reside in a
3618 # subdirectory of /usr/include, etc.
3619 PRG=""
3620 while test \[$]# != 3
3621 do
3622 PRG="\$PRG \[$]1"; shift
3623 done
3624 DST=\[$]1
3625 REF=\[$]2
3626 SRC=\[$]3
3627 TMPSRC=\${TMPDIR:-/tmp}/\`basename \$SRC\`\$\$
3628 TMPSED=\${TMPDIR:-/tmp}/headers.sed\$\$
3629 echo installing \$SRC in \$DST
3630 CF_EOF
3631
3632 if test $WITH_CURSES_H = yes; then
3633         cat >>headers.sh <<CF_EOF
3634 case \$DST in
3635 /*/include/*)
3636         END=\`basename \$DST\`
3637         for i in \`cat \$REF/../*/headers |fgrep -v "#"\`
3638         do
3639                 NAME=\`basename \$i\`
3640                 echo "s/<\$NAME>/<\$END\/\$NAME>/" >> \$TMPSED
3641         done
3642         ;;
3643 *)
3644         echo "" >> \$TMPSED
3645         ;;
3646 esac
3647 CF_EOF
3648
3649 else
3650         cat >>headers.sh <<CF_EOF
3651 case \$DST in
3652 /*/include/*)
3653         END=\`basename \$DST\`
3654         for i in \`cat \$REF/../*/headers |fgrep -v "#"\`
3655         do
3656                 NAME=\`basename \$i\`
3657                 if test "\$NAME" = "curses.h"
3658                 then
3659                         echo "s/<curses.h>/<ncurses.h>/" >> \$TMPSED
3660                         NAME=ncurses.h
3661                 fi
3662                 echo "s/<\$NAME>/<\$END\/\$NAME>/" >> \$TMPSED
3663         done
3664         ;;
3665 *)
3666         echo "s/<curses.h>/<ncurses.h>/" >> \$TMPSED
3667         ;;
3668 esac
3669 CF_EOF
3670 fi
3671 cat >>headers.sh <<CF_EOF
3672 rm -f \$TMPSRC
3673 sed -f \$TMPSED \$SRC > \$TMPSRC
3674 NAME=\`basename \$SRC\`
3675 CF_EOF
3676 if test $WITH_CURSES_H != yes; then
3677         cat >>headers.sh <<CF_EOF
3678 test "\$NAME" = "curses.h" && NAME=ncurses.h
3679 CF_EOF
3680 fi
3681 cat >>headers.sh <<CF_EOF
3682 # Just in case someone gzip'd manpages, remove the conflicting copy.
3683 test -f \$DST/\$NAME.gz && rm -f \$DST/\$NAME.gz
3684
3685 eval \$PRG \$TMPSRC \$DST/\$NAME
3686 rm -f \$TMPSRC \$TMPSED
3687 CF_EOF
3688
3689 chmod 0755 headers.sh
3690
3691 for cf_dir in $SRC_SUBDIRS
3692 do
3693         if test ! -d $srcdir/$cf_dir ; then
3694                 continue
3695         fi
3696
3697         if test -f $srcdir/$cf_dir/headers; then
3698                 $AWK -f $srcdir/mk-hdr.awk \
3699                         subset="$LIB_SUBSETS" \
3700                         compat="$WITH_CURSES_H" \
3701                         $srcdir/$cf_dir/headers >>$cf_dir/Makefile
3702         fi
3703
3704         if test -f $srcdir/$cf_dir/modules; then
3705                 if test "$cf_dir" != "c++" ; then
3706                         cat >>$cf_dir/Makefile <<"CF_EOF"
3707 depend : ${AUTO_SRC}
3708         makedepend -- ${CPPFLAGS} -- ${C_SRC}
3709
3710 # DO NOT DELETE THIS LINE -- make depend depends on it.
3711 CF_EOF
3712                 fi
3713         fi
3714 done
3715 AC_SUBST(Libs_To_Make)
3716 ])dnl
3717 dnl ---------------------------------------------------------------------------
3718 dnl CF_LIB_SONAME version: 5 updated: 2010/08/14 18:25:37
3719 dnl -------------
3720 dnl Find the and soname for the given shared library.  Set the cache variable
3721 dnl cf_cv_$3_soname to this, unless it is not found.  Then set the cache
3722 dnl variable to "unknown".
3723 dnl
3724 dnl $1 = headers
3725 dnl $2 = code
3726 dnl $3 = library name
3727 AC_DEFUN([CF_LIB_SONAME],
3728 [
3729 AC_CACHE_CHECK(for soname of $3 library,cf_cv_$3_soname,[
3730
3731 cf_cv_$3_soname=unknown
3732 if test "$cross_compiling" != yes ; then
3733 cat >conftest.$ac_ext <<CF_EOF
3734 $1
3735 int main()
3736 {
3737 $2
3738         ${cf_cv_main_return:-return}(0);
3739 }
3740 CF_EOF
3741 cf_save_LIBS="$LIBS"
3742         CF_ADD_LIB($3)
3743         if AC_TRY_EVAL(ac_compile) ; then
3744                 if AC_TRY_EVAL(ac_link) ; then
3745                         cf_cv_$3_soname=`ldd conftest$ac_exeext 2>/dev/null | sed -e 's,^.*/,,' -e 's, .*$,,' | fgrep lib$3.`
3746                         test -z "$cf_cv_$3_soname" && cf_cv_$3_soname=unknown
3747                 fi
3748         fi
3749 rm -rf conftest*
3750 LIBS="$cf_save_LIBS"
3751 fi
3752 ])
3753 ])
3754 dnl ---------------------------------------------------------------------------
3755 dnl CF_LIB_SUFFIX version: 23 updated: 2014/06/21 17:47:12
3756 dnl -------------
3757 dnl Compute the library file-suffix from the given model name
3758 dnl $1 = model name
3759 dnl $2 = variable to set (the nominal library suffix)
3760 dnl $3 = dependency variable to set (actual filename)
3761 dnl The variable $LIB_SUFFIX, if set, prepends the variable to set.
3762 AC_DEFUN([CF_LIB_SUFFIX],
3763 [
3764         case X$1 in #(vi
3765         Xlibtool) #(vi
3766                 $2='.la'
3767                 $3=[$]$2
3768                 ;;
3769         Xdebug) #(vi
3770                 $2='_g.a'
3771                 $3=[$]$2
3772                 ;;
3773         Xprofile) #(vi
3774                 $2='_p.a'
3775                 $3=[$]$2
3776                 ;;
3777         Xshared) #(vi
3778                 case $cf_cv_system_name in
3779                 aix[[5-7]]*) #(vi
3780                         $2='.so'
3781                         $3=[$]$2
3782                         ;;
3783                 cygwin*|msys*|mingw*) #(vi
3784                         $2='.dll'
3785                         $3='.dll.a'
3786                         ;;
3787                 darwin*) #(vi
3788                         $2='.dylib'
3789                         $3=[$]$2
3790                         ;;
3791                 hpux*) #(vi
3792                         case $target in
3793                         ia64*) #(vi
3794                                 $2='.so'
3795                                 $3=[$]$2
3796                                 ;;
3797                         *) #(vi
3798                                 $2='.sl'
3799                                 $3=[$]$2
3800                                 ;;
3801                         esac
3802                         ;;
3803                 *) #(vi
3804                         $2='.so'
3805                         $3=[$]$2
3806                         ;;
3807                 esac
3808                 ;;
3809         *)
3810                 $2='.a'
3811                 $3=[$]$2
3812                 ;;
3813         esac
3814         test -n "$LIB_SUFFIX" && $2="${LIB_SUFFIX}[$]{$2}"
3815         test -n "$LIB_SUFFIX" && $3="${LIB_SUFFIX}[$]{$3}"
3816 ])dnl
3817 dnl ---------------------------------------------------------------------------
3818 dnl CF_LIB_TYPE version: 4 updated: 2000/10/20 22:57:49
3819 dnl -----------
3820 dnl Compute the string to append to -library from the given model name
3821 dnl $1 = model name
3822 dnl $2 = variable to set
3823 dnl The variable $LIB_SUFFIX, if set, prepends the variable to set.
3824 AC_DEFUN([CF_LIB_TYPE],
3825 [
3826         case $1 in
3827         libtool) $2=''   ;;
3828         normal)  $2=''   ;;
3829         debug)   $2='_g' ;;
3830         profile) $2='_p' ;;
3831         shared)  $2=''   ;;
3832         esac
3833         test -n "$LIB_SUFFIX" && $2="${LIB_SUFFIX}[$]{$2}"
3834 ])dnl
3835 dnl ---------------------------------------------------------------------------
3836 dnl CF_LINK_DATAONLY version: 10 updated: 2012/10/06 17:41:51
3837 dnl ----------------
3838 dnl Some systems have a non-ANSI linker that doesn't pull in modules that have
3839 dnl only data (i.e., no functions), for example NeXT.  On those systems we'll
3840 dnl have to provide wrappers for global tables to ensure they're linked
3841 dnl properly.
3842 AC_DEFUN([CF_LINK_DATAONLY],
3843 [
3844 AC_MSG_CHECKING([if data-only library module links])
3845 AC_CACHE_VAL(cf_cv_link_dataonly,[
3846         rm -f conftest.a
3847         cat >conftest.$ac_ext <<EOF
3848 #line __oline__ "configure"
3849 int     testdata[[3]] = { 123, 456, 789 };
3850 EOF
3851         if AC_TRY_EVAL(ac_compile) ; then
3852                 mv conftest.o data.o && \
3853                 ( $AR $ARFLAGS conftest.a data.o ) 2>&AC_FD_CC 1>/dev/null
3854         fi
3855         rm -f conftest.$ac_ext data.o
3856         cat >conftest.$ac_ext <<EOF
3857 #line __oline__ "configure"
3858 int     testfunc()
3859 {
3860 #if defined(NeXT)
3861         ${cf_cv_main_return:-return}(1);        /* I'm told this linker is broken */
3862 #else
3863         extern int testdata[[3]];
3864         return testdata[[0]] == 123
3865            &&  testdata[[1]] == 456
3866            &&  testdata[[2]] == 789;
3867 #endif
3868 }
3869 EOF
3870         if AC_TRY_EVAL(ac_compile); then
3871                 mv conftest.o func.o && \
3872                 ( $AR $ARFLAGS conftest.a func.o ) 2>&AC_FD_CC 1>/dev/null
3873         fi
3874         rm -f conftest.$ac_ext func.o
3875         ( eval $RANLIB conftest.a ) 2>&AC_FD_CC >/dev/null
3876         cf_saveLIBS="$LIBS"
3877         LIBS="conftest.a $LIBS"
3878         AC_TRY_RUN([
3879         int main()
3880         {
3881                 extern int testfunc();
3882                 ${cf_cv_main_return:-return} (!testfunc());
3883         }
3884         ],
3885         [cf_cv_link_dataonly=yes],
3886         [cf_cv_link_dataonly=no],
3887         [cf_cv_link_dataonly=unknown])
3888         LIBS="$cf_saveLIBS"
3889         ])
3890 AC_MSG_RESULT($cf_cv_link_dataonly)
3891
3892 if test "$cf_cv_link_dataonly" = no ; then
3893         AC_DEFINE(BROKEN_LINKER,1,[if data-only library module does not link])
3894         BROKEN_LINKER=1
3895 fi
3896
3897 ])dnl
3898 dnl ---------------------------------------------------------------------------
3899 dnl CF_LINK_FUNCS version: 8 updated: 2012/10/06 17:56:13
3900 dnl -------------
3901 dnl Most Unix systems have both link and symlink, a few don't have symlink.
3902 dnl A few non-Unix systems implement symlink, but not link.
3903 dnl A few non-systems implement neither (or have nonfunctional versions).
3904 AC_DEFUN([CF_LINK_FUNCS],
3905 [
3906 AC_CHECK_FUNCS( \
3907         remove \
3908         unlink )
3909
3910 if test "$cross_compiling" = yes ; then
3911         AC_CHECK_FUNCS( \
3912                 link \
3913                 symlink )
3914 else
3915         AC_CACHE_CHECK(if link/symlink functions work,cf_cv_link_funcs,[
3916                 cf_cv_link_funcs=
3917                 for cf_func in link symlink ; do
3918                         AC_TRY_RUN([
3919 #include <sys/types.h>
3920 #include <sys/stat.h>
3921 #ifdef HAVE_UNISTD_H
3922 #include <unistd.h>
3923 #endif
3924 int main()
3925 {
3926         int fail = 0;
3927         char *src = "config.log";
3928         char *dst = "conftest.chk";
3929         struct stat src_sb;
3930         struct stat dst_sb;
3931
3932         stat(src, &src_sb);
3933         fail = ($cf_func("config.log", "conftest.chk") < 0)
3934             || (stat(dst, &dst_sb) < 0)
3935             || (dst_sb.st_mtime != src_sb.st_mtime);
3936 #ifdef HAVE_UNLINK
3937         unlink(dst);
3938 #else
3939         remove(dst);
3940 #endif
3941         ${cf_cv_main_return:-return} (fail);
3942 }
3943                         ],[
3944                         cf_cv_link_funcs="$cf_cv_link_funcs $cf_func"
3945                         eval 'ac_cv_func_'$cf_func'=yes'],[
3946                         eval 'ac_cv_func_'$cf_func'=no'],[
3947                         eval 'ac_cv_func_'$cf_func'=error'])
3948                 done
3949                 test -z "$cf_cv_link_funcs" && cf_cv_link_funcs=no
3950         ])
3951         test "$ac_cv_func_link"    = yes && AC_DEFINE(HAVE_LINK,1,[Define to 1 if we have link() function])
3952         test "$ac_cv_func_symlink" = yes && AC_DEFINE(HAVE_SYMLINK,1,[Define to 1 if we have symlink() function])
3953 fi
3954 ])dnl
3955 dnl ---------------------------------------------------------------------------
3956 dnl CF_MAKEFLAGS version: 15 updated: 2014/05/10 16:43:23
3957 dnl ------------
3958 dnl Some 'make' programs support ${MAKEFLAGS}, some ${MFLAGS}, to pass 'make'
3959 dnl options to lower-levels.  It's very useful for "make -n" -- if we have it.
3960 dnl (GNU 'make' does both, something POSIX 'make', which happens to make the
3961 dnl ${MAKEFLAGS} variable incompatible because it adds the assignments :-)
3962 AC_DEFUN([CF_MAKEFLAGS],
3963 [
3964 AC_CACHE_CHECK(for makeflags variable, cf_cv_makeflags,[
3965         cf_cv_makeflags=''
3966         for cf_option in '-${MAKEFLAGS}' '${MFLAGS}'
3967         do
3968                 cat >cf_makeflags.tmp <<CF_EOF
3969 SHELL = /bin/sh
3970 all :
3971         @ echo '.$cf_option'
3972 CF_EOF
3973                 cf_result=`${MAKE:-make} -k -f cf_makeflags.tmp 2>/dev/null | fgrep -v "ing directory" | sed -e 's,[[   ]]*$,,'`
3974                 case "$cf_result" in
3975                 .*k|.*kw)
3976                         cf_result=`${MAKE:-make} -k -f cf_makeflags.tmp CC=cc 2>/dev/null`
3977                         case "$cf_result" in
3978                         .*CC=*) cf_cv_makeflags=
3979                                 ;;
3980                         *)      cf_cv_makeflags=$cf_option
3981                                 ;;
3982                         esac
3983                         break
3984                         ;;
3985                 .-)     ;;
3986                 *)      echo "given option \"$cf_option\", no match \"$cf_result\""
3987                         ;;
3988                 esac
3989         done
3990         rm -f cf_makeflags.tmp
3991 ])
3992
3993 AC_SUBST(cf_cv_makeflags)
3994 ])dnl
3995 dnl ---------------------------------------------------------------------------
3996 dnl CF_MAKE_TAGS version: 6 updated: 2010/10/23 15:52:32
3997 dnl ------------
3998 dnl Generate tags/TAGS targets for makefiles.  Do not generate TAGS if we have
3999 dnl a monocase filesystem.
4000 AC_DEFUN([CF_MAKE_TAGS],[
4001 AC_REQUIRE([CF_MIXEDCASE_FILENAMES])
4002
4003 AC_CHECK_PROGS(CTAGS, exctags ctags)
4004 AC_CHECK_PROGS(ETAGS, exetags etags)
4005
4006 AC_CHECK_PROG(MAKE_LOWER_TAGS, ${CTAGS:-ctags}, yes, no)
4007
4008 if test "$cf_cv_mixedcase" = yes ; then
4009         AC_CHECK_PROG(MAKE_UPPER_TAGS, ${ETAGS:-etags}, yes, no)
4010 else
4011         MAKE_UPPER_TAGS=no
4012 fi
4013
4014 if test "$MAKE_UPPER_TAGS" = yes ; then
4015         MAKE_UPPER_TAGS=
4016 else
4017         MAKE_UPPER_TAGS="#"
4018 fi
4019
4020 if test "$MAKE_LOWER_TAGS" = yes ; then
4021         MAKE_LOWER_TAGS=
4022 else
4023         MAKE_LOWER_TAGS="#"
4024 fi
4025
4026 AC_SUBST(CTAGS)
4027 AC_SUBST(ETAGS)
4028
4029 AC_SUBST(MAKE_UPPER_TAGS)
4030 AC_SUBST(MAKE_LOWER_TAGS)
4031 ])dnl
4032 dnl ---------------------------------------------------------------------------
4033 dnl CF_MANPAGE_FORMAT version: 9 updated: 2010/10/23 16:10:30
4034 dnl -----------------
4035 dnl Option to allow user to override automatic configuration of manpage format.
4036 dnl There are several special cases:
4037 dnl
4038 dnl     gzip - man checks for, can display gzip'd files
4039 dnl     compress - man checks for, can display compressed files
4040 dnl     BSDI - files in the cat-directories are suffixed ".0"
4041 dnl     formatted - installer should format (put files in cat-directory)
4042 dnl     catonly - installer should only format, e.g., for a turnkey system.
4043 dnl
4044 dnl There are other configurations which this macro does not test, e.g., HPUX's
4045 dnl compressed manpages (but uncompressed manpages are fine, and HPUX's naming
4046 dnl convention would not match our use).
4047 AC_DEFUN([CF_MANPAGE_FORMAT],
4048 [
4049 AC_REQUIRE([CF_PATHSEP])
4050 AC_MSG_CHECKING(format of man-pages)
4051
4052 AC_ARG_WITH(manpage-format,
4053         [  --with-manpage-format   specify manpage-format: gzip/compress/BSDI/normal and
4054                           optionally formatted/catonly, e.g., gzip,formatted],
4055         [MANPAGE_FORMAT=$withval],
4056         [MANPAGE_FORMAT=unknown])
4057
4058 test -z "$MANPAGE_FORMAT" && MANPAGE_FORMAT=unknown
4059 MANPAGE_FORMAT=`echo "$MANPAGE_FORMAT" | sed -e 's/,/ /g'`
4060
4061 cf_unknown=
4062
4063 case $MANPAGE_FORMAT in
4064 unknown)
4065   if test -z "$MANPATH" ; then
4066     MANPATH="/usr/man:/usr/share/man"
4067   fi
4068
4069   # look for the 'date' man-page (it's most likely to be installed!)
4070   MANPAGE_FORMAT=
4071   cf_preform=no
4072   cf_catonly=yes
4073   cf_example=date
4074
4075   IFS="${IFS:-  }"; ac_save_ifs="$IFS"; IFS="${IFS}${PATH_SEPARATOR}"
4076   for cf_dir in $MANPATH; do
4077     test -z "$cf_dir" && cf_dir=/usr/man
4078     for cf_name in $cf_dir/man*/$cf_example.[[01]]* $cf_dir/cat*/$cf_example.[[01]]* $cf_dir/man*/$cf_example $cf_dir/cat*/$cf_example
4079     do
4080       cf_test=`echo $cf_name | sed -e 's/*//'`
4081       if test "x$cf_test" = "x$cf_name" ; then
4082
4083         case "$cf_name" in
4084         *.gz) MANPAGE_FORMAT="$MANPAGE_FORMAT gzip";;
4085         *.Z)  MANPAGE_FORMAT="$MANPAGE_FORMAT compress";;
4086         *.0)    MANPAGE_FORMAT="$MANPAGE_FORMAT BSDI";;
4087         *)    MANPAGE_FORMAT="$MANPAGE_FORMAT normal";;
4088         esac
4089
4090         case "$cf_name" in
4091         $cf_dir/man*)
4092           cf_catonly=no
4093           ;;
4094         $cf_dir/cat*)
4095           cf_preform=yes
4096           ;;
4097         esac
4098         break
4099       fi
4100
4101       # if we found a match in either man* or cat*, stop looking
4102       if test -n "$MANPAGE_FORMAT" ; then
4103         cf_found=no
4104         test "$cf_preform" = yes && MANPAGE_FORMAT="$MANPAGE_FORMAT formatted"
4105         test "$cf_catonly" = yes && MANPAGE_FORMAT="$MANPAGE_FORMAT catonly"
4106         case "$cf_name" in
4107         $cf_dir/cat*)
4108           cf_found=yes
4109           ;;
4110         esac
4111         test $cf_found=yes && break
4112       fi
4113     done
4114     # only check the first directory in $MANPATH where we find manpages
4115     if test -n "$MANPAGE_FORMAT" ; then
4116        break
4117     fi
4118   done
4119   # if we did not find the example, just assume it is normal
4120   test -z "$MANPAGE_FORMAT" && MANPAGE_FORMAT=normal
4121   IFS="$ac_save_ifs"
4122   ;;
4123 *)
4124   for cf_option in $MANPAGE_FORMAT; do
4125      case $cf_option in #(vi
4126      gzip|compress|BSDI|normal|formatted|catonly)
4127        ;;
4128      *)
4129        cf_unknown="$cf_unknown $cf_option"
4130        ;;
4131      esac
4132   done
4133   ;;
4134 esac
4135
4136 AC_MSG_RESULT($MANPAGE_FORMAT)
4137 if test -n "$cf_unknown" ; then
4138   AC_MSG_WARN(Unexpected manpage-format $cf_unknown)
4139 fi
4140 ])dnl
4141 dnl ---------------------------------------------------------------------------
4142 dnl CF_MANPAGE_RENAMES version: 7 updated: 2005/06/18 18:51:57
4143 dnl ------------------
4144 dnl The Debian people have their own naming convention for manpages.  This
4145 dnl option lets us override the name of the file containing renaming, or
4146 dnl disable it altogether.
4147 AC_DEFUN([CF_MANPAGE_RENAMES],
4148 [
4149 AC_MSG_CHECKING(for manpage renaming)
4150
4151 AC_ARG_WITH(manpage-renames,
4152         [  --with-manpage-renames  specify manpage-renaming],
4153         [MANPAGE_RENAMES=$withval],
4154         [MANPAGE_RENAMES=yes])
4155
4156 case ".$MANPAGE_RENAMES" in #(vi
4157 .no) #(vi
4158   ;;
4159 .|.yes)
4160   # Debian 'man' program?
4161   if test -f /etc/debian_version ; then
4162     MANPAGE_RENAMES=`cd $srcdir && pwd`/man/man_db.renames
4163   else
4164     MANPAGE_RENAMES=no
4165   fi
4166   ;;
4167 esac
4168
4169 if test "$MANPAGE_RENAMES" != no ; then
4170   if test -f $srcdir/man/$MANPAGE_RENAMES ; then
4171     MANPAGE_RENAMES=`cd $srcdir/man && pwd`/$MANPAGE_RENAMES
4172   elif test ! -f $MANPAGE_RENAMES ; then
4173     AC_MSG_ERROR(not a filename: $MANPAGE_RENAMES)
4174   fi
4175
4176   test ! -d man && mkdir man
4177
4178   # Construct a sed-script to perform renaming within man-pages
4179   if test -n "$MANPAGE_RENAMES" ; then
4180     test ! -d man && mkdir man
4181     sh $srcdir/man/make_sed.sh $MANPAGE_RENAMES >./edit_man.sed
4182   fi
4183 fi
4184
4185 AC_MSG_RESULT($MANPAGE_RENAMES)
4186 AC_SUBST(MANPAGE_RENAMES)
4187 ])dnl
4188 dnl ---------------------------------------------------------------------------
4189 dnl CF_MANPAGE_SYMLINKS version: 5 updated: 2010/07/24 17:12:40
4190 dnl -------------------
4191 dnl Some people expect each tool to make all aliases for manpages in the
4192 dnl man-directory.  This accommodates the older, less-capable implementations
4193 dnl of 'man', and is optional.
4194 AC_DEFUN([CF_MANPAGE_SYMLINKS],
4195 [
4196 AC_MSG_CHECKING(if manpage aliases will be installed)
4197
4198 AC_ARG_WITH(manpage-aliases,
4199         [  --with-manpage-aliases  specify manpage-aliases using .so],
4200         [MANPAGE_ALIASES=$withval],
4201         [MANPAGE_ALIASES=yes])
4202
4203 AC_MSG_RESULT($MANPAGE_ALIASES)
4204
4205 case "x$LN_S" in #(vi
4206 xln*) #(vi
4207         cf_use_symlinks=yes
4208         ;;
4209 *)
4210         cf_use_symlinks=no
4211         ;;
4212 esac
4213
4214 MANPAGE_SYMLINKS=no
4215 if test "$MANPAGE_ALIASES" = yes ; then
4216 AC_MSG_CHECKING(if manpage symlinks should be used)
4217
4218 AC_ARG_WITH(manpage-symlinks,
4219         [  --with-manpage-symlinks specify manpage-aliases using symlinks],
4220         [MANPAGE_SYMLINKS=$withval],
4221         [MANPAGE_SYMLINKS=$cf_use_symlinks])
4222
4223 if test "$$cf_use_symlinks" = no; then
4224 if test "$MANPAGE_SYMLINKS" = yes ; then
4225         AC_MSG_WARN(cannot make symlinks, will use .so files)
4226         MANPAGE_SYMLINKS=no
4227 fi
4228 fi
4229
4230 AC_MSG_RESULT($MANPAGE_SYMLINKS)
4231 fi
4232
4233 ])dnl
4234 dnl ---------------------------------------------------------------------------
4235 dnl CF_MANPAGE_TBL version: 3 updated: 2002/01/19 22:51:32
4236 dnl --------------
4237 dnl This option causes manpages to be run through tbl(1) to generate tables
4238 dnl correctly.
4239 AC_DEFUN([CF_MANPAGE_TBL],
4240 [
4241 AC_MSG_CHECKING(for manpage tbl)
4242
4243 AC_ARG_WITH(manpage-tbl,
4244         [  --with-manpage-tbl      specify manpage processing with tbl],
4245         [MANPAGE_TBL=$withval],
4246         [MANPAGE_TBL=no])
4247
4248 AC_MSG_RESULT($MANPAGE_TBL)
4249 ])dnl
4250 dnl ---------------------------------------------------------------------------
4251 dnl CF_MAN_PAGES version: 43 updated: 2013/02/09 12:53:45
4252 dnl ------------
4253 dnl Try to determine if the man-pages on the system are compressed, and if
4254 dnl so, what format is used.  Use this information to construct a script that
4255 dnl will install man-pages.
4256 AC_DEFUN([CF_MAN_PAGES],
4257 [
4258 CF_HELP_MESSAGE(Options to Specify How Manpages are Installed:)
4259 CF_MANPAGE_FORMAT
4260 CF_MANPAGE_RENAMES
4261 CF_MANPAGE_SYMLINKS
4262 CF_MANPAGE_TBL
4263
4264   if test "$prefix" = "NONE" ; then
4265      cf_prefix="$ac_default_prefix"
4266   else
4267      cf_prefix="$prefix"
4268   fi
4269
4270   case "$MANPAGE_FORMAT" in # (vi
4271   *catonly*) # (vi
4272     cf_format=yes
4273     cf_inboth=no
4274     ;;
4275   *formatted*) # (vi
4276     cf_format=yes
4277     cf_inboth=yes
4278     ;;
4279   *)
4280     cf_format=no
4281     cf_inboth=no
4282     ;;
4283   esac
4284
4285 test ! -d man && mkdir man
4286
4287 cf_so_strip=
4288 cf_compress=
4289 case "$MANPAGE_FORMAT" in #(vi
4290 *compress*) #(vi
4291         cf_so_strip="Z"
4292         cf_compress=compress
4293   ;;
4294 *gzip*)
4295         cf_so_strip="gz"
4296         cf_compress=gzip
4297   ;;
4298 esac
4299
4300 cf_edit_man=./edit_man.sh
4301 cf_man_alias=`pwd`/man_alias.sed
4302
4303 cat >$cf_edit_man <<CF_EOF
4304 #! /bin/sh
4305 # this script is generated by the configure-script CF_MAN_PAGES macro.
4306
4307 prefix="$cf_prefix"
4308 datarootdir="$datarootdir"
4309 datadir="$datadir"
4310
4311 NCURSES_MAJOR="$NCURSES_MAJOR"
4312 NCURSES_MINOR="$NCURSES_MINOR"
4313 NCURSES_PATCH="$NCURSES_PATCH"
4314
4315 NCURSES_OSPEED="$NCURSES_OSPEED"
4316 TERMINFO="$TERMINFO"
4317
4318 INSTALL="$INSTALL"
4319 INSTALL_DATA="$INSTALL_DATA"
4320
4321 transform="$program_transform_name"
4322
4323 TMP=\${TMPDIR:=/tmp}/man\$\$
4324 trap "rm -f \$TMP" 0 1 2 5 15
4325
4326 form=\[$]1
4327 shift || exit 1
4328
4329 verb=\[$]1
4330 shift || exit 1
4331
4332 mandir=\[$]1
4333 shift || exit 1
4334
4335 srcdir=\[$]1
4336 top_srcdir=\[$]srcdir/..
4337 shift || exit 1
4338
4339 if test "\$form" = normal ; then
4340         if test "$cf_format" = yes ; then
4341         if test "$cf_inboth" = no ; then
4342                 sh \[$]0 format \$verb \$mandir \$srcdir \[$]*
4343                 exit $?
4344         fi
4345         fi
4346         cf_subdir=\$mandir/man
4347         cf_tables=$MANPAGE_TBL
4348 else
4349         cf_subdir=\$mandir/cat
4350         cf_tables=yes
4351 fi
4352
4353 # process the list of source-files
4354 for i in \[$]* ; do
4355 case \$i in #(vi
4356 *.orig|*.rej) ;; #(vi
4357 *.[[0-9]]*)
4358         section=\`expr "\$i" : '.*\\.\\([[0-9]]\\)[[xm]]*'\`;
4359         if test \$verb = installing ; then
4360         if test ! -d \$cf_subdir\${section} ; then
4361                 mkdir -p \$cf_subdir\$section
4362         fi
4363         fi
4364
4365         # replace variables in man page
4366         if test ! -f $cf_man_alias ; then
4367 cat >>$cf_man_alias <<-CF_EOF2
4368                 s,@DATADIR@,\$datadir,g
4369                 s,@TERMINFO@,\${TERMINFO:="no default value"},g
4370                 s,@TERMINFO_DIRS@,\${TERMINFO_DIRS:="no default value"},g
4371                 s,@NCURSES_MAJOR@,\${NCURSES_MAJOR:="no default value"},g
4372                 s,@NCURSES_MINOR@,\${NCURSES_MINOR:="no default value"},g
4373                 s,@NCURSES_PATCH@,\${NCURSES_PATCH:="no default value"},g
4374                 s,@NCURSES_OSPEED@,\${NCURSES_OSPEED:="no default value"},g
4375 CF_EOF
4376         ifelse($1,,,[
4377         for cf_name in $1
4378         do
4379                 cf_NAME=`echo "$cf_name" | sed y%abcdefghijklmnopqrstuvwxyz./-%ABCDEFGHIJKLMNOPQRSTUVWXYZ___%`
4380                 cf_name=`echo $cf_name|sed "$program_transform_name"`
4381 cat >>$cf_edit_man <<-CF_EOF
4382                 s,@$cf_NAME@,$cf_name,g
4383 CF_EOF
4384         done
4385         ])
4386 cat >>$cf_edit_man <<CF_EOF
4387 CF_EOF2
4388                 echo "...made $cf_man_alias"
4389         fi
4390
4391         aliases=
4392         cf_source=\`basename \$i\`
4393         inalias=\$cf_source
4394         test ! -f \$inalias && inalias="\$srcdir/\$inalias"
4395         if test ! -f \$inalias ; then
4396                 echo .. skipped \$cf_source
4397                 continue
4398         fi
4399 CF_EOF
4400
4401 if test "$MANPAGE_ALIASES" != no ; then
4402 cat >>$cf_edit_man <<CF_EOF
4403         nCurses=ignore.3x
4404         test $with_curses_h = yes && nCurses=ncurses.3x
4405         aliases=\`sed -f \$top_srcdir/man/manlinks.sed \$inalias |sed -f $cf_man_alias | sort -u; test \$inalias = \$nCurses && echo curses\`
4406 CF_EOF
4407 fi
4408
4409 if test "$MANPAGE_RENAMES" = no ; then
4410 cat >>$cf_edit_man <<CF_EOF
4411         # perform program transformations for section 1 man pages
4412         if test \$section = 1 ; then
4413                 cf_target=\$cf_subdir\${section}/\`echo \$cf_source|sed "\${transform}"\`
4414         else
4415                 cf_target=\$cf_subdir\${section}/\$cf_source
4416         fi
4417 CF_EOF
4418 else
4419 cat >>$cf_edit_man <<CF_EOF
4420         cf_target=\`grep "^\$cf_source" $MANPAGE_RENAMES | $AWK '{print \[$]2}'\`
4421         if test -z "\$cf_target" ; then
4422                 echo '? missing rename for '\$cf_source
4423                 cf_target="\$cf_source"
4424         fi
4425         cf_target="\$cf_subdir\${section}/\${cf_target}"
4426
4427 CF_EOF
4428 fi
4429
4430 cat >>$cf_edit_man <<CF_EOF
4431         sed     -f $cf_man_alias \\
4432 CF_EOF
4433
4434 if test -f $MANPAGE_RENAMES ; then
4435 cat >>$cf_edit_man <<CF_EOF
4436                 < \$i | sed -f `pwd`/edit_man.sed >\$TMP
4437 CF_EOF