Merged in changes from CVS trunk.

Patches applied:

 * miles@gnu.org--gnu-2004/emacs--cvs-trunk--0--patch-398
   Tweak permissions

 * miles@gnu.org--gnu-2004/emacs--cvs-trunk--0--patch-399
   Tweak directory permissions

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

 * miles@gnu.org--gnu-2004/emacs--cvs-trunk--0--patch-401
   More build-in-place tweaking of arch tagging

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

 * miles@gnu.org--gnu-2004/emacs--cvs-trunk--0--patch-403
   Yet more build-in-place tweaking of arch tagging

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

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

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

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


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

27 files changed, 1278 insertions, 826 deletions

diff --git a/lisp/.arch-inventory b/lisp/.arch-inventory
index 5341c2d8fec..9bd88350a95 100644
--- a/lisp/.arch-inventory
+++ b/lisp/.arch-inventory
@@ -1,4 +1,7 @@
 # Auto-generated lisp files, which ignore
 precious ^(loaddefs|finder-inf|cus-load)\.el$
 
+# Something generated during a windows build?!?
+precious ^(Makefile\.unix)$
+
 # arch-tag: fc62dc9f-3a91-455b-b8e7-d49df66beee0
diff --git a/lisp/ChangeLog b/lisp/ChangeLog
index 6dcc5c8fbbe..055bb70de3b 100644
--- a/lisp/ChangeLog
+++ b/lisp/ChangeLog
@@ -1,3 +1,149 @@
+2004-06-14  Kenichi Handa  <handa@m17n.org>
+
+        * international/code-pages.el (windows-1256, cp1125): Fix tables
+        for several characters.
+
+        * international/utf-8.el (ccl-encode-mule-utf-8): Fix previous
+        change.
+
+2004-06-13  Richard M. Stallman  <rms@gnu.org>
+
+        * textmodes/paragraphs.el (sentence-end): Add 0x5397d as close brace.
+
+        * emulation/pc-select.el: Doc fixes: say "PC Selection mode",
+        not "`pc-selection-mode'".
+
+        * emacs-lisp/bytecomp.el: Put `...' around symbols in warning messages.
+
+        * simple.el (previous-matching-history-element): Specify a default.
+
+        * hexl.el (hexl-mode): Catch errors in hexl-goto-address.
+
+        * cus-face.el (custom-declare-face): Simplify code.
+
+        * abbrev.el (abbrev-mode, edit-abbrevs-map): Doc fixes.
+
+2004-06-13  Luc Teirlinck  <teirllm@auburn.edu>
+
+        * files.el (before-save-hook): Add `time-stamp' to the options.
+
+        * time-stamp.el (time-stamp): Recommend adding it to
+        `before-save-hook', rather than `write-file-functions'
+        Make a similar change in `Commentary' section.
+
+2004-06-13  Kai Grossjohann  <kai.grossjohann@gmx.net>
+
+        * diff-mode.el (diff-current-defun): If at start of hunk, use
+        position of first change.
+
+2004-06-13  Lars Hansen  <larsh@math.ku.dk>
+
+        * dired-x.el (dired-mark-omitted): Bind to "*O".
+
+2004-06-12  Karl Fogel  <kfogel@red-bean.com>
+
+        * bookmark.el (bookmark-bmenu-relocate): New function, as
+        suggested by David J. Biesack <David.Biesack@sas.com>.
+        (bookmark-bmenu-mode-map): Bind `bookmark-bmenu-relocate' to "R".
+        (bookmark-bmenu-mode): Describe binding in doc string.
+        (bookmark-set-filename): Save the bookmark list if it's time.
+
+2004-06-13  Kenichi Handa  <handa@m17n.org>
+
+        * international/utf-8.el (ccl-decode-mule-utf-8): Fix previous
+        change.
+        (ccl-untranslated-to-ucs): Fix typo.
+
+2004-06-12  Karl Chen  <quarl@hkn.eecs.berkeley.edu>  (tiny change)
+
+        * progmodes/python.el (python-open-block-statement-p): Fix
+        indentation after a block opening that contains a comment.
+
+2004-06-12  J,Ai(Br,At(Bme Marant  <jerome@marant.org>  (tiny change)
+
+        * bindings.el (completion-ignored-extensions): Add file extensions
+        of Python byte-compiled files.
+
+2004-06-12  Juri Linkov  <juri@jurta.org>
+
+        * info.el (Info-goto-node): Add autoload.
+        (Info-toc): Add substring-no-properties on Info file name.
+        (Info-mode, info, Info-toc, Info-mode-menu): Doc fix.
+        (Info-mode-map): Bind L to Info-history, T to Info-toc.
+
+2004-06-12  Kenichi Handa  <handa@m17n.org>
+
+        * international/mule-cmds.el (set-language-environment): Load
+        subst tables if necessary.
+
+        * international/mule.el (decode-char): Load subst tables if
+        necessary.
+        (encode-char): Likewise.
+
+        * international/utf-16.el (utf-16-decode-ucs): Handle a surrogate
+        pair correctly.  Call ccl-mule-utf-untrans for untranslable chars.
+        (utf-16le-decode-loop): Set r5 to -1 before loop.
+        (utf-16be-decode-loop): Likewise.
+        (ccl-decode-mule-utf-16le): Add EOF processing block.
+        (ccl-decode-mule-utf-16be): Likewise.
+        (ccl-decode-mule-utf-16le-with-signature): Likewise.
+        (ccl-decode-mule-utf-16be-with-signature): Likewise.
+        (ccl-decode-mule-utf-16): Likewise.  Set r5 to -1 initially.
+        (ccl-mule-utf-16-encode-untrans): New CCL.
+        (utf-16-decode-to-ucs): Handle pre-read character.
+        (utf-16le-encode-loop): Handle surrogate pair.
+        (utf-16be-encode-loop): Likewise.
+        (ccl-encode-mule-utf-16le-with-signature): Adjusted for the change
+        of utf-16le-encode-loop.
+        (ccl-encode-mule-utf-16be-with-signature): Adjusted for the change
+        of utf-16be-encode-loop.
+        (mule-utf-16-post-read-conversion): Call
+        utf-8-post-read-conversion at first.
+        (mule-utf-16[{le|be}], mule-utf-16{le|be}-with-signature): Include
+        CJK charsets in safe-charsets if utf-translate-cjk-mode is on.
+        Add post-read-conversion and pre-write-conversion.
+
+        * international/utf-8.el (utf-translate-cjk-charsets): New
+        variable.
+        (utf-translate-cjk-unicode-range): New variable.
+        (utf-translate-cjk-load-tables): New function.
+        (utf-lookup-subst-table-for-decode): New function.
+        (utf-lookup-subst-table-for-encode): New function.
+        (utf-translate-cjk-mode): Init-value changed to t.  Don't load
+        tables here.  Update safe-charsets of utf-* coding systems.
+        (ccl-mule-utf-untrans): New CCL.
+        (ccl-decode-mule-utf-8): Call ccl-mule-utf-untrans.  Use `repeat'
+        at end of each branch.
+        (ccl-mule-utf-8-encode-untrans): New CCL.
+        (ccl-encode-mule-utf-8): Call ccl-mule-utf-8-encode-untrans.
+        (ccl-untranslated-to-ucs): Handle 2-byte encoding.  Set r1 to the
+        length of encoding.  Don't return r0.
+        (utf-8-compose): New arg hash-table.  Handle 2-byte encoding.
+        (utf-8-post-read-conversion): Narrow to region properly.  If
+        utf-translate-cjk-mode is on, load tables if necessary.  Call
+        utf-8-compose with hash-table arg if necessary.  Call
+        XXX-compose-region instead of XXX-post-read-convesion.
+        (utf-8-pre-write-conversion): New function.
+        (mule-utf-8): Include CJK charsets in safe-charsets if
+        utf-translate-cjk-mode is on.  Add pre-write-conversion.
+
+        * international/characters.el: Temporarily set
+        utf-translate-cjk-mode to nil.
+
+        * language/devan-util.el (devanagari-compose-region): Add
+        autoload cookie.
+
+        * international/ccl.el (ccl-dump-call): Fix printing the
+        subroutine name.
+
+2004-06-11  Luc Teirlinck  <teirllm@auburn.edu>
+
+        * dired.el (dired-revert): If buffer is marked unmodified before
+        reverting, keep it marked unmodified.
+        Adapt to new conventions for commenting out code.
+        (dired-make-relative): Adapt to new conventions for commenting out
+        code.
+
 2004-06-10  Miles Bader  <miles@gnu.ai.mit.edu>
 
         * eshell/esh-module.el (eshell-load-defgroups): Bind
@@ -2169,17 +2315,21 @@
         (desktop-buffer-info-misc-data): Rename to
         Info-desktop-buffer-misc-data and move to info.el.
         (desktop-read): Add message about number of buffers restored/failed.
+
         * dired.el (dired-restore-desktop-buffer) Move from desktop.el.
         Add parameters.  Pause to display error only when
         desktop-missing-file-warning is non-nil.
         (dired-desktop-buffer-misc-data): Move from desktop.el.  Add parameter.
         (dired-mode): Bind desktop-buffer-misc-data-function.
+
         * info.el (Info-restore-desktop-buffer): Move from desktop.el.
         Add Parameters.
         (Info-desktop-buffer-misc-data): Move from desktop.el.  Add parameter.
         (Info-mode): Bind desktop-buffer-misc-data-function.
+
         * mail/rmail.el (rmail-restore-desktop-buffer): Move from desktop.el.
         Add Parameters.
+
         * mh-e/mh-e.el (mh-restore-desktop-buffer): Move from desktop.el.
         Add Parameters.
 
diff --git a/lisp/abbrev.el b/lisp/abbrev.el
index 1e3eea0e359..3be0014fd0e 100644
--- a/lisp/abbrev.el
+++ b/lisp/abbrev.el
@@ -37,9 +37,9 @@ define global abbrevs instead."
   :group 'convenience)
 
 (defun abbrev-mode (&optional arg)
-  "Toggle abbrev mode.
+  "Toggle Abbrev mode in the current buffer.
 With argument ARG, turn abbrev mode on iff ARG is positive.
-In abbrev mode, inserting an abbreviation causes it to expand
+In Abbrev mode, inserting an abbreviation causes it to expand
 and be replaced by its expansion."
   (interactive "P")
   (setq abbrev-mode
@@ -48,18 +48,19 @@ and be replaced by its expansion."
   (force-mode-line-update))
 
 (defcustom abbrev-mode nil
-  "Toggle abbrev mode.
+  "Enable or disable Abbrev mode.
 Non-nil means automatically expand abbrevs as they are inserted.
 
+Setting this variable with `setq' changes it for the current buffer.
 Changing it with \\[customize] sets the default value.
-Use the command `abbrev-mode' to enable or disable Abbrev mode in the current
-buffer."
+Interactively, use the command `abbrev-mode'
+to enable or disable Abbrev mode in the current buffer."
   :type 'boolean
   :group 'abbrev-mode)
 
 
 (defvar edit-abbrevs-map nil
-  "Keymap used in edit-abbrevs.")
+  "Keymap used in `edit-abbrevs'.")
 (if edit-abbrevs-map
     nil
   (setq edit-abbrevs-map (make-sparse-keymap))
diff --git a/lisp/bindings.el b/lisp/bindings.el
index 2518c9bae08..68c4ec433f7 100644
--- a/lisp/bindings.el
+++ b/lisp/bindings.el
@@ -524,7 +524,9 @@ is okay.  See `mode-line-format'.")
          ;; files you do want to see, not just TeX stuff.  -- fx
          ".toc" ".aux"
          ".cp" ".fn" ".ky" ".pg" ".tp" ".vr"
-         ".cps" ".fns" ".kys" ".pgs" ".tps" ".vrs")))
+         ".cps" ".fns" ".kys" ".pgs" ".tps" ".vrs"
+         ;; Python byte-compiled
+         ".pyc" ".pyo")))
 
 ;; Suffixes used for executables.
 (setq exec-suffixes
diff --git a/lisp/bookmark.el b/lisp/bookmark.el
index 3ed66f229a8..b25c261c1e7 100644
--- a/lisp/bookmark.el
+++ b/lisp/bookmark.el
@@ -376,7 +376,11 @@ That is, all information but the name."
     (if cell
         (setcdr cell filename)
       (nconc (bookmark-get-bookmark-record bookmark)
-             (list (cons 'filename filename))))))
+             (list (cons 'filename filename))))
+    (setq bookmark-alist-modification-count
+          (1+ bookmark-alist-modification-count))
+    (if (bookmark-time-to-save-p)
+        (bookmark-save))))
 
 
 (defun bookmark-get-position (bookmark)
@@ -1491,6 +1495,7 @@ method buffers use to resolve name collisions."
   (define-key bookmark-bmenu-mode-map "m" 'bookmark-bmenu-mark)
   (define-key bookmark-bmenu-mode-map "l" 'bookmark-bmenu-load)
   (define-key bookmark-bmenu-mode-map "r" 'bookmark-bmenu-rename)
+  (define-key bookmark-bmenu-mode-map "R" 'bookmark-bmenu-relocate)
   (define-key bookmark-bmenu-mode-map "t" 'bookmark-bmenu-toggle-filenames)
   (define-key bookmark-bmenu-mode-map "a" 'bookmark-bmenu-show-annotation)
   (define-key bookmark-bmenu-mode-map "A" 'bookmark-bmenu-show-all-annotations)
@@ -1589,6 +1594,7 @@ Bookmark names preceded by a \"*\" have annotations.
   so the bookmark menu bookmark remains visible in its window.
 \\[bookmark-bmenu-switch-other-window] -- switch the other window to this bookmark.
 \\[bookmark-bmenu-rename] -- rename this bookmark \(prompts for new name\).
+\\[bookmark-bmenu-relocate] -- relocate this bookmark's file \(prompts for new file\).
 \\[bookmark-bmenu-delete] -- mark this bookmark to be deleted, and move down.
 \\[bookmark-bmenu-delete-backwards] -- mark this bookmark to be deleted, and move up.
 \\[bookmark-bmenu-execute-deletions] -- delete bookmarks marked with `\\[bookmark-bmenu-delete]'.
@@ -2041,6 +2047,15 @@ To carry out the deletions that you've marked, use \\<bookmark-bmenu-mode-map>\\
       (let ((bmrk (bookmark-bmenu-bookmark)))
         (message (bookmark-location bmrk)))))
 
+(defun bookmark-bmenu-relocate ()
+  "Change the file path of the bookmark on the current line,
+  prompting with completion for the new path."
+  (interactive)
+  (if (bookmark-bmenu-check-position)
+      (let ((bmrk (bookmark-bmenu-bookmark))
+            (thispoint (point)))
+        (bookmark-relocate bmrk)
+        (goto-char thispoint))))
 
 
 ;;; Menu bar stuff.  Prefix is "bookmark-menu".
diff --git a/lisp/cus-face.el b/lisp/cus-face.el
index b5716da161a..0bd3387d3c7 100644
--- a/lisp/cus-face.el
+++ b/lisp/cus-face.el
@@ -40,15 +40,11 @@
       (unless (facep face)
         ;; If the user has already created the face, respect that.
         (let ((value (or (get face 'saved-face) spec))
-              (frames (frame-list))
-              (have-window-system (memq initial-window-system '(x w32)))
-              frame)
+              (have-window-system (memq initial-window-system '(x w32))))
           ;; Create global face.
           (make-empty-face face)
           ;; Create frame-local faces
-          (while frames
-            (setq frame (car frames)
-                  frames (cdr frames))
+          (dolist (frame (frame-list))
             (face-spec-set face value frame)
             (when (memq (window-system frame) '(x w32))
               (setq have-window-system t)))
diff --git a/lisp/diff-mode.el b/lisp/diff-mode.el
index 9b00eae050d..26ff5441baf 100644
--- a/lisp/diff-mode.el
+++ b/lisp/diff-mode.el
@@ -1248,9 +1248,12 @@ If the prefix arg is bigger than 8 (for example with \\[universal-argument] \\[u
 (defun diff-current-defun ()
   "Find the name of function at point.
 For use in `add-log-current-defun-function'."
-  (destructuring-bind (buf line-offset pos src dst &optional switched)
-      (diff-find-source-location)
-    (save-excursion
+  (save-excursion
+    (when (looking-at diff-hunk-header-re)
+      (forward-line 1)
+      (while (and (looking-at " ") (not (zerop (forward-line 1))))))
+    (destructuring-bind (buf line-offset pos src dst &optional switched)
+        (diff-find-source-location)
       (beginning-of-line)
       (or (when (memq (char-after) '(?< ?-))
             ;; Cursor is pointing at removed text.  This could be a removed
diff --git a/lisp/dired-x.el b/lisp/dired-x.el
index caef06a64fb..6b44b73b170 100644
--- a/lisp/dired-x.el
+++ b/lisp/dired-x.el
@@ -239,7 +239,7 @@ to nil: a pipe using `zcat' or `gunzip -c' will be used."
 ;;; KEY BINDINGS.
 
 (define-key dired-mode-map "\M-o" 'dired-omit-mode)
-(define-key dired-mode-map "\M-O" 'dired-mark-omitted)
+(define-key dired-mode-map "*O" 'dired-mark-omitted)
 (define-key dired-mode-map "\M-(" 'dired-mark-sexp)
 (define-key dired-mode-map "*(" 'dired-mark-sexp)
 (define-key dired-mode-map "*." 'dired-mark-extension)
diff --git a/lisp/dired.el b/lisp/dired.el
index 3d3fd34b5ac..e5e23dfe2d6 100644
--- a/lisp/dired.el
+++ b/lisp/dired.el
@@ -880,7 +880,8 @@ Must also be called after dired-actual-switches have changed.
 Should not fail even on completely garbaged buffers.
 Preserves old cursor, marks/flags, hidden-p."
   (widen)                               ; just in case user narrowed
-  (let ((opoint (point))
+  (let ((modflag (buffer-modified-p))
+        (opoint (point))
         (ofile (dired-get-filename nil t))
         (mark-alist nil)                ; save marked files
         (hidden-subdirs (dired-remember-hidden))
@@ -907,9 +908,10 @@ Preserves old cursor, marks/flags, hidden-p."
     (save-excursion                     ; hide subdirs that were hidden
       (dolist (dir hidden-subdirs)
         (if (dired-goto-subdir dir)
-            (dired-hide-subdir 1)))))
+            (dired-hide-subdir 1))))
+    (unless modflag (restore-buffer-modified-p nil)))
   ;; outside of the let scope
-;;; Might as well not override the user if the user changed this.
+;;;  Might as well not override the user if the user changed this.
 ;;;  (setq buffer-read-only t)
   )
 
@@ -1707,7 +1709,7 @@ DIR must be a directory name, not a file name."
       (setq dir (expand-file-name dir)))
   (if (string-match (concat "^" (regexp-quote dir)) file)
       (substring file (match-end 0))
-;;; (or no-error
+;;;  (or no-error
 ;;;     (error "%s: not in directory tree growing at %s" file dir))
     file))
 
diff --git a/lisp/emacs-lisp/bytecomp.el b/lisp/emacs-lisp/bytecomp.el
index 8e20925c70d..a4ae751cab7 100644
--- a/lisp/emacs-lisp/bytecomp.el
+++ b/lisp/emacs-lisp/bytecomp.el
@@ -1008,11 +1008,11 @@ Each function's symbol gets added to `byte-compile-noruntime-functions'."
          (when (nth 2 new)))
     (byte-compile-set-symbol-position (car form))
     (if (memq 'obsolete byte-compile-warnings)
-        (byte-compile-warn "%s is an obsolete function%s; %s" (car form)
+        (byte-compile-warn "`%s' is an obsolete function%s; %s" (car form)
                            (if when (concat " since " when) "")
                            (if (stringp (car new))
                                (car new)
-                             (format "use %s instead." (car new)))))
+                             (format "use `%s' instead." (car new)))))
     (funcall (or handler 'byte-compile-normal-call) form)))
 
 ;; Compiler options
@@ -2076,7 +2076,7 @@ list that represents a doc string reference.
 (defun byte-compile-file-form-defsubst (form)
   (when (assq (nth 1 form) byte-compile-unresolved-functions)
     (setq byte-compile-current-form (nth 1 form))
-    (byte-compile-warn "defsubst %s was used before it was defined"
+    (byte-compile-warn "defsubst `%s' was used before it was defined"
                        (nth 1 form)))
   (byte-compile-file-form
    (macroexpand form byte-compile-macro-environment))
@@ -2206,7 +2206,7 @@ list that represents a doc string reference.
                     (not (assq (nth 1 form)
                                byte-compile-initial-macro-environment)))
                (byte-compile-warn
-                 "%s defined multiple times, as both function and macro"
+                 "`%s' defined multiple times, as both function and macro"
                  (nth 1 form)))
            (setcdr that-one nil))
           (this-one
@@ -2215,14 +2215,14 @@ list that represents a doc string reference.
                     ;; byte-compiler macros in byte-run.el...
                     (not (assq (nth 1 form)
                                byte-compile-initial-macro-environment)))
-             (byte-compile-warn "%s %s defined multiple times in this file"
+             (byte-compile-warn "%s `%s' defined multiple times in this file"
                                 (if macrop "macro" "function")
                                 (nth 1 form))))
           ((and (fboundp name)
                 (eq (car-safe (symbol-function name))
                     (if macrop 'lambda 'macro)))
            (when (memq 'redefine byte-compile-warnings)
-             (byte-compile-warn "%s %s being redefined as a %s"
+             (byte-compile-warn "%s `%s' being redefined as a %s"
                                 (if macrop "function" "macro")
                                 (nth 1 form)
                                 (if macrop "macro" "function")))
@@ -2695,7 +2695,7 @@ If FORM is a lambda or a macro, byte-compile it as a function."
                 (handler (get fn 'byte-compile)))
            (byte-compile-set-symbol-position fn)
            (when (byte-compile-const-symbol-p fn)
-             (byte-compile-warn "%s called as a function" fn))
+             (byte-compile-warn "`%s' called as a function" fn))
            (if (and handler
                     (or (not (byte-compile-version-cond
                               byte-compile-compatibility))
@@ -2730,9 +2730,9 @@ If FORM is a lambda or a macro, byte-compile it as a function."
   (if (or (not (symbolp var))
           (byte-compile-const-symbol-p var (not (eq base-op 'byte-varref))))
       (byte-compile-warn
-       (cond ((eq base-op 'byte-varbind) "attempt to let-bind %s %s")
-             ((eq base-op 'byte-varset) "variable assignment to %s %s")
-             (t "variable reference to %s %s"))
+       (cond ((eq base-op 'byte-varbind) "attempt to let-bind %s `%s'")
+             ((eq base-op 'byte-varset) "variable assignment to %s `%s'")
+             (t "variable reference to %s `%s'"))
        (if (symbolp var) "constant" "nonvariable")
        (prin1-to-string var))
     (if (and (get var 'byte-obsolete-variable)
@@ -2740,11 +2740,11 @@ If FORM is a lambda or a macro, byte-compile it as a function."
              (not (eq var byte-compile-not-obsolete-var)))
         (let* ((ob (get var 'byte-obsolete-variable))
                (when (cdr ob)))
-          (byte-compile-warn "%s is an obsolete variable%s; %s" var
+          (byte-compile-warn "`%s' is an obsolete variable%s; %s" var
                              (if when (concat " since " when) "")
                              (if (stringp (car ob))
                                  (car ob)
-                               (format "use %s instead." (car ob))))))
+                               (format "use `%s' instead." (car ob))))))
     (if (memq 'free-vars byte-compile-warnings)
         (if (eq base-op 'byte-varbind)
             (push var byte-compile-bound-variables)
@@ -2753,11 +2753,11 @@ If FORM is a lambda or a macro, byte-compile it as a function."
               (if (eq base-op 'byte-varset)
                   (or (memq var byte-compile-free-assignments)
                       (progn
-                        (byte-compile-warn "assignment to free variable %s" var)
+                        (byte-compile-warn "assignment to free variable `%s'" var)
                         (push var byte-compile-free-assignments)))
                 (or (memq var byte-compile-free-references)
                     (progn
-                      (byte-compile-warn "reference to free variable %s" var)
+                      (byte-compile-warn "reference to free variable `%s'" var)
                       (push var byte-compile-free-references))))))))
   (let ((tmp (assq var byte-compile-variables)))
     (unless tmp
@@ -2958,7 +2958,7 @@ If FORM is a lambda or a macro, byte-compile it as a function."
 
 (defun byte-compile-subr-wrong-args (form n)
   (byte-compile-set-symbol-position (car form))
-  (byte-compile-warn "%s called with %d arg%s, but requires %s"
+  (byte-compile-warn "`%s' called with %d arg%s, but requires %s"
                      (car form) (length (cdr form))
                      (if (= 1 (length (cdr form))) "" "s") n)
   ;; get run-time wrong-number-of-args error.
@@ -3124,7 +3124,7 @@ If FORM is a lambda or a macro, byte-compile it as a function."
           (if (and (consp (car body))
                    (not (eq 'byte-code (car (car body)))))
               (byte-compile-warn
-      "A quoted lambda form is the second argument of fset.  This is probably
+      "A quoted lambda form is the second argument of `fset'.  This is probably
      not what you want, as that lambda cannot be compiled.  Consider using
      the syntax (function (lambda (...) ...)) instead.")))))
   (byte-compile-two-args form))
@@ -3507,7 +3507,7 @@ being undefined will be suppressed."
     (byte-compile-set-symbol-position 'condition-case)
     (unless (symbolp var)
       (byte-compile-warn
-       "%s is not a variable-name or nil (in condition-case)" var))
+       "`%s' is not a variable-name or nil (in condition-case)" var))
     (byte-compile-push-constant var)
     (byte-compile-push-constant (byte-compile-top-level
                                  (nth 2 form) for-effect))
@@ -3525,13 +3525,13 @@ being undefined will be suppressed."
                                    (setq syms (cdr syms)))
                                  ok))))
                  (byte-compile-warn
-                   "%s is not a condition name or list of such (in condition-case)"
+                   "`%s' is not a condition name or list of such (in condition-case)"
                    (prin1-to-string condition)))
 ;;                ((not (or (eq condition 't)
 ;;                        (and (stringp (get condition 'error-message))
 ;;                             (consp (get condition 'error-conditions)))))
 ;;                 (byte-compile-warn
-;;                   "%s is not a known condition name (in condition-case)"
+;;                   "`%s' is not a known condition name (in condition-case)"
 ;;                   condition))
                 )
           (setq compiled-clauses
@@ -3627,7 +3627,7 @@ being undefined will be suppressed."
               (and (eq fun 'defconst) (null (cddr form))))
       (let ((ncall (length (cdr form))))
         (byte-compile-warn
-         "%s called with %d argument%s, but %s %s"
+         "`%s' called with %d argument%s, but %s %s"
          fun ncall
          (if (= 1 ncall) "" "s")
          (if (< ncall 2) "requires" "accepts only")
@@ -3644,7 +3644,7 @@ being undefined will be suppressed."
         `(push ',var current-load-list))
       (when (> (length form) 3)
         (when (and string (not (stringp string)))
-          (byte-compile-warn "third arg to %s %s is not a string: %s"
+          (byte-compile-warn "third arg to `%s %s' is not a string: %s"
                              fun var string))
         `(put ',var 'variable-documentation ,string))
       (if (cddr form)           ; `value' provided
diff --git a/lisp/emulation/pc-select.el b/lisp/emulation/pc-select.el
index c7ea973467f..188e335687c 100644
--- a/lisp/emulation/pc-select.el
+++ b/lisp/emulation/pc-select.el
@@ -61,7 +61,7 @@
 ;; Eli Barzilay (eli@cs.bgu.ac.il) suggested the sexps functions and
 ;; keybindings.
 ;;
-;; Ok, some details about the idea of pc-selection-mode:
+;; Ok, some details about the idea of PC Selection mode:
 ;;
 ;;  o The standard keys for moving around (right, left, up, down, home, end,
 ;;    prior, next, called "move-keys" from now on) will always de-activate
@@ -114,23 +114,23 @@ This gives mostly Emacs-like behaviour with only the selection keys enabled."
   :group 'pc-select)
 
 (defvar pc-select-saved-settings-alist nil
-  "The values of the variables before `pc-selection-mode' was toggled on.
-When `pc-selection-mode' is toggled on, it sets quite a few variables
+  "The values of the variables before PC Selection mode was toggled on.
+When PC Selection mode is toggled on, it sets quite a few variables
 for its own purposes.  This alist holds the original values of the
-variables `pc-selection-mode' had set, so that these variables can be
-restored to their original values when `pc-selection-mode' is toggled off.")
+variables PC Selection mode had set, so that these variables can be
+restored to their original values when PC Selection mode is toggled off.")
 
 (defvar pc-select-map nil
-  "The keymap used as the global map when `pc-selection-mode' is on." )
+  "The keymap used as the global map when PC Selection mode is on." )
 
 (defvar pc-select-saved-global-map nil
-  "The global map that was in effect when `pc-selection-mode' was toggled on.")
+  "The global map that was in effect when PC Selection mode was toggled on.")
 
 (defvar pc-select-key-bindings-alist nil
-  "This alist holds all the key bindings `pc-selection-mode' sets.")
+  "This alist holds all the key bindings PC Selection mode sets.")
 
 (defvar pc-select-default-key-bindings nil
-  "These key bindings always get set by `pc-selection-mode'.")
+  "These key bindings always get set by PC Selection mode.")
 
 (unless pc-select-default-key-bindings
   (let ((lst
@@ -250,7 +250,7 @@ These key bindings get installed when running in a tty, but only if
 (defvar pc-select-old-M-delete-binding nil
   "Holds the old mapping of [M-delete] in the `function-key-map'.
 This variable holds the value associated with [M-delete] in the
-`function-key-map' before `pc-selection-mode' had changed that
+`function-key-map' before PC Selection mode had changed that
 association.")
 
 ;;;;
@@ -842,7 +842,7 @@ M-LEFT and M-RIGHT move back or forward one word or sexp, disabling the mark.
 S-M-LEFT and S-M-RIGHT move back or forward one word or sexp, leaving the mark
 behind.  To control whether these keys move word-wise or sexp-wise set the
 variable `pc-select-meta-moves-sexps' after loading pc-select.el but before
-turning `pc-selection-mode' on.
+turning PC Selection mode on.
 
 C-DOWN and C-UP move back or forward a paragraph, disabling the mark.
 S-C-DOWN and S-C-UP move back or forward a paragraph, leaving the mark behind.
@@ -864,7 +864,7 @@ C-INSERT copies the region into the kill ring (`copy-region-as-kill').
 
 In addition, certain other PC bindings are imitated (to avoid this, set
 the variable `pc-select-selection-keys-only' to t after loading pc-select.el
-but before calling `pc-selection-mode'):
+but before calling PC Selection mode):
 
   F6           other-window
   DELETE       delete-char
@@ -974,7 +974,8 @@ but before calling `pc-selection-mode'):
 Change mark behaviour to emulate Motif, MAC or MS-Windows cut and paste style,
 and cursor movement commands.
 This mode enables Delete Selection mode and Transient Mark mode.
-You must modify via \\[customize] for this variable to have an effect."
+Setting this variable directly does not take effect;
+you must modify it using \\[customize] or \\[pc-selection-mode]."
   :set (lambda (symbol value)
          (pc-selection-mode (if value 1 -1)))
   :initialize 'custom-initialize-default
diff --git a/lisp/eshell/.arch-inventory b/lisp/eshell/.arch-inventory
new file mode 100644
index 00000000000..b5d82cdd6fc
--- /dev/null
+++ b/lisp/eshell/.arch-inventory
@@ -0,0 +1,4 @@
+# Generated files
+precious ^(esh-groups)\.el$
+
+# arch-tag: 8dc7bfaa-6ca6-4be0-915a-1e539c3dabfb
diff --git a/lisp/files.el b/lisp/files.el
index 4ee6da4e544..dc84c79df84 100644
--- a/lisp/files.el
+++ b/lisp/files.el
@@ -3024,7 +3024,7 @@ the last real save, but optional arg FORCE non-nil means delete anyway."
 
 (defcustom before-save-hook nil
   "Normal hook that is run before a buffer is saved to its file."
-  :options '(copyright-update)
+  :options '(copyright-update time-stamp)
   :type 'hook
   :group 'files)
 
diff --git a/lisp/hexl.el b/lisp/hexl.el
index cc36c37602e..883700933a8 100644
--- a/lisp/hexl.el
+++ b/lisp/hexl.el
@@ -217,7 +217,9 @@ You can use \\[hexl-find-file] to visit a file in Hexl mode.
         (set-buffer-modified-p modified))
       (make-local-variable 'hexl-max-address)
       (setq hexl-max-address max-address)
-      (hexl-goto-address original-point))
+      (condition-case nil
+          (hexl-goto-address original-point)
+        (error nil)))
 
     ;; We do not turn off the old major mode; instead we just
     ;; override most of it.  That way, we can restore it perfectly.
@@ -405,7 +407,7 @@ This function is indented to be used as eldoc callback."
 Signal error if ADDRESS out of range."
   (interactive "nAddress: ")
   (if (or (< address 0) (> address hexl-max-address))
-          (error "Out of hexl region"))
+      (error "Out of hexl region"))
   (goto-char (hexl-address-to-marker address)))
 
 (defun hexl-goto-hex-address (hex-address)
diff --git a/lisp/info.el b/lisp/info.el
index 14183383743..43e1dafcc6f 100644
--- a/lisp/info.el
+++ b/lisp/info.el
@@ -469,7 +469,8 @@ with the top-level Info directory.
 
 In interactive use, a non-numeric prefix argument directs
 this command to read a file name from the minibuffer.
-A numeric prefix argument appends the number to the buffer name.
+A numeric prefix argument selects an Info buffer with the prefix number
+appended to the Info buffer name.
 
 The search path for Info files is in the variable `Info-directory-list'.
 The top-level Info directory is made by combining all the files named `dir'
@@ -1315,6 +1316,7 @@ any double quotes or backslashes must be escaped (\\\",\\\\)."
 ;; Go to an info node specified with a filename-and-nodename string
 ;; of the sort that is found in pointers in nodes.
 
+;;;###autoload
 (defun Info-goto-node (nodename &optional fork)
   "Go to info node named NODENAME.  Give just NODENAME or (FILENAME)NODENAME.
 If NODENAME is of the form (FILENAME)NODENAME, the node is in the Info file
@@ -1672,7 +1674,8 @@ If SAME-FILE is non-nil, do not move to a different Info file."
     (goto-char (or p (point-min)))))
 
 (defun Info-toc ()
-  "Go to a node with table of contents of the current Info file."
+  "Go to a node with table of contents of the current Info file.
+Table of contents is created from the tree structure of menus."
   (interactive)
   (let ((curr-file Info-current-file)
         (curr-node Info-current-node)
@@ -1687,7 +1690,7 @@ If SAME-FILE is non-nil, do not move to a different Info file."
         (insert "*Note Top::\n")
         (Info-insert-toc
          (nth 2 (assoc "Top" node-list)) ; get Top nodes
-         node-list 0 curr-file))
+         node-list 0 (substring-no-properties curr-file)))
       (if (not (bobp))
           (let ((Info-hide-note-references 'hide)
                 (Info-fontify-visited-nodes nil))
@@ -2786,6 +2789,7 @@ if point is in a menu item description, follow that menu item."
   (define-key Info-mode-map "h" 'Info-help)
   (define-key Info-mode-map "i" 'Info-index)
   (define-key Info-mode-map "l" 'Info-last)
+  (define-key Info-mode-map "L" 'Info-history)
   (define-key Info-mode-map "m" 'Info-menu)
   (define-key Info-mode-map "n" 'Info-next)
   (define-key Info-mode-map "p" 'Info-prev)
@@ -2796,6 +2800,7 @@ if point is in a menu item description, follow that menu item."
   (define-key Info-mode-map "\M-s" 'Info-search)
   (define-key Info-mode-map "\M-n" 'clone-buffer)
   (define-key Info-mode-map "t" 'Info-top-node)
+  (define-key Info-mode-map "T" 'Info-toc)
   (define-key Info-mode-map "u" 'Info-up)
   ;; For consistency with dired-copy-filename-as-kill.
   (define-key Info-mode-map "w" 'Info-copy-current-node-name)
@@ -2843,9 +2848,9 @@ if point is in a menu item description, follow that menu item."
    ["Last" Info-last :active Info-history
     :help "Go to the last node you were at"]
    ["History" Info-history :active Info-history-list
-    :help "Go to the history buffer"]
+    :help "Go to menu of visited nodes"]
    ["Table of Contents" Info-toc
-    :help "Go to the buffer with a table of contents"]
+    :help "Go to table of contents"]
    ("Index..."
     ["Lookup a String" Info-index
      :help "Look for a string in the index items"]
@@ -2990,15 +2995,15 @@ Selecting other nodes:
 \\[Info-directory]      Go to the Info directory node.
 \\[Info-follow-reference]       Follow a cross reference.  Reads name of reference.
 \\[Info-last]   Move to the last node you were at.
-\\[Info-history]        Go to the history buffer.
-\\[Info-toc]    Go to the buffer with a table of contents.
-\\[Info-index]  Look up a topic in this file's Index and move to that node.
-\\[Info-index-next]     (comma) Move to the next match from a previous \\<Info-mode-map>\\[Info-index] command.
-\\[info-apropos]        Look for a string in the indices of all manuals.
+\\[Info-history]        Go to menu of visited nodes.
+\\[Info-toc]    Go to table of contents of the current Info file.
 \\[Info-top-node]       Go to the Top node of this file.
 \\[Info-final-node]     Go to the final node in this file.
 \\[Info-backward-node]  Go backward one node, considering all nodes as forming one sequence.
 \\[Info-forward-node]   Go forward one node, considering all nodes as forming one sequence.
+\\[Info-index]  Look up a topic in this file's Index and move to that node.
+\\[Info-index-next]     (comma) Move to the next match from a previous \\<Info-mode-map>\\[Info-index] command.
+\\[info-apropos]        Look for a string in the indices of all manuals.
 
 Moving within a node:
 \\[Info-scroll-up]      Normally, scroll forward a full screen.
@@ -3015,15 +3020,15 @@ Advanced commands:
 \\[Info-copy-current-node-name] Put name of current info node in the kill ring.
 \\[clone-buffer]        Select a new cloned Info buffer in another window.
 \\[Info-edit]   Edit contents of selected node.
-1       Pick first item in node's menu.
-2, 3, 4, 5   Pick second ... fifth item in node's menu.
+1 .. 9  Pick first ... ninth item in node's menu.
+          Every third `*' is highlighted to help pick the right number.
 \\[Info-goto-node]      Move to node specified by name.
           You may include a filename as well, as (FILENAME)NODENAME.
 \\[universal-argument] \\[info] Move to new Info file with completion.
+\\[universal-argument] N \\[info]       Select Info buffer with prefix number in the name *info*<N>.
 \\[Info-search] Search through this Info file for specified regexp,
           and select the node in which the next occurrence is found.
-\\[Info-search-case-sensitively]        Search through this Info file
-          for specified regexp case-sensitively.
+\\[Info-search-case-sensitively]        Search through this Info file for specified regexp case-sensitively.
 \\[Info-search-next]    Search for another occurrence of regexp
           from a previous \\<Info-mode-map>\\[Info-search] command.
 \\[Info-next-reference] Move cursor to next cross-reference or menu item.
diff --git a/lisp/international/ccl.el b/lisp/international/ccl.el
index e9e46bb0c6c..e55f1fbcf36 100644
--- a/lisp/international/ccl.el
+++ b/lisp/international/ccl.el
@@ -1120,7 +1120,8 @@
   (insert (format "write r%d (%d remaining)\n" rrr cc)))
 
 (defun ccl-dump-call (ignore cc)
-  (insert (format "call subroutine #%d\n" cc)))
+  (let ((subroutine (car (ccl-get-next-code))))
+    (insert (format "call subroutine `%s'\n" subroutine))))
 
 (defun ccl-dump-write-const-string (rrr cc)
   (if (= rrr 0)
diff --git a/lisp/international/characters.el b/lisp/international/characters.el
index 809c457c6e1..c33bd2eb43f 100644
--- a/lisp/international/characters.el
+++ b/lisp/international/characters.el
@@ -33,6 +33,11 @@
 
 ;;; Code:
 
+;; We must set utf-translate-cjk-mode to nil while loading this file
+;; to avoid translating CJK characters in decode-char.
+(defvar saved-utf-translate-cjk-mode utf-translate-cjk-mode)
+(setq utf-translate-cjk-mode nil)
+
 ;;; Predefined categories.
 
 ;; For each character set.
@@ -1277,6 +1282,10 @@
     (put-charset-property (car l) 'nospace-between-words t)
     (setq l (cdr l))))
 
+
+(setq utf-translate-cjk-mode saved-utf-translate-cjk-mode)
+(makunbound 'saved-utf-translate-cjk-mode)
+
 ;;; Local Variables:
 ;;; coding: iso-2022-7bit
 ;;; End:
diff --git a/lisp/international/code-pages.el b/lisp/international/code-pages.el
index 64c430f9383..0f8cdbf5713 100644
--- a/lisp/international/code-pages.el
+++ b/lisp/international/code-pages.el
@@ -2970,22 +2970,22 @@ Return an updated `non-iso-charset-alist'."
 (cp-make-coding-system
  windows-1256
  [?\€
-  ?\Ù 
+  ?\Ù¾
   ?\‚
-  ?\Ù¡
+  ?\Æ’
   ?\„
   ?\…
   ?\†
   ?\‡
-  ?\Ù¢
-  ?\Ù£
-  ?\Ù¤
+  ?\ˆ
+  ?\‰
+  ?\Ù¹
   ?\‹
-  ?\Ù¥
-  ?\Ù¦
-  ?\Ù§
-  ?\Ù¨
-  ?\Ù©
+  ?\Å’
+  ?\Ú†
+  ?\Ú˜
+  ?\Úˆ
+  ?\Ú¯
   ?\‘
   ?\’
   ?\“
@@ -2993,110 +2993,110 @@ Return an updated `non-iso-charset-alist'."
   ?\•
   ?\–
   ?\—
-  ?\Ø›
+  ?\Ú©
   ?\â„¢
-  ?\ØŸ
+  ?\Ú‘
   ?\›
-  ?\Ø¡
-  ?\Ø¢
-  ?\Ø£
-  ?\Ÿ
+  ?\Å“
+  ?\‌
+  ?\�
+  ?\Úº
   ?\ 
-  ?\ؤ
-  ?\Ø¥
+  ?\،
+  ?\¢
   ?\£
   ?\¤
-  ?\ئ
+  ?\Â¥
   ?\¦
   ?\§
-  ?\ا
+  ?\¨
   ?\©
-  ?\ب
+  ?\Ú¾
   ?\«
   ?\¬
   ?\­
   ?\®
-  ?\Ù¾
+  ?\¯
   ?\°
   ?\±
-  ?\Ø©
-  ?\ت
-  ?\Ø«
+  ?\²
+  ?\³
+  ?\´
   ?\µ
   ?\¶
   ?\·
+  ?\¸
+  ?\¹
+  ?\Ø›
+  ?\»
+  ?\¼
+  ?\½
+  ?\¾
+  ?\ØŸ
+  ?\Û�
+  ?\Ø¡
+  ?\Ø¢
+  ?\Ø£
+  ?\ؤ
+  ?\Ø¥
+  ?\ئ
+  ?\ا
+  ?\ب
+  ?\Ø©
+  ?\ت
+  ?\Ø«
   ?\ج
-  ?\Ú†
   ?\Ø­
-  ?\»
   ?\Ø®
   ?\د
   ?\Ø°
   ?\ر
-  ?\À
   ?\ز
-  ?\Â
-  ?\Ú˜
   ?\س
   ?\Ø´
   ?\ص
-  ?\Ç
-  ?\È
-  ?\É
-  ?\Ê
-  ?\Ë
   ?\ض
+  ?\×
   ?\Ø·
-  ?\ÃŽ
-  ?\�
-  ?\ã„“
+  ?\ظ
   ?\ع
   ?\غ
   ?\Ù€
-  ?\Ô
   ?\Ù�
   ?\Ù‚
-  ?\×
   ?\Ùƒ
-  ?\Ù
-  ?\Ú¯
-  ?\Û
-  ?\Ü
+  ?\à
   ?\Ù„
+  ?\â
   ?\Ù…
   ?\Ù†
-  ?\à
   ?\Ù‡
-  ?\â
-  ?\Ú�
   ?\Ùˆ
-  ?\Ù‰
-  ?\ÙŠ
   ?\ç
   ?\è
   ?\é
   ?\ê
   ?\ë
-  ?\Ù‹
-  ?\ٌ
+  ?\Ù‰
+  ?\ÙŠ
   ?\î
   ?\ï
+  ?\Ù‹
+  ?\ٌ
   ?\Ù�
   ?\ÙŽ
+  ?\ô
   ?\Ù�
   ?\Ù�
-  ?\ô
-  ?\Ù‘
-  ?\Ù’
   ?\÷
-  nil
+  ?\Ù‘
   ?\ù
-  nil
+  ?\Ù’
   ?\û
   ?\ü
   ?\‎
   ?\�
-  ?\ÿ]
+  ?\Û’]
  nil ?a) ;; Arabic
 
 (cp-make-coding-system
@@ -4430,11 +4430,11 @@ Return an updated `non-iso-charset-alist'."
   ?\Ñ–
   ?\Ї
   ?\Ñ—
-  ?\÷
-  ?\±
+  ?\·
+  ?\√
   ?\â„–
   ?\¤
-  ?\ï¿­
+  ?\â– 
   ?\ ])
 (define-coding-system-alias 'ruscii 'cp1125)
 ;; Original name for cp1125, says Serhii Hlodin <hlodin@lutsk.bank.gov.ua>
diff --git a/lisp/international/mule-cmds.el b/lisp/international/mule-cmds.el
index c9c462f028e..95177fdb954 100644
--- a/lisp/international/mule-cmds.el
+++ b/lisp/international/mule-cmds.el
@@ -1834,6 +1834,15 @@ specifies the character set for the major languages of Western Europe."
   (let ((func (get-language-info language-name 'setup-function)))
     (if (functionp func)
         (funcall func)))
+  (if (and utf-translate-cjk-mode
+           utf-translate-cjk-lang-env
+           (not (eq utf-translate-cjk-lang-env language-name))
+           (catch 'tag
+             (dolist (charset (get-language-info language-name 'charset))
+               (if (memq charset utf-translate-cjk-charsets)
+                   (throw 'tag t)))
+             nil))
+      (utf-translate-cjk-load-tables))
   (run-hooks 'set-language-environment-hook)
   (force-mode-line-update t))
 
diff --git a/lisp/international/mule.el b/lisp/international/mule.el
index c4c7be3a225..bbe83c2baf7 100644
--- a/lisp/international/mule.el
+++ b/lisp/international/mule.el
@@ -316,8 +316,7 @@ Optional argument RESTRICTION specifies a way to map the pair of CCS
 and CODE-POINT to a character.  Currently not supported and just ignored."
   (cond
    ((eq ccs 'ucs)
-    (or (gethash code-point
-                 (get 'utf-subst-table-for-decode 'translation-hash-table))
+    (or (utf-lookup-subst-table-for-decode code-point)
         (let ((c (cond
                   ((< code-point 160)
                    code-point)
@@ -361,8 +360,7 @@ code-point in CCS.  Currently not supported and just ignored."
          (charset (car split))
          trans)
     (cond ((eq ccs 'ucs)
-           (or (gethash char (get 'utf-subst-table-for-encode
-                                  'translation-hash-table))
+           (or (utf-lookup-subst-table-for-encode char)
                (let ((table (get 'utf-translation-table-for-encode
                                  'translation-table)))
                  (setq trans (aref table char))
diff --git a/lisp/international/utf-16.el b/lisp/international/utf-16.el
index d924512b634..477cccc2bf9 100644
--- a/lisp/international/utf-16.el
+++ b/lisp/international/utf-16.el
@@ -48,99 +48,110 @@
 ;; things below, sometimes with commonality abstracted into a let
 ;; binding for maintenance convenience.
 
-;; We'd need new charsets distinct from ascii and eight-bit-control to
-;; deal with untranslated sequences, since we can't otherwise
-;; distinguish the bytes, as we can with utf-8.
-
-;; ;; Do a multibyte write for bytes in r3 and r4.
-;; ;; Intended for untranslatable utf-16 sequences.
-;; (define-ccl-program ccl-mule-utf-16-untrans
-;;   `(0
-;;      (if (r3 < 128)
-;;       (r0 = ,(charset-id 'ascii))
-;;        (if (r3 < 160)
-;;         (r0 = ,(charset-id 'eight-bit-control))
-;;       (r0 = ,(charset-id 'eight-bit-graphic))))
-;;      (if (r4 < 128)
-;;       (r0 = ,(charset-id 'ascii))
-;;        (if (r4 < 160)
-;;         (r0 = ,(charset-id 'eight-bit-control))
-;;       (r0 = ,(charset-id 'eight-bit-graphic))))
-;;      (r1 = r4)))
-;;   "Do a multibyte write for bytes in r3 and r4.
-;; First swap them if we're big endian, indicated by r5==0.
-;; Intended for untranslatable utf-16 sequences.")
-
 ;; Needed in macro expansion, so can't be let-bound.  Zapped after use.
 (eval-and-compile
 (defconst utf-16-decode-ucs
-  ;; We have the unicode in r1.  Output is charset ID in r0, code
-  ;; point in r1.
-  `((lookup-integer utf-subst-table-for-decode r1 r3)
-    (if r7                              ; got a translation
-        ((r0 = r1) (r1 = r3))
-      (if (r1 < 128)
-          (r0 = ,(charset-id 'ascii))
-        (if (r1 < 160)
-            (r0 = ,(charset-id 'eight-bit-control))
-          (if (r1 < 256)
-              ((r0 = ,(charset-id 'latin-iso8859-1))
-               (r1 -= 128))
-            (if (r1 < #x2500)
-                ((r0 = ,(charset-id 'mule-unicode-0100-24ff))
-                 (r1 -= #x100)
-                 (r2 = (((r1 / 96) + 32) << 7))
-                 (r1 %= 96)
-                 (r1 += (r2 + 32)))
-              (if (r1 < #x3400)
-                  ((r0 = ,(charset-id 'mule-unicode-2500-33ff))
-                   (r1 -= #x2500)
-                   (r2 = (((r1 / 96) + 32) << 7))
-                   (r1 %= 96)
-                   (r1 += (r2 + 32)))
-                (if (r1 < #xd800)       ; 2 untranslated bytes
-                    ;;           ;; Assume this is rare, so don't worry about the
-                    ;;           ;; overhead of the call.
-                    ;;           (call mule-utf-16-untrans)
-                    ((r0 = ,(charset-id 'mule-unicode-e000-ffff))
-                     (r1 = 15037))      ; U+fffd
-                  (if (r1 < #xe000)     ; surrogate
-                      ;;                        ((call mule-utf-16-untrans)
-                      ;;                         (write-multibyte-character r0 r1)
-                      ;;                         (read r3 r4)
-                      ;;                         (call mule-utf-16-untrans))
-                      ((read r3 r4)
-                       (r0 = ,(charset-id 'mule-unicode-e000-ffff))
-                       (r1 = 15037))
-                    ((r0 = ,(charset-id 'mule-unicode-e000-ffff))
-                     (r1 -= #xe000)
-                     (r2 = (((r1 / 96) + 32) << 7))
-                     (r1 %= 96)
-                     (r1 += (r2 + 32)))))))))))))
+  ;; If r5 is negative, r1 is a Unicode chacter code.  Otherise, r5 is
+  ;; the first of a surrogate pair and r1 is the second of the pair.
+  ;; Output is charset ID in r0, code point in r1.  R0 may be set to
+  ;; -1 in which case a caller should not write out r1.
+  `((if (r5 >= 0)
+        ((r0 = (r1 < #xDC00))
+         (if ((r1 >= #xE000) | r0)
+             ;; Invalid second code of surrogate pair.
+             ((r0 = r5)
+              (call ccl-mule-utf-untrans))
+           ((r1 -= #xDC00)
+            (r1 += (((r5 - #xD800) << 10) + #x10000))))
+         (r5 = -1)))
+    (if (r1 < 128)
+        (r0 = ,(charset-id 'ascii))
+      ((lookup-integer utf-subst-table-for-decode r1 r3)
+       (if r7                           ; got a translation
+           ((r0 = r1) (r1 = r3))
+         (if (r1 < 160)
+             (r0 = ,(charset-id 'eight-bit-control))
+           (if (r1 < 256)
+               ((r0 = ,(charset-id 'latin-iso8859-1))
+                (r1 -= 128))
+             (if (r1 < #x2500)
+                 ((r0 = ,(charset-id 'mule-unicode-0100-24ff))
+                  (r1 -= #x100)
+                  (r2 = (((r1 / 96) + 32) << 7))
+                  (r1 %= 96)
+                  (r1 += (r2 + 32)))
+               (if (r1 < #x3400)
+                   ((r0 = ,(charset-id 'mule-unicode-2500-33ff))
+                    (r1 -= #x2500)
+                    (r2 = (((r1 / 96) + 32) << 7))
+                    (r1 %= 96)
+                    (r1 += (r2 + 32)))
+                 (if (r1 < #xD800)
+                     ;; We can't have this character.
+                     ((r0 = r1)
+                      (call ccl-mule-utf-untrans)
+                      (r5 = -1)
+                      (r0 = -1))
+                   (if (r1 < #xDC00)
+                       ;; The first code of a surrogate pair.
+                       ((r5 = r1)
+                        (r0 = -1))
+                     (if (r1 < #xE000)
+                         ;; The second code of a surrogate pair, invalid.
+                         ((r0 = r1)
+                          (call ccl-mule-utf-untrans)
+                          (r5 = -1)
+                          (r0 = -1))
+                       (if (r1 < #x10000)
+                           ((r0 = ,(charset-id 'mule-unicode-e000-ffff))
+                            (r1 -= #xE000)
+                            (r2 = (((r1 / 96) + 32) << 7))
+                            (r1 %= 96)
+                            (r1 += (r2 + 32)))
+                         ;; We can't have this character.
+                         ((r0 = r1)
+                          (call ccl-mule-utf-untrans)
+                          (r5 = -1)
+                          (r0 = -1)))))))))))))))
 
 (defconst utf-16le-decode-loop
-  `(loop
-    (read r3 r4)
-    (r1 = (r4 <8 r3))
-    ,utf-16-decode-ucs
-    (translate-character utf-translation-table-for-decode r0 r1)
-    (write-multibyte-character r0 r1)
-    (repeat)))
+  `((r5 = -1)
+    (loop
+     (r3 = -1)
+     (read r3 r4)
+     (r1 = (r4 <8 r3))
+     ,@utf-16-decode-ucs
+     (if (r0 >= 0)
+         ((translate-character utf-translation-table-for-decode r0 r1)
+          (write-multibyte-character r0 r1)))
+     (repeat))))
 
 (defconst utf-16be-decode-loop
-  `(loop
-    (read r3 r4)
-    (r1 = (r3 <8 r4))
-    ,@utf-16-decode-ucs
-    (translate-character utf-translation-table-for-decode r0 r1)
-    (write-multibyte-character r0 r1)
-    (repeat)))
+  `((r5 = -1)
+    (loop
+     (r3 = -1)
+     (read r3 r4)
+     (r1 = (r3 <8 r4))
+     ,@utf-16-decode-ucs
+     (if (r0 >= 0)
+         ((translate-character utf-translation-table-for-decode r0 r1)
+          (write-multibyte-character r0 r1)))
+     (repeat))))
 
 )
 
 (define-ccl-program ccl-decode-mule-utf-16le
   `(2                                   ; 2 bytes -> 1 to 4 bytes
-    ,utf-16le-decode-loop)
+    ,utf-16le-decode-loop
+    ((if (r5 >= 0)
+         ((r0 = r5)
+          (call ccl-mule-utf-untrans)))
+     (if (r3 < 0)
+         nil
+       ((if (r3 < #xA0)
+            (r0 = ,(charset-id 'eight-bit-control))
+          (r0 = ,(charset-id 'eight-bit-graphic)))
+        (write-multibyte-character r0 r3)))))
   "Decode UTF-16LE (little endian without signature bytes).
 Basic decoding is done into the charsets ascii, latin-iso8859-1 and
 mule-unicode-*.  Un-representable Unicode characters are decoded as
@@ -149,7 +160,13 @@ U+fffd.  The result is run through the translation-table named
 
 (define-ccl-program ccl-decode-mule-utf-16be
   `(2                                   ; 2 bytes -> 1 to 4 bytes
-    ,utf-16be-decode-loop)
+    ,utf-16be-decode-loop
+    ((if (r5 >= 0)
+         ((r0 = r5)
+          (call ccl-mule-utf-untrans)))
+     (if (r3 >= 0)
+         ((r0 = r3)
+          (call ccl-mule-utf-untrans)))))
   "Decode UTF-16BE (big endian without signature bytes).
 Basic decoding is done into the charsets ascii, latin-iso8859-1 and
 mule-unicode-*.  Un-representable Unicode characters are
@@ -158,91 +175,218 @@ name `utf-translation-table-for-decode'.")
 
 (define-ccl-program ccl-decode-mule-utf-16le-with-signature
   `(2
-    ((read r3 r4)
-     ,utf-16le-decode-loop))
+    ((r3 = -1)
+     (read r3 r4)
+     ,@utf-16le-decode-loop)
+    (if (r3 >= 0)
+        ((r0 = r3)
+         (call ccl-mule-utf-untrans))))
   "Like ccl-decode-utf-16le but skip the first 2-byte BOM.")
 
 (define-ccl-program ccl-decode-mule-utf-16be-with-signature
   `(2
-    ((read r3 r4)
-     ,utf-16be-decode-loop))
+    ((r3 = -1)
+     (read r3 r4)
+     ,@utf-16be-decode-loop)
+    (if (r3 >= 0)
+        ((r0 = r3)
+         (call ccl-mule-utf-untrans))))
   "Like ccl-decode-utf-16be but skip the first 2-byte BOM.")
 
 (define-ccl-program ccl-decode-mule-utf-16
   `(2
-    ((read r3 r4)
+    ((r3 = -1)
+     (read r3 r4)
      (r1 = (r3 <8 r4))
+     (r5 = -1)
      (if (r1 == #xFFFE)
          ;; R1 is a BOM for little endian.  We keep this character as
          ;; is temporarily.  It is removed by post-read-conversion
          ;; function.
          (,@utf-16-decode-ucs
           (write-multibyte-character r0 r1)
-          ,utf-16le-decode-loop)
+          ,@utf-16le-decode-loop)
        ((if (r1 == #xFEFF)
             ;; R1 is a BOM for big endian, but we can't keep that
             ;; character in the output because it can't be
             ;; distinguished with the normal U+FEFF.  So, we keep
             ;; #xFFFF instead.
             ((r1 = #xFFFF)
-             ,@utf-16-decode-ucs)
-          ;; R1 a normal Unicode character.
+             ,@utf-16-decode-ucs
+             (write-multibyte-character r0 r1))
+          ;; R1 is a normal Unicode character.
           (,@utf-16-decode-ucs
-           (translate-character utf-translation-table-for-decode r0 r1)))
-        (write-multibyte-character r0 r1)
-        ,utf-16be-decode-loop))))
+           (if (r0 >= 0)
+               ((translate-character utf-translation-table-for-decode r0 r1)
+                (write-multibyte-character r0 r1)))))
+        ,@utf-16be-decode-loop)))
+    (if (r3 >= 0)
+        ((r0 = r3)
+         (call ccl-mule-utf-untrans))))
   "Like ccl-decode-utf-16be/le but check the first BOM.")
 
 (makunbound 'utf-16-decode-ucs)         ; done with it
 (makunbound 'utf-16le-decode-loop)
 (makunbound 'utf-16be-decode-loop)
 
+;; UTF-16 decoder generates an UTF-8 sequence represented by a
+;; sequence eight-bit-control/graphic chars for an invalid byte (the
+;; last byte of an odd length source) and an untranslatable character
+;; (including an invalid surrogate-pair code-point).
+;;
+;; This CCL parses that sequence (the first byte is already in r1),
+;; and if the sequence represents an untranslatable character, it sets
+;; r1 to the original invalid code or untranslated Unicode character
+;; code, sets r2 to -1 (to prevent r2 and r3 are written), set2 r5 to
+;; -1 (to tell the caller that there's no pre-read character).
+;;
+;; If the sequence represents an invalid byte, it sets r1 to -1, r2 to
+;; the byte, sets r3 and r5 to -1.
+;;
+;; Otherwise, don't change r1, set r2 and r3 to already read
+;; eight-bit-control/graphic characters (if any), set r5 and r6 to the
+;; last character that invalidates the UTF-8 form.
+;;
+;; Note: For UTF-8 validation, we only check if a character is
+;; eight-bit-control/graphic or not.  It may result in incorrect
+;; handling of random binary data, but such a data can't be encoded by
+;; UTF-16 anyway.  At least, UTF-16 decoder doesn't generate such a
+;; sequence even if a source contains invalid byte-sequence.
+
+(define-ccl-program ccl-mule-utf-16-encode-untrans
+  `(0
+    ((r2 = -1)
+     ;; Read the 2nd byte.
+     (read-multibyte-character r5 r6)
+     (r0 = (r5 != ,(charset-id 'eight-bit-control)))
+     (if ((r5 != ,(charset-id 'eight-bit-graphic)) & r0)
+         ((r2 = r1)
+          (r3 = -1)
+          (r1 = -1)
+          (end)))                       ; invalid UTF-8
+
+     (r3 = -1)
+     (r2 = r6)
+     (if (r1 <= #xE0)
+         ;; 2-byte UTF-8, i.e. originally an invalid byte.
+         ((r2 &= #x3F)
+          (r2 |= ((r1 & #x1F) << 6))
+          (r1 = -1)
+          (r5 = -1)
+          (end)))
+         
+     ;; Read the 3rd byte.
+     (read-multibyte-character r5 r6)
+     (r0 = (r5 != ,(charset-id 'eight-bit-control)))           
+     (if ((r5 != ,(charset-id 'eight-bit-graphic)) & r0)
+         ((end)))                       ; invalid UTF-8
+
+     (if (r1 < #xF0)            ; valid 3-byte UTF-8
+         ((r1 = ((r1 & #x0F) << 12))
+          (r1 |= ((r2 & #x3F) << 6))
+          (r1 |= (r6 & #x3F))
+          (r2 = -1)
+          (r5 = -1)
+          (end)))
+
+     (r3 = r6)
+     ;; Read the 4th byte.
+     (read-multibyte-character r5 r6)
+     (r0 = (r5 != ,(charset-id 'eight-bit-control)))           
+     (if ((r5 != ,(charset-id 'eight-bit-graphic)) & r0)
+         (end))                     ; livalid UTF-8
+
+     ;; valid 4-byte UTF-8
+     (r1 = ((r1 & #x07) << 18))
+     (r1 |= ((r2 & #x3F) << 12))
+     (r1 |= ((r3 & #x3F) << 6))
+     (r1 |= (r6 & #x3F))
+     (r2 = -1)
+     (r5 = -1)
+     (end))
+
+    (if (r1 >= 0)
+        ((write r1)
+         (if (r2 >= 0)
+             ((write r2)
+              (if (r3 >= 0)
+                  (write r3))))))))
+
 (eval-and-compile
 (defconst utf-16-decode-to-ucs
-  ;; CCL which, given the result of a multibyte read in r0 and r1,
-  ;; sets r0 to the character's Unicode if the charset is one of the
-  ;; basic utf-8 coding system ones.  Otherwise set to U+fffd.
-  `(if (r0 == ,(charset-id 'ascii))
-       (r0 = r1)
-     (if (r0 == ,(charset-id 'latin-iso8859-1))
-         (r0 = (r1 + 128))
-       (if (r0 == ,(charset-id 'eight-bit-control))
-           (r0 = r1)
-         (if (r0 == ,(charset-id 'eight-bit-graphic))
-             (r0 = r1)
-           ((r2 = (r1 & #x7f))
-            (r1 >>= 7)
-            (r3 = ((r1 - 32) * 96))
-            (r3 += (r2 - 32))
-            (if (r0 == ,(charset-id 'mule-unicode-0100-24ff))
-                (r0 = (r3 + #x100))
-              (if (r0 == ,(charset-id 'mule-unicode-2500-33ff))
-                  (r0 = (r3 + #x2500))
-                (if (r0 == ,(charset-id 'mule-unicode-e000-ffff))
-                    (r0 = (r3 + #xe000))
-                  (r0 = #xfffd))))))))))
+  ;; Read a character and set r1 to the corresponding Unicode code.
+  ;; If r5 is not negative, it means that we have already read a
+  ;; character into r5 and r6.
+  ;; If an invalid eight-bit-control/graphic sequence is found, r2 and
+  ;; r3 may contain a byte to written out, r5 and r6 may contain a
+  ;; pre-read character.  Usually they are set to -1.
+  `((if (r5 < 0)
+        (read-multibyte-character r0 r1)
+      ((r0 = r5)
+       (r1 = r6)
+       (r5 = -1)))
+    (lookup-character utf-subst-table-for-encode r0 r1)
+    (r2 = -1)
+    (if (r7 > 0)
+        (r1 = r0)
+      ((translate-character utf-translation-table-for-encode r0 r1)
+       (if (r0 == ,(charset-id 'ascii))
+           nil
+         (if (r0 == ,(charset-id 'latin-iso8859-1))
+             (r1 += 128)
+           (if (r0 == ,(charset-id 'eight-bit-control))
+               nil
+             (if (r0 == ,(charset-id 'eight-bit-graphic))
+                 (call ccl-mule-utf-16-encode-untrans)
+               ((r2 = ((r1 & #x7f) - 32))
+                (r3 = ((((r1 >> 7) - 32) * 96) + r2))
+                (r2 = -1)
+                (r5 = -1)
+                (if (r0 == ,(charset-id 'mule-unicode-0100-24ff))
+                    (r1 = (r3 + #x100))
+                  (if (r0 == ,(charset-id 'mule-unicode-2500-33ff))
+                      (r1 = (r3 + #x2500))
+                    (if (r0 == ,(charset-id 'mule-unicode-e000-ffff))
+                        (r1 = (r3 + #xe000))
+                      (r1 = #xfffd)))))))))))))
 
 (defconst utf-16le-encode-loop
-  `(loop
-    (read-multibyte-character r0 r1)
-    (lookup-character utf-subst-table-for-encode r0 r1)
-    (if (r7 == 0)
-        ((translate-character utf-translation-table-for-encode r0 r1)
-         ,utf-16-decode-to-ucs))
-    (write (r0 & 255))
-    (write (r0 >> 8))
-    (repeat)))
+  `((r5 = -1)
+    (loop
+     ,@utf-16-decode-to-ucs
+     (if (r1 >= #x10000)
+         ((r1 -= #x10000)
+          (r0 = ((r1 >> 10) + #xD800))
+          (write (r0 & 255))
+          (write (r0 >> 8))
+          (r1 = ((r1 & #x3FF) + #xDC00))))
+     (if (r1 >= 0)
+         ((write (r1 & 255))
+          (write (r1 >> 8))))
+     (if (r2 >= 0)
+         ((write r2)
+          (if (r3 >= 0)
+              (write r3))))
+     (repeat))))
 
 (defconst utf-16be-encode-loop
-  `(loop
-    (read-multibyte-character r0 r1)
-    (lookup-character utf-subst-table-for-encode r0 r1)
-    (if (r7 == 0)
-        ((translate-character utf-translation-table-for-encode r0 r1)
-         ,utf-16-decode-to-ucs))
-    (write (r0 >> 8))
-    (write (r0 & 255))
-    (repeat)))
+  `((r5 = -1)
+    (loop
+     ,@utf-16-decode-to-ucs
+     (if (r1 >= #x10000)
+         ((r1 -= #x10000)
+          (r0 = ((r1 >> 10) + #xD800))
+          (write (r0 >> 8))
+          (write (r0 & 255))
+          (r1 = ((r1 & #x3FF) + #xDC00))))
+     (if (r1 >= 0)
+         ((write (r1 >> 8))
+          (write (r1 & 255))))
+     (if (r2 >= 0)
+         ((write r2)
+          (if (r3 >= 0)
+              (write r3))))
+     (repeat))))
 )
 
 
@@ -270,7 +414,7 @@ Others are encoded as U+FFFD.")
   `(1
     ((write #xFF)
      (write #xFE)
-     ,utf-16le-encode-loop))
+     ,@utf-16le-encode-loop))
   "Encode to UTF-16 (little endian with signature).
 Characters from the charsets ascii, eight-bit-control,
 eight-bit-graphic, latin-iso8859-1 and mule-unicode-* are encoded
@@ -282,7 +426,7 @@ Others are encoded as U+FFFD.")
   `(1
     ((write #xFE)
      (write #xFF)
-     ,utf-16be-encode-loop))
+     ,@utf-16be-encode-loop))
   "Encode to UTF-16 (big endian with signature).
 Characters from the charsets ascii, eight-bit-control,
 eight-bit-graphic, latin-iso8859-1 and mule-unicode-* are encoded
@@ -296,6 +440,7 @@ Others are encoded as U+FFFD.")
 
 (defun mule-utf-16-post-read-conversion (length)
   (when (> length 0)
+    (setq length (utf-8-post-read-conversion length))
     (let ((char (following-char)))
       (cond ((= char (decode-char 'ucs #xFFFE))
              (delete-char 1)
@@ -329,29 +474,34 @@ if they are re-encoded.
 
 On encoding (e.g. writing a file), Emacs characters not belonging to
 any of the character sets listed above are encoded into the byte
-sequence representing U+FFFD (REPLACEMENT CHARACTER)."))
+sequence representing U+FFFD (REPLACEMENT CHARACTER).")
+      (props `((safe-charsets
+                ascii
+                eight-bit-control
+                eight-bit-graphic
+                latin-iso8859-1
+                mule-unicode-0100-24ff
+                mule-unicode-2500-33ff
+                mule-unicode-e000-ffff
+                ,@(if utf-translate-cjk-mode
+                      utf-translate-cjk-charsets))
+               (valid-codes (0 . 255))
+               (mime-text-unsuitable . t)
+               (pre-write-conversion . utf-8-pre-write-conversion)
+               (dependency unify-8859-on-encoding-mode
+                           unify-8859-on-decoding-mode
+                           utf-fragment-on-decoding
+                           utf-translate-cjk-mode))))
   (make-coding-system
    'mule-utf-16le 4
    ?u         ; Mule-UCS uses ?U, but code-pages uses that for koi8-u.
    (concat
     "UTF-16LE encoding for Emacs-supported Unicode characters."
     doc)
-
    '(ccl-decode-mule-utf-16le . ccl-encode-mule-utf-16le)
-   '((safe-charsets
-      ascii
-      eight-bit-control
-      latin-iso8859-1
-      mule-unicode-0100-24ff
-      mule-unicode-2500-33ff
-      mule-unicode-e000-ffff)
-     (mime-charset . utf-16le)
-     (mime-text-unsuitable . t)
-     (valid-codes (0 . 255))
-     (dependency unify-8859-on-encoding-mode
-                 unify-8859-on-decoding-mode
-                 utf-fragment-on-decoding
-                 utf-translate-cjk-mode)))
+   `(,@props
+     (post-read-conversion . utf-8-post-read-conversion)
+     (mime-charset . utf-16le)))
 
   (make-coding-system
    'mule-utf-16be 4 ?u
@@ -360,19 +510,9 @@ sequence representing U+FFFD (REPLACEMENT CHARACTER)."))
     doc)
 
    '(ccl-decode-mule-utf-16be . ccl-encode-mule-utf-16be)
-   '((safe-charsets
-      ascii
-      eight-bit-control
-      latin-iso8859-1
-      mule-unicode-0100-24ff
-      mule-unicode-2500-33ff
-      mule-unicode-e000-ffff)
-     (mime-charset . utf-16be)
-     (valid-codes (0 . 255))
-     (dependency unify-8859-on-encoding-mode
-                 unify-8859-on-decoding-mode
-                 utf-fragment-on-decoding
-                 utf-translate-cjk-mode)))
+   `(,@props
+     (post-read-conversion . utf-8-post-read-conversion)
+     (mime-charset . utf-16be)))
 
   (make-coding-system
    'mule-utf-16le-with-signature 4 ?u
@@ -382,21 +522,10 @@ sequence representing U+FFFD (REPLACEMENT CHARACTER)."))
 
    '(ccl-decode-mule-utf-16le-with-signature
      . ccl-encode-mule-utf-16le-with-signature)
-   '((safe-charsets
-      ascii
-      eight-bit-control
-      latin-iso8859-1
-      mule-unicode-0100-24ff
-      mule-unicode-2500-33ff
-      mule-unicode-e000-ffff)
+   `(,@props
+     (post-read-conversion . utf-8-post-read-conversion)
      (coding-category . coding-category-utf-16-le)
-     (mime-charset . utf-16)
-     (mime-text-unsuitable . t)
-     (valid-codes (0 . 255))
-     (dependency unify-8859-on-encoding-mode
-                 unify-8859-on-decoding-mode
-                 utf-fragment-on-decoding
-                 utf-translate-cjk-mode)))
+     (mime-charset . utf-16)))
 
   (make-coding-system
    'mule-utf-16be-with-signature 4 ?u
@@ -406,20 +535,10 @@ sequence representing U+FFFD (REPLACEMENT CHARACTER)."))
 
    '(ccl-decode-mule-utf-16be-with-signature
      . ccl-encode-mule-utf-16be-with-signature)
-   '((safe-charsets
-      ascii
-      eight-bit-control
-      latin-iso8859-1
-      mule-unicode-0100-24ff
-      mule-unicode-2500-33ff
-      mule-unicode-e000-ffff)
+   `(,@props
+     (post-read-conversion . utf-8-post-read-conversion)
      (coding-category . coding-category-utf-16-be)
-     (mime-charset . utf-16)
-     (valid-codes (0 . 255))
-     (dependency unify-8859-on-encoding-mode
-                 unify-8859-on-decoding-mode
-                 utf-fragment-on-decoding
-                 utf-translate-cjk-mode)))
+     (mime-charset . utf-16)))
 
   (make-coding-system
    'mule-utf-16 4 ?u
@@ -428,22 +547,10 @@ sequence representing U+FFFD (REPLACEMENT CHARACTER)."))
     doc)
 
    '(ccl-decode-mule-utf-16 . ccl-encode-mule-utf-16be-with-signature)
-   '((safe-charsets
-      ascii
-      eight-bit-control
-      latin-iso8859-1
-      mule-unicode-0100-24ff
-      mule-unicode-2500-33ff
-      mule-unicode-e000-ffff)
+   `(,@props
+     (post-read-conversion . mule-utf-16-post-read-conversion)
      (coding-category . coding-category-utf-16-be)
-     (mime-charset . utf-16)
-     (mime-text-unsuitable . t)
-     (valid-codes (0 . 255))
-     (dependency unify-8859-on-encoding-mode
-                 unify-8859-on-decoding-mode
-                 utf-fragment-on-decoding
-                 utf-translate-cjk-mode)
-     (post-read-conversion . mule-utf-16-post-read-conversion)))
+     (mime-charset . utf-16)))
 )
 
 (define-coding-system-alias 'utf-16le 'mule-utf-16le)
diff --git a/lisp/international/utf-8.el b/lisp/international/utf-8.el
index d4dd7b6c882..77a51abb43f 100644
--- a/lisp/international/utf-8.el
+++ b/lisp/international/utf-8.el
@@ -190,9 +190,102 @@ Setting this variable outside customize has no effect."
   :type 'boolean
   :group 'mule)
 
+
+(defconst utf-translate-cjk-charsets '(chinese-gb2312
+                                       chinese-big5-1 chinese-big5-2
+                                       japanese-jisx0208 japanese-jisx0212
+                                       korean-ksc5601)
+  "List of charsets supported by `utf-translate-cjk-mode'.")
+
+(defconst utf-translate-cjk-unicode-range
+  '((#x2e80 . #xd7a3)
+    (#xff00 . #xffef))
+  "List of Unicode code ranges supported by `utf-translate-cjk-mode'.")
+
+;; Return non-nil if CODE-POINT is in `utf-translate-cjk-unicode-range'.
+(defsubst utf-translate-cjk-substitutable-p (code-point)
+  (let ((tail utf-translate-cjk-unicode-range)
+        elt)
+    (while tail
+      (setq elt (car tail) tail (cdr tail))
+      (if (and (>= code-point (car elt)) (<= code-point (cdr elt)))
+          (setq tail nil)
+        (setq elt nil)))
+    elt))
+
+(defvar utf-translate-cjk-lang-env nil
+  "Language environment in which tables for `utf-translate-cjk-mode' is loaded.
+The value nil means that the tables are not yet loaded.")
+
+(defun utf-translate-cjk-load-tables ()
+  "Load tables for `utf-translate-cjk-mode'."
+  ;; Fixme: Allow the use of the CJK charsets to be
+  ;; customized by reordering and possible omission.
+  (let ((redefined (< (hash-table-size ucs-mule-cjk-to-unicode) 43000)))
+    (if redefined
+        ;; Redefine them with realistic initial sizes and a
+        ;; smallish rehash size to avoid wasting significant
+        ;; space after they're built.
+        (setq ucs-mule-cjk-to-unicode
+              (make-hash-table :test 'eq :size 43000 :rehash-size 1000)
+              ucs-unicode-to-mule-cjk
+              (make-hash-table :test 'eq :size 21500 :rehash-size 1000)))
+
+    ;; Load the files explicitly, to avoid having to keep
+    ;; around the large tables they contain (as well as the
+    ;; ones which get built).
+    (cond ((string= "Korean" current-language-environment)
+           (load "subst-jis")
+           (load "subst-big5")
+           (load "subst-gb2312")
+           (load "subst-ksc"))
+          ((string= "Chinese-BIG5" current-language-environment)
+           (load "subst-jis")
+           (load "subst-ksc")
+           (load "subst-gb2312")
+           (load "subst-big5"))
+          ((string= "Chinese-GB" current-language-environment)
+           (load "subst-jis")
+           (load "subst-ksc")
+           (load "subst-big5")
+           (load "subst-gb2312"))
+          (t
+           (load "subst-ksc")
+           (load "subst-gb2312")
+           (load "subst-big5")
+           (load "subst-jis")))   ; jis covers as much as big5, gb2312
+
+    (when redefined
+      (define-translation-hash-table 'utf-subst-table-for-decode
+        ucs-unicode-to-mule-cjk)
+      (define-translation-hash-table 'utf-subst-table-for-encode
+        ucs-mule-cjk-to-unicode)
+      (set-char-table-extra-slot (get 'utf-translation-table-for-encode
+                                      'translation-table)
+                                 1 ucs-mule-cjk-to-unicode))
+
+    (setq utf-translate-cjk-lang-env current-language-environment)))
+
+(defun utf-lookup-subst-table-for-decode (code-point)
+  (if (and utf-translate-cjk-mode
+           (not utf-translate-cjk-lang-env)
+           (utf-translate-cjk-substitutable-p code-point))
+      (utf-translate-cjk-load-tables))
+  (gethash code-point
+           (get 'utf-subst-table-for-decode 'translation-hash-table)))
+  
+
+(defun utf-lookup-subst-table-for-encode (char)
+  (if (and utf-translate-cjk-mode
+           (not utf-translate-cjk-lang-env)
+           (memq (char-charset char) utf-translate-cjk-charsets))
+      (utf-translate-cjk-load-tables))
+  (gethash char
+           (get 'utf-subst-table-for-encode 'translation-hash-table)))
+  
 (define-minor-mode utf-translate-cjk-mode
   "Whether the UTF based coding systems should decode/encode CJK characters.
-Enabling this loads tables which allow the coding systems mule-utf-8,
+Enabling this allows the coding systems mule-utf-8,
 mule-utf-16le and mule-utf-16be to encode characters in the charsets
 `korean-ksc5601', `chinese-gb2312', `chinese-big5-1',
 `chinese-big5-2', `japanese-jisx0208' and `japanese-jisx0212', and to
@@ -203,49 +296,16 @@ according to the language environment in effect when this option is
 turned on: ksc5601 for Korean, gb2312 for Chinese-GB, big5 for
 Chinese-Big5 and jisx for other environments.
 
-The tables are large (over 40000 entries), so this option is not the
-default.  Also, installing them may be rather slow."
-  :init-value nil
+This option is on by default.  If you are not interested in CJK
+characters and want to avoid some overhead on encoding/decoding
+by the above coding systems, you can customize this option to nil."
+  :init-value t
   :version "21.4"
   :type 'boolean
-  :set-after '(current-language-environment)
   :group 'mule
   :global t
   (if utf-translate-cjk-mode
-      ;; Fixme: Allow the use of the CJK charsets to be
-      ;; customized by reordering and possible omission.
       (progn
-        ;; Redefine them with realistic initial sizes and a
-        ;; smallish rehash size to avoid wasting significant
-        ;; space after they're built.
-        (setq ucs-mule-cjk-to-unicode
-              (make-hash-table :test 'eq :size 43000 :rehash-size 1000)
-              ucs-unicode-to-mule-cjk
-              (make-hash-table :test 'eq :size 21500 :rehash-size 1000))
-        ;; Load the files explicitly, to avoid having to keep
-        ;; around the large tables they contain (as well as the
-        ;; ones which get built).
-        (cond
-         ((string= "Korean" current-language-environment)
-          (load "subst-jis")
-          (load "subst-big5")
-          (load "subst-gb2312")
-          (load "subst-ksc"))
-         ((string= "Chinese-BIG5" current-language-environment)
-          (load "subst-jis")
-          (load "subst-ksc")
-          (load "subst-gb2312")
-          (load "subst-big5"))
-         ((string= "Chinese-GB" current-language-environment)
-          (load "subst-jis")
-          (load "subst-ksc")
-          (load "subst-big5")
-          (load "subst-gb2312"))
-         (t
-          (load "subst-ksc")
-          (load "subst-gb2312")
-          (load "subst-big5")
-          (load "subst-jis")))    ; jis covers as much as big5, gb2312
         (define-translation-hash-table 'utf-subst-table-for-decode
           ucs-unicode-to-mule-cjk)
         (define-translation-hash-table 'utf-subst-table-for-encode
@@ -259,7 +319,58 @@ default.  Also, installing them may be rather slow."
       (make-hash-table :test 'eq))
     (set-char-table-extra-slot (get 'utf-translation-table-for-encode
                                     'translation-table)
-                               1 nil)))
+                               1 nil))
+
+  ;; Update safe-chars of mule-utf-* coding systems.
+  (dolist (elt (coding-system-list t))
+    (if (string-match "^mule-utf" (symbol-name elt))
+        (let ((safe-charsets (coding-system-get elt 'safe-charsets))
+              (safe-chars (coding-system-get elt 'safe-chars))
+              (need-update nil))
+          (dolist (charset utf-translate-cjk-charsets)
+            (unless (eq utf-translate-cjk-mode (memq charset safe-charsets))
+              (setq safe-charsets
+                    (if utf-translate-cjk-mode
+                        (cons charset safe-charsets)
+                      (delq charset safe-charsets))
+                    need-update t)
+              (aset safe-chars (make-char charset) utf-translate-cjk-mode)))
+          (when need-update
+            (coding-system-put elt 'safe-charsets safe-charsets)
+            (define-coding-system-internal elt))))))
+
+(define-ccl-program ccl-mule-utf-untrans
+  ;; R0 is an untranslatable Unicode code-point (U+3500..U+DFFF or
+  ;; U+10000..U+10FFFF) or an invaid byte (#x00..#xFF).  Write
+  ;; eight-bit-control/graphic sequence (2 to 4 chars) representing
+  ;; UTF-8 sequence of r0.  Registers r4, r5, r6 are modified.
+  ;;
+  ;; This is a subrountine because we assume that this is called very
+  ;; rarely (so we don't have to worry about the overhead of the
+  ;; call).
+  `(0
+    ((r5 = ,(charset-id 'eight-bit-control))
+     (r6 = ,(charset-id 'eight-bit-graphic))
+     (if (r0 < #x100)
+         ((r4 = ((r0 >> 6) | #xC0))
+          (write-multibyte-character r6 r4))
+       ((if (r0 < #x10000)
+            ((r4 = ((r0 >> 12) | #xE0))
+             (write-multibyte-character r6 r4))
+          ((r4 = ((r0 >> 18) | #xF0))
+           (write-multibyte-character r6 r4)
+           (r4 = (((r0 >> 12) & #x3F) | #x80))
+           (if (r4 < #xA0)
+               (write-multibyte-character r5 r4)
+             (write-multibyte-character r6 r4))))
+        (r4 = (((r0 >> 6) & #x3F) | #x80))
+        (if (r4 < #xA0)
+            (write-multibyte-character r5 r4)
+          (write-multibyte-character r6 r4))))
+     (r4 = ((r0 & #x3F) | #x80))
+     (if (r4 < #xA0)
+         (write-multibyte-character r5 r4)
+       (write-multibyte-character r6 r4)))))
 
 (define-ccl-program ccl-decode-mule-utf-8
   ;;
@@ -278,260 +389,210 @@ default.  Also, installing them may be rather slow."
   ;;        (>= 8000)       |                |
   ;; mule-unicode-2500-33ff |       3        |       4
   ;; mule-unicode-e000-ffff |       3        |       4
+  ;; -----------------------+----------------+---------------
+  ;;      invalid byte      |       1        |       2
   ;;
   ;; Thus magnification factor is two.
   ;;
   `(2
-    ((r5 = ,(charset-id 'eight-bit-control))
-     (r6 = ,(charset-id 'eight-bit-graphic))
+    ((r6 = ,(charset-id 'latin-iso8859-1))
+     (read r0)
      (loop
-      (r0 = -1)
-      (read r0)
-
-      ;; 1byte encoding, i.e., ascii
       (if (r0 < #x80)
-          ((write r0))
-        (if (r0 < #xc0)             ; continuation byte (invalid here)
-            ((if (r0 < #xa0)
-                 (write-multibyte-character r5 r0)
-               (write-multibyte-character r6 r0)))
-          ;; 2 byte encoding 00000yyyyyxxxxxx = 110yyyyy 10xxxxxx
-          (if (r0 < #xe0)
-              ((r1 = -1)
-               (read r1)
-
-               (if ((r1 & #b11000000) != #b10000000)
-                   ;; Invalid 2-byte sequence
-                   ((if (r0 < #xa0)
-                        (write-multibyte-character r5 r0)
-                      (write-multibyte-character r6 r0))
-                    (if (r1 < #x80)
-                        (write r1)
-                      (if (r1 < #xa0)
-                          (write-multibyte-character r5 r1)
-                        (write-multibyte-character r6 r1))))
-
-                 ((r3 = r0)        ; save in case of overlong sequence
-                  (r2 = r1)
-                  (r0 &= #x1f)
-                  (r0 <<= 6)
-                  (r1 &= #x3f)
-                  (r1 += r0)
-                  ;; Now r1 holds scalar value
-
-                  (if (r1 < 128)        ; `overlong sequence'
-                      ((if (r3 < #xa0)
-                           (write-multibyte-character r5 r3)
-                         (write-multibyte-character r6 r3))
-                       (if (r2 < #x80)
-                           (write r2)
-                         (if (r2 < #xa0)
-                             (write-multibyte-character r5 r2)
-                           (write-multibyte-character r6 r2))))
-
-                    ;; eight-bit-control
-                    (if (r1 < 160)
-                        ((write-multibyte-character r5 r1))
-
-                      ;; latin-iso8859-1
-                      (if (r1 < 256)
-                          ((r0 = ,(charset-id 'latin-iso8859-1))
-                           (r1 -= 128)
-                           (write-multibyte-character r0 r1))
-
-                        ;; mule-unicode-0100-24ff (< 0800)
-                        ((r0 = ,(charset-id 'mule-unicode-0100-24ff))
-                         (r1 -= #x0100)
-                         (r2 = (((r1 / 96) + 32) << 7))
-                         (r1 %= 96)
-                         (r1 += (r2 + 32))
-                         (translate-character
-                          utf-translation-table-for-decode r0 r1)
-                         (write-multibyte-character r0 r1))))))))
-
-            ;; 3byte encoding
-            ;; zzzzyyyyyyxxxxxx = 1110zzzz 10yyyyyy 10xxxxxx
-            (if (r0 < #xf0)
-                ((r1 = -1)
-                 (r2 = -1)
-                 (read r1 r2)
-
-                 ;; This is set to 1 if the encoding is invalid.
-                 (r4 = 0)
-
-                 (r3 = (r1 & #b11000000))
-                 (r3 |= ((r2 >> 2) & #b00110000))
-                 (if (r3 != #b10100000)
-                     (r4 = 1)
-                   ((r3 = ((r0 & #x0f) << 12))
-                    (r3 += ((r1 & #x3f) << 6))
-                    (r3 += (r2 & #x3f))
-                    (if (r3 < #x0800)
-                        (r4 = 1))))
-
-                 (if (r4 != 0)
-                     ;; Invalid 3-byte sequence
-                     ((if (r0 < #xa0)
-                          (write-multibyte-character r5 r0)
-                        (write-multibyte-character r6 r0))
-                      (if (r1 < #x80)
-                          (write r1)
-                        (if (r1 < #xa0)
-                            (write-multibyte-character r5 r1)
-                          (write-multibyte-character r6 r1)))
-                      (if (r2 < #x80)
-                          (write r2)
-                        (if (r2 < #xa0)
-                            (write-multibyte-character r5 r2)
-                          (write-multibyte-character r6 r2))))
-
-                   ;; mule-unicode-0100-24ff (>= 0800)
-                   ((if (r3 < #x2500)
-                        ((r0 = ,(charset-id 'mule-unicode-0100-24ff))
-                         (r3 -= #x0100)
-                         (r3 //= 96)
-                         (r1 = (r7 + 32))
-                         (r1 += ((r3 + 32) << 7))
-                         (translate-character
-                          utf-translation-table-for-decode r0 r1)
-                         (write-multibyte-character r0 r1))
-
-                      ;; mule-unicode-2500-33ff
-                      (if (r3 < #x3400)
-                          ((r4 = r3)    ; don't zap r3
-                           (lookup-integer utf-subst-table-for-decode r4 r5)
-                           (if r7
-                               ;; got a translation
-                               ((write-multibyte-character r4 r5)
-                                ;; Zapped through register starvation.
-                                (r5 = ,(charset-id 'eight-bit-control)))
-                             ((r0 = ,(charset-id 'mule-unicode-2500-33ff))
-                              (r3 -= #x2500)
-                              (r3 //= 96)
-                              (r1 = (r7 + 32))
-                              (r1 += ((r3 + 32) << 7))
-                              (write-multibyte-character r0 r1))))
-
-                        ;; U+3400 .. U+D7FF
-                        ;; Try to convert to CJK chars, else keep
-                        ;; them as eight-bit-{control|graphic}.
-                        (if (r3 < #xd800)
-                            ((r4 = r3)  ; don't zap r3
-                             (lookup-integer utf-subst-table-for-decode r4 r5)
-                             (if r7
-                                 ;; got a translation
-                                 ((write-multibyte-character r4 r5)
-                                  ;; Zapped through register starvation.
-                                  (r5 = ,(charset-id 'eight-bit-control)))
-                               ;; #xe0 <= r0 < #xf0, so r0 is eight-bit-graphic
-                               ((r3 = r6)
-                                (write-multibyte-character r3 r0)
-                                (if (r1 < #xa0)
-                                    (r3 = r5))
-                                (write-multibyte-character r3 r1)
-                                (if (r2 < #xa0)
-                                    (r3 = r5)
-                                  (r3 = r6))
-                                (write-multibyte-character r3 r2))))
-
-                          ;; Surrogates, U+D800 .. U+DFFF
-                          (if (r3 < #xe000)
-                              ((r3 = r6)
-                               (write-multibyte-character r3 r0) ; eight-bit-graphic
-                               (if (r1 < #xa0)
-                                   (r3 = r5))
-                               (write-multibyte-character r3 r1)
-                               (if (r2 < #xa0)
-                                   (r3 = r5)
-                                 (r3 = r6))
-                               (write-multibyte-character r3 r2))
-
-                            ;; mule-unicode-e000-ffff
-                            ;; Fixme: fffe and ffff are invalid.
-                            ((r4 = r3)  ; don't zap r3
-                             (lookup-integer utf-subst-table-for-decode r4 r5)
-                             (if r7
-                                 ;; got a translation
-                                 ((write-multibyte-character r4 r5)
-                                  ;; Zapped through register starvation.
-                                  (r5 = ,(charset-id 'eight-bit-control)))
-                               ((r0 = ,(charset-id 'mule-unicode-e000-ffff))
-                                (r3 -= #xe000)
-                                (r3 //= 96)
-                                (r1 = (r7 + 32))
-                                (r1 += ((r3 + 32) << 7))
-                                (write-multibyte-character r0 r1)))))))))))
-
-              (if (r0 < #xfe)
-                  ;; 4byte encoding
-                  ;; keep those bytes as eight-bit-{control|graphic}
-                  ;; Fixme: allow lookup in utf-subst-table-for-decode.
-                  ((r1 = -1)
-                   (r2 = -1)
-                   (r3 = -1)
-                   (read r1 r2 r3)
-                   ;; r0 > #xf0, thus eight-bit-graphic
-                   (write-multibyte-character r6 r0)
-                   (if (r1 < #xa0)
-                       (if (r1 < #x80)  ; invalid byte
-                           (write r1)
-                         (write-multibyte-character r5 r1))
-                     (write-multibyte-character r6 r1))
-                   (if (r2 < #xa0)
-                       (if (r2 < #x80)  ; invalid byte
-                           (write r2)
-                         (write-multibyte-character r5 r2))
-                     (write-multibyte-character r6 r2))
-                   (if (r3 < #xa0)
-                       (if (r3 < #x80)  ; invalid byte
-                           (write r3)
-                         (write-multibyte-character r5 r3))
-                     (write-multibyte-character r6 r3))
-                   (if (r0 >= #xf8)     ; 5- or 6-byte encoding
-                       ((r0 = -1)
-                        (read r0)
-                        (if (r0 < #xa0)
-                            (if (r0 < #x80) ; invalid byte
-                                (write r0)
-                              (write-multibyte-character r5 r0))
-                          (write-multibyte-character r6 r0))
-                        (if (r0 >= #xfc) ; 6-byte
-                            ((r0 = -1)
-                             (read r0)
-                             (if (r0 < #xa0)
-                                 (if (r0 < #x80) ; invalid byte
-                                     (write r0)
-                                   (write-multibyte-character r5 r0))
-                               (write-multibyte-character r6 r0)))))))
-                ;; else invalid byte >= #xfe
-                (write-multibyte-character r6 r0))))))
+          ;; 1-byte encoding, i.e., ascii
+          (write-read-repeat r0))
+      (if (r0 < #xc2)
+          ;; continuation byte (invalid here) or 1st byte of overlong
+          ;; 2-byte sequence.
+          ((call ccl-mule-utf-untrans)
+           (r6 = ,(charset-id 'latin-iso8859-1))
+           (read r0)
+           (repeat)))
+
+      ;; Read the 2nd byte.
+      (read r1)
+      (if ((r1 & #b11000000) != #b10000000) ; Invalid 2nd byte
+          ((call ccl-mule-utf-untrans)
+           (r6 = ,(charset-id 'latin-iso8859-1))
+           ;; Handle it in the next loop.
+           (r0 = r1)
+           (repeat)))
+
+      (if (r0 < #xe0)
+          ;; 2-byte encoding 00000yyyyyxxxxxx = 110yyyyy 10xxxxxx
+          ((r1 &= #x3F)
+           (r1 |= ((r0 & #x1F) << 6))
+           ;; Now r2 holds scalar value.  We don't have to check
+           ;; `overlong sequence' because r0 >= 0xC2.
+
+           (if (r1 >= 256)
+               ;; mule-unicode-0100-24ff (< 0800)
+               ((r0 = ,(charset-id 'mule-unicode-0100-24ff))
+                (r1 -= #x0100)
+                (r2 = (((r1 / 96) + 32) << 7))
+                (r1 %= 96)
+                (r1 += (r2 + 32))
+                (translate-character
+                 utf-translation-table-for-decode r0 r1)
+                (write-multibyte-character r0 r1)
+                (read r0)
+                (repeat))
+             (if (r1 >= 160)
+                 ;; latin-iso8859-1
+                 ((r1 -= 128)
+                  (write-multibyte-character r6 r1)
+                  (read r0)
+                  (repeat))
+               ;; eight-bit-control
+               ((r0 = ,(charset-id 'eight-bit-control))
+                (write-multibyte-character r0 r1)
+                (read r0)
+                (repeat))))))
+
+      ;; Read the 3rd bytes.
+      (read r2)
+      (if ((r2 & #b11000000) != #b10000000) ; Invalid 3rd byte
+          ((call ccl-mule-utf-untrans)
+           (r0 = r1)
+           (call ccl-mule-utf-untrans)
+           (r6 = ,(charset-id 'latin-iso8859-1))
+           ;; Handle it in the next loop.
+           (r0 = r2)
+           (repeat)))
+
+      (if (r0 < #xF0)
+          ;; 3byte encoding
+          ;; zzzzyyyyyyxxxxxx = 1110zzzz 10yyyyyy 10xxxxxx
+          ((r3 = ((r0 & #xF) << 12))
+           (r3 |= ((r1 & #x3F) << 6))
+           (r3 |= (r2 & #x3F))
+
+           (if (r3 < #x800)             ; `overlong sequence'
+               ((call ccl-mule-utf-untrans)
+                (r0 = r1)
+                (call ccl-mule-utf-untrans)
+                (r0 = r2)
+                (call ccl-mule-utf-untrans)
+                (r6 = ,(charset-id 'latin-iso8859-1))
+                (read r0)
+                (repeat)))
+
+           (if (r3 < #x2500)
+               ;; mule-unicode-0100-24ff (>= 0800)
+               ((r0 = ,(charset-id 'mule-unicode-0100-24ff))
+                (r3 -= #x0100)
+                (r3 //= 96)
+                (r1 = (r7 + 32))
+                (r1 += ((r3 + 32) << 7))
+                (translate-character
+                 utf-translation-table-for-decode r0 r1)
+                (write-multibyte-character r0 r1)
+                (read r0)
+                (repeat)))
+
+           (if (r3 < #x3400)
+               ;; mule-unicode-2500-33ff
+               ((r0 = r3)               ; don't zap r3
+                (lookup-integer utf-subst-table-for-decode r0 r1)
+                (if (r7 == 0)
+                    ((r0 = ,(charset-id 'mule-unicode-2500-33ff))
+                     (r3 -= #x2500)
+                     (r3 //= 96)
+                     (r1 = (r7 + 32))
+                     (r1 += ((r3 + 32) << 7))))
+                (write-multibyte-character r0 r1)
+                (read r0)
+                (repeat)))
+
+           (if (r3 < #xE000)
+               ;; Try to convert to CJK chars, else
+               ;; keep them as eight-bit-{control|graphic}.
+               ((r0 = r3)
+                (lookup-integer utf-subst-table-for-decode r3 r1)
+                (if r7
+                    ;; got a translation
+                    ((write-multibyte-character r3 r1)
+                     (read r0)
+                     (repeat))
+                  ((call ccl-mule-utf-untrans)
+                   (r6 = ,(charset-id 'latin-iso8859-1))
+                   (read r0)
+                   (repeat)))))
+
+           ;; mule-unicode-e000-ffff
+           ;; Fixme: fffe and ffff are invalid.
+           (r0 = r3)            ; don't zap r3
+           (lookup-integer utf-subst-table-for-decode r0 r1)
+           (if (r7 == 0)
+               ((r0 = ,(charset-id 'mule-unicode-e000-ffff))
+                (r3 -= #xe000)
+                (r3 //= 96)
+                (r1 = (r7 + 32))
+                (r1 += ((r3 + 32) << 7))))
+           (write-multibyte-character r0 r1)
+           (read r0)
+           (repeat)))
+
+      ;; Read the 4th bytes.
+      (read r3)
+      (if ((r3 & #b11000000) != #b10000000) ; Invalid 4th byte
+          ((call ccl-mule-utf-untrans)
+           (r0 = r1)
+           (call ccl-mule-utf-untrans)
+           (r0 = r2)
+           (call ccl-mule-utf-untrans)
+           (r6 = ,(charset-id 'latin-iso8859-1))
+           ;; Handle it in the next loop.
+           (r0 = r3)
+           (repeat)))
+
+      (if (r0 < #xF8)
+          ;; 4-byte encoding:
+          ;; wwwzzzzzzyyyyyyxxxxxx = 11110www 10zzzzzz 10yyyyyy 10xxxxxx
+          ;; keep those bytes as eight-bit-{control|graphic}
+          ;; Fixme: allow lookup in utf-subst-table-for-decode.
+          ((r4 = ((r0 & #x7) << 18))
+           (r4 |= ((r1 & #x3F) << 12))
+           (r4 |= ((r2 & #x3F) << 6))
+           (r4 |= (r3 & #x3F))
+
+           (if (r4 < #x10000)           ; `overlong sequence'
+               ((call ccl-mule-utf-untrans)
+                (r0 = r1)
+                (call ccl-mule-utf-untrans)
+                (r0 = r2)
+                (call ccl-mule-utf-untrans)
+                (r0 = r3)
+                (call ccl-mule-utf-untrans))
+             ((r0 = r4)
+              (call ccl-mule-utf-untrans))))
+
+        ;; Unsupported sequence.
+        ((call ccl-mule-utf-untrans)
+         (r0 = r1)
+         (call ccl-mule-utf-untrans)
+         (r0 = r2)
+         (call ccl-mule-utf-untrans)
+         (r0 = r3)
+         (call ccl-mule-utf-untrans)))
+      (r6 = ,(charset-id 'latin-iso8859-1))
+      (read r0)
       (repeat)))
 
+
     ;; At EOF...
     (if (r0 >= 0)
-        ((if (r0 < #x80)
-             (write r0)
-           (if (r0 < #xa0)
-               (write-multibyte-character r5 r0)
-             ((write-multibyte-character r6 r0))))
+        ;; r0 >= #x80
+        ((call ccl-mule-utf-untrans)
          (if (r1 >= 0)
-             ((if (r1 < #x80)
-                  (write r1)
-                (if (r1 < #xa0)
-                    (write-multibyte-character r5 r1)
-                  ((write-multibyte-character r6 r1))))
+             ((r0 = r1)
+              (call ccl-mule-utf-untrans)
               (if (r2 >= 0)
-                  ((if (r2 < #x80)
-                       (write r2)
-                     (if (r2 < #xa0)
-                         (write-multibyte-character r5 r2)
-                       ((write-multibyte-character r6 r2))))
+                  ((r0 = r2)
+                   (call ccl-mule-utf-untrans)
                    (if (r3 >= 0)
-                       (if (r3 < #x80)
-                           (write r3)
-                         (if (r3 < #xa0)
-                             (write-multibyte-character r5 r3)
-                           ((write-multibyte-character r6 r3))))))))))))
+                       ((r0 = r3)
+                        (call ccl-mule-utf-untrans))))))))))
 
   "CCL program to decode UTF-8.
 Basic decoding is done into the charsets ascii, latin-iso8859-1 and
@@ -540,164 +601,203 @@ mule-unicode-*, but see also `utf-fragmentation-table' and
 Encodings of un-representable Unicode characters are decoded asis into
 eight-bit-control and eight-bit-graphic characters.")
 
+(define-ccl-program ccl-mule-utf-8-encode-untrans
+  ;; UTF-8 decoder generates an UTF-8 sequence represented by a
+  ;; sequence eight-bit-control/graphic chars for an untranslatable
+  ;; character and an invalid byte.
+  ;; 
+  ;; This CCL parses that sequence (the first byte is already in r1),
+  ;; writes out the original bytes of that sequence, and sets r5 to
+  ;; -1.
+  ;;
+  ;; If the eight-bit-control/graphic sequence is shorter than what r1
+  ;; suggests, it sets r5 and r6 to the last character read that
+  ;; should be handled by the next loop of a caller.
+  ;;
+  ;; Note: For UTF-8 validation, we only check if a character is
+  ;; eight-bit-control/graphic or not.  It may result in incorrect
+  ;; handling of random binary data, but such a data can't be encoded
+  ;; by UTF-8 anyway.  At least, UTF-8 decoders doesn't generate such
+  ;; a sequence even if a source contains invalid byte-sequence.
+  `(0
+    (;; Read the 2nd byte.
+     (read-multibyte-character r5 r6)
+     (r0 = (r5 != ,(charset-id 'eight-bit-control)))
+     (if ((r5 != ,(charset-id 'eight-bit-graphic)) & r0)
+         ((write r1)                    ; invalid UTF-8 
+          (r1 = -1)
+          (end)))
+
+     (if (r1 <= #xC3)
+         ;; 2-byte sequence for an originally invalid byte.
+         ((r6 &= #x3F)
+          (r6 |= ((r1 & #x1F) << 6))
+          (write r6)
+          (r5 = -1)
+          (end)))
+
+     (write r1 r6)
+     (r2 = r1)
+     (r1 = -1)
+     ;; Read the 3rd byte.
+     (read-multibyte-character r5 r6)
+     (r0 = (r5 != ,(charset-id 'eight-bit-control)))           
+     (if ((r5 != ,(charset-id 'eight-bit-graphic)) & r0)
+         (end))                         ; invalid UTF-8
+     (write r6)
+     (if (r2 < #xF0)
+         ;; 3-byte sequence for an untranslated character.
+         ((r5 = -1)
+          (end)))
+     ;; Read the 4th byte.
+     (read-multibyte-character r5 r6)
+     (r0 = (r5 != ,(charset-id 'eight-bit-control)))           
+     (if ((r5 != ,(charset-id 'eight-bit-graphic)) & r0)
+         (end))                 ; invalid UTF-8
+     ;; 4-byte sequence for an untranslated character.
+     (write r6)
+     (r5 = -1)
+     (end))
+
+    ;; At EOF...
+    ((r5 = -1)
+     (if (r1 >= 0)
+         (write r1)))))
+
 (define-ccl-program ccl-encode-mule-utf-8
   `(1
     ((r5 = -1)
      (loop
       (if (r5 < 0)
-          ((r1 = -1)
-           (read-multibyte-character r0 r1)
-           (translate-character utf-translation-table-for-encode r0 r1))
-        (;; We have already done read-multibyte-character.
-         (r0 = r5)
+          (read-multibyte-character r0 r1)
+        ;; Pre-read character is in r5 (charset-ID) and r6 (code-point).
+        ((r0 = r5)
          (r1 = r6)
          (r5 = -1)))
+      (translate-character utf-translation-table-for-encode r0 r1)
 
       (if (r0 == ,(charset-id 'ascii))
-          (write r1)
-
-        (if (r0 == ,(charset-id 'latin-iso8859-1))
-            ;; r1          scalar                  utf-8
-            ;;       0000 0yyy yyxx xxxx    110y yyyy 10xx xxxx
-            ;; 20    0000 0000 1010 0000    1100 0010 1010 0000
-            ;; 7f    0000 0000 1111 1111    1100 0011 1011 1111
-            ((r0 = (((r1 & #x40) >> 6) | #xc2))
-             (r1 &= #x3f)
-             (r1 |= #x80)
-             (write r0 r1))
-
-          (if (r0 == ,(charset-id 'mule-unicode-0100-24ff))
-              ((r0 = ((((r1 & #x3f80) >> 7) - 32) * 96))
-               ;; #x3f80 == (0011 1111 1000 0000)b
-               (r1 &= #x7f)
-               (r1 += (r0 + 224))       ; 240 == -32 + #x0100
-               ;; now r1 holds scalar value
-               (if (r1 < #x0800)
-                   ;; 2byte encoding
-                   ((r0 = (((r1 & #x07c0) >> 6) | #xc0))
-                    ;; #x07c0 == (0000 0111 1100 0000)b
-                    (r1 &= #x3f)
-                    (r1 |= #x80)
-                    (write r0 r1))
-                 ;; 3byte encoding
-                 ((r0 = (((r1 & #xf000) >> 12) | #xe0))
-                  (r2 = ((r1 & #x3f) | #x80))
-                  (r1 &= #x0fc0)
-                  (r1 >>= 6)
-                  (r1 |= #x80)
-                  (write r0 r1 r2))))
-
-            (if (r0 == ,(charset-id 'mule-unicode-2500-33ff))
-                ((r0 = ((((r1 & #x3f80) >> 7) - 32) * 96))
-                 (r1 &= #x7f)
-                 (r1 += (r0 + 9440))    ; 9440 == -32 + #x2500
-                 (r0 = (((r1 & #xf000) >> 12) | #xe0))
-                 (r2 = ((r1 & #x3f) | #x80))
-                 (r1 &= #x0fc0)
-                 (r1 >>= 6)
-                 (r1 |= #x80)
-                 (write r0 r1 r2))
-
-              (if (r0 == ,(charset-id 'mule-unicode-e000-ffff))
-                  ((r0 = ((((r1 & #x3f80) >> 7) - 32) * 96))
-                   (r1 &= #x7f)
-                   (r1 += (r0 + 57312)) ; 57312 == -32 + #xe000
-                   (r0 = (((r1 & #xf000) >> 12) | #xe0))
-                   (r2 = ((r1 & #x3f) | #x80))
-                   (r1 &= #x0fc0)
-                   (r1 >>= 6)
-                   (r1 |= #x80)
-                   (write r0 r1 r2))
-
-                (if (r0 == ,(charset-id 'eight-bit-control))
-                    ;; r1          scalar                  utf-8
-                    ;;       0000 0yyy yyxx xxxx    110y yyyy 10xx xxxx
-                    ;; 80    0000 0000 1000 0000    1100 0010 1000 0000
-                    ;; 9f    0000 0000 1001 1111    1100 0010 1001 1111
-                    ((write #xc2)
-                     (write r1))
-
-                  (if (r0 == ,(charset-id 'eight-bit-graphic))
-                      ;; r1          scalar                  utf-8
-                      ;;       0000 0yyy yyxx xxxx    110y yyyy 10xx xxxx
-                      ;; a0    0000 0000 1010 0000    1100 0010 1010 0000
-                      ;; ff    0000 0000 1111 1111    1101 1111 1011 1111
-                      ((write r1)
-                       (r1 = -1)
-                       (read-multibyte-character r0 r1)
-                       (if (r0 != ,(charset-id 'eight-bit-graphic))
-                           (if (r0 != ,(charset-id 'eight-bit-control))
-                               ((r5 = r0)
-                                (r6 = r1))))
-                       (if (r5 < 0)
-                           ((read-multibyte-character r0 r2)
-                            (if (r0 != ,(charset-id 'eight-bit-graphic))
-                                (if (r0 != ,(charset-id 'eight-bit-control))
-                                    ((r5 = r0)
-                                     (r6 = r2))))
-                            (if (r5 < 0)
-                                (write r1 r2)
-                              (if (r1 < #xa0)
-                                  (write r1)
-                                ((write #xc2)
-                                 (write r1)))))))
-
-                    ((lookup-character utf-subst-table-for-encode r0 r1)
-                     (if r7             ; lookup succeeded
-                         ((r1 = (((r0 & #xf000) >> 12) | #xe0))
-                          (r2 = ((r0 & #x3f) | #x80))
-                          (r0 &= #x0fc0)
-                          (r0 >>= 6)
-                          (r0 |= #x80)
-                          (write r1 r0 r2))
-                       ;; Unsupported character.
-                       ;; Output U+FFFD, which is `ef bf bd' in UTF-8.
-                       ((write #xef)
-                        (write #xbf)
-                        (write #xbd)))))))))))
-      (repeat)))
-    (if (r1 >= #xa0)
-        (write r1)
-      (if (r1 >= #x80)
-          ((write #xc2)
-           (write r1)))))
-
+          (write-repeat r1))
+
+      (if (r0 == ,(charset-id 'latin-iso8859-1))
+          ;; r1          scalar                  utf-8
+          ;;       0000 0yyy yyxx xxxx    110y yyyy 10xx xxxx
+          ;; 20    0000 0000 1010 0000    1100 0010 1010 0000
+          ;; 7f    0000 0000 1111 1111    1100 0011 1011 1111
+          ((write ((r1 >> 6) | #xc2))
+           (r1 &= #x3f)
+           (r1 |= #x80)
+           (write-repeat r1)))
+
+      (if (r0 == ,(charset-id 'mule-unicode-0100-24ff))
+          ((r0 = ((((r1 & #x3f80) >> 7) - 32) * 96))
+           ;; #x3f80 == (0011 1111 1000 0000)b
+           (r1 &= #x7f)
+           (r1 += (r0 + 224))           ; 240 == -32 + #x0100
+           ;; now r1 holds scalar value
+           (if (r1 < #x0800)
+               ;; 2byte encoding
+               ((write ((r1 >> 6) | #xC0))
+                (r1 &= #x3F)
+                (r1 |= #x80)
+                (write-repeat r1))
+             ;; 3byte encoding
+             ((write ((r1 >> 12) | #xE0))
+              (write  (((r1 & #x0FC0) >> 6) | #x80))
+              (r1 &= #x3F)
+              (r1 |= #x80)
+              (write-repeat r1)))))
+
+      (if (r0 == ,(charset-id 'mule-unicode-2500-33ff))
+          ((r0 = ((((r1 & #x3f80) >> 7) - 32) * 96))
+           (r1 &= #x7f)
+           (r1 += (r0 + 9440))          ; 9440 == -32 + #x2500
+           ;; now r1 holds scalar value
+           (write ((r1 >> 12) | #xE0))
+           (write  (((r1 & #x0FC0) >> 6) | #x80))
+           (r1 &= #x3F)
+           (r1 |= #x80)
+           (write-repeat r1)))
+
+      (if (r0 == ,(charset-id 'mule-unicode-e000-ffff))
+          ((r0 = ((((r1 & #x3f80) >> 7) - 32) * 96))
+           (r1 &= #x7f)
+           (r1 += (r0 + 57312))         ; 57312 == -32 + #xe000
+           ;; now r1 holds scalar value
+           (write ((r1 >> 12) | #xE0))
+           (write  (((r1 & #x0FC0) >> 6) | #x80))
+           (r1 &= #x3F)
+           (r1 |= #x80)
+           (write-repeat r1)))
+
+      (if (r0 == ,(charset-id 'eight-bit-control))
+          ;; r1          scalar                  utf-8
+          ;;       0000 0yyy yyxx xxxx    110y yyyy 10xx xxxx
+          ;; 80    0000 0000 1000 0000    1100 0010 1000 0000
+          ;; 9f    0000 0000 1001 1111    1100 0010 1001 1111
+          ((write #xC2)
+           (write-repeat r1)))
+
+      (if (r0 == ,(charset-id 'eight-bit-graphic))
+          ;; r1          scalar                  utf-8
+          ;;       0000 0yyy yyxx xxxx    110y yyyy 10xx xxxx
+          ;; a0    0000 0000 1010 0000    1100 0010 1010 0000
+          ;; ff    0000 0000 1111 1111    1101 1111 1011 1111
+          ((r0 = (r1 >= #xC0))
+           (r0 &= (r1 <= #xC3))
+           (r4 = (r1 >= #xE1))
+           (r4 &= (r1 <= #xF7))
+           (r0 |= r4)
+           (if r0
+               ((call ccl-mule-utf-8-encode-untrans)
+                (repeat))
+             (write-repeat r1))))
+
+      (lookup-character utf-subst-table-for-encode r0 r1)
+      (if r7            ; lookup succeeded
+          (if (r0 < #x800)
+              ;; 2byte encoding
+              ((write ((r0 >> 6) | #xC0))
+               (r0 = ((r0 & #x3F) | #x80))
+               (write-repeat r0))
+            ;; 3byte encoding
+            ((write ((r0 >> 12) | #xE0))
+             (write  (((r0 & #x0FC0) >> 6) | #x80))
+             (r0 = ((r0 & #x3F) | #x80))
+             (write-repeat r0))))
+
+      ;; Unsupported character.
+      ;; Output U+FFFD, which is `ef bf bd' in UTF-8.
+      (write #xef)
+      (write #xbf)
+      (write-repeat #xbd))))
   "CCL program to encode into UTF-8.")
 
 
 (define-ccl-program ccl-untranslated-to-ucs
   `(0
-    (if (r0 < #xf0)                     ; 3-byte encoding, as above
-        ((r4 = 0)
-         (r3 = (r1 & #b11000000))
-         (r3 |= ((r2 >> 2) & #b00110000))
-         (if (r3 != #b10100000)
-             (r4 = 1)
-           ((r3 = ((r0 & #x0f) << 12))
-            (r3 += ((r1 & #x3f) << 6))
-            (r3 += (r2 & #x3f))
-            (if (r3 < #x0800)
-                (r4 = 1))))
-         (if (r4 != 0)
-             (r0 = 0)
-           (r0 = r3)))
-      (if (r0 < #xf8)                   ; 4-byte (Mule-UCS recipe)
-          ((r4 = (r1 >> 6))
-           (if (r4 != #b10)
-               (r0 = 0)
-             ((r4 = (r2 >> 6))
-              (if (r4 != #b10)
-                  (r0 = 0)
-                ((r4 = (r3 >> 6))
-                 (if (r4 != #b10)
-                     (r0 = 0)
-                   ((r1 = ((r1  & #x3F) << 12))
-                    (r2 = ((r2  & #x3F) << 6))
-                    (r3 &= #x3F)
-                    (r0 = (((((r0 & #x07) << 18) | r1) | r2) | r3)))))))))
-        (r0 = 0))))
-  "Decode 3- or 4-byte sequences in r0, r1, r2 [,r3] to unicodes in r0.
-r0 == 0 for invalid sequence.")
+    (if (r1 == 0)
+        nil
+      (if (r0 <= #xC3)                  ; 2-byte encoding
+          ((r0 = ((r0 & #x3) << 6))
+           (r0 |= (r1 & #x3F))
+           (r1 = 2))
+        (if (r2 == 0)
+            (r1 = 0)
+          (if (r0 < #xF0)               ; 3-byte encoding, as above
+              ((r0 = ((r0 & #xF) << 12))
+               (r0 |= ((r1 & #x3F) << 6))
+               (r0 |= (r2 & #x3F))
+               (r1 = 3))
+            (if (r3 == 0)
+                (r1 = 0)
+              ((r0 = ((r0 & #x7) << 18))
+               (r0 |= ((r1 & #x3F) << 12))
+               (r0 |= ((r2 & #x3F) << 6))
+               (r0 |= (r3 & #x3F))
+               (r1 = 4))))))))
+  "Decode 2-, 3-, or 4-byte sequences in r0, r1, r2 [,r3] to unicodes in r0.
+Set r1 to the byte length.  r0 == 0 for invalid sequence.")
 
 (defvar utf-8-ccl-regs (make-vector 8 0))
 
@@ -708,33 +808,47 @@ Only for 3- or 4-byte sequences."
   (aset utf-8-ccl-regs 1 (or (char-after (1+ (point))) 0))
   (aset utf-8-ccl-regs 2 (or (char-after (+ 2 (point))) 0))
   (aset utf-8-ccl-regs 3 (or (char-after (+ 3 (point))) 0))
-  (ccl-execute 'ccl-untranslated-to-ucs utf-8-ccl-regs)
-  (aref utf-8-ccl-regs 0))
+  (ccl-execute 'ccl-untranslated-to-ucs utf-8-ccl-regs))
 
 (defun utf-8-help-echo (window object position)
   (format "Untranslated Unicode U+%04X"
           (get-char-property position 'untranslated-utf-8 object)))
 
-;; We compose the untranslatable sequences into a single character.
+;; We compose the untranslatable sequences into a single character,
+;; and move point to the next character.
 ;; This is infelicitous for editing, because there's currently no
 ;; mechanism for treating compositions as atomic, but is OK for
 ;; display.  They are composed to U+FFFD with help-echo which
 ;; indicates the unicodes they represent.  This function GCs too much.
-(defsubst utf-8-compose ()
-  "Put a suitable composition on an untranslatable sequence.
-Return the sequence's length."
-  (let* ((u (utf-8-untranslated-to-ucs))
-         (l (unless (zerop u)
-              (if (>= u #x10000)
-                       4
-                     3))))
-    (when l
-      (put-text-property (point) (min (point-max) (+ l (point)))
-                         'untranslated-utf-8 u)
-      (put-text-property (point) (min (point-max) (+ l (point)))
-                         'help-echo 'utf-8-help-echo)
-      (compose-region (point) (+ l (point)) ?$,3u=(B)
-      l)))
+
+;; If utf-translate-cjk-mode is non-nil, this function is called with
+;; HASH-TABLE which translates CJK characters into some of CJK
+;; charsets.
+
+(defsubst utf-8-compose (hash-table)
+  "Put a suitable composition on an untranslatable sequence at point.
+If HASH-TABLE is non-nil, try to translate CJK characters by it at first.
+Move point to the end of the sequence."
+  (utf-8-untranslated-to-ucs)
+  (let ((l (aref utf-8-ccl-regs 1))
+        ch)
+    (if (> l 0)
+        (if (and hash-table
+                 (setq ch (gethash (aref utf-8-ccl-regs 0)  hash-table)))
+            (progn
+              (insert ch)
+              (delete-region (point) (min (point-max) (+ l (point)))))
+          (setq ch (aref utf-8-ccl-regs 0))
+          (put-text-property (point) (min (point-max) (+ l (point)))
+                             'untranslated-utf-8 ch)
+          (put-text-property (point) (min (point-max) (+ l (point)))
+                             'help-echo 'utf-8-help-echo)
+          (if (= l 2)
+              (put-text-property (point) (min (point-max) (+ l (point)))
+                                 'display (format "\\%03o" ch))
+            (compose-region (point) (+ l (point)) ?$,3u=(B))
+          (forward-char l))
+      (forward-char 1))))
 
 (defcustom utf-8-compose-scripts nil
   "*Non-nil means compose various scripts on decoding utf-8 text."
@@ -744,38 +858,63 @@ Return the sequence's length."
 
 (defun utf-8-post-read-conversion (length)
   "Compose untranslated utf-8 sequences into single characters.
+If `utf-translate-cjk-mode' is non-nil, tries to translate CJK characters.
 Also compose particular scripts if `utf-8-compose-scripts' is non-nil."
   (save-excursion
-    ;; Can't do eval-when-compile to insert a multibyte constant
-    ;; version of the string in the loop, since it's always loaded as
-    ;; unibyte from a byte-compiled file.
-    (let ((range (string-as-multibyte "^\xe1-\xf7")))
-      (while (and (skip-chars-forward range)
-                  (not (eobp)))
-        (forward-char (utf-8-compose)))))
-  ;; Fixme: Takahashi-san implies it may not work this easily.  I
-  ;; asked why but didn't get a reply. -- fx
-  (when (and utf-8-compose-scripts (> length 1))
-    ;; These currently have definitions which cover the relevant
-    ;; unicodes.  We could avoid loading thai-util &c by checking
-    ;; whether the region contains any characters with the appropriate
-    ;; categories.  There aren't yet Unicode-based rules for Tibetan.
-    (save-excursion (setq length (diacritic-post-read-conversion length)))
-    (save-excursion (setq length (thai-post-read-conversion length)))
-    (save-excursion (setq length (lao-post-read-conversion length)))
-    (save-excursion (setq length (devanagari-post-read-conversion length)))
-    (save-excursion (setq length (malayalam-post-read-conversion length)))
-    (save-excursion (setq length (tamil-post-read-conversion length))))
-  length)
-
-;; ucs-tables is preloaded
-;; (defun utf-8-pre-write-conversion (beg end)
-;;   "Semi-dummy pre-write function effectively to autoload ucs-tables."
-;;   ;; Ensure translation-table is loaded.
-;;   (require 'ucs-tables)
-;;   ;; Don't do this again.
-;;   (coding-system-put 'mule-utf-8 'pre-write-conversion nil)
-;;   nil)
+    (save-restriction
+      (narrow-to-region (point) (+ (point) length))
+      ;; Can't do eval-when-compile to insert a multibyte constant
+      ;; 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"))
+            hash-table ch)
+        (when utf-translate-cjk-mode
+          (if (not utf-translate-cjk-lang-env)
+              ;; Check these characters:
+              ;;   "U+2e80-U+33ff", "U+ff00-U+ffef"
+              ;; We may have to translate them to CJK charsets.
+              (let ((range2 "$,29@(B-$,2G$,3r`(B-$,3u/(B"))
+                (skip-chars-forward (concat range range2))
+                (unless (eobp)
+                  (utf-translate-cjk-load-tables)
+                  (setq range (concat range range2)))
+          (setq hash-table (get 'utf-subst-table-for-decode
+                                'translation-hash-table)))))
+        (while (and (skip-chars-forward range)
+                    (not (eobp)))
+          (setq ch (following-char))
+          (if (< ch 256)
+              (utf-8-compose hash-table)
+            (if (and hash-table
+                     (setq ch (gethash (encode-char ch 'ucs) hash-table)))
+                (progn
+                  (insert ch)
+                  (delete-char 1))
+              (forward-char 1)))))
+
+      (when (and utf-8-compose-scripts (> length 1))
+        ;; These currently have definitions which cover the relevant
+        ;; unicodes.  We could avoid loading thai-util &c by checking
+        ;; whether the region contains any characters with the appropriate
+        ;; categories.  There aren't yet Unicode-based rules for Tibetan.
+        (diacritic-compose-region (point-max) (point-min))
+        (thai-compose-region (point-max) (point-min))
+        (lao-compose-region (point-max) (point-min))
+        (devanagari-compose-region (point-max) (point-min))
+        (malayalam-compose-region (point-max) (point-min))
+        (tamil-compose-region (point-max) (point-min)))
+      (- (point-max) (point-min)))))
+
+(defun utf-8-pre-write-conversion (beg end)
+  "Prepare for `utf-translate-cjk-mode' to encode text between BEG and END.
+This is used as a post-read-conversion of utf-8 coding system."
+  (if (and utf-translate-cjk-mode
+           (not utf-translate-cjk-lang-env)
+           (save-excursion
+             (goto-char beg)
+             (re-search-forward "\\cc\\|\\cj\\|\\ch" end t)))
+      (utf-translate-cjk-load-tables))
+  nil)
 
 (make-coding-system
  'mule-utf-8 4 ?u
@@ -797,18 +936,20 @@ any of the character sets listed above are encoded into the UTF-8 byte
 sequence representing U+FFFD (REPLACEMENT CHARACTER)."
 
  '(ccl-decode-mule-utf-8 . ccl-encode-mule-utf-8)
- '((safe-charsets
+ `((safe-charsets
     ascii
     eight-bit-control
     eight-bit-graphic
     latin-iso8859-1
     mule-unicode-0100-24ff
     mule-unicode-2500-33ff
-    mule-unicode-e000-ffff)
+    mule-unicode-e000-ffff
+    ,@(if utf-translate-cjk-mode
+          utf-translate-cjk-charsets))
    (mime-charset . utf-8)
    (coding-category . coding-category-utf-8)
    (valid-codes (0 . 255))
-;;    (pre-write-conversion . utf-8-pre-write-conversion)
+   (pre-write-conversion . utf-8-pre-write-conversion)
    (post-read-conversion . utf-8-post-read-conversion)
    (translation-table-for-encode . utf-translation-table-for-encode)
    (dependency unify-8859-on-encoding-mode
diff --git a/lisp/language/devan-util.el b/lisp/language/devan-util.el
index 20bcffdad49..24b9d40eec0 100644
--- a/lisp/language/devan-util.el
+++ b/lisp/language/devan-util.el
@@ -60,6 +60,7 @@
    "\\)")
   "Regexp matching a composable sequence of Devanagari characters.")
 
+;;;###autoload
 (defun devanagari-compose-region (from to)
   (interactive "r")
   (save-excursion
diff --git a/lisp/progmodes/python.el b/lisp/progmodes/python.el
index cee59a6e3e1..274480a36de 100644
--- a/lisp/progmodes/python.el
+++ b/lisp/progmodes/python.el
@@ -323,7 +323,8 @@ BOS non-nil means point is known to be at beginning of statement."
                                      line-end))
                             (save-excursion (python-end-of-statement))
                             t)
-         (not (python-in-string/comment)))))
+         (not (progn (goto-char (match-beginning 0))
+                     (python-in-string/comment))))))
 
 (defun python-close-block-statement-p (&optional bos)
   "Return non-nil if current line is a statement closing a block.
diff --git a/lisp/simple.el b/lisp/simple.el
index 94557956de0..9cd630b94ec 100644
--- a/lisp/simple.el
+++ b/lisp/simple.el
@@ -953,7 +953,8 @@ See also `minibuffer-history-case-insensitive-variables'."
                                         nil
                                         minibuffer-local-map
                                         nil
-                                        'minibuffer-history-search-history)))
+                                        'minibuffer-history-search-history
+                                        (car minibuffer-history-search-history))))
      ;; Use the last regexp specified, by default, if input is empty.
      (list (if (string= regexp "")
                (if minibuffer-history-search-history
diff --git a/lisp/textmodes/paragraphs.el b/lisp/textmodes/paragraphs.el
index 1b2628760e1..e9cc4f397de 100644
--- a/lisp/textmodes/paragraphs.el
+++ b/lisp/textmodes/paragraphs.el
@@ -171,7 +171,7 @@ followed by two spaces, unless it's inside some sort of quotes or
 parenthesis.  See Info node `Sentences'."
   (or sentence-end
       (concat (if sentence-end-without-period "\\w  \\|")
-              "\\([.?!][]\"'\xd0c9)}]*"
+              "\\([.?!][]\"'\xd0c9\x5397d)}]*"
               (if sentence-end-double-space
                   "\\($\\| $\\|\t\\|  \\)" "\\($\\|[\t ]\\)")
               "\\|[" sentence-end-without-space "]+\\)"
diff --git a/lisp/time-stamp.el b/lisp/time-stamp.el
index b6e76ee5394..f574144f4b0 100644
--- a/lisp/time-stamp.el
+++ b/lisp/time-stamp.el
@@ -5,7 +5,7 @@
 
 ;; This file is part of GNU Emacs.
 
-;; Maintainer's Time-stamp: <2003-02-01 09:26:25 gildea>
+;; Maintainer's Time-stamp: <2004-06-13 19:04:36 teirllm>
 ;; Maintainer: Stephen Gildea <gildea@stop.mail-abuse.org>
 ;; Keywords: tools
 
@@ -32,7 +32,7 @@
 ;; See the top of `time-stamp.el' for another example.
 
 ;; To use time-stamping, add this line to your .emacs file:
-;;     (add-hook 'write-file-hooks 'time-stamp)
+;;     (add-hook 'before-save-hook 'time-stamp)
 ;; Now any time-stamp templates in your files will be updated automatically.
 
 ;; See the documentation for the functions `time-stamp'
@@ -242,7 +242,8 @@ of the time-stamped file itself.")
   "Update the time stamp string(s) in the buffer.
 A template in a file can be automatically updated with a new time stamp
 every time you save the file.  Add this line to your .emacs file:
-    (add-hook 'write-file-hooks 'time-stamp)
+    (add-hook 'before-save-hook 'time-stamp)
+or customize `before-save-hook' through Custom.
 Normally the template must appear in the first 8 lines of a file and
 look like one of the following:
       Time-stamp: <>
@@ -318,7 +319,6 @@ template."
       (setq start (time-stamp-once start search-limit ts-start ts-end
                                    ts-format format-lines end-lines))
       (setq ts-count (1- ts-count))))
-  ;; be sure to return nil so can be used on write-file-hooks
   nil)
 
 (defun time-stamp-once (start search-limit ts-start ts-end