Re: Can't decode encoding x-uuencode

[Shenghuo ZHU <zsh@cs.rochester.edu>]

>>>>> "LMI" == Lars Magne Ingebrigtsen <larsi@gnus.org> writes:

LMI> Niels Olof Bouvin <n.o.bouvin@daimi.aau.dk> writes:
>> I often get MIME mails with uuencoded attachments. When I try to 'o' the
>> attachments, I am informed that 'Can't decode encoding x-uuencode'.
>> What should I change to make this work? 

LMI> I've added this to the todo list.

Untested solution:

1. Extract the attachment to loadpath;
2. Modefy mm-bodies.el(mm-decode-content-transfer-encoding) as
    follows;
3. Test it or send me a sample. :-)

(require 'uudecode) 

(defun mm-decode-content-transfer-encoding (encoding)
  (cond
   ((eq encoding 'quoted-printable)
    (quoted-printable-decode-region (point-min) (point-max)))
   ((eq encoding 'base64)
    (condition-case ()
	(base64-decode-region (point-min) (point-max))
      (error nil)))
   ((memq encoding '(7bit 8bit binary))
    )
   ((null encoding)
    )
   ((eq encoding 'x-uuencode)
    (condition-case ()
	(uu-decode-region (point-min) (point-max))
      (error nil)))
   ((fboundp encoding)
    (funcall encoding (point-min) (point-max))
    )
   (t
    (error "Can't decode encoding %s" encoding))))


-- 
Shenghuo

----------------------------------------------------------------------
;;; uudecode.el -- elisp native uudecode
;;; Copyright (c) 1998 by Shenghuo Zhu <zsh@cs.rochester.edu>

;; Author: Shenghuo Zhu <zsh@cs.rochester.edu>
;; $Revision: 1.1 $
;; Keywords: uudecode

;;; This file is not part of GNU Emacs, but the same permissions
;;; apply.
;;;
;;; GNU Emacs is free software; you can redistribute it and/or modify
;;; it under the terms of the GNU General Public License as published by
;;; the Free Software Foundation; either version 2, or (at your option)
;;; any later version.
;;;
;;; GNU Emacs is distributed in the hope that it will be useful,
;;; but WITHOUT ANY WARRANTY; without even the implied warranty of
;;; MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
;;; GNU General Public License for more details.
;;;
;;; You should have received a copy of the GNU General Public License
;;; along with GNU Emacs; see the file COPYING.  If not, write to the
;;; Free Software Foundation, Inc., 59 Temple Place - Suite 330,
;;; Boston, MA 02111-1307, USA.

;;; Commentary:
;;;     Lots of codes are stolen from mm-decode.el, gnus-uu.el and
;;;     base64.el

;;; Code:

(if (not (fboundp 'char-int))
    (fset 'char-int 'identity))

(defvar uu-decoder-program "uudecode"
  "*Non-nil value should be a string that names a uu decoder.
The program should expect to read uu data on its standard
input and write the converted data to its standard output.")

(defvar uu-decoder-switches nil
  "*List of command line flags passed to the command named by
uu-decoder-program.")

(defvar uu-alphabet "\040-\140")

(defvar uu-begin-string "^begin[ \t]+[0-7][0-7][0-7][ \t]+\\(.*\\)$")
(defvar uu-end-string "^end[ \t]*$")

(defvar uu-body-line
  (let ((i 61) (str "^M"))
    (while (> (setq i (1- i)) 0)
      (setq str (concat str "[^a-z]")))
    (concat str ".?$")))

(defvar uu-temporary-file-directory "/tmp/")

(defun uu-decode-region-external (start end &optional file-name)
  ""
  (interactive "r\nP")
  (let ((cbuf (current-buffer)) tempfile firstline work-buffer status) 
    (save-excursion
      (goto-char start)
      (when (re-search-forward uu-begin-string nil t)
	(forward-line 1)
	(setq firstline (point))
	(cond ((null file-name))
	      ((stringp file-name))
	      (t 
	       (setq file-name (read-file-name "File to Name:" 
					       nil nil nil 
					       (match-string 1)))))
	(setq tempfile (expand-file-name
			(or file-name (concat uu-temporary-file-directory
					      (make-temp-name "uu")))))
	(let ((cdir default-directory) default-process-coding-system)
	  (unwind-protect
	      (progn
		(set-buffer (setq work-buffer 
				  (generate-new-buffer " *uudecode-work*")))
		(buffer-disable-undo work-buffer)
		(insert "begin 600 " (file-name-nondirectory tempfile) "\n")
		(insert-buffer-substring cbuf firstline end)
		(cd (file-name-directory tempfile))
		(apply 'call-process-region
		       (point-min)
		       (point-max)
		       uu-decoder-program 
		       nil
		       nil
		       nil
		       uu-decoder-switches))
	    (cd cdir) (set-buffer cbuf)))
	(if (file-exists-p tempfile)
	    (unless file-name
	      (goto-char start)
	      (delete-region start end)
	      (let (format-alist)
		(if (fboundp 'insert-file-contents-internal)
		    (insert-file-contents-internal tempfile)
		(insert-file-contents tempfile))))
	  (message "Can not uudecode")))
      (and work-buffer (kill-buffer work-buffer))
      (condition-case ()
	  (or file-name (delete-file tempfile))
	(error))
      )))

(defun uu-insert-char (char &optional count ignored buffer)
  (condition-case nil
      (progn
	(insert-char char count ignored buffer)
	(fset 'uu-insert-char 'insert-char))
    (wrong-number-of-arguments
     (fset 'uu-insert-char 'uu-xemacs-insert-char)
     (uu-insert-char char count ignored buffer))))

(defun uu-xemacs-insert-char (char &optional count ignored buffer)
  (if (or (null buffer) (eq buffer (current-buffer)))
      (insert-char char count)
    (save-excursion
      (set-buffer buffer)
      (insert-char char count))))

(defun uu-decode-region (start end &optional file-name)
  (interactive "r\nP")
  (let ((work-buffer nil)
	(done nil)
	(counter 0)
	(remain 0)
	(bits 0)
	(lim 0) inputpos
	(non-data-chars (concat "^" uu-alphabet)))
    (unwind-protect
	(save-excursion
	  (goto-char start)
	  (when (re-search-forward uu-begin-string nil t)
	    (cond ((null file-name))
		  ((stringp file-name))
		  (t 
		   (setq file-name (expand-file-name 
				    (read-file-name "File to Name:" 
						    nil nil nil 
						    (match-string 1))))))
	    (setq work-buffer (generate-new-buffer " *uudecode-work*"))
	    (buffer-disable-undo work-buffer)
	    (forward-line 1)
	    (skip-chars-forward non-data-chars end)
	    (while (not done)
	      (setq inputpos (point))
	      (setq remain 0 bits 0 counter 0)
	      (cond
	       ((> (skip-chars-forward uu-alphabet end) 0)
		(setq lim (point))
		(setq remain 
		      (logand (- (char-int (char-after inputpos)) 32) 63))
		(setq inputpos (1+ inputpos))
		(if (= remain 0) (setq done t))
		(while (and (< inputpos lim) (> remain 0))
		  (setq bits (+ bits 
				(logand 
				 (- 
				  (char-int (char-after inputpos)) 32) 63)))
		  (if (/= counter 0) (setq remain (1- remain)))
		  (setq counter (1+ counter)
			inputpos (1+ inputpos))
		  (cond ((= counter 4)
			 (uu-insert-char (lsh bits -16) 1 nil work-buffer)
			 (uu-insert-char (logand (lsh bits -8) 255) 1 nil
					 work-buffer)
			 (uu-insert-char (logand bits 255) 1 nil
					 work-buffer)
			 (setq bits 0 counter 0))
			(t (setq bits (lsh bits 6)))))))
	      (cond
		 (done)
		 ((> 0 remain)
		  (error "uucode line ends unexpectly")
		  (setq done t))
		 ((and (= (point) end) (not done))
		  (error "uucode ends unexpectly")
		  (setq done t))
		 ((= counter 3)
		  (uu-insert-char (logand (lsh bits -16) 255) 1 nil 
				  work-buffer)
		  (uu-insert-char (logand (lsh bits -8) 255) 1 nil
				  work-buffer))
		 ((= counter 2)
		  (uu-insert-char (logand (lsh bits -10) 255) 1 nil 
				  work-buffer)))
	      (skip-chars-forward non-data-chars end))
	    (if file-name
		(save-excursion
		  (set-buffer work-buffer)
		  (write-file file-name))
	      (or (markerp end) (setq end (set-marker (make-marker) end)))
	      (goto-char start)
	      (insert-buffer-substring work-buffer)
	      (delete-region (point) end))))
      (and work-buffer (kill-buffer work-buffer)))))

(provide 'uudecode)
;; end of uudecode.el