mirror of
https://git.savannah.gnu.org/git/emacs.git
synced 2024-11-22 07:09:54 +00:00
3058 lines
109 KiB
EmacsLisp
3058 lines
109 KiB
EmacsLisp
;;; gnus-uu.el --- extract, view or save (uu)encoded files from gnus
|
|
|
|
;; Copyright (C) 1985, 1986, 1987, 1993, 1994 Free Software Foundation, Inc.
|
|
|
|
;; Author: Lars Ingebrigtsen <larsi@ifi.uio.no>
|
|
;; Created: 2 Oct 1993
|
|
;; Version: v2.8
|
|
;; Last Modified: 1994/06/01
|
|
;; Keywords: news
|
|
|
|
;; This file is part of GNU Emacs.
|
|
|
|
;; GNU Emacs is free software; you can redistribute it and/or modify
|
|
;; it under the terms of the GNU General Public License as published by
|
|
;; the Free Software Foundation; either version 2, or (at your option)
|
|
;; any later version.
|
|
|
|
;; GNU Emacs is distributed in the hope that it will be useful,
|
|
;; but WITHOUT ANY WARRANTY; without even the implied warranty of
|
|
;; MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
|
|
;; GNU General Public License for more details.
|
|
|
|
;; You should have received a copy of the GNU General Public License
|
|
;; along with GNU Emacs; see the file COPYING. If not, write to
|
|
;; the Free Software Foundation, 675 Mass Ave, Cambridge, MA 02139, USA.
|
|
|
|
;;; Commentary:
|
|
|
|
;; All gnus-uu commands start with `C-c C-v'.
|
|
;;
|
|
;; Short user manual for this package:
|
|
;;
|
|
;; Type `C-c C-v C-v' to decode and view all articles of the current
|
|
;; series. The defaults should be reasonable for most systems.
|
|
;;
|
|
;; Type `C-c C-v C-i' to toggle interactive mode. When using
|
|
;; interactive mode, gnus-uu will which display a buffer that will let
|
|
;; you see the suggested commands to be executed.
|
|
;;
|
|
;; To post an uuencoded file, type `C-c C-v p', which will enter you
|
|
;; into a buffer analogous to the one you will get when typing `a'. Do
|
|
;; an `M-x describe-mode' in this buffer to get a description of what
|
|
;; this buffer lets you do.
|
|
;;
|
|
;; Read the documentation of the `gnus-uu' dummy function for a more
|
|
;; complete description of what this package does and how you can
|
|
;; customize it to fit your needs.
|
|
;;
|
|
;;
|
|
;;
|
|
;; History
|
|
;;
|
|
;; v1.0: First version released Oct 2 1992.
|
|
;;
|
|
;; v1.1: Changed `C-c C-r' to `C-c C-e' and `C-c C-p' to `C-c C-k'.
|
|
;; Changed (setq gnus-exit-group-hook) to (add-hook). Removed
|
|
;; checking for "Re:" for finding parts.
|
|
;;
|
|
;; v2.2: Fixed handling of currupted archives. Changed uudecoding to
|
|
;; an asynchronous process to avoid loading tons of data into emacs
|
|
;; buffers. No longer reads articles emacs already have aboard. Fixed
|
|
;; a firmer support for shar files. Made regexp searches for files
|
|
;; more convenient. Added `C-c C-l' for editing uucode begin
|
|
;; lines. Added multi-system decoder entry point. Added interactive
|
|
;; view mode. Added function for decoding and saving all uuencoded
|
|
;; articles in the current newsgroup.
|
|
;;
|
|
;; v2.3: After suggestions I have changed all the gnus-uu key bindings
|
|
;; to avoid hogging all the user keys (C-c LETTER). Also added
|
|
;; (provide) and fixed some saving stuff. First posted version to
|
|
;; gnu.emacs.sources.
|
|
;;
|
|
;; v2.4: Fixed some more in the save-all category. Automatic fixing of
|
|
;; uucode "begin" lines: names on the form of "dir/file" are
|
|
;; translated into "dir-file". Added a function for fixing stripped
|
|
;; uucode articles. Added binhex save.
|
|
;;
|
|
;; v2.5: First version copyrighted by FSF. Changed lots of
|
|
;; documentation strings.
|
|
;;
|
|
;; v2.5.1: Added uuencode/posting code to post binary files.
|
|
;;
|
|
;; v2.6: Thread support. gnus-uu is now able to decode uuencoded files
|
|
;; posted in threads. gnus-uu can also post in threads. I don't know
|
|
;; if this ability is of much use - I've never seen anyone post
|
|
;; uuencoded files in threads.
|
|
;;
|
|
;; v2.7: gnus-uu is now able to decode (and view/save) multiple
|
|
;; encoded files in one big gulp. Also added pseudo-mime support
|
|
;; (users can use metamail to view files), posting uuencoded/mime
|
|
;; files and various other bits and pieces.
|
|
;;
|
|
;; v2.7.1: New functions for decoding/saving threads bound to `C-c
|
|
;; C-v C-j'. Handy to save entire threads, not very useful for
|
|
;; decoding, as nobody posts encoded files in threads...
|
|
;;
|
|
;; v2.7.2: New functions for digesting and forwarding articles added
|
|
;; on the suggestion of Per Abrahamsen. Also added a function for
|
|
;; marking threads.
|
|
;;
|
|
;; v2.8: Fixed saving original files in interactive mode. Fixed ask
|
|
;; before/save after view. Fixed setting up interactive buffers. Added
|
|
;; scanning and rescanning from interactive mode. Added the
|
|
;; `gnus-uu-ignore-file-by-name' and `...-by-type' variables to allow
|
|
;; users to sift files they don't want to view. At the suggestion of
|
|
;; boris@cs.rochester.edu, `C-c C-v C-h' has been undefined to allow
|
|
;; users to view list of binding beginning with `C-c C-v'. Fixed
|
|
;; viewing with `gnus-uu-asynchronous' set. The
|
|
;; "decode-and-save/view-all-articles" functions now accepts the
|
|
;; numeric prefix to delimit the maximum number of files to be
|
|
;; decoded.
|
|
|
|
;;; Code:
|
|
|
|
(require 'gnus)
|
|
(require 'gnuspost)
|
|
|
|
;; Binding of keys to the gnus-uu functions.
|
|
|
|
(defvar gnus-uu-ctl-map nil)
|
|
(define-prefix-command 'gnus-uu-ctl-map)
|
|
(define-key gnus-summary-mode-map "\C-c\C-v" gnus-uu-ctl-map)
|
|
|
|
(define-key gnus-uu-ctl-map "\C-v" 'gnus-uu-decode-and-view)
|
|
(define-key gnus-uu-ctl-map "v" 'gnus-uu-decode-and-save)
|
|
(define-key gnus-uu-ctl-map "\C-s" 'gnus-uu-shar-and-view)
|
|
(define-key gnus-uu-ctl-map "s" 'gnus-uu-shar-and-save)
|
|
(define-key gnus-uu-ctl-map "\C-m" 'gnus-uu-multi-decode-and-view)
|
|
(define-key gnus-uu-ctl-map "m" 'gnus-uu-multi-decode-and-save)
|
|
|
|
(define-key gnus-uu-ctl-map "\C-b" 'gnus-uu-decode-and-show-in-buffer)
|
|
|
|
(define-key gnus-summary-mode-map "#" 'gnus-uu-mark-article)
|
|
(define-key gnus-summary-mode-map "\M-#" 'gnus-uu-unmark-article)
|
|
(define-key gnus-uu-ctl-map "\C-u" 'gnus-uu-unmark-all-articles)
|
|
(define-key gnus-uu-ctl-map "\C-r" 'gnus-uu-mark-by-regexp)
|
|
(define-key gnus-uu-ctl-map "r" 'gnus-uu-mark-by-regexp)
|
|
(define-key gnus-uu-ctl-map "t" 'gnus-uu-mark-thread)
|
|
|
|
(define-key gnus-uu-ctl-map "\M-\C-v" 'gnus-uu-marked-decode-and-view)
|
|
(define-key gnus-uu-ctl-map "\M-v" 'gnus-uu-marked-decode-and-save)
|
|
(define-key gnus-uu-ctl-map "\M-\C-s" 'gnus-uu-marked-shar-and-view)
|
|
(define-key gnus-uu-ctl-map "\M-s" 'gnus-uu-marked-shar-and-save)
|
|
(define-key gnus-uu-ctl-map "\M-\C-m" 'gnus-uu-marked-multi-decode-and-view)
|
|
(define-key gnus-uu-ctl-map "\M-m" 'gnus-uu-marked-multi-decode-and-save)
|
|
|
|
(define-key gnus-uu-ctl-map "f" 'gnus-uu-digest-and-forward)
|
|
(define-key gnus-uu-ctl-map "\M-f" 'gnus-uu-marked-digest-and-forward)
|
|
|
|
(define-key gnus-uu-ctl-map "\C-i" 'gnus-uu-toggle-interactive-view)
|
|
(define-key gnus-uu-ctl-map "\C-t" 'gnus-uu-toggle-any-variable)
|
|
|
|
(define-key gnus-uu-ctl-map "\C-l" 'gnus-uu-edit-begin-line)
|
|
|
|
(define-key gnus-uu-ctl-map "a" 'gnus-uu-decode-and-save-all-unread-articles)
|
|
(define-key gnus-uu-ctl-map "w" 'gnus-uu-decode-and-save-all-articles)
|
|
(define-key gnus-uu-ctl-map "\C-a" 'gnus-uu-decode-and-view-all-unread-articles)
|
|
(define-key gnus-uu-ctl-map "\C-w" 'gnus-uu-decode-and-view-all-articles)
|
|
|
|
(define-key gnus-uu-ctl-map "\C-j" 'gnus-uu-threaded-multi-decode-and-view)
|
|
(define-key gnus-uu-ctl-map "j" 'gnus-uu-threaded-multi-decode-and-save)
|
|
|
|
(define-key gnus-uu-ctl-map "p" 'gnus-uu-post-news)
|
|
|
|
;; Dummy function gnus-uu
|
|
|
|
(defun gnus-uu ()
|
|
"gnus-uu is a package for uudecoding and viewing articles.
|
|
|
|
|
|
Keymap overview:
|
|
|
|
By default, all gnus-uu keystrokes begin with `C-c C-v'.
|
|
|
|
There four decoding commands categories:
|
|
All commands for viewing are `C-c C-v C-LETTER'.
|
|
All commands for saving are `C-c C-v LETTER'.
|
|
All commands for marked viewing are `C-c C-v C-M-LETTER'.
|
|
All commands for marked saving are `C-c C-v M-LETTER'.
|
|
|
|
\\<gnus-summary-mode-map>\\[gnus-uu-decode-and-view]\tDecode and view articles
|
|
\\[gnus-uu-decode-and-save]\tDecode and save articles
|
|
\\[gnus-uu-shar-and-view]\tUnshar and view articles
|
|
\\[gnus-uu-shar-and-save]\tUnshar and save articles
|
|
\\[gnus-uu-multi-decode-and-view]\tChoose a decoding method, decode and view articles
|
|
\\[gnus-uu-multi-decode-and-save]\tChoose a decoding method, decode and save articles
|
|
|
|
\\[gnus-uu-threaded-multi-decode-and-view]\tDecode a thread and view
|
|
\\[gnus-uu-threaded-multi-decode-and-save]\tDecode a thread and save
|
|
|
|
\\[gnus-uu-decode-and-show-in-buffer]\tDecode the current article and view the result in a buffer
|
|
\\[gnus-uu-edit-begin-line]\tEdit the 'begin' line of an uuencoded article
|
|
|
|
\\[gnus-uu-decode-and-save-all-unread-articles]\tDecode and save all unread articles
|
|
\\[gnus-uu-decode-and-save-all-articles]\tDecode and save all articles
|
|
\\[gnus-uu-decode-and-view-all-unread-articles]\tDecode and view all unread articles
|
|
\\[gnus-uu-decode-and-view-all-articles]\tDecode and view all articles
|
|
|
|
\\[gnus-uu-digest-and-forward]\tDigest and forward a series of articles
|
|
\\[gnus-uu-marked-digest-and-forward]\tDigest and forward all marked articles
|
|
|
|
\\[gnus-uu-mark-article]\tMark the current article for decoding
|
|
\\[gnus-uu-unmark-article]\tUnmark the current article
|
|
\\[gnus-uu-unmark-all-articles]\tUnmark all articles
|
|
\\[gnus-uu-mark-by-regexp]\tMark articles for decoding by regexp
|
|
\\[gnus-uu-mark-thread]\tMark articles in this thread
|
|
\\[gnus-uu-marked-decode-and-view]\tDecode and view marked articles
|
|
\\[gnus-uu-marked-decode-and-save]\tDecode and save marked articles
|
|
\\[gnus-uu-marked-shar-and-view]\tUnshar and view marked articles
|
|
\\[gnus-uu-marked-shar-and-save]\tUnshar and save marked articles
|
|
\\[gnus-uu-marked-multi-decode-and-view]\tChoose decoding method, decode and view marked articles
|
|
\\[gnus-uu-marked-multi-decode-and-save]\tChoose decoding method, decode and save marked articles
|
|
|
|
\\[gnus-uu-toggle-asynchronous]\tToggle asynchronous viewing mode
|
|
\\[gnus-uu-toggle-query]\tToggle whether to ask before viewing a file
|
|
\\[gnus-uu-toggle-always-ask]\tToggle whether to ask to save a file after viewing
|
|
\\[gnus-uu-toggle-kill-carriage-return]\tToggle whether to strip trailing carriage returns
|
|
\\[gnus-uu-toggle-interactive-view]\tToggle whether to use interactive viewing mode
|
|
\\[gnus-uu-toggle-correct-stripped-articles]\tToggle whether to 'correct' articles
|
|
\\[gnus-uu-toggle-view-with-metamail]\tToggle whether to use metamail for viewing
|
|
\\[gnus-uu-toggle-any-variable]\tToggle any of the things above
|
|
|
|
\\[gnus-uu-post-news]\tPost an uuencoded article
|
|
|
|
Function description:
|
|
|
|
`gnus-uu-decode-and-view' will try to find all articles in the same
|
|
series, uudecode them and view the resulting file(s).
|
|
|
|
gnus-uu guesses what articles are in the series according to the
|
|
following simplish rule: The subjects must be (nearly) identical,
|
|
except for the last two numbers of the line. (Spaces are largely
|
|
ignored, however.)
|
|
|
|
For example: If you choose a subject called
|
|
\"cat.gif (2/3)\"
|
|
gnus-uu will find all the articles that matches
|
|
\"^cat.gif ([0-9]+/[0-9]+).*$\".
|
|
|
|
Subjects that are nonstandard, like
|
|
\"cat.gif (2/3) Part 6 of a series\",
|
|
will not be properly recognized by any of the automatic viewing
|
|
commands, and you have to mark the articles manually with '#'.
|
|
|
|
`gnus-uu-decode-and-save' will do the same as
|
|
`gnus-uu-decode-and-view', except that it will not display the
|
|
resulting file, but save it instead.
|
|
|
|
`gnus-uu-shar-and-view' and `gnus-uu-shar-and-save' are the \"shar\"
|
|
equivalents to the uudecode functions. Instead of feeding the articles
|
|
to uudecode, they are run through /bin/sh. Most shar files can be
|
|
viewed and/or saved with the normal uudecode commands, which is much
|
|
safer, as no foreign code is run.
|
|
|
|
Instead of having windows popping up automatically, it can be handy to
|
|
view files interactivly, especially when viewing archives. Use
|
|
`gnus-uu-toggle-interactive-mode' to toggle interactive mode.
|
|
|
|
`gnus-uu-mark-article' marks an article for later
|
|
decoding/unsharing/saving/viewing. The files will be decoded in the
|
|
sequence they were marked. To decode the files after you've marked the
|
|
articles you are interested in, type the corresponding key strokes as
|
|
the normal decoding commands, but put a `M-' in the last
|
|
keystroke. For instance, to perform a standard uudecode and view, you
|
|
would type `C-c C-v C-v'. To perform a marked uudecode and view, say
|
|
`C-v C-v M-C-v'. All the other view and save commands are handled the
|
|
same way; marked uudecode and save is then `C-c C-v M-v'.
|
|
|
|
`gnus-uu-unmark-article' will remove the mark from a previosly marked
|
|
article.
|
|
|
|
`gnus-uu-unmark-all-articles' will remove the mark from all marked
|
|
articles.
|
|
|
|
`gnus-uu-mark-by-regexp' will prompt for a regular expression and mark
|
|
all articles matching that regular expression.
|
|
|
|
`gnus-uu-mark-thread' will mark all articles downward in the current
|
|
thread.
|
|
|
|
There's an additional way to reach the decoding functions to make
|
|
future expansions easier: `gnus-uu-multi-decode-and-view' and the
|
|
corresponding save, marked view and marked save functions. You will be
|
|
prompted for a decoding method, like uudecode, shar, binhex or plain
|
|
save. Note that methods like binhex and save doesn't have view modes;
|
|
even if you issue a view command (`C-c C-v C-m' and \"binhex\"),
|
|
gnus-uu will just save the resulting binhex file.
|
|
|
|
`gnus-uu-decode-and-show-in-buffer' will decode the current article
|
|
and display the results in an emacs buffer. This might be useful if
|
|
there's jsut some text in the current article that has been uuencoded
|
|
by some perverse poster.
|
|
|
|
`gnus-uu-decode-and-save-all-articles' looks at all the articles in
|
|
the current newsgroup and tries to uudecode everything it can
|
|
find. The user will be prompted for a directory where the resulting
|
|
files (if any) will be
|
|
saved. `gnus-uu-decode-and-save-unread-articles' does only checks
|
|
unread articles.
|
|
|
|
`gnus-uu-decode-and-view-all-articles' does the same as the function
|
|
above, only viewing files instead of saving them.
|
|
|
|
`gnus-uu-edit-begin-line' lets you edit the begin line of an uuencoded
|
|
file in the current article. Useful to change a corrupted begin line.
|
|
|
|
|
|
When using the view commands, `gnus-uu-decode-and-view' for instance,
|
|
gnus-uu will (normally, see below) try to view the file according to
|
|
the rules given in `gnus-uu-default-view-rules' and
|
|
`gnus-uu-user-view-rules'. If it recognizes the file, it will display
|
|
it immediately. If the file is some sort of archive, gnus-uu will
|
|
attempt to unpack the archive and see if any of the files in the
|
|
archive can be viewed. For instance, if you have a gzipped tar file
|
|
\"pics.tar.gz\" containing the files \"pic1.jpg\" and \"pic2.gif\",
|
|
gnus-uu will uncompress and detar the main file, and then view the two
|
|
pictures. This unpacking process is recursive, so if the archive
|
|
contains archives of archives, it'll all be unpacked.
|
|
|
|
If the view command doesn't recognise the file type, or can't view it
|
|
because you don't have the viewer, or can't view *any* of the files in
|
|
the archive, the user will be asked if she wishes to have the file
|
|
saved somewhere. Note that if the decoded file is an archive, and
|
|
gnus-uu manages to view some of the files in the archive, it won't
|
|
tell the user that there were some files that were unviewable. Try
|
|
interactive view for a different approach.
|
|
|
|
|
|
Note that gnus-uu adds a function to `gnus-exit-group-hook' to clear
|
|
the list of marked articles and check for any generated files that
|
|
might have escaped deletion if the user typed `C-g' during viewing.
|
|
|
|
|
|
`gnus-uu-toggle-asynchronous' toggles the `gnus-uu-asynchronous'
|
|
variable.
|
|
|
|
`gnus-uu-toggle-query' toggles the `gnus-uu-ask-before-view'
|
|
variable.
|
|
|
|
`gnus-uu-toggle-always-ask' toggles the `gnus-uu-view-and-save'
|
|
variable.
|
|
|
|
`gnus-uu-toggle-kill-carriage-return' toggles the
|
|
`gnus-uu-kill-carriage-return' variable.
|
|
|
|
`gnus-uu-toggle-interactive-view' toggles interactive mode. If it is
|
|
turned on, gnus-uu won't view files immediately, but will give you a
|
|
buffer with the default commands and files and let you edit the
|
|
commands and execute them at leisure.
|
|
|
|
`gnus-uu-toggle-correct-stripped-articles' toggles whether to check
|
|
and correct uuencoded articles that may have had trailing spaces
|
|
stripped by mailers.
|
|
|
|
`gnus-uu-toggle-view-with-metamail' toggles whether to skip the
|
|
gnus-uu viewing methods and just guess at an content-type based on the
|
|
file name suffix and feed it to metamail.
|
|
|
|
`gnus-uu-toggle-any-variable' is an interface to the toggle commands
|
|
listed above.
|
|
|
|
|
|
Customization
|
|
|
|
Rule Variables
|
|
|
|
gnus-uu uses \"rule\" variables to decide how to view a file. All
|
|
these variables are of the form
|
|
|
|
(list '(regexp1 command2)
|
|
'(regexp2 command2)
|
|
...)
|
|
|
|
`gnus-uu-user-view-rules'
|
|
This variable is consulted first when viewing files. If you wish
|
|
to use, for instance, sox to convert an .au sound file, you could
|
|
say something like:
|
|
|
|
(setq gnus-uu-user-view-rules
|
|
(list '(\"\\\\.au$\" \"sox %s -t .aiff > /dev/audio\")))
|
|
|
|
`gnus-uu-user-view-rules-end'
|
|
This variable is consulted if gnus-uu couldn't make any matches
|
|
from the user and default view rules.
|
|
|
|
`gnus-uu-user-interactive-view-rules'
|
|
This is the variable used instead of `gnus-uu-user-view-rules'
|
|
when in interactive mode.
|
|
|
|
`gnus-uu-user-interactive-view-rules-end'
|
|
This variable is used instead of `gnus-uu-user-view-rules-end'
|
|
when in interactive mode.
|
|
|
|
`gnus-uu-user-archive-rules`
|
|
This variable can be used to say what comamnds should be used to
|
|
unpack archives.
|
|
|
|
|
|
Other Variables
|
|
|
|
`gnus-uu-ignore-files-by-name'
|
|
Files with name matching this regular expression won't be viewed.
|
|
|
|
`gnus-uu-ignore-files-by-type'
|
|
Files with a MIME type matching this variable won't be viewed.
|
|
Note that gnus-uu tries to guess what type the file is based on
|
|
the name. gnus-uu is not a MIME package, so this is slightly
|
|
kludgy.
|
|
|
|
`gnus-uu-tmp-dir'
|
|
Where gnus-uu does its work.
|
|
|
|
`gnus-uu-do-not-unpack-archives'
|
|
Non-nil means that gnus-uu won't peek inside archives looking for
|
|
files to dispay.
|
|
|
|
`gnus-uu-view-and-save'
|
|
Non-nil means that the user will always be asked to save a file
|
|
after viewing it.
|
|
|
|
`gnus-uu-asynchronous'
|
|
Non-nil means that files will be viewed asynchronously. This can
|
|
be useful if you're viewing long .mod files, for instance, which
|
|
often takes several minutes. Note, however, that since gnus-uu
|
|
doesn't ask, and if you are viewing an archive with lots of
|
|
viewable files, you'll get them all up more or less at once,
|
|
which can be confusing, to say the least. To get gnus-uu to ask
|
|
you before viewing a file, set the `gnus-uu-ask-before-view'
|
|
variable.
|
|
|
|
`gnus-uu-ask-before-view'
|
|
Non-nil means that gnus-uu will ask you before viewing each file
|
|
|
|
`gnus-uu-ignore-default-view-rules'
|
|
Non-nil means that gnus-uu will ignore the default viewing rules.
|
|
|
|
`gnus-uu-ignore-default-archive-rules'
|
|
Non-nil means that gnus-uu will ignore the default archive
|
|
unpacking commands.
|
|
|
|
`gnus-uu-kill-carriage-return'
|
|
Non-nil means that gnus-uu will strip all carriage returns from
|
|
articles.
|
|
|
|
`gnus-uu-unmark-articles-not-decoded'
|
|
Non-nil means that gnus-uu will mark articles that were
|
|
unsuccessfully decoded as unread.
|
|
|
|
`gnus-uu-output-window-height'
|
|
This variable says how tall the output buffer window is to be
|
|
when using interactive view mode.
|
|
|
|
`gnus-uu-correct-stripped-uucode'
|
|
Non-nil means that gnus-uu will *try* to fix uuencoded files that
|
|
have had traling spaces deleted.
|
|
|
|
`gnus-uu-use-interactive-view'
|
|
Non-nil means that gnus-uu will use interactive viewing mode.
|
|
|
|
`gnus-uu-view-with-metamail'
|
|
Non-nil means that gnus-uu will ignore the viewing commands
|
|
defined by the rule variables and just fudge a MIME content type
|
|
based on the file name. The result will be fed to metamail for
|
|
viewing.
|
|
|
|
`gnus-uu-save-in-digest'
|
|
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 file without any embellishments. The
|
|
digesting almost conforms to RFC1153 - no easy way to specify any
|
|
meaningful volume and issue numbers were found, so I simply
|
|
dropped them.
|
|
|
|
`gnus-uu-post-include-before-composing'
|
|
Non-nil means that gnus-uu will ask for a file to encode before
|
|
you compose the article. If this variable is t, you can either
|
|
include an encoded file with \\<gnus-uu-post-reply-mode-map>\\[gnus-uu-post-insert-binary-in-article] or have one included for you when you
|
|
post the article.
|
|
|
|
`gnus-uu-post-length'
|
|
Maximum length of an article. The encoded file will be split
|
|
into how many articles it takes to post the entire file.
|
|
|
|
`gnus-uu-post-threaded'
|
|
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 counts...) Default is
|
|
nil.
|
|
|
|
`gnus-uu-post-separate-description'
|
|
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 t.
|
|
"
|
|
(interactive)
|
|
)
|
|
|
|
;; Default viewing action rules
|
|
|
|
(defvar gnus-uu-default-view-rules
|
|
(list
|
|
'("\\.\\(jpe?g\\|gif\\|tiff?\\|p[pgb]m\\|xwd\\|xbm\\|pcx\\)$" "xv")
|
|
'("\\.tga$" "tgatoppm %s | xv -")
|
|
'("\\.te?xt$\\|\\.doc$\\|read.*me" "xterm -e less")
|
|
'("\\.\\(wav\\|aiff\\|hcom\\|u[blw]\\|s[bfw]\\|voc\\|smp\\)$"
|
|
"sox -v .5 %s -t .au -u - > /dev/audio")
|
|
'("\\.au$" "cat %s > /dev/audio")
|
|
'("\\.mod$" "str32")
|
|
'("\\.ps$" "ghostview")
|
|
'("\\.dvi$" "xdvi")
|
|
'("\\.[1-6]$" "xterm -e man -l")
|
|
'("\\.html$" "xmosaic")
|
|
'("\\.mpe?g$" "mpeg_play")
|
|
'("\\.\\(flc\\|fli\\|rle\\|iff\\|pfx\\|avi\\|sme\\|rpza\\|dl\\|qt\\|rsrc\\)$" "xanim")
|
|
'("\\.\\(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.
|
|
To change the behaviour, you can either edit this variable or set
|
|
`gnus-uu-user-view-rules' to something useful.
|
|
|
|
For example:
|
|
|
|
To make gnus-uu use 'xli' to display JPEG and GIF files, put the
|
|
following in your .emacs file
|
|
|
|
(setq gnus-uu-user-view-rules (list '(\"jpg$\\\\|gif$\" \"xli\")))
|
|
|
|
Both these variables are lists of lists with two string elements. The
|
|
first string is a regular expression. If the file name matches this
|
|
regular expression, the command in the second string is executed with
|
|
the file as an argument.
|
|
|
|
If the command string contains \"%s\", the file name will be inserted
|
|
at that point in the command string. If there's no \"%s\" in the
|
|
command string, the file name will be appended to the command string
|
|
before executing.
|
|
|
|
There are several user variables to tailor the behaviour of gnus-uu to
|
|
your needs. First we have `gnus-uu-user-view-rules', which is the
|
|
variable gnus-uu first consults when trying to decide how to view a
|
|
file. If this variable contains no matches, gnus-uu examines the
|
|
default rule vaiable provided in this package. If gnus-uu finds no
|
|
match here, it uses `gnus-uu-user-view-rules-end' to try to make a
|
|
match.
|
|
|
|
Unless, of course, you are using the interactive view mode. Then
|
|
`gnus-uu-user-interactive-view-rules' and
|
|
`gnus-uu-user-interactive-view-rules-end' will be used instead.")
|
|
|
|
(defvar gnus-uu-user-view-rules nil
|
|
"Variable detailing what actions are to be taken to view a file.
|
|
See the documentation on the `gnus-uu-default-view-rules' variable for
|
|
details.")
|
|
|
|
(defvar gnus-uu-user-view-rules-end nil
|
|
"Variable saying 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
|
|
details.")
|
|
|
|
(defvar gnus-uu-user-interactive-view-rules nil
|
|
"Variable detailing what actions are to be taken to view a file when using interactive mode.
|
|
See the documentation on the `gnus-uu-default-view-rules' variable for
|
|
details.")
|
|
|
|
(defvar gnus-uu-user-interactive-view-rules-end nil
|
|
"Variable saying what actions are to be taken if no rule matched the file name when using interactive mode.
|
|
See the documentation on the `gnus-uu-default-view-rules' variable for
|
|
details.")
|
|
|
|
(defvar gnus-uu-default-interactive-view-rules-begin
|
|
(list
|
|
'("\\.te?xt$\\|\\.doc$\\|read.*me\\|\\.c?$\\|\\.h$\\|\\.bat$\\|\\.asm$\\|makefile" "cat %s | sed s/\r//g")
|
|
'("\\.pas$" "cat %s | sed s/\r//g")
|
|
))
|
|
|
|
(defvar gnus-uu-default-interactive-view-rules-end
|
|
(list
|
|
'(".*" "file")))
|
|
|
|
;; Default unpacking commands
|
|
|
|
(defvar gnus-uu-default-archive-rules
|
|
(list '("\\.tar$" "tar xf")
|
|
'("\\.zip$" "unzip -o")
|
|
'("\\.ar$" "ar x")
|
|
'("\\.arj$" "unarj x")
|
|
'("\\.zoo$" "zoo -e")
|
|
'("\\.\\(lzh\\|lha\\)$" "lha x")
|
|
'("\\.Z$" "uncompress")
|
|
'("\\.gz$" "gunzip")
|
|
'("\\.arc$" "arc -x"))
|
|
)
|
|
|
|
(defvar gnus-uu-destructive-archivers
|
|
(list "uncompress" "gunzip"))
|
|
|
|
(defvar 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
|
|
(list '(\"\\\\.tar$\" \"untar\")
|
|
'(\"\\\\.zip$\" \"zip -x\")))")
|
|
|
|
(defvar 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,
|
|
you could say something like
|
|
|
|
(setq gnus-uu-ignore-files-by-name \"\\\\.au$\\\\|\\\\.wav$\")
|
|
|
|
Note that this variable can be used in conjunction with the
|
|
`gnus-uu-ignore-files-by-type' variable.")
|
|
|
|
(defvar 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,
|
|
you could say something like
|
|
|
|
(setq gnus-uu-ignore-files-by-type \"audio/\\\\|video/mpeg\")
|
|
|
|
Note that this variable can be used in conjunction with the
|
|
`gnus-uu-ignore-files-by-name' variable.")
|
|
|
|
;; Pseudo-MIME support
|
|
|
|
(defconst gnus-uu-ext-to-mime-list
|
|
(list '("\\.gif$" "image/gif")
|
|
'("\\.jpe?g$" "image/jpeg")
|
|
'("\\.tiff?$" "image/tiff")
|
|
'("\\.xwd$" "image/xwd")
|
|
'("\\.pbm$" "image/pbm")
|
|
'("\\.pgm$" "image/pgm")
|
|
'("\\.ppm$" "image/ppm")
|
|
'("\\.xbm$" "image/xbm")
|
|
'("\\.pcx$" "image/pcx")
|
|
'("\\.tga$" "image/tga")
|
|
'("\\.ps$" "image/postscript")
|
|
'("\\.fli$" "video/fli")
|
|
'("\\.wav$" "audio/wav")
|
|
'("\\.aiff$" "audio/aiff")
|
|
'("\\.hcom$" "audio/hcom")
|
|
'("\\.voc$" "audio/voc")
|
|
'("\\.smp$" "audio/smp")
|
|
'("\\.mod$" "audio/mod")
|
|
'("\\.dvi$" "image/dvi")
|
|
'("\\.mpe?g$" "video/mpeg")
|
|
'("\\.au$" "audio/basic")
|
|
'("\\.\\(te?xt\\|doc\\|c\\|h\\)$" "text/plain")
|
|
'("\\.\\(c\\|h\\)$" "text/source")
|
|
'("read.*me" "text/plain")
|
|
'("\\.html$" "text/html")
|
|
'("\\.bat$" "text/bat")
|
|
'("\\.[1-6]$" "text/man")
|
|
'("\\.flc$" "video/flc")
|
|
'("\\.rle$" "video/rle")
|
|
'("\\.pfx$" "video/pfx")
|
|
'("\\.avi$" "video/avi")
|
|
'("\\.sme$" "video/sme")
|
|
'("\\.rpza$" "video/prza")
|
|
'("\\.dl$" "video/dl")
|
|
'("\\.qt$" "video/qt")
|
|
'("\\.rsrc$" "video/rsrc")
|
|
'("\\..*$" "unknown/unknown")))
|
|
|
|
;; Various variables users may set
|
|
|
|
(defvar gnus-uu-tmp-dir "/tmp/"
|
|
"Variable saying where gnus-uu is to do its work.
|
|
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.
|
|
Default is nil.")
|
|
|
|
(defvar gnus-uu-view-and-save nil
|
|
"Non-nil means that the user will always be asked to save a file after viewing it.
|
|
If the variable is nil, the suer will only be asked to save if the
|
|
viewing is unsuccessful. Default is nil.")
|
|
|
|
(defvar gnus-uu-asynchronous nil
|
|
"Non-nil means that files will be viewed asynchronously.
|
|
Default is nil.")
|
|
|
|
(defvar gnus-uu-ask-before-view nil
|
|
"Non-nil means that gnus-uu will ask you before viewing each file.
|
|
Especially useful when `gnus-uu-asynchronous' is set. Default is
|
|
nil.")
|
|
|
|
(defvar gnus-uu-ignore-default-view-rules 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-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-kill-carriage-return t
|
|
"Non-nil means that gnus-uu will strip all carriage returns from articles.
|
|
Default is t.")
|
|
|
|
(defvar gnus-uu-view-with-metamail nil
|
|
"Non-nil means that files will be viewed with metamail.
|
|
The gnus-uu viewing functions will be ignored and gnus-uu will try
|
|
to guess at a content-type based on file name suffixes. Default
|
|
it nil.")
|
|
|
|
(defvar gnus-uu-unmark-articles-not-decoded nil
|
|
"Non-nil means that gnus-uu will mark articles that were unsuccessfully decoded as unread.
|
|
Default is nil.")
|
|
|
|
(defvar gnus-uu-output-window-height 20
|
|
"This variable says how tall the output buffer window is to be when using interactive view mode.
|
|
Change it at your convenience. Default is 20.")
|
|
|
|
(defvar gnus-uu-correct-stripped-uucode nil
|
|
"Non-nil means that gnus-uu will *try* to fix uuencoded files that have had traling spaces deleted.
|
|
Default is nil.")
|
|
|
|
(defvar gnus-uu-use-interactive-view nil
|
|
"Non-nil means that gnus-uu will use interactive viewing mode.
|
|
Gnus-uu will create a special buffer where the user may choose
|
|
interactively which files to view and how. Default is nil.")
|
|
|
|
(defvar 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
|
|
file without any embellishments. The digesting almost conforms to RFC1153 -
|
|
no easy way to specify any meaningful volume and issue numbers were found,
|
|
so I simply dropped them.")
|
|
|
|
|
|
;; Internal variables
|
|
|
|
(defconst gnus-uu-begin-string "^begin[ \t]+[0-7][0-7][0-7][ \t]+\\(.*\\)$")
|
|
(defconst gnus-uu-end-string "^end[ \t]*$")
|
|
|
|
(defconst gnus-uu-body-line "^M")
|
|
(let ((i 61))
|
|
(while (> (setq i (1- i)) 0)
|
|
(setq gnus-uu-body-line (concat gnus-uu-body-line "[^a-z]")))
|
|
(setq gnus-uu-body-line (concat gnus-uu-body-line ".?$")))
|
|
|
|
;"^M.............................................................?$"
|
|
|
|
(defconst gnus-uu-shar-begin-string "^#! */bin/sh")
|
|
|
|
(defvar gnus-uu-shar-file-name nil)
|
|
(defconst gnus-uu-shar-name-marker "begin [0-7][0-7][0-7][ \t]+\\(\\(\\w\\|\\.\\)*\\b\\)")
|
|
(defvar gnus-uu-shar-directory nil)
|
|
|
|
(defvar gnus-uu-file-name nil)
|
|
(defvar gnus-uu-list-of-files-decoded nil)
|
|
(defconst gnus-uu-uudecode-process nil)
|
|
|
|
(defvar gnus-uu-interactive-file-list nil)
|
|
(defvar gnus-uu-marked-article-list nil)
|
|
(defvar gnus-uu-generated-file-list nil)
|
|
(defvar gnus-uu-work-dir nil)
|
|
|
|
(defconst gnus-uu-interactive-buffer-name "*gnus-uu interactive*")
|
|
(defconst gnus-uu-output-buffer-name "*Gnus UU Output*")
|
|
(defconst gnus-uu-result-buffer "*Gnus UU Result Buffer*")
|
|
|
|
(defconst gnus-uu-highest-article-number 1)
|
|
|
|
;; Interactive functions
|
|
|
|
;; UUdecode and view
|
|
|
|
(defun gnus-uu-decode-and-view ()
|
|
"UUdecodes and 'views' (if possible) the resulting file.
|
|
'Viewing' can be any action at all, as defined in the
|
|
`gnus-uu-file-action-list' variable. Running 'xv' on gifs and 'cat
|
|
>/dev/audio' on au files are popular actions. If the file can't be
|
|
viewed, the user is asked if she would like to save the file instead."
|
|
(interactive)
|
|
(gnus-uu-decode-and-view-or-save t nil))
|
|
|
|
(defun gnus-uu-decode-and-save ()
|
|
"Decodes and saves the resulting file."
|
|
(interactive)
|
|
(gnus-uu-decode-and-view-or-save nil nil))
|
|
|
|
(defun gnus-uu-marked-decode-and-view ()
|
|
"Decodes and views articles marked.
|
|
The marked equivalent to `gnus-uu-decode-and-view'."
|
|
(interactive)
|
|
(gnus-uu-decode-and-view-or-save t t))
|
|
|
|
(defun gnus-uu-marked-decode-and-save ()
|
|
"Decodes and saves articles marked.
|
|
The marked equivalent to `gnus-uu-decode-and-save'."
|
|
(interactive)
|
|
(gnus-uu-decode-and-view-or-save nil t))
|
|
|
|
|
|
;; Unshar and view
|
|
|
|
(defun gnus-uu-shar-and-view ()
|
|
"Unshars and views articles.
|
|
The shar equivalent of `gnus-uu-decode-and-view'."
|
|
(interactive)
|
|
(gnus-uu-unshar-and-view-or-save t nil))
|
|
|
|
(defun gnus-uu-shar-and-save ()
|
|
"Unshars and saves files.
|
|
The shar equivalent to `gnus-uu-decode-and-save'."
|
|
(interactive)
|
|
(gnus-uu-unshar-and-view-or-save nil nil))
|
|
|
|
(defun gnus-uu-marked-shar-and-view ()
|
|
"Unshars and views articles marked.
|
|
The marked equivalent to `gnus-uu-shar-and-view'."
|
|
(interactive)
|
|
(gnus-uu-unshar-and-view-or-save t t))
|
|
|
|
(defun gnus-uu-marked-shar-and-save ()
|
|
"Unshars and saves articles marked.
|
|
The marked equivalent to `gnus-uu-shar-and-save'."
|
|
(interactive)
|
|
(gnus-uu-unshar-and-view-or-save nil t))
|
|
|
|
;; Threaded decode
|
|
|
|
(defun gnus-uu-threaded-decode-and-view ()
|
|
"Decodes and saves the resulting file."
|
|
(interactive)
|
|
(gnus-uu-threaded-decode-and-view-or-save t))
|
|
|
|
(defun gnus-uu-threaded-decode-and-save ()
|
|
"Decodes and saves the resulting file."
|
|
(interactive)
|
|
(gnus-uu-threaded-decode-and-view-or-save nil))
|
|
|
|
(defun gnus-uu-threaded-multi-decode-and-view ()
|
|
"Decodes and saves the resulting file."
|
|
(interactive)
|
|
(gnus-uu-threaded-multi-decode-and-view-or-save t))
|
|
|
|
(defun gnus-uu-threaded-multi-decode-and-save ()
|
|
"Decodes and saves the resulting file."
|
|
(interactive)
|
|
(gnus-uu-threaded-multi-decode-and-view-or-save nil))
|
|
|
|
(defun gnus-uu-threaded-decode-and-view-or-save (&optional view)
|
|
(gnus-uu-unmark-all-articles)
|
|
(gnus-uu-mark-thread)
|
|
(gnus-uu-decode-and-view-or-save view t))
|
|
|
|
(defun gnus-uu-threaded-multi-decode-and-view-or-save (view)
|
|
(let (type)
|
|
(message "Decode type: [u]udecode, (s)har, s(a)ve, (b)inhex: ")
|
|
(setq type (read-char))
|
|
(if (not (or (= type ?u) (= type ?s) (= type ?b) (= type ?a)))
|
|
(error "No such decoding method '%c'" type))
|
|
|
|
(gnus-uu-unmark-all-articles)
|
|
(gnus-uu-mark-thread)
|
|
|
|
(if (= type ?\r) (setq type ?u))
|
|
(cond ((= type ?u) (gnus-uu-decode-and-view-or-save view t))
|
|
((= type ?s) (gnus-uu-unshar-and-view-or-save view t))
|
|
((= type ?b) (gnus-uu-binhex-and-save view t))
|
|
((= type ?a) (gnus-uu-save-articles view t)))))
|
|
|
|
|
|
;; Toggle commands
|
|
|
|
(defun gnus-uu-toggle-asynchronous ()
|
|
"This function toggles asynchronous viewing."
|
|
(interactive)
|
|
(if (setq gnus-uu-asynchronous (not gnus-uu-asynchronous))
|
|
(message "gnus-uu will now view files asynchronously")
|
|
(message "gnus-uu will now view files synchronously")))
|
|
|
|
(defun gnus-uu-toggle-query ()
|
|
"This function toggles whether to ask before viewing or not."
|
|
(interactive)
|
|
(if (setq gnus-uu-ask-before-view (not gnus-uu-ask-before-view))
|
|
(message "gnus-uu will now ask before viewing")
|
|
(message "gnus-uu will now view without asking first")))
|
|
|
|
(defun gnus-uu-toggle-always-ask ()
|
|
"This function toggles whether to always ask to save a file after viewing."
|
|
(interactive)
|
|
(if (setq gnus-uu-view-and-save (not gnus-uu-view-and-save))
|
|
(message "gnus-uu will now ask to save the file after viewing")
|
|
(message "gnus-uu will now not ask to save after successful viewing")))
|
|
|
|
(defun gnus-uu-toggle-interactive-view ()
|
|
"This function toggles whether to use interactive view."
|
|
(interactive)
|
|
(if (setq gnus-uu-use-interactive-view (not gnus-uu-use-interactive-view))
|
|
(message "gnus-uu will now use interactive view")
|
|
(message "gnus-uu will now use non-interactive view")))
|
|
|
|
(defun gnus-uu-toggle-unmark-undecoded ()
|
|
"This function toggles whether to unmark articles not decoded."
|
|
(interactive)
|
|
(if (setq gnus-uu-unmark-articles-not-decoded
|
|
(not gnus-uu-unmark-articles-not-decoded))
|
|
(message "gnus-uu will now unmark articles not decoded")
|
|
(message "gnus-uu will now not unmark articles not decoded")))
|
|
|
|
(defun gnus-uu-toggle-kill-carriage-return ()
|
|
"This function toggles the stripping of carriage returns from the articles."
|
|
(interactive)
|
|
(if (setq gnus-uu-kill-carriage-return (not gnus-uu-kill-carriage-return))
|
|
(message "gnus-uu will now strip carriage returns")
|
|
(message "gnus-uu won't strip carriage returns")))
|
|
|
|
(defun gnus-uu-toggle-view-with-metamail ()
|
|
"This function toggles whether to view files with metamail."
|
|
(interactive)
|
|
(if (setq gnus-uu-view-with-metamail (not gnus-uu-view-with-metamail))
|
|
(message "gnus-uu will now view with metamail")
|
|
(message "gnus-uu will now view with the gnus-uu viewing functions")))
|
|
|
|
(defun gnus-uu-toggle-correct-stripped-uucode ()
|
|
"This function toggles whether to correct stripped uucode."
|
|
(interactive)
|
|
(if (setq gnus-uu-correct-stripped-uucode
|
|
(not gnus-uu-correct-stripped-uucode))
|
|
(message "gnus-uu will now correct stripped uucode")
|
|
(message "gnus-uu won't check and correct stripped uucode")))
|
|
|
|
(defun gnus-uu-toggle-any-variable ()
|
|
"This function ask what variable the user wants to toggle."
|
|
(interactive)
|
|
(let (rep)
|
|
(message "(a)sync, (q)uery, (p)ask, (k)ill CR, (i)nteract, (u)nmark, (c)orrect, (m)eta")
|
|
(setq rep (read-char))
|
|
(if (= rep ?a)
|
|
(gnus-uu-toggle-asynchronous))
|
|
(if (= rep ?q)
|
|
(gnus-uu-toggle-query))
|
|
(if (= rep ?p)
|
|
(gnus-uu-toggle-always-ask))
|
|
(if (= rep ?k)
|
|
(gnus-uu-toggle-kill-carriage-return))
|
|
(if (= rep ?u)
|
|
(gnus-uu-toggle-unmark-undecoded))
|
|
(if (= rep ?c)
|
|
(gnus-uu-toggle-correct-stripped-uucode))
|
|
(if (= rep ?m)
|
|
(gnus-uu-toggle-view-with-metamail))
|
|
(if (= rep ?i)
|
|
(gnus-uu-toggle-interactive-view))))
|
|
|
|
|
|
;; Misc interactive functions
|
|
|
|
(defun gnus-uu-decode-and-show-in-buffer ()
|
|
"Uudecodes the current article and displays the result in a buffer.
|
|
Might be useful if someone has, for instance, some text uuencoded in
|
|
their sigs. (Stranger things have happened.)"
|
|
(interactive)
|
|
(gnus-uu-initialize)
|
|
(let ((uu-buffer (get-buffer-create gnus-uu-output-buffer-name))
|
|
file-name)
|
|
(save-excursion
|
|
(and
|
|
(gnus-summary-select-article)
|
|
(gnus-uu-grab-articles (list gnus-current-article)
|
|
'gnus-uu-uustrip-article-as)
|
|
(setq file-name (concat gnus-uu-work-dir gnus-uu-file-name))
|
|
(progn
|
|
(save-excursion
|
|
(set-buffer uu-buffer)
|
|
(erase-buffer)
|
|
(insert-file-contents file-name))
|
|
(set-window-buffer (get-buffer-window gnus-article-buffer)
|
|
uu-buffer)
|
|
(message "Showing file %s in buffer" file-name)
|
|
(delete-file file-name))))))
|
|
|
|
(defun gnus-uu-edit-begin-line ()
|
|
"Edit the begin line of the current article."
|
|
(interactive)
|
|
(let ((buffer-read-only nil)
|
|
begin b)
|
|
(save-excursion
|
|
(gnus-summary-select-article)
|
|
(set-buffer gnus-article-buffer)
|
|
(goto-line 1)
|
|
(if (not (re-search-forward "begin " nil t))
|
|
(error "No begin line in the current article")
|
|
(beginning-of-line)
|
|
(setq b (point))
|
|
(end-of-line)
|
|
(setq begin (buffer-substring b (point)))
|
|
(setq begin (read-string "" begin))
|
|
(setq buffer-read-only nil)
|
|
(delete-region b (point))
|
|
(insert-string begin)))))
|
|
|
|
|
|
;; Multi functions
|
|
|
|
(defun gnus-uu-multi-decode-and-view ()
|
|
"Choose a method of decoding and then decode and view.
|
|
This function lets the user decide what method to use for decoding.
|
|
Other than that, it's equivalent to the other decode-and-view
|
|
functions."
|
|
(interactive)
|
|
(gnus-uu-multi-decode-and-view-or-save t nil))
|
|
|
|
(defun gnus-uu-multi-decode-and-save ()
|
|
"Choose a method of decoding and then decode and save.
|
|
This function lets the user decide what method to use for decoding.
|
|
Other than that, it's equivalent to the other decode-and-save
|
|
functions."
|
|
(interactive)
|
|
(gnus-uu-multi-decode-and-view-or-save nil nil))
|
|
|
|
(defun gnus-uu-marked-multi-decode-and-view ()
|
|
"Choose a method of decoding and then decode and view the marked articles.
|
|
This function lets the user decide what method to use for decoding.
|
|
Other than that, it's equivalent to the other marked decode-and-view
|
|
functions."
|
|
(interactive)
|
|
(gnus-uu-multi-decode-and-view-or-save t t))
|
|
|
|
(defun gnus-uu-marked-multi-decode-and-save ()
|
|
"Choose a method of decoding and then decode and save the marked articles.
|
|
This function lets the user decide what method to use for decoding.
|
|
Other than that, it's equivalent to the other marked decode-and-save
|
|
functions."
|
|
(interactive)
|
|
(gnus-uu-multi-decode-and-view-or-save t t))
|
|
|
|
(defun gnus-uu-multi-decode-and-view-or-save (view marked)
|
|
(let (type)
|
|
(message "[u]udecode, (s)har, s(a)ve, (b)inhex: ")
|
|
(setq type (read-char))
|
|
(if (= type ?\r) (setq type ?u))
|
|
(cond ((= type ?u) (gnus-uu-decode-and-view-or-save view marked))
|
|
((= type ?s) (gnus-uu-unshar-and-view-or-save view marked))
|
|
((= type ?b) (gnus-uu-binhex-and-save view marked))
|
|
((= type ?a) (gnus-uu-save-articles view marked))
|
|
(t (error "Unknown decode method '%c'." type)))))
|
|
|
|
|
|
;; "All articles" commands
|
|
|
|
(defconst gnus-uu-rest-of-articles nil)
|
|
(defvar gnus-uu-current-save-dir nil)
|
|
|
|
(defun gnus-uu-decode-and-view-all-articles (arg &optional unread)
|
|
"Try to decode all articles and view the result.
|
|
ARG delimits the number of files to be decoded."
|
|
(interactive "p")
|
|
(if (not (setq gnus-uu-marked-article-list
|
|
(nreverse (gnus-uu-get-list-of-articles
|
|
"^." nil unread t))))
|
|
(error "No%s articles to be decoded" (if unread " unread" "")))
|
|
(gnus-uu-decode-and-view-or-save t t nil (if (> arg 1) arg nil)))
|
|
|
|
(defun gnus-uu-decode-and-view-all-unread-articles (arg)
|
|
"Try to decode all unread articles and view the result.
|
|
ARG delimits the number of files to be decoded."
|
|
(interactive "p")
|
|
(gnus-uu-decode-and-view-all-articles arg t))
|
|
|
|
(defun gnus-uu-decode-and-save-all-unread-articles (arg)
|
|
"Try to decode all unread articles and saves the result.
|
|
This function reads all unread articles in the current group and sees
|
|
whether it can uudecode the articles. The user will be prompted for an
|
|
directory to put the resulting (if any) files.
|
|
ARG delimits the number of files to be decoded."
|
|
(interactive "p")
|
|
(gnus-uu-decode-and-save-articles arg t t))
|
|
|
|
(defun gnus-uu-decode-and-save-all-articles (arg)
|
|
"Try to decode all articles and saves the result.
|
|
Does the same as `gnus-uu-decode-and-save-all-unread-articles', except
|
|
that it grabs all articles visible, unread or not.
|
|
ARG delimits the number of files to be decoded."
|
|
(interactive "p")
|
|
(gnus-uu-decode-and-save-articles arg nil t))
|
|
|
|
(defun gnus-uu-decode-and-save-articles (arg &optional unread unmark)
|
|
(let (dir)
|
|
(if (not (setq gnus-uu-marked-article-list
|
|
(nreverse (gnus-uu-get-list-of-articles
|
|
"^." nil unread t))))
|
|
(error "No%s articles to be decoded." (if unread " unread" ""))
|
|
(setq dir (gnus-uu-read-directory "Where do you want the files? "))
|
|
(gnus-uu-decode-and-view-or-save nil t dir (if (> arg 1) arg nil))
|
|
(message "Saved."))))
|
|
|
|
|
|
;; Work functions
|
|
|
|
; All the interactive uudecode/view/save/marked functions are interfaces
|
|
; to this function, which does the rest.
|
|
(defun gnus-uu-decode-and-view-or-save (view marked &optional save-dir limit)
|
|
(gnus-uu-initialize)
|
|
(let (decoded)
|
|
(save-excursion
|
|
(if (gnus-uu-decode-and-strip nil marked limit)
|
|
(progn
|
|
(setq decoded t)
|
|
(if view
|
|
(gnus-uu-view-directory gnus-uu-work-dir
|
|
gnus-uu-use-interactive-view)
|
|
(gnus-uu-save-directory gnus-uu-work-dir save-dir save-dir)
|
|
(gnus-uu-check-for-generated-files)))))
|
|
|
|
(gnus-uu-summary-next-subject)
|
|
|
|
(if (and gnus-uu-use-interactive-view view decoded)
|
|
(gnus-uu-do-interactive))
|
|
|
|
(if (or (not view) (not gnus-uu-use-interactive-view) (not decoded))
|
|
(gnus-uu-clean-up))))
|
|
|
|
; Unshars and views/saves marked/unmarked articles.
|
|
(defun gnus-uu-unshar-and-view-or-save (view marked)
|
|
(gnus-uu-initialize)
|
|
(let (tar-file files decoded)
|
|
(save-excursion
|
|
(setq gnus-uu-shar-directory
|
|
(make-temp-name (concat gnus-uu-tmp-dir "gnusuush")))
|
|
(make-directory gnus-uu-shar-directory)
|
|
(gnus-uu-add-file gnus-uu-shar-directory)
|
|
(if (gnus-uu-decode-and-strip t marked)
|
|
(progn
|
|
(setq decoded t)
|
|
(setq files (directory-files gnus-uu-shar-directory t))
|
|
(setq gnus-uu-generated-file-list
|
|
(append files gnus-uu-generated-file-list))
|
|
(if (> (length files) 3)
|
|
(progn
|
|
(setq tar-file
|
|
(concat
|
|
(make-temp-name (concat gnus-uu-tmp-dir "gnusuuar"))
|
|
".tar"))
|
|
(gnus-uu-add-file tar-file)
|
|
(call-process
|
|
"sh" nil
|
|
(get-buffer-create gnus-uu-output-buffer-name) nil "-c"
|
|
(format "cd %s ; tar cf %s * ; cd .. ; rm -r %s"
|
|
gnus-uu-shar-directory tar-file
|
|
gnus-uu-shar-directory))
|
|
(if view
|
|
(gnus-uu-view-file tar-file)
|
|
(gnus-uu-save-file tar-file)))
|
|
(if view
|
|
(gnus-uu-view-file (elt files 2))
|
|
(gnus-uu-save-file (elt files 2)))))))
|
|
|
|
(gnus-uu-summary-next-subject)
|
|
|
|
(if (and gnus-uu-use-interactive-view view decoded)
|
|
(gnus-uu-do-interactive))
|
|
|
|
(if (or (not gnus-uu-use-interactive-view) (not decoded))
|
|
(gnus-uu-clean-up))))
|
|
|
|
|
|
;; Functions for saving and possibly digesting articles without
|
|
;; any decoding.
|
|
|
|
(defconst gnus-uu-saved-article-name nil)
|
|
|
|
; VIEW isn't used, but is here anyway, to provide similar interface to
|
|
; the other related functions. If MARKED is non-nil, the list of
|
|
; marked articles is used. If NO-SAVE is non-nil, the articles aren't
|
|
; actually saved in a permanent location, but the collecting is done
|
|
; and a temporary file with the result is returned.
|
|
(defun gnus-uu-save-articles (view marked &optional no-save)
|
|
(let (list-of-articles)
|
|
(save-excursion
|
|
(gnus-uu-initialize)
|
|
(if (not marked)
|
|
(setq list-of-articles (gnus-uu-get-list-of-articles))
|
|
(setq list-of-articles (reverse gnus-uu-marked-article-list))
|
|
(setq gnus-uu-marked-article-list nil))
|
|
|
|
(if (not list-of-articles)
|
|
(error "No list of articles"))
|
|
|
|
(setq gnus-uu-saved-article-name
|
|
(concat gnus-uu-work-dir
|
|
(if no-save
|
|
gnus-newsgroup-name
|
|
(read-file-name "Enter file name: " gnus-newsgroup-name
|
|
gnus-newsgroup-name))))
|
|
(gnus-uu-add-file gnus-uu-saved-article-name)
|
|
(if (and (gnus-uu-grab-articles list-of-articles 'gnus-uu-save-article t)
|
|
(not no-save))
|
|
(gnus-uu-save-file gnus-uu-saved-article-name)
|
|
gnus-uu-saved-article-name))))
|
|
|
|
; Function called by gnus-uu-grab-articles to treat each article.
|
|
(defun gnus-uu-save-article (buffer in-state)
|
|
(if (not gnus-uu-save-in-digest)
|
|
(save-excursion
|
|
(set-buffer buffer)
|
|
(write-region 1 (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 'begin 'end))
|
|
((eq in-state 'last) (list 'end))
|
|
(t (list 'middle))))
|
|
(let (beg subj name headers headline sorthead body end-string state)
|
|
(string-match "/\\([^/]*\\)$" gnus-uu-saved-article-name)
|
|
(setq name (substring gnus-uu-saved-article-name (match-beginning 1)
|
|
(match-end 1)))
|
|
(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 1)
|
|
(re-search-forward "\n\n")
|
|
(setq body (buffer-substring (1- (point)) (point-max)))
|
|
(narrow-to-region 1 (point))
|
|
(setq headers (list "Date:" "From:" "To:" "Cc:" "Subject:"
|
|
"Message-ID:" "Keywords:" "Summary:"))
|
|
(while headers
|
|
(setq headline (car headers))
|
|
(setq headers (cdr headers))
|
|
(goto-char 1)
|
|
(if (re-search-forward (concat "^" headline ".*$") nil t)
|
|
(setq sorthead
|
|
(concat sorthead (buffer-substring
|
|
(match-beginning 0)
|
|
(match-end 0)) "\n"))))
|
|
(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)
|
|
(eq in-state 'first-and-last))
|
|
(progn
|
|
(save-excursion
|
|
(set-buffer (get-buffer "*gnus-uu-pre*"))
|
|
(insert (format "\n\n%s\n\n" (make-string 70 ?-)))
|
|
(write-region 1 (point-max) gnus-uu-saved-article-name))
|
|
(save-excursion
|
|
(set-buffer (get-buffer "*gnus-uu-body*"))
|
|
(goto-char (point-max))
|
|
(insert
|
|
(concat (setq end-string (format "End of %s Digest" name))
|
|
"\n"))
|
|
(insert (concat (make-string (length end-string) ?*) "\n"))
|
|
(write-region 1 (point-max) gnus-uu-saved-article-name t))
|
|
(kill-buffer (get-buffer "*gnus-uu-pre*"))
|
|
(kill-buffer (get-buffer "*gnus-uu-body*"))
|
|
(setq state (cons 'end state))))
|
|
(if (memq 'begin state)
|
|
(cons gnus-uu-saved-article-name state)
|
|
state))))
|
|
|
|
|
|
;; Digest and forward articles
|
|
|
|
(autoload 'gnus-mail-forward-using-mail "gnusmail"
|
|
"Forward the current message to another user." t)
|
|
(autoload 'gnus-mail-forward-using-mhe "gnusmail"
|
|
"Forward the current message to another user." t)
|
|
|
|
(defun gnus-uu-digest-and-forward (&optional marked)
|
|
"Digests and forwards all articles in this series."
|
|
(interactive)
|
|
(let ((gnus-uu-save-in-digest t)
|
|
file buf)
|
|
(setq file (gnus-uu-save-articles nil marked t))
|
|
(switch-to-buffer (setq buf (get-buffer-create "*gnus-uu-forward*")))
|
|
(erase-buffer)
|
|
(delete-other-windows)
|
|
(erase-buffer)
|
|
(insert-file file)
|
|
(goto-char 1)
|
|
(bury-buffer buf)
|
|
(funcall gnus-mail-forward-method)))
|
|
|
|
(defun gnus-uu-marked-digest-and-forward (&optional marked)
|
|
"Digests and forwards all marked articles."
|
|
(interactive)
|
|
(gnus-uu-digest-and-forward t))
|
|
|
|
|
|
;; Binhex treatment - not very advanced.
|
|
|
|
(defconst gnus-uu-binhex-body-line
|
|
"^[^:]...............................................................$")
|
|
(defconst gnus-uu-binhex-begin-line
|
|
"^:...............................................................$")
|
|
(defconst gnus-uu-binhex-end-line
|
|
":$")
|
|
(defvar gnus-uu-binhex-article-name nil)
|
|
|
|
; This just concatenates and strips stuff from binhexed articles.
|
|
; No actual unbinhexing takes place. VIEW is ignored.
|
|
(defun gnus-uu-binhex-and-save (view marked)
|
|
(gnus-uu-initialize)
|
|
(let (list-of-articles)
|
|
(save-excursion
|
|
(if (not marked)
|
|
(setq list-of-articles (gnus-uu-get-list-of-articles))
|
|
(setq list-of-articles (reverse gnus-uu-marked-article-list))
|
|
(setq gnus-uu-marked-article-list nil))
|
|
(if (not list-of-articles)
|
|
(error "No list of articles"))
|
|
|
|
(setq gnus-uu-binhex-article-name
|
|
(concat gnus-uu-work-dir
|
|
(read-file-name "Enter binhex file name: "
|
|
gnus-newsgroup-name
|
|
gnus-newsgroup-name)))
|
|
(gnus-uu-add-file gnus-uu-binhex-article-name)
|
|
(if (gnus-uu-grab-articles list-of-articles 'gnus-uu-binhex-article t)
|
|
(gnus-uu-save-file gnus-uu-binhex-article-name))))
|
|
(gnus-uu-check-for-generated-files)
|
|
(gnus-uu-summary-next-subject))
|
|
|
|
(defun gnus-uu-binhex-article (buffer in-state)
|
|
(let (state start-char)
|
|
(save-excursion
|
|
(set-buffer buffer)
|
|
(widen)
|
|
(goto-char 1)
|
|
(if (not (re-search-forward gnus-uu-binhex-begin-line nil t))
|
|
(if (not (re-search-forward gnus-uu-binhex-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-binhex-begin-line)
|
|
(progn
|
|
(setq state (list 'begin))
|
|
(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 "\\|"
|
|
gnus-uu-binhex-end-line) nil t)
|
|
(if (looking-at gnus-uu-binhex-end-line)
|
|
(setq state (if (memq 'begin state)
|
|
(cons 'end state)
|
|
(list 'end))))
|
|
(beginning-of-line)
|
|
(forward-line 1)
|
|
(if (file-exists-p gnus-uu-binhex-article-name)
|
|
(append-to-file start-char (point) gnus-uu-binhex-article-name))))
|
|
(if (memq 'begin state)
|
|
(cons gnus-uu-binhex-article-name state)
|
|
state)))
|
|
|
|
|
|
;; Internal view commands
|
|
|
|
; This function takes two parameters. The first is name of the file to
|
|
; be viewed. `gnus-uu-view-file' will look for an action associated
|
|
; with the file type of the file. If it finds an appropriate action,
|
|
; the file will be attempted displayed.
|
|
;
|
|
; The second parameter specifies if the user is to be asked whether to
|
|
; save the file if viewing is unsuccessful. t means "do not ask."
|
|
;
|
|
; Note that the file given will be deleted by this function, one way
|
|
; or another. If `gnus-uu-asynchronous' is set, it won't be deleted
|
|
; right away, but sometime later. If the user is offered to save the
|
|
; file, it'll be moved to wherever the user wants it.
|
|
|
|
; `gnus-uu-view-file' returns t if viewing is successful.
|
|
|
|
(defun gnus-uu-view-file (file &optional silent)
|
|
(let (action did-view)
|
|
(cond
|
|
((not (setq action (gnus-uu-get-action file)))
|
|
(if (and (not silent) (not gnus-uu-use-interactive-view))
|
|
(progn
|
|
(message "Couldn't find any rule for file '%s'" file)
|
|
(sleep-for 2)
|
|
(gnus-uu-ask-to-save-file file))))
|
|
|
|
((and gnus-uu-use-interactive-view
|
|
(not (string= (or action "") "gnus-uu-archive")))
|
|
(gnus-uu-enter-interactive-file (or action "") file))
|
|
|
|
(gnus-uu-ask-before-view
|
|
(if (y-or-n-p (format "Do you want to view %s? " file))
|
|
(setq did-view (gnus-uu-call-file-action file action)))
|
|
(message ""))
|
|
|
|
((setq did-view (gnus-uu-call-file-action file action)))
|
|
|
|
((not silent)
|
|
(gnus-uu-ask-to-save-file file)))
|
|
|
|
(if (and (file-exists-p file)
|
|
(not gnus-uu-use-interactive-view)
|
|
(or
|
|
(not (and gnus-uu-asynchronous did-view))
|
|
(string= (or action "") "gnus-uu-archive")))
|
|
(delete-file file))
|
|
|
|
did-view))
|
|
|
|
(defun gnus-uu-call-file-action (file action)
|
|
(prog1
|
|
(if gnus-uu-asynchronous
|
|
(gnus-uu-call-asynchronous file action)
|
|
(gnus-uu-call-synchronous file action))
|
|
(if gnus-uu-view-and-save
|
|
(gnus-uu-ask-to-save-file file))))
|
|
|
|
(defun gnus-uu-ask-to-save-file (file)
|
|
(if (y-or-n-p (format "Do you want to save the file %s? " file))
|
|
(gnus-uu-save-file file))
|
|
(message ""))
|
|
|
|
(defun gnus-uu-get-action (file-name)
|
|
(let (action)
|
|
(setq action
|
|
(gnus-uu-choose-action
|
|
file-name
|
|
(append
|
|
(if (and gnus-uu-use-interactive-view
|
|
gnus-uu-user-interactive-view-rules)
|
|
gnus-uu-user-interactive-view-rules
|
|
gnus-uu-user-view-rules)
|
|
(if (or gnus-uu-ignore-default-view-rules
|
|
(not gnus-uu-use-interactive-view))
|
|
()
|
|
gnus-uu-default-interactive-view-rules-begin)
|
|
(if gnus-uu-ignore-default-view-rules
|
|
nil
|
|
gnus-uu-default-view-rules)
|
|
(if gnus-uu-use-interactive-view
|
|
(append gnus-uu-user-interactive-view-rules-end
|
|
(if gnus-uu-ignore-default-view-rules
|
|
()
|
|
gnus-uu-default-interactive-view-rules-end))
|
|
gnus-uu-user-view-rules-end))))
|
|
(if (and (not (string= (or action "") "gnus-uu-archive"))
|
|
gnus-uu-view-with-metamail)
|
|
(if (setq action
|
|
(gnus-uu-choose-action file-name gnus-uu-ext-to-mime-list))
|
|
(setq action (format "metamail -d -b -c \"%s\"" action))))
|
|
action))
|
|
|
|
; `gnus-uu-call-synchronous' takes two parameters: The name of the
|
|
; file to be displayed and the command to display it with. Returns t
|
|
; on success and nil if the file couldn't be displayed.
|
|
(defun gnus-uu-call-synchronous (file-name action)
|
|
(let (did-view command)
|
|
(save-excursion
|
|
(set-buffer (get-buffer-create gnus-uu-output-buffer-name))
|
|
(erase-buffer)
|
|
(setq command (gnus-uu-command action file-name))
|
|
(message "Viewing with '%s'" command)
|
|
(if (not (= 0 (call-process "sh" nil t nil "-c" command)))
|
|
(progn
|
|
(goto-char 1)
|
|
(while (re-search-forward "\n" nil t)
|
|
(replace-match " "))
|
|
(message (concat "Error: " (buffer-substring 1 (point-max))))
|
|
(sit-for 2))
|
|
(message "")
|
|
(setq did-view t)))
|
|
did-view))
|
|
|
|
; `gnus-uu-call-asyncronous' takes two parameters: The name of the
|
|
; file to be displayed and the command to display it with. Since the
|
|
; view command is executed asynchronously, it's kinda hard to decide
|
|
; whether the command succeded or not, so this function always returns
|
|
; t. It also adds "; rm -f file-name" to the end of the execution
|
|
; string, so the file will be removed after viewing has ended.
|
|
(defun gnus-uu-call-asynchronous (file-name action)
|
|
(let (command file tmp-file start)
|
|
(while (string-match "/" file-name start)
|
|
(setq start (1+ (match-beginning 0))))
|
|
(setq file (substring file-name start))
|
|
(setq tmp-file (concat gnus-uu-work-dir file))
|
|
(if (string= tmp-file file-name)
|
|
()
|
|
(rename-file file-name tmp-file t)
|
|
(setq file-name tmp-file))
|
|
|
|
(setq command (gnus-uu-command action file-name))
|
|
(setq command (format "%s ; rm -f %s" command file-name))
|
|
(message "Viewing with %s" command)
|
|
(start-process "gnus-uu-view" nil "sh" "-c" command)
|
|
t))
|
|
|
|
; `gnus-uu-decode-and-strip' does all the main work. It finds out what
|
|
; articles to grab, grabs them, strips the result and decodes. If any
|
|
; of these operations fail, it returns nil, t otherwise. If shar is
|
|
; t, it will pass this on to `gnus-uu-grab-articles', which will
|
|
; (probably) unshar the articles. If use-marked is non-nil, it won't
|
|
; try to find articles, but use the marked list.
|
|
(defun gnus-uu-decode-and-strip (&optional shar use-marked limit)
|
|
(let (list-of-articles)
|
|
(save-excursion
|
|
|
|
(if use-marked
|
|
(if (not gnus-uu-marked-article-list)
|
|
(message "No articles marked")
|
|
(setq list-of-articles (reverse gnus-uu-marked-article-list))
|
|
(setq gnus-uu-marked-article-list nil))
|
|
(setq list-of-articles (gnus-uu-get-list-of-articles)))
|
|
|
|
(and list-of-articles
|
|
(gnus-uu-grab-articles
|
|
list-of-articles
|
|
(if shar 'gnus-uu-unshar-article 'gnus-uu-uustrip-article-as)
|
|
t limit)))))
|
|
|
|
; Takes a string and puts a \ in front of every special character;
|
|
; ignores any leading "version numbers" thingies that they use in the
|
|
; comp.binaries groups, and either replaces anything that looks like
|
|
; "2/3" with "[0-9]+/[0-9]+" or, if it can't find something like that,
|
|
; replaces the last two numbers with "[0-9]+". This, in my experience,
|
|
; should get most postings of a series."
|
|
(defun gnus-uu-reginize-string (string)
|
|
(let ((count 2)
|
|
(vernum "v[0-9]+[a-z][0-9]+:")
|
|
reg beg)
|
|
(save-excursion
|
|
(set-buffer (get-buffer-create gnus-uu-output-buffer-name))
|
|
(erase-buffer)
|
|
(insert (regexp-quote string))
|
|
(setq beg 1)
|
|
|
|
(setq case-fold-search nil)
|
|
(goto-char 1)
|
|
(if (looking-at vernum)
|
|
(progn
|
|
(replace-match vernum t t)
|
|
(setq beg (length vernum))))
|
|
|
|
(goto-char beg)
|
|
(if (re-search-forward "[ \t]*[0-9]+/[0-9]+" nil t)
|
|
(replace-match " [0-9]+/[0-9]+")
|
|
|
|
(goto-char beg)
|
|
(if (re-search-forward "[0-9]+[ \t]*of[ \t]*[0-9]+" nil t)
|
|
(replace-match "[0-9]+ of [0-9]+")
|
|
|
|
(end-of-line)
|
|
(while (and (re-search-backward "[0-9]" nil t) (> count 0))
|
|
(while (and
|
|
(looking-at "[0-9]")
|
|
(< 1 (goto-char (1- (point))))))
|
|
(re-search-forward "[0-9]+" nil t)
|
|
(replace-match "[0-9]+")
|
|
(backward-char 5)
|
|
(setq count (1- count)))))
|
|
|
|
(goto-char beg)
|
|
(while (re-search-forward "[ \t]+" nil t)
|
|
(replace-match "[ \t]*" t t))
|
|
|
|
(buffer-substring 1 (point-max)))))
|
|
|
|
; Finds all articles that matches the regular expression given.
|
|
; Returns the resulting list. SUBJECT is the regular expression to be
|
|
; matched. If it is nil, the current article name will be used. If
|
|
; MARK-ARTICLES is non-nil, articles found are marked. If ONLY-UNREAD
|
|
; is non-nil, only unread articles are chose. If DO-NOT-TRANSLATE is
|
|
; non-nil, article names are not equialized before sorting.
|
|
(defun gnus-uu-get-list-of-articles (&optional subject mark-articles only-unread do-not-translate)
|
|
(let (beg end reg-subject list-of-subjects list-of-numbers art-num)
|
|
(save-excursion
|
|
|
|
; If the subject is not given, this function looks at the current subject
|
|
; and takes that.
|
|
|
|
(if subject
|
|
(setq reg-subject subject)
|
|
(end-of-line)
|
|
(setq end (point))
|
|
(beginning-of-line)
|
|
(if (not (re-search-forward "\\] " end t))
|
|
(progn (message "No valid subject chosen") (sit-for 2))
|
|
(setq subject (buffer-substring (point) end))
|
|
(setq reg-subject
|
|
(concat "\\[.*\\] " (gnus-uu-reginize-string subject)))))
|
|
|
|
; (message reg-subject)(sleep-for 2)
|
|
|
|
(if reg-subject
|
|
(progn
|
|
|
|
; Collect all subjects matching reg-subject.
|
|
|
|
(let ((case-fold-search t))
|
|
(goto-char 1)
|
|
(while (re-search-forward reg-subject nil t)
|
|
(beginning-of-line)
|
|
(setq beg (point))
|
|
(if (or (not only-unread) (looking-at " \\|-"))
|
|
(progn
|
|
(end-of-line)
|
|
(setq list-of-subjects (cons
|
|
(buffer-substring beg (point))
|
|
list-of-subjects)))
|
|
(end-of-line))))
|
|
|
|
; Expand all numbers in all the subjects: (hi9 -> hi0009, etc).
|
|
|
|
(setq list-of-subjects (gnus-uu-expand-numbers
|
|
list-of-subjects
|
|
(not do-not-translate)))
|
|
|
|
; Sort the subjects.
|
|
|
|
(setq list-of-subjects (sort list-of-subjects 'gnus-uu-string<))
|
|
|
|
; Get the article numbers from the sorted list of subjects.
|
|
|
|
(while list-of-subjects
|
|
(setq art-num (gnus-uu-article-number (car list-of-subjects)))
|
|
(if mark-articles (gnus-summary-mark-as-read art-num ?#))
|
|
(setq list-of-numbers (cons art-num list-of-numbers))
|
|
(setq list-of-subjects (cdr list-of-subjects)))
|
|
|
|
(setq list-of-numbers (nreverse list-of-numbers))))
|
|
|
|
list-of-numbers)))
|
|
|
|
; Takes a list of strings and "expands" all numbers in all the
|
|
; strings. That is, this function makes all numbers equal length by
|
|
; prepending lots of zeroes before each number. This is to ease later
|
|
; sorting to find out what sequence the articles are supposed to be
|
|
; decoded in. Returns the list of expanded strings.
|
|
(defun gnus-uu-expand-numbers (string-list &optional translate)
|
|
(let (string out-list pos num)
|
|
(save-excursion
|
|
(set-buffer (get-buffer-create gnus-uu-output-buffer-name))
|
|
(while string-list
|
|
(erase-buffer)
|
|
(setq string (car string-list))
|
|
(setq string-list (cdr string-list))
|
|
(insert string)
|
|
(goto-char 1)
|
|
(while (re-search-forward "[ \t]+" nil t)
|
|
(replace-match " "))
|
|
(goto-char 1)
|
|
(if translate
|
|
(while (re-search-forward "[A-Za-z]" nil t)
|
|
(replace-match "a" t t)))
|
|
|
|
(goto-char 1)
|
|
(if (not (search-forward "] " nil t))
|
|
()
|
|
(while (re-search-forward "[0-9]+" nil t)
|
|
(replace-match
|
|
(format "%06d"
|
|
(string-to-int (buffer-substring
|
|
(match-beginning 0) (match-end 0))))))
|
|
(setq string (buffer-substring 1 (point-max)))
|
|
(setq out-list (cons string out-list)))))
|
|
out-list))
|
|
|
|
; Used in a sort for finding out what string is bigger, but ignoring
|
|
; everything before the subject part.
|
|
(defun gnus-uu-string< (string1 string2)
|
|
(string< (substring string1 (string-match "\\] " string1))
|
|
(substring string2 (string-match "\\] " string2))))
|
|
|
|
|
|
;; gnus-uu-grab-article
|
|
;
|
|
; This is the general multi-article treatment function. It takes a
|
|
; list of articles to be grabbed and a function to apply to each
|
|
; article. It puts the result in `gnus-uu-result-buffer'.
|
|
;
|
|
; The function to be called should take two parameters. The first
|
|
; parameter is the article buffer. The function should leave the
|
|
; result, if any, in this buffer. This result is then appended on to
|
|
; the `gnus-uu-result-buffer'. Most treatment functions will just
|
|
; generate files...
|
|
;
|
|
; The second parameter is the state of the list of articles, and can
|
|
; have four values: `first', `middle', `last' and `first-and-last'.
|
|
;
|
|
; The function should return a list. The list may contain the
|
|
; following symbols:
|
|
; `error' if an error occurred
|
|
; `begin' if the beginning of an encoded file has been received
|
|
; If the list returned contains a `begin', the first element of
|
|
; the list *must* be a string with the file name of the decoded
|
|
; file.
|
|
; `end' if the the end of an encoded file has been received
|
|
; `middle' if the article was a body part of an encoded file
|
|
; `wrong-type' if the article was not a part of an encoded file
|
|
; `ok', which can be used everything is ok
|
|
|
|
(defvar gnus-uu-has-been-grabbed nil)
|
|
|
|
(defun gnus-uu-unmark-list-of-grabbed (&optional dont-unmark-last-article)
|
|
(let (art)
|
|
(if (not (and gnus-uu-has-been-grabbed
|
|
gnus-uu-unmark-articles-not-decoded))
|
|
()
|
|
(if dont-unmark-last-article
|
|
(progn
|
|
(setq art (car gnus-uu-has-been-grabbed))
|
|
(setq gnus-uu-has-been-grabbed (cdr gnus-uu-has-been-grabbed))))
|
|
(while gnus-uu-has-been-grabbed
|
|
(gnus-summary-mark-as-unread (car gnus-uu-has-been-grabbed) t)
|
|
(setq gnus-uu-has-been-grabbed (cdr gnus-uu-has-been-grabbed)))
|
|
(if dont-unmark-last-article
|
|
(setq gnus-uu-has-been-grabbed (list art))))))
|
|
|
|
|
|
; This function takes a list of articles and a function to apply to
|
|
; each article grabbed. The result of the function is appended on to
|
|
; `gnus-uu-result-buffer'.
|
|
;
|
|
; 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 (list-of-articles process-function &optional sloppy limit)
|
|
(let ((result-buffer (get-buffer-create gnus-uu-result-buffer))
|
|
(state 'first)
|
|
(wrong-type t)
|
|
has-been-begin has-been-end
|
|
article result-file result-files process-state)
|
|
|
|
(save-excursion
|
|
(set-buffer result-buffer)
|
|
(erase-buffer))
|
|
(setq gnus-uu-has-been-grabbed nil)
|
|
|
|
(while (and list-of-articles
|
|
(not (memq 'error process-state))
|
|
(or sloppy
|
|
(not (memq 'end process-state))))
|
|
|
|
(setq article (car list-of-articles))
|
|
(setq list-of-articles (cdr list-of-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 list-of-articles ())
|
|
(if (eq state 'first)
|
|
(setq state 'first-and-last)
|
|
(setq state 'last)))
|
|
|
|
(message "Getting article %d" article)
|
|
(if (not (= (or gnus-current-article 0) article))
|
|
(gnus-summary-display-article article))
|
|
(gnus-summary-mark-as-read article)
|
|
|
|
(save-excursion (set-buffer gnus-article-buffer) (widen))
|
|
|
|
(setq process-state (funcall process-function gnus-article-buffer state))
|
|
|
|
; (message "process-state er %s" process-state)(sleep-for 3)
|
|
|
|
(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 (file-exists-p result-file) (delete-file result-file)))
|
|
(setq result-file (car process-state))
|
|
(setq has-been-begin t)
|
|
(setq has-been-end nil)))
|
|
|
|
(if (memq 'end process-state)
|
|
(progn
|
|
(setq gnus-uu-has-been-grabbed nil)
|
|
(setq result-files (cons result-file result-files))
|
|
(setq has-been-end t)
|
|
(setq has-been-begin nil)
|
|
(if (and limit (= (length result-files) limit))
|
|
(progn
|
|
(setq list-of-articles nil)
|
|
(setq gnus-uu-marked-article-list 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)))
|
|
|
|
(setq result-file nil)
|
|
|
|
(if (not (memq 'wrong-type process-state))
|
|
(setq wrong-type nil)
|
|
(if gnus-uu-unmark-articles-not-decoded
|
|
(gnus-summary-mark-as-unread article t)))
|
|
|
|
(if sloppy (setq wrong-type nil))
|
|
|
|
(if (and (not has-been-begin)
|
|
(not sloppy)
|
|
(or (memq 'end process-state)
|
|
(memq 'middle process-state)))
|
|
(progn
|
|
(setq process-state (list 'error))
|
|
(message "No begin part at the beginning")
|
|
(sleep-for 2))
|
|
(setq state 'middle)))
|
|
|
|
(if result-files
|
|
()
|
|
(if (not has-been-begin)
|
|
(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
|
|
(message "End of articles reached before end of file")
|
|
(setq result-files nil))
|
|
(gnus-uu-unmark-list-of-grabbed)))))
|
|
(setq gnus-uu-list-of-files-decoded result-files)
|
|
result-files))
|
|
|
|
(defun gnus-uu-uudecode-sentinel (process event)
|
|
(delete-process (get-process process)))
|
|
|
|
; Uudecodes a file asynchronously.
|
|
(defun gnus-uu-uustrip-article-as (process-buffer in-state)
|
|
(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))
|
|
|
|
(goto-char 1)
|
|
|
|
(if gnus-uu-kill-carriage-return
|
|
(progn
|
|
(while (search-forward "\r" nil t)
|
|
(delete-backward-char 1))
|
|
(goto-char 1)))
|
|
|
|
(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))
|
|
|
|
; Replace any slashes and spaces in file names before decoding
|
|
(goto-char (setq name-beg (match-beginning 1)))
|
|
(while (re-search-forward "/" name-end t)
|
|
(replace-match ","))
|
|
(goto-char name-beg)
|
|
(while (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))))
|
|
(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))
|
|
|
|
(re-search-backward
|
|
(concat gnus-uu-body-line "\\|" gnus-uu-end-string) nil t)
|
|
(beginning-of-line)
|
|
|
|
(if (looking-at gnus-uu-end-string)
|
|
(setq state (cons 'end state)))
|
|
(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 err
|
|
(process-send-region gnus-uu-uudecode-process
|
|
start-char (point))
|
|
(error
|
|
(progn
|
|
(message "gnus-uu: Couldn't uudecode")
|
|
(sleep-for 2)
|
|
(setq state (list 'wrong-type))
|
|
(delete-process gnus-uu-uudecode-process))))
|
|
(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)))))
|
|
|
|
(if (memq 'begin state)
|
|
(cons (concat gnus-uu-work-dir gnus-uu-file-name) state)
|
|
state))))
|
|
|
|
; This function is used by `gnus-uu-grab-articles' to treat
|
|
; a shared article.
|
|
(defun gnus-uu-unshar-article (process-buffer in-state)
|
|
(let ((state (list 'ok))
|
|
start-char)
|
|
(save-excursion
|
|
(set-buffer process-buffer)
|
|
(goto-char 1)
|
|
(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-shar-directory " ; sh"))))
|
|
state))
|
|
|
|
; Returns the name of what the shar file is going to unpack.
|
|
(defun gnus-uu-find-name-in-shar ()
|
|
(let ((oldpoint (point))
|
|
res)
|
|
(goto-char 1)
|
|
(if (re-search-forward gnus-uu-shar-name-marker nil t)
|
|
(setq res (buffer-substring (match-beginning 1) (match-end 1))))
|
|
(goto-char oldpoint)
|
|
res))
|
|
|
|
; Returns the article number of the given subject.
|
|
(defun gnus-uu-article-number (subject)
|
|
(let (end)
|
|
(string-match "[0-9]+[^0-9]" subject 1)
|
|
(setq end (match-end 0))
|
|
(string-to-int
|
|
(substring subject (string-match "[0-9]" subject 1) end))))
|
|
|
|
; `gnus-uu-choose-action' chooses what action to perform given the name
|
|
; and `gnus-uu-file-action-list'. Returns either nil if no action is
|
|
; 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))
|
|
rule action)
|
|
(and
|
|
(or no-ignore
|
|
(and (not
|
|
(and gnus-uu-ignore-files-by-name
|
|
(string-match gnus-uu-ignore-files-by-name file-name)))
|
|
(not
|
|
(and gnus-uu-ignore-files-by-type
|
|
(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))
|
|
(setq rule (car action-list))
|
|
(setq action-list (cdr action-list))
|
|
(if (string-match (car rule) file-name)
|
|
(setq action (car (cdr rule))))))
|
|
action))
|
|
|
|
(defun gnus-uu-save-directory (from-dir &optional default-dir ignore-existing)
|
|
(let (dir file-name command files file)
|
|
(setq files (directory-files from-dir t))
|
|
(if default-dir
|
|
(setq dir default-dir)
|
|
(setq dir (gnus-uu-read-directory
|
|
(concat "Where do you want the file"
|
|
(if (< 3 (length files)) "s" "") "? "))))
|
|
|
|
(while files
|
|
(setq file (car files))
|
|
(setq files (cdr files))
|
|
(string-match "/[^/]*$" file)
|
|
(setq file-name (substring file (1+ (match-beginning 0))))
|
|
(if (string-match "^\\.\\.?$" file-name)
|
|
()
|
|
(if (and (not ignore-existing) (file-exists-p (concat dir file-name)))
|
|
(setq file-name
|
|
(read-file-name "File exists. Enter a new name: " dir
|
|
(concat dir file-name) nil file-name))
|
|
(setq file-name (concat dir file-name)))
|
|
(rename-file file file-name t)))))
|
|
|
|
; Moves the file from the tmp directory to where the user wants it.
|
|
(defun gnus-uu-save-file (from-file-name &optional default-dir ignore-existing)
|
|
(let (dir file-name command)
|
|
(string-match "/[^/]*$" from-file-name)
|
|
(setq file-name (substring from-file-name (1+ (match-beginning 0))))
|
|
(if default-dir
|
|
(setq dir default-dir)
|
|
(setq dir (gnus-uu-read-directory "Where do you want the file? ")))
|
|
(if (and (not ignore-existing) (file-exists-p (concat dir file-name)))
|
|
(setq file-name
|
|
(read-file-name "File exist. Enter a new name: " dir
|
|
(concat dir file-name) nil file-name))
|
|
(setq file-name (concat dir file-name)))
|
|
(rename-file from-file-name file-name t)))
|
|
|
|
(defun gnus-uu-read-directory (prompt &optional default)
|
|
(let (dir ok create)
|
|
(while (not ok)
|
|
(setq ok t)
|
|
(setq dir (if default default
|
|
(read-file-name prompt gnus-uu-current-save-dir
|
|
gnus-uu-current-save-dir)))
|
|
(while (string-match "/$" dir)
|
|
(setq dir (substring dir 0 (match-beginning 0))))
|
|
(if (file-exists-p dir)
|
|
(if (not (file-directory-p dir))
|
|
(progn
|
|
(setq ok nil)
|
|
(message "%s is a file" dir)
|
|
(sit-for 2)))
|
|
(setq create ?o)
|
|
(while (not (or (= create ?y) (= create ?n)))
|
|
(message "%s: No such directory. Do you want to create it? (y/n)"
|
|
dir)
|
|
(setq create (read-char)))
|
|
(if (= create ?y) (make-directory dir))))
|
|
(setq gnus-uu-current-save-dir (concat dir "/"))))
|
|
|
|
; Unpacks an archive and views all the files in it. Returns t if
|
|
; viewing one or more files is successful.
|
|
(defun gnus-uu-treat-archive (file-path)
|
|
(let ((did-unpack t)
|
|
action command files file file-name dir)
|
|
(setq action (gnus-uu-choose-action
|
|
file-path (append gnus-uu-user-archive-rules
|
|
(if gnus-uu-ignore-default-archive-rules
|
|
nil
|
|
gnus-uu-default-archive-rules))))
|
|
|
|
(if (not action) (error "No unpackers for the file %s" file-path))
|
|
|
|
(string-match "/[^/]*$" file-path)
|
|
(setq file-name (substring file-path (1+ (match-beginning 0))))
|
|
(setq dir (substring file-path 0 (match-beginning 0)))
|
|
|
|
(if (gnus-uu-string-in-list action gnus-uu-destructive-archivers)
|
|
(copy-file file-path (concat file-path "~") t))
|
|
|
|
(setq command (format "cd %s ; %s" dir (gnus-uu-command action file-path)))
|
|
|
|
(save-excursion
|
|
(set-buffer (get-buffer-create gnus-uu-output-buffer-name))
|
|
(erase-buffer))
|
|
|
|
(message "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 "")
|
|
(if (not gnus-uu-use-interactive-view)
|
|
(progn
|
|
(message "Error during unpacking of archive")
|
|
(sleep-for 2)))
|
|
(setq did-unpack nil))
|
|
|
|
(if (gnus-uu-string-in-list action gnus-uu-destructive-archivers)
|
|
(rename-file (concat file-path "~") file-path t))
|
|
|
|
did-unpack))
|
|
|
|
; Tries to view all the files in the given directory. Returns t if
|
|
; viewing one or more files is successful.
|
|
(defun gnus-uu-view-directory (dir &optional dont-delete-files not-top)
|
|
(let ((first t)
|
|
files file did-view ignore-files)
|
|
(setq files (directory-files dir t "[^/][^\\.][^\\.]?$"))
|
|
(gnus-uu-add-file files)
|
|
(setq ignore-files files)
|
|
|
|
(while (gnus-uu-unpack-archives
|
|
files (if not-top (list ".")
|
|
(if first () ignore-files)))
|
|
(setq first nil)
|
|
(gnus-uu-add-file
|
|
(setq files (directory-files dir t "[^/][^\\.][^\\.]?$"))))
|
|
|
|
(gnus-uu-add-file (directory-files dir t "[^/][^\\.][^\\.]?$"))
|
|
|
|
(while files
|
|
(setq file (car files))
|
|
(setq files (cdr files))
|
|
(if (not (string= (or (gnus-uu-get-action file) "") "gnus-uu-archive"))
|
|
(progn
|
|
(set-file-modes file 448)
|
|
(if (file-directory-p file)
|
|
(setq did-view (or (gnus-uu-view-directory file
|
|
dont-delete-files
|
|
t)
|
|
did-view))
|
|
(setq did-view (or (gnus-uu-view-file file t) did-view)))))
|
|
(if (and (not dont-delete-files) (not gnus-uu-asynchronous)
|
|
(file-exists-p file))
|
|
(delete-file file)))
|
|
|
|
(if (and (not gnus-uu-asynchronous) (not dont-delete-files))
|
|
(if (string-match "/$" dir)
|
|
(delete-directory (substring dir 0 (match-beginning 0)))
|
|
(delete-directory dir)))
|
|
did-view))
|
|
|
|
(defun gnus-uu-unpack-archives (files &optional ignore)
|
|
(let (path did-unpack)
|
|
(while files
|
|
(setq path (car files))
|
|
(setq files (cdr files))
|
|
(if (not (gnus-uu-string-in-list path ignore))
|
|
(if (string= (or (gnus-uu-get-action
|
|
(gnus-uu-name-from-path path)) "")
|
|
"gnus-uu-archive")
|
|
(progn
|
|
(if (and (not (setq did-unpack (gnus-uu-treat-archive path)))
|
|
gnus-uu-use-interactive-view)
|
|
(gnus-uu-enter-interactive-file
|
|
"# error during unpacking of" path))
|
|
(if ignore (delete-file path))))))
|
|
did-unpack))
|
|
|
|
|
|
;; Manual marking
|
|
|
|
(defun gnus-uu-enter-mark-in-list ()
|
|
(let (article beg)
|
|
(save-excursion
|
|
(beginning-of-line)
|
|
(setq beg (point))
|
|
(end-of-line)
|
|
(setq article (gnus-uu-article-number
|
|
(buffer-substring beg (point))))
|
|
(message "Adding article %d to list" article)
|
|
(setq gnus-uu-marked-article-list
|
|
(cons article gnus-uu-marked-article-list)))))
|
|
|
|
(defun gnus-uu-mark-article (&optional dont-move)
|
|
"Marks the current article to be decoded later."
|
|
(interactive)
|
|
(gnus-uu-enter-mark-in-list)
|
|
(gnus-summary-mark-as-read nil ?#)
|
|
(gnus-summary-next-subject 1 nil))
|
|
|
|
(defun gnus-uu-unmark-article ()
|
|
"Unmarks the current article."
|
|
(interactive)
|
|
(let ((in (copy-sequence gnus-uu-marked-article-list))
|
|
out article beg found
|
|
(old-point (point)))
|
|
(beginning-of-line)
|
|
(setq beg (point))
|
|
(end-of-line)
|
|
(setq article (gnus-uu-article-number (buffer-substring beg (point))))
|
|
(message "Removing article %d" article)
|
|
(while in
|
|
(if (not (= (car in) article))
|
|
(setq out (cons (car in) out))
|
|
(setq found t)
|
|
(message "Removing article %d" article))
|
|
(setq in (cdr in)))
|
|
(if (not found) (message "Not a marked article."))
|
|
(setq gnus-uu-marked-article-list (reverse out))
|
|
(gnus-summary-mark-as-unread nil t)
|
|
(gnus-summary-next-subject 1 nil)))
|
|
|
|
(defun gnus-uu-unmark-all-articles ()
|
|
"Removes the mark from all articles marked for decoding."
|
|
(interactive)
|
|
(while gnus-uu-marked-article-list
|
|
(gnus-summary-goto-subject (car gnus-uu-marked-article-list))
|
|
(gnus-summary-mark-as-unread nil t)
|
|
(setq gnus-uu-marked-article-list (cdr gnus-uu-marked-article-list))))
|
|
|
|
(defun gnus-uu-mark-by-regexp ()
|
|
"Asks for a regular expression and marks all articles that match."
|
|
(interactive)
|
|
(let (exp)
|
|
(setq exp (read-from-minibuffer "Mark (regexp): "))
|
|
(setq gnus-uu-marked-article-list
|
|
(append gnus-uu-marked-article-list
|
|
(reverse (gnus-uu-get-list-of-articles exp t))))
|
|
(message "")))
|
|
|
|
(defun gnus-uu-mark-thread ()
|
|
"Marks all articles downwards in this thread."
|
|
(interactive)
|
|
(beginning-of-line)
|
|
(let (level)
|
|
(if (not (search-forward ":" nil t))
|
|
()
|
|
(setq level (current-column))
|
|
(gnus-uu-enter-mark-in-list)
|
|
(gnus-summary-mark-as-read nil ?#)
|
|
(gnus-summary-search-forward)
|
|
(while (< level (current-column))
|
|
(gnus-uu-enter-mark-in-list)
|
|
(gnus-summary-mark-as-read nil ?#)
|
|
(gnus-summary-search-forward))
|
|
(gnus-summary-search-backward))))
|
|
|
|
|
|
;; Various stuff
|
|
|
|
(defun gnus-uu-string-in-list (string list)
|
|
(while (and list
|
|
(not (string= (car list) string))
|
|
(setq list (cdr list))))
|
|
list)
|
|
|
|
(defun gnus-uu-name-from-path (path)
|
|
(string-match "/[^/]*$" path)
|
|
(substring path (1+ (match-beginning 0))))
|
|
|
|
(defun gnus-uu-directory-files (dir)
|
|
(let (files out file)
|
|
(setq files (directory-files dir t))
|
|
(while files
|
|
(setq file (car files))
|
|
(setq files (cdr files))
|
|
(if (not (string-match "/\\.\\.?$" file))
|
|
(setq out (cons file out))))
|
|
(setq out (reverse out))
|
|
out))
|
|
|
|
(defun gnus-uu-check-correct-stripped-uucode (start end)
|
|
(let (found beg length short)
|
|
(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)
|
|
(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))))))
|
|
|
|
(defun gnus-uu-initialize ()
|
|
(setq gnus-uu-highest-article-number 1)
|
|
(gnus-uu-check-for-generated-files)
|
|
(setq gnus-uu-tmp-dir (expand-file-name gnus-uu-tmp-dir))
|
|
(if (string-match "[^/]$" gnus-uu-tmp-dir)
|
|
(setq gnus-uu-tmp-dir (concat 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
|
|
(concat gnus-uu-tmp-dir (make-temp-name "gnus")))
|
|
(gnus-uu-add-file gnus-uu-work-dir)
|
|
(if (not (file-directory-p gnus-uu-work-dir))
|
|
(make-directory gnus-uu-work-dir))
|
|
(setq gnus-uu-work-dir (concat gnus-uu-work-dir "/"))
|
|
(setq gnus-uu-interactive-file-list nil))
|
|
|
|
; Kills the temporary uu buffers, kills any processes, etc.
|
|
(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)))
|
|
(and (not gnus-uu-asynchronous)
|
|
(setq buf (get-buffer gnus-uu-output-buffer-name))
|
|
(kill-buffer buf))
|
|
(and (setq buf (get-buffer gnus-uu-result-buffer))
|
|
(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))))
|
|
|
|
; Go to the next unread subject. If there is no further unread
|
|
; subjects, go to the last subject in the buffer.
|
|
(defun gnus-uu-summary-next-subject ()
|
|
(let (opi)
|
|
(if (not (gnus-summary-search-forward t))
|
|
(progn
|
|
(goto-char 1)
|
|
(sit-for 0)
|
|
(gnus-summary-goto-subject gnus-uu-highest-article-number)))
|
|
|
|
; You may well find all this a bit puzzling - so do I, but I seem
|
|
; to have to do something like this to move to the next unread article,
|
|
; as `sit-for' seems to do some rather strange things here. Might
|
|
; be a bug in my head, probably.
|
|
(setq opi (point))
|
|
(sit-for 0)
|
|
(goto-char opi)
|
|
(gnus-summary-recenter)))
|
|
|
|
; Inputs an action and a file and returns a full command, putting
|
|
; ticks round the file name and escaping any ticks in the file name.
|
|
(defun gnus-uu-command (action file)
|
|
(let ((ofile ""))
|
|
(while (string-match "`\\|\"\\|\\$\\|\\\\" file)
|
|
(progn
|
|
(setq ofile
|
|
(concat ofile (substring file 0 (match-beginning 0)) "\\"
|
|
(substring file (match-beginning 0) (match-end 0))))
|
|
(setq file (substring file (1+ (match-beginning 0))))))
|
|
(setq ofile (concat "\"" ofile file "\""))
|
|
(if (string-match "%s" action)
|
|
(format action ofile)
|
|
(concat action " " ofile))))
|
|
|
|
|
|
;; Initializing
|
|
(add-hook 'gnus-exit-group-hook
|
|
'(lambda ()
|
|
(gnus-uu-clean-up)
|
|
(setq gnus-uu-marked-article-list nil)
|
|
(gnus-uu-check-for-generated-files)))
|
|
|
|
|
|
;; Interactive exec mode
|
|
|
|
(defvar gnus-uu-output-window nil)
|
|
(defvar gnus-uu-mode-hook nil)
|
|
|
|
(defvar gnus-uu-mode-map nil)
|
|
(if gnus-uu-mode-map
|
|
()
|
|
(setq gnus-uu-mode-map (make-sparse-keymap))
|
|
(define-key gnus-uu-mode-map "\C-c\C-x" 'gnus-uu-interactive-execute)
|
|
(define-key gnus-uu-mode-map "\C-c\C-v" 'gnus-uu-interactive-execute)
|
|
(define-key gnus-uu-mode-map "\C-m" 'gnus-uu-interactive-execute)
|
|
(define-key gnus-uu-mode-map "\C-c\C-c" 'gnus-uu-interactive-end)
|
|
(define-key gnus-uu-mode-map "\C-c\C-z"
|
|
'gnus-uu-interactive-save-current-file)
|
|
(define-key gnus-uu-mode-map "\C-c\C-s"
|
|
'gnus-uu-interactive-save-current-file-silent)
|
|
(define-key gnus-uu-mode-map "\C-c\C-w" 'gnus-uu-interactive-save-all-files)
|
|
(define-key gnus-uu-mode-map "\C-c\C-o" 'gnus-uu-interactive-save-original-file)
|
|
(define-key gnus-uu-mode-map "\C-c\C-r" 'gnus-uu-interactive-rescan-directory)
|
|
(define-key gnus-uu-mode-map "\C-c\C-d" 'gnus-uu-interactive-scan-directory)
|
|
)
|
|
|
|
(defun gnus-uu-interactive-set-up-windows ()
|
|
(let (int-buf out-buf)
|
|
(set-buffer
|
|
(setq int-buf (get-buffer-create gnus-uu-interactive-buffer-name)))
|
|
(if (not (get-buffer-window int-buf))
|
|
(switch-to-buffer-other-window int-buf))
|
|
(pop-to-buffer int-buf)
|
|
(setq out-buf (get-buffer-create gnus-uu-output-buffer-name))
|
|
(if (not (get-buffer-window out-buf))
|
|
(progn
|
|
(setq gnus-uu-output-window
|
|
(split-window nil (- (window-height)
|
|
gnus-uu-output-window-height)))
|
|
(set-window-buffer gnus-uu-output-window out-buf)))))
|
|
|
|
(defun gnus-uu-do-interactive (&optional dont-do-windows)
|
|
(if (not gnus-uu-interactive-file-list)
|
|
(gnus-uu-enter-interactive-file "#" ""))
|
|
(if (not dont-do-windows) (gnus-uu-interactive-set-up-windows))
|
|
(save-excursion
|
|
(set-buffer (get-buffer-create gnus-uu-output-buffer-name))
|
|
(erase-buffer))
|
|
(set-buffer (get-buffer-create gnus-uu-interactive-buffer-name))
|
|
(goto-char 1)
|
|
(forward-line 3)
|
|
(run-hooks 'gnus-uu-mode-hook))
|
|
|
|
(defun gnus-uu-enter-interactive-file (action file)
|
|
(let (command)
|
|
(save-excursion
|
|
(set-buffer (get-buffer-create gnus-uu-interactive-buffer-name))
|
|
(if (not gnus-uu-interactive-file-list)
|
|
(progn
|
|
(erase-buffer)
|
|
(gnus-uu-mode)
|
|
(insert
|
|
"# Press return to execute a command.
|
|
# Press `C-c C-c' to exit interactive view.
|
|
|
|
")))
|
|
(setq gnus-uu-interactive-file-list
|
|
(cons file gnus-uu-interactive-file-list))
|
|
; (if (string-match (concat "^" gnus-uu-work-dir) file)
|
|
; (setq file (substring file (match-end 0))))
|
|
(setq command (gnus-uu-command action file))
|
|
(goto-char (point-max))
|
|
(insert (format "%s\n" command)))))
|
|
|
|
(defun gnus-uu-interactive-execute ()
|
|
"Executes the command on the current line in interactive mode."
|
|
(interactive)
|
|
(let (beg out-buf command)
|
|
(beginning-of-line)
|
|
(setq beg (point))
|
|
(end-of-line)
|
|
(setq command (buffer-substring beg (point)))
|
|
(setq out-buf (get-buffer-create gnus-uu-output-buffer-name))
|
|
(save-excursion
|
|
(set-buffer out-buf)
|
|
(erase-buffer)
|
|
(insert (format "$ %s \n\n" command)))
|
|
(setq command (format "cd %s ; %s" gnus-uu-work-dir command))
|
|
(message "Executing...")
|
|
(if gnus-uu-asynchronous
|
|
(start-process "gnus-uu-view" out-buf "sh" "-c" command)
|
|
(call-process "sh" nil out-buf nil "-c" command)
|
|
(message ""))
|
|
(end-of-line)
|
|
(if (= (forward-line 1) 1)
|
|
(progn
|
|
(end-of-line)
|
|
(insert "\n")))
|
|
(beginning-of-line)))
|
|
|
|
(defun gnus-uu-interactive-end ()
|
|
"This function exits interactive view mode and returns to summary mode."
|
|
(interactive)
|
|
(let (buf)
|
|
(delete-window gnus-uu-output-window)
|
|
(gnus-uu-clean-up)
|
|
(if (not gnus-uu-asynchronous) (gnus-uu-check-for-generated-files))
|
|
(setq buf (get-buffer gnus-uu-interactive-buffer-name))
|
|
(if gnus-article-buffer (switch-to-buffer gnus-article-buffer))
|
|
(if buf (kill-buffer buf))
|
|
(pop-to-buffer gnus-summary-buffer)))
|
|
|
|
|
|
(defun gnus-uu-interactive-scan-directory (dir)
|
|
"Read any directory and view the files.
|
|
When used in interactive mode, the files and commands will be displayed,
|
|
as usual, in the interactive mode buffer."
|
|
(interactive "DDirectory: ")
|
|
(setq gnus-uu-interactive-file-list nil)
|
|
(gnus-uu-view-directory dir gnus-uu-use-interactive-view)
|
|
(gnus-uu-do-interactive t))
|
|
|
|
(defun gnus-uu-interactive-rescan-directory ()
|
|
"Reread the directory and view the files.
|
|
When used in interactive mode, the files and commands will be displayed,
|
|
as usual, in the interactive mode buffer."
|
|
(interactive)
|
|
(gnus-uu-interactive-scan-directory gnus-uu-work-dir))
|
|
|
|
(defun gnus-uu-interactive-save-original-file ()
|
|
"Saves the file from whence the file on the current line came from."
|
|
(interactive)
|
|
(let ((files gnus-uu-list-of-files-decoded)
|
|
(filestr "")
|
|
file did dir)
|
|
(while files
|
|
(setq file (car files))
|
|
(setq files (cdr files))
|
|
(if (file-exists-p file)
|
|
(progn
|
|
(if (not did)
|
|
(progn
|
|
(setq dir (gnus-uu-read-directory
|
|
(format "Where do you want the file%s? "
|
|
(if (> (length files) 1) "s" ""))))
|
|
(setq did t)))
|
|
(setq filestr (concat filestr (gnus-uu-name-from-path file) " "))
|
|
(gnus-uu-save-file file dir t)))
|
|
(if did
|
|
(message "Saved %s" filestr)
|
|
(message "Already saved.")))))
|
|
|
|
(defun gnus-uu-interactive-save-current-file-silent ()
|
|
"Saves the file referred to on the current line in the current directory."
|
|
(interactive)
|
|
(gnus-uu-interactive-save-current-file t))
|
|
|
|
(defun gnus-uu-interactive-save-current-file (&optional dont-ask silent)
|
|
"Saves the file referred to on the current line."
|
|
(interactive)
|
|
(let (files beg line file)
|
|
(setq files (copy-sequence gnus-uu-interactive-file-list))
|
|
(beginning-of-line)
|
|
(setq beg (point))
|
|
(end-of-line)
|
|
(setq line (buffer-substring beg (point)))
|
|
(while (and files
|
|
(not (string-match
|
|
(concat "" (regexp-quote (setq file (car files))) "")
|
|
line)))
|
|
(setq files (cdr files)))
|
|
(beginning-of-line)
|
|
(forward-line 1)
|
|
(if (not files)
|
|
(if (not silent)
|
|
(progn (message "Could not find file") (sit-for 2)))
|
|
(gnus-uu-save-file file (if dont-ask gnus-uu-current-save-dir nil) silent)
|
|
(delete-region beg (point)))))
|
|
|
|
(defun gnus-uu-interactive-save-all-files ()
|
|
"Saves all files referred to in the interactive buffer."
|
|
(interactive)
|
|
(let (dir)
|
|
(goto-char 1)
|
|
(setq dir (gnus-uu-read-directory "Where do you want the files? "))
|
|
(while (not (eobp))
|
|
(gnus-uu-interactive-save-current-file t t))))
|
|
|
|
(defun gnus-uu-mode ()
|
|
"Major mode for editing view commands in gnus-uu.
|
|
|
|
Commands:
|
|
\\<gnus-uu-mode-map>Return, C-c C-v, C-c C-x Execute the current command
|
|
\\[gnus-uu-interactive-end]\tEnd interactive mode
|
|
\\[gnus-uu-interactive-save-current-file]\tSave the current file
|
|
\\[gnus-uu-interactive-save-current-file-silent]\tSave the current file without asking
|
|
\twhere to put it
|
|
\\[gnus-uu-interactive-save-all-files]\tSave all files
|
|
\\[gnus-uu-interactive-save-original-file]\tSave the original file: If the files
|
|
\toriginated in an archive, the archive
|
|
\tfile is saved.
|
|
\\[gnus-uu-interactive-rescan-directory]\tRescan the directory
|
|
\\[gnus-uu-interactive-scan-directory]\tScan any directory
|
|
"
|
|
(interactive)
|
|
(kill-all-local-variables)
|
|
(use-local-map gnus-uu-mode-map)
|
|
(setq mode-name "gnus-uu")
|
|
(setq major-mode 'gnus-uu-mode)
|
|
)
|
|
|
|
(define-key gnus-uu-mode-map "\C-c\C-x" 'gnus-uu-interactive-execute)
|
|
(define-key gnus-uu-mode-map "\C-c\C-v" 'gnus-uu-interactive-execute)
|
|
(define-key gnus-uu-mode-map "\C-m" 'gnus-uu-interactive-execute)
|
|
(define-key gnus-uu-mode-map "\C-c\C-c" 'gnus-uu-interactive-end)
|
|
(define-key gnus-uu-mode-map "\C-cs"
|
|
'gnus-uu-interactive-save-current-file)
|
|
(define-key gnus-uu-mode-map "\C-c\C-s"
|
|
'gnus-uu-interactive-save-current-file-silent)
|
|
(define-key gnus-uu-mode-map "\C-c\C-a" 'gnus-uu-interactive-save-all-files)
|
|
(define-key gnus-uu-mode-map "\C-c\C-o" 'gnus-uu-interactive-save-original-file)
|
|
|
|
|
|
;; Major mode for posting encoded articles.
|
|
|
|
(require 'sendmail)
|
|
(require 'rnews)
|
|
|
|
; Any function that is to be used as and encoding method will take two
|
|
; parameters: PATH-NAME and FILE-NAME. (E.g. "/home/gaga/spiral.jpg"
|
|
; and "spiral.jpg", respectively.) The function should return nil if
|
|
; the encoding wasn't successful.
|
|
(defvar gnus-uu-post-encode-method 'gnus-uu-post-encode-uuencode
|
|
"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
|
|
uuencode and adds MIME headers.")
|
|
|
|
(defvar gnus-uu-post-include-before-composing nil
|
|
"Non-nil means that gnus-uu will ask for a file to encode before you compose the article.
|
|
If this variable is t, you can either include an encoded file with
|
|
\\<gnus-uu-post-reply-mode-map>\\[gnus-uu-post-insert-binary-in-article] or have one included for you when you post the article.")
|
|
|
|
(defvar gnus-uu-post-length 990
|
|
"Maximum length of an article.
|
|
The encoded file will be split into how many articles it takes to
|
|
post the entire file.")
|
|
|
|
(defvar gnus-uu-post-threaded nil
|
|
"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
|
|
counts...) Default is nil.")
|
|
|
|
(defvar 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 t.")
|
|
|
|
(defconst 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)
|
|
|
|
; The following map and mode was taken from rnewspost.el and edited
|
|
; somewhat.
|
|
(defvar gnus-uu-post-reply-mode-map () "Mode map used by gnus-uu-post-reply.")
|
|
(or gnus-uu-post-reply-mode-map
|
|
(progn
|
|
(setq gnus-uu-post-reply-mode-map (make-keymap))
|
|
(define-key gnus-uu-post-reply-mode-map "\C-c?" 'describe-mode)
|
|
(define-key gnus-uu-post-reply-mode-map "\C-c\C-f\C-d"
|
|
'news-reply-distribution)
|
|
(define-key gnus-uu-post-reply-mode-map "\C-c\C-f\C-k"
|
|
'news-reply-keywords)
|
|
(define-key gnus-uu-post-reply-mode-map "\C-c\C-f\C-n"
|
|
'news-reply-newsgroups)
|
|
|
|
(define-key gnus-uu-post-reply-mode-map "\C-c\C-f\C-f"
|
|
'news-reply-followup-to)
|
|
(define-key gnus-uu-post-reply-mode-map "\C-c\C-f\C-s" 'mail-subject)
|
|
(define-key gnus-uu-post-reply-mode-map "\C-c\C-f\C-a"
|
|
'gnus-uu-post-reply-summary)
|
|
(define-key gnus-uu-post-reply-mode-map "\C-c\C-r"
|
|
'news-caesar-buffer-body)
|
|
(define-key gnus-uu-post-reply-mode-map "\C-c\C-w" 'news-reply-signature)
|
|
(define-key gnus-uu-post-reply-mode-map "\C-c\C-y"
|
|
'news-reply-yank-original)
|
|
(define-key gnus-uu-post-reply-mode-map "\C-c\C-q"
|
|
'mail-fill-yanked-message)
|
|
(define-key gnus-uu-post-reply-mode-map "\C-c\C-c"
|
|
'gnus-uu-post-news-inews)
|
|
(define-key gnus-uu-post-reply-mode-map "\C-c\C-s"
|
|
'gnus-uu-post-news-inews)
|
|
(define-key gnus-uu-post-reply-mode-map "\C-c\C-i"
|
|
'gnus-uu-post-insert-binary-in-article)
|
|
))
|
|
|
|
; This mode was taken from rnewspost.el and modified slightly.
|
|
(defun gnus-uu-post-reply-mode ()
|
|
"Major mode for editing binary news to be posted on USENET.
|
|
First-time posters are asked to please read the articles in newsgroup:
|
|
news.announce.newusers .
|
|
|
|
Like news-reply-mode, which is like Text Mode, but with these
|
|
additional commands:
|
|
|
|
\\<gnus-uu-post-reply-mode-map>\\[gnus-uu-post-news-inews] post the message.
|
|
C-c C-f move to a header field (and create it if there isn't):
|
|
C-c C-f C-n move to Newsgroups: C-c C-f C-s move to Subj:
|
|
C-c C-f C-f move to Followup-To: C-c C-f C-k move to Keywords:
|
|
C-c C-f C-d move to Distribution: C-c C-f C-a move to Summary:
|
|
C-c C-y news-reply-yank-original (insert current message, in NEWS).
|
|
C-c C-q mail-fill-yanked-message (fill what was yanked).
|
|
C-c C-r caesar rotate all letters by 13 places in the article's body (rot13).
|
|
\\[gnus-uu-post-insert-binary-in-article] encode and include a file in this article.
|
|
|
|
This mode is almost identical to news-reply-mode, but has some
|
|
additional commands for treating encoded binary articles. In
|
|
particular, \\[gnus-uu-post-news-inews] will ask for a file to include, if
|
|
one hasn't been included already. It will post, first, the message
|
|
composed, and then it will post as many additional articles it takes
|
|
to post the entire encoded files.
|
|
|
|
Relevant Variables
|
|
|
|
`gnus-uu-post-encode-method'
|
|
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
|
|
uuencode and adds MIME headers.
|
|
|
|
`gnus-uu-post-include-before-composing'
|
|
Non-nil means that gnus-uu will ask for a file to encode before you
|
|
compose the article. If this variable is t, you can either include
|
|
an encoded file with `C-c C-i' or have one included for you when you
|
|
post the article.
|
|
|
|
`gnus-uu-post-length'
|
|
Maximum length of an article. The encoded file will be split into how
|
|
many articles it takes to post the entire file.
|
|
|
|
`gnus-uu-post-separate-description'
|
|
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 t.
|
|
|
|
`gnus-uu-post-threaded'
|
|
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
|
|
counts...) Default is nil.
|
|
"
|
|
(interactive)
|
|
;; require...
|
|
(or (fboundp 'mail-setup) (load "sendmail"))
|
|
(kill-all-local-variables)
|
|
(make-local-variable 'mail-reply-buffer)
|
|
(setq mail-reply-buffer nil)
|
|
(set-syntax-table text-mode-syntax-table)
|
|
(use-local-map gnus-uu-post-reply-mode-map)
|
|
(setq local-abbrev-table text-mode-abbrev-table)
|
|
(setq major-mode 'gnus-uu-post-reply-mode)
|
|
(setq mode-name "Gnus UU News")
|
|
(make-local-variable 'paragraph-separate)
|
|
(make-local-variable 'paragraph-start)
|
|
(setq paragraph-start (concat mail-header-separator "$\\|"
|
|
paragraph-start))
|
|
(setq paragraph-separate (concat mail-header-separator "$\\|"
|
|
paragraph-separate))
|
|
(run-hooks 'text-mode-hook 'gnus-uu-post-reply-mode-hook))
|
|
|
|
(defun gnus-uu-post-news ()
|
|
"Compose an article and post an encoded file."
|
|
(interactive)
|
|
(setq gnus-uu-post-inserted-file-name nil)
|
|
(setq gnus-uu-winconf-post-news (current-window-configuration))
|
|
(let (news-reply-mode)
|
|
(fset 'news-reply-mode 'gnus-uu-post-reply-mode)
|
|
(gnus-summary-post-news)
|
|
(if gnus-uu-post-include-before-composing
|
|
(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)
|
|
(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))))
|
|
|
|
; Encodes with uuencode and substitutes all spaces with backticks.
|
|
(defun gnus-uu-post-encode-uuencode (path file-name)
|
|
(if (gnus-uu-post-encode-file "uuencode" path file-name)
|
|
(progn
|
|
(goto-char 1)
|
|
(forward-line 1)
|
|
(while (re-search-forward " " nil t)
|
|
(replace-match "`"))
|
|
t)))
|
|
|
|
; Encodes with uuencode and adds MIME headers.
|
|
(defun gnus-uu-post-encode-mime-uuencode (path file-name)
|
|
(if (gnus-uu-post-encode-uuencode path file-name)
|
|
(progn
|
|
(gnus-uu-post-make-mime file-name "x-uue")
|
|
t)))
|
|
|
|
; Encodes with base64 and adds MIME headers
|
|
(defun gnus-uu-post-encode-mime (path file-name)
|
|
(if (gnus-uu-post-encode-file "mmencode" path file-name)
|
|
(progn
|
|
(gnus-uu-post-make-mime file-name "base64")
|
|
t)))
|
|
|
|
; Adds MIME headers.
|
|
(defun gnus-uu-post-make-mime (file-name encoding)
|
|
(goto-char 1)
|
|
(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))
|
|
(save-restriction
|
|
(set-buffer gnus-post-news-buffer)
|
|
(goto-char 1)
|
|
(re-search-forward mail-header-separator)
|
|
(beginning-of-line)
|
|
(forward-line -1)
|
|
(narrow-to-region 1 (point))
|
|
(or (mail-fetch-field "mime-version")
|
|
(progn
|
|
(widen)
|
|
(insert "MIME-Version: 1.0\n")))
|
|
(widen)))
|
|
|
|
; 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 "sh" nil t nil "-c"
|
|
(format "%s %s %s" command path file-name))))
|
|
|
|
(defun gnus-uu-post-news-inews ()
|
|
"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)
|
|
|
|
(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 ((gnus-required-headers
|
|
(if (memq 'Message-ID gnus-required-headers)
|
|
gnus-required-headers
|
|
(cons 'Message-ID gnus-required-headers)))
|
|
gnus-inews-article-hook elem)
|
|
|
|
(setq gnus-inews-article-hook (if (listp gnus-inews-article-hook)
|
|
gnus-inews-article-hook
|
|
(list gnus-inews-article-hook)))
|
|
(setq gnus-inews-article-hook
|
|
(cons
|
|
'(lambda ()
|
|
(save-excursion
|
|
(goto-char 1)
|
|
(if (re-search-forward "^Message-ID: \\(.*\\)$" nil t)
|
|
(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))
|
|
(gnus-uu-post-encoded file-name t))
|
|
(gnus-uu-post-encoded file-name nil)))
|
|
(setq gnus-uu-post-inserted-file-name nil)
|
|
(and 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 post-buf uubuf file-name)
|
|
|
|
(setq file-path (read-file-name
|
|
"What file do you want to encode? "))
|
|
(if (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))
|
|
|
|
(if (string-match "^~/" file-path)
|
|
(setq file-path (concat "$HOME" (substring file-path 1))))
|
|
(if (string-match "/[^/]*$" file-path)
|
|
(setq file-name (substring file-path (1+ (match-beginning 0))))
|
|
(setq file-name file-path))
|
|
|
|
(unwind-protect
|
|
(if (save-excursion
|
|
(set-buffer (setq uubuf
|
|
(get-buffer-create uuencode-buffer-name)))
|
|
(erase-buffer)
|
|
(funcall gnus-uu-post-encode-method file-path file-name))
|
|
(insert-buffer uubuf)
|
|
(error "Encoding unsuccessful"))
|
|
(kill-buffer uubuf))
|
|
file-name))
|
|
|
|
; Posts the article and all of the encoded file.
|
|
(defun gnus-uu-post-encoded (file-name &optional threaded)
|
|
(let ((send-buffer-name "*uuencode send buffer*")
|
|
(encoded-buffer-name "*encoded buffer*")
|
|
(top-string "[ cut here %s (%s %d/%d) %s gnus-uu ]")
|
|
(separator (concat mail-header-separator "\n\n"))
|
|
file uubuf length parts header i end beg
|
|
beg-line minlen buf post-buf whole-len beg-binary end-binary)
|
|
|
|
(setq post-buf (current-buffer))
|
|
|
|
(goto-char 1)
|
|
(if (not (re-search-forward
|
|
(if gnus-uu-post-separate-description
|
|
gnus-uu-post-binary-separator
|
|
mail-header-separator) nil t))
|
|
(error "Internal error: No binary/header separator"))
|
|
(beginning-of-line)
|
|
(forward-line 1)
|
|
(setq beg-binary (point))
|
|
(setq end-binary (point-max))
|
|
|
|
(save-excursion
|
|
(set-buffer (setq uubuf (get-buffer-create encoded-buffer-name)))
|
|
(erase-buffer)
|
|
(insert-buffer-substring post-buf beg-binary end-binary)
|
|
(goto-char 1)
|
|
(setq length (count-lines 1 (point-max)))
|
|
(setq parts (/ length gnus-uu-post-length))
|
|
(if (not (< (% length gnus-uu-post-length) 4))
|
|
(setq parts (1+ parts))))
|
|
|
|
(if gnus-uu-post-separate-description
|
|
(forward-line -1))
|
|
(kill-region (point) (point-max))
|
|
|
|
(goto-char 1)
|
|
(search-forward mail-header-separator nil t)
|
|
(beginning-of-line)
|
|
(setq header (buffer-substring 1 (point)))
|
|
|
|
(goto-char 1)
|
|
(if (not gnus-uu-post-separate-description)
|
|
()
|
|
(if (and (not threaded) (re-search-forward "^Subject: " nil t))
|
|
(progn
|
|
(end-of-line)
|
|
(insert (format " (0/%d)" parts))))
|
|
(gnus-inews-news))
|
|
|
|
(save-excursion
|
|
(setq i 1)
|
|
(setq beg 1)
|
|
(while (not (> i parts))
|
|
(set-buffer (get-buffer-create send-buffer-name))
|
|
(erase-buffer)
|
|
(insert header)
|
|
(if (and threaded gnus-uu-post-message-id)
|
|
(insert (format "References: %s\n" gnus-uu-post-message-id)))
|
|
(insert separator)
|
|
(setq whole-len
|
|
(- 62 (length (format top-string "" file-name i parts ""))))
|
|
(if (> 1 (setq minlen (/ whole-len 2)))
|
|
(setq minlen 1))
|
|
(setq
|
|
beg-line
|
|
(format top-string
|
|
(make-string minlen ?-)
|
|
file-name i parts
|
|
(make-string
|
|
(if (= 0 (% whole-len 2)) (1- minlen) minlen) ?-)))
|
|
|
|
(goto-char 1)
|
|
(if (not (re-search-forward "^Subject: " nil t))
|
|
()
|
|
(if (not threaded)
|
|
(progn
|
|
(end-of-line)
|
|
(insert (format " (%d/%d)" i parts)))
|
|
(if (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)
|
|
(goto-char beg)
|
|
(if (= i parts)
|
|
(goto-char (point-max))
|
|
(forward-line gnus-uu-post-length))
|
|
(if (and (= (1+ i) parts) (< (count-lines (point) (point-max)) 4))
|
|
(forward-line -4))
|
|
(setq end (point)))
|
|
(insert-buffer-substring uubuf beg end)
|
|
(insert beg-line)
|
|
(insert "\n")
|
|
(setq beg end)
|
|
(setq i (1+ i))
|
|
(goto-char 1)
|
|
(re-search-forward mail-header-separator nil t)
|
|
(beginning-of-line)
|
|
(forward-line 2)
|
|
(if (re-search-forward gnus-uu-post-binary-separator nil t)
|
|
(progn
|
|
(replace-match "")
|
|
(forward-line 1)))
|
|
(insert beg-line)
|
|
(insert "\n")
|
|
(gnus-inews-news)))
|
|
|
|
(and (setq buf (get-buffer send-buffer-name))
|
|
(kill-buffer buf))
|
|
(and (setq buf (get-buffer encoded-buffer-name))
|
|
(kill-buffer buf))
|
|
|
|
(if (not gnus-uu-post-separate-description)
|
|
(progn
|
|
(set-buffer-modified-p nil)
|
|
(and (fboundp 'bury-buffer) (bury-buffer))))))
|
|
|
|
(provide 'gnus-uu)
|
|
|
|
;; gnus-uu.el ends here
|