Revision: miles@gnu.org--gnu-2004/emacs--unicode--0--patch-78

Merge from emacs--cvs-trunk--0

Patches applied:

 * miles@gnu.org--gnu-2004/emacs--cvs-trunk--0--patch-719
 - miles@gnu.org--gnu-2004/emacs--cvs-trunk--0--patch-732
   Update from CVS

 * miles@gnu.org--gnu-2004/emacs--cvs-trunk--0--patch-733
   Update from CVS: man/calc.texi: Fix some TeX definitions.

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

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

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

37 files changed, 1302 insertions, 615 deletions

diff --git a/lisp/ChangeLog b/lisp/ChangeLog
index db884f5af3b..6912fb5d861 100644
--- a/lisp/ChangeLog
+++ b/lisp/ChangeLog
@@ -1,3 +1,207 @@
+2004-12-14  Juri Linkov  <juri@jurta.org>
+
+        * buff-menu.el (list-buffers-noselect): Collect internal info
+        for every buffer in BUFFER-LIST arg too.
+        (Buffer-menu-switch-other-window): Bind pop-up-windows to t.
+        (Buffer-menu-switch-other-window, Buffer-menu-2-window):
+        Bind same-window-buffer-names and same-window-regexps to nil.
+
+2004-12-13  Juri Linkov  <juri@jurta.org>
+
+        * simple.el (next-error-buffer-p, next-error-find-buffer):
+        Doc fix.
+
+        * mail/supercite.el (sc-cite-frame-alist): Doc fix.
+        (sc-cite-region, sc-uncite-region, sc-recite-region):
+        Fix previous change to handle not alist as a symbol, but
+        a citation frame as a symbol that represents a variable name.
+
+2004-12-13  Richard M. Stallman  <rms@gnu.org>
+
+        * filecache.el (file-cache-add-directory-using-find):
+        Only set up file-cache-find-command-posix-flag if we will use it.
+
+        * bindings.el (mode-line-buffer-identification-keymap):
+        Don't cancel the mode-line's usual down-mouse-1 binding.
+
+        * cus-edit.el (custom-face-selected): Handle `default' specs.
+        (custom-face-edit): Increase extra-offset.
+        (custom-display): Handle `default' specs.
+
+        * xml.el (xml-name-re, xml-entity-value-re): Add defvars.
+
+        * emacs-lisp/elint.el (elint-standard-variables)
+        (elint-unknown-builtin-args): Move definitions up.
+
+        * net/browse-url.el (browse-url-url-at-point): Add autoload.
+
+        * info.el (info-xref-visited): Use `default' instead of t.
+        (Info-try-follow-nearest-node): Don't explicitly load browse-url.
+
+        * faces.el (header-line, mode-line-inactive, tool-bar):
+        Use `default' instead of t for setting the defaults.
+        (face-spec-choose): Separate `t' from `default'.
+
+        * subr.el (while-no-input): New macro.
+
+2004-12-13  Frederik Fouvry  <fouvry@CoLi.Uni-SB.DE>  (tiny change)
+
+        * filecache.el (file-cache-add-directory-using-find):
+        Only test file-cache-find-command-posix-flag on some systems.
+
+2004-12-13  Stefan Monnier  <monnier@iro.umontreal.ca>
+
+        * vc-svn.el (vc-svn-repository-hostname): Adjust to new format.
+        Reported by Ville Skytt,Ad(B <scop@xemacs.org>.
+        (vc-svn-annotate-current-time, vc-svn-annotate-time-of-rev)
+        (vc-svn-annotate-time, vc-svn-annotate-extract-revision-at-line)
+        (vc-svn-annotate-command, vc-svn-annotate-re): Support for svn annotate.
+
+2004-12-12  Juri Linkov  <juri@jurta.org>
+
+        * files.el (find-file-other-window, find-file-other-frame):
+        Add the first buffer to the returned value to return the complete
+        list of all visited buffers.
+        (find-file-read-only, find-file-read-only-other-window)
+        (find-file-read-only-other-frame): Use nil for `mustmatch' arg of
+        `find-file-read-args'.  Signal an error about non-existent file
+        only if file name doesn't contain wildcards.  Toggle read-only in
+        all visited buffers.
+        (find-alternate-file, find-alternate-file-other-window):
+        Add optional arg `wildcards'.  Doc fix.  Set `wildcards' to t when
+        called interactively.  Pass arg `wildcards' to other functions.
+        (find-file-noselect): Doc fix.
+
+        * ffap.el (ffap-dired-wildcards): Set default to "[*?][^/]*\\'".
+        Doc fix.
+        (ffap-directory-finder): New variable.
+        (ffap-string-at-point-mode-alist): Add * and ? to `file'.
+        (ffap-file-at-point): Add /* to immediately rejected names.
+        Return absolute file names matching ffap-dired-wildcards.
+        (ffap-read-file-or-url): Set default value for `completing-read'
+        to `buffer-file-name'.
+        (find-file-at-point): When filename matches ffap-dired-wildcards,
+        call ffap-file-finder with t arg `wildcards', instead of dired.
+        (ffap-other-window, ffap-other-frame): Return visited buffers.
+        (ffap-read-only, ffap-read-only-other-window)
+        (ffap-read-only-other-frame, ffap-alternate-file): New commands.
+        (dired-at-point): Call ffap-directory-finder instead of dired.
+        (ffap-dired-other-window, ffap-dired-other-frame)
+        (ffap-list-directory): New commands.
+        (ffap-bindings): New keybindings for new commands.
+
+2004-12-12  Juri Linkov  <juri@jurta.org>
+
+        * simple.el (beginning-of-buffer, end-of-buffer):
+        * emacs-lisp/lisp.el (beginning-of-defun, end-of-defun):
+        Do not push mark when mark is active in transient-mark-mode.
+
+        * simple.el (mark-word):
+        * emacs-lisp/lisp.el (mark-sexp, mark-defun):
+        * textmodes/paragraphs.el (mark-paragraph):
+        Extend the region when mark is active in transient-mark-mode,
+        regardless of the last command.  Doc fix.
+
+        * simple.el (mark-word): Preserve direction when repeating.
+        Make arg optional.  Interactive "p" -> "P".
+        (transient-mark-mode, inhibit-mark-movement): Doc fix.
+
+        * emacs-lisp/lisp.el (mark-sexp): Reverse the condition for
+        preserving direction, to mark forward instead of backward when mark
+        is equal to point (e.g. when C-SPC C-M-SPC is typed in t-m-m).
+
+2004-12-12  Juri Linkov  <juri@jurta.org>
+
+        * isearch.el (isearch-edit-string): Set 7th arg of
+        `read-from-minibuffer' to `t' to inherit the current input
+        method (whose name is indicated by [IM] in the minibuffer prompt)
+        from the current buffer to the minibuffer.
+        (isearch-lazy-highlight-update): Put body to `with-local-quit'
+        to allow C-g quitting for lazy highlighting looping inside the
+        search with nested repetition operators.  Add overlay to the list
+        before setting its face and other properties to avoid the case of
+        code quitting after placing the new overlay but before it's
+        recorded on the list.  Select the window where isearch was
+        activated, to highlight matches in the right window when isearch
+        switches the current window to the minibuffer.
+
+        * international/isearch-x.el
+        (isearch-process-search-multibyte-characters):
+        Use `isearch-message' as initial input for `read-string' instead
+        of adding it to the minibuffer prompt.  After reading a string
+        remove the initial value of `isearch-message' from the string.
+
+        * replace.el (replace-match-maybe-edit): Doc fix.
+        (perform-replace): Don't call `replace-highlight' when automatic
+        replacement is requested in literal mode, since it is intended
+        only to highlight words during entering a new replacement string
+        for \? in non-literal mode.
+
+        * replace.el (query-replace-highlight): Add new value `isearch'
+        that allows query replacement to use isearch highlighting.
+        Change type from `boolean' to `choice'.  Doc fix.
+        (replace-highlight, replace-dehighlight, perform-replace):
+        Use isearch highlighting if query-replace-highlight eq `isearch'.
+
+2004-12-11  Stefan Monnier  <monnier@iro.umontreal.ca>
+
+        * emacs-lisp/checkdoc.el (checkdoc-continue, checkdoc-comments)
+        (checkdoc-message-text, checkdoc-defun): Fix format messages for `error'.
+
+        * textmodes/tex-mode.el (latex-backward-sexp-1): Handle the special
+        case of \end{verbatim}.
+
+2004-12-11  Dan Nicolaescu  <dann@ics.uci.edu>
+
+        * term.el (term-termcap-format): Synchronyze with terminfo.
+        (term-emulate-terminal): Handle reset.
+        (term-reset-terminal): New function.
+
+2004-12-11  Thien-Thi Nguyen  <ttn@gnu.org>
+
+        * play/zone.el (zone-programs): Add `zone-pgm-random-life'.
+        (zone-fill-out-screen): New func.
+        (zone-pgm-drip): Use `zone-fill-out-screen'.
+        Also, no longer go to point-min on every cycle.
+        (zone-pgm-paragraph-spaz): Allow spazzing for texinfo-mode.
+        (zone-pgm-random-life-wait): New user var.
+        (zone-pgm-random-life): New func.
+
+2004-12-10  Thien-Thi Nguyen  <ttn@gnu.org>
+
+        * files.el (auto-mode-alist): Map .com to DCL mode.
+
+2004-12-09  Richard M. Stallman  <rms@gnu.org>
+
+        * isearch.el (isearch-mode-map): Treat S-SPC like SPC.
+
+2004-12-09  Nick Roberts  <nickrob@snap.net.nz>
+
+        * xt-mouse.el (xterm-mouse-event): Correct cursor position in a
+        buffer with a display margin.
+
+2004-12-08  Jay Belanger  <belanger@truman.edu>
+
+        * calc/calc-keypd.el (calc-keypad-mode): Unbind unused mouse events.
+        (calc-keypad-left-click): Set buffer to calc-keymap-buffer.
+
+2004-12-08  Richard M. Stallman  <rms@gnu.org>
+
+        * faces.el: Delete code to set display table.
+        (escape-glyph): Redefine to be less loud.  (Copy minibuffer-prompt.)
+
+2004-12-08  Jay Belanger  <belanger@truman.edu>
+
+        * calc/calc.el: Add math-read-preprocess-string to autoloads.
+
+        * calc/calc-ext.el (math-read-replacement-list)
+        (math-read-superscripts, math-read-preprocess-string): Move to
+        calc-aent.el.
+
+        * calc/calc-aent.el (math-read-replacement-list)
+        (math-read-superscripts, math-read-preprocess-string): Move from
+        calc-ext.el.
+
 2004-12-07  Stefan Monnier  <monnier@iro.umontreal.ca>
 
         * isearch.el (isearch-quote-char): Fix up typo in last change.
@@ -10,10 +214,9 @@
         * edmacro.el: `edit-kbd-macro' is now bound to `C-x C-k e'.
         (edmacro-finish-edit): Further update for keyboard macros that are
         lambda forms.
-        (edmacro-sanitize-for-string): Correctly remove Meta modifier
-        (as suggested by Kim Storm).
+        (edmacro-sanitize-for-string): Correctly remove Meta modifier.
 
-2004-12-06  Stefan Monnier  <monnier@iro.umontreal.ca>
+2004-12-07  Stefan Monnier  <monnier@iro.umontreal.ca>
 
         * font-lock.el (font-lock-unfontify-region): Save buffer state.
         (font-lock-default-unfontify-region): Don't save buffer state any more.
@@ -7853,7 +8056,115 @@
         (compilation-forget-errors): Don't localize already local
         compilation-locs and remove FIXME about refontifying.
 
-2004-04-14
+2004-04-14  Kim F. Storm  <storm@cua.dk>
+
+        * startup.el (emacs-quick-startup): New defvar (set by -Q).
+        (command-line): New option -Q.  Like -q --no-site-file, but
+        in addition it also disables menu-bar, tool-bar, scroll-bars,
+        tool-tips, and the blinking cursor.
+        (command-line-1): Skip startup screen if -Q.
+        (fancy-splash-head): Use ":align-to center" prop to center splash image.
+
+        * emulation/cua-base.el (cua-read-only-cursor-color)
+        (cua-overwrite-cursor-color, cua-global-mark-cursor-color): Doc fix.
+
+2004-04-13  Dave Love  <fx@gnu.org>
+
+        * progmodes/python.el: Doc fixes.  Changes for compiler warnings.
+        (syntax): Don't require.
+        (python) <defgroup>: Add :version.
+        (python-quote-syntax): Re-written.
+        (inferior-python-mode): Move stuff here from run-python and add
+        some more.
+        (python-preoutput-continuation, python-preoutput-result)
+        (python-dotty-syntax-table): New.
+        (python-describe-symbol): Use them.
+        (run-python): Move stuff to inferior-python-mode.  Modify code
+        loaded into Python.
+        (python-send-region): Use python-proc, python-send-string.
+        (python-send-string): Send newlines too.  Callers changed.
+        (python-load-file): Re-written.
+        (python-eldoc-function): New.
+        (info-look): Don't require.
+        (python-after-info-look): New.  A modified version of former
+        top-level code for use with eval-after-load.
+        (python-maybe-jython, python-guess-indent): Use widened buffer.
+        (python-fill-paragraph): Re-written.
+        (python-mode): Fix outline-regexp.  Set outline-heading-end-regexp,
+        eldoc-print-current-symbol-info-function.  Add to eldoc-mode-hook.
+
+2004-04-13  Stefan Monnier  <monnier@iro.umontreal.ca>
+
+        * progmodes/python.el (run-python): Use compilation-shell-minor-mode.
+        Set compilation-error-regexp-alist earlier.
+
+        * progmodes/compile.el (compilation-minor-mode-map)
+        (compilation-shell-minor-mode-map, compile-mouse-goto-error)
+        (compile-goto-error): Re-merge the mouse and non-mouse commands.
+
+2004-04-12  Stefan Monnier  <monnier@iro.umontreal.ca>
+
+        * progmodes/compile.el (compile-goto-error): Select the buffer/window
+        corresponding to the event.
+
+2004-04-12  Joe Buehler  <jbuehler@hekiman.com>
+
+        * loadup.el: Add cygwin to system-type list, for unexec() support.
+
+2004-04-12  John Paul Wallington  <jpw@gnu.org>
+
+        * ibuffer.el (ibuffer-delete-window-on-quit): Remove.
+        (ibuffer-restore-window-config-on-quit): New variable to replace
+        `ibuffer-delete-window-on-quit'.  Update all references.
+        (ibuffer-prev-window-config): New variable.
+        (ibuffer-quit): Restore previous window configuration instead of
+        deleting window.
+        (ibuffer): Save window configuration before showing Ibuffer buffer.
+
+        * help.el (describe-mode): Doc fix.
+
+2004-04-12  Stefan Monnier  <monnier@iro.umontreal.ca>
+
+        * progmodes/compile.el (compilation-mode-font-lock-keywords): Fix test
+        not to treat nil as a function.
+
+        * vc-arch.el (vc-arch-root): Be a bit more careful.
+        (vc-arch-register): Save the buffer if we modified it.
+        (vc-arch-delete-rej-if-obsolete): Save excursion.
+        (vc-arch-find-file-hook): Use the simpler after-save-hook.
+        (vc-arch-responsible-p, vc-arch-init-version): New functions.
+
+        * net/ldap.el (ldap-search): Use list*.
+
+2004-04-12  Juri Linkov  <juri@jurta.org>
+
+        * info.el (Info-follow-reference): Allow multiline reference name.
+
+2004-04-11  Dave Love  <fx@gnu.org>
+
+        * emacs-lisp/bytecomp.el (byte-compile-cond): Fix last change.
+
+        * progmodes/python.el: New file.
+
+2004-04-11  Andre Spiegel  <spiegel@gnu.org>
+
+        * vc-hooks.el (vc-arg-list): Function removed.
+        (vc-default-workfile-unchanged-p): Use condition-case to check for
+        backward compatibility.
+
+        * vc.el (vc-print-log): Use condition-case to check for backward
+        compatibility.
+
+2004-04-11  Juri Linkov  <juri@jurta.org>
+
+        * dired.el (dired-faces): New defgroup.
+        (dired-header, dired-mark, dired-marked, dired-flagged)
+        (dired-warning, dired-directory, dired-symlink, dired-ignored):
+        New faces.
+        (dired-header-face, dired-mark-face, dired-marked-face)
+        (dired-flagged-face, dired-warning-face, dired-directory-face)
+        (dired-symlink-face, dired-ignored-face): New face variables.
+        (dired-font-lock-keywords): Use them instead of font-lock faces.
         Split the rule for dired marks into 3 separate rules: for marks,
         marked file names and flagged file names.
 
diff --git a/lisp/bindings.el b/lisp/bindings.el
index b3459b62ac8..93921c6f982 100644
--- a/lisp/bindings.el
+++ b/lisp/bindings.el
@@ -448,7 +448,6 @@ Menu of mode operations in the mode line.")
 (let ((map (make-sparse-keymap)))
   ;; Bind down- events so that the global keymap won't ``shine
   ;; through''.
-  (define-key map [mode-line down-mouse-1] 'ignore)
   (define-key map [mode-line mouse-1] 'mode-line-unbury-buffer)
   (define-key map [header-line down-mouse-1] 'ignore)
   (define-key map [header-line mouse-1] 'mode-line-unbury-buffer)
diff --git a/lisp/buff-menu.el b/lisp/buff-menu.el
index 990ab32c9a4..1c3fa704041 100644
--- a/lisp/buff-menu.el
+++ b/lisp/buff-menu.el
@@ -484,14 +484,19 @@ in the selected frame."
   "Make the other window select this line's buffer.
 The current window remains selected."
   (interactive)
-  (display-buffer (Buffer-menu-buffer t)))
+  (let ((pop-up-windows t)
+        same-window-buffer-names
+        same-window-regexps)
+    (display-buffer (Buffer-menu-buffer t))))
 
 (defun Buffer-menu-2-window ()
   "Select this line's buffer, with previous buffer in second window."
   (interactive)
   (let ((buff (Buffer-menu-buffer t))
         (menu (current-buffer))
-        (pop-up-windows t))
+        (pop-up-windows t)
+        same-window-buffer-names
+        same-window-regexps)
     (delete-other-windows)
     (switch-to-buffer (other-buffer))
     (pop-to-buffer buff)
@@ -671,8 +676,7 @@ For more information, see the function `buffer-menu'."
       ;; line with the beginning of the text (rather than with the left
       ;; scrollbar or the left fringe).  –-Stef
       (setq header (concat (propertize " " 'display '(space :align-to 0))
-                           header))
-      )
+                           header)))
     (with-current-buffer (get-buffer-create "*Buffer List*")
       (setq buffer-read-only nil)
       (erase-buffer)
@@ -684,47 +688,45 @@ For more information, see the function `buffer-menu'."
                          (mapcar (lambda (c)
                                    (if (memq c '(?\n ?\ )) c underline))
                                  header)))))
-      (if buffer-list
-          (setq list buffer-list)
-        ;; Collect info for every buffer we're interested in.
-        (dolist (buffer (buffer-list))
-          (with-current-buffer buffer
-            (let ((name (buffer-name))
-                  (file buffer-file-name))
-              (cond
-               ;; Don't mention internal buffers.
-               ((and (string= (substring name 0 1) " ") (null file)))
-               ;; Maybe don't mention buffers without files.
-               ((and files-only (not file)))
-               ((string= name "*Buffer List*"))
-               ;; Otherwise output info.
-               (t
-                (let ((mode (concat (format-mode-line mode-name nil nil buffer)
-                                    (if mode-line-process
-                                        (format-mode-line mode-line-process
-                                                          nil nil buffer))))
-                      (bits (string
-                             (if (eq buffer old-buffer) ?. ?\ )
-                             ;; Handle readonly status.  The output buffer
-                             ;; is special cased to appear readonly; it is
-                             ;; actually made so at a later date.
-                             (if (or (eq buffer standard-output)
-                                     buffer-read-only)
-                                 ?% ?\ )
-                             ;; Identify modified buffers.
-                             (if (buffer-modified-p) ?* ?\ )
-                             ;; Space separator.
-                             ?\ )))
-                  (unless file
-                    ;; No visited file.  Check local value of
-                    ;; list-buffers-directory.
-                    (when (and (boundp 'list-buffers-directory)
-                               list-buffers-directory)
-                      (setq file list-buffers-directory)))
-                  (push (list buffer bits name (buffer-size) mode file)
-                        list)))))))
-        ;; Preserve the original buffer-list ordering, just in case.
-        (setq list (nreverse list)))
+      ;; Collect info for every buffer we're interested in.
+      (dolist (buffer (or buffer-list (buffer-list)))
+        (with-current-buffer buffer
+          (let ((name (buffer-name))
+                (file buffer-file-name))
+            (unless (and (not buffer-list)
+                         (or
+                          ;; Don't mention internal buffers.
+                          (and (string= (substring name 0 1) " ") (null file))
+                          ;; Maybe don't mention buffers without files.
+                          (and files-only (not file))
+                          (string= name "*Buffer List*")))
+              ;; Otherwise output info.
+              (let ((mode (concat (format-mode-line mode-name nil nil buffer)
+                                  (if mode-line-process
+                                      (format-mode-line mode-line-process
+                                                        nil nil buffer))))
+                    (bits (string
+                           (if (eq buffer old-buffer) ?. ?\ )
+                           ;; Handle readonly status.  The output buffer
+                           ;; is special cased to appear readonly; it is
+                           ;; actually made so at a later date.
+                           (if (or (eq buffer standard-output)
+                                   buffer-read-only)
+                               ?% ?\ )
+                           ;; Identify modified buffers.
+                           (if (buffer-modified-p) ?* ?\ )
+                           ;; Space separator.
+                           ?\ )))
+                (unless file
+                  ;; No visited file.  Check local value of
+                  ;; list-buffers-directory.
+                  (when (and (boundp 'list-buffers-directory)
+                             list-buffers-directory)
+                    (setq file list-buffers-directory)))
+                (push (list buffer bits name (buffer-size) mode file)
+                      list))))))
+      ;; Preserve the original buffer-list ordering, just in case.
+      (setq list (nreverse list))
       ;; Place the buffers's info in the output buffer, sorted if necessary.
       (dolist (buffer
                (if Buffer-menu-sort-column
diff --git a/lisp/calc/calc-aent.el b/lisp/calc/calc-aent.el
index 4c62e570349..c062a822e89 100644
--- a/lisp/calc/calc-aent.el
+++ b/lisp/calc/calc-aent.el
@@ -465,6 +465,73 @@ T means abort and give an error message.")
 
 ;;; Algebraic expression parsing.   [Public]
 
+(defvar math-read-replacement-list
+  '(;; Misc symbols
+    ("±" "+/-")  ; plus or minus
+    ("×" "*")    ; multiplication sign
+    ("÷" ":")    ; division sign
+    ("−" "-")    ; subtraction sign
+    ("∕" "/")    ; division sign
+    ("∗" "*")    ; asterisk multiplication
+    ("∞" "inf")  ; infinity symbol
+    ("≤" "<=")
+    ("≥" ">=")
+    ("≦" "<=")
+    ("≧" ">=")
+    ;; fractions
+    ("¼" "(1:4)") ; 1/4
+    ("½" "(1:2)") ; 1/2
+    ("¾" "(3:4)") ; 3/4
+    ("⅓" "(1:3)") ; 1/3
+    ("⅔" "(2:3)") ; 2/3
+    ("⅕" "(1:5)") ; 1/5
+    ("⅖" "(2:5)") ; 2/5
+    ("⅗" "(3:5)") ; 3/5
+    ("⅘" "(4:5)") ; 4/5
+    ("⅙" "(1:6)") ; 1/6
+    ("⅚" "(5:6)") ; 5/6
+    ("⅛" "(1:8)") ; 1/8
+    ("⅜" "(3:8)") ; 3/8
+    ("⅝" "(5:8)") ; 5/8
+    ("⅞" "(7:8)") ; 7/8
+    ("⅟" "1:")    ; 1/...
+    ;; superscripts
+    ("⁰" "0")  ; 0
+    ("¹" "1")  ; 1
+    ("²" "2")  ; 2
+    ("³" "3")  ; 3
+    ("⁴" "4")  ; 4
+    ("⁵" "5")  ; 5
+    ("⁶" "6")  ; 6
+    ("⁷" "7")  ; 7
+    ("⁸" "8")  ; 8
+    ("⁹" "9")  ; 9
+    ("⁺" "+")  ; +
+    ("⁻" "-")  ; -
+    ("⁽" "(")  ; (
+    ("⁾" ")")  ; )
+    ("ⁿ" "n")  ; n
+    ("ⁱ" "i")) ; i
+  "A list whose elements (old new) indicate replacements to make
+in Calc algebraic input.")
+
+(defvar math-read-superscripts
+  "⁰¹²³⁴⁵⁶⁷⁸⁹⁺⁻⁽⁾ⁿⁱ" ; 0123456789+-()ni
+  "A string consisting of the superscripts allowed by Calc.")
+
+(defun math-read-preprocess-string (str)
+  "Replace some substrings of STR by Calc equivalents."
+  (setq str
+        (replace-regexp-in-string (concat "[" math-read-superscripts "]+")
+                                  "^(\\&)" str))
+  (let ((rep-list math-read-replacement-list))
+    (while rep-list
+      (setq str
+            (replace-regexp-in-string (nth 0 (car rep-list))
+                                      (nth 1 (car rep-list)) str))
+      (setq rep-list (cdr rep-list))))
+  str)
+
 ;; The next few variables are local to math-read-exprs (and math-read-expr
 ;; in calc-ext.el), but are set in functions they call.
 
diff --git a/lisp/calc/calc-ext.el b/lisp/calc/calc-ext.el
index d308a391a05..89588b4ea74 100644
--- a/lisp/calc/calc-ext.el
+++ b/lisp/calc/calc-ext.el
@@ -2874,73 +2874,6 @@ calc-kill calc-kill-region calc-yank))))
 
 (defvar math-expr-data)
 
-(defvar math-read-replacement-list
-  '(;; Misc symbols
-    ("±" "+/-")  ; plus or minus
-    ("×" "*")    ; multiplication sign
-    ("÷" ":")    ; division sign
-    ("−" "-")    ; subtraction sign
-    ("∕" "/")    ; division sign
-    ("∗" "*")    ; asterisk multiplication
-    ("∞" "inf")  ; infinity symbol
-    ("≤" "<=")
-    ("≥" ">=")
-    ("≦" "<=")
-    ("≧" ">=")
-    ;; fractions
-    ("¼" "(1:4)") ; 1/4
-    ("½" "(1:2)") ; 1/2
-    ("¾" "(3:4)") ; 3/4
-    ("⅓" "(1:3)") ; 1/3
-    ("⅔" "(2:3)") ; 2/3
-    ("⅕" "(1:5)") ; 1/5
-    ("⅖" "(2:5)") ; 2/5
-    ("⅗" "(3:5)") ; 3/5
-    ("⅘" "(4:5)") ; 4/5
-    ("⅙" "(1:6)") ; 1/6
-    ("⅚" "(5:6)") ; 5/6
-    ("⅛" "(1:8)") ; 1/8
-    ("⅜" "(3:8)") ; 3/8
-    ("⅝" "(5:8)") ; 5/8
-    ("⅞" "(7:8)") ; 7/8
-    ("⅟" "1:")    ; 1/...
-    ;; superscripts
-    ("⁰" "0")  ; 0
-    ("¹" "1")  ; 1
-    ("²" "2")  ; 2
-    ("³" "3")  ; 3
-    ("⁴" "4")  ; 4
-    ("⁵" "5")  ; 5
-    ("⁶" "6")  ; 6
-    ("⁷" "7")  ; 7
-    ("⁸" "8")  ; 8
-    ("⁹" "9")  ; 9
-    ("⁺" "+")  ; +
-    ("⁻" "-")  ; -
-    ("⁽" "(")  ; (
-    ("⁾" ")")  ; )
-    ("ⁿ" "n")  ; n
-    ("ⁱ" "i")) ; i
-  "A list whose elements (old new) indicate replacements to make
-in Calc algebraic input.")
-
-(defvar math-read-superscripts
-  "⁰¹²³⁴⁵⁶⁷⁸⁹⁺⁻⁽⁾ⁿⁱ" ; 0123456789+-()ni
-  "A string consisting of the superscripts allowed by Calc.")
-
-(defun math-read-preprocess-string (str)
-  "Replace some substrings of STR by Calc equivalents."
-  (setq str
-        (replace-regexp-in-string (concat "[" math-read-superscripts "]+")
-                                  "^(\\&)" str))
-  (let ((rep-list math-read-replacement-list))
-    (while rep-list
-      (setq str
-            (replace-regexp-in-string (nth 0 (car rep-list))
-                                      (nth 1 (car rep-list)) str))
-      (setq rep-list (cdr rep-list))))
-  str)
-
 (defun math-read-expr (math-exp-str)
   (let ((math-exp-pos 0)
         (math-exp-old-pos 0)
diff --git a/lisp/calc/calc-keypd.el b/lisp/calc/calc-keypd.el
index e517ac1942b..2c2a0f0f4aa 100644
--- a/lisp/calc/calc-keypd.el
+++ b/lisp/calc/calc-keypd.el
@@ -236,9 +236,21 @@
   (define-key calc-keypad-mode-map (kbd "RET") 'calc-keypad-press)
   (define-key calc-keypad-mode-map (kbd "TAB") 'calc-keypad-menu)
   (define-key calc-keypad-mode-map "q" 'calc-keypad-off)
-  (define-key calc-keypad-mode-map [(mouse-3)] 'calc-keypad-right-click)
-  (define-key calc-keypad-mode-map [(mouse-2)] 'calc-keypad-middle-click)
-  (define-key calc-keypad-mode-map [(mouse-1)] 'calc-keypad-left-click)
+  (define-key calc-keypad-mode-map [down-mouse-1] 'ignore)
+  (define-key calc-keypad-mode-map [drag-mouse-1] 'ignore)
+  (define-key calc-keypad-mode-map [double-mouse-1] 'ignore)
+  (define-key calc-keypad-mode-map [triple-mouse-1] 'ignore)
+  (define-key calc-keypad-mode-map [down-mouse-2] 'ignore)
+  (define-key calc-keypad-mode-map [drag-mouse-2] 'ignore)
+  (define-key calc-keypad-mode-map [double-mouse-2] 'ignore)
+  (define-key calc-keypad-mode-map [triple-mouse-2] 'ignore)
+  (define-key calc-keypad-mode-map [down-mouse-3] 'ignore)
+  (define-key calc-keypad-mode-map [drag-mouse-3] 'ignore)
+  (define-key calc-keypad-mode-map [double-mouse-3] 'ignore)
+  (define-key calc-keypad-mode-map [triple-mouse-3] 'ignore)
+  (define-key calc-keypad-mode-map [mouse-3] 'calc-keypad-right-click)
+  (define-key calc-keypad-mode-map [mouse-2] 'calc-keypad-middle-click)
+  (define-key calc-keypad-mode-map [mouse-1] 'calc-keypad-left-click)
   (put 'calc-keypad-mode 'mode-class 'special)
   (make-local-variable 'calc-main-buffer))
 
@@ -529,8 +541,9 @@
 (defun calc-keypad-left-click (event)
   "Handle a left-button mouse click in Calc Keypad window."
   (interactive "e")
-  (goto-char (posn-point (event-start event)))
-  (calc-keypad-press))
+  (with-current-buffer calc-keypad-buffer
+    (goto-char (posn-point (event-start event)))
+    (calc-keypad-press)))
 
 (defun calc-keypad-right-click (event)
   "Handle a right-button mouse click in Calc Keypad window."
diff --git a/lisp/calc/calc.el b/lisp/calc/calc.el
index a7e840594ec..d8e6eb3017c 100644
--- a/lisp/calc/calc.el
+++ b/lisp/calc/calc.el
@@ -890,7 +890,7 @@ If nil, selections displayed but ignored.")
     calc-check-user-syntax calc-do-alg-entry calc-do-calc-eval
     calc-do-quick-calc calc-match-user-syntax math-build-parse-table
     math-find-user-tokens math-read-expr-list math-read-exprs math-read-if
-    math-read-token math-remove-dashes)
+    math-read-token math-remove-dashes math-read-preprocess-string)
 
  ("calc-embed" calc-do-embedded-activate)
 
diff --git a/lisp/cus-edit.el b/lisp/cus-edit.el
index 046c1bebcf7..5f3ffc6f8bf 100644
--- a/lisp/cus-edit.el
+++ b/lisp/cus-edit.el
@@ -1561,9 +1561,9 @@ item in another window.\n\n"))
   :group 'custom-magic-faces)
 
 (defface custom-set-face '((((class color))
-                                (:foreground "blue" :background "white"))
-                               (t
-                                (:slant italic)))
+                            (:foreground "blue" :background "white"))
+                           (t
+                            (:slant italic)))
   "Face used when the customize item has been set."
   :group 'custom-magic-faces)
 
@@ -1578,31 +1578,32 @@ item in another window.\n\n"))
   "Face used when the customize item has been saved."
   :group 'custom-magic-faces)
 
-(defconst custom-magic-alist '((nil "#" underline "\
+(defconst custom-magic-alist
+  '((nil "#" underline "\
 uninitialized, you should not see this.")
-                               (unknown "?" italic "\
+    (unknown "?" italic "\
 unknown, you should not see this.")
-                               (hidden "-" default "\
+    (hidden "-" default "\
 hidden, invoke \"Show\" in the previous line to show." "\
 group now hidden, invoke \"Show\", above, to show contents.")
-                               (invalid "x" custom-invalid-face "\
+    (invalid "x" custom-invalid-face "\
 the value displayed for this %c is invalid and cannot be set.")
-                               (modified "*" custom-modified-face "\
+    (modified "*" custom-modified-face "\
 you have edited the value as text, but you have not set the %c." "\
 you have edited something in this group, but not set it.")
-                               (set "+" custom-set-face "\
+    (set "+" custom-set-face "\
 you have set this %c, but not saved it for future sessions." "\
 something in this group has been set, but not saved.")
-                               (changed ":" custom-changed-face "\
+    (changed ":" custom-changed-face "\
 this %c has been changed outside the customize buffer." "\
 something in this group has been changed outside customize.")
-                               (saved "!" custom-saved-face "\
+    (saved "!" custom-saved-face "\
 this %c has been set and saved." "\
 something in this group has been set and saved.")
-                               (rogue "@" custom-rogue-face "\
+    (rogue "@" custom-rogue-face "\
 this %c has not been changed with customize." "\
 something in this group is not prepared for customization.")
-                               (standard " " nil "\
+    (standard " " nil "\
 this %c is unchanged from its standard setting." "\
 visible group members are all at standard settings."))
   "Alist of customize option states.
@@ -2576,7 +2577,7 @@ to switch between two values."
   "Edit face attributes."
   :format "%t: %v"
   :tag "Attributes"
-  :extra-offset 12
+  :extra-offset 13
   :button-args '(:help-echo "Control whether this attribute has any effect.")
   :value-to-internal 'custom-face-edit-fix-value
   :match (lambda (widget value)
@@ -2689,6 +2690,7 @@ Also change :reverse-video to :inverse-video."
   :value t
   :help-echo "Specify frames where the face attributes should be used."
   :args '((const :tag "all" t)
+          (const :tag "defaults" default)
           (checklist
            :offset 0
            :extra-offset 9
@@ -2817,13 +2819,29 @@ Only match frames that support the specified face attributes.")
 
 (define-widget 'custom-face-selected 'group
   "Edit the attributes of the selected display in a face specification."
-  :args '((repeat :format ""
-                  :inline t
-                  (group custom-display-unselected sexp))
-          (group (sexp :format "") custom-face-edit)
-          (repeat :format ""
-                  :inline t
-                  sexp)))
+  :args '((choice :inline t
+                  (group :tag "With Defaults" :inline t
+                   (group (const :tag "" default)
+                          (custom-face-edit :tag " Default\n Attributes"))
+                   (repeat :format ""
+                           :inline t
+                           (group custom-display-unselected sexp))
+                   (group (sexp :format "")
+                          (custom-face-edit :tag " Overriding\n Attributes"))
+                   (repeat :format ""
+                           :inline t
+                           sexp))
+                  (group :tag "No Defaults" :inline t
+                         (repeat :format ""
+                                 :inline t
+                                 (group custom-display-unselected sexp))
+                         (group (sexp :format "")
+                                (custom-face-edit :tag "\n Attributes"))
+                         (repeat :format ""
+                                 :inline t
+                                 sexp)))))
+
+
 
 (defconst custom-face-selected (widget-convert 'custom-face-selected)
   "Converted version of the `custom-face-selected' widget.")
diff --git a/lisp/emacs-lisp/checkdoc.el b/lisp/emacs-lisp/checkdoc.el
index cc2be890657..7b022e9f118 100644
--- a/lisp/emacs-lisp/checkdoc.el
+++ b/lisp/emacs-lisp/checkdoc.el
@@ -919,7 +919,7 @@ is the starting location.  If this is nil, `point-min' is used instead."
         (progn
           (goto-char wrong)
           (if (not take-notes)
-              (error (checkdoc-error-text msg)))))
+              (error "%s" (checkdoc-error-text msg)))))
     (checkdoc-show-diagnostics)
     (if (interactive-p)
         (message "No style warnings."))))
@@ -952,7 +952,7 @@ if there is one."
          (e (checkdoc-file-comments-engine))
         (checkdoc-generate-compile-warnings-flag
          (or take-notes checkdoc-generate-compile-warnings-flag)))
-    (if e (error (checkdoc-error-text e)))
+    (if e (error "%s" (checkdoc-error-text e)))
     (checkdoc-show-diagnostics)
     e))
 
@@ -990,7 +990,7 @@ Optional argument TAKE-NOTES causes all errors to be logged."
     (if (not (interactive-p))
         e
       (if e
-          (error (checkdoc-error-text e))
+          (error "%s" (checkdoc-error-text e))
         (checkdoc-show-diagnostics)))
     (goto-char p))
   (if (interactive-p) (message "Checking interactive message text...done.")))
@@ -1033,15 +1033,15 @@ space at the end of each line."
              (msg (checkdoc-this-string-valid)))
         (if msg (if no-error
                     (message (checkdoc-error-text msg))
-                  (error (checkdoc-error-text msg)))
+                  (error "%s" (checkdoc-error-text msg)))
           (setq msg (checkdoc-message-text-search beg end))
           (if msg (if no-error
                       (message (checkdoc-error-text msg))
-                    (error (checkdoc-error-text msg)))
+                    (error "%s" (checkdoc-error-text msg)))
             (setq msg (checkdoc-rogue-space-check-engine beg end))
             (if msg (if no-error
                         (message (checkdoc-error-text msg))
-                      (error (checkdoc-error-text msg))))))
+                      (error "%s" (checkdoc-error-text msg))))))
         (if (interactive-p) (message "Checkdoc: done."))))))
 
 ;;; Ispell interface for forcing a spell check
diff --git a/lisp/emacs-lisp/elint.el b/lisp/emacs-lisp/elint.el
index bf9c1d39f95..9454bfc9da3 100644
--- a/lisp/emacs-lisp/elint.el
+++ b/lisp/emacs-lisp/elint.el
@@ -50,6 +50,85 @@
   "*The buffer to insert lint messages in.")
 
 ;;;
+;;; Data
+;;;
+
+(defconst elint-standard-variables
+  '(abbrev-mode auto-fill-function buffer-auto-save-file-name
+     buffer-backed-up buffer-display-count buffer-display-table buffer-display-time buffer-file-coding-system buffer-file-format
+     buffer-file-name buffer-file-number buffer-file-truename
+     buffer-file-type buffer-invisibility-spec buffer-offer-save
+     buffer-read-only buffer-saved-size buffer-undo-list
+     cache-long-line-scans case-fold-search ctl-arrow cursor-type comment-column
+     default-directory defun-prompt-regexp desktop-save-buffer enable-multibyte-characters fill-column fringes-outside-margins goal-column
+     header-line-format indicate-buffer-boundaries indicate-empty-lines
+     left-fringe-width
+     left-margin left-margin-width line-spacing local-abbrev-table local-write-file-hooks major-mode
+     mark-active mark-ring mode-line-buffer-identification
+     mode-line-format mode-line-modified mode-line-process mode-name
+     overwrite-mode 
+     point-before-scroll right-fringe-width right-margin-width
+     scroll-bar-width scroll-down-aggressively scroll-up-aggressively selective-display
+     selective-display-ellipses tab-width truncate-lines vc-mode vertical-scroll-bar)
+  "Standard buffer local vars.")
+
+(defconst elint-unknown-builtin-args
+  '((while test &rest forms)
+    (insert-before-markers-and-inherit &rest text)
+    (catch tag &rest body)
+    (and &rest args)
+    (funcall func &rest args)
+    (insert &rest args)
+    (vconcat &rest args)
+    (run-hook-with-args hook &rest args)
+    (message-or-box string &rest args)
+    (save-window-excursion &rest body)
+    (append &rest args)
+    (logior &rest args)
+    (progn &rest body)
+    (insert-and-inherit &rest args)
+    (message-box string &rest args)
+    (prog2 x y &rest body)
+    (prog1 first &rest body)
+    (insert-before-markers &rest args)
+    (call-process-region start end program &optional delete
+                         destination display &rest args)
+    (concat &rest args)
+    (vector &rest args)
+    (run-hook-with-args-until-success hook &rest args)
+    (track-mouse &rest body)
+    (unwind-protect bodyform &rest unwindforms)
+    (save-restriction &rest body)
+    (quote arg)
+    (make-byte-code &rest args)
+    (or &rest args)
+    (cond &rest clauses)
+    (start-process name buffer program &rest args)
+    (run-hook-with-args-until-failure hook &rest args)
+    (if cond then &rest else)
+    (apply function &rest args)
+    (format string &rest args)
+    (encode-time second minute hour day month year zone &rest args)
+    (min &rest args)
+    (logand &rest args)
+    (logxor &rest args)
+    (max &rest args)
+    (list &rest args)
+    (message string &rest args)
+    (defvar symbol init doc)
+    (call-process program &optional infile destination display &rest args)
+    (with-output-to-temp-buffer bufname &rest body)
+    (nconc &rest args)
+    (save-excursion &rest body)
+    (run-hooks &rest hooks)
+    (/ x y &rest zs)
+    (- x &rest y)
+    (+ &rest args)
+    (* &rest args)
+    (interactive &optional args))
+  "Those built-ins for which we can't find arguments.")
+
+;;;
 ;;; ADT: top-form
 ;;;
 
@@ -724,85 +803,6 @@ If no documentation could be found args will be `unknown'."
             (if list list
               (elint-find-builtins))))
 
-;;;
-;;; Data
-;;;
-
-(defconst elint-standard-variables
-  '(abbrev-mode auto-fill-function buffer-auto-save-file-name
-     buffer-backed-up buffer-display-count buffer-display-table buffer-display-time buffer-file-coding-system buffer-file-format
-     buffer-file-name buffer-file-number buffer-file-truename
-     buffer-file-type buffer-invisibility-spec buffer-offer-save
-     buffer-read-only buffer-saved-size buffer-undo-list
-     cache-long-line-scans case-fold-search ctl-arrow cursor-type comment-column
-     default-directory defun-prompt-regexp desktop-save-buffer enable-multibyte-characters fill-column fringes-outside-margins goal-column
-     header-line-format indicate-buffer-boundaries indicate-empty-lines
-     left-fringe-width
-     left-margin left-margin-width line-spacing local-abbrev-table local-write-file-hooks major-mode
-     mark-active mark-ring mode-line-buffer-identification
-     mode-line-format mode-line-modified mode-line-process mode-name
-     overwrite-mode 
-     point-before-scroll right-fringe-width right-margin-width
-     scroll-bar-width scroll-down-aggressively scroll-up-aggressively selective-display
-     selective-display-ellipses tab-width truncate-lines vc-mode vertical-scroll-bar)
-  "Standard buffer local vars.")
-
-(defconst elint-unknown-builtin-args
-  '((while test &rest forms)
-    (insert-before-markers-and-inherit &rest text)
-    (catch tag &rest body)
-    (and &rest args)
-    (funcall func &rest args)
-    (insert &rest args)
-    (vconcat &rest args)
-    (run-hook-with-args hook &rest args)
-    (message-or-box string &rest args)
-    (save-window-excursion &rest body)
-    (append &rest args)
-    (logior &rest args)
-    (progn &rest body)
-    (insert-and-inherit &rest args)
-    (message-box string &rest args)
-    (prog2 x y &rest body)
-    (prog1 first &rest body)
-    (insert-before-markers &rest args)
-    (call-process-region start end program &optional delete
-                         destination display &rest args)
-    (concat &rest args)
-    (vector &rest args)
-    (run-hook-with-args-until-success hook &rest args)
-    (track-mouse &rest body)
-    (unwind-protect bodyform &rest unwindforms)
-    (save-restriction &rest body)
-    (quote arg)
-    (make-byte-code &rest args)
-    (or &rest args)
-    (cond &rest clauses)
-    (start-process name buffer program &rest args)
-    (run-hook-with-args-until-failure hook &rest args)
-    (if cond then &rest else)
-    (apply function &rest args)
-    (format string &rest args)
-    (encode-time second minute hour day month year zone &rest args)
-    (min &rest args)
-    (logand &rest args)
-    (logxor &rest args)
-    (max &rest args)
-    (list &rest args)
-    (message string &rest args)
-    (defvar symbol init doc)
-    (call-process program &optional infile destination display &rest args)
-    (with-output-to-temp-buffer bufname &rest body)
-    (nconc &rest args)
-    (save-excursion &rest body)
-    (run-hooks &rest hooks)
-    (/ x y &rest zs)
-    (- x &rest y)
-    (+ &rest args)
-    (* &rest args)
-    (interactive &optional args))
-  "Those built-ins for which we can't find arguments.")
-
 (provide 'elint)
 
 ;;; arch-tag: b2f061e2-af84-4ddc-8e39-f5e969ac228f
diff --git a/lisp/emacs-lisp/lisp.el b/lisp/emacs-lisp/lisp.el
index 87b3fcff96c..090f793c700 100644
--- a/lisp/emacs-lisp/lisp.el
+++ b/lisp/emacs-lisp/lisp.el
@@ -73,17 +73,18 @@ move forward across N balanced expressions."
   "Set mark ARG sexps from point.
 The place mark goes is the same place \\[forward-sexp] would
 move to with the same argument.
-If this command is repeated, it marks the next ARG sexps after the ones
-already marked."
+If this command is repeated or mark is active in Transient Mark mode,
+it marks the next ARG sexps after the ones already marked."
   (interactive "P")
-  (cond ((and (eq last-command this-command) (mark t))
+  (cond ((or (and (eq last-command this-command) (mark t))
+             (and transient-mark-mode mark-active))
          (setq arg (if arg (prefix-numeric-value arg)
-                     (if (> (mark) (point)) 1 -1)))
+                     (if (< (mark) (point)) -1 1)))
          (set-mark
           (save-excursion
-           (goto-char (mark))
-           (forward-sexp arg)
-           (point))))
+            (goto-char (mark))
+            (forward-sexp arg)
+            (point))))
         (t
          (push-mark
           (save-excursion
@@ -191,9 +192,11 @@ open-parenthesis, and point ends up at the beginning of the line.
 If variable `beginning-of-defun-function' is non-nil, its value
 is called as a function to find the defun's beginning."
   (interactive "p")
-  (and (eq this-command 'beginning-of-defun)
-       (or inhibit-mark-movement (eq last-command 'beginning-of-defun)
-           (push-mark)))
+  (or inhibit-mark-movement
+      (not (eq this-command 'beginning-of-defun))
+      (eq last-command 'beginning-of-defun)
+      (and transient-mark-mode mark-active)
+      (push-mark))
   (and (beginning-of-defun-raw arg)
        (progn (beginning-of-line) t)))
 
@@ -242,9 +245,11 @@ matches the open-parenthesis that starts a defun; see function
 If variable `end-of-defun-function' is non-nil, its value
 is called as a function to find the defun's end."
   (interactive "p")
-  (and (eq this-command 'end-of-defun)
-       (or inhibit-mark-movement (eq last-command 'end-of-defun)
-           (push-mark)))
+  (or inhibit-mark-movement
+      (not (eq this-command 'end-of-defun))
+      (eq last-command 'end-of-defun)
+      (and transient-mark-mode mark-active)
+      (push-mark))
   (if (or (null arg) (= arg 0)) (setq arg 1))
   (if end-of-defun-function
       (if (> arg 0)
@@ -289,10 +294,11 @@ is called as a function to find the defun's end."
 (defun mark-defun ()
   "Put mark at end of this defun, point at beginning.
 The defun marked is the one that contains point or follows point.
-If this command is repeated, marks more defuns after the ones
-already marked."
+If this command is repeated or mark is active in Transient Mark mode,
+it marks more defuns after the ones already marked."
   (interactive)
-  (cond ((and (eq last-command this-command) (mark t))
+  (cond ((or (and (eq last-command this-command) (mark t))
+             (and transient-mark-mode mark-active))
          (set-mark
           (save-excursion
             (goto-char (mark))
diff --git a/lisp/faces.el b/lisp/faces.el
index 35a2bd71399..5a7c119899d 100644
--- a/lisp/faces.el
+++ b/lisp/faces.el
@@ -1335,21 +1335,29 @@ If SPEC is nil, return nil."
   (unless frame
     (setq frame (selected-frame)))
   (let ((tail spec)
-        result all)
+        result defaults)
     (while tail
       (let* ((entry (pop tail))
              (display (car entry))
-             (attrs (cdr entry)))
-        (when (face-spec-set-match-display display frame)
-          (setq result (if (null (cdr attrs)) ;; was (listp (car attrs))
-                           ;; Old-style entry, the attribute list is the
-                           ;; first element.
-                           (car attrs)
-                         attrs))
-          (if (eq display t)
-              (setq all result result nil)
+             (attrs (cdr entry))
+             thisval)
+        ;; Get the attributes as actually specified by this alternative.
+        (setq thisval
+              (if (null (cdr attrs)) ;; was (listp (car attrs))
+                  ;; Old-style entry, the attribute list is the
+                  ;; first element.
+                  (car attrs)
+                attrs))
+
+        ;; If the condition is `default', that sets the default
+        ;; for following conditions.
+        (if (eq display 'default)
+            (setq defaults thisval)
+          ;; Otherwise, if it matches, use it.
+          (when (face-spec-set-match-display display frame)
+            (setq result thisval)
             (setq tail nil)))))
-    (if all (append result all) result)))
+    (if defaults (append result defaults) result)))
 
 
 (defun face-spec-reset-face (face &optional frame)
@@ -1787,7 +1795,7 @@ created."
   :group 'basic-faces)
 
 (defface mode-line-inactive
-  '((t
+  '((default
      :inherit mode-line)
     (((type x w32 mac) (background light) (class color))
      :weight light
@@ -1807,7 +1815,7 @@ created."
 (put 'modeline-inactive 'face-alias 'mode-line-inactive)
 
 (defface header-line
-  '((t
+  '((default
      :inherit mode-line)
     (((type tty))
      ;; This used to be `:inverse-video t', but that doesn't look very
@@ -1843,7 +1851,7 @@ created."
 
 
 (defface tool-bar
-  '((t
+  '((default
      :box (:line-width 1 :style released-button)
      :foreground "black")
     (((type x w32 mac) (class color))
@@ -2022,32 +2030,11 @@ Note: Other faces cannot inherit from the cursor face."
   :group 'font-lock                     ; like `show-trailing-whitespace'
   :group 'basic-faces)
 
-
-;; Make escape characters stand out in display
-
-(defface escape-glyph
-  '((t :inherit secondary-selection))
-  "Basic face for displaying \\ and ^ in multichar glyphs.
-It is also used for ... in ellipses."
+(defface escape-glyph '((((background dark)) :foreground "cyan")
+                        (((type pc)) :foreground "magenta")
+                        (t :foreground "dark blue"))
+  "Face for displaying \\ and ^ in multichar glyphs."
   :group 'basic-faces)
-
-(put 'display-table 'char-table-extra-slots 6)
-
-(or standard-display-table
-    ;; avoid using autoloaded make-display-table here
-    (setq standard-display-table (make-char-table 'display-table nil)))
-
-(let* ((face (lsh (face-id 'escape-glyph) 19))
-       (backslash (+ face ?\\))
-       (dot (+ face ?.)))
-  (set-char-table-extra-slot standard-display-table 2 backslash)
-  (aset standard-display-table 2208 (vector backslash ?\s))
-  (aset standard-display-table 2221 (vector backslash ?-))
-  (set-char-table-extra-slot standard-display-table 3 (+ face ?^))
-  (set-char-table-extra-slot standard-display-table 4 (vector dot dot dot)))
-
-
-
 
 ;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;
 ;;; Manipulating font names.
diff --git a/lisp/ffap.el b/lisp/ffap.el
index dc78bd355be..ab9d223256f 100644
--- a/lisp/ffap.el
+++ b/lisp/ffap.el
@@ -42,10 +42,21 @@
 ;;
 ;; ffap-bindings makes the following global key bindings:
 ;;
-;; C-x C-f       find-file-at-point (abbreviated as ffap)
-;; C-x d         dired-at-point
-;; C-x 4 f       ffap-other-window
-;; C-x 5 f       ffap-other-frame
+;; C-x C-f              find-file-at-point (abbreviated as ffap)
+;; C-x C-r              ffap-read-only
+;; C-x C-v              ffap-alternate-file
+;;
+;; C-x d                dired-at-point
+;; C-x C-d              ffap-list-directory
+;;
+;; C-x 4 f              ffap-other-window
+;; C-x 4 r              ffap-read-only-other-window
+;; C-x 4 d              ffap-dired-other-window
+;;
+;; C-x 5 f              ffap-other-frame
+;; C-x 5 r              ffap-read-only-other-frame
+;; C-x 5 d              ffap-dired-other-frame
+;;
 ;; S-mouse-3     ffap-at-mouse
 ;; C-S-mouse-3   ffap-menu
 ;;
@@ -202,13 +213,17 @@ Sensible values are nil, \"news\", or \"mailto\"."
 ;; through this section for features that you like, put an appropriate
 ;; enabler in your .emacs file.
 
-(defcustom ffap-dired-wildcards nil
-  ;; Suggestion from RHOGEE, 07 Jul 1994.  Disabled, dired is still
-  ;; available by "C-x C-d <pattern>", and valid filenames may
-  ;; sometimes contain wildcard characters.
+(defcustom ffap-dired-wildcards "[*?][^/]*\\'"
   "*A regexp matching filename wildcard characters, or nil.
+
 If `find-file-at-point' gets a filename matching this pattern,
-it passes it on to `dired' instead of `find-file'."
+it passes it on to `find-file' with non-nil WILDCARDS argument,
+which expands wildcards and visits multiple files.  To visit
+a file whose name contains wildcard characters you can suppress
+wildcard expansion by setting `find-file-wildcards'.
+
+If `dired-at-point' gets a filename matching this pattern,
+it passes it on to `dired'."
   :type '(choice (const :tag "Disable" nil)
                  (const :tag "Enable" "[*?][^/]*\\'")
                  ;; regexp -- probably not useful
@@ -236,6 +251,12 @@ ffap most of the time."
   :group 'ffap)
 (put 'ffap-file-finder 'risky-local-variable t)
 
+(defcustom ffap-directory-finder 'dired
+  "*The command called by `dired-at-point' to find a directory."
+  :type 'function
+  :group 'ffap)
+(put 'ffap-directory-finder 'risky-local-variable t)
+
 (defcustom ffap-url-fetcher
   (if (fboundp 'browse-url)
       'browse-url                       ; rely on browse-url-browser-function
@@ -939,7 +960,7 @@ If t, `ffap-tex-init' will initialize this when needed.")
     ;; Slightly controversial decisions:
     ;; * strip trailing "@" and ":"
     ;; * no commas (good for latex)
-    (file "--:$+<>@-Z_a-z~" "<@" "@>;.,!?:")
+    (file "--:$+<>@-Z_a-z~*?" "<@" "@>;.,!:")
     ;; An url, or maybe a email/news message-id:
     (url "--:=&?$+@-Z_a-z~#,%;" "^A-Za-z0-9" ":;.,!?")
     ;; Find a string that does *not* contain a colon:
@@ -1120,8 +1141,8 @@ which may actually result in an url rather than a filename."
          (default-directory default-directory))
     (unwind-protect
         (cond
-         ;; Immediate rejects (/ and // are too common in C++):
-         ((member name '("" "/" "//" ".")) nil)
+         ;; Immediate rejects (/ and // and /* are too common in C/C++):
+         ((member name '("" "/" "//" "/*" ".")) nil)
          ;; Immediately test local filenames.  If default-directory is
          ;; remote, you probably already have a connection.
          ((and (not abs) (ffap-file-exists-string name)))
@@ -1187,6 +1208,12 @@ which may actually result in an url rather than a filename."
                          remote-dir (substring name (match-end 1)))))
                   (ffap-file-exists-string
                    (ffap-replace-file-component remote-dir name))))))
+         ((and ffap-dired-wildcards
+               (string-match ffap-dired-wildcards name)
+               abs
+               (ffap-file-exists-string (file-name-directory
+                                         (directory-file-name name)))
+               name))
          ;; Try all parent directories by deleting the trailing directory
          ;; name until existing directory is found or name stops changing
          ((let ((dir name))
@@ -1227,7 +1254,9 @@ which may actually result in an url rather than a filename."
              dir
              nil
              (if dir (cons guess (length dir)) guess)
-             (list 'file-name-history))))
+             (list 'file-name-history)
+             (and buffer-file-name
+                  (abbreviate-file-name buffer-file-name)))))
     ;; Do file substitution like (interactive "F"), suggested by MCOOK.
     (or (ffap-url-p guess) (setq guess (substitute-in-file-name guess)))
     ;; Should not do it on url's, where $ is a common (VMS?) character.
@@ -1357,10 +1386,12 @@ See <ftp://ftp.mathcs.emory.edu/pub/mic/emacs/> for latest version."
      ((ffap-url-p filename)
       (let (current-prefix-arg)         ; w3 2.3.25 bug, reported by KPC
         (funcall ffap-url-fetcher filename)))
-     ;; This junk more properly belongs in a modified ffap-file-finder:
      ((and ffap-dired-wildcards
-           (string-match ffap-dired-wildcards filename))
-      (dired filename))
+           (string-match ffap-dired-wildcards filename)
+           find-file-wildcards
+           ;; Check if it's find-file that supports wildcards arg
+           (memq ffap-file-finder '(find-file find-alternate-file)))
+      (funcall ffap-file-finder (expand-file-name filename) t))
      ((or (not ffap-newfile-prompt)
           (file-exists-p filename)
           (y-or-n-p "File does not exist, create buffer? "))
@@ -1556,9 +1587,7 @@ Return value:
      )))
 
 
-;;; ffap-other-* commands:
-;;
-;; Requested by KPC.
+;;; ffap-other-*, ffap-read-only-*, ffap-alternate-* commands:
 
 ;; There could be a real `ffap-noselect' function, but we would need
 ;; at least two new user variables, and there is no w3-fetch-noselect.
@@ -1568,23 +1597,70 @@ Return value:
   "Like `ffap', but put buffer in another window.
 Only intended for interactive use."
   (interactive)
-  (switch-to-buffer-other-window
-   (save-window-excursion (call-interactively 'ffap) (current-buffer))))
+  (let (value)
+    (switch-to-buffer-other-window
+     (save-window-excursion
+       (setq value (call-interactively 'ffap))
+       (unless (or (bufferp value) (bufferp (car-safe value)))
+         (setq value (current-buffer)))
+       (current-buffer)))
+    value))
 
 (defun ffap-other-frame nil
   "Like `ffap', but put buffer in another frame.
 Only intended for interactive use."
   (interactive)
   ;; Extra code works around dedicated windows (noted by JENS, 7/96):
-  (let* ((win (selected-window)) (wdp (window-dedicated-p win)))
+  (let* ((win (selected-window))
+         (wdp (window-dedicated-p win))
+         value)
     (unwind-protect
         (progn
           (set-window-dedicated-p win nil)
           (switch-to-buffer-other-frame
            (save-window-excursion
-             (call-interactively 'ffap)
+             (setq value (call-interactively 'ffap))
+             (unless (or (bufferp value) (bufferp (car-safe value)))
+               (setq value (current-buffer)))
              (current-buffer))))
-      (set-window-dedicated-p win wdp))))
+      (set-window-dedicated-p win wdp))
+    value))
+
+(defun ffap-read-only ()
+  "Like `ffap', but mark buffer as read-only.
+Only intended for interactive use."
+  (interactive)
+  (let ((value (call-interactively 'ffap)))
+    (unless (or (bufferp value) (bufferp (car-safe value)))
+      (setq value (current-buffer)))
+    (mapc (lambda (b) (with-current-buffer b (toggle-read-only 1)))
+          (if (listp value) value (list value)))
+    value))
+
+(defun ffap-read-only-other-window ()
+  "Like `ffap', but put buffer in another window and mark as read-only.
+Only intended for interactive use."
+  (interactive)
+  (let ((value (ffap-other-window)))
+    (mapc (lambda (b) (with-current-buffer b (toggle-read-only 1)))
+          (if (listp value) value (list value)))
+    value))
+
+(defun ffap-read-only-other-frame ()
+  "Like `ffap', but put buffer in another frame and mark as read-only.
+Only intended for interactive use."
+  (interactive)
+  (let ((value (ffap-other-frame)))
+    (mapc (lambda (b) (with-current-buffer b (toggle-read-only 1)))
+          (if (listp value) value (list value)))
+    value))
+
+(defun ffap-alternate-file ()
+  "Like `ffap' and `find-alternate-file'.
+Only intended for interactive use."
+  (interactive)
+  (let ((ffap-file-finder 'find-alternate-file))
+    (call-interactively 'ffap)))
 
 
 ;;; Bug Reporter:
@@ -1665,24 +1741,26 @@ ffap most of the time."
                (not current-prefix-arg)
              current-prefix-arg))
       (let (current-prefix-arg)         ; already interpreted
-        (call-interactively 'dired))
+        (call-interactively ffap-directory-finder))
     (or filename (setq filename (dired-at-point-prompter)))
     (cond
      ((ffap-url-p filename)
       (funcall ffap-url-fetcher filename))
      ((and ffap-dired-wildcards
            (string-match ffap-dired-wildcards filename))
-      (dired filename))
+      (funcall ffap-directory-finder filename))
      ((file-exists-p filename)
       (if (file-directory-p filename)
-          (dired (expand-file-name filename))
-        (dired (concat (expand-file-name filename) "*"))))
+          (funcall ffap-directory-finder
+                   (expand-file-name filename))
+        (funcall ffap-directory-finder
+                 (concat (expand-file-name filename) "*"))))
      ((and (file-writable-p
             (or (file-name-directory (directory-file-name filename))
                 filename))
            (y-or-n-p "Directory does not exist, create it? "))
       (make-directory filename)
-      (dired filename))
+      (funcall ffap-directory-finder filename))
      ((error "No such file or directory `%s'" filename)))))
 
 (defun dired-at-point-prompter (&optional guess)
@@ -1712,16 +1790,66 @@ ffap most of the time."
          (and guess (ffap-highlight))))
     (ffap-highlight t)))
 
+;;; ffap-dired-other-*, ffap-list-directory commands:
+
+(defun ffap-dired-other-window ()
+  "Like `dired-at-point', but put buffer in another window.
+Only intended for interactive use."
+  (interactive)
+  (let (value)
+    (switch-to-buffer-other-window
+     (save-window-excursion
+       (setq value (call-interactively 'dired-at-point))
+       (current-buffer)))
+    value))
+
+(defun ffap-dired-other-frame ()
+  "Like `dired-at-point', but put buffer in another frame.
+Only intended for interactive use."
+  (interactive)
+  ;; Extra code works around dedicated windows (noted by JENS, 7/96):
+  (let* ((win (selected-window))
+         (wdp (window-dedicated-p win))
+         value)
+    (unwind-protect
+        (progn
+          (set-window-dedicated-p win nil)
+          (switch-to-buffer-other-frame
+           (save-window-excursion
+             (setq value (call-interactively 'dired-at-point))
+             (current-buffer))))
+      (set-window-dedicated-p win wdp))
+    value))
+
+(defun ffap-list-directory ()
+  "Like `dired-at-point' and `list-directory'.
+Only intended for interactive use."
+  (interactive)
+  (let ((ffap-directory-finder 'list-directory))
+    (call-interactively 'dired-at-point)))
+
+
 ;;; Offer default global bindings (`ffap-bindings'):
 
 (defvar ffap-bindings
    '(
      (global-set-key [S-mouse-3] 'ffap-at-mouse)
      (global-set-key [C-S-mouse-3] 'ffap-menu)
+
      (global-set-key "\C-x\C-f" 'find-file-at-point)
+     (global-set-key "\C-x\C-r" 'ffap-read-only)
+     (global-set-key "\C-x\C-v" 'ffap-alternate-file)
+
      (global-set-key "\C-x4f"   'ffap-other-window)
      (global-set-key "\C-x5f"   'ffap-other-frame)
+     (global-set-key "\C-x4r"   'ffap-read-only-other-window)
+     (global-set-key "\C-x5r"   'ffap-read-only-other-frame)
+
      (global-set-key "\C-xd"    'dired-at-point)
+     (global-set-key "\C-x4d"   'ffap-dired-other-window)
+     (global-set-key "\C-x5d"   'ffap-dired-other-frame)
+     (global-set-key "\C-x\C-d" 'ffap-list-directory)
+
      (add-hook 'gnus-summary-mode-hook 'ffap-gnus-hook)
      (add-hook 'gnus-article-mode-hook 'ffap-gnus-hook)
      (add-hook 'vm-mode-hook 'ffap-ro-mode-hook)
diff --git a/lisp/filecache.el b/lisp/filecache.el
index bd0b0f77781..90287ba5eef 100644
--- a/lisp/filecache.el
+++ b/lisp/filecache.el
@@ -337,21 +337,20 @@ in each directory, not to the directory list itself."
 Find is run in DIRECTORY."
   (interactive "DAdd files under directory: ")
   (let ((dir (expand-file-name directory)))
-    (if (eq file-cache-find-command-posix-flag 'not-defined)
-        (setq file-cache-find-command-posix-flag
-              (executable-command-find-posix-p file-cache-find-command)))
+    (when (memq system-type '(windows-nt cygwin))
+      (if (eq file-cache-find-command-posix-flag 'not-defined)
+          (setq file-cache-find-command-posix-flag
+                (executable-command-find-posix-p file-cache-find-command))))
     (set-buffer (get-buffer-create file-cache-buffer))
     (erase-buffer)
     (call-process file-cache-find-command nil
                   (get-buffer file-cache-buffer) nil
                   dir "-name"
-                  (cond
-                   (file-cache-find-command-posix-flag
-                    "\\*")
-                   ((eq system-type 'windows-nt)
-                    "'*'")
-                   (t
-                    "*"))
+                  (if (memq system-type '(windows-nt cygwin))
+                      (if file-cache-find-command-posix-flag
+                          "\\*"
+                        "'*'")
+                    "*")
                   "-print")
     (file-cache-add-from-file-cache-buffer)))
 
diff --git a/lisp/files.el b/lisp/files.el
index b1cd0fbf8d0..48c7c9a7489 100644
--- a/lisp/files.el
+++ b/lisp/files.el
@@ -932,8 +932,7 @@ suppress wildcard expansion by setting `find-file-wildcards'.
 
 To visit a file without any kind of conversion and without
 automatically choosing a major mode, use \\[find-file-literally]."
-  (interactive
-   (find-file-read-args "Find file: " nil))
+  (interactive (find-file-read-args "Find file: " nil))
   (let ((value (find-file-noselect filename nil nil wildcards)))
     (if (listp value)
         (mapcar 'switch-to-buffer (nreverse value))
@@ -955,8 +954,8 @@ expand wildcards (if any) and visit multiple files."
     (if (listp value)
         (progn
           (setq value (nreverse value))
-          (switch-to-buffer-other-window (car value))
-          (mapcar 'switch-to-buffer (cdr value)))
+          (cons (switch-to-buffer-other-window (car value))
+                (mapcar 'switch-to-buffer (cdr value))))
       (switch-to-buffer-other-window value))))
 
 (defun find-file-other-frame (filename &optional wildcards)
@@ -975,8 +974,8 @@ expand wildcards (if any) and visit multiple files."
     (if (listp value)
         (progn
           (setq value (nreverse value))
-          (switch-to-buffer-other-frame (car value))
-          (mapcar 'switch-to-buffer (cdr value)))
+          (cons (switch-to-buffer-other-frame (car value))
+                (mapcar 'switch-to-buffer (cdr value))))
       (switch-to-buffer-other-frame value))))
 
 (defun find-file-existing (filename &optional wildcards)
@@ -991,35 +990,53 @@ Like \\[find-file] but only allow files that exists."
   "Edit file FILENAME but don't allow changes.
 Like \\[find-file] but marks buffer as read-only.
 Use \\[toggle-read-only] to permit editing."
-  (interactive (find-file-read-args "Find file read-only: " t))
-  (unless (file-exists-p filename) (error "%s does not exist" filename))
-  (find-file filename wildcards)
-  (toggle-read-only 1)
-  (current-buffer))
+  (interactive (find-file-read-args "Find file read-only: " nil))
+  (unless (or (and wildcards find-file-wildcards
+                   (not (string-match "\\`/:" filename))
+                   (string-match "[[*?]" filename))
+              (file-exists-p filename))
+    (error "%s does not exist" filename))
+  (let ((value (find-file filename wildcards)))
+    (mapc (lambda (b) (with-current-buffer b (toggle-read-only 1)))
+          (if (listp value) value (list value)))
+    value))
 
 (defun find-file-read-only-other-window (filename &optional wildcards)
   "Edit file FILENAME in another window but don't allow changes.
 Like \\[find-file-other-window] but marks buffer as read-only.
 Use \\[toggle-read-only] to permit editing."
-  (interactive (find-file-read-args "Find file read-only other window: " t))
-  (unless (file-exists-p filename) (error "%s does not exist" filename))
-  (find-file-other-window filename wildcards)
-  (toggle-read-only 1)
-  (current-buffer))
+  (interactive (find-file-read-args "Find file read-only other window: " nil))
+  (unless (or (and wildcards find-file-wildcards
+                   (not (string-match "\\`/:" filename))
+                   (string-match "[[*?]" filename))
+              (file-exists-p filename))
+    (error "%s does not exist" filename))
+  (let ((value (find-file-other-window filename wildcards)))
+    (mapc (lambda (b) (with-current-buffer b (toggle-read-only 1)))
+          (if (listp value) value (list value)))
+    value))
 
 (defun find-file-read-only-other-frame (filename &optional wildcards)
   "Edit file FILENAME in another frame but don't allow changes.
 Like \\[find-file-other-frame] but marks buffer as read-only.
 Use \\[toggle-read-only] to permit editing."
-  (interactive (find-file-read-args "Find file read-only other frame: " t))
-  (unless (file-exists-p filename) (error "%s does not exist" filename))
-  (find-file-other-frame filename wildcards)
-  (toggle-read-only 1)
-  (current-buffer))
-
-(defun find-alternate-file-other-window (filename)
+  (interactive (find-file-read-args "Find file read-only other frame: " nil))
+  (unless (or (and wildcards find-file-wildcards
+                   (not (string-match "\\`/:" filename))
+                   (string-match "[[*?]" filename))
+              (file-exists-p filename))
+    (error "%s does not exist" filename))
+  (let ((value (find-file-other-frame filename wildcards)))
+    (mapc (lambda (b) (with-current-buffer b (toggle-read-only 1)))
+          (if (listp value) value (list value)))
+    value))
+
+(defun find-alternate-file-other-window (filename &optional wildcards)
   "Find file FILENAME as a replacement for the file in the next window.
-This command does not select that window."
+This command does not select that window.
+
+Interactively, or if WILDCARDS is non-nil in a call from Lisp,
+expand wildcards (if any) and replace the file with multiple files."
   (interactive
    (save-selected-window
      (other-window 1)
@@ -1030,17 +1047,21 @@ This command does not select that window."
             (setq file-name (file-name-nondirectory file)
                   file-dir (file-name-directory file)))
        (list (read-file-name
-              "Find alternate file: " file-dir nil nil file-name)))))
+              "Find alternate file: " file-dir nil nil file-name)
+             t))))
   (if (one-window-p)
-      (find-file-other-window filename)
+      (find-file-other-window filename wildcards)
     (save-selected-window
       (other-window 1)
-      (find-alternate-file filename))))
+      (find-alternate-file filename wildcards))))
 
-(defun find-alternate-file (filename)
+(defun find-alternate-file (filename &optional wildcards)
   "Find file FILENAME, select its buffer, kill previous buffer.
 If the current buffer now contains an empty file that you just visited
-\(presumably by mistake), use this command to visit the file you really want."
+\(presumably by mistake), use this command to visit the file you really want.
+
+Interactively, or if WILDCARDS is non-nil in a call from Lisp,
+expand wildcards (if any) and replace the file with multiple files."
   (interactive
    (let ((file buffer-file-name)
          (file-name nil)
@@ -1049,7 +1070,8 @@ If the current buffer now contains an empty file that you just visited
           (setq file-name (file-name-nondirectory file)
                 file-dir (file-name-directory file)))
      (list (read-file-name
-            "Find alternate file: " file-dir nil nil file-name))))
+            "Find alternate file: " file-dir nil nil file-name)
+           t)))
   (unless (run-hook-with-args-until-failure 'kill-buffer-query-functions)
     (error "Aborted"))
   (when (and (buffer-modified-p) (buffer-file-name))
@@ -1077,7 +1099,7 @@ If the current buffer now contains an empty file that you just visited
           (setq buffer-file-truename nil)
           ;; Likewise for dired buffers.
           (setq dired-directory nil)
-          (find-file filename))
+          (find-file filename wildcards))
       (when (eq obuf (current-buffer))
         ;; This executes if find-file gets an error
         ;; and does not really find anything.
@@ -1247,8 +1269,8 @@ Optional first arg NOWARN non-nil means suppress any warning messages.
 Optional second arg RAWFILE non-nil means the file is read literally.
 Optional third arg WILDCARDS non-nil means do wildcard processing
 and visit all the matching files.  When wildcards are actually
-used and expanded, the value is a list of buffers
-that are visiting the various files."
+used and expanded, return a list of buffers that are visiting
+the various files."
   (setq filename
         (abbreviate-file-name
          (expand-file-name filename)))
@@ -1757,6 +1779,7 @@ in that case, this function acts as if `enable-local-variables' were t."
      ("\\.ses\\'" . ses-mode)
      ("\\.\\(soa\\|zone\\)\\'" . dns-mode)
      ("\\.docbook\\'" . sgml-mode)
+     ("\\.com\\'" . dcl-mode)
      ("/config\\.\\(?:bat\\|log\\)\\'" . fundamental-mode)
      ;; Windows candidates may be opened case sensitively on Unix
      ("\\.\\(?:[iI][nN][iI]\\|[lL][sS][tT]\\|[rR][eE][gG]\\|[sS][yY][sS]\\)\\'" . conf-mode)
diff --git a/lisp/gnus/ChangeLog b/lisp/gnus/ChangeLog
index 2b83229010d..518a9903085 100644
--- a/lisp/gnus/ChangeLog
+++ b/lisp/gnus/ChangeLog
@@ -1,8 +1,20 @@
+2004-12-08  Stefan Monnier  <monnier@iro.umontreal.ca>
+
+        * gnus-art.el (gnus-narrow-to-page): Don't hardcode point-min.
+
+2004-12-13  Katsumi Yamaoka  <yamaoka@jpl.org>
+
+        * gnus-group.el (gnus-group-make-rss-group): Use
+        gnus-group-make-group instead of gnus-group-unsubscribe-group.
+
+        * gnus-start.el (gnus-setup-news): Honor user's setting to
+        gnus-message-archive-method.  Suggested by Lute Kamstra
+        <Lute.Kamstra@xs4all.nl>.
+
 2004-12-02  Katsumi Yamaoka  <yamaoka@jpl.org>
 
         * message.el (message-forward-make-body-mml): Remove headers
-        according to message-forward-ignored-headers if a message is
-        decoded.
+        according to message-forward-ignored-headers if a message is decoded.
 
 2004-12-02  Romain Francoise  <romain@orebokech.com>
 
@@ -60,17 +72,16 @@
 
 2004-11-25  Reiner Steib  <Reiner.Steib@gmx.de>
 
-        * message.el (message-forbidden-properties): Fixed typo in doc
-        string.
+        * message.el (message-forbidden-properties): Fix typo in doc string.
 
 2004-11-25  Lars Magne Ingebrigtsen  <larsi@gnus.org>
 
-        * message.el (message-strip-forbidden-properties): Bind
-        buffer-read-only (etc) to nil.
+        * message.el (message-strip-forbidden-properties):
+        Bind buffer-read-only (etc) to nil.
 
 2004-11-25  Reiner Steib  <Reiner.Steib@gmx.de>
 
-        * gnus-util.el (gnus-replace-in-string): Added doc string.
+        * gnus-util.el (gnus-replace-in-string): Add doc string.
 
         * nnmail.el (nnmail-split-header-length-limit): Increase to 2048
         to avoid problems when splitting mails with many recipients.
@@ -97,8 +108,8 @@
 
 2004-11-14  Reiner Steib  <Reiner.Steib@gmx.de>
 
-        * gnus-start.el (gnus-convert-old-newsrc): Assign
-        legacy-gnus-agent to 5.10.7.
+        * gnus-start.el (gnus-convert-old-newsrc):
+        Assign legacy-gnus-agent to 5.10.7.
 
 2004-11-10  Katsumi Yamaoka  <yamaoka@jpl.org>
 
diff --git a/lisp/gnus/gnus-art.el b/lisp/gnus/gnus-art.el
index f6286c7de87..7450fee69ee 100644
--- a/lisp/gnus/gnus-art.el
+++ b/lisp/gnus/gnus-art.el
@@ -5066,7 +5066,7 @@ If given a numerical ARG, move forward ARG pages."
           (goto-char (point-min))
           (gnus-insert-prev-page-button)))
       (when (and (gnus-visual-p 'page-marker)
-                 (< (+ (point-max) 2) (buffer-size)))
+                 (< (point-max) (save-restriction (widen) (point-max))))
         (save-excursion
           (goto-char (point-max))
           (gnus-insert-next-page-button))))))
diff --git a/lisp/gnus/gnus-group.el b/lisp/gnus/gnus-group.el
index c55264b22de..b7d0cf9eef4 100644
--- a/lisp/gnus/gnus-group.el
+++ b/lisp/gnus/gnus-group.el
@@ -2592,8 +2592,7 @@ If there is, use Gnus to create an nnrss group"
               (href (cdr (assoc 'href feedinfo))))
           (push (list title href desc)
                 nnrss-group-alist)
-          (gnus-group-unsubscribe-group
-           (concat "nnrss:" title))
+          (gnus-group-make-group title '(nnrss ""))
           (nnrss-save-server-data nil))
       (error "No feeds found for %s" url))))
 
diff --git a/lisp/gnus/gnus-start.el b/lisp/gnus/gnus-start.el
index ddf00a37ee1..c1c79033267 100644
--- a/lisp/gnus/gnus-start.el
+++ b/lisp/gnus/gnus-start.el
@@ -954,16 +954,28 @@ If LEVEL is non-nil, the news will be set up at level LEVEL."
     ;; Make sure the archive server is available to all and sundry.
     (when gnus-message-archive-method
       (unless (assoc "archive" gnus-server-alist)
-        (push `("archive"
-                nnfolder
-                "archive"
-                (nnfolder-directory
-                 ,(nnheader-concat message-directory "archive"))
-                (nnfolder-active-file
-                 ,(nnheader-concat message-directory "archive/active"))
-                (nnfolder-get-new-mail nil)
-                (nnfolder-inhibit-expiry t))
-              gnus-server-alist)))
+        (let ((method (or (and (stringp gnus-message-archive-method)
+                               (gnus-server-to-method
+                                gnus-message-archive-method))
+                          gnus-message-archive-method)))
+          ;; Check whether the archive method is writable.
+          (unless (or (stringp method)
+                      (memq 'respool (assoc (format "%s" (car method))
+                                            gnus-valid-select-methods)))
+            (setq method "archive")) ;; The default.
+          (push (if (stringp method)
+                    `("archive"
+                      nnfolder
+                      ,method
+                      (nnfolder-directory
+                       ,(nnheader-concat message-directory method))
+                      (nnfolder-active-file
+                       ,(nnheader-concat message-directory
+                                         (concat method "/active")))
+                      (nnfolder-get-new-mail nil)
+                      (nnfolder-inhibit-expiry t))
+                  (cons "archive" method))
+                gnus-server-alist))))
 
     ;; If we don't read the complete active file, we fill in the
     ;; hashtb here.
diff --git a/lisp/info.el b/lisp/info.el
index ef4225e5a3e..750f302d422 100644
--- a/lisp/info.el
+++ b/lisp/info.el
@@ -86,7 +86,7 @@ The Lisp code is executed when the node is selected.")
   :group 'info)
 
 (defface info-xref-visited
-  '((t :inherit info-xref)
+  '((default :inherit info-xref)
     (((class color) (background light)) :foreground "magenta4")
     (((class color) (background dark)) :foreground "magenta3")) ;"violet"?
   "Face for visited Info cross-references."
@@ -2834,8 +2834,7 @@ if point is in a menu item description, follow that menu item."
   "Follow a node reference near point.  Return non-nil if successful."
   (let (node)
     (cond
-     ((and (Info-get-token (point) "[hf]t?tp://" "[hf]t?tp://\\([^ \t\n\"`({<>})']+\\)")
-           (or (featurep 'browse-url) (require 'browse-url nil t)))
+     ((Info-get-token (point) "[hf]t?tp://" "[hf]t?tp://\\([^ \t\n\"`({<>})']+\\)")
       (setq node t)
       (browse-url (browse-url-url-at-point)))
      ((setq node (Info-get-token (point) "\\*note[ \n\t]+"
diff --git a/lisp/international/isearch-x.el b/lisp/international/isearch-x.el
index 60736277b97..aad6b6e745e 100644
--- a/lisp/international/isearch-x.el
+++ b/lisp/international/isearch-x.el
@@ -97,7 +97,7 @@
 (defun isearch-process-search-multibyte-characters (last-char)
   (if (eq this-command 'isearch-printing-char)
       (let ((overriding-terminal-local-map nil)
-            (prompt (concat (isearch-message-prefix) isearch-message))
+            (prompt (concat (isearch-message-prefix)))
             (minibuffer-local-map isearch-minibuffer-local-map)
             str)
         (if isearch-input-method-function
@@ -107,11 +107,12 @@
                     (cons 'with-input-method
                           (cons last-char unread-command-events))
                     ;; Inherit current-input-method in a minibuffer.
-                    str (read-string prompt nil nil nil t))
+                    str (read-string prompt isearch-message nil nil t))
               (if (not str)
                   ;; All inputs were deleted while the input method
                   ;; was working.
                   (setq str "")
+                (setq str (substring str (length isearch-message)))
                 (if (and (= (length str) 1)
                          (= (aref str 0) last-char)
                          (>= last-char 128))
diff --git a/lisp/isearch.el b/lisp/isearch.el
index e8bb47509be..b15a8f5affe 100644
--- a/lisp/isearch.el
+++ b/lisp/isearch.el
@@ -258,6 +258,7 @@ Default value, nil, means edit the string instead."
     (define-key map "\r" 'isearch-exit)
     (define-key map "\C-j" 'isearch-printing-char)
     (define-key map "\t" 'isearch-printing-char)
+    (define-key map [?\S-\ ] 'isearch-printing-char)
 
     (define-key map    "\C-w" 'isearch-yank-word-or-char)
     (define-key map "\M-\C-w" 'isearch-del-char)
@@ -938,7 +939,7 @@ If first char entered is \\[isearch-yank-word-or-char], then do word search inst
                          (isearch-message-prefix nil nil isearch-nonincremental)
                          isearch-string
                          minibuffer-local-isearch-map nil
-                         'junk-ring))
+                         'junk-ring nil t))
                       isearch-new-message
                       (mapconcat 'isearch-text-char-description
                                  isearch-new-string "")))
@@ -2381,59 +2382,64 @@ Attempt to do the search exactly the way the pending isearch would."
   (let ((max isearch-lazy-highlight-max-at-a-time)
         (looping t)
         nomore)
-    (save-excursion
-      (save-match-data
-        (goto-char (if isearch-forward
-                       isearch-lazy-highlight-end
-                     isearch-lazy-highlight-start))
-        (while looping
-          (let ((found (isearch-lazy-highlight-search)))
-            (when max
-              (setq max (1- max))
-              (if (<= max 0)
-                  (setq looping nil)))
-            (if found
-                (let ((mb (match-beginning 0))
-                      (me (match-end 0)))
-                  (if (= mb me)      ;zero-length match
+    (with-local-quit
+      (save-selected-window
+        (if (and (window-live-p isearch-lazy-highlight-window)
+                 (not (eq (selected-window) isearch-lazy-highlight-window)))
+            (select-window isearch-lazy-highlight-window))
+        (save-excursion
+          (save-match-data
+            (goto-char (if isearch-forward
+                           isearch-lazy-highlight-end
+                         isearch-lazy-highlight-start))
+            (while looping
+              (let ((found (isearch-lazy-highlight-search)))
+                (when max
+                  (setq max (1- max))
+                  (if (<= max 0)
+                      (setq looping nil)))
+                (if found
+                    (let ((mb (match-beginning 0))
+                          (me (match-end 0)))
+                      (if (= mb me)     ;zero-length match
+                          (if isearch-forward
+                              (if (= mb (if isearch-lazy-highlight-wrapped
+                                            isearch-lazy-highlight-start
+                                          (window-end)))
+                                  (setq found nil)
+                                (forward-char 1))
+                            (if (= mb (if isearch-lazy-highlight-wrapped
+                                          isearch-lazy-highlight-end
+                                        (window-start)))
+                                (setq found nil)
+                              (forward-char -1)))
+
+                        ;; non-zero-length match
+                        (let ((ov (make-overlay mb me)))
+                          (push ov isearch-lazy-highlight-overlays)
+                          (overlay-put ov 'face isearch-lazy-highlight-face)
+                          (overlay-put ov 'priority 0) ;lower than main overlay
+                          (overlay-put ov 'window (selected-window))))
+                      (if isearch-forward
+                          (setq isearch-lazy-highlight-end (point))
+                        (setq isearch-lazy-highlight-start (point)))))
+
+                ;; not found or zero-length match at the search bound
+                (if (not found)
+                    (if isearch-lazy-highlight-wrapped
+                        (setq looping nil
+                              nomore  t)
+                      (setq isearch-lazy-highlight-wrapped t)
                       (if isearch-forward
-                          (if (= mb (if isearch-lazy-highlight-wrapped
-                                        isearch-lazy-highlight-start
-                                      (window-end)))
-                              (setq found nil)
-                            (forward-char 1))
-                        (if (= mb (if isearch-lazy-highlight-wrapped
-                                      isearch-lazy-highlight-end
-                                    (window-start)))
-                            (setq found nil)
-                          (forward-char -1)))
-
-                    ;; non-zero-length match
-                    (let ((ov (make-overlay mb me)))
-                      (overlay-put ov 'face isearch-lazy-highlight-face)
-                      (overlay-put ov 'priority 0) ;lower than main overlay
-                      (overlay-put ov 'window (selected-window))
-                      (push ov isearch-lazy-highlight-overlays)))
-                  (if isearch-forward
-                      (setq isearch-lazy-highlight-end (point))
-                    (setq isearch-lazy-highlight-start (point)))))
-
-            ;; not found or zero-length match at the search bound
-            (if (not found)
-                (if isearch-lazy-highlight-wrapped
-                    (setq looping nil
-                          nomore  t)
-                  (setq isearch-lazy-highlight-wrapped t)
-                  (if isearch-forward
-                      (progn
-                        (setq isearch-lazy-highlight-end (window-start))
-                        (goto-char (window-start)))
-                    (setq isearch-lazy-highlight-start (window-end))
-                    (goto-char (window-end)))))))
-        (unless nomore
-          (setq isearch-lazy-highlight-timer
-                (run-at-time isearch-lazy-highlight-interval nil
-                             'isearch-lazy-highlight-update)))))))
+                          (progn
+                            (setq isearch-lazy-highlight-end (window-start))
+                            (goto-char (window-start)))
+                        (setq isearch-lazy-highlight-start (window-end))
+                        (goto-char (window-end)))))))
+            (unless nomore
+              (setq isearch-lazy-highlight-timer
+                    (run-at-time isearch-lazy-highlight-interval nil
+                                 'isearch-lazy-highlight-update)))))))))
 
 (defun isearch-resume (search regexp word forward message case-fold)
   "Resume an incremental search.
diff --git a/lisp/mail/supercite.el b/lisp/mail/supercite.el
index c1f4b6f0170..06282c430f0 100644
--- a/lisp/mail/supercite.el
+++ b/lisp/mail/supercite.el
@@ -146,8 +146,9 @@ Each element of this list has the following form:
              (...)))
 
 Where INFOKEY is a key for `sc-mail-field', REGEXP is a regular
-expression to match against the INFOKEY's value.  FRAME is a citation
-frame, or a variable containing a citation frame."
+expression to match against the INFOKEY's value.  FRAME is
+a citation frame, or a symbol that represents the name of
+a variable whose value is a citation frame."
   :type '(repeat (list symbol (repeat (cons regexp
                                             (choice (repeat (repeat sexp))
                                                     symbol)))))
@@ -1434,12 +1435,11 @@ When called interactively, the optional arg INTERACTIVE is non-nil,
 and that means call `sc-select-attribution' too."
   (interactive "r\nP\np")
   (undo-boundary)
-  (let ((frame (or (sc-scan-info-alist
-                    (if (symbolp sc-cite-frame-alist)
-                        (symbol-value sc-cite-frame-alist)
-                      sc-cite-frame-alist))
-                   sc-default-cite-frame))
+  (let ((frame (sc-scan-info-alist sc-cite-frame-alist))
         (sc-confirm-always-p (if confirm-p t sc-confirm-always-p)))
+    (if (and frame (symbolp frame))
+        (setq frame (symbol-value frame)))
+    (or frame (setq frame sc-default-cite-frame))
     (run-hooks 'sc-pre-cite-hook)
     (if interactive
         (sc-select-attribution))
@@ -1450,11 +1450,10 @@ and that means call `sc-select-attribution' too."
 First runs `sc-pre-uncite-hook'."
   (interactive "r")
   (undo-boundary)
-  (let ((frame (or (sc-scan-info-alist
-                    (if (symbolp sc-uncite-frame-alist)
-                        (symbol-value sc-uncite-frame-alist)
-                      sc-uncite-frame-alist))
-                   sc-default-uncite-frame)))
+  (let ((frame (sc-scan-info-alist sc-uncite-frame-alist)))
+    (if (and frame (symbolp frame))
+        (setq frame (symbol-value frame)))
+    (or frame (setq frame sc-default-uncite-frame))
     (run-hooks 'sc-pre-uncite-hook)
     (regi-interpret frame start end)))
 
@@ -1465,11 +1464,10 @@ First runs `sc-pre-recite-hook'."
   (let ((sc-confirm-always-p t))
     (sc-select-attribution))
   (undo-boundary)
-  (let ((frame (or (sc-scan-info-alist
-                    (if (symbolp sc-recite-frame-alist)
-                        (symbol-value sc-recite-frame-alist)
-                      sc-recite-frame-alist))
-                   sc-default-recite-frame)))
+  (let ((frame (sc-scan-info-alist sc-recite-frame-alist)))
+    (if (and frame (symbolp frame))
+        (setq frame (symbol-value frame)))
+    (or frame (setq frame sc-default-recite-frame))
     (run-hooks 'sc-pre-recite-hook)
     (regi-interpret frame start end)))
 
diff --git a/lisp/net/browse-url.el b/lisp/net/browse-url.el
index 098f2988f1b..6e679876eef 100644
--- a/lisp/net/browse-url.el
+++ b/lisp/net/browse-url.el
@@ -575,6 +575,7 @@ down (this *won't* always work)."
 ;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;
 ;; URL input
 
+;;;###autoload
 (defun browse-url-url-at-point ()
   (let ((url (thing-at-point 'url)))
     (set-text-properties 0 (length url) nil url)
diff --git a/lisp/play/zone.el b/lisp/play/zone.el
index abe9657a9d8..e073e343f02 100644
--- a/lisp/play/zone.el
+++ b/lisp/play/zone.el
@@ -75,6 +75,7 @@ If nil, don't interrupt for about 1^26 seconds.")
                        zone-pgm-paragraph-spaz
                        zone-pgm-stress
                        zone-pgm-stress-destress
+                       zone-pgm-random-life
                        ])
 
 (defmacro zone-orig (&rest body)
@@ -459,6 +460,26 @@ If the element is a function or a list of a function and a number,
       (sit-for wait))
     (delete-char -1) (insert c-string)))
 
+(defun zone-fill-out-screen (width height)
+  (save-excursion
+    (goto-char (point-min))
+    ;; fill out rectangular ws block
+    (while (not (eobp))
+      (end-of-line)
+      (let ((cc (current-column)))
+        (if (< cc width)
+            (insert (make-string (- width cc) 32))
+          (delete-char (- width cc))))
+      (unless (eobp)
+        (forward-char 1)))
+    ;; pad ws past bottom of screen
+    (let ((nl (- height (count-lines (point-min) (point)))))
+      (when (> nl 0)
+        (let ((line (concat (make-string (1- width) ? ) "\n")))
+          (do ((i 0 (1+ i)))
+              ((= i nl))
+            (insert line)))))))
+
 (defun zone-fall-through-ws (c col wend)
   (let ((fall-p nil)                    ; todo: move outward
         (wait 0.15)
@@ -486,27 +507,9 @@ If the element is a function or a list of a function and a number,
          (mc 0)                         ; miss count
          (total (* ww wh))
          (fall-p nil))
-    (goto-char (point-min))
-    ;; fill out rectangular ws block
-    (while (not (eobp))
-      (end-of-line)
-      (let ((cc (current-column)))
-        (if (< cc ww)
-            (insert (make-string (- ww cc) ? ))
-          (delete-char (- ww cc))))
-      (unless (eobp)
-        (forward-char 1)))
-    ;; pad ws past bottom of screen
-    (let ((nl (- wh (count-lines (point-min) (point)))))
-      (when (> nl 0)
-        (let ((line (concat (make-string (1- ww) ? ) "\n")))
-          (do ((i 0 (1+ i)))
-              ((= i nl))
-            (insert line)))))
+    (zone-fill-out-screen ww wh)
     (catch 'done
       (while (not (input-pending-p))
-        (goto-char (point-min))
-        (sit-for 0)
         (let ((wbeg (window-start))
               (wend (window-end)))
           (setq mc 0)
@@ -552,7 +555,9 @@ If the element is a function or a list of a function and a number,
 ;;;; zone-pgm-paragraph-spaz
 
 (defun zone-pgm-paragraph-spaz ()
-  (if (memq (zone-orig major-mode) '(text-mode fundamental-mode))
+  (if (memq (zone-orig major-mode)
+            ;; there should be a better way to distinguish textish modes
+            '(text-mode texinfo-mode fundamental-mode))
       (let ((fill-column fill-column)
             (fc-min fill-column)
             (fc-max fill-column)
@@ -570,7 +575,7 @@ If the element is a function or a list of a function and a number,
     (zone-pgm-rotate)))
 
 
-;;;; zone-pgm-stress
+;;;; stressing and destressing
 
 (defun zone-pgm-stress ()
   (goto-char (point-min))
@@ -596,9 +601,6 @@ If the element is a function or a list of a function and a number,
        (message (concat (make-string (random (- (frame-width) 5)) ? ) "grrr"))
        (sit-for 0.1)))))
 
-
-;;;; zone-pgm-stress-destress
-
 (defun zone-pgm-stress-destress ()
   (zone-call 'zone-pgm-stress 25)
   (zone-hiding-modeline
@@ -617,6 +619,59 @@ If the element is a function or a list of a function and a number,
                 zone-pgm-drip))))
 
 
+;;;; the lyfe so short the craft so long to lerne --chaucer
+
+(defvar zone-pgm-random-life-wait nil
+  "*Seconds to wait between successive `life' generations.
+If nil, `zone-pgm-random-life' chooses a value from 0-3 (inclusive).")
+
+(defun zone-pgm-random-life ()
+  (require 'life)
+  (zone-fill-out-screen (1- (window-width)) (1- (window-height)))
+  (let ((top (progn (goto-char (window-start)) (forward-line 7) (point)))
+        (bot (progn (goto-char (window-end)) (forward-line -7) (point)))
+        (rtc (- (frame-width) 11))
+        (min (window-start))
+        (max (1- (window-end)))
+        c col)
+    (delete-region max (point-max))
+    (while (progn (goto-char (+ min (random max)))
+                  (and (sit-for 0.005)
+                       (or (progn (skip-chars-forward " @\n" max)
+                                  (not (= max (point))))
+                           (unless (or (= 0 (skip-chars-backward " @\n" min))
+                                       (= min (point)))
+                             (forward-char -1)
+                             t))))
+      (setq c (char-after))
+      (unless (or (not c) (= ?\n c))
+        (forward-char 1)
+        (insert-and-inherit             ; keep colors
+         (cond ((or (> top (point))
+                    (< bot (point))
+                    (or (> 11 (setq col (current-column)))
+                        (< rtc col)))
+                32)
+               ((and (<= ?a c) (>= ?z c)) (+ c (- ?A ?a)))
+               ((and (<= ?A c) (>= ?Z c)) ?*)
+               (t ?@)))
+        (forward-char -1)
+        (delete-char -1)))
+    (sit-for 3)
+    (setq col nil)
+    (goto-char bot)
+    (while (< top (point))
+      (setq c (point))
+      (move-to-column 9)
+      (setq col (cons (buffer-substring (point) c) col))
+      (end-of-line 0)
+      (forward-char -10))
+    (let ((life-patterns (vector (cons (make-string (length (car col)) 32)
+                                       col))))
+      (life (or zone-pgm-random-life-wait (random 4)))
+      (kill-buffer nil))))
+
+
 ;;;;;;;;;;;;;;;
 (provide 'zone)
 
diff --git a/lisp/progmodes/idlw-shell.el b/lisp/progmodes/idlw-shell.el
index eaa6f3be4ea..44675470b67 100644
--- a/lisp/progmodes/idlw-shell.el
+++ b/lisp/progmodes/idlw-shell.el
@@ -841,6 +841,8 @@ IDL has currently stepped.")
 (defvar idlwave-shell-sources-query)
 (defvar idlwave-shell-mode-map)
 (defvar idlwave-shell-calling-stack-index)
+(defvar idlwave-shell-only-prompt-pattern nil)
+(defvar tool-bar-map)
 
 (defun idlwave-shell-mode ()
   "Major mode for interacting with an inferior IDL process.
@@ -994,7 +996,7 @@ IDL has currently stepped.")
   (setq idlwave-shell-hide-output nil)
 
   ;; NB: `make-local-hook' needed for older/alternative Emacs compatibility
-  (make-local-hook 'kill-buffer-hook)
+  ;;(make-local-hook 'kill-buffer-hook)
   (add-hook 'kill-buffer-hook 'idlwave-shell-kill-shell-buffer-confirm
             nil 'local)
   (add-hook 'kill-buffer-hook 'idlwave-shell-delete-temp-files nil 'local)
@@ -1038,7 +1040,7 @@ IDL has currently stepped.")
   (setq abbrev-mode t)
 
   ;; NB: `make-local-hook' needed for older/alternative Emacs compatibility
-  (make-local-hook 'post-command-hook)
+  ;;(make-local-hook 'post-command-hook)
   (add-hook 'post-command-hook 'idlwave-command-hook nil t)
 
   ;; Read the command history?
@@ -1458,7 +1460,6 @@ Otherwise just move the line.  Move down unless UP is non-nil."
   "Return t if the shell process is running."
   (eq (process-status idlwave-shell-process-name) 'run))
 
-(defvar idlwave-shell-only-prompt-pattern nil)
 (defun idlwave-shell-filter-hidden-output (output)
   "Filter hidden output, leaving the good stuff.
 
@@ -1475,6 +1476,7 @@ error messages, etc."
 
 (defvar idlwave-shell-hidden-output-buffer " *idlwave-shell-hidden-output*"
   "Buffer containing hidden output from IDL commands.")
+(defvar idlwave-shell-current-state nil)
   
 (defun idlwave-shell-filter (proc string)
   "Watch for IDL prompt and filter incoming text.
@@ -1627,7 +1629,55 @@ and then calls `idlwave-shell-send-command' for any pending commands."
           (run-hooks 'idlwave-shell-sentinel-hook))
       (run-hooks 'idlwave-shell-sentinel-hook))))
 
-(defvar idlwave-shell-current-state nil)
+(defvar idlwave-shell-error-buffer " *idlwave-shell-errors*"
+  "Buffer containing syntax errors from IDL compilations.")
+
+;; FIXME: the following two variables do not currently allow line breaks
+;; in module and file names.  I am not sure if it will be necessary to
+;; change this.  Currently it seems to work the way it is.
+(defvar idlwave-shell-syntax-error
+  "^% Syntax error.\\s-*\n\\s-*At:\\s-*\\(.*\\),\\s-*Line\\s-*\\(.*\\)" 
+  "A regular expression to match an IDL syntax error.  
+The 1st pair matches the file name, the second pair matches the line
+number.")
+
+(defvar idlwave-shell-other-error
+  "^% .*\n\\s-*At:\\s-*\\(.*\\),\\s-*Line\\s-*\\(.*\\)"
+  "A regular expression to match any IDL error.")
+
+(defvar idlwave-shell-halting-error 
+  "^% .*\n\\([^%].*\n\\)*% Execution halted at:\\(\\s-*\\S-+\\s-*[0-9]+\\s-*.*\\)\n"
+  "A regular expression to match errors which halt execution.")
+
+(defvar idlwave-shell-cant-continue-error 
+  "^% Can't continue from this point.\n"
+  "A regular expression to match errors stepping errors.")
+
+(defvar idlwave-shell-file-line-message
+  (concat 
+   "\\("                                 ; program name group (1)
+   "\\$MAIN\\$\\|"                       ; main level routine
+   "\\<[a-zA-Z][a-zA-Z0-9_$:]*"          ; start with a letter followed by [..]
+   "\\([ \t]*\n[ \t]*[a-zA-Z0-9_$:]+\\)*"; continuation lines program name (2)
+   "\\)"                                 ; end program name group (1)
+   "[ \t\n]+"                            ; white space
+   "\\("                                 ; line number group (3)
+   "[0-9]+"                              ; the line number (the fix point)
+   "\\([ \t]*\n[ \t]*[0-9]+\\)*"         ; continuation lines number (4)
+   "\\)"                                 ; end line number group (3)
+   "[ \t\n]+"                            ; white space
+   "\\("                                 ; file name group (5)
+   "[^ \t\n]+"                           ; file names can contain any non-white
+   "\\([ \t]*\n[ \t]*[^ \t\n]+\\)*"      ; continuation lines file name (6)
+   "\\)"                                 ; end line number group (5)
+   )
+  "*A regular expression to parse out the file name and line number.
+The 1st group should match the subroutine name.  
+The 3rd group is the line number.
+The 5th group is the file name.
+All parts may contain linebreaks surrounded by spaces.  This is important
+in IDL5 which inserts random linebreaks in long module and file names.")
+
 (defun idlwave-shell-scan-for-state ()
   "Scan for state info.  Looks for messages in output from last IDL
 command indicating where IDL has stopped. The types of messages we are
@@ -1721,55 +1771,6 @@ the above."
      ;; Otherwise, no particular state
      (t (setq idlwave-shell-current-state nil)))))
 
-(defvar idlwave-shell-error-buffer " *idlwave-shell-errors*"
-  "Buffer containing syntax errors from IDL compilations.")
-
-;; FIXME: the following two variables do not currently allow line breaks
-;; in module and file names.  I am not sure if it will be necessary to
-;; change this.  Currently it seems to work the way it is.
-(defvar idlwave-shell-syntax-error
-  "^% Syntax error.\\s-*\n\\s-*At:\\s-*\\(.*\\),\\s-*Line\\s-*\\(.*\\)" 
-  "A regular expression to match an IDL syntax error.  
-The 1st pair matches the file name, the second pair matches the line
-number.")
-
-(defvar idlwave-shell-other-error
-  "^% .*\n\\s-*At:\\s-*\\(.*\\),\\s-*Line\\s-*\\(.*\\)"
-  "A regular expression to match any IDL error.")
-
-(defvar idlwave-shell-halting-error 
-  "^% .*\n\\([^%].*\n\\)*% Execution halted at:\\(\\s-*\\S-+\\s-*[0-9]+\\s-*.*\\)\n"
-  "A regular expression to match errors which halt execution.")
-
-(defvar idlwave-shell-cant-continue-error 
-  "^% Can't continue from this point.\n"
-  "A regular expression to match errors stepping errors.")
-
-(defvar idlwave-shell-file-line-message
-  (concat 
-   "\\("                                 ; program name group (1)
-   "\\$MAIN\\$\\|"                       ; main level routine
-   "\\<[a-zA-Z][a-zA-Z0-9_$:]*"          ; start with a letter followed by [..]
-   "\\([ \t]*\n[ \t]*[a-zA-Z0-9_$:]+\\)*"; continuation lines program name (2)
-   "\\)"                                 ; end program name group (1)
-   "[ \t\n]+"                            ; white space
-   "\\("                                 ; line number group (3)
-   "[0-9]+"                              ; the line number (the fix point)
-   "\\([ \t]*\n[ \t]*[0-9]+\\)*"         ; continuation lines number (4)
-   "\\)"                                 ; end line number group (3)
-   "[ \t\n]+"                            ; white space
-   "\\("                                 ; file name group (5)
-   "[^ \t\n]+"                           ; file names can contain any non-white
-   "\\([ \t]*\n[ \t]*[^ \t\n]+\\)*"      ; continuation lines file name (6)
-   "\\)"                                 ; end line number group (5)
-   )
-  "*A regular expression to parse out the file name and line number.
-The 1st group should match the subroutine name.  
-The 3rd group is the line number.
-The 5th group is the file name.
-All parts may contain linebreaks surrounded by spaces.  This is important
-in IDL5 which inserts random linebreaks in long module and file names.")
-
 (defun idlwave-shell-parse-line (string &optional skip-main)
   "Parse IDL message for the subroutine, file name and line number.
 We need to work hard here to remove the stupid line breaks inserted by
@@ -2102,8 +2103,8 @@ Change the default directory for the process buffer to concur."
        'hide 'wait)
       ;; If we don't know anything about the class, update shell routines
       (if (and idlwave-shell-get-object-class
-               (not (assoc-ignore-case idlwave-shell-get-object-class
-                                       (idlwave-class-alist))))
+               (not (assoc-string idlwave-shell-get-object-class
+                                  (idlwave-class-alist) t)))
           (idlwave-shell-maybe-update-routine-info))
       idlwave-shell-get-object-class)))
 
@@ -2165,9 +2166,10 @@ keywords."
       (idlwave-complete arg)))))
 
 ;; Get rid of opaque dynamic variable passing of link?
+(defvar link) ;dynamic variable
 (defun idlwave-shell-complete-execcomm-help (mode word)
   (let ((word (or (nth 1 idlwave-completion-help-info) word))
-        (entry (assoc-ignore-case word idlwave-executive-commands-alist)))
+        (entry (assoc-string word idlwave-executive-commands-alist t)))
     (cond
      ((eq mode 'test)
       (and (stringp word) entry (cdr entry)))
@@ -2217,6 +2219,7 @@ args of an executive .run, .rnew or .compile."
     (looking-at "\\$")))
 
 ;; Debugging Commands ------------------------------------------------------
+(defvar idlwave-shell-electric-debug-mode) ; defined by easy-mmode
 
 (defun idlwave-shell-redisplay (&optional hide)
   "Tries to resync the display with where execution has stopped.
@@ -3517,6 +3520,7 @@ considered the new breakpoint if the file name of frame matches."
 
 (defvar idlwave-shell-bp-overlays nil
   "Alist of overlays marking breakpoints")
+(defvar idlwave-shell-bp-glyph)
 
 (defun idlwave-shell-update-bp-overlays ()
   "Update the overlays which mark breakpoints in the source code.
@@ -3605,7 +3609,6 @@ Existing overlays are recycled, in order to minimize consumption."
                   (set-window-buffer win buf))))))))
 
 
-(defvar idlwave-shell-bp-glyph)
 (defun idlwave-shell-make-new-bp-overlay (&optional type disabled help)
   "Make a new overlay for highlighting breakpoints.  
 
@@ -4026,7 +4029,7 @@ Otherwise, just expand the file name."
                    '(alt))))
        (shift (memq 'shift mod))
        (mod-noshift (delete 'shift (copy-sequence mod)))
-       s k1 c2 k2 cmd cannotshift)
+       s k1 c2 k2 cmd electric only-buffer cannotshift)
   (while (setq s (pop specs))
     (setq k1  (nth 0 s)
           c2  (nth 1 s)
@@ -4089,6 +4092,9 @@ Otherwise, just expand the file name."
     (setq idlwave-shell-suppress-electric-debug nil))
   (idlwave-shell-electric-debug-mode))
 
+(defvar idlwave-shell-electric-debug-read-only) 
+(defvar idlwave-shell-electric-debug-buffers nil)
+
 (easy-mmode-define-minor-mode idlwave-shell-electric-debug-mode
   "Toggle Electric Debug mode.
 With no argument, this command toggles the mode. 
@@ -4138,7 +4144,6 @@ idlwave-shell-electric-debug-mode-map)
   (force-mode-line-update))
 
 ;; Turn it off in all relevant buffers
-(defvar idlwave-shell-electric-debug-buffers nil)
 (defun idlwave-shell-electric-debug-all-off ()
   (setq idlwave-shell-suppress-electric-debug nil)
   (let ((buffers idlwave-shell-electric-debug-buffers)
diff --git a/lisp/replace.el b/lisp/replace.el
index 8a5c0a9680c..646f693cd7f 100644
--- a/lisp/replace.el
+++ b/lisp/replace.el
@@ -1214,7 +1214,7 @@ but coerced to the correct value of INTEGERS."
 
 (defun replace-match-maybe-edit (newtext fixedcase literal noedit match-data)
   "Make a replacement with `replace-match', editing `\\?'.
-NEXTEXT, FIXEDCASE, LITERAL are just passed on.  If NOEDIT is true, no
+NEWTEXT, FIXEDCASE, LITERAL are just passed on.  If NOEDIT is true, no
 check for `\\?' is made to save time.  MATCH-DATA is used for the
 replacement.  In case editing is done, it is changed to use markers.
 
@@ -1281,6 +1281,8 @@ make, or the user didn't cancel the call."
         ;; (match-data); otherwise it is t if a match is possible at point.
         (match-again t)
 
+        (isearch-string isearch-string)
+        (isearch-regexp isearch-regexp)
         (message
          (if query-flag
              (substitute-command-keys
@@ -1313,6 +1315,10 @@ make, or the user didn't cancel the call."
                                     (if regexp-flag from-string
                                       (regexp-quote from-string))
                                     "\\b")))
+    (if (eq query-replace-highlight 'isearch)
+        (setq isearch-string search-string
+              isearch-regexp regexp-flag))
+
     (push-mark)
     (undo-boundary)
     (unwind-protect
@@ -1380,7 +1386,7 @@ make, or the user didn't cancel the call."
             (if (not query-flag)
                 (let ((inhibit-read-only
                        query-replace-skip-read-only))
-                  (unless noedit
+                  (unless (or literal noedit)
                     (replace-highlight (nth 0 real-match-data)
                                        (nth 1 real-match-data)))
                   (setq noedit
@@ -1528,7 +1534,14 @@ make, or the user didn't cancel the call."
                          (setq unread-command-events
                                (append (listify-key-sequence key)
                                        unread-command-events))
-                         (setq done t))))
+                         (setq done t)))
+                  (when (eq query-replace-highlight 'isearch)
+                    ;; Force isearch rehighlighting
+                    (if (not (memq def '(skip backup)))
+                        (setq isearch-lazy-highlight-last-string nil))
+                    ;; Restore isearch data in case of isearching during edit
+                    (setq isearch-string search-string
+                          isearch-regexp regexp-flag)))
                 ;; Record previous position for ^ when we move on.
                 ;; Change markers to numbers in the match data
                 ;; since lots of markers slow down editing.
@@ -1563,27 +1576,38 @@ make, or the user didn't cancel the call."
                  (if (= replace-count 1) "" "s")))
     (and keep-going stack)))
 
-(defcustom query-replace-highlight t
-  "*Non-nil means to highlight words during query replacement."
-  :type 'boolean
+(defcustom query-replace-highlight
+  (if (and search-highlight isearch-lazy-highlight) 'isearch t)
+  "*Non-nil means to highlight words during query replacement.
+If `isearch', use isearch highlighting for query replacement."
+  :type '(choice (const :tag "Highlight" t)
+                 (const :tag "No highlighting" nil)
+                 (const :tag "Isearch highlighting" 'isearch))
   :group 'matching)
 
 (defvar replace-overlay nil)
 
 (defun replace-dehighlight ()
-  (and replace-overlay
-       (progn
-         (delete-overlay replace-overlay)
-         (setq replace-overlay nil))))
+  (cond ((eq query-replace-highlight 'isearch)
+         (isearch-dehighlight t)
+         (isearch-lazy-highlight-cleanup isearch-lazy-highlight-cleanup)
+         (setq isearch-lazy-highlight-last-string nil))
+        (query-replace-highlight
+         (when replace-overlay
+           (delete-overlay replace-overlay)
+           (setq replace-overlay nil)))))
 
 (defun replace-highlight (start end)
-  (and query-replace-highlight
-       (if replace-overlay
-           (move-overlay replace-overlay start end (current-buffer))
-         (setq replace-overlay (make-overlay start end))
-         (overlay-put replace-overlay 'face
-                      (if (facep 'query-replace)
-                          'query-replace 'region)))))
+  (cond ((eq query-replace-highlight 'isearch)
+         (isearch-highlight start end)
+         (isearch-lazy-highlight-new-loop))
+        (query-replace-highlight
+         (if replace-overlay
+             (move-overlay replace-overlay start end (current-buffer))
+           (setq replace-overlay (make-overlay start end))
+           (overlay-put replace-overlay 'face
+                        (if (facep 'query-replace)
+                            'query-replace 'region))))))
 
 ;; arch-tag: 16b4cd61-fd40-497b-b86f-b667c4cf88e4
 ;;; replace.el ends here
diff --git a/lisp/simple.el b/lisp/simple.el
index 979f3835c57..4a95b18bcb9 100644
--- a/lisp/simple.el
+++ b/lisp/simple.el
@@ -123,33 +123,33 @@ to navigate in it.")
 
 (make-variable-buffer-local 'next-error-function)
 
-(defsubst next-error-buffer-p (buffer 
-                               &optional 
-                               extra-test-inclusive 
+(defsubst next-error-buffer-p (buffer
+                               &optional
+                               extra-test-inclusive
                                extra-test-exclusive)
   "Test if BUFFER is a next-error capable buffer.
 EXTRA-TEST-INCLUSIVE is called to allow extra buffers.
-EXTRA-TEST-INCLUSIVE is called to disallow buffers."
+EXTRA-TEST-EXCLUSIVE is called to disallow buffers."
   (with-current-buffer buffer
     (or (and extra-test-inclusive (funcall extra-test-inclusive))
         (and (if extra-test-exclusive (funcall extra-test-exclusive) t)
          next-error-function))))
 
-(defun next-error-find-buffer (&optional other-buffer 
-                                         extra-test-inclusive 
+(defun next-error-find-buffer (&optional other-buffer
+                                         extra-test-inclusive
                                          extra-test-exclusive)
   "Return a next-error capable buffer.
 OTHER-BUFFER will disallow the current buffer.
 EXTRA-TEST-INCLUSIVE is called to allow extra buffers.
-EXTRA-TEST-INCLUSIVE is called to disallow buffers."
+EXTRA-TEST-EXCLUSIVE is called to disallow buffers."
   (or
    ;; 1. If one window on the selected frame displays such buffer, return it.
    (let ((window-buffers
           (delete-dups
            (delq nil (mapcar (lambda (w)
                                (if (next-error-buffer-p
-                                    (window-buffer w) 
-                                    extra-test-inclusive extra-test-exclusive)
+                                    (window-buffer w)
+                                    extra-test-inclusive extra-test-exclusive)
                                    (window-buffer w)))
                              (window-list))))))
      (if other-buffer
@@ -159,29 +159,29 @@ EXTRA-TEST-INCLUSIVE is called to disallow buffers."
    ;; 2. If next-error-last-buffer is set to a live buffer, use that.
    (if (and next-error-last-buffer
             (buffer-name next-error-last-buffer)
-            (next-error-buffer-p next-error-last-buffer 
-                                 extra-test-inclusive extra-test-exclusive)
+            (next-error-buffer-p next-error-last-buffer
+                                 extra-test-inclusive extra-test-exclusive)
             (or (not other-buffer)
                 (not (eq next-error-last-buffer (current-buffer)))))
        next-error-last-buffer)
    ;; 3. If the current buffer is a next-error capable buffer, return it.
    (if (and (not other-buffer)
-            (next-error-buffer-p (current-buffer) 
-                                 extra-test-inclusive extra-test-exclusive))
+            (next-error-buffer-p (current-buffer)
+                                 extra-test-inclusive extra-test-exclusive))
        (current-buffer))
    ;; 4. Look for a next-error capable buffer in a buffer list.
    (let ((buffers (buffer-list)))
      (while (and buffers
-                 (or (not (next-error-buffer-p 
-                           (car buffers) 
-                           extra-test-inclusive extra-test-exclusive))
+                 (or (not (next-error-buffer-p
+                           (car buffers)
+                           extra-test-inclusive extra-test-exclusive))
                      (and other-buffer (eq (car buffers) (current-buffer)))))
        (setq buffers (cdr buffers)))
      (if buffers
          (car buffers)
        (or (and other-buffer
-                (next-error-buffer-p (current-buffer) 
-                                     extra-test-inclusive extra-test-exclusive)
+                (next-error-buffer-p (current-buffer)
+                                     extra-test-inclusive extra-test-exclusive)
                 ;; The current buffer is a next-error capable buffer.
                 (progn
                   (if other-buffer
@@ -646,7 +646,8 @@ If BACKWARD-ONLY is non-nil, only delete spaces before point."
        (constrain-to-field nil orig-pos t)))))
 
 (defvar inhibit-mark-movement nil
-  "If non-nil, \\[beginning-of-buffer] and \\[end-of-buffer] does not set the mark.")
+  "If non-nil, movement commands, such as \\[beginning-of-buffer], \
+do not set the mark.")
 
 (defun beginning-of-buffer (&optional arg)
   "Move point to the beginning of the buffer; leave mark at previous position.
@@ -659,8 +660,10 @@ of the accessible part of the buffer.
 Don't use this command in Lisp programs!
 \(goto-char (point-min)) is faster and avoids clobbering the mark."
   (interactive "P")
-  (unless (or inhibit-mark-movement (consp arg))
-    (push-mark))
+  (or inhibit-mark-movement
+      (consp arg)
+      (and transient-mark-mode mark-active)
+      (push-mark))
   (let ((size (- (point-max) (point-min))))
     (goto-char (if (and arg (not (consp arg)))
                    (+ (point-min)
@@ -683,8 +686,10 @@ of the accessible part of the buffer.
 Don't use this command in Lisp programs!
 \(goto-char (point-max)) is faster and avoids clobbering the mark."
   (interactive "P")
-  (unless (or inhibit-mark-movement (consp arg))
-    (push-mark))
+  (or inhibit-mark-movement
+      (consp arg)
+      (and transient-mark-mode mark-active)
+      (push-mark))
   (let ((size (- (point-max) (point-min))))
     (goto-char (if (and arg (not (consp arg)))
                    (- (point-max)
@@ -2987,11 +2992,11 @@ You can also deactivate the mark by typing \\[keyboard-quit] or
 Many commands change their behavior when Transient Mark mode is in effect
 and the mark is active, by acting on the region instead of their usual
 default part of the buffer's text.  Examples of such commands include
-\\[comment-dwim], \\[flush-lines], \\[ispell], \\[keep-lines],
-\\[query-replace], \\[query-replace-regexp], and \\[undo].  Invoke
-\\[apropos-documentation] and type \"transient\" or \"mark.*active\" at
-the prompt, to see the documentation of commands which are sensitive to
-the Transient Mark mode."
+\\[comment-dwim], \\[flush-lines], \\[keep-lines], \
+\\[query-replace], \\[query-replace-regexp], \\[ispell], and \\[undo].
+Invoke \\[apropos-documentation] and type \"transient\" or
+\"mark.*active\" at the prompt, to see the documentation of
+commands which are sensitive to the Transient Mark mode."
   :global t :group 'editing-basics :require nil)
 
 (defun pop-global-mark ()
@@ -3242,7 +3247,7 @@ Outline mode sets this."
             (if (if forward
                     ;; If going forward, don't accept the previous
                     ;; allowable position if it is before the target line.
-                    (< line-beg (point)) 
+                    (< line-beg (point))
                   ;; If going backward, don't accept the previous
                   ;; allowable position if it is still after the target line.
                   (<= (point) line-end))
@@ -3523,12 +3528,17 @@ With argument, do this that many times."
   (interactive "p")
   (forward-word (- (or arg 1))))
 
-(defun mark-word (arg)
-  "Set mark arg words away from point.
-If this command is repeated, it marks the next ARG words after the ones
-already marked."
-  (interactive "p")
-  (cond ((and (eq last-command this-command) (mark t))
+(defun mark-word (&optional arg)
+  "Set mark ARG words away from point.
+The place mark goes is the same place \\[forward-word] would
+move to with the same argument.
+If this command is repeated or mark is active in Transient Mark mode,
+it marks the next ARG words after the ones already marked."
+  (interactive "P")
+  (cond ((or (and (eq last-command this-command) (mark t))
+             (and transient-mark-mode mark-active))
+         (setq arg (if arg (prefix-numeric-value arg)
+                     (if (< (mark) (point)) -1 1)))
          (set-mark
           (save-excursion
             (goto-char (mark))
@@ -3537,7 +3547,7 @@ already marked."
         (t
          (push-mark
           (save-excursion
-            (forward-word arg)
+            (forward-word (prefix-numeric-value arg))
             (point))
           nil t))))
 
@@ -4021,8 +4031,7 @@ or go back to just one window (by deleting all but the selected window)."
          (abort-recursive-edit))
         (current-prefix-arg
          nil)
-        ((and transient-mark-mode
-              mark-active)
+        ((and transient-mark-mode mark-active)
          (deactivate-mark))
         ((> (recursion-depth) 0)
          (exit-recursive-edit))
diff --git a/lisp/subr.el b/lisp/subr.el
index 4c695ea167d..c20eaad9c56 100644
--- a/lisp/subr.el
+++ b/lisp/subr.el
@@ -1862,6 +1862,19 @@ is allowed once again."
          ,@body)
      (quit (setq quit-flag t) nil)))
 
+(defmacro while-no-input (&rest body)
+  "Execute BODY only as long as there's no pending input.
+If input arrives, that ends the execution of BODY,
+and `while-no-input' returns nil.  If BODY finishes,
+`while-no-input' returns whatever value BODY produced."
+  (declare (debug t) (indent 0))
+  (let ((catch-sym (make-symbol "input")))
+    `(with-local-quit
+       (catch ',catch-sym
+         (let ((throw-on-input ',catch-sym))
+           (when (sit-for 0 0 t)
+             ,@body))))))
+
 (defmacro combine-after-change-calls (&rest body)
   "Execute BODY, but don't call the after-change functions till the end.
 If BODY makes changes in the buffer, they are recorded
diff --git a/lisp/term.el b/lisp/term.el
index 8f3ba77daf5..32e249024d9 100644
--- a/lisp/term.el
+++ b/lisp/term.el
@@ -1400,7 +1400,7 @@ The main purpose is to get rid of the local keymap."
 :kl=\\EOD:kd=\\EOB:kr=\\EOC:ku=\\EOA:kN=\\E[6~:kP=\\E[5~:@7=\\E[4~:kh=\\E[1~\
 :mk=\\E[8m:cb=\\E[1K:op=\\E[39;49m:Co#8:pa#64:AB=\\E[4%%dm:AF=\\E[3%%dm:cr=^M\
 :bl=^G:do=^J:le=^H:ta=^I:se=\E[27m:ue=\E24m\
-:kb=^?:kD=^[[3~:sc=\E7:rc=\E8:"
+:kb=^?:kD=^[[3~:sc=\E7:rc=\E8:r1=\Ec:"
 ;;; : -undefine ic
 ;;; don't define :te=\\E[2J\\E[?47l\\E8:ti=\\E7\\E[?47h\
   "termcap capabilities supported")
@@ -2891,6 +2891,10 @@ See `term-prompt-regexp'."
                               (term-goto (car term-saved-cursor)
                                          (cdr term-saved-cursor)))
                           (setq term-terminal-state 0))
+                         ((eq char ?c) ;; \Ec - Reset (terminfo: rs1) 
+                          ;; This is used by the "clear" program.
+                          (setq term-terminal-state 0)
+                          (term-reset-terminal))
                          ;; The \E#8 reset sequence for xterm. We
                          ;; probably don't need to handle it, but this
                          ;; is the code to parse it.
@@ -3018,13 +3022,29 @@ See `term-prompt-regexp'."
           (set-marker term-home-marker (point))
           (setq term-current-row (1- term-height))))))
 
+;;; Reset the terminal, delete all the content and set the face to the
+;;; default one. 
+(defun term-reset-terminal ()
+  (erase-buffer)
+  (setq term-current-row 1)
+  (setq term-current-column 1)
+  (setq term-insert-mode nil)
+  (setq term-current-face nil)
+  (setq term-ansi-current-underline 0)
+  (setq term-ansi-current-bold 0)
+  (setq term-ansi-current-reverse 0)
+  (setq term-ansi-current-color 0)
+  (setq term-ansi-current-invisible 0)
+  (setq term-ansi-face-already-done 1)
+  (setq term-ansi-current-bg-color 0))
+
 ;;; New function to deal with ansi colorized output, as you can see you can
 ;;; have any bold/underline/fg/bg/reverse combination. -mm
 
 (defun term-handle-colors-array (parameter)
   (cond
 
-;;; Bold
+;;; Bold  (terminfo: bold)
    ((eq parameter 1)
     (setq term-ansi-current-bold 1))
 
diff --git a/lisp/textmodes/paragraphs.el b/lisp/textmodes/paragraphs.el
index 206f7a42f78..353aa0ee8a2 100644
--- a/lisp/textmodes/paragraphs.el
+++ b/lisp/textmodes/paragraphs.el
@@ -357,13 +357,15 @@ the number of paragraphs marked equals ARG.
 If ARG is negative, point is put at end of this paragraph, mark is put
 at beginning of this or a previous paragraph.
 
-If this command is repeated, it marks the next ARG paragraphs after (or
-before, if arg is negative) the ones already marked."
+If this command is repeated or mark is active in Transient Mark mode,
+it marks the next ARG paragraphs after (or before, if arg is negative)
+the ones already marked."
   (interactive "p")
   (unless arg (setq arg 1))
   (when (zerop arg)
     (error "Cannot mark zero paragraphs"))
-  (cond ((and (eq last-command this-command) (mark t))
+  (cond ((or (and (eq last-command this-command) (mark t))
+             (and transient-mark-mode mark-active))
          (set-mark
           (save-excursion
             (goto-char (mark))
diff --git a/lisp/textmodes/tex-mode.el b/lisp/textmodes/tex-mode.el
index 48b5edb3a69..1f9336fef50 100644
--- a/lisp/textmodes/tex-mode.el
+++ b/lisp/textmodes/tex-mode.el
@@ -1351,7 +1351,9 @@ Mark is left at original location."
       (when (eq (char-after) ?{)
         (let ((newpos (point)))
           (when (ignore-errors (backward-sexp 1) t)
-            (if (looking-at "\\\\end\\>")
+            (if (or (looking-at "\\\\end\\>")
+                    ;; In case the \\ ends a verbatim section.
+                    (and (looking-at "end\\>") (eq (char-before) ?\\)))
                 (tex-last-unended-begin)
               (goto-char newpos))))))))
 
diff --git a/lisp/url/ChangeLog b/lisp/url/ChangeLog
index c9663baff8f..9bb5ef1c3e5 100644
--- a/lisp/url/ChangeLog
+++ b/lisp/url/ChangeLog
@@ -1,3 +1,7 @@
+2004-12-11  Stefan Monnier  <monnier@iro.umontreal.ca>
+
+        * url-handlers.el: Don't `require' everything eagerly.
+
 2004-11-30  Paul Pogonyshev  <pogonyshev@gmx.net>
 
         * url-http.el (url-http-handle-cookies): Bind `url-current-object'
@@ -18,8 +22,7 @@
 
 2004-11-12  Masatake YAMATO  <jet@gyve.org>
 
-        * url-mailto.el (url-mailto): Fix a typo in the 
-        comment.
+        * url-mailto.el (url-mailto): Fix a typo in the comment.
 
 2004-11-02  Masatake YAMATO  <jet@gyve.org>
 
@@ -76,12 +79,12 @@
 
         * url-vars.el (url-passwd-entry-func): Var deleted.
         (mm-mime-mule-charset-alist): Remove compatibility code for old Gnus.
-        (url-weekday-alist): Renamed from weekday-alist.
-        (url-monthabbrev-alist): Renamed from monthabbrev-alist.
+        (url-weekday-alist): Rename from weekday-alist.
+        (url-monthabbrev-alist): Rename from monthabbrev-alist.
         (url-vars-unload-hook): Initialize hook var to hold the function.
 
-        * url-util.el (url-get-normalized-date): Use
-        url-weekday-alist and url-monthabbrev-alist.
+        * url-util.el (url-get-normalized-date): Use url-weekday-alist and
+        url-monthabbrev-alist.
 
         * url-misc.el: Load cl at compile time.
 
@@ -99,8 +102,8 @@
         * url-news.el (url-snews): Use nntp-open-tls-stream if
         url-gateway-method is tls.
 
-        * url-ldap.el (url-ldap-certificate-formatter): Use
-        tls-certificate-information if ssl.el is not available.
+        * url-ldap.el (url-ldap-certificate-formatter):
+        Use tls-certificate-information if ssl.el is not available.
 
         * url-https.el (url-https-create-secure-wrapper): Use tls if ssl
         is not available.
diff --git a/lisp/url/url-handlers.el b/lisp/url/url-handlers.el
index db961b9c27e..f90f21a3dbe 100644
--- a/lisp/url/url-handlers.el
+++ b/lisp/url/url-handlers.el
@@ -25,11 +25,21 @@
 
 ;;; Code:
 
-(require 'url)
-(require 'url-parse)
-(require 'url-util)
-(require 'mm-decode)
-(require 'mailcap)
+;; (require 'url)
+(eval-when-compile (require 'url-parse))
+;; (require 'url-util)
+(eval-when-compile (require 'mm-decode))
+;; (require 'mailcap)
+;; The following functions in the byte compiler's warnings are known not
+;; to cause any real problem for the following reasons:
+;; - mm-save-part-to-file, mm-destroy-parts: always used
+;;   after mm-dissect-buffer and defined in the same file.
+;; The following are autoloaded instead of `require'd to avoid eagerly
+;; loading all of URL when turning on url-handler-mode in the .emacs.
+(autoload 'url-retrieve-synchronously "url" "Retrieve url synchronously.")
+(autoload 'url-expand-file-name "url-expand" "Convert url to a fully specified url, and canonicalize it.")
+(autoload 'mm-dissect-buffer "mm-decode" "Dissect the current buffer and return a list of MIME handles.")
+(autoload 'url-scheme-get-property "url-methods" "Get property of a URL SCHEME.")
 
 (eval-when-compile
   (require 'cl))
diff --git a/lisp/vc-svn.el b/lisp/vc-svn.el
index fafb5eff7cd..cbb951d60b7 100644
--- a/lisp/vc-svn.el
+++ b/lisp/vc-svn.el
@@ -447,10 +447,14 @@ and that it passes `vc-svn-global-switches' to it before FLAGS."
       (vc-insert-file (expand-file-name ".svn/entries" dirname)))
     (goto-char (point-min))
     (when (re-search-forward
-           (concat "name=\"svn:this_dir\"[\n\t ]*"
-                   "\\([-a-z]+=\"[^\"]*\"[\n\t ]*\\)*?"
+           ;; Old `svn' used name="svn:dir", newer use just name="".
+           (concat "name=\"\\(?:svn:this_dir\\)?\"[\n\t ]*"
+                   "\\(?:[-a-z]+=\"[^\"]*\"[\n\t ]*\\)*?"
                    "url=\"\\([^\"]+\\)\"") nil t)
-      (match-string 2))))
+      ;; This is not a hostname but a URL.  This may actually be considered
+      ;; as a feature since it allows vc-svn-stay-local to specify different
+      ;; behavior for different modules on the same server.
+      (match-string 1))))
 
 (defun vc-svn-parse-status (localp)
   "Parse output of \"svn status\" command in the current buffer.
@@ -505,6 +509,30 @@ essential information."
   (and (string-match "^[0-9]" tag)
        (not (string-match "[^0-9]" tag))))
 
+;; Support for `svn annotate'
+
+(defun vc-svn-annotate-command (file buf &optional rev)
+  (vc-svn-command buf 0 file "annotate" (if rev (concat "-r" rev))))
+
+(defun vc-svn-annotate-time-of-rev (rev)
+  ;; Arbitrarily assume 10 commmits per day.
+  (/ (string-to-number rev) 10.0))
+
+(defun vc-svn-annotate-current-time ()
+  (vc-svn-annotate-time-of-rev vc-annotate-parent-rev))
+
+(defconst vc-svn-annotate-re "[ \t]*\\([0-9]+\\)[ \t]+[^\t ]+ ")
+
+(defun vc-svn-annotate-time ()
+  (when (looking-at vc-svn-annotate-re)
+    (goto-char (match-end 0))
+    (vc-svn-annotate-time-of-rev (match-string 1))))
+
+(defun vc-svn-annotate-extract-revision-at-line ()
+  (save-excursion
+    (beginning-of-line)
+    (if (looking-at vc-svn-annotate-re) (match-string 1))))
+
 (provide 'vc-svn)
 
 ;; arch-tag: 02f10c68-2b4d-453a-90fc-1eee6cfb268d
diff --git a/lisp/xml.el b/lisp/xml.el
index aba84d33230..daf5689c18b 100644
--- a/lisp/xml.el
+++ b/lisp/xml.el
@@ -179,6 +179,8 @@ If PARSE-NS is non-nil, then QNAMES are expanded."
       xml)))
 
 
+(defvar xml-name-re)
+(defvar xml-entity-value-re)
 (let* ((start-chars (concat "[:alpha:]:_"))
        (name-chars  (concat "-[:digit:]." start-chars))
 ;;[3]           S          ::=          (#x20 | #x9 | #xD | #xA)+
diff --git a/lisp/xt-mouse.el b/lisp/xt-mouse.el
index a261d3d36c8..19b58475a93 100644
--- a/lisp/xt-mouse.el
+++ b/lisp/xt-mouse.el
@@ -139,12 +139,13 @@
                                                   default-header-line-format)
                                               1
                                             0)))
-                    (move-to-column (+ (car where) (current-column)
+                    (move-to-column (- (+ (car where) (current-column)
                                        (if (string-match "\\` \\*Minibuf"
                                                          (buffer-name))
                                            (- (minibuffer-prompt-width))
                                          0)
-                                       (max 0 (1- (window-hscroll)))))
+                                       (max 0 (1- (window-hscroll))))
+                                       left-margin-width))
                     (point))
                 where))
          (mouse (intern