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