diff --exclude=*.elc --exclude=*~ --exclude=*-[0-9] --exclude=gnus --exclude=readme --context --recursive pub/dgnus/lisp/ChangeLog dgnus/lisp/ChangeLog
*** pub/dgnus/lisp/ChangeLog	Fri Apr 14 16:47:49 1995
--- dgnus/lisp/ChangeLog	Sun Apr 16 00:31:32 1995
***************
*** 1,3 ****
--- 1,47 ----
+ Sun Apr 16 00:02:02 1995  Lars Magne Ingebrigtsen  <larsi@holmenkollen.ifi.uio.no>
+ 
+ 	* gnus.el (gnus-summary-update-line): Don't mark ancient and read
+ 	articles as low-scored.
+ 	(gnus-inews-article): Would insert headers one line too early. 
+ 
+ Sat Apr 15 22:16:26 1995  Lars Magne Ingebrigtsen  <larsi@holmenkollen.ifi.uio.no>
+ 
+ 	* gnus.el (gnus-score-headers): Changed to allow score alists
+ 	returned from function in...
+ 	(gnus-score-find-score-files-function): Wider semantics.
+ 	(gnus-parse-options-lines): Don't parse options if there aren't
+ 	any. 
+ 	(gnus-group-default-list-level): New variable.
+ 	(gnus-use-long-file-name): Extended semantics.
+ 	(gnus-group-list-groups): Use new variable.
+ 	(gnus-group-jump-to-group): Bux fix.
+ 
+ Fri Apr 14 08:05:42 1995  Lars Ingebrigtsen  <lars@eyesore.no>
+ 
+ 	* gnus.el: Installed Fabrice Popineau's XEmacs patches.
+ 
+ 	* nnfolder.el: Installed Scott Byer's version.
+ 
+ 	* nntp.el (nntp-request-group): Use LIST ACTIVE group if the
+ 	server supports it.
+ 
+ Fri Apr 14 17:14:44 1995  Lars Magne Ingebrigtsen  <larsi@menja.ifi.uio.no>
+ 
+ 	* gnus.el (gnus-post-news): Set gnus-newsgroup-name when posting. 
+ 
+ 	* nnfolder.el (nnfolder-request-expire-articles): Setcar the wrong
+ 	thing. 
+ 
+ 	* gnus.el (gnus-summary-catchup): Would catchup no matter what
+ 	answer the user gave.
+ 
+ 	* nnfolder.el (nnfolder-request-close): New function to remove
+ 	nnfolder buffers.
+ 
+ Fri Apr 14 17:09:40 1995  Lars Magne Ingebrigtsen  <larsi@gymir.ifi.uio.no>
+ 
+         * gnus.el: 0.49 is released.
+ 
  Fri Apr 14 00:29:43 1995  Lars Magne Ingebrigtsen  <larsi@gymir.ifi.uio.no>
  
  	* gnus.el (gnus-list-active-group): New function.
diff --exclude=*.elc --exclude=*~ --exclude=*-[0-9] --exclude=gnus --exclude=readme --context --recursive pub/dgnus/lisp/gnus-visual.el dgnus/lisp/gnus-visual.el
*** pub/dgnus/lisp/gnus-visual.el	Fri Apr 14 16:47:45 1995
--- dgnus/lisp/gnus-visual.el	Sat Apr 15 22:09:28 1995
***************
*** 25,31 ****
  ;;; Code:
  
  (require 'gnus)
! (require 'easymenu)
  
  (defvar gnus-summary-selected-face 'underline
    "Face used for highlighting the current article in the summary buffer.")
--- 25,31 ----
  ;;; Code:
  
  (require 'gnus)
! (require (if gnus-xemacs 'auc-menu 'easymenu))
  
  (defvar gnus-summary-selected-face 'underline
    "Face used for highlighting the current article in the summary buffer.")
***************
*** 81,108 ****
     gnus-group-mode-map
     ""
     '("Groups"
       ["Jump to group" gnus-group-jump-to-group t]
       ["Best unread group" gnus-group-best-unread-group t]
-      ["List subscribed groups" gnus-group-list-groups t]
-      ["List all groups" gnus-group-list-all-groups t]
-      ["List groups matching..." gnus-group-list-matching t]
-      ["Sort group buffer" gnus-group-sort-groups t]
-      ["Subscribe to random group" gnus-group-unsubscribe-group t]
-      ["Describe all groups" gnus-group-describe-all-groups t]
-      ["Group apropos" gnus-group-apropos t]
-      ["Group and description apropos" gnus-group-description-apropos t]
-      ["List groups matching..." gnus-group-list-matching t]
-      ["Make a foreign group" gnus-group-make-group t]
-      ["Edit a group entry" gnus-group-edit-group t]
-      ["Add a directory group" gnus-group-make-directory-group t]
-      ["Add the help group" gnus-group-make-help-group t]
-      ["Add the archive group" gnus-group-make-archive-group t]
-      ["Make a kiboze group" gnus-group-make-kiboze-group t]
-      ["Kill all newsgroups in region" gnus-group-kill-region t]
-      ["Kill all zombie groups" gnus-group-kill-all-zombies t]
-      ["List killed groups" gnus-group-list-killed t]
-      ["List zombie groups" gnus-group-list-zombies t]
-      ["Edit global KILL file" gnus-group-edit-global-kill t]
       ))
  
    (easy-menu-define
--- 81,109 ----
     gnus-group-mode-map
     ""
     '("Groups"
+      ("Listing"
+       ["List subscribed groups" gnus-group-list-groups t]
+       ["List all groups" gnus-group-list-all-groups t]
+       ["List groups matching..." gnus-group-list-matching t]
+       ["List killed groups" gnus-group-list-killed t]
+       ["List zombie groups" gnus-group-list-zombies t]
+       ["Describe all groups" gnus-group-describe-all-groups t]
+       ["Group apropos" gnus-group-apropos t]
+       ["Group and description apropos" gnus-group-description-apropos t]
+       ["List groups matching..." gnus-group-list-matching t])
+      ("Subscribe"
+       ["Subscribe to random group" gnus-group-unsubscribe-group t]
+       ["Kill all newsgroups in region" gnus-group-kill-region t]
+       ["Kill all zombie groups" gnus-group-kill-all-zombies t])
+      ("Foreign groups"
+       ["Make a foreign group" gnus-group-make-group t]
+       ["Edit a group entry" gnus-group-edit-group t]
+       ["Add a directory group" gnus-group-make-directory-group t]
+       ["Add the help group" gnus-group-make-help-group t]
+       ["Add the archive group" gnus-group-make-archive-group t]
+       ["Make a kiboze group" gnus-group-make-kiboze-group t])
       ["Jump to group" gnus-group-jump-to-group t]
       ["Best unread group" gnus-group-best-unread-group t]
       ))
  
    (easy-menu-define
***************
*** 134,139 ****
--- 135,142 ----
       ["Clear dribble buffer" gnus-group-clear-dribble t]
       ["Exit from Gnus" gnus-group-exit t]
       ["Exit without saving" gnus-group-quit t]
+      ["Sort group buffer" gnus-group-sort-groups t]
+      ["Edit global KILL file" gnus-group-edit-global-kill t]
       ))
  
    )
***************
*** 350,356 ****
  (defun gnus-article-make-menu-bar ()
  
   (easy-menu-define
!    gnus-article-mode-menu
     gnus-article-mode-map
     ""
     '("Article"
--- 353,359 ----
  (defun gnus-article-make-menu-bar ()
  
   (easy-menu-define
!    gnus-article-article-menu
     gnus-article-mode-map
     ""
     '("Article"
***************
*** 364,370 ****
       ))
  
   (easy-menu-define
!    gnus-article-mode-menu
     gnus-article-mode-map
     ""
     '("Treatment"
--- 367,373 ----
       ))
  
   (easy-menu-define
!    gnus-article-treatment-menu
     gnus-article-mode-map
     ""
     '("Treatment"
***************
*** 377,399 ****
       ))
   )
  
! (defun gnus-visual-highlight-selected-summary ()
!   ;; Added by Per Abrahamsen <amanda@iesd.auc.dk>.
!   ;; Highlight selected article in summary buffer
!   (if gnus-summary-selected-face
!       (save-excursion
! 	(let* ((beg (progn (beginning-of-line) (point)))
! 	       (end (progn (end-of-line) (point)))
! 	       (to (1- (previous-single-property-change
! 			end 'mouse-face nil beg)))
! 	       (from (1+ (previous-single-property-change 
! 			  to 'mouse-face nil beg))))
! 	  (if gnus-newsgroup-selected-overlay
! 	      (move-overlay gnus-newsgroup-selected-overlay 
! 			    from to (current-buffer))
! 	    (setq gnus-newsgroup-selected-overlay (make-overlay from to))
! 	    (overlay-put gnus-newsgroup-selected-overlay 'face 
! 			 gnus-summary-selected-face))))))
  
  ;; New implementation by Christian Limpach <Christian.Limpach@nice.ch>.
  (defun gnus-visual-summary-highlight-line ()
--- 380,420 ----
       ))
   )
  
! (if gnus-xemacs
!     (defun gnus-visual-highlight-selected-summary ()
!       (if gnus-summary-selected-face
! 	  (save-excursion
! 	    (let* ((beg (progn (beginning-of-line) (point)))
! 		   (end (progn (end-of-line) (point)))
! 		   (from (or
! 			  (next-single-property-change beg 'mouse-face nil end)
! 			  beg))
! 		   (to (or (next-single-property-change from 'mouse-face nil end)
! 			   end)))
! 	      (if gnus-newsgroup-selected-overlay
! 		  (move-overlay gnus-newsgroup-selected-overlay 
! 				from to (current-buffer))
! 		(setq gnus-newsgroup-selected-overlay (make-overlay from to))
! 		(overlay-put gnus-newsgroup-selected-overlay 'face 
! 			     gnus-summary-selected-face))))))
! 
!   (defun gnus-visual-highlight-selected-summary ()
!     ;; Added by Per Abrahamsen <amanda@iesd.auc.dk>.
!     ;; Highlight selected article in summary buffer
!     (if gnus-summary-selected-face
! 	(save-excursion
! 	  (let* ((beg (progn (beginning-of-line) (point)))
! 		 (end (progn (end-of-line) (point)))
! 		 (to (max 1 (1- (previous-single-property-change
! 				 end 'mouse-face nil beg))))
! 		 (from (1+ (previous-single-property-change 
! 			    to 'mouse-face nil beg))))
! 	    (if gnus-newsgroup-selected-overlay
! 		(move-overlay gnus-newsgroup-selected-overlay 
! 			      from to (current-buffer))
! 	      (setq gnus-newsgroup-selected-overlay (make-overlay from to))
! 	      (overlay-put gnus-newsgroup-selected-overlay 'face 
! 			   gnus-summary-selected-face)))))))
  
  ;; New implementation by Christian Limpach <Christian.Limpach@nice.ch>.
  (defun gnus-visual-summary-highlight-line ()
***************
*** 419,424 ****
  	  (put-text-property beg end 'face face)))
      (goto-char p)))
  
  (provide 'gnus-visual)
  
! ;;; gnus-visual.el ends here
--- 440,473 ----
  	  (put-text-property beg end 'face face)))
      (goto-char p)))
  
+ (if (not gnus-xemacs)
+     ()
+   (setq gnus-group-mode-hook
+ 	(cons
+ 	 (lambda ()
+ 	   (easy-menu-add gnus-group-reading-menu)
+ 	   (easy-menu-add gnus-group-group-menu)
+ 	   (easy-menu-add gnus-group-post-menu)
+ 	   (easy-menu-add gnus-group-misc-menu)) 
+ 	 gnus-group-mode-hook))
+   (setq gnus-summary-mode-hook
+ 	(cons
+ 	 (lambda ()
+ 	   (easy-menu-add gnus-summary-mark-menu)
+ 	   (easy-menu-add gnus-summary-move-menu)
+ 	   (easy-menu-add gnus-summary-article-menu)
+ 	   (easy-menu-add gnus-summary-thread-menu)
+ 	   (easy-menu-add gnus-summary-misc-menu)
+ 	   (easy-menu-add gnus-summary-post-menu)
+ 	   (easy-menu-add gnus-summary-kill-menu))
+ 	 gnus-summary-mode-hook))
+   (setq gnus-article-mode-hook
+ 	(cons
+ 	 (lambda ()
+ 	   (easy-menu-add gnus-article-article-menu)
+ 	   (easy-menu-add gnus-article-treatment-menu)) 
+ 	 gnus-article-mode-hook)))
+ 
  (provide 'gnus-visual)
  
! ;;; gnus-visual.el ends here
\ No newline at end of file
diff --exclude=*.elc --exclude=*~ --exclude=*-[0-9] --exclude=gnus --exclude=readme --context --recursive pub/dgnus/lisp/gnus.el dgnus/lisp/gnus.el
*** pub/dgnus/lisp/gnus.el	Fri Apr 14 16:47:46 1995
--- dgnus/lisp/gnus.el	Sun Apr 16 00:31:34 1995
***************
*** 242,248 ****
  
  (defvar gnus-use-long-file-name (not (memq system-type '(usg-unix-v xenix)))
    "Non-nil means that the default name of a file to save articles in is the group name.
! If it's nil, the directory form of the group name is used instead.")
  
  (defvar gnus-article-save-directory (or (getenv "SAVEDIR") "~/News/")
    "Name of the directory articles will be saved in (default \"~/News\").
--- 242,254 ----
  
  (defvar gnus-use-long-file-name (not (memq system-type '(usg-unix-v xenix)))
    "Non-nil means that the default name of a file to save articles in is the group name.
! If it's nil, the directory form of the group name is used instead.
! 
! If this variable is a list, and the list contains the element
! `not-score', long file names will not be used for score files, if it
! contains the element `not-save', long file names will not be used for
! saving, and if it contains the element `not-kill', long file names
! will not be used for kill files.")
  
  (defvar gnus-article-save-directory (or (getenv "SAVEDIR") "~/News/")
    "Name of the directory articles will be saved in (default \"~/News\").
***************
*** 476,481 ****
--- 482,490 ----
    "Default article score level.
  If this variable is nil, scoring will be disabled.")
  
+ (defvar gnus-group-default-list-level 5
+   "Default listing level.")
+ 
  (defvar gnus-user-login-name nil
    "The login name of the user.
  Got from the function `user-login-name' if undefined.")
***************
*** 669,675 ****
  in hierarchical newsgroup order; `gnus-subscribe-interactively' asks
  for your decision.")
  
! ;; Suggested by a bug report by Hallvard B Furuseth
  ;; <h.b.furuseth@usit.uio.no>. 
  (defvar gnus-subscribe-options-newsgroup-method
    (function gnus-subscribe-alphabetically)
--- 678,684 ----
  in hierarchical newsgroup order; `gnus-subscribe-interactively' asks
  for your decision.")
  
! ;; Suggested by a bug report by Hallvard B Furuseth.
  ;; <h.b.furuseth@usit.uio.no>. 
  (defvar gnus-subscribe-options-newsgroup-method
    (function gnus-subscribe-alphabetically)
***************
*** 927,933 ****
  gnus-score-find-hierarchical: Also apply SCORE files from parent groups.
  gnus-score-find-bnews: Apply SCORE files whose names matches.
  
! See the documentation to these functions for more information.")
  
  (defvar gnus-options-subscribe nil
    "All new groups matching this regexp will be subscribed unconditionally.
--- 936,946 ----
  gnus-score-find-hierarchical: Also apply SCORE files from parent groups.
  gnus-score-find-bnews: Apply SCORE files whose names matches.
  
! See the documentation to these functions for more information.
! 
! This variable can also be a list of functions to be called.  Each
! function should either return a list of score files, or the functions
! may also return lists of score alists.")
  
  (defvar gnus-options-subscribe nil
    "All new groups matching this regexp will be subscribed unconditionally.
***************
*** 1251,1257 ****
  (defconst gnus-maintainer "Lars Magne Ingebrigtsen <larsi@ifi.uio.no>"
    "The mail address of the Gnus maintainer.")
  
! (defconst gnus-version "(ding) Gnus v0.49"
    "Version number for this version of Gnus.")
  
  (defvar gnus-info-nodes
--- 1264,1270 ----
  (defconst gnus-maintainer "Lars Magne Ingebrigtsen <larsi@ifi.uio.no>"
    "The mail address of the Gnus maintainer.")
  
! (defconst gnus-version "(ding) Gnus v0.50"
    "Version number for this version of Gnus.")
  
  (defvar gnus-info-nodes
***************
*** 1493,1509 ****
    (autoload 'mail-extract-address-components "mail-extr")
    )
  
- (put 'gnus-group-mode 'mode-class 'special)
- (put 'gnus-summary-mode 'mode-class 'special)
- (put 'gnus-article-mode 'mode-class 'special)
- 
  
  
  ;; Fix by Hallvard B Furuseth <h.b.furuseth@usit.uio.no>.
! (defun gnus-summary-position-cursor () nil)
! (defun gnus-group-position-cursor () nil)
! (fset 'gnus-summary-position-cursor 'gnus-goto-colon)
! (fset 'gnus-group-position-cursor 'gnus-goto-colon)
  
  (defmacro gnus-eval-in-buffer-window (buffer &rest forms)
    "Pop to BUFFER, evaluate FORMS, and then returns to original window."
--- 1506,1537 ----
    (autoload 'mail-extract-address-components "mail-extr")
    )
  
  
  
  ;; Fix by Hallvard B Furuseth <h.b.furuseth@usit.uio.no>.
! ;; If you want the cursor to go somewhere else, set these two
! ;; functions in some startup hook to whatever you want.
! (defalias 'gnus-summary-position-cursor 'gnus-goto-colon)
! (defalias 'gnus-group-position-cursor 'gnus-goto-colon)
! 
! ;; Cruft to make Gnus work under GNU XEmacs.
! (defvar gnus-xemacs nil
!   "Non-nil if Gnus is running under GNU XEmacs.")
! 
! (if (not (string-match "XEmacs\\|Lucid" emacs-version))
!     ()
!   (setq gnus-xemacs t)
!   (eval
!    '((or (memq 'underline (list-faces))
! 	 (make-face 'underline))
!      (or (face-differs-from-default-p 'underline)
! 	 (set-face-underline-p 'underline t))
!      
!      (defun set-text-properties (start end props &optional buffer)
!        (if props
! 	   (put-text-property start end (car props) (cadr props) buffer)
! 	 (remove-text-properties start end ()))))))
! 
  
  (defmacro gnus-eval-in-buffer-window (buffer &rest forms)
    "Pop to BUFFER, evaluate FORMS, and then returns to original window."
***************
*** 1647,1653 ****
  
  (defun gnus-set-mouse-face (string)
    ;; Set mouse face property on STRING.
!   (put-text-property 0 (length string) 'mouse-face gnus-mouse-face string)
    string)
  
  (defun gnus-parse-format (format spec-alist)
--- 1675,1682 ----
  
  (defun gnus-set-mouse-face (string)
    ;; Set mouse face property on STRING.
!   (or gnus-xemacs
!       (put-text-property 0 (length string) 'mouse-face gnus-mouse-face string))
    string)
  
  (defun gnus-parse-format (format spec-alist)
***************
*** 1736,1742 ****
  ;; Suggested by Brian Edmonds <edmonds@cs.ubc.ca>.
  (defun gnus-read-init-file ()
    (and gnus-init-file
!        (or (file-exists-p gnus-init-file)
  	   (file-exists-p (concat gnus-init-file ".el"))
  	   (file-exists-p (concat gnus-init-file ".elc")))
         (load gnus-init-file nil t)))
--- 1765,1773 ----
  ;; Suggested by Brian Edmonds <edmonds@cs.ubc.ca>.
  (defun gnus-read-init-file ()
    (and gnus-init-file
!        (or (and (file-exists-p gnus-init-file) 
! 		;; Don't try to load a directory.
! 		(not (file-directory-p gnus-init-file)))
  	   (file-exists-p (concat gnus-init-file ".el"))
  	   (file-exists-p (concat gnus-init-file ".elc")))
         (load gnus-init-file nil t)))
***************
*** 1749,1755 ****
  Otherwise, it is like ~/News/news/group/num."
    (let ((default
  	  (expand-file-name
! 	   (concat (if gnus-use-long-file-name
  		       (gnus-capitalize-newsgroup newsgroup)
  		     (gnus-newsgroup-directory-form newsgroup))
  		   "/" (int-to-string (header-number headers)))
--- 1780,1786 ----
  Otherwise, it is like ~/News/news/group/num."
    (let ((default
  	  (expand-file-name
! 	   (concat (if (gnus-use-long-file-name 'not-save)
  		       (gnus-capitalize-newsgroup newsgroup)
  		     (gnus-newsgroup-directory-form newsgroup))
  		   "/" (int-to-string (header-number headers)))
***************
*** 1767,1773 ****
  Otherwise, it is like ~/News/news/group/num."
    (let ((default
  	  (expand-file-name
! 	   (concat (if gnus-use-long-file-name
  		       newsgroup
  		     (gnus-newsgroup-directory-form newsgroup))
  		   "/" (int-to-string (header-number headers)))
--- 1798,1804 ----
  Otherwise, it is like ~/News/news/group/num."
    (let ((default
  	  (expand-file-name
! 	   (concat (if (gnus-use-long-file-name 'not-save)
  		       newsgroup
  		     (gnus-newsgroup-directory-form newsgroup))
  		   "/" (int-to-string (header-number headers)))
***************
*** 1785,1791 ****
  Otherwise, it is like ~/News/news/group/news."
    (or last-file
        (expand-file-name
!        (if gnus-use-long-file-name
  	   (gnus-capitalize-newsgroup newsgroup)
  	 (concat (gnus-newsgroup-directory-form newsgroup) "/news"))
         (or gnus-article-save-directory "~/News"))))
--- 1816,1822 ----
  Otherwise, it is like ~/News/news/group/news."
    (or last-file
        (expand-file-name
!        (if (gnus-use-long-file-name 'not-save)
  	   (gnus-capitalize-newsgroup newsgroup)
  	 (concat (gnus-newsgroup-directory-form newsgroup) "/news"))
         (or gnus-article-save-directory "~/News"))))
***************
*** 1796,1802 ****
  Otherwise, it is like ~/News/news/group/news."
    (or last-file
        (expand-file-name
!        (if gnus-use-long-file-name
  	   newsgroup
  	 (concat (gnus-newsgroup-directory-form newsgroup) "/news"))
         (or gnus-article-save-directory "~/News"))))
--- 1827,1833 ----
  Otherwise, it is like ~/News/news/group/news."
    (or last-file
        (expand-file-name
!        (if (gnus-use-long-file-name 'not-save)
  	   newsgroup
  	 (concat (gnus-newsgroup-directory-form newsgroup) "/news"))
         (or gnus-article-save-directory "~/News"))))
***************
*** 2337,2342 ****
--- 2368,2379 ----
       (gnus-number-base-x 
        (% num (expt base pos)) (1- pos) base))))
  
+ ;; Check whether to use long file names.
+ (defun gnus-use-long-file-name (symbol)
+   (and gnus-use-long-file-name
+        (or (not (listp gnus-use-long-file-name))
+ 	   (not (memq 'symbol gnus-use-long-file-name)))))
+ 
  ;; List and range functions
  
  (defun gnus-last-element (list)
***************
*** 2619,2624 ****
--- 2656,2663 ----
  (defvar gnus-group-mode-map nil)
  (defvar gnus-group-make-map nil)
  (defvar gnus-group-list-map nil)
+ (defvar gnus-group-sub-map nil)
+ (put 'gnus-group-mode 'mode-class 'special)
  
  (if gnus-group-mode-map
      nil
***************
*** 2661,2673 ****
    (define-key gnus-group-mode-map "\C-k" 'gnus-group-kill-group)
    (define-key gnus-group-mode-map "\C-y" 'gnus-group-yank-group)
    (define-key gnus-group-mode-map "\C-w" 'gnus-group-kill-region)
-   (define-key gnus-group-mode-map "\M-z" 'gnus-group-kill-all-zombies)
    (define-key gnus-group-mode-map "\C-x\C-t" 'gnus-group-transpose-groups)
    (define-key gnus-group-mode-map "\C-c\C-l" 'gnus-group-list-killed)
    (define-key gnus-group-mode-map "\C-c\C-x" 'gnus-group-expire-articles)
    (define-key gnus-group-mode-map "\C-c\M-\C-x" 'gnus-group-expire-all-groups)
    (define-key gnus-group-mode-map "V" 'gnus-version)
-   (define-key gnus-group-mode-map "S" 'gnus-group-set-current-level)
    (define-key gnus-group-mode-map "s" 'gnus-group-save-newsrc)
    (define-key gnus-group-mode-map "z" 'gnus-group-suspend)
    (define-key gnus-group-mode-map "Z" 'gnus-group-clear-dribble)
--- 2700,2710 ----
***************
*** 2677,2683 ****
    (define-key gnus-group-mode-map "?" 'gnus-group-describe-briefly)
    (define-key gnus-group-mode-map "\C-c\C-i" 'gnus-info-find-node)
    (define-key gnus-group-mode-map "\M-e" 'gnus-group-edit-group)
!   (define-key gnus-group-mode-map [mouse-2] 'gnus-mouse-pick-group)
  
    (define-prefix-command 'gnus-group-make-map)
    (define-key gnus-group-mode-map "M" 'gnus-group-make-map)
--- 2714,2721 ----
    (define-key gnus-group-mode-map "?" 'gnus-group-describe-briefly)
    (define-key gnus-group-mode-map "\C-c\C-i" 'gnus-info-find-node)
    (define-key gnus-group-mode-map "\M-e" 'gnus-group-edit-group)
!   (define-key gnus-group-mode-map
!     (if gnus-xemacs [button2] [mouse-2]) 'gnus-mouse-pick-group)
  
    (define-prefix-command 'gnus-group-make-map)
    (define-key gnus-group-mode-map "M" 'gnus-group-make-map)
***************
*** 2698,2704 ****
    (define-key gnus-group-list-map "d" 'gnus-group-description-apropos)
    (define-key gnus-group-list-map "m" 'gnus-group-list-matching)
    (define-key gnus-group-list-map "M" 'gnus-group-list-all-matching)
!   )
  
  (defun gnus-group-mode ()
    "Major mode for reading news.
--- 2736,2751 ----
    (define-key gnus-group-list-map "d" 'gnus-group-description-apropos)
    (define-key gnus-group-list-map "m" 'gnus-group-list-matching)
    (define-key gnus-group-list-map "M" 'gnus-group-list-all-matching)
! 
!   (define-prefix-command 'gnus-group-sub-map)
!   (define-key gnus-group-mode-map "S" 'gnus-group-sub-map)
!   (define-key gnus-group-sub-map "l" 'gnus-group-set-current-level)
!   (define-key gnus-group-sub-map "t" 'gnus-group-unsubscribe-current-group)
!   (define-key gnus-group-sub-map "s" 'gnus-group-unsubscribe-group)
!   (define-key gnus-group-sub-map "k" 'gnus-group-kill-group)
!   (define-key gnus-group-sub-map "y" 'gnus-group-yank-group)
!   (define-key gnus-group-sub-map "w" 'gnus-group-kill-region)
!   (define-key gnus-group-sub-map "z" 'gnus-group-kill-all-zombies))
  
  (defun gnus-group-mode ()
    "Major mode for reading news.
***************
*** 2793,2799 ****
  	  (or t (not gnus-novice-user)
  	      gnus-expert-user
  	      (gnus-group-describe-briefly)) ;Show brief help message.
! 	  (gnus-group-list-groups (or level 5)))))))
  
  (defun gnus-group-startup-message (&optional x y)
    "Insert startup message in current buffer."
--- 2840,2846 ----
  	  (or t (not gnus-novice-user)
  	      gnus-expert-user
  	      (gnus-group-describe-briefly)) ;Show brief help message.
! 	  (gnus-group-list-groups level))))))
  
  (defun gnus-group-startup-message (&optional x y)
    "Insert startup message in current buffer."
***************
*** 2834,2840 ****
  Default is 5, which lists all subscribed groups.
  If argument UNREAD is non-nil, groups with no unread articles are also listed."
    (interactive "P")
!   (setq level (or level 5))
    (gnus-group-setup-buffer)	;May call from out of group buffer
    (let ((case-fold-search nil)
  	(group (gnus-group-group-name)))
--- 2881,2887 ----
  Default is 5, which lists all subscribed groups.
  If argument UNREAD is non-nil, groups with no unread articles are also listed."
    (interactive "P")
!   (setq level (or level gnus-group-default-list-level 5))
    (gnus-group-setup-buffer)	;May call from out of group buffer
    (let ((case-fold-search nil)
  	(group (gnus-group-group-name)))
***************
*** 3178,3187 ****
  			    (let ((unread 
  				   (get-text-property (point) 'gnus-unread)))
  			      (or (eq unread t) (and unread (> unread 0))))
! 			    (< (get-text-property (point) 'gnus-level) 6)))
  		       (or (not level)
  			   (let ((lev (get-text-property (point) 'gnus-level)))
! 			     (if (<= lev level)
  				 t
  			       (if (< lev low)
  				   (progn
--- 3225,3235 ----
  			    (let ((unread 
  				   (get-text-property (point) 'gnus-unread)))
  			      (or (eq unread t) (and unread (> unread 0))))
! 			    (let ((lev (get-text-property (point) 'gnus-level)))
! 			      (and lev (< (get-text-property (point) 'gnus-level) 6)))))
  		       (or (not level)
  			   (let ((lev (get-text-property (point) 'gnus-level)))
! 			     (if (and lev (<= lev level))
  				 t
  			       (if (< lev low)
  				   (progn
***************
*** 3227,3252 ****
  
  (defun gnus-group-jump-to-group (group)
    "Jump to newsgroup GROUP."
!   (interactive
!    ;; Fix by Hallvard B Furuseth <h.b.furuseth@usit.uio.no>.
!    (list 
!     (if gnus-read-active-file
! 	(completing-read "Group: " gnus-active-hashtb nil t)
!       (let ((group (completing-read "Group: " gnus-active-hashtb)))
! 	(or (intern-soft group gnus-active-hashtb)
! 	    (equal group "")
! 	    (gnus-get-new-news-in-group group)
! 	    (error "%s error: %s" group (gnus-status-message group)))
! 	group))))
!   (let (b)
!     ;; Either go to the line in the group buffer...
!     (or (and (setq b (text-property-any (point-min) (point-max) 
! 					'gnus-group (intern group)))
! 	     (goto-char b))
! 	;; ... or insert the line.
! 	(progn (gnus-group-update-group group)
! 	       (goto-char (text-property-any (point-min) (point-max) 
! 					     'gnus-group (intern group))))))
    ;; Adjust cursor point.
    (gnus-group-position-cursor))
  
--- 3275,3300 ----
  
  (defun gnus-group-jump-to-group (group)
    "Jump to newsgroup GROUP."
!   (interactive (list (completing-read "Group: " gnus-active-hashtb nil
! 				      (not (not gnus-read-active-file)))))
! 
!   (if (equal group "")
!       (error "empty group name"))
! 
!   (let ((b (text-property-any (point-min) (point-max) 
! 			      'gnus-group (intern group))))
!     (if b
! 	;; Either go to the line in the group buffer...
! 	(goto-char b)
!       ;; ... or insert the line.
!       (or
!        (gnus-gethash group gnus-active-hashtb)
!        (gnus-activate-newsgroup group)
!        (error "%s error: %s" group (gnus-status-message group)))
! 
!       (gnus-group-update-group group)
!       (goto-char (text-property-any (point-min) (point-max) 
! 				    'gnus-group (intern group)))))
    ;; Adjust cursor point.
    (gnus-group-position-cursor))
  
***************
*** 3490,3496 ****
  	(sort (cdr gnus-newsrc-assoc) gnus-group-sort-function))
    (gnus-make-hashtable-from-newsrc-alist)
    (gnus-get-unread-articles 6)
!   (gnus-group-list-groups 5))
  
  (defun gnus-group-sort-by-alphabet (info1 info2)
    (string< (car info1) (car info2)))
--- 3538,3544 ----
  	(sort (cdr gnus-newsrc-assoc) gnus-group-sort-function))
    (gnus-make-hashtable-from-newsrc-alist)
    (gnus-get-unread-articles 6)
!   (gnus-group-list-groups nil))
  
  (defun gnus-group-sort-by-alphabet (info1 info2)
    (string< (car info1) (car info2)))
***************
*** 3778,3784 ****
  	(gnus-get-unread-articles (or arg 6)))
      (let ((gnus-read-active-file nil))
        (gnus-get-unread-articles (or arg 6))))
!   (gnus-group-list-groups 5 gnus-have-all-newsgroups))
  
  (defun gnus-group-get-new-news-this-group (n)
    "Check for newly arrived news in the current group (and the N-1 next groups).
--- 3826,3832 ----
  	(gnus-get-unread-articles (or arg 6)))
      (let ((gnus-read-active-file nil))
        (gnus-get-unread-articles (or arg 6))))
!   (gnus-group-list-groups nil gnus-have-all-newsgroups))
  
  (defun gnus-group-get-new-news-this-group (n)
    "Check for newly arrived news in the current group (and the N-1 next groups).
***************
*** 3944,3950 ****
    (interactive "P")
    (gnus-save-newsrc-file)
    (gnus-setup-news 'force)
!   (gnus-group-list-groups (or arg 5) gnus-have-all-newsgroups))
  
  (defun gnus-group-read-init-file ()
    "Read the Gnus elisp init file."
--- 3992,3998 ----
    (interactive "P")
    (gnus-save-newsrc-file)
    (gnus-setup-news 'force)
!   (gnus-group-list-groups arg gnus-have-all-newsgroups))
  
  (defun gnus-group-read-init-file ()
    "Read the Gnus elisp init file."
***************
*** 3955,3961 ****
    "Check bogus newsgroups."
    (interactive)
    (gnus-check-bogus-newsgroups (not gnus-expert-user))	;Require confirmation.
!   (gnus-group-list-groups 5 gnus-have-all-newsgroups))
  
  (defun gnus-group-mail ()
    "Start composing a mail."
--- 4003,4009 ----
    "Check bogus newsgroups."
    (interactive)
    (gnus-check-bogus-newsgroups (not gnus-expert-user))	;Require confirmation.
!   (gnus-group-list-groups nil gnus-have-all-newsgroups))
  
  (defun gnus-group-mail ()
    "Start composing a mail."
***************
*** 4023,4028 ****
--- 4071,4077 ----
  	(gnus-clear-system))))
  
  (defun gnus-close-backends ()
+   ;; Send a close request to all backends that support such a request. 
    (let ((methods gnus-valid-select-methods)
  	func)
      (while methods
***************
*** 4079,4084 ****
--- 4128,4134 ----
  
  (defvar gnus-browse-server-mode-hook nil)
  (defvar gnus-browse-server-mode-map nil)
+ (put 'gnus-browse-server-mode 'mode-class 'special)
  
  (if gnus-browse-server-mode-map
      nil
***************
*** 4111,4118 ****
    (let ((gnus-select-method method)
  	groups group)
      (message "Connecting to %s..." (nth 1 method))
!     (if (not (gnus-request-list method))
! 	(error "Unable to contact server: " (gnus-status-message method)))
      (set-buffer (get-buffer-create "*Gnus Browse Server*"))
      (gnus-add-current-to-buffer-list)
      (buffer-disable-undo (current-buffer))
--- 4161,4171 ----
    (let ((gnus-select-method method)
  	groups group)
      (message "Connecting to %s..." (nth 1 method))
!     (or (gnus-server-opened method)
! 	(gnus-open-server method)
! 	(error "Unable to contact server: %s" (gnus-status-message method)))
!     (or (gnus-request-list method)
! 	(error "Couldn't request list: %s" (gnus-status-message method)))
      (set-buffer (get-buffer-create "*Gnus Browse Server*"))
      (gnus-add-current-to-buffer-list)
      (buffer-disable-undo (current-buffer))
***************
*** 4228,4234 ****
    (if (eq major-mode 'gnus-browse-server-mode)
        (kill-buffer (current-buffer)))
    (switch-to-buffer gnus-group-buffer)
!   (gnus-group-list-groups 5))
  
  (defun gnus-browse-describe-briefly ()
    "Give a one line description of the group mode commands."
--- 4281,4287 ----
    (if (eq major-mode 'gnus-browse-server-mode)
        (kill-buffer (current-buffer)))
    (switch-to-buffer gnus-group-buffer)
!   (gnus-group-list-groups nil))
  
  (defun gnus-browse-describe-briefly ()
    "Give a one line description of the group mode commands."
***************
*** 4274,4279 ****
--- 4327,4333 ----
  (defvar gnus-summary-low-xref-map nil)
  (defvar gnus-summary-low-thread-map nil)
  (defvar gnus-summary-low-fol-map nil)
+ (put 'gnus-summary-mode 'mode-class 'special)
  
  (if gnus-summary-mode-map
      nil
***************
*** 4356,4362 ****
    (define-key gnus-summary-mode-map "q" 'gnus-summary-exit)
    (define-key gnus-summary-mode-map "Q" 'gnus-summary-exit-no-update)
    (define-key gnus-summary-mode-map "\C-c\C-i" 'gnus-info-find-node)
!   (define-key gnus-summary-mode-map [mouse-2] 'gnus-mouse-pick-article)
    (define-key gnus-summary-mode-map "m" 'gnus-summary-mail-other-window)
    (define-key gnus-summary-mode-map "a" 'gnus-summary-post-news)
    (define-key gnus-summary-mode-map "x" 'gnus-summary-delete-marked-as-read)
--- 4410,4417 ----
    (define-key gnus-summary-mode-map "q" 'gnus-summary-exit)
    (define-key gnus-summary-mode-map "Q" 'gnus-summary-exit-no-update)
    (define-key gnus-summary-mode-map "\C-c\C-i" 'gnus-info-find-node)
!   (define-key gnus-summary-mode-map
!     (if gnus-xemacs [button2] [mouse-2]) 'gnus-mouse-pick-article)
    (define-key gnus-summary-mode-map "m" 'gnus-summary-mail-other-window)
    (define-key gnus-summary-mode-map "a" 'gnus-summary-post-news)
    (define-key gnus-summary-mode-map "x" 'gnus-summary-delete-marked-as-read)
***************
*** 4857,4870 ****
    ;; Update summary line after change.
    (or (not gnus-summary-default-score)
        gnus-summary-inhibit-highlight
!       (let ((gnus-summary-inhibit-highlight t))
  	(progn
  	  (or dont-update
  	      (if (and gnus-summary-mark-below
  		       (< (gnus-summary-article-score)
  			  gnus-summary-mark-below))
! 		  (and (not (memq (gnus-summary-article-number)
! 				  gnus-newsgroup-marked))
  		       (gnus-summary-mark-article nil gnus-low-score-mark))
  		(and (eq (gnus-summary-article-mark) gnus-low-score-mark)
  		     (gnus-summary-mark-article nil gnus-unread-mark))))
--- 4912,4927 ----
    ;; Update summary line after change.
    (or (not gnus-summary-default-score)
        gnus-summary-inhibit-highlight
!       (let ((gnus-summary-inhibit-highlight t)
! 	    (article (gnus-summary-article-number)))
  	(progn
  	  (or dont-update
  	      (if (and gnus-summary-mark-below
  		       (< (gnus-summary-article-score)
  			  gnus-summary-mark-below))
! 		  (and (not (memq article gnus-newsgroup-marked))
! 		       (not (memq article gnus-newsgroup-dormant))
! 		       (memq article gnus-newsgroup-unreads)
  		       (gnus-summary-mark-article nil gnus-low-score-mark))
  		(and (eq (gnus-summary-article-mark) gnus-low-score-mark)
  		     (gnus-summary-mark-article nil gnus-unread-mark))))
***************
*** 6307,6312 ****
--- 6364,6370 ----
  		newsgroup nil)))
      name))
  
+ 
  (defun gnus-summary-jump-to-group (newsgroup)
    "Move point to NEWSGROUP in group mode buffer."
    ;; Keep update point of group mode buffer if visible.
***************
*** 6573,6578 ****
--- 6631,6637 ----
  	(unwind-protect
  	    (gnus-summary-read-group group nil no-article buf)
  	  (and (string= gnus-newsgroup-name ingroup)
+ 	       (bufferp sumbuf) (buffer-name sumbuf)
  	       (progn
  		 (set-buffer (setq gnus-summary-buffer sumbuf))
  		 (gnus-summary-exit-no-update t))))))))
***************
*** 6670,6676 ****
    (if (null article)
        nil
      (gnus-article-prepare article all-header)
!     (if (= (gnus-summary-article-mark) ?Z) 
  	(progn
  	  (forward-line 1)
  	  (gnus-summary-position-cursor)))
--- 6729,6735 ----
    (if (null article)
        nil
      (gnus-article-prepare article all-header)
!     (if (eq (gnus-summary-article-mark) ?Z)
  	(progn
  	  (forward-line 1)
  	  (gnus-summary-position-cursor)))
***************
*** 7519,7525 ****
    (interactive "p")
    ;; Skip dummy header line.
    (save-excursion
!     (if (= (gnus-summary-article-mark) ?Z) (forward-line 1))
      (let ((buffer-read-only nil))
        ;; Set score.
        (gnus-summary-update-mark
--- 7578,7585 ----
    (interactive "p")
    ;; Skip dummy header line.
    (save-excursion
!     (if (eq (gnus-summary-article-mark) ?Z)
! 	(forward-line 1))
      (let ((buffer-read-only nil))
        ;; Set score.
        (gnus-summary-update-mark
***************
*** 7750,7756 ****
    (let ((buffer-read-only nil))
      (if (gnus-summary-goto-subject article)
  	(progn
! 	  (if (= (gnus-summary-article-mark) ?Z) (forward-line 1))
  	  (gnus-summary-update-mark gnus-process-mark 'replied)
  	  t))))
  
--- 7810,7817 ----
    (let ((buffer-read-only nil))
      (if (gnus-summary-goto-subject article)
  	(progn
! 	  (and (eq (gnus-summary-article-mark) ?Z)
! 	       (forward-line 1))
  	  (gnus-summary-update-mark gnus-process-mark 'replied)
  	  t))))
  
***************
*** 7760,7766 ****
    (let ((buffer-read-only nil))
      (if (gnus-summary-goto-subject article)
  	(progn
! 	  (and (= (gnus-summary-article-mark) ?Z) (forward-line 1))
  	  (gnus-summary-update-mark ?  'replied)
  	  (if (memq article gnus-newsgroup-replied) 
  	      (gnus-summary-update-mark gnus-replied-mark 'replied))
--- 7821,7828 ----
    (let ((buffer-read-only nil))
      (if (gnus-summary-goto-subject article)
  	(progn
! 	  (and (eq (gnus-summary-article-mark) ?Z)
! 	       (forward-line 1))
  	  (gnus-summary-update-mark ?  'replied)
  	  (if (memq article gnus-newsgroup-replied) 
  	      (gnus-summary-update-mark gnus-replied-mark 'replied))
***************
*** 7817,7823 ****
  	(progn
  	  (gnus-summary-show-thread)
  	  (beginning-of-line)
! 	  (if (= (gnus-summary-article-mark) ?Z) (forward-line 1))
  	  ;; Fix the mark.
  	  (gnus-summary-update-mark mark 'unread)
  	  t))))
--- 7879,7886 ----
  	(progn
  	  (gnus-summary-show-thread)
  	  (beginning-of-line)
! 	  (and (eq (gnus-summary-article-mark) ?Z)
! 	       (forward-line 1))
  	  ;; Fix the mark.
  	  (gnus-summary-update-mark mark 'unread)
  	  t))))
***************
*** 8115,8123 ****
  		(while (and (gnus-summary-mark-as-read nil gnus-catchup-mark)
  			    (if to-here (< (point) to-here) t)
  			    (gnus-summary-search-subject nil (not all)))))
! 	    (- unreads (length gnus-newsgroup-unreads))))
!     (or to-here
! 	(setq gnus-newsgroup-unreads gnus-newsgroup-marked))
      (gnus-summary-position-cursor)))
  
  (defun gnus-summary-catchup-to-here (&optional all)
--- 8178,8186 ----
  		(while (and (gnus-summary-mark-as-read nil gnus-catchup-mark)
  			    (if to-here (< (point) to-here) t)
  			    (gnus-summary-search-subject nil (not all)))))
! 	    (- unreads (length gnus-newsgroup-unreads))
! 	    (or to-here
! 		(setq gnus-newsgroup-unreads gnus-newsgroup-marked))))
      (gnus-summary-position-cursor)))
  
  (defun gnus-summary-catchup-to-here (&optional all)
***************
*** 8547,8553 ****
      (or filename
  	(setq filename
  	      (read-file-name
! 	       (concat "Save article in rmail file: (default "
  		       (file-name-nondirectory default-name) ") ")
  	       (file-name-directory default-name)
  	       default-name)))
--- 8610,8616 ----
      (or filename
  	(setq filename
  	      (read-file-name
! 	       (concat "Save in rmail file: (default "
  		       (file-name-nondirectory default-name) ") ")
  	       (file-name-directory default-name)
  	       default-name)))
***************
*** 8573,8579 ****
      (or filename
  	(setq filename
  	      (read-file-name
! 	       (concat "Save article in Unix mail file: (default "
  		       (file-name-nondirectory default-name) ") ")
  	       (file-name-directory default-name)
  	       default-name)))
--- 8636,8642 ----
      (or filename
  	(setq filename
  	      (read-file-name
! 	       (concat "Save in Unix mail file: (default "
  		       (file-name-nondirectory default-name) ") ")
  	       (file-name-directory default-name)
  	       default-name)))
***************
*** 8605,8611 ****
      (or filename
  	(setq filename
  	      (read-file-name
! 	       (concat "Save article in file: (default "
  		       (file-name-nondirectory default-name) ") ")
  	       (file-name-directory default-name)
  	       default-name)))
--- 8668,8674 ----
      (or filename
  	(setq filename
  	      (read-file-name
! 	       (concat "Save in file: (default "
  		       (file-name-nondirectory default-name) ") ")
  	       (file-name-directory default-name)
  	       default-name)))
***************
*** 8992,8997 ****
--- 9055,9062 ----
  ;;; Gnus article mode
  ;;;
  
+ (put 'gnus-article-mode 'mode-class 'special)
+ 
  (if gnus-article-mode-map
      nil
    (setq gnus-article-mode-map (make-keymap))
***************
*** 9794,9800 ****
  	 ;; The global KILL file is placed at top of the directory.
  	 (expand-file-name gnus-kill-file-name
  			   (or gnus-kill-files-directory "~/News")))
! 	(gnus-use-long-file-name
  	 ;; Append ".KILL" to newsgroup name.
  	 (expand-file-name (concat newsgroup "." gnus-kill-file-name)
  			   (or gnus-kill-files-directory "~/News")))
--- 9859,9865 ----
  	 ;; The global KILL file is placed at top of the directory.
  	 (expand-file-name gnus-kill-file-name
  			   (or gnus-kill-files-directory "~/News")))
! 	((gnus-use-long-file-name 'not-kill)
  	 ;; Append ".KILL" to newsgroup name.
  	 (expand-file-name (concat newsgroup "." gnus-kill-file-name)
  			   (or gnus-kill-files-directory "~/News")))
***************
*** 9936,9941 ****
--- 10001,10007 ----
  	   (car (gnus-score-get 'mark-and-expunge alist)))
  	  (read-only (gnus-score-get 'read-only alist))
  	  (files (gnus-score-get 'files alist))
+ 	  (exclude-files (gnus-score-get 'exclude-files alist))
            (orphan (gnus-score-get 'orphan alist))
  	  (eval (gnus-score-get 'eval alist)))
        ;; We do not respect eval and files atoms from global score
***************
*** 10077,10092 ****
    
  (defun gnus-score-headers ()
    ;; Score `gnus-newsgroup-headers'.
!   (let ((score-files (and (symbolp gnus-score-find-score-files-function)
! 			  (fboundp gnus-score-find-score-files-function)
! 			  (funcall gnus-score-find-score-files-function
! 				   gnus-newsgroup-name)))
! 	scores)
      ;; PLM: probably this is not the best place to clear orphan-score
      (setq gnus-orphan-score nil)
      ;; Load the SCORE files.
      (while score-files
!       (setq scores (nconc (gnus-score-load-file (car score-files)) scores))
        (setq score-files (cdr score-files)))
      (if (not (and gnus-summary-default-score
  		  scores
--- 10143,10167 ----
    
  (defun gnus-score-headers ()
    ;; Score `gnus-newsgroup-headers'.
!   (let ((func gnus-score-find-score-files-function)
! 	score-files scores)
!     (and func (not (listp func))
! 	 (setq func (list func)))
!     ;; Go through all the functions for finding score files (or actual
!     ;; scores) and add them to a list.
!     (while func
!       (and (symbolp (car func))
! 	   (fboundp (car func))
! 	   (setq score-files 
! 		 (nconc score-files (funcall (car func) gnus-newsgroup-name))))
!       (setq func (cdr func)))
      ;; PLM: probably this is not the best place to clear orphan-score
      (setq gnus-orphan-score nil)
      ;; Load the SCORE files.
      (while score-files
!       (if (stringp (car score-files))
! 	  (setq scores (nconc (gnus-score-load-file (car score-files)) scores))
! 	(setq scores (nconc (car score-files) scores)))
        (setq score-files (cdr score-files)))
      (if (not (and gnus-summary-default-score
  		  scores
***************
*** 10516,10522 ****
  	  ;; The global score file is placed at top of the directory.
  	  (expand-file-name gnus-score-file-suffix
  			    (or gnus-kill-files-directory "~/News")))
! 	 (gnus-use-long-file-name
  	  ;; Append ".SCORE" to newsgroup name.
  	  (expand-file-name (concat newsgroup "." gnus-score-file-suffix)
  			    (or gnus-kill-files-directory "~/News")))
--- 10591,10597 ----
  	  ;; The global score file is placed at top of the directory.
  	  (expand-file-name gnus-score-file-suffix
  			    (or gnus-kill-files-directory "~/News")))
! 	 ((gnus-use-long-file-name 'not-score)
  	  ;; Append ".SCORE" to newsgroup name.
  	  (expand-file-name (concat newsgroup "." gnus-score-file-suffix)
  			    (or gnus-kill-files-directory "~/News")))
***************
*** 10536,10542 ****
  	 (or gnus-kill-files-directory "~/News/")))
    (if (not (file-readable-p gnus-kill-files-directory))
        (setq gnus-score-file-list nil)
!     (if gnus-use-long-file-name
  	(if (or (not gnus-score-file-list)
  		(gnus-file-newer-than gnus-kill-files-directory
  				      (car gnus-score-file-list)))
--- 10611,10617 ----
  	 (or gnus-kill-files-directory "~/News/")))
    (if (not (file-readable-p gnus-kill-files-directory))
        (setq gnus-score-file-list nil)
!     (if (gnus-use-long-file-name 'not-score)
  	(if (or (not gnus-score-file-list)
  		(gnus-file-newer-than gnus-kill-files-directory
  				      (car gnus-score-file-list)))
***************
*** 10635,10641 ****
        ;; file, and not end up in some global score file.
        (let ((localscore
  	     (expand-file-name
! 	      (if gnus-use-long-file-name
  		  (concat gnus-kill-files-directory group "." 
  			  gnus-score-file-suffix)
  		(concat gnus-kill-files-directory
--- 10710,10716 ----
        ;; 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
***************
*** 10880,10958 ****
  	       (setq subject (read-string "Subject: "))))
  	(setq mail-reply-buffer article-buffer)
  
! 	(setq real-group (and group (gnus-group-real-name group)))
! 	(setq gnus-post-news-buffer 
! 	      (gnus-request-post-buffer 
! 	       post real-group subject header article-buffer
! 	       (nth 2 (and group (gnus-gethash group gnus-newsrc-hashtb)))
! 	       (if (and (boundp 'gnus-followup-to-function)
! 			gnus-followup-to-function)
! 		   (setq follow-to
! 			 (save-excursion
! 			   (set-buffer article-buffer)
! 			   (funcall gnus-followup-to-function group))))
! 	       (eq gnus-use-followup-to t)))
! 	(if post
! 	    (progn
! 	      (gnus-configure-windows '(1 0 0))
! 	      (switch-to-buffer gnus-post-news-buffer))
! 	  (gnus-configure-windows '(0 1 0))
! 	  (if (not yank)
  	      (progn
! 		(switch-to-buffer article-buffer)
! 		(pop-to-buffer gnus-post-news-buffer))
! 	    (switch-to-buffer gnus-post-news-buffer)))
! 	(gnus-overload-functions)
! 	(make-local-variable 'gnus-article-reply)
! 	(make-local-variable 'gnus-article-check-size)
! 	(setq gnus-article-reply sumart)
! 	;; Handle `gnus-auto-mail-to-author'.
! 	;; Suggested by Daniel Quinlan <quinlan@best.com>.
! 	(let ((to (if (eq gnus-auto-mail-to-author 'ask)
! 		      (and (y-or-n-p "Also send mail to author? ") from)
! 		    (and gnus-auto-mail-to-author from))))
! 	  (if to
  	      (progn
! 		(if (mail-fetch-field "To")
! 		    (progn
! 		      (beginning-of-line)
! 		      (insert "Cc: " to "\n"))
! 		  (mail-position-on-field "To")
! 		  (insert to)))))
! 	;; Handle author copy using BCC field.
! 	(if (and gnus-mail-self-blind
! 		 (not (mail-fetch-field "bcc")))
! 	    (progn
! 	      (mail-position-on-field "Bcc")
! 	      (insert (if (stringp gnus-mail-self-blind)
! 			  gnus-mail-self-blind
! 			(user-login-name)))))
! 	;; Handle author copy using FCC field.
! 	(if gnus-author-copy
! 	    (progn
! 	      (mail-position-on-field "Fcc")
! 	      (insert gnus-author-copy)))
! 	(goto-char (point-min))
! 	(if post 
! 	    (cond ((not group)
! 		   (re-search-forward "^Newsgroup:" nil t)
! 		   (end-of-line))
! 		  ((not subject)
! 		   (re-search-forward "^Subject:" nil t)
! 		   (end-of-line))
! 		  (t
! 		   (re-search-forward 
! 		    (concat "^" (regexp-quote mail-header-separator) "$"))
! 		   (forward-line 1)))
! 	  (re-search-forward 
! 	   (concat "^" (regexp-quote mail-header-separator) "$"))
! 	  (forward-line 1)
! 	  (if yank 
! 	      (save-excursion
! 		(run-hooks 'news-reply-header-hook)
! 		(mail-yank-original nil)))
! 	  (if gnus-post-prepare-function
! 	      (funcall gnus-post-prepare-function group)))))
    (setq gnus-article-check-size (cons (buffer-size) (gnus-article-checksum)))
    (message "")
    t)
--- 10955,11034 ----
  	       (setq subject (read-string "Subject: "))))
  	(setq mail-reply-buffer article-buffer)
  
! 	(let ((gnus-newsgroup-name (or group gnus-newsgroup-name "")))
! 	  (setq real-group (and group (gnus-group-real-name group)))
! 	  (setq gnus-post-news-buffer 
! 		(gnus-request-post-buffer 
! 		 post real-group subject header article-buffer
! 		 (nth 2 (and group (gnus-gethash group gnus-newsrc-hashtb)))
! 		 (if (and (boundp 'gnus-followup-to-function)
! 			  gnus-followup-to-function)
! 		     (setq follow-to
! 			   (save-excursion
! 			     (set-buffer article-buffer)
! 			     (funcall gnus-followup-to-function group))))
! 		 (eq gnus-use-followup-to t)))
! 	  (if post
  	      (progn
! 		(gnus-configure-windows '(1 0 0))
! 		(switch-to-buffer gnus-post-news-buffer))
! 	    (gnus-configure-windows '(0 1 0))
! 	    (if (not yank)
! 		(progn
! 		  (switch-to-buffer article-buffer)
! 		  (pop-to-buffer gnus-post-news-buffer))
! 	      (switch-to-buffer gnus-post-news-buffer)))
! 	  (gnus-overload-functions)
! 	  (make-local-variable 'gnus-article-reply)
! 	  (make-local-variable 'gnus-article-check-size)
! 	  (setq gnus-article-reply sumart)
! 	  ;; Handle `gnus-auto-mail-to-author'.
! 	  ;; Suggested by Daniel Quinlan <quinlan@best.com>.
! 	  (let ((to (if (eq gnus-auto-mail-to-author 'ask)
! 			(and (y-or-n-p "Also send mail to author? ") from)
! 		      (and gnus-auto-mail-to-author from))))
! 	    (if to
! 		(progn
! 		  (if (mail-fetch-field "To")
! 		      (progn
! 			(beginning-of-line)
! 			(insert "Cc: " to "\n"))
! 		    (mail-position-on-field "To")
! 		    (insert to)))))
! 	  ;; Handle author copy using BCC field.
! 	  (if (and gnus-mail-self-blind
! 		   (not (mail-fetch-field "bcc")))
  	      (progn
! 		(mail-position-on-field "Bcc")
! 		(insert (if (stringp gnus-mail-self-blind)
! 			    gnus-mail-self-blind
! 			  (user-login-name)))))
! 	  ;; Handle author copy using FCC field.
! 	  (if gnus-author-copy
! 	      (progn
! 		(mail-position-on-field "Fcc")
! 		(insert gnus-author-copy)))
! 	  (goto-char (point-min))
! 	  (if post 
! 	      (cond ((not group)
! 		     (re-search-forward "^Newsgroup:" nil t)
! 		     (end-of-line))
! 		    ((not subject)
! 		     (re-search-forward "^Subject:" nil t)
! 		     (end-of-line))
! 		    (t
! 		     (re-search-forward 
! 		      (concat "^" (regexp-quote mail-header-separator) "$"))
! 		     (forward-line 1)))
! 	    (re-search-forward 
! 	     (concat "^" (regexp-quote mail-header-separator) "$"))
! 	    (forward-line 1)
! 	    (if yank 
! 		(save-excursion
! 		  (run-hooks 'news-reply-header-hook)
! 		  (mail-yank-original nil)))
! 	    (if gnus-post-prepare-function
! 		(funcall gnus-post-prepare-function group))))))
    (setq gnus-article-check-size (cons (buffer-size) (gnus-article-checksum)))
    (message "")
    t)
***************
*** 11281,11288 ****
         (save-excursion
  	 (re-search-forward 
  	  (concat "^" (regexp-quote mail-header-separator) "$"))
! 	 (forward-line -1) 
! 	 (point)))
        (gnus-inews-insert-headers)
        (run-hooks gnus-inews-article-header-hook)
        (widen))
--- 11357,11363 ----
         (save-excursion
  	 (re-search-forward 
  	  (concat "^" (regexp-quote mail-header-separator) "$"))
! 	 (match-beginning 0)))
        (gnus-inews-insert-headers)
        (run-hooks gnus-inews-article-header-hook)
        (widen))
***************
*** 12925,12930 ****
--- 13000,13006 ----
  			       (concat " from " where) "")
  			   (car (car methods)))))
  	(message mesg)
+ 	(gnus-check-news-server (car methods))
  	(if (gnus-request-list (car methods)) ; Get active 
  	    (save-excursion
  	      (set-buffer nntp-server-buffer)
***************
*** 13197,13203 ****
  			       (substring gnus-newsrc-options
  					  (match-beginning 1)
  					  (match-end 1))))))
!     (gnus-parse-n-options result)
      nil))
  
  (defun gnus-parse-newsrc-body ()
--- 13273,13280 ----
  			       (substring gnus-newsrc-options
  					  (match-beginning 1)
  					  (match-end 1))))))
! 
!     (and result (gnus-parse-n-options result))
      nil))
  
  (defun gnus-parse-newsrc-body ()
diff --exclude=*.elc --exclude=*~ --exclude=*-[0-9] --exclude=gnus --exclude=readme --context --recursive pub/dgnus/lisp/nnfolder.el dgnus/lisp/nnfolder.el
*** pub/dgnus/lisp/nnfolder.el	Fri Apr 14 16:47:46 1995
--- dgnus/lisp/nnfolder.el	Fri Apr 14 08:39:36 1995
***************
*** 26,31 ****
--- 26,33 ----
  ;; For an overview of what the interface functions do, please see the
  ;; Gnus sources.  
  
+ ;; Various enhancements by byer@mv.us.adobe.com (Scott Byer).
+ 
  ;;; Code:
  
  (require 'nnheader)
***************
*** 49,60 ****
--- 51,68 ----
  (defconst nnfolder-version "nnfolder 0.1"
    "nnfolder version.")
  
+ (defconst nnfolder-article-marker "X-Gnus-Article-Number: "
+   "String used to demarcate what the article number for a message is.")
+ 
  (defvar nnfolder-current-group nil)
  (defvar nnfolder-current-buffer nil)
  (defvar nnfolder-status-string "")
  (defvar nnfolder-group-alist nil)
  (defvar nnfolder-buffer-alist nil)
  
+ (defmacro nnfolder-article-string (article)
+   (` (concat "\n" nnfolder-article-marker (int-to-string (, article)) "")))
+ 
  ;;; Interface functions
  
  (defun nnfolder-retrieve-headers (sequence &optional newsgroup server)
***************
*** 63,68 ****
--- 71,77 ----
      (erase-buffer)
      (let ((file nil)
  	  (number (length sequence))
+ 	  (delim-string (concat "^" rmail-unix-mail-delimiter))
  	  beg article art-string start stop)
        (nnfolder-possibly-change-group newsgroup)
        (while sequence
***************
*** 70,83 ****
  	(setq art-string (nnfolder-article-string article))
  	(set-buffer nnfolder-current-buffer)
  	(if (or (search-forward art-string nil t)
! 		(progn (goto-char 1)
! 		       (search-forward art-string nil t)))
  	    (progn
! 	      (setq start 
! 		    (save-excursion
! 		      (re-search-backward 
! 		       (concat "^" rmail-unix-mail-delimiter) nil t)
! 		      (point)))
  	      (search-forward "\n\n" nil t)
  	      (setq stop (1- (point)))
  	      (set-buffer nntp-server-buffer)
--- 79,92 ----
  	(setq art-string (nnfolder-article-string article))
  	(set-buffer nnfolder-current-buffer)
  	(if (or (search-forward art-string nil t)
! 		;; Don't search the whole file twice!  Also, articles
! 		;; probably have some locality by number, so searching
! 		;; backwards will be faster.  Especially if we're at the
! 		;; beginning of the buffer :-). -SLB
! 		(search-backward art-string nil t))
  	    (progn
! 	      (setq start (or (re-search-backward delim-string nil t)
! 			      (point)))
  	      (search-forward "\n\n" nil t)
  	      (setq stop (1- (point)))
  	      (set-buffer nntp-server-buffer)
***************
*** 89,94 ****
--- 98,104 ----
  	(setq sequence (cdr sequence)))
  
        ;; Fold continuation lines.
+       (set-buffer nntp-server-buffer)
        (goto-char 1)
        (while (re-search-forward "\\(\r?\n[ \t]+\\)+" nil t)
  	(replace-match " " t t))
***************
*** 102,107 ****
--- 112,125 ----
  (defun nnfolder-close-server (&optional server)
    t)
  
+ (defun nnfolder-request-close ()
+   (let ((alist nnfolder-buffer-alist))
+     (while alist
+       (nnfolder-close-group (car (car alist)))
+       (setq alist (cdr alist))))
+   (setq nnfolder-buffer-alist nil
+ 	nnfolder-group-alist nil))
+ 
  (defun nnfolder-server-opened (&optional server)
    (and nntp-server-buffer
         (buffer-name nntp-server-buffer)))
***************
*** 148,153 ****
--- 166,174 ----
  	       t
  	     (nnfolder-get-new-mail)
  	     (let ((active (assoc group nnfolder-group-alist)))
+ 	       ;; I've been getting stray 211 lines in my nnfolder active
+ 	       ;; file.  So, let's make sure that doesn't happen. -SLB
+ 	       (set-buffer nntp-server-buffer)
  	       (insert (format "211 %d %d %d %s\n" 
  			       (1+ (- (cdr (car (cdr active)))
  				      (car (car (cdr active)))))
***************
*** 157,167 ****
  	     t)))))
  
  (defun nnfolder-close-group (group &optional server)
    t)
  
  (defun nnfolder-request-list (&optional server)
    (if server (nnfolder-get-new-mail))
!   (or (nnmail-find-file nnfolder-active-file)
        (progn
  	(setq nnfolder-group-alist (nnmail-get-active))
  	(nnmail-save-active nnfolder-group-alist nnfolder-active-file)
--- 178,198 ----
  	     t)))))
  
  (defun nnfolder-close-group (group &optional server)
+   (nnfolder-possibly-change-group group)
+   (save-excursion
+     (set-buffer nnfolder-current-buffer)
+     (or (buffer-modified-p)
+ 	(kill-buffer (current-buffer))))
+   (setq nnfolder-buffer-alist (delq (assoc group nnfolder-buffer-alist)
+ 				    nnfolder-buffer-alist))
+   (setq nnfolder-current-group nil
+ 	nnfolder-current-buffer nil)
    t)
  
  (defun nnfolder-request-list (&optional server)
    (if server (nnfolder-get-new-mail))
!   (or nnfolder-group-alist
!       (nnmail-find-file nnfolder-active-file)
        (progn
  	(setq nnfolder-group-alist (nnmail-get-active))
  	(nnmail-save-active nnfolder-group-alist nnfolder-active-file)
***************
*** 207,213 ****
  	(goto-char (point-min))
  	(while (not (search-forward
  		     (nnfolder-article-string (car active)) nil t))
! 	  (setcar (car active) (1+ (car active)))
  	  (goto-char (point-min))))
        (nnmail-save-active nnfolder-group-alist nnfolder-active-file)
        rest)))
--- 238,244 ----
  	(goto-char (point-min))
  	(while (not (search-forward
  		     (nnfolder-article-string (car active)) nil t))
! 	  (setcar active (1+ (car active)))
  	  (goto-char (point-min))))
        (nnmail-save-active nnfolder-group-alist nnfolder-active-file)
        rest)))
***************
*** 338,346 ****
  					    nnfolder-buffer-alist))))))
    (setq nnfolder-current-group group))
  
- (defun nnfolder-article-string (article)
-   (concat "\nX-Gnus-Article-Number: " (int-to-string article) " "))
- 
  (defun nnfolder-save-mail (&optional group)
    "Called narrowed to an article."
    (let* ((nnmail-split-methods 
--- 369,374 ----
***************
*** 363,369 ****
  	  (goto-char (point-max))
  	  (insert-buffer-substring obuf beg end)))
        (goto-char (point-min))
!       (search-forward "\nX-Gnus-Article-Number: ")
        (delete-region (progn (beginning-of-line) (point))
  		     (progn (forward-line 1) (point))))))
  
--- 391,397 ----
  	  (goto-char (point-max))
  	  (insert-buffer-substring obuf beg end)))
        (goto-char (point-min))
!       (search-forward (concat "\n" nnfolder-article-marker))
        (delete-region (progn (beginning-of-line) (point))
  		     (progn (forward-line 1) (point))))))
  
***************
*** 373,417 ****
      (if (search-forward "\n\n" nil t)
  	(progn
  	  (forward-char -1)
! 	  (insert (format "X-Gnus-Article-Number: %d   %s\n" 
  			  (cdr group-art) (current-time-string)))))))
  
  (defun nnfolder-active-number (group)
    (let ((active (car (cdr (assoc group nnfolder-group-alist)))))
      (setcdr active (1+ (cdr active)))
      (cdr active)))
  
  (defun nnfolder-read-folder (file)
-   (nnfolder-request-list)
-   (setq nnfolder-group-alist (nnmail-get-active))
    (save-excursion
!     (set-buffer
!      (setq nnfolder-current-buffer 
! 	   (find-file-noselect file)))
      (buffer-disable-undo (current-buffer))
      (let ((delim (concat "^" rmail-unix-mail-delimiter))
! 	  start end)
        (goto-char (point-min))
!       (while (re-search-forward delim nil t)
! 	(setq start (match-beginning 0))
! 	(if (not (search-forward "\nX-Gnus-Article-Number: " 
! 				 (save-excursion 
! 				   (setq end
! 					 (or
! 					  (and
! 					   (re-search-forward delim nil t)
! 					   (match-beginning 0))
! 					  (point-max))))
! 				 t))
! 	    (save-excursion
! 	      (save-restriction
! 		(narrow-to-region start end)
! 		(nnmail-insert-lines)
! 		(nnfolder-insert-newsgroup-line 
! 		 (cons nil (nnfolder-active-number nnfolder-current-group))))))
! 	(goto-char end)))
!     (nnmail-save-active nnfolder-group-alist nnfolder-active-file)
!     (current-buffer)))
  
  (defun nnfolder-get-new-mail ()
    (let (incoming)
--- 401,492 ----
      (if (search-forward "\n\n" nil t)
  	(progn
  	  (forward-char -1)
! 	  (insert (format (concat nnfolder-article-marker "%d   %s\n")
  			  (cdr group-art) (current-time-string)))))))
  
  (defun nnfolder-active-number (group)
+   (if (not nnfolder-group-alist)
+       (save-excursion
+ 	(nnfolder-request-list)
+ 	(setq nnfolder-group-alist (nnmail-get-active))))
    (let ((active (car (cdr (assoc group nnfolder-group-alist)))))
      (setcdr active (1+ (cdr active)))
      (cdr active)))
  
+ 
+ ;; This method has a problem if you've accidentally let the active list get
+ ;; out of sync with the files.  This could happen, say, if you've
+ ;; accidentally gotten new mail with something other than (ding) (but why
+ ;; would _that_ ever happen? :-).  In that case, we will be in the middle of
+ ;; processing the file, ready to add new X-Gnus article number markers, and
+ ;; we'll run accross a message with no ID yet - the active list _may_not_ be
+ ;; ready for us yet.
+ 
+ ;; To handle this, I'm modifying this routine to maintain the maximum ID seen
+ ;; so far, and when we hit a message with no ID, we will _manually_ scan the
+ ;; rest of the message looking for any more, possibly higher IDs.  We'll
+ ;; assume the maximum that we find is the highest active.  Note that this
+ ;; shouldn't cost us much extra time at all, but will be a lot less
+ ;; vulnerable to glitches between the mbox and the active file.
+ 
  (defun nnfolder-read-folder (file)
    (save-excursion
!     (if (not nnfolder-group-alist)
! 	(progn
! 	  (nnfolder-request-list)
! 	  (setq nnfolder-group-alist (nnmail-get-active))))
!     ;; We should be paranoid here and make sure the group is in the alist,
!     ;; and add it if it isn't.
!     ;;(if (not (assoc nnfoler-current-group nnfolder-group-alist)
!     (set-buffer (setq nnfolder-current-buffer (find-file-noselect file)))
      (buffer-disable-undo (current-buffer))
      (let ((delim (concat "^" rmail-unix-mail-delimiter))
! 	  (marker (concat "\n" nnfolder-article-marker))
! 	  (number "[0-9]+")
! 	  (active (car (cdr (assoc nnfolder-current-group 
! 				   nnfolder-group-alist))))
! 	  activenumber start end)
        (goto-char (point-min))
!       ;;
!       ;; Anytime the active number is 1 or 0, it is supect.  In that case,
!       ;; search the file manually to find the active number.
!       (setq activenumber (cdr active))
!       (if (< activenumber 2)
! 	  (progn
! 	    (while (and (search-forward marker nil t)
! 			(re-search-forward number nil t))
! 	      (setq activenumber (max activenumber
! 				      (string-to-number (buffer-substring
! 							 (match-beginning 0)
! 							 (match-end 0))))))
! 	    (goto-char (point-min))))
! 
!       ;; Keep track of the active number on our own, and insert it back into
!       ;; the active list when we're done. Also, prime the pump to cut down on
!       ;; the number of searches we do.
!       (setq end (or (and (re-search-forward delim nil t)
! 			 (match-beginning 0))
! 		    (point-max)))
!       (while (not (= end (point-max)))
! 	(setq start end)
! 	(goto-char end)
! 	(end-of-line)
! 	(setq end (or (and (re-search-forward delim nil t)
! 			   (match-beginning 0))
! 		      (point-max)))
! 	(goto-char start)
! 	(if (not (search-forward marker end t))
! 	    (progn
! 	      (narrow-to-region start end)
! 	      (nnmail-insert-lines)
! 	      (setq activenumber (1+ activenumber))
! 	      (nnfolder-insert-newsgroup-line (cons nil activenumber))
! 	      (widen))))
! 
!       ;; Make absolutely sure that the active list reflects reality!
!       (setcdr active activenumber)
!       (nnmail-save-active nnfolder-group-alist nnfolder-active-file)
!       (current-buffer))))
  
  (defun nnfolder-get-new-mail ()
    (let (incoming)
diff --exclude=*.elc --exclude=*~ --exclude=*-[0-9] --exclude=gnus --exclude=readme --context --recursive pub/dgnus/lisp/nnml.el dgnus/lisp/nnml.el
*** pub/dgnus/lisp/nnml.el	Fri Apr 14 16:47:46 1995
--- dgnus/lisp/nnml.el	Sat Apr 15 22:09:29 1995
***************
*** 416,421 ****
--- 416,425 ----
  (defun nnml-active-number (group)
    "Compute the next article number in GROUP."
    (let ((active (car (cdr (assoc group nnml-group-alist)))))
+     (or active
+ 	(progn
+ 	  (setq active (cons 1 0))
+ 	  (setq nnml-group-alist (cons (list group active) nnml-group-alist))))
      (setcdr active (1+ (cdr active)))
      (let (file)
        (while (file-exists-p
diff --exclude=*.elc --exclude=*~ --exclude=*-[0-9] --exclude=gnus --exclude=readme --context --recursive pub/dgnus/lisp/nntp.el dgnus/lisp/nntp.el
*** pub/dgnus/lisp/nntp.el	Fri Apr 14 16:47:46 1995
--- dgnus/lisp/nntp.el	Fri Apr 14 08:05:03 1995
***************
*** 116,121 ****
--- 116,122 ----
  (defvar nntp-current-server "")
  (defvar nntp-server-alist nil)
  (defvar nntp-server-xover t)
+ (defvar nntp-server-list-active-group t)
  (defvar nntp-current-group "")
  
  ;;; Interface funtions.
***************
*** 234,239 ****
--- 235,248 ----
  
  (fset 'nntp-request-quit (symbol-function 'nntp-close-server))
  
+ (defun nntp-request-close ()
+   "Close all server connections."
+   (while nntp-server-alist
+     (delete-process (car (cdr (car nntp-server-alist))))
+     (setq nntp-server-alist (cdr nntp-server-alist)))
+   (setq nntp-current-server "")
+   (setq nntp-server-process nil))
+ 
  (defun nntp-server-opened (&optional server)
    "Say whether a connection to SERVER has been opened."
    (if (or server nntp-current-server)
***************
*** 291,298 ****
  
  (defun nntp-request-group (group &optional server dont-check)
    "Select GROUP."
!   (if (nntp-possibly-change-server nil server)
!       (nntp-send-command "^.*\r$" "GROUP" group)))
  
  (defun nntp-list-active-group (group &optional server)
    (nntp-send-command "^.*\r$" "LIST ACTIVE" group))
--- 300,343 ----
  
  (defun nntp-request-group (group &optional server dont-check)
    "Select GROUP."
!   (if (not (nntp-possibly-change-server nil server))
!       ()
!     (if dont-check
! 	(nntp-send-command "^.*\r$" "GROUP" group)
!       (if nntp-server-list-active-group
! 	  (save-excursion
! 	    (nntp-list-active-group group server)
! 	    (set-buffer nntp-server-buffer)
! 	    (goto-char (point-min))
! 	    ;; We look at the output from `nntp-list-active-group' to
! 	    ;; see whether the server supports this command.  If it
! 	    ;; does, we transform the output.  
! 	    (cond ((looking-at "2[0-9]+")
! 		   (forward-line 1)
! 		   (if (looking-at "[^ ] +\\([0-9]\\) +\\([0-9]\\)")
! 		       (let ((end (progn (goto-char (match-beginning 1))
! 					 (read (current-buffer))))
! 			     (beg (read (current-buffer))))
! 			 (and (> beg end)
! 			      (setq end 0
! 				    beg 0))
! 			 (erase-buffer)
! 			 (insert (format "211 %s %d %d %d\n"
! 					 group (max (- (1+ end) beg) 0)
! 					 beg end)))))
! 		  ;; The server does not support the command.
! 		  ((looking-at "5[0-9]+")
! 		   (setq nntp-server-list-active-group nil)
! 		   (setcar (nthcdr 
! 			    3 (assoc nntp-current-server nntp-server-alist))
! 			   nntp-server-xover)
! 		   (nntp-send-command "^.*\r$" "GROUP" group))
! 		  ;; The server supports it, but the group doesn't
! 		  ;; exist. 
! 		  ((looking-at "4[0-9]+")
! 		   (erase-buffer)
! 		   nil)))
! 	(nntp-send-command "^.*\r$" "GROUP" group)))))
  
  (defun nntp-list-active-group (group &optional server)
    (nntp-send-command "^.*\r$" "LIST ACTIVE" group))
***************
*** 707,714 ****
  	    ;; Suggested by Hallvard B Furuseth <h.b.furuseth@usit.uio.no>.
  	    (process-kill-without-query proc)
  	    (setq nntp-server-xover t)
  	    (setq nntp-server-name server)
! 	    (setq nntp-server-alist (cons (list server nntp-server-process t)
  					  nntp-server-alist))
  	    ;; It is possible to change kanji-fileio-code in this hook.
  	    (run-hooks 'nntp-server-hook)
--- 752,760 ----
  	    ;; Suggested by Hallvard B Furuseth <h.b.furuseth@usit.uio.no>.
  	    (process-kill-without-query proc)
  	    (setq nntp-server-xover t)
+ 	    (setq nntp-server-list-active-group t)
  	    (setq nntp-server-name server)
! 	    (setq nntp-server-alist (cons (list server nntp-server-process t t)
  					  nntp-server-alist))
  	    ;; It is possible to change kanji-fileio-code in this hook.
  	    (run-hooks 'nntp-server-hook)
***************
*** 724,737 ****
  				nntp-server-alist))
    (setq nntp-current-server ""))
  
- (defun nntp-request-close ()
-   "Close all server connections."
-   (while nntp-server-alist
-     (delete-process (car (cdr (car nntp-server-alist))))
-     (setq nntp-server-alist (cdr nntp-server-alist)))
-   (setq nntp-current-server "")
-   (setq nntp-server-process nil))
- 
  (defun nntp-accept-response ()
    "Read response of server.
  It is well-known that the communication speed will be much improved by
--- 770,775 ----
***************
*** 783,788 ****
--- 821,827 ----
  		(setq nntp-server-name server)
  		(setq nntp-server-process (nth 1 info))
  		(setq nntp-server-xover (nth 2 info))
+ 		(setq nntp-server-list-active-group (nth 3 info))
  		(setq changed-server t)
  		(setq result t))))
        (setq result t))
diff --exclude=*.elc --exclude=*~ --exclude=*-[0-9] --exclude=gnus --exclude=readme --context --recursive pub/dgnus/texi/gnus.texi dgnus/texi/gnus.texi
*** pub/dgnus/texi/gnus.texi	Fri Apr 14 16:47:50 1995
--- dgnus/texi/gnus.texi	Sat Apr 15 23:18:45 1995
***************
*** 1,7 ****
  \input texinfo                  @c -*-texinfo-*-
  @comment %**start of header (This is for running Texinfo on a region.)
  @setfilename gnus
! @settitle (ding) Gnus 0.41 Manual
  @synindex fn cp
  @synindex vr cp
  @synindex pg cp
--- 1,7 ----
  \input texinfo                  @c -*-texinfo-*-
  @comment %**start of header (This is for running Texinfo on a region.)
  @setfilename gnus
! @settitle Gnus 0.50 Manual
  @synindex fn cp
  @synindex vr cp
  @synindex pg cp
***************
*** 18,24 ****
  
  @ifinfo
  
! This file documents (ding) Gnus, the GNU Emacs newsreader.
  
  Copyright (C) 1989, 1990, 1993, 1995 Free Software Foundation, Inc.
  
--- 18,24 ----
  
  @ifinfo
  
! This file documents Gnus, the GNU Emacs newsreader.
  
  Copyright (C) 1989, 1990, 1993, 1995 Free Software Foundation, Inc.
  
***************
*** 43,49 ****
  @end ifinfo
  
  @titlepage
! @title (ding) Gnus Manual
  
  @author by Lars Magne Ingebrigtsen
  @page
--- 43,49 ----
  @end ifinfo
  
  @titlepage
! @title Gnus Manual
  
  @author by Lars Magne Ingebrigtsen
  @page
***************
*** 69,78 ****
  @node Top
  @top The Gnus Newsreader
  
! You can read news (and mail) from within Emacs by using (ding) Gnus.
! The news can be gotten by any nefarious means you can think of - NNTP,
! local spool or your mbox file.  All at the same time, if you want to
! push your luck.
  
  @menu
  * History::                 How Gnus got where it is today.
--- 69,78 ----
  @node Top
  @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.
  
  @menu
  * History::                 How Gnus got where it is today.
***************
*** 96,107 ****
  @chapter History
  
  @cindex history
! @sc{GNUS} was written by Masanobu UMEDA.  When autumn crept up in '94,
! Lars Magne Ingebrigtsen grew bored and decided to write (ding) Gnus.
! 
! (ding) Gnus is based on @sc{GNUS 4.1} and includes excellent functions
! from Per Abrahamsen, lots of fixes by Sudish Joseph, as well as bits and
! pieces from the XGnus distribution by Felix Lee and JWZ.
  
  The recommended pronounciation of the name this program is "ding
  guh-noose", with "ding" being half-sung in a loud, high-pitched voice,
--- 96,103 ----
  @chapter History
  
  @cindex history
! @sc{gnus} was written by Masanobu UMEDA.  When autumn crept up in '94,
! Lars Magne Ingebrigtsen grew bored and decided to rewrite Gnus.
  
  The recommended pronounciation of the name this program is "ding
  guh-noose", with "ding" being half-sung in a loud, high-pitched voice,
***************
*** 122,128 ****
  which makes it a more appropriate name, don't you think?)
  
  @menu
! * Compatibility::       Just how compatible is (ding) Gnus with @sc{GNUS}?
  * Gnus & hilit::        Old hilit19 code will not work with (ding) Gnus.
  * New Features::        A short description of all the new stuff in Gnus.
  * Newest Features::     Features so new that they haven't been written yet.
--- 118,125 ----
  which makes it a more appropriate name, don't you think?)
  
  @menu
! * Compatibility::       Just how compatible is (ding) Gnus with @sc{gnus}?
! * Contributors::        Oodles of people.  
  * Gnus & hilit::        Old hilit19 code will not work with (ding) Gnus.
  * New Features::        A short description of all the new stuff in Gnus.
  * Newest Features::     Features so new that they haven't been written yet.
***************
*** 132,146 ****
  @section Compatibility
  
  @cindex compatability
! (ding) Gnus was designed to be fully compatible with @sc{GNUS}.  Almost
! all key binding have been kept.  More key binding have been added, of
! course, but only in one or two obscure cases have key bindings been
  changed.
  
  Our motto is:
  @quotation
  @cartouche
! In a cloud bones of steel.
  @end cartouche
  @end quotation
  
--- 129,143 ----
  @section Compatibility
  
  @cindex compatability
! (ding) Gnus was designed to be fully compatible with @sc{gnus}.  Almost
! all key bindings have been kept.  More key bindings have been added, of
! course, but only in one or two obscure cases have old bindings been
  changed.
  
  Our motto is:
  @quotation
  @cartouche
! @center In a cloud bones of steel.
  @end cartouche
  @end quotation
  
***************
*** 151,163 ****
  Articles}. 
  
  One major compatability question if the presence of several summary
! buffers.  The variables that are relevant while reading a group are
  buffer-local to the summary buffer they belong in.  Although most
  important variables have their values copied into their global
  counterparts whenever a command is executed in the summary buffer, this
! might lead to incorrect values being used if one is not careful.
  
! All code that relies on knowledge of @sc{GNUS} internals will probably
  fail.  To take two examples: Sorting @code{gnus-newsrc-assoc} (or
  changing it in any way, as a matter of fact) is strictly verboten.  Gnus
  maintains a hash table that points to the entries in this assoc (which
--- 148,160 ----
  Articles}. 
  
  One major compatability question if the presence of several summary
! buffers.  All variables that are relevant while reading a group are
  buffer-local to the summary buffer they belong in.  Although most
  important variables have their values copied into their global
  counterparts whenever a command is executed in the summary buffer, this
! change might lead to incorrect values being used unless you are careful.
  
! All code that relies on knowledge of @sc{gnus} internals will probably
  fail.  To take two examples: Sorting @code{gnus-newsrc-assoc} (or
  changing it in any way, as a matter of fact) is strictly verboten.  Gnus
  maintains a hash table that points to the entries in this assoc (which
***************
*** 167,182 ****
  @cindex hilit19
  @cindex highlighting
  Old hilit19 code does not work at all.  In fact, you should probably
! remove all hihit code from all the Gnus hooks
  (@code{gnus-group-prepare-hook}, @code{gnus-summary-prepare-hook} and
  @code{gnus-summary-article-hook}).  (Well, at the very least the first
! two.)  Gnus provides various integrated functions for highlighting,
! which are both faster and more accurated. 
  
  Packages like @code{expire-kill} will no longer work.  As a matter of
! fact, you should probably remove all old @sc{GNUS} packages (and other
  code) when you start using (ding) Gnus.  More likely than not, (ding)
! Gnus already do what you have written code to make @sc{GNUS} do.
  (Snicker.)
  
  Even though old methods of doing things are still supported, only the
--- 164,179 ----
  @cindex hilit19
  @cindex highlighting
  Old hilit19 code does not work at all.  In fact, you should probably
! remove all hihit code from all Gnus hooks
  (@code{gnus-group-prepare-hook}, @code{gnus-summary-prepare-hook} and
  @code{gnus-summary-article-hook}).  (Well, at the very least the first
! two.)  Gnus provides various integrated functions for highlighting.
! These are faster and more accurate.
  
  Packages like @code{expire-kill} will no longer work.  As a matter of
! fact, you should probably remove all old @sc{gnus} packages (and other
  code) when you start using (ding) Gnus.  More likely than not, (ding)
! Gnus already does what you have written code to make @sc{gnus} do.
  (Snicker.)
  
  Even though old methods of doing things are still supported, only the
***************
*** 184,196 ****
  doing something while reading this manual, that does not mean you have
  to stop doing it the old way.
  
! (ding) Gnus understands all @sc{GNUS} startup files.
  
  @kindex M-x gnus-bug
  Overall, a casual user who hasn't written much code that depends on
! @sc{GNUS} internals should suffer no problems.  If problems occur,
  please let me know (@kbd{M-x gnus-bug}).
  
  @node Gnus & hilit
  @section Gnus & hilit
  @cindex hilit
--- 181,236 ----
  doing something while reading this manual, that does not mean you have
  to stop doing it the old way.
  
! (ding) Gnus understands all @sc{gnus} startup files.
  
  @kindex M-x gnus-bug
  Overall, a casual user who hasn't written much code that depends on
! @sc{gnus} internals should suffer no problems.  If problems occur,
  please let me know (@kbd{M-x gnus-bug}).
  
+ Problems specific to GNU XEmacs can be reported to popineau@@ese-metz.fr
+ (Fabrice Popineau).  I will just forward any such questions to him,
+ anyway, so you might have to wait longer if you mail XEmacs questions to
+ me.
+ 
+ @node Contributors
+ @section Contributors
+ @cindex contributors
+ 
+ The new Gnus version couldn't have been done without the help of all the
+ people on the (ding) mailing list.  Every day for months I have gotten
+ tens of nice bug reports from them, filling me with joy, every single
+ one of them.  Smooches.
+ 
+ I would like to take this opportunity to thank the Academy for...  oops,
+ wrong show.
+ 
+ @itemize @bullet
+ @item
+ Of course, GNUS was written by Masanobu UMEDA.
+ @item 
+ Many excellent functions, especially dealing with scoring and
+ highlighting (as well as the soon-to-come @sc{soup} support) was written
+ by Per Abrahamsen.
+ @item
+ Innumarable bug fixes were written by Sudish Joseph.
+ @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 
+ Stainless Steel Rat, Brian Edmonds, Jack Vinson, Daniel Quinlan, Ilja
+ Weis, Andrew Eskilsson have all contributed code and suggestions. 
+ @end itemize
+ 
+ 
  @node Gnus & hilit
  @section Gnus & hilit
  @cindex hilit
***************
*** 199,220 ****
  
  @code{gnus-visual} can be used to highlight the summary buffer.  It
  offers far more flexibility than hilit (since it has access to more
! data; for eg., the article score) in deciding how to highlight a given
! article.  Also, highlight gets confused by the way Gnus manipulates the
  summary buffer, leading to errors.  Such errors may be detected by
! looking for any hilit-specific functions in a *Backtrace* buffer.  If
! such a reference exists, you should be using the code below.
  
  On the other hand, @code{gnus-visual} makes no attempt to highlight the
  article buffer, while hilit does a very good job of this.  There is a
  compatibility problem here though, since hilit uses
! gnus-article-prepare-hook to do its magic.  This hook is executed
  @emph{before} headers are hidden, via
  @code{gnus-article-hide-headers-if-wanted} which is run from
  @code{gnus-article-display-hook}.  The act of hiding the headers undoes
  all of the hilighting already done.  A similar effect occured in vanilla
! @sc{GNUS 4.1} if @code{gnus-show-mime} was set to @code{t}, since
! @sc{mime} processing too is done after this hook is executed.
  
  The solution here is to use @code{gnus-article-display-hook} for
  highlighting (and for all purposes where you used
--- 239,260 ----
  
  @code{gnus-visual} can be used to highlight the summary buffer.  It
  offers far more flexibility than hilit (since it has access to more
! data; eg. the article score) in deciding how to highlight a given
! article.  Also, hilit gets confused by the way Gnus manipulates the
  summary buffer, leading to errors.  Such errors may be detected by
! looking for any hilit-specific functions in the @code{*Backtrace*}
! buffer.  If such a reference exists, you should be using the code below.
  
  On the other hand, @code{gnus-visual} makes no attempt to highlight the
  article buffer, while hilit does a very good job of this.  There is a
  compatibility problem here though, since hilit uses
! @code{gnus-article-prepare-hook} to do its magic.  This hook is executed
  @emph{before} headers are hidden, via
  @code{gnus-article-hide-headers-if-wanted} which is run from
  @code{gnus-article-display-hook}.  The act of hiding the headers undoes
  all of the hilighting already done.  A similar effect occured in vanilla
! @sc{gnus 4.1} if @code{gnus-show-mime} was set to @code{t}, since
! @sc{mime} processing, too, is done after this hook is executed.
  
  The solution here is to use @code{gnus-article-display-hook} for
  highlighting (and for all purposes where you used
***************
*** 248,254 ****
  
  The look of all buffers can be changed by setting format-like variables.
   
! Local spool and several NNTP servers can be used at once.  Virtual
  groups and private mail groups are featured.
  
  Gnus can use various strategies for gathering threads that have lost
--- 288,294 ----
  
  The look of all buffers can be changed by setting format-like variables.
   
! Local spool and several @sc{nntp} servers can be used at once.  Virtual
  groups and private mail groups are featured.
  
  Gnus can use various strategies for gathering threads that have lost
***************
*** 284,307 ****
  however, could possibly be included much sooner, as it is a separate
  issue. 
  @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.  (ding) might
! support @sc{MIME} quite soon, and it might not.
  @item 
  Some form of caching would come in handy.  Not only for those with
! extremely slow @sc{NNTP} connections, but as a more general way of
! saving articles in a simple fashion.  (You'd basically just mark is as
! @dfn{cached}, Gnus would put it in some local directory, and each time
! you request that article from that group, Gnus would fetch the local
! copy instead.)  Lots of quite interesting stuff to be considered
  (caching @sc{nov} headers or not?) before jumping into it.  It would
  require much twiddling of Gnus internals to make it work transparently.
  @item
! Gnus could detect what articles in a newsgroup you read and which
! articles you kill, and then employ some adaptive scoring scheme.  That
! could potentially be quite interesting, and it's easy enough to
! implement. 
  @item
  When the user references the parent of an article, some sort of
  re-threading should be done to build a proper tree.  The same goes for
--- 324,346 ----
  however, could possibly be included much sooner, as it is a separate
  issue. 
  @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.  (ding) might
! support @sc{mime} quite soon, and it might not.
  @item 
  Some form of caching would come in handy.  Not only for those with
! extremely slow @sc{nntp} connections, but as a more general way of
! saving articles in a simple fashion.  (You'd basically just mark an
! article as @dfn{cached}.  Gnus would put it in some local directory, and
! each time you request that article from that group, Gnus would fetch the
! local copy instead.)  Lots of quite interesting stuff to be considered
  (caching @sc{nov} headers or not?) before jumping into it.  It would
  require much twiddling of Gnus internals to make it work transparently.
  @item
! Gnus could detect which articles in you read and which articles you
! kill, and then employ some adaptive scoring scheme.  That could
! potentially be quite interesting, and it's easy enough to implement.
  @item
  When the user references the parent of an article, some sort of
  re-threading should be done to build a proper tree.  The same goes for
***************
*** 314,327 ****
  @chapter Terminology
  
  @cindex terminology
! @itemize @bullet
  @item news
  @cindex news
  This is what you are supposed to use this thing for - reading news.
! News is generally fetched from a nearby 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 snigger
! mischievously.  Behind your back.
  @item mail
  @cindex mail
  Everything that's delivered to you personally is mail.  Some news/mail
--- 353,366 ----
  @chapter Terminology
  
  @cindex terminology
! @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
! snigger mischievously.  Behind your back.
  @item mail
  @cindex mail
  Everything that's delivered to you personally is mail.  Some news/mail
***************
*** 349,356 ****
  @item headers
  @cindex headers
  A collection of such lines, or a collection of heads.  Or even a
! collection of @sc{NOV} lines.
! @item @sc{NOV}
  @cindex nov
  When Gnus enters a group, it asks the backend for the headers for all
  the unread articles in the group.  Most servers support the News OverView
--- 388,395 ----
  @item headers
  @cindex headers
  A collection of such lines, or a collection of heads.  Or even a
! collection of @sc{nov} lines.
! @item @sc{nov}
  @cindex nov
  When Gnus enters a group, it asks the backend for the headers for all
  the unread articles in the group.  Most servers support the News OverView
***************
*** 364,377 ****
  "subscribed"; 6-7 are "unsubscribed"; 8 are zombies; and 9 are killed.
  Commands for listing groups and scanning for new articles will all use
  the numeric prefix as @dfn{working level}.  
! @end itemize
  
  @node Starting Up
  @chapter Starting Gnus
  @cindex starting up
  
  @kindex M-x gnus
! If your system administrator has set thing 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
--- 403,420 ----
  "subscribed"; 6-7 are "unsubscribed"; 8 are zombies; and 9 are killed.
  Commands for listing groups and scanning for new articles will all use
  the numeric prefix as @dfn{working level}.  
! @item active file
! The news server has to keep track of what articles it carries, and what
! groups exist.  All this information in stored in the active file, which
! is rather large, as you might surmise.
! @end table
  
  @node Starting Up
  @chapter Starting Gnus
  @cindex starting up
  
  @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
***************
*** 397,404 ****
  the second element says "where".  This method is is your native method.
  All groups that are not fetched with this method are foreign groups.
  
! For instance, if you want to get your daily dosage of news from the NNTP
! server "news.friendly.server", you'd say:
  
  @lisp
  (setq gnus-select-method '(nntp "news.friendly.server"))
--- 440,447 ----
  the second element says "where".  This method is is your native method.
  All groups that are not fetched with this method are foreign groups.
  
! For instance, if you want to get your daily dosage of news from the
! @sc{nntp} server @samp{news.friendly.server}, you'd say:
  
  @lisp
  (setq gnus-select-method '(nntp "news.friendly.server"))
***************
*** 410,421 ****
  (setq gnus-select-method '(nnspool ""))
  @end lisp
  
! If you can use the local spool, you probably should, as it will almost
  certainly be much faster.
  
  If this variable is not set, Gnus will take a look at the
  @code{NNTPSERVER} environment variable.  If that isn't set either, it
! will try to use the machine that is running Emacs as an NNTP server.
  
  @vindex gnus-nntp-server
  If @code{gnus-nntp-server} is set, this variable will override
--- 453,465 ----
  (setq gnus-select-method '(nnspool ""))
  @end lisp
  
! If you can use a local spool, you probably should, as it will almost
  certainly be much faster.
  
  If this variable is not set, Gnus will take a look at the
  @code{NNTPSERVER} environment variable.  If that isn't set either, it
! will try to use the machine that is running Emacs as an @sc{nntp}
! server.
  
  @vindex gnus-nntp-server
  If @code{gnus-nntp-server} is set, this variable will override
***************
*** 423,446 ****
  @code{gnus-nntp-server} to @code{nil}, which is what it is by default.
  
  @vindex gnus-secondary-servers
! You can also make Gnus prompt you interactively for the name of an NNTP
! server.  If you give a non-numerical prefix to @code{gnus} (ie. @kbd{C-u
! M-x gnus}), Gnus will let you choose between the servers in the
! @code{gnus-secondary-servers} list (if any).  You can also just type in
! the name of any server you feel like visiting.
! 
! However, if you use one NNTP server regularly, and is just interested in
! a couple of groups from a different server, you would be better served
! by using the @code{gnus-group-browse-foreign-server} command from the
! group buffer.  It will let you have a look at what groups are available,
! and you can subscribe to any of the groups you want to.  This also makes
! @file{.newsrc} maintenance much tidier.  @xref{Foreign Groups}.
  
  @vindex gnus-secondary-select-methods
  A slightly different approach to foreign groups is to set the
  @code{gnus-secondary-select-methods} variable.  The select methods
  listed in this variable are in many ways just as native as the
! @code{gnus-select-method} server.  They will also be asked for active
  files during startup (if that's required), and new newsgroups that
  appear on these servers will be subscribed (or not) just as native
  groups are.
--- 467,491 ----
  @code{gnus-nntp-server} to @code{nil}, which is what it is by default.
  
  @vindex gnus-secondary-servers
! You can also make Gnus prompt you interactively for the name of an
! @sc{nntp} server.  If you give a non-numerical prefix to @code{gnus}
! (ie. @kbd{C-u M-x gnus}), Gnus will let you choose between the servers
! in the @code{gnus-secondary-servers} list (if any).  You can also just
! type in the name of any server you feel like visiting.
! 
! However, if you use one @sc{nntp} server regularly, and are just
! interested in a couple of groups from a different server, you would be
! better served by using the @code{gnus-group-browse-foreign-server}
! command from the group buffer.  It will let you have a look at what
! groups are available, and you can subscribe to any of the groups you
! want to.  This also makes @file{.newsrc} maintenance much tidier.
! @xref{Foreign Groups}.
  
  @vindex gnus-secondary-select-methods
  A slightly different approach to foreign groups is to set the
  @code{gnus-secondary-select-methods} variable.  The select methods
  listed in this variable are in many ways just as native as the
! @code{gnus-select-method} server.  They will also be queried for active
  files during startup (if that's required), and new newsgroups that
  appear on these servers will be subscribed (or not) just as native
  groups are.
***************
*** 449,456 ****
  would typically set this variable to
  
  @lisp
! (setq gnus-secondary-select-methods 
!   '((nnmbox "")))
  @end lisp
  
  @node The First Time
--- 494,500 ----
  would typically set this variable to
  
  @lisp
! (setq gnus-secondary-select-methods '((nnmbox "")))
  @end lisp
  
  @node The First Time
***************
*** 485,496 ****
  problems starting.  However, if you have some mail groups in addition to
  the news groups, you may want to start Gnus anyway.
  
! @findex gnus-no-server
! You can do that by @kbd{M-x gnus-no-server}.  This will start Gnus
! without attempting to contact the default server.  Gnus will be started
! on level two, so you shouldn't have any groups from the native server on
! level one or two, but only have mail groups and other foreign groups on
! these two levels.
  
  @node New Groups
  @section New Groups
--- 529,545 ----
  problems starting.  However, if you have some mail groups in addition to
  the news groups, you may want to start Gnus anyway.
  
! Gnus, being the trusting sort of program, will ask whether to proceed
! without a native select method if that server can't be contacted.  This
! will happen whether the server doesn't actually exist (ie. you have
! given the wrong address) or the server has just momentarily taken ill
! for some reason or other.  
! 
! If Gnus says "nntp server on <your server> can't be opened. Continue?",
! you do not want to continue unless you have some foreign groups that you
! want to read.  Even if you don't, Gnus will let you continue, but you'll
! find it difficult to actually do anything in the group buffer.  But,
! hey, that's your problem.  Blllrph!
  
  @node New Groups
  @section New Groups
***************
*** 566,572 ****
  @code{nil}, you can always subscribe to the new groups just by pressing
  @kbd{U} in the group buffer (@pxref{Group Maintenance}).
  
! Gnus normally determine whether a group is new or not by comparing the
  list of groups from the active file(s) with the lists of subscribed and
  dead groups.  This isn't a particularly fast method.  If
  @code{gnus-check-new-newsgroups} is @code{ask-server}, Gnus will ask the
--- 615,621 ----
  @code{nil}, you can always subscribe to the new groups just by pressing
  @kbd{U} in the group buffer (@pxref{Group Maintenance}).
  
! Gnus normally determines whether a group is new or not by comparing the
  list of groups from the active file(s) with the lists of subscribed and
  dead groups.  This isn't a particularly fast method.  If
  @code{gnus-check-new-newsgroups} is @code{ask-server}, Gnus will ask the
***************
*** 589,605 ****
  @cindex startup files
  @cindex .newsrc
  
! Now, you all know about the @file{.newsrc} files.  All information about
! what groups you read is traditionally stored in this file, which has a
! rather rigid structure.
  
! Things got a bit more complicated with @sc{GNUS}.  In addition to
  keeping the @file{.newsrc} file updated, it also used a file called
  @file{.newsrc.el} for storing all the information that didn't fit into
  the @file{.newsrc} file.  (Actually, it duplicated everything in the
! @file{.newsrc} file.)  @sc{GNUS} would read whichever one of these files
  that were the most recently saved, which enabled people to swap between
! @sc{GNUS} and other newsreaders.
  
  That was kinda silly, so (ding) Gnus went one better: In addition to the
  @file{.newsrc} and @file{.newsrc.el} files, (ding) Gnus also has a file
--- 638,653 ----
  @cindex startup files
  @cindex .newsrc
  
! Now, you all know about the @file{.newsrc} file.  All subscription
! information is traditionally stored in this file.
  
! Things got a bit more complicated with @sc{gnus}.  In addition to
  keeping the @file{.newsrc} file updated, it also used a file called
  @file{.newsrc.el} for storing all the information that didn't fit into
  the @file{.newsrc} file.  (Actually, it duplicated everything in the
! @file{.newsrc} file.)  @sc{gnus} would read whichever one of these files
  that were the most recently saved, which enabled people to swap between
! @sc{gnus} and other newsreaders.
  
  That was kinda silly, so (ding) Gnus went one better: In addition to the
  @file{.newsrc} and @file{.newsrc.el} files, (ding) Gnus also has a file
***************
*** 607,617 ****
  are most recent, but it will never write a @file{.newsrc.el} file.
  
  @vindex gnus-save-newsrc-file
! You can also turn off writing @file{.newsrc} by setting
  @code{gnus-save-newsrc-file} to @code{nil}, which means you can delete
! the file and save some space, as well as some time when quitting Gnus.
! However, that will make it impossible to use other newsreaders than
! (ding) Gnus.  But hey, who would want to, right?
  
  @vindex gnus-save-killed-list
  If @code{gnus-save-killed-list} is @code{nil}, Gnus will not save the
--- 655,665 ----
  are most recent, but it will never write a @file{.newsrc.el} file.
  
  @vindex gnus-save-newsrc-file
! You can also turn off writing the @file{.newsrc} file by setting
  @code{gnus-save-newsrc-file} to @code{nil}, which means you can delete
! the file and save some space, as well as making exit from Gnus faster.
! However, this will make it impossible to use other newsreaders than
! Gnus.  But hey, who would want to, right?
  
  @vindex gnus-save-killed-list
  If @code{gnus-save-killed-list} is @code{nil}, Gnus will not save the
***************
*** 619,626 ****
  (when starting and quitting) and space (on disk).  It will also means
  that Gnus has no record of what groups are new or old, so the automatic
  new groups subscription methods become meaningless.  You should always
! set @code{gnus-check-new-newsgroups} to @code{nil} if you set this
! variable to @code{nil}.
  
  @vindex gnus-startup-file
  The @code{gnus-startup-file} variable says where the startup files are.
--- 667,674 ----
  (when starting and quitting) and space (on disk).  It will also means
  that Gnus has no record of what groups are new or old, so the automatic
  new groups subscription methods become meaningless.  You should always
! set @code{gnus-check-new-newsgroups} to @code{nil} or @code{ask-server}
! if you set this variable to @code{nil} (@pxref{New Groups}).
  
  @vindex gnus-startup-file
  The @code{gnus-startup-file} variable says where the startup files are.
***************
*** 637,652 ****
  @cindex auto-save
  
  Whenever you do something that changes the Gnus data (reading articles,
! cathing up, killing/subscribing to groups,) the change is added to a
! special @dfn{dribble} buffer.  This buffer is auto-saved the normal
  Emacs way.  If your Emacs should crash before you have saved the
  @file{.newsrc} files, all changes you have made can be recovered from
! this file. 
  
  If Gnus detects this file at startup, it will ask the user whether to
! read it.
! 
! The auto save file is deleted whenever the real startup file is saved. 
  
  @vindex gnus-use-dribble-file
  If @code{gnus-use-dribble-file} is @code{nil}, Gnus won't create and
--- 685,699 ----
  @cindex auto-save
  
  Whenever you do something that changes the Gnus data (reading articles,
! cathing up, killing/subscribing groups), the change is added to a
! special @dfn{dribble buffer}.  This buffer is auto-saved the normal
  Emacs way.  If your Emacs should crash before you have saved the
  @file{.newsrc} files, all changes you have made can be recovered from
! this file.
  
  If Gnus detects this file at startup, it will ask the user whether to
! read it. The auto save file is deleted whenever the real startup file is
! saved.
  
  @vindex gnus-use-dribble-file
  If @code{gnus-use-dribble-file} is @code{nil}, Gnus won't create and
***************
*** 658,671 ****
  @cindex ignored groups
  
  When Gnus starts, or indeed whenever it tries to determine whether new
! articles have arrived, it reads the active file.  This is a large file
! that the NNTP server maintains to keep track of what groups it carries.
  
  @vindex gnus-ignored-newsgroups
! Before examining the active file to see what groups are available, Gnus
! deletes all lines in this file that match the regexp
! @code{gnus-ignored-newsgroups}.  This is done primarily to reject any
! groups with bogus names (eg. groups containing characters like
  @samp{'[]"} and so on), but you can use this variable to make Gnus
  ignore hierarchies you aren't ever interested in.
  
--- 705,718 ----
  @cindex ignored groups
  
  When Gnus starts, or indeed whenever it tries to determine whether new
! articles have arrived, it reads the active file.  This is a very large
! file that lists all the active groups and articles on the @sc{nntp}
! server.
  
  @vindex gnus-ignored-newsgroups
! Before examining the active file, Gnus deletes all lines that match the
! regexp @code{gnus-ignored-newsgroups}.  This is done primarily to reject
! any groups with bogus names (eg. groups containing characters like
  @samp{'[]"} and so on), but you can use this variable to make Gnus
  ignore hierarchies you aren't ever interested in.
  
***************
*** 749,758 ****
  
  Quite simple, huh?
  
! Those lines mean that there are 25 unread articles in
! @samp{news.announce.newusers} and no unread articles, but some ticked
! articles in @samp{alt.fan.andrea-dworkin} (see that little asterisk at
! the beginning of the line?)
  
  @vindex gnus-group-line-format
  You can fuck that up to your heart's delight by fiddling with the
--- 796,805 ----
  
  Quite simple, huh?
  
! You can see that there are 25 unread articles in
! @samp{news.announce.newusers}.  There are no unread articles, but some
! ticked articles, in @samp{alt.fan.andrea-dworkin} (see that little
! asterisk at the beginning of the line?)
  
  @vindex gnus-group-line-format
  You can fuck that up to your heart's delight by fiddling with the
***************
*** 768,774 ****
  The default value that produced those lines above is 
  @samp{"%M%S%5y: %(%g%)\n"}.
  
! There should always be a colon on the line; the cursor always move 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
--- 815,821 ----
  The default value that produced those lines above is 
  @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
***************
*** 782,830 ****
  
  @table @samp
  @item M    
! Only marked articles
  @item S
! Whether the group is subscribed 
  @item L    
! Level of subscribedness 
  @item N
! Number of unread articles
  @item I
! Number of dormant articles
  @item T
! Number of ticked articles
  @item R
! Number of read articles
  @item t
! Total number of articles
  @item y
! Number of unread, unticked, non-dormant articles
  @item i
! Number of ticked and dormant articles
  @item g
! Full group name
  @item G
! Group name 
  @item D
! Newsgroup description
  @item o
! Moderated
  @item O
! Moderated
  @item s
! Select method 
  @item n
! Select from where
  @item z
! A string that look like @samp{<%s:%n>} if a foreign select method is
! used. 
  @item u
  User defined specifier.  The next character in the format string should
! be a letter.  @sc{GNUS} will call the function gnus-user-format-function-X,
! where X is the letter following %u.  The function will be passed the
! current headers as argument.  The function should return a string, which
! will be inserted into the buffer just like information from any other
! specifier.
  @end table
  
  @vindex gnus-group-mode-line-format
--- 829,877 ----
  
  @table @samp
  @item M    
! Only marked articles.
  @item S
! Whether the group is subscribed.
  @item L    
! Level of subscribedness.
  @item N
! Number of unread articles.
  @item I
! Number of dormant articles.
  @item T
! Number of ticked articles.
  @item R
! Number of read articles.
  @item t
! Total number of articles.
  @item y
! Number of unread, unticked, non-dormant articles.
  @item i
! Number of ticked and dormant articles.
  @item g
! Full group name.
  @item G
! Group name.
  @item D
! Newsgroup description.
  @item o
! Moderated.
  @item O
! Moderated.
  @item s
! Select method.
  @item n
! Select from where.
  @item z
! A string that looks like @samp{<%s:%n>} if a foreign select method is
! used.
  @item u
  User defined specifier.  The next character in the format string should
! be a letter.  @sc{gnus} will call the function
! @code{gnus-user-format-function-}@samp{X}, where @samp{X} is the letter
! following @samp{%u}.  The function will be passed the current headers as
! argument.  The function should return a string, which will be inserted
! into the buffer just like information from any other specifier.
  @end table
  
  @vindex gnus-group-mode-line-format
***************
*** 834,842 ****
  
  @table @samp
  @item S
! Default news server
  @item M
! Default select method
  @end table
  
  @node Group Manouvering
--- 881,889 ----
  
  @table @samp
  @item S
! Default news server.
  @item M
! Default select method.
  @end table
  
  @node Group Manouvering
***************
*** 850,864 ****
  @item n
  @kindex n (Group)
  @findex gnus-group-next-unread-group
! Go to the next group with unread articles
! (@code{gnus-group-next-unread-group}). 
  @item p
  @item DEL
  @kindex DEL (Group)
  @kindex p (Group)
  @findex gnus-group-prev-unread-group
! Go to the previous group group with unread articles
! (@code{gnus-group-prev-unread-group}). 
  @item N
  @kindex N (Group)
  @findex gnus-group-next-group
--- 897,911 ----
  @item n
  @kindex n (Group)
  @findex gnus-group-next-unread-group
! Go to the next group that has unread articles
! (@code{gnus-group-next-unread-group}).
  @item p
  @item DEL
  @kindex DEL (Group)
  @kindex p (Group)
  @findex gnus-group-prev-unread-group
! Go to the previous group group that has unread articles
! (@code{gnus-group-prev-unread-group}).
  @item N
  @kindex N (Group)
  @findex gnus-group-next-group
***************
*** 908,919 ****
  @item SPACE
  @kindex SPACE (Group)
  @findex gnus-group-read-group
! Select the current group, switch to the summary buffer and display
! the first unread article in the group
! (@code{gnus-group-read-group}).  If there are no unread articles in the
! group, or if you give a prefix to this command, Gnus will offer to
! fetch all the old articles in this group from the server.
! server. 
  @item RET
  @kindex RET (Group)
  @findex gnus-group-select-group
--- 955,965 ----
  @item SPACE
  @kindex SPACE (Group)
  @findex gnus-group-read-group
! Select the current group, switch to the summary buffer and display the
! first unread article (@code{gnus-group-read-group}).  If there are no
! unread articles in the group, or if you give a prefix to this command,
! Gnus will offer to fetch all the old articles in this group from the
! server.  
  @item RET
  @kindex RET (Group)
  @findex gnus-group-select-group
***************
*** 934,943 ****
  
  @vindex gnus-large-newsgroup
  The @code{gnus-large-newsgroup} variable says what Gnus should consider
! to be a big group.  If the group has more unread articles than this
! variable, Gnus will query the user before entering the group.  The user
! can then specify how many articles should be fetched from the server.
! If the user specifies a negative number (@samp{-n}), the @samp{n} oldest
  articles will be fetched.  If it is positive, the @samp{n} articles that
  have arrived most recently will be fetched.
  
--- 980,989 ----
  
  @vindex gnus-large-newsgroup
  The @code{gnus-large-newsgroup} variable says what Gnus should consider
! to be a big group.  If the group has more unread articles than this,
! Gnus will query the user before entering the group.  The user can then
! specify how many articles should be fetched from the server.  If the
! user specifies a negative number (@samp{-n}), the @samp{n} oldest
  articles will be fetched.  If it is positive, the @samp{n} articles that
  have arrived most recently will be fetched.
  
***************
*** 956,968 ****
  @findex gnus-thread-sort-by-author
  @findex gnus-thread-sort-by-number
  @vindex gnus-thread-sort-functions
! If you are using threaded summary display, you can sort the threads by
  setting @code{gnus-thread-sort-functions}, which is a list of functions.
  By default, sorting is done on article numbers.  Ready-made sorting
  functions include @code{gnus-thread-sort-by-number},
  @code{gnus-thread-sort-by-author}, @code{gnus-thread-sort-by-subject},
  @code{gnus-thread-sort-by-date}, @code{gnus-thread-sort-by-score},
! @code{gnus-thread-sort-by-total-score}. 
  
  Each function takes two threads and return non-@code{nil} if the first
  thread should be sorted before the other.  If you use more than one
--- 1002,1014 ----
  @findex gnus-thread-sort-by-author
  @findex gnus-thread-sort-by-number
  @vindex gnus-thread-sort-functions
! If you are using a threaded summary display, you can sort the threads by
  setting @code{gnus-thread-sort-functions}, which is a list of functions.
  By default, sorting is done on article numbers.  Ready-made sorting
  functions include @code{gnus-thread-sort-by-number},
  @code{gnus-thread-sort-by-author}, @code{gnus-thread-sort-by-subject},
  @code{gnus-thread-sort-by-date}, @code{gnus-thread-sort-by-score},
! @code{gnus-thread-sort-by-total-score}.
  
  Each function takes two threads and return non-@code{nil} if the first
  thread should be sorted before the other.  If you use more than one
***************
*** 989,1019 ****
  @cindex subscribing
  
  @table @kbd
  @item u
  @kindex u (Group)
  @findex gnus-group-unsubscribe-current-group
! Unsubscribe the current group, or, if it was unsubscribed already,
! subscribe it (@code{gnus-group-unsubscribe-current-group}). 
  @item U
  @kindex U (Group)
  @findex gnus-group-unsubscribe-group
! Ask the user for a group to unsubscribe, and then unsubscribe it.  If
! it was unsubscribed already, subscribe it instead
! (@code{gnus-group-unsubscribe-group}). 
  @item C-k
  @kindex C-k (Group)
  @findex gnus-group-kill-group
  Kill the current group (@code{gnus-group-kill-group}).
  @item C-y
  @kindex C-y (Group)
  @findex gnus-group-yank-group
  Yank the last killed group (@code{gnus-group-yank-group}).
  @item C-w
  @kindex C-w (Group)
  @findex gnus-group-kill-region
  Kill all groups in the region (@code{gnus-group-kill-region}). 
! @item M-z
! @kindex M-z (Group)
  @findex gnus-group-kill-all-zombies
  Kill all zombie groups (@code{gnus-group-kill-all-zombies}).
  @end table
--- 1035,1075 ----
  @cindex subscribing
  
  @table @kbd
+ @item S t
  @item u
+ @kindex S t (Group)
  @kindex u (Group)
  @findex gnus-group-unsubscribe-current-group
! Toggle subscription to the current group
! (@code{gnus-group-unsubscribe-current-group}).  
! @item S s
  @item U
+ @kindex S s (Group)
  @kindex U (Group)
  @findex gnus-group-unsubscribe-group
! Prompt for a group to subscribe, and then subscribe it.  If it was
! subscribed already, unsubscribe it instead
! (@code{gnus-group-unsubscribe-group}).
! @item S k
  @item C-k
+ @kindex S k (Group)
  @kindex C-k (Group)
  @findex gnus-group-kill-group
  Kill the current group (@code{gnus-group-kill-group}).
+ @item S y
  @item C-y
+ @kindex S y (Group)
  @kindex C-y (Group)
  @findex gnus-group-yank-group
  Yank the last killed group (@code{gnus-group-yank-group}).
+ @item S w
  @item C-w
+ @kindex S w (Group)
  @kindex C-w (Group)
  @findex gnus-group-kill-region
  Kill all groups in the region (@code{gnus-group-kill-region}). 
! @item S z
! @kindex S z (Group)
  @findex gnus-group-kill-all-zombies
  Kill all zombie groups (@code{gnus-group-kill-all-zombies}).
  @end table
***************
*** 1024,1039 ****
  
  All groups have a level of @dfn{subscribedness}.  For instance, if a
  group is on level 2, it is more subscribed than a group on level 5.  You
! can ask Gnus to just list groups on a given level and lower
  (@pxref{Listing Groups}), or to just check for new articles in groups on
! a given level and lower (@pxref{Misc Group Stuff}).
  
  @table @kbd
! @item S
! @kindex S (Group)
  @findex gnus-group-set-current-level
  Set the level of the current group depending on the numeric
! prefix.  For instance, @kbd{3 s} will set the level of the current
  group to three (@code{gnus-group-set-current-level}).  If no numeric
  prefix is given, this command will prompt the user for a level.
  @end table
--- 1080,1095 ----
  
  All groups have a level of @dfn{subscribedness}.  For instance, if a
  group is on level 2, it is more subscribed than a group on level 5.  You
! can ask Gnus to just list groups on a given level or lower
  (@pxref{Listing Groups}), or to just check for new articles in groups on
! a given level or lower (@pxref{Misc Group Stuff}).
  
  @table @kbd
! @item S l
! @kindex S l (Group)
  @findex gnus-group-set-current-level
  Set the level of the current group depending on the numeric
! prefix.  For instance, @kbd{3 S l} will set the level of the current
  group to three (@code{gnus-group-set-current-level}).  If no numeric
  prefix is given, this command will prompt the user for a level.
  @end table
***************
*** 1044,1050 ****
  the same, but zombie and killed groups have no information on what
  articles you have read, etc, stored.  This distinction between dead and
  living groups isn't done because it is nice or clever, it is done purely
! for reasons of efficiency. 
  
  It is recommended that you keep all regular groups on level 3 or higher,
  and keep your mail groups (if any) on level 1 or 2.
--- 1100,1108 ----
  the same, but zombie and killed groups have no information on what
  articles you have read, etc, stored.  This distinction between dead and
  living groups isn't done because it is nice or clever, it is done purely
! for reasons of efficiency.  On the other hand, if you would like a finer
! granularity to the levels - you're out of luck.  The nine levels are
! hardcoded into the source.  Sorry.
  
  It is recommended that you keep all regular groups on level 3 or higher,
  and keep your mail groups (if any) on level 1 or 2.
***************
*** 1063,1085 ****
  
  A @dfn{foreign group} is a group that is not read by the usual (or
  default) means.  It could be, for instance, a group from a different
! NNTP server, it could be a virtual group, or it could be your own
  personal mail group.
  
  A foreign group (or any group, really) is specified by a @dfn{name} and
  a @dfn{select method}.  To take the latter first, a select method is a
  list where the first element says what backend to use (eg. nntp,
! nnspool, nnml) and the second element is the "address", in some meaning of
! the word.  There may be additional elements in the select method, where
! the value may have special meaning for the backends.
  
  The @dfn{name} of the group is the name the backend will recognize the
  group as.
  
! For instance, the group @samp{soc.motss} on the NNTP server
  @samp{some.where.edu} will have the name @samp{soc.motss} and select
! method @samp{(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,
--- 1121,1144 ----
  
  A @dfn{foreign group} is a group that is not read by the usual (or
  default) means.  It could be, for instance, a group from a different
! @sc{nntp} server, it could be a virtual group, or it could be your own
  personal mail group.
  
  A foreign group (or any group, really) is specified by a @dfn{name} and
  a @dfn{select method}.  To take the latter first, a select method is a
  list where the first element says what backend to use (eg. nntp,
! nnspool, nnml) and the second element is the @dfn{address}, in some
! meaning of the word.  There may be additional elements in the select
! method, where the value may have special meaning for the backend in
! question.
  
  The @dfn{name} of the group is the name the backend will recognize the
  group as.
  
! For instance, the group @samp{soc.motss} on the @sc{nntp} server
  @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,
***************
*** 1089,1096 ****
  @item M m
  @kindex M m (Group)
  @findex gnus-group-make-group
! Make a new group.  Gnus will prompt you for a name, a method and an
! "address" (@code{gnus-group-make-group}).
  @item M e
  @kindex M e (Group)
  @findex gnus-group-edit-group
--- 1148,1156 ----
  @item M m
  @kindex M m (Group)
  @findex gnus-group-make-group
! Make a new group (@code{gnus-group-make-group}).  Gnus will prompt you
! for a name, a method and possibly an @dfn{address}.  For an easier way
! to subscribe to @sc{nntp} groups, @xref{Browse Foreign Server}.
  @item M e
  @kindex M e (Group)
  @findex gnus-group-edit-group
***************
*** 1123,1129 ****
  The different methods all have their peculiarities, of course.
  
  @menu
! * nntp::             Reading news from a different NNTP server.
  * nnspool::          Reading news from the local spool.
  * nnvirtual::        Combining articles from many groups.
  * nnkiboze::         Looking through parts of the newsfeed for articles.
--- 1183,1189 ----
  The different methods all have their peculiarities, of course.
  
  @menu
! * nntp::             Reading news from a different @sc{nntp} server.
  * nnspool::          Reading news from the local spool.
  * nnvirtual::        Combining articles from many groups.
  * nnkiboze::         Looking through parts of the newsfeed for articles.
***************
*** 1137,1160 ****
  If the @code{gnus-activate-foreign-newsgroups} is a positive number,
  Gnus will check all foreign groups with this level or lower at startup.
  This might take quite a while, especially if you subscribe to lots of
! groups from different NNTP servers.  It is @code{nil} by default, which
! means that you won't be told whether there are new articles in these
! groups.  How many unread articles there are will be determined when, or
! if, you decide to enter them.  You can also activate any group with
! @kbd{M-g} to see how many unread articles there are.
  
  @cindex to-address
  If the select method contains an element that looks like
  @samp{(to-address .  "some@@where.com")}, that address will be used by
  the backend when doing followups and posts.  This is primarily useful in
! mail groups that represent mailing lists.  You'd then just set this
! address to whatever the list address is.
  
  This trick will actually work whether the group is foreign or not.
  Let's say there's a group on the server that is called @samp{fa.4ad-l}.
! This is a real group, 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. 
  
  To achieve this, go to the group in question in the group buffer and
  type @kbd{M e} to edit the group entry.  You'll then be put in a buffer
--- 1197,1220 ----
  If the @code{gnus-activate-foreign-newsgroups} is a positive number,
  Gnus will check all foreign groups with this level or lower at startup.
  This might take quite a while, especially if you subscribe to lots of
! groups from different @sc{nntp} servers.  It is @code{nil} by default,
! which means that you won't be told whether there are new articles in
! these groups.  How many unread articles there are will be determined
! when, or if, you decide to enter them.  You can also activate any group
! with @kbd{M-g} to see how many unread articles there are.
  
  @cindex to-address
  If the select method contains an element that looks like
  @samp{(to-address .  "some@@where.com")}, that address will be used by
  the backend when doing followups and posts.  This is primarily useful in
! mail groups that represent mailing lists.  You just set this address to
! whatever the list address is.
  
  This trick will actually work whether the group is foreign or not.
  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.
  
  To achieve this, go to the group in question in the group buffer and
  type @kbd{M e} to edit the group entry.  You'll then be put in a buffer
***************
*** 1203,1216 ****
  @end quotation
  
  @node nntp
! @subsection nntp
  @cindex nntp
  
! Subscribing to a foreign group from an NNTP server is rather easy.  You
! just specify @code{nntp} as method and the address of the NNTP server as
! the, uhm, address.
  
! If the NNTP server is located at a non-standard port number, setting the
  third element of the select method to this port number should allow you
  to connect to the right port.  You'll have to edit the group info for
  that (@pxref{Foreign Groups}).
--- 1263,1276 ----
  @end quotation
  
  @node nntp
! @subsection @sc{nntp}
  @cindex nntp
  
! Subscribing to a foreign group from an @sc{nntp} server is rather easy.
! You just specify @code{nntp} as method and the address of the @sc{nntp}
! server as the, uhm, address.
  
! If the @sc{nntp} server is located at a non-standard port, setting the
  third element of the select method to this port number should allow you
  to connect to the right port.  You'll have to edit the group info for
  that (@pxref{Foreign Groups}).
***************
*** 1219,1243 ****
  fact, you can subscribe to the same group from as many different servers
  you feel like.  There will be no name collisions.
  
! @cindex @sc{MODE READER}
  @cindex authinfo
  @findex nntp-send-authinfo
  @findex nntp-send-mode-reader
  @vindex nntp-server-opened-hook
  @code{nntp-server-opened-hook} is run after a connection has been made.
! It can be used to send commands to the NNTP server after it has been
! contacted.  By default is sends the command @samp{MODE READER} to the
! server with the @code{nntp-send-mode-reader} function.  Another popular
! function for sending the @sc{authinfo} command to the server is
! @code{nntp-send-authinfo}. 
  
  @vindex nntp-maximum-request
! If the NNTP server doesn't support @sc{NOV} headers, this backend will
! collect headers by sending a series of @code{HEAD} commands.  To speed
! things up, the backend sends lots of these commands, without waiting for
! reply, and then reads all the replies.  This is controlled by the
! @code{nntp-maximum-request} variable, and is 400 by default.  If your
! network is buggy, you should set this to 1.
  
  @vindex nntp-connection-timeout
  If you have lots of foreign nntp groups that you connect to regularly,
--- 1279,1303 ----
  fact, you can subscribe to the same group from as many different servers
  you feel like.  There will be no name collisions.
  
! @cindex @sc{mode reader}
  @cindex authinfo
  @findex nntp-send-authinfo
  @findex nntp-send-mode-reader
  @vindex nntp-server-opened-hook
  @code{nntp-server-opened-hook} is run after a connection has been made.
! It can be used to send commands to the @sc{nntp} server after it has
! been contacted.  By default is sends the command @samp{MODE READER} to
! the server with the @code{nntp-send-mode-reader} function.  Another
! popular function is @code{nntp-send-authinfo}, which will prompt you for
! an @sc{nntp} password and stuff.
  
  @vindex nntp-maximum-request
! If the @sc{nntp} server doesn't support @sc{nov} headers, this backend
! will collect headers by sending a series of @code{head} commands.  To
! speed things up, the backend sends lots of these commands without
! waiting for reply, and then reads all the replies.  This is controlled
! by the @code{nntp-maximum-request} variable, and is 400 by default.  If
! your network is buggy, you should set this to 1.
  
  @vindex nntp-connection-timeout
  If you have lots of foreign nntp groups that you connect to regularly,
***************
*** 1270,1276 ****
  Where nnspool looks for the articles.  This is normally
  @file{/usr/spool/news/}.
  @item nnspool-nov-directory 
! Where nnspool will look for @sc{NOV} files.  This is normally
  @file{/usr/spool/news/over.view/}.
  @item nnspool-lib-dir
  Where the news lib dir is (@file{/usr/lib/news/} by default).
--- 1330,1336 ----
  Where nnspool looks for the articles.  This is normally
  @file{/usr/spool/news/}.
  @item nnspool-nov-directory 
! Where nnspool will look for @sc{nov} files.  This is normally
  @file{/usr/spool/news/over.view/}.
  @item nnspool-lib-dir
  Where the news lib dir is (@file{/usr/lib/news/} by default).
***************
*** 1281,1322 ****
  @cindex nnvirtual
  @cindex virtual groups
  
! A @dfn{virtual group} is really nothing more than a collection of
! other groups. 
! 
! You specify @code{nnvirtual} as the method and a regular expression that
! says which groups that you wish to have in this one as the address. 
  
  For instance, if you are tired of reading many small group, you can
  put them all in one big group, and then grow tired of reading one
  big, unwieldy group.  The joys of computing!
  
! All marks, read status, etc., in the nnvirtual group will stick to the
! articles in the component groups.  So if you tick an article in an
! nnvirtual group, the article will also be ticked in the component group
! from whence it it.  (And vice versa - marks from the component groups
! will also be shown in the nnvirtual group.)
  
! @example
! "^alt\\.fan\\.andrea-dworkin$\\|^rec\\.dworkin.*"
! @end example
  
! These groups can be native or foreign; everything should work smoothly,
! but if your computer explodes, it was probably my fault.  
  
  Collecting the same group from several servers might actually be a good
! idea if users have set the Distribution headers to limit distribution. 
  If you would like to read @samp{soc.motss} both from a server in Japan
  and a server in Norway, you could use the following as the group regexp:
  
  @example
! "^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.
  
  One limitation, however - all groups that are included in a virtual
  group has to be alive (ie. subscribed or unsubscribed).  Killed or
--- 1341,1386 ----
  @cindex nnvirtual
  @cindex virtual groups
  
! An @dfn{nnvirtual group} is really nothing more than a collection of
! other groups.
  
  For instance, if you are tired of reading many small group, you can
  put them all in one big group, and then grow tired of reading one
  big, unwieldy group.  The joys of computing!
  
! You specify @code{nnvirtual} as the method.  The address should be a
! regexp to match component groups.
  
! 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
! (nnvirtual "^alt\\.fan\\.andrea-dworkin$\\|^rec\\.dworkin.*")
! @end lisp
  
! The component groups can be native or foreign; everything should work
! smoothly, but if your computer explodes, it was probably my fault.
  
  Collecting the same group from several servers might actually be a good
! idea if users have set the Distribution header to limit distribution.
  If you would like to read @samp{soc.motss} both from a server in Japan
  and a server in Norway, you could use the following as the group regexp:
  
  @example
! "^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 (ie. subscribed or unsubscribed).  Killed or
***************
*** 1327,1336 ****
  @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 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
--- 1391,1400 ----
  @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
***************
*** 1338,1359 ****
  
  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.
  
  @kindex M-x nnkiboze-generate-groups
  @findex nnkiboze-generate-groups
! After creating the nnkiboze groups you feel like having, you must run
! @kbd{M-x nnkiboze-generate-groups}.  (This can also be reached from one
! of the menus.) This will take time.  Lots of time.  Oodles ond oodles of
! time.  Gnus has to fetch the headers from all the articles on 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.  Or your sysadm may become annoyed with you, and the 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.
--- 1402,1422 ----
  
  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{Score Files}).
  
  @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 sysadm 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.
***************
*** 1361,1372 ****
  @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} 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
--- 1424,1436 ----
  @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
***************
*** 1382,1392 ****
  think much about it - a backend to read directories.  Big deal.
  
  ange-ftp changes that picture dramatically.  For instance, if you enter
! @file{/ftp/amanda} as the the directory name, ange-ftp will actually
! allow you to read this directory over at amanda as a newsgroup.
! Distributed news ahoy!
  
! nndir supports, and will use, @sc{NOV} files if they are present.
  
  @node nndoc
  @subsection nndoc
--- 1446,1456 ----
  think much about it - a backend to read directories.  Big deal.
  
  ange-ftp changes that picture dramatically.  For instance, if you enter
! @file{"/ftp@@sina.tcamc.uh.edu:/pub/emacs/ding-list/"} as the the
! directory name, ange-ftp will actually allow you to read this directory
! over at @samp{sina} as a newsgroup.  Distributed news ahoy!
  
! nndir will use @sc{nov} files if they are present.
  
  @node nndoc
  @subsection nndoc
***************
*** 1406,1412 ****
  @cindex digest groups
  
  nndigest is a bit odd.  It will use a buffer containing a valid digest
! as the basis of the group.
  
  These nndigest groups are rather ephemeral.  They will never store
  information on what articles you have read, and you can't really use
--- 1470,1476 ----
  @cindex digest groups
  
  nndigest is a bit odd.  It will use a buffer containing a valid digest
! as the basis for a group.
  
  These nndigest groups are rather ephemeral.  They will never store
  information on what articles you have read, and you can't really use
***************
*** 1454,1460 ****
  @vindex nnmail-spool-file
  @code{nnmail-spool-file} says where to look for new mail.  If this
  variable is @code{nil}, the mail backends will never attempt to fetch
! mail by themselves.
  
  @vindex nnmail-prepare-incoming-hook
  @code{nnmail-prepare-incoming-hook} is run in a buffer that holds all
--- 1518,1526 ----
  @vindex nnmail-spool-file
  @code{nnmail-spool-file} says where to look for new mail.  If this
  variable is @code{nil}, the mail backends will never attempt to fetch
! mail by themselves.  It is quite likely that Gnus supports POP-mail.
! Set this variable to begin with the string @samp{"po:"}, and everything
! should go smoothly, even though I have never tested this.
  
  @vindex nnmail-prepare-incoming-hook
  @code{nnmail-prepare-incoming-hook} is run in a buffer that holds all
***************
*** 1490,1496 ****
  @code{gnus-subscribe-newsgroup-method} variable.)
  
  @vindex nnmail-split-methods
! The you should set the variable @code{nnmail-split-methods} to specify
  how the incoming mail is to be split into groups.
  
  @lisp
--- 1556,1562 ----
  @code{gnus-subscribe-newsgroup-method} variable.)
  
  @vindex nnmail-split-methods
! Then you should set the variable @code{nnmail-split-methods} to specify
  how the incoming mail is to be split into groups.
  
  @lisp
***************
*** 1501,1510 ****
  @end lisp
  
  This variable is a list of lists, where the first element of each of
! these lists contain the name of the mail group (they do not have to be
! called something beginning with @samp{"mail"}, by the way), and the
! second element is a regular expression used on the header of each mail
! to determine if it belongs in this mail group.
  
  The second element can also be a function.  In that case, it will be
  called narrowed to the headers with the first element of the rule as the
--- 1567,1576 ----
  @end lisp
  
  This variable is a list of lists, where the first element of each of
! these lists is the name of the mail group (they do not have to be called
! something beginning with @samp{"mail"}, by the way), and the second
! element is a regular expression used on the header of each mail to
! determine if it belongs in this mail group.
  
  The second element can also be a function.  In that case, it will be
  called narrowed to the headers with the first element of the rule as the
***************
*** 1542,1551 ****
  When a mail backend is queried for what groups it carries, it replies
  with the contents of that variable, along with any groups it has figured
  out that it carries by other means.  None of the backends (except
! @code{nnmh}) actually go out to the disk and check what groups that
! actually exists.  (It's not trivial to distinguish between what the user
! thinks is a basis for a newsgroup and what is just a plain old file or
! directory.)
  
  This means that you have to tell Gnus (and the backends) what groups
  exist by hand.
--- 1608,1616 ----
  When a mail backend is queried for what groups it carries, it replies
  with the contents of that variable, along with any groups it has figured
  out that it carries by other means.  None of the backends (except
! @code{nnmh}) actually go out to the disk and check what groups actually
! exist.  (It's not trivial to distinguish between what the user thinks is
! a basis for a newsgroup and what is just a plain old file or directory.)
  
  This means that you have to tell Gnus (and the backends) what groups
  exist by hand.
***************
*** 1559,1565 ****
  
  Go to the group buffer and type @kbd{M m}.  When prompted, answer
  @samp{foo} for the name and @samp{nnfolder} for the method.  Repeat
! twice for the two other groups, @samp{bar} and @code{mail.baz}.  Be sure
  to include all your mail groups.
  
  That's it.  You are now set to read your mail.  An active file for this
--- 1624,1630 ----
  
  Go to the group buffer and type @kbd{M m}.  When prompted, answer
  @samp{foo} for the name and @samp{nnfolder} for the method.  Repeat
! twice for the two other groups, @samp{bar} and @samp{mail.baz}.  Be sure
  to include all your mail groups.
  
  That's it.  You are now set to read your mail.  An active file for this
***************
*** 1602,1608 ****
  
  @lisp
  (setq gnus-auto-expirable-newsgroups 
!       "^mail.nonsense-list\\|^mail.nice-list")
  @end lisp
  
  Another way to have auto-expiry happen is to have the element
--- 1667,1673 ----
  
  @lisp
  (setq gnus-auto-expirable-newsgroups 
!       "mail.nonsense-list\\|mail.nice-list")
  @end lisp
  
  Another way to have auto-expiry happen is to have the element
***************
*** 1650,1656 ****
  @vindex nnmh-get-new-mail
  @vindex nnfolder-get-new-mail
  This might be too much, if, for instance, you are reading mail quite
! happily with @code{nnml} and just want to peek at some old @sc{RMAIL}
  file you have stashed away with @code{nnbabyl}.  All backends have
  variables called backend-@code{get-new-mail}.  If you want to disable
  the @code{nnbabyl} mail reading, you just set
--- 1715,1721 ----
  @vindex nnmh-get-new-mail
  @vindex nnfolder-get-new-mail
  This might be too much, if, for instance, you are reading mail quite
! happily with @code{nnml} and just want to peek at some old @sc{rmail}
  file you have stashed away with @code{nnbabyl}.  All backends have
  variables called backend-@code{get-new-mail}.  If you want to disable
  the @code{nnbabyl} mail reading, you just set
***************
*** 1693,1700 ****
  @cindex nnml
  @cindex mail @sc{nov} spool
  
! The spool mail format (@code{nnml}) isn't compatible with any other
! known format.  It should be used with some caution.
  
  @vindex nnml-directory
  If you use this backend, Gnus will split all incoming mail into files;
--- 1758,1765 ----
  @cindex nnml
  @cindex mail @sc{nov} spool
  
! The @dfn{nnml} spool mail format isn't compatible with any other known
! format.  It should be used with some caution.
  
  @vindex nnml-directory
  If you use this backend, Gnus will split all incoming mail into files;
***************
*** 1716,1722 ****
  
  @code{nnml} is probably the slowest backend when it comes to article
  splitting.  It has to create lots of files, and it also generates
! @sc{NOV} databases for the incoming mails.  This makes is the fastest
  backend when it comes to reading mail.
  
  @findex nnml-generate-nov-databases
--- 1781,1787 ----
  
  @code{nnml} is probably the slowest backend when it comes to article
  splitting.  It has to create lots of files, and it also generates
! @sc{nov} databases for the incoming mails.  This makes is the fastest
  backend when it comes to reading mail.
  
  @findex nnml-generate-nov-databases
***************
*** 1724,1730 ****
  you can do a complete update by typing @kbd{M-x
  nnml-generate-nov-databases}.  This command will trawl through the
  entire @code{nnml} hierarchy, looking at each and every article, so it
! might take a while to finish.
  
  @node nnmh
  @subsubsection nnmh
--- 1789,1795 ----
  you can do a complete update by typing @kbd{M-x
  nnml-generate-nov-databases}.  This command will trawl through the
  entire @code{nnml} hierarchy, looking at each and every article, so it
! might take a while to complete.
  
  @node nnmh
  @subsubsection nnmh
***************
*** 1732,1738 ****
  @cindex mh-e mail spool
  
  @code{nnmh} is just like @code{nnml}, except that is doesn't generate
! @sc{NOV} databases and it doesn't keep an active file.  This makes
  @code{nnmh} a @emph{much} slower backend than @code{nnml}, but it also
  makes it easier to write procmail scripts for.
  
--- 1797,1803 ----
  @cindex mh-e mail spool
  
  @code{nnmh} is just like @code{nnml}, except that is doesn't generate
! @sc{nov} databases and it doesn't keep an active file.  This makes
  @code{nnmh} a @emph{much} slower backend than @code{nnml}, but it also
  makes it easier to write procmail scripts for.
  
***************
*** 1764,1783 ****
  @kindex G s (Group)
  @kindex l (Group)
  @findex gnus-group-list-groups
! List all subscribed groups that have unread articles
  (@code{gnus-group-list-groups}).  If the numeric prefix is used, this
  command will list only groups of level ARG and lower.  By default, it
  only lists groups of level five or lower (ie. just subscribed groups).
  @item L
  @item G u
! @kindex G u
  @kindex L (Group)
  @findex gnus-group-list-all-groups
! List all subscribed and unsubscribed groups, whether they have unread
! articles or not (@code{gnus-group-list-all-groups}).  If the numeric
! prefix is used, this command will list only groups of level ARG and
! lower.  By default, it lists groups of level seven or lower (ie. just
! subscribed and unsubscribed groups).
  @item G k
  @kindex G k (Group)
  @findex gnus-group-list-killed
--- 1829,1848 ----
  @kindex G s (Group)
  @kindex l (Group)
  @findex gnus-group-list-groups
! List all groups that have unread articles
  (@code{gnus-group-list-groups}).  If the numeric prefix is used, this
  command will list only groups of level ARG and lower.  By default, it
  only lists groups of level five or lower (ie. just subscribed groups).
  @item L
  @item G u
! @kindex G u (Group)
  @kindex L (Group)
  @findex gnus-group-list-all-groups
! List all groups, whether they have unread articles or not
! (@code{gnus-group-list-all-groups}).  If the numeric prefix is used,
! this command will list only groups of level ARG and lower.  By default,
! it lists groups of level seven or lower (ie. just subscribed and
! unsubscribed groups).
  @item G k
  @kindex G k (Group)
  @findex gnus-group-list-killed
***************
*** 1805,1816 ****
  @item b
  @kindex b (Group)
  @findex gnus-group-check-bogus-groups
! Check bogus groups and delete them
  (@code{gnus-group-check-bogus-groups}).
  @item F
  @kindex F (Group)
  @findex gnus-find-new-newsgroups
! Find new groups (@code{gnus-find-new-newsgroups}).
  @item C-c C-x
  @kindex C-c C-x (Group)
  @findex gnus-group-expire-articles
--- 1870,1881 ----
  @item b
  @kindex b (Group)
  @findex gnus-group-check-bogus-groups
! Find bogus groups and delete them
  (@code{gnus-group-check-bogus-groups}).
  @item F
  @kindex F (Group)
  @findex gnus-find-new-newsgroups
! Find new groups and process them (@code{gnus-find-new-newsgroups}).
  @item C-c C-x
  @kindex C-c C-x (Group)
  @findex gnus-group-expire-articles
***************
*** 1878,1885 ****
--- 1943,1952 ----
  @findex gnus-browse-unsubscribe-current-group
  Unsubscribe to the current group, or, as will be the case here,
  subscribe to it (@code{gnus-browse-unsubscribe-current-group}). 
+ @item l
  @item q
  @kindex q (Browse)
+ @kindex l (Browse)
  @findex gnus-browse-exit
  Exit browse mode (@code{gnus-browse-exit}).
  @item ?
***************
*** 1901,1907 ****
  @findex gnus-group-suspend
  Suspend Gnus (@code{gnus-group-suspend}).  This doesn't really exit Gnus,
  but it kills all buffers exept the Group buffer.  I'm not sure why this
! is a gain, but then who am I to judge.
  @item q
  @kindex q (Group)
  @findex gnus-group-exit
--- 1968,1974 ----
  @findex gnus-group-suspend
  Suspend Gnus (@code{gnus-group-suspend}).  This doesn't really exit Gnus,
  but it kills all buffers exept the Group buffer.  I'm not sure why this
! is a gain, but then who am I to judge?
  @item q
  @kindex q (Group)
  @findex gnus-group-exit
***************
*** 1971,1983 ****
  @findex gnus-group-describe-group
  Describe the current group (@code{gnus-group-describe-group}).  If given
  a prefix, force Gnus to re-read the description from the server.
! @item C-c C-a
! @kindex C-c C-a (Group)
  @findex gnus-group-apropos
  List all groups that have names that match a regexp
  (@code{gnus-group-apropos}).
! @item C-c M-C-a 
! @kindex C-c M-C-a (Group)
  @findex gnus-group-description-apropos
  List all groups that have names or descriptions that match a regexp
  (@code{gnus-group-description-apropos}).
--- 2038,2050 ----
  @findex gnus-group-describe-group
  Describe the current group (@code{gnus-group-describe-group}).  If given
  a prefix, force Gnus to re-read the description from the server.
! @item G a
! @kindex G a (Group)
  @findex gnus-group-apropos
  List all groups that have names that match a regexp
  (@code{gnus-group-apropos}).
! @item G d
! @kindex G d (Group)
  @findex gnus-group-description-apropos
  List all groups that have names or descriptions that match a regexp
  (@code{gnus-group-description-apropos}).
***************
*** 2013,2021 ****
  @end table
  
  @vindex gnus-group-prepare-hook
! @code{gnus-group-prepare-hook} is called after the group list is
! created in the Group buffer.  It may be used to modify the group
! buffer in some strange, unnatural way.
  
  @node The Summary Buffer
  @chapter The Summary Buffer
--- 2080,2088 ----
  @end table
  
  @vindex gnus-group-prepare-hook
! @code{gnus-group-prepare-hook} is called after the group buffer is
! generated.  It may be used to modify the buffer in some strange,
! unnatural way.
  
  @node The Summary Buffer
  @chapter The Summary Buffer
***************
*** 2138,2144 ****
  Xref
  @item u
  User defined specifier.  The next character in the format string should
! be a letter.  @sc{GNUS} will call the function
  gnus-user-format-function-X, where X is the letter following @samp{%u}.
  The function will be passed the current header as argument.  The
  function should return a string, which will be inserted into the summary
--- 2205,2211 ----
  Xref
  @item u
  User defined specifier.  The next character in the format string should
! be a letter.  @sc{gnus} will call the function
  gnus-user-format-function-X, where X is the letter following @samp{%u}.
  The function will be passed the current header as argument.  The
  function should return a string, which will be inserted into the summary
***************
*** 3124,3130 ****
  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}.  In either case, fetching old headers only works if the
! select method you are using supports @sc{XOVER}.  Also remember that if
  the root of the thread has been expired by the server, there's not much
  Gnus can do about that.
  @item gnus-gather-loose-threads
--- 3191,3197 ----
  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}.  In either case, fetching old headers only works if the
! select method you are using supports @sc{xover}.  Also remember that if
  the root of the thread has been expired by the server, there's not much
  Gnus can do about that.
  @item gnus-gather-loose-threads
***************
*** 3336,3349 ****
  separately to several groups is not.
  
  One thing that may cause Gnus to not do the cross-posting thing
! correctly is if you use an NNTP server that supports @sc{xover} (which
! is very nice, because it speeds things up considerably) which does not
! include the Xref header in its @sc{NOV} lines.  This is Evil, but it's
! common.  Gnus tries to Do The Right Thing even with @sc{xover} by
! registering the Xref lines of all articles you actually read, but if you
! kill the articles, or just mark them as read without reading them, Gnus
! will not get a chance to snoop the Xref lines out of these articles, and
! will be unable to use the cross reference mechanism.
  
  @vindex gnus-nov-is-evil
  If you want Gnus to get the Xrefs right all the time, you have to set
--- 3403,3416 ----
  separately to several groups is not.
  
  One thing that may cause Gnus to not do the cross-posting thing
! correctly is if you use an @sc{nntp} server that supports @sc{xover}
! (which is very nice, because it speeds things up considerably) which
! does not include the Xref header in its @sc{nov} lines.  This is Evil,
! but it's common.  Gnus tries to Do The Right Thing even with @sc{xover}
! by registering the Xref lines of all articles you actually read, but if
! you kill the articles, or just mark them as read without reading them,
! Gnus will not get a chance to snoop the Xref lines out of these
! articles, and will be unable to use the cross reference mechanism.
  
  @vindex gnus-nov-is-evil
  If you want Gnus to get the Xrefs right all the time, you have to set
***************
*** 3491,3496 ****
--- 3558,3570 ----
  (@samp{~/News/alt/andrea-dworkin} instead of
  @samp{~/News/alt.andrea-dworkin}.)
  
+ This function also affects kill and score file names.  If this variable
+ is a list, and the list contains the element @code{not-score}, long file
+ names will not be used for score files, if it contains the element
+ @code{not-save}, long file names will not be used for saving, and if it
+ contains the element @code{not-kill}, long file names will not be used
+ for kill files.
+ 
  @node Decoding Articles
  @section Decoding Articles
  @cindex decoding articles
***************
*** 3557,3563 ****
  (@code{gnus-uu-mark-all}) and then @kbd{X U} (@code{gnus-uu-decode-uu}).
  
  All this is very much different from how @code{gnus-uu} worked with
! @sc{GNUS 4.1}, where you had explicit keystrokes for everything under
  the sun.  This version of @code{gnus-uu} generally assumes that you
  either mark articles in some way (@pxref{Setting Process Marks}) and
  then press @kbd{X u}.
--- 3631,3637 ----
  (@code{gnus-uu-mark-all}) and then @kbd{X U} (@code{gnus-uu-decode-uu}).
  
  All this is very much different from how @code{gnus-uu} worked with
! @sc{gnus 4.1}, where you had explicit keystrokes for everything under
  the sun.  This version of @code{gnus-uu} generally assumes that you
  either mark articles in some way (@pxref{Setting Process Marks}) and
  then press @kbd{X u}.
***************
*** 3647,3655 ****
  
  @item gnus-uu-ignore-files-by-type
  @vindex gnus-uu-ignore-files-by-type
! Files with a MIME type matching this variable won't be viewed.  Note
! that Gnus tries to guess what type the file is based on the name.
! @code{gnus-uu} is not a MIME package, so this is slightly kludgy.
  
  @item gnus-uu-tmp-dir
  @vindex gnus-uu-tmp-dir
--- 3721,3730 ----
  
  @item gnus-uu-ignore-files-by-type
  @vindex gnus-uu-ignore-files-by-type
! Files with a @sc{mime} type matching this variable won't be viewed.
! Note that Gnus tries to guess what type the file is based on the name.
! @code{gnus-uu} is not a @sc{mime} package (yet), so this is slightly
! kludgy.
  
  @item gnus-uu-tmp-dir
  @vindex gnus-uu-tmp-dir
***************
*** 3693,3701 ****
  @item gnus-uu-view-with-metamail
  @vindex gnus-uu-view-with-metamail
  Non-@code{nil} means that @code{gnus-uu} will ignore the viewing
! commands defined by the rule variables and just fudge a MIME content
! type based on the file name.  The result will be fed to metamail for
! viewing.
  
  @item gnus-uu-save-in-digest
  @vindex gnus-uu-save-in-digest
--- 3768,3776 ----
  @item gnus-uu-view-with-metamail
  @vindex gnus-uu-view-with-metamail
  Non-@code{nil} means that @code{gnus-uu} will ignore the viewing
! commands defined by the rule variables and just fudge a @sc{mime}
! content type based on the file name.  The result will be fed to metamail
! for viewing.
  
  @item gnus-uu-save-in-digest
  @vindex gnus-uu-save-in-digest
***************
*** 3796,3803 ****
  @item A m
  @kindex A m (Summary)
  @findex gnus-summary-toggle-mime
! Toggle whether to run the article through MIME before displaying
! (@code{gnus-summary-toggle-mime}). 
  @end table
  
  There's a battery of commands for washing the article buffer:
--- 3871,3878 ----
  @item A m
  @kindex A m (Summary)
  @findex gnus-summary-toggle-mime
! Toggle whether to run the article through @sc{mime} before displaying
! (@code{gnus-summary-toggle-mime}).
  @end table
  
  There's a battery of commands for washing the article buffer:
***************
*** 3876,3883 ****
  @kindex ^ (Summary)
  If you'd like to read the parent of the current article, and it is not
  displayed in the article buffer, you might still be able to.  That is,
! if the current group is fetched by NNTP, the parent hasn't expired and
! the References in the current article are not mangled, you can just
  press @kbd{^} or @kbd{A r} (@code{gnus-summary-refer-parent-article}).
  If everything goes well, you'll get the parent.  If the parent is
  already displayed in the summary buffer, point will just move to this
--- 3951,3958 ----
  @kindex ^ (Summary)
  If you'd like to read the parent of the current article, and it is not
  displayed in the article buffer, you might still be able to.  That is,
! if the current group is fetched by @sc{nntp}, the parent hasn't expired
! and the References in the current article are not mangled, you can just
  press @kbd{^} or @kbd{A r} (@code{gnus-summary-refer-parent-article}).
  If everything goes well, you'll get the parent.  If the parent is
  already displayed in the summary buffer, point will just move to this
***************
*** 3885,3903 ****
  
  @findex gnus-summary-refer-article
  @kindex M-^ (Summary)
! You can also ask the NNTP server for an arbitrary article, no matter
! what group it belongs to.  @kbd{V r} (@code{gnus-summary-refer-article})
! will ask you for a message-id, which is one of those long thingies that
! look something like @samp{<38o6up$6f2@@hymir.ifi.uio.no>}.  You have to
! get it all exactly right.  No fuzzy searches, I'm afraid.
  
  @vindex gnus-refer-article-method
  If the group you are reading is located on a backend that does not
  support fetching by Message-ID very well (like @code{nnspool}), you can
! set @code{gnus-refer-article-method} to an NNTP method.  It would,
! perhaps, be best if the NNTP server you consult is the same as the one
! that keeps the spool you are reading from updated, but that's not really
! necessary. 
  
  @node Score Files
  @section Score Files
--- 3960,3979 ----
  
  @findex gnus-summary-refer-article
  @kindex M-^ (Summary)
! You can also ask the @sc{nntp} server for an arbitrary article, no
! matter what group it belongs to.  @kbd{V r}
! (@code{gnus-summary-refer-article}) will ask you for a message-id, which
! is one of those long thingies that look something like
! @samp{<38o6up$6f2@@hymir.ifi.uio.no>}.  You have to get it all exactly
! right.  No fuzzy searches, I'm afraid.
  
  @vindex gnus-refer-article-method
  If the group you are reading is located on a backend that does not
  support fetching by Message-ID very well (like @code{nnspool}), you can
! set @code{gnus-refer-article-method} to an @sc{nntp} method.  It would,
! perhaps, be best if the @sc{nntp} server you consult is the same as the
! one that keeps the spool you are reading from updated, but that's not
! really necessary.
  
  @node Score Files
  @section Score Files
***************
*** 4695,4701 ****
  
  @menu
  * Hiding Headers::        Deciding what headers should be displayed.
! * Using Mime::            Pushing articles through MIME before reading them.
  * Customizing Articles::  Tailoring the look of the articles.
  * Article Keymap::        Keystrokes available in the article buffer
  * Misc Article::          Other stuff.
--- 4771,4777 ----
  
  @menu
  * Hiding Headers::        Deciding what headers should be displayed.
! * Using Mime::            Pushing articles through @sc{mime} before reading them.
  * Customizing Articles::  Tailoring the look of the articles.
  * Article Keymap::        Keystrokes available in the article buffer
  * Misc Article::          Other stuff.
***************
*** 4772,4804 ****
  
  @node Using Mime
  @section Using Mime
! @cindex MIME
  
  Mime is a standard for waving your hands through the air, aimlessly,
  while people stand around yawning.
  
! MIME, however, is a standard for encoding your articles, aimlessly,
  while all newsreaders die of fear.
  
! MIME may specify what character set the article uses, the encoding of
! the characters, and it also makes it possible to embed pictures and
  other naughty stuff in innocent-looking articles.
  
  @vindex gnus-show-mime
  @vindex gnus-show-mime-method
! Gnus handles MIME by shoving the articles through
  @code{gnus-show-mime-method}, which is @code{metamail-buffer} by
! default.  Set @code{gnus-show-mime} to @code{t} if you want to use MIME
! all the time; it might be best just use the toggling functions from the
! summary buffer to avoid getting nasty surprises (for instance, you enter
! the group @samp{alt.sing-a-long} and, before you know it, MIME has
! decoded the sounds file in the article and some horrible sing-a-long
! song comes streaming out out your speakers, and you can't find the
! volume button, because there isn't one, and people are starting to look
! at you, and you try to stop the program, but you can't, and you can't
! find the program to control the volume, and everybody else in the room
! suddenly decides to look at you disdainfully, and you'll feel rather
! stupid.)
  
  Any similarity to real events and people is purely coincidental.  Ahem.
  
--- 4848,4880 ----
  
  @node Using Mime
  @section Using Mime
! @cindex @sc{mime}
  
  Mime is a standard for waving your hands through the air, aimlessly,
  while people stand around yawning.
  
! @sc{mime}, however, is a standard for encoding your articles, aimlessly,
  while all newsreaders die of fear.
  
! @sc{mime} may specify what character set the article uses, the encoding
! of the characters, and it also makes it possible to embed pictures and
  other naughty stuff in innocent-looking articles.
  
  @vindex gnus-show-mime
  @vindex gnus-show-mime-method
! Gnus handles @sc{mime} by shoving the articles through
  @code{gnus-show-mime-method}, which is @code{metamail-buffer} by
! default.  Set @code{gnus-show-mime} to @code{t} if you want to use
! @sc{mime} all the time; it might be best just use the toggling functions
! from the summary buffer to avoid getting nasty surprises (for instance,
! you enter the group @samp{alt.sing-a-long} and, before you know it,
! @sc{mime} has decoded the sounds file in the article and some horrible
! sing-a-long song comes streaming out out your speakers, and you can't
! find the volume button, because there isn't one, and people are starting
! to look at you, and you try to stop the program, but you can't, and you
! can't find the program to control the volume, and everybody else in the
! room suddenly decides to look at you disdainfully, and you'll feel
! rather stupid.)
  
  Any similarity to real events and people is purely coincidental.  Ahem.
  
***************
*** 5039,5056 ****
  for some quite common situations.
  
  @menu
! * Slow NNTP Connection::      You run a local Emacs and get the news elsewhere.
  * Slow Terminal Connection::  You run a remote Emacs.
  * Little Disk Space::         You feel that having large setup files is icky.
  * Slow Machine::              You feel like buying a faster machine.
  @end menu
  
! @node Slow NNTP Connection
! @section Slow NNTP Connection
  
  If you run Emacs on a machine locally, and get your news from a machine
  over some very thin strings, you want to cut down on the amount of data
! Gnus has to get from the NNTP server.
  
  @table @code
  @item gnus-read-active-file
--- 5115,5132 ----
  for some quite common situations.
  
  @menu
! * Slow @sc{nntp} Connection::      You run a local Emacs and get the news elsewhere.
  * Slow Terminal Connection::  You run a remote Emacs.
  * Little Disk Space::         You feel that having large setup files is icky.
  * Slow Machine::              You feel like buying a faster machine.
  @end menu
  
! @node Slow @sc{nntp} Connection
! @section Slow @sc{nntp} Connection
  
  If you run Emacs on a machine locally, and get your news from a machine
  over some very thin strings, you want to cut down on the amount of data
! Gnus has to get from the @sc{nntp} server.
  
  @table @code
  @item gnus-read-active-file
***************
*** 5062,5069 ****
  will make it difficult for you to get hold of new groups.
  @item gnus-nov-is-evil
  This one has to be @code{nil}.  If not, grabbing article headers from
! the NNTP server will not be very fast.  Not all NNTP servers support
! @sc{XOVER}; Gnus will detect this by itself.
  @end table
  
  @node Slow Terminal Connection
--- 5138,5145 ----
  will make it difficult for you to get hold of new groups.
  @item gnus-nov-is-evil
  This one has to be @code{nil}.  If not, grabbing article headers from
! the @sc{nntp} server will not be very fast.  Not all @sc{nntp} servers
! support @sc{xover}; Gnus will detect this by itself.
  @end table
  
  @node Slow Terminal Connection
***************
*** 5159,5165 ****
  Make sure your computer is switched on.
  
  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.
  
  Try doing an @kbd{M-x gnus-version}.  If you get something that looks
--- 5235,5241 ----
  Make sure your computer is switched on.
  
  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.
  
  Try doing an @kbd{M-x gnus-version}.  If you get something that looks
