1998-08-28 Shuhei KOBAYASHI <shuhei-k@jaist.ac.jp>
+ * lisp/gnus.el (gnus-version-number): Update to 6.8.10.
+
+ * Sync up with Gnus 5.6.41.
+
+1998-08-28 Shuhei KOBAYASHI <shuhei-k@jaist.ac.jp>
+
* lisp/gnus-i18n.el (gnus-set-summary-default-charset): Try
"qualified" newsgroup name first.
* lisp/message.el (message-fill-references): Reverted.
- * Sync up with Semi-gnus 6.8.15. (except for multi-frame code.)
+ * Sync up with Semi-gnus 6.8.15.
1998-08-23 Tatsuya Ichikawa <t-ichi@po.shiojiri.ne.jp>
+Thu Aug 27 11:03:59 1998 Lars Magne Ingebrigtsen <larsi@menja.ifi.uio.no>
+
+ * gnus.el: Gnus v5.6.41 is released.
+
+1998-08-27 Mike McEwan <mike@lotusland.demon.co.uk>
+
+ * gnus-agent.el (gnus-agent-fetch-group-1): Leave the calculation
+ of `articles' to `gnus-agent-fetch-headers'.
+ (gnus-agent-fetch-headers): We only want headers that are after
+ the last entry in `gnus-group-alist'.
+
+1998-08-27 09:45:42 Lars Magne Ingebrigtsen <larsi@gnus.org>
+
+ * Makefile.in (warn): New.
+
+ * gnus.el: Removed unreferenced bound variables all over.
+
+ * gnus-group.el (gnus-update-group-mark-positions): Removed topic.
+
+ * gnus-cus.el (gnus-group-customize): No part.
+
+ * gnus-agent.el (gnus-category-line-format-alist): Renamed specs.
+ (gnus-category-insert-line): Use it.
+
+Thu Aug 27 09:29:53 1998 Lars Magne Ingebrigtsen <larsi@menja.ifi.uio.no>
+
+ * gnus.el: Gnus v5.6.40 is released.
+
+1998-08-27 09:19:31 Lars Magne Ingebrigtsen <larsi@gnus.org>
+
+ * gnus-agent.el (gnus-agent-mode): Only toggle plugged in group
+ mode.
+
+1998-08-27 07:25:47 Lars Balker Rasmussen <gnort@daimi.aau.dk>
+
+ * message.el (message-supersede): Check the right headers.
+
+1998-08-26 13:51:18 Lars Magne Ingebrigtsen <larsi@gnus.org>
+
+ * gnus-sum.el (gnus-sort-threads): Changed level.
+
+1998-08-26 Mike McEwan <mike@lotusland.demon.co.uk>
+
+ * gnus-sum.el (gnus-build-all-threads): `save-excursion' and
+ `set-buffer' back to `gnus-summary-buffer' in order to access
+ buffer-local variables.
+
+1998-08-26 06:00:44 Lars Magne Ingebrigtsen <larsi@gnus.org>
+
+ * gnus-sum.el (gnus-data-compute-positions): More and faster.
+
+1998-08-26 05:41:15 Matt Pharr <mmp@Graphics.Stanford.EDU>
+
+ * message.el (message-wash-subject): Remove more.
+
+1998-08-25 11:33:28 Tatsuya Ichikawa <ichikawa@hv.epson.co.jp>
+
+ * gnus-cache.el (gnus-cache-overview-coding-system): New
+ variable.
+
+1998-08-25 08:23:05 Albert L. Ting <alt@artisan.com>
+
+ * gnus-group.el (gnus-fetch-group-other-frame): New command.
+
+1998-08-25 07:24:51 Lars Magne Ingebrigtsen <larsi@gnus.org>
+
+ * gnus-uu.el (gnus-uu-grab-articles): Check for pseudos.
+
+ * gnus-art.el (gnus-ignored-headers): More headers.
+
+ * gnus-sum.el (gnus-summary-move-article): Update the right
+ group.
+
+1998-08-23 14:31:31 Lars Magne Ingebrigtsen <larsi@gnus.org>
+
+ * gnus-art.el (gnus-ignored-headers): More headers.
+
+1998-08-23 Mike McEwan <mike@lotusland.demon.co.uk>
+
+ * gnus-agent.el (gnus-agent-copy-nov-line): Return to beginning of
+ line before next read.
+ (gnus-agent-braid-nov): Remove redundant `let'.
+
+1998-08-22 10:40:54 Lars Magne Ingebrigtsen <larsi@gnus.org>
+
+ * gnus-art.el (article-display-x-face): Allow multiple X-Faces
+ under XEmacs.
+
Sat Aug 22 10:28:25 1998 Lars Magne Ingebrigtsen <larsi@menja.ifi.uio.no>
* gnus.el: Gnus v5.6.39 is released.
all:
rm -f *.elc ; $(EMACS) $(FLAGS) -f dgnushack-compile
+warn:
+ rm -f *.elc ; $(EMACS) $(FLAGS) --eval '(dgnushack-compile t)' 2>&1 | egrep -v "variable G|inhibit-point-motion-hooks|coding-system|temp-results|variable gnus|variable nn|scroll-in-place|deactivate-mark|filladapt-mode|byte-code-function-p|print-quoted|ps-right-header|ps-left-header|article-inhibit|print-escape|ssl-program-arguments|message-log-max"
+
clever:
$(EMACS) $(FLAGS) -f dgnushack-compile
(require 'bytecomp)
(push "~/lisp/custom" load-path)
(push "." load-path)
-(load "./lpath.el")
+(load "./lpath.el" nil t)
(defalias 'device-sound-enabled-p 'ignore)
(defalias 'play-sound-file 'ignore)
(fset 'x-defined-colors 'ignore)
(fset 'read-color 'ignore)))
-(setq byte-compile-warnings
- '(free-vars unresolved callargs redefine))
-
-(defun dgnushack-compile ()
+(defun dgnushack-compile (&optional warn)
;;(setq byte-compile-dynamic t)
+ (unless warn
+ (setq byte-compile-warnings
+ '(free-vars unresolved callargs redefine)))
(unless (locate-library "cus-edit")
(error "You do not seem to have Custom installed.
Fetch it from <URL:http://www.dina.kvl.dk/~abraham/custom/>.
(push (cons mode (symbol-value (intern (format "gnus-agent-%s-mode-map"
buffer))))
minor-mode-map-alist))
- (gnus-agent-toggle-plugged gnus-plugged)
+ (when (eq major-mode 'gnus-group-mode)
+ (gnus-agent-toggle-plugged gnus-plugged))
(gnus-run-hooks 'gnus-agent-mode-hook
(intern (format "gnus-agent-%s-mode-hook" buffer)))))
;; Prune off articles that we have already fetched.
(while (and articles
(cdr (assq (car articles) gnus-agent-article-alist)))
- (pop articles))
+ (pop articles))
(let ((arts articles))
(while (cdr arts)
(if (cdr (assq (cadr arts) gnus-agent-article-alist))
(gnus-agent-group-path group) "/"))
(date (gnus-time-to-day (current-time)))
(case-fold-search t)
- pos alists crosses id elem)
+ pos crosses id elem)
(gnus-make-directory dir)
(gnus-message 7 "Fetching articles for %s..." group)
;; Fetch the articles from the backend.
(if (gnus-check-backend-function 'retrieve-articles group)
(setq pos (gnus-retrieve-articles articles group))
(nnheader-temp-write nil
- (let ((buf (current-buffer))
- article)
+ (let (article)
(while (setq article (pop articles))
(when (gnus-request-article article group)
(goto-char (point-max))
(insert "\n"))
(pop gnus-agent-group-alist))))
-(defun gnus-agent-fetch-headers (group articles &optional force)
- (gnus-agent-load-alist group)
- ;; Find out what headers we need to retrieve.
- (when articles
- (while (and articles
- (assq (car articles) gnus-agent-article-alist))
- (pop articles))
- (let ((arts articles))
- (while (cdr arts)
- (if (assq (cadr arts) gnus-agent-article-alist)
- (setcdr arts (cddr arts))
- (setq arts (cdr arts)))))
- ;; Fetch them.
- (when articles
- (gnus-message 7 "Fetching headers for %s..." group)
- (save-excursion
- (set-buffer nntp-server-buffer)
- (unless (eq 'nov (gnus-retrieve-headers articles group))
- (nnvirtual-convert-headers))
- ;;
- ;; To gnus-agent-expire work fine with no Xref field in .overview
- ;; Tatsuya Ichikawa <ichikawa@hv.epson.co.jp>
- (goto-char (point-min))
- (while (not (eobp))
- (goto-char (point-at-eol))
- (insert "\t")
- (forward-line 1))
- ;; Tatsuya Ichikawa <ichikawa@hv.epson.co.jp>
- ;; To gnus-agent-expire work fine with no Xref field in .overview
- ;;
- ;; Save these headers for later processing.
- (copy-to-buffer gnus-agent-overview-buffer (point-min) (point-max))
- (let (file)
- (when (file-exists-p
- (setq file (gnus-agent-article-name ".overview" group)))
- (gnus-agent-braid-nov group articles file))
- (gnus-make-directory (nnheader-translate-file-chars
- (file-name-directory file)))
- (write-region (point-min) (point-max) file nil 'silent)
- (gnus-agent-save-alist group articles nil)
- (gnus-agent-enter-history "last-header-fetched-for-session"
- (list (cons group (nth (- (length articles) 1) articles)))
- (gnus-time-to-day (current-time)))
- t)))))
+(defun gnus-agent-fetch-headers (group &optional force)
+ (when (gnus-agent-load-alist group)
+ (let ((articles (gnus-uncompress-range
+ (cons (1+ (caar (last (gnus-agent-load-alist group))))
+ (cdr (gnus-active group))))))
+ ;; Fetch them.
+ (when articles
+ (gnus-message 7 "Fetching headers for %s..." group)
+ (save-excursion
+ (set-buffer nntp-server-buffer)
+ (unless (eq 'nov (gnus-retrieve-headers articles group))
+ (nnvirtual-convert-headers))
+ ;; XXX: Is this still need?
+ ;; To gnus-agent-expire work fine with no Xref field in .overview
+ ;; Tatsuya Ichikawa <ichikawa@hv.epson.co.jp>
+ ;; (goto-char (point-min))
+ ;; (while (not (eobp))
+ ;; (goto-char (point-at-eol))
+ ;; (insert "\t")
+ ;; (forward-line 1))
+ ;; Save these headers for later processing.
+ (copy-to-buffer gnus-agent-overview-buffer (point-min) (point-max))
+ (let (file)
+ (when (file-exists-p
+ (setq file (gnus-agent-article-name ".overview" group)))
+ (gnus-agent-braid-nov group articles file))
+ (gnus-make-directory (nnheader-translate-file-chars
+ (file-name-directory file)))
+ (write-region (point-min) (point-max) file nil 'silent)
+ (gnus-agent-save-alist group articles nil)
+ (gnus-agent-enter-history
+ "last-header-fetched-for-session"
+ (list (cons group (nth (- (length articles) 1) articles)))
+ (gnus-time-to-day (current-time)))
+ articles))))))
(defsubst gnus-agent-copy-nov-line (article)
(let (b e)
(setq b (point))
(if (eq article (read (current-buffer)))
(setq e (progn (forward-line 1) (point)))
- (setq e b))
+ (progn
+ (beginning-of-line)
+ (setq e b)))
(set-buffer nntp-server-buffer)
(insert-buffer-substring gnus-agent-overview-buffer b e)))
(defun gnus-agent-braid-nov (group articles file)
- (let (beg end)
- (set-buffer gnus-agent-overview-buffer)
- (goto-char (point-min))
- (set-buffer nntp-server-buffer)
- (erase-buffer)
- (nnheader-insert-file-contents file)
- (goto-char (point-max))
- (if (or (= (point-min) (point-max))
- (progn
- (forward-line -1)
- (< (read (current-buffer)) (car articles))))
- ;; We have only headers that are after the older headers,
- ;; so we just append them.
- (progn
- (goto-char (point-max))
- (insert-buffer-substring gnus-agent-overview-buffer))
- ;; We do it the hard way.
- (nnheader-find-nov-line (car articles))
- (gnus-agent-copy-nov-line (car articles))
- (pop articles)
- (while (and articles
- (not (eobp)))
- (while (and (not (eobp))
- (< (read (current-buffer)) (car articles)))
- (forward-line 1))
- (beginning-of-line)
- (unless (eobp)
- (gnus-agent-copy-nov-line (car articles))
- (setq articles (cdr articles))))
- (when articles
- (let (b e)
- (set-buffer gnus-agent-overview-buffer)
- (setq b (point)
- e (point-max))
- (set-buffer nntp-server-buffer)
- (insert-buffer-substring gnus-agent-overview-buffer b e))))))
+ (set-buffer gnus-agent-overview-buffer)
+ (goto-char (point-min))
+ (set-buffer nntp-server-buffer)
+ (erase-buffer)
+ (nnheader-insert-file-contents file)
+ (goto-char (point-max))
+ (if (or (= (point-min) (point-max))
+ (progn
+ (forward-line -1)
+ (< (read (current-buffer)) (car articles))))
+ ;; We have only headers that are after the older headers,
+ ;; so we just append them.
+ (progn
+ (goto-char (point-max))
+ (insert-buffer-substring gnus-agent-overview-buffer))
+ ;; We do it the hard way.
+ (nnheader-find-nov-line (car articles))
+ (gnus-agent-copy-nov-line (car articles))
+ (pop articles)
+ (while (and articles
+ (not (eobp)))
+ (while (and (not (eobp))
+ (< (read (current-buffer)) (car articles)))
+ (forward-line 1))
+ (beginning-of-line)
+ (unless (eobp)
+ (gnus-agent-copy-nov-line (car articles))
+ (setq articles (cdr articles))))
+ (when articles
+ (let (b e)
+ (set-buffer gnus-agent-overview-buffer)
+ (setq b (point)
+ e (point-max))
+ (set-buffer nntp-server-buffer)
+ (insert-buffer-substring gnus-agent-overview-buffer b e)))))
(defun gnus-agent-load-alist (group &optional dir)
"Load the article-state alist for GROUP."
(gnus-agent-article-name ".agentview" group)))))
(defun gnus-agent-save-alist (group &optional articles state dir)
- "Load the article-state alist for GROUP."
+ "Save the article-state alist for GROUP."
(nnheader-temp-write (if dir
(concat dir ".agentview")
(gnus-agent-article-name ".agentview" group))
(let ((gnus-command-method method)
gnus-newsgroup-dependencies gnus-newsgroup-headers
gnus-newsgroup-scored gnus-headers gnus-score
- gnus-use-cache articles score arts
+ gnus-use-cache articles arts
category predicate info marks score-param)
;; Fetch headers.
(when (and (or (gnus-active group) (gnus-activate-group group))
- (setq articles (gnus-list-of-unread-articles group))
- (gnus-agent-fetch-headers group articles))
+ (setq articles (gnus-agent-fetch-headers group)))
;; Parse them and see which articles we want to fetch.
(setq gnus-newsgroup-dependencies
(make-vector (length articles) 0))
(defvar gnus-category-buffer "*Agent Category*")
(defvar gnus-category-line-format-alist
- `((?c name ?s)
- (?g groups ?d)))
+ `((?c gnus-tmp-name ?s)
+ (?g gnus-tmp-groups ?d)))
(defvar gnus-category-mode-line-format-alist
`((?u user-defined ?s)))
(defalias 'gnus-category-position-point 'gnus-goto-colon)
(defun gnus-category-insert-line (category)
- (let* ((name (car category))
- (groups (length (cadddr category))))
+ (let* ((gnus-tmp-name (car category))
+ (gnus-tmp-groups (length (cadddr category))))
(beginning-of-line)
(gnus-add-text-properties
(point)
(prog1 (1+ (point))
;; Insert the text.
(eval gnus-category-line-format-spec))
- (list 'gnus-category name))))
+ (list 'gnus-category gnus-tmp-name))))
(defun gnus-enter-category-buffer ()
"Go to the Category buffer."
"^X-MimeOLE:" "^X-MSMail-Priority:" "^X-Priority:" "^X-Loop:"
"^X-Authentication-Warning:" "^X-MIME-Autoconverted:" "^X-Face:"
"^X-Attribution:" "^X-Originating-IP:" "^Delivered-To:"
- "^NNTP-[-A-Za-z]*:" "^Distribution:" "^X-no-archive:" "^X-Trace:"
+ "^NNTP-[-A-Za-z]+:" "^Distribution:" "^X-no-archive:" "^X-Trace:"
"^X-Complaints-To:" "^X-NNTP-Posting-Host:" "^X-Orig.*:"
"^Abuse-Reports-To:" "^Cache-Post-Path:" "^X-Article-Creation-Date:"
"^X-Poster:" "^X-Mail2News-Path:" "^X-Server-Date:" "^X-Cache:"
"^Originator:" "^X-Problems-To:" "^X-Auth-User:" "^X-Post-Time:"
- "^X-Admin:" "^X-UID:")
+ "^X-Admin:" "^X-UID:" "^Resent-[-A-Za-z]+:" "^X-Mailing-List:"
+ "^Precedence:" "^Original-[-A-Za-z]+:" "^X-filename:" "^X-Orcpt:"
+ "^Old-Received:" "^X-Pgp-Fingerprint:" "^X-Pgp-Key-Id:"
+ "^X-Pgp-Public-Key-Url:" "^X-Auth:" "^X-From-Line:"
+ "^X-Gnus-Article-Number:" "^X-Majordomo:" "^X-Url:" "^X-Sender:"
+ "^X-Mailing-List:" "^MBOX-Line" "^Priority:" "^X-Pgp" "^X400-[-A-Za-z]+:"
+ "^Status:")
"*All headers that start with this regexp will be hidden.
This variable can also be a list of regexps of headers to be ignored.
If `gnus-visible-headers' is non-nil, this variable will be ignored."
(listp gnus-visible-headers))
(mapconcat 'identity gnus-visible-headers "\\|"))))
(inhibit-point-motion-hooks t)
- want-list beg)
+ beg)
;; First we narrow to just the headers.
(widen)
(goto-char (point-min))
(delete-process "article-x-face"))
(let ((inhibit-point-motion-hooks t)
(case-fold-search t)
- from)
+ from last)
(save-restriction
(nnheader-narrow-to-headers)
(setq from (message-fetch-field "from"))
(goto-char (point-min))
- ;; This used to try to do multiple faces (`while' instead of
- ;; `when' below), but (a) sending multiple EOFs to xv doesn't
- ;; work (b) it can crash some versions of Emacs (c) are
- ;; multiple faces really something to encourage?
- (when (and gnus-article-x-face-command
- (or force
- ;; Check whether this face is censored.
- (not gnus-article-x-face-too-ugly)
- (and gnus-article-x-face-too-ugly from
- (not (string-match gnus-article-x-face-too-ugly
- from))))
- ;; Has to be present.
- (re-search-forward "^X-Face: " nil t))
+ (while (and gnus-article-x-face-command
+ (not last)
+ (or force
+ ;; Check whether this face is censored.
+ (not gnus-article-x-face-too-ugly)
+ (and gnus-article-x-face-too-ugly from
+ (not (string-match gnus-article-x-face-too-ugly
+ from))))
+ ;; Has to be present.
+ (re-search-forward "^X-Face: " nil t))
+ ;; This used to try to do multiple faces (`while' instead of
+ ;; `when' above), but (a) sending multiple EOFs to xv doesn't
+ ;; work (b) it can crash some versions of Emacs (c) are
+ ;; multiple faces really something to encourage?
+ (when (stringp gnus-article-x-face-command)
+ (setq last t))
;; We now have the area of the buffer where the X-Face is stored.
(save-excursion
(let ((beg (point))
(defun gnus-article-hidden-text-p (type)
"Say whether the current buffer contains hidden text of type TYPE."
- (let ((start (point-min))
- (pos (text-property-any (point-min) (point-max) 'article-type type)))
+ (let ((pos (text-property-any (point-min) (point-max) 'article-type type)))
(while (and pos
(not (get-text-property pos 'invisible)))
(setq pos
(setq gnus-summary-buffer (current-buffer))
(let* ((gnus-article (if header (mail-header-number header) article))
(summary-buffer (current-buffer))
- (internal-hook gnus-article-internal-prepare-hook)
+ (gnus-tmp-internal-hook gnus-article-internal-prepare-hook)
(group gnus-newsgroup-name)
result)
(save-excursion
gnus-article-display-method-for-traditional)))
;; Hooks for getting information from the article.
;; This hook must be called before being narrowed.
- (gnus-run-hooks 'internal-hook)
+ (gnus-run-hooks 'gnus-tmp-internal-hook)
(gnus-run-hooks 'gnus-article-prepare-hook)
;; Display message.
(funcall method)
;; Send mail to someone
(when (string-match "mailto:/*\\(.*\\)" url)
(setq url (substring url (match-beginning 1) nil)))
- (let (to args source-url subject func)
+ (let (to args subject func)
(if (string-match (regexp-quote "?") url)
(setq to (gnus-url-unhex-string (substring url 0 (match-beginning 0)))
args (gnus-url-parse-query-string
:type '(choice (const :tag "off" nil)
regexp))
+(defvar gnus-cache-overview-coding-system 'raw-text
+ "Coding system used on Gnus cache files.")
+
\f
;;; Internal variables.
(set-buffer buffer)
(if (> (buffer-size) 0)
;; Non-empty overview, write it to a file.
- (gnus-write-buffer overview-file)
+ (let ((coding-system-for-write
+ gnus-cache-overview-coding-system))
+ (gnus-write-buffer overview-file))
;; Empty overview file, remove it
(when (file-exists-p overview-file)
(delete-file overview-file))
headers (copy-sequence headers))
(mail-header-set-number headers (cdr result))))
(let ((number (mail-header-number headers))
- file dir)
+ file)
(when (and number
(> number 0) ; Reffed article.
(or force
(not (file-exists-p (setq file (gnus-cache-file-name
group number)))))
;; Possibly create the cache directory.
- (gnus-make-directory (setq dir (file-name-directory file)))
+ (gnus-make-directory (file-name-directory file))
;; Save the article in the cache.
(if (file-exists-p file)
t ; The article already is saved.
(defvar gnus-custom-method)
(defvar gnus-custom-group)
-(defun gnus-group-customize (group &optional part)
+(defun gnus-group-customize (group)
"Edit the group on the current line."
(interactive (list (gnus-group-group-name)))
- (let ((part (or part 'info))
- info
+ (let (info
(types (mapcar (lambda (entry)
`(cons :format "%v%h\n"
:doc ,(nth 2 entry)
found buffer-read-only)
;; Enter the current status into the dribble buffer.
(let ((entry (gnus-gethash group gnus-newsrc-hashtb)))
- (when (and entry (not (gnus-ephemeral-group-p group)))
+ (when (and entry
+ (not (gnus-ephemeral-group-p group)))
(gnus-dribble-enter
(concat "(gnus-group-set-info '"
(gnus-prin1-to-string (nth 2 entry))
(gnus-no-server))
(gnus-group-read-group nil nil group))
+;;;###autoload
+(defun gnus-fetch-group-other-frame (group)
+ "Pop up a frame and enter GROUP."
+ (interactive "P")
+ (let ((window (get-buffer-window gnus-group-buffer)))
+ (cond (window
+ (select-frame (window-frame window)))
+ ((= (length (frame-list)) 1)
+ (select-frame (make-frame)))
+ (t
+ (other-frame 1))))
+ (gnus-fetch-group group))
+
(defvar gnus-ephemeral-group-server 0)
;; Enter a group that is not in the group buffer. Non-nil is returned
"Create the Gnus documentation group."
(interactive)
(let ((name (gnus-group-prefixed-name "gnus-help" '(nndoc "gnus-help")))
- (file (nnheader-find-etc-directory "gnus-tut.txt" t))
- dir)
+ (file (nnheader-find-etc-directory "gnus-tut.txt" t)))
(when (gnus-gethash name gnus-newsrc-hashtb)
(error "Documentation group already exists"))
(if (not file)
(when (gnus-group-native-p (gnus-info-group info))
(gnus-info-clear-data info)))
(gnus-get-unread-articles)
- (gnus-dribble-enter "")
+ (gnus-dribble-touch)
(when (gnus-y-or-n-p
"Move the cache away to avoid problems in the future? ")
(call-interactively 'gnus-cache-move-cache)))))
;; If INFO is non-nil, use that info. If FORCE is non-nil, don't
;; add, but replace marked articles of TYPE with ARTICLES.
(let ((info (or info (gnus-get-info group)))
- (uncompressed '(score bookmark killed))
marked m)
(or (not info)
(and (not (setq marked (nthcdr 3 info)))
(?h . "")
(?f . "from")
(?: . "subject")))
- (com-to-com
- '((?m . " ")
- (?j . "X")))
+ ;;(com-to-com
+ ;; '((?m . " ")
+ ;; (?j . "X")))
pattern modifier commands)
(while (not (eobp))
(if (not (looking-at "[ \t]*/\\([^/]*\\)/\\([ahfcH]\\)?:\\([a-z=:]*\\)"))
(setq gnus-article-copy (gnus-get-buffer-create " *gnus article copy*"))
(buffer-disable-undo gnus-article-copy)
(let ((article-buffer (or article-buffer gnus-article-buffer))
- end beg contents)
+ end beg)
(if (not (and (get-buffer article-buffer)
(gnus-buffer-exists-p article-buffer)))
(error "Can't find any article buffer")
(start-point (posn-point start-posn))
(start-line (1+ (count-lines 1 start-point)))
(start-window (posn-window start-posn))
- (start-frame (window-frame start-window))
(bounds (gnus-window-edges start-window))
(top (nth 1 bounds))
(bottom (if (window-minibuffer-p start-window)
;; end-of-range is used only in the single-click case.
;; It is the place where the drag has reached so far
;; (but not outside the window where the drag started).
- (let (event end end-point last-end-point (end-of-range (point)))
+ (let (event end end-point (end-of-range (point)))
(track-mouse
(while (progn
(setq event (cdr (gnus-read-event-char)))
nil
(setq end (event-end event)
end-point (posn-point end))
- (when end-point
- (setq last-end-point end-point))
(cond
;; Are we moving within the original window?
(push (cons 'version emacs-version) gnus-format-specs)
;; Mark the .newsrc.eld file as "dirty".
- (gnus-dribble-enter " ")
+ (gnus-dribble-touch)
(gnus-message 7 "Compiling user specs...done"))))
(defun gnus-set-format (type &optional insertable)
(defvar gnus-inserted-opened-servers nil)
(defvar gnus-server-line-format-alist
- `((?h how ?s)
- (?n name ?s)
- (?w where ?s)
- (?s status ?s)))
+ `((?h gnus-tmp-how ?s)
+ (?n gnus-tmp-name ?s)
+ (?w gnus-tmp-where ?s)
+ (?s gnus-tmp-status ?s)))
(defvar gnus-server-mode-line-format-alist
- `((?S news-server ?s)
- (?M news-method ?s)
- (?u user-defined ?s)))
+ `((?S gnus-tmp-news-server ?s)
+ (?M gnus-tmp-news-method ?s)
+ (?u gnus-tmp-user-defined ?s)))
(defvar gnus-server-line-format-spec nil)
(defvar gnus-server-mode-line-format-spec nil)
(setq buffer-read-only t)
(gnus-run-hooks 'gnus-server-mode-hook))
-(defun gnus-server-insert-server-line (name method)
- (let* ((how (car method))
- (where (nth 1 method))
+(defun gnus-server-insert-server-line (gnus-tmp-name method)
+ (let* ((gnus-tmp-how (car method))
+ (gnus-tmp-where (nth 1 method))
(elem (assoc method gnus-opened-servers))
- (status (cond ((eq (nth 1 elem) 'denied)
+ (gnus-tmp-status (cond ((eq (nth 1 elem) 'denied)
"(denied)")
((or (gnus-server-opened method)
(eq (nth 1 elem) 'ok))
(prog1 (1+ (point))
;; Insert the text.
(eval gnus-server-line-format-spec))
- (list 'gnus-server (intern name)))))
+ (list 'gnus-server (intern gnus-tmp-name)))))
(defun gnus-enter-server-buffer ()
"Set up the server buffer."
(error "No server on the current line")))
(unless (assoc server gnus-server-alist)
(error "Read-only server %s" server))
- (gnus-dribble-enter "")
+ (gnus-dribble-touch)
(let ((buffer-read-only nil))
(gnus-delete-line))
(push (assoc server gnus-server-alist) gnus-server-killed-servers)
(defun gnus-data-compute-positions ()
"Compute the positions of all articles."
(setq gnus-newsgroup-data-reverse nil)
- (let ((data gnus-newsgroup-data)
- pos)
- (while data
- (when (setq pos (text-property-any
- (point-min) (point-max)
- 'gnus-number (gnus-data-number (car data))))
- (gnus-data-set-pos (car data) (+ pos 3)))
- (setq data (cdr data)))))
+ (let ((data gnus-newsgroup-data))
+ (save-excursion
+ (goto-char (point-min))
+ (while data
+ (while (get-text-property (point) 'gnus-intangible)
+ (forward-line 1))
+ (gnus-data-set-pos (car data) (+ (point) 3))
+ (setq data (cdr data))
+ (forward-line 1)))))
(defun gnus-summary-article-pseudo-p (article)
"Say whether this article is a pseudo article or not."
(gnus-score-over-mark 130)
(gnus-download-mark 131)
(spec gnus-summary-line-format-spec)
- thread gnus-visual pos)
+ gnus-visual pos)
(save-excursion
(gnus-set-work-buffer)
(let ((gnus-summary-line-format-spec spec)
(let ((headers gnus-newsgroup-headers)
(gnus-summary-ignore-duplicates t)
header references generation relations
- cthread subject child end pthread relation new-child date)
+ subject child end new-child date)
;; First we create an alist of generations/relations, where
;; generations is how much we trust the relation, and the relation
;; is parent/child.
"Read all the headers."
(let ((gnus-summary-ignore-duplicates t)
(dependencies gnus-newsgroup-dependencies)
- found header article)
+ header article)
(save-excursion
(set-buffer nntp-server-buffer)
(let ((case-fold-search nil))
header (gnus-nov-parse-line
article dependencies)))
(when header
- (push header gnus-newsgroup-headers)
- (if (memq (setq article (mail-header-number header))
- gnus-newsgroup-unselected)
- (progn
- (push article gnus-newsgroup-unreads)
- (setq gnus-newsgroup-unselected
- (delq article gnus-newsgroup-unselected)))
- (push article gnus-newsgroup-ancient))
+ (save-excursion
+ (set-buffer gnus-summary-buffer)
+ (push header gnus-newsgroup-headers)
+ (if (memq (setq article (mail-header-number header))
+ gnus-newsgroup-unselected)
+ (progn
+ (push article gnus-newsgroup-unreads)
+ (setq gnus-newsgroup-unselected
+ (delq article gnus-newsgroup-unselected)))
+ (push article gnus-newsgroup-ancient)))
(forward-line 1)))))))
(defun gnus-summary-update-article-line (article header)
references))
"none")))
(buffer-read-only nil)
- (old (car thread))
- (number (mail-header-number header))
- pos)
+ (old (car thread)))
(when thread
(unless iheader
(setcar thread nil)
"Sort THREADS."
(if (not gnus-thread-sort-functions)
threads
- (gnus-message 7 "Sorting threads...")
+ (gnus-message 8 "Sorting threads...")
(prog1
(sort threads (gnus-make-sort-function gnus-thread-sort-functions))
- (gnus-message 7 "Sorting threads...done"))))
+ (gnus-message 8 "Sorting threads...done"))))
(defun gnus-sort-articles (articles)
"Sort ARTICLES."
(or dependencies
(save-excursion (set-buffer gnus-summary-buffer)
gnus-newsgroup-dependencies)))
- headers id id-dep ref-dep end ref)
+ headers id end ref)
(save-excursion
(set-buffer nntp-server-buffer)
;; Translate all TAB characters into SPACE characters.
(t
(gnus-read-header id))))
(number (and (numberp id) id))
- pos d)
+ d)
(when header
;; Rebuild the thread that this article is part of and go to the
;; article we have fetched.
(interactive "P")
(let ((id (mail-header-id (gnus-summary-article-header)))
(limit (if limit (prefix-numeric-value limit)
- gnus-refer-thread-limit))
- fmethod root)
+ gnus-refer-thread-limit)))
;; We want to fetch LIMIT *old* headers, but we also have to
;; re-fetch all the headers in the current buffer, because many of
;; them may be undisplayed. So we adjust LIMIT.
(gnus-summary-article-sparse-p
(mail-header-number header))
(memq (mail-header-number header)
- gnus-newsgroup-limit)))
- h)
+ gnus-newsgroup-limit))))
(cond
;; If the article is present in the buffer we just go to it.
((and header
(gnus-summary-mark-article article gnus-canceled-mark)
(gnus-message 4 "Deleted article %s" article))
(t
- (let* ((entry
- (or
- (gnus-gethash (car art-group) gnus-newsrc-hashtb)
- (gnus-gethash
- (gnus-group-prefixed-name
- (car art-group)
- (or select-method
- (gnus-find-method-for-group to-newsgroup)))
- gnus-newsrc-hashtb)))
+ (let* ((pto-group (gnus-group-prefixed-name
+ (car art-group) to-method))
+ (entry
+ (gnus-gethash pto-group gnus-newsrc-hashtb))
(info (nth 2 entry))
(to-group (gnus-info-group info)))
;; Update the group that has been moved to.
"Pipe the current article through PROGRAM."
(interactive "sProgram: ")
(gnus-summary-select-article)
- (let ((mail-header-separator "")
- (art-buf (get-buffer gnus-article-buffer)))
+ (let ((mail-header-separator ""))
(gnus-eval-in-buffer-window gnus-article-buffer
(save-restriction
(widen)
(defun gnus-map-function (funs arg)
"Applies the result of the first function in FUNS to the second, and so on.
ARG is passed to the first function."
- (let ((myfuns funs)
- (myarg arg))
+ (let ((myfuns funs))
(while myfuns
(setq arg (funcall (pop myfuns) arg)))
arg))
;;; Various
+(defvar gnus-group-buffer) ; Compiler directive
(defun gnus-alive-p ()
"Say whether Gnus is running or not."
(and (boundp 'gnus-group-buffer)
(interactive "P")
(let ((gnus-uu-save-in-digest t)
(file (make-temp-name (nnheader-concat gnus-uu-tmp-dir "forward")))
- buf subject from newsgroups)
+ buf subject from)
(gnus-setup-message 'forward
(setq gnus-uu-digest-from-subject nil)
(gnus-uu-decode-save n file)
"Invert the list of process-marked articles."
(interactive)
(let ((data gnus-newsgroup-data)
- d number)
+ number)
(save-excursion
(while data
(if (memq (setq number (gnus-data-number (pop data)))
(mail-header-subject header))
gnus-uu-digest-from-subject))
(let ((name (file-name-nondirectory gnus-uu-saved-article-name))
- (delim (concat "^" (make-string 30 ?-) "$"))
beg subj headers headline sorthead body end-string state)
(if (or (eq in-state 'first)
(eq in-state 'first-and-last))
;; replaces the last thing that looks like "2/3" with "[0-9]+/3"
;; or, if it can't find something like that, tries "2 of 3", then
;; finally just replaces the next to last number with "[0-9]+".
- (let ((count 2))
- (save-excursion
- (set-buffer (gnus-get-buffer-create gnus-uu-output-buffer-name))
- (buffer-disable-undo (current-buffer))
- (erase-buffer)
- (insert (regexp-quote string))
+ (save-excursion
+ (set-buffer (gnus-get-buffer-create gnus-uu-output-buffer-name))
+ (buffer-disable-undo (current-buffer))
+ (erase-buffer)
+ (insert (regexp-quote string))
+
+ (setq case-fold-search nil)
- (setq case-fold-search nil)
+ (end-of-line)
+ (if (re-search-backward "\\([^0-9]\\)[0-9]+/\\([0-9]+\\)" nil t)
+ (replace-match "\\1[0-9]+/\\2")
(end-of-line)
- (if (re-search-backward "\\([^0-9]\\)[0-9]+/\\([0-9]+\\)" nil t)
- (replace-match "\\1[0-9]+/\\2")
+ (if (re-search-backward "\\([^0-9]\\)[0-9]+[ \t]*of[ \t]*\\([0-9]+\\)"
+ nil t)
+ (replace-match "\\1[0-9]+ of \\2")
(end-of-line)
- (if (re-search-backward "\\([^0-9]\\)[0-9]+[ \t]*of[ \t]*\\([0-9]+\\)"
+ (if (re-search-backward "\\([^0-9]\\)[0-9]+\\([^0-9]+\\)[0-9]+"
nil t)
- (replace-match "\\1[0-9]+ of \\2")
-
- (end-of-line)
- (if (re-search-backward "\\([^0-9]\\)[0-9]+\\([^0-9]+\\)[0-9]+"
- nil t)
- (replace-match "\\1[0-9]+\\2[0-9]+" t nil nil nil))))
+ (replace-match "\\1[0-9]+\\2[0-9]+" t nil nil nil))))
- (goto-char 1)
- (while (re-search-forward "[ \t]+" nil t)
- (replace-match "[ \t]+" t t))
+ (goto-char 1)
+ (while (re-search-forward "[ \t]+" nil t)
+ (replace-match "[ \t]+" t t))
- (buffer-substring 1 (point-max)))))
+ (buffer-substring 1 (point-max))))
(defun gnus-uu-get-list-of-articles (n)
;; If N is non-nil, the article numbers of the N next articles
(not (memq 'end process-state))))
(setq article (pop articles))
- (push article article-series)
+ (when (vectorp (gnus-summary-article-header article))
+ (push article article-series)
- (unless articles
- (if (eq state 'first)
- (setq state 'first-and-last)
- (setq state 'last)))
+ (unless articles
+ (if (eq state 'first)
+ (setq state 'first-and-last)
+ (setq state 'last)))
- (let ((part (gnus-uu-part-number article)))
- (gnus-message 6 "Getting article %d%s..."
- article (if (string= part "") "" (concat ", " part))))
- (gnus-summary-display-article article)
+ (let ((part (gnus-uu-part-number article)))
+ (gnus-message 6 "Getting article %d%s..."
+ article (if (string= part "") "" (concat ", " part))))
+ (gnus-summary-display-article article)
- ;; Push the article to the processing function.
- (save-excursion
- (set-buffer gnus-original-article-buffer)
- (let ((buffer-read-only nil))
- (save-excursion
- (set-buffer gnus-summary-buffer)
- (setq process-state
- (funcall process-function
- gnus-original-article-buffer state)))))
-
- (gnus-summary-remove-process-mark article)
-
- ;; If this is the beginning of a decoded file, we push it
- ;; on to a list.
- (when (or (memq 'begin process-state)
- (and (or (eq state 'first)
- (eq state 'first-and-last))
- (memq 'ok process-state)))
- (when has-been-begin
- ;; If there is a `result-file' here, that means that the
- ;; file was unsuccessfully decoded, so we delete it.
- (when (and result-file
- (file-exists-p result-file)
- (not gnus-uu-be-dangerous)
- (or (eq gnus-uu-be-dangerous t)
- (gnus-y-or-n-p
- (format "Delete unsuccessfully decoded file %s"
- result-file))))
- (delete-file result-file)))
- (when (memq 'begin process-state)
- (setq result-file (car process-state)))
- (setq has-been-begin t))
-
- ;; Check whether we have decoded one complete file.
- (when (memq 'end process-state)
- (setq article-series nil)
- (setq has-been-begin nil)
- (if (stringp result-file)
- (setq files (list result-file))
- (setq files result-file))
- (setq result-file (car files))
- (while files
- (push (list (cons 'name (pop files))
- (cons 'article article))
- result-files))
- ;; Allow user-defined functions to be run on this file.
- (when gnus-uu-grabbed-file-functions
- (let ((funcs gnus-uu-grabbed-file-functions))
- (unless (listp funcs)
- (setq funcs (list funcs)))
- (while funcs
- (funcall (pop funcs) result-file))))
- (setq result-file nil)
- ;; Check whether we have decoded enough articles.
- (and limit (= (length result-files) limit)
- (setq articles nil)))
-
- ;; If this is the last article to be decoded, and
- ;; we still haven't reached the end, then we delete
- ;; the partially decoded file.
- (and (or (eq state 'last) (eq state 'first-and-last))
- (not (memq 'end process-state))
- result-file
- (file-exists-p result-file)
- (not gnus-uu-be-dangerous)
- (or (eq gnus-uu-be-dangerous t)
- (gnus-y-or-n-p
- (format "Delete incomplete file %s? " result-file)))
- (delete-file result-file))
-
- ;; If this was a file of the wrong sort, then
- (when (and (or (memq 'wrong-type process-state)
- (memq 'error process-state))
- gnus-uu-unmark-articles-not-decoded)
- (gnus-summary-tick-article article t))
-
- ;; Set the new series state.
- (if (and (not has-been-begin)
- (not sloppy)
- (or (memq 'end process-state)
- (memq 'middle process-state)))
- (progn
- (setq process-state (list 'error))
- (gnus-message 2 "No begin part at the beginning")
- (sleep-for 2))
- (setq state 'middle)))
-
- ;; When there are no result-files, then something must be wrong.
- (if result-files
- (message "")
- (cond
- ((not has-been-begin)
- (gnus-message 2 "Wrong type file"))
- ((memq 'error process-state)
- (gnus-message 2 "An error occurred during decoding"))
- ((not (or (memq 'ok process-state)
- (memq 'end process-state)))
- (gnus-message 2 "End of articles reached before end of file")))
- ;; Make unsuccessfully decoded articles unread.
- (when gnus-uu-unmark-articles-not-decoded
- (while article-series
- (gnus-summary-tick-article (pop article-series) t))))
+ ;; Push the article to the processing function.
+ (save-excursion
+ (set-buffer gnus-original-article-buffer)
+ (let ((buffer-read-only nil))
+ (save-excursion
+ (set-buffer gnus-summary-buffer)
+ (setq process-state
+ (funcall process-function
+ gnus-original-article-buffer state)))))
+
+ (gnus-summary-remove-process-mark article)
+
+ ;; If this is the beginning of a decoded file, we push it
+ ;; on to a list.
+ (when (or (memq 'begin process-state)
+ (and (or (eq state 'first)
+ (eq state 'first-and-last))
+ (memq 'ok process-state)))
+ (when has-been-begin
+ ;; If there is a `result-file' here, that means that the
+ ;; file was unsuccessfully decoded, so we delete it.
+ (when (and result-file
+ (file-exists-p result-file)
+ (not gnus-uu-be-dangerous)
+ (or (eq gnus-uu-be-dangerous t)
+ (gnus-y-or-n-p
+ (format "Delete unsuccessfully decoded file %s"
+ result-file))))
+ (delete-file result-file)))
+ (when (memq 'begin process-state)
+ (setq result-file (car process-state)))
+ (setq has-been-begin t))
+
+ ;; Check whether we have decoded one complete file.
+ (when (memq 'end process-state)
+ (setq article-series nil)
+ (setq has-been-begin nil)
+ (if (stringp result-file)
+ (setq files (list result-file))
+ (setq files result-file))
+ (setq result-file (car files))
+ (while files
+ (push (list (cons 'name (pop files))
+ (cons 'article article))
+ result-files))
+ ;; Allow user-defined functions to be run on this file.
+ (when gnus-uu-grabbed-file-functions
+ (let ((funcs gnus-uu-grabbed-file-functions))
+ (unless (listp funcs)
+ (setq funcs (list funcs)))
+ (while funcs
+ (funcall (pop funcs) result-file))))
+ (setq result-file nil)
+ ;; Check whether we have decoded enough articles.
+ (and limit (= (length result-files) limit)
+ (setq articles nil)))
+
+ ;; If this is the last article to be decoded, and
+ ;; we still haven't reached the end, then we delete
+ ;; the partially decoded file.
+ (and (or (eq state 'last) (eq state 'first-and-last))
+ (not (memq 'end process-state))
+ result-file
+ (file-exists-p result-file)
+ (not gnus-uu-be-dangerous)
+ (or (eq gnus-uu-be-dangerous t)
+ (gnus-y-or-n-p
+ (format "Delete incomplete file %s? " result-file)))
+ (delete-file result-file))
+
+ ;; If this was a file of the wrong sort, then
+ (when (and (or (memq 'wrong-type process-state)
+ (memq 'error process-state))
+ gnus-uu-unmark-articles-not-decoded)
+ (gnus-summary-tick-article article t))
+
+ ;; Set the new series state.
+ (if (and (not has-been-begin)
+ (not sloppy)
+ (or (memq 'end process-state)
+ (memq 'middle process-state)))
+ (progn
+ (setq process-state (list 'error))
+ (gnus-message 2 "No begin part at the beginning")
+ (sleep-for 2))
+ (setq state 'middle)))
+
+ ;; When there are no result-files, then something must be wrong.
+ (if result-files
+ (message "")
+ (cond
+ ((not has-been-begin)
+ (gnus-message 2 "Wrong type file"))
+ ((memq 'error process-state)
+ (gnus-message 2 "An error occurred during decoding"))
+ ((not (or (memq 'ok process-state)
+ (memq 'end process-state)))
+ (gnus-message 2 "End of articles reached before end of file")))
+ ;; Make unsuccessfully decoded articles unread.
+ (when gnus-uu-unmark-articles-not-decoded
+ (while article-series
+ (gnus-summary-tick-article (pop article-series) t)))))
result-files))
(top-string "[ cut here %s (%s %d/%d) %s gnus-uu ]")
(separator (concat mail-header-separator "\n\n"))
uubuf length parts header i end beg
- beg-line minlen buf post-buf whole-len beg-binary end-binary)
+ beg-line minlen post-buf whole-len beg-binary end-binary)
(setq post-buf (current-buffer))
(defconst gnus-product-name "Shoe-gnus"
"Product name of this version of gnus.")
-(defconst gnus-version-number "6.8.9"
+(defconst gnus-version-number "6.8.10"
"Version number for this version of gnus.")
(defconst gnus-version
- (format "%s %s (based on Gnus 5.6.39; for SEMI 1.8, FLIM 1.8/1.9)"
+ (format "%s %s (based on Gnus 5.6.41; for SEMI 1.8, FLIM 1.8/1.9)"
gnus-product-name gnus-version-number)
"Version string for this version of gnus.")
:group 'gnus-files
:group 'gnus-server
:type 'file)
-
+
;; This function is used to check both the environment variable
;; NNTPSERVER and the /etc/nntpserver file to see whether one can find
;; an nntp server name default.
gnus-start-date-timer gnus-stop-date-timer)
("gnus-int" gnus-request-type)
("gnus-start" gnus-newsrc-parse-options gnus-1 gnus-no-server-1
- gnus-dribble-enter gnus-read-init-file)
+ gnus-dribble-enter gnus-read-init-file gnus-dribble-touch)
("gnus-dup" gnus-dup-suppress-articles gnus-dup-unsuppress-article
gnus-dup-enter-articles)
("gnus-range" gnus-copy-sequence)
"Version number of this version of Gnus.
If ARG, insert string at point."
(interactive "P")
- (let ((methods gnus-valid-select-methods)
- (mess gnus-version)
- meth)
- (if arg
- (insert (message mess))
- (message mess))))
+ (if arg
+ (insert (message gnus-version))
+ (message gnus-version)))
(defun gnus-continuum-version (version)
"Return VERSION as a floating point number."
(insert "\n"))
(funcall message-citation-line-function))))
+(defvar mail-citation-hook) ;Compiler directive
(defun message-cite-original ()
"Cite function in the standard Message manner."
(if (and (boundp 'mail-citation-hook)
This is done simply by taking the old article and adding a Supersedes
header line with the old Message-ID."
(interactive)
- (let ((cur (current-buffer)))
+ (let ((cur (current-buffer))
+ (sender (message-fetch-field "sender"))
+ (from (message-fetch-field "from")))
;; Check whether the user owns the article that is to be superseded.
- (unless (string-equal
- (downcase (or (message-fetch-field "sender")
- (cadr (std11-extract-address-components
- (message-fetch-field "from")))))
- (downcase (message-make-sender)))
+ (unless (or (and sender
+ (string-equal
+ (downcase sender)
+ (downcase (message-make-sender))))
+ (string-equal
+ (downcase (cadr (std11-extract-address-components from)))
+ (downcase (cadr (std11-extract-address-components
+ (message-make-from))))))
(error "This article is not yours"))
;; Get a normal message buffer.
(message-pop-to-buffer (message-buffer-name "supersede"))
(goto-char (point-min))
;; strip Re/Fwd stuff off the beginning
(while (re-search-forward
- "\\([Rr][Ee]:\\|[Ff][Ww][Dd]:\\|[Ff][Ww]:\\)" nil t)
+ "\\([Rr][Ee]:\\|[Ff][Ww][Dd]\\(\\[[0-9]*\\]\\)?:\\|[Ff][Ww]:\\)" nil t)
(replace-match ""))
;; and gnus-style forwards [foo@bar.com] subject
(point))))
(hashtb (and (boundp 'gnus-active-hashtb) gnus-active-hashtb))
(completions (all-completions string hashtb))
- (cur (current-buffer))
comp)
(delete-region b (point))
(cond
(save-excursion
(set-buffer buffer)
(goto-char (point-max))
- (let ((xref (mail-header-xref header))
- (prefix (gnus-group-real-prefix group))
+ (let ((prefix (gnus-group-real-prefix group))
(oheader (copy-sequence header))
- (first t)
article)
(if (zerop (forward-line -1))
(progn
(deffoo nnmh-request-expire-articles (articles newsgroup
&optional server force)
(nnmh-possibly-change-directory newsgroup server)
- (let* ((active-articles
- (mapcar
- (function
- (lambda (name)
- (string-to-int name)))
- (directory-files nnmh-current-directory nil "^[0-9]+$" t)))
- (is-old t)
+ (let* ((is-old t)
article rest mod-time)
(nnheader-init-server-buffer)
(nntp-inhibit-erase t)
(map (apply 'vector articles))
(point 1)
- article alist)
+ article)
(set-buffer buf)
(erase-buffer)
;; Send ARTICLE command.
(let ((mart (nnvirtual-map-article article)))
(if mart
(gnus-request-type (car mart) (cdr mart))))
- (let ((method (gnus-find-method-for-group
- nnvirtual-last-accessed-component-group)))
- (gnus-request-type
- nnvirtual-last-accessed-component-group nil)))))
+ (gnus-request-type
+ nnvirtual-last-accessed-component-group nil))))
(deffoo nnvirtual-request-update-mark (group article mark)
(let* ((nart (nnvirtual-map-article article))
+1998-08-27 07:29:17 Lars Magne Ingebrigtsen <larsi@gnus.org>
+
+ * gnus.texi (Mail Folders): Addition.
+
+1998-08-25 08:06:28 Lars Magne Ingebrigtsen <larsi@gnus.org>
+
+ * gnus.texi (Posting Styles): Document this-is.
+ (Virtual Groups): Addition.
+
1998-08-18 00:30:05 Lars Magne Ingebrigtsen <larsi@gnus.org>
* gnus.texi (Article Hiding): Addition.
return value will be used), a variable (its value will be used) or a
list (it will be @code{eval}ed and the return value will be used).
+If you wish to check whether the message you are about to compose is
+meant to be a news article or a mail message, you can check the values
+of the two dynamically bound variables @code{message-this-is-news} and
+@code{message-this-is-mail}.
+
+@vindex message-this-is-mail
+@vindex message-this-is-news
+
So here's a new example:
@lisp
(signature my-funny-signature-randomizer))
((equal (system-name) "gnarly")
(signature my-quote-randomizer))
+ (message-this-is-new
+ (signature my-news-signature))
(posting-from-work-p
(signature-file "~/.work-signature")
(address "user@@bar.foo")
@item nnfolder-get-new-mail
@vindex nnfolder-get-new-mail
If non-@code{nil}, @code{nnfolder} will read incoming mail.
+
+@item nnfolder-save-buffer-hook
+@vindex nnfolder-save-buffer-hook
+@cindex backup files
+Hook run before saving the folders. Note that Emacs does the normal
+backup renaming of files even with the @code{nnfolder} buffers. If you
+wish to switch this off, you could say something like the following in
+your @file{.emacs} file:
+
+@lisp
+(defun turn-off-backup ()
+ (set (make-local-variable 'backup-inhibited) t))
+
+(add-hook 'nnfolder-save-buffer-hook 'turn-off-backup)
+@end lisp
+
@end table
+
@findex nnfolder-generate-active-file
@kindex M-x nnfolder-generate-active-file
If you have lots of @code{nnfolder}-like files you'd like to read with
Or you can just tap @code{M-g} on the virtual group every time before
you enter it---it'll have much the same effect.
+@code{nnvirtual} can have both mail and news groups as component groups.
+When responding to articles in @code{nnvirtual} groups, @code{nnvirtual}
+has to ask the backend of the component group the article comes from
+whether it is a news or mail backend. However, when you do a @kbd{^},
+there is typically no sure way for the component backend to know this,
+and in that case @code{nnvirtual} tells Gnus that the article came from a
+not-news backend. (Just to be on the safe side.)
+
+@kbd{C-c C-t} in the message buffer will insert the @code{Newsgroups}
+line from the article you respond to in these cases.
+
+
@node Kibozed Groups
@subsection Kibozed Groups
* ding Gnus:: New things in Gnus 5.0/5.1, the first new Gnus.
* September Gnus:: The Thing Formally Known As Gnus 5.3/5.3.
* Red Gnus:: Third time best---Gnus 5.4/5.5.
-* Quassia Gnus:: Two times two is four, or Gnus 5.6.
+* Quassia Gnus:: Two times two is four, or Gnus 5.6/5.7.
@end menu
These lists are, of course, just @emph{short} overviews of the
lists.
@item
+Introduce nnmail-home-directory.
+
+@item
+gnus-fetch-group and friends should exit Gnus when the user
+exits the group.
+
+@item
Solve the halting problem.
@c TODO
\input texinfo @c -*-texinfo-*-
@setfilename message
-@settitle Message 5.6.33 Manual
+@settitle Message 5.6.41 Manual
@synindex fn cp
@synindex vr cp
@synindex pg cp
@tex
@titlepage
-@title Message 5.6.33 Manual
+@title Message 5.6.41 Manual
@author by Lars Magne Ingebrigtsen
@page
* Key Index:: List of Message mode keys.
@end menu
-This manual corresponds to Message 5.6.33. Message is distributed with
+This manual corresponds to Message 5.6.41. Message is distributed with
the Gnus distribution bearing the same version number as this manual
has.
projects / elisp / gnus.git- / commitdiff