Revision: miles@gnu.org--gnu-2005/emacs--unicode--0--patch-2

Merge from emacs--cvs-trunk--0

Patches applied:

 * miles@gnu.org--gnu-2004/gnus--rel--5.10--patch-83
 - miles@gnu.org--gnu-2004/gnus--rel--5.10--patch-84
   Update from CVS

 * miles@gnu.org--gnu-2005/emacs--cvs-trunk--0--patch-3
 - miles@gnu.org--gnu-2005/emacs--cvs-trunk--0--patch-4
   Update from CVS

 * miles@gnu.org--gnu-2005/emacs--cvs-trunk--0--patch-5
   Merge from gnus--rel--5.10

 * miles@gnu.org--gnu-2005/emacs--cvs-trunk--0--patch-6
 - miles@gnu.org--gnu-2005/emacs--cvs-trunk--0--patch-11
   Update from CVS

 * miles@gnu.org--gnu-2005/emacs--cvs-trunk--0--patch-12
   Remove "-face" suffix from lazy-highlight face name

 * miles@gnu.org--gnu-2005/emacs--cvs-trunk--0--patch-13
 - miles@gnu.org--gnu-2005/emacs--cvs-trunk--0--patch-16
   Update from CVS

 * miles@gnu.org--gnu-2005/emacs--cvs-trunk--0--patch-17
   Merge from gnus--rel--5.10

 * miles@gnu.org--gnu-2005/emacs--cvs-trunk--0--patch-18
 - miles@gnu.org--gnu-2005/emacs--cvs-trunk--0--patch-21
   Update from CVS

 * miles@gnu.org--gnu-2005/emacs--cvs-trunk--0--patch-22
   <no summary provided>

 * miles@gnu.org--gnu-2005/emacs--cvs-trunk--0--patch-23
 - miles@gnu.org--gnu-2005/emacs--cvs-trunk--0--patch-39
   Update from CVS

 * miles@gnu.org--gnu-2005/emacs--cvs-trunk--0--patch-40
   Fix regressions from latest reftex update

 * miles@gnu.org--gnu-2005/gnus--rel--5.10--base-0
   tag of miles@gnu.org--gnu-2004/gnus--rel--5.10--patch-82

 * miles@gnu.org--gnu-2005/gnus--rel--5.10--patch-1
   Merge from emacs--cvs-trunk--0

 * miles@gnu.org--gnu-2005/gnus--rel--5.10--patch-2
   Merge from miles@gnu.org--gnu-2004

 * miles@gnu.org--gnu-2005/gnus--rel--5.10--patch-3
   Merge from emacs--cvs-trunk--0

79 files changed, 3326 insertions, 1230 deletions

diff --git a/lisp/ChangeLog b/lisp/ChangeLog
index 1df649e2d5b..fa3006178b1 100644
--- a/lisp/ChangeLog
+++ b/lisp/ChangeLog
@@ -1,13 +1,558 @@
-2005-01-01  Jay Belanger  <belanger@truman.edu>
+2005-01-15  Richard M. Stallman  <rms@gnu.org>
+
+        * emacs-lisp/lisp-mnt.el (lm-with-file): Use Lisp mode in temp buffer.
+        In non-temp buffer, switch syntax table temporarily.
+
+        * emacs-lisp/lisp-mode.el (indent-pp-sexp): Doc fix.
+
+        * replace.el (occur-accumulate-lines, occur-engine): Avoid warnings.
+
+        * tar-mode.el (tar-extract): Bind buffer-undo-list to t.
+
+        * imenu.el (imenu--split-menu): Copy menulist before sorting.
+        (imenu--generic-function): Use START, not BEG, as pos of definition.
+
+        * simple.el (just-one-space): Argument specifies number of spaces.
+
+        * simple.el (eval-expression-print-format): Avoid warning
+        about edebug-active.
+
+2005-01-15  "James R. Van Zandt"  <jrvz@comcast.net>  (Tiny change)
+
+        * progmodes/sh-script.el: Code copied from make-mode.el
+        with small changes,
+        (sh-mode-map): Bind C-c C-\.
+        (sh-backslash-column, sh-backslash-align): New variables.
+        (sh-backslash-region, sh-append-backslash): New functions.
+        
+2005-01-15  Sergey Poznyakoff  <gray@Mirddin.farlep.net>
+
+        * mail/rmail.el: Updated to work with movemail from GNU Mailutils
+        (rmail-pop-password, rmail-pop-password-required): Moved to
+        rmail-obsolete group.
+        (rmail-set-pop-password): Renamed to rmail-set-remote-password.
+        All callers updated.
+        (rmail-get-pop-password): Renamed to rmail-get-remote-password.
+        Take an argument specifying whether it is POP or IMAP mailbox we
+        are using.  All callers updated.
+        (rmail-pop-password-error): Renamed to
+        rmail-remote-password-error.  Added mailutils-specific error
+        message.
+        (rmail-movemail-search-path)
+        (rmail-movemail-variant-in-use): New variables.
+        (rmail-remote-password, rmail-remote-password-required): New
+        customization variables.
+        (rmail-probe,rmail-autodetect, rmail-movemail-variant-p): New
+        functions.
+        (rmail-parse-url): New function.
+        (rmail-get-new-mail, rmail-insert-inbox-text): Updated for use
+        with GNU mailutils movemail.
+
+2005-01-15  Kevin Ryde  <user42@zip.com.au>
+
+        * info-look.el (c-mode/symbol): Add ^` to prefix, and change
+        suffix to space, $ or '$, to correctly position point when going
+        to @table style constants like DBL_MAX.
+
+2005-01-15  Jorgen Schaefer  <forcer@forcix.cx>  (tiny change)
+
+        * type-break.el (type-break-mode, type-break-file-time)
+        (type-break-file-keystroke-count, type-break-choose-file): Don't
+        store data in or load data from the file if type-break-file-name
+        is nil.
+        (type-break-file-name): Doc update as per the above.
+
+2005-01-15  Stephen Eglen  <S.J.Eglen@damtp.cam.ac.uk>  (tiny change)
+
+        * woman.el (woman-dired-define-key-maybe): If KEY is undefined,
+        lookup-key might return nil; handle that.
+
+2005-01-15  Alan Mackenzie  <acm@muc.de>
+
+        * ebrowse.el (ebrowse-class-in-tree): Return the tail of the tree
+        rather than the element found, thus enabling the tree to be
+        setcar'd.
 
-        * calc-yank.el (calc-edit-mode): Change default header.
+2005-01-14  Carsten Dominik  <dominik@science.uva.nl>
 
-        * calc-store.el (calc-edit-variable): Change title to match new
-        header.
+        * textmodes/org.el (org-show-following-heading): New option.
+        (org-show-hierarchy-above): Use `org-show-following-heading'.
+        (org-cycle): Documentation fix.
+
+        * textmodes/org.el (orgtbl-optimized): New option
+        (orgtbl-mode): New command, a minor mode.
+        (orgtbl-mode-map): New variable.
+        (turn-on-orgtbl, orgtbl-mode, orgtbl-make-binding)
+        (orgtbl-error, orgtbl-self-insert-command)
+        (orgtbl-delete-backward-char, orgtbl-delete-char): New functions.
+
+        * textmodes/org.el (org-mode): `org-table-may-need-update' is now
+        a local variable in each org-mode buffer.
+
+        * textmodes/org.el (org-set-regexps-and-options): Renamed from
+        `org-set-regexps'.  Added checking for STARTUP keyword.
+        (org-get-current-options): Added STARTUP options.
+        (org-table-insert-row): Mode mode intelligent about when
+        realignment is needed.
+        (org-self-insert-command, org-delete-backward-char,
+        org-delete-char): New commands.
+        (org-enable-table-editor): new default value `optimized'.
+        (org-table-blank-field): Support blanking regions if active.
+
+
+2005-01-14  Carsten Dominik  <dominik@science.uva.nl>
+
+        * textmodes/reftex-cite.el (reftex-bib-sort-year): Catch the case
+        if the year is not given.
+
+        * textmodes/reftex-ref.el (reftex-replace-prefix-escapes): Added
+        new escapes %m and %M, fixed bug with %F by adding
+        save-match-data.
+        (reftex-reference): Removed ?. from list of spaces.
+        (reftex-label-info): Added automatic label prefix recognition
+
+        * textmodes/reftex-index.el (reftex-index-next-phrase): Added
+        slave parameter to call of `reftex-index-this-phrase'
+        (reftex-index-this-phrase): New optional argument
+        (reftex-index-region-phrases): Added slave parameter to call of
+        `reftex-index-this-phrase'
+        (reftex-display-index): New argument redo
+        (reftex-index-rescan): Added 'redo to arguments of
+        `reftex-display-index'
+        (reftex-index-Rescan, reftex-index-revert)
+        (reftex-index-switch-index-tag): Added 'redo to arguments of
+        `reftex-display-index'
+        (reftex-index-make-phrase-regexp): Fixed bug with case-sensitive
+        indexing.  Fixed bug with matching is there is a quote before or
+        after the word.
+
+        * textmodes/reftex-cite.el (reftex-all-used-citation-keys): Fix
+        bug when collecting citation keys in lines with comments.
+        (reftex-citation): Prefix argument no longer rescans the document,
+        but forces prompting for optional arguments of cite macros.
+        (reftex-do-citation): Prompting for optional arguments
+        implemented.
+
+        * textmodes/reftex-vars.el (reftex-cite-format-builtin): Added
+        optional arguments to most cite commands.
+        (reftex-cite-cleanup-optional-args): New option
+        (reftex-cite-prompt-optional-args): New option.
+        (reftex-trust-label-prefix): New option
+
+        * textmodes/reftex-toc.el (reftex-toc-find-section): Added
+        push-mark before changing the position in the buffer.
+
+        * textmodes/reftex.el (reftex-prefix-to-typekey-alist): New
+        variable
+        (reftex-compile-variables): Compute reftex-prefix-to-typekey-alist
+
+2005-01-14  Nick Roberts  <nickrob@snap.net.nz>
+
+        * xt-mouse.el (xterm-mouse-event): Compute window co-ordinates
+        more carefully.
+
+2005-01-13  Stefan Monnier  <monnier@iro.umontreal.ca>
+
+        * textmodes/sgml-mode.el (sgml-fill-nobreak): New fun.
+        (sgml-mode): Use it.
+        (sgml-get-context): Better keep track of implicitly closed tags.
+
+2005-01-13  Kenichi Handa  <handa@m17n.org>
+
+        * textmodes/ispell.el: These changes are to fix misalignment error
+        caused by equivalent characters of different Emacs charsets.
+        (ispell-unified-chars-table): New variable.
+        (ispell-get-decoded-string): New function.
+        (ispell-get-casechars, ispell-get-not-casechars)
+        (ispell-get-otherchars): Call ispell-get-decoded-string.
+
+2005-01-12  Johan Bockg,Ae(Brd  <bojohan@users.sourceforge.net>
+
+        * custom.el (custom-declare-variable): Just put symbol instead
+        of (defvar . symbol) in `current-load-list'.
+
+2005-01-12  Reiner Steib  <Reiner.Steib@gmx.de>
+
+        * emacs-lisp/elint.el: Fixed typo in Commentary section.
+
+2005-01-12  Jay Belanger  <belanger@truman.edu>
+
+        * calc/calc-help.el (calc-describe-key): Use temporary info buffer
+        to create a Calc summary.
+
+2005-01-12  Kim F. Storm  <storm@cua.dk>
+
+        * mouse.el (mouse-on-link-p): Change functionality and doc
+        string to comply with latest description in lisp ref.
+
+2005-01-12  Nick Roberts  <nickrob@snap.net.nz>
+
+        * xt-mouse.el (xterm-mouse-translate, xterm-mouse-event):
+        Enable mouse clicks on mode-line, header-line and margin.
+        (event-type): Give mouse event symbols an 'event-kind property
+        with value 'mouse-click.
+
+2005-01-12  Juri Linkov  <juri@jurta.org>
+
+        * facemenu.el (list-colors-display): Add new arg buffer-name.
+        Use it.  Fix docstring.  Replace code for identifying duplicate
+        colors by the name with call to `list-colors-duplicates' which
+        identifies duplicate colors by the value unless the color
+        is one of special Windows colors.  Set truncate-lines to t.
+        Print sorted duplicate color names on each line.  Indent to 22
+        \(the longest color name in rgb.txt) instead of 20.  Optimize.
+        (list-colors-duplicates): New function.
+        (facemenu-color-name-equal): Delete function.
+
+        * facemenu.el (list-colors-print): New function created from code
+        in list-colors-display.  Print #RRGGBB at the window right edge.
+        (list-colors-display): When temp-buffer-show-function is not
+        defined, call list-colors-print from temp-buffer-show-hook
+        to get the right value of window-width in list-colors-print
+        after the buffer is displayed.
+
+        * simple.el (pop-mark): Move deactivate-mark out of conditional
+        part to deactivate the active mark regardless of the state of the
+        mark ring.
+
+        * desktop.el (desktop-save): Add `mode: emacs-lisp' to the local
+        variables line in desktop files.
+
+2005-01-12  Juri Linkov  <juri@jurta.org>
+
+        * isearch.el (search-highlight, isearch, isearch-lazy-highlight):
+        Bring together isearch highlight related options.
+        (lazy-highlight): Replace group `replace' by `matching'.
+        (lazy-highlight-cleanup, lazy-highlight-initial-delay)
+        (lazy-highlight-interval, lazy-highlight-max-at-a-time)
+        (lazy-highlight): Add aliases to old names isearch-lazy-highlight-...
+        and declare them obsolete.
+        (lazy-highlight-face): Rename from isearch-lazy-highlight-face.
+        (isearch-faces): Remove defgroup.
+        (isearch-overlay, isearch-highlight, isearch-dehighlight):
+        Move isearch highlighting code closer to lazy highlighting code.
+
+        * replace.el (query-replace-lazy-highlight): Add lazy-highlight group.
+        (query-replace-highlight, query-replace-lazy-highlight)
+        (query-replace): Move definitions to the beginning of the file.
+
+2005-01-11  Juri Linkov  <juri@jurta.org>
+
+        * toolbar/back_arrow.xpm, toolbar/back_arrow.pbm,
+        * toolbar/lc-back_arrow.xpm, toolbar/lc-fwd_arrow.xpm,
+        * toolbar/fwd_arrow.xpm, toolbar/fwd_arrow.pbm: New icons.
+
+        * info.el (Info-history-forward): New variable.
+        (Info-select-node): Reset Info-history-forward to nil.
+        (Info-last): Turn into defalias.
+        (Info-history-back): Rename from Info-last.
+        Add current node to Info-history-forward.
+        (Info-history-forward): New fun.
+        (Info-mode-map): Replace Info-last by Info-history-back.
+        Bind Info-history-forward to "r".
+        (Info-mode-menu): Replace Info-last by Info-history-back.
+        Fix menu item text.  Add menu item for Info-history-forward.
+        (info-tool-bar-map): Replace Info-last by Info-history-back.
+        Replace its icon "undo" by "back_arrow".  Add icon "fwd_arrow"
+        for Info-history-forward.
+        (Info-mode): Replace Info-last by Info-history-back in docstring.
+        Add local variable Info-history-forward.
+        (Info-goto-emacs-command-node): Replace Info-last by Info-history-back.
+
+2005-01-11  Stefan Monnier  <monnier@iro.umontreal.ca>
+
+        * mouse.el (mouse-drag-mode-line-1, mouse-drag-vertical-line)
+        (mouse-drag-region, mouse-drag-region-1, mouse-drag-secondary):
+        Ignore select-window events rather than fiddle with
+        mouse-autoselect-window.
+
+2005-01-11  Matthew Mundell  <matt@mundell.ukfsn.org>
+
+        * type-break.el (type-break-mode): Fix previous change.
+
+2005-01-10  Jay Belanger  <belanger@truman.edu>
+
+        * calc/calc-ext.el (calc-reset): Reset when inside embedded
+        calculator; only reset when point is inside a calculator.
+        Don't adjust the window height if the window takes up the whole height
+        of the frame.
+
+2005-01-10  Thien-Thi Nguyen  <ttn@gnu.org>
+
+        * ebuff-menu.el (Electric-buffer-menu-mode):
+        Preserve value of buffer-local var header-line-format.
+
+2005-01-09  Jay Belanger  <belanger@truman.edu>
+
+        * calc/calc.el (calc-mode-var-list-restore-saved-values):
+        Make sure settings file exists before accessing it.
+
+        * calc/calc-embed.el (calc-embedded-subst):
+        Replace math-multi-subst-rec, which is only supposed to be called
+        by math-multi-subst, by math-multi-subst.
+
+2005-01-09  Andre Spiegel  <spiegel@gnu.org>
+
+        * vc.el (vc-allow-async-revert): New user option.
+        (vc-disable-async-diff): New internal variable.
+        (vc-revert-buffer): Use them to disable asynchronous diff.
+
+        * vc-cvs.el, vc-arch.el, vc-svn.el, vc-mcvs.el (vc-cvs-diff)
+        (vc-arch-diff, vc-svn-diff, vc-mcvs-diff): Don't diff
+        asynchronously if vc-disable-async-diff is t.
+
+2005-01-09  Jay Belanger  <belanger@truman.edu>
+
+        * calc/calc.el (defcalcmodevar): New macro.
+        (calc-mode-var-list-restore-default-values)
+        (calc-mode-var-list-restore-saved-values): New functions.
+        (calc-mode-var-list): Use defcalcmodevar to define it.
+        (calc-always-load-extensions, calc-line-numbering)
+        (calc-line-breaking, calc-display-just, calc-display-origin)
+        (calc-number-radix, calc-leading-zeros, calc-group-digits)
+        (calc-group-char, calc-point-char, calc-frac-format)
+        (calc-prefer-frac, calc-hms-format, calc-date-format)
+        (calc-float-format, calc-full-float-format, calc-complex-format)
+        (calc-complex-mode, calc-infinite-mode, calc-display-strings)
+        (calc-matrix-just, calc-break-vectors, calc-full-vectors)
+        (calc-full-trail-vectors, calc-vector-commas, calc-vector-brackets)
+        (calc-matrix-brackets, calc-language, calc-language-option)
+        (calc-left-label, calc-right-label, calc-word-size)
+        (calc-previous-modulo, calc-simplify-mode, calc-auto-recompute)
+        (calc-display-raw, calc-internal-prec, calc-angle-mode)
+        (calc-algebraic-mode, calc-incomplete-algebraic-mode)
+        (calc-symbolic-mode, calc-matrix-mode, calc-shift-prefix)
+        (calc-window-height, calc-display-trail, calc-show-selections)
+        (calc-use-selections, calc-assoc-selections)
+        (calc-display-working-message, calc-auto-why, calc-timing)
+        (calc-mode-save-mode, calc-standard-date-formats, calc-autorange-units)
+        (calc-was-keypad-mode, calc-full-mode, calc-user-parse-tables)
+        (calc-gnuplot-default-device, calc-gnuplot-default-output)
+        (calc-gnuplot-print-device, calc-gnuplot-print-output)
+        (calc-gnuplot-geometry, calc-graph-default-resolution)
+        (calc-graph-default-resolution-3d, calc-invocation-macro)
+        (calc-show-banner): Use defcalcmodevar to declare them and set
+        their default values.
+
+        * calc/calc-ext.el (calc-reset): Restore saved values of variables
+        instead of default values (but restore default values if there is
+        an argument of 0).
+
+2005-01-09  David Kastrup  <dak@gnu.org>
+
+        * desktop.el (desktop-restore-eager): Fix typo in type.
+
+2005-01-08  Richard M. Stallman  <rms@gnu.org>
+
+        * cus-edit.el (customize): Delete :link.
+
+2005-01-08  Jay Belanger  <belanger@truman.edu>
+
+        * calc/calc.el (calc-mode): Remove the extension from the
+        `calc-settings-file' file name when loading it.
+
+2005-01-08  Kim F. Storm  <storm@cua.dk>
+
+        * info.el (Info-mode-map, Info-next-link-keymap)
+        (Info-prev-link-keymap, Info-up-link-keymap):
+        Map follow-link to mouse-face.
+        (Info-fontify-node): Add "mouse-2: " prefix to tooltip.
+
+2005-01-08  Jay Belanger  <belanger@truman.edu>
+
+        * calc/calc.el (calc-settings-file): Change default value.
+        Suggested by cgw in a comment in calc-mode.el.
+
+        * calc/calc-mode.el (calc-settings-file-name):
+        Compare calc-settings-file to user-init-file instead of ~/.emacs.
+        Replace ~/.emacs in a prompt by calc-settings-file.
+
+2005-01-07  Lars Hansen  <larsh@math.ku.dk>
+
+        * desktop.el (desktop-restore-eager, desktop-lazy-verbose)
+        (desktop-lazy-idle-delay): New customizable variables.
+        (desktop-buffer-args-list): New variable.
+        (desktop-append-buffer-args): New function.
+        (desktop-save): Call desktop-append-buffer-args for some buffers.
+        (desktop-lazy-create-buffer): New function.
+        (desktop-idle-create-buffers): New function.
+        (desktop-read): Add message about buffers to restore lazily.
+        (desktop-lazy-abort): New command.
+        (desktop-clear): Call desktop-lazy-abort.
+        (desktop-lazy-complete): New command.
 
-        * calc/calc-prog.el (calc-edit-user-syntax): Change title to edit
+2005-01-06  Richard M. Stallman  <rms@gnu.org>
+
+        * emacs-lisp/find-func.el (find-face-definition):
+        Rename from find-face.
+
+2005-01-06  Kim F. Storm  <storm@cua.dk>
+
+        * simple.el (completion-list-mode-map): Map follow-link to mouse-face.
+
+        * man.el (Man-xref-man-page, Man-xref-header-file)
+        (Man-xref-normal-file): Add follow-link property.
+
+2005-01-06  Jay Belanger  <belanger@truman.edu>
+
+        * calc/calc-units.el: Make sure the proper macro definitions are
+        available when compiling.
+
+2005-01-06  Juri Linkov  <juri@jurta.org>
+
+        * isearch.el (isearch-lazy-highlight-update):
+        Rename `isearch-lazy-highlight-interval' to `lazy-highlight-interval'.
+
+2005-01-06  Miles Bader  <miles@gnu.org>
+
+        * isearch.el (lazy-highlight): Rename from `lazy-highlight-face'.
+        (isearch-lazy-highlight-face): Use new name.
+
+2005-01-05  Stefan Monnier  <monnier@iro.umontreal.ca>
+
+        * uniquify.el (uniquify-rationalize-file-buffer-names):
+        Re-add an interactive spec.
+        (uniquify-rationalize-file-buffer-names): Fix corner case when renaming
+        to the same name.
+
+        * isearch.el (isearch-dehighlight): Remove unused arg `totally'.
+        (isearch-update, isearch-done): Adjust calls accordingly.
+
+2005-01-05  Richard M. Stallman  <rms@gnu.org>
+
+        * custom.el (custom-set-variables, custom-theme-set-variables):
+        Clarify documentation.
+
+        * emacs-lisp/find-func.el (find-variable)
+        (find-variable-other-window, find-variable-other-frame):
+        Fix the TYPE args to find-function-read and find-function-do-it.
+        (find-function): Doc fix.
+        (find-function-at-point): Replace function-at-point alias.
+
+2005-01-04  Richard M. Stallman  <rms@gnu.org>
+
+        * cus-face.el (custom-declare-face):
+        Record defface in current-load-list.
+
+        * help-fns.el (variable-at-point): New arg ANY-SYMBOL.
+
+        * emacs-lisp/find-func.el: Doc fixes.
+        (find-face-regexp): New variable.
+        (find-function-regexp-alist): New variable.
+        (find-function-C-source): Third arg is now TYPE.
+        (find-function-search-for-symbol): Handle general TYPE.
+        (find-function-read, find-function-do-it): Handle general TYPE.
+        (find-definition-noselect, find-face): New functions.
+        (function-at-point): Alias deleted.
+
+2005-01-04  Stefan Monnier  <monnier@iro.umontreal.ca>
+
+        * battery.el (display-battery-mode): Rename from display-battery.
+        Handle the case where it gets turned off.
+
+2005-01-04  Richard M. Stallman  <rms@gnu.org>
+
+        * cus-edit.el (customize): Make :link point to user doc.
+
+        * man.el (Man-fontify-manpage): Turn off undo generation.
+
+        * add-log.el (change-log-font-lock-keywords): Don't match just "From".
+
+2005-01-04  Andreas Schwab  <schwab@suse.de>
+
+        * files.el (insert-directory): Only look for error lines in
+        inserted text.  Don't move too far after processing --dired markers.
+
+2005-01-04  Richard M. Stallman  <rms@gnu.org>
+
+        * mail/mailabbrev.el (sendmail-pre-abbrev-expand-hook):
+        Don't expand if the character is @, period, dash, etc.
+        (define-mail-abbrev): Quote names that contain problem characters.
+
+2005-01-04  Thien-Thi Nguyen  <ttn@gnu.org>
+
+        * progmodes/hideshow.el: No longer require `cl'; `dolist' is standard.
+
+2005-01-03  Richard M. Stallman  <rms@gnu.org>
+
+        * replace.el (replace-dehighlight): Use lazy-highlight-cleanup.
+        (query-replace-highlight, query-replace-lazy-highlight)
+        (query-replace): Definitions moved up.  Doc fix.
+
+2005-01-03  Richard M. Stallman  <rms@gnu.org>
+
+        * isearch.el (lazy-highlight): Group renamed from isearch-lazy-...
+        (lazy-highlight-cleanup, lazy-highlight-initial-delay)
+        (lazy-highlight-interval, lazy-highlight-max-at-a-time)
+        (lazy-highlight-face): Rename from isearch-lazy-...
+        Change all references to them.
+
+2005-01-03  Luc Teirlinck  <teirllm@auburn.edu>
+
+        * cus-edit.el (custom-file): Doc fix for defcustom.
+        (custom-file): The function no longer sets the variable
+        `custom-file' to its return value.
+
+        * startup.el (command-line): No longer load `custom-file'.
+
+2005-01-03  Stefan Monnier  <monnier@iro.umontreal.ca>
+
+        * emacs-lisp/find-func.el (find-variable-regexp): Avoid defface.
+
+        * progmodes/perl-mode.el (perl-nochange, perl-calculate-indent):
+        Don't confuse module-prefixed identifiers for labels.
+        Reported by Juan-Leon Lahoz Garcia <juanleon1@gmail.com>.
+
+2005-01-02  Richard M. Stallman  <rms@gnu.org>
+
+        * files.el (basic-save-buffer-1): Fix previous change.
+
+        * loadhist.el (file-loadhist-lookup): New function.
+        (file-provides, file-requires): Use it.
+
+        * electric.el (Electric-pop-up-window): Use fit-window-to-buffer
+        instead of calculating the right size.
+
+2005-01-02  Karl Chen  <quarl@cs.berkeley.edu>  (tiny change)
+
+        * vc-svn.el (vc-svn-diff): Stay local if possible.
+
+2005-01-02  Stefan  <monnier@iro.umontreal.ca>
+
+        * vc-arch.el (vc-arch-workfile-version): Handle the empty-branch case.
+
+        * files.el (hack-local-variables): Fix last change.
+
+2005-01-02  Jay Belanger  <belanger@truman.edu>
+
+        * calc/calc-yank.el (calc-edit-top): New variable.
+        (calc-edit-mode): Set calc-edit-top to be the beginning of the edited
+        object.  Change header properties.
+        (calc-edit-finish, calc-edit-finish-stack-object)
+        (calc-edit-show-buffer): Use calc-edit-top to find the beginning of the
+        edited object.
+        * calc/calc-sel.el (calc-finish-selection-edit): Use calc-edit-top
+        for the beginning of the edited object.
+        * calc/calc-embed.el (calc-embedded-finish-edit): Use calc-edit-top
+        for the beginning of the edited object.
+        * calc/calc-prog.el (calc-edit-macro-finish-edit)
+        (calc-finish-formula-edit, calc-macro-repeats)
+        (calc-edit-macro-adjust-buffer, calc-edit-format-macro-buffer)
+        (calc-edit-macro-pre-finish-edit): Use calc-edit-top for the
+        beginning of the edited object.
+        (calc-user-define-edit): Change the header for editing macros.
+        Remove unnecessary variable.
+
+2005-01-01  Jay Belanger  <belanger@truman.edu>
+
+        * calc/calc-yank.el (calc-edit-mode): Change default header.
+        (calc-edit-finish, calc-show-edit-buffer): Adjust to handle new header.
+        * calc/calc-store.el (calc-edit-variable): Change title to match new
+        header.
+        * calc/calc-prog.el (calc-edit-user-syntax): Change title in edit
         mode to match new header.
         (calc-user-define-edit): Change titles to include names of commands.
+        (calc-finish-formula-edit): Adjust to handle new header.
         (calc-finish-macro-edit): Remove.
         (calc-edit-macro-repeats, calc-edit-macro-adjust-buffer)
         (calc-edit-macro-command, calc-edit-macro-command-type)
@@ -2944,7 +3489,7 @@
         * menu-bar.el (menu-bar-files-menu): Make "Open File..." call
         find-file-existing.  Add "New File..." that calls find-file.
 
-        * diropen.pbm diropen.xpm: New files.
+        * diropen.pbm, diropen.xpm: New files.
 
         * toolbar/tool-bar.el (tool-bar-setup): Tool bar item dired uses
         icon diropen.  New tool bar item find-file-existing uses icon open.
@@ -4044,7 +4589,7 @@
         (dired-move-to-end-of-filename): Make the " -> " search more specific.
         (dired-buffers-for-dir): Remove unused var `pattern'.
 
-2004-09-28  Matthew Mundell  <matt@mundell.ukfsn.org>  (tiny change)
+2004-09-28  Matthew Mundell  <matt@mundell.ukfsn.org>
 
         * calendar/diary-lib.el (list-diary-entries): Save diary buffer
         from diary display excursion.  Store diary buffer's point for
diff --git a/lisp/add-log.el b/lisp/add-log.el
index 14a32e580c8..50be95d265a 100644
--- a/lisp/add-log.el
+++ b/lisp/add-log.el
@@ -248,7 +248,9 @@ Note: The search is conducted only within 10%, at the beginning of the file."
     ("<\\([^>\n]+\\)>\\(:\\| (\\)" (1 'change-log-function-face))
     ;;
     ;; Acknowledgements.
-    ("\\(^\t\\|  \\)\\(From\\|Patch\\(es\\)? by\\|Report\\(ed by\\| from\\)\\|Suggest\\(ed by\\|ion from\\)\\)"
+    ;; Don't include plain "From" because that is vague;
+    ;; we want to encourage people to say something more specific.
+    ("\\(^\t\\|  \\)\\(Patch\\(es\\)? by\\|Report\\(ed by\\| from\\)\\|Suggest\\(ed by\\|ion from\\)\\)"
      2 'change-log-acknowledgement-face))
   "Additional expressions to highlight in Change Log mode.")
 
diff --git a/lisp/battery.el b/lisp/battery.el
index b8790450735..69bd68bb0b9 100644
--- a/lisp/battery.el
+++ b/lisp/battery.el
@@ -1,6 +1,6 @@
 ;;; battery.el --- display battery status information
 
-;; Copyright (C) 1997, 1998, 2000, 2001, 2003, 2004
+;; Copyright (C) 1997, 1998, 2000, 2001, 2003, 2004, 2005
 ;;           Free Software Foundation, Inc.
 
 ;; Author: Ralph Schleicher <rs@nunatak.allgaeu.org>
@@ -108,20 +108,23 @@ The text being displayed in the echo area is controlled by the variables
                   "Battery status not available")))
 
 ;;;###autoload
-(defun display-battery ()
+(define-minor-mode display-battery-mode
   "Display battery status information in the mode line.
 The text being displayed in the mode line is controlled by the variables
 `battery-mode-line-format' and `battery-status-function'.
 The mode line will be updated automatically every `battery-update-interval'
 seconds."
-  (interactive)
+  :global t
   (setq battery-mode-line-string "")
   (or global-mode-string (setq global-mode-string '("")))
-  (add-to-list 'global-mode-string 'battery-mode-line-string t)
   (and battery-update-timer (cancel-timer battery-update-timer))
-  (setq battery-update-timer (run-at-time nil battery-update-interval
-                                          'battery-update-handler))
-  (battery-update))
+  (if (not display-battery-mode)
+      (setq global-mode-string
+            (delq 'battery-mode-line-string global-mode-string))
+    (add-to-list 'global-mode-string 'battery-mode-line-string t)
+    (setq battery-update-timer (run-at-time nil battery-update-interval
+                                            'battery-update-handler))
+    (battery-update)))
 
 (defun battery-update-handler ()
   (battery-update)
diff --git a/lisp/calc/calc-embed.el b/lisp/calc/calc-embed.el
index 067d233bf4a..db1acfcb145 100644
--- a/lisp/calc/calc-embed.el
+++ b/lisp/calc/calc-embed.el
@@ -308,10 +308,10 @@ This is not required to be present for user-written mode annotations.")
   (calc-show-edit-buffer))
 
 (defvar calc-original-buffer)
-
+(defvar calc-edit-top)
 (defun calc-embedded-finish-edit (info)
   (let ((buf (current-buffer))
-        (str (buffer-substring (point) (point-max)))
+        (str (buffer-substring calc-edit-top (point-max)))
         (start (point))
         pos)
     (switch-to-buffer calc-original-buffer)
@@ -885,7 +885,7 @@ The command \\[yank] can retrieve it from there."
         (list 'calcFunc-assign
               (nth 1 x)
               (calc-embedded-subst (nth 2 x)))
-      (calc-normalize (math-evaluate-expr-rec (math-multi-subst-rec x))))))
+      (calc-normalize (math-evaluate-expr-rec (math-multi-subst x nil nil))))))
 
 (defun calc-embedded-eval-get-var (var base)
   (let ((entry base)
diff --git a/lisp/calc/calc-ext.el b/lisp/calc/calc-ext.el
index 89588b4ea74..280c3ca634b 100644
--- a/lisp/calc/calc-ext.el
+++ b/lisp/calc/calc-ext.el
@@ -1240,36 +1240,54 @@ calc-kill calc-kill-region calc-yank))))
 
 (defun calc-reset (arg)
   (interactive "P")
-  (save-excursion
-    (or (eq major-mode 'calc-mode)
-        (calc-create-buffer))
-    (if calc-embedded-info
-        (calc-embedded nil))
-    (or arg
-        (setq calc-stack nil))
-    (setq calc-undo-list nil
-          calc-redo-list nil)
-    (let (calc-stack calc-user-parse-tables calc-standard-date-formats
-                     calc-invocation-macro)
-      (mapcar (function (lambda (v) (set v nil))) calc-local-var-list)
-      (mapcar (function (lambda (v) (set (car v) (nth 1 v))))
-              calc-mode-var-list))
-    (calc-set-language nil nil t)
-    (calc-mode)
-    (calc-flush-caches t)
-    (run-hooks 'calc-reset-hook))
-  (calc-wrapper
-   (let ((win (get-buffer-window (current-buffer))))
-     (calc-realign 0)
-     (if win
-         (let ((height (- (window-height win) 2)))
-           (set-window-point win (point))
-           (or (= height calc-window-height)
-               (let ((swin (selected-window)))
-                 (select-window win)
-                 (enlarge-window (- calc-window-height height))
-                 (select-window swin)))))))
-  (message "(Calculator reset)"))
+  (setq arg (if arg (prefix-numeric-value arg) nil))
+  (cond
+   ((and
+     calc-embedded-info
+     (equal (aref calc-embedded-info 0) (current-buffer))
+     (<= (point) (aref calc-embedded-info 5))
+     (>= (point) (aref calc-embedded-info 4)))
+    (let ((cbuf (aref calc-embedded-info 1))
+          (calc-embedded-quiet t))
+      (save-window-excursion
+        (calc-embedded nil)
+        (set-buffer cbuf)
+        (calc-reset arg))
+      (calc-embedded nil)))
+   ((eq major-mode 'calc-mode)
+    (save-excursion
+      (unless (and arg (> (abs arg) 0))
+        (setq calc-stack nil))
+      (setq calc-undo-list nil
+            calc-redo-list nil)
+      (let (calc-stack calc-user-parse-tables calc-standard-date-formats
+                       calc-invocation-macro)
+        (mapcar (function (lambda (v) (set v nil))) calc-local-var-list)
+        (if (and arg (<= arg 0))
+            (calc-mode-var-list-restore-default-values)
+          (calc-mode-var-list-restore-saved-values)))
+      (calc-set-language nil nil t)
+      (calc-mode)
+      (calc-flush-caches t)
+      (run-hooks 'calc-reset-hook))
+    (calc-wrapper
+     (let ((win (get-buffer-window (current-buffer))))
+       (calc-realign 0)
+       ;; Adjust the window height if the window is visible, but doesn't
+       ;; take up the whole height of the frame.
+       (if (and
+            win
+            (< (window-height win) (1- (frame-height))))
+           (let ((height (- (window-height win) 2)))
+             (set-window-point win (point))
+             (or (= height calc-window-height)
+                 (let ((swin (selected-window)))
+                   (select-window win)
+                   (enlarge-window (- calc-window-height height))
+                   (select-window swin)))))))
+    (message "(Calculator reset)"))
+   (t
+    (message "(Not inside a Calc buffer)"))))
 
 ;; What a pain; scroll-left behaves differently when called non-interactively.
 (defun calc-scroll-left (n)
diff --git a/lisp/calc/calc-help.el b/lisp/calc/calc-help.el
index 087c42d295c..eb0cba79cd8 100644
--- a/lisp/calc/calc-help.el
+++ b/lisp/calc/calc-help.el
@@ -178,15 +178,15 @@ C-w  Describe how there is no warranty for Calc."
                        (if (= (buffer-size) 0)
                            (progn
                              (message "Reading Calc summary from manual...")
-                             (save-window-excursion
-                               (save-excursion
-                                 (calc-info-goto-node "Summary")
-                                 (goto-char (point-min))
-                                 (forward-line 1)
-                                 (copy-to-buffer "*Calc Summary*"
-                                                 (point) (point-max))
-                                 (if Info-history
-                                     (Info-last))))))
+                             (require 'info nil t)
+                             (with-temp-buffer
+                               (Info-mode)
+                               (Info-goto-node "(Calc)Summary")
+                               (goto-char (point-min))
+                               (forward-line 1)
+                               (copy-to-buffer "*Calc Summary*"
+                                               (point) (point-max)))
+                             (setq buffer-read-only t)))
                        (goto-char (point-min))
                        (setq case-fold-search nil)
                        (re-search-forward "^\\(.*\\)\\[\\.\\. a b")
diff --git a/lisp/calc/calc-mode.el b/lisp/calc/calc-mode.el
index dfc488d49dd..389b52385b6 100644
--- a/lisp/calc/calc-mode.el
+++ b/lisp/calc/calc-mode.el
@@ -309,25 +309,22 @@
 (defun calc-settings-file-name (name &optional arg)
   (interactive
    (list (read-file-name (format "Settings file name (normally %s): "
-                                 (abbreviate-file-name (or user-init-file
-                                                           "~/.emacs"))))
+                                 (abbreviate-file-name calc-settings-file)))
          current-prefix-arg))
   (calc-wrapper
    (setq arg (if arg (prefix-numeric-value arg) 0))
-   (if (equal name "")
+   (if (string-equal (file-name-nondirectory name) "")
        (message "Calc settings file is \"%s\"" calc-settings-file)
      (if (< (math-abs arg) 2)
          (let ((list calc-mode-var-list))
            (while list
              (set (car (car list)) (nth 1 (car list)))
              (setq list (cdr list)))))
-     ;; FIXME: we should use ~/.calc or so in order to avoid
-     ;; reexecuting ~/.emacs (it's not always idempotent) -cgw 2001.11.12
      (setq calc-settings-file name)
      (or (and
           calc-settings-file
-          (string-match "\\.emacs" calc-settings-file)
-              (> arg 0))
+          (equal user-init-file calc-settings-file)
+          (> arg 0))
          (< arg 0)
          (load name t)
          (message "New file")))))
diff --git a/lisp/calc/calc-prog.el b/lisp/calc/calc-prog.el
index b171010e220..b4901b5f8a0 100644
--- a/lisp/calc/calc-prog.el
+++ b/lisp/calc/calc-prog.el
@@ -684,21 +684,16 @@
                     (eq (car-safe (nth 3 cmd)) 'calc-execute-kbd-macro)))
            (let* ((mac (elt (nth 1 (nth 3 cmd)) 1))
                   (str (edmacro-format-keys mac t))
-                  (macbeg)
                   (kys (nth 3 (nth 3 cmd))))
              (calc-edit-mode 
               (list 'calc-edit-macro-finish-edit cmdname kys)
-              t (format "Editing keyboard macro (%s, bound to %s).\n" 
-                        cmdname kys))
-             (goto-char (point-max))
-             (insert "Original keys: " (elt (nth 1 (nth 3 cmd)) 0)  "\n" )
-             (setq macbeg (point))
+              t (format (concat 
+                         "Editing keyboard macro (%s, bound to %s).\n" 
+                         "Original keys: %s \n")
+                        cmdname kys (elt (nth 1 (nth 3 cmd)) 0)))
              (insert str "\n")
              (calc-edit-format-macro-buffer)
-             (calc-show-edit-buffer)
-             (goto-char (point-min))
-             (search-forward "Original")
-             (forward-line 2)))
+             (calc-show-edit-buffer)))
           (t (let* ((func (calc-stack-command-p cmd))
                     (defn (and func
                                (symbolp func)
@@ -714,18 +709,16 @@
                        nil
                        (format "Editing formula (%s, %s, bound to %s).\n"
                                intcmd algcmd kys))
-                      (insert (math-showing-full-precision
-                               (math-format-nice-expr defn (frame-width)))
-                              "\n"))
-                     (calc-show-edit-buffer)
-                     (goto-char (point-min))
-                     (forward-line 2))
+                      (insert  (math-showing-full-precision
+                                (math-format-nice-expr defn (frame-width)))
+                               "\n"))
+                     (calc-show-edit-buffer))
                  (error "That command's definition cannot be edited")))))))
 
 ;; Formatting the macro buffer
 
 (defun calc-edit-macro-repeats ()
-  (goto-char (point-min))
+  (goto-char calc-edit-top)
   (while
       (re-search-forward "^\\([0-9]+\\)\\*" nil t)
     (setq num (string-to-int (match-string 1)))
@@ -738,10 +731,10 @@
 
 (defun calc-edit-macro-adjust-buffer ()
   (calc-edit-macro-repeats)
-  (goto-char (point-min))
+  (goto-char calc-edit-top)
   (while (re-search-forward "^RET$" nil t)
     (delete-char 1))
-  (goto-char (point-min))
+  (goto-char calc-edit-top)
   (while (and (re-search-forward "^$" nil t)
               (not (= (point) (point-max))))
     (delete-char 1)))
@@ -869,11 +862,7 @@
 (defun calc-edit-format-macro-buffer ()
   "Rewrite the Calc macro editing buffer."
   (calc-edit-macro-adjust-buffer)
-  (goto-char (point-min))
-  (search-forward "Original keys:")
-  (forward-line 1)
-  (insert "\n")
-  (skip-chars-forward " \t\n")
+  (goto-char calc-edit-top)
   (let ((type (calc-edit-macro-command-type)))
     (while (not (string-equal type ""))
       (cond
@@ -913,27 +902,25 @@
         (calc-edit-macro-combine-var-name))
        (t (forward-line 1)))
       (setq type (calc-edit-macro-command-type))))
-  (goto-char (point-min)))
+  (goto-char calc-edit-top))
 
 ;; Finish editing the macro
 
 (defun calc-edit-macro-pre-finish-edit ()
-  (goto-char (point-min))
+  (goto-char calc-edit-top)
   (while (re-search-forward "\\(^\\| \\)RET\\($\\|\t\\| \\)" nil t)
     (search-backward "RET")
     (delete-char 3)
     (insert "<return>")))
 
+(defvar calc-edit-top)
 (defun calc-edit-macro-finish-edit (cmdname key)
   "Finish editing a Calc macro.
 Redefine the corresponding command."
   (interactive)
   (let ((cmd (intern cmdname)))
     (calc-edit-macro-pre-finish-edit)
-    (goto-char (point-max))
-    (re-search-backward "^Original keys:")
-    (forward-line 1)
-    (let* ((str (buffer-substring (point) (point-max)))
+    (let* ((str (buffer-substring calc-edit-top (point-max)))
            (mac (edmacro-parse-keys str t)))
       (if (= (length mac) 0)
           (fmakunbound cmd)
@@ -946,10 +933,8 @@ Redefine the corresponding command."
                           'arg key)))))))
 
 (defun calc-finish-formula-edit (func)
-  (goto-char (point-min))
-  (forward-line 2)
   (let ((buf (current-buffer))
-        (str (buffer-substring (point) (point-max)))
+        (str (buffer-substring calc-edit-top (point-max)))
         (start (point))
         (body (calc-valid-formula-func func)))
     (set-buffer calc-original-buffer)
diff --git a/lisp/calc/calc-sel.el b/lisp/calc/calc-sel.el
index 7b45814f1e7..4ae0df5d3ba 100644
--- a/lisp/calc/calc-sel.el
+++ b/lisp/calc/calc-sel.el
@@ -677,10 +677,11 @@
 ;; The variable calc-edit-disp-trail is local to calc-edit-finish,
 ;; in calc-yank.el.
 (defvar calc-edit-disp-trail)
+(defvar calc-edit-top)
 
 (defun calc-finish-selection-edit (num sel reselect)
   (let ((buf (current-buffer))
-        (str (buffer-substring (point) (point-max)))
+        (str (buffer-substring calc-edit-top (point-max)))
         (start (point)))
     (switch-to-buffer calc-original-buffer)
     (let ((val (math-read-expr str)))
diff --git a/lisp/calc/calc-units.el b/lisp/calc/calc-units.el
index d473b02c0a6..e8a3abfe958 100644
--- a/lisp/calc/calc-units.el
+++ b/lisp/calc/calc-units.el
@@ -30,6 +30,8 @@
 
 (require 'calc-ext)
 (require 'calc-macs)
+(eval-when-compile
+  (require 'calc-alg))
 
 ;;; Units operations.
 
diff --git a/lisp/calc/calc-yank.el b/lisp/calc/calc-yank.el
index 4c7d41e0f76..53d5946e073 100644
--- a/lisp/calc/calc-yank.el
+++ b/lisp/calc/calc-yank.el
@@ -430,6 +430,7 @@
 (defvar calc-edit-handler)
 (defvar calc-restore-trail)
 (defvar calc-allow-ret)
+(defvar calc-edit-top)
 
 (defun calc-edit-mode (&optional handler allow-ret title)
   "Calculator editing mode.  Press RET, LFD, or C-c C-c to finish.
@@ -464,10 +465,15 @@ To cancel the edit, simply kill the *Calc Edit* buffer."
                                   (let ((calc-edit-handler nil))
                                     (calc-edit-finish t))
                                   (message "(Cancelled)")) t t)
-    (insert (or title title "Calc Edit Mode. ")
-            "Press `C-c C-c'"
-            (if allow-ret "" " or RET")
-            " to finish, `C-x k RET' to cancel.\n")))
+    (insert (propertize
+             (concat 
+              (or title title "Calc Edit Mode. ")
+              "Press `C-c C-c'"
+              (if allow-ret "" " or RET")
+              " to finish, `C-x k RET' to cancel.\n\n")
+             'font-lock-face 'italic 'read-only t 'rear-nonsticky t 'front-sticky t))
+    (make-local-variable 'calc-edit-top)
+    (setq calc-edit-top (point))))
 (put 'calc-edit-mode 'mode-class 'special)
 
 (defun calc-show-edit-buffer ()
@@ -484,8 +490,7 @@ To cancel the edit, simply kill the *Calc Edit* buffer."
           (if win
               (delete-window win))))
     (set-buffer-modified-p nil)
-    (goto-char (point-min))
-    (forward-line 1)))
+    (goto-char calc-edit-top)))
 
 (defun calc-edit-return ()
   (interactive)
@@ -519,9 +524,7 @@ To cancel the edit, simply kill the *Calc Edit* buffer."
                   (set-buffer original)
                   (not (eq major-mode 'calc-mode))))
         (error "Original calculator buffer has been corrupted")))
-    (goto-char (point-min))
-    (when (looking-at "Calc Edit\\|Editing ")
-      (forward-line 1))
+    (goto-char calc-edit-top)
     (if (buffer-modified-p)
         (eval calc-edit-handler))
     (if one-window
@@ -546,7 +549,7 @@ To cancel the edit, simply kill the *Calc Edit* buffer."
 
 (defun calc-finish-stack-edit (num)
   (let ((buf (current-buffer))
-        (str (buffer-substring (point) (point-max)))
+        (str (buffer-substring calc-edit-top (point-max)))
         (start (point))
         pos)
     (if (and (integerp num) (> num 1))
diff --git a/lisp/calc/calc.el b/lisp/calc/calc.el
index f93c2e899b5..a578a8666b8 100644
--- a/lisp/calc/calc.el
+++ b/lisp/calc/calc.el
@@ -206,8 +206,8 @@
 (require 'calc-macs)
 
 ;;;###autoload
-(defvar calc-settings-file user-init-file
-  "*File in which to record permanent settings; default is `user-init-file'.")
+(defvar calc-settings-file (convert-standard-filename "~/.calc.el")
+  "*File in which to record permanent settings.")
 
 (defvar calc-bug-address "belanger@truman.edu"
   "Address of the author of Calc, for use by `report-calc-bug'.")
@@ -241,128 +241,102 @@ scientific notation in calc-mode.")
 (defvar calc-loaded-settings-file nil
   "t if `calc-settings-file' has been loaded yet.")
 
-(defvar calc-always-load-extensions)
-(defvar calc-line-numbering)
-(defvar calc-line-breaking)
-(defvar calc-display-just)
-(defvar calc-display-origin)
-(defvar calc-number-radix)
-(defvar calc-leading-zeros)
-(defvar calc-group-digits)
-(defvar calc-group-char)
-(defvar calc-point-char)
-(defvar calc-frac-format)
-(defvar calc-prefer-frac)
-(defvar calc-hms-format)
-(defvar calc-date-format)
-(defvar calc-float-format)
-(defvar calc-full-float-format)
-(defvar calc-complex-format)
-(defvar calc-complex-mode)
-(defvar calc-infinite-mode)
-(defvar calc-display-strings)
-(defvar calc-matrix-just)
-(defvar calc-break-vectors)
-(defvar calc-full-vectors)
-(defvar calc-full-trail-vectors)
-(defvar calc-vector-commas)
-(defvar calc-vector-brackets)
-(defvar calc-matrix-brackets)
-(defvar calc-language)
-(defvar calc-language-option)
-(defvar calc-left-label)
-(defvar calc-right-label)
-(defvar calc-word-size)
-(defvar calc-previous-modulo)
-(defvar calc-simplify-mode)
-(defvar calc-auto-recompute)
-(defvar calc-display-raw)
-(defvar calc-internal-prec)
-(defvar calc-angle-mode)
-(defvar calc-algebraic-mode)
-(defvar calc-incomplete-algebraic-mode)
-(defvar calc-symbolic-mode)
-(defvar calc-matrix-mode)
-(defvar calc-shift-prefix)
-(defvar calc-window-height)
-(defvar calc-display-trail)
-(defvar calc-show-selections)
-(defvar calc-use-selections)
-(defvar calc-assoc-selections)
-(defvar calc-display-working-message)
-(defvar calc-auto-why)
-(defvar calc-timing)
-(defvar calc-mode-save-mode)
-(defvar calc-standard-date-formats)
-(defvar calc-autorange-units)
-(defvar calc-was-keypad-mode)
-(defvar calc-full-mode)
-(defvar calc-user-parse-tables)
-(defvar calc-gnuplot-default-device)
-(defvar calc-gnuplot-default-output)
-(defvar calc-gnuplot-print-device)
-(defvar calc-gnuplot-print-output)
-(defvar calc-gnuplot-geometry)
-(defvar calc-graph-default-resolution)
-(defvar calc-graph-default-resolution-3d)
-(defvar calc-invocation-macro)
-(defvar calc-show-banner)
-
-(defconst calc-mode-var-list '(
-  (calc-always-load-extensions nil
-   "If non-nil, load the calc-ext module automatically when calc is loaded.")
-
-  (calc-line-numbering t
-   "If non-nil, display line numbers in Calculator stack.")
-
-  (calc-line-breaking t
-   "If non-nil, break long values across multiple lines in Calculator stack.")
-
-  (calc-display-just nil
-   "If nil, stack display is left-justified.
+
+(defvar calc-mode-var-list '()
+  "List of variables used in customizing GNU Calc.")
+
+(defmacro defcalcmodevar (var defval &optional doc)
+  `(progn
+     (defvar ,var ,defval ,doc)
+     (add-to-list 'calc-mode-var-list (list (quote ,var) ,defval))))
+
+(defun calc-mode-var-list-restore-default-values ()
+  (mapcar (function (lambda (v) (set (car v) (nth 1 v))))
+          calc-mode-var-list))
+
+(defun calc-mode-var-list-restore-saved-values ()
+  (let ((newvarlist '()))
+    (save-excursion
+      (let (pos
+            (file (substitute-in-file-name calc-settings-file)))
+        (when (and
+               (file-regular-p file)
+               (set-buffer (find-file-noselect file))
+               (goto-char (point-min))
+               (search-forward ";;; Mode settings stored by Calc" nil t)
+               (progn
+                 (forward-line 1)
+                 (setq pos (point))
+                 (search-forward "\n;;; End of mode settings" nil t)))
+          (beginning-of-line)
+          (calc-mode-var-list-restore-default-values)
+          (eval-region pos (point))
+          (let ((varlist calc-mode-var-list))
+            (while varlist
+              (let ((var (car varlist)))
+                (setq newvarlist
+                      (cons (list (car var) (symbol-value (car var)))
+                            newvarlist)))
+              (setq varlist (cdr varlist)))))))
+    (if newvarlist
+        (mapcar (function (lambda (v) (set (car v) (nth 1 v))))
+                newvarlist)
+      (calc-mode-var-list-restore-default-values))))
+
+(defcalcmodevar calc-always-load-extensions nil
+  "If non-nil, load the calc-ext module automatically when calc is loaded.")
+
+(defcalcmodevar  calc-line-numbering t
+  "If non-nil, display line numbers in Calculator stack.")
+
+(defcalcmodevar calc-line-breaking t
+  "If non-nil, break long values across multiple lines in Calculator stack.")
+
+(defcalcmodevar calc-display-just nil
+  "If nil, stack display is left-justified.
 If `right', stack display is right-justified.
 If `center', stack display is centered.")
 
-  (calc-display-origin nil
-   "Horizontal origin of displayed stack entries.
+(defcalcmodevar calc-display-origin nil
+  "Horizontal origin of displayed stack entries.
 In left-justified mode, this is effectively indentation.  (Default 0).
 In right-justified mode, this is effectively window width.
 In centered mode, center of stack entry is placed here.")
 
-  (calc-number-radix 10
-   "Radix for entry and display of numbers in calc-mode, 2-36.")
+(defcalcmodevar calc-number-radix 10
+  "Radix for entry and display of numbers in calc-mode, 2-36.")
 
-  (calc-leading-zeros nil
-   "If non-nil, leading zeros are provided to pad integers to calc-word-size.")
+(defcalcmodevar calc-leading-zeros nil
+  "If non-nil, leading zeros are provided to pad integers to calc-word-size.")
 
-  (calc-group-digits nil
-   "If non-nil, group digits in large displayed integers by inserting spaces.
+(defcalcmodevar calc-group-digits nil
+  "If non-nil, group digits in large displayed integers by inserting spaces.
 If an integer, group that many digits at a time.
 If t, use 4 for binary and hex, 3 otherwise.")
 
-  (calc-group-char ","
-   "The character (in the form of a string) to be used for grouping digits.
+(defcalcmodevar calc-group-char ","
+  "The character (in the form of a string) to be used for grouping digits.
 This is used only when calc-group-digits mode is on.")
 
-  (calc-point-char "."
-   "The character (in the form of a string) to be used as a decimal point.")
+(defcalcmodevar calc-point-char "."
+  "The character (in the form of a string) to be used as a decimal point.")
   
-  (calc-frac-format (":" nil)
-   "Format of displayed fractions; a string of one or two of \":\" or \"/\".")
+(defcalcmodevar calc-frac-format '(":" nil)
+  "Format of displayed fractions; a string of one or two of \":\" or \"/\".")
 
-  (calc-prefer-frac nil
-   "If non-nil, prefer fractional over floating-point results.")
+(defcalcmodevar calc-prefer-frac nil
+  "If non-nil, prefer fractional over floating-point results.")
 
-  (calc-hms-format "%s@ %s' %s\""
-   "Format of displayed hours-minutes-seconds angles, a format string.
+(defcalcmodevar calc-hms-format "%s@ %s' %s\""
+  "Format of displayed hours-minutes-seconds angles, a format string.
 String must contain three %s marks for hours, minutes, seconds respectively.")
 
-  (calc-date-format ((H ":" mm C SS pp " ")
-                     Www " " Mmm " " D ", " YYYY)
-   "Format of displayed date forms.")
+(defcalcmodevar calc-date-format '((H ":" mm C SS pp " ")
+                                  Www " " Mmm " " D ", " YYYY)
+  "Format of displayed date forms.")
 
-  (calc-float-format (float 0)
-   "Format to use for display of floating-point numbers in calc-mode.
+(defcalcmodevar calc-float-format '(float 0)
+  "Format to use for display of floating-point numbers in calc-mode.
 Must be a list of one of the following forms:
  (float 0)      Floating point format, display full precision.
  (float N)      N > 0: Floating point format, at most N significant figures.
@@ -375,54 +349,54 @@ Must be a list of one of the following forms:
  (eng N)        N > 0: Engineering notation, N significant figures.
  (eng -N)       -N < 0: Engineering notation, calc-internal-prec - N figs.")
 
-  (calc-full-float-format (float 0)
-   "Format to use when full precision must be displayed.")
+(defcalcmodevar calc-full-float-format '(float 0)
+  "Format to use when full precision must be displayed.")
 
-  (calc-complex-format nil
-   "Format to use for display of complex numbers in calc-mode.  Must be one of:
+(defcalcmodevar calc-complex-format nil
+  "Format to use for display of complex numbers in calc-mode.  Must be one of:
   nil            Use (x, y) form.
   i              Use x + yi form.
   j              Use x + yj form.")
 
-  (calc-complex-mode cplx
-   "Preferred form, either `cplx' or `polar', for complex numbers.")
+(defcalcmodevar calc-complex-mode 'cplx
+  "Preferred form, either `cplx' or `polar', for complex numbers.")
 
-  (calc-infinite-mode nil
-   "If nil, 1 / 0 is left unsimplified.
+(defcalcmodevar calc-infinite-mode nil
+  "If nil, 1 / 0 is left unsimplified.
 If 0, 1 / 0 is changed to inf (zeros are considered positive).
 Otherwise, 1 / 0 is changed to uinf (undirected infinity).")
 
-  (calc-display-strings nil
-   "If non-nil, display vectors of byte-sized integers as strings.")
+(defcalcmodevar calc-display-strings nil
+  "If non-nil, display vectors of byte-sized integers as strings.")
 
-  (calc-matrix-just center
-   "If nil, vector elements are left-justified.
+(defcalcmodevar calc-matrix-just 'center
+  "If nil, vector elements are left-justified.
 If `right', vector elements are right-justified.
 If `center', vector elements are centered.")
 
-  (calc-break-vectors nil
-   "If non-nil, display vectors one element per line.")
+(defcalcmodevar calc-break-vectors nil
+  "If non-nil, display vectors one element per line.")
 
-  (calc-full-vectors t
-   "If non-nil, display long vectors in full.  If nil, use abbreviated form.")
+(defcalcmodevar calc-full-vectors t
+  "If non-nil, display long vectors in full.  If nil, use abbreviated form.")
 
-  (calc-full-trail-vectors t
-   "If non-nil, display long vectors in full in the trail.")
+(defcalcmodevar calc-full-trail-vectors t
+  "If non-nil, display long vectors in full in the trail.")
 
-  (calc-vector-commas ","
-   "If non-nil, separate elements of displayed vectors with this string.")
+(defcalcmodevar calc-vector-commas ","
+  "If non-nil, separate elements of displayed vectors with this string.")
 
-  (calc-vector-brackets "[]"
-   "If non-nil, surround displayed vectors with these characters.")
+(defcalcmodevar calc-vector-brackets "[]"
+  "If non-nil, surround displayed vectors with these characters.")
 
-  (calc-matrix-brackets (R O)
-   "A list of code-letter symbols that control \"big\" matrix display.
+(defcalcmodevar calc-matrix-brackets '(R O)
+  "A list of code-letter symbols that control \"big\" matrix display.
 If `R' is present, display inner brackets for matrices.
 If `O' is present, display outer brackets for matrices (above/below).
 If `C' is present, display outer brackets for matrices (centered).")
 
-  (calc-language nil
-   "Language or format for entry and display of stack values.  Must be one of:
+(defcalcmodevar calc-language nil
+  "Language or format for entry and display of stack values.  Must be one of:
   nil           Use standard Calc notation.
   flat          Use standard Calc notation, one-line format.
   big           Display formulas in 2-d notation (enter w/std notation).
@@ -435,23 +409,23 @@ If `C' is present, display outer brackets for matrices (centered).")
   math          Use Mathematica(tm) notation.
   maple         Use Maple notation.")
 
-  (calc-language-option nil
-   "Numeric prefix argument for the command that set `calc-language'.")
+(defcalcmodevar calc-language-option nil
+  "Numeric prefix argument for the command that set `calc-language'.")
 
-  (calc-left-label ""
-   "Label to display at left of formula.")
+(defcalcmodevar calc-left-label ""
+  "Label to display at left of formula.")
 
-  (calc-right-label ""
-   "Label to display at right of formula.")
+(defcalcmodevar calc-right-label ""
+  "Label to display at right of formula.")
 
-  (calc-word-size 32
-   "Minimum number of bits per word, if any, for binary operations in calc-mode.")
+(defcalcmodevar calc-word-size 32
+  "Minimum number of bits per word, if any, for binary operations in calc-mode.")
 
-  (calc-previous-modulo nil
-   "Most recently used value of M in a modulo form.")
+(defcalcmodevar calc-previous-modulo nil
+  "Most recently used value of M in a modulo form.")
 
-  (calc-simplify-mode nil
-   "Type of simplification applied to results.
+(defcalcmodevar calc-simplify-mode nil
+  "Type of simplification applied to results.
 If `none', results are not simplified when pushed on the stack.
 If `num', functions are simplified only when args are constant.
 If nil, only fast simplifications are applied.
@@ -460,69 +434,69 @@ If `alg', `math-simplify' is applied.
 If `ext', `math-simplify-extended' is applied.
 If `units', `math-simplify-units' is applied.")
 
-  (calc-auto-recompute t
-   "If non-nil, recompute evalto's automatically when necessary.")
+(defcalcmodevar calc-auto-recompute t
+  "If non-nil, recompute evalto's automatically when necessary.")
 
-  (calc-display-raw nil
-   "If non-nil, display shows unformatted Lisp exprs.  (For debugging)")
+(defcalcmodevar calc-display-raw nil
+  "If non-nil, display shows unformatted Lisp exprs.(defcalcmodevar For debugging)")
 
-  (calc-internal-prec 12
-   "Number of digits of internal precision for calc-mode calculations.")
+(defcalcmodevar calc-internal-prec 12
+  "Number of digits of internal precision for calc-mode calculations.")
 
-  (calc-angle-mode deg
-   "If deg, angles are in degrees; if rad, angles are in radians.
+(defcalcmodevar calc-angle-mode 'deg
+  "If deg, angles are in degrees; if rad, angles are in radians.
 If hms, angles are in degrees-minutes-seconds.")
 
-  (calc-algebraic-mode nil
-   "If non-nil, numeric entry accepts whole algebraic expressions.
+(defcalcmodevar calc-algebraic-mode nil
+  "If non-nil, numeric entry accepts whole algebraic expressions.
 If nil, algebraic expressions must be preceded by \"'\".")
 
-  (calc-incomplete-algebraic-mode nil
-   "Like calc-algebraic-mode except only affects ( and [ keys.")
+(defcalcmodevar calc-incomplete-algebraic-mode nil
+  "Like calc-algebraic-mode except only affects ( and [ keys.")
 
-  (calc-symbolic-mode nil
-   "If non-nil, inexact numeric computations like sqrt(2) are postponed.
+(defcalcmodevar calc-symbolic-mode nil
+  "If non-nil, inexact numeric computations like sqrt(2) are postponed.
 If nil, computations on numbers always yield numbers where possible.")
 
-  (calc-matrix-mode nil
-   "If `matrix', variables are assumed to be matrix-valued.
+(defcalcmodevar calc-matrix-mode nil
+  "If `matrix', variables are assumed to be matrix-valued.
 If a number, variables are assumed to be NxN matrices.
 If `scalar', variables are assumed to be scalar-valued.
 If nil, symbolic math routines make no assumptions about variables.")
 
-  (calc-shift-prefix nil
-   "If non-nil, shifted letter keys are prefix keys rather than normal meanings.")
+(defcalcmodevar calc-shift-prefix nil
+  "If non-nil, shifted letter keys are prefix keys rather than normal meanings.")
 
-  (calc-window-height 7
-   "Initial height of Calculator window.")
+(defcalcmodevar calc-window-height 7
+  "Initial height of Calculator window.")
 
-  (calc-display-trail t
-   "If non-nil, M-x calc creates a window to display Calculator trail.")
+(defcalcmodevar calc-display-trail t
+  "If non-nil, M-x calc creates a window to display Calculator trail.")
 
-  (calc-show-selections t
-   "If non-nil, selected sub-formulas are shown by obscuring rest of formula.
+(defcalcmodevar calc-show-selections t
+  "If non-nil, selected sub-formulas are shown by obscuring rest of formula.
 If nil, selected sub-formulas are highlighted by obscuring the sub-formulas.")
 
-  (calc-use-selections t
-   "If non-nil, commands operate only on selected portions of formulas.
+(defcalcmodevar calc-use-selections t
+  "If non-nil, commands operate only on selected portions of formulas.
 If nil, selections displayed but ignored.")
 
-  (calc-assoc-selections t
-   "If non-nil, selection hides deep structure of associative formulas.")
+(defcalcmodevar calc-assoc-selections t
+  "If non-nil, selection hides deep structure of associative formulas.")
 
-  (calc-display-working-message lots
-   "If non-nil, display \"Working...\" for potentially slow Calculator commands.")
+(defcalcmodevar calc-display-working-message 'lots
+  "If non-nil, display \"Working...\" for potentially slow Calculator commands.")
 
-  (calc-auto-why maybe
-   "If non-nil, automatically execute a \"why\" command to explain odd results.")
+(defcalcmodevar calc-auto-why 'maybe
+  "If non-nil, automatically execute a \"why\" command to explain odd results.")
 
-  (calc-timing nil
-   "If non-nil, display timing information on each slow command.")
+(defcalcmodevar calc-timing nil
+  "If non-nil, display timing information on each slow command.")
 
-  (calc-mode-save-mode local)
+(defcalcmodevar calc-mode-save-mode 'local)
 
-  (calc-standard-date-formats
-   ("N"
+(defcalcmodevar calc-standard-date-formats
+  '("N"
     "<H:mm:SSpp >Www Mmm D, YYYY"
     "D Mmm YYYY<, h:mm:SS>"
     "Www Mmm BD< hh:mm:ss> YYYY"
@@ -533,40 +507,32 @@ If nil, selections displayed but ignored.")
     "j<, h:mm:SS>"
     "YYddd< hh:mm:ss>"))
 
-  (calc-autorange-units nil)
+(defcalcmodevar calc-autorange-units nil)
   
-  (calc-was-keypad-mode nil)
+(defcalcmodevar calc-was-keypad-mode nil)
   
-  (calc-full-mode nil)
+(defcalcmodevar calc-full-mode nil)
 
-  (calc-user-parse-tables nil)
+(defcalcmodevar calc-user-parse-tables nil)
 
-  (calc-gnuplot-default-device "default")
+(defcalcmodevar calc-gnuplot-default-device "default")
 
-  (calc-gnuplot-default-output "STDOUT")
+(defcalcmodevar calc-gnuplot-default-output "STDOUT")
 
-  (calc-gnuplot-print-device "postscript")
+(defcalcmodevar calc-gnuplot-print-device "postscript")
   
-  (calc-gnuplot-print-output "auto")
+(defcalcmodevar calc-gnuplot-print-output "auto")
 
-  (calc-gnuplot-geometry nil)
+(defcalcmodevar calc-gnuplot-geometry nil)
 
-  (calc-graph-default-resolution 15)
+(defcalcmodevar calc-graph-default-resolution 15)
 
-  (calc-graph-default-resolution-3d 5)
+(defcalcmodevar calc-graph-default-resolution-3d 5)
   
-  (calc-invocation-macro nil)
-
-  (calc-show-banner t
-   "*If non-nil, show a friendly greeting above the stack."))
-  "List of variables (and default values) used in customizing GNU Calc.")
+(defcalcmodevar calc-invocation-macro nil)
 
-(mapcar (function (lambda (v)
-                    (or (boundp (car v))
-                        (set (car v) (nth 1 v)))
-                    (if (nth 2 v)
-                        (put (car v) 'variable-documentation (nth 2 v)))))
-        calc-mode-var-list)
+(defcalcmodevar calc-show-banner t
+  "*If non-nil, show a friendly greeting above the stack.")
 
 (defconst calc-local-var-list '(calc-stack
                                 calc-stack-top
@@ -1028,7 +994,7 @@ Notations:  3.14e6     3.14 * 10^6
       (equal calc-settings-file user-init-file)
       (progn
         (setq calc-loaded-settings-file t)
-        (load calc-settings-file t)))   ; t = missing-ok
+        (load (file-name-sans-extension calc-settings-file) t)))   ; t = missing-ok
   (let ((p command-line-args))
     (while p
       (and (equal (car p) "-f")
diff --git a/lisp/cus-edit.el b/lisp/cus-edit.el
index 5f3ffc6f8bf..8a60163181a 100644
--- a/lisp/cus-edit.el
+++ b/lisp/cus-edit.el
@@ -243,7 +243,6 @@
 
 (defgroup customize '((widgets custom-group))
   "Customization of the Customization support."
-  :link '(custom-manual "(elisp)Customization")
   :prefix "custom-"
   :group 'help)
 
@@ -3699,35 +3698,57 @@ The default is nil, which means to use your init file
 as specified by `user-init-file'.  If the value is not nil,
 it should be an absolute file name.
 
-To make this feature work, you'll need to put something in your
-init file to specify the value of `custom-file'.  Just
-customizing the variable won't suffice, because Emacs won't know
-which file to load unless the init file sets `custom-file'.
-
-When you change this variable, look in the previous custom file
-\(usually your init file) for the forms `(custom-set-variables ...)'
-and `(custom-set-faces ...)', and copy them (whichever ones you find)
-to the new custom file.  This will preserve your existing customizations."
-  :type '(choice (const :tag "Your Emacs init file" nil) file)
+You can set this option through Custom, if you carefully read the
+last paragraph below.  However, usually it is simpler to write
+something like the following in your init file:
+
+\(setq custom-file \"~/.emacs-custom.el\")
+\(load custom-file)
+
+Note that both lines are necessary: the first line tells Custom to
+save all customizations in this file, but does not load it.
+
+When you change this variable outside Custom, look in the
+previous custom file \(usually your init file) for the
+forms `(custom-set-variables ...)'  and `(custom-set-faces ...)',
+and copy them (whichever ones you find) to the new custom file.
+This will preserve your existing customizations.
+
+If you save this option using Custom, Custom will write all
+currently saved customizations, including the new one for this
+option itself, into the file you specify, overwriting any
+`custom-set-variables' and `custom-set-faces' forms already
+present in that file.  It will not delete any customizations from
+the old custom file.  You should do that manually if that is what you
+want.  You also have to put something like `\(load \"CUSTOM-FILE\")
+in your init file, where CUSTOM-FILE is the actual name of the
+file.  Otherwise, Emacs will not load the file when it starts up,
+and hence will not set `custom-file' to that file either."
+  :type '(choice (const :tag "Your Emacs init file" nil)
+                 (file :format "%t:%v%d"
+                       :doc
+                       "Please read entire docstring below before setting \
+this through Custom.
+Click om \"More\" \(or position point there and press RETURN)
+if only the first line of the docstring is shown."))
   :group 'customize)
 
 (defun custom-file ()
   "Return the file name for saving customizations."
-  (setq custom-file
-        (or custom-file
-            (let ((user-init-file user-init-file)
-                  (default-init-file
-                    (if (eq system-type 'ms-dos) "~/_emacs" "~/.emacs")))
-              (when (null user-init-file)
-                (if (or (file-exists-p default-init-file)
-                        (and (eq system-type 'windows-nt)
-                             (file-exists-p "~/_emacs")))
-                    ;; Started with -q, i.e. the file containing
-                    ;; Custom settings hasn't been read.  Saving
-                    ;; settings there would overwrite other settings.
-                    (error "Saving settings from \"emacs -q\" would overwrite existing customizations"))
-                (setq user-init-file default-init-file))
-              user-init-file))))
+  (or custom-file
+      (let ((user-init-file user-init-file)
+            (default-init-file
+              (if (eq system-type 'ms-dos) "~/_emacs" "~/.emacs")))
+        (when (null user-init-file)
+          (if (or (file-exists-p default-init-file)
+                  (and (eq system-type 'windows-nt)
+                       (file-exists-p "~/_emacs")))
+              ;; Started with -q, i.e. the file containing
+              ;; Custom settings hasn't been read.  Saving
+              ;; settings there would overwrite other settings.
+              (error "Saving settings from \"emacs -q\" would overwrite existing customizations"))
+          (setq user-init-file default-init-file))
+        user-init-file)))
 
 (defun custom-save-delete (symbol)
   "Visit `custom-file' and delete all calls to SYMBOL from it.
diff --git a/lisp/cus-face.el b/lisp/cus-face.el
index 0f3f6018cfc..33c8c995a4c 100644
--- a/lisp/cus-face.el
+++ b/lisp/cus-face.el
@@ -50,6 +50,7 @@
             (make-face-x-resource-internal face))))
     ;; Don't record SPEC until we see it causes no errors.
     (put face 'face-defface-spec spec)
+    (push (cons 'defface face) current-load-list)
     (when (and doc (null (face-documentation face)))
       (set-face-documentation face (purecopy doc)))
     (custom-handle-all-keywords face args 'custom-face)
diff --git a/lisp/custom.el b/lisp/custom.el
index 2ddd7ceb943..e7aba88f72a 100644
--- a/lisp/custom.el
+++ b/lisp/custom.el
@@ -168,7 +168,7 @@ set to nil, as the value is no longer rogue."
     ;; Do the actual initialization.
     (unless custom-dont-initialize
       (funcall initialize symbol default)))
-  (push (cons 'defvar symbol) current-load-list)
+  (push symbol current-load-list)
   (run-hooks 'custom-define-hook)
   symbol)
 
@@ -710,44 +710,46 @@ in every Customization buffer.")
 (put 'custom-local-buffer 'permanent-local t)
 
 (defun custom-set-variables (&rest args)
-  "Initialize variables according to user preferences.
-The settings are registered as theme `user'.
+  "Install user customizations of variable values specified in ARGS.
+These settings are registered as theme `user'.
 The arguments should each be a list of the form:
 
-  (SYMBOL VALUE [NOW [REQUEST [COMMENT]]])
+  (SYMBOL EXP [NOW [REQUEST [COMMENT]]])
 
-The unevaluated VALUE is stored as the saved value for SYMBOL.
-If NOW is present and non-nil, VALUE is also evaluated and bound as
-the default value for the SYMBOL.
+This stores EXP (without evaluating it) as the saved value for SYMBOL.
+If NOW is present and non-nil, then also evaluate EXP and set
+the default value for the SYMBOL to the value of EXP.
 
-REQUEST is a list of features we must 'require for SYMBOL.
+REQUEST is a list of features we must require in order to
+handle SYMBOL properly.
 COMMENT is a comment string about SYMBOL."
   (apply 'custom-theme-set-variables 'user args))
 
 (defun custom-theme-set-variables (theme &rest args)
-  "Initialize variables according to settings specified by args.
-Records the settings as belonging to THEME.
+  "Initialize variables for theme THEME according to settings in ARGS.
+Each of the arguments in ARGS should be a list of this form:
 
-The arguments should be a list where each entry has the form:
+  (SYMBOL EXP [NOW [REQUEST [COMMENT]]])
 
-  (SYMBOL VALUE [NOW [REQUEST [COMMENT]]])
+This stores EXP (without evaluating it) as the saved value for SYMBOL.
+If NOW is present and non-nil, then also evaluate EXP and set
+the default value for the SYMBOL to the value of EXP.
 
-The unevaluated VALUE is stored as the saved value for SYMBOL.
-If NOW is present and non-nil, VALUE is also evaluated and bound as
-the default value for the SYMBOL.
-REQUEST is a list of features we must 'require for SYMBOL.
+REQUEST is a list of features we must require in order to
+handle SYMBOL properly.
 COMMENT is a comment string about SYMBOL.
 
 Several properties of THEME and SYMBOL are used in the process:
 
-If THEME property `theme-immediate' is non-nil, this is equivalent of
-providing the NOW argument to all symbols in the argument list: SYMBOL
-is bound to the evaluated VALUE.  The only difference is SYMBOL property
+If THEME's property `theme-immediate' is non-nil, this is equivalent of
+providing the NOW argument to all symbols in the argument list:
+evaluate each EXP and set the corresponding SYMBOL.  However,
+there's a difference in the handling of SYMBOL's property
 `force-value': if NOW is non-nil, SYMBOL's property `force-value' is set to
 the symbol `rogue', else if THEME's property `theme-immediate' is non-nil,
-FACE's property `force-face' is set to the symbol `immediate'.
+SYMBOL's property `force-value' is set to the symbol `immediate'.
 
-VALUE itself is saved unevaluated as SYMBOL property `saved-value' and
+EXP itself is saved unevaluated as SYMBOL property `saved-value' and
 in SYMBOL's list property `theme-value' \(using `custom-push-theme')."
   (custom-check-theme theme)
   (let ((immediate (get theme 'theme-immediate)))
diff --git a/lisp/desktop.el b/lisp/desktop.el
index 50ee9d03b7e..163122a2d14 100644
--- a/lisp/desktop.el
+++ b/lisp/desktop.el
@@ -1,6 +1,6 @@
 ;;; desktop.el --- save partial status of Emacs when killed
 
-;; Copyright (C) 1993, 1994, 1995, 1997, 2000, 2001
+;; Copyright (C) 1993, 1994, 1995, 1997, 2000, 2001, 2005
 ;;   Free Software Foundation, Inc.
 
 ;; Author: Morten Welinder <terra@diku.dk>
@@ -198,7 +198,7 @@ Feature: Saving `kill-ring' implies saving `kill-ring-yank-pointer'."
     search-ring-yank-pointer
     regexp-search-ring
     regexp-search-ring-yank-pointer)
-  "List of global variables to clear by `desktop-clear'.
+  "List of global variables that `desktop-clear' will clear.
 An element may be variable name (a symbol) or a cons cell of the form
 \(VAR . FORM). Symbols are set to nil and for cons cells VAR is set
 to the value obtained by evaluateing FORM."
@@ -267,6 +267,27 @@ Possible values are:
   :group 'desktop
   :version "21.4")
 
+(defcustom desktop-restore-eager t
+  "Number of buffers to restore immediately.
+Remaining buffers are restored lazily (when Emacs is idle).
+If value is t, all buffers are restored immediately."
+  :type '(choice (const t) integer)
+  :group 'desktop
+  :version "21.4")
+
+(defcustom desktop-lazy-verbose t
+  "Verbose reporting of lazily created buffers."
+  :type 'boolean
+  :group 'desktop
+  :version "21.4")
+
+(defcustom desktop-lazy-idle-delay 5
+  "Idle delay before starting to create buffers.
+See `desktop-restore-eager'."
+  :type 'integer
+  :group 'desktop
+  :version "21.4")
+
 ;;;###autoload
 (defvar desktop-save-buffer nil
   "When non-nil, save buffer status in desktop file.
@@ -365,6 +386,7 @@ This kills all buffers except for internal ones and those matching
 `desktop-clear-preserve-buffers'.  Furthermore, it clears the
 variables listed in `desktop-globals-to-clear'."
   (interactive)
+  (desktop-lazy-abort)
   (dolist (var desktop-globals-to-clear)
     (if (symbolp var)
       (eval `(setq-default ,var nil))
@@ -625,12 +647,13 @@ See also `desktop-base-file-name'."
                         (setq locals (cdr locals)))
                       ll)))
               (buffer-list)))
+          (eager desktop-restore-eager)
           (buf (get-buffer-create "*desktop*")))
       (set-buffer buf)
       (erase-buffer)
 
       (insert
-        ";; -*- coding: utf-8-emacs; -*-\n"
+        ";; -*- mode: emacs-lisp; coding: utf-8-emacs; -*-\n"
         desktop-header
         ";; Created " (current-time-string) "\n"
         ";; Desktop file format version " desktop-file-version "\n"
@@ -645,14 +668,21 @@ See also `desktop-base-file-name'."
 
       (insert "\n;; Buffer section -- buffers listed in same order as in buffer list:\n")
       (mapc #'(lambda (l)
-                (if (apply 'desktop-save-buffer-p l)
-                    (progn
-                      (insert "(desktop-create-buffer " desktop-file-version)
-                      (mapc #'(lambda (e)
-                                (insert "\n  " (desktop-value-to-string e)))
-                            l)
-                      (insert ")\n\n"))))
-            info)
+                (when (apply 'desktop-save-buffer-p l)
+                  (insert "("
+                          (if (or (not (integerp eager))
+                                  (unless (zerop eager)
+                                    (setq eager (1- eager))
+                                    t))
+                              "desktop-create-buffer"
+                            "desktop-append-buffer-args")
+                          " "
+                          desktop-file-version)
+                  (mapc #'(lambda (e)
+                            (insert "\n  " (desktop-value-to-string e)))
+                        l)
+                  (insert ")\n\n")))
+            info)
       (setq default-directory dirname)
       (when (file-exists-p filename) (delete-file filename))
       (let ((coding-system-for-write 'utf-8-emacs))
@@ -670,6 +700,11 @@ This function also sets `desktop-dirname' to nil."
       (when (file-exists-p filename)
         (delete-file filename)))))
 
+(defvar desktop-buffer-args-list nil
+  "List of args for `desktop-create-buffer'.")
+
+(defvar desktop-lazy-timer nil)
+
 ;; ----------------------------------------------------------------------------
 ;;;###autoload
 (defun desktop-read (&optional dirname)
@@ -706,6 +741,7 @@ It returns t if a desktop file was loaded, nil otherwise."
       (let ((desktop-first-buffer nil)
             (desktop-buffer-ok-count 0)
             (desktop-buffer-fail-count 0))
+        (setq desktop-lazy-timer nil)
         ;; Evaluate desktop buffer.
         (load (expand-file-name desktop-base-file-name desktop-dirname) t t t)
         ;; `desktop-create-buffer' puts buffers at end of the buffer list.
@@ -717,11 +753,15 @@ It returns t if a desktop file was loaded, nil otherwise."
         (run-hooks 'desktop-delay-hook)
         (setq desktop-delay-hook nil)
         (run-hooks 'desktop-after-read-hook)
-        (message "Desktop: %d buffer%s restored%s."
+        (message "Desktop: %d buffer%s restored%s%s."
                  desktop-buffer-ok-count
                  (if (= 1 desktop-buffer-ok-count) "" "s")
                  (if (< 0 desktop-buffer-fail-count)
                      (format ", %d failed to restore" desktop-buffer-fail-count)
+                   "")
+                 (if desktop-buffer-args-list
+                     (format ", %d to restore lazily"
+                             (length desktop-buffer-args-list))
                    ""))
         t)
       ;; No desktop file found.
@@ -917,6 +957,69 @@ directory DIRNAME."
                                (cons 'case-replace cr)
                                (cons 'overwrite-mode (car mim)))))
 
+(defun desktop-append-buffer-args (&rest args)
+  "Append ARGS at end of `desktop-buffer-args-list'
+ARGS must be an argument list for `desktop-create-buffer'."
+  (setq desktop-buffer-args-list (nconc desktop-buffer-args-list (list args)))
+  (unless desktop-lazy-timer
+    (setq desktop-lazy-timer
+          (run-with-idle-timer desktop-lazy-idle-delay t 'desktop-idle-create-buffers))))
+
+(defun desktop-lazy-create-buffer ()
+  "Pop args from `desktop-buffer-args-list', create buffer and bury it."
+  (when desktop-buffer-args-list
+    (let* ((remaining (length desktop-buffer-args-list))
+           (args (pop desktop-buffer-args-list))
+           (buffer-name (nth 2 args))
+           (msg (format "Desktop lazily opening %s (%s remaining)..."
+                            buffer-name remaining)))
+      (when desktop-lazy-verbose
+        (message msg))
+      (let ((desktop-first-buffer nil)
+            (desktop-buffer-ok-count 0)
+            (desktop-buffer-fail-count 0))
+        (apply 'desktop-create-buffer args)
+        (run-hooks 'desktop-delay-hook)
+        (setq desktop-delay-hook nil)
+        (bury-buffer (get-buffer buffer-name))
+        (when desktop-lazy-verbose
+          (message "%s%s" msg (if (> desktop-buffer-ok-count 0) "done" "failed")))))))
+
+(defun desktop-idle-create-buffers ()
+  "Create buffers until the user does something, then stop.
+If there are no buffers left to create, kill the timer."
+  (let ((repeat 1))
+    (while (and repeat desktop-buffer-args-list)
+      (save-window-excursion
+        (desktop-lazy-create-buffer))
+      (setq repeat (sit-for 0.2))
+    (unless desktop-buffer-args-list
+      (cancel-timer desktop-lazy-timer)
+      (setq desktop-lazy-timer nil)
+      (message "Lazy desktop load complete")
+      (sit-for 3)
+      (message "")))))
+
+(defun desktop-lazy-complete ()
+  "Run the desktop load to completion."
+  (interactive)
+  (let ((desktop-lazy-verbose t))
+    (while desktop-buffer-args-list
+      (save-window-excursion
+        (desktop-lazy-create-buffer)))
+    (message "Lazy desktop load complete")))
+
+(defun desktop-lazy-abort ()
+  "Abort lazy loading of the desktop."
+  (interactive)
+  (when desktop-lazy-timer
+    (cancel-timer desktop-lazy-timer)
+    (setq desktop-lazy-timer nil))
+  (when desktop-buffer-args-list
+    (setq desktop-buffer-args-list nil)
+    (when (interactive-p)
+      (message "Lazy desktop load aborted"))))
+
 ;; ----------------------------------------------------------------------------
 ;; When `desktop-save-mode' is non-nil and "--no-desktop" is not specified on the
 ;; command line, we do the rest of what it takes to use desktop, but do it
diff --git a/lisp/ebuff-menu.el b/lisp/ebuff-menu.el
index 2bfbace4c4b..bfac2afe6e9 100644
--- a/lisp/ebuff-menu.el
+++ b/lisp/ebuff-menu.el
@@ -149,7 +149,9 @@ Letters do not insert themselves; instead, they are commands.
 
 Entry to this mode via command `electric-buffer-list' calls the value of
 `electric-buffer-menu-mode-hook'."
-  (kill-all-local-variables)
+  (let ((saved header-line-format))
+    (kill-all-local-variables)
+    (setq header-line-format saved))
   (use-local-map electric-buffer-menu-mode-map)
   (setq mode-name "Electric Buffer Menu")
   (setq mode-line-buffer-identification "Electric Buffer List")
diff --git a/lisp/electric.el b/lisp/electric.el
index 3d2bf140c8c..18a4d8388c5 100644
--- a/lisp/electric.el
+++ b/lisp/electric.el
@@ -144,31 +144,17 @@
          (buf (get-buffer buffer))
          (one-window (one-window-p t))
          (pop-up-windows t)
-         (pop-up-frames nil)
-         (target-height)
-         (lines))
+         (pop-up-frames nil))
     (if (not buf)
         (error "Buffer %s does not exist" buffer)
-      (with-current-buffer buf
-        (setq lines (count-lines (point-min) (point-max)))
-        (setq target-height
-              (min (max (if max-height (min max-height (1+ lines)) (1+ lines))
-                        window-min-height)
-                   (save-window-excursion
-                     (delete-other-windows)
-                     (1- (window-height (selected-window)))))))
       (cond ((and (eq (window-buffer win) buf))
              (select-window win))
             (one-window
              (pop-to-buffer buffer)
-             (setq win (selected-window))
-             (enlarge-window (- target-height (window-height win))))
+             (setq win (selected-window)))
             (t
              (switch-to-buffer buf)))
-      (if (and (not max-height)
-               (> target-height (window-height (selected-window))))
-          (progn (goto-char (window-start win))
-                 (enlarge-window (- target-height (window-height win)))))
+      (fit-window-to-buffer win max-height)
       (goto-char (point-min))
       win)))
 
diff --git a/lisp/emacs-lisp/autoload.el b/lisp/emacs-lisp/autoload.el
index 196786e9179..0a75a43827e 100644
--- a/lisp/emacs-lisp/autoload.el
+++ b/lisp/emacs-lisp/autoload.el
@@ -135,7 +135,7 @@ or macro definition or a defcustom)."
 
 
 (defun autoload-trim-file-name (file)
-  ;; Returns a relative pathname of FILE
+  ;; Returns a relative file path for FILE
   ;; starting from the directory that loaddefs.el is in.
   ;; That is normally a directory in load-path,
   ;; which means Emacs will be able to find FILE when it looks.
@@ -273,7 +273,7 @@ are used."
         output-end)
 
     ;; If the autoload section we create here uses an absolute
-    ;; pathname for FILE in its header, and then Emacs is installed
+    ;; file name for FILE in its header, and then Emacs is installed
     ;; under a different path on another system,
     ;; `update-autoloads-here' won't be able to find the files to be
     ;; autoloaded.  So, if FILE is in the same directory or a
diff --git a/lisp/emacs-lisp/elint.el b/lisp/emacs-lisp/elint.el
index 9454bfc9da3..d4967a7cd06 100644
--- a/lisp/emacs-lisp/elint.el
+++ b/lisp/emacs-lisp/elint.el
@@ -29,7 +29,7 @@
 ;; mispellings and undefined variables, although it can also catch
 ;; function calls with the wrong number of arguments.
 
-;; Before using, call `elint-initialize' to set up som argument
+;; Before using, call `elint-initialize' to set up some argument
 ;; data. This takes a while. Then call elint-current-buffer or
 ;; elint-defun to lint a buffer or a defun.
 
diff --git a/lisp/emacs-lisp/find-func.el b/lisp/emacs-lisp/find-func.el
index a70adb4d423..7e2ac5aa883 100644
--- a/lisp/emacs-lisp/find-func.el
+++ b/lisp/emacs-lisp/find-func.el
@@ -1,6 +1,6 @@
 ;;; find-func.el --- find the definition of the Emacs Lisp function near point
 
-;; Copyright (C) 1997, 1999, 2001, 2004  Free Software Foundation, Inc.
+;; Copyright (C) 1997, 1999, 2001, 2004, 2005  Free Software Foundation, Inc.
 
 ;; Author: Jens Petersen <petersen@kurims.kyoto-u.ac.jp>
 ;; Maintainer: petersen@kurims.kyoto-u.ac.jp
@@ -76,16 +76,37 @@ Please send improvements and fixes to the maintainer."
   :version "21.1")
 
 (defcustom find-variable-regexp
-  (concat"^\\s-*(def[^umag]\\(\\w\\|\\s_\\)+\\*?" find-function-space-re "%s\\(\\s-\\|$\\)")
+  (concat"^\\s-*(def[^fumag]\\(\\w\\|\\s_\\)+\\*?" find-function-space-re "%s\\(\\s-\\|$\\)")
   "The regexp used by `find-variable' to search for a variable definition.
-It should match right up to the variable name.  The default value
-avoids `defun', `defmacro', `defalias', `defadvice', `defgroup'.
+Note it must contain a `%s' at the place where `format'
+should insert the variable name.  The default value
+avoids `defun', `defmacro', `defalias', `defadvice', `defgroup', `defface'.
 
 Please send improvements and fixes to the maintainer."
   :type 'regexp
   :group 'find-function
   :version "21.1")
 
+(defcustom find-face-regexp
+  (concat"^\\s-*(defface" find-function-space-re "%s\\(\\s-\\|$\\)")
+  "The regexp used by `find-face' to search for a face definition.
+Note it must contain a `%s' at the place where `format'
+should insert the face name.
+
+Please send improvements and fixes to the maintainer."
+  :type 'regexp
+  :group 'find-function
+  :version "21.4")
+
+(defvar find-function-regexp-alist
+  '((nil . find-function-regexp)
+    (defvar . find-variable-regexp)
+    (defface . find-face-regexp))
+  "Alist mapping definition types into regexp variables.
+Each regexp variable's value should actually be a format string
+to be used to substitute the desired symbol name into the regexp.")
+(put 'find-function-regexp-alist 'risky-local-variable t)
+
 (defcustom find-function-source-path nil
   "The default list of directories where `find-function' searches.
 
@@ -136,9 +157,9 @@ See the functions `find-function' and `find-variable'."
 If nil, do not try to find the source code of functions and variables
 defined in C.")
 
-(defun find-function-C-source (fun-or-var file variable-p)
+(defun find-function-C-source (fun-or-var file type)
   "Find the source location where SUBR-OR-VAR is defined in FILE.
-VARIABLE-P should be non-nil for a variable or nil for a subroutine."
+TYPE should be nil to find a function, or `defvar' to find a variable."
   (unless find-function-C-source-directory
     (setq find-function-C-source-directory
           (read-directory-name "Emacs C source dir: " nil nil t)))
@@ -146,12 +167,12 @@ VARIABLE-P should be non-nil for a variable or nil for a subroutine."
   (unless (file-readable-p file)
     (error "The C source file %s is not available"
            (file-name-nondirectory file)))
-  (unless variable-p
+  (unless type
     (setq fun-or-var (indirect-function fun-or-var)))
   (with-current-buffer (find-file-noselect file)
     (goto-char (point-min))
     (unless (re-search-forward
-             (if variable-p
+             (if type
                  (concat "DEFVAR[A-Z_]*[ \t\n]*([ \t\n]*\""
                          (regexp-quote (symbol-name fun-or-var))
                          "\"")
@@ -175,10 +196,12 @@ VARIABLE-P should be non-nil for a variable or nil for a subroutine."
     (condition-case nil (switch-to-buffer buf) (error (pop-to-buffer buf)))))
 
 ;;;###autoload
-(defun find-function-search-for-symbol (symbol variable-p library)
-  "Search for SYMBOL.
-If VARIABLE-P is nil, `find-function-regexp' is used, otherwise
-`find-variable-regexp' is used.  The search is done in library LIBRARY."
+(defun find-function-search-for-symbol (symbol type library)
+  "Search for SYMBOL's definition of type TYPE in LIBRARY.
+If TYPE is nil, look for a function definition.
+Otherwise, TYPE specifies the kind of definition,
+and it is interpreted via `find-function-regexp-alist'.
+The search is done in the source for library LIBRARY."
   (if (null library)
       (error "Don't know where `%s' is defined" symbol))
   ;; Some functions are defined as part of the construct
@@ -186,14 +209,13 @@ If VARIABLE-P is nil, `find-function-regexp' is used, otherwise
   (while (and (symbolp symbol) (get symbol 'definition-name))
     (setq symbol (get symbol 'definition-name)))
   (if (string-match "\\`src/\\(.*\\.c\\)\\'" library)
-      (find-function-C-source symbol (match-string 1 library) variable-p)
+      (find-function-C-source symbol (match-string 1 library) type)
     (if (string-match "\\.el\\(c\\)\\'" library)
         (setq library (substring library 0 (match-beginning 1))))
-    (let* ((filename (find-library-name library)))
+    (let* ((filename (find-library-name library))
+           (regexp-symbol (cdr (assq type find-function-regexp-alist))))
       (with-current-buffer (find-file-noselect filename)
-        (let ((regexp (format (if variable-p
-                                  find-variable-regexp
-                                find-function-regexp)
+        (let ((regexp (format (symbol-value regexp-symbol)
                               (regexp-quote (symbol-name symbol))))
               (case-fold-search))
           (with-syntax-table emacs-lisp-mode-syntax-table
@@ -245,55 +267,53 @@ in `load-path'."
                  ((symbol-file function 'defun)))))
       (find-function-search-for-symbol function nil library))))
 
-(defalias 'function-at-point 'function-called-at-point)
-
-(defun find-function-read (&optional variable-p)
+(defun find-function-read (&optional type)
   "Read and return an interned symbol, defaulting to the one near point.
 
-If the optional VARIABLE-P is nil, then a function is gotten
-defaulting to the value of the function `function-at-point', otherwise
-a variable is asked for, with the default coming from
-`variable-at-point'."
-  (let ((symb (funcall (if variable-p
-                           'variable-at-point
-                         'function-at-point)))
+If TYPE is nil, insist on a symbol with a function definition.
+Otherwise TYPE should be `defvar' or `defface'.
+If TYPE is nil, defaults using `function-called-at-point',
+otherwise uses `variable-at-point'."
+  (let ((symb (if (null type)
+                  (function-called-at-point)
+                (if (eq type 'defvar)
+                    (variable-at-point)
+                  (variable-at-point t))))
+        (predicate (cdr (assq type '((nil . fboundp) (defvar . boundp)
+                                     (defface . facep)))))
+        (prompt (cdr (assq type '((nil . "function") (defvar . "variable")
+                                  (defface . "face")))))
         (enable-recursive-minibuffers t)
         val)
     (if (equal symb 0)
         (setq symb nil))
-    (setq val (if variable-p
-                  (completing-read
-                   (concat "Find variable"
-                           (if symb
-                               (format " (default %s)" symb))
-                           ": ")
-                   obarray 'boundp t nil)
-                (completing-read
-                 (concat "Find function"
-                         (if symb
-                             (format " (default %s)" symb))
-                         ": ")
-                 obarray 'fboundp t nil)))
+    (setq val (completing-read
+               (concat "Find "
+                       prompt
+                       (if symb
+                           (format " (default %s)" symb))
+                       ": ")
+               obarray predicate t nil))
     (list (if (equal val "")
               symb
             (intern val)))))
 
-(defun find-function-do-it (symbol variable-p switch-fn)
+(defun find-function-do-it (symbol type switch-fn)
   "Find Emacs Lisp SYMBOL in a buffer and display it.
-If VARIABLE-P is nil, a function definition is searched for, otherwise
-a variable definition is searched for.  The start of a definition is
-centered according to the variable `find-function-recenter-line'.
-See also `find-function-after-hook'  It is displayed with function SWITCH-FN.
+TYPE is nil to search for a function definition,
+or else `defvar' or `defface'.
+
+The variable `find-function-recenter-line' controls how
+to recenter the display.  SWITCH-FN is the function to call
+to display and select the buffer.
+See also `find-function-after-hook'.
 
-Point is saved in the buffer if it is one of the current buffers."
+Set mark before moving, if the buffer already existed."
   (let* ((orig-point (point))
         (orig-buf (window-buffer))
         (orig-buffers (buffer-list))
         (buffer-point (save-excursion
-                        (funcall (if variable-p
-                                      'find-variable-noselect
-                                    'find-function-noselect)
-                                  symbol)))
+                        (find-definition-noselect symbol type)))
         (new-buf (car buffer-point))
         (new-point (cdr buffer-point)))
     (when buffer-point
@@ -309,9 +329,9 @@ Point is saved in the buffer if it is one of the current buffers."
   "Find the definition of the FUNCTION near point.
 
 Finds the Emacs Lisp library containing the definition of the function
-near point (selected by `function-at-point') in a buffer and
-places point before the definition.  Point is saved in the buffer if
-it is one of the current buffers.
+near point (selected by `function-called-at-point') in a buffer and
+places point before the definition.
+Set mark before moving, if the buffer already existed.
 
 The library where FUNCTION is defined is searched for in
 `find-function-source-path', if non nil, otherwise in `load-path'.
@@ -340,15 +360,15 @@ See `find-function' for more details."
   "Return a pair `(BUFFER . POINT)' pointing to the definition of SYMBOL.
 
 Finds the Emacs Lisp library containing the definition of SYMBOL
-in a buffer and the point of the definition.  The buffer is
-not selected.
+in a buffer, and the point of the definition.  It does not switch
+to the buffer or display it.
 
 The library where VARIABLE is defined is searched for in FILE or
 `find-function-source-path', if non nil, otherwise in `load-path'."
   (if (not variable)
       (error "You didn't specify a variable"))
   (let ((library (or file (symbol-file variable 'defvar))))
-    (find-function-search-for-symbol variable 'variable library)))
+    (find-function-search-for-symbol variable 'defvar library)))
 
 ;;;###autoload
 (defun find-variable (variable)
@@ -356,35 +376,70 @@ The library where VARIABLE is defined is searched for in FILE or
 
 Finds the Emacs Lisp library containing the definition of the variable
 near point (selected by `variable-at-point') in a buffer and
-places point before the definition.  Point is saved in the buffer if
-it is one of the current buffers.
+places point before the definition.
+
+Set mark before moving, if the buffer already existed.
 
 The library where VARIABLE is defined is searched for in
 `find-function-source-path', if non nil, otherwise in `load-path'.
 See also `find-function-recenter-line' and `find-function-after-hook'."
-  (interactive (find-function-read 'variable))
-  (find-function-do-it variable t 'switch-to-buffer))
+  (interactive (find-function-read 'defvar))
+  (find-function-do-it variable 'defvar 'switch-to-buffer))
 
 ;;;###autoload
 (defun find-variable-other-window (variable)
   "Find, in another window, the definition of VARIABLE near point.
 
 See `find-variable' for more details."
-  (interactive (find-function-read 'variable))
-  (find-function-do-it variable t 'switch-to-buffer-other-window))
+  (interactive (find-function-read 'defvar))
+  (find-function-do-it variable 'defvar 'switch-to-buffer-other-window))
 
 ;;;###autoload
 (defun find-variable-other-frame (variable)
   "Find, in annother frame, the definition of VARIABLE near point.
 
 See `find-variable' for more details."
-  (interactive (find-function-read 'variable))
-  (find-function-do-it variable t 'switch-to-buffer-other-frame))
+  (interactive (find-function-read 'defvar))
+  (find-function-do-it variable 'defvar 'switch-to-buffer-other-frame))
+
+;;;###autoload
+(defun find-definition-noselect (symbol type &optional file)
+  "Return a pair `(BUFFER . POINT)' pointing to the definition of SYMBOL.
+TYPE says what type of definition: nil for a function,
+`defvar' or `defface' for a variable or face.  This functoin
+does not switch to the buffer or display it.
+
+The library where SYMBOL is defined is searched for in FILE or
+`find-function-source-path', if non nil, otherwise in `load-path'."
+  (if (not symbol)
+      (error "You didn't specify a symbol"))
+  (if (null type)
+      (find-function-noselect symbol)
+    (let ((library (or file (symbol-file symbol type))))
+      (find-function-search-for-symbol symbol type library))))
+
+;; For symmetry, this should be called find-face; but some programs
+;; assume that, if that name is defined, it means something else.
+;;;###autoload
+(defun find-face-definition (face)
+  "Find the definition of FACE.  FACE defaults to the name near point.
+
+Finds the Emacs Lisp library containing the definition of the face
+near point (selected by `variable-at-point') in a buffer and
+places point before the definition.
+
+Set mark before moving, if the buffer already existed.
+
+The library where FACE is defined is searched for in
+`find-function-source-path', if non nil, otherwise in `load-path'.
+See also `find-function-recenter-line' and `find-function-after-hook'."
+  (interactive (find-function-read 'defface))
+  (find-function-do-it face 'defface 'switch-to-buffer))
 
 ;;;###autoload
 (defun find-function-on-key (key)
   "Find the function that KEY invokes.  KEY is a string.
-Point is saved if FUNCTION is in the current buffer."
+Set mark before moving, if the buffer already existed."
   (interactive "kFind function on key: ")
   (let (defn)
     (save-excursion
@@ -412,7 +467,7 @@ Point is saved if FUNCTION is in the current buffer."
 (defun find-function-at-point ()
   "Find directly the function at point in the other window."
   (interactive)
-  (let ((symb (function-at-point)))
+  (let ((symb (function-called-at-point)))
     (when symb
       (find-function-other-window symb))))
 
@@ -437,5 +492,5 @@ Point is saved if FUNCTION is in the current buffer."
 
 (provide 'find-func)
 
-;;; arch-tag: 43ecd81c-74dc-4d9a-8f63-a61e55670d64
+;; arch-tag: 43ecd81c-74dc-4d9a-8f63-a61e55670d64
 ;;; find-func.el ends here
diff --git a/lisp/emacs-lisp/lisp-mnt.el b/lisp/emacs-lisp/lisp-mnt.el
index 671f3c8ce2a..701da1c4dec 100644
--- a/lisp/emacs-lisp/lisp-mnt.el
+++ b/lisp/emacs-lisp/lisp-mnt.el
@@ -304,9 +304,14 @@ If FILE is nil, execute BODY in the current buffer."
        (if ,filesym
            (with-temp-buffer
              (insert-file-contents ,filesym)
+             (lisp-mode)
              ,@body)
          (save-excursion 
-           ,@body)))))
+           ;; Switching major modes is too drastic, so just switch
+           ;; temporarily to the Lisp mode syntax table.
+           (with-syntax-table lisp-mode-syntax-table
+             ,@body))))))
+
 (put 'lm-with-file 'lisp-indent-function 1)
 (put 'lm-with-file 'edebug-form-spec t)
 
diff --git a/lisp/emacs-lisp/lisp-mode.el b/lisp/emacs-lisp/lisp-mode.el
index f4364c38e8d..f181f3683f0 100644
--- a/lisp/emacs-lisp/lisp-mode.el
+++ b/lisp/emacs-lisp/lisp-mode.el
@@ -1125,7 +1125,8 @@ ENDPOS is encountered."
       (set-marker endmark nil))))
 
 (defun indent-pp-sexp (&optional arg)
-  "Indent each line of the list or, with prefix ARG, pretty-printify the list."
+  "Indent each line of the list starting just after point, or prettyprint it.
+A prefix argument specifies pretty-printing."
   (interactive "P")
   (if arg
       (save-excursion
diff --git a/lisp/emacs-lisp/re-builder.el b/lisp/emacs-lisp/re-builder.el
index 77a12167c30..019a45213c8 100644
--- a/lisp/emacs-lisp/re-builder.el
+++ b/lisp/emacs-lisp/re-builder.el
@@ -1,6 +1,6 @@
 ;;; re-builder.el --- building Regexps with visual feedback
 
-;; Copyright (C) 1999, 2000, 2001 Free Software Foundation, Inc.
+;; Copyright (C) 1999, 2000, 2001, 2002, 2004 Free Software Foundation, Inc.
 
 ;; Author: Detlev Zundel <dzu@gnu.org>
 ;; Keywords: matching, lisp, tools
@@ -61,12 +61,12 @@
 ;; even the auto updates go all the way.  Forcing an update overrides
 ;; this limit allowing an easy way to see all matches.
 
-;; Currently `re-builder' understands four different forms of input,
-;; namely `read', `string', `sregex' and `lisp-re' syntax.  Read
+;; Currently `re-builder' understands five different forms of input,
+;; namely `read', `string', `rx', `sregex' and `lisp-re' syntax.  Read
 ;; syntax and string syntax are both delimited by `"'s and behave
 ;; according to their name.  With the `string' syntax there's no need
 ;; to escape the backslashes and double quotes simplifying the editing
-;; somewhat.  The other two allow editing of symbolic regular
+;; somewhat.  The other three allow editing of symbolic regular
 ;; expressions supported by the packages of the same name.  (`lisp-re'
 ;; is a package by me and its support may go away as it is nearly the
 ;; same as the `sregex' package in Emacs)
diff --git a/lisp/facemenu.el b/lisp/facemenu.el
index c6cce457fe6..127b8fe608b 100644
--- a/lisp/facemenu.el
+++ b/lisp/facemenu.el
@@ -471,50 +471,81 @@ These special properties include `invisible', `intangible' and `read-only'."
       col)))
 
 ;;;###autoload
-(defun list-colors-display (&optional list)
+(defun list-colors-display (&optional list buffer-name)
   "Display names of defined colors, and show what they look like.
 If the optional argument LIST is non-nil, it should be a list of
-colors to display.  Otherwise, this command computes a list
-of colors that the current display can handle."
+colors to display.  Otherwise, this command computes a list of
+colors that the current display can handle.  If the optional
+argument BUFFER-NAME is nil, it defaults to *Colors*."
   (interactive)
   (when (and (null list) (> (display-color-cells) 0))
-    (setq list (defined-colors))
-    ;; Delete duplicate colors.
-
-    ;; Identify duplicate colors by the name rather than the color
-    ;; value.  For example, on MS-Windows, logical colors are added to
-    ;; the list that might have the same value but have different
-    ;; names and meanings.  For example, `SystemMenuText' (the color
-    ;; w32 uses for the text in menu entries) and `SystemWindowText'
-    ;; (the default color w32 uses for the text in windows and
-    ;; dialogs) may be the same display color and be adjacent in the
-    ;; list.  Detecting duplicates by name insures that both of these
-    ;; colors remain despite identical color values.
-    (let ((l list))
-      (while (cdr l)
-        (if (facemenu-color-name-equal (car l) (car (cdr l)))
-            (setcdr l (cdr (cdr l)))
-          (setq l (cdr l)))))
+    (setq list (list-colors-duplicates (defined-colors)))
     (when (memq (display-visual-class) '(gray-scale pseudo-color direct-color))
       ;; Don't show more than what the display can handle.
       (let ((lc (nthcdr (1- (display-color-cells)) list)))
         (if lc
             (setcdr lc nil)))))
-  (with-output-to-temp-buffer "*Colors*"
+  (with-output-to-temp-buffer (or buffer-name "*Colors*")
     (save-excursion
       (set-buffer standard-output)
-      (let (s)
-        (while list
-          (setq s (point))
-          (insert (car list))
-          (indent-to 20)
-          (put-text-property s (point) 'face
-                             (cons 'background-color (car list)))
-          (setq s (point))
-          (insert "  " (car list) "\n")
-          (put-text-property s (point) 'face
-                             (cons 'foreground-color (car list)))
-          (setq list (cdr list)))))))
+      (setq truncate-lines t)
+      (if temp-buffer-show-function
+          (list-colors-print list)
+        ;; Call list-colors-print from temp-buffer-show-hook
+        ;; to get the right value of window-width in list-colors-print
+        ;; after the buffer is displayed.
+        (add-hook 'temp-buffer-show-hook
+                  (lambda () (list-colors-print list)) nil t)))))
+
+(defun list-colors-print (list)
+  (dolist (color list)
+    (if (consp color)
+        (if (cdr color)
+            (setq color (sort color (lambda (a b)
+                                      (string< (downcase a)
+                                               (downcase b))))))
+      (setq color (list color)))
+    (put-text-property
+     (prog1 (point)
+       (insert (car color))
+       (indent-to 22))
+     (point)
+     'face (cons 'background-color (car color)))
+    (put-text-property
+     (prog1 (point)
+       (insert "  " (if (cdr color)
+                        (mapconcat 'identity (cdr color) ", ")
+                      (car color)))
+       (indent-to (max (- (window-width) 8) 44))
+       (insert (apply 'format " #%02x%02x%02x"
+                      (mapcar (lambda (c) (lsh c -8))
+                              (color-values (car color)))))
+
+       (insert "\n"))
+     (point)
+     'face (cons 'foreground-color (car color))))
+  (goto-char (point-min)))
+
+(defun list-colors-duplicates (&optional list)
+  "Return a list of colors with grouped duplicate colors.
+If a color has no duplicates, then the element of the returned list
+has the form '(COLOR-NAME).  The element of the returned list with
+duplicate colors has the form '(COLOR-NAME DUPLICATE-COLOR-NAME ...).
+This function uses the predicate `facemenu-color-equal' to compare
+color names.  If the optional argument LIST is non-nil, it should
+be a list of colors to display.  Otherwise, this function uses
+a list of colors that the current display can handle."
+  (let* ((list (mapcar 'list (or list (defined-colors))))
+         (l list))
+    (while (cdr l)
+      (if (and (facemenu-color-equal (car (car l)) (car (car (cdr l))))
+               (not (and (boundp 'w32-default-color-map)
+                         (not (assoc (car (car l)) w32-default-color-map)))))
+          (progn
+            (setcdr (car l) (cons (car (car (cdr l))) (cdr (car l))))
+            (setcdr l (cdr (cdr l))))
+        (setq l (cdr l))))
+    list))
 
 (defun facemenu-color-equal (a b)
   "Return t if colors A and B are the same color.
@@ -525,22 +556,6 @@ determine the correct answer."
   (cond ((equal a b) t)
         ((equal (color-values a) (color-values b)))))
 
-(defun facemenu-color-name-equal (a b)
-  "Return t if colors A and B are the same color.
-A and B should be strings naming colors.  These names are
-downcased, stripped of spaces and the string `grey' is turned
-into `gray'.  This accommodates alternative spellings of colors
-found commonly in the list.  It returns nil if the colors differ."
-  (progn
-    (setq a (replace-regexp-in-string "grey" "gray"
-            (replace-regexp-in-string " " ""
-             (downcase a)))
-         b (replace-regexp-in-string "grey" "gray"
-            (replace-regexp-in-string " " ""
-             (downcase b))))
-
-    (equal a b)))
-
 (defun facemenu-add-face (face &optional start end)
   "Add FACE to text between START and END.
 If START is nil or START to END is empty, add FACE to next typed character
diff --git a/lisp/files.el b/lisp/files.el
index cfee975066d..cdaa7a5adb8 100644
--- a/lisp/files.el
+++ b/lisp/files.el
@@ -1856,8 +1856,14 @@ mode function to use.  FUNCTION will be called, unless it is nil.
 
 If the element has the form (REGEXP FUNCTION NON-NIL), then after
 calling FUNCTION (if it's not nil), we delete the suffix that matched
-REGEXP and search the list again for another match.")
+REGEXP and search the list again for another match.
 
+If the file name matches `inhibit-first-line-modes-regexps',
+then `auto-mode-alist' is not processed.
+
+See also `interpreter-mode-alist', which detects executable script modes
+based on the interpreters they specify to run,
+and `magic-mode-alist', which determines modes based on file contents.")
 
 (defvar interpreter-mode-alist
   ;; Note: The entries for the modes defined in cc-mode.el (awk-mode
@@ -1902,11 +1908,13 @@ REGEXP and search the list again for another match.")
      ("guile" . scheme-mode)
      ("clisp" . lisp-mode)))
   "Alist mapping interpreter names to major modes.
-This alist applies to files whose first line starts with `#!'.
+This is used for files whose first lines match `auto-mode-interpreter-regexp'.
 Each element looks like (INTERPRETER . MODE).
 The car of each element is compared with
 the name of the interpreter specified in the first line.
-If it matches, mode MODE is selected.")
+If it matches, mode MODE is selected.
+
+See also `auto-mode-alist'.")
 
 (defvar inhibit-first-line-modes-regexps '("\\.tar\\'" "\\.tgz\\'")
   "List of regexps; if one matches a file name, don't look for `-*-'.")
@@ -1935,12 +1943,14 @@ with that interpreter in `interpreter-mode-alist'.")
         (concat "\\(?:<\\?xml\\s +[^>]*>\\)?\\s *<"
                 comment-re "*"
                 "\\(?:!DOCTYPE\\s +[^>]*>\\s *<\\s *" comment-re "*\\)?"
-                "[Hh][Tt][Mm][Ll]")) . html-mode)
+                "[Hh][Tt][Mm][Ll]"))
+     . html-mode)
     ;; These two must come after html, because they are more general:
     ("<\\?xml " . xml-mode)
     (,(let* ((incomment-re "\\(?:[^-]\\|-[^-]\\)")
              (comment-re (concat "\\(?:!--" incomment-re "*-->\\s *<\\)")))
-        (concat "\\s *<" comment-re "*!DOCTYPE ")) . sgml-mode)
+        (concat "\\s *<" comment-re "*!DOCTYPE "))
+     . sgml-mode)
     ("%![^V]" . ps-mode)
     ("# xmcd " . conf-unix-mode))
   "Alist of buffer beginnings vs. corresponding major mode functions.
@@ -2202,86 +2212,86 @@ is specified, returning t if it is specified."
     (save-excursion
       (goto-char (point-max))
       (search-backward "\n\^L" (max (- (point-max) 3000) (point-min)) 'move)
-      (if (let ((case-fold-search t))
-            (and (search-forward "Local Variables:" nil t)
-                 (or (eq enable-local-variables t)
-                     mode-only
-                     (and enable-local-variables
-                          (save-window-excursion
-                            (switch-to-buffer (current-buffer))
-                            (save-excursion
-                              (beginning-of-line)
-                              (set-window-start (selected-window) (point)))
-                            (y-or-n-p (format "Set local variables as specified at end of %s? "
-                                              (if buffer-file-name
-                                                  (file-name-nondirectory
-                                                   buffer-file-name)
-                                                (concat "buffer "
-                                                        (buffer-name))))))))))
-          (skip-chars-forward " \t")
-          (let ((enable-local-eval enable-local-eval)
-                ;; suffix is what comes after "local variables:" in its line.
-                (suffix
-                 (concat
-                  (regexp-quote (buffer-substring (point) (line-end-position)))
-                  "$"))
-                ;; prefix is what comes before "local variables:" in its line.
-                (prefix
-                 (concat "^" (regexp-quote
-                              (buffer-substring (line-beginning-position)
-                                                (match-beginning 0)))))
-                beg)
-
-            (forward-line 1)
-            (let ((startpos (point))
-                  endpos
-                  (thisbuf (current-buffer)))
-              (save-excursion
-                (if (not (re-search-forward
-                          (concat prefix "[ \t]*End:[ \t]*" suffix)
-                          nil t))
-                    (error "Local variables list is not properly terminated"))
-                (beginning-of-line)
-                (setq endpos (point)))
-
-              (with-temp-buffer
-                (insert-buffer-substring thisbuf startpos endpos)
-                (goto-char (point-min))
-                (subst-char-in-region (point) (point-max) ?\^m ?\n)
-                (while (not (eobp))
-                  ;; Discard the prefix.
-                  (if (looking-at prefix)
-                      (delete-region (point) (match-end 0))
-                    (error "Local variables entry is missing the prefix"))
-                  (end-of-line)
-                  ;; Discard the suffix.
-                  (if (looking-back suffix)
-                      (delete-region (match-beginning 0) (point))
-                    (error "Local variables entry is missing the suffix"))
-                  (forward-line 1))
-                (goto-char (point-min))
-
-                (while (not (eobp))
-                  ;; Find the variable name; strip whitespace.
-                  (skip-chars-forward " \t")
-                  (setq beg (point))
-                  (skip-chars-forward "^:\n")
-                  (if (eolp) (error "Missing colon in local variables entry"))
-                  (skip-chars-backward " \t")
-                  (let* ((str (buffer-substring beg (point)))
-                         (var (read str))
-                         val)
-                    ;; Read the variable value.
-                    (skip-chars-forward "^:")
-                    (forward-char 1)
-                    (setq val (read (current-buffer)))
-                    (if mode-only
-                        (if (eq var 'mode)
-                            (setq mode-specified t))
-                      ;; Set the variable.  "Variables" mode and eval are funny.
-                      (with-current-buffer thisbuf
-                        (hack-one-local-variable var val))))
-                  (forward-line 1)))))))
+      (when (let ((case-fold-search t))
+              (and (search-forward "Local Variables:" nil t)
+                   (or (eq enable-local-variables t)
+                       mode-only
+                       (and enable-local-variables
+                            (save-window-excursion
+                              (switch-to-buffer (current-buffer))
+                              (save-excursion
+                                (beginning-of-line)
+                                (set-window-start (selected-window) (point)))
+                              (y-or-n-p (format "Set local variables as specified at end of %s? "
+                                                (if buffer-file-name
+                                                    (file-name-nondirectory
+                                                     buffer-file-name)
+                                                  (concat "buffer "
+                                                          (buffer-name))))))))))
+        (skip-chars-forward " \t")
+        (let ((enable-local-eval enable-local-eval)
+              ;; suffix is what comes after "local variables:" in its line.
+              (suffix
+               (concat
+                (regexp-quote (buffer-substring (point) (line-end-position)))
+                "$"))
+              ;; prefix is what comes before "local variables:" in its line.
+              (prefix
+               (concat "^" (regexp-quote
+                            (buffer-substring (line-beginning-position)
+                                              (match-beginning 0)))))
+              beg)
+
+          (forward-line 1)
+          (let ((startpos (point))
+                endpos
+                (thisbuf (current-buffer)))
+            (save-excursion
+              (if (not (re-search-forward
+                        (concat prefix "[ \t]*End:[ \t]*" suffix)
+                        nil t))
+                  (error "Local variables list is not properly terminated"))
+              (beginning-of-line)
+              (setq endpos (point)))
+
+            (with-temp-buffer
+              (insert-buffer-substring thisbuf startpos endpos)
+              (goto-char (point-min))
+              (subst-char-in-region (point) (point-max) ?\^m ?\n)
+              (while (not (eobp))
+                ;; Discard the prefix.
+                (if (looking-at prefix)
+                    (delete-region (point) (match-end 0))
+                  (error "Local variables entry is missing the prefix"))
+                (end-of-line)
+                ;; Discard the suffix.
+                (if (looking-back suffix)
+                    (delete-region (match-beginning 0) (point))
+                  (error "Local variables entry is missing the suffix"))
+                (forward-line 1))
+              (goto-char (point-min))
+
+              (while (not (eobp))
+                ;; Find the variable name; strip whitespace.
+                (skip-chars-forward " \t")
+                (setq beg (point))
+                (skip-chars-forward "^:\n")
+                (if (eolp) (error "Missing colon in local variables entry"))
+                (skip-chars-backward " \t")
+                (let* ((str (buffer-substring beg (point)))
+                       (var (read str))
+                       val)
+                  ;; Read the variable value.
+                  (skip-chars-forward "^:")
+                  (forward-char 1)
+                  (setq val (read (current-buffer)))
+                  (if mode-only
+                      (if (eq var 'mode)
+                          (setq mode-specified t))
+                    ;; Set the variable.  "Variables" mode and eval are funny.
+                    (with-current-buffer thisbuf
+                      (hack-one-local-variable var val))))
+                (forward-line 1)))))))
     (unless mode-only
       (run-hooks 'hack-local-variables-hook))
     mode-specified))
@@ -3264,11 +3274,12 @@ Before and after saving the buffer, this function runs
 ;; but inhibited if one of write-file-functions returns non-nil.
 ;; It returns a value (MODES . BACKUPNAME), like backup-buffer.
 (defun basic-save-buffer-1 ()
-  (if save-buffer-coding-system
-      (let ((coding-system-for-write save-buffer-coding-system))
+  (prog1
+      (if save-buffer-coding-system
+          (let ((coding-system-for-write save-buffer-coding-system))
+            (basic-save-buffer-2))
         (basic-save-buffer-2))
-    (basic-save-buffer-2))
-  (setq buffer-file-coding-system-explicit last-coding-system-used))
+    (setq buffer-file-coding-system-explicit last-coding-system-used)))
 
 ;; This returns a value (MODES . BACKUPNAME), like backup-buffer.
 (defun basic-save-buffer-2 ()
@@ -4549,7 +4560,7 @@ normally equivalent short `-D' option is just passed on to
                     error-lines)
                 ;; Find all the lines that are error messages,
                 ;; and record the bounds of each one.
-                (goto-char (point-min))
+                (goto-char beg)
                 (while (< (point) linebeg)
                   (or (eql (following-char) ?\s)
                       (push (list (point) (line-end-position)) error-lines))
@@ -4575,11 +4586,9 @@ normally equivalent short `-D' option is just passed on to
                       (end-of-line))))
                 (goto-char end)
                 (beginning-of-line)
-                (delete-region (point) (progn (forward-line 2) (point))))
-              (forward-line 1)
+                (delete-region (point) (progn (forward-line 1) (point))))
               (if (looking-at "//DIRED-OPTIONS//")
-                  (delete-region (point) (progn (forward-line 1) (point)))
-                (forward-line 1))))
+                  (delete-region (point) (progn (forward-line 1) (point))))))
 
           ;; Now decode what read if necessary.
           (let ((coding (or coding-system-for-read
diff --git a/lisp/gnus/ChangeLog b/lisp/gnus/ChangeLog
index 46a1449ce79..4eee8bcbbfc 100644
--- a/lisp/gnus/ChangeLog
+++ b/lisp/gnus/ChangeLog
@@ -1,3 +1,8 @@
+2005-01-05  Reiner Steib  <Reiner.Steib@gmx.de>
+
+        * spam.el (spam-face): New face.  Don't use `gnus-splash-face'
+        which is unreadable in some setups.
+
 2004-12-27  Simon Josefsson  <jas@extundo.com>
 
         * mm-bodies.el (mm-body-encoding): Don't permit 7-bit to be used
diff --git a/lisp/gnus/spam.el b/lisp/gnus/spam.el
index a0b28340717..9a55ba9f318 100644
--- a/lisp/gnus/spam.el
+++ b/lisp/gnus/spam.el
@@ -298,7 +298,19 @@ All unmarked article in such group receive the spam mark on group entry."
   :type '(radio (const nil) regexp)
   :group 'spam)
 
-(defcustom spam-face 'gnus-splash-face
+(defface spam-face
+  '((((class color) (type tty) (background dark))
+     (:foreground "gray80" :background "gray50"))
+    (((class color) (type tty) (background light))
+     (:foreground "gray50" :background "gray80"))
+    (((class color) (background dark))
+     (:foreground "ivory2"))
+    (((class color) (background light))
+     (:foreground "ivory4"))
+    (t :inverse-video t))
+  "Face for spam-marked articles.")
+
+(defcustom spam-face 'spam-face
   "Face for spam-marked articles."
   :type 'face
   :group 'spam)
diff --git a/lisp/help-fns.el b/lisp/help-fns.el
index 522c1e2c19d..9acadaa2fa6 100644
--- a/lisp/help-fns.el
+++ b/lisp/help-fns.el
@@ -216,6 +216,14 @@ ARGLIST can also be t or a string of the form \"(FUN ARG1 ARG2 ...)\"."
                         (intern (upcase name))))))
                 arglist)))
 
+;;; Could be this, if we make symbol-file do the work below.
+;;; (defun help-C-file-name (subr-or-var kind)
+;;;   "Return the name of the C file where SUBR-OR-VAR is defined.
+;;; KIND should be `var' for a variable or `subr' for a subroutine."
+;;;   (symbol-file (if (symbolp subr-or-var) subr-or-var
+;;;              (subr-name subr-or-var))
+;;;            (if (eq kind 'var) 'defvar 'defun)))
+
 (defun help-C-file-name (subr-or-var kind)
   "Return the name of the C file where SUBR-OR-VAR is defined.
 KIND should be `var' for a variable or `subr' for a subroutine."
@@ -231,8 +239,8 @@ KIND should be `var' for a variable or `subr' for a subroutine."
       (let ((file (catch 'loop
                     (while t
                       (let ((pnt (search-forward (concat "" name "\n"))))
-      (re-search-backward "S\\(.*\\)")
-      (let ((file (match-string 1)))
+                        (re-search-backward "S\\(.*\\)")
+                        (let ((file (match-string 1)))
                           (if (member file build-files)
                               (throw 'loop file)
                             (goto-char pnt))))))))
@@ -463,9 +471,10 @@ face (according to `face-differs-from-default-p')."
 ;; Variables
 
 ;;;###autoload
-(defun variable-at-point ()
+(defun variable-at-point (&optional any-symbol)
   "Return the bound variable symbol found around point.
-Return 0 if there is no such symbol."
+Return 0 if there is no such symbol.
+If ANY-SYMBOL is non-nil, don't insist the symbol be bound."
   (or (condition-case ()
           (with-syntax-table emacs-lisp-mode-syntax-table
             (save-excursion
@@ -479,12 +488,12 @@ Return 0 if there is no such symbol."
         (error nil))
       (let* ((str (find-tag-default))
              (sym (if str (intern-soft str))))
-        (if (and sym (boundp sym))
+        (if (and sym (or any-symbol (boundp sym)))
             sym
           (save-match-data
             (when (and str (string-match "\\`\\W*\\(.*?\\)\\W*\\'" str))
               (setq sym (intern-soft (match-string 1 str)))
-              (and (boundp sym) sym)))))
+              (and (or any-symbol (boundp sym)) sym)))))
       0))
 
 ;;;###autoload
diff --git a/lisp/help-macro.el b/lisp/help-macro.el
index a36eed86d01..3a7cf0898cb 100644
--- a/lisp/help-macro.el
+++ b/lisp/help-macro.el
@@ -121,7 +121,7 @@ and then returns."
                      (if three-step-help
                          (progn
                            (setq key (let ((overriding-local-map local-map))
-                                     (read-key-sequence nil)))
+                                       (read-key-sequence nil)))
                            ;; Make the HELP key translate to C-h.
                            (if (lookup-key function-key-map key)
                                (setq key (lookup-key function-key-map key)))
diff --git a/lisp/imenu.el b/lisp/imenu.el
index af617498b07..6ee72a88bc4 100644
--- a/lisp/imenu.el
+++ b/lisp/imenu.el
@@ -532,7 +532,7 @@ A nested sub-alist element looks like (INDEX-NAME SUB-ALIST).")
         (push item keep-at-top)
         (setq menulist (delq item menulist))))
     (if imenu-sort-function
-        (setq menulist (sort menulist imenu-sort-function)))
+        (setq menulist (sort (copy-sequence menulist) imenu-sort-function)))
     (if (> (length menulist) imenu-max-items)
         (setq menulist
               (mapcar
@@ -817,32 +817,30 @@ depending on PATTERNS."
                 (setq start (point))
                 (goto-char (match-end index))
                 (setq beg (match-beginning index))
-                (goto-char beg)
+                ;; Go to the start of the match.
+                ;; That's the official position of this definition.
+                (goto-char start)
                 (imenu-progress-message prev-pos nil t)
                 ;; Add this sort of submenu only when we've found an
                 ;; item for it, avoiding empty, duff menus.
                 (unless (assoc menu-title index-alist)
                   (push (list menu-title) index-alist))
                 (if imenu-use-markers
-                    (setq beg (copy-marker beg)))
+                    (setq start (copy-marker start)))
                 (let ((item
                        (if function
                            (nconc (list (match-string-no-properties index)
-                                        beg function)
+                                        start function)
                                   rest)
                          (cons (match-string-no-properties index)
-                               beg)))
+                               start)))
                       ;; This is the desired submenu,
                       ;; starting with its title (or nil).
                       (menu (assoc menu-title index-alist)))
                   ;; Insert the item unless it is already present.
                   (unless (member item (cdr menu))
                     (setcdr menu
-                            (cons item (cdr menu)))))
-                ;; Move to the start of the entire match,
-                ;; to ensure we keep moving backwards
-                ;; as long as the match is nonempty.
-                (goto-char start))))
+                            (cons item (cdr menu))))))))
           (set-syntax-table old-table)))
     (imenu-progress-message prev-pos 100 t)
     ;; Sort each submenu by position.
diff --git a/lisp/info-look.el b/lisp/info-look.el
index bc886f0320c..4fc2c6b4c63 100644
--- a/lisp/info-look.el
+++ b/lisp/info-look.el
@@ -1,7 +1,7 @@
 ;;; info-look.el --- major-mode-sensitive Info index lookup facility
 ;; An older version of this was known as libc.el.
 
-;; Copyright (C) 1995,96,97,98,99,2001,03,04  Free Software Foundation, Inc.
+;; Copyright (C) 1995,96,97,98,99,2001,03,04,05  Free Software Foundation, Inc.
 
 ;; Author: Ralph Schleicher <rs@nunatak.allgaeu.org>
 ;;         (did not show signs of life (Nov 2001)  -stef)
@@ -634,8 +634,15 @@ Return nil if there is nothing appropriate in the buffer near point."
  :regexp "\\(struct \\|union \\|enum \\)?[_a-zA-Z][_a-zA-Z0-9]*"
  :doc-spec '(("(libc)Function Index" nil
               "^[ \t]+-+ \\(Function\\|Macro\\): .*\\<" "\\>")
+             ;; prefix/suffix has to match things like
+             ;;   " -- Macro: int F_DUPFD"
+             ;;   " -- Variable: char * tzname [2]"
+             ;;   "`DBL_MAX'"    (texinfo @table)
+             ;; suffix "\\>" is not used because that sends DBL_MAX to
+             ;; DBL_MAX_EXP ("_" is a non-word char)
              ("(libc)Variable Index" nil
-              "^[ \t]+-+ \\(Variable\\|Macro\\): .*\\<" "\\>")
+              "^\\([ \t]+-+ \\(Variable\\|Macro\\): .*\\<\\|`\\)"
+              "\\( \\|'?$\\)")
              ("(libc)Type Index" nil
               "^[ \t]+-+ Data Type: \\<" "\\>")
              ("(termcap)Var Index" nil
diff --git a/lisp/info.el b/lisp/info.el
index 750f302d422..4fcbdeb6330 100644
--- a/lisp/info.el
+++ b/lisp/info.el
@@ -47,6 +47,10 @@
   "Stack of info nodes user has visited.
 Each element of list is a list (FILENAME NODENAME BUFFERPOS).")
 
+(defvar Info-history-forward nil
+  "Stack of info nodes user has visited with `Info-history-back' command.
+Each element of list is a list (FILENAME NODENAME BUFFERPOS).")
+
 (defvar Info-history-list nil
   "List of all info nodes user has visited.
 Each element of list is a list (FILENAME NODENAME).")
@@ -1295,7 +1299,8 @@ any double quotes or backslashes must be escaped (\\\",\\\\)."
         ;; Add a new unique history item to full history list
         (let ((new-history (list Info-current-file Info-current-node)))
           (setq Info-history-list
-                (cons new-history (delete new-history Info-history-list))))
+                (cons new-history (delete new-history Info-history-list)))
+          (setq Info-history-forward nil))
         (if (not (eq Info-fontify-maximum-menu-size nil))
             (Info-fontify-node))
         (Info-display-images-node)
@@ -1731,18 +1736,38 @@ If SAME-FILE is non-nil, do not move to a different Info file."
       (goto-char p)
       (Info-restore-point Info-history))))
 
-(defun Info-last ()
-  "Go back to the last node visited."
+(defun Info-history-back ()
+  "Go back in the history to the last node visited."
   (interactive)
   (or Info-history
       (error "This is the first Info node you looked at"))
-  (let (filename nodename opoint)
+  (let ((history-forward
+         (cons (list Info-current-file Info-current-node (point))
+               Info-history-forward))
+        filename nodename opoint)
     (setq filename (car (car Info-history)))
     (setq nodename (car (cdr (car Info-history))))
     (setq opoint (car (cdr (cdr (car Info-history)))))
     (setq Info-history (cdr Info-history))
     (Info-find-node filename nodename)
     (setq Info-history (cdr Info-history))
+    (setq Info-history-forward history-forward)
+    (goto-char opoint)))
+
+(defalias 'Info-last 'Info-history-back)
+
+(defun Info-history-forward ()
+  "Go forward in the history of visited nodes."
+  (interactive)
+  (or Info-history-forward
+      (error "This is the last Info node you looked at"))
+  (let ((history-forward (cdr Info-history-forward))
+        filename nodename opoint)
+    (setq filename (car (car Info-history-forward)))
+    (setq nodename (car (cdr (car Info-history-forward))))
+    (setq opoint (car (cdr (cdr (car Info-history-forward)))))
+    (Info-find-node filename nodename)
+    (setq Info-history-forward history-forward)
     (goto-char opoint)))
 
 ;;;###autoload
@@ -2894,12 +2919,13 @@ if point is in a menu item description, follow that menu item."
   (define-key Info-mode-map "g" 'Info-goto-node)
   (define-key Info-mode-map "h" 'Info-help)
   (define-key Info-mode-map "i" 'Info-index)
-  (define-key Info-mode-map "l" 'Info-last)
+  (define-key Info-mode-map "l" 'Info-history-back)
   (define-key Info-mode-map "L" 'Info-history)
   (define-key Info-mode-map "m" 'Info-menu)
   (define-key Info-mode-map "n" 'Info-next)
   (define-key Info-mode-map "p" 'Info-prev)
   (define-key Info-mode-map "q" 'Info-exit)
+  (define-key Info-mode-map "r" 'Info-history-forward)
   (define-key Info-mode-map "s" 'Info-search)
   (define-key Info-mode-map "S" 'Info-search-case-sensitively)
   ;; For consistency with Rmail.
@@ -2913,6 +2939,7 @@ if point is in a menu item description, follow that menu item."
   (define-key Info-mode-map "," 'Info-index-next)
   (define-key Info-mode-map "\177" 'Info-scroll-down)
   (define-key Info-mode-map [mouse-2] 'Info-mouse-follow-nearest-node)
+  (define-key Info-mode-map [follow-link] 'mouse-face)
   )
 
 (defun Info-check-pointer (item)
@@ -2951,8 +2978,10 @@ if point is in a menu item description, follow that menu item."
     :help "Search for another occurrence of regular expression"]
    ["Go to Node..." Info-goto-node
     :help "Go to a named node"]
-   ["Last" Info-last :active Info-history
-    :help "Go to the last node you were at"]
+   ["Back in history" Info-history-back :active Info-history
+    :help "Go back in history to the last node you were at"]
+   ["Forward in history" Info-history-forward :active Info-history-forward
+    :help "Go forward in history"]
    ["History" Info-history :active Info-history-list
     :help "Go to menu of visited nodes"]
    ["Table of Contents" Info-toc
@@ -2980,7 +3009,8 @@ if point is in a menu item description, follow that menu item."
         (tool-bar-local-item-from-menu 'Info-prev "left_arrow" map Info-mode-map)
         (tool-bar-local-item-from-menu 'Info-next "right_arrow" map Info-mode-map)
         (tool-bar-local-item-from-menu 'Info-up "up_arrow" map Info-mode-map)
-        (tool-bar-local-item-from-menu 'Info-last "undo" map Info-mode-map)
+        (tool-bar-local-item-from-menu 'Info-history-back "back_arrow" map Info-mode-map)
+        (tool-bar-local-item-from-menu 'Info-history-forward "fwd_arrow" map Info-mode-map)
         (tool-bar-local-item-from-menu 'Info-top-node "home" map Info-mode-map)
         (tool-bar-local-item-from-menu 'Info-index "index" map Info-mode-map)
         (tool-bar-local-item-from-menu 'Info-goto-node "jump_to" map Info-mode-map)
@@ -3100,7 +3130,8 @@ Selecting other nodes:
           Picking a menu item causes another node to be selected.
 \\[Info-directory]      Go to the Info directory node.
 \\[Info-follow-reference]       Follow a cross reference.  Reads name of reference.
-\\[Info-last]   Move to the last node you were at.
+\\[Info-history-back]   Move back in history to the last node you were at.
+\\[Info-history-forward]        Move forward in history to the node you returned from after using \\[Info-history-back].
 \\[Info-history]        Go to menu of visited nodes.
 \\[Info-toc]    Go to table of contents of the current Info file.
 \\[Info-top-node]       Go to the Top node of this file.
@@ -3157,6 +3188,7 @@ Advanced commands:
   (make-local-variable 'Info-tag-table-buffer)
   (setq Info-tag-table-buffer nil)
   (make-local-variable 'Info-history)
+  (make-local-variable 'Info-history-forward)
   (make-local-variable 'Info-index-alternatives)
   (setq header-line-format
         (if Info-use-header-line
@@ -3368,7 +3400,7 @@ COMMAND must be a symbol or string."
                 (message "Found %d other entr%s.  Use %s to see %s."
                          (1- num-matches)
                          (if (> num-matches 2) "ies" "y")
-                         (substitute-command-keys "\\[Info-last]")
+                         (substitute-command-keys "\\[Info-history-back]")
                          (if (> num-matches 2) "them" "it")))))
       (error "Couldn't find documentation for %s" command))))
 
@@ -3453,6 +3485,7 @@ Preserve text properties."
     (define-key keymap [header-line mouse-2] 'Info-next)
     (define-key keymap [header-line down-mouse-1] 'ignore)
     (define-key keymap [mouse-2] 'Info-next)
+    (define-key keymap [follow-link] 'mouse-face)
     keymap)
   "Keymap to put on the Next link in the text or the header line.")
 
@@ -3462,6 +3495,7 @@ Preserve text properties."
     (define-key keymap [header-line mouse-2] 'Info-prev)
     (define-key keymap [header-line down-mouse-1] 'ignore)
     (define-key keymap [mouse-2] 'Info-prev)
+    (define-key keymap [follow-link] 'mouse-face)
     keymap)
   "Keymap to put on the Prev link in the text or the header line.")
 
@@ -3472,6 +3506,7 @@ Preserve text properties."
     (define-key keymap [header-line mouse-2] 'Info-up)
     (define-key keymap [header-line down-mouse-1] 'ignore)
     (define-key keymap [mouse-2] 'Info-up)
+    (define-key keymap [follow-link] 'mouse-face)
     keymap)
   "Keymap to put on the Up link in the text or the header line.")
 
@@ -3506,7 +3541,7 @@ Preserve text properties."
               (put-text-property tbeg nend 'mouse-face 'highlight)
               (put-text-property tbeg nend
                                  'help-echo
-                                 (concat "Go to node "
+                                 (concat "mouse-2: Go to node "
                                          (buffer-substring nbeg nend)))
               ;; Always set up the text property keymap.
               ;; It will either be used in the buffer
diff --git a/lisp/isearch.el b/lisp/isearch.el
index fb31c3a2587..7702707c6ac 100644
--- a/lisp/isearch.el
+++ b/lisp/isearch.el
@@ -1,7 +1,7 @@
 ;;; isearch.el --- incremental search minor mode
 
 ;; Copyright (C) 1992, 1993, 1994, 1995, 1996, 1997, 1999,
-;;   2000, 2001, 2003, 2004  Free Software Foundation, Inc.
+;;   2000, 2001, 2003, 2004, 2005  Free Software Foundation, Inc.
 
 ;; Author: Daniel LaLiberte <liberte@cs.uiuc.edu>
 ;; Maintainer: FSF
@@ -120,11 +120,6 @@ a tab, a carriage return (control-M), a newline, and `]+'."
   :type 'regexp
   :group 'isearch)
 
-(defcustom search-highlight t
-  "*Non-nil means incremental search highlights the current match."
-  :type 'boolean
-  :group 'isearch)
-
 (defcustom search-invisible 'open
   "If t incremental search can match hidden text.
 nil means don't match invisible text.
@@ -199,6 +194,98 @@ Default value, nil, means edit the string instead."
   :type 'boolean
   :group 'isearch)
 
+;;; isearch highlight customization.
+
+(defcustom search-highlight t
+  "*Non-nil means incremental search highlights the current match."
+  :type 'boolean
+  :group 'isearch)
+
+(defface isearch
+  '((((class color) (min-colors 88) (background light))
+     ;; The background must not be too dark, for that means
+     ;; the character is hard to see when the cursor is there.
+     (:background "magenta2" :foreground "lightskyblue1"))
+    (((class color) (min-colors 88) (background dark))
+     (:background "palevioletred2" :foreground "brown4"))
+    (((class color) (min-colors 16))
+     (:background "magenta4" :foreground "cyan1"))
+    (((class color) (min-colors 8))
+     (:background "magenta4" :foreground "cyan1"))
+    (t (:inverse-video t)))
+  "Face for highlighting Isearch matches."
+  :group 'isearch)
+(defvar isearch 'isearch)
+
+(defcustom isearch-lazy-highlight t
+  "*Controls the lazy-highlighting during incremental search.
+When non-nil, all text in the buffer matching the current search
+string is highlighted lazily (see `lazy-highlight-initial-delay'
+and `lazy-highlight-interval')."
+  :type 'boolean
+  :group 'lazy-highlight
+  :group 'isearch)
+
+;;; Lazy highlight customization.
+
+(defgroup lazy-highlight nil
+  "Lazy highlighting feature for matching strings."
+  :prefix "lazy-highlight-"
+  :version "21.1"
+  :group 'isearch
+  :group 'matching)
+
+(defcustom lazy-highlight-cleanup t
+  "*Controls whether to remove extra highlighting after a search.
+If this is nil, extra highlighting can be \"manually\" removed with
+\\[isearch-lazy-highlight-cleanup]."
+  :type 'boolean
+  :group 'lazy-highlight)
+(defvaralias 'isearch-lazy-highlight-cleanup 'lazy-highlight-cleanup)
+(make-obsolete-variable 'isearch-lazy-highlight-cleanup 'lazy-highlight-cleanup)
+
+(defcustom lazy-highlight-initial-delay 0.25
+  "*Seconds to wait before beginning to lazily highlight all matches."
+  :type 'number
+  :group 'lazy-highlight)
+(defvaralias 'isearch-lazy-highlight-initial-delay 'lazy-highlight-initial-delay)
+(make-obsolete-variable 'isearch-lazy-highlight-initial-delay 'lazy-highlight-initial-delay)
+
+(defcustom lazy-highlight-interval 0 ; 0.0625
+  "*Seconds between lazily highlighting successive matches."
+  :type 'number
+  :group 'lazy-highlight)
+(defvaralias 'isearch-lazy-highlight-interval 'lazy-highlight-interval)
+(make-obsolete-variable 'isearch-lazy-highlight-interval 'lazy-highlight-interval)
+
+(defcustom lazy-highlight-max-at-a-time 20
+  "*Maximum matches to highlight at a time (for `lazy-highlight').
+Larger values may reduce isearch's responsiveness to user input;
+smaller values make matches highlight slowly.
+A value of nil means highlight all matches."
+  :type '(choice (const :tag "All" nil)
+                 (integer :tag "Some"))
+  :group 'lazy-highlight)
+(defvaralias 'isearch-lazy-highlight-max-at-a-time 'lazy-highlight-max-at-a-time)
+(make-obsolete-variable 'isearch-lazy-highlight-max-at-a-time 'lazy-highlight-max-at-a-time)
+
+(defface lazy-highlight
+  '((((class color) (min-colors 88) (background light))
+     (:background "paleturquoise"))
+    (((class color) (min-colors 88) (background dark))
+     (:background "paleturquoise4"))
+    (((class color) (min-colors 16))
+     (:background "turquoise3"))
+    (((class color) (min-colors 8))
+     (:background "turquoise3"))
+    (t (:underline t)))
+  "Face for lazy highlighting of matches other than the current one."
+  :group 'lazy-highlight)
+(put 'isearch-lazy-highlight-face 'face-alias 'lazy-highlight)
+(defvar lazy-highlight-face 'lazy-highlight)
+(defvaralias 'isearch-lazy-highlight-face 'lazy-highlight-face)
+(make-obsolete-variable 'isearch-lazy-highlight-face 'lazy-highlight-face)
+
 ;; Define isearch-mode keymap.
 
 (defvar isearch-mode-map
@@ -644,7 +731,7 @@ is treated as a regexp.  See \\[isearch-forward] for more info."
             (if (< isearch-other-end (point)) ; isearch-forward?
                 (isearch-highlight isearch-other-end (point))
               (isearch-highlight (point) isearch-other-end))
-          (isearch-dehighlight nil))
+          (isearch-dehighlight))
         ))
   (setq ;; quit-flag nil  not for isearch-mode
    isearch-adjusted nil
@@ -672,8 +759,8 @@ is treated as a regexp.  See \\[isearch-forward] for more info."
   (setq overriding-terminal-local-map nil)
   ;; (setq pre-command-hook isearch-old-pre-command-hook) ; for lemacs
   (setq minibuffer-message-timeout isearch-original-minibuffer-message-timeout)
-  (isearch-dehighlight t)
-  (isearch-lazy-highlight-cleanup isearch-lazy-highlight-cleanup)
+  (isearch-dehighlight)
+  (isearch-lazy-highlight-cleanup lazy-highlight-cleanup)
   (let ((found-start (window-start (selected-window)))
         (found-point (point)))
     (if isearch-window-configuration
@@ -2142,31 +2229,8 @@ Can be changed via `isearch-search-fun-function' for special needs."
               (setq isearch-hidden t)))))))
 
 
-;; Highlighting
-
-(defvar isearch-overlay nil)
-
-(defun isearch-highlight (beg end)
-  (unless (null search-highlight)
-    (cond (isearch-overlay
-           ;; Overlay already exists, just move it.
-           (move-overlay isearch-overlay beg end (current-buffer)))
-
-          (t
-           ;; Overlay doesn't exist, create it.
-           (setq isearch-overlay (make-overlay beg end))
-           (overlay-put isearch-overlay 'face isearch)
-           (overlay-put isearch-overlay 'priority 1) ;higher than lazy overlays
-           ))))
-
-(defun isearch-dehighlight (totally)
-  (when isearch-overlay
-    (delete-overlay isearch-overlay)))
-
-
 ;; General utilities
 
-
 (defun isearch-no-upper-case-p (string regexp-flag)
   "Return t if there are no upper case chars in STRING.
 If REGEXP-FLAG is non-nil, disregard letters preceded by `\\' (but not `\\\\')
@@ -2198,12 +2262,33 @@ since they have special meaning in a regexp."
         (append char-or-events unread-command-events)))
 
 
+;; Highlighting
+
+(defvar isearch-overlay nil)
+
+(defun isearch-highlight (beg end)
+  (unless (null search-highlight)
+    (cond (isearch-overlay
+           ;; Overlay already exists, just move it.
+           (move-overlay isearch-overlay beg end (current-buffer)))
+
+          (t
+           ;; Overlay doesn't exist, create it.
+           (setq isearch-overlay (make-overlay beg end))
+           (overlay-put isearch-overlay 'face isearch)
+           (overlay-put isearch-overlay 'priority 1) ;higher than lazy overlays
+           ))))
+
+(defun isearch-dehighlight ()
+  (when isearch-overlay
+    (delete-overlay isearch-overlay)))
+
 ;; isearch-lazy-highlight feature
 ;; by Bob Glickstein <http://www.zanshin.com/~bobg/>
 
 ;; When active, *every* match for the current search string is
 ;; highlighted: the current one using the normal isearch match color
-;; and all the others using `isearch-lazy-highlight-face'.  The extra
+;; and all the others using `isearch-lazy-highlight'.  The extra
 ;; highlighting makes it easier to anticipate where the cursor will
 ;; land each time you press C-s or C-r to repeat a pending search.
 ;; Highlighting of these additional matches happens in a deferred
@@ -2223,81 +2308,6 @@ since they have special meaning in a regexp."
 ;;  - the variable `isearch-invalid-regexp' is expected to be true
 ;;    iff `isearch-string' is an invalid regexp.
 
-(defgroup isearch-lazy-highlight nil
-  "Lazy highlighting feature for incremental search."
-  :prefix "isearch-lazy-highlight-"
-  :version "21.1"
-  :group 'isearch)
-
-(defcustom isearch-lazy-highlight t
-  "*Controls the lazy-highlighting during incremental searches.
-When non-nil, all text in the buffer matching the current search
-string is highlighted lazily (see `isearch-lazy-highlight-initial-delay'
-and `isearch-lazy-highlight-interval')."
-  :type 'boolean
-  :group 'isearch-lazy-highlight)
-
-(defcustom isearch-lazy-highlight-cleanup t
-  "*Controls whether to remove extra highlighting after a search.
-If this is nil, extra highlighting can be \"manually\" removed with
-\\[isearch-lazy-highlight-cleanup]."
-  :type 'boolean
-  :group 'isearch-lazy-highlight)
-
-(defcustom isearch-lazy-highlight-initial-delay 0.25
-  "*Seconds to wait before beginning to lazily highlight all matches."
-  :type 'number
-  :group 'isearch-lazy-highlight)
-
-(defcustom isearch-lazy-highlight-interval 0 ; 0.0625
-  "*Seconds between lazily highlighting successive matches."
-  :type 'number
-  :group 'isearch-lazy-highlight)
-
-(defcustom isearch-lazy-highlight-max-at-a-time 20
-  "*Maximum matches to highlight at a time (for `isearch-lazy-highlight').
-Larger values may reduce isearch's responsiveness to user input;
-smaller values make matches highlight slowly.
-A value of nil means highlight all matches."
-  :type '(choice (const :tag "All" nil)
-                 (integer :tag "Some"))
-  :group 'isearch-lazy-highlight)
-
-(defgroup isearch-faces nil
-  "Lazy highlighting feature for incremental search."
-  :version "21.1"
-  :group 'isearch)
-
-(defface isearch
-  '((((class color) (min-colors 88) (background light))
-     ;; The background must not be too dark, for that means
-     ;; the character is hard to see when the cursor is there.
-     (:background "magenta2" :foreground "lightskyblue1"))
-    (((class color) (min-colors 88) (background dark))
-     (:background "palevioletred2" :foreground "brown4"))
-    (((class color) (min-colors 16))
-     (:background "magenta4" :foreground "cyan1"))
-    (((class color) (min-colors 8))
-     (:background "magenta4" :foreground "cyan1"))
-    (t (:inverse-video t)))
-  "Face for highlighting Isearch matches."
-  :group 'isearch-faces)
-(defvar isearch 'isearch)
-
-(defface isearch-lazy-highlight-face
-  '((((class color) (min-colors 88) (background light))
-     (:background "paleturquoise"))
-    (((class color) (min-colors 88) (background dark))
-     (:background "paleturquoise4"))
-    (((class color) (min-colors 16))
-     (:background "turquoise3"))
-    (((class color) (min-colors 8))
-     (:background "turquoise3"))
-    (t (:underline t)))
-  "Face for lazy highlighting of Isearch matches other than the current one."
-  :group 'isearch-faces)
-(defvar isearch-lazy-highlight-face 'isearch-lazy-highlight-face)
-
 (defvar isearch-lazy-highlight-overlays nil)
 (defvar isearch-lazy-highlight-wrapped nil)
 (defvar isearch-lazy-highlight-start nil)
@@ -2312,11 +2322,11 @@ A value of nil means highlight all matches."
 
 (defun isearch-lazy-highlight-cleanup (&optional force)
   "Stop lazy highlighting and remove extra highlighting from current buffer.
-FORCE non-nil means do it whether or not `isearch-lazy-highlight-cleanup'
+FORCE non-nil means do it whether or not `lazy-highlight-cleanup'
 is nil.  This function is called when exiting an incremental search if
-`isearch-lazy-highlight-cleanup' is non-nil."
+`lazy-highlight-cleanup' is non-nil."
   (interactive '(t))
-  (if (or force isearch-lazy-highlight-cleanup)
+  (if (or force lazy-highlight-cleanup)
       (while isearch-lazy-highlight-overlays
         (delete-overlay (car isearch-lazy-highlight-overlays))
         (setq isearch-lazy-highlight-overlays
@@ -2326,7 +2336,7 @@ is nil.  This function is called when exiting an incremental search if
     (setq isearch-lazy-highlight-timer nil)))
 
 (defun isearch-lazy-highlight-new-loop ()
-  "Cleanup any previous `isearch-lazy-highlight' loop and begin a new one.
+  "Cleanup any previous `lazy-highlight' loop and begin a new one.
 This happens when `isearch-update' is invoked (which can cause the
 search string to change or the window to scroll)."
   (when (and (null executing-kbd-macro)
@@ -2357,7 +2367,7 @@ search string to change or the window to scroll)."
             isearch-lazy-highlight-wrapped      nil)
       (unless (equal isearch-string "")
         (setq isearch-lazy-highlight-timer
-              (run-with-idle-timer isearch-lazy-highlight-initial-delay nil
+              (run-with-idle-timer lazy-highlight-initial-delay nil
                                    'isearch-lazy-highlight-update))))))
 
 (defun isearch-lazy-highlight-search ()
@@ -2378,7 +2388,7 @@ Attempt to do the search exactly the way the pending isearch would."
 
 (defun isearch-lazy-highlight-update ()
   "Update highlighting of other matches for current search."
-  (let ((max isearch-lazy-highlight-max-at-a-time)
+  (let ((max lazy-highlight-max-at-a-time)
         (looping t)
         nomore)
     (with-local-quit
@@ -2437,7 +2447,7 @@ Attempt to do the search exactly the way the pending isearch would."
                         (goto-char (window-end)))))))
             (unless nomore
               (setq isearch-lazy-highlight-timer
-                    (run-at-time isearch-lazy-highlight-interval nil
+                    (run-at-time lazy-highlight-interval nil
                                  'isearch-lazy-highlight-update)))))))))
 
 (defun isearch-resume (search regexp word forward message case-fold)
diff --git a/lisp/loadhist.el b/lisp/loadhist.el
index 8cbe1d80cd3..76ef87ee845 100644
--- a/lisp/loadhist.el
+++ b/lisp/loadhist.el
@@ -51,9 +51,26 @@ a buffer with no associated file, or an `eval-region', return nil."
       (error "%S is not a currently loaded feature" feature)
     (car (feature-symbols feature))))
 
+(defun file-loadhist-lookup (file)
+  "Return the `load-history' element for FILE."
+  ;; First look for FILE as given.
+  (let ((symbols (assoc file load-history)))
+    ;; Try converting a library name to an absolute file name.
+    (and (null symbols)
+         (let ((absname (find-library-name file)))
+           (if (not (equal absname file))
+               (setq symbols (cdr (assoc absname load-history))))))
+    ;; Try converting an absolute file name to a library name.
+    (and (null symbols) (string-match "[.]el\\'" file)
+         (let ((libname (file-name-nondirectory file)))
+           (string-match "[.]el\\'" libname)
+           (setq libname (substring libname 0 (match-beginning 0)))
+           (setq symbols (cdr (assoc libname load-history)))))
+    symbols))
+
 (defun file-provides (file)
   "Return the list of features provided by FILE."
-  (let ((symbols (cdr (assoc file load-history)))
+  (let ((symbols (file-loadhist-lookup file))
         provides)
     (mapc (lambda (x)
             (if (and (consp x) (eq (car x) 'provide))
@@ -63,7 +80,7 @@ a buffer with no associated file, or an `eval-region', return nil."
 
 (defun file-requires (file)
   "Return the list of features required by FILE."
-  (let ((symbols (cdr (assoc file load-history)))
+  (let ((symbols (file-loadhist-lookup file))
         requires)
     (mapc (lambda (x)
             (if (and (consp x) (eq (car x) 'require))
diff --git a/lisp/mail/mailabbrev.el b/lisp/mail/mailabbrev.el
index 1b94f179f94..2f973cdfbb9 100644
--- a/lisp/mail/mailabbrev.el
+++ b/lisp/mail/mailabbrev.el
@@ -305,10 +305,19 @@ If DEFINITION contains multiple addresses, separate them with commas."
                     end (string-match "\"[ \t,]*" definition start))
             (setq end (string-match "[ \t,]+" definition start)))
         (setq end (string-match "[ \t\n,]*,[ \t\n,]*" definition start)))
-      (setq result (cons (substring definition start end) result))
-      (setq start (and end
-                       (/= (match-end 0) L)
-                       (match-end 0))))
+      (let ((tem (substring definition start end)))
+        ;; Advance the loop past this address.
+        (setq start (and end
+                         (/= (match-end 0) L)
+                         (match-end 0)))
+        ;; If the full name contains a problem character, quote it.
+        (when (string-match "\\(.+?\\)[ \t]*\\(<.*>\\)" tem)
+          (if (string-match "[^- !#$%&'*+/0-9=?A-Za-z^_`{|}~]"
+                            (match-string 1 tem))
+              (setq tem (replace-regexp-in-string
+                         "\\(.+?\\)[ \t]*\\(<.*>\\)" "\"\\1\" \\2"
+                         tem))))
+        (push tem result)))
     (setq definition (mapconcat (function identity)
                                 (nreverse result)
                                 mail-alias-separator-string)))
@@ -485,7 +494,9 @@ of a mail alias.  The value is set up, buffer-local, when first needed.")
              ;; the usual syntax table.
 
              (or (and (integerp last-command-char)
-                      (eq (char-syntax last-command-char) ?_))
+                      (or (eq (char-syntax last-command-char) ?_)
+                          ;; Don't expand on @.
+                          (memq last-command-char '(?@ ?. ?% ?! ?_ ?-))))
                  (let ((pre-abbrev-expand-hook nil)) ; That's us; don't loop.
                    ;; Use this table so that abbrevs can have hyphens in them.
                    (set-syntax-table mail-abbrev-syntax-table)
@@ -610,7 +621,8 @@ Don't use this command in Lisp programs!
   (interactive "P")
   (if (looking-at "[ \t]*\n") (expand-abbrev))
   (setq this-command 'end-of-buffer)
-  (end-of-buffer arg))
+  (with-no-warnings
+   (end-of-buffer arg)))
 
 (eval-after-load "sendmail"
   '(progn
diff --git a/lisp/mail/rmail.el b/lisp/mail/rmail.el
index fddbc4d1c6b..c97f048a940 100644
--- a/lisp/mail/rmail.el
+++ b/lisp/mail/rmail.el
@@ -1,6 +1,6 @@
 ;;; rmail.el --- main code of "RMAIL" mail reader for Emacs
 
-;; Copyright (C) 1985,86,87,88,93,94,95,96,97,98,2000, 01, 2004
+;; Copyright (C) 1985,86,87,88,93,94,95,96,97,98,2000,01,2004,2005
 ;;              Free Software Foundation, Inc.
 
 ;; Maintainer: FSF
@@ -91,6 +91,9 @@
   :prefix "rmail-edit-"
   :group 'rmail)
 
+(defgroup rmail-obsolete nil
+  "Rmail obsolete customization variables."
+  :group 'rmail)
 
 (defcustom rmail-movemail-program nil
   "If non-nil, name of program for fetching new mail."
@@ -98,15 +101,46 @@
   :type '(choice (const nil) string))
 
 (defcustom rmail-pop-password nil
-  "*Password to use when reading mail from a POP server, if required."
+  "*Password to use when reading mail from POP server. Please, use rmail-remote-password instead."
   :type '(choice (string :tag "Password")
                  (const :tag "Not Required" nil))
-  :group 'rmail-retrieve)
+  :group 'rmail-obsolete)
 
 (defcustom rmail-pop-password-required nil
-  "*Non-nil if a password is required when reading mail using POP."
+  "*Non-nil if a password is required when reading mail from a POP server. Please, use rmail-remote-password-required instead."
   :type 'boolean
-  :group 'rmail-retrieve)
+  :group 'rmail-obsolete)
+
+(defcustom rmail-remote-password nil
+  "*Password to use when reading mail from a remote server. This setting is ignored for mailboxes whose URL already contains a password."
+  :type '(choice (string :tag "Password")
+                 (const :tag "Not Required" nil))
+  :set-after '(rmail-pop-password)
+  :set #'(lambda (symbol value)
+           (set-default symbol 
+                        (if (and (not value)
+                                 (boundp 'rmail-pop-password)
+                                 rmail-pop-password)
+                            rmail-pop-password
+                          value))
+           (setq rmail-pop-password nil))
+  :group 'rmail-retrieve
+  :version "21.3.50.1")
+
+(defcustom rmail-remote-password-required nil
+  "*Non-nil if a password is required when reading mail from a remote server."
+  :type 'boolean
+  :set-after '(rmail-pop-password-required)
+  :set #'(lambda (symbol value)
+           (set-default symbol 
+                        (if (and (not value)
+                                 (boundp 'rmail-pop-password-required)
+                                 rmail-pop-password-required)
+                            rmail-pop-password-required
+                          value))
+           (setq rmail-pop-password-required nil))
+  :group 'rmail-retrieve
+  :version "21.3.50.1")
 
 (defcustom rmail-movemail-flags nil
   "*List of flags to pass to movemail.
@@ -116,13 +150,14 @@ or `-k' to enable Kerberos authentication."
   :group 'rmail-retrieve
   :version "20.3")
 
-(defvar rmail-pop-password-error "invalid usercode or password\\|
-unknown user name or bad password"
-  "Regular expression matching incorrect-password POP server error messages.
+(defvar rmail-remote-password-error "invalid usercode or password\\|
+unknown user name or bad password\\|Authentication failed\\|MU_ERR_AUTH_FAILURE"
+  "Regular expression matching incorrect-password POP or IMAP server error
+messages.
 If you get an incorrect-password error that this expression does not match,
 please report it with \\[report-emacs-bug].")
 
-(defvar rmail-encoded-pop-password nil)
+(defvar rmail-encoded-remote-password nil)
 
 (defcustom rmail-preserve-inbox nil
   "*Non-nil if incoming mail should be left in the user's inbox,
@@ -130,6 +165,67 @@ rather than deleted, after it is retrieved."
   :type 'boolean
   :group 'rmail-retrieve)
 
+(defcustom rmail-movemail-search-path nil
+    "*List of directories to search for movemail (in addition to `exec-path')."
+    :group 'rmail-retrieve
+    :type '(repeat (directory)))
+
+(defun rmail-probe (prog)
+  "Determine what flavor of movemail PROG is by executing it with --version
+command line option and analyzing its output."
+  (with-temp-buffer
+    (let ((tbuf (current-buffer)))
+      (buffer-disable-undo tbuf)
+      (call-process prog nil tbuf nil "--version")
+      (if (not (buffer-modified-p tbuf))
+          ;; Should not happen...
+          nil
+        (goto-char (point-min))
+        (cond
+         ((looking-at ".*movemail: invalid option")
+          'emacs)    ;; Possibly...
+         ((looking-at "movemail (GNU Mailutils .*)")
+          'mailutils)
+         (t
+          ;; FIXME:
+          'emacs))))))
+
+(defun rmail-autodetect ()
+  "Determine and return the flavor of `movemail' program in use. If
+rmail-movemail-program is set, use it. Otherwise, look for `movemail'
+in the path constructed by appending rmail-movemail-search-path,
+exec-path and exec-directory."
+  (if rmail-movemail-program
+      (rmail-probe rmail-movemail-program)
+    (catch 'scan
+      (dolist (dir (append rmail-movemail-search-path exec-path
+                           (list exec-directory)))
+        (when (and dir (file-accessible-directory-p dir))
+          (let ((progname (expand-file-name "movemail" dir)))
+            (when (and (not (file-directory-p progname))
+                       (file-executable-p progname))
+              (let ((x (rmail-probe progname)))
+                (when x
+                  (setq rmail-movemail-program progname)
+                  (throw 'scan x))))))))))
+
+(defvar rmail-movemail-variant-in-use nil
+  "The movemail variant currently in use. Known variants are:
+
+  `emacs'     Means any implementation, compatible with the native Emacs one.
+              This is the default;
+  `mailutils' Means GNU mailutils implementation, capable of handling full
+mail URLs as the source mailbox;")
+
+;;;###autoload
+(defun rmail-movemail-variant-p (&rest variants)
+  "Return t if the current movemail variant is any of VARIANTS.
+Currently known variants are 'emacs and 'mailutils."
+  (when (not rmail-movemail-variant-in-use)
+    ;; Autodetect
+    (setq rmail-movemail-variant-in-use (rmail-autodetect)))
+  (not (null (member rmail-movemail-variant-in-use variants))))
+
 ;;;###autoload
 (defcustom rmail-dont-reply-to-names nil "\
 *A regexp specifying addresses to prune from a reply message.
@@ -1516,6 +1612,40 @@ It returns t if it got any new messages."
       ;; Don't leave the buffer screwed up if we get a disk-full error.
       (or found (rmail-show-message)))))
 
+(defun rmail-parse-url (file)
+  "Parse the supplied URL. Return (list MAILBOX-NAME REMOTE PASSWORD GOT-PASSWORD)
+WHERE MAILBOX-NAME is the name of the mailbox suitable as argument to the
+actual version of `movemail', REMOTE is non-nil if MAILBOX-NAME refers to
+a remote mailbox, PASSWORD is the password if it should be
+supplied as a separate argument to `movemail' or nil otherwise, GOT-PASSWORD
+is non-nil if the user has supplied the password interactively.
+"
+  (if (string-match "^\\([^:]+\\)://\\(\\([^:@]+\\)\\(:\\([^@]+\\)\\)?@\\)?.*" file)
+      (let (got-password supplied-password 
+            (proto (match-string 1 file))
+            (user  (match-string 3 file))
+            (pass  (match-string 5 file))
+            (host  (substring file (or (match-end 2)
+                                       (+ 3 (match-end 1))))))
+        (if (not pass)
+            (when rmail-remote-password-required
+              (setq got-password (not (rmail-have-password)))
+              (setq supplied-password (rmail-get-remote-password
+                                       (string-equal proto "imap")))))
+                              
+        (if (rmail-movemail-variant-p 'emacs)
+            (if (string-equal proto "pop")
+                (list (concat "po:" user ":" host)
+                      t
+                      (or pass supplied-password)
+                      got-password)
+              (error "Emacs movemail does not support %s protocol" proto))
+          (list file
+                (or (string-equal proto "pop") (string-equal proto "imap"))
+                supplied-password
+                got-password)))
+    (list file nil nil nil)))
+
 (defun rmail-insert-inbox-text (files renamep)
   ;; Detect a locked file now, so that we avoid moving mail
   ;; out of the real inbox file.  (That could scare people.)
@@ -1524,10 +1654,15 @@ It returns t if it got any new messages."
              (file-name-nondirectory buffer-file-name)))
   (let (file tofile delete-files movemail popmail got-password password)
     (while files
-      ;; Handle POP mailbox names specially; don't expand as filenames
+      ;; Handle remote mailbox names specially; don't expand as filenames
       ;; in case the userid contains a directory separator.
       (setq file (car files))
-      (setq popmail (string-match "^po:" file))
+      (let ((url-data (rmail-parse-url file)))
+        (setq file (nth 0 url-data))
+        (setq popmail (nth 1 url-data))
+        (setq password (nth 2 url-data))
+        (setq got-password (nth 3 url-data)))
+
       (if popmail
           (setq renamep t)
         (setq file (file-truename
@@ -1535,7 +1670,12 @@ It returns t if it got any new messages."
       (setq tofile (expand-file-name
                     ;; Generate name to move to from inbox name,
                     ;; in case of multiple inboxes that need moving.
-                    (concat ".newmail-" (file-name-nondirectory file))
+                    (concat ".newmail-"
+                            (file-name-nondirectory 
+                             (if (memq system-type '(windows-nt cygwin))
+                                 ;; cannot have "po:" in file name
+                                 (substring file 3)
+                               file)))
                     ;; Use the directory of this rmail file
                     ;; because it's a nuisance to use the homedir
                     ;; if that is on a full disk and this rmail
@@ -1560,18 +1700,7 @@ It returns t if it got any new messages."
                 (setq file (expand-file-name (user-login-name)
                                              file)))))
       (cond (popmail
-             (if rmail-pop-password-required
-                 (progn (setq got-password (not (rmail-have-password)))
-                        (setq password (rmail-get-pop-password))))
-             (if (memq system-type '(windows-nt cygwin))
-                 ;; cannot have "po:" in file name
-                 (setq tofile
-                       (expand-file-name
-                        (concat ".newmail-pop-"
-                                (file-name-nondirectory (substring file 3)))
-                        (file-name-directory
-                         (expand-file-name buffer-file-name)))))
-             (message "Getting mail from post office ..."))
+             (message "Getting mail from the remote server ..."))
             ((and (file-exists-p tofile)
                   (/= 0 (nth 7 (file-attributes tofile))))
              (message "Getting mail from %s..." tofile))
@@ -1603,50 +1732,59 @@ It returns t if it got any new messages."
                      (write-region (point) (point) file)
                    (file-error nil))))
             (t
-             (let ((errors nil))
-               (unwind-protect
-                   (save-excursion
-                     (setq errors (generate-new-buffer " *rmail loss*"))
-                     (buffer-disable-undo errors)
-                     (let ((args
-                            (append
-                             (list (or rmail-movemail-program
-                                       (expand-file-name "movemail"
-                                                         exec-directory))
-                                   nil errors nil)
-                             (if rmail-preserve-inbox
-                                 (list "-p")
-                               nil)
-                             rmail-movemail-flags
-                             (list file tofile)
-                             (if password (list password) nil))))
-                       (apply 'call-process args))
-                     (if (not (buffer-modified-p errors))
-                         ;; No output => movemail won
-                         nil
-                       (set-buffer errors)
-                       (subst-char-in-region (point-min) (point-max)
-                                             ?\n ?\  )
-                       (goto-char (point-max))
-                       (skip-chars-backward " \t")
-                       (delete-region (point) (point-max))
-                       (goto-char (point-min))
-                       (if (looking-at "movemail: ")
-                           (delete-region (point-min) (match-end 0)))
-                       (beep t)
-                       (message "movemail: %s"
-                                (buffer-substring (point-min)
-                                                  (point-max)))
-                       ;; If we just read the password, most likely it is
-                       ;; wrong.  Otherwise, see if there is a specific
-                       ;; reason to think that the problem is a wrong passwd.
-                       (if (or got-password
-                               (re-search-forward rmail-pop-password-error
-                                                  nil t))
-                           (rmail-set-pop-password nil))
-                       (sit-for 3)
-                       nil))
-                 (if errors (kill-buffer errors))))))
+             (with-temp-buffer
+               (let ((errors (current-buffer)))
+                 (buffer-disable-undo errors)
+                 (let ((args
+                        (append
+                         (list (or rmail-movemail-program
+                                   (expand-file-name "movemail"
+                                                     exec-directory))
+                               nil errors nil)
+                         (if rmail-preserve-inbox
+                             (list "-p")
+                           nil)
+                         (if (rmail-movemail-variant-p 'mailutils)
+                             (append (list "--emacs") rmail-movemail-flags)
+                           rmail-movemail-flags)
+                         (list file tofile)
+                         (if password (list password) nil))))
+                   (apply 'call-process args))
+                 (if (not (buffer-modified-p errors))
+                     ;; No output => movemail won
+                     nil
+                   (set-buffer errors)
+                   (subst-char-in-region (point-min) (point-max)
+                                         ?\n ?\  )
+                   (goto-char (point-max))
+                   (skip-chars-backward " \t")
+                   (delete-region (point) (point-max))
+                   (goto-char (point-min))
+                   (if (looking-at "movemail: ")
+                       (delete-region (point-min) (match-end 0)))
+                   (beep t)
+                   ;; If we just read the password, most likely it is
+                   ;; wrong.  Otherwise, see if there is a specific
+                   ;; reason to think that the problem is a wrong passwd.
+                   (if (or got-password
+                           (re-search-forward rmail-remote-password-error
+                                              nil t))
+                       (rmail-set-remote-password nil))
+
+                   ;; If using Mailutils, remove initial error code
+                   ;; abbreviation
+                   (when (rmail-movemail-variant-p 'mailutils)
+                     (goto-char (point-min))
+                     (when (looking-at "[A-Z][A-Z0-9_]*:")
+                       (delete-region (point-min) (match-end 0))))
+                   
+                   (message "movemail: %s"
+                            (buffer-substring (point-min)
+                                              (point-max)))
+                       
+                   (sit-for 3)
+                   nil)))))
+               
       ;; At this point, TOFILE contains the name to read:
       ;; Either the alternate name (if we renamed)
       ;; or the actual inbox (if not renaming).
@@ -3834,27 +3972,30 @@ TEXT and INDENT are not used."
 ; nor is it meant to be.
 
 ;;;###autoload
-(defun rmail-set-pop-password (password)
-  "Set PASSWORD to be used for retrieving mail from a POP server."
+(defun rmail-set-remote-password (password)
+  "Set PASSWORD to be used for retrieving mail from a POP or IMAP server."
   (interactive "sPassword: ")
   (if password
-      (setq rmail-encoded-pop-password
+      (setq rmail-encoded-remote-password
             (rmail-encode-string password (emacs-pid)))
-    (setq rmail-pop-password nil)
-    (setq rmail-encoded-pop-password nil)))
+    (setq rmail-remote-password nil)
+    (setq rmail-encoded-remote-password nil)))
 
-(defun rmail-get-pop-password ()
-  "Get the password for retrieving mail from a POP server.  If none
+(defun rmail-get-remote-password (imap)
+  "Get the password for retrieving mail from a POP or IMAP server.  If none
 has been set, then prompt the user for one."
-  (if (not rmail-encoded-pop-password)
-      (progn (if (not rmail-pop-password)
-                 (setq rmail-pop-password (read-passwd "POP password: ")))
-             (rmail-set-pop-password rmail-pop-password)
-             (setq rmail-pop-password nil)))
-  (rmail-encode-string rmail-encoded-pop-password (emacs-pid)))
+  (when (not rmail-encoded-remote-password)
+    (if (not rmail-remote-password)
+        (setq rmail-remote-password
+              (read-passwd (if imap
+                               "IMAP password: "
+                             "POP password: "))))
+    (rmail-set-remote-password rmail-remote-password)
+    (setq rmail-remote-password nil))
+  (rmail-encode-string rmail-encoded-remote-password (emacs-pid)))
 
 (defun rmail-have-password ()
-  (or rmail-pop-password rmail-encoded-pop-password))
+  (or rmail-remote-password rmail-encoded-remote-password))
 
 (defun rmail-encode-string (string mask)
  "Encode STRING with integer MASK, by taking the exclusive OR of the
diff --git a/lisp/man.el b/lisp/man.el
index 735805f1bba..e9503ca883a 100644
--- a/lisp/man.el
+++ b/lisp/man.el
@@ -415,13 +415,15 @@ Otherwise, the value is whatever the function
 ;; buttons
 (define-button-type 'Man-xref-man-page
   'action (lambda (button) (man-follow (button-label button)))
-  'help-echo "RET, mouse-2: display this man page")
+  'follow-link t
+  'help-echo "mouse-2, RET: display this man page")
 
 (define-button-type 'Man-xref-header-file
     'action (lambda (button)
               (let ((w (button-get button 'Man-target-string)))
                 (unless (Man-view-header-file w)
                   (error "Cannot find header file: %s" w))))
+    'follow-link t
     'help-echo "mouse-2: display this header file")
 
 (define-button-type 'Man-xref-normal-file
@@ -433,6 +435,7 @@ Otherwise, the value is whatever the function
                       (view-file f)
                     (error "Cannot read a file: %s" f))
                 (error "Cannot find a file: %s" f))))
+  'follow-link t
   'help-echo "mouse-2: display this file")
 
 
@@ -822,6 +825,7 @@ Same for the ANSI bold and normal escape sequences."
   (goto-char (point-min))
   ;; Fontify ANSI escapes.
   (let ((faces nil)
+        (buffer-undo-list t)
         (start (point)))
     ;; http://www.isthe.com/chongo/tech/comp/ansi_escapes.html
     ;; suggests many codes, but we only handle:
@@ -853,46 +857,47 @@ Same for the ANSI bold and normal escape sequences."
       (delete-region (match-beginning 0) (match-end 0))
       (setq start (point))))
   ;; Other highlighting.
-  (if (< (buffer-size) (position-bytes (point-max)))
-      ;; Multibyte characters exist.
-      (progn
-        (goto-char (point-min))
-        (while (search-forward "__\b\b" nil t)
-          (backward-delete-char 4)
-          (put-text-property (point) (1+ (point)) 'face Man-underline-face))
-        (goto-char (point-min))
-        (while (search-forward "\b\b__" nil t)
-          (backward-delete-char 4)
-          (put-text-property (1- (point)) (point) 'face Man-underline-face))))
-  (goto-char (point-min))
-  (while (search-forward "_\b" nil t)
-    (backward-delete-char 2)
-    (put-text-property (point) (1+ (point)) 'face Man-underline-face))
-  (goto-char (point-min))
-  (while (search-forward "\b_" nil t)
-    (backward-delete-char 2)
-    (put-text-property (1- (point)) (point) 'face Man-underline-face))
-  (goto-char (point-min))
-  (while (re-search-forward "\\(.\\)\\(\b+\\1\\)+" nil t)
-    (replace-match "\\1")
-    (put-text-property (1- (point)) (point) 'face Man-overstrike-face))
-  (goto-char (point-min))
-  (while (re-search-forward "o\b\\+\\|\\+\bo" nil t)
-    (replace-match "o")
-    (put-text-property (1- (point)) (point) 'face 'bold))
-  (goto-char (point-min))
-  (while (re-search-forward "[-|]\\(\b[-|]\\)+" nil t)
-    (replace-match "+")
-    (put-text-property (1- (point)) (point) 'face 'bold))
-  (goto-char (point-min))
-  ;; Try to recognize common forms of cross references.
-  (Man-highlight-references)
-  (Man-softhyphen-to-minus)
-  (goto-char (point-min))
-  (while (re-search-forward Man-heading-regexp nil t)
-    (put-text-property (match-beginning 0)
-                       (match-end 0)
-                       'face Man-overstrike-face))
+  (let ((buffer-undo-list t))
+    (if (< (buffer-size) (position-bytes (point-max)))
+        ;; Multibyte characters exist.
+        (progn
+          (goto-char (point-min))
+          (while (search-forward "__\b\b" nil t)
+            (backward-delete-char 4)
+            (put-text-property (point) (1+ (point)) 'face Man-underline-face))
+          (goto-char (point-min))
+          (while (search-forward "\b\b__" nil t)
+            (backward-delete-char 4)
+            (put-text-property (1- (point)) (point) 'face Man-underline-face))))
+    (goto-char (point-min))
+    (while (search-forward "_\b" nil t)
+      (backward-delete-char 2)
+      (put-text-property (point) (1+ (point)) 'face Man-underline-face))
+    (goto-char (point-min))
+    (while (search-forward "\b_" nil t)
+      (backward-delete-char 2)
+      (put-text-property (1- (point)) (point) 'face Man-underline-face))
+    (goto-char (point-min))
+    (while (re-search-forward "\\(.\\)\\(\b+\\1\\)+" nil t)
+      (replace-match "\\1")
+      (put-text-property (1- (point)) (point) 'face Man-overstrike-face))
+    (goto-char (point-min))
+    (while (re-search-forward "o\b\\+\\|\\+\bo" nil t)
+      (replace-match "o")
+      (put-text-property (1- (point)) (point) 'face 'bold))
+    (goto-char (point-min))
+    (while (re-search-forward "[-|]\\(\b[-|]\\)+" nil t)
+      (replace-match "+")
+      (put-text-property (1- (point)) (point) 'face 'bold))
+    (goto-char (point-min))
+    ;; Try to recognize common forms of cross references.
+    (Man-highlight-references)
+    (Man-softhyphen-to-minus)
+    (goto-char (point-min))
+    (while (re-search-forward Man-heading-regexp nil t)
+      (put-text-property (match-beginning 0)
+                         (match-end 0)
+                         'face Man-overstrike-face)))
   (message "%s man page formatted" Man-arguments))
 
 (defun Man-highlight-references ()
diff --git a/lisp/mouse.el b/lisp/mouse.el
index 63e0f6c9d91..7d94b678ca2 100644
--- a/lisp/mouse.el
+++ b/lisp/mouse.el
@@ -1,6 +1,6 @@
 ;;; mouse.el --- window system-independent mouse support
 
-;; Copyright (C) 1993, 94, 95, 1999, 2000, 2001, 2002, 2003, 2004
+;; Copyright (C) 1993, 94, 95, 1999, 2000, 2001, 2002, 2003, 2004, 2005
 ;;   Free Software Foundation, Inc.
 
 ;; Maintainer: FSF
@@ -397,7 +397,6 @@ MODE-LINE-P non-nil means dragging a mode line; nil means a header line."
          (start-nwindows (count-windows t))
          (old-selected-window (selected-window))
          (minibuffer (frame-parameter nil 'minibuffer))
-         (mouse-autoselect-window nil)
          should-enlarge-minibuffer event mouse y top bot edges wconfig growth)
     (track-mouse
       (progn
@@ -435,7 +434,7 @@ MODE-LINE-P non-nil means dragging a mode line; nil means a header line."
           (cond ((integerp event)
                  (setq done t))
 
-                ((eq (car event) 'switch-frame)
+                ((memq (car event) '(switch-frame select-window))
                  nil)
 
                 ((not (memq (car event) '(mouse-movement scroll-bar-movement)))
@@ -582,7 +581,7 @@ resized by dragging their header-line."
           ;;     unknown event.
           (cond ((integerp event)
                  (setq done t))
-                ((eq (car event) 'switch-frame)
+                ((memq (car event) '(switch-frame select-window))
                  nil)
                 ((not (memq (car event)
                             '(mouse-movement scroll-bar-movement)))
@@ -754,11 +753,11 @@ remains active.  Otherwise, it remains until the next input event.
 
 If the click is in the echo area, display the `*Messages*' buffer."
   (interactive "e")
-  (let ((w (posn-window (event-start start-event)))
-        (mouse-autoselect-window nil))
-    (if (not (or (not (window-minibuffer-p w))
-                 (minibuffer-window-active-p w)))
+  (let ((w (posn-window (event-start start-event))))
+    (if (and (window-minibuffer-p w)
+             (not (minibuffer-window-active-p w)))
         (save-excursion
+          ;; Swallow the up-event.
           (read-event)
           (set-buffer "*Messages*")
           (goto-char (point-max))
@@ -773,21 +772,24 @@ If the click is in the echo area, display the `*Messages*' buffer."
 
 A clickable link is identified by one of the following methods:
 
-1) If the character at POS has a non-nil `follow-link' text or
-overlay property, the value of that property is returned.
+- If the character at POS has a non-nil `follow-link' text or
+overlay property, use the value of that property determines what
+to do.
 
-2) If there is a local key-binding or a keybinding at position
-POS for the `follow-link' event, the binding of that event
-determines whether POS is inside a link:
+- If there is a local key-binding or a keybinding at position POS
+for the `follow-link' event, the binding of that event determines
+what to do.
 
-- If the binding is `mouse-face', POS is inside a link if there
+The resulting value determine whether POS is inside a link:
+
+- If the value is `mouse-face', POS is inside a link if there
 is a non-nil `mouse-face' property at POS.  Return t in this case.
 
-- If the binding is a function, FUNC, POS is inside a link if
+- If the value is a function, FUNC, POS is inside a link if
 the call \(FUNC POS) returns non-nil.  Return the return value
 from that call.
 
-- Otherwise, return the binding of the `follow-link' binding.
+- Otherwise, return the value itself.
 
 The return value is interpreted as follows:
 
@@ -801,16 +803,17 @@ click is the local or global binding of that event.
 
 - Otherwise, the mouse-1 event is translated into a mouse-2 event
 at the same position."
-  (or (get-char-property pos 'follow-link)
-      (save-excursion
-        (goto-char pos)
-        (let ((b (key-binding [follow-link] nil t)))
-          (cond
-           ((eq b 'mouse-face)
-            (and (get-char-property pos 'mouse-face) t))
-           ((functionp b)
-            (funcall b pos))
-           (t b))))))
+  (let ((action
+         (or (get-char-property pos 'follow-link)
+             (save-excursion
+               (goto-char pos)
+               (key-binding [follow-link] nil t)))))
+    (cond
+     ((eq action 'mouse-face)
+      (and (get-char-property pos 'mouse-face) t))
+     ((functionp action)
+      (funcall action pos))
+     (t action))))
 
 (defun mouse-drag-region-1 (start-event)
   (mouse-minibuffer-check start-event)
@@ -858,8 +861,8 @@ at the same position."
         (while (progn
                  (setq event (read-event))
                  (or (mouse-movement-p event)
-                     (eq (car-safe event) 'switch-frame)))
-          (if (eq (car-safe event) 'switch-frame)
+                     (memq (car-safe event) '(switch-frame select-window))))
+          (if (memq (car-safe event) '(switch-frame select-window))
               nil
             (setq end (event-end event)
                   end-point (posn-point end))
@@ -1153,6 +1156,7 @@ If MODE is 2 then do the same for lines."
       (move-overlay mouse-drag-overlay (point) (mark t)))
     (catch 'mouse-show-mark
       ;; In this loop, execute scroll bar and switch-frame events.
+      ;; Should we similarly handle `select-window' events?  --Stef
       ;; Also ignore down-events that are undefined.
       (while (progn (setq event (read-event))
                     (setq events (append events (list event)))
@@ -1476,9 +1480,9 @@ The function returns a non-nil value if it creates a secondary selection."
           (while (progn
                    (setq event (read-event))
                    (or (mouse-movement-p event)
-                       (eq (car-safe event) 'switch-frame)))
+                       (memq (car-safe event) '(switch-frame select-window))))
 
-            (if (eq (car-safe event) 'switch-frame)
+            (if (memq (car-safe event) '(switch-frame select-window))
                 nil
               (setq end (event-end event)
                     end-point (posn-point end))
diff --git a/lisp/progmodes/ebrowse.el b/lisp/progmodes/ebrowse.el
index 478ce403b31..bf11ea28514 100644
--- a/lisp/progmodes/ebrowse.el
+++ b/lisp/progmodes/ebrowse.el
@@ -780,16 +780,16 @@ The class tree is found in the buffer-local variable `ebrowse--tree-obarray'."
 
 (defun ebrowse-class-in-tree (class tree)
   "Search for a class with name CLASS in TREE.
-Return the class found, if any.  This function is used during the load
-phase where classes appended to a file replace older class
-information."
+If CLASS is found, return the tail of TREE starting at CLASS.  This function
+is used during the load phase where classes appended to a file replace older
+class information."
   (let ((tclass (ebrowse-ts-class class))
         found)
     (while (and tree (not found))
-      (let ((root (car tree)))
-        (when (string= (ebrowse-qualified-class-name (ebrowse-ts-class root))
+      (let ((root-ptr tree))
+        (when (string= (ebrowse-qualified-class-name (ebrowse-ts-class (car root-ptr)))
                        (ebrowse-qualified-class-name tclass))
-          (setq found root))
+          (setq found root-ptr))
         (setq tree (cdr tree))))
     found))
 
@@ -903,10 +903,10 @@ and TREE is a list of `ebrowse-ts' structures forming the class tree."
     (let ((gc-cons-threshold 2000000))
       (while (not (progn (skip-chars-forward " \t\n\r") (eobp)))
         (let* ((root (read (current-buffer)))
-               (old-root (ebrowse-class-in-tree root tree)))
+               (old-root-ptr (ebrowse-class-in-tree root tree)))
           (ebrowse-show-progress "Reading data" (null tree))
-          (if old-root
-              (setf (car old-root) root)
+          (if old-root-ptr
+              (setcar old-root-ptr root)
             (push root tree)))))
     (garbage-collect)
     (list header tree)))
diff --git a/lisp/progmodes/hideshow.el b/lisp/progmodes/hideshow.el
index 07fcda385ef..d4229cf44c6 100644
--- a/lisp/progmodes/hideshow.el
+++ b/lisp/progmodes/hideshow.el
@@ -5,7 +5,7 @@
 ;; Author: Thien-Thi Nguyen <ttn@gnu.org>
 ;;      Dan Nicolaescu <dann@ics.uci.edu>
 ;; Keywords: C C++ java lisp tools editing comments blocks hiding outlines
-;; Maintainer-Version: 5.58.2.3
+;; Maintainer-Version: 5.58.2.4
 ;; Time-of-Day-Author-Most-Likely-to-be-Recalcitrant: early morning
 
 ;; This file is part of GNU Emacs.
@@ -233,7 +233,6 @@
 ;;; Code:
 
 (require 'easymenu)
-(eval-when-compile (require 'cl))
 
 ;;---------------------------------------------------------------------------
 ;; user-configurable variables
diff --git a/lisp/progmodes/perl-mode.el b/lisp/progmodes/perl-mode.el
index 49d3d46acbc..4b2941bd966 100644
--- a/lisp/progmodes/perl-mode.el
+++ b/lisp/progmodes/perl-mode.el
@@ -1,6 +1,6 @@
 ;;; perl-mode.el --- Perl code editing commands for GNU Emacs
 
-;; Copyright (C) 1990, 1994, 2003  Free Software Foundation, Inc.
+;; Copyright (C) 1990, 1994, 2003, 2005  Free Software Foundation, Inc.
 
 ;; Author: William F. Mann
 ;; Maintainer: FSF
@@ -408,7 +408,7 @@ existing comment, moves to end-of-line, or if at end-of-line already,
 create a new comment."
   :type 'boolean)
 
-(defcustom perl-nochange ";?#\\|\f\\|\\s(\\|\\(\\w\\|\\s_\\)+:"
+(defcustom perl-nochange ";?#\\|\f\\|\\s(\\|\\(\\w\\|\\s_\\)+:[^:]"
   "*Lines starting with this regular expression are not auto-indented."
   :type 'regexp)
 
@@ -769,7 +769,7 @@ Optional argument PARSE-START should be the position of `beginning-of-defun'."
                            (skip-chars-forward " \t\f\n")
                            (cond ((looking-at ";?#")
                                   (forward-line 1) t)
-                                 ((looking-at "\\(\\w\\|\\s_\\)+:")
+                                 ((looking-at "\\(\\w\\|\\s_\\)+:[^:]")
                                   (save-excursion
                                     (end-of-line)
                                     (setq colon-line-end (point)))
@@ -929,5 +929,5 @@ With argument, repeat that many times; negative args move backward."
 
 (provide 'perl-mode)
 
-;;; arch-tag: 8c7ff68d-15f3-46a2-ade2-b7c41f176826
+;; arch-tag: 8c7ff68d-15f3-46a2-ade2-b7c41f176826
 ;;; perl-mode.el ends here
diff --git a/lisp/progmodes/sh-script.el b/lisp/progmodes/sh-script.el
index 387e1232dc0..a1e868a3926 100644
--- a/lisp/progmodes/sh-script.el
+++ b/lisp/progmodes/sh-script.el
@@ -448,6 +448,7 @@ This is buffer-local in every such buffer.")
     (define-key map "\C-c=" 'sh-set-indent)
     (define-key map "\C-c<" 'sh-learn-line-indent)
     (define-key map "\C-c>" 'sh-learn-buffer-indent)
+    (define-key map "\C-c\C-\\" 'sh-backslash-region)
 
     (define-key map "=" 'sh-assignment)
     (define-key map "\C-c+" 'sh-add)
@@ -1183,6 +1184,16 @@ This is for the rc shell."
   :type `(choice ,@ sh-number-or-symbol-list)
   :group 'sh-indentation)
 
+(defcustom sh-backslash-column 48
+  "*Column in which `sh-backslash-region' inserts backslashes."
+  :type 'integer
+  :group 'sh)
+
+(defcustom sh-backslash-align t
+  "*If non-nil, `sh-backslash-region' will align backslashes."
+  :type 'boolean
+  :group 'sh)
+
 ;; Internal use - not designed to be changed by the user:
 
 (defun sh-mkword-regexpr (word)
@@ -3547,6 +3558,77 @@ The document is bounded by `sh-here-document-word'."
   (if (re-search-forward sh-end-of-command nil t)
       (goto-char (match-end 1))))
 
+;; Backslashification.  Stolen from make-mode.el.
+
+(defun sh-backslash-region (from to delete-flag)
+  "Insert, align, or delete end-of-line backslashes on the lines in the region.
+With no argument, inserts backslashes and aligns existing backslashes.
+With an argument, deletes the backslashes.
+
+This function does not modify the last line of the region if the region ends
+right at the start of the following line; it does not modify blank lines
+at the start of the region.  So you can put the region around an entire 
+shell command and conveniently use this command."
+  (interactive "r\nP")
+  (save-excursion
+    (goto-char from)
+    (let ((column sh-backslash-column)
+          (endmark (make-marker)))
+      (move-marker endmark to)
+      ;; Compute the smallest column number past the ends of all the lines.
+      (if sh-backslash-align
+          (progn
+            (if (not delete-flag)
+                (while (< (point) to)
+                  (end-of-line)
+                  (if (= (preceding-char) ?\\)
+                      (progn (forward-char -1)
+                             (skip-chars-backward " \t")))
+                  (setq column (max column (1+ (current-column))))
+                  (forward-line 1)))
+            ;; Adjust upward to a tab column, if that doesn't push
+            ;; past the margin.
+            (if (> (% column tab-width) 0)
+                (let ((adjusted (* (/ (+ column tab-width -1) tab-width)
+                                   tab-width)))
+                  (if (< adjusted (window-width))
+                      (setq column adjusted))))))
+      ;; Don't modify blank lines at start of region.
+      (goto-char from)
+      (while (and (< (point) endmark) (eolp))
+        (forward-line 1))
+      ;; Add or remove backslashes on all the lines.
+      (while (and (< (point) endmark)
+                  ;; Don't backslashify the last line
+                  ;; if the region ends right at the start of the next line.
+                  (save-excursion
+                    (forward-line 1)
+                    (< (point) endmark)))
+        (if (not delete-flag)
+            (sh-append-backslash column)
+          (sh-delete-backslash))
+        (forward-line 1))
+      (move-marker endmark nil))))
+
+(defun sh-append-backslash (column)
+  (end-of-line)
+  ;; Note that "\\\\" is needed to get one backslash.
+  (if (= (preceding-char) ?\\)
+      (progn (forward-char -1)
+             (delete-horizontal-space)
+             (indent-to column (if sh-backslash-align nil 1)))
+    (indent-to column (if sh-backslash-align nil 1))
+    (insert "\\")))
+
+(defun sh-delete-backslash ()
+  (end-of-line)
+  (or (bolp)
+      (progn
+        (forward-char -1)
+        (if (looking-at "\\\\")
+            (delete-region (1+ (point))
+                           (progn (skip-chars-backward " \t") (point)))))))
+
 (provide 'sh-script)
 
 ;;; arch-tag: eccd8b72-f337-4fc2-ae86-18155a69d937
diff --git a/lisp/replace.el b/lisp/replace.el
index 8820a768006..82b2a993fdb 100644
--- a/lisp/replace.el
+++ b/lisp/replace.el
@@ -64,6 +64,27 @@ strings or patterns."
   :group 'matching
   :version "21.4")
 
+(defcustom query-replace-highlight t
+  "*Non-nil means to highlight matches during query replacement."
+  :type 'boolean
+  :group 'matching)
+
+(defcustom query-replace-lazy-highlight t
+  "*Controls the lazy-highlighting during query replacements.
+When non-nil, all text in the buffer matching the current match
+is highlighted lazily using isearch lazy highlighting (see
+`lazy-highlight-initial-delay' and `lazy-highlight-interval')."
+  :type 'boolean
+  :group 'lazy-highlight
+  :group 'matching
+  :version "21.4")
+
+(defface query-replace
+  '((t (:inherit isearch)))
+  "Face for highlighting query replacement matches."
+  :group 'matching
+  :version "21.4")
+
 (defun query-replace-descr (string)
   (mapconcat 'isearch-text-char-description string ""))
 
@@ -802,9 +823,10 @@ If the value is nil, don't highlight the buffer names specially."
         (setq count (+ count (if forwardp -1 1)))
         (setq beg (line-beginning-position)
               end (line-end-position))
-        (if (and keep-props (boundp 'jit-lock-mode) jit-lock-mode
+        (if (and keep-props (if (boundp 'jit-lock-mode) jit-lock-mode)
                  (text-property-not-all beg end 'fontified t))
-            (jit-lock-fontify-now beg end))
+            (if (fboundp 'jit-lock-fontify-now)
+                (jit-lock-fontify-now beg end)))
         (push
          (funcall (if keep-props
                       #'buffer-substring
@@ -1008,9 +1030,11 @@ See also `multi-occur'."
                             endpt (line-end-position)))
                     (setq marker (make-marker))
                     (set-marker marker matchbeg)
-                    (if (and keep-props (boundp 'jit-lock-mode) jit-lock-mode
+                    (if (and keep-props
+                             (if (boundp 'jit-lock-mode) jit-lock-mode)
                              (text-property-not-all begpt endpt 'fontified t))
-                        (jit-lock-fontify-now begpt endpt))
+                        (if (fboundp 'jit-lock-fontify-now)
+                            (jit-lock-fontify-now begpt endpt)))
                     (setq curstring (buffer-substring begpt endpt))
                     ;; Depropertize the string, and maybe
                     ;; highlight the matches
@@ -1258,27 +1282,6 @@ passed in.  If LITERAL is set, no checking is done, anyway."
   (replace-match newtext fixedcase literal)
   noedit)
 
-(defcustom query-replace-highlight t
-  "*Non-nil means to highlight matches during query replacement."
-  :type 'boolean
-  :group 'matching)
-
-(defcustom query-replace-lazy-highlight t
-  "*Controls the lazy-highlighting during query replacements.
-When non-nil, all text in the buffer matching the current match
-is highlighted lazily using isearch lazy highlighting (see
-`isearch-lazy-highlight-initial-delay' and
-`isearch-lazy-highlight-interval')."
-  :type 'boolean
-  :group 'matching
-  :version "21.4")
-
-(defface query-replace
-  '((t (:inherit isearch)))
-  "Face for highlighting query replacement matches."
-  :group 'matching
-  :version "21.4")
-
 (defun perform-replace (from-string replacements
                         query-flag regexp-flag delimited-flag
                         &optional repeat-count map start end)
diff --git a/lisp/simple.el b/lisp/simple.el
index 2baacc01531..77bdb47e250 100644
--- a/lisp/simple.el
+++ b/lisp/simple.el
@@ -647,15 +647,16 @@ If BACKWARD-ONLY is non-nil, only delete spaces before point."
        (skip-chars-backward " \t")
        (constrain-to-field nil orig-pos)))))
 
-(defun just-one-space ()
-  "Delete all spaces and tabs around point, leaving one space."
-  (interactive "*")
+(defun just-one-space (n)
+  "Delete all spaces and tabs around point, leaving one space (or N spaces)."
+  (interactive "*p")
   (let ((orig-pos (point)))
     (skip-chars-backward " \t")
     (constrain-to-field nil orig-pos)
-    (if (= (following-char) ? )
-        (forward-char 1)
-      (insert ? ))
+    (dotimes (i n)
+      (if (= (following-char) ?\ )
+          (forward-char 1)
+        (insert ?\ )))
     (delete-region
      (point)
      (progn
@@ -899,7 +900,7 @@ display the result of expression evaluation."
   (if (and (integerp value)
            (or (not (memq this-command '(eval-last-sexp eval-print-last-sexp)))
                (eq this-command last-command)
-               (and (boundp 'edebug-active) edebug-active)))
+               (if (boundp 'edebug-active) edebug-active)))
       (let ((char-string
              (if (or (and (boundp 'edebug-active) edebug-active)
                      (memq this-command '(eval-last-sexp eval-print-last-sexp)))
@@ -3008,10 +3009,10 @@ Does not set point.  Does nothing if mark ring is empty."
   (when mark-ring
     (setq mark-ring (nconc mark-ring (list (copy-marker (mark-marker)))))
     (set-marker (mark-marker) (+ 0 (car mark-ring)) (current-buffer))
-    (deactivate-mark)
     (move-marker (car mark-ring) nil)
     (if (null (mark t)) (ding))
-    (setq mark-ring (cdr mark-ring))))
+    (setq mark-ring (cdr mark-ring)))
+  (deactivate-mark))
 
 (defalias 'exchange-dot-and-mark 'exchange-point-and-mark)
 (defun exchange-point-and-mark (&optional arg)
@@ -3590,7 +3591,7 @@ With argument, do this that many times."
 The place mark goes is the same place \\[forward-word] would
 move to with the same argument.
 Interactively, if this command is repeated
-or (in Transient Mark mode) if the mark is active, 
+or (in Transient Mark mode) if the mark is active,
 it marks the next ARG words after the ones already marked."
   (interactive "P\np")
   (cond ((and allow-extend
@@ -4115,7 +4116,7 @@ specification for `play-sound'."
     (play-sound sound)))
 
 (define-key global-map "\e\e\e" 'keyboard-escape-quit)
-
+
 (defcustom read-mail-command 'rmail
   "*Your preference for a mail reading package.
 This is used by some keybindings which support reading mail.
@@ -4257,7 +4258,7 @@ Each action has the form (FUNCTION . ARGS)."
    (list nil nil nil current-prefix-arg))
   (compose-mail to subject other-headers continue
                 'switch-to-buffer-other-frame yank-action send-actions))
-
+
 (defvar set-variable-value-history nil
   "History of values entered with `set-variable'.")
 
@@ -4320,7 +4321,7 @@ With a prefix argument, set VARIABLE to VALUE buffer-locally."
   ;; Force a thorough redisplay for the case that the variable
   ;; has an effect on the display, like `tab-width' has.
   (force-mode-line-update))
-
+
 ;; Define the major mode for lists of completions.
 
 (defvar completion-list-mode-map nil
@@ -4328,6 +4329,7 @@ With a prefix argument, set VARIABLE to VALUE buffer-locally."
 (or completion-list-mode-map
     (let ((map (make-sparse-keymap)))
       (define-key map [mouse-2] 'mouse-choose-completion)
+      (define-key map [follow-link] 'mouse-face)
       (define-key map [down-mouse-2] nil)
       (define-key map "\C-m" 'choose-completion)
       (define-key map "\e\e\e" 'delete-completion-window)
diff --git a/lisp/startup.el b/lisp/startup.el
index e806dba7716..9dc60f4705f 100644
--- a/lisp/startup.el
+++ b/lisp/startup.el
@@ -871,12 +871,6 @@ or `CVS', and any subdirectory that contains a file named `.nosearch'."
                               (sit-for 1))
                             (setq user-init-file source))))
 
-                      (when (stringp custom-file)
-                        (unless (assoc custom-file load-history)
-                          ;; If the .emacs file has set `custom-file' but hasn't
-                          ;; loaded the file yet, let's load it.
-                          (load custom-file t t)))
-
                       (unless inhibit-default-init
                         (let ((inhibit-startup-message nil))
                           ;; Users are supposed to be told their rights.
diff --git a/lisp/textmodes/ispell.el b/lisp/textmodes/ispell.el
index f3a7616bfd6..0c4aeb1bd24 100644
--- a/lisp/textmodes/ispell.el
+++ b/lisp/textmodes/ispell.el
@@ -1074,15 +1074,54 @@ Protects against bogus binding of `enable-multibyte-characters' in XEmacs."
       (decode-coding-string str (ispell-get-coding-system))
     str))
 
+(put 'ispell-unified-chars-table 'char-table-extra-slots 0)
+
+;; Char-table that maps an Unicode character (charset:
+;; latin-iso8859-1, mule-unicode-0100-24ff, mule-unicode-2500-34ff) to
+;; a string in which all equivalent characters are listed.
+
+(defconst ispell-unified-chars-table
+  (let ((table (make-char-table 'ispell-unified-chars-table)))
+    (map-char-table
+     #'(lambda (c v)
+         (if (and v (/= c v))
+             (let ((unified (or (aref table v) (string v))))
+               (aset table v (concat unified (string c))))))
+     ucs-mule-8859-to-mule-unicode)
+    table))
+
+;; Return a string decoded from Nth element of the current dictionary
+;; while splice equivalent characters into the string.  This splicing
+;; is done only if the string is a regular expression of the form
+;; "[...]" because, otherwise, splicing will result in incorrect
+;; regular expression matching.
+
+(defun ispell-get-decoded-string (n)
+  (let* ((slot (assoc ispell-dictionary ispell-dictionary-alist))
+         (str (nth n slot)))
+    (when (and (> (length str) 0)
+               (not (multibyte-string-p str)))
+      (setq str (ispell-decode-string str))
+      (if (and (= (aref str 0) ?\[)
+               (eq (string-match "\\]" str) (1- (length str))))
+          (setq str
+                (string-as-multibyte
+                 (mapconcat
+                  #'(lambda (c)
+                      (let ((unichar (aref ucs-mule-8859-to-mule-unicode c)))
+                        (if unichar
+                            (aref ispell-unified-chars-table unichar)
+                          (string c))))
+                  str ""))))
+      (setcar (nthcdr n slot) str))
+    str))
+
 (defun ispell-get-casechars ()
-  (ispell-decode-string
-   (nth 1 (assoc ispell-dictionary ispell-dictionary-alist))))
+  (ispell-get-decoded-string 1))
 (defun ispell-get-not-casechars ()
-  (ispell-decode-string
-   (nth 2 (assoc ispell-dictionary ispell-dictionary-alist))))
+  (ispell-get-decoded-string 2))
 (defun ispell-get-otherchars ()
-  (ispell-decode-string
-   (nth 3 (assoc ispell-dictionary ispell-dictionary-alist))))
+  (ispell-get-decoded-string 3))
 (defun ispell-get-many-otherchars-p ()
   (nth 4 (assoc ispell-dictionary ispell-dictionary-alist)))
 (defun ispell-get-ispell-args ()
diff --git a/lisp/textmodes/org.el b/lisp/textmodes/org.el
index fc1ffb329d9..80ff7637365 100644
--- a/lisp/textmodes/org.el
+++ b/lisp/textmodes/org.el
@@ -1,11 +1,11 @@
 ;; org.el --- Outline-based notes management and organizer 
-
+;; Carstens outline-mode for keeping track of everything.
 ;; Copyright (c) 2003, 2004 Free Software Foundation
 
 ;; Author: Carsten Dominik <dominik at science dot uva dot nl>
 ;; Keywords: outlines, hypermedia, calendar
 ;; Homepage: http://www.astro.uva.nl/~dominik/Tools/org/
-;; Version: 3.03
+;; Version: 3.04
 
 ;; This file is part of GNU Emacs.
 
@@ -23,9 +23,7 @@
 ;; along with GNU Emacs; see the file COPYING.  If not, write to the
 ;; Free Software Foundation, Inc., 59 Temple Place - Suite 330,
 ;; Boston, MA 02111-1307, USA.
-
 ;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;
-;; Carsten's outline-mode for keeping track of everything.
 ;;
 ;;; Commentary:
 ;;
@@ -59,6 +57,8 @@
 ;;    (autoload 'org-diary "org" "Diary entries from Org mode")
 ;;    (autoload 'org-agenda "org" "Multi-file agenda from Org mode" t)
 ;;    (autoload 'org-store-link "org" "Store a link to the current location" t)
+;;    (autoload 'orgtbl-mode "org" "Org tables as a minor mode" t)
+;;    (autoload 'turn-on-orgtbl "org" "Org tables as a minor mode")
 ;;    (add-to-list 'auto-mode-alist '("\\.org$" . org-mode))
 ;;    (define-key global-map "\C-cl" 'org-store-link)
 ;;    (define-key global-map "\C-ca" 'org-agenda)
@@ -79,9 +79,18 @@
 ;;
 ;; Changes:
 ;; -------
+;; Version 3.04
+;;    - Table editor optimized to need fewer realignments, and to keep
+;;      table shape when typing in fields.
+;;    - A new minor mode, orgtbl-mode, introduces the Org-mode table editor
+;;      into arbitrary major modes.
+;;    - Fixed bug with realignment in XEmacs.
+;;    - Startup options can be set with special #+STARTUP line.
+;;    - Heading following a match in org-occur can be suppressed.
+;;
 ;; Version 3.03
 ;;    - Copyright transfer to the FSF.
-;;    - Effect of C-u and C-u C-u in org-timeline interchanged.
+;;    - Effect of C-u and C-u C-u in org-timeline swapped.
 ;;    - Timeline now always contains today, and `.' jumps to it.
 ;;    - Table editor:
 ;;      - cut and paste of regtangular regions in tables
@@ -204,7 +213,7 @@
 
 ;;; Customization variables
 
-(defvar org-version "3.03"
+(defvar org-version "3.04"
   "The version number of the file org.el.")
 (defun org-version (arg)
   (interactive "P")
@@ -402,11 +411,11 @@ lisp variable `state'."
   "Matches the SCHEDULED keyword together with a time stamp.")
 (make-variable-buffer-local 'org-scheduled-time-regexp)
 
-(defun org-set-regexps ()
+(defun org-set-regexps-and-options ()
   "Precompute regular expressions for current buffer."
   (when (eq major-mode 'org-mode)
     (let ((re (org-make-options-regexp
-               '("CATEGORY" "SEQ_TODO" "PRI_TODO" "TYP_TODO")))
+               '("CATEGORY" "SEQ_TODO" "PRI_TODO" "TYP_TODO" "STARTUP")))
           (splitre "[ \t]+")
           kwds int key value cat)
       (save-restriction
@@ -426,7 +435,17 @@ lisp variable `state'."
                     kwds (append kwds (org-split-string value splitre))))
              ((equal key "TYP_TODO")
               (setq int 'type
-                    kwds (append kwds (org-split-string value splitre)))))
+                    kwds (append kwds (org-split-string value splitre))))
+             ((equal key "STARTUP")
+              (let ((opts (org-split-string value splitre))
+                    (set '(("fold" org-startup-folded t)
+                           ("nofold" org-startup-folded nil)
+                           ("dlcheck" org-startup-with-deadline-check t)
+                           ("nodlcheck" org-startup-with-deadline-check nil)))
+                    l var val)
+                (while (setq l (assoc (pop opts) set))
+                  (setq var (nth 1 l) val (nth 2 l))
+                  (set (make-local-variable var) val)))))             
             )))
       (and cat (set (make-local-variable 'org-category) cat))
       (and kwds (set (make-local-variable 'org-todo-keywords) kwds))
@@ -465,8 +484,6 @@ lisp variable `state'."
           (concat "\\<" org-scheduled-string " *<\\([^>]+\\)>"))
     (org-set-font-lock-defaults)))
 
-;(add-hook 'hack-local-variables-hook 'org-set-regexps)
-
 (defgroup org-time nil
   "Options concerning time stamps and deadlines in Org-mode."
   :tag "Org Time"
@@ -540,7 +557,7 @@ When nil, always start on the current day."
   :type 'number)
 
 (defcustom org-agenda-include-all-todo t
-  "Non-nil means, the multifile agenda will always contain alm TODO entries.
+  "Non-nil means, the multifile agenda will always contain all TODO entries.
 When nil, date-less entries will only be shown if `org-agenda' is called
 with a prefix argument.
 When non-nil, the TODO entries will be listed at the top of the agenda, before
@@ -639,6 +656,18 @@ t      Everywhere except in headlines"
   "Formats for `format-time-string' which are used for time stamps.
 It is not recommended to change this constant.")
 
+(defcustom org-show-following-heading t
+  "Non-nil means, show heading following match in `org-occur'.
+When doing an `org-occur' it is useful to show the headline which
+follows the match, even if they do not match the regexp. This makes it
+easier to edit directly inside the sparse tree. However, if you use
+org-occur mainly as an overview, the following headlines are
+unnecessary clutter."
+  :group 'org-structure
+  :type 'boolean)
+
+
+
 (defgroup org-link nil
   "Options concerning links in Org-mode."
   :tag "Org Link"
@@ -845,11 +874,34 @@ When nil, new notes will be filed to the end of a file or entry."
   :tag "Org Table"
   :group 'org)
 
-(defcustom org-enable-table-editor t
+(defcustom org-enable-table-editor 'optimized
   "Non-nil means, lines starting with \"|\" are handled by the table editor.
-When nil, such lines will be treated like ordinary lines."
+When nil, such lines will be treated like ordinary lines.
+
+When equal to the symbol `optimized', the table editor will be optimized to
+do the following
+- Use automatic overwrite mode in front of whitespace in table fields.
+  This make the structure of the table stay in tact as long as the edited
+  field does not exceed the column width.
+- Minimize the number of realigns.  Normally, the table is aligned each time
+  TAB or RET are pressed to move to another field.  With optimization this
+  happens only if changes to a field might have  changed the column width.
+Optimization requires replacing the functions `self-insert-command',
+`delete-char', and `backward-delete-char' in Org-mode buffers, with a
+slight (in fact: unnoticable) speed impact for normal typing.  Org-mode is
+very good at guessing when a re-align will be necessary, but you can always
+force one with `C-c C-c'.
+
+I you would like to use the optimized version in Org-mode, but the un-optimized
+version in OrgTbl-mode, see the variable `orgtbl-optimized'.
+
+This variable can be used to turn on and off the table editor during a session,
+but in order to toggle optimization, a restart is required."
   :group 'org-table
-  :type 'boolean)
+  :type '(choice
+          (const :tag "off" nil)
+          (const :tag "on" t)
+          (const :tag "on, optimized" optimized)))
 
 (defcustom org-table-default-size "5x2"
   "The default size for newly created tables, Columns x Rows."
@@ -1295,6 +1347,8 @@ Otherwise, the buffer will just be saved to a file and stay hidden."
 (eval-when-compile
   (defvar zmacs-regions)
   (defvar org-transient-mark-mode)
+  (defvar org-old-auto-fill-inhibit-regexp)
+  (defvar orgtbl-mode-menu)
   (defvar org-html-entities)
   (defvar org-goto-start-pos)
   (defvar org-cursor-color)
@@ -1351,7 +1405,7 @@ messages (Gnus), BBDB entries, and any files related to the project.
 For printing and sharing of notes, an Org-mode file (or a part of it)
 can be exported as a well-structured ASCII or HTML file.
 
-+  The following commands are available:
+The following commands are available:
 
 \\{org-mode-map}"
   (interactive "P")
@@ -1363,10 +1417,12 @@ can be exported as a well-structured ASCII or HTML file.
   (org-install-agenda-files-menu)
   (setq outline-regexp "\\*+")
   (if org-startup-truncated (setq truncate-lines t))
-  (org-set-regexps)
+  (org-set-regexps-and-options)
   (set (make-local-variable 'font-lock-unfontify-region-function)
        'org-unfontify-region)
   ;; Activate before-change-function
+  (set (make-local-variable 'org-table-may-need-update) t)
+  (make-local-hook 'before-change-functions)  ;; needed for XEmacs
   (add-hook 'before-change-functions 'org-before-change-function nil
             'local)
   ;; Inhibit auto-fill for headers, tables and fixed-width lines.
@@ -1507,7 +1563,7 @@ can be exported as a well-structured ASCII or HTML file.
 (defvar org-cycle-global-status nil)
 (defvar org-cycle-subtree-status nil)
 (defun org-cycle (&optional arg)
-  "Visibility cycling for outline(-minor)-mode.
+  "Visibility cycling for org-mode.
 
 - When this function is called with a prefix argument, rotate the entire
   buffer through 3 states (global cycling)
@@ -1540,7 +1596,9 @@ can be exported as a well-structured ASCII or HTML file.
    ((org-at-table-p 'any)
     ;; Enter the table or move to the next field in the table
     (or (org-table-recognize-table.el)
-        (org-table-next-field)))
+        (progn
+          (org-table-justify-field-maybe)
+          (org-table-next-field))))
 
    (arg ;; Global cycling
 
@@ -1765,9 +1823,9 @@ or nil."
 (defvar org-ignore-region nil
   "To temporary disable the active region.")
 
-(defun org-insert-heading ()
+(defun org-insert-heading (arg)
   "Insert a new heading with same depth at point."
-  (interactive)
+  (interactive "P")
   (let* ((head (save-excursion
                  (condition-case nil
                      (org-back-to-heading)
@@ -2271,14 +2329,14 @@ that the match should indeed be shown."
         (message "%d match(es) for regexp %s" cnt regexp))
     cnt))
 
-
 (defun org-show-hierarchy-above ()
   "Make sure point and the headings hierarchy above is visible."
   (if (org-on-heading-p t)
       (org-flag-heading nil)    ; only show the heading
     (org-show-hidden-entry))    ; show entire entry
   (save-excursion
-    (and (outline-next-heading)
+    (and org-show-following-heading
+         (outline-next-heading)
          (org-flag-heading nil)))  ; show the next heading
   (save-excursion                  ; show all higher headings
     (while (condition-case nil
@@ -2361,7 +2419,7 @@ Otherwise, only the date will be included.  All parts of a date not
 specified by the user will be filled in from the current date/time.
 So if you press just return without typing anything, the time stamp
 will represent the current date/time.  If there is already a timestamp
-at the cursoe, it will be modified."
+at the cursor, it will be modified."
   (interactive "P")
   (let ((fmt (if arg (cdr org-time-stamp-formats)
                (car org-time-stamp-formats)))
@@ -2798,7 +2856,11 @@ If there is already a time stamp at the cursor position, update it."
 
 ;;;###autoload
 (defun org-agenda-mode ()
-  "Mode for time-sorted view on action items in Org-mode files."
+  "Mode for time-sorted view on action items in Org-mode files.
+
+The following commands are available:
+
+\\{org-agenda-mode-map}"
   (interactive)
   (kill-all-local-variables)
   (setq major-mode 'org-agenda-mode)
@@ -3118,7 +3180,7 @@ NDAYS defaults to `org-agenda-ndays'."
 (defun org-check-agenda-file (file)
   "Make sure FILE exists.  If not, ask user what to do."
   ;; FIXME:  this does not correctly change the menus
-  ;; Could be fixed by explicitly going to the buffer, maybe.
+  ;; Could probably be fixed by explicitly going to the buffer.
   (when (not (file-exists-p file))
     (message "non-existent file %s.  [R]emove from agenda-files or [A]bort?"
              file)
@@ -4507,7 +4569,6 @@ RET at beg-of-buf -> Append to file as level 2 headline
 RET on headline   -> Store as sublevel entry to current headline
 <left>/<right>    -> before/after current headline, same headings level")
 
-;; FIXME: Document C-u C-c C-c
 ;;;###autoload
 (defun org-remember-handler ()
   "Store stuff from remember.el into an org file.
@@ -4796,6 +4857,21 @@ Such a file can be imported into a spreadsheet program like Excel."
       (save-buffer))
     (kill-buffer buf)))
 
+(defvar org-table-aligned-begin-marker (make-marker)
+  "Marker at the beginning of the table last aligned.
+Used to check if cursor still is in that table, to minimize realignment.")
+(defvar org-table-aligned-end-marker (make-marker)
+  "Marker at the end of the table last aligned.
+Used to check if cursor still is in that table, to minimize realignment.")
+(defvar org-table-last-alignment nil
+  "List of flags for flushright alignment, from the last re-algnment.
+This is being used to correctly align a single field after TAB or RET.")
+;; FIXME:  The following is currently not used.
+(defvar org-table-last-column-widths nil
+  "List of max width of ffields in each column.
+This is being used to correctly align a single field after TAB or RET.")
+
+
 (defun org-table-align (&optional arg)
   "Align the table at point by aligning all vertical bars."
   (interactive "P")
@@ -4866,6 +4942,8 @@ Such a file can be imported into a spreadsheet program like Excel."
       (push (>= frac org-table-number-fraction) typenums))
     (setq lengths (nreverse lengths)
           typenums (nreverse typenums))
+    (setq org-table-last-alignment typenums
+          org-table-last-column-widths lengths)
     ;; Compute the formats needed for output of the table
     (setq rfmt (concat indent "|") hfmt (concat indent "|"))
     (while (setq l (pop lengths))
@@ -4884,13 +4962,14 @@ Such a file can be imported into a spreadsheet program like Excel."
     ;; Replace the old one
     (delete-region beg end)
     (move-marker end nil)
+    (move-marker org-table-aligned-begin-marker (point))
     (insert new)
+    (move-marker org-table-aligned-end-marker (point))
     ;; Try to move to the old location (approximately)
     (goto-line linepos)
     (set-window-start (selected-window) winstart 'noforce)
     (org-table-goto-column colpos)
     (setq org-table-may-need-update nil)
-    ;; (message "Aligning table...done")
     (if (org-in-invisibility-spec-p '(org-table))
         (org-table-add-invisible-to-vertical-lines))
     ))
@@ -4920,6 +4999,35 @@ With argument TABLE-TYPE, go to the end of a table.el-type table."
       (goto-char (match-beginning 0)))
     (point-marker)))
 
+(defun org-table-justify-field-maybe ()
+  "Justify the current field, text to left, number to right."
+  (cond
+   (org-table-may-need-update) ; Realignment will happen anyway, don't bother
+   ((org-at-table-hline-p)
+    ;; This is pretty stupid, but I don't know how to deal with hlines
+    (setq org-table-may-need-update t))
+   ((or (not (equal (marker-buffer org-table-aligned-begin-marker)
+                    (current-buffer)))
+        (< (point) org-table-aligned-begin-marker)
+        (>= (point) org-table-aligned-end-marker))
+    ;; This is not the same table, force a full re-align
+    (setq org-table-may-need-update t))
+   (t ;; realign the current field, based on previous full realign
+    (let* ((pos (point)) s org-table-may-need-update
+           (col (org-table-current-column))
+           (num (nth (1- col) org-table-last-alignment))
+           l f)
+      (when (> col 0)
+        (skip-chars-backward "^|\n")
+        (if (looking-at " *\\([^|\n]*?\\) *|")
+            (progn
+              (setq s (match-string 1)
+                    l (max 1 (- (match-end 0) (match-beginning 0) 3)))
+              (setq f (format (if num " %%%ds |" " %%-%ds |") l))
+              (replace-match (format f s t t)))
+          (setq org-table-may-need-update t))
+        (goto-char pos))))))
+
 (defun org-table-next-field (&optional arg)
   "Go to the next field in the current table.
 Before doing so, re-align the table if necessary."
@@ -5013,18 +5121,21 @@ I.e. not on a hline or before the first or after the last column?"
       (error "Not in table data field")))
 
 (defun org-table-blank-field ()
-  "Blank the current table field."
+  "Blank the current table field or active region."
   (interactive)
   (org-table-check-inside-data-field)
-  (skip-chars-backward "^|")
-  (backward-char 1)
-  (if (looking-at "|[^|]+")
-      (let* ((pos (match-beginning 0))
-             (match (match-string 0))
-             (len (length match)))
-        (replace-match (concat "|" (make-string (1- len) ?\ )))
-        (goto-char (+ 2 pos))
-        (substring match 1))))
+  (if (and (interactive-p) (org-region-active-p))
+      (let (org-table-clip)
+        (org-table-cut-region))
+    (skip-chars-backward "^|")
+    (backward-char 1)
+    (if (looking-at "|[^|]+")
+        (let* ((pos (match-beginning 0))
+               (match (match-string 0))
+               (len (length match)))
+          (replace-match (concat "|" (make-string (1- len) ?\ )))
+          (goto-char (+ 2 pos))
+          (substring match 1)))))
 
 (defun org-table-get-field (&optional n replace)
   "Return the value of the field in column N of current row.
@@ -5199,6 +5310,15 @@ However, when FORCE is non-nil, create new columns if necessary."
     (org-table-goto-column colpos))
   (org-table-align))
 
+(defun org-table-move-column-right ()
+  "Move column to the right."
+  (interactive)
+  (org-table-move-column nil))
+(defun org-table-move-column-left ()
+  "Move column to the left."
+  (interactive)
+  (org-table-move-column 'left))
+
 (defun org-table-move-column (&optional left)
   "Move the current column to the right.  With arg LEFT, move to the left."
   (interactive "P")
@@ -5230,6 +5350,15 @@ However, when FORCE is non-nil, create new columns if necessary."
     (org-table-goto-column colpos))
   (org-table-align))
 
+(defun org-table-move-row-down ()
+  "Move table row down."
+  (interactive)
+  (org-table-move-row nil))
+(defun org-table-move-row-up ()
+  "Move table row down."
+  (interactive)
+  (org-table-move-row 'up))
+
 (defun org-table-move-row (&optional up)
   "Move the current table line down. With arg UP, move it up."
   (interactive "P")
@@ -5263,11 +5392,12 @@ With prefix ARG, insert below the current line."
         (setq line (mapcar (lambda (x) (if (member x '(?| ?+)) ?| ?\ )) line))
       (setq line (mapcar (lambda (x) (if (equal x ?|) ?| ?\ )) line)))
     (beginning-of-line (if arg 2 1))
-    (apply 'insert line)
-    (insert "\n")
+    (let (org-table-may-need-update)
+      (apply 'insert-before-markers line)
+      (insert-before-markers "\n"))
     (beginning-of-line 0)
     (re-search-forward "| ?" (point-at-eol) t)
-    (org-table-align)))
+    (and org-table-may-need-update (org-table-align))))
 
 (defun org-table-insert-hline (&optional arg)
   "Insert a horizontal-line below the current line into the table.
@@ -5788,6 +5918,271 @@ separator line)."
         (setq ndown 0)))
     (org-table-align)))
 
+;;; The orgtbl minor mode
+
+;; Define a minor mode which can be used in other modes in order to
+;; integrate the org-mode table editor.
+
+;; This is really a hack, because the org-mode table editor uses several
+;; keys which normally belong to the major mode, for example the TAB and
+;; RET keys.  Here is how it works: The minor mode defines all the keys
+;; necessary to operate the table editor, but wraps the commands into a
+;; function which tests if the cursor is currently inside a table.  If that
+;; is the case, the table editor command is executed.  However, when any of
+;; those keys is used outside a table, the function uses `key-binding' to
+;; look up if the key has an associated command in another currently active
+;; keymap (minor modes, major mode, global), and executes that command.
+;; There might be problems if any of the keys used by the table editor is
+;; otherwise used as a prefix key.
+
+;; Another challenge is that the key binding for TAB can be tab or \C-i,
+;; likewise the binding for RET can be return or \C-m.  Orgtbl-mode
+;; addresses this by checking explicitly for both bindings.
+
+;; The optimized version (see variable `orgtbl-optimized') takes over
+;; all keys which are bound to `self-insert-command' in the *global map*.
+;; Some modes bind other commands to simple characters, for example
+;; AUCTeX binds the double quote to `Tex-insert-quote'.  With orgtbl-mode
+;; active, this binding is ignored inside tables and replaced with a
+;; modified self-insert.
+
+(defcustom orgtbl-optimized (eq org-enable-table-editor 'optimized)
+  "Non-nil means, use the optimized table editor version for orgtbl-mode.
+In the optimized version, the table editor takes over all simple keys that
+normally just insert a character.  In tables, the characters are inserted
+in a way to minimize disturbing the table structure (i.e. in overwrite mode
+for empty fields).  Outside tables, the correct binding of the keys is
+restored.
+
+The default for this option is t if the optimized version is also used in
+Org-mode.  See the variable `org-enable-table-editor' for details.  Changing
+this variable requires a restart of Emacs to become effective."
+  :group 'org-table
+  :type 'boolean)
+
+(defvar orgtbl-mode nil
+  "Variable controlling orgtbl-mode, a minor mode enabling the org-mode
+table editor iin arbitrary modes.")
+(make-variable-buffer-local 'orgtbl-mode)
+
+(defvar orgtbl-mode-map (make-sparse-keymap)
+  "Keymap for orgtbl-mode.")
+
+;;;###autoload
+(defun turn-on-orgtbl ()
+  "Unconditionally turn on orgtbl-mode."
+  (orgtbl-mode 1))
+
+;;;###autoload
+(defun orgtbl-mode (&optional arg)
+  "The org-mode table editor as a minor mode for use in other modes." 
+  (interactive) 
+  (setq orgtbl-mode
+        (if arg (> (prefix-numeric-value arg) 0) (not orgtbl-mode)))
+  (if orgtbl-mode
+      (progn 
+        (set (make-local-variable (quote org-table-may-need-update)) t)
+        (make-local-hook (quote before-change-functions))
+        (add-hook 'before-change-functions 'org-before-change-function
+                  nil 'local)
+        (set (make-local-variable 'org-old-auto-fill-inhibit-regexp)
+             auto-fill-inhibit-regexp)
+        (set (make-local-variable 'auto-fill-inhibit-regexp)
+             (if auto-fill-inhibit-regexp 
+                 (concat "\\([ \t]*|\\|" auto-fill-inhibit-regexp)
+               "[ \t]*|"))
+        (easy-menu-add orgtbl-mode-menu)
+        (run-hooks (quote orgtbl-mode-hook)))
+    (setq auto-fill-inhibit-regexp org-old-auto-fill-inhibit-regexp)
+    (remove-hook 'before-change-functions 'org-before-change-function t)
+    (easy-menu-remove orgtbl-mode-menu)
+    (force-mode-line-update 'all)))
+
+;; Install it as a minor mode.
+(put 'orgtbl-mode :included t)
+(put 'orgtbl-mode :menu-tag "Org Table Mode")
+(add-minor-mode 'orgtbl-mode " OrgTbl" orgtbl-mode-map)
+
+(defun orgtbl-make-binding (fun &rest keys)
+  "Create a function for binding in the table minor mode."
+  (list 'lambda '(arg) '(interactive "p")
+        (list 'if
+              '(org-at-table-p)
+              (list 'call-interactively (list 'quote fun))
+              (list 'let '(orgtbl-mode)
+                    (list 'call-interactively
+                          (append '(or)
+                                  (mapcar (lambda (k)
+                                            (list 'key-binding k))
+                                          keys)
+                                  '('orgtbl-error)))))))
+
+(defun orgtbl-error ()
+  "Error when there is no default binding for a table key."
+  (interactive)
+  (error "This key is has no function outside tables"))
+
+;; Keybindings for the minor mode
+(let ((bindings
+       '(([(meta shift left)]  org-table-delete-column)
+         ([(meta left)]        org-table-move-column-left)
+         ([(meta right)]       org-table-move-column-right)
+         ([(meta shift right)] org-table-insert-column)
+         ([(meta shift up)]    org-table-kill-row)
+         ([(meta shift down)]  org-table-insert-row)
+         ([(meta up)]          org-table-move-row-up)
+         ([(meta down)]        org-table-move-row-down)
+         ("\C-c\C-w"           org-table-cut-region)
+         ("\C-c\M-w"           org-table-copy-region)
+         ("\C-c\C-y"           org-table-paste-rectangle)
+         ("\C-c-"              org-table-insert-hline)
+         ([(shift tab)]        org-table-previous-field)
+         ("\C-c\C-c"           org-table-align)
+         ([(return)]           org-table-next-row)
+         ([(shift return)]     org-table-copy-from-above)
+         ([(meta return)]      org-table-wrap-region)
+         ("\C-c\C-q"           org-table-wrap-region)
+         ("\C-c?"              org-table-current-column)
+         ("\C-c "              org-table-blank-field)
+         ("\C-c+"              org-table-sum)
+         ("\C-c|"              org-table-toggle-vline-visibility)
+         ("\C-c="              org-table-eval-formula)))
+      elt key fun cmd)
+  (while (setq elt (pop bindings))
+    (setq key (car elt)
+          fun (nth 1 elt)
+          cmd (orgtbl-make-binding fun key))
+    (define-key orgtbl-mode-map key cmd)))
+
+;; Special treatment needed for TAB and RET
+;(define-key orgtbl-mode-map [(return)] 
+;  (orgtbl-make-binding 'org-table-next-row [(return)] "\C-m"))
+;(define-key orgtbl-mode-map "\C-m" 
+;  (orgtbl-make-binding 'org-table-next-row "\C-m" [(return)]))
+;(define-key orgtbl-mode-map [(tab)] 
+;  (orgtbl-make-binding 'org-table-next-field [(tab)] "\C-i"))
+;(define-key orgtbl-mode-map "\C-i"
+;  (orgtbl-make-binding 'org-table-next-field "\C-i" [(tab)]))
+
+(define-key orgtbl-mode-map [(return)] 
+  (orgtbl-make-binding 'orgtbl-ret [(return)] "\C-m"))
+(define-key orgtbl-mode-map "\C-m" 
+  (orgtbl-make-binding 'orgtbl-ret "\C-m" [(return)]))
+(define-key orgtbl-mode-map [(tab)] 
+  (orgtbl-make-binding 'orgtbl-tab [(tab)] "\C-i"))
+(define-key orgtbl-mode-map "\C-i"
+  (orgtbl-make-binding 'orgtbl-tab "\C-i" [(tab)]))
+
+(when orgtbl-optimized
+  ;; If the user wants maximum table support, we need to hijack
+  ;; some standard editing functions
+  (substitute-key-definition 'self-insert-command 'orgtbl-self-insert-command
+                             orgtbl-mode-map global-map)
+  (substitute-key-definition 'delete-char 'orgtbl-delete-char
+                             orgtbl-mode-map global-map)
+  (substitute-key-definition 'delete-backward-char 'orgtbl-delete-backward-char
+                             orgtbl-mode-map global-map)
+  (define-key org-mode-map "|" 'self-insert-command))
+
+(defun orgtbl-tab ()
+  "Justification and field motion for orgtbl-mode."
+  (interactive)
+  (org-table-justify-field-maybe)
+  (org-table-next-field))
+
+(defun orgtbl-ret ()
+  "Justification and field motion for orgtbl-mode."
+  (interactive)
+  (org-table-justify-field-maybe)
+  (org-table-next-row))
+
+(defun orgtbl-self-insert-command (N)
+  "Like `self-insert-command', use overwrite-mode for whitespace in tables.
+If the cursor is in a table looking at whitespace, the whitespace is
+overwritten, and the table is not marked as requiring realignment."
+  (interactive "p")
+  (if (and (org-at-table-p)
+           (eq N 1)
+           (looking-at "[^|\n]*  +|"))
+      (let (org-table-may-need-update (pos (point)))
+        (goto-char (1- (match-end 0)))
+        (delete-backward-char 1)
+        (goto-char (match-beginning 0))
+        (self-insert-command N))
+    (setq org-table-may-need-update t)
+    (let (orgtbl-mode)
+      (call-interactively (key-binding (vector last-input-event))))))
+
+(defun orgtbl-delete-backward-char (N)
+  "Like `delete-backward-char', insert whitespace at field end in tables.
+When deleting backwards, in tables this function will insert whitespace in
+front of the next \"|\" separator, to keep the table aligned.  The table will
+still be marked for re-alignment, because a narrow field may lead to a
+reduced column width."
+  (interactive "p")
+  (if (and (org-at-table-p)
+           (eq N 1)
+           (looking-at ".*?|"))
+      (let ((pos (point)))
+        (backward-delete-char N)
+        (skip-chars-forward "^|")
+        (insert " ")
+        (goto-char (1- pos)))
+    (message "%s" last-input-event) (sit-for 1)
+    (delete-backward-char N)))
+
+(defun orgtbl-delete-char (N)
+  "Like `delete-char', but insert whitespace at field end in tables.
+When deleting characters, in tables this function will insert whitespace in
+front of the next \"|\" separator, to keep the table aligned.  The table
+will still be marked for re-alignment, because a narrow field may lead to
+a reduced column width."
+  (interactive "p")
+  (if (and (org-at-table-p)
+           (eq N 1))
+      (if (looking-at ".*?|")
+          (let ((pos (point)))
+            (replace-match (concat
+                            (substring (match-string 0) 1 -1)
+                            " |"))
+            (goto-char pos)))
+    (delete-char N)))
+
+(easy-menu-define orgtbl-mode-menu orgtbl-mode-map "OrgTbl menu"
+  '("Tbl"
+    ["Align" org-ctrl-c-ctrl-c :active (org-at-table-p) :keys "C-c C-c"]
+    ["Next field" org-cycle :active (org-at-table-p) :keys "TAB"]
+    ["Previous Field" org-shifttab :active (org-at-table-p) :keys "S-TAB"]
+    ["Next row" org-return :active (org-at-table-p) :keys "RET"]
+    "--"
+    ["Blank field" org-table-blank-field :active (org-at-table-p) :keys "C-c SPC"]
+    ["Copy field from above"
+     org-table-copy-from-above :active (org-at-table-p) :keys "S-RET"]
+    "--"
+    ("Column"
+     ["Move column left" org-metaleft :active (org-at-table-p) :keys "M-<left>"]
+     ["Move column right" org-metaright :active (org-at-table-p) :keys "M-<right>"]
+     ["Delete column" org-shiftmetaleft :active (org-at-table-p) :keys "M-S-<left>"]
+     ["Insert column" org-shiftmetaright :active (org-at-table-p) :keys "M-S-<right>"])
+    ("Row"
+     ["Move row up" org-metaup :active (org-at-table-p) :keys "M-<up>"]
+     ["Move row down" org-metadown :active (org-at-table-p) :keys "M-<down>"]
+     ["Delete row" org-shiftmetaup :active (org-at-table-p) :keys "M-S-<up>"]
+     ["Insert row" org-shiftmetadown :active (org-at-table-p) :keys "M-S-<down>"]
+     "--"
+     ["Insert hline" org-table-insert-hline :active (org-at-table-p) :keys "C-c -"])
+    ("Rectangle"
+     ["Copy rectangle" org-copy-special :active (org-at-table-p) :keys "C-c M-w"]
+     ["Cut rectangle" org-cut-special :active (org-at-table-p) :keys "C-c C-w"]
+     ["Paste rectangle" org-paste-special :active (org-at-table-p) :keys "C-c C-y"]
+     ["Fill rectangle" org-table-wrap-region :active (org-at-table-p) :keys "C-c C-q"])
+    "--"
+    ["Which column?" org-table-current-column :active (org-at-table-p) :keys "C-c ?"]
+    ["Sum column/rectangle" org-table-sum 
+     :active (or (org-at-table-p) (org-region-active-p)) :keys "C-c +"]
+    ["Eval formula" org-table-eval-formula :active (org-at-table-p) :keys "C-c ="]
+    ))
+
 ;;; Exporting
 
 (defconst org-level-max 20)
@@ -6300,6 +6695,7 @@ Does include HTML export options as well as TODO and CATEGORY stuff."
 #+CATEGORY:  %s
 #+SEQ_TODO:  %s
 #+TYP_TODO:  %s
+#+STARTUP:   %s %s
 "
    (buffer-name) (user-full-name) user-mail-address org-export-default-language
    org-export-headline-levels
@@ -6318,7 +6714,10 @@ Does include HTML export options as well as TODO and CATEGORY stuff."
      "TODO FEEDBACK VERIFY DONE")
    (if (equal org-todo-interpretation 'type)
        (mapconcat 'identity org-todo-keywords " ")
-     "Me Jason Marie DONE")))
+     "Me Jason Marie DONE")
+   (if org-startup-folded "fold" "nofold")
+   (if org-startup-with-deadline-check "dlcheck" "nodlcheck")
+   ))
 
 (defun org-insert-export-options-template ()
   "Insert into the buffer a template with information for exporting."
@@ -7025,6 +7424,7 @@ When LEVEL is non-nil, increase section numbers on that level."
 (define-key org-mode-map "\C-c\C-c"       'org-ctrl-c-ctrl-c)
 (define-key org-mode-map [(return)]       'org-return)
 (define-key org-mode-map [(shift return)] 'org-table-copy-from-above)
+(define-key org-mode-map [(meta return)]  'org-meta-return)
 (define-key org-mode-map [(control up)]   'org-move-line-up)
 (define-key org-mode-map [(control down)] 'org-move-line-down)
 (define-key org-mode-map "\C-c?"          'org-table-current-column)
@@ -7041,6 +7441,105 @@ When LEVEL is non-nil, increase section numbers on that level."
 (define-key org-mode-map "\C-c\C-xh"      'org-export-as-html)
 (define-key org-mode-map "\C-c\C-x\C-h"   'org-export-as-html-and-open)
 
+
+;; FIXME:  Do we really need to save match data in these commands?
+;; I would like to remove it in order to minimize impact.
+;; Self-insert already does not preserve it.  How much resources does this take???
+
+(defsubst org-table-p ()
+  (if (and (eq major-mode 'org-mode) font-lock-mode)
+      (eq (get-text-property (point) 'face) 'org-table-face)
+    (save-match-data (org-at-table-p))))
+
+(defun org-self-insert-command (N)
+  "Like `self-insert-command', use overwrite-mode for whitespace in tables.
+If the cursor is in a table looking at whitespace, the whitespace is
+overwritten, and the table is not marked as requiring realignment."
+  (interactive "p")
+  (if (and (org-table-p)
+           (eq N 1)
+           (looking-at "[^|\n]*  +|"))
+      (let (org-table-may-need-update (pos (point)))
+        (goto-char (1- (match-end 0)))
+        (delete-backward-char 1)
+        (goto-char (match-beginning 0))
+        (self-insert-command N))
+    (setq org-table-may-need-update t)
+    (self-insert-command N)))
+
+;; FIXME:
+;; The following two functions might still be optimized to trigger
+;; re-alignment less frequently.  Right now they raise the flag each time
+;; (through before-change-functions).  Here is how this could be minimized:
+;; Basically, check if the non-white field width before deletion is
+;; equal to the column width.  If yes, the delete should trigger a
+;; re-align.  I have not implemented this so far because it is not so
+;; easy, requires grabbing the field etc.  So it may finally have some
+;; impact on typing performance which we don't want.
+
+;; The defsubst is only a draft, untested...
+
+;; Maybe it is not so important to get rid of realigns - maybe the most
+;; important aspect is to keep the table look noce as long as possible,
+;; which is already achieved...
+
+;(defsubst org-check-delete-triggers-realign ()
+;  (let ((pos (point)))
+;    (skip-chars-backward "^|\n")
+;    (and (looking-at " *\\(.*?\\) *|")
+;         (= (nth (1- (org-table-current-column))
+;                 org-table-last-column-widths)
+;            (- (match-end 1) (match-beginning 1)))
+;         (setq org-table-may-need-update t))))
+
+(defun org-delete-backward-char (N)
+  "Like `delete-backward-char', insert whitespace at field end in tables.
+When deleting backwards, in tables this function will insert whitespace in
+front of the next \"|\" separator, to keep the table aligned.  The table will
+still be marked for re-alignment, because a narrow field may lead to a
+reduced column width."
+  (interactive "p")
+  (if (and (org-table-p)
+           (eq N 1)
+           (looking-at ".*?|"))
+      (let ((pos (point)))
+        (backward-delete-char N)
+        (skip-chars-forward "^|")
+        (insert " ")
+        (goto-char (1- pos)))
+    (backward-delete-char N)))
+
+(defun org-delete-char (N)
+  "Like `delete-char', but insert whitespace at field end in tables.
+When deleting characters, in tables this function will insert whitespace in
+front of the next \"|\" separator, to keep the table aligned.  The table
+will still be marked for re-alignment, because a narrow field may lead to
+a reduced column width."
+  (interactive "p")
+  (if (and (org-table-p)
+           (eq N 1))
+      (if (looking-at ".*?|")
+          (let ((pos (point)))
+            (replace-match (concat
+                            (substring (match-string 0) 1 -1)
+                            " |"))
+            (goto-char pos)))
+    (delete-char N)))
+
+;; How to do this: Measure non-white length of current string
+;; If equal to column width, we should realign.
+
+(when (eq org-enable-table-editor 'optimized)
+  ;; If the user wants maximum table support, we need to hijack
+  ;; some standard editing functions
+  (substitute-key-definition 'self-insert-command 'org-self-insert-command
+                             org-mode-map global-map)
+  (substitute-key-definition 'delete-char 'org-delete-char
+                             org-mode-map global-map)
+  (substitute-key-definition 'delete-backward-char 'org-delete-backward-char
+                             org-mode-map global-map)
+  (define-key org-mode-map "|" 'self-insert-command))
+
 (defun org-shiftcursor-error ()
   "Throw an error because Shift-Cursor command was applied in wrong context."
   (error "This command is only active in tables and on headlines."))
@@ -7173,9 +7672,18 @@ the automatic table editor has been turned off."
   "Call `org-table-next-row' or `newline'."
   (interactive "P")
   (cond
-   ((org-at-table-p) (org-table-next-row))
+   ((org-at-table-p)
+    (org-table-justify-field-maybe)
+    (org-table-next-row))
    (t (newline))))
 
+(defun org-meta-return (&optional arg)
+  "Call `org-insert-heading' or `org-table-wrap-region'."
+  (interactive "P")
+  (cond
+   ((org-at-table-p)
+    (org-table-wrap-region arg))
+   (t (org-insert-heading arg))))
 
 ;;; Menu entries
 
@@ -7245,7 +7753,7 @@ the automatic table editor has been turned off."
      ["Check Deadlines this file" org-check-deadlines t]
      ["Timeline current file" org-timeline t]
      "--"
-     ["Adenda (multifile)" org-agenda-overview t])
+     ["Adenda (multifile)" org-agenda t])
     ("File List for Agenda")
     "--"
     ("Hyperlinks"
@@ -7586,6 +8094,7 @@ When ENTRY is non-nil, show the entire entry."
 
 (run-hooks 'org-load-hook)
 
+;; arch-tag: e77da1a7-acc7-4336-b19e-efa25af3f9fd
+
 ;;; org.el ends here
 
-;; arch-tag: e77da1a7-acc7-4336-b19e-efa25af3f9fd
diff --git a/lisp/textmodes/reftex-auc.el b/lisp/textmodes/reftex-auc.el
index 534e4e7b27b..93cd0757b4e 100644
--- a/lisp/textmodes/reftex-auc.el
+++ b/lisp/textmodes/reftex-auc.el
@@ -1,8 +1,8 @@
 ;;; reftex-auc.el --- RefTeX's interface to AUCTeX
-;; Copyright (c) 1997, 1998, 1999, 2000, 2003 Free Software Foundation, Inc.
+;; Copyright (c) 1997, 1998, 1999, 2000, 2003, 2004 Free Software Foundation, Inc.
 
 ;; Author: Carsten Dominik <dominik@science.uva.nl>
-;; Version: 4.21
+;; Version: 4.26
 
 ;; This file is part of GNU Emacs.
 
diff --git a/lisp/textmodes/reftex-cite.el b/lisp/textmodes/reftex-cite.el
index e25464c798d..6369f9637db 100644
--- a/lisp/textmodes/reftex-cite.el
+++ b/lisp/textmodes/reftex-cite.el
@@ -1,8 +1,8 @@
 ;;; reftex-cite.el --- creating citations with RefTeX
-;; Copyright (c) 1997, 1998, 1999, 2000, 2003 Free Software Foundation, Inc.
+;; Copyright (c) 1997, 1998, 1999, 2000, 2003, 2004 Free Software Foundation, Inc.
 
 ;; Author: Carsten Dominik <dominik@science.uva.nl>
-;; Version: 4.21
+;; Version: 4.26
 
 ;; This file is part of GNU Emacs.
 
@@ -49,11 +49,11 @@
  TAB        Enter citation key with completion.
  RET        Accept current entry (also on mouse-2) and create \\cite macro.
  m / u      Mark/Unmark the entry.
+ e / E      Create BibTeX file with all (marked/unmarked) entries
  a / A      Put all (marked) entries into one/many \\cite commands.")
 
 ;; Find bibtex files
 
-
 (defmacro reftex-with-special-syntax-for-bib (&rest body)
   `(let ((saved-syntax (syntax-table)))
      (unwind-protect
@@ -311,8 +311,8 @@
       (not (stringp (car al1))))))
 
 (defun reftex-bib-sort-year (e1 e2)
-  (< (string-to-int (cdr (assoc "year" e1)))
-     (string-to-int (cdr (assoc "year" e2)))))
+  (< (string-to-int (or (cdr (assoc "year" e1)) "0"))
+     (string-to-int (or (cdr (assoc "year" e2)) "0"))))
 
 (defun reftex-bib-sort-year-reverse (e1 e2)
   (> (string-to-int (or (cdr (assoc "year" e1)) "0"))
@@ -597,12 +597,13 @@ to `reftex-cite-format' and inserted into the buffer.
 
 If NO-INSERT is non-nil, nothing is inserted, only the selected key returned.
 
-FORAT-KEY can be used to pre-select a citation format.
+FORMAT-KEY can be used to pre-select a citation format.
 
-When called with one or two `C-u' prefixes, first rescans the document.
-When called with a numeric prefix, make that many citations.  When
-called with point inside the braces of a `\\cite' command, it will
-add another key, ignoring the value of `reftex-cite-format'.
+When called with a `C-u' prefix, prompt for optional arguments in
+cite macros.  When called with a numeric prefix, make that many
+citations.  When called with point inside the braces of a `\\cite'
+command, it will add another key, ignoring the value of
+`reftex-cite-format'.
 
 The regular expression uses an expanded syntax: && is interpreted as `and'.
 Thus, `aaaa&&bbb' matches entries which contain both `aaaa' and `bbb'.
@@ -618,7 +619,7 @@ While entering the regexp, completion on knows citation keys is possible.
   ;; Thus look for the scanning info only if in reftex-mode.
 
   (when reftex-mode
-    (reftex-access-scan-info current-prefix-arg))
+    (reftex-access-scan-info nil))
 
   ;; Call reftex-do-citation, but protected
   (unwind-protect
@@ -629,11 +630,14 @@ While entering the regexp, completion on knows citation keys is possible.
   ;; This really does the work of reftex-citation.
 
   (let* ((format (reftex-figure-out-cite-format arg no-insert format-key))
+         (start 0)
          (docstruct-symbol reftex-docstruct-symbol)
          (selected-entries (reftex-offer-bib-menu))
          (insert-entries selected-entries)
          entry string cite-view)
 
+    (when (stringp selected-entries)
+      (error selected-entries))
     (unless selected-entries (error "Quit"))
 
     (if (stringp selected-entries)
@@ -646,6 +650,7 @@ While entering the regexp, completion on knows citation keys is possible.
 
     (when (eq (car selected-entries) 'concat)
       ;; All keys go into a single command - we need to trick a little
+      ;; FIXME: Unfortunately, this meens that commenting does not work right.
       (pop selected-entries)
       (let ((concat-keys (mapconcat 'car selected-entries ",")))
         (setq insert-entries 
@@ -663,6 +668,24 @@ While entering the regexp, completion on knows citation keys is possible.
                                   (reftex-get-bib-field "&key" entry)
                                   format)
                        (reftex-format-citation entry format)))
+        (when (or (eq reftex-cite-prompt-optional-args t)
+                  (and reftex-cite-prompt-optional-args
+                       (equal arg '(4))))
+          (let ((start 0) (nth 0) value)
+            (while (setq start (string-match "\\[\\]" string start))
+              (setq value (read-string (format "Optional argument %d: "
+                                               (setq nth (1+ nth)))))
+              (setq string (replace-match (concat "[" value "]") t t string))
+              (setq start (1+ start)))))
+        ;; Should we cleanup empty optional arguments?
+        ;; if the first is empty, it can be removed.  If the second is empty,
+        ;; it has to go.
+        (when reftex-cite-cleanup-optional-args
+          (cond 
+           ((string-match "\\[\\]\\(\\[[a-zA-Z0-9., ]+\\]\\)" string)
+            (setq string (replace-match "\\1" nil nil string)))
+           ((string-match "\\[\\]\\[\\]" string)
+            (setq string (replace-match "" t t string)))))
         (insert string))
 
       ;; Reposition cursor?
@@ -842,6 +865,17 @@ While entering the regexp, completion on knows citation keys is possible.
                                 (mapcar 'car (nreverse reftex-select-marked))
                               found-list)))
                 (throw 'done t))
+               ((eq key ?e)
+                ;; Take all (marked), and push the symbol 'concat
+                (reftex-extract-bib-file found-list reftex-select-marked)
+                (setq selected-entries "BibTeX database file created")
+                (throw 'done t))
+               ((eq key ?E)
+                ;; Take all (marked), and push the symbol 'concat
+                (reftex-extract-bib-file found-list reftex-select-marked
+                                         'complement)
+                (setq selected-entries "BibTeX database file created")
+                (throw 'done t))
                ((or (eq key ?\C-m)
                     (eq key 'return))
                 ;; Take selected
@@ -882,6 +916,29 @@ While entering the regexp, completion on knows citation keys is possible.
       (ding)
       found-list)))
 
+(defun reftex-extract-bib-file (all &optional marked complement)
+  ;; Limit FOUND-LIST with more regular expressions
+  (let ((file (read-file-name "File to create: ")))
+    (find-file-other-window file)
+    (if (> (buffer-size) 0)
+        (unless (yes-or-no-p 
+                 (format "Overwrite non-empty file %s? " file))
+          (error "Abort")))
+    (erase-buffer)
+    (setq all (delq nil
+                    (mapcar
+                     (lambda (x)
+                       (if marked
+                           (if (or (and (assoc x marked) (not complement))
+                                   (and (not (assoc x marked)) complement))
+                               (cdr (assoc "&entry" x))
+                             nil)
+                         (cdr (assoc "&entry" x))))
+                     all)))
+    (insert (mapconcat 'identity all "\n\n"))
+    (save-buffer)
+    (goto-char (point-min))))
+
 (defun reftex-insert-bib-matches (list)
   ;; Insert the bib matches and number them correctly
   (let ((mouse-face
@@ -1043,5 +1100,73 @@ While entering the regexp, completion on knows citation keys is possible.
       
     (select-window win)))
 
+;;; Global BibTeX file
+(defun reftex-all-used-citation-keys ()
+  (reftex-access-scan-info)
+  (let ((files (reftex-all-document-files)) file keys kkk kk k)
+    (save-excursion
+      (while (setq file (pop files))
+        (set-buffer (reftex-get-file-buffer-force file 'mark))
+        (save-excursion
+          (save-restriction
+            (widen)
+            (goto-char (point-min))
+            (while (re-search-forward "^[^%\n\r]*\\\\\\(bibentry\\|[a-zA-Z]*cite[a-zA-Z]*\\)\\(\\[[^\\]]*\\]\\)?{\\([^}]+\\)}" nil t)
+              (setq kk (match-string-no-properties 3))
+              (while (string-match "%.*\n?" kk)
+                (setq kk (replace-match "" t t kk)))
+              (setq kk (split-string kk "[, \t\r\n]+"))
+              (while (setq k (pop kk))
+                (or (member k keys)
+                    (setq keys (cons k keys)))))))))
+    (reftex-kill-temporary-buffers)
+    keys))
+
+(defun reftex-create-bibtex-file (bibfile)
+  "Create a new BibTeX database file with all entries referenced in document.
+The command prompts for a filename and writes the collected entries to
+that file.  Only entries referenced in the current document with
+any \\cite-like macros are used. 
+The sequence in the new file is the same as it was in the old database."
+  (interactive "FNew BibTeX file: ")
+  (let ((keys (reftex-all-used-citation-keys))
+        (files (reftex-get-bibfile-list))
+        file key entries beg end entry)
+    (save-excursion
+      (while (setq file (pop files))
+        (set-buffer (reftex-get-file-buffer-force file 'mark))
+        (reftex-with-special-syntax-for-bib
+         (save-excursion
+           (save-restriction
+             (widen)
+             (goto-char (point-min))
+             (while (re-search-forward 
+                     "^[ \t]*@[a-zA-Z]+[ \t]*{\\([^ \t\r\n]+\\),"
+                     nil t)
+               (setq key (match-string 1)
+                     beg (match-beginning 0)
+                     end (progn
+                           (goto-char (match-beginning 1))
+                           (condition-case nil
+                               (up-list 1)
+                             (error (goto-char (match-end 0))))
+                           (point)))
+               (when (member key keys)
+                 (setq entry (buffer-substring beg end)
+                       entries (cons entry entries)
+                       keys (delete key keys)))))))))
+    (find-file-other-window bibfile)
+    (if (> (buffer-size) 0)
+        (unless (yes-or-no-p 
+                 (format "Overwrite non-empty file %s? " bibfile))
+          (error "Abort")))
+    (erase-buffer)
+    (insert (mapconcat 'identity (reverse entries) "\n\n"))
+    (goto-char (point-min))
+    (save-buffer)
+    (message "%d entries extracted and copied to new database"
+             (length entries))))
+
+
 ;;; arch-tag: d53d0a5a-ab32-4b52-a846-2a7c3527cd89
 ;;; reftex-cite.el ends here
diff --git a/lisp/textmodes/reftex-dcr.el b/lisp/textmodes/reftex-dcr.el
index dc47a5e7564..e832465cf17 100644
--- a/lisp/textmodes/reftex-dcr.el
+++ b/lisp/textmodes/reftex-dcr.el
@@ -1,8 +1,8 @@
 ;;; reftex-dcr.el --- viewing cross references and citations with RefTeX
-;; Copyright (c) 1997, 1998, 1999, 2000, 2003 Free Software Foundation, Inc.
+;; Copyright (c) 1997, 1998, 1999, 2000, 2003, 2004 Free Software Foundation, Inc.
 
 ;; Author: Carsten Dominik <dominik@science.uva.nl>
-;; Version: 4.21
+;; Version: 4.26
 ;;
 
 ;; This file is part of GNU Emacs.
diff --git a/lisp/textmodes/reftex-global.el b/lisp/textmodes/reftex-global.el
index 84b4c7c67f5..d4d91b476e9 100644
--- a/lisp/textmodes/reftex-global.el
+++ b/lisp/textmodes/reftex-global.el
@@ -1,8 +1,8 @@
 ;;; reftex-global.el --- operations on entire documents with RefTeX
-;; Copyright (c) 1997, 1998, 1999, 2000, 2003 Free Software Foundation, Inc.
+;; Copyright (c) 1997, 1998, 1999, 2000, 2003, 2004 Free Software Foundation, Inc.
 
 ;; Author: Carsten Dominik <dominik@science.uva.nl>
-;; Version: 4.21
+;; Version: 4.26
 
 ;; This file is part of GNU Emacs.
 
diff --git a/lisp/textmodes/reftex-index.el b/lisp/textmodes/reftex-index.el
index 71b3b624770..cb02f2e056f 100644
--- a/lisp/textmodes/reftex-index.el
+++ b/lisp/textmodes/reftex-index.el
@@ -1,8 +1,8 @@
 ;;; reftex-index.el --- index support with RefTeX
-;; Copyright (c) 1997, 1998, 1999, 2000, 2003 Free Software Foundation, Inc.
+;; Copyright (c) 1997, 1998, 1999, 2000, 2003, 2004 Free Software Foundation, Inc.
 
 ;; Author: Carsten Dominik <dominik@science.uva.nl>
-;; Version: 4.21
+;; Version: 4.26
 
 ;; This file is part of GNU Emacs.
 
@@ -360,7 +360,7 @@ _ ^        Add/Remove parent key (to make this item a subitem).
       (reftex-highlight 0 (match-beginning 0) (match-end 0) (current-buffer)))
     match))
 
-(defun reftex-display-index (&optional tag overriding-restriction
+(defun reftex-display-index (&optional tag overriding-restriction redo
                                        &rest locations)
   "Display a buffer with an index compiled from the current document.
 When the document has multiple indices, first prompts for the correct one.
@@ -387,7 +387,7 @@ With prefix 3, restrict index to region."
          (calling-file (buffer-file-name))
          (restriction
           (or overriding-restriction
-              (and (interactive-p) 
+              (and (not redo) 
                    (reftex-get-restriction current-prefix-arg docstruct))))
          (locations
           ;; See if we are on an index macro as initial position
@@ -427,7 +427,7 @@ With prefix 3, restrict index to region."
     (if restriction
         (setq reftex-index-restriction-indicator (car restriction)
               reftex-index-restriction-data (cdr restriction))
-      (if (interactive-p)
+      (if (not redo)
           (setq reftex-index-restriction-indicator nil
                 reftex-index-restriction-data nil)))
     (when (= (buffer-size) 0)
@@ -703,7 +703,7 @@ The function will go to the section where the entry at point was defined."
               (error "Don't know which file to rescan.  Try `C-u r'")
             (switch-to-buffer (reftex-get-file-buffer-force file))
             (setq current-prefix-arg '(4))
-            (reftex-display-index index-tag nil line)))
+            (reftex-display-index index-tag nil 'redo line)))
       (reftex-index-Rescan))
     (reftex-kill-temporary-buffers)))
 (defun reftex-index-Rescan (&rest ignore)
@@ -714,7 +714,7 @@ The function will go to the section where the entry at point was defined."
     (switch-to-buffer
      (reftex-get-file-buffer-force reftex-last-index-file))
     (setq current-prefix-arg '(16))
-    (reftex-display-index index-tag nil line)))
+    (reftex-display-index index-tag nil 'redo line)))
 (defun reftex-index-revert (&rest ignore)
   "Regenerate the *Index* from the internal lists.  No reparsing os done."
   (interactive)
@@ -727,14 +727,14 @@ The function will go to the section where the entry at point was defined."
     (reftex-erase-buffer buf)
     (setq current-prefix-arg nil
           reftex-last-follow-point 1)
-    (reftex-display-index index-tag nil data line)))
+    (reftex-display-index index-tag nil 'redo data line)))
 (defun reftex-index-switch-index-tag (&rest ignore)
   "Switch to a different index of the same document."
   (interactive)
   (switch-to-buffer
    (reftex-get-file-buffer-force reftex-last-index-file))
   (setq current-prefix-arg nil)
-  (reftex-display-index))
+  (reftex-display-index nil nil 'redo))
 
 (defun reftex-index-restrict-to-section (&optional force)
   "Restrict index to entries defined in same document sect. as entry at point."
@@ -1352,23 +1352,23 @@ Here are all local bindings.
     (if (re-search-forward reftex-index-phrases-phrase-regexp12 nil t)
         (progn
           (goto-char (match-beginning 0))
-          (reftex-index-this-phrase))
+          (reftex-index-this-phrase 'slave))
       (error "No more phrase lines after point"))))
 
-(defun reftex-index-this-phrase ()
+(defun reftex-index-this-phrase (&optional slave)
   "Index the phrase in the current line.
 Does a global search and replace in the entire document.  At each
 match, the user will be asked to confirm the replacement."
   (interactive)
-  (if (interactive-p) (reftex-index-phrases-parse-header t))
+  (if (not slave) (reftex-index-phrases-parse-header t))
   (save-excursion
     (beginning-of-line)
     (cond ((looking-at reftex-index-phrases-comment-regexp)
-           (if (interactive-p) (error "Comment line")))
+           (if (not slave) (error "Comment line")))
           ((looking-at "^[ \t]*$")
-           (if (interactive-p) (error "Empty line")))
+           (if (not slave) (error "Empty line")))
           ((looking-at reftex-index-phrases-macrodef-regexp)
-           (if (interactive-p) (error "Macro definition line")))
+           (if (not slave) (error "Macro definition line")))
           ((looking-at reftex-index-phrases-phrase-regexp12)
            ;; This is a phrase
            (let* ((char (if (not (equal (match-string 1) ""))
@@ -1429,7 +1429,7 @@ Calls `reftex-index-this-phrase' on each line in the region."
   (goto-char beg)
   (while (not (or (eobp)
                   (>= (point) end)))
-    (save-excursion (reftex-index-this-phrase))
+    (save-excursion (reftex-index-this-phrase 'slave))
     (beginning-of-line 2)))
 
 (defun reftex-index-phrases-parse-header (&optional get-files)
@@ -1736,12 +1736,15 @@ With optional arg ALLOW-NEWLINE, allow single newline between words."
                        "\\([ \t]*\\(\n[ \t]*\\)?\\|[ \t]\\)"
                      "\\([ \t]+\\)")))
     (concat (if (and as-words (string-match "\\`\\w" (car words)))
-                "\\<" "")
-            (mapconcat (lambda (w) (regexp-quote (downcase w)))
+                "\\(\\<\\|[`']\\)" "")
+            (mapconcat (lambda (w) (regexp-quote 
+                                    (if reftex-index-phrases-case-fold-search
+                                        (downcase w)
+                                      w)))
                        words space-re)
             (if (and as-words 
                      (string-match "\\w\\'" (nth (1- (length words)) words)))
-                "\\>" ""))))
+                "\\(\\>\\|'\\)" ""))))
 
 (defun reftex-index-simplify-phrase (phrase)
   "Make phrase single spaces and single line."
@@ -1825,6 +1828,8 @@ both ends."
     (unwind-protect
         (while (re-search-forward re nil t)
           (catch 'next-match
+            (if (reftex-in-comment)
+                (throw 'next-match nil))
             (if (and (fboundp reftex-index-verify-function)
                      (not (funcall reftex-index-verify-function)))
                 (throw 'next-match nil))
@@ -1925,7 +1930,7 @@ both ends."
       (reftex-unhighlight 0))))
 
 (defun reftex-index-phrase-match-is-indexed (beg end)
-  ;; CHeck if match is in an argument of an index macro, or if an
+  ;; Check if match is in an argument of an index macro, or if an
   ;; index macro is directly attached to the match.
   (save-excursion
     (goto-char end)
diff --git a/lisp/textmodes/reftex-parse.el b/lisp/textmodes/reftex-parse.el
index 534775bf5a5..630c7101725 100644
--- a/lisp/textmodes/reftex-parse.el
+++ b/lisp/textmodes/reftex-parse.el
@@ -1,8 +1,8 @@
 ;;; reftex-parse.el --- parser functions for RefTeX
-;; Copyright (c) 1997, 1998, 1999, 2000, 2003 Free Software Foundation, Inc.
+;; Copyright (c) 1997, 1998, 1999, 2000, 2003, 2004 Free Software Foundation, Inc.
 
 ;; Author: Carsten Dominik <dominik@science.uva.nl>
-;; Version: 4.21
+;; Version: 4.26
 ;;
 
 ;; This file is part of GNU Emacs.
diff --git a/lisp/textmodes/reftex-ref.el b/lisp/textmodes/reftex-ref.el
index 2d4935aedde..43095e2d684 100644
--- a/lisp/textmodes/reftex-ref.el
+++ b/lisp/textmodes/reftex-ref.el
@@ -1,8 +1,8 @@
 ;;; reftex-ref.el --- code to create labels and references with RefTeX
-;; Copyright (c) 1997, 1998, 1999, 2000, 2003 Free Software Foundation, Inc.
+;; Copyright (c) 1997, 1998, 1999, 2000, 2003, 2004 Free Software Foundation, Inc.
 
 ;; Author: Carsten Dominik <dominik@science.uva.nl>
-;; Version: 4.21
+;; Version: 4.26
 
 ;; This file is part of GNU Emacs.
 
@@ -96,14 +96,27 @@ If optional BOUND is an integer, limit backward searches to that point."
 
 (defun reftex-label-info (label &optional file bound derive env-or-mac)
   ;; Return info list on LABEL at point.
-  (let* ((env-or-mac (or env-or-mac (reftex-label-location bound)))
-         (typekey (nth 1 (assoc env-or-mac reftex-env-or-mac-alist)))
+  (let* ((prefix (if (string-match "^[a-zA-Z0-9]+:" label)
+                     (match-string 0 label)))
+         (typekey (cdr (assoc prefix reftex-prefix-to-typekey-alist)))
          (file (or file (buffer-file-name)))
-         (parse (nth 2 (assoc env-or-mac reftex-env-or-mac-alist)))
-         (text (reftex-short-context env-or-mac parse reftex-location-start
-                                     derive))
+         (trust reftex-trust-label-prefix)
          (in-comment (reftex-in-comment)))
-    (list label typekey text file in-comment)))
+    (if (and typekey
+             (cond ((eq trust t) t)
+                   ((null trust) nil)
+                   ((stringp trust) (string-match trust typekey))
+                   ((listp trust) (member typekey trust))
+                   (t nil)))
+        (list label typekey
+              (reftex-nicify-text (reftex-context-substring))
+              file in-comment)
+      (let* ((env-or-mac (or env-or-mac (reftex-label-location bound)))
+             (typekey (nth 1 (assoc env-or-mac reftex-env-or-mac-alist)))
+             (parse (nth 2 (assoc env-or-mac reftex-env-or-mac-alist)))
+             (text (reftex-short-context env-or-mac parse reftex-location-start
+                                         derive)))
+        (list label typekey text file in-comment)))))
 
 ;;; Creating labels ---------------------------------------------------------
 
@@ -296,35 +309,43 @@ also applies `reftex-translate-to-ascii-function' to the string."
       (while (string-match "\\%\\([a-zA-Z]\\)" prefix num)
         (setq letter (match-string 1 prefix))
         (setq replace
-              (cond
-               ((equal letter "f")
-                (file-name-sans-extension
-                 (file-name-nondirectory (buffer-file-name))))
-               ((equal letter "F")
-                (let ((masterdir (file-name-directory (reftex-TeX-master-file)))
-                      (file (file-name-sans-extension (buffer-file-name))))
-                  (if (string-match (concat "\\`" (regexp-quote masterdir))
-                                    file)
-                      (substring file (length masterdir))
-                    file)))
-               ((equal letter "u")
-                (or (user-login-name) ""))
-               ((equal letter "S")
-                (let* (macro level-exp level)
-                  (save-excursion
-                    (save-match-data
-                      (when (re-search-backward reftex-section-regexp nil t)
-                        (setq macro (reftex-match-string 2)
-                              level-exp (cdr (assoc macro reftex-section-levels-all))
-                              level (if (symbolp level-exp)
-                                        (abs (save-match-data
-                                               (funcall level-exp)))
-                                      (abs level-exp))))
-                      (cdr (or (assoc macro reftex-section-prefixes)
-                               (assoc level reftex-section-prefixes)
-                               (assq t reftex-section-prefixes)
-                               (list t "sec:")))))))
-               (t "")))
+              (save-match-data
+                (cond
+                 ((equal letter "f")
+                  (file-name-sans-extension
+                   (file-name-nondirectory (buffer-file-name))))
+                 ((equal letter "F")
+                  (let ((masterdir (file-name-directory (reftex-TeX-master-file)))
+                        (file (file-name-sans-extension (buffer-file-name))))
+                    (if (string-match (concat "\\`" (regexp-quote masterdir))
+                                      file)
+                        (substring file (length masterdir))
+                      file)))
+                 ((equal letter "m")
+                  (file-name-sans-extension
+                   (file-name-nondirectory (reftex-TeX-master-file))))
+                 ((equal letter "M")
+                  (file-name-nondirectory
+                   (substring (file-name-directory (reftex-TeX-master-file))
+                              0 -1)))
+                 ((equal letter "u")
+                  (or (user-login-name) ""))
+                 ((equal letter "S")
+                  (let* (macro level-exp level)
+                    (save-excursion
+                      (save-match-data
+                        (when (re-search-backward reftex-section-regexp nil t)
+                          (setq macro (reftex-match-string 2)
+                                level-exp (cdr (assoc macro reftex-section-levels-all))
+                                level (if (symbolp level-exp)
+                                          (abs (save-match-data
+                                                 (funcall level-exp)))
+                                        (abs level-exp))))
+                        (cdr (or (assoc macro reftex-section-prefixes)
+                                 (assoc level reftex-section-prefixes)
+                                 (assq t reftex-section-prefixes)
+                                 (list t "sec:")))))))
+                 (t ""))))
         (setq num (1- (+ (match-beginning 1) (length replace)))
               prefix (replace-match replace nil nil prefix)))
       prefix)))
@@ -449,7 +470,7 @@ When called with 2 C-u prefix args, disable magic word recognition."
 
         ;; remove ~ if we do already have a space
         (when (and (= ?~ (string-to-char form))
-                   (member (preceding-char) '(?\ ?\t ?\n ?. ?~)))
+                   (member (preceding-char) '(?\ ?\t ?\n ?~)))
           (setq form (substring form 1)))
         ;; do we have a special format?
         (setq reftex-format-ref-function
diff --git a/lisp/textmodes/reftex-sel.el b/lisp/textmodes/reftex-sel.el
index 3074e83b681..8b0ebb2ca2b 100644
--- a/lisp/textmodes/reftex-sel.el
+++ b/lisp/textmodes/reftex-sel.el
@@ -1,8 +1,8 @@
 ;;; reftex-sel.el --- the selection modes for RefTeX
-;; Copyright (c) 1997, 1998, 1999, 2000, 2003 Free Software Foundation, Inc.
+;; Copyright (c) 1997, 1998, 1999, 2000, 2003, 2004 Free Software Foundation, Inc.
 
 ;; Author: Carsten Dominik <dominik@science.uva.nl>
-;; Version: 4.21
+;; Version: 4.26
 
 ;; This file is part of GNU Emacs.
 
@@ -607,13 +607,11 @@ Useful for large TOC's."
     (setq ovl (make-overlay boe eoe))
     (push (list data ovl separator) reftex-select-marked)
     (overlay-put ovl 'face reftex-select-mark-face)
-    (if (featurep 'xemacs)
-        ;; before-string property is broken in Emacs
-        (overlay-put ovl 'before-string
-                     (if separator
-                         (format "*%c%d* " separator
-                                 (length reftex-select-marked))
-                       (format "*%d*  " (length reftex-select-marked)))))
+    (overlay-put ovl 'before-string
+                 (if separator
+                     (format "*%c%d* " separator
+                             (length reftex-select-marked))
+                   (format "*%d*  " (length reftex-select-marked))))
     (message "Entry has mark no. %d" (length reftex-select-marked))))
 
 (defun reftex-select-mark-comma ()
@@ -725,7 +723,7 @@ Useful for large TOC's."
       (define-key reftex-select-label-map (car x) (cdr x)))
 
 ;; Specific bindings in reftex-select-bib-map
-(loop for key across "grRaA" do
+(loop for key across "grRaAeE" do
       (define-key reftex-select-bib-map (vector (list key))
         (list 'lambda '() 
               "Press `?' during selection to find out about this key."
diff --git a/lisp/textmodes/reftex-toc.el b/lisp/textmodes/reftex-toc.el
index 8d217f08dfb..ed9746f8a69 100644
--- a/lisp/textmodes/reftex-toc.el
+++ b/lisp/textmodes/reftex-toc.el
@@ -2,7 +2,7 @@
 ;; Copyright (c) 1997, 1998, 1999, 2000, 2003, 2004 Free Software Foundation, Inc.
 
 ;; Author: Carsten Dominik <dominik@science.uva.nl>
-;; Version: 4.21
+;; Version: 4.26
 
 ;; This file is part of GNU Emacs.
 
@@ -868,6 +868,7 @@ label prefix determines the wording of a reference."
            ((and (markerp marker) (marker-buffer marker))
             ;; Buffer is still live and we have the marker.  Should be easy.
             (switch-to-buffer-other-window (marker-buffer marker))
+            (push-mark nil)
             (goto-char (marker-position marker))
             (or (looking-at (regexp-quote literal))
                 (looking-at (reftex-make-regexp-allow-for-ctrl-m literal))
@@ -1088,4 +1089,4 @@ always show the current section in connection with the option
 
 
 ;;; arch-tag: 92400ce2-0b86-4c89-a606-4ed71acea17e
-;;; reftex-toc.el ends here
\ No newline at end of file
+;;; reftex-toc.el ends here
diff --git a/lisp/textmodes/reftex-vars.el b/lisp/textmodes/reftex-vars.el
index 53357342c51..a7c0cb1c1ad 100644
--- a/lisp/textmodes/reftex-vars.el
+++ b/lisp/textmodes/reftex-vars.el
@@ -1,8 +1,8 @@
 ;;; reftex-vars.el --- configuration variables for RefTeX
-;; Copyright (c) 1997, 1998, 1999, 2003 Free Software Foundation, Inc.
+;; Copyright (c) 1997, 1998, 1999, 2003, 2004 Free Software Foundation, Inc.
 
 ;; Author: Carsten Dominik <dominik@science.uva.nl>
-;; Version: 4.21
+;; Version: 4.26
 
 ;; This file is part of GNU Emacs.
 
@@ -128,13 +128,13 @@ distribution.  Mixed-case symbols are convenience aliases.")
 
 (defconst reftex-cite-format-builtin
   '((default "Default macro \\cite{%l}"
-      "\\cite{%l}")
+      "\\cite[]{%l}")
     (natbib "The Natbib package"
-     ((?\C-m . "\\cite{%l}")
-      (?t    . "\\citet{%l}")
-      (?T    . "\\citet*{%l}")
-      (?p    . "\\citep{%l}")
-      (?P    . "\\citep*{%l}")
+     ((?\C-m . "\\cite[][]{%l}")
+      (?t    . "\\citet[][]{%l}")
+      (?T    . "\\citet*[][]{%l}")
+      (?p    . "\\citep[][]{%l}")
+      (?P    . "\\citep*[][]{%l}")
       (?e    . "\\citep[e.g.][]{%l}")
       (?s    . "\\citep[see][]{%l}")
       (?a    . "\\citeauthor{%l}")
@@ -157,8 +157,8 @@ distribution.  Mixed-case symbols are convenience aliases.")
     (bibentry "The Bibentry package"
       "\\bibentry{%l}")
     (harvard "The Harvard package"
-     ((?\C-m . "\\cite{%l}")
-      (?p    . "\\cite{%l}")
+     ((?\C-m . "\\cite[]{%l}")
+      (?p    . "\\cite[]{%l}")
       (?t    . "\\citeasnoun{%l}")
       (?n    . "\\citeasnoun{%l}")
       (?s    . "\\possessivecite{%l}")
@@ -166,17 +166,17 @@ distribution.  Mixed-case symbols are convenience aliases.")
       (?y    . "\\citeyear{%l}")
       (?a    . "\\citename{%l}")))
     (chicago "The Chicago package"
-     ((?\C-m . "\\cite{%l}")
-      (?t    . "\\citeN{%l}")
+     ((?\C-m . "\\cite[]{%l}")
+      (?t    . "\\citeN[]{%l}")
       (?T    . "\\shortciteN{%l}")
-      (?p    . "\\cite{%l}")
+      (?p    . "\\cite[]{%l}")
       (?P    . "\\shortcite{%l}")
       (?a    . "\\citeA{%l}")
       (?A    . "\\shortciteA{%l}")
       (?y    . "\\citeyear{%l}")))
     (astron "The Astron package"
-     ((?\C-m . "\\cite{%l}")
-      (?p    . "\\cite{%l}" )
+     ((?\C-m . "\\cite[]{%l}")
+      (?p    . "\\cite[]{%l}" )
       (?t    . "%2a (\\cite{%l})")))
     (author-year "Do-it-yourself Author-year"
      ((?\C-m . "\\cite{%l}")
@@ -484,6 +484,8 @@ LABEL-PREFIX
     empty string.  The prefix may contain the following `%' escapes:
        %f   Current file name with directory and extension stripped.
        %F   Current file name relative to directory of master file.
+       %m   Master file name, directory and extension stripped.
+       %M   Directory name (without path) where master file is located.
        %u   User login name, on systems which support this.
        %S   A section prefix derived with variable `reftex-section-prefixes'.
 
@@ -631,6 +633,43 @@ the final regular expression - so %s will be replaced with the environment
 or macro."
   :group 'reftex-defining-label-environments
   :type '(repeat (cons (symbol) (regexp))))
+
+(defcustom reftex-trust-label-prefix nil
+  "Non-nil means, trust the label prefix when determining label type.
+It is customary to use special label prefixes to distinguish different label
+types.  The label prefixes have no syntactic meaning in LaTeX (unless
+special packages like fancyref) are being used.  RefTeX can and by
+default does parse around each label to detect the correct label type,
+but this process can be slow when a document contains thousands of
+labels.  If you use label prefixes consistently, you may speed up
+document parsing by setting this variable to a non-nil value.  RefTeX
+will then compare the label prefix with the prefixes found in
+`reftex-label-alist' and derive the correct label type in this way.
+Possible values for this option are:
+
+t          This means to trust any label prefixes found.
+regexp     If a regexp, only prefixes matched by the regexp are trusted.
+list       List of accepted prefixes, as strings.  The colon is part of
+           the prefix, e.g. (\"fn:\" \"eqn:\" \"item:\").
+nil        Never trust a label prefix.
+
+The only disadvantage of using this feature is that the label context
+displayed in the label selection buffer along with each label is
+simply some text after the label definition.  This is no problem if you
+place labels keeping this in mind (e.g. *before* the equation, *at
+the beginning* of a fig/tab caption ...).  Anyway, it is probably best
+to use the regexp or the list value types to fine-tune this feature.
+For example, if your document contains thousands of footnotes with
+labels fn:xxx, you may want to set this variable to the value \"^fn:$\" or
+\(\"fn:\").  Then RefTeX will still do extensive parsing for any
+non-footnote labels."
+  :group 'reftex-defining-label-environments
+  :type '(choice
+          (const :tag "Always" t)
+          (const :tag "Never" nil)
+          (regexp)
+          (repeat :tag "List"
+                  (string :tag "prefix (with colon)"))))
   
 (defcustom reftex-special-environment-functions nil
   "List of functions to be called when trying to figure out current environment.
@@ -1010,6 +1049,9 @@ display, and for (setq reftex-comment-citations t).
 %< as a special operator kills punctuation and space around it after the 
 string has been formatted.
 
+A pair of square brackets indicates an optional argument, and RefTeX
+will prompt for the values of these arguments.
+
 Beware that all this only works with BibTeX database files.  When
 citations are made from the \\bibitems in an explicit thebibliography
 environment, only %l is available.
@@ -1042,6 +1084,42 @@ E.g.: (setq reftex-cite-format 'natbib)"
             (cons (character :tag "Key character" ?\r)
                   (string    :tag "Format string" "")))))
 
+(defcustom reftex-cite-prompt-optional-args 'maybe
+  "*Non-nil means, prompt for empty optional arguments in cite macros.
+When an entry in `reftex-cite-format' ist given with square brackets to
+indicate optional arguments (for example \\cite[][]{%l}), RefTeX can
+prompt for values.  Possible values are:
+
+nil     Never prompt for optional arguments
+t       Always prompt
+maybe   Prompt only if `reftex-citation' was called with C-u prefix arg
+
+Unnecessary empty optional arguments are removed before insertion into
+the buffer.  See `reftex-cite-cleanup-optional-args'."
+  :group 'reftex-citation-support
+  :type '(choice
+          (const :tag "Always" t)
+          (const :tag "When called with prefix arg" maybe)
+          (const :tag "Never" nil)))
+
+(defcustom reftex-cite-cleanup-optional-args t
+  "*Non-nil means, remove unnecessary empty optional arguments in cite macros.
+The cite macros provided by some packages (for example
+natbib) allow specifying two optional arguments, one for a prefix to
+the citation, and a second for a postfix.  When only one optional
+argument is given, it is interpreted as postfix.  When this option is
+t, RefTeX removes unnecessary empty optional arguments from the cite
+macro before insertion.  For example, it will change
+    \\cite[][]{Jones}              -> \\cite{Jones}
+    \\cite[][Chapter 1]{Jones}     -> \\cite[Chapter 1]{Jones}
+    \\cite[see][]{Jones}           -> \\cite[see][]{Jones}
+    \\cite[see][Chapter 1]{Jones}  -> \\cite{Jones}
+Is is possible that other packages have other conventions about which
+optional argument is interpreted how - that is why this cleaning up
+can be turned off."
+  :group 'reftex-citation-support
+  :type 'boolean)
+
 (defcustom reftex-comment-citations nil
   "*Non-nil means add a comment for each citation describing the full entry.
 The comment is formatted according to `reftex-cite-comment-format'."
diff --git a/lisp/textmodes/reftex.el b/lisp/textmodes/reftex.el
index c00400a7b96..e177805e9c4 100644
--- a/lisp/textmodes/reftex.el
+++ b/lisp/textmodes/reftex.el
@@ -1,8 +1,8 @@
 ;;; reftex.el --- minor mode for doing \label, \ref, \cite, \index in LaTeX
-;; Copyright (c) 1997, 1998, 1999, 2000, 2003 Free Software Foundation, Inc.
+;; Copyright (c) 1997, 1998, 1999, 2000, 2003, 2004 Free Software Foundation, Inc.
 
 ;; Author: Carsten Dominik <dominik@science.uva.nl>
-;; Version: 4.21
+;; Version: 4.26
 ;; Keywords: tex
 
 ;; This file is part of GNU Emacs.
@@ -300,7 +300,7 @@
 ;;; Define the formal stuff for a minor mode named RefTeX.
 ;;;
 
-(defconst reftex-version "RefTeX version 4.21"
+(defconst reftex-version "RefTeX version 4.26"
   "Version string for RefTeX.")
 
 (defvar reftex-mode nil
@@ -669,6 +669,8 @@ the label information is recompiled on next use."
 
 ;; Alist relating magic words to a label type.
 (defvar reftex-words-to-typekey-alist nil)
+;; Alist relating label prefixes to a label type.
+(defvar reftex-prefix-to-typekey-alist nil)
 
 ;; The last list-of-labels entry used in a reference.
 (defvar reftex-last-used-reference (list nil nil nil nil))
@@ -750,6 +752,7 @@ the label information is recompiled on next use."
     reftex-typekey-to-format-alist
     reftex-typekey-to-prefix-alist
     reftex-words-to-typekey-alist
+    reftex-prefix-to-typekey-alist
     reftex-type-query-prompt
     reftex-type-query-help
 
@@ -904,6 +907,8 @@ This enforces rescanning the buffer on next use."
         macro verify repeat nindex tag key toc-level toc-levels)
 
     (setq reftex-words-to-typekey-alist nil
+          reftex-prefix-to-typekey-alist 
+          '(("sec:" . "s") ("cha:" . "s") ("chap:" . "s"))
           reftex-typekey-list nil
           reftex-typekey-to-format-alist nil
           reftex-typekey-to-prefix-alist nil
@@ -946,6 +951,10 @@ This enforces rescanning the buffer on next use."
         (if typekey
             (add-to-list 'reftex-typekey-list typekey))
         (if (and typekey prefix
+                 (not (assoc prefix reftex-prefix-to-typekey-alist)))
+            (add-to-list 'reftex-prefix-to-typekey-alist
+                         (cons prefix typekey)))
+        (if (and typekey prefix
                  (not (assoc typekey reftex-typekey-to-prefix-alist)))
             (add-to-list 'reftex-typekey-to-prefix-alist
                          (cons typekey prefix)))
@@ -1676,6 +1685,7 @@ When DIE is non-nil, throw an error if file not found."
  "Make a citation using BibTeX database files." t)
 (autoload 'reftex-default-bibliography "reftex-cite")
 (autoload 'reftex-bib-or-thebib "reftex-cite")
+(autoload 'reftex-create-bibtex-file "reftex-cite")
 
 ;;; =========================================================================
 ;;;
@@ -2439,6 +2449,7 @@ IGNORE-WORDS List of words which should be removed from the string."
     ["Restore from File"      (reftex-access-parse-file 'restore) t])
    ("Global Actions"
     ["Search Whole Document"  reftex-search-document t]
+    ["Search Again"           tags-loop-continue t]
     ["Replace in Document"    reftex-query-replace-document t]
     ["Grep on Document"       reftex-grep-document t]
     "--"
@@ -2447,6 +2458,8 @@ IGNORE-WORDS List of words which should be removed from the string."
     ["Change Label and Refs"  reftex-change-label t]
     ["Renumber Simple Labels" reftex-renumber-simple-labels t]
     "--"
+    ["Create BibTeX File"     reftex-create-bibtex-file t]
+    "--"
     ["Create TAGS File"       reftex-create-tags-file t]
     "--"
     ["Save Document"          reftex-save-all-document-buffers t])
diff --git a/lisp/textmodes/sgml-mode.el b/lisp/textmodes/sgml-mode.el
index 6da9cc23aaa..b1a1b70397a 100644
--- a/lisp/textmodes/sgml-mode.el
+++ b/lisp/textmodes/sgml-mode.el
@@ -1,6 +1,6 @@
 ;;; sgml-mode.el --- SGML- and HTML-editing modes
 
-;; Copyright (C) 1992, 1995, 1996, 1998, 2001, 2002, 2003, 2004
+;; Copyright (C) 1992, 1995, 1996, 1998, 2001, 2002, 2003, 2004, 2005
 ;;           Free Software Foundation, Inc.
 
 ;; Author: James Clark <jjc@jclark.com>
@@ -392,6 +392,14 @@ Otherwise, it is set to be buffer-local when the file has
         (concat "<" face ">"))
     (error "Face not configured for %s mode" mode-name)))
 
+(defun sgml-fill-nobreak ()
+  ;; Don't break between a tag name and its first argument.
+  (save-excursion
+    (skip-chars-backward " \t")
+    (and (not (zerop (skip-syntax-backward "w_")))
+         (skip-chars-backward "/?!")
+         (eq (char-before) ?<))))
+
 ;;;###autoload
 (define-derived-mode sgml-mode text-mode "SGML"
   "Major mode for editing SGML documents.
@@ -422,6 +430,7 @@ Do \\[describe-key] on the following bindings to discover what they do.
   (set (make-local-variable 'paragraph-separate)
        (concat paragraph-start "$"))
   (set (make-local-variable 'adaptive-fill-regexp) "[ \t]*")
+  (add-hook 'fill-nobreak-predicate 'sgml-fill-nobreak nil t)
   (set (make-local-variable 'indent-line-function) 'sgml-indent-line)
   (set (make-local-variable 'comment-start) "<!-- ")
   (set (make-local-variable 'comment-end) " -->")
@@ -1138,17 +1147,19 @@ immediately enclosing the current position.
 Point is assumed to be outside of any tag.  If we discover that it's
 not the case, the first tag returned is the one inside which we are."
   (let ((here (point))
+        (stack nil)
         (ignore nil)
         (context nil)
         tag-info)
     ;; CONTEXT keeps track of the tag-stack
-    ;; IGNORE keeps track of the nesting level of point relative to the
-    ;;   first (outermost) tag on the context.  This is the list of
-    ;;   enclosing start-tags we'll have to ignore.
+    ;; STACK keeps track of the end tags we've seen (and thus the start-tags
+    ;;   we'll have to ignore) when skipping over matching open..close pairs.
+    ;; IGNORE is a list of tags that can be ignored because they have been
+    ;;   closed implicitly.
     (skip-chars-backward " \t\n")      ; Make sure we're not at indentation.
     (while
         (and (not (eq until 'now))
-             (or ignore
+             (or stack
                  (not (if until (eq until 'empty) context))
                  (not (sgml-at-indentation-p))
                  (and context
@@ -1172,24 +1183,25 @@ not the case, the first tag returned is the one inside which we are."
        ;; start-tag
        ((eq (sgml-tag-type tag-info) 'open)
         (cond
-         ((null ignore)
-          (if (and context
-                   (sgml-unclosed-tag-p (sgml-tag-name tag-info))
-                   (eq t (compare-strings
-                          (sgml-tag-name tag-info) nil nil
-                          (sgml-tag-name (car context)) nil nil t)))
+         ((null stack)
+          (if (member-ignore-case (sgml-tag-name tag-info) ignore)
               ;; There was an implicit end-tag.
               nil
-            (push tag-info context)))
+            (push tag-info context)
+            ;; We're changing context so the tags implicitly closed inside
+            ;; the previous context aren't implicitly closed here any more.
+            ;; [ Well, actually it depends, but we don't have the info about
+            ;; when it doesn't and when it does.   --Stef ]
+            (setq ignore nil)))
          ((eq t (compare-strings (sgml-tag-name tag-info) nil nil
-                                 (car ignore) nil nil t))
-          (setq ignore (cdr ignore)))
+                                 (car stack) nil nil t))
+          (setq stack (cdr stack)))
          (t
           ;; The open and close tags don't match.
           (if (not sgml-xml-mode)
               (unless (sgml-unclosed-tag-p (sgml-tag-name tag-info))
                 (message "Unclosed tag <%s>" (sgml-tag-name tag-info))
-                (let ((tmp ignore))
+                (let ((tmp stack))
                   ;; We could just assume that the tag is simply not closed
                   ;; but it's a bad assumption when tags *are* closed but
                   ;; not properly nested.
@@ -1200,13 +1212,19 @@ not the case, the first tag returned is the one inside which we are."
                     (setq tmp (cdr tmp)))
                   (if (cdr tmp) (setcdr tmp (cddr tmp)))))
             (message "Unmatched tags <%s> and </%s>"
-                     (sgml-tag-name tag-info) (pop ignore))))))
+                     (sgml-tag-name tag-info) (pop stack)))))
+        
+        (if (and (null stack) (sgml-unclosed-tag-p (sgml-tag-name tag-info)))
+            ;; This is a top-level open of an implicitly closed tag, so any
+            ;; occurrence of such an open tag at the same level can be ignored
+            ;; because it's been implicitly closed.
+            (push (sgml-tag-name tag-info) ignore)))
 
        ;; end-tag
        ((eq (sgml-tag-type tag-info) 'close)
         (if (sgml-empty-tag-p (sgml-tag-name tag-info))
             (message "Spurious </%s>: empty tag" (sgml-tag-name tag-info))
-          (push (sgml-tag-name tag-info) ignore)))
+          (push (sgml-tag-name tag-info) stack)))
        ))
 
     ;; return context
diff --git a/lisp/toolbar/README b/lisp/toolbar/README
index f7c8cb033b4..4bf1700dd91 100644
--- a/lisp/toolbar/README
+++ b/lisp/toolbar/README
@@ -5,4 +5,6 @@ The following icons are from GTK+ 2.x:
     paste.xpm preferences.xpm print.xpm right_arrow.xpm save.xpm
     saveas.xpm search.xpm spell.xpm undo.xpm up_arrow.xpm
 
+    back_arrow.xpm and fwd_arrow.xpm are slightly modified undo and redo.
+
 They are not part of Emacs, but distributed and used by Emacs.
diff --git a/lisp/toolbar/back_arrow.pbm b/lisp/toolbar/back_arrow.pbm
new file mode 100644
index 00000000000..7f9b8975d2f
--- /dev/null
+++ b/lisp/toolbar/back_arrow.pbm
diff --git a/lisp/toolbar/back_arrow.xpm b/lisp/toolbar/back_arrow.xpm
new file mode 100644
index 00000000000..b9b13613d81
--- /dev/null
+++ b/lisp/toolbar/back_arrow.xpm
@@ -0,0 +1,57 @@
+/* XPM */
+static char *back_arrow_xpm[] = {
+"24 24 30 1",
+"  c #000000",
+". c #53692A",
+"X c #59702D",
+"o c #657255",
+"O c #6D7A5B",
+"+ c #6D8839",
+"@ c #7C9B40",
+"# c #748261",
+"$ c #7F8E6B",
+"% c #818F71",
+"& c #879772",
+"* c #8C9A7F",
+"= c #85A24D",
+"- c #8BA859",
+"; c #92AD62",
+": c #95A77E",
+"> c #98AF74",
+", c #9BB572",
+"< c #9BAA87",
+"1 c #9CAF84",
+"2 c #A4B690",
+"3 c #A8BCA6",
+"4 c #ADBDA0",
+"5 c #AFC394",
+"6 c #BAD09D",
+"7 c #B5C3A9",
+"8 c #BED2A3",
+"9 c #D5E1C6",
+"0 c #FFFFFF",
+"q c None",
+"qqqqqqqqqqqqqqqqqqqqqqqq",
+"qqqqqqqqqqqqqqqqqqqqqqqq",
+"qqqqqqqqqqqqqqqqqqqqqqqq",
+"qqqqqqqqqq qqqqqqqqqqqqq",
+"qqqqqqqqq  qqqqqqqqqqqqq",
+"qqqqqqqq 9 qqqqqqqqqqqqq",
+"qqqqqqq 96    qqqqqqqqqq",
+"qqqqqq 968664% qqqqqqqqq",
+"qqqqq 966666663 qqqqqqqq",
+"qqqq <666666666* qqqqqqq",
+"qqqqq X@@@@@@;67  qqqqqq",
+"qqqqqq .@@@@@@=6$ qqqqqq",
+"qqqqqqq .@   X@,2 qqqqqq",
+"qqqqqqqq X q  +-6 qqqqqq",
+"qqqqqqqqq  qq  @6 qqqqqq",
+"qqqqqqqqqq qqq -: qqqqqq",
+"qqqqqqqqqqqqqq >o qqqqqq",
+"qqqqqqqqqqqqqq 5 qqqqqqq",
+"qqqqqqqqqqqqq 1O qqqqqqq",
+"qqqqqqqqqqqq &# qqqqqqqq",
+"qqqqqqqqqqqqq  qqqqqqqqq",
+"qqqqqqqqqqqqqqqqqqqqqqqq",
+"qqqqqqqqqqqqqqqqqqqqqqqq",
+"qqqqqqqqqqqqqqqqqqqqqqqq"};
diff --git a/lisp/toolbar/fwd_arrow.pbm b/lisp/toolbar/fwd_arrow.pbm
new file mode 100644
index 00000000000..e08e6fa35db
--- /dev/null
+++ b/lisp/toolbar/fwd_arrow.pbm
diff --git a/lisp/toolbar/fwd_arrow.xpm b/lisp/toolbar/fwd_arrow.xpm
new file mode 100644
index 00000000000..5e7c5602ea1
--- /dev/null
+++ b/lisp/toolbar/fwd_arrow.xpm
@@ -0,0 +1,70 @@
+/* XPM */
+static char *fwd_arrow_xpm[] = {
+"24 24 43 1",
+"  c #000000",
+". c #53692A",
+"X c #59702D",
+"o c #657255",
+"O c #6D7A5B",
+"+ c #6D8839",
+"@ c #7C9B40",
+"# c #748261",
+"$ c #7F8E6B",
+"% c #818F71",
+"& c #879772",
+"* c #8C9A7F",
+"= c #85A24D",
+"- c #8BA859",
+"; c #92AD62",
+": c #95A77E",
+"> c #98AF74",
+", c #9BB572",
+"< c #919889",
+"1 c #92998C",
+"2 c #939A8D",
+"3 c #99A28F",
+"4 c #9BAA87",
+"5 c #9CAF84",
+"6 c #A4B690",
+"7 c #A8BCA6",
+"8 c #ADBDA0",
+"9 c #AFC394",
+"0 c #BAD09D",
+"q c #B5C3A9",
+"w c #BED2A3",
+"e c #BFD3A6",
+"r c #C2D5AA",
+"t c #C5D7AE",
+"y c #C8D9B2",
+"u c #CDDCBC",
+"i c #D1DFBE",
+"p c #D2E0BF",
+"a c #D3E0C1",
+"s c #D4E0C5",
+"d c #D5E1C6",
+"f c #FFFFFF",
+"g c None",
+"gggggggggggggggggggggggg",
+"gggggggggggggggggggggggg",
+"gggggggggggggggggggggggg",
+"ggggggggggggg gggggggggg",
+"ggggggggggggg  ggggggggg",
+"ggggggggggggg 2 gggggggg",
+"gggggggggg    02 ggggggg",
+"ggggggggg &6riw03 gggggg",
+"gggggggg 7suat000< ggggg",
+"ggggggg *saie000004 gggg",
+"gggggg  qs;@@@@@@X ggggg",
+"gggggg $y=@@@@@@. gggggg",
+"gggggg 6,@X   @. ggggggg",
+"gggggg 0@+  g X gggggggg",
+"gggggg 0@  gg  ggggggggg",
+"gggggg :- ggg gggggggggg",
+"gggggg o> gggggggggggggg",
+"ggggggg 9 gggggggggggggg",
+"ggggggg O5 ggggggggggggg",
+"gggggggg #& gggggggggggg",
+"ggggggggg  ggggggggggggg",
+"gggggggggggggggggggggggg",
+"gggggggggggggggggggggggg",
+"gggggggggggggggggggggggg"};
diff --git a/lisp/toolbar/lc-back_arrow.xpm b/lisp/toolbar/lc-back_arrow.xpm
new file mode 100644
index 00000000000..05a797c7a65
--- /dev/null
+++ b/lisp/toolbar/lc-back_arrow.xpm
@@ -0,0 +1,33 @@
+/* XPM */
+static char *back_arrow_xpm[] = {
+"24 24 6 1",
+"  c #000000",
+". c #000100",
+"X c #6B6B66",
+"o c #87AF85",
+"O c #FFFFFF",
+"+ c None",
+"++++++++++++++++++++++++",
+"++++++++++++++++++++++++",
+"++++++++++++++++++++++++",
+"++++++++++ +++++++++++++",
+"+++++++++ .+++++++++++++",
+"++++++++ O.+++++++++++++",
+"+++++++ Oo .  ++++++++++",
+"++++++ Ooooooo +++++++++",
+"+++++ Ooooooooo ++++++++",
+"++++ ooooooooooo.+++++++",
+"+++++ oooooooooo..++++++",
+"++++++.oooooooooo.++++++",
+"+++++++.oo.. oooo.++++++",
+"++++++++.o.+  ooo.++++++",
+"+++++++++..++..oo.++++++",
+"++++++++++.+++.oo.++++++",
+"++++++++++++++.oo.++++++",
+"++++++++++++++.o.+++++++",
+"+++++++++++++.oX.+++++++",
+"++++++++++++.oo.++++++++",
+"+++++++++++++..+++++++++",
+"++++++++++++++++++++++++",
+"++++++++++++++++++++++++",
+"++++++++++++++++++++++++"};
diff --git a/lisp/toolbar/lc-fwd_arrow.xpm b/lisp/toolbar/lc-fwd_arrow.xpm
new file mode 100644
index 00000000000..284b8c9bee7
--- /dev/null
+++ b/lisp/toolbar/lc-fwd_arrow.xpm
@@ -0,0 +1,32 @@
+/* XPM */
+static char *fwd_arrow_xpm[] = {
+"24 24 5 1",
+"  c #000000",
+". c #000100",
+"X c #87AF85",
+"o c #FFFFFF",
+"O c None",
+"OOOOOOOOOOOOOOOOOOOOOOOO",
+"OOOOOOOOOOOOOOOOOOOOOOOO",
+"OOOOOOOOOOOOOOOOOOOOOOOO",
+"OOOOOOOOOOOOO OOOOOOOOOO",
+"OOOOOOOOOOOOO  OOOOOOOOO",
+"OOOOOOOOOOOOO X OOOOOOOO",
+"OOOOOOOOOO  . XX.OOOOOOO",
+"OOOOOOOOO oXXXXXX.OOOOOO",
+"OOOOOOOO.oXXXXXXXX.OOOOO",
+"OOOOOOO.oXXXXXXXXXX.OOOO",
+"OOOOOO..XXXXXXXXXX.OOOOO",
+"OOOOOO.XXXXXXXXXX.OOOOOO",
+"OOOOOO.XXXX.  XX.OOOOOOO",
+"OOOOOO.XXX..O X OOOOOOOO",
+"OOOOOO.XX..OO. OOOOOOOOO",
+"OOOOOO.XX.OOO.OOOOOOOOOO",
+"OOOOOO.XX.OOOOOOOOOOOOOO",
+"OOOOOOO.X.OOOOOOOOOOOOOO",
+"OOOOOOO.XX.OOOOOOOOOOOOO",
+"OOOOOOOO.XX.OOOOOOOOOOOO",
+"OOOOOOOOO..OOOOOOOOOOOOO",
+"OOOOOOOOOOOOOOOOOOOOOOOO",
+"OOOOOOOOOOOOOOOOOOOOOOOO",
+"OOOOOOOOOOOOOOOOOOOOOOOO"};
diff --git a/lisp/type-break.el b/lisp/type-break.el
index b51a74ea37e..3a0b8b5adcc 100644
--- a/lisp/type-break.el
+++ b/lisp/type-break.el
@@ -229,7 +229,8 @@ key is pressed."
   :group 'type-break)
 
 (defcustom type-break-file-name (convert-standard-filename "~/.type-break")
-  "*Name of file used to save state across sessions."
+  "*Name of file used to save state across sessions.
+If this is nil, no data will be saved across sessions."
   :type 'file
   :group 'type-break)
 
@@ -389,6 +390,9 @@ problems."
       (and (interactive-p)
            (message "Type Break mode is already enabled")))
      (type-break-mode
+      (with-current-buffer (find-file-noselect type-break-file-name 'nowarn)
+        (setq buffer-save-without-query t))
+
       (or global-mode-string
           (setq global-mode-string '("")))
       (or (assq 'type-break-mode-line-message-mode
@@ -399,7 +403,9 @@ problems."
       (type-break-keystroke-reset)
       (type-break-mode-line-countdown-or-break nil)
 
-      (setq type-break-time-last-break (type-break-get-previous-time))
+      (setq type-break-time-last-break
+            (or (type-break-get-previous-time)
+                (current-time)))
 
       ;; schedule according to break time from session file
       (type-break-schedule
@@ -431,12 +437,12 @@ problems."
       (type-break-mode-line-countdown-or-break nil)
       (type-break-cancel-schedule)
       (do-auto-save)
-      (with-current-buffer (find-file-noselect type-break-file-name
-                                               'nowarn)
-        (setq buffer-save-without-query t)
-        (set-buffer-modified-p nil)
-        (unlock-buffer)
-        (kill-this-buffer))
+      (when type-break-file-name
+        (with-current-buffer (find-file-noselect type-break-file-name
+                                                 'nowarn)
+          (set-buffer-modified-p nil)
+          (unlock-buffer)
+          (kill-this-buffer)))
       (and (interactive-p)
            (message "Type Break mode is disabled")))))
   type-break-mode)
@@ -496,7 +502,8 @@ variable of the same name."
 
 (defun type-break-file-time (&optional time)
   "File break time in `type-break-file-name', unless the file is locked."
-  (if (not (stringp (file-locked-p type-break-file-name)))
+  (if (and type-break-file-name
+           (not (stringp (file-locked-p type-break-file-name))))
       (with-current-buffer (find-file-noselect type-break-file-name
                                                'nowarn)
         (let ((inhibit-read-only t))
@@ -507,7 +514,8 @@ variable of the same name."
 
 (defun type-break-file-keystroke-count ()
   "File keystroke count in `type-break-file-name', unless the file is locked."
-  (if (not (stringp (file-locked-p type-break-file-name)))
+  (if (and type-break-file-name
+           (not (stringp (file-locked-p type-break-file-name))))
       ;; Prevent deactivation of the mark in some other buffer.
       (let (deactivate-mark)
         (with-current-buffer (find-file-noselect type-break-file-name
@@ -534,6 +542,8 @@ return TIME, else return nil."
 (defun type-break-choose-file ()
   "Return file to read from."
   (cond
+   ((not type-break-file-name)
+    nil)
    ((and (file-exists-p type-break-auto-save-file-name)
          (file-readable-p type-break-auto-save-file-name))
     type-break-auto-save-file-name)
diff --git a/lisp/uniquify.el b/lisp/uniquify.el
index b2da7971167..ea9094da78a 100644
--- a/lisp/uniquify.el
+++ b/lisp/uniquify.el
@@ -1,6 +1,7 @@
 ;;; uniquify.el --- unique buffer names dependent on file name
 
-;; Copyright (c) 1989,95,96,97,2001,2003  Free Software Foundation, Inc.
+;; Copyright (c) 1989, 1995, 1996, 1997, 2001, 2003, 2005
+;;           Free Software Foundation, Inc.
 
 ;; Author: Dick King <king@reasoning.com>
 ;; Maintainer: FSF
@@ -187,9 +188,16 @@ It actually holds the list of `uniquify-item's corresponding to the conflict.")
 If `uniquify-min-dir-content' > 0, always pulls that many
 file name elements.
 Arguments BASE, DIRNAME, and NEWBUF specify the new buffer that causes
-this rationaliztion."
-  (if (null dirname)
-      (with-current-buffer newbuf (setq uniquify-managed nil))
+this rationalization."
+  (interactive
+   (list (if uniquify-managed
+             (uniquify-item-base (car uniquify-managed)) (buffer-name))
+         (uniquify-buffer-file-name (current-buffer))
+         (current-buffer)))
+  ;; Make sure we don't get confused by outdated uniquify-managed info in
+  ;; this buffer.
+  (with-current-buffer newbuf (setq uniquify-managed nil))
+  (when dirname
     (setq dirname (expand-file-name (directory-file-name dirname)))
     (let ((fix-list (list (uniquify-make-item base dirname newbuf)))
           items)
@@ -457,5 +465,5 @@ For use on `kill-buffer-hook'."
 
 (provide 'uniquify)
 
-;;; arch-tag: e763faa3-56c9-4903-8eb8-26e1c45a0065
+;; arch-tag: e763faa3-56c9-4903-8eb8-26e1c45a0065
 ;;; uniquify.el ends here
diff --git a/lisp/url/ChangeLog b/lisp/url/ChangeLog
index 9bb5ef1c3e5..19f39265251 100644
--- a/lisp/url/ChangeLog
+++ b/lisp/url/ChangeLog
@@ -1,3 +1,13 @@
+2005-01-13  Stefan Monnier  <monnier@iro.umontreal.ca>
+
+        * url.el (url-retrieve-synchronously): Use accept-process-output rather
+        than sit-for.
+
+2005-01-03  Klaus Straubinger  <ksnetz@arcor.de>  (tiny change)
+
+        * url-http.el (url-http-handle-authentication):
+        Don't kill the current buffer.
+
 2004-12-11  Stefan Monnier  <monnier@iro.umontreal.ca>
 
         * url-handlers.el: Don't `require' everything eagerly.
diff --git a/lisp/url/url-http.el b/lisp/url/url-http.el
index 8a7269e6bea..2608a85963a 100644
--- a/lisp/url/url-http.el
+++ b/lisp/url/url-http.el
@@ -322,8 +322,8 @@ This allows us to use `mail-fetch-field', etc."
           (let ((url-request-method url-http-method)
                 (url-request-data url-http-data)
                 (url-request-extra-headers url-http-extra-headers))
-            (url-retrieve url url-callback-function url-callback-arguments))))
-      (kill-buffer (current-buffer)))))
+            (url-retrieve url url-callback-function
+                          url-callback-arguments)))))))
 
 (defun url-http-parse-response ()
   "Parse just the response code."
diff --git a/lisp/url/url.el b/lisp/url/url.el
index f94e965129a..a9fd46bc23a 100644
--- a/lisp/url/url.el
+++ b/lisp/url/url.el
@@ -1,6 +1,7 @@
 ;;; url.el --- Uniform Resource Locator retrieval tool
 
-;; Copyright (c) 1996,1997,1998,1999,2001,2004  Free Software Foundation, Inc.
+;; Copyright (c) 1996, 1997, 1998, 1999, 2001, 2004, 2005
+;;           Free Software Foundation, Inc.
 
 ;; Author: Bill Perry <wmperry@gnu.org>
 ;; Keywords: comm, data, processes, hypermedia
@@ -169,26 +170,25 @@ no further processing).  URL is either a string or a parsed URL."
                               (url-debug 'retrieval "Synchronous fetching done (%S)" (current-buffer))
                               (setq retrieval-done t
                                     asynch-buffer (current-buffer)))))
-    (if (not asynch-buffer)
-        ;; We do not need to do anything, it was a mailto or something
-        ;; similar that takes processing completely outside of the URL
-        ;; package.
-        nil
-      (while (not retrieval-done)
-        (url-debug 'retrieval "Spinning in url-retrieve-synchronously: %S (%S)"
-                   retrieval-done asynch-buffer)
-        ;; Quoth Stef:
-        ;; It turns out that the problem seems to be that the (sit-for
-        ;; 0.1) below doesn't actually process the data: instead it
-        ;; returns immediately because there is keyboard input
-        ;; waiting, so we end up spinning endlessly waiting for the
-        ;; process to finish while not letting it finish.
-
-        ;; However, raman claims that it blocks Emacs with Emacspeak
-        ;; for unexplained reasons.  Put back for his benefit until
-        ;; someone can understand it.
-        ;; (sleep-for 0.1)
-        (sit-for 0.1))
+    (let ((proc (and asynch-buffer (get-buffer-process asynch-buffer))))
+      (if (null proc)
+          ;; We do not need to do anything, it was a mailto or something
+          ;; similar that takes processing completely outside of the URL
+          ;; package.
+          nil
+        (while (not retrieval-done)
+          (url-debug 'retrieval
+                     "Spinning in url-retrieve-synchronously: %S (%S)"
+                     retrieval-done asynch-buffer)
+          ;; We used to use `sit-for' here, but in some cases it wouldn't
+          ;; work because apparently pending keyboard input would always
+          ;; interrupt it before it got a chance to handle process input.
+          ;; `sleep-for' was tried but it lead to other forms of
+          ;; hanging.  --Stef
+          (unless (accept-process-output proc)
+            ;; accept-process-output returned nil, maybe because the process
+            ;; exited (and may have been replaced with another).
+            (setq proc (get-buffer-process asynch-buffer)))))
       asynch-buffer)))
 
 (defun url-mm-callback (&rest ignored)
diff --git a/lisp/vc-arch.el b/lisp/vc-arch.el
index 70dbdcc85f2..b821928c539 100644
--- a/lisp/vc-arch.el
+++ b/lisp/vc-arch.el
@@ -1,6 +1,6 @@
 ;;; vc-arch.el --- VC backend for the Arch version-control system
 
-;; Copyright (C) 1995, 1998, 1999, 2000, 2001, 2002, 2003, 2004
+;; Copyright (C) 1995, 1998, 1999, 2000, 2001, 2002, 2003, 2004, 2005
 ;;           Free Software Foundation, Inc.
 
 ;; Author:      FSF (see vc.el for full credits)
@@ -270,7 +270,7 @@ Return non-nil if FILE is unchanged."
 (defun vc-arch-workfile-version (file)
   (let* ((root (expand-file-name "{arch}" (vc-arch-root file)))
          (defbranch (vc-arch-default-version file)))
-    (when (and defbranch (string-match "\\`\\(.+@[^/\n]+\\)/\\(\\(\\(.*\\)--.*\\)--.*\\)\\'" defbranch))
+    (when (and defbranch (string-match "\\`\\(.+@[^/\n]+\\)/\\(\\(\\(.*?\\)\\(?:--.*\\)?\\)--.*\\)\\'" defbranch))
       (let* ((archive (match-string 1 defbranch))
              (category (match-string 4 defbranch))
              (branch (match-string 3 defbranch))
@@ -377,7 +377,7 @@ Return non-nil if FILE is unchanged."
       (setq newvers nil))
   (if newvers
       (error "Diffing specific revisions not implemented.")
-    (let* ((async (fboundp 'start-process))
+    (let* ((async (and (not vc-disable-async-diff) (fboundp 'start-process)))
            ;; Run the command from the root dir.
            (default-directory (vc-arch-root file))
            (status
diff --git a/lisp/vc-cvs.el b/lisp/vc-cvs.el
index 22346cab68c..2bca3fb90b1 100644
--- a/lisp/vc-cvs.el
+++ b/lisp/vc-cvs.el
@@ -548,7 +548,9 @@ The changes are between FIRST-VERSION and SECOND-VERSION."
                (append (vc-switches nil 'diff) '("/dev/null")))
         ;; Even if it's empty, it's locally modified.
         1)
-    (let* ((async (and (vc-stay-local-p file) (fboundp 'start-process)))
+    (let* ((async (and (not vc-disable-async-diff) 
+                       (vc-stay-local-p file)
+                       (fboundp 'start-process)))
            (status (apply 'vc-cvs-command (or buffer "*vc-diff*")
                           (if async 'async 1)
                           file "diff"
diff --git a/lisp/vc-mcvs.el b/lisp/vc-mcvs.el
index ea577489239..aca8bcd66f0 100644
--- a/lisp/vc-mcvs.el
+++ b/lisp/vc-mcvs.el
@@ -446,7 +446,9 @@ The changes are between FIRST-VERSION and SECOND-VERSION."
                (append (vc-switches nil 'diff) '("/dev/null")))
         ;; Even if it's empty, it's locally modified.
         1)
-    (let* ((async (and (vc-stay-local-p file) (fboundp 'start-process)))
+    (let* ((async (and (not vc-disable-async-diff)
+                       (vc-stay-local-p file) 
+                       (fboundp 'start-process)))
            ;; Run the command from the root dir so that `mcvs filt' returns
            ;; valid relative names.
            (default-directory (vc-mcvs-root file))
diff --git a/lisp/vc-svn.el b/lisp/vc-svn.el
index cbb951d60b7..f783066b39b 100644
--- a/lisp/vc-svn.el
+++ b/lisp/vc-svn.el
@@ -1,6 +1,6 @@
 ;;; vc-svn.el --- non-resident support for Subversion version-control
 
-;; Copyright (C) 1995, 1998, 1999, 2000, 2001, 2002, 2003, 2004
+;; Copyright (C) 1995, 1998, 1999, 2000, 2001, 2002, 2003, 2004, 2005
 ;;           Free Software Foundation, Inc.
 
 ;; Author:      FSF (see vc.el for full credits)
@@ -352,6 +352,10 @@ The changes are between FIRST-VERSION and SECOND-VERSION."
 (defun vc-svn-diff (file &optional oldvers newvers buffer)
   "Get a difference report using SVN between two versions of FILE."
   (unless buffer (setq buffer "*vc-diff*"))
+  (if (and oldvers (equal oldvers (vc-workfile-version file)))
+      ;; Use nil rather than the current revision because svn handles it
+      ;; better (i.e. locally).
+      (setq oldvers nil))
   (if (string= (vc-workfile-version file) "0")
       ;; This file is added but not yet committed; there is no master file.
       (if (or oldvers newvers)
@@ -368,7 +372,8 @@ The changes are between FIRST-VERSION and SECOND-VERSION."
             (if vc-svn-diff-switches
                 (vc-switches 'SVN 'diff)
               (list "-x" (mapconcat 'identity (vc-switches nil 'diff) " "))))
-           (async (and (vc-stay-local-p file)
+           (async (and (not vc-disable-async-diff)
+                       (vc-stay-local-p file)
                        (or oldvers newvers) ; Svn diffs those locally.
                        (fboundp 'start-process))))
       (apply 'vc-svn-command buffer
diff --git a/lisp/vc.el b/lisp/vc.el
index 64de0351922..4a26b88c0e3 100644
--- a/lisp/vc.el
+++ b/lisp/vc.el
@@ -152,7 +152,7 @@
 ;;   have such a brief-comparison feature, the default implementation of
 ;;   this function can be used, which delegates to a full
 ;;   vc-BACKEND-diff.  (Note that vc-BACKEND-diff must not run
-;;   asynchronously in this case.)
+;;   asynchronously in this case, see variable `vc-disable-async-diff'.)
 ;;
 ;; - mode-line-string (file)
 ;;
@@ -566,6 +566,15 @@ specific to any particular backend."
   :group 'vc
   :version "21.1")
 
+(defcustom vc-allow-async-revert nil
+  "*Specifies whether the diff during \\[vc-revert-buffer] may be asynchronous.
+Enabling this option means that you can confirm a revert operation even
+if the local changes in the file have not been found and displayed yet."
+  :type '(choice (const :tag "No" nil)
+                 (const :tag "Yes" t))
+  :group 'vc
+  :version "21.4")
+
 ;;;###autoload
 (defcustom vc-checkout-hook nil
   "*Normal hook (list of functions) run after checking out a file.
@@ -714,6 +723,11 @@ The keys are \(BUFFER . BACKEND\).  See also `vc-annotate-get-backend'.")
 (defvar vc-parent-buffer-name nil)
 (put 'vc-parent-buffer-name 'permanent-local t)
 
+(defvar vc-disable-async-diff nil
+  "VC sets this to t locally to disable some async diff operations.
+Backends that offer asynchronous diffs should respect this variable
+in their implementation of vc-BACKEND-diff.")
+
 (defvar vc-log-file)
 (defvar vc-log-version)
 
@@ -2435,11 +2449,13 @@ changes found in the master file; use \\[universal-argument] \\[vc-next-action]
         (unless (yes-or-no-p "File seems up-to-date.  Revert anyway? ")
           (error "Revert canceled")))
     (unless (vc-workfile-unchanged-p file)
+      (message "Finding changes...")
       ;; vc-diff selects the new window, which is not what we want:
       ;; if the new window is on another frame, that'd require the user
       ;; moving her mouse to answer the yes-or-no-p question.
-      (let ((win (save-selected-window
-                   (setq status (vc-diff nil t)) (selected-window))))
+      (let* ((vc-disable-async-diff (not vc-allow-async-revert))
+             (win (save-selected-window
+                    (setq status (vc-diff nil t)) (selected-window))))
         (vc-exec-after `(message nil))
         (when status
           (unwind-protect
diff --git a/lisp/woman.el b/lisp/woman.el
index 610590a2972..e4b29374a05 100644
--- a/lisp/woman.el
+++ b/lisp/woman.el
@@ -1491,7 +1491,8 @@ Also make each path-info component into a list.
 
 (defsubst woman-dired-define-key-maybe (key)
   "If KEY is undefined in Dired, bind it to command `woman-dired-find-file'."
-  (if (eq (lookup-key dired-mode-map key) 'undefined)
+  (if (or (eq (lookup-key dired-mode-map key) 'undefined)
+          (null (lookup-key dired-mode-map key)))
       (woman-dired-define-key key)))
 
 (defun woman-dired-define-keys ()
diff --git a/lisp/xt-mouse.el b/lisp/xt-mouse.el
index 19b58475a93..5709834ab91 100644
--- a/lisp/xt-mouse.el
+++ b/lisp/xt-mouse.el
@@ -43,14 +43,17 @@
 
 ;; Support multi-click -- somehow.
 
-;; Clicking on the mode-line does not work, although it should.
-
 ;;; Code:
 
 (define-key function-key-map "\e[M" 'xterm-mouse-translate)
 
 (defvar xterm-mouse-last)
 
+;; Mouse events symbols must have an 'event-kind property with
+;; the value 'mouse-click.
+(dolist (event-type '(mouse-1 mouse-2 mouse-3))
+  (put event-type 'event-kind 'mouse-click))
+
 (defun xterm-mouse-translate (event)
   "Read a click and release event from XTerm."
   (save-excursion
@@ -78,7 +81,7 @@
                (click-where (nth 1 click-data)))
           (if (memq down-binding '(nil ignore))
               (if (and (symbolp click-where)
-                       (not (eq 'menu-bar click-where)))
+                       (consp click-where))
                   (vector (list click-where click-data) click)
                 (vector click))
             (setq unread-command-events
@@ -92,10 +95,9 @@
                          0
                        (list (intern (format "drag-mouse-%d"
                                              (+ 1 xterm-mouse-last)))
-                             down-data click-data))
-                     )))
+                             down-data click-data)))))
             (if (and (symbolp down-where)
-                     (not (eq 'menu-bar down-where)))
+                     (consp down-where))
                 (vector (list down-where down-data) down)
               (vector down))))))))
 
@@ -124,30 +126,6 @@
   (let* ((type (- (xterm-mouse-event-read) #o40))
          (x (- (xterm-mouse-event-read) #o40 1))
          (y (- (xterm-mouse-event-read) #o40 1))
-         (point (cons x y))
-         (window (window-at x y))
-         (where (if window
-                    (coordinates-in-window-p point window)
-                  'menu-bar))
-         (pos (if (consp where)
-                  (progn
-                    (select-window window)
-                    (goto-char (window-start window))
-                    (move-to-window-line (-
-                                          (cdr where)
-                                          (if (or header-line-format
-                                                  default-header-line-format)
-                                              1
-                                            0)))
-                    (move-to-column (- (+ (car where) (current-column)
-                                       (if (string-match "\\` \\*Minibuf"
-                                                         (buffer-name))
-                                           (- (minibuffer-prompt-width))
-                                         0)
-                                       (max 0 (1- (window-hscroll))))
-                                       left-margin-width))
-                    (point))
-                where))
          (mouse (intern
                  ;; For buttons > 3, the release-event looks
                  ;; differently (see xc/programs/xterm/button.c,
@@ -159,12 +137,18 @@
                         (format "mouse-%d" (+ 1 xterm-mouse-last)))
                        (t
                         (setq xterm-mouse-last type)
-                        (format "down-mouse-%d" (+ 1 type)))))))
+                        (format "down-mouse-%d" (+ 1 type))))))
+         (w (window-at x y))
+         (ltrb (window-edges w))
+         (left (nth 0 ltrb))
+         (top (nth 1 ltrb)))
+
     (setq xterm-mouse-x x
           xterm-mouse-y y)
-    (list mouse
-          (list window pos point
-                (/ (nth 2 (current-time)) 1000)))))
+    (if w
+        (list mouse (posn-at-x-y (- x left) (- y top) w))
+      (list mouse
+            (append (list nil 'menu-bar) (nthcdr 2 (posn-at-x-y x y w)))))))
 
 ;;;###autoload
 (define-minor-mode xterm-mouse-mode