;;; gnus-uu.el --- extract (uu)encoded files in Gnus
-;; Copyright (C) 1985,86,87,93,94,95 Free Software Foundation, Inc.
+;; Copyright (C) 1985,86,87,93,94,95,96 Free Software Foundation, Inc.
;; Author: Lars Magne Ingebrigtsen <larsi@ifi.uio.no>
;; Created: 2 Oct 1993
-;; Version: v3.0
;; Keyword: news
;; This file is part of GNU Emacs.
;; 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:
(require 'gnus)
(require 'gnus-msg)
+(eval-when-compile (require 'cl))
;; Default viewing action rules
("\\.\\(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")
Default is \"/tmp/\".")
(defvar gnus-uu-do-not-unpack-archives nil
- "*Non-nil means that gnus-uu won't peek inside archives looking for files to dispay.
+ "*Non-nil means that gnus-uu won't peek inside archives looking for files to display.
Default is nil.")
(defvar gnus-uu-view-and-save nil
"*Non-nil means that gnus-uu will ignore the default viewing rules.
Only the user viewing rules will be consulted. Default is nil.")
+(defvar gnus-uu-grabbed-file-functions nil
+ "*Functions run on each file after successful decoding.
+They will be called with the name of the file as the argument.
+Likely functions you can use in this list are `gnus-uu-grab-view'
+and `gnus-uu-grab-move'.")
+
(defvar gnus-uu-ignore-default-archive-rules nil
"*Non-nil means that gnus-uu will ignore the default archive unpacking commands.
Only the user unpacking commands will be consulted. Default is nil.")
(defvar gnus-uu-file-name nil)
(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*")
+(defconst gnus-uu-output-buffer-name " *Gnus UU Output*")
-(defconst gnus-uu-highest-article-number 1)
-(defvar gnus-uu-default-dir default-directory)
+(defvar gnus-uu-default-dir gnus-article-save-directory)
+(defvar gnus-uu-digest-from-subject nil)
;; Keymaps
-(defvar gnus-uu-extract-map nil)
-(defvar gnus-uu-extract-view-map nil)
-(defvar gnus-uu-mark-map nil)
-
-(define-prefix-command 'gnus-uu-mark-map)
-(define-key gnus-summary-mark-map "p" 'gnus-uu-mark-map)
-(define-key gnus-uu-mark-map "p" 'gnus-summary-mark-as-processable)
-(define-key gnus-uu-mark-map "u" 'gnus-summary-unmark-as-processable)
-(define-key gnus-uu-mark-map "U" 'gnus-summary-unmark-all-processable)
-(define-key gnus-uu-mark-map "s" 'gnus-uu-mark-series)
-(define-key gnus-uu-mark-map "r" 'gnus-uu-mark-region)
-(define-key gnus-uu-mark-map "R" 'gnus-uu-mark-by-regexp)
-(define-key gnus-uu-mark-map "t" 'gnus-uu-mark-thread)
-(define-key gnus-uu-mark-map "a" 'gnus-uu-mark-all)
-(define-key gnus-uu-mark-map "S" 'gnus-uu-mark-sparse)
-
-(define-prefix-command 'gnus-uu-extract-map)
-(define-key gnus-summary-mode-map "X" 'gnus-uu-extract-map)
-;;(define-key gnus-uu-extract-map "x" 'gnus-uu-extract-any)
-;;(define-key gnus-uu-extract-map "m" 'gnus-uu-extract-mime)
-(define-key gnus-uu-extract-map "u" 'gnus-uu-decode-uu)
-(define-key gnus-uu-extract-map "U" 'gnus-uu-decode-uu-and-save)
-(define-key gnus-uu-extract-map "s" 'gnus-uu-decode-unshar)
-(define-key gnus-uu-extract-map "S" 'gnus-uu-decode-unshar-and-save)
-(define-key gnus-uu-extract-map "o" 'gnus-uu-decode-save)
-(define-key gnus-uu-extract-map "O" 'gnus-uu-decode-save)
-(define-key gnus-uu-extract-map "b" 'gnus-uu-decode-binhex)
-(define-key gnus-uu-extract-map "B" 'gnus-uu-decode-binhex)
-(define-key gnus-uu-extract-map "p" 'gnus-uu-decode-postscript)
-(define-key gnus-uu-extract-map "P" 'gnus-uu-decode-postscript-and-save)
-
-(define-prefix-command 'gnus-uu-extract-view-map)
-(define-key gnus-uu-extract-map "v" 'gnus-uu-extract-view-map)
-(define-key gnus-uu-extract-view-map "u" 'gnus-uu-decode-uu-view)
-(define-key gnus-uu-extract-view-map "U" 'gnus-uu-decode-uu-and-save-view)
-(define-key gnus-uu-extract-view-map "s" 'gnus-uu-decode-unshar-view)
-(define-key gnus-uu-extract-view-map "S" 'gnus-uu-decode-unshar-and-save-view)
-(define-key gnus-uu-extract-view-map "o" 'gnus-uu-decode-save-view)
-(define-key gnus-uu-extract-view-map "O" 'gnus-uu-decode-save-view)
-(define-key gnus-uu-extract-view-map "b" 'gnus-uu-decode-binhex-view)
-(define-key gnus-uu-extract-view-map "B" 'gnus-uu-decode-binhex-view)
-(define-key gnus-uu-extract-view-map "p" 'gnus-uu-decode-postscript-view)
-(define-key gnus-uu-extract-view-map "P" 'gnus-uu-decode-postscript-and-save-view)
-
+(gnus-define-keys
+ (gnus-uu-mark-map "P" gnus-summary-mark-map)
+ "p" gnus-summary-mark-as-processable
+ "u" gnus-summary-unmark-as-processable
+ "U" gnus-summary-unmark-all-processable
+ "v" gnus-uu-mark-over
+ "s" gnus-uu-mark-series
+ "r" gnus-uu-mark-region
+ "R" gnus-uu-mark-by-regexp
+ "t" gnus-uu-mark-thread
+ "T" gnus-uu-unmark-thread
+ "a" gnus-uu-mark-all
+ "b" gnus-uu-mark-buffer
+ "S" gnus-uu-mark-sparse)
+
+(gnus-define-keys
+ (gnus-uu-extract-map "X" gnus-summary-mode-map)
+ ;;"x" gnus-uu-extract-any
+ ;;"m" gnus-uu-extract-mime
+ "u" gnus-uu-decode-uu
+ "U" gnus-uu-decode-uu-and-save
+ "s" gnus-uu-decode-unshar
+ "S" gnus-uu-decode-unshar-and-save
+ "o" gnus-uu-decode-save
+ "O" gnus-uu-decode-save
+ "b" gnus-uu-decode-binhex
+ "B" gnus-uu-decode-binhex
+ "p" gnus-uu-decode-postscript
+ "P" gnus-uu-decode-postscript-and-save)
+
+(gnus-define-keys
+ (gnus-uu-extract-view-map "v" gnus-uu-extract-map)
+ "u" gnus-uu-decode-uu-view
+ "U" gnus-uu-decode-uu-and-save-view
+ "s" gnus-uu-decode-unshar-view
+ "S" gnus-uu-decode-unshar-and-save-view
+ "o" gnus-uu-decode-save-view
+ "O" gnus-uu-decode-save-view
+ "b" gnus-uu-decode-binhex-view
+ "B" gnus-uu-decode-binhex-view
+ "p" gnus-uu-decode-postscript-view
+ "P" gnus-uu-decode-postscript-and-save-view)
;; Commands.
(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."
(file-name-as-directory
(read-file-name "Unbinhex and save in dir: "
gnus-uu-default-dir
- gnus-uu-default-dir t))))
+ gnus-uu-default-dir))))
+ (setq gnus-uu-binhex-article-name
+ (make-temp-name (concat gnus-uu-work-dir "binhex")))
(gnus-uu-decode-with-method 'gnus-uu-binhex-article n dir))
(defun gnus-uu-decode-uu-view (n)
(list current-prefix-arg
(read-file-name "Unbinhex, view and save in dir: "
gnus-uu-default-dir gnus-uu-default-dir)))
+ (setq gnus-uu-binhex-article-name
+ (make-temp-name (concat gnus-uu-work-dir "binhex")))
(let ((gnus-view-pseudos (or gnus-view-pseudos 'automatic)))
(gnus-uu-decode-binhex n file)))
(interactive "P")
(let ((gnus-uu-save-in-digest t)
(file (make-temp-name (concat gnus-uu-tmp-dir "forward")))
- buf)
+ 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*")))
(erase-buffer)
(delete-other-windows)
(insert-file file)
+ (let ((fs gnus-uu-digest-from-subject))
+ (if (not fs)
+ ()
+ (setq from (car (car fs))
+ subject (gnus-simplify-subject-fuzzy (cdr (car fs)))
+ fs (cdr fs))
+ (while (and fs (or from subject))
+ (and from
+ (or (string= from (car (car fs)))
+ (setq from nil)))
+ (and subject
+ (or (string= (gnus-simplify-subject-fuzzy (cdr (car fs)))
+ subject)
+ (setq subject nil)))
+ (setq fs (cdr fs))))
+ (or subject (setq subject "Digested Articles"))
+ (or from (setq from "Various")))
(goto-char (point-min))
(and (re-search-forward "^Subject: ")
(progn
(delete-region (point) (gnus-point-at-eol))
- (insert "Digested Articles")))
+ (insert subject)))
(goto-char (point-min))
(and (re-search-forward "^From: ")
(progn
(delete-region (point) (gnus-point-at-eol))
- (insert "Various")))
+ (insert from)))
(if post
(gnus-forward-using-post)
- (funcall gnus-mail-forward-method))
+ (gnus-mail-forward))
(delete-file file)
- (kill-buffer buf)))
+ (kill-buffer buf)
+ (setq gnus-uu-digest-from-subject nil)))
(defun gnus-uu-digest-post-forward (n)
"Digest and forward to a newsgroup."
;; Process marking.
-(defun gnus-uu-mark-by-regexp (regexp)
+(defun gnus-uu-mark-by-regexp (regexp &optional unmark)
"Ask for a regular expression and set the process mark on all articles that match."
(interactive (list (read-from-minibuffer "Mark (regexp): ")))
(gnus-set-global-variables)
(let ((articles (gnus-uu-find-articles-matching regexp)))
(while articles
- (gnus-summary-set-process-mark (car articles))
- (setq articles (cdr articles)))
+ (if unmark
+ (gnus-summary-remove-process-mark (pop articles))
+ (gnus-summary-set-process-mark (pop articles))))
(message ""))
- (gnus-summary-position-cursor))
+ (gnus-summary-position-point))
+
+(defun gnus-uu-unmark-by-regexp (regexp &optional unmark)
+ "Ask for a regular expression and remove the process mark on all articles that match."
+ (interactive (list (read-from-minibuffer "Mark (regexp): ")))
+ (gnus-uu-mark-by-regexp regexp t))
(defun gnus-uu-mark-series ()
"Mark the current series with the process mark."
(gnus-summary-set-process-mark (car articles))
(setq articles (cdr articles)))
(message ""))
- (gnus-summary-position-cursor))
+ (gnus-summary-position-point))
-(defun gnus-uu-mark-region (beg end)
- "Marks all articles between point and mark."
+(defun gnus-uu-mark-region (beg end &optional unmark)
+ "Set the process mark on all articles between point and mark."
(interactive "r")
(gnus-set-global-variables)
(save-excursion
(goto-char beg)
(while (< (point) end)
- (gnus-summary-set-process-mark (gnus-summary-article-number))
+ (if unmark
+ (gnus-summary-remove-process-mark (gnus-summary-article-number))
+ (gnus-summary-set-process-mark (gnus-summary-article-number)))
(forward-line 1)))
- (gnus-summary-position-cursor))
+ (gnus-summary-position-point))
+
+(defun gnus-uu-unmark-region (beg end)
+ "Remove the process mark from all articles between point and mark."
+ (interactive "r")
+ (gnus-uu-mark-region beg end t))
+
+(defun gnus-uu-mark-buffer ()
+ "Set the process mark on all articles in the buffer."
+ (interactive)
+ (gnus-uu-mark-region (point-min) (point-max)))
+
+(defun gnus-uu-unmark-buffer ()
+ "Remove the process mark on all articles in the buffer."
+ (interactive)
+ (gnus-uu-mark-region (point-min) (point-max) t))
(defun gnus-uu-mark-thread ()
"Marks all articles downwards in this thread."
(interactive)
(gnus-set-global-variables)
- (save-excursion
- (let ((level (gnus-summary-thread-level)))
+ (let ((level (gnus-summary-thread-level)))
(while (and (gnus-summary-set-process-mark (gnus-summary-article-number))
(zerop (gnus-summary-next-subject 1))
- (> (gnus-summary-thread-level) level)))))
- (gnus-summary-position-cursor))
+ (> (gnus-summary-thread-level) level))))
+ (gnus-summary-position-point))
+
+(defun gnus-uu-unmark-thread ()
+ "Unmarks all articles downwards in this thread."
+ (interactive)
+ (gnus-set-global-variables)
+ (let ((level (gnus-summary-thread-level)))
+ (while (and (gnus-summary-remove-process-mark
+ (gnus-summary-article-number))
+ (zerop (gnus-summary-next-subject 1))
+ (> (gnus-summary-thread-level) level))))
+ (gnus-summary-position-point))
+
+(defun gnus-uu-mark-over (score)
+ "Mark all articles with a score over SCORE (the prefix.)"
+ (interactive "P")
+ (let ((score (gnus-score-default score))
+ (data gnus-newsgroup-data))
+ (save-excursion
+ (while data
+ (when (> (or (cdr (assq (gnus-data-number (caar data))
+ gnus-newsgroup-scored))
+ gnus-summary-default-score 0)
+ score)
+ (gnus-summary-set-process-mark (caar data)))
+ (setq data (cdr data))))
+ (gnus-summary-position-point)))
(defun gnus-uu-mark-sparse ()
"Mark all series that have some articles marked."
(setq gnus-newsgroup-processable nil)
(save-excursion
(while marked
- (and (setq headers (gnus-get-header-by-number (car marked)))
- (setq subject (header-subject headers)
+ (and (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))
total (nconc total articles)))
(setq articles (cdr articles)))
(setq marked (cdr marked)))
(setq gnus-newsgroup-processable (nreverse total)))
- (gnus-summary-position-cursor)))
+ (gnus-summary-position-point)))
(defun gnus-uu-mark-all ()
"Mark all articles in \"series\" order."
(gnus-set-global-variables)
(setq gnus-newsgroup-processable nil)
(save-excursion
- (goto-char (point-min))
- (let (number)
- (while (and (not (eobp))
- (setq number (gnus-summary-article-number)))
- (if (not (memq number gnus-newsgroup-processable))
- (save-excursion (gnus-uu-mark-series)))
- (forward-line 1))))
- (gnus-summary-position-cursor))
+ (let ((data gnus-newsgroup-data)
+ number)
+ (while data
+ (unless (memq (setq number (gnus-data-number (car data)))
+ gnus-newsgroup-processable)
+ (gnus-summary-goto-subject number)
+ (gnus-uu-mark-series))
+ (setq data (cdr data)))))
+ (gnus-summary-position-point))
;; All PostScript functions written by Erik Selberg <speed@cs.washington.edu>.
(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)
- (gnus-uu-initialize)
+(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
+ (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))
(let ((gnus-current-article (car articles)))
(and scan (setq files (gnus-uu-scan-directory gnus-uu-work-dir))))
(and save (gnus-uu-save-files files save))
- (setq files (gnus-uu-unpack-files files))
+ (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 (gnus-summary-insert-pseudos files save))))
+ (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
- (setq file (cdr (assq 'name (car files))))
- (and (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 1 t))))
- (setq files (cdr files)))
+ (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)))))
(message "Saved %d file%s" len (if (> len 1) "s" ""))))
;; Functions for saving and possibly digesting articles without
'begin 'end))
((eq in-state 'last) (list 'end))
(t (list 'middle)))))
- (t
- (let ((name (file-name-nondirectory gnus-uu-saved-article-name))
- beg subj headers headline sorthead body end-string state)
- (if (or (eq in-state 'first)
- (eq in-state 'first-and-last))
- (progn
- (setq state (list 'begin))
- (save-excursion (set-buffer (get-buffer-create "*gnus-uu-body*"))
- (erase-buffer))
- (save-excursion
- (set-buffer (get-buffer-create "*gnus-uu-pre*"))
- (erase-buffer)
- (insert (format
- "Date: %s\nFrom: %s\nSubject: %s Digest\n\nTopics:\n"
- (current-time-string) name name))))
- (if (not (eq in-state 'end))
- (setq state (list 'middle))))
- (save-excursion
- (set-buffer (get-buffer "*gnus-uu-body*"))
- (goto-char (setq beg (point-max)))
- (save-excursion
- (save-restriction
- (set-buffer buffer)
- (goto-char (point-min))
- (re-search-forward "\n\n")
- (setq body (buffer-substring (1- (point)) (point-max)))
- (narrow-to-region 1 (point))
- (setq headers gnus-uu-digest-headers)
- (while headers
- (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))))))))
- (widen)))
- (insert sorthead)(goto-char (point-max))
- (insert body)(goto-char (point-max))
- (insert (concat "\n" (make-string 30 ?-) "\n\n"))
- (goto-char beg)
- (if (re-search-forward "^Subject: \\(.*\\)$" nil t)
- (progn
- (setq subj (buffer-substring (match-beginning 1) (match-end 1)))
- (save-excursion
+ (t
+ (let ((header (gnus-summary-article-header)))
+ (setq gnus-uu-digest-from-subject
+ (cons (cons (mail-header-from header)
+ (mail-header-subject header))
+ gnus-uu-digest-from-subject)))
+ (let ((name (file-name-nondirectory gnus-uu-saved-article-name))
+ (delim (concat "^" (make-string 30 ?-) "$"))
+ beg subj headers headline sorthead body end-string state)
+ (if (or (eq in-state 'first)
+ (eq in-state 'first-and-last))
+ (progn
+ (setq state (list 'begin))
+ (save-excursion (set-buffer (get-buffer-create "*gnus-uu-body*"))
+ (erase-buffer))
+ (save-excursion
+ (set-buffer (get-buffer-create "*gnus-uu-pre*"))
+ (erase-buffer)
+ (insert (format
+ "Date: %s\nFrom: %s\nSubject: %s Digest\n\nTopics:\n"
+ (current-time-string) name name))))
+ (if (not (eq in-state 'end))
+ (setq state (list 'middle))))
+ (save-excursion
+ (set-buffer (get-buffer "*gnus-uu-body*"))
+ (goto-char (setq beg (point-max)))
+ (save-excursion
+ (save-restriction
+ (set-buffer buffer)
+ (let (buffer-read-only)
+ (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))
+ (goto-char (point-min))
+ (re-search-forward "\n\n")
+ ;; Quote all 30-dash lines.
+ (save-excursion
+ (while (re-search-forward delim nil t)
+ (beginning-of-line)
+ (delete-char 1)
+ (insert " ")))
+ (setq body (buffer-substring (1- (point)) (point-max)))
+ (narrow-to-region (point-min) (point))
+ (if (not (setq headers gnus-uu-digest-headers))
+ (setq sorthead (buffer-substring (point-min) (point-max)))
+ (while headers
+ (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)))))))))
+ (widen)))
+ (insert sorthead) (goto-char (point-max))
+ (insert body) (goto-char (point-max))
+ (insert (concat "\n" (make-string 30 ?-) "\n\n"))
+ (goto-char beg)
+ (if (re-search-forward "^Subject: \\(.*\\)$" nil t)
+ (progn
+ (setq subj (buffer-substring (match-beginning 1) (match-end 1)))
+ (save-excursion
(set-buffer (get-buffer "*gnus-uu-pre*"))
(insert (format " %s\n" subj))))))
(if (or (eq in-state 'last)
"^:...............................................................$")
(defconst gnus-uu-binhex-end-line
":$")
-(defvar gnus-uu-binhex-article-name nil)
(defun gnus-uu-binhex-article (buffer in-state)
(let (state start-char)
(let ((state (list 'ok))
start-char end-char file-name)
(save-excursion
- (set-buffer process-buffer)
- (goto-char (point-min))
- (if (not (re-search-forward gnus-uu-postscript-begin-string nil t))
- (setq state (list 'wrong-type))
- (beginning-of-line)
- (setq start-char (point))
- (if (not (re-search-forward gnus-uu-postscript-end-string nil t))
- (setq state (list 'wrong-type))
- (setq end-char (point))
- (set-buffer (get-buffer-create gnus-uu-output-buffer-name))
- (insert-buffer-substring process-buffer start-char end-char)
- (setq file-name (concat gnus-uu-work-dir (cdr gnus-article-current) ".ps"))
- (write-region (point-min) (point-max) file-name)
- (setq state (list file-name'begin 'end))
-
- ))
- )
+ (set-buffer process-buffer)
+ (goto-char (point-min))
+ (if (not (re-search-forward gnus-uu-postscript-begin-string nil t))
+ (setq state (list 'wrong-type))
+ (beginning-of-line)
+ (setq start-char (point))
+ (if (not (re-search-forward gnus-uu-postscript-end-string nil t))
+ (setq state (list 'wrong-type))
+ (setq end-char (point))
+ (set-buffer (get-buffer-create gnus-uu-output-buffer-name))
+ (insert-buffer-substring process-buffer start-char end-char)
+ (setq file-name (concat gnus-uu-work-dir
+ (cdr gnus-article-current) ".ps"))
+ (write-region (point-min) (point-max) file-name)
+ (setq state (list file-name 'begin 'end)))))
state))
(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))
;; Failing that, articles that have subjects that are part of the
;; same "series" as the current will be returned.
(let (articles)
- (cond
- (n
- (let ((backward (< n 0))
- (n (abs n)))
- (save-excursion
- (while (and (> n 0)
- (setq articles (cons (gnus-summary-article-number)
- articles))
- (gnus-summary-search-forward nil nil backward))
- (setq n (1- n))))
- (nreverse articles)))
- (gnus-newsgroup-processable
- (reverse gnus-newsgroup-processable))
- (t
- (gnus-uu-find-articles-matching)))))
+ (cond
+ (n
+ (let ((backward (< n 0))
+ (n (abs n)))
+ (save-excursion
+ (while (and (> n 0)
+ (setq articles (cons (gnus-summary-article-number)
+ articles))
+ (gnus-summary-search-forward nil nil backward))
+ (setq n (1- n))))
+ (nreverse articles)))
+ (gnus-newsgroup-processable
+ (reverse gnus-newsgroup-processable))
+ (t
+ (gnus-uu-find-articles-matching)))))
(defun gnus-uu-string< (l1 l2)
(string< (car l1) (car l2)))
;; non-nil, only unread articles are chosen. If DO-NOT-TRANSLATE is
;; non-nil, article names are not equalized before sorting.
(let ((subject (or subject
- (gnus-uu-reginize-string (gnus-summary-subject-string))))
+ (gnus-uu-reginize-string (gnus-summary-article-subject))))
list-of-subjects)
(save-excursion
(if (not subject)
()
;; Collect all subjects matching subject.
(let ((case-fold-search t)
- subj mark)
- (goto-char (point-min))
- (while (not (eobp))
- (and (setq subj (gnus-summary-subject-string))
- (string-match subject subj)
+ (data gnus-newsgroup-data)
+ subj mark d)
+ (while data
+ (setq d (pop data))
+ (and (not (gnus-data-pseudo-p d))
(or (not only-unread)
- (= (setq mark (gnus-summary-article-mark))
+ (= (setq mark (gnus-data-mark d))
gnus-unread-mark)
(= mark gnus-ticked-mark)
(= mark gnus-dormant-mark))
+ (setq subj (mail-header-subject (gnus-data-header d)))
+ (string-match subject subj)
(setq list-of-subjects
- (cons (cons subj (gnus-summary-article-number))
- list-of-subjects)))
- (forward-line 1)))
+ (cons (cons subj (gnus-data-number d))
+ list-of-subjects)))))
;; Expand numbers, sort, and return the list of article
;; numbers.
(defun gnus-uu-grab-articles
(articles process-function &optional sloppy limit no-errors)
(let ((state 'first)
- has-been-begin article result-file result-files process-state
- article-buffer)
+ has-been-begin article result-file result-files process-state
+ article-series)
- (if (not (gnus-server-opened gnus-current-select-method))
- (progn
- (gnus-start-news-server)
- (gnus-request-group gnus-newsgroup-name)))
-
- (setq gnus-uu-has-been-grabbed nil)
-
(while (and articles
(not (memq 'error process-state))
(or sloppy
(not (memq 'end process-state))))
- (setq article (car articles))
- (setq articles (cdr articles))
- (setq gnus-uu-has-been-grabbed (cons article gnus-uu-has-been-grabbed))
-
- (if (> article gnus-uu-highest-article-number)
- (setq gnus-uu-highest-article-number article))
-
- (if (eq articles ())
- (if (eq state 'first)
- (setq state 'first-and-last)
- (setq state 'last)))
+ (setq article (pop articles))
+ (push article article-series)
- (message "Getting article %d, %s" article (gnus-uu-part-number article))
-
- (if (not (= (or gnus-current-article 0) article))
- (progn
- (gnus-request-article article gnus-newsgroup-name
- nntp-server-buffer)
- (setq gnus-last-article gnus-current-article)
- (setq gnus-current-article article)
- (setq gnus-article-current (cons gnus-newsgroup-name article))
- (if (stringp nntp-server-buffer)
- (setq article-buffer nntp-server-buffer)
- (setq article-buffer (buffer-name nntp-server-buffer))))
- (setq article-buffer gnus-article-buffer))
-
- (buffer-disable-undo article-buffer)
- ;; Mark article as read.
- (run-hooks 'gnus-mark-article-hook)
- (and (memq article gnus-newsgroup-processable)
- (gnus-summary-remove-process-mark article))
-
- (setq process-state (funcall process-function article-buffer state))
-
- (if (or (memq 'begin process-state)
- (and (or (eq state 'first) (eq state 'first-and-last))
- (memq 'ok process-state)))
- (progn
- (if has-been-begin
- (if (and result-file (file-exists-p result-file))
- (delete-file result-file)))
- (if (memq 'begin process-state)
- (setq result-file (car process-state)))
- (setq has-been-begin t)))
-
- (if (memq 'end process-state)
- (progn
- (setq gnus-uu-has-been-grabbed nil)
- (setq result-files (cons (list (cons 'name result-file)
- (cons 'article article))
- result-files))
- (setq has-been-begin nil)
- (and limit (= (length result-files) limit)
- (setq articles nil))))
-
- (if (and (or (eq state 'last) (eq state 'first-and-last))
- (not (memq 'end process-state)))
- (if (and result-file (file-exists-p result-file))
- (delete-file result-file)))
-
- (if (not (memq 'wrong-type process-state))
- ()
- (if gnus-uu-unmark-articles-not-decoded
- (gnus-summary-tick-article article t)))
+ (unless articles
+ (if (eq state 'first)
+ (setq state 'first-and-last)
+ (setq state 'last)))
+ (let ((part (gnus-uu-part-number article)))
+ (message "Getting article %d%s..."
+ article (if (string= part "") "" (concat ", " part))))
+ (gnus-summary-display-article article)
+
+ ;; Push the article to the processing function.
+ (save-excursion
+ (set-buffer gnus-original-article-buffer)
+ (let ((buffer-read-only nil))
+ (save-excursion
+ (set-buffer gnus-summary-buffer)
+ (setq process-state
+ (funcall process-function
+ gnus-original-article-buffer state)))))
+
+ (gnus-summary-remove-process-mark article)
+
+ ;; If this is the beginning of a decoded file, we push it
+ ;; on to a list.
+ (when (or (memq 'begin process-state)
+ (and (or (eq state 'first)
+ (eq state 'first-and-last))
+ (memq 'ok process-state)))
+ (if has-been-begin
+ ;; If there is a `result-file' here, that means that the
+ ;; file was unsuccessfully decoded, so we delete it.
+ (when (and result-file
+ (file-exists-p result-file))
+ (delete-file result-file)))
+ (when (memq 'begin process-state)
+ (setq result-file (car process-state)))
+ (setq has-been-begin t))
+
+ ;; Check whether we have decoded one complete file.
+ (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)
+ ;; Allow user-defined functions to be run on this file.
+ (when gnus-uu-grabbed-file-functions
+ (let ((funcs gnus-uu-grabbed-file-functions))
+ (unless (listp funcs)
+ (setq funcs (list funcs)))
+ (while funcs
+ (funcall (pop funcs) result-file))))
+ ;; Check whether we have decoded enough articles.
+ (and limit (= (length result-files) limit)
+ (setq articles nil)))
+
+ ;; If this is the last article to be decoded, and
+ ;; we still haven't reached the end, then we delete
+ ;; the partially decoded file.
+ (and (or (eq state 'last) (eq state 'first-and-last))
+ (not (memq 'end process-state))
+ result-file
+ (file-exists-p result-file)
+ (delete-file result-file))
+
+ ;; If this was a file of the wrong sort, then
+ (when (and (or (memq 'wrong-type process-state)
+ (memq 'error process-state))
+ gnus-uu-unmark-articles-not-decoded)
+ (gnus-summary-tick-article article t))
+
+ ;; Set the new series state.
(if (and (not has-been-begin)
(not sloppy)
(or (memq 'end process-state)
(sleep-for 2))
(setq state 'middle)))
- ;; Make sure the last article is put in the article buffer & fix
- ;; windows etc.
-
- (if (not (string= article-buffer gnus-article-buffer))
- (save-excursion
- (set-buffer (get-buffer-create gnus-article-buffer))
- (let ((buffer-read-only nil))
- (widen)
- (erase-buffer)
- (insert-buffer-substring article-buffer)
- (goto-char (point-min)))))
-
+ ;; When there are no result-files, then something must be wrong.
(if result-files
- ()
- (if (not has-been-begin)
- (if (not no-errors) (message "Wrong type file"))
- (if (memq 'error process-state)
- (setq result-files nil)
- (if (not (or (memq 'ok process-state)
- (memq 'end process-state)))
- (progn
- (if (not no-errors)
- (message "End of articles reached before end of file"))
- (setq result-files nil))
- (gnus-uu-unmark-list-of-grabbed)))))
+ (message "")
+ (cond
+ ((not has-been-begin)
+ (message "Wrong type file"))
+ ((memq 'error process-state)
+ (message "An error occurred during decoding"))
+ ((not (or (memq 'ok process-state)
+ (memq 'end process-state)))
+ (message "End of articles reached before end of file")))
+ ;; Make unsuccessfully decoded articles unread.
+ (when gnus-uu-unmark-articles-not-decoded
+ (while article-series
+ (gnus-summary-tick-article (pop article-series) t))))
+
result-files))
+(defun gnus-uu-grab-view (file)
+ "View FILE using the gnus-uu methods."
+ (let ((action (gnus-uu-get-action file)))
+ (gnus-execute-command
+ (if (string-match "%" action)
+ (format action file)
+ (concat action " " file))
+ (eq gnus-view-pseudos 'not-confirm))))
+
+(defun gnus-uu-grab-move (file)
+ "Move FILE to somewhere."
+ (when gnus-uu-default-dir
+ (let ((to-file (concat (file-name-as-directory gnus-uu-default-dir)
+ (file-name-nondirectory file))))
+ (rename-file file to-file)
+ (unless (file-exists-p file)
+ (make-symbolic-link to-file file)))))
+
(defun gnus-uu-part-number (article)
- (let ((subject (header-subject (gnus-get-header-by-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))
(or (looking-at gnus-uu-body-line)
(gnus-delete-line))
- ; Replace any slashes and spaces in file names before decoding
+ ;; Replace any slashes and spaces in file names before decoding
(goto-char name-beg)
(while (re-search-forward "/" name-end t)
(replace-match ","))
(replace-match "_"))
(goto-char name-beg)
(if (re-search-forward "_*$" name-end t)
- (replace-match ""))
+ (replace-match ""))
(setq gnus-uu-file-name (buffer-substring name-beg name-end))
(and gnus-uu-uudecode-process
(progn
(delete-process gnus-uu-uudecode-process)
(message "gnus-uu: Couldn't uudecode")
-; (sleep-for 2)
+ ; (sleep-for 2)
(setq state (list 'wrong-type)))))
(if (memq 'end state)
(let ((state (list 'ok))
start-char)
(save-excursion
- (set-buffer process-buffer)
- (goto-char (point-min))
- (if (not (re-search-forward gnus-uu-shar-begin-string nil t))
- (setq state (list 'wrong-type))
- (beginning-of-line)
- (setq start-char (point))
- (call-process-region
- start-char (point-max) "sh" nil
- (get-buffer-create gnus-uu-output-buffer-name) nil
- "-c" (concat "cd " gnus-uu-work-dir " ; sh"))))
+ (set-buffer process-buffer)
+ (goto-char (point-min))
+ (if (not (re-search-forward gnus-uu-shar-begin-string nil t))
+ (setq state (list 'wrong-type))
+ (beginning-of-line)
+ (setq start-char (point))
+ (call-process-region
+ start-char (point-max) "sh" nil
+ (get-buffer-create gnus-uu-output-buffer-name) nil
+ "-c" (concat "cd " gnus-uu-work-dir " ; sh"))))
state))
;; Returns the name of what the shar file is going to unpack.
;; found, or the name of the command to run if such a rule is found.
(defun gnus-uu-choose-action (file-name file-action-list &optional no-ignore)
(let ((action-list (copy-sequence file-action-list))
+ (case-fold-search t)
rule action)
(and
(or no-ignore
(insert (make-string (- length (- (point) beg)) ? ))))
(forward-line 1))))))
-(defun gnus-uu-initialize ()
- (setq gnus-uu-highest-article-number 1)
- (gnus-uu-check-for-generated-files)
- (setq gnus-uu-tmp-dir (file-name-as-directory
- (expand-file-name gnus-uu-tmp-dir)))
-
- (if (not (file-directory-p gnus-uu-tmp-dir))
- (error "Temp directory %s doesn't exist" gnus-uu-tmp-dir)
- (if (not (file-writable-p gnus-uu-tmp-dir))
- (error "Temp directory %s can't be written to" gnus-uu-tmp-dir)))
-
- (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)
- (setq gnus-uu-work-dir (file-name-as-directory gnus-uu-work-dir)))
+(defvar gnus-uu-tmp-alist nil)
+
+(defun gnus-uu-initialize (&optional scan)
+ (let (entry)
+ (if (and (not scan)
+ (if (setq entry (assoc gnus-newsgroup-name gnus-uu-tmp-alist))
+ (if (file-exists-p (cdr entry))
+ (setq gnus-uu-work-dir (cdr entry))
+ (setq gnus-uu-tmp-alist (delq entry gnus-uu-tmp-alist))
+ nil)))
+ t
+ (setq gnus-uu-tmp-dir (file-name-as-directory
+ (expand-file-name gnus-uu-tmp-dir)))
+ (if (not (file-directory-p gnus-uu-tmp-dir))
+ (error "Temp directory %s doesn't exist" gnus-uu-tmp-dir)
+ (if (not (file-writable-p gnus-uu-tmp-dir))
+ (error "Temp directory %s can't be written to"
+ gnus-uu-tmp-dir)))
+
+ (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)
+ (setq gnus-uu-work-dir (file-name-as-directory gnus-uu-work-dir))
+ (setq gnus-uu-tmp-alist (cons (cons gnus-newsgroup-name gnus-uu-work-dir)
+ gnus-uu-tmp-alist)))))
+
;; Kills the temporary uu buffers, kills any processes, etc.
(defun gnus-uu-clean-up ()
;; 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))))))
+ ;; First delete the generated files.
+ (while (setq file (pop gnus-uu-generated-file-list))
+ (unless (string-match "/\\.[\\.]?$" file)
+ (if (file-directory-p file)
+ (push file dirs)
+ (when (file-exists-p file)
+ (delete-file file)))))
+ ;; Then delete the directories.
(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))))))
+ (while (setq file (pop dirs))
+ (delete-directory (directory-file-name file)))))
;; Add a file (or a list of files) to be checked (and deleted if it/they
;; still exists upon exiting the newsgroup).
;; quotes round the file name and escaping any quotes in the file name.
(defun gnus-uu-command (action file)
(let ((ofile ""))
- (while (string-match "!\\|`\\|\"\\|\\$\\|\\\\" file)
+ (while (string-match "!\\|`\\|\"\\|\\$\\|\\\\\\|&" file)
(progn
(setq ofile
(concat ofile (substring file 0 (match-beginning 0)) "\\"
beginning of the first article, which will be numbered (1/x). Default
is t.")
-(defconst gnus-uu-post-binary-separator "--binary follows this line--")
+(defvar gnus-uu-post-binary-separator "--binary follows this line--")
(defvar gnus-uu-post-message-id nil)
(defvar gnus-uu-post-inserted-file-name nil)
(defvar gnus-uu-winconf-post-news nil)
(get-buffer-create uuencode-buffer-name)))
(erase-buffer)
(funcall gnus-uu-post-encode-method file-path file-name))
- (insert-buffer uubuf)
+ (insert-buffer-substring uubuf)
(error "Encoding unsuccessful"))
(kill-buffer uubuf))
file-name))
projects / gnus / blobdiff