+Wed Feb 28 04:39:49 1996 Lars Ingebrigtsen <lars@eyesore.no>
+
+ * gnus.el (gnus-read-active-file): Don't try to retrieve groups
+ when no can be found.
+ (gnus-find-method-for-group): Return "cleaner" select methods.
+
+ * gnus-uu.el (gnus-uu-uustrip-article): Don't loop forever if the
+ uudecode is silent.
+
+ * nnmail.el (nnmail-search-unix-mail-delim): Stricter 822-delim
+ format.
+
+ * gnus.el (gnus-summary-local-variables): Didn't clear
+ `gnus-cache-removable-articles'.
+ (gnus-buffer-configuration): Display article-copy in reply and
+ followup.
+
+ * nnvirtual.el (nnvirtual-retrieve-headers): Always insert new
+ Xref headers.
+
+ * gnus.el (gnus-add-marked-articles): Remove empty mark lists.
+
+ * nnvirtual.el (nnvirtual-retrieve-headers): Propagate
+ `fetch-old'.
+
+ * gnus.el (gnus-check-server): Accept a `silent' parameter.
+
+ * nnvirtual.el (nnvirtual-retrieve-headers): Make sure the proper
+ server is opened.
+
+ * gnus.el (gnus-recenter): Don't do unconditional horizontal
+ recentering.
+
+ * gnus-vis.el (gnus-article-next-button): Skip past intangible
+ buttons.
+
+ * gnus-msg.el (gnus-inews-insert-archive-gcc): Don't do archiving
+ if `gnus-message-archive-method' is nil.
+
+ * gnus.el (gnus-find-method-for-group): Don't add `*-address'
+ indiscriminately.
+
+Tue Feb 27 08:50:10 1996 Lars Ingebrigtsen <lars@eyesore.no>
+
+ * gnus-msg.el (gnus-draft-group): Would return a bogus group
+ name.
+
+ * nndir.el (nndir-open-server): Escape ftp errors.
+
+ * gnus-msg.el (gnus-mail-reply): Handle "always" Mail-Reply-To.
+ (gnus-debug): Produced messy bug reports.
+
Tue Feb 27 04:04:17 1996 Lars Magne Ingebrigtsen <larsi@ylfing.ifi.uio.no>
+ * gnus.el: 0.45 is released.
+
* nntp.el (nntp-retry-on-break): New variable.
(nntp-send-command): Use it.
(save-restriction
(while (cdr marks)
(widen)
- (narrow-to-region (car (car marks)) (car (cadr marks)))
- (let ((adaptive-fill-regexp (concat "^" (regexp-quote
- (cdr (car marks)))
- " *"))
- (fill-prefix (cdr (car marks))))
+ (narrow-to-region (caar marks) (caadr marks))
+ (let ((adaptive-fill-regexp
+ (concat "^" (regexp-quote (cdar marks)) " *"))
+ (fill-prefix (cdar marks)))
(fill-region (point-min) (point-max)))
(set-marker (caar marks) nil)
(setq marks (cdr marks)))
(re-search-backward gnus-signature-separator nil t)
(setq total (count-lines start (point)))
(while atts
- (setq hiden (+ hiden (length (cdr (assoc (cdr (car atts))
+ (setq hiden (+ hiden (length (cdr (assoc (cdar atts)
gnus-cite-prefix-alist))))
atts (cdr atts)))
(if (or force
(progn
(setq atts gnus-cite-attribution-alist)
(while atts
- (setq total (cdr (assoc (cdr (car atts))
- gnus-cite-prefix-alist))
+ (setq total (cdr (assoc (cdar atts) gnus-cite-prefix-alist))
atts (cdr atts))
(while total
(setq hiden (car total)
(if (null arg) (not gnus-grouplens-mode)
(> (prefix-numeric-value arg) 0)))
(when gnus-grouplens-mode
- (make-local-hook 'gnus-select-article-hook)
- (add-hook 'gnus-select-article-hook 'grouplens-do-time nil 'local)
- (make-local-hook 'gnus-exit-group-hook)
- (add-hook 'gnus-exit-group-hook 'bbb-put-ratings nil 'local)
+ (if (not (fboundp 'make-local-hook))
+ (add-hook 'gnus-select-article-hook 'grouplens-do-time)
+ (make-local-hook 'gnus-select-article-hook)
+ (add-hook 'gnus-select-article-hook 'grouplens-do-time nil 'local))
+ (if (not (fboundp 'make-local-hook))
+ (add-hook 'gnus-exit-group-hook 'bbb-put-ratings)
+ (make-local-hook 'gnus-exit-group-hook)
+ (add-hook 'gnus-exit-group-hook 'bbb-put-ratings nil 'local))
(make-local-variable 'gnus-score-find-score-files-function)
(if gnus-grouplens-override-scoring
(setq gnus-score-find-score-files-function
(erase-buffer)
(insert string ":\n\n")
(while alist
- (insert (format " %c: %s\n" (car (car alist)) (nth idx (car alist))))
+ (insert (format " %c: %s\n" (caar alist) (nth idx (car alist))))
(setq alist (cdr alist)))))
(defun gnus-kill-parse-gnus-kill-file ()
(if (or (not (consp (nth 2 object)))
(not (consp (cdr (nth 2 object))))
(and (eq 'quote (car (nth 2 object)))
- (not (consp (cdr (car (cdr (nth 2 object))))))))
+ (not (consp (cdadr (nth 2 object))))))
(concat "\n" (prin1-to-string object))
(save-excursion
(set-buffer (get-buffer-create "*Gnus PP*"))
(buffer-disable-undo (current-buffer))
(erase-buffer)
(insert (format "\n(%S %S\n '(" (nth 0 object) (nth 1 object)))
- (let ((klist (car (cdr (nth 2 object))))
+ (let ((klist (cadr (nth 2 object)))
(first t))
(while klist
(insert (if first (progn (setq first nil) "") "\n ")
(when (and from
(not (gnus-check-before-posting 'sender))
(not (string=
- (downcase (car (cdr (gnus-extract-address-components
- from))))
+ (downcase (cadr (gnus-extract-address-components from)))
(downcase (gnus-inews-real-user-address))))
(or (null sender)
(not
(string=
- (downcase (car (cdr (gnus-extract-address-components
- sender))))
+ (downcase
+ (cadr (gnus-extract-address-components sender)))
(downcase secure-sender)))))
(goto-char (point-min))
;; Rename any old Sender headers to Original-Sender.
(setq message-id (match-string 0 gnus-warning)))
(setq mctdo (not (equal mct "never")))
+ (when (and mct (string= (downcase mct) "always"))
+ (setq mct (or reply-to from)))
(if (not (and followup (not to-address)))
- (setq new-to (or reply-to from))
+ (setq new-to (or reply-to from)
+ new-cc
+ (if (and mctdo
+ (not (string=
+ (mail-strip-quoted-names mct)
+ (mail-strip-quoted-names
+ (or to-address
+ (if (and follow-to
+ (not (stringp follow-to)))
+ sendto
+ (or follow-to new-to
+ sender "")))))))
+ mct))
(let (ccalist)
(save-excursion
(gnus-set-work-buffer)
(and (re-search-forward "^Newsgroups:" nil t)
(forward-line 1))
(while follow-to
- (insert (car (car follow-to)) ": "
- (cdr (car follow-to)) "\n")
+ (insert (caar follow-to) ": " (cdar follow-to) "\n")
(setq follow-to (cdr follow-to)))))
;; If a distribution existed, we use it.
(while olist
(if (boundp (car olist))
(insert
- (pp-to-string
- `(setq ,(symbol-name (car olist))
- ,(if (or (consp (setq sym (symbol-value (car olist))))
- (and (symbolp sym)
- (not (or (eq sym nil)
- (eq sym t)))))
- (list 'quote (symbol-value (car olist)))
- (symbol-value (car olist)))
- "\n")))
+ (condition-case ()
+ (pp-to-string
+ `(setq ,(car olist)
+ ,(if (or (consp (setq sym (symbol-value (car olist))))
+ (and (symbolp sym)
+ (not (or (eq sym nil)
+ (eq sym t)))))
+ (list 'quote (symbol-value (car olist)))
+ (symbol-value (car olist)))))
+ (error
+ (format "(setq %s 'whatever)\n" (car olist)))))
(insert ";; (makeunbound '" (symbol-name (car olist)) ")\n"))
(setq olist (cdr olist)))
(insert "\n\n")
result
(groups
(cond
+ ((null gnus-message-archive-method)
+ ;; Ignore.
+ nil)
((stringp var)
;; Just a single group.
(list var))
(defun gnus-draft-group ()
"Return the name of the draft group."
(gnus-group-prefixed-name
- (file-name-nondirectory gnus-draft-group-directory)
+ (file-name-nondirectory (directory-file-name gnus-draft-group-directory))
(list 'nndraft gnus-draft-group-directory)))
(defun gnus-make-draft-group ()
(insert "\n"))
(setq pad (- width 3))
(setq format (concat "%c: %-" (int-to-string pad) "s"))
- (insert (format format (car (car alist)) (nth idx (car alist))))
+ (insert (format format (caar alist) (nth idx (car alist))))
(setq alist (cdr alist))
(setq i (1+ i))))
;; display ourselves in a small window at the bottom
(set-buffer gnus-summary-buffer)
(while local
(and (consp (car local))
- (symbolp (car (car local)))
+ (symbolp (caar local))
(progn
- (make-local-variable (car (car local)))
- (set (car (car local)) (nth 1 (car local)))))
+ (make-local-variable (caar local))
+ (set (caar local) (nth 1 (car local)))))
(setq local (cdr local)))))
(if orphan (setq gnus-orphan-score orphan))
(setq gnus-adaptive-score-alist
(cond
((not (listp (car a)))
(format "Illegal score element %s in %s" (car a) file))
- ((stringp (car (car a)))
+ ((stringp (caar a))
(cond
- ((not (listp (setq sr (cdr (car a)))))
+ ((not (listp (setq sr (cdar a))))
(format "Illegal header match %s in %s" (nth 1 (car a)) file))
(t
(setq type (caar a))
(setq out (cons entry out))
(while scor
(setcar scor
- (list (car (car scor)) (nth 2 (car scor))
+ (list (caar scor) (nth 2 (car scor))
(and (nth 3 (car scor))
(gnus-day-number (nth 3 (car scor))))
(if (nth 1 (car scor)) 'r 's)))
;; Add articles to `gnus-newsgroup-scored'.
(while gnus-scores-articles
- (or (= gnus-summary-default-score (cdr (car gnus-scores-articles)))
+ (or (= gnus-summary-default-score (cdar gnus-scores-articles))
(setq gnus-newsgroup-scored
(cons (cons (mail-header-number
- (car (car gnus-scores-articles)))
- (cdr (car gnus-scores-articles)))
+ (caar gnus-scores-articles))
+ (cdar gnus-scores-articles))
gnus-newsgroup-scored)))
(setq gnus-scores-articles (cdr gnus-scores-articles)))
;; time than one would gain.
(while articles
(and (funcall match-func
- (or (aref (car (car articles)) gnus-score-index) 0)
+ (or (aref (caar articles) gnus-score-index) 0)
match)
(progn
(and trace (setq gnus-score-trace
kill)
gnus-score-trace)))
(setq found t)
- (setcdr (car articles) (+ score (cdr (car articles))))))
+ (setcdr (car articles) (+ score (cdar articles)))))
(setq articles (cdr articles)))
;; Update expire date
(cond ((null date)) ;Permanent entry.
;; time than one would gain.
(while articles
(and
- (setq l (aref (car (car articles)) gnus-score-index))
+ (setq l (aref (caar articles) gnus-score-index))
(funcall match-func match (timezone-make-date-sortable l))
(progn
(and trace (setq gnus-score-trace
kill)
gnus-score-trace)))
(setq found t)
- (setcdr (car articles) (+ score (cdr (car articles))))))
+ (setcdr (car articles) (+ score (cdar articles)))))
(setq articles (cdr articles)))
;; Update expire date
(cond ((null date)) ;Permanent entry.
(save-restriction
(let* ((buffer-read-only nil)
(articles gnus-scores-articles)
- (last (mail-header-number (car (car gnus-scores-articles))))
+ (last (mail-header-number (caar gnus-scores-articles)))
(all-scores scores)
(request-func (cond ((string= "head" (downcase header))
'gnus-request-head)
(setq ofunc request-func)
(setq request-func 'gnus-request-article)))
(while articles
- (setq article (mail-header-number (car (car articles))))
+ (setq article (mail-header-number (caar articles)))
(gnus-message 7 "Scoring on article %s of %s..." article last)
(if (not (funcall request-func article gnus-newsgroup-name))
()
(if (funcall search-func match nil t)
;; Found a match, update scores.
(progn
- (setcdr (car articles) (+ score (cdr (car articles))))
+ (setcdr (car articles) (+ score (cdar articles)))
(setq found t)
(and trace (setq gnus-score-trace
(cons
;; Don't enter a score if there already is one.
(while (setq entry (pop scores))
(and (equal "references" (car entry))
- (or (null (nth 3 (car (cdr entry))))
- (eq 's (nth 3 (car (cdr entry)))))
+ (or (null (nth 3 (cadr entry)))
+ (eq 's (nth 3 (cadr entry))))
(assoc id entry)
(setq dont t)))
(unless dont
(setq elem (cdr elem))
(while elem
(setcdr (car elem)
- (cons (if (eq (car (car elem)) 'followup)
+ (cons (if (eq (caar elem) 'followup)
"references"
- (symbol-name (car (car elem))))
- (cdr (car elem))))
+ (symbol-name (caar elem)))
+ (cdar elem)))
(setcar (car elem)
`(lambda (h)
(,(intern
(concat "mail-header-"
- (if (eq (car (car elem)) 'followup)
+ (if (eq (caar elem) 'followup)
"message-id"
- (downcase (symbol-name (car (car elem)))))))
+ (downcase (symbol-name (caar elem))))))
h)))
(setq elem (cdr elem)))
(setq malist (cdr malist)))
()
(when (setq headers (gnus-data-header (car data)))
(while elem
- (setq match (funcall (car (car elem)) headers))
+ (setq match (funcall (caar elem) headers))
(gnus-summary-score-entry
(nth 1 (car elem)) match
(cond
(gnus-add-current-to-buffer-list)
(erase-buffer)
(while trace
- (insert (format "%S -> %s\n" (cdr (car trace))
- (file-name-nondirectory (car (car trace)))))
+ (insert (format "%S -> %s\n" (cdar trace)
+ (file-name-nondirectory (caar trace))))
(setq trace (cdr trace)))
(goto-char (point-min))
(pop-to-buffer buf)))
(cdr score-files) ;ensures caching groups with no matches
;; handle the multiple match alist
(while alist
- (and (string-match (car (car alist)) group)
+ (and (string-match (caar alist) group)
(setq score-files
- (nconc score-files (copy-sequence (cdr (car alist))))))
+ (nconc score-files (copy-sequence (cdar alist)))))
(setq alist (cdr alist)))
(setq alist gnus-score-file-single-match-alist)
;; handle the single match alist
(while alist
- (and (string-match (car (car alist)) group)
+ (and (string-match (caar alist) group)
;; progn used just in case ("regexp") has no files
;; and score-files is still nil. -sj
;; this can be construed as a "stop searching here" feature :>
;; and used to simplify regexps in the single-alist
(progn
(setq score-files
- (nconc score-files (copy-sequence (cdr (car alist)))))
+ (nconc score-files (copy-sequence (cdar alist))))
(setq alist nil)))
(setq alist (cdr alist)))
;; cache the score files
(newsrc (cdr gnus-newsrc-alist)))
(while newsrc
(and (<= (nth 1 (car newsrc)) level)
- (gnus-soup-group-brew (car (car newsrc))))
+ (gnus-soup-group-brew (caar newsrc)))
(setq newsrc (cdr newsrc)))
(gnus-soup-save-areas)))
(save-excursion
(while prefix
(gnus-set-work-buffer)
- (insert (format "(setq gnus-soup-prev-prefix %d)\n"
- (cdr (car prefix))))
- (gnus-make-directory (car (car prefix)))
+ (insert (format "(setq gnus-soup-prev-prefix %d)\n" (cdar prefix)))
+ (gnus-make-directory (caar prefix))
(write-region (point-min) (point-max)
- (concat (car (car prefix))
- gnus-soup-prefix-file)
+ (concat (caar prefix) gnus-soup-prefix-file)
nil 'nomesg)
(setq prefix (cdr prefix))))))
(while opened
(unless (member (caar opened) done)
(gnus-server-insert-server-line
- (setq op-ser (format "%s:%s" (car (car (car opened)))
- (nth 1 (car (car opened)))))
- (car (car opened)))
+ (setq op-ser (format "%s:%s" (caaar opened) (nth 1 (caar opened))))
+ (caar opened))
(push (list op-ser (caar opened)) gnus-inserted-opened-servers))
(setq opened (cdr opened))))
(goto-char (point-min))
(killed (car gnus-server-killed-servers)))
(if (not server)
(setq gnus-server-alist (nconc gnus-server-alist (list killed)))
- (if (string= server (car (car gnus-server-alist)))
+ (if (string= server (caar gnus-server-alist))
(setq gnus-server-alist (cons killed gnus-server-alist))
(while (and (cdr alist)
- (not (string= server (car (car (cdr alist))))))
+ (not (string= server (caadr alist))))
(setq alist (cdr alist)))
(if alist
(setcdr alist (cons killed (cdr alist)))
(setq mode-line-buffer-identification
(list
(format
- "Gnus: %%b {%s:%s}" (car method) (car (cdr method)))))
+ "Gnus: %%b {%s:%s}" (car method) (cadr method))))
(save-excursion
(set-buffer nntp-server-buffer)
(let ((cur (current-buffer)))
(while (and (zerop (forward-line 1))
(> (or (gnus-group-topic-level) (1+ level)) level)))
(delete-region beg (point))
- (setcar (cdr (car (cdr (gnus-topic-find-topology topic))))
+ (setcar (cdadr (gnus-topic-find-topology topic))
(if insert 'visible 'invisible))
(when hide
- (setcdr (cdr (car (cdr (gnus-topic-find-topology topic))))
+ (setcdr (cdadr (gnus-topic-find-topology topic))
(list hide)))
(unless total-remove
(gnus-topic-insert-topic topic in-level)))))
(defun gnus-topic-previous-topic (topic)
"Return the previous topic on the same level as TOPIC."
- (let ((top (cdr (cdr (gnus-topic-find-topology
- (gnus-topic-parent-topic topic))))))
- (unless (equal topic (car (car (car top))))
- (while (and top (not (equal (car (car (car (cdr top)))) topic)))
+ (let ((top (cddr (gnus-topic-find-topology
+ (gnus-topic-parent-topic topic)))))
+ (unless (equal topic (caaar top))
+ (while (and top (not (equal (caaadr top) topic)))
(setq top (cdr top)))
- (car (car (car top))))))
+ (caaar top))))
(defun gnus-topic-parent-topic (topic &optional topology)
"Return the parent of TOPIC."
(let ((parent (car (pop topology)))
result found)
(while (and topology
- (not (setq found (equal (car (car (car topology))) topic)))
+ (not (setq found (equal (caaar topology) topic)))
(not (setq result (gnus-topic-parent-topic topic
(car topology)))))
(setq topology (cdr topology)))
(setq level 0))
(let ((top topology)
result)
- (if (equal (car (car topology)) topic)
+ (if (equal (caar topology) topic)
(progn
(when remove
(delq topology remove))
(alist gnus-topic-alist)
changed)
(while alist
- (unless (member (car (car alist)) topics)
+ (unless (member (caar alist) topics)
(nconc gnus-topic-topology
- (list (list (list (car (car alist)) 'visible))))
+ (list (list (list (caar alist) 'visible))))
(setq changed t))
(setq alist (cdr alist)))
(when changed
(unless topology
(setq topology gnus-topic-topology
gnus-tmp-topics nil))
- (push (car (car topology)) gnus-tmp-topics)
+ (push (caar topology) gnus-tmp-topics)
(mapcar 'gnus-topic-list (cdr topology))
gnus-tmp-topics)
(let ((alist gnus-topic-alist)
out)
(while alist
- (when (member group (cdr (car alist)))
- (setq out (car (car alist))
+ (when (member group (cdar alist))
+ (setq out (caar alist)
alist nil))
(setq alist (cdr alist)))
out))
(when (gnus-topic-find-topology topic)
(error "Topic aleady exists"))
(unless parent
- (setq parent (car (car gnus-topic-topology))))
+ (setq parent (caar gnus-topic-topology)))
(let ((top (cdr (gnus-topic-find-topology parent))))
(unless top
(error "No such parent topic: %s" parent))
(if previous
(progn
(while (and (cdr top)
- (not (equal (car (car (car (cdr top)))) previous)))
+ (not (equal (caaadr top) previous)))
(setq top (cdr top)))
(setcdr top (cons (list (list topic 'visible)) (cdr top))))
(nconc top (list (list (list topic 'visible)))))
(if (not (cdr alist))
(setcdr alist (nconc yanked (cdr alist)))
(while (cdr alist)
- (when (equal (car (cdr alist)) prev)
+ (when (equal (cadr alist) prev)
(setcdr alist (nconc yanked (cdr alist)))
(setq alist nil))
(setq alist (cdr alist))))))
(let ((top (gnus-topic-find-topology old-name))
(entry (assoc old-name gnus-topic-alist)))
(when top
- (setcar (car (cdr top)) new-name))
+ (setcar (cadr top) new-name))
(when entry
(setcar entry new-name))
(gnus-group-list-groups)))
(let ((fs gnus-uu-digest-from-subject))
(if (not fs)
()
- (setq from (car (car fs))
- subject (gnus-simplify-subject-fuzzy (cdr (car fs)))
+ (setq from (caar fs)
+ subject (gnus-simplify-subject-fuzzy (cdar fs))
fs (cdr fs))
(while (and fs (or from subject))
(and from
- (or (string= from (car (car fs)))
+ (or (string= from (caar fs))
(setq from nil)))
(and subject
- (or (string= (gnus-simplify-subject-fuzzy (cdr (car fs)))
+ (or (string= (gnus-simplify-subject-fuzzy (cdar fs))
subject)
(setq subject nil)))
(setq fs (cdr fs))))
(buffer-disable-undo (current-buffer))
(while string-list
(erase-buffer)
- (insert (car (car string-list)))
+ (insert (caar string-list))
;; Translate multiple spaces to one space.
(goto-char (point-min))
(while (re-search-forward "[ \t]+" nil t)
; (sleep-for 2)
(setq state (list 'wrong-type)))))
- (if (memq 'end state)
- (accept-process-output gnus-uu-uudecode-process)))
+ (when (memq 'end state)
+ (while (memq (process-status gnus-uu-uudecode-process)
+ '(open run))
+ (accept-process-output gnus-uu-uudecode-process 1))))
(setq state (list 'wrong-type))))
(if (not gnus-uu-uudecode-process)
(setq state (list 'wrong-type)))))
(setq rule (car action-list))
(setq action-list (cdr action-list))
(if (string-match (car rule) file-name)
- (setq action (car (cdr rule))))))
+ (setq action (cadr rule)))))
action))
(defun gnus-uu-treat-archive (file-path)
(cons
(apply
'nconc
- (list (car (car ts)))
+ (list (caar ts))
(let ((ps perms)
outp)
(while ps
(setq outp
(cons
(vector
- (car (car ps))
+ (caar ps)
(list
'gnus-summary-score-entry
(nth 1 header)
(interactive "p")
(let ((function (if (< n 0) 'prev-single-property-change
'next-single-property-change))
+ (inhibit-point-motion-hooks t)
(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))
+ ;; Skip past intangible buttons.
+ (when (get-text-property (point) 'intangible)
+ (incf n))
(decf n))
(unless (zerop n)
(gnus-message 5 "No more buttons"))
(defvar gnus-signature-separator "^-- *$"
"Regexp matching signature separator.")
+(defvar gnus-signature-limit nil
+ "Provide a limit to what is considered a signature.
+If it is a number, no signature may not be longer (in characters) than
+that number. If it is a function, the function will be called without
+any parameters, and if it returns nil, there is no signature in the
+buffer. If it is a string, it will be used as a regexp. If it
+matches, the text in question is not a signature.")
+
(defvar gnus-auto-extend-newsgroup t
"*If non-nil, extend newsgroup forward and backward when requested.")
current article is unread.")
(defvar gnus-auto-center-summary t
- "*If non-nil, always center the current summary buffer.")
+ "*If non-nil, always center the current summary buffer.
+In particular, if `vertical' do only vertical recentering. If non-nil
+and non-`vertical', do both horizontal and vertical recentering.")
(defvar gnus-break-pages t
"*If non-nil, do page breaking on articles.
(mail 1.0 point)))
(summary-reply
(vertical 1.0
- (article 0.5)
+ (article-copy 0.5)
(mail 1.0 point)))
(pick
(vertical 1.0
(post 1.0 point)))
(reply
(vertical 1.0
- (article 0.5)
+ (article-copy 0.5)
(mail 1.0 point)))
(mail-forward
(vertical 1.0
("*Shell Command Output*" 1.0)))
(followup
(vertical 1.0
- (article 0.5)
+ (article-copy 0.5)
(post 1.0 point)))
(followup-yank
(vertical 1.0
(picons . "*Picons*")
(tree . gnus-tree-buffer)
(info . gnus-info-buffer)
+ (article-copy . gnus-article-copy)
(draft . gnus-draft-buffer))
"Mapping from short symbols to buffer names or buffer variables.")
"gnus-bug@ifi.uio.no (The Gnus Bugfixing Girls + Boys)"
"The mail address of the Gnus maintainers.")
-(defconst gnus-version "September Gnus v0.45"
+(defconst gnus-version "September Gnus v0.46"
"Version number for this version of Gnus.")
(defvar gnus-info-nodes
(gnus-newsgroup-adaptive . gnus-use-adaptive-scoring)
gnus-newsgroup-adaptive-score-file
(gnus-newsgroup-expunged-tally . 0)
- gnus-cache-removeable-articles gnus-newsgroup-cached
+ gnus-cache-removable-articles gnus-newsgroup-cached
gnus-newsgroup-data gnus-newsgroup-data-reverse
gnus-newsgroup-limit gnus-newsgroup-limits)
"Variables that are buffer-local to the summary buffers.")
(gnus-parse-format
gnus-group-mode-line-format
gnus-group-mode-line-format-alist))))
- (gnus-tmp-news-server (car (cdr gnus-select-method)))
+ (gnus-tmp-news-server (cadr gnus-select-method))
(gnus-tmp-news-method (car gnus-select-method))
(max-len 60)
gnus-tmp-header ;Dummy binding for user-defined formats
(gnus-group-goto-group group)
(gnus-group-kill-group)
;; ... changing its name ...
- (setcar (cdr (car gnus-list-of-killed-groups))
- new-name)
+ (setcar (cdar gnus-list-of-killed-groups) new-name)
;; ... and then yanking it. Magic!
(gnus-group-yank-group)
(gnus-set-active new-name (gnus-active group))
((setq entry (gnus-gethash group gnus-newsrc-hashtb))
(push (cons (car entry) (nth 2 entry))
gnus-list-of-killed-groups)
- (setcdr (cdr entry) (cdr (cdr (cdr entry)))))
+ (setcdr (cdr entry) (cdddr entry)))
((member group gnus-zombie-list)
(setq gnus-zombie-list (delete group gnus-zombie-list)))))
(gnus-make-hashtable-from-newsrc-alist)))
(let ((methods gnus-valid-select-methods)
func)
(while methods
- (if (fboundp (setq func (intern (concat (car (car methods))
+ (if (fboundp (setq func (intern (concat (caar methods)
"-request-close"))))
(funcall func))
(setq methods (cdr methods)))))
(while locals
(if (consp (car locals))
(progn
- (make-local-variable (car (car locals)))
- (set (car (car locals)) (eval (cdr (car locals)))))
+ (make-local-variable (caar locals))
+ (set (caar locals) (eval (cdar locals))))
(make-local-variable (car locals))
(set (car locals) nil))
(setq locals (cdr locals))))
(let ((locals gnus-summary-local-variables))
(while locals
(if (consp (car locals))
- (and (vectorp (car (car locals)))
- (set (car (car locals)) nil))
+ (and (vectorp (caar locals))
+ (set (caar locals) nil))
(and (vectorp (car locals))
(set (car locals) nil)))
(setq locals (cdr locals)))))
(setcdr data (cons (gnus-data-make number mark pos header level)
(cdr data)))
(setq gnus-newsgroup-data-reverse nil)
- (gnus-data-update-list (cdr (cdr data)) offset)))
+ (gnus-data-update-list (cddr data) offset)))
(defun gnus-data-enter-list (after-article list &optional offset)
(when list
(setq gnus-newsgroup-data (cdr gnus-newsgroup-data)
gnus-newsgroup-data-reverse nil)
(while (cdr data)
- (and (= (gnus-data-number (car (cdr data))) article)
+ (and (= (gnus-data-number (cadr data)) article)
(progn
- (setcdr data (cdr (cdr data)))
+ (setcdr data (cddr data))
(and offset (gnus-data-update-list (cdr data) offset))
(setq data nil
gnus-newsgroup-data-reverse nil)))
(result threads)
subject hthread whole-subject)
(while threads
- (setq whole-subject (mail-header-subject (car (car threads))))
+ (setq whole-subject (mail-header-subject (caar threads)))
(if (and gnus-summary-gather-exclude-subject
(string-match gnus-summary-gather-exclude-subject
whole-subject))
(progn
;; We enter a dummy root into the thread, if we
;; haven't done that already.
- (unless (stringp (car (car hthread)))
+ (unless (stringp (caar hthread))
(setcar hthread (list whole-subject (car hthread))))
;; We add this new gathered thread to this gathered
;; thread.
(setcdr (car hthread)
- (nconc (cdr (car hthread)) (list (car threads))))
+ (nconc (cdar hthread) (list (car threads))))
;; Remove it from the list of threads.
(setcdr prev (cdr threads))
(setq threads prev))
"Sort subtreads inside each gathered thread by article number."
(let ((result threads))
(while threads
- (when (stringp (car (car threads)))
+ (when (stringp (caar threads))
(setcdr (car threads)
- (sort (cdr (car threads)) 'gnus-thread-sort-by-number)))
+ (sort (cdar threads) 'gnus-thread-sort-by-number)))
(setq threads (cdr threads)))
result))
(when (not (car (symbol-value refs)))
(setq heads (cdr (symbol-value refs)))
(while heads
- (if (memq (mail-header-number (car (car heads)))
+ (if (memq (mail-header-number (caar heads))
gnus-newsgroup-dormant)
(setq heads (cdr heads))
(setq id (symbol-name refs))
(while thread
(unless (memq (setq thr (gnus-id-to-thread
(gnus-root-id
- (mail-header-id (car (car thread))))))
+ (mail-header-id (caar thread)))))
roots)
(push thr roots))
(setq thread (cdr thread)))
;; First go up in this thread until we find the root.
(setq last-id (gnus-root-id id))
(setq headers (list (car (gnus-id-to-thread last-id))
- (car (car (cdr (gnus-id-to-thread last-id))))))
+ (caadr (gnus-id-to-thread last-id))))
;; We have now found the real root of this thread. It might have
;; been gathered into some loose thread, so we have to search
;; through the threads to find the thread we wanted.
(progn
(setq sub (cdr sub))
(while sub
- (when (member (car (car sub)) headers)
+ (when (member (caar sub) headers)
(setq thread (car threads)
threads nil
sub nil))
(if (and (= gnus-tmp-level 0)
(not (setq gnus-tmp-dummy-line nil))
(or (not stack)
- (= (car (car stack)) 0))
+ (= (caar stack) 0))
(not gnus-tmp-false-parent)
(or gnus-tmp-new-adopts new-roots))
(if gnus-tmp-new-adopts
(setq gnus-tmp-level (if gnus-tmp-root-expunged 0 1)
thread (list (car gnus-tmp-new-adopts))
- gnus-tmp-header (car (car thread))
+ gnus-tmp-header (caar thread)
gnus-tmp-new-adopts (cdr gnus-tmp-new-adopts))
(if new-roots
(setq thread (list (car new-roots))
- gnus-tmp-header (car (car thread))
+ gnus-tmp-header (caar thread)
new-roots (cdr new-roots))))
(if threads
;; If there are some threads, we do them before the
;; threads on the stack.
(setq thread threads
- gnus-tmp-header (car (car thread)))
+ gnus-tmp-header (caar thread))
;; There were no current threads, so we pop something off
;; the stack.
(setq state (car stack)
gnus-tmp-level (car state)
thread (cdr state)
stack (cdr stack)
- gnus-tmp-header (car (car thread)))))
+ gnus-tmp-header (caar thread))))
(setq gnus-tmp-false-parent nil)
(setq gnus-tmp-root-expunged nil)
((eq gnus-summary-make-false-root 'adopt)
;; We let the first article adopt the rest.
(setq gnus-tmp-new-adopts (nconc gnus-tmp-new-adopts
- (cdr (cdr (car thread)))))
+ (cddar thread)))
(setq gnus-tmp-gathered
(nconc (mapcar
(lambda (h) (mail-header-number (car h)))
- (cdr (cdr (car thread))))
+ (cddar thread))
gnus-tmp-gathered))
- (setq thread (cons (list (car (car thread))
- (car (cdr (car thread))))
+ (setq thread (cons (list (caar thread)
+ (cadar thread))
(cdr thread)))
(setq gnus-tmp-level -1
gnus-tmp-false-parent t))
(setq gnus-tmp-gathered
(nconc (mapcar
(lambda (h) (mail-header-number (car h)))
- (cdr (cdr (car thread))))
+ (cddar thread))
gnus-tmp-gathered))
(setq gnus-tmp-level -1))
((eq gnus-summary-make-false-root 'dummy)
(setq gnus-tmp-gathered
(nconc (mapcar
(lambda (h) (mail-header-number (car h)))
- (cdr (car thread)))
+ (cdar thread))
gnus-tmp-gathered))
- (setq gnus-tmp-new-adopts (if (cdr (car thread))
+ (setq gnus-tmp-new-adopts (if (cdar thread)
(append gnus-tmp-new-adopts
- (cdr (car thread)))
+ (cdar thread))
gnus-tmp-new-adopts)
thread-end t
gnus-tmp-header nil)
(when (nth 1 thread)
(push (cons (max 0 gnus-tmp-level) (nthcdr 1 thread)) stack))
(incf gnus-tmp-level)
- (setq threads (if thread-end nil (cdr (car thread))))
+ (setq threads (if thread-end nil (cdar thread)))
(unless threads
(setq gnus-tmp-level 0)))))
(gnus-message 7 "Generating summary...done"))
marked m)
(or (not info)
(and (not (setq marked (nthcdr 3 info)))
- (setcdr (nthcdr 2 info)
- (list (list (cons type (gnus-compress-sequence
- articles t))))))
+ (or (null articles)
+ (setcdr (nthcdr 2 info)
+ (list (list (cons type (gnus-compress-sequence
+ articles t)))))))
(and (not (setq m (assq type (car marked))))
- (setcar marked
- (cons (cons type (gnus-compress-sequence articles t) )
- (car marked))))
+ (or (null articles)
+ (setcar marked
+ (cons (cons type (gnus-compress-sequence articles t) )
+ (car marked)))))
(if force
- (setcdr m (gnus-compress-sequence articles t))
+ (if (null articles)
+ (setcar (nthcdr 3 info)
+ (delq (assq type marked) marked))
+ (setcdr m (gnus-compress-sequence articles t)))
(setcdr m (gnus-compress-sequence
(sort (nconc (gnus-uncompress-range m)
(copy-sequence articles)) '<) t))))))
(while range
(if (numberp (car range))
(setq num (1+ num))
- (setq num (+ num (- (1+ (cdr (car range)))
- (car (car range))))))
+ (setq num (+ num (- (1+ (cdar range)) (caar range)))))
(setq range (cdr range)))
(setq num (- (cdr active) num))))
;; Update the number of unread articles.
"Center point in window and redisplay frame.
Also do horizontal recentering."
(interactive)
- (gnus-horizontal-recenter)
+ (when (and gnus-auto-center-summary
+ (not (eq gnus-auto-center-summary 'vertical)))
+ (gnus-horizontal-recenter))
(recenter n))
(defun gnus-summary-recenter ()
(setq first (1+ (cdr read)))
;; `read' is a list of ranges.
(if (/= (setq nlast (or (and (numberp (car read)) (car read))
- (car (car read)))) 1)
+ (caar read))) 1)
(setq first 1))
(while read
(if first
(while (< first nlast)
(setq unread (cons first unread))
(setq first (1+ first))))
- (setq first (1+ (if (atom (car read)) (car read) (cdr (car read)))))
- (setq nlast (if (atom (car (cdr read)))
- (car (cdr read))
- (car (car (cdr read)))))
+ (setq first (1+ (if (atom (car read)) (car read) (cdar read))))
+ (setq nlast (if (atom (cadr read)) (cadr read) (caadr read)))
(setq read (cdr read)))))
;; And add the last unread articles.
(while (<= first last)
(switch-to-buffer gnus-group-buffer)
(and group
(gnus-group-jump-to-group group))
- (eval (car (cdr (assq key keystrokes))))
+ (eval (cadr (assq key keystrokes)))
(setq group (gnus-group-group-name))
(switch-to-buffer obuf))
(setq ended nil))
(let ((scored gnus-newsgroup-scored)
headers h)
(while scored
- (or (gnus-summary-goto-subject (car (car scored)))
- (and (setq h (gnus-summary-article-header (car (car scored))))
- (< (cdr (car scored)) gnus-summary-expunge-below)
+ (or (gnus-summary-goto-subject (caar scored))
+ (and (setq h (gnus-summary-article-header (caar scored)))
+ (< (cdar scored) gnus-summary-expunge-below)
(setq headers (cons h headers))))
(setq scored (cdr scored)))
(or headers (error "No expunged articles hidden."))
(concat prompt " ") split-name nil nil)))
(concat gnus-article-save-directory
(if (string= result "")
- (car (car split-name))
+ (caar split-name)
result)))))))
;; If we have read a directory, we append the default file name.
(when (file-directory-p file)
(setq files (list (cdr (assq 'name (car ps)))))
(while (and ps (cdr ps)
(string= (or action "1")
- (or (cdr (assq 'action (car (cdr ps)))) "2")))
- (setq files (cons (cdr (assq 'name (car (cdr ps)))) files))
- (setcdr ps (cdr (cdr ps))))
+ (or (cdr (assq 'action (cadr ps))) "2")))
+ (setq files (cons (cdr (assq 'name (cadr ps))) files))
+ (setcdr ps (cddr ps)))
(if (not files)
()
(if (not (string-match "%s" action))
(nconc (list 'gnus-type 'signature)
gnus-hidden-properties))))))))
-(defvar gnus-signature-limit nil
- "Provide a limit to what is considered a signature.
-If it is a number, no signature may not be longer (in characters) than
-that number. If it is a function, the function will be called without
-any parameters, and if it returns nil, there is no signature in the
-buffer. If it is a string, it will be used as a regexp. If it
-matches, the text in question is not a signature.")
-
(defun gnus-narrow-to-signature ()
"Narrow to the signature."
(widen)
;; Apply kills to specified newsgroups in command line arguments.
(setq newsrc (cdr gnus-newsrc-alist))
(while newsrc
- (setq group (car (car newsrc)))
+ (setq group (caar newsrc))
(setq entry (gnus-gethash group gnus-newsrc-hashtb))
(if (and (<= (nth 1 (car newsrc)) gnus-level-subscribed)
(and (car entry)
(or (gnus-server-opened method)
(gnus-open-server method))))
-(defun gnus-check-server (&optional method)
+(defun gnus-check-server (&optional method silent)
"Check whether the connection to METHOD is down.
If METHOD is nil, use `gnus-select-method'.
If it is down, start it up (again)."
;; The stream is already opened.
t
;; Open the server.
- (gnus-message 5 "Opening %s server%s..." (car method)
- (if (equal (nth 1 method) "") ""
- (format " on %s" (nth 1 method))))
+ (unless silent
+ (gnus-message 5 "Opening %s server%s..." (car method)
+ (if (equal (nth 1 method) "") ""
+ (format " on %s" (nth 1 method)))))
(run-hooks 'gnus-open-server-hook)
(prog1
(gnus-open-server method)
- (message "")))))
+ (unless silent
+ (message ""))))))
(defun gnus-get-function (method function)
"Return a function symbol based on METHOD and FUNCTION."
(let ((info (or info (gnus-get-info group)))
method)
(if (or (not info)
- (not (setq method (gnus-info-method info))))
- (setq method gnus-select-method)
+ (not (setq method (gnus-info-method info)))
+ (equal method "native"))
+ gnus-select-method
(setq method
(cond ((stringp method)
(gnus-server-to-method method))
(gnus-server-extend-method group method))
(t
method)))
- (gnus-server-add-address method)))))
+ (if (equal (cadr method) "")
+ method
+ (gnus-server-add-address method))))))
(defun gnus-check-backend-function (func group)
"Check whether GROUP supports function FUNC."
(t
(let ((regs gnus-newsrc-options-n))
(while (and regs
- (not (string-match (car (car regs)) group)))
+ (not (string-match (caar regs) group)))
(setq regs (cdr regs)))
- (and regs (cdr (car regs)))))))
+ (and regs (cdar regs))))))
(defun gnus-ask-server-for-new-groups ()
(let* ((date (or gnus-newsrc-last-checked-date (current-time-string)))
(setq entry (gnus-gethash entry gnus-newsrc-hashtb)))
(if (and (not oldlevel)
(consp entry))
- (setq oldlevel (car (cdr (nth 2 entry)))))
+ (setq oldlevel (cadr (nth 2 entry))))
(if (stringp previous)
(setq previous (gnus-gethash previous gnus-newsrc-hashtb)))
(setcdr (gnus-gethash (car (nth 3 entry))
gnus-newsrc-hashtb)
(cdr entry)))
- (setcdr (cdr entry) (cdr (cdr (cdr entry))))))))
+ (setcdr (cdr entry) (cdddr entry))))))
;; Finally we enter (if needed) the list where it is supposed to
;; go, and change the subscription level. If it is to be killed,
;; It was alive, and it is going to stay alive, so we
;; just change the level and don't change any pointers or
;; hash table entries.
- (setcar (cdr (car (cdr (cdr entry)))) level)
+ (setcar (cdaddr entry) level)
(if (listp entry)
(setq info (cdr entry)
num (car entry))
(unless previous
(setq previous
(let ((p gnus-newsrc-alist))
- (while (cdr (cdr p))
+ (while (cddr p)
(setq p (cdr p)))
p)))
- (setq entry (cons info (cdr (cdr previous))))
+ (setq entry (cons info (cddr previous)))
(if (cdr previous)
(progn
(setcdr (cdr previous) entry)
(gnus-sethash group (cons num previous)
gnus-newsrc-hashtb))
(when (cdr entry)
- (setcdr (gnus-gethash (car (car (cdr entry))) gnus-newsrc-hashtb)
- entry)))))
+ (setcdr (gnus-gethash (caadr entry) gnus-newsrc-hashtb) entry)))))
(when gnus-group-change-level-function
(funcall gnus-group-change-level-function group level oldlevel)))))
gnus-activate-foreign-newsgroups)
(t 0))
level))
- info group active virtuals method)
+ info group active method)
(gnus-message 5 "Checking new news...")
(while newsrc
- (setq info (car newsrc)
- group (gnus-info-group info)
- active (gnus-active group))
+ (setq active (gnus-active (setq group (gnus-info-group
+ (setq info (pop newsrc))))))
;; Check newsgroups. If the user doesn't want to check them, or
;; they can't be checked (for instance, if the news server can't
;; The group couldn't be reached, so we nix out the number of
;; unread articles and stuff.
(gnus-set-active group nil)
- (setcar (gnus-gethash group gnus-newsrc-hashtb) t))
-
- (setq newsrc (cdr newsrc)))
+ (setcar (gnus-gethash group gnus-newsrc-hashtb) t)))
(gnus-message 5 "Checking new news...done")))
(setq gnus-newsrc-hashtb (gnus-make-hashtable (length alist)))
(setq alist
(setq prev (setq gnus-newsrc-alist
- (if (equal (car (car gnus-newsrc-alist))
+ (if (equal (caar gnus-newsrc-alist)
"dummy.group")
gnus-newsrc-alist
(cons (list "dummy.group" 0 nil) alist)))))
(while alist
(gnus-sethash
- (car (car alist))
- (cons (and ohashtb (car (gnus-gethash (car (car alist)) ohashtb)))
+ (caar alist)
+ (cons (and ohashtb (car (gnus-gethash (caar alist) ohashtb)))
prev)
gnus-newsrc-hashtb)
(setq prev alist
;; active limit.
(while (and (cdr range)
(>= (car active)
- (or (and (atom (car (cdr range))) (car (cdr range)))
- (car (car (cdr range))))))
+ (or (and (atom (cadr range)) (cadr range))
+ (caadr range))))
(if (numberp (car range))
(setcar range
(cons (car range)
- (or (and (numberp (car (cdr range)))
- (car (cdr range)))
- (cdr (car (cdr range))))))
+ (or (and (numberp (cadr range))
+ (cadr range))
+ (cdadr range))))
(setcdr (car range)
(or (and (numberp (nth 1 range)) (nth 1 range))
- (cdr (car (cdr range))))))
- (setcdr range (cdr (cdr range))))
+ (cdadr range))))
+ (setcdr range (cddr range)))
;; Adjust the first element to be the same as the lower limit.
(if (and (not (atom (car range)))
- (< (cdr (car range)) (car active)))
+ (< (cdar range) (car active)))
(setcdr (car range) (1- (car active))))
;; Then we want to peel off any elements that are higher
;; than the upper active limit.
(let ((srange range))
;; Go past all legal elements.
(while (and (cdr srange)
- (<= (or (and (atom (car (cdr srange)))
- (car (cdr srange)))
- (car (car (cdr srange)))) (cdr active)))
+ (<= (or (and (atom (cadr srange))
+ (cadr srange))
+ (caadr srange)) (cdr active)))
(setq srange (cdr srange)))
(if (cdr srange)
;; Nuke all remaining illegal elements.
;; Adjust the final element.
(if (and (not (atom (car srange)))
- (> (cdr (car srange)) (cdr active)))
+ (> (cdar srange) (cdr active)))
(setcdr (car srange) (cdr active))))
;; Compute the number of unread articles.
(while range
(setq num (+ num (- (1+ (or (and (atom (car range)) (car range))
- (cdr (car range))))
+ (cdar range)))
(or (and (atom (car range)) (car range))
- (car (car range))))))
+ (caar range)))))
(setq range (cdr range)))
(setq num (max 0 (- (cdr active) num)))))
;; Set the number of unread articles.
(concat " from " where) "")
(car method))))
(gnus-message 5 mesg)
- (if (not (gnus-check-server method))
- ()
+ (when (gnus-check-server method)
;; Request that the backend scan its incoming messages.
(and (gnus-check-backend-function 'request-scan (car method))
(gnus-request-scan nil method))
(gnus-check-backend-function 'retrieve-groups (car method)))
(let ((newsrc (cdr gnus-newsrc-alist))
(gmethod (gnus-server-get-method nil method))
- groups)
- (while newsrc
- (and (gnus-server-equal
- (gnus-find-method-for-group
- (car (car newsrc)) (car newsrc))
- gmethod)
- (setq groups (cons (gnus-group-real-name
- (car (car newsrc))) groups)))
- (setq newsrc (cdr newsrc)))
- (gnus-check-server method)
- (setq list-type (gnus-retrieve-groups groups method))
- (cond
- ((not list-type)
- (gnus-message
- 1 "Cannot read partial active file from %s server."
- (car method))
- (ding)
- (sit-for 2))
- ((eq list-type 'active)
- (gnus-active-to-gnus-format method gnus-active-hashtb))
- (t
- (gnus-groups-to-gnus-format method gnus-active-hashtb)))))
+ groups info)
+ (while (setq info (pop newsrc))
+ (when (gnus-server-equal
+ (gnus-find-method-for-group
+ (gnus-info-group info) info)
+ gmethod)
+ (push (gnus-group-real-name (gnus-info-group info))
+ groups)))
+ (when groups
+ (gnus-check-server method)
+ (setq list-type (gnus-retrieve-groups groups method))
+ (cond
+ ((not list-type)
+ (gnus-message
+ 1 "Cannot read partial active file from %s server."
+ (car method))
+ (ding)
+ (sit-for 2))
+ ((eq list-type 'active)
+ (gnus-active-to-gnus-format method gnus-active-hashtb))
+ (t
+ (gnus-groups-to-gnus-format method gnus-active-hashtb))))))
(t
(if (not (gnus-request-list method))
(progn
(let ((info (gnus-get-info (car group))))
(if info
(progn
- (gnus-info-set-read info (cdr (cdr group)))
+ (gnus-info-set-read info (cddr group))
(gnus-info-set-level
info (if (nth 1 group) gnus-level-default-subscribed
gnus-level-default-unsubscribed))
(list (car group)
(if (nth 1 group) gnus-level-default-subscribed
gnus-level-default-unsubscribed)
- (cdr (cdr group))))
+ (cddr group)))
gnus-newsrc-alist)))
(if (setq m (assoc (car group) marked))
(gnus-info-set-marks
(setq newsrc (cdr newsrc)))
(setq newsrc killed)
(while newsrc
- (setcar newsrc (car (car newsrc)))
+ (setcar newsrc (caar newsrc))
(setq newsrc (cdr newsrc)))
(setq gnus-killed-list killed))
;; The .el file version of this variable does not begin with
entry mentry)
(while rc
(or (null (nth 4 (car rc))) ; It's a native group.
- (assoc (car (car rc)) newsrc) ; It's already in the alist.
- (if (setq entry (assoc (car (car prev)) newsrc))
+ (assoc (caar rc) newsrc) ; It's already in the alist.
+ (if (setq entry (assoc (caar prev) newsrc))
(setcdr (setq mentry (memq entry newsrc))
(cons (car rc) (cdr mentry)))
(setq newsrc (cons (car rc) newsrc))))
(list (nth 5 (file-attributes file)) file))
slave-files)
(lambda (f1 f2)
- (or (< (car (car f1)) (car (car f2)))
+ (or (< (caar f1) (caar f2))
(< (nth 1 (car f1)) (nth 1 (car f2)))))))
(while slave-files
(erase-buffer)
(save-excursion
(set-buffer nnbabyl-mbox-buffer)
(narrow-to-region
- (car (car nnbabyl-previous-buffer-mode))
- (cdr (car nnbabyl-previous-buffer-mode)))
+ (caar nnbabyl-previous-buffer-mode)
+ (cdar nnbabyl-previous-buffer-mode))
(funcall (cdr nnbabyl-previous-buffer-mode))))
(setq nnbabyl-current-server nil
nnbabyl-mbox-buffer nil)
(forward-char -1)
(while group-art
(insert (format "X-Gnus-Newsgroup: %s:%d %s\n"
- (car (car group-art)) (cdr (car group-art))
+ (caar group-art) (cdar group-art)
(current-time-string)))
(setq group-art (cdr group-art)))))
t))
(defun nnbabyl-active-number (group)
;; Find the next article number in GROUP.
- (let ((active (car (cdr (assoc group nnbabyl-group-alist)))))
+ (let ((active (cadr (assoc group nnbabyl-group-alist))))
(if active
(setcdr active (1+ (cdr active)))
;; This group is new, so we create a new entry for it.
(nnheader-change-server 'nndir server defs)
(unless (assq 'nndir-directory defs)
(setq nndir-directory server))
- (cond
- ((not (file-exists-p nndir-directory))
- (nndir-close-server)
- (nnheader-report 'nndir "No such file or directory: %s" nndir-directory))
- ((not (file-directory-p (file-truename nndir-directory)))
- (nndir-close-server)
- (nnheader-report 'nndir "Not a directory: %s" nndir-directory))
- (t
- (nnheader-report 'nndir "Opened server %s using directory %s"
- server nndir-directory)
- t)))
+ (let (err)
+ (cond
+ ((not (condition-case arg
+ (file-exists-p nndir-directory)
+ (ftp-error (setq err (format "%s" arg)))))
+ (nndir-close-server)
+ (nnheader-report
+ 'nndir (or err "No such file or directory: %s" nndir-directory)))
+ ((not (file-directory-p (file-truename nndir-directory)))
+ (nndir-close-server)
+ (nnheader-report 'nndir "Not a directory: %s" nndir-directory))
+ (t
+ (nnheader-report 'nndir "Opened server %s using directory %s"
+ server nndir-directory)
+ t))))
(defun nndir-close-server (&optional server)
(setq nndir-current-server nil)
(setq nndoc-article-type (funcall (cdr guess))))
;; Set the nndoc variables.
(while defs
- (set (intern (format "nndoc-%s" (car (car defs))))
+ (set (intern (format "nndoc-%s" (caar defs)))
(cdr (pop defs))))))
(defun nndoc-search (regexp)
nndraft-buffer-name)))
(defun nndraft-request-update-info (group info &optional server)
- (setcar (cdr (cdr info)) nil)
+ (setcar (cddr info) nil)
(when (nth 3 info)
(setcar (nthcdr 3 info) nil)))
(error nil)))
(or nneething-active (setq nneething-active (cons 1 0)))
;; Old nneething had a different map format.
- (when (and (cdr (car nneething-map))
+ (when (and (cdar nneething-map)
(atom (cdar nneething-map)))
(setq nneething-map
(mapcar (lambda (n)
(defun nnfolder-request-close ()
(let ((alist nnfolder-buffer-alist))
(while alist
- (nnfolder-close-group (car (car alist)) nil t)
+ (nnfolder-close-group (caar alist) nil t)
(setq alist (cdr alist))))
(setq nnfolder-buffer-alist nil
nnfolder-current-server nil
t)
(let* ((active (assoc group nnfolder-group-alist))
(group (car active))
- (range (car (cdr active)))
+ (range (cadr active))
(minactive (car range))
(maxactive (cdr range)))
(cond
(setq articles (cdr articles)))
(and (buffer-modified-p) (save-buffer))
;; Find the lowest active article in this group.
- (let* ((active (car (cdr (assoc newsgroup nnfolder-group-alist))))
+ (let* ((active (cadr (assoc newsgroup nnfolder-group-alist)))
(marker (concat "\n" nnfolder-article-marker))
(number "[0-9]+")
(activemin (cdr active)))
(save-excursion
;; Find the next article number in GROUP.
(prog1
- (let ((active (car (cdr (assoc group nnfolder-group-alist)))))
+ (let ((active (cadr (assoc group nnfolder-group-alist))))
(if active
(setcdr active (1+ (cdr active)))
;; This group is new, so we create a new entry for it.
(let ((delim (concat "^" rmail-unix-mail-delimiter))
(marker (concat "\n" nnfolder-article-marker))
(number "[0-9]+")
- (active (car (cdr (assoc nnfolder-current-group
- nnfolder-group-alist))))
+ (active (cadr (assoc nnfolder-current-group
+ nnfolder-group-alist)))
activenumber activemin start end)
(goto-char (point-min))
;;
;; use the definitions from the `defs' list where that is
;; possible.
(while s
- (set (car (car s))
- (if (setq val (assq (car (car s)) defs))
+ (set (caar s)
+ (if (setq val (assq (caar s) defs))
(nth 1 val)
(nth 1 (car s))))
(setq s (cdr s)))
;; The we go through the defs list and set any variables that were
;; not set in the first sweep.
(while defs
- (if (not (assq (car (car defs)) server))
- (set (car (car defs))
+ (if (not (assq (caar defs) server))
+ (set (caar defs)
(if (and (symbolp (nth 1 (car defs)))
(not (boundp (nth 1 (car defs)))))
(nth 1 (car defs))
(defun nnheader-save-variables (server)
(let (out)
(while server
- (setq out (cons (list (car (car server))
- (symbol-value (car (car server))))
- out))
+ (push (list (caar server) (symbol-value (caar server))) out)
(setq server (cdr server)))
(nreverse out)))
(defun nnheader-restore-variables (state)
(while state
- (set (car (car state)) (nth 1 (car state)))
+ (set (caar state) (nth 1 (car state)))
(setq state (cdr state))))
(defun nnheader-change-server (backend server defs)
;; We have copied all the newsrc alist info over to local copies
;; so that we can mess all we want with these lists.
(while newsrc
- (if (string-match "nnkiboze" (car (car newsrc)))
+ (if (string-match "nnkiboze" (caar newsrc))
;; For each kiboze group, we call this function to generate
;; it.
- (nnkiboze-generate-group (car (car newsrc))))
+ (nnkiboze-generate-group (caar newsrc)))
(setq newsrc (cdr newsrc)))))
(defun nnkiboze-score-file (group)
(setq newsrc nnkiboze-newsrc)
(while newsrc
(if (not (setq active (gnus-gethash
- (car (car newsrc)) gnus-active-hashtb)))
+ (caar newsrc) gnus-active-hashtb)))
;; This group isn't active after all, so we remove it from
;; the list of component groups.
(setq nnkiboze-newsrc (delq (car newsrc) nnkiboze-newsrc))
- (setq lowest (cdr (car newsrc)))
+ (setq lowest (cdar newsrc))
;; Ok, we have a valid component group, so we jump to it.
(switch-to-buffer gnus-group-buffer)
- (gnus-group-jump-to-group (car (car newsrc)))
+ (gnus-group-jump-to-group (caar newsrc))
;; We set all list of article marks to nil. Since we operate
;; on copies of the real lists, we can destroy anything we
;; want here.
(and (eq method gnus-select-method) (setq method nil))
;; We go through the list of scored articles.
(while gnus-newsgroup-scored
- (if (> (car (car gnus-newsgroup-scored)) lowest)
+ (if (> (caar gnus-newsgroup-scored) lowest)
;; If it has a good score, then we enter this article
;; into the kiboze group.
(nnkiboze-enter-nov
nov-buffer
(gnus-summary-article-header
- (car (car gnus-newsgroup-scored)))
+ (caar gnus-newsgroup-scored))
(if method
(gnus-group-prefixed-name gnus-newsgroup-name method)
gnus-newsgroup-name)))
(erase-buffer)
(while group-assoc
(setq group (pop group-assoc))
- (insert (format "%s %d %d y\n" (car group) (cdr (car (cdr group)) )
- (car (car (cdr group))))))
+ (insert (format "%s %d %d y\n" (car group) (cdadr group)
+ (caadr group))))
(unless (file-exists-p (file-name-directory file-name))
(make-directory (file-name-directory file-name) t))
(write-region 1 (point-max) (expand-file-name file-name) nil 'nomesg)
found)
(while (not found)
(if (re-search-forward delim nil t)
- (when (looking-at "[^ :]+:")
+ (when (looking-at "[^\000-\037\177-\377\ :]+:")
(forward-line -1)
(setq found 'yes))
(setq found 'no)))
;; If there is only just one group to put everything in, we
;; just return a list with just this one method in.
(setq group-art
- (list (cons (car (car methods))
- (funcall func (car (car methods))))))
+ (list (cons (caar methods) (funcall func (caar methods)))))
;; We do actual comparison.
(save-excursion
;; Find headers.
(when (and
(condition-case ()
(if (stringp (nth 1 method))
- (re-search-backward (car (cdr method)) nil t)
+ (re-search-backward (cadr method) nil t)
;; Function to say whether this is a match.
(funcall (nth 1 method) (car method)))
(error nil))
(progn (forward-line 1) (point))))
(insert (format "Xref: %s" (system-name)))
(while group-alist
- (insert (format " %s:%d" (car (car group-alist))
- (cdr (car group-alist))))
+ (insert (format " %s:%d" (caar group-alist) (cdar group-alist)))
(setq group-alist (cdr group-alist)))
(insert "\n"))))
(forward-char -1)
(while group-art
(insert (format "X-Gnus-Newsgroup: %s:%d %s\n"
- (car (car group-art)) (cdr (car group-art))
+ (caar group-art) (cdar group-art)
(current-time-string)))
(setq group-art (cdr group-art)))))
t))
(defun nnmbox-active-number (group)
;; Find the next article number in GROUP.
- (let ((active (car (cdr (assoc group nnmbox-group-alist)))))
+ (let ((active (cadr (assoc group nnmbox-group-alist))))
(if active
(setcdr active (1+ (cdr active)))
;; This group is new, so we create a new entry for it.
(let ((ga group-art)
first)
(while ga
- (nnmh-possibly-create-directory (car (car ga)))
+ (nnmh-possibly-create-directory (caar ga))
(let ((file (concat (nnmail-group-pathname
- (car (car ga)) nnmh-directory)
- (int-to-string (cdr (car ga))))))
+ (caar ga) nnmh-directory)
+ (int-to-string (cdar ga)))))
(if first
;; It was already saved, so we just make a hard link.
(funcall nnmail-crosspost-link-function first file t)
(defun nnmh-active-number (group)
"Compute the next article number in GROUP."
- (let ((active (car (cdr (assoc group nnmh-group-alist)))))
+ (let ((active (cadr (assoc group nnmh-group-alist))))
;; The group wasn't known to nnmh, so we just create an active
;; entry for it.
(or active
;; Remove all deleted articles.
(let ((art articles))
(while art
- (if (not (memq (car (car art)) files))
+ (if (not (memq (caar art) files))
(setq articles (delq (car art) articles)))
(setq art (cdr art))))
;; Check whether the highest-numbered articles really are the ones
(while (and art
(not (equal
(nth 5 (file-attributes
- (concat dir (int-to-string (car (car art))))))
- (cdr (car art)))))
+ (concat dir (int-to-string (caar art)))))
+ (cdar art))))
(setq articles (delq (car art) articles))
- (setq new (cons (car (car art)) new))
+ (setq new (cons (caar art) new))
(setq art (cdr art))))
;; Go through all the new articles and add them, and their
;; time-stamps to the list.
;; It wasn't there, so we look through the other groups as well.
(while (and (not number)
alist)
- (or (string= (car (car alist)) nnml-current-group)
- (setq number (nnml-find-id (car (car alist)) id)))
+ (or (string= (caar alist) nnml-current-group)
+ (setq number (nnml-find-id (caar alist) id)))
(or number
(setq alist (cdr alist))))
(and number
- (cons (car (car alist)) number))))))
+ (cons (caar alist) number))))))
(defun nnml-find-id (group id)
(erase-buffer)
(let ((ga group-art)
first)
(while ga
- (nnml-possibly-create-directory (car (car ga)))
+ (nnml-possibly-create-directory (caar ga))
(let ((file (concat (nnmail-group-pathname
- (car (car ga)) nnml-directory)
- (int-to-string (cdr (car ga))))))
+ (caar ga) nnml-directory)
+ (int-to-string (cdar ga)))))
(if first
;; It was already saved, so we just make a hard link.
(funcall nnmail-crosspost-link-function first file t)
;; Output the nov line to all nov databases that should have it.
(let ((ga group-art))
(while ga
- (nnml-add-nov (car (car ga)) (cdr (car ga)) nov-line)
+ (nnml-add-nov (caar ga) (cdar ga) nov-line)
(setq ga (cdr ga))))
group-art))
(defun nnml-active-number (group)
"Compute the next article number in GROUP."
- (let ((active (car (cdr (assoc group nnml-group-alist)))))
+ (let ((active (cadr (assoc group nnml-group-alist))))
;; The group wasn't known to nnml, so we just create an active
;; entry for it.
(or active
(defun nnml-save-nov ()
(save-excursion
(while nnml-nov-buffer-alist
- (when (buffer-name (cdr (car nnml-nov-buffer-alist)))
- (set-buffer (cdr (car nnml-nov-buffer-alist)))
+ (when (buffer-name (cdar nnml-nov-buffer-alist))
+ (set-buffer (cdar nnml-nov-buffer-alist))
(and (buffer-modified-p)
(write-region
1 (point-max) (buffer-file-name) nil 'nomesg))
;; articles in SEQUENCE come from.
(while (and areas sequence)
;; Peel off areas that are below sequence.
- (while (and areas (< (cdr (car (car areas))) (car sequence)))
+ (while (and areas (< (cdaar areas) (car sequence)))
(setq areas (cdr areas)))
(when areas
;; This is a useful area.
(setq use-nov nil))
;; We assign the portion of `sequence' that is relevant to
;; this MSG packet to this packet.
- (while (and sequence (<= (car sequence) (cdr (car (car areas)))))
+ (while (and sequence (<= (car sequence) (cdaar areas)))
(push (car sequence) this-area-seq)
(setq sequence (cdr sequence)))
(setcar useful-areas (cons (nreverse this-area-seq)
'nov)
;; We insert HEADs.
(while useful-areas
- (setq articles (car (car useful-areas))
+ (setq articles (caar useful-areas)
useful-areas (cdr useful-areas))
(while articles
(when (setq msg-buf
(nnsoup-narrow-to-article
- (car articles) (cdr (car useful-areas)) 'head))
+ (car articles) (cdar useful-areas) 'head))
(goto-char (point-max))
(insert (format "221 %d Article retrieved.\n" (car articles)))
(insert-buffer-substring msg-buf)
(when (not mod-time)
(setcdr (cdr total-infolist) (delq info (cddr total-infolist)))))
(if (cddr total-infolist)
- (setcar active (car (car (car (cdr (cdr total-infolist))))))
+ (setcar active (caaadr (cdr total-infolist)))
(setcar active (1+ (cdr active))))
(nnsoup-write-active-file)
;; Return the articles that weren't expired.
(set-buffer (nnsoup-index-buffer prefix))
(widen)
(goto-char (point-min))
- (forward-line (- article (car (car area))))
+ (forward-line (- article (caar area)))
(setq beg (read (current-buffer)))
(forward-line 1)
(if (looking-at "[0-9]+")
(let ((header (nnsoup-header
(gnus-soup-encoding-format
(gnus-soup-area-encoding (nth 1 area))))))
- (re-search-forward header nil t (- article (car (car area))))
+ (re-search-forward header nil t (- article (caar area)))
(narrow-to-region
(match-beginning 0)
(if (re-search-forward header nil t)
(defun nnsoup-article-to-area (article group)
"Return the area that ARTICLE in GROUP is located in."
(let ((areas (cddr (assoc group nnsoup-group-alist))))
- (while (and areas (< (cdr (car (car areas))) article))
+ (while (and areas (< (cdaar areas) article))
(setq areas (cdr areas)))
(and areas (car areas))))
active)
(nconc elem
(list
- (list (cons (setq min (1+ (cdr (car (car
- (cdr elem))))))
+ (list (cons (setq min (1+ (cdaadr elem)))
(+ min lines))
(vector ident group "ncm" "" lines))))
(setcdr (cadr elem) (+ min lines)))
(message "")
(setq nnsoup-group-alist active)
(while active
- (setcdr (car active) (nreverse (cdr (car active))))
+ (setcdr (car active) (nreverse (cdar active)))
(setq active (cdr active)))
(nnsoup-write-active-file)))
(nth 2 tdate) (nth 1 tdate) (nth 0 tdate)
(nth 4 tdate))))
(+ (* (car unix) 65536.0)
- (car (cdr unix)))))
+ (cadr unix))))
(provide 'nnspool)
(not (equal proc (nth 1 (assq 'nntp-server-process
(car servers))))))
(setq servers (cdr servers)))
- (setq server (car (car servers))))
+ (setq server (caar servers)))
(when (and server
nntp-warn-about-losing-connection)
(message "nntp: Connection closed to server %s" server)
nart)
(while (and (>= (setq max (1- max)) 0)
articles)
- (or (memq (setq nart (car (car articles))) nntp-async-fetched)
+ (or (memq (setq nart (caar articles)) nntp-async-fetched)
(progn
(nntp-async-send-strings "ARTICLE " (int-to-string nart))
(setq nntp-async-fetched (cons nart nntp-async-fetched))))
beg cgroup active article result prefix)
(while articles
(setq article (assq (pop articles) nnvirtual-mapping))
- (when (setq cgroup (cadr article))
- (gnus-request-group cgroup t)
+ (when (and (setq cgroup (cadr article))
+ (gnus-check-server
+ (gnus-find-method-for-group cgroup) t)
+ (gnus-request-group cgroup t))
(setq prefix (gnus-group-real-prefix cgroup))
(when (setq result (gnus-retrieve-headers
- (list (caddr article)) cgroup))
+ (list (caddr article)) cgroup fetch-old))
(set-buffer nntp-server-buffer)
(if (zerop (buffer-size))
(nconc (assq cgroup unfetched) (list (caddr article)))
(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)))
(if (not (string= "" prefix))
(while (re-search-forward
"[^ ]+:[0-9]+"
nnvirtual-current-group '(nnvirtual ""))))
(setq nnvirtual-component-groups nil)
(while newsrc
- (and (string-match regexp (car (car newsrc)))
- (not (string= (car (car newsrc)) virt-group))
+ (and (string-match regexp (caar newsrc))
+ (not (string= (caar newsrc) virt-group))
(setq nnvirtual-component-groups
- (cons (car (car newsrc)) nnvirtual-component-groups)))
+ (cons (caar newsrc) nnvirtual-component-groups)))
(setq newsrc (cdr newsrc))))
(if nnvirtual-component-groups
(progn
+Wed Feb 28 04:54:41 1996 Lars Ingebrigtsen <lars@eyesore.no>
+
+ * gnus.texi (Slow Terminal Connection): Addition.
+
Sat Feb 24 01:11:40 1996 Mark Borges <mdb@cdc.noaa.gov>
* gnus.texi: Typo fixes.
then, if it sits waiting longer than that number of seconds for a reply
from the server, shut down the connection, start a new one, and resend
the command. This should hopefully be transparent to the user. A
-likely number is 30 seconds. (You can also @kbd{C-g} if Gnus hangs in
-this manner. The same thing will hopefully happen, but it can be
-somewhat unsafe.)
+likely number is 30 seconds.
+
+@item nntp-retry-on-break
+@vindex nntp-retry-on-break
+If this variable is non-@code{nilp, you can also @kbd{C-g} if Gnus
+hangs. This will have much the same effect as the command timeout
+described above.
@item nntp-server-hook
@vindex nntp-server-hook
@item gnus-auto-center-summary
Set this to @code{nil} to inhibit Gnus from re-centering the summary
-buffer all the time.
+buffer all the time. If it is @code{vertical}, do only vertical
+re-centering. If it is neither @code{nil} nor @code{vertical}, do both
+horizontal and vertical recentering.
@item gnus-visible-headers
Cut down on the headers that are included in the articles to the
projects / gnus / commitdiff