Merged in changes from CVS trunk.

Patches applied:

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

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

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


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

12 files changed, 581 insertions, 563 deletions

diff --git a/ChangeLog b/ChangeLog
index 60fbc7e8723..223d75fdf07 100644
--- a/ChangeLog
+++ b/ChangeLog
@@ -1,3 +1,7 @@
+2004-08-06  Andreas Schwab  <schwab@suse.de>
+
+        * Makefile.in (install-arch-indep, uninstall): Add flymake.
+
 2004-07-31  Eli Zaretskii  <eliz@gnu.org>
 
         * config.bat: Update URLs in the comments.
diff --git a/Makefile.in b/Makefile.in
index 35cc2798e32..05d7b556256 100644
--- a/Makefile.in
+++ b/Makefile.in
@@ -475,7 +475,7 @@ install-arch-indep: mkdir info
               chmod a+r ${infodir}/dir); \
            fi; \
            cd ${srcdir}/info ; \
-           for f in ada-mode* autotype* calc* ccmode* cl* dired-x* ebrowse* ediff* efaq* eintr* elisp* emacs* emacs-xtra* eshell* eudc* forms* gnus* idlwave* info* message* mh-e* pcl-cvs* reftex* sc* ses* speedbar* tramp* vip* widget* woman* smtpmail*; do \
+           for f in ada-mode* autotype* calc* ccmode* cl* dired-x* ebrowse* ediff* efaq* eintr* elisp* emacs* emacs-xtra* eshell* eudc* flymake* forms* gnus* idlwave* info* message* mh-e* pcl-cvs* reftex* sc* ses* speedbar* tramp* vip* widget* woman* smtpmail*; do \
              (cd $${thisdir}; \
               ${INSTALL_DATA} ${srcdir}/info/$$f ${infodir}/$$f; \
               chmod a+r ${infodir}/$$f); \
@@ -485,7 +485,7 @@ install-arch-indep: mkdir info
         thisdir=`/bin/pwd`; \
         if [ `(cd ${srcdir}/info && /bin/pwd)` != `(cd ${infodir} && /bin/pwd)` ]; \
         then \
-          for f in ada-mode autotype calc ccmode cl dired-x ebrowse ediff efaq elisp eintr emacs emacs-mime emacs-xtra eshell eudc forms gnus idlwave info message mh-e pcl-cvs reftex sc ses speedbar tramp vip viper widget woman smtpmail; do \
+          for f in ada-mode autotype calc ccmode cl dired-x ebrowse ediff efaq elisp eintr emacs emacs-mime emacs-xtra eshell eudc flymake forms gnus idlwave info message mh-e pcl-cvs reftex sc ses speedbar tramp vip viper widget woman smtpmail; do \
             (cd $${thisdir}; \
              ${INSTALL_INFO} --info-dir=${infodir} ${infodir}/$$f); \
           done; \
@@ -551,7 +551,7 @@ uninstall:
         done
         (cd ${archlibdir} && rm -f fns-*)
         -rm -rf ${libexecdir}/emacs/${version}
-        (cd ${infodir} && rm -f cl* ada-mode* autotype* calc* ccmode* ebrowse* efaq* eintr elisp* eshell* eudc* idlwave* message* pcl-cvs* reftex* speedbar* tramp* widget* woman* dired-x* ediff* emacs* emacs-xtra* forms* gnus* info* mh-e* sc* ses* vip* smtpmail*)
+        (cd ${infodir} && rm -f cl* ada-mode* autotype* calc* ccmode* ebrowse* efaq* eintr elisp* eshell* eudc* idlwave* message* pcl-cvs* reftex* speedbar* tramp* widget* woman* dired-x* ediff* emacs* emacs-xtra* flymake* forms* gnus* info* mh-e* sc* ses* vip* smtpmail*)
         (cd ${man1dir}  && rm -f emacs${manext} emacsclient${manext} etags${manext} ctags${manext})
         (cd ${bindir}  && rm -f $(EMACSFULL) $(EMACS))
 
diff --git a/leim/ChangeLog b/leim/ChangeLog
index 146bc897098..c30c488c0b7 100644
--- a/leim/ChangeLog
+++ b/leim/ChangeLog
@@ -1,3 +1,7 @@
+2004-08-06  Andreas Schwab  <schwab@suse.de>
+
+        * Makefile.in (install): Remove .arch-inventory files.
+
 2004-07-01  David Kastrup  <dak@gnu.org>
 
         * quail/greek.el ("((") ("))"): add quotation mark shorthands.
diff --git a/leim/Makefile.in b/leim/Makefile.in
index 7f3c13dbe36..acffcc7f7b5 100644
--- a/leim/Makefile.in
+++ b/leim/Makefile.in
@@ -232,6 +232,7 @@ install: all
           fi; \
           rm -rf ${INSTALLDIR}/CVS        ${INSTALLDIR}/*/CVS; \
           rm -f  ${INSTALLDIR}/.cvsignore ${INSTALLDIR}/*/.cvsignore; \
+          rm -f  ${INSTALLDIR}/.arch-inventory ${INSTALLDIR}/*/.arch-inventory; \
           rm -f  ${INSTALLDIR}/\#*        ${INSTALLDIR}/*/\#* ; \
           rm -f  ${INSTALLDIR}/.\#*       ${INSTALLDIR}/*/.\#* ; \
           rm -f  ${INSTALLDIR}/*~         ${INSTALLDIR}/*/*~ ; \
diff --git a/lisp/ChangeLog b/lisp/ChangeLog
index b5134b2647f..e12449df8e4 100644
--- a/lisp/ChangeLog
+++ b/lisp/ChangeLog
@@ -1,3 +1,27 @@
+2004-08-04  Kenichi Handa  <handa@m17n.org>
+
+        * international/encoded-kb.el (encoded-kbd-setup-keymap): Fix
+        previous change.
+
+2004-08-03  Kenichi Handa  <handa@m17n.org>
+
+        * international/encoded-kb.el: The following changes are to
+        utilize key-translation-map instead of minor mode map.
+        (encoded-kbd-iso2022-non-ascii-map): Delete it.
+        (encoded-kbd-coding, encoded-kbd-handle-8bit): Delete them.
+        (encoded-kbd-last-key): New function.
+        (encoded-kbd-iso2022-single-shift): New function.
+        (encoded-kbd-iso2022-designation)
+        (encoded-kbd-self-insert-iso2022-7bit)
+        (encoded-kbd-self-insert-iso2022-8bit)
+        (encoded-kbd-self-insert-sjis, encoded-kbd-self-insert-big5)
+        (encoded-kbd-self-insert-ccl): Make them suitable for bindings in
+        key-translation-map.
+        (encoded-kbd-setup-keymap): Setup key-translation-map.
+        (saved-key-translation-map): New variable.
+        (encoded-kbd-mode): Save/restore key-translation-map.  Adjusted
+        for the change of encoded-kbd-setup-keymap.
+
 2004-08-02  Kim F. Storm  <storm@cua.dk>
 
         * avoid.el (mouse-avoidance-point-position): Use window-inside-edges
diff --git a/lisp/international/encoded-kb.el b/lisp/international/encoded-kb.el
index 6eae1011c40..cba2f0e45b9 100644
--- a/lisp/international/encoded-kb.el
+++ b/lisp/international/encoded-kb.el
@@ -24,6 +24,10 @@
 
 ;;; Code:
 
+;; Usually this map is empty (even if Encoded-kbd mode is on), but if
+;; the keyboard coding system is iso-2022-based, it defines dummy key
+;; bindings for ESC $ ..., etc. so that those bindings in
+;; key-translation-map take effect.
 (defconst encoded-kbd-mode-map (make-sparse-keymap)
   "Keymap for Encoded-kbd minor mode.")
 
@@ -69,25 +73,6 @@
 (fset 'encoded-kbd-iso2022-designation-prefix
       encoded-kbd-iso2022-designation-map)
 
-(defvar encoded-kbd-iso2022-non-ascii-map
-  (let ((map (make-keymap))
-        (i 32))
-    (while (< i 128)
-      (define-key map (char-to-string i) 'encoded-kbd-self-insert-iso2022-7bit)
-      (setq i (1+ i)))
-    (define-key map "\e" 'encoded-kbd-iso2022-esc-prefix)
-    (setq i 160)
-    (while (< i 256)
-      (define-key map (vector i) 'encoded-kbd-handle-8bit)
-      (setq i (1+ i)))
-    map)
-  "Keymap for handling non-ASCII character set in Encoded-kbd mode.")
-
-;; One of the symbols `sjis', `iso2022-7', `iso2022-8', or `big5' to
-;; denote what kind of coding-system we are now handling in
-;; Encoded-kbd mode.
-(defvar encoded-kbd-coding nil)
-
 ;; Keep information of designation state of ISO2022 encoding.  When
 ;; Encoded-kbd mode is on, this is set to a vector of length 4, the
 ;; elements are character sets currently designated to graphic
@@ -104,11 +89,14 @@
 (defvar encoded-kbd-iso2022-invocations nil)
 (put 'encoded-kbd-iso2022-invocations 'permanent-local t)
 
-(defun encoded-kbd-iso2022-designation ()
+(defsubst encoded-kbd-last-key ()
+  (let ((keys (this-single-command-keys)))
+    (aref keys (1- (length keys)))))
+
+(defun encoded-kbd-iso2022-designation (ignore)
   "Do ISO2022 designation according to the current key in Encoded-kbd mode.
 The following key sequence may cause multilingual text insertion."
-  (interactive)
-  (let ((key-seq (this-command-keys))
+  (let ((key-seq (this-single-command-keys))
         (prev-g0-charset (aref encoded-kbd-iso2022-designations
                                (aref encoded-kbd-iso2022-invocations 0)))
         intermediate-char final-char
@@ -132,143 +120,122 @@ The following key sequence may cause multilingual text insertion."
               chars (if (< intermediate-char ?,) 94 96)
               final-char (aref key-seq 2)
               reg (mod intermediate-char 4))))
-    (if (setq charset (iso-charset dimension chars final-char))
-        (aset encoded-kbd-iso2022-designations reg charset)
-      (error "Character set of DIMENSION %s, CHARS %s, FINAL-CHAR `%c' is not supported"
-             dimension chars final-char))
-
-    (if (memq (aref encoded-kbd-iso2022-designations
-                    (aref encoded-kbd-iso2022-invocations 0))
-              '(ascii latin-jisx0201))
-        ;; Graphic plane 0 (0x20..0x7f) is for ASCII.  We don't have
-        ;; to handle characters in this range specially.
-        (if (not (memq prev-g0-charset '(ascii latin-jisx0201)))
-            ;; We must exit recursive edit now.
-            (throw 'exit nil))
-      ;; Graphic plane 0 is for non-ASCII.
-      (if (memq prev-g0-charset '(ascii latin-jisx0201))
-          ;; We must handle keys specially.
-          (let ((overriding-local-map encoded-kbd-iso2022-non-ascii-map))
-            (recursive-edit))))))
-
-(defun encoded-kbd-handle-8bit ()
-  "Handle an 8-bit character entered in Encoded-kbd mode."
-  (interactive)
-  (cond ((eq encoded-kbd-coding 'iso2022-7)
-         (error "Can't handle the character code %d" last-command-char))
-
-        ((eq encoded-kbd-coding 'iso2022-8)
-         (cond ((= last-command-char ?\216)
-                (aset encoded-kbd-iso2022-invocations 2 2))
-
-               ((= last-command-char ?\217)
-                (aset encoded-kbd-iso2022-invocations 2 3))
-
-               ((>= last-command-char ?\240)
-                (encoded-kbd-self-insert-iso2022-8bit))
-
-               (t
-                (error "Can't handle the character code %d"
-                       last-command-char))))
-
-        ((eq encoded-kbd-coding 'sjis)
-         (encoded-kbd-self-insert-sjis))
-
-        (t
-         (encoded-kbd-self-insert-big5))))
-
-(defun encoded-kbd-self-insert-iso2022-7bit ()
-  (interactive)
-  (let* ((charset (aref encoded-kbd-iso2022-designations
-                        (or (aref encoded-kbd-iso2022-invocations 2)
-                            (aref encoded-kbd-iso2022-invocations 0))))
-         (char (if (= (charset-dimension charset) 1)
-                   (make-char charset last-command-char)
-                 (make-char charset last-command-char (read-char-exclusive)))))
+    (aset encoded-kbd-iso2022-designations reg
+          (iso-charset dimension chars final-char)))
+  "")
+
+(defun encoded-kbd-iso2022-single-shift (ignore)
+  (let ((char (encoded-kbd-last-key)))
+    (aset encoded-kbd-iso2022-invocations 2
+          (aref encoded-kbd-iso2022-designations
+                (if (= char ?\216) 2 3))))
+  "")
+
+(defun encoded-kbd-self-insert-iso2022-7bit (ignore)
+  (let ((char (encoded-kbd-last-key))
+        (charset (aref encoded-kbd-iso2022-designations
+                       (or (aref encoded-kbd-iso2022-invocations 2)
+                           (aref encoded-kbd-iso2022-invocations 0)))))
     (aset encoded-kbd-iso2022-invocations 2 nil)
-    (setq unread-command-events (cons char unread-command-events))))
-
-(defun encoded-kbd-self-insert-iso2022-8bit ()
-  (interactive)
-  (cond
-   ((= last-command-char ?\216)         ; SS2 (Single Shift 2)
-    (aset encoded-kbd-iso2022-invocations 2 2))
-   ((= last-command-char ?\217)         ; SS3 (Single Shift 3)
-    (aset encoded-kbd-iso2022-invocations 2 3))
-   (t
-    (let* ((charset (aref encoded-kbd-iso2022-designations
-                          (or (aref encoded-kbd-iso2022-invocations 2)
-                              (aref encoded-kbd-iso2022-invocations 1))))
-           (char (if (= (charset-dimension charset) 1)
-                     (make-char charset last-command-char)
-                   (make-char charset last-command-char
-                              (read-char-exclusive)))))
-      (aset encoded-kbd-iso2022-invocations 2 nil)
-      (setq unread-command-events (cons char unread-command-events))))))
-
-(defun encoded-kbd-self-insert-sjis ()
-  (interactive)
-  (let ((char (if (or (< last-command-char ?\xA0) (>= last-command-char ?\xE0))
-                  (decode-sjis-char (+ (ash last-command-char 8)
-                                       (read-char-exclusive)))
-                (make-char 'katakana-jisx0201 last-command-char))))
-    (setq unread-command-events (cons char unread-command-events))))
-
-(defun encoded-kbd-self-insert-big5 ()
-  (interactive)
-  (let ((char (decode-big5-char (+ (ash last-command-char 8)
-                                   (read-char-exclusive)))))
-    (setq unread-command-events (cons char unread-command-events))))
-
-(defun encoded-kbd-self-insert-ccl ()
-  (interactive)
-  (let ((str (char-to-string last-command-char))
+    (vector (if (= (charset-dimension charset) 1)
+                (make-char charset char)
+              (make-char charset char (read-char-exclusive))))))
+
+(defun encoded-kbd-self-insert-iso2022-8bit (ignore)
+  (let ((char (encoded-kbd-last-key))
+        (charset (aref encoded-kbd-iso2022-designations
+                       (or (aref encoded-kbd-iso2022-invocations 2)
+                           (aref encoded-kbd-iso2022-invocations 1)))))
+    (aset encoded-kbd-iso2022-invocations 2 nil)
+    (vector (if (= (charset-dimension charset) 1)
+                (make-char charset char)
+              (make-char charset char (read-char-exclusive))))))
+
+(defun encoded-kbd-self-insert-sjis (ignore)
+  (let ((char (encoded-kbd-last-key)))
+    (vector
+     (if (or (< char ?\xA0) (>= char ?\xE0))
+         (decode-sjis-char (+ (ash char 8) (read-char-exclusive)))
+       (make-char 'katakana-jisx0201 char)))))
+
+(defun encoded-kbd-self-insert-big5 (ignore)
+  (let ((char (encoded-kbd-last-key)))
+    (vector 
+     (decode-big5-char (+ (ash char 8) (read-char-exclusive))))))
+
+(defun encoded-kbd-self-insert-ccl (ignore)
+  (let ((str (char-to-string (encoded-kbd-last-key)))
         (ccl (car (aref (coding-system-spec (keyboard-coding-system)) 4)))
         (vec [nil nil nil nil nil nil nil nil nil])
         result)
     (while (= (length (setq result (ccl-execute-on-string ccl vec str t))) 0)
       (dotimes (i 9) (aset vec i nil))
       (setq str (format "%s%c" str (read-char-exclusive))))
-    (setq unread-command-events
-          (append result unread-command-events))))
+    (vector (aref result 0))))
 
 (defun encoded-kbd-setup-keymap (coding)
   ;; At first, reset the keymap.
-  (setcdr encoded-kbd-mode-map nil)
+  (define-key encoded-kbd-mode-map "\e" nil)
   ;; Then setup the keymap according to the keyboard coding system.
   (cond
-   ((eq encoded-kbd-coding 'sjis)
+   ((eq (coding-system-type coding) 1)  ; SJIS
     (let ((i 128))
       (while (< i 256)
-        (define-key encoded-kbd-mode-map
+        (define-key key-translation-map
           (vector i) 'encoded-kbd-self-insert-sjis)
-        (setq i (1+ i)))))
+        (setq i (1+ i))))
+    8)
 
-   ((eq encoded-kbd-coding 'big5)
+   ((eq (coding-system-type coding) 3)  ; Big5
     (let ((i 161))
       (while (< i 255)
-        (define-key encoded-kbd-mode-map
+        (define-key key-translation-map
           (vector i) 'encoded-kbd-self-insert-big5)
-        (setq i (1+ i)))))
-
-   ((eq encoded-kbd-coding 'iso2022-7)
-    (define-key encoded-kbd-mode-map "\e" 'encoded-kbd-iso2022-esc-prefix))
-
-   ((eq encoded-kbd-coding 'iso2022-8)
-    (define-key encoded-kbd-mode-map
-      (vector ?\216) 'encoded-kbd-self-insert-iso2022-8bit)
-    (define-key encoded-kbd-mode-map
-      (vector ?\217) 'encoded-kbd-self-insert-iso2022-8bit)
-    (let ((i 160))
-      (while (< i 256)
-        (define-key encoded-kbd-mode-map
-          (vector i) 'encoded-kbd-self-insert-iso2022-8bit)
-        (setq i (1+ i)))))
-
-   ((eq encoded-kbd-coding 'ccl)
+        (setq i (1+ i))))
+    8)
+
+   ((eq (coding-system-type coding) 2) ; ISO-2022
+    (let ((flags (coding-system-flags coding))
+          use-designation)
+      (if (aref flags 8)
+          nil                           ; Don't support locking-shift.
+        (setq encoded-kbd-iso2022-designations (make-vector 4 nil)
+              encoded-kbd-iso2022-invocations (make-vector 3 nil))
+        (dotimes (i 4)
+          (if (aref flags i)
+              (if (charsetp (aref flags i))
+                  (aset encoded-kbd-iso2022-designations
+                        i (aref flags i))
+                (setq use-designation t)
+                (if (charsetp (car-safe (aref flags i)))
+                    (aset encoded-kbd-iso2022-designations
+                          i (car (aref flags i)))))))
+        (aset encoded-kbd-iso2022-invocations 0 0)
+        (if (aref encoded-kbd-iso2022-designations 1)
+            (aset encoded-kbd-iso2022-invocations 1 1))
+        (when use-designation
+          (define-key encoded-kbd-mode-map "\e" 'encoded-kbd-iso2022-esc-prefix)
+          (define-key key-translation-map "\e" 'encoded-kbd-iso2022-esc-prefix))
+        (when (or (aref flags 2) (aref flags 3))
+          (define-key key-translation-map
+            [?\216] 'encoded-kbd-iso2022-single-shift)
+          (define-key key-translation-map
+            [?\217] 'encoded-kbd-iso2022-single-shift))
+        (or (eq (aref flags 0) 'ascii)
+            (dotimes (i 96)
+              (define-key key-translation-map
+                (vector (+ 32 i)) 'encoded-kbd-self-insert-iso2022-7bit)))
+        (if (aref flags 7)
+            t
+          (dotimes (i 96)
+            (define-key key-translation-map
+              (vector (+ 160 i)) 'encoded-kbd-self-insert-iso2022-8bit))
+          8))))
+
+   ((eq (coding-system-type coding) 4)  ; CCL-base
     (let ((valid-codes (or (coding-system-get coding 'valid-codes)
                            '((128 . 255))))
-          elt from to)
+          elt from to valid)
       (while valid-codes
         (setq elt (car valid-codes) valid-codes (cdr valid-codes))
         (if (consp elt)
@@ -276,13 +243,17 @@ The following key sequence may cause multilingual text insertion."
           (setq from (setq to elt)))
         (while (<= from to)
           (if (>= from 128)
-              (define-key encoded-kbd-mode-map
+              (define-key key-translation-map
                 (vector from) 'encoded-kbd-self-insert-ccl))
-          (setq from (1+ from))))))
+          (setq from (1+ from))))
+      8))
 
    (t
-    (error "Invalid value in encoded-kbd-coding: %s" encoded-kbd-coding))))
+    nil)))
 
+;; key-translation-map at the time Encoded-kbd mode is turned on is
+;; saved here.
+(defvar saved-key-translation-map nil)
 
 ;; Input mode at the time Encoded-kbd mode is turned on is saved here.
 (defvar saved-input-mode nil)
@@ -301,60 +272,38 @@ In Encoded-kbd mode, a text sent from keyboard is accepted
 as a multilingual text encoded in a coding system set by
 \\[set-keyboard-coding-system]."
   :global t
-  ;; We must at first reset input-mode to the original.
-  (if saved-input-mode (apply 'set-input-mode saved-input-mode))
+
   (if encoded-kbd-mode
-      (let ((coding (keyboard-coding-system)))
-        (setq saved-input-mode  (current-input-mode))
-        (cond ((null coding)
-               (setq encoded-kbd-mode nil)
-               (error "No coding system for keyboard input is set"))
-
-              ((= (coding-system-type coding) 1) ; SJIS
-               (set-input-mode
-                (nth 0 saved-input-mode) (nth 1 saved-input-mode)
-                'use-8th-bit (nth 3 saved-input-mode))
-               (setq encoded-kbd-coding 'sjis))
-
-              ((= (coding-system-type coding) 2) ; ISO2022
-               (if (aref (coding-system-flags coding) 7) ; 7-bit only
-                   (setq encoded-kbd-coding 'iso2022-7)
-                 (set-input-mode
-                  (nth 0 saved-input-mode) (nth 1 saved-input-mode)
-                  'use-8th-bit (nth 3 saved-input-mode))
-                 (setq encoded-kbd-coding 'iso2022-8))
-               (setq encoded-kbd-iso2022-designations (make-vector 4 nil))
-               (let ((flags (coding-system-flags coding))
-                     (i 0))
-                 (while (< i 4)
-                   (if (charsetp (aref flags i))
-                       (aset encoded-kbd-iso2022-designations i
-                             (aref flags i))
-                     (if (charsetp (car-safe (aref flags i)))
-                       (aset encoded-kbd-iso2022-designations i
-                             (car (aref flags i)))))
-                   (setq i (1+ i))))
-               (setq encoded-kbd-iso2022-invocations (make-vector 3 nil))
-               (aset encoded-kbd-iso2022-invocations 0 0)
-               (aset encoded-kbd-iso2022-invocations 1 1))
-
-              ((= (coding-system-type coding) 3) ; BIG5
-               (set-input-mode
-                (nth 0 saved-input-mode) (nth 1 saved-input-mode)
-                'use-8th-bit (nth 3 saved-input-mode))
-               (setq encoded-kbd-coding 'big5))
-
-              ((= (coding-system-type coding) 4) ; CCL based coding
-               (set-input-mode
-                (nth 0 saved-input-mode) (nth 1 saved-input-mode)
-                'use-8th-bit (nth 3 saved-input-mode))
-               (setq encoded-kbd-coding 'ccl))
-
-              (t
-               (setq encoded-kbd-mode nil)
-               (error "Coding-system `%s' is not supported in Encoded-kbd mode"
-                      (keyboard-coding-system))))
-        (encoded-kbd-setup-keymap coding))))
+      ;; We are turning on Encoded-kbd mode.
+      (let ((coding (keyboard-coding-system))
+            result)
+        (or saved-key-translation-map
+            (if (keymapp key-translation-map)
+                (setq saved-key-translation-map
+                      (copy-keymap key-translation-map))
+              (setq key-translation-map (make-sparse-keymap))))
+        (or saved-input-mode
+            (setq saved-input-mode
+                  (current-input-mode)))
+        (setq result (and coding (encoded-kbd-setup-keymap coding)))
+        (if result
+            (if (eq result 8)
+                (set-input-mode
+                 (nth 0 saved-input-mode) 
+                 (nth 1 saved-input-mode)
+                 'use-8th-bit
+                 (nth 3 saved-input-mode)))
+          (setq encoded-kbd-mode nil
+                saved-key-translation-map nil
+                saved-input-mode nil)
+          (error "Unsupported coding system in Encoded-kbd mode: %S"
+                 coding)))
+
+    ;; We are turning off Encoded-kbd mode.
+    (setq key-translation-map saved-key-translation-map
+          saved-key-translation-map nil)
+    (apply 'set-input-mode saved-input-mode)
+    (setq saved-input-mode nil)))
 
 (provide 'encoded-kb)
 
diff --git a/lisp/mail/mail-extr.el b/lisp/mail/mail-extr.el
index faa7ca1bb74..7f2e6fef6b6 100644
--- a/lisp/mail/mail-extr.el
+++ b/lisp/mail/mail-extr.el
@@ -1434,374 +1434,388 @@ consing a string.)"
     (if all (nreverse value-list) (car value-list))
     ))
 
+(defcustom mail-extr-disable-voodoo "\\cj"
+  "*If it is a regexp, names matching it will never be modified.
+If it is neither nil nor a string, modifying of names will never take
+place.  It affects how `mail-extract-address-components' works."
+  :type '(choice (regexp :size 0)
+                 (const :tag "Always enabled" nil)
+                 (const :tag "Always disabled" t))
+  :group 'mail-extr)
+
 (defun mail-extr-voodoo (mbox-beg mbox-end canonicalization-buffer)
-  (let ((word-count 0)
-        (case-fold-search nil)
-        mixed-case-flag lower-case-flag ;;upper-case-flag
-        suffix-flag last-name-comma-flag
-        ;;cbeg cend
-        initial
-        begin-again-flag
-        drop-this-word-if-trailing-flag
-        drop-last-word-if-trailing-flag
-        word-found-flag
-        this-word-beg last-word-beg
-        name-beg name-end
-        name-done-flag
-        )
-    (save-excursion
-      (set-syntax-table mail-extr-address-text-syntax-table)
-
-      ;; Get rid of comments.
-      (goto-char (point-min))
-      (while (not (eobp))
-        ;; Initialize for this iteration of the loop.
-        (skip-chars-forward "^({[\"'`")
-        (let ((cbeg (point)))
-          (set-syntax-table mail-extr-address-text-comment-syntax-table)
-          (if (memq (following-char) '(?\' ?\`))
-              (search-forward "'" nil 'move
-                              (if (eq ?\' (following-char)) 2 1))
-            (or (mail-extr-safe-move-sexp 1)
-                (goto-char (point-max))))
-          (set-syntax-table mail-extr-address-text-syntax-table)
-          (when (eq (char-after cbeg) ?\()
-            ;; Delete the comment itself.
-            (delete-region cbeg (point))
-            ;; Canonicalize whitespace where the comment was.
-            (skip-chars-backward " \t")
-            (if (looking-at "\\([ \t]+$\\|[ \t]+,\\)")
-                (replace-match "")
-              (setq cbeg (point))
-              (skip-chars-forward " \t")
-              (if (bobp)
-                  (delete-region (point) cbeg)
-                (just-one-space))))))
-
-      ;; This was moved above.
-      ;; Fix . used as space
-      ;; But it belongs here because it occurs not only as
-      ;;   rypens@reks.uia.ac.be (Piet.Rypens)
-      ;; but also as
-      ;;   "Piet.Rypens" <rypens@reks.uia.ac.be>
-      ;;(goto-char (point-min))
-      ;;(while (re-search-forward mail-extr-bad-dot-pattern nil t)
-      ;;  (replace-match "\\1 \\2" t))
-
-      (unless (search-forward " " nil t)
+  (unless (and mail-extr-disable-voodoo
+               (or (not (stringp mail-extr-disable-voodoo))
+                   (progn
+                     (goto-char (point-min))
+                     (re-search-forward mail-extr-disable-voodoo nil t))))
+    (let ((word-count 0)
+          (case-fold-search nil)
+          mixed-case-flag lower-case-flag ;;upper-case-flag
+          suffix-flag last-name-comma-flag
+          ;;cbeg cend
+          initial
+          begin-again-flag
+          drop-this-word-if-trailing-flag
+          drop-last-word-if-trailing-flag
+          word-found-flag
+          this-word-beg last-word-beg
+          name-beg name-end
+          name-done-flag
+          )
+      (save-excursion
+        (set-syntax-table mail-extr-address-text-syntax-table)
+
+        ;; Get rid of comments.
         (goto-char (point-min))
-        (cond ((search-forward "_" nil t)
-               ;; Handle the *idiotic* use of underlines as spaces.
-               ;; Example: fml@foo.bar.dom (First_M._Last)
-               (goto-char (point-min))
-               (while (search-forward "_" nil t)
-                 (replace-match " " t)))
-              ((search-forward "." nil t)
-               ;; Fix . used as space
-               ;; Example: danj1@cb.att.com (daniel.jacobson)
-               (goto-char (point-min))
-               (while (re-search-forward mail-extr-bad-dot-pattern nil t)
-                 (replace-match "\\1 \\2" t)))))
-
-      ;; Loop over the words (and other junk) in the name.
-      (goto-char (point-min))
-      (while (not name-done-flag)
-
-        (when word-found-flag
-          ;; Last time through this loop we skipped over a word.
-          (setq last-word-beg this-word-beg)
-          (setq drop-last-word-if-trailing-flag
-                drop-this-word-if-trailing-flag)
-          (setq word-found-flag nil))
-
-        (when begin-again-flag
-          ;; Last time through the loop we found something that
-          ;; indicates we should pretend we are beginning again from
-          ;; the start.
-          (setq word-count 0)
-          (setq last-word-beg nil)
-          (setq drop-last-word-if-trailing-flag nil)
-          (setq mixed-case-flag nil)
-          (setq lower-case-flag nil)
-          ;;           (setq upper-case-flag nil)
-          (setq begin-again-flag nil))
-
-        ;; Initialize for this iteration of the loop.
-        (mail-extr-skip-whitespace-forward)
-        (if (eq word-count 0) (narrow-to-region (point) (point-max)))
-        (setq this-word-beg (point))
-        (setq drop-this-word-if-trailing-flag nil)
-
-        ;; Decide what to do based on what we are looking at.
-        (cond
-
-         ;; Delete title
-         ((and (eq word-count 0)
-               (looking-at mail-extr-full-name-prefixes))
-          (goto-char (match-end 0))
-          (narrow-to-region (point) (point-max)))
+        (while (not (eobp))
+          ;; Initialize for this iteration of the loop.
+          (skip-chars-forward "^({[\"'`")
+          (let ((cbeg (point)))
+            (set-syntax-table mail-extr-address-text-comment-syntax-table)
+            (if (memq (following-char) '(?\' ?\`))
+                (search-forward "'" nil 'move
+                                (if (eq ?\' (following-char)) 2 1))
+              (or (mail-extr-safe-move-sexp 1)
+                  (goto-char (point-max))))
+            (set-syntax-table mail-extr-address-text-syntax-table)
+            (when (eq (char-after cbeg) ?\()
+              ;; Delete the comment itself.
+              (delete-region cbeg (point))
+              ;; Canonicalize whitespace where the comment was.
+              (skip-chars-backward " \t")
+              (if (looking-at "\\([ \t]+$\\|[ \t]+,\\)")
+                  (replace-match "")
+                (setq cbeg (point))
+                (skip-chars-forward " \t")
+                (if (bobp)
+                    (delete-region (point) cbeg)
+                  (just-one-space))))))
+
+        ;; This was moved above.
+        ;; Fix . used as space
+        ;; But it belongs here because it occurs not only as
+        ;;   rypens@reks.uia.ac.be (Piet.Rypens)
+        ;; but also as
+        ;;   "Piet.Rypens" <rypens@reks.uia.ac.be>
+        ;;(goto-char (point-min))
+        ;;(while (re-search-forward mail-extr-bad-dot-pattern nil t)
+        ;;  (replace-match "\\1 \\2" t))
+
+        (unless (search-forward " " nil t)
+          (goto-char (point-min))
+          (cond ((search-forward "_" nil t)
+                 ;; Handle the *idiotic* use of underlines as spaces.
+                 ;; Example: fml@foo.bar.dom (First_M._Last)
+                 (goto-char (point-min))
+                 (while (search-forward "_" nil t)
+                   (replace-match " " t)))
+                ((search-forward "." nil t)
+                 ;; Fix . used as space
+                 ;; Example: danj1@cb.att.com (daniel.jacobson)
+                 (goto-char (point-min))
+                 (while (re-search-forward mail-extr-bad-dot-pattern nil t)
+                   (replace-match "\\1 \\2" t)))))
 
-         ;; Stop after name suffix
-         ((and (>= word-count 2)
-               (looking-at mail-extr-full-name-suffix-pattern))
-          (mail-extr-skip-whitespace-backward)
-          (setq suffix-flag (point))
-          (if (eq ?, (following-char))
-              (forward-char 1)
-            (insert ?,))
-          ;; Enforce at least one space after comma
-          (or (eq ?\  (following-char))
-              (insert ?\ ))
+        ;; Loop over the words (and other junk) in the name.
+        (goto-char (point-min))
+        (while (not name-done-flag)
+
+          (when word-found-flag
+            ;; Last time through this loop we skipped over a word.
+            (setq last-word-beg this-word-beg)
+            (setq drop-last-word-if-trailing-flag
+                  drop-this-word-if-trailing-flag)
+            (setq word-found-flag nil))
+
+          (when begin-again-flag
+            ;; Last time through the loop we found something that
+            ;; indicates we should pretend we are beginning again from
+            ;; the start.
+            (setq word-count 0)
+            (setq last-word-beg nil)
+            (setq drop-last-word-if-trailing-flag nil)
+            (setq mixed-case-flag nil)
+            (setq lower-case-flag nil)
+            ;;         (setq upper-case-flag nil)
+            (setq begin-again-flag nil))
+
+          ;; Initialize for this iteration of the loop.
           (mail-extr-skip-whitespace-forward)
-          (cond ((memq (following-char) '(?j ?J ?s ?S))
-                 (capitalize-word 1)
-                 (if (eq (following-char) ?.)
-                     (forward-char 1)
-                   (insert ?.)))
-                (t
-                 (upcase-word 1)))
-          (setq word-found-flag t)
-          (setq name-done-flag t))
-
-         ;; Handle SCA names
-         ((looking-at "MKA \\(.+\\)")   ; "Mundanely Known As"
-          (goto-char (match-beginning 1))
-          (narrow-to-region (point) (point-max))
-          (setq begin-again-flag t))
-
-         ;; Check for initial last name followed by comma
-         ((and (eq ?, (following-char))
-               (eq word-count 1))
-          (forward-char 1)
-          (setq last-name-comma-flag t)
-          (or (eq ?\  (following-char))
-              (insert ?\ )))
-
-         ;; Stop before trailing comma-separated comment
-         ;; THIS CASE MUST BE AFTER THE PRECEDING CASES.
-         ;; *** This case is redundant???
-         ;;((eq ?, (following-char))
-         ;; (setq name-done-flag t))
-
-         ;; Delete parenthesized/quoted comment/nickname
-         ((memq (following-char) '(?\( ?\{ ?\[ ?\" ?\' ?\`))
-          (setq cbeg (point))
-          (set-syntax-table mail-extr-address-text-comment-syntax-table)
-          (cond ((memq (following-char) '(?\' ?\`))
-                 (or (search-forward "'" nil t
-                                     (if (eq ?\' (following-char)) 2 1))
-                     (delete-char 1)))
-                (t
-                 (or (mail-extr-safe-move-sexp 1)
-                     (goto-char (point-max)))))
-          (set-syntax-table mail-extr-address-text-syntax-table)
-          (setq cend (point))
+          (if (eq word-count 0) (narrow-to-region (point) (point-max)))
+          (setq this-word-beg (point))
+          (setq drop-this-word-if-trailing-flag nil)
+
+          ;; Decide what to do based on what we are looking at.
           (cond
-           ;; Handle case of entire name being quoted
+
+           ;; Delete title
            ((and (eq word-count 0)
-                 (looking-at " *\\'")
-                 (>= (- cend cbeg) 2))
-            (narrow-to-region (1+ cbeg) (1- cend))
-            (goto-char (point-min)))
-           (t
-            ;; Handle case of quoted initial
-            (if (and (or (= 3 (- cend cbeg))
-                         (and (= 4 (- cend cbeg))
-                              (eq ?. (char-after (+ 2 cbeg)))))
-                     (not (looking-at " *\\'")))
-                (setq initial (char-after (1+ cbeg)))
-              (setq initial nil))
-            (delete-region cbeg cend)
-            (if initial
-                (insert initial ". ")))))
-
-         ;; Handle *Stupid* VMS date stamps
-         ((looking-at mail-extr-stupid-vms-date-stamp-pattern)
-          (replace-match "" t))
-
-         ;; Handle Chinese characters.
-         ((looking-at mail-extr-hz-embedded-gb-encoded-chinese-pattern)
-          (goto-char (match-end 0))
-          (setq word-found-flag t))
-
-         ;; Skip initial garbage characters.
-         ;; THIS CASE MUST BE AFTER THE PRECEDING CASES.
-         ((and (eq word-count 0)
-               (looking-at mail-extr-leading-garbage))
-          (goto-char (match-end 0))
-          ;; *** Skip backward over these???
-          ;; (skip-chars-backward "& \"")
-          (narrow-to-region (point) (point-max)))
+                 (looking-at mail-extr-full-name-prefixes))
+            (goto-char (match-end 0))
+            (narrow-to-region (point) (point-max)))
 
-         ;; Various stopping points
-         ((or
-
-           ;; Stop before ALL CAPS acronyms, if preceded by mixed-case
-           ;; words.  Example: XT-DEM.
-           (and (>= word-count 2)
-                mixed-case-flag
-                (looking-at mail-extr-weird-acronym-pattern)
-                (not (looking-at mail-extr-roman-numeral-pattern)))
-
-           ;; Stop before trailing alternative address
-           (looking-at mail-extr-alternative-address-pattern)
-
-           ;; Stop before trailing comment not introduced by comma
-           ;; THIS CASE MUST BE AFTER AN EARLIER CASE.
-           (looking-at mail-extr-trailing-comment-start-pattern)
-
-           ;; Stop before telephone numbers
-           (and (>= word-count 1)
-                (looking-at mail-extr-telephone-extension-pattern)))
-          (setq name-done-flag t))
-
-         ;; Delete ham radio call signs
-         ((looking-at mail-extr-ham-call-sign-pattern)
-          (delete-region (match-beginning 0) (match-end 0)))
-
-         ;; Fixup initials
-         ((looking-at mail-extr-initial-pattern)
-          (or (eq (following-char) (upcase (following-char)))
-              (setq lower-case-flag t))
-          (forward-char 1)
-          (if (eq ?. (following-char))
-              (forward-char 1)
-            (insert ?.))
-          (or (eq ?\  (following-char))
-              (insert ?\ ))
-          (setq word-found-flag t))
-
-         ;; Handle BITNET LISTSERV list names.
-         ((and (eq word-count 0)
-               (looking-at mail-extr-listserv-list-name-pattern))
-          (narrow-to-region (match-beginning 1) (match-end 1))
-          (setq word-found-flag t)
-          (setq name-done-flag t))
-
-         ;; Handle & substitution, when & is last and is not first.
-         ((and (> word-count 0)
-               (eq ?\  (preceding-char))
-               (eq (following-char) ?&)
-               (eq (1+ (point)) (point-max)))
-          (delete-char 1)
-          (capitalize-region
-           (point)
-           (progn
-             (insert-buffer-substring canonicalization-buffer
-                                      mbox-beg mbox-end)
-             (point)))
-          (setq disable-initial-guessing-flag t)
-          (setq word-found-flag t))
-
-         ;; Handle & between names, as in "Bob & Susie".
-         ((and (> word-count 0) (eq (following-char) ?\&))
-          (setq name-beg (point))
-          (setq name-end (1+ name-beg))
-          (setq word-found-flag t)
-          (goto-char name-end))
-
-         ;; Regular name words
-         ((looking-at mail-extr-name-pattern)
-          (setq name-beg (point))
-          (setq name-end (match-end 0))
-
-          ;; Certain words will be dropped if they are at the end.
-          (and (>= word-count 2)
-               (not lower-case-flag)
-               (or
-                ;; Trailing 4-or-more letter lowercase words preceded by
-                ;; mixed case or uppercase words will be dropped.
-                (looking-at "[[:lower:]]\\{4,\\}[ \t]*\\'")
-                ;; Drop a trailing word which is terminated with a period.
-                (eq ?. (char-after (1- name-end))))
-               (setq drop-this-word-if-trailing-flag t))
-
-          ;; Set the flags that indicate whether we have seen a lowercase
-          ;; word, a mixed case word, and an uppercase word.
-          (if (re-search-forward "[[:lower:]]" name-end t)
-              (if (progn
-                    (goto-char name-beg)
-                    (re-search-forward "[[:upper:]]" name-end t))
-                  (setq mixed-case-flag t)
+           ;; Stop after name suffix
+           ((and (>= word-count 2)
+                 (looking-at mail-extr-full-name-suffix-pattern))
+            (mail-extr-skip-whitespace-backward)
+            (setq suffix-flag (point))
+            (if (eq ?, (following-char))
+                (forward-char 1)
+              (insert ?,))
+            ;; Enforce at least one space after comma
+            (or (eq ?\  (following-char))
+                (insert ?\ ))
+            (mail-extr-skip-whitespace-forward)
+            (cond ((memq (following-char) '(?j ?J ?s ?S))
+                   (capitalize-word 1)
+                   (if (eq (following-char) ?.)
+                       (forward-char 1)
+                     (insert ?.)))
+                  (t
+                   (upcase-word 1)))
+            (setq word-found-flag t)
+            (setq name-done-flag t))
+
+           ;; Handle SCA names
+           ((looking-at "MKA \\(.+\\)") ; "Mundanely Known As"
+            (goto-char (match-beginning 1))
+            (narrow-to-region (point) (point-max))
+            (setq begin-again-flag t))
+
+           ;; Check for initial last name followed by comma
+           ((and (eq ?, (following-char))
+                 (eq word-count 1))
+            (forward-char 1)
+            (setq last-name-comma-flag t)
+            (or (eq ?\  (following-char))
+                (insert ?\ )))
+
+           ;; Stop before trailing comma-separated comment
+           ;; THIS CASE MUST BE AFTER THE PRECEDING CASES.
+           ;; *** This case is redundant???
+           ;;((eq ?, (following-char))
+           ;; (setq name-done-flag t))
+
+           ;; Delete parenthesized/quoted comment/nickname
+           ((memq (following-char) '(?\( ?\{ ?\[ ?\" ?\' ?\`))
+            (setq cbeg (point))
+            (set-syntax-table mail-extr-address-text-comment-syntax-table)
+            (cond ((memq (following-char) '(?\' ?\`))
+                   (or (search-forward "'" nil t
+                                       (if (eq ?\' (following-char)) 2 1))
+                       (delete-char 1)))
+                  (t
+                   (or (mail-extr-safe-move-sexp 1)
+                       (goto-char (point-max)))))
+            (set-syntax-table mail-extr-address-text-syntax-table)
+            (setq cend (point))
+            (cond
+             ;; Handle case of entire name being quoted
+             ((and (eq word-count 0)
+                   (looking-at " *\\'")
+                   (>= (- cend cbeg) 2))
+              (narrow-to-region (1+ cbeg) (1- cend))
+              (goto-char (point-min)))
+             (t
+              ;; Handle case of quoted initial
+              (if (and (or (= 3 (- cend cbeg))
+                           (and (= 4 (- cend cbeg))
+                                (eq ?. (char-after (+ 2 cbeg)))))
+                       (not (looking-at " *\\'")))
+                  (setq initial (char-after (1+ cbeg)))
+                (setq initial nil))
+              (delete-region cbeg cend)
+              (if initial
+                  (insert initial ". ")))))
+
+           ;; Handle *Stupid* VMS date stamps
+           ((looking-at mail-extr-stupid-vms-date-stamp-pattern)
+            (replace-match "" t))
+
+           ;; Handle Chinese characters.
+           ((looking-at mail-extr-hz-embedded-gb-encoded-chinese-pattern)
+            (goto-char (match-end 0))
+            (setq word-found-flag t))
+
+           ;; Skip initial garbage characters.
+           ;; THIS CASE MUST BE AFTER THE PRECEDING CASES.
+           ((and (eq word-count 0)
+                 (looking-at mail-extr-leading-garbage))
+            (goto-char (match-end 0))
+            ;; *** Skip backward over these???
+            ;; (skip-chars-backward "& \"")
+            (narrow-to-region (point) (point-max)))
+
+           ;; Various stopping points
+           ((or
+
+             ;; Stop before ALL CAPS acronyms, if preceded by mixed-case
+             ;; words.  Example: XT-DEM.
+             (and (>= word-count 2)
+                  mixed-case-flag
+                  (looking-at mail-extr-weird-acronym-pattern)
+                  (not (looking-at mail-extr-roman-numeral-pattern)))
+
+             ;; Stop before trailing alternative address
+             (looking-at mail-extr-alternative-address-pattern)
+
+             ;; Stop before trailing comment not introduced by comma
+             ;; THIS CASE MUST BE AFTER AN EARLIER CASE.
+             (looking-at mail-extr-trailing-comment-start-pattern)
+
+             ;; Stop before telephone numbers
+             (and (>= word-count 1)
+                  (looking-at mail-extr-telephone-extension-pattern)))
+            (setq name-done-flag t))
+
+           ;; Delete ham radio call signs
+           ((looking-at mail-extr-ham-call-sign-pattern)
+            (delete-region (match-beginning 0) (match-end 0)))
+
+           ;; Fixup initials
+           ((looking-at mail-extr-initial-pattern)
+            (or (eq (following-char) (upcase (following-char)))
                 (setq lower-case-flag t))
-;;          (setq upper-case-flag t)
-            )
+            (forward-char 1)
+            (if (eq ?. (following-char))
+                (forward-char 1)
+              (insert ?.))
+            (or (eq ?\  (following-char))
+                (insert ?\ ))
+            (setq word-found-flag t))
+
+           ;; Handle BITNET LISTSERV list names.
+           ((and (eq word-count 0)
+                 (looking-at mail-extr-listserv-list-name-pattern))
+            (narrow-to-region (match-beginning 1) (match-end 1))
+            (setq word-found-flag t)
+            (setq name-done-flag t))
+
+           ;; Handle & substitution, when & is last and is not first.
+           ((and (> word-count 0)
+                 (eq ?\  (preceding-char))
+                 (eq (following-char) ?&)
+                 (eq (1+ (point)) (point-max)))
+            (delete-char 1)
+            (capitalize-region
+             (point)
+             (progn
+               (insert-buffer-substring canonicalization-buffer
+                                        mbox-beg mbox-end)
+               (point)))
+            (setq disable-initial-guessing-flag t)
+            (setq word-found-flag t))
+
+           ;; Handle & between names, as in "Bob & Susie".
+           ((and (> word-count 0) (eq (following-char) ?\&))
+            (setq name-beg (point))
+            (setq name-end (1+ name-beg))
+            (setq word-found-flag t)
+            (goto-char name-end))
+
+           ;; Regular name words
+           ((looking-at mail-extr-name-pattern)
+            (setq name-beg (point))
+            (setq name-end (match-end 0))
+
+            ;; Certain words will be dropped if they are at the end.
+            (and (>= word-count 2)
+                 (not lower-case-flag)
+                 (or
+                  ;; Trailing 4-or-more letter lowercase words preceded by
+                  ;; mixed case or uppercase words will be dropped.
+                  (looking-at "[[:lower:]]\\{4,\\}[ \t]*\\'")
+                  ;; Drop a trailing word which is terminated with a period.
+                  (eq ?. (char-after (1- name-end))))
+                 (setq drop-this-word-if-trailing-flag t))
+
+            ;; Set the flags that indicate whether we have seen a lowercase
+            ;; word, a mixed case word, and an uppercase word.
+            (if (re-search-forward "[[:lower:]]" name-end t)
+                (if (progn
+                      (goto-char name-beg)
+                      (re-search-forward "[[:upper:]]" name-end t))
+                    (setq mixed-case-flag t)
+                  (setq lower-case-flag t))
+              ;;            (setq upper-case-flag t)
+              )
 
-          (goto-char name-end)
-          (setq word-found-flag t))
+            (goto-char name-end)
+            (setq word-found-flag t))
 
-         ;; Allow a number as a word, if it doesn't mean anything else.
-         ((looking-at "[0-9]+\\>")
-          (setq name-beg (point))
-          (setq name-end (match-end 0))
+           ;; Allow a number as a word, if it doesn't mean anything else.
+           ((looking-at "[0-9]+\\>")
+            (setq name-beg (point))
+            (setq name-end (match-end 0))
+            (goto-char name-end)
+            (setq word-found-flag t))
+
+           (t
+            (setq name-done-flag t)
+            ))
+
+          ;; Count any word that we skipped over.
+          (if word-found-flag
+              (setq word-count (1+ word-count))))
+
+        ;; If the last thing in the name is 2 or more periods, or one or more
+        ;; other sentence terminators (but not a single period) then keep them
+        ;; and the preceding word.  This is for the benefit of whole sentences
+        ;; in the name field: it's better behavior than dropping the last word
+        ;; of the sentence...
+        (if (and (not suffix-flag)
+                 (looking-at "\\(\\.+\\|[?!;:.][?!;:.]+\\|[?!;:][?!;:.]*\\)\\'"))
+            (goto-char (setq suffix-flag (point-max))))
+
+        ;; Drop everything after point and certain trailing words.
+        (narrow-to-region (point-min)
+                          (or (and drop-last-word-if-trailing-flag
+                                   last-word-beg)
+                              (point)))
+
+        ;; Xerox's mailers SUCK!!!!!!
+        ;; We simply refuse to believe that any last name is PARC or ADOC.
+        ;; If it looks like that is the last name, that there is no meaningful
+        ;; here at all.  Actually I guess it would be best to map patterns
+        ;; like foo.hoser@xerox.com into foo@hoser.xerox.com, but I don't
+        ;; actually know that that is what's going on.
+        (unless suffix-flag
+          (goto-char (point-min))
+          (let ((case-fold-search t))
+            (if (looking-at "[-A-Za-z_]+[. ]\\(PARC\\|ADOC\\)\\'")
+                (erase-buffer))))
+
+        ;; If last name first put it at end (but before suffix)
+        (when last-name-comma-flag
+          (goto-char (point-min))
+          (search-forward ",")
+          (setq name-end (1- (point)))
+          (goto-char (or suffix-flag (point-max)))
+          (or (eq ?\  (preceding-char))
+              (insert ?\ ))
+          (insert-buffer-substring (current-buffer) (point-min) name-end)
           (goto-char name-end)
-          (setq word-found-flag t))
-
-         (t
-          (setq name-done-flag t)
-          ))
-
-        ;; Count any word that we skipped over.
-        (if word-found-flag
-            (setq word-count (1+ word-count))))
-
-      ;; If the last thing in the name is 2 or more periods, or one or more
-      ;; other sentence terminators (but not a single period) then keep them
-      ;; and the preceding word.  This is for the benefit of whole sentences
-      ;; in the name field: it's better behavior than dropping the last word
-      ;; of the sentence...
-      (if (and (not suffix-flag)
-               (looking-at "\\(\\.+\\|[?!;:.][?!;:.]+\\|[?!;:][?!;:.]*\\)\\'"))
-          (goto-char (setq suffix-flag (point-max))))
-
-      ;; Drop everything after point and certain trailing words.
-      (narrow-to-region (point-min)
-                        (or (and drop-last-word-if-trailing-flag
-                                 last-word-beg)
-                            (point)))
-
-      ;; Xerox's mailers SUCK!!!!!!
-      ;; We simply refuse to believe that any last name is PARC or ADOC.
-      ;; If it looks like that is the last name, that there is no meaningful
-      ;; here at all.  Actually I guess it would be best to map patterns
-      ;; like foo.hoser@xerox.com into foo@hoser.xerox.com, but I don't
-      ;; actually know that that is what's going on.
-      (unless suffix-flag
-        (goto-char (point-min))
-        (let ((case-fold-search t))
-          (if (looking-at "[-A-Za-z_]+[. ]\\(PARC\\|ADOC\\)\\'")
-              (erase-buffer))))
+          (skip-chars-forward "\t ,")
+          (narrow-to-region (point) (point-max)))
 
-      ;; If last name first put it at end (but before suffix)
-      (when last-name-comma-flag
+        ;; Delete leading and trailing junk characters.
+        ;; *** This is probably completely unneeded now.
+        ;;(goto-char (point-max))
+        ;;(skip-chars-backward mail-extr-non-end-name-chars)
+        ;;(if (eq ?. (following-char))
+        ;;    (forward-char 1))
+        ;;(narrow-to-region (point)
+        ;;                  (progn
+        ;;                    (goto-char (point-min))
+        ;;                    (skip-chars-forward mail-extr-non-begin-name-chars)
+        ;;                    (point)))
+
+        ;; Compress whitespace
         (goto-char (point-min))
-        (search-forward ",")
-        (setq name-end (1- (point)))
-        (goto-char (or suffix-flag (point-max)))
-        (or (eq ?\  (preceding-char))
-            (insert ?\ ))
-        (insert-buffer-substring (current-buffer) (point-min) name-end)
-        (goto-char name-end)
-        (skip-chars-forward "\t ,")
-        (narrow-to-region (point) (point-max)))
-
-      ;; Delete leading and trailing junk characters.
-      ;; *** This is probably completely unneeded now.
-      ;;(goto-char (point-max))
-      ;;(skip-chars-backward mail-extr-non-end-name-chars)
-      ;;(if (eq ?. (following-char))
-      ;;    (forward-char 1))
-      ;;(narrow-to-region (point)
-      ;;                  (progn
-      ;;                    (goto-char (point-min))
-      ;;                    (skip-chars-forward mail-extr-non-begin-name-chars)
-      ;;                    (point)))
-
-      ;; Compress whitespace
-      (goto-char (point-min))
-      (while (re-search-forward "[ \t\n]+" nil t)
-        (replace-match (if (eobp) "" " ") t))
-      )))
+        (while (re-search-forward "[ \t\n]+" nil t)
+          (replace-match (if (eobp) "" " ") t))
+        ))))
 
 
 
diff --git a/man/ChangeLog b/man/ChangeLog
index a36b0c75fe4..4f2ce160de6 100644
--- a/man/ChangeLog
+++ b/man/ChangeLog
@@ -1,3 +1,9 @@
+2004-08-05  Lars Hansen  <larsh@math.ku.dk>
+
+        * widget.texi (User Interface): Update how to separate the
+        editable field of an editable-field widget from other widgets.
+        (Programming Example): Add text after field.
+
 2004-07-24  Richard M. Stallman  <rms@gnu.org>
 
         * text.texi (Paragraphs): Update how paragraphs are separated
diff --git a/man/widget.texi b/man/widget.texi
index 457af8a07bb..7e1d920cc62 100644
--- a/man/widget.texi
+++ b/man/widget.texi
@@ -213,14 +213,19 @@ middle of another field is prohibited.
 
 Editable text fields are created by the @code{editable-field} widget.
 
-An editable field must be surrounded by static text on both sides, that
-is, text that does not change in the lifetime of the widget.  If the
-field extends to the end of the line, the terminating line-feed character
-will count as the necessary static text on that end, but you will have
-to provide the static text before the field yourself.  The
-@code{:format} keyword is useful for generating the static text; for
-instance, if you give it a value of @code{"Name: %v"}, the "Name: " part
-will count as the static text.
+@strong{Warning:} In an @code{editable-field} widget, the editable
+field must not be adjacent to another widget---that won't work.
+You must put some text in between.  Either make this text part of
+the @code{editable-field} widget itself, or insert it with
+@code{widget-insert}.
+
+The @code{:format} keyword is useful for generating the necessary
+text; for instance, if you give it a value of @code{"Name: %v "},
+the @samp{Name: } part will provide the necessary separating text
+before the field and the trailing space will provide the
+separating text after the field.  If you don't include the
+@code{:size} keyword, the field will extend to the end of the
+line, and the terminating newline will provide separation after.
 
 The editing text fields are highlighted with the
 @code{widget-field-face} face, making them easy to find.
@@ -345,6 +350,7 @@ Interface}).
   (widget-insert "Here is some documentation.\n\nName: ")
   (widget-create 'editable-field
                  :size 13
+                 :format "%v " ; Text after the field!
                  "My Name")
   (widget-create 'menu-choice
                  :tag "Choose"
diff --git a/src/ChangeLog b/src/ChangeLog
index 0194c4b8c6f..2b0c47862d4 100644
--- a/src/ChangeLog
+++ b/src/ChangeLog
@@ -1,3 +1,8 @@
+2004-08-03  Kenichi Handa  <handa@m17n.org>
+
+        * coding.c (decode_coding_string): Adjust coding->consumed, and
+        etc. with shrinked_bytes.
+
 2004-08-03  Kim F. Storm  <storm@cua.dk>
 
         * indent.c (compute_motion): Fix check for full width window
diff --git a/src/coding.c b/src/coding.c
index b36f7fbfbff..1257771d3ed 100644
--- a/src/coding.c
+++ b/src/coding.c
@@ -6234,6 +6234,11 @@ decode_coding_string (str, coding, nocopy)
                    shrinked_bytes - from);
   free_conversion_buffer (&buf);
 
+  coding->consumed += shrinked_bytes;
+  coding->consumed_char += shrinked_bytes;
+  coding->produced += shrinked_bytes;
+  coding->produced_char += shrinked_bytes;
+
   if (coding->cmp_data && coding->cmp_data->used)
     coding_restore_composition (coding, newstr);
   coding_free_composition_data (coding);
diff --git a/src/indent.c b/src/indent.c
index d6fea34f5f5..ffde428c12f 100644
--- a/src/indent.c
+++ b/src/indent.c
@@ -1262,10 +1262,10 @@ compute_motion (from, fromvpos, fromhpos, did_motion, to, tovpos, tohpos, width,
         width -= 1;
     }
 
-  continuation_glyph_width = 0;
+  continuation_glyph_width = 1;
 #ifdef HAVE_WINDOW_SYSTEM
-  if (!FRAME_WINDOW_P (XFRAME (win->frame)))
-    continuation_glyph_width = 1;
+  if (FRAME_WINDOW_P (XFRAME (win->frame)))
+    continuation_glyph_width = 0;  /* In the fringe.  */
 #endif
 
   immediate_quit = 1;