--- /dev/null	Thu Jan 01 00:00:00 1970 +0000
+++ b/CHANGES-ben-mule	Wed Mar 13 08:54:06 2002 +0000
@@ -0,0 +1,479 @@
+List of changes in new Mule workspace:
+--------------------------------------
+
+Deleted files:
+
+src/iso-wide.h
+src/mule-charset.h
+src/mule.c
+src/ntheap.h
+src/syscommctrl.h
+lisp/files-nomule.el
+lisp/help-nomule.el
+lisp/mule/mule-help.el
+lisp/mule/mule-init.el
+lisp/mule/mule-misc.el
+nt/config.h
+
+
+Other deleted files, all zero-width and accidentally present:
+
+src/events-mod.h
+tests/Dnd/README.OffiX
+tests/Dnd/dragtest.el
+netinstall/README.xemacs
+lib-src/srcdir-symlink.stamp
+
+New files:
+
+CHANGES-ben-mule
+README.ben-mule-21-5
+README.ben-separate-stderr
+TODO.ben-mule-21-5
+etc/TUTORIAL.{cs,es,nl,sk,sl}
+etc/unicode/*
+lib-src/make-mswin-unicode.pl
+lisp/code-init.el
+lisp/resize-minibuffer.el
+lisp/unicode.el
+lisp/mule/china-util.el
+lisp/mule/cyril-util.el
+lisp/mule/devan-util.el
+lisp/mule/devanagari.el
+lisp/mule/ethio-util.el
+lisp/mule/indian.el
+lisp/mule/japan-util.el
+lisp/mule/korea-util.el
+lisp/mule/lao-util.el
+lisp/mule/lao.el
+lisp/mule/mule-locale.txt
+lisp/mule/mule-msw-init.el
+lisp/mule/thai-util.el
+lisp/mule/thai.el
+lisp/mule/tibet-util.el
+lisp/mule/tibetan.el
+lisp/mule/viet-util.el
+src/charset.h
+src/intl-auto-encap-win32.c
+src/intl-auto-encap-win32.h
+src/intl-encap-win32.c
+src/intl-win32.c
+src/intl-x.c
+src/mule-coding.c
+src/text.c
+src/text.h
+src/unicode.c
+src/s/win32-common.h
+src/s/win32-native.h
+
+
+
+gzip support:
+
+-- new coding system `gzip' (bytes -> bytes); unfortunately, not quite
+   working yet because it handles only the raw zlib format and not the
+   higher-level gzip format (the zlib library is brain-damaged in that it
+   provides low-level, stream-oriented API's only for raw zlib, and for
+   gzip you have only high-level API's, which aren't useful for xemacs).
+-- configure support (with-zlib).
+
+configure changes:
+
+- file-coding always compiled in.  eol detection is off by default on unix,
+  non-mule, but can be enabled with configure option
+  --with-default-eol-detection or command-line flag -eol.
+- code that selects which files are compiled is mostly moved to
+   Makefile.in.in.  see comment in Makefile.in.in.
+- vestigial i18n3 code deleted.
+- new cygwin mswin libs imm32 (input methods), mpr (user name enumeration).
+- check for link, symlink.
+- vfork-related code deleted.
+- fix configure.usage. (delete --with-file-coding, --no-doc-file, add
+  --with-default-eol-detection, --quick-build).
+- nt/config.h has been eliminated and everything in it merged into
+  config.h.in and s/windowsnt.h.  see config.h.in for more info.
+- massive rewrite of s/windowsnt.h, m/windowsnt.h, s/cygwin32.h,
+  s/mingw32.h.  common code moved into s/win32-common.h, s/win32-native.h.
+- in nt/xemacs.mak,config.inc.samp, variable is called MULE, not HAVE_MULE,
+  for consistency with sources.
+- define TABDLY, TAB3 in freebsd.h (#### from where?)
+
+Tutorial:
+
+- massive rewrite; sync to FSF 21.0.106, switch focus to window systems,
+  new sections on terminology and multiple frames, lots of fixes for
+  current xemacs idioms.
+- german version from Adrian mostly matching my changes.
+- copy new tutorials from FSF (Spanish, Dutch, Slovak, Slovenian, Czech);
+  not updated yet though.
+- eliminate help-nomule.el and mule-help.el; merge into one single tutorial
+  function, fix lots of problems, put back in help.el where it belongs.
+  (there was some random junk in help-nomule -- string-width and make-char.
+  string-width is now in subr.el with a single definition, and make-char in
+  text.c.)
+
+Sample init file:
+
+- remove forward/backward buffer code, since it's now standard.
+- when disabling C-x C-c, make it display a message saying how to exit, not
+  just beep and complain "undefined".
+
+Key bindings: (keymap.c, keydefs.el, help.el, etc.)
+
+- M-home, M-end now move forward and backward in buffers; with Shift, stay
+  within current group (e.g. all C files; same grouping as the gutter
+  tabs). (bindings switch-to-{next/previous}-buffer[-in-group] in files.el)
+  - needed to move code from gutter-items.el to buff-menu.el that's used by
+    these bindings, since gutter-items.el is loaded only when the gutter is
+    active and these bindings (and hence the code) is not (any more) gutter
+    specific.
+- new global vars global-tty-map and global-window-system-map specify key
+  bindings for use only on TTY's or window systems, respectively.  this is
+  used to make ESC ESC be keyboard-quit on window systems, but ESC ESC ESC
+  on TTY's, where Meta + arrow keys may appear as ESC ESC O A or whatever.
+  C-z on window systems is now zap-up-to-char, and iconify-frame is moved
+  to C-Z.  ESC ESC is isearch-quit. (isearch-mode.el)
+- document global-{tty,window-system}-map in various places; display them
+  when you do C-h b.
+- fix up function documentation in general for keyboard primitives.
+  e.g. key-bindings now contains a detailed section on the steps prior to
+  looking up in keymaps, i.e. function-key-map,
+  keyboard-translate-table. etc.  define-key and other obvious starting
+  points indicate where to look for more info.
+- eliminate use and mention of grody advertised-undo and
+  deprecated-help. (simple.el, startup.el, picture.el, menubar-items.el)
+
+gnuclient, gnuserv:
+
+- clean up headers a bit.
+- use proper ms win idiom for checking for temp directory (TEMP or TMP, not
+  TMPDIR).
+
+throughout XEmacs sources:
+
+- all #ifdef FILE_CODING statements removed from code.
+
+I/O:
+
+- use PATH_MAX consistently instead of MAXPATHLEN, MAX_PATH, etc.
+- all code that does preprocessor games with C lib I/O functions (open,
+  read) has been removed.  The code has been changed to call the correct
+  function directly.  Functions that accept Intbyte * arguments for
+  filenames and such and do automatic conversion to or from external format
+  will be prefixed qxe...().  Functions that are retrying in case of EINTR
+  are prefixed retry_...().  DONT_ENCAPSULATE is long-gone.
+- never call getcwd() any more.  use our shadowed value always.
+
+Strings:
+
+- new qxe() string functions that accept Intbyte * as arguments.  These
+  work exactly like the standard strcmp(), strcpy(), sprintf(), etc. except
+  for the argument declaration differences.  We use these whenever we have
+  Intbyte * strings, which is quite often.
+- new fun build_intstring() takes an Intbyte *.  also new funs
+  build_msg_intstring (like build_intstring()) and build_msg_string (like
+  build_string()) to do a GETTEXT() before building the
+  string. (elimination of old build_translated_string(), replaced by
+  build_msg_string()).
+- the doprnt.c external entry points have been completely rewritten to be
+  more useful and have more sensible names.  We now have, for example,
+  versions that work exactly like sprintf() but return a malloc()ed string.
+- function intern_int() for Intbyte * arguments, like intern().
+- numerous places throughout code where char * replaced with something
+  else, e.g. Char_ASCII *, Intbyte *, Char_Binary *, etc.  same with
+  unsigned char *, going to UChar_Binary *, etc.
+- code in print.c that handles stdout, stderr rewritten.
+- places that print to stderr directly replaced with stderr_out().
+- new convenience functions write_fmt_string(), write_fmt_string_lisp(), stderr_out_lisp(), write_string().
+
+Allocation, Objects, Lisp Interpreter:
+
+- automatically use "managed lcrecord" code when allocating.  any lcrecord
+  can be put on a free list with free_lcrecord().
+- record_unwind_protect() returns the old spec depth.
+- unbind_to() now takes only one arg.  use unbind_to_1() if you want the
+  2-arg version, with GC protection of second arg.
+- new funs to easily inhibit GC. ({begin,end}_gc_forbidden()) use them in
+  places where gc is currently being inhibited in a more ugly fashion.
+  also, we disable GC in certain strategic places where string data is
+  often passed in, e.g. dfc functions, print functions.
+- major improvements to eistring code, fleshing out of missing funs.
+- make_buffer() -> wrap_buffer() for consistency with other objects; same
+  for make_frame() -> wrap_frame() and make_console() -> wrap_console().
+- better documentation in condition-case.
+- new convenience funs record_unwind_protect_freeing() and
+  record_unwind_protect_freeing_dynarr() for conveniently setting up an
+  unwind-protect to xfree() or Dynarr_free() a pointer.
+
+Init code:
+
+- lots of init code rewritten to be mule-correct.
+
+Processes:
+
+- always call egetenv(), never getenv(), for mule correctness.
+
+s/m files:
+
+- removal of unused DATA_END, TEXT_END, SYSTEM_PURESIZE_EXTRA, HAVE_ALLOCA
+  (automatically determined)
+- removal of vfork references (we no longer use vfork)
+
+
+make-docfile:
+
+- clean up headers a bit.
+- allow .obj to mean equivalent .c, just like for .o.
+- allow specification of a "response file" (a command-line argument
+  beginning with @, specifying a file containing further command-line
+  arguments) -- a standard mswin idiom to avoid potential command-line
+  limits and to simplify makefiles.  use this in xemacs.mak.
+
+debug support:
+
+- (cmdloop.el) new var breakpoint-on-error, which breaks into the C
+  debugger when an unhandled error occurs noninteractively.  useful when
+  debugging errors coming out of complicated make scripts, e.g. package
+  compilation, since you can set this through an env var.
+- (startup.el) new env var XEMACSDEBUG, specifying a Lisp form executed
+  early in the startup process; meant to be used for turning on debug flags
+  such as breakpoint-on-error or stack-trace-on-error, to track down
+  noninteractive errors.
+- (cmdloop.el) removed non-working code in command-error to display a
+  backtrace on debug-on-error.  use stack-trace-on-error instead to get
+  this.
+- (process.c) new var debug-process-io displays data sent to and received
+  from a process.
+- (alloc.c) staticpros have name stored with them for easier debugging.
+- (emacs.c) code that handles fatal errors consolidated and rewritten.
+  much more robust and correctly handles all fatal exits on mswin
+  (e.g. aborts, not previously handled right).
+
+command line (startup.el, emacs.c):
+
+- new option -eol to enable auto EOL detection under non-mule unix.
+- new option -nuni (--no-unicode-lib-calls) to force use of non-Unicode
+  API's under Windows NT, mostly for debugging purposes.
+- help message fixed up (divided into sections), existing problem causing
+  incomplete output fixed, undocumented options documented.
+
+startup.el:
+
+- move init routines from before-init-hook or after-init-hook; just call
+  them directly (init-menubar-at-startup, init-mule-at-startup).
+
+frame.el:
+
+- delete old commented-out code.
+
+Mule changes:
+
+Major:
+
+- the code that handles the details of processing multilingual text has
+  been consolidated to make it easier to extend it.  it has been yanked out
+  of various files (buffer.h, mule-charset.h, lisp.h, insdel.c, fns.c,
+  file-coding.c, etc.) and put into text.c and text.h.  mule-charset.h has
+  also been renamed charset.h.  all long comments concerning the
+  representations and their processing have been consolidated into text.c.
+- major rewriting of file-coding.  it's mostly abstracted into coding
+  systems that are defined by methods (similar to devices and
+  specifiers), with the ultimate aim being to allow non-i18n coding
+  systems such as gzip.  there is a "chain" coding system that allows
+  multiple coding systems to be chained together. (it doesn't yet
+  have the concept that either end of a coding system can be bytes or
+  chars; this needs to be added.)
+- large amounts of code throughout the code base have been Mule-ized,
+  not just Windows code.
+- total rewriting of OS locale code.  it notices your locale at startup and
+  sets the language environment accordingly, and calls setlocale() and sets
+  LANG when you change the language environment.  new language environment
+  properties locale, mswindows-locale, cygwin-locale, native-coding-system,
+  to determine langenv from locale and vice-versa; fix all language
+  environments (lots of language files).  langenv startup code rewritten.
+  many new functions to convert between locales, language environments,
+  etc.
+- major overhaul of the way default values for the various coding system
+  variables are handled.  all default values are collected into one
+  location, a new file code-init.el, which provides a unified mechanism for
+  setting and querying what i call "basic coding system variables" (which
+  may be aliases, parts of conses, etc.) and a mechanism of different
+  configurations (Windows w/Mule, Windows w/o Mule, Unix w/Mule, Unix w/o
+  Mule, unix w/o Mule but w/auto EOL), each of which specifies a set of
+  default values.  we determine the configuration at startup and set all
+  the values in one place. (code-init.el, code-files.el, coding.el, ...)
+- i copied the remaining language-specific files from fsf.  i made
+  some minor changes in certain cases but for the most part the stuff
+  was just copied and may not work.
+- ms windows mule support, with full unicode support.  required font,
+  redisplay, event, other changes.  ime support from ikeyama.
+
+User-Visible Changes:
+
+Lisp-Visible Changes:
+
+- ensure that `escape-quoted' works correctly even without Mule support and
+  use it for all auto-saves. (auto-save.el, fileio.c, coding.el, files.el)
+- new var buffer-file-coding-system-when-loaded specifies the actual coding
+  system used when the file was loaded (buffer-file-coding-system is
+  usually the same, but may be changed because it controls how the file is
+  written out).  use it in revert-buffer (files.el, code-files.el) and in
+  new submenu File->Revert Buffer with Specified Encoding
+  (menubar-items.el).
+- improve docs on how the coding system is determined when a file is read
+  in; improved docs are in both find-file and insert-file-contents and a
+  reference to where to find them is in
+  buffer-file-coding-system-for-read. (files.el, code-files.el)
+- new (brain-damaged) FSF way of calling post-read-conversion (only one
+  arg, not two) is supported, along with our two-argument way, as best we
+  can. (code-files.el)
+- add inexplicably missing var default-process-coding-system.  use it.  get
+  rid of former hacked-up way of setting these defaults using
+  comint-exec-hook.  also fun
+  set-buffer-process-coding-system. (code-process.el, code-cmds.el, process.c)
+- remove function set-default-coding-systems; replace with
+  set-default-output-coding-systems, which affects only the output defaults
+  (buffer-file-coding-system, output half of
+  default-process-coding-system).  the input defaults should not be set by
+  this because they should always remain `undecided' in normal
+  circumstances.  fix prefer-coding-system to use the new function and
+  correct its docs.
+- fix bug in coding-system-change-eol-conversion (code-cmds.el)
+- recognize all eol types in prefer-coding-system (code-cmds.el)
+- rewrite coding-system-category to be correct (coding.el)
+
+Internal Changes:
+
+- Separate encoding and decoding lstreams have been combined into a single
+  coding lstream.  Functions make_encoding_*_stream and
+  make_decoding_*_stream have been combined into make_coding_*_stream,
+  which takes an argument specifying whether encode or decode is wanted.
+- remove last vestiges of I18N3, I18N4 code.
+- ascii optimization for strings: we keep track of the number of ascii
+  chars at the beginning and use this to optimize byte<->char conversion on
+  strings.
+- mule-misc.el, mule-init.el deleted; code in there either deleted,
+  rewritten, or moved to another file.
+- mule.c deleted.
+- move non-Mule-specific code out of mule-cmds.el into code-cmds.el. (coding-system-change-text-conversion; remove duplicate coding-system-change-eol-conversion)
+- remove duplicate set-buffer-process-coding-system (code-cmds.el)
+- add some commented-out code from FSF mule-cmds.el
+  (find-coding-systems-region-subset-p, find-coding-systems-region,
+  find-coding-systems-string, find-coding-systems-for-charsets,
+  find-multibyte-characters, last-coding-system-specified,
+  select-safe-coding-system, select-message-coding-system) (code-cmds.el)
+- remove obsolete alias pathname-coding-system, function set-pathname-coding-system (coding.el)
+- remove coding-system property doc-string; split into `description'
+  (short, for menu items) and `documentation' (long); correct coding system
+  defns (coding.el, file-coding.c, lots of language files)
+- move coding-system-base into C and make use of internal info (coding.el, file-coding.c)
+- move undecided defn into C (coding.el, file-coding.c)
+- use define-coding-system-alias, not copy-coding-system (coding.el)
+- new coding system iso-8859-6 for arabic
+- delete windows-1251 support from cyrillic.el; we do it automatically
+- remove setup-*-environment as per FSF 21
+- rewrite european.el with lang envs for each language, so we can specify the locale
+- fix corruption in greek.el
+- sync japanese.el with FSF 20.6
+- fix warnings in mule-ccl.el
+- move FSF compat Mule fns from obsolete.el to mule-charset.el
+- eliminate unused truncate-string{-to-width}
+- make-coding-system accepts (but ignores) the additional properties
+  present in the fsf version, for compatibility.
+- i fixed the iso2022 handling so it will correctly read in files
+  containing unknown charsets, creating a "temporary" charset which
+  can later be overwritten by the real charset when it's defined.
+  this allows iso2022 elisp files with literals in strange languages
+  to compile correctly under mule.  i also added a hack that will
+  correctly read in and write out the emacs-specific "composition"
+  escape sequences, i.e. ESC 0 through ESC 4.  this means that my
+  workspace correctly compiles the new file devanagari.el that i added.
+- elimination of string-to-char-list (use string-to-list)
+- elimination of junky define-charset
+
+Search:
+
+- make regex routines reentrant, since they're sometimes called
+  reentrantly. (see regex.c for a description of how.) all global variables
+  used by the regex routines get pushed onto a stack by the callers before
+  being set, and are restored when finished.  redo the preprocessor flags
+  controlling REL_ALLOC in conjunction with this.
+
+Selection:
+
+- fix msw selection code for Mule.  proper encoding for
+  RegisterClipboardFormat.  store selection as CF_UNICODETEXT, which will
+  get converted to the other formats.  don't respond to destroy messages
+  from EmptyClipboard().
+
+Menubar:
+
+- move menu-splitting code (menu-split-long-menu, etc.) from font-menu.el
+  to menubar-items.el and redo its algorithm; use in various items with
+  long generated menus; rename to remove `font-' from beginning of
+  functions but keep old names as aliases
+- new fn menu-sort-menu
+- new items Open With Specified Encoding, Revert Buffer with Specified Encoding
+- split Mule menu into Encoding (non-Mule-specific; includes new item to
+  control EOL auto-detection) and International submenus on Options,
+  International on Help
+- redo items Grep All Files in Current Directory {and Below} using stuff
+  from sample init.el
+- Debug on Error and friends now affect current session only; not saved
+- maybe-add-init-button -> init-menubar-at-startup and call explicitly from startup.el
+- don't use charset-registry in msw-font-menu.el; it's only for X
+
+Process:
+
+- Move setenv from packages; synch setenv/getenv with 21.0.105
+
+Unicode support:
+
+- translation tables added in etc/unicode
+- new files unicode.c, unicode.el containing unicode coding systems and
+  support; old code ripped out of file-coding.c
+- translation tables read in at startup (NEEDS WORK TO MAKE IT MORE EFFICIENT)
+- support CF_TEXT, CF_UNICODETEXT in select.el
+- encapsulation code added so that we can support both Windows 9x and NT in
+  a single executable, determining at runtime whether to call the Unicode
+  or non-Unicode API.  encapsulated routines in intl-encap-win32.c
+  (non-auto-generated) and intl-auto-encap-win32.[ch] (auto-generated).
+  code generator in lib-src/make-mswin-unicode.pl.  changes throughout the
+  code to use the wide structures (W suffix) and call the encapsulated
+  Win32 API routines (qxe prefix).  calling code needs to do proper
+  conversion of text using new coding systems Qmswindows_tstr,
+  Qmswindows_unicode, or Qmswindows_multibyte. (the first points to one of
+  the other two.)
+
+
+File-coding rewrite:
+
+The coding system code has been majorly rewritten.  It's abstracted into
+coding systems that are defined by methods (similar to devices and
+specifiers).  The types of conversions have also been
+generalized. Formerly, decoding always converted bytes to characters and
+encoding the reverse (these are now called "text file converters"), but
+conversion can now happen either to or from bytes or characters.  This
+allows coding systems such as `gzip' and `base64' to be written.  When
+specifying such a coding system to an operation that expects a text file
+converter (such as reading in or writing out a file), the appropriate
+coding systems to convert between bytes and characters are automatically
+inserted into the conversion chain as necessary.  To facilitate creating
+such chains, a special coding system called "chain" has been created, which
+chains together two or more coding systems.
+
+Encoding detection has also been abstracted.  Detectors are logically
+separate from coding systems, and each detector defines one or more
+categories. (For example, the detector for Unicode defines categories such
+as UTF-8, UTF-16, UCS-4, and UTF-7.) When a particular detector is given a
+piece of text to detect, it determines likeliness values (seven of them,
+from 3 [most likely] to -3 [least likely]; specific criteria are defined
+for each possible value).  All detectors are run in parallel on a
+particular piece of text, and the results tabulated together to determine
+the actual encoding of the text.
+
+Encoding and decoding are now completely parallel operations, and the
+former "encoding" and "decoding" lstreams have been combined into a single
+"coding" lstream.  Coding system methods that were formerly split in such a
+fashion have also been combined.
+

--- a/ChangeLog	Fri Mar 08 13:33:14 2002 +0000
+++ b/ChangeLog	Wed Mar 13 08:54:06 2002 +0000
@@ -141,13 +141,13 @@
 
 2001-09-19  Ben Wing  <ben@xemacs.org>
 
-	* configure.in (USAGE_ERROR):
-	* configure.in (CANONICALIZE_PATH):
-	* configure.in (XE_COMPUTE_RUNPATH):
-
-	The great integral types renaming.
-
-	Please see the 2001-09-19 entry in src/ChangeLog for the full details.
+	* etc\TUTORIAL.de: Translate TERMINOLOGY section for TUTORIAL.de,
+	change menu entry separator from / to ->.  Change SPC to <Space>.
+
+2001-10-07  Adrian Aichner  <adrian@xemacs.org>
+
+	* etc\TUTORIAL.de: Update of TUTORIAL.de according to Ben's
+	Updates and Syncing with Emacs 21.0.106.
 
 2001-09-17  Ben Wing  <ben@xemacs.org>
 

--- /dev/null	Thu Jan 01 00:00:00 1970 +0000
+++ b/README.ben-mule-21-5	Wed Mar 13 08:54:06 2002 +0000
@@ -0,0 +1,1587 @@
+oct 27, 2001:
+
+-------- proposal for better buffer-switching commands:
+
+implement what VC++ currently has.  you have a single "switch" command like
+CTRL-TAB, which as long as you hold the CTRL button down, brings successive
+buffers that are "next in line" into the current position, bumping the rest
+forward.  once you release the CTRL key, the chain is broken, and further
+CTRL-TABs will start from the beginning again.  this way, frequently used
+buffers naturally move toward the front of the chain, and you can switch
+back and forth between two buffers using CTRL-TAB.  the only thing about
+CTRL-TAB is it's a bit awkward.  the way to implement is to have
+modifier-up strokes fire off a hook, like modifier-up-hook.  this is driven
+by event dispatch, so there are no synchronization issues.  when C-tab is
+pressed, the binding function does something like set a one-shot handler on
+the modifier-up-hook (perhaps separate hooks for separate modifiers?).
+
+to do this, we'd also want to change the buffer tabs so that they maintain
+their own order.  in particular, they start out synched to the regular
+order, but as you make changes, you don't want the tabs to change
+order. (in fact, they may already do this.) selecting a particular buffer
+from the buffer tabs DOES make the buffer go to the head of the line.  the
+invariant is that if the tabs are displaying X items, those X items are the
+first X items in the standard buffer list, but may be in a different
+order. (it looks like the tabs may already implement all of this.)
+
+oct 26, 2001:
+
+necessary testing/changes:
+
+- test all eol detection stuff under windows w/ and w/o mule, unix w/ and
+  w/o mule. (test configure flag, command-line flag, menu option) may need
+  a way of pretending to be unix under cygwin.
+- test under windows w/ and w/o mule, cygwin w/ and w/o mule, cygwin x
+  windows w/ and w/o mule.
+- test undecided-dos/unix/mac.
+- check ESC ESC works as isearch-quit under TTY's.
+- test coding-system-base and all its uses (grep for them).
+- menu item to revert to most recent auto save.
+- consider renaming build_string -> build_intstring and build_c_string to
+  build_string. (consistent with build_msg_string et al; many more
+  build_c_string than build_string)
+
+oct 20, 2001:
+
+fixed problem causing crash due to invalid internal-format data, fixed an
+existing bug in valid_char_p, and added checks to more quickly catch when
+invalid chars are generated.  still need to investigate why
+mswindows-multibyte is being detected.
+
+i now see why -- we only process 65536 bytes due to a constant
+MAX_BYTES_PROCESSED_FOR_DETECTION.  instead, we should have no limit as
+long as we have a seekable stream.  we also need to write
+stderr_out_lisp(), used in the debug info routines i wrote.
+
+check once more about DEBUG_XEMACS.  i think debugging info should be
+ON by default.  make sure it is.  check that nothing untoward will result
+in a production system, e.g. presumably assert()s should not really abort().
+(!! Actually, this should be runtime settable!  Use a variable for this, and
+it can be set using the same XEMACSDEBUG method.  In fact, now that I think
+of it, I'm sure that debugging info should be on always, with runtime ways
+of turning on or off any funny behavior.)
+
+oct 19, 2001:
+
+fixed various bugs preventing packages from being able to be built.  still
+another bug, with psgml/etc/cdtd/docbook, which contains some strange
+characters starting around char pos 110,000.  It gets detected as
+mswindows-multibyte (wrong! why?) and then invalid internal-format data is
+generated.  need to fix mswindows-multibyte (and possibly add something
+that signals an error as well; need to work on this error-signalling
+mechanism) and figure out why it's getting detected as such.  what i should
+do is add a debug var that outputs blow-by-blow info of the detection
+process.
+
+oct 9, 2001:
+
+the stuff with global-window-system-map doesn't appear to work.  in any
+case it needs better documentation. [DONE]
+
+M-home, M-end do work, but cause cl-macs to get loaded.  why?
+
+oct 8, 2001:
+
+finished the coding system changes and they finally work!
+
+need to implement undecided-unix/dos/mac.  they should be easy to do; it
+should be enough to specify an eol-type but not do-eol, but check this.
+
+consider making the standard naming be foo-lf/crlf/cr, with unix/dos/mac as
+aliases.
+
+print methods for coding systems should include some of the generic
+properties. (also then fix print_..._within_print_method). [DONE]
+
+in a little while, go back and delete the text-file-wrapper-coding-system
+code. (it'll be in CVS if necessary to get at it.) [DONE]
+
+need to verify at some point that non-text-file coding systems work
+properly when specified.  when gzip is working, this would be a good test
+case. (and consider creating base64 as well!)
+
+remove extra crap from coding-system-category that checks for chain coding
+systems. [DONE]
+
+perhaps make a primitive that gets at coding-system-canonical. [DONE]
+
+need to test cygwin, compiling the mule packages, get unix-eol stuff
+working.  frank from germany says he doesn't see a lisp backtrace when he
+gets an error during temacs?  verify that this actually gets outputted.
+
+consider putting the current language on the modeline, mousable so it can
+be switched.  also consider making the coding system be mousable and the
+line number (pick a line) and the percentage (pick a percentage).
+
+oct 6, 2001:
+
+added code so that debug_print() will output a newline to the mswindows
+debugging output, not just the console.  need to test. [DONE]
+
+working on problem where all files are being detected as binary.  the
+problem may be that the undecided coding system is getting wrapped with an
+auto-eol coding system, which it shouldn't be -- but even in this
+situation, we should get the right results!  check the
+canonicalize-after-coding methods.  also, determine_real_coding_system
+appears to be getting called even when we're not detecting encoding.  also,
+undecided needs a print method to show its params, and chain needs to be
+updated to show canonicalize_after_coding.  check others as well. [DONE]
+
+oct 5, 2001:
+
+finished up coding system changes, testing.
+
+errors byte-compiling files in iso-2022-7-bit.  perhaps it's not correctly
+detecting the encoding?
+
+noticed a problem in the dfc macros: we call
+get_coding_system_for_text_file with eol_wrap == 1, to allow for
+auto-detection of the eol type; but this defeats the check and
+short-circuit for unicode.
+
+still need to implement calling determine_real_coding_system() for
+non-seekable streams.  to implement correctly, we need to do our own
+buffering. [DONE, BUT WITHOUT BUFFERING]
+
+oct 4, 2001:
+
+implemented most stuff below.
+
+need to finish up changes to make_coding_system_1. (i changed the way
+internal coding systems were handled; i need to create subsidiaries for all
+types of coding systems, not just text ones.) there's a nasty xfree() crash
+i was hitting; perhaps it'll go away once all stuff has been rewritten.
+
+check under cygwin to make sure that when an error occurs during loadup, a
+backtrace is output.
+
+as soon as andy releases his new setup, we should put it onto various
+standard windows software repositories.
+
+oct 3, 2001:
+
+added global-tty-map and global-window-system-map.  add some stuff to the
+maps, e.g. C-x ESC for repeat vs. C-x ESC ESC on TTY's, and of course ESC
+ESC on window systems vs. ESC ESC ESC on TTY's. [TEST]
+
+was working on integrating the two help-for-tutorial versions (mule,
+non-mule). [DONE, but test under non-Mule]
+
+was working on the file-coding changes.  need to think more about
+text-file-wrapper.  conclusion i think is that
+get_coding_system_for_text_file should wrap using a special coding system
+type called a text-file-wrapper, which inherits from chain, and implements
+canonicalize-after-decoding to just return the unwrapped coding system.  We
+need to implement inheritance of coding systems, which will certainly come
+in extremely useful when coding systems get implemented in Lisp, which
+should happen at some point. (see existing docs about this.)  essentially,
+we have a way of declaring that we inherit from some system, and the
+appropriate data structures get created, perhaps just an extra inheritance
+pointer.  but when we create the coding system, the extra data needs to be
+a stretchy array of offsets, pointing to the type-specific data for the
+coding system type and all its parents.  that means that in the methods
+structure for a coding system (which perhaps should be expanded beyond
+method, it's just a "class structure") is the index in these arrays of
+offsets.  CODING_SYSTEM_DATA() can take any of the coding system classes
+(rename type to class!) that make up this class.  similarly, a coding
+system class inherits its methods from the class above unless specifying
+its own method, and can call the superclass method at any point by either
+just invoking its name, or conceivably by some macro like
+
+CALL_SUPER (method, (args))
+
+similar mods would have to be made to coding stream structures.
+
+perhaps for the immediate we can just sort of fake things like we currently
+do with undecided calling some stuff from chain.
+
+oct 2, 2001:
+
+need to implement support for iso-8859-15, i.e. iso-8859-1 + euro symbol.
+figure out how to fall back to iso-8859-1 as necessary.
+
+leave the current bindings the way they are for the moment, but bump off
+M-home and M-end (hardly used), and substitute my buffer movement stuff
+there. [DONE, but test]
+
+there's something to be said for combining block of 6 and paragraph,
+esp. if we make the definition of "paragraph" be so that it skips by 6 when
+within code.  hmm.
+
+eliminate advertised-undo crap, and similar hacks. [DONE]
+
+think about obsolete stuff to be eliminated.  think about eliminating or
+dimming obsolete items from hyper-apropos and something similar in
+completion buffers.
+
+sep 30, 2001:
+
+synched up the tutorials with FSF 21.0.105.  was rewriting them to favor
+the cursor keys over the older C-p, etc. keys.
+
+Got thinking about key bindings again.
+
+(1) I think that M-up/down and M-C-up/down should be reversed.  I use
+    scroll-up/down much more often than motion by paragraph.
+
+(2) Should we eliminate move by block (of 6) and subsitute it for
+    paragraph?  This would have the advantage that I could make bindings
+    for buffer change (forward/back buffer, perhaps M-C-up/down.  with
+    shift, M-C-S-up/down only goes within the same type (C files, etc.).
+    alternatively, just bump off beginning-of-defun from C-M-home, since
+    it's on C-M-a already.
+
+need someone to go over the other tutorials (five new ones, from FSF
+21.0.105) and fix them up to correspond to the english one.
+
+shouldn't shift-motion work with C-a and such as well as arrows?
+
+sep 29, 2001:
+
+charcount_to_bytecount can also be made to scream -- as can scan_buffer,
+buffer_mule_signal_inserted_region, others?  we should start profiling
+though before going too far down this line.
+
+Debug code that causes no slowdown should in general remain in the
+executable even in the release version because it may be useful (e.g. for
+people to see the event output).  so DEBUG_XEMACS should be rethought.
+things like use of msvcrtd.dll should be controlled by error_checking on.
+maybe DEBUG_XEMACS controls general debug code (e.g. use of msvcrtd.dll,
+asserts abort, error checking), and the actual debugging code should remain
+always, or be conditonalized on something else
+(e.g. DEBUGGING_FUNS_PRESENT).
+
+doc strings in dumped files are displayed with an extra blank line between
+each line.  presumably this is recent?  i assume either the change to
+detect-coding-region or the double-wrapping mentioned below.
+
+error with coding-system-property on iso-2022-jp-dos.  problem is that that
+coding system is wrapped, so its type shows up as chain, not iso-2022.
+this is a general problem, and i think the way to fix it is to in essence
+do late canonicalization -- similar in spirit to what was done long ago,
+canonicalize_when_code, except that the new coding system (the wrapper) is
+created only once, either when the original cs is created or when first
+needed.  this way, operations on the coding system work like expected, and
+you get the same results as currently when decoding/encoding.  the only
+thing tricky is handling canonicalize-after-coding and the ever-tricky
+double-wrapping problem mentioned below.  i think the proper solution is to
+move the autodetection of eol into the main autodetect type.  it can be
+asked to autodetect eol, coding, or both.  for just coding, it does like it
+currently does.  for just eol, it does similar to what it currently does
+but runs the detection code that convert-eol currently does, and selects
+the appropriate convert-eol system.  when it does both eol and coding, it
+does something on the order of creating two more autodetect coding systems,
+one for eol only and one for coding only, and chains them together.  when
+each has detected the appropriate value, the results are combined.  this
+automatically eliminates the double-wrapping problem, removes the need for
+complicated canonicalize-after-coding stuff in chain, and fixes the problem
+of autodetect not having a seekable stream because hidden inside of a
+chain. (we presume that in the both-eol-and-coding case, the various
+autodetect coding streams can communicate with each other appropriately.)
+
+also, we should solve the problem of internal coding systems floating
+around and clogging up the list simply by having an "internal" property on
+cs's and an internal param to coding-system-list (optional; if not given,
+you don't get the internal ones). [DONE]
+
+we should try to reduce the size of the from-unicode tables (the dominant
+memory hog in the tables).  one obvious thing is to not store a whole
+emchar as the mapped-to value, but a short that encodes the octets. [DONE]
+
+sep 28, 2001:
+
+need to merge up to latest in trunk.
+
+add unicode charsets for all non-translatable unicode chars; probably want
+to extend the concept of charsets to allow for dimension 3 and dimension 4
+charsets.  for the moment we should stick with just dimension 3 charsets;
+otherwise we run past the current maximum of 4 bytes per emchar. (most code
+would work automatically since it uses MAX_EMCHAR_LEN; the trickiness is in
+certain code that has intimate knowledge of the representation.
+e.g. bufpos_to_bytind() has to multiply or divide by 1, 2, 3, or 4,
+and has special ways of handling each number.  with 5 or 6 bytes per char,
+we'd have to change that code in various ways.) 96x96x96 = 884,000 or so,
+so with two 96x96x96 charsets, we could tackle all Unicode values
+representable by UTF-16 and then some -- and only these codepoints will
+ever have assigned chars, as far as we know.  
+
+need an easy way of showing the current language environment.  some menus
+need to have the current one checked or whatever. [DONE]
+
+implement unicode surrogates.
+
+implement buffer-file-coding-system-when-loaded -- make sure find-file,
+revert-file, etc. set the coding system [DONE]
+
+verify all the menu stuff [DONE]
+
+implemented the entirely-ascii check in buffers.  not sure how much gain
+it'll get us as we already have a known range inside of which is constant
+time, and with pure-ascii files the known range spans the whole buffer.
+improved the comment about how bufpos-to-bytind and vice-versa work. [DONE]
+
+fix double-wrapping of convert-eol: when undecided converts itself to
+something with a non-autodetect eol, it needs to tell the adjacent
+convert-eol to reduce itself to nothing.
+
+need menu item for find file with specified encoding. [DONE]
+
+renamed coding systems mswindows-### to windows-### to follow the standard
+in rfc1345. [DONE]
+
+implemented coding-system-subsidiary-parent [DONE]
+HAVE_MULE -> MULE in files in nt/ so that depend checking works [DONE]
+
+need to take the smarter search-all-files-in-dir stuff from my sample init
+file and put it on the grep menu [DONE]
+
+added item for revert w/specified encoding; mostly works, but needs fixes.
+in particular, you get the correct results, but buffer-file-coding-system
+does not reflect things right.  also, there are too many entries.  need to
+split into submenus.  there is already split code out there; see if it's
+generalized and if not make it so.  it should only split when there's more
+than a specified number, and when splitting, split into groups of a
+specified size, not into a specified number of groups. [DONE]
+
+too many entries in the langenv menus; need to split. [DONE]
+
+sep 27, 2001:
+
+NOTE: M-x grep for make-string causes crash now.  something definitely to
+do with string changes.  check very carefully the diffs and put in those
+sledgehammer checks. [DONE]
+
+fix font-lock bug i introduced. [DONE]
+
+added optimization to strings (keeps track of # of bytes of ascii at the
+beginning of a string).  perhaps should also keep an all-ascii flag to deal
+with really large (> 2 MB) strings.  rewrite code to count ascii-begin to
+use the 4-or-8-at-a-time stuff in bytecount_to_charcount.
+
+Error: M-q is causing Invalid Regexp error on the above paragraph.  It's
+not in working.  I assume it's a side effect of the string stuff.  VERIFY!
+Write sledgehammer checks for strings. [DONE]
+
+revamped the locale/init stuff so that it tries much harder to get things
+right.  should test a bit more.  in particular, test out Describe Language
+on the various created environments and make sure everything looks right.
+
+should change the menus: move the submenus on Edit->Mule directly under
+Edit.  add a menu entry on File to say "Reload with specified encoding ->".
+[DONE]
+
+Also Find File with specified encoding -> Also entry to change the EOL
+settings for Unix, and implement it.
+
+decode-coding-region isn't working because it needs to insert a binary
+(char->byte) converter. [DONE]
+
+chain should be rearranged to be in decoding order; similar for
+source/sink-type, other things?
+
+the detector should check for a magic cookie even without a seekable input.
+(currently its input is not seekable, because it's hidden within a chain.
+#### See what we can do about this.)
+
+provide a way to display various settings, e.g. the current category
+mappings and priority (see mule-diag; get this working so it's in the
+path); also a way to print out the likeliness results from a detection,
+perhaps a debug flag.
+
+problem with `env', which causes path issues due to `env' in packages.
+move env code to process, sync with fsf 21.0.105, check that the autoloads
+in `env' don't cause problems. [DONE]
+
+8-bit iso2022 detection appears broken; or at least, mule-canna.c is not so
+detected.
+
+sep 25, 2001:
+
+something else to do is review the font selection and fix it so that (e.g.) 
+JISX-0212 can be displayed.
+
+also, text in widgets needs to be drawn by us so that the correct fonts
+will be displayed even in multi-lingual text.
+
+sep 24, 2001:
+
+the detection system is now properly abstracted.  the detectors have been
+rewritten to include multiple levels of abstraction.  now we just need
+detectors for ascii, binary, and latin-x, as well as more sophisticated
+detectors in general and further review of the general algorithm for doing
+detection. (#### Is this written up anywhere?) after that, consider adding
+error-checking to decoding (VERY IMPORTANT) and verifying the binary
+correctness of things under unix no-mule.
+
+sep 23, 2001:
+
+began to fix the detection system -- adding multiple levels of likelihood
+and properly abstracting the detectors.  the system is in place except for
+the abstraction of the detector-specific data out of the struct
+detection_state.  we should get things working first before tackling that
+(which should not be too hard).  i'm rewriting algorithms here rather than
+just converting code, so it's harder.  mostly done with everything, but i
+need to review all detectors except iso2022 and make them properly follow
+the new way.  also write a no-conversion detector.  also need to look into
+the `recode' package and see how (if?) they handle detection, and maybe
+copy some of the algorithms.  also look at recent FSF 21.0 and see if their
+algorithms have improved.
+
+sep 22, 2001:
+
+fixed gc bugs from yesterday.
+fixed truename bug.
+close/finalize stuff works.
+eliminated notyet stuff in syswindows.h.
+eliminated special code in tstr_to_c_string.
+fixed pdump problems. (many of them, mostly latent bugs, ugh)
+fixed cygwin sscanf problems in parse-unicode-translation-table. (NOT a
+sscanf bug, but subtly different behavior w.r.t. whitespace in the format
+string, combined with a debugger that sucks ROCKS!! and consistently
+outputs garbage for variable values.)
+main stuff to test is the handling of EOF recognition vs. binary
+(i.e. check what the default settings are under Unix).  then we may have
+something that WORKS on all platforms!!!  (Also need to test Windows
+non-Mule)
+
+sep 21, 2001:
+
+finished redoing the close/finalize stuff in the lstream code.  but i
+encountered again the nasty bug mentioned on sep 15 that disappeared on its
+own then.  the problem seems to be that the finalize method of some of the
+lstreams is calling Lstream_delete(), which calls free_managed_lcrecord(),
+which is a no-no when we're inside of garbage-collection and the object
+passed to free_managed_lcrecord() is unmarked, and about to be released by
+the gc mechanism -- the free lists will end up with xfree()d objects on
+them, which is very bad.  we need to modify free_managed_lcrecord() to
+check if we're in gc and the object is unmarked, and ignore it rather than
+move it to the free list. [DONE]
+
+(#### What we really need to do is do what Java and C# do w.r.t. their
+finalize methods: For objects with finalizers, when they're about to be
+freed, leave them marked, run the finalizer, and set another bit on them
+indicating that the finalizer has run.  Next GC cycle, the objects will
+again come up for freeing, and this time the sweeper notices that the
+finalize method has already been called, and frees them for good (provided
+that a finalize method didn't do something to make the object alive
+again).)
+
+sep 20, 2001:
+
+redid the lstream code so there is only one coding stream.  combined the
+various doubled coding stream methods into one; i'm a little bit unsure of
+this last part, though, as the results of combining the two together seem
+unclean.  got it to compile, but it crashes in loadup.  need to go through
+and rehash the close vs. finalize stuff, as the problem was stuff getting
+freed too quickly, before the canonicalize-after-decoding was run.  should
+eliminate entirely CODING_STATE_END and use a different method (close
+coding stream).  rewrite to use these two.  make sure they're called in the
+right places.  Lstream_close on a stream should *NOT* do finalizing.
+finalize only on delete. [DONE]
+
+in general i'd like to see the flags eliminated and converted to
+bit-fields.  also, rewriting the methods to take advantage of rejecting
+should make it possible to eliminate much of the state in the various
+methods, esp. including the flags.  need to test this is working, though --
+reduce the buffer size down very low and try files with only CRLF's in
+them, with one offset by a byte from the other, and see if we correctly
+handle rejection.
+
+still have the problem with incorrectly truenaming files.
+
+
+sep 19, 2001:
+
+bug reported: crash while closing lstreams.
+
+the lstream/coding system close code needs revamping.  we need to document
+that order of closing lstreams is very important, and make sure we're
+consistent.  furthermore, chain and undecided lstreams need to close their
+underneath lstreams when they receive the EOF signal (there may be data in
+the underneath streams waiting to come out), not when they themselves are
+closed. [DONE]
+
+(if only we had proper inheritance.  i think in any case we should
+simulate it for the chain coding stream -- write things in such a way that
+undecided can use the chain coding stream and not have to duplicate
+anything itself.)
+
+in general we need to carefully think through the closing process to make
+sure everything always works correctly and in the right order.  also check
+very carefully to make sure there are no dangling pointers to deleted
+objects floating around.
+
+move the docs for the lstream functions to the functions themselves, not
+the header files.  document more carefully what exactly Lstream_delete()
+means and how it's used, what the connections are between Lstream_close(),
+Lstream_delete(), Lstream_flush(), lstream_finalize, etc. [DONE]
+
+additional error-checking: consider deadbeefing the memory in objects
+stored in lcrecord free lists; furthermore, consider whether lifo or fifo
+is correct; under error-checking, we should perhaps be doing fifo, and
+setting a minimum number of objects on the lists that's quite large so that
+it's highly likely that any erroneous accesses to freed objects will go
+into such deadbeefed memory and cause crashes.  also, at the earliest
+available opportunity, go through all freed memory and check for any
+consistency failures (overwrites of the deadbeef), crashing if so.  perhaps
+we could have some sort of id for each block, to easier trace where the
+offending block came from. (all of these ideas are present in the debug
+system malloc from VC++, plus more stuff.) there's similar code i wrote
+sitting somewhere (in free-hook.c? doesn't appear so. we need to delete the
+blocking stuff out of there!).  also look into using the debug system
+malloc from VC++, which has lots of cool stuff in it. we even have the
+sources.  that means compiling under pdump, which would be a good idea
+anyway.  set it as the default. (but then, we need to remove the
+requirement that Xpm be a DLL, which is extremely annoying.  look into
+this.)
+
+test the windows code page coding systems recently created.
+
+problems reading my mail files -- 1personal appears to hang, others come up
+with lots of ^M's.  investigate.
+
+test the enum functions i just wrote, and finish them.
+
+still pdump problems.
+
+sep 18, 2001:
+
+critical-quit broken sometime after aug 25.
+
+-- fixed critical quit.
+-- fixed process problems.
+-- print routines work. (no routine for ccl, though)
+-- can read and write unicode files, and they can still be read by some
+   other program
+-- defaults should come up correctly -- mswindows-multibyte is general.
+
+still need to test matej's stuff.
+seems ok with multibyte stuff but needs more testing.
+
+sep 17, 2001:
+
+!!!!! something broken with processes !!!!! cannot send mail anymore.  must
+investigate.
+
+sep 17, 2001:
+
+on mon/wed nights, stop *BEFORE* 11pm.  Otherwise i just start getting
+woozy and can't concentrate.
+
+just finished getting assorted fixups to the main branch committed, so it
+will compile under C++ (Andy committed some code that broke C++ builds).
+cup'd the code into the fixtypes workspace, updated the tags appropriately.
+i've created the appropriate log message, sitting in fixtypes.txt in
+/src/xemacs; perhaps it should go into a README.  now i just have to build
+on everything (it's currently building), verify it's ok, run patcher-mail,
+commit, send.
+
+my mule ws is also very close.  need to:
+
+-- test the new print routines.
+-- test it can read and write unicode files, and they can still be read by
+   some other program.
+-- try to see if unicode can be auto-detected properly.
+-- test it can read and write multibyte files in a few different formats.
+   currently can't recognize them, but if you set the cs right, it should
+   work.
+-- examine the test files sent by matej and see if we can handle them.
+
+sep 15, 2001:
+
+more eol fixing.  this stuff is utter crap.
+
+currently we wrap coding systems with convert-eol-autodetect when we create
+them in make_coding_system_1.  i had a feeling that this would be a
+problem, and indeed it is -- when autodetecting with `undecided', for
+example, we end up with multiple layers of eol conversion.  to avoid this,
+we need to do the eol wrapping *ONLY* when we actually retrieve a coding
+system in places such as insert-file-contents.  these places are
+insert-file-contents, load, process input, call-process-internal,
+encode/decode/detect-coding-region, database input, ...
+
+(later) it's fixed, and things basically work.  NOTE: for some reason,
+adding code to wrap coding systems with convert-eol-lf when eol-type == lf
+results in crashing during garbage collection in some pretty obscure place
+-- an lstream is free when it shouldn't be.  this is a bad sign.  i guess
+something might be getting initialized too early?
+
+we still need to fix the canonicalization-after-decoding code to avoid
+problems with coding systems like `internal-7' showing up.  basically, when
+eol==lf is detected, nil should be returned, and the callers should handle
+it appropriately, eliding when necessary.  chain needs to recognize when
+it's got only one (or even 0) items in the chain, and elide out the chain.
+
+sep 11, 2001: the day that will live in infamy.
+
+rewrite of sep 9 entry about formats:
+
+when calling make-coding-system, the name can be a cons of (format1 .
+format2), specifying that it decodes format1->format2 and encodes the other
+way.  if only one name is given, that is assumed to be format1, and the
+other is either `external' or `internal' depending on the end type.
+normally the user when decoding gives the decoding order in formats, but
+can leave off the last one, `internal', which is assumed.  a multichain
+might look like gzip|multibyte|unicode, using the coding systems named
+`gzip', `(unicode . multibyte)' and `unicode'.  the way this actually works
+is by searching for gzip->multibyte; if not found, look for gzip->external
+or gzip->internal. (In general we automatically do conversion between
+internal and external as necessary: thus gzip|crlf does the expected, and
+maps to gzip->external, external->internal, crlf->internal, which when
+fully specified would be gzip|external:external|internal:crlf|internal --
+see below.)  To forcibly fit together two converters that have explicitly
+specified and incompatible names (say you have unicode->multibyte and
+iso8859-1->ebcdic and you know that the multibyte and iso8859-1 in this
+case are compatible), you can force-cast using :, like this:
+ebcdic|iso8859-1:multibyte|unicode. (again, if you force-cast between
+internal and external formats, the conversion happens automatically.)
+
+
+sep 10, 2001:
+
+moved the autodetection stuff (both codesys and eol) into particular coding
+systems -- `undecided' and `convert-eol' (type == `autodetect').  needs
+lots of work.  still need to search through the rest of the code and find
+any remaining auto-detect code and move it into the undecided coding
+system.  need to modify make-coding-system so that it spits out
+auto-detecting versions of all text-file coding systems unless we say not
+to.  need eliminate entirely the EOF flag from both the stream info and the
+coding system; have only the original-eof flag.  in
+coding_system_from_mask, need to check that the returned value is not of
+type `undecided', falling back to no-conversion if so.  also need to make
+sure we wrap everything appropriate for text-files -- i removed the
+wrapping on set-coding-category-list or whatever (need to check all those
+files to make sure all wrapping is removed).  need to review carefully the
+new code in `undecided' to make sure it works are preserves the same logic
+as previously.  need to review the closing and rewinding behavior of chain
+and undecided (same -- should really consolidate into helper routines, so
+that any coding system can embed a chain in it) -- make sure the dynarr's
+are getting their data flushed out as necessary, rewound/closed in the
+right order, no missing steps, etc.
+
+also split out mule stuff into mule-coding.c.  work done on
+configure/xemacs.mak/Makefiles not done yet.  work on emacs.c/symsinit.h to
+interface with the new init functions not done yet.
+
+also put in a few declarations of the way i think the abstracted detection
+stuff ought to go.  DON'T WORK ON THIS MORE UNTIL THE REST IS DEALT WITH
+AND WE HAVE A WORKING XEMACS AGAIN WITH ALL EOL ISSUES NAILED.
+
+really need a version of cvs-mods that reports only the current directory.
+WRITE THIS!  use it to implement a better cvs-checkin.
+
+sep 9, 2001:
+
+implemented a gzip coding system.  unfortunately, doesn't quite work right
+because it doesn't handle the gzip headers -- it just reads and writes raw
+zlib data.  there's no function in the library to skip past the header, but
+we do have some code out of the library that we can snarf that implements
+header parsing.  we need to snarf that, store it, and output it again at
+the beginning when encoding.  in the process, we should create a "get next
+byte" macro that bails out when there are no more.  using this, we set up a
+nice way of doing most stuff statelessly -- if we have to bail, we reject
+everything back to the sync point.  also need to fix up the autodetection
+of zlib in configure.in.
+
+BIG problems with eol.  finished up everything i thought i would need to
+get eol stuff working, but no -- when you have mswindows-unicode, with its
+eol set to autodetect, the detection routines themselves do the autodetect
+(first), and fail (they report CR on CRLF because of the NULL byte between
+the CR and the LF) since they're not looking at ascii data.  with a chain
+it's similarly bad. for mswindows-multibyte, for example, which is a chain
+unicode->unicode-to-multibyte, autodetection happens inside of the chain,
+both when unicode and unicode-to-multibyte are active.  we could twiddle
+around with the eol flags to try to deal with this, but it's gonna be a big
+mess, which is exactly what we're trying to avoid.  what we basically want
+is to entirely rip out all EOL settings from either the coding system or
+the stream (yes, there are two!  one might saw autodetect, and then the
+stream contains the actual detected value).  instead, we simply create an
+eol-autodetect coding system -- or rather, it's part of the convert-eol
+coding system.  convert-eol, type = autodetect, does autodetection the
+first time it gets data sent to it to decode, and thereafter sets a stream
+parameter indicating the actual eol type for this stream.  this means that
+all autodetect coding systems, as created by `make-coding-system', really
+are chains with a convert-eol at the beginning.  only subsidiary xxx-unix
+has no wrapping at all.  this should allow eof detection of gzip, unicode,
+etc.  for that matter, general autodetection should be entirely
+encapsulated inside of the `autodetect' coding system, with no
+eol-autodetection -- the chain becomes convert-eol (autodetect) ->
+autodetect or perhaps backwards.  the generic autodetect similarly has a
+coding-system in its stream methods, and needs somehow or other to insert
+the detected coding-system into the chain.  either it contains a chain
+inside of it (perhaps it *IS* a chain), or there's some magic involving
+canonicalization-type switcherooing in the middle of a decode.  either way,
+once everything is good and done and we want to save the coding system so
+it can be used later, we need to do another sort of canonicalization --
+converting auto-detect-type coding systems into the detected systems.
+again, a coding-system method, with some magic currently so that
+subsidiaries get properly used rather than something that's new but
+equivalent to subsidiaries. (#### perhaps we could use a hash table to
+avoid recreating coding systems when not necessary.  but that would require
+that coding systems be immutable from external, and i'm not sure that's the
+case.)
+
+i really think, after all, that i should reverse the naming of everything
+in chain and source-sink-type -- they should be decoding-centric.  later
+on, if/when we come up with the proper way to make it totally symmetrical,
+we'll be fine whether before then we were encoding or decoding centric.
+
+
+sep 9, 2001:
+
+investigated eol parameter.
+implemented handling in make-coding-system of eol-cr and eol-crlf.
+fixed calls everywhere to Fget_coding_system / Ffind_coding_system to
+reject non-char->byte coding systems.
+
+still need to handle "query eol type using coding-system-property" so it
+magically returns the right type by parsing the chain.
+
+no work done on formats, as mentioned below.  we should consider using :
+instead of || to indicate casting.
+
+early sep 9, 2001:
+
+renamed some codesys properties: `list' in chain -> chain; `subtype' in
+unicode -> type.  everything compiles again and sort of works; some CRLF
+problems that may resolve themselves when i finish the convert-eol stuff.
+the stuff to create subsidiaries has been rewritten to use chains; but i
+still need to investigate how the EOL type parameter is used.  also, still
+need to implement this: when a coding system is created, and its eol type
+is not autodetect or lf, a chain needs to be created and returned.  i think
+that what needs to happen is that the eol type can only be set to
+autodetect or lf; later on this should be changed to simply be either
+autodetect or not (but that would require ripping out the eol converting
+stuff in the various coding systems), and eventually we will do the work on
+the detection mechanism so it can do chain detection; then we won't need an
+eol autodetect setting at all.  i think there's a way to query the eol type
+of a coding system; this should check to see if the coding system is a
+chain and there's a convert-eol at the front; if so, the eol type comes
+from the type of the convert-eol.
+
+also check out everywhere that Fget_coding_system or Ffind_coding_system is
+called, and see whether anything but a char->byte system can be tolerated.
+create a new function for all the places that only want char->byte,
+something like get_coding_system_char_to_byte_only.
+
+think about specifying formats in make-coding-system.  perhaps the name can
+be a cons of (format1, format2), specifying that it encodes
+format1->format2 and decodes the other way.  if only one name is given,
+that is assumed to be format2, and the other is either `byte' or `char'
+depending on the end type.  normally the user when decoding gives the
+decoding order in formats, but can leave off the last one, `char', which is
+assumed.  perhaps we should say `internal' instead of `char' and `external'
+instead of byte.  a multichain might look like gzip|multibyte|unicode,
+using the coding systems named `gzip', `(unicode . multibyte)' and
+`unicode'.  we would have to allow something where one format is given only
+as generic byte/char or internal/external to fit with any of the same
+byte/char type.  when forcibly fitting together two converters that have
+explicitly specified and incompatible names (say you have
+unicode->multibyte and iso8859-1->ebcdic and you know that the multibyte
+and iso8859-1 in this case are compatible), you can force-cast using ||,
+like this: ebcdic|iso8859-1||multibyte|unicode.  this will also force
+external->internal translation as necessary:
+unicode|multibyte||crlf|internal does unicode->multibyte,
+external->internal, crlf->internal.  perhaps you'd need to put in the
+internal translation, like this: unicode|multibyte|internal||crlf|internal,
+which means unicode->multibyte, external->internal (multibyte is compatible
+with external); force-cast to crlf format and convert crlf->internal.
+
+even later: Sep 8, 2001:
+
+chain doesn't need to set character mode, that happens automatically when
+the coding systems are created.  fixed chain to return correct source/sink
+type for itself and to check the compatibility of source/sink types in its
+chain.  fixed decode/encode-coding-region to check the source and sink
+types of the coding system performing the conversion and insert appropriate
+byte->char/char->byte converters (aka "binary" coding system).  fixed
+set-coding-category-system to only accept the traditional
+encode-char-to-byte types of coding systems.
+
+still need to extend chain to specify the parameters mentioned below,
+esp. "reverse".  also need to extend the print mechanism for chain so it
+prints out the chain.  probably this should be general: have a new method
+to return all properties, and output those properties.  you could also
+implement a read syntax for coding systems this way.
+
+still need to implement convert-eol and finish up the rest of the eol stuff
+mentioned below.
+
+later September 7, 2001: (more like Sep 8)
+
+moved many Lisp_Coding_System * params to Lisp_Object.  In general this is
+the way to go, and if we ever implement a copying GC, we will never want to
+be passing direct pointers around.  With no error-checking, we lose no
+cycles using Lisp_Objects in place of pointers -- the Lisp_Object itself is
+nothing but a pointer, and so all the casts and "dereferences" boil down to
+nothing.
+
+Clarified and cleaned up the "character mode" on streams, and documented
+who (caller or object itself) has the right to be setting character mode on
+a stream, depending on whether it's a read or write stream.  changed
+conversion_end_type method and enum source_sink_type to return
+encoding-centric values, rather than decoding-centric.  for the moment,
+we're going to be entirely encoding-centric in everything; we can rethink
+later.  fixed coding systems so that the decode and encode methods are
+guaranteed to receive only full characters, if that's the source type of
+the data, as per conversion_end_type.
+
+still need to fix the chain method so that it correctly sets the character
+mode on all the lstreams in it and checks the source/sink types to be
+compatible.  also fix decode-coding-string and friends to put the
+appropriate byte->character (i.e. no-conversion) coding systems on the ends
+as necessary so that the final ends are both character.  also add to chain
+a parameter giving the ability to switch the direction of conversion of any
+particular item in the chain (i.e. swap encoding and decoding).  i think
+what we really want to do is allow for arbitrary parameters to be put onto
+a particular coding system in the chain, of which the only one so far is
+swap-encode-decode.  don't need too much codage here for that, but make the
+design extendable.
+
+
+
+September 7, 2001:
+
+just added a return value from the decode and encode methods of a coding
+system, so that some of the data can get rejected.  fixed the calling
+routines to handle this.  need to investigate when and whether the coding
+lstream is set to character mode, so that the decode/encode methods only
+get whole characters.  if not, we should do so, according to the source
+type of these methods.  also need to implement the convert_eol coding
+system, and fix the subsidiary coding systems (and in general, any coding
+system where the eol type is specified and is not LF) to be chains
+involving convert_eol.
+
+after everything is working, need to remove eol handling from encode/decode
+methods and eventually consider rewriting (simplifying) them given the
+reject ability.
+
+September 5, 2001:
+
+-- need to organize this.  get everything below into the TODO list.
+   CVS the TODO list frequently so i can delete old stuff.  prioritize
+   it!!!!!!!!!
+
+-- move README.ben-mule... to STATUS.ben-mule...; use README for
+   intro, overview of what's new, what's broken, how to use the
+   features, etc.
+
+-- need a global and local coding-category-precedence list, which get
+   merged.
+
+-- finished the BOM support.  also finished something not listed
+   below, expansion to the auto-generator of Unicode-encapsulation to
+   support bracketing code with #if ... #endif, for Cygwin and MINGW
+   problems, e.g.  This is tested; appears to work.
+
+-- need to add more multibyte coding systems now that we have various
+   properties to specify them.  need to add DEFUN's for mac-code-page
+   and ebcdic-code-page for completeness.  need to rethink the whole
+   way that the priority list works.  it will continue to be total
+   junk until multiple levels of likeliness get implemented.
+
+-- need to finish up the stuff about the various defaults. [need to
+   investigate more generally where all the different default values
+   are that control encoding. (there are six places or so.) need to
+   list them in make-coding-system docs and put pointers
+   elsewhere. [[[[#### what interface to specify that this default
+   should be unicode?  a "Unicode" language environment seems too
+   drastic, as the language environment controls much more.]]]] even
+   skipping the Unicode stuff here, we need to survey and list the
+   variables that control coding page behavior and determine how they
+   need to be set for various possible scenarios:
+
+  -- total binary: no detection at all.
+  -- raw-text only: wants only autodetection of line endings, nothing else.
+  -- "standard Windows environment": tries for Unicode, falls back on
+     code page encoding.
+  -- some sort of East European environment, and Russian.
+  -- some sort of standard Japanese Windows environment.
+  -- standard Chinese Windows environments (traditional and simplified)
+  -- various Unix environments (European, Japanese, Russian, etc.)
+  -- Unicode support in all of these when it's reasonable
+
+These really require multiple likelihood levels to be fully
+implementable.  We should see what can be done ("gracefully fall
+back") with single likelihood level.  need lots of testing.
+
+-- need to fix the truename problem.
+
+-- lots of testing: need to test all of the stuff above and below that's recently been implemented.
+
+
+
+September 4, 2001:
+
+mostly everything compiles.  currently there is a crash in
+parse-unicode-translation-table, and Cygwin/Mule won't run.  it may
+well be a bug in the sscanf() in Cygwin.
+
+working on today:
+
+-- adding BOM support for Unicode coding systems.  mostly there, but
+   need to finish adding BOM support to the detection routines.  then test.
+-- adding properties to unicode-to-multibyte to specify the coding
+   system in various flexible ways, e.g. directly specified code page
+   or ansi or oem code page of specified locale, current locale,
+   user-default or system-default locale.  need to test.
+-- creating a `multibyte' coding system, with the same parameters as
+   unicode-to-multibyte and which resolves at coding-system-creation
+   time to the appropriate chain.  creating the underlying mechanism
+   to allow such under-the-scenes switcheroo.  need to test.
+-- set default-value of buffer-file-coding-system to
+   mswindows-multibyte, as Matej said it should be.  need to test.
+   need to investigate more generally where all the different default
+   values are that control encoding. (there are six places or so.) 
+   need to list them in make-coding-system docs and put pointers
+   elsewhere. #### what interface to specify that this default should
+   be unicode?  a "Unicode" language environment seems too drastic, as
+   the language environment controls much more.
+-- thinking about adding multiple levels of certainty to the detection
+   schemes, instead of just a mask.  eventually, we need to totally
+   abstract things, but that can easier be done in many steps. (we
+   need multiple levels of likelihood to more reasonably support a
+   Windows environment with code-page type files.  currently, in order
+   to get them detected, we have to put them first, because they can
+   look like lots of other things; but then, other encodings don't get
+   detected.  with multiple levels of likelihood, we still put the
+   code-page categories first, but they will return low levels of
+   likelihood.  Lower-down encodings may be able to return higher
+   levels of likelihood, and will get taken preferentially.)
+-- making it so you cannot disable file-coding, but you get an
+   equivalent default on Unix non-Mule systems where all defaults are
+   `binary'.  need to test!!!!!!!!!
+
+Matej (mostly, + some others) notes the following problems, and here
+are possible solutions:
+
+-- he wants the defaults to work right. [figure out what those
+   defaults are.  i presume they are auto-detection of data in current
+   code page and in unicode, and new files have current code page set
+   as their output encoding.]
+
+-- too easy to lose data with incorrect encodings. [need to set up an
+   error system for encoding/decoding.  extremely important but a
+   little tricky to implement so let's deal with other issues now.]
+
+-- EOL isn't always detected correctly. [#### ?? need examples]
+
+-- truename isn't working: c:\t.txt and c:\tmp.txt have the same truename.
+   [should be easy to fix]
+
+-- unicode files lose the BOM mark. [working on this]
+
+-- command-line utilities use OEM. [actually it seems more
+   complicated.  it seems they use the codepage of the console.  we
+   may be able to set that, e.g. to UTF8, before we invoke a command.
+   need to investigate.]
+
+-- no way to handle unicode characters not recognized as charsets. [we
+   need to create something like 8 private 2-dimensional charsets to
+   handle all BMP Unicode chars.  Obviously this is a stopgap
+   solution.  Switching to Unicode internal will ultimately make life
+   far easier and remove the BMP limitation.  but for now it will
+   work.  we translate all characters where we have charsets into
+   chars in those charsets, and the remainder in a unicode charset.
+   that way we can save them out again and guarantee no data loss with
+   unicode.  this creates font problems, though ...]
+
+-- problems with xemacs font handling. [xemacs font handling is not
+   sophisticated enough.  it goes on a charset granularity basis and
+   only looks for a font whose name contains the corresponding windows
+   charset in it.  with unicode this fails in various ways.  for one
+   the granularity needs to be single character, so that those unicode
+   charsets mentioned above work; and it needs to query the font to
+   see what unicode ranges it supports, rather than just looking at
+   the charset ending.]
+
+
+
+August 28, 2001:
+
+working on getting everything to compile again: Cygwin, non-MULE,
+pdump.  not there yet.
+
+mswindows-multibyte is now defined using chain, and works.  removed
+most vestiges of the mswindows-multibyte coding system type.
+
+file-coding is on by default; should default to binary only on Unix.
+Need to test. (Needs to compile first :-)
+
+August 26, 2001:
+
+I've fixed the issue of inputting non-ASCII text under -nuni, and done
+some of the work on the Russian C-x problem -- we now compute the
+other possibilities.  We still need to fix the key-lookup code,
+though, and that code is unfortunately a bit ugly.  the best way, it
+seems, is to expand the command-builder structure so you can specify
+different interpretations for keys. (if we do find an alternative
+binding, though, we need to mess with both the command builder and
+this-command-keys, as does the function-key stuff.  probably need to
+abstract that munging code.)
+
+high-priority:
+
+[currently doing]
+
+-- support for WM_IME_CHAR.  IME input can work under -nuni if we use
+   WM_IME_CHAR.  probably we should always be using this, instead of
+   snarfing input using WM_COMPOSITION.  i'll check this out.
+-- Russian C-x problem.  see above.
+
+[clean-up]
+
+-- make sure it compiles and runs under non-mule.  remember that some
+   code needs the unicode support, or at least a simple version of it.
+-- make sure it compiles and runs under pdump.  see below.
+-- clean up mswindows-multibyte, TSTR_TO_C_STRING.  see below. [DONE]
+-- eliminate last vestiges of codepage<->charset conversion and similar stuff.
+
+[other]
+-- cut and paste.  see below.
+-- misc issues with handling lang environments.  see also August 25,
+   "finally: working on the C-x in ...".
+   -- when switching lang env, needs to set keyboard layout.
+   -- user var to control whether, when moving into text of a
+      particular language, we set the appropriate keyboard layout.  we
+      would need to have a lisp api for retrieving and setting the
+      keyboard layout, set text properties to indicate the layout of
+      text, and have a way of dealing with text with no property on
+      it. (e.g. saved text has no text properties on it.) basically,
+      we need to get a keyboard layout from a charset; getting a
+      language would do.  Perhaps we need a table that maps charsets
+      to language environments.
+   -- test that the lang env is properly set at startup.  test that
+      switching the lang env properly sets the C locale (call
+      setlocale(), set LANG, etc.) -- a spawned subprogram should have
+      the new locale in its environment.
+-- look through everything below and see if anything is missed in this
+   priority list, and if so add it.  create a separate file for the
+   priority list, so it can be updated as appropriate.
+
+
+mid-priority:
+
+-- clean up the chain coding system.  its list should specify decode
+   order, not encode; i now think this way is more logical.  it should
+   check the endpoints to make sure they make sense.  it should also
+   allow for the specification of "reverse-direction coding systems":
+   use the specified coding system, but invert the sense of decode and
+   encode.
+
+-- along with that, places that take an arbitrary coding system and
+   expect the ends to be anything specific need to check this, and add
+   the appropriate conversions from byte->char or char->byte.
+
+-- get some support for arabic, thai, vietnamese, japanese jisx 0212:
+   at least get the unicode information in place and make sure we have
+   things tied together so that we can display them.  worry about r2l
+   some other time.
+
+August 25, 2001:
+
+There is actually more non-Unicode-ized stuff, but it's basically
+inconsequential. (See previous note.) You can check using the file
+nmkun.txt (#### RENAME), which is just a list of all the routines that
+have been split. (It was generated from the output of `nmake
+unicode-encapsulate', after removing everything from the output but
+the function names.) Use something like
+
+fgrep -f ../nmkun.txt -w [a-hj-z]*.[ch]  |m
+
+in the source directory, which does a word match and skips
+intl-unicode-win32.[ch] and intl-win32.[ch], which have a whole lot of
+references to these, unavoidably.  It effectively detects what needs
+to be changed because changed versions either begin qxe... or end with
+A or W, and in each case there's no whole-word match.
+
+The nasty bug has been fixed below.  The -nuni option now works -- all
+specially-written code to handle the encapsulation has been tested by
+some operation (fonts by loadup and checking the output of (list-fonts
+""); devmode by printing; dragdrop tests other stuff).
+
+NOTE: for -nuni (Win 95), areas need work:
+
+-- cut and paste.  we should be able to receive Unicode text if it's
+   there, and we should be able to receive it even in Win 95 or -nuni.
+   we should just check in all circumstances.  also, under 95, when we
+   put some text in the clipboard, it may or may not also be
+   automatically enumerated as unicode.  we need to test this out
+   and/or just go ahead and manually do the unicode enumeration.
+
+-- receiving keyboard input.  we get only a single byte, but we should
+   be able to correlate the language of the keyboard layout to a
+   particular code page, so we can then decode it correctly.
+
+-- mswindows-multibyte.  still implemented as its own thing.  should
+   be done as a chain of (encoding) unicode | unicode-to-multibyte.
+   need to turn this on, get it working, and look into optimizations
+   in the dfc stuff. (#### perhaps there's a general way to do these
+   optimizations???  something like having a method on a coding system
+   that can specify whether a pure-ASCII string gets rendered as
+   pure-ASCII bytes and vice-versa.)
+
+
+ALSO:
+
+-- we have special macros TSTR_TO_C_STRING and such because formerly
+   the DFC macros didn't know about external stuff that was Unicode
+   encoded and would call strlen() on them.  this is fixed, so now we
+   should undo the special macros, make em normal, removal the
+   comments about this, and make sure it works. [DONE]
+
+
+-- finally: working on the C-x in Russian key layout problem.  in the
+   process will probably end up doing work on cleaning up the handling
+   of keyboard layouts, integrating or deleting the FSF stuff, adding
+   code to change the keyboard layout as we move in and out of text in
+   different languages (implemented as a post-command-hook; we need
+   something like internal-post-command-hook if not already there, for
+   internal stuff that doesn't want to get mixed up with the regular
+   post-command-hook; similar for pre-command-hook).  also, when
+   langenv changes, ways to set the keyboard layout appropriately.
+
+-- i think the stuff above is higher priority than the other stuff
+   mentioned below.  what i'm aiming for is to be able to input and
+   work with multiple languages without weird glitches, both under 95
+   and NT.  the problems above are all basic impediments to such work.
+   we assume for the moment that the user can make use of the existing
+   file i/o conversion stuff, and put that lower in priority, after
+   the basic input is working.
+
+-- i should get my modem connected and write up what's going on and
+   send it to the lists; also cvs commit my workspaces and get more
+   testers.
+
+August 24, 2001:
+
+All code has been Unicode-ized except for some stuff in console-msw.c
+that deals with console output.  Much of the Unicode-encapsulation
+stuff, particularly the hand-written stuff, really needs testing.  I
+added a new command-line option, -nuni, to force use of all ANSI calls
+-- XE_UNICODEP evaluates to false in this case.
+
+There is a nasty bug that appeared recently, probably when the event
+code got Unicode-ized -- bad interactions with OS sticky modifiers.
+Hold the shift key down and release it, then instead of affecting the
+next char only, it gets permanently stuck on (until you do a regular
+shift+char stroke).  This needs to be debugged.
+
+Other things on agenda:
+
+-- go through and prioritize what's listed below.
+
+-- make sure the pdump code can compile and work.  for the moment we
+   just don't try to dump any Unicode tables and load them up each
+   time.  this is certainly fast but ...
+
+-- there's the problem that XEmacs can't be run in a directory with
+   non-ASCII/Latin-1 chars in it, since it will be doing Unicode
+   processing before we've had a chance to load the tables.  In fact,
+   even finding the tables in such a situation is problematic using
+   the normal commands.  my idea is to eventually load the stuff
+   extremely extremely early, at the same time as the pdump data gets
+   loaded.  in fact, the unicode table data (stored in an efficient
+   binary format) can even be stuck into the pdump file (which would
+   mean as a resource to the executable, for windows).  we'd need to
+   extend pdump a bit: to allow for attaching extra data to the pdump
+   file. (something like pdump_attach_extra_data (addr, length)
+   returns a number of some sort, an index into the file, which you
+   can then retrieve with pdump_load_extra_data(), which returns an
+   addr (mmap()ed or loaded), and later you pdump_unload_extra_data()
+   when finished.  we'd probably also need
+   pdump_attach_extra_data_append(), which appends data to the data
+   just written out with pdump_attach_extra_data().  this way,
+   multiple tables in memory can be written out into one contiguous
+   table. (we'd use the tar-like trick of allowing new blocks to be
+   written without going back to change the old blocks -- we just rely
+   on the end of file/end of memory.) this same mechanism could be
+   extracted out of pdump and used to handle the non-pdump situation
+   (or alternatively, we could just dump either the memory image of
+   the tables themselves or the compressed binary version).  in the
+   case of extra unicode tables not known about at compile time that
+   get loaded before dumping, we either just dump them into the image
+   (pdump and all) or extract them into the compressed binary format,
+   free the original tables, and treat them like all other tables.
+
+-- `C-x b' when using a Russian keyboard layout.  XEmacs currently
+   tries to interpret C+cyrillic char, which causes an error.  We want
+   C-x b to still work even when the keyboard normally generates
+   Cyrillic.  What we should do is expand the keyboard event structure
+   so that it contains not only the actual char, but what the char
+   would have been in various other keyboard layouts, and in contexts
+   where only certain keystrokes make sense (creating control chars,
+   and looking up in keymaps), we proceed in order, processing each of
+   them until we get something.  order should be something like:
+   current keyboard layout; layout of the current language
+   environment; layout of the user's default language; layout of the
+   system default language; layout of US English.
+
+-- reading and writing Unicode files.  multiple problems:
+
+   -- EOL's aren't handled right.  for the moment, just fix the
+      Unicode coding systems; later on, create EOL-only coding
+      systems:
+
+      1. they would be character->character and operate next to the
+         internal data; this means that coding systems need to be able
+         to handle ends of lines that are either CR, LF, or CRLF.
+         usually this isn't a problem, as they are just characters
+         like any other and get encoded appropriately.  however,
+         coding systems that are line-oriented need to recognize any
+         of the three as line endings.
+
+      2. we'd also have to complete the stuff that handles coding
+         systems where either end can be byte or char (four
+         possibilities total; use a single enum such as
+         ENCODES_CHAR_TO_BYTE, ENCODES_BYTE_TO_BYTE, etc.).
+
+      3. we'd need ways of specifying the chaining of coding systems.
+         e.g. when reading a coding system, a user can specify more
+         than one with a | symbol between them.  when a context calls
+         for a coding system and a chain is needed, the `chain' coding
+         system is useful; but we should really expand the contexts
+         where a list of coding systems can be given, and whenever
+         possible try to inline the chain instead of using a
+         surrounding `chain' coding system.
+
+      4. the `chain' needs some work so that it passes all sorts of
+         lstream commands down to the chain inside it -- it should be
+         entirely transparent and the fact that there's actually a
+         surrounding coding system should be invisible.  more general
+         coding system methods might need to be created.
+
+      5. important: we need a way of specifying how detecting works
+         when we have more than one coding system.  we might need more
+         than a single priority list.  need to think about this.
+
+   -- Unicode files beginning with the BOM are not recognized as such.
+      we need to fix this; but to make things sensible, we really need
+      to add the idea of different levels of confidence regarding
+      what's detected.  otherwise, Unicode says "yes this is me" but
+      others higher up do too.  in the process we should probably
+      finish abstracting the detection system and fix up some
+      stupidities in it.
+
+   -- When writing a file, we need error detection; otherwise somebody
+      will create a Unicode file without realizing the coding system
+      of the buffer is Raw, and then lose all the non-ASCII/Latin-1
+      text when it's written out.  We need two levels
+
+      1. first, a "safe-charset" level that checks before any actual
+         encoding to see if all characters in the document can safely
+         be represented using the given coding system.  FSF has a
+         "safe-charset" property of coding systems, but it's stupid
+         because this information can be automatically derived from
+         the coding system, at least the vast majority of the time.
+         What we need is some sort of
+         alternative-coding-system-precedence-list, langenv-specific,
+         where everything on it can be checked for safe charsets and
+         then the user given a list of possibilities.  When the user
+         does "save with specified encoding", they should see the same
+         precedence list.  Again like with other precedence lists,
+         there's also a global one, and presumably all coding systems
+         not on other list get appended to the end (and perhaps not
+         checked at all when doing safe-checking?).  safe-checking
+         should work something like this: compile a list of all
+         charsets used in the buffer, along with a count of chars
+         used.  that way, "slightly unsafe" charsets can perhaps be
+         presented at the end, which will lose only a few characters
+         and are perhaps what the users were looking for.
+
+      2. when actually writing out, we need error checking in case an
+         individual char in a charset can't be written even though the
+         charsets are safe.  again, the user gets the choice of other
+         reasonable coding systems.
+
+      3. same thing (error checking, list of alternatives, etc.) needs
+         to happen when reading!  all of this will be a lot of work!
+
+
+
+Announcement, August 20, 2001:
+
+I'm looking for testers.  There is a complete and fast implementation
+in C of Unicode conversion, translations for almost all of the
+standardly-defined charsets that load up automatically and
+instantaneously at runtime, coding systems supporting the common
+external representations of Unicode [utf-16, ucs-4, utf-8,
+little-endian versions of utf-16 and ucs-4; utf-7 is sitting there
+with abort[]s where the coding routines should go, just waiting for
+somebody to implement], and a nice set of primitives for translating
+characters<->codepoints and setting the priority lists used to control
+codepoint->char lookup.
+
+It's so far hooked into one place: the Windows IME.  Currently I can
+select the Japanese IME from the thing on my tray pad in the lower
+right corner of the screen, and type Japanese into XEmacs, and you get
+Japanese in XEmacs -- regardless of whether you set either your
+current or global system locale to Japanese,and regardless of whether
+you set your XEmacs lang env as Japanese.  This should work for many
+other languages, too -- Cyrillic, Chinese either Traditional or
+Simplified, and many others, but YMMV.  There may be some lurking
+bugs (hardly surprising for something so raw).
+
+To get at this, checkout using `ben-mule-21-5', NOT the simpler
+*`mule-21-5'.  For example
+
+cvs -d :pserver:xemacs@cvs.xemacs.org:/usr/CVSroot checkout -r ben-mule-21-5  xemacs
+
+or you get the idea.  the `-r ben-mule-21-5' is important.
+
+I keep track of my progress in a file called README.ben-mule-21-5 in
+the root directory of the source tree.
+
+WARNING: Pdump might not work. Will be fixed rsn.
+
+August 20, 2001:
+
+-- still need to sort out demand loading, binary format, etc.  figure
+   out what the goals are and how we're going to achieve them.  for
+   the moment let's just say that running XEmacs in a directory with
+   Japanese or other weird characters in the name is likely to cause
+   problems under MS Windows, but once XEmacs is initialized (and
+   before processing init files), all Unicode support is there.
+
+-- wrote the size computation routines, although not yet tested.
+
+-- lots more abstraction of coding systems; almost done.
+
+-- UNICODE WORKS!!!!!
+
+
+August 19, 2001:
+
+Still needed on the Unicode support:
+
+-- demand loading: load the Unicode table data the first time a
+   conversion needs to be done.
+
+-- maybe: table size computation: figure out how big the in-memory
+   tables actually are.
+
+-- maybe: create a space-efficient binary format for the data, and a
+   way to dump out an existing charset's data into this binary format.
+   it should allow for many such groups of data to be appended
+   together in one file, such that you can just append the new data
+   onto the end and not have to go back and modify anything
+   previously. (like how tar archives work, and how the UFS? for
+   CD-R's and CD-RW's works.)
+
+-- maybe: figure out how to be able to access the Unicode tables at
+   init_intl() time, before we know how to get at data-directory; that
+   way we can handle the need for unicode conversions that come up
+   very early, for example if XEmacs is run from a directory
+   containing Japanese in it.  Presumably we'd want to generalize the
+   stuff in pdump.c that deals with the dumper file, so that it can
+   handle other files -- putting the file either in the directory of
+   the executable or in a resource, maybe actually attached to the
+   pdump file itself -- or maybe we just dump the data into the actual
+   executable.  With pdump we could extend pdump to allow for data
+   that's in the pdump file but not actually mapped at startup,
+   separate from the data that does get mapped -- and then at runtime
+   the pointer gets restored not with a real pointer but an offset
+   into the file; another pdump call and we get some way to access the
+   data. (tricky because it might be in a resource, not a file.  we
+   might have to just tell pdump to mmap or whatever the data in, and
+   then tell pdump to release it.)
+
+-- fix multibyte to use unicode.  at first, just reverse
+   mswindows-multibyte-to-unicode to be unicode-to-multibyte; later
+   implement something in chain to allow for reversal, for declaring
+   the ends of the coding systems, etc.
+
+-- actually make sure that the IME stuff is working!!!
+
+Other things before announcing:
+
+-- change so that the Unicode tables are not pdumped.  This means we
+   need to free any table data out there.  Make sure that pdump
+   compiles and try to finish the pretty-much-already-done stuff
+   already with XD_STRUCT_ARRAY and dynamic size computation; just
+   need to see what's going on with LO_LINK.
+
+August 14, 2001:
+
+To do a diff between this workspace and the mainline, use the most recent sync tags, currently:
+
+cvs diff -r main-branch-ben-mule-21-5-aug-11-2001-sync -r ben-mule-21-5-post-aug-11-2001-sync
+
+Unicode support:
+
+Unicode support is important for supporting many languages under
+Windows, such as Cyrillic, without resorting to translation tables for
+particular Windows-specific code pages.  Internally, all characters in
+Windows can be represented in two encodings: code pages and Unicode.
+With Unicode support, we can seamlessly support all Windows
+characters.  Currently, the test in the drive to support Unicode is if
+IME input works properly, since it is being converted from Unicode.
+
+Unicode support also requires that the various Windows API's be
+"Unicode-encapsulated", so that they automatically call the ANSI or
+Unicode version of the API call appropriately and handle the size
+differences in structures.  What this means is:
+
+-- first, note that Windows already provides a sort of encapsulation
+   of all API's that deal with text.  All such API's are underlyingly
+   provided in two versions, with an A or W suffix (ANSI or "wide"
+   i.e. Unicode), and the compile-time constant UNICODE controls which
+   is selected by the unsuffixed API.  Same thing happens with
+   structures.  Unfortunately, this is compile-time only, not
+   run-time, so not sufficient. (Creating the necessary run-time
+   encoding is not conceptually difficult, but very time-consuming to
+   write.  It adds no significant overhead, and the only reason it's
+   not standard in Windows is conscious marketing attempts by
+   Microsoft to cripple Windows 95.  FUCK MICROSOFT!  They even
+   describe in a KnowledgeBase article exactly how to create such an
+   API [although we don't exactly follow their procedure], and point
+   out its usefulness; the procedure is also described more generally
+   in Nadine Kano's book on Win32 internationalization -- written SIX
+   YEARS AGO!  Obviously Microsoft has such an API available
+   internally.)
+
+-- what we do is provide an encapsulation of each standard Windows API
+   call that is split into A and W versions.  current theory is to
+   avoid all preprocessor games; so we name the function with a prefix
+   -- "qxe" currently -- and require callers to use the prefixed name.
+   Callers need to explicitly use the W version of all structures, and
+   convert text themselves using Qmswindows_tstr.  the qxe
+   encapsulated version will automatically call the appropriate A or W
+   version depending on whether we're running on 9x or NT, and copy
+   data between W and A versions of the structures as necessary.
+
+-- We require the caller to handle the actual translation of text to
+   avoid possible overflow when dealing with fixed-size Windows
+   structures.  There are no such problems when copying data between
+   the A and W versions because ANSI text is never larger than its
+   equivalent Unicode representation.
+
+-- We allow for incremental creation of the encapsulated routines by
+   using the coding system Qmswindows_tstr_notyet.  This is an alias
+   for Qmswindows_multibyte, i.e. it always converts to ANSI; but it
+   indicates that it will be changed to Qmswindows_tstr when we have a
+   qxe version of the API call that the data is being passed to and
+   change the code to use the new function.
+
+Besides creating the encapsulation, the following needs to be done for
+Unicode support:
+
+-- No actual translation tables are fed into XEmacs.  We need to
+   provide glue code to read the tables in etc/unicode.  See
+   etc/unicode/README for the interface to implement.
+
+-- Fix pdump.  The translation tables for Unicode characters function
+   as unions of structures with different numbers of indirection
+   levels, in order to be efficient.  pdump doesn't yet support such
+   unions.  charset.h has a general description of how the translation
+   tables work, and the pdump code has constants added for the new
+   required data types, and descriptions of how these should work.
+
+-- ultimately, there's no end to additional work (composition, bidi
+   reordering, glyph shaping/ordering, etc.), but the above is enough
+   to get basic translation working.
+
+Merging this workspace into the trunk requires some work.  ChangeLogs
+have not yet been created.  Also, there is a lot of additional code in
+this workspace other than just Windows and Unicode stuff.  Some of the
+changes have been somewhat disruptive to the code base, in particular:
+
+-- the code that handles the details of processing multilingual text
+   has been consolidated to make it easier to extend it.  it has been
+   yanked out of various files (buffer.h, mule-charset.h, lisp.h,
+   insdel.c, fns.c, file-coding.c, etc.) and put into text.c and
+   text.h.  mule-charset.h has also been renamed charset.h.  all long
+   comments concerning the representations and their processing have
+   been consolidated into text.c.
+
+-- nt/config.h has been eliminated and everything in it merged into
+   config.h.in and s/windowsnt.h.  see config.h.in for more info.
+
+-- s/windowsnt.h has been completely rewritten, and s/cygwin32.h and
+   s/mingw32.h have been largely rewritten.  tons of dead weight has
+   been removed, and stuff common to more than one file has been
+   isolated into s/win32-common.h and s/win32-native.h, similar to
+   what's already done for usg variants.
+
+-- large amounts of code throughout the code base have been Mule-ized,
+   not just Windows code.
+
+-- file-coding.c/.h have been largely rewritten (although still mostly
+   syncable); see below.
+
+
+
+June 26, 2001:
+
+-- ben-mule-21-5
+
+this contains all the mule work i've been doing.  this includes mostly
+work done to get mule working under ms windows, but in the process
+i've [of course] fixed a whole lot of other things as well, mostly
+mule issues.  the specifics:
+
+- it compiles and runs under windows and should basically work.  the
+  stuff remaining to do is (a) improved unicode support (see below)
+  and (b) smarter handling of keyboard layouts.  in particular, it
+  should (1) set the right keyboard layout when you change your
+  language environment; (2) optionally (a user var) set the
+  appropriate keyboard layout as you move the cursor into text in a
+  particular language.
+
+- i added a bunch of code to better support OS locales.  it tries to
+  notice your locale at startup and set the language environment
+  accordingly (this more or less works), and call setlocale() and set
+  LANG when you change the language environment (may or may not work).
+
+- major rewriting of file-coding.  it's mostly abstracted into coding
+  systems that are defined by methods (similar to devices and
+  specifiers), with the ultimate aim being to allow non-i18n coding
+  systems such as gzip.  there is a "chain" coding system that allows
+  multiple coding systems to be chained together. (it doesn't yet
+  have the concept that either end of a coding system can be bytes or
+  chars; this needs to be added.)
+
+- unicode support.  very raw.  a few days ago i wrote a complete and
+  efficient implementation of unicode translation.  it should be very
+  fast, and fairly memory-efficient in its tables.  it allows for
+  charset priority lists, which should be language-environment
+  specific (but i haven't yet written the glue code).  it works in
+  preliminary testing, but obviously needs more testing and work.
+  as of yet there is no translation data added for the standard charsets.
+  the tables are in etc/unicode, and all we need is a bit of glue code
+  to process them.  see etc/unicode/README for the interface to
+  implement.
+
+- support for unicode in windows is partly there.  this will work even
+  on windows 95.  the basic model is implemented but it needs finishing
+  up.
+
+- there is a preliminary implementation of windows ime support courtesy
+  of ikeyama.
+
+- if you want to get cyrillic working under windows (it appears to "work"
+  but the wrong chars currently appear), the best way is to add unicode
+  support for iso-8859-5 and use it in redisplay-msw.c.  we are already
+  passing unicode codepoints to the text-draw routine (ExtTextOutW).
+  (ExtTextOutW and GetTextExtentPoint32W are implemented on both 95 and NT.)
+
+- i fixed the iso2022 handling so it will correctly read in files
+  containing unknown charsets, creating a "temporary" charset which
+  can later be overwritten by the real charset when it's defined.
+  this allows iso2022 elisp files with literals in strange languages
+  to compile correctly under mule.  i also added a hack that will
+  correctly read in and write out the emacs-specific "composition"
+  escape sequences, i.e. ESC 0 through ESC 4.  this means that my
+  workspace correctly compiles the new file devanagari.el that i added
+  (see below).
+
+- i copied the remaining language-specific files from fsf.  i made
+  some minor changes in certain cases but for the most part the stuff
+  was just copied and may not work.
+
+- i fixed post-read-conversion in coding systems to follow fsf
+  conventions. (i also support our convention, for the moment.  a
+  kludge, of course.)
+
+- make-coding-system accepts (but ignores) the additional properties
+  present in the fsf version, for compatibility.

--- /dev/null	Thu Jan 01 00:00:00 1970 +0000
+++ b/README.ben-separate-stderr	Wed Mar 13 08:54:06 2002 +0000
@@ -0,0 +1,15 @@
+-- ben-separate-stderr-improved-error-trapping
+
+this is an old workspace, very close to being done, containing
+
+- subprocess stderr output can be read separately; needed to fully
+  implement call-process with asynch. subprocesses.
+
+- huge improvements to the internal error-trapping routines (i.e. the
+  routines that call Lisp code and trap errors); Lisp code can now be
+  called from within redisplay.
+
+- cleanup and simplification of C-g handling; some things work now
+  that never used to.
+
+- see the ChangeLogs in the workspace.

--- /dev/null	Thu Jan 01 00:00:00 1970 +0000
+++ b/TODO.ben-mule-21-5	Wed Mar 13 08:54:06 2002 +0000
@@ -0,0 +1,81 @@
+
+
+last update: August 29, 2001.
+
+This is the most current list of priorities in `ben-mule-21-5'.
+Updated often.
+
+high-priority:
+
+[input]
+
+-- support for WM_IME_CHAR.  IME input can work under -nuni if we use
+   WM_IME_CHAR.  probably we should always be using this, instead of
+   snarfing input using WM_COMPOSITION.  i'll check this out.
+-- Russian C-x problem.  see above.
+
+[clean-up]
+
+-- make sure it compiles and runs under non-mule.  remember that some
+   code needs the unicode support, or at least a simple version of it.
+-- make sure it compiles and runs under pdump.  see below.
+-- make sure it compiles and runs under cygwin.  see below.
+-- clean up mswindows-multibyte, TSTR_TO_C_STRING.  expand dfc
+   optimizations to work across chain.
+-- eliminate last vestiges of codepage<->charset conversion and similar stuff.
+
+[other]
+
+-- test the "file-coding is binary only on Unix, no-Mule" stuff.
+-- test that things work correctly in -nuni if the system environment
+   is set to e.g. japanese -- i should get japanese menus, japanese
+   file names, etc.  same for russian, hebrew ...
+-- cut and paste.  see below.
+-- misc issues with handling lang environments.  see also August 25,
+   "finally: working on the C-x in ...".
+   -- when switching lang env, needs to set keyboard layout.
+   -- user var to control whether, when moving into text of a
+      particular language, we set the appropriate keyboard layout.  we
+      would need to have a lisp api for retrieving and setting the
+      keyboard layout, set text properties to indicate the layout of
+      text, and have a way of dealing with text with no property on
+      it. (e.g. saved text has no text properties on it.) basically,
+      we need to get a keyboard layout from a charset; getting a
+      language would do.  Perhaps we need a table that maps charsets
+      to language environments.
+   -- test that the lang env is properly set at startup.  test that
+      switching the lang env properly sets the C locale (call
+      setlocale(), set LANG, etc.) -- a spawned subprogram should have
+      the new locale in its environment.
+-- look through everything below and see if anything is missed in this
+   priority list, and if so add it.  create a separate file for the
+   priority list, so it can be updated as appropriate.
+
+
+mid-priority:
+
+-- clean up the chain coding system.  its list should specify decode
+   order, not encode; i now think this way is more logical.  it should
+   check the endpoints to make sure they make sense.  it should also
+   allow for the specification of "reverse-direction coding systems":
+   use the specified coding system, but invert the sense of decode and
+   encode.
+
+-- along with that, places that take an arbitrary coding system and
+   expect the ends to be anything specific need to check this, and add
+   the appropriate conversions from byte->char or char->byte.
+
+-- get some support for arabic, thai, vietnamese, japanese jisx 0212:
+   at least get the unicode information in place and make sure we have
+   things tied together so that we can display them.  worry about r2l
+   some other time.
+
+-- check the handling of C-c.  can XEmacs itself be interrupted with C-c?
+   is that impossible now that we are a window, not a console, app?  at
+   least we should work something out with `i', so that if it receives a
+   C-c or C-break, it interrupts XEmacs, too.  check out how process groups
+   work and if they apply only to console apps.  also redo the way that
+   XEmacs sends C-c to other apps.  the business of injecting code should
+   be last resort.  we should try C-c first, and if that doesn't work, then
+   the next time we try to interrupt the same process, use the injection
+   method.

--- a/configure	Fri Mar 08 13:33:14 2002 +0000
+++ b/configure	Wed Mar 13 08:54:06 2002 +0000
@@ -6,7 +6,7 @@
 #### Copyright (C) 1992, 1993, 1994, 1995, 1996, 1997, 1998, 1999, 2000 Free Software Foundation, Inc.
 #### Copyright (C) 1993-1995 Board of Trustees, University of Illinois.
 #### Copyright (C) 1996, 1997 Sun Microsystems, Inc.
-#### Copyright (C) 1995, 1996 Ben Wing.
+#### Copyright (C) 1995, 1996, 2002 Ben Wing.
 #### Copyright (C) 2000, 2001 Martin Buchholz.
 #### Copyright (C) 1998, 1999 J. Kean Johnston.
 
@@ -256,7 +256,7 @@
 use_union_type="no"
 with_dnet=""
 pdump="no"
-with_dragndrop="no"
+with_dragndrop_default="no"
 with_ipv6_cname="no"
 
 
@@ -328,6 +328,7 @@
 	with_jpeg	| \
 	with_png	| \
 	with_tiff	| \
+	with_zlib	| \
 	with_wmcommand	| \
 	with_xmu	| \
 	with_purify	| \
@@ -335,9 +336,8 @@
 	with_toolbars	| \
 	with_tty	| \
 	with_xfs	| \
-	with_i18n3	| \
 	with_mule	| \
-	with_file_coding| \
+        with_default_eol_detection | \
 	with_canna	| \
 	with_wnn	| \
 	with_wnn6	| \
@@ -1078,13 +1078,8 @@
 }
 
 if test "${debug:=$beta}" = "yes"; then
-  use_assertions=yes memory_usage_stats=yes
-  extra_objs="$extra_objs debug.o" &&  if test "$extra_verbose" = "yes"; then
-   echo "    xemacs will be linked with \"debug.o\""
- fi
-  extra_objs="$extra_objs tests.o" &&  if test "$extra_verbose" = "yes"; then
-   echo "    xemacs will be linked with \"tests.o\""
- fi
+  use_assertions=yes
+  memory_usage_stats=yes
   { test "$extra_verbose" = "yes" && cat << \EOF
     Defining DEBUG_XEMACS
 EOF
@@ -1113,7 +1108,7 @@
 
 
 echo $ac_n "checking "host system type"""... $ac_c" 1>&6
-echo "configure:1117: checking "host system type"" >&5
+echo "configure:1112: checking "host system type"" >&5
 internal_configuration=`echo $configuration | sed 's/-\(workshop\)//'`
 canonical=`${CONFIG_SHELL-/bin/sh} $srcdir/config.sub "$internal_configuration"`
 configuration=`echo "$configuration" | sed 's/^\([^-][^-]*-[^-][^-]*-[^-][^-]*\)-.*$/\1/'`
@@ -1594,9 +1589,6 @@
 EOF
 }
 
-  extra_objs="$extra_objs sunpro.o" &&  if test "$extra_verbose" = "yes"; then
-   echo "    xemacs will be linked with \"sunpro.o\""
- fi
 fi
 
 if test "$with_clash_detection" != "no"; then
@@ -1608,9 +1600,6 @@
 EOF
 }
 
-  extra_objs="$extra_objs filelock.o" &&  if test "$extra_verbose" = "yes"; then
-   echo "    xemacs will be linked with \"filelock.o\""
- fi
 fi
 
 test -n "$compiler" && CC="$compiler"
@@ -1628,7 +1617,7 @@
 # Extract the first word of "gcc", so it can be a program name with args.
 set dummy gcc; ac_word=$2
 echo $ac_n "checking for $ac_word""... $ac_c" 1>&6
-echo "configure:1632: checking for $ac_word" >&5
+echo "configure:1621: checking for $ac_word" >&5
 
 if test -n "$CC"; then
   ac_cv_prog_CC="$CC" # Let the user override the test.
@@ -1655,7 +1644,7 @@
   # Extract the first word of "cc", so it can be a program name with args.
 set dummy cc; ac_word=$2
 echo $ac_n "checking for $ac_word""... $ac_c" 1>&6
-echo "configure:1659: checking for $ac_word" >&5
+echo "configure:1648: checking for $ac_word" >&5
 
 if test -n "$CC"; then
   ac_cv_prog_CC="$CC" # Let the user override the test.
@@ -1703,7 +1692,7 @@
       # Extract the first word of "cl", so it can be a program name with args.
 set dummy cl; ac_word=$2
 echo $ac_n "checking for $ac_word""... $ac_c" 1>&6
-echo "configure:1707: checking for $ac_word" >&5
+echo "configure:1696: checking for $ac_word" >&5
 
 if test -n "$CC"; then
   ac_cv_prog_CC="$CC" # Let the user override the test.
@@ -1732,7 +1721,7 @@
 fi
 
 echo $ac_n "checking whether the C compiler ($CC $CFLAGS $LDFLAGS) works""... $ac_c" 1>&6
-echo "configure:1736: checking whether the C compiler ($CC $CFLAGS $LDFLAGS) works" >&5
+echo "configure:1725: checking whether the C compiler ($CC $CFLAGS $LDFLAGS) works" >&5
 
 ac_ext=c
 xe_cppflags='$CPPFLAGS $c_switch_site $c_switch_machine $c_switch_system $c_switch_x_site $X_CFLAGS'
@@ -1745,12 +1734,12 @@
 
 cat > conftest.$ac_ext << EOF
 
-#line 1749 "configure"
+#line 1738 "configure"
 #include "confdefs.h"
 
 main(){return(0);}
 EOF
-if { (eval echo configure:1754: \"$ac_link\") 1>&5; (eval $ac_link) 2>&5; } && test -s conftest${ac_exeext}; then
+if { (eval echo configure:1743: \"$ac_link\") 1>&5; (eval $ac_link) 2>&5; } && test -s conftest${ac_exeext}; then
   ac_cv_prog_cc_works=yes
   # If we can't run a trivial program, we are probably using a cross compiler.
   if (./conftest; exit) 2>/dev/null; then
@@ -1778,19 +1767,19 @@
   { echo "configure: error: installation or configuration problem: C compiler cannot create executables." 1>&2; exit 1; }
 fi
 echo $ac_n "checking whether the C compiler ($CC $CFLAGS $LDFLAGS) is a cross-compiler""... $ac_c" 1>&6
-echo "configure:1782: checking whether the C compiler ($CC $CFLAGS $LDFLAGS) is a cross-compiler" >&5
+echo "configure:1771: checking whether the C compiler ($CC $CFLAGS $LDFLAGS) is a cross-compiler" >&5
 echo "$ac_t""$ac_cv_prog_cc_cross" 1>&6
 cross_compiling=$ac_cv_prog_cc_cross
 
 echo $ac_n "checking whether we are using GNU C""... $ac_c" 1>&6
-echo "configure:1787: checking whether we are using GNU C" >&5
+echo "configure:1776: checking whether we are using GNU C" >&5
 
 cat > conftest.c <<EOF
 #ifdef __GNUC__
   yes;
 #endif
 EOF
-if { ac_try='${CC-cc} -E conftest.c'; { (eval echo configure:1794: \"$ac_try\") 1>&5; (eval $ac_try) 2>&5; }; } | egrep yes >/dev/null 2>&1; then
+if { ac_try='${CC-cc} -E conftest.c'; { (eval echo configure:1783: \"$ac_try\") 1>&5; (eval $ac_try) 2>&5; }; } | egrep yes >/dev/null 2>&1; then
   ac_cv_prog_gcc=yes
 else
   ac_cv_prog_gcc=no
@@ -1808,7 +1797,7 @@
 ac_save_CFLAGS="$CFLAGS"
 CFLAGS=
 echo $ac_n "checking whether ${CC-cc} accepts -g""... $ac_c" 1>&6
-echo "configure:1812: checking whether ${CC-cc} accepts -g" >&5
+echo "configure:1801: checking whether ${CC-cc} accepts -g" >&5
 
 echo 'void f(){}' > conftest.c
 if test -z "`${CC-cc} -g -c conftest.c 2>&1`"; then
@@ -1841,7 +1830,7 @@
   # Extract the first word of "gcc", so it can be a program name with args.
 set dummy gcc; ac_word=$2
 echo $ac_n "checking for $ac_word""... $ac_c" 1>&6
-echo "configure:1845: checking for $ac_word" >&5
+echo "configure:1834: checking for $ac_word" >&5
 
 if test -n "$CC"; then
   ac_cv_prog_CC="$CC" # Let the user override the test.
@@ -1868,7 +1857,7 @@
   # Extract the first word of "cc", so it can be a program name with args.
 set dummy cc; ac_word=$2
 echo $ac_n "checking for $ac_word""... $ac_c" 1>&6
-echo "configure:1872: checking for $ac_word" >&5
+echo "configure:1861: checking for $ac_word" >&5
 
 if test -n "$CC"; then
   ac_cv_prog_CC="$CC" # Let the user override the test.
@@ -1916,7 +1905,7 @@
       # Extract the first word of "cl", so it can be a program name with args.
 set dummy cl; ac_word=$2
 echo $ac_n "checking for $ac_word""... $ac_c" 1>&6
-echo "configure:1920: checking for $ac_word" >&5
+echo "configure:1909: checking for $ac_word" >&5
 
 if test -n "$CC"; then
   ac_cv_prog_CC="$CC" # Let the user override the test.
@@ -1945,7 +1934,7 @@
 fi
 
 echo $ac_n "checking whether the C compiler ($CC $CFLAGS $LDFLAGS) works""... $ac_c" 1>&6
-echo "configure:1949: checking whether the C compiler ($CC $CFLAGS $LDFLAGS) works" >&5
+echo "configure:1938: checking whether the C compiler ($CC $CFLAGS $LDFLAGS) works" >&5
 
 ac_ext=c
 xe_cppflags='$CPPFLAGS $c_switch_site $c_switch_machine $c_switch_system $c_switch_x_site $X_CFLAGS'
@@ -1958,12 +1947,12 @@
 
 cat > conftest.$ac_ext << EOF
 
-#line 1962 "configure"
+#line 1951 "configure"
 #include "confdefs.h"
 
 main(){return(0);}
 EOF
-if { (eval echo configure:1967: \"$ac_link\") 1>&5; (eval $ac_link) 2>&5; } && test -s conftest${ac_exeext}; then
+if { (eval echo configure:1956: \"$ac_link\") 1>&5; (eval $ac_link) 2>&5; } && test -s conftest${ac_exeext}; then
   ac_cv_prog_cc_works=yes
   # If we can't run a trivial program, we are probably using a cross compiler.
   if (./conftest; exit) 2>/dev/null; then
@@ -1991,19 +1980,19 @@
   { echo "configure: error: installation or configuration problem: C compiler cannot create executables." 1>&2; exit 1; }
 fi
 echo $ac_n "checking whether the C compiler ($CC $CFLAGS $LDFLAGS) is a cross-compiler""... $ac_c" 1>&6
-echo "configure:1995: checking whether the C compiler ($CC $CFLAGS $LDFLAGS) is a cross-compiler" >&5
+echo "configure:1984: checking whether the C compiler ($CC $CFLAGS $LDFLAGS) is a cross-compiler" >&5
 echo "$ac_t""$ac_cv_prog_cc_cross" 1>&6
 cross_compiling=$ac_cv_prog_cc_cross
 
 echo $ac_n "checking whether we are using GNU C""... $ac_c" 1>&6
-echo "configure:2000: checking whether we are using GNU C" >&5
+echo "configure:1989: checking whether we are using GNU C" >&5
 
 cat > conftest.c <<EOF
 #ifdef __GNUC__
   yes;
 #endif
 EOF
-if { ac_try='${CC-cc} -E conftest.c'; { (eval echo configure:2007: \"$ac_try\") 1>&5; (eval $ac_try) 2>&5; }; } | egrep yes >/dev/null 2>&1; then
+if { ac_try='${CC-cc} -E conftest.c'; { (eval echo configure:1996: \"$ac_try\") 1>&5; (eval $ac_try) 2>&5; }; } | egrep yes >/dev/null 2>&1; then
   ac_cv_prog_gcc=yes
 else
   ac_cv_prog_gcc=no
@@ -2021,7 +2010,7 @@
 ac_save_CFLAGS="$CFLAGS"
 CFLAGS=
 echo $ac_n "checking whether ${CC-cc} accepts -g""... $ac_c" 1>&6
-echo "configure:2025: checking whether ${CC-cc} accepts -g" >&5
+echo "configure:2014: checking whether ${CC-cc} accepts -g" >&5
 
 echo 'void f(){}' > conftest.c
 if test -z "`${CC-cc} -g -c conftest.c 2>&1`"; then
@@ -2054,7 +2043,7 @@
   # Extract the first word of "gcc", so it can be a program name with args.
 set dummy gcc; ac_word=$2
 echo $ac_n "checking for $ac_word""... $ac_c" 1>&6
-echo "configure:2058: checking for $ac_word" >&5
+echo "configure:2047: checking for $ac_word" >&5
 
 if test -n "$CC"; then
   ac_cv_prog_CC="$CC" # Let the user override the test.
@@ -2081,7 +2070,7 @@
   # Extract the first word of "cc", so it can be a program name with args.
 set dummy cc; ac_word=$2
 echo $ac_n "checking for $ac_word""... $ac_c" 1>&6
-echo "configure:2085: checking for $ac_word" >&5
+echo "configure:2074: checking for $ac_word" >&5
 
 if test -n "$CC"; then
   ac_cv_prog_CC="$CC" # Let the user override the test.
@@ -2129,7 +2118,7 @@
       # Extract the first word of "cl", so it can be a program name with args.
 set dummy cl; ac_word=$2
 echo $ac_n "checking for $ac_word""... $ac_c" 1>&6
-echo "configure:2133: checking for $ac_word" >&5
+echo "configure:2122: checking for $ac_word" >&5
 
 if test -n "$CC"; then
   ac_cv_prog_CC="$CC" # Let the user override the test.
@@ -2158,7 +2147,7 @@
 fi
 
 echo $ac_n "checking whether the C compiler ($CC $CFLAGS $LDFLAGS) works""... $ac_c" 1>&6
-echo "configure:2162: checking whether the C compiler ($CC $CFLAGS $LDFLAGS) works" >&5
+echo "configure:2151: checking whether the C compiler ($CC $CFLAGS $LDFLAGS) works" >&5
 
 ac_ext=c
 xe_cppflags='$CPPFLAGS $c_switch_site $c_switch_machine $c_switch_system $c_switch_x_site $X_CFLAGS'
@@ -2171,12 +2160,12 @@
 
 cat > conftest.$ac_ext << EOF
 
-#line 2175 "configure"
+#line 2164 "configure"
 #include "confdefs.h"
 
 main(){return(0);}
 EOF
-if { (eval echo configure:2180: \"$ac_link\") 1>&5; (eval $ac_link) 2>&5; } && test -s conftest${ac_exeext}; then
+if { (eval echo configure:2169: \"$ac_link\") 1>&5; (eval $ac_link) 2>&5; } && test -s conftest${ac_exeext}; then
   ac_cv_prog_cc_works=yes
   # If we can't run a trivial program, we are probably using a cross compiler.
   if (./conftest; exit) 2>/dev/null; then
@@ -2204,19 +2193,19 @@
   { echo "configure: error: installation or configuration problem: C compiler cannot create executables." 1>&2; exit 1; }
 fi
 echo $ac_n "checking whether the C compiler ($CC $CFLAGS $LDFLAGS) is a cross-compiler""... $ac_c" 1>&6
-echo "configure:2208: checking whether the C compiler ($CC $CFLAGS $LDFLAGS) is a cross-compiler" >&5
+echo "configure:2197: checking whether the C compiler ($CC $CFLAGS $LDFLAGS) is a cross-compiler" >&5
 echo "$ac_t""$ac_cv_prog_cc_cross" 1>&6
 cross_compiling=$ac_cv_prog_cc_cross
 
 echo $ac_n "checking whether we are using GNU C""... $ac_c" 1>&6
-echo "configure:2213: checking whether we are using GNU C" >&5
+echo "configure:2202: checking whether we are using GNU C" >&5
 
 cat > conftest.c <<EOF
 #ifdef __GNUC__
   yes;
 #endif
 EOF
-if { ac_try='${CC-cc} -E conftest.c'; { (eval echo configure:2220: \"$ac_try\") 1>&5; (eval $ac_try) 2>&5; }; } | egrep yes >/dev/null 2>&1; then
+if { ac_try='${CC-cc} -E conftest.c'; { (eval echo configure:2209: \"$ac_try\") 1>&5; (eval $ac_try) 2>&5; }; } | egrep yes >/dev/null 2>&1; then
   ac_cv_prog_gcc=yes
 else
   ac_cv_prog_gcc=no
@@ -2234,7 +2223,7 @@
 ac_save_CFLAGS="$CFLAGS"
 CFLAGS=
 echo $ac_n "checking whether ${CC-cc} accepts -g""... $ac_c" 1>&6
-echo "configure:2238: checking whether ${CC-cc} accepts -g" >&5
+echo "configure:2227: checking whether ${CC-cc} accepts -g" >&5
 
 echo 'void f(){}' > conftest.c
 if test -z "`${CC-cc} -g -c conftest.c 2>&1`"; then
@@ -2271,7 +2260,7 @@
 test -n "$NON_GNU_CPP" -a "$GCC" != "yes" -a -z "$CPP" && CPP="$NON_GNU_CPP"
 
 echo $ac_n "checking how to run the C preprocessor""... $ac_c" 1>&6
-echo "configure:2275: checking how to run the C preprocessor" >&5
+echo "configure:2264: checking how to run the C preprocessor" >&5
 # On Suns, sometimes $CPP names a directory.
 if test -n "$CPP" && test -d "$CPP"; then
   CPP=
@@ -2284,13 +2273,13 @@
   # On the NeXT, cc -E runs the code through the compiler's parser,
   # not just through cpp.
   cat > conftest.$ac_ext <<EOF
-#line 2288 "configure"
+#line 2277 "configure"
 #include "confdefs.h"
 #include <assert.h>
 Syntax Error
 EOF
 ac_try="$ac_cpp conftest.$ac_ext >/dev/null 2>conftest.out"
-{ (eval echo configure:2294: \"$ac_try\") 1>&5; (eval $ac_try) 2>&5; }
+{ (eval echo configure:2283: \"$ac_try\") 1>&5; (eval $ac_try) 2>&5; }
 ac_err=`grep -v '^ *+' conftest.out | grep -v "^conftest.${ac_ext}\$"`
 if test -z "$ac_err"; then
   :
@@ -2301,13 +2290,13 @@
   rm -rf conftest*
   CPP="${CC-cc} -E -traditional-cpp"
   cat > conftest.$ac_ext <<EOF
-#line 2305 "configure"
+#line 2294 "configure"
 #include "confdefs.h"
 #include <assert.h>
 Syntax Error
 EOF
 ac_try="$ac_cpp conftest.$ac_ext >/dev/null 2>conftest.out"
-{ (eval echo configure:2311: \"$ac_try\") 1>&5; (eval $ac_try) 2>&5; }
+{ (eval echo configure:2300: \"$ac_try\") 1>&5; (eval $ac_try) 2>&5; }
 ac_err=`grep -v '^ *+' conftest.out | grep -v "^conftest.${ac_ext}\$"`
 if test -z "$ac_err"; then
   :
@@ -2318,13 +2307,13 @@
   rm -rf conftest*
   CPP="${CC-cc} -nologo -E"
   cat > conftest.$ac_ext <<EOF
-#line 2322 "configure"
+#line 2311 "configure"
 #include "confdefs.h"
 #include <assert.h>
 Syntax Error
 EOF
 ac_try="$ac_cpp conftest.$ac_ext >/dev/null 2>conftest.out"
-{ (eval echo configure:2328: \"$ac_try\") 1>&5; (eval $ac_try) 2>&5; }
+{ (eval echo configure:2317: \"$ac_try\") 1>&5; (eval $ac_try) 2>&5; }
 ac_err=`grep -v '^ *+' conftest.out | grep -v "^conftest.${ac_ext}\$"`
 if test -z "$ac_err"; then
   :
@@ -2350,9 +2339,9 @@
 
 
 echo $ac_n "checking for AIX""... $ac_c" 1>&6
-echo "configure:2354: checking for AIX" >&5
-cat > conftest.$ac_ext <<EOF
-#line 2356 "configure"
+echo "configure:2343: checking for AIX" >&5
+cat > conftest.$ac_ext <<EOF
+#line 2345 "configure"
 #include "confdefs.h"
 #ifdef _AIX
   yes
@@ -2379,9 +2368,9 @@
  
 
 echo $ac_n "checking for GNU libc""... $ac_c" 1>&6
-echo "configure:2383: checking for GNU libc" >&5
-cat > conftest.$ac_ext <<EOF
-#line 2385 "configure"
+echo "configure:2372: checking for GNU libc" >&5
+cat > conftest.$ac_ext <<EOF
+#line 2374 "configure"
 #include "confdefs.h"
 #include <features.h>
 int main() {
@@ -2393,7 +2382,7 @@
 
 ; return 0; }
 EOF
-if { (eval echo configure:2397: \"$ac_compile\") 1>&5; (eval $ac_compile) 2>&5; }; then
+if { (eval echo configure:2386: \"$ac_compile\") 1>&5; (eval $ac_compile) 2>&5; }; then
   rm -rf conftest*
   have_glibc=yes
 else
@@ -2470,7 +2459,7 @@
 esac
 
 cat > conftest.$ac_ext <<EOF
-#line 2474 "configure"
+#line 2463 "configure"
 #include "confdefs.h"
 int main () {
 #if defined __SUNPRO_C
@@ -2484,7 +2473,7 @@
 #endif
 }
 EOF
-if { (eval echo configure:2488: \"$ac_link\") 1>&5; (eval $ac_link) 2>&5; } && test -s conftest && (./conftest; exit $?) 2>&5
+if { (eval echo configure:2477: \"$ac_link\") 1>&5; (eval $ac_link) 2>&5; } && test -s conftest && (./conftest; exit $?) 2>&5
 then
   :
 else
@@ -2736,17 +2725,17 @@
 
 if test "$__USLC__" = yes; then
   echo $ac_n "checking for whether the -Kalloca compiler flag is needed""... $ac_c" 1>&6
-echo "configure:2740: checking for whether the -Kalloca compiler flag is needed" >&5
+echo "configure:2729: checking for whether the -Kalloca compiler flag is needed" >&5
   need_kalloca=no
   cat > conftest.$ac_ext <<EOF
-#line 2743 "configure"
+#line 2732 "configure"
 #include "confdefs.h"
 
 int main() {
 void *x = alloca(4);
 ; return 0; }
 EOF
-if { (eval echo configure:2750: \"$ac_link\") 1>&5; (eval $ac_link) 2>&5; } && test -s conftest${ac_exeext}; then
+if { (eval echo configure:2739: \"$ac_link\") 1>&5; (eval $ac_link) 2>&5; } && test -s conftest${ac_exeext}; then
   rm -rf conftest*
   :
 else
@@ -2757,14 +2746,14 @@
     xe_save_c_switch_system="$c_switch_system"
     c_switch_system="$c_switch_system -Kalloca"
     cat > conftest.$ac_ext <<EOF
-#line 2761 "configure"
+#line 2750 "configure"
 #include "confdefs.h"
 
 int main() {
 void *x = alloca(4);
 ; return 0; }
 EOF
-if { (eval echo configure:2768: \"$ac_link\") 1>&5; (eval $ac_link) 2>&5; } && test -s conftest${ac_exeext}; then
+if { (eval echo configure:2757: \"$ac_link\") 1>&5; (eval $ac_link) 2>&5; } && test -s conftest${ac_exeext}; then
   rm -rf conftest*
    need_kalloca=yes 
 else
@@ -2783,7 +2772,7 @@
       if   test "$GCC" = "yes"; then
     CFLAGS="-g -O3 -Wall -Wno-switch -Winline -Wmissing-prototypes"
         CFLAGS="$CFLAGS -Wsign-compare"
-                if test "$xemacs_compiler" != "g++"; then
+                    if test "$xemacs_compiler" != "g++"; then
       CFLAGS="$CFLAGS -Wshadow"
     fi
             test "$have_glibc" != "yes" && CFLAGS="$CFLAGS -Wpointer-arith"
@@ -2802,7 +2791,7 @@
 
 if test "$GCC" = "yes"; then
 echo $ac_n "checking for buggy gcc versions""... $ac_c" 1>&6
-echo "configure:2806: checking for buggy gcc versions" >&5
+echo "configure:2795: checking for buggy gcc versions" >&5
 GCC_VERSION=`$CC --version`
 case `uname -s`:`uname -m`:$GCC_VERSION in
 		    *:sun4*:2.8.1|*:sun4*:egcs-2.90.*)
@@ -2925,7 +2914,7 @@
  fi
 
 echo $ac_n "checking for dynodump""... $ac_c" 1>&6
-echo "configure:2929: checking for dynodump" >&5
+echo "configure:2918: checking for dynodump" >&5
 if test "$unexec" != "unexsol2.o"; then
   echo "$ac_t""no" 1>&6
 else
@@ -2963,12 +2952,12 @@
   done
   
 echo $ac_n "checking for terminateAndUnload in -lC""... $ac_c" 1>&6
-echo "configure:2967: checking for terminateAndUnload in -lC" >&5
+echo "configure:2956: checking for terminateAndUnload in -lC" >&5
 ac_lib_var=`echo C'_'terminateAndUnload | sed 'y%./+-%__p_%'`
 
 xe_check_libs=" -lC "
 cat > conftest.$ac_ext <<EOF
-#line 2972 "configure"
+#line 2961 "configure"
 #include "confdefs.h"
 /* Override any gcc2 internal prototype to avoid an error.  */
 /* We use char because int might match the return type of a gcc2
@@ -2979,7 +2968,7 @@
 terminateAndUnload()
 ; return 0; }
 EOF
-if { (eval echo configure:2983: \"$ac_link\") 1>&5; (eval $ac_link) 2>&5; } && test -s conftest${ac_exeext}; then
+if { (eval echo configure:2972: \"$ac_link\") 1>&5; (eval $ac_link) 2>&5; } && test -s conftest${ac_exeext}; then
   rm -rf conftest*
   eval "ac_cv_lib_$ac_lib_var=yes"
 else
@@ -3087,7 +3076,7 @@
 
 if test "$add_runtime_path" = "yes"; then
       echo $ac_n "checking "for runtime libraries flag"""... $ac_c" 1>&6
-echo "configure:3091: checking "for runtime libraries flag"" >&5
+echo "configure:3080: checking "for runtime libraries flag"" >&5
   case "$opsys" in
     sol2 ) dash_r="-R" ;;
     decosf* | linux* | irix*) dash_r="-rpath " ;;
@@ -3109,14 +3098,14 @@
   done
 fi
         cat > conftest.$ac_ext <<EOF
-#line 3113 "configure"
-#include "confdefs.h"
-
-int main() {
-
-; return 0; }
-EOF
-if { (eval echo configure:3120: \"$ac_link\") 1>&5; (eval $ac_link) 2>&5; } && test -s conftest${ac_exeext}; then
+#line 3102 "configure"
+#include "confdefs.h"
+
+int main() {
+
+; return 0; }
+EOF
+if { (eval echo configure:3109: \"$ac_link\") 1>&5; (eval $ac_link) 2>&5; } && test -s conftest${ac_exeext}; then
   rm -rf conftest*
   dash_r="$try_dash_r"
 else
@@ -3217,10 +3206,10 @@
 fi
 after_morecore_hook_exists=yes
 echo $ac_n "checking for malloc_set_state""... $ac_c" 1>&6
-echo "configure:3221: checking for malloc_set_state" >&5
-
-cat > conftest.$ac_ext <<EOF
-#line 3224 "configure"
+echo "configure:3210: checking for malloc_set_state" >&5
+
+cat > conftest.$ac_ext <<EOF
+#line 3213 "configure"
 #include "confdefs.h"
 /* System header to define __stub macros and hopefully few prototypes,
     which can conflict with char malloc_set_state(); below.  */
@@ -3243,7 +3232,7 @@
 
 ; return 0; }
 EOF
-if { (eval echo configure:3247: \"$ac_link\") 1>&5; (eval $ac_link) 2>&5; } && test -s conftest${ac_exeext}; then
+if { (eval echo configure:3236: \"$ac_link\") 1>&5; (eval $ac_link) 2>&5; } && test -s conftest${ac_exeext}; then
   rm -rf conftest*
   eval "ac_cv_func_malloc_set_state=yes"
 else
@@ -3263,16 +3252,16 @@
 fi
 
 echo $ac_n "checking whether __after_morecore_hook exists""... $ac_c" 1>&6
-echo "configure:3267: checking whether __after_morecore_hook exists" >&5
-cat > conftest.$ac_ext <<EOF
-#line 3269 "configure"
+echo "configure:3256: checking whether __after_morecore_hook exists" >&5
+cat > conftest.$ac_ext <<EOF
+#line 3258 "configure"
 #include "confdefs.h"
 extern void (* __after_morecore_hook)();
 int main() {
 __after_morecore_hook = 0
 ; return 0; }
 EOF
-if { (eval echo configure:3276: \"$ac_link\") 1>&5; (eval $ac_link) 2>&5; } && test -s conftest${ac_exeext}; then
+if { (eval echo configure:3265: \"$ac_link\") 1>&5; (eval $ac_link) 2>&5; } && test -s conftest${ac_exeext}; then
   rm -rf conftest*
   echo "$ac_t""yes" 1>&6
 else
@@ -3328,7 +3317,7 @@
 # Extract the first word of "ranlib", so it can be a program name with args.
 set dummy ranlib; ac_word=$2
 echo $ac_n "checking for $ac_word""... $ac_c" 1>&6
-echo "configure:3332: checking for $ac_word" >&5
+echo "configure:3321: checking for $ac_word" >&5
 
 if test -n "$RANLIB"; then
   ac_cv_prog_RANLIB="$RANLIB" # Let the user override the test.
@@ -3383,7 +3372,7 @@
 # SVR4 /usr/ucb/install, which tries to use the nonexistent group "staff"
 # ./install, which can be erroneously created by make from ./install.sh.
 echo $ac_n "checking for a BSD compatible install""... $ac_c" 1>&6
-echo "configure:3387: checking for a BSD compatible install" >&5
+echo "configure:3376: checking for a BSD compatible install" >&5
 if test -z "$INSTALL"; then
 
   IFS="${IFS= 	}"; ac_save_IFS="$IFS"; IFS=":"
@@ -3437,7 +3426,7 @@
 # Extract the first word of "$ac_prog", so it can be a program name with args.
 set dummy $ac_prog; ac_word=$2
 echo $ac_n "checking for $ac_word""... $ac_c" 1>&6
-echo "configure:3441: checking for $ac_word" >&5
+echo "configure:3430: checking for $ac_word" >&5
 
 if test -n "$YACC"; then
   ac_cv_prog_YACC="$YACC" # Let the user override the test.
@@ -3469,15 +3458,15 @@
 do
 ac_safe=`echo "$ac_hdr" | sed 'y%./+-%__p_%'`
 echo $ac_n "checking for $ac_hdr""... $ac_c" 1>&6
-echo "configure:3473: checking for $ac_hdr" >&5
-
-cat > conftest.$ac_ext <<EOF
-#line 3476 "configure"
+echo "configure:3462: checking for $ac_hdr" >&5
+
+cat > conftest.$ac_ext <<EOF
+#line 3465 "configure"
 #include "confdefs.h"
 #include <$ac_hdr>
 EOF
 ac_try="$ac_cpp conftest.$ac_ext >/dev/null 2>conftest.out"
-{ (eval echo configure:3481: \"$ac_try\") 1>&5; (eval $ac_try) 2>&5; }
+{ (eval echo configure:3470: \"$ac_try\") 1>&5; (eval $ac_try) 2>&5; }
 ac_err=`grep -v '^ *+' conftest.out | grep -v "^conftest.${ac_ext}\$"`
 if test -z "$ac_err"; then
   rm -rf conftest*
@@ -3507,10 +3496,10 @@
 done
 
 echo $ac_n "checking for sys/wait.h that is POSIX.1 compatible""... $ac_c" 1>&6
-echo "configure:3511: checking for sys/wait.h that is POSIX.1 compatible" >&5
-
-cat > conftest.$ac_ext <<EOF
-#line 3514 "configure"
+echo "configure:3500: checking for sys/wait.h that is POSIX.1 compatible" >&5
+
+cat > conftest.$ac_ext <<EOF
+#line 3503 "configure"
 #include "confdefs.h"
 #include <sys/types.h>
 #include <sys/wait.h>
@@ -3526,7 +3515,7 @@
 s = WIFEXITED (s) ? WEXITSTATUS (s) : 1;
 ; return 0; }
 EOF
-if { (eval echo configure:3530: \"$ac_compile\") 1>&5; (eval $ac_compile) 2>&5; }; then
+if { (eval echo configure:3519: \"$ac_compile\") 1>&5; (eval $ac_compile) 2>&5; }; then
   rm -rf conftest*
   ac_cv_header_sys_wait_h=yes
 else
@@ -3550,10 +3539,10 @@
 fi
 
 echo $ac_n "checking for ANSI C header files""... $ac_c" 1>&6
-echo "configure:3554: checking for ANSI C header files" >&5
-
-cat > conftest.$ac_ext <<EOF
-#line 3557 "configure"
+echo "configure:3543: checking for ANSI C header files" >&5
+
+cat > conftest.$ac_ext <<EOF
+#line 3546 "configure"
 #include "confdefs.h"
 #include <stdlib.h>
 #include <stdarg.h>
@@ -3561,7 +3550,7 @@
 #include <float.h>
 EOF
 ac_try="$ac_cpp conftest.$ac_ext >/dev/null 2>conftest.out"
-{ (eval echo configure:3565: \"$ac_try\") 1>&5; (eval $ac_try) 2>&5; }
+{ (eval echo configure:3554: \"$ac_try\") 1>&5; (eval $ac_try) 2>&5; }
 ac_err=`grep -v '^ *+' conftest.out | grep -v "^conftest.${ac_ext}\$"`
 if test -z "$ac_err"; then
   rm -rf conftest*
@@ -3578,7 +3567,7 @@
 if test $ac_cv_header_stdc = yes; then
   # SunOS 4.x string.h does not declare mem*, contrary to ANSI.
 cat > conftest.$ac_ext <<EOF
-#line 3582 "configure"
+#line 3571 "configure"
 #include "confdefs.h"
 #include <string.h>
 EOF
@@ -3596,7 +3585,7 @@
 if test $ac_cv_header_stdc = yes; then
   # ISC 2.0.2 stdlib.h does not declare free, contrary to ANSI.
 cat > conftest.$ac_ext <<EOF
-#line 3600 "configure"
+#line 3589 "configure"
 #include "confdefs.h"
 #include <stdlib.h>
 EOF
@@ -3614,7 +3603,7 @@
 if test $ac_cv_header_stdc = yes; then
   # /bin/cc in Irix-4.0.5 gets non-ANSI ctype macros unless using -ansi.
 cat > conftest.$ac_ext <<EOF
-#line 3618 "configure"
+#line 3607 "configure"
 #include "confdefs.h"
 #include <ctype.h>
 #define ISLOWER(c) ('a' <= (c) && (c) <= 'z')
@@ -3625,7 +3614,7 @@
 exit (0); }
 
 EOF
-if { (eval echo configure:3629: \"$ac_link\") 1>&5; (eval $ac_link) 2>&5; } && test -s conftest && (./conftest; exit $?) 2>&5
+if { (eval echo configure:3618: \"$ac_link\") 1>&5; (eval $ac_link) 2>&5; } && test -s conftest && (./conftest; exit $?) 2>&5
 then
   :
 else
@@ -3651,10 +3640,10 @@
 fi
 
 echo $ac_n "checking whether time.h and sys/time.h may both be included""... $ac_c" 1>&6
-echo "configure:3655: checking whether time.h and sys/time.h may both be included" >&5
-
-cat > conftest.$ac_ext <<EOF
-#line 3658 "configure"
+echo "configure:3644: checking whether time.h and sys/time.h may both be included" >&5
+
+cat > conftest.$ac_ext <<EOF
+#line 3647 "configure"
 #include "confdefs.h"
 #include <sys/types.h>
 #include <sys/time.h>
@@ -3663,7 +3652,7 @@
 struct tm *tp;
 ; return 0; }
 EOF
-if { (eval echo configure:3667: \"$ac_compile\") 1>&5; (eval $ac_compile) 2>&5; }; then
+if { (eval echo configure:3656: \"$ac_compile\") 1>&5; (eval $ac_compile) 2>&5; }; then
   rm -rf conftest*
   ac_cv_header_time=yes
 else
@@ -3687,10 +3676,10 @@
 fi
 
 echo $ac_n "checking for sys_siglist declaration in signal.h or unistd.h""... $ac_c" 1>&6
-echo "configure:3691: checking for sys_siglist declaration in signal.h or unistd.h" >&5
-
-cat > conftest.$ac_ext <<EOF
-#line 3694 "configure"
+echo "configure:3680: checking for sys_siglist declaration in signal.h or unistd.h" >&5
+
+cat > conftest.$ac_ext <<EOF
+#line 3683 "configure"
 #include "confdefs.h"
 #include <sys/types.h>
 #include <signal.h>
@@ -3702,7 +3691,7 @@
 char *msg = *(sys_siglist + 1);
 ; return 0; }
 EOF
-if { (eval echo configure:3706: \"$ac_compile\") 1>&5; (eval $ac_compile) 2>&5; }; then
+if { (eval echo configure:3695: \"$ac_compile\") 1>&5; (eval $ac_compile) 2>&5; }; then
   rm -rf conftest*
   ac_cv_decl_sys_siglist=yes
 else
@@ -3728,9 +3717,9 @@
 
 
 echo $ac_n "checking for utime""... $ac_c" 1>&6
-echo "configure:3732: checking for utime" >&5
-cat > conftest.$ac_ext <<EOF
-#line 3734 "configure"
+echo "configure:3721: checking for utime" >&5
+cat > conftest.$ac_ext <<EOF
+#line 3723 "configure"
 #include "confdefs.h"
 #include <sys/types.h>
 #include <utime.h>
@@ -3738,7 +3727,7 @@
 struct utimbuf x; x.actime = x.modtime = 0; utime ("/", &x);
 ; return 0; }
 EOF
-if { (eval echo configure:3742: \"$ac_compile\") 1>&5; (eval $ac_compile) 2>&5; }; then
+if { (eval echo configure:3731: \"$ac_compile\") 1>&5; (eval $ac_compile) 2>&5; }; then
   rm -rf conftest*
   echo "$ac_t""yes" 1>&6
    { test "$extra_verbose" = "yes" && cat << \EOF
@@ -3757,10 +3746,10 @@
       for ac_func in utimes
 do
 echo $ac_n "checking for $ac_func""... $ac_c" 1>&6
-echo "configure:3761: checking for $ac_func" >&5
-
-cat > conftest.$ac_ext <<EOF
-#line 3764 "configure"
+echo "configure:3750: checking for $ac_func" >&5
+
+cat > conftest.$ac_ext <<EOF
+#line 3753 "configure"
 #include "confdefs.h"
 /* System header to define __stub macros and hopefully few prototypes,
     which can conflict with char $ac_func(); below.  */
@@ -3783,7 +3772,7 @@
 
 ; return 0; }
 EOF
-if { (eval echo configure:3787: \"$ac_link\") 1>&5; (eval $ac_link) 2>&5; } && test -s conftest${ac_exeext}; then
+if { (eval echo configure:3776: \"$ac_link\") 1>&5; (eval $ac_link) 2>&5; } && test -s conftest${ac_exeext}; then
   rm -rf conftest*
   eval "ac_cv_func_$ac_func=yes"
 else
@@ -3815,10 +3804,10 @@
 
 
 echo $ac_n "checking return type of signal handlers""... $ac_c" 1>&6
-echo "configure:3819: checking return type of signal handlers" >&5
-
-cat > conftest.$ac_ext <<EOF
-#line 3822 "configure"
+echo "configure:3808: checking return type of signal handlers" >&5
+
+cat > conftest.$ac_ext <<EOF
+#line 3811 "configure"
 #include "confdefs.h"
 #include <sys/types.h>
 #include <signal.h>
@@ -3835,7 +3824,7 @@
 int i;
 ; return 0; }
 EOF
-if { (eval echo configure:3839: \"$ac_compile\") 1>&5; (eval $ac_compile) 2>&5; }; then
+if { (eval echo configure:3828: \"$ac_compile\") 1>&5; (eval $ac_compile) 2>&5; }; then
   rm -rf conftest*
   ac_cv_type_signal=void
 else
@@ -3857,10 +3846,10 @@
 
 
 echo $ac_n "checking for size_t""... $ac_c" 1>&6
-echo "configure:3861: checking for size_t" >&5
-
-cat > conftest.$ac_ext <<EOF
-#line 3864 "configure"
+echo "configure:3850: checking for size_t" >&5
+
+cat > conftest.$ac_ext <<EOF
+#line 3853 "configure"
 #include "confdefs.h"
 #include <sys/types.h>
 #if STDC_HEADERS
@@ -3891,10 +3880,10 @@
 fi
 
 echo $ac_n "checking for pid_t""... $ac_c" 1>&6
-echo "configure:3895: checking for pid_t" >&5
-
-cat > conftest.$ac_ext <<EOF
-#line 3898 "configure"
+echo "configure:3884: checking for pid_t" >&5
+
+cat > conftest.$ac_ext <<EOF
+#line 3887 "configure"
 #include "confdefs.h"
 #include <sys/types.h>
 #if STDC_HEADERS
@@ -3925,10 +3914,10 @@
 fi
 
 echo $ac_n "checking for uid_t in sys/types.h""... $ac_c" 1>&6
-echo "configure:3929: checking for uid_t in sys/types.h" >&5
-
-cat > conftest.$ac_ext <<EOF
-#line 3932 "configure"
+echo "configure:3918: checking for uid_t in sys/types.h" >&5
+
+cat > conftest.$ac_ext <<EOF
+#line 3921 "configure"
 #include "confdefs.h"
 #include <sys/types.h>
 EOF
@@ -3964,10 +3953,10 @@
 fi
 
 echo $ac_n "checking for mode_t""... $ac_c" 1>&6
-echo "configure:3968: checking for mode_t" >&5
-
-cat > conftest.$ac_ext <<EOF
-#line 3971 "configure"
+echo "configure:3957: checking for mode_t" >&5
+
+cat > conftest.$ac_ext <<EOF
+#line 3960 "configure"
 #include "confdefs.h"
 #include <sys/types.h>
 #if STDC_HEADERS
@@ -3998,10 +3987,10 @@
 fi
 
 echo $ac_n "checking for off_t""... $ac_c" 1>&6
-echo "configure:4002: checking for off_t" >&5
-
-cat > conftest.$ac_ext <<EOF
-#line 4005 "configure"
+echo "configure:3991: checking for off_t" >&5
+
+cat > conftest.$ac_ext <<EOF
+#line 3994 "configure"
 #include "confdefs.h"
 #include <sys/types.h>
 #if STDC_HEADERS
@@ -4032,10 +4021,10 @@
 fi
 
 echo $ac_n "checking for ssize_t""... $ac_c" 1>&6
-echo "configure:4036: checking for ssize_t" >&5
-
-cat > conftest.$ac_ext <<EOF
-#line 4039 "configure"
+echo "configure:4025: checking for ssize_t" >&5
+
+cat > conftest.$ac_ext <<EOF
+#line 4028 "configure"
 #include "confdefs.h"
 #include <sys/types.h>
 #if STDC_HEADERS
@@ -4067,9 +4056,9 @@
 
 
 echo $ac_n "checking for socklen_t""... $ac_c" 1>&6
-echo "configure:4071: checking for socklen_t" >&5
-cat > conftest.$ac_ext <<EOF
-#line 4073 "configure"
+echo "configure:4060: checking for socklen_t" >&5
+cat > conftest.$ac_ext <<EOF
+#line 4062 "configure"
 #include "confdefs.h"
 #include <sys/socket.h>
 socklen_t x;
@@ -4078,7 +4067,7 @@
 
 ; return 0; }
 EOF
-if { (eval echo configure:4082: \"$ac_compile\") 1>&5; (eval $ac_compile) 2>&5; }; then
+if { (eval echo configure:4071: \"$ac_compile\") 1>&5; (eval $ac_compile) 2>&5; }; then
   rm -rf conftest*
   echo "$ac_t""yes" 1>&6
 else
@@ -4087,7 +4076,7 @@
   rm -rf conftest*
   
 cat > conftest.$ac_ext <<EOF
-#line 4091 "configure"
+#line 4080 "configure"
 #include "confdefs.h"
 #include <sys/socket.h>
 int accept (int, struct sockaddr *, size_t *);
@@ -4096,7 +4085,7 @@
 
 ; return 0; }
 EOF
-if { (eval echo configure:4100: \"$ac_compile\") 1>&5; (eval $ac_compile) 2>&5; }; then
+if { (eval echo configure:4089: \"$ac_compile\") 1>&5; (eval $ac_compile) 2>&5; }; then
   rm -rf conftest*
   
 echo "$ac_t""size_t" 1>&6
@@ -4128,9 +4117,9 @@
 rm -f conftest*
 
 echo $ac_n "checking for struct timeval""... $ac_c" 1>&6
-echo "configure:4132: checking for struct timeval" >&5
-cat > conftest.$ac_ext <<EOF
-#line 4134 "configure"
+echo "configure:4121: checking for struct timeval" >&5
+cat > conftest.$ac_ext <<EOF
+#line 4123 "configure"
 #include "confdefs.h"
 #ifdef TIME_WITH_SYS_TIME
 #include <sys/time.h>
@@ -4146,7 +4135,7 @@
 static struct timeval x; x.tv_sec = x.tv_usec;
 ; return 0; }
 EOF
-if { (eval echo configure:4150: \"$ac_compile\") 1>&5; (eval $ac_compile) 2>&5; }; then
+if { (eval echo configure:4139: \"$ac_compile\") 1>&5; (eval $ac_compile) 2>&5; }; then
   rm -rf conftest*
   echo "$ac_t""yes" 1>&6
   HAVE_TIMEVAL=yes
@@ -4168,10 +4157,10 @@
 rm -f conftest*
 
 echo $ac_n "checking whether struct tm is in sys/time.h or time.h""... $ac_c" 1>&6
-echo "configure:4172: checking whether struct tm is in sys/time.h or time.h" >&5
-
-cat > conftest.$ac_ext <<EOF
-#line 4175 "configure"
+echo "configure:4161: checking whether struct tm is in sys/time.h or time.h" >&5
+
+cat > conftest.$ac_ext <<EOF
+#line 4164 "configure"
 #include "confdefs.h"
 #include <sys/types.h>
 #include <time.h>
@@ -4179,7 +4168,7 @@
 struct tm *tp; tp->tm_sec;
 ; return 0; }
 EOF
-if { (eval echo configure:4183: \"$ac_compile\") 1>&5; (eval $ac_compile) 2>&5; }; then
+if { (eval echo configure:4172: \"$ac_compile\") 1>&5; (eval $ac_compile) 2>&5; }; then
   rm -rf conftest*
   ac_cv_struct_tm=time.h
 else
@@ -4203,10 +4192,10 @@
 fi
 
 echo $ac_n "checking for tm_zone in struct tm""... $ac_c" 1>&6
-echo "configure:4207: checking for tm_zone in struct tm" >&5
-
-cat > conftest.$ac_ext <<EOF
-#line 4210 "configure"
+echo "configure:4196: checking for tm_zone in struct tm" >&5
+
+cat > conftest.$ac_ext <<EOF
+#line 4199 "configure"
 #include "confdefs.h"
 #include <sys/types.h>
 #include <$ac_cv_struct_tm>
@@ -4214,7 +4203,7 @@
 struct tm tm; tm.tm_zone;
 ; return 0; }
 EOF
-if { (eval echo configure:4218: \"$ac_compile\") 1>&5; (eval $ac_compile) 2>&5; }; then
+if { (eval echo configure:4207: \"$ac_compile\") 1>&5; (eval $ac_compile) 2>&5; }; then
   rm -rf conftest*
   ac_cv_struct_tm_zone=yes
 else
@@ -4237,10 +4226,10 @@
 
 else
   echo $ac_n "checking for tzname""... $ac_c" 1>&6
-echo "configure:4241: checking for tzname" >&5
-
-cat > conftest.$ac_ext <<EOF
-#line 4244 "configure"
+echo "configure:4230: checking for tzname" >&5
+
+cat > conftest.$ac_ext <<EOF
+#line 4233 "configure"
 #include "confdefs.h"
 #include <time.h>
 #ifndef tzname /* For SGI.  */
@@ -4250,7 +4239,7 @@
 atoi(*tzname);
 ; return 0; }
 EOF
-if { (eval echo configure:4254: \"$ac_link\") 1>&5; (eval $ac_link) 2>&5; } && test -s conftest${ac_exeext}; then
+if { (eval echo configure:4243: \"$ac_link\") 1>&5; (eval $ac_link) 2>&5; } && test -s conftest${ac_exeext}; then
   rm -rf conftest*
   ac_cv_var_tzname=yes
 else
@@ -4276,10 +4265,10 @@
 
 
 echo $ac_n "checking for working const""... $ac_c" 1>&6
-echo "configure:4280: checking for working const" >&5
-
-cat > conftest.$ac_ext <<EOF
-#line 4283 "configure"
+echo "configure:4269: checking for working const" >&5
+
+cat > conftest.$ac_ext <<EOF
+#line 4272 "configure"
 #include "confdefs.h"
 
 int main() {
@@ -4328,7 +4317,7 @@
 
 ; return 0; }
 EOF
-if { (eval echo configure:4332: \"$ac_compile\") 1>&5; (eval $ac_compile) 2>&5; }; then
+if { (eval echo configure:4321: \"$ac_compile\") 1>&5; (eval $ac_compile) 2>&5; }; then
   rm -rf conftest*
   ac_cv_c_const=yes
 else
@@ -4353,7 +4342,7 @@
 
 
 echo $ac_n "checking whether ${MAKE-make} sets \${MAKE}""... $ac_c" 1>&6
-echo "configure:4357: checking whether ${MAKE-make} sets \${MAKE}" >&5
+echo "configure:4346: checking whether ${MAKE-make} sets \${MAKE}" >&5
 set dummy ${MAKE-make}; ac_make=`echo "$2" | sed 'y%./+-%__p_%'`
 
 cat > conftestmake <<\EOF
@@ -4378,12 +4367,12 @@
 
 
 echo $ac_n "checking whether byte ordering is bigendian""... $ac_c" 1>&6
-echo "configure:4382: checking whether byte ordering is bigendian" >&5
+echo "configure:4371: checking whether byte ordering is bigendian" >&5
 
 ac_cv_c_bigendian=unknown
 # See if sys/param.h defines the BYTE_ORDER macro.
 cat > conftest.$ac_ext <<EOF
-#line 4387 "configure"
+#line 4376 "configure"
 #include "confdefs.h"
 #include <sys/types.h>
 #include <sys/param.h>
@@ -4394,11 +4383,11 @@
 #endif
 ; return 0; }
 EOF
-if { (eval echo configure:4398: \"$ac_compile\") 1>&5; (eval $ac_compile) 2>&5; }; then
+if { (eval echo configure:4387: \"$ac_compile\") 1>&5; (eval $ac_compile) 2>&5; }; then
   rm -rf conftest*
   # It does; now see whether it defined to BIG_ENDIAN or not.
 cat > conftest.$ac_ext <<EOF
-#line 4402 "configure"
+#line 4391 "configure"
 #include "confdefs.h"
 #include <sys/types.h>
 #include <sys/param.h>
@@ -4409,7 +4398,7 @@
 #endif
 ; return 0; }
 EOF
-if { (eval echo configure:4413: \"$ac_compile\") 1>&5; (eval $ac_compile) 2>&5; }; then
+if { (eval echo configure:4402: \"$ac_compile\") 1>&5; (eval $ac_compile) 2>&5; }; then
   rm -rf conftest*
   ac_cv_c_bigendian=yes
 else
@@ -4426,7 +4415,7 @@
 rm -f conftest*
 if test $ac_cv_c_bigendian = unknown; then
 cat > conftest.$ac_ext <<EOF
-#line 4430 "configure"
+#line 4419 "configure"
 #include "confdefs.h"
 main () {
   /* Are we little or big endian?  From Harbison&Steele.  */
@@ -4439,7 +4428,7 @@
   exit (u.c[sizeof (long) - 1] == 1);
 }
 EOF
-if { (eval echo configure:4443: \"$ac_link\") 1>&5; (eval $ac_link) 2>&5; } && test -s conftest && (./conftest; exit $?) 2>&5
+if { (eval echo configure:4432: \"$ac_link\") 1>&5; (eval $ac_link) 2>&5; } && test -s conftest && (./conftest; exit $?) 2>&5
 then
   ac_cv_c_bigendian=no
 else
@@ -4466,13 +4455,12 @@
 
 
 echo $ac_n "checking size of short""... $ac_c" 1>&6
-echo "configure:4470: checking size of short" >&5
-
-cat > conftest.$ac_ext <<EOF
-#line 4473 "configure"
+echo "configure:4459: checking size of short" >&5
+
+cat > conftest.$ac_ext <<EOF
+#line 4462 "configure"
 #include "confdefs.h"
 #include <stdio.h>
-#include <sys/types.h>
 main()
 {
   FILE *f=fopen("conftestval", "w");
@@ -4481,7 +4469,7 @@
   exit(0);
 }
 EOF
-if { (eval echo configure:4485: \"$ac_link\") 1>&5; (eval $ac_link) 2>&5; } && test -s conftest && (./conftest; exit $?) 2>&5
+if { (eval echo configure:4473: \"$ac_link\") 1>&5; (eval $ac_link) 2>&5; } && test -s conftest && (./conftest; exit $?) 2>&5
 then
   ac_cv_sizeof_short=`cat conftestval`
 else
@@ -4509,13 +4497,12 @@
   exit 1
 fi
 echo $ac_n "checking size of int""... $ac_c" 1>&6
-echo "configure:4513: checking size of int" >&5
-
-cat > conftest.$ac_ext <<EOF
-#line 4516 "configure"
+echo "configure:4501: checking size of int" >&5
+
+cat > conftest.$ac_ext <<EOF
+#line 4504 "configure"
 #include "confdefs.h"
 #include <stdio.h>
-#include <sys/types.h>
 main()
 {
   FILE *f=fopen("conftestval", "w");
@@ -4524,7 +4511,7 @@
   exit(0);
 }
 EOF
-if { (eval echo configure:4528: \"$ac_link\") 1>&5; (eval $ac_link) 2>&5; } && test -s conftest && (./conftest; exit $?) 2>&5
+if { (eval echo configure:4515: \"$ac_link\") 1>&5; (eval $ac_link) 2>&5; } && test -s conftest && (./conftest; exit $?) 2>&5
 then
   ac_cv_sizeof_int=`cat conftestval`
 else
@@ -4546,13 +4533,12 @@
 
 
 echo $ac_n "checking size of long""... $ac_c" 1>&6
-echo "configure:4550: checking size of long" >&5
-
-cat > conftest.$ac_ext <<EOF
-#line 4553 "configure"
+echo "configure:4537: checking size of long" >&5
+
+cat > conftest.$ac_ext <<EOF
+#line 4540 "configure"
 #include "confdefs.h"
 #include <stdio.h>
-#include <sys/types.h>
 main()
 {
   FILE *f=fopen("conftestval", "w");
@@ -4561,7 +4547,7 @@
   exit(0);
 }
 EOF
-if { (eval echo configure:4565: \"$ac_link\") 1>&5; (eval $ac_link) 2>&5; } && test -s conftest && (./conftest; exit $?) 2>&5
+if { (eval echo configure:4551: \"$ac_link\") 1>&5; (eval $ac_link) 2>&5; } && test -s conftest && (./conftest; exit $?) 2>&5
 then
   ac_cv_sizeof_long=`cat conftestval`
 else
@@ -4583,13 +4569,12 @@
 
 
 echo $ac_n "checking size of long long""... $ac_c" 1>&6
-echo "configure:4587: checking size of long long" >&5
-
-cat > conftest.$ac_ext <<EOF
-#line 4590 "configure"
+echo "configure:4573: checking size of long long" >&5
+
+cat > conftest.$ac_ext <<EOF
+#line 4576 "configure"
 #include "confdefs.h"
 #include <stdio.h>
-#include <sys/types.h>
 main()
 {
   FILE *f=fopen("conftestval", "w");
@@ -4598,7 +4583,7 @@
   exit(0);
 }
 EOF
-if { (eval echo configure:4602: \"$ac_link\") 1>&5; (eval $ac_link) 2>&5; } && test -s conftest && (./conftest; exit $?) 2>&5
+if { (eval echo configure:4587: \"$ac_link\") 1>&5; (eval $ac_link) 2>&5; } && test -s conftest && (./conftest; exit $?) 2>&5
 then
   ac_cv_sizeof_long_long=`cat conftestval`
 else
@@ -4620,13 +4605,12 @@
 
 
 echo $ac_n "checking size of void *""... $ac_c" 1>&6
-echo "configure:4624: checking size of void *" >&5
-
-cat > conftest.$ac_ext <<EOF
-#line 4627 "configure"
+echo "configure:4609: checking size of void *" >&5
+
+cat > conftest.$ac_ext <<EOF
+#line 4612 "configure"
 #include "confdefs.h"
 #include <stdio.h>
-#include <sys/types.h>
 main()
 {
   FILE *f=fopen("conftestval", "w");
@@ -4635,7 +4619,7 @@
   exit(0);
 }
 EOF
-if { (eval echo configure:4639: \"$ac_link\") 1>&5; (eval $ac_link) 2>&5; } && test -s conftest && (./conftest; exit $?) 2>&5
+if { (eval echo configure:4623: \"$ac_link\") 1>&5; (eval $ac_link) 2>&5; } && test -s conftest && (./conftest; exit $?) 2>&5
 then
   ac_cv_sizeof_void_p=`cat conftestval`
 else
@@ -4658,7 +4642,7 @@
 
 
 echo $ac_n "checking for long file names""... $ac_c" 1>&6
-echo "configure:4662: checking for long file names" >&5
+echo "configure:4646: checking for long file names" >&5
 
 ac_cv_sys_long_file_names=yes
 # Test for long file names in all the places we know might matter:
@@ -4704,10 +4688,10 @@
 
 
 echo $ac_n "checking for sin""... $ac_c" 1>&6
-echo "configure:4708: checking for sin" >&5
-
-cat > conftest.$ac_ext <<EOF
-#line 4711 "configure"
+echo "configure:4692: checking for sin" >&5
+
+cat > conftest.$ac_ext <<EOF
+#line 4695 "configure"
 #include "confdefs.h"
 /* System header to define __stub macros and hopefully few prototypes,
     which can conflict with char sin(); below.  */
@@ -4730,7 +4714,7 @@
 
 ; return 0; }
 EOF
-if { (eval echo configure:4734: \"$ac_link\") 1>&5; (eval $ac_link) 2>&5; } && test -s conftest${ac_exeext}; then
+if { (eval echo configure:4718: \"$ac_link\") 1>&5; (eval $ac_link) 2>&5; } && test -s conftest${ac_exeext}; then
   rm -rf conftest*
   eval "ac_cv_func_sin=yes"
 else
@@ -4748,12 +4732,12 @@
   echo "$ac_t""no" 1>&6
 
 echo $ac_n "checking for sin in -lm""... $ac_c" 1>&6
-echo "configure:4752: checking for sin in -lm" >&5
+echo "configure:4736: checking for sin in -lm" >&5
 ac_lib_var=`echo m'_'sin | sed 'y%./+-%__p_%'`
 
 xe_check_libs=" -lm "
 cat > conftest.$ac_ext <<EOF
-#line 4757 "configure"
+#line 4741 "configure"
 #include "confdefs.h"
 /* Override any gcc2 internal prototype to avoid an error.  */
 /* We use char because int might match the return type of a gcc2
@@ -4764,7 +4748,7 @@
 sin()
 ; return 0; }
 EOF
-if { (eval echo configure:4768: \"$ac_link\") 1>&5; (eval $ac_link) 2>&5; } && test -s conftest${ac_exeext}; then
+if { (eval echo configure:4752: \"$ac_link\") 1>&5; (eval $ac_link) 2>&5; } && test -s conftest${ac_exeext}; then
   rm -rf conftest*
   eval "ac_cv_lib_$ac_lib_var=yes"
 else
@@ -4808,14 +4792,14 @@
 
 
 cat > conftest.$ac_ext <<EOF
-#line 4812 "configure"
+#line 4796 "configure"
 #include "confdefs.h"
 #include <math.h>
 int main() {
 return atanh(1.0) + asinh(1.0) + acosh(1.0); 
 ; return 0; }
 EOF
-if { (eval echo configure:4819: \"$ac_link\") 1>&5; (eval $ac_link) 2>&5; } && test -s conftest${ac_exeext}; then
+if { (eval echo configure:4803: \"$ac_link\") 1>&5; (eval $ac_link) 2>&5; } && test -s conftest${ac_exeext}; then
   rm -rf conftest*
   { test "$extra_verbose" = "yes" && cat << \EOF
     Defining HAVE_INVERSE_HYPERBOLIC
@@ -4834,10 +4818,10 @@
 for ac_func in mkstemp
 do
 echo $ac_n "checking for $ac_func""... $ac_c" 1>&6
-echo "configure:4838: checking for $ac_func" >&5
-
-cat > conftest.$ac_ext <<EOF
-#line 4841 "configure"
+echo "configure:4822: checking for $ac_func" >&5
+
+cat > conftest.$ac_ext <<EOF
+#line 4825 "configure"
 #include "confdefs.h"
 /* System header to define __stub macros and hopefully few prototypes,
     which can conflict with char $ac_func(); below.  */
@@ -4860,7 +4844,7 @@
 
 ; return 0; }
 EOF
-if { (eval echo configure:4864: \"$ac_link\") 1>&5; (eval $ac_link) 2>&5; } && test -s conftest${ac_exeext}; then
+if { (eval echo configure:4848: \"$ac_link\") 1>&5; (eval $ac_link) 2>&5; } && test -s conftest${ac_exeext}; then
   rm -rf conftest*
   eval "ac_cv_func_$ac_func=yes"
 else
@@ -4889,14 +4873,14 @@
 
 
 echo "checking type of mail spool file locking" 1>&6
-echo "configure:4893: checking type of mail spool file locking" >&5
+echo "configure:4877: checking type of mail spool file locking" >&5
 for ac_func in lockf flock
 do
 echo $ac_n "checking for $ac_func""... $ac_c" 1>&6
-echo "configure:4897: checking for $ac_func" >&5
-
-cat > conftest.$ac_ext <<EOF
-#line 4900 "configure"
+echo "configure:4881: checking for $ac_func" >&5
+
+cat > conftest.$ac_ext <<EOF
+#line 4884 "configure"
 #include "confdefs.h"
 /* System header to define __stub macros and hopefully few prototypes,
     which can conflict with char $ac_func(); below.  */
@@ -4919,7 +4903,7 @@
 
 ; return 0; }
 EOF
-if { (eval echo configure:4923: \"$ac_link\") 1>&5; (eval $ac_link) 2>&5; } && test -s conftest${ac_exeext}; then
+if { (eval echo configure:4907: \"$ac_link\") 1>&5; (eval $ac_link) 2>&5; } && test -s conftest${ac_exeext}; then
   rm -rf conftest*
   eval "ac_cv_func_$ac_func=yes"
 else
@@ -5001,12 +4985,12 @@
 case "$opsys" in decosf*)
   
 echo $ac_n "checking for cma_open in -lpthreads""... $ac_c" 1>&6
-echo "configure:5005: checking for cma_open in -lpthreads" >&5
+echo "configure:4989: checking for cma_open in -lpthreads" >&5
 ac_lib_var=`echo pthreads'_'cma_open | sed 'y%./+-%__p_%'`
 
 xe_check_libs=" -lpthreads "
 cat > conftest.$ac_ext <<EOF
-#line 5010 "configure"
+#line 4994 "configure"
 #include "confdefs.h"
 /* Override any gcc2 internal prototype to avoid an error.  */
 /* We use char because int might match the return type of a gcc2
@@ -5017,7 +5001,7 @@
 cma_open()
 ; return 0; }
 EOF
-if { (eval echo configure:5021: \"$ac_link\") 1>&5; (eval $ac_link) 2>&5; } && test -s conftest${ac_exeext}; then
+if { (eval echo configure:5005: \"$ac_link\") 1>&5; (eval $ac_link) 2>&5; } && test -s conftest${ac_exeext}; then
   rm -rf conftest*
   eval "ac_cv_lib_$ac_lib_var=yes"
 else
@@ -5054,7 +5038,7 @@
 
 
 echo $ac_n "checking whether the -xildoff compiler flag is required""... $ac_c" 1>&6
-echo "configure:5058: checking whether the -xildoff compiler flag is required" >&5
+echo "configure:5042: checking whether the -xildoff compiler flag is required" >&5
 if   ${CC-cc} '-###' -xildon  no_such_file.c 2>&1 | grep '^[^ ]*/ild ' > /dev/null ; then
   if ${CC-cc} '-###' -xildoff no_such_file.c 2>&1 | grep '^[^ ]*/ild ' > /dev/null ;
     then echo "$ac_t""no" 1>&6;
@@ -5066,7 +5050,7 @@
 if test "$opsys" = "sol2"; then
   if test "$os_release" -ge 56; then
     echo $ac_n "checking for \"-z ignore\" linker flag""... $ac_c" 1>&6
-echo "configure:5070: checking for \"-z ignore\" linker flag" >&5
+echo "configure:5054: checking for \"-z ignore\" linker flag" >&5
     case "`ld -h 2>&1`" in
       *-z\ ignore\|record* ) echo "$ac_t""yes" 1>&6
         ld_switch_site="-z ignore $ld_switch_site" &&  if test "$extra_verbose" = "yes"; then echo "    Prepending \"-z ignore\" to \$ld_switch_site"; fi ;;
@@ -5077,7 +5061,7 @@
 
 if test "$pdump" != "yes"; then
   echo $ac_n "checking for \"-z nocombreloc\" linker flag""... $ac_c" 1>&6
-echo "configure:5081: checking for \"-z nocombreloc\" linker flag" >&5
+echo "configure:5065: checking for \"-z nocombreloc\" linker flag" >&5
   case "`ld --help 2>&1`" in
     *-z\ nocombreloc* ) echo "$ac_t""yes" 1>&6
       ld_switch_site="-z nocombreloc $ld_switch_site" &&  if test "$extra_verbose" = "yes"; then echo "    Prepending \"-z nocombreloc\" to \$ld_switch_site"; fi ;;
@@ -5087,7 +5071,7 @@
 
 
 echo "checking "for specified window system"" 1>&6
-echo "configure:5091: checking "for specified window system"" >&5
+echo "configure:5075: checking "for specified window system"" >&5
 
 
 GNOME_CONFIG=no
@@ -5095,7 +5079,7 @@
 
 if test "$with_gnome" != "no"; then
    echo $ac_n "checking for GNOME configuration script""... $ac_c" 1>&6
-echo "configure:5099: checking for GNOME configuration script" >&5
+echo "configure:5083: checking for GNOME configuration script" >&5
    for possible in gnome-config
    do
       possible_version=`${possible} --version 2> /dev/null`
@@ -5126,7 +5110,7 @@
 
 if test "$with_gtk" != "no";then
    echo $ac_n "checking for GTK configuration script""... $ac_c" 1>&6
-echo "configure:5130: checking for GTK configuration script" >&5
+echo "configure:5114: checking for GTK configuration script" >&5
    for possible in gtk12-config gtk14-config gtk-config
    do
       possible_version=`${possible} --version 2> /dev/null`
@@ -5148,18 +5132,18 @@
 
 if test "${GTK_CONFIG}" != "no"; then
       echo $ac_n "checking gtk version""... $ac_c" 1>&6
-echo "configure:5152: checking gtk version" >&5
+echo "configure:5136: checking gtk version" >&5
       GTK_VERSION=`${GTK_CONFIG} --version`
       echo "$ac_t""${GTK_VERSION}" 1>&6
 
       echo $ac_n "checking gtk libs""... $ac_c" 1>&6
-echo "configure:5157: checking gtk libs" >&5
+echo "configure:5141: checking gtk libs" >&5
       GTK_LIBS=`${GTK_CONFIG} --libs`
       libs_gtk="$libs_gtk ${GTK_LIBS}" &&  if test "$extra_verbose" = "yes"; then echo "    Appending \"${GTK_LIBS}\" to \$libs_gtk"; fi
       echo "$ac_t""${GTK_LIBS}" 1>&6
 
       echo $ac_n "checking gtk cflags""... $ac_c" 1>&6
-echo "configure:5163: checking gtk cflags" >&5
+echo "configure:5147: checking gtk cflags" >&5
       GTK_CFLAGS=`${GTK_CONFIG} --cflags`
       if test "$GCC" = "yes"; then
       	GTK_CFLAGS="${GTK_CFLAGS} -Wno-shadow"
@@ -5169,19 +5153,19 @@
 
       
 echo $ac_n "checking for main in -lgdk_imlib""... $ac_c" 1>&6
-echo "configure:5173: checking for main in -lgdk_imlib" >&5
+echo "configure:5157: checking for main in -lgdk_imlib" >&5
 ac_lib_var=`echo gdk_imlib'_'main | sed 'y%./+-%__p_%'`
 
 xe_check_libs=" -lgdk_imlib "
 cat > conftest.$ac_ext <<EOF
-#line 5178 "configure"
+#line 5162 "configure"
 #include "confdefs.h"
 
 int main() {
 main()
 ; return 0; }
 EOF
-if { (eval echo configure:5185: \"$ac_link\") 1>&5; (eval $ac_link) 2>&5; } && test -s conftest${ac_exeext}; then
+if { (eval echo configure:5169: \"$ac_link\") 1>&5; (eval $ac_link) 2>&5; } && test -s conftest${ac_exeext}; then
   rm -rf conftest*
   eval "ac_cv_lib_$ac_lib_var=yes"
 else
@@ -5203,12 +5187,12 @@
 
       
 echo $ac_n "checking for Imlib_init in -lImlib""... $ac_c" 1>&6
-echo "configure:5207: checking for Imlib_init in -lImlib" >&5
+echo "configure:5191: checking for Imlib_init in -lImlib" >&5
 ac_lib_var=`echo Imlib'_'Imlib_init | sed 'y%./+-%__p_%'`
 
 xe_check_libs=" -lImlib "
 cat > conftest.$ac_ext <<EOF
-#line 5212 "configure"
+#line 5196 "configure"
 #include "confdefs.h"
 /* Override any gcc2 internal prototype to avoid an error.  */
 /* We use char because int might match the return type of a gcc2
@@ -5219,7 +5203,7 @@
 Imlib_init()
 ; return 0; }
 EOF
-if { (eval echo configure:5223: \"$ac_link\") 1>&5; (eval $ac_link) 2>&5; } && test -s conftest${ac_exeext}; then
+if { (eval echo configure:5207: \"$ac_link\") 1>&5; (eval $ac_link) 2>&5; } && test -s conftest${ac_exeext}; then
   rm -rf conftest*
   eval "ac_cv_lib_$ac_lib_var=yes"
 else
@@ -5242,10 +5226,10 @@
       for ac_func in gdk_imlib_init
 do
 echo $ac_n "checking for $ac_func""... $ac_c" 1>&6
-echo "configure:5246: checking for $ac_func" >&5
-
-cat > conftest.$ac_ext <<EOF
-#line 5249 "configure"
+echo "configure:5230: checking for $ac_func" >&5
+
+cat > conftest.$ac_ext <<EOF
+#line 5233 "configure"
 #include "confdefs.h"
 /* System header to define __stub macros and hopefully few prototypes,
     which can conflict with char $ac_func(); below.  */
@@ -5268,7 +5252,7 @@
 
 ; return 0; }
 EOF
-if { (eval echo configure:5272: \"$ac_link\") 1>&5; (eval $ac_link) 2>&5; } && test -s conftest${ac_exeext}; then
+if { (eval echo configure:5256: \"$ac_link\") 1>&5; (eval $ac_link) 2>&5; } && test -s conftest${ac_exeext}; then
   rm -rf conftest*
   eval "ac_cv_func_$ac_func=yes"
 else
@@ -5324,19 +5308,6 @@
       test "${with_dialogs}" != "no" && with_dialogs=gtk
       test "${with_widgets}" != "no" && with_widgets=gtk
 
-      extra_objs="$extra_objs console-gtk.o device-gtk.o event-gtk.o frame-gtk.o" &&  if test "$extra_verbose" = "yes"; then
-   echo "    xemacs will be linked with \"console-gtk.o device-gtk.o event-gtk.o frame-gtk.o\""
- fi
-      extra_objs="$extra_objs objects-gtk.o redisplay-gtk.o glyphs-gtk.o" &&  if test "$extra_verbose" = "yes"; then
-   echo "    xemacs will be linked with \"objects-gtk.o redisplay-gtk.o glyphs-gtk.o\""
- fi
-      extra_objs="$extra_objs select-gtk.o gccache-gtk.o" &&  if test "$extra_verbose" = "yes"; then
-   echo "    xemacs will be linked with \"select-gtk.o gccache-gtk.o\""
- fi
-      extra_objs="$extra_objs gtk-xemacs.o ui-gtk.o" &&  if test "$extra_verbose" = "yes"; then
-   echo "    xemacs will be linked with \"gtk-xemacs.o ui-gtk.o\""
- fi
-
             OLD_CFLAGS="${CFLAGS}"
       OLD_CPPFLAGS="${CPPFLAGS}"
       OLD_LDFLAGS="${LDFLAGS}"
@@ -5347,15 +5318,15 @@
 do
 ac_safe=`echo "$ac_hdr" | sed 'y%./+-%__p_%'`
 echo $ac_n "checking for $ac_hdr""... $ac_c" 1>&6
-echo "configure:5351: checking for $ac_hdr" >&5
-
-cat > conftest.$ac_ext <<EOF
-#line 5354 "configure"
+echo "configure:5322: checking for $ac_hdr" >&5
+
+cat > conftest.$ac_ext <<EOF
+#line 5325 "configure"
 #include "confdefs.h"
 #include <$ac_hdr>
 EOF
 ac_try="$ac_cpp conftest.$ac_ext >/dev/null 2>conftest.out"
-{ (eval echo configure:5359: \"$ac_try\") 1>&5; (eval $ac_try) 2>&5; }
+{ (eval echo configure:5330: \"$ac_try\") 1>&5; (eval $ac_try) 2>&5; }
 ac_err=`grep -v '^ *+' conftest.out | grep -v "^conftest.${ac_ext}\$"`
 if test -z "$ac_err"; then
   rm -rf conftest*
@@ -5386,19 +5357,19 @@
 
       
 echo $ac_n "checking for main in -lxml""... $ac_c" 1>&6
-echo "configure:5390: checking for main in -lxml" >&5
+echo "configure:5361: checking for main in -lxml" >&5
 ac_lib_var=`echo xml'_'main | sed 'y%./+-%__p_%'`
 
 xe_check_libs=" -lxml "
 cat > conftest.$ac_ext <<EOF
-#line 5395 "configure"
+#line 5366 "configure"
 #include "confdefs.h"
 
 int main() {
 main()
 ; return 0; }
 EOF
-if { (eval echo configure:5402: \"$ac_link\") 1>&5; (eval $ac_link) 2>&5; } && test -s conftest${ac_exeext}; then
+if { (eval echo configure:5373: \"$ac_link\") 1>&5; (eval $ac_link) 2>&5; } && test -s conftest${ac_exeext}; then
   rm -rf conftest*
   eval "ac_cv_lib_$ac_lib_var=yes"
 else
@@ -5420,19 +5391,19 @@
 
       
 echo $ac_n "checking for main in -lglade""... $ac_c" 1>&6
-echo "configure:5424: checking for main in -lglade" >&5
+echo "configure:5395: checking for main in -lglade" >&5
 ac_lib_var=`echo glade'_'main | sed 'y%./+-%__p_%'`
 
 xe_check_libs=" -lglade "
 cat > conftest.$ac_ext <<EOF
-#line 5429 "configure"
+#line 5400 "configure"
 #include "confdefs.h"
 
 int main() {
 main()
 ; return 0; }
 EOF
-if { (eval echo configure:5436: \"$ac_link\") 1>&5; (eval $ac_link) 2>&5; } && test -s conftest${ac_exeext}; then
+if { (eval echo configure:5407: \"$ac_link\") 1>&5; (eval $ac_link) 2>&5; } && test -s conftest${ac_exeext}; then
   rm -rf conftest*
   eval "ac_cv_lib_$ac_lib_var=yes"
 else
@@ -5454,19 +5425,19 @@
 
       
 echo $ac_n "checking for main in -lglade-gnome""... $ac_c" 1>&6
-echo "configure:5458: checking for main in -lglade-gnome" >&5
+echo "configure:5429: checking for main in -lglade-gnome" >&5
 ac_lib_var=`echo glade-gnome'_'main | sed 'y%./+-%__p_%'`
 
 xe_check_libs=" -lglade-gnome "
 cat > conftest.$ac_ext <<EOF
-#line 5463 "configure"
+#line 5434 "configure"
 #include "confdefs.h"
 
 int main() {
 main()
 ; return 0; }
 EOF
-if { (eval echo configure:5470: \"$ac_link\") 1>&5; (eval $ac_link) 2>&5; } && test -s conftest${ac_exeext}; then
+if { (eval echo configure:5441: \"$ac_link\") 1>&5; (eval $ac_link) 2>&5; } && test -s conftest${ac_exeext}; then
   rm -rf conftest*
   eval "ac_cv_lib_$ac_lib_var=yes"
 else
@@ -5487,7 +5458,7 @@
 
 
       cat > conftest.$ac_ext <<EOF
-#line 5491 "configure"
+#line 5462 "configure"
 #include "confdefs.h"
 #include <glade/glade-xml.h>
 EOF
@@ -5546,7 +5517,7 @@
 # Uses ac_ vars as temps to allow command line to override cache and checks.
 # --without-x overrides everything else, but does not touch the cache.
 echo $ac_n "checking for X""... $ac_c" 1>&6
-echo "configure:5550: checking for X" >&5
+echo "configure:5521: checking for X" >&5
 
 # Check whether --with-x or --without-x was given.
 if test "${with_x+set}" = set; then
@@ -5606,12 +5577,12 @@
 
   # First, try using that file with no special directory specified.
 cat > conftest.$ac_ext <<EOF
-#line 5610 "configure"
+#line 5581 "configure"
 #include "confdefs.h"
 #include <$x_direct_test_include>
 EOF
 ac_try="$ac_cpp conftest.$ac_ext >/dev/null 2>conftest.out"
-{ (eval echo configure:5615: \"$ac_try\") 1>&5; (eval $ac_try) 2>&5; }
+{ (eval echo configure:5586: \"$ac_try\") 1>&5; (eval $ac_try) 2>&5; }
 ac_err=`grep -v '^ *+' conftest.out | grep -v "^conftest.${ac_ext}\$"`
 if test -z "$ac_err"; then
   rm -rf conftest*
@@ -5680,14 +5651,14 @@
   ac_save_LIBS="$LIBS"
   LIBS="-l$x_direct_test_library $LIBS"
 cat > conftest.$ac_ext <<EOF
-#line 5684 "configure"
+#line 5655 "configure"
 #include "confdefs.h"
 
 int main() {
 ${x_direct_test_function}()
 ; return 0; }
 EOF
-if { (eval echo configure:5691: \"$ac_link\") 1>&5; (eval $ac_link) 2>&5; } && test -s conftest${ac_exeext}; then
+if { (eval echo configure:5662: \"$ac_link\") 1>&5; (eval $ac_link) 2>&5; } && test -s conftest${ac_exeext}; then
   rm -rf conftest*
   LIBS="$ac_save_LIBS"
 # We can link X programs with no special library path.
@@ -5796,17 +5767,17 @@
     case "`(uname -sr) 2>/dev/null`" in
     "SunOS 5"*)
       echo $ac_n "checking whether -R must be followed by a space""... $ac_c" 1>&6
-echo "configure:5800: checking whether -R must be followed by a space" >&5
+echo "configure:5771: checking whether -R must be followed by a space" >&5
       ac_xsave_LIBS="$LIBS"; LIBS="$LIBS -R$x_libraries"
       cat > conftest.$ac_ext <<EOF
-#line 5803 "configure"
-#include "confdefs.h"
-
-int main() {
-
-; return 0; }
-EOF
-if { (eval echo configure:5810: \"$ac_link\") 1>&5; (eval $ac_link) 2>&5; } && test -s conftest${ac_exeext}; then
+#line 5774 "configure"
+#include "confdefs.h"
+
+int main() {
+
+; return 0; }
+EOF
+if { (eval echo configure:5781: \"$ac_link\") 1>&5; (eval $ac_link) 2>&5; } && test -s conftest${ac_exeext}; then
   rm -rf conftest*
   ac_R_nospace=yes
 else
@@ -5822,14 +5793,14 @@
       else
 	LIBS="$ac_xsave_LIBS -R $x_libraries"
 	cat > conftest.$ac_ext <<EOF
-#line 5826 "configure"
-#include "confdefs.h"
-
-int main() {
-
-; return 0; }
-EOF
-if { (eval echo configure:5833: \"$ac_link\") 1>&5; (eval $ac_link) 2>&5; } && test -s conftest${ac_exeext}; then
+#line 5797 "configure"
+#include "confdefs.h"
+
+int main() {
+
+; return 0; }
+EOF
+if { (eval echo configure:5804: \"$ac_link\") 1>&5; (eval $ac_link) 2>&5; } && test -s conftest${ac_exeext}; then
   rm -rf conftest*
   ac_R_space=yes
 else
@@ -5865,12 +5836,12 @@
 else
 
 echo $ac_n "checking for dnet_ntoa in -ldnet""... $ac_c" 1>&6
-echo "configure:5869: checking for dnet_ntoa in -ldnet" >&5
+echo "configure:5840: checking for dnet_ntoa in -ldnet" >&5
 ac_lib_var=`echo dnet'_'dnet_ntoa | sed 'y%./+-%__p_%'`
 
 xe_check_libs=" -ldnet "
 cat > conftest.$ac_ext <<EOF
-#line 5874 "configure"
+#line 5845 "configure"
 #include "confdefs.h"
 /* Override any gcc2 internal prototype to avoid an error.  */
 /* We use char because int might match the return type of a gcc2
@@ -5881,7 +5852,7 @@
 dnet_ntoa()
 ; return 0; }
 EOF
-if { (eval echo configure:5885: \"$ac_link\") 1>&5; (eval $ac_link) 2>&5; } && test -s conftest${ac_exeext}; then
+if { (eval echo configure:5856: \"$ac_link\") 1>&5; (eval $ac_link) 2>&5; } && test -s conftest${ac_exeext}; then
   rm -rf conftest*
   eval "ac_cv_lib_$ac_lib_var=yes"
 else
@@ -5905,12 +5876,12 @@
     if test $ac_cv_lib_dnet_dnet_ntoa = no; then
       
 echo $ac_n "checking for dnet_ntoa in -ldnet_stub""... $ac_c" 1>&6
-echo "configure:5909: checking for dnet_ntoa in -ldnet_stub" >&5
+echo "configure:5880: checking for dnet_ntoa in -ldnet_stub" >&5
 ac_lib_var=`echo dnet_stub'_'dnet_ntoa | sed 'y%./+-%__p_%'`
 
 xe_check_libs=" -ldnet_stub "
 cat > conftest.$ac_ext <<EOF
-#line 5914 "configure"
+#line 5885 "configure"
 #include "confdefs.h"
 /* Override any gcc2 internal prototype to avoid an error.  */
 /* We use char because int might match the return type of a gcc2
@@ -5921,7 +5892,7 @@
 dnet_ntoa()
 ; return 0; }
 EOF
-if { (eval echo configure:5925: \"$ac_link\") 1>&5; (eval $ac_link) 2>&5; } && test -s conftest${ac_exeext}; then
+if { (eval echo configure:5896: \"$ac_link\") 1>&5; (eval $ac_link) 2>&5; } && test -s conftest${ac_exeext}; then
   rm -rf conftest*
   eval "ac_cv_lib_$ac_lib_var=yes"
 else
@@ -5950,10 +5921,10 @@
     # The nsl library prevents programs from opening the X display
     # on Irix 5.2, according to dickey@clark.net.
     echo $ac_n "checking for gethostbyname""... $ac_c" 1>&6
-echo "configure:5954: checking for gethostbyname" >&5
-
-cat > conftest.$ac_ext <<EOF
-#line 5957 "configure"
+echo "configure:5925: checking for gethostbyname" >&5
+
+cat > conftest.$ac_ext <<EOF
+#line 5928 "configure"
 #include "confdefs.h"
 /* System header to define __stub macros and hopefully few prototypes,
     which can conflict with char gethostbyname(); below.  */
@@ -5976,7 +5947,7 @@
 
 ; return 0; }
 EOF
-if { (eval echo configure:5980: \"$ac_link\") 1>&5; (eval $ac_link) 2>&5; } && test -s conftest${ac_exeext}; then
+if { (eval echo configure:5951: \"$ac_link\") 1>&5; (eval $ac_link) 2>&5; } && test -s conftest${ac_exeext}; then
   rm -rf conftest*
   eval "ac_cv_func_gethostbyname=yes"
 else
@@ -5997,12 +5968,12 @@
     if test $ac_cv_func_gethostbyname = no; then
       
 echo $ac_n "checking for gethostbyname in -lnsl""... $ac_c" 1>&6
-echo "configure:6001: checking for gethostbyname in -lnsl" >&5
+echo "configure:5972: checking for gethostbyname in -lnsl" >&5
 ac_lib_var=`echo nsl'_'gethostbyname | sed 'y%./+-%__p_%'`
 
 xe_check_libs=" -lnsl "
 cat > conftest.$ac_ext <<EOF
-#line 6006 "configure"
+#line 5977 "configure"
 #include "confdefs.h"
 /* Override any gcc2 internal prototype to avoid an error.  */
 /* We use char because int might match the return type of a gcc2
@@ -6013,7 +5984,7 @@
 gethostbyname()
 ; return 0; }
 EOF
-if { (eval echo configure:6017: \"$ac_link\") 1>&5; (eval $ac_link) 2>&5; } && test -s conftest${ac_exeext}; then
+if { (eval echo configure:5988: \"$ac_link\") 1>&5; (eval $ac_link) 2>&5; } && test -s conftest${ac_exeext}; then
   rm -rf conftest*
   eval "ac_cv_lib_$ac_lib_var=yes"
 else
@@ -6043,10 +6014,10 @@
     # -lsocket must be given before -lnsl if both are needed.
     # We assume that if connect needs -lnsl, so does gethostbyname.
     echo $ac_n "checking for connect""... $ac_c" 1>&6
-echo "configure:6047: checking for connect" >&5
-
-cat > conftest.$ac_ext <<EOF
-#line 6050 "configure"
+echo "configure:6018: checking for connect" >&5
+
+cat > conftest.$ac_ext <<EOF
+#line 6021 "configure"
 #include "confdefs.h"
 /* System header to define __stub macros and hopefully few prototypes,
     which can conflict with char connect(); below.  */
@@ -6069,7 +6040,7 @@
 
 ; return 0; }
 EOF
-if { (eval echo configure:6073: \"$ac_link\") 1>&5; (eval $ac_link) 2>&5; } && test -s conftest${ac_exeext}; then
+if { (eval echo configure:6044: \"$ac_link\") 1>&5; (eval $ac_link) 2>&5; } && test -s conftest${ac_exeext}; then
   rm -rf conftest*
   eval "ac_cv_func_connect=yes"
 else
@@ -6092,12 +6063,12 @@
 xe_msg_checking="for connect in -lsocket"
 test -n "$X_EXTRA_LIBS" && xe_msg_checking="$xe_msg_checking using extra libs $X_EXTRA_LIBS"
 echo $ac_n "checking "$xe_msg_checking"""... $ac_c" 1>&6
-echo "configure:6096: checking "$xe_msg_checking"" >&5
+echo "configure:6067: checking "$xe_msg_checking"" >&5
 ac_lib_var=`echo socket'_'connect | sed 'y%./+-%__p_%'`
 
 xe_check_libs=" -lsocket $X_EXTRA_LIBS"
 cat > conftest.$ac_ext <<EOF
-#line 6101 "configure"
+#line 6072 "configure"
 #include "confdefs.h"
 /* Override any gcc2 internal prototype to avoid an error.  */
 /* We use char because int might match the return type of a gcc2
@@ -6108,7 +6079,7 @@
 connect()
 ; return 0; }
 EOF
-if { (eval echo configure:6112: \"$ac_link\") 1>&5; (eval $ac_link) 2>&5; } && test -s conftest${ac_exeext}; then
+if { (eval echo configure:6083: \"$ac_link\") 1>&5; (eval $ac_link) 2>&5; } && test -s conftest${ac_exeext}; then
   rm -rf conftest*
   eval "ac_cv_lib_$ac_lib_var=yes"
 else
@@ -6132,10 +6103,10 @@
 
     # gomez@mi.uni-erlangen.de says -lposix is necessary on A/UX.
     echo $ac_n "checking for remove""... $ac_c" 1>&6
-echo "configure:6136: checking for remove" >&5
-
-cat > conftest.$ac_ext <<EOF
-#line 6139 "configure"
+echo "configure:6107: checking for remove" >&5
+
+cat > conftest.$ac_ext <<EOF
+#line 6110 "configure"
 #include "confdefs.h"
 /* System header to define __stub macros and hopefully few prototypes,
     which can conflict with char remove(); below.  */
@@ -6158,7 +6129,7 @@
 
 ; return 0; }
 EOF
-if { (eval echo configure:6162: \"$ac_link\") 1>&5; (eval $ac_link) 2>&5; } && test -s conftest${ac_exeext}; then
+if { (eval echo configure:6133: \"$ac_link\") 1>&5; (eval $ac_link) 2>&5; } && test -s conftest${ac_exeext}; then
   rm -rf conftest*
   eval "ac_cv_func_remove=yes"
 else
@@ -6179,12 +6150,12 @@
     if test $ac_cv_func_remove = no; then
       
 echo $ac_n "checking for remove in -lposix""... $ac_c" 1>&6
-echo "configure:6183: checking for remove in -lposix" >&5
+echo "configure:6154: checking for remove in -lposix" >&5
 ac_lib_var=`echo posix'_'remove | sed 'y%./+-%__p_%'`
 
 xe_check_libs=" -lposix "
 cat > conftest.$ac_ext <<EOF
-#line 6188 "configure"
+#line 6159 "configure"
 #include "confdefs.h"
 /* Override any gcc2 internal prototype to avoid an error.  */
 /* We use char because int might match the return type of a gcc2
@@ -6195,7 +6166,7 @@
 remove()
 ; return 0; }
 EOF
-if { (eval echo configure:6199: \"$ac_link\") 1>&5; (eval $ac_link) 2>&5; } && test -s conftest${ac_exeext}; then
+if { (eval echo configure:6170: \"$ac_link\") 1>&5; (eval $ac_link) 2>&5; } && test -s conftest${ac_exeext}; then
   rm -rf conftest*
   eval "ac_cv_lib_$ac_lib_var=yes"
 else
@@ -6219,10 +6190,10 @@
 
     # BSDI BSD/OS 2.1 needs -lipc for XOpenDisplay.
     echo $ac_n "checking for shmat""... $ac_c" 1>&6
-echo "configure:6223: checking for shmat" >&5
-
-cat > conftest.$ac_ext <<EOF
-#line 6226 "configure"
+echo "configure:6194: checking for shmat" >&5
+
+cat > conftest.$ac_ext <<EOF
+#line 6197 "configure"
 #include "confdefs.h"
 /* System header to define __stub macros and hopefully few prototypes,
     which can conflict with char shmat(); below.  */
@@ -6245,7 +6216,7 @@
 
 ; return 0; }
 EOF
-if { (eval echo configure:6249: \"$ac_link\") 1>&5; (eval $ac_link) 2>&5; } && test -s conftest${ac_exeext}; then
+if { (eval echo configure:6220: \"$ac_link\") 1>&5; (eval $ac_link) 2>&5; } && test -s conftest${ac_exeext}; then
   rm -rf conftest*
   eval "ac_cv_func_shmat=yes"
 else
@@ -6266,12 +6237,12 @@
     if test $ac_cv_func_shmat = no; then
       
 echo $ac_n "checking for shmat in -lipc""... $ac_c" 1>&6
-echo "configure:6270: checking for shmat in -lipc" >&5
+echo "configure:6241: checking for shmat in -lipc" >&5
 ac_lib_var=`echo ipc'_'shmat | sed 'y%./+-%__p_%'`
 
 xe_check_libs=" -lipc "
 cat > conftest.$ac_ext <<EOF
-#line 6275 "configure"
+#line 6246 "configure"
 #include "confdefs.h"
 /* Override any gcc2 internal prototype to avoid an error.  */
 /* We use char because int might match the return type of a gcc2
@@ -6282,7 +6253,7 @@
 shmat()
 ; return 0; }
 EOF
-if { (eval echo configure:6286: \"$ac_link\") 1>&5; (eval $ac_link) 2>&5; } && test -s conftest${ac_exeext}; then
+if { (eval echo configure:6257: \"$ac_link\") 1>&5; (eval $ac_link) 2>&5; } && test -s conftest${ac_exeext}; then
   rm -rf conftest*
   eval "ac_cv_lib_$ac_lib_var=yes"
 else
@@ -6318,12 +6289,12 @@
 xe_msg_checking="for IceConnectionNumber in -lICE"
 test -n "$X_EXTRA_LIBS" && xe_msg_checking="$xe_msg_checking using extra libs $X_EXTRA_LIBS"
 echo $ac_n "checking "$xe_msg_checking"""... $ac_c" 1>&6
-echo "configure:6322: checking "$xe_msg_checking"" >&5
+echo "configure:6293: checking "$xe_msg_checking"" >&5
 ac_lib_var=`echo ICE'_'IceConnectionNumber | sed 'y%./+-%__p_%'`
 
 xe_check_libs=" -lICE $X_EXTRA_LIBS"
 cat > conftest.$ac_ext <<EOF
-#line 6327 "configure"
+#line 6298 "configure"
 #include "confdefs.h"
 /* Override any gcc2 internal prototype to avoid an error.  */
 /* We use char because int might match the return type of a gcc2
@@ -6334,7 +6305,7 @@
 IceConnectionNumber()
 ; return 0; }
 EOF
-if { (eval echo configure:6338: \"$ac_link\") 1>&5; (eval $ac_link) 2>&5; } && test -s conftest${ac_exeext}; then
+if { (eval echo configure:6309: \"$ac_link\") 1>&5; (eval $ac_link) 2>&5; } && test -s conftest${ac_exeext}; then
   rm -rf conftest*
   eval "ac_cv_lib_$ac_lib_var=yes"
 else
@@ -6501,7 +6472,7 @@
 
 
     echo "checking for X defines extracted by xmkmf" 1>&6
-echo "configure:6505: checking for X defines extracted by xmkmf" >&5
+echo "configure:6476: checking for X defines extracted by xmkmf" >&5
   rm -fr conftestdir
   if mkdir conftestdir; then
     cd conftestdir
@@ -6550,15 +6521,15 @@
 
     ac_safe=`echo "X11/Intrinsic.h" | sed 'y%./+-%__p_%'`
 echo $ac_n "checking for X11/Intrinsic.h""... $ac_c" 1>&6
-echo "configure:6554: checking for X11/Intrinsic.h" >&5
-
-cat > conftest.$ac_ext <<EOF
-#line 6557 "configure"
+echo "configure:6525: checking for X11/Intrinsic.h" >&5
+
+cat > conftest.$ac_ext <<EOF
+#line 6528 "configure"
 #include "confdefs.h"
 #include <X11/Intrinsic.h>
 EOF
 ac_try="$ac_cpp conftest.$ac_ext >/dev/null 2>conftest.out"
-{ (eval echo configure:6562: \"$ac_try\") 1>&5; (eval $ac_try) 2>&5; }
+{ (eval echo configure:6533: \"$ac_try\") 1>&5; (eval $ac_try) 2>&5; }
 ac_err=`grep -v '^ *+' conftest.out | grep -v "^conftest.${ac_ext}\$"`
 if test -z "$ac_err"; then
   rm -rf conftest*
@@ -6582,12 +6553,12 @@
 
       
 echo $ac_n "checking for XOpenDisplay in -lX11""... $ac_c" 1>&6
-echo "configure:6586: checking for XOpenDisplay in -lX11" >&5
+echo "configure:6557: checking for XOpenDisplay in -lX11" >&5
 ac_lib_var=`echo X11'_'XOpenDisplay | sed 'y%./+-%__p_%'`
 
 xe_check_libs=" -lX11 "
 cat > conftest.$ac_ext <<EOF
-#line 6591 "configure"
+#line 6562 "configure"
 #include "confdefs.h"
 /* Override any gcc2 internal prototype to avoid an error.  */
 /* We use char because int might match the return type of a gcc2
@@ -6598,7 +6569,7 @@
 XOpenDisplay()
 ; return 0; }
 EOF
-if { (eval echo configure:6602: \"$ac_link\") 1>&5; (eval $ac_link) 2>&5; } && test -s conftest${ac_exeext}; then
+if { (eval echo configure:6573: \"$ac_link\") 1>&5; (eval $ac_link) 2>&5; } && test -s conftest${ac_exeext}; then
   rm -rf conftest*
   eval "ac_cv_lib_$ac_lib_var=yes"
 else
@@ -6623,12 +6594,12 @@
 xe_msg_checking="for XGetFontProperty in -lX11"
 test -n "-b i486-linuxaout" && xe_msg_checking="$xe_msg_checking using extra libs -b i486-linuxaout"
 echo $ac_n "checking "$xe_msg_checking"""... $ac_c" 1>&6
-echo "configure:6627: checking "$xe_msg_checking"" >&5
+echo "configure:6598: checking "$xe_msg_checking"" >&5
 ac_lib_var=`echo X11'_'XGetFontProperty | sed 'y%./+-%__p_%'`
 
 xe_check_libs=" -lX11 -b i486-linuxaout"
 cat > conftest.$ac_ext <<EOF
-#line 6632 "configure"
+#line 6603 "configure"
 #include "confdefs.h"
 /* Override any gcc2 internal prototype to avoid an error.  */
 /* We use char because int might match the return type of a gcc2
@@ -6639,7 +6610,7 @@
 XGetFontProperty()
 ; return 0; }
 EOF
-if { (eval echo configure:6643: \"$ac_link\") 1>&5; (eval $ac_link) 2>&5; } && test -s conftest${ac_exeext}; then
+if { (eval echo configure:6614: \"$ac_link\") 1>&5; (eval $ac_link) 2>&5; } && test -s conftest${ac_exeext}; then
   rm -rf conftest*
   eval "ac_cv_lib_$ac_lib_var=yes"
 else
@@ -6666,12 +6637,12 @@
 
     
 echo $ac_n "checking for XShapeSelectInput in -lXext""... $ac_c" 1>&6
-echo "configure:6670: checking for XShapeSelectInput in -lXext" >&5
+echo "configure:6641: checking for XShapeSelectInput in -lXext" >&5
 ac_lib_var=`echo Xext'_'XShapeSelectInput | sed 'y%./+-%__p_%'`
 
 xe_check_libs=" -lXext "
 cat > conftest.$ac_ext <<EOF
-#line 6675 "configure"
+#line 6646 "configure"
 #include "confdefs.h"
 /* Override any gcc2 internal prototype to avoid an error.  */
 /* We use char because int might match the return type of a gcc2
@@ -6682,7 +6653,7 @@
 XShapeSelectInput()
 ; return 0; }
 EOF
-if { (eval echo configure:6686: \"$ac_link\") 1>&5; (eval $ac_link) 2>&5; } && test -s conftest${ac_exeext}; then
+if { (eval echo configure:6657: \"$ac_link\") 1>&5; (eval $ac_link) 2>&5; } && test -s conftest${ac_exeext}; then
   rm -rf conftest*
   eval "ac_cv_lib_$ac_lib_var=yes"
 else
@@ -6705,12 +6676,12 @@
 
     
 echo $ac_n "checking for XtOpenDisplay in -lXt""... $ac_c" 1>&6
-echo "configure:6709: checking for XtOpenDisplay in -lXt" >&5
+echo "configure:6680: checking for XtOpenDisplay in -lXt" >&5
 ac_lib_var=`echo Xt'_'XtOpenDisplay | sed 'y%./+-%__p_%'`
 
 xe_check_libs=" -lXt "
 cat > conftest.$ac_ext <<EOF
-#line 6714 "configure"
+#line 6685 "configure"
 #include "confdefs.h"
 /* Override any gcc2 internal prototype to avoid an error.  */
 /* We use char because int might match the return type of a gcc2
@@ -6721,7 +6692,7 @@
 XtOpenDisplay()
 ; return 0; }
 EOF
-if { (eval echo configure:6725: \"$ac_link\") 1>&5; (eval $ac_link) 2>&5; } && test -s conftest${ac_exeext}; then
+if { (eval echo configure:6696: \"$ac_link\") 1>&5; (eval $ac_link) 2>&5; } && test -s conftest${ac_exeext}; then
   rm -rf conftest*
   eval "ac_cv_lib_$ac_lib_var=yes"
 else
@@ -6744,14 +6715,14 @@
 
 
   echo $ac_n "checking the version of X11 being used""... $ac_c" 1>&6
-echo "configure:6748: checking the version of X11 being used" >&5
+echo "configure:6719: checking the version of X11 being used" >&5
   cat > conftest.$ac_ext <<EOF
-#line 6750 "configure"
+#line 6721 "configure"
 #include "confdefs.h"
 #include <X11/Intrinsic.h>
     int main(int c, char *v[]) { return c>1 ? XlibSpecificationRelease : 0; }
 EOF
-if { (eval echo configure:6755: \"$ac_link\") 1>&5; (eval $ac_link) 2>&5; } && test -s conftest && (./conftest; exit $?) 2>&5
+if { (eval echo configure:6726: \"$ac_link\") 1>&5; (eval $ac_link) 2>&5; } && test -s conftest && (./conftest; exit $?) 2>&5
 then
   ./conftest foobar; x11_release=$?
 else
@@ -6782,10 +6753,10 @@
   for ac_func in XConvertCase
 do
 echo $ac_n "checking for $ac_func""... $ac_c" 1>&6
-echo "configure:6786: checking for $ac_func" >&5
-
-cat > conftest.$ac_ext <<EOF
-#line 6789 "configure"
+echo "configure:6757: checking for $ac_func" >&5
+
+cat > conftest.$ac_ext <<EOF
+#line 6760 "configure"
 #include "confdefs.h"
 /* System header to define __stub macros and hopefully few prototypes,
     which can conflict with char $ac_func(); below.  */
@@ -6808,7 +6779,7 @@
 
 ; return 0; }
 EOF
-if { (eval echo configure:6812: \"$ac_link\") 1>&5; (eval $ac_link) 2>&5; } && test -s conftest${ac_exeext}; then
+if { (eval echo configure:6783: \"$ac_link\") 1>&5; (eval $ac_link) 2>&5; } && test -s conftest${ac_exeext}; then
   rm -rf conftest*
   eval "ac_cv_func_$ac_func=yes"
 else
@@ -6840,15 +6811,15 @@
 do
 ac_safe=`echo "$ac_hdr" | sed 'y%./+-%__p_%'`
 echo $ac_n "checking for $ac_hdr""... $ac_c" 1>&6
-echo "configure:6844: checking for $ac_hdr" >&5
-
-cat > conftest.$ac_ext <<EOF
-#line 6847 "configure"
+echo "configure:6815: checking for $ac_hdr" >&5
+
+cat > conftest.$ac_ext <<EOF
+#line 6818 "configure"
 #include "confdefs.h"
 #include <$ac_hdr>
 EOF
 ac_try="$ac_cpp conftest.$ac_ext >/dev/null 2>conftest.out"
-{ (eval echo configure:6852: \"$ac_try\") 1>&5; (eval $ac_try) 2>&5; }
+{ (eval echo configure:6823: \"$ac_try\") 1>&5; (eval $ac_try) 2>&5; }
 ac_err=`grep -v '^ *+' conftest.out | grep -v "^conftest.${ac_ext}\$"`
 if test -z "$ac_err"; then
   rm -rf conftest*
@@ -6881,10 +6852,10 @@
     for ac_func in XRegisterIMInstantiateCallback
 do
 echo $ac_n "checking for $ac_func""... $ac_c" 1>&6
-echo "configure:6885: checking for $ac_func" >&5
-
-cat > conftest.$ac_ext <<EOF
-#line 6888 "configure"
+echo "configure:6856: checking for $ac_func" >&5
+
+cat > conftest.$ac_ext <<EOF
+#line 6859 "configure"
 #include "confdefs.h"
 /* System header to define __stub macros and hopefully few prototypes,
     which can conflict with char $ac_func(); below.  */
@@ -6907,7 +6878,7 @@
 
 ; return 0; }
 EOF
-if { (eval echo configure:6911: \"$ac_link\") 1>&5; (eval $ac_link) 2>&5; } && test -s conftest${ac_exeext}; then
+if { (eval echo configure:6882: \"$ac_link\") 1>&5; (eval $ac_link) 2>&5; } && test -s conftest${ac_exeext}; then
   rm -rf conftest*
   eval "ac_cv_func_$ac_func=yes"
 else
@@ -6935,9 +6906,9 @@
 done
 
   echo $ac_n "checking for standard XRegisterIMInstantiateCallback prototype""... $ac_c" 1>&6
-echo "configure:6939: checking for standard XRegisterIMInstantiateCallback prototype" >&5
+echo "configure:6910: checking for standard XRegisterIMInstantiateCallback prototype" >&5
   cat > conftest.$ac_ext <<EOF
-#line 6941 "configure"
+#line 6912 "configure"
 #include "confdefs.h"
 
 #define NeedFunctionPrototypes 1
@@ -6949,7 +6920,7 @@
 
 ; return 0; }
 EOF
-if { (eval echo configure:6953: \"$ac_compile\") 1>&5; (eval $ac_compile) 2>&5; }; then
+if { (eval echo configure:6924: \"$ac_compile\") 1>&5; (eval $ac_compile) 2>&5; }; then
   rm -rf conftest*
   echo "$ac_t""yes" 1>&6
 else
@@ -6970,12 +6941,12 @@
 
     test -z "$with_xmu" && { 
 echo $ac_n "checking for XmuReadBitmapDataFromFile in -lXmu""... $ac_c" 1>&6
-echo "configure:6974: checking for XmuReadBitmapDataFromFile in -lXmu" >&5
+echo "configure:6945: checking for XmuReadBitmapDataFromFile in -lXmu" >&5
 ac_lib_var=`echo Xmu'_'XmuReadBitmapDataFromFile | sed 'y%./+-%__p_%'`
 
 xe_check_libs=" -lXmu "
 cat > conftest.$ac_ext <<EOF
-#line 6979 "configure"
+#line 6950 "configure"
 #include "confdefs.h"
 /* Override any gcc2 internal prototype to avoid an error.  */
 /* We use char because int might match the return type of a gcc2
@@ -6986,7 +6957,7 @@
 XmuReadBitmapDataFromFile()
 ; return 0; }
 EOF
-if { (eval echo configure:6990: \"$ac_link\") 1>&5; (eval $ac_link) 2>&5; } && test -s conftest${ac_exeext}; then
+if { (eval echo configure:6961: \"$ac_link\") 1>&5; (eval $ac_link) 2>&5; } && test -s conftest${ac_exeext}; then
   rm -rf conftest*
   eval "ac_cv_lib_$ac_lib_var=yes"
 else
@@ -7025,19 +6996,19 @@
 
       
 echo $ac_n "checking for main in -lXbsd""... $ac_c" 1>&6
-echo "configure:7029: checking for main in -lXbsd" >&5
+echo "configure:7000: checking for main in -lXbsd" >&5
 ac_lib_var=`echo Xbsd'_'main | sed 'y%./+-%__p_%'`
 
 xe_check_libs=" -lXbsd "
 cat > conftest.$ac_ext <<EOF
-#line 7034 "configure"
+#line 7005 "configure"
 #include "confdefs.h"
 
 int main() {
 main()
 ; return 0; }
 EOF
-if { (eval echo configure:7041: \"$ac_link\") 1>&5; (eval $ac_link) 2>&5; } && test -s conftest${ac_exeext}; then
+if { (eval echo configure:7012: \"$ac_link\") 1>&5; (eval $ac_link) 2>&5; } && test -s conftest${ac_exeext}; then
   rm -rf conftest*
   eval "ac_cv_lib_$ac_lib_var=yes"
 else
@@ -7074,22 +7045,22 @@
 fi 
 if test "$with_msw" != "no"; then
   echo "checking for MS-Windows" 1>&6
-echo "configure:7078: checking for MS-Windows" >&5
+echo "configure:7049: checking for MS-Windows" >&5
   
 echo $ac_n "checking for main in -lgdi32""... $ac_c" 1>&6
-echo "configure:7081: checking for main in -lgdi32" >&5
+echo "configure:7052: checking for main in -lgdi32" >&5
 ac_lib_var=`echo gdi32'_'main | sed 'y%./+-%__p_%'`
 
 xe_check_libs=" -lgdi32 "
 cat > conftest.$ac_ext <<EOF
-#line 7086 "configure"
+#line 7057 "configure"
 #include "confdefs.h"
 
 int main() {
 main()
 ; return 0; }
 EOF
-if { (eval echo configure:7093: \"$ac_link\") 1>&5; (eval $ac_link) 2>&5; } && test -s conftest${ac_exeext}; then
+if { (eval echo configure:7064: \"$ac_link\") 1>&5; (eval $ac_link) 2>&5; } && test -s conftest${ac_exeext}; then
   rm -rf conftest*
   eval "ac_cv_lib_$ac_lib_var=yes"
 else
@@ -7126,50 +7097,28 @@
     fi
 
     install_pp="$blddir/lib-src/installexe.sh"
-    libs_system="$libs_system -lshell32 -lgdi32 -luser32 -lcomdlg32 -lcomctl32 -lwinspool" &&  if test "$extra_verbose" = "yes"; then echo "    Appending \"-lshell32 -lgdi32 -luser32 -lcomdlg32 -lcomctl32 -lwinspool\" to \$libs_system"; fi
-    test "$with_dragndrop" != no && dragndrop_proto="$dragndrop_proto msw" &&  if test "$extra_verbose" = "yes"; then echo "    Appending \"msw\" to \$dragndrop_proto"; fi
+    libs_system="$libs_system -limm32 -lshell32 -lgdi32 -luser32 -lcomdlg32 -lcomctl32 -lole32 -luuid -lwinspool -lmpr" &&  if test "$extra_verbose" = "yes"; then echo "    Appending \"-limm32 -lshell32 -lgdi32 -luser32 -lcomdlg32 -lcomctl32 -lole32 -luuid -lwinspool -lmpr\" to \$libs_system"; fi
+    if test "$with_dragndrop" != no; then
+      dragndrop_proto="$dragndrop_proto msw" &&  if test "$extra_verbose" = "yes"; then echo "    Appending \"msw\" to \$dragndrop_proto"; fi
+      with_dragndrop=yes
+    fi
     if test "$window_system" != x11; then
- 	window_system=msw
-	test "$with_scrollbars" != "no" && with_scrollbars=msw \
-	    && extra_objs="$extra_objs scrollbar-msw.o" &&  if test "$extra_verbose" = "yes"; then
-   echo "    xemacs will be linked with \"scrollbar-msw.o\""
- fi
-	test "$with_menubars"   != "no" && with_menubars=msw \
-	    && extra_objs="$extra_objs menubar-msw.o" &&  if test "$extra_verbose" = "yes"; then
-   echo "    xemacs will be linked with \"menubar-msw.o\""
- fi
-	test "$with_toolbars"   != "no" && with_toolbars=msw \
-	    && extra_objs="$extra_objs toolbar-msw.o" &&  if test "$extra_verbose" = "yes"; then
-   echo "    xemacs will be linked with \"toolbar-msw.o\""
- fi
-	test "$with_dialogs"   != "no" && with_dialogs=msw \
-	    && extra_objs="$extra_objs dialog-msw.o" &&  if test "$extra_verbose" = "yes"; then
-   echo "    xemacs will be linked with \"dialog-msw.o\""
- fi
-	test "$with_widgets"   != "no" && with_widgets=msw
-    else
-	test "$with_scrollbars" != "no" && extra_objs="$extra_objs scrollbar-msw.o" &&  if test "$extra_verbose" = "yes"; then
-   echo "    xemacs will be linked with \"scrollbar-msw.o\""
- fi
-	test "$with_menubars"   != "no" && extra_objs="$extra_objs menubar-msw.o" &&  if test "$extra_verbose" = "yes"; then
-   echo "    xemacs will be linked with \"menubar-msw.o\""
- fi
-	test "$with_toolbars"   != "no" && extra_objs="$extra_objs toolbar-msw.o" &&  if test "$extra_verbose" = "yes"; then
-   echo "    xemacs will be linked with \"toolbar-msw.o\""
- fi
-	test "$with_dialogs"    != "no" && extra_objs="$extra_objs dialog-msw.o" &&  if test "$extra_verbose" = "yes"; then
-   echo "    xemacs will be linked with \"dialog-msw.o\""
- fi
+      window_system=msw
+      test "$with_scrollbars" != "no" && with_scrollbars=msw
+      test "$with_menubars"   != "no" && with_menubars=msw
+      test "$with_toolbars"   != "no" && with_toolbars=msw
+      test "$with_dialogs"    != "no" && with_dialogs=msw
+      test "$with_widgets"    != "no" && with_widgets=msw
     fi
         cat > conftest.$ac_ext <<EOF
-#line 7166 "configure"
+#line 7115 "configure"
 #include "confdefs.h"
 #include <fcntl.h>
     int main() { return (open("/dev/windows", O_RDONLY, 0) > 0)? 0 : 1; }
 EOF
-if { (eval echo configure:7171: \"$ac_link\") 1>&5; (eval $ac_link) 2>&5; } && test -s conftest && (./conftest; exit $?) 2>&5
+if { (eval echo configure:7120: \"$ac_link\") 1>&5; (eval $ac_link) 2>&5; } && test -s conftest && (./conftest; exit $?) 2>&5
 then
-  need_event_unixoid=yes; { test "$extra_verbose" = "yes" && cat << \EOF
+  { test "$extra_verbose" = "yes" && cat << \EOF
     Defining HAVE_MSG_SELECT
 EOF
 cat >> confdefs.h <<\EOF
@@ -7183,15 +7132,12 @@
   cat conftest.$ac_ext >&5
 fi
 rm -fr conftest*
-    with_file_coding=yes
-    extra_objs="$extra_objs console-msw.o device-msw.o event-msw.o frame-msw.o objects-msw.o select-msw.o redisplay-msw.o glyphs-msw.o gui-msw.o" &&  if test "$extra_verbose" = "yes"; then
-   echo "    xemacs will be linked with \"console-msw.o device-msw.o event-msw.o frame-msw.o objects-msw.o select-msw.o redisplay-msw.o glyphs-msw.o gui-msw.o\""
- fi
-  fi
-fi
-
-
-
+  fi
+fi
+
+
+
+test -z "$with_dragndrop" && with_dragndrop="$with_dragndrop_default"
 test -z "$window_system" && window_system="none"
 
 if test "$window_system" = "none"; then
@@ -7231,15 +7177,15 @@
 if test "$with_x11" = "yes"; then
   ac_safe=`echo "X11/extensions/shape.h" | sed 'y%./+-%__p_%'`
 echo $ac_n "checking for X11/extensions/shape.h""... $ac_c" 1>&6
-echo "configure:7235: checking for X11/extensions/shape.h" >&5
-
-cat > conftest.$ac_ext <<EOF
-#line 7238 "configure"
+echo "configure:7181: checking for X11/extensions/shape.h" >&5
+
+cat > conftest.$ac_ext <<EOF
+#line 7184 "configure"
 #include "confdefs.h"
 #include <X11/extensions/shape.h>
 EOF
 ac_try="$ac_cpp conftest.$ac_ext >/dev/null 2>conftest.out"
-{ (eval echo configure:7243: \"$ac_try\") 1>&5; (eval $ac_try) 2>&5; }
+{ (eval echo configure:7189: \"$ac_try\") 1>&5; (eval $ac_try) 2>&5; }
 ac_err=`grep -v '^ *+' conftest.out | grep -v "^conftest.${ac_ext}\$"`
 if test -z "$ac_err"; then
   rm -rf conftest*
@@ -7263,9 +7209,7 @@
 EOF
 }
 
-   extra_objs="$extra_objs balloon_help.o balloon-x.o" &&  if test "$extra_verbose" = "yes"; then
-   echo "    xemacs will be linked with \"balloon_help.o balloon-x.o\""
- fi
+   
 else
   echo "$ac_t""no" 1>&6
 fi
@@ -7291,7 +7235,7 @@
 esac
 
 echo "checking for WM_COMMAND option" 1>&6
-echo "configure:7295: checking for WM_COMMAND option" >&5;
+echo "configure:7239: checking for WM_COMMAND option" >&5;
 if test "$with_wmcommand" != "no"; then
   { test "$extra_verbose" = "yes" && cat << \EOF
     Defining HAVE_WMCOMMAND
@@ -7306,15 +7250,15 @@
 test -z "$with_xauth" && test "$window_system" = "none" && with_xauth=no
 test -z "$with_xauth" && { ac_safe=`echo "X11/Xauth.h" | sed 'y%./+-%__p_%'`
 echo $ac_n "checking for X11/Xauth.h""... $ac_c" 1>&6
-echo "configure:7310: checking for X11/Xauth.h" >&5
-
-cat > conftest.$ac_ext <<EOF
-#line 7313 "configure"
+echo "configure:7254: checking for X11/Xauth.h" >&5
+
+cat > conftest.$ac_ext <<EOF
+#line 7257 "configure"
 #include "confdefs.h"
 #include <X11/Xauth.h>
 EOF
 ac_try="$ac_cpp conftest.$ac_ext >/dev/null 2>conftest.out"
-{ (eval echo configure:7318: \"$ac_try\") 1>&5; (eval $ac_try) 2>&5; }
+{ (eval echo configure:7262: \"$ac_try\") 1>&5; (eval $ac_try) 2>&5; }
 ac_err=`grep -v '^ *+' conftest.out | grep -v "^conftest.${ac_ext}\$"`
 if test -z "$ac_err"; then
   rm -rf conftest*
@@ -7337,12 +7281,12 @@
  }
 test -z "$with_xauth" && { 
 echo $ac_n "checking for XauGetAuthByAddr in -lXau""... $ac_c" 1>&6
-echo "configure:7341: checking for XauGetAuthByAddr in -lXau" >&5
+echo "configure:7285: checking for XauGetAuthByAddr in -lXau" >&5
 ac_lib_var=`echo Xau'_'XauGetAuthByAddr | sed 'y%./+-%__p_%'`
 
 xe_check_libs=" -lXau "
 cat > conftest.$ac_ext <<EOF
-#line 7346 "configure"
+#line 7290 "configure"
 #include "confdefs.h"
 /* Override any gcc2 internal prototype to avoid an error.  */
 /* We use char because int might match the return type of a gcc2
@@ -7353,7 +7297,7 @@
 XauGetAuthByAddr()
 ; return 0; }
 EOF
-if { (eval echo configure:7357: \"$ac_link\") 1>&5; (eval $ac_link) 2>&5; } && test -s conftest${ac_exeext}; then
+if { (eval echo configure:7301: \"$ac_link\") 1>&5; (eval $ac_link) 2>&5; } && test -s conftest${ac_exeext}; then
   rm -rf conftest*
   eval "ac_cv_lib_$ac_lib_var=yes"
 else
@@ -7398,15 +7342,15 @@
       for dir in "" "Tt/" "desktop/" ; do
     ac_safe=`echo "${dir}tt_c.h" | sed 'y%./+-%__p_%'`
 echo $ac_n "checking for ${dir}tt_c.h""... $ac_c" 1>&6
-echo "configure:7402: checking for ${dir}tt_c.h" >&5
-
-cat > conftest.$ac_ext <<EOF
-#line 7405 "configure"
+echo "configure:7346: checking for ${dir}tt_c.h" >&5
+
+cat > conftest.$ac_ext <<EOF
+#line 7349 "configure"
 #include "confdefs.h"
 #include <${dir}tt_c.h>
 EOF
 ac_try="$ac_cpp conftest.$ac_ext >/dev/null 2>conftest.out"
-{ (eval echo configure:7410: \"$ac_try\") 1>&5; (eval $ac_try) 2>&5; }
+{ (eval echo configure:7354: \"$ac_try\") 1>&5; (eval $ac_try) 2>&5; }
 ac_err=`grep -v '^ *+' conftest.out | grep -v "^conftest.${ac_ext}\$"`
 if test -z "$ac_err"; then
   rm -rf conftest*
@@ -7442,12 +7386,12 @@
 xe_msg_checking="for tt_message_create in -ltt"
 test -n "$extra_libs" && xe_msg_checking="$xe_msg_checking using extra libs $extra_libs"
 echo $ac_n "checking "$xe_msg_checking"""... $ac_c" 1>&6
-echo "configure:7446: checking "$xe_msg_checking"" >&5
+echo "configure:7390: checking "$xe_msg_checking"" >&5
 ac_lib_var=`echo tt'_'tt_message_create | sed 'y%./+-%__p_%'`
 
 xe_check_libs=" -ltt $extra_libs"
 cat > conftest.$ac_ext <<EOF
-#line 7451 "configure"
+#line 7395 "configure"
 #include "confdefs.h"
 /* Override any gcc2 internal prototype to avoid an error.  */
 /* We use char because int might match the return type of a gcc2
@@ -7458,7 +7402,7 @@
 tt_message_create()
 ; return 0; }
 EOF
-if { (eval echo configure:7462: \"$ac_link\") 1>&5; (eval $ac_link) 2>&5; } && test -s conftest${ac_exeext}; then
+if { (eval echo configure:7406: \"$ac_link\") 1>&5; (eval $ac_link) 2>&5; } && test -s conftest${ac_exeext}; then
   rm -rf conftest*
   eval "ac_cv_lib_$ac_lib_var=yes"
 else
@@ -7508,22 +7452,19 @@
 }
 
   libs_x="$tt_libs $libs_x" &&  if test "$extra_verbose" = "yes"; then echo "    Prepending \"$tt_libs\" to \$libs_x"; fi
-  extra_objs="$extra_objs tooltalk.o" &&  if test "$extra_verbose" = "yes"; then
-   echo "    xemacs will be linked with \"tooltalk.o\""
- fi
 fi
 
 test -z "$with_cde" && { ac_safe=`echo "Dt/Dt.h" | sed 'y%./+-%__p_%'`
 echo $ac_n "checking for Dt/Dt.h""... $ac_c" 1>&6
-echo "configure:7519: checking for Dt/Dt.h" >&5
-
-cat > conftest.$ac_ext <<EOF
-#line 7522 "configure"
+echo "configure:7460: checking for Dt/Dt.h" >&5
+
+cat > conftest.$ac_ext <<EOF
+#line 7463 "configure"
 #include "confdefs.h"
 #include <Dt/Dt.h>
 EOF
 ac_try="$ac_cpp conftest.$ac_ext >/dev/null 2>conftest.out"
-{ (eval echo configure:7527: \"$ac_try\") 1>&5; (eval $ac_try) 2>&5; }
+{ (eval echo configure:7468: \"$ac_try\") 1>&5; (eval $ac_try) 2>&5; }
 ac_err=`grep -v '^ *+' conftest.out | grep -v "^conftest.${ac_ext}\$"`
 if test -z "$ac_err"; then
   rm -rf conftest*
@@ -7546,12 +7487,12 @@
  }
 test -z "$with_cde" && { 
 echo $ac_n "checking for DtDndDragStart in -lDtSvc""... $ac_c" 1>&6
-echo "configure:7550: checking for DtDndDragStart in -lDtSvc" >&5
+echo "configure:7491: checking for DtDndDragStart in -lDtSvc" >&5
 ac_lib_var=`echo DtSvc'_'DtDndDragStart | sed 'y%./+-%__p_%'`
 
 xe_check_libs=" -lDtSvc "
 cat > conftest.$ac_ext <<EOF
-#line 7555 "configure"
+#line 7496 "configure"
 #include "confdefs.h"
 /* Override any gcc2 internal prototype to avoid an error.  */
 /* We use char because int might match the return type of a gcc2
@@ -7562,7 +7503,7 @@
 DtDndDragStart()
 ; return 0; }
 EOF
-if { (eval echo configure:7566: \"$ac_link\") 1>&5; (eval $ac_link) 2>&5; } && test -s conftest${ac_exeext}; then
+if { (eval echo configure:7507: \"$ac_link\") 1>&5; (eval $ac_link) 2>&5; } && test -s conftest${ac_exeext}; then
   rm -rf conftest*
   eval "ac_cv_lib_$ac_lib_var=yes"
 else
@@ -7643,7 +7584,7 @@
 
 if test "$with_dragndrop" != "no" ; then
   echo $ac_n "checking if drag and drop API is needed""... $ac_c" 1>&6
-echo "configure:7647: checking if drag and drop API is needed" >&5
+echo "configure:7588: checking if drag and drop API is needed" >&5
   if test -n "$dragndrop_proto" ; then
     with_dragndrop=yes
     echo "$ac_t""yes (${dragndrop_proto} )" 1>&6
@@ -7663,18 +7604,18 @@
 fi
 
 echo "checking for LDAP" 1>&6
-echo "configure:7667: checking for LDAP" >&5
+echo "configure:7608: checking for LDAP" >&5
 test -z "$with_ldap" && { ac_safe=`echo "ldap.h" | sed 'y%./+-%__p_%'`
 echo $ac_n "checking for ldap.h""... $ac_c" 1>&6
-echo "configure:7670: checking for ldap.h" >&5
-
-cat > conftest.$ac_ext <<EOF
-#line 7673 "configure"
+echo "configure:7611: checking for ldap.h" >&5
+
+cat > conftest.$ac_ext <<EOF
+#line 7614 "configure"
 #include "confdefs.h"
 #include <ldap.h>
 EOF
 ac_try="$ac_cpp conftest.$ac_ext >/dev/null 2>conftest.out"
-{ (eval echo configure:7678: \"$ac_try\") 1>&5; (eval $ac_try) 2>&5; }
+{ (eval echo configure:7619: \"$ac_try\") 1>&5; (eval $ac_try) 2>&5; }
 ac_err=`grep -v '^ *+' conftest.out | grep -v "^conftest.${ac_ext}\$"`
 if test -z "$ac_err"; then
   rm -rf conftest*
@@ -7697,15 +7638,15 @@
  }
 test -z "$with_ldap" && { ac_safe=`echo "lber.h" | sed 'y%./+-%__p_%'`
 echo $ac_n "checking for lber.h""... $ac_c" 1>&6
-echo "configure:7701: checking for lber.h" >&5
-
-cat > conftest.$ac_ext <<EOF
-#line 7704 "configure"
+echo "configure:7642: checking for lber.h" >&5
+
+cat > conftest.$ac_ext <<EOF
+#line 7645 "configure"
 #include "confdefs.h"
 #include <lber.h>
 EOF
 ac_try="$ac_cpp conftest.$ac_ext >/dev/null 2>conftest.out"
-{ (eval echo configure:7709: \"$ac_try\") 1>&5; (eval $ac_try) 2>&5; }
+{ (eval echo configure:7650: \"$ac_try\") 1>&5; (eval $ac_try) 2>&5; }
 ac_err=`grep -v '^ *+' conftest.out | grep -v "^conftest.${ac_ext}\$"`
 if test -z "$ac_err"; then
   rm -rf conftest*
@@ -7729,12 +7670,12 @@
 if test "$with_ldap" != "no"; then
   
 echo $ac_n "checking for ldap_search in -lldap""... $ac_c" 1>&6
-echo "configure:7733: checking for ldap_search in -lldap" >&5
+echo "configure:7674: checking for ldap_search in -lldap" >&5
 ac_lib_var=`echo ldap'_'ldap_search | sed 'y%./+-%__p_%'`
 
 xe_check_libs=" -lldap "
 cat > conftest.$ac_ext <<EOF
-#line 7738 "configure"
+#line 7679 "configure"
 #include "confdefs.h"
 /* Override any gcc2 internal prototype to avoid an error.  */
 /* We use char because int might match the return type of a gcc2
@@ -7745,7 +7686,7 @@
 ldap_search()
 ; return 0; }
 EOF
-if { (eval echo configure:7749: \"$ac_link\") 1>&5; (eval $ac_link) 2>&5; } && test -s conftest${ac_exeext}; then
+if { (eval echo configure:7690: \"$ac_link\") 1>&5; (eval $ac_link) 2>&5; } && test -s conftest${ac_exeext}; then
   rm -rf conftest*
   eval "ac_cv_lib_$ac_lib_var=yes"
 else
@@ -7770,12 +7711,12 @@
 xe_msg_checking="for ldap_open in -lldap"
 test -n "-llber" && xe_msg_checking="$xe_msg_checking using extra libs -llber"
 echo $ac_n "checking "$xe_msg_checking"""... $ac_c" 1>&6
-echo "configure:7774: checking "$xe_msg_checking"" >&5
+echo "configure:7715: checking "$xe_msg_checking"" >&5
 ac_lib_var=`echo ldap'_'ldap_open | sed 'y%./+-%__p_%'`
 
 xe_check_libs=" -lldap -llber"
 cat > conftest.$ac_ext <<EOF
-#line 7779 "configure"
+#line 7720 "configure"
 #include "confdefs.h"
 /* Override any gcc2 internal prototype to avoid an error.  */
 /* We use char because int might match the return type of a gcc2
@@ -7786,7 +7727,7 @@
 ldap_open()
 ; return 0; }
 EOF
-if { (eval echo configure:7790: \"$ac_link\") 1>&5; (eval $ac_link) 2>&5; } && test -s conftest${ac_exeext}; then
+if { (eval echo configure:7731: \"$ac_link\") 1>&5; (eval $ac_link) 2>&5; } && test -s conftest${ac_exeext}; then
   rm -rf conftest*
   eval "ac_cv_lib_$ac_lib_var=yes"
 else
@@ -7811,12 +7752,12 @@
 xe_msg_checking="for ldap_open in -lldap"
 test -n "-llber -lkrb" && xe_msg_checking="$xe_msg_checking using extra libs -llber -lkrb"
 echo $ac_n "checking "$xe_msg_checking"""... $ac_c" 1>&6
-echo "configure:7815: checking "$xe_msg_checking"" >&5
+echo "configure:7756: checking "$xe_msg_checking"" >&5
 ac_lib_var=`echo ldap'_'ldap_open | sed 'y%./+-%__p_%'`
 
 xe_check_libs=" -lldap -llber -lkrb"
 cat > conftest.$ac_ext <<EOF
-#line 7820 "configure"
+#line 7761 "configure"
 #include "confdefs.h"
 /* Override any gcc2 internal prototype to avoid an error.  */
 /* We use char because int might match the return type of a gcc2
@@ -7827,7 +7768,7 @@
 ldap_open()
 ; return 0; }
 EOF
-if { (eval echo configure:7831: \"$ac_link\") 1>&5; (eval $ac_link) 2>&5; } && test -s conftest${ac_exeext}; then
+if { (eval echo configure:7772: \"$ac_link\") 1>&5; (eval $ac_link) 2>&5; } && test -s conftest${ac_exeext}; then
   rm -rf conftest*
   eval "ac_cv_lib_$ac_lib_var=yes"
 else
@@ -7852,12 +7793,12 @@
 xe_msg_checking="for ldap_open in -lldap"
 test -n "-llber -lkrb -ldes" && xe_msg_checking="$xe_msg_checking using extra libs -llber -lkrb -ldes"
 echo $ac_n "checking "$xe_msg_checking"""... $ac_c" 1>&6
-echo "configure:7856: checking "$xe_msg_checking"" >&5
+echo "configure:7797: checking "$xe_msg_checking"" >&5
 ac_lib_var=`echo ldap'_'ldap_open | sed 'y%./+-%__p_%'`
 
 xe_check_libs=" -lldap -llber -lkrb -ldes"
 cat > conftest.$ac_ext <<EOF
-#line 7861 "configure"
+#line 7802 "configure"
 #include "confdefs.h"
 /* Override any gcc2 internal prototype to avoid an error.  */
 /* We use char because int might match the return type of a gcc2
@@ -7868,7 +7809,7 @@
 ldap_open()
 ; return 0; }
 EOF
-if { (eval echo configure:7872: \"$ac_link\") 1>&5; (eval $ac_link) 2>&5; } && test -s conftest${ac_exeext}; then
+if { (eval echo configure:7813: \"$ac_link\") 1>&5; (eval $ac_link) 2>&5; } && test -s conftest${ac_exeext}; then
   rm -rf conftest*
   eval "ac_cv_lib_$ac_lib_var=yes"
 else
@@ -7900,9 +7841,6 @@
 EOF
 }
 
-  extra_objs="$extra_objs eldap.o" &&  if test "$extra_verbose" = "yes"; then
-   echo "    xemacs will be linked with \"eldap.o\""
- fi
   if test "$with_ldap_nolber" = "yes" ; then
     LIBS="-lldap $LIBS" &&  if test "$extra_verbose" = "yes"; then echo "    Prepending \"-lldap\" to \$LIBS"; fi
   else
@@ -7919,10 +7857,10 @@
   for ac_func in ldap_set_option ldap_get_lderrno ldap_result2error ldap_parse_result
 do
 echo $ac_n "checking for $ac_func""... $ac_c" 1>&6
-echo "configure:7923: checking for $ac_func" >&5
-
-cat > conftest.$ac_ext <<EOF
-#line 7926 "configure"
+echo "configure:7861: checking for $ac_func" >&5
+
+cat > conftest.$ac_ext <<EOF
+#line 7864 "configure"
 #include "confdefs.h"
 /* System header to define __stub macros and hopefully few prototypes,
     which can conflict with char $ac_func(); below.  */
@@ -7945,7 +7883,7 @@
 
 ; return 0; }
 EOF
-if { (eval echo configure:7949: \"$ac_link\") 1>&5; (eval $ac_link) 2>&5; } && test -s conftest${ac_exeext}; then
+if { (eval echo configure:7887: \"$ac_link\") 1>&5; (eval $ac_link) 2>&5; } && test -s conftest${ac_exeext}; then
   rm -rf conftest*
   eval "ac_cv_func_$ac_func=yes"
 else
@@ -7976,20 +7914,20 @@
 
 if test "$with_postgresql" != "no"; then
   echo "checking for PostgreSQL" 1>&6
-echo "configure:7980: checking for PostgreSQL" >&5
+echo "configure:7918: checking for PostgreSQL" >&5
 
   for header_dir in "" "pgsql/" "postgresql/"; do
     ac_safe=`echo "${header_dir}libpq-fe.h" | sed 'y%./+-%__p_%'`
 echo $ac_n "checking for ${header_dir}libpq-fe.h""... $ac_c" 1>&6
-echo "configure:7985: checking for ${header_dir}libpq-fe.h" >&5
-
-cat > conftest.$ac_ext <<EOF
-#line 7988 "configure"
+echo "configure:7923: checking for ${header_dir}libpq-fe.h" >&5
+
+cat > conftest.$ac_ext <<EOF
+#line 7926 "configure"
 #include "confdefs.h"
 #include <${header_dir}libpq-fe.h>
 EOF
 ac_try="$ac_cpp conftest.$ac_ext >/dev/null 2>conftest.out"
-{ (eval echo configure:7993: \"$ac_try\") 1>&5; (eval $ac_try) 2>&5; }
+{ (eval echo configure:7931: \"$ac_try\") 1>&5; (eval $ac_try) 2>&5; }
 ac_err=`grep -v '^ *+' conftest.out | grep -v "^conftest.${ac_ext}\$"`
 if test -z "$ac_err"; then
   rm -rf conftest*
@@ -8013,12 +7951,12 @@
 
   test -n "$libpq_fe_h_file" && { 
 echo $ac_n "checking for PQconnectdb in -lpq""... $ac_c" 1>&6
-echo "configure:8017: checking for PQconnectdb in -lpq" >&5
+echo "configure:7955: checking for PQconnectdb in -lpq" >&5
 ac_lib_var=`echo pq'_'PQconnectdb | sed 'y%./+-%__p_%'`
 
 xe_check_libs=" -lpq "
 cat > conftest.$ac_ext <<EOF
-#line 8022 "configure"
+#line 7960 "configure"
 #include "confdefs.h"
 /* Override any gcc2 internal prototype to avoid an error.  */
 /* We use char because int might match the return type of a gcc2
@@ -8029,7 +7967,7 @@
 PQconnectdb()
 ; return 0; }
 EOF
-if { (eval echo configure:8033: \"$ac_link\") 1>&5; (eval $ac_link) 2>&5; } && test -s conftest${ac_exeext}; then
+if { (eval echo configure:7971: \"$ac_link\") 1>&5; (eval $ac_link) 2>&5; } && test -s conftest${ac_exeext}; then
   rm -rf conftest*
   eval "ac_cv_lib_$ac_lib_var=yes"
 else
@@ -8062,12 +8000,12 @@
 
     
 echo $ac_n "checking for PQconnectStart in -lpq""... $ac_c" 1>&6
-echo "configure:8066: checking for PQconnectStart in -lpq" >&5
+echo "configure:8004: checking for PQconnectStart in -lpq" >&5
 ac_lib_var=`echo pq'_'PQconnectStart | sed 'y%./+-%__p_%'`
 
 xe_check_libs=" -lpq "
 cat > conftest.$ac_ext <<EOF
-#line 8071 "configure"
+#line 8009 "configure"
 #include "confdefs.h"
 /* Override any gcc2 internal prototype to avoid an error.  */
 /* We use char because int might match the return type of a gcc2
@@ -8078,7 +8016,7 @@
 PQconnectStart()
 ; return 0; }
 EOF
-if { (eval echo configure:8082: \"$ac_link\") 1>&5; (eval $ac_link) 2>&5; } && test -s conftest${ac_exeext}; then
+if { (eval echo configure:8020: \"$ac_link\") 1>&5; (eval $ac_link) 2>&5; } && test -s conftest${ac_exeext}; then
   rm -rf conftest*
   eval "ac_cv_lib_$ac_lib_var=yes"
 else
@@ -8115,9 +8053,6 @@
 }
 
     LIBS="-lpq $LIBS" &&  if test "$extra_verbose" = "yes"; then echo "    Prepending \"-lpq\" to \$LIBS"; fi
-    extra_objs="$extra_objs postgresql.o" &&  if test "$extra_verbose" = "yes"; then
-   echo "    xemacs will be linked with \"postgresql.o\""
- fi
   elif test "$with_postgresql" = "yes"; then
     { echo "Error:" "Required PostgreSQL support cannot be provided.  Check --site-prefixes." >&2; exit 1; }
   fi
@@ -8126,7 +8061,7 @@
 
 if test "$window_system" != "none"; then
   echo "checking for graphics libraries" 1>&6
-echo "configure:8130: checking for graphics libraries" >&5
+echo "configure:8065: checking for graphics libraries" >&5
 
       libpath_xpm=
   incpath_xpm=
@@ -8152,10 +8087,10 @@
     CFLAGS=""$incpath_xpm" $CFLAGS" &&  if test "$extra_verbose" = "yes"; then echo "    Prepending \""$incpath_xpm"\" to \$CFLAGS"; fi
     LDFLAGS=""$libpath_xpm" $LDFLAGS" &&  if test "$extra_verbose" = "yes"; then echo "    Prepending \""$libpath_xpm"\" to \$LDFLAGS"; fi
     echo $ac_n "checking for Xpm - no older than 3.4f""... $ac_c" 1>&6
-echo "configure:8156: checking for Xpm - no older than 3.4f" >&5
+echo "configure:8091: checking for Xpm - no older than 3.4f" >&5
     xe_check_libs=-lXpm
     cat > conftest.$ac_ext <<EOF
-#line 8159 "configure"
+#line 8094 "configure"
 #include "confdefs.h"
 #define XPM_NUMBERS
 #include <X11/xpm.h>
@@ -8164,7 +8099,7 @@
       XpmIncludeVersion != XpmLibraryVersion() ? 1 :
       XpmIncludeVersion < 30406 ? 2 : 0 ;}
 EOF
-if { (eval echo configure:8168: \"$ac_link\") 1>&5; (eval $ac_link) 2>&5; } && test -s conftest && (./conftest; exit $?) 2>&5
+if { (eval echo configure:8103: \"$ac_link\") 1>&5; (eval $ac_link) 2>&5; } && test -s conftest && (./conftest; exit $?) 2>&5
 then
   ./conftest dummy_arg; xpm_status=$?;
       if test "$xpm_status" = "0"; then
@@ -8208,17 +8143,17 @@
     libs_x="-lXpm $libs_x" &&  if test "$extra_verbose" = "yes"; then echo "    Prepending \"-lXpm\" to \$libs_x"; fi
     CFLAGS=""$incpath_xpm" $CFLAGS" &&  if test "$extra_verbose" = "yes"; then echo "    Prepending \""$incpath_xpm"\" to \$CFLAGS"; fi
     echo $ac_n "checking for \"FOR_MSW\" xpm""... $ac_c" 1>&6
-echo "configure:8212: checking for \"FOR_MSW\" xpm" >&5
+echo "configure:8147: checking for \"FOR_MSW\" xpm" >&5
     xe_check_libs=-lXpm
     cat > conftest.$ac_ext <<EOF
-#line 8215 "configure"
+#line 8150 "configure"
 #include "confdefs.h"
 
 int main() {
 XpmCreatePixmapFromData()
 ; return 0; }
 EOF
-if { (eval echo configure:8222: \"$ac_link\") 1>&5; (eval $ac_link) 2>&5; } && test -s conftest${ac_exeext}; then
+if { (eval echo configure:8157: \"$ac_link\") 1>&5; (eval $ac_link) 2>&5; } && test -s conftest${ac_exeext}; then
   rm -rf conftest*
   xpm_for_msw=no
 else
@@ -8244,15 +8179,15 @@
 
     test -z "$with_xface" && { ac_safe=`echo "compface.h" | sed 'y%./+-%__p_%'`
 echo $ac_n "checking for compface.h""... $ac_c" 1>&6
-echo "configure:8248: checking for compface.h" >&5
-
-cat > conftest.$ac_ext <<EOF
-#line 8251 "configure"
+echo "configure:8183: checking for compface.h" >&5
+
+cat > conftest.$ac_ext <<EOF
+#line 8186 "configure"
 #include "confdefs.h"
 #include <compface.h>
 EOF
 ac_try="$ac_cpp conftest.$ac_ext >/dev/null 2>conftest.out"
-{ (eval echo configure:8256: \"$ac_try\") 1>&5; (eval $ac_try) 2>&5; }
+{ (eval echo configure:8191: \"$ac_try\") 1>&5; (eval $ac_try) 2>&5; }
 ac_err=`grep -v '^ *+' conftest.out | grep -v "^conftest.${ac_ext}\$"`
 if test -z "$ac_err"; then
   rm -rf conftest*
@@ -8275,12 +8210,12 @@
  }
   test -z "$with_xface" && { 
 echo $ac_n "checking for UnGenFace in -lcompface""... $ac_c" 1>&6
-echo "configure:8279: checking for UnGenFace in -lcompface" >&5
+echo "configure:8214: checking for UnGenFace in -lcompface" >&5
 ac_lib_var=`echo compface'_'UnGenFace | sed 'y%./+-%__p_%'`
 
 xe_check_libs=" -lcompface "
 cat > conftest.$ac_ext <<EOF
-#line 8284 "configure"
+#line 8219 "configure"
 #include "confdefs.h"
 /* Override any gcc2 internal prototype to avoid an error.  */
 /* We use char because int might match the return type of a gcc2
@@ -8291,7 +8226,7 @@
 UnGenFace()
 ; return 0; }
 EOF
-if { (eval echo configure:8295: \"$ac_link\") 1>&5; (eval $ac_link) 2>&5; } && test -s conftest${ac_exeext}; then
+if { (eval echo configure:8230: \"$ac_link\") 1>&5; (eval $ac_link) 2>&5; } && test -s conftest${ac_exeext}; then
   rm -rf conftest*
   eval "ac_cv_lib_$ac_lib_var=yes"
 else
@@ -8335,20 +8270,17 @@
 EOF
 }
 
-    extra_objs="$extra_objs dgif_lib.o gif_io.o" &&  if test "$extra_verbose" = "yes"; then
-   echo "    xemacs will be linked with \"dgif_lib.o gif_io.o\""
- fi
   fi
 
       if test "$with_png $with_tiff" != "no no"; then
     
 echo $ac_n "checking for inflate in -lc""... $ac_c" 1>&6
-echo "configure:8347: checking for inflate in -lc" >&5
+echo "configure:8279: checking for inflate in -lc" >&5
 ac_lib_var=`echo c'_'inflate | sed 'y%./+-%__p_%'`
 
 xe_check_libs=" -lc "
 cat > conftest.$ac_ext <<EOF
-#line 8352 "configure"
+#line 8284 "configure"
 #include "confdefs.h"
 /* Override any gcc2 internal prototype to avoid an error.  */
 /* We use char because int might match the return type of a gcc2
@@ -8359,7 +8291,7 @@
 inflate()
 ; return 0; }
 EOF
-if { (eval echo configure:8363: \"$ac_link\") 1>&5; (eval $ac_link) 2>&5; } && test -s conftest${ac_exeext}; then
+if { (eval echo configure:8295: \"$ac_link\") 1>&5; (eval $ac_link) 2>&5; } && test -s conftest${ac_exeext}; then
   rm -rf conftest*
   eval "ac_cv_lib_$ac_lib_var=yes"
 else
@@ -8378,12 +8310,12 @@
   echo "$ac_t""no" 1>&6
 
 echo $ac_n "checking for inflate in -lz""... $ac_c" 1>&6
-echo "configure:8382: checking for inflate in -lz" >&5
+echo "configure:8314: checking for inflate in -lz" >&5
 ac_lib_var=`echo z'_'inflate | sed 'y%./+-%__p_%'`
 
 xe_check_libs=" -lz "
 cat > conftest.$ac_ext <<EOF
-#line 8387 "configure"
+#line 8319 "configure"
 #include "confdefs.h"
 /* Override any gcc2 internal prototype to avoid an error.  */
 /* We use char because int might match the return type of a gcc2
@@ -8394,7 +8326,7 @@
 inflate()
 ; return 0; }
 EOF
-if { (eval echo configure:8398: \"$ac_link\") 1>&5; (eval $ac_link) 2>&5; } && test -s conftest${ac_exeext}; then
+if { (eval echo configure:8330: \"$ac_link\") 1>&5; (eval $ac_link) 2>&5; } && test -s conftest${ac_exeext}; then
   rm -rf conftest*
   eval "ac_cv_lib_$ac_lib_var=yes"
 else
@@ -8413,12 +8345,12 @@
   echo "$ac_t""no" 1>&6
 
 echo $ac_n "checking for inflate in -lgz""... $ac_c" 1>&6
-echo "configure:8417: checking for inflate in -lgz" >&5
+echo "configure:8349: checking for inflate in -lgz" >&5
 ac_lib_var=`echo gz'_'inflate | sed 'y%./+-%__p_%'`
 
 xe_check_libs=" -lgz "
 cat > conftest.$ac_ext <<EOF
-#line 8422 "configure"
+#line 8354 "configure"
 #include "confdefs.h"
 /* Override any gcc2 internal prototype to avoid an error.  */
 /* We use char because int might match the return type of a gcc2
@@ -8429,7 +8361,7 @@
 inflate()
 ; return 0; }
 EOF
-if { (eval echo configure:8433: \"$ac_link\") 1>&5; (eval $ac_link) 2>&5; } && test -s conftest${ac_exeext}; then
+if { (eval echo configure:8365: \"$ac_link\") 1>&5; (eval $ac_link) 2>&5; } && test -s conftest${ac_exeext}; then
   rm -rf conftest*
   eval "ac_cv_lib_$ac_lib_var=yes"
 else
@@ -8459,15 +8391,15 @@
 
     test -z "$with_jpeg" && { ac_safe=`echo "jpeglib.h" | sed 'y%./+-%__p_%'`
 echo $ac_n "checking for jpeglib.h""... $ac_c" 1>&6
-echo "configure:8463: checking for jpeglib.h" >&5
-
-cat > conftest.$ac_ext <<EOF
-#line 8466 "configure"
+echo "configure:8395: checking for jpeglib.h" >&5
+
+cat > conftest.$ac_ext <<EOF
+#line 8398 "configure"
 #include "confdefs.h"
 #include <jpeglib.h>
 EOF
 ac_try="$ac_cpp conftest.$ac_ext >/dev/null 2>conftest.out"
-{ (eval echo configure:8471: \"$ac_try\") 1>&5; (eval $ac_try) 2>&5; }
+{ (eval echo configure:8403: \"$ac_try\") 1>&5; (eval $ac_try) 2>&5; }
 ac_err=`grep -v '^ *+' conftest.out | grep -v "^conftest.${ac_ext}\$"`
 if test -z "$ac_err"; then
   rm -rf conftest*
@@ -8490,12 +8422,12 @@
  }
   test -z "$with_jpeg" && { 
 echo $ac_n "checking for jpeg_destroy_decompress in -ljpeg""... $ac_c" 1>&6
-echo "configure:8494: checking for jpeg_destroy_decompress in -ljpeg" >&5
+echo "configure:8426: checking for jpeg_destroy_decompress in -ljpeg" >&5
 ac_lib_var=`echo jpeg'_'jpeg_destroy_decompress | sed 'y%./+-%__p_%'`
 
 xe_check_libs=" -ljpeg "
 cat > conftest.$ac_ext <<EOF
-#line 8499 "configure"
+#line 8431 "configure"
 #include "confdefs.h"
 /* Override any gcc2 internal prototype to avoid an error.  */
 /* We use char because int might match the return type of a gcc2
@@ -8506,7 +8438,7 @@
 jpeg_destroy_decompress()
 ; return 0; }
 EOF
-if { (eval echo configure:8510: \"$ac_link\") 1>&5; (eval $ac_link) 2>&5; } && test -s conftest${ac_exeext}; then
+if { (eval echo configure:8442: \"$ac_link\") 1>&5; (eval $ac_link) 2>&5; } && test -s conftest${ac_exeext}; then
   rm -rf conftest*
   eval "ac_cv_lib_$ac_lib_var=yes"
 else
@@ -8542,10 +8474,10 @@
 
     png_problem=""
   test -z "$with_png" && { echo $ac_n "checking for pow""... $ac_c" 1>&6
-echo "configure:8546: checking for pow" >&5
-
-cat > conftest.$ac_ext <<EOF
-#line 8549 "configure"
+echo "configure:8478: checking for pow" >&5
+
+cat > conftest.$ac_ext <<EOF
+#line 8481 "configure"
 #include "confdefs.h"
 /* System header to define __stub macros and hopefully few prototypes,
     which can conflict with char pow(); below.  */
@@ -8568,7 +8500,7 @@
 
 ; return 0; }
 EOF
-if { (eval echo configure:8572: \"$ac_link\") 1>&5; (eval $ac_link) 2>&5; } && test -s conftest${ac_exeext}; then
+if { (eval echo configure:8504: \"$ac_link\") 1>&5; (eval $ac_link) 2>&5; } && test -s conftest${ac_exeext}; then
   rm -rf conftest*
   eval "ac_cv_func_pow=yes"
 else
@@ -8589,15 +8521,15 @@
  }
   test -z "$with_png" && { ac_safe=`echo "png.h" | sed 'y%./+-%__p_%'`
 echo $ac_n "checking for png.h""... $ac_c" 1>&6
-echo "configure:8593: checking for png.h" >&5
-
-cat > conftest.$ac_ext <<EOF
-#line 8596 "configure"
+echo "configure:8525: checking for png.h" >&5
+
+cat > conftest.$ac_ext <<EOF
+#line 8528 "configure"
 #include "confdefs.h"
 #include <png.h>
 EOF
 ac_try="$ac_cpp conftest.$ac_ext >/dev/null 2>conftest.out"
-{ (eval echo configure:8601: \"$ac_try\") 1>&5; (eval $ac_try) 2>&5; }
+{ (eval echo configure:8533: \"$ac_try\") 1>&5; (eval $ac_try) 2>&5; }
 ac_err=`grep -v '^ *+' conftest.out | grep -v "^conftest.${ac_ext}\$"`
 if test -z "$ac_err"; then
   rm -rf conftest*
@@ -8620,12 +8552,12 @@
  }
   test -z "$with_png" && { 
 echo $ac_n "checking for png_read_image in -lpng""... $ac_c" 1>&6
-echo "configure:8624: checking for png_read_image in -lpng" >&5
+echo "configure:8556: checking for png_read_image in -lpng" >&5
 ac_lib_var=`echo png'_'png_read_image | sed 'y%./+-%__p_%'`
 
 xe_check_libs=" -lpng "
 cat > conftest.$ac_ext <<EOF
-#line 8629 "configure"
+#line 8561 "configure"
 #include "confdefs.h"
 /* Override any gcc2 internal prototype to avoid an error.  */
 /* We use char because int might match the return type of a gcc2
@@ -8636,7 +8568,7 @@
 png_read_image()
 ; return 0; }
 EOF
-if { (eval echo configure:8640: \"$ac_link\") 1>&5; (eval $ac_link) 2>&5; } && test -s conftest${ac_exeext}; then
+if { (eval echo configure:8572: \"$ac_link\") 1>&5; (eval $ac_link) 2>&5; } && test -s conftest${ac_exeext}; then
   rm -rf conftest*
   eval "ac_cv_lib_$ac_lib_var=yes"
 else
@@ -8659,10 +8591,10 @@
  }
   if test -z "$with_png"; then
     echo $ac_n "checking for workable png version information""... $ac_c" 1>&6
-echo "configure:8663: checking for workable png version information" >&5
+echo "configure:8595: checking for workable png version information" >&5
     xe_check_libs="-lpng -lz"
     cat > conftest.$ac_ext <<EOF
-#line 8666 "configure"
+#line 8598 "configure"
 #include "confdefs.h"
 #include <png.h>
     int main(int c, char **v) {
@@ -8670,7 +8602,7 @@
     if (strcmp(png_libpng_ver, PNG_LIBPNG_VER_STRING) != 0) return 1;
     return (PNG_LIBPNG_VER < 10002) ? 2 : 0 ;}
 EOF
-if { (eval echo configure:8674: \"$ac_link\") 1>&5; (eval $ac_link) 2>&5; } && test -s conftest && (./conftest; exit $?) 2>&5
+if { (eval echo configure:8606: \"$ac_link\") 1>&5; (eval $ac_link) 2>&5; } && test -s conftest && (./conftest; exit $?) 2>&5
 then
   ./conftest dummy_arg; png_status=$?;
       if test "$png_status" = "0"; then
@@ -8713,15 +8645,15 @@
 
     test -z "$with_tiff" && { ac_safe=`echo "tiffio.h" | sed 'y%./+-%__p_%'`
 echo $ac_n "checking for tiffio.h""... $ac_c" 1>&6
-echo "configure:8717: checking for tiffio.h" >&5
-
-cat > conftest.$ac_ext <<EOF
-#line 8720 "configure"
+echo "configure:8649: checking for tiffio.h" >&5
+
+cat > conftest.$ac_ext <<EOF
+#line 8652 "configure"
 #include "confdefs.h"
 #include <tiffio.h>
 EOF
 ac_try="$ac_cpp conftest.$ac_ext >/dev/null 2>conftest.out"
-{ (eval echo configure:8725: \"$ac_try\") 1>&5; (eval $ac_try) 2>&5; }
+{ (eval echo configure:8657: \"$ac_try\") 1>&5; (eval $ac_try) 2>&5; }
 ac_err=`grep -v '^ *+' conftest.out | grep -v "^conftest.${ac_ext}\$"`
 if test -z "$ac_err"; then
   rm -rf conftest*
@@ -8744,12 +8676,12 @@
  }
   test -z "$with_tiff" && { 
 echo $ac_n "checking for TIFFClientOpen in -ltiff""... $ac_c" 1>&6
-echo "configure:8748: checking for TIFFClientOpen in -ltiff" >&5
+echo "configure:8680: checking for TIFFClientOpen in -ltiff" >&5
 ac_lib_var=`echo tiff'_'TIFFClientOpen | sed 'y%./+-%__p_%'`
 
 xe_check_libs=" -ltiff "
 cat > conftest.$ac_ext <<EOF
-#line 8753 "configure"
+#line 8685 "configure"
 #include "confdefs.h"
 /* Override any gcc2 internal prototype to avoid an error.  */
 /* We use char because int might match the return type of a gcc2
@@ -8760,7 +8692,7 @@
 TIFFClientOpen()
 ; return 0; }
 EOF
-if { (eval echo configure:8764: \"$ac_link\") 1>&5; (eval $ac_link) 2>&5; } && test -s conftest${ac_exeext}; then
+if { (eval echo configure:8696: \"$ac_link\") 1>&5; (eval $ac_link) 2>&5; } && test -s conftest${ac_exeext}; then
   rm -rf conftest*
   eval "ac_cv_lib_$ac_lib_var=yes"
 else
@@ -8799,15 +8731,15 @@
 if test "$with_gtk" = "yes"; then
     test -z "$with_xface" && { ac_safe=`echo "compface.h" | sed 'y%./+-%__p_%'`
 echo $ac_n "checking for compface.h""... $ac_c" 1>&6
-echo "configure:8803: checking for compface.h" >&5
-
-cat > conftest.$ac_ext <<EOF
-#line 8806 "configure"
+echo "configure:8735: checking for compface.h" >&5
+
+cat > conftest.$ac_ext <<EOF
+#line 8738 "configure"
 #include "confdefs.h"
 #include <compface.h>
 EOF
 ac_try="$ac_cpp conftest.$ac_ext >/dev/null 2>conftest.out"
-{ (eval echo configure:8811: \"$ac_try\") 1>&5; (eval $ac_try) 2>&5; }
+{ (eval echo configure:8743: \"$ac_try\") 1>&5; (eval $ac_try) 2>&5; }
 ac_err=`grep -v '^ *+' conftest.out | grep -v "^conftest.${ac_ext}\$"`
 if test -z "$ac_err"; then
   rm -rf conftest*
@@ -8830,12 +8762,12 @@
  }
   test -z "$with_xface" && { 
 echo $ac_n "checking for UnGenFace in -lcompface""... $ac_c" 1>&6
-echo "configure:8834: checking for UnGenFace in -lcompface" >&5
+echo "configure:8766: checking for UnGenFace in -lcompface" >&5
 ac_lib_var=`echo compface'_'UnGenFace | sed 'y%./+-%__p_%'`
 
 xe_check_libs=" -lcompface "
 cat > conftest.$ac_ext <<EOF
-#line 8839 "configure"
+#line 8771 "configure"
 #include "confdefs.h"
 /* Override any gcc2 internal prototype to avoid an error.  */
 /* We use char because int might match the return type of a gcc2
@@ -8846,7 +8778,7 @@
 UnGenFace()
 ; return 0; }
 EOF
-if { (eval echo configure:8850: \"$ac_link\") 1>&5; (eval $ac_link) 2>&5; } && test -s conftest${ac_exeext}; then
+if { (eval echo configure:8782: \"$ac_link\") 1>&5; (eval $ac_link) 2>&5; } && test -s conftest${ac_exeext}; then
   rm -rf conftest*
   eval "ac_cv_lib_$ac_lib_var=yes"
 else
@@ -8885,7 +8817,7 @@
 
 if test "$with_x11" = "yes"; then
   echo "checking for X11 graphics libraries" 1>&6
-echo "configure:8889: checking for X11 graphics libraries" >&5
+echo "configure:8821: checking for X11 graphics libraries" >&5
 fi
 
 case "$with_widgets" in
@@ -8895,7 +8827,7 @@
 
 if test "$with_x11" = "yes" -a "$detect_athena" = "yes" ; then
   echo "checking for the Athena widgets" 1>&6
-echo "configure:8899: checking for the Athena widgets" >&5
+echo "configure:8831: checking for the Athena widgets" >&5
 
     case "$with_athena" in
         "xaw" | "")	athena_variant=Xaw	athena_3d=no  ;;
@@ -8909,12 +8841,12 @@
     if test "$athena_3d" = "no"; then
     
 echo $ac_n "checking for XawScrollbarSetThumb in -l$athena_variant""... $ac_c" 1>&6
-echo "configure:8913: checking for XawScrollbarSetThumb in -l$athena_variant" >&5
+echo "configure:8845: checking for XawScrollbarSetThumb in -l$athena_variant" >&5
 ac_lib_var=`echo $athena_variant'_'XawScrollbarSetThumb | sed 'y%./+-%__p_%'`
 
 xe_check_libs=" -l$athena_variant "
 cat > conftest.$ac_ext <<EOF
-#line 8918 "configure"
+#line 8850 "configure"
 #include "confdefs.h"
 /* Override any gcc2 internal prototype to avoid an error.  */
 /* We use char because int might match the return type of a gcc2
@@ -8925,7 +8857,7 @@
 XawScrollbarSetThumb()
 ; return 0; }
 EOF
-if { (eval echo configure:8929: \"$ac_link\") 1>&5; (eval $ac_link) 2>&5; } && test -s conftest${ac_exeext}; then
+if { (eval echo configure:8861: \"$ac_link\") 1>&5; (eval $ac_link) 2>&5; } && test -s conftest${ac_exeext}; then
   rm -rf conftest*
   eval "ac_cv_lib_$ac_lib_var=yes"
 else
@@ -8941,12 +8873,12 @@
   echo "$ac_t""yes" 1>&6
           
 echo $ac_n "checking for threeDClassRec in -l$athena_variant""... $ac_c" 1>&6
-echo "configure:8945: checking for threeDClassRec in -l$athena_variant" >&5
+echo "configure:8877: checking for threeDClassRec in -l$athena_variant" >&5
 ac_lib_var=`echo $athena_variant'_'threeDClassRec | sed 'y%./+-%__p_%'`
 
 xe_check_libs=" -l$athena_variant "
 cat > conftest.$ac_ext <<EOF
-#line 8950 "configure"
+#line 8882 "configure"
 #include "confdefs.h"
 /* Override any gcc2 internal prototype to avoid an error.  */
 /* We use char because int might match the return type of a gcc2
@@ -8957,7 +8889,7 @@
 threeDClassRec()
 ; return 0; }
 EOF
-if { (eval echo configure:8961: \"$ac_link\") 1>&5; (eval $ac_link) 2>&5; } && test -s conftest${ac_exeext}; then
+if { (eval echo configure:8893: \"$ac_link\") 1>&5; (eval $ac_link) 2>&5; } && test -s conftest${ac_exeext}; then
   rm -rf conftest*
   eval "ac_cv_lib_$ac_lib_var=yes"
 else
@@ -8988,12 +8920,12 @@
   else
         
 echo $ac_n "checking for threeDClassRec in -l$athena_variant""... $ac_c" 1>&6
-echo "configure:8992: checking for threeDClassRec in -l$athena_variant" >&5
+echo "configure:8924: checking for threeDClassRec in -l$athena_variant" >&5
 ac_lib_var=`echo $athena_variant'_'threeDClassRec | sed 'y%./+-%__p_%'`
 
 xe_check_libs=" -l$athena_variant "
 cat > conftest.$ac_ext <<EOF
-#line 8997 "configure"
+#line 8929 "configure"
 #include "confdefs.h"
 /* Override any gcc2 internal prototype to avoid an error.  */
 /* We use char because int might match the return type of a gcc2
@@ -9004,7 +8936,7 @@
 threeDClassRec()
 ; return 0; }
 EOF
-if { (eval echo configure:9008: \"$ac_link\") 1>&5; (eval $ac_link) 2>&5; } && test -s conftest${ac_exeext}; then
+if { (eval echo configure:8940: \"$ac_link\") 1>&5; (eval $ac_link) 2>&5; } && test -s conftest${ac_exeext}; then
   rm -rf conftest*
   eval "ac_cv_lib_$ac_lib_var=yes"
 else
@@ -9022,12 +8954,12 @@
 else
   echo "$ac_t""no" 1>&6
 echo $ac_n "checking for threeDClassRec in -lXaw""... $ac_c" 1>&6
-echo "configure:9026: checking for threeDClassRec in -lXaw" >&5
+echo "configure:8958: checking for threeDClassRec in -lXaw" >&5
 ac_lib_var=`echo Xaw'_'threeDClassRec | sed 'y%./+-%__p_%'`
 
 xe_check_libs=" -lXaw "
 cat > conftest.$ac_ext <<EOF
-#line 9031 "configure"
+#line 8963 "configure"
 #include "confdefs.h"
 /* Override any gcc2 internal prototype to avoid an error.  */
 /* We use char because int might match the return type of a gcc2
@@ -9038,7 +8970,7 @@
 threeDClassRec()
 ; return 0; }
 EOF
-if { (eval echo configure:9042: \"$ac_link\") 1>&5; (eval $ac_link) 2>&5; } && test -s conftest${ac_exeext}; then
+if { (eval echo configure:8974: \"$ac_link\") 1>&5; (eval $ac_link) 2>&5; } && test -s conftest${ac_exeext}; then
   rm -rf conftest*
   eval "ac_cv_lib_$ac_lib_var=yes"
 else
@@ -9069,15 +9001,15 @@
     if test "$athena_3d" = "no"; then
     ac_safe=`echo "X11/Xaw/ThreeD.h" | sed 'y%./+-%__p_%'`
 echo $ac_n "checking for X11/Xaw/ThreeD.h""... $ac_c" 1>&6
-echo "configure:9073: checking for X11/Xaw/ThreeD.h" >&5
-
-cat > conftest.$ac_ext <<EOF
-#line 9076 "configure"
+echo "configure:9005: checking for X11/Xaw/ThreeD.h" >&5
+
+cat > conftest.$ac_ext <<EOF
+#line 9008 "configure"
 #include "confdefs.h"
 #include <X11/Xaw/ThreeD.h>
 EOF
 ac_try="$ac_cpp conftest.$ac_ext >/dev/null 2>conftest.out"
-{ (eval echo configure:9081: \"$ac_try\") 1>&5; (eval $ac_try) 2>&5; }
+{ (eval echo configure:9013: \"$ac_try\") 1>&5; (eval $ac_try) 2>&5; }
 ac_err=`grep -v '^ *+' conftest.out | grep -v "^conftest.${ac_ext}\$"`
 if test -z "$ac_err"; then
   rm -rf conftest*
@@ -9097,15 +9029,15 @@
   echo "$ac_t""no" 1>&6
 ac_safe=`echo "X11/Xaw/XawInit.h" | sed 'y%./+-%__p_%'`
 echo $ac_n "checking for X11/Xaw/XawInit.h""... $ac_c" 1>&6
-echo "configure:9101: checking for X11/Xaw/XawInit.h" >&5
-
-cat > conftest.$ac_ext <<EOF
-#line 9104 "configure"
+echo "configure:9033: checking for X11/Xaw/XawInit.h" >&5
+
+cat > conftest.$ac_ext <<EOF
+#line 9036 "configure"
 #include "confdefs.h"
 #include <X11/Xaw/XawInit.h>
 EOF
 ac_try="$ac_cpp conftest.$ac_ext >/dev/null 2>conftest.out"
-{ (eval echo configure:9109: \"$ac_try\") 1>&5; (eval $ac_try) 2>&5; }
+{ (eval echo configure:9041: \"$ac_try\") 1>&5; (eval $ac_try) 2>&5; }
 ac_err=`grep -v '^ *+' conftest.out | grep -v "^conftest.${ac_ext}\$"`
 if test -z "$ac_err"; then
   rm -rf conftest*
@@ -9131,15 +9063,15 @@
   else
             ac_safe=`echo "X11/$athena_variant/XawInit.h" | sed 'y%./+-%__p_%'`
 echo $ac_n "checking for X11/$athena_variant/XawInit.h""... $ac_c" 1>&6
-echo "configure:9135: checking for X11/$athena_variant/XawInit.h" >&5
-
-cat > conftest.$ac_ext <<EOF
-#line 9138 "configure"
+echo "configure:9067: checking for X11/$athena_variant/XawInit.h" >&5
+
+cat > conftest.$ac_ext <<EOF
+#line 9070 "configure"
 #include "confdefs.h"
 #include <X11/$athena_variant/XawInit.h>
 EOF
 ac_try="$ac_cpp conftest.$ac_ext >/dev/null 2>conftest.out"
-{ (eval echo configure:9143: \"$ac_try\") 1>&5; (eval $ac_try) 2>&5; }
+{ (eval echo configure:9075: \"$ac_try\") 1>&5; (eval $ac_try) 2>&5; }
 ac_err=`grep -v '^ *+' conftest.out | grep -v "^conftest.${ac_ext}\$"`
 if test -z "$ac_err"; then
   rm -rf conftest*
@@ -9156,15 +9088,15 @@
   echo "$ac_t""yes" 1>&6
   ac_safe=`echo "X11/$athena_variant/ThreeD.h" | sed 'y%./+-%__p_%'`
 echo $ac_n "checking for X11/$athena_variant/ThreeD.h""... $ac_c" 1>&6
-echo "configure:9160: checking for X11/$athena_variant/ThreeD.h" >&5
-
-cat > conftest.$ac_ext <<EOF
-#line 9163 "configure"
+echo "configure:9092: checking for X11/$athena_variant/ThreeD.h" >&5
+
+cat > conftest.$ac_ext <<EOF
+#line 9095 "configure"
 #include "confdefs.h"
 #include <X11/$athena_variant/ThreeD.h>
 EOF
 ac_try="$ac_cpp conftest.$ac_ext >/dev/null 2>conftest.out"
-{ (eval echo configure:9168: \"$ac_try\") 1>&5; (eval $ac_try) 2>&5; }
+{ (eval echo configure:9100: \"$ac_try\") 1>&5; (eval $ac_try) 2>&5; }
 ac_err=`grep -v '^ *+' conftest.out | grep -v "^conftest.${ac_ext}\$"`
 if test -z "$ac_err"; then
   rm -rf conftest*
@@ -9192,15 +9124,15 @@
         if test -z "$athena_h_path"; then
       ac_safe=`echo "$athena_variant/XawInit.h" | sed 'y%./+-%__p_%'`
 echo $ac_n "checking for $athena_variant/XawInit.h""... $ac_c" 1>&6
-echo "configure:9196: checking for $athena_variant/XawInit.h" >&5
-
-cat > conftest.$ac_ext <<EOF
-#line 9199 "configure"
+echo "configure:9128: checking for $athena_variant/XawInit.h" >&5
+
+cat > conftest.$ac_ext <<EOF
+#line 9131 "configure"
 #include "confdefs.h"
 #include <$athena_variant/XawInit.h>
 EOF
 ac_try="$ac_cpp conftest.$ac_ext >/dev/null 2>conftest.out"
-{ (eval echo configure:9204: \"$ac_try\") 1>&5; (eval $ac_try) 2>&5; }
+{ (eval echo configure:9136: \"$ac_try\") 1>&5; (eval $ac_try) 2>&5; }
 ac_err=`grep -v '^ *+' conftest.out | grep -v "^conftest.${ac_ext}\$"`
 if test -z "$ac_err"; then
   rm -rf conftest*
@@ -9217,15 +9149,15 @@
   echo "$ac_t""yes" 1>&6
   ac_safe=`echo "$athena_variant/ThreeD.h" | sed 'y%./+-%__p_%'`
 echo $ac_n "checking for $athena_variant/ThreeD.h""... $ac_c" 1>&6
-echo "configure:9221: checking for $athena_variant/ThreeD.h" >&5
-
-cat > conftest.$ac_ext <<EOF
-#line 9224 "configure"
+echo "configure:9153: checking for $athena_variant/ThreeD.h" >&5
+
+cat > conftest.$ac_ext <<EOF
+#line 9156 "configure"
 #include "confdefs.h"
 #include <$athena_variant/ThreeD.h>
 EOF
 ac_try="$ac_cpp conftest.$ac_ext >/dev/null 2>conftest.out"
-{ (eval echo configure:9229: \"$ac_try\") 1>&5; (eval $ac_try) 2>&5; }
+{ (eval echo configure:9161: \"$ac_try\") 1>&5; (eval $ac_try) 2>&5; }
 ac_err=`grep -v '^ *+' conftest.out | grep -v "^conftest.${ac_ext}\$"`
 if test -z "$ac_err"; then
   rm -rf conftest*
@@ -9254,15 +9186,15 @@
         if test -z "$athena_h_path" -a "$athena_variant" != "Xaw3d"; then
       ac_safe=`echo "X11/Xaw3d/XawInit.h" | sed 'y%./+-%__p_%'`
 echo $ac_n "checking for X11/Xaw3d/XawInit.h""... $ac_c" 1>&6
-echo "configure:9258: checking for X11/Xaw3d/XawInit.h" >&5
-
-cat > conftest.$ac_ext <<EOF
-#line 9261 "configure"
+echo "configure:9190: checking for X11/Xaw3d/XawInit.h" >&5
+
+cat > conftest.$ac_ext <<EOF
+#line 9193 "configure"
 #include "confdefs.h"
 #include <X11/Xaw3d/XawInit.h>
 EOF
 ac_try="$ac_cpp conftest.$ac_ext >/dev/null 2>conftest.out"
-{ (eval echo configure:9266: \"$ac_try\") 1>&5; (eval $ac_try) 2>&5; }
+{ (eval echo configure:9198: \"$ac_try\") 1>&5; (eval $ac_try) 2>&5; }
 ac_err=`grep -v '^ *+' conftest.out | grep -v "^conftest.${ac_ext}\$"`
 if test -z "$ac_err"; then
   rm -rf conftest*
@@ -9279,15 +9211,15 @@
   echo "$ac_t""yes" 1>&6
   ac_safe=`echo "X11/Xaw3d/ThreeD.h" | sed 'y%./+-%__p_%'`
 echo $ac_n "checking for X11/Xaw3d/ThreeD.h""... $ac_c" 1>&6
-echo "configure:9283: checking for X11/Xaw3d/ThreeD.h" >&5
-
-cat > conftest.$ac_ext <<EOF
-#line 9286 "configure"
+echo "configure:9215: checking for X11/Xaw3d/ThreeD.h" >&5
+
+cat > conftest.$ac_ext <<EOF
+#line 9218 "configure"
 #include "confdefs.h"
 #include <X11/Xaw3d/ThreeD.h>
 EOF
 ac_try="$ac_cpp conftest.$ac_ext >/dev/null 2>conftest.out"
-{ (eval echo configure:9291: \"$ac_try\") 1>&5; (eval $ac_try) 2>&5; }
+{ (eval echo configure:9223: \"$ac_try\") 1>&5; (eval $ac_try) 2>&5; }
 ac_err=`grep -v '^ *+' conftest.out | grep -v "^conftest.${ac_ext}\$"`
 if test -z "$ac_err"; then
   rm -rf conftest*
@@ -9319,15 +9251,15 @@
         if test -z "$athena_h_path" -a "$athena_variant" != "Xaw3d"; then
       ac_safe=`echo "Xaw3d/XawInit.h" | sed 'y%./+-%__p_%'`
 echo $ac_n "checking for Xaw3d/XawInit.h""... $ac_c" 1>&6
-echo "configure:9323: checking for Xaw3d/XawInit.h" >&5
-
-cat > conftest.$ac_ext <<EOF
-#line 9326 "configure"
+echo "configure:9255: checking for Xaw3d/XawInit.h" >&5
+
+cat > conftest.$ac_ext <<EOF
+#line 9258 "configure"
 #include "confdefs.h"
 #include <Xaw3d/XawInit.h>
 EOF
 ac_try="$ac_cpp conftest.$ac_ext >/dev/null 2>conftest.out"
-{ (eval echo configure:9331: \"$ac_try\") 1>&5; (eval $ac_try) 2>&5; }
+{ (eval echo configure:9263: \"$ac_try\") 1>&5; (eval $ac_try) 2>&5; }
 ac_err=`grep -v '^ *+' conftest.out | grep -v "^conftest.${ac_ext}\$"`
 if test -z "$ac_err"; then
   rm -rf conftest*
@@ -9344,15 +9276,15 @@
   echo "$ac_t""yes" 1>&6
   ac_safe=`echo "Xaw3d/ThreeD.h" | sed 'y%./+-%__p_%'`
 echo $ac_n "checking for Xaw3d/ThreeD.h""... $ac_c" 1>&6
-echo "configure:9348: checking for Xaw3d/ThreeD.h" >&5
-
-cat > conftest.$ac_ext <<EOF
-#line 9351 "configure"
+echo "configure:9280: checking for Xaw3d/ThreeD.h" >&5
+
+cat > conftest.$ac_ext <<EOF
+#line 9283 "configure"
 #include "confdefs.h"
 #include <Xaw3d/ThreeD.h>
 EOF
 ac_try="$ac_cpp conftest.$ac_ext >/dev/null 2>conftest.out"
-{ (eval echo configure:9356: \"$ac_try\") 1>&5; (eval $ac_try) 2>&5; }
+{ (eval echo configure:9288: \"$ac_try\") 1>&5; (eval $ac_try) 2>&5; }
 ac_err=`grep -v '^ *+' conftest.out | grep -v "^conftest.${ac_ext}\$"`
 if test -z "$ac_err"; then
   rm -rf conftest*
@@ -9384,15 +9316,15 @@
             if test -z "$athena_h_path"; then
       ac_safe=`echo "X11/Xaw/ThreeD.h" | sed 'y%./+-%__p_%'`
 echo $ac_n "checking for X11/Xaw/ThreeD.h""... $ac_c" 1>&6
-echo "configure:9388: checking for X11/Xaw/ThreeD.h" >&5
-
-cat > conftest.$ac_ext <<EOF
-#line 9391 "configure"
+echo "configure:9320: checking for X11/Xaw/ThreeD.h" >&5
+
+cat > conftest.$ac_ext <<EOF
+#line 9323 "configure"
 #include "confdefs.h"
 #include <X11/Xaw/ThreeD.h>
 EOF
 ac_try="$ac_cpp conftest.$ac_ext >/dev/null 2>conftest.out"
-{ (eval echo configure:9396: \"$ac_try\") 1>&5; (eval $ac_try) 2>&5; }
+{ (eval echo configure:9328: \"$ac_try\") 1>&5; (eval $ac_try) 2>&5; }
 ac_err=`grep -v '^ *+' conftest.out | grep -v "^conftest.${ac_ext}\$"`
 if test -z "$ac_err"; then
   rm -rf conftest*
@@ -9431,15 +9363,15 @@
 if test "$with_x11" = "yes"; then
     ac_safe=`echo "Xm/Xm.h" | sed 'y%./+-%__p_%'`
 echo $ac_n "checking for Xm/Xm.h""... $ac_c" 1>&6
-echo "configure:9435: checking for Xm/Xm.h" >&5
-
-cat > conftest.$ac_ext <<EOF
-#line 9438 "configure"
+echo "configure:9367: checking for Xm/Xm.h" >&5
+
+cat > conftest.$ac_ext <<EOF
+#line 9370 "configure"
 #include "confdefs.h"
 #include <Xm/Xm.h>
 EOF
 ac_try="$ac_cpp conftest.$ac_ext >/dev/null 2>conftest.out"
-{ (eval echo configure:9443: \"$ac_try\") 1>&5; (eval $ac_try) 2>&5; }
+{ (eval echo configure:9375: \"$ac_try\") 1>&5; (eval $ac_try) 2>&5; }
 ac_err=`grep -v '^ *+' conftest.out | grep -v "^conftest.${ac_ext}\$"`
 if test -z "$ac_err"; then
   rm -rf conftest*
@@ -9456,12 +9388,12 @@
   echo "$ac_t""yes" 1>&6
   
 echo $ac_n "checking for XmStringFree in -lXm""... $ac_c" 1>&6
-echo "configure:9460: checking for XmStringFree in -lXm" >&5
+echo "configure:9392: checking for XmStringFree in -lXm" >&5
 ac_lib_var=`echo Xm'_'XmStringFree | sed 'y%./+-%__p_%'`
 
 xe_check_libs=" -lXm "
 cat > conftest.$ac_ext <<EOF
-#line 9465 "configure"
+#line 9397 "configure"
 #include "confdefs.h"
 /* Override any gcc2 internal prototype to avoid an error.  */
 /* We use char because int might match the return type of a gcc2
@@ -9472,7 +9404,7 @@
 XmStringFree()
 ; return 0; }
 EOF
-if { (eval echo configure:9476: \"$ac_link\") 1>&5; (eval $ac_link) 2>&5; } && test -s conftest${ac_exeext}; then
+if { (eval echo configure:9408: \"$ac_link\") 1>&5; (eval $ac_link) 2>&5; } && test -s conftest${ac_exeext}; then
   rm -rf conftest*
   eval "ac_cv_lib_$ac_lib_var=yes"
 else
@@ -9501,9 +9433,9 @@
 
   if test "$have_motif" = "yes"; then
         echo $ac_n "checking for Lesstif""... $ac_c" 1>&6
-echo "configure:9505: checking for Lesstif" >&5
+echo "configure:9437: checking for Lesstif" >&5
     cat > conftest.$ac_ext <<EOF
-#line 9507 "configure"
+#line 9439 "configure"
 #include "confdefs.h"
 #include <Xm/Xm.h>
 #ifdef LESSTIF_VERSION
@@ -9532,6 +9464,7 @@
 case "$with_dialogs" in "" | "yes" | "lucid" )
   if   test "$have_motif"     = "yes"; then with_dialogs="motif"
   elif test "$have_xaw"       = "yes"; then with_dialogs="athena"
+  elif test "$with_msw"       = "yes"; then with_dialogs="msw"
   else with_dialogs=no
   fi ;;
 esac
@@ -9541,6 +9474,7 @@
 case "$with_widgets" in "" | "yes" | "lucid")
   if   test "$have_motif" = "yes"; then with_widgets="motif"
   elif test "$have_xaw"   = "yes"; then with_widgets="athena"
+  elif test "$with_msw"   = "yes"; then with_widgets="msw"
   else with_widgets=no
   fi ;;
 esac
@@ -9857,83 +9791,24 @@
 }
 
 
-test "$with_menubars"   != "no"    && extra_objs="$extra_objs menubar.o" &&  if test "$extra_verbose" = "yes"; then
-   echo "    xemacs will be linked with \"menubar.o\""
- fi
-test "$with_scrollbars" != "no"    && extra_objs="$extra_objs scrollbar.o" &&  if test "$extra_verbose" = "yes"; then
-   echo "    xemacs will be linked with \"scrollbar.o\""
- fi
-test "$with_dialogs"    != "no"    && extra_objs="$extra_objs dialog.o" &&  if test "$extra_verbose" = "yes"; then
-   echo "    xemacs will be linked with \"dialog.o\""
- fi
-test "$with_toolbars"   != "no"    && extra_objs="$extra_objs toolbar.o" &&  if test "$extra_verbose" = "yes"; then
-   echo "    xemacs will be linked with \"toolbar.o\""
- fi
-
-if test "$with_gtk" = "yes"; then
-  test "$with_menubars"   != "no"      && extra_objs="$extra_objs menubar-gtk.o" &&  if test "$extra_verbose" = "yes"; then
-   echo "    xemacs will be linked with \"menubar-gtk.o\""
- fi
-  test "$with_scrollbars" != "no"      && extra_objs="$extra_objs scrollbar-gtk.o" &&  if test "$extra_verbose" = "yes"; then
-   echo "    xemacs will be linked with \"scrollbar-gtk.o\""
- fi
-  test "$with_dialogs"    != "no"      && extra_objs="$extra_objs dialog-gtk.o" &&  if test "$extra_verbose" = "yes"; then
-   echo "    xemacs will be linked with \"dialog-gtk.o\""
- fi
-  test "$with_toolbars"   != "no"      && extra_objs="$extra_objs toolbar-common.o toolbar-gtk.o" &&  if test "$extra_verbose" = "yes"; then
-   echo "    xemacs will be linked with \"toolbar-common.o toolbar-gtk.o\""
- fi
-  test "$all_widgets" != "no no no no no" && extra_objs="$extra_objs gui-gtk.o" &&  if test "$extra_verbose" = "yes"; then
-   echo "    xemacs will be linked with \"gui-gtk.o\""
- fi
-fi
-
-if test "$with_x11" = "yes"; then
-  test "$with_menubars"   != "no"  && extra_objs="$extra_objs menubar-x.o" &&  if test "$extra_verbose" = "yes"; then
-   echo "    xemacs will be linked with \"menubar-x.o\""
- fi
-  test "$with_scrollbars" != "no"  && extra_objs="$extra_objs scrollbar-x.o" &&  if test "$extra_verbose" = "yes"; then
-   echo "    xemacs will be linked with \"scrollbar-x.o\""
- fi
-  test "$with_dialogs"    != "no"  && extra_objs="$extra_objs dialog-x.o" &&  if test "$extra_verbose" = "yes"; then
-   echo "    xemacs will be linked with \"dialog-x.o\""
- fi
-  test "$with_toolbars"   != "no"  && extra_objs="$extra_objs toolbar-common.o toolbar-x.o" &&  if test "$extra_verbose" = "yes"; then
-   echo "    xemacs will be linked with \"toolbar-common.o toolbar-x.o\""
- fi
-  test "$all_widgets" != "no no no no no" && extra_objs="$extra_objs gui-x.o" &&  if test "$extra_verbose" = "yes"; then
-   echo "    xemacs will be linked with \"gui-x.o\""
- fi
-fi
-
 
 test -z "$with_mule" && with_mule=no
 
 
-if test "$with_file_coding" = "no" && test "$with_mule" = "yes"; then
-  echo "configure: warning: --with-file-coding forced to \`yes': Required for Mule support" 1>&2
-  with_file_coding=yes
-fi
-
-if test "$with_file_coding" = "yes" && test "$with_mule" = "no"; then
+if test "$with_default_eol_detection" = "yes"; then
   { test "$extra_verbose" = "yes" && cat << \EOF
-    Defining FILE_CODING
-EOF
-cat >> confdefs.h <<\EOF
-#define FILE_CODING 1
-EOF
-}
-
-  extra_objs="$extra_objs file-coding.o" &&  if test "$extra_verbose" = "yes"; then
-   echo "    xemacs will be linked with \"file-coding.o\""
- fi
-fi
-
-test -z "$with_file_coding" && with_file_coding=no
+    Defining HAVE_DEFAULT_EOL_DETECTION
+EOF
+cat >> confdefs.h <<\EOF
+#define HAVE_DEFAULT_EOL_DETECTION 1
+EOF
+}
+
+fi
 
 if test "$with_mule" = "yes" ; then
   echo "checking for Mule-related features" 1>&6
-echo "configure:9937: checking for Mule-related features" >&5
+echo "configure:9812: checking for Mule-related features" >&5
   { test "$extra_verbose" = "yes" && cat << \EOF
     Defining MULE
 EOF
@@ -9942,31 +9817,20 @@
 EOF
 }
 
-  { test "$extra_verbose" = "yes" && cat << \EOF
-    Defining FILE_CODING
-EOF
-cat >> confdefs.h <<\EOF
-#define FILE_CODING 1
-EOF
-}
-
-  extra_objs="$extra_objs mule.o mule-ccl.o mule-charset.o file-coding.o" &&  if test "$extra_verbose" = "yes"; then
-   echo "    xemacs will be linked with \"mule.o mule-ccl.o mule-charset.o file-coding.o\""
- fi
 
     for ac_hdr in libintl.h
 do
 ac_safe=`echo "$ac_hdr" | sed 'y%./+-%__p_%'`
 echo $ac_n "checking for $ac_hdr""... $ac_c" 1>&6
-echo "configure:9962: checking for $ac_hdr" >&5
-
-cat > conftest.$ac_ext <<EOF
-#line 9965 "configure"
+echo "configure:9826: checking for $ac_hdr" >&5
+
+cat > conftest.$ac_ext <<EOF
+#line 9829 "configure"
 #include "confdefs.h"
 #include <$ac_hdr>
 EOF
 ac_try="$ac_cpp conftest.$ac_ext >/dev/null 2>conftest.out"
-{ (eval echo configure:9970: \"$ac_try\") 1>&5; (eval $ac_try) 2>&5; }
+{ (eval echo configure:9834: \"$ac_try\") 1>&5; (eval $ac_try) 2>&5; }
 ac_err=`grep -v '^ *+' conftest.out | grep -v "^conftest.${ac_ext}\$"`
 if test -z "$ac_err"; then
   rm -rf conftest*
@@ -9997,12 +9861,12 @@
 
   
 echo $ac_n "checking for strerror in -lintl""... $ac_c" 1>&6
-echo "configure:10001: checking for strerror in -lintl" >&5
+echo "configure:9865: checking for strerror in -lintl" >&5
 ac_lib_var=`echo intl'_'strerror | sed 'y%./+-%__p_%'`
 
 xe_check_libs=" -lintl "
 cat > conftest.$ac_ext <<EOF
-#line 10006 "configure"
+#line 9870 "configure"
 #include "confdefs.h"
 /* Override any gcc2 internal prototype to avoid an error.  */
 /* We use char because int might match the return type of a gcc2
@@ -10013,7 +9877,7 @@
 strerror()
 ; return 0; }
 EOF
-if { (eval echo configure:10017: \"$ac_link\") 1>&5; (eval $ac_link) 2>&5; } && test -s conftest${ac_exeext}; then
+if { (eval echo configure:9881: \"$ac_link\") 1>&5; (eval $ac_link) 2>&5; } && test -s conftest${ac_exeext}; then
   rm -rf conftest*
   eval "ac_cv_lib_$ac_lib_var=yes"
 else
@@ -10046,18 +9910,18 @@
 
 
   echo "checking for Mule input methods" 1>&6
-echo "configure:10050: checking for Mule input methods" >&5
+echo "configure:9914: checking for Mule input methods" >&5
         case "$with_xim" in "" | "yes" )
     echo "checking for XIM" 1>&6
-echo "configure:10053: checking for XIM" >&5
+echo "configure:9917: checking for XIM" >&5
     
 echo $ac_n "checking for XOpenIM in -lX11""... $ac_c" 1>&6
-echo "configure:10056: checking for XOpenIM in -lX11" >&5
+echo "configure:9920: checking for XOpenIM in -lX11" >&5
 ac_lib_var=`echo X11'_'XOpenIM | sed 'y%./+-%__p_%'`
 
 xe_check_libs=" -lX11 "
 cat > conftest.$ac_ext <<EOF
-#line 10061 "configure"
+#line 9925 "configure"
 #include "confdefs.h"
 /* Override any gcc2 internal prototype to avoid an error.  */
 /* We use char because int might match the return type of a gcc2
@@ -10068,7 +9932,7 @@
 XOpenIM()
 ; return 0; }
 EOF
-if { (eval echo configure:10072: \"$ac_link\") 1>&5; (eval $ac_link) 2>&5; } && test -s conftest${ac_exeext}; then
+if { (eval echo configure:9936: \"$ac_link\") 1>&5; (eval $ac_link) 2>&5; } && test -s conftest${ac_exeext}; then
   rm -rf conftest*
   eval "ac_cv_lib_$ac_lib_var=yes"
 else
@@ -10092,12 +9956,12 @@
         if test "$have_motif $have_lesstif" = "yes no"; then
       
 echo $ac_n "checking for XmImMbLookupString in -lXm""... $ac_c" 1>&6
-echo "configure:10096: checking for XmImMbLookupString in -lXm" >&5
+echo "configure:9960: checking for XmImMbLookupString in -lXm" >&5
 ac_lib_var=`echo Xm'_'XmImMbLookupString | sed 'y%./+-%__p_%'`
 
 xe_check_libs=" -lXm "
 cat > conftest.$ac_ext <<EOF
-#line 10101 "configure"
+#line 9965 "configure"
 #include "confdefs.h"
 /* Override any gcc2 internal prototype to avoid an error.  */
 /* We use char because int might match the return type of a gcc2
@@ -10108,7 +9972,7 @@
 XmImMbLookupString()
 ; return 0; }
 EOF
-if { (eval echo configure:10112: \"$ac_link\") 1>&5; (eval $ac_link) 2>&5; } && test -s conftest${ac_exeext}; then
+if { (eval echo configure:9976: \"$ac_link\") 1>&5; (eval $ac_link) 2>&5; } && test -s conftest${ac_exeext}; then
   rm -rf conftest*
   eval "ac_cv_lib_$ac_lib_var=yes"
 else
@@ -10173,15 +10037,15 @@
 
     if test "$with_xfs" = "yes" ; then
     echo "checking for XFontSet" 1>&6
-echo "configure:10177: checking for XFontSet" >&5
+echo "configure:10041: checking for XFontSet" >&5
     
 echo $ac_n "checking for XmbDrawString in -lX11""... $ac_c" 1>&6
-echo "configure:10180: checking for XmbDrawString in -lX11" >&5
+echo "configure:10044: checking for XmbDrawString in -lX11" >&5
 ac_lib_var=`echo X11'_'XmbDrawString | sed 'y%./+-%__p_%'`
 
 xe_check_libs=" -lX11 "
 cat > conftest.$ac_ext <<EOF
-#line 10185 "configure"
+#line 10049 "configure"
 #include "confdefs.h"
 /* Override any gcc2 internal prototype to avoid an error.  */
 /* We use char because int might match the return type of a gcc2
@@ -10192,7 +10056,7 @@
 XmbDrawString()
 ; return 0; }
 EOF
-if { (eval echo configure:10196: \"$ac_link\") 1>&5; (eval $ac_link) 2>&5; } && test -s conftest${ac_exeext}; then
+if { (eval echo configure:10060: \"$ac_link\") 1>&5; (eval $ac_link) 2>&5; } && test -s conftest${ac_exeext}; then
   rm -rf conftest*
   eval "ac_cv_lib_$ac_lib_var=yes"
 else
@@ -10232,15 +10096,15 @@
     test "$with_wnn6" = "yes" && with_wnn=yes # wnn6 implies wnn support
   test -z "$with_wnn" && { ac_safe=`echo "wnn/jllib.h" | sed 'y%./+-%__p_%'`
 echo $ac_n "checking for wnn/jllib.h""... $ac_c" 1>&6
-echo "configure:10236: checking for wnn/jllib.h" >&5
-
-cat > conftest.$ac_ext <<EOF
-#line 10239 "configure"
+echo "configure:10100: checking for wnn/jllib.h" >&5
+
+cat > conftest.$ac_ext <<EOF
+#line 10103 "configure"
 #include "confdefs.h"
 #include <wnn/jllib.h>
 EOF
 ac_try="$ac_cpp conftest.$ac_ext >/dev/null 2>conftest.out"
-{ (eval echo configure:10244: \"$ac_try\") 1>&5; (eval $ac_try) 2>&5; }
+{ (eval echo configure:10108: \"$ac_try\") 1>&5; (eval $ac_try) 2>&5; }
 ac_err=`grep -v '^ *+' conftest.out | grep -v "^conftest.${ac_ext}\$"`
 if test -z "$ac_err"; then
   rm -rf conftest*
@@ -10263,15 +10127,15 @@
  }
     test -z "$with_wnn" && { ac_safe=`echo "wnn/commonhd.h" | sed 'y%./+-%__p_%'`
 echo $ac_n "checking for wnn/commonhd.h""... $ac_c" 1>&6
-echo "configure:10267: checking for wnn/commonhd.h" >&5
-
-cat > conftest.$ac_ext <<EOF
-#line 10270 "configure"
+echo "configure:10131: checking for wnn/commonhd.h" >&5
+
+cat > conftest.$ac_ext <<EOF
+#line 10134 "configure"
 #include "confdefs.h"
 #include <wnn/commonhd.h>
 EOF
 ac_try="$ac_cpp conftest.$ac_ext >/dev/null 2>conftest.out"
-{ (eval echo configure:10275: \"$ac_try\") 1>&5; (eval $ac_try) 2>&5; }
+{ (eval echo configure:10139: \"$ac_try\") 1>&5; (eval $ac_try) 2>&5; }
 ac_err=`grep -v '^ *+' conftest.out | grep -v "^conftest.${ac_ext}\$"`
 if test -z "$ac_err"; then
   rm -rf conftest*
@@ -10296,10 +10160,10 @@
     for ac_func in crypt
 do
 echo $ac_n "checking for $ac_func""... $ac_c" 1>&6
-echo "configure:10300: checking for $ac_func" >&5
-
-cat > conftest.$ac_ext <<EOF
-#line 10303 "configure"
+echo "configure:10164: checking for $ac_func" >&5
+
+cat > conftest.$ac_ext <<EOF
+#line 10167 "configure"
 #include "confdefs.h"
 /* System header to define __stub macros and hopefully few prototypes,
     which can conflict with char $ac_func(); below.  */
@@ -10322,7 +10186,7 @@
 
 ; return 0; }
 EOF
-if { (eval echo configure:10326: \"$ac_link\") 1>&5; (eval $ac_link) 2>&5; } && test -s conftest${ac_exeext}; then
+if { (eval echo configure:10190: \"$ac_link\") 1>&5; (eval $ac_link) 2>&5; } && test -s conftest${ac_exeext}; then
   rm -rf conftest*
   eval "ac_cv_func_$ac_func=yes"
 else
@@ -10351,12 +10215,12 @@
 
     test "$ac_cv_func_crypt" != "yes" && { 
 echo $ac_n "checking for crypt in -lcrypt""... $ac_c" 1>&6
-echo "configure:10355: checking for crypt in -lcrypt" >&5
+echo "configure:10219: checking for crypt in -lcrypt" >&5
 ac_lib_var=`echo crypt'_'crypt | sed 'y%./+-%__p_%'`
 
 xe_check_libs=" -lcrypt "
 cat > conftest.$ac_ext <<EOF
-#line 10360 "configure"
+#line 10224 "configure"
 #include "confdefs.h"
 /* Override any gcc2 internal prototype to avoid an error.  */
 /* We use char because int might match the return type of a gcc2
@@ -10367,7 +10231,7 @@
 crypt()
 ; return 0; }
 EOF
-if { (eval echo configure:10371: \"$ac_link\") 1>&5; (eval $ac_link) 2>&5; } && test -s conftest${ac_exeext}; then
+if { (eval echo configure:10235: \"$ac_link\") 1>&5; (eval $ac_link) 2>&5; } && test -s conftest${ac_exeext}; then
   rm -rf conftest*
   eval "ac_cv_lib_$ac_lib_var=yes"
 else
@@ -10402,12 +10266,12 @@
     if test -z "$with_wnn" -o "$with_wnn" = "yes"; then
     
 echo $ac_n "checking for jl_dic_list_e in -lwnn""... $ac_c" 1>&6
-echo "configure:10406: checking for jl_dic_list_e in -lwnn" >&5
+echo "configure:10270: checking for jl_dic_list_e in -lwnn" >&5
 ac_lib_var=`echo wnn'_'jl_dic_list_e | sed 'y%./+-%__p_%'`
 
 xe_check_libs=" -lwnn "
 cat > conftest.$ac_ext <<EOF
-#line 10411 "configure"
+#line 10275 "configure"
 #include "confdefs.h"
 /* Override any gcc2 internal prototype to avoid an error.  */
 /* We use char because int might match the return type of a gcc2
@@ -10418,7 +10282,7 @@
 jl_dic_list_e()
 ; return 0; }
 EOF
-if { (eval echo configure:10422: \"$ac_link\") 1>&5; (eval $ac_link) 2>&5; } && test -s conftest${ac_exeext}; then
+if { (eval echo configure:10286: \"$ac_link\") 1>&5; (eval $ac_link) 2>&5; } && test -s conftest${ac_exeext}; then
   rm -rf conftest*
   eval "ac_cv_lib_$ac_lib_var=yes"
 else
@@ -10436,12 +10300,12 @@
 else
   echo "$ac_t""no" 1>&6
 echo $ac_n "checking for jl_dic_list_e in -lwnn4""... $ac_c" 1>&6
-echo "configure:10440: checking for jl_dic_list_e in -lwnn4" >&5
+echo "configure:10304: checking for jl_dic_list_e in -lwnn4" >&5
 ac_lib_var=`echo wnn4'_'jl_dic_list_e | sed 'y%./+-%__p_%'`
 
 xe_check_libs=" -lwnn4 "
 cat > conftest.$ac_ext <<EOF
-#line 10445 "configure"
+#line 10309 "configure"
 #include "confdefs.h"
 /* Override any gcc2 internal prototype to avoid an error.  */
 /* We use char because int might match the return type of a gcc2
@@ -10452,7 +10316,7 @@
 jl_dic_list_e()
 ; return 0; }
 EOF
-if { (eval echo configure:10456: \"$ac_link\") 1>&5; (eval $ac_link) 2>&5; } && test -s conftest${ac_exeext}; then
+if { (eval echo configure:10320: \"$ac_link\") 1>&5; (eval $ac_link) 2>&5; } && test -s conftest${ac_exeext}; then
   rm -rf conftest*
   eval "ac_cv_lib_$ac_lib_var=yes"
 else
@@ -10470,12 +10334,12 @@
 else
   echo "$ac_t""no" 1>&6
 echo $ac_n "checking for jl_dic_list_e in -lwnn6""... $ac_c" 1>&6
-echo "configure:10474: checking for jl_dic_list_e in -lwnn6" >&5
+echo "configure:10338: checking for jl_dic_list_e in -lwnn6" >&5
 ac_lib_var=`echo wnn6'_'jl_dic_list_e | sed 'y%./+-%__p_%'`
 
 xe_check_libs=" -lwnn6 "
 cat > conftest.$ac_ext <<EOF
-#line 10479 "configure"
+#line 10343 "configure"
 #include "confdefs.h"
 /* Override any gcc2 internal prototype to avoid an error.  */
 /* We use char because int might match the return type of a gcc2
@@ -10486,7 +10350,7 @@
 jl_dic_list_e()
 ; return 0; }
 EOF
-if { (eval echo configure:10490: \"$ac_link\") 1>&5; (eval $ac_link) 2>&5; } && test -s conftest${ac_exeext}; then
+if { (eval echo configure:10354: \"$ac_link\") 1>&5; (eval $ac_link) 2>&5; } && test -s conftest${ac_exeext}; then
   rm -rf conftest*
   eval "ac_cv_lib_$ac_lib_var=yes"
 else
@@ -10504,12 +10368,12 @@
 else
   echo "$ac_t""no" 1>&6
 echo $ac_n "checking for dic_list_e in -lwnn6_fromsrc""... $ac_c" 1>&6
-echo "configure:10508: checking for dic_list_e in -lwnn6_fromsrc" >&5
+echo "configure:10372: checking for dic_list_e in -lwnn6_fromsrc" >&5
 ac_lib_var=`echo wnn6_fromsrc'_'dic_list_e | sed 'y%./+-%__p_%'`
 
 xe_check_libs=" -lwnn6_fromsrc "
 cat > conftest.$ac_ext <<EOF
-#line 10513 "configure"
+#line 10377 "configure"
 #include "confdefs.h"
 /* Override any gcc2 internal prototype to avoid an error.  */
 /* We use char because int might match the return type of a gcc2
@@ -10520,7 +10384,7 @@
 dic_list_e()
 ; return 0; }
 EOF
-if { (eval echo configure:10524: \"$ac_link\") 1>&5; (eval $ac_link) 2>&5; } && test -s conftest${ac_exeext}; then
+if { (eval echo configure:10388: \"$ac_link\") 1>&5; (eval $ac_link) 2>&5; } && test -s conftest${ac_exeext}; then
   rm -rf conftest*
   eval "ac_cv_lib_$ac_lib_var=yes"
 else
@@ -10562,18 +10426,15 @@
 }
 
     libs_x="-l$libwnn $libs_x" &&  if test "$extra_verbose" = "yes"; then echo "    Prepending \"-l$libwnn\" to \$libs_x"; fi
-    extra_objs="$extra_objs mule-wnnfns.o" &&  if test "$extra_verbose" = "yes"; then
-   echo "    xemacs will be linked with \"mule-wnnfns.o\""
- fi
     if test "$with_wnn6" != "no"; then
       
 echo $ac_n "checking for jl_fi_dic_list in -l$libwnn""... $ac_c" 1>&6
-echo "configure:10572: checking for jl_fi_dic_list in -l$libwnn" >&5
+echo "configure:10433: checking for jl_fi_dic_list in -l$libwnn" >&5
 ac_lib_var=`echo $libwnn'_'jl_fi_dic_list | sed 'y%./+-%__p_%'`
 
 xe_check_libs=" -l$libwnn "
 cat > conftest.$ac_ext <<EOF
-#line 10577 "configure"
+#line 10438 "configure"
 #include "confdefs.h"
 /* Override any gcc2 internal prototype to avoid an error.  */
 /* We use char because int might match the return type of a gcc2
@@ -10584,7 +10445,7 @@
 jl_fi_dic_list()
 ; return 0; }
 EOF
-if { (eval echo configure:10588: \"$ac_link\") 1>&5; (eval $ac_link) 2>&5; } && test -s conftest${ac_exeext}; then
+if { (eval echo configure:10449: \"$ac_link\") 1>&5; (eval $ac_link) 2>&5; } && test -s conftest${ac_exeext}; then
   rm -rf conftest*
   eval "ac_cv_lib_$ac_lib_var=yes"
 else
@@ -10619,15 +10480,15 @@
   if test "$with_canna" != "no"; then
     ac_safe=`echo "canna/jrkanji.h" | sed 'y%./+-%__p_%'`
 echo $ac_n "checking for canna/jrkanji.h""... $ac_c" 1>&6
-echo "configure:10623: checking for canna/jrkanji.h" >&5
-
-cat > conftest.$ac_ext <<EOF
-#line 10626 "configure"
+echo "configure:10484: checking for canna/jrkanji.h" >&5
+
+cat > conftest.$ac_ext <<EOF
+#line 10487 "configure"
 #include "confdefs.h"
 #include <canna/jrkanji.h>
 EOF
 ac_try="$ac_cpp conftest.$ac_ext >/dev/null 2>conftest.out"
-{ (eval echo configure:10631: \"$ac_try\") 1>&5; (eval $ac_try) 2>&5; }
+{ (eval echo configure:10492: \"$ac_try\") 1>&5; (eval $ac_try) 2>&5; }
 ac_err=`grep -v '^ *+' conftest.out | grep -v "^conftest.${ac_ext}\$"`
 if test -z "$ac_err"; then
   rm -rf conftest*
@@ -10654,15 +10515,15 @@
     c_switch_site="$c_switch_site -I/usr/local/canna/include"
     ac_safe=`echo "canna/jrkanji.h" | sed 'y%./+-%__p_%'`
 echo $ac_n "checking for canna/jrkanji.h""... $ac_c" 1>&6
-echo "configure:10658: checking for canna/jrkanji.h" >&5
-
-cat > conftest.$ac_ext <<EOF
-#line 10661 "configure"
+echo "configure:10519: checking for canna/jrkanji.h" >&5
+
+cat > conftest.$ac_ext <<EOF
+#line 10522 "configure"
 #include "confdefs.h"
 #include <canna/jrkanji.h>
 EOF
 ac_try="$ac_cpp conftest.$ac_ext >/dev/null 2>conftest.out"
-{ (eval echo configure:10666: \"$ac_try\") 1>&5; (eval $ac_try) 2>&5; }
+{ (eval echo configure:10527: \"$ac_try\") 1>&5; (eval $ac_try) 2>&5; }
 ac_err=`grep -v '^ *+' conftest.out | grep -v "^conftest.${ac_ext}\$"`
 if test -z "$ac_err"; then
   rm -rf conftest*
@@ -10690,15 +10551,15 @@
 
   test -z "$with_canna" && { ac_safe=`echo "canna/RK.h" | sed 'y%./+-%__p_%'`
 echo $ac_n "checking for canna/RK.h""... $ac_c" 1>&6
-echo "configure:10694: checking for canna/RK.h" >&5
-
-cat > conftest.$ac_ext <<EOF
-#line 10697 "configure"
+echo "configure:10555: checking for canna/RK.h" >&5
+
+cat > conftest.$ac_ext <<EOF
+#line 10558 "configure"
 #include "confdefs.h"
 #include <canna/RK.h>
 EOF
 ac_try="$ac_cpp conftest.$ac_ext >/dev/null 2>conftest.out"
-{ (eval echo configure:10702: \"$ac_try\") 1>&5; (eval $ac_try) 2>&5; }
+{ (eval echo configure:10563: \"$ac_try\") 1>&5; (eval $ac_try) 2>&5; }
 ac_err=`grep -v '^ *+' conftest.out | grep -v "^conftest.${ac_ext}\$"`
 if test -z "$ac_err"; then
   rm -rf conftest*
@@ -10721,12 +10582,12 @@
  }
   test -z "$with_canna" && { 
 echo $ac_n "checking for RkBgnBun in -lRKC""... $ac_c" 1>&6
-echo "configure:10725: checking for RkBgnBun in -lRKC" >&5
+echo "configure:10586: checking for RkBgnBun in -lRKC" >&5
 ac_lib_var=`echo RKC'_'RkBgnBun | sed 'y%./+-%__p_%'`
 
 xe_check_libs=" -lRKC "
 cat > conftest.$ac_ext <<EOF
-#line 10730 "configure"
+#line 10591 "configure"
 #include "confdefs.h"
 /* Override any gcc2 internal prototype to avoid an error.  */
 /* We use char because int might match the return type of a gcc2
@@ -10737,7 +10598,7 @@
 RkBgnBun()
 ; return 0; }
 EOF
-if { (eval echo configure:10741: \"$ac_link\") 1>&5; (eval $ac_link) 2>&5; } && test -s conftest${ac_exeext}; then
+if { (eval echo configure:10602: \"$ac_link\") 1>&5; (eval $ac_link) 2>&5; } && test -s conftest${ac_exeext}; then
   rm -rf conftest*
   eval "ac_cv_lib_$ac_lib_var=yes"
 else
@@ -10760,12 +10621,12 @@
  }
   test -z "$with_canna" && { 
 echo $ac_n "checking for jrKanjiControl in -lcanna""... $ac_c" 1>&6
-echo "configure:10764: checking for jrKanjiControl in -lcanna" >&5
+echo "configure:10625: checking for jrKanjiControl in -lcanna" >&5
 ac_lib_var=`echo canna'_'jrKanjiControl | sed 'y%./+-%__p_%'`
 
 xe_check_libs=" -lcanna "
 cat > conftest.$ac_ext <<EOF
-#line 10769 "configure"
+#line 10630 "configure"
 #include "confdefs.h"
 /* Override any gcc2 internal prototype to avoid an error.  */
 /* We use char because int might match the return type of a gcc2
@@ -10776,7 +10637,7 @@
 jrKanjiControl()
 ; return 0; }
 EOF
-if { (eval echo configure:10780: \"$ac_link\") 1>&5; (eval $ac_link) 2>&5; } && test -s conftest${ac_exeext}; then
+if { (eval echo configure:10641: \"$ac_link\") 1>&5; (eval $ac_link) 2>&5; } && test -s conftest${ac_exeext}; then
   rm -rf conftest*
   eval "ac_cv_lib_$ac_lib_var=yes"
 else
@@ -10808,9 +10669,6 @@
 }
 
     libs_x="-lcanna -lRKC $libs_x" &&  if test "$extra_verbose" = "yes"; then echo "    Prepending \"-lcanna -lRKC\" to \$libs_x"; fi
-    extra_objs="$extra_objs mule-canna.o" &&  if test "$extra_verbose" = "yes"; then
-   echo "    xemacs will be linked with \"mule-canna.o\""
- fi
   fi
 
 else   for feature in xim canna wnn; do
@@ -10825,12 +10683,12 @@
   libs_x="-lXm $libs_x" &&  if test "$extra_verbose" = "yes"; then echo "    Prepending \"-lXm\" to \$libs_x"; fi
     
 echo $ac_n "checking for layout_object_getvalue in -li18n""... $ac_c" 1>&6
-echo "configure:10829: checking for layout_object_getvalue in -li18n" >&5
+echo "configure:10687: checking for layout_object_getvalue in -li18n" >&5
 ac_lib_var=`echo i18n'_'layout_object_getvalue | sed 'y%./+-%__p_%'`
 
 xe_check_libs=" -li18n "
 cat > conftest.$ac_ext <<EOF
-#line 10834 "configure"
+#line 10692 "configure"
 #include "confdefs.h"
 /* Override any gcc2 internal prototype to avoid an error.  */
 /* We use char because int might match the return type of a gcc2
@@ -10841,7 +10699,7 @@
 layout_object_getvalue()
 ; return 0; }
 EOF
-if { (eval echo configure:10845: \"$ac_link\") 1>&5; (eval $ac_link) 2>&5; } && test -s conftest${ac_exeext}; then
+if { (eval echo configure:10703: \"$ac_link\") 1>&5; (eval $ac_link) 2>&5; } && test -s conftest${ac_exeext}; then
   rm -rf conftest*
   eval "ac_cv_lib_$ac_lib_var=yes"
 else
@@ -10924,13 +10782,13 @@
 
 fi
 
-for ac_func in cbrt closedir dup2 eaccess fmod fpathconf frexp ftime getaddrinfo gethostname getnameinfo getpagesize gettimeofday getcwd getwd logb lrand48 matherr mkdir mktime perror poll random rename res_init rint rmdir select setitimer setpgid setlocale setsid sigblock sighold sigprocmask snprintf stpcpy strerror tzset ulimit usleep waitpid vsnprintf fsync ftruncate umask
+for ac_func in cbrt closedir dup2 eaccess fmod fpathconf frexp ftime getaddrinfo gethostname getnameinfo getpagesize 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 symlink tzset ulimit usleep waitpid vsnprintf fsync ftruncate umask
 do
 echo $ac_n "checking for $ac_func""... $ac_c" 1>&6
-echo "configure:10931: checking for $ac_func" >&5
-
-cat > conftest.$ac_ext <<EOF
-#line 10934 "configure"
+echo "configure:10789: checking for $ac_func" >&5
+
+cat > conftest.$ac_ext <<EOF
+#line 10792 "configure"
 #include "confdefs.h"
 /* System header to define __stub macros and hopefully few prototypes,
     which can conflict with char $ac_func(); below.  */
@@ -10953,7 +10811,7 @@
 
 ; return 0; }
 EOF
-if { (eval echo configure:10957: \"$ac_link\") 1>&5; (eval $ac_link) 2>&5; } && test -s conftest${ac_exeext}; then
+if { (eval echo configure:10815: \"$ac_link\") 1>&5; (eval $ac_link) 2>&5; } && test -s conftest${ac_exeext}; then
   rm -rf conftest*
   eval "ac_cv_func_$ac_func=yes"
 else
@@ -10985,10 +10843,10 @@
 for ac_func in getpt _getpty grantpt unlockpt ptsname killpg tcgetpgrp
 do
 echo $ac_n "checking for $ac_func""... $ac_c" 1>&6
-echo "configure:10989: checking for $ac_func" >&5
-
-cat > conftest.$ac_ext <<EOF
-#line 10992 "configure"
+echo "configure:10847: checking for $ac_func" >&5
+
+cat > conftest.$ac_ext <<EOF
+#line 10850 "configure"
 #include "confdefs.h"
 /* System header to define __stub macros and hopefully few prototypes,
     which can conflict with char $ac_func(); below.  */
@@ -11011,7 +10869,7 @@
 
 ; return 0; }
 EOF
-if { (eval echo configure:11015: \"$ac_link\") 1>&5; (eval $ac_link) 2>&5; } && test -s conftest${ac_exeext}; then
+if { (eval echo configure:10873: \"$ac_link\") 1>&5; (eval $ac_link) 2>&5; } && test -s conftest${ac_exeext}; then
   rm -rf conftest*
   eval "ac_cv_func_$ac_func=yes"
 else
@@ -11040,10 +10898,10 @@
 
 
 echo $ac_n "checking for openpty""... $ac_c" 1>&6
-echo "configure:11044: checking for openpty" >&5
-
-cat > conftest.$ac_ext <<EOF
-#line 11047 "configure"
+echo "configure:10902: checking for openpty" >&5
+
+cat > conftest.$ac_ext <<EOF
+#line 10905 "configure"
 #include "confdefs.h"
 /* System header to define __stub macros and hopefully few prototypes,
     which can conflict with char openpty(); below.  */
@@ -11066,7 +10924,7 @@
 
 ; return 0; }
 EOF
-if { (eval echo configure:11070: \"$ac_link\") 1>&5; (eval $ac_link) 2>&5; } && test -s conftest${ac_exeext}; then
+if { (eval echo configure:10928: \"$ac_link\") 1>&5; (eval $ac_link) 2>&5; } && test -s conftest${ac_exeext}; then
   rm -rf conftest*
   eval "ac_cv_func_openpty=yes"
 else
@@ -11085,12 +10943,12 @@
 
   
 echo $ac_n "checking for openpty in -lutil""... $ac_c" 1>&6
-echo "configure:11089: checking for openpty in -lutil" >&5
+echo "configure:10947: checking for openpty in -lutil" >&5
 ac_lib_var=`echo util'_'openpty | sed 'y%./+-%__p_%'`
 
 xe_check_libs=" -lutil "
 cat > conftest.$ac_ext <<EOF
-#line 11094 "configure"
+#line 10952 "configure"
 #include "confdefs.h"
 /* Override any gcc2 internal prototype to avoid an error.  */
 /* We use char because int might match the return type of a gcc2
@@ -11101,7 +10959,7 @@
 openpty()
 ; return 0; }
 EOF
-if { (eval echo configure:11105: \"$ac_link\") 1>&5; (eval $ac_link) 2>&5; } && test -s conftest${ac_exeext}; then
+if { (eval echo configure:10963: \"$ac_link\") 1>&5; (eval $ac_link) 2>&5; } && test -s conftest${ac_exeext}; then
   rm -rf conftest*
   eval "ac_cv_lib_$ac_lib_var=yes"
 else
@@ -11136,15 +10994,15 @@
 do
 ac_safe=`echo "$ac_hdr" | sed 'y%./+-%__p_%'`
 echo $ac_n "checking for $ac_hdr""... $ac_c" 1>&6
-echo "configure:11140: checking for $ac_hdr" >&5
-
-cat > conftest.$ac_ext <<EOF
-#line 11143 "configure"
+echo "configure:10998: checking for $ac_hdr" >&5
+
+cat > conftest.$ac_ext <<EOF
+#line 11001 "configure"
 #include "confdefs.h"
 #include <$ac_hdr>
 EOF
 ac_try="$ac_cpp conftest.$ac_ext >/dev/null 2>conftest.out"
-{ (eval echo configure:11148: \"$ac_try\") 1>&5; (eval $ac_try) 2>&5; }
+{ (eval echo configure:11006: \"$ac_try\") 1>&5; (eval $ac_try) 2>&5; }
 ac_err=`grep -v '^ *+' conftest.out | grep -v "^conftest.${ac_ext}\$"`
 if test -z "$ac_err"; then
   rm -rf conftest*
@@ -11181,15 +11039,15 @@
 do
 ac_safe=`echo "$ac_hdr" | sed 'y%./+-%__p_%'`
 echo $ac_n "checking for $ac_hdr""... $ac_c" 1>&6
-echo "configure:11185: checking for $ac_hdr" >&5
-
-cat > conftest.$ac_ext <<EOF
-#line 11188 "configure"
+echo "configure:11043: checking for $ac_hdr" >&5
+
+cat > conftest.$ac_ext <<EOF
+#line 11046 "configure"
 #include "confdefs.h"
 #include <$ac_hdr>
 EOF
 ac_try="$ac_cpp conftest.$ac_ext >/dev/null 2>conftest.out"
-{ (eval echo configure:11193: \"$ac_try\") 1>&5; (eval $ac_try) 2>&5; }
+{ (eval echo configure:11051: \"$ac_try\") 1>&5; (eval $ac_try) 2>&5; }
 ac_err=`grep -v '^ *+' conftest.out | grep -v "^conftest.${ac_ext}\$"`
 if test -z "$ac_err"; then
   rm -rf conftest*
@@ -11222,15 +11080,15 @@
 do
 ac_safe=`echo "$ac_hdr" | sed 'y%./+-%__p_%'`
 echo $ac_n "checking for $ac_hdr""... $ac_c" 1>&6
-echo "configure:11226: checking for $ac_hdr" >&5
-
-cat > conftest.$ac_ext <<EOF
-#line 11229 "configure"
+echo "configure:11084: checking for $ac_hdr" >&5
+
+cat > conftest.$ac_ext <<EOF
+#line 11087 "configure"
 #include "confdefs.h"
 #include <$ac_hdr>
 EOF
 ac_try="$ac_cpp conftest.$ac_ext >/dev/null 2>conftest.out"
-{ (eval echo configure:11234: \"$ac_try\") 1>&5; (eval $ac_try) 2>&5; }
+{ (eval echo configure:11092: \"$ac_try\") 1>&5; (eval $ac_try) 2>&5; }
 ac_err=`grep -v '^ *+' conftest.out | grep -v "^conftest.${ac_ext}\$"`
 if test -z "$ac_err"; then
   rm -rf conftest*
@@ -11263,6 +11121,148 @@
 do
 ac_safe=`echo "$ac_hdr" | sed 'y%./+-%__p_%'`
 echo $ac_n "checking for $ac_hdr""... $ac_c" 1>&6
+echo "configure:11125: checking for $ac_hdr" >&5
+
+cat > conftest.$ac_ext <<EOF
+#line 11128 "configure"
+#include "confdefs.h"
+#include <$ac_hdr>
+EOF
+ac_try="$ac_cpp conftest.$ac_ext >/dev/null 2>conftest.out"
+{ (eval echo configure:11133: \"$ac_try\") 1>&5; (eval $ac_try) 2>&5; }
+ac_err=`grep -v '^ *+' conftest.out | grep -v "^conftest.${ac_ext}\$"`
+if test -z "$ac_err"; then
+  rm -rf conftest*
+  eval "ac_cv_header_$ac_safe=yes"
+else
+  echo "$ac_err" >&5
+  echo "configure: failed program was:" >&5
+  cat conftest.$ac_ext >&5
+  rm -rf conftest*
+  eval "ac_cv_header_$ac_safe=no"
+fi
+rm -f conftest*
+if eval "test \"`echo '$ac_cv_header_'$ac_safe`\" = yes"; then
+  echo "$ac_t""yes" 1>&6
+    ac_tr_hdr=HAVE_`echo $ac_hdr | sed 'y%abcdefghijklmnopqrstuvwxyz./-%ABCDEFGHIJKLMNOPQRSTUVWXYZ___%'`
+  { test "$extra_verbose" = "yes" && cat << EOF
+    Defining $ac_tr_hdr
+EOF
+cat >> confdefs.h <<EOF
+#define $ac_tr_hdr 1
+EOF
+}
+ 
+else
+  echo "$ac_t""no" 1>&6
+fi
+done
+
+     ;;
+esac
+
+for ac_hdr in stropts.h
+do
+ac_safe=`echo "$ac_hdr" | sed 'y%./+-%__p_%'`
+echo $ac_n "checking for $ac_hdr""... $ac_c" 1>&6
+echo "configure:11169: checking for $ac_hdr" >&5
+
+cat > conftest.$ac_ext <<EOF
+#line 11172 "configure"
+#include "confdefs.h"
+#include <$ac_hdr>
+EOF
+ac_try="$ac_cpp conftest.$ac_ext >/dev/null 2>conftest.out"
+{ (eval echo configure:11177: \"$ac_try\") 1>&5; (eval $ac_try) 2>&5; }
+ac_err=`grep -v '^ *+' conftest.out | grep -v "^conftest.${ac_ext}\$"`
+if test -z "$ac_err"; then
+  rm -rf conftest*
+  eval "ac_cv_header_$ac_safe=yes"
+else
+  echo "$ac_err" >&5
+  echo "configure: failed program was:" >&5
+  cat conftest.$ac_ext >&5
+  rm -rf conftest*
+  eval "ac_cv_header_$ac_safe=no"
+fi
+rm -f conftest*
+if eval "test \"`echo '$ac_cv_header_'$ac_safe`\" = yes"; then
+  echo "$ac_t""yes" 1>&6
+    ac_tr_hdr=HAVE_`echo $ac_hdr | sed 'y%abcdefghijklmnopqrstuvwxyz./-%ABCDEFGHIJKLMNOPQRSTUVWXYZ___%'`
+  { test "$extra_verbose" = "yes" && cat << EOF
+    Defining $ac_tr_hdr
+EOF
+cat >> confdefs.h <<EOF
+#define $ac_tr_hdr 1
+EOF
+}
+ 
+else
+  echo "$ac_t""no" 1>&6
+fi
+done
+
+if test "$ac_cv_header_stropts_h" = "yes"; then
+  for ac_func in isastream
+do
+echo $ac_n "checking for $ac_func""... $ac_c" 1>&6
+echo "configure:11210: checking for $ac_func" >&5
+
+cat > conftest.$ac_ext <<EOF
+#line 11213 "configure"
+#include "confdefs.h"
+/* System header to define __stub macros and hopefully few prototypes,
+    which can conflict with char $ac_func(); below.  */
+#include <assert.h>
+/* Override any gcc2 internal prototype to avoid an error.  */
+/* We use char because int might match the return type of a gcc2
+    builtin and then its argument prototype would still apply.  */
+char $ac_func();
+
+int main() {
+
+/* The GNU C library defines this for functions which it implements
+    to always fail with ENOSYS.  Some functions are actually named
+    something starting with __ and the normal name is an alias.  */
+#if defined (__stub_$ac_func) || defined (__stub___$ac_func)
+choke me
+#else
+$ac_func();
+#endif
+
+; return 0; }
+EOF
+if { (eval echo configure:11236: \"$ac_link\") 1>&5; (eval $ac_link) 2>&5; } && test -s conftest${ac_exeext}; then
+  rm -rf conftest*
+  eval "ac_cv_func_$ac_func=yes"
+else
+  echo "configure: failed program was:" >&5
+  cat conftest.$ac_ext >&5
+  rm -rf conftest*
+  eval "ac_cv_func_$ac_func=no"
+fi
+rm -f conftest*
+
+if eval "test \"`echo '$ac_cv_func_'$ac_func`\" = yes"; then
+  echo "$ac_t""yes" 1>&6
+    ac_tr_func=HAVE_`echo $ac_func | tr 'abcdefghijklmnopqrstuvwxyz' 'ABCDEFGHIJKLMNOPQRSTUVWXYZ'`
+  { test "$extra_verbose" = "yes" && cat << EOF
+    Defining $ac_tr_func
+EOF
+cat >> confdefs.h <<EOF
+#define $ac_tr_func 1
+EOF
+}
+ 
+else
+  echo "$ac_t""no" 1>&6
+fi
+done
+
+  for ac_hdr in strtio.h
+do
+ac_safe=`echo "$ac_hdr" | sed 'y%./+-%__p_%'`
+echo $ac_n "checking for $ac_hdr""... $ac_c" 1>&6
 echo "configure:11267: checking for $ac_hdr" >&5
 
 cat > conftest.$ac_ext <<EOF
@@ -11299,59 +11299,15 @@
   echo "$ac_t""no" 1>&6
 fi
 done
-
-     ;;
-esac
-
-for ac_hdr in stropts.h
-do
-ac_safe=`echo "$ac_hdr" | sed 'y%./+-%__p_%'`
-echo $ac_n "checking for $ac_hdr""... $ac_c" 1>&6
-echo "configure:11311: checking for $ac_hdr" >&5
-
-cat > conftest.$ac_ext <<EOF
-#line 11314 "configure"
-#include "confdefs.h"
-#include <$ac_hdr>
-EOF
-ac_try="$ac_cpp conftest.$ac_ext >/dev/null 2>conftest.out"
-{ (eval echo configure:11319: \"$ac_try\") 1>&5; (eval $ac_try) 2>&5; }
-ac_err=`grep -v '^ *+' conftest.out | grep -v "^conftest.${ac_ext}\$"`
-if test -z "$ac_err"; then
-  rm -rf conftest*
-  eval "ac_cv_header_$ac_safe=yes"
-else
-  echo "$ac_err" >&5
-  echo "configure: failed program was:" >&5
-  cat conftest.$ac_ext >&5
-  rm -rf conftest*
-  eval "ac_cv_header_$ac_safe=no"
-fi
-rm -f conftest*
-if eval "test \"`echo '$ac_cv_header_'$ac_safe`\" = yes"; then
-  echo "$ac_t""yes" 1>&6
-    ac_tr_hdr=HAVE_`echo $ac_hdr | sed 'y%abcdefghijklmnopqrstuvwxyz./-%ABCDEFGHIJKLMNOPQRSTUVWXYZ___%'`
-  { test "$extra_verbose" = "yes" && cat << EOF
-    Defining $ac_tr_hdr
-EOF
-cat >> confdefs.h <<EOF
-#define $ac_tr_hdr 1
-EOF
-}
- 
-else
-  echo "$ac_t""no" 1>&6
-fi
-done
-
-if test "$ac_cv_header_stropts_h" = "yes"; then
-  for ac_func in isastream
+ fi
+
+for ac_func in getloadavg
 do
 echo $ac_n "checking for $ac_func""... $ac_c" 1>&6
-echo "configure:11352: checking for $ac_func" >&5
-
-cat > conftest.$ac_ext <<EOF
-#line 11355 "configure"
+echo "configure:11308: checking for $ac_func" >&5
+
+cat > conftest.$ac_ext <<EOF
+#line 11311 "configure"
 #include "confdefs.h"
 /* System header to define __stub macros and hopefully few prototypes,
     which can conflict with char $ac_func(); below.  */
@@ -11374,109 +11330,7 @@
 
 ; return 0; }
 EOF
-if { (eval echo configure:11378: \"$ac_link\") 1>&5; (eval $ac_link) 2>&5; } && test -s conftest${ac_exeext}; then
-  rm -rf conftest*
-  eval "ac_cv_func_$ac_func=yes"
-else
-  echo "configure: failed program was:" >&5
-  cat conftest.$ac_ext >&5
-  rm -rf conftest*
-  eval "ac_cv_func_$ac_func=no"
-fi
-rm -f conftest*
-
-if eval "test \"`echo '$ac_cv_func_'$ac_func`\" = yes"; then
-  echo "$ac_t""yes" 1>&6
-    ac_tr_func=HAVE_`echo $ac_func | tr 'abcdefghijklmnopqrstuvwxyz' 'ABCDEFGHIJKLMNOPQRSTUVWXYZ'`
-  { test "$extra_verbose" = "yes" && cat << EOF
-    Defining $ac_tr_func
-EOF
-cat >> confdefs.h <<EOF
-#define $ac_tr_func 1
-EOF
-}
- 
-else
-  echo "$ac_t""no" 1>&6
-fi
-done
-
-  for ac_hdr in strtio.h
-do
-ac_safe=`echo "$ac_hdr" | sed 'y%./+-%__p_%'`
-echo $ac_n "checking for $ac_hdr""... $ac_c" 1>&6
-echo "configure:11409: checking for $ac_hdr" >&5
-
-cat > conftest.$ac_ext <<EOF
-#line 11412 "configure"
-#include "confdefs.h"
-#include <$ac_hdr>
-EOF
-ac_try="$ac_cpp conftest.$ac_ext >/dev/null 2>conftest.out"
-{ (eval echo configure:11417: \"$ac_try\") 1>&5; (eval $ac_try) 2>&5; }
-ac_err=`grep -v '^ *+' conftest.out | grep -v "^conftest.${ac_ext}\$"`
-if test -z "$ac_err"; then
-  rm -rf conftest*
-  eval "ac_cv_header_$ac_safe=yes"
-else
-  echo "$ac_err" >&5
-  echo "configure: failed program was:" >&5
-  cat conftest.$ac_ext >&5
-  rm -rf conftest*
-  eval "ac_cv_header_$ac_safe=no"
-fi
-rm -f conftest*
-if eval "test \"`echo '$ac_cv_header_'$ac_safe`\" = yes"; then
-  echo "$ac_t""yes" 1>&6
-    ac_tr_hdr=HAVE_`echo $ac_hdr | sed 'y%abcdefghijklmnopqrstuvwxyz./-%ABCDEFGHIJKLMNOPQRSTUVWXYZ___%'`
-  { test "$extra_verbose" = "yes" && cat << EOF
-    Defining $ac_tr_hdr
-EOF
-cat >> confdefs.h <<EOF
-#define $ac_tr_hdr 1
-EOF
-}
- 
-else
-  echo "$ac_t""no" 1>&6
-fi
-done
- fi
-
-extra_objs="$extra_objs realpath.o" &&  if test "$extra_verbose" = "yes"; then
-   echo "    xemacs will be linked with \"realpath.o\""
- fi
-
-for ac_func in getloadavg
-do
-echo $ac_n "checking for $ac_func""... $ac_c" 1>&6
-echo "configure:11454: checking for $ac_func" >&5
-
-cat > conftest.$ac_ext <<EOF
-#line 11457 "configure"
-#include "confdefs.h"
-/* System header to define __stub macros and hopefully few prototypes,
-    which can conflict with char $ac_func(); below.  */
-#include <assert.h>
-/* Override any gcc2 internal prototype to avoid an error.  */
-/* We use char because int might match the return type of a gcc2
-    builtin and then its argument prototype would still apply.  */
-char $ac_func();
-
-int main() {
-
-/* The GNU C library defines this for functions which it implements
-    to always fail with ENOSYS.  Some functions are actually named
-    something starting with __ and the normal name is an alias.  */
-#if defined (__stub_$ac_func) || defined (__stub___$ac_func)
-choke me
-#else
-$ac_func();
-#endif
-
-; return 0; }
-EOF
-if { (eval echo configure:11480: \"$ac_link\") 1>&5; (eval $ac_link) 2>&5; } && test -s conftest${ac_exeext}; then
+if { (eval echo configure:11334: \"$ac_link\") 1>&5; (eval $ac_link) 2>&5; } && test -s conftest${ac_exeext}; then
   rm -rf conftest*
   eval "ac_cv_func_$ac_func=yes"
 else
@@ -11509,15 +11363,15 @@
 do
 ac_safe=`echo "$ac_hdr" | sed 'y%./+-%__p_%'`
 echo $ac_n "checking for $ac_hdr""... $ac_c" 1>&6
-echo "configure:11513: checking for $ac_hdr" >&5
-
-cat > conftest.$ac_ext <<EOF
-#line 11516 "configure"
+echo "configure:11367: checking for $ac_hdr" >&5
+
+cat > conftest.$ac_ext <<EOF
+#line 11370 "configure"
 #include "confdefs.h"
 #include <$ac_hdr>
 EOF
 ac_try="$ac_cpp conftest.$ac_ext >/dev/null 2>conftest.out"
-{ (eval echo configure:11521: \"$ac_try\") 1>&5; (eval $ac_try) 2>&5; }
+{ (eval echo configure:11375: \"$ac_try\") 1>&5; (eval $ac_try) 2>&5; }
 ac_err=`grep -v '^ *+' conftest.out | grep -v "^conftest.${ac_ext}\$"`
 if test -z "$ac_err"; then
   rm -rf conftest*
@@ -11553,12 +11407,12 @@
 
     
 echo $ac_n "checking for kstat_open in -lkstat""... $ac_c" 1>&6
-echo "configure:11557: checking for kstat_open in -lkstat" >&5
+echo "configure:11411: checking for kstat_open in -lkstat" >&5
 ac_lib_var=`echo kstat'_'kstat_open | sed 'y%./+-%__p_%'`
 
 xe_check_libs=" -lkstat "
 cat > conftest.$ac_ext <<EOF
-#line 11562 "configure"
+#line 11416 "configure"
 #include "confdefs.h"
 /* Override any gcc2 internal prototype to avoid an error.  */
 /* We use char because int might match the return type of a gcc2
@@ -11569,7 +11423,7 @@
 kstat_open()
 ; return 0; }
 EOF
-if { (eval echo configure:11573: \"$ac_link\") 1>&5; (eval $ac_link) 2>&5; } && test -s conftest${ac_exeext}; then
+if { (eval echo configure:11427: \"$ac_link\") 1>&5; (eval $ac_link) 2>&5; } && test -s conftest${ac_exeext}; then
   rm -rf conftest*
   eval "ac_cv_lib_$ac_lib_var=yes"
 else
@@ -11604,15 +11458,15 @@
 do
 ac_safe=`echo "$ac_hdr" | sed 'y%./+-%__p_%'`
 echo $ac_n "checking for $ac_hdr""... $ac_c" 1>&6
-echo "configure:11608: checking for $ac_hdr" >&5
-
-cat > conftest.$ac_ext <<EOF
-#line 11611 "configure"
+echo "configure:11462: checking for $ac_hdr" >&5
+
+cat > conftest.$ac_ext <<EOF
+#line 11465 "configure"
 #include "confdefs.h"
 #include <$ac_hdr>
 EOF
 ac_try="$ac_cpp conftest.$ac_ext >/dev/null 2>conftest.out"
-{ (eval echo configure:11616: \"$ac_try\") 1>&5; (eval $ac_try) 2>&5; }
+{ (eval echo configure:11470: \"$ac_try\") 1>&5; (eval $ac_try) 2>&5; }
 ac_err=`grep -v '^ *+' conftest.out | grep -v "^conftest.${ac_ext}\$"`
 if test -z "$ac_err"; then
   rm -rf conftest*
@@ -11644,12 +11498,12 @@
 
     
 echo $ac_n "checking for kvm_read in -lkvm""... $ac_c" 1>&6
-echo "configure:11648: checking for kvm_read in -lkvm" >&5
+echo "configure:11502: checking for kvm_read in -lkvm" >&5
 ac_lib_var=`echo kvm'_'kvm_read | sed 'y%./+-%__p_%'`
 
 xe_check_libs=" -lkvm "
 cat > conftest.$ac_ext <<EOF
-#line 11653 "configure"
+#line 11507 "configure"
 #include "confdefs.h"
 /* Override any gcc2 internal prototype to avoid an error.  */
 /* We use char because int might match the return type of a gcc2
@@ -11660,7 +11514,7 @@
 kvm_read()
 ; return 0; }
 EOF
-if { (eval echo configure:11664: \"$ac_link\") 1>&5; (eval $ac_link) 2>&5; } && test -s conftest${ac_exeext}; then
+if { (eval echo configure:11518: \"$ac_link\") 1>&5; (eval $ac_link) 2>&5; } && test -s conftest${ac_exeext}; then
   rm -rf conftest*
   eval "ac_cv_lib_$ac_lib_var=yes"
 else
@@ -11694,16 +11548,16 @@
 fi
 
 echo $ac_n "checking whether netdb declares h_errno""... $ac_c" 1>&6
-echo "configure:11698: checking whether netdb declares h_errno" >&5
-cat > conftest.$ac_ext <<EOF
-#line 11700 "configure"
+echo "configure:11552: checking whether netdb declares h_errno" >&5
+cat > conftest.$ac_ext <<EOF
+#line 11554 "configure"
 #include "confdefs.h"
 #include <netdb.h>
 int main() {
 return h_errno;
 ; return 0; }
 EOF
-if { (eval echo configure:11707: \"$ac_link\") 1>&5; (eval $ac_link) 2>&5; } && test -s conftest${ac_exeext}; then
+if { (eval echo configure:11561: \"$ac_link\") 1>&5; (eval $ac_link) 2>&5; } && test -s conftest${ac_exeext}; then
   rm -rf conftest*
   echo "$ac_t""yes" 1>&6
    { test "$extra_verbose" = "yes" && cat << \EOF
@@ -11723,16 +11577,16 @@
 rm -f conftest*
 
 echo $ac_n "checking for sigsetjmp""... $ac_c" 1>&6
-echo "configure:11727: checking for sigsetjmp" >&5
-cat > conftest.$ac_ext <<EOF
-#line 11729 "configure"
+echo "configure:11581: checking for sigsetjmp" >&5
+cat > conftest.$ac_ext <<EOF
+#line 11583 "configure"
 #include "confdefs.h"
 #include <setjmp.h>
 int main() {
 sigjmp_buf bar; sigsetjmp (bar, 0);
 ; return 0; }
 EOF
-if { (eval echo configure:11736: \"$ac_compile\") 1>&5; (eval $ac_compile) 2>&5; }; then
+if { (eval echo configure:11590: \"$ac_compile\") 1>&5; (eval $ac_compile) 2>&5; }; then
   rm -rf conftest*
   echo "$ac_t""yes" 1>&6
    { test "$extra_verbose" = "yes" && cat << \EOF
@@ -11752,11 +11606,11 @@
 rm -f conftest*
 
 echo $ac_n "checking whether localtime caches TZ""... $ac_c" 1>&6
-echo "configure:11756: checking whether localtime caches TZ" >&5
+echo "configure:11610: checking whether localtime caches TZ" >&5
 
 if test "$ac_cv_func_tzset" = "yes"; then
 cat > conftest.$ac_ext <<EOF
-#line 11760 "configure"
+#line 11614 "configure"
 #include "confdefs.h"
 #include <time.h>
 #if STDC_HEADERS
@@ -11791,7 +11645,7 @@
   exit (0);
 }
 EOF
-if { (eval echo configure:11795: \"$ac_link\") 1>&5; (eval $ac_link) 2>&5; } && test -s conftest && (./conftest; exit $?) 2>&5
+if { (eval echo configure:11649: \"$ac_link\") 1>&5; (eval $ac_link) 2>&5; } && test -s conftest && (./conftest; exit $?) 2>&5
 then
   emacs_cv_localtime_cache=no
 else
@@ -11821,9 +11675,9 @@
 
 if test "$HAVE_TIMEVAL" = "yes"; then
 echo $ac_n "checking whether gettimeofday accepts one or two arguments""... $ac_c" 1>&6
-echo "configure:11825: checking whether gettimeofday accepts one or two arguments" >&5
-cat > conftest.$ac_ext <<EOF
-#line 11827 "configure"
+echo "configure:11679: checking whether gettimeofday accepts one or two arguments" >&5
+cat > conftest.$ac_ext <<EOF
+#line 11681 "configure"
 #include "confdefs.h"
 
 #ifdef TIME_WITH_SYS_TIME
@@ -11844,7 +11698,7 @@
 
 ; return 0; }
 EOF
-if { (eval echo configure:11848: \"$ac_link\") 1>&5; (eval $ac_link) 2>&5; } && test -s conftest${ac_exeext}; then
+if { (eval echo configure:11702: \"$ac_link\") 1>&5; (eval $ac_link) 2>&5; } && test -s conftest${ac_exeext}; then
   rm -rf conftest*
   echo "$ac_t""two" 1>&6
 else
@@ -11866,19 +11720,19 @@
 
 
 echo $ac_n "checking for inline""... $ac_c" 1>&6
-echo "configure:11870: checking for inline" >&5
+echo "configure:11724: checking for inline" >&5
 
 ac_cv_c_inline=no
 for ac_kw in inline __inline__ __inline; do
   cat > conftest.$ac_ext <<EOF
-#line 11875 "configure"
+#line 11729 "configure"
 #include "confdefs.h"
 
 int main() {
 } $ac_kw foo() {
 ; return 0; }
 EOF
-if { (eval echo configure:11882: \"$ac_compile\") 1>&5; (eval $ac_compile) 2>&5; }; then
+if { (eval echo configure:11736: \"$ac_compile\") 1>&5; (eval $ac_compile) 2>&5; }; then
   rm -rf conftest*
   ac_cv_c_inline=$ac_kw; break
 else
@@ -11919,17 +11773,17 @@
   # The Ultrix 4.2 mips builtin alloca declared by alloca.h only works
 # for constant arguments.  Useless!
 echo $ac_n "checking for working alloca.h""... $ac_c" 1>&6
-echo "configure:11923: checking for working alloca.h" >&5
-
-cat > conftest.$ac_ext <<EOF
-#line 11926 "configure"
+echo "configure:11777: checking for working alloca.h" >&5
+
+cat > conftest.$ac_ext <<EOF
+#line 11780 "configure"
 #include "confdefs.h"
 #include <alloca.h>
 int main() {
 char *p = alloca(2 * sizeof(int));
 ; return 0; }
 EOF
-if { (eval echo configure:11933: \"$ac_link\") 1>&5; (eval $ac_link) 2>&5; } && test -s conftest${ac_exeext}; then
+if { (eval echo configure:11787: \"$ac_link\") 1>&5; (eval $ac_link) 2>&5; } && test -s conftest${ac_exeext}; then
   rm -rf conftest*
   ac_cv_header_alloca_h=yes
 else
@@ -11953,10 +11807,10 @@
 fi
 
 echo $ac_n "checking for alloca""... $ac_c" 1>&6
-echo "configure:11957: checking for alloca" >&5
-
-cat > conftest.$ac_ext <<EOF
-#line 11960 "configure"
+echo "configure:11811: checking for alloca" >&5
+
+cat > conftest.$ac_ext <<EOF
+#line 11814 "configure"
 #include "confdefs.h"
 
 #ifdef __GNUC__
@@ -11984,7 +11838,7 @@
 char *p = (char *) alloca(1);
 ; return 0; }
 EOF
-if { (eval echo configure:11988: \"$ac_link\") 1>&5; (eval $ac_link) 2>&5; } && test -s conftest${ac_exeext}; then
+if { (eval echo configure:11842: \"$ac_link\") 1>&5; (eval $ac_link) 2>&5; } && test -s conftest${ac_exeext}; then
   rm -rf conftest*
   ac_cv_func_alloca_works=yes
 else
@@ -12023,10 +11877,10 @@
 
 
 echo $ac_n "checking whether alloca needs Cray hooks""... $ac_c" 1>&6
-echo "configure:12027: checking whether alloca needs Cray hooks" >&5
-
-cat > conftest.$ac_ext <<EOF
-#line 12030 "configure"
+echo "configure:11881: checking whether alloca needs Cray hooks" >&5
+
+cat > conftest.$ac_ext <<EOF
+#line 11884 "configure"
 #include "confdefs.h"
 #if defined(CRAY) && ! defined(CRAY2)
 webecray
@@ -12050,10 +11904,10 @@
 if test $ac_cv_os_cray = yes; then
 for ac_func in _getb67 GETB67 getb67; do
   echo $ac_n "checking for $ac_func""... $ac_c" 1>&6
-echo "configure:12054: checking for $ac_func" >&5
-
-cat > conftest.$ac_ext <<EOF
-#line 12057 "configure"
+echo "configure:11908: checking for $ac_func" >&5
+
+cat > conftest.$ac_ext <<EOF
+#line 11911 "configure"
 #include "confdefs.h"
 /* System header to define __stub macros and hopefully few prototypes,
     which can conflict with char $ac_func(); below.  */
@@ -12076,7 +11930,7 @@
 
 ; return 0; }
 EOF
-if { (eval echo configure:12080: \"$ac_link\") 1>&5; (eval $ac_link) 2>&5; } && test -s conftest${ac_exeext}; then
+if { (eval echo configure:11934: \"$ac_link\") 1>&5; (eval $ac_link) 2>&5; } && test -s conftest${ac_exeext}; then
   rm -rf conftest*
   eval "ac_cv_func_$ac_func=yes"
 else
@@ -12106,10 +11960,10 @@
 fi
 
 echo $ac_n "checking stack direction for C alloca""... $ac_c" 1>&6
-echo "configure:12110: checking stack direction for C alloca" >&5
-
-cat > conftest.$ac_ext <<EOF
-#line 12113 "configure"
+echo "configure:11964: checking stack direction for C alloca" >&5
+
+cat > conftest.$ac_ext <<EOF
+#line 11967 "configure"
 #include "confdefs.h"
 find_stack_direction ()
 {
@@ -12128,7 +11982,7 @@
   exit (find_stack_direction() < 0);
 }
 EOF
-if { (eval echo configure:12132: \"$ac_link\") 1>&5; (eval $ac_link) 2>&5; } && test -s conftest && (./conftest; exit $?) 2>&5
+if { (eval echo configure:11986: \"$ac_link\") 1>&5; (eval $ac_link) 2>&5; } && test -s conftest && (./conftest; exit $?) 2>&5
 then
   ac_cv_c_stack_direction=1
 else
@@ -12156,172 +12010,11 @@
  fi
 fi
 
-ac_safe=`echo "vfork.h" | sed 'y%./+-%__p_%'`
-echo $ac_n "checking for vfork.h""... $ac_c" 1>&6
-echo "configure:12162: checking for vfork.h" >&5
-
-cat > conftest.$ac_ext <<EOF
-#line 12165 "configure"
-#include "confdefs.h"
-#include <vfork.h>
-EOF
-ac_try="$ac_cpp conftest.$ac_ext >/dev/null 2>conftest.out"
-{ (eval echo configure:12170: \"$ac_try\") 1>&5; (eval $ac_try) 2>&5; }
-ac_err=`grep -v '^ *+' conftest.out | grep -v "^conftest.${ac_ext}\$"`
-if test -z "$ac_err"; then
-  rm -rf conftest*
-  eval "ac_cv_header_$ac_safe=yes"
-else
-  echo "$ac_err" >&5
-  echo "configure: failed program was:" >&5
-  cat conftest.$ac_ext >&5
-  rm -rf conftest*
-  eval "ac_cv_header_$ac_safe=no"
-fi
-rm -f conftest*
-if eval "test \"`echo '$ac_cv_header_'$ac_safe`\" = yes"; then
-  echo "$ac_t""yes" 1>&6
-  { test "$extra_verbose" = "yes" && cat << \EOF
-    Defining HAVE_VFORK_H
-EOF
-cat >> confdefs.h <<\EOF
-#define HAVE_VFORK_H 1
-EOF
-}
-
-else
-  echo "$ac_t""no" 1>&6
-fi
-
-echo $ac_n "checking for working vfork""... $ac_c" 1>&6
-echo "configure:12198: checking for working vfork" >&5
-
-cat > conftest.$ac_ext <<EOF
-#line 12201 "configure"
-#include "confdefs.h"
-/* Thanks to Paul Eggert for this test.  */
-#include <stdio.h>
-#include <sys/types.h>
-#include <sys/stat.h>
-#ifdef HAVE_UNISTD_H
-#include <unistd.h>
-#endif
-#ifdef HAVE_VFORK_H
-#include <vfork.h>
-#endif
-/* On some sparc systems, changes by the child to local and incoming
-   argument registers are propagated back to the parent.
-   The compiler is told about this with #include <vfork.h>,
-   but some compilers (e.g. gcc -O) don't grok <vfork.h>.
-   Test for this by using a static variable whose address
-   is put into a register that is clobbered by the vfork.  */
-static
-#ifdef __cplusplus
-sparc_address_test (int arg)
-#else
-sparc_address_test (arg) int arg;
-#endif
-{
-  static pid_t child;
-  if (!child) {
-    child = vfork ();
-    if (child < 0) {
-      perror ("vfork");
-      _exit(2);
-    }
-    if (!child) {
-      arg = getpid();
-      write(-1, "", 0);
-      _exit (arg);
-    }
-  }
-}
-main() {
-  pid_t parent = getpid ();
-  pid_t child;
-
-  sparc_address_test ();
-
-  child = vfork ();
-
-  if (child == 0) {
-    /* Here is another test for sparc vfork register problems.
-       This test uses lots of local variables, at least
-       as many local variables as main has allocated so far
-       including compiler temporaries.  4 locals are enough for
-       gcc 1.40.3 on a Solaris 4.1.3 sparc, but we use 8 to be safe.
-       A buggy compiler should reuse the register of parent
-       for one of the local variables, since it will think that
-       parent can't possibly be used any more in this routine.
-       Assigning to the local variable will thus munge parent
-       in the parent process.  */
-    pid_t
-      p = getpid(), p1 = getpid(), p2 = getpid(), p3 = getpid(),
-      p4 = getpid(), p5 = getpid(), p6 = getpid(), p7 = getpid();
-    /* Convince the compiler that p..p7 are live; otherwise, it might
-       use the same hardware register for all 8 local variables.  */
-    if (p != p1 || p != p2 || p != p3 || p != p4
-	|| p != p5 || p != p6 || p != p7)
-      _exit(1);
-
-    /* On some systems (e.g. IRIX 3.3),
-       vfork doesn't separate parent from child file descriptors.
-       If the child closes a descriptor before it execs or exits,
-       this munges the parent's descriptor as well.
-       Test for this by closing stdout in the child.  */
-    _exit(close(fileno(stdout)) != 0);
-  } else {
-    int status;
-    struct stat st;
-
-    while (wait(&status) != child)
-      ;
-    exit(
-	 /* Was there some problem with vforking?  */
-	 child < 0
-
-	 /* Did the child fail?  (This shouldn't happen.)  */
-	 || status
-
-	 /* Did the vfork/compiler bug occur?  */
-	 || parent != getpid()
-
-	 /* Did the file descriptor bug occur?  */
-	 || fstat(fileno(stdout), &st) != 0
-	 );
-  }
-}
-EOF
-if { (eval echo configure:12296: \"$ac_link\") 1>&5; (eval $ac_link) 2>&5; } && test -s conftest && (./conftest; exit $?) 2>&5
-then
-  ac_cv_func_vfork_works=yes
-else
-  conftest_rc="$?"
-  echo "configure: failed program was:" >&5
-  cat conftest.$ac_ext >&5
-  rm -fr conftest*
-  ac_cv_func_vfork_works=no
-fi
-rm -fr conftest*
-
-echo "$ac_t""$ac_cv_func_vfork_works" 1>&6
-if test $ac_cv_func_vfork_works = no; then
-  { test "$extra_verbose" = "yes" && cat << \EOF
-    Defining vfork = fork
-EOF
-cat >> confdefs.h <<\EOF
-#define vfork fork
-EOF
-}
-
-fi
-
-
 echo $ac_n "checking for working strcoll""... $ac_c" 1>&6
-echo "configure:12322: checking for working strcoll" >&5
-
-cat > conftest.$ac_ext <<EOF
-#line 12325 "configure"
+echo "configure:12015: checking for working strcoll" >&5
+
+cat > conftest.$ac_ext <<EOF
+#line 12018 "configure"
 #include "confdefs.h"
 #include <string.h>
 main ()
@@ -12331,7 +12024,7 @@
 	strcoll ("123", "456") >= 0);
 }
 EOF
-if { (eval echo configure:12335: \"$ac_link\") 1>&5; (eval $ac_link) 2>&5; } && test -s conftest && (./conftest; exit $?) 2>&5
+if { (eval echo configure:12028: \"$ac_link\") 1>&5; (eval $ac_link) 2>&5; } && test -s conftest && (./conftest; exit $?) 2>&5
 then
   ac_cv_func_strcoll_works=yes
 else
@@ -12359,10 +12052,10 @@
 for ac_func in getpgrp
 do
 echo $ac_n "checking for $ac_func""... $ac_c" 1>&6
-echo "configure:12363: checking for $ac_func" >&5
-
-cat > conftest.$ac_ext <<EOF
-#line 12366 "configure"
+echo "configure:12056: checking for $ac_func" >&5
+
+cat > conftest.$ac_ext <<EOF
+#line 12059 "configure"
 #include "confdefs.h"
 /* System header to define __stub macros and hopefully few prototypes,
     which can conflict with char $ac_func(); below.  */
@@ -12385,7 +12078,7 @@
 
 ; return 0; }
 EOF
-if { (eval echo configure:12389: \"$ac_link\") 1>&5; (eval $ac_link) 2>&5; } && test -s conftest${ac_exeext}; then
+if { (eval echo configure:12082: \"$ac_link\") 1>&5; (eval $ac_link) 2>&5; } && test -s conftest${ac_exeext}; then
   rm -rf conftest*
   eval "ac_cv_func_$ac_func=yes"
 else
@@ -12413,10 +12106,10 @@
 done
 
 echo $ac_n "checking whether getpgrp takes no argument""... $ac_c" 1>&6
-echo "configure:12417: checking whether getpgrp takes no argument" >&5
-
-cat > conftest.$ac_ext <<EOF
-#line 12420 "configure"
+echo "configure:12110: checking whether getpgrp takes no argument" >&5
+
+cat > conftest.$ac_ext <<EOF
+#line 12113 "configure"
 #include "confdefs.h"
 
 /*
@@ -12471,7 +12164,7 @@
 }
 
 EOF
-if { (eval echo configure:12475: \"$ac_link\") 1>&5; (eval $ac_link) 2>&5; } && test -s conftest && (./conftest; exit $?) 2>&5
+if { (eval echo configure:12168: \"$ac_link\") 1>&5; (eval $ac_link) 2>&5; } && test -s conftest && (./conftest; exit $?) 2>&5
 then
   ac_cv_func_getpgrp_void=yes
 else
@@ -12498,10 +12191,10 @@
 
 
 echo $ac_n "checking for working mmap""... $ac_c" 1>&6
-echo "configure:12502: checking for working mmap" >&5
+echo "configure:12195: checking for working mmap" >&5
 case "$opsys" in ultrix* ) have_mmap=no ;; *)
 cat > conftest.$ac_ext <<EOF
-#line 12505 "configure"
+#line 12198 "configure"
 #include "confdefs.h"
 #include <stdio.h>
 #include <unistd.h>
@@ -12534,7 +12227,7 @@
   return 1;
 }
 EOF
-if { (eval echo configure:12538: \"$ac_link\") 1>&5; (eval $ac_link) 2>&5; } && test -s conftest && (./conftest; exit $?) 2>&5
+if { (eval echo configure:12231: \"$ac_link\") 1>&5; (eval $ac_link) 2>&5; } && test -s conftest && (./conftest; exit $?) 2>&5
 then
   have_mmap=yes
 else
@@ -12563,9 +12256,9 @@
 if test "$rel_alloc $have_mmap" = "default yes"; then
   if test "$doug_lea_malloc" = "yes"; then
         echo $ac_n "checking for M_MMAP_THRESHOLD""... $ac_c" 1>&6
-echo "configure:12567: checking for M_MMAP_THRESHOLD" >&5
+echo "configure:12260: checking for M_MMAP_THRESHOLD" >&5
     cat > conftest.$ac_ext <<EOF
-#line 12569 "configure"
+#line 12262 "configure"
 #include "confdefs.h"
 #include <malloc.h>
 int main() {
@@ -12577,7 +12270,7 @@
 
 ; return 0; }
 EOF
-if { (eval echo configure:12581: \"$ac_compile\") 1>&5; (eval $ac_compile) 2>&5; }; then
+if { (eval echo configure:12274: \"$ac_compile\") 1>&5; (eval $ac_compile) 2>&5; }; then
   rm -rf conftest*
   rel_alloc=no; echo "$ac_t""yes" 1>&6;
 else
@@ -12602,15 +12295,15 @@
 
 ac_safe=`echo "termios.h" | sed 'y%./+-%__p_%'`
 echo $ac_n "checking for termios.h""... $ac_c" 1>&6
-echo "configure:12606: checking for termios.h" >&5
-
-cat > conftest.$ac_ext <<EOF
-#line 12609 "configure"
+echo "configure:12299: checking for termios.h" >&5
+
+cat > conftest.$ac_ext <<EOF
+#line 12302 "configure"
 #include "confdefs.h"
 #include <termios.h>
 EOF
 ac_try="$ac_cpp conftest.$ac_ext >/dev/null 2>conftest.out"
-{ (eval echo configure:12614: \"$ac_try\") 1>&5; (eval $ac_try) 2>&5; }
+{ (eval echo configure:12307: \"$ac_try\") 1>&5; (eval $ac_try) 2>&5; }
 ac_err=`grep -v '^ *+' conftest.out | grep -v "^conftest.${ac_ext}\$"`
 if test -z "$ac_err"; then
   rm -rf conftest*
@@ -12653,15 +12346,15 @@
   echo "$ac_t""no" 1>&6
 ac_safe=`echo "termio.h" | sed 'y%./+-%__p_%'`
 echo $ac_n "checking for termio.h""... $ac_c" 1>&6
-echo "configure:12657: checking for termio.h" >&5
-
-cat > conftest.$ac_ext <<EOF
-#line 12660 "configure"
+echo "configure:12350: checking for termio.h" >&5
+
+cat > conftest.$ac_ext <<EOF
+#line 12353 "configure"
 #include "confdefs.h"
 #include <termio.h>
 EOF
 ac_try="$ac_cpp conftest.$ac_ext >/dev/null 2>conftest.out"
-{ (eval echo configure:12665: \"$ac_try\") 1>&5; (eval $ac_try) 2>&5; }
+{ (eval echo configure:12358: \"$ac_try\") 1>&5; (eval $ac_try) 2>&5; }
 ac_err=`grep -v '^ *+' conftest.out | grep -v "^conftest.${ac_ext}\$"`
 if test -z "$ac_err"; then
   rm -rf conftest*
@@ -12693,10 +12386,10 @@
 
 
 echo $ac_n "checking for socket""... $ac_c" 1>&6
-echo "configure:12697: checking for socket" >&5
-
-cat > conftest.$ac_ext <<EOF
-#line 12700 "configure"
+echo "configure:12390: checking for socket" >&5
+
+cat > conftest.$ac_ext <<EOF
+#line 12393 "configure"
 #include "confdefs.h"
 /* System header to define __stub macros and hopefully few prototypes,
     which can conflict with char socket(); below.  */
@@ -12719,7 +12412,7 @@
 
 ; return 0; }
 EOF
-if { (eval echo configure:12723: \"$ac_link\") 1>&5; (eval $ac_link) 2>&5; } && test -s conftest${ac_exeext}; then
+if { (eval echo configure:12416: \"$ac_link\") 1>&5; (eval $ac_link) 2>&5; } && test -s conftest${ac_exeext}; then
   rm -rf conftest*
   eval "ac_cv_func_socket=yes"
 else
@@ -12734,15 +12427,15 @@
   echo "$ac_t""yes" 1>&6
   ac_safe=`echo "netinet/in.h" | sed 'y%./+-%__p_%'`
 echo $ac_n "checking for netinet/in.h""... $ac_c" 1>&6
-echo "configure:12738: checking for netinet/in.h" >&5
-
-cat > conftest.$ac_ext <<EOF
-#line 12741 "configure"
+echo "configure:12431: checking for netinet/in.h" >&5
+
+cat > conftest.$ac_ext <<EOF
+#line 12434 "configure"
 #include "confdefs.h"
 #include <netinet/in.h>
 EOF
 ac_try="$ac_cpp conftest.$ac_ext >/dev/null 2>conftest.out"
-{ (eval echo configure:12746: \"$ac_try\") 1>&5; (eval $ac_try) 2>&5; }
+{ (eval echo configure:12439: \"$ac_try\") 1>&5; (eval $ac_try) 2>&5; }
 ac_err=`grep -v '^ *+' conftest.out | grep -v "^conftest.${ac_ext}\$"`
 if test -z "$ac_err"; then
   rm -rf conftest*
@@ -12759,15 +12452,15 @@
   echo "$ac_t""yes" 1>&6
   ac_safe=`echo "arpa/inet.h" | sed 'y%./+-%__p_%'`
 echo $ac_n "checking for arpa/inet.h""... $ac_c" 1>&6
-echo "configure:12763: checking for arpa/inet.h" >&5
-
-cat > conftest.$ac_ext <<EOF
-#line 12766 "configure"
+echo "configure:12456: checking for arpa/inet.h" >&5
+
+cat > conftest.$ac_ext <<EOF
+#line 12459 "configure"
 #include "confdefs.h"
 #include <arpa/inet.h>
 EOF
 ac_try="$ac_cpp conftest.$ac_ext >/dev/null 2>conftest.out"
-{ (eval echo configure:12771: \"$ac_try\") 1>&5; (eval $ac_try) 2>&5; }
+{ (eval echo configure:12464: \"$ac_try\") 1>&5; (eval $ac_try) 2>&5; }
 ac_err=`grep -v '^ *+' conftest.out | grep -v "^conftest.${ac_ext}\$"`
 if test -z "$ac_err"; then
   rm -rf conftest*
@@ -12792,9 +12485,9 @@
 }
 
       echo $ac_n "checking "for sun_len member in struct sockaddr_un"""... $ac_c" 1>&6
-echo "configure:12796: checking "for sun_len member in struct sockaddr_un"" >&5
+echo "configure:12489: checking "for sun_len member in struct sockaddr_un"" >&5
       cat > conftest.$ac_ext <<EOF
-#line 12798 "configure"
+#line 12491 "configure"
 #include "confdefs.h"
 
 #include <sys/types.h>
@@ -12805,7 +12498,7 @@
 static struct sockaddr_un x; x.sun_len = 1;
 ; return 0; }
 EOF
-if { (eval echo configure:12809: \"$ac_link\") 1>&5; (eval $ac_link) 2>&5; } && test -s conftest${ac_exeext}; then
+if { (eval echo configure:12502: \"$ac_link\") 1>&5; (eval $ac_link) 2>&5; } && test -s conftest${ac_exeext}; then
   rm -rf conftest*
   echo "$ac_t""yes" 1>&6; { test "$extra_verbose" = "yes" && cat << \EOF
     Defining HAVE_SOCKADDR_SUN_LEN
@@ -12823,9 +12516,9 @@
 fi
 rm -f conftest*
       echo $ac_n "checking "for ip_mreq struct in netinet/in.h"""... $ac_c" 1>&6
-echo "configure:12827: checking "for ip_mreq struct in netinet/in.h"" >&5
+echo "configure:12520: checking "for ip_mreq struct in netinet/in.h"" >&5
       cat > conftest.$ac_ext <<EOF
-#line 12829 "configure"
+#line 12522 "configure"
 #include "confdefs.h"
 
 #include <sys/types.h>
@@ -12835,7 +12528,7 @@
 static struct ip_mreq x;
 ; return 0; }
 EOF
-if { (eval echo configure:12839: \"$ac_link\") 1>&5; (eval $ac_link) 2>&5; } && test -s conftest${ac_exeext}; then
+if { (eval echo configure:12532: \"$ac_link\") 1>&5; (eval $ac_link) 2>&5; } && test -s conftest${ac_exeext}; then
   rm -rf conftest*
   echo "$ac_t""yes" 1>&6; { test "$extra_verbose" = "yes" && cat << \EOF
     Defining HAVE_MULTICAST
@@ -12866,10 +12559,10 @@
 
 
 echo $ac_n "checking for msgget""... $ac_c" 1>&6
-echo "configure:12870: checking for msgget" >&5
-
-cat > conftest.$ac_ext <<EOF
-#line 12873 "configure"
+echo "configure:12563: checking for msgget" >&5
+
+cat > conftest.$ac_ext <<EOF
+#line 12566 "configure"
 #include "confdefs.h"
 /* System header to define __stub macros and hopefully few prototypes,
     which can conflict with char msgget(); below.  */
@@ -12892,7 +12585,7 @@
 
 ; return 0; }
 EOF
-if { (eval echo configure:12896: \"$ac_link\") 1>&5; (eval $ac_link) 2>&5; } && test -s conftest${ac_exeext}; then
+if { (eval echo configure:12589: \"$ac_link\") 1>&5; (eval $ac_link) 2>&5; } && test -s conftest${ac_exeext}; then
   rm -rf conftest*
   eval "ac_cv_func_msgget=yes"
 else
@@ -12907,15 +12600,15 @@
   echo "$ac_t""yes" 1>&6
   ac_safe=`echo "sys/ipc.h" | sed 'y%./+-%__p_%'`
 echo $ac_n "checking for sys/ipc.h""... $ac_c" 1>&6
-echo "configure:12911: checking for sys/ipc.h" >&5
-
-cat > conftest.$ac_ext <<EOF
-#line 12914 "configure"
+echo "configure:12604: checking for sys/ipc.h" >&5
+
+cat > conftest.$ac_ext <<EOF
+#line 12607 "configure"
 #include "confdefs.h"
 #include <sys/ipc.h>
 EOF
 ac_try="$ac_cpp conftest.$ac_ext >/dev/null 2>conftest.out"
-{ (eval echo configure:12919: \"$ac_try\") 1>&5; (eval $ac_try) 2>&5; }
+{ (eval echo configure:12612: \"$ac_try\") 1>&5; (eval $ac_try) 2>&5; }
 ac_err=`grep -v '^ *+' conftest.out | grep -v "^conftest.${ac_ext}\$"`
 if test -z "$ac_err"; then
   rm -rf conftest*
@@ -12932,15 +12625,15 @@
   echo "$ac_t""yes" 1>&6
   ac_safe=`echo "sys/msg.h" | sed 'y%./+-%__p_%'`
 echo $ac_n "checking for sys/msg.h""... $ac_c" 1>&6
-echo "configure:12936: checking for sys/msg.h" >&5
-
-cat > conftest.$ac_ext <<EOF
-#line 12939 "configure"
+echo "configure:12629: checking for sys/msg.h" >&5
+
+cat > conftest.$ac_ext <<EOF
+#line 12632 "configure"
 #include "confdefs.h"
 #include <sys/msg.h>
 EOF
 ac_try="$ac_cpp conftest.$ac_ext >/dev/null 2>conftest.out"
-{ (eval echo configure:12944: \"$ac_try\") 1>&5; (eval $ac_try) 2>&5; }
+{ (eval echo configure:12637: \"$ac_try\") 1>&5; (eval $ac_try) 2>&5; }
 ac_err=`grep -v '^ *+' conftest.out | grep -v "^conftest.${ac_ext}\$"`
 if test -z "$ac_err"; then
   rm -rf conftest*
@@ -12978,15 +12671,15 @@
 
 ac_safe=`echo "dirent.h" | sed 'y%./+-%__p_%'`
 echo $ac_n "checking for dirent.h""... $ac_c" 1>&6
-echo "configure:12982: checking for dirent.h" >&5
-
-cat > conftest.$ac_ext <<EOF
-#line 12985 "configure"
+echo "configure:12675: checking for dirent.h" >&5
+
+cat > conftest.$ac_ext <<EOF
+#line 12678 "configure"
 #include "confdefs.h"
 #include <dirent.h>
 EOF
 ac_try="$ac_cpp conftest.$ac_ext >/dev/null 2>conftest.out"
-{ (eval echo configure:12990: \"$ac_try\") 1>&5; (eval $ac_try) 2>&5; }
+{ (eval echo configure:12683: \"$ac_try\") 1>&5; (eval $ac_try) 2>&5; }
 ac_err=`grep -v '^ *+' conftest.out | grep -v "^conftest.${ac_ext}\$"`
 if test -z "$ac_err"; then
   rm -rf conftest*
@@ -13013,15 +12706,15 @@
   echo "$ac_t""no" 1>&6
 ac_safe=`echo "sys/dir.h" | sed 'y%./+-%__p_%'`
 echo $ac_n "checking for sys/dir.h""... $ac_c" 1>&6
-echo "configure:13017: checking for sys/dir.h" >&5
-
-cat > conftest.$ac_ext <<EOF
-#line 13020 "configure"
+echo "configure:12710: checking for sys/dir.h" >&5
+
+cat > conftest.$ac_ext <<EOF
+#line 12713 "configure"
 #include "confdefs.h"
 #include <sys/dir.h>
 EOF
 ac_try="$ac_cpp conftest.$ac_ext >/dev/null 2>conftest.out"
-{ (eval echo configure:13025: \"$ac_try\") 1>&5; (eval $ac_try) 2>&5; }
+{ (eval echo configure:12718: \"$ac_try\") 1>&5; (eval $ac_try) 2>&5; }
 ac_err=`grep -v '^ *+' conftest.out | grep -v "^conftest.${ac_ext}\$"`
 if test -z "$ac_err"; then
   rm -rf conftest*
@@ -13054,15 +12747,15 @@
 
 ac_safe=`echo "nlist.h" | sed 'y%./+-%__p_%'`
 echo $ac_n "checking for nlist.h""... $ac_c" 1>&6
-echo "configure:13058: checking for nlist.h" >&5
-
-cat > conftest.$ac_ext <<EOF
-#line 13061 "configure"
+echo "configure:12751: checking for nlist.h" >&5
+
+cat > conftest.$ac_ext <<EOF
+#line 12754 "configure"
 #include "confdefs.h"
 #include <nlist.h>
 EOF
 ac_try="$ac_cpp conftest.$ac_ext >/dev/null 2>conftest.out"
-{ (eval echo configure:13066: \"$ac_try\") 1>&5; (eval $ac_try) 2>&5; }
+{ (eval echo configure:12759: \"$ac_try\") 1>&5; (eval $ac_try) 2>&5; }
 ac_err=`grep -v '^ *+' conftest.out | grep -v "^conftest.${ac_ext}\$"`
 if test -z "$ac_err"; then
   rm -rf conftest*
@@ -13092,22 +12785,22 @@
 
 
 echo "checking "for sound support"" 1>&6
-echo "configure:13096: checking "for sound support"" >&5
+echo "configure:12789: checking "for sound support"" >&5
 test -z "$with_native_sound" -a -n "$native_sound_lib" && with_native_sound=yes
 
 if test "$with_native_sound" != "no"; then
     if test -n "$native_sound_lib"; then
     ac_safe=`echo "multimedia/audio_device.h" | sed 'y%./+-%__p_%'`
 echo $ac_n "checking for multimedia/audio_device.h""... $ac_c" 1>&6
-echo "configure:13103: checking for multimedia/audio_device.h" >&5
-
-cat > conftest.$ac_ext <<EOF
-#line 13106 "configure"
+echo "configure:12796: checking for multimedia/audio_device.h" >&5
+
+cat > conftest.$ac_ext <<EOF
+#line 12799 "configure"
 #include "confdefs.h"
 #include <multimedia/audio_device.h>
 EOF
 ac_try="$ac_cpp conftest.$ac_ext >/dev/null 2>conftest.out"
-{ (eval echo configure:13111: \"$ac_try\") 1>&5; (eval $ac_try) 2>&5; }
+{ (eval echo configure:12804: \"$ac_try\") 1>&5; (eval $ac_try) 2>&5; }
 ac_err=`grep -v '^ *+' conftest.out | grep -v "^conftest.${ac_ext}\$"`
 if test -z "$ac_err"; then
   rm -rf conftest*
@@ -13155,12 +12848,12 @@
       if test -z "$native_sound_lib"; then
         
 echo $ac_n "checking for ALopenport in -laudio""... $ac_c" 1>&6
-echo "configure:13159: checking for ALopenport in -laudio" >&5
+echo "configure:12852: checking for ALopenport in -laudio" >&5
 ac_lib_var=`echo audio'_'ALopenport | sed 'y%./+-%__p_%'`
 
 xe_check_libs=" -laudio "
 cat > conftest.$ac_ext <<EOF
-#line 13164 "configure"
+#line 12857 "configure"
 #include "confdefs.h"
 /* Override any gcc2 internal prototype to avoid an error.  */
 /* We use char because int might match the return type of a gcc2
@@ -13171,7 +12864,7 @@
 ALopenport()
 ; return 0; }
 EOF
-if { (eval echo configure:13175: \"$ac_link\") 1>&5; (eval $ac_link) 2>&5; } && test -s conftest${ac_exeext}; then
+if { (eval echo configure:12868: \"$ac_link\") 1>&5; (eval $ac_link) 2>&5; } && test -s conftest${ac_exeext}; then
   rm -rf conftest*
   eval "ac_cv_lib_$ac_lib_var=yes"
 else
@@ -13202,12 +12895,12 @@
       if test -z "$native_sound_lib"; then
 	
 echo $ac_n "checking for AOpenAudio in -lAlib""... $ac_c" 1>&6
-echo "configure:13206: checking for AOpenAudio in -lAlib" >&5
+echo "configure:12899: checking for AOpenAudio in -lAlib" >&5
 ac_lib_var=`echo Alib'_'AOpenAudio | sed 'y%./+-%__p_%'`
 
 xe_check_libs=" -lAlib "
 cat > conftest.$ac_ext <<EOF
-#line 13211 "configure"
+#line 12904 "configure"
 #include "confdefs.h"
 /* Override any gcc2 internal prototype to avoid an error.  */
 /* We use char because int might match the return type of a gcc2
@@ -13218,7 +12911,7 @@
 AOpenAudio()
 ; return 0; }
 EOF
-if { (eval echo configure:13222: \"$ac_link\") 1>&5; (eval $ac_link) 2>&5; } && test -s conftest${ac_exeext}; then
+if { (eval echo configure:12915: \"$ac_link\") 1>&5; (eval $ac_link) 2>&5; } && test -s conftest${ac_exeext}; then
   rm -rf conftest*
   eval "ac_cv_lib_$ac_lib_var=yes"
 else
@@ -13266,15 +12959,15 @@
     for dir in "machine" "sys" "linux"; do
       ac_safe=`echo "${dir}/soundcard.h" | sed 'y%./+-%__p_%'`
 echo $ac_n "checking for ${dir}/soundcard.h""... $ac_c" 1>&6
-echo "configure:13270: checking for ${dir}/soundcard.h" >&5
-
-cat > conftest.$ac_ext <<EOF
-#line 13273 "configure"
+echo "configure:12963: checking for ${dir}/soundcard.h" >&5
+
+cat > conftest.$ac_ext <<EOF
+#line 12966 "configure"
 #include "confdefs.h"
 #include <${dir}/soundcard.h>
 EOF
 ac_try="$ac_cpp conftest.$ac_ext >/dev/null 2>conftest.out"
-{ (eval echo configure:13278: \"$ac_try\") 1>&5; (eval $ac_try) 2>&5; }
+{ (eval echo configure:12971: \"$ac_try\") 1>&5; (eval $ac_try) 2>&5; }
 ac_err=`grep -v '^ *+' conftest.out | grep -v "^conftest.${ac_ext}\$"`
 if test -z "$ac_err"; then
   rm -rf conftest*
@@ -13328,15 +13021,15 @@
 if test "$with_nas_sound" != "no"; then
   ac_safe=`echo "audio/audiolib.h" | sed 'y%./+-%__p_%'`
 echo $ac_n "checking for audio/audiolib.h""... $ac_c" 1>&6
-echo "configure:13332: checking for audio/audiolib.h" >&5
-
-cat > conftest.$ac_ext <<EOF
-#line 13335 "configure"
+echo "configure:13025: checking for audio/audiolib.h" >&5
+
+cat > conftest.$ac_ext <<EOF
+#line 13028 "configure"
 #include "confdefs.h"
 #include <audio/audiolib.h>
 EOF
 ac_try="$ac_cpp conftest.$ac_ext >/dev/null 2>conftest.out"
-{ (eval echo configure:13340: \"$ac_try\") 1>&5; (eval $ac_try) 2>&5; }
+{ (eval echo configure:13033: \"$ac_try\") 1>&5; (eval $ac_try) 2>&5; }
 ac_err=`grep -v '^ *+' conftest.out | grep -v "^conftest.${ac_ext}\$"`
 if test -z "$ac_err"; then
   rm -rf conftest*
@@ -13354,12 +13047,12 @@
   
     
 echo $ac_n "checking for AuOpenServer in -laudio""... $ac_c" 1>&6
-echo "configure:13358: checking for AuOpenServer in -laudio" >&5
+echo "configure:13051: checking for AuOpenServer in -laudio" >&5
 ac_lib_var=`echo audio'_'AuOpenServer | sed 'y%./+-%__p_%'`
 
 xe_check_libs=" -laudio "
 cat > conftest.$ac_ext <<EOF
-#line 13363 "configure"
+#line 13056 "configure"
 #include "confdefs.h"
 /* Override any gcc2 internal prototype to avoid an error.  */
 /* We use char because int might match the return type of a gcc2
@@ -13370,7 +13063,7 @@
 AuOpenServer()
 ; return 0; }
 EOF
-if { (eval echo configure:13374: \"$ac_link\") 1>&5; (eval $ac_link) 2>&5; } && test -s conftest${ac_exeext}; then
+if { (eval echo configure:13067: \"$ac_link\") 1>&5; (eval $ac_link) 2>&5; } && test -s conftest${ac_exeext}; then
   rm -rf conftest*
   eval "ac_cv_lib_$ac_lib_var=yes"
 else
@@ -13409,7 +13102,7 @@
  fi
     libs_x="-laudio $libs_x" &&  if test "$extra_verbose" = "yes"; then echo "    Prepending \"-laudio\" to \$libs_x"; fi
             cat > conftest.$ac_ext <<EOF
-#line 13413 "configure"
+#line 13106 "configure"
 #include "confdefs.h"
 #include <audio/Xtutil.h>
 EOF
@@ -13440,7 +13133,7 @@
   # Extract the first word of "esd-config", so it can be a program name with args.
 set dummy esd-config; ac_word=$2
 echo $ac_n "checking for $ac_word""... $ac_c" 1>&6
-echo "configure:13444: checking for $ac_word" >&5
+echo "configure:13137: checking for $ac_word" >&5
 
 if test -n "$have_esd_config"; then
   ac_cv_prog_have_esd_config="$have_esd_config" # Let the user override the test.
@@ -13469,10 +13162,10 @@
     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
     LIBS="`esd-config --libs` $LIBS" &&  if test "$extra_verbose" = "yes"; then echo "    Prepending \"`esd-config --libs`\" to \$LIBS"; fi
     echo $ac_n "checking for esd_play_stream""... $ac_c" 1>&6
-echo "configure:13473: checking for esd_play_stream" >&5
-
-cat > conftest.$ac_ext <<EOF
-#line 13476 "configure"
+echo "configure:13166: checking for esd_play_stream" >&5
+
+cat > conftest.$ac_ext <<EOF
+#line 13169 "configure"
 #include "confdefs.h"
 /* System header to define __stub macros and hopefully few prototypes,
     which can conflict with char esd_play_stream(); below.  */
@@ -13495,7 +13188,7 @@
 
 ; return 0; }
 EOF
-if { (eval echo configure:13499: \"$ac_link\") 1>&5; (eval $ac_link) 2>&5; } && test -s conftest${ac_exeext}; then
+if { (eval echo configure:13192: \"$ac_link\") 1>&5; (eval $ac_link) 2>&5; } && test -s conftest${ac_exeext}; then
   rm -rf conftest*
   eval "ac_cv_func_esd_play_stream=yes"
 else
@@ -13546,7 +13239,7 @@
 
 if test "$with_tty" = "yes"  ; then
   echo "checking for TTY-related features" 1>&6
-echo "configure:13550: checking for TTY-related features" >&5
+echo "configure:13243: checking for TTY-related features" >&5
   { test "$extra_verbose" = "yes" && cat << \EOF
     Defining HAVE_TTY
 EOF
@@ -13555,19 +13248,16 @@
 EOF
 }
 
-  extra_objs="$extra_objs console-tty.o device-tty.o event-tty.o frame-tty.o objects-tty.o redisplay-tty.o cm.o" &&  if test "$extra_verbose" = "yes"; then
-   echo "    xemacs will be linked with \"console-tty.o device-tty.o event-tty.o frame-tty.o objects-tty.o redisplay-tty.o cm.o\""
- fi
 
     if test -z "$with_ncurses"; then
     
 echo $ac_n "checking for tgetent in -lncurses""... $ac_c" 1>&6
-echo "configure:13566: checking for tgetent in -lncurses" >&5
+echo "configure:13256: checking for tgetent in -lncurses" >&5
 ac_lib_var=`echo ncurses'_'tgetent | sed 'y%./+-%__p_%'`
 
 xe_check_libs=" -lncurses "
 cat > conftest.$ac_ext <<EOF
-#line 13571 "configure"
+#line 13261 "configure"
 #include "confdefs.h"
 /* Override any gcc2 internal prototype to avoid an error.  */
 /* We use char because int might match the return type of a gcc2
@@ -13578,7 +13268,7 @@
 tgetent()
 ; return 0; }
 EOF
-if { (eval echo configure:13582: \"$ac_link\") 1>&5; (eval $ac_link) 2>&5; } && test -s conftest${ac_exeext}; then
+if { (eval echo configure:13272: \"$ac_link\") 1>&5; (eval $ac_link) 2>&5; } && test -s conftest${ac_exeext}; then
   rm -rf conftest*
   eval "ac_cv_lib_$ac_lib_var=yes"
 else
@@ -13611,15 +13301,15 @@
 
     ac_safe=`echo "ncurses/curses.h" | sed 'y%./+-%__p_%'`
 echo $ac_n "checking for ncurses/curses.h""... $ac_c" 1>&6
-echo "configure:13615: checking for ncurses/curses.h" >&5
-
-cat > conftest.$ac_ext <<EOF
-#line 13618 "configure"
+echo "configure:13305: checking for ncurses/curses.h" >&5
+
+cat > conftest.$ac_ext <<EOF
+#line 13308 "configure"
 #include "confdefs.h"
 #include <ncurses/curses.h>
 EOF
 ac_try="$ac_cpp conftest.$ac_ext >/dev/null 2>conftest.out"
-{ (eval echo configure:13623: \"$ac_try\") 1>&5; (eval $ac_try) 2>&5; }
+{ (eval echo configure:13313: \"$ac_try\") 1>&5; (eval $ac_try) 2>&5; }
 ac_err=`grep -v '^ *+' conftest.out | grep -v "^conftest.${ac_ext}\$"`
 if test -z "$ac_err"; then
   rm -rf conftest*
@@ -13641,15 +13331,15 @@
 
     ac_safe=`echo "ncurses/term.h" | sed 'y%./+-%__p_%'`
 echo $ac_n "checking for ncurses/term.h""... $ac_c" 1>&6
-echo "configure:13645: checking for ncurses/term.h" >&5
-
-cat > conftest.$ac_ext <<EOF
-#line 13648 "configure"
+echo "configure:13335: checking for ncurses/term.h" >&5
+
+cat > conftest.$ac_ext <<EOF
+#line 13338 "configure"
 #include "confdefs.h"
 #include <ncurses/term.h>
 EOF
 ac_try="$ac_cpp conftest.$ac_ext >/dev/null 2>conftest.out"
-{ (eval echo configure:13653: \"$ac_try\") 1>&5; (eval $ac_try) 2>&5; }
+{ (eval echo configure:13343: \"$ac_try\") 1>&5; (eval $ac_try) 2>&5; }
 ac_err=`grep -v '^ *+' conftest.out | grep -v "^conftest.${ac_ext}\$"`
 if test -z "$ac_err"; then
   rm -rf conftest*
@@ -13679,15 +13369,15 @@
       c_switch_site="$c_switch_site -I/usr/include/ncurses"
       ac_safe=`echo "ncurses/curses.h" | sed 'y%./+-%__p_%'`
 echo $ac_n "checking for ncurses/curses.h""... $ac_c" 1>&6
-echo "configure:13683: checking for ncurses/curses.h" >&5
-
-cat > conftest.$ac_ext <<EOF
-#line 13686 "configure"
+echo "configure:13373: checking for ncurses/curses.h" >&5
+
+cat > conftest.$ac_ext <<EOF
+#line 13376 "configure"
 #include "confdefs.h"
 #include <ncurses/curses.h>
 EOF
 ac_try="$ac_cpp conftest.$ac_ext >/dev/null 2>conftest.out"
-{ (eval echo configure:13691: \"$ac_try\") 1>&5; (eval $ac_try) 2>&5; }
+{ (eval echo configure:13381: \"$ac_try\") 1>&5; (eval $ac_try) 2>&5; }
 ac_err=`grep -v '^ *+' conftest.out | grep -v "^conftest.${ac_ext}\$"`
 if test -z "$ac_err"; then
   rm -rf conftest*
@@ -13722,12 +13412,12 @@
 	for lib in curses termlib termcap; do
 	  
 echo $ac_n "checking for tgetent in -l$lib""... $ac_c" 1>&6
-echo "configure:13726: checking for tgetent in -l$lib" >&5
+echo "configure:13416: checking for tgetent in -l$lib" >&5
 ac_lib_var=`echo $lib'_'tgetent | sed 'y%./+-%__p_%'`
 
 xe_check_libs=" -l$lib "
 cat > conftest.$ac_ext <<EOF
-#line 13731 "configure"
+#line 13421 "configure"
 #include "confdefs.h"
 /* Override any gcc2 internal prototype to avoid an error.  */
 /* We use char because int might match the return type of a gcc2
@@ -13738,7 +13428,7 @@
 tgetent()
 ; return 0; }
 EOF
-if { (eval echo configure:13742: \"$ac_link\") 1>&5; (eval $ac_link) 2>&5; } && test -s conftest${ac_exeext}; then
+if { (eval echo configure:13432: \"$ac_link\") 1>&5; (eval $ac_link) 2>&5; } && test -s conftest${ac_exeext}; then
   rm -rf conftest*
   eval "ac_cv_lib_$ac_lib_var=yes"
 else
@@ -13769,12 +13459,12 @@
       else
 	
 echo $ac_n "checking for tgetent in -lcurses""... $ac_c" 1>&6
-echo "configure:13773: checking for tgetent in -lcurses" >&5
+echo "configure:13463: checking for tgetent in -lcurses" >&5
 ac_lib_var=`echo curses'_'tgetent | sed 'y%./+-%__p_%'`
 
 xe_check_libs=" -lcurses "
 cat > conftest.$ac_ext <<EOF
-#line 13778 "configure"
+#line 13468 "configure"
 #include "confdefs.h"
 /* Override any gcc2 internal prototype to avoid an error.  */
 /* We use char because int might match the return type of a gcc2
@@ -13785,7 +13475,7 @@
 tgetent()
 ; return 0; }
 EOF
-if { (eval echo configure:13789: \"$ac_link\") 1>&5; (eval $ac_link) 2>&5; } && test -s conftest${ac_exeext}; then
+if { (eval echo configure:13479: \"$ac_link\") 1>&5; (eval $ac_link) 2>&5; } && test -s conftest${ac_exeext}; then
   rm -rf conftest*
   eval "ac_cv_lib_$ac_lib_var=yes"
 else
@@ -13803,12 +13493,12 @@
 else
   echo "$ac_t""no" 1>&6
 echo $ac_n "checking for tgetent in -ltermcap""... $ac_c" 1>&6
-echo "configure:13807: checking for tgetent in -ltermcap" >&5
+echo "configure:13497: checking for tgetent in -ltermcap" >&5
 ac_lib_var=`echo termcap'_'tgetent | sed 'y%./+-%__p_%'`
 
 xe_check_libs=" -ltermcap "
 cat > conftest.$ac_ext <<EOF
-#line 13812 "configure"
+#line 13502 "configure"
 #include "confdefs.h"
 /* Override any gcc2 internal prototype to avoid an error.  */
 /* We use char because int might match the return type of a gcc2
@@ -13819,7 +13509,7 @@
 tgetent()
 ; return 0; }
 EOF
-if { (eval echo configure:13823: \"$ac_link\") 1>&5; (eval $ac_link) 2>&5; } && test -s conftest${ac_exeext}; then
+if { (eval echo configure:13513: \"$ac_link\") 1>&5; (eval $ac_link) 2>&5; } && test -s conftest${ac_exeext}; then
   rm -rf conftest*
   eval "ac_cv_lib_$ac_lib_var=yes"
 else
@@ -13867,15 +13557,15 @@
 
     test -z "$with_gpm" && { ac_safe=`echo "gpm.h" | sed 'y%./+-%__p_%'`
 echo $ac_n "checking for gpm.h""... $ac_c" 1>&6
-echo "configure:13871: checking for gpm.h" >&5
-
-cat > conftest.$ac_ext <<EOF
-#line 13874 "configure"
+echo "configure:13561: checking for gpm.h" >&5
+
+cat > conftest.$ac_ext <<EOF
+#line 13564 "configure"
 #include "confdefs.h"
 #include <gpm.h>
 EOF
 ac_try="$ac_cpp conftest.$ac_ext >/dev/null 2>conftest.out"
-{ (eval echo configure:13879: \"$ac_try\") 1>&5; (eval $ac_try) 2>&5; }
+{ (eval echo configure:13569: \"$ac_try\") 1>&5; (eval $ac_try) 2>&5; }
 ac_err=`grep -v '^ *+' conftest.out | grep -v "^conftest.${ac_ext}\$"`
 if test -z "$ac_err"; then
   rm -rf conftest*
@@ -13898,12 +13588,12 @@
  }
   test -z "$with_gpm" && { 
 echo $ac_n "checking for Gpm_Open in -lgpm""... $ac_c" 1>&6
-echo "configure:13902: checking for Gpm_Open in -lgpm" >&5
+echo "configure:13592: checking for Gpm_Open in -lgpm" >&5
 ac_lib_var=`echo gpm'_'Gpm_Open | sed 'y%./+-%__p_%'`
 
 xe_check_libs=" -lgpm "
 cat > conftest.$ac_ext <<EOF
-#line 13907 "configure"
+#line 13597 "configure"
 #include "confdefs.h"
 /* Override any gcc2 internal prototype to avoid an error.  */
 /* We use char because int might match the return type of a gcc2
@@ -13914,7 +13604,7 @@
 Gpm_Open()
 ; return 0; }
 EOF
-if { (eval echo configure:13918: \"$ac_link\") 1>&5; (eval $ac_link) 2>&5; } && test -s conftest${ac_exeext}; then
+if { (eval echo configure:13608: \"$ac_link\") 1>&5; (eval $ac_link) 2>&5; } && test -s conftest${ac_exeext}; then
   rm -rf conftest*
   eval "ac_cv_lib_$ac_lib_var=yes"
 else
@@ -13944,9 +13634,6 @@
 EOF
 }
 
-    extra_objs="$extra_objs gpmevent.o" &&  if test "$extra_verbose" = "yes"; then
-   echo "    xemacs will be linked with \"gpmevent.o\""
- fi
     LIBS="-lgpm $LIBS" &&  if test "$extra_verbose" = "yes"; then echo "    Prepending \"-lgpm\" to \$LIBS"; fi
   fi
 
@@ -13957,27 +13644,23 @@
     eval "with_${feature}=no"
   done
 fi 
-test "$with_x11" = "yes" -o "$with_tty" = "yes" -o "$need_event_unixoid" = "yes" && extra_objs="$extra_objs event-unixoid.o" &&  if test "$extra_verbose" = "yes"; then
-   echo "    xemacs will be linked with \"event-unixoid.o\""
- fi
-
 
 test "$with_database_gdbm $with_database_dbm $with_database_berkdb" \
   != "no no no" && echo "checking for database support" 1>&6
-echo "configure:13968: checking for database support" >&5
+echo "configure:13651: checking for database support" >&5
 
 if test "$with_database_gdbm $with_database_dbm" != "no no"; then
   ac_safe=`echo "ndbm.h" | sed 'y%./+-%__p_%'`
 echo $ac_n "checking for ndbm.h""... $ac_c" 1>&6
-echo "configure:13973: checking for ndbm.h" >&5
-
-cat > conftest.$ac_ext <<EOF
-#line 13976 "configure"
+echo "configure:13656: checking for ndbm.h" >&5
+
+cat > conftest.$ac_ext <<EOF
+#line 13659 "configure"
 #include "confdefs.h"
 #include <ndbm.h>
 EOF
 ac_try="$ac_cpp conftest.$ac_ext >/dev/null 2>conftest.out"
-{ (eval echo configure:13981: \"$ac_try\") 1>&5; (eval $ac_try) 2>&5; }
+{ (eval echo configure:13664: \"$ac_try\") 1>&5; (eval $ac_try) 2>&5; }
 ac_err=`grep -v '^ *+' conftest.out | grep -v "^conftest.${ac_ext}\$"`
 if test -z "$ac_err"; then
   rm -rf conftest*
@@ -14007,12 +13690,12 @@
 if test "$with_database_gdbm" != "no"; then
   
 echo $ac_n "checking for dbm_open in -lgdbm""... $ac_c" 1>&6
-echo "configure:14011: checking for dbm_open in -lgdbm" >&5
+echo "configure:13694: checking for dbm_open in -lgdbm" >&5
 ac_lib_var=`echo gdbm'_'dbm_open | sed 'y%./+-%__p_%'`
 
 xe_check_libs=" -lgdbm "
 cat > conftest.$ac_ext <<EOF
-#line 14016 "configure"
+#line 13699 "configure"
 #include "confdefs.h"
 /* Override any gcc2 internal prototype to avoid an error.  */
 /* We use char because int might match the return type of a gcc2
@@ -14023,7 +13706,7 @@
 dbm_open()
 ; return 0; }
 EOF
-if { (eval echo configure:14027: \"$ac_link\") 1>&5; (eval $ac_link) 2>&5; } && test -s conftest${ac_exeext}; then
+if { (eval echo configure:13710: \"$ac_link\") 1>&5; (eval $ac_link) 2>&5; } && test -s conftest${ac_exeext}; then
   rm -rf conftest*
   eval "ac_cv_lib_$ac_lib_var=yes"
 else
@@ -14051,10 +13734,10 @@
 
 if test "$with_database_dbm" != "no"; then
   echo $ac_n "checking for dbm_open""... $ac_c" 1>&6
-echo "configure:14055: checking for dbm_open" >&5
-
-cat > conftest.$ac_ext <<EOF
-#line 14058 "configure"
+echo "configure:13738: checking for dbm_open" >&5
+
+cat > conftest.$ac_ext <<EOF
+#line 13741 "configure"
 #include "confdefs.h"
 /* System header to define __stub macros and hopefully few prototypes,
     which can conflict with char dbm_open(); below.  */
@@ -14077,7 +13760,7 @@
 
 ; return 0; }
 EOF
-if { (eval echo configure:14081: \"$ac_link\") 1>&5; (eval $ac_link) 2>&5; } && test -s conftest${ac_exeext}; then
+if { (eval echo configure:13764: \"$ac_link\") 1>&5; (eval $ac_link) 2>&5; } && test -s conftest${ac_exeext}; then
   rm -rf conftest*
   eval "ac_cv_func_dbm_open=yes"
 else
@@ -14096,12 +13779,12 @@
 
     
 echo $ac_n "checking for dbm_open in -ldbm""... $ac_c" 1>&6
-echo "configure:14100: checking for dbm_open in -ldbm" >&5
+echo "configure:13783: checking for dbm_open in -ldbm" >&5
 ac_lib_var=`echo dbm'_'dbm_open | sed 'y%./+-%__p_%'`
 
 xe_check_libs=" -ldbm "
 cat > conftest.$ac_ext <<EOF
-#line 14105 "configure"
+#line 13788 "configure"
 #include "confdefs.h"
 /* Override any gcc2 internal prototype to avoid an error.  */
 /* We use char because int might match the return type of a gcc2
@@ -14112,7 +13795,7 @@
 dbm_open()
 ; return 0; }
 EOF
-if { (eval echo configure:14116: \"$ac_link\") 1>&5; (eval $ac_link) 2>&5; } && test -s conftest${ac_exeext}; then
+if { (eval echo configure:13799: \"$ac_link\") 1>&5; (eval $ac_link) 2>&5; } && test -s conftest${ac_exeext}; then
   rm -rf conftest*
   eval "ac_cv_lib_$ac_lib_var=yes"
 else
@@ -14153,10 +13836,10 @@
 
 if test "$with_database_berkdb" != "no"; then
   echo $ac_n "checking for Berkeley db.h""... $ac_c" 1>&6
-echo "configure:14157: checking for Berkeley db.h" >&5
+echo "configure:13840: checking for Berkeley db.h" >&5
   for header in "db/db.h" "db.h"; do
     cat > conftest.$ac_ext <<EOF
-#line 14160 "configure"
+#line 13843 "configure"
 #include "confdefs.h"
 
 #include <stdlib.h>
@@ -14178,7 +13861,7 @@
 
 ; return 0; }
 EOF
-if { (eval echo configure:14182: \"$ac_compile\") 1>&5; (eval $ac_compile) 2>&5; }; then
+if { (eval echo configure:13865: \"$ac_compile\") 1>&5; (eval $ac_compile) 2>&5; }; then
   rm -rf conftest*
   db_h_file="$header"; break
 else
@@ -14194,9 +13877,9 @@
 
   if test "$with_database_berkdb" != "no"; then
     echo $ac_n "checking for Berkeley DB version""... $ac_c" 1>&6
-echo "configure:14198: checking for Berkeley DB version" >&5
+echo "configure:13881: checking for Berkeley DB version" >&5
     cat > conftest.$ac_ext <<EOF
-#line 14200 "configure"
+#line 13883 "configure"
 #include "confdefs.h"
 #include <$db_h_file>
 #if DB_VERSION_MAJOR > 1
@@ -14208,7 +13891,7 @@
   egrep "yes" >/dev/null 2>&1; then
   rm -rf conftest*
   cat > conftest.$ac_ext <<EOF
-#line 14212 "configure"
+#line 13895 "configure"
 #include "confdefs.h"
 #include <$db_h_file>
 #if DB_VERSION_MAJOR > 2
@@ -14235,10 +13918,10 @@
 rm -f conftest*
 
     echo $ac_n "checking for $dbfunc""... $ac_c" 1>&6
-echo "configure:14239: checking for $dbfunc" >&5
-
-cat > conftest.$ac_ext <<EOF
-#line 14242 "configure"
+echo "configure:13922: checking for $dbfunc" >&5
+
+cat > conftest.$ac_ext <<EOF
+#line 13925 "configure"
 #include "confdefs.h"
 /* System header to define __stub macros and hopefully few prototypes,
     which can conflict with char $dbfunc(); below.  */
@@ -14261,7 +13944,7 @@
 
 ; return 0; }
 EOF
-if { (eval echo configure:14265: \"$ac_link\") 1>&5; (eval $ac_link) 2>&5; } && test -s conftest${ac_exeext}; then
+if { (eval echo configure:13948: \"$ac_link\") 1>&5; (eval $ac_link) 2>&5; } && test -s conftest${ac_exeext}; then
   rm -rf conftest*
   eval "ac_cv_func_$dbfunc=yes"
 else
@@ -14280,12 +13963,12 @@
 
     
 echo $ac_n "checking for $dbfunc in -ldb""... $ac_c" 1>&6
-echo "configure:14284: checking for $dbfunc in -ldb" >&5
+echo "configure:13967: checking for $dbfunc in -ldb" >&5
 ac_lib_var=`echo db'_'$dbfunc | sed 'y%./+-%__p_%'`
 
 xe_check_libs=" -ldb "
 cat > conftest.$ac_ext <<EOF
-#line 14289 "configure"
+#line 13972 "configure"
 #include "confdefs.h"
 /* Override any gcc2 internal prototype to avoid an error.  */
 /* We use char because int might match the return type of a gcc2
@@ -14296,7 +13979,7 @@
 $dbfunc()
 ; return 0; }
 EOF
-if { (eval echo configure:14300: \"$ac_link\") 1>&5; (eval $ac_link) 2>&5; } && test -s conftest${ac_exeext}; then
+if { (eval echo configure:13983: \"$ac_link\") 1>&5; (eval $ac_link) 2>&5; } && test -s conftest${ac_exeext}; then
   rm -rf conftest*
   eval "ac_cv_lib_$ac_lib_var=yes"
 else
@@ -14352,20 +14035,17 @@
 EOF
 }
 
-  extra_objs="$extra_objs database.o" &&  if test "$extra_verbose" = "yes"; then
-   echo "    xemacs will be linked with \"database.o\""
- fi
 fi
 
 if test "$with_socks" = "yes"; then
   
 echo $ac_n "checking for SOCKSinit in -lsocks""... $ac_c" 1>&6
-echo "configure:14364: checking for SOCKSinit in -lsocks" >&5
+echo "configure:14044: checking for SOCKSinit in -lsocks" >&5
 ac_lib_var=`echo socks'_'SOCKSinit | sed 'y%./+-%__p_%'`
 
 xe_check_libs=" -lsocks "
 cat > conftest.$ac_ext <<EOF
-#line 14369 "configure"
+#line 14049 "configure"
 #include "confdefs.h"
 /* Override any gcc2 internal prototype to avoid an error.  */
 /* We use char because int might match the return type of a gcc2
@@ -14376,7 +14056,7 @@
 SOCKSinit()
 ; return 0; }
 EOF
-if { (eval echo configure:14380: \"$ac_link\") 1>&5; (eval $ac_link) 2>&5; } && test -s conftest${ac_exeext}; then
+if { (eval echo configure:14060: \"$ac_link\") 1>&5; (eval $ac_link) 2>&5; } && test -s conftest${ac_exeext}; then
   rm -rf conftest*
   eval "ac_cv_lib_$ac_lib_var=yes"
 else
@@ -14431,22 +14111,22 @@
 
 if test "$with_modules" != "no"; then
   echo "checking for module support" 1>&6
-echo "configure:14435: checking for module support" >&5
+echo "configure:14115: checking for module support" >&5
 
     if test "$with_msw" = "yes"; then
     have_dl=yes;
   else
         ac_safe=`echo "dlfcn.h" | sed 'y%./+-%__p_%'`
 echo $ac_n "checking for dlfcn.h""... $ac_c" 1>&6
-echo "configure:14442: checking for dlfcn.h" >&5
-
-cat > conftest.$ac_ext <<EOF
-#line 14445 "configure"
+echo "configure:14122: checking for dlfcn.h" >&5
+
+cat > conftest.$ac_ext <<EOF
+#line 14125 "configure"
 #include "confdefs.h"
 #include <dlfcn.h>
 EOF
 ac_try="$ac_cpp conftest.$ac_ext >/dev/null 2>conftest.out"
-{ (eval echo configure:14450: \"$ac_try\") 1>&5; (eval $ac_try) 2>&5; }
+{ (eval echo configure:14130: \"$ac_try\") 1>&5; (eval $ac_try) 2>&5; }
 ac_err=`grep -v '^ *+' conftest.out | grep -v "^conftest.${ac_ext}\$"`
 if test -z "$ac_err"; then
   rm -rf conftest*
@@ -14463,16 +14143,16 @@
   echo "$ac_t""yes" 1>&6
   
       echo $ac_n "checking for dlopen in -lc""... $ac_c" 1>&6
-echo "configure:14467: checking for dlopen in -lc" >&5
+echo "configure:14147: checking for dlopen in -lc" >&5
       cat > conftest.$ac_ext <<EOF
-#line 14469 "configure"
+#line 14149 "configure"
 #include "confdefs.h"
 #include <dlfcn.h>
 int main() {
 	dlopen ("", 0);
 ; return 0; }
 EOF
-if { (eval echo configure:14476: \"$ac_link\") 1>&5; (eval $ac_link) 2>&5; } && test -s conftest${ac_exeext}; then
+if { (eval echo configure:14156: \"$ac_link\") 1>&5; (eval $ac_link) 2>&5; } && test -s conftest${ac_exeext}; then
   rm -rf conftest*
    have_dl=yes 
 else
@@ -14481,18 +14161,18 @@
   rm -rf conftest*
   
       echo $ac_n "checking for dlopen in -ldl""... $ac_c" 1>&6
-echo "configure:14485: checking for dlopen in -ldl" >&5
+echo "configure:14165: checking for dlopen in -ldl" >&5
       ac_save_LIBS="$LIBS"
       LIBS="-ldl $LIBS"
       cat > conftest.$ac_ext <<EOF
-#line 14489 "configure"
+#line 14169 "configure"
 #include "confdefs.h"
 #include <dlfcn.h>
 int main() {
 	dlopen ("", 0);
 ; return 0; }
 EOF
-if { (eval echo configure:14496: \"$ac_link\") 1>&5; (eval $ac_link) 2>&5; } && test -s conftest${ac_exeext}; then
+if { (eval echo configure:14176: \"$ac_link\") 1>&5; (eval $ac_link) 2>&5; } && test -s conftest${ac_exeext}; then
   rm -rf conftest*
    have_dl=yes 
 else
@@ -14521,12 +14201,12 @@
     else
       
 echo $ac_n "checking for shl_load in -ldld""... $ac_c" 1>&6
-echo "configure:14525: checking for shl_load in -ldld" >&5
+echo "configure:14205: checking for shl_load in -ldld" >&5
 ac_lib_var=`echo dld'_'shl_load | sed 'y%./+-%__p_%'`
 
 xe_check_libs=" -ldld "
 cat > conftest.$ac_ext <<EOF
-#line 14530 "configure"
+#line 14210 "configure"
 #include "confdefs.h"
 /* Override any gcc2 internal prototype to avoid an error.  */
 /* We use char because int might match the return type of a gcc2
@@ -14537,7 +14217,7 @@
 shl_load()
 ; return 0; }
 EOF
-if { (eval echo configure:14541: \"$ac_link\") 1>&5; (eval $ac_link) 2>&5; } && test -s conftest${ac_exeext}; then
+if { (eval echo configure:14221: \"$ac_link\") 1>&5; (eval $ac_link) 2>&5; } && test -s conftest${ac_exeext}; then
   rm -rf conftest*
   eval "ac_cv_lib_$ac_lib_var=yes"
 else
@@ -14564,12 +14244,12 @@
   echo "$ac_t""no" 1>&6
 
 echo $ac_n "checking for dld_init in -ldld""... $ac_c" 1>&6
-echo "configure:14568: checking for dld_init in -ldld" >&5
+echo "configure:14248: checking for dld_init in -ldld" >&5
 ac_lib_var=`echo dld'_'dld_init | sed 'y%./+-%__p_%'`
 
 xe_check_libs=" -ldld "
 cat > conftest.$ac_ext <<EOF
-#line 14573 "configure"
+#line 14253 "configure"
 #include "confdefs.h"
 /* Override any gcc2 internal prototype to avoid an error.  */
 /* We use char because int might match the return type of a gcc2
@@ -14580,7 +14260,7 @@
 dld_init()
 ; return 0; }
 EOF
-if { (eval echo configure:14584: \"$ac_link\") 1>&5; (eval $ac_link) 2>&5; } && test -s conftest${ac_exeext}; then
+if { (eval echo configure:14264: \"$ac_link\") 1>&5; (eval $ac_link) 2>&5; } && test -s conftest${ac_exeext}; then
   rm -rf conftest*
   eval "ac_cv_lib_$ac_lib_var=yes"
 else
@@ -14625,7 +14305,7 @@
 xealias=$internal_configuration
 
 echo "checking how to build dynamic libraries for ${xehost}" 1>&6
-echo "configure:14629: checking how to build dynamic libraries for ${xehost}" >&5
+echo "configure:14309: checking how to build dynamic libraries for ${xehost}" >&5
 # Transform *-*-linux* to *-*-linux-gnu*, to support old configure scripts.
 case "$xehost" in
 *-*-linux-gnu*) ;;
@@ -14653,9 +14333,9 @@
   XEGCC=yes
 else
   echo $ac_n "checking checking whether we are using GNU C""... $ac_c" 1>&6
-echo "configure:14657: checking checking whether we are using GNU C" >&5
+echo "configure:14337: checking checking whether we are using GNU C" >&5
   cat > conftest.$ac_ext <<EOF
-#line 14659 "configure"
+#line 14339 "configure"
 #include "confdefs.h"
 
 #ifdef __GNUC__
@@ -14677,7 +14357,7 @@
 fi
 
 echo $ac_n "checking how to produce PIC code""... $ac_c" 1>&6
-echo "configure:14681: checking how to produce PIC code" >&5
+echo "configure:14361: checking how to produce PIC code" >&5
 wl=
 
 can_build_shared=yes
@@ -14778,18 +14458,18 @@
 
   # Check to make sure the dll_cflags actually works.
   echo $ac_n "checking if PIC flag ${dll_cflags} really works""... $ac_c" 1>&6
-echo "configure:14782: checking if PIC flag ${dll_cflags} really works" >&5
+echo "configure:14462: checking if PIC flag ${dll_cflags} really works" >&5
   save_CFLAGS="$CFLAGS"
   CFLAGS="$CFLAGS $dll_cflags -DPIC"
   cat > conftest.$ac_ext <<EOF
-#line 14786 "configure"
+#line 14466 "configure"
 #include "confdefs.h"
 
 int main() {
 int x=0;
 ; return 0; }
 EOF
-if { (eval echo configure:14793: \"$ac_compile\") 1>&5; (eval $ac_compile) 2>&5; }; then
+if { (eval echo configure:14473: \"$ac_compile\") 1>&5; (eval $ac_compile) 2>&5; }; then
   rm -rf conftest*
   
     # On HP-UX, the stripped-down bundled CC doesn't accept +Z, but also
@@ -14820,7 +14500,7 @@
 xldf=
 xcldf=
 echo $ac_n "checking if C compiler can produce shared libraries""... $ac_c" 1>&6
-echo "configure:14824: checking if C compiler can produce shared libraries" >&5
+echo "configure:14504: checking if C compiler can produce shared libraries" >&5
 if test "$XEGCC" = yes; then
   xcldf="-shared"
   xldf="-shared"
@@ -14871,14 +14551,14 @@
   xe_libs=
   ac_link='${CC-cc} -o conftest $CFLAGS '"$xe_cppflags $xe_ldflags"' conftest.$ac_ext '"$xe_libs"' 1>&5'
   cat > conftest.$ac_ext <<EOF
-#line 14875 "configure"
+#line 14555 "configure"
 #include "confdefs.h"
 
 int main() {
 int x=0;
 ; return 0; }
 EOF
-if { (eval echo configure:14882: \"$ac_link\") 1>&5; (eval $ac_link) 2>&5; } && test -s conftest${ac_exeext}; then
+if { (eval echo configure:14562: \"$ac_link\") 1>&5; (eval $ac_link) 2>&5; } && test -s conftest${ac_exeext}; then
   rm -rf conftest*
   cc_produces_so=yes
 else
@@ -14903,7 +14583,7 @@
   if test "$XEGCC" = yes; then
     # Check if gcc -print-prog-name=ld gives a path.
     echo $ac_n "checking for ld used by GCC""... $ac_c" 1>&6
-echo "configure:14907: checking for ld used by GCC" >&5
+echo "configure:14587: checking for ld used by GCC" >&5
     ac_prog=`($CC -print-prog-name=ld) 2>&5`
     case "$ac_prog" in
     # Accept absolute paths.
@@ -14929,7 +14609,7 @@
     esac
   else
     echo $ac_n "checking for GNU ld""... $ac_c" 1>&6
-echo "configure:14933: checking for GNU ld" >&5
+echo "configure:14613: checking for GNU ld" >&5
   fi
 
   if test -z "$LTLD"; then
@@ -14967,7 +14647,7 @@
 
 # Check to see if it really is or isn't GNU ld.
 echo $ac_n "checking if the linker is GNU ld""... $ac_c" 1>&6
-echo "configure:14971: checking if the linker is GNU ld" >&5
+echo "configure:14651: checking if the linker is GNU ld" >&5
 # I'd rather use --version here, but apparently some GNU ld's only accept -v.
 if $LTLD -v 2>&1 </dev/null | egrep '(GNU|with BFD)' 1>&5; then
   xe_gnu_ld=yes
@@ -14995,7 +14675,7 @@
   # OK - only NOW do we futz about with ld.
   # See if the linker supports building shared libraries.
   echo $ac_n "checking whether the linker supports shared libraries""... $ac_c" 1>&6
-echo "configure:14999: checking whether the linker supports shared libraries" >&5
+echo "configure:14679: checking whether the linker supports shared libraries" >&5
   dll_ld=$CC
   dll_ldflags=$LDFLAGS
   ld_shlibs=yes
@@ -15198,18 +14878,15 @@
 EOF
 }
 
-    extra_objs="$extra_objs sysdll.o emodules.o" &&  if test "$extra_verbose" = "yes"; then
-   echo "    xemacs will be linked with \"sysdll.o emodules.o\""
- fi
     INSTALL_ARCH_DEP_SUBDIR="$INSTALL_ARCH_DEP_SUBDIR src" &&  if test "$extra_verbose" = "yes"; then echo "    Appending \"src\" to \$INSTALL_ARCH_DEP_SUBDIR"; fi
     test -n "$libdl" && LIBS="-l${libdl} $LIBS" &&  if test "$extra_verbose" = "yes"; then echo "    Prepending \"-l${libdl}\" to \$LIBS"; fi
     for ac_func in dlerror _dlerror
 do
 echo $ac_n "checking for $ac_func""... $ac_c" 1>&6
-echo "configure:15210: checking for $ac_func" >&5
-
-cat > conftest.$ac_ext <<EOF
-#line 15213 "configure"
+echo "configure:14887: checking for $ac_func" >&5
+
+cat > conftest.$ac_ext <<EOF
+#line 14890 "configure"
 #include "confdefs.h"
 /* System header to define __stub macros and hopefully few prototypes,
     which can conflict with char $ac_func(); below.  */
@@ -15232,7 +14909,7 @@
 
 ; return 0; }
 EOF
-if { (eval echo configure:15236: \"$ac_link\") 1>&5; (eval $ac_link) 2>&5; } && test -s conftest${ac_exeext}; then
+if { (eval echo configure:14913: \"$ac_link\") 1>&5; (eval $ac_link) 2>&5; } && test -s conftest${ac_exeext}; then
   rm -rf conftest*
   eval "ac_cv_func_$ac_func=yes"
 else
@@ -15271,11 +14948,11 @@
 fi
 
 cat > conftest.$ac_ext <<EOF
-#line 15275 "configure"
+#line 14952 "configure"
 #include "confdefs.h"
 int main(int c,char *v[]){return 0;}
 EOF
-if { (eval echo configure:15279: \"$ac_link\") 1>&5; (eval $ac_link) 2>&5; } && test -s conftest && (./conftest; exit $?) 2>&5
+if { (eval echo configure:14956: \"$ac_link\") 1>&5; (eval $ac_link) 2>&5; } && test -s conftest && (./conftest; exit $?) 2>&5
 then
   :
 else
@@ -15302,11 +14979,7 @@
 fi
 rm -fr conftest*
 
-if test "$win32_processes" = "yes"; then
-  extra_objs="$extra_objs process-nt.o" &&  if test "$extra_verbose" = "yes"; then
-   echo "    xemacs will be linked with \"process-nt.o\""
- fi
-else
+if test "$win32_processes" != "yes"; then
   { test "$extra_verbose" = "yes" && cat << \EOF
     Defining HAVE_UNIX_PROCESSES
 EOF
@@ -15315,9 +14988,6 @@
 EOF
 }
 
-  extra_objs="$extra_objs process-unix.o" &&  if test "$extra_verbose" = "yes"; then
-   echo "    xemacs will be linked with \"process-unix.o\""
- fi
 fi
 
 
@@ -15754,14 +15424,6 @@
 }
 
 fi
-test "$with_i18n3"         = "yes" && { test "$extra_verbose" = "yes" && cat << \EOF
-    Defining I18N3
-EOF
-cat >> confdefs.h <<\EOF
-#define I18N3 1
-EOF
-}
-
 test "$GCC"                = "yes" && { test "$extra_verbose" = "yes" && cat << \EOF
     Defining USE_GCC
 EOF
@@ -16033,7 +15695,6 @@
 echo "
 Internationalization:"
 test "$with_mule" = yes && echo "  Compiling in support for Mule (multi-lingual Emacs)."
-test "$with_file_coding" = yes && echo "  Compiling in support for file coding."
 test "$with_xim" != no && echo "  Compiling in support for XIM (X11R5+ I18N input method)."
 test "$with_xim" = motif && echo "    - Using Motif to provide XIM support."
 test "$with_xim" = xlib && echo "    - Using raw Xlib to provide XIM support."
@@ -16043,7 +15704,6 @@
   echo "  Compiling in support for the WNN input method on Mule."
   test "$with_wnn6" = yes && echo "    - Using WNN version 6."
 fi
-test "$with_i18n3" = yes && echo "  Compiling in support for I18N level 3 (doesn't currently work)."
 
 echo "
 Mail:"