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