+Fri Mar 8 00:03:14 1996 Lars Magne Ingebrigtsen <larsi@ifi.uio.no>
+
+ * gnus.el (gnus-group-yank-group): Would bug out on groups with
+ scores.
+ (gnus-summary-go-to-next-thread): Do dummies properly.
+ (gnus-summary-setup-buffer): Make `gnus-article-current' be
+ buffer-local.
+
+ * gnus-topic.el (gnus-topic-update-topic): Don't update dead
+ groups.
+
+ * gnus.el (gnus-clear-system): Clear list mode.
+ (gnus-group-list-groups): Might start out in the wrong buffer.
+ (gnus-clear-system): Clear topic variables.
+
+ * gnus-msg.el (gnus-ignored-resent-headers): New variable.
+ (gnus-summary-resend-message): Use it.
+
+Thu Mar 7 23:38:35 1996 Lars Magne Ingebrigtsen <larsi@ifi.uio.no>
+
+ * nnvirtual.el (nnvirtual-retrieve-headers): `princ' bugs.
+
+ * gnus-uu.el (gnus-uu-decode-with-method): Check whether `save' is
+ nil.
+
+Thu Mar 7 21:38:31 1996 Lars Magne Ingebrigtsen <larsi@hler.ifi.uio.no>
+
+ * gnus-vis.el (gnus-article-next-button): Move point to the start
+ of the button when skipping backwards.
+
+Thu Mar 7 00:15:32 1996 Lars Magne Ingebrigtsen <lars@eyesore.no>
+
+ * gnus-soup.el (gnus-group-brew-soup): Don't pack ticked
+ articles.
+
+ * gnus.el (gnus-eval-in-buffer-window): Use uninterned symbol.
+ (gnus-buffer-exists-p): `let'.
+ (gnus-summary-reparent-thread): Don't use `substring-no-props'.
+ (gnus-summary-edit-article-done): Ditto.
+
+ * gnus-msg.el (gnus-news-followup): Don't ask about "poster".
+ (gnus-summary-followup): Bugged out on "poster".
+ (gnus-inews-set-point): Didn't reliably set point.
+
+Wed Mar 6 01:02:25 1996 Lars Magne Ingebrigtsen <lars@eyesore.no>
+
+ * gnus-cache.el (gnus-cache-enter-article): Advance point.
+
+ * gnus.el (gnus-summary-copy-article): Would pass the `respool'
+ parameter.
+
+ * nnmail.el (nnmail-search-unix-mail-delim): Accept a quoted From
+ as the second line.
+
+ * nnvirtual.el (nnvirtual-retrieve-headers): Don't collect so much
+ garbage.
+
+ * gnus.el (gnus-group-set-mark): Allow forcing.
+ (gnus-group-unmark-all-groups): Non-interactive.
+
+Tue Mar 5 15:21:21 1996 Lars Ingebrigtsen <lars@eyesore.no>
+
+ * gnus-topic.el (gnus-topic-mark-topic): Would skip the first group.
+ (gnus-topic-unmark-topic): New function and keystroke.
+ (gnus-topic-tallied-groups): New variable.
+ (gnus-topic-prepare-topic): Don't count groups twice.
+
+ * gnus.el (gnus-get-split-value): Would return nil.
+
+ * gnus-soup.el (gnus-soup-group-brew): Don't enter group with 0
+ unread articles.
+
+ * gnus.el (gnus-group-set-current-level): Don't error out when
+ point isn't on a group.
+
+ * gnus-vis.el (gnus-article-highlight-headers): Would infollop on
+ illegal headers.
+
+ * gnus-topic.el (gnus-topic-hide-topic): Toggle the parent topic.
+
+ * nn*.el: Made sure all virtual server variables are saved.
+
+Mon Mar 4 19:18:57 1996 Lars Magne Ingebrigtsen <lars@eyesore.no>
+
+ * nntp.el (nntp-server-variables): Save more variables.
+
+ * gnus.el (gnus-read-old-newsrc-el-file): Would bug out on
+ entering ticks into infos.
+ (gnus-gnus-to-newsrc-format): Write "native"-server groups to the
+ .newsrc.
+
+ * nnsoup.el (nnsoup-store-reply): Make sure `expand-mail-aliases'
+ and `mail-swallows-etc' is bound.
+
+ * nnvirtual.el (nnvirtual-marks): Made into a defsubst.
+ (nnvirtual-possibly-change-group): Would recreate the mapping
+ several times.
+
+ * nnml.el (nnml-request-rename-group): Wouldn't allow renaming
+ non-leaf group name components.
+
+ * gnus.el (gnus-group-change-level): Wouldn change levels of
+ living groups.
+
+Sun Mar 3 23:17:57 1996 Lars Ingebrigtsen <lars@eyesore.no>
+
+ * gnus-msg.el (gnus-sent-message-ids-file): New variable.
+ (gnus-sent-message-ids-length): New variable.
+ (gnus-inews-reject-message): New function.
+
+Sun Mar 3 22:03:47 1996 Jason L. Tibbitts, III <tibbs@hpc.uh.edu>
+
+ * nnmail.el (nnmail-process-unix-mail-format): Better
+ Content-Length check.
+
+Sun Mar 3 21:53:12 1996 Lars Ingebrigtsen <lars@eyesore.no>
+
+ * nntp.el (nntp-end-of-line): New variable.
+ (nntp-request-close, nntp-encode-text,
+ nntp-send-strings-to-server, nntp-async-send-strings): Use it.
+ (nntp-read-server-type): Use slow wait-for-response.
+
+Sun Mar 3 21:50:22 1996 Thor Kristoffersen <thor@unik.no>
+
+ * nntp.el (nntp-open-rlogin): New definition.
+
+Sun Mar 3 21:39:20 1996 Lars Ingebrigtsen <lars@eyesore.no>
+
+ * gnus.el (gnus-get-new-news-in-group): Close group after opening
+ it.
+
+Sun Mar 3 02:27:17 1996 Jason L Tibbitts III <tibbs@uh.edu>
+
+ * nnmail.el (nnmail-process-unix-mail-format): Rewrite of
+ Content-Length: header processing.
+
+Sun Mar 3 13:05:15 1996 Loren Schall <schall@saifr00.ateng.az.honeywell.com>
+
+ * gnus.el (gnus-simplify-buffer-fuzzy): Regexp fix.
+
+Sun Mar 3 12:07:37 1996 Lars Ingebrigtsen <lars@eyesore.no>
+
+ * nnmail.el (nnmail-search-unix-mail-delim): Accept "From " as the
+ line after the delim.
+
+ * gnus-kill.el (gnus-kill-file-enter-kill): Don't move point.
+ (gnus-kill-file-kill-by-subject, gnus-kill-file-kill-by-author,
+ gnus-kill-file-kill-by-thread, gnus-kill-file-kill-by-xref): Use
+ it.
+
+Sat Mar 2 16:39:34 1996 Lars Ingebrigtsen <lars@eyesore.no>
+
+ * gnus.el (gnus-summary-exit): Close the group.
+
+ * nndoc.el (nndoc-type-alist): Be a bit slacker with digest head
+ ends.
+
+ * gnus.el (gnus-select-newsgroup): Would kill the group buffer.
+
+ * gnus-msg.el (gnus-group-post-news): Configure windows.
+
+ * gnus.el (gnus-setup-news): Don't read the descriptions file when
+ started with `no-server'.
+
Sat Mar 2 11:38:26 1996 Lars Magne Ingebrigtsen <larsi@ifi.uio.no>
+ * gnus.el: 0.49 is released.
+
* gnus-vis.el (gnus-article-button-next-page): New function.
(gnus-article-button-prev-page): New function.
(gnus-insert-next-page-button): Use them.
(push article out))
(gnus-summary-remove-process-mark article)
(gnus-summary-update-secondary-mark article))
+ (gnus-summary-next-subject 1)
(gnus-summary-position-point)
(nreverse out)))
(push (string-to-int (file-name-nondirectory (pop files))) nums)
(push (pop files) alphs)))
;; If we have nums, then this is probably a valid group.
- (setq nums (sort nums '<))
- (if nums
- (gnus-sethash group (cons (car nums) (gnus-last-element nums))
- gnus-cache-active-hashtb))
+ (when (setq nums (sort nums '<))
+ (gnus-sethash group (cons (car nums) (gnus-last-element nums))
+ gnus-cache-active-hashtb))
;; Go through all the other files.
(while alphs
(when (and (file-directory-p (car alphs))
(gnus-kill-file-mode)
(bury-buffer buffer)))
-(defun gnus-kill-file-enter-kill (field regexp)
+(defun gnus-kill-file-enter-kill (field regexp &optional dont-move)
;; Enter kill file entry.
;; FIELD: String containing the name of the header field to kill.
;; REGEXP: The string to kill.
(let (string)
(or (eq major-mode 'gnus-kill-file-mode)
(gnus-kill-set-kill-buffer))
- (current-buffer)
- (goto-char (point-max))
+ (unless dont-move
+ (goto-char (point-max)))
(insert (setq string (format "(gnus-kill %S %S)\n" field regexp)))
(gnus-kill-file-apply-string string))))
(if (vectorp gnus-current-headers)
(regexp-quote
(gnus-simplify-subject (mail-header-subject gnus-current-headers)))
- "")))
+ "") t))
(defun gnus-kill-file-kill-by-author ()
"Kill by author."
"From"
(if (vectorp gnus-current-headers)
(regexp-quote (mail-header-from gnus-current-headers))
- "")))
+ "") t))
(defun gnus-kill-file-kill-by-thread ()
"Kill by author."
(substring xref (match-beginning 1) (match-end 1)))
gnus-newsgroup-name))
(gnus-kill-file-enter-kill
- "Xref" (concat " " (regexp-quote group) ":"))))
- (gnus-kill-file-enter-kill "Xref" ""))))
+ "Xref" (concat " " (regexp-quote group) ":") t)))
+ (gnus-kill-file-enter-kill "Xref" "" t))))
(defun gnus-kill-file-raise-followups-to-author (level)
"Raise score for all followups to the current author."
(defvar gnus-removable-headers '(NNTP-Posting-Host Xref)
"*Headers to be removed unconditionally before posting.")
+(defvar gnus-ignored-resent-headers "^Return-receipt"
+ "*All headers that match this regexp will be deleted when resending a message.")
+
(defvar gnus-article-expires 14
"*Number of days before your article expires.
This variable isn't used unless you have the `Expires' element in
(defvar gnus-bounced-headers-junk "^\\(Received\\):"
"*Regexp that matches headers to be removed in resent bounced mail.")
+(defvar gnus-sent-message-ids-file
+ (concat (file-name-as-directory gnus-article-save-directory)
+ "Sent-Message-IDs")
+ "File where Gnus saves a cache of sent message ids.")
+
+(defvar gnus-sent-message-ids-length 1000
+ "The number of sent Message-IDs to save.")
+
(defvar gnus-inews-article-hook (list 'gnus-inews-do-fcc)
"*A hook called before finally posting an article.
The default hook (`gnus-inews-do-fcc') does FCC processing (ie. saves
;; We might want to prompt here.
(when (and gnus-interactive-post
(not gnus-expert-user))
- (read-string "To: "))))
+ (read-string "To: ")))
+ (gnus-configure-windows 'group-mail 'force))
(defun gnus-group-post-news (&optional arg)
"Post an article.
(setq group
(completing-read "Group: " gnus-active-hashtb nil nil
(cons (or group "") 0)))))
- (gnus-post-news 'post group nil gnus-article-buffer)))
+ (gnus-post-news 'post group nil gnus-article-buffer)
+ (if (eq major-mode 'news-reply-mode)
+ (gnus-configure-windows 'group-post t)
+ (gnus-configure-windows 'group-mail t))))
(defun gnus-summary-post-news ()
"Post an article."
(not (gnus-y-or-n-p
"Do you want to ignore `Followup-To: poster'? "))))
;; Mail to the poster.
- (gnus-summary-reply yank)
+ (progn
+ (set-buffer gnus-summary-buffer)
+ (gnus-summary-reply yank))
;; Send a followup.
(gnus-post-news nil gnus-newsgroup-name
headers gnus-article-buffer
(count-lines (point) (point-max))))
t)))))))
+(defvar gnus-inews-sent-ids nil)
+
+(defun gnus-inews-reject-message ()
+ "Check whether this message has already been sent."
+ (when gnus-sent-message-ids-file
+ (let ((message-id (save-restriction (gnus-inews-narrow-to-headers)
+ (mail-fetch-field "message-id")))
+ end)
+ (when message-id
+ (unless gnus-inews-sent-ids
+ (condition-case ()
+ (load t t t)
+ (error nil)))
+ (if (member message-id gnus-inews-sent-ids)
+ ;; Reject this message.
+ (not (gnus-yes-or-no-p
+ (format "Message %s already sent. Send anyway? "
+ message-id)))
+ (push message-id gnus-inews-sent-ids)
+ ;; Chop off the last Message-IDs.
+ (when (setq end (nthcdr gnus-sent-message-ids-length
+ gnus-inews-sent-ids))
+ (setcdr end nil))
+ (nnheader-temp-write gnus-sent-message-ids-file
+ (prin1 `(setq gnus-inews-sent-ids ',gnus-inews-sent-ids)))
+ nil)))))
+
(defun gnus-tokenize-header (header &optional separator)
"Split HEADER into a list of header elements.
\",\" is used as the separator."
(goto-char (point-min))
(search-forward "\n\n")
(forward-char -1)
+ (save-restriction
+ (narrow-to-region beg (point))
+ (nnheader-remove-header gnus-ignored-resent-headers t))
(insert mail-header-separator)
;; Rename all old ("Also-")Resent headers.
(while (re-search-backward "^\\(Also-\\)?Resent-" beg t)
(news-setup
nil subject nil
(or sendto
- (and followup-to
- gnus-use-followup-to
- (or (not (eq gnus-use-followup-to 'ask))
- (equal followup-to newsgroups)
- (gnus-y-or-n-p
- (format "Use Followup-To %s? " followup-to)))
- followup-to)
+ (if (equal followup-to "poster")
+ (or newsgroups group "")
+ (and followup-to
+ gnus-use-followup-to
+ (or (not (eq gnus-use-followup-to 'ask))
+ (equal followup-to newsgroups)
+ (gnus-y-or-n-p
+ (format "Use Followup-To %s? " followup-to)))
+ followup-to))
newsgroups group "")
gnus-article-copy)
(gnus-inews-insert-headers gnus-required-mail-headers)
(gnus-inews-remove-empty-headers))))
(widen)
- ;; Remove the header separator.
- (goto-char (point-min))
- (and (re-search-forward
- (concat "^" (regexp-quote mail-header-separator) "$") nil t)
- (replace-match "" t t))
- ;; Run final inews hooks. This hook may do FCC.
- (run-hooks 'gnus-inews-article-hook)
- (gnus-inews-do-gcc)
- (nnheader-narrow-to-headers)
- (nnheader-remove-header "^[gf]cc:" t)
- (widen)
- (goto-char (point-min))
- (search-forward "\n\n")
- (forward-char -1)
- (insert mail-header-separator)
- (mail-send)
- (run-hooks 'gnus-message-sent-hook))
+ (when (not (gnus-inews-reject-message))
+ ;; Remove the header separator.
+ (goto-char (point-min))
+ (and (re-search-forward
+ (concat "^" (regexp-quote mail-header-separator) "$") nil t)
+ (replace-match "" t t))
+ ;; Run final inews hooks. This hook may do FCC.
+ (run-hooks 'gnus-inews-article-hook)
+ (gnus-inews-do-gcc)
+ (nnheader-narrow-to-headers)
+ (nnheader-remove-header "^[gf]cc:" t)
+ (widen)
+ (goto-char (point-min))
+ (search-forward "\n\n")
+ (forward-char -1)
+ (insert mail-header-separator)
+ (mail-send)
+ (run-hooks 'gnus-message-sent-hook)))
(defun gnus-inews-modify-mail-mode-map ()
(use-local-map (copy-keymap (current-local-map)))
(widen)
(forward-line 1)
(unless (looking-at "$")
- (forward-line 2)))))
+ (forward-line 2)))
+ (sit-for 0)))
;;; Allow redefinition of functions.
(let ((groups (gnus-group-process-prefix n)))
(while groups
(gnus-group-remove-mark (car groups))
- (gnus-soup-group-brew (car groups))
+ (gnus-soup-group-brew (car groups) t)
(setq groups (cdr groups)))
(gnus-soup-save-areas)))
(newsrc (cdr gnus-newsrc-alist)))
(while newsrc
(and (<= (nth 1 (car newsrc)) level)
- (gnus-soup-group-brew (caar newsrc)))
+ (gnus-soup-group-brew (caar newsrc) t))
(setq newsrc (cdr newsrc)))
(gnus-soup-save-areas)))
"Enter GROUP and add all articles to a SOUP package.
If NOT-ALL, don't pack ticked articles."
(let ((gnus-expert-user t)
- (gnus-large-newsgroup nil))
- (when (gnus-summary-read-group group nil t)
- (let ((gnus-newsgroup-processable
- (if (not not-all)
- (reverse (append gnus-newsgroup-marked
- gnus-newsgroup-unreads))
- (reverse gnus-newsgroup-unreads))))
- (gnus-soup-add-article nil))
- (gnus-summary-exit))))
+ (gnus-large-newsgroup nil)
+ (entry (gnus-gethash group gnus-newsrc-hashtb)))
+ (when (or (null entry)
+ (eq (car entry) t)
+ (and (car entry)
+ (> (car entry) 0))
+ (and (not not-all)
+ (gnus-range-length (cdr (assq 'tick (gnus-info-marks
+ (nth 2 entry)))))))
+ (when (gnus-summary-read-group group nil t)
+ (let ((gnus-newsgroup-processable
+ (if (not not-all)
+ (reverse (append gnus-newsgroup-marked
+ gnus-newsgroup-unreads))
+ (reverse gnus-newsgroup-unreads))))
+ (gnus-soup-add-article nil))
+ (gnus-summary-exit)))))
(defun gnus-soup-insert-idx (offset header)
;; [number subject from date id references chars lines xref]
(defvar gnus-topic-killed-topics nil)
(defvar gnus-topic-inhibit-change-level nil)
-
+(defvar gnus-topic-tallied-groups nil)
(defconst gnus-topic-line-format-alist
`((?n name ?s)
(?l level ?d)))
(defvar gnus-topic-line-format-spec nil)
-(defvar gnus-topic-active-topology nil)
-(defvar gnus-topic-active-alist nil)
;; Functions.
(lowest (or lowest 1))
tlist info)
+ (unless gnus-topic-alist
+ (gnus-topic-check-topology))
+
(unless list-topic
(erase-buffer))
(setq gnus-killed-list (sort gnus-killed-list 'string<))
gnus-level-killed ?K
regexp))
-
+
+ (setq gnus-topic-tallied-groups nil)
;; Use topics.
(when (< lowest gnus-level-zombie)
(if list-topic
(gnus-info-level info) (gnus-info-marks info)
(car entry) (gnus-info-method info)))))
(when (and (listp entry)
- (numberp (car entry)))
+ (numberp (car entry))
+ (not (member (gnus-info-group info)
+ gnus-topic-tallied-groups)))
+ (push (gnus-info-group info) gnus-topic-tallied-groups)
(incf unread (car entry))))
(goto-char beg)
;; Insert the topic line.
(when (and (eq major-mode 'gnus-group-mode)
gnus-topic-mode)
(let ((group (gnus-group-group-name)))
- (gnus-topic-goto-topic (gnus-group-parent-topic))
- (gnus-topic-update-topic-line)
- (gnus-group-goto-group group)
- (gnus-group-position-point))))
+ (when (and group (gnus-get-info group))
+ (gnus-topic-goto-topic (gnus-group-parent-topic))
+ (gnus-topic-update-topic-line)
+ (gnus-group-goto-group group)
+ (gnus-group-position-point)))))
(defun gnus-topic-goto-missing-group (group)
"Place point where GROUP is supposed to be inserted."
(gnus-define-keys
(gnus-group-topic-map "T" gnus-group-mode-map)
"#" gnus-topic-mark-topic
+ "\M-#" gnus-topic-unmark-topic
"n" gnus-topic-create-topic
"m" gnus-topic-move-group
"D" gnus-topic-remove-group
["Indent" gnus-topic-indent t])
["List active" gnus-topic-list-active t]))))
-
(defun gnus-topic-mode (&optional arg redisplay)
"Minor mode for topicsifying Gnus group buffers."
(interactive (list current-prefix-arg t))
'gnus-topic-goto-next-group)
(setq gnus-group-change-level-function 'gnus-topic-change-level)
(setq gnus-goto-missing-group-function 'gnus-topic-goto-missing-group)
- (run-hooks 'gnus-topic-mode-hook)
;; We check the topology.
- (gnus-topic-check-topology))
+ (gnus-topic-check-topology)
+ (run-hooks 'gnus-topic-mode-hook))
;; Remove topic infestation.
(unless gnus-topic-mode
(remove-hook 'gnus-summary-exit-hook 'gnus-topic-update-topic)
(defun gnus-topic-change-level (group level oldlevel)
"Run when changing levels to enter/remove groups from topics."
(when (and gnus-topic-mode
+ gnus-topic-alist
(not gnus-topic-inhibit-change-level))
;; Remove the group from the topics.
(when (and (< oldlevel gnus-level-zombie)
(defun gnus-topic-hide-topic ()
"Hide all subtopics under the current topic."
(interactive)
- (when (gnus-group-topic-p)
+ (when (gnus-group-parent-topic)
+ (gnus-topic-goto-topic (gnus-group-parent-topic))
(gnus-topic-remove-topic nil nil 'hidden)))
(defun gnus-topic-show-topic ()
(when (gnus-group-topic-p)
(gnus-topic-remove-topic t nil 'shown)))
-(defun gnus-topic-mark-topic (topic)
+(defun gnus-topic-mark-topic (topic &optional unmark)
"Mark all groups in the topic with the process mark."
(interactive (list (gnus-group-parent-topic)))
- (let ((groups (cdr (gnus-topic-find-groups topic))))
- (while groups
- (gnus-group-set-mark (gnus-info-group (nth 2 (pop groups)))))))
+ (save-excursion
+ (let ((groups (gnus-topic-find-groups topic)))
+ (while groups
+ (funcall (if unmark 'gnus-group-remove-mark 'gnus-group-set-mark)
+ (gnus-info-group (nth 2 (pop groups))))))))
+
+(defun gnus-topic-unmark-topic (topic &optional unmark)
+ "Remove the process mark from all groups in the topic."
+ (interactive (list (gnus-group-parent-topic)))
+ (gnus-topic-mark-topic topic t))
(defun gnus-topic-get-new-news-this-topic (&optional n)
"Check for new news in the current topic."
"List all groups that Gnus knows about in a topicsified fashion.
If FORCE, always re-read the active file."
(interactive "P")
- (gnus-topic-grok-active force)
+ (gnus-topic-grok-active force force)
(let ((gnus-topic-topology gnus-topic-active-topology)
(gnus-topic-alist gnus-topic-active-alist)
gnus-killed-list gnus-zombie-list)
(gnus-uu-initialize scan)
(if save (setq gnus-uu-default-dir save))
;; Create the directory we save to.
- (when (and scan cdir
+ (when (and scan cdir save
(not (file-exists-p save)))
(make-directory save t))
(let ((articles (gnus-uu-get-list-of-articles n))
(let ((function (if (< n 0) 'previous-single-property-change
'next-single-property-change))
(inhibit-point-motion-hooks t)
+ (backward (< n 0))
(limit (if (< n 0) (point-min) (point-max))))
(setq n (abs n))
(while (and (not (= limit (point)))
(goto-char (funcall function (point) 'gnus-callback nil limit)))
;; Go to the next (or previous) button.
(gnus-goto-char (funcall function (point) 'gnus-callback nil limit))
+ ;; Put point at the start of the button.
+ (when (and backward (not (get-text-property (point) 'gnus-callback)))
+ (goto-char (funcall function (point) 'gnus-callback nil limit)))
;; Skip past intangible buttons.
(when (get-text-property (point) 'intangible)
(incf n))
(not (eobp)))
(beginning-of-line)
(setq from (point))
- (search-forward ":" nil t)
+ (or (search-forward ":" nil t)
+ (forward-char 1))
(when (and header-face
(not (memq (point) hpoints)))
(push (point) hpoints)
(group-mail
(vertical 1.0
(mail 1.0 point)))
+ (group-post
+ (vertical 1.0
+ (post 1.0 point)))
(summary-mail
(vertical 1.0
(mail 1.0 point)))
(defvar gnus-server-alist nil
"List of available servers.")
+(defvar gnus-topic-active-topology nil)
+(defvar gnus-topic-active-alist nil)
+
(defvar gnus-topic-indentation "") ;; Obsolete variable.
(defvar gnus-goto-missing-group-function nil)
"gnus-bug@ifi.uio.no (The Gnus Bugfixing Girls + Boys)"
"The mail address of the Gnus maintainers.")
-(defconst gnus-version "September Gnus v0.49"
+(defconst gnus-version "September Gnus v0.50"
"Version number for this version of Gnus.")
(defvar gnus-info-nodes
(defmacro gnus-eval-in-buffer-window (buffer &rest forms)
"Pop to BUFFER, evaluate FORMS, and then return to the original window."
- `(let ((GnusStartBufferWindow (selected-window)))
- (unwind-protect
- (progn
- (pop-to-buffer ,buffer)
- ,@forms)
- (select-window GnusStartBufferWindow))))
+ (let ((tempvar (make-symbol "GnusStartBufferWindow")))
+ `(let ((,tempvar (selected-window)))
+ (unwind-protect
+ (progn
+ (pop-to-buffer ,buffer)
+ ,@forms)
+ (select-window ,tempvar)))))
(defmacro gnus-gethash (string hashtable)
"Get hash value of STRING in HASHTABLE."
(and point (goto-char point)))
(defmacro gnus-buffer-exists-p (buffer)
- `(and ,buffer
- (funcall (if (stringp ,buffer) 'get-buffer 'buffer-name)
- ,buffer)))
+ `(let ((buffer ,buffer))
+ (and buffer
+ (funcall (if (stringp buffer) 'get-buffer 'buffer-name)
+ buffer))))
(defmacro gnus-kill-buffer (buffer)
`(let ((buf ,buffer))
(set (intern (format "gnus-%s-line-format-spec" type)) val))))
(gnus-update-group-mark-positions)
- (gnus-update-summary-mark-positions)
-
- ;; See whether we need to read the description file.
- (if (and (string-match "%[-,0-9]*D" gnus-group-line-format)
- (not gnus-description-hashtb)
- gnus-read-active-file)
- (gnus-read-all-descriptions-files)))
+ (gnus-update-summary-mark-positions))
(defun gnus-update-summary-mark-positions ()
"Compute where the summary marks are to go."
(progn (goto-char (match-beginning 0)))
(re-search-forward ":"))))
(goto-char (point-min))
- (while (re-search-forward "[ \t\n]*[[{(][^()]*[]})][ \t]*$" nil t)
+ (while (re-search-forward "[ \t\n]*[[{(][^()\n]*[]})][ \t]*$" nil t)
(replace-match "" t t))
(goto-char (point-min))
(while (re-search-forward "[ \t]+" nil t)
gnus-newsgroup-headers nil
gnus-newsgroup-name nil
gnus-server-alist nil
+ gnus-group-list-mode nil
+ gnus-topic-active-topology nil
+ gnus-topic-active-alist nil
gnus-opened-servers nil
gnus-current-select-method nil)
;; Reset any score variables.
"Return a string like DD-MMM from a big messy string"
(let ((datevec (timezone-parse-date messy-date)))
(format "%2s-%s"
- (or (aref datevec 2) "??")
+ (condition-case ()
+ ;; Make sure leading zeroes are stripped.
+ (number-to-string (string-to-number (aref datevec 2)))
+ (error "??"))
(capitalize
(or (car
(nth (1- (string-to-number (aref datevec 1)))
(gnus-define-keys gnus-group-mode-map
" " gnus-group-read-group
"=" gnus-group-select-group
- "\M- " gnus-group-unhidden-select-group
"\r" gnus-group-select-group
"\M-\r" gnus-group-quick-select-group
"j" gnus-group-jump-to-group
(gnus-summary-make-display-table)
;; Do the actual startup.
- (gnus-setup-news nil level)
+ (gnus-setup-news nil level dont-connect)
;; Generate the group buffer.
(gnus-group-list-groups level)
(gnus-group-first-unread-group)
(let ((case-fold-search nil)
(props (text-properties-at (gnus-point-at-bol)))
(group (gnus-group-group-name)))
+ (set-buffer gnus-group-buffer)
(funcall gnus-group-prepare-function level unread lowest)
(if (zerop (buffer-size))
(gnus-message 5 gnus-no-groups-message)
(defun gnus-group-unmark-all-groups ()
"Unmark all groups."
+ (interactive)
(let ((groups gnus-group-marked))
(save-excursion
(while groups
(defun gnus-group-set-mark (group)
"Set the process mark on GROUP."
- (if (gnus-group-goto-group group)
+ (if (gnus-group-goto-group group)
(save-excursion
(gnus-group-mark-group 1 nil t))
- (setq gnus-group-marked
- (cons group (delete group gnus-group-marked)))))
+ (setq gnus-group-marked (cons group (delete group gnus-group-marked)))))
(defun gnus-group-universal-argument (arg &optional groups func)
"Perform any command on all groups accoring to the process/prefix convention."
(interactive
(list
current-prefix-arg
- (if (not (gnus-group-group-name))
- (error "No group on the current line")
- (string-to-int
- (let ((s (read-string
- (format "Level (default %s): " (gnus-group-group-level)))))
- (if (string-match "^\\s-*$" s)
- (int-to-string (gnus-group-group-level))
- s))))))
+ (string-to-int
+ (let ((s (read-string
+ (format "Level (default %s): "
+ (or (gnus-group-group-level)
+ gnus-level-default-subscribed)))))
+ (if (string-match "^\\s-*$" s)
+ (int-to-string (or (gnus-group-group-level)
+ gnus-level-default-subscribed))
+ s)))))
(or (and (>= level 1) (<= level gnus-level-killed))
(error "Illegal level: %d" level))
(let ((groups (gnus-group-process-prefix n))
;; first newsgroup.
(setq prev (gnus-group-group-name))
(gnus-group-change-level
- info (nth 2 info) gnus-level-killed
+ info (gnus-info-level (cdr info)) gnus-level-killed
(and prev (gnus-gethash prev gnus-newsrc-hashtb))
t)
(gnus-group-insert-group-line-info group))
(when (and group (gnus-activate-group group 'scan))
(gnus-get-unread-articles-in-group
(gnus-get-info group) (gnus-active group) t)
+ (gnus-close-group group)
(when (gnus-group-goto-group group)
(gnus-group-update-group-line))
t))
"\M-p" gnus-summary-prev-unread-subject
"f" gnus-summary-first-unread-article
"b" gnus-summary-best-unread-article
+ "j" gnus-summary-goto-article
"g" gnus-summary-goto-subject
"l" gnus-summary-goto-last-article
"p" gnus-summary-pop-article)
(gnus-carpal-setup-buffer 'summary))
(unless gnus-single-article-buffer
(make-local-variable 'gnus-article-buffer)
+ (make-local-variable 'gnus-article-current)
(make-local-variable 'gnus-original-article-buffer))
(setq gnus-newsgroup-name group)
t)))
(summary gnus-summary-buffer)
(article-buffer gnus-article-buffer)
(original gnus-original-article-buffer)
+ (gac gnus-article-current)
(score-file gnus-current-score-file))
(save-excursion
(set-buffer gnus-group-buffer)
(setq gnus-newsgroup-unreads unread)
(setq gnus-current-headers headers)
(setq gnus-newsgroup-data data)
+ (setq gnus-article-current gac)
(setq gnus-summary-buffer summary)
(setq gnus-article-buffer article-buffer)
(setq gnus-original-article-buffer original)
(or (and entry (not (eq (car entry) t))) ; Either it's active...
(gnus-activate-group group) ; Or we can activate it...
(progn ; Or we bug out.
- (kill-buffer (current-buffer))
+ (when (equal major-mode 'gnus-summary-mode)
+ (kill-buffer (current-buffer)))
(error "Couldn't request group %s: %s"
group (gnus-status-message group))))
(unless (listp (cdr gnus-newsgroup-killed))
(setq gnus-newsgroup-killed (list gnus-newsgroup-killed)))
(let ((headers gnus-newsgroup-headers))
- (gnus-close-group group)
(run-hooks 'gnus-exit-group-hook)
(unless gnus-save-score
(setq gnus-newsgroup-scored nil))
;; Make all changes in this group permanent.
(unless quit-config
(gnus-summary-update-info))
+ (gnus-close-group group)
;; Make sure where I was, and go to next newsgroup.
(set-buffer gnus-group-buffer)
(unless quit-config
(setq n (1- n)))
(if (/= 0 n) (gnus-message 7 "No more%s articles"
(if unread " unread" "")))
- (or dont-display
- (progn
- (gnus-summary-recenter)
- (gnus-summary-position-point)))
+ (unless dont-display
+ (gnus-summary-recenter)
+ (gnus-summary-position-point))
n))
(defun gnus-summary-next-unread-subject (n)
If SELECT-METHOD is symbol, do not move to a specific newsgroup, but
re-spool using this method."
(interactive "P")
- (gnus-summary-move-article n nil nil 'copy))
+ (gnus-summary-move-article n nil select-method 'copy))
(defun gnus-summary-crosspost-article (&optional n)
"Crosspost the current article to some other group."
(gnus-message
1 "The current newsgroup does not support article editing.")
(ding))
- (let ((buf (buffer-substring-no-properties (point-min) (point-max))))
+ (let ((buf (format "%s" (buffer-string))))
(erase-buffer)
(insert buf)
(if (not (gnus-request-replace-article
(gnus-summary-select-article t t nil current-article)
(set-buffer gnus-article-buffer)
(setq buffer-read-only nil)
- (let ((buf (buffer-substring-no-properties (point-min) (point-max))))
+ (let ((buf (format "%s" (buffer-string))))
(erase-buffer)
(insert buf))
(goto-char (point-min))
"Go to the same level (or less) next thread.
If PREVIOUS is non-nil, go to previous thread instead.
Return the article number moved to, or nil if moving was impossible."
- (let* ((level (gnus-summary-thread-level))
- (article (gnus-summary-article-number))
- (data (cdr (gnus-data-find-list article (gnus-data-list previous))))
- oart)
- (while data
- (if (<= (gnus-data-level (car data)) level)
- (setq oart (gnus-data-number (car data))
- data nil)
- (setq data (cdr data))))
- (and oart
- (gnus-summary-goto-subject oart))))
+ (if (and (eq gnus-summary-make-false-root 'dummy)
+ (gnus-summary-article-intangible-p))
+ (let ((beg (point)))
+ (while (and (zerop (forward-line 1))
+ (not (gnus-summary-article-intangible-p))))
+ (if (eobp)
+ (progn
+ (goto-char beg)
+ nil)
+ (point)))
+ (let* ((level (gnus-summary-thread-level))
+ (article (gnus-summary-article-number))
+ (data (cdr (gnus-data-find-list article (gnus-data-list previous))))
+ oart)
+ (while data
+ (if (<= (gnus-data-level (car data)) level)
+ (setq oart (gnus-data-number (car data))
+ data nil)
+ (setq data (cdr data))))
+ (and oart
+ (gnus-summary-goto-subject oart)))))
(defun gnus-summary-next-thread (n &optional silent)
"Go to the same level next N'th thread.
(while methods
(goto-char (point-min))
(setq method (pop methods))
- (setq match (pop method))
+ (setq match (car method))
(when (cond
((stringp match)
;; Regular expression.
(save-restriction
(widen)
(setq result (eval match)))))
- (setq split-name (append (cdr methods) split-name))
+ (setq split-name (append (cdr method) split-name))
(cond ((stringp result)
(push result split-name))
((consp result)
;;; Active & Newsrc File Handling
;;;
-(defun gnus-setup-news (&optional rawfile level)
+(defun gnus-setup-news (&optional rawfile level dont-connect)
"Setup news information.
If RAWFILE is non-nil, the .newsrc file will also be read.
If LEVEL is non-nil, the news will be set up at level LEVEL."
(let ((init (not (and gnus-newsrc-alist gnus-active-hashtb (not rawfile)))))
- ;; Clear some variables to re-initialize news information.
- (if init (setq gnus-newsrc-alist nil
- gnus-active-hashtb nil))
- ;; Read the newsrc file and create `gnus-newsrc-hashtb'.
- (if init (gnus-read-newsrc-file rawfile))
+ (when init
+ ;; Clear some variables to re-initialize news information.
+ (setq gnus-newsrc-alist nil
+ gnus-active-hashtb nil)
+ ;; Read the newsrc file and create `gnus-newsrc-hashtb'.
+ (gnus-read-newsrc-file rawfile))
(when (and (not (assoc "archive" gnus-server-alist))
gnus-message-archive-method)
(gnus-update-format-specifications)
+ ;; See whether we need to read the description file.
+ (if (and (string-match "%[-,0-9]*D" gnus-group-line-format)
+ (not gnus-description-hashtb)
+ (not dont-connect)
+ gnus-read-active-file)
+ (gnus-read-all-descriptions-files))
+
;; Find new newsgroups and treat them.
(if (and init gnus-check-new-newsgroups (not level)
(gnus-check-server gnus-select-method))
(if (and (not oldlevel)
(consp entry))
(setq oldlevel (gnus-info-level (nth 2 entry)))
- (setq oldlevel 9))
+ (setq oldlevel (or oldlevel 9)))
(if (stringp previous)
(setq previous (gnus-gethash previous gnus-newsrc-hashtb)))
;; Parse the old-style quick startup file
(defun gnus-read-old-newsrc-el-file (file)
- (let (newsrc killed marked group m)
+ (let (newsrc killed marked group m info)
(prog1
(let ((gnus-killed-assoc nil)
gnus-marked-assoc gnus-newsrc-alist gnus-newsrc-assoc)
killed gnus-killed-assoc
marked gnus-marked-assoc)))
(setq gnus-newsrc-alist nil)
- (while newsrc
- (setq group (car newsrc))
- (let ((info (gnus-get-info (car group))))
- (if info
- (progn
- (gnus-info-set-read info (cddr group))
- (gnus-info-set-level
- info (if (nth 1 group) gnus-level-default-subscribed
- gnus-level-default-unsubscribed))
- (setq gnus-newsrc-alist (cons info gnus-newsrc-alist)))
- (setq gnus-newsrc-alist
- (cons
- (setq info
- (list (car group)
- (if (nth 1 group) gnus-level-default-subscribed
- gnus-level-default-unsubscribed)
- (cddr group)))
- gnus-newsrc-alist)))
- (if (setq m (assoc (car group) marked))
- (gnus-info-set-marks
- info (cons (list (cons 'tick (gnus-compress-sequence
- (sort (cdr m) '<) t)))
- nil))))
- (setq newsrc (cdr newsrc)))
+ (while (setq info (gnus-get-info (setq group (pop newsrc))))
+ (if info
+ (progn
+ (gnus-info-set-read info (cddr group))
+ (gnus-info-set-level
+ info (if (nth 1 group) gnus-level-default-subscribed
+ gnus-level-default-unsubscribed))
+ (setq gnus-newsrc-alist (cons info gnus-newsrc-alist)))
+ (push (setq info
+ (list (car group)
+ (if (nth 1 group) gnus-level-default-subscribed
+ gnus-level-default-unsubscribed)
+ (cddr group)))
+ gnus-newsrc-alist))
+ ;; Copy marks into info.
+ (when (setq m (assoc (car group) marked))
+ (unless (nthcdr 3 info)
+ (nconc info (list nil)))
+ (gnus-info-set-marks
+ info (list (cons 'tick (gnus-compress-sequence
+ (sort (cdr m) '<) t))))))
(setq newsrc killed)
(while newsrc
(setcar newsrc (caar newsrc))
;; Write options.
(if gnus-newsrc-options (insert gnus-newsrc-options))
;; Write subscribed and unsubscribed.
- (while newsrc
- (setq info (car newsrc))
- (if (not (gnus-info-method info))
- ;; Don't write foreign groups to .newsrc.
- (progn
- (insert (gnus-info-group info)
- (if (> (gnus-info-level info) gnus-level-subscribed)
- "!" ":"))
- (if (setq ranges (gnus-info-read info))
- (progn
- (insert " ")
- (if (not (listp (cdr ranges)))
- (if (= (car ranges) (cdr ranges))
- (insert (int-to-string (car ranges)))
- (insert (int-to-string (car ranges)) "-"
- (int-to-string (cdr ranges))))
- (while ranges
- (setq range (car ranges)
- ranges (cdr ranges))
- (if (or (atom range) (= (car range) (cdr range)))
- (insert (int-to-string
- (or (and (atom range) range)
- (car range))))
- (insert (int-to-string (car range)) "-"
- (int-to-string (cdr range))))
- (if ranges (insert ","))))))
- (insert "\n")))
- (setq newsrc (cdr newsrc)))
+ (while (setq info (pop newsrc))
+ ;; Don't write foreign groups to .newsrc.
+ (when (gnus-server-equal (gnus-info-method info) gnus-select-method)
+ (insert (gnus-info-group info)
+ (if (> (gnus-info-level info) gnus-level-subscribed)
+ "!" ":"))
+ (when (setq ranges (gnus-info-read info))
+ (insert " ")
+ (if (not (listp (cdr ranges)))
+ (if (= (car ranges) (cdr ranges))
+ (insert (int-to-string (car ranges)))
+ (insert (int-to-string (car ranges)) "-"
+ (int-to-string (cdr ranges))))
+ (while ranges
+ (setq range (car ranges)
+ ranges (cdr ranges))
+ (if (or (atom range) (= (car range) (cdr range)))
+ (insert (int-to-string
+ (or (and (atom range) range)
+ (car range))))
+ (insert (int-to-string (car range)) "-"
+ (int-to-string (cdr range))))
+ (if ranges (insert ",")))))
+ (insert "\n")))
(make-local-variable 'version-control)
(setq version-control 'never)
;; It has been reported that sometime the modtime on the .newsrc
(defvar nndir-server-variables
`((nndir-directory nil)
(nndir-status-string "")
- (nndir-group-alist)))
+ (nndir-nov-is-evil ,nndir-nov-is-evil)
+ (nndir-group-alist nil)))
\f
(article-begin . ,(concat "\n\n" (make-string 30 ?-) "\n\n+"))
(prepare-body . nndoc-prepare-digest-body)
(body-end-function . nndoc-digest-body-end)
+ (head-end . "^ ?$")
+ (body-begin . "^ ?\n")
(file-end . "^End of .*digest.*[0-9].*\n\\*\\*\\|^End of.*Digest *$"))
(guess
(guess . nndoc-guess-type))
(defvar nndoc-generate-head nil)
(defvar nndoc-article-transform nil)
+(defvar nndoc-status-string "")
+(defvar nndoc-group-alist nil)
+(defvar nndoc-current-buffer nil
+ "Current nndoc news buffer.")
+(defvar nndoc-address nil)
+
+\f
+
(defvar nndoc-current-server nil)
(defvar nndoc-server-alist nil)
(defvar nndoc-server-variables
(nndoc-body-end-function nil)
(nndoc-prepare-body nil)
(nndoc-body-begin-function nil)
+ (nndoc-status-string ,nndoc-status-string)
+ (nndoc-body-end ,nndoc-body-end)
+ (nndoc-file-end ,nndoc-file-end)
+ (nndoc-file-begin ,nndoc-file-begin)
+ (nndoc-type-alist ,nndoc-type-alist)
+ (nndoc-post-type ,nndoc-post-type)
(nndoc-address nil)))
(defconst nndoc-version "nndoc 1.0"
"nndoc version.")
-(defvar nndoc-current-buffer nil
- "Current nndoc news buffer.")
-
-(defvar nndoc-address nil)
-
\f
-(defvar nndoc-status-string "")
-
-(defvar nndoc-group-alist nil)
-
;;; Interface functions
(defun nndoc-retrieve-headers (articles &optional newsgroup server fetch-old)
(defvar nneething-message-id-number 0)
(defvar nneething-work-buffer " *nneething work*")
-\f
-
(defvar nneething-directory nil)
(defvar nneething-group nil)
(defvar nneething-map nil)
(defvar nneething-read-only nil)
(defvar nneething-active nil)
+
+\f
+
+(defvar nneething-current-server nil)
+(defvar nneething-server-alist)
(defvar nneething-server-variables
`((nneething-directory ,nneething-directory)
(nneething-current-directory nil)
(nneething-status-string "")
- (nneething-group-alist)))
+ (nneething-active nil)
+ (nneething-read-only nil)
+ (nneething-map nil)
+ (nneething-group nil)
+ (nneething-work-buffer ,nneething-work-buffer)
+ (nneething-message-id-number ,nneething-message-id-number)
+ (nneething-exclude-files nil)
+ (nneething-map-file ,nneething-map-file)
+ (nneething-map-file-directory ,nneething-map-file-directory)
+ (nneething-group-alist nil)))
\f
(nnfolder-get-new-mail ,nnfolder-get-new-mail)
(nnfolder-inhibit-expiry ,nnfolder-inhibit-expiry)
(nnfolder-current-group nil)
+ (nnfolder-prepare-save-mail-hook nil)
+ (nnfolder-ignore-active-file nil)
(nnfolder-current-buffer nil)
(nnfolder-status-string "")
(nnfolder-group-alist nil)
found)
(while (not found)
(if (re-search-forward delim nil t)
- (when (looking-at "[^\000-\037\177-\377\ :]+:")
+ (when (or (looking-at "[^\n :]+ *:")
+ (looking-at delim)
+ (looking-at (concat ">" delim)))
(forward-line -1)
(setq found 'yes))
(setq found 'no)))
(goto-char (point-max))
(widen)
(setq head-end (point))
- ;; We try the Content-Length value.
+ ;; We try the Content-Length value. The idea: skip over the header
+ ;; separator, then check what happens content-length bytes into the
+ ;; message body. This should be either the end ot the buffer, the
+ ;; message separator or a blank line followed by the separator.
+ ;; The blank line should probably be deleted. If neither of the
+ ;; three is met, the content-length header is probably invalid.
(when content-length
(forward-line 1)
(setq skip (+ (point) content-length))
(when (or (= skip (point-max))
(and (< skip (point-max))
(goto-char skip)
- (looking-at delim)))
+ (or (looking-at delim)
+ (and (looking-at
+ (concat "[ \t]*\n\\(" delim "\\)"))
+ (setq skip (match-beginning 1))))))
(setq end skip)))
+ (when content-length
+ (forward-line 1)
+ (setq skip (+ (point) content-length))
+ (goto-char skip)
+ (cond ((or (= skip (point-max))
+ (= (1+ skip) (point-max)))
+ (setq end (point-max)))
+ ((looking-at delim)
+ (setq end skip))
+ ((looking-at
+ (concat "[ \t]*\n\\(" delim "\\)"))
+ (setq end (match-beginning 1)))
+ (t (setq end nil))))
(if end
(goto-char end)
;; No Content-Length, so we find the beginning of the next
(nnmbox-active-file ,nnmbox-active-file)
(nnmbox-get-new-mail ,nnmbox-get-new-mail)
(nnmbox-current-group nil)
+ (nnmbox-active-timestamp nil)
+ (nnmbox-prepare-save-mail-hook nil)
(nnmbox-status-string "")
(nnmbox-group-alist nil)))
(defvar nnmh-server-variables
`((nnmh-directory ,nnmh-directory)
(nnmh-get-new-mail ,nnmh-get-new-mail)
+ (nnmh-be-safe nil)
+ (nnmh-prepare-save-mail-hook nil)
(nnmh-current-directory nil)
(nnmh-status-string "")
(nnmh-group-alist)))
(nnml-nov-is-evil ,nnml-nov-is-evil)
(nnml-nov-file-name ,nnml-nov-file-name)
(nnml-current-directory nil)
+ (nnml-generate-active-function ,nnml-generate-active-function)
+ (nnml-article-file-alist nil)
+ (nnml-prepare-save-mail-hook nil)
(nnml-current-group nil)
(nnml-status-string "")
(nnml-nov-buffer-alist nil)
;; Rename directory.
(and (file-writable-p nnml-current-directory)
(condition-case ()
- (progn
+ (let ((parent
+ (file-name-directory
+ (directory-file-name
+ (nnmail-group-pathname new-name nnml-directory)))))
+ (unless (file-exists-p parent)
+ (make-directory parent t))
(rename-file
(directory-file-name nnml-current-directory)
(directory-file-name
(set-buffer nov-buffer)
(goto-char (point-max))
(insert (int-to-string (car files)) nov-line)))
- (widen)
- (setq files (cdr files))))
+ (widen))
+ (setq files (cdr files)))
(save-excursion
(set-buffer nov-buffer)
(write-region 1 (point-max) (expand-file-name nov) nil
(nnsoup-active-file ,nnsoup-active-file)
(nnsoup-status-string "")
(nnsoup-current-prefix 0)
+ (nnsoup-current-group nil)
+ (nnsoup-buffers nil)
+ (nnsoup-replies-list nil)
+ (nnsoup-packet-regexp ,nnsoup-packet-regexp)
+ (nnsoup-packet-directory ,nnsoup-packet-directory)
+ (nnsoup-unpacker ,nnsoup-unpacker)
+ (nnsoup-packer ,nnsoup-packer)
+ (nnsoup-replies-index-type ,nnsoup-replies-index-type)
+ (nnsoup-replies-format-type ,nnsoup-replies-format-type)
+ (nnsoup-replies-directory ,nnsoup-replies-directory)
+ (nnsoup-tmp-directory ,nnsoup-tmp-directory)
(nnsoup-group-alist nil)))
\f
(search-forward "\n\n" nil t))
(backward-char 1)
(setq delimline (point-marker))
- (if mail-aliases (expand-mail-aliases (point-min) delimline))
+ (if (and mail-aliases (fboundp 'expand-mail-aliases))
+ (expand-mail-aliases (point-min) delimline))
(goto-char (point-min))
;; ignore any blank lines in the header
(while (and (re-search-forward "\n\n\n*" delimline t)
;; Insert an extra newline if we need it to work around
;; Sun's bug that swallows newlines.
(goto-char (1+ delimline))
- (if (eval mail-mailer-swallows-blank-line)
+ (if (and (boundp 'mail-mailer-swallows-blank-line)
+ (eval mail-mailer-swallows-blank-line))
(newline)))
(let ((msg-buf
(gnus-soup-store
(nnspool-active-file ,nnspool-active-file)
(nnspool-newsgroups-file ,nnspool-newsgroups-file)
(nnspool-distributions-file ,nnspool-distributions-file)
+ (nnspool-rejected-article-hook nil)
(nnspool-history-file ,nnspool-history-file)
(nnspool-active-times-file ,nnspool-active-times-file)
(nnspool-large-newsgroup ,nnspool-large-newsgroup)
(defvar nntp-port-number "nntp"
"*Port number to connect to.")
+(defvar nntp-end-of-line "\r\n"
+ "String to use on the end of lines when talking to the NNTP server.
+This is \"\\r\\n\" by default, but should be \"\\n\" when
+using rlogin to communicate with the server.")
+
(defvar nntp-large-newsgroup 50
"*The number of the articles which indicates a large newsgroup.
If the number of the articles is greater than the value, verbose
(defvar nntp-async-fetched nil)
(defvar nntp-async-group-alist nil)
-
\f
+
(defvar nntp-current-server nil)
(defvar nntp-server-alist nil)
(defvar nntp-server-variables
(nntp-news-default-headers ,nntp-news-default-headers)
(nntp-prepare-server-hook ,nntp-prepare-server-hook)
(nntp-async-number ,nntp-async-number)
+ (nntp-open-server-function ,nntp-open-server-function)
+ (nntp-warn-about-losing-connection ,nntp-warn-about-losing-connection)
+ (nntp-retry-on-break nil)
+ (nntp-command-timeout nil)
+ (nntp-nov-gap ,nntp-nov-gap)
+ (nntp-rlogin-parameters ,nntp-rlogin-parameters)
+ (nntp-rlogin-user-name ,nntp-rlogin-user-name)
+ (nntp-end-of-line ,nntp-end-of-line)
(nntp-server-type nil)
(nntp-async-process nil)
(nntp-async-buffer nil)
(while nntp-opened-connections
(when (setq proc (pop nntp-opened-connections))
(condition-case ()
- (process-send-string proc "QUIT\r\n")
+ (process-send-string proc (concat "QUIT" nntp-end-of-line))
(error nil))
(delete-process proc)))
(and nntp-async-buffer
;; Insert newline at end of buffer.
(or (bolp) (insert "\n"))
;; Insert `.' at end of buffer (end of text mark).
- (insert ".\r\n")))
+ (insert "." nntp-end-of-line)))
\f
;;;
(defun nntp-send-strings-to-server (&rest strings)
"Send STRINGS to the server."
- (let ((cmd (concat (mapconcat 'identity strings " ") "\r\n")))
+ (let ((cmd (concat (mapconcat 'identity strings " ") nntp-end-of-line)))
;; We open the nntp server if it is down.
(or (nntp-server-opened nntp-current-server)
(nntp-open-server nntp-current-server)
(defun nntp-read-server-type ()
"Find out what the name of the server we have connected to is."
;; Wait for the status string to arrive.
- (nntp-wait-for-response "^.*\n")
+ (nntp-wait-for-response "^.*\n" t)
(setq nntp-server-type (buffer-string))
(let ((alist nntp-server-action-alist)
entry)
"nntpd" nntp-server-buffer server nntp-port-number))
(defun nntp-open-rlogin (server)
- (let ((proc (start-process "nntpd" nntp-server-buffer "rsh" server)))
- (process-send-string proc (mapconcat 'identity nntp-rlogin-parameters
- " "))
- (process-send-string proc "\n")))
+ (let ((proc (if nntp-rlogin-user-name
+ (start-process "nntpd" nntp-server-buffer "rsh"
+ "-l"
+ nntp-rlogin-user-name
+ server
+ (mapconcat 'identity
+ nntp-rlogin-parameters " "))
+ (start-process "nntpd" nntp-server-buffer "rsh"
+ server
+ (mapconcat 'identity
+ nntp-rlogin-parameters " ")))))
+ proc))
(defun nntp-telnet-to-machine ()
(let (b)
(setq articles (cdr articles))))))
(defun nntp-async-send-strings (&rest strings)
- (let ((cmd (concat (mapconcat 'identity strings " ") "\r\n")))
+ (let ((cmd (concat (mapconcat 'identity strings " ") nntp-end-of-line)))
(or (nntp-async-server-opened)
(nntp-async-open-server)
(error (nntp-status-message)))
(get-buffer-create " *virtual headers*")))
(unfetched (mapcar (lambda (g) (list g))
nnvirtual-component-groups))
+ (system-name (system-name))
beg cgroup active article result prefix)
(while articles
(setq article (assq (pop articles) nnvirtual-mapping))
(while (not (eobp))
(delete-region
(point) (progn (read nntp-server-buffer) (point)))
- (insert (int-to-string (car article)))
+ (princ (car article) (current-buffer))
(beginning-of-line)
(looking-at
"[^\t]*\t[^\t]*\t[^\t]*\t[^\t]*\t[^\t]*\t[^\t]*\t[^\t]*\t")
(end-of-line)
(or (= (char-after (1- (point))) ?\t)
(insert ?\t))
- (insert (format "Xref: %s %s:%d\t" (system-name)
- cgroup (caddr article))))
- (insert (format "Xref: %s %s:%d " (system-name)
- cgroup (caddr article)))
+ (insert "Xref: " system-name " " cgroup ":")
+ (princ (caddr article) (current-buffer))
+ (insert "\t"))
+ (insert "Xref: " system-name " " cgroup ":")
+ (princ (caddr article) (current-buffer))
+ (insert " ")
(if (not (string= "" prefix))
(while (re-search-forward
"[^ ]+:[0-9]+"
(cond
((null (nnvirtual-possibly-change-group
group server
- (if nnvirtual-always-rescan nil dont-check)))
+ (if nnvirtual-always-rescan nil (not dont-check))))
(setq nnvirtual-current-group nil)
(nnheader-report 'nnvirtual "No component groups in %s" group))
(t
(concat "Xref: " (mail-header-xref header) "\t")
"") "\n")))))
-(defun nnvirtual-possibly-change-group (group regexp &optional dont-check)
+(defun nnvirtual-possibly-change-group (group regexp &optional check)
(let ((inf t))
- (unless (equal group nnvirtual-current-group)
+ (when (or (not (equal group nnvirtual-current-group))
+ check)
(and (setq inf (assoc group nnvirtual-group-alist))
regexp
(string= (nth 3 inf) regexp)
(progn
(setq nnvirtual-current-group (car inf))
(setq nnvirtual-component-groups (nth 1 inf))
- (setq nnvirtual-mapping (nth 2 inf)))))
- (when (and regexp
- (or (not inf)
- (not dont-check)))
- (and inf (setq nnvirtual-group-alist
- (delq inf nnvirtual-group-alist)))
- (setq nnvirtual-mapping nil)
- (setq nnvirtual-current-group group)
- (let ((newsrc gnus-newsrc-alist)
- (virt-group (gnus-group-prefixed-name
- nnvirtual-current-group '(nnvirtual ""))))
- (setq nnvirtual-component-groups nil)
- (while newsrc
- (and (string-match regexp (caar newsrc))
- (not (string= (caar newsrc) virt-group))
- (setq nnvirtual-component-groups
- (cons (caar newsrc) nnvirtual-component-groups)))
- (setq newsrc (cdr newsrc))))
- (if nnvirtual-component-groups
- (progn
- (nnvirtual-create-mapping)
- (setq nnvirtual-group-alist
- (cons (list group nnvirtual-component-groups
- nnvirtual-mapping regexp)
- nnvirtual-group-alist)))
- (nnheader-report 'nnvirtual "No component groups: %s" group))))
+ (setq nnvirtual-mapping (nth 2 inf))))
+ (when (and regexp (not inf))
+ (and inf (setq nnvirtual-group-alist
+ (delq inf nnvirtual-group-alist)))
+ (setq nnvirtual-mapping nil)
+ (setq nnvirtual-current-group group)
+ (let ((newsrc gnus-newsrc-alist)
+ (virt-group (gnus-group-prefixed-name
+ nnvirtual-current-group '(nnvirtual ""))))
+ (setq nnvirtual-component-groups nil)
+ (while newsrc
+ (and (string-match regexp (caar newsrc))
+ (not (string= (caar newsrc) virt-group))
+ (setq nnvirtual-component-groups
+ (cons (caar newsrc) nnvirtual-component-groups)))
+ (setq newsrc (cdr newsrc))))
+ (if nnvirtual-component-groups
+ (progn
+ (nnvirtual-create-mapping)
+ (setq nnvirtual-group-alist
+ (cons (list group nnvirtual-component-groups
+ nnvirtual-mapping regexp)
+ nnvirtual-group-alist)))
+ (nnheader-report 'nnvirtual "No component groups: %s" group)))))
nnvirtual-component-groups)
(defun nnvirtual-update-marked ()
(caar cgroups) type (cdar cgroups) nil t)
(gnus-group-update-group (car (pop cgroups)) t)))))
-(defun nnvirtual-marks (article marks)
+(defsubst nnvirtual-marks (article marks)
"Return a list of mark types for ARTICLE."
(let (out)
(while marks
+Wed Mar 6 21:18:04 1996 Lars Magne Ingebrigtsen <lars@eyesore.no>
+
+ * gnus.texi (Topic Commands): Addition.
+ (Kill Files): Addition.
+ (Summary Maneuvering): Change.
+ (Summary Maneuvering): Addition.
+ (Saving Articles): Addition.
+
+Mon Mar 4 23:16:56 1996 Lars Ingebrigtsen <lars@eyesore.no>
+
+ * gnus.texi (Compilation ): Change.
+
+Sun Mar 3 21:56:46 1996 Lars Ingebrigtsen <lars@eyesore.no>
+
+ * gnus.texi (NNTP): Addition.
+ (Post): Addition.
+
Fri Mar 1 20:52:50 1996 Lars Ingebrigtsen <lars@eyesore.no>
* gnus.texi (Customizing Threading): Change.
# MAKEINFO=makeinfo -o gnus.info gnus.texi
LATEX=latex
DVIPS=dvips
+PERL=perl
all: gnus.info refcard.dvi
$(MAKEINFO)
dvi: gnus.texi
- perl -n -e ' if (/@iflatex/) { $$latex=1; } if (!$$latex) { print; } if (/@end iflatex/) { $$latex=0; }' gnus.texi > gnus.tmptexi
+ $(PERL) -n -e 'if (/\@iflatex/) { $$latex=1; } if (!$$latex) { print; } if (/\@end iflatex/) { $$latex=0; }' gnus.texi > gnus.tmptexi
$(TEXI2DVI) gnus.tmptexi
refcard.dvi: refcard.tex
minimum amount off fuzz (@code{gnus-group-quick-select-group}). No
scoring/killing will be performed, there will be no highlights and no
expunging. This might be useful if you're in a real hurry and have to
-enter some humongous groups.
+enter some humongous group.
@item M-SPACE
@kindex M-RET (Group)
Copy all groups that match some regular expression to a topic
(@code{gnus-topic-copy-matching}).
+@item T #
+@kindex T # (Group)
+@findex gnus-topic-mark-topic
+Mark all groups in the current topic with the process mark
+(@code{gnus-topic-mark-topic}).
+
+@item T M-#
+@kindex T M-# (Group)
+@findex gnus-topic-unmark-topic
+Remove the process mark from all groups in the current topic
+(@code{gnus-topic-unmark-topic}).
+
@item RET
@kindex RET (Group)
@findex gnus-topic-select-group
Go to the previous summary line of an unread article
(@code{gnus-summary-prev-unread-subject}).
-@item G g
+@item G j
@itemx j
@kindex j (Summary)
+@kindex G j (Summary)
+@findex gnus-summary-goto-article
+Ask for an article number and then go that article
+(@code{gnus-summary-goto-article}).
+
+@item G g
@kindex G g (Summary)
@findex gnus-summary-goto-subject
-Ask for an article number and then go to this summary line
-(@code{gnus-summary-goto-subject}).
+Ask for an article number and then go the summary line of that article
+(@code{gnus-summary-goto-subject}).
@end table
If Gnus asks you to press a key to confirm going to the next group, you
@item S D r
@kindex S D r (Summary)
@findex gnus-summary-resend-message
+@vindex gnus-ignored-resent-headers
Not to be confused with the previous command,
@code{gnus-summary-resend-message} will prompt you for an address to
send the current message off to, and then send it to that place. The
@code{Resent-To}, @code{Resent-From} and so on will be added. This
means that you actually send a mail to someone that has a @code{To}
header that (probably) points to yourself. This will confuse people.
-So, natcherly you'll only do that if you're really eVIl.
+So, natcherly you'll only do that if you're really eVIl. All old
+headers that match the regular expression
+@code{gnus-ignored-resent-headers} will be deleted before resending the
+message. The default is @samp{"^Return-receipt"}.
This command is mainly used if you have several accounts and want to
ship a mail to a different account of yours. (If you're both
Save the current article in mh folder format
(@code{gnus-summary-save-article-folder}).
+@item O v
+@kindex O v (Summary)
+@findex gnus-summary-save-article-vm
+Save the current article in a VM folder
+(@code{gnus-summary-save-article-vm}).
+
@item O p
@kindex O p (Summary)
@findex gnus-summary-pipe-output
@item W w
@kindex W w (Summary)
-@findex gnus-article-word-wrap
-Do word wrap (@code{gnus-article-word-wrap}).
+@findex gnus-article-fill-cited-article
+Do word wrap (@code{gnus-article-fill-cited-article}).
@item W c
@kindex W c (Summary)
@item B q
@kindex B q (Summary)
-@findex gnus-summary-fancy-query
+@findex gnus-summary-respool-query
If you want to re-spool an article, you might be curious as to what group
the article will end up in before you do the re-spooling. This command
-will tell you (@code{gnus-summary-fancy-query}).
+will tell you (@code{gnus-summary-respool-query}).
@end table
@vindex gnus-move-split-methods
All these conditions are checked by default.
+@item gnus-sent-message-ids-file
+@vindex gnus-sent-message-ids-file
+Gnus will keep a @code{Message-ID} history file of all the mails it has
+sent. If it discovers that it has already sent a mail, it will ask the
+user whether to re-send the mail. (This is primarily useful when
+dealing with @sc{soup} packets and the like where one is apt to sent the
+same packet multiple times.) This variable says what the name of this
+history file is. It is @file{~/News/Sent-Message-IDs} by default. Set
+this variable to @code{nil} if you don't want Gnus to keep a history
+file.
+
+@item gnus-sent-message-ids-length
+@vindex gnus-sent-message-ids-length
+This variable says how many @code{Message-ID}s to keep in the history
+file. It is 1000 by default.
+
@end table
This hook is run as the last step when connecting to an @sc{nntp}
server.
-@c @findex nntp-open-rlogin
-@c @findex nntp-open-network-stream
-@c @item nntp-open-server-function
-@c @vindex nntp-open-server-function
-@c This function is used to connect to the remote system. Two pre-made
-@c functions are @code{nntp-open-network-stream}, which is the default, and
-@c simply connects to some port or other on the remote system. The other
-@c is @code{nntp-open-rlogin}, which does an rlogin on the remote system,
-@c and then does a telnet to the @sc{nntp} server available there.
-@c
-@c @item nntp-rlogin-parameters
-@c @vindex nntp-rlogin-parameters
-@c If you use @code{nntp-open-rlogin} as the
-@c @code{nntp-open-server-function}, this list will be used as the
-@c parameter list given to @code{rsh}.
-@c
-@c @item nntp-rlogin-user-name
-@c @vindex nntp-rlogin-user-name
-@c User name on the remote system when using the @code{rlogin} connect
-@c function.
+@findex nntp-open-rlogin
+@findex nntp-open-network-stream
+@item nntp-open-server-function
+@vindex nntp-open-server-function
+This function is used to connect to the remote system. Two pre-made
+functions are @code{nntp-open-network-stream}, which is the default, and
+simply connects to some port or other on the remote system. The other
+is @code{nntp-open-rlogin}, which does an rlogin on the remote system,
+and then does a telnet to the @sc{nntp} server available there.
+
+@item nntp-rlogin-parameters
+@vindex nntp-rlogin-parameters
+If you use @code{nntp-open-rlogin} as the
+@code{nntp-open-server-function}, this list will be used as the
+parameter list given to @code{rsh}.
+
+@item nntp-end-of-line
+@vindex nntp-end-of-line
+String to use as end-of-line markers when talking to the @sc{nntp}
+server. This is @samp{\r\n} by default, but should be @samp{\n} when
+using @code{rlogin} to talk to the server.
+
+@item nntp-rlogin-user-name
+@vindex nntp-rlogin-user-name
+User name on the remote system when using the @code{rlogin} connect
+function.
@item nntp-address
@vindex nntp-address
@item orphan
The value of this entry should be a number. Articles that do not have
-parents will get this number added to their scores.
+parents will get this number added to their scores. Imagine you follow
+some high-volume newsgroup, like @samp{comp.lang.c}. Most likely you
+will only follow a few of the threads, also want to see any new threads.
+
+You can do this with the following two score file entries:
+
+@example
+ (orphan -500)
+ (mark-and-expunge -100)
+@end example
+
+When you enter the group the first time, you will only see the new
+threads. You then raise the score of the threads that you find
+interesting (with @kbd{I T} or @kbd{I S}), and ignore (@kbd{C y}) the
+rest. Next time you enter the group, you will see new articles in the
+interesting threads, plus any new threads.
+
+I.e. -- the orphan score atom is for high-volume groups where there
+exist a few interesting threads which can't be found automatically by
+ordinary scoring rules.
@item adapt
This entry controls the adaptive scoring. If it is @code{t}, the
encounters what looks like a @code{rn} kill file, it will take a stab at
interpreting it.
-Two functions for editing a GNUS kill file:
+Two summary functions for editing a GNUS kill file:
@table @kbd
Edit the general kill file (@code{gnus-summary-edit-global-kill}).
@end table
+Two group mode functions for editing the kill files:
+
+@table @kbd
+
+@item M-k
+@kindex M-k (Group)
+@findex gnus-group-edit-local-kill
+Edit this group's kill file (@code{gnus-group-edit-local-kill}).
+
+@item M-K
+@kindex M-K (Group)
+@findex gnus-group-edit-global-kill
+Edit the general kill file (@code{gnus-group-edit-global-kill}).
+@end table
+
Kill file variables:
@table @code
* Interactive:: Making Gnus ask you many questions.
* Formatting Variables:: You can specify what buffers should look like.
* Windows Configuration:: Configuring the Gnus buffer windows.
-* Compilation and Init File:: How to speed Gnus up.
+* Compilation:: How to speed Gnus up.
* Mode Lines:: Displaying information in the mode lines.
* Highlighting and Menus:: Making buffers look all nice and cozy.
* Buttons:: Get tendonitis in ten easy steps!
Gnus has been loaded.
-@node Compilation and Init File
-@section Compilation and Init File
+@node Compilation
+@section Compilation
@cindex compilation
-@cindex init file
@cindex byte-compilation
-@vindex gnus-init-file
@findex gnus-compile
-When Gnus starts up, it will read the Gnus init file
-@code{gnus-init-file}, which is @file{.gnus} by default. It is
-recommended that you keep any Gnus-related functions that you have
-written in that file. If you want to byte-compile the file, Gnus offers
-the handy @kbd{M-x gnus-compile} function that will do that for you.
-
-That's not really why that function was written, though.
Remember all those line format specification variables?
@code{gnus-summary-line-format}, @code{gnus-group-line-format}, and so
associated with them, while the user-generated versions do not, of
course.)
-To help with this, you can run @code{gnus-compile} after you've fiddled
-around with the variables and feel that you're (kind of) satisfied.
-This will result in the new specs being byte-compiled, and you'll get
-top speed again.
-
-The result of these byte-compilations will be written to
-@file{.gnus.elc} by default.
-
-Note that Gnus will read @file{.gnus.elc} instead of @file{.gnus} if
-@file{.gnus.elc} exists, so if you change @file{.gnus}, you should
-remove @file{.gnus.elc}.
+To help with this, you can run @kbd{M-x gnus-compile} after you've
+fiddled around with the variables and feel that you're (kind of)
+satisfied. This will result in the new specs being byte-compiled, and
+you'll get top speed again.
@node Mode Lines
projects / gnus / commitdiff