* gnus.el (gnus-group-prefixed-name): Comment out the test for

[gnus] / lisp / mm-decode.el

diff --git a/lisp/mm-decode.el b/lisp/mm-decode.el
index 6a6d4c8..249f3e9 100644 (file)
--- a/lisp/mm-decode.el
+++ b/lisp/mm-decode.el
@@ -1,5 +1,6 @@
 ;;; mm-decode.el --- Functions for decoding MIME things
-;; Copyright (C) 1998, 1999, 2000, 2001, 2002, 2003 Free Software Foundation, Inc.
+;; Copyright (C) 1998, 1999, 2000, 2001, 2002,
+;;        2003 Free Software Foundation, Inc.
 
 ;; Author: Lars Magne Ingebrigtsen <larsi@gnus.org>
 ;;     MORIOKA Tomohiko <morioka@jaist.ac.jp>
@@ -110,7 +111,7 @@ The defined renderer types are:
 `links': using links;
 `lynx' : using lynx;
 `html2text' : using html2text;
-`nil'  : using external viewer."
+nil    : using external viewer."
   :type '(choice (const w3)
                 (const w3m)
                 (const links)
@@ -332,10 +333,10 @@ Ready-made functions include
 `upcase-initials'.")
 
 (defvar mm-path-name-rewrite-functions nil
-  "*List of functions used for rewriting path names of MIME parts.
-This is used when viewing parts externally , and is meant for
-transforming the path name so that non-compliant programs can
-find the file where it's saved.
+  "*List of functions for rewriting the full file names of MIME parts.
+This is used when viewing parts externally, and is meant for
+transforming the absolute name so that non-compliant programs can find
+the file where it's saved.
 
 Each function takes a file name as input and returns a file name.")
 
@@ -355,7 +356,6 @@ If not set, `default-directory' will be used."
 
 ;;; Internal variables.
 
-(defvar mm-dissection-list nil)
 (defvar mm-last-shell-command "")
 (defvar mm-content-id-alist nil)
 (defvar mm-postponed-undisplay-list nil)
@@ -552,16 +552,8 @@ for types in mm-keep-viewer-alive-types."
            (if (equal "text/plain" (car ctl))
                (assoc 'format ctl)
              t))
-    (let ((res (mm-make-handle
-               (mm-copy-to-buffer) ctl cte nil cdl description nil id)))
-      (push (car res) mm-dissection-list)
-      res)))
-
-(defun mm-remove-all-parts ()
-  "Remove all MIME handles."
-  (interactive)
-  (mapcar 'mm-remove-part mm-dissection-list)
-  (setq mm-dissection-list nil))
+    (mm-make-handle
+     (mm-copy-to-buffer) ctl cte nil cdl description nil id)))
 
 (defun mm-dissect-multipart (ctl)
   (goto-char (point-min))
@@ -954,7 +946,7 @@ external if displayed external."
   "Return the contents of HANDLE as a string."
   (mm-with-unibyte-buffer
     (insert (with-current-buffer (mm-handle-buffer handle)
-             (mm-with-unibyte-current-buffer-mule4
+             (mm-with-unibyte-current-buffer
                (buffer-string))))
     (mm-decode-content-transfer-encoding
      (mm-handle-encoding handle)
@@ -1270,7 +1262,7 @@ If RECURSIVE, search recursively."
                    (if notp
                        (not (equal (car ctl) type))
                      (equal (car ctl) type)))
-             (setq result (buffer-substring (point-min) (point-max)))))))
+             (setq result (buffer-string))))))
       (forward-line 1)
       (setq start (point)))
     (when (and (not result) start)
@@ -1283,16 +1275,16 @@ If RECURSIVE, search recursively."
                  (if notp
                      (not (equal (car ctl) type))
                    (equal (car ctl) type)))
-           (setq result (buffer-substring (point-min) (point-max)))))))
+           (setq result (buffer-string))))))
     result))
 
 (defvar mm-security-handle nil)
 
 (defsubst mm-set-handle-multipart-parameter (handle parameter value)
   ;; HANDLE could be a CTL.
-  (if handle
-      (put-text-property 0 (length (car handle)) parameter value
-                        (car handle))))
+  (when handle
+    (put-text-property 0 (length (car handle)) parameter value
+                      (car handle))))
 
 (defun mm-possibly-verify-or-decrypt (parts ctl)
   (let ((type (car ctl))
@@ -1325,25 +1317,26 @@ If RECURSIVE, search recursively."
                      protocols nil)
              (setq protocols (cdr protocols))))))
       (setq func (nth 1 (assoc protocol mm-verify-function-alist)))
-      (if (cond
-          ((eq mm-verify-option 'never) nil)
-          ((eq mm-verify-option 'always) t)
-          ((eq mm-verify-option 'known)
-           (and func
-                (or (not (setq functest
-                               (nth 3 (assoc protocol
-                                             mm-verify-function-alist))))
-                    (funcall functest parts ctl))))
-          (t (y-or-n-p
+      (when (cond
+            ((eq mm-verify-option 'never) nil)
+            ((eq mm-verify-option 'always) t)
+            ((eq mm-verify-option 'known)
+             (and func
+                  (or (not (setq functest
+                                 (nth 3 (assoc protocol
+                                               mm-verify-function-alist))))
+                      (funcall functest parts ctl))))
+            (t
+             (y-or-n-p
               (format "Verify signed (%s) part? "
                       (or (nth 2 (assoc protocol mm-verify-function-alist))
                           (format "protocol=%s" protocol))))))
-         (save-excursion
-           (if func
-               (funcall func parts ctl)
-             (mm-set-handle-multipart-parameter
-              mm-security-handle 'gnus-details
-              (format "Unknown sign protocol (%s)" protocol))))))
+       (save-excursion
+         (if func
+             (funcall func parts ctl)
+           (mm-set-handle-multipart-parameter
+            mm-security-handle 'gnus-details
+            (format "Unknown sign protocol (%s)" protocol))))))
      ((equal subtype "encrypted")
       (unless (setq protocol
                    (mm-handle-multipart-ctl-parameter ctl 'protocol))
@@ -1356,25 +1349,26 @@ If RECURSIVE, search recursively."
                      parts nil)
              (setq parts (cdr parts))))))
       (setq func (nth 1 (assoc protocol mm-decrypt-function-alist)))
-      (if (cond
-          ((eq mm-decrypt-option 'never) nil)
-          ((eq mm-decrypt-option 'always) t)
-          ((eq mm-decrypt-option 'known)
-           (and func
-                (or (not (setq functest
-                               (nth 3 (assoc protocol
-                                             mm-decrypt-function-alist))))
-                    (funcall functest parts ctl))))
-          (t (y-or-n-p
+      (when (cond
+            ((eq mm-decrypt-option 'never) nil)
+            ((eq mm-decrypt-option 'always) t)
+            ((eq mm-decrypt-option 'known)
+             (and func
+                  (or (not (setq functest
+                                 (nth 3 (assoc protocol
+                                               mm-decrypt-function-alist))))
+                      (funcall functest parts ctl))))
+            (t
+             (y-or-n-p
               (format "Decrypt (%s) part? "
                       (or (nth 2 (assoc protocol mm-decrypt-function-alist))
                           (format "protocol=%s" protocol))))))
-         (save-excursion
-           (if func
-               (setq parts (funcall func parts ctl))
-             (mm-set-handle-multipart-parameter
-              mm-security-handle 'gnus-details
-              (format "Unknown encrypt protocol (%s)" protocol))))))
+       (save-excursion
+         (if func
+             (setq parts (funcall func parts ctl))
+           (mm-set-handle-multipart-parameter
+            mm-security-handle 'gnus-details
+            (format "Unknown encrypt protocol (%s)" protocol))))))
      (t nil))
     parts))