*** pub/sgnus/lisp/gnus-cus.el	Sat Sep 30 06:05:52 1995
--- sgnus/lisp/gnus-cus.el	Sun Oct  1 10:09:01 1995
***************
*** 106,116 ****
  		 ((tag . "Article Display")
  		  (doc . "Controls how the article buffer will look.
  
! The list below contains various filters you can use to change the look
! of the article.  If you leave the list empty, the article will appear
! exactly as it is stored on the disk.  The list entries will hide or
! highlight various parts of the article, making it easier to find the
! information you want.")
  		  (name . gnus-article-display-hook)
  		  (type . list)
  		  (default . (gnus-article-hide-headers-if-wanted
--- 106,115 ----
  		 ((tag . "Article Display")
  		  (doc . "Controls how the article buffer will look.
  
! If you leave the list empty, the article will appear exactly as it is
! stored on the disk.  The list entries will hide or highlight various
! parts of the article, making it easier to find the information you
! want.")
  		  (name . gnus-article-display-hook)
  		  (type . list)
  		  (default . (gnus-article-hide-headers-if-wanted
*** pub/sgnus/lisp/gnus-edit.el	Sat Sep 30 06:05:52 1995
--- sgnus/lisp/gnus-edit.el	Sun Oct  1 11:32:31 1995
***************
*** 548,554 ****
        (if entry 
  	  (mapcar 'gnus-score-custom-sanify (cdr entry))
  	(setq entry (assoc name gnus-score-alist))
! 	(if (memq name '(files exclude-files local adapt))
  	    (cdr entry)
  	  (car (cdr entry)))))))
  
--- 548,556 ----
        (if entry 
  	  (mapcar 'gnus-score-custom-sanify (cdr entry))
  	(setq entry (assoc name gnus-score-alist))
! 	(if  (or (memq name '(files exclude-files local))
! 		 (and (eq name 'adapt)
! 		      (not (symbolp (car (cdr entry))))))
  	    (cdr entry)
  	  (car (cdr entry)))))))
  
*** pub/sgnus/lisp/gnus-msg.el	Sat Sep 30 06:05:53 1995
--- sgnus/lisp/gnus-msg.el	Mon Oct  2 16:42:36 1995
***************
*** 122,127 ****
--- 122,133 ----
  current newsgroup name and then returns a suitable group name (or list
  of names).")
  
+ (defvar gnus-mailing-list-groups nil
+   "*Regexp matching groups that are really mailing lists.
+ This is useful when you're reading a mailing list that has been
+ gatewayed to a newsgroup, and you want to followup to an article in
+ the group.")
+ 
  (defvar gnus-draft-group-directory 
    (expand-file-name
     (concat (file-name-as-directory gnus-article-save-directory)
***************
*** 344,349 ****
--- 350,356 ----
  		       "Do you want to ignore `Followup-To: poster'? "))))
  	;; Mail to the poster. 
  	(gnus-summary-reply yank)
+       ;; Send a followup.
        (gnus-post-news nil gnus-newsgroup-name
  		      headers gnus-article-buffer 
  		      (or yank-articles (not (not yank)))))))
***************
*** 358,364 ****
    "Compose a followup and do an auto mail to author."
    (interactive "P")
    (gnus-set-global-variables)
!   (let ((gnus-auto-mail-to-author t))
      (gnus-summary-followup yank yank-articles)))
  
  (defun gnus-summary-followup-and-reply-with-original (n)
--- 365,371 ----
    "Compose a followup and do an auto mail to author."
    (interactive "P")
    (gnus-set-global-variables)
!   (let ((gnus-auto-mail-to-author 'force))
      (gnus-summary-followup yank yank-articles)))
  
  (defun gnus-summary-followup-and-reply-with-original (n)
***************
*** 451,464 ****
    (interactive (list t))
    (let* ((group (or group gnus-newsgroup-name))
  	 (to-address 
! 	  (cdr (assq 
! 		'to-address 
! 		(nth 5 (nth 2 (gnus-gethash group gnus-newsrc-hashtb)))))))
      (if (and (gnus-member-of-valid 'post (or group gnus-newsgroup-name))
  	     (not to-address))
  	(if post
  	    (gnus-new-news group)
  	  (gnus-news-followup yank group))
        (if post
  	  (progn
  	    (gnus-new-mail to-address)
--- 458,479 ----
    (interactive (list t))
    (let* ((group (or group gnus-newsgroup-name))
  	 (to-address 
! 	  (and group
! 	       (cdr (assq 
! 		     'to-address 
! 		     (nth 5 (nth 2 (gnus-gethash 
! 				    group gnus-newsrc-hashtb)))))))
! 	 (mailing-list
! 	  (and group gnus-mailing-list-groups
! 	       (string-match gnus-mailing-list-groups group))))
      (if (and (gnus-member-of-valid 'post (or group gnus-newsgroup-name))
+ 	     (not mailing-list)
  	     (not to-address))
+ 	;; This is news.
  	(if post
  	    (gnus-new-news group)
  	  (gnus-news-followup yank group))
+       ;; The is mail.
        (if post
  	  (progn
  	    (gnus-new-mail to-address)
***************
*** 553,560 ****
  	  (gnus-inews-narrow-to-headers)
  	  (nnheader-remove-header "fcc")
  
  	  (widen)
! 	    
  	  (if (and gnus-mail-courtesy-message
  		   (or (member "to" types)
  		       (member "cc" types)))
--- 568,583 ----
  	  (gnus-inews-narrow-to-headers)
  	  (nnheader-remove-header "fcc")
  
+ 	  ;; Insert the X-Courtesy-Message header.
+ 	  (and (or (member "to" types)
+ 		   (member "cc" types))
+ 	       (progn
+ 		(goto-char (point-max))
+ 		(insert "X-Courtesy-Message: " 
+ 			(mail-fetch-field "newsgroups"))))
+ 
  	  (widen)
! 	  
  	  (if (and gnus-mail-courtesy-message
  		   (or (member "to" types)
  		       (member "cc" types)))
***************
*** 1132,1142 ****
  
  ;; Written by "Mr. Per Persson" <pp@solace.mh.se>.
  (defun gnus-inews-insert-mime-headers ()
!   (let ((mail-header-separator ""))
      (or (mail-position-on-field "Mime-Version")
  	(insert "1.0")
! 	(cond ((save-excursion
! 		 (beginning-of-buffer)
  		 (re-search-forward "[\200-\377]" nil t))
  	       (or (mail-position-on-field "Content-Type")
  		   (insert "text/plain; charset=ISO-8859-1"))
--- 1155,1173 ----
  
  ;; Written by "Mr. Per Persson" <pp@solace.mh.se>.
  (defun gnus-inews-insert-mime-headers ()
!   (goto-char (point-min))
!   (let ((mail-header-separator 
! 	 (progn 
! 	   (goto-char (point-min))
! 	   (if (and (search-forward (concat "\n" mail-header-separator "\n")
! 				    nil t)
! 		    (not (search-backward "\n\n" nil t)))
! 	       mail-header-separator
! 	     ""))))
      (or (mail-position-on-field "Mime-Version")
  	(insert "1.0")
! 	(cond ((progn
! 		 (goto-char (point-min))
  		 (re-search-forward "[\200-\377]" nil t))
  	       (or (mail-position-on-field "Content-Type")
  		   (insert "text/plain; charset=ISO-8859-1"))
***************
*** 1442,1448 ****
  (defun gnus-new-mail (&optional to)
    (pop-to-buffer gnus-mail-buffer)
    (erase-buffer)
!   (gnus-mail-setup to nil nil nil nil nil))
  
  (defun gnus-mail-reply (&optional yank to-address followup)
    (save-excursion
--- 1473,1480 ----
  (defun gnus-new-mail (&optional to)
    (pop-to-buffer gnus-mail-buffer)
    (erase-buffer)
!   (gnus-mail-setup to nil nil nil nil nil)
!   (gnus-inews-modify-mail-mode-map))
  
  (defun gnus-mail-reply (&optional yank to-address followup)
    (save-excursion
***************
*** 1479,1490 ****
  	    (setq from (mail-fetch-field "from"))
  	    (setq date (or (mail-fetch-field "date") 
  			   (mail-header-date gnus-current-headers)))
! 	    (and from
! 		 (let ((stop-pos 
! 			(string-match "  *at \\|  *@ \\| *(\\| *<" from)))
! 		   (setq message-of
! 			 (concat (if stop-pos (substring from 0 stop-pos) from)
! 				 "'s message of " date))))
  	    (setq sender (mail-fetch-field "sender"))
  	    (setq subject (or (mail-fetch-field "subject") "none"))
  	    ;; Remove any (buggy) Re:'s that are present and make a
--- 1511,1517 ----
  	    (setq from (mail-fetch-field "from"))
  	    (setq date (or (mail-fetch-field "date") 
  			   (mail-header-date gnus-current-headers)))
! 	    (setq message-of (gnus-message-of from date))
  	    (setq sender (mail-fetch-field "sender"))
  	    (setq subject (or (mail-fetch-field "subject") "none"))
  	    ;; Remove any (buggy) Re:'s that are present and make a
***************
*** 1640,1652 ****
  	      (setq from (mail-fetch-field "from"))
  	      (setq date (or (mail-fetch-field "date") 
  			     (mail-header-date gnus-current-headers)))
! 	      (and from
! 		   (let ((stop-pos 
! 			  (string-match "  *at \\|  *@ \\| *(\\| *<" from)))
! 		     (setq message-of
! 			   (concat 
! 			    (if stop-pos (substring from 0 stop-pos) from)
! 			    "'s message of " date))))
  	      (setq subject (or (mail-fetch-field "subject") "none"))
  	      ;; Remove any (buggy) Re:'s that are present and make a
  	      ;; proper one.
--- 1667,1673 ----
  	      (setq from (mail-fetch-field "from"))
  	      (setq date (or (mail-fetch-field "date") 
  			     (mail-header-date gnus-current-headers)))
! 	      (setq message-of (gnus-message-of from date))
  	      (setq subject (or (mail-fetch-field "subject") "none"))
  	      ;; Remove any (buggy) Re:'s that are present and make a
  	      ;; proper one.
***************
*** 1727,1733 ****
  			(or (save-excursion
  			      (set-buffer gnus-article-copy)
  			      (gnus-fetch-field "reply-to"))
! 			    from))))
  	    (if to
  		(if (mail-fetch-field "To")
  		    (progn
--- 1748,1765 ----
  			(or (save-excursion
  			      (set-buffer gnus-article-copy)
  			      (gnus-fetch-field "reply-to"))
! 			    from)))
! 		(x-mail (save-excursion
! 			  (set-buffer gnus-article-copy)
! 			  (gnus-fetch-field "x-mail-copy-to"))))
! 	    ;; Deny sending copy if there's a negative X-Mail-Copy-To
! 	    ;; header. 
! 	    (if x-mail
! 		(if (and (string= xmail "never")
! 			 (not (eq gnus-auto-mail-to-author 'force)))
! 		    (setq to nil)
! 		  (setq to x-mail)))
! 	    ;; Insert a To or Cc header.
  	    (if to
  		(if (mail-fetch-field "To")
  		    (progn
***************
*** 1785,1790 ****
--- 1817,1835 ----
  	  (setq gnus-article-check-size
  		(cons (buffer-size) (gnus-article-checksum))))))))
  
+ (defun gnus-message-of (from date)
+   "Take a FROM and a DATE and create an IN-REPLY-TO."
+   (cond 
+    ((not from)
+     nil)
+    (t
+     (let ((stop-pos 
+ 	   (string-match "  *at \\|  *@ \\| *(\\| *<" from)))
+       (concat (if stop-pos (substring from 0 stop-pos) from)
+ 	      "'s message of " 
+ 	      (if (or (not date) (string= date ""))
+ 		  "(unknown date)" date))))))
+ 
  (defun gnus-mail-yank-original ()
    (interactive)
    (save-excursion
***************
*** 2271,2277 ****
  	   (`
  	    (lambda ()
  	      (gnus-request-expire-articles 
! 	       (, (list (cdr gnus-article-current)))
  	       (, gnus-newsgroup-name) t)))))
      ;; Insert the draft.
      (insert-buffer-substring gnus-article-buffer)
--- 2316,2322 ----
  	   (`
  	    (lambda ()
  	      (gnus-request-expire-articles 
! 	       (quote (, (list (cdr gnus-article-current))))
  	       (, gnus-newsgroup-name) t)))))
      ;; Insert the draft.
      (insert-buffer-substring gnus-article-buffer)
*** pub/sgnus/lisp/gnus-score.el	Sat Sep 30 06:05:53 1995
--- sgnus/lisp/gnus-score.el	Mon Oct  2 13:33:23 1995
***************
*** 1299,1305 ****
  	 (progn
  	   (insert last ?\n)			
  	   (put-text-property (1- (point)) (point) 'articles alike)))
!   
      ;; Find ordinary matches.
      (setq scores score-list) 
      (while scores
--- 1299,1305 ----
  	 (progn
  	   (insert last ?\n)			
  	   (put-text-property (1- (point)) (point) 'articles alike)))
! 
      ;; Find ordinary matches.
      (setq scores score-list) 
      (while scores
***************
*** 1325,1332 ****
--- 1325,1334 ----
  	       arts art)
  	  (if (= dmt ?f)
  	      (setq fuzzy t)
+ 	    ;; Do non-fuzzy matching.
  	    (goto-char (point-min))
  	    (if (= dmt ?e)
+ 		;; Do exact matching.
  		(while (and (not (eobp)) 
  			    (funcall search-func match nil t))
  		  (and (= (progn (beginning-of-line) (point))
***************
*** 1354,1359 ****
--- 1356,1362 ----
  				   arts (cdr arts))
  			     (setcdr art (+ score (cdr art)))))))
  		  (forward-line 1))
+ 	      ;; Do regexp and substring matching.
  	      (and (string= match "") (setq match "\n"))
  	      (while (and (not (eobp))
  			  (funcall search-func match nil t))
*** pub/sgnus/lisp/gnus-soup.el	Sat Sep 30 06:05:53 1995
--- sgnus/lisp/gnus-soup.el	Mon Oct  2 19:16:22 1995
***************
*** 299,314 ****
  	  (set-buffer buf)
  	  (and (buffer-modified-p) (save-buffer))
  	  (kill-buffer (current-buffer)))))
!     (let ((prefix gnus-soup-last-prefix))
!       (while prefix
! 	(gnus-set-work-buffer)
! 	(insert (format "(setq gnus-soup-prev-prefix %d)\n" 
! 			(cdr (car prefix))))
! 	(write-region (point-min) (point-max)
! 		      (concat (car (car prefix)) 
! 			      gnus-soup-prefix-file) 
! 		      nil 'nomesg)
! 	(setq prefix (cdr prefix))))))
  
  (defun gnus-soup-pack (dir packer)
    (let* ((files (mapconcat 'identity
--- 299,317 ----
  	  (set-buffer buf)
  	  (and (buffer-modified-p) (save-buffer))
  	  (kill-buffer (current-buffer)))))
!     (gnus-soup-write-prefixes)))
! 
! (defun gnus-soup-write-prefixes ()
!   (let ((prefix gnus-soup-last-prefix))
!     (while prefix
!       (gnus-set-work-buffer)
!       (insert (format "(setq gnus-soup-prev-prefix %d)\n" 
! 		      (cdr (car prefix))))
!       (write-region (point-min) (point-max)
! 		    (concat (car (car prefix)) 
! 			    gnus-soup-prefix-file) 
! 		    nil 'nomesg)
!       (setq prefix (cdr prefix)))))
  
  (defun gnus-soup-pack (dir packer)
    (let* ((files (mapconcat 'identity
***************
*** 472,477 ****
--- 475,481 ----
  	    (cons (setq entry (cons dir (or gnus-soup-prev-prefix 0)))
  		  gnus-soup-last-prefix)))
      (setcdr entry (1+ (cdr entry)))
+     (gnus-soup-write-prefixes)
      (int-to-string (cdr entry))))
  
  (defun gnus-soup-unpack-packet (dir unpacker packet)
*** pub/sgnus/lisp/gnus-topic.el	Sat Sep 30 06:05:53 1995
--- sgnus/lisp/gnus-topic.el	Wed Oct  4 16:04:17 1995
***************
*** 30,36 ****
  (defvar gnus-group-topic-face 'bold
    "*Face used to highlight topic headers.")
  
! (defvar gnus-group-topics '(("misc" "." nil))
    "*Alist of newsgroup topics.
  This alist has entries of the form
  
--- 30,36 ----
  (defvar gnus-group-topic-face 'bold
    "*Face used to highlight topic headers.")
  
! (defvar gnus-group-topics '(("no" "^no" nil) ("misc" "." nil))
    "*Alist of newsgroup topics.
  This alist has entries of the form
  
***************
*** 47,52 ****
--- 47,55 ----
  (defvar gnus-group-topic-topics-only nil
    "*If non-nil, only the topics will be shown when typing `l' or `L'.")
  
+ (defvar gnus-topic-unique t
+   "*If non-nil, each group will only belong to one topic.")
+ 
  ;; Internal variables.
  
  (defvar gnus-topics-not-listed nil)
***************
*** 54,59 ****
--- 57,63 ----
  ;; Functions.
  
  (defun gnus-group-topic-name ()
+   "The name of the topic on the current line."
    (get-text-property (gnus-point-at-bol) 'gnus-topic))
  
  (defun gnus-group-prepare-topics (level &optional all lowest regexp)
***************
*** 63,69 ****
  If LOWEST is non-nil, list all newsgroups of level LOWEST or higher."
    (set-buffer gnus-group-buffer)
    (let ((buffer-read-only nil)
!         (lowest (or lowest 1)))
      
      (erase-buffer)
      
--- 67,74 ----
  If LOWEST is non-nil, list all newsgroups of level LOWEST or higher."
    (set-buffer gnus-group-buffer)
    (let ((buffer-read-only nil)
!         (lowest (or lowest 1))
! 	tlist info)
      
      (erase-buffer)
      
***************
*** 80,93 ****
      
      ;; Use topics
      (if (< lowest 8)
!         (let ((topics gnus-group-topics)
                topic how)
            (erase-buffer)
            (while topics
              (setq topic (car (car topics))
!                   how (nth 2 (car topics))
                    topics (cdr topics))
  
              (add-text-properties 
  	     (point)
  	     (progn
--- 85,100 ----
      
      ;; Use topics
      (if (< lowest 8)
!         (let ((topics (gnus-topic-find-groups))
                topic how)
            (erase-buffer)
            (while topics
              (setq topic (car (car topics))
! 		  tlist (cdr (car topics))
!                   how (nth 2 (assoc topic gnus-group-topics))
                    topics (cdr topics))
  
+ 	    ;; Insert the topic.
              (add-text-properties 
  	     (point)
  	     (progn
***************
*** 97,106 ****
  		   'face gnus-group-topic-face
  		   'gnus-topic topic))
  
              (if (and (or (and (not how) (not gnus-group-topic-topics-only))
  			 (and how (not (numberp how))))
  		     (not (member topic gnus-topics-not-listed)))
! 		(gnus-topic-insert-topic topic level all lowest t)
  	      (setq gnus-topics-not-listed
  		    (cons topic gnus-topics-not-listed)))))))
  
--- 104,124 ----
  		   'face gnus-group-topic-face
  		   'gnus-topic topic))
  
+ 	    ;; We insert the groups for the topics we want to have. 
              (if (and (or (and (not how) (not gnus-group-topic-topics-only))
  			 (and how (not (numberp how))))
  		     (not (member topic gnus-topics-not-listed)))
! 		(progn
! 		  (setq gnus-topics-not-listed
! 			(delete topic gnus-topics-not-listed))
! 		  (setq tlist (nreverse tlist))
! 		  (while tlist
! 		    (setq info (car tlist))
! 		    (gnus-group-insert-group-line 
! 		     nil (car info) (car (cdr info)) (nth 3 info) 
! 		     (car (gnus-gethash (car info) gnus-newsrc-hashtb))
! 		     (nth 4 info))
! 		    (setq tlist (cdr tlist))))
  	      (setq gnus-topics-not-listed
  		    (cons topic gnus-topics-not-listed)))))))
  
***************
*** 108,143 ****
    (setq gnus-group-list-mode (cons level all))
    (run-hooks 'gnus-group-prepare-hook))
  
! (defun gnus-topic-insert-topic (topic level &optional all lowest m)
!   "Insert all groups matching TOPIC with unread articles of level LEVEL or lower.
! If ALL is non-nil, list groups that have no unread articles.  If
! LOWEST is non-nil, list all newsgroups of level LOWEST or higher.  If
! M is non-nil, nothing will be inserted, but only
! `gnus-group-listed-topics' will be changed."
!   (let ((buffer-read-only nil)
!         (regexp (car (cdr (assoc topic gnus-group-topics))))
!         (newsrc (cdr gnus-newsrc-alist))
!         info clevel unread group w)
      (setq lowest (or lowest 1))
      (while newsrc
        (setq info (car newsrc)
              group (car info)
              newsrc (cdr newsrc)
              unread (car (gnus-gethash group gnus-newsrc-hashtb)))
!       (and unread
!            (string-match regexp group)
!            (<= (setq clevel (car (cdr info))) level)
!            (>= clevel lowest)
!            (or all
!                (eq unread t)
!                (> unread 0)
!                (cdr (assq 'tick (nth 3 info))))
!            (progn
! 	     (gnus-group-insert-group-line 
! 	      nil group (car (cdr info)) (nth 3 info) unread 
! 	      (nth 4 info))
! 	     (setq gnus-topics-not-listed
! 		   (delete topic gnus-topics-not-listed)))))))
  
  (defun gnus-topic-remove-topic ()
    (let ((topic (gnus-group-topic-name))
--- 126,172 ----
    (setq gnus-group-list-mode (cons level all))
    (run-hooks 'gnus-group-prepare-hook))
  
! (defun gnus-topic-find-groups ()
!   (let ((newsrc (cdr gnus-newsrc-alist))
! 	(topics (mapcar (lambda (e) (list (car e)))
! 			gnus-group-topics))
!         info clevel unread group w lowest level all gtopic)
      (setq lowest (or lowest 1))
+     ;; We go through the newsrc to look for matches.
      (while newsrc
        (setq info (car newsrc)
              group (car info)
              newsrc (cdr newsrc)
              unread (car (gnus-gethash group gnus-newsrc-hashtb)))
!       (and 
!        unread				; nil means that the group is dead.
!        (<= (setq clevel (car (cdr info))) level) 
!        (>= clevel lowest)		; Is inside the level we want.
!        (or all
! 	   (eq unread t)
! 	   (> unread 0)
! 	   (cdr (assq 'tick (nth 3 info)))) ; Has right readedness.
!        (progn
! 	 ;; So we find out what topic this group belongs to.  First we
! 	 ;; check the group parameters.
! 	 (setq gtopic (cdr (assq 'topic (nth 5 info))))
! 	 ;; On match, we add it.
! 	 (and (stringp gtopic) 
! 	      (if (setq e (assoc gtopic topics))
! 		  (setcdr e (cons info (cdr e)))
! 		(setq topics (cons (list gtopic info) topics))))
! 	 ;; We look through the topic alist for further matches, if
! 	 ;; needed.  
! 	 (if (or (not gnus-topic-unique) (not (stringp gtopic)))
! 	     (let ((ts gnus-group-topics))
! 	       (while ts
! 		 (if (string-match (nth 1 (car ts)) group)
! 		     (progn
! 		       (setcdr (setq e (assoc (car (car ts)) topics))
! 			       (cons info (cdr e)))
! 		       (and gnus-topic-unique (setq ts nil))))
! 		 (setq ts (cdr ts))))))))
!     topics))
  
  (defun gnus-topic-remove-topic ()
    (let ((topic (gnus-group-topic-name))
*** pub/sgnus/lisp/gnus-vis.el	Sat Sep 30 06:05:54 1995
--- sgnus/lisp/gnus-vis.el	Mon Oct  2 10:05:18 1995
***************
*** 290,298 ****
     (boundp 'gnus-group-reading-menu)
     (progn
       (easy-menu-define
!       gnus-group-reading-menu
!       gnus-group-mode-map
!       ""
        '("Group"
  	["Read" gnus-group-read-group t]
  	["Select" gnus-group-select-group t]
--- 290,296 ----
     (boundp 'gnus-group-reading-menu)
     (progn
       (easy-menu-define
!       gnus-group-reading-menu gnus-group-mode-map ""
        '("Group"
  	["Read" gnus-group-read-group t]
  	["Select" gnus-group-select-group t]
***************
*** 312,320 ****
  	))
    
       (easy-menu-define
!       gnus-group-group-menu
!       gnus-group-mode-map
!       ""
        '("Groups"
  	("Listing"
  	 ["List subscribed groups" gnus-group-list-groups t]
--- 310,316 ----
  	))
    
       (easy-menu-define
!       gnus-group-group-menu gnus-group-mode-map ""
        '("Groups"
  	("Listing"
  	 ["List subscribed groups" gnus-group-list-groups t]
***************
*** 358,366 ****
  	))
  
       (easy-menu-define
!       gnus-group-misc-menu
!       gnus-group-mode-map
!       ""
        '("Misc"
  	["Send a bug report" gnus-bug t]
  	["Send a mail" gnus-group-mail t]
--- 354,360 ----
  	))
  
       (easy-menu-define
!       gnus-group-misc-menu gnus-group-mode-map ""
        '("Misc"
  	["Send a bug report" gnus-bug t]
  	["Send a mail" gnus-group-mail t]
***************
*** 395,403 ****
     (boundp 'gnus-server-menu)
     (progn
       (easy-menu-define
!       gnus-server-menu
!       gnus-server-mode-map
!       ""
        '("Server"
  	["Add" gnus-server-add-server t]
  	["Browse" gnus-server-read-server t]
--- 389,395 ----
     (boundp 'gnus-server-menu)
     (progn
       (easy-menu-define
!       gnus-server-menu gnus-server-mode-map ""
        '("Server"
  	["Add" gnus-server-add-server t]
  	["Browse" gnus-server-read-server t]
***************
*** 408,415 ****
  	["Edit" gnus-server-edit-server t]
  	["Exit" gnus-server-exit t]
  	))
!      (run-hooks 'gnus-server-menu-hook)
!      )))
  
  ;; Browse mode
  (defun gnus-browse-make-menu-bar ()
--- 400,416 ----
  	["Edit" gnus-server-edit-server t]
  	["Exit" gnus-server-exit t]
  	))
! 
!      (easy-menu-define
!       gnus-server-menu gnus-server-mode-map ""
!       '("Connections"
! 	["Open" gnus-server-open-server t]
! 	["Close" gnus-server-close-server t]
! 	["Deny" gnus-server-deny-servers t]
! 	["Reset" gnus-server-remove-denials t]
! 	))
! 
!      (run-hooks 'gnus-server-menu-hook))))
  
  ;; Browse mode
  (defun gnus-browse-make-menu-bar ()
***************
*** 418,433 ****
     (boundp 'gnus-browse-menu)
     (progn
       (easy-menu-define
!       gnus-browse-menu
!       gnus-browse-mode-map
!       ""
        '("Browse"
  	["Subscribe" gnus-browse-unsubscribe-current-group t]
  	["Read" gnus-group-read-group t]
  	["Exit" gnus-browse-exit t]
  	))
!       (run-hooks 'gnus-browse-menu-hook)
!       )))
  
  
  ;; Summary buffer
--- 419,431 ----
     (boundp 'gnus-browse-menu)
     (progn
       (easy-menu-define
!       gnus-browse-menu gnus-browse-mode-map ""
        '("Browse"
  	["Subscribe" gnus-browse-unsubscribe-current-group t]
  	["Read" gnus-group-read-group t]
  	["Exit" gnus-browse-exit t]
  	))
!       (run-hooks 'gnus-browse-menu-hook))))
  
  
  ;; Summary buffer
***************
*** 439,447 ****
     (progn
  
       (easy-menu-define
!       gnus-summary-misc-menu
!       gnus-summary-mode-map
!       ""
        '("Misc"
  	("Mark"
  	 ("Read"
--- 437,443 ----
     (progn
  
       (easy-menu-define
!       gnus-summary-misc-menu gnus-summary-mode-map ""
        '("Misc"
  	("Mark"
  	 ("Read"
***************
*** 515,523 ****
  	))
  
       (easy-menu-define
!       gnus-summary-kill-menu
!       gnus-summary-mode-map
!       ""
        (cons
         "Score"
         (nconc
--- 511,517 ----
  	))
  
       (easy-menu-define
!       gnus-summary-kill-menu gnus-summary-mode-map ""
        (cons
         "Score"
         (nconc
***************
*** 648,656 ****
  	    ))
  
       (easy-menu-define
!       gnus-summary-article-menu
!       gnus-summary-mode-map
!       ""
        '("Article"
  	("Hide"
  	 ["All" gnus-article-hide t]
--- 642,648 ----
  	    ))
  
       (easy-menu-define
!       gnus-summary-article-menu gnus-summary-mode-map ""
        '("Article"
  	("Hide"
  	 ["All" gnus-article-hide t]
***************
*** 716,724 ****
  
  	 
       (easy-menu-define
!       gnus-summary-thread-menu
!       gnus-summary-mode-map
!       ""
        '("Threads"
  	["Toggle threading" gnus-summary-toggle-threads t]
  	["Display hidden thread" gnus-summary-show-thread t]
--- 708,714 ----
  
  	 
       (easy-menu-define
!       gnus-summary-thread-menu gnus-summary-mode-map ""
        '("Threads"
  	["Toggle threading" gnus-summary-toggle-threads t]
  	["Display hidden thread" gnus-summary-show-thread t]
***************
*** 731,740 ****
  	["Lower thread score" gnus-summary-lower-thread t]
  	["Raise thread score" gnus-summary-raise-thread t]
  	))
       (easy-menu-define
!       gnus-summary-post-menu
!       gnus-summary-mode-map
!       ""
        '("Post"
  	["Post an article" gnus-summary-post-news t]
  	["Followup" gnus-summary-followup t]
--- 721,729 ----
  	["Lower thread score" gnus-summary-lower-thread t]
  	["Raise thread score" gnus-summary-raise-thread t]
  	))
+ 
       (easy-menu-define
!       gnus-summary-post-menu gnus-summary-mode-map ""
        '("Post"
  	["Post an article" gnus-summary-post-news t]
  	["Followup" gnus-summary-followup t]
***************
*** 906,914 ****
     (boundp 'gnus-article-article-menu)
     (progn
       (easy-menu-define
!       gnus-article-article-menu
!       gnus-article-mode-map
!       ""
        '("Article"
  	["Scroll forwards" gnus-article-next-page t]
  	["Scroll backwards" gnus-article-prev-page t]
--- 895,901 ----
     (boundp 'gnus-article-article-menu)
     (progn
       (easy-menu-define
!       gnus-article-article-menu gnus-article-mode-map ""
        '("Article"
  	["Scroll forwards" gnus-article-next-page t]
  	["Scroll backwards" gnus-article-prev-page t]
***************
*** 918,926 ****
  	))
  
       (easy-menu-define
!       gnus-article-treatment-menu
!       gnus-article-mode-map
!       ""
        '("Treatment"
  	["Hide headers" gnus-article-hide-headers t]
  	["Hide signature" gnus-article-hide-signature t]
--- 905,911 ----
  	))
  
       (easy-menu-define
!       gnus-article-treatment-menu gnus-article-mode-map ""
        '("Treatment"
  	["Hide headers" gnus-article-hide-headers t]
  	["Hide signature" gnus-article-hide-signature t]
***************
*** 929,936 ****
  	["Remove carriage return" gnus-article-remove-cr t]
  	["Remove quoted-unreadable" gnus-article-de-quoted-unreadable t]
  	))
!      (run-hooks 'gnus-article-menu-hook)
!      )))
  
  ;;;
  ;;; summary highlights
--- 914,920 ----
  	["Remove carriage return" gnus-article-remove-cr t]
  	["Remove quoted-unreadable" gnus-article-de-quoted-unreadable t]
  	))
!      (run-hooks 'gnus-article-menu-hook))))
  
  ;;;
  ;;; summary highlights
*** pub/sgnus/lisp/gnus.el	Sat Sep 30 06:05:56 1995
--- sgnus/lisp/gnus.el	Wed Oct  4 12:38:23 1995
***************
*** 402,407 ****
--- 402,413 ----
  (defvar gnus-use-cache nil
    "*If non-nil, Gnus will cache (some) articles locally.")
  
+ (defvar gnus-keep-backlog nil
+   "*If non-nil, Gnus will keep read articles for later re-retrieval.
+ If it is a number N, then Gnus will only keep the last N articles
+ read.  If it is neither nil nor a number, Gnus will keep all read
+ articles.  This is not a good idea.")
+ 
  (defvar gnus-use-scoring t
    "*If non-nil, enable scoring.")
  
***************
*** 713,718 ****
--- 719,730 ----
  (defvar gnus-save-all-headers t
    "*If non-nil, don't remove any headers before saving.")
  
+ (defvar gnus-saved-headers gnus-visible-headers
+   "*Headers to keep if `gnus-save-all-headers' is nil.
+ If `gnus-save-all-headers' is non-nil, this variable will be ignored.
+ If that variable is nil, however, all headers that match this regexp
+ will be kept while the rest will be deleted before saving.")
+ 
  (defvar gnus-inhibit-startup-message nil
    "*If non-nil, the startup message will not be displayed.")
  
***************
*** 1199,1205 ****
  than this number should be displayed.
  
  The only current function implemented are `gnus-group-prepare-flat'
! (which does the normal boring group display) and
  `gnus-group-prepare-topics' (which does a folding display accoring to
  topics).")
  
--- 1211,1217 ----
  than this number should be displayed.
  
  The only current function implemented are `gnus-group-prepare-flat'
! \(which does the normal boring group display) and
  `gnus-group-prepare-topics' (which does a folding display accoring to
  topics).")
  
***************
*** 1346,1351 ****
--- 1358,1364 ----
  (defvar gnus-internal-global-score-files nil)
  (defvar gnus-score-file-list nil)
  
+ (defvar gnus-opened-servers nil)
  
  (defvar gnus-current-move-group nil)
  
***************
*** 1358,1448 ****
  (defvar gnus-summary-display-table nil)
  
  (defconst gnus-group-line-format-alist
!   (list (list ?M 'marked ?c)
! 	(list ?S 'subscribed ?c)
! 	(list ?L 'level ?d)
! 	(list ?N 'number ?s)
! 	(list ?I 'number-of-dormant ?d)
! 	(list ?T 'number-of-ticked ?d)
! 	(list ?R 'number-of-read ?s)
! 	(list ?t 'number-total ?d)
! 	(list ?y 'number-of-unread-unticked ?s)
! 	(list ?i 'number-of-ticked-and-dormant ?d)
! 	(list ?g 'group ?s)
! 	(list ?G 'qualified-group ?s)
! 	(list ?D 'newsgroup-description ?s)
! 	(list ?o 'moderated ?c)
! 	(list ?O 'moderated-string ?s)
! 	(list ?p 'process-marked ?c)
! 	(list ?s 'news-server ?s)
! 	(list ?n 'news-method ?s)
! 	(list ?z 'news-method-string ?s)
! 	(list ?u 'user-defined ?s)))
  
  (defconst gnus-summary-line-format-alist 
!   (list (list ?N 'number ?d)
! 	(list ?S 'subject ?s)
! 	(list ?s 'subject-or-nil ?s)
! 	(list ?n 'name ?s)
! 	(list ?A '(car (cdr (funcall gnus-extract-address-components from)))
! 	      ?s)
! 	(list ?a '(or (car (funcall gnus-extract-address-components from)) 
! 		      from) ?s)
! 	(list ?F 'from ?s)
! 	(list ?x (macroexpand '(mail-header-xref header)) ?s)
! 	(list ?D (macroexpand '(mail-header-date header)) ?s)
!   	(list ?d '(gnus-dd-mmm (mail-header-date header)) ?s)
! 	(list ?M (macroexpand '(mail-header-id header)) ?s)
! 	(list ?r (macroexpand '(mail-header-references header)) ?s)
! 	(list ?c '(or (mail-header-chars header) 0) ?d)
! 	(list ?L 'lines ?d)
! 	(list ?I 'indentation ?s)
! 	(list ?T '(if (= level 0) "" (make-string (frame-width) ? )) ?s)
! 	(list ?R 'replied ?c)
! 	(list ?\[ 'opening-bracket ?c)
! 	(list ?\] 'closing-bracket ?c)
! 	(list ?\> '(make-string level ? ) ?s)
! 	(list ?\< '(make-string (max 0 (- 20 level)) ? ) ?s)
! 	(list ?i 'score ?d)
! 	(list ?z 'score-char ?c)
! 	(list ?U 'unread ?c)
! 	(list ?t '(gnus-summary-number-of-articles-in-thread 
! 		   (and (boundp 'thread) (car thread)))
! 	      ?d)
! 	(list ?e '(gnus-summary-number-of-articles-in-thread 
! 		   (and (boundp 'thread) (car thread)) t)
! 	      ?c)
! 	(list ?u 'user-defined ?s))
    "An alist of format specifications that can appear in summary lines,
  and what variables they correspond with, along with the type of the
  variable (string, integer, character, etc).")
  
  (defconst gnus-summary-dummy-line-format-alist
!   (list (list ?S 'subject ?s)
! 	(list ?N 'number ?d)
! 	(list ?u 'user-defined ?s)))
  
  (defconst gnus-summary-mode-line-format-alist 
!   (list (list ?G 'group-name ?s)
! 	(list ?g '(gnus-short-group-name group-name) ?s)
! 	(list ?p '(gnus-group-real-name group-name) ?s)
! 	(list ?A 'article-number ?d)
! 	(list ?Z 'unread-and-unselected ?s)
! 	(list ?V 'gnus-version ?s)
! 	(list ?U 'unread ?d)
! 	(list ?S 'subject ?s)
! 	(list ?e 'unselected ?d)
! 	(list ?u 'user-defined ?s)
! 	(list ?d '(length gnus-newsgroup-dormant) ?d)
! 	(list ?t '(length gnus-newsgroup-marked) ?d)
! 	(list ?r '(length gnus-newsgroup-reads) ?d)
! 	(list ?E 'gnus-newsgroup-expunged-tally ?d)
! 	(list ?s '(gnus-current-score-file-nondirectory) ?s)))
  
  (defconst gnus-group-mode-line-format-alist 
!   (list (list ?S 'news-server ?s)
! 	(list ?M 'news-method ?s)
! 	(list ?u 'user-defined ?s)))
  
  (defvar gnus-have-read-active-file nil)
  
--- 1371,1461 ----
  (defvar gnus-summary-display-table nil)
  
  (defconst gnus-group-line-format-alist
!   (` ((?M marked ?c)
!       (?S subscribed ?c)
!       (?L level ?d)
!       (?N number ?s)
!       (?I number-of-dormant ?d)
!       (?T number-of-ticked ?d)
!       (?R number-of-read ?s)
!       (?t number-total ?d)
!       (?y number-of-unread-unticked ?s)
!       (?i number-of-ticked-and-dormant ?d)
!       (?g group ?s)
!       (?G qualified-group ?s)
!       (?D newsgroup-description ?s)
!       (?o moderated ?c)
!       (?O moderated-string ?s)
!       (?p process-marked ?c)
!       (?s news-server ?s)
!       (?n news-method ?s)
!       (?z news-method-string ?s)
!       (?u user-defined ?s))))
  
  (defconst gnus-summary-line-format-alist 
!   (` ((?N number ?d)
!       (?S subject ?s)
!       (?s subject-or-nil ?s)
!       (?n name ?s)
!       (?A (car (cdr (funcall gnus-extract-address-components from)))
! 	  ?s)
!       (?a (or (car (funcall gnus-extract-address-components from)) 
! 	      from) ?s)
!       (?F from ?s)
!       (?x (, (macroexpand '(mail-header-xref header))) ?s)
!       (?D (, (macroexpand '(mail-header-date header))) ?s)
!       (?d (gnus-dd-mmm (mail-header-date header)) ?s)
!       (?M (, (macroexpand '(mail-header-id header))) ?s)
!       (?r (, (macroexpand '(mail-header-references header))) ?s)
!       (?c (or (mail-header-chars header) 0) ?d)
!       (?L lines ?d)
!       (?I indentation ?s)
!       (?T (if (= level 0) "" (make-string (frame-width) ? )) ?s)
!       (?R replied ?c)
!       (?\[ opening-bracket ?c)
!       (?\] closing-bracket ?c)
!       (?\> (make-string level ? ) ?s)
!       (?\< (make-string (max 0 (- 20 level)) ? ) ?s)
!       (?i score ?d)
!       (?z score-char ?c)
!       (?U unread ?c)
!       (?t (gnus-summary-number-of-articles-in-thread 
! 	   (and (boundp 'thread) (car thread)))
! 	  ?d)
!       (?e (gnus-summary-number-of-articles-in-thread 
! 	   (and (boundp 'thread) (car thread)) t)
! 	  ?c)
!       (?u user-defined ?s)))
    "An alist of format specifications that can appear in summary lines,
  and what variables they correspond with, along with the type of the
  variable (string, integer, character, etc).")
  
  (defconst gnus-summary-dummy-line-format-alist
!   (` ((?S subject ?s)
!       (?N number ?d)
!       (?u user-defined ?s))))
  
  (defconst gnus-summary-mode-line-format-alist 
!   (` ((?G group-name ?s)
!       (?g (gnus-short-group-name group-name) ?s)
!       (?p (gnus-group-real-name group-name) ?s)
!       (?A article-number ?d)
!       (?Z unread-and-unselected ?s)
!       (?V gnus-version ?s)
!       (?U unread ?d)
!       (?S subject ?s)
!       (?e unselected ?d)
!       (?u user-defined ?s)
!       (?d (length gnus-newsgroup-dormant) ?d)
!       (?t (length gnus-newsgroup-marked) ?d)
!       (?r (length gnus-newsgroup-reads) ?d)
!       (?E gnus-newsgroup-expunged-tally ?d)
!       (?s (gnus-current-score-file-nondirectory) ?s))))
  
  (defconst gnus-group-mode-line-format-alist 
!   (` ((?S news-server ?s)
!       (?M news-method ?s)
!       (?u user-defined ?s))))
  
  (defvar gnus-have-read-active-file nil)
  
***************
*** 1450,1456 ****
    "gnus-bug@ifi.uio.no (The Gnus Bugfixing Girls + Boys)"
    "The mail address of the Gnus maintainers.")
  
! (defconst gnus-version "September Gnus v0.5"
    "Version number for this version of Gnus.")
  
  (defvar gnus-info-nodes
--- 1463,1469 ----
    "gnus-bug@ifi.uio.no (The Gnus Bugfixing Girls + Boys)"
    "The mail address of the Gnus maintainers.")
  
! (defconst gnus-version "September Gnus v0.6"
    "Version number for this version of Gnus.")
  
  (defvar gnus-info-nodes
***************
*** 1792,1797 ****
--- 1805,1811 ----
  
    ;; gnus-topic
    (autoload 'gnus-topic-fold "gnus-topic")
+   (autoload 'gnus-group-prepare-topics "gnus-topic")
  
    ;; gnus-uu
    (autoload 'gnus-uu-extract-map "gnus-uu" nil nil 'keymap)
***************
*** 3746,3751 ****
--- 3760,3770 ----
    "Return non-nil if the current line is a topic."
    (get-text-property (gnus-point-at-bol) 'gnus-topic))
  
+ (defun gnus-group-parameter-value (params symbol)
+   "Return the value of SYMBOL in group PARAMS."
+   (or (car (memq symbol params))	; It's either a simple symbol
+       (cdr (assq symbol params))))	; or a cons.
+ 
  (defun gnus-group-add-parameter (group param)
    "Add parameter PARAM to GROUP."
    (let ((info (nth 2 (gnus-gethash group gnus-newsrc-hashtb))))
***************
*** 3825,3846 ****
    (gnus-group-set-info params group 'params))
  
  (defun gnus-group-update-group-line ()
!   "This function updates the current line in the newsgroup buffer and
! moves the point to the colon."
    (let* ((buffer-read-only nil)
  	 (group (gnus-group-group-name))
  	 (entry (and group (gnus-gethash group gnus-newsrc-hashtb))))
!     (if entry
! 	(gnus-dribble-enter 
! 	 (concat "(gnus-group-set-info '" (prin1-to-string (nth 2 entry))
! 		 ")")))
!     (beginning-of-line)
!     (delete-region (point) (progn (forward-line 1) (point)))
      (gnus-group-insert-group-line-info group)
      (forward-line -1)
      (gnus-group-position-point)))
  
  (defun gnus-group-insert-group-line-info (group)
    (let ((entry (gnus-gethash group gnus-newsrc-hashtb)) 
  	active info)
      (if entry
--- 3844,3864 ----
    (gnus-group-set-info params group 'params))
  
  (defun gnus-group-update-group-line ()
!   "Update the current line in the group buffer."
    (let* ((buffer-read-only nil)
  	 (group (gnus-group-group-name))
  	 (entry (and group (gnus-gethash group gnus-newsrc-hashtb))))
!     (and entry
! 	 (gnus-dribble-enter 
! 	  (concat "(gnus-group-set-info '" 
! 		  (prin1-to-string (nth 2 entry)) ")")))
!     (gnus-delete-line)
      (gnus-group-insert-group-line-info group)
      (forward-line -1)
      (gnus-group-position-point)))
  
  (defun gnus-group-insert-group-line-info (group)
+   "Insert GROUP on the current line."
    (let ((entry (gnus-gethash group gnus-newsrc-hashtb)) 
  	active info)
      (if entry
***************
*** 3911,3964 ****
  		    'gnus-level level))))
  
  (defun gnus-group-update-group (group &optional visible-only)
!   "Update newsgroup info of GROUP.
! If VISIBLE-ONLY is non-nil, the group won't be displayed if it isn't already."
    (save-excursion
      (set-buffer gnus-group-buffer)
!     (let ((buffer-read-only nil)
! 	  visible)
!       (let ((entry (gnus-gethash group gnus-newsrc-hashtb)))
! 	(if entry
! 	    (gnus-dribble-enter 
! 	     (concat "(gnus-group-set-info '" (prin1-to-string (nth 2 entry))
! 		     ")"))))
!       ;; Buffer may be narrowed.
!       (save-restriction
! 	(widen)
! 	;; Search a line to modify.  If the buffer is large, the search
! 	;; takes long time.  In most cases, current point is on the line
! 	;; we are looking for.  So, first of all, check current line. 
! 	(if (or (progn
! 		  (beginning-of-line)
! 		  (eq (get-text-property (point) 'gnus-group)
! 		      (intern group)))
! 		(progn
! 		  (gnus-goto-char 
! 		   (text-property-any 
! 		    (point-min) (point-max) 'gnus-group (intern group)))))
! 	    ;; GROUP is listed in current buffer. So, delete old line.
! 	    (progn
! 	      (setq visible t)
! 	      (beginning-of-line)
! 	      (delete-region (point) (progn (forward-line 1) (point))))
  	  ;; No such line in the buffer, find out where it's supposed to
  	  ;; go, and insert it there (or at the end of the buffer).
  	  ;; Fix by Per Abrahamsen <amanda@iesd.auc.dk>.
! 	  (or visible-only
! 	      (let ((entry 
! 		     (cdr (cdr (gnus-gethash group gnus-newsrc-hashtb)))))
! 		(while (and entry
! 			    (car entry)
! 			    (not
! 			     (gnus-goto-char
! 			      (text-property-any
! 			       (point-min) (point-max) 
! 			       'gnus-group (intern (car (car entry)))))))
! 		  (setq entry (cdr entry)))
! 		(or entry (goto-char (point-max)))))))
!       (if (or visible (not visible-only))
  	  (gnus-group-insert-group-line-info group))
!       (gnus-group-set-mode-line))))
  
  (defun gnus-group-set-mode-line ()
    (if (memq 'group gnus-updated-mode-lines)
--- 3929,3977 ----
  		    'gnus-level level))))
  
  (defun gnus-group-update-group (group &optional visible-only)
!   "Update all lines where GROUP appear.
! If VISIBLE-ONLY is non-nil, the group won't be displayed if it isn't
! already." 
    (save-excursion
      (set-buffer gnus-group-buffer)
!     ;; The buffer may be narrowed.
!     (save-restriction
!       (widen)
!       (let ((ident (intern group))
! 	    (loc (point-min))
! 	    found buffer-read-only visible)
! 	;; Enter the current status into the dribble buffer.
! 	(let ((entry (gnus-gethash group gnus-newsrc-hashtb)))
! 	  (if entry
! 	      (gnus-dribble-enter 
! 	       (concat "(gnus-group-set-info '" (prin1-to-string (nth 2 entry))
! 		       ")"))))
! 	;; Find all group instances.  If topics are in use, each group
! 	;; may be listed in more than once.
! 	(while (setq loc (text-property-any 
! 			  loc (point-max) 'gnus-group ident))
! 	  (setq found t)
! 	  (goto-char loc)
! 	  (gnus-delete-line)
! 	  (gnus-group-insert-group-line-info group)
! 	  (setq loc (1+ loc)))
! 	(if (or found visible-only)
! 	    ()
  	  ;; No such line in the buffer, find out where it's supposed to
  	  ;; go, and insert it there (or at the end of the buffer).
  	  ;; Fix by Per Abrahamsen <amanda@iesd.auc.dk>.
! 	  (let ((entry (cdr (cdr (gnus-gethash group gnus-newsrc-hashtb)))))
! 	    (while (and entry (car entry)
! 			(not
! 			 (gnus-goto-char
! 			  (text-property-any
! 			   (point-min) (point-max) 
! 			   'gnus-group (intern (car (car entry)))))))
! 	      (setq entry (cdr entry)))
! 	    (or entry (goto-char (point-max))))
! 	  ;; Finally insert the line.
  	  (gnus-group-insert-group-line-info group))
! 	(gnus-group-set-mode-line)))))
  
  (defun gnus-group-set-mode-line ()
    (if (memq 'group gnus-updated-mode-lines)
***************
*** 4370,4376 ****
        (if (assoc method gnus-valid-select-methods)
  	  (require (intern method)))
        (and (gnus-check-backend-function 'request-create-group nname)
! 	   (gnus-request-create-group nname)))))
  
  (defun gnus-group-delete-group (group &optional force)
    "Delete the current group.
--- 4383,4390 ----
        (if (assoc method gnus-valid-select-methods)
  	  (require (intern method)))
        (and (gnus-check-backend-function 'request-create-group nname)
! 	   (gnus-request-create-group nname))
!       t)))
  
  (defun gnus-group-delete-group (group &optional force)
    "Delete the current group.
***************
*** 4598,4604 ****
     (list (read-file-name "Create group from directory: ")))
    (or (file-exists-p dir) (error "No such directory"))
    (or (file-directory-p dir) (error "Not a directory"))
!   (gnus-group-make-group dir "nndir" dir)
    (forward-line -1)
    (gnus-group-position-point))
  
--- 4612,4630 ----
     (list (read-file-name "Create group from directory: ")))
    (or (file-exists-p dir) (error "No such directory"))
    (or (file-directory-p dir) (error "Not a directory"))
!   (let ((ext "")
! 	(i 0)
! 	group)
!     (while (or (not group) (gnus-gethash group gnus-newsrc-hashtb))
!       (setq group
! 	    (gnus-group-prefixed-name 
! 	     (concat (file-name-as-directory (directory-file-name dir))
! 		     ext)
! 	     '(nndir "")))
!       (setq ext (format "<%d>" (setq i (1+ i)))))
!     (gnus-group-make-group 
!      (gnus-group-real-name group)
!      (list 'nndir group (list 'nndir-directory dir))))
    (forward-line -1)
    (gnus-group-position-point))
  
***************
*** 6377,6394 ****
  	  gnus-empty-thread-mark)
        number)))
  
- ;; This function goes through the local params of GROUP and sets all
- ;; variable specs in that list.
  (defun gnus-summary-set-local-parameters (group)
    (let ((params (nth 5 (nth 2 (gnus-gethash group gnus-newsrc-hashtb))))
  	elem)
      (while params
        (setq elem (car params)
  	    params (cdr params))
!       (and (consp elem) 
! 	   (consp (cdr elem))
! 	   (symbolp (car elem))
! 	   (progn
  	     (make-local-variable (car elem))
  	     (set (car elem) (eval (nth 1 elem))))))))
  
--- 6403,6419 ----
  	  gnus-empty-thread-mark)
        number)))
  
  (defun gnus-summary-set-local-parameters (group)
+  "Go through the local params of GROUP and set all variable specs in that list."
    (let ((params (nth 5 (nth 2 (gnus-gethash group gnus-newsrc-hashtb))))
  	elem)
      (while params
        (setq elem (car params)
  	    params (cdr params))
!       (and (consp elem)			; Has to be a cons.
! 	   (consp (cdr elem))		; The cdr has to be a list.
! 	   (symbolp (car elem))		; Has to be a symbol in there.
! 	   (progn			; So we set it.
  	     (make-local-variable (car elem))
  	     (set (car elem) (eval (nth 1 elem))))))))
  
***************
*** 6884,6890 ****
  		;; We output a dummy root.
  		(gnus-summary-insert-dummy-line 
  		 nil header (mail-header-number
! 			     (car (car (cdr (car thread)))))))
  	       (t
  		;; We do not make a root for the gathered
  		;; sub-threads at all.  
--- 6909,6916 ----
  		;; We output a dummy root.
  		(gnus-summary-insert-dummy-line 
  		 nil header (mail-header-number
! 			     (car (car (cdr (car thread))))))
! 		(setq gnus-tmp-prev-subject header))
  	       (t
  		;; We do not make a root for the gathered
  		;; sub-threads at all.  
***************
*** 6972,6979 ****
  					 header level)
  			 gnus-newsgroup-data))
  
! 	     (setq gnus-tmp-prev-subject 
! 		   (gnus-simplify-subject-re subject)))))
  
  	(if (nth 1 thread) 
  	    (setq stack (cons (cons (max 0 level) (nthcdr 1 thread)) stack)))
--- 6998,7004 ----
  					 header level)
  			 gnus-newsgroup-data))
  
! 	     (setq gnus-tmp-prev-subject subject))))
  
  	(if (nth 1 thread) 
  	    (setq stack (cons (cons (max 0 level) (nthcdr 1 thread)) stack)))
***************
*** 7521,7528 ****
  (defun gnus-get-newsgroup-headers ()
    (setq gnus-article-internal-prepare-hook nil)
    (let ((cur nntp-server-buffer)
! 	(dependencies (save-excursion (set-buffer gnus-summary-buffer)
! 				      gnus-newsgroup-dependencies))
  	headers id id-dep ref-dep end ref)
      (save-excursion
        (set-buffer nntp-server-buffer)
--- 7546,7553 ----
  (defun gnus-get-newsgroup-headers ()
    (setq gnus-article-internal-prepare-hook nil)
    (let ((cur nntp-server-buffer)
! 	(dependencies; (save-excursion (set-buffer gnus-summary-buffer)
! 				      gnus-newsgroup-dependencies) ;)
  	headers id id-dep ref-dep end ref)
      (save-excursion
        (set-buffer nntp-server-buffer)
***************
*** 7546,7552 ****
  	    ;; Number.
  	    (prog1
  		(read cur)
! 	      (forward-line 1)
  	      (setq p (point))
  	      (narrow-to-region (point) 
  				(or (and (search-forward "\n.\n" nil t)
--- 7571,7577 ----
  	    ;; Number.
  	    (prog1
  		(read cur)
! 	      (end-of-line)
  	      (setq p (point))
  	      (narrow-to-region (point) 
  				(or (and (search-forward "\n.\n" nil t)
***************
*** 7606,7612 ****
  			(setq ref (substring in-reply-to (match-beginning 0)
  					     (match-end 0)))
  		      (setq ref (downcase ref))))
! 		(setq ref "none")))
  	    ;; Chars.
  	    0
  	    ;; Lines.
--- 7631,7637 ----
  			(setq ref (substring in-reply-to (match-beginning 0)
  					     (match-end 0)))
  		      (setq ref (downcase ref))))
! 		(setq ref "")))
  	    ;; Chars.
  	    0
  	    ;; Lines.
***************
*** 9187,9213 ****
    (gnus-set-global-variables)
    (save-excursion
      (set-buffer gnus-article-buffer)
!     (let ((buffer-read-only nil))
!       (if (numberp arg) 
! 	  (if (> arg 0) (remove-text-properties (point-min) (point-max) 
! 						gnus-hidden-properties)
! 	    (if (< arg 0) (run-hooks 'gnus-article-display-hook)))
! 	(if (text-property-any (point-min) (point-max) 'invisible t)
! 	    (remove-text-properties 
! 	     (point-min) (point-max) gnus-hidden-properties)
! 	  ;; We hide the headers. This song and dance act below is
! 	  ;; done because `gnus-have-all-headers' is buffer-local to
! 	  ;; the summary buffer, and we only want to temporarily
! 	  ;; change it in that buffer. Ugh.
! 	  (let ((have gnus-have-all-headers))
! 	    (save-excursion
! 	      (set-buffer gnus-summary-buffer)
! 	      (setq gnus-have-all-headers nil)
! 	      (save-excursion
! 		(set-buffer gnus-article-buffer)
! 		(run-hooks 'gnus-article-display-hook))
! 	      (setq gnus-have-all-headers have)))))
!       (set-window-point (get-buffer-window (current-buffer)) (point-min)))))
  
  (defun gnus-summary-show-all-headers ()
    "Make all header lines visible."
--- 9212,9232 ----
    (gnus-set-global-variables)
    (save-excursion
      (set-buffer gnus-article-buffer)
!     (let* ((buffer-read-only nil)
! 	   (inhibit-point-motion-hooks t) 
! 	   (hidden (text-property-any (point-min) (search-forward "\n\n")
! 				      'invisible t))
! 	   e)
!       (goto-char (point-min))
!       (delete-region (point) (1- (search-forward "\n\n" nil t)))
!       (goto-char (point-min))
!       (save-excursion 
! 	(set-buffer gnus-original-article-buffer)
! 	(goto-char (point-min))
! 	(setq e (1- (search-forward "\n\n"))))
!       (insert-buffer-substring gnus-original-article-buffer 1 e)
!       (if (or (not hidden) (and (numberp arg) (< arg 0)))
! 	  (gnus-article-hide-headers)))))
  
  (defun gnus-summary-show-all-headers ()
    "Make all header lines visible."
***************
*** 9440,9446 ****
  		  (gnus-request-article-this-buffer
  		   (car articles) gnus-newsgroup-name)
  		  (gnus-request-accept-article
! 		   (if select-method (quote select-method) to-newsgroup)
  		   (not (cdr articles)))))
  	  (let* ((entry 
  		  (or
--- 9459,9465 ----
  		  (gnus-request-article-this-buffer
  		   (car articles) gnus-newsgroup-name)
  		  (gnus-request-accept-article
! 		   (if select-method select-method to-newsgroup)
  		   (not (cdr articles)))))
  	  (let* ((entry 
  		  (or
***************
*** 10729,10735 ****
  	      (save-window-excursion
  		(gnus-summary-select-article t nil nil (car articles)))
  	      (or gnus-save-all-headers
! 		  (gnus-article-hide-headers t))
  	      ;; Remove any X-Gnus lines.
  	      (save-excursion
  		(save-restriction
--- 10748,10757 ----
  	      (save-window-excursion
  		(gnus-summary-select-article t nil nil (car articles)))
  	      (or gnus-save-all-headers
! 		  ;; Remove headers accoring to `gnus-saved-headers'.
! 		  (let ((gnus-visible-headers 
! 			 (or gnus-saved-headers gnus-visible-headers)))
! 		    (gnus-article-hide-headers t)))
  	      ;; Remove any X-Gnus lines.
  	      (save-excursion
  		(save-restriction
***************
*** 11293,11298 ****
--- 11315,11326 ----
  	 ;; We first check `gnus-original-article-buffer'.
  	 ((and (equal (car gnus-original-article) group)
  	       (eq (cdr gnus-original-article) article))
+ 	  ;; We don't have to do anything, since it's already where we
+ 	  ;; want it.  
+ 	  'article)
+ 	 ;; Check the backlog.
+ 	 ((and gnus-keep-backlog
+ 	       (gnus-backlog-request-article group article (current-buffer)))
  	  'article)
  	 ;; Check the cache.
  	 ((and gnus-use-cache
***************
*** 11304,11311 ****
  	  (erase-buffer)
  	  (let ((gnus-override-method 
  		 (and (stringp article) gnus-refer-article-method)))
! 	    (and (gnus-request-article article group (current-buffer))
! 		 'article)))
  	 ;; It was a pseudo.
  	 (t article)))
      (setq gnus-original-article (cons group article))
--- 11332,11343 ----
  	  (erase-buffer)
  	  (let ((gnus-override-method 
  		 (and (stringp article) gnus-refer-article-method)))
! 	    (if (gnus-request-article article group (current-buffer))
! 		(progn
! 		  (and gnus-keep-backlog 
! 		       (gnus-backlog-enter-article 
! 			group article (current-buffer)))
! 		  'article))))
  	 ;; It was a pseudo.
  	 (t article)))
      (setq gnus-original-article (cons group article))
***************
*** 11565,11571 ****
  		((eq next ?_)
  		 (put-text-property (1- (point)) (1+ (point))
  				    'invisible t)
! 		 (put-text-property (1- (point)) (point)
  				    'face 'underline))
  		((eq previous ?_)
  		 (put-text-property (- (point) 2) (point)
--- 11597,11603 ----
  		((eq next ?_)
  		 (put-text-property (1- (point)) (1+ (point))
  				    'invisible t)
! 		 (put-text-property (- (point) 2) (1- (point))
  				    'face 'underline))
  		((eq previous ?_)
  		 (put-text-property (- (point) 2) (point)
***************
*** 11645,11651 ****
  		(process-send-eof "gnus-x-face")))))))))
  
  (defun gnus-article-de-quoted-unreadable (&optional force)
!   "Do a naïve translation of a quoted-printable-encoded article.
  This is in no way, shape or form meant as a replacement for real MIME
  processing, but is simply a stop-gap measure until MIME support is
  written.
--- 11677,11683 ----
  		(process-send-eof "gnus-x-face")))))))))
  
  (defun gnus-article-de-quoted-unreadable (&optional force)
!   "Do a naive translation of a quoted-printable-encoded article.
  This is in no way, shape or form meant as a replacement for real MIME
  processing, but is simply a stop-gap measure until MIME support is
  written.
***************
*** 12315,12322 ****
  ;;; Interface functions to the backends.
  
  (defun gnus-open-server (method)
!   (funcall (gnus-get-function method 'open-server)
! 	   (nth 1 method) (nthcdr 2 method)))
  
  (defun gnus-close-server (method)
    (funcall (gnus-get-function method 'close-server) (nth 1 method)))
--- 12347,12368 ----
  ;;; Interface functions to the backends.
  
  (defun gnus-open-server (method)
!   (let ((elem (assoc method gnus-opened-servers)))
!     ;; If this method was previously denied, we just return nil.
!     (if (eq (cdr elem) 'denied)
! 	nil
!       ;; Open the server.
!       (let ((result
! 	     (funcall (gnus-get-function method 'open-server)
! 		      (nth 1 method) (nthcdr 2 method))))
! 	;; If this hasn't been opened before, we add it to the list.
! 	(or elem 
! 	    (setq elem (list method nil)
! 		  gnus-opened-servers (cons elem gnus-opened-servers)))
! 	;; Set the status of this server.
! 	(setcar (cdr elem) (if result 'ok 'denied))
! 	;; Return the result from the "open" call.
! 	result))))
  
  (defun gnus-close-server (method)
    (funcall (gnus-get-function method 'close-server) (nth 1 method)))
***************
*** 14160,14166 ****
  (defvar gnus-server-mode-hook nil
    "Hook run in `gnus-server-mode' buffers.")
  
! (defconst gnus-server-line-format "     {%(%h:%w%)}\n"
    "Format of server lines.
  It works along the same lines as a normal formatting string,
  with some simple extensions.")
--- 14206,14212 ----
  (defvar gnus-server-mode-hook nil
    "Hook run in `gnus-server-mode' buffers.")
  
! (defconst gnus-server-line-format "     {%(%h:%w%)} %s\n"
    "Format of server lines.
  It works along the same lines as a normal formatting string,
  with some simple extensions.")
***************
*** 14169,14183 ****
    "The format specification for the server mode line.")
  
  (defconst gnus-server-line-format-alist
!   (list (list ?h 'how ?s)
! 	(list ?n 'name ?s)
! 	(list ?w 'where ?s)
! 	))
  
  (defconst gnus-server-mode-line-format-alist 
!   (list (list ?S 'news-server ?s)
! 	(list ?M 'news-method ?s)
! 	(list ?u 'user-defined ?s)))
  
  (defvar gnus-server-line-format-spec nil)
  (defvar gnus-server-mode-line-format-spec nil)
--- 14215,14229 ----
    "The format specification for the server mode line.")
  
  (defconst gnus-server-line-format-alist
!   (` ((?h how ?s)
!       (?n name ?s)
!       (?w where ?s)
!       (?s status ?s)))) 
  
  (defconst gnus-server-mode-line-format-alist 
!   (` ((?S news-server ?s)
!       (?M news-method ?s)
!       (?u user-defined ?s))))
  
  (defvar gnus-server-line-format-spec nil)
  (defvar gnus-server-mode-line-format-spec nil)
***************
*** 14199,14205 ****
    (define-key gnus-server-mode-map "y" 'gnus-server-yank-server)
    (define-key gnus-server-mode-map "c" 'gnus-server-copy-server)
    (define-key gnus-server-mode-map "a" 'gnus-server-add-server)
!   (define-key gnus-server-mode-map "e" 'gnus-server-edit-server))
  
  (defun gnus-server-mode ()
    "Major mode for listing and editing servers.
--- 14245,14257 ----
    (define-key gnus-server-mode-map "y" 'gnus-server-yank-server)
    (define-key gnus-server-mode-map "c" 'gnus-server-copy-server)
    (define-key gnus-server-mode-map "a" 'gnus-server-add-server)
!   (define-key gnus-server-mode-map "e" 'gnus-server-edit-server)
! 
!   (define-key gnus-server-mode-map "O" 'gnus-server-open-server)
!   (define-key gnus-server-mode-map "C" 'gnus-server-close-server)
!   (define-key gnus-server-mode-map "D" 'gnus-server-deny-server)
!   (define-key gnus-server-mode-map "R" 'gnus-server-remove-denials)
!   )
  
  (defun gnus-server-mode ()
    "Major mode for listing and editing servers.
***************
*** 14234,14239 ****
--- 14286,14298 ----
    (let* ((sformat (or sformat gnus-server-line-format-spec))
  	 (how (car method))
  	 (where (nth 1 method))
+ 	 (elem (assoc method gnus-opened-servers))
+ 	 (status (cond ((eq (nth 1 elem) 'denied)
+ 			"(denied)")
+ 		       ((gnus-server-opened method)
+ 			"(open)")
+ 		       (t
+ 			"(closed)")))
  	 b)
      (beginning-of-line)
      (setq b (point))
***************
*** 14257,14267 ****
  	(gnus-parse-format gnus-server-line-format 
  			   gnus-server-line-format-alist))
    (let ((alist gnus-server-alist)
! 	(buffer-read-only nil))
      (erase-buffer)
      (while alist
        (gnus-server-insert-server-line nil (car (car alist)) (cdr (car alist)))
!       (setq alist (cdr alist))))
    (goto-char (point-min))
    (gnus-server-position-point))
  
--- 14316,14339 ----
  	(gnus-parse-format gnus-server-line-format 
  			   gnus-server-line-format-alist))
    (let ((alist gnus-server-alist)
! 	(buffer-read-only nil)
! 	(opened gnus-opened-servers)
! 	done)
      (erase-buffer)
+     ;; First we do the real list of servers.
      (while alist
        (gnus-server-insert-server-line nil (car (car alist)) (cdr (car alist)))
!       (and (assoc (cdr (car alist)) gnus-opened-servers)
! 	   (setq done (cons (cdr (car alist)) done)))
!       (setq alist (cdr alist)))
!     ;; Then we insert the list of servers that have been opened in
!     ;; this session.
!     (while opened 
!       (or (member (car (car opened)) done)
! 	  (gnus-server-insert-server-line 
! 	   nil (concat (car (car (car opened)))
! 		       (nth 1 (car (car opened)))) (car (car opened))))
!       (setq opened (cdr opened))))
    (goto-char (point-min))
    (gnus-server-position-point))
  
***************
*** 14399,14404 ****
--- 14471,14521 ----
        (forward-line -1))
      (gnus-server-position-point)))
  
+ (defun gnus-opened-servers-remove (method)
+   "Remove METHOD from the list of opened servers."
+   (setq gnus-opened-servers (delq (assoc method gnus-opened-servers)
+ 				  gnus-opened-servers)))
+ 
+ (defun gnus-server-open-server (server)
+   "Force an open of SERVER."
+   (interactive (list (gnus-server-server-name)))
+   (let ((method (gnus-server-to-method server)))
+     (or method (error "No such server: %s" server))
+     (gnus-opened-servers-remove method)
+     (prog1
+ 	(or (gnus-open-server method)
+ 	    (progn (message "Couldn't open %s" server) nil))
+       (gnus-server-update-server server)
+       (gnus-server-position-point))))
+ 
+ (defun gnus-server-close-server (server)
+   "Close SERVER."
+   (interactive (list (gnus-server-server-name)))
+   (let ((method (gnus-server-to-method server)))
+     (or method (error "No such server: %s" server))
+     (gnus-opened-servers-remove method)
+     (prog1
+ 	(gnus-close-server method)
+       (gnus-server-update-server server)
+       (gnus-server-position-point))))
+ 
+ (defun gnus-server-deny-server (server)
+   "Make sure SERVER will never be attempted opened."
+   (interactive (list (gnus-server-server-name)))
+   (let ((method (gnus-server-to-method server)))
+     (or method (error "No such server: %s" server))
+     (gnus-opened-servers-remove method)
+     (setq gnus-opened-servers
+ 	  (cons (list method 'denied) gnus-opened-servers)))
+   (gnus-server-update-server server)
+   (gnus-server-position-point))
+ 
+ (defun gnus-server-remove-denials ()
+   "Remove all marks as to whether Gnus could open servers or not."
+   (interactive)
+   (setq gnus-opened-servers nil)
+   (gnus-server-list-servers))
+ 
  (defun gnus-server-copy-server (from to)
    (interactive
     (list
***************
*** 14622,14638 ****
        ;; the local score file, whether it exists or not. This is so
        ;; that any score commands the user enters will go to the right
        ;; file, and not end up in some global score file.
!       (let ((localscore
! 	     (expand-file-name
! 	      (if (gnus-use-long-file-name 'not-score)
! 		  (concat gnus-kill-files-directory group "." 
! 			  gnus-score-file-suffix)
! 		(concat gnus-kill-files-directory
! 			(gnus-replace-chars-in-string group ?. ?/ ?: ?/)
! 			"/" gnus-score-file-suffix)))))
! 	(and (member localscore ofiles)
! 	     (delete localscore ofiles))
! 	(setq ofiles (cons localscore ofiles)))
        (nreverse ofiles))))
  
  (defun gnus-score-find-single (group)
--- 14739,14746 ----
        ;; the local score file, whether it exists or not. This is so
        ;; that any score commands the user enters will go to the right
        ;; file, and not end up in some global score file.
!       (let ((localscore (gnus-score-file-name group)))
! 	(setq ofiles (cons localscore (delete localscore ofiles))))
        (nreverse ofiles))))
  
  (defun gnus-score-find-single (group)
***************
*** 14689,14695 ****
  	    (cons (cons group score-files) gnus-score-file-alist-cache))
        score-files)))
  
- 
  (defun gnus-possibly-score-headers (&optional trace)
    (let ((func gnus-score-find-score-files-function)
  	score-files)
--- 14797,14802 ----
***************
*** 14741,14746 ****
--- 14848,14927 ----
  	(setq out (cons (car files) out)))
        (setq files (cdr files)))
      (setq gnus-internal-global-score-files out)))
+ 
+ ;;;
+ ;;; Buffering of read articles.
+ ;;;
+ 
+ (defvar gnus-backlog-buffer " *Gnus Backlog*")
+ (defvar gnus-backlog-articles nil)
+ 
+ (defun gnus-backlog-buffer ()
+   (or (get-buffer gnus-backlog-buffer)
+       (save-excursion
+ 	(set-buffer (get-buffer-create gnus-backlog-buffer))
+ 	(buffer-disable-undo (current-buffer))
+ 	(setq buffer-read-only t)
+ 	(gnus-add-current-to-buffer-list))))
+ 
+ (defun gnus-backlog-enter-article (group number buffer)
+   (let ((ident (intern (concat group ":" (int-to-string number))))
+ 	b)
+     (if (memq ident gnus-backlog-articles)
+ 	() ; It's already kept.
+       ;; Remove the oldest article, if necessary.
+       (and (numberp gnus-keep-backlog)
+ 	   (>= (length gnus-backlog-articles) gnus-keep-backlog)
+ 	   (gnus-backlog-remove-oldest-article))
+       (setq gnus-backlog-articles (cons ident gnus-backlog-articles))
+       ;; Insert the new article.
+       (save-excursion
+ 	(set-buffer (gnus-backlog-buffer))
+ 	(let (buffer-read-only)
+ 	  (goto-char (point-max))
+ 	  (or (bolp) (insert "\n"))
+ 	  (setq b (point))
+ 	  (insert-buffer-substring buffer)
+ 	  ;; Tag the beginning of the article with the ident.
+ 	  (put-text-property b (1+ b) 'gnus-backlog ident))))))
+ 
+ (defun gnus-backlog-remove-oldest-article ()
+   (save-excursion
+     (set-buffer (gnus-backlog-buffer))
+     (goto-char (point-min))
+     (if (zerop (buffer-size))
+ 	() ; The buffer is empty.
+       (let ((ident (get-text-property (point) 'gnus-backlog))
+ 	    buffer-read-only)
+ 	;; Remove the ident from the list of articles.
+ 	(and ident
+ 	     (setq gnus-backlog-articles (delq ident gnus-backlog-articles)))
+ 	;; Delete the article itself.
+ 	(delete-region 
+ 	 (point) (next-single-property-change
+ 		  (1+ (point)) 'gnus-backlog nil (point-max)))))))
+ 
+ (defun gnus-backlog-request-article (group number buffer)
+   (let ((ident (intern (concat group ":" (int-to-string number))))
+ 	beg end)
+     (if (not (memq ident gnus-backlog-articles))
+ 	() ; It wasn't in the backlog.
+       (save-excursion
+ 	(set-buffer (gnus-backlog-buffer))
+ 	(if (not (setq beg (text-property-any 
+ 			    (point-min) (point-max) 'gnus-backlog
+ 			    ident)))
+ 	    ;; It wasn't in the backlog after all.
+ 	    (progn
+ 	      (setq gnus-backlog-articles (delq ident gnus-backlog-articles))
+ 	      nil)
+ 	  ;; Find the end (i. e., the beginning of the next article).
+ 	  (setq end
+ 		(next-single-property-change 
+ 		 (1+ beg) 'gnus-backlog (current-buffer) (point-max)))))
+       (erase-buffer)
+       (insert-buffer-substring gnus-backlog-buffer beg end))))
+ 					      
  
  ;; Allow redefinition of Gnus functions.
  
*** pub/sgnus/lisp/nndir.el	Sat Sep 30 06:05:56 1995
--- sgnus/lisp/nndir.el	Sun Oct  1 10:52:32 1995
***************
*** 116,122 ****
  (defun nndir-request-expire-articles 
    (articles group &optional server force)
    (nndir-execute-nnmh-command
!    (` (nnmh-request-expire-articles (, articles) group
  				    (, server) (, force)))))
  
  (defun nndir-request-accept-article (group &optional last)
--- 116,122 ----
  (defun nndir-request-expire-articles 
    (articles group &optional server force)
    (nndir-execute-nnmh-command
!    (` (nnmh-request-expire-articles (quote (, articles)) group
  				    (, server) (, force)))))
  
  (defun nndir-request-accept-article (group &optional last)
*** pub/sgnus/lisp/nneething.el	Sat Sep 30 06:05:56 1995
--- sgnus/lisp/nneething.el	Mon Oct  2 18:57:38 1995
***************
*** 200,206 ****
  
  (defun nneething-map-file ()
    ;; We make sure that the .neething directory exists. 
!   (make-directory nneething-map-file-directory 'parents)
    ;; We store it in a special directory under the user's home dir.
    (concat (file-name-as-directory nneething-map-file-directory)
  	  nneething-group nneething-map-file))
--- 200,207 ----
  
  (defun nneething-map-file ()
    ;; We make sure that the .neething directory exists. 
!   (or (file-exists-p nneething-map-file-directory)
!       (make-directory nneething-map-file-directory 'parents))
    ;; We store it in a special directory under the user's home dir.
    (concat (file-name-as-directory nneething-map-file-directory)
  	  nneething-group nneething-map-file))
*** pub/sgnus/lisp/nnmail.el	Sat Sep 30 06:05:57 1995
--- sgnus/lisp/nnmail.el	Mon Oct  2 18:57:01 1995
***************
*** 128,137 ****
  
  Eg.
  
! (add-hook 'nnmail-read-incoming-hook 
  	   (lambda () 
  	     (start-process \"mailsend\" nil 
! 			    \"/local/bin/mailsend\" \"read\" \"mbox\")))")
  
  ;; Suggested by Erik Selberg <speed@cs.washington.edu>.
  (defvar nnmail-prepare-incoming-hook nil
--- 128,149 ----
  
  Eg.
  
! \(add-hook 'nnmail-read-incoming-hook 
  	   (lambda () 
  	     (start-process \"mailsend\" nil 
! 			    \"/local/bin/mailsend\" \"read\" \"mbox\")))
! 
! If you have xwatch running, this will alert it that mail has been
! read.  
! 
! If you use `display-time', you could use something like this:
! 
! \(add-hook 'nnmail-read-incoming-hook
! 	  (lambda ()
! 	    ;; Update the displayed time, since that will clear out
! 	    ;; the flag that says you have mail.
! 	    (if (eq (process-status \"display-time\") 'run)
! 		(display-time-filter display-time-process \"\"))))") 
  
  ;; Suggested by Erik Selberg <speed@cs.washington.edu>.
  (defvar nnmail-prepare-incoming-hook nil
*** pub/sgnus/lisp/nnsoup.el	Sat Sep 30 06:05:57 1995
--- sgnus/lisp/nnsoup.el	Mon Oct  2 19:16:19 1995
***************
*** 284,302 ****
    (nnsoup-store-reply "mail")
    t)
  
- (defun nnsoup-request-post-buffer (post group &rest args)
-   (nnsoup-possibly-change-group group)
-   (apply
-    ;; Find out whether the source for this group is a mail or a news
-    ;; group and call the right function for getting a buffer.
-    (let ((enc (nth 1 (car (cdr (assoc nnsoup-current-group
- 				      nnsoup-group-alist))))))
-      (if (and enc
- 	      (= (gnus-soup-encoding-kind (gnus-soup-area-encoding enc)) ?m))
- 	 'nnmail-request-post-buffer 
-        'nntp-request-post-buffer))
-    post group args))
- 
  
  ;;; Internal functions
  
--- 284,289 ----
*** pub/sgnus/lisp/nntp.el	Sat Sep 30 06:05:57 1995
--- sgnus/lisp/nntp.el	Mon Oct  2 09:03:52 1995
***************
*** 164,170 ****
  (defvar nntp-server-xover 'try)
  (defvar nntp-server-list-active-group 'try)
  (defvar nntp-current-group "")
- (defvar nntp-timeout-servers nil)
  
  (defvar nntp-async-process nil)
  (defvar nntp-async-buffer nil)
--- 164,169 ----
***************
*** 355,364 ****
      (setq nntp-current-server server)
      (or (nntp-server-opened server)
  	(progn
! 	  (if (member nntp-address nntp-timeout-servers)
! 	      nil
! 	    (run-hooks 'nntp-prepare-server-hook)
! 	    (nntp-open-server-semi-internal nntp-address nntp-port-number))))))
  
  (defun nntp-close-server (&optional server)
    "Close connection to SERVER."
--- 354,361 ----
      (setq nntp-current-server server)
      (or (nntp-server-opened server)
  	(progn
! 	  (run-hooks 'nntp-prepare-server-hook)
! 	  (nntp-open-server-semi-internal nntp-address nntp-port-number)))))
  
  (defun nntp-close-server (&optional server)
    "Close connection to SERVER."
***************
*** 373,380 ****
  	;; We cannot send QUIT command unless the process is running.
  	(if (nntp-server-opened)
  	    (nntp-send-command nil "QUIT")))
!     (nntp-close-server-internal server)
!     (setq nntp-timeout-servers (delete server nntp-timeout-servers))))
  
  (defalias 'nntp-request-quit (symbol-function 'nntp-close-server))
  
--- 370,376 ----
  	;; We cannot send QUIT command unless the process is running.
  	(if (nntp-server-opened)
  	    (nntp-send-command nil "QUIT")))
!     (nntp-close-server-internal server)))
  
  (defalias 'nntp-request-quit (symbol-function 'nntp-close-server))
  
***************
*** 418,424 ****
  	   (kill-buffer proc))
        (setq nntp-server-alist (cdr nntp-server-alist)))
      (setq nntp-current-server nil
- 	  nntp-timeout-servers nil
  	  nntp-async-group-alist nil)))
  
  (defun nntp-server-opened (&optional server)
--- 414,419 ----
***************
*** 674,680 ****
  			   (assoc server nntp-server-alist)))))
      (and proc (delete-process (process-name proc)))
      (nntp-close-server server)
-     (setq nntp-timeout-servers (cons server nntp-timeout-servers))
      (setq nntp-status-string 
  	  (message "Connection timed out to server %s." server))
      (ding)
--- 669,674 ----
***************
*** 1068,1075 ****
  	     (setq nntp-status-string "NNTP server is not specified."))
  	    (t				; We couldn't open the server.
  	     (setq nntp-status-string 
! 		   (buffer-substring (point-min) (point-max)))
! 	     (setq nntp-timeout-servers (cons server nntp-timeout-servers))))
        (and timer (cancel-timer timer))
        (message "")
        (or status
--- 1062,1068 ----
  	     (setq nntp-status-string "NNTP server is not specified."))
  	    (t				; We couldn't open the server.
  	     (setq nntp-status-string 
! 		   (buffer-substring (point-min) (point-max)))))
        (and timer (cancel-timer timer))
        (message "")
        (or status
*** pub/sgnus/lisp/x-easymenu.el	Sat Sep 30 06:05:57 1995
--- sgnus/lisp/x-easymenu.el	Wed Oct  4 12:27:55 1995
***************
*** 175,354 ****
  (provide 'easymenu)
  
  ;;; easymenu.el ends here
- ;;; easymenu.el - Easy menu support for Emacs 19 and XEmacs.
- ;; 
- ;; $Id: easymenu.el,v 5.9 1995/02/14 19:44:00 amanda Exp $
- ;;
- ;; LCD Archive Entry:
- ;; easymenu|Per Abrahamsen|abraham@iesd.auc.dk|
- ;; Easy menu support for XEmacs|
- ;; $Date: 1995/02/14 19:44:00 $|$Revision: 5.9 $|~/misc/easymenu.el.gz|
- 
- ;; Copyright (C) 1992, 1993, 1994, 1995 Free Software Foundation, Inc.
- ;;
- ;; This program is free software; you can redistribute it and/or modify
- ;; it under the terms of the GNU General Public License as published by
- ;; the Free Software Foundation; either version 2, or (at your option)
- ;; any later version.
- ;; 
- ;; This program is distributed in the hope that it will be useful,
- ;; but WITHOUT ANY WARRANTY; without even the implied warranty of
- ;; MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
- ;; GNU General Public License for more details.
- ;; 
- ;; You should have received a copy of the GNU General Public License
- ;; along with this program; if not, write to the Free Software
- ;; Foundation, Inc., 675 Mass Ave, Cambridge, MA 02139, USA.
- 
- ;; Commentary:
- ;;
- ;; Easymenu allows you to define menus for both Emacs 19 and XEmacs.
- ;;
- ;; This file 
- ;; The advantages of using easymenu are:
- ;;
- ;; - Easier to use than either the Emacs 19 and XEmacs menu syntax.
- ;;
- ;; - Common interface for Emacs 18, Emacs 19, and XEmacs.  
- ;;   (The code does nothing when run under Emacs 18).
- ;;
- ;; The public functions are:
- ;; 
- ;; - Function: easy-menu-define SYMBOL MAPS DOC MENU
- ;;     SYMBOL is both the name of the variable that holds the menu and
- ;;            the name of a function that will present a the menu.
- ;;     MAPS is a list of keymaps where the menu should appear in the menubar.
- ;;     DOC is the documentation string for the variable.
- ;;     MENU is an XEmacs style menu description.  
- ;;
- ;;     See the documentation for easy-menu-define for details.
- ;;
- ;; - Function: easy-menu-change PATH NAME ITEMS
- ;;     Change an existing menu.
- ;;     The menu must already exist an be visible on the menu bar.
- ;;     PATH is a list of strings used for locating the menu on the menu bar. 
- ;;     NAME is the name of the menu.  
- ;;     ITEMS is a list of menu items, as defined in `easy-menu-define'.
- ;;
- ;; - Function: easy-menu-add MENU [ MAP ]
- ;;     Add MENU to the current menubar in MAP.
- ;;
- ;; - Function: easy-menu-remove MENU
- ;;     Remove MENU from the current menubar.
- ;;
- ;; Emacs 19 never uses `easy-menu-add' or `easy-menu-remove', menus
- ;; automatically appear and disappear when the keymaps specified by
- ;; the MAPS argument to `easy-menu-define' are activated.
- ;;
- ;; XEmacs will bind the map to button3 in each MAPS, but you must
- ;; explicitly call `easy-menu-add' and `easy-menu-remove' to add and
- ;; remove menus from the menu bar.
- 
- ;;; Code:
- 
- ;;;###autoload
- (defmacro easy-menu-define (symbol maps doc menu)
-   "Define a menu bar submenu in maps MAPS, according to MENU.
- The arguments SYMBOL and DOC are ignored; they are present for
- compatibility only.  SYMBOL is not evaluated.  In other Emacs versions
- these arguments may be used as a variable to hold the menu data, and a
- doc string for that variable.
- 
- The first element of MENU must be a string.  It is the menu bar item name.
- The rest of the elements are menu items.
- 
- A menu item is usually a vector of three elements:  [NAME CALLBACK ENABLE]
- 
- NAME is a string--the menu item name.
- 
- CALLBACK is a command to run when the item is chosen,
- or a list to evaluate when the item is chosen.
- 
- ENABLE is an expression; the item is enabled for selection
- whenever this expression's value is non-nil.
- 
- Alternatively, a menu item may have the form: 
- 
-    [ NAME CALLBACK [ KEYWORD ARG ] ... ]
- 
- Where KEYWORD is one of the symbol defined below.
- 
-    :keys KEYS
- 
- KEYS is a string; a complex keyboard equivalent to this menu item.
- 
-    :active ENABLE
- 
- ENABLE is an expression; the item is enabled for selection
- whenever this expression's value is non-nil.
- 
-    :suffix NAME
- 
- NAME is a string; the name of an argument to CALLBACK.
- 
-    :style STYLE
-    
- STYLE is a symbol describing the type of menu item.  The following are
- defined:  
- 
- toggle: A checkbox.  
-         Currently just prepend the name with the string \"Toggle \".
- radio: A radio button. 
- nil: An ordinary menu item.
- 
-    :selected SELECTED
- 
- SELECTED is an expression; the checkbox or radio button is selected
- whenever this expression's value is non-nil.
- Currently just disable radio buttons, no effect on checkboxes.
- 
- A menu item can be a string.  Then that string appears in the menu as
- unselectable text.  A string consisting solely of hyphens is displayed
- as a solid horizontal line.
- 
- A menu item can be a list.  It is treated as a submenu.
- The first element should be the submenu name.  That's used as the
- menu item in the top-level menu.  The cdr of the submenu list
- is a list of menu items, as above."
-   (` (progn
-        (defvar (, symbol) nil (, doc))
-        (easy-menu-do-define (quote (, symbol)) (, maps) (, doc) (, menu)))))
- 
- (defun easy-menu-do-define (symbol maps doc menu)
-   (set symbol menu)
-   (fset symbol (list 'lambda '(e)
- 		     doc
- 		     '(interactive "@e")
- 		     '(run-hooks 'activate-menubar-hook)
- 		     '(setq zmacs-region-stays 't)
- 		     (list 'popup-menu symbol)))
-   (mapcar (function (lambda (map) (define-key map 'button3 symbol)))
- 	  (if (keymapp maps) (list maps) maps)))
- 
- (fset 'easy-menu-change (symbol-function 'add-menu))
- 
- (defun easy-menu-add (menu &optional map)
-   "Add MENU to the current menu bar."
-   (cond ((null current-menubar)
- 	 ;; Don't add it to a non-existing menubar.
- 	 nil)
- 	((assoc (car menu) current-menubar)
- 	 ;; Already present.
- 	 nil)
- 	((equal current-menubar '(nil))
- 	 ;; Set at left if only contains right marker.
- 	 (set-buffer-menubar (list menu nil)))
- 	(t
- 	 ;; Add at right.
- 	 (set-buffer-menubar (copy-sequence current-menubar))
- 	 (add-menu nil (car menu) (cdr menu)))))
- 
- (defun easy-menu-remove (menu)
-   "Remove MENU from the current menu bar."
-   (and current-menubar
-        (assoc (car menu) current-menubar)
-        (delete-menu-item (list (car menu)))))
- 
- (provide 'easymenu)
- 
- ;;; easymenu.el ends here
--- 175,177 ----
*** pub/sgnus/lisp/ChangeLog	Sat Sep 30 06:06:01 1995
--- sgnus/lisp/ChangeLog	Wed Oct  4 12:38:22 1995
***************
*** 1,9 ****
--- 1,95 ----
+ Wed Oct  4 12:28:04 1995  Lars Magne Ingebrigtsen  <larsi@menja.ifi.uio.no>
+ 
+ 	* x-easymenu.el: Included twice.
+ 
+ Mon Oct  2 08:23:30 1995  Lars Ingebrigtsen  <lars@eyesore.no>
+ 
+ 	* gnus-soup.el (gnus-soup-write-prefixes): New function.
+ 
+ 	* gnus.el (gnus-group-make-directory-group): Create better group
+ 	names. 
+ 	(gnus-summary-toggle-header): More correct implementation.
+ 
+ 	* nneething.el (nneething-map-file): Would bug out if the map dir
+ 	exists. 
+ 
+ 	* gnus.el (gnus-saved-headers): New variable.
+ 
+ 	* gnus-msg.el (gnus-news-followup): Do X-Mail-Copy handling.
+ 
+ 	* gnus-topic.el (gnus-topic-insert-topic): Use `topic' local
+ 	params. 
+ 
+ 	* gnus.el (gnus-group-update-group): New implementation.
+ 
+ 	* gnus-msg.el (gnus-mailing-list-groups): New variable.
+ 
+ 	* gnus.el (gnus-open-server): Deny or allow opening based on
+ 	previous successes.
+ 	(gnus-server-open-server): New command and keystroke.
+ 	(gnus-server-close-server): Ditto.
+ 	(gnus-server-deny-server): Ditto.
+ 	(gnus-backlog-enter-article): New function.
+ 	(gnus-backlog-remove-oldest-article): New function.
+ 	(gnus-backlog-request-article): New function.
+ 	(gnus-request-article-this-buffer): Use the backlog.
+ 	(gnus-keep-backlog): New variable.
+ 
+ 	* nntp.el: Removed all `nntp-timeout-servers' code. 
+ 
+ Sun Oct  1 11:40:58 1995  Lars Ingebrigtsen  <lars@eyesore.no>
+ 
+ 	* gnus.el (gnus-score-find-bnews): Would sometimes add the local
+ 	score file twice.
+ 
+ Thu Sep 28 21:10:44 1995  Per Abrahamsen  <abraham@dina.kvl.dk>
+ 
+ 	* gnus.el (gnus-article-treat-overstrike): Fixed range error for
+ 	the letter backspace underscore case. 
+ 
+ Wed Sep 27 17:28:31 1995  Per Abrahamsen  <abraham@dina.kvl.dk>
+ 
+ 	* gnus-msg.el (gnus-inews-insert-mime-headers): Allow it to be
+ 	called in the compose buffer.
+ 
+ Sun Oct  1 10:26:26 1995  Lars Ingebrigtsen  <lars@eyesore.no>
+ 
+ 	* gnus.el (gnus-summary-copy-article): Would bug out on
+ 	respooling. 
+ 
+ 	* nndir.el (nndir-request-expire-articles): Couldn't expire
+ 	articles. 
+ 
+ 	* gnus.el (gnus-group-make-group): Returned nil.
+ 
+ 	* gnus-msg.el (gnus-post-news): Couldn't post from the group
+ 	buffer. 
+ 
+ Wed Sep 27 14:53:36 1995  Per Abrahamsen  <abraham@dina.kvl.dk>
+ 
+ 	* gnus-edit.el (gnus-score-custom-get): Setting adapt to an atom
+ 	didn't work.  Reported by kchrist@lochness.ncrmicro.ncr.com (Kevin
+ 	Christian). 
+ 
+ Sun Oct  1 09:34:18 1995  Lars Ingebrigtsen  <lars@eyesore.no>
+ 
+ 	* gnus-msg.el (gnus-message-of): New function.
+ 
+ 	* gnus.el (gnus-get-newsgroup-headers): Don't set references to
+ 	"none". 
+ 	(gnus-summary-prepare-threads): Would output the subject several
+ 	times when dummying.
+ 	(gnus-get-newsgroup-headers): Would never find the first header in
+ 	each head.
+ 
  Sat Sep 30 05:05:57 1995  Lars Magne Ingebrigtsen  <larsi@hymir.ifi.uio.no>
  
  	* gnus-msg.el (gnus-news-followup): Insert signature before
  	composing. 
  
  Fri Sep 29 05:33:01 1995  Lars Magne Ingebrigtsen  <larsi@hymir.ifi.uio.no>
+ 
+ 	* gnus.el: 0.5 is released.
  
  	* gnus.el (gnus-article-mode-map): Took out boogaboo.
  
*** pub/sgnus/texi/gnus.texi	Sat Sep 30 06:06:03 1995
--- sgnus/texi/gnus.texi	Wed Oct  4 16:10:30 1995
***************
*** 74,80 ****
  @top The Gnus Newsreader
  
  You can read news (and mail) from within Emacs by using Gnus.  The news
! can be gotten by any nefarious means you can think of - @sc{nntp}, local
  spool or your mbox file.  All at the same time, if you want to push your
  luck.
  
--- 74,80 ----
  @top The Gnus Newsreader
  
  You can read news (and mail) from within Emacs by using Gnus.  The news
! can be gotten by any nefarious means you can think of---@sc{nntp}, local
  spool or your mbox file.  All at the same time, if you want to push your
  luck.
  
***************
*** 119,125 ****
  In any case, after spending all that energy with coming up with a new
  and spiffy name, we decided that the name was @emph{too} spiffy, so we
  renamamed it back again to "Gnus".  But in mixed case.  "Gnus" vs.
! @sc{gnus}.  New vs. old.
  
  Incidentally, the next Gnus generation will be called "September Gnus",
  and won't be released until February.  Confused?  You will be.
--- 119,125 ----
  In any case, after spending all that energy with coming up with a new
  and spiffy name, we decided that the name was @emph{too} spiffy, so we
  renamamed it back again to "Gnus".  But in mixed case.  "Gnus" vs.
! "@sc{gnus}".  New vs. old.
  
  Incidentally, the next Gnus generation will be called "September Gnus",
  and won't be released until February.  Confused?  You will be.
***************
*** 227,246 ****
  @section Conformity
  
  No rebels without a clue here, ma'am.  We conform to all standards known
! to man.  Except, of course, where we disagree with the standards and/or
! conventions.
  
  @table @strong
  
  @item RFC 822
! There are no known breaches to this standard.
  
  @item RFC 1036
! There are no known breaches to this standard, either.
  
  @item Usenet Seal of Approval
  Gnus hasn't been formally through the Seal process, but I have read
! through the Seal text, and I think that Gnus would pass.
  
  @item Son-of-RFC 1036
  We do have some breaches to this one.
--- 227,246 ----
  @section Conformity
  
  No rebels without a clue here, ma'am.  We conform to all standards known
! to (wo)man.  Except for those standards and/or conventions we disagree
! with, of course.
  
  @table @strong
  
  @item RFC 822
! There are no known breaches of this standard.
  
  @item RFC 1036
! There are no known breaches of this standard, either.
  
  @item Usenet Seal of Approval
  Gnus hasn't been formally through the Seal process, but I have read
! through the Seal text and I think Gnus would pass.
  
  @item Son-of-RFC 1036
  We do have some breaches to this one.
***************
*** 256,267 ****
  those for posting articles.  I would not have known that if it wasn't
  for the @code{X-Newsreader} header.
  @item References
! Gnus does line breaking on this header.  I infer from RFC1036 that being
! conservative in what you output is not creating 5000-character lines, so
! it seems like a good idea to me.  However, this standard-to-be says that
! whitespace in the @code{References} header is to be preserved, so...  It
! doesn't matter one way or the other to Gnus, so if somebody tells me
! what The Way is, I'll change it.  Or not.
  @end table
  
  @end table
--- 256,267 ----
  those for posting articles.  I would not have known that if it wasn't
  for the @code{X-Newsreader} header.
  @item References
! Gnus breaks lines if this header is long.  I infer from RFC1036 that
! being conservative in what you output is not creating 5000-character
! lines, so it seems like a good idea to me.  However, this standard-to-be
! says that whitespace in the @code{References} header is to be preserved,
! so...  It doesn't matter one way or the other to Gnus, so if somebody
! tells me what The Way is, I'll change it.  Or not.
  @end table
  
  @end table
***************
*** 305,315 ****
  XEmacs. 
  
  @item 
! The same with current-article marking -- XEmacs puts an underline under
! the entire article while Emacs and Mule are nicer and kinder.
  
  @item
! XEmacs features more graphics -- a logo and a toolbar.
  
  @item
  Citation highlighting us better under Emacs and Mule than under XEmacs.
--- 305,315 ----
  XEmacs. 
  
  @item 
! The same with current-article marking---XEmacs puts an underline under
! the entire summary line while Emacs and Mule are nicer and kinder.
  
  @item
! XEmacs features more graphics---a logo and a toolbar.
  
  @item
  Citation highlighting us better under Emacs and Mule than under XEmacs.
***************
*** 332,339 ****
  endurance, what with my "oh, that's a neat idea <type type>, yup, I'll
  release it right away <ship off> no wait, that doesn't work at all <type
  type>, yup, I'll ship that one off right away <ship off> no, wait, that
! absolutely does not work" policy for releases.  Microsoft - bah.  I'm
! @emph{much} worse.
  
  I would like to take this opportunity to thank the Academy for...  oops,
  wrong show.
--- 332,340 ----
  endurance, what with my "oh, that's a neat idea <type type>, yup, I'll
  release it right away <ship off> no wait, that doesn't work at all <type
  type>, yup, I'll ship that one off right away <ship off> no, wait, that
! absolutely does not work" policy for releases.  Micro$oft---bah.
! Amateurs.  I'm @emph{much} worse.  (Or is that "worser"? "much worser"?
! "worsest"?)
  
  I would like to take this opportunity to thank the Academy for...  oops,
  wrong show.
***************
*** 354,370 ****
  @item
  I stole some pieces from the XGnus distribution by Felix Lee and JWZ.
  @item 
! nnfolder has been much enhanced by Scott Byer.
  @item
  The orphan scoring was written by Peter Mutsaers.
  @item 
  GNU XEmacs support has been added by Fabrice Popineau. 
  @item 
! Various bits and pieces, especially dealing with .newsrc files, was
  suggested and added by Hallvard B Furuseth.
  @item 
! Brian Edmonds has written @code{gnus-bbdb}, as well as other bits and
! pieces. 
  @item 
  Ricardo Nassif did the proof-reading.
  @item
--- 355,370 ----
  @item
  I stole some pieces from the XGnus distribution by Felix Lee and JWZ.
  @item 
! @code{nnfolder} has been much enhanced by Scott Byer.
  @item
  The orphan scoring was written by Peter Mutsaers.
  @item 
  GNU XEmacs support has been added by Fabrice Popineau. 
  @item 
! Various bits and pieces, especially dealing with .newsrc files, were
  suggested and added by Hallvard B Furuseth.
  @item 
! Brian Edmonds has written @code{gnus-bbdb}.
  @item 
  Ricardo Nassif did the proof-reading.
  @item
***************
*** 396,406 ****
  @item 
  You can read a number of different mail formats (@pxref{Reading Mail}).
  All the mail backends implement a convenient mail expiry scheme
! (@code{Expiring Old Mail Articles}). 
  
  @item
  Gnus can use various strategies for gathering threads that have lost
! their roots (thereby gathering loose sub-threads in one thread) or it
  can go back and retrieve enough headers to build a complete thread
  (@pxref{Customizing Threading}).
  
--- 396,406 ----
  @item 
  You can read a number of different mail formats (@pxref{Reading Mail}).
  All the mail backends implement a convenient mail expiry scheme
! (@pxref{Expiring Old Mail Articles}). 
  
  @item
  Gnus can use various strategies for gathering threads that have lost
! their roots (thereby gathering loose sub-threads into one thread) or it
  can go back and retrieve enough headers to build a complete thread
  (@pxref{Customizing Threading}).
  
***************
*** 409,415 ****
  them as well.
  
  @item 
! Gnus can do partial group updates - you do not have to retrieve the
  entire active file just to check for new articles in a few groups
  (@pxref{The Active File}).
  
--- 409,415 ----
  them as well.
  
  @item 
! Gnus can do partial group updates---you do not have to retrieve the
  entire active file just to check for new articles in a few groups
  (@pxref{The Active File}).
  
***************
*** 419,426 ****
  
  @item 
  You can score articles according to any number of criteria
! (@pxref{Scoring}).  You can even get Gnus to score articles for you
! (@pxref{Adaptive Scoring}).
  
  @item 
  Gnus maintains a dribble buffer that is auto-saved the normal Emacs
--- 419,426 ----
  
  @item 
  You can score articles according to any number of criteria
! (@pxref{Scoring}).  You can even get Gnus to find out how to score
! articles for you (@pxref{Adaptive Scoring}).
  
  @item 
  Gnus maintains a dribble buffer that is auto-saved the normal Emacs
***************
*** 467,474 ****
  glitches (@pxref{Finding the Parent}). 
  
  @item
! Gnus can fetch FAQs to and descriptions of groups (@pxref{Group
! Information}). 
  
  @item
  Digests (and other files) can be used as the basis for groups
--- 467,473 ----
  glitches (@pxref{Finding the Parent}). 
  
  @item
! Gnus can fetch FAQs and group descriptions (@pxref{Group Information}).
  
  @item
  Digests (and other files) can be used as the basis for groups
***************
*** 478,483 ****
--- 477,486 ----
  Articles can be highlighted and customized (@pxref{Customizing
  Articles}). 
  
+ @item 
+ URLs and other external references can be buttonized (@pxref{Article
+ Buttons}). 
+ 
  @item
  All Gnus buffers can be customized in a difficult fashion
  (@pxref{Windows Configuration}). 
***************
*** 505,515 ****
  
  @itemize @bullet
  @item
! Native @sc{mime} support is something that should be done.  I was hoping
! I could steal code from @code{Mew}, the @sc{mime} mail reader for Emacs,
! but I'm not quite sure what the status of that project is.  Gnus might
! support @sc{mime} quite soon, and it might not.
! 
  @item
  @code{trn}-like trees.
  @item
--- 508,514 ----
  
  @itemize @bullet
  @item
! Native @sc{mime} support is something that should be done.  
  @item
  @code{trn}-like trees.
  @item
***************
*** 518,529 ****
  NoCeM support.
  @item 
  Frame configuration.
- @item
- Re-sending bounced mail and rejected articles.
  @item 
  Floating point group levels and group bubbling.
- @item
- @file{/etc/nntpserver} usage.
  @item 
  Automatic re-scan of incoming mail.
  @item
--- 517,524 ----
***************
*** 537,550 ****
  @item
  Gather thread by filling in missing Message-IDs.
  @item 
- Slave Gnusii to enable several Gnusii to run at once.
- @item 
  PGP support.
  @item
  Allow posting through mail-to-news gateways.
  @item
- Allow renaming mail groups in a simple fashion.
- @item
  Speed up massive group massacres.
  @item
  @code{jka-compr} isn't fully supported.
--- 532,541 ----
***************
*** 559,574 ****
  @item
  Really do unbinhexing.
  @item
- Fetching by Message-ID should work in mail groups.
- @item
  Listing of all active groups.
  @item
  XEmacs toolbar.
  @item
  Do the X-Receipt-To thing.
  @item
- Hierarchal group buffers.
- @item
  Don't kill summary buffers upon exit from the groups.
  @item
  Allow adaption on secondary marks.
--- 550,561 ----
***************
*** 577,584 ****
  And much, much, much more.  There is more to come than has already been
  implemented.  (But that's always true, isn't it?)
  
! You can probably sneak a look at the actual up-to-the-second todo list
! by snooping @code{<URL:http://www.ifi.uio.no/~larsi/sgnus/todo>}. 
  
  @node Terminology
  @chapter Terminology
--- 564,572 ----
  And much, much, much more.  There is more to come than has already been
  implemented.  (But that's always true, isn't it?)
  
! @code{<URL:http://www.ifi.uio.no/~larsi/sgnus/todo>} is where the actual
! up-to-the-second todo list is located, so if you're really curious, you
! could point your Web browser over that-a-way.
  
  @node Terminology
  @chapter Terminology
***************
*** 587,593 ****
  @table @dfn
  @item news
  @cindex news
! This is what you are supposed to use this thing for - reading news.
  News is generally fetched from a nearby @sc{nntp} server, and is
  generally publicly available to everybody.  If you post news, the entire
  world is likely to read just what you have written, and they'll all
--- 575,581 ----
  @table @dfn
  @item news
  @cindex news
! This is what you are supposed to use this thing for---reading news.
  News is generally fetched from a nearby @sc{nntp} server, and is
  generally publicly available to everybody.  If you post news, the entire
  world is likely to read just what you have written, and they'll all
***************
*** 605,611 ****
  are reading.
  @item backend
  Gnus gets fed articles from a number of backends, both news and mail
! backends.  Gnus does not handle the underlying media, so to speak - this
  is all done by the backends.
  @item native
  Gnus will always use one method (and backend) as the @dfn{native}, or
--- 593,599 ----
  are reading.
  @item backend
  Gnus gets fed articles from a number of backends, both news and mail
! backends.  Gnus does not handle the underlying media, so to speak---this
  is all done by the backends.
  @item native
  Gnus will always use one method (and backend) as the @dfn{native}, or
***************
*** 667,673 ****
  
  @kindex M-x gnus
  If your system administrator has set things up properly, starting Gnus
! and reading news is extremely easy - you just type @kbd{M-x gnus}.
  
  If things do not go smoothly at startup, you have to twiddle some
  variables. 
--- 655,661 ----
  
  @kindex M-x gnus
  If your system administrator has set things up properly, starting Gnus
! and reading news is extremely easy---you just type @kbd{M-x gnus}.
  
  If things do not go smoothly at startup, you have to twiddle some
  variables. 
***************
*** 679,685 ****
  * Slave Gnusii::        You can have more than one Gnus active at a time.
  * Fetching a Group::    Starting Gnus just to read a group.
  * New Groups::          What is Gnus supposed to do with new groups?
! * Startup Files::       Those pesky startup files - @file{.newsrc}.
  * Auto Save::           Recovering from a crash.
  * The Active File::     Reading the active file over a slow line Takes Time.
  * Startup Variables::   Other variables you might change.
--- 667,673 ----
  * Slave Gnusii::        You can have more than one Gnus active at a time.
  * Fetching a Group::    Starting Gnus just to read a group.
  * New Groups::          What is Gnus supposed to do with new groups?
! * Startup Files::       Those pesky startup files---@file{.newsrc}.
  * Auto Save::           Recovering from a crash.
  * The Active File::     Reading the active file over a slow line Takes Time.
  * Startup Variables::   Other variables you might change.
***************
*** 713,719 ****
  
  @vindex gnus-nntpserver-file
  @cindex NNTPSERVER
! @cindex nntp server
  If this variable is not set, Gnus will take a look at the
  @code{NNTPSERVER} environment variable.  If that variable isn't set,
  Gnus will see whether @code{gnus-nntpserver-file} (default
--- 701,707 ----
  
  @vindex gnus-nntpserver-file
  @cindex NNTPSERVER
! @cindex @sc{nntp} server
  If this variable is not set, Gnus will take a look at the
  @code{NNTPSERVER} environment variable.  If that variable isn't set,
  Gnus will see whether @code{gnus-nntpserver-file} (default
***************
*** 817,841 ****
  are using the two different Gnusii to read from two different servers),
  that is no problem whatsoever.  You just do it.
  
! The problem appears when you want to run two Gnusii that uses the same
! @code{.newsrc} file.  
  
  To work around that problem some, we here at the Think-Tank at the Gnus
! Towers have come up with a new concept: @dfn{Master} and @dfn{servants}.
! (We have applied for a patent on this concept, and have taken out a
! copyright on those words.  If you wish to use those words in conjunction
! with each other, you have to send ¢1 per usage to me.  Usage of the
! patent (@dfn{Master/Slave Relationships In Computer Applications}) will
! be much more expensive, of course.)
  
  Anyways, you start one Gnus up the normal way with @kbd{M-x gnus} (or
  however you do it).  Each subsequent slave Gnusii should be started with
  @kbd{M-x gnus-slave}.  These slaves won't save normal @file{.newsrc}
! files, but some slave files that contains only information on what
  groups have been read in the slave session.  When a master Gnus starts,
  it will read (and delete) these slave files, incorporating all
  information from all of them.  (The slave files will be read in the
! sequence they were created, so the latest changes will have presedence.)
  
  Information from the slave files has, of course, presedence over the
  information in the normal (i. e., master) @code{.newsrc} file.
--- 805,829 ----
  are using the two different Gnusii to read from two different servers),
  that is no problem whatsoever.  You just do it.
  
! The problem appears when you want to run two Gnusii that use the same
! @code{.newsrc} file.
  
  To work around that problem some, we here at the Think-Tank at the Gnus
! Towers have come up with a new concept: @dfn{Masters} and
! @dfn{servants}.  (We have applied for a patent on this concept, and have
! taken out a copyright on those words.  If you wish to use those words in
! conjunction with each other, you have to send $1 per usage instance to
! me.  Usage of the patent (@dfn{Master/Slave Relationships In Computer
! Applications}) will be much more expensive, of course.)
  
  Anyways, you start one Gnus up the normal way with @kbd{M-x gnus} (or
  however you do it).  Each subsequent slave Gnusii should be started with
  @kbd{M-x gnus-slave}.  These slaves won't save normal @file{.newsrc}
! files, but some slave files that contains information only on what
  groups have been read in the slave session.  When a master Gnus starts,
  it will read (and delete) these slave files, incorporating all
  information from all of them.  (The slave files will be read in the
! sequence they were created, so the latest changes will have precedence.)
  
  Information from the slave files has, of course, presedence over the
  information in the normal (i. e., master) @code{.newsrc} file.
***************
*** 1088,1094 ****
  @item gnus-load-hook
  @vindex gnus-load-hook
  A hook that is run while Gnus is being loaded.  Note that this hook will
! normally be run just once in a single Emacs session, no matter how many
  times you start Gnus.
  
  @item gnus-startup-hook
--- 1076,1082 ----
  @item gnus-load-hook
  @vindex gnus-load-hook
  A hook that is run while Gnus is being loaded.  Note that this hook will
! normally be run just once in each Emacs session, no matter how many
  times you start Gnus.
  
  @item gnus-startup-hook
***************
*** 1127,1133 ****
  * Group Buffer Format::    Information listed and how you can change it.
  * Group Maneuvering::      Commands for moving in the group buffer.
  * Selecting a Group::      Actually reading news.
! * Group Subscribing::      Unsubscribing, killing, subscribing.
  * Group Levels::           Levels? What are those, then?
  * Marking Groups::         You can mark groups for later processing.
  * Foreign Groups::         How to create foreign groups.
--- 1115,1121 ----
  * Group Buffer Format::    Information listed and how you can change it.
  * Group Maneuvering::      Commands for moving in the group buffer.
  * Selecting a Group::      Actually reading news.
! * Subscription Commands::  Unsubscribing, killing, subscribing.
  * Group Levels::           Levels? What are those, then?
  * Marking Groups::         You can mark groups for later processing.
  * Foreign Groups::         How to create foreign groups.
***************
*** 1176,1182 ****
  @samp{"%M%S%5y: %(%g%)\n"}.
  
  There should always be a colon on the line; the cursor always moves to
! the colon after performing an operation.  Nothing else is required - not
  even the group name.  All displayed text is just window dressing, and is
  never examined by Gnus.  Gnus stores all real information it needs using
  text properties.
--- 1164,1170 ----
  @samp{"%M%S%5y: %(%g%)\n"}.
  
  There should always be a colon on the line; the cursor always moves to
! the colon after performing an operation.  Nothing else is required---not
  even the group name.  All displayed text is just window dressing, and is
  never examined by Gnus.  Gnus stores all real information it needs using
  text properties.
***************
*** 1236,1242 ****
  
  @cindex *
  All the "number-of" specs will be filled with an asterisk (@samp{*}) if
! no info is available - for instance, if it is a non-activated foreign
  group, or a bogus (or semi-bogus) native group.
  
  @vindex gnus-group-mode-line-format
--- 1224,1230 ----
  
  @cindex *
  All the "number-of" specs will be filled with an asterisk (@samp{*}) if
! no info is available---for instance, if it is a non-activated foreign
  group, or a bogus (or semi-bogus) native group.
  
  @vindex gnus-group-mode-line-format
***************
*** 1340,1346 ****
  @findex gnus-group-select-group
  Select the current group and switch to the summary buffer
  (@code{gnus-group-select-group}).  Takes the same arguments as
! @code{gnus-group-read-group} - the only difference is that this command
  does not display the first unread article automatically upon group
  entry. 
  
--- 1328,1334 ----
  @findex gnus-group-select-group
  Select the current group and switch to the summary buffer
  (@code{gnus-group-select-group}).  Takes the same arguments as
! @code{gnus-group-read-group}---the only difference is that this command
  does not display the first unread article automatically upon group
  entry. 
  
***************
*** 1418,1425 ****
  functions might be @code{max}, @code{min}, or squared means, or whatever
  tickles you fancy.
  
! @node Group Subscribing
! @section Group Subscribing
  @cindex subscribing
  
  @table @kbd
--- 1406,1413 ----
  functions might be @code{max}, @code{min}, or squared means, or whatever
  tickles you fancy.
  
! @node Subscription Commands
! @section Subscription Commands
  @cindex subscribing
  
  @table @kbd
***************
*** 1462,1467 ****
--- 1450,1457 ----
  Kill all zombie groups (@code{gnus-group-kill-all-zombies}).
  @end table
  
+ Also @xref{Group Levels}.
+ 
  @node Group Levels
  @section Group Levels
  @cindex group level
***************
*** 1533,1567 ****
  @section Marking Groups
  @cindex marking groups
  
! If you want to perform some action on several groups, and they appear
  subsequently in the group buffer, you would normally just give a
  numerical prefix to the command.  Most group commands will then do your
  bidding on those groups.
  
  However, if the groups are not in sequential order, you can still
! perform an action on several groups.  You simply mark the groups first,
! and then execute the command.  
  
  @table @kbd
  @item #
  @kindex # (Group)
! @item M m
  @kindex M m (Group)
  @findex gnus-group-mark-group
  Set the mark on the current group (@code{gnus-group-mark-group}). 
  @item M-#
  @kindex M-# (Group)
! @item < u
  @kindex M u (Group)
  @findex gnus-group-unmark-group
  Remove the mark from the current group
  (@code{gnus-group-unmark-group}). 
  @item M w
  @kindex M w (Group)
  @findex gnus-group-mark-region
  Mark all groups between point and mark (@code{gnus-group-mark-region}). 
  @end table
  
  @node Foreign Groups
  @section Foreign Groups
  @cindex foreign groups
--- 1523,1563 ----
  @section Marking Groups
  @cindex marking groups
  
! If you want to perform some command on several groups, and they appear
  subsequently in the group buffer, you would normally just give a
  numerical prefix to the command.  Most group commands will then do your
  bidding on those groups.
  
  However, if the groups are not in sequential order, you can still
! perform a command on several groups.  You simply mark the groups first
! with the process mark and then execute the command.
  
  @table @kbd
+ 
  @item #
  @kindex # (Group)
! @itemx M m
  @kindex M m (Group)
  @findex gnus-group-mark-group
  Set the mark on the current group (@code{gnus-group-mark-group}). 
+ 
  @item M-#
  @kindex M-# (Group)
! @itemx < u
  @kindex M u (Group)
  @findex gnus-group-unmark-group
  Remove the mark from the current group
  (@code{gnus-group-unmark-group}). 
+ 
  @item M w
  @kindex M w (Group)
  @findex gnus-group-mark-region
  Mark all groups between point and mark (@code{gnus-group-mark-region}). 
  @end table
  
+ Also @xref{Process/Prefix}.
+ 
+ 
  @node Foreign Groups
  @section Foreign Groups
  @cindex foreign groups
***************
*** 1578,1584 ****
  name}.  There may be additional elements in the select method, where the
  value may have special meaning for the backend in question.
  
! One could say that a select method defines a @dfn{virtual server} - so
  we do just that (@pxref{The Server Buffer}).
  
  The @dfn{name} of the group is the name the backend will recognize the
--- 1574,1580 ----
  name}.  There may be additional elements in the select method, where the
  value may have special meaning for the backend in question.
  
! One could say that a select method defines a @dfn{virtual server}---so
  we do just that (@pxref{The Server Buffer}).
  
  The @dfn{name} of the group is the name the backend will recognize the
***************
*** 1588,1594 ****
  @samp{some.where.edu} will have the name @samp{soc.motss} and select
  method @code{(nntp "some.where.edu")}.  Gnus will call this group, in
  all circumstances, @samp{nntp+some.where.edu:soc.motss}, even though the
! nntp backend just knows this group as @samp{soc.motss}.
  
  Here are some commands for making and editing general foreign groups,
  and some commands to ease the creation of some special-purpose groups:
--- 1584,1590 ----
  @samp{some.where.edu} will have the name @samp{soc.motss} and select
  method @code{(nntp "some.where.edu")}.  Gnus will call this group, in
  all circumstances, @samp{nntp+some.where.edu:soc.motss}, even though the
! @code{nntp} backend just knows this group as @samp{soc.motss}.
  
  Here are some commands for making and editing general foreign groups,
  and some commands to ease the creation of some special-purpose groups:
***************
*** 1674,1680 ****
  @findex gnus-group-delete-group
  This function will delete the current group
  (@code{gnus-group-delete-group}).  If given a prefix, this function will
! actuallt delete all the articles in the group, and forcibly remove the
  group itself from the face of the Earth.  Use a prefix only if you are
  sure of what you are doing.  
  
--- 1670,1676 ----
  @findex gnus-group-delete-group
  This function will delete the current group
  (@code{gnus-group-delete-group}).  If given a prefix, this function will
! actually delete all the articles in the group, and forcibly remove the
  group itself from the face of the Earth.  Use a prefix only if you are
  sure of what you are doing.  
  
***************
*** 1855,1861 ****
  
  @node nnspool
  @subsection nnspool
! @cindex nnspool
  @cindex news spool
  
  Subscribing to a foreign group from the local spool is extremely easy,
--- 1851,1857 ----
  
  @node nnspool
  @subsection nnspool
! @cindex @code{nnspool}
  @cindex news spool
  
  Subscribing to a foreign group from the local spool is extremely easy,
***************
*** 1879,1890 ****
  
  @item nnspool-spool-directory
  @vindex nnspool-spool-directory
! Where nnspool looks for the articles.  This is normally
  @file{/usr/spool/news/}.
  
  @item nnspool-nov-directory 
  @vindex nnspool-nov-directory 
! Where nnspool will look for @sc{nov} files.  This is normally
  @file{/usr/spool/news/over.view/}.
  
  @item nnspool-lib-dir
--- 1875,1886 ----
  
  @item nnspool-spool-directory
  @vindex nnspool-spool-directory
! Where @code{nnspool} looks for the articles.  This is normally
  @file{/usr/spool/news/}.
  
  @item nnspool-nov-directory 
  @vindex nnspool-nov-directory 
! Where @code{nnspool} will look for @sc{nov} files.  This is normally
  @file{/usr/spool/news/over.view/}.
  
  @item nnspool-lib-dir
***************
*** 1922,1928 ****
  
  @node nnvirtual
  @subsection nnvirtual
! @cindex nnvirtual
  @cindex virtual groups
  
  An @dfn{nnvirtual group} is really nothing more than a collection of
--- 1918,1924 ----
  
  @node nnvirtual
  @subsection nnvirtual
! @cindex @code{nnvirtual}
  @cindex virtual groups
  
  An @dfn{nnvirtual group} is really nothing more than a collection of
***************
*** 1938,1947 ****
  All marks in the virtual group will stick to the articles in the
  component groups.  So if you tick an article in a virtual group, the
  article will also be ticked in the component group from whence it came.
! (And vice versa - marks from the component groups will also be shown in
  the virtual group.)
  
! Here's an example nnvirtual method that collects all Andrea Dworkin
  newsgroups into one, big, happy newsgroup:
  
  @lisp
--- 1934,1943 ----
  All marks in the virtual group will stick to the articles in the
  component groups.  So if you tick an article in a virtual group, the
  article will also be ticked in the component group from whence it came.
! (And vice versa---marks from the component groups will also be shown in
  the virtual group.)
  
! Here's an example @code{nnvirtual} method that collects all Andrea Dworkin
  newsgroups into one, big, happy newsgroup:
  
  @lisp
***************
*** 1960,2024 ****
  "^nntp+some.server.jp:soc.motss$\\|^nntp+some.server.no:soc.motss$"
  @end example
  
! This should work kinda smoothly - all articles from both groups should
  end up in this one, and there should be no duplicates.  Threading (and
  the rest) will still work as usual, but there might be problems with the
  sequence of articles.  Sorting on date might be an option here
  (@pxref{Selecting a Group}.
  
! One limitation, however - all groups that are included in a virtual
  group has to be alive (i.e., subscribed or unsubscribed).  Killed or
! zombie groups can't be component groups for nnvirtual groups.
  
  @node nnkiboze
  @subsection nnkiboze
! @cindex nnkiboze
  @cindex kibozing
  
! @dfn{Kibozing} is defined by OED as "grepping through (parts of) the
! news feed".  nnkiboze is a backend that will do this for you.  Oh joy!
! Now you can grind any @sc{nntp} server down to a halt with useless
  requests!  Oh happiness!
  
! The address field of the nnkiboze method is, as with nnvirtual, a regexp
! to match groups to be "included" in the nnkiboze group.  There most
! similarities between nnkiboze and nnvirtual ends.
  
! In addition to this regexp detailing component groups, an nnkiboze group
  must have a score file to say what articles that are to be included in
  the group (@pxref{Scoring}).
  
  @kindex M-x nnkiboze-generate-groups
  @findex nnkiboze-generate-groups
  You must run @kbd{M-x nnkiboze-generate-groups} after creating the
! nnkiboze groups you want to have.  This command will take time.  Lots of
  time.  Oodles and oodles of time.  Gnus has to fetch the headers from
  all the articles in all the components groups and run them through the
  scoring process to determine if there are any articles in the groups
! that are to be part of the nnkiboze groups.
  
  Please limit the number of component groups by using restrictive
  regexps.  Otherwise your sysadmin may become annoyed with you, and the
  @sc{nntp} site may throw you off and never let you back in again.
  Stranger things have happened.
  
! nnkiboze component groups do not have to be alive - they can be dead,
  and they can be foreign.  No restrictions.
  
  @vindex nnkiboze-directory
! The generation of an nnkiboze group means writing two files in
  @code{nnkiboze-directory}, which is @file{~/News/} by default.  One
  contains the @sc{nov} header lines for all the articles in the group,
  and the other is an additional @file{.newsrc} file to store information
  on what groups that have been searched through to find component
  articles.
  
! Articles that are marked as read in the nnkiboze group will have their
  @sc{nov} lines removed from the @sc{nov} file.
  
  @node nndir
  @subsection nndir
! @cindex nndir
  @cindex directory groups
  
  If you have a directory that has lots of articles in separate files in
--- 1956,2020 ----
  "^nntp+some.server.jp:soc.motss$\\|^nntp+some.server.no:soc.motss$"
  @end example
  
! This should work kinda smoothly---all articles from both groups should
  end up in this one, and there should be no duplicates.  Threading (and
  the rest) will still work as usual, but there might be problems with the
  sequence of articles.  Sorting on date might be an option here
  (@pxref{Selecting a Group}.
  
! One limitation, however---all groups that are included in a virtual
  group has to be alive (i.e., subscribed or unsubscribed).  Killed or
! zombie groups can't be component groups for @code{nnvirtual} groups.
  
  @node nnkiboze
  @subsection nnkiboze
! @cindex @code{nnkiboze}
  @cindex kibozing
  
! @dfn{Kibozing} is defined by @sc{oed} as "grepping through (parts of)
! the news feed".  @code{nnkiboze} is a backend that will do this for you.  Oh
! joy!  Now you can grind any @sc{nntp} server down to a halt with useless
  requests!  Oh happiness!
  
! The address field of the @code{nnkiboze} method is, as with @code{nnvirtual}, a regexp
! to match groups to be "included" in the @code{nnkiboze} group.  There most
! similarities between @code{nnkiboze} and @code{nnvirtual} ends.
  
! In addition to this regexp detailing component groups, an @code{nnkiboze} group
  must have a score file to say what articles that are to be included in
  the group (@pxref{Scoring}).
  
  @kindex M-x nnkiboze-generate-groups
  @findex nnkiboze-generate-groups
  You must run @kbd{M-x nnkiboze-generate-groups} after creating the
! @code{nnkiboze} groups you want to have.  This command will take time.  Lots of
  time.  Oodles and oodles of time.  Gnus has to fetch the headers from
  all the articles in all the components groups and run them through the
  scoring process to determine if there are any articles in the groups
! that are to be part of the @code{nnkiboze} groups.
  
  Please limit the number of component groups by using restrictive
  regexps.  Otherwise your sysadmin may become annoyed with you, and the
  @sc{nntp} site may throw you off and never let you back in again.
  Stranger things have happened.
  
! @code{nnkiboze} component groups do not have to be alive---they can be dead,
  and they can be foreign.  No restrictions.
  
  @vindex nnkiboze-directory
! The generation of an @code{nnkiboze} group means writing two files in
  @code{nnkiboze-directory}, which is @file{~/News/} by default.  One
  contains the @sc{nov} header lines for all the articles in the group,
  and the other is an additional @file{.newsrc} file to store information
  on what groups that have been searched through to find component
  articles.
  
! Articles that are marked as read in the @code{nnkiboze} group will have their
  @sc{nov} lines removed from the @sc{nov} file.
  
  @node nndir
  @subsection nndir
! @cindex @code{nndir}
  @cindex directory groups
  
  If you have a directory that has lots of articles in separate files in
***************
*** 2027,2033 ****
  
  This might be an opportune moment to mention @code{ange-ftp}, that most
  wonderful of all wonderful Emacs packages.  When I wrote @code{nndir}, I
! didn't think much about it - a backend to read directories.  Big deal.
  
  @code{ange-ftp} changes that picture dramatically.  For instance, if you
  enter @file{"/ftp@@sina.tcamc.uh.edu:/pub/emacs/ding-list/"} as the the
--- 2023,2029 ----
  
  This might be an opportune moment to mention @code{ange-ftp}, that most
  wonderful of all wonderful Emacs packages.  When I wrote @code{nndir}, I
! didn't think much about it---a backend to read directories.  Big deal.
  
  @code{ange-ftp} changes that picture dramatically.  For instance, if you
  enter @file{"/ftp@@sina.tcamc.uh.edu:/pub/emacs/ding-list/"} as the the
***************
*** 2036,2049 ****
  
  @code{nndir} will use @sc{nov} files if they are present.
  
! @code{nndir} is a "read-only" backend - you can't delete or expire
  articles with this method.  You can use @code{nnmh} or @code{nnml} for
  whatever you use @code{nndir} for, so you could switch to any of those
  methods if you feel the need to have a non-read-only @code{nndir}.
  
  @node nneething
  @subsection nneething
! @cindex nneething
  
  From the @code{nndir} backend (which reads a single spool-like
  directory), it's just a hop and a skip to @code{nneething}, which
--- 2032,2045 ----
  
  @code{nndir} will use @sc{nov} files if they are present.
  
! @code{nndir} is a "read-only" backend---you can't delete or expire
  articles with this method.  You can use @code{nnmh} or @code{nnml} for
  whatever you use @code{nndir} for, so you could switch to any of those
  methods if you feel the need to have a non-read-only @code{nndir}.
  
  @node nneething
  @subsection nneething
! @cindex @code{nneething}
  
  From the @code{nndir} backend (which reads a single spool-like
  directory), it's just a hop and a skip to @code{nneething}, which
***************
*** 2070,2076 ****
  traverse the entire disk this way, if you feel like, but remember that
  Gnus is not dired, really, and does not intend to be, either.
  
! There are two overall modes to this action - ephemeral or solid. When
  doing the ephemeral thing (i.e., @kbd{G D} from the group buffer), Gnus
  will not store information on what files you have read, and what files
  are new, and so on. If you create a solid @code{nneething} group the
--- 2066,2072 ----
  traverse the entire disk this way, if you feel like, but remember that
  Gnus is not dired, really, and does not intend to be, either.
  
! There are two overall modes to this action---ephemeral or solid. When
  doing the ephemeral thing (i.e., @kbd{G D} from the group buffer), Gnus
  will not store information on what files you have read, and what files
  are new, and so on. If you create a solid @code{nneething} group the
***************
*** 2100,2115 ****
  
  @node nndoc
  @subsection nndoc
! @cindex nndoc
  @cindex documentation group
  @cindex help group
  
! nndoc is a cute little thing that will let you read a single file as a
  newsgroup.  Currently supported file types are @code{babyl}, @code{mbox}
  and @code{digest}. 
  
! nndoc will not try to change the file or insert any extra headers into
! it - it will simply, like, let you use the file as the basis for a
  group.  And that's it.
  
  Virtual server variables:
--- 2096,2111 ----
  
  @node nndoc
  @subsection nndoc
! @cindex @code{nndoc}
  @cindex documentation group
  @cindex help group
  
! @code{nndoc} is a cute little thing that will let you read a single file as a
  newsgroup.  Currently supported file types are @code{babyl}, @code{mbox}
  and @code{digest}. 
  
! @code{nndoc} will not try to change the file or insert any extra headers into
! it---it will simply, like, let you use the file as the basis for a
  group.  And that's it.
  
  Virtual server variables:
***************
*** 2125,2131 ****
  @cindex reading mail
  @cindex mail
  
! Reading mail with a newsreader - isn't that just plain WeIrD? But of
  course.
  
  Gnus will read the mail spool when you activate a mail group.  The mail
--- 2121,2127 ----
  @cindex reading mail
  @cindex mail
  
! Reading mail with a newsreader---isn't that just plain WeIrD? But of
  course.
  
  Gnus will read the mail spool when you activate a mail group.  The mail
***************
*** 2384,2390 ****
  @code{nnmail-resplit-incoming} to @code{t}.
  
  @vindex nnmail-keep-last-article
! If you use @code{procmail} to split things directory into an nnmh
  directory (which you shouldn't do), you should set
  @code{nnmail-keep-last-article} to non-@code{nil} to prevent Gnus from
  ever expiring the final article in a mail newsgroup. This is quite,
--- 2380,2386 ----
  @code{nnmail-resplit-incoming} to @code{t}.
  
  @vindex nnmail-keep-last-article
! If you use @code{procmail} to split things directory into an @code{nnmh}
  directory (which you shouldn't do), you should set
  @code{nnmail-keep-last-article} to non-@code{nil} to prevent Gnus from
  ever expiring the final article in a mail newsgroup. This is quite,
***************
*** 2504,2510 ****
  
  @node nnmbox
  @subsubsection nnmbox
! @cindex nnmbox
  @cindex unix mail box
  
  @vindex nnmbox-active-file
--- 2500,2506 ----
  
  @node nnmbox
  @subsubsection nnmbox
! @cindex @code{nnmbox}
  @cindex unix mail box
  
  @vindex nnmbox-active-file
***************
*** 2532,2538 ****
  
  @node nnbabyl
  @subsubsection nnbabyl
! @cindex nnbabyl
  @cindex rmail mbox
  
  @vindex nnbabyl-active-file
--- 2528,2534 ----
  
  @node nnbabyl
  @subsubsection nnbabyl
! @cindex @code{nnbabyl}
  @cindex rmail mbox
  
  @vindex nnbabyl-active-file
***************
*** 2559,2565 ****
  
  @node nnml
  @subsubsection nnml
! @cindex nnml
  @cindex mail @sc{nov} spool
  
  The @dfn{nnml} spool mail format isn't compatible with any other known
--- 2555,2561 ----
  
  @node nnml
  @subsubsection nnml
! @cindex @code{nnml}
  @cindex mail @sc{nov} spool
  
  The @dfn{nnml} spool mail format isn't compatible with any other known
***************
*** 2626,2632 ****
  
  @node nnmh
  @subsubsection nnmh
! @cindex nnmh
  @cindex mh-e mail spool
  
  @code{nnmh} is just like @code{nnml}, except that is doesn't generate
--- 2622,2628 ----
  
  @node nnmh
  @subsubsection nnmh
! @cindex @code{nnmh}
  @cindex mh-e mail spool
  
  @code{nnmh} is just like @code{nnml}, except that is doesn't generate
***************
*** 2651,2663 ****
  sure that the articles in the folder is actually what Gnus think they
  are.  It will check date stamps, and stat everything in sight, so
  setting this to @code{t} will mean a serious slow-down.  If you never
! use anything by Gnus to read the nnmh articles, you do not have to set
  this variable to @code{t}. 
  @end table
  
  @node nnfolder
  @subsubsection nnfolder
! @cindex nnfolder
  @cindex mbox folders
  
  @code{nnfolder} is a backend for storing each mail group in a separate
--- 2647,2659 ----
  sure that the articles in the folder is actually what Gnus think they
  are.  It will check date stamps, and stat everything in sight, so
  setting this to @code{t} will mean a serious slow-down.  If you never
! use anything by Gnus to read the @code{nnmh} articles, you do not have to set
  this variable to @code{t}. 
  @end table
  
  @node nnfolder
  @subsubsection nnfolder
! @cindex @code{nnfolder}
  @cindex mbox folders
  
  @code{nnfolder} is a backend for storing each mail group in a separate
***************
*** 2685,2690 ****
--- 2681,2687 ----
  If non-@code{nil}, @code{nnfolder} will read incoming mail.
  @end table
  
+ 
  @node Group Parameters
  @section Group Parameters
  @cindex group parameters
***************
*** 2710,2716 ****
  In fact, the vast majority of groups will normally only have the first
  three elements, which saves quite a lot of cons cells.
  
! The group parameters stores information local to a particular group: 
  
  @table @code
  @item to-address
--- 2707,2713 ----
  In fact, the vast majority of groups will normally only have the first
  three elements, which saves quite a lot of cons cells.
  
! The group parameters store information local to a particular group:
  
  @table @code
  @item to-address
***************
*** 2725,2736 ****
  Let's say there's a group on the server that is called @samp{fa.4ad-l}.
  This is a real newsgroup, but the server has gotten the articles from a
  mail-to-news gateway.  Posting directly to this group is therefore
! impossible - you have to send mail to the mailing list address instead.
  
  @item to-group
  @cindex to-group
! IF the group parameter list contains an element like @code{(to-group
! . "some.group.name")}, all posts will be sent to that groups.
  
  @item auto-expire
  @cindex auto-expire
--- 2722,2740 ----
  Let's say there's a group on the server that is called @samp{fa.4ad-l}.
  This is a real newsgroup, but the server has gotten the articles from a
  mail-to-news gateway.  Posting directly to this group is therefore
! impossible---you have to send mail to the mailing list address instead.
! Also @xref{Mail & Post}. 
  
  @item to-group
  @cindex to-group
! If the group parameter list contains an element like @code{(to-group
! . "some.group.name")}, all posts will be sent to that group.
! 
! @item topic
! @cindex topic
! If the group parameter list contains an element like @code{(topic
! . "some-topic")}, the group will become a member of the topic in
! question (@pxref{Group Topics}). 
  
  @item auto-expire
  @cindex auto-expire
***************
*** 2864,2869 ****
--- 2868,2877 ----
  
  @table @code
  
+ @item gnus-group-sort-by-alphabet
+ @findex gnus-group-sort-by-alphabet
+ Sort the group names alphabetically.  This is the default.
+ 
  @item gnus-group-sort-by-level
  @findex gnus-group-sort-by-level
  Sort by group level.
***************
*** 2872,2881 ****
  @findex gnus-group-sort-by-unread
  Sort by number of unread articles.
  
- @item gnus-group-sort-by-alphabet
- @findex gnus-group-sort-by-alphabet
- Sort the group names alphabetically.  This is the default.
- 
  @item gnus-group-sort-by-method
  @findex gnus-group-sort-by-method
  Sort by alphabetically on the select method.
--- 2880,2885 ----
***************
*** 3028,3034 ****
  (TOPIC REGEXP SHOW)
  @end lisp
  
! As you've already guessed (only geniouses read manuals anyway), all
  groups that match @var{regexp} gets put into a section called
  @var{topic}.  If @var{show} is non-@code{nil}, it overrides
  @code{gnus-group-topic-topics-only}.  In specific, if @var{show} is
--- 3032,3038 ----
  (TOPIC REGEXP SHOW)
  @end lisp
  
! As you've already guessed (only geniï read manuals anyway), all
  groups that match @var{regexp} gets put into a section called
  @var{topic}.  If @var{show} is non-@code{nil}, it overrides
  @code{gnus-group-topic-topics-only}.  In specific, if @var{show} is
***************
*** 3046,3051 ****
--- 3050,3063 ----
  @vindex gnus-group-topic-face
  Topics are shown with @code{gnus-group-topic-face}.
  
+ @vindex{gnus-topic-unique}
+ If @code{gnus-topic-unique} is non-@code{nil}, each group will be member
+ of (tops) one topic each.  If this is @code{nil}, each group might end
+ up being a member of several topics.
+ 
+ You can also put a @code{topic} in the group parameters (@pxref{Group
+ Parameters}). 
+ 
  Now, if you select a topic, if will fold/unfold that topic, which is
  really neat, I think.
  
***************
*** 3067,3077 ****
  @item g
  @kindex g (Group)
  @findex gnus-group-get-new-news
! Check server for new articles.  If the numerical prefix is used, this
! command will check only groups of level @var{arg} and lower
  (@code{gnus-group-get-new-news}).  If given a non-numerical prefix, this
  command will force a total rereading of the active file(s) from the
! backend(s).  
  
  @item M-g
  @kindex M-g (Group)
--- 3079,3089 ----
  @item g
  @kindex g (Group)
  @findex gnus-group-get-new-news
! Check the server(s) for new articles.  If the numerical prefix is used,
! this command will check only groups of level @var{arg} and lower
  (@code{gnus-group-get-new-news}).  If given a non-numerical prefix, this
  command will force a total rereading of the active file(s) from the
! backend(s).
  
  @item M-g
  @kindex M-g (Group)
***************
*** 3181,3186 ****
--- 3193,3199 ----
  * Threading::                   How threads are made.
  * Asynchronous Fetching::       Gnus might be able to pre-fetch articles.
  * Article Caching::             You may store articles in a cache.
+ * Article Backlog::             Having already read articles hang around.
  * Exiting the Summary Buffer::  Returning to the Group buffer.
  * Process/Prefix::              A convention used by many treatment commands.
  * Saving Articles::             Ways of customizing article saving.
***************
*** 3887,3900 ****
  @end table
  
  In addition, you can enter conses into this list.  The car of this cons
! should be a symbol who's name is the name of the header, and the cdr can
! either a string to be entered verbatim as the value of this header, or
! it can be a function to be called.  This function should return a string
! to be inserted.  For instance, if you want to insert @samp{Mime-Version:
! 1.0}, you should enter @code{(Mime-Version . "1.0")} into the list.  If
! you want to insert a funny quote, you could enter something like
! @code{(X-Yow . yow)} into the list.  The function @code{yow} will then
! be called without any arguments. 
  
  The list contains a cons where the car of the cons is @code{optional},
  the cdr of this cons will only be inserted if it is non-@code{nil}.
--- 3900,3913 ----
  @end table
  
  In addition, you can enter conses into this list.  The car of this cons
! should be a symbol. This symbol's name is the name of the header, and
! the cdr can either be a string to be entered verbatim as the value of
! this header, or it can be a function to be called.  This function should
! return a string to be inserted.  For instance, if you want to insert
! @samp{Mime-Version: 1.0}, you should enter @code{(Mime-Version . "1.0")}
! into the list.  If you want to insert a funny quote, you could enter
! something like @code{(X-Yow . yow)} into the list.  The function
! @code{yow} will then be called without any arguments.
  
  The list contains a cons where the car of the cons is @code{optional},
  the cdr of this cons will only be inserted if it is non-@code{nil}.
***************
*** 4062,4068 ****
  @item new-text
  Check whether there is any new text in the messages.
  @item signature
! Check the length of the signature
  @item approved
  Check whether the article has an @code{Approved} header, which is
  something only moderators should include.
--- 4075,4081 ----
  @item new-text
  Check whether there is any new text in the messages.
  @item signature
! Check the length of the signature.
  @item approved
  Check whether the article has an @code{Approved} header, which is
  something only moderators should include.
***************
*** 4105,4111 ****
  signature will be appended to all outgoing post.  Most people find it
  more convenient to use @code{mail-signature}, which (sort of) does the
  same, but inserts the signature into the buffer before you start editing
! the post (or mail).  So - if you have both of these variables set, you
  will get two signatures.  Note that @code{mail-signature} does not work
  the same way as @code{gnus-signature-file}, which is a bit confusing.
  If @code{mail-signature} is @code{t}, it will insert
--- 4118,4124 ----
  signature will be appended to all outgoing post.  Most people find it
  more convenient to use @code{mail-signature}, which (sort of) does the
  same, but inserts the signature into the buffer before you start editing
! the post (or mail).  So---if you have both of these variables set, you
  will get two signatures.  Note that @code{mail-signature} does not work
  the same way as @code{gnus-signature-file}, which is a bit confusing.
  If @code{mail-signature} is @code{t}, it will insert
***************
*** 4153,4159 ****
  (Lars Magne Ingebrigtsen)"} and @samp{"Lars Magne Ingebrigtsen
  <larsi@@ifi.uio.no>"}. The latter version is recommended in news (and is
  probably illegal in mail), but the name has to be quoted if it contains
! non-alpha-numerical characters - @samp{"\"Lars M. Ingebrigtsen\"
  <larsi@@ifi.uio.no>"}.
  
  @item mail-default-headers
--- 4166,4172 ----
  (Lars Magne Ingebrigtsen)"} and @samp{"Lars Magne Ingebrigtsen
  <larsi@@ifi.uio.no>"}. The latter version is recommended in news (and is
  probably illegal in mail), but the name has to be quoted if it contains
! non-alpha-numerical characters---@samp{"\"Lars M. Ingebrigtsen\"
  <larsi@@ifi.uio.no>"}.
  
  @item mail-default-headers
***************
*** 4169,4175 ****
  copy to the author of the article you are following up.  If
  non-@code{nil} and not @code{ask}, Gnus will send a mail with a copy of
  all follow-ups to the authors of the articles you follow up.  It's nice
! in one way - you make sure that the person you are responding to gets
  your response.  Other people loathe this method and will hate you dearly
  for it, because it means that they will first get a mail, and then have
  to read the same article later when they read the news.  It is
--- 4182,4188 ----
  copy to the author of the article you are following up.  If
  non-@code{nil} and not @code{ask}, Gnus will send a mail with a copy of
  all follow-ups to the authors of the articles you follow up.  It's nice
! in one way---you make sure that the person you are responding to gets
  your response.  Other people loathe this method and will hate you dearly
  for it, because it means that they will first get a mail, and then have
  to read the same article later when they read the news.  It is
***************
*** 4192,4197 ****
--- 4205,4225 ----
  current newsgroup name and then returns a suitable group name (or list
  of names).
  
+ @item gnus-mailing-list-groups
+ @findex gnus-mailing-list-groups
+ @cindex mailing lists
+ 
+ If your newsserver offer groups that are really mailing lists that are
+ gatewayed to the @sc{nntp} server, you can read those groups without
+ problems, but you can't post/followup to them without some difficulty.
+ One solution is to add a @code{to-address} to the group parameters
+ (@pxref{Group Parameters}).  An easier thing to do is set the
+ @code{gnus-mailing-list-groups} to a regexp that match the groups that
+ really are mailing lists.  Then, at least, followups to the mailing
+ lists will work most of the time.  Posting to these groups (@kbd{a}) is
+ still a pain, though.
+ 
+ 
  @end table
  
  You may want to do spell-checking on messages that you send out.  Or, if
***************
*** 4229,4244 ****
  (unfinished) message in a special draft group (which is implemented as
  an @code{nndir} group, if you absolutely have to know) called
  @samp{nndir:drafts}.  The variable @code{gnus-draft-group-directory}
! controls both the name of the group and the location -- the leaf element
  in the path will be used as the name of the group.
  
! If the group doesn't exist, it will be created and subscribed to.
  
  @findex gnus-summary-send-draft
  @kindex S D c
! When you want to continue editing, you simply enter the draft group and
! push @kbd{S D c} (@code{gnus-summary-send-draft}) to do that.  You will
! be placed in a buffer where you left off.
  
  Rejected articles will also be put in this draft group (@pxref{Rejected
  Articles}).
--- 4257,4273 ----
  (unfinished) message in a special draft group (which is implemented as
  an @code{nndir} group, if you absolutely have to know) called
  @samp{nndir:drafts}.  The variable @code{gnus-draft-group-directory}
! controls both the name of the group and the location---the leaf element
  in the path will be used as the name of the group.
  
! If the group doesn't exist, it will be created and you'll be subscribed
! to it.
  
  @findex gnus-summary-send-draft
  @kindex S D c
! When you want to continue editing the article, you simply enter the
! draft group and push @kbd{S D c} (@code{gnus-summary-send-draft}) to do
! that.  You will be placed in a buffer where you left off.
  
  Rejected articles will also be put in this draft group (@pxref{Rejected
  Articles}).
***************
*** 4247,4253 ****
  If you have lots of rejected messages you want to post (or mail) without
  doing further editing, you can use the @kbd{S D a} command
  (@code{gnus-summary-send-all-drafts}).  This command understands the
! process/prefix convention.  
  
  
  @node Rejected Articles
--- 4276,4282 ----
  If you have lots of rejected messages you want to post (or mail) without
  doing further editing, you can use the @kbd{S D a} command
  (@code{gnus-summary-send-all-drafts}).  This command understands the
! process/prefix convention (@pxref{Process/Prefix}).  
  
  
  @node Rejected Articles
***************
*** 4255,4269 ****
  @cindex rejected articles
  
  Sometimes a news server will reject an article.  Perhaps the server
! doesn't like your face.  Perhaps it just feels miserable.  Perhaps there
! be demons.  Perhaps you have included too much cited text.  Perhaps the
! disk is full.  Perhaps the server is down.
  
  These situations are, of course, totally beyond the control of Gnus.
  (Gnus, of course, loves the way you look, always feels great, has angels
! fluttering around in it, doesn't care about how much cited text you
! include, never runs full and never goes down.)  So what Gnus does is
! saves these articles until some later time when the server feels better.
  
  The rejected articles will automatically be put in a special draft group
  (@pxref{Drafts}).  When the server comes back up again, you'd then
--- 4284,4298 ----
  @cindex rejected articles
  
  Sometimes a news server will reject an article.  Perhaps the server
! doesn't like your face.  Perhaps it just feels miserable.  Perhaps
! @emph{there be demons}.  Perhaps you have included too much cited text.
! Perhaps the disk is full.  Perhaps the server is down.
  
  These situations are, of course, totally beyond the control of Gnus.
  (Gnus, of course, loves the way you look, always feels great, has angels
! fluttering around inside of it, doesn't care about how much cited text
! you include, never runs full and never goes down.)  So Gnus saves these
! articles until some later time when the server feels better.
  
  The rejected articles will automatically be put in a special draft group
  (@pxref{Drafts}).  When the server comes back up again, you'd then
***************
*** 4285,4291 ****
  Find the article you wish to cancel (you can only cancel your own
  articles, so don't try any funny stuff).  Then press @kbd{C} or @kbd{S
  c} (@code{gnus-summary-cancel-article}).  Your article will be
! canceled - machines all over the world will be deleting your article. 
  
  Be aware, however, that not all sites honor cancels, so your article may
  live on here and there, while most sites will delete the article in
--- 4314,4320 ----
  Find the article you wish to cancel (you can only cancel your own
  articles, so don't try any funny stuff).  Then press @kbd{C} or @kbd{S
  c} (@code{gnus-summary-cancel-article}).  Your article will be
! canceled---machines all over the world will be deleting your article. 
  
  Be aware, however, that not all sites honor cancels, so your article may
  live on here and there, while most sites will delete the article in
***************
*** 4304,4310 ****
  
  @vindex gnus-delete-supersedes-headers
  You probably want to delete some of the old headers before sending the
! superseding article - @code{Path} and @code{Date} are probably
  incorrect.  Set @code{gnus-delete-supersedes-headers} to a regexp to
  match the lines you want removed.  The default is
  @samp{"^Path:\\|^Date"}. 
--- 4333,4339 ----
  
  @vindex gnus-delete-supersedes-headers
  You probably want to delete some of the old headers before sending the
! superseding article---@code{Path} and @code{Date} are probably
  incorrect.  Set @code{gnus-delete-supersedes-headers} to a regexp to
  match the lines you want removed.  The default is
  @samp{"^Path:\\|^Date"}. 
***************
*** 4505,4511 ****
  @item M C-c
  @kindex M C-c (Summary)
  @findex gnus-summary-catchup-all
! Mark all articles in the group as read - even the ticked and dormant
  articles (@code{gnus-summary-catchup-all}).
  @item M H
  @kindex M H (Summary)
--- 4534,4540 ----
  @item M C-c
  @kindex M C-c (Summary)
  @findex gnus-summary-catchup-all
! Mark all articles in the group as read---even the ticked and dormant
  articles (@code{gnus-summary-catchup-all}).
  @item M H
  @kindex M H (Summary)
***************
*** 4719,4725 ****
  @cindex article threading
  
  Gnus threads articles by default.  @dfn{To thread} is to put replies to
! articles directly after the articles they reply to - in a hierarchical
  fashion.
  
  @menu
--- 4748,4754 ----
  @cindex article threading
  
  Gnus threads articles by default.  @dfn{To thread} is to put replies to
! articles directly after the articles they reply to---in a hierarchical
  fashion.
  
  @menu
***************
*** 4744,4756 ****
  @item gnus-fetch-old-headers
  @vindex gnus-fetch-old-headers
  If non-@code{nil}, Gnus will attempt to build old threads by fetching
! more old headers - headers to articles that are marked as read.  If you
  would like to display as few summary lines as possible, but still
  connect as many loose threads as possible, you should set this variable
  to @code{some} or a number.  If you set it to a number, no more than
  that number of extra old headers will be fetched.  In either case,
  fetching old headers only works if the backend you are using carries
! overview files -- this would normally be @code{nntp}, @code{nnspool} and
  @code{nnml}.  Also remember that if the root of the thread has been
  expired by the server, there's not much Gnus can do about that.
  
--- 4773,4785 ----
  @item gnus-fetch-old-headers
  @vindex gnus-fetch-old-headers
  If non-@code{nil}, Gnus will attempt to build old threads by fetching
! more old headers---headers to articles that are marked as read.  If you
  would like to display as few summary lines as possible, but still
  connect as many loose threads as possible, you should set this variable
  to @code{some} or a number.  If you set it to a number, no more than
  that number of extra old headers will be fetched.  In either case,
  fetching old headers only works if the backend you are using carries
! overview files---this would normally be @code{nntp}, @code{nnspool} and
  @code{nnml}.  Also remember that if the root of the thread has been
  expired by the server, there's not much Gnus can do about that.
  
***************
*** 4968,4974 ****
  Gnus will fetch more articles than you will read.  This will mean that
  the link between your machine and the @sc{nntp} server will become more
  loaded than if you didn't use article pre-fetch.  The server itself will
! also become more loaded - both with the extra article requests, and the
  extra connection.
  
  Ok, so now you know that you shouldn't really use this thing... unless
--- 4997,5003 ----
  Gnus will fetch more articles than you will read.  This will mean that
  the link between your machine and the @sc{nntp} server will become more
  loaded than if you didn't use article pre-fetch.  The server itself will
! also become more loaded---both with the extra article requests, and the
  extra connection.
  
  Ok, so now you know that you shouldn't really use this thing... unless
***************
*** 5056,5061 ****
--- 5085,5115 ----
  since @code{nnvirtual} assigns random article numbers to its articles.
  
  
+ @node Article Backlog
+ @section Article Backlog
+ @cindex backlog
+ @cindex article backlog
+ 
+ If you have a slow connection, but the idea of using caching seems
+ unappealing to you (and it is, really), you can help the situation some
+ by switching on the @dfn{backlog}.  This is where Gnus will buffer
+ already read articles so that it doesn't have to re-fetch articles
+ you've already read.  This only helps if you are in the habit of
+ re-selecting articles you've recently read, of course.  If you never do
+ that, turning the backlog on will slow Gnus down a little bit, and
+ increase memory usage some.
+ 
+ @vindex gnus-keep-backlog
+ If you set @code{gnus-keep-backlog} to a number @var{n}, Gnus will store
+ at most @var{n} old articles in a buffer for later re-fetching.  If this
+ variable is non-@code{nil} and is not a number, Gnus will store
+ @emph{all} read articles, which means that your Emacs will group without
+ bound before exploding and taking your machine down with you.  I put
+ that in there just to keep y'all on your toes.  
+ 
+ This variable is @code{nil} by default.
+ 
+ 
  @node Exiting the Summary Buffer
  @section Exiting the Summary Buffer
  @cindex summary exit
***************
*** 5210,5215 ****
--- 5264,5274 ----
  If @code{gnus-save-all-headers} is non-@code{nil}, Gnus will not delete
  unwanted headers before saving the article.
  
+ @vindex gnus-saved-headers
+ If the preceeding variable is @code{nil}, all headers that match the
+ @code{gnus-saved-headers} regexp will be kept, while the rest will be
+ deleted before saving.
+ 
  @table @kbd
  
  @item O o
***************
*** 5253,5259 ****
  @item O p
  @kindex O p (Summary)
  @findex gnus-summary-pipe-output
! Save the current article in a pipe.  Uhm, like, what I mean is - Pipe
  the current article to a process (@code{gnus-summary-pipe-output}).
  @end table
  
--- 5312,5318 ----
  @item O p
  @kindex O p (Summary)
  @findex gnus-summary-pipe-output
! Save the current article in a pipe.  Uhm, like, what I mean is---Pipe
  the current article to a process (@code{gnus-summary-pipe-output}).
  @end table
  
***************
*** 5340,5346 ****
  @vindex gnus-use-long-file-name
  Finally, you have the @code{gnus-use-long-file-name} variable.  If it is
  @code{nil}, all the preceding functions will replace all periods
! (@samp{.}) in the group names with slashes (@samp{/}) - which means that
  the functions will generate hierarchies of directories instead of having
  all the files in the toplevel directory
  (@samp{~/News/alt/andrea-dworkin} instead of
--- 5399,5405 ----
  @vindex gnus-use-long-file-name
  Finally, you have the @code{gnus-use-long-file-name} variable.  If it is
  @code{nil}, all the preceding functions will replace all periods
! (@samp{.}) in the group names with slashes (@samp{/})---which means that
  the functions will generate hierarchies of directories instead of having
  all the files in the toplevel directory
  (@samp{~/News/alt/andrea-dworkin} instead of
***************
*** 5362,5368 ****
  @end lisp
  
  Then just save with @kbd{o}. You'd then read this hierarchy with
! ephemeral @code{nneething} groups - @kbd{G D} in the group buffer, and
  the toplevel directory as the argument (@file{~/News/}). Then just walk
  around to the groups/directories with @code{nneething}.
  
--- 5421,5427 ----
  @end lisp
  
  Then just save with @kbd{o}. You'd then read this hierarchy with
! ephemeral @code{nneething} groups---@kbd{G D} in the group buffer, and
  the toplevel directory as the argument (@file{~/News/}). Then just walk
  around to the groups/directories with @code{nneething}.
  
***************
*** 5606,5612 ****
  Non-@code{nil} means that @code{gnus-uu}, when asked to save without
  decoding, will save in digests.  If this variable is @code{nil},
  @code{gnus-uu} will just save everything in a file without any
! embellishments.  The digesting almost conforms to RFC1153 - no easy way
  to specify any meaningful volume and issue numbers were found, so I
  simply dropped them.
  
--- 5665,5671 ----
  Non-@code{nil} means that @code{gnus-uu}, when asked to save without
  decoding, will save in digests.  If this variable is @code{nil},
  @code{gnus-uu} will just save everything in a file without any
! embellishments.  The digesting almost conforms to RFC1153---no easy way
  to specify any meaningful volume and issue numbers were found, so I
  simply dropped them.
  
***************
*** 5634,5640 ****
  Non-@code{nil} means that @code{gnus-uu} will post the encoded file in a
  thread.  This may not be smart, as no other decoder I have seen are able
  to follow threads when collecting uuencoded articles.  (Well, I have
! seen one package that does that - @code{gnus-uu}, but somehow, I don't
  think that counts...) Default is @code{nil}.
  
  @item gnus-uu-post-separate-description
--- 5693,5699 ----
  Non-@code{nil} means that @code{gnus-uu} will post the encoded file in a
  thread.  This may not be smart, as no other decoder I have seen are able
  to follow threads when collecting uuencoded articles.  (Well, I have
! seen one package that does that---@code{gnus-uu}, but somehow, I don't
  think that counts...) Default is @code{nil}.
  
  @item gnus-uu-post-separate-description
***************
*** 6344,6352 ****
  There is a lot of useful information in the head: the name of the person
  who wrote the article, the date it was written and the subject of the
  article.  That's well and nice, but there's also lots of information
! most people do not want to see - what systems the article has passed
  through before reaching you, the @code{Message-Id}, the
! @code{References}, etc. ad nauseum - and you'll probably want to get rid
  of some of those lines.  If you want to keep all those lines in the
  article buffer, you can set @code{gnus-show-all-headers} to @code{t}.
  
--- 6403,6411 ----
  There is a lot of useful information in the head: the name of the person
  who wrote the article, the date it was written and the subject of the
  article.  That's well and nice, but there's also lots of information
! most people do not want to see---what systems the article has passed
  through before reaching you, the @code{Message-Id}, the
! @code{References}, etc. ad nauseum---and you'll probably want to get rid
  of some of those lines.  If you want to keep all those lines in the
  article buffer, you can set @code{gnus-show-all-headers} to @code{t}.
  
***************
*** 6454,6460 ****
  
  You can, of course, write your own functions.  The functions are called
  from the article buffer, and you can do anything you like, pretty much.
! There is no information that you have to keep in the buffer - you can
  change everything.  However, you shouldn't delete any headers.  Instead
  make them invisible if you want to make them go away.
  
--- 6513,6519 ----
  
  You can, of course, write your own functions.  The functions are called
  from the article buffer, and you can do anything you like, pretty much.
! There is no information that you have to keep in the buffer---you can
  change everything.  However, you shouldn't delete any headers.  Instead
  make them invisible if you want to make them go away.
  
***************
*** 6545,6561 ****
  backend represents a virtual server.
  
  For instance, the @code{nntp} backend may be used to connect to several
! different actual nntp servers, or, perhaps, to many different ports on
! the same actual nntp server.  You tell Gnus which backend to use, and
! what parameters to set by specifying a @dfn{select method}.  
  
  These select methods specifications can sometimes become quite
! complicated - say, for instance, that you want to read from the nntp
! server @samp{news.funet.fi} on port number @samp{13}, which hangs if
! queried for @sc{nov} headers and has a buggy select.  Ahem.  Anyways, if
! you had to specify that for each group that used this server, that would
! be too much work, so Gnus offers a way of putting names to methods,
! which is what you do in the server buffer.
  
  To enter the server buffer, user the @kbd{^}
  (@code{gnus-group-enter-server-mode}) command in the group buffer.
--- 6604,6620 ----
  backend represents a virtual server.
  
  For instance, the @code{nntp} backend may be used to connect to several
! different actual @sc{nntp} servers, or, perhaps, to many different ports
! on the same actual @sc{nntp} server.  You tell Gnus which backend to
! use, and what parameters to set by specifying a @dfn{select method}.
  
  These select methods specifications can sometimes become quite
! complicated---say, for instance, that you want to read from the
! @sc{nntp} server @samp{news.funet.fi} on port number @samp{13}, which
! hangs if queried for @sc{nov} headers and has a buggy select.  Ahem.
! Anyways, if you had to specify that for each group that used this
! server, that would be too much work, so Gnus offers a way of putting
! names to methods, which is what you do in the server buffer.
  
  To enter the server buffer, user the @kbd{^}
  (@code{gnus-group-enter-server-mode}) command in the group buffer.
***************
*** 6565,6570 ****
--- 6624,6630 ----
  * Server Commands::        Commands to manipulate servers.
  * Example Methods::        Examples server specifications.
  * Servers & Methods::      You can use server names as select methods.
+ * Unavailable Servers::    Some servers you try to contact may be down.
  @end menu
  
  @node Server Buffer Format
***************
*** 6578,6588 ****
  
  @table @samp
  @item h 
! How the news is fetched - the backend name.
  @item n
  The name of this server.
  @item w
! Where the news is to be fetched from - the address.
  @end table
  
  @node Server Commands
--- 6638,6648 ----
  
  @table @samp
  @item h 
! How the news is fetched---the backend name.
  @item n
  The name of this server.
  @item w
! Where the news is to be fetched from---the address.
  @end table
  
  @node Server Commands
***************
*** 6630,6636 ****
  After these two elements, there may be a random number of @var{(variable
  form)} pairs.
  
! To go back to the first example - imagine that you want to read from
  port @code{15} from that machine.  This is what the select method should
  look like then:
  
--- 6690,6696 ----
  After these two elements, there may be a random number of @var{(variable
  form)} pairs.
  
! To go back to the first example---imagine that you want to read from
  port @code{15} from that machine.  This is what the select method should
  look like then:
  
***************
*** 6671,6676 ****
--- 6731,6792 ----
  over.
  
  
+ @node Unavailable Servers
+ @section Unavailable Servers
+ 
+ If a server seems to be unreachable, Gnus will mark that server as
+ @code{denied}.  That means that any subsequent attempt to make contact
+ with that server will just be ignored.  "It can't be opened," Gnus will
+ tell you, without making the least effort to see whether that is
+ actually the case or not.  
+ 
+ That might seem quite naughty, but it does make sense most of the time.
+ Let's say you have 10 groups subscribed to the server
+ @samp{nepholococcygia.com}.  This server is located somewhere quite far
+ away from you, the machine is quite, so it takes 1 minute just to find
+ out that it refuses connection from you today.  If Gnus were to attempt
+ to do that 10 times, you'd be quite annoyed, so Gnus won't attempt to do
+ that.  Once it has gotten a single "connection refused", it will regard
+ that server as "down".
+ 
+ So, what happens if the machine was only feeling unwell temporarily?
+ How do you test to see whether the machine has come up again?
+ 
+ You jump to the server buffer (@pxref{The Server Buffer}) and poke ut
+ with the following commands:
+ 
+ @table @kbd
+ 
+ @item O
+ @kindex O (Server)
+ @findex gnus-server-open-server
+ Try to establish connection to the server on the current line
+ (@code{gnus-server-open-server}).
+ 
+ @item C
+ @kindex C (Server)
+ @findex gnus-server-close-server
+ Close the connection (if any) to the server
+ (@code{gnus-server-close-server}).
+ 
+ @item D
+ @kindex D (Server)
+ @findex gnus-server-deny-server
+ Mark the current server as unreachable
+ (@code{gnus-server-deny-server}). 
+ 
+ @item R
+ @kindex R (Server)
+ @findex gnus-server-remove-denials
+ Remove all marks to whether Gnus was denied connection from all servers
+ (@code{gnus-server-remove-denials}). 
+ 
+ @end table
+ 
+ 
+ 
+ 
+ 
  @node Scoring
  @chapter Scoring
  @cindex scoring
***************
*** 6822,6830 ****
  @item s
  Score on the subject line.
  @item x
! Score on the Xref line - i.e., the cross-posting line.
  @item t
! Score on thread - the References line.
  @item d
  Score on the date.
  @item l
--- 6938,6946 ----
  @item s
  Score on the subject line.
  @item x
! Score on the Xref line---i.e., the cross-posting line.
  @item t
! Score on thread---the References line.
  @item d
  Score on the date.
  @item l
***************
*** 7059,7064 ****
--- 7175,7181 ----
   (orphan -10)
   (adapt t)
   (files "/hom/larsi/News/gnu.SCORE")
+  (exclude-files "all.SCORE")
   (local (gnus-newsgroup-auto-expire t)
          (gnus-summary-make-false-root 'empty))
   (eval (ding)))
***************
*** 7096,7114 ****
  be a string, but on the Lines and Chars headers, this must be an
  integer. 
  @item 
! If the second element is present, it should be a number - the @dfn{score
  element}.  This number should be an integer in the neginf to posinf
  interval.  This number is added to the score of the article if the match
  is successful.  If this element is not present, the
  @code{gnus-score-interactive-default-score} number will be used instead.
  @item 
! If the third element is present, it should be a number - the @dfn{date
  element}.  This date says when the last time this score entry matched,
  which provides a mechanism for expiring the score entries.  It this
  element is not present, the score entry is permanent.  The date is
  represented by the number of days since December 31, 1 ce.
  @item 
! If the fourth element is present, it should be a symbol - the @dfn{type
  element}.  This element specifies what function should be used to see
  whether this score entry matches the article.  What match types that can
  be used depends on what header you wish to perform the match on.
--- 7213,7231 ----
  be a string, but on the Lines and Chars headers, this must be an
  integer. 
  @item 
! If the second element is present, it should be a number---the @dfn{score
  element}.  This number should be an integer in the neginf to posinf
  interval.  This number is added to the score of the article if the match
  is successful.  If this element is not present, the
  @code{gnus-score-interactive-default-score} number will be used instead.
  @item 
! If the third element is present, it should be a number---the @dfn{date
  element}.  This date says when the last time this score entry matched,
  which provides a mechanism for expiring the score entries.  It this
  element is not present, the score entry is permanent.  The date is
  represented by the number of days since December 31, 1 ce.
  @item 
! If the fourth element is present, it should be a symbol---the @dfn{type
  element}.  This element specifies what function should be used to see
  whether this score entry matches the article.  What match types that can
  be used depends on what header you wish to perform the match on.
***************
*** 7218,7224 ****
  @cindex adaptive scoring
  
  If all this scoring is getting you down, Gnus has a way of making it all
! happen automatically - as if by magic.  Or rather, as if by artificial
  stupidity, to be precise.
  
  @vindex gnus-use-adaptive-scoring
--- 7335,7341 ----
  @cindex adaptive scoring
  
  If all this scoring is getting you down, Gnus has a way of making it all
! happen automatically---as if by magic.  Or rather, as if by artificial
  stupidity, to be precise.
  
  @vindex gnus-use-adaptive-scoring
***************
*** 7247,7262 ****
  @end lisp
  
  As you see, each element in this alist has a mark as a key (either a
! variable name or a "real" mark - a character).  Following this key is a
  random number of header/score pairs.  
  
! To take @code{gnus-del-mark} as an example - this alist says that all
  articles that have that mark (i.e., are marked with @samp{D}) will have a
  score entry added to lower based on the @code{From} header by -4, and
  lowered by @code{Subject} by -1.  Change this to fit your prejudices. 
  
  If you use this scheme, you should set @code{mark-below} to something
! small - like -300, perhaps, to avoid having small random changes result
  in articles getting marked as read.
  
  After using adaptive scoring for a week or so, Gnus should start to
--- 7364,7379 ----
  @end lisp
  
  As you see, each element in this alist has a mark as a key (either a
! variable name or a "real" mark---a character).  Following this key is a
  random number of header/score pairs.  
  
! To take @code{gnus-del-mark} as an example---this alist says that all
  articles that have that mark (i.e., are marked with @samp{D}) will have a
  score entry added to lower based on the @code{From} header by -4, and
  lowered by @code{Subject} by -1.  Change this to fit your prejudices. 
  
  If you use this scheme, you should set @code{mark-below} to something
! small---like -300, perhaps, to avoid having small random changes result
  in articles getting marked as read.
  
  After using adaptive scoring for a week or so, Gnus should start to
***************
*** 7298,7304 ****
  ("xref" (" +[^ ]+:[0-9]+ +[^ ]+:[0-9]+ +[^ ]+:[0-9]+" -1000 nil r))
  @end lisp
  @item Matching on the body
! This is generally not a very good idea - it takes a very long time.
  Gnus actually has to fetch each individual article from the server.  But
  you might want to anyway, I guess.  Even though there are three match
  keys (@code{Head}, @code{Body} and @code{All}), you should choose one
--- 7415,7421 ----
  ("xref" (" +[^ ]+:[0-9]+ +[^ ]+:[0-9]+ +[^ ]+:[0-9]+" -1000 nil r))
  @end lisp
  @item Matching on the body
! This is generally not a very good idea---it takes a very long time.
  Gnus actually has to fetch each individual article from the server.  But
  you might want to anyway, I guess.  Even though there are three match
  keys (@code{Head}, @code{Body} and @code{All}), you should choose one
***************
*** 7374,7380 ****
  use the @code{gnus-score-search-global-directories} command.
  
  Note that, at present, using this option will slow down group entry
! somewhat.  (That is - a lot.)
  
  If you want to start maintaining score files for other people to use,
  just put your score file up for anonymous ftp and announce it to the
--- 7491,7497 ----
  use the @code{gnus-score-search-global-directories} command.
  
  Note that, at present, using this option will slow down group entry
! somewhat.  (That is---a lot.)
  
  If you want to start maintaining score files for other people to use,
  just put your score file up for anonymous ftp and announce it to the
***************
*** 7848,7854 ****
  buffer all the time.
  @item gnus-visible-headers
  Cut down on the headers that are included in the articles to the
! minimum.  You can, in fact, make do without them altogether - most of the
  useful data is in the summary buffer, anyway.  Set this variable to
  @samp{"^NEVVVVER"} or @samp{"From:"}, or whatever you feel you need.
  @item gnus-article-display-hook
--- 7965,7971 ----
  buffer all the time.
  @item gnus-visible-headers
  Cut down on the headers that are included in the articles to the
! minimum.  You can, in fact, make do without them altogether---most of the
  useful data is in the summary buffer, anyway.  Set this variable to
  @samp{"^NEVVVVER"} or @samp{"From:"}, or whatever you feel you need.
  @item gnus-article-display-hook
***************
*** 7879,7885 ****
  
  @table @code
  @item gnus-save-newsrc-file
! If this is @code{nil}, Gnus will never save @file{.newsrc} - it will
  only save @file{.newsrc.eld}.  This means that you will not be able to
  use any other newsreaders than Gnus.
  @item gnus-save-killed-list
--- 7996,8002 ----
  
  @table @code
  @item gnus-save-newsrc-file
! If this is @code{nil}, Gnus will never save @file{.newsrc}---it will
  only save @file{.newsrc.eld}.  This means that you will not be able to
  use any other newsreaders than Gnus.
  @item gnus-save-killed-list
***************
*** 7905,7937 ****
  Set @code{gnus-article-display-hook} to @code{nil} to make article
  processing a bit faster.
  
  @node Troubleshooting
  @chapter Troubleshooting
  @cindex troubleshooting
  
! Gnus works @emph{so} well straight out of the box - I can't imagine any
  problems, really.
  
  Ahem.
  
  @enumerate
  @item
  Make sure your computer is switched on.
  @item
  Make sure that you really load the current Gnus version.  If you have
  been running @sc{gnus}, you need to exit Emacs and start it up again before
  Gnus will work.
  @item
  Try doing an @kbd{M-x gnus-version}.  If you get something that looks
  like @samp{Gnus v5.46; nntp 4.0} you have the right files loaded.  If,
  on the other hand, you get something like @samp{NNTP 3.x} or @samp{nntp
  flee}, you have some old @file{.el} files lying around.  Delete these.
  @item
  Read the help group (@kbd{M h} in the group buffer) for a FAQ and a
  how-to. 
  @end enumerate
  
! If all else fails, report the problem as a bug,
  
  @cindex bugs
  @cindex reporting bugs
--- 8022,8059 ----
  Set @code{gnus-article-display-hook} to @code{nil} to make article
  processing a bit faster.
  
+ 
  @node Troubleshooting
  @chapter Troubleshooting
  @cindex troubleshooting
  
! Gnus works @emph{so} well straight out of the box---I can't imagine any
  problems, really.
  
  Ahem.
  
  @enumerate
+ 
  @item
  Make sure your computer is switched on.
+ 
  @item
  Make sure that you really load the current Gnus version.  If you have
  been running @sc{gnus}, you need to exit Emacs and start it up again before
  Gnus will work.
+ 
  @item
  Try doing an @kbd{M-x gnus-version}.  If you get something that looks
  like @samp{Gnus v5.46; nntp 4.0} you have the right files loaded.  If,
  on the other hand, you get something like @samp{NNTP 3.x} or @samp{nntp
  flee}, you have some old @file{.el} files lying around.  Delete these.
+ 
  @item
  Read the help group (@kbd{M h} in the group buffer) for a FAQ and a
  how-to. 
  @end enumerate
  
! If all else fails, report the problem as a bug.
  
  @cindex bugs
  @cindex reporting bugs
***************
*** 7943,7958 ****
  me the backtrace. I will fix bugs, but I can only fix them if you send
  me a precise description as to how to reproduce the bug.
  
! @c If you just need help, you are better off asking on
! @c @samp{gnu.emacs.gnus}.  
  
  @node The End
  @chapter The End
  
! Well, that's the manual - you can get on with your life now.  Keep in
  touch.  Say hello to your cats from me.  
  
! My @strong{ghod} - I just can't stand goodbyes.  Sniffle.
  
  Ol' Chuck Reznikoff said it pretty well, so I leave the floor to him:
  
--- 8065,8094 ----
  me the backtrace. I will fix bugs, but I can only fix them if you send
  me a precise description as to how to reproduce the bug.
  
! You really can never be too detailed in a bug report.  Always use the
! @kbd{M-x gnus-bug} command when you make bug reports, even if it creates
! a 10Kb mail each time you use it, and even if you have sent me your
! environment 500 times before.  I don't care.  I want the full info each
! time.  
! 
! It is also important to remember that I have no memory whatsoever.  If
! you send a bug report, and I send you a reply, and then you send back
! just "No, it's not! Moron!", I will have no idea what you are insulting
! me about.  Always overexplain everything.  It's much easier for all of
! us---if I don't have all the information I need, I will just mail you
! and ask for more info, and everything takes more time.
! 
! If you just need help, you are better off asking on
! @samp{gnu.emacs.gnus}.  I'm not very helpful.
! 
  
  @node The End
  @chapter The End
  
! Well, that's the manual---you can get on with your life now.  Keep in
  touch.  Say hello to your cats from me.  
  
! My @strong{ghod}---I just can't stand goodbyes.  Sniffle.
  
  Ol' Chuck Reznikoff said it pretty well, so I leave the floor to him:
  
***************
*** 8000,8013 ****
  @node Backend Interface
  @section Backend Interface
  
! Gnus doesn't know anything about nntp, spools, mail or virtual groups.
! It only knows how to talk to @dfn{virtual servers}.  A virtual server is
! a @dfn{backend} and some @dfn{backend variables}.  As examples of the
! first, we have @code{nntp}, @code{nnspool} and @code{nnmbox}.  As
  examples of the latter we have @code{nntp-port-number} and
! @code{nnmbox-directory}. 
  
! When Gnus asks for information from a backend -- say @code{nntp} -- on
  something, it will normally include a virtual server name in the
  function parameters.  (If not, the backend should use the "current"
  virtual server.)  For instance, @code{nntp-request-list} takes a virtual
--- 8136,8149 ----
  @node Backend Interface
  @section Backend Interface
  
! Gnus doesn't know anything about @sc{nntp}, spools, mail or virtual
! groups.  It only knows how to talk to @dfn{virtual servers}.  A virtual
! server is a @dfn{backend} and some @dfn{backend variables}.  As examples
! of the first, we have @code{nntp}, @code{nnspool} and @code{nnmbox}.  As
  examples of the latter we have @code{nntp-port-number} and
! @code{nnmbox-directory}.
  
! When Gnus asks for information from a backend---say @code{nntp}---on
  something, it will normally include a virtual server name in the
  function parameters.  (If not, the backend should use the "current"
  virtual server.)  For instance, @code{nntp-request-list} takes a virtual
***************
*** 8049,8055 ****
  In the examples and definitions I will refer to the imaginary backend
  @code{nnchoke}. 
  
! @cindex nnchoke
  
  @menu
  * Required Backend Functions::        Functions that must be implemented.
--- 8185,8191 ----
  In the examples and definitions I will refer to the imaginary backend
  @code{nnchoke}. 
  
! @cindex @code{nnchoke}
  
  @menu
  * Required Backend Functions::        Functions that must be implemented.
***************
*** 8065,8071 ****
  @item (nnchoke-retrieve-headers ARTICLES &optional GROUP SERVER FETCH-OLD)
  
  @var{articles} is either a range of article numbers or a list of
! @code{Message-ID}s.  Current backends do not fully support either - only
  sequences (lists) of article numbers, and most backends do not support
  retrieval of @code{Message-ID}s.  But they should try for both. 
  
--- 8201,8207 ----
  @item (nnchoke-retrieve-headers ARTICLES &optional GROUP SERVER FETCH-OLD)
  
  @var{articles} is either a range of article numbers or a list of
! @code{Message-ID}s.  Current backends do not fully support either---only
  sequences (lists) of article numbers, and most backends do not support
  retrieval of @code{Message-ID}s.  But they should try for both. 
  
***************
*** 8325,8331 ****
  request that the backend check for incoming articles, in one way or
  another.  A mail backend will typically read the spool file or query the
  POP server when this function is invoked.  The @var{group} doesn't have
! to be heeded -- if the backend decides that it is too much work just
  scanning for a single group, it may do a total scan of all groups.  It
  would be nice, however, to keep things local if that's practical.
  
--- 8461,8467 ----
  request that the backend check for incoming articles, in one way or
  another.  A mail backend will typically read the spool file or query the
  POP server when this function is invoked.  The @var{group} doesn't have
! to be heeded---if the backend decides that it is too much work just
  scanning for a single group, it may do a total scan of all groups.  It
  would be nice, however, to keep things local if that's practical.
  
***************
*** 8521,8527 ****
  
  As you can see, white space is needed, but the type and amount of white
  space is irrelevant.  This means that formatting of the score file is
! left up to the programmer -- if it's simpler to just spew it all out on
  one looong line, then that's ok.
  
  The meaning of the various atoms are explained elsewhere in this
--- 8657,8663 ----
  
  As you can see, white space is needed, but the type and amount of white
  space is irrelevant.  This means that formatting of the score file is
! left up to the programmer---if it's simpler to just spew it all out on
  one looong line, then that's ok.
  
  The meaning of the various atoms are explained elsewhere in this
***************
*** 8537,8543 ****
  
  @dfn{Header} is a severly overloaded term.  "Header" is used in RFC1036
  to talk about lines in the head of an article (eg., @code{From}).  It is
! used by many people as a synonym for "head" -- "the header and the
  body".  (That should be avoided, in my opinion.)  And Gnus uses a format
  interanally that it calls "header", which is what I'm talking about
  here.  This is a 9-element vector, basically, with each header (ouch)
--- 8673,8679 ----
  
  @dfn{Header} is a severly overloaded term.  "Header" is used in RFC1036
  to talk about lines in the head of an article (eg., @code{From}).  It is
! used by many people as a synonym for "head"---"the header and the
  body".  (That should be avoided, in my opinion.)  And Gnus uses a format
  interanally that it calls "header", which is what I'm talking about
  here.  This is a 9-element vector, basically, with each header (ouch)
*** pub/sgnus/texi/ChangeLog	Sat Sep 30 06:06:02 1995
--- sgnus/texi/ChangeLog	Mon Oct  2 16:42:16 1995
***************
*** 1,3 ****
--- 1,10 ----
+ Mon Oct  2 10:01:19 1995  Lars Ingebrigtsen  <lars@eyesore.no>
+ 
+ 	* gnus.texi (Unavailable Servers): New.
+ 	(Article Backlog): New.
+ 	(Mail & Post): Addition.
+ 	(Saving Articles): Addition.
+ 
  Mon Sep 25 00:28:32 1995  Lars Ingebrigtsen  <lars@eyesore.no>
  
  	* gnus.texi (Group Maintenance): Change.
