comparison configure @ 2367:ecf1ebac70d8

[xemacs-hg @ 2004-11-04 23:05:23 by ben] commit mega-patch configure.in: Turn off -Winline and -Wchar-subscripts. Use the right set of cflags when compiling modules. Rewrite ldap configuration to separate the inclusion of lber (needed in recent Cygwin) from the basic checks for the needed libraries. add a function for MAKE_JUNK_C; initially code was added to generate xemacs.def using this, but it will need to be rewritten. add an rm -f for junk.c to avoid weird Cygwin bug with cp -f onto an existing file. Sort list of auto-detected functions and eliminate unused checks for stpcpy, setlocale and getwd. Add autodetection of Cygwin scanf problems BETA: Rewrite section on configure to indicate what flags are important and what not. digest-doc.c, make-dump-id.c, profile.c, sorted-doc.c: Add proper decls for main(). make-msgfile.c: Document that this is old junk. Move proposal to text.c. make-msgfile.lex: Move proposal to text.c. make-mswin-unicode.pl: Convert error-generating code so that the entire message will be seen as a single unrecognized token. mule/mule-ccl.el: Update docs. lispref/mule.texi: Update CCL docs. ldap/eldap.c: Mule-ize. Use EXTERNAL_LIST_LOOP_2 instead of deleted EXTERNAL_LIST_LOOP. * XEmacs 21.5.18 "chestnut" is released. --------------------------------------------------------------- MULE-RELATED WORK: --------------------------------------------------------------- --------------------------- byte-char conversion --------------------------- buffer.c, buffer.h, insdel.c, text.c: Port FSF algorithm for byte-char conversion, replacing broken previous version. Track the char position of the gap. Add functions to do char-byte conversion downwards as well as upwards. Move comments about algorithm workings to internals manual. --------------------------- work on types --------------------------- alloc.c, console-x-impl.h, dump-data.c, dump-data.h, dumper.c, dialog-msw.c, dired-msw.c, doc.c, editfns.c, esd.c, event-gtk.h, event-msw.c, events.c, file-coding.c, file-coding.h, fns.c, glyphs-eimage.c, glyphs-gtk.c, glyphs-msw.c, glyphs-shared.c, glyphs-x.c, glyphs.c, glyphs.h, gui.c, hpplay.c, imgproc.c, intl-win32.c, lrecord.h, lstream.c, keymap.c, lisp.h, libsst.c, linuxplay.c, miscplay.c, miscplay.h, mule-coding.c, nas.c, nt.c, ntheap.c, ntplay.c, objects-msw.c, objects-tty.c, objects-x.c, print.c, process-nt.c, process.c, redisplay.h, select-common.h, select-gtk.c, select-x.c, sgiplay.c, sound.c, sound.h, sunplay.c, sysfile.h, sysdep.c, syswindows.h, text.c, unexnt.c, win32.c, xgccache.c: Further work on types. This creates a full set of types for all the basic semantics of `char' that I have so far identified, so that its semantics can always be identified for the purposes of proper Mule-safe code, and the raw use of `char' always avoided. (1) More type renaming, for consistency of naming. Char_ASCII -> Ascbyte UChar_ASCII -> UAscbyte Char_Binary -> CBinbyte UChar_Binary -> Binbyte SChar_Binary -> SBinbyte (2) Introduce Rawbyte, CRawbyte, Boolbyte, Chbyte, UChbyte, and Bitbyte and use them. (3) New types Itext, Wexttext and Textcount for separating out the concepts of bytes and textual units (different under UTF-16 and UTF-32, which are potential internal encodings). (4) qxestr*_c -> qxestr*_ascii. lisp.h: New; goes with other qxe() functions. #### Maybe goes in a different section. lisp.h: Group generic int-type defs together with EMACS_INT defs. lisp.h: * lisp.h (WEXTTEXT_IS_WIDE) New defns. lisp.h: New type to replace places where int occurs as a boolean. It's signed because occasionally people may want to use -1 as an error value, and because unsigned ints are viral -- see comments in the internals manual against using them. dynarr.c: int -> Bytecount. --------------------------- Mule-izing --------------------------- device-x.c: Partially Mule-ize. dumper.c, dumper.h: Mule-ize. Use Rawbyte. Use stderr_out not printf. Use wext_*(). sysdep.c, syswindows.h, text.c: New Wexttext API for manipulation of external text that may be Unicode (e.g. startup code under Windows). emacs.c: Mule-ize. Properly deal with argv in external encoding. Use wext_*() and Wexttext. Use Rawbyte. #if 0 some old junk on SCO that is unlikely to be correct. Rewrite allocation code in run-temacs. emacs.c, symsinit.h, win32.c: Rename win32 init function and call it even earlier, to initialize mswindows_9x_p even earlier, for use in startup code (XEUNICODE_P). process.c: Use _wenviron not environ under Windows, to get Unicode environment variables. event-Xt.c: Mule-ize drag-n-drop related stuff. dragdrop.c, dragdrop.h, frame-x.c: Mule-ize. text.h: Add some more stand-in defines for particular kinds of conversion; use in Mule-ization work in frame-x.c etc. --------------------------- Freshening --------------------------- intl-auto-encap-win32.c, intl-auto-encap-win32.h: Regenerate. --------------------------- Unicode-work --------------------------- intl-win32.c, syswindows.h: Factor out common options to MultiByteToWideChar and WideCharToMultiByte. Add convert_unicode_to_multibyte_malloc() and convert_unicode_to_multibyte_dynarr() and use. Add stuff for alloca() conversion of multibyte/unicode. alloc.c: Use dfc_external_data_len() in case of unicode coding system. alloc.c, mule-charset.c: Don't zero out and reinit charset Unicode tables. This fucks up dump-time loading. Anyway, either we load them at dump time or run time, never both. unicode.c: Dump the blank tables as well. --------------------------------------------------------------- DOCUMENTATION, MOSTLY MULE-RELATED: --------------------------------------------------------------- EmacsFrame.c, emodules.c, event-Xt.c, fileio.c, input-method-xlib.c, mule-wnnfns.c, redisplay-gtk.c, redisplay-tty.c, redisplay-x.c, regex.c, sysdep.c: Add comment about Mule work needed. text.h: Add more documentation describing why DFC routines were not written to return their value. Add some other DFC documentation. console-msw.c, console-msw.h: Add pointer to docs in win32.c. emacs.c: Add comments on sources of doc info. text.c, charset.h, unicode.c, intl-win32.c, intl-encap-win32.c, text.h, file-coding.c, mule-coding.c: Collect background comments and related to text matters and internationalization, and proposals for work to be done, in text.c or Internals manual, stuff related to specific textual API's in text.h, and stuff related to internal implementation of Unicode conversion in unicode.c. Put lots of pointers to the comments to make them easier to find. s/mingw32.h, s/win32-common.h, s/win32-native.h, s/windowsnt.h, win32.c: Add bunches of new documentation on the different kinds of builds and environments under Windows and how they work. Collect this info in win32.c. Add pointers to these docs in the relevant s/* files. emacs.c: Document places with long comments. Remove comment about exiting, move to internals manual, put in pointer. event-stream.c: Move docs about event queues and focus to internals manual, put in pointer. events.h: Move docs about event stream callbacks to internals manual, put in pointer. profile.c, redisplay.c, signal.c: Move documentation to the Internals manual. process-nt.c: Add pointer to comment in win32-native.el. lisp.h: Add comments about some comment conventions. lisp.h: Add comment about the second argument. device-msw.c, redisplay-msw.c: @@#### comments are out-of-date. --------------------------------------------------------------- PDUMP WORK (MOTIVATED BY UNICODE CHANGES) --------------------------------------------------------------- alloc.c, buffer.c, bytecode.c, console-impl.h, console.c, device.c, dumper.c, lrecord.h, elhash.c, emodules.h, events.c, extents.c, frame.c, glyphs.c, glyphs.h, mule-charset.c, mule-coding.c, objects.c, profile.c, rangetab.c, redisplay.c, specifier.c, specifier.h, window.c, lstream.c, file-coding.h, file-coding.c: PDUMP: Properly implement dump_add_root_block(), which never worked before, and is necessary for dumping Unicode tables. Pdump name changes for accuracy: XD_STRUCT_PTR -> XD_BLOCK_PTR. XD_STRUCT_ARRAY -> XD_BLOCK_ARRAY. XD_C_STRING -> XD_ASCII_STRING. *_structure_* -> *_block_*. lrecord.h: some comments added about dump_add_root_block() vs dump_add_root_block_ptr(). extents.c: remove incorrect comment about pdump problems with gap array. --------------------------------------------------------------- ALLOCATION --------------------------------------------------------------- abbrev.c, alloc.c, bytecode.c, casefiddle.c, device-msw.c, device-x.c, dired-msw.c, doc.c, doprnt.c, dragdrop.c, editfns.c, emodules.c, file-coding.c, fileio.c, filelock.c, fns.c, glyphs-eimage.c, glyphs-gtk.c, glyphs-msw.c, glyphs-x.c, gui-msw.c, gui-x.c, imgproc.c, intl-win32.c, lread.c, menubar-gtk.c, menubar.c, nt.c, objects-msw.c, objects-x.c, print.c, process-nt.c, process-unix.c, process.c, realpath.c, redisplay.c, search.c, select-common.c, symbols.c, sysdep.c, syswindows.h, text.c, text.h, ui-byhand.c: New macros {alloca,xnew}_{itext,{i,ext,raw,bin,asc}bytes} for more convenient allocation of these commonly requested items. Modify functions to use alloca_ibytes, alloca_array, alloca_extbytes, xnew_ibytes, etc. also XREALLOC_ARRAY, xnew. alloc.c: Rewrite the allocation functions to factor out repeated code. Add assertions for freeing dumped data. lisp.h: Moved down and consolidated with other allocation stuff. lisp.h, dynarr.c: New functions for allocation that's very efficient when mostly in LIFO order. lisp.h, text.c, text.h: Factor out some stuff for general use by alloca()-conversion funs. text.h, lisp.h: Fill out convenience routines for allocating various kinds of bytes and put them in lisp.h. Use them in place of xmalloc(), ALLOCA(). text.h: Fill out the convenience functions so the _MALLOC() kinds match the alloca() kinds. --------------------------------------------------------------- ERROR-CHECKING --------------------------------------------------------------- text.h: Create ASSERT_ASCTEXT_ASCII() and ASSERT_ASCTEXT_ASCII_LEN() from similar Eistring checkers and change the Eistring checkers to use them instead. --------------------------------------------------------------- MACROS IN LISP.H --------------------------------------------------------------- lisp.h: Redo GCPRO declarations. Create a "base" set of functions that can be used to generate any kind of gcpro sets -- regular, ngcpro, nngcpro, private ones used in GC_EXTERNAL_LIST_LOOP_2. buffer.c, callint.c, chartab.c, console-msw.c, device-x.c, dialog-msw.c, dired.c, extents.c, ui-gtk.c, rangetab.c, nt.c, mule-coding.c, minibuf.c, menubar-msw.c, menubar.c, menubar-gtk.c, lread.c, lisp.h, gutter.c, glyphs.c, glyphs-widget.c, fns.c, fileio.c, file-coding.c, specifier.c: Eliminate EXTERNAL_LIST_LOOP, which does not check for circularities. Use EXTERNAL_LIST_LOOP_2 instead or EXTERNAL_LIST_LOOP_3 or EXTERNAL_PROPERTY_LIST_LOOP_3 or GC_EXTERNAL_LIST_LOOP_2 (new macro). Removed/redid comments on EXTERNAL_LIST_LOOP. --------------------------------------------------------------- SPACING FIXES --------------------------------------------------------------- callint.c, hftctl.c, number-gmp.c, process-unix.c: Spacing fixes. --------------------------------------------------------------- FIX FOR GEOMETRY PROBLEM IN FIRST FRAME --------------------------------------------------------------- unicode.c: Add workaround for newlib bug in sscanf() [should be fixed by release 1.5.12 of Cygwin]. toolbar.c: bug fix for problem of initial frame being 77 chars wide on Windows. will be overridden by my other ws. --------------------------------------------------------------- FIX FOR LEAKING PROCESS HANDLES: --------------------------------------------------------------- process-nt.c: Fixes for leaking handles. Inspired by work done by Adrian Aichner <adrian@xemacs.org>. --------------------------------------------------------------- FIX FOR CYGWIN BUG (Unicode-related): --------------------------------------------------------------- unicode.c: Add workaround for newlib bug in sscanf() [should be fixed by release 1.5.12 of Cygwin]. --------------------------------------------------------------- WARNING FIXES: --------------------------------------------------------------- console-stream.c: `reinit' is unused. compiler.h, event-msw.c, frame-msw.c, intl-encap-win32.c, text.h: Add stuff to deal with ANSI-aliasing warnings I got. regex.c: Gather includes together to avoid warning. --------------------------------------------------------------- CHANGES TO INITIALIZATION ROUTINES: --------------------------------------------------------------- buffer.c, emacs.c, console.c, debug.c, device-x.c, device.c, dragdrop.c, emodules.c, eval.c, event-Xt.c, event-gtk.c, event-msw.c, event-stream.c, event-tty.c, events.c, extents.c, faces.c, file-coding.c, fileio.c, font-lock.c, frame-msw.c, glyphs-widget.c, glyphs.c, gui-x.c, insdel.c, lread.c, lstream.c, menubar-gtk.c, menubar-x.c, minibuf.c, mule-wnnfns.c, objects-msw.c, objects.c, print.c, scrollbar-x.c, search.c, select-x.c, text.c, undo.c, unicode.c, window.c, symsinit.h: Call reinit_*() functions directly from emacs.c, for clarity. Factor out some redundant init code. Move disallowed stuff that had crept into vars_of_glyphs() into complex_vars_of_glyphs(). Call init_eval_semi_early() from eval.c not in the middle of vars_of_() in emacs.c since there should be no order dependency in the latter calls. --------------------------------------------------------------- ARMAGEDDON: --------------------------------------------------------------- alloc.c, emacs.c, lisp.h, print.c: Rename inhibit_non_essential_printing_operations to inhibit_non_essential_conversion_operations. text.c: Assert on !inhibit_non_essential_conversion_operations. console-msw.c, print.c: Don't do conversion in SetConsoleTitle or FindWindow to avoid problems during armageddon. Put #errors for NON_ASCII_INTERNAL_FORMAT in places where problems would arise. --------------------------------------------------------------- CHANGES TO THE BUILD PROCEDURE: --------------------------------------------------------------- config.h.in, s/cxux.h, s/usg5-4-2.h, m/powerpc.h: Add comment about correct ordering of this file. Rearrange everything to follow this -- put all #undefs together and before the s&m files. Add undefs for HAVE_ALLOCA, C_ALLOCA, BROKEN_ALLOCA_IN_FUNCTION_CALLS, STACK_DIRECTION. Remove unused HAVE_STPCPY, HAVE_GETWD, HAVE_SETLOCALE. m/gec63.h: Deleted; totally broken, not used at all, not in FSF. m/7300.h, m/acorn.h, m/alliant-2800.h, m/alliant.h, m/altos.h, m/amdahl.h, m/apollo.h, m/att3b.h, m/aviion.h, m/celerity.h, m/clipper.h, m/cnvrgnt.h, m/convex.h, m/cydra5.h, m/delta.h, m/delta88k.h, m/dpx2.h, m/elxsi.h, m/ews4800r.h, m/gould.h, m/hp300bsd.h, m/hp800.h, m/hp9000s300.h, m/i860.h, m/ibmps2-aix.h, m/ibmrs6000.h, m/ibmrt-aix.h, m/ibmrt.h, m/intel386.h, m/iris4d.h, m/iris5d.h, m/iris6d.h, m/irist.h, m/isi-ov.h, m/luna88k.h, m/m68k.h, m/masscomp.h, m/mg1.h, m/mips-nec.h, m/mips-siemens.h, m/mips.h, m/news.h, m/nh3000.h, m/nh4000.h, m/ns32000.h, m/orion105.h, m/pfa50.h, m/plexus.h, m/pmax.h, m/powerpc.h, m/pyrmips.h, m/sequent-ptx.h, m/sequent.h, m/sgi-challenge.h, m/symmetry.h, m/tad68k.h, m/tahoe.h, m/targon31.h, m/tekxd88.h, m/template.h, m/tower32.h, m/tower32v3.h, m/ustation.h, m/vax.h, m/wicat.h, m/xps100.h: Delete C_ALLOCA, HAVE_ALLOCA, STACK_DIRECTION, BROKEN_ALLOCA_IN_FUNCTION_CALLS. All of this is auto-detected. When in doubt, I followed recent FSF sources, which also have these things deleted.
author ben
date Thu, 04 Nov 2004 23:08:28 +0000
parents 162083ea139d
children df0455455d17
comparison
equal deleted inserted replaced
2366:2a392e0c390a 2367:ecf1ebac70d8
4 #### Guess values for system-dependent variables and create Makefiles. 4 #### Guess values for system-dependent variables and create Makefiles.
5 #### Generated automatically using autoconf version 2.13 5 #### Generated automatically using autoconf version 2.13
6 #### Copyright (C) 1992, 1993, 1994, 1995, 1996, 1997, 1998, 1999, 2000 Free Software Foundation, Inc. 6 #### Copyright (C) 1992, 1993, 1994, 1995, 1996, 1997, 1998, 1999, 2000 Free Software Foundation, Inc.
7 #### Copyright (C) 1993-1995 Board of Trustees, University of Illinois. 7 #### Copyright (C) 1993-1995 Board of Trustees, University of Illinois.
8 #### Copyright (C) 1996, 1997 Sun Microsystems, Inc. 8 #### Copyright (C) 1996, 1997 Sun Microsystems, Inc.
9 #### Copyright (C) 1995, 1996, 2002, 2003 Ben Wing. 9 #### Copyright (C) 1995, 1996, 2002, 2003, 2004 Ben Wing.
10 #### Copyright (C) 2000, 2001 Martin Buchholz. 10 #### Copyright (C) 2000, 2001 Martin Buchholz.
11 #### Copyright (C) 1998, 1999 J. Kean Johnston. 11 #### Copyright (C) 1998, 1999 J. Kean Johnston.
12 12
13 ### Don't edit this script! 13 ### Don't edit this script!
14 ### This script was automatically generated by the `autoconf' program 14 ### This script was automatically generated by the `autoconf' program
2925 sol2 ) cflags_warning="-v" ;; 2925 sol2 ) cflags_warning="-v" ;;
2926 esac 2926 esac
2927 elif test "$CC" = "xlc"; then 2927 elif test "$CC" = "xlc"; then
2928 cflags_warning="-qinfo" 2928 cflags_warning="-qinfo"
2929 elif test "$GCC" = "yes"; then 2929 elif test "$GCC" = "yes"; then
2930 cflags_warning="-Wall -Wno-switch -Winline -Wmissing-prototypes" 2930 cflags_warning="-Wall -Wno-switch -Wmissing-prototypes"
2931 2931
2932 cflags_warning="$cflags_warning -Wsign-compare" 2932 cflags_warning="$cflags_warning -Wsign-compare -Wno-char-subscripts"
2933 cflags_warning="$cflags_warning -Wundef -Wstrict-prototypes" 2933 cflags_warning="$cflags_warning -Wundef -Wstrict-prototypes"
2934 test "$__GCC3" = "yes" && cflags_warning="$cflags_warning -Wpacked" 2934 test "$__GCC3" = "yes" && cflags_warning="$cflags_warning -Wpacked"
2935 test "$have_glibc" != "yes" && \ 2935 test "$have_glibc" != "yes" && \
2936 cflags_warning="$cflags_warning -Wpointer-arith" 2936 cflags_warning="$cflags_warning -Wpointer-arith"
2937 if test "$xemacs_compiler" = "g++"; then 2937 if test "$xemacs_compiler" = "g++"; then
4779 4779
4780 cat > conftest.$ac_ext <<EOF 4780 cat > conftest.$ac_ext <<EOF
4781 #line 4782 "configure" 4781 #line 4782 "configure"
4782 #include "confdefs.h" 4782 #include "confdefs.h"
4783 #include <stdio.h> 4783 #include <stdio.h>
4784 #include <sys/types.h>
4785 main() 4784 main()
4786 { 4785 {
4787 FILE *f=fopen("conftestval", "w"); 4786 FILE *f=fopen("conftestval", "w");
4788 if (!f) exit(1); 4787 if (!f) exit(1);
4789 fprintf(f, "%d\n", sizeof(short)); 4788 fprintf(f, "%d\n", sizeof(short));
4790 exit(0); 4789 exit(0);
4791 } 4790 }
4792 EOF 4791 EOF
4793 if { (eval echo configure:4794: \"$ac_link\") 1>&5; (eval $ac_link) 2>&5; } && test -s conftest && (./conftest; exit $?) 2>&5 4792 if { (eval echo configure:4793: \"$ac_link\") 1>&5; (eval $ac_link) 2>&5; } && test -s conftest && (./conftest; exit $?) 2>&5
4794 then 4793 then
4795 ac_cv_sizeof_short=`cat conftestval` 4794 ac_cv_sizeof_short=`cat conftestval`
4796 else 4795 else
4797 conftest_rc="$?" 4796 conftest_rc="$?"
4798 echo "configure: failed program was:" >&5 4797 echo "configure: failed program was:" >&5
4816 echo "*** PANIC *** Configure tests are not working - compiler is broken." 4815 echo "*** PANIC *** Configure tests are not working - compiler is broken."
4817 echo "*** PANIC *** Please examine config.log for compilation errors." 4816 echo "*** PANIC *** Please examine config.log for compilation errors."
4818 exit 1 4817 exit 1
4819 fi 4818 fi
4820 echo $ac_n "checking size of int""... $ac_c" 1>&6 4819 echo $ac_n "checking size of int""... $ac_c" 1>&6
4821 echo "configure:4822: checking size of int" >&5 4820 echo "configure:4821: checking size of int" >&5
4822 4821
4823 cat > conftest.$ac_ext <<EOF 4822 cat > conftest.$ac_ext <<EOF
4824 #line 4825 "configure" 4823 #line 4824 "configure"
4825 #include "confdefs.h" 4824 #include "confdefs.h"
4826 #include <stdio.h> 4825 #include <stdio.h>
4827 #include <sys/types.h>
4828 main() 4826 main()
4829 { 4827 {
4830 FILE *f=fopen("conftestval", "w"); 4828 FILE *f=fopen("conftestval", "w");
4831 if (!f) exit(1); 4829 if (!f) exit(1);
4832 fprintf(f, "%d\n", sizeof(int)); 4830 fprintf(f, "%d\n", sizeof(int));
4833 exit(0); 4831 exit(0);
4834 } 4832 }
4835 EOF 4833 EOF
4836 if { (eval echo configure:4837: \"$ac_link\") 1>&5; (eval $ac_link) 2>&5; } && test -s conftest && (./conftest; exit $?) 2>&5 4834 if { (eval echo configure:4835: \"$ac_link\") 1>&5; (eval $ac_link) 2>&5; } && test -s conftest && (./conftest; exit $?) 2>&5
4837 then 4835 then
4838 ac_cv_sizeof_int=`cat conftestval` 4836 ac_cv_sizeof_int=`cat conftestval`
4839 else 4837 else
4840 conftest_rc="$?" 4838 conftest_rc="$?"
4841 echo "configure: failed program was:" >&5 4839 echo "configure: failed program was:" >&5
4853 EOF 4851 EOF
4854 } 4852 }
4855 4853
4856 4854
4857 echo $ac_n "checking size of long""... $ac_c" 1>&6 4855 echo $ac_n "checking size of long""... $ac_c" 1>&6
4858 echo "configure:4859: checking size of long" >&5 4856 echo "configure:4857: checking size of long" >&5
4859 4857
4860 cat > conftest.$ac_ext <<EOF 4858 cat > conftest.$ac_ext <<EOF
4861 #line 4862 "configure" 4859 #line 4860 "configure"
4862 #include "confdefs.h" 4860 #include "confdefs.h"
4863 #include <stdio.h> 4861 #include <stdio.h>
4864 #include <sys/types.h>
4865 main() 4862 main()
4866 { 4863 {
4867 FILE *f=fopen("conftestval", "w"); 4864 FILE *f=fopen("conftestval", "w");
4868 if (!f) exit(1); 4865 if (!f) exit(1);
4869 fprintf(f, "%d\n", sizeof(long)); 4866 fprintf(f, "%d\n", sizeof(long));
4870 exit(0); 4867 exit(0);
4871 } 4868 }
4872 EOF 4869 EOF
4873 if { (eval echo configure:4874: \"$ac_link\") 1>&5; (eval $ac_link) 2>&5; } && test -s conftest && (./conftest; exit $?) 2>&5 4870 if { (eval echo configure:4871: \"$ac_link\") 1>&5; (eval $ac_link) 2>&5; } && test -s conftest && (./conftest; exit $?) 2>&5
4874 then 4871 then
4875 ac_cv_sizeof_long=`cat conftestval` 4872 ac_cv_sizeof_long=`cat conftestval`
4876 else 4873 else
4877 conftest_rc="$?" 4874 conftest_rc="$?"
4878 echo "configure: failed program was:" >&5 4875 echo "configure: failed program was:" >&5
4890 EOF 4887 EOF
4891 } 4888 }
4892 4889
4893 4890
4894 echo $ac_n "checking size of long long""... $ac_c" 1>&6 4891 echo $ac_n "checking size of long long""... $ac_c" 1>&6
4895 echo "configure:4896: checking size of long long" >&5 4892 echo "configure:4893: checking size of long long" >&5
4896 4893
4897 cat > conftest.$ac_ext <<EOF 4894 cat > conftest.$ac_ext <<EOF
4898 #line 4899 "configure" 4895 #line 4896 "configure"
4899 #include "confdefs.h" 4896 #include "confdefs.h"
4900 #include <stdio.h> 4897 #include <stdio.h>
4901 #include <sys/types.h>
4902 main() 4898 main()
4903 { 4899 {
4904 FILE *f=fopen("conftestval", "w"); 4900 FILE *f=fopen("conftestval", "w");
4905 if (!f) exit(1); 4901 if (!f) exit(1);
4906 fprintf(f, "%d\n", sizeof(long long)); 4902 fprintf(f, "%d\n", sizeof(long long));
4907 exit(0); 4903 exit(0);
4908 } 4904 }
4909 EOF 4905 EOF
4910 if { (eval echo configure:4911: \"$ac_link\") 1>&5; (eval $ac_link) 2>&5; } && test -s conftest && (./conftest; exit $?) 2>&5 4906 if { (eval echo configure:4907: \"$ac_link\") 1>&5; (eval $ac_link) 2>&5; } && test -s conftest && (./conftest; exit $?) 2>&5
4911 then 4907 then
4912 ac_cv_sizeof_long_long=`cat conftestval` 4908 ac_cv_sizeof_long_long=`cat conftestval`
4913 else 4909 else
4914 conftest_rc="$?" 4910 conftest_rc="$?"
4915 echo "configure: failed program was:" >&5 4911 echo "configure: failed program was:" >&5
4927 EOF 4923 EOF
4928 } 4924 }
4929 4925
4930 4926
4931 echo $ac_n "checking size of void *""... $ac_c" 1>&6 4927 echo $ac_n "checking size of void *""... $ac_c" 1>&6
4932 echo "configure:4933: checking size of void *" >&5 4928 echo "configure:4929: checking size of void *" >&5
4933 4929
4934 cat > conftest.$ac_ext <<EOF 4930 cat > conftest.$ac_ext <<EOF
4935 #line 4936 "configure" 4931 #line 4932 "configure"
4936 #include "confdefs.h" 4932 #include "confdefs.h"
4937 #include <stdio.h> 4933 #include <stdio.h>
4938 #include <sys/types.h>
4939 main() 4934 main()
4940 { 4935 {
4941 FILE *f=fopen("conftestval", "w"); 4936 FILE *f=fopen("conftestval", "w");
4942 if (!f) exit(1); 4937 if (!f) exit(1);
4943 fprintf(f, "%d\n", sizeof(void *)); 4938 fprintf(f, "%d\n", sizeof(void *));
4944 exit(0); 4939 exit(0);
4945 } 4940 }
4946 EOF 4941 EOF
4947 if { (eval echo configure:4948: \"$ac_link\") 1>&5; (eval $ac_link) 2>&5; } && test -s conftest && (./conftest; exit $?) 2>&5 4942 if { (eval echo configure:4943: \"$ac_link\") 1>&5; (eval $ac_link) 2>&5; } && test -s conftest && (./conftest; exit $?) 2>&5
4948 then 4943 then
4949 ac_cv_sizeof_void_p=`cat conftestval` 4944 ac_cv_sizeof_void_p=`cat conftestval`
4950 else 4945 else
4951 conftest_rc="$?" 4946 conftest_rc="$?"
4952 echo "configure: failed program was:" >&5 4947 echo "configure: failed program was:" >&5
4964 EOF 4959 EOF
4965 } 4960 }
4966 4961
4967 4962
4968 echo $ac_n "checking size of double""... $ac_c" 1>&6 4963 echo $ac_n "checking size of double""... $ac_c" 1>&6
4969 echo "configure:4970: checking size of double" >&5 4964 echo "configure:4965: checking size of double" >&5
4970 4965
4971 cat > conftest.$ac_ext <<EOF 4966 cat > conftest.$ac_ext <<EOF
4972 #line 4973 "configure" 4967 #line 4968 "configure"
4973 #include "confdefs.h" 4968 #include "confdefs.h"
4974 #include <stdio.h> 4969 #include <stdio.h>
4975 #include <sys/types.h>
4976 main() 4970 main()
4977 { 4971 {
4978 FILE *f=fopen("conftestval", "w"); 4972 FILE *f=fopen("conftestval", "w");
4979 if (!f) exit(1); 4973 if (!f) exit(1);
4980 fprintf(f, "%d\n", sizeof(double)); 4974 fprintf(f, "%d\n", sizeof(double));
4981 exit(0); 4975 exit(0);
4982 } 4976 }
4983 EOF 4977 EOF
4984 if { (eval echo configure:4985: \"$ac_link\") 1>&5; (eval $ac_link) 2>&5; } && test -s conftest && (./conftest; exit $?) 2>&5 4978 if { (eval echo configure:4979: \"$ac_link\") 1>&5; (eval $ac_link) 2>&5; } && test -s conftest && (./conftest; exit $?) 2>&5
4985 then 4979 then
4986 ac_cv_sizeof_double=`cat conftestval` 4980 ac_cv_sizeof_double=`cat conftestval`
4987 else 4981 else
4988 conftest_rc="$?" 4982 conftest_rc="$?"
4989 echo "configure: failed program was:" >&5 4983 echo "configure: failed program was:" >&5
5002 } 4996 }
5003 4997
5004 4998
5005 4999
5006 echo $ac_n "checking for long file names""... $ac_c" 1>&6 5000 echo $ac_n "checking for long file names""... $ac_c" 1>&6
5007 echo "configure:5008: checking for long file names" >&5 5001 echo "configure:5002: checking for long file names" >&5
5008 5002
5009 ac_cv_sys_long_file_names=yes 5003 ac_cv_sys_long_file_names=yes
5010 # Test for long file names in all the places we know might matter: 5004 # Test for long file names in all the places we know might matter:
5011 # . the current directory, where building will happen 5005 # . the current directory, where building will happen
5012 # $prefix/lib where we will be installing things 5006 # $prefix/lib where we will be installing things
5048 5042
5049 fi 5043 fi
5050 5044
5051 5045
5052 echo $ac_n "checking for sin""... $ac_c" 1>&6 5046 echo $ac_n "checking for sin""... $ac_c" 1>&6
5053 echo "configure:5054: checking for sin" >&5 5047 echo "configure:5048: checking for sin" >&5
5054 5048
5055 cat > conftest.$ac_ext <<EOF 5049 cat > conftest.$ac_ext <<EOF
5056 #line 5057 "configure" 5050 #line 5051 "configure"
5057 #include "confdefs.h" 5051 #include "confdefs.h"
5058 /* System header to define __stub macros and hopefully few prototypes, 5052 /* System header to define __stub macros and hopefully few prototypes,
5059 which can conflict with char sin(); below. */ 5053 which can conflict with char sin(); below. */
5060 #include <assert.h> 5054 #include <assert.h>
5061 /* Override any gcc2 internal prototype to avoid an error. */ 5055 /* Override any gcc2 internal prototype to avoid an error. */
5074 sin(); 5068 sin();
5075 #endif 5069 #endif
5076 5070
5077 ; return 0; } 5071 ; return 0; }
5078 EOF 5072 EOF
5079 if { (eval echo configure:5080: \"$ac_link\") 1>&5; (eval $ac_link) 2>&5; } && test -s conftest${ac_exeext}; then 5073 if { (eval echo configure:5074: \"$ac_link\") 1>&5; (eval $ac_link) 2>&5; } && test -s conftest${ac_exeext}; then
5080 rm -rf conftest* 5074 rm -rf conftest*
5081 eval "ac_cv_func_sin=yes" 5075 eval "ac_cv_func_sin=yes"
5082 else 5076 else
5083 echo "configure: failed program was:" >&5 5077 echo "configure: failed program was:" >&5
5084 cat conftest.$ac_ext >&5 5078 cat conftest.$ac_ext >&5
5092 : 5086 :
5093 else 5087 else
5094 echo "$ac_t""no" 1>&6 5088 echo "$ac_t""no" 1>&6
5095 5089
5096 echo $ac_n "checking for sin in -lm""... $ac_c" 1>&6 5090 echo $ac_n "checking for sin in -lm""... $ac_c" 1>&6
5097 echo "configure:5098: checking for sin in -lm" >&5 5091 echo "configure:5092: checking for sin in -lm" >&5
5098 ac_lib_var=`echo m'_'sin | sed 'y%./+-%__p_%'` 5092 ac_lib_var=`echo m'_'sin | sed 'y%./+-%__p_%'`
5099 5093
5100 xe_check_libs=" -lm " 5094 xe_check_libs=" -lm "
5101 cat > conftest.$ac_ext <<EOF 5095 cat > conftest.$ac_ext <<EOF
5102 #line 5103 "configure" 5096 #line 5097 "configure"
5103 #include "confdefs.h" 5097 #include "confdefs.h"
5104 /* Override any gcc2 internal prototype to avoid an error. */ 5098 /* Override any gcc2 internal prototype to avoid an error. */
5105 /* We use char because int might match the return type of a gcc2 5099 /* We use char because int might match the return type of a gcc2
5106 builtin and then its argument prototype would still apply. */ 5100 builtin and then its argument prototype would still apply. */
5107 char sin(); 5101 char sin();
5108 5102
5109 int main() { 5103 int main() {
5110 sin() 5104 sin()
5111 ; return 0; } 5105 ; return 0; }
5112 EOF 5106 EOF
5113 if { (eval echo configure:5114: \"$ac_link\") 1>&5; (eval $ac_link) 2>&5; } && test -s conftest${ac_exeext}; then 5107 if { (eval echo configure:5108: \"$ac_link\") 1>&5; (eval $ac_link) 2>&5; } && test -s conftest${ac_exeext}; then
5114 rm -rf conftest* 5108 rm -rf conftest*
5115 eval "ac_cv_lib_$ac_lib_var=yes" 5109 eval "ac_cv_lib_$ac_lib_var=yes"
5116 else 5110 else
5117 echo "configure: failed program was:" >&5 5111 echo "configure: failed program was:" >&5
5118 cat conftest.$ac_ext >&5 5112 cat conftest.$ac_ext >&5
5143 5137
5144 fi 5138 fi
5145 5139
5146 5140
5147 cat > conftest.$ac_ext <<EOF 5141 cat > conftest.$ac_ext <<EOF
5148 #line 5149 "configure" 5142 #line 5143 "configure"
5149 #include "confdefs.h" 5143 #include "confdefs.h"
5150 #include <math.h> 5144 #include <math.h>
5151 int main() { 5145 int main() {
5152 return atanh(1.0) + asinh(1.0) + acosh(1.0); 5146 return atanh(1.0) + asinh(1.0) + acosh(1.0);
5153 ; return 0; } 5147 ; return 0; }
5154 EOF 5148 EOF
5155 if { (eval echo configure:5156: \"$ac_link\") 1>&5; (eval $ac_link) 2>&5; } && test -s conftest${ac_exeext}; then 5149 if { (eval echo configure:5150: \"$ac_link\") 1>&5; (eval $ac_link) 2>&5; } && test -s conftest${ac_exeext}; then
5156 rm -rf conftest* 5150 rm -rf conftest*
5157 { test "$extra_verbose" = "yes" && cat << \EOF 5151 { test "$extra_verbose" = "yes" && cat << \EOF
5158 Defining HAVE_INVERSE_HYPERBOLIC 5152 Defining HAVE_INVERSE_HYPERBOLIC
5159 EOF 5153 EOF
5160 cat >> confdefs.h <<\EOF 5154 cat >> confdefs.h <<\EOF
5169 rm -f conftest* 5163 rm -f conftest*
5170 5164
5171 for ac_func in mkstemp 5165 for ac_func in mkstemp
5172 do 5166 do
5173 echo $ac_n "checking for $ac_func""... $ac_c" 1>&6 5167 echo $ac_n "checking for $ac_func""... $ac_c" 1>&6
5174 echo "configure:5175: checking for $ac_func" >&5 5168 echo "configure:5169: checking for $ac_func" >&5
5175 5169
5176 cat > conftest.$ac_ext <<EOF 5170 cat > conftest.$ac_ext <<EOF
5177 #line 5178 "configure" 5171 #line 5172 "configure"
5178 #include "confdefs.h" 5172 #include "confdefs.h"
5179 /* System header to define __stub macros and hopefully few prototypes, 5173 /* System header to define __stub macros and hopefully few prototypes,
5180 which can conflict with char $ac_func(); below. */ 5174 which can conflict with char $ac_func(); below. */
5181 #include <assert.h> 5175 #include <assert.h>
5182 /* Override any gcc2 internal prototype to avoid an error. */ 5176 /* Override any gcc2 internal prototype to avoid an error. */
5195 $ac_func(); 5189 $ac_func();
5196 #endif 5190 #endif
5197 5191
5198 ; return 0; } 5192 ; return 0; }
5199 EOF 5193 EOF
5200 if { (eval echo configure:5201: \"$ac_link\") 1>&5; (eval $ac_link) 2>&5; } && test -s conftest${ac_exeext}; then 5194 if { (eval echo configure:5195: \"$ac_link\") 1>&5; (eval $ac_link) 2>&5; } && test -s conftest${ac_exeext}; then
5201 rm -rf conftest* 5195 rm -rf conftest*
5202 eval "ac_cv_func_$ac_func=yes" 5196 eval "ac_cv_func_$ac_func=yes"
5203 else 5197 else
5204 echo "configure: failed program was:" >&5 5198 echo "configure: failed program was:" >&5
5205 cat conftest.$ac_ext >&5 5199 cat conftest.$ac_ext >&5
5224 fi 5218 fi
5225 done 5219 done
5226 5220
5227 5221
5228 echo "checking type of mail spool file locking" 1>&6 5222 echo "checking type of mail spool file locking" 1>&6
5229 echo "configure:5230: checking type of mail spool file locking" >&5 5223 echo "configure:5224: checking type of mail spool file locking" >&5
5230 for ac_func in lockf flock 5224 for ac_func in lockf flock
5231 do 5225 do
5232 echo $ac_n "checking for $ac_func""... $ac_c" 1>&6 5226 echo $ac_n "checking for $ac_func""... $ac_c" 1>&6
5233 echo "configure:5234: checking for $ac_func" >&5 5227 echo "configure:5228: checking for $ac_func" >&5
5234 5228
5235 cat > conftest.$ac_ext <<EOF 5229 cat > conftest.$ac_ext <<EOF
5236 #line 5237 "configure" 5230 #line 5231 "configure"
5237 #include "confdefs.h" 5231 #include "confdefs.h"
5238 /* System header to define __stub macros and hopefully few prototypes, 5232 /* System header to define __stub macros and hopefully few prototypes,
5239 which can conflict with char $ac_func(); below. */ 5233 which can conflict with char $ac_func(); below. */
5240 #include <assert.h> 5234 #include <assert.h>
5241 /* Override any gcc2 internal prototype to avoid an error. */ 5235 /* Override any gcc2 internal prototype to avoid an error. */
5254 $ac_func(); 5248 $ac_func();
5255 #endif 5249 #endif
5256 5250
5257 ; return 0; } 5251 ; return 0; }
5258 EOF 5252 EOF
5259 if { (eval echo configure:5260: \"$ac_link\") 1>&5; (eval $ac_link) 2>&5; } && test -s conftest${ac_exeext}; then 5253 if { (eval echo configure:5254: \"$ac_link\") 1>&5; (eval $ac_link) 2>&5; } && test -s conftest${ac_exeext}; then
5260 rm -rf conftest* 5254 rm -rf conftest*
5261 eval "ac_cv_func_$ac_func=yes" 5255 eval "ac_cv_func_$ac_func=yes"
5262 else 5256 else
5263 echo "configure: failed program was:" >&5 5257 echo "configure: failed program was:" >&5
5264 cat conftest.$ac_ext >&5 5258 cat conftest.$ac_ext >&5
5336 { echo "Error:" "locking mail locking requested but not available." >&2; exit 1; } 5330 { echo "Error:" "locking mail locking requested but not available." >&2; exit 1; }
5337 5331
5338 case "$opsys" in decosf*) 5332 case "$opsys" in decosf*)
5339 5333
5340 echo $ac_n "checking for cma_open in -lpthreads""... $ac_c" 1>&6 5334 echo $ac_n "checking for cma_open in -lpthreads""... $ac_c" 1>&6
5341 echo "configure:5342: checking for cma_open in -lpthreads" >&5 5335 echo "configure:5336: checking for cma_open in -lpthreads" >&5
5342 ac_lib_var=`echo pthreads'_'cma_open | sed 'y%./+-%__p_%'` 5336 ac_lib_var=`echo pthreads'_'cma_open | sed 'y%./+-%__p_%'`
5343 5337
5344 xe_check_libs=" -lpthreads " 5338 xe_check_libs=" -lpthreads "
5345 cat > conftest.$ac_ext <<EOF 5339 cat > conftest.$ac_ext <<EOF
5346 #line 5347 "configure" 5340 #line 5341 "configure"
5347 #include "confdefs.h" 5341 #include "confdefs.h"
5348 /* Override any gcc2 internal prototype to avoid an error. */ 5342 /* Override any gcc2 internal prototype to avoid an error. */
5349 /* We use char because int might match the return type of a gcc2 5343 /* We use char because int might match the return type of a gcc2
5350 builtin and then its argument prototype would still apply. */ 5344 builtin and then its argument prototype would still apply. */
5351 char cma_open(); 5345 char cma_open();
5352 5346
5353 int main() { 5347 int main() {
5354 cma_open() 5348 cma_open()
5355 ; return 0; } 5349 ; return 0; }
5356 EOF 5350 EOF
5357 if { (eval echo configure:5358: \"$ac_link\") 1>&5; (eval $ac_link) 2>&5; } && test -s conftest${ac_exeext}; then 5351 if { (eval echo configure:5352: \"$ac_link\") 1>&5; (eval $ac_link) 2>&5; } && test -s conftest${ac_exeext}; then
5358 rm -rf conftest* 5352 rm -rf conftest*
5359 eval "ac_cv_lib_$ac_lib_var=yes" 5353 eval "ac_cv_lib_$ac_lib_var=yes"
5360 else 5354 else
5361 echo "configure: failed program was:" >&5 5355 echo "configure: failed program was:" >&5
5362 cat conftest.$ac_ext >&5 5356 cat conftest.$ac_ext >&5
5389 c_switch_site="$c_switch_site -threads" ;; 5383 c_switch_site="$c_switch_site -threads" ;;
5390 esac 5384 esac
5391 5385
5392 5386
5393 echo $ac_n "checking whether the -xildoff compiler flag is required""... $ac_c" 1>&6 5387 echo $ac_n "checking whether the -xildoff compiler flag is required""... $ac_c" 1>&6
5394 echo "configure:5395: checking whether the -xildoff compiler flag is required" >&5 5388 echo "configure:5389: checking whether the -xildoff compiler flag is required" >&5
5395 if ${CC-cc} '-###' -xildon no_such_file.c 2>&1 | grep '^[^ ]*/ild ' > /dev/null ; then 5389 if ${CC-cc} '-###' -xildon no_such_file.c 2>&1 | grep '^[^ ]*/ild ' > /dev/null ; then
5396 if ${CC-cc} '-###' -xildoff no_such_file.c 2>&1 | grep '^[^ ]*/ild ' > /dev/null ; 5390 if ${CC-cc} '-###' -xildoff no_such_file.c 2>&1 | grep '^[^ ]*/ild ' > /dev/null ;
5397 then echo "$ac_t""no" 1>&6; 5391 then echo "$ac_t""no" 1>&6;
5398 else echo "$ac_t""yes" 1>&6; ld_switch_site="$ld_switch_site -xildoff" && if test "$extra_verbose" = "yes"; then echo " Appending \"-xildoff\" to \$ld_switch_site"; fi 5392 else echo "$ac_t""yes" 1>&6; ld_switch_site="$ld_switch_site -xildoff" && if test "$extra_verbose" = "yes"; then echo " Appending \"-xildoff\" to \$ld_switch_site"; fi
5399 fi 5393 fi
5401 fi 5395 fi
5402 5396
5403 if test "$opsys" = "sol2"; then 5397 if test "$opsys" = "sol2"; then
5404 if test "$os_release" -ge 506; then 5398 if test "$os_release" -ge 506; then
5405 echo $ac_n "checking for \"-z ignore\" linker flag""... $ac_c" 1>&6 5399 echo $ac_n "checking for \"-z ignore\" linker flag""... $ac_c" 1>&6
5406 echo "configure:5407: checking for \"-z ignore\" linker flag" >&5 5400 echo "configure:5401: checking for \"-z ignore\" linker flag" >&5
5407 case "`ld -h 2>&1`" in 5401 case "`ld -h 2>&1`" in
5408 *-z\ ignore\|record* ) echo "$ac_t""yes" 1>&6 5402 *-z\ ignore\|record* ) echo "$ac_t""yes" 1>&6
5409 ld_switch_site="-z ignore $ld_switch_site" && if test "$extra_verbose" = "yes"; then echo " Prepending \"-z ignore\" to \$ld_switch_site"; fi ;; 5403 ld_switch_site="-z ignore $ld_switch_site" && if test "$extra_verbose" = "yes"; then echo " Prepending \"-z ignore\" to \$ld_switch_site"; fi ;;
5410 *) echo "$ac_t""no" 1>&6 ;; 5404 *) echo "$ac_t""no" 1>&6 ;;
5411 esac 5405 esac
5412 fi 5406 fi
5413 fi 5407 fi
5414 5408
5415 5409
5416 echo "checking "for specified window system"" 1>&6 5410 echo "checking "for specified window system"" 1>&6
5417 echo "configure:5418: checking "for specified window system"" >&5 5411 echo "configure:5412: checking "for specified window system"" >&5
5418 5412
5419 5413
5420 GNOME_CONFIG=no 5414 GNOME_CONFIG=no
5421 GTK_CONFIG=no 5415 GTK_CONFIG=no
5422 5416
5423 if test "$with_gnome" != "no"; then 5417 if test "$with_gnome" != "no"; then
5424 echo $ac_n "checking for GNOME configuration script""... $ac_c" 1>&6 5418 echo $ac_n "checking for GNOME configuration script""... $ac_c" 1>&6
5425 echo "configure:5426: checking for GNOME configuration script" >&5 5419 echo "configure:5420: checking for GNOME configuration script" >&5
5426 for possible in gnome-config 5420 for possible in gnome-config
5427 do 5421 do
5428 possible_version=`${possible} --version 2> /dev/null` 5422 possible_version=`${possible} --version 2> /dev/null`
5429 if test "x${possible_version}" != "x"; then 5423 if test "x${possible_version}" != "x"; then
5430 GNOME_CONFIG="${possible}" 5424 GNOME_CONFIG="${possible}"
5451 c_switch_gtk="$c_switch_gtk ${GNOME_CFLAGS}" && if test "$extra_verbose" = "yes"; then echo " Appending \"${GNOME_CFLAGS}\" to \$c_switch_gtk"; fi 5445 c_switch_gtk="$c_switch_gtk ${GNOME_CFLAGS}" && if test "$extra_verbose" = "yes"; then echo " Appending \"${GNOME_CFLAGS}\" to \$c_switch_gtk"; fi
5452 fi 5446 fi
5453 5447
5454 if test "$with_gtk" != "no";then 5448 if test "$with_gtk" != "no";then
5455 echo $ac_n "checking for GTK configuration script""... $ac_c" 1>&6 5449 echo $ac_n "checking for GTK configuration script""... $ac_c" 1>&6
5456 echo "configure:5457: checking for GTK configuration script" >&5 5450 echo "configure:5451: checking for GTK configuration script" >&5
5457 for possible in gtk12-config gtk14-config gtk-config 5451 for possible in gtk12-config gtk14-config gtk-config
5458 do 5452 do
5459 possible_version=`${possible} --version 2> /dev/null` 5453 possible_version=`${possible} --version 2> /dev/null`
5460 if test "x${possible_version}" != "x"; then 5454 if test "x${possible_version}" != "x"; then
5461 GTK_CONFIG="${possible}" 5455 GTK_CONFIG="${possible}"
5473 echo "$ac_t""${GTK_CONFIG}" 1>&6 5467 echo "$ac_t""${GTK_CONFIG}" 1>&6
5474 fi 5468 fi
5475 5469
5476 if test "${GTK_CONFIG}" != "no"; then 5470 if test "${GTK_CONFIG}" != "no"; then
5477 echo $ac_n "checking gtk version""... $ac_c" 1>&6 5471 echo $ac_n "checking gtk version""... $ac_c" 1>&6
5478 echo "configure:5479: checking gtk version" >&5 5472 echo "configure:5473: checking gtk version" >&5
5479 GTK_VERSION=`${GTK_CONFIG} --version` 5473 GTK_VERSION=`${GTK_CONFIG} --version`
5480 echo "$ac_t""${GTK_VERSION}" 1>&6 5474 echo "$ac_t""${GTK_VERSION}" 1>&6
5481 5475
5482 echo $ac_n "checking gtk libs""... $ac_c" 1>&6 5476 echo $ac_n "checking gtk libs""... $ac_c" 1>&6
5483 echo "configure:5484: checking gtk libs" >&5 5477 echo "configure:5478: checking gtk libs" >&5
5484 GTK_LIBS=`${GTK_CONFIG} --libs` 5478 GTK_LIBS=`${GTK_CONFIG} --libs`
5485 libs_gtk="$libs_gtk ${GTK_LIBS}" && if test "$extra_verbose" = "yes"; then echo " Appending \"${GTK_LIBS}\" to \$libs_gtk"; fi 5479 libs_gtk="$libs_gtk ${GTK_LIBS}" && if test "$extra_verbose" = "yes"; then echo " Appending \"${GTK_LIBS}\" to \$libs_gtk"; fi
5486 echo "$ac_t""${GTK_LIBS}" 1>&6 5480 echo "$ac_t""${GTK_LIBS}" 1>&6
5487 5481
5488 echo $ac_n "checking gtk cflags""... $ac_c" 1>&6 5482 echo $ac_n "checking gtk cflags""... $ac_c" 1>&6
5489 echo "configure:5490: checking gtk cflags" >&5 5483 echo "configure:5484: checking gtk cflags" >&5
5490 GTK_CFLAGS=`${GTK_CONFIG} --cflags` 5484 GTK_CFLAGS=`${GTK_CONFIG} --cflags`
5491 if test "$GCC" = "yes"; then 5485 if test "$GCC" = "yes"; then
5492 GTK_CFLAGS="${GTK_CFLAGS} -Wno-shadow" 5486 GTK_CFLAGS="${GTK_CFLAGS} -Wno-shadow"
5493 fi 5487 fi
5494 c_switch_gtk="$c_switch_gtk ${GTK_CFLAGS}" && if test "$extra_verbose" = "yes"; then echo " Appending \"${GTK_CFLAGS}\" to \$c_switch_gtk"; fi 5488 c_switch_gtk="$c_switch_gtk ${GTK_CFLAGS}" && if test "$extra_verbose" = "yes"; then echo " Appending \"${GTK_CFLAGS}\" to \$c_switch_gtk"; fi
5495 echo "$ac_t""${GTK_CFLAGS}" 1>&6 5489 echo "$ac_t""${GTK_CFLAGS}" 1>&6
5496 5490
5497 5491
5498 echo $ac_n "checking for main in -lgdk_imlib""... $ac_c" 1>&6 5492 echo $ac_n "checking for main in -lgdk_imlib""... $ac_c" 1>&6
5499 echo "configure:5500: checking for main in -lgdk_imlib" >&5 5493 echo "configure:5494: checking for main in -lgdk_imlib" >&5
5500 ac_lib_var=`echo gdk_imlib'_'main | sed 'y%./+-%__p_%'` 5494 ac_lib_var=`echo gdk_imlib'_'main | sed 'y%./+-%__p_%'`
5501 5495
5502 xe_check_libs=" -lgdk_imlib " 5496 xe_check_libs=" -lgdk_imlib "
5503 cat > conftest.$ac_ext <<EOF 5497 cat > conftest.$ac_ext <<EOF
5504 #line 5505 "configure" 5498 #line 5499 "configure"
5505 #include "confdefs.h" 5499 #include "confdefs.h"
5506 5500
5507 int main() { 5501 int main() {
5508 main() 5502 main()
5509 ; return 0; } 5503 ; return 0; }
5510 EOF 5504 EOF
5511 if { (eval echo configure:5512: \"$ac_link\") 1>&5; (eval $ac_link) 2>&5; } && test -s conftest${ac_exeext}; then 5505 if { (eval echo configure:5506: \"$ac_link\") 1>&5; (eval $ac_link) 2>&5; } && test -s conftest${ac_exeext}; then
5512 rm -rf conftest* 5506 rm -rf conftest*
5513 eval "ac_cv_lib_$ac_lib_var=yes" 5507 eval "ac_cv_lib_$ac_lib_var=yes"
5514 else 5508 else
5515 echo "configure: failed program was:" >&5 5509 echo "configure: failed program was:" >&5
5516 cat conftest.$ac_ext >&5 5510 cat conftest.$ac_ext >&5
5528 fi 5522 fi
5529 5523
5530 5524
5531 5525
5532 echo $ac_n "checking for Imlib_init in -lImlib""... $ac_c" 1>&6 5526 echo $ac_n "checking for Imlib_init in -lImlib""... $ac_c" 1>&6
5533 echo "configure:5534: checking for Imlib_init in -lImlib" >&5 5527 echo "configure:5528: checking for Imlib_init in -lImlib" >&5
5534 ac_lib_var=`echo Imlib'_'Imlib_init | sed 'y%./+-%__p_%'` 5528 ac_lib_var=`echo Imlib'_'Imlib_init | sed 'y%./+-%__p_%'`
5535 5529
5536 xe_check_libs=" -lImlib " 5530 xe_check_libs=" -lImlib "
5537 cat > conftest.$ac_ext <<EOF 5531 cat > conftest.$ac_ext <<EOF
5538 #line 5539 "configure" 5532 #line 5533 "configure"
5539 #include "confdefs.h" 5533 #include "confdefs.h"
5540 /* Override any gcc2 internal prototype to avoid an error. */ 5534 /* Override any gcc2 internal prototype to avoid an error. */
5541 /* We use char because int might match the return type of a gcc2 5535 /* We use char because int might match the return type of a gcc2
5542 builtin and then its argument prototype would still apply. */ 5536 builtin and then its argument prototype would still apply. */
5543 char Imlib_init(); 5537 char Imlib_init();
5544 5538
5545 int main() { 5539 int main() {
5546 Imlib_init() 5540 Imlib_init()
5547 ; return 0; } 5541 ; return 0; }
5548 EOF 5542 EOF
5549 if { (eval echo configure:5550: \"$ac_link\") 1>&5; (eval $ac_link) 2>&5; } && test -s conftest${ac_exeext}; then 5543 if { (eval echo configure:5544: \"$ac_link\") 1>&5; (eval $ac_link) 2>&5; } && test -s conftest${ac_exeext}; then
5550 rm -rf conftest* 5544 rm -rf conftest*
5551 eval "ac_cv_lib_$ac_lib_var=yes" 5545 eval "ac_cv_lib_$ac_lib_var=yes"
5552 else 5546 else
5553 echo "configure: failed program was:" >&5 5547 echo "configure: failed program was:" >&5
5554 cat conftest.$ac_ext >&5 5548 cat conftest.$ac_ext >&5
5567 5561
5568 5562
5569 for ac_func in gdk_imlib_init 5563 for ac_func in gdk_imlib_init
5570 do 5564 do
5571 echo $ac_n "checking for $ac_func""... $ac_c" 1>&6 5565 echo $ac_n "checking for $ac_func""... $ac_c" 1>&6
5572 echo "configure:5573: checking for $ac_func" >&5 5566 echo "configure:5567: checking for $ac_func" >&5
5573 5567
5574 cat > conftest.$ac_ext <<EOF 5568 cat > conftest.$ac_ext <<EOF
5575 #line 5576 "configure" 5569 #line 5570 "configure"
5576 #include "confdefs.h" 5570 #include "confdefs.h"
5577 /* System header to define __stub macros and hopefully few prototypes, 5571 /* System header to define __stub macros and hopefully few prototypes,
5578 which can conflict with char $ac_func(); below. */ 5572 which can conflict with char $ac_func(); below. */
5579 #include <assert.h> 5573 #include <assert.h>
5580 /* Override any gcc2 internal prototype to avoid an error. */ 5574 /* Override any gcc2 internal prototype to avoid an error. */
5593 $ac_func(); 5587 $ac_func();
5594 #endif 5588 #endif
5595 5589
5596 ; return 0; } 5590 ; return 0; }
5597 EOF 5591 EOF
5598 if { (eval echo configure:5599: \"$ac_link\") 1>&5; (eval $ac_link) 2>&5; } && test -s conftest${ac_exeext}; then 5592 if { (eval echo configure:5593: \"$ac_link\") 1>&5; (eval $ac_link) 2>&5; } && test -s conftest${ac_exeext}; then
5599 rm -rf conftest* 5593 rm -rf conftest*
5600 eval "ac_cv_func_$ac_func=yes" 5594 eval "ac_cv_func_$ac_func=yes"
5601 else 5595 else
5602 echo "configure: failed program was:" >&5 5596 echo "configure: failed program was:" >&5
5603 cat conftest.$ac_ext >&5 5597 cat conftest.$ac_ext >&5
5677 LDFLAGS="${LDFLAGS} ${GTK_LIBS}" 5671 LDFLAGS="${LDFLAGS} ${GTK_LIBS}"
5678 for ac_hdr in glade/glade.h glade.h 5672 for ac_hdr in glade/glade.h glade.h
5679 do 5673 do
5680 ac_safe=`echo "$ac_hdr" | sed 'y%./+-%__p_%'` 5674 ac_safe=`echo "$ac_hdr" | sed 'y%./+-%__p_%'`
5681 echo $ac_n "checking for $ac_hdr""... $ac_c" 1>&6 5675 echo $ac_n "checking for $ac_hdr""... $ac_c" 1>&6
5682 echo "configure:5683: checking for $ac_hdr" >&5 5676 echo "configure:5677: checking for $ac_hdr" >&5
5683 5677
5684 cat > conftest.$ac_ext <<EOF 5678 cat > conftest.$ac_ext <<EOF
5685 #line 5686 "configure" 5679 #line 5680 "configure"
5686 #include "confdefs.h" 5680 #include "confdefs.h"
5687 #include <$ac_hdr> 5681 #include <$ac_hdr>
5688 EOF 5682 EOF
5689 ac_try="$ac_cpp conftest.$ac_ext >/dev/null 2>conftest.out" 5683 ac_try="$ac_cpp conftest.$ac_ext >/dev/null 2>conftest.out"
5690 { (eval echo configure:5691: \"$ac_try\") 1>&5; (eval $ac_try) 2>&5; } 5684 { (eval echo configure:5685: \"$ac_try\") 1>&5; (eval $ac_try) 2>&5; }
5691 ac_err=`grep -v '^ *+' conftest.out | grep -v "^conftest.${ac_ext}\$"` 5685 ac_err=`grep -v '^ *+' conftest.out | grep -v "^conftest.${ac_ext}\$"`
5692 if test -z "$ac_err"; then 5686 if test -z "$ac_err"; then
5693 rm -rf conftest* 5687 rm -rf conftest*
5694 eval "ac_cv_header_$ac_safe=yes" 5688 eval "ac_cv_header_$ac_safe=yes"
5695 else 5689 else
5716 fi 5710 fi
5717 done 5711 done
5718 5712
5719 5713
5720 echo $ac_n "checking for main in -lxml""... $ac_c" 1>&6 5714 echo $ac_n "checking for main in -lxml""... $ac_c" 1>&6
5721 echo "configure:5722: checking for main in -lxml" >&5 5715 echo "configure:5716: checking for main in -lxml" >&5
5722 ac_lib_var=`echo xml'_'main | sed 'y%./+-%__p_%'` 5716 ac_lib_var=`echo xml'_'main | sed 'y%./+-%__p_%'`
5723 5717
5724 xe_check_libs=" -lxml " 5718 xe_check_libs=" -lxml "
5725 cat > conftest.$ac_ext <<EOF 5719 cat > conftest.$ac_ext <<EOF
5726 #line 5727 "configure" 5720 #line 5721 "configure"
5727 #include "confdefs.h" 5721 #include "confdefs.h"
5728 5722
5729 int main() { 5723 int main() {
5730 main() 5724 main()
5731 ; return 0; } 5725 ; return 0; }
5732 EOF 5726 EOF
5733 if { (eval echo configure:5734: \"$ac_link\") 1>&5; (eval $ac_link) 2>&5; } && test -s conftest${ac_exeext}; then 5727 if { (eval echo configure:5728: \"$ac_link\") 1>&5; (eval $ac_link) 2>&5; } && test -s conftest${ac_exeext}; then
5734 rm -rf conftest* 5728 rm -rf conftest*
5735 eval "ac_cv_lib_$ac_lib_var=yes" 5729 eval "ac_cv_lib_$ac_lib_var=yes"
5736 else 5730 else
5737 echo "configure: failed program was:" >&5 5731 echo "configure: failed program was:" >&5
5738 cat conftest.$ac_ext >&5 5732 cat conftest.$ac_ext >&5
5750 fi 5744 fi
5751 5745
5752 5746
5753 5747
5754 echo $ac_n "checking for main in -lglade""... $ac_c" 1>&6 5748 echo $ac_n "checking for main in -lglade""... $ac_c" 1>&6
5755 echo "configure:5756: checking for main in -lglade" >&5 5749 echo "configure:5750: checking for main in -lglade" >&5
5756 ac_lib_var=`echo glade'_'main | sed 'y%./+-%__p_%'` 5750 ac_lib_var=`echo glade'_'main | sed 'y%./+-%__p_%'`
5757 5751
5758 xe_check_libs=" -lglade " 5752 xe_check_libs=" -lglade "
5759 cat > conftest.$ac_ext <<EOF 5753 cat > conftest.$ac_ext <<EOF
5760 #line 5761 "configure" 5754 #line 5755 "configure"
5761 #include "confdefs.h" 5755 #include "confdefs.h"
5762 5756
5763 int main() { 5757 int main() {
5764 main() 5758 main()
5765 ; return 0; } 5759 ; return 0; }
5766 EOF 5760 EOF
5767 if { (eval echo configure:5768: \"$ac_link\") 1>&5; (eval $ac_link) 2>&5; } && test -s conftest${ac_exeext}; then 5761 if { (eval echo configure:5762: \"$ac_link\") 1>&5; (eval $ac_link) 2>&5; } && test -s conftest${ac_exeext}; then
5768 rm -rf conftest* 5762 rm -rf conftest*
5769 eval "ac_cv_lib_$ac_lib_var=yes" 5763 eval "ac_cv_lib_$ac_lib_var=yes"
5770 else 5764 else
5771 echo "configure: failed program was:" >&5 5765 echo "configure: failed program was:" >&5
5772 cat conftest.$ac_ext >&5 5766 cat conftest.$ac_ext >&5
5784 fi 5778 fi
5785 5779
5786 5780
5787 5781
5788 echo $ac_n "checking for main in -lglade-gnome""... $ac_c" 1>&6 5782 echo $ac_n "checking for main in -lglade-gnome""... $ac_c" 1>&6
5789 echo "configure:5790: checking for main in -lglade-gnome" >&5 5783 echo "configure:5784: checking for main in -lglade-gnome" >&5
5790 ac_lib_var=`echo glade-gnome'_'main | sed 'y%./+-%__p_%'` 5784 ac_lib_var=`echo glade-gnome'_'main | sed 'y%./+-%__p_%'`
5791 5785
5792 xe_check_libs=" -lglade-gnome " 5786 xe_check_libs=" -lglade-gnome "
5793 cat > conftest.$ac_ext <<EOF 5787 cat > conftest.$ac_ext <<EOF
5794 #line 5795 "configure" 5788 #line 5789 "configure"
5795 #include "confdefs.h" 5789 #include "confdefs.h"
5796 5790
5797 int main() { 5791 int main() {
5798 main() 5792 main()
5799 ; return 0; } 5793 ; return 0; }
5800 EOF 5794 EOF
5801 if { (eval echo configure:5802: \"$ac_link\") 1>&5; (eval $ac_link) 2>&5; } && test -s conftest${ac_exeext}; then 5795 if { (eval echo configure:5796: \"$ac_link\") 1>&5; (eval $ac_link) 2>&5; } && test -s conftest${ac_exeext}; then
5802 rm -rf conftest* 5796 rm -rf conftest*
5803 eval "ac_cv_lib_$ac_lib_var=yes" 5797 eval "ac_cv_lib_$ac_lib_var=yes"
5804 else 5798 else
5805 echo "configure: failed program was:" >&5 5799 echo "configure: failed program was:" >&5
5806 cat conftest.$ac_ext >&5 5800 cat conftest.$ac_ext >&5
5817 echo "$ac_t""no" 1>&6 5811 echo "$ac_t""no" 1>&6
5818 fi 5812 fi
5819 5813
5820 5814
5821 cat > conftest.$ac_ext <<EOF 5815 cat > conftest.$ac_ext <<EOF
5822 #line 5823 "configure" 5816 #line 5817 "configure"
5823 #include "confdefs.h" 5817 #include "confdefs.h"
5824 #include <glade/glade-xml.h> 5818 #include <glade/glade-xml.h>
5825 EOF 5819 EOF
5826 if (eval "$ac_cpp conftest.$ac_ext") 2>&5 | 5820 if (eval "$ac_cpp conftest.$ac_ext") 2>&5 |
5827 egrep "char \*txtdomain;" >/dev/null 2>&1; then 5821 egrep "char \*txtdomain;" >/dev/null 2>&1; then
5876 # If we find X, set shell vars x_includes and x_libraries to the 5870 # If we find X, set shell vars x_includes and x_libraries to the
5877 # paths, otherwise set no_x=yes. 5871 # paths, otherwise set no_x=yes.
5878 # Uses ac_ vars as temps to allow command line to override cache and checks. 5872 # Uses ac_ vars as temps to allow command line to override cache and checks.
5879 # --without-x overrides everything else, but does not touch the cache. 5873 # --without-x overrides everything else, but does not touch the cache.
5880 echo $ac_n "checking for X""... $ac_c" 1>&6 5874 echo $ac_n "checking for X""... $ac_c" 1>&6
5881 echo "configure:5882: checking for X" >&5 5875 echo "configure:5876: checking for X" >&5
5882 5876
5883 # Check whether --with-x or --without-x was given. 5877 # Check whether --with-x or --without-x was given.
5884 if test "${with_x+set}" = set; then 5878 if test "${with_x+set}" = set; then
5885 withval="$with_x" 5879 withval="$with_x"
5886 : 5880 :
5936 # Guess where to find include files, by looking for this one X11 .h file. 5930 # Guess where to find include files, by looking for this one X11 .h file.
5937 test -z "$x_direct_test_include" && x_direct_test_include=X11/Intrinsic.h 5931 test -z "$x_direct_test_include" && x_direct_test_include=X11/Intrinsic.h
5938 5932
5939 # First, try using that file with no special directory specified. 5933 # First, try using that file with no special directory specified.
5940 cat > conftest.$ac_ext <<EOF 5934 cat > conftest.$ac_ext <<EOF
5941 #line 5942 "configure" 5935 #line 5936 "configure"
5942 #include "confdefs.h" 5936 #include "confdefs.h"
5943 #include <$x_direct_test_include> 5937 #include <$x_direct_test_include>
5944 EOF 5938 EOF
5945 ac_try="$ac_cpp conftest.$ac_ext >/dev/null 2>conftest.out" 5939 ac_try="$ac_cpp conftest.$ac_ext >/dev/null 2>conftest.out"
5946 { (eval echo configure:5947: \"$ac_try\") 1>&5; (eval $ac_try) 2>&5; } 5940 { (eval echo configure:5941: \"$ac_try\") 1>&5; (eval $ac_try) 2>&5; }
5947 ac_err=`grep -v '^ *+' conftest.out | grep -v "^conftest.${ac_ext}\$"` 5941 ac_err=`grep -v '^ *+' conftest.out | grep -v "^conftest.${ac_ext}\$"`
5948 if test -z "$ac_err"; then 5942 if test -z "$ac_err"; then
5949 rm -rf conftest* 5943 rm -rf conftest*
5950 # We can compile using X headers with no special include directory. 5944 # We can compile using X headers with no special include directory.
5951 ac_x_includes= 5945 ac_x_includes=
6010 # See if we find them without any special options. 6004 # See if we find them without any special options.
6011 # Don't add to $LIBS permanently. 6005 # Don't add to $LIBS permanently.
6012 ac_save_LIBS="$LIBS" 6006 ac_save_LIBS="$LIBS"
6013 LIBS="-l$x_direct_test_library $LIBS" 6007 LIBS="-l$x_direct_test_library $LIBS"
6014 cat > conftest.$ac_ext <<EOF 6008 cat > conftest.$ac_ext <<EOF
6015 #line 6016 "configure" 6009 #line 6010 "configure"
6016 #include "confdefs.h" 6010 #include "confdefs.h"
6017 6011
6018 int main() { 6012 int main() {
6019 ${x_direct_test_function}() 6013 ${x_direct_test_function}()
6020 ; return 0; } 6014 ; return 0; }
6021 EOF 6015 EOF
6022 if { (eval echo configure:6023: \"$ac_link\") 1>&5; (eval $ac_link) 2>&5; } && test -s conftest${ac_exeext}; then 6016 if { (eval echo configure:6017: \"$ac_link\") 1>&5; (eval $ac_link) 2>&5; } && test -s conftest${ac_exeext}; then
6023 rm -rf conftest* 6017 rm -rf conftest*
6024 LIBS="$ac_save_LIBS" 6018 LIBS="$ac_save_LIBS"
6025 # We can link X programs with no special library path. 6019 # We can link X programs with no special library path.
6026 ac_x_libraries= 6020 ac_x_libraries=
6027 else 6021 else
6126 # For Solaris; some versions of Sun CC require a space after -R and 6120 # For Solaris; some versions of Sun CC require a space after -R and
6127 # others require no space. Words are not sufficient . . . . 6121 # others require no space. Words are not sufficient . . . .
6128 case "`(uname -sr) 2>/dev/null`" in 6122 case "`(uname -sr) 2>/dev/null`" in
6129 "SunOS 5"*) 6123 "SunOS 5"*)
6130 echo $ac_n "checking whether -R must be followed by a space""... $ac_c" 1>&6 6124 echo $ac_n "checking whether -R must be followed by a space""... $ac_c" 1>&6
6131 echo "configure:6132: checking whether -R must be followed by a space" >&5 6125 echo "configure:6126: checking whether -R must be followed by a space" >&5
6132 ac_xsave_LIBS="$LIBS"; LIBS="$LIBS -R$x_libraries" 6126 ac_xsave_LIBS="$LIBS"; LIBS="$LIBS -R$x_libraries"
6133 cat > conftest.$ac_ext <<EOF 6127 cat > conftest.$ac_ext <<EOF
6134 #line 6135 "configure" 6128 #line 6129 "configure"
6135 #include "confdefs.h" 6129 #include "confdefs.h"
6136 6130
6137 int main() { 6131 int main() {
6138 6132
6139 ; return 0; } 6133 ; return 0; }
6140 EOF 6134 EOF
6141 if { (eval echo configure:6142: \"$ac_link\") 1>&5; (eval $ac_link) 2>&5; } && test -s conftest${ac_exeext}; then 6135 if { (eval echo configure:6136: \"$ac_link\") 1>&5; (eval $ac_link) 2>&5; } && test -s conftest${ac_exeext}; then
6142 rm -rf conftest* 6136 rm -rf conftest*
6143 ac_R_nospace=yes 6137 ac_R_nospace=yes
6144 else 6138 else
6145 echo "configure: failed program was:" >&5 6139 echo "configure: failed program was:" >&5
6146 cat conftest.$ac_ext >&5 6140 cat conftest.$ac_ext >&5
6152 echo "$ac_t""no" 1>&6 6146 echo "$ac_t""no" 1>&6
6153 X_LIBS="$X_LIBS -R$x_libraries" 6147 X_LIBS="$X_LIBS -R$x_libraries"
6154 else 6148 else
6155 LIBS="$ac_xsave_LIBS -R $x_libraries" 6149 LIBS="$ac_xsave_LIBS -R $x_libraries"
6156 cat > conftest.$ac_ext <<EOF 6150 cat > conftest.$ac_ext <<EOF
6157 #line 6158 "configure" 6151 #line 6152 "configure"
6158 #include "confdefs.h" 6152 #include "confdefs.h"
6159 6153
6160 int main() { 6154 int main() {
6161 6155
6162 ; return 0; } 6156 ; return 0; }
6163 EOF 6157 EOF
6164 if { (eval echo configure:6165: \"$ac_link\") 1>&5; (eval $ac_link) 2>&5; } && test -s conftest${ac_exeext}; then 6158 if { (eval echo configure:6159: \"$ac_link\") 1>&5; (eval $ac_link) 2>&5; } && test -s conftest${ac_exeext}; then
6165 rm -rf conftest* 6159 rm -rf conftest*
6166 ac_R_space=yes 6160 ac_R_space=yes
6167 else 6161 else
6168 echo "configure: failed program was:" >&5 6162 echo "configure: failed program was:" >&5
6169 cat conftest.$ac_ext >&5 6163 cat conftest.$ac_ext >&5
6195 if test "$with_dnet" = "no" ; then 6189 if test "$with_dnet" = "no" ; then
6196 ac_cv_lib_dnet_dnet_ntoa=no 6190 ac_cv_lib_dnet_dnet_ntoa=no
6197 else 6191 else
6198 6192
6199 echo $ac_n "checking for dnet_ntoa in -ldnet""... $ac_c" 1>&6 6193 echo $ac_n "checking for dnet_ntoa in -ldnet""... $ac_c" 1>&6
6200 echo "configure:6201: checking for dnet_ntoa in -ldnet" >&5 6194 echo "configure:6195: checking for dnet_ntoa in -ldnet" >&5
6201 ac_lib_var=`echo dnet'_'dnet_ntoa | sed 'y%./+-%__p_%'` 6195 ac_lib_var=`echo dnet'_'dnet_ntoa | sed 'y%./+-%__p_%'`
6202 6196
6203 xe_check_libs=" -ldnet " 6197 xe_check_libs=" -ldnet "
6204 cat > conftest.$ac_ext <<EOF 6198 cat > conftest.$ac_ext <<EOF
6205 #line 6206 "configure" 6199 #line 6200 "configure"
6206 #include "confdefs.h" 6200 #include "confdefs.h"
6207 /* Override any gcc2 internal prototype to avoid an error. */ 6201 /* Override any gcc2 internal prototype to avoid an error. */
6208 /* We use char because int might match the return type of a gcc2 6202 /* We use char because int might match the return type of a gcc2
6209 builtin and then its argument prototype would still apply. */ 6203 builtin and then its argument prototype would still apply. */
6210 char dnet_ntoa(); 6204 char dnet_ntoa();
6211 6205
6212 int main() { 6206 int main() {
6213 dnet_ntoa() 6207 dnet_ntoa()
6214 ; return 0; } 6208 ; return 0; }
6215 EOF 6209 EOF
6216 if { (eval echo configure:6217: \"$ac_link\") 1>&5; (eval $ac_link) 2>&5; } && test -s conftest${ac_exeext}; then 6210 if { (eval echo configure:6211: \"$ac_link\") 1>&5; (eval $ac_link) 2>&5; } && test -s conftest${ac_exeext}; then
6217 rm -rf conftest* 6211 rm -rf conftest*
6218 eval "ac_cv_lib_$ac_lib_var=yes" 6212 eval "ac_cv_lib_$ac_lib_var=yes"
6219 else 6213 else
6220 echo "configure: failed program was:" >&5 6214 echo "configure: failed program was:" >&5
6221 cat conftest.$ac_ext >&5 6215 cat conftest.$ac_ext >&5
6235 fi 6229 fi
6236 6230
6237 if test $ac_cv_lib_dnet_dnet_ntoa = no; then 6231 if test $ac_cv_lib_dnet_dnet_ntoa = no; then
6238 6232
6239 echo $ac_n "checking for dnet_ntoa in -ldnet_stub""... $ac_c" 1>&6 6233 echo $ac_n "checking for dnet_ntoa in -ldnet_stub""... $ac_c" 1>&6
6240 echo "configure:6241: checking for dnet_ntoa in -ldnet_stub" >&5 6234 echo "configure:6235: checking for dnet_ntoa in -ldnet_stub" >&5
6241 ac_lib_var=`echo dnet_stub'_'dnet_ntoa | sed 'y%./+-%__p_%'` 6235 ac_lib_var=`echo dnet_stub'_'dnet_ntoa | sed 'y%./+-%__p_%'`
6242 6236
6243 xe_check_libs=" -ldnet_stub " 6237 xe_check_libs=" -ldnet_stub "
6244 cat > conftest.$ac_ext <<EOF 6238 cat > conftest.$ac_ext <<EOF
6245 #line 6246 "configure" 6239 #line 6240 "configure"
6246 #include "confdefs.h" 6240 #include "confdefs.h"
6247 /* Override any gcc2 internal prototype to avoid an error. */ 6241 /* Override any gcc2 internal prototype to avoid an error. */
6248 /* We use char because int might match the return type of a gcc2 6242 /* We use char because int might match the return type of a gcc2
6249 builtin and then its argument prototype would still apply. */ 6243 builtin and then its argument prototype would still apply. */
6250 char dnet_ntoa(); 6244 char dnet_ntoa();
6251 6245
6252 int main() { 6246 int main() {
6253 dnet_ntoa() 6247 dnet_ntoa()
6254 ; return 0; } 6248 ; return 0; }
6255 EOF 6249 EOF
6256 if { (eval echo configure:6257: \"$ac_link\") 1>&5; (eval $ac_link) 2>&5; } && test -s conftest${ac_exeext}; then 6250 if { (eval echo configure:6251: \"$ac_link\") 1>&5; (eval $ac_link) 2>&5; } && test -s conftest${ac_exeext}; then
6257 rm -rf conftest* 6251 rm -rf conftest*
6258 eval "ac_cv_lib_$ac_lib_var=yes" 6252 eval "ac_cv_lib_$ac_lib_var=yes"
6259 else 6253 else
6260 echo "configure: failed program was:" >&5 6254 echo "configure: failed program was:" >&5
6261 cat conftest.$ac_ext >&5 6255 cat conftest.$ac_ext >&5
6280 # chad@anasazi.com says the Pyramis MIS-ES running DC/OSx (SVR4) 6274 # chad@anasazi.com says the Pyramis MIS-ES running DC/OSx (SVR4)
6281 # needs -lnsl. 6275 # needs -lnsl.
6282 # The nsl library prevents programs from opening the X display 6276 # The nsl library prevents programs from opening the X display
6283 # on Irix 5.2, according to dickey@clark.net. 6277 # on Irix 5.2, according to dickey@clark.net.
6284 echo $ac_n "checking for gethostbyname""... $ac_c" 1>&6 6278 echo $ac_n "checking for gethostbyname""... $ac_c" 1>&6
6285 echo "configure:6286: checking for gethostbyname" >&5 6279 echo "configure:6280: checking for gethostbyname" >&5
6286 6280
6287 cat > conftest.$ac_ext <<EOF 6281 cat > conftest.$ac_ext <<EOF
6288 #line 6289 "configure" 6282 #line 6283 "configure"
6289 #include "confdefs.h" 6283 #include "confdefs.h"
6290 /* System header to define __stub macros and hopefully few prototypes, 6284 /* System header to define __stub macros and hopefully few prototypes,
6291 which can conflict with char gethostbyname(); below. */ 6285 which can conflict with char gethostbyname(); below. */
6292 #include <assert.h> 6286 #include <assert.h>
6293 /* Override any gcc2 internal prototype to avoid an error. */ 6287 /* Override any gcc2 internal prototype to avoid an error. */
6306 gethostbyname(); 6300 gethostbyname();
6307 #endif 6301 #endif
6308 6302
6309 ; return 0; } 6303 ; return 0; }
6310 EOF 6304 EOF
6311 if { (eval echo configure:6312: \"$ac_link\") 1>&5; (eval $ac_link) 2>&5; } && test -s conftest${ac_exeext}; then 6305 if { (eval echo configure:6306: \"$ac_link\") 1>&5; (eval $ac_link) 2>&5; } && test -s conftest${ac_exeext}; then
6312 rm -rf conftest* 6306 rm -rf conftest*
6313 eval "ac_cv_func_gethostbyname=yes" 6307 eval "ac_cv_func_gethostbyname=yes"
6314 else 6308 else
6315 echo "configure: failed program was:" >&5 6309 echo "configure: failed program was:" >&5
6316 cat conftest.$ac_ext >&5 6310 cat conftest.$ac_ext >&5
6327 fi 6321 fi
6328 6322
6329 if test $ac_cv_func_gethostbyname = no; then 6323 if test $ac_cv_func_gethostbyname = no; then
6330 6324
6331 echo $ac_n "checking for gethostbyname in -lnsl""... $ac_c" 1>&6 6325 echo $ac_n "checking for gethostbyname in -lnsl""... $ac_c" 1>&6
6332 echo "configure:6333: checking for gethostbyname in -lnsl" >&5 6326 echo "configure:6327: checking for gethostbyname in -lnsl" >&5
6333 ac_lib_var=`echo nsl'_'gethostbyname | sed 'y%./+-%__p_%'` 6327 ac_lib_var=`echo nsl'_'gethostbyname | sed 'y%./+-%__p_%'`
6334 6328
6335 xe_check_libs=" -lnsl " 6329 xe_check_libs=" -lnsl "
6336 cat > conftest.$ac_ext <<EOF 6330 cat > conftest.$ac_ext <<EOF
6337 #line 6338 "configure" 6331 #line 6332 "configure"
6338 #include "confdefs.h" 6332 #include "confdefs.h"
6339 /* Override any gcc2 internal prototype to avoid an error. */ 6333 /* Override any gcc2 internal prototype to avoid an error. */
6340 /* We use char because int might match the return type of a gcc2 6334 /* We use char because int might match the return type of a gcc2
6341 builtin and then its argument prototype would still apply. */ 6335 builtin and then its argument prototype would still apply. */
6342 char gethostbyname(); 6336 char gethostbyname();
6343 6337
6344 int main() { 6338 int main() {
6345 gethostbyname() 6339 gethostbyname()
6346 ; return 0; } 6340 ; return 0; }
6347 EOF 6341 EOF
6348 if { (eval echo configure:6349: \"$ac_link\") 1>&5; (eval $ac_link) 2>&5; } && test -s conftest${ac_exeext}; then 6342 if { (eval echo configure:6343: \"$ac_link\") 1>&5; (eval $ac_link) 2>&5; } && test -s conftest${ac_exeext}; then
6349 rm -rf conftest* 6343 rm -rf conftest*
6350 eval "ac_cv_lib_$ac_lib_var=yes" 6344 eval "ac_cv_lib_$ac_lib_var=yes"
6351 else 6345 else
6352 echo "configure: failed program was:" >&5 6346 echo "configure: failed program was:" >&5
6353 cat conftest.$ac_ext >&5 6347 cat conftest.$ac_ext >&5
6373 # on later versions), says simon@lia.di.epfl.ch: it contains 6367 # on later versions), says simon@lia.di.epfl.ch: it contains
6374 # gethostby* variants that don't use the nameserver (or something). 6368 # gethostby* variants that don't use the nameserver (or something).
6375 # -lsocket must be given before -lnsl if both are needed. 6369 # -lsocket must be given before -lnsl if both are needed.
6376 # We assume that if connect needs -lnsl, so does gethostbyname. 6370 # We assume that if connect needs -lnsl, so does gethostbyname.
6377 echo $ac_n "checking for connect""... $ac_c" 1>&6 6371 echo $ac_n "checking for connect""... $ac_c" 1>&6
6378 echo "configure:6379: checking for connect" >&5 6372 echo "configure:6373: checking for connect" >&5
6379 6373
6380 cat > conftest.$ac_ext <<EOF 6374 cat > conftest.$ac_ext <<EOF
6381 #line 6382 "configure" 6375 #line 6376 "configure"
6382 #include "confdefs.h" 6376 #include "confdefs.h"
6383 /* System header to define __stub macros and hopefully few prototypes, 6377 /* System header to define __stub macros and hopefully few prototypes,
6384 which can conflict with char connect(); below. */ 6378 which can conflict with char connect(); below. */
6385 #include <assert.h> 6379 #include <assert.h>
6386 /* Override any gcc2 internal prototype to avoid an error. */ 6380 /* Override any gcc2 internal prototype to avoid an error. */
6399 connect(); 6393 connect();
6400 #endif 6394 #endif
6401 6395
6402 ; return 0; } 6396 ; return 0; }
6403 EOF 6397 EOF
6404 if { (eval echo configure:6405: \"$ac_link\") 1>&5; (eval $ac_link) 2>&5; } && test -s conftest${ac_exeext}; then 6398 if { (eval echo configure:6399: \"$ac_link\") 1>&5; (eval $ac_link) 2>&5; } && test -s conftest${ac_exeext}; then
6405 rm -rf conftest* 6399 rm -rf conftest*
6406 eval "ac_cv_func_connect=yes" 6400 eval "ac_cv_func_connect=yes"
6407 else 6401 else
6408 echo "configure: failed program was:" >&5 6402 echo "configure: failed program was:" >&5
6409 cat conftest.$ac_ext >&5 6403 cat conftest.$ac_ext >&5
6422 if test $ac_cv_func_connect = no; then 6416 if test $ac_cv_func_connect = no; then
6423 6417
6424 xe_msg_checking="for connect in -lsocket" 6418 xe_msg_checking="for connect in -lsocket"
6425 test -n "$X_EXTRA_LIBS" && xe_msg_checking="$xe_msg_checking using extra libs $X_EXTRA_LIBS" 6419 test -n "$X_EXTRA_LIBS" && xe_msg_checking="$xe_msg_checking using extra libs $X_EXTRA_LIBS"
6426 echo $ac_n "checking "$xe_msg_checking"""... $ac_c" 1>&6 6420 echo $ac_n "checking "$xe_msg_checking"""... $ac_c" 1>&6
6427 echo "configure:6428: checking "$xe_msg_checking"" >&5 6421 echo "configure:6422: checking "$xe_msg_checking"" >&5
6428 ac_lib_var=`echo socket'_'connect | sed 'y%./+-%__p_%'` 6422 ac_lib_var=`echo socket'_'connect | sed 'y%./+-%__p_%'`
6429 6423
6430 xe_check_libs=" -lsocket $X_EXTRA_LIBS" 6424 xe_check_libs=" -lsocket $X_EXTRA_LIBS"
6431 cat > conftest.$ac_ext <<EOF 6425 cat > conftest.$ac_ext <<EOF
6432 #line 6433 "configure" 6426 #line 6427 "configure"
6433 #include "confdefs.h" 6427 #include "confdefs.h"
6434 /* Override any gcc2 internal prototype to avoid an error. */ 6428 /* Override any gcc2 internal prototype to avoid an error. */
6435 /* We use char because int might match the return type of a gcc2 6429 /* We use char because int might match the return type of a gcc2
6436 builtin and then its argument prototype would still apply. */ 6430 builtin and then its argument prototype would still apply. */
6437 char connect(); 6431 char connect();
6438 6432
6439 int main() { 6433 int main() {
6440 connect() 6434 connect()
6441 ; return 0; } 6435 ; return 0; }
6442 EOF 6436 EOF
6443 if { (eval echo configure:6444: \"$ac_link\") 1>&5; (eval $ac_link) 2>&5; } && test -s conftest${ac_exeext}; then 6437 if { (eval echo configure:6438: \"$ac_link\") 1>&5; (eval $ac_link) 2>&5; } && test -s conftest${ac_exeext}; then
6444 rm -rf conftest* 6438 rm -rf conftest*
6445 eval "ac_cv_lib_$ac_lib_var=yes" 6439 eval "ac_cv_lib_$ac_lib_var=yes"
6446 else 6440 else
6447 echo "configure: failed program was:" >&5 6441 echo "configure: failed program was:" >&5
6448 cat conftest.$ac_ext >&5 6442 cat conftest.$ac_ext >&5
6462 6456
6463 fi 6457 fi
6464 6458
6465 # gomez@mi.uni-erlangen.de says -lposix is necessary on A/UX. 6459 # gomez@mi.uni-erlangen.de says -lposix is necessary on A/UX.
6466 echo $ac_n "checking for remove""... $ac_c" 1>&6 6460 echo $ac_n "checking for remove""... $ac_c" 1>&6
6467 echo "configure:6468: checking for remove" >&5 6461 echo "configure:6462: checking for remove" >&5
6468 6462
6469 cat > conftest.$ac_ext <<EOF 6463 cat > conftest.$ac_ext <<EOF
6470 #line 6471 "configure" 6464 #line 6465 "configure"
6471 #include "confdefs.h" 6465 #include "confdefs.h"
6472 /* System header to define __stub macros and hopefully few prototypes, 6466 /* System header to define __stub macros and hopefully few prototypes,
6473 which can conflict with char remove(); below. */ 6467 which can conflict with char remove(); below. */
6474 #include <assert.h> 6468 #include <assert.h>
6475 /* Override any gcc2 internal prototype to avoid an error. */ 6469 /* Override any gcc2 internal prototype to avoid an error. */
6488 remove(); 6482 remove();
6489 #endif 6483 #endif
6490 6484
6491 ; return 0; } 6485 ; return 0; }
6492 EOF 6486 EOF
6493 if { (eval echo configure:6494: \"$ac_link\") 1>&5; (eval $ac_link) 2>&5; } && test -s conftest${ac_exeext}; then 6487 if { (eval echo configure:6488: \"$ac_link\") 1>&5; (eval $ac_link) 2>&5; } && test -s conftest${ac_exeext}; then
6494 rm -rf conftest* 6488 rm -rf conftest*
6495 eval "ac_cv_func_remove=yes" 6489 eval "ac_cv_func_remove=yes"
6496 else 6490 else
6497 echo "configure: failed program was:" >&5 6491 echo "configure: failed program was:" >&5
6498 cat conftest.$ac_ext >&5 6492 cat conftest.$ac_ext >&5
6509 fi 6503 fi
6510 6504
6511 if test $ac_cv_func_remove = no; then 6505 if test $ac_cv_func_remove = no; then
6512 6506
6513 echo $ac_n "checking for remove in -lposix""... $ac_c" 1>&6 6507 echo $ac_n "checking for remove in -lposix""... $ac_c" 1>&6
6514 echo "configure:6515: checking for remove in -lposix" >&5 6508 echo "configure:6509: checking for remove in -lposix" >&5
6515 ac_lib_var=`echo posix'_'remove | sed 'y%./+-%__p_%'` 6509 ac_lib_var=`echo posix'_'remove | sed 'y%./+-%__p_%'`
6516 6510
6517 xe_check_libs=" -lposix " 6511 xe_check_libs=" -lposix "
6518 cat > conftest.$ac_ext <<EOF 6512 cat > conftest.$ac_ext <<EOF
6519 #line 6520 "configure" 6513 #line 6514 "configure"
6520 #include "confdefs.h" 6514 #include "confdefs.h"
6521 /* Override any gcc2 internal prototype to avoid an error. */ 6515 /* Override any gcc2 internal prototype to avoid an error. */
6522 /* We use char because int might match the return type of a gcc2 6516 /* We use char because int might match the return type of a gcc2
6523 builtin and then its argument prototype would still apply. */ 6517 builtin and then its argument prototype would still apply. */
6524 char remove(); 6518 char remove();
6525 6519
6526 int main() { 6520 int main() {
6527 remove() 6521 remove()
6528 ; return 0; } 6522 ; return 0; }
6529 EOF 6523 EOF
6530 if { (eval echo configure:6531: \"$ac_link\") 1>&5; (eval $ac_link) 2>&5; } && test -s conftest${ac_exeext}; then 6524 if { (eval echo configure:6525: \"$ac_link\") 1>&5; (eval $ac_link) 2>&5; } && test -s conftest${ac_exeext}; then
6531 rm -rf conftest* 6525 rm -rf conftest*
6532 eval "ac_cv_lib_$ac_lib_var=yes" 6526 eval "ac_cv_lib_$ac_lib_var=yes"
6533 else 6527 else
6534 echo "configure: failed program was:" >&5 6528 echo "configure: failed program was:" >&5
6535 cat conftest.$ac_ext >&5 6529 cat conftest.$ac_ext >&5
6549 6543
6550 fi 6544 fi
6551 6545
6552 # BSDI BSD/OS 2.1 needs -lipc for XOpenDisplay. 6546 # BSDI BSD/OS 2.1 needs -lipc for XOpenDisplay.
6553 echo $ac_n "checking for shmat""... $ac_c" 1>&6 6547 echo $ac_n "checking for shmat""... $ac_c" 1>&6
6554 echo "configure:6555: checking for shmat" >&5 6548 echo "configure:6549: checking for shmat" >&5
6555 6549
6556 cat > conftest.$ac_ext <<EOF 6550 cat > conftest.$ac_ext <<EOF
6557 #line 6558 "configure" 6551 #line 6552 "configure"
6558 #include "confdefs.h" 6552 #include "confdefs.h"
6559 /* System header to define __stub macros and hopefully few prototypes, 6553 /* System header to define __stub macros and hopefully few prototypes,
6560 which can conflict with char shmat(); below. */ 6554 which can conflict with char shmat(); below. */
6561 #include <assert.h> 6555 #include <assert.h>
6562 /* Override any gcc2 internal prototype to avoid an error. */ 6556 /* Override any gcc2 internal prototype to avoid an error. */
6575 shmat(); 6569 shmat();
6576 #endif 6570 #endif
6577 6571
6578 ; return 0; } 6572 ; return 0; }
6579 EOF 6573 EOF
6580 if { (eval echo configure:6581: \"$ac_link\") 1>&5; (eval $ac_link) 2>&5; } && test -s conftest${ac_exeext}; then 6574 if { (eval echo configure:6575: \"$ac_link\") 1>&5; (eval $ac_link) 2>&5; } && test -s conftest${ac_exeext}; then
6581 rm -rf conftest* 6575 rm -rf conftest*
6582 eval "ac_cv_func_shmat=yes" 6576 eval "ac_cv_func_shmat=yes"
6583 else 6577 else
6584 echo "configure: failed program was:" >&5 6578 echo "configure: failed program was:" >&5
6585 cat conftest.$ac_ext >&5 6579 cat conftest.$ac_ext >&5
6596 fi 6590 fi
6597 6591
6598 if test $ac_cv_func_shmat = no; then 6592 if test $ac_cv_func_shmat = no; then
6599 6593
6600 echo $ac_n "checking for shmat in -lipc""... $ac_c" 1>&6 6594 echo $ac_n "checking for shmat in -lipc""... $ac_c" 1>&6
6601 echo "configure:6602: checking for shmat in -lipc" >&5 6595 echo "configure:6596: checking for shmat in -lipc" >&5
6602 ac_lib_var=`echo ipc'_'shmat | sed 'y%./+-%__p_%'` 6596 ac_lib_var=`echo ipc'_'shmat | sed 'y%./+-%__p_%'`
6603 6597
6604 xe_check_libs=" -lipc " 6598 xe_check_libs=" -lipc "
6605 cat > conftest.$ac_ext <<EOF 6599 cat > conftest.$ac_ext <<EOF
6606 #line 6607 "configure" 6600 #line 6601 "configure"
6607 #include "confdefs.h" 6601 #include "confdefs.h"
6608 /* Override any gcc2 internal prototype to avoid an error. */ 6602 /* Override any gcc2 internal prototype to avoid an error. */
6609 /* We use char because int might match the return type of a gcc2 6603 /* We use char because int might match the return type of a gcc2
6610 builtin and then its argument prototype would still apply. */ 6604 builtin and then its argument prototype would still apply. */
6611 char shmat(); 6605 char shmat();
6612 6606
6613 int main() { 6607 int main() {
6614 shmat() 6608 shmat()
6615 ; return 0; } 6609 ; return 0; }
6616 EOF 6610 EOF
6617 if { (eval echo configure:6618: \"$ac_link\") 1>&5; (eval $ac_link) 2>&5; } && test -s conftest${ac_exeext}; then 6611 if { (eval echo configure:6612: \"$ac_link\") 1>&5; (eval $ac_link) 2>&5; } && test -s conftest${ac_exeext}; then
6618 rm -rf conftest* 6612 rm -rf conftest*
6619 eval "ac_cv_lib_$ac_lib_var=yes" 6613 eval "ac_cv_lib_$ac_lib_var=yes"
6620 else 6614 else
6621 echo "configure: failed program was:" >&5 6615 echo "configure: failed program was:" >&5
6622 cat conftest.$ac_ext >&5 6616 cat conftest.$ac_ext >&5
6648 # --interran@uluru.Stanford.EDU, kb@cs.umb.edu. 6642 # --interran@uluru.Stanford.EDU, kb@cs.umb.edu.
6649 6643
6650 xe_msg_checking="for IceConnectionNumber in -lICE" 6644 xe_msg_checking="for IceConnectionNumber in -lICE"
6651 test -n "$X_EXTRA_LIBS" && xe_msg_checking="$xe_msg_checking using extra libs $X_EXTRA_LIBS" 6645 test -n "$X_EXTRA_LIBS" && xe_msg_checking="$xe_msg_checking using extra libs $X_EXTRA_LIBS"
6652 echo $ac_n "checking "$xe_msg_checking"""... $ac_c" 1>&6 6646 echo $ac_n "checking "$xe_msg_checking"""... $ac_c" 1>&6
6653 echo "configure:6654: checking "$xe_msg_checking"" >&5 6647 echo "configure:6648: checking "$xe_msg_checking"" >&5
6654 ac_lib_var=`echo ICE'_'IceConnectionNumber | sed 'y%./+-%__p_%'` 6648 ac_lib_var=`echo ICE'_'IceConnectionNumber | sed 'y%./+-%__p_%'`
6655 6649
6656 xe_check_libs=" -lICE $X_EXTRA_LIBS" 6650 xe_check_libs=" -lICE $X_EXTRA_LIBS"
6657 cat > conftest.$ac_ext <<EOF 6651 cat > conftest.$ac_ext <<EOF
6658 #line 6659 "configure" 6652 #line 6653 "configure"
6659 #include "confdefs.h" 6653 #include "confdefs.h"
6660 /* Override any gcc2 internal prototype to avoid an error. */ 6654 /* Override any gcc2 internal prototype to avoid an error. */
6661 /* We use char because int might match the return type of a gcc2 6655 /* We use char because int might match the return type of a gcc2
6662 builtin and then its argument prototype would still apply. */ 6656 builtin and then its argument prototype would still apply. */
6663 char IceConnectionNumber(); 6657 char IceConnectionNumber();
6664 6658
6665 int main() { 6659 int main() {
6666 IceConnectionNumber() 6660 IceConnectionNumber()
6667 ; return 0; } 6661 ; return 0; }
6668 EOF 6662 EOF
6669 if { (eval echo configure:6670: \"$ac_link\") 1>&5; (eval $ac_link) 2>&5; } && test -s conftest${ac_exeext}; then 6663 if { (eval echo configure:6664: \"$ac_link\") 1>&5; (eval $ac_link) 2>&5; } && test -s conftest${ac_exeext}; then
6670 rm -rf conftest* 6664 rm -rf conftest*
6671 eval "ac_cv_lib_$ac_lib_var=yes" 6665 eval "ac_cv_lib_$ac_lib_var=yes"
6672 else 6666 else
6673 echo "configure: failed program was:" >&5 6667 echo "configure: failed program was:" >&5
6674 cat conftest.$ac_ext >&5 6668 cat conftest.$ac_ext >&5
6710 SRC_SUBDIR_DEPS="$SRC_SUBDIR_DEPS lwlib" && if test "$extra_verbose" = "yes"; then echo " Appending \"lwlib\" to \$SRC_SUBDIR_DEPS"; fi 6704 SRC_SUBDIR_DEPS="$SRC_SUBDIR_DEPS lwlib" && if test "$extra_verbose" = "yes"; then echo " Appending \"lwlib\" to \$SRC_SUBDIR_DEPS"; fi
6711 6705
6712 6706
6713 ac_safe=`echo "Xm/Xm.h" | sed 'y%./+-%__p_%'` 6707 ac_safe=`echo "Xm/Xm.h" | sed 'y%./+-%__p_%'`
6714 echo $ac_n "checking for Xm/Xm.h""... $ac_c" 1>&6 6708 echo $ac_n "checking for Xm/Xm.h""... $ac_c" 1>&6
6715 echo "configure:6716: checking for Xm/Xm.h" >&5 6709 echo "configure:6710: checking for Xm/Xm.h" >&5
6716 6710
6717 cat > conftest.$ac_ext <<EOF 6711 cat > conftest.$ac_ext <<EOF
6718 #line 6719 "configure" 6712 #line 6713 "configure"
6719 #include "confdefs.h" 6713 #include "confdefs.h"
6720 #include <Xm/Xm.h> 6714 #include <Xm/Xm.h>
6721 EOF 6715 EOF
6722 ac_try="$ac_cpp conftest.$ac_ext >/dev/null 2>conftest.out" 6716 ac_try="$ac_cpp conftest.$ac_ext >/dev/null 2>conftest.out"
6723 { (eval echo configure:6724: \"$ac_try\") 1>&5; (eval $ac_try) 2>&5; } 6717 { (eval echo configure:6718: \"$ac_try\") 1>&5; (eval $ac_try) 2>&5; }
6724 ac_err=`grep -v '^ *+' conftest.out | grep -v "^conftest.${ac_ext}\$"` 6718 ac_err=`grep -v '^ *+' conftest.out | grep -v "^conftest.${ac_ext}\$"`
6725 if test -z "$ac_err"; then 6719 if test -z "$ac_err"; then
6726 rm -rf conftest* 6720 rm -rf conftest*
6727 eval "ac_cv_header_$ac_safe=yes" 6721 eval "ac_cv_header_$ac_safe=yes"
6728 else 6722 else
6735 rm -f conftest* 6729 rm -f conftest*
6736 if eval "test \"`echo '$ac_cv_header_'$ac_safe`\" = yes"; then 6730 if eval "test \"`echo '$ac_cv_header_'$ac_safe`\" = yes"; then
6737 echo "$ac_t""yes" 1>&6 6731 echo "$ac_t""yes" 1>&6
6738 6732
6739 echo $ac_n "checking for XmStringFree in -lXm""... $ac_c" 1>&6 6733 echo $ac_n "checking for XmStringFree in -lXm""... $ac_c" 1>&6
6740 echo "configure:6741: checking for XmStringFree in -lXm" >&5 6734 echo "configure:6735: checking for XmStringFree in -lXm" >&5
6741 ac_lib_var=`echo Xm'_'XmStringFree | sed 'y%./+-%__p_%'` 6735 ac_lib_var=`echo Xm'_'XmStringFree | sed 'y%./+-%__p_%'`
6742 6736
6743 xe_check_libs=" -lXm " 6737 xe_check_libs=" -lXm "
6744 cat > conftest.$ac_ext <<EOF 6738 cat > conftest.$ac_ext <<EOF
6745 #line 6746 "configure" 6739 #line 6740 "configure"
6746 #include "confdefs.h" 6740 #include "confdefs.h"
6747 /* Override any gcc2 internal prototype to avoid an error. */ 6741 /* Override any gcc2 internal prototype to avoid an error. */
6748 /* We use char because int might match the return type of a gcc2 6742 /* We use char because int might match the return type of a gcc2
6749 builtin and then its argument prototype would still apply. */ 6743 builtin and then its argument prototype would still apply. */
6750 char XmStringFree(); 6744 char XmStringFree();
6751 6745
6752 int main() { 6746 int main() {
6753 XmStringFree() 6747 XmStringFree()
6754 ; return 0; } 6748 ; return 0; }
6755 EOF 6749 EOF
6756 if { (eval echo configure:6757: \"$ac_link\") 1>&5; (eval $ac_link) 2>&5; } && test -s conftest${ac_exeext}; then 6750 if { (eval echo configure:6751: \"$ac_link\") 1>&5; (eval $ac_link) 2>&5; } && test -s conftest${ac_exeext}; then
6757 rm -rf conftest* 6751 rm -rf conftest*
6758 eval "ac_cv_lib_$ac_lib_var=yes" 6752 eval "ac_cv_lib_$ac_lib_var=yes"
6759 else 6753 else
6760 echo "configure: failed program was:" >&5 6754 echo "configure: failed program was:" >&5
6761 cat conftest.$ac_ext >&5 6755 cat conftest.$ac_ext >&5
6903 EOF 6897 EOF
6904 } 6898 }
6905 6899
6906 6900
6907 echo "checking for X defines extracted by xmkmf" 1>&6 6901 echo "checking for X defines extracted by xmkmf" 1>&6
6908 echo "configure:6909: checking for X defines extracted by xmkmf" >&5 6902 echo "configure:6903: checking for X defines extracted by xmkmf" >&5
6909 rm -fr conftestdir 6903 rm -fr conftestdir
6910 if mkdir conftestdir; then 6904 if mkdir conftestdir; then
6911 cd conftestdir 6905 cd conftestdir
6912 cat > Imakefile <<'EOF' 6906 cat > Imakefile <<'EOF'
6913 xetest: 6907 xetest:
6952 done 6946 done
6953 fi 6947 fi
6954 6948
6955 ac_safe=`echo "X11/Intrinsic.h" | sed 'y%./+-%__p_%'` 6949 ac_safe=`echo "X11/Intrinsic.h" | sed 'y%./+-%__p_%'`
6956 echo $ac_n "checking for X11/Intrinsic.h""... $ac_c" 1>&6 6950 echo $ac_n "checking for X11/Intrinsic.h""... $ac_c" 1>&6
6957 echo "configure:6958: checking for X11/Intrinsic.h" >&5 6951 echo "configure:6952: checking for X11/Intrinsic.h" >&5
6958 6952
6959 cat > conftest.$ac_ext <<EOF 6953 cat > conftest.$ac_ext <<EOF
6960 #line 6961 "configure" 6954 #line 6955 "configure"
6961 #include "confdefs.h" 6955 #include "confdefs.h"
6962 #include <X11/Intrinsic.h> 6956 #include <X11/Intrinsic.h>
6963 EOF 6957 EOF
6964 ac_try="$ac_cpp conftest.$ac_ext >/dev/null 2>conftest.out" 6958 ac_try="$ac_cpp conftest.$ac_ext >/dev/null 2>conftest.out"
6965 { (eval echo configure:6966: \"$ac_try\") 1>&5; (eval $ac_try) 2>&5; } 6959 { (eval echo configure:6960: \"$ac_try\") 1>&5; (eval $ac_try) 2>&5; }
6966 ac_err=`grep -v '^ *+' conftest.out | grep -v "^conftest.${ac_ext}\$"` 6960 ac_err=`grep -v '^ *+' conftest.out | grep -v "^conftest.${ac_ext}\$"`
6967 if test -z "$ac_err"; then 6961 if test -z "$ac_err"; then
6968 rm -rf conftest* 6962 rm -rf conftest*
6969 eval "ac_cv_header_$ac_safe=yes" 6963 eval "ac_cv_header_$ac_safe=yes"
6970 else 6964 else
6984 fi 6978 fi
6985 6979
6986 6980
6987 6981
6988 echo $ac_n "checking for XOpenDisplay in -lX11""... $ac_c" 1>&6 6982 echo $ac_n "checking for XOpenDisplay in -lX11""... $ac_c" 1>&6
6989 echo "configure:6990: checking for XOpenDisplay in -lX11" >&5 6983 echo "configure:6984: checking for XOpenDisplay in -lX11" >&5
6990 ac_lib_var=`echo X11'_'XOpenDisplay | sed 'y%./+-%__p_%'` 6984 ac_lib_var=`echo X11'_'XOpenDisplay | sed 'y%./+-%__p_%'`
6991 6985
6992 xe_check_libs=" -lX11 " 6986 xe_check_libs=" -lX11 "
6993 cat > conftest.$ac_ext <<EOF 6987 cat > conftest.$ac_ext <<EOF
6994 #line 6995 "configure" 6988 #line 6989 "configure"
6995 #include "confdefs.h" 6989 #include "confdefs.h"
6996 /* Override any gcc2 internal prototype to avoid an error. */ 6990 /* Override any gcc2 internal prototype to avoid an error. */
6997 /* We use char because int might match the return type of a gcc2 6991 /* We use char because int might match the return type of a gcc2
6998 builtin and then its argument prototype would still apply. */ 6992 builtin and then its argument prototype would still apply. */
6999 char XOpenDisplay(); 6993 char XOpenDisplay();
7000 6994
7001 int main() { 6995 int main() {
7002 XOpenDisplay() 6996 XOpenDisplay()
7003 ; return 0; } 6997 ; return 0; }
7004 EOF 6998 EOF
7005 if { (eval echo configure:7006: \"$ac_link\") 1>&5; (eval $ac_link) 2>&5; } && test -s conftest${ac_exeext}; then 6999 if { (eval echo configure:7000: \"$ac_link\") 1>&5; (eval $ac_link) 2>&5; } && test -s conftest${ac_exeext}; then
7006 rm -rf conftest* 7000 rm -rf conftest*
7007 eval "ac_cv_lib_$ac_lib_var=yes" 7001 eval "ac_cv_lib_$ac_lib_var=yes"
7008 else 7002 else
7009 echo "configure: failed program was:" >&5 7003 echo "configure: failed program was:" >&5
7010 cat conftest.$ac_ext >&5 7004 cat conftest.$ac_ext >&5
7025 if test "$have_lib_x11" != "yes"; then 7019 if test "$have_lib_x11" != "yes"; then
7026 7020
7027 xe_msg_checking="for XGetFontProperty in -lX11" 7021 xe_msg_checking="for XGetFontProperty in -lX11"
7028 test -n "-b i486-linuxaout" && xe_msg_checking="$xe_msg_checking using extra libs -b i486-linuxaout" 7022 test -n "-b i486-linuxaout" && xe_msg_checking="$xe_msg_checking using extra libs -b i486-linuxaout"
7029 echo $ac_n "checking "$xe_msg_checking"""... $ac_c" 1>&6 7023 echo $ac_n "checking "$xe_msg_checking"""... $ac_c" 1>&6
7030 echo "configure:7031: checking "$xe_msg_checking"" >&5 7024 echo "configure:7025: checking "$xe_msg_checking"" >&5
7031 ac_lib_var=`echo X11'_'XGetFontProperty | sed 'y%./+-%__p_%'` 7025 ac_lib_var=`echo X11'_'XGetFontProperty | sed 'y%./+-%__p_%'`
7032 7026
7033 xe_check_libs=" -lX11 -b i486-linuxaout" 7027 xe_check_libs=" -lX11 -b i486-linuxaout"
7034 cat > conftest.$ac_ext <<EOF 7028 cat > conftest.$ac_ext <<EOF
7035 #line 7036 "configure" 7029 #line 7030 "configure"
7036 #include "confdefs.h" 7030 #include "confdefs.h"
7037 /* Override any gcc2 internal prototype to avoid an error. */ 7031 /* Override any gcc2 internal prototype to avoid an error. */
7038 /* We use char because int might match the return type of a gcc2 7032 /* We use char because int might match the return type of a gcc2
7039 builtin and then its argument prototype would still apply. */ 7033 builtin and then its argument prototype would still apply. */
7040 char XGetFontProperty(); 7034 char XGetFontProperty();
7041 7035
7042 int main() { 7036 int main() {
7043 XGetFontProperty() 7037 XGetFontProperty()
7044 ; return 0; } 7038 ; return 0; }
7045 EOF 7039 EOF
7046 if { (eval echo configure:7047: \"$ac_link\") 1>&5; (eval $ac_link) 2>&5; } && test -s conftest${ac_exeext}; then 7040 if { (eval echo configure:7041: \"$ac_link\") 1>&5; (eval $ac_link) 2>&5; } && test -s conftest${ac_exeext}; then
7047 rm -rf conftest* 7041 rm -rf conftest*
7048 eval "ac_cv_lib_$ac_lib_var=yes" 7042 eval "ac_cv_lib_$ac_lib_var=yes"
7049 else 7043 else
7050 echo "configure: failed program was:" >&5 7044 echo "configure: failed program was:" >&5
7051 cat conftest.$ac_ext >&5 7045 cat conftest.$ac_ext >&5
7068 libs_x="-lX11" 7062 libs_x="-lX11"
7069 test "$extra_verbose" = "yes" && echo " Setting libs_x to \"-lX11\"" 7063 test "$extra_verbose" = "yes" && echo " Setting libs_x to \"-lX11\""
7070 7064
7071 7065
7072 echo $ac_n "checking for XShapeSelectInput in -lXext""... $ac_c" 1>&6 7066 echo $ac_n "checking for XShapeSelectInput in -lXext""... $ac_c" 1>&6
7073 echo "configure:7074: checking for XShapeSelectInput in -lXext" >&5 7067 echo "configure:7068: checking for XShapeSelectInput in -lXext" >&5
7074 ac_lib_var=`echo Xext'_'XShapeSelectInput | sed 'y%./+-%__p_%'` 7068 ac_lib_var=`echo Xext'_'XShapeSelectInput | sed 'y%./+-%__p_%'`
7075 7069
7076 xe_check_libs=" -lXext " 7070 xe_check_libs=" -lXext "
7077 cat > conftest.$ac_ext <<EOF 7071 cat > conftest.$ac_ext <<EOF
7078 #line 7079 "configure" 7072 #line 7073 "configure"
7079 #include "confdefs.h" 7073 #include "confdefs.h"
7080 /* Override any gcc2 internal prototype to avoid an error. */ 7074 /* Override any gcc2 internal prototype to avoid an error. */
7081 /* We use char because int might match the return type of a gcc2 7075 /* We use char because int might match the return type of a gcc2
7082 builtin and then its argument prototype would still apply. */ 7076 builtin and then its argument prototype would still apply. */
7083 char XShapeSelectInput(); 7077 char XShapeSelectInput();
7084 7078
7085 int main() { 7079 int main() {
7086 XShapeSelectInput() 7080 XShapeSelectInput()
7087 ; return 0; } 7081 ; return 0; }
7088 EOF 7082 EOF
7089 if { (eval echo configure:7090: \"$ac_link\") 1>&5; (eval $ac_link) 2>&5; } && test -s conftest${ac_exeext}; then 7083 if { (eval echo configure:7084: \"$ac_link\") 1>&5; (eval $ac_link) 2>&5; } && test -s conftest${ac_exeext}; then
7090 rm -rf conftest* 7084 rm -rf conftest*
7091 eval "ac_cv_lib_$ac_lib_var=yes" 7085 eval "ac_cv_lib_$ac_lib_var=yes"
7092 else 7086 else
7093 echo "configure: failed program was:" >&5 7087 echo "configure: failed program was:" >&5
7094 cat conftest.$ac_ext >&5 7088 cat conftest.$ac_ext >&5
7107 7101
7108 7102
7109 7103
7110 7104
7111 echo $ac_n "checking for XtOpenDisplay in -lXt""... $ac_c" 1>&6 7105 echo $ac_n "checking for XtOpenDisplay in -lXt""... $ac_c" 1>&6
7112 echo "configure:7113: checking for XtOpenDisplay in -lXt" >&5 7106 echo "configure:7107: checking for XtOpenDisplay in -lXt" >&5
7113 ac_lib_var=`echo Xt'_'XtOpenDisplay | sed 'y%./+-%__p_%'` 7107 ac_lib_var=`echo Xt'_'XtOpenDisplay | sed 'y%./+-%__p_%'`
7114 7108
7115 xe_check_libs=" -lXt " 7109 xe_check_libs=" -lXt "
7116 cat > conftest.$ac_ext <<EOF 7110 cat > conftest.$ac_ext <<EOF
7117 #line 7118 "configure" 7111 #line 7112 "configure"
7118 #include "confdefs.h" 7112 #include "confdefs.h"
7119 /* Override any gcc2 internal prototype to avoid an error. */ 7113 /* Override any gcc2 internal prototype to avoid an error. */
7120 /* We use char because int might match the return type of a gcc2 7114 /* We use char because int might match the return type of a gcc2
7121 builtin and then its argument prototype would still apply. */ 7115 builtin and then its argument prototype would still apply. */
7122 char XtOpenDisplay(); 7116 char XtOpenDisplay();
7123 7117
7124 int main() { 7118 int main() {
7125 XtOpenDisplay() 7119 XtOpenDisplay()
7126 ; return 0; } 7120 ; return 0; }
7127 EOF 7121 EOF
7128 if { (eval echo configure:7129: \"$ac_link\") 1>&5; (eval $ac_link) 2>&5; } && test -s conftest${ac_exeext}; then 7122 if { (eval echo configure:7123: \"$ac_link\") 1>&5; (eval $ac_link) 2>&5; } && test -s conftest${ac_exeext}; then
7129 rm -rf conftest* 7123 rm -rf conftest*
7130 eval "ac_cv_lib_$ac_lib_var=yes" 7124 eval "ac_cv_lib_$ac_lib_var=yes"
7131 else 7125 else
7132 echo "configure: failed program was:" >&5 7126 echo "configure: failed program was:" >&5
7133 cat conftest.$ac_ext >&5 7127 cat conftest.$ac_ext >&5
7146 fi 7140 fi
7147 7141
7148 7142
7149 7143
7150 echo $ac_n "checking the version of X11 being used""... $ac_c" 1>&6 7144 echo $ac_n "checking the version of X11 being used""... $ac_c" 1>&6
7151 echo "configure:7152: checking the version of X11 being used" >&5 7145 echo "configure:7146: checking the version of X11 being used" >&5
7152 cat > conftest.$ac_ext <<EOF 7146 cat > conftest.$ac_ext <<EOF
7153 #line 7154 "configure" 7147 #line 7148 "configure"
7154 #include "confdefs.h" 7148 #include "confdefs.h"
7155 #include <X11/Intrinsic.h> 7149 #include <X11/Intrinsic.h>
7156 int main(int c, char *v[]) { return c>1 ? XlibSpecificationRelease : 0; } 7150 int main(int c, char *v[]) { return c>1 ? XlibSpecificationRelease : 0; }
7157 EOF 7151 EOF
7158 if { (eval echo configure:7159: \"$ac_link\") 1>&5; (eval $ac_link) 2>&5; } && test -s conftest && (./conftest; exit $?) 2>&5 7152 if { (eval echo configure:7153: \"$ac_link\") 1>&5; (eval $ac_link) 2>&5; } && test -s conftest && (./conftest; exit $?) 2>&5
7159 then 7153 then
7160 ./conftest foobar; x11_release=$? 7154 ./conftest foobar; x11_release=$?
7161 else 7155 else
7162 conftest_rc="$?" 7156 conftest_rc="$?"
7163 echo "configure: failed program was:" >&5 7157 echo "configure: failed program was:" >&5
7184 fi 7178 fi
7185 7179
7186 for ac_func in XConvertCase 7180 for ac_func in XConvertCase
7187 do 7181 do
7188 echo $ac_n "checking for $ac_func""... $ac_c" 1>&6 7182 echo $ac_n "checking for $ac_func""... $ac_c" 1>&6
7189 echo "configure:7190: checking for $ac_func" >&5 7183 echo "configure:7184: checking for $ac_func" >&5
7190 7184
7191 cat > conftest.$ac_ext <<EOF 7185 cat > conftest.$ac_ext <<EOF
7192 #line 7193 "configure" 7186 #line 7187 "configure"
7193 #include "confdefs.h" 7187 #include "confdefs.h"
7194 /* System header to define __stub macros and hopefully few prototypes, 7188 /* System header to define __stub macros and hopefully few prototypes,
7195 which can conflict with char $ac_func(); below. */ 7189 which can conflict with char $ac_func(); below. */
7196 #include <assert.h> 7190 #include <assert.h>
7197 /* Override any gcc2 internal prototype to avoid an error. */ 7191 /* Override any gcc2 internal prototype to avoid an error. */
7210 $ac_func(); 7204 $ac_func();
7211 #endif 7205 #endif
7212 7206
7213 ; return 0; } 7207 ; return 0; }
7214 EOF 7208 EOF
7215 if { (eval echo configure:7216: \"$ac_link\") 1>&5; (eval $ac_link) 2>&5; } && test -s conftest${ac_exeext}; then 7209 if { (eval echo configure:7210: \"$ac_link\") 1>&5; (eval $ac_link) 2>&5; } && test -s conftest${ac_exeext}; then
7216 rm -rf conftest* 7210 rm -rf conftest*
7217 eval "ac_cv_func_$ac_func=yes" 7211 eval "ac_cv_func_$ac_func=yes"
7218 else 7212 else
7219 echo "configure: failed program was:" >&5 7213 echo "configure: failed program was:" >&5
7220 cat conftest.$ac_ext >&5 7214 cat conftest.$ac_ext >&5
7242 7236
7243 for ac_hdr in X11/Xlocale.h 7237 for ac_hdr in X11/Xlocale.h
7244 do 7238 do
7245 ac_safe=`echo "$ac_hdr" | sed 'y%./+-%__p_%'` 7239 ac_safe=`echo "$ac_hdr" | sed 'y%./+-%__p_%'`
7246 echo $ac_n "checking for $ac_hdr""... $ac_c" 1>&6 7240 echo $ac_n "checking for $ac_hdr""... $ac_c" 1>&6
7247 echo "configure:7248: checking for $ac_hdr" >&5 7241 echo "configure:7242: checking for $ac_hdr" >&5
7248 7242
7249 cat > conftest.$ac_ext <<EOF 7243 cat > conftest.$ac_ext <<EOF
7250 #line 7251 "configure" 7244 #line 7245 "configure"
7251 #include "confdefs.h" 7245 #include "confdefs.h"
7252 #include <$ac_hdr> 7246 #include <$ac_hdr>
7253 EOF 7247 EOF
7254 ac_try="$ac_cpp conftest.$ac_ext >/dev/null 2>conftest.out" 7248 ac_try="$ac_cpp conftest.$ac_ext >/dev/null 2>conftest.out"
7255 { (eval echo configure:7256: \"$ac_try\") 1>&5; (eval $ac_try) 2>&5; } 7249 { (eval echo configure:7250: \"$ac_try\") 1>&5; (eval $ac_try) 2>&5; }
7256 ac_err=`grep -v '^ *+' conftest.out | grep -v "^conftest.${ac_ext}\$"` 7250 ac_err=`grep -v '^ *+' conftest.out | grep -v "^conftest.${ac_ext}\$"`
7257 if test -z "$ac_err"; then 7251 if test -z "$ac_err"; then
7258 rm -rf conftest* 7252 rm -rf conftest*
7259 eval "ac_cv_header_$ac_safe=yes" 7253 eval "ac_cv_header_$ac_safe=yes"
7260 else 7254 else
7283 7277
7284 7278
7285 for ac_func in XRegisterIMInstantiateCallback 7279 for ac_func in XRegisterIMInstantiateCallback
7286 do 7280 do
7287 echo $ac_n "checking for $ac_func""... $ac_c" 1>&6 7281 echo $ac_n "checking for $ac_func""... $ac_c" 1>&6
7288 echo "configure:7289: checking for $ac_func" >&5 7282 echo "configure:7283: checking for $ac_func" >&5
7289 7283
7290 cat > conftest.$ac_ext <<EOF 7284 cat > conftest.$ac_ext <<EOF
7291 #line 7292 "configure" 7285 #line 7286 "configure"
7292 #include "confdefs.h" 7286 #include "confdefs.h"
7293 /* System header to define __stub macros and hopefully few prototypes, 7287 /* System header to define __stub macros and hopefully few prototypes,
7294 which can conflict with char $ac_func(); below. */ 7288 which can conflict with char $ac_func(); below. */
7295 #include <assert.h> 7289 #include <assert.h>
7296 /* Override any gcc2 internal prototype to avoid an error. */ 7290 /* Override any gcc2 internal prototype to avoid an error. */
7309 $ac_func(); 7303 $ac_func();
7310 #endif 7304 #endif
7311 7305
7312 ; return 0; } 7306 ; return 0; }
7313 EOF 7307 EOF
7314 if { (eval echo configure:7315: \"$ac_link\") 1>&5; (eval $ac_link) 2>&5; } && test -s conftest${ac_exeext}; then 7308 if { (eval echo configure:7309: \"$ac_link\") 1>&5; (eval $ac_link) 2>&5; } && test -s conftest${ac_exeext}; then
7315 rm -rf conftest* 7309 rm -rf conftest*
7316 eval "ac_cv_func_$ac_func=yes" 7310 eval "ac_cv_func_$ac_func=yes"
7317 else 7311 else
7318 echo "configure: failed program was:" >&5 7312 echo "configure: failed program was:" >&5
7319 cat conftest.$ac_ext >&5 7313 cat conftest.$ac_ext >&5
7337 echo "$ac_t""no" 1>&6 7331 echo "$ac_t""no" 1>&6
7338 fi 7332 fi
7339 done 7333 done
7340 7334
7341 echo $ac_n "checking for standard XRegisterIMInstantiateCallback prototype""... $ac_c" 1>&6 7335 echo $ac_n "checking for standard XRegisterIMInstantiateCallback prototype""... $ac_c" 1>&6
7342 echo "configure:7343: checking for standard XRegisterIMInstantiateCallback prototype" >&5 7336 echo "configure:7337: checking for standard XRegisterIMInstantiateCallback prototype" >&5
7343 cat > conftest.$ac_ext <<EOF 7337 cat > conftest.$ac_ext <<EOF
7344 #line 7345 "configure" 7338 #line 7339 "configure"
7345 #include "confdefs.h" 7339 #include "confdefs.h"
7346 7340
7347 #define NeedFunctionPrototypes 1 7341 #define NeedFunctionPrototypes 1
7348 #include <X11/Xlib.h> 7342 #include <X11/Xlib.h>
7349 extern Bool XRegisterIMInstantiateCallback( 7343 extern Bool XRegisterIMInstantiateCallback(
7351 7345
7352 int main() { 7346 int main() {
7353 7347
7354 ; return 0; } 7348 ; return 0; }
7355 EOF 7349 EOF
7356 if { (eval echo configure:7357: \"$ac_compile\") 1>&5; (eval $ac_compile) 2>&5; }; then 7350 if { (eval echo configure:7351: \"$ac_compile\") 1>&5; (eval $ac_compile) 2>&5; }; then
7357 rm -rf conftest* 7351 rm -rf conftest*
7358 echo "$ac_t""yes" 1>&6 7352 echo "$ac_t""yes" 1>&6
7359 else 7353 else
7360 echo "configure: failed program was:" >&5 7354 echo "configure: failed program was:" >&5
7361 cat conftest.$ac_ext >&5 7355 cat conftest.$ac_ext >&5
7372 fi 7366 fi
7373 rm -f conftest* 7367 rm -f conftest*
7374 7368
7375 test -z "$with_xmu" && { 7369 test -z "$with_xmu" && {
7376 echo $ac_n "checking for XmuReadBitmapDataFromFile in -lXmu""... $ac_c" 1>&6 7370 echo $ac_n "checking for XmuReadBitmapDataFromFile in -lXmu""... $ac_c" 1>&6
7377 echo "configure:7378: checking for XmuReadBitmapDataFromFile in -lXmu" >&5 7371 echo "configure:7372: checking for XmuReadBitmapDataFromFile in -lXmu" >&5
7378 ac_lib_var=`echo Xmu'_'XmuReadBitmapDataFromFile | sed 'y%./+-%__p_%'` 7372 ac_lib_var=`echo Xmu'_'XmuReadBitmapDataFromFile | sed 'y%./+-%__p_%'`
7379 7373
7380 xe_check_libs=" -lXmu " 7374 xe_check_libs=" -lXmu "
7381 cat > conftest.$ac_ext <<EOF 7375 cat > conftest.$ac_ext <<EOF
7382 #line 7383 "configure" 7376 #line 7377 "configure"
7383 #include "confdefs.h" 7377 #include "confdefs.h"
7384 /* Override any gcc2 internal prototype to avoid an error. */ 7378 /* Override any gcc2 internal prototype to avoid an error. */
7385 /* We use char because int might match the return type of a gcc2 7379 /* We use char because int might match the return type of a gcc2
7386 builtin and then its argument prototype would still apply. */ 7380 builtin and then its argument prototype would still apply. */
7387 char XmuReadBitmapDataFromFile(); 7381 char XmuReadBitmapDataFromFile();
7388 7382
7389 int main() { 7383 int main() {
7390 XmuReadBitmapDataFromFile() 7384 XmuReadBitmapDataFromFile()
7391 ; return 0; } 7385 ; return 0; }
7392 EOF 7386 EOF
7393 if { (eval echo configure:7394: \"$ac_link\") 1>&5; (eval $ac_link) 2>&5; } && test -s conftest${ac_exeext}; then 7387 if { (eval echo configure:7388: \"$ac_link\") 1>&5; (eval $ac_link) 2>&5; } && test -s conftest${ac_exeext}; then
7394 rm -rf conftest* 7388 rm -rf conftest*
7395 eval "ac_cv_lib_$ac_lib_var=yes" 7389 eval "ac_cv_lib_$ac_lib_var=yes"
7396 else 7390 else
7397 echo "configure: failed program was:" >&5 7391 echo "configure: failed program was:" >&5
7398 cat conftest.$ac_ext >&5 7392 cat conftest.$ac_ext >&5
7427 7421
7428 fi 7422 fi
7429 7423
7430 7424
7431 echo $ac_n "checking for main in -lXbsd""... $ac_c" 1>&6 7425 echo $ac_n "checking for main in -lXbsd""... $ac_c" 1>&6
7432 echo "configure:7433: checking for main in -lXbsd" >&5 7426 echo "configure:7427: checking for main in -lXbsd" >&5
7433 ac_lib_var=`echo Xbsd'_'main | sed 'y%./+-%__p_%'` 7427 ac_lib_var=`echo Xbsd'_'main | sed 'y%./+-%__p_%'`
7434 7428
7435 xe_check_libs=" -lXbsd " 7429 xe_check_libs=" -lXbsd "
7436 cat > conftest.$ac_ext <<EOF 7430 cat > conftest.$ac_ext <<EOF
7437 #line 7438 "configure" 7431 #line 7432 "configure"
7438 #include "confdefs.h" 7432 #include "confdefs.h"
7439 7433
7440 int main() { 7434 int main() {
7441 main() 7435 main()
7442 ; return 0; } 7436 ; return 0; }
7443 EOF 7437 EOF
7444 if { (eval echo configure:7445: \"$ac_link\") 1>&5; (eval $ac_link) 2>&5; } && test -s conftest${ac_exeext}; then 7438 if { (eval echo configure:7439: \"$ac_link\") 1>&5; (eval $ac_link) 2>&5; } && test -s conftest${ac_exeext}; then
7445 rm -rf conftest* 7439 rm -rf conftest*
7446 eval "ac_cv_lib_$ac_lib_var=yes" 7440 eval "ac_cv_lib_$ac_lib_var=yes"
7447 else 7441 else
7448 echo "configure: failed program was:" >&5 7442 echo "configure: failed program was:" >&5
7449 cat conftest.$ac_ext >&5 7443 cat conftest.$ac_ext >&5
7476 fi 7470 fi
7477 7471
7478 fi 7472 fi
7479 if test "$with_msw" != "no"; then 7473 if test "$with_msw" != "no"; then
7480 echo "checking for MS-Windows" 1>&6 7474 echo "checking for MS-Windows" 1>&6
7481 echo "configure:7482: checking for MS-Windows" >&5 7475 echo "configure:7476: checking for MS-Windows" >&5
7482 7476
7483 echo $ac_n "checking for main in -lgdi32""... $ac_c" 1>&6 7477 echo $ac_n "checking for main in -lgdi32""... $ac_c" 1>&6
7484 echo "configure:7485: checking for main in -lgdi32" >&5 7478 echo "configure:7479: checking for main in -lgdi32" >&5
7485 ac_lib_var=`echo gdi32'_'main | sed 'y%./+-%__p_%'` 7479 ac_lib_var=`echo gdi32'_'main | sed 'y%./+-%__p_%'`
7486 7480
7487 xe_check_libs=" -lgdi32 " 7481 xe_check_libs=" -lgdi32 "
7488 cat > conftest.$ac_ext <<EOF 7482 cat > conftest.$ac_ext <<EOF
7489 #line 7490 "configure" 7483 #line 7484 "configure"
7490 #include "confdefs.h" 7484 #include "confdefs.h"
7491 7485
7492 int main() { 7486 int main() {
7493 main() 7487 main()
7494 ; return 0; } 7488 ; return 0; }
7495 EOF 7489 EOF
7496 if { (eval echo configure:7497: \"$ac_link\") 1>&5; (eval $ac_link) 2>&5; } && test -s conftest${ac_exeext}; then 7490 if { (eval echo configure:7491: \"$ac_link\") 1>&5; (eval $ac_link) 2>&5; } && test -s conftest${ac_exeext}; then
7497 rm -rf conftest* 7491 rm -rf conftest*
7498 eval "ac_cv_lib_$ac_lib_var=yes" 7492 eval "ac_cv_lib_$ac_lib_var=yes"
7499 else 7493 else
7500 echo "configure: failed program was:" >&5 7494 echo "configure: failed program was:" >&5
7501 cat conftest.$ac_ext >&5 7495 cat conftest.$ac_ext >&5
7542 test "$with_toolbars" != "no" && with_toolbars=msw 7536 test "$with_toolbars" != "no" && with_toolbars=msw
7543 test "$with_dialogs" != "no" && with_dialogs=msw 7537 test "$with_dialogs" != "no" && with_dialogs=msw
7544 test "$with_widgets" != "no" && with_widgets=msw 7538 test "$with_widgets" != "no" && with_widgets=msw
7545 fi 7539 fi
7546 cat > conftest.$ac_ext <<EOF 7540 cat > conftest.$ac_ext <<EOF
7547 #line 7548 "configure" 7541 #line 7542 "configure"
7548 #include "confdefs.h" 7542 #include "confdefs.h"
7549 #include <fcntl.h> 7543 #include <fcntl.h>
7550 int main() { return (open("/dev/windows", O_RDONLY, 0) > 0)? 0 : 1; } 7544 int main() { return (open("/dev/windows", O_RDONLY, 0) > 0)? 0 : 1; }
7551 EOF 7545 EOF
7552 if { (eval echo configure:7553: \"$ac_link\") 1>&5; (eval $ac_link) 2>&5; } && test -s conftest && (./conftest; exit $?) 2>&5 7546 if { (eval echo configure:7547: \"$ac_link\") 1>&5; (eval $ac_link) 2>&5; } && test -s conftest && (./conftest; exit $?) 2>&5
7553 then 7547 then
7554 { test "$extra_verbose" = "yes" && cat << \EOF 7548 { test "$extra_verbose" = "yes" && cat << \EOF
7555 Defining HAVE_MSG_SELECT 7549 Defining HAVE_MSG_SELECT
7556 EOF 7550 EOF
7557 cat >> confdefs.h <<\EOF 7551 cat >> confdefs.h <<\EOF
7608 fi 7602 fi
7609 7603
7610 if test "$with_x11" = "yes"; then 7604 if test "$with_x11" = "yes"; then
7611 ac_safe=`echo "X11/extensions/shape.h" | sed 'y%./+-%__p_%'` 7605 ac_safe=`echo "X11/extensions/shape.h" | sed 'y%./+-%__p_%'`
7612 echo $ac_n "checking for X11/extensions/shape.h""... $ac_c" 1>&6 7606 echo $ac_n "checking for X11/extensions/shape.h""... $ac_c" 1>&6
7613 echo "configure:7614: checking for X11/extensions/shape.h" >&5 7607 echo "configure:7608: checking for X11/extensions/shape.h" >&5
7614 7608
7615 cat > conftest.$ac_ext <<EOF 7609 cat > conftest.$ac_ext <<EOF
7616 #line 7617 "configure" 7610 #line 7611 "configure"
7617 #include "confdefs.h" 7611 #include "confdefs.h"
7618 #include <X11/extensions/shape.h> 7612 #include <X11/extensions/shape.h>
7619 EOF 7613 EOF
7620 ac_try="$ac_cpp conftest.$ac_ext >/dev/null 2>conftest.out" 7614 ac_try="$ac_cpp conftest.$ac_ext >/dev/null 2>conftest.out"
7621 { (eval echo configure:7622: \"$ac_try\") 1>&5; (eval $ac_try) 2>&5; } 7615 { (eval echo configure:7616: \"$ac_try\") 1>&5; (eval $ac_try) 2>&5; }
7622 ac_err=`grep -v '^ *+' conftest.out | grep -v "^conftest.${ac_ext}\$"` 7616 ac_err=`grep -v '^ *+' conftest.out | grep -v "^conftest.${ac_ext}\$"`
7623 if test -z "$ac_err"; then 7617 if test -z "$ac_err"; then
7624 rm -rf conftest* 7618 rm -rf conftest*
7625 eval "ac_cv_header_$ac_safe=yes" 7619 eval "ac_cv_header_$ac_safe=yes"
7626 else 7620 else
7666 test "$opsys" = "hpux9" && opsysfile="s/hpux9-x11r4.h" 7660 test "$opsys" = "hpux9" && opsysfile="s/hpux9-x11r4.h"
7667 test "$opsys" = "hpux9-shr" && opsysfile="s/hpux9shxr4.h" 7661 test "$opsys" = "hpux9-shr" && opsysfile="s/hpux9shxr4.h"
7668 esac 7662 esac
7669 7663
7670 echo "checking for WM_COMMAND option" 1>&6 7664 echo "checking for WM_COMMAND option" 1>&6
7671 echo "configure:7672: checking for WM_COMMAND option" >&5; 7665 echo "configure:7666: checking for WM_COMMAND option" >&5;
7672 if test "$with_wmcommand" != "no"; then 7666 if test "$with_wmcommand" != "no"; then
7673 { test "$extra_verbose" = "yes" && cat << \EOF 7667 { test "$extra_verbose" = "yes" && cat << \EOF
7674 Defining HAVE_WMCOMMAND 7668 Defining HAVE_WMCOMMAND
7675 EOF 7669 EOF
7676 cat >> confdefs.h <<\EOF 7670 cat >> confdefs.h <<\EOF
7681 fi 7675 fi
7682 7676
7683 test -z "$with_xauth" && test "$window_system" = "none" && with_xauth=no 7677 test -z "$with_xauth" && test "$window_system" = "none" && with_xauth=no
7684 test -z "$with_xauth" && { ac_safe=`echo "X11/Xauth.h" | sed 'y%./+-%__p_%'` 7678 test -z "$with_xauth" && { ac_safe=`echo "X11/Xauth.h" | sed 'y%./+-%__p_%'`
7685 echo $ac_n "checking for X11/Xauth.h""... $ac_c" 1>&6 7679 echo $ac_n "checking for X11/Xauth.h""... $ac_c" 1>&6
7686 echo "configure:7687: checking for X11/Xauth.h" >&5 7680 echo "configure:7681: checking for X11/Xauth.h" >&5
7687 7681
7688 cat > conftest.$ac_ext <<EOF 7682 cat > conftest.$ac_ext <<EOF
7689 #line 7690 "configure" 7683 #line 7684 "configure"
7690 #include "confdefs.h" 7684 #include "confdefs.h"
7691 #include <X11/Xauth.h> 7685 #include <X11/Xauth.h>
7692 EOF 7686 EOF
7693 ac_try="$ac_cpp conftest.$ac_ext >/dev/null 2>conftest.out" 7687 ac_try="$ac_cpp conftest.$ac_ext >/dev/null 2>conftest.out"
7694 { (eval echo configure:7695: \"$ac_try\") 1>&5; (eval $ac_try) 2>&5; } 7688 { (eval echo configure:7689: \"$ac_try\") 1>&5; (eval $ac_try) 2>&5; }
7695 ac_err=`grep -v '^ *+' conftest.out | grep -v "^conftest.${ac_ext}\$"` 7689 ac_err=`grep -v '^ *+' conftest.out | grep -v "^conftest.${ac_ext}\$"`
7696 if test -z "$ac_err"; then 7690 if test -z "$ac_err"; then
7697 rm -rf conftest* 7691 rm -rf conftest*
7698 eval "ac_cv_header_$ac_safe=yes" 7692 eval "ac_cv_header_$ac_safe=yes"
7699 else 7693 else
7712 with_xauth=no 7706 with_xauth=no
7713 fi 7707 fi
7714 } 7708 }
7715 test -z "$with_xauth" && { 7709 test -z "$with_xauth" && {
7716 echo $ac_n "checking for XauGetAuthByAddr in -lXau""... $ac_c" 1>&6 7710 echo $ac_n "checking for XauGetAuthByAddr in -lXau""... $ac_c" 1>&6
7717 echo "configure:7718: checking for XauGetAuthByAddr in -lXau" >&5 7711 echo "configure:7712: checking for XauGetAuthByAddr in -lXau" >&5
7718 ac_lib_var=`echo Xau'_'XauGetAuthByAddr | sed 'y%./+-%__p_%'` 7712 ac_lib_var=`echo Xau'_'XauGetAuthByAddr | sed 'y%./+-%__p_%'`
7719 7713
7720 xe_check_libs=" -lXau " 7714 xe_check_libs=" -lXau "
7721 cat > conftest.$ac_ext <<EOF 7715 cat > conftest.$ac_ext <<EOF
7722 #line 7723 "configure" 7716 #line 7717 "configure"
7723 #include "confdefs.h" 7717 #include "confdefs.h"
7724 /* Override any gcc2 internal prototype to avoid an error. */ 7718 /* Override any gcc2 internal prototype to avoid an error. */
7725 /* We use char because int might match the return type of a gcc2 7719 /* We use char because int might match the return type of a gcc2
7726 builtin and then its argument prototype would still apply. */ 7720 builtin and then its argument prototype would still apply. */
7727 char XauGetAuthByAddr(); 7721 char XauGetAuthByAddr();
7728 7722
7729 int main() { 7723 int main() {
7730 XauGetAuthByAddr() 7724 XauGetAuthByAddr()
7731 ; return 0; } 7725 ; return 0; }
7732 EOF 7726 EOF
7733 if { (eval echo configure:7734: \"$ac_link\") 1>&5; (eval $ac_link) 2>&5; } && test -s conftest${ac_exeext}; then 7727 if { (eval echo configure:7728: \"$ac_link\") 1>&5; (eval $ac_link) 2>&5; } && test -s conftest${ac_exeext}; then
7734 rm -rf conftest* 7728 rm -rf conftest*
7735 eval "ac_cv_lib_$ac_lib_var=yes" 7729 eval "ac_cv_lib_$ac_lib_var=yes"
7736 else 7730 else
7737 echo "configure: failed program was:" >&5 7731 echo "configure: failed program was:" >&5
7738 cat conftest.$ac_ext >&5 7732 cat conftest.$ac_ext >&5
7779 fi 7773 fi
7780 7774
7781 7775
7782 if test "$with_modules" != "no"; then 7776 if test "$with_modules" != "no"; then
7783 echo "checking for module support" 1>&6 7777 echo "checking for module support" 1>&6
7784 echo "configure:7785: checking for module support" >&5 7778 echo "configure:7779: checking for module support" >&5
7785 7779
7786 case "$opsys" in 7780 case "$opsys" in
7787 mingw* | cygwin* ) have_dl=yes ;; 7781 mingw* | cygwin* ) have_dl=yes ;;
7788 darwin ) have_dl=yes 7782 darwin ) have_dl=yes
7789 { test "$extra_verbose" = "yes" && cat << \EOF 7783 { test "$extra_verbose" = "yes" && cat << \EOF
7796 7790
7797 ;; 7791 ;;
7798 * ) 7792 * )
7799 ac_safe=`echo "dlfcn.h" | sed 'y%./+-%__p_%'` 7793 ac_safe=`echo "dlfcn.h" | sed 'y%./+-%__p_%'`
7800 echo $ac_n "checking for dlfcn.h""... $ac_c" 1>&6 7794 echo $ac_n "checking for dlfcn.h""... $ac_c" 1>&6
7801 echo "configure:7802: checking for dlfcn.h" >&5 7795 echo "configure:7796: checking for dlfcn.h" >&5
7802 7796
7803 cat > conftest.$ac_ext <<EOF 7797 cat > conftest.$ac_ext <<EOF
7804 #line 7805 "configure" 7798 #line 7799 "configure"
7805 #include "confdefs.h" 7799 #include "confdefs.h"
7806 #include <dlfcn.h> 7800 #include <dlfcn.h>
7807 EOF 7801 EOF
7808 ac_try="$ac_cpp conftest.$ac_ext >/dev/null 2>conftest.out" 7802 ac_try="$ac_cpp conftest.$ac_ext >/dev/null 2>conftest.out"
7809 { (eval echo configure:7810: \"$ac_try\") 1>&5; (eval $ac_try) 2>&5; } 7803 { (eval echo configure:7804: \"$ac_try\") 1>&5; (eval $ac_try) 2>&5; }
7810 ac_err=`grep -v '^ *+' conftest.out | grep -v "^conftest.${ac_ext}\$"` 7804 ac_err=`grep -v '^ *+' conftest.out | grep -v "^conftest.${ac_ext}\$"`
7811 if test -z "$ac_err"; then 7805 if test -z "$ac_err"; then
7812 rm -rf conftest* 7806 rm -rf conftest*
7813 eval "ac_cv_header_$ac_safe=yes" 7807 eval "ac_cv_header_$ac_safe=yes"
7814 else 7808 else
7821 rm -f conftest* 7815 rm -f conftest*
7822 if eval "test \"`echo '$ac_cv_header_'$ac_safe`\" = yes"; then 7816 if eval "test \"`echo '$ac_cv_header_'$ac_safe`\" = yes"; then
7823 echo "$ac_t""yes" 1>&6 7817 echo "$ac_t""yes" 1>&6
7824 7818
7825 echo $ac_n "checking for dlopen in -lc""... $ac_c" 1>&6 7819 echo $ac_n "checking for dlopen in -lc""... $ac_c" 1>&6
7826 echo "configure:7827: checking for dlopen in -lc" >&5 7820 echo "configure:7821: checking for dlopen in -lc" >&5
7827 cat > conftest.$ac_ext <<EOF 7821 cat > conftest.$ac_ext <<EOF
7828 #line 7829 "configure" 7822 #line 7823 "configure"
7829 #include "confdefs.h" 7823 #include "confdefs.h"
7830 #include <dlfcn.h> 7824 #include <dlfcn.h>
7831 int main() { 7825 int main() {
7832 dlopen ("", 0); 7826 dlopen ("", 0);
7833 ; return 0; } 7827 ; return 0; }
7834 EOF 7828 EOF
7835 if { (eval echo configure:7836: \"$ac_link\") 1>&5; (eval $ac_link) 2>&5; } && test -s conftest${ac_exeext}; then 7829 if { (eval echo configure:7830: \"$ac_link\") 1>&5; (eval $ac_link) 2>&5; } && test -s conftest${ac_exeext}; then
7836 rm -rf conftest* 7830 rm -rf conftest*
7837 have_dl=yes 7831 have_dl=yes
7838 else 7832 else
7839 echo "configure: failed program was:" >&5 7833 echo "configure: failed program was:" >&5
7840 cat conftest.$ac_ext >&5 7834 cat conftest.$ac_ext >&5
7841 rm -rf conftest* 7835 rm -rf conftest*
7842 7836
7843 echo $ac_n "checking for dlopen in -ldl""... $ac_c" 1>&6 7837 echo $ac_n "checking for dlopen in -ldl""... $ac_c" 1>&6
7844 echo "configure:7845: checking for dlopen in -ldl" >&5 7838 echo "configure:7839: checking for dlopen in -ldl" >&5
7845 ac_save_LIBS="$LIBS" 7839 ac_save_LIBS="$LIBS"
7846 LIBS="$LIBS -ldl" 7840 LIBS="$LIBS -ldl"
7847 cat > conftest.$ac_ext <<EOF 7841 cat > conftest.$ac_ext <<EOF
7848 #line 7849 "configure" 7842 #line 7843 "configure"
7849 #include "confdefs.h" 7843 #include "confdefs.h"
7850 #include <dlfcn.h> 7844 #include <dlfcn.h>
7851 int main() { 7845 int main() {
7852 dlopen ("", 0); 7846 dlopen ("", 0);
7853 ; return 0; } 7847 ; return 0; }
7854 EOF 7848 EOF
7855 if { (eval echo configure:7856: \"$ac_link\") 1>&5; (eval $ac_link) 2>&5; } && test -s conftest${ac_exeext}; then 7849 if { (eval echo configure:7850: \"$ac_link\") 1>&5; (eval $ac_link) 2>&5; } && test -s conftest${ac_exeext}; then
7856 rm -rf conftest* 7850 rm -rf conftest*
7857 have_dl=yes 7851 have_dl=yes
7858 else 7852 else
7859 echo "configure: failed program was:" >&5 7853 echo "configure: failed program was:" >&5
7860 cat conftest.$ac_ext >&5 7854 cat conftest.$ac_ext >&5
7861 rm -rf conftest* 7855 rm -rf conftest*
7862 7856
7863 echo $ac_n "checking for dlopen in -lsvld""... $ac_c" 1>&6 7857 echo $ac_n "checking for dlopen in -lsvld""... $ac_c" 1>&6
7864 echo "configure:7865: checking for dlopen in -lsvld" >&5 7858 echo "configure:7859: checking for dlopen in -lsvld" >&5
7865 LIBS="$ac_save_LIBS -lsvld" 7859 LIBS="$ac_save_LIBS -lsvld"
7866 cat > conftest.$ac_ext <<EOF 7860 cat > conftest.$ac_ext <<EOF
7867 #line 7868 "configure" 7861 #line 7862 "configure"
7868 #include "confdefs.h" 7862 #include "confdefs.h"
7869 #include <dlfcn.h> 7863 #include <dlfcn.h>
7870 int main() { 7864 int main() {
7871 dlopen ("", 0); 7865 dlopen ("", 0);
7872 ; return 0; } 7866 ; return 0; }
7873 EOF 7867 EOF
7874 if { (eval echo configure:7875: \"$ac_link\") 1>&5; (eval $ac_link) 2>&5; } && test -s conftest${ac_exeext}; then 7868 if { (eval echo configure:7869: \"$ac_link\") 1>&5; (eval $ac_link) 2>&5; } && test -s conftest${ac_exeext}; then
7875 rm -rf conftest* 7869 rm -rf conftest*
7876 have_dl=yes 7870 have_dl=yes
7877 else 7871 else
7878 echo "configure: failed program was:" >&5 7872 echo "configure: failed program was:" >&5
7879 cat conftest.$ac_ext >&5 7873 cat conftest.$ac_ext >&5
7899 } 7893 }
7900 7894
7901 else 7895 else
7902 ac_safe=`echo "dl.h" | sed 'y%./+-%__p_%'` 7896 ac_safe=`echo "dl.h" | sed 'y%./+-%__p_%'`
7903 echo $ac_n "checking for dl.h""... $ac_c" 1>&6 7897 echo $ac_n "checking for dl.h""... $ac_c" 1>&6
7904 echo "configure:7905: checking for dl.h" >&5 7898 echo "configure:7899: checking for dl.h" >&5
7905 7899
7906 cat > conftest.$ac_ext <<EOF 7900 cat > conftest.$ac_ext <<EOF
7907 #line 7908 "configure" 7901 #line 7902 "configure"
7908 #include "confdefs.h" 7902 #include "confdefs.h"
7909 #include <dl.h> 7903 #include <dl.h>
7910 EOF 7904 EOF
7911 ac_try="$ac_cpp conftest.$ac_ext >/dev/null 2>conftest.out" 7905 ac_try="$ac_cpp conftest.$ac_ext >/dev/null 2>conftest.out"
7912 { (eval echo configure:7913: \"$ac_try\") 1>&5; (eval $ac_try) 2>&5; } 7906 { (eval echo configure:7907: \"$ac_try\") 1>&5; (eval $ac_try) 2>&5; }
7913 ac_err=`grep -v '^ *+' conftest.out | grep -v "^conftest.${ac_ext}\$"` 7907 ac_err=`grep -v '^ *+' conftest.out | grep -v "^conftest.${ac_ext}\$"`
7914 if test -z "$ac_err"; then 7908 if test -z "$ac_err"; then
7915 rm -rf conftest* 7909 rm -rf conftest*
7916 eval "ac_cv_header_$ac_safe=yes" 7910 eval "ac_cv_header_$ac_safe=yes"
7917 else 7911 else
7924 rm -f conftest* 7918 rm -f conftest*
7925 if eval "test \"`echo '$ac_cv_header_'$ac_safe`\" = yes"; then 7919 if eval "test \"`echo '$ac_cv_header_'$ac_safe`\" = yes"; then
7926 echo "$ac_t""yes" 1>&6 7920 echo "$ac_t""yes" 1>&6
7927 7921
7928 echo $ac_n "checking for shl_load in -lc""... $ac_c" 1>&6 7922 echo $ac_n "checking for shl_load in -lc""... $ac_c" 1>&6
7929 echo "configure:7930: checking for shl_load in -lc" >&5 7923 echo "configure:7924: checking for shl_load in -lc" >&5
7930 cat > conftest.$ac_ext <<EOF 7924 cat > conftest.$ac_ext <<EOF
7931 #line 7932 "configure" 7925 #line 7926 "configure"
7932 #include "confdefs.h" 7926 #include "confdefs.h"
7933 #include <dl.h> 7927 #include <dl.h>
7934 int main() { 7928 int main() {
7935 shl_load ("", 0, 0); 7929 shl_load ("", 0, 0);
7936 ; return 0; } 7930 ; return 0; }
7937 EOF 7931 EOF
7938 if { (eval echo configure:7939: \"$ac_link\") 1>&5; (eval $ac_link) 2>&5; } && test -s conftest${ac_exeext}; then 7932 if { (eval echo configure:7933: \"$ac_link\") 1>&5; (eval $ac_link) 2>&5; } && test -s conftest${ac_exeext}; then
7939 rm -rf conftest* 7933 rm -rf conftest*
7940 have_dl=yes 7934 have_dl=yes
7941 else 7935 else
7942 echo "configure: failed program was:" >&5 7936 echo "configure: failed program was:" >&5
7943 cat conftest.$ac_ext >&5 7937 cat conftest.$ac_ext >&5
7944 rm -rf conftest* 7938 rm -rf conftest*
7945 7939
7946 echo $ac_n "checking for shl_load in -ldl""... $ac_c" 1>&6 7940 echo $ac_n "checking for shl_load in -ldl""... $ac_c" 1>&6
7947 echo "configure:7948: checking for shl_load in -ldl" >&5 7941 echo "configure:7942: checking for shl_load in -ldl" >&5
7948 ac_save_LIBS="$LIBS" 7942 ac_save_LIBS="$LIBS"
7949 LIBS="$LIBS -ldld" 7943 LIBS="$LIBS -ldld"
7950 cat > conftest.$ac_ext <<EOF 7944 cat > conftest.$ac_ext <<EOF
7951 #line 7952 "configure" 7945 #line 7946 "configure"
7952 #include "confdefs.h" 7946 #include "confdefs.h"
7953 #include <dl.h> 7947 #include <dl.h>
7954 int main() { 7948 int main() {
7955 shl_load ("", 0, 0); 7949 shl_load ("", 0, 0);
7956 ; return 0; } 7950 ; return 0; }
7957 EOF 7951 EOF
7958 if { (eval echo configure:7959: \"$ac_link\") 1>&5; (eval $ac_link) 2>&5; } && test -s conftest${ac_exeext}; then 7952 if { (eval echo configure:7953: \"$ac_link\") 1>&5; (eval $ac_link) 2>&5; } && test -s conftest${ac_exeext}; then
7959 rm -rf conftest* 7953 rm -rf conftest*
7960 have_dl=yes 7954 have_dl=yes
7961 else 7955 else
7962 echo "configure: failed program was:" >&5 7956 echo "configure: failed program was:" >&5
7963 cat conftest.$ac_ext >&5 7957 cat conftest.$ac_ext >&5
7981 } 7975 }
7982 7976
7983 else 7977 else
7984 ac_safe=`echo "ltdl.h" | sed 'y%./+-%__p_%'` 7978 ac_safe=`echo "ltdl.h" | sed 'y%./+-%__p_%'`
7985 echo $ac_n "checking for ltdl.h""... $ac_c" 1>&6 7979 echo $ac_n "checking for ltdl.h""... $ac_c" 1>&6
7986 echo "configure:7987: checking for ltdl.h" >&5 7980 echo "configure:7981: checking for ltdl.h" >&5
7987 7981
7988 cat > conftest.$ac_ext <<EOF 7982 cat > conftest.$ac_ext <<EOF
7989 #line 7990 "configure" 7983 #line 7984 "configure"
7990 #include "confdefs.h" 7984 #include "confdefs.h"
7991 #include <ltdl.h> 7985 #include <ltdl.h>
7992 EOF 7986 EOF
7993 ac_try="$ac_cpp conftest.$ac_ext >/dev/null 2>conftest.out" 7987 ac_try="$ac_cpp conftest.$ac_ext >/dev/null 2>conftest.out"
7994 { (eval echo configure:7995: \"$ac_try\") 1>&5; (eval $ac_try) 2>&5; } 7988 { (eval echo configure:7989: \"$ac_try\") 1>&5; (eval $ac_try) 2>&5; }
7995 ac_err=`grep -v '^ *+' conftest.out | grep -v "^conftest.${ac_ext}\$"` 7989 ac_err=`grep -v '^ *+' conftest.out | grep -v "^conftest.${ac_ext}\$"`
7996 if test -z "$ac_err"; then 7990 if test -z "$ac_err"; then
7997 rm -rf conftest* 7991 rm -rf conftest*
7998 eval "ac_cv_header_$ac_safe=yes" 7992 eval "ac_cv_header_$ac_safe=yes"
7999 else 7993 else
8006 rm -f conftest* 8000 rm -f conftest*
8007 if eval "test \"`echo '$ac_cv_header_'$ac_safe`\" = yes"; then 8001 if eval "test \"`echo '$ac_cv_header_'$ac_safe`\" = yes"; then
8008 echo "$ac_t""yes" 1>&6 8002 echo "$ac_t""yes" 1>&6
8009 8003
8010 echo $ac_n "checking for lt_dlinit in -lltdl""... $ac_c" 1>&6 8004 echo $ac_n "checking for lt_dlinit in -lltdl""... $ac_c" 1>&6
8011 echo "configure:8012: checking for lt_dlinit in -lltdl" >&5 8005 echo "configure:8006: checking for lt_dlinit in -lltdl" >&5
8012 ac_save_LIBS="$LIBS" 8006 ac_save_LIBS="$LIBS"
8013 LIBS="$LIBS -lltdl" 8007 LIBS="$LIBS -lltdl"
8014 cat > conftest.$ac_ext <<EOF 8008 cat > conftest.$ac_ext <<EOF
8015 #line 8016 "configure" 8009 #line 8010 "configure"
8016 #include "confdefs.h" 8010 #include "confdefs.h"
8017 #include <ltdl.h> 8011 #include <ltdl.h>
8018 int main() { 8012 int main() {
8019 lt_dlinit (); 8013 lt_dlinit ();
8020 ; return 0; } 8014 ; return 0; }
8021 EOF 8015 EOF
8022 if { (eval echo configure:8023: \"$ac_link\") 1>&5; (eval $ac_link) 2>&5; } && test -s conftest${ac_exeext}; then 8016 if { (eval echo configure:8017: \"$ac_link\") 1>&5; (eval $ac_link) 2>&5; } && test -s conftest${ac_exeext}; then
8023 rm -rf conftest* 8017 rm -rf conftest*
8024 have_dl=yes 8018 have_dl=yes
8025 else 8019 else
8026 echo "configure: failed program was:" >&5 8020 echo "configure: failed program was:" >&5
8027 cat conftest.$ac_ext >&5 8021 cat conftest.$ac_ext >&5
8058 ld_dynamic_link_flags= 8052 ld_dynamic_link_flags=
8059 xehost=$canonical 8053 xehost=$canonical
8060 xealias=$internal_configuration 8054 xealias=$internal_configuration
8061 8055
8062 echo "checking how to build dynamic libraries for ${xehost}" 1>&6 8056 echo "checking how to build dynamic libraries for ${xehost}" 1>&6
8063 echo "configure:8064: checking how to build dynamic libraries for ${xehost}" >&5 8057 echo "configure:8058: checking how to build dynamic libraries for ${xehost}" >&5
8064 # Transform *-*-linux* to *-*-linux-gnu*, to support old configure scripts. 8058 # Transform *-*-linux* to *-*-linux-gnu*, to support old configure scripts.
8065 case "$xehost" in 8059 case "$xehost" in
8066 *-*-linux-gnu*) ;; 8060 *-*-linux-gnu*) ;;
8067 *-*-linux*) xehost=`echo $xehost | sed 's/^\(.*-.*-linux\)\(.*\)$/\1-gnu\2/'` 8061 *-*-linux*) xehost=`echo $xehost | sed 's/^\(.*-.*-linux\)\(.*\)$/\1-gnu\2/'`
8068 esac 8062 esac
8086 # Now see if the compiler is really GCC. 8080 # Now see if the compiler is really GCC.
8087 if test "$GCC" = "yes"; then 8081 if test "$GCC" = "yes"; then
8088 XEGCC=yes 8082 XEGCC=yes
8089 else 8083 else
8090 echo $ac_n "checking checking whether we are using GNU C""... $ac_c" 1>&6 8084 echo $ac_n "checking checking whether we are using GNU C""... $ac_c" 1>&6
8091 echo "configure:8092: checking checking whether we are using GNU C" >&5 8085 echo "configure:8086: checking checking whether we are using GNU C" >&5
8092 cat > conftest.$ac_ext <<EOF 8086 cat > conftest.$ac_ext <<EOF
8093 #line 8094 "configure" 8087 #line 8088 "configure"
8094 #include "confdefs.h" 8088 #include "confdefs.h"
8095 8089
8096 #ifdef __GNUC__ 8090 #ifdef __GNUC__
8097 yes; 8091 yes;
8098 #endif 8092 #endif
8110 8104
8111 echo "$ac_t""${XEGCC}" 1>&6 8105 echo "$ac_t""${XEGCC}" 1>&6
8112 fi 8106 fi
8113 8107
8114 echo $ac_n "checking how to produce PIC code""... $ac_c" 1>&6 8108 echo $ac_n "checking how to produce PIC code""... $ac_c" 1>&6
8115 echo "configure:8116: checking how to produce PIC code" >&5 8109 echo "configure:8110: checking how to produce PIC code" >&5
8116 wl= 8110 wl=
8117 8111
8118 can_build_shared=yes 8112 can_build_shared=yes
8119 if test "$XEGCC" = yes -o "$__ICC" = yes; then 8113 if test "$XEGCC" = yes -o "$__ICC" = yes; then
8120 wl='-Wl,' 8114 wl='-Wl,'
8214 if test -n "$dll_cflags"; then 8208 if test -n "$dll_cflags"; then
8215 echo "$ac_t""${dll_cflags}" 1>&6 8209 echo "$ac_t""${dll_cflags}" 1>&6
8216 8210
8217 # Check to make sure the dll_cflags actually works. 8211 # Check to make sure the dll_cflags actually works.
8218 echo $ac_n "checking if PIC flag ${dll_cflags} really works""... $ac_c" 1>&6 8212 echo $ac_n "checking if PIC flag ${dll_cflags} really works""... $ac_c" 1>&6
8219 echo "configure:8220: checking if PIC flag ${dll_cflags} really works" >&5 8213 echo "configure:8214: checking if PIC flag ${dll_cflags} really works" >&5
8220 save_CFLAGS="$CFLAGS" 8214 save_CFLAGS="$CFLAGS"
8221 CFLAGS="$CFLAGS $dll_cflags -DPIC" 8215 CFLAGS="$CFLAGS $dll_cflags -DPIC"
8222 cat > conftest.$ac_ext <<EOF 8216 cat > conftest.$ac_ext <<EOF
8223 #line 8224 "configure" 8217 #line 8218 "configure"
8224 #include "confdefs.h" 8218 #include "confdefs.h"
8225 8219
8226 int main() { 8220 int main() {
8227 int x=0; 8221 int x=0;
8228 ; return 0; } 8222 ; return 0; }
8229 EOF 8223 EOF
8230 if { (eval echo configure:8231: \"$ac_compile\") 1>&5; (eval $ac_compile) 2>&5; }; then 8224 if { (eval echo configure:8225: \"$ac_compile\") 1>&5; (eval $ac_compile) 2>&5; }; then
8231 rm -rf conftest* 8225 rm -rf conftest*
8232 8226
8233 # On HP-UX, the stripped-down bundled CC doesn't accept +Z, but also 8227 # On HP-UX, the stripped-down bundled CC doesn't accept +Z, but also
8234 # reports no error. So, we need to grep stderr for (Bundled). 8228 # reports no error. So, we need to grep stderr for (Bundled).
8235 if grep '(Bundled)' config.log >/dev/null; then 8229 if grep '(Bundled)' config.log >/dev/null; then
8256 if test "$can_build_shared" = "yes"; then 8250 if test "$can_build_shared" = "yes"; then
8257 cc_produces_so=no 8251 cc_produces_so=no
8258 xldf= 8252 xldf=
8259 xcldf= 8253 xcldf=
8260 echo $ac_n "checking if C compiler can produce shared libraries""... $ac_c" 1>&6 8254 echo $ac_n "checking if C compiler can produce shared libraries""... $ac_c" 1>&6
8261 echo "configure:8262: checking if C compiler can produce shared libraries" >&5 8255 echo "configure:8256: checking if C compiler can produce shared libraries" >&5
8262 if test "$XEGCC" = yes -o "$__ICC" = yes; then 8256 if test "$XEGCC" = yes -o "$__ICC" = yes; then
8263 case "$xehost_os" in 8257 case "$xehost_os" in
8264 *darwin*) 8258 *darwin*)
8265 xcldf='-bundle' 8259 xcldf='-bundle'
8266 xldf='-bundle -bundle_loader ../../src/xemacs' 8260 xldf='-bundle -bundle_loader ../../src/xemacs'
8315 LDFLAGS="$xcldf $LDFLAGS" 8309 LDFLAGS="$xcldf $LDFLAGS"
8316 LIBS= 8310 LIBS=
8317 xe_libs= 8311 xe_libs=
8318 ac_link='${CC-cc} -o conftest $CFLAGS '"$xe_cppflags $xe_ldflags"' conftest.$ac_ext '"$xe_libs"' 1>&5' 8312 ac_link='${CC-cc} -o conftest $CFLAGS '"$xe_cppflags $xe_ldflags"' conftest.$ac_ext '"$xe_libs"' 1>&5'
8319 cat > conftest.$ac_ext <<EOF 8313 cat > conftest.$ac_ext <<EOF
8320 #line 8321 "configure" 8314 #line 8315 "configure"
8321 #include "confdefs.h" 8315 #include "confdefs.h"
8322 8316
8323 int main() { 8317 int main() {
8324 int x=0; 8318 int x=0;
8325 ; return 0; } 8319 ; return 0; }
8326 EOF 8320 EOF
8327 if { (eval echo configure:8328: \"$ac_link\") 1>&5; (eval $ac_link) 2>&5; } && test -s conftest${ac_exeext}; then 8321 if { (eval echo configure:8322: \"$ac_link\") 1>&5; (eval $ac_link) 2>&5; } && test -s conftest${ac_exeext}; then
8328 rm -rf conftest* 8322 rm -rf conftest*
8329 cc_produces_so=yes 8323 cc_produces_so=yes
8330 else 8324 else
8331 echo "configure: failed program was:" >&5 8325 echo "configure: failed program was:" >&5
8332 cat conftest.$ac_ext >&5 8326 cat conftest.$ac_ext >&5
8347 if test -z "$LTLD"; then 8341 if test -z "$LTLD"; then
8348 ac_prog=ld 8342 ac_prog=ld
8349 if test "$XEGCC" = yes; then 8343 if test "$XEGCC" = yes; then
8350 # Check if gcc -print-prog-name=ld gives a path. 8344 # Check if gcc -print-prog-name=ld gives a path.
8351 echo $ac_n "checking for ld used by GCC""... $ac_c" 1>&6 8345 echo $ac_n "checking for ld used by GCC""... $ac_c" 1>&6
8352 echo "configure:8353: checking for ld used by GCC" >&5 8346 echo "configure:8347: checking for ld used by GCC" >&5
8353 ac_prog=`($CC -print-prog-name=ld) 2>&5` 8347 ac_prog=`($CC -print-prog-name=ld) 2>&5`
8354 case "$ac_prog" in 8348 case "$ac_prog" in
8355 # Accept absolute paths. 8349 # Accept absolute paths.
8356 /*) 8350 /*)
8357 if test -z "$LTLD"; then 8351 if test -z "$LTLD"; then
8373 with_gnu_ld=unknown 8367 with_gnu_ld=unknown
8374 ;; 8368 ;;
8375 esac 8369 esac
8376 else 8370 else
8377 echo $ac_n "checking for GNU ld""... $ac_c" 1>&6 8371 echo $ac_n "checking for GNU ld""... $ac_c" 1>&6
8378 echo "configure:8379: checking for GNU ld" >&5 8372 echo "configure:8373: checking for GNU ld" >&5
8379 fi 8373 fi
8380 8374
8381 if test -z "$LTLD"; then 8375 if test -z "$LTLD"; then
8382 IFS="${IFS= }"; ac_save_ifs="$IFS"; IFS="${IFS}:" 8376 IFS="${IFS= }"; ac_save_ifs="$IFS"; IFS="${IFS}:"
8383 for ac_dir in $PATH; do 8377 for ac_dir in $PATH; do
8411 8405
8412 ld_dynamic_link_flags= 8406 ld_dynamic_link_flags=
8413 8407
8414 # Check to see if it really is or isn't GNU ld. 8408 # Check to see if it really is or isn't GNU ld.
8415 echo $ac_n "checking if the linker is GNU ld""... $ac_c" 1>&6 8409 echo $ac_n "checking if the linker is GNU ld""... $ac_c" 1>&6
8416 echo "configure:8417: checking if the linker is GNU ld" >&5 8410 echo "configure:8411: checking if the linker is GNU ld" >&5
8417 # I'd rather use --version here, but apparently some GNU ld's only accept -v. 8411 # I'd rather use --version here, but apparently some GNU ld's only accept -v.
8418 if $LTLD -v 2>&1 </dev/null | egrep '(GNU|with BFD)' 1>&5; then 8412 if $LTLD -v 2>&1 </dev/null | egrep '(GNU|with BFD)' 1>&5; then
8419 xe_gnu_ld=yes 8413 xe_gnu_ld=yes
8420 else 8414 else
8421 xe_gnu_ld=no 8415 xe_gnu_ld=no
8446 ld_shlibs=yes 8440 ld_shlibs=yes
8447 else 8441 else
8448 # OK - only NOW do we futz about with ld. 8442 # OK - only NOW do we futz about with ld.
8449 # See if the linker supports building shared libraries. 8443 # See if the linker supports building shared libraries.
8450 echo $ac_n "checking whether the linker supports shared libraries""... $ac_c" 1>&6 8444 echo $ac_n "checking whether the linker supports shared libraries""... $ac_c" 1>&6
8451 echo "configure:8452: checking whether the linker supports shared libraries" >&5 8445 echo "configure:8446: checking whether the linker supports shared libraries" >&5
8452 dll_ld=$CC 8446 dll_ld=$CC
8453 dll_ldflags=$LDFLAGS 8447 dll_ldflags=$LDFLAGS
8454 ld_shlibs=yes 8448 ld_shlibs=yes
8455 can_build_shared=yes 8449 can_build_shared=yes
8456 if test "$xe_gnu_ld" = yes && test "$gnu_ld_acts_native" != yes; then 8450 if test "$xe_gnu_ld" = yes && test "$gnu_ld_acts_native" != yes; then
8659 INSTALL_ARCH_DEP_SUBDIR="$INSTALL_ARCH_DEP_SUBDIR src" && if test "$extra_verbose" = "yes"; then echo " Appending \"src\" to \$INSTALL_ARCH_DEP_SUBDIR"; fi 8653 INSTALL_ARCH_DEP_SUBDIR="$INSTALL_ARCH_DEP_SUBDIR src" && if test "$extra_verbose" = "yes"; then echo " Appending \"src\" to \$INSTALL_ARCH_DEP_SUBDIR"; fi
8660 test -n "$libdl" && LIBS="-l${libdl} $LIBS" && if test "$extra_verbose" = "yes"; then echo " Prepending \"-l${libdl}\" to \$LIBS"; fi 8654 test -n "$libdl" && LIBS="-l${libdl} $LIBS" && if test "$extra_verbose" = "yes"; then echo " Prepending \"-l${libdl}\" to \$LIBS"; fi
8661 for ac_func in dlerror _dlerror 8655 for ac_func in dlerror _dlerror
8662 do 8656 do
8663 echo $ac_n "checking for $ac_func""... $ac_c" 1>&6 8657 echo $ac_n "checking for $ac_func""... $ac_c" 1>&6
8664 echo "configure:8665: checking for $ac_func" >&5 8658 echo "configure:8659: checking for $ac_func" >&5
8665 8659
8666 cat > conftest.$ac_ext <<EOF 8660 cat > conftest.$ac_ext <<EOF
8667 #line 8668 "configure" 8661 #line 8662 "configure"
8668 #include "confdefs.h" 8662 #include "confdefs.h"
8669 /* System header to define __stub macros and hopefully few prototypes, 8663 /* System header to define __stub macros and hopefully few prototypes,
8670 which can conflict with char $ac_func(); below. */ 8664 which can conflict with char $ac_func(); below. */
8671 #include <assert.h> 8665 #include <assert.h>
8672 /* Override any gcc2 internal prototype to avoid an error. */ 8666 /* Override any gcc2 internal prototype to avoid an error. */
8685 $ac_func(); 8679 $ac_func();
8686 #endif 8680 #endif
8687 8681
8688 ; return 0; } 8682 ; return 0; }
8689 EOF 8683 EOF
8690 if { (eval echo configure:8691: \"$ac_link\") 1>&5; (eval $ac_link) 2>&5; } && test -s conftest${ac_exeext}; then 8684 if { (eval echo configure:8685: \"$ac_link\") 1>&5; (eval $ac_link) 2>&5; } && test -s conftest${ac_exeext}; then
8691 rm -rf conftest* 8685 rm -rf conftest*
8692 eval "ac_cv_func_$ac_func=yes" 8686 eval "ac_cv_func_$ac_func=yes"
8693 else 8687 else
8694 echo "configure: failed program was:" >&5 8688 echo "configure: failed program was:" >&5
8695 cat conftest.$ac_ext >&5 8689 cat conftest.$ac_ext >&5
8729 with_modules=no 8723 with_modules=no
8730 fi 8724 fi
8731 fi 8725 fi
8732 if test "$with_modules" != "yes"; then 8726 if test "$with_modules" != "yes"; then
8733 MOD_CC="$XEMACS_CC" 8727 MOD_CC="$XEMACS_CC"
8734 MODCFLAGS="\$(CFLAGS) -I../../src -I\$(srcdir)/../../src" 8728 MODCFLAGS="\$(XE_CFLAGS) -I../../src -I\$(srcdir)/../../src"
8735 INSTALLPATH="" 8729 INSTALLPATH=""
8736 MOD_INSTALL_PROGRAM="true" 8730 MOD_INSTALL_PROGRAM="true"
8737 OBJECT_TO_BUILD="\$(MODNAME).o" 8731 OBJECT_TO_BUILD="\$(MODNAME).o"
8738 fi 8732 fi
8739 MODARCHDIR= 8733 MODARCHDIR=
8749 8743
8750 if test "$with_tooltalk" != "no" ; then 8744 if test "$with_tooltalk" != "no" ; then
8751 for dir in "" "Tt/" "desktop/" ; do 8745 for dir in "" "Tt/" "desktop/" ; do
8752 ac_safe=`echo "${dir}tt_c.h" | sed 'y%./+-%__p_%'` 8746 ac_safe=`echo "${dir}tt_c.h" | sed 'y%./+-%__p_%'`
8753 echo $ac_n "checking for ${dir}tt_c.h""... $ac_c" 1>&6 8747 echo $ac_n "checking for ${dir}tt_c.h""... $ac_c" 1>&6
8754 echo "configure:8755: checking for ${dir}tt_c.h" >&5 8748 echo "configure:8749: checking for ${dir}tt_c.h" >&5
8755 8749
8756 cat > conftest.$ac_ext <<EOF 8750 cat > conftest.$ac_ext <<EOF
8757 #line 8758 "configure" 8751 #line 8752 "configure"
8758 #include "confdefs.h" 8752 #include "confdefs.h"
8759 #include <${dir}tt_c.h> 8753 #include <${dir}tt_c.h>
8760 EOF 8754 EOF
8761 ac_try="$ac_cpp conftest.$ac_ext >/dev/null 2>conftest.out" 8755 ac_try="$ac_cpp conftest.$ac_ext >/dev/null 2>conftest.out"
8762 { (eval echo configure:8763: \"$ac_try\") 1>&5; (eval $ac_try) 2>&5; } 8756 { (eval echo configure:8757: \"$ac_try\") 1>&5; (eval $ac_try) 2>&5; }
8763 ac_err=`grep -v '^ *+' conftest.out | grep -v "^conftest.${ac_ext}\$"` 8757 ac_err=`grep -v '^ *+' conftest.out | grep -v "^conftest.${ac_ext}\$"`
8764 if test -z "$ac_err"; then 8758 if test -z "$ac_err"; then
8765 rm -rf conftest* 8759 rm -rf conftest*
8766 eval "ac_cv_header_$ac_safe=yes" 8760 eval "ac_cv_header_$ac_safe=yes"
8767 else 8761 else
8793 for extra_libs in "" "-lI18N -lce" "-lcxx"; do 8787 for extra_libs in "" "-lI18N -lce" "-lcxx"; do
8794 8788
8795 xe_msg_checking="for tt_message_create in -ltt" 8789 xe_msg_checking="for tt_message_create in -ltt"
8796 test -n "$extra_libs" && xe_msg_checking="$xe_msg_checking using extra libs $extra_libs" 8790 test -n "$extra_libs" && xe_msg_checking="$xe_msg_checking using extra libs $extra_libs"
8797 echo $ac_n "checking "$xe_msg_checking"""... $ac_c" 1>&6 8791 echo $ac_n "checking "$xe_msg_checking"""... $ac_c" 1>&6
8798 echo "configure:8799: checking "$xe_msg_checking"" >&5 8792 echo "configure:8793: checking "$xe_msg_checking"" >&5
8799 ac_lib_var=`echo tt'_'tt_message_create | sed 'y%./+-%__p_%'` 8793 ac_lib_var=`echo tt'_'tt_message_create | sed 'y%./+-%__p_%'`
8800 8794
8801 xe_check_libs=" -ltt $extra_libs" 8795 xe_check_libs=" -ltt $extra_libs"
8802 cat > conftest.$ac_ext <<EOF 8796 cat > conftest.$ac_ext <<EOF
8803 #line 8804 "configure" 8797 #line 8798 "configure"
8804 #include "confdefs.h" 8798 #include "confdefs.h"
8805 /* Override any gcc2 internal prototype to avoid an error. */ 8799 /* Override any gcc2 internal prototype to avoid an error. */
8806 /* We use char because int might match the return type of a gcc2 8800 /* We use char because int might match the return type of a gcc2
8807 builtin and then its argument prototype would still apply. */ 8801 builtin and then its argument prototype would still apply. */
8808 char tt_message_create(); 8802 char tt_message_create();
8809 8803
8810 int main() { 8804 int main() {
8811 tt_message_create() 8805 tt_message_create()
8812 ; return 0; } 8806 ; return 0; }
8813 EOF 8807 EOF
8814 if { (eval echo configure:8815: \"$ac_link\") 1>&5; (eval $ac_link) 2>&5; } && test -s conftest${ac_exeext}; then 8808 if { (eval echo configure:8809: \"$ac_link\") 1>&5; (eval $ac_link) 2>&5; } && test -s conftest${ac_exeext}; then
8815 rm -rf conftest* 8809 rm -rf conftest*
8816 eval "ac_cv_lib_$ac_lib_var=yes" 8810 eval "ac_cv_lib_$ac_lib_var=yes"
8817 else 8811 else
8818 echo "configure: failed program was:" >&5 8812 echo "configure: failed program was:" >&5
8819 cat conftest.$ac_ext >&5 8813 cat conftest.$ac_ext >&5
8863 libs_x="$tt_libs $libs_x" && if test "$extra_verbose" = "yes"; then echo " Prepending \"$tt_libs\" to \$libs_x"; fi 8857 libs_x="$tt_libs $libs_x" && if test "$extra_verbose" = "yes"; then echo " Prepending \"$tt_libs\" to \$libs_x"; fi
8864 fi 8858 fi
8865 8859
8866 test -z "$with_cde" && { ac_safe=`echo "Dt/Dt.h" | sed 'y%./+-%__p_%'` 8860 test -z "$with_cde" && { ac_safe=`echo "Dt/Dt.h" | sed 'y%./+-%__p_%'`
8867 echo $ac_n "checking for Dt/Dt.h""... $ac_c" 1>&6 8861 echo $ac_n "checking for Dt/Dt.h""... $ac_c" 1>&6
8868 echo "configure:8869: checking for Dt/Dt.h" >&5 8862 echo "configure:8863: checking for Dt/Dt.h" >&5
8869 8863
8870 cat > conftest.$ac_ext <<EOF 8864 cat > conftest.$ac_ext <<EOF
8871 #line 8872 "configure" 8865 #line 8866 "configure"
8872 #include "confdefs.h" 8866 #include "confdefs.h"
8873 #include <Dt/Dt.h> 8867 #include <Dt/Dt.h>
8874 EOF 8868 EOF
8875 ac_try="$ac_cpp conftest.$ac_ext >/dev/null 2>conftest.out" 8869 ac_try="$ac_cpp conftest.$ac_ext >/dev/null 2>conftest.out"
8876 { (eval echo configure:8877: \"$ac_try\") 1>&5; (eval $ac_try) 2>&5; } 8870 { (eval echo configure:8871: \"$ac_try\") 1>&5; (eval $ac_try) 2>&5; }
8877 ac_err=`grep -v '^ *+' conftest.out | grep -v "^conftest.${ac_ext}\$"` 8871 ac_err=`grep -v '^ *+' conftest.out | grep -v "^conftest.${ac_ext}\$"`
8878 if test -z "$ac_err"; then 8872 if test -z "$ac_err"; then
8879 rm -rf conftest* 8873 rm -rf conftest*
8880 eval "ac_cv_header_$ac_safe=yes" 8874 eval "ac_cv_header_$ac_safe=yes"
8881 else 8875 else
8894 with_cde=no 8888 with_cde=no
8895 fi 8889 fi
8896 } 8890 }
8897 test -z "$with_cde" && { 8891 test -z "$with_cde" && {
8898 echo $ac_n "checking for DtDndDragStart in -lDtSvc""... $ac_c" 1>&6 8892 echo $ac_n "checking for DtDndDragStart in -lDtSvc""... $ac_c" 1>&6
8899 echo "configure:8900: checking for DtDndDragStart in -lDtSvc" >&5 8893 echo "configure:8894: checking for DtDndDragStart in -lDtSvc" >&5
8900 ac_lib_var=`echo DtSvc'_'DtDndDragStart | sed 'y%./+-%__p_%'` 8894 ac_lib_var=`echo DtSvc'_'DtDndDragStart | sed 'y%./+-%__p_%'`
8901 8895
8902 xe_check_libs=" -lDtSvc " 8896 xe_check_libs=" -lDtSvc "
8903 cat > conftest.$ac_ext <<EOF 8897 cat > conftest.$ac_ext <<EOF
8904 #line 8905 "configure" 8898 #line 8899 "configure"
8905 #include "confdefs.h" 8899 #include "confdefs.h"
8906 /* Override any gcc2 internal prototype to avoid an error. */ 8900 /* Override any gcc2 internal prototype to avoid an error. */
8907 /* We use char because int might match the return type of a gcc2 8901 /* We use char because int might match the return type of a gcc2
8908 builtin and then its argument prototype would still apply. */ 8902 builtin and then its argument prototype would still apply. */
8909 char DtDndDragStart(); 8903 char DtDndDragStart();
8910 8904
8911 int main() { 8905 int main() {
8912 DtDndDragStart() 8906 DtDndDragStart()
8913 ; return 0; } 8907 ; return 0; }
8914 EOF 8908 EOF
8915 if { (eval echo configure:8916: \"$ac_link\") 1>&5; (eval $ac_link) 2>&5; } && test -s conftest${ac_exeext}; then 8909 if { (eval echo configure:8910: \"$ac_link\") 1>&5; (eval $ac_link) 2>&5; } && test -s conftest${ac_exeext}; then
8916 rm -rf conftest* 8910 rm -rf conftest*
8917 eval "ac_cv_lib_$ac_lib_var=yes" 8911 eval "ac_cv_lib_$ac_lib_var=yes"
8918 else 8912 else
8919 echo "configure: failed program was:" >&5 8913 echo "configure: failed program was:" >&5
8920 cat conftest.$ac_ext >&5 8914 cat conftest.$ac_ext >&5
8991 dragndrop_proto="$dragndrop_proto GTK" && if test "$extra_verbose" = "yes"; then echo " Appending \"GTK\" to \$dragndrop_proto"; fi 8985 dragndrop_proto="$dragndrop_proto GTK" && if test "$extra_verbose" = "yes"; then echo " Appending \"GTK\" to \$dragndrop_proto"; fi
8992 fi 8986 fi
8993 8987
8994 if test "$with_dragndrop" != "no" ; then 8988 if test "$with_dragndrop" != "no" ; then
8995 echo $ac_n "checking if drag and drop API is needed""... $ac_c" 1>&6 8989 echo $ac_n "checking if drag and drop API is needed""... $ac_c" 1>&6
8996 echo "configure:8997: checking if drag and drop API is needed" >&5 8990 echo "configure:8991: checking if drag and drop API is needed" >&5
8997 if test -n "$dragndrop_proto" ; then 8991 if test -n "$dragndrop_proto" ; then
8998 with_dragndrop=yes 8992 with_dragndrop=yes
8999 echo "$ac_t""yes (${dragndrop_proto} )" 1>&6 8993 echo "$ac_t""yes (${dragndrop_proto} )" 1>&6
9000 { test "$extra_verbose" = "yes" && cat << \EOF 8994 { test "$extra_verbose" = "yes" && cat << \EOF
9001 Defining HAVE_DRAGNDROP 8995 Defining HAVE_DRAGNDROP
9011 echo "$ac_t""no" 1>&6 9005 echo "$ac_t""no" 1>&6
9012 fi 9006 fi
9013 fi 9007 fi
9014 9008
9015 echo "checking for LDAP" 1>&6 9009 echo "checking for LDAP" 1>&6
9016 echo "configure:9017: checking for LDAP" >&5 9010 echo "configure:9011: checking for LDAP" >&5
9017 ldap_libs= 9011 ldap_libs=
9018 test -z "$with_ldap" && { ac_safe=`echo "ldap.h" | sed 'y%./+-%__p_%'` 9012 test -z "$with_ldap" && { ac_safe=`echo "ldap.h" | sed 'y%./+-%__p_%'`
9019 echo $ac_n "checking for ldap.h""... $ac_c" 1>&6 9013 echo $ac_n "checking for ldap.h""... $ac_c" 1>&6
9020 echo "configure:9021: checking for ldap.h" >&5 9014 echo "configure:9015: checking for ldap.h" >&5
9021 9015
9022 cat > conftest.$ac_ext <<EOF 9016 cat > conftest.$ac_ext <<EOF
9023 #line 9024 "configure" 9017 #line 9018 "configure"
9024 #include "confdefs.h" 9018 #include "confdefs.h"
9025 #include <ldap.h> 9019 #include <ldap.h>
9026 EOF 9020 EOF
9027 ac_try="$ac_cpp conftest.$ac_ext >/dev/null 2>conftest.out" 9021 ac_try="$ac_cpp conftest.$ac_ext >/dev/null 2>conftest.out"
9028 { (eval echo configure:9029: \"$ac_try\") 1>&5; (eval $ac_try) 2>&5; } 9022 { (eval echo configure:9023: \"$ac_try\") 1>&5; (eval $ac_try) 2>&5; }
9029 ac_err=`grep -v '^ *+' conftest.out | grep -v "^conftest.${ac_ext}\$"` 9023 ac_err=`grep -v '^ *+' conftest.out | grep -v "^conftest.${ac_ext}\$"`
9030 if test -z "$ac_err"; then 9024 if test -z "$ac_err"; then
9031 rm -rf conftest* 9025 rm -rf conftest*
9032 eval "ac_cv_header_$ac_safe=yes" 9026 eval "ac_cv_header_$ac_safe=yes"
9033 else 9027 else
9046 with_ldap=no 9040 with_ldap=no
9047 fi 9041 fi
9048 } 9042 }
9049 test -z "$with_ldap" && { ac_safe=`echo "lber.h" | sed 'y%./+-%__p_%'` 9043 test -z "$with_ldap" && { ac_safe=`echo "lber.h" | sed 'y%./+-%__p_%'`
9050 echo $ac_n "checking for lber.h""... $ac_c" 1>&6 9044 echo $ac_n "checking for lber.h""... $ac_c" 1>&6
9051 echo "configure:9052: checking for lber.h" >&5 9045 echo "configure:9046: checking for lber.h" >&5
9052 9046
9053 cat > conftest.$ac_ext <<EOF 9047 cat > conftest.$ac_ext <<EOF
9054 #line 9055 "configure" 9048 #line 9049 "configure"
9055 #include "confdefs.h" 9049 #include "confdefs.h"
9056 #include <lber.h> 9050 #include <lber.h>
9057 EOF 9051 EOF
9058 ac_try="$ac_cpp conftest.$ac_ext >/dev/null 2>conftest.out" 9052 ac_try="$ac_cpp conftest.$ac_ext >/dev/null 2>conftest.out"
9059 { (eval echo configure:9060: \"$ac_try\") 1>&5; (eval $ac_try) 2>&5; } 9053 { (eval echo configure:9054: \"$ac_try\") 1>&5; (eval $ac_try) 2>&5; }
9060 ac_err=`grep -v '^ *+' conftest.out | grep -v "^conftest.${ac_ext}\$"` 9054 ac_err=`grep -v '^ *+' conftest.out | grep -v "^conftest.${ac_ext}\$"`
9061 if test -z "$ac_err"; then 9055 if test -z "$ac_err"; then
9062 rm -rf conftest* 9056 rm -rf conftest*
9063 eval "ac_cv_header_$ac_safe=yes" 9057 eval "ac_cv_header_$ac_safe=yes"
9064 else 9058 else
9078 fi 9072 fi
9079 } 9073 }
9080 if test "$with_ldap" != "no"; then 9074 if test "$with_ldap" != "no"; then
9081 9075
9082 echo $ac_n "checking for ldap_search in -lldap""... $ac_c" 1>&6 9076 echo $ac_n "checking for ldap_search in -lldap""... $ac_c" 1>&6
9083 echo "configure:9084: checking for ldap_search in -lldap" >&5 9077 echo "configure:9078: checking for ldap_search in -lldap" >&5
9084 ac_lib_var=`echo ldap'_'ldap_search | sed 'y%./+-%__p_%'` 9078 ac_lib_var=`echo ldap'_'ldap_search | sed 'y%./+-%__p_%'`
9085 9079
9086 xe_check_libs=" -lldap " 9080 xe_check_libs=" -lldap "
9087 cat > conftest.$ac_ext <<EOF 9081 cat > conftest.$ac_ext <<EOF
9088 #line 9089 "configure" 9082 #line 9083 "configure"
9089 #include "confdefs.h" 9083 #include "confdefs.h"
9090 /* Override any gcc2 internal prototype to avoid an error. */ 9084 /* Override any gcc2 internal prototype to avoid an error. */
9091 /* We use char because int might match the return type of a gcc2 9085 /* We use char because int might match the return type of a gcc2
9092 builtin and then its argument prototype would still apply. */ 9086 builtin and then its argument prototype would still apply. */
9093 char ldap_search(); 9087 char ldap_search();
9094 9088
9095 int main() { 9089 int main() {
9096 ldap_search() 9090 ldap_search()
9097 ; return 0; } 9091 ; return 0; }
9098 EOF 9092 EOF
9099 if { (eval echo configure:9100: \"$ac_link\") 1>&5; (eval $ac_link) 2>&5; } && test -s conftest${ac_exeext}; then 9093 if { (eval echo configure:9094: \"$ac_link\") 1>&5; (eval $ac_link) 2>&5; } && test -s conftest${ac_exeext}; then
9100 rm -rf conftest* 9094 rm -rf conftest*
9101 eval "ac_cv_lib_$ac_lib_var=yes" 9095 eval "ac_cv_lib_$ac_lib_var=yes"
9102 else 9096 else
9103 echo "configure: failed program was:" >&5 9097 echo "configure: failed program was:" >&5
9104 cat conftest.$ac_ext >&5 9098 cat conftest.$ac_ext >&5
9108 rm -f conftest* 9102 rm -f conftest*
9109 xe_check_libs="" 9103 xe_check_libs=""
9110 9104
9111 if eval "test \"`echo '$ac_cv_lib_'$ac_lib_var`\" = yes" ; then 9105 if eval "test \"`echo '$ac_cv_lib_'$ac_lib_var`\" = yes" ; then
9112 echo "$ac_t""yes" 1>&6 9106 echo "$ac_t""yes" 1>&6
9113 with_ldap_nolber=yes 9107 with_ldap=yes
9114 else 9108 else
9115 echo "$ac_t""no" 1>&6 9109 echo "$ac_t""no" 1>&6
9116 with_ldap_nolber=no 9110 fi
9117 fi 9111
9118 9112
9119 9113 test "$with_ldap" != "yes" && {
9120 test "$with_ldap_nolber" = "no" && {
9121 xe_msg_checking="for ldap_open in -lldap" 9114 xe_msg_checking="for ldap_open in -lldap"
9122 test -n "-llber" && xe_msg_checking="$xe_msg_checking using extra libs -llber" 9115 test -n "-llber" && xe_msg_checking="$xe_msg_checking using extra libs -llber"
9123 echo $ac_n "checking "$xe_msg_checking"""... $ac_c" 1>&6 9116 echo $ac_n "checking "$xe_msg_checking"""... $ac_c" 1>&6
9124 echo "configure:9125: checking "$xe_msg_checking"" >&5 9117 echo "configure:9118: checking "$xe_msg_checking"" >&5
9125 ac_lib_var=`echo ldap'_'ldap_open | sed 'y%./+-%__p_%'` 9118 ac_lib_var=`echo ldap'_'ldap_open | sed 'y%./+-%__p_%'`
9126 9119
9127 xe_check_libs=" -lldap -llber" 9120 xe_check_libs=" -lldap -llber"
9128 cat > conftest.$ac_ext <<EOF 9121 cat > conftest.$ac_ext <<EOF
9129 #line 9130 "configure" 9122 #line 9123 "configure"
9130 #include "confdefs.h" 9123 #include "confdefs.h"
9131 /* Override any gcc2 internal prototype to avoid an error. */ 9124 /* Override any gcc2 internal prototype to avoid an error. */
9132 /* We use char because int might match the return type of a gcc2 9125 /* We use char because int might match the return type of a gcc2
9133 builtin and then its argument prototype would still apply. */ 9126 builtin and then its argument prototype would still apply. */
9134 char ldap_open(); 9127 char ldap_open();
9135 9128
9136 int main() { 9129 int main() {
9137 ldap_open() 9130 ldap_open()
9138 ; return 0; } 9131 ; return 0; }
9139 EOF 9132 EOF
9140 if { (eval echo configure:9141: \"$ac_link\") 1>&5; (eval $ac_link) 2>&5; } && test -s conftest${ac_exeext}; then 9133 if { (eval echo configure:9134: \"$ac_link\") 1>&5; (eval $ac_link) 2>&5; } && test -s conftest${ac_exeext}; then
9141 rm -rf conftest* 9134 rm -rf conftest*
9142 eval "ac_cv_lib_$ac_lib_var=yes" 9135 eval "ac_cv_lib_$ac_lib_var=yes"
9143 else 9136 else
9144 echo "configure: failed program was:" >&5 9137 echo "configure: failed program was:" >&5
9145 cat conftest.$ac_ext >&5 9138 cat conftest.$ac_ext >&5
9149 rm -f conftest* 9142 rm -f conftest*
9150 xe_check_libs="" 9143 xe_check_libs=""
9151 9144
9152 if eval "test \"`echo '$ac_cv_lib_'$ac_lib_var`\" = yes" ; then 9145 if eval "test \"`echo '$ac_cv_lib_'$ac_lib_var`\" = yes" ; then
9153 echo "$ac_t""yes" 1>&6 9146 echo "$ac_t""yes" 1>&6
9154 with_ldap_lber=yes 9147 with_ldap=yes with_ldap_lber=yes
9155 else 9148 else
9156 echo "$ac_t""no" 1>&6 9149 echo "$ac_t""no" 1>&6
9157 with_ldap_lber=no
9158 fi 9150 fi
9159 9151
9160 } 9152 }
9161 test "$with_ldap_nolber" = "no" -a "$with_ldap_lber" = "no" && { 9153 test "$with_ldap" != "yes" && {
9162 xe_msg_checking="for ldap_open in -lldap" 9154 xe_msg_checking="for ldap_open in -lldap"
9163 test -n "-llber -lkrb" && xe_msg_checking="$xe_msg_checking using extra libs -llber -lkrb" 9155 test -n "-llber -lkrb" && xe_msg_checking="$xe_msg_checking using extra libs -llber -lkrb"
9164 echo $ac_n "checking "$xe_msg_checking"""... $ac_c" 1>&6 9156 echo $ac_n "checking "$xe_msg_checking"""... $ac_c" 1>&6
9165 echo "configure:9166: checking "$xe_msg_checking"" >&5 9157 echo "configure:9158: checking "$xe_msg_checking"" >&5
9166 ac_lib_var=`echo ldap'_'ldap_open | sed 'y%./+-%__p_%'` 9158 ac_lib_var=`echo ldap'_'ldap_open | sed 'y%./+-%__p_%'`
9167 9159
9168 xe_check_libs=" -lldap -llber -lkrb" 9160 xe_check_libs=" -lldap -llber -lkrb"
9169 cat > conftest.$ac_ext <<EOF 9161 cat > conftest.$ac_ext <<EOF
9170 #line 9171 "configure" 9162 #line 9163 "configure"
9171 #include "confdefs.h" 9163 #include "confdefs.h"
9172 /* Override any gcc2 internal prototype to avoid an error. */ 9164 /* Override any gcc2 internal prototype to avoid an error. */
9173 /* We use char because int might match the return type of a gcc2 9165 /* We use char because int might match the return type of a gcc2
9174 builtin and then its argument prototype would still apply. */ 9166 builtin and then its argument prototype would still apply. */
9175 char ldap_open(); 9167 char ldap_open();
9176 9168
9177 int main() { 9169 int main() {
9178 ldap_open() 9170 ldap_open()
9179 ; return 0; } 9171 ; return 0; }
9180 EOF 9172 EOF
9181 if { (eval echo configure:9182: \"$ac_link\") 1>&5; (eval $ac_link) 2>&5; } && test -s conftest${ac_exeext}; then 9173 if { (eval echo configure:9174: \"$ac_link\") 1>&5; (eval $ac_link) 2>&5; } && test -s conftest${ac_exeext}; then
9182 rm -rf conftest* 9174 rm -rf conftest*
9183 eval "ac_cv_lib_$ac_lib_var=yes" 9175 eval "ac_cv_lib_$ac_lib_var=yes"
9184 else 9176 else
9185 echo "configure: failed program was:" >&5 9177 echo "configure: failed program was:" >&5
9186 cat conftest.$ac_ext >&5 9178 cat conftest.$ac_ext >&5
9190 rm -f conftest* 9182 rm -f conftest*
9191 xe_check_libs="" 9183 xe_check_libs=""
9192 9184
9193 if eval "test \"`echo '$ac_cv_lib_'$ac_lib_var`\" = yes" ; then 9185 if eval "test \"`echo '$ac_cv_lib_'$ac_lib_var`\" = yes" ; then
9194 echo "$ac_t""yes" 1>&6 9186 echo "$ac_t""yes" 1>&6
9195 with_ldap_krb=yes 9187 with_ldap=yes with_ldap_lber=yes with_ldap_krb=yes
9196 else 9188 else
9197 echo "$ac_t""no" 1>&6 9189 echo "$ac_t""no" 1>&6
9198 with_ldap_krb=no
9199 fi 9190 fi
9200 9191
9201 } 9192 }
9202 test "$with_ldap_nolber" = "no" -a "$with_ldap_lber" = "no" -a "$with_ldap_krb" = "no" && { 9193 test "$with_ldap" != "yes" && {
9203 xe_msg_checking="for ldap_open in -lldap" 9194 xe_msg_checking="for ldap_open in -lldap"
9204 test -n "-llber -lkrb -ldes" && xe_msg_checking="$xe_msg_checking using extra libs -llber -lkrb -ldes" 9195 test -n "-llber -lkrb -ldes" && xe_msg_checking="$xe_msg_checking using extra libs -llber -lkrb -ldes"
9205 echo $ac_n "checking "$xe_msg_checking"""... $ac_c" 1>&6 9196 echo $ac_n "checking "$xe_msg_checking"""... $ac_c" 1>&6
9206 echo "configure:9207: checking "$xe_msg_checking"" >&5 9197 echo "configure:9198: checking "$xe_msg_checking"" >&5
9207 ac_lib_var=`echo ldap'_'ldap_open | sed 'y%./+-%__p_%'` 9198 ac_lib_var=`echo ldap'_'ldap_open | sed 'y%./+-%__p_%'`
9208 9199
9209 xe_check_libs=" -lldap -llber -lkrb -ldes" 9200 xe_check_libs=" -lldap -llber -lkrb -ldes"
9210 cat > conftest.$ac_ext <<EOF 9201 cat > conftest.$ac_ext <<EOF
9211 #line 9212 "configure" 9202 #line 9203 "configure"
9212 #include "confdefs.h" 9203 #include "confdefs.h"
9213 /* Override any gcc2 internal prototype to avoid an error. */ 9204 /* Override any gcc2 internal prototype to avoid an error. */
9214 /* We use char because int might match the return type of a gcc2 9205 /* We use char because int might match the return type of a gcc2
9215 builtin and then its argument prototype would still apply. */ 9206 builtin and then its argument prototype would still apply. */
9216 char ldap_open(); 9207 char ldap_open();
9217 9208
9218 int main() { 9209 int main() {
9219 ldap_open() 9210 ldap_open()
9220 ; return 0; } 9211 ; return 0; }
9221 EOF 9212 EOF
9222 if { (eval echo configure:9223: \"$ac_link\") 1>&5; (eval $ac_link) 2>&5; } && test -s conftest${ac_exeext}; then 9213 if { (eval echo configure:9214: \"$ac_link\") 1>&5; (eval $ac_link) 2>&5; } && test -s conftest${ac_exeext}; then
9223 rm -rf conftest* 9214 rm -rf conftest*
9224 eval "ac_cv_lib_$ac_lib_var=yes" 9215 eval "ac_cv_lib_$ac_lib_var=yes"
9225 else 9216 else
9226 echo "configure: failed program was:" >&5 9217 echo "configure: failed program was:" >&5
9227 cat conftest.$ac_ext >&5 9218 cat conftest.$ac_ext >&5
9231 rm -f conftest* 9222 rm -f conftest*
9232 xe_check_libs="" 9223 xe_check_libs=""
9233 9224
9234 if eval "test \"`echo '$ac_cv_lib_'$ac_lib_var`\" = yes" ; then 9225 if eval "test \"`echo '$ac_cv_lib_'$ac_lib_var`\" = yes" ; then
9235 echo "$ac_t""yes" 1>&6 9226 echo "$ac_t""yes" 1>&6
9236 with_ldap_krbdes=yes 9227 with_ldap=yes with_ldap_lber=yes with_ldap_krb=yes with_ldap_des=yes
9237 else 9228 else
9238 echo "$ac_t""no" 1>&6 9229 echo "$ac_t""no" 1>&6
9239 with_ldap_krbdes=no
9240 fi 9230 fi
9241 9231
9242 } 9232 }
9243 test -z "$with_ldap" -a \( "$with_ldap_lber" = "yes" -o "$with_ldap_nolber" = "yes" -o "$with_ldap_krb" = "yes" -o "$with_ldap_krbdes" = "yes" \) && with_ldap=yes 9233 test "$with_ldap_lber" != "yes" && {
9234 echo $ac_n "checking for ber_pvt_opt_on in -llber""... $ac_c" 1>&6
9235 echo "configure:9236: checking for ber_pvt_opt_on in -llber" >&5
9236 ac_lib_var=`echo lber'_'ber_pvt_opt_on | sed 'y%./+-%__p_%'`
9237
9238 xe_check_libs=" -llber "
9239 cat > conftest.$ac_ext <<EOF
9240 #line 9241 "configure"
9241 #include "confdefs.h"
9242 /* Override any gcc2 internal prototype to avoid an error. */
9243 /* We use char because int might match the return type of a gcc2
9244 builtin and then its argument prototype would still apply. */
9245 char ber_pvt_opt_on();
9246
9247 int main() {
9248 ber_pvt_opt_on()
9249 ; return 0; }
9250 EOF
9251 if { (eval echo configure:9252: \"$ac_link\") 1>&5; (eval $ac_link) 2>&5; } && test -s conftest${ac_exeext}; then
9252 rm -rf conftest*
9253 eval "ac_cv_lib_$ac_lib_var=yes"
9254 else
9255 echo "configure: failed program was:" >&5
9256 cat conftest.$ac_ext >&5
9257 rm -rf conftest*
9258 eval "ac_cv_lib_$ac_lib_var=no"
9259 fi
9260 rm -f conftest*
9261 xe_check_libs=""
9262
9263 if eval "test \"`echo '$ac_cv_lib_'$ac_lib_var`\" = yes" ; then
9264 echo "$ac_t""yes" 1>&6
9265 with_ldap_lber=yes
9266 else
9267 echo "$ac_t""no" 1>&6
9268 fi
9269
9270 }
9244 fi 9271 fi
9245 if test "$with_ldap" = "yes"; then 9272 if test "$with_ldap" = "yes"; then
9246 { test "$extra_verbose" = "yes" && cat << \EOF 9273 { test "$extra_verbose" = "yes" && cat << \EOF
9247 Defining HAVE_LDAP 9274 Defining HAVE_LDAP
9248 EOF 9275 EOF
9249 cat >> confdefs.h <<\EOF 9276 cat >> confdefs.h <<\EOF
9250 #define HAVE_LDAP 1 9277 #define HAVE_LDAP 1
9251 EOF 9278 EOF
9252 } 9279 }
9253 9280
9254 if test "$with_ldap_nolber" = "yes" ; then 9281 if test "$with_ldap_des" = "yes" ; then
9255 ldap_libs="-lldap $ldap_libs" && if test "$extra_verbose" = "yes"; then echo " Prepending \"-lldap\" to \$ldap_libs"; fi 9282 ldap_libs="-ldes $ldap_libs" && if test "$extra_verbose" = "yes"; then echo " Prepending \"-ldes\" to \$ldap_libs"; fi
9256 else 9283 fi
9257 if test "$with_ldap_krb" = "yes" ; then 9284 if test "$with_ldap_krb" = "yes" ; then
9258 ldap_libs="-lkrb $ldap_libs" && if test "$extra_verbose" = "yes"; then echo " Prepending \"-lkrb\" to \$ldap_libs"; fi 9285 ldap_libs="-lkrb $ldap_libs" && if test "$extra_verbose" = "yes"; then echo " Prepending \"-lkrb\" to \$ldap_libs"; fi
9259 fi 9286 fi
9260 if test "$with_ldap_krbdes" = "yes" ; then 9287 if test "$with_ldap_lber" = "yes" ; then
9261 ldap_libs="-ldes $ldap_libs" && if test "$extra_verbose" = "yes"; then echo " Prepending \"-ldes\" to \$ldap_libs"; fi
9262 ldap_libs="-lkrb $ldap_libs" && if test "$extra_verbose" = "yes"; then echo " Prepending \"-lkrb\" to \$ldap_libs"; fi
9263 fi
9264 ldap_libs="-llber $ldap_libs" && if test "$extra_verbose" = "yes"; then echo " Prepending \"-llber\" to \$ldap_libs"; fi 9288 ldap_libs="-llber $ldap_libs" && if test "$extra_verbose" = "yes"; then echo " Prepending \"-llber\" to \$ldap_libs"; fi
9265 ldap_libs="-lldap $ldap_libs" && if test "$extra_verbose" = "yes"; then echo " Prepending \"-lldap\" to \$ldap_libs"; fi
9266 fi 9289 fi
9290 ldap_libs="-lldap $ldap_libs" && if test "$extra_verbose" = "yes"; then echo " Prepending \"-lldap\" to \$ldap_libs"; fi
9267 save_LIBS="$LIBS" LIBS="$LIBS $ldap_libs" 9291 save_LIBS="$LIBS" LIBS="$LIBS $ldap_libs"
9268 for ac_func in ldap_set_option ldap_get_lderrno ldap_result2error ldap_parse_result 9292 for ac_func in ldap_set_option ldap_get_lderrno ldap_result2error ldap_parse_result
9269 do 9293 do
9270 echo $ac_n "checking for $ac_func""... $ac_c" 1>&6 9294 echo $ac_n "checking for $ac_func""... $ac_c" 1>&6
9271 echo "configure:9272: checking for $ac_func" >&5 9295 echo "configure:9296: checking for $ac_func" >&5
9272 9296
9273 cat > conftest.$ac_ext <<EOF 9297 cat > conftest.$ac_ext <<EOF
9274 #line 9275 "configure" 9298 #line 9299 "configure"
9275 #include "confdefs.h" 9299 #include "confdefs.h"
9276 /* System header to define __stub macros and hopefully few prototypes, 9300 /* System header to define __stub macros and hopefully few prototypes,
9277 which can conflict with char $ac_func(); below. */ 9301 which can conflict with char $ac_func(); below. */
9278 #include <assert.h> 9302 #include <assert.h>
9279 /* Override any gcc2 internal prototype to avoid an error. */ 9303 /* Override any gcc2 internal prototype to avoid an error. */
9292 $ac_func(); 9316 $ac_func();
9293 #endif 9317 #endif
9294 9318
9295 ; return 0; } 9319 ; return 0; }
9296 EOF 9320 EOF
9297 if { (eval echo configure:9298: \"$ac_link\") 1>&5; (eval $ac_link) 2>&5; } && test -s conftest${ac_exeext}; then 9321 if { (eval echo configure:9322: \"$ac_link\") 1>&5; (eval $ac_link) 2>&5; } && test -s conftest${ac_exeext}; then
9298 rm -rf conftest* 9322 rm -rf conftest*
9299 eval "ac_cv_func_$ac_func=yes" 9323 eval "ac_cv_func_$ac_func=yes"
9300 else 9324 else
9301 echo "configure: failed program was:" >&5 9325 echo "configure: failed program was:" >&5
9302 cat conftest.$ac_ext >&5 9326 cat conftest.$ac_ext >&5
9331 9355
9332 9356
9333 postgresql_libs= 9357 postgresql_libs=
9334 if test "$with_postgresql" != "no"; then 9358 if test "$with_postgresql" != "no"; then
9335 echo "checking for PostgreSQL" 1>&6 9359 echo "checking for PostgreSQL" 1>&6
9336 echo "configure:9337: checking for PostgreSQL" >&5 9360 echo "configure:9361: checking for PostgreSQL" >&5
9337 9361
9338 for header_dir in "" "pgsql/" "postgresql/"; do 9362 for header_dir in "" "pgsql/" "postgresql/"; do
9339 ac_safe=`echo "${header_dir}libpq-fe.h" | sed 'y%./+-%__p_%'` 9363 ac_safe=`echo "${header_dir}libpq-fe.h" | sed 'y%./+-%__p_%'`
9340 echo $ac_n "checking for ${header_dir}libpq-fe.h""... $ac_c" 1>&6 9364 echo $ac_n "checking for ${header_dir}libpq-fe.h""... $ac_c" 1>&6
9341 echo "configure:9342: checking for ${header_dir}libpq-fe.h" >&5 9365 echo "configure:9366: checking for ${header_dir}libpq-fe.h" >&5
9342 9366
9343 cat > conftest.$ac_ext <<EOF 9367 cat > conftest.$ac_ext <<EOF
9344 #line 9345 "configure" 9368 #line 9369 "configure"
9345 #include "confdefs.h" 9369 #include "confdefs.h"
9346 #include <${header_dir}libpq-fe.h> 9370 #include <${header_dir}libpq-fe.h>
9347 EOF 9371 EOF
9348 ac_try="$ac_cpp conftest.$ac_ext >/dev/null 2>conftest.out" 9372 ac_try="$ac_cpp conftest.$ac_ext >/dev/null 2>conftest.out"
9349 { (eval echo configure:9350: \"$ac_try\") 1>&5; (eval $ac_try) 2>&5; } 9373 { (eval echo configure:9374: \"$ac_try\") 1>&5; (eval $ac_try) 2>&5; }
9350 ac_err=`grep -v '^ *+' conftest.out | grep -v "^conftest.${ac_ext}\$"` 9374 ac_err=`grep -v '^ *+' conftest.out | grep -v "^conftest.${ac_ext}\$"`
9351 if test -z "$ac_err"; then 9375 if test -z "$ac_err"; then
9352 rm -rf conftest* 9376 rm -rf conftest*
9353 eval "ac_cv_header_$ac_safe=yes" 9377 eval "ac_cv_header_$ac_safe=yes"
9354 else 9378 else
9368 9392
9369 done 9393 done
9370 9394
9371 test -n "$libpq_fe_h_file" && { 9395 test -n "$libpq_fe_h_file" && {
9372 echo $ac_n "checking for PQconnectdb in -lpq""... $ac_c" 1>&6 9396 echo $ac_n "checking for PQconnectdb in -lpq""... $ac_c" 1>&6
9373 echo "configure:9374: checking for PQconnectdb in -lpq" >&5 9397 echo "configure:9398: checking for PQconnectdb in -lpq" >&5
9374 ac_lib_var=`echo pq'_'PQconnectdb | sed 'y%./+-%__p_%'` 9398 ac_lib_var=`echo pq'_'PQconnectdb | sed 'y%./+-%__p_%'`
9375 9399
9376 xe_check_libs=" -lpq " 9400 xe_check_libs=" -lpq "
9377 cat > conftest.$ac_ext <<EOF 9401 cat > conftest.$ac_ext <<EOF
9378 #line 9379 "configure" 9402 #line 9403 "configure"
9379 #include "confdefs.h" 9403 #include "confdefs.h"
9380 /* Override any gcc2 internal prototype to avoid an error. */ 9404 /* Override any gcc2 internal prototype to avoid an error. */
9381 /* We use char because int might match the return type of a gcc2 9405 /* We use char because int might match the return type of a gcc2
9382 builtin and then its argument prototype would still apply. */ 9406 builtin and then its argument prototype would still apply. */
9383 char PQconnectdb(); 9407 char PQconnectdb();
9384 9408
9385 int main() { 9409 int main() {
9386 PQconnectdb() 9410 PQconnectdb()
9387 ; return 0; } 9411 ; return 0; }
9388 EOF 9412 EOF
9389 if { (eval echo configure:9390: \"$ac_link\") 1>&5; (eval $ac_link) 2>&5; } && test -s conftest${ac_exeext}; then 9413 if { (eval echo configure:9414: \"$ac_link\") 1>&5; (eval $ac_link) 2>&5; } && test -s conftest${ac_exeext}; then
9390 rm -rf conftest* 9414 rm -rf conftest*
9391 eval "ac_cv_lib_$ac_lib_var=yes" 9415 eval "ac_cv_lib_$ac_lib_var=yes"
9392 else 9416 else
9393 echo "configure: failed program was:" >&5 9417 echo "configure: failed program was:" >&5
9394 cat conftest.$ac_ext >&5 9418 cat conftest.$ac_ext >&5
9417 EOF 9441 EOF
9418 } 9442 }
9419 9443
9420 9444
9421 echo $ac_n "checking for PQconnectStart in -lpq""... $ac_c" 1>&6 9445 echo $ac_n "checking for PQconnectStart in -lpq""... $ac_c" 1>&6
9422 echo "configure:9423: checking for PQconnectStart in -lpq" >&5 9446 echo "configure:9447: checking for PQconnectStart in -lpq" >&5
9423 ac_lib_var=`echo pq'_'PQconnectStart | sed 'y%./+-%__p_%'` 9447 ac_lib_var=`echo pq'_'PQconnectStart | sed 'y%./+-%__p_%'`
9424 9448
9425 xe_check_libs=" -lpq " 9449 xe_check_libs=" -lpq "
9426 cat > conftest.$ac_ext <<EOF 9450 cat > conftest.$ac_ext <<EOF
9427 #line 9428 "configure" 9451 #line 9452 "configure"
9428 #include "confdefs.h" 9452 #include "confdefs.h"
9429 /* Override any gcc2 internal prototype to avoid an error. */ 9453 /* Override any gcc2 internal prototype to avoid an error. */
9430 /* We use char because int might match the return type of a gcc2 9454 /* We use char because int might match the return type of a gcc2
9431 builtin and then its argument prototype would still apply. */ 9455 builtin and then its argument prototype would still apply. */
9432 char PQconnectStart(); 9456 char PQconnectStart();
9433 9457
9434 int main() { 9458 int main() {
9435 PQconnectStart() 9459 PQconnectStart()
9436 ; return 0; } 9460 ; return 0; }
9437 EOF 9461 EOF
9438 if { (eval echo configure:9439: \"$ac_link\") 1>&5; (eval $ac_link) 2>&5; } && test -s conftest${ac_exeext}; then 9462 if { (eval echo configure:9463: \"$ac_link\") 1>&5; (eval $ac_link) 2>&5; } && test -s conftest${ac_exeext}; then
9439 rm -rf conftest* 9463 rm -rf conftest*
9440 eval "ac_cv_lib_$ac_lib_var=yes" 9464 eval "ac_cv_lib_$ac_lib_var=yes"
9441 else 9465 else
9442 echo "configure: failed program was:" >&5 9466 echo "configure: failed program was:" >&5
9443 cat conftest.$ac_ext >&5 9467 cat conftest.$ac_ext >&5
9484 9508
9485 9509
9486 9510
9487 if test "$window_system" != "none"; then 9511 if test "$window_system" != "none"; then
9488 echo "checking for graphics libraries" 1>&6 9512 echo "checking for graphics libraries" 1>&6
9489 echo "configure:9490: checking for graphics libraries" >&5 9513 echo "configure:9514: checking for graphics libraries" >&5
9490 9514
9491 libpath_xpm= 9515 libpath_xpm=
9492 incpath_xpm= 9516 incpath_xpm=
9493 case "$opsys" in 9517 case "$opsys" in
9494 cygwin*) 9518 cygwin*)
9510 xpm_problem="" 9534 xpm_problem=""
9511 if test -z "$with_xpm"; then 9535 if test -z "$with_xpm"; then
9512 CFLAGS=""$incpath_xpm" $CFLAGS" && if test "$extra_verbose" = "yes"; then echo " Prepending \""$incpath_xpm"\" to \$CFLAGS"; fi 9536 CFLAGS=""$incpath_xpm" $CFLAGS" && if test "$extra_verbose" = "yes"; then echo " Prepending \""$incpath_xpm"\" to \$CFLAGS"; fi
9513 LDFLAGS=""$libpath_xpm" $LDFLAGS" && if test "$extra_verbose" = "yes"; then echo " Prepending \""$libpath_xpm"\" to \$LDFLAGS"; fi 9537 LDFLAGS=""$libpath_xpm" $LDFLAGS" && if test "$extra_verbose" = "yes"; then echo " Prepending \""$libpath_xpm"\" to \$LDFLAGS"; fi
9514 echo $ac_n "checking for Xpm - no older than 3.4f""... $ac_c" 1>&6 9538 echo $ac_n "checking for Xpm - no older than 3.4f""... $ac_c" 1>&6
9515 echo "configure:9516: checking for Xpm - no older than 3.4f" >&5 9539 echo "configure:9540: checking for Xpm - no older than 3.4f" >&5
9516 xe_check_libs=-lXpm 9540 xe_check_libs=-lXpm
9517 cat > conftest.$ac_ext <<EOF 9541 cat > conftest.$ac_ext <<EOF
9518 #line 9519 "configure" 9542 #line 9543 "configure"
9519 #include "confdefs.h" 9543 #include "confdefs.h"
9520 #define XPM_NUMBERS 9544 #define XPM_NUMBERS
9521 #include <X11/xpm.h> 9545 #include <X11/xpm.h>
9522 int main(int c, char **v) { 9546 int main(int c, char **v) {
9523 return c == 1 ? 0 : 9547 return c == 1 ? 0 :
9524 XpmIncludeVersion != XpmLibraryVersion() ? 1 : 9548 XpmIncludeVersion != XpmLibraryVersion() ? 1 :
9525 XpmIncludeVersion < 30406 ? 2 : 0 ;} 9549 XpmIncludeVersion < 30406 ? 2 : 0 ;}
9526 EOF 9550 EOF
9527 if { (eval echo configure:9528: \"$ac_link\") 1>&5; (eval $ac_link) 2>&5; } && test -s conftest && (./conftest; exit $?) 2>&5 9551 if { (eval echo configure:9552: \"$ac_link\") 1>&5; (eval $ac_link) 2>&5; } && test -s conftest && (./conftest; exit $?) 2>&5
9528 then 9552 then
9529 ./conftest dummy_arg; xpm_status=$?; 9553 ./conftest dummy_arg; xpm_status=$?;
9530 if test "$xpm_status" = "0"; then 9554 if test "$xpm_status" = "0"; then
9531 with_xpm=yes; 9555 with_xpm=yes;
9532 else 9556 else
9566 9590
9567 LDFLAGS=""$libpath_xpm" $LDFLAGS" && if test "$extra_verbose" = "yes"; then echo " Prepending \""$libpath_xpm"\" to \$LDFLAGS"; fi 9591 LDFLAGS=""$libpath_xpm" $LDFLAGS" && if test "$extra_verbose" = "yes"; then echo " Prepending \""$libpath_xpm"\" to \$LDFLAGS"; fi
9568 libs_x="-lXpm $libs_x" && if test "$extra_verbose" = "yes"; then echo " Prepending \"-lXpm\" to \$libs_x"; fi 9592 libs_x="-lXpm $libs_x" && if test "$extra_verbose" = "yes"; then echo " Prepending \"-lXpm\" to \$libs_x"; fi
9569 CFLAGS=""$incpath_xpm" $CFLAGS" && if test "$extra_verbose" = "yes"; then echo " Prepending \""$incpath_xpm"\" to \$CFLAGS"; fi 9593 CFLAGS=""$incpath_xpm" $CFLAGS" && if test "$extra_verbose" = "yes"; then echo " Prepending \""$incpath_xpm"\" to \$CFLAGS"; fi
9570 echo $ac_n "checking for \"FOR_MSW\" xpm""... $ac_c" 1>&6 9594 echo $ac_n "checking for \"FOR_MSW\" xpm""... $ac_c" 1>&6
9571 echo "configure:9572: checking for \"FOR_MSW\" xpm" >&5 9595 echo "configure:9596: checking for \"FOR_MSW\" xpm" >&5
9572 xe_check_libs=-lXpm 9596 xe_check_libs=-lXpm
9573 cat > conftest.$ac_ext <<EOF 9597 cat > conftest.$ac_ext <<EOF
9574 #line 9575 "configure" 9598 #line 9599 "configure"
9575 #include "confdefs.h" 9599 #include "confdefs.h"
9576 9600
9577 int main() { 9601 int main() {
9578 XpmCreatePixmapFromData() 9602 XpmCreatePixmapFromData()
9579 ; return 0; } 9603 ; return 0; }
9580 EOF 9604 EOF
9581 if { (eval echo configure:9582: \"$ac_link\") 1>&5; (eval $ac_link) 2>&5; } && test -s conftest${ac_exeext}; then 9605 if { (eval echo configure:9606: \"$ac_link\") 1>&5; (eval $ac_link) 2>&5; } && test -s conftest${ac_exeext}; then
9582 rm -rf conftest* 9606 rm -rf conftest*
9583 xpm_for_msw=no 9607 xpm_for_msw=no
9584 else 9608 else
9585 echo "configure: failed program was:" >&5 9609 echo "configure: failed program was:" >&5
9586 cat conftest.$ac_ext >&5 9610 cat conftest.$ac_ext >&5
9602 fi 9626 fi
9603 fi 9627 fi
9604 9628
9605 test -z "$with_xface" && { ac_safe=`echo "compface.h" | sed 'y%./+-%__p_%'` 9629 test -z "$with_xface" && { ac_safe=`echo "compface.h" | sed 'y%./+-%__p_%'`
9606 echo $ac_n "checking for compface.h""... $ac_c" 1>&6 9630 echo $ac_n "checking for compface.h""... $ac_c" 1>&6
9607 echo "configure:9608: checking for compface.h" >&5 9631 echo "configure:9632: checking for compface.h" >&5
9608 9632
9609 cat > conftest.$ac_ext <<EOF 9633 cat > conftest.$ac_ext <<EOF
9610 #line 9611 "configure" 9634 #line 9635 "configure"
9611 #include "confdefs.h" 9635 #include "confdefs.h"
9612 #include <compface.h> 9636 #include <compface.h>
9613 EOF 9637 EOF
9614 ac_try="$ac_cpp conftest.$ac_ext >/dev/null 2>conftest.out" 9638 ac_try="$ac_cpp conftest.$ac_ext >/dev/null 2>conftest.out"
9615 { (eval echo configure:9616: \"$ac_try\") 1>&5; (eval $ac_try) 2>&5; } 9639 { (eval echo configure:9640: \"$ac_try\") 1>&5; (eval $ac_try) 2>&5; }
9616 ac_err=`grep -v '^ *+' conftest.out | grep -v "^conftest.${ac_ext}\$"` 9640 ac_err=`grep -v '^ *+' conftest.out | grep -v "^conftest.${ac_ext}\$"`
9617 if test -z "$ac_err"; then 9641 if test -z "$ac_err"; then
9618 rm -rf conftest* 9642 rm -rf conftest*
9619 eval "ac_cv_header_$ac_safe=yes" 9643 eval "ac_cv_header_$ac_safe=yes"
9620 else 9644 else
9633 with_xface=no 9657 with_xface=no
9634 fi 9658 fi
9635 } 9659 }
9636 test -z "$with_xface" && { 9660 test -z "$with_xface" && {
9637 echo $ac_n "checking for UnGenFace in -lcompface""... $ac_c" 1>&6 9661 echo $ac_n "checking for UnGenFace in -lcompface""... $ac_c" 1>&6
9638 echo "configure:9639: checking for UnGenFace in -lcompface" >&5 9662 echo "configure:9663: checking for UnGenFace in -lcompface" >&5
9639 ac_lib_var=`echo compface'_'UnGenFace | sed 'y%./+-%__p_%'` 9663 ac_lib_var=`echo compface'_'UnGenFace | sed 'y%./+-%__p_%'`
9640 9664
9641 xe_check_libs=" -lcompface " 9665 xe_check_libs=" -lcompface "
9642 cat > conftest.$ac_ext <<EOF 9666 cat > conftest.$ac_ext <<EOF
9643 #line 9644 "configure" 9667 #line 9668 "configure"
9644 #include "confdefs.h" 9668 #include "confdefs.h"
9645 /* Override any gcc2 internal prototype to avoid an error. */ 9669 /* Override any gcc2 internal prototype to avoid an error. */
9646 /* We use char because int might match the return type of a gcc2 9670 /* We use char because int might match the return type of a gcc2
9647 builtin and then its argument prototype would still apply. */ 9671 builtin and then its argument prototype would still apply. */
9648 char UnGenFace(); 9672 char UnGenFace();
9649 9673
9650 int main() { 9674 int main() {
9651 UnGenFace() 9675 UnGenFace()
9652 ; return 0; } 9676 ; return 0; }
9653 EOF 9677 EOF
9654 if { (eval echo configure:9655: \"$ac_link\") 1>&5; (eval $ac_link) 2>&5; } && test -s conftest${ac_exeext}; then 9678 if { (eval echo configure:9679: \"$ac_link\") 1>&5; (eval $ac_link) 2>&5; } && test -s conftest${ac_exeext}; then
9655 rm -rf conftest* 9679 rm -rf conftest*
9656 eval "ac_cv_lib_$ac_lib_var=yes" 9680 eval "ac_cv_lib_$ac_lib_var=yes"
9657 else 9681 else
9658 echo "configure: failed program was:" >&5 9682 echo "configure: failed program was:" >&5
9659 cat conftest.$ac_ext >&5 9683 cat conftest.$ac_ext >&5
9698 fi 9722 fi
9699 9723
9700 if test "$with_png $with_tiff" != "no no"; then 9724 if test "$with_png $with_tiff" != "no no"; then
9701 9725
9702 echo $ac_n "checking for inflate in -lc""... $ac_c" 1>&6 9726 echo $ac_n "checking for inflate in -lc""... $ac_c" 1>&6
9703 echo "configure:9704: checking for inflate in -lc" >&5 9727 echo "configure:9728: checking for inflate in -lc" >&5
9704 ac_lib_var=`echo c'_'inflate | sed 'y%./+-%__p_%'` 9728 ac_lib_var=`echo c'_'inflate | sed 'y%./+-%__p_%'`
9705 9729
9706 xe_check_libs=" -lc " 9730 xe_check_libs=" -lc "
9707 cat > conftest.$ac_ext <<EOF 9731 cat > conftest.$ac_ext <<EOF
9708 #line 9709 "configure" 9732 #line 9733 "configure"
9709 #include "confdefs.h" 9733 #include "confdefs.h"
9710 /* Override any gcc2 internal prototype to avoid an error. */ 9734 /* Override any gcc2 internal prototype to avoid an error. */
9711 /* We use char because int might match the return type of a gcc2 9735 /* We use char because int might match the return type of a gcc2
9712 builtin and then its argument prototype would still apply. */ 9736 builtin and then its argument prototype would still apply. */
9713 char inflate(); 9737 char inflate();
9714 9738
9715 int main() { 9739 int main() {
9716 inflate() 9740 inflate()
9717 ; return 0; } 9741 ; return 0; }
9718 EOF 9742 EOF
9719 if { (eval echo configure:9720: \"$ac_link\") 1>&5; (eval $ac_link) 2>&5; } && test -s conftest${ac_exeext}; then 9743 if { (eval echo configure:9744: \"$ac_link\") 1>&5; (eval $ac_link) 2>&5; } && test -s conftest${ac_exeext}; then
9720 rm -rf conftest* 9744 rm -rf conftest*
9721 eval "ac_cv_lib_$ac_lib_var=yes" 9745 eval "ac_cv_lib_$ac_lib_var=yes"
9722 else 9746 else
9723 echo "configure: failed program was:" >&5 9747 echo "configure: failed program was:" >&5
9724 cat conftest.$ac_ext >&5 9748 cat conftest.$ac_ext >&5
9733 : 9757 :
9734 else 9758 else
9735 echo "$ac_t""no" 1>&6 9759 echo "$ac_t""no" 1>&6
9736 9760
9737 echo $ac_n "checking for inflate in -lz""... $ac_c" 1>&6 9761 echo $ac_n "checking for inflate in -lz""... $ac_c" 1>&6
9738 echo "configure:9739: checking for inflate in -lz" >&5 9762 echo "configure:9763: checking for inflate in -lz" >&5
9739 ac_lib_var=`echo z'_'inflate | sed 'y%./+-%__p_%'` 9763 ac_lib_var=`echo z'_'inflate | sed 'y%./+-%__p_%'`
9740 9764
9741 xe_check_libs=" -lz " 9765 xe_check_libs=" -lz "
9742 cat > conftest.$ac_ext <<EOF 9766 cat > conftest.$ac_ext <<EOF
9743 #line 9744 "configure" 9767 #line 9768 "configure"
9744 #include "confdefs.h" 9768 #include "confdefs.h"
9745 /* Override any gcc2 internal prototype to avoid an error. */ 9769 /* Override any gcc2 internal prototype to avoid an error. */
9746 /* We use char because int might match the return type of a gcc2 9770 /* We use char because int might match the return type of a gcc2
9747 builtin and then its argument prototype would still apply. */ 9771 builtin and then its argument prototype would still apply. */
9748 char inflate(); 9772 char inflate();
9749 9773
9750 int main() { 9774 int main() {
9751 inflate() 9775 inflate()
9752 ; return 0; } 9776 ; return 0; }
9753 EOF 9777 EOF
9754 if { (eval echo configure:9755: \"$ac_link\") 1>&5; (eval $ac_link) 2>&5; } && test -s conftest${ac_exeext}; then 9778 if { (eval echo configure:9779: \"$ac_link\") 1>&5; (eval $ac_link) 2>&5; } && test -s conftest${ac_exeext}; then
9755 rm -rf conftest* 9779 rm -rf conftest*
9756 eval "ac_cv_lib_$ac_lib_var=yes" 9780 eval "ac_cv_lib_$ac_lib_var=yes"
9757 else 9781 else
9758 echo "configure: failed program was:" >&5 9782 echo "configure: failed program was:" >&5
9759 cat conftest.$ac_ext >&5 9783 cat conftest.$ac_ext >&5
9768 libs_x="-lz $libs_x" && if test "$extra_verbose" = "yes"; then echo " Prepending \"-lz\" to \$libs_x"; fi 9792 libs_x="-lz $libs_x" && if test "$extra_verbose" = "yes"; then echo " Prepending \"-lz\" to \$libs_x"; fi
9769 else 9793 else
9770 echo "$ac_t""no" 1>&6 9794 echo "$ac_t""no" 1>&6
9771 9795
9772 echo $ac_n "checking for inflate in -lgz""... $ac_c" 1>&6 9796 echo $ac_n "checking for inflate in -lgz""... $ac_c" 1>&6
9773 echo "configure:9774: checking for inflate in -lgz" >&5 9797 echo "configure:9798: checking for inflate in -lgz" >&5
9774 ac_lib_var=`echo gz'_'inflate | sed 'y%./+-%__p_%'` 9798 ac_lib_var=`echo gz'_'inflate | sed 'y%./+-%__p_%'`
9775 9799
9776 xe_check_libs=" -lgz " 9800 xe_check_libs=" -lgz "
9777 cat > conftest.$ac_ext <<EOF 9801 cat > conftest.$ac_ext <<EOF
9778 #line 9779 "configure" 9802 #line 9803 "configure"
9779 #include "confdefs.h" 9803 #include "confdefs.h"
9780 /* Override any gcc2 internal prototype to avoid an error. */ 9804 /* Override any gcc2 internal prototype to avoid an error. */
9781 /* We use char because int might match the return type of a gcc2 9805 /* We use char because int might match the return type of a gcc2
9782 builtin and then its argument prototype would still apply. */ 9806 builtin and then its argument prototype would still apply. */
9783 char inflate(); 9807 char inflate();
9784 9808
9785 int main() { 9809 int main() {
9786 inflate() 9810 inflate()
9787 ; return 0; } 9811 ; return 0; }
9788 EOF 9812 EOF
9789 if { (eval echo configure:9790: \"$ac_link\") 1>&5; (eval $ac_link) 2>&5; } && test -s conftest${ac_exeext}; then 9813 if { (eval echo configure:9814: \"$ac_link\") 1>&5; (eval $ac_link) 2>&5; } && test -s conftest${ac_exeext}; then
9790 rm -rf conftest* 9814 rm -rf conftest*
9791 eval "ac_cv_lib_$ac_lib_var=yes" 9815 eval "ac_cv_lib_$ac_lib_var=yes"
9792 else 9816 else
9793 echo "configure: failed program was:" >&5 9817 echo "configure: failed program was:" >&5
9794 cat conftest.$ac_ext >&5 9818 cat conftest.$ac_ext >&5
9814 9838
9815 fi 9839 fi
9816 9840
9817 test -z "$with_jpeg" && { ac_safe=`echo "jpeglib.h" | sed 'y%./+-%__p_%'` 9841 test -z "$with_jpeg" && { ac_safe=`echo "jpeglib.h" | sed 'y%./+-%__p_%'`
9818 echo $ac_n "checking for jpeglib.h""... $ac_c" 1>&6 9842 echo $ac_n "checking for jpeglib.h""... $ac_c" 1>&6
9819 echo "configure:9820: checking for jpeglib.h" >&5 9843 echo "configure:9844: checking for jpeglib.h" >&5
9820 9844
9821 cat > conftest.$ac_ext <<EOF 9845 cat > conftest.$ac_ext <<EOF
9822 #line 9823 "configure" 9846 #line 9847 "configure"
9823 #include "confdefs.h" 9847 #include "confdefs.h"
9824 #include <jpeglib.h> 9848 #include <jpeglib.h>
9825 EOF 9849 EOF
9826 ac_try="$ac_cpp conftest.$ac_ext >/dev/null 2>conftest.out" 9850 ac_try="$ac_cpp conftest.$ac_ext >/dev/null 2>conftest.out"
9827 { (eval echo configure:9828: \"$ac_try\") 1>&5; (eval $ac_try) 2>&5; } 9851 { (eval echo configure:9852: \"$ac_try\") 1>&5; (eval $ac_try) 2>&5; }
9828 ac_err=`grep -v '^ *+' conftest.out | grep -v "^conftest.${ac_ext}\$"` 9852 ac_err=`grep -v '^ *+' conftest.out | grep -v "^conftest.${ac_ext}\$"`
9829 if test -z "$ac_err"; then 9853 if test -z "$ac_err"; then
9830 rm -rf conftest* 9854 rm -rf conftest*
9831 eval "ac_cv_header_$ac_safe=yes" 9855 eval "ac_cv_header_$ac_safe=yes"
9832 else 9856 else
9845 with_jpeg=no 9869 with_jpeg=no
9846 fi 9870 fi
9847 } 9871 }
9848 test -z "$with_jpeg" && { 9872 test -z "$with_jpeg" && {
9849 echo $ac_n "checking for jpeg_destroy_decompress in -ljpeg""... $ac_c" 1>&6 9873 echo $ac_n "checking for jpeg_destroy_decompress in -ljpeg""... $ac_c" 1>&6
9850 echo "configure:9851: checking for jpeg_destroy_decompress in -ljpeg" >&5 9874 echo "configure:9875: checking for jpeg_destroy_decompress in -ljpeg" >&5
9851 ac_lib_var=`echo jpeg'_'jpeg_destroy_decompress | sed 'y%./+-%__p_%'` 9875 ac_lib_var=`echo jpeg'_'jpeg_destroy_decompress | sed 'y%./+-%__p_%'`
9852 9876
9853 xe_check_libs=" -ljpeg " 9877 xe_check_libs=" -ljpeg "
9854 cat > conftest.$ac_ext <<EOF 9878 cat > conftest.$ac_ext <<EOF
9855 #line 9856 "configure" 9879 #line 9880 "configure"
9856 #include "confdefs.h" 9880 #include "confdefs.h"
9857 /* Override any gcc2 internal prototype to avoid an error. */ 9881 /* Override any gcc2 internal prototype to avoid an error. */
9858 /* We use char because int might match the return type of a gcc2 9882 /* We use char because int might match the return type of a gcc2
9859 builtin and then its argument prototype would still apply. */ 9883 builtin and then its argument prototype would still apply. */
9860 char jpeg_destroy_decompress(); 9884 char jpeg_destroy_decompress();
9861 9885
9862 int main() { 9886 int main() {
9863 jpeg_destroy_decompress() 9887 jpeg_destroy_decompress()
9864 ; return 0; } 9888 ; return 0; }
9865 EOF 9889 EOF
9866 if { (eval echo configure:9867: \"$ac_link\") 1>&5; (eval $ac_link) 2>&5; } && test -s conftest${ac_exeext}; then 9890 if { (eval echo configure:9891: \"$ac_link\") 1>&5; (eval $ac_link) 2>&5; } && test -s conftest${ac_exeext}; then
9867 rm -rf conftest* 9891 rm -rf conftest*
9868 eval "ac_cv_lib_$ac_lib_var=yes" 9892 eval "ac_cv_lib_$ac_lib_var=yes"
9869 else 9893 else
9870 echo "configure: failed program was:" >&5 9894 echo "configure: failed program was:" >&5
9871 cat conftest.$ac_ext >&5 9895 cat conftest.$ac_ext >&5
9897 libs_x="-ljpeg $libs_x" && if test "$extra_verbose" = "yes"; then echo " Prepending \"-ljpeg\" to \$libs_x"; fi 9921 libs_x="-ljpeg $libs_x" && if test "$extra_verbose" = "yes"; then echo " Prepending \"-ljpeg\" to \$libs_x"; fi
9898 fi 9922 fi
9899 9923
9900 png_problem="" 9924 png_problem=""
9901 test -z "$with_png" && { echo $ac_n "checking for pow""... $ac_c" 1>&6 9925 test -z "$with_png" && { echo $ac_n "checking for pow""... $ac_c" 1>&6
9902 echo "configure:9903: checking for pow" >&5 9926 echo "configure:9927: checking for pow" >&5
9903 9927
9904 cat > conftest.$ac_ext <<EOF 9928 cat > conftest.$ac_ext <<EOF
9905 #line 9906 "configure" 9929 #line 9930 "configure"
9906 #include "confdefs.h" 9930 #include "confdefs.h"
9907 /* System header to define __stub macros and hopefully few prototypes, 9931 /* System header to define __stub macros and hopefully few prototypes,
9908 which can conflict with char pow(); below. */ 9932 which can conflict with char pow(); below. */
9909 #include <assert.h> 9933 #include <assert.h>
9910 /* Override any gcc2 internal prototype to avoid an error. */ 9934 /* Override any gcc2 internal prototype to avoid an error. */
9923 pow(); 9947 pow();
9924 #endif 9948 #endif
9925 9949
9926 ; return 0; } 9950 ; return 0; }
9927 EOF 9951 EOF
9928 if { (eval echo configure:9929: \"$ac_link\") 1>&5; (eval $ac_link) 2>&5; } && test -s conftest${ac_exeext}; then 9952 if { (eval echo configure:9953: \"$ac_link\") 1>&5; (eval $ac_link) 2>&5; } && test -s conftest${ac_exeext}; then
9929 rm -rf conftest* 9953 rm -rf conftest*
9930 eval "ac_cv_func_pow=yes" 9954 eval "ac_cv_func_pow=yes"
9931 else 9955 else
9932 echo "configure: failed program was:" >&5 9956 echo "configure: failed program was:" >&5
9933 cat conftest.$ac_ext >&5 9957 cat conftest.$ac_ext >&5
9944 with_png=no 9968 with_png=no
9945 fi 9969 fi
9946 } 9970 }
9947 test -z "$with_png" && { ac_safe=`echo "png.h" | sed 'y%./+-%__p_%'` 9971 test -z "$with_png" && { ac_safe=`echo "png.h" | sed 'y%./+-%__p_%'`
9948 echo $ac_n "checking for png.h""... $ac_c" 1>&6 9972 echo $ac_n "checking for png.h""... $ac_c" 1>&6
9949 echo "configure:9950: checking for png.h" >&5 9973 echo "configure:9974: checking for png.h" >&5
9950 9974
9951 cat > conftest.$ac_ext <<EOF 9975 cat > conftest.$ac_ext <<EOF
9952 #line 9953 "configure" 9976 #line 9977 "configure"
9953 #include "confdefs.h" 9977 #include "confdefs.h"
9954 #include <png.h> 9978 #include <png.h>
9955 EOF 9979 EOF
9956 ac_try="$ac_cpp conftest.$ac_ext >/dev/null 2>conftest.out" 9980 ac_try="$ac_cpp conftest.$ac_ext >/dev/null 2>conftest.out"
9957 { (eval echo configure:9958: \"$ac_try\") 1>&5; (eval $ac_try) 2>&5; } 9981 { (eval echo configure:9982: \"$ac_try\") 1>&5; (eval $ac_try) 2>&5; }
9958 ac_err=`grep -v '^ *+' conftest.out | grep -v "^conftest.${ac_ext}\$"` 9982 ac_err=`grep -v '^ *+' conftest.out | grep -v "^conftest.${ac_ext}\$"`
9959 if test -z "$ac_err"; then 9983 if test -z "$ac_err"; then
9960 rm -rf conftest* 9984 rm -rf conftest*
9961 eval "ac_cv_header_$ac_safe=yes" 9985 eval "ac_cv_header_$ac_safe=yes"
9962 else 9986 else
9975 with_png=no 9999 with_png=no
9976 fi 10000 fi
9977 } 10001 }
9978 test -z "$with_png" && { 10002 test -z "$with_png" && {
9979 echo $ac_n "checking for png_read_image in -lpng""... $ac_c" 1>&6 10003 echo $ac_n "checking for png_read_image in -lpng""... $ac_c" 1>&6
9980 echo "configure:9981: checking for png_read_image in -lpng" >&5 10004 echo "configure:10005: checking for png_read_image in -lpng" >&5
9981 ac_lib_var=`echo png'_'png_read_image | sed 'y%./+-%__p_%'` 10005 ac_lib_var=`echo png'_'png_read_image | sed 'y%./+-%__p_%'`
9982 10006
9983 xe_check_libs=" -lpng " 10007 xe_check_libs=" -lpng "
9984 cat > conftest.$ac_ext <<EOF 10008 cat > conftest.$ac_ext <<EOF
9985 #line 9986 "configure" 10009 #line 10010 "configure"
9986 #include "confdefs.h" 10010 #include "confdefs.h"
9987 /* Override any gcc2 internal prototype to avoid an error. */ 10011 /* Override any gcc2 internal prototype to avoid an error. */
9988 /* We use char because int might match the return type of a gcc2 10012 /* We use char because int might match the return type of a gcc2
9989 builtin and then its argument prototype would still apply. */ 10013 builtin and then its argument prototype would still apply. */
9990 char png_read_image(); 10014 char png_read_image();
9991 10015
9992 int main() { 10016 int main() {
9993 png_read_image() 10017 png_read_image()
9994 ; return 0; } 10018 ; return 0; }
9995 EOF 10019 EOF
9996 if { (eval echo configure:9997: \"$ac_link\") 1>&5; (eval $ac_link) 2>&5; } && test -s conftest${ac_exeext}; then 10020 if { (eval echo configure:10021: \"$ac_link\") 1>&5; (eval $ac_link) 2>&5; } && test -s conftest${ac_exeext}; then
9997 rm -rf conftest* 10021 rm -rf conftest*
9998 eval "ac_cv_lib_$ac_lib_var=yes" 10022 eval "ac_cv_lib_$ac_lib_var=yes"
9999 else 10023 else
10000 echo "configure: failed program was:" >&5 10024 echo "configure: failed program was:" >&5
10001 cat conftest.$ac_ext >&5 10025 cat conftest.$ac_ext >&5
10014 fi 10038 fi
10015 10039
10016 } 10040 }
10017 if test -z "$with_png"; then 10041 if test -z "$with_png"; then
10018 echo $ac_n "checking for workable png version information""... $ac_c" 1>&6 10042 echo $ac_n "checking for workable png version information""... $ac_c" 1>&6
10019 echo "configure:10020: checking for workable png version information" >&5 10043 echo "configure:10044: checking for workable png version information" >&5
10020 xe_check_libs="-lpng -lz" 10044 xe_check_libs="-lpng -lz"
10021 cat > conftest.$ac_ext <<EOF 10045 cat > conftest.$ac_ext <<EOF
10022 #line 10023 "configure" 10046 #line 10047 "configure"
10023 #include "confdefs.h" 10047 #include "confdefs.h"
10024 #include <png.h> 10048 #include <png.h>
10025 int main(int c, char **v) { 10049 int main(int c, char **v) {
10026 if (c == 1) return 0; 10050 if (c == 1) return 0;
10027 if (strcmp(png_libpng_ver, PNG_LIBPNG_VER_STRING) != 0) return 1; 10051 if (strcmp(png_libpng_ver, PNG_LIBPNG_VER_STRING) != 0) return 1;
10028 return (PNG_LIBPNG_VER < 10002) ? 2 : 0 ;} 10052 return (PNG_LIBPNG_VER < 10002) ? 2 : 0 ;}
10029 EOF 10053 EOF
10030 if { (eval echo configure:10031: \"$ac_link\") 1>&5; (eval $ac_link) 2>&5; } && test -s conftest && (./conftest; exit $?) 2>&5 10054 if { (eval echo configure:10055: \"$ac_link\") 1>&5; (eval $ac_link) 2>&5; } && test -s conftest && (./conftest; exit $?) 2>&5
10031 then 10055 then
10032 ./conftest dummy_arg; png_status=$?; 10056 ./conftest dummy_arg; png_status=$?;
10033 if test "$png_status" = "0"; then 10057 if test "$png_status" = "0"; then
10034 with_png=yes; 10058 with_png=yes;
10035 else 10059 else
10068 libs_x="-lpng $libs_x" && if test "$extra_verbose" = "yes"; then echo " Prepending \"-lpng\" to \$libs_x"; fi 10092 libs_x="-lpng $libs_x" && if test "$extra_verbose" = "yes"; then echo " Prepending \"-lpng\" to \$libs_x"; fi
10069 fi 10093 fi
10070 10094
10071 test -z "$with_tiff" && { ac_safe=`echo "tiffio.h" | sed 'y%./+-%__p_%'` 10095 test -z "$with_tiff" && { ac_safe=`echo "tiffio.h" | sed 'y%./+-%__p_%'`
10072 echo $ac_n "checking for tiffio.h""... $ac_c" 1>&6 10096 echo $ac_n "checking for tiffio.h""... $ac_c" 1>&6
10073 echo "configure:10074: checking for tiffio.h" >&5 10097 echo "configure:10098: checking for tiffio.h" >&5
10074 10098
10075 cat > conftest.$ac_ext <<EOF 10099 cat > conftest.$ac_ext <<EOF
10076 #line 10077 "configure" 10100 #line 10101 "configure"
10077 #include "confdefs.h" 10101 #include "confdefs.h"
10078 #include <tiffio.h> 10102 #include <tiffio.h>
10079 EOF 10103 EOF
10080 ac_try="$ac_cpp conftest.$ac_ext >/dev/null 2>conftest.out" 10104 ac_try="$ac_cpp conftest.$ac_ext >/dev/null 2>conftest.out"
10081 { (eval echo configure:10082: \"$ac_try\") 1>&5; (eval $ac_try) 2>&5; } 10105 { (eval echo configure:10106: \"$ac_try\") 1>&5; (eval $ac_try) 2>&5; }
10082 ac_err=`grep -v '^ *+' conftest.out | grep -v "^conftest.${ac_ext}\$"` 10106 ac_err=`grep -v '^ *+' conftest.out | grep -v "^conftest.${ac_ext}\$"`
10083 if test -z "$ac_err"; then 10107 if test -z "$ac_err"; then
10084 rm -rf conftest* 10108 rm -rf conftest*
10085 eval "ac_cv_header_$ac_safe=yes" 10109 eval "ac_cv_header_$ac_safe=yes"
10086 else 10110 else
10099 with_tiff=no 10123 with_tiff=no
10100 fi 10124 fi
10101 } 10125 }
10102 test -z "$with_tiff" && { 10126 test -z "$with_tiff" && {
10103 echo $ac_n "checking for TIFFClientOpen in -ltiff""... $ac_c" 1>&6 10127 echo $ac_n "checking for TIFFClientOpen in -ltiff""... $ac_c" 1>&6
10104 echo "configure:10105: checking for TIFFClientOpen in -ltiff" >&5 10128 echo "configure:10129: checking for TIFFClientOpen in -ltiff" >&5
10105 ac_lib_var=`echo tiff'_'TIFFClientOpen | sed 'y%./+-%__p_%'` 10129 ac_lib_var=`echo tiff'_'TIFFClientOpen | sed 'y%./+-%__p_%'`
10106 10130
10107 xe_check_libs=" -ltiff " 10131 xe_check_libs=" -ltiff "
10108 cat > conftest.$ac_ext <<EOF 10132 cat > conftest.$ac_ext <<EOF
10109 #line 10110 "configure" 10133 #line 10134 "configure"
10110 #include "confdefs.h" 10134 #include "confdefs.h"
10111 /* Override any gcc2 internal prototype to avoid an error. */ 10135 /* Override any gcc2 internal prototype to avoid an error. */
10112 /* We use char because int might match the return type of a gcc2 10136 /* We use char because int might match the return type of a gcc2
10113 builtin and then its argument prototype would still apply. */ 10137 builtin and then its argument prototype would still apply. */
10114 char TIFFClientOpen(); 10138 char TIFFClientOpen();
10115 10139
10116 int main() { 10140 int main() {
10117 TIFFClientOpen() 10141 TIFFClientOpen()
10118 ; return 0; } 10142 ; return 0; }
10119 EOF 10143 EOF
10120 if { (eval echo configure:10121: \"$ac_link\") 1>&5; (eval $ac_link) 2>&5; } && test -s conftest${ac_exeext}; then 10144 if { (eval echo configure:10145: \"$ac_link\") 1>&5; (eval $ac_link) 2>&5; } && test -s conftest${ac_exeext}; then
10121 rm -rf conftest* 10145 rm -rf conftest*
10122 eval "ac_cv_lib_$ac_lib_var=yes" 10146 eval "ac_cv_lib_$ac_lib_var=yes"
10123 else 10147 else
10124 echo "configure: failed program was:" >&5 10148 echo "configure: failed program was:" >&5
10125 cat conftest.$ac_ext >&5 10149 cat conftest.$ac_ext >&5
10154 10178
10155 10179
10156 if test "$with_gtk" = "yes"; then 10180 if test "$with_gtk" = "yes"; then
10157 test -z "$with_xface" && { ac_safe=`echo "compface.h" | sed 'y%./+-%__p_%'` 10181 test -z "$with_xface" && { ac_safe=`echo "compface.h" | sed 'y%./+-%__p_%'`
10158 echo $ac_n "checking for compface.h""... $ac_c" 1>&6 10182 echo $ac_n "checking for compface.h""... $ac_c" 1>&6
10159 echo "configure:10160: checking for compface.h" >&5 10183 echo "configure:10184: checking for compface.h" >&5
10160 10184
10161 cat > conftest.$ac_ext <<EOF 10185 cat > conftest.$ac_ext <<EOF
10162 #line 10163 "configure" 10186 #line 10187 "configure"
10163 #include "confdefs.h" 10187 #include "confdefs.h"
10164 #include <compface.h> 10188 #include <compface.h>
10165 EOF 10189 EOF
10166 ac_try="$ac_cpp conftest.$ac_ext >/dev/null 2>conftest.out" 10190 ac_try="$ac_cpp conftest.$ac_ext >/dev/null 2>conftest.out"
10167 { (eval echo configure:10168: \"$ac_try\") 1>&5; (eval $ac_try) 2>&5; } 10191 { (eval echo configure:10192: \"$ac_try\") 1>&5; (eval $ac_try) 2>&5; }
10168 ac_err=`grep -v '^ *+' conftest.out | grep -v "^conftest.${ac_ext}\$"` 10192 ac_err=`grep -v '^ *+' conftest.out | grep -v "^conftest.${ac_ext}\$"`
10169 if test -z "$ac_err"; then 10193 if test -z "$ac_err"; then
10170 rm -rf conftest* 10194 rm -rf conftest*
10171 eval "ac_cv_header_$ac_safe=yes" 10195 eval "ac_cv_header_$ac_safe=yes"
10172 else 10196 else
10185 with_xface=no 10209 with_xface=no
10186 fi 10210 fi
10187 } 10211 }
10188 test -z "$with_xface" && { 10212 test -z "$with_xface" && {
10189 echo $ac_n "checking for UnGenFace in -lcompface""... $ac_c" 1>&6 10213 echo $ac_n "checking for UnGenFace in -lcompface""... $ac_c" 1>&6
10190 echo "configure:10191: checking for UnGenFace in -lcompface" >&5 10214 echo "configure:10215: checking for UnGenFace in -lcompface" >&5
10191 ac_lib_var=`echo compface'_'UnGenFace | sed 'y%./+-%__p_%'` 10215 ac_lib_var=`echo compface'_'UnGenFace | sed 'y%./+-%__p_%'`
10192 10216
10193 xe_check_libs=" -lcompface " 10217 xe_check_libs=" -lcompface "
10194 cat > conftest.$ac_ext <<EOF 10218 cat > conftest.$ac_ext <<EOF
10195 #line 10196 "configure" 10219 #line 10220 "configure"
10196 #include "confdefs.h" 10220 #include "confdefs.h"
10197 /* Override any gcc2 internal prototype to avoid an error. */ 10221 /* Override any gcc2 internal prototype to avoid an error. */
10198 /* We use char because int might match the return type of a gcc2 10222 /* We use char because int might match the return type of a gcc2
10199 builtin and then its argument prototype would still apply. */ 10223 builtin and then its argument prototype would still apply. */
10200 char UnGenFace(); 10224 char UnGenFace();
10201 10225
10202 int main() { 10226 int main() {
10203 UnGenFace() 10227 UnGenFace()
10204 ; return 0; } 10228 ; return 0; }
10205 EOF 10229 EOF
10206 if { (eval echo configure:10207: \"$ac_link\") 1>&5; (eval $ac_link) 2>&5; } && test -s conftest${ac_exeext}; then 10230 if { (eval echo configure:10231: \"$ac_link\") 1>&5; (eval $ac_link) 2>&5; } && test -s conftest${ac_exeext}; then
10207 rm -rf conftest* 10231 rm -rf conftest*
10208 eval "ac_cv_lib_$ac_lib_var=yes" 10232 eval "ac_cv_lib_$ac_lib_var=yes"
10209 else 10233 else
10210 echo "configure: failed program was:" >&5 10234 echo "configure: failed program was:" >&5
10211 cat conftest.$ac_ext >&5 10235 cat conftest.$ac_ext >&5
10240 10264
10241 10265
10242 10266
10243 if test "$with_x11" = "yes"; then 10267 if test "$with_x11" = "yes"; then
10244 echo "checking for X11 graphics libraries" 1>&6 10268 echo "checking for X11 graphics libraries" 1>&6
10245 echo "configure:10246: checking for X11 graphics libraries" >&5 10269 echo "configure:10270: checking for X11 graphics libraries" >&5
10246 fi 10270 fi
10247 10271
10248 case "$with_widgets" in 10272 case "$with_widgets" in
10249 "yes" | "athena") detect_athena=yes ;; 10273 "yes" | "athena") detect_athena=yes ;;
10250 *) detect_athena=no ;; 10274 *) detect_athena=no ;;
10251 esac 10275 esac
10252 10276
10253 if test "$with_x11" = "yes" -a "$detect_athena" = "yes" ; then 10277 if test "$with_x11" = "yes" -a "$detect_athena" = "yes" ; then
10254 echo "checking for the Athena widgets" 1>&6 10278 echo "checking for the Athena widgets" 1>&6
10255 echo "configure:10256: checking for the Athena widgets" >&5 10279 echo "configure:10280: checking for the Athena widgets" >&5
10256 10280
10257 case "$with_athena" in 10281 case "$with_athena" in
10258 "xaw" | "") athena_variant=Xaw athena_3d=no ;; 10282 "xaw" | "") athena_variant=Xaw athena_3d=no ;;
10259 "3d") athena_variant=Xaw3d athena_3d=yes ;; 10283 "3d") athena_variant=Xaw3d athena_3d=yes ;;
10260 "next") athena_variant=neXtaw athena_3d=yes ;; 10284 "next") athena_variant=neXtaw athena_3d=yes ;;
10264 esac 10288 esac
10265 10289
10266 if test "$athena_3d" = "no"; then 10290 if test "$athena_3d" = "no"; then
10267 10291
10268 echo $ac_n "checking for XawScrollbarSetThumb in -l$athena_variant""... $ac_c" 1>&6 10292 echo $ac_n "checking for XawScrollbarSetThumb in -l$athena_variant""... $ac_c" 1>&6
10269 echo "configure:10270: checking for XawScrollbarSetThumb in -l$athena_variant" >&5 10293 echo "configure:10294: checking for XawScrollbarSetThumb in -l$athena_variant" >&5
10270 ac_lib_var=`echo $athena_variant'_'XawScrollbarSetThumb | sed 'y%./+-%__p_%'` 10294 ac_lib_var=`echo $athena_variant'_'XawScrollbarSetThumb | sed 'y%./+-%__p_%'`
10271 10295
10272 xe_check_libs=" -l$athena_variant " 10296 xe_check_libs=" -l$athena_variant "
10273 cat > conftest.$ac_ext <<EOF 10297 cat > conftest.$ac_ext <<EOF
10274 #line 10275 "configure" 10298 #line 10299 "configure"
10275 #include "confdefs.h" 10299 #include "confdefs.h"
10276 /* Override any gcc2 internal prototype to avoid an error. */ 10300 /* Override any gcc2 internal prototype to avoid an error. */
10277 /* We use char because int might match the return type of a gcc2 10301 /* We use char because int might match the return type of a gcc2
10278 builtin and then its argument prototype would still apply. */ 10302 builtin and then its argument prototype would still apply. */
10279 char XawScrollbarSetThumb(); 10303 char XawScrollbarSetThumb();
10280 10304
10281 int main() { 10305 int main() {
10282 XawScrollbarSetThumb() 10306 XawScrollbarSetThumb()
10283 ; return 0; } 10307 ; return 0; }
10284 EOF 10308 EOF
10285 if { (eval echo configure:10286: \"$ac_link\") 1>&5; (eval $ac_link) 2>&5; } && test -s conftest${ac_exeext}; then 10309 if { (eval echo configure:10310: \"$ac_link\") 1>&5; (eval $ac_link) 2>&5; } && test -s conftest${ac_exeext}; then
10286 rm -rf conftest* 10310 rm -rf conftest*
10287 eval "ac_cv_lib_$ac_lib_var=yes" 10311 eval "ac_cv_lib_$ac_lib_var=yes"
10288 else 10312 else
10289 echo "configure: failed program was:" >&5 10313 echo "configure: failed program was:" >&5
10290 cat conftest.$ac_ext >&5 10314 cat conftest.$ac_ext >&5
10296 10320
10297 if eval "test \"`echo '$ac_cv_lib_'$ac_lib_var`\" = yes" ; then 10321 if eval "test \"`echo '$ac_cv_lib_'$ac_lib_var`\" = yes" ; then
10298 echo "$ac_t""yes" 1>&6 10322 echo "$ac_t""yes" 1>&6
10299 10323
10300 echo $ac_n "checking for threeDClassRec in -l$athena_variant""... $ac_c" 1>&6 10324 echo $ac_n "checking for threeDClassRec in -l$athena_variant""... $ac_c" 1>&6
10301 echo "configure:10302: checking for threeDClassRec in -l$athena_variant" >&5 10325 echo "configure:10326: checking for threeDClassRec in -l$athena_variant" >&5
10302 ac_lib_var=`echo $athena_variant'_'threeDClassRec | sed 'y%./+-%__p_%'` 10326 ac_lib_var=`echo $athena_variant'_'threeDClassRec | sed 'y%./+-%__p_%'`
10303 10327
10304 xe_check_libs=" -l$athena_variant " 10328 xe_check_libs=" -l$athena_variant "
10305 cat > conftest.$ac_ext <<EOF 10329 cat > conftest.$ac_ext <<EOF
10306 #line 10307 "configure" 10330 #line 10331 "configure"
10307 #include "confdefs.h" 10331 #include "confdefs.h"
10308 /* Override any gcc2 internal prototype to avoid an error. */ 10332 /* Override any gcc2 internal prototype to avoid an error. */
10309 /* We use char because int might match the return type of a gcc2 10333 /* We use char because int might match the return type of a gcc2
10310 builtin and then its argument prototype would still apply. */ 10334 builtin and then its argument prototype would still apply. */
10311 char threeDClassRec(); 10335 char threeDClassRec();
10312 10336
10313 int main() { 10337 int main() {
10314 threeDClassRec() 10338 threeDClassRec()
10315 ; return 0; } 10339 ; return 0; }
10316 EOF 10340 EOF
10317 if { (eval echo configure:10318: \"$ac_link\") 1>&5; (eval $ac_link) 2>&5; } && test -s conftest${ac_exeext}; then 10341 if { (eval echo configure:10342: \"$ac_link\") 1>&5; (eval $ac_link) 2>&5; } && test -s conftest${ac_exeext}; then
10318 rm -rf conftest* 10342 rm -rf conftest*
10319 eval "ac_cv_lib_$ac_lib_var=yes" 10343 eval "ac_cv_lib_$ac_lib_var=yes"
10320 else 10344 else
10321 echo "configure: failed program was:" >&5 10345 echo "configure: failed program was:" >&5
10322 cat conftest.$ac_ext >&5 10346 cat conftest.$ac_ext >&5
10343 10367
10344 10368
10345 else 10369 else
10346 10370
10347 echo $ac_n "checking for threeDClassRec in -l$athena_variant""... $ac_c" 1>&6 10371 echo $ac_n "checking for threeDClassRec in -l$athena_variant""... $ac_c" 1>&6
10348 echo "configure:10349: checking for threeDClassRec in -l$athena_variant" >&5 10372 echo "configure:10373: checking for threeDClassRec in -l$athena_variant" >&5
10349 ac_lib_var=`echo $athena_variant'_'threeDClassRec | sed 'y%./+-%__p_%'` 10373 ac_lib_var=`echo $athena_variant'_'threeDClassRec | sed 'y%./+-%__p_%'`
10350 10374
10351 xe_check_libs=" -l$athena_variant " 10375 xe_check_libs=" -l$athena_variant "
10352 cat > conftest.$ac_ext <<EOF 10376 cat > conftest.$ac_ext <<EOF
10353 #line 10354 "configure" 10377 #line 10378 "configure"
10354 #include "confdefs.h" 10378 #include "confdefs.h"
10355 /* Override any gcc2 internal prototype to avoid an error. */ 10379 /* Override any gcc2 internal prototype to avoid an error. */
10356 /* We use char because int might match the return type of a gcc2 10380 /* We use char because int might match the return type of a gcc2
10357 builtin and then its argument prototype would still apply. */ 10381 builtin and then its argument prototype would still apply. */
10358 char threeDClassRec(); 10382 char threeDClassRec();
10359 10383
10360 int main() { 10384 int main() {
10361 threeDClassRec() 10385 threeDClassRec()
10362 ; return 0; } 10386 ; return 0; }
10363 EOF 10387 EOF
10364 if { (eval echo configure:10365: \"$ac_link\") 1>&5; (eval $ac_link) 2>&5; } && test -s conftest${ac_exeext}; then 10388 if { (eval echo configure:10389: \"$ac_link\") 1>&5; (eval $ac_link) 2>&5; } && test -s conftest${ac_exeext}; then
10365 rm -rf conftest* 10389 rm -rf conftest*
10366 eval "ac_cv_lib_$ac_lib_var=yes" 10390 eval "ac_cv_lib_$ac_lib_var=yes"
10367 else 10391 else
10368 echo "configure: failed program was:" >&5 10392 echo "configure: failed program was:" >&5
10369 cat conftest.$ac_ext >&5 10393 cat conftest.$ac_ext >&5
10377 echo "$ac_t""yes" 1>&6 10401 echo "$ac_t""yes" 1>&6
10378 athena_lib=$athena_variant 10402 athena_lib=$athena_variant
10379 else 10403 else
10380 echo "$ac_t""no" 1>&6 10404 echo "$ac_t""no" 1>&6
10381 echo $ac_n "checking for threeDClassRec in -lXaw""... $ac_c" 1>&6 10405 echo $ac_n "checking for threeDClassRec in -lXaw""... $ac_c" 1>&6
10382 echo "configure:10383: checking for threeDClassRec in -lXaw" >&5 10406 echo "configure:10407: checking for threeDClassRec in -lXaw" >&5
10383 ac_lib_var=`echo Xaw'_'threeDClassRec | sed 'y%./+-%__p_%'` 10407 ac_lib_var=`echo Xaw'_'threeDClassRec | sed 'y%./+-%__p_%'`
10384 10408
10385 xe_check_libs=" -lXaw " 10409 xe_check_libs=" -lXaw "
10386 cat > conftest.$ac_ext <<EOF 10410 cat > conftest.$ac_ext <<EOF
10387 #line 10388 "configure" 10411 #line 10412 "configure"
10388 #include "confdefs.h" 10412 #include "confdefs.h"
10389 /* Override any gcc2 internal prototype to avoid an error. */ 10413 /* Override any gcc2 internal prototype to avoid an error. */
10390 /* We use char because int might match the return type of a gcc2 10414 /* We use char because int might match the return type of a gcc2
10391 builtin and then its argument prototype would still apply. */ 10415 builtin and then its argument prototype would still apply. */
10392 char threeDClassRec(); 10416 char threeDClassRec();
10393 10417
10394 int main() { 10418 int main() {
10395 threeDClassRec() 10419 threeDClassRec()
10396 ; return 0; } 10420 ; return 0; }
10397 EOF 10421 EOF
10398 if { (eval echo configure:10399: \"$ac_link\") 1>&5; (eval $ac_link) 2>&5; } && test -s conftest${ac_exeext}; then 10422 if { (eval echo configure:10423: \"$ac_link\") 1>&5; (eval $ac_link) 2>&5; } && test -s conftest${ac_exeext}; then
10399 rm -rf conftest* 10423 rm -rf conftest*
10400 eval "ac_cv_lib_$ac_lib_var=yes" 10424 eval "ac_cv_lib_$ac_lib_var=yes"
10401 else 10425 else
10402 echo "configure: failed program was:" >&5 10426 echo "configure: failed program was:" >&5
10403 cat conftest.$ac_ext >&5 10427 cat conftest.$ac_ext >&5
10424 fi 10448 fi
10425 10449
10426 if test "$athena_3d" = "no"; then 10450 if test "$athena_3d" = "no"; then
10427 ac_safe=`echo "X11/Xaw/ThreeD.h" | sed 'y%./+-%__p_%'` 10451 ac_safe=`echo "X11/Xaw/ThreeD.h" | sed 'y%./+-%__p_%'`
10428 echo $ac_n "checking for X11/Xaw/ThreeD.h""... $ac_c" 1>&6 10452 echo $ac_n "checking for X11/Xaw/ThreeD.h""... $ac_c" 1>&6
10429 echo "configure:10430: checking for X11/Xaw/ThreeD.h" >&5 10453 echo "configure:10454: checking for X11/Xaw/ThreeD.h" >&5
10430 10454
10431 cat > conftest.$ac_ext <<EOF 10455 cat > conftest.$ac_ext <<EOF
10432 #line 10433 "configure" 10456 #line 10457 "configure"
10433 #include "confdefs.h" 10457 #include "confdefs.h"
10434 #include <X11/Xaw/ThreeD.h> 10458 #include <X11/Xaw/ThreeD.h>
10435 EOF 10459 EOF
10436 ac_try="$ac_cpp conftest.$ac_ext >/dev/null 2>conftest.out" 10460 ac_try="$ac_cpp conftest.$ac_ext >/dev/null 2>conftest.out"
10437 { (eval echo configure:10438: \"$ac_try\") 1>&5; (eval $ac_try) 2>&5; } 10461 { (eval echo configure:10462: \"$ac_try\") 1>&5; (eval $ac_try) 2>&5; }
10438 ac_err=`grep -v '^ *+' conftest.out | grep -v "^conftest.${ac_ext}\$"` 10462 ac_err=`grep -v '^ *+' conftest.out | grep -v "^conftest.${ac_ext}\$"`
10439 if test -z "$ac_err"; then 10463 if test -z "$ac_err"; then
10440 rm -rf conftest* 10464 rm -rf conftest*
10441 eval "ac_cv_header_$ac_safe=yes" 10465 eval "ac_cv_header_$ac_safe=yes"
10442 else 10466 else
10452 echo "configure: warning: Could not find a non-3d Athena header set." 1>&2 10476 echo "configure: warning: Could not find a non-3d Athena header set." 1>&2
10453 else 10477 else
10454 echo "$ac_t""no" 1>&6 10478 echo "$ac_t""no" 1>&6
10455 ac_safe=`echo "X11/Xaw/XawInit.h" | sed 'y%./+-%__p_%'` 10479 ac_safe=`echo "X11/Xaw/XawInit.h" | sed 'y%./+-%__p_%'`
10456 echo $ac_n "checking for X11/Xaw/XawInit.h""... $ac_c" 1>&6 10480 echo $ac_n "checking for X11/Xaw/XawInit.h""... $ac_c" 1>&6
10457 echo "configure:10458: checking for X11/Xaw/XawInit.h" >&5 10481 echo "configure:10482: checking for X11/Xaw/XawInit.h" >&5
10458 10482
10459 cat > conftest.$ac_ext <<EOF 10483 cat > conftest.$ac_ext <<EOF
10460 #line 10461 "configure" 10484 #line 10485 "configure"
10461 #include "confdefs.h" 10485 #include "confdefs.h"
10462 #include <X11/Xaw/XawInit.h> 10486 #include <X11/Xaw/XawInit.h>
10463 EOF 10487 EOF
10464 ac_try="$ac_cpp conftest.$ac_ext >/dev/null 2>conftest.out" 10488 ac_try="$ac_cpp conftest.$ac_ext >/dev/null 2>conftest.out"
10465 { (eval echo configure:10466: \"$ac_try\") 1>&5; (eval $ac_try) 2>&5; } 10489 { (eval echo configure:10490: \"$ac_try\") 1>&5; (eval $ac_try) 2>&5; }
10466 ac_err=`grep -v '^ *+' conftest.out | grep -v "^conftest.${ac_ext}\$"` 10490 ac_err=`grep -v '^ *+' conftest.out | grep -v "^conftest.${ac_ext}\$"`
10467 if test -z "$ac_err"; then 10491 if test -z "$ac_err"; then
10468 rm -rf conftest* 10492 rm -rf conftest*
10469 eval "ac_cv_header_$ac_safe=yes" 10493 eval "ac_cv_header_$ac_safe=yes"
10470 else 10494 else
10486 fi 10510 fi
10487 10511
10488 else 10512 else
10489 ac_safe=`echo "X11/$athena_variant/XawInit.h" | sed 'y%./+-%__p_%'` 10513 ac_safe=`echo "X11/$athena_variant/XawInit.h" | sed 'y%./+-%__p_%'`
10490 echo $ac_n "checking for X11/$athena_variant/XawInit.h""... $ac_c" 1>&6 10514 echo $ac_n "checking for X11/$athena_variant/XawInit.h""... $ac_c" 1>&6
10491 echo "configure:10492: checking for X11/$athena_variant/XawInit.h" >&5 10515 echo "configure:10516: checking for X11/$athena_variant/XawInit.h" >&5
10492 10516
10493 cat > conftest.$ac_ext <<EOF 10517 cat > conftest.$ac_ext <<EOF
10494 #line 10495 "configure" 10518 #line 10519 "configure"
10495 #include "confdefs.h" 10519 #include "confdefs.h"
10496 #include <X11/$athena_variant/XawInit.h> 10520 #include <X11/$athena_variant/XawInit.h>
10497 EOF 10521 EOF
10498 ac_try="$ac_cpp conftest.$ac_ext >/dev/null 2>conftest.out" 10522 ac_try="$ac_cpp conftest.$ac_ext >/dev/null 2>conftest.out"
10499 { (eval echo configure:10500: \"$ac_try\") 1>&5; (eval $ac_try) 2>&5; } 10523 { (eval echo configure:10524: \"$ac_try\") 1>&5; (eval $ac_try) 2>&5; }
10500 ac_err=`grep -v '^ *+' conftest.out | grep -v "^conftest.${ac_ext}\$"` 10524 ac_err=`grep -v '^ *+' conftest.out | grep -v "^conftest.${ac_ext}\$"`
10501 if test -z "$ac_err"; then 10525 if test -z "$ac_err"; then
10502 rm -rf conftest* 10526 rm -rf conftest*
10503 eval "ac_cv_header_$ac_safe=yes" 10527 eval "ac_cv_header_$ac_safe=yes"
10504 else 10528 else
10511 rm -f conftest* 10535 rm -f conftest*
10512 if eval "test \"`echo '$ac_cv_header_'$ac_safe`\" = yes"; then 10536 if eval "test \"`echo '$ac_cv_header_'$ac_safe`\" = yes"; then
10513 echo "$ac_t""yes" 1>&6 10537 echo "$ac_t""yes" 1>&6
10514 ac_safe=`echo "X11/$athena_variant/ThreeD.h" | sed 'y%./+-%__p_%'` 10538 ac_safe=`echo "X11/$athena_variant/ThreeD.h" | sed 'y%./+-%__p_%'`
10515 echo $ac_n "checking for X11/$athena_variant/ThreeD.h""... $ac_c" 1>&6 10539 echo $ac_n "checking for X11/$athena_variant/ThreeD.h""... $ac_c" 1>&6
10516 echo "configure:10517: checking for X11/$athena_variant/ThreeD.h" >&5 10540 echo "configure:10541: checking for X11/$athena_variant/ThreeD.h" >&5
10517 10541
10518 cat > conftest.$ac_ext <<EOF 10542 cat > conftest.$ac_ext <<EOF
10519 #line 10520 "configure" 10543 #line 10544 "configure"
10520 #include "confdefs.h" 10544 #include "confdefs.h"
10521 #include <X11/$athena_variant/ThreeD.h> 10545 #include <X11/$athena_variant/ThreeD.h>
10522 EOF 10546 EOF
10523 ac_try="$ac_cpp conftest.$ac_ext >/dev/null 2>conftest.out" 10547 ac_try="$ac_cpp conftest.$ac_ext >/dev/null 2>conftest.out"
10524 { (eval echo configure:10525: \"$ac_try\") 1>&5; (eval $ac_try) 2>&5; } 10548 { (eval echo configure:10549: \"$ac_try\") 1>&5; (eval $ac_try) 2>&5; }
10525 ac_err=`grep -v '^ *+' conftest.out | grep -v "^conftest.${ac_ext}\$"` 10549 ac_err=`grep -v '^ *+' conftest.out | grep -v "^conftest.${ac_ext}\$"`
10526 if test -z "$ac_err"; then 10550 if test -z "$ac_err"; then
10527 rm -rf conftest* 10551 rm -rf conftest*
10528 eval "ac_cv_header_$ac_safe=yes" 10552 eval "ac_cv_header_$ac_safe=yes"
10529 else 10553 else
10547 10571
10548 10572
10549 if test -z "$athena_h_path"; then 10573 if test -z "$athena_h_path"; then
10550 ac_safe=`echo "$athena_variant/XawInit.h" | sed 'y%./+-%__p_%'` 10574 ac_safe=`echo "$athena_variant/XawInit.h" | sed 'y%./+-%__p_%'`
10551 echo $ac_n "checking for $athena_variant/XawInit.h""... $ac_c" 1>&6 10575 echo $ac_n "checking for $athena_variant/XawInit.h""... $ac_c" 1>&6
10552 echo "configure:10553: checking for $athena_variant/XawInit.h" >&5 10576 echo "configure:10577: checking for $athena_variant/XawInit.h" >&5
10553 10577
10554 cat > conftest.$ac_ext <<EOF 10578 cat > conftest.$ac_ext <<EOF
10555 #line 10556 "configure" 10579 #line 10580 "configure"
10556 #include "confdefs.h" 10580 #include "confdefs.h"
10557 #include <$athena_variant/XawInit.h> 10581 #include <$athena_variant/XawInit.h>
10558 EOF 10582 EOF
10559 ac_try="$ac_cpp conftest.$ac_ext >/dev/null 2>conftest.out" 10583 ac_try="$ac_cpp conftest.$ac_ext >/dev/null 2>conftest.out"
10560 { (eval echo configure:10561: \"$ac_try\") 1>&5; (eval $ac_try) 2>&5; } 10584 { (eval echo configure:10585: \"$ac_try\") 1>&5; (eval $ac_try) 2>&5; }
10561 ac_err=`grep -v '^ *+' conftest.out | grep -v "^conftest.${ac_ext}\$"` 10585 ac_err=`grep -v '^ *+' conftest.out | grep -v "^conftest.${ac_ext}\$"`
10562 if test -z "$ac_err"; then 10586 if test -z "$ac_err"; then
10563 rm -rf conftest* 10587 rm -rf conftest*
10564 eval "ac_cv_header_$ac_safe=yes" 10588 eval "ac_cv_header_$ac_safe=yes"
10565 else 10589 else
10572 rm -f conftest* 10596 rm -f conftest*
10573 if eval "test \"`echo '$ac_cv_header_'$ac_safe`\" = yes"; then 10597 if eval "test \"`echo '$ac_cv_header_'$ac_safe`\" = yes"; then
10574 echo "$ac_t""yes" 1>&6 10598 echo "$ac_t""yes" 1>&6
10575 ac_safe=`echo "$athena_variant/ThreeD.h" | sed 'y%./+-%__p_%'` 10599 ac_safe=`echo "$athena_variant/ThreeD.h" | sed 'y%./+-%__p_%'`
10576 echo $ac_n "checking for $athena_variant/ThreeD.h""... $ac_c" 1>&6 10600 echo $ac_n "checking for $athena_variant/ThreeD.h""... $ac_c" 1>&6
10577 echo "configure:10578: checking for $athena_variant/ThreeD.h" >&5 10601 echo "configure:10602: checking for $athena_variant/ThreeD.h" >&5
10578 10602
10579 cat > conftest.$ac_ext <<EOF 10603 cat > conftest.$ac_ext <<EOF
10580 #line 10581 "configure" 10604 #line 10605 "configure"
10581 #include "confdefs.h" 10605 #include "confdefs.h"
10582 #include <$athena_variant/ThreeD.h> 10606 #include <$athena_variant/ThreeD.h>
10583 EOF 10607 EOF
10584 ac_try="$ac_cpp conftest.$ac_ext >/dev/null 2>conftest.out" 10608 ac_try="$ac_cpp conftest.$ac_ext >/dev/null 2>conftest.out"
10585 { (eval echo configure:10586: \"$ac_try\") 1>&5; (eval $ac_try) 2>&5; } 10609 { (eval echo configure:10610: \"$ac_try\") 1>&5; (eval $ac_try) 2>&5; }
10586 ac_err=`grep -v '^ *+' conftest.out | grep -v "^conftest.${ac_ext}\$"` 10610 ac_err=`grep -v '^ *+' conftest.out | grep -v "^conftest.${ac_ext}\$"`
10587 if test -z "$ac_err"; then 10611 if test -z "$ac_err"; then
10588 rm -rf conftest* 10612 rm -rf conftest*
10589 eval "ac_cv_header_$ac_safe=yes" 10613 eval "ac_cv_header_$ac_safe=yes"
10590 else 10614 else
10609 fi 10633 fi
10610 10634
10611 if test -z "$athena_h_path" -a "$athena_variant" != "Xaw3d"; then 10635 if test -z "$athena_h_path" -a "$athena_variant" != "Xaw3d"; then
10612 ac_safe=`echo "X11/Xaw3d/XawInit.h" | sed 'y%./+-%__p_%'` 10636 ac_safe=`echo "X11/Xaw3d/XawInit.h" | sed 'y%./+-%__p_%'`
10613 echo $ac_n "checking for X11/Xaw3d/XawInit.h""... $ac_c" 1>&6 10637 echo $ac_n "checking for X11/Xaw3d/XawInit.h""... $ac_c" 1>&6
10614 echo "configure:10615: checking for X11/Xaw3d/XawInit.h" >&5 10638 echo "configure:10639: checking for X11/Xaw3d/XawInit.h" >&5
10615 10639
10616 cat > conftest.$ac_ext <<EOF 10640 cat > conftest.$ac_ext <<EOF
10617 #line 10618 "configure" 10641 #line 10642 "configure"
10618 #include "confdefs.h" 10642 #include "confdefs.h"
10619 #include <X11/Xaw3d/XawInit.h> 10643 #include <X11/Xaw3d/XawInit.h>
10620 EOF 10644 EOF
10621 ac_try="$ac_cpp conftest.$ac_ext >/dev/null 2>conftest.out" 10645 ac_try="$ac_cpp conftest.$ac_ext >/dev/null 2>conftest.out"
10622 { (eval echo configure:10623: \"$ac_try\") 1>&5; (eval $ac_try) 2>&5; } 10646 { (eval echo configure:10647: \"$ac_try\") 1>&5; (eval $ac_try) 2>&5; }
10623 ac_err=`grep -v '^ *+' conftest.out | grep -v "^conftest.${ac_ext}\$"` 10647 ac_err=`grep -v '^ *+' conftest.out | grep -v "^conftest.${ac_ext}\$"`
10624 if test -z "$ac_err"; then 10648 if test -z "$ac_err"; then
10625 rm -rf conftest* 10649 rm -rf conftest*
10626 eval "ac_cv_header_$ac_safe=yes" 10650 eval "ac_cv_header_$ac_safe=yes"
10627 else 10651 else
10634 rm -f conftest* 10658 rm -f conftest*
10635 if eval "test \"`echo '$ac_cv_header_'$ac_safe`\" = yes"; then 10659 if eval "test \"`echo '$ac_cv_header_'$ac_safe`\" = yes"; then
10636 echo "$ac_t""yes" 1>&6 10660 echo "$ac_t""yes" 1>&6
10637 ac_safe=`echo "X11/Xaw3d/ThreeD.h" | sed 'y%./+-%__p_%'` 10661 ac_safe=`echo "X11/Xaw3d/ThreeD.h" | sed 'y%./+-%__p_%'`
10638 echo $ac_n "checking for X11/Xaw3d/ThreeD.h""... $ac_c" 1>&6 10662 echo $ac_n "checking for X11/Xaw3d/ThreeD.h""... $ac_c" 1>&6
10639 echo "configure:10640: checking for X11/Xaw3d/ThreeD.h" >&5 10663 echo "configure:10664: checking for X11/Xaw3d/ThreeD.h" >&5
10640 10664
10641 cat > conftest.$ac_ext <<EOF 10665 cat > conftest.$ac_ext <<EOF
10642 #line 10643 "configure" 10666 #line 10667 "configure"
10643 #include "confdefs.h" 10667 #include "confdefs.h"
10644 #include <X11/Xaw3d/ThreeD.h> 10668 #include <X11/Xaw3d/ThreeD.h>
10645 EOF 10669 EOF
10646 ac_try="$ac_cpp conftest.$ac_ext >/dev/null 2>conftest.out" 10670 ac_try="$ac_cpp conftest.$ac_ext >/dev/null 2>conftest.out"
10647 { (eval echo configure:10648: \"$ac_try\") 1>&5; (eval $ac_try) 2>&5; } 10671 { (eval echo configure:10672: \"$ac_try\") 1>&5; (eval $ac_try) 2>&5; }
10648 ac_err=`grep -v '^ *+' conftest.out | grep -v "^conftest.${ac_ext}\$"` 10672 ac_err=`grep -v '^ *+' conftest.out | grep -v "^conftest.${ac_ext}\$"`
10649 if test -z "$ac_err"; then 10673 if test -z "$ac_err"; then
10650 rm -rf conftest* 10674 rm -rf conftest*
10651 eval "ac_cv_header_$ac_safe=yes" 10675 eval "ac_cv_header_$ac_safe=yes"
10652 else 10676 else
10674 fi 10698 fi
10675 10699
10676 if test -z "$athena_h_path" -a "$athena_variant" != "Xaw3d"; then 10700 if test -z "$athena_h_path" -a "$athena_variant" != "Xaw3d"; then
10677 ac_safe=`echo "Xaw3d/XawInit.h" | sed 'y%./+-%__p_%'` 10701 ac_safe=`echo "Xaw3d/XawInit.h" | sed 'y%./+-%__p_%'`
10678 echo $ac_n "checking for Xaw3d/XawInit.h""... $ac_c" 1>&6 10702 echo $ac_n "checking for Xaw3d/XawInit.h""... $ac_c" 1>&6
10679 echo "configure:10680: checking for Xaw3d/XawInit.h" >&5 10703 echo "configure:10704: checking for Xaw3d/XawInit.h" >&5
10680 10704
10681 cat > conftest.$ac_ext <<EOF 10705 cat > conftest.$ac_ext <<EOF
10682 #line 10683 "configure" 10706 #line 10707 "configure"
10683 #include "confdefs.h" 10707 #include "confdefs.h"
10684 #include <Xaw3d/XawInit.h> 10708 #include <Xaw3d/XawInit.h>
10685 EOF 10709 EOF
10686 ac_try="$ac_cpp conftest.$ac_ext >/dev/null 2>conftest.out" 10710 ac_try="$ac_cpp conftest.$ac_ext >/dev/null 2>conftest.out"
10687 { (eval echo configure:10688: \"$ac_try\") 1>&5; (eval $ac_try) 2>&5; } 10711 { (eval echo configure:10712: \"$ac_try\") 1>&5; (eval $ac_try) 2>&5; }
10688 ac_err=`grep -v '^ *+' conftest.out | grep -v "^conftest.${ac_ext}\$"` 10712 ac_err=`grep -v '^ *+' conftest.out | grep -v "^conftest.${ac_ext}\$"`
10689 if test -z "$ac_err"; then 10713 if test -z "$ac_err"; then
10690 rm -rf conftest* 10714 rm -rf conftest*
10691 eval "ac_cv_header_$ac_safe=yes" 10715 eval "ac_cv_header_$ac_safe=yes"
10692 else 10716 else
10699 rm -f conftest* 10723 rm -f conftest*
10700 if eval "test \"`echo '$ac_cv_header_'$ac_safe`\" = yes"; then 10724 if eval "test \"`echo '$ac_cv_header_'$ac_safe`\" = yes"; then
10701 echo "$ac_t""yes" 1>&6 10725 echo "$ac_t""yes" 1>&6
10702 ac_safe=`echo "Xaw3d/ThreeD.h" | sed 'y%./+-%__p_%'` 10726 ac_safe=`echo "Xaw3d/ThreeD.h" | sed 'y%./+-%__p_%'`
10703 echo $ac_n "checking for Xaw3d/ThreeD.h""... $ac_c" 1>&6 10727 echo $ac_n "checking for Xaw3d/ThreeD.h""... $ac_c" 1>&6
10704 echo "configure:10705: checking for Xaw3d/ThreeD.h" >&5 10728 echo "configure:10729: checking for Xaw3d/ThreeD.h" >&5
10705 10729
10706 cat > conftest.$ac_ext <<EOF 10730 cat > conftest.$ac_ext <<EOF
10707 #line 10708 "configure" 10731 #line 10732 "configure"
10708 #include "confdefs.h" 10732 #include "confdefs.h"
10709 #include <Xaw3d/ThreeD.h> 10733 #include <Xaw3d/ThreeD.h>
10710 EOF 10734 EOF
10711 ac_try="$ac_cpp conftest.$ac_ext >/dev/null 2>conftest.out" 10735 ac_try="$ac_cpp conftest.$ac_ext >/dev/null 2>conftest.out"
10712 { (eval echo configure:10713: \"$ac_try\") 1>&5; (eval $ac_try) 2>&5; } 10736 { (eval echo configure:10737: \"$ac_try\") 1>&5; (eval $ac_try) 2>&5; }
10713 ac_err=`grep -v '^ *+' conftest.out | grep -v "^conftest.${ac_ext}\$"` 10737 ac_err=`grep -v '^ *+' conftest.out | grep -v "^conftest.${ac_ext}\$"`
10714 if test -z "$ac_err"; then 10738 if test -z "$ac_err"; then
10715 rm -rf conftest* 10739 rm -rf conftest*
10716 eval "ac_cv_header_$ac_safe=yes" 10740 eval "ac_cv_header_$ac_safe=yes"
10717 else 10741 else
10739 fi 10763 fi
10740 10764
10741 if test -z "$athena_h_path"; then 10765 if test -z "$athena_h_path"; then
10742 ac_safe=`echo "X11/Xaw/ThreeD.h" | sed 'y%./+-%__p_%'` 10766 ac_safe=`echo "X11/Xaw/ThreeD.h" | sed 'y%./+-%__p_%'`
10743 echo $ac_n "checking for X11/Xaw/ThreeD.h""... $ac_c" 1>&6 10767 echo $ac_n "checking for X11/Xaw/ThreeD.h""... $ac_c" 1>&6
10744 echo "configure:10745: checking for X11/Xaw/ThreeD.h" >&5 10768 echo "configure:10769: checking for X11/Xaw/ThreeD.h" >&5
10745 10769
10746 cat > conftest.$ac_ext <<EOF 10770 cat > conftest.$ac_ext <<EOF
10747 #line 10748 "configure" 10771 #line 10772 "configure"
10748 #include "confdefs.h" 10772 #include "confdefs.h"
10749 #include <X11/Xaw/ThreeD.h> 10773 #include <X11/Xaw/ThreeD.h>
10750 EOF 10774 EOF
10751 ac_try="$ac_cpp conftest.$ac_ext >/dev/null 2>conftest.out" 10775 ac_try="$ac_cpp conftest.$ac_ext >/dev/null 2>conftest.out"
10752 { (eval echo configure:10753: \"$ac_try\") 1>&5; (eval $ac_try) 2>&5; } 10776 { (eval echo configure:10777: \"$ac_try\") 1>&5; (eval $ac_try) 2>&5; }
10753 ac_err=`grep -v '^ *+' conftest.out | grep -v "^conftest.${ac_ext}\$"` 10777 ac_err=`grep -v '^ *+' conftest.out | grep -v "^conftest.${ac_ext}\$"`
10754 if test -z "$ac_err"; then 10778 if test -z "$ac_err"; then
10755 rm -rf conftest* 10779 rm -rf conftest*
10756 eval "ac_cv_header_$ac_safe=yes" 10780 eval "ac_cv_header_$ac_safe=yes"
10757 else 10781 else
10786 have_xaw=no 10810 have_xaw=no
10787 fi 10811 fi
10788 if test "$with_x11" = "yes"; then 10812 if test "$with_x11" = "yes"; then
10789 ac_safe=`echo "Xm/Xm.h" | sed 'y%./+-%__p_%'` 10813 ac_safe=`echo "Xm/Xm.h" | sed 'y%./+-%__p_%'`
10790 echo $ac_n "checking for Xm/Xm.h""... $ac_c" 1>&6 10814 echo $ac_n "checking for Xm/Xm.h""... $ac_c" 1>&6
10791 echo "configure:10792: checking for Xm/Xm.h" >&5 10815 echo "configure:10816: checking for Xm/Xm.h" >&5
10792 10816
10793 cat > conftest.$ac_ext <<EOF 10817 cat > conftest.$ac_ext <<EOF
10794 #line 10795 "configure" 10818 #line 10819 "configure"
10795 #include "confdefs.h" 10819 #include "confdefs.h"
10796 #include <Xm/Xm.h> 10820 #include <Xm/Xm.h>
10797 EOF 10821 EOF
10798 ac_try="$ac_cpp conftest.$ac_ext >/dev/null 2>conftest.out" 10822 ac_try="$ac_cpp conftest.$ac_ext >/dev/null 2>conftest.out"
10799 { (eval echo configure:10800: \"$ac_try\") 1>&5; (eval $ac_try) 2>&5; } 10823 { (eval echo configure:10824: \"$ac_try\") 1>&5; (eval $ac_try) 2>&5; }
10800 ac_err=`grep -v '^ *+' conftest.out | grep -v "^conftest.${ac_ext}\$"` 10824 ac_err=`grep -v '^ *+' conftest.out | grep -v "^conftest.${ac_ext}\$"`
10801 if test -z "$ac_err"; then 10825 if test -z "$ac_err"; then
10802 rm -rf conftest* 10826 rm -rf conftest*
10803 eval "ac_cv_header_$ac_safe=yes" 10827 eval "ac_cv_header_$ac_safe=yes"
10804 else 10828 else
10811 rm -f conftest* 10835 rm -f conftest*
10812 if eval "test \"`echo '$ac_cv_header_'$ac_safe`\" = yes"; then 10836 if eval "test \"`echo '$ac_cv_header_'$ac_safe`\" = yes"; then
10813 echo "$ac_t""yes" 1>&6 10837 echo "$ac_t""yes" 1>&6
10814 10838
10815 echo $ac_n "checking for XmStringFree in -lXm""... $ac_c" 1>&6 10839 echo $ac_n "checking for XmStringFree in -lXm""... $ac_c" 1>&6
10816 echo "configure:10817: checking for XmStringFree in -lXm" >&5 10840 echo "configure:10841: checking for XmStringFree in -lXm" >&5
10817 ac_lib_var=`echo Xm'_'XmStringFree | sed 'y%./+-%__p_%'` 10841 ac_lib_var=`echo Xm'_'XmStringFree | sed 'y%./+-%__p_%'`
10818 10842
10819 xe_check_libs=" -lXm " 10843 xe_check_libs=" -lXm "
10820 cat > conftest.$ac_ext <<EOF 10844 cat > conftest.$ac_ext <<EOF
10821 #line 10822 "configure" 10845 #line 10846 "configure"
10822 #include "confdefs.h" 10846 #include "confdefs.h"
10823 /* Override any gcc2 internal prototype to avoid an error. */ 10847 /* Override any gcc2 internal prototype to avoid an error. */
10824 /* We use char because int might match the return type of a gcc2 10848 /* We use char because int might match the return type of a gcc2
10825 builtin and then its argument prototype would still apply. */ 10849 builtin and then its argument prototype would still apply. */
10826 char XmStringFree(); 10850 char XmStringFree();
10827 10851
10828 int main() { 10852 int main() {
10829 XmStringFree() 10853 XmStringFree()
10830 ; return 0; } 10854 ; return 0; }
10831 EOF 10855 EOF
10832 if { (eval echo configure:10833: \"$ac_link\") 1>&5; (eval $ac_link) 2>&5; } && test -s conftest${ac_exeext}; then 10856 if { (eval echo configure:10857: \"$ac_link\") 1>&5; (eval $ac_link) 2>&5; } && test -s conftest${ac_exeext}; then
10833 rm -rf conftest* 10857 rm -rf conftest*
10834 eval "ac_cv_lib_$ac_lib_var=yes" 10858 eval "ac_cv_lib_$ac_lib_var=yes"
10835 else 10859 else
10836 echo "configure: failed program was:" >&5 10860 echo "configure: failed program was:" >&5
10837 cat conftest.$ac_ext >&5 10861 cat conftest.$ac_ext >&5
10856 fi 10880 fi
10857 10881
10858 10882
10859 if test "$have_motif" = "yes"; then 10883 if test "$have_motif" = "yes"; then
10860 echo $ac_n "checking for Lesstif""... $ac_c" 1>&6 10884 echo $ac_n "checking for Lesstif""... $ac_c" 1>&6
10861 echo "configure:10862: checking for Lesstif" >&5 10885 echo "configure:10886: checking for Lesstif" >&5
10862 cat > conftest.$ac_ext <<EOF 10886 cat > conftest.$ac_ext <<EOF
10863 #line 10864 "configure" 10887 #line 10888 "configure"
10864 #include "confdefs.h" 10888 #include "confdefs.h"
10865 #include <Xm/Xm.h> 10889 #include <Xm/Xm.h>
10866 #ifdef LESSTIF_VERSION 10890 #ifdef LESSTIF_VERSION
10867 yes 10891 yes
10868 #endif 10892 #endif
11231 11255
11232 fi 11256 fi
11233 11257
11234 if test "$with_mule" = "yes" ; then 11258 if test "$with_mule" = "yes" ; then
11235 echo "checking for Mule-related features" 1>&6 11259 echo "checking for Mule-related features" 1>&6
11236 echo "configure:11237: checking for Mule-related features" >&5 11260 echo "configure:11261: checking for Mule-related features" >&5
11237 { test "$extra_verbose" = "yes" && cat << \EOF 11261 { test "$extra_verbose" = "yes" && cat << \EOF
11238 Defining MULE 11262 Defining MULE
11239 EOF 11263 EOF
11240 cat >> confdefs.h <<\EOF 11264 cat >> confdefs.h <<\EOF
11241 #define MULE 1 11265 #define MULE 1
11245 11269
11246 for ac_hdr in libintl.h 11270 for ac_hdr in libintl.h
11247 do 11271 do
11248 ac_safe=`echo "$ac_hdr" | sed 'y%./+-%__p_%'` 11272 ac_safe=`echo "$ac_hdr" | sed 'y%./+-%__p_%'`
11249 echo $ac_n "checking for $ac_hdr""... $ac_c" 1>&6 11273 echo $ac_n "checking for $ac_hdr""... $ac_c" 1>&6
11250 echo "configure:11251: checking for $ac_hdr" >&5 11274 echo "configure:11275: checking for $ac_hdr" >&5
11251 11275
11252 cat > conftest.$ac_ext <<EOF 11276 cat > conftest.$ac_ext <<EOF
11253 #line 11254 "configure" 11277 #line 11278 "configure"
11254 #include "confdefs.h" 11278 #include "confdefs.h"
11255 #include <$ac_hdr> 11279 #include <$ac_hdr>
11256 EOF 11280 EOF
11257 ac_try="$ac_cpp conftest.$ac_ext >/dev/null 2>conftest.out" 11281 ac_try="$ac_cpp conftest.$ac_ext >/dev/null 2>conftest.out"
11258 { (eval echo configure:11259: \"$ac_try\") 1>&5; (eval $ac_try) 2>&5; } 11282 { (eval echo configure:11283: \"$ac_try\") 1>&5; (eval $ac_try) 2>&5; }
11259 ac_err=`grep -v '^ *+' conftest.out | grep -v "^conftest.${ac_ext}\$"` 11283 ac_err=`grep -v '^ *+' conftest.out | grep -v "^conftest.${ac_ext}\$"`
11260 if test -z "$ac_err"; then 11284 if test -z "$ac_err"; then
11261 rm -rf conftest* 11285 rm -rf conftest*
11262 eval "ac_cv_header_$ac_safe=yes" 11286 eval "ac_cv_header_$ac_safe=yes"
11263 else 11287 else
11284 fi 11308 fi
11285 done 11309 done
11286 11310
11287 11311
11288 echo $ac_n "checking for strerror in -lintl""... $ac_c" 1>&6 11312 echo $ac_n "checking for strerror in -lintl""... $ac_c" 1>&6
11289 echo "configure:11290: checking for strerror in -lintl" >&5 11313 echo "configure:11314: checking for strerror in -lintl" >&5
11290 ac_lib_var=`echo intl'_'strerror | sed 'y%./+-%__p_%'` 11314 ac_lib_var=`echo intl'_'strerror | sed 'y%./+-%__p_%'`
11291 11315
11292 xe_check_libs=" -lintl " 11316 xe_check_libs=" -lintl "
11293 cat > conftest.$ac_ext <<EOF 11317 cat > conftest.$ac_ext <<EOF
11294 #line 11295 "configure" 11318 #line 11319 "configure"
11295 #include "confdefs.h" 11319 #include "confdefs.h"
11296 /* Override any gcc2 internal prototype to avoid an error. */ 11320 /* Override any gcc2 internal prototype to avoid an error. */
11297 /* We use char because int might match the return type of a gcc2 11321 /* We use char because int might match the return type of a gcc2
11298 builtin and then its argument prototype would still apply. */ 11322 builtin and then its argument prototype would still apply. */
11299 char strerror(); 11323 char strerror();
11300 11324
11301 int main() { 11325 int main() {
11302 strerror() 11326 strerror()
11303 ; return 0; } 11327 ; return 0; }
11304 EOF 11328 EOF
11305 if { (eval echo configure:11306: \"$ac_link\") 1>&5; (eval $ac_link) 2>&5; } && test -s conftest${ac_exeext}; then 11329 if { (eval echo configure:11330: \"$ac_link\") 1>&5; (eval $ac_link) 2>&5; } && test -s conftest${ac_exeext}; then
11306 rm -rf conftest* 11330 rm -rf conftest*
11307 eval "ac_cv_lib_$ac_lib_var=yes" 11331 eval "ac_cv_lib_$ac_lib_var=yes"
11308 else 11332 else
11309 echo "configure: failed program was:" >&5 11333 echo "configure: failed program was:" >&5
11310 cat conftest.$ac_ext >&5 11334 cat conftest.$ac_ext >&5
11333 fi 11357 fi
11334 11358
11335 11359
11336 11360
11337 echo "checking for Mule input methods" 1>&6 11361 echo "checking for Mule input methods" 1>&6
11338 echo "configure:11339: checking for Mule input methods" >&5 11362 echo "configure:11363: checking for Mule input methods" >&5
11339 case "$with_xim" in "" | "yes" ) 11363 case "$with_xim" in "" | "yes" )
11340 echo "checking for XIM" 1>&6 11364 echo "checking for XIM" 1>&6
11341 echo "configure:11342: checking for XIM" >&5 11365 echo "configure:11366: checking for XIM" >&5
11342 11366
11343 echo $ac_n "checking for XOpenIM in -lX11""... $ac_c" 1>&6 11367 echo $ac_n "checking for XOpenIM in -lX11""... $ac_c" 1>&6
11344 echo "configure:11345: checking for XOpenIM in -lX11" >&5 11368 echo "configure:11369: checking for XOpenIM in -lX11" >&5
11345 ac_lib_var=`echo X11'_'XOpenIM | sed 'y%./+-%__p_%'` 11369 ac_lib_var=`echo X11'_'XOpenIM | sed 'y%./+-%__p_%'`
11346 11370
11347 xe_check_libs=" -lX11 " 11371 xe_check_libs=" -lX11 "
11348 cat > conftest.$ac_ext <<EOF 11372 cat > conftest.$ac_ext <<EOF
11349 #line 11350 "configure" 11373 #line 11374 "configure"
11350 #include "confdefs.h" 11374 #include "confdefs.h"
11351 /* Override any gcc2 internal prototype to avoid an error. */ 11375 /* Override any gcc2 internal prototype to avoid an error. */
11352 /* We use char because int might match the return type of a gcc2 11376 /* We use char because int might match the return type of a gcc2
11353 builtin and then its argument prototype would still apply. */ 11377 builtin and then its argument prototype would still apply. */
11354 char XOpenIM(); 11378 char XOpenIM();
11355 11379
11356 int main() { 11380 int main() {
11357 XOpenIM() 11381 XOpenIM()
11358 ; return 0; } 11382 ; return 0; }
11359 EOF 11383 EOF
11360 if { (eval echo configure:11361: \"$ac_link\") 1>&5; (eval $ac_link) 2>&5; } && test -s conftest${ac_exeext}; then 11384 if { (eval echo configure:11385: \"$ac_link\") 1>&5; (eval $ac_link) 2>&5; } && test -s conftest${ac_exeext}; then
11361 rm -rf conftest* 11385 rm -rf conftest*
11362 eval "ac_cv_lib_$ac_lib_var=yes" 11386 eval "ac_cv_lib_$ac_lib_var=yes"
11363 else 11387 else
11364 echo "configure: failed program was:" >&5 11388 echo "configure: failed program was:" >&5
11365 cat conftest.$ac_ext >&5 11389 cat conftest.$ac_ext >&5
11379 11403
11380 11404
11381 if test "$have_motif $have_lesstif" = "yes no"; then 11405 if test "$have_motif $have_lesstif" = "yes no"; then
11382 11406
11383 echo $ac_n "checking for XmImMbLookupString in -lXm""... $ac_c" 1>&6 11407 echo $ac_n "checking for XmImMbLookupString in -lXm""... $ac_c" 1>&6
11384 echo "configure:11385: checking for XmImMbLookupString in -lXm" >&5 11408 echo "configure:11409: checking for XmImMbLookupString in -lXm" >&5
11385 ac_lib_var=`echo Xm'_'XmImMbLookupString | sed 'y%./+-%__p_%'` 11409 ac_lib_var=`echo Xm'_'XmImMbLookupString | sed 'y%./+-%__p_%'`
11386 11410
11387 xe_check_libs=" -lXm " 11411 xe_check_libs=" -lXm "
11388 cat > conftest.$ac_ext <<EOF 11412 cat > conftest.$ac_ext <<EOF
11389 #line 11390 "configure" 11413 #line 11414 "configure"
11390 #include "confdefs.h" 11414 #include "confdefs.h"
11391 /* Override any gcc2 internal prototype to avoid an error. */ 11415 /* Override any gcc2 internal prototype to avoid an error. */
11392 /* We use char because int might match the return type of a gcc2 11416 /* We use char because int might match the return type of a gcc2
11393 builtin and then its argument prototype would still apply. */ 11417 builtin and then its argument prototype would still apply. */
11394 char XmImMbLookupString(); 11418 char XmImMbLookupString();
11395 11419
11396 int main() { 11420 int main() {
11397 XmImMbLookupString() 11421 XmImMbLookupString()
11398 ; return 0; } 11422 ; return 0; }
11399 EOF 11423 EOF
11400 if { (eval echo configure:11401: \"$ac_link\") 1>&5; (eval $ac_link) 2>&5; } && test -s conftest${ac_exeext}; then 11424 if { (eval echo configure:11425: \"$ac_link\") 1>&5; (eval $ac_link) 2>&5; } && test -s conftest${ac_exeext}; then
11401 rm -rf conftest* 11425 rm -rf conftest*
11402 eval "ac_cv_lib_$ac_lib_var=yes" 11426 eval "ac_cv_lib_$ac_lib_var=yes"
11403 else 11427 else
11404 echo "configure: failed program was:" >&5 11428 echo "configure: failed program was:" >&5
11405 cat conftest.$ac_ext >&5 11429 cat conftest.$ac_ext >&5
11460 fi 11484 fi
11461 fi 11485 fi
11462 11486
11463 if test "$with_xfs" = "yes" ; then 11487 if test "$with_xfs" = "yes" ; then
11464 echo "checking for XFontSet" 1>&6 11488 echo "checking for XFontSet" 1>&6
11465 echo "configure:11466: checking for XFontSet" >&5 11489 echo "configure:11490: checking for XFontSet" >&5
11466 11490
11467 echo $ac_n "checking for XmbDrawString in -lX11""... $ac_c" 1>&6 11491 echo $ac_n "checking for XmbDrawString in -lX11""... $ac_c" 1>&6
11468 echo "configure:11469: checking for XmbDrawString in -lX11" >&5 11492 echo "configure:11493: checking for XmbDrawString in -lX11" >&5
11469 ac_lib_var=`echo X11'_'XmbDrawString | sed 'y%./+-%__p_%'` 11493 ac_lib_var=`echo X11'_'XmbDrawString | sed 'y%./+-%__p_%'`
11470 11494
11471 xe_check_libs=" -lX11 " 11495 xe_check_libs=" -lX11 "
11472 cat > conftest.$ac_ext <<EOF 11496 cat > conftest.$ac_ext <<EOF
11473 #line 11474 "configure" 11497 #line 11498 "configure"
11474 #include "confdefs.h" 11498 #include "confdefs.h"
11475 /* Override any gcc2 internal prototype to avoid an error. */ 11499 /* Override any gcc2 internal prototype to avoid an error. */
11476 /* We use char because int might match the return type of a gcc2 11500 /* We use char because int might match the return type of a gcc2
11477 builtin and then its argument prototype would still apply. */ 11501 builtin and then its argument prototype would still apply. */
11478 char XmbDrawString(); 11502 char XmbDrawString();
11479 11503
11480 int main() { 11504 int main() {
11481 XmbDrawString() 11505 XmbDrawString()
11482 ; return 0; } 11506 ; return 0; }
11483 EOF 11507 EOF
11484 if { (eval echo configure:11485: \"$ac_link\") 1>&5; (eval $ac_link) 2>&5; } && test -s conftest${ac_exeext}; then 11508 if { (eval echo configure:11509: \"$ac_link\") 1>&5; (eval $ac_link) 2>&5; } && test -s conftest${ac_exeext}; then
11485 rm -rf conftest* 11509 rm -rf conftest*
11486 eval "ac_cv_lib_$ac_lib_var=yes" 11510 eval "ac_cv_lib_$ac_lib_var=yes"
11487 else 11511 else
11488 echo "configure: failed program was:" >&5 11512 echo "configure: failed program was:" >&5
11489 cat conftest.$ac_ext >&5 11513 cat conftest.$ac_ext >&5
11519 fi 11543 fi
11520 fi 11544 fi
11521 test "$with_wnn6" = "yes" && with_wnn=yes # wnn6 implies wnn support 11545 test "$with_wnn6" = "yes" && with_wnn=yes # wnn6 implies wnn support
11522 test -z "$with_wnn" && { ac_safe=`echo "wnn/jllib.h" | sed 'y%./+-%__p_%'` 11546 test -z "$with_wnn" && { ac_safe=`echo "wnn/jllib.h" | sed 'y%./+-%__p_%'`
11523 echo $ac_n "checking for wnn/jllib.h""... $ac_c" 1>&6 11547 echo $ac_n "checking for wnn/jllib.h""... $ac_c" 1>&6
11524 echo "configure:11525: checking for wnn/jllib.h" >&5 11548 echo "configure:11549: checking for wnn/jllib.h" >&5
11525 11549
11526 cat > conftest.$ac_ext <<EOF 11550 cat > conftest.$ac_ext <<EOF
11527 #line 11528 "configure" 11551 #line 11552 "configure"
11528 #include "confdefs.h" 11552 #include "confdefs.h"
11529 #include <wnn/jllib.h> 11553 #include <wnn/jllib.h>
11530 EOF 11554 EOF
11531 ac_try="$ac_cpp conftest.$ac_ext >/dev/null 2>conftest.out" 11555 ac_try="$ac_cpp conftest.$ac_ext >/dev/null 2>conftest.out"
11532 { (eval echo configure:11533: \"$ac_try\") 1>&5; (eval $ac_try) 2>&5; } 11556 { (eval echo configure:11557: \"$ac_try\") 1>&5; (eval $ac_try) 2>&5; }
11533 ac_err=`grep -v '^ *+' conftest.out | grep -v "^conftest.${ac_ext}\$"` 11557 ac_err=`grep -v '^ *+' conftest.out | grep -v "^conftest.${ac_ext}\$"`
11534 if test -z "$ac_err"; then 11558 if test -z "$ac_err"; then
11535 rm -rf conftest* 11559 rm -rf conftest*
11536 eval "ac_cv_header_$ac_safe=yes" 11560 eval "ac_cv_header_$ac_safe=yes"
11537 else 11561 else
11550 with_wnn=no 11574 with_wnn=no
11551 fi 11575 fi
11552 } 11576 }
11553 test -z "$with_wnn" && { ac_safe=`echo "wnn/commonhd.h" | sed 'y%./+-%__p_%'` 11577 test -z "$with_wnn" && { ac_safe=`echo "wnn/commonhd.h" | sed 'y%./+-%__p_%'`
11554 echo $ac_n "checking for wnn/commonhd.h""... $ac_c" 1>&6 11578 echo $ac_n "checking for wnn/commonhd.h""... $ac_c" 1>&6
11555 echo "configure:11556: checking for wnn/commonhd.h" >&5 11579 echo "configure:11580: checking for wnn/commonhd.h" >&5
11556 11580
11557 cat > conftest.$ac_ext <<EOF 11581 cat > conftest.$ac_ext <<EOF
11558 #line 11559 "configure" 11582 #line 11583 "configure"
11559 #include "confdefs.h" 11583 #include "confdefs.h"
11560 #include <wnn/commonhd.h> 11584 #include <wnn/commonhd.h>
11561 EOF 11585 EOF
11562 ac_try="$ac_cpp conftest.$ac_ext >/dev/null 2>conftest.out" 11586 ac_try="$ac_cpp conftest.$ac_ext >/dev/null 2>conftest.out"
11563 { (eval echo configure:11564: \"$ac_try\") 1>&5; (eval $ac_try) 2>&5; } 11587 { (eval echo configure:11588: \"$ac_try\") 1>&5; (eval $ac_try) 2>&5; }
11564 ac_err=`grep -v '^ *+' conftest.out | grep -v "^conftest.${ac_ext}\$"` 11588 ac_err=`grep -v '^ *+' conftest.out | grep -v "^conftest.${ac_ext}\$"`
11565 if test -z "$ac_err"; then 11589 if test -z "$ac_err"; then
11566 rm -rf conftest* 11590 rm -rf conftest*
11567 eval "ac_cv_header_$ac_safe=yes" 11591 eval "ac_cv_header_$ac_safe=yes"
11568 else 11592 else
11583 } 11607 }
11584 if test "$with_wnn" != "no"; then 11608 if test "$with_wnn" != "no"; then
11585 for ac_func in crypt 11609 for ac_func in crypt
11586 do 11610 do
11587 echo $ac_n "checking for $ac_func""... $ac_c" 1>&6 11611 echo $ac_n "checking for $ac_func""... $ac_c" 1>&6
11588 echo "configure:11589: checking for $ac_func" >&5 11612 echo "configure:11613: checking for $ac_func" >&5
11589 11613
11590 cat > conftest.$ac_ext <<EOF 11614 cat > conftest.$ac_ext <<EOF
11591 #line 11592 "configure" 11615 #line 11616 "configure"
11592 #include "confdefs.h" 11616 #include "confdefs.h"
11593 /* System header to define __stub macros and hopefully few prototypes, 11617 /* System header to define __stub macros and hopefully few prototypes,
11594 which can conflict with char $ac_func(); below. */ 11618 which can conflict with char $ac_func(); below. */
11595 #include <assert.h> 11619 #include <assert.h>
11596 /* Override any gcc2 internal prototype to avoid an error. */ 11620 /* Override any gcc2 internal prototype to avoid an error. */
11609 $ac_func(); 11633 $ac_func();
11610 #endif 11634 #endif
11611 11635
11612 ; return 0; } 11636 ; return 0; }
11613 EOF 11637 EOF
11614 if { (eval echo configure:11615: \"$ac_link\") 1>&5; (eval $ac_link) 2>&5; } && test -s conftest${ac_exeext}; then 11638 if { (eval echo configure:11639: \"$ac_link\") 1>&5; (eval $ac_link) 2>&5; } && test -s conftest${ac_exeext}; then
11615 rm -rf conftest* 11639 rm -rf conftest*
11616 eval "ac_cv_func_$ac_func=yes" 11640 eval "ac_cv_func_$ac_func=yes"
11617 else 11641 else
11618 echo "configure: failed program was:" >&5 11642 echo "configure: failed program was:" >&5
11619 cat conftest.$ac_ext >&5 11643 cat conftest.$ac_ext >&5
11638 fi 11662 fi
11639 done 11663 done
11640 11664
11641 test "$ac_cv_func_crypt" != "yes" && { 11665 test "$ac_cv_func_crypt" != "yes" && {
11642 echo $ac_n "checking for crypt in -lcrypt""... $ac_c" 1>&6 11666 echo $ac_n "checking for crypt in -lcrypt""... $ac_c" 1>&6
11643 echo "configure:11644: checking for crypt in -lcrypt" >&5 11667 echo "configure:11668: checking for crypt in -lcrypt" >&5
11644 ac_lib_var=`echo crypt'_'crypt | sed 'y%./+-%__p_%'` 11668 ac_lib_var=`echo crypt'_'crypt | sed 'y%./+-%__p_%'`
11645 11669
11646 xe_check_libs=" -lcrypt " 11670 xe_check_libs=" -lcrypt "
11647 cat > conftest.$ac_ext <<EOF 11671 cat > conftest.$ac_ext <<EOF
11648 #line 11649 "configure" 11672 #line 11673 "configure"
11649 #include "confdefs.h" 11673 #include "confdefs.h"
11650 /* Override any gcc2 internal prototype to avoid an error. */ 11674 /* Override any gcc2 internal prototype to avoid an error. */
11651 /* We use char because int might match the return type of a gcc2 11675 /* We use char because int might match the return type of a gcc2
11652 builtin and then its argument prototype would still apply. */ 11676 builtin and then its argument prototype would still apply. */
11653 char crypt(); 11677 char crypt();
11654 11678
11655 int main() { 11679 int main() {
11656 crypt() 11680 crypt()
11657 ; return 0; } 11681 ; return 0; }
11658 EOF 11682 EOF
11659 if { (eval echo configure:11660: \"$ac_link\") 1>&5; (eval $ac_link) 2>&5; } && test -s conftest${ac_exeext}; then 11683 if { (eval echo configure:11684: \"$ac_link\") 1>&5; (eval $ac_link) 2>&5; } && test -s conftest${ac_exeext}; then
11660 rm -rf conftest* 11684 rm -rf conftest*
11661 eval "ac_cv_lib_$ac_lib_var=yes" 11685 eval "ac_cv_lib_$ac_lib_var=yes"
11662 else 11686 else
11663 echo "configure: failed program was:" >&5 11687 echo "configure: failed program was:" >&5
11664 cat conftest.$ac_ext >&5 11688 cat conftest.$ac_ext >&5
11689 } 11713 }
11690 fi 11714 fi
11691 if test -z "$with_wnn" -o "$with_wnn" = "yes"; then 11715 if test -z "$with_wnn" -o "$with_wnn" = "yes"; then
11692 11716
11693 echo $ac_n "checking for jl_dic_list_e in -lwnn""... $ac_c" 1>&6 11717 echo $ac_n "checking for jl_dic_list_e in -lwnn""... $ac_c" 1>&6
11694 echo "configure:11695: checking for jl_dic_list_e in -lwnn" >&5 11718 echo "configure:11719: checking for jl_dic_list_e in -lwnn" >&5
11695 ac_lib_var=`echo wnn'_'jl_dic_list_e | sed 'y%./+-%__p_%'` 11719 ac_lib_var=`echo wnn'_'jl_dic_list_e | sed 'y%./+-%__p_%'`
11696 11720
11697 xe_check_libs=" -lwnn " 11721 xe_check_libs=" -lwnn "
11698 cat > conftest.$ac_ext <<EOF 11722 cat > conftest.$ac_ext <<EOF
11699 #line 11700 "configure" 11723 #line 11724 "configure"
11700 #include "confdefs.h" 11724 #include "confdefs.h"
11701 /* Override any gcc2 internal prototype to avoid an error. */ 11725 /* Override any gcc2 internal prototype to avoid an error. */
11702 /* We use char because int might match the return type of a gcc2 11726 /* We use char because int might match the return type of a gcc2
11703 builtin and then its argument prototype would still apply. */ 11727 builtin and then its argument prototype would still apply. */
11704 char jl_dic_list_e(); 11728 char jl_dic_list_e();
11705 11729
11706 int main() { 11730 int main() {
11707 jl_dic_list_e() 11731 jl_dic_list_e()
11708 ; return 0; } 11732 ; return 0; }
11709 EOF 11733 EOF
11710 if { (eval echo configure:11711: \"$ac_link\") 1>&5; (eval $ac_link) 2>&5; } && test -s conftest${ac_exeext}; then 11734 if { (eval echo configure:11735: \"$ac_link\") 1>&5; (eval $ac_link) 2>&5; } && test -s conftest${ac_exeext}; then
11711 rm -rf conftest* 11735 rm -rf conftest*
11712 eval "ac_cv_lib_$ac_lib_var=yes" 11736 eval "ac_cv_lib_$ac_lib_var=yes"
11713 else 11737 else
11714 echo "configure: failed program was:" >&5 11738 echo "configure: failed program was:" >&5
11715 cat conftest.$ac_ext >&5 11739 cat conftest.$ac_ext >&5
11723 echo "$ac_t""yes" 1>&6 11747 echo "$ac_t""yes" 1>&6
11724 libwnn=wnn 11748 libwnn=wnn
11725 else 11749 else
11726 echo "$ac_t""no" 1>&6 11750 echo "$ac_t""no" 1>&6
11727 echo $ac_n "checking for jl_dic_list_e in -lwnn4""... $ac_c" 1>&6 11751 echo $ac_n "checking for jl_dic_list_e in -lwnn4""... $ac_c" 1>&6
11728 echo "configure:11729: checking for jl_dic_list_e in -lwnn4" >&5 11752 echo "configure:11753: checking for jl_dic_list_e in -lwnn4" >&5
11729 ac_lib_var=`echo wnn4'_'jl_dic_list_e | sed 'y%./+-%__p_%'` 11753 ac_lib_var=`echo wnn4'_'jl_dic_list_e | sed 'y%./+-%__p_%'`
11730 11754
11731 xe_check_libs=" -lwnn4 " 11755 xe_check_libs=" -lwnn4 "
11732 cat > conftest.$ac_ext <<EOF 11756 cat > conftest.$ac_ext <<EOF
11733 #line 11734 "configure" 11757 #line 11758 "configure"
11734 #include "confdefs.h" 11758 #include "confdefs.h"
11735 /* Override any gcc2 internal prototype to avoid an error. */ 11759 /* Override any gcc2 internal prototype to avoid an error. */
11736 /* We use char because int might match the return type of a gcc2 11760 /* We use char because int might match the return type of a gcc2
11737 builtin and then its argument prototype would still apply. */ 11761 builtin and then its argument prototype would still apply. */
11738 char jl_dic_list_e(); 11762 char jl_dic_list_e();
11739 11763
11740 int main() { 11764 int main() {
11741 jl_dic_list_e() 11765 jl_dic_list_e()
11742 ; return 0; } 11766 ; return 0; }
11743 EOF 11767 EOF
11744 if { (eval echo configure:11745: \"$ac_link\") 1>&5; (eval $ac_link) 2>&5; } && test -s conftest${ac_exeext}; then 11768 if { (eval echo configure:11769: \"$ac_link\") 1>&5; (eval $ac_link) 2>&5; } && test -s conftest${ac_exeext}; then
11745 rm -rf conftest* 11769 rm -rf conftest*
11746 eval "ac_cv_lib_$ac_lib_var=yes" 11770 eval "ac_cv_lib_$ac_lib_var=yes"
11747 else 11771 else
11748 echo "configure: failed program was:" >&5 11772 echo "configure: failed program was:" >&5
11749 cat conftest.$ac_ext >&5 11773 cat conftest.$ac_ext >&5
11757 echo "$ac_t""yes" 1>&6 11781 echo "$ac_t""yes" 1>&6
11758 libwnn=wnn4 11782 libwnn=wnn4
11759 else 11783 else
11760 echo "$ac_t""no" 1>&6 11784 echo "$ac_t""no" 1>&6
11761 echo $ac_n "checking for jl_dic_list_e in -lwnn6""... $ac_c" 1>&6 11785 echo $ac_n "checking for jl_dic_list_e in -lwnn6""... $ac_c" 1>&6
11762 echo "configure:11763: checking for jl_dic_list_e in -lwnn6" >&5 11786 echo "configure:11787: checking for jl_dic_list_e in -lwnn6" >&5
11763 ac_lib_var=`echo wnn6'_'jl_dic_list_e | sed 'y%./+-%__p_%'` 11787 ac_lib_var=`echo wnn6'_'jl_dic_list_e | sed 'y%./+-%__p_%'`
11764 11788
11765 xe_check_libs=" -lwnn6 " 11789 xe_check_libs=" -lwnn6 "
11766 cat > conftest.$ac_ext <<EOF 11790 cat > conftest.$ac_ext <<EOF
11767 #line 11768 "configure" 11791 #line 11792 "configure"
11768 #include "confdefs.h" 11792 #include "confdefs.h"
11769 /* Override any gcc2 internal prototype to avoid an error. */ 11793 /* Override any gcc2 internal prototype to avoid an error. */
11770 /* We use char because int might match the return type of a gcc2 11794 /* We use char because int might match the return type of a gcc2
11771 builtin and then its argument prototype would still apply. */ 11795 builtin and then its argument prototype would still apply. */
11772 char jl_dic_list_e(); 11796 char jl_dic_list_e();
11773 11797
11774 int main() { 11798 int main() {
11775 jl_dic_list_e() 11799 jl_dic_list_e()
11776 ; return 0; } 11800 ; return 0; }
11777 EOF 11801 EOF
11778 if { (eval echo configure:11779: \"$ac_link\") 1>&5; (eval $ac_link) 2>&5; } && test -s conftest${ac_exeext}; then 11802 if { (eval echo configure:11803: \"$ac_link\") 1>&5; (eval $ac_link) 2>&5; } && test -s conftest${ac_exeext}; then
11779 rm -rf conftest* 11803 rm -rf conftest*
11780 eval "ac_cv_lib_$ac_lib_var=yes" 11804 eval "ac_cv_lib_$ac_lib_var=yes"
11781 else 11805 else
11782 echo "configure: failed program was:" >&5 11806 echo "configure: failed program was:" >&5
11783 cat conftest.$ac_ext >&5 11807 cat conftest.$ac_ext >&5
11791 echo "$ac_t""yes" 1>&6 11815 echo "$ac_t""yes" 1>&6
11792 libwnn=wnn6 11816 libwnn=wnn6
11793 else 11817 else
11794 echo "$ac_t""no" 1>&6 11818 echo "$ac_t""no" 1>&6
11795 echo $ac_n "checking for dic_list_e in -lwnn6_fromsrc""... $ac_c" 1>&6 11819 echo $ac_n "checking for dic_list_e in -lwnn6_fromsrc""... $ac_c" 1>&6
11796 echo "configure:11797: checking for dic_list_e in -lwnn6_fromsrc" >&5 11820 echo "configure:11821: checking for dic_list_e in -lwnn6_fromsrc" >&5
11797 ac_lib_var=`echo wnn6_fromsrc'_'dic_list_e | sed 'y%./+-%__p_%'` 11821 ac_lib_var=`echo wnn6_fromsrc'_'dic_list_e | sed 'y%./+-%__p_%'`
11798 11822
11799 xe_check_libs=" -lwnn6_fromsrc " 11823 xe_check_libs=" -lwnn6_fromsrc "
11800 cat > conftest.$ac_ext <<EOF 11824 cat > conftest.$ac_ext <<EOF
11801 #line 11802 "configure" 11825 #line 11826 "configure"
11802 #include "confdefs.h" 11826 #include "confdefs.h"
11803 /* Override any gcc2 internal prototype to avoid an error. */ 11827 /* Override any gcc2 internal prototype to avoid an error. */
11804 /* We use char because int might match the return type of a gcc2 11828 /* We use char because int might match the return type of a gcc2
11805 builtin and then its argument prototype would still apply. */ 11829 builtin and then its argument prototype would still apply. */
11806 char dic_list_e(); 11830 char dic_list_e();
11807 11831
11808 int main() { 11832 int main() {
11809 dic_list_e() 11833 dic_list_e()
11810 ; return 0; } 11834 ; return 0; }
11811 EOF 11835 EOF
11812 if { (eval echo configure:11813: \"$ac_link\") 1>&5; (eval $ac_link) 2>&5; } && test -s conftest${ac_exeext}; then 11836 if { (eval echo configure:11837: \"$ac_link\") 1>&5; (eval $ac_link) 2>&5; } && test -s conftest${ac_exeext}; then
11813 rm -rf conftest* 11837 rm -rf conftest*
11814 eval "ac_cv_lib_$ac_lib_var=yes" 11838 eval "ac_cv_lib_$ac_lib_var=yes"
11815 else 11839 else
11816 echo "configure: failed program was:" >&5 11840 echo "configure: failed program was:" >&5
11817 cat conftest.$ac_ext >&5 11841 cat conftest.$ac_ext >&5
11852 11876
11853 libs_x="-l$libwnn $libs_x" && if test "$extra_verbose" = "yes"; then echo " Prepending \"-l$libwnn\" to \$libs_x"; fi 11877 libs_x="-l$libwnn $libs_x" && if test "$extra_verbose" = "yes"; then echo " Prepending \"-l$libwnn\" to \$libs_x"; fi
11854 if test "$with_wnn6" != "no"; then 11878 if test "$with_wnn6" != "no"; then
11855 11879
11856 echo $ac_n "checking for jl_fi_dic_list in -l$libwnn""... $ac_c" 1>&6 11880 echo $ac_n "checking for jl_fi_dic_list in -l$libwnn""... $ac_c" 1>&6
11857 echo "configure:11858: checking for jl_fi_dic_list in -l$libwnn" >&5 11881 echo "configure:11882: checking for jl_fi_dic_list in -l$libwnn" >&5
11858 ac_lib_var=`echo $libwnn'_'jl_fi_dic_list | sed 'y%./+-%__p_%'` 11882 ac_lib_var=`echo $libwnn'_'jl_fi_dic_list | sed 'y%./+-%__p_%'`
11859 11883
11860 xe_check_libs=" -l$libwnn " 11884 xe_check_libs=" -l$libwnn "
11861 cat > conftest.$ac_ext <<EOF 11885 cat > conftest.$ac_ext <<EOF
11862 #line 11863 "configure" 11886 #line 11887 "configure"
11863 #include "confdefs.h" 11887 #include "confdefs.h"
11864 /* Override any gcc2 internal prototype to avoid an error. */ 11888 /* Override any gcc2 internal prototype to avoid an error. */
11865 /* We use char because int might match the return type of a gcc2 11889 /* We use char because int might match the return type of a gcc2
11866 builtin and then its argument prototype would still apply. */ 11890 builtin and then its argument prototype would still apply. */
11867 char jl_fi_dic_list(); 11891 char jl_fi_dic_list();
11868 11892
11869 int main() { 11893 int main() {
11870 jl_fi_dic_list() 11894 jl_fi_dic_list()
11871 ; return 0; } 11895 ; return 0; }
11872 EOF 11896 EOF
11873 if { (eval echo configure:11874: \"$ac_link\") 1>&5; (eval $ac_link) 2>&5; } && test -s conftest${ac_exeext}; then 11897 if { (eval echo configure:11898: \"$ac_link\") 1>&5; (eval $ac_link) 2>&5; } && test -s conftest${ac_exeext}; then
11874 rm -rf conftest* 11898 rm -rf conftest*
11875 eval "ac_cv_lib_$ac_lib_var=yes" 11899 eval "ac_cv_lib_$ac_lib_var=yes"
11876 else 11900 else
11877 echo "configure: failed program was:" >&5 11901 echo "configure: failed program was:" >&5
11878 cat conftest.$ac_ext >&5 11902 cat conftest.$ac_ext >&5
11903 11927
11904 canna_includes_found=no 11928 canna_includes_found=no
11905 if test "$with_canna" != "no"; then 11929 if test "$with_canna" != "no"; then
11906 ac_safe=`echo "canna/jrkanji.h" | sed 'y%./+-%__p_%'` 11930 ac_safe=`echo "canna/jrkanji.h" | sed 'y%./+-%__p_%'`
11907 echo $ac_n "checking for canna/jrkanji.h""... $ac_c" 1>&6 11931 echo $ac_n "checking for canna/jrkanji.h""... $ac_c" 1>&6
11908 echo "configure:11909: checking for canna/jrkanji.h" >&5 11932 echo "configure:11933: checking for canna/jrkanji.h" >&5
11909 11933
11910 cat > conftest.$ac_ext <<EOF 11934 cat > conftest.$ac_ext <<EOF
11911 #line 11912 "configure" 11935 #line 11936 "configure"
11912 #include "confdefs.h" 11936 #include "confdefs.h"
11913 #include <canna/jrkanji.h> 11937 #include <canna/jrkanji.h>
11914 EOF 11938 EOF
11915 ac_try="$ac_cpp conftest.$ac_ext >/dev/null 2>conftest.out" 11939 ac_try="$ac_cpp conftest.$ac_ext >/dev/null 2>conftest.out"
11916 { (eval echo configure:11917: \"$ac_try\") 1>&5; (eval $ac_try) 2>&5; } 11940 { (eval echo configure:11941: \"$ac_try\") 1>&5; (eval $ac_try) 2>&5; }
11917 ac_err=`grep -v '^ *+' conftest.out | grep -v "^conftest.${ac_ext}\$"` 11941 ac_err=`grep -v '^ *+' conftest.out | grep -v "^conftest.${ac_ext}\$"`
11918 if test -z "$ac_err"; then 11942 if test -z "$ac_err"; then
11919 rm -rf conftest* 11943 rm -rf conftest*
11920 eval "ac_cv_header_$ac_safe=yes" 11944 eval "ac_cv_header_$ac_safe=yes"
11921 else 11945 else
11938 -d "/usr/local/canna/include"; then 11962 -d "/usr/local/canna/include"; then
11939 save_c_switch_site="$c_switch_site" 11963 save_c_switch_site="$c_switch_site"
11940 c_switch_site="$c_switch_site -I/usr/local/canna/include" 11964 c_switch_site="$c_switch_site -I/usr/local/canna/include"
11941 ac_safe=`echo "canna/jrkanji.h" | sed 'y%./+-%__p_%'` 11965 ac_safe=`echo "canna/jrkanji.h" | sed 'y%./+-%__p_%'`
11942 echo $ac_n "checking for canna/jrkanji.h""... $ac_c" 1>&6 11966 echo $ac_n "checking for canna/jrkanji.h""... $ac_c" 1>&6
11943 echo "configure:11944: checking for canna/jrkanji.h" >&5 11967 echo "configure:11968: checking for canna/jrkanji.h" >&5
11944 11968
11945 cat > conftest.$ac_ext <<EOF 11969 cat > conftest.$ac_ext <<EOF
11946 #line 11947 "configure" 11970 #line 11971 "configure"
11947 #include "confdefs.h" 11971 #include "confdefs.h"
11948 #include <canna/jrkanji.h> 11972 #include <canna/jrkanji.h>
11949 EOF 11973 EOF
11950 ac_try="$ac_cpp conftest.$ac_ext >/dev/null 2>conftest.out" 11974 ac_try="$ac_cpp conftest.$ac_ext >/dev/null 2>conftest.out"
11951 { (eval echo configure:11952: \"$ac_try\") 1>&5; (eval $ac_try) 2>&5; } 11975 { (eval echo configure:11976: \"$ac_try\") 1>&5; (eval $ac_try) 2>&5; }
11952 ac_err=`grep -v '^ *+' conftest.out | grep -v "^conftest.${ac_ext}\$"` 11976 ac_err=`grep -v '^ *+' conftest.out | grep -v "^conftest.${ac_ext}\$"`
11953 if test -z "$ac_err"; then 11977 if test -z "$ac_err"; then
11954 rm -rf conftest* 11978 rm -rf conftest*
11955 eval "ac_cv_header_$ac_safe=yes" 11979 eval "ac_cv_header_$ac_safe=yes"
11956 else 11980 else
11974 fi 11998 fi
11975 fi 11999 fi
11976 12000
11977 test -z "$with_canna" && { ac_safe=`echo "canna/RK.h" | sed 'y%./+-%__p_%'` 12001 test -z "$with_canna" && { ac_safe=`echo "canna/RK.h" | sed 'y%./+-%__p_%'`
11978 echo $ac_n "checking for canna/RK.h""... $ac_c" 1>&6 12002 echo $ac_n "checking for canna/RK.h""... $ac_c" 1>&6
11979 echo "configure:11980: checking for canna/RK.h" >&5 12003 echo "configure:12004: checking for canna/RK.h" >&5
11980 12004
11981 cat > conftest.$ac_ext <<EOF 12005 cat > conftest.$ac_ext <<EOF
11982 #line 11983 "configure" 12006 #line 12007 "configure"
11983 #include "confdefs.h" 12007 #include "confdefs.h"
11984 #include <canna/RK.h> 12008 #include <canna/RK.h>
11985 EOF 12009 EOF
11986 ac_try="$ac_cpp conftest.$ac_ext >/dev/null 2>conftest.out" 12010 ac_try="$ac_cpp conftest.$ac_ext >/dev/null 2>conftest.out"
11987 { (eval echo configure:11988: \"$ac_try\") 1>&5; (eval $ac_try) 2>&5; } 12011 { (eval echo configure:12012: \"$ac_try\") 1>&5; (eval $ac_try) 2>&5; }
11988 ac_err=`grep -v '^ *+' conftest.out | grep -v "^conftest.${ac_ext}\$"` 12012 ac_err=`grep -v '^ *+' conftest.out | grep -v "^conftest.${ac_ext}\$"`
11989 if test -z "$ac_err"; then 12013 if test -z "$ac_err"; then
11990 rm -rf conftest* 12014 rm -rf conftest*
11991 eval "ac_cv_header_$ac_safe=yes" 12015 eval "ac_cv_header_$ac_safe=yes"
11992 else 12016 else
12005 with_canna=no 12029 with_canna=no
12006 fi 12030 fi
12007 } 12031 }
12008 test -z "$with_canna" && { 12032 test -z "$with_canna" && {
12009 echo $ac_n "checking for RkBgnBun in -lRKC""... $ac_c" 1>&6 12033 echo $ac_n "checking for RkBgnBun in -lRKC""... $ac_c" 1>&6
12010 echo "configure:12011: checking for RkBgnBun in -lRKC" >&5 12034 echo "configure:12035: checking for RkBgnBun in -lRKC" >&5
12011 ac_lib_var=`echo RKC'_'RkBgnBun | sed 'y%./+-%__p_%'` 12035 ac_lib_var=`echo RKC'_'RkBgnBun | sed 'y%./+-%__p_%'`
12012 12036
12013 xe_check_libs=" -lRKC " 12037 xe_check_libs=" -lRKC "
12014 cat > conftest.$ac_ext <<EOF 12038 cat > conftest.$ac_ext <<EOF
12015 #line 12016 "configure" 12039 #line 12040 "configure"
12016 #include "confdefs.h" 12040 #include "confdefs.h"
12017 /* Override any gcc2 internal prototype to avoid an error. */ 12041 /* Override any gcc2 internal prototype to avoid an error. */
12018 /* We use char because int might match the return type of a gcc2 12042 /* We use char because int might match the return type of a gcc2
12019 builtin and then its argument prototype would still apply. */ 12043 builtin and then its argument prototype would still apply. */
12020 char RkBgnBun(); 12044 char RkBgnBun();
12021 12045
12022 int main() { 12046 int main() {
12023 RkBgnBun() 12047 RkBgnBun()
12024 ; return 0; } 12048 ; return 0; }
12025 EOF 12049 EOF
12026 if { (eval echo configure:12027: \"$ac_link\") 1>&5; (eval $ac_link) 2>&5; } && test -s conftest${ac_exeext}; then 12050 if { (eval echo configure:12051: \"$ac_link\") 1>&5; (eval $ac_link) 2>&5; } && test -s conftest${ac_exeext}; then
12027 rm -rf conftest* 12051 rm -rf conftest*
12028 eval "ac_cv_lib_$ac_lib_var=yes" 12052 eval "ac_cv_lib_$ac_lib_var=yes"
12029 else 12053 else
12030 echo "configure: failed program was:" >&5 12054 echo "configure: failed program was:" >&5
12031 cat conftest.$ac_ext >&5 12055 cat conftest.$ac_ext >&5
12044 fi 12068 fi
12045 12069
12046 } 12070 }
12047 test -z "$with_canna" && { 12071 test -z "$with_canna" && {
12048 echo $ac_n "checking for jrKanjiControl in -lcanna""... $ac_c" 1>&6 12072 echo $ac_n "checking for jrKanjiControl in -lcanna""... $ac_c" 1>&6
12049 echo "configure:12050: checking for jrKanjiControl in -lcanna" >&5 12073 echo "configure:12074: checking for jrKanjiControl in -lcanna" >&5
12050 ac_lib_var=`echo canna'_'jrKanjiControl | sed 'y%./+-%__p_%'` 12074 ac_lib_var=`echo canna'_'jrKanjiControl | sed 'y%./+-%__p_%'`
12051 12075
12052 xe_check_libs=" -lcanna " 12076 xe_check_libs=" -lcanna "
12053 cat > conftest.$ac_ext <<EOF 12077 cat > conftest.$ac_ext <<EOF
12054 #line 12055 "configure" 12078 #line 12079 "configure"
12055 #include "confdefs.h" 12079 #include "confdefs.h"
12056 /* Override any gcc2 internal prototype to avoid an error. */ 12080 /* Override any gcc2 internal prototype to avoid an error. */
12057 /* We use char because int might match the return type of a gcc2 12081 /* We use char because int might match the return type of a gcc2
12058 builtin and then its argument prototype would still apply. */ 12082 builtin and then its argument prototype would still apply. */
12059 char jrKanjiControl(); 12083 char jrKanjiControl();
12060 12084
12061 int main() { 12085 int main() {
12062 jrKanjiControl() 12086 jrKanjiControl()
12063 ; return 0; } 12087 ; return 0; }
12064 EOF 12088 EOF
12065 if { (eval echo configure:12066: \"$ac_link\") 1>&5; (eval $ac_link) 2>&5; } && test -s conftest${ac_exeext}; then 12089 if { (eval echo configure:12090: \"$ac_link\") 1>&5; (eval $ac_link) 2>&5; } && test -s conftest${ac_exeext}; then
12066 rm -rf conftest* 12090 rm -rf conftest*
12067 eval "ac_cv_lib_$ac_lib_var=yes" 12091 eval "ac_cv_lib_$ac_lib_var=yes"
12068 else 12092 else
12069 echo "configure: failed program was:" >&5 12093 echo "configure: failed program was:" >&5
12070 cat conftest.$ac_ext >&5 12094 cat conftest.$ac_ext >&5
12106 12130
12107 if test "$need_motif" = "yes" ; then 12131 if test "$need_motif" = "yes" ; then
12108 libs_x="-lXm $libs_x" && if test "$extra_verbose" = "yes"; then echo " Prepending \"-lXm\" to \$libs_x"; fi 12132 libs_x="-lXm $libs_x" && if test "$extra_verbose" = "yes"; then echo " Prepending \"-lXm\" to \$libs_x"; fi
12109 12133
12110 echo $ac_n "checking for layout_object_getvalue in -li18n""... $ac_c" 1>&6 12134 echo $ac_n "checking for layout_object_getvalue in -li18n""... $ac_c" 1>&6
12111 echo "configure:12112: checking for layout_object_getvalue in -li18n" >&5 12135 echo "configure:12136: checking for layout_object_getvalue in -li18n" >&5
12112 ac_lib_var=`echo i18n'_'layout_object_getvalue | sed 'y%./+-%__p_%'` 12136 ac_lib_var=`echo i18n'_'layout_object_getvalue | sed 'y%./+-%__p_%'`
12113 12137
12114 xe_check_libs=" -li18n " 12138 xe_check_libs=" -li18n "
12115 cat > conftest.$ac_ext <<EOF 12139 cat > conftest.$ac_ext <<EOF
12116 #line 12117 "configure" 12140 #line 12141 "configure"
12117 #include "confdefs.h" 12141 #include "confdefs.h"
12118 /* Override any gcc2 internal prototype to avoid an error. */ 12142 /* Override any gcc2 internal prototype to avoid an error. */
12119 /* We use char because int might match the return type of a gcc2 12143 /* We use char because int might match the return type of a gcc2
12120 builtin and then its argument prototype would still apply. */ 12144 builtin and then its argument prototype would still apply. */
12121 char layout_object_getvalue(); 12145 char layout_object_getvalue();
12122 12146
12123 int main() { 12147 int main() {
12124 layout_object_getvalue() 12148 layout_object_getvalue()
12125 ; return 0; } 12149 ; return 0; }
12126 EOF 12150 EOF
12127 if { (eval echo configure:12128: \"$ac_link\") 1>&5; (eval $ac_link) 2>&5; } && test -s conftest${ac_exeext}; then 12151 if { (eval echo configure:12152: \"$ac_link\") 1>&5; (eval $ac_link) 2>&5; } && test -s conftest${ac_exeext}; then
12128 rm -rf conftest* 12152 rm -rf conftest*
12129 eval "ac_cv_lib_$ac_lib_var=yes" 12153 eval "ac_cv_lib_$ac_lib_var=yes"
12130 else 12154 else
12131 echo "configure: failed program was:" >&5 12155 echo "configure: failed program was:" >&5
12132 cat conftest.$ac_ext >&5 12156 cat conftest.$ac_ext >&5
12206 fi 12230 fi
12207 12231
12208 fi 12232 fi
12209 12233
12210 12234
12211 for ac_func in cbrt closedir dup2 eaccess fmod fpathconf frexp ftime getaddrinfo gethostname getnameinfo getpagesize getrlimit gettimeofday getcwd getwd link logb lrand48 matherr mkdir mktime perror poll random readlink rename res_init rint rmdir select setitimer setpgid setlocale setsid sigblock sighold sigprocmask snprintf stpcpy strerror strlwr strupr symlink tzset ulimit usleep waitpid vsnprintf fsync ftruncate umask wcslen wcscmp vlimit 12235 for ac_func in cbrt closedir dup2 eaccess fmod fpathconf frexp fsync ftime ftruncate getaddrinfo gethostname getnameinfo getpagesize getrlimit gettimeofday getcwd link logb lrand48 matherr mkdir mktime perror poll random readlink rename res_init rint rmdir select setitimer setpgid setsid sigblock sighold sigprocmask snprintf strerror strlwr strupr symlink tzset ulimit umask usleep vlimit vsnprintf waitpid wcscmp wcslen
12212 do 12236 do
12213 echo $ac_n "checking for $ac_func""... $ac_c" 1>&6 12237 echo $ac_n "checking for $ac_func""... $ac_c" 1>&6
12214 echo "configure:12215: checking for $ac_func" >&5 12238 echo "configure:12239: checking for $ac_func" >&5
12215 12239
12216 cat > conftest.$ac_ext <<EOF 12240 cat > conftest.$ac_ext <<EOF
12217 #line 12218 "configure" 12241 #line 12242 "configure"
12218 #include "confdefs.h" 12242 #include "confdefs.h"
12219 /* System header to define __stub macros and hopefully few prototypes, 12243 /* System header to define __stub macros and hopefully few prototypes,
12220 which can conflict with char $ac_func(); below. */ 12244 which can conflict with char $ac_func(); below. */
12221 #include <assert.h> 12245 #include <assert.h>
12222 /* Override any gcc2 internal prototype to avoid an error. */ 12246 /* Override any gcc2 internal prototype to avoid an error. */
12235 $ac_func(); 12259 $ac_func();
12236 #endif 12260 #endif
12237 12261
12238 ; return 0; } 12262 ; return 0; }
12239 EOF 12263 EOF
12240 if { (eval echo configure:12241: \"$ac_link\") 1>&5; (eval $ac_link) 2>&5; } && test -s conftest${ac_exeext}; then 12264 if { (eval echo configure:12265: \"$ac_link\") 1>&5; (eval $ac_link) 2>&5; } && test -s conftest${ac_exeext}; then
12241 rm -rf conftest* 12265 rm -rf conftest*
12242 eval "ac_cv_func_$ac_func=yes" 12266 eval "ac_cv_func_$ac_func=yes"
12243 else 12267 else
12244 echo "configure: failed program was:" >&5 12268 echo "configure: failed program was:" >&5
12245 cat conftest.$ac_ext >&5 12269 cat conftest.$ac_ext >&5
12276 12300
12277 12301
12278 for ac_func in getpt _getpty grantpt unlockpt ptsname killpg tcgetpgrp 12302 for ac_func in getpt _getpty grantpt unlockpt ptsname killpg tcgetpgrp
12279 do 12303 do
12280 echo $ac_n "checking for $ac_func""... $ac_c" 1>&6 12304 echo $ac_n "checking for $ac_func""... $ac_c" 1>&6
12281 echo "configure:12282: checking for $ac_func" >&5 12305 echo "configure:12306: checking for $ac_func" >&5
12282 12306
12283 cat > conftest.$ac_ext <<EOF 12307 cat > conftest.$ac_ext <<EOF
12284 #line 12285 "configure" 12308 #line 12309 "configure"
12285 #include "confdefs.h" 12309 #include "confdefs.h"
12286 /* System header to define __stub macros and hopefully few prototypes, 12310 /* System header to define __stub macros and hopefully few prototypes,
12287 which can conflict with char $ac_func(); below. */ 12311 which can conflict with char $ac_func(); below. */
12288 #include <assert.h> 12312 #include <assert.h>
12289 /* Override any gcc2 internal prototype to avoid an error. */ 12313 /* Override any gcc2 internal prototype to avoid an error. */
12302 $ac_func(); 12326 $ac_func();
12303 #endif 12327 #endif
12304 12328
12305 ; return 0; } 12329 ; return 0; }
12306 EOF 12330 EOF
12307 if { (eval echo configure:12308: \"$ac_link\") 1>&5; (eval $ac_link) 2>&5; } && test -s conftest${ac_exeext}; then 12331 if { (eval echo configure:12332: \"$ac_link\") 1>&5; (eval $ac_link) 2>&5; } && test -s conftest${ac_exeext}; then
12308 rm -rf conftest* 12332 rm -rf conftest*
12309 eval "ac_cv_func_$ac_func=yes" 12333 eval "ac_cv_func_$ac_func=yes"
12310 else 12334 else
12311 echo "configure: failed program was:" >&5 12335 echo "configure: failed program was:" >&5
12312 cat conftest.$ac_ext >&5 12336 cat conftest.$ac_ext >&5
12331 fi 12355 fi
12332 done 12356 done
12333 12357
12334 12358
12335 echo $ac_n "checking for openpty""... $ac_c" 1>&6 12359 echo $ac_n "checking for openpty""... $ac_c" 1>&6
12336 echo "configure:12337: checking for openpty" >&5 12360 echo "configure:12361: checking for openpty" >&5
12337 12361
12338 cat > conftest.$ac_ext <<EOF 12362 cat > conftest.$ac_ext <<EOF
12339 #line 12340 "configure" 12363 #line 12364 "configure"
12340 #include "confdefs.h" 12364 #include "confdefs.h"
12341 /* System header to define __stub macros and hopefully few prototypes, 12365 /* System header to define __stub macros and hopefully few prototypes,
12342 which can conflict with char openpty(); below. */ 12366 which can conflict with char openpty(); below. */
12343 #include <assert.h> 12367 #include <assert.h>
12344 /* Override any gcc2 internal prototype to avoid an error. */ 12368 /* Override any gcc2 internal prototype to avoid an error. */
12357 openpty(); 12381 openpty();
12358 #endif 12382 #endif
12359 12383
12360 ; return 0; } 12384 ; return 0; }
12361 EOF 12385 EOF
12362 if { (eval echo configure:12363: \"$ac_link\") 1>&5; (eval $ac_link) 2>&5; } && test -s conftest${ac_exeext}; then 12386 if { (eval echo configure:12387: \"$ac_link\") 1>&5; (eval $ac_link) 2>&5; } && test -s conftest${ac_exeext}; then
12363 rm -rf conftest* 12387 rm -rf conftest*
12364 eval "ac_cv_func_openpty=yes" 12388 eval "ac_cv_func_openpty=yes"
12365 else 12389 else
12366 echo "configure: failed program was:" >&5 12390 echo "configure: failed program was:" >&5
12367 cat conftest.$ac_ext >&5 12391 cat conftest.$ac_ext >&5
12376 else 12400 else
12377 echo "$ac_t""no" 1>&6 12401 echo "$ac_t""no" 1>&6
12378 12402
12379 12403
12380 echo $ac_n "checking for openpty in -lutil""... $ac_c" 1>&6 12404 echo $ac_n "checking for openpty in -lutil""... $ac_c" 1>&6
12381 echo "configure:12382: checking for openpty in -lutil" >&5 12405 echo "configure:12406: checking for openpty in -lutil" >&5
12382 ac_lib_var=`echo util'_'openpty | sed 'y%./+-%__p_%'` 12406 ac_lib_var=`echo util'_'openpty | sed 'y%./+-%__p_%'`
12383 12407
12384 xe_check_libs=" -lutil " 12408 xe_check_libs=" -lutil "
12385 cat > conftest.$ac_ext <<EOF 12409 cat > conftest.$ac_ext <<EOF
12386 #line 12387 "configure" 12410 #line 12411 "configure"
12387 #include "confdefs.h" 12411 #include "confdefs.h"
12388 /* Override any gcc2 internal prototype to avoid an error. */ 12412 /* Override any gcc2 internal prototype to avoid an error. */
12389 /* We use char because int might match the return type of a gcc2 12413 /* We use char because int might match the return type of a gcc2
12390 builtin and then its argument prototype would still apply. */ 12414 builtin and then its argument prototype would still apply. */
12391 char openpty(); 12415 char openpty();
12392 12416
12393 int main() { 12417 int main() {
12394 openpty() 12418 openpty()
12395 ; return 0; } 12419 ; return 0; }
12396 EOF 12420 EOF
12397 if { (eval echo configure:12398: \"$ac_link\") 1>&5; (eval $ac_link) 2>&5; } && test -s conftest${ac_exeext}; then 12421 if { (eval echo configure:12422: \"$ac_link\") 1>&5; (eval $ac_link) 2>&5; } && test -s conftest${ac_exeext}; then
12398 rm -rf conftest* 12422 rm -rf conftest*
12399 eval "ac_cv_lib_$ac_lib_var=yes" 12423 eval "ac_cv_lib_$ac_lib_var=yes"
12400 else 12424 else
12401 echo "configure: failed program was:" >&5 12425 echo "configure: failed program was:" >&5
12402 cat conftest.$ac_ext >&5 12426 cat conftest.$ac_ext >&5
12427 12451
12428 for ac_hdr in libutil.h util.h 12452 for ac_hdr in libutil.h util.h
12429 do 12453 do
12430 ac_safe=`echo "$ac_hdr" | sed 'y%./+-%__p_%'` 12454 ac_safe=`echo "$ac_hdr" | sed 'y%./+-%__p_%'`
12431 echo $ac_n "checking for $ac_hdr""... $ac_c" 1>&6 12455 echo $ac_n "checking for $ac_hdr""... $ac_c" 1>&6
12432 echo "configure:12433: checking for $ac_hdr" >&5 12456 echo "configure:12457: checking for $ac_hdr" >&5
12433 12457
12434 cat > conftest.$ac_ext <<EOF 12458 cat > conftest.$ac_ext <<EOF
12435 #line 12436 "configure" 12459 #line 12460 "configure"
12436 #include "confdefs.h" 12460 #include "confdefs.h"
12437 #include <$ac_hdr> 12461 #include <$ac_hdr>
12438 EOF 12462 EOF
12439 ac_try="$ac_cpp conftest.$ac_ext >/dev/null 2>conftest.out" 12463 ac_try="$ac_cpp conftest.$ac_ext >/dev/null 2>conftest.out"
12440 { (eval echo configure:12441: \"$ac_try\") 1>&5; (eval $ac_try) 2>&5; } 12464 { (eval echo configure:12465: \"$ac_try\") 1>&5; (eval $ac_try) 2>&5; }
12441 ac_err=`grep -v '^ *+' conftest.out | grep -v "^conftest.${ac_ext}\$"` 12465 ac_err=`grep -v '^ *+' conftest.out | grep -v "^conftest.${ac_ext}\$"`
12442 if test -z "$ac_err"; then 12466 if test -z "$ac_err"; then
12443 rm -rf conftest* 12467 rm -rf conftest*
12444 eval "ac_cv_header_$ac_safe=yes" 12468 eval "ac_cv_header_$ac_safe=yes"
12445 else 12469 else
12472 case "$opsys" in 12496 case "$opsys" in
12473 hpux*) for ac_hdr in sys/ptyio.h 12497 hpux*) for ac_hdr in sys/ptyio.h
12474 do 12498 do
12475 ac_safe=`echo "$ac_hdr" | sed 'y%./+-%__p_%'` 12499 ac_safe=`echo "$ac_hdr" | sed 'y%./+-%__p_%'`
12476 echo $ac_n "checking for $ac_hdr""... $ac_c" 1>&6 12500 echo $ac_n "checking for $ac_hdr""... $ac_c" 1>&6
12477 echo "configure:12478: checking for $ac_hdr" >&5 12501 echo "configure:12502: checking for $ac_hdr" >&5
12478 12502
12479 cat > conftest.$ac_ext <<EOF 12503 cat > conftest.$ac_ext <<EOF
12480 #line 12481 "configure" 12504 #line 12505 "configure"
12481 #include "confdefs.h" 12505 #include "confdefs.h"
12482 #include <$ac_hdr> 12506 #include <$ac_hdr>
12483 EOF 12507 EOF
12484 ac_try="$ac_cpp conftest.$ac_ext >/dev/null 2>conftest.out" 12508 ac_try="$ac_cpp conftest.$ac_ext >/dev/null 2>conftest.out"
12485 { (eval echo configure:12486: \"$ac_try\") 1>&5; (eval $ac_try) 2>&5; } 12509 { (eval echo configure:12510: \"$ac_try\") 1>&5; (eval $ac_try) 2>&5; }
12486 ac_err=`grep -v '^ *+' conftest.out | grep -v "^conftest.${ac_ext}\$"` 12510 ac_err=`grep -v '^ *+' conftest.out | grep -v "^conftest.${ac_ext}\$"`
12487 if test -z "$ac_err"; then 12511 if test -z "$ac_err"; then
12488 rm -rf conftest* 12512 rm -rf conftest*
12489 eval "ac_cv_header_$ac_safe=yes" 12513 eval "ac_cv_header_$ac_safe=yes"
12490 else 12514 else
12513 ;; 12537 ;;
12514 *) for ac_hdr in pty.h 12538 *) for ac_hdr in pty.h
12515 do 12539 do
12516 ac_safe=`echo "$ac_hdr" | sed 'y%./+-%__p_%'` 12540 ac_safe=`echo "$ac_hdr" | sed 'y%./+-%__p_%'`
12517 echo $ac_n "checking for $ac_hdr""... $ac_c" 1>&6 12541 echo $ac_n "checking for $ac_hdr""... $ac_c" 1>&6
12518 echo "configure:12519: checking for $ac_hdr" >&5 12542 echo "configure:12543: checking for $ac_hdr" >&5
12519 12543
12520 cat > conftest.$ac_ext <<EOF 12544 cat > conftest.$ac_ext <<EOF
12521 #line 12522 "configure" 12545 #line 12546 "configure"
12522 #include "confdefs.h" 12546 #include "confdefs.h"
12523 #include <$ac_hdr> 12547 #include <$ac_hdr>
12524 EOF 12548 EOF
12525 ac_try="$ac_cpp conftest.$ac_ext >/dev/null 2>conftest.out" 12549 ac_try="$ac_cpp conftest.$ac_ext >/dev/null 2>conftest.out"
12526 { (eval echo configure:12527: \"$ac_try\") 1>&5; (eval $ac_try) 2>&5; } 12550 { (eval echo configure:12551: \"$ac_try\") 1>&5; (eval $ac_try) 2>&5; }
12527 ac_err=`grep -v '^ *+' conftest.out | grep -v "^conftest.${ac_ext}\$"` 12551 ac_err=`grep -v '^ *+' conftest.out | grep -v "^conftest.${ac_ext}\$"`
12528 if test -z "$ac_err"; then 12552 if test -z "$ac_err"; then
12529 rm -rf conftest* 12553 rm -rf conftest*
12530 eval "ac_cv_header_$ac_safe=yes" 12554 eval "ac_cv_header_$ac_safe=yes"
12531 else 12555 else
12554 12578
12555 test "$ac_cv_header_pty_h" = "no" && for ac_hdr in sys/pty.h 12579 test "$ac_cv_header_pty_h" = "no" && for ac_hdr in sys/pty.h
12556 do 12580 do
12557 ac_safe=`echo "$ac_hdr" | sed 'y%./+-%__p_%'` 12581 ac_safe=`echo "$ac_hdr" | sed 'y%./+-%__p_%'`
12558 echo $ac_n "checking for $ac_hdr""... $ac_c" 1>&6 12582 echo $ac_n "checking for $ac_hdr""... $ac_c" 1>&6
12559 echo "configure:12560: checking for $ac_hdr" >&5 12583 echo "configure:12584: checking for $ac_hdr" >&5
12560 12584
12561 cat > conftest.$ac_ext <<EOF 12585 cat > conftest.$ac_ext <<EOF
12562 #line 12563 "configure" 12586 #line 12587 "configure"
12563 #include "confdefs.h" 12587 #include "confdefs.h"
12564 #include <$ac_hdr> 12588 #include <$ac_hdr>
12565 EOF 12589 EOF
12566 ac_try="$ac_cpp conftest.$ac_ext >/dev/null 2>conftest.out" 12590 ac_try="$ac_cpp conftest.$ac_ext >/dev/null 2>conftest.out"
12567 { (eval echo configure:12568: \"$ac_try\") 1>&5; (eval $ac_try) 2>&5; } 12591 { (eval echo configure:12592: \"$ac_try\") 1>&5; (eval $ac_try) 2>&5; }
12568 ac_err=`grep -v '^ *+' conftest.out | grep -v "^conftest.${ac_ext}\$"` 12592 ac_err=`grep -v '^ *+' conftest.out | grep -v "^conftest.${ac_ext}\$"`
12569 if test -z "$ac_err"; then 12593 if test -z "$ac_err"; then
12570 rm -rf conftest* 12594 rm -rf conftest*
12571 eval "ac_cv_header_$ac_safe=yes" 12595 eval "ac_cv_header_$ac_safe=yes"
12572 else 12596 else
12598 12622
12599 for ac_hdr in stropts.h 12623 for ac_hdr in stropts.h
12600 do 12624 do
12601 ac_safe=`echo "$ac_hdr" | sed 'y%./+-%__p_%'` 12625 ac_safe=`echo "$ac_hdr" | sed 'y%./+-%__p_%'`
12602 echo $ac_n "checking for $ac_hdr""... $ac_c" 1>&6 12626 echo $ac_n "checking for $ac_hdr""... $ac_c" 1>&6
12603 echo "configure:12604: checking for $ac_hdr" >&5 12627 echo "configure:12628: checking for $ac_hdr" >&5
12604 12628
12605 cat > conftest.$ac_ext <<EOF 12629 cat > conftest.$ac_ext <<EOF
12606 #line 12607 "configure" 12630 #line 12631 "configure"
12607 #include "confdefs.h" 12631 #include "confdefs.h"
12608 #include <$ac_hdr> 12632 #include <$ac_hdr>
12609 EOF 12633 EOF
12610 ac_try="$ac_cpp conftest.$ac_ext >/dev/null 2>conftest.out" 12634 ac_try="$ac_cpp conftest.$ac_ext >/dev/null 2>conftest.out"
12611 { (eval echo configure:12612: \"$ac_try\") 1>&5; (eval $ac_try) 2>&5; } 12635 { (eval echo configure:12636: \"$ac_try\") 1>&5; (eval $ac_try) 2>&5; }
12612 ac_err=`grep -v '^ *+' conftest.out | grep -v "^conftest.${ac_ext}\$"` 12636 ac_err=`grep -v '^ *+' conftest.out | grep -v "^conftest.${ac_ext}\$"`
12613 if test -z "$ac_err"; then 12637 if test -z "$ac_err"; then
12614 rm -rf conftest* 12638 rm -rf conftest*
12615 eval "ac_cv_header_$ac_safe=yes" 12639 eval "ac_cv_header_$ac_safe=yes"
12616 else 12640 else
12639 12663
12640 if test "$ac_cv_header_stropts_h" = "yes"; then 12664 if test "$ac_cv_header_stropts_h" = "yes"; then
12641 for ac_func in isastream 12665 for ac_func in isastream
12642 do 12666 do
12643 echo $ac_n "checking for $ac_func""... $ac_c" 1>&6 12667 echo $ac_n "checking for $ac_func""... $ac_c" 1>&6
12644 echo "configure:12645: checking for $ac_func" >&5 12668 echo "configure:12669: checking for $ac_func" >&5
12645 12669
12646 cat > conftest.$ac_ext <<EOF 12670 cat > conftest.$ac_ext <<EOF
12647 #line 12648 "configure" 12671 #line 12672 "configure"
12648 #include "confdefs.h" 12672 #include "confdefs.h"
12649 /* System header to define __stub macros and hopefully few prototypes, 12673 /* System header to define __stub macros and hopefully few prototypes,
12650 which can conflict with char $ac_func(); below. */ 12674 which can conflict with char $ac_func(); below. */
12651 #include <assert.h> 12675 #include <assert.h>
12652 /* Override any gcc2 internal prototype to avoid an error. */ 12676 /* Override any gcc2 internal prototype to avoid an error. */
12665 $ac_func(); 12689 $ac_func();
12666 #endif 12690 #endif
12667 12691
12668 ; return 0; } 12692 ; return 0; }
12669 EOF 12693 EOF
12670 if { (eval echo configure:12671: \"$ac_link\") 1>&5; (eval $ac_link) 2>&5; } && test -s conftest${ac_exeext}; then 12694 if { (eval echo configure:12695: \"$ac_link\") 1>&5; (eval $ac_link) 2>&5; } && test -s conftest${ac_exeext}; then
12671 rm -rf conftest* 12695 rm -rf conftest*
12672 eval "ac_cv_func_$ac_func=yes" 12696 eval "ac_cv_func_$ac_func=yes"
12673 else 12697 else
12674 echo "configure: failed program was:" >&5 12698 echo "configure: failed program was:" >&5
12675 cat conftest.$ac_ext >&5 12699 cat conftest.$ac_ext >&5
12696 12720
12697 for ac_hdr in strtio.h 12721 for ac_hdr in strtio.h
12698 do 12722 do
12699 ac_safe=`echo "$ac_hdr" | sed 'y%./+-%__p_%'` 12723 ac_safe=`echo "$ac_hdr" | sed 'y%./+-%__p_%'`
12700 echo $ac_n "checking for $ac_hdr""... $ac_c" 1>&6 12724 echo $ac_n "checking for $ac_hdr""... $ac_c" 1>&6
12701 echo "configure:12702: checking for $ac_hdr" >&5 12725 echo "configure:12726: checking for $ac_hdr" >&5
12702 12726
12703 cat > conftest.$ac_ext <<EOF 12727 cat > conftest.$ac_ext <<EOF
12704 #line 12705 "configure" 12728 #line 12729 "configure"
12705 #include "confdefs.h" 12729 #include "confdefs.h"
12706 #include <$ac_hdr> 12730 #include <$ac_hdr>
12707 EOF 12731 EOF
12708 ac_try="$ac_cpp conftest.$ac_ext >/dev/null 2>conftest.out" 12732 ac_try="$ac_cpp conftest.$ac_ext >/dev/null 2>conftest.out"
12709 { (eval echo configure:12710: \"$ac_try\") 1>&5; (eval $ac_try) 2>&5; } 12733 { (eval echo configure:12734: \"$ac_try\") 1>&5; (eval $ac_try) 2>&5; }
12710 ac_err=`grep -v '^ *+' conftest.out | grep -v "^conftest.${ac_ext}\$"` 12734 ac_err=`grep -v '^ *+' conftest.out | grep -v "^conftest.${ac_ext}\$"`
12711 if test -z "$ac_err"; then 12735 if test -z "$ac_err"; then
12712 rm -rf conftest* 12736 rm -rf conftest*
12713 eval "ac_cv_header_$ac_safe=yes" 12737 eval "ac_cv_header_$ac_safe=yes"
12714 else 12738 else
12737 fi 12761 fi
12738 12762
12739 for ac_func in getloadavg 12763 for ac_func in getloadavg
12740 do 12764 do
12741 echo $ac_n "checking for $ac_func""... $ac_c" 1>&6 12765 echo $ac_n "checking for $ac_func""... $ac_c" 1>&6
12742 echo "configure:12743: checking for $ac_func" >&5 12766 echo "configure:12767: checking for $ac_func" >&5
12743 12767
12744 cat > conftest.$ac_ext <<EOF 12768 cat > conftest.$ac_ext <<EOF
12745 #line 12746 "configure" 12769 #line 12770 "configure"
12746 #include "confdefs.h" 12770 #include "confdefs.h"
12747 /* System header to define __stub macros and hopefully few prototypes, 12771 /* System header to define __stub macros and hopefully few prototypes,
12748 which can conflict with char $ac_func(); below. */ 12772 which can conflict with char $ac_func(); below. */
12749 #include <assert.h> 12773 #include <assert.h>
12750 /* Override any gcc2 internal prototype to avoid an error. */ 12774 /* Override any gcc2 internal prototype to avoid an error. */
12763 $ac_func(); 12787 $ac_func();
12764 #endif 12788 #endif
12765 12789
12766 ; return 0; } 12790 ; return 0; }
12767 EOF 12791 EOF
12768 if { (eval echo configure:12769: \"$ac_link\") 1>&5; (eval $ac_link) 2>&5; } && test -s conftest${ac_exeext}; then 12792 if { (eval echo configure:12793: \"$ac_link\") 1>&5; (eval $ac_link) 2>&5; } && test -s conftest${ac_exeext}; then
12769 rm -rf conftest* 12793 rm -rf conftest*
12770 eval "ac_cv_func_$ac_func=yes" 12794 eval "ac_cv_func_$ac_func=yes"
12771 else 12795 else
12772 echo "configure: failed program was:" >&5 12796 echo "configure: failed program was:" >&5
12773 cat conftest.$ac_ext >&5 12797 cat conftest.$ac_ext >&5
12796 if test "$ac_cv_func_getloadavg" = "yes"; then 12820 if test "$ac_cv_func_getloadavg" = "yes"; then
12797 for ac_hdr in sys/loadavg.h 12821 for ac_hdr in sys/loadavg.h
12798 do 12822 do
12799 ac_safe=`echo "$ac_hdr" | sed 'y%./+-%__p_%'` 12823 ac_safe=`echo "$ac_hdr" | sed 'y%./+-%__p_%'`
12800 echo $ac_n "checking for $ac_hdr""... $ac_c" 1>&6 12824 echo $ac_n "checking for $ac_hdr""... $ac_c" 1>&6
12801 echo "configure:12802: checking for $ac_hdr" >&5 12825 echo "configure:12826: checking for $ac_hdr" >&5
12802 12826
12803 cat > conftest.$ac_ext <<EOF 12827 cat > conftest.$ac_ext <<EOF
12804 #line 12805 "configure" 12828 #line 12829 "configure"
12805 #include "confdefs.h" 12829 #include "confdefs.h"
12806 #include <$ac_hdr> 12830 #include <$ac_hdr>
12807 EOF 12831 EOF
12808 ac_try="$ac_cpp conftest.$ac_ext >/dev/null 2>conftest.out" 12832 ac_try="$ac_cpp conftest.$ac_ext >/dev/null 2>conftest.out"
12809 { (eval echo configure:12810: \"$ac_try\") 1>&5; (eval $ac_try) 2>&5; } 12833 { (eval echo configure:12834: \"$ac_try\") 1>&5; (eval $ac_try) 2>&5; }
12810 ac_err=`grep -v '^ *+' conftest.out | grep -v "^conftest.${ac_ext}\$"` 12834 ac_err=`grep -v '^ *+' conftest.out | grep -v "^conftest.${ac_ext}\$"`
12811 if test -z "$ac_err"; then 12835 if test -z "$ac_err"; then
12812 rm -rf conftest* 12836 rm -rf conftest*
12813 eval "ac_cv_header_$ac_safe=yes" 12837 eval "ac_cv_header_$ac_safe=yes"
12814 else 12838 else
12840 echo " xemacs will be linked with \"getloadavg.o\"" 12864 echo " xemacs will be linked with \"getloadavg.o\""
12841 fi 12865 fi
12842 12866
12843 12867
12844 echo $ac_n "checking for kstat_open in -lkstat""... $ac_c" 1>&6 12868 echo $ac_n "checking for kstat_open in -lkstat""... $ac_c" 1>&6
12845 echo "configure:12846: checking for kstat_open in -lkstat" >&5 12869 echo "configure:12870: checking for kstat_open in -lkstat" >&5
12846 ac_lib_var=`echo kstat'_'kstat_open | sed 'y%./+-%__p_%'` 12870 ac_lib_var=`echo kstat'_'kstat_open | sed 'y%./+-%__p_%'`
12847 12871
12848 xe_check_libs=" -lkstat " 12872 xe_check_libs=" -lkstat "
12849 cat > conftest.$ac_ext <<EOF 12873 cat > conftest.$ac_ext <<EOF
12850 #line 12851 "configure" 12874 #line 12875 "configure"
12851 #include "confdefs.h" 12875 #include "confdefs.h"
12852 /* Override any gcc2 internal prototype to avoid an error. */ 12876 /* Override any gcc2 internal prototype to avoid an error. */
12853 /* We use char because int might match the return type of a gcc2 12877 /* We use char because int might match the return type of a gcc2
12854 builtin and then its argument prototype would still apply. */ 12878 builtin and then its argument prototype would still apply. */
12855 char kstat_open(); 12879 char kstat_open();
12856 12880
12857 int main() { 12881 int main() {
12858 kstat_open() 12882 kstat_open()
12859 ; return 0; } 12883 ; return 0; }
12860 EOF 12884 EOF
12861 if { (eval echo configure:12862: \"$ac_link\") 1>&5; (eval $ac_link) 2>&5; } && test -s conftest${ac_exeext}; then 12885 if { (eval echo configure:12886: \"$ac_link\") 1>&5; (eval $ac_link) 2>&5; } && test -s conftest${ac_exeext}; then
12862 rm -rf conftest* 12886 rm -rf conftest*
12863 eval "ac_cv_lib_$ac_lib_var=yes" 12887 eval "ac_cv_lib_$ac_lib_var=yes"
12864 else 12888 else
12865 echo "configure: failed program was:" >&5 12889 echo "configure: failed program was:" >&5
12866 cat conftest.$ac_ext >&5 12890 cat conftest.$ac_ext >&5
12891 12915
12892 for ac_hdr in kstat.h 12916 for ac_hdr in kstat.h
12893 do 12917 do
12894 ac_safe=`echo "$ac_hdr" | sed 'y%./+-%__p_%'` 12918 ac_safe=`echo "$ac_hdr" | sed 'y%./+-%__p_%'`
12895 echo $ac_n "checking for $ac_hdr""... $ac_c" 1>&6 12919 echo $ac_n "checking for $ac_hdr""... $ac_c" 1>&6
12896 echo "configure:12897: checking for $ac_hdr" >&5 12920 echo "configure:12921: checking for $ac_hdr" >&5
12897 12921
12898 cat > conftest.$ac_ext <<EOF 12922 cat > conftest.$ac_ext <<EOF
12899 #line 12900 "configure" 12923 #line 12924 "configure"
12900 #include "confdefs.h" 12924 #include "confdefs.h"
12901 #include <$ac_hdr> 12925 #include <$ac_hdr>
12902 EOF 12926 EOF
12903 ac_try="$ac_cpp conftest.$ac_ext >/dev/null 2>conftest.out" 12927 ac_try="$ac_cpp conftest.$ac_ext >/dev/null 2>conftest.out"
12904 { (eval echo configure:12905: \"$ac_try\") 1>&5; (eval $ac_try) 2>&5; } 12928 { (eval echo configure:12929: \"$ac_try\") 1>&5; (eval $ac_try) 2>&5; }
12905 ac_err=`grep -v '^ *+' conftest.out | grep -v "^conftest.${ac_ext}\$"` 12929 ac_err=`grep -v '^ *+' conftest.out | grep -v "^conftest.${ac_ext}\$"`
12906 if test -z "$ac_err"; then 12930 if test -z "$ac_err"; then
12907 rm -rf conftest* 12931 rm -rf conftest*
12908 eval "ac_cv_header_$ac_safe=yes" 12932 eval "ac_cv_header_$ac_safe=yes"
12909 else 12933 else
12931 done 12955 done
12932 12956
12933 12957
12934 12958
12935 echo $ac_n "checking for kvm_read in -lkvm""... $ac_c" 1>&6 12959 echo $ac_n "checking for kvm_read in -lkvm""... $ac_c" 1>&6
12936 echo "configure:12937: checking for kvm_read in -lkvm" >&5 12960 echo "configure:12961: checking for kvm_read in -lkvm" >&5
12937 ac_lib_var=`echo kvm'_'kvm_read | sed 'y%./+-%__p_%'` 12961 ac_lib_var=`echo kvm'_'kvm_read | sed 'y%./+-%__p_%'`
12938 12962
12939 xe_check_libs=" -lkvm " 12963 xe_check_libs=" -lkvm "
12940 cat > conftest.$ac_ext <<EOF 12964 cat > conftest.$ac_ext <<EOF
12941 #line 12942 "configure" 12965 #line 12966 "configure"
12942 #include "confdefs.h" 12966 #include "confdefs.h"
12943 /* Override any gcc2 internal prototype to avoid an error. */ 12967 /* Override any gcc2 internal prototype to avoid an error. */
12944 /* We use char because int might match the return type of a gcc2 12968 /* We use char because int might match the return type of a gcc2
12945 builtin and then its argument prototype would still apply. */ 12969 builtin and then its argument prototype would still apply. */
12946 char kvm_read(); 12970 char kvm_read();
12947 12971
12948 int main() { 12972 int main() {
12949 kvm_read() 12973 kvm_read()
12950 ; return 0; } 12974 ; return 0; }
12951 EOF 12975 EOF
12952 if { (eval echo configure:12953: \"$ac_link\") 1>&5; (eval $ac_link) 2>&5; } && test -s conftest${ac_exeext}; then 12976 if { (eval echo configure:12977: \"$ac_link\") 1>&5; (eval $ac_link) 2>&5; } && test -s conftest${ac_exeext}; then
12953 rm -rf conftest* 12977 rm -rf conftest*
12954 eval "ac_cv_lib_$ac_lib_var=yes" 12978 eval "ac_cv_lib_$ac_lib_var=yes"
12955 else 12979 else
12956 echo "configure: failed program was:" >&5 12980 echo "configure: failed program was:" >&5
12957 cat conftest.$ac_ext >&5 12981 cat conftest.$ac_ext >&5
12981 13005
12982 13006
12983 fi 13007 fi
12984 13008
12985 echo $ac_n "checking whether netdb declares h_errno""... $ac_c" 1>&6 13009 echo $ac_n "checking whether netdb declares h_errno""... $ac_c" 1>&6
12986 echo "configure:12987: checking whether netdb declares h_errno" >&5 13010 echo "configure:13011: checking whether netdb declares h_errno" >&5
12987 cat > conftest.$ac_ext <<EOF 13011 cat > conftest.$ac_ext <<EOF
12988 #line 12989 "configure" 13012 #line 13013 "configure"
12989 #include "confdefs.h" 13013 #include "confdefs.h"
12990 #include <netdb.h> 13014 #include <netdb.h>
12991 int main() { 13015 int main() {
12992 return h_errno; 13016 return h_errno;
12993 ; return 0; } 13017 ; return 0; }
12994 EOF 13018 EOF
12995 if { (eval echo configure:12996: \"$ac_link\") 1>&5; (eval $ac_link) 2>&5; } && test -s conftest${ac_exeext}; then 13019 if { (eval echo configure:13020: \"$ac_link\") 1>&5; (eval $ac_link) 2>&5; } && test -s conftest${ac_exeext}; then
12996 rm -rf conftest* 13020 rm -rf conftest*
12997 echo "$ac_t""yes" 1>&6 13021 echo "$ac_t""yes" 1>&6
12998 { test "$extra_verbose" = "yes" && cat << \EOF 13022 { test "$extra_verbose" = "yes" && cat << \EOF
12999 Defining HAVE_H_ERRNO 13023 Defining HAVE_H_ERRNO
13000 EOF 13024 EOF
13010 echo "$ac_t""no" 1>&6 13034 echo "$ac_t""no" 1>&6
13011 fi 13035 fi
13012 rm -f conftest* 13036 rm -f conftest*
13013 13037
13014 echo $ac_n "checking for sigsetjmp""... $ac_c" 1>&6 13038 echo $ac_n "checking for sigsetjmp""... $ac_c" 1>&6
13015 echo "configure:13016: checking for sigsetjmp" >&5 13039 echo "configure:13040: checking for sigsetjmp" >&5
13016 cat > conftest.$ac_ext <<EOF 13040 cat > conftest.$ac_ext <<EOF
13017 #line 13018 "configure" 13041 #line 13042 "configure"
13018 #include "confdefs.h" 13042 #include "confdefs.h"
13019 #include <setjmp.h> 13043 #include <setjmp.h>
13020 int main() { 13044 int main() {
13021 sigjmp_buf bar; sigsetjmp (bar, 0); 13045 sigjmp_buf bar; sigsetjmp (bar, 0);
13022 ; return 0; } 13046 ; return 0; }
13023 EOF 13047 EOF
13024 if { (eval echo configure:13025: \"$ac_compile\") 1>&5; (eval $ac_compile) 2>&5; }; then 13048 if { (eval echo configure:13049: \"$ac_compile\") 1>&5; (eval $ac_compile) 2>&5; }; then
13025 rm -rf conftest* 13049 rm -rf conftest*
13026 echo "$ac_t""yes" 1>&6 13050 echo "$ac_t""yes" 1>&6
13027 { test "$extra_verbose" = "yes" && cat << \EOF 13051 { test "$extra_verbose" = "yes" && cat << \EOF
13028 Defining HAVE_SIGSETJMP 13052 Defining HAVE_SIGSETJMP
13029 EOF 13053 EOF
13039 echo "$ac_t""no" 1>&6 13063 echo "$ac_t""no" 1>&6
13040 fi 13064 fi
13041 rm -f conftest* 13065 rm -f conftest*
13042 13066
13043 echo $ac_n "checking whether localtime caches TZ""... $ac_c" 1>&6 13067 echo $ac_n "checking whether localtime caches TZ""... $ac_c" 1>&6
13044 echo "configure:13045: checking whether localtime caches TZ" >&5 13068 echo "configure:13069: checking whether localtime caches TZ" >&5
13045 13069
13046 if test "$ac_cv_func_tzset" = "yes"; then 13070 if test "$ac_cv_func_tzset" = "yes"; then
13047 cat > conftest.$ac_ext <<EOF 13071 cat > conftest.$ac_ext <<EOF
13048 #line 13049 "configure" 13072 #line 13073 "configure"
13049 #include "confdefs.h" 13073 #include "confdefs.h"
13050 #include <time.h> 13074 #include <time.h>
13051 #if STDC_HEADERS 13075 #if STDC_HEADERS
13052 # include <stdlib.h> 13076 # include <stdlib.h>
13053 #endif 13077 #endif
13078 if (localtime (&now)->tm_hour != hour_unset) 13102 if (localtime (&now)->tm_hour != hour_unset)
13079 exit (1); 13103 exit (1);
13080 exit (0); 13104 exit (0);
13081 } 13105 }
13082 EOF 13106 EOF
13083 if { (eval echo configure:13084: \"$ac_link\") 1>&5; (eval $ac_link) 2>&5; } && test -s conftest && (./conftest; exit $?) 2>&5 13107 if { (eval echo configure:13108: \"$ac_link\") 1>&5; (eval $ac_link) 2>&5; } && test -s conftest && (./conftest; exit $?) 2>&5
13084 then 13108 then
13085 emacs_cv_localtime_cache=no 13109 emacs_cv_localtime_cache=no
13086 else 13110 else
13087 conftest_rc="$?" 13111 conftest_rc="$?"
13088 echo "configure: failed program was:" >&5 13112 echo "configure: failed program was:" >&5
13108 13132
13109 fi 13133 fi
13110 13134
13111 if test "$HAVE_TIMEVAL" = "yes"; then 13135 if test "$HAVE_TIMEVAL" = "yes"; then
13112 echo $ac_n "checking whether gettimeofday accepts one or two arguments""... $ac_c" 1>&6 13136 echo $ac_n "checking whether gettimeofday accepts one or two arguments""... $ac_c" 1>&6
13113 echo "configure:13114: checking whether gettimeofday accepts one or two arguments" >&5 13137 echo "configure:13138: checking whether gettimeofday accepts one or two arguments" >&5
13114 cat > conftest.$ac_ext <<EOF 13138 cat > conftest.$ac_ext <<EOF
13115 #line 13116 "configure" 13139 #line 13140 "configure"
13116 #include "confdefs.h" 13140 #include "confdefs.h"
13117 13141
13118 #ifdef TIME_WITH_SYS_TIME 13142 #ifdef TIME_WITH_SYS_TIME
13119 #include <sys/time.h> 13143 #include <sys/time.h>
13120 #include <time.h> 13144 #include <time.h>
13131 struct timeval time; 13155 struct timeval time;
13132 gettimeofday (&time, 0); 13156 gettimeofday (&time, 0);
13133 13157
13134 ; return 0; } 13158 ; return 0; }
13135 EOF 13159 EOF
13136 if { (eval echo configure:13137: \"$ac_link\") 1>&5; (eval $ac_link) 2>&5; } && test -s conftest${ac_exeext}; then 13160 if { (eval echo configure:13161: \"$ac_link\") 1>&5; (eval $ac_link) 2>&5; } && test -s conftest${ac_exeext}; then
13137 rm -rf conftest* 13161 rm -rf conftest*
13138 echo "$ac_t""two" 1>&6 13162 echo "$ac_t""two" 1>&6
13139 else 13163 else
13140 echo "configure: failed program was:" >&5 13164 echo "configure: failed program was:" >&5
13141 cat conftest.$ac_ext >&5 13165 cat conftest.$ac_ext >&5
13153 rm -f conftest* 13177 rm -f conftest*
13154 fi 13178 fi
13155 13179
13156 13180
13157 echo $ac_n "checking for inline""... $ac_c" 1>&6 13181 echo $ac_n "checking for inline""... $ac_c" 1>&6
13158 echo "configure:13159: checking for inline" >&5 13182 echo "configure:13183: checking for inline" >&5
13159 13183
13160 ac_cv_c_inline=no 13184 ac_cv_c_inline=no
13161 for ac_kw in inline __inline__ __inline; do 13185 for ac_kw in inline __inline__ __inline; do
13162 cat > conftest.$ac_ext <<EOF 13186 cat > conftest.$ac_ext <<EOF
13163 #line 13164 "configure" 13187 #line 13188 "configure"
13164 #include "confdefs.h" 13188 #include "confdefs.h"
13165 13189
13166 int main() { 13190 int main() {
13167 } $ac_kw foo() { 13191 } $ac_kw foo() {
13168 ; return 0; } 13192 ; return 0; }
13169 EOF 13193 EOF
13170 if { (eval echo configure:13171: \"$ac_compile\") 1>&5; (eval $ac_compile) 2>&5; }; then 13194 if { (eval echo configure:13195: \"$ac_compile\") 1>&5; (eval $ac_compile) 2>&5; }; then
13171 rm -rf conftest* 13195 rm -rf conftest*
13172 ac_cv_c_inline=$ac_kw; break 13196 ac_cv_c_inline=$ac_kw; break
13173 else 13197 else
13174 echo "configure: failed program was:" >&5 13198 echo "configure: failed program was:" >&5
13175 cat conftest.$ac_ext >&5 13199 cat conftest.$ac_ext >&5
13202 test "$ac_cv_c_inline" != "no" -a "$GCC" = "yes" && extra_objs="$extra_objs inline.o" && if test "$extra_verbose" = "yes"; then 13226 test "$ac_cv_c_inline" != "no" -a "$GCC" = "yes" && extra_objs="$extra_objs inline.o" && if test "$extra_verbose" = "yes"; then
13203 echo " xemacs will be linked with \"inline.o\"" 13227 echo " xemacs will be linked with \"inline.o\""
13204 fi 13228 fi
13205 13229
13206 echo $ac_n "checking for typeof""... $ac_c" 1>&6 13230 echo $ac_n "checking for typeof""... $ac_c" 1>&6
13207 echo "configure:13208: checking for typeof" >&5 13231 echo "configure:13232: checking for typeof" >&5
13208 cat > conftest.$ac_ext <<EOF 13232 cat > conftest.$ac_ext <<EOF
13209 #line 13210 "configure" 13233 #line 13234 "configure"
13210 #include "confdefs.h" 13234 #include "confdefs.h"
13211 13235
13212 int main() { 13236 int main() {
13213 int i; __typeof__(i) j; 13237 int i; __typeof__(i) j;
13214 ; return 0; } 13238 ; return 0; }
13215 EOF 13239 EOF
13216 if { (eval echo configure:13217: \"$ac_compile\") 1>&5; (eval $ac_compile) 2>&5; }; then 13240 if { (eval echo configure:13241: \"$ac_compile\") 1>&5; (eval $ac_compile) 2>&5; }; then
13217 rm -rf conftest* 13241 rm -rf conftest*
13218 typeofname="__typeof__" 13242 typeofname="__typeof__"
13219 else 13243 else
13220 echo "configure: failed program was:" >&5 13244 echo "configure: failed program was:" >&5
13221 cat conftest.$ac_ext >&5 13245 cat conftest.$ac_ext >&5
13222 rm -rf conftest* 13246 rm -rf conftest*
13223 cat > conftest.$ac_ext <<EOF 13247 cat > conftest.$ac_ext <<EOF
13224 #line 13225 "configure" 13248 #line 13249 "configure"
13225 #include "confdefs.h" 13249 #include "confdefs.h"
13226 13250
13227 int main() { 13251 int main() {
13228 int i; typeof(i) j; 13252 int i; typeof(i) j;
13229 ; return 0; } 13253 ; return 0; }
13230 EOF 13254 EOF
13231 if { (eval echo configure:13232: \"$ac_compile\") 1>&5; (eval $ac_compile) 2>&5; }; then 13255 if { (eval echo configure:13256: \"$ac_compile\") 1>&5; (eval $ac_compile) 2>&5; }; then
13232 rm -rf conftest* 13256 rm -rf conftest*
13233 typeofname="typeof" 13257 typeofname="typeof"
13234 else 13258 else
13235 echo "configure: failed program was:" >&5 13259 echo "configure: failed program was:" >&5
13236 cat conftest.$ac_ext >&5 13260 cat conftest.$ac_ext >&5
13255 13279
13256 if test "$__DECC" != "yes"; then 13280 if test "$__DECC" != "yes"; then
13257 # The Ultrix 4.2 mips builtin alloca declared by alloca.h only works 13281 # The Ultrix 4.2 mips builtin alloca declared by alloca.h only works
13258 # for constant arguments. Useless! 13282 # for constant arguments. Useless!
13259 echo $ac_n "checking for working alloca.h""... $ac_c" 1>&6 13283 echo $ac_n "checking for working alloca.h""... $ac_c" 1>&6
13260 echo "configure:13261: checking for working alloca.h" >&5 13284 echo "configure:13285: checking for working alloca.h" >&5
13261 13285
13262 cat > conftest.$ac_ext <<EOF 13286 cat > conftest.$ac_ext <<EOF
13263 #line 13264 "configure" 13287 #line 13288 "configure"
13264 #include "confdefs.h" 13288 #include "confdefs.h"
13265 #include <alloca.h> 13289 #include <alloca.h>
13266 int main() { 13290 int main() {
13267 char *p = alloca(2 * sizeof(int)); 13291 char *p = alloca(2 * sizeof(int));
13268 ; return 0; } 13292 ; return 0; }
13269 EOF 13293 EOF
13270 if { (eval echo configure:13271: \"$ac_link\") 1>&5; (eval $ac_link) 2>&5; } && test -s conftest${ac_exeext}; then 13294 if { (eval echo configure:13295: \"$ac_link\") 1>&5; (eval $ac_link) 2>&5; } && test -s conftest${ac_exeext}; then
13271 rm -rf conftest* 13295 rm -rf conftest*
13272 ac_cv_header_alloca_h=yes 13296 ac_cv_header_alloca_h=yes
13273 else 13297 else
13274 echo "configure: failed program was:" >&5 13298 echo "configure: failed program was:" >&5
13275 cat conftest.$ac_ext >&5 13299 cat conftest.$ac_ext >&5
13289 } 13313 }
13290 13314
13291 fi 13315 fi
13292 13316
13293 echo $ac_n "checking for alloca""... $ac_c" 1>&6 13317 echo $ac_n "checking for alloca""... $ac_c" 1>&6
13294 echo "configure:13295: checking for alloca" >&5 13318 echo "configure:13319: checking for alloca" >&5
13295 13319
13296 cat > conftest.$ac_ext <<EOF 13320 cat > conftest.$ac_ext <<EOF
13297 #line 13298 "configure" 13321 #line 13322 "configure"
13298 #include "confdefs.h" 13322 #include "confdefs.h"
13299 13323
13300 #ifdef __GNUC__ 13324 #ifdef __GNUC__
13301 # define alloca __builtin_alloca 13325 # define alloca __builtin_alloca
13302 #else 13326 #else
13320 13344
13321 int main() { 13345 int main() {
13322 char *p = (char *) alloca(1); 13346 char *p = (char *) alloca(1);
13323 ; return 0; } 13347 ; return 0; }
13324 EOF 13348 EOF
13325 if { (eval echo configure:13326: \"$ac_link\") 1>&5; (eval $ac_link) 2>&5; } && test -s conftest${ac_exeext}; then 13349 if { (eval echo configure:13350: \"$ac_link\") 1>&5; (eval $ac_link) 2>&5; } && test -s conftest${ac_exeext}; then
13326 rm -rf conftest* 13350 rm -rf conftest*
13327 ac_cv_func_alloca_works=yes 13351 ac_cv_func_alloca_works=yes
13328 else 13352 else
13329 echo "configure: failed program was:" >&5 13353 echo "configure: failed program was:" >&5
13330 cat conftest.$ac_ext >&5 13354 cat conftest.$ac_ext >&5
13359 EOF 13383 EOF
13360 } 13384 }
13361 13385
13362 13386
13363 echo $ac_n "checking whether alloca needs Cray hooks""... $ac_c" 1>&6 13387 echo $ac_n "checking whether alloca needs Cray hooks""... $ac_c" 1>&6
13364 echo "configure:13365: checking whether alloca needs Cray hooks" >&5 13388 echo "configure:13389: checking whether alloca needs Cray hooks" >&5
13365 13389
13366 cat > conftest.$ac_ext <<EOF 13390 cat > conftest.$ac_ext <<EOF
13367 #line 13368 "configure" 13391 #line 13392 "configure"
13368 #include "confdefs.h" 13392 #include "confdefs.h"
13369 #if defined(CRAY) && ! defined(CRAY2) 13393 #if defined(CRAY) && ! defined(CRAY2)
13370 webecray 13394 webecray
13371 #else 13395 #else
13372 wenotbecray 13396 wenotbecray
13386 13410
13387 echo "$ac_t""$ac_cv_os_cray" 1>&6 13411 echo "$ac_t""$ac_cv_os_cray" 1>&6
13388 if test $ac_cv_os_cray = yes; then 13412 if test $ac_cv_os_cray = yes; then
13389 for ac_func in _getb67 GETB67 getb67; do 13413 for ac_func in _getb67 GETB67 getb67; do
13390 echo $ac_n "checking for $ac_func""... $ac_c" 1>&6 13414 echo $ac_n "checking for $ac_func""... $ac_c" 1>&6
13391 echo "configure:13392: checking for $ac_func" >&5 13415 echo "configure:13416: checking for $ac_func" >&5
13392 13416
13393 cat > conftest.$ac_ext <<EOF 13417 cat > conftest.$ac_ext <<EOF
13394 #line 13395 "configure" 13418 #line 13419 "configure"
13395 #include "confdefs.h" 13419 #include "confdefs.h"
13396 /* System header to define __stub macros and hopefully few prototypes, 13420 /* System header to define __stub macros and hopefully few prototypes,
13397 which can conflict with char $ac_func(); below. */ 13421 which can conflict with char $ac_func(); below. */
13398 #include <assert.h> 13422 #include <assert.h>
13399 /* Override any gcc2 internal prototype to avoid an error. */ 13423 /* Override any gcc2 internal prototype to avoid an error. */
13412 $ac_func(); 13436 $ac_func();
13413 #endif 13437 #endif
13414 13438
13415 ; return 0; } 13439 ; return 0; }
13416 EOF 13440 EOF
13417 if { (eval echo configure:13418: \"$ac_link\") 1>&5; (eval $ac_link) 2>&5; } && test -s conftest${ac_exeext}; then 13441 if { (eval echo configure:13442: \"$ac_link\") 1>&5; (eval $ac_link) 2>&5; } && test -s conftest${ac_exeext}; then
13418 rm -rf conftest* 13442 rm -rf conftest*
13419 eval "ac_cv_func_$ac_func=yes" 13443 eval "ac_cv_func_$ac_func=yes"
13420 else 13444 else
13421 echo "configure: failed program was:" >&5 13445 echo "configure: failed program was:" >&5
13422 cat conftest.$ac_ext >&5 13446 cat conftest.$ac_ext >&5
13442 13466
13443 done 13467 done
13444 fi 13468 fi
13445 13469
13446 echo $ac_n "checking stack direction for C alloca""... $ac_c" 1>&6 13470 echo $ac_n "checking stack direction for C alloca""... $ac_c" 1>&6
13447 echo "configure:13448: checking stack direction for C alloca" >&5 13471 echo "configure:13472: checking stack direction for C alloca" >&5
13448 13472
13449 cat > conftest.$ac_ext <<EOF 13473 cat > conftest.$ac_ext <<EOF
13450 #line 13451 "configure" 13474 #line 13475 "configure"
13451 #include "confdefs.h" 13475 #include "confdefs.h"
13452 find_stack_direction () 13476 find_stack_direction ()
13453 { 13477 {
13454 static char *addr = 0; 13478 static char *addr = 0;
13455 auto char dummy; 13479 auto char dummy;
13464 main () 13488 main ()
13465 { 13489 {
13466 exit (find_stack_direction() < 0); 13490 exit (find_stack_direction() < 0);
13467 } 13491 }
13468 EOF 13492 EOF
13469 if { (eval echo configure:13470: \"$ac_link\") 1>&5; (eval $ac_link) 2>&5; } && test -s conftest && (./conftest; exit $?) 2>&5 13493 if { (eval echo configure:13494: \"$ac_link\") 1>&5; (eval $ac_link) 2>&5; } && test -s conftest && (./conftest; exit $?) 2>&5
13470 then 13494 then
13471 ac_cv_c_stack_direction=1 13495 ac_cv_c_stack_direction=1
13472 else 13496 else
13473 conftest_rc="$?" 13497 conftest_rc="$?"
13474 echo "configure: failed program was:" >&5 13498 echo "configure: failed program was:" >&5
13493 echo " xemacs will be linked with \"$ALLOCA\"" 13517 echo " xemacs will be linked with \"$ALLOCA\""
13494 fi 13518 fi
13495 fi 13519 fi
13496 13520
13497 echo $ac_n "checking for working alloca in function calls""... $ac_c" 1>&6 13521 echo $ac_n "checking for working alloca in function calls""... $ac_c" 1>&6
13498 echo "configure:13499: checking for working alloca in function calls" >&5 13522 echo "configure:13523: checking for working alloca in function calls" >&5
13499 cat > conftest.$ac_ext <<EOF 13523 cat > conftest.$ac_ext <<EOF
13500 #line 13501 "configure" 13524 #line 13525 "configure"
13501 #include "confdefs.h" 13525 #include "confdefs.h"
13502 13526
13503 #if defined (__CYGWIN__) 13527 #if defined (__CYGWIN__)
13504 #include <alloca.h> 13528 #include <alloca.h>
13505 #elif defined (__GNUC__) 13529 #elif defined (__GNUC__)
13548 return 1; 13572 return 1;
13549 return 0; 13573 return 0;
13550 } 13574 }
13551 13575
13552 EOF 13576 EOF
13553 if { (eval echo configure:13554: \"$ac_link\") 1>&5; (eval $ac_link) 2>&5; } && test -s conftest && (./conftest; exit $?) 2>&5 13577 if { (eval echo configure:13578: \"$ac_link\") 1>&5; (eval $ac_link) 2>&5; } && test -s conftest && (./conftest; exit $?) 2>&5
13554 then 13578 then
13555 working_alloca_in_function_calls=yes 13579 working_alloca_in_function_calls=yes
13556 else 13580 else
13557 conftest_rc="$?" 13581 conftest_rc="$?"
13558 echo "configure: failed program was:" >&5 13582 echo "configure: failed program was:" >&5
13570 #define BROKEN_ALLOCA_IN_FUNCTION_CALLS 1 13594 #define BROKEN_ALLOCA_IN_FUNCTION_CALLS 1
13571 EOF 13595 EOF
13572 } 13596 }
13573 13597
13574 13598
13599 echo $ac_n "checking for working scanf""... $ac_c" 1>&6
13600 echo "configure:13601: checking for working scanf" >&5
13601 cat > conftest.$ac_ext <<EOF
13602 #line 13603 "configure"
13603 #include "confdefs.h"
13604
13605 int
13606 main (int argc, char **argv)
13607 {
13608 int ret, cp1, cp2, endcount;
13609 char *p = "0x7d 0x000E ";
13610 ret = sscanf (p, "%i %i%n", &cp1, &cp2, &endcount);
13611 /* endcount should be 13 but it's 11 in Cygwin newlib after 6/04;
13612 this breaks unicode.c */
13613 return endcount != 13;
13614 }
13615
13616 EOF
13617 if { (eval echo configure:13618: \"$ac_link\") 1>&5; (eval $ac_link) 2>&5; } && test -s conftest && (./conftest; exit $?) 2>&5
13618 then
13619 working_scanf=yes
13620 else
13621 conftest_rc="$?"
13622 echo "configure: failed program was:" >&5
13623 cat conftest.$ac_ext >&5
13624 rm -fr conftest*
13625 working_scanf=no
13626 fi
13627 rm -fr conftest*
13628 echo "$ac_t""$working_scanf" 1>&6
13629 test "$working_scanf" != "yes" && \
13630 { test "$extra_verbose" = "yes" && cat << \EOF
13631 Defining CYGWIN_SCANF_BUG
13632 EOF
13633 cat >> confdefs.h <<\EOF
13634 #define CYGWIN_SCANF_BUG 1
13635 EOF
13636 }
13637
13638
13575 echo $ac_n "checking for working strcoll""... $ac_c" 1>&6 13639 echo $ac_n "checking for working strcoll""... $ac_c" 1>&6
13576 echo "configure:13577: checking for working strcoll" >&5 13640 echo "configure:13641: checking for working strcoll" >&5
13577 13641
13578 cat > conftest.$ac_ext <<EOF 13642 cat > conftest.$ac_ext <<EOF
13579 #line 13580 "configure" 13643 #line 13644 "configure"
13580 #include "confdefs.h" 13644 #include "confdefs.h"
13581 #include <string.h> 13645 #include <string.h>
13582 main () 13646 main ()
13583 { 13647 {
13584 exit (strcoll ("abc", "def") >= 0 || 13648 exit (strcoll ("abc", "def") >= 0 ||
13585 strcoll ("ABC", "DEF") >= 0 || 13649 strcoll ("ABC", "DEF") >= 0 ||
13586 strcoll ("123", "456") >= 0); 13650 strcoll ("123", "456") >= 0);
13587 } 13651 }
13588 EOF 13652 EOF
13589 if { (eval echo configure:13590: \"$ac_link\") 1>&5; (eval $ac_link) 2>&5; } && test -s conftest && (./conftest; exit $?) 2>&5 13653 if { (eval echo configure:13654: \"$ac_link\") 1>&5; (eval $ac_link) 2>&5; } && test -s conftest && (./conftest; exit $?) 2>&5
13590 then 13654 then
13591 ac_cv_func_strcoll_works=yes 13655 ac_cv_func_strcoll_works=yes
13592 else 13656 else
13593 conftest_rc="$?" 13657 conftest_rc="$?"
13594 echo "configure: failed program was:" >&5 13658 echo "configure: failed program was:" >&5
13612 13676
13613 13677
13614 for ac_func in getpgrp 13678 for ac_func in getpgrp
13615 do 13679 do
13616 echo $ac_n "checking for $ac_func""... $ac_c" 1>&6 13680 echo $ac_n "checking for $ac_func""... $ac_c" 1>&6
13617 echo "configure:13618: checking for $ac_func" >&5 13681 echo "configure:13682: checking for $ac_func" >&5
13618 13682
13619 cat > conftest.$ac_ext <<EOF 13683 cat > conftest.$ac_ext <<EOF
13620 #line 13621 "configure" 13684 #line 13685 "configure"
13621 #include "confdefs.h" 13685 #include "confdefs.h"
13622 /* System header to define __stub macros and hopefully few prototypes, 13686 /* System header to define __stub macros and hopefully few prototypes,
13623 which can conflict with char $ac_func(); below. */ 13687 which can conflict with char $ac_func(); below. */
13624 #include <assert.h> 13688 #include <assert.h>
13625 /* Override any gcc2 internal prototype to avoid an error. */ 13689 /* Override any gcc2 internal prototype to avoid an error. */
13638 $ac_func(); 13702 $ac_func();
13639 #endif 13703 #endif
13640 13704
13641 ; return 0; } 13705 ; return 0; }
13642 EOF 13706 EOF
13643 if { (eval echo configure:13644: \"$ac_link\") 1>&5; (eval $ac_link) 2>&5; } && test -s conftest${ac_exeext}; then 13707 if { (eval echo configure:13708: \"$ac_link\") 1>&5; (eval $ac_link) 2>&5; } && test -s conftest${ac_exeext}; then
13644 rm -rf conftest* 13708 rm -rf conftest*
13645 eval "ac_cv_func_$ac_func=yes" 13709 eval "ac_cv_func_$ac_func=yes"
13646 else 13710 else
13647 echo "configure: failed program was:" >&5 13711 echo "configure: failed program was:" >&5
13648 cat conftest.$ac_ext >&5 13712 cat conftest.$ac_ext >&5
13666 echo "$ac_t""no" 1>&6 13730 echo "$ac_t""no" 1>&6
13667 fi 13731 fi
13668 done 13732 done
13669 13733
13670 echo $ac_n "checking whether getpgrp takes no argument""... $ac_c" 1>&6 13734 echo $ac_n "checking whether getpgrp takes no argument""... $ac_c" 1>&6
13671 echo "configure:13672: checking whether getpgrp takes no argument" >&5 13735 echo "configure:13736: checking whether getpgrp takes no argument" >&5
13672 13736
13673 cat > conftest.$ac_ext <<EOF 13737 cat > conftest.$ac_ext <<EOF
13674 #line 13675 "configure" 13738 #line 13739 "configure"
13675 #include "confdefs.h" 13739 #include "confdefs.h"
13676 13740
13677 /* 13741 /*
13678 * If this system has a BSD-style getpgrp(), 13742 * If this system has a BSD-style getpgrp(),
13679 * which takes a pid argument, exit unsuccessfully. 13743 * which takes a pid argument, exit unsuccessfully.
13724 exit(s>>8); 13788 exit(s>>8);
13725 } 13789 }
13726 } 13790 }
13727 13791
13728 EOF 13792 EOF
13729 if { (eval echo configure:13730: \"$ac_link\") 1>&5; (eval $ac_link) 2>&5; } && test -s conftest && (./conftest; exit $?) 2>&5 13793 if { (eval echo configure:13794: \"$ac_link\") 1>&5; (eval $ac_link) 2>&5; } && test -s conftest && (./conftest; exit $?) 2>&5
13730 then 13794 then
13731 ac_cv_func_getpgrp_void=yes 13795 ac_cv_func_getpgrp_void=yes
13732 else 13796 else
13733 conftest_rc="$?" 13797 conftest_rc="$?"
13734 echo "configure: failed program was:" >&5 13798 echo "configure: failed program was:" >&5
13751 13815
13752 fi 13816 fi
13753 13817
13754 13818
13755 echo $ac_n "checking for working mmap""... $ac_c" 1>&6 13819 echo $ac_n "checking for working mmap""... $ac_c" 1>&6
13756 echo "configure:13757: checking for working mmap" >&5 13820 echo "configure:13821: checking for working mmap" >&5
13757 case "$opsys" in ultrix* ) have_mmap=no ;; *) 13821 case "$opsys" in ultrix* ) have_mmap=no ;; *)
13758 cat > conftest.$ac_ext <<EOF 13822 cat > conftest.$ac_ext <<EOF
13759 #line 13760 "configure" 13823 #line 13824 "configure"
13760 #include "confdefs.h" 13824 #include "confdefs.h"
13761 #include <stdio.h> 13825 #include <stdio.h>
13762 #include <unistd.h> 13826 #include <unistd.h>
13763 #include <fcntl.h> 13827 #include <fcntl.h>
13764 #include <sys/mman.h> 13828 #include <sys/mman.h>
13787 return 0; 13851 return 0;
13788 perror ("conftest: mmap failed"); 13852 perror ("conftest: mmap failed");
13789 return 1; 13853 return 1;
13790 } 13854 }
13791 EOF 13855 EOF
13792 if { (eval echo configure:13793: \"$ac_link\") 1>&5; (eval $ac_link) 2>&5; } && test -s conftest && (./conftest; exit $?) 2>&5 13856 if { (eval echo configure:13857: \"$ac_link\") 1>&5; (eval $ac_link) 2>&5; } && test -s conftest && (./conftest; exit $?) 2>&5
13793 then 13857 then
13794 have_mmap=yes 13858 have_mmap=yes
13795 else 13859 else
13796 conftest_rc="$?" 13860 conftest_rc="$?"
13797 echo "configure: failed program was:" >&5 13861 echo "configure: failed program was:" >&5
13816 esac 13880 esac
13817 test "$GNU_MALLOC" != "yes" -a "$have_mmap" != "yes" && rel_alloc=no 13881 test "$GNU_MALLOC" != "yes" -a "$have_mmap" != "yes" && rel_alloc=no
13818 if test "$rel_alloc $have_mmap" = "default yes"; then 13882 if test "$rel_alloc $have_mmap" = "default yes"; then
13819 if test "$doug_lea_malloc" = "yes"; then 13883 if test "$doug_lea_malloc" = "yes"; then
13820 echo $ac_n "checking for M_MMAP_THRESHOLD""... $ac_c" 1>&6 13884 echo $ac_n "checking for M_MMAP_THRESHOLD""... $ac_c" 1>&6
13821 echo "configure:13822: checking for M_MMAP_THRESHOLD" >&5 13885 echo "configure:13886: checking for M_MMAP_THRESHOLD" >&5
13822 cat > conftest.$ac_ext <<EOF 13886 cat > conftest.$ac_ext <<EOF
13823 #line 13824 "configure" 13887 #line 13888 "configure"
13824 #include "confdefs.h" 13888 #include "confdefs.h"
13825 #include <malloc.h> 13889 #include <malloc.h>
13826 int main() { 13890 int main() {
13827 13891
13828 #ifndef M_MMAP_THRESHOLD 13892 #ifndef M_MMAP_THRESHOLD
13830 !@+$%^&*_)(_ - unlikely to compile... 13894 !@+$%^&*_)(_ - unlikely to compile...
13831 #endif 13895 #endif
13832 13896
13833 ; return 0; } 13897 ; return 0; }
13834 EOF 13898 EOF
13835 if { (eval echo configure:13836: \"$ac_compile\") 1>&5; (eval $ac_compile) 2>&5; }; then 13899 if { (eval echo configure:13900: \"$ac_compile\") 1>&5; (eval $ac_compile) 2>&5; }; then
13836 rm -rf conftest* 13900 rm -rf conftest*
13837 rel_alloc=no; echo "$ac_t""yes" 1>&6; 13901 rel_alloc=no; echo "$ac_t""yes" 1>&6;
13838 else 13902 else
13839 echo "configure: failed program was:" >&5 13903 echo "configure: failed program was:" >&5
13840 cat conftest.$ac_ext >&5 13904 cat conftest.$ac_ext >&5
13855 } 13919 }
13856 13920
13857 13921
13858 ac_safe=`echo "termios.h" | sed 'y%./+-%__p_%'` 13922 ac_safe=`echo "termios.h" | sed 'y%./+-%__p_%'`
13859 echo $ac_n "checking for termios.h""... $ac_c" 1>&6 13923 echo $ac_n "checking for termios.h""... $ac_c" 1>&6
13860 echo "configure:13861: checking for termios.h" >&5 13924 echo "configure:13925: checking for termios.h" >&5
13861 13925
13862 cat > conftest.$ac_ext <<EOF 13926 cat > conftest.$ac_ext <<EOF
13863 #line 13864 "configure" 13927 #line 13928 "configure"
13864 #include "confdefs.h" 13928 #include "confdefs.h"
13865 #include <termios.h> 13929 #include <termios.h>
13866 EOF 13930 EOF
13867 ac_try="$ac_cpp conftest.$ac_ext >/dev/null 2>conftest.out" 13931 ac_try="$ac_cpp conftest.$ac_ext >/dev/null 2>conftest.out"
13868 { (eval echo configure:13869: \"$ac_try\") 1>&5; (eval $ac_try) 2>&5; } 13932 { (eval echo configure:13933: \"$ac_try\") 1>&5; (eval $ac_try) 2>&5; }
13869 ac_err=`grep -v '^ *+' conftest.out | grep -v "^conftest.${ac_ext}\$"` 13933 ac_err=`grep -v '^ *+' conftest.out | grep -v "^conftest.${ac_ext}\$"`
13870 if test -z "$ac_err"; then 13934 if test -z "$ac_err"; then
13871 rm -rf conftest* 13935 rm -rf conftest*
13872 eval "ac_cv_header_$ac_safe=yes" 13936 eval "ac_cv_header_$ac_safe=yes"
13873 else 13937 else
13906 13970
13907 else 13971 else
13908 echo "$ac_t""no" 1>&6 13972 echo "$ac_t""no" 1>&6
13909 ac_safe=`echo "termio.h" | sed 'y%./+-%__p_%'` 13973 ac_safe=`echo "termio.h" | sed 'y%./+-%__p_%'`
13910 echo $ac_n "checking for termio.h""... $ac_c" 1>&6 13974 echo $ac_n "checking for termio.h""... $ac_c" 1>&6
13911 echo "configure:13912: checking for termio.h" >&5 13975 echo "configure:13976: checking for termio.h" >&5
13912 13976
13913 cat > conftest.$ac_ext <<EOF 13977 cat > conftest.$ac_ext <<EOF
13914 #line 13915 "configure" 13978 #line 13979 "configure"
13915 #include "confdefs.h" 13979 #include "confdefs.h"
13916 #include <termio.h> 13980 #include <termio.h>
13917 EOF 13981 EOF
13918 ac_try="$ac_cpp conftest.$ac_ext >/dev/null 2>conftest.out" 13982 ac_try="$ac_cpp conftest.$ac_ext >/dev/null 2>conftest.out"
13919 { (eval echo configure:13920: \"$ac_try\") 1>&5; (eval $ac_try) 2>&5; } 13983 { (eval echo configure:13984: \"$ac_try\") 1>&5; (eval $ac_try) 2>&5; }
13920 ac_err=`grep -v '^ *+' conftest.out | grep -v "^conftest.${ac_ext}\$"` 13984 ac_err=`grep -v '^ *+' conftest.out | grep -v "^conftest.${ac_ext}\$"`
13921 if test -z "$ac_err"; then 13985 if test -z "$ac_err"; then
13922 rm -rf conftest* 13986 rm -rf conftest*
13923 eval "ac_cv_header_$ac_safe=yes" 13987 eval "ac_cv_header_$ac_safe=yes"
13924 else 13988 else
13946 fi 14010 fi
13947 14011
13948 14012
13949 14013
13950 echo $ac_n "checking for socket""... $ac_c" 1>&6 14014 echo $ac_n "checking for socket""... $ac_c" 1>&6
13951 echo "configure:13952: checking for socket" >&5 14015 echo "configure:14016: checking for socket" >&5
13952 14016
13953 cat > conftest.$ac_ext <<EOF 14017 cat > conftest.$ac_ext <<EOF
13954 #line 13955 "configure" 14018 #line 14019 "configure"
13955 #include "confdefs.h" 14019 #include "confdefs.h"
13956 /* System header to define __stub macros and hopefully few prototypes, 14020 /* System header to define __stub macros and hopefully few prototypes,
13957 which can conflict with char socket(); below. */ 14021 which can conflict with char socket(); below. */
13958 #include <assert.h> 14022 #include <assert.h>
13959 /* Override any gcc2 internal prototype to avoid an error. */ 14023 /* Override any gcc2 internal prototype to avoid an error. */
13972 socket(); 14036 socket();
13973 #endif 14037 #endif
13974 14038
13975 ; return 0; } 14039 ; return 0; }
13976 EOF 14040 EOF
13977 if { (eval echo configure:13978: \"$ac_link\") 1>&5; (eval $ac_link) 2>&5; } && test -s conftest${ac_exeext}; then 14041 if { (eval echo configure:14042: \"$ac_link\") 1>&5; (eval $ac_link) 2>&5; } && test -s conftest${ac_exeext}; then
13978 rm -rf conftest* 14042 rm -rf conftest*
13979 eval "ac_cv_func_socket=yes" 14043 eval "ac_cv_func_socket=yes"
13980 else 14044 else
13981 echo "configure: failed program was:" >&5 14045 echo "configure: failed program was:" >&5
13982 cat conftest.$ac_ext >&5 14046 cat conftest.$ac_ext >&5
13987 14051
13988 if eval "test \"`echo '$ac_cv_func_'socket`\" = yes"; then 14052 if eval "test \"`echo '$ac_cv_func_'socket`\" = yes"; then
13989 echo "$ac_t""yes" 1>&6 14053 echo "$ac_t""yes" 1>&6
13990 ac_safe=`echo "netinet/in.h" | sed 'y%./+-%__p_%'` 14054 ac_safe=`echo "netinet/in.h" | sed 'y%./+-%__p_%'`
13991 echo $ac_n "checking for netinet/in.h""... $ac_c" 1>&6 14055 echo $ac_n "checking for netinet/in.h""... $ac_c" 1>&6
13992 echo "configure:13993: checking for netinet/in.h" >&5 14056 echo "configure:14057: checking for netinet/in.h" >&5
13993 14057
13994 cat > conftest.$ac_ext <<EOF 14058 cat > conftest.$ac_ext <<EOF
13995 #line 13996 "configure" 14059 #line 14060 "configure"
13996 #include "confdefs.h" 14060 #include "confdefs.h"
13997 #include <netinet/in.h> 14061 #include <netinet/in.h>
13998 EOF 14062 EOF
13999 ac_try="$ac_cpp conftest.$ac_ext >/dev/null 2>conftest.out" 14063 ac_try="$ac_cpp conftest.$ac_ext >/dev/null 2>conftest.out"
14000 { (eval echo configure:14001: \"$ac_try\") 1>&5; (eval $ac_try) 2>&5; } 14064 { (eval echo configure:14065: \"$ac_try\") 1>&5; (eval $ac_try) 2>&5; }
14001 ac_err=`grep -v '^ *+' conftest.out | grep -v "^conftest.${ac_ext}\$"` 14065 ac_err=`grep -v '^ *+' conftest.out | grep -v "^conftest.${ac_ext}\$"`
14002 if test -z "$ac_err"; then 14066 if test -z "$ac_err"; then
14003 rm -rf conftest* 14067 rm -rf conftest*
14004 eval "ac_cv_header_$ac_safe=yes" 14068 eval "ac_cv_header_$ac_safe=yes"
14005 else 14069 else
14012 rm -f conftest* 14076 rm -f conftest*
14013 if eval "test \"`echo '$ac_cv_header_'$ac_safe`\" = yes"; then 14077 if eval "test \"`echo '$ac_cv_header_'$ac_safe`\" = yes"; then
14014 echo "$ac_t""yes" 1>&6 14078 echo "$ac_t""yes" 1>&6
14015 ac_safe=`echo "arpa/inet.h" | sed 'y%./+-%__p_%'` 14079 ac_safe=`echo "arpa/inet.h" | sed 'y%./+-%__p_%'`
14016 echo $ac_n "checking for arpa/inet.h""... $ac_c" 1>&6 14080 echo $ac_n "checking for arpa/inet.h""... $ac_c" 1>&6
14017 echo "configure:14018: checking for arpa/inet.h" >&5 14081 echo "configure:14082: checking for arpa/inet.h" >&5
14018 14082
14019 cat > conftest.$ac_ext <<EOF 14083 cat > conftest.$ac_ext <<EOF
14020 #line 14021 "configure" 14084 #line 14085 "configure"
14021 #include "confdefs.h" 14085 #include "confdefs.h"
14022 #include <arpa/inet.h> 14086 #include <arpa/inet.h>
14023 EOF 14087 EOF
14024 ac_try="$ac_cpp conftest.$ac_ext >/dev/null 2>conftest.out" 14088 ac_try="$ac_cpp conftest.$ac_ext >/dev/null 2>conftest.out"
14025 { (eval echo configure:14026: \"$ac_try\") 1>&5; (eval $ac_try) 2>&5; } 14089 { (eval echo configure:14090: \"$ac_try\") 1>&5; (eval $ac_try) 2>&5; }
14026 ac_err=`grep -v '^ *+' conftest.out | grep -v "^conftest.${ac_ext}\$"` 14090 ac_err=`grep -v '^ *+' conftest.out | grep -v "^conftest.${ac_ext}\$"`
14027 if test -z "$ac_err"; then 14091 if test -z "$ac_err"; then
14028 rm -rf conftest* 14092 rm -rf conftest*
14029 eval "ac_cv_header_$ac_safe=yes" 14093 eval "ac_cv_header_$ac_safe=yes"
14030 else 14094 else
14045 #define HAVE_SOCKETS 1 14109 #define HAVE_SOCKETS 1
14046 EOF 14110 EOF
14047 } 14111 }
14048 14112
14049 echo $ac_n "checking "for sun_len member in struct sockaddr_un"""... $ac_c" 1>&6 14113 echo $ac_n "checking "for sun_len member in struct sockaddr_un"""... $ac_c" 1>&6
14050 echo "configure:14051: checking "for sun_len member in struct sockaddr_un"" >&5 14114 echo "configure:14115: checking "for sun_len member in struct sockaddr_un"" >&5
14051 cat > conftest.$ac_ext <<EOF 14115 cat > conftest.$ac_ext <<EOF
14052 #line 14053 "configure" 14116 #line 14117 "configure"
14053 #include "confdefs.h" 14117 #include "confdefs.h"
14054 14118
14055 #include <sys/types.h> 14119 #include <sys/types.h>
14056 #include <sys/socket.h> 14120 #include <sys/socket.h>
14057 #include <sys/un.h> 14121 #include <sys/un.h>
14058 14122
14059 int main() { 14123 int main() {
14060 static struct sockaddr_un x; x.sun_len = 1; 14124 static struct sockaddr_un x; x.sun_len = 1;
14061 ; return 0; } 14125 ; return 0; }
14062 EOF 14126 EOF
14063 if { (eval echo configure:14064: \"$ac_link\") 1>&5; (eval $ac_link) 2>&5; } && test -s conftest${ac_exeext}; then 14127 if { (eval echo configure:14128: \"$ac_link\") 1>&5; (eval $ac_link) 2>&5; } && test -s conftest${ac_exeext}; then
14064 rm -rf conftest* 14128 rm -rf conftest*
14065 echo "$ac_t""yes" 1>&6; { test "$extra_verbose" = "yes" && cat << \EOF 14129 echo "$ac_t""yes" 1>&6; { test "$extra_verbose" = "yes" && cat << \EOF
14066 Defining HAVE_SOCKADDR_SUN_LEN 14130 Defining HAVE_SOCKADDR_SUN_LEN
14067 EOF 14131 EOF
14068 cat >> confdefs.h <<\EOF 14132 cat >> confdefs.h <<\EOF
14076 rm -rf conftest* 14140 rm -rf conftest*
14077 echo "$ac_t""no" 1>&6 14141 echo "$ac_t""no" 1>&6
14078 fi 14142 fi
14079 rm -f conftest* 14143 rm -f conftest*
14080 echo $ac_n "checking "for ip_mreq struct in netinet/in.h"""... $ac_c" 1>&6 14144 echo $ac_n "checking "for ip_mreq struct in netinet/in.h"""... $ac_c" 1>&6
14081 echo "configure:14082: checking "for ip_mreq struct in netinet/in.h"" >&5 14145 echo "configure:14146: checking "for ip_mreq struct in netinet/in.h"" >&5
14082 cat > conftest.$ac_ext <<EOF 14146 cat > conftest.$ac_ext <<EOF
14083 #line 14084 "configure" 14147 #line 14148 "configure"
14084 #include "confdefs.h" 14148 #include "confdefs.h"
14085 14149
14086 #include <sys/types.h> 14150 #include <sys/types.h>
14087 #include <netinet/in.h> 14151 #include <netinet/in.h>
14088 14152
14089 int main() { 14153 int main() {
14090 static struct ip_mreq x; 14154 static struct ip_mreq x;
14091 ; return 0; } 14155 ; return 0; }
14092 EOF 14156 EOF
14093 if { (eval echo configure:14094: \"$ac_link\") 1>&5; (eval $ac_link) 2>&5; } && test -s conftest${ac_exeext}; then 14157 if { (eval echo configure:14158: \"$ac_link\") 1>&5; (eval $ac_link) 2>&5; } && test -s conftest${ac_exeext}; then
14094 rm -rf conftest* 14158 rm -rf conftest*
14095 echo "$ac_t""yes" 1>&6; { test "$extra_verbose" = "yes" && cat << \EOF 14159 echo "$ac_t""yes" 1>&6; { test "$extra_verbose" = "yes" && cat << \EOF
14096 Defining HAVE_MULTICAST 14160 Defining HAVE_MULTICAST
14097 EOF 14161 EOF
14098 cat >> confdefs.h <<\EOF 14162 cat >> confdefs.h <<\EOF
14119 echo "$ac_t""no" 1>&6 14183 echo "$ac_t""no" 1>&6
14120 fi 14184 fi
14121 14185
14122 14186
14123 echo $ac_n "checking for msgget""... $ac_c" 1>&6 14187 echo $ac_n "checking for msgget""... $ac_c" 1>&6
14124 echo "configure:14125: checking for msgget" >&5 14188 echo "configure:14189: checking for msgget" >&5
14125 14189
14126 cat > conftest.$ac_ext <<EOF 14190 cat > conftest.$ac_ext <<EOF
14127 #line 14128 "configure" 14191 #line 14192 "configure"
14128 #include "confdefs.h" 14192 #include "confdefs.h"
14129 /* System header to define __stub macros and hopefully few prototypes, 14193 /* System header to define __stub macros and hopefully few prototypes,
14130 which can conflict with char msgget(); below. */ 14194 which can conflict with char msgget(); below. */
14131 #include <assert.h> 14195 #include <assert.h>
14132 /* Override any gcc2 internal prototype to avoid an error. */ 14196 /* Override any gcc2 internal prototype to avoid an error. */
14145 msgget(); 14209 msgget();
14146 #endif 14210 #endif
14147 14211
14148 ; return 0; } 14212 ; return 0; }
14149 EOF 14213 EOF
14150 if { (eval echo configure:14151: \"$ac_link\") 1>&5; (eval $ac_link) 2>&5; } && test -s conftest${ac_exeext}; then 14214 if { (eval echo configure:14215: \"$ac_link\") 1>&5; (eval $ac_link) 2>&5; } && test -s conftest${ac_exeext}; then
14151 rm -rf conftest* 14215 rm -rf conftest*
14152 eval "ac_cv_func_msgget=yes" 14216 eval "ac_cv_func_msgget=yes"
14153 else 14217 else
14154 echo "configure: failed program was:" >&5 14218 echo "configure: failed program was:" >&5
14155 cat conftest.$ac_ext >&5 14219 cat conftest.$ac_ext >&5
14160 14224
14161 if eval "test \"`echo '$ac_cv_func_'msgget`\" = yes"; then 14225 if eval "test \"`echo '$ac_cv_func_'msgget`\" = yes"; then
14162 echo "$ac_t""yes" 1>&6 14226 echo "$ac_t""yes" 1>&6
14163 ac_safe=`echo "sys/ipc.h" | sed 'y%./+-%__p_%'` 14227 ac_safe=`echo "sys/ipc.h" | sed 'y%./+-%__p_%'`
14164 echo $ac_n "checking for sys/ipc.h""... $ac_c" 1>&6 14228 echo $ac_n "checking for sys/ipc.h""... $ac_c" 1>&6
14165 echo "configure:14166: checking for sys/ipc.h" >&5 14229 echo "configure:14230: checking for sys/ipc.h" >&5
14166 14230
14167 cat > conftest.$ac_ext <<EOF 14231 cat > conftest.$ac_ext <<EOF
14168 #line 14169 "configure" 14232 #line 14233 "configure"
14169 #include "confdefs.h" 14233 #include "confdefs.h"
14170 #include <sys/ipc.h> 14234 #include <sys/ipc.h>
14171 EOF 14235 EOF
14172 ac_try="$ac_cpp conftest.$ac_ext >/dev/null 2>conftest.out" 14236 ac_try="$ac_cpp conftest.$ac_ext >/dev/null 2>conftest.out"
14173 { (eval echo configure:14174: \"$ac_try\") 1>&5; (eval $ac_try) 2>&5; } 14237 { (eval echo configure:14238: \"$ac_try\") 1>&5; (eval $ac_try) 2>&5; }
14174 ac_err=`grep -v '^ *+' conftest.out | grep -v "^conftest.${ac_ext}\$"` 14238 ac_err=`grep -v '^ *+' conftest.out | grep -v "^conftest.${ac_ext}\$"`
14175 if test -z "$ac_err"; then 14239 if test -z "$ac_err"; then
14176 rm -rf conftest* 14240 rm -rf conftest*
14177 eval "ac_cv_header_$ac_safe=yes" 14241 eval "ac_cv_header_$ac_safe=yes"
14178 else 14242 else
14185 rm -f conftest* 14249 rm -f conftest*
14186 if eval "test \"`echo '$ac_cv_header_'$ac_safe`\" = yes"; then 14250 if eval "test \"`echo '$ac_cv_header_'$ac_safe`\" = yes"; then
14187 echo "$ac_t""yes" 1>&6 14251 echo "$ac_t""yes" 1>&6
14188 ac_safe=`echo "sys/msg.h" | sed 'y%./+-%__p_%'` 14252 ac_safe=`echo "sys/msg.h" | sed 'y%./+-%__p_%'`
14189 echo $ac_n "checking for sys/msg.h""... $ac_c" 1>&6 14253 echo $ac_n "checking for sys/msg.h""... $ac_c" 1>&6
14190 echo "configure:14191: checking for sys/msg.h" >&5 14254 echo "configure:14255: checking for sys/msg.h" >&5
14191 14255
14192 cat > conftest.$ac_ext <<EOF 14256 cat > conftest.$ac_ext <<EOF
14193 #line 14194 "configure" 14257 #line 14258 "configure"
14194 #include "confdefs.h" 14258 #include "confdefs.h"
14195 #include <sys/msg.h> 14259 #include <sys/msg.h>
14196 EOF 14260 EOF
14197 ac_try="$ac_cpp conftest.$ac_ext >/dev/null 2>conftest.out" 14261 ac_try="$ac_cpp conftest.$ac_ext >/dev/null 2>conftest.out"
14198 { (eval echo configure:14199: \"$ac_try\") 1>&5; (eval $ac_try) 2>&5; } 14262 { (eval echo configure:14263: \"$ac_try\") 1>&5; (eval $ac_try) 2>&5; }
14199 ac_err=`grep -v '^ *+' conftest.out | grep -v "^conftest.${ac_ext}\$"` 14263 ac_err=`grep -v '^ *+' conftest.out | grep -v "^conftest.${ac_ext}\$"`
14200 if test -z "$ac_err"; then 14264 if test -z "$ac_err"; then
14201 rm -rf conftest* 14265 rm -rf conftest*
14202 eval "ac_cv_header_$ac_safe=yes" 14266 eval "ac_cv_header_$ac_safe=yes"
14203 else 14267 else
14231 fi 14295 fi
14232 14296
14233 14297
14234 ac_safe=`echo "dirent.h" | sed 'y%./+-%__p_%'` 14298 ac_safe=`echo "dirent.h" | sed 'y%./+-%__p_%'`
14235 echo $ac_n "checking for dirent.h""... $ac_c" 1>&6 14299 echo $ac_n "checking for dirent.h""... $ac_c" 1>&6
14236 echo "configure:14237: checking for dirent.h" >&5 14300 echo "configure:14301: checking for dirent.h" >&5
14237 14301
14238 cat > conftest.$ac_ext <<EOF 14302 cat > conftest.$ac_ext <<EOF
14239 #line 14240 "configure" 14303 #line 14304 "configure"
14240 #include "confdefs.h" 14304 #include "confdefs.h"
14241 #include <dirent.h> 14305 #include <dirent.h>
14242 EOF 14306 EOF
14243 ac_try="$ac_cpp conftest.$ac_ext >/dev/null 2>conftest.out" 14307 ac_try="$ac_cpp conftest.$ac_ext >/dev/null 2>conftest.out"
14244 { (eval echo configure:14245: \"$ac_try\") 1>&5; (eval $ac_try) 2>&5; } 14308 { (eval echo configure:14309: \"$ac_try\") 1>&5; (eval $ac_try) 2>&5; }
14245 ac_err=`grep -v '^ *+' conftest.out | grep -v "^conftest.${ac_ext}\$"` 14309 ac_err=`grep -v '^ *+' conftest.out | grep -v "^conftest.${ac_ext}\$"`
14246 if test -z "$ac_err"; then 14310 if test -z "$ac_err"; then
14247 rm -rf conftest* 14311 rm -rf conftest*
14248 eval "ac_cv_header_$ac_safe=yes" 14312 eval "ac_cv_header_$ac_safe=yes"
14249 else 14313 else
14266 14330
14267 else 14331 else
14268 echo "$ac_t""no" 1>&6 14332 echo "$ac_t""no" 1>&6
14269 ac_safe=`echo "sys/dir.h" | sed 'y%./+-%__p_%'` 14333 ac_safe=`echo "sys/dir.h" | sed 'y%./+-%__p_%'`
14270 echo $ac_n "checking for sys/dir.h""... $ac_c" 1>&6 14334 echo $ac_n "checking for sys/dir.h""... $ac_c" 1>&6
14271 echo "configure:14272: checking for sys/dir.h" >&5 14335 echo "configure:14336: checking for sys/dir.h" >&5
14272 14336
14273 cat > conftest.$ac_ext <<EOF 14337 cat > conftest.$ac_ext <<EOF
14274 #line 14275 "configure" 14338 #line 14339 "configure"
14275 #include "confdefs.h" 14339 #include "confdefs.h"
14276 #include <sys/dir.h> 14340 #include <sys/dir.h>
14277 EOF 14341 EOF
14278 ac_try="$ac_cpp conftest.$ac_ext >/dev/null 2>conftest.out" 14342 ac_try="$ac_cpp conftest.$ac_ext >/dev/null 2>conftest.out"
14279 { (eval echo configure:14280: \"$ac_try\") 1>&5; (eval $ac_try) 2>&5; } 14343 { (eval echo configure:14344: \"$ac_try\") 1>&5; (eval $ac_try) 2>&5; }
14280 ac_err=`grep -v '^ *+' conftest.out | grep -v "^conftest.${ac_ext}\$"` 14344 ac_err=`grep -v '^ *+' conftest.out | grep -v "^conftest.${ac_ext}\$"`
14281 if test -z "$ac_err"; then 14345 if test -z "$ac_err"; then
14282 rm -rf conftest* 14346 rm -rf conftest*
14283 eval "ac_cv_header_$ac_safe=yes" 14347 eval "ac_cv_header_$ac_safe=yes"
14284 else 14348 else
14307 fi 14371 fi
14308 14372
14309 14373
14310 ac_safe=`echo "nlist.h" | sed 'y%./+-%__p_%'` 14374 ac_safe=`echo "nlist.h" | sed 'y%./+-%__p_%'`
14311 echo $ac_n "checking for nlist.h""... $ac_c" 1>&6 14375 echo $ac_n "checking for nlist.h""... $ac_c" 1>&6
14312 echo "configure:14313: checking for nlist.h" >&5 14376 echo "configure:14377: checking for nlist.h" >&5
14313 14377
14314 cat > conftest.$ac_ext <<EOF 14378 cat > conftest.$ac_ext <<EOF
14315 #line 14316 "configure" 14379 #line 14380 "configure"
14316 #include "confdefs.h" 14380 #include "confdefs.h"
14317 #include <nlist.h> 14381 #include <nlist.h>
14318 EOF 14382 EOF
14319 ac_try="$ac_cpp conftest.$ac_ext >/dev/null 2>conftest.out" 14383 ac_try="$ac_cpp conftest.$ac_ext >/dev/null 2>conftest.out"
14320 { (eval echo configure:14321: \"$ac_try\") 1>&5; (eval $ac_try) 2>&5; } 14384 { (eval echo configure:14385: \"$ac_try\") 1>&5; (eval $ac_try) 2>&5; }
14321 ac_err=`grep -v '^ *+' conftest.out | grep -v "^conftest.${ac_ext}\$"` 14385 ac_err=`grep -v '^ *+' conftest.out | grep -v "^conftest.${ac_ext}\$"`
14322 if test -z "$ac_err"; then 14386 if test -z "$ac_err"; then
14323 rm -rf conftest* 14387 rm -rf conftest*
14324 eval "ac_cv_header_$ac_safe=yes" 14388 eval "ac_cv_header_$ac_safe=yes"
14325 else 14389 else
14345 fi 14409 fi
14346 14410
14347 14411
14348 14412
14349 echo "checking "for sound support"" 1>&6 14413 echo "checking "for sound support"" 1>&6
14350 echo "configure:14351: checking "for sound support"" >&5 14414 echo "configure:14415: checking "for sound support"" >&5
14351 test -z "$with_native_sound" -a -n "$native_sound_lib" && with_native_sound=yes 14415 test -z "$with_native_sound" -a -n "$native_sound_lib" && with_native_sound=yes
14352 14416
14353 if test "$with_native_sound" != "no"; then 14417 if test "$with_native_sound" != "no"; then
14354 if test -n "$native_sound_lib"; then 14418 if test -n "$native_sound_lib"; then
14355 ac_safe=`echo "multimedia/audio_device.h" | sed 'y%./+-%__p_%'` 14419 ac_safe=`echo "multimedia/audio_device.h" | sed 'y%./+-%__p_%'`
14356 echo $ac_n "checking for multimedia/audio_device.h""... $ac_c" 1>&6 14420 echo $ac_n "checking for multimedia/audio_device.h""... $ac_c" 1>&6
14357 echo "configure:14358: checking for multimedia/audio_device.h" >&5 14421 echo "configure:14422: checking for multimedia/audio_device.h" >&5
14358 14422
14359 cat > conftest.$ac_ext <<EOF 14423 cat > conftest.$ac_ext <<EOF
14360 #line 14361 "configure" 14424 #line 14425 "configure"
14361 #include "confdefs.h" 14425 #include "confdefs.h"
14362 #include <multimedia/audio_device.h> 14426 #include <multimedia/audio_device.h>
14363 EOF 14427 EOF
14364 ac_try="$ac_cpp conftest.$ac_ext >/dev/null 2>conftest.out" 14428 ac_try="$ac_cpp conftest.$ac_ext >/dev/null 2>conftest.out"
14365 { (eval echo configure:14366: \"$ac_try\") 1>&5; (eval $ac_try) 2>&5; } 14429 { (eval echo configure:14430: \"$ac_try\") 1>&5; (eval $ac_try) 2>&5; }
14366 ac_err=`grep -v '^ *+' conftest.out | grep -v "^conftest.${ac_ext}\$"` 14430 ac_err=`grep -v '^ *+' conftest.out | grep -v "^conftest.${ac_ext}\$"`
14367 if test -z "$ac_err"; then 14431 if test -z "$ac_err"; then
14368 rm -rf conftest* 14432 rm -rf conftest*
14369 eval "ac_cv_header_$ac_safe=yes" 14433 eval "ac_cv_header_$ac_safe=yes"
14370 else 14434 else
14416 case "$canonical" in 14480 case "$canonical" in
14417 *-sgi-* ) 14481 *-sgi-* )
14418 if test -z "$native_sound_lib"; then 14482 if test -z "$native_sound_lib"; then
14419 14483
14420 echo $ac_n "checking for ALopenport in -laudio""... $ac_c" 1>&6 14484 echo $ac_n "checking for ALopenport in -laudio""... $ac_c" 1>&6
14421 echo "configure:14422: checking for ALopenport in -laudio" >&5 14485 echo "configure:14486: checking for ALopenport in -laudio" >&5
14422 ac_lib_var=`echo audio'_'ALopenport | sed 'y%./+-%__p_%'` 14486 ac_lib_var=`echo audio'_'ALopenport | sed 'y%./+-%__p_%'`
14423 14487
14424 xe_check_libs=" -laudio " 14488 xe_check_libs=" -laudio "
14425 cat > conftest.$ac_ext <<EOF 14489 cat > conftest.$ac_ext <<EOF
14426 #line 14427 "configure" 14490 #line 14491 "configure"
14427 #include "confdefs.h" 14491 #include "confdefs.h"
14428 /* Override any gcc2 internal prototype to avoid an error. */ 14492 /* Override any gcc2 internal prototype to avoid an error. */
14429 /* We use char because int might match the return type of a gcc2 14493 /* We use char because int might match the return type of a gcc2
14430 builtin and then its argument prototype would still apply. */ 14494 builtin and then its argument prototype would still apply. */
14431 char ALopenport(); 14495 char ALopenport();
14432 14496
14433 int main() { 14497 int main() {
14434 ALopenport() 14498 ALopenport()
14435 ; return 0; } 14499 ; return 0; }
14436 EOF 14500 EOF
14437 if { (eval echo configure:14438: \"$ac_link\") 1>&5; (eval $ac_link) 2>&5; } && test -s conftest${ac_exeext}; then 14501 if { (eval echo configure:14502: \"$ac_link\") 1>&5; (eval $ac_link) 2>&5; } && test -s conftest${ac_exeext}; then
14438 rm -rf conftest* 14502 rm -rf conftest*
14439 eval "ac_cv_lib_$ac_lib_var=yes" 14503 eval "ac_cv_lib_$ac_lib_var=yes"
14440 else 14504 else
14441 echo "configure: failed program was:" >&5 14505 echo "configure: failed program was:" >&5
14442 cat conftest.$ac_ext >&5 14506 cat conftest.$ac_ext >&5
14463 fi ;; 14527 fi ;;
14464 hppa*-hp-hpux* ) 14528 hppa*-hp-hpux* )
14465 if test -z "$native_sound_lib"; then 14529 if test -z "$native_sound_lib"; then
14466 14530
14467 echo $ac_n "checking for AOpenAudio in -lAlib""... $ac_c" 1>&6 14531 echo $ac_n "checking for AOpenAudio in -lAlib""... $ac_c" 1>&6
14468 echo "configure:14469: checking for AOpenAudio in -lAlib" >&5 14532 echo "configure:14533: checking for AOpenAudio in -lAlib" >&5
14469 ac_lib_var=`echo Alib'_'AOpenAudio | sed 'y%./+-%__p_%'` 14533 ac_lib_var=`echo Alib'_'AOpenAudio | sed 'y%./+-%__p_%'`
14470 14534
14471 xe_check_libs=" -lAlib " 14535 xe_check_libs=" -lAlib "
14472 cat > conftest.$ac_ext <<EOF 14536 cat > conftest.$ac_ext <<EOF
14473 #line 14474 "configure" 14537 #line 14538 "configure"
14474 #include "confdefs.h" 14538 #include "confdefs.h"
14475 /* Override any gcc2 internal prototype to avoid an error. */ 14539 /* Override any gcc2 internal prototype to avoid an error. */
14476 /* We use char because int might match the return type of a gcc2 14540 /* We use char because int might match the return type of a gcc2
14477 builtin and then its argument prototype would still apply. */ 14541 builtin and then its argument prototype would still apply. */
14478 char AOpenAudio(); 14542 char AOpenAudio();
14479 14543
14480 int main() { 14544 int main() {
14481 AOpenAudio() 14545 AOpenAudio()
14482 ; return 0; } 14546 ; return 0; }
14483 EOF 14547 EOF
14484 if { (eval echo configure:14485: \"$ac_link\") 1>&5; (eval $ac_link) 2>&5; } && test -s conftest${ac_exeext}; then 14548 if { (eval echo configure:14549: \"$ac_link\") 1>&5; (eval $ac_link) 2>&5; } && test -s conftest${ac_exeext}; then
14485 rm -rf conftest* 14549 rm -rf conftest*
14486 eval "ac_cv_lib_$ac_lib_var=yes" 14550 eval "ac_cv_lib_$ac_lib_var=yes"
14487 else 14551 else
14488 echo "configure: failed program was:" >&5 14552 echo "configure: failed program was:" >&5
14489 cat conftest.$ac_ext >&5 14553 cat conftest.$ac_ext >&5
14527 14591
14528 if test -z "$sound_found"; then 14592 if test -z "$sound_found"; then
14529 for dir in "machine" "sys" "linux"; do 14593 for dir in "machine" "sys" "linux"; do
14530 ac_safe=`echo "${dir}/soundcard.h" | sed 'y%./+-%__p_%'` 14594 ac_safe=`echo "${dir}/soundcard.h" | sed 'y%./+-%__p_%'`
14531 echo $ac_n "checking for ${dir}/soundcard.h""... $ac_c" 1>&6 14595 echo $ac_n "checking for ${dir}/soundcard.h""... $ac_c" 1>&6
14532 echo "configure:14533: checking for ${dir}/soundcard.h" >&5 14596 echo "configure:14597: checking for ${dir}/soundcard.h" >&5
14533 14597
14534 cat > conftest.$ac_ext <<EOF 14598 cat > conftest.$ac_ext <<EOF
14535 #line 14536 "configure" 14599 #line 14600 "configure"
14536 #include "confdefs.h" 14600 #include "confdefs.h"
14537 #include <${dir}/soundcard.h> 14601 #include <${dir}/soundcard.h>
14538 EOF 14602 EOF
14539 ac_try="$ac_cpp conftest.$ac_ext >/dev/null 2>conftest.out" 14603 ac_try="$ac_cpp conftest.$ac_ext >/dev/null 2>conftest.out"
14540 { (eval echo configure:14541: \"$ac_try\") 1>&5; (eval $ac_try) 2>&5; } 14604 { (eval echo configure:14605: \"$ac_try\") 1>&5; (eval $ac_try) 2>&5; }
14541 ac_err=`grep -v '^ *+' conftest.out | grep -v "^conftest.${ac_ext}\$"` 14605 ac_err=`grep -v '^ *+' conftest.out | grep -v "^conftest.${ac_ext}\$"`
14542 if test -z "$ac_err"; then 14606 if test -z "$ac_err"; then
14543 rm -rf conftest* 14607 rm -rf conftest*
14544 eval "ac_cv_header_$ac_safe=yes" 14608 eval "ac_cv_header_$ac_safe=yes"
14545 else 14609 else
14589 fi 14653 fi
14590 14654
14591 if test "$with_nas_sound" != "no"; then 14655 if test "$with_nas_sound" != "no"; then
14592 ac_safe=`echo "audio/audiolib.h" | sed 'y%./+-%__p_%'` 14656 ac_safe=`echo "audio/audiolib.h" | sed 'y%./+-%__p_%'`
14593 echo $ac_n "checking for audio/audiolib.h""... $ac_c" 1>&6 14657 echo $ac_n "checking for audio/audiolib.h""... $ac_c" 1>&6
14594 echo "configure:14595: checking for audio/audiolib.h" >&5 14658 echo "configure:14659: checking for audio/audiolib.h" >&5
14595 14659
14596 cat > conftest.$ac_ext <<EOF 14660 cat > conftest.$ac_ext <<EOF
14597 #line 14598 "configure" 14661 #line 14662 "configure"
14598 #include "confdefs.h" 14662 #include "confdefs.h"
14599 #include <audio/audiolib.h> 14663 #include <audio/audiolib.h>
14600 EOF 14664 EOF
14601 ac_try="$ac_cpp conftest.$ac_ext >/dev/null 2>conftest.out" 14665 ac_try="$ac_cpp conftest.$ac_ext >/dev/null 2>conftest.out"
14602 { (eval echo configure:14603: \"$ac_try\") 1>&5; (eval $ac_try) 2>&5; } 14666 { (eval echo configure:14667: \"$ac_try\") 1>&5; (eval $ac_try) 2>&5; }
14603 ac_err=`grep -v '^ *+' conftest.out | grep -v "^conftest.${ac_ext}\$"` 14667 ac_err=`grep -v '^ *+' conftest.out | grep -v "^conftest.${ac_ext}\$"`
14604 if test -z "$ac_err"; then 14668 if test -z "$ac_err"; then
14605 rm -rf conftest* 14669 rm -rf conftest*
14606 eval "ac_cv_header_$ac_safe=yes" 14670 eval "ac_cv_header_$ac_safe=yes"
14607 else 14671 else
14615 if eval "test \"`echo '$ac_cv_header_'$ac_safe`\" = yes"; then 14679 if eval "test \"`echo '$ac_cv_header_'$ac_safe`\" = yes"; then
14616 echo "$ac_t""yes" 1>&6 14680 echo "$ac_t""yes" 1>&6
14617 14681
14618 14682
14619 echo $ac_n "checking for AuOpenServer in -laudio""... $ac_c" 1>&6 14683 echo $ac_n "checking for AuOpenServer in -laudio""... $ac_c" 1>&6
14620 echo "configure:14621: checking for AuOpenServer in -laudio" >&5 14684 echo "configure:14685: checking for AuOpenServer in -laudio" >&5
14621 ac_lib_var=`echo audio'_'AuOpenServer | sed 'y%./+-%__p_%'` 14685 ac_lib_var=`echo audio'_'AuOpenServer | sed 'y%./+-%__p_%'`
14622 14686
14623 xe_check_libs=" -laudio " 14687 xe_check_libs=" -laudio "
14624 cat > conftest.$ac_ext <<EOF 14688 cat > conftest.$ac_ext <<EOF
14625 #line 14626 "configure" 14689 #line 14690 "configure"
14626 #include "confdefs.h" 14690 #include "confdefs.h"
14627 /* Override any gcc2 internal prototype to avoid an error. */ 14691 /* Override any gcc2 internal prototype to avoid an error. */
14628 /* We use char because int might match the return type of a gcc2 14692 /* We use char because int might match the return type of a gcc2
14629 builtin and then its argument prototype would still apply. */ 14693 builtin and then its argument prototype would still apply. */
14630 char AuOpenServer(); 14694 char AuOpenServer();
14631 14695
14632 int main() { 14696 int main() {
14633 AuOpenServer() 14697 AuOpenServer()
14634 ; return 0; } 14698 ; return 0; }
14635 EOF 14699 EOF
14636 if { (eval echo configure:14637: \"$ac_link\") 1>&5; (eval $ac_link) 2>&5; } && test -s conftest${ac_exeext}; then 14700 if { (eval echo configure:14701: \"$ac_link\") 1>&5; (eval $ac_link) 2>&5; } && test -s conftest${ac_exeext}; then
14637 rm -rf conftest* 14701 rm -rf conftest*
14638 eval "ac_cv_lib_$ac_lib_var=yes" 14702 eval "ac_cv_lib_$ac_lib_var=yes"
14639 else 14703 else
14640 echo "configure: failed program was:" >&5 14704 echo "configure: failed program was:" >&5
14641 cat conftest.$ac_ext >&5 14705 cat conftest.$ac_ext >&5
14670 extra_objs="$extra_objs nas.o" && if test "$extra_verbose" = "yes"; then 14734 extra_objs="$extra_objs nas.o" && if test "$extra_verbose" = "yes"; then
14671 echo " xemacs will be linked with \"nas.o\"" 14735 echo " xemacs will be linked with \"nas.o\""
14672 fi 14736 fi
14673 libs_x="-laudio $libs_x" && if test "$extra_verbose" = "yes"; then echo " Prepending \"-laudio\" to \$libs_x"; fi 14737 libs_x="-laudio $libs_x" && if test "$extra_verbose" = "yes"; then echo " Prepending \"-laudio\" to \$libs_x"; fi
14674 cat > conftest.$ac_ext <<EOF 14738 cat > conftest.$ac_ext <<EOF
14675 #line 14676 "configure" 14739 #line 14740 "configure"
14676 #include "confdefs.h" 14740 #include "confdefs.h"
14677 #include <audio/Xtutil.h> 14741 #include <audio/Xtutil.h>
14678 EOF 14742 EOF
14679 if (eval "$ac_cpp conftest.$ac_ext") 2>&5 | 14743 if (eval "$ac_cpp conftest.$ac_ext") 2>&5 |
14680 egrep "AuXtErrorJump" >/dev/null 2>&1; then 14744 egrep "AuXtErrorJump" >/dev/null 2>&1; then
14701 14765
14702 if test "$with_esd_sound" != "no"; then 14766 if test "$with_esd_sound" != "no"; then
14703 # Extract the first word of "esd-config", so it can be a program name with args. 14767 # Extract the first word of "esd-config", so it can be a program name with args.
14704 set dummy esd-config; ac_word=$2 14768 set dummy esd-config; ac_word=$2
14705 echo $ac_n "checking for $ac_word""... $ac_c" 1>&6 14769 echo $ac_n "checking for $ac_word""... $ac_c" 1>&6
14706 echo "configure:14707: checking for $ac_word" >&5 14770 echo "configure:14771: checking for $ac_word" >&5
14707 14771
14708 if test -n "$have_esd_config"; then 14772 if test -n "$have_esd_config"; then
14709 ac_cv_prog_have_esd_config="$have_esd_config" # Let the user override the test. 14773 ac_cv_prog_have_esd_config="$have_esd_config" # Let the user override the test.
14710 else 14774 else
14711 IFS="${IFS= }"; ac_save_ifs="$IFS"; IFS=":" 14775 IFS="${IFS= }"; ac_save_ifs="$IFS"; IFS=":"
14730 if test "$have_esd_config" = "yes"; then 14794 if test "$have_esd_config" = "yes"; then
14731 save_c_switch_site="$c_switch_site" save_LIBS="$LIBS" 14795 save_c_switch_site="$c_switch_site" save_LIBS="$LIBS"
14732 c_switch_site="$c_switch_site `esd-config --cflags`" && if test "$extra_verbose" = "yes"; then echo " Appending \"`esd-config --cflags`\" to \$c_switch_site"; fi 14796 c_switch_site="$c_switch_site `esd-config --cflags`" && if test "$extra_verbose" = "yes"; then echo " Appending \"`esd-config --cflags`\" to \$c_switch_site"; fi
14733 LIBS="`esd-config --libs` $LIBS" && if test "$extra_verbose" = "yes"; then echo " Prepending \"`esd-config --libs`\" to \$LIBS"; fi 14797 LIBS="`esd-config --libs` $LIBS" && if test "$extra_verbose" = "yes"; then echo " Prepending \"`esd-config --libs`\" to \$LIBS"; fi
14734 echo $ac_n "checking for esd_play_stream""... $ac_c" 1>&6 14798 echo $ac_n "checking for esd_play_stream""... $ac_c" 1>&6
14735 echo "configure:14736: checking for esd_play_stream" >&5 14799 echo "configure:14800: checking for esd_play_stream" >&5
14736 14800
14737 cat > conftest.$ac_ext <<EOF 14801 cat > conftest.$ac_ext <<EOF
14738 #line 14739 "configure" 14802 #line 14803 "configure"
14739 #include "confdefs.h" 14803 #include "confdefs.h"
14740 /* System header to define __stub macros and hopefully few prototypes, 14804 /* System header to define __stub macros and hopefully few prototypes,
14741 which can conflict with char esd_play_stream(); below. */ 14805 which can conflict with char esd_play_stream(); below. */
14742 #include <assert.h> 14806 #include <assert.h>
14743 /* Override any gcc2 internal prototype to avoid an error. */ 14807 /* Override any gcc2 internal prototype to avoid an error. */
14756 esd_play_stream(); 14820 esd_play_stream();
14757 #endif 14821 #endif
14758 14822
14759 ; return 0; } 14823 ; return 0; }
14760 EOF 14824 EOF
14761 if { (eval echo configure:14762: \"$ac_link\") 1>&5; (eval $ac_link) 2>&5; } && test -s conftest${ac_exeext}; then 14825 if { (eval echo configure:14826: \"$ac_link\") 1>&5; (eval $ac_link) 2>&5; } && test -s conftest${ac_exeext}; then
14762 rm -rf conftest* 14826 rm -rf conftest*
14763 eval "ac_cv_func_esd_play_stream=yes" 14827 eval "ac_cv_func_esd_play_stream=yes"
14764 else 14828 else
14765 echo "configure: failed program was:" >&5 14829 echo "configure: failed program was:" >&5
14766 cat conftest.$ac_ext >&5 14830 cat conftest.$ac_ext >&5
14807 14871
14808 test -z "$with_tty" && with_tty=yes 14872 test -z "$with_tty" && with_tty=yes
14809 14873
14810 if test "$with_tty" = "yes" ; then 14874 if test "$with_tty" = "yes" ; then
14811 echo "checking for TTY-related features" 1>&6 14875 echo "checking for TTY-related features" 1>&6
14812 echo "configure:14813: checking for TTY-related features" >&5 14876 echo "configure:14877: checking for TTY-related features" >&5
14813 { test "$extra_verbose" = "yes" && cat << \EOF 14877 { test "$extra_verbose" = "yes" && cat << \EOF
14814 Defining HAVE_TTY 14878 Defining HAVE_TTY
14815 EOF 14879 EOF
14816 cat >> confdefs.h <<\EOF 14880 cat >> confdefs.h <<\EOF
14817 #define HAVE_TTY 1 14881 #define HAVE_TTY 1
14820 14884
14821 14885
14822 if test -z "$with_ncurses"; then 14886 if test -z "$with_ncurses"; then
14823 14887
14824 echo $ac_n "checking for tgetent in -lncurses""... $ac_c" 1>&6 14888 echo $ac_n "checking for tgetent in -lncurses""... $ac_c" 1>&6
14825 echo "configure:14826: checking for tgetent in -lncurses" >&5 14889 echo "configure:14890: checking for tgetent in -lncurses" >&5
14826 ac_lib_var=`echo ncurses'_'tgetent | sed 'y%./+-%__p_%'` 14890 ac_lib_var=`echo ncurses'_'tgetent | sed 'y%./+-%__p_%'`
14827 14891
14828 xe_check_libs=" -lncurses " 14892 xe_check_libs=" -lncurses "
14829 cat > conftest.$ac_ext <<EOF 14893 cat > conftest.$ac_ext <<EOF
14830 #line 14831 "configure" 14894 #line 14895 "configure"
14831 #include "confdefs.h" 14895 #include "confdefs.h"
14832 /* Override any gcc2 internal prototype to avoid an error. */ 14896 /* Override any gcc2 internal prototype to avoid an error. */
14833 /* We use char because int might match the return type of a gcc2 14897 /* We use char because int might match the return type of a gcc2
14834 builtin and then its argument prototype would still apply. */ 14898 builtin and then its argument prototype would still apply. */
14835 char tgetent(); 14899 char tgetent();
14836 14900
14837 int main() { 14901 int main() {
14838 tgetent() 14902 tgetent()
14839 ; return 0; } 14903 ; return 0; }
14840 EOF 14904 EOF
14841 if { (eval echo configure:14842: \"$ac_link\") 1>&5; (eval $ac_link) 2>&5; } && test -s conftest${ac_exeext}; then 14905 if { (eval echo configure:14906: \"$ac_link\") 1>&5; (eval $ac_link) 2>&5; } && test -s conftest${ac_exeext}; then
14842 rm -rf conftest* 14906 rm -rf conftest*
14843 eval "ac_cv_lib_$ac_lib_var=yes" 14907 eval "ac_cv_lib_$ac_lib_var=yes"
14844 else 14908 else
14845 echo "configure: failed program was:" >&5 14909 echo "configure: failed program was:" >&5
14846 cat conftest.$ac_ext >&5 14910 cat conftest.$ac_ext >&5
14869 EOF 14933 EOF
14870 } 14934 }
14871 14935
14872 ac_safe=`echo "ncurses/curses.h" | sed 'y%./+-%__p_%'` 14936 ac_safe=`echo "ncurses/curses.h" | sed 'y%./+-%__p_%'`
14873 echo $ac_n "checking for ncurses/curses.h""... $ac_c" 1>&6 14937 echo $ac_n "checking for ncurses/curses.h""... $ac_c" 1>&6
14874 echo "configure:14875: checking for ncurses/curses.h" >&5 14938 echo "configure:14939: checking for ncurses/curses.h" >&5
14875 14939
14876 cat > conftest.$ac_ext <<EOF 14940 cat > conftest.$ac_ext <<EOF
14877 #line 14878 "configure" 14941 #line 14942 "configure"
14878 #include "confdefs.h" 14942 #include "confdefs.h"
14879 #include <ncurses/curses.h> 14943 #include <ncurses/curses.h>
14880 EOF 14944 EOF
14881 ac_try="$ac_cpp conftest.$ac_ext >/dev/null 2>conftest.out" 14945 ac_try="$ac_cpp conftest.$ac_ext >/dev/null 2>conftest.out"
14882 { (eval echo configure:14883: \"$ac_try\") 1>&5; (eval $ac_try) 2>&5; } 14946 { (eval echo configure:14947: \"$ac_try\") 1>&5; (eval $ac_try) 2>&5; }
14883 ac_err=`grep -v '^ *+' conftest.out | grep -v "^conftest.${ac_ext}\$"` 14947 ac_err=`grep -v '^ *+' conftest.out | grep -v "^conftest.${ac_ext}\$"`
14884 if test -z "$ac_err"; then 14948 if test -z "$ac_err"; then
14885 rm -rf conftest* 14949 rm -rf conftest*
14886 eval "ac_cv_header_$ac_safe=yes" 14950 eval "ac_cv_header_$ac_safe=yes"
14887 else 14951 else
14899 echo "$ac_t""no" 1>&6 14963 echo "$ac_t""no" 1>&6
14900 fi 14964 fi
14901 14965
14902 ac_safe=`echo "ncurses/term.h" | sed 'y%./+-%__p_%'` 14966 ac_safe=`echo "ncurses/term.h" | sed 'y%./+-%__p_%'`
14903 echo $ac_n "checking for ncurses/term.h""... $ac_c" 1>&6 14967 echo $ac_n "checking for ncurses/term.h""... $ac_c" 1>&6
14904 echo "configure:14905: checking for ncurses/term.h" >&5 14968 echo "configure:14969: checking for ncurses/term.h" >&5
14905 14969
14906 cat > conftest.$ac_ext <<EOF 14970 cat > conftest.$ac_ext <<EOF
14907 #line 14908 "configure" 14971 #line 14972 "configure"
14908 #include "confdefs.h" 14972 #include "confdefs.h"
14909 #include <ncurses/term.h> 14973 #include <ncurses/term.h>
14910 EOF 14974 EOF
14911 ac_try="$ac_cpp conftest.$ac_ext >/dev/null 2>conftest.out" 14975 ac_try="$ac_cpp conftest.$ac_ext >/dev/null 2>conftest.out"
14912 { (eval echo configure:14913: \"$ac_try\") 1>&5; (eval $ac_try) 2>&5; } 14976 { (eval echo configure:14977: \"$ac_try\") 1>&5; (eval $ac_try) 2>&5; }
14913 ac_err=`grep -v '^ *+' conftest.out | grep -v "^conftest.${ac_ext}\$"` 14977 ac_err=`grep -v '^ *+' conftest.out | grep -v "^conftest.${ac_ext}\$"`
14914 if test -z "$ac_err"; then 14978 if test -z "$ac_err"; then
14915 rm -rf conftest* 14979 rm -rf conftest*
14916 eval "ac_cv_header_$ac_safe=yes" 14980 eval "ac_cv_header_$ac_safe=yes"
14917 else 14981 else
14937 if test "$ac_cv_header_ncurses_curses_h" != "yes" ; then 15001 if test "$ac_cv_header_ncurses_curses_h" != "yes" ; then
14938 save_c_switch_site="$c_switch_site" 15002 save_c_switch_site="$c_switch_site"
14939 c_switch_site="$c_switch_site -I/usr/include/ncurses" 15003 c_switch_site="$c_switch_site -I/usr/include/ncurses"
14940 ac_safe=`echo "ncurses/curses.h" | sed 'y%./+-%__p_%'` 15004 ac_safe=`echo "ncurses/curses.h" | sed 'y%./+-%__p_%'`
14941 echo $ac_n "checking for ncurses/curses.h""... $ac_c" 1>&6 15005 echo $ac_n "checking for ncurses/curses.h""... $ac_c" 1>&6
14942 echo "configure:14943: checking for ncurses/curses.h" >&5 15006 echo "configure:15007: checking for ncurses/curses.h" >&5
14943 15007
14944 cat > conftest.$ac_ext <<EOF 15008 cat > conftest.$ac_ext <<EOF
14945 #line 14946 "configure" 15009 #line 15010 "configure"
14946 #include "confdefs.h" 15010 #include "confdefs.h"
14947 #include <ncurses/curses.h> 15011 #include <ncurses/curses.h>
14948 EOF 15012 EOF
14949 ac_try="$ac_cpp conftest.$ac_ext >/dev/null 2>conftest.out" 15013 ac_try="$ac_cpp conftest.$ac_ext >/dev/null 2>conftest.out"
14950 { (eval echo configure:14951: \"$ac_try\") 1>&5; (eval $ac_try) 2>&5; } 15014 { (eval echo configure:15015: \"$ac_try\") 1>&5; (eval $ac_try) 2>&5; }
14951 ac_err=`grep -v '^ *+' conftest.out | grep -v "^conftest.${ac_ext}\$"` 15015 ac_err=`grep -v '^ *+' conftest.out | grep -v "^conftest.${ac_ext}\$"`
14952 if test -z "$ac_err"; then 15016 if test -z "$ac_err"; then
14953 rm -rf conftest* 15017 rm -rf conftest*
14954 eval "ac_cv_header_$ac_safe=yes" 15018 eval "ac_cv_header_$ac_safe=yes"
14955 else 15019 else
14980 LIBS="$libs_termcap $LIBS" && if test "$extra_verbose" = "yes"; then echo " Prepending \"$libs_termcap\" to \$LIBS"; fi 15044 LIBS="$libs_termcap $LIBS" && if test "$extra_verbose" = "yes"; then echo " Prepending \"$libs_termcap\" to \$LIBS"; fi
14981 else 15045 else
14982 for lib in curses termlib termcap; do 15046 for lib in curses termlib termcap; do
14983 15047
14984 echo $ac_n "checking for tgetent in -l$lib""... $ac_c" 1>&6 15048 echo $ac_n "checking for tgetent in -l$lib""... $ac_c" 1>&6
14985 echo "configure:14986: checking for tgetent in -l$lib" >&5 15049 echo "configure:15050: checking for tgetent in -l$lib" >&5
14986 ac_lib_var=`echo $lib'_'tgetent | sed 'y%./+-%__p_%'` 15050 ac_lib_var=`echo $lib'_'tgetent | sed 'y%./+-%__p_%'`
14987 15051
14988 xe_check_libs=" -l$lib " 15052 xe_check_libs=" -l$lib "
14989 cat > conftest.$ac_ext <<EOF 15053 cat > conftest.$ac_ext <<EOF
14990 #line 14991 "configure" 15054 #line 15055 "configure"
14991 #include "confdefs.h" 15055 #include "confdefs.h"
14992 /* Override any gcc2 internal prototype to avoid an error. */ 15056 /* Override any gcc2 internal prototype to avoid an error. */
14993 /* We use char because int might match the return type of a gcc2 15057 /* We use char because int might match the return type of a gcc2
14994 builtin and then its argument prototype would still apply. */ 15058 builtin and then its argument prototype would still apply. */
14995 char tgetent(); 15059 char tgetent();
14996 15060
14997 int main() { 15061 int main() {
14998 tgetent() 15062 tgetent()
14999 ; return 0; } 15063 ; return 0; }
15000 EOF 15064 EOF
15001 if { (eval echo configure:15002: \"$ac_link\") 1>&5; (eval $ac_link) 2>&5; } && test -s conftest${ac_exeext}; then 15065 if { (eval echo configure:15066: \"$ac_link\") 1>&5; (eval $ac_link) 2>&5; } && test -s conftest${ac_exeext}; then
15002 rm -rf conftest* 15066 rm -rf conftest*
15003 eval "ac_cv_lib_$ac_lib_var=yes" 15067 eval "ac_cv_lib_$ac_lib_var=yes"
15004 else 15068 else
15005 echo "configure: failed program was:" >&5 15069 echo "configure: failed program was:" >&5
15006 cat conftest.$ac_ext >&5 15070 cat conftest.$ac_ext >&5
15027 if test -n "$libs_termcap"; then 15091 if test -n "$libs_termcap"; then
15028 LIBS="$libs_termcap $LIBS" && if test "$extra_verbose" = "yes"; then echo " Prepending \"$libs_termcap\" to \$LIBS"; fi 15092 LIBS="$libs_termcap $LIBS" && if test "$extra_verbose" = "yes"; then echo " Prepending \"$libs_termcap\" to \$LIBS"; fi
15029 else 15093 else
15030 15094
15031 echo $ac_n "checking for tgetent in -lcurses""... $ac_c" 1>&6 15095 echo $ac_n "checking for tgetent in -lcurses""... $ac_c" 1>&6
15032 echo "configure:15033: checking for tgetent in -lcurses" >&5 15096 echo "configure:15097: checking for tgetent in -lcurses" >&5
15033 ac_lib_var=`echo curses'_'tgetent | sed 'y%./+-%__p_%'` 15097 ac_lib_var=`echo curses'_'tgetent | sed 'y%./+-%__p_%'`
15034 15098
15035 xe_check_libs=" -lcurses " 15099 xe_check_libs=" -lcurses "
15036 cat > conftest.$ac_ext <<EOF 15100 cat > conftest.$ac_ext <<EOF
15037 #line 15038 "configure" 15101 #line 15102 "configure"
15038 #include "confdefs.h" 15102 #include "confdefs.h"
15039 /* Override any gcc2 internal prototype to avoid an error. */ 15103 /* Override any gcc2 internal prototype to avoid an error. */
15040 /* We use char because int might match the return type of a gcc2 15104 /* We use char because int might match the return type of a gcc2
15041 builtin and then its argument prototype would still apply. */ 15105 builtin and then its argument prototype would still apply. */
15042 char tgetent(); 15106 char tgetent();
15043 15107
15044 int main() { 15108 int main() {
15045 tgetent() 15109 tgetent()
15046 ; return 0; } 15110 ; return 0; }
15047 EOF 15111 EOF
15048 if { (eval echo configure:15049: \"$ac_link\") 1>&5; (eval $ac_link) 2>&5; } && test -s conftest${ac_exeext}; then 15112 if { (eval echo configure:15113: \"$ac_link\") 1>&5; (eval $ac_link) 2>&5; } && test -s conftest${ac_exeext}; then
15049 rm -rf conftest* 15113 rm -rf conftest*
15050 eval "ac_cv_lib_$ac_lib_var=yes" 15114 eval "ac_cv_lib_$ac_lib_var=yes"
15051 else 15115 else
15052 echo "configure: failed program was:" >&5 15116 echo "configure: failed program was:" >&5
15053 cat conftest.$ac_ext >&5 15117 cat conftest.$ac_ext >&5
15061 echo "$ac_t""yes" 1>&6 15125 echo "$ac_t""yes" 1>&6
15062 LIBS="-lcurses $LIBS" && if test "$extra_verbose" = "yes"; then echo " Prepending \"-lcurses\" to \$LIBS"; fi 15126 LIBS="-lcurses $LIBS" && if test "$extra_verbose" = "yes"; then echo " Prepending \"-lcurses\" to \$LIBS"; fi
15063 else 15127 else
15064 echo "$ac_t""no" 1>&6 15128 echo "$ac_t""no" 1>&6
15065 echo $ac_n "checking for tgetent in -ltermcap""... $ac_c" 1>&6 15129 echo $ac_n "checking for tgetent in -ltermcap""... $ac_c" 1>&6
15066 echo "configure:15067: checking for tgetent in -ltermcap" >&5 15130 echo "configure:15131: checking for tgetent in -ltermcap" >&5
15067 ac_lib_var=`echo termcap'_'tgetent | sed 'y%./+-%__p_%'` 15131 ac_lib_var=`echo termcap'_'tgetent | sed 'y%./+-%__p_%'`
15068 15132
15069 xe_check_libs=" -ltermcap " 15133 xe_check_libs=" -ltermcap "
15070 cat > conftest.$ac_ext <<EOF 15134 cat > conftest.$ac_ext <<EOF
15071 #line 15072 "configure" 15135 #line 15136 "configure"
15072 #include "confdefs.h" 15136 #include "confdefs.h"
15073 /* Override any gcc2 internal prototype to avoid an error. */ 15137 /* Override any gcc2 internal prototype to avoid an error. */
15074 /* We use char because int might match the return type of a gcc2 15138 /* We use char because int might match the return type of a gcc2
15075 builtin and then its argument prototype would still apply. */ 15139 builtin and then its argument prototype would still apply. */
15076 char tgetent(); 15140 char tgetent();
15077 15141
15078 int main() { 15142 int main() {
15079 tgetent() 15143 tgetent()
15080 ; return 0; } 15144 ; return 0; }
15081 EOF 15145 EOF
15082 if { (eval echo configure:15083: \"$ac_link\") 1>&5; (eval $ac_link) 2>&5; } && test -s conftest${ac_exeext}; then 15146 if { (eval echo configure:15147: \"$ac_link\") 1>&5; (eval $ac_link) 2>&5; } && test -s conftest${ac_exeext}; then
15083 rm -rf conftest* 15147 rm -rf conftest*
15084 eval "ac_cv_lib_$ac_lib_var=yes" 15148 eval "ac_cv_lib_$ac_lib_var=yes"
15085 else 15149 else
15086 echo "configure: failed program was:" >&5 15150 echo "configure: failed program was:" >&5
15087 cat conftest.$ac_ext >&5 15151 cat conftest.$ac_ext >&5
15126 15190
15127 15191
15128 if test "$with_gpm" != "no"; then 15192 if test "$with_gpm" != "no"; then
15129 ac_safe=`echo "gpm.h" | sed 'y%./+-%__p_%'` 15193 ac_safe=`echo "gpm.h" | sed 'y%./+-%__p_%'`
15130 echo $ac_n "checking for gpm.h""... $ac_c" 1>&6 15194 echo $ac_n "checking for gpm.h""... $ac_c" 1>&6
15131 echo "configure:15132: checking for gpm.h" >&5 15195 echo "configure:15196: checking for gpm.h" >&5
15132 15196
15133 cat > conftest.$ac_ext <<EOF 15197 cat > conftest.$ac_ext <<EOF
15134 #line 15135 "configure" 15198 #line 15199 "configure"
15135 #include "confdefs.h" 15199 #include "confdefs.h"
15136 #include <gpm.h> 15200 #include <gpm.h>
15137 EOF 15201 EOF
15138 ac_try="$ac_cpp conftest.$ac_ext >/dev/null 2>conftest.out" 15202 ac_try="$ac_cpp conftest.$ac_ext >/dev/null 2>conftest.out"
15139 { (eval echo configure:15140: \"$ac_try\") 1>&5; (eval $ac_try) 2>&5; } 15203 { (eval echo configure:15204: \"$ac_try\") 1>&5; (eval $ac_try) 2>&5; }
15140 ac_err=`grep -v '^ *+' conftest.out | grep -v "^conftest.${ac_ext}\$"` 15204 ac_err=`grep -v '^ *+' conftest.out | grep -v "^conftest.${ac_ext}\$"`
15141 if test -z "$ac_err"; then 15205 if test -z "$ac_err"; then
15142 rm -rf conftest* 15206 rm -rf conftest*
15143 eval "ac_cv_header_$ac_safe=yes" 15207 eval "ac_cv_header_$ac_safe=yes"
15144 else 15208 else
15152 if eval "test \"`echo '$ac_cv_header_'$ac_safe`\" = yes"; then 15216 if eval "test \"`echo '$ac_cv_header_'$ac_safe`\" = yes"; then
15153 echo "$ac_t""yes" 1>&6 15217 echo "$ac_t""yes" 1>&6
15154 15218
15155 15219
15156 echo $ac_n "checking for Gpm_Open in -lgpm""... $ac_c" 1>&6 15220 echo $ac_n "checking for Gpm_Open in -lgpm""... $ac_c" 1>&6
15157 echo "configure:15158: checking for Gpm_Open in -lgpm" >&5 15221 echo "configure:15222: checking for Gpm_Open in -lgpm" >&5
15158 ac_lib_var=`echo gpm'_'Gpm_Open | sed 'y%./+-%__p_%'` 15222 ac_lib_var=`echo gpm'_'Gpm_Open | sed 'y%./+-%__p_%'`
15159 15223
15160 xe_check_libs=" -lgpm " 15224 xe_check_libs=" -lgpm "
15161 cat > conftest.$ac_ext <<EOF 15225 cat > conftest.$ac_ext <<EOF
15162 #line 15163 "configure" 15226 #line 15227 "configure"
15163 #include "confdefs.h" 15227 #include "confdefs.h"
15164 /* Override any gcc2 internal prototype to avoid an error. */ 15228 /* Override any gcc2 internal prototype to avoid an error. */
15165 /* We use char because int might match the return type of a gcc2 15229 /* We use char because int might match the return type of a gcc2
15166 builtin and then its argument prototype would still apply. */ 15230 builtin and then its argument prototype would still apply. */
15167 char Gpm_Open(); 15231 char Gpm_Open();
15168 15232
15169 int main() { 15233 int main() {
15170 Gpm_Open() 15234 Gpm_Open()
15171 ; return 0; } 15235 ; return 0; }
15172 EOF 15236 EOF
15173 if { (eval echo configure:15174: \"$ac_link\") 1>&5; (eval $ac_link) 2>&5; } && test -s conftest${ac_exeext}; then 15237 if { (eval echo configure:15238: \"$ac_link\") 1>&5; (eval $ac_link) 2>&5; } && test -s conftest${ac_exeext}; then
15174 rm -rf conftest* 15238 rm -rf conftest*
15175 eval "ac_cv_lib_$ac_lib_var=yes" 15239 eval "ac_cv_lib_$ac_lib_var=yes"
15176 else 15240 else
15177 echo "configure: failed program was:" >&5 15241 echo "configure: failed program was:" >&5
15178 cat conftest.$ac_ext >&5 15242 cat conftest.$ac_ext >&5
15220 done 15284 done
15221 fi 15285 fi
15222 15286
15223 test "$with_database_gdbm $with_database_dbm $with_database_berkdb" \ 15287 test "$with_database_gdbm $with_database_dbm $with_database_berkdb" \
15224 != "no no no" && echo "checking for database support" 1>&6 15288 != "no no no" && echo "checking for database support" 1>&6
15225 echo "configure:15226: checking for database support" >&5 15289 echo "configure:15290: checking for database support" >&5
15226 15290
15227 if test "$with_database_gdbm $with_database_dbm" != "no no"; then 15291 if test "$with_database_gdbm $with_database_dbm" != "no no"; then
15228 ac_safe=`echo "ndbm.h" | sed 'y%./+-%__p_%'` 15292 ac_safe=`echo "ndbm.h" | sed 'y%./+-%__p_%'`
15229 echo $ac_n "checking for ndbm.h""... $ac_c" 1>&6 15293 echo $ac_n "checking for ndbm.h""... $ac_c" 1>&6
15230 echo "configure:15231: checking for ndbm.h" >&5 15294 echo "configure:15295: checking for ndbm.h" >&5
15231 15295
15232 cat > conftest.$ac_ext <<EOF 15296 cat > conftest.$ac_ext <<EOF
15233 #line 15234 "configure" 15297 #line 15298 "configure"
15234 #include "confdefs.h" 15298 #include "confdefs.h"
15235 #include <ndbm.h> 15299 #include <ndbm.h>
15236 EOF 15300 EOF
15237 ac_try="$ac_cpp conftest.$ac_ext >/dev/null 2>conftest.out" 15301 ac_try="$ac_cpp conftest.$ac_ext >/dev/null 2>conftest.out"
15238 { (eval echo configure:15239: \"$ac_try\") 1>&5; (eval $ac_try) 2>&5; } 15302 { (eval echo configure:15303: \"$ac_try\") 1>&5; (eval $ac_try) 2>&5; }
15239 ac_err=`grep -v '^ *+' conftest.out | grep -v "^conftest.${ac_ext}\$"` 15303 ac_err=`grep -v '^ *+' conftest.out | grep -v "^conftest.${ac_ext}\$"`
15240 if test -z "$ac_err"; then 15304 if test -z "$ac_err"; then
15241 rm -rf conftest* 15305 rm -rf conftest*
15242 eval "ac_cv_header_$ac_safe=yes" 15306 eval "ac_cv_header_$ac_safe=yes"
15243 else 15307 else
15263 fi 15327 fi
15264 15328
15265 if test "$with_database_gdbm" != "no"; then 15329 if test "$with_database_gdbm" != "no"; then
15266 15330
15267 echo $ac_n "checking for dbm_open in -lgdbm""... $ac_c" 1>&6 15331 echo $ac_n "checking for dbm_open in -lgdbm""... $ac_c" 1>&6
15268 echo "configure:15269: checking for dbm_open in -lgdbm" >&5 15332 echo "configure:15333: checking for dbm_open in -lgdbm" >&5
15269 ac_lib_var=`echo gdbm'_'dbm_open | sed 'y%./+-%__p_%'` 15333 ac_lib_var=`echo gdbm'_'dbm_open | sed 'y%./+-%__p_%'`
15270 15334
15271 xe_check_libs=" -lgdbm " 15335 xe_check_libs=" -lgdbm "
15272 cat > conftest.$ac_ext <<EOF 15336 cat > conftest.$ac_ext <<EOF
15273 #line 15274 "configure" 15337 #line 15338 "configure"
15274 #include "confdefs.h" 15338 #include "confdefs.h"
15275 /* Override any gcc2 internal prototype to avoid an error. */ 15339 /* Override any gcc2 internal prototype to avoid an error. */
15276 /* We use char because int might match the return type of a gcc2 15340 /* We use char because int might match the return type of a gcc2
15277 builtin and then its argument prototype would still apply. */ 15341 builtin and then its argument prototype would still apply. */
15278 char dbm_open(); 15342 char dbm_open();
15279 15343
15280 int main() { 15344 int main() {
15281 dbm_open() 15345 dbm_open()
15282 ; return 0; } 15346 ; return 0; }
15283 EOF 15347 EOF
15284 if { (eval echo configure:15285: \"$ac_link\") 1>&5; (eval $ac_link) 2>&5; } && test -s conftest${ac_exeext}; then 15348 if { (eval echo configure:15349: \"$ac_link\") 1>&5; (eval $ac_link) 2>&5; } && test -s conftest${ac_exeext}; then
15285 rm -rf conftest* 15349 rm -rf conftest*
15286 eval "ac_cv_lib_$ac_lib_var=yes" 15350 eval "ac_cv_lib_$ac_lib_var=yes"
15287 else 15351 else
15288 echo "configure: failed program was:" >&5 15352 echo "configure: failed program was:" >&5
15289 cat conftest.$ac_ext >&5 15353 cat conftest.$ac_ext >&5
15307 15371
15308 fi 15372 fi
15309 15373
15310 if test "$with_database_dbm" != "no"; then 15374 if test "$with_database_dbm" != "no"; then
15311 echo $ac_n "checking for dbm_open""... $ac_c" 1>&6 15375 echo $ac_n "checking for dbm_open""... $ac_c" 1>&6
15312 echo "configure:15313: checking for dbm_open" >&5 15376 echo "configure:15377: checking for dbm_open" >&5
15313 15377
15314 cat > conftest.$ac_ext <<EOF 15378 cat > conftest.$ac_ext <<EOF
15315 #line 15316 "configure" 15379 #line 15380 "configure"
15316 #include "confdefs.h" 15380 #include "confdefs.h"
15317 /* System header to define __stub macros and hopefully few prototypes, 15381 /* System header to define __stub macros and hopefully few prototypes,
15318 which can conflict with char dbm_open(); below. */ 15382 which can conflict with char dbm_open(); below. */
15319 #include <assert.h> 15383 #include <assert.h>
15320 /* Override any gcc2 internal prototype to avoid an error. */ 15384 /* Override any gcc2 internal prototype to avoid an error. */
15333 dbm_open(); 15397 dbm_open();
15334 #endif 15398 #endif
15335 15399
15336 ; return 0; } 15400 ; return 0; }
15337 EOF 15401 EOF
15338 if { (eval echo configure:15339: \"$ac_link\") 1>&5; (eval $ac_link) 2>&5; } && test -s conftest${ac_exeext}; then 15402 if { (eval echo configure:15403: \"$ac_link\") 1>&5; (eval $ac_link) 2>&5; } && test -s conftest${ac_exeext}; then
15339 rm -rf conftest* 15403 rm -rf conftest*
15340 eval "ac_cv_func_dbm_open=yes" 15404 eval "ac_cv_func_dbm_open=yes"
15341 else 15405 else
15342 echo "configure: failed program was:" >&5 15406 echo "configure: failed program was:" >&5
15343 cat conftest.$ac_ext >&5 15407 cat conftest.$ac_ext >&5
15352 else 15416 else
15353 echo "$ac_t""no" 1>&6 15417 echo "$ac_t""no" 1>&6
15354 15418
15355 15419
15356 echo $ac_n "checking for dbm_open in -ldbm""... $ac_c" 1>&6 15420 echo $ac_n "checking for dbm_open in -ldbm""... $ac_c" 1>&6
15357 echo "configure:15358: checking for dbm_open in -ldbm" >&5 15421 echo "configure:15422: checking for dbm_open in -ldbm" >&5
15358 ac_lib_var=`echo dbm'_'dbm_open | sed 'y%./+-%__p_%'` 15422 ac_lib_var=`echo dbm'_'dbm_open | sed 'y%./+-%__p_%'`
15359 15423
15360 xe_check_libs=" -ldbm " 15424 xe_check_libs=" -ldbm "
15361 cat > conftest.$ac_ext <<EOF 15425 cat > conftest.$ac_ext <<EOF
15362 #line 15363 "configure" 15426 #line 15427 "configure"
15363 #include "confdefs.h" 15427 #include "confdefs.h"
15364 /* Override any gcc2 internal prototype to avoid an error. */ 15428 /* Override any gcc2 internal prototype to avoid an error. */
15365 /* We use char because int might match the return type of a gcc2 15429 /* We use char because int might match the return type of a gcc2
15366 builtin and then its argument prototype would still apply. */ 15430 builtin and then its argument prototype would still apply. */
15367 char dbm_open(); 15431 char dbm_open();
15368 15432
15369 int main() { 15433 int main() {
15370 dbm_open() 15434 dbm_open()
15371 ; return 0; } 15435 ; return 0; }
15372 EOF 15436 EOF
15373 if { (eval echo configure:15374: \"$ac_link\") 1>&5; (eval $ac_link) 2>&5; } && test -s conftest${ac_exeext}; then 15437 if { (eval echo configure:15438: \"$ac_link\") 1>&5; (eval $ac_link) 2>&5; } && test -s conftest${ac_exeext}; then
15374 rm -rf conftest* 15438 rm -rf conftest*
15375 eval "ac_cv_lib_$ac_lib_var=yes" 15439 eval "ac_cv_lib_$ac_lib_var=yes"
15376 else 15440 else
15377 echo "configure: failed program was:" >&5 15441 echo "configure: failed program was:" >&5
15378 cat conftest.$ac_ext >&5 15442 cat conftest.$ac_ext >&5
15409 } 15473 }
15410 15474
15411 15475
15412 if test "$with_database_berkdb" != "no"; then 15476 if test "$with_database_berkdb" != "no"; then
15413 echo $ac_n "checking for Berkeley db.h""... $ac_c" 1>&6 15477 echo $ac_n "checking for Berkeley db.h""... $ac_c" 1>&6
15414 echo "configure:15415: checking for Berkeley db.h" >&5 15478 echo "configure:15479: checking for Berkeley db.h" >&5
15415 for header in "db/db.h" "db.h"; do 15479 for header in "db/db.h" "db.h"; do
15416 cat > conftest.$ac_ext <<EOF 15480 cat > conftest.$ac_ext <<EOF
15417 #line 15418 "configure" 15481 #line 15482 "configure"
15418 #include "confdefs.h" 15482 #include "confdefs.h"
15419 15483
15420 #include <stdlib.h> 15484 #include <stdlib.h>
15421 #if !(defined __GLIBC__ && __GLIBC_MINOR__ >= 1) 15485 #if !(defined __GLIBC__ && __GLIBC_MINOR__ >= 1)
15422 #ifdef HAVE_INTTYPES_H 15486 #ifdef HAVE_INTTYPES_H
15434 15498
15435 int main() { 15499 int main() {
15436 15500
15437 ; return 0; } 15501 ; return 0; }
15438 EOF 15502 EOF
15439 if { (eval echo configure:15440: \"$ac_compile\") 1>&5; (eval $ac_compile) 2>&5; }; then 15503 if { (eval echo configure:15504: \"$ac_compile\") 1>&5; (eval $ac_compile) 2>&5; }; then
15440 rm -rf conftest* 15504 rm -rf conftest*
15441 db_h_file="$header"; break 15505 db_h_file="$header"; break
15442 else 15506 else
15443 echo "configure: failed program was:" >&5 15507 echo "configure: failed program was:" >&5
15444 cat conftest.$ac_ext >&5 15508 cat conftest.$ac_ext >&5
15450 else echo "$ac_t""$db_h_file" 1>&6 15514 else echo "$ac_t""$db_h_file" 1>&6
15451 fi 15515 fi
15452 15516
15453 if test "$with_database_berkdb" != "no"; then 15517 if test "$with_database_berkdb" != "no"; then
15454 echo $ac_n "checking for Berkeley DB version""... $ac_c" 1>&6 15518 echo $ac_n "checking for Berkeley DB version""... $ac_c" 1>&6
15455 echo "configure:15456: checking for Berkeley DB version" >&5 15519 echo "configure:15520: checking for Berkeley DB version" >&5
15456 cat > conftest.$ac_ext <<EOF 15520 cat > conftest.$ac_ext <<EOF
15457 #line 15458 "configure" 15521 #line 15522 "configure"
15458 #include "confdefs.h" 15522 #include "confdefs.h"
15459 #include <$db_h_file> 15523 #include <$db_h_file>
15460 #if DB_VERSION_MAJOR > 1 15524 #if DB_VERSION_MAJOR > 1
15461 yes 15525 yes
15462 #endif 15526 #endif
15464 EOF 15528 EOF
15465 if (eval "$ac_cpp conftest.$ac_ext") 2>&5 | 15529 if (eval "$ac_cpp conftest.$ac_ext") 2>&5 |
15466 egrep "yes" >/dev/null 2>&1; then 15530 egrep "yes" >/dev/null 2>&1; then
15467 rm -rf conftest* 15531 rm -rf conftest*
15468 cat > conftest.$ac_ext <<EOF 15532 cat > conftest.$ac_ext <<EOF
15469 #line 15470 "configure" 15533 #line 15534 "configure"
15470 #include "confdefs.h" 15534 #include "confdefs.h"
15471 #include <$db_h_file> 15535 #include <$db_h_file>
15472 #if DB_VERSION_MAJOR > 2 15536 #if DB_VERSION_MAJOR > 2
15473 yes 15537 yes
15474 #endif 15538 #endif
15476 EOF 15540 EOF
15477 if (eval "$ac_cpp conftest.$ac_ext") 2>&5 | 15541 if (eval "$ac_cpp conftest.$ac_ext") 2>&5 |
15478 egrep "yes" >/dev/null 2>&1; then 15542 egrep "yes" >/dev/null 2>&1; then
15479 rm -rf conftest* 15543 rm -rf conftest*
15480 cat > conftest.$ac_ext <<EOF 15544 cat > conftest.$ac_ext <<EOF
15481 #line 15482 "configure" 15545 #line 15546 "configure"
15482 #include "confdefs.h" 15546 #include "confdefs.h"
15483 #include <$db_h_file> 15547 #include <$db_h_file>
15484 #if DB_VERSION_MAJOR > 3 15548 #if DB_VERSION_MAJOR > 3
15485 yes 15549 yes
15486 #endif 15550 #endif
15510 echo "$ac_t""1" 1>&6; dbfunc=dbopen; dbver=1 15574 echo "$ac_t""1" 1>&6; dbfunc=dbopen; dbver=1
15511 fi 15575 fi
15512 rm -f conftest* 15576 rm -f conftest*
15513 15577
15514 echo $ac_n "checking for $dbfunc""... $ac_c" 1>&6 15578 echo $ac_n "checking for $dbfunc""... $ac_c" 1>&6
15515 echo "configure:15516: checking for $dbfunc" >&5 15579 echo "configure:15580: checking for $dbfunc" >&5
15516 15580
15517 cat > conftest.$ac_ext <<EOF 15581 cat > conftest.$ac_ext <<EOF
15518 #line 15519 "configure" 15582 #line 15583 "configure"
15519 #include "confdefs.h" 15583 #include "confdefs.h"
15520 /* System header to define __stub macros and hopefully few prototypes, 15584 /* System header to define __stub macros and hopefully few prototypes,
15521 which can conflict with char $dbfunc(); below. */ 15585 which can conflict with char $dbfunc(); below. */
15522 #include <assert.h> 15586 #include <assert.h>
15523 /* Override any gcc2 internal prototype to avoid an error. */ 15587 /* Override any gcc2 internal prototype to avoid an error. */
15536 $dbfunc(); 15600 $dbfunc();
15537 #endif 15601 #endif
15538 15602
15539 ; return 0; } 15603 ; return 0; }
15540 EOF 15604 EOF
15541 if { (eval echo configure:15542: \"$ac_link\") 1>&5; (eval $ac_link) 2>&5; } && test -s conftest${ac_exeext}; then 15605 if { (eval echo configure:15606: \"$ac_link\") 1>&5; (eval $ac_link) 2>&5; } && test -s conftest${ac_exeext}; then
15542 rm -rf conftest* 15606 rm -rf conftest*
15543 eval "ac_cv_func_$dbfunc=yes" 15607 eval "ac_cv_func_$dbfunc=yes"
15544 else 15608 else
15545 echo "configure: failed program was:" >&5 15609 echo "configure: failed program was:" >&5
15546 cat conftest.$ac_ext >&5 15610 cat conftest.$ac_ext >&5
15555 else 15619 else
15556 echo "$ac_t""no" 1>&6 15620 echo "$ac_t""no" 1>&6
15557 15621
15558 15622
15559 echo $ac_n "checking for $dbfunc in -ldb""... $ac_c" 1>&6 15623 echo $ac_n "checking for $dbfunc in -ldb""... $ac_c" 1>&6
15560 echo "configure:15561: checking for $dbfunc in -ldb" >&5 15624 echo "configure:15625: checking for $dbfunc in -ldb" >&5
15561 ac_lib_var=`echo db'_'$dbfunc | sed 'y%./+-%__p_%'` 15625 ac_lib_var=`echo db'_'$dbfunc | sed 'y%./+-%__p_%'`
15562 15626
15563 xe_check_libs=" -ldb " 15627 xe_check_libs=" -ldb "
15564 cat > conftest.$ac_ext <<EOF 15628 cat > conftest.$ac_ext <<EOF
15565 #line 15566 "configure" 15629 #line 15630 "configure"
15566 #include "confdefs.h" 15630 #include "confdefs.h"
15567 /* Override any gcc2 internal prototype to avoid an error. */ 15631 /* Override any gcc2 internal prototype to avoid an error. */
15568 /* We use char because int might match the return type of a gcc2 15632 /* We use char because int might match the return type of a gcc2
15569 builtin and then its argument prototype would still apply. */ 15633 builtin and then its argument prototype would still apply. */
15570 char $dbfunc(); 15634 char $dbfunc();
15571 15635
15572 int main() { 15636 int main() {
15573 $dbfunc() 15637 $dbfunc()
15574 ; return 0; } 15638 ; return 0; }
15575 EOF 15639 EOF
15576 if { (eval echo configure:15577: \"$ac_link\") 1>&5; (eval $ac_link) 2>&5; } && test -s conftest${ac_exeext}; then 15640 if { (eval echo configure:15641: \"$ac_link\") 1>&5; (eval $ac_link) 2>&5; } && test -s conftest${ac_exeext}; then
15577 rm -rf conftest* 15641 rm -rf conftest*
15578 eval "ac_cv_lib_$ac_lib_var=yes" 15642 eval "ac_cv_lib_$ac_lib_var=yes"
15579 else 15643 else
15580 echo "configure: failed program was:" >&5 15644 echo "configure: failed program was:" >&5
15581 cat conftest.$ac_ext >&5 15645 cat conftest.$ac_ext >&5
15605 | sed -n -e "s/[ ]*=[ \"]*/='/" -e "s/[ \"]*\$/'/" -e "s/^configure___//p"` 15669 | sed -n -e "s/[ ]*=[ \"]*/='/" -e "s/[ \"]*\$/'/" -e "s/^configure___//p"`
15606 rm -f $tempcname 15670 rm -f $tempcname
15607 echo "configure: warning: "db_create is really $dbfunc"" 1>&2 15671 echo "configure: warning: "db_create is really $dbfunc"" 1>&2
15608 15672
15609 echo $ac_n "checking for $dbfunc in -ldb""... $ac_c" 1>&6 15673 echo $ac_n "checking for $dbfunc in -ldb""... $ac_c" 1>&6
15610 echo "configure:15611: checking for $dbfunc in -ldb" >&5 15674 echo "configure:15675: checking for $dbfunc in -ldb" >&5
15611 ac_lib_var=`echo db'_'$dbfunc | sed 'y%./+-%__p_%'` 15675 ac_lib_var=`echo db'_'$dbfunc | sed 'y%./+-%__p_%'`
15612 15676
15613 xe_check_libs=" -ldb " 15677 xe_check_libs=" -ldb "
15614 cat > conftest.$ac_ext <<EOF 15678 cat > conftest.$ac_ext <<EOF
15615 #line 15616 "configure" 15679 #line 15680 "configure"
15616 #include "confdefs.h" 15680 #include "confdefs.h"
15617 /* Override any gcc2 internal prototype to avoid an error. */ 15681 /* Override any gcc2 internal prototype to avoid an error. */
15618 /* We use char because int might match the return type of a gcc2 15682 /* We use char because int might match the return type of a gcc2
15619 builtin and then its argument prototype would still apply. */ 15683 builtin and then its argument prototype would still apply. */
15620 char $dbfunc(); 15684 char $dbfunc();
15621 15685
15622 int main() { 15686 int main() {
15623 $dbfunc() 15687 $dbfunc()
15624 ; return 0; } 15688 ; return 0; }
15625 EOF 15689 EOF
15626 if { (eval echo configure:15627: \"$ac_link\") 1>&5; (eval $ac_link) 2>&5; } && test -s conftest${ac_exeext}; then 15690 if { (eval echo configure:15691: \"$ac_link\") 1>&5; (eval $ac_link) 2>&5; } && test -s conftest${ac_exeext}; then
15627 rm -rf conftest* 15691 rm -rf conftest*
15628 eval "ac_cv_lib_$ac_lib_var=yes" 15692 eval "ac_cv_lib_$ac_lib_var=yes"
15629 else 15693 else
15630 echo "configure: failed program was:" >&5 15694 echo "configure: failed program was:" >&5
15631 cat conftest.$ac_ext >&5 15695 cat conftest.$ac_ext >&5
15680 fi 15744 fi
15681 15745
15682 if test "$with_socks" = "yes"; then 15746 if test "$with_socks" = "yes"; then
15683 15747
15684 echo $ac_n "checking for SOCKSinit in -lsocks""... $ac_c" 1>&6 15748 echo $ac_n "checking for SOCKSinit in -lsocks""... $ac_c" 1>&6
15685 echo "configure:15686: checking for SOCKSinit in -lsocks" >&5 15749 echo "configure:15750: checking for SOCKSinit in -lsocks" >&5
15686 ac_lib_var=`echo socks'_'SOCKSinit | sed 'y%./+-%__p_%'` 15750 ac_lib_var=`echo socks'_'SOCKSinit | sed 'y%./+-%__p_%'`
15687 15751
15688 xe_check_libs=" -lsocks " 15752 xe_check_libs=" -lsocks "
15689 cat > conftest.$ac_ext <<EOF 15753 cat > conftest.$ac_ext <<EOF
15690 #line 15691 "configure" 15754 #line 15755 "configure"
15691 #include "confdefs.h" 15755 #include "confdefs.h"
15692 /* Override any gcc2 internal prototype to avoid an error. */ 15756 /* Override any gcc2 internal prototype to avoid an error. */
15693 /* We use char because int might match the return type of a gcc2 15757 /* We use char because int might match the return type of a gcc2
15694 builtin and then its argument prototype would still apply. */ 15758 builtin and then its argument prototype would still apply. */
15695 char SOCKSinit(); 15759 char SOCKSinit();
15696 15760
15697 int main() { 15761 int main() {
15698 SOCKSinit() 15762 SOCKSinit()
15699 ; return 0; } 15763 ; return 0; }
15700 EOF 15764 EOF
15701 if { (eval echo configure:15702: \"$ac_link\") 1>&5; (eval $ac_link) 2>&5; } && test -s conftest${ac_exeext}; then 15765 if { (eval echo configure:15766: \"$ac_link\") 1>&5; (eval $ac_link) 2>&5; } && test -s conftest${ac_exeext}; then
15702 rm -rf conftest* 15766 rm -rf conftest*
15703 eval "ac_cv_lib_$ac_lib_var=yes" 15767 eval "ac_cv_lib_$ac_lib_var=yes"
15704 else 15768 else
15705 echo "configure: failed program was:" >&5 15769 echo "configure: failed program was:" >&5
15706 cat conftest.$ac_ext >&5 15770 cat conftest.$ac_ext >&5
15752 fi 15816 fi
15753 15817
15754 if test "$use_number_lib" = "gmp"; then 15818 if test "$use_number_lib" = "gmp"; then
15755 ac_safe=`echo "gmp.h" | sed 'y%./+-%__p_%'` 15819 ac_safe=`echo "gmp.h" | sed 'y%./+-%__p_%'`
15756 echo $ac_n "checking for gmp.h""... $ac_c" 1>&6 15820 echo $ac_n "checking for gmp.h""... $ac_c" 1>&6
15757 echo "configure:15758: checking for gmp.h" >&5 15821 echo "configure:15822: checking for gmp.h" >&5
15758 15822
15759 cat > conftest.$ac_ext <<EOF 15823 cat > conftest.$ac_ext <<EOF
15760 #line 15761 "configure" 15824 #line 15825 "configure"
15761 #include "confdefs.h" 15825 #include "confdefs.h"
15762 #include <gmp.h> 15826 #include <gmp.h>
15763 EOF 15827 EOF
15764 ac_try="$ac_cpp conftest.$ac_ext >/dev/null 2>conftest.out" 15828 ac_try="$ac_cpp conftest.$ac_ext >/dev/null 2>conftest.out"
15765 { (eval echo configure:15766: \"$ac_try\") 1>&5; (eval $ac_try) 2>&5; } 15829 { (eval echo configure:15830: \"$ac_try\") 1>&5; (eval $ac_try) 2>&5; }
15766 ac_err=`grep -v '^ *+' conftest.out | grep -v "^conftest.${ac_ext}\$"` 15830 ac_err=`grep -v '^ *+' conftest.out | grep -v "^conftest.${ac_ext}\$"`
15767 if test -z "$ac_err"; then 15831 if test -z "$ac_err"; then
15768 rm -rf conftest* 15832 rm -rf conftest*
15769 eval "ac_cv_header_$ac_safe=yes" 15833 eval "ac_cv_header_$ac_safe=yes"
15770 else 15834 else
15778 if eval "test \"`echo '$ac_cv_header_'$ac_safe`\" = yes"; then 15842 if eval "test \"`echo '$ac_cv_header_'$ac_safe`\" = yes"; then
15779 echo "$ac_t""yes" 1>&6 15843 echo "$ac_t""yes" 1>&6
15780 15844
15781 15845
15782 echo $ac_n "checking for __gmpz_init in -lgmp""... $ac_c" 1>&6 15846 echo $ac_n "checking for __gmpz_init in -lgmp""... $ac_c" 1>&6
15783 echo "configure:15784: checking for __gmpz_init in -lgmp" >&5 15847 echo "configure:15848: checking for __gmpz_init in -lgmp" >&5
15784 ac_lib_var=`echo gmp'_'__gmpz_init | sed 'y%./+-%__p_%'` 15848 ac_lib_var=`echo gmp'_'__gmpz_init | sed 'y%./+-%__p_%'`
15785 15849
15786 xe_check_libs=" -lgmp " 15850 xe_check_libs=" -lgmp "
15787 cat > conftest.$ac_ext <<EOF 15851 cat > conftest.$ac_ext <<EOF
15788 #line 15789 "configure" 15852 #line 15853 "configure"
15789 #include "confdefs.h" 15853 #include "confdefs.h"
15790 /* Override any gcc2 internal prototype to avoid an error. */ 15854 /* Override any gcc2 internal prototype to avoid an error. */
15791 /* We use char because int might match the return type of a gcc2 15855 /* We use char because int might match the return type of a gcc2
15792 builtin and then its argument prototype would still apply. */ 15856 builtin and then its argument prototype would still apply. */
15793 char __gmpz_init(); 15857 char __gmpz_init();
15794 15858
15795 int main() { 15859 int main() {
15796 __gmpz_init() 15860 __gmpz_init()
15797 ; return 0; } 15861 ; return 0; }
15798 EOF 15862 EOF
15799 if { (eval echo configure:15800: \"$ac_link\") 1>&5; (eval $ac_link) 2>&5; } && test -s conftest${ac_exeext}; then 15863 if { (eval echo configure:15864: \"$ac_link\") 1>&5; (eval $ac_link) 2>&5; } && test -s conftest${ac_exeext}; then
15800 rm -rf conftest* 15864 rm -rf conftest*
15801 eval "ac_cv_lib_$ac_lib_var=yes" 15865 eval "ac_cv_lib_$ac_lib_var=yes"
15802 else 15866 else
15803 echo "configure: failed program was:" >&5 15867 echo "configure: failed program was:" >&5
15804 cat conftest.$ac_ext >&5 15868 cat conftest.$ac_ext >&5
15843 fi 15907 fi
15844 elif test "$use_number_lib" = "mp"; then 15908 elif test "$use_number_lib" = "mp"; then
15845 for library in "" "-lcrypto"; do 15909 for library in "" "-lcrypto"; do
15846 ac_safe=`echo "mp.h" | sed 'y%./+-%__p_%'` 15910 ac_safe=`echo "mp.h" | sed 'y%./+-%__p_%'`
15847 echo $ac_n "checking for mp.h""... $ac_c" 1>&6 15911 echo $ac_n "checking for mp.h""... $ac_c" 1>&6
15848 echo "configure:15849: checking for mp.h" >&5 15912 echo "configure:15913: checking for mp.h" >&5
15849 15913
15850 cat > conftest.$ac_ext <<EOF 15914 cat > conftest.$ac_ext <<EOF
15851 #line 15852 "configure" 15915 #line 15916 "configure"
15852 #include "confdefs.h" 15916 #include "confdefs.h"
15853 #include <mp.h> 15917 #include <mp.h>
15854 EOF 15918 EOF
15855 ac_try="$ac_cpp conftest.$ac_ext >/dev/null 2>conftest.out" 15919 ac_try="$ac_cpp conftest.$ac_ext >/dev/null 2>conftest.out"
15856 { (eval echo configure:15857: \"$ac_try\") 1>&5; (eval $ac_try) 2>&5; } 15920 { (eval echo configure:15921: \"$ac_try\") 1>&5; (eval $ac_try) 2>&5; }
15857 ac_err=`grep -v '^ *+' conftest.out | grep -v "^conftest.${ac_ext}\$"` 15921 ac_err=`grep -v '^ *+' conftest.out | grep -v "^conftest.${ac_ext}\$"`
15858 if test -z "$ac_err"; then 15922 if test -z "$ac_err"; then
15859 rm -rf conftest* 15923 rm -rf conftest*
15860 eval "ac_cv_header_$ac_safe=yes" 15924 eval "ac_cv_header_$ac_safe=yes"
15861 else 15925 else
15871 15935
15872 15936
15873 xe_msg_checking="for mp_mfree in -lmp" 15937 xe_msg_checking="for mp_mfree in -lmp"
15874 test -n "$library" && xe_msg_checking="$xe_msg_checking using extra libs $library" 15938 test -n "$library" && xe_msg_checking="$xe_msg_checking using extra libs $library"
15875 echo $ac_n "checking "$xe_msg_checking"""... $ac_c" 1>&6 15939 echo $ac_n "checking "$xe_msg_checking"""... $ac_c" 1>&6
15876 echo "configure:15877: checking "$xe_msg_checking"" >&5 15940 echo "configure:15941: checking "$xe_msg_checking"" >&5
15877 ac_lib_var=`echo mp'_'mp_mfree | sed 'y%./+-%__p_%'` 15941 ac_lib_var=`echo mp'_'mp_mfree | sed 'y%./+-%__p_%'`
15878 15942
15879 xe_check_libs=" -lmp $library" 15943 xe_check_libs=" -lmp $library"
15880 cat > conftest.$ac_ext <<EOF 15944 cat > conftest.$ac_ext <<EOF
15881 #line 15882 "configure" 15945 #line 15946 "configure"
15882 #include "confdefs.h" 15946 #include "confdefs.h"
15883 /* Override any gcc2 internal prototype to avoid an error. */ 15947 /* Override any gcc2 internal prototype to avoid an error. */
15884 /* We use char because int might match the return type of a gcc2 15948 /* We use char because int might match the return type of a gcc2
15885 builtin and then its argument prototype would still apply. */ 15949 builtin and then its argument prototype would still apply. */
15886 char mp_mfree(); 15950 char mp_mfree();
15887 15951
15888 int main() { 15952 int main() {
15889 mp_mfree() 15953 mp_mfree()
15890 ; return 0; } 15954 ; return 0; }
15891 EOF 15955 EOF
15892 if { (eval echo configure:15893: \"$ac_link\") 1>&5; (eval $ac_link) 2>&5; } && test -s conftest${ac_exeext}; then 15956 if { (eval echo configure:15957: \"$ac_link\") 1>&5; (eval $ac_link) 2>&5; } && test -s conftest${ac_exeext}; then
15893 rm -rf conftest* 15957 rm -rf conftest*
15894 eval "ac_cv_lib_$ac_lib_var=yes" 15958 eval "ac_cv_lib_$ac_lib_var=yes"
15895 else 15959 else
15896 echo "configure: failed program was:" >&5 15960 echo "configure: failed program was:" >&5
15897 cat conftest.$ac_ext >&5 15961 cat conftest.$ac_ext >&5
15908 echo "$ac_t""no" 1>&6 15972 echo "$ac_t""no" 1>&6
15909 15973
15910 xe_msg_checking="for mfree in -lmp" 15974 xe_msg_checking="for mfree in -lmp"
15911 test -n "$library" && xe_msg_checking="$xe_msg_checking using extra libs $library" 15975 test -n "$library" && xe_msg_checking="$xe_msg_checking using extra libs $library"
15912 echo $ac_n "checking "$xe_msg_checking"""... $ac_c" 1>&6 15976 echo $ac_n "checking "$xe_msg_checking"""... $ac_c" 1>&6
15913 echo "configure:15914: checking "$xe_msg_checking"" >&5 15977 echo "configure:15978: checking "$xe_msg_checking"" >&5
15914 ac_lib_var=`echo mp'_'mfree | sed 'y%./+-%__p_%'` 15978 ac_lib_var=`echo mp'_'mfree | sed 'y%./+-%__p_%'`
15915 15979
15916 xe_check_libs=" -lmp $library" 15980 xe_check_libs=" -lmp $library"
15917 cat > conftest.$ac_ext <<EOF 15981 cat > conftest.$ac_ext <<EOF
15918 #line 15919 "configure" 15982 #line 15983 "configure"
15919 #include "confdefs.h" 15983 #include "confdefs.h"
15920 /* Override any gcc2 internal prototype to avoid an error. */ 15984 /* Override any gcc2 internal prototype to avoid an error. */
15921 /* We use char because int might match the return type of a gcc2 15985 /* We use char because int might match the return type of a gcc2
15922 builtin and then its argument prototype would still apply. */ 15986 builtin and then its argument prototype would still apply. */
15923 char mfree(); 15987 char mfree();
15924 15988
15925 int main() { 15989 int main() {
15926 mfree() 15990 mfree()
15927 ; return 0; } 15991 ; return 0; }
15928 EOF 15992 EOF
15929 if { (eval echo configure:15930: \"$ac_link\") 1>&5; (eval $ac_link) 2>&5; } && test -s conftest${ac_exeext}; then 15993 if { (eval echo configure:15994: \"$ac_link\") 1>&5; (eval $ac_link) 2>&5; } && test -s conftest${ac_exeext}; then
15930 rm -rf conftest* 15994 rm -rf conftest*
15931 eval "ac_cv_lib_$ac_lib_var=yes" 15995 eval "ac_cv_lib_$ac_lib_var=yes"
15932 else 15996 else
15933 echo "configure: failed program was:" >&5 15997 echo "configure: failed program was:" >&5
15934 cat conftest.$ac_ext >&5 15998 cat conftest.$ac_ext >&5
15966 LIBS="$LIBS -lmp" && if test "$extra_verbose" = "yes"; then echo " Appending \"-lmp\" to \$LIBS"; fi 16030 LIBS="$LIBS -lmp" && if test "$extra_verbose" = "yes"; then echo " Appending \"-lmp\" to \$LIBS"; fi
15967 if test "$library" != ""; then 16031 if test "$library" != ""; then
15968 LIBS="$LIBS $library" && if test "$extra_verbose" = "yes"; then echo " Appending \"$library\" to \$LIBS"; fi 16032 LIBS="$LIBS $library" && if test "$extra_verbose" = "yes"; then echo " Appending \"$library\" to \$LIBS"; fi
15969 fi 16033 fi
15970 echo $ac_n "checking for mp_move""... $ac_c" 1>&6 16034 echo $ac_n "checking for mp_move""... $ac_c" 1>&6
15971 echo "configure:15972: checking for mp_move" >&5 16035 echo "configure:16036: checking for mp_move" >&5
15972 16036
15973 cat > conftest.$ac_ext <<EOF 16037 cat > conftest.$ac_ext <<EOF
15974 #line 15975 "configure" 16038 #line 16039 "configure"
15975 #include "confdefs.h" 16039 #include "confdefs.h"
15976 /* System header to define __stub macros and hopefully few prototypes, 16040 /* System header to define __stub macros and hopefully few prototypes,
15977 which can conflict with char mp_move(); below. */ 16041 which can conflict with char mp_move(); below. */
15978 #include <assert.h> 16042 #include <assert.h>
15979 /* Override any gcc2 internal prototype to avoid an error. */ 16043 /* Override any gcc2 internal prototype to avoid an error. */
15992 mp_move(); 16056 mp_move();
15993 #endif 16057 #endif
15994 16058
15995 ; return 0; } 16059 ; return 0; }
15996 EOF 16060 EOF
15997 if { (eval echo configure:15998: \"$ac_link\") 1>&5; (eval $ac_link) 2>&5; } && test -s conftest${ac_exeext}; then 16061 if { (eval echo configure:16062: \"$ac_link\") 1>&5; (eval $ac_link) 2>&5; } && test -s conftest${ac_exeext}; then
15998 rm -rf conftest* 16062 rm -rf conftest*
15999 eval "ac_cv_func_mp_move=yes" 16063 eval "ac_cv_func_mp_move=yes"
16000 else 16064 else
16001 echo "configure: failed program was:" >&5 16065 echo "configure: failed program was:" >&5
16002 cat conftest.$ac_ext >&5 16066 cat conftest.$ac_ext >&5
16023 LIBS="$LIBS -lmp" && if test "$extra_verbose" = "yes"; then echo " Appending \"-lmp\" to \$LIBS"; fi 16087 LIBS="$LIBS -lmp" && if test "$extra_verbose" = "yes"; then echo " Appending \"-lmp\" to \$LIBS"; fi
16024 if test "$library" != ""; then 16088 if test "$library" != ""; then
16025 LIBS="$LIBS $library" && if test "$extra_verbose" = "yes"; then echo " Appending \"$library\" to \$LIBS"; fi 16089 LIBS="$LIBS $library" && if test "$extra_verbose" = "yes"; then echo " Appending \"$library\" to \$LIBS"; fi
16026 fi 16090 fi
16027 echo $ac_n "checking for move""... $ac_c" 1>&6 16091 echo $ac_n "checking for move""... $ac_c" 1>&6
16028 echo "configure:16029: checking for move" >&5 16092 echo "configure:16093: checking for move" >&5
16029 16093
16030 cat > conftest.$ac_ext <<EOF 16094 cat > conftest.$ac_ext <<EOF
16031 #line 16032 "configure" 16095 #line 16096 "configure"
16032 #include "confdefs.h" 16096 #include "confdefs.h"
16033 /* System header to define __stub macros and hopefully few prototypes, 16097 /* System header to define __stub macros and hopefully few prototypes,
16034 which can conflict with char move(); below. */ 16098 which can conflict with char move(); below. */
16035 #include <assert.h> 16099 #include <assert.h>
16036 /* Override any gcc2 internal prototype to avoid an error. */ 16100 /* Override any gcc2 internal prototype to avoid an error. */
16049 move(); 16113 move();
16050 #endif 16114 #endif
16051 16115
16052 ; return 0; } 16116 ; return 0; }
16053 EOF 16117 EOF
16054 if { (eval echo configure:16055: \"$ac_link\") 1>&5; (eval $ac_link) 2>&5; } && test -s conftest${ac_exeext}; then 16118 if { (eval echo configure:16119: \"$ac_link\") 1>&5; (eval $ac_link) 2>&5; } && test -s conftest${ac_exeext}; then
16055 rm -rf conftest* 16119 rm -rf conftest*
16056 eval "ac_cv_func_move=yes" 16120 eval "ac_cv_func_move=yes"
16057 else 16121 else
16058 echo "configure: failed program was:" >&5 16122 echo "configure: failed program was:" >&5
16059 cat conftest.$ac_ext >&5 16123 cat conftest.$ac_ext >&5
16096 } 16160 }
16097 16161
16098 fi 16162 fi
16099 16163
16100 cat > conftest.$ac_ext <<EOF 16164 cat > conftest.$ac_ext <<EOF
16101 #line 16102 "configure" 16165 #line 16166 "configure"
16102 #include "confdefs.h" 16166 #include "confdefs.h"
16103 int main(int c,char *v[]){return 0;} 16167 int main(int c,char *v[]){return 0;}
16104 EOF 16168 EOF
16105 if { (eval echo configure:16106: \"$ac_link\") 1>&5; (eval $ac_link) 2>&5; } && test -s conftest && (./conftest; exit $?) 2>&5 16169 if { (eval echo configure:16170: \"$ac_link\") 1>&5; (eval $ac_link) 2>&5; } && test -s conftest && (./conftest; exit $?) 2>&5
16106 then 16170 then
16107 : 16171 :
16108 else 16172 else
16109 conftest_rc="$?" 16173 conftest_rc="$?"
16110 echo "configure: failed program was:" >&5 16174 echo "configure: failed program was:" >&5
17368 EOF 17432 EOF
17369 cat >> $CONFIG_STATUS <<\EOF 17433 cat >> $CONFIG_STATUS <<\EOF
17370 for dir in . $MAKE_SUBDIR; do 17434 for dir in . $MAKE_SUBDIR; do
17371 ( 17435 (
17372 cd $dir 17436 cd $dir
17437
17438
17439
17440
17441
17442
17373 rm -f junk.c 17443 rm -f junk.c
17374 < Makefile.in \ 17444 < Makefile.in \
17375 sed -e '/^# Generated/d' \ 17445 sed -e '/^# Generated/d' \
17376 -e 's%/\*\*/#.*%%' \ 17446 -e 's%/\*\*/#.*%%' \
17377 -e 's/^ *# */#/' \ 17447 -e 's/^ *# */#/' \
17384 s/\([\"]\)/\\\1/g 17454 s/\([\"]\)/\\\1/g
17385 s/^/"/ 17455 s/^/"/
17386 s/$/"/ 17456 s/$/"/
17387 }' > junk.c; 17457 }' > junk.c;
17388 17458
17389
17390
17391 echo creating $dir/Makefile 17459 echo creating $dir/Makefile
17392 $CPP -I. -I${top_srcdir}/src junk.c \ 17460 $CPP -I. -I${top_srcdir}/src junk.c \
17393 | sed -e 's/^\#.*//' \ 17461 | sed -e 's/^\#.*//' \
17394 -e 's/^[ ][ ]*$//'\ 17462 -e 's/^[ ][ ]*$//'\
17395 -e 's/^ / /' \ 17463 -e 's/^ / /' \
17415 }' > Makefile.new 17483 }' > Makefile.new
17416 chmod 444 Makefile.new 17484 chmod 444 Makefile.new
17417 mv -f Makefile.new GNUmakefile 17485 mv -f Makefile.new GNUmakefile
17418 17486
17419 if test -r "xemacs.def.in"; then 17487 if test -r "xemacs.def.in"; then
17420 cp -f xemacs.def.in junk.c 17488 rm -f junk.c
17489 cp xemacs.def.in junk.c
17421 echo creating $dir/xemacs.def 17490 echo creating $dir/xemacs.def
17422 $CPP -I. -I${top_srcdir}/src junk.c \ 17491 $CPP -I. -I${top_srcdir}/src junk.c \
17423 | sed -e 's/^\#.*//' \ 17492 | sed -e 's/^\#.*//' \
17424 -e 's/^[ ][ ]*$//'\ 17493 -e 's/^[ ][ ]*$//'\
17425 -e 's/^ / /' \ 17494 -e 's/^ / /' \