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