Merged in changes from CVS trunk.

Patches applied:

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

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

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

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

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

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

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

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

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

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


git-archimport-id: lorentey@elte.hu--2004/emacs--multi-tty--0--patch-239

19 files changed, 537 insertions, 279 deletions

diff --git a/lisp/ChangeLog b/lisp/ChangeLog
index a0dcde78786..e6b3e1f60a7 100644
--- a/lisp/ChangeLog
+++ b/lisp/ChangeLog
@@ -1,3 +1,92 @@
+2004-08-30  John Paul Wallington  <jpw@gnu.org>
+
+        * textmodes/tex-mode.el (tex-validate-buffer): Use distinct
+        strings rather than programatically constructing message.
+
+2004-08-30  Richard M. Stallman  <rms@gnu.org>
+
+        * emacs-lisp/lisp-mode.el (prin1-char): Don't turn S-a into A.
+        Don't return a string that would read as the wrong character code.
+
+2004-08-29  Kim F. Storm  <storm@cua.dk>
+
+        * emulation/cua-base.el (cua-auto-expand-rectangles): Remove
+        automatic rectangle padding feature; replace by non-destructive
+        virtual rectangle edges feature.
+        (cua-virtual-rectangle-edges): New defcustom.
+        (cua-auto-tabify-rectangles): New defcustom.
+        (cua-paste): If paste into a marked rectangle, insert rectangle at
+        current column, even if virtual; also paste exactly as many lines
+        as has been marked (ignore additional lines or add empty lines),
+        but paste whole source if only one line is marked.
+        (cua--update-indications): No longer use overwrite-cursor to
+        indicate rectangle padding
+
+        * emulation/cua-rect.el (cua--rectangle-padding): Remove.
+        (cua--rectangle-virtual-edges): New defun.
+        (cua--rectangle-get-corners): Remove optional PAD arg.
+        (cua--rectangle-set-corners): Never do padding.
+        (cua--forward-line): Remove optional PAD arg.  Simplify.
+        (cua-resize-rectangle-right, cua-resize-rectangle-left)
+        (cua-resize-rectangle-down, cua-resize-rectangle-up):
+        (cua-resize-rectangle-bot, cua-resize-rectangle-top)
+        (cua-resize-rectangle-page-up, cua-resize-rectangle-page-down)
+        (cua--rectangle-move): Never do padding.  Simplify.
+        (cua--tabify-start): New defun.
+        (cua--rectangle-operation): Add tabify arg.  All callers changed.
+        (cua--pad-rectangle): Remove.
+        (cua--delete-rectangle): Handle delete with virtual edges.
+        (cua--extract-rectangle): Add spaces if rectangle has virtual edges.
+        (cua--insert-rectangle): Handle insert at virtual column.
+        Perform auto-tabify if necessary.
+        (cua--activate-rectangle): Remove optional FORCE arg.
+        Never do padding.  Simplify.
+        (cua--highlight-rectangle): Enhance for virtual edges.
+        (cua-toggle-rectangle-padding): Remove command.
+        (cua-toggle-rectangle-virtual-edges): New command.
+        (cua-sequence-rectangle): Add optional TABIFY arg.  Callers changed.
+        (cua--rectangle-post-command): Don't force rectangle padding.
+        (cua--init-rectangles): Bind M-p to cua-toggle-rectangle-virtual-edges.
+
+2004-08-28  Luc Teirlinck  <teirllm@auburn.edu>
+
+        * indent.el (edit-tab-stops-buffer): Doc fix.
+
+2004-08-28  Richard M. Stallman  <rms@gnu.org>
+
+        * progmodes/grep.el (grep-default-command): Use find-tag-default.
+        (grep-tag-default): Function deleted.
+
+        * subr.el (find-tag-default): Moved from etags.el.
+
+        * progmodes/etags.el (find-tag-default): Moved to subr.el.
+
+        * emacs-lisp/lisp-mode.el (prin1-char): Put `shift' modifier
+        into the basic character if it has an uppercase form.
+
+2004-08-27  Kenichi Handa  <handa@m17n.org>
+
+        * international/utf-8.el (utf-8-post-read-conversion): If the
+        buffer is unibyte, temporarily make it multibyte.
+
+2004-08-27  Masatake YAMATO  <jet@gyve.org>
+
+        * calendar/time-date.el (time-to-seconds): Add autoload cookies.
+
+2004-08-25  John Paul Wallington  <jpw@gnu.org>
+
+        * textmodes/tex-mode.el (tex-validate-buffer): Distinguish between
+        0, 1, and many mismatches in message.
+        (tex-start-shell): Use `set-process-query-on-exit-flag'.
+
+        * ielm.el (ielm-tab, ielm-complete-symbol): Doc fix.
+        (inferior-emacs-lisp-mode): Use `set-process-query-on-exit-flag'.
+
+2004-08-23  Stefan Monnier  <monnier@iro.umontreal.ca>
+
+        * vc-svn.el (vc-svn-diff): Treat options from vc-svn-diff-switches and
+        vc-diff-switches differently.
+
 2004-08-22  Luc Teirlinck  <teirllm@auburn.edu>
 
         * speedbar.el (speedbar-file-regexp): Give it a phony defvar
@@ -7,8 +96,8 @@
 
 2004-08-22  Richard M. Stallman  <rms@gnu.org>
 
-        * textmodes/flyspell.el (flyspell-word): Use
-        set-process-query-on-exit-flag.
+        * textmodes/flyspell.el (flyspell-word):
+        Use set-process-query-on-exit-flag.
         (flyspell-highlight-duplicate-region): Take POSS as arg.
         (flyspell-word): Pass POSS as arg.
 
@@ -51,8 +140,7 @@
 
 2004-08-22  Andreas Schwab  <schwab@suse.de>
 
-        * cvs-status.el: Require pcvs during byte-compiling for
-        defun-cvs-mode.
+        * cvs-status.el: Require pcvs during byte-compiling for defun-cvs-mode.
 
 2004-08-22  Masatake YAMATO  <jet@gyve.org>
 
diff --git a/lisp/calendar/time-date.el b/lisp/calendar/time-date.el
index 846231befe6..6439089273a 100644
--- a/lisp/calendar/time-date.el
+++ b/lisp/calendar/time-date.el
@@ -45,6 +45,7 @@
               (timezone-make-date-arpa-standard date)))
     (error (error "Invalid date: %s" date))))
 
+;;;###autoload
 (defun time-to-seconds (time)
   "Convert time value TIME to a floating point number.
 You can use `float-time' instead."
diff --git a/lisp/emacs-lisp/lisp-mode.el b/lisp/emacs-lisp/lisp-mode.el
index df05555ae7b..e2aac327ddc 100644
--- a/lisp/emacs-lisp/lisp-mode.el
+++ b/lisp/emacs-lisp/lisp-mode.el
@@ -363,7 +363,7 @@ if that value is non-nil."
     (when (stringp default)
       (if (string-match ":+" default)
           (substring default (match-end 0))
-          default))))
+        default))))
 
 ;; Used in old LispM code.
 (defalias 'common-lisp-mode 'lisp-mode)
@@ -459,21 +459,37 @@ alternative printed representations that can be displayed."
 If CHAR is not a character, return nil."
   (and (integerp char)
        (eventp char)
-       (let ((c (event-basic-type char)))
-         (concat
-          "?"
-          (mapconcat
-           (lambda (modif)
-             (cond ((eq modif 'super) "\\s-")
-                   (t (string ?\\ (upcase (aref (symbol-name modif) 0)) ?-))))
-           (event-modifiers char) "")
-          (cond
-           ((memq c '(?\; ?\( ?\) ?\{ ?\} ?\[ ?\] ?\" ?\' ?\\)) (string ?\\ c))
-           ((eq c 127) "\\C-?")
-           (t
-            (condition-case nil
-                (string c)
-              (error nil))))))))
+       (let ((c (event-basic-type char))
+             (mods (event-modifiers char))
+             string)
+         ;; Prevent ?A from turning into ?\S-a.
+         (if (and (memq 'shift mods)
+                  (zerop (logand char ?\S-\^@))
+                  (not (let ((case-fold-search nil))
+                         (char-equal c (upcase c)))))
+             (setq c (upcase c) mods nil))
+         ;; What string are we considering using?
+         (condition-case nil
+             (setq string
+                   (concat
+                    "?"
+                    (mapconcat
+                     (lambda (modif)
+                       (cond ((eq modif 'super) "\\s-")
+                             (t (string ?\\ (upcase (aref (symbol-name modif) 0)) ?-))))
+                     mods "")
+                    (cond
+                     ((memq c '(?\; ?\( ?\) ?\{ ?\} ?\[ ?\] ?\" ?\' ?\\)) (string ?\\ c))
+                     ((eq c 127) "\\C-?")
+                     (t
+                      (string c)))))
+           (error nil))
+         ;; Verify the string reads a CHAR, not to some other character.
+         ;; If it doesn't, return nil instead.
+         (and string
+              (= (car (read-from-string string)) char)
+              string))))
+         
 
 (defun eval-last-sexp-1 (eval-last-sexp-arg-internal)
   "Evaluate sexp before point; print value in minibuffer.
diff --git a/lisp/emulation/cua-base.el b/lisp/emulation/cua-base.el
index b39945c7712..fb3c537936f 100644
--- a/lisp/emulation/cua-base.el
+++ b/lisp/emulation/cua-base.el
@@ -141,30 +141,39 @@
 ;; completely separate set of "rectangle commands" [C-x r ...] on the
 ;; region to copy, kill, fill a.s.o. the virtual rectangle.
 ;;
-;; cua-mode's superior rectangle support is based on using a true visual
-;; representation of the selected rectangle. To start a rectangle, use
-;; [S-return] and extend it using the normal movement keys (up, down,
-;; left, right, home, end, C-home, C-end). Once the rectangle has the
-;; desired size, you can cut or copy it using C-x and C-c (or C-w and M-w),
-;; and you can subsequently insert it - as a rectangle - using C-v (or
-;; C-y).  So the only new command you need to know to work with
-;; cua-mode rectangles is S-return!
+;; cua-mode's superior rectangle support uses a true visual
+;; representation of the selected rectangle, i.e. it highlights the
+;; actual part of the buffer that is currently selected as part of the
+;; rectangle.  Unlike emacs' traditional rectangle commands, the
+;; selected rectangle always as straight left and right edges, even
+;; when those are in the middle of a TAB character or beyond the end
+;; of the current line.  And it does this without actually modifying
+;; the buffer contents (it uses display overlays to visualize the
+;; virtual dimensions of the rectangle).
+;;
+;; This means that cua-mode's rectangles are not limited to the actual
+;; contents of the buffer, so if the cursor is currently at the end of a
+;; short line, you can still extend the rectangle to include more columns
+;; of longer lines in the same rectangle.  And you can also have the
+;; left edge of a rectangle start in the middle of a TAB character.
+;; Sounds strange? Try it!
+;;
+;; To start a rectangle, use [S-return] and extend it using the normal
+;; movement keys (up, down, left, right, home, end, C-home,
+;; C-end). Once the rectangle has the desired size, you can cut or
+;; copy it using C-x and C-c (or C-w and M-w), and you can
+;; subsequently insert it - as a rectangle - using C-v (or C-y).  So
+;; the only new command you need to know to work with cua-mode
+;; rectangles is S-return!
 ;;
 ;; Normally, when you paste a rectangle using C-v (C-y), each line of
 ;; the rectangle is inserted into the existing lines in the buffer.
 ;; If overwrite-mode is active when you paste a rectangle, it is
 ;; inserted as normal (multi-line) text.
 ;;
-;; Furthermore, cua-mode's rectangles are not limited to the actual
-;; contents of the buffer, so if the cursor is currently at the end of a
-;; short line, you can still extend the rectangle to include more columns
-;; of longer lines in the same rectangle.  Sounds strange? Try it!
-;;
-;; You can enable padding for just this rectangle by pressing [M-p];
-;; this works like entering `picture-mode' where the tabs and spaces
-;; are automatically converted/inserted to make the rectangle truly
-;; rectangular. Or you can do it for all rectangles by setting the
-;; `cua-auto-expand-rectangles' variable.
+;; If you prefer the traditional rectangle marking (i.e. don't want
+;; straight edges), [M-p] toggles this for the current rectangle,
+;; or you can customize cua-virtual-rectangle-edges.
 
 ;; And there's more: If you want to extend or reduce the size of the
 ;; rectangle in one of the other corners of the rectangle, just use
@@ -204,8 +213,8 @@
 ;;       a supplied format string (prompt)
 ;; [M-o] opens the rectangle by moving the highlighted text to the
 ;;       right of the rectangle and filling the rectangle with blanks.
-;; [M-p] toggles rectangle padding, i.e. insert tabs and spaces to
-;;       make rectangles truly rectangular
+;; [M-p] toggles virtual straight rectangle edges
+;; [M-P] inserts tabs and spaces (padding) to make real straight edges
 ;; [M-q] performs text filling on the rectangle
 ;; [M-r] replaces REGEXP (prompt) by STRING (prompt) in rectangle
 ;; [M-R] reverse the lines in the rectangle
@@ -347,14 +356,27 @@ managers, so try setting this to nil, if prefix override doesn't work."
 
 ;;; Rectangle Customization
 
-(defcustom cua-auto-expand-rectangles nil
-  "*If non-nil, rectangles are padded with spaces to make straight edges.
-This implies modifying buffer contents by expanding tabs and inserting spaces.
-Consequently, this is inhibited in read-only buffers.
-Can be toggled by [M-p] while the rectangle is active,"
+(defcustom cua-virtual-rectangle-edges t
+  "*If non-nil, rectangles have virtual straight edges.
+Note that although rectangles are always DISPLAYED with straight edges, the
+buffer is NOT modified, until you execute a command that actually modifies it.
+\[M-p] toggles this feature when a rectangle is active."
   :type 'boolean
   :group 'cua)
 
+(defcustom cua-auto-tabify-rectangles 1000
+  "*If non-nil, automatically tabify after rectangle commands.
+This basically means that `tabify' is applied to all lines that
+are modified by inserting or deleting a rectangle.  If value is
+an integer, cua will look for existing tabs in a region around
+the rectangle, and only do the conversion if any tabs are already
+present.  The number specifies then number of characters before
+and after the region marked by the rectangle to search."
+  :type '(choice (number :tag "Auto detect (limit)")
+                 (const :tag "Disabled" nil)
+                 (other :tag "Enabled" t))
+  :group 'cua)
+
 (defcustom cua-enable-rectangle-auto-help t
   "*If non-nil, automatically show help for region, rectangle and global mark."
   :type 'boolean
@@ -412,7 +434,6 @@ Can be toggled by [M-p] while the rectangle is active,"
                                        (frame-parameter nil 'cursor-color)
                                        "red")
   "Normal (non-overwrite) cursor color.
-Also used to indicate that rectangle padding is not in effect.
 Default is to load cursor color from initial or default frame parameters.
 
 If the value is a COLOR name, then only the `cursor-color' attribute will be
@@ -462,7 +483,6 @@ a cons (TYPE . COLOR), then both properties are affected."
 
 (defcustom cua-overwrite-cursor-color "yellow"
   "*Cursor color used when overwrite mode is set, if non-nil.
-Also used to indicate that rectangle padding is in effect.
 Only used when `cua-enable-cursor-indications' is non-nil.
 
 If the value is a COLOR name, then only the `cursor-color' attribute will be
@@ -806,7 +826,8 @@ If global mark is active, copy from register or one character."
   (interactive "P")
   (setq arg (cua--prefix-arg arg))
   (let ((regtxt (and cua--register (get-register cua--register)))
-        (count (prefix-numeric-value arg)))
+        (count (prefix-numeric-value arg))
+        paste-column paste-lines)
     (cond
      ((and cua--register (not regtxt))
       (message "Nothing in register %c" cua--register))
@@ -825,7 +846,12 @@ If global mark is active, copy from register or one character."
           ;; the same region that we are going to delete.
           ;; That would make yank a no-op.
           (if cua--rectangle
-              (cua--delete-rectangle)
+              (progn
+                (goto-char (min (mark) (point)))
+                (setq paste-column (cua--rectangle-left))
+                (setq paste-lines (cua--delete-rectangle))
+                (if (= paste-lines 1)
+                    (setq paste-lines nil))) ;; paste all
             (if (string= (buffer-substring (point) (mark))
                          (car kill-ring))
                 (current-kill 1))
@@ -843,7 +869,8 @@ If global mark is active, copy from register or one character."
             (setq this-command 'cua--paste-rectangle)
             (undo-boundary)
             (setq buffer-undo-list (cons pt buffer-undo-list)))
-          (cua--insert-rectangle (cdr cua--last-killed-rectangle))
+          (cua--insert-rectangle (cdr cua--last-killed-rectangle)
+                                 nil paste-column paste-lines)
           (if arg (goto-char pt))))
        (t (yank arg)))))))
 
@@ -1033,9 +1060,7 @@ If ARG is the atom `-', scroll upward by nearly full screen."
            ((and buffer-read-only
                  cua-read-only-cursor-color)
             cua-read-only-cursor-color)
-           ((and cua-overwrite-cursor-color
-                 (or overwrite-mode
-                     (and cua--rectangle (cua--rectangle-padding))))
+           ((and cua-overwrite-cursor-color overwrite-mode)
             cua-overwrite-cursor-color)
            (t cua-normal-cursor-color)))
          (color (if (consp cursor) (cdr cursor) cursor))
diff --git a/lisp/emulation/cua-rect.el b/lisp/emulation/cua-rect.el
index 965fe63bced..626ef22cf2d 100644
--- a/lisp/emulation/cua-rect.el
+++ b/lisp/emulation/cua-rect.el
@@ -44,10 +44,10 @@
 (require 'rect)
 
 ;; If non-nil, restrict current region to this rectangle.
-;; Value is a vector [top bot left right corner ins pad select].
+;; Value is a vector [top bot left right corner ins virt select].
 ;; CORNER specifies currently active corner 0=t/l 1=t/r 2=b/l 3=b/r.
 ;; INS specifies whether to insert on left(nil) or right(t) side.
-;; If PAD is non-nil, tabs are converted to spaces when necessary.
+;; If VIRT is non-nil, virtual straight edges are enabled.
 ;; If SELECT is a regexp, only lines starting with that regexp are affected.")
 (defvar cua--rectangle nil)
 (make-variable-buffer-local 'cua--rectangle)
@@ -65,6 +65,8 @@
 (defvar cua--rectangle-overlays nil)
 (make-variable-buffer-local 'cua--rectangle-overlays)
 
+(defvar cua--virtual-edges-debug nil)
+
 ;; Per-buffer CUA mode undo list.
 (defvar cua--undo-list nil)
 (make-variable-buffer-local 'cua--undo-list)
@@ -97,7 +99,7 @@ Knows about CUA rectangle highlighting in addition to standard undo."
 (defvar cua--tidy-undo-counter 0
   "Number of times `cua--tidy-undo-lists' have run successfully.")
 
-;; Clean out danling entries from cua's undo list.
+;; Clean out dangling entries from cua's undo list.
 ;; Since this list contains pointers into the standard undo list,
 ;; such references are only meningful as undo information if the
 ;; corresponding entry is still on the standard undo list.
@@ -203,11 +205,11 @@ Knows about CUA rectangle highlighting in addition to standard undo."
           (aref cua--rectangle 5))
       (cua--rectangle-left))))
 
-(defun cua--rectangle-padding (&optional set val)
-  ;; Current setting of rectangle padding
+(defun cua--rectangle-virtual-edges (&optional set val)
+  ;; Current setting of rectangle virtual-edges
   (if set
       (aset cua--rectangle 6 val))
-  (and (not buffer-read-only)
+  (and ;(not buffer-read-only)
        (aref cua--rectangle 6)))
 
 (defun cua--rectangle-restriction (&optional val bounded negated)
@@ -226,7 +228,7 @@ Knows about CUA rectangle highlighting in addition to standard undo."
   (if (< (cua--rectangle-bot) (cua--rectangle-top))
       (message "rectangle bot < top")))
 
-(defun cua--rectangle-get-corners (&optional pad)
+(defun cua--rectangle-get-corners ()
   ;; Calculate the rectangular region represented by point and mark,
   ;; putting start in the upper left corner and end in the
   ;; bottom right corner.
@@ -245,12 +247,12 @@ Knows about CUA rectangle highlighting in addition to standard undo."
               (setq r (1- r)))
         (setq l (prog1 r (setq r l)))
         (goto-char top)
-        (move-to-column l pad)
+        (move-to-column l)
         (setq top (point))
         (goto-char bot)
-        (move-to-column r pad)
+        (move-to-column r)
         (setq bot (point))))
-    (vector top bot l r corner 0 pad nil)))
+    (vector top bot l r corner 0 cua-virtual-rectangle-edges nil)))
 
 (defun cua--rectangle-set-corners ()
   ;; Set mark and point in opposite corners of current rectangle.
@@ -269,24 +271,21 @@ Knows about CUA rectangle highlighting in addition to standard undo."
       (setq pp (cua--rectangle-bot) pc (cua--rectangle-right)
             mp (cua--rectangle-top) mc (cua--rectangle-left))))
     (goto-char mp)
-    (move-to-column mc (cua--rectangle-padding))
+    (move-to-column mc)
     (set-mark (point))
     (goto-char pp)
-    (move-to-column pc (cua--rectangle-padding))))
+    (move-to-column pc)
+    ))
 
 ;;; Rectangle resizing
 
-(defun cua--forward-line (n pad)
+(defun cua--forward-line (n)
   ;; Move forward/backward one line.  Returns t if movement.
-  (if (or (not pad) (< n 0))
-      (= (forward-line n) 0)
-    (next-line 1)
-    t))
+  (= (forward-line n) 0))
 
 (defun cua--rectangle-resized ()
   ;; Refresh state after resizing rectangle
   (setq cua--buffer-and-point-before-command nil)
-  (cua--pad-rectangle)
   (cua--rectangle-insert-col 0)
   (cua--rectangle-set-corners)
   (cua--keep-active))
@@ -294,47 +293,35 @@ Knows about CUA rectangle highlighting in addition to standard undo."
 (defun cua-resize-rectangle-right (n)
   "Resize rectangle to the right."
   (interactive "p")
-  (let ((pad (cua--rectangle-padding)) (resized (> n 0)))
+  (let ((resized (> n 0)))
     (while (> n 0)
       (setq n (1- n))
       (cond
-       ((and (cua--rectangle-right-side) (or pad (eolp)))
-        (cua--rectangle-right (1+ (cua--rectangle-right)))
-        (move-to-column (cua--rectangle-right) pad))
        ((cua--rectangle-right-side)
-        (forward-char 1)
-        (cua--rectangle-right (current-column)))
-       ((or pad (eolp))
-        (cua--rectangle-left (1+ (cua--rectangle-left)))
-        (move-to-column (cua--rectangle-right) pad))
+        (cua--rectangle-right (1+ (cua--rectangle-right)))
+        (move-to-column (cua--rectangle-right)))
        (t
-        (forward-char 1)
-        (cua--rectangle-left (current-column)))))
+        (cua--rectangle-left (1+ (cua--rectangle-left)))
+        (move-to-column (cua--rectangle-right)))))
     (if resized
         (cua--rectangle-resized))))
 
 (defun cua-resize-rectangle-left (n)
   "Resize rectangle to the left."
   (interactive "p")
-  (let ((pad (cua--rectangle-padding)) resized)
+  (let (resized)
     (while (> n 0)
       (setq n (1- n))
       (if (or (= (cua--rectangle-right) 0)
               (and (not (cua--rectangle-right-side)) (= (cua--rectangle-left) 0)))
           (setq n 0)
         (cond
-         ((and (cua--rectangle-right-side) (or pad (eolp) (bolp)))
-          (cua--rectangle-right (1- (cua--rectangle-right)))
-          (move-to-column (cua--rectangle-right) pad))
          ((cua--rectangle-right-side)
-          (backward-char 1)
-          (cua--rectangle-right (current-column)))
-         ((or pad (eolp) (bolp))
-          (cua--rectangle-left (1- (cua--rectangle-left)))
-          (move-to-column (cua--rectangle-right) pad))
+          (cua--rectangle-right (1- (cua--rectangle-right)))
+          (move-to-column (cua--rectangle-right)))
          (t
-          (backward-char 1)
-          (cua--rectangle-left (current-column))))
+          (cua--rectangle-left (1- (cua--rectangle-left)))
+          (move-to-column (cua--rectangle-right))))
         (setq resized t)))
     (if resized
         (cua--rectangle-resized))))
@@ -342,20 +329,20 @@ Knows about CUA rectangle highlighting in addition to standard undo."
 (defun cua-resize-rectangle-down (n)
   "Resize rectangle downwards."
   (interactive "p")
-  (let ((pad (cua--rectangle-padding)) resized)
+  (let (resized)
     (while (> n 0)
       (setq n (1- n))
       (cond
        ((>= (cua--rectangle-corner) 2)
         (goto-char (cua--rectangle-bot))
-        (when (cua--forward-line 1 pad)
-          (move-to-column (cua--rectangle-column) pad)
+        (when (cua--forward-line 1)
+          (move-to-column (cua--rectangle-column))
           (cua--rectangle-bot t)
           (setq resized t)))
        (t
         (goto-char (cua--rectangle-top))
-        (when (cua--forward-line 1 pad)
-          (move-to-column (cua--rectangle-column) pad)
+        (when (cua--forward-line 1)
+          (move-to-column (cua--rectangle-column))
           (cua--rectangle-top t)
           (setq resized t)))))
     (if resized
@@ -364,20 +351,20 @@ Knows about CUA rectangle highlighting in addition to standard undo."
 (defun cua-resize-rectangle-up (n)
   "Resize rectangle upwards."
   (interactive "p")
-  (let ((pad (cua--rectangle-padding)) resized)
+  (let (resized)
     (while (> n 0)
       (setq n (1- n))
       (cond
        ((>= (cua--rectangle-corner) 2)
         (goto-char (cua--rectangle-bot))
-        (when (cua--forward-line -1 pad)
-          (move-to-column (cua--rectangle-column) pad)
+        (when (cua--forward-line -1)
+          (move-to-column (cua--rectangle-column))
           (cua--rectangle-bot t)
           (setq resized t)))
        (t
         (goto-char (cua--rectangle-top))
-        (when (cua--forward-line -1 pad)
-          (move-to-column (cua--rectangle-column) pad)
+        (when (cua--forward-line -1)
+          (move-to-column (cua--rectangle-column))
           (cua--rectangle-top t)
           (setq resized t)))))
     (if resized
@@ -408,7 +395,7 @@ Knows about CUA rectangle highlighting in addition to standard undo."
   "Resize rectangle to bottom of buffer."
   (interactive)
   (goto-char (point-max))
-  (move-to-column (cua--rectangle-column) (cua--rectangle-padding))
+  (move-to-column (cua--rectangle-column))
   (cua--rectangle-bot t)
   (cua--rectangle-resized))
 
@@ -416,31 +403,29 @@ Knows about CUA rectangle highlighting in addition to standard undo."
   "Resize rectangle to top of buffer."
   (interactive)
   (goto-char (point-min))
-  (move-to-column (cua--rectangle-column) (cua--rectangle-padding))
+  (move-to-column (cua--rectangle-column))
   (cua--rectangle-top t)
   (cua--rectangle-resized))
 
 (defun cua-resize-rectangle-page-up ()
   "Resize rectangle upwards by one scroll page."
   (interactive)
-  (let ((pad (cua--rectangle-padding)))
-    (scroll-down)
-    (move-to-column (cua--rectangle-column) pad)
-    (if (>= (cua--rectangle-corner) 2)
-        (cua--rectangle-bot t)
-      (cua--rectangle-top t))
-    (cua--rectangle-resized)))
+  (scroll-down)
+  (move-to-column (cua--rectangle-column))
+  (if (>= (cua--rectangle-corner) 2)
+      (cua--rectangle-bot t)
+    (cua--rectangle-top t))
+  (cua--rectangle-resized))
 
 (defun cua-resize-rectangle-page-down ()
   "Resize rectangle downwards by one scroll page."
   (interactive)
-  (let ((pad (cua--rectangle-padding)))
-    (scroll-up)
-    (move-to-column (cua--rectangle-column) pad)
-    (if (>= (cua--rectangle-corner) 2)
-        (cua--rectangle-bot t)
-      (cua--rectangle-top t))
-    (cua--rectangle-resized)))
+  (scroll-up)
+  (move-to-column (cua--rectangle-column))
+  (if (>= (cua--rectangle-corner) 2)
+      (cua--rectangle-bot t)
+    (cua--rectangle-top t))
+  (cua--rectangle-resized))
 
 ;;; Mouse support
 
@@ -450,7 +435,8 @@ Knows about CUA rectangle highlighting in addition to standard undo."
   "Set rectangle corner at mouse click position."
   (interactive "e")
   (mouse-set-point event)
-  (if (cua--rectangle-padding)
+  ;; FIX ME -- need to calculate virtual column.
+  (if (cua--rectangle-virtual-edges)
       (move-to-column (car (posn-col-row (event-end event))) t))
   (if (cua--rectangle-right-side)
       (cua--rectangle-right (current-column))
@@ -470,6 +456,7 @@ Knows about CUA rectangle highlighting in addition to standard undo."
     (cua--deactivate t))
   (setq cua--last-rectangle nil)
   (mouse-set-point event)
+  ;; FIX ME -- need to calculate virtual column.
   (cua-set-rectangle-mark)
   (setq cua--buffer-and-point-before-command nil)
   (setq cua--mouse-last-pos nil))
@@ -489,13 +476,13 @@ If command is repeated at same position, delete the rectangle."
     (let ((cua-keep-region-after-copy t))
       (cua-copy-rectangle arg)
       (setq cua--mouse-last-pos (cons (point) cua--last-killed-rectangle)))))
+
 (defun cua--mouse-ignore (event)
   (interactive "e")
   (setq this-command last-command))
 
 (defun cua--rectangle-move (dir)
-  (let ((pad (cua--rectangle-padding))
-        (moved t)
+  (let ((moved t)
         (top (cua--rectangle-top))
         (bot (cua--rectangle-bot))
         (l (cua--rectangle-left))
@@ -503,17 +490,17 @@ If command is repeated at same position, delete the rectangle."
     (cond
      ((eq dir 'up)
       (goto-char top)
-      (when (cua--forward-line -1 pad)
+      (when (cua--forward-line -1)
         (cua--rectangle-top t)
         (goto-char bot)
         (forward-line -1)
         (cua--rectangle-bot t)))
      ((eq dir 'down)
       (goto-char bot)
-      (when (cua--forward-line 1 pad)
+      (when (cua--forward-line 1)
         (cua--rectangle-bot t)
         (goto-char top)
-        (cua--forward-line 1 pad)
+        (cua--forward-line 1)
         (cua--rectangle-top t)))
      ((eq dir 'left)
       (when (> l 0)
@@ -526,19 +513,37 @@ If command is repeated at same position, delete the rectangle."
       (setq moved nil)))
     (when moved
       (setq cua--buffer-and-point-before-command nil)
-      (cua--pad-rectangle)
       (cua--rectangle-set-corners)
       (cua--keep-active))))
 
 
 ;;; Operations on current rectangle
 
-(defun cua--rectangle-operation (keep-clear visible undo pad &optional fct post-fct)
+(defun cua--tabify-start (start end)
+  ;; Return position where auto-tabify should start (or nil if not required).
+  (save-excursion
+    (save-restriction
+      (widen)
+      (and (not buffer-read-only)
+           cua-auto-tabify-rectangles
+           (if (or (not (integerp cua-auto-tabify-rectangles))
+                   (= (point-min) (point-max))
+                   (progn
+                     (goto-char (max (point-min)
+                                     (- start cua-auto-tabify-rectangles)))
+                     (search-forward "\t" (min (point-max)
+                                               (+ end cua-auto-tabify-rectangles)) t)))
+               start)))))
+
+(defun cua--rectangle-operation (keep-clear visible undo pad tabify &optional fct post-fct)
   ;; Call FCT for each line of region with 4 parameters:
   ;; Region start, end, left-col, right-col
   ;; Point is at start when FCT is called
+  ;; Call fct with (s,e) = whole lines if VISIBLE non-nil.
+  ;; Only call fct for visible lines if VISIBLE==t.
   ;; Set undo boundary if UNDO is non-nil.
-  ;; Rectangle is padded if PAD = t or numeric and (cua--rectangle-padding)
+  ;; Rectangle is padded if PAD = t or numeric and (cua--rectangle-virtual-edges)
+  ;; Perform auto-tabify after operation if TABIFY is non-nil.
   ;; Mark is kept if keep-clear is 'keep and cleared if keep-clear is 'clear.
   (let* ((start (cua--rectangle-top))
          (end   (cua--rectangle-bot))
@@ -546,11 +551,12 @@ If command is repeated at same position, delete the rectangle."
          (r (1+ (cua--rectangle-right)))
          (m (make-marker))
          (tabpad (and (integerp pad) (= pad 2)))
-         (sel (cua--rectangle-restriction)))
+         (sel (cua--rectangle-restriction))
+         (tabify-start (and tabify (cua--tabify-start start end))))
     (if undo
         (cua--rectangle-undo-boundary))
     (if (integerp pad)
-        (setq pad (cua--rectangle-padding)))
+        (setq pad (cua--rectangle-virtual-edges)))
     (save-excursion
       (save-restriction
         (widen)
@@ -558,7 +564,7 @@ If command is repeated at same position, delete the rectangle."
           (goto-char end)
           (and (bolp) (not (eolp)) (not (eobp))
                (setq end (1+ end))))
-        (when visible
+        (when (eq visible t)
           (setq start (max (window-start) start))
           (setq end   (min (window-end) end)))
         (goto-char end)
@@ -575,7 +581,7 @@ If command is repeated at same position, delete the rectangle."
               (forward-char 1))
           (set-marker m (point))
           (move-to-column l pad)
-          (if (and fct (>= (current-column) l) (<= (current-column) r))
+          (if (and fct (or visible (and (>= (current-column) l) (<= (current-column) r))))
               (let ((v t) (p (point)))
                 (when sel
                   (if (car (cdr sel))
@@ -585,8 +591,7 @@ If command is repeated at same position, delete the rectangle."
                   (if (car (cdr (cdr sel)))
                       (setq v (null v))))
                 (if visible
-                    (unless (eolp)
-                        (funcall fct p m l r v))
+                    (funcall fct p m l r v)
                   (if v
                       (funcall fct p m l r)))))
           (set-marker m nil)
@@ -594,7 +599,9 @@ If command is repeated at same position, delete the rectangle."
         (if (not visible)
             (cua--rectangle-bot t))
         (if post-fct
-            (funcall post-fct l r))))
+            (funcall post-fct l r))
+        (when tabify-start
+          (tabify tabify-start (point)))))
     (cond
      ((eq keep-clear 'keep)
       (cua--keep-active))
@@ -607,48 +614,96 @@ If command is repeated at same position, delete the rectangle."
 
 (put 'cua--rectangle-operation 'lisp-indent-function 4)
 
-(defun cua--pad-rectangle (&optional pad)
-  (if (or pad (cua--rectangle-padding))
-      (cua--rectangle-operation nil nil t t)))
-
 (defun cua--delete-rectangle ()
-  (cua--rectangle-operation nil nil t 2
-    '(lambda (s e l r)
-       (if (and (> e s) (<= e (point-max)))
-           (delete-region s e)))))
+  (let ((lines 0))
+    (if (not (cua--rectangle-virtual-edges))
+        (cua--rectangle-operation nil nil t 2 t
+          '(lambda (s e l r v)
+             (setq lines (1+ lines))
+             (if (and (> e s) (<= e (point-max)))
+                 (delete-region s e))))
+      (cua--rectangle-operation nil 1 t nil t
+        '(lambda (s e l r v)
+           (setq lines (1+ lines))
+           (when (and (> e s) (<= e (point-max)))
+             (delete-region s e)))))
+    lines))
 
 (defun cua--extract-rectangle ()
   (let (rect)
-    (cua--rectangle-operation nil nil nil 1
-     '(lambda (s e l r)
-        (setq rect (cons (buffer-substring-no-properties s e) rect))))
-      (nreverse rect)))
-
-(defun cua--insert-rectangle (rect &optional below)
+    (if (not (cua--rectangle-virtual-edges))
+        (cua--rectangle-operation nil nil nil nil nil ; do not tabify
+          '(lambda (s e l r)
+             (setq rect (cons (buffer-substring-no-properties s e) rect))))
+      (cua--rectangle-operation nil 1 nil nil nil ; do not tabify
+        '(lambda (s e l r v)
+           (let ((copy t) (bs 0) (as 0) row)
+             (if (= s e) (setq e (1+ e)))
+             (goto-char s)
+             (move-to-column l)
+             (if (= (point) (line-end-position))
+                 (setq bs (- r l)
+                       copy nil)
+               (skip-chars-forward "\s\t" e)
+               (setq bs (- (min r (current-column)) l)
+                     s (point))
+               (move-to-column r)
+               (skip-chars-backward "\s\t" s)
+               (setq as (- r (max (current-column) l))
+                     e (point)))
+             (setq row (if (and copy (> e s))
+                           (buffer-substring-no-properties s e)
+                         ""))
+             (when (> bs 0)
+               (setq row (concat (make-string bs ?\s) row)))
+             (when (> as 0)
+               (setq row (concat row (make-string as ?\s))))
+             (setq rect (cons row rect))))))
+    (nreverse rect)))
+
+(defun cua--insert-rectangle (rect &optional below paste-column line-count)
   ;; Insert rectangle as insert-rectangle, but don't set mark and exit with
   ;; point at either next to top right or below bottom left corner
   ;; Notice: In overwrite mode, the rectangle is inserted as separate text lines.
-  (if (and below (eq below 'auto))
+  (if (eq below 'auto)
       (setq below (and (bolp)
                        (or (eolp) (eobp) (= (1+ (point)) (point-max))))))
+  (unless paste-column
+    (setq paste-column (current-column)))
   (let ((lines rect)
-        (insertcolumn (current-column))
         (first t)
+        (tabify-start (cua--tabify-start (point) (point)))
+        last-column
         p)
     (while (or lines below)
       (or first
           (if overwrite-mode
               (insert ?\n)
             (forward-line 1)
-            (or (bolp) (insert ?\n))
-            (move-to-column insertcolumn t)))
+            (or (bolp) (insert ?\n))))
+      (unless overwrite-mode
+        (move-to-column paste-column t))
       (if (not lines)
           (setq below nil)
         (insert-for-yank (car lines))
+        (unless last-column
+          (setq last-column (current-column)))
         (setq lines (cdr lines))
         (and first (not below)
              (setq p (point))))
-      (setq first nil))
+      (setq first nil)
+      (if (and line-count (= (setq line-count (1- line-count)) 0))
+          (setq lines nil)))
+    (when (and line-count last-column (not overwrite-mode))
+      (while (> line-count 0)
+        (forward-line 1)
+        (or (bolp) (insert ?\n))
+        (move-to-column paste-column t)
+        (insert-char ?\s (- last-column paste-column -1))
+        (setq line-count (1- line-count))))
+    (when (and tabify-start
+               (not overwrite-mode))
+      (tabify tabify-start (point)))
     (and p (not overwrite-mode)
          (goto-char p))))
 
@@ -662,7 +717,7 @@ If command is repeated at same position, delete the rectangle."
                    (function (lambda (row) (concat row "\n")))
                    killed-rectangle "")))))
 
-(defun cua--activate-rectangle (&optional force)
+(defun cua--activate-rectangle ()
   ;; Turn on rectangular marking mode by disabling transient mark mode
   ;; and manually handling highlighting from a post command hook.
   ;; Be careful if we are already marking a rectangle.
@@ -671,12 +726,8 @@ If command is repeated at same position, delete the rectangle."
                  (eq (car cua--last-rectangle) (current-buffer))
                  (eq (car (cdr cua--last-rectangle)) (point)))
             (cdr (cdr cua--last-rectangle))
-          (cua--rectangle-get-corners
-           (and (not buffer-read-only)
-                (or cua-auto-expand-rectangles
-                    force
-                    (eq major-mode 'picture-mode)))))
-        cua--status-string (if (cua--rectangle-padding) " Pad" "")
+          (cua--rectangle-get-corners))
+        cua--status-string (if (cua--rectangle-virtual-edges) " [R]" "")
         cua--last-rectangle nil))
 
 ;; (defvar cua-save-point nil)
@@ -698,7 +749,7 @@ If command is repeated at same position, delete the rectangle."
   ;; Each overlay extends across all the columns of the rectangle.
   ;; We try to reuse overlays where possible because this is more efficient
   ;; and results in less flicker.
-  ;; If cua--rectangle-padding is nil and the buffer contains tabs or short lines,
+  ;; If cua--rectangle-virtual-edges is nil and the buffer contains tabs or short lines,
   ;; the higlighted region may not be perfectly rectangular.
   (let ((deactivate-mark deactivate-mark)
         (old cua--rectangle-overlays)
@@ -707,12 +758,59 @@ If command is repeated at same position, delete the rectangle."
         (right (1+ (cua--rectangle-right))))
     (when (/= left right)
       (sit-for 0)  ; make window top/bottom reliable
-      (cua--rectangle-operation nil t nil nil
+      (cua--rectangle-operation nil t nil nil nil ; do not tabify
         '(lambda (s e l r v)
            (let ((rface (if v 'cua-rectangle-face 'cua-rectangle-noselect-face))
-                 overlay)
-             ;; Trim old leading overlays.
+                 overlay bs as)
              (if (= s e) (setq e (1+ e)))
+             (when (cua--rectangle-virtual-edges)
+               (let ((lb (line-beginning-position))
+                     (le (line-end-position))
+                     cl cl0 pl cr cr0 pr)
+                 (goto-char s)
+                 (setq cl (move-to-column l)
+                       pl (point))
+                 (setq cr (move-to-column r)
+                       pr (point))
+                 (if (= lb pl)
+                     (setq cl0 0)
+                   (goto-char (1- pl))
+                   (setq cl0 (current-column)))
+                 (if (= lb le)
+                     (setq cr0 0)
+                   (goto-char (1- pr))
+                   (setq cr0 (current-column)))
+                 (unless (and (= cl l) (= cr r))
+                   (when (/= cl l)
+                     (setq bs (propertize
+                               (make-string
+                                (- l cl0 (if (and (= le pl) (/= le lb)) 1 0))
+                                (if cua--virtual-edges-debug ?. ?\s))
+                               'face 'default))
+                     (if (/= pl le)
+                         (setq s (1- s))))
+                   (cond
+                    ((= cr r)
+                     (if (and (/= cr0 (1- cr))
+                              (= (mod cr tab-width) 0))
+                         (setq e (1- e))))
+                    ((= cr cl)
+                     (setq bs (concat bs
+                                      (propertize
+                                       (make-string
+                                        (- r l)
+                                        (if cua--virtual-edges-debug ?, ?\s))
+                                       'face rface)))
+                     (setq rface nil))
+                    (t
+                     (setq as (propertize
+                               (make-string
+                                (- r cr0 (if (= le pr) 1 0))
+                                (if cua--virtual-edges-debug ?~ ?\s))
+                               'face rface))
+                     (if (/= pr le)
+                         (setq e (1- e))))))))
+             ;; Trim old leading overlays.
              (while (and old
                          (setq overlay (car old))
                          (< (overlay-start overlay) s)
@@ -728,8 +826,10 @@ If command is repeated at same position, delete the rectangle."
                    (move-overlay overlay s e)
                    (setq old (cdr old)))
                (setq overlay (make-overlay s e)))
-             (overlay-put overlay 'face rface)
-             (setq new (cons overlay new))))))
+             (overlay-put overlay 'before-string bs)
+             (overlay-put overlay 'after-string as)
+             (overlay-put overlay 'face rface)
+             (setq new (cons overlay new))))))
     ;; Trim old trailing overlays.
     (mapcar (function delete-overlay) old)
     (setq cua--rectangle-overlays (nreverse new))))
@@ -737,9 +837,9 @@ If command is repeated at same position, delete the rectangle."
 (defun cua--indent-rectangle (&optional ch to-col clear)
   ;; Indent current rectangle.
   (let ((col (cua--rectangle-insert-col))
-        (pad (cua--rectangle-padding))
+        (pad (cua--rectangle-virtual-edges))
         indent)
-    (cua--rectangle-operation (if clear 'clear 'corners) nil t pad
+    (cua--rectangle-operation (if clear 'clear 'corners) nil t pad t
       '(lambda (s e l r)
          (move-to-column col pad)
          (if (and (eolp)
@@ -877,21 +977,18 @@ With prefix argument, the toggle restriction."
   (cua--rectangle-corner (if (= (cua--rectangle-left) (cua--rectangle-right)) 0 1))
   (cua--rectangle-set-corners))
 
-(defun cua-toggle-rectangle-padding ()
+(defun cua-toggle-rectangle-virtual-edges ()
   (interactive)
-  (if buffer-read-only
-      (message "Cannot do padding in read-only buffer.")
-    (cua--rectangle-padding t (not (cua--rectangle-padding)))
-    (cua--pad-rectangle)
-    (cua--rectangle-set-corners))
-  (setq cua--status-string (and (cua--rectangle-padding) " Pad"))
+  (cua--rectangle-virtual-edges t (not (cua--rectangle-virtual-edges)))
+  (cua--rectangle-set-corners)
+  (setq cua--status-string (and (cua--rectangle-virtual-edges) " [R]"))
   (cua--keep-active))
 
 (defun cua-do-rectangle-padding ()
   (interactive)
   (if buffer-read-only
       (message "Cannot do padding in read-only buffer.")
-    (cua--pad-rectangle t)
+    (cua--rectangle-operation nil nil t t t)
     (cua--rectangle-set-corners))
   (cua--keep-active))
 
@@ -900,7 +997,7 @@ With prefix argument, the toggle restriction."
 The text previously in the region is not overwritten by the blanks,
 but instead winds up to the right of the rectangle."
   (interactive)
-  (cua--rectangle-operation 'corners nil t 1
+  (cua--rectangle-operation 'corners nil t 1 nil
    '(lambda (s e l r)
       (skip-chars-forward " \t")
       (let ((ws (- (current-column) l))
@@ -915,7 +1012,7 @@ On each line in the rectangle, all continuous whitespace starting
 at that column is deleted.
 With prefix arg, also delete whitespace to the left of that column."
   (interactive "P")
-  (cua--rectangle-operation 'clear nil t 1
+  (cua--rectangle-operation 'clear nil t 1 nil
    '(lambda (s e l r)
       (when arg
         (skip-syntax-backward " " (line-beginning-position))
@@ -927,7 +1024,7 @@ With prefix arg, also delete whitespace to the left of that column."
   "Blank out CUA rectangle.
 The text previously in the rectangle is overwritten by the blanks."
   (interactive)
-  (cua--rectangle-operation 'keep nil nil 1
+  (cua--rectangle-operation 'keep nil nil 1 nil
    '(lambda (s e l r)
       (goto-char e)
       (skip-syntax-forward " " (line-end-position))
@@ -942,7 +1039,7 @@ The text previously in the rectangle is overwritten by the blanks."
   "Align rectangle lines to left column."
   (interactive)
   (let (x)
-    (cua--rectangle-operation 'clear nil t t
+    (cua--rectangle-operation 'clear nil t t nil
      '(lambda (s e l r)
         (let ((b (line-beginning-position)))
           (skip-syntax-backward "^ " b)
@@ -984,7 +1081,7 @@ The text previously in the rectangle is overwritten by the blanks."
   "Replace CUA rectangle contents with STRING on each line.
 The length of STRING need not be the same as the rectangle width."
   (interactive "sString rectangle: ")
-  (cua--rectangle-operation 'keep nil t t
+  (cua--rectangle-operation 'keep nil t t nil
      '(lambda (s e l r)
         (delete-region s e)
         (skip-chars-forward " \t")
@@ -999,7 +1096,7 @@ The length of STRING need not be the same as the rectangle width."
 (defun cua-fill-char-rectangle (ch)
   "Replace CUA rectangle contents with CHARACTER."
   (interactive "cFill rectangle with character: ")
-  (cua--rectangle-operation 'clear nil t 1
+  (cua--rectangle-operation 'clear nil t 1 nil
    '(lambda (s e l r)
       (delete-region s e)
       (move-to-column l t)
@@ -1010,7 +1107,7 @@ The length of STRING need not be the same as the rectangle width."
   (interactive "sReplace regexp: \nsNew text: ")
   (if buffer-read-only
       (message "Cannot replace in read-only buffer")
-    (cua--rectangle-operation 'keep nil t 1
+    (cua--rectangle-operation 'keep nil t 1 nil
      '(lambda (s e l r)
         (if (re-search-forward regexp e t)
             (replace-match newtext nil nil))))))
@@ -1018,7 +1115,7 @@ The length of STRING need not be the same as the rectangle width."
 (defun cua-incr-rectangle (increment)
   "Increment each line of CUA rectangle by prefix amount."
   (interactive "p")
-  (cua--rectangle-operation 'keep nil t 1
+  (cua--rectangle-operation 'keep nil t 1 nil
      '(lambda (s e l r)
         (cond
          ((re-search-forward "0x\\([0-9a-fA-F]+\\)" e t)
@@ -1051,36 +1148,36 @@ The numbers are formatted according to the FORMAT string."
   (if (= (length fmt) 0)
       (setq fmt cua--rectangle-seq-format)
     (setq cua--rectangle-seq-format fmt))
-  (cua--rectangle-operation 'clear nil t 1
+  (cua--rectangle-operation 'clear nil t 1 nil
      '(lambda (s e l r)
          (delete-region s e)
          (insert (format fmt first))
          (setq first (+ first incr)))))
 
-(defmacro cua--convert-rectangle-as (command)
-  `(cua--rectangle-operation 'clear nil nil nil
+(defmacro cua--convert-rectangle-as (command tabify)
+  `(cua--rectangle-operation 'clear nil nil nil ,tabify
     '(lambda (s e l r)
        (,command s e))))
 
 (defun cua-upcase-rectangle ()
   "Convert the rectangle to upper case."
   (interactive)
-  (cua--convert-rectangle-as upcase-region))
+  (cua--convert-rectangle-as upcase-region nil))
 
 (defun cua-downcase-rectangle ()
   "Convert the rectangle to lower case."
   (interactive)
-  (cua--convert-rectangle-as downcase-region))
+  (cua--convert-rectangle-as downcase-region nil))
 
 (defun cua-upcase-initials-rectangle ()
   "Convert the rectangle initials to upper case."
   (interactive)
-  (cua--convert-rectangle-as upcase-initials-region))
+  (cua--convert-rectangle-as upcase-initials-region nil))
 
 (defun cua-capitalize-rectangle ()
   "Convert the rectangle to proper case."
   (interactive)
-  (cua--convert-rectangle-as capitalize-region))
+  (cua--convert-rectangle-as capitalize-region nil))
 
 
 ;;; Replace/rearrange text in current rectangle
@@ -1116,7 +1213,7 @@ The numbers are formatted according to the FORMAT string."
       (setq z (reverse z))
       (if cua--debug
           (print z auxbuf))
-      (cua--rectangle-operation nil nil t pad
+      (cua--rectangle-operation nil nil t pad nil
         '(lambda (s e l r)
            (let (cc)
              (goto-char e)
@@ -1232,9 +1329,9 @@ With prefix arg, indent to that column."
   "Delete char to left or right of rectangle."
   (interactive)
   (let ((col (cua--rectangle-insert-col))
-        (pad (cua--rectangle-padding))
+        (pad (cua--rectangle-virtual-edges))
         indent)
-    (cua--rectangle-operation 'corners nil t pad
+    (cua--rectangle-operation 'corners nil t pad nil
      '(lambda (s e l r)
         (move-to-column
          (if (cua--rectangle-right-side t)
@@ -1282,10 +1379,7 @@ With prefix arg, indent to that column."
         (cua--rectangle-left (current-column)))
       (if (>= (cua--rectangle-corner) 2)
           (cua--rectangle-bot t)
-        (cua--rectangle-top t))
-      (if (cua--rectangle-padding)
-          (setq unread-command-events
-                (cons (if cua-use-hyper-key ?\H-P ?\M-P) unread-command-events)))))
+        (cua--rectangle-top t))))
   (if cua--rectangle
       (if (and mark-active
                (not deactivate-mark))
@@ -1379,7 +1473,7 @@ With prefix arg, indent to that column."
   (cua--rect-M/H-key ?m 'cua-copy-rectangle-as-text)
   (cua--rect-M/H-key ?n 'cua-sequence-rectangle)
   (cua--rect-M/H-key ?o 'cua-open-rectangle)
-  (cua--rect-M/H-key ?p 'cua-toggle-rectangle-padding)
+  (cua--rect-M/H-key ?p 'cua-toggle-rectangle-virtual-edges)
   (cua--rect-M/H-key ?P 'cua-do-rectangle-padding)
   (cua--rect-M/H-key ?q 'cua-refill-rectangle)
   (cua--rect-M/H-key ?r 'cua-replace-in-rectangle)
diff --git a/lisp/ielm.el b/lisp/ielm.el
index 944e2453cb9..96969bfc878 100644
--- a/lisp/ielm.el
+++ b/lisp/ielm.el
@@ -198,7 +198,7 @@ This variable is buffer-local.")
 ;;; Completion stuff
 
 (defun ielm-tab nil
-  "Possibly indent the current line as lisp code."
+  "Possibly indent the current line as Lisp code."
   (interactive)
   (if (or (eq (preceding-char) ?\n)
           (eq (char-syntax (preceding-char)) ? ))
@@ -207,7 +207,7 @@ This variable is buffer-local.")
         t)))
 
 (defun ielm-complete-symbol nil
-  "Complete the lisp symbol before point."
+  "Complete the Lisp symbol before point."
   ;; A wrapper for lisp-complete symbol that returns non-nil if
   ;; completion has occurred
   (let* ((btick (buffer-modified-tick))
@@ -528,7 +528,7 @@ Customized bindings may be defined in `ielm-map', which currently contains:
     (condition-case nil
         (start-process "ielm" (current-buffer) "hexl")
       (file-error (start-process "ielm" (current-buffer) "cat")))
-    (process-kill-without-query (ielm-process))
+    (set-process-query-on-exit-flag (ielm-process) nil)
     (goto-char (point-max))
 
     ;; Lisp output can include raw characters that confuse comint's
diff --git a/lisp/indent.el b/lisp/indent.el
index e56db11b6f1..2d223b05ad6 100644
--- a/lisp/indent.el
+++ b/lisp/indent.el
@@ -442,8 +442,8 @@ This should be a list of integers, ordered from smallest to largest."
   "Keymap used in `edit-tab-stops'.")
 
 (defvar edit-tab-stops-buffer nil
-  "Buffer whose tab stops are being edited--in case
-the variable `tab-stop-list' is local in that buffer.")
+  "Buffer whose tab stops are being edited.
+This matters if the variable `tab-stop-list' is local in that buffer.")
 
 (defun edit-tab-stops ()
   "Edit the tab stops used by `tab-to-tab-stop'.
diff --git a/lisp/international/utf-8.el b/lisp/international/utf-8.el
index bad79b58743..5a7acee0f0e 100644
--- a/lisp/international/utf-8.el
+++ b/lisp/international/utf-8.el
@@ -870,7 +870,9 @@ Also compose particular scripts if `utf-8-compose-scripts' is non-nil."
       ;; version of the string in the loop, since it's always loaded as
       ;; unibyte from a byte-compiled file.
       (let ((range (string-as-multibyte "^\xc0-\xc3\xe1-\xf7"))
+            (buffer-multibyte enable-multibyte-characters)
             hash-table ch)
+        (set-buffer-multibyte t)
         (when utf-translate-cjk-mode
           (if (not utf-translate-cjk-lang-env)
               ;; Check these characters:
@@ -893,7 +895,9 @@ Also compose particular scripts if `utf-8-compose-scripts' is non-nil."
                 (progn
                   (insert ch)
                   (delete-char 1))
-              (forward-char 1)))))
+              (forward-char 1))))
+        (or buffer-multibyte
+            (set-buffer-multibyte nil)))
 
       (when (and utf-8-compose-scripts (> length 1))
         ;; These currently have definitions which cover the relevant
diff --git a/lisp/mh-e/ChangeLog b/lisp/mh-e/ChangeLog
index 990291caead..dd1062da816 100644
--- a/lisp/mh-e/ChangeLog
+++ b/lisp/mh-e/ChangeLog
@@ -1,5 +1,40 @@
 2004-08-21  Bill Wohler  <wohler@newt.com>
 
+        * Released MH-E version 7.82.
+     
+        * MH-E-NEWS, README: Updated for release 7.82.
+     
+        * mh-e.el (Version, mh-version): Updated for release 7.82.
+
+2004-08-24  Bill Wohler  <wohler@newt.com>
+
+        * mh-init.el (mh-variant-set): Changed MH to mh as that's what is
+        emitted by `mh-variant-mh-info' (closes SF #1014781).
+        (mh-variant-p): Added mu-mh to docstring.
+
+2004-08-23  Satyaki Das  <satyaki@theforce.stanford.edu>
+
+        * mh-acros.el (mh-require-cl): Remove unneeded autoloads.
+        (require): Add an advice to the function so that at compile time
+        the uncompiled file is loaded. This avoids compilation problems
+        when built in the Emacs tree.
+
+        * mh-mime.el (mh-identity-pgg-default-user-id): Defvar the
+        variable, to avoid compiler warnings.
+
+        * mh-e.el (mh-seq): Load mh-seq since functions defined there are
+        used here. Without this, the state mh-seq.elc would be loaded.
+
+        * mh-customize.el (mh-init, mh-identity): Load mh-init and
+        mh-identity at compile time manually, before the corresponding
+        stale elc files get autoloaded.
+
+2004-08-21  Bill Wohler  <wohler@newt.com>
+
+        * mh-e.el (Version, mh-version): Added +cvs to release number.
+
+2004-08-21  Bill Wohler  <wohler@newt.com>
+
         * Released MH-E version 7.81.
      
         * MH-E-NEWS, README: Updated for release 7.81.
diff --git a/lisp/mh-e/mh-acros.el b/lisp/mh-e/mh-acros.el
index dd8660a8ce3..16383304503 100644
--- a/lisp/mh-e/mh-acros.el
+++ b/lisp/mh-e/mh-acros.el
@@ -51,12 +51,7 @@ Some versions of `cl' produce code for the expansion of
 \(setf (gethash ...) ...) that uses functions in `cl' at run time.  This macro
 recognizes that and loads `cl' where appropriate."
   (if (eq (car (macroexpand '(setf (gethash foo bar) baz))) 'cl-puthash)
-      `(progn
-         (require 'cl)
-         ;; Autoloads of CL functions go here...
-         (autoload 'cl-puthash "cl")
-         (autoload 'values "cl")
-         (autoload 'copy-tree "cl"))
+      `(require 'cl)
     `(eval-when-compile (require 'cl))))
 
 ;;; Macros to generate correct code for different emacs variants
@@ -130,6 +125,12 @@ various structure fields. Lookup `defstruct' for more details."
                           (list 'nth ,x z)))
        (quote ,struct-name))))
 
+(defadvice require (around mh-prefer-el activate)
+  "Modify `require' to load uncompiled MH-E files."
+  (or (featurep (ad-get-arg 0))
+      (and (string-match "^mh-" (symbol-name (ad-get-arg 0)))
+           (load (format "%s.el" (ad-get-arg 0)) t t))
+      ad-do-it))
 
 (provide 'mh-acros)
 
diff --git a/lisp/mh-e/mh-customize.el b/lisp/mh-e/mh-customize.el
index 67a126a8327..622c457897f 100644
--- a/lisp/mh-e/mh-customize.el
+++ b/lisp/mh-e/mh-customize.el
@@ -78,6 +78,13 @@
 (when mh-xemacs-flag
   (require 'mh-xemacs))
 
+;; XXX: Functions autoloaded from the following files are used to initialize
+;;  customizable variables. They are require'd here, since otherwise the
+;;  corresponding .elc would be loaded at compile time.
+(eval-when-compile
+  (require 'mh-init)
+  (require 'mh-identity))
+
 (defun mh-customize (&optional delete-other-windows-flag)
   "Customize MH-E variables.
 If optional argument DELETE-OTHER-WINDOWS-FLAG is non-nil, other windows in
diff --git a/lisp/mh-e/mh-e.el b/lisp/mh-e/mh-e.el
index 5cbb97b72d0..2081d49b6cd 100644
--- a/lisp/mh-e/mh-e.el
+++ b/lisp/mh-e/mh-e.el
@@ -5,7 +5,7 @@
 
 ;; Author: Bill Wohler <wohler@newt.com>
 ;; Maintainer: Bill Wohler <wohler@newt.com>
-;; Version: 7.81
+;; Version: 7.82
 ;; Keywords: mail
 
 ;; This file is part of GNU Emacs.
@@ -89,6 +89,7 @@
 (require 'mh-utils)
 (require 'mh-init)
 (require 'mh-inc)
+(require 'mh-seq)
 (require 'gnus-util)
 (require 'easymenu)
 
@@ -96,7 +97,7 @@
 (defvar font-lock-auto-fontify)
 (defvar font-lock-defaults)
 
-(defconst mh-version "7.81" "Version number of MH-E.")
+(defconst mh-version "7.82" "Version number of MH-E.")
 
 ;;; Autoloads
 (autoload 'Info-goto-node "info")
diff --git a/lisp/mh-e/mh-init.el b/lisp/mh-e/mh-init.el
index ac7305fa217..a975b882128 100644
--- a/lisp/mh-e/mh-init.el
+++ b/lisp/mh-e/mh-init.el
@@ -90,7 +90,7 @@ GNU mailutils."
       (cond
        ((mh-variant-set-variant 'nmh)
         (message "%s installed as MH variant" mh-variant-in-use))
-       ((mh-variant-set-variant 'MH)
+       ((mh-variant-set-variant 'mh)
         (message "%s installed as MH variant" mh-variant-in-use))
        ((mh-variant-set-variant 'mu-mh)
         (message "%s installed as MH variant" mh-variant-in-use))
@@ -145,7 +145,7 @@ If VARIANT is a symbol, select the first entry that matches that variant."
 ;;;###mh-autoload
 (defun mh-variant-p (&rest variants)
   "Return t if variant is any of VARIANTS.
-Currently known variants are 'mh and 'nmh."
+Currently known variants are 'MH, 'nmh, and 'mu-mh."
   (let ((variant-in-use
          (cadr (assoc 'variant (assoc mh-variant-in-use mh-variants)))))
     (not (null (member variant-in-use variants)))))
diff --git a/lisp/mh-e/mh-loaddefs.el b/lisp/mh-e/mh-loaddefs.el
index 6a88278a847..fd989ffa3b9 100644
--- a/lisp/mh-e/mh-loaddefs.el
+++ b/lisp/mh-e/mh-loaddefs.el
@@ -13,7 +13,7 @@
 ;;;;;;  mh-check-whom mh-insert-signature mh-to-fcc mh-to-field mh-fill-paragraph-function
 ;;;;;;  mh-get-header-field mh-send-other-window mh-send mh-reply
 ;;;;;;  mh-redistribute mh-forward mh-extract-rejected-mail mh-edit-again)
-;;;;;;  "mh-comp" "mh-comp.el" (16665 55172))
+;;;;;;  "mh-comp" "mh-comp.el" (16665 53716))
 ;;; Generated autoloads from mh-comp.el
 
 (autoload (quote mh-edit-again) "mh-comp" "\
@@ -183,7 +183,7 @@ If we are at the first header field go to the start of the message body." t nil)
 ;;;;;;  mh-store-msg mh-undo-folder mh-sort-folder mh-page-digest-backwards
 ;;;;;;  mh-page-digest mh-pipe-msg mh-pack-folder mh-list-folders
 ;;;;;;  mh-kill-folder mh-copy-msg mh-burst-digest) "mh-funcs" "mh-funcs.el"
-;;;;;;  (16671 49652))
+;;;;;;  (16671 48788))
 ;;; Generated autoloads from mh-funcs.el
 
 (autoload (quote mh-burst-digest) "mh-funcs" "\
@@ -261,7 +261,7 @@ Display cheat sheet for the commands of the current prefix in minibuffer." t nil
 ;;;;;;  mh-identity-insert-attribution-verb mh-identity-handler-attribution-verb
 ;;;;;;  mh-identity-handler-signature mh-identity-handler-gpg-identity
 ;;;;;;  mh-insert-identity mh-identity-list-set mh-identity-make-menu)
-;;;;;;  "mh-identity" "mh-identity.el" (16680 7172))
+;;;;;;  "mh-identity" "mh-identity.el" (16671 57010))
 ;;; Generated autoloads from mh-identity.el
 
 (autoload (quote mh-identity-make-menu) "mh-identity" "\
@@ -307,7 +307,7 @@ If the field wasn't present, the VALUE is added at the bottom of the header." ni
 ;;;***
 
 ;;;### (autoloads (mh-inc-spool-list-set) "mh-inc" "mh-inc.el" (16671
-;;;;;;  49652))
+;;;;;;  48848))
 ;;; Generated autoloads from mh-inc.el
 
 (autoload (quote mh-inc-spool-list-set) "mh-inc" "\
@@ -326,7 +326,7 @@ This is called after 'customize is used to alter `mh-inc-spool-list'." nil nil)
 ;;;;;;  mh-index-parse-search-regexp mh-index-do-search mh-index-p
 ;;;;;;  mh-index-read-data mh-index-search mh-index-create-sequences
 ;;;;;;  mh-create-sequence-map mh-index-update-maps) "mh-index" "mh-index.el"
-;;;;;;  (16665 55172))
+;;;;;;  (16665 53754))
 ;;; Generated autoloads from mh-index.el
 
 (autoload (quote mh-index-update-maps) "mh-index" "\
@@ -582,7 +582,7 @@ system." nil nil)
 ;;;***
 
 ;;;### (autoloads (mh-variants mh-variant-p mh-variant-set) "mh-init"
-;;;;;;  "mh-init.el" (16680 9361))
+;;;;;;  "mh-init.el" (16684 6777))
 ;;; Generated autoloads from mh-init.el
 
 (autoload (quote mh-variant-set) "mh-init" "\
@@ -593,7 +593,7 @@ GNU mailutils." t nil)
 
 (autoload (quote mh-variant-p) "mh-init" "\
 Return t if variant is any of VARIANTS.
-Currently known variants are 'mh and 'nmh." nil nil)
+Currently known variants are 'MH, 'nmh, and 'mu-mh." nil nil)
 
 (autoload (quote mh-variants) "mh-init" "\
 Return a list of installed variants of MH on the system.
@@ -604,7 +604,7 @@ by the variable `mh-variants'." nil nil)
 ;;;***
 
 ;;;### (autoloads (mh-junk-whitelist mh-junk-blacklist) "mh-junk"
-;;;;;;  "mh-junk.el" (16671 49652))
+;;;;;;  "mh-junk.el" (16671 48929))
 ;;; Generated autoloads from mh-junk.el
 
 (autoload (quote mh-junk-blacklist) "mh-junk" "\
@@ -644,7 +644,7 @@ The `mh-junk-program' option specifies the spam program in use." t nil)
 ;;;;;;  mh-mhn-compose-external-compressed-tar mh-mhn-compose-anon-ftp
 ;;;;;;  mh-mhn-compose-insertion mh-file-mime-type mh-have-file-command
 ;;;;;;  mh-compose-forward mh-compose-insertion) "mh-mime" "mh-mime.el"
-;;;;;;  (16680 7172))
+;;;;;;  (16684 7323))
 ;;; Generated autoloads from mh-mime.el
 
 (autoload (quote mh-compose-insertion) "mh-mime" "\
@@ -857,7 +857,7 @@ View MIME PART-INDEX externally." t nil)
 ;;;***
 
 ;;;### (autoloads (mh-do-search mh-pick-do-search mh-search-folder)
-;;;;;;  "mh-pick" "mh-pick.el" (16671 49652))
+;;;;;;  "mh-pick" "mh-pick.el" (16671 49140))
 ;;; Generated autoloads from mh-pick.el
 
 (autoload (quote mh-search-folder) "mh-pick" "\
@@ -882,7 +882,7 @@ indexing program specified in `mh-index-program' is used." t nil)
 
 ;;;### (autoloads (mh-print-msg mh-ps-print-toggle-mime mh-ps-print-toggle-color
 ;;;;;;  mh-ps-print-toggle-faces mh-ps-print-msg-show mh-ps-print-msg-file
-;;;;;;  mh-ps-print-msg) "mh-print" "mh-print.el" (16680 9361))
+;;;;;;  mh-ps-print-msg) "mh-print" "mh-print.el" (16680 11171))
 ;;; Generated autoloads from mh-print.el
 
 (autoload (quote mh-ps-print-msg) "mh-print" "\
@@ -935,7 +935,7 @@ The messages are formatted by mhl. See the variable `mhl-formfile'." t nil)
 ;;;;;;  mh-rename-seq mh-translate-range mh-read-range mh-read-seq-default
 ;;;;;;  mh-notate-deleted-and-refiled mh-widen mh-put-msg-in-seq
 ;;;;;;  mh-narrow-to-seq mh-msg-is-in-seq mh-list-sequences mh-delete-seq)
-;;;;;;  "mh-seq" "mh-seq.el" (16668 22297))
+;;;;;;  "mh-seq" "mh-seq.el" (16671 65286))
 ;;; Generated autoloads from mh-seq.el
 
 (autoload (quote mh-delete-seq) "mh-seq" "\
@@ -1157,7 +1157,7 @@ Use \\<mh-folder-mode-map>\\[mh-widen] to undo this command." t nil)
 
 ;;;### (autoloads (mh-speed-add-folder mh-speed-invalidate-map mh-speed-flists
 ;;;;;;  mh-speed-view mh-speed-toggle mh-folder-speedbar-buttons)
-;;;;;;  "mh-speed" "mh-speed.el" (16665 55171))
+;;;;;;  "mh-speed" "mh-speed.el" (16665 53793))
 ;;; Generated autoloads from mh-speed.el
 
 (autoload (quote mh-folder-speedbar-buttons) "mh-speed" "\
@@ -1196,7 +1196,7 @@ The function invalidates the latest ancestor that is present." nil nil)
 ;;;;;;  mh-alias-grab-from-field mh-alias-add-alias mh-alias-for-from-p
 ;;;;;;  mh-alias-address-to-alias mh-alias-letter-expand-alias mh-alias-minibuffer-confirm-address
 ;;;;;;  mh-read-address mh-alias-reload-maybe mh-alias-reload) "mh-alias"
-;;;;;;  "mh-alias.el" (16671 49553))
+;;;;;;  "mh-alias.el" (16671 49382))
 ;;; Generated autoloads from mh-alias.el
 
 (autoload (quote mh-alias-reload) "mh-alias" "\
diff --git a/lisp/mh-e/mh-mime.el b/lisp/mh-e/mh-mime.el
index f952f8b80fb..72cb654dedd 100644
--- a/lisp/mh-e/mh-mime.el
+++ b/lisp/mh-e/mh-mime.el
@@ -583,6 +583,8 @@ automatically."
     (mml-insert-empty-tag 'part 'type type 'filename file
                           'disposition dispos 'description description)))
 
+(defvar mh-identity-pgg-default-user-id)
+
 (defun mh-secure-message (method mode &optional identity)
   "Add directive to Encrypt/Sign an entire message.
 METHOD should be one of: \"pgpmime\", \"pgp\", \"smime\".
@@ -852,7 +854,7 @@ If message has been encoded for transfer take that into account."
 ;;;###mh-autoload
 (defun mh-toggle-mh-decode-mime-flag ()
   "Toggle whether MH-E should decode MIME or not."
-  (interactive) 
+  (interactive)
   (setq mh-decode-mime-flag (not mh-decode-mime-flag))
   (mh-show nil t)
   (message (format "(setq mh-decode-mime-flag %s)" mh-decode-mime-flag)))
diff --git a/lisp/progmodes/etags.el b/lisp/progmodes/etags.el
index 4464df3a916..ddbd2ce6f35 100644
--- a/lisp/progmodes/etags.el
+++ b/lisp/progmodes/etags.el
@@ -772,26 +772,6 @@ Assumes the tags table is the current buffer."
         (all-completions string (tags-completion-table) predicate)
       (try-completion string (tags-completion-table) predicate))))
 
-;; Return a default tag to search for, based on the text at point.
-(defun find-tag-default ()
-  (save-excursion
-    (while (looking-at "\\sw\\|\\s_")
-      (forward-char 1))
-    (if (or (re-search-backward "\\sw\\|\\s_"
-                                (save-excursion (beginning-of-line) (point))
-                                t)
-            (re-search-forward "\\(\\sw\\|\\s_\\)+"
-                               (save-excursion (end-of-line) (point))
-                               t))
-        (progn (goto-char (match-end 0))
-               (buffer-substring-no-properties
-                (point)
-                (progn (forward-sexp -1)
-                       (while (looking-at "\\s'")
-                         (forward-char 1))
-                       (point))))
-      nil)))
-
 ;; Read a tag name from the minibuffer with defaulting and completion.
 (defun find-tag-tag (string)
   (let* ((completion-ignore-case (if (memq tags-case-fold-search '(t nil))
diff --git a/lisp/progmodes/grep.el b/lisp/progmodes/grep.el
index 5b678f26171..f4acd564a3c 100644
--- a/lisp/progmodes/grep.el
+++ b/lisp/progmodes/grep.el
@@ -384,9 +384,7 @@ Set up `compilation-exit-message-function' and run `grep-setup-hook'."
   (let ((tag-default
          (funcall (or find-tag-default-function
                       (get major-mode 'find-tag-default-function)
-                      ;; We use grep-tag-default instead of
-                      ;; find-tag-default, to avoid loading etags.
-                      'grep-tag-default)))
+                      'find-tag-default)))
         (sh-arg-re "\\(\\(?:\"\\(?:[^\"]\\|\\\\\"\\)+\"\\|'[^']+'\\|[^\"' \t\n]\\)+\\)")
         (grep-default (or (car grep-history) grep-command)))
     ;; Replace the thing matching for with that around cursor.
@@ -457,25 +455,6 @@ temporarily highlight in visited source lines."
   (set (make-local-variable 'compilation-error-regexp-alist)
        grep-regexp-alist))
 
-;; This is a copy of find-tag-default from etags.el.
-;;;###autoload
-(defun grep-tag-default ()
-  (save-excursion
-    (while (looking-at "\\sw\\|\\s_")
-      (forward-char 1))
-    (when (or (re-search-backward "\\sw\\|\\s_"
-                                  (save-excursion (beginning-of-line) (point))
-                                  t)
-              (re-search-forward "\\(\\sw\\|\\s_\\)+"
-                                 (save-excursion (end-of-line) (point))
-                                 t))
-      (goto-char (match-end 0))
-      (buffer-substring (point)
-                        (progn (forward-sexp -1)
-                               (while (looking-at "\\s'")
-                                 (forward-char 1))
-                               (point))))))
-
 ;;;###autoload
 (defun grep-find (command-args)
   "Run grep via find, with user-specified args COMMAND-ARGS.
diff --git a/lisp/subr.el b/lisp/subr.el
index bac77872cf0..6676a6b7794 100644
--- a/lisp/subr.el
+++ b/lisp/subr.el
@@ -1981,6 +1981,27 @@ Uses the `derived-mode-parent' property of the symbol to trace backwards."
                 (setq parent (get parent 'derived-mode-parent))))
     parent))
 
+(defun find-tag-default ()
+  "Determine default tag to search for, based on text at point.
+If there is no plausible default, return nil."
+  (save-excursion
+    (while (looking-at "\\sw\\|\\s_")
+      (forward-char 1))
+    (if (or (re-search-backward "\\sw\\|\\s_"
+                                (save-excursion (beginning-of-line) (point))
+                                t)
+            (re-search-forward "\\(\\sw\\|\\s_\\)+"
+                               (save-excursion (end-of-line) (point))
+                               t))
+        (progn (goto-char (match-end 0))
+               (buffer-substring-no-properties
+                (point)
+                (progn (forward-sexp -1)
+                       (while (looking-at "\\s'")
+                         (forward-char 1))
+                       (point))))
+      nil)))
+
 (defmacro with-syntax-table (table &rest body)
   "Evaluate BODY with syntax table of current buffer set to TABLE.
 The syntax table of the current buffer is saved, BODY is evaluated, and the
diff --git a/lisp/textmodes/tex-mode.el b/lisp/textmodes/tex-mode.el
index 28bf9f6cf28..1c4b89f0a62 100644
--- a/lisp/textmodes/tex-mode.el
+++ b/lisp/textmodes/tex-mode.el
@@ -1141,10 +1141,14 @@ on the line for the invalidity you want to see."
                                          'occur-target tem)))))
             (goto-char prev-end))))
       (with-current-buffer standard-output
-        (if (eq num-matches 0)
-            (insert "None!\n"))
-        (if (interactive-p)
-            (message "%d mismatches found" num-matches))))))
+        (let ((no-matches (zerop num-matches)))
+          (if no-matches
+              (insert "None!\n"))
+          (if (interactive-p)
+              (message (cond (no-matches "No mismatches found")
+                             ((= num-matches 1) "1 mismatch found")
+                             (t "%d mismatches found"))
+                       num-matches)))))))
 
 (defun tex-validate-region (start end)
   "Check for mismatched braces or $'s in region.
@@ -1459,7 +1463,7 @@ Mark is left at original location."
        nil)
     (let ((proc (get-process "tex-shell")))
       (set-process-sentinel proc 'tex-shell-sentinel)
-      (process-kill-without-query proc)
+      (set-process-query-on-exit-flag proc nil)
       (tex-shell)
       (while (zerop (buffer-size))
         (sleep-for 1)))))
@@ -1928,7 +1932,7 @@ for the error messages."
                 (re-search-forward
                  "^l\\.\\([0-9]+\\) \\(\\.\\.\\.\\)?\\(.*\\)$" nil 'move))
       (let* ((this-error (copy-marker begin-of-error))
-             (linenum (string-to-int (match-string 1)))
+             (linenum (string-to-number (match-string 1)))
              (error-text (regexp-quote (match-string 3)))
              (filename
               (save-excursion