* mm-util.el, nnultimate.el, nnweb.el, nnslashdot.el: Sync with

	the Gnus CVS.

	* mm-util.el (mm-mime-mule-charset-alist): Move down and call
	mm-coding-system-p. Don't correct it only in XEmacs.
	(mm-charset-to-coding-system): Use mm-coding-system-p and
	mm-get-coding-system-list.
	(mm-emacs-mule, mm-mule4-p): New.
	(mm-enable-multibyte, mm-disable-multibyte,
	mm-enable-multibyte-mule4, mm-disable-multibyte-mule4,
	mm-with-unibyte-current-buffer,
	mm-with-unibyte-current-buffer-mule4): Use them.
	(mm-find-mime-charset-region): Treat iso-2022-jp.

	From  Dave Love  <fx@gnu.org>:

	* mm-util.el (mm-mime-mule-charset-alist): Make it correct by
	construction.
	(mm-charset-synonym-alist): Remove windows-125[02].  Make other
	entries conditional on not having a coding system defined for
	them.
	(mm-mule-charset-to-mime-charset): Use
	find-coding-systems-for-charsets if defined.
	(mm-charset-to-coding-system): Don't use
	mm-get-coding-system-list.  Look in mm-charset-synonym-alist
	later.  Add last resort search of coding systems.
	(mm-enable-multibyte-mule4, mm-disable-multibyte-mule4)
	(mm-with-unibyte-current-buffer-mule4): Just treat Mule 5 like
	Mule 4.
	(mm-find-mime-charset-region): Re-write.
	(mm-with-unibyte-current-buffer): Restore buffer as well as
	multibyteness.

1 files changed, 303 insertions, 188 deletions

diff --git a/lisp/gnus/mm-util.el b/lisp/gnus/mm-util.el
index 95ab4f6291f..69823c43d1c 100644
--- a/lisp/gnus/mm-util.el
+++ b/lisp/gnus/mm-util.el
@@ -1,4 +1,4 @@
-;;; mm-util.el --- utility functions for MIME things
+;;; mm-util.el --- Utility functions for Mule and low level things
 ;; Copyright (C) 1998, 1999, 2000, 2001 Free Software Foundation, Inc.
 
 ;; Author: Lars Magne Ingebrigtsen <larsi@gnus.org>
@@ -27,63 +27,6 @@
 (eval-when-compile (require 'cl))
 (require 'mail-prsvr)
 
-(defun mm-coding-system-p (sym)
-  "Return non-nil if SYM is a coding system."
-  (or (and (fboundp 'coding-system-p) (coding-system-p sym))
-      (memq sym (mm-get-coding-system-list))))
-
-(defvar mm-mime-mule-charset-alist
-  `((us-ascii ascii)
-    (iso-8859-1 latin-iso8859-1)
-    (iso-8859-2 latin-iso8859-2)
-    (iso-8859-3 latin-iso8859-3)
-    (iso-8859-4 latin-iso8859-4)
-    (iso-8859-5 cyrillic-iso8859-5)
-    ;; Non-mule (X)Emacs uses the last mule-charset for 8bit characters.
-    ;; The fake mule-charset, gnus-koi8-r, tells Gnus that the default 
-    ;; charset is koi8-r, not iso-8859-5.
-    (koi8-r cyrillic-iso8859-5 gnus-koi8-r)
-    (iso-8859-6 arabic-iso8859-6)
-    (iso-8859-7 greek-iso8859-7)
-    (iso-8859-8 hebrew-iso8859-8)
-    (iso-8859-9 latin-iso8859-9)
-    (iso-8859-14 latin-iso8859-14)
-    (iso-8859-15 latin-iso8859-15)
-    (viscii vietnamese-viscii-lower)
-    (iso-2022-jp latin-jisx0201 japanese-jisx0208 japanese-jisx0208-1978)
-    (euc-kr korean-ksc5601)
-    (gb2312 chinese-gb2312)
-    (big5 chinese-big5-1 chinese-big5-2)
-    (tibetan tibetan)
-    (thai-tis620 thai-tis620)
-    (iso-2022-7bit ethiopic arabic-1-column arabic-2-column)
-    (iso-2022-jp-2 latin-iso8859-1 greek-iso8859-7
-		   latin-jisx0201 japanese-jisx0208-1978
-		   chinese-gb2312 japanese-jisx0208
-		   korean-ksc5601 japanese-jisx0212
-		   katakana-jisx0201)
-    (iso-2022-int-1 latin-iso8859-1 greek-iso8859-7
-		    latin-jisx0201 japanese-jisx0208-1978
-		    chinese-gb2312 japanese-jisx0208
-		    korean-ksc5601 japanese-jisx0212
-		    chinese-cns11643-1 chinese-cns11643-2)
-    (iso-2022-int-1 latin-iso8859-1 latin-iso8859-2
-		    cyrillic-iso8859-5 greek-iso8859-7
-		    latin-jisx0201 japanese-jisx0208-1978
-		    chinese-gb2312 japanese-jisx0208
-		    korean-ksc5601 japanese-jisx0212
-		    chinese-cns11643-1 chinese-cns11643-2
-		    chinese-cns11643-3 chinese-cns11643-4
-		    chinese-cns11643-5 chinese-cns11643-6
-		    chinese-cns11643-7)
-    ;; utf-8 comes either from Mule-UCS or Mule 5+.
-    ,@(if (mm-coding-system-p 'utf-8)
-	  (list (cons 'utf-8 (delete 'ascii
-				     (coding-system-get
-				      'mule-utf-8
-				      'safe-charsets))))))
-  "Alist of MIME-charset/MULE-charsets.")
-
 (eval-and-compile
   (mapcar
    (lambda (elem)
@@ -104,12 +47,6 @@
      (make-char
       . (lambda (charset int)
 	  (int-to-char int)))
-     (read-coding-system
-      . (lambda (prompt)
-	  "Prompt the user for a coding system."
-	  (completing-read
-	   prompt (mapcar (lambda (s) (list (symbol-name (car s))))
-			  mm-mime-mule-charset-alist))))
      (read-charset
       . (lambda (prompt)
 	  "Return a charset."
@@ -119,40 +56,85 @@
 	    (mapcar (lambda (e) (list (symbol-name (car e))))
 		    mm-mime-mule-charset-alist)
 	    nil t))))
+     (subst-char-in-string
+      . (lambda (from to string) ;; stolen (and renamed) from nnheader.el
+	  "Replace characters in STRING from FROM to TO."
+	  (let ((string (substring string 0)) ;Copy string.
+		(len (length string))
+		(idx 0))
+	    ;; Replace all occurrences of FROM with TO.
+	    (while (< idx len)
+	      (when (= (aref string idx) from)
+		(aset string idx to))
+	      (setq idx (1+ idx)))
+	    string)))
      (string-as-unibyte . identity)
-     (multibyte-string-p . ignore)
-     )))
+     (string-as-multibyte . identity)
+     (multibyte-string-p . ignore))))
 
 (eval-and-compile
   (defalias 'mm-char-or-char-int-p
-    (cond 
+    (cond
      ((fboundp 'char-or-char-int-p) 'char-or-char-int-p)
-     ((fboundp 'char-valid-p) 'char-valid-p) 
+     ((fboundp 'char-valid-p) 'char-valid-p)
      (t 'identity))))
 
+(eval-and-compile
+  (defalias 'mm-read-coding-system
+    (cond
+     ((fboundp 'read-coding-system)
+      (if (and (featurep 'xemacs)
+	       (<= (string-to-number emacs-version) 21.1))
+	  (lambda (prompt &optional default-coding-system)
+	    (read-coding-system prompt))
+	'read-coding-system))
+     (t (lambda (prompt &optional default-coding-system)
+	  "Prompt the user for a coding system."
+	  (completing-read
+	   prompt (mapcar (lambda (s) (list (symbol-name (car s))))
+			  mm-mime-mule-charset-alist)))))))
+
 (defvar mm-coding-system-list nil)
 (defun mm-get-coding-system-list ()
   "Get the coding system list."
   (or mm-coding-system-list
       (setq mm-coding-system-list (mm-coding-system-list))))
 
+(defun mm-coding-system-p (sym)
+  "Return non-nil if SYM is a coding system."
+  (or (and (fboundp 'coding-system-p) (coding-system-p sym))
+      (memq sym (mm-get-coding-system-list))))
+
 (defvar mm-charset-synonym-alist
-  `((big5 . cn-big5)
-    (gb2312 . cn-gb-2312)
+  `(
+    ;; Perfectly fine?  A valid MIME name, anyhow.
+    ,(unless (mm-coding-system-p 'big5)
+       '(big5 . cn-big5))
+    ;; Not in XEmacs, but it's not a proper MIME charset anyhow.
+    ,(unless (mm-coding-system-p 'x-ctext)
+       '(x-ctext . ctext))
+    ;; Apparently not defined in Emacs 20, but is a valid MIME name.
+    ,(unless (mm-coding-system-p 'gb2312)
+       '(gb2312 . cn-gb-2312))
     ;; Windows-1252 is actually a superset of Latin-1.  See also
     ;; `gnus-article-dumbquotes-map'.
-    ,(unless (mm-coding-system-p 'windows-1252) ; should be defined eventually
-       '(windows-1252 . iso-8859-1))
+    ;;,(unless (mm-coding-system-p 'windows-1252)	
+					; should be defined eventually
+    ;;  '(windows-1252 . iso-8859-1))
+    ;; ISO-8859-15 is very similar to ISO-8859-1.
+    ;;,(unless (mm-coding-system-p 'iso-8859-15) ; Emacs 21 defines it.
+    ;;   '(iso-8859-15 . iso-8859-1))
     ;; Windows-1250 is a variant of Latin-2 heavily used by Microsoft
     ;; Outlook users in Czech republic. Use this to allow reading of their
     ;; e-mails. cp1250 should be defined by M-x codepage-setup.
-    ,(unless (mm-coding-system-p 'windows-1250)	; should be defined eventually
-       '(windows-1250 . cp1250))
-    (x-ctext . ctext))
+    ;;,(unless (mm-coding-system-p 'windows-1250)	
+					; should be defined eventually
+    ;;  '(windows-1250 . cp1250))
+    )
   "A mapping from invalid charset names to the real charset names.")
 
 (defvar mm-binary-coding-system
-  (cond 
+  (cond
    ((mm-coding-system-p 'binary) 'binary)
    ((mm-coding-system-p 'no-conversion) 'no-conversion)
    (t nil))
@@ -169,30 +151,113 @@
   "Text coding system for write.")
 
 (defvar mm-auto-save-coding-system
-  (cond 
+  (cond
    ((mm-coding-system-p 'emacs-mule)
     (if (memq system-type '(windows-nt ms-dos ms-windows))
-	(if (mm-coding-system-p 'emacs-mule-dos) 
+	(if (mm-coding-system-p 'emacs-mule-dos)
 	    'emacs-mule-dos mm-binary-coding-system)
       'emacs-mule))
    ((mm-coding-system-p 'escape-quoted) 'escape-quoted)
    (t mm-binary-coding-system))
   "Coding system of auto save file.")
 
+(defvar mm-universal-coding-system mm-auto-save-coding-system
+  "The universal Coding system.")
+
+;; Fixme: some of the cars here aren't valid MIME charsets.  That
+;; should only matter with XEmacs, though.
+(defvar mm-mime-mule-charset-alist
+  `((us-ascii ascii)
+    (iso-8859-1 latin-iso8859-1)
+    (iso-8859-2 latin-iso8859-2)
+    (iso-8859-3 latin-iso8859-3)
+    (iso-8859-4 latin-iso8859-4)
+    (iso-8859-5 cyrillic-iso8859-5)
+    ;; Non-mule (X)Emacs uses the last mule-charset for 8bit characters.
+    ;; The fake mule-charset, gnus-koi8-r, tells Gnus that the default
+    ;; charset is koi8-r, not iso-8859-5.
+    (koi8-r cyrillic-iso8859-5 gnus-koi8-r)
+    (iso-8859-6 arabic-iso8859-6)
+    (iso-8859-7 greek-iso8859-7)
+    (iso-8859-8 hebrew-iso8859-8)
+    (iso-8859-9 latin-iso8859-9)
+    (iso-8859-14 latin-iso8859-14)
+    (iso-8859-15 latin-iso8859-15)
+    (viscii vietnamese-viscii-lower)
+    (iso-2022-jp latin-jisx0201 japanese-jisx0208 japanese-jisx0208-1978)
+    (euc-kr korean-ksc5601)
+    (gb2312 chinese-gb2312)
+    (big5 chinese-big5-1 chinese-big5-2)
+    (tibetan tibetan)
+    (thai-tis620 thai-tis620)
+    (iso-2022-7bit ethiopic arabic-1-column arabic-2-column)
+    (iso-2022-jp-2 latin-iso8859-1 greek-iso8859-7
+		   latin-jisx0201 japanese-jisx0208-1978
+		   chinese-gb2312 japanese-jisx0208
+		   korean-ksc5601 japanese-jisx0212
+		   katakana-jisx0201)
+    (iso-2022-int-1 latin-iso8859-1 greek-iso8859-7
+		    latin-jisx0201 japanese-jisx0208-1978
+		    chinese-gb2312 japanese-jisx0208
+		    korean-ksc5601 japanese-jisx0212
+		    chinese-cns11643-1 chinese-cns11643-2)
+    (iso-2022-int-1 latin-iso8859-1 latin-iso8859-2
+		    cyrillic-iso8859-5 greek-iso8859-7
+		    latin-jisx0201 japanese-jisx0208-1978
+		    chinese-gb2312 japanese-jisx0208
+		    korean-ksc5601 japanese-jisx0212
+		    chinese-cns11643-1 chinese-cns11643-2
+		    chinese-cns11643-3 chinese-cns11643-4
+		    chinese-cns11643-5 chinese-cns11643-6
+		    chinese-cns11643-7)
+    ,(if (or (not (fboundp 'charsetp)) ;; non-Mule case
+	     (charsetp 'unicode-a)
+	     (not (mm-coding-system-p 'mule-utf-8)))
+	 '(utf-8 unicode-a unicode-b unicode-c unicode-d unicode-e)
+       ;; If we have utf-8 we're in Mule 5+.
+       (append '(utf-8)
+	       (delete 'ascii
+		       (coding-system-get 'mule-utf-8 'safe-charsets)))))
+  "Alist of MIME-charset/MULE-charsets.")
+
+;; Correct by construction, but should be unnecessary:
+;; XEmacs hates it.
+(when (and (not (featurep 'xemacs))
+	   (fboundp 'coding-system-list)
+	   (fboundp 'sort-coding-systems))
+  (setq mm-mime-mule-charset-alist
+	(apply
+	 'nconc
+	 (mapcar
+	  (lambda (cs)
+	    (when (and (coding-system-get cs 'mime-charset)
+		       (not (eq t (coding-system-get cs 'safe-charsets))))
+	      (list (cons (coding-system-get cs 'mime-charset)
+			  (delq 'ascii
+				(coding-system-get cs 'safe-charsets))))))
+	  (sort-coding-systems (coding-system-list 'base-only))))))
+
 ;;; Internal variables:
 
 ;;; Functions:
 
 (defun mm-mule-charset-to-mime-charset (charset)
   "Return the MIME charset corresponding to the given Mule CHARSET."
-  (let ((alist mm-mime-mule-charset-alist)
-	out)
-    (while alist
-      (when (memq charset (cdar alist))
-	(setq out (caar alist)
-	      alist nil))
-      (pop alist))
-    out))
+  (if (fboundp 'find-coding-systems-for-charsets)
+      (let (mime)
+	(dolist (cs (find-coding-systems-for-charsets (list charset)))
+	  (unless mime
+	    (when cs
+	      (setq mime (coding-system-get cs 'mime-charset)))))
+	mime)
+    (let ((alist mm-mime-mule-charset-alist)
+	  out)
+      (while alist
+	(when (memq charset (cdar alist))
+	  (setq out (caar alist)
+		alist nil))
+	(pop alist))
+      out)))
 
 (defun mm-charset-to-coding-system (charset &optional lbt)
   "Return coding-system corresponding to CHARSET.
@@ -201,9 +266,6 @@ If optional argument LBT (`unix', `dos' or `mac') is specified, it is
 used as the line break code type of the coding system."
   (when (stringp charset)
     (setq charset (intern (downcase charset))))
-  (setq charset
-	(or (cdr (assq charset mm-charset-synonym-alist))
-	    charset))
   (when lbt
     (setq charset (intern (format "%s-%s" charset lbt))))
   (cond
@@ -215,58 +277,73 @@ used as the line break code type of the coding system."
     'ascii)
    ;; Check to see whether we can handle this charset.  (This depends
    ;; on there being some coding system matching each `mime-charset'
-   ;; coding sysytem property defined, as there should be.)
-   ((memq charset (mm-get-coding-system-list))
+   ;; property defined, as there should be.)
+   ((and (mm-coding-system-p charset)
+;;; Doing this would potentially weed out incorrect charsets.
+;;; 	 charset
+;;; 	 (eq charset (coding-system-get charset 'mime-charset))
+	 )
     charset)
-   ;; Nope.
-   (t
-    nil)))
-
-(if (fboundp 'subst-char-in-string)
-    (defsubst mm-replace-chars-in-string (string from to)
-      (subst-char-in-string from to string))
-  (defun mm-replace-chars-in-string (string from to)
-    "Replace characters in STRING from FROM to TO."
-    (let ((string (substring string 0))	;Copy string.
-	  (len (length string))
-	  (idx 0))
-      ;; Replace all occurrences of FROM with TO.
-      (while (< idx len)
-	(when (= (aref string idx) from)
-	  (aset string idx to))
-	(setq idx (1+ idx)))
-      string)))
-
-(defsubst mm-enable-multibyte ()
-  "Set the multibyte flag of the current buffer.
+   ;; Translate invalid charsets.
+   ((mm-coding-system-p (setq charset
+			   (cdr (assq charset
+				      mm-charset-synonym-alist))))
+    charset)
+   ;; Last resort: search the coding system list for entries which
+   ;; have the right mime-charset in case the canonical name isn't
+   ;; defined (though it should be).
+   ((let (cs)
+      ;; mm-get-coding-system-list returns a list of cs without lbt.
+      ;; Do we need -lbt?
+      (dolist (c (mm-get-coding-system-list))
+	(if (and (null cs)
+		 (eq charset (coding-system-get c 'mime-charset)))
+	    (setq cs c)))
+      cs))))
+
+(defsubst mm-replace-chars-in-string (string from to)
+  (mm-subst-char-in-string from to string))
+
+(eval-and-compile
+  (defvar mm-emacs-mule (and (not (featurep 'xemacs))
+			     (boundp 'default-enable-multibyte-characters)
+			     default-enable-multibyte-characters
+			     (fboundp 'set-buffer-multibyte))
+    "Emacs mule.")
+  
+  (defvar mm-mule4-p (and mm-emacs-mule
+			  (fboundp 'charsetp)
+			  (not (charsetp 'eight-bit-control)))
+    "Mule version 4.")
+
+  (if mm-emacs-mule
+      (defun mm-enable-multibyte ()
+	"Set the multibyte flag of the current buffer.
 Only do this if the default value of `enable-multibyte-characters' is
 non-nil.  This is a no-op in XEmacs."
-  (when (and (fboundp 'set-buffer-multibyte)
-             (boundp 'enable-multibyte-characters)
-	     (default-value 'enable-multibyte-characters))
-    (set-buffer-multibyte t)))
+	(set-buffer-multibyte t))
+    (defalias 'mm-enable-multibyte 'ignore))
 
-(defsubst mm-disable-multibyte ()
-  "Unset the multibyte flag of in the current buffer.
+  (if mm-emacs-mule
+      (defun mm-disable-multibyte ()
+	"Unset the multibyte flag of in the current buffer.
 This is a no-op in XEmacs."
-  (when (fboundp 'set-buffer-multibyte)
-    (set-buffer-multibyte nil)))
+	(set-buffer-multibyte nil))
+    (defalias 'mm-disable-multibyte 'ignore))
 
-(defsubst mm-enable-multibyte-mule4 ()
-  "Enable multibyte in the current buffer.
+  (if mm-mule4-p
+      (defun mm-enable-multibyte-mule4  ()
+	"Enable multibyte in the current buffer.
 Only used in Emacs Mule 4."
-  (when (and (fboundp 'set-buffer-multibyte)
-             (boundp 'enable-multibyte-characters)
-	     (default-value 'enable-multibyte-characters)
-	     (not (charsetp 'eight-bit-control)))
-    (set-buffer-multibyte t)))
-
-(defsubst mm-disable-multibyte-mule4 ()
-  "Disable multibyte in the current buffer.
+	(set-buffer-multibyte t))
+    (defalias 'mm-enable-multibyte-mule4 'ignore))
+  
+  (if mm-mule4-p
+      (defun mm-disable-multibyte-mule4 ()
+	"Disable multibyte in the current buffer.
 Only used in Emacs Mule 4."
-  (when (and (fboundp 'set-buffer-multibyte)
-	     (not (charsetp 'eight-bit-control)))
-    (set-buffer-multibyte nil)))
+	(set-buffer-multibyte nil))
+    (defalias 'mm-disable-multibyte-mule4 'ignore)))
 
 (defun mm-preferred-coding-system (charset)
   ;; A typo in some Emacs versions.
@@ -294,10 +371,10 @@ If the charset is `composition', return the actual one."
 	   (progn
 	     (setq mail-parse-mule-charset
 		   (and (boundp 'current-language-environment)
-		      (car (last 
-			    (assq 'charset 
-				  (assoc current-language-environment 
-					 language-info-alist))))))
+			(car (last
+			      (assq 'charset
+				    (assoc current-language-environment
+					   language-info-alist))))))
 	     (if (or (not mail-parse-mule-charset)
 		     (eq mail-parse-mule-charset 'ascii))
 		 (setq mail-parse-mule-charset
@@ -309,6 +386,8 @@ If the charset is `composition', return the actual one."
 
 (defun mm-mime-charset (charset)
   "Return the MIME charset corresponding to the given Mule CHARSET."
+  (if (eq charset 'unknown)
+      (error "The message contains non-printable characters, please use attachment"))
   (if (and (fboundp 'coding-system-get) (fboundp 'get-charset-property))
       ;; This exists in Emacs 20.
       (or
@@ -317,6 +396,7 @@ If the charset is `composition', return the actual one."
 	     (mm-preferred-coding-system charset) 'mime-charset))
        (and (eq charset 'ascii)
 	    'us-ascii)
+       (mm-preferred-coding-system charset)
        (mm-mule-charset-to-mime-charset charset))
     ;; This is for XEmacs.
     (mm-mule-charset-to-mime-charset charset)))
@@ -330,21 +410,8 @@ If the charset is `composition', return the actual one."
       (setq result (cons head result)))
     (nreverse result)))
 
-(defun mm-find-mime-charset-region (b e)
-  "Return the MIME charsets needed to encode the region between B and E."
-  (let ((charsets (mapcar 'mm-mime-charset
-			  (delq 'ascii
-				(mm-find-charset-region b e)))))
-    (when (memq 'iso-2022-jp-2 charsets)
-      (setq charsets (delq 'iso-2022-jp charsets)))
-    (setq charsets (mm-delete-duplicates charsets))
-    (if (and (> (length charsets) 1)
-	     (fboundp 'find-coding-systems-region)
-	     (let ((cs (find-coding-systems-region b e)))
-	       (or (memq 'utf-8 cs) (memq 'mule-utf-8 cs))))
-	'(utf-8)
-      charsets)))
-
+;; It's not clear whether this is supposed to mean the global or local
+;; setting.  I think it's used inconsistently.  -- fx
 (defsubst mm-multibyte-p ()
   "Say whether multibyte is enabled."
   (if (and (not (featurep 'xemacs))
@@ -352,6 +419,39 @@ If the charset is `composition', return the actual one."
       enable-multibyte-characters
     (featurep 'mule)))
 
+(defun mm-find-mime-charset-region (b e)
+  "Return the MIME charsets needed to encode the region between B and E.
+Nil means ASCII, a single-element list represents an appropriate MIME
+charset, and a longer list means no appropriate charset."
+  ;; The return possibilities of this function are a mess...
+  (or (and
+       (mm-multibyte-p)
+       (fboundp 'find-coding-systems-region)
+       ;; Find the mime-charset of the most preferred coding
+       ;; system that has one.
+       (let ((systems (find-coding-systems-region b e))
+	     result)
+	 ;; Fixme: The `mime-charset' (`x-ctext') of `compound-text'
+	 ;; is not in the IANA list.
+	 (setq systems (delq 'compound-text systems))
+	 (unless (equal systems '(undecided))
+	   (while systems
+	     (let ((cs (coding-system-get (pop systems) 'mime-charset)))
+	       (if cs
+		   (setq systems nil
+			 result (list cs))))))
+	 result))
+      ;; Otherwise we're not multibyte, XEmacs or a single coding
+      ;; system won't cover it.
+      (let ((charsets 
+	     (mm-delete-duplicates
+	      (mapcar 'mm-mime-charset
+		      (delq 'ascii
+			    (mm-find-charset-region b e))))))
+	(if (memq 'iso-2022-jp-2 charsets)
+	    (delq 'iso-2022-jp charsets)
+	  charsets))))
+
 (defmacro mm-with-unibyte-buffer (&rest forms)
   "Create a temporary buffer, and evaluate FORMS there like `progn'.
 Use unibyte mode for this."
@@ -364,15 +464,18 @@ Use unibyte mode for this."
   "Evaluate FORMS with current current buffer temporarily made unibyte.
 Also bind `default-enable-multibyte-characters' to nil.
 Equivalent to `progn' in XEmacs"
-  (let ((multibyte (make-symbol "multibyte")))
-    `(if (fboundp 'set-buffer-multibyte)
-	 (let ((,multibyte enable-multibyte-characters))
+  (let ((multibyte (make-symbol "multibyte"))
+	(buffer (make-symbol "buffer")))
+    `(if mm-emacs-mule 
+ 	 (let ((,multibyte enable-multibyte-characters)
+	       (,buffer (current-buffer)))
 	   (unwind-protect
 	       (let (default-enable-multibyte-characters)
 		 (set-buffer-multibyte nil)
 		 ,@forms)
+	     (set-buffer ,buffer)
 	     (set-buffer-multibyte ,multibyte)))
-       (progn
+       (let (default-enable-multibyte-characters)
 	 ,@forms))))
 (put 'mm-with-unibyte-current-buffer 'lisp-indent-function 0)
 (put 'mm-with-unibyte-current-buffer 'edebug-form-spec '(body))
@@ -380,22 +483,19 @@ Equivalent to `progn' in XEmacs"
 (defmacro mm-with-unibyte-current-buffer-mule4 (&rest forms)
   "Evaluate FORMS there like `progn' in current buffer.
 Mule4 only."
-  (let ((multibyte (make-symbol "multibyte")))
-    `(if (or (featurep 'xemacs)
-	     (not (fboundp 'set-buffer-multibyte))
-	     (charsetp 'eight-bit-control)) ;; For Emacs Mule 4 only.
-	 (progn
-	   ,@forms)
-       (let ((,multibyte (default-value 'enable-multibyte-characters)))
-	 (unwind-protect
-	     (let ((buffer-file-coding-system mm-binary-coding-system)
-		   (coding-system-for-read mm-binary-coding-system)
-		   (coding-system-for-write mm-binary-coding-system))
-	       (set-buffer-multibyte nil)
-	       (setq-default enable-multibyte-characters nil)
-	       ,@forms)
-	   (setq-default enable-multibyte-characters ,multibyte)
-	   (set-buffer-multibyte ,multibyte))))))
+  (let ((multibyte (make-symbol "multibyte"))
+	(buffer (make-symbol "buffer")))
+    `(if mm-mule4-p
+ 	 (let ((,multibyte enable-multibyte-characters)
+	       (,buffer (current-buffer)))
+	   (unwind-protect
+	       (let (default-enable-multibyte-characters)
+		 (set-buffer-multibyte nil)
+		 ,@forms)
+	     (set-buffer ,buffer)
+	     (set-buffer-multibyte ,multibyte)))
+       (let (default-enable-multibyte-characters)
+	 ,@forms))))
 (put 'mm-with-unibyte-current-buffer-mule4 'lisp-indent-function 0)
 (put 'mm-with-unibyte-current-buffer-mule4 'edebug-form-spec '(body))
 
@@ -410,9 +510,14 @@ Mule4 only."
   "Return a list of Emacs charsets in the region B to E."
   (cond
    ((and (mm-multibyte-p)
- 	 (fboundp 'find-charset-region))
+	 (fboundp 'find-charset-region))
     ;; Remove composition since the base charsets have been included.
-    (delq 'composition (find-charset-region b e)))
+    ;; Remove eight-bit-*, treat them as ascii.
+    (let ((css (find-charset-region b e)))
+      (mapcar (lambda (cs) (setq css (delq cs css)))
+	      '(composition eight-bit-control eight-bit-graphic
+			    control-1))
+      css))
    (t
     ;; We are in a unibyte buffer or XEmacs non-mule, so we futz around a bit.
     (save-excursion
@@ -425,8 +530,8 @@ Mule4 only."
 	  (let (charset)
 	    (setq charset
 		  (and (boundp 'current-language-environment)
-		       (car (last (assq 'charset 
-					(assoc current-language-environment 
+		       (car (last (assq 'charset
+					(assoc current-language-environment
 					       language-info-alist))))))
 	    (if (eq charset 'ascii) (setq charset nil))
 	    (or charset
@@ -476,15 +581,15 @@ If INHIBIT is non-nil, inhibit mm-inhibit-file-name-handlers.
 	(auto-mode-alist (if inhibit nil (mm-auto-mode-alist)))
 	(default-major-mode 'fundamental-mode)
 	(enable-local-variables nil)
-        (after-insert-file-functions nil)
+	(after-insert-file-functions nil)
 	(enable-local-eval nil)
 	(find-file-hooks nil)
-	(inhibit-file-name-operation (if inhibit 
+	(inhibit-file-name-operation (if inhibit
 					 'insert-file-contents
 				       inhibit-file-name-operation))
 	(inhibit-file-name-handlers
 	 (if inhibit
-	     (append mm-inhibit-file-name-handlers 
+	     (append mm-inhibit-file-name-handlers
 		     inhibit-file-name-handlers)
 	   inhibit-file-name-handlers)))
     (insert-file-contents filename visit beg end replace)))
@@ -497,37 +602,47 @@ saying what text to write.
 Optional fourth argument specifies the coding system to use when
 encoding the file.
 If INHIBIT is non-nil, inhibit mm-inhibit-file-name-handlers."
-  (let ((coding-system-for-write 
-	 (or codesys mm-text-coding-system-for-write 
+  (let ((coding-system-for-write
+	 (or codesys mm-text-coding-system-for-write
 	     mm-text-coding-system))
-	(inhibit-file-name-operation (if inhibit 
+	(inhibit-file-name-operation (if inhibit
 					 'append-to-file
 				       inhibit-file-name-operation))
 	(inhibit-file-name-handlers
 	 (if inhibit
-	     (append mm-inhibit-file-name-handlers 
+	     (append mm-inhibit-file-name-handlers
 		     inhibit-file-name-handlers)
 	   inhibit-file-name-handlers)))
     (append-to-file start end filename)))
 
-(defun mm-write-region (start end filename &optional append visit lockname 
+(defun mm-write-region (start end filename &optional append visit lockname
 			      coding-system inhibit)
 
   "Like `write-region'.
 If INHIBIT is non-nil, inhibit mm-inhibit-file-name-handlers."
-  (let ((coding-system-for-write 
-	 (or coding-system mm-text-coding-system-for-write 
+  (let ((coding-system-for-write
+	 (or coding-system mm-text-coding-system-for-write
 	     mm-text-coding-system))
-	(inhibit-file-name-operation (if inhibit 
+	(inhibit-file-name-operation (if inhibit
 					 'write-region
 				       inhibit-file-name-operation))
 	(inhibit-file-name-handlers
 	 (if inhibit
-	     (append mm-inhibit-file-name-handlers 
+	     (append mm-inhibit-file-name-handlers
 		     inhibit-file-name-handlers)
 	   inhibit-file-name-handlers)))
     (write-region start end filename append visit lockname)))
 
+(defun mm-image-load-path (&optional package)
+  (let (dir result)
+    (dolist (path load-path (nreverse result))
+      (if (file-directory-p
+	   (setq dir (concat (file-name-directory
+			      (directory-file-name path))
+			     "etc/" (or package "gnus/"))))
+	  (push dir result))
+      (push path result))))
+
 (provide 'mm-util)
 
 ;;; mm-util.el ends here