;; 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, 675 Mass Ave, Cambridge, MA 02139, USA.
+;; 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:
("\\.\\(wav\\|aiff\\|hcom\\|u[blw]\\|s[bfw]\\|voc\\|smp\\)$"
"sox -v .5 %s -t .au -u - > /dev/audio")
("\\.au$" "cat %s > /dev/audio")
+ ("\\.midi?$" "playmidi -f")
("\\.mod$" "str32")
("\\.ps$" "ghostview")
("\\.dvi$" "xdvi")
(defconst gnus-uu-uudecode-process nil)
(defvar gnus-uu-binhex-article-name nil)
-(defvar gnus-uu-generated-file-list nil)
(defvar gnus-uu-work-dir nil)
(defconst gnus-uu-output-buffer-name " *Gnus UU Output*")
-(defvar gnus-uu-default-dir default-directory)
+(defvar gnus-uu-default-dir gnus-article-save-directory)
(defvar gnus-uu-digest-from-subject nil)
;; Keymaps
(read-file-name "Uudecode and save in dir: "
gnus-uu-default-dir
gnus-uu-default-dir t))))
- (gnus-uu-decode-with-method 'gnus-uu-uustrip-article n dir))
+ (gnus-uu-decode-with-method 'gnus-uu-uustrip-article n dir nil nil t))
(defun gnus-uu-decode-unshar (n)
"Unshars the current article."
(interactive "P")
- (gnus-uu-decode-with-method 'gnus-uu-unshar-article n nil nil 'scan))
+ (gnus-uu-decode-with-method 'gnus-uu-unshar-article n nil nil 'scan t))
(defun gnus-uu-decode-unshar-and-save (n dir)
"Unshars and saves the current article."
(read-file-name "Unshar and save in dir: "
gnus-uu-default-dir
gnus-uu-default-dir t))))
- (gnus-uu-decode-with-method 'gnus-uu-unshar-article n dir nil 'scan))
+ (gnus-uu-decode-with-method 'gnus-uu-unshar-article n dir nil 'scan t))
(defun gnus-uu-decode-save (n file)
"Saves the current article."
gnus-uu-default-dir
gnus-uu-default-dir)))
(setq gnus-uu-saved-article-name file)
- (gnus-uu-decode-with-method 'gnus-uu-save-article n nil t)
- (setq gnus-uu-generated-file-list
- (delete file gnus-uu-generated-file-list)))
+ (gnus-uu-decode-with-method 'gnus-uu-save-article n nil t))
(defun gnus-uu-decode-binhex (n dir)
"Unbinhexes the current article."
buf subject from)
(setq gnus-uu-digest-from-subject nil)
(gnus-uu-decode-save n file)
- (gnus-uu-add-file file)
(setq buf (switch-to-buffer (get-buffer-create " *gnus-uu-forward*")))
(gnus-add-current-to-buffer-list)
(erase-buffer)
(let ((fs gnus-uu-digest-from-subject))
(if (not fs)
()
- (setq from (car (car fs))
- subject (gnus-simplify-subject-fuzzy (cdr (car fs)))
+ (setq from (caar fs)
+ subject (gnus-simplify-subject-fuzzy (cdar fs))
fs (cdr fs))
(while (and fs (or from subject))
(and from
- (or (string= from (car (car fs)))
+ (or (string= from (caar fs))
(setq from nil)))
(and subject
- (or (string= (gnus-simplify-subject-fuzzy (cdr (car fs)))
+ (or (string= (gnus-simplify-subject-fuzzy (cdar fs))
subject)
(setq subject nil)))
(setq fs (cdr fs))))
(progn
(delete-region (point) (gnus-point-at-eol))
(insert from)))
- (if post
- (gnus-forward-using-post)
- (gnus-mail-forward))
+ (message-forward post)
(delete-file file)
(kill-buffer buf)
(setq gnus-uu-digest-from-subject nil)))
(setq gnus-newsgroup-processable nil)
(save-excursion
(while marked
- (and (setq headers (gnus-summary-article-header (car marked)))
+ (and (vectorp (setq headers
+ (gnus-summary-article-header (car marked))))
(setq subject (mail-header-subject headers)
articles (gnus-uu-find-articles-matching
(gnus-uu-reginize-string subject))
(let ((data gnus-newsgroup-data)
number)
(while data
- (unless (memq (setq number (gnus-data-number (car data)))
- gnus-newsgroup-processable)
+ (when (and (not (memq (setq number (gnus-data-number (car data)))
+ gnus-newsgroup-processable))
+ (vectorp (gnus-data-header (car data))))
(gnus-summary-goto-subject number)
(gnus-uu-mark-series))
(setq data (cdr data)))))
(read-file-name "Save in dir: "
gnus-uu-default-dir
gnus-uu-default-dir t))))
- (gnus-uu-decode-with-method 'gnus-uu-decode-postscript-article n dir))
-
+ (gnus-uu-decode-with-method 'gnus-uu-decode-postscript-article
+ n dir nil nil t))
(defun gnus-uu-decode-postscript-and-save-view (n dir)
"Decodes, views and saves the resulting file."
;; Internal functions.
-(defun gnus-uu-decode-with-method (method n &optional save not-insert scan)
+(defun gnus-uu-decode-with-method (method n &optional save not-insert
+ scan cdir)
(gnus-uu-initialize scan)
(if save (setq gnus-uu-default-dir save))
+ ;; Create the directory we save to.
+ (when (and scan cdir save
+ (not (file-exists-p save)))
+ (make-directory save t))
(let ((articles (gnus-uu-get-list-of-articles n))
files)
(setq files (gnus-uu-grab-articles articles method t))
(and save (gnus-uu-save-files files save))
(if (eq gnus-uu-do-not-unpack-archives nil)
(setq files (gnus-uu-unpack-files files)))
- (gnus-uu-add-file (mapcar (lambda (file) (cdr (assq 'name file))) files))
(setq files (nreverse (gnus-uu-get-actions files)))
(or not-insert (not gnus-insert-pseudo-articles)
(gnus-summary-insert-pseudos files save))))
-;; Return a list of files in dir.
-(defun gnus-uu-scan-directory (dir)
+(defun gnus-uu-scan-directory (dir &optional rec)
+ "Return a list of all files under DIR."
(let ((files (directory-files dir t))
- dirs out)
- (while files
- (cond ((string-match "/\\.\\.?$" (car files)))
- ((file-directory-p (car files))
- (setq dirs (cons (car files) dirs)))
- (t (setq out (cons (list (cons 'name (car files))
- (cons 'article gnus-current-article))
- out))))
- (setq files (cdr files)))
- (apply 'nconc out (mapcar (lambda (d) (gnus-uu-scan-directory d))
- dirs))))
+ out file)
+ (while (setq file (pop files))
+ (unless (string-match "/\\.\\.?$" file)
+ (push (list (cons 'name file)
+ (cons 'article gnus-current-article))
+ out)
+ (when (file-directory-p file)
+ (setq out (nconc (gnus-uu-scan-directory file t) out)))))
+ (if rec
+ out
+ (nreverse out))))
(defun gnus-uu-save-files (files dir)
+ "Save FILES in DIR."
(let ((len (length files))
- to-file file)
- (while files
- (and
- (setq file (cdr (assq 'name (car files))))
- (file-exists-p file)
- (progn
- (setq to-file (if (file-directory-p dir)
- (concat dir (file-name-nondirectory file))
- dir))
- (and (or (not (file-exists-p to-file))
- (gnus-y-or-n-p (format "%s exists; overwrite? "
- to-file)))
- (copy-file file to-file t t))))
- (setq files (cdr files)))
- (message "Saved %d file%s" len (if (> len 1) "s" ""))))
+ (reg (concat "^" (regexp-quote gnus-uu-work-dir)))
+ to-file file fromdir)
+ (while (setq file (cdr (assq 'name (pop files))))
+ (when (file-exists-p file)
+ (string-match reg file)
+ (setq fromdir (substring file (match-end 0)))
+ (if (file-directory-p file)
+ (unless (file-exists-p (concat dir fromdir))
+ (make-directory (concat dir fromdir) t))
+ (setq to-file (concat dir fromdir))
+ (when (or (not (file-exists-p to-file))
+ (gnus-y-or-n-p (format "%s exists; overwrite? " to-file)))
+ (copy-file file to-file t t)))))
+ (gnus-message 5 "Saved %d file%s" len (if (= len 1) "" "s"))))
;; Functions for saving and possibly digesting articles without
;; any decoding.
(save-restriction
(set-buffer buffer)
(let (buffer-read-only)
- (set-text-properties (point-min) (point-max) nil)
+ (gnus-set-text-properties (point-min) (point-max) nil)
;; These two are necessary for XEmacs 19.12 fascism.
(put-text-property (point-min) (point-max) 'invisible nil)
(put-text-property (point-min) (point-max) 'intangible nil))
(setq headline (car headers))
(setq headers (cdr headers))
(goto-char (point-min))
- (if (re-search-forward headline nil t)
- (setq sorthead
- (concat sorthead
- (buffer-substring
- (match-beginning 0)
- (or (and (re-search-forward "^[^ \t]" nil t)
- (1- (point)))
- (progn (forward-line 1) (point)))))))))
+ (while (re-search-forward headline nil t)
+ (setq sorthead
+ (concat sorthead
+ (buffer-substring
+ (match-beginning 0)
+ (or (and (re-search-forward "^[^ \t]" nil t)
+ (1- (point)))
+ (progn (forward-line 1) (point)))))))))
(widen)))
(insert sorthead) (goto-char (point-max))
(insert body) (goto-char (point-max))
(setcar files (nconc (list (if (string= action "gnus-uu-archive")
(cons 'action "file")
(cons 'action action))
- (cons 'execute (if (string-match "%" action)
- (format action name)
- (concat action " " name))))
+ (cons 'execute (gnus-uu-command
+ action name)))
(car files))))
(setq files (cdr files)))
ofiles))
(buffer-disable-undo (current-buffer))
(while string-list
(erase-buffer)
- (insert (car (car string-list)))
+ (insert (caar string-list))
;; Translate multiple spaces to one space.
(goto-char (point-min))
(while (re-search-forward "[ \t]+" nil t)
(articles process-function &optional sloppy limit no-errors)
(let ((state 'first)
has-been-begin article result-file result-files process-state
- article-series)
+ gnus-summary-display-article-function
+ article-series files)
(while (and articles
(not (memq 'error process-state))
(setq state 'last)))
(let ((part (gnus-uu-part-number article)))
- (message "Getting article %d%s..."
- article (if (string= part "") "" (concat ", " part))))
+ (gnus-message 6 "Getting article %d%s..."
+ article (if (string= part "") "" (concat ", " part))))
(gnus-summary-display-article article)
;; Push the article to the processing function.
(when (memq 'end process-state)
(setq article-series nil)
(setq has-been-begin nil)
- (push (list (cons 'name result-file)
- (cons 'article article))
- result-files)
+ (if (stringp result-file)
+ (setq files (list result-file))
+ (setq files result-file))
+ (setq result-file (car files))
+ (while files
+ (push (list (cons 'name (pop files))
+ (cons 'article article))
+ result-files))
;; Allow user-defined functions to be run on this file.
(when gnus-uu-grabbed-file-functions
(let ((funcs gnus-uu-grabbed-file-functions))
(memq 'middle process-state)))
(progn
(setq process-state (list 'error))
- (message "No begin part at the beginning")
+ (gnus-message 2 "No begin part at the beginning")
(sleep-for 2))
(setq state 'middle)))
;; When there are no result-files, then something must be wrong.
- (unless result-files
+ (if result-files
+ (message "")
(cond
((not has-been-begin)
- (message "Wrong type file"))
+ (gnus-message 2 "Wrong type file"))
((memq 'error process-state)
- (message "An error occurred during decoding"))
+ (gnus-message 2 "An error occurred during decoding"))
((not (or (memq 'ok process-state)
(memq 'end process-state)))
- (message "End of articles reached before end of file")))
+ (gnus-message 2 "End of articles reached before end of file")))
;; Make unsuccessfully decoded articles unread.
(when gnus-uu-unmark-articles-not-decoded
(while article-series
(make-symbolic-link to-file file)))))
(defun gnus-uu-part-number (article)
- (let ((subject (mail-header-subject (gnus-summary-article-header article))))
- (if (string-match "[0-9]+ */[0-9]+\\|[0-9]+ * of *[0-9]+"
- subject)
- (substring subject (match-beginning 0) (match-end 0))
+ (let* ((header (gnus-summary-article-header article))
+ (subject (and header (mail-header-subject header))))
+ (if (and subject
+ (string-match "[0-9]+ */[0-9]+\\|[0-9]+ * of *[0-9]+" subject))
+ (match-string 0 subject)
"")))
(defun gnus-uu-uudecode-sentinel (process event)
(defun gnus-uu-uustrip-article (process-buffer in-state)
;; Uudecodes a file asynchronously.
- (let ((state (list 'ok))
- (process-connection-type nil)
- start-char pst name-beg name-end)
- (save-excursion
- (set-buffer process-buffer)
- (let ((case-fold-search nil)
- (buffer-read-only nil))
+ (save-excursion
+ (set-buffer process-buffer)
+ (let ((state (list 'wrong-type))
+ process-connection-type case-fold-search buffer-read-only
+ files start-char)
+ (goto-char (point-min))
- (goto-char (point-min))
+ ;; Deal with ^M at the end of the lines.
+ (when gnus-uu-kill-carriage-return
+ (save-excursion
+ (while (search-forward "\r" nil t)
+ (delete-backward-char 1))))
- (if gnus-uu-kill-carriage-return
- (progn
- (while (search-forward "\r" nil t)
- (delete-backward-char 1))
- (goto-char (point-min))))
-
- (if (not (re-search-forward gnus-uu-begin-string nil t))
- (if (not (re-search-forward gnus-uu-body-line nil t))
- (setq state (list 'wrong-type))))
-
- (if (memq 'wrong-type state)
- ()
- (beginning-of-line)
- (setq start-char (point))
-
- (if (looking-at gnus-uu-begin-string)
- (progn
- (setq name-end (match-end 1)
- name-beg (match-beginning 1))
- ;; Remove any non gnus-uu-body-line right after start.
- (forward-line 1)
- (or (looking-at gnus-uu-body-line)
- (gnus-delete-line))
-
- ; Replace any slashes and spaces in file names before decoding
- (goto-char name-beg)
- (while (re-search-forward "/" name-end t)
- (replace-match ","))
- (goto-char name-beg)
- (while (re-search-forward " " name-end t)
- (replace-match "_"))
- (goto-char name-beg)
- (if (re-search-forward "_*$" name-end t)
- (replace-match ""))
-
- (setq gnus-uu-file-name (buffer-substring name-beg name-end))
- (and gnus-uu-uudecode-process
- (setq pst (process-status
- (or gnus-uu-uudecode-process "nevair")))
- (if (or (eq pst 'stop) (eq pst 'run))
- (progn
- (delete-process gnus-uu-uudecode-process)
- (gnus-uu-unmark-list-of-grabbed t))))
- (if (get-process "*uudecode*")
- (delete-process "*uudecode*"))
- (setq gnus-uu-uudecode-process
- (start-process
- "*uudecode*"
- (get-buffer-create gnus-uu-output-buffer-name)
- "sh" "-c"
- (format "cd %s ; uudecode" gnus-uu-work-dir)))
- (set-process-sentinel
- gnus-uu-uudecode-process 'gnus-uu-uudecode-sentinel)
- (setq state (list 'begin))
- (gnus-uu-add-file (concat gnus-uu-work-dir gnus-uu-file-name)))
- (setq state (list 'middle)))
-
- (goto-char (point-max))
+ (while (or (re-search-forward gnus-uu-begin-string nil t)
+ (re-search-forward gnus-uu-body-line nil t))
+ (setq state (list 'ok))
+ ;; Ok, we are at the first uucoded line.
+ (beginning-of-line)
+ (setq start-char (point))
- (re-search-backward
- (concat gnus-uu-body-line "\\|" gnus-uu-end-string) nil t)
- (beginning-of-line)
+ (if (not (looking-at gnus-uu-begin-string))
+ (setq state (list 'middle))
+ ;; This is the beginning of an uuencoded article.
+ ;; We replace certain characters that could make things messy.
+ (setq gnus-uu-file-name
+ (let ((nnheader-file-name-translation-alist
+ '((?/ . ?,) (? . ?_) (?* . ?_) (?$ . ?_))))
+ (nnheader-translate-file-chars (match-string 1))))
- (if (looking-at gnus-uu-end-string)
- (setq state (cons 'end state)))
+ ;; Remove any non gnus-uu-body-line right after start.
(forward-line 1)
+ (while (and (not (eobp))
+ (not (looking-at gnus-uu-body-line)))
+ (gnus-delete-line))
+
+ ;; If a process is running, we kill it.
+ (when (and gnus-uu-uudecode-process
+ (memq (process-status gnus-uu-uudecode-process)
+ '(run stop)))
+ (delete-process gnus-uu-uudecode-process)
+ (gnus-uu-unmark-list-of-grabbed t))
+
+ ;; Start a new uudecoding process.
+ (setq gnus-uu-uudecode-process
+ (start-process
+ "*uudecode*"
+ (get-buffer-create gnus-uu-output-buffer-name)
+ "sh" "-c"
+ (format "cd %s ; uudecode" gnus-uu-work-dir)))
+ (set-process-sentinel
+ gnus-uu-uudecode-process 'gnus-uu-uudecode-sentinel)
+ (setq state (list 'begin))
+ (push (concat gnus-uu-work-dir gnus-uu-file-name) files))
+
+ ;; We look for the end of the thing to be decoded.
+ (if (re-search-forward gnus-uu-end-string nil t)
+ (setq state (cons 'end state))
+ (goto-char (point-max))
+ (re-search-backward gnus-uu-body-line nil t))
+
+ (forward-line 1)
- (and gnus-uu-uudecode-process
- (setq pst (process-status
- (or gnus-uu-uudecode-process "nevair")))
- (if (or (eq pst 'run) (eq pst 'stop))
- (progn
- (if gnus-uu-correct-stripped-uucode
- (progn
- (gnus-uu-check-correct-stripped-uucode
- start-char (point))
- (goto-char (point-max))
- (re-search-backward
- (concat gnus-uu-body-line "\\|"
- gnus-uu-end-string)
- nil t)
- (forward-line 1)))
-
- (condition-case nil
- (process-send-region gnus-uu-uudecode-process
- start-char (point))
- (error
- (progn
- (delete-process gnus-uu-uudecode-process)
- (message "gnus-uu: Couldn't uudecode")
- ; (sleep-for 2)
- (setq state (list 'wrong-type)))))
-
- (if (memq 'end state)
- (accept-process-output gnus-uu-uudecode-process)))
- (setq state (list 'wrong-type))))
- (if (not gnus-uu-uudecode-process)
- (setq state (list 'wrong-type)))))
+ (when gnus-uu-uudecode-process
+ (when (memq (process-status gnus-uu-uudecode-process) '(run stop))
+ ;; Try to correct mishandled uucode.
+ (when gnus-uu-correct-stripped-uucode
+ (gnus-uu-check-correct-stripped-uucode start-char (point)))
+
+ ;; Send the text to the process.
+ (condition-case nil
+ (process-send-region
+ gnus-uu-uudecode-process start-char (point))
+ (error
+ (progn
+ (delete-process gnus-uu-uudecode-process)
+ (gnus-message 2 "gnus-uu: Couldn't uudecode")
+ (setq state (list 'wrong-type)))))
+
+ (if (memq 'end state)
+ (progn
+ ;; Send an EOF, just in case.
+ (condition-case ()
+ (process-send-eof gnus-uu-uudecode-process)
+ (error nil))
+ (while (memq (process-status gnus-uu-uudecode-process)
+ '(open run))
+ (accept-process-output gnus-uu-uudecode-process 1)))
+ (when (or (not gnus-uu-uudecode-process)
+ (not (memq (process-status gnus-uu-uudecode-process)
+ '(run stop))))
+ (setq state (list 'wrong-type)))))))
(if (memq 'begin state)
- (cons (concat gnus-uu-work-dir gnus-uu-file-name) state)
+ (cons (if (= (length files) 1) (car files) files) state)
state))))
;; This function is used by `gnus-uu-grab-articles' to treat
(setq rule (car action-list))
(setq action-list (cdr action-list))
(if (string-match (car rule) file-name)
- (setq action (car (cdr rule))))))
+ (setq action (cadr rule)))))
action))
(defun gnus-uu-treat-archive (file-path)
(set-buffer (get-buffer-create gnus-uu-output-buffer-name))
(erase-buffer))
- (message "Unpacking: %s..." (gnus-uu-command action file-path))
+ (gnus-message 5 "Unpacking: %s..." (gnus-uu-command action file-path))
(if (= 0 (call-process "sh" nil
(get-buffer-create gnus-uu-output-buffer-name)
nil "-c" command))
(message "")
- (message "Error during unpacking of archive")
+ (gnus-message 2 "Error during unpacking of archive")
(setq did-unpack nil))
(if (member action gnus-uu-destructive-archivers)
;; Go through FILES and look for files to unpack.
(let* ((totfiles (gnus-uu-ls-r gnus-uu-work-dir))
(ofiles files)
- file did-unpack file-entry)
- (gnus-uu-add-file totfiles)
+ file did-unpack)
(while files
- (setq file (cdr (setq file-entry (assq 'name (car files)))))
+ (setq file (cdr (assq 'name (car files))))
(if (and (not (member file ignore))
(equal (gnus-uu-get-action (file-name-nondirectory file))
"gnus-uu-archive"))
(progn
(setq did-unpack (cons file did-unpack))
(or (gnus-uu-treat-archive file)
- (message "Error during unpacking of %s" file))
+ (gnus-message 2 "Error during unpacking of %s" file))
(let* ((newfiles (gnus-uu-ls-r gnus-uu-work-dir))
(nfiles newfiles))
- (gnus-uu-add-file newfiles)
(while nfiles
(or (member (car nfiles) totfiles)
(setq ofiles (cons (list (cons 'name (car nfiles))
out))
(defun gnus-uu-check-correct-stripped-uucode (start end)
- (let (found beg length)
- (if (not gnus-uu-correct-stripped-uucode)
- ()
- (goto-char start)
+ (save-excursion
+ (let (found beg length)
+ (if (not gnus-uu-correct-stripped-uucode)
+ ()
+ (goto-char start)
- (if (re-search-forward " \\|`" end t)
- (progn
- (goto-char start)
- (while (not (eobp))
- (progn
- (if (looking-at "\n") (replace-match ""))
- (forward-line 1))))
-
- (while (not (eobp))
- (if (looking-at (concat gnus-uu-begin-string "\\|"
- gnus-uu-end-string))
- ()
- (if (not found)
+ (if (re-search-forward " \\|`" end t)
+ (progn
+ (goto-char start)
+ (while (not (eobp))
(progn
- (beginning-of-line)
- (setq beg (point))
- (end-of-line)
- (setq length (- (point) beg))))
- (setq found t)
- (beginning-of-line)
- (setq beg (point))
- (end-of-line)
- (if (not (= length (- (point) beg)))
- (insert (make-string (- length (- (point) beg)) ? ))))
- (forward-line 1))))))
+ (if (looking-at "\n") (replace-match ""))
+ (forward-line 1))))
+
+ (while (not (eobp))
+ (if (looking-at (concat gnus-uu-begin-string "\\|"
+ gnus-uu-end-string))
+ ()
+ (if (not found)
+ (progn
+ (beginning-of-line)
+ (setq beg (point))
+ (end-of-line)
+ (setq length (- (point) beg))))
+ (setq found t)
+ (beginning-of-line)
+ (setq beg (point))
+ (end-of-line)
+ (if (not (= length (- (point) beg)))
+ (insert (make-string (- length (- (point) beg)) ? ))))
+ (forward-line 1)))))))
(defvar gnus-uu-tmp-alist nil)
(setq gnus-uu-work-dir
(make-temp-name (concat gnus-uu-tmp-dir "gnus")))
- (gnus-uu-add-file gnus-uu-work-dir)
(if (not (file-directory-p gnus-uu-work-dir))
(gnus-make-directory gnus-uu-work-dir))
(set-file-modes gnus-uu-work-dir 448)
(defun gnus-uu-clean-up ()
(let (buf pst)
(and gnus-uu-uudecode-process
- (setq pst (process-status (or gnus-uu-uudecode-process "nevair")))
- (if (or (eq pst 'stop) (eq pst 'run))
- (delete-process gnus-uu-uudecode-process)))
+ (memq (process-status (or gnus-uu-uudecode-process "nevair"))
+ '(stop run))
+ (delete-process gnus-uu-uudecode-process))
(and (setq buf (get-buffer gnus-uu-output-buffer-name))
(kill-buffer buf))))
-;; `gnus-uu-check-for-generated-files' deletes any generated files that
-;; hasn't been deleted, if, for instance, the user terminated decoding
-;; with `C-g'.
-(defun gnus-uu-check-for-generated-files ()
- (let (file dirs)
- (while gnus-uu-generated-file-list
- (setq file (car gnus-uu-generated-file-list))
- (setq gnus-uu-generated-file-list (cdr gnus-uu-generated-file-list))
- (if (not (string-match "/\\.[\\.]?$" file))
- (progn
- (if (file-directory-p file)
- (setq dirs (cons file dirs))
- (if (file-exists-p file)
- (delete-file file))))))
- (setq dirs (nreverse dirs))
- (while dirs
- (setq file (car dirs))
- (setq dirs (cdr dirs))
- (if (file-directory-p file)
- (if (string-match "/$" file)
- (delete-directory (substring file 0 (match-beginning 0)))
- (delete-directory file))))))
-
-;; Add a file (or a list of files) to be checked (and deleted if it/they
-;; still exists upon exiting the newsgroup).
-(defun gnus-uu-add-file (file)
- (if (stringp file)
- (setq gnus-uu-generated-file-list
- (cons file gnus-uu-generated-file-list))
- (setq gnus-uu-generated-file-list
- (append file gnus-uu-generated-file-list))))
-
;; Inputs an action and a file and returns a full command, putting
;; quotes round the file name and escaping any quotes in the file name.
(defun gnus-uu-command (action file)
(format action ofile)
(concat action " " ofile))))
+(defun gnus-uu-delete-work-dir (&optional dir)
+ "Delete recursively all files and directories under `gnus-uu-work-dir'."
+ (if dir
+ (gnus-message 7 "Deleting directory %s..." dir)
+ (setq dir gnus-uu-work-dir))
+ (when (and dir
+ (file-exists-p dir))
+ (let ((files (directory-files dir t nil t))
+ file)
+ (while (setq file (pop files))
+ (unless (string-match "/\\.\\.?$" file)
+ (if (file-directory-p file)
+ (gnus-uu-delete-work-dir file)
+ (gnus-message 9 "Deleting file %s..." file)
+ (delete-file file))))
+ (delete-directory dir)))
+ (gnus-message 7 ""))
;; Initializing
(add-hook 'gnus-exit-group-hook 'gnus-uu-clean-up)
-(add-hook 'gnus-exit-group-hook 'gnus-uu-check-for-generated-files)
+(add-hook 'gnus-exit-group-hook 'gnus-uu-delete-work-dir)
\f
"Inserts an encoded file in the buffer.
The user will be asked for a file name."
(interactive)
- (if (not (eq (current-buffer) (get-buffer gnus-post-news-buffer)))
- (error "Not in post-news buffer"))
(save-excursion
(setq gnus-uu-post-inserted-file-name (gnus-uu-post-insert-binary))))
file-name))
(insert (format "Content-Transfer-Encoding: %s\n\n" encoding))
(save-restriction
- (set-buffer gnus-post-news-buffer)
+ (set-buffer gnus-message-buffer)
(goto-char (point-min))
(re-search-forward (concat "^" (regexp-quote mail-header-separator) "$"))
(forward-line -1)
"Posts the composed news article and encoded file.
If no file has been included, the user will be asked for a file."
(interactive)
- (if (not (eq (current-buffer) (get-buffer gnus-post-news-buffer)))
- (error "Not in post news buffer"))
(let (file-name)
(setq file-name (gnus-uu-post-insert-binary)))
(if gnus-uu-post-threaded
- (let ((gnus-required-headers
- (if (memq 'Message-ID gnus-required-headers)
- gnus-required-headers
- (cons 'Message-ID gnus-required-headers)))
+ (let ((message-required-news-headers
+ (if (memq 'Message-ID message-required-news-headers)
+ message-required-news-headers
+ (cons 'Message-ID message-required-news-headers)))
gnus-inews-article-hook)
(setq gnus-inews-article-hook (if (listp gnus-inews-article-hook)
(progn
(end-of-line)
(insert (format " (0/%d)" parts))))
- (gnus-inews-news))
+ (message-send))
(save-excursion
(setq i 1)
(forward-line 1)))
(insert beg-line)
(insert "\n")
- (gnus-inews-news)))
+ (let (message-sent-message-via)
+ (message-send))))
(and (setq buf (get-buffer send-buffer-name))
(kill-buffer buf))