;;; Commentary:
-;;; Code:
+;;; Code:
(require 'gnus)
(require 'gnus-art)
;; Default viewing action rules
-(defcustom gnus-uu-default-view-rules
+(defcustom gnus-uu-default-view-rules
'(("\\.te?xt$\\|\\.doc$\\|read.*me\\|\\.c?$\\|\\.h$\\|\\.bat$\\|\\.asm$\\|makefile" "cat %s | sed s/\r//g")
("\\.pas$" "cat %s | sed s/\r//g")
("\\.[1-9]$" "groff -mandoc -Tascii %s | sed s/\b.//g")
("\\.\\(jpe?g\\|gif\\|tiff?\\|p[pgb]m\\|xwd\\|xbm\\|pcx\\)$" "xv")
("\\.tga$" "tgatoppm %s | xv -")
- ("\\.\\(wav\\|aiff\\|hcom\\|u[blw]\\|s[bfw]\\|voc\\|smp\\)$"
+ ("\\.\\(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")
("\\.html$" "xmosaic")
("\\.mpe?g$" "mpeg_play")
("\\.\\(flc\\|fli\\|rle\\|iff\\|pfx\\|avi\\|sme\\|rpza\\|dl\\|qt\\|rsrc\\|mov\\)$" "xanim")
- ("\\.\\(tar\\|arj\\|zip\\|zoo\\|arc\\|gz\\|Z\\|lzh\\|ar\\|lha\\)$"
+ ("\\.\\(tar\\|arj\\|zip\\|zoo\\|arc\\|gz\\|Z\\|lzh\\|ar\\|lha\\)$"
"gnus-uu-archive"))
- "Default actions to be taken when the user asks to view a file.
+ "Default actions to be taken when the user asks to view a file.
To change the behaviour, you can either edit this variable or set
`gnus-uu-user-view-rules' to something useful.
:group 'gnus-extract-view
:type '(repeat (group regexp (string :tag "Command"))))
-(defcustom gnus-uu-user-view-rules nil
+(defcustom gnus-uu-user-view-rules nil
"What actions are to be taken to view a file.
-See the documentation on the `gnus-uu-default-view-rules' variable for
+See the documentation on the `gnus-uu-default-view-rules' variable for
details."
:group 'gnus-extract-view
:type '(repeat (group regexp (string :tag "Command"))))
-(defcustom gnus-uu-user-view-rules-end
+(defcustom gnus-uu-user-view-rules-end
'(("" "file"))
"What actions are to be taken if no rule matched the file name.
-See the documentation on the `gnus-uu-default-view-rules' variable for
+See the documentation on the `gnus-uu-default-view-rules' variable for
details."
:group 'gnus-extract-view
:type '(repeat (group regexp (string :tag "Command"))))
;; Default unpacking commands
-(defcustom gnus-uu-default-archive-rules
+(defcustom gnus-uu-default-archive-rules
'(("\\.tar$" "tar xf")
("\\.zip$" "unzip -o")
("\\.ar$" "ar x")
:group 'gnus-extract-archive
:type '(repeat (group regexp (string :tag "Command"))))
-(defvar gnus-uu-destructive-archivers
+(defvar gnus-uu-destructive-archivers
(list "uncompress" "gunzip"))
(defcustom gnus-uu-user-archive-rules nil
"A list that can be set to override the default archive unpacking commands.
To use, for instance, 'untar' to unpack tar files and 'zip -x' to
unpack zip files, say the following:
- (setq gnus-uu-user-archive-rules
+ (setq gnus-uu-user-archive-rules
'((\"\\\\.tar$\" \"untar\")
(\"\\\\.zip$\" \"zip -x\")))"
:group 'gnus-extract-archive
(defcustom gnus-uu-ignore-files-by-name nil
"*A regular expression saying what files should not be viewed based on name.
-If, for instance, you want gnus-uu to ignore all .au and .wav files,
+If, for instance, you want gnus-uu to ignore all .au and .wav files,
you could say something like
(setq gnus-uu-ignore-files-by-name \"\\\\.au$\\\\|\\\\.wav$\")
(defcustom gnus-uu-ignore-files-by-type nil
"*A regular expression saying what files that shouldn't be viewed, based on MIME file type.
-If, for instance, you want gnus-uu to ignore all audio files and all mpegs,
+If, for instance, you want gnus-uu to ignore all audio files and all mpegs,
you could say something like
(setq gnus-uu-ignore-files-by-type \"audio/\\\\|video/mpeg\")
("\\.rsrc$" "video/rsrc")
("\\..*$" "unknown/unknown")))
-;; Various variables users may set
+;; Various variables users may set
-(defcustom gnus-uu-tmp-dir "/tmp/"
+(defcustom gnus-uu-tmp-dir "/tmp/"
"*Variable saying where gnus-uu is to do its work.
Default is \"/tmp/\"."
:group 'gnus-extract
:type 'directory)
-(defcustom gnus-uu-do-not-unpack-archives nil
- "*Non-nil means that gnus-uu won't peek inside archives looking for files to display.
+(defcustom gnus-uu-do-not-unpack-archives nil
+ "*Non-nil means that gnus-uu won't peek inside archives looking for files to display.
Default is nil."
:group 'gnus-extract-archive
:type 'boolean)
(defcustom 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'
+Likely functions you can use in this list are `gnus-uu-grab-view'
and `gnus-uu-grab-move'."
:group 'gnus-extract
:options '(gnus-uu-grab-view gnus-uu-grab-move)
:type 'hook)
-(defcustom gnus-uu-ignore-default-archive-rules nil
- "*Non-nil means that gnus-uu will ignore the default archive unpacking commands.
+(defcustom 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."
:group 'gnus-extract-archive
:type 'boolean)
:type 'boolean)
(defcustom gnus-uu-unmark-articles-not-decoded nil
- "*Non-nil means that gnus-uu will mark articles that were unsuccessfully decoded as unread.
+ "*Non-nil means that gnus-uu will mark articles that were unsuccessfully decoded as unread.
Default is nil."
:group 'gnus-extract
:type 'boolean)
(defcustom gnus-uu-correct-stripped-uucode nil
- "*Non-nil means that gnus-uu will *try* to fix uuencoded files that have had trailing spaces deleted.
+ "*Non-nil means that gnus-uu will *try* to fix uuencoded files that have had trailing spaces deleted.
Default is nil."
:group 'gnus-extract
:type 'boolean)
(defcustom gnus-uu-save-in-digest nil
"*Non-nil means that gnus-uu, when asked to save without decoding, will save in digests.
-If this variable is nil, gnus-uu will just save everything in a
+If this variable is nil, gnus-uu will just save everything in a
file without any embellishments. The digesting almost conforms to RFC1153 -
-no easy way to specify any meaningful volume and issue numbers were found,
+no easy way to specify any meaningful volume and issue numbers were found,
so I simply dropped them."
:group 'gnus-extract
:type 'boolean)
-(defcustom gnus-uu-digest-headers
+(defcustom gnus-uu-digest-headers
'("^Date:" "^From:" "^To:" "^Cc:" "^Subject:" "^Message-ID:" "^Keywords:"
"^Summary:" "^References:")
"List of regexps to match headers included in digested messages.
"p" gnus-uu-decode-postscript
"P" gnus-uu-decode-postscript-and-save)
-(gnus-define-keys
+(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
"Saves the current article."
(interactive
(list current-prefix-arg
- (read-file-name
+ (read-file-name
(if gnus-uu-save-separate-articles
"Save articles is dir: "
"Save articles in file: ")
(read-file-name "Unbinhex and save in dir: "
gnus-uu-default-dir
gnus-uu-default-dir))))
- (setq gnus-uu-binhex-article-name
+ (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 (&optional n)
- "Uudecodes and views the current article."
+ "Uudecodes and views the current article."
(interactive "P")
(let ((gnus-view-pseudos (or gnus-view-pseudos 'automatic)))
(gnus-uu-decode-uu 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
+ (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)))
(setq fs (cdr fs))))
(unless subject
(setq subject "Digested Articles"))
- (unless from
+ (unless from
(setq from
(if (gnus-news-group-p gnus-newsgroup-name)
gnus-newsgroup-name
"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)
(setq gnus-newsgroup-processable nil)
(save-excursion
(while marked
- (and (vectorp (setq headers
+ (and (vectorp (setq headers
(gnus-summary-article-header (car marked))))
(setq subject (mail-header-subject headers)
- articles (gnus-uu-find-articles-matching
+ articles (gnus-uu-find-articles-matching
(gnus-uu-reginize-string subject))
total (nconc total articles)))
(while articles
(setq data (cdr data)))))
(gnus-summary-position-point))
-;; All PostScript functions written by Erik Selberg <speed@cs.washington.edu>.
+;; All PostScript functions written by Erik Selberg <speed@cs.washington.edu>.
(defun gnus-uu-decode-postscript (&optional n)
"Gets postscript of the current article."
(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
+ (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)
;; Internal functions.
-(defun gnus-uu-decode-with-method (method n &optional save not-insert
+(defun gnus-uu-decode-with-method (method n &optional save not-insert
scan cdir)
(gnus-uu-initialize scan)
(when save
out)
(when (file-directory-p file)
(setq out (nconc (gnus-uu-scan-directory file t) out)))))
- (if rec
+ (if rec
out
(nreverse out))))
;; Function called by gnus-uu-grab-articles to treat each article.
(defun gnus-uu-save-article (buffer in-state)
- (cond
+ (cond
(gnus-uu-save-separate-articles
(save-excursion
(set-buffer buffer)
(gnus-write-buffer
(concat gnus-uu-saved-article-name gnus-current-article))
(cond ((eq in-state 'first) (list gnus-uu-saved-article-name 'begin))
- ((eq in-state 'first-and-last) (list gnus-uu-saved-article-name
+ ((eq in-state 'first-and-last) (list gnus-uu-saved-article-name
'begin 'end))
((eq in-state 'last) (list 'end))
(t (list 'middle)))))
(set-buffer buffer)
(write-region (point-min) (point-max) gnus-uu-saved-article-name t)
(cond ((eq in-state 'first) (list gnus-uu-saved-article-name 'begin))
- ((eq in-state 'first-and-last) (list gnus-uu-saved-article-name
+ ((eq in-state 'first-and-last) (list gnus-uu-saved-article-name
'begin 'end))
((eq in-state 'last) (list 'end))
(t (list 'middle)))))
beg subj headers headline sorthead body end-string state)
(if (or (eq in-state 'first)
(eq in-state 'first-and-last))
- (progn
+ (progn
(setq state (list 'begin))
(save-excursion (set-buffer (get-buffer-create "*gnus-uu-body*"))
(erase-buffer))
- (save-excursion
+ (save-excursion
(set-buffer (get-buffer-create "*gnus-uu-pre*"))
(erase-buffer)
- (insert (format
+ (insert (format
"Date: %s\nFrom: %s\nSubject: %s Digest\n\nTopics:\n"
(current-time-string) name name))))
(when (not (eq in-state 'end))
(setq headers (cdr headers))
(goto-char (point-min))
(while (re-search-forward headline nil t)
- (setq sorthead
+ (setq sorthead
(concat sorthead
- (buffer-substring
+ (buffer-substring
(match-beginning 0)
(or (and (re-search-forward "^[^ \t]" nil t)
(1- (point)))
(goto-char beg)
(when (re-search-forward "^Subject: \\(.*\\)$" nil t)
(setq subj (buffer-substring (match-beginning 1) (match-end 1)))
- (save-excursion
+ (save-excursion
(set-buffer (get-buffer "*gnus-uu-pre*"))
(insert (format " %s\n" subj)))))
(when (or (eq in-state 'last)
(save-excursion
(set-buffer (get-buffer "*gnus-uu-body*"))
(goto-char (point-max))
- (insert
+ (insert
(concat (setq end-string (format "End of %s Digest" name))
"\n"))
(insert (concat (make-string (length end-string) ?*) "\n"))
(cons gnus-uu-saved-article-name state)
state)))))
-;; Binhex treatment - not very advanced.
+;; Binhex treatment - not very advanced.
-(defconst gnus-uu-binhex-body-line
+(defconst gnus-uu-binhex-body-line
"^[^:]...............................................................$")
-(defconst gnus-uu-binhex-begin-line
+(defconst gnus-uu-binhex-begin-line
"^:...............................................................$")
(defconst gnus-uu-binhex-end-line
":$")
(write-region 1 1 gnus-uu-binhex-article-name))
(setq state (list 'middle)))
(goto-char (point-max))
- (re-search-backward (concat gnus-uu-binhex-body-line "\\|"
+ (re-search-backward (concat gnus-uu-binhex-body-line "\\|"
gnus-uu-binhex-end-line)
nil t)
(when (looking-at gnus-uu-binhex-end-line)
(write-region (point-min) (point-max) file-name)
(setq state (list file-name 'begin 'end)))))
state))
-
+
;; Find actions.
action name)
(while files
(setq name (cdr (assq 'name (car files))))
- (and
+ (and
(setq action (gnus-uu-get-action name))
(setcar files (nconc (list (if (string= action "gnus-uu-archive")
(cons 'action "file")
(defun gnus-uu-get-action (file-name)
(let (action)
- (setq action
- (gnus-uu-choose-action
+ (setq action
+ (gnus-uu-choose-action
file-name
- (append
+ (append
gnus-uu-user-view-rules
- (if gnus-uu-ignore-default-view-rules
- nil
+ (if gnus-uu-ignore-default-view-rules
+ nil
gnus-uu-default-view-rules)
gnus-uu-user-view-rules-end)))
(when (and (not (string= (or action "") "gnus-uu-archive"))
gnus-uu-view-with-metamail)
- (when (setq action
+ (when (setq action
(gnus-uu-choose-action file-name gnus-uu-ext-to-mime-list))
(setq action (format "metamail -d -b -c \"%s\"" action))))
action))
(if (re-search-backward "\\([^0-9]\\)[0-9]+\\([^0-9]+\\)[0-9]+"
nil t)
(replace-match "\\1[0-9]+\\2[0-9]+" t nil nil nil))))
-
+
(goto-char beg)
(while (re-search-forward "[ \t]+" nil t)
(replace-match "[ \t]*" t t))
;; If N is non-nil, the article numbers of the N next articles
;; will be returned.
;; If any articles have been marked as processable, they will be
- ;; returned.
+ ;; returned.
;; Failing that, articles that have subjects that are part of the
;; same "series" as the current will be returned.
(let (articles)
- (cond
+ (cond
(n
(setq n (prefix-numeric-value n))
(let ((backward (< n 0))
(defun gnus-uu-string< (l1 l2)
(string< (car l1) (car l2)))
-(defun gnus-uu-find-articles-matching
+(defun gnus-uu-find-articles-matching
(&optional subject only-unread do-not-translate)
;; Finds all articles that matches the regexp SUBJECT. If it is
;; nil, the current article name will be used. If ONLY-UNREAD is
;; 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
+ (let ((subject (or subject
(gnus-uu-reginize-string (gnus-summary-article-subject))))
list-of-subjects)
(save-excursion
;; Expand numbers, sort, and return the list of article
;; numbers.
(mapcar (lambda (sub) (cdr sub))
- (sort (gnus-uu-expand-numbers
+ (sort (gnus-uu-expand-numbers
list-of-subjects
(not do-not-translate))
'gnus-uu-string<))))))
(replace-match " "))
;; Translate all characters to "a".
(goto-char (point-min))
- (when translate
+ (when translate
(while (re-search-forward "[A-Za-z]" nil t)
(replace-match "a" t t)))
;; Expand numbers.
(goto-char (point-min))
(while (re-search-forward "[0-9]+" nil t)
- (replace-match
- (format "%06d"
- (string-to-int (buffer-substring
+ (replace-match
+ (format "%06d"
+ (string-to-int (buffer-substring
(match-beginning 0) (match-end 0))))))
(setq string (buffer-substring 1 (point-max)))
(setcar (car string-list) string)
(setq gnus-uu-has-been-grabbed (list art))))))
;; This function takes a list of articles and a function to apply to
-;; each article grabbed.
-;;
+;; each article grabbed.
+;;
;; This function returns a list of files decoded if the grabbing and
;; the process-function has been successful and nil otherwise.
-(defun gnus-uu-grab-articles (articles process-function
+(defun gnus-uu-grab-articles (articles process-function
&optional sloppy limit no-errors)
(let ((state 'first)
(gnus-asynchronous nil)
gnus-summary-display-article-function
gnus-article-display-hook gnus-article-prepare-hook
article-series files)
-
- (while (and articles
+
+ (while (and articles
(not (memq 'error process-state))
(or sloppy
(not (memq 'end process-state))))
(setq article (pop articles))
(push article article-series)
- (unless articles
+ (unless articles
(if (eq state 'first)
(setq state 'first-and-last)
(setq state 'last)))
(let ((part (gnus-uu-part-number article)))
- (gnus-message 6 "Getting article %d%s..."
+ (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.
(save-excursion
(set-buffer gnus-original-article-buffer)
(let ((buffer-read-only nil))
(save-excursion
(set-buffer gnus-summary-buffer)
- (setq process-state
+ (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
+ ;; 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)
(when 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
+ (when (and result-file
(file-exists-p result-file)
(not gnus-uu-be-dangerous)
(or (eq gnus-uu-be-dangerous t)
;; the partially decoded file.
(and (or (eq state 'last) (eq state 'first-and-last))
(not (memq 'end process-state))
- result-file
+ result-file
(file-exists-p result-file)
(not gnus-uu-be-dangerous)
(or (eq gnus-uu-be-dangerous t)
(gnus-y-or-n-p (format "Delete incomplete file %s? " result-file)))
(delete-file result-file))
- ;; If this was a file of the wrong sort, then
+ ;; 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)
(defun gnus-uu-part-number (article)
(let* ((header (gnus-summary-article-header article))
(subject (and header (mail-header-subject header))))
- (if (and subject
+ (if (and subject
(string-match "[0-9]+ */[0-9]+\\|[0-9]+ * of *[0-9]+" subject))
(match-string 0 subject)
"")))
(save-excursion
(set-buffer process-buffer)
(let ((state (list 'wrong-type))
- process-connection-type case-fold-search buffer-read-only
+ process-connection-type case-fold-search buffer-read-only
files start-char)
(goto-char (point-min))
(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
+ (setq gnus-uu-file-name
(let ((nnheader-file-name-translation-alist
'((?/ . ?,) (? . ?_) (?* . ?_) (?$ . ?_))))
(nnheader-translate-file-chars (match-string 1))))
(progn
(cd gnus-uu-work-dir)
(setq gnus-uu-uudecode-process
- (start-process
- "*uudecode*"
+ (start-process
+ "*uudecode*"
(get-buffer-create gnus-uu-output-buffer-name)
shell-file-name shell-command-switch
(format "cd %s %s uudecode" gnus-uu-work-dir
gnus-shell-command-separator))))
(cd cdir)))
- (set-process-sentinel
+ (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)
(push 'end state)
(goto-char (point-max))
(re-search-backward gnus-uu-body-line nil t))
-
+
(forward-line 1)
(when gnus-uu-uudecode-process
(condition-case nil
(process-send-region
gnus-uu-uudecode-process start-char (point))
- (error
- (progn
+ (error
+ (progn
(delete-process gnus-uu-uudecode-process)
(gnus-message 2 "gnus-uu: Couldn't uudecode")
(setq state (list 'wrong-type)))))
(setq state (list 'wrong-type))
(beginning-of-line)
(setq start-char (point))
- (call-process-region
- start-char (point-max) shell-file-name nil
- (get-buffer-create gnus-uu-output-buffer-name) nil
- shell-command-switch
- (concat "cd " gnus-uu-work-dir " "
+ (call-process-region
+ start-char (point-max) shell-file-name nil
+ (get-buffer-create gnus-uu-output-buffer-name) nil
+ shell-command-switch
+ (concat "cd " gnus-uu-work-dir " "
gnus-shell-command-separator " sh"))))
state))
(let ((action-list (copy-sequence file-action-list))
(case-fold-search t)
rule action)
- (and
- (unless no-ignore
- (and (not
+ (and
+ (unless no-ignore
+ (and (not
(and gnus-uu-ignore-files-by-name
(string-match gnus-uu-ignore-files-by-name file-name)))
- (not
+ (not
(and gnus-uu-ignore-files-by-type
- (string-match gnus-uu-ignore-files-by-type
- (or (gnus-uu-choose-action
+ (string-match gnus-uu-ignore-files-by-type
+ (or (gnus-uu-choose-action
file-name gnus-uu-ext-to-mime-list t)
""))))))
(while (not (or (eq action-list ()) action))
;; Unpacks an archive. Returns t if unpacking is successful.
(let ((did-unpack t)
action command dir)
- (setq action (gnus-uu-choose-action
+ (setq action (gnus-uu-choose-action
file-path (append gnus-uu-user-archive-rules
(if gnus-uu-ignore-default-archive-rules
nil
(gnus-message 5 "Unpacking: %s..." (gnus-uu-command action file-path))
- (if (= 0 (call-process shell-file-name nil
+ (if (= 0 (call-process shell-file-name nil
(get-buffer-create gnus-uu-output-buffer-name)
nil shell-command-switch command))
(message "")
files))
(defun gnus-uu-unpack-files (files &optional ignore)
- ;; Go through FILES and look for files to unpack.
+ ;; Go through FILES and look for files to unpack.
(let* ((totfiles (gnus-uu-ls-r gnus-uu-work-dir))
(ofiles files)
file did-unpack)
(setq nfiles (cdr nfiles)))
(setq totfiles newfiles)))
(setq files (cdr files)))
- (if did-unpack
+ (if did-unpack
(gnus-uu-unpack-files ofiles (append did-unpack ignore))
ofiles)))
(when (looking-at "\n")
(replace-match ""))
(forward-line 1))))
-
+
(while (not (eobp))
- (if (looking-at (concat gnus-uu-begin-string "\\|"
+ (if (looking-at (concat gnus-uu-begin-string "\\|"
gnus-uu-end-string))
()
(when (not found)
(setq gnus-uu-tmp-alist (delq entry gnus-uu-tmp-alist))
nil)))
t
- (setq gnus-uu-tmp-dir (file-name-as-directory
+ (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)
(when (not (file-writable-p gnus-uu-tmp-dir))
- (error "Temp directory %s can't be written to"
+ (error "Temp directory %s can't be written to"
gnus-uu-tmp-dir)))
- (setq gnus-uu-work-dir
+ (setq gnus-uu-work-dir
(make-temp-name (concat gnus-uu-tmp-dir "gnus")))
(gnus-make-directory gnus-uu-work-dir)
(set-file-modes gnus-uu-work-dir 448)
(defun gnus-quote-arg-for-sh-or-csh (arg)
(let ((pos 0) new-pos accum)
;; *** bug: we don't handle newline characters properly
- (while (setq new-pos (string-match "[!`\"$\\& \t]" arg pos))
+ (while (setq new-pos (string-match "[!`\"$\\& \t{}]" arg pos))
(push (substring arg pos new-pos) accum)
(push "\\" accum)
(push (list (aref arg new-pos)) accum)
"Function used for encoding binary files.
There are three functions supplied with gnus-uu for encoding files:
`gnus-uu-post-encode-uuencode', which does straight uuencoding;
-`gnus-uu-post-encode-mime', which encodes with base64 and adds MIME
-headers; and `gnus-uu-post-encode-mime-uuencode', which encodes with
+`gnus-uu-post-encode-mime', which encodes with base64 and adds MIME
+headers; and `gnus-uu-post-encode-mime-uuencode', which encodes with
uuencode and adds MIME headers."
:group 'gnus-extract-post
:type '(radio (function-item gnus-uu-post-encode-uuencode)
"Non-nil means that gnus-uu will post the encoded file in a thread.
This may not be smart, as no other decoder I have seen are able to
follow threads when collecting uuencoded articles. (Well, I have seen
-one package that does that - gnus-uu, but somehow, I don't think that
+one package that does that - gnus-uu, but somehow, I don't think that
counts...) Default is nil."
:group 'gnus-extract-post
:type 'boolean)
(defcustom gnus-uu-post-separate-description t
"Non-nil means that the description will be posted in a separate article.
The first article will typically be numbered (0/x). If this variable
-is nil, the description the user enters will be included at the
-beginning of the first article, which will be numbered (1/x). Default
+is nil, the description the user enters will be included at the
+beginning of the first article, which will be numbered (1/x). Default
is t."
:group 'gnus-extract-post
:type 'boolean)
(local-set-key "\C-c\C-c" 'gnus-uu-post-news-inews)
(local-set-key "\C-c\C-s" 'gnus-uu-post-news-inews)
(local-set-key "\C-c\C-i" 'gnus-uu-post-insert-binary-in-article)
-
+
(when gnus-uu-post-include-before-composing
- (save-excursion (setq gnus-uu-post-inserted-file-name
+ (save-excursion (setq gnus-uu-post-inserted-file-name
(gnus-uu-post-insert-binary)))))
(defun gnus-uu-post-insert-binary-in-article ()
"Inserts an encoded file in the buffer.
The user will be asked for a file name."
(interactive)
- (save-excursion
+ (save-excursion
(setq gnus-uu-post-inserted-file-name (gnus-uu-post-insert-binary))))
;; Encodes with uuencode and substitutes all spaces with backticks.
;; Adds MIME headers.
(defun gnus-uu-post-make-mime (file-name encoding)
(goto-char (point-min))
- (insert (format "Content-Type: %s; name=\"%s\"\n"
+ (insert (format "Content-Type: %s; name=\"%s\"\n"
(gnus-uu-choose-action file-name gnus-uu-ext-to-mime-list)
file-name))
(insert (format "Content-Transfer-Encoding: %s\n\n" encoding))
;; Encodes a file PATH with COMMAND, leaving the result in the
;; current buffer.
(defun gnus-uu-post-encode-file (command path file-name)
- (= 0 (call-process shell-file-name nil t nil shell-command-switch
+ (= 0 (call-process shell-file-name nil t nil shell-command-switch
(format "%s %s %s" command path file-name))))
(defun gnus-uu-post-news-inews ()
(if gnus-uu-post-inserted-file-name
(setq file-name gnus-uu-post-inserted-file-name)
(setq file-name (gnus-uu-post-insert-binary)))
-
+
(if gnus-uu-post-threaded
- (let ((message-required-news-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)))
(save-excursion
(goto-char (point-min))
(if (re-search-forward "^Message-ID: \\(.*\\)$" nil t)
- (setq gnus-uu-post-message-id
- (buffer-substring
+ (setq gnus-uu-post-message-id
+ (buffer-substring
(match-beginning 1) (match-end 1)))
(setq gnus-uu-post-message-id nil))))
gnus-inews-article-hook)
(setq gnus-uu-post-inserted-file-name nil)
(when gnus-uu-winconf-post-news
(set-window-configuration gnus-uu-winconf-post-news)))
-
+
;; Asks for a file to encode, encodes it and inserts the result in
;; the current buffer. Returns the file name the user gave.
(defun gnus-uu-post-insert-binary ()
(let ((uuencode-buffer-name "*uuencode buffer*")
file-path uubuf file-name)
- (setq file-path (read-file-name
+ (setq file-path (read-file-name
"What file do you want to encode? "))
(when (not (file-exists-p file-path))
(error "%s: No such file" file-path))
(goto-char (point-max))
(insert (format "\n%s\n" gnus-uu-post-binary-separator))
-
+
(when (string-match "^~/" file-path)
(setq file-path (concat "$HOME" (substring file-path 1))))
(if (string-match "/[^/]*$" file-path)
(unwind-protect
(if (save-excursion
- (set-buffer (setq uubuf
+ (set-buffer (setq uubuf
(get-buffer-create uuencode-buffer-name)))
(erase-buffer)
(funcall gnus-uu-post-encode-method file-path file-name))
(setq post-buf (current-buffer))
(goto-char (point-min))
- (when (not (re-search-forward
- (if gnus-uu-post-separate-description
+ (when (not (re-search-forward
+ (if gnus-uu-post-separate-description
(concat "^" (regexp-quote gnus-uu-post-binary-separator)
"$")
(concat "^" (regexp-quote mail-header-separator) "$"))
(setq beg-binary (point))
(setq end-binary (point-max))
- (save-excursion
+ (save-excursion
(set-buffer (setq uubuf (get-buffer-create encoded-buffer-name)))
(erase-buffer)
(insert-buffer-substring post-buf beg-binary end-binary)
(kill-region (point) (point-max))
(goto-char (point-min))
- (re-search-forward
+ (re-search-forward
(concat "^" (regexp-quote mail-header-separator) "$") nil t)
(beginning-of-line)
(setq header (buffer-substring 1 (point)))
(- 62 (length (format top-string "" file-name i parts ""))))
(when (> 1 (setq minlen (/ whole-len 2)))
(setq minlen 1))
- (setq
- beg-line
+ (setq
+ beg-line
(format top-string
(make-string minlen ?-)
file-name i parts
- (make-string
+ (make-string
(if (= 0 (% whole-len 2)) (1- minlen) minlen) ?-)))
(goto-char (point-min))
(when (or (and (= i 2) gnus-uu-post-separate-description)
(and (= i 1) (not gnus-uu-post-separate-description)))
(replace-match "Subject: Re: "))))
-
+
(goto-char (point-max))
(save-excursion
(set-buffer uubuf)
(concat "^" (regexp-quote mail-header-separator) "$") nil t)
(beginning-of-line)
(forward-line 2)
- (when (re-search-forward
+ (when (re-search-forward
(concat "^" (regexp-quote gnus-uu-post-binary-separator) "$")
nil t)
(replace-match "")
projects / gnus / blobdiff