Commits

Anonymous committed 0b4047b

Synch with Quassia Gnus 0.32

  • Participants
  • Parent commits 350a866

Comments (0)

Files changed (44)

+1998-02-23  SL Baur  <steve@altair.xemacs.org>
+
+	* Synch with qgnus-0.32.
+
 1998-02-16  SL Baur  <steve@altair.xemacs.org>
 
 	* Synch with qgnus-0.28.
 # the Free Software Foundation, Inc., 59 Temple Place - Suite 330,
 # Boston, MA 02111-1307, USA.
 
-VERSION = 1.06
-AUTHOR_VERSION = 0.28q
+VERSION = 1.07
+AUTHOR_VERSION = 0.30q
 MAINTAINER = XEmacs Development Team <xemacs-beta@xemacs.org>
 PACKAGE = gnus
 PKG_TYPE = regular

File gnus/lisp/ChangeLog

+Mon Feb 23 18:06:47 1998  Lars Magne Ingebrigtsen  <larsi@menja.ifi.uio.no>
+
+	* gnus.el: Quassia Gnus v0.32 is released.
+
+Mon Feb 23 17:48:42 1998  Lars Magne Ingebrigtsen  <larsi@ifi.uio.no>
+
+	* gnus-cite.el (gnus-article-hide-citation-maybe): Wrong
+	interactive specs.
+	(gnus-cite-toggle): Maybe parse.
+
+Mon Feb 23 05:26:11 1998  Rui-Tao Dong ~{6-HpLN~}  <rdong@internetmci.com>
+
+	* nnweb.el (nnweb-type-definition): Fixed.
+
+Sun Feb 22 18:10:53 1998  Lars Magne Ingebrigtsen  <larsi@ifi.uio.no>
+
+	* gnus-agent.el (gnus-agent-group-path): Translate right chars.
+	(gnus-agent-toggle-plugged): Allow proper closing.
+
+	* gnus-srvr.el (gnus-browse-read-group): Allow entering
+	non-ephemeral groups.
+
+Sun Feb 22 04:21:15 1998  Lars Magne Ingebrigtsen  <larsi@menja.ifi.uio.no>
+
+	* gnus.el: Quassia Gnus v0.31 is released.
+
+Sun Feb 22 02:09:35 1998  Lars Magne Ingebrigtsen  <larsi@ifi.uio.no>
+
+	* gnus-sum.el (gnus-summary-highlight): Give undownloaded marks a
+	better face.
+
+	* gnus-score.el (gnus-score-set): Take optional "warn".
+	(gnus-summary-score-entry): Use it.
+
+	* gnus.el: Removed spurious * in defcustoms.
+
+	* gnus-score.el (gnus-score-load-file): Reverse logic.
+
+	* gnus-cite.el (gnus-article-hide-citation): Use markers to make
+	things work when wrapping.
+
+	* gnus-sum.el (gnus-summary-exit): Stop prefetch.
+
+Sat Feb 21 02:12:42 1998  Lars Magne Ingebrigtsen  <larsi@ifi.uio.no>
+
+	* gnus-sum.el (gnus-get-newsgroup-headers): Buggy regexp.
+
+Sat Feb 21 00:51:22 1998  Lars Magne Ingebrigtsen  <larsi@menja.ifi.uio.no>
+
+	* gnus.el: Quassia Gnus v0.30 is released.
+
+Sat Feb 21 00:09:14 1998  Lars Magne Ingebrigtsen  <larsi@ifi.uio.no>
+
+	* gnus-sum.el (gnus-summary-mark-article): Don't do anything if
+	the mark doesn't change.
+
+	* gnus-art.el (gnus-article-prepare): Don't enter article into
+	cache. 
+
+	* gnus-sum.el (gnus-summary-reparent-thread): Don't mark as read.
+	(gnus-summary-mark-article): Don't do cache things here.
+
+	* gnus-util.el (gnus-parse-netrc): Skip past macdefs.
+
+Fri Feb 20 22:56:22 1998  Lars Magne Ingebrigtsen  <larsi@ifi.uio.no>
+
+	* gnus-srvr.el (gnus-browse-unsubscribe-group): Wouldn't allow
+	unsubscription. 
+
+	* gnus-sum.el (gnus-summary-insert-subject): Allow inserting
+	articles outside limits.
+
+	* gnus-start.el (gnus-dribble-enter): Update mode line.
+
+	* gnus-srvr.el (gnus-browse-unsubscribe-group): Allow
+	unsubscription. 
+
+	* gnus-picon.el (gnus-article-display-picons): Check that the
+	extents are live first.
+
+Thu Feb 19 15:13:44 1998  Lars Magne Ingebrigtsen  <larsi@ifi.uio.no>
+
+	* gnus-group.el (gnus-useful-groups): Include gnus-bug.
+
+Thu Feb 19 02:28:17 1998  Jens-Ulrik Holger Petersen  <petersen@kurims.kyoto-u.ac.jp>
+
+	* gnus.el (gnus-group-history): Defined twice.
+
+Thu Feb 19 01:58:47 1998  Lars Magne Ingebrigtsen  <larsi@ifi.uio.no>
+
+	* gnus-sum.el (gnus-get-newsgroup-headers): Just use the header
+	value. 
+	(gnus-summary-exit): Set global vars.
+
+Tue Feb 17 07:17:49 1998  Lars Magne Ingebrigtsen  <larsi@ifi.uio.no>
+
+	* gnus-sum.el (gnus-summary-stop-page-breaking): Mark page as no
+	longer broken.
+	(gnus-summary-exit): Purge the real name.
+
 Tue Feb 17 07:00:43 1998  Lars Magne Ingebrigtsen  <larsi@menja.ifi.uio.no>
 
 	* gnus.el: Quassia Gnus v0.29 is released.
 
 Tue Feb 17 06:15:03 1998  Lars Magne Ingebrigtsen  <larsi@ifi.uio.no>
 
-	* nnmail.el (nnmail-purge-split-history): List if alists, not
+	* nnmail.el (nnmail-purge-split-history): List of alists, not
 	alist. 
 
 Mon Feb 16 20:22:04 1998  Lars Magne Ingebrigtsen  <larsi@menja.ifi.uio.no>

File gnus/lisp/_pkg.el

 ;;;###autoload
 (package-provide 'gnus
-		 :version 1.06
+		 :version 1.07
 		 :type 'regular)

File gnus/lisp/auto-autoloads.el

 
 ;;;### (autoloads nil "_pkg" "lisp/_pkg.el")
 
-(package-provide 'gnus :version 1.06 :type 'regular)
+(package-provide 'gnus :version 1.07 :type 'regular)
 
 ;;;***
 

File gnus/lisp/earcon.el

   :group 'earcon)
 
 (defcustom earcon-suffix "**"
-  "*String denoting the end of an earcon."
+  "String denoting the end of an earcon."
   :type 'string
   :group 'earcon)
 
 		       (integer :tag "Match")
 		       (string :tag "Sound")))
   :group 'earcon)
-
 (defvar earcon-button-marker-list nil)
 (make-variable-buffer-local 'earcon-button-marker-list)
 

File gnus/lisp/gnus-agent.el

 (eval-when-compile (require 'cl))
 
 (defcustom gnus-agent-directory (nnheader-concat gnus-directory "agent/")
-  "*Where the Gnus agent will store its files."
+  "Where the Gnus agent will store its files."
   :group 'gnus-agent
   :type 'directory)
 
 (defcustom gnus-agent-plugged-hook nil
-  "*Hook run when plugging into the network."
+  "Hook run when plugging into the network."
   :group 'gnus-agent
   :type 'hook)
 
 (defcustom gnus-agent-unplugged-hook nil
-  "*Hook run when unplugging from the network."
+  "Hook run when unplugging from the network."
   :group 'gnus-agent
   :type 'hook)
 
 (defcustom gnus-agent-handle-level gnus-level-subscribed
-  "*Groups on levels higher than this variable will be ignored by the Agent."
+  "Groups on levels higher than this variable will be ignored by the Agent."
   :group 'gnus-agent
   :type 'integer)
 
 (defun gnus-agent-toggle-plugged (plugged)
   "Toggle whether Gnus is unplugged or not."
   (interactive (list (not gnus-plugged)))
-  (setq gnus-plugged plugged)
   (if plugged
       (progn
+	(setq gnus-plugged plugged)
 	(gnus-run-hooks 'gnus-agent-plugged-hook)
 	(setcar (cdr gnus-agent-mode-status) " Plugged"))
     (gnus-agent-close-connections)
+    (setq gnus-plugged plugged)
     (gnus-run-hooks 'gnus-agent-unplugged-hook)
     (setcar (cdr gnus-agent-mode-status) " Unplugged"))
   (set-buffer-modified-p t))
   "Translate GROUP into a path."
   (if nnmail-use-long-file-names
       group
-    (nnheader-translate-file-chars
-     (nnheader-replace-chars-in-string group ?. ?/))))
+    (nnheader-replace-chars-in-string
+     (nnheader-translate-file-chars group)
+     ?. ?/)))
 
 
 
 	    (if (not (re-search-forward "^Message-ID: *<\\([^>\n]+\\)>" nil t))
 		(setq id "No-Message-ID-in-article")
 	      (setq id (buffer-substring (match-beginning 1) (match-end 1))))
-	    (let ((coding-system-for-write gnus-agent-article-file-coding-system))
+	    (let ((coding-system-for-write
+		   gnus-agent-article-file-coding-system))
 	      (write-region (point-min) (point-max)
 			    (concat dir (number-to-string (caar pos)))
 			    nil 'silent))

File gnus/lisp/gnus-art.el

   :group 'gnus-article-hiding)
 
 (defcustom gnus-visible-headers
-  "^From:\\|^Newsgroups:\\|^Subject:\\|^Date:\\|^Followup-To:\\|^Reply-To:\\|^Organization:\\|^Summary:\\|^Keywords:\\|^To:\\|^Cc:\\|^Posted-To:\\|^Mail-Copies-To:\\|^Apparently-To:\\|^Gnus-Warning:\\|^Resent-From:\\|X-Sent:"
+  "From:\\|^Newsgroups:\\|^Subject:\\|^Date:\\|^Followup-To:\\|^Reply-To:\\|^Organization:\\|^Summary:\\|^Keywords:\\|^To:\\|^Cc:\\|^Posted-To:\\|^Mail-Copies-To:\\|^Apparently-To:\\|^Gnus-Warning:\\|^Resent-From:\\|X-Sent:"
   "*All headers that do not match this regexp will be hidden.
 This variable can also be a list of regexp of headers to remain visible.
 If this variable is non-nil, `gnus-ignored-headers' will be ignored."
   :group 'gnus-article-hiding)
 
 (defcustom gnus-boring-article-headers '(empty followup-to reply-to)
-  "*Headers that are only to be displayed if they have interesting data.
+  "Headers that are only to be displayed if they have interesting data.
 Possible values in this list are `empty', `newsgroups', `followup-to',
 `reply-to', `date', `long-to', and `many-to'."
   :type '(set (const :tag "Headers with no content." empty)
   :group 'gnus-article-hiding)
 
 (defcustom gnus-signature-separator '("^-- $" "^-- *$")
-  "*Regexp matching signature separator.
+  "Regexp matching signature separator.
 This can also be a list of regexps.  In that case, it will be checked
 from head to tail looking for a separator.  Searches will be done from
 the end of the buffer."
   :group 'gnus-article-signature)
 
 (defcustom gnus-signature-limit nil
-   "*Provide a limit to what is considered a signature.
+   "Provide a limit to what is considered a signature.
 If it is a number, no signature may not be longer (in characters) than
 that number.  If it is a floating point number, no signature may be
 longer (in lines) than that number.  If it is a function, the function
   :group 'gnus-article-signature)
 
 (defcustom gnus-hidden-properties '(invisible t intangible t)
-  "*Property list to use for hiding text."
+  "Property list to use for hiding text."
   :type 'sexp
   :group 'gnus-article-hiding)
 
 (defcustom gnus-article-x-face-command
-  "{ echo '/* Width=48, Height=48 */'; uncompface; } | icontopbm | xv -quit -"
+  " echo '/* Width=48, Height=48 */'; uncompface; } | icontopbm | xv -quit -"
   "*String or function to be executed to display an X-Face header.
 If it is a string, the command will be executed in a sub-shell
 asynchronously.	 The compressed face will be piped to this command."
   :group 'gnus-article-washing)
 
 (defcustom gnus-article-x-face-too-ugly nil
-  "*Regexp matching posters whose face shouldn't be shown automatically."
+  "Regexp matching posters whose face shouldn't be shown automatically."
   :type '(choice regexp (const nil))
   :group 'gnus-article-washing)
 
   :group 'gnus-article-emphasis)
 
 (defcustom gnus-article-time-format "%a, %b %d %Y %T %Z"
-  "*Format for display of Date headers in article bodies.
+  "Format for display of Date headers in article bodies.
 See `format-time-string' for the possible values.
 
 The variable can also be function, which should return a complete Date
 		 (sexp :tag "once" :format "%t\n" :value t)))
 
 (defcustom gnus-saved-headers gnus-visible-headers
-  "*Headers to keep if `gnus-save-all-headers' is nil.
+  "Headers to keep if `gnus-save-all-headers' is nil.
 If `gnus-save-all-headers' is non-nil, this variable will be ignored.
 If that variable is nil, however, all headers that match this regexp
 will be kept while the rest will be deleted before saving."
   :type 'regexp)
 
 (defcustom gnus-default-article-saver 'gnus-summary-save-in-rmail
-  "*A function to save articles in your favourite format.
+  "A function to save articles in your favourite format.
 The function must be interactively callable (in other words, it must
 be an Emacs command).
 
 		(function-item gnus-summary-write-to-file)))
 
 (defcustom gnus-rmail-save-name 'gnus-plain-save-name
-  "*A function generating a file name to save articles in Rmail format.
+  "A function generating a file name to save articles in Rmail format.
 The function is called with NEWSGROUP, HEADERS, and optional LAST-FILE."
   :group 'gnus-article-saving
   :type 'function)
 
 (defcustom gnus-mail-save-name 'gnus-plain-save-name
-  "*A function generating a file name to save articles in Unix mail format.
+  "A function generating a file name to save articles in Unix mail format.
 The function is called with NEWSGROUP, HEADERS, and optional LAST-FILE."
   :group 'gnus-article-saving
   :type 'function)
 
 (defcustom gnus-folder-save-name 'gnus-folder-save-name
-  "*A function generating a file name to save articles in MH folder.
+  "A function generating a file name to save articles in MH folder.
 The function is called with NEWSGROUP, HEADERS, and optional LAST-FOLDER."
   :group 'gnus-article-saving
   :type 'function)
 
 (defcustom gnus-file-save-name 'gnus-numeric-save-name
-  "*A function generating a file name to save articles in article format.
+  "A function generating a file name to save articles in article format.
 The function is called with NEWSGROUP, HEADERS, and optional
 LAST-FILE."
   :group 'gnus-article-saving
   :type 'boolean)
 
 (defcustom gnus-show-mime-method 'metamail-buffer
-  "*Function to process a MIME message.
+  "Function to process a MIME message.
 The function is called from the article buffer."
   :group 'gnus-article-mime
   :type 'function)
   :group 'gnus-article-various)
 
 (defcustom gnus-article-button-face 'bold
-  "*Face used for highlighting buttons in the article buffer.
+  "Face used for highlighting buttons in the article buffer.
 
 An article button is a piece of text that you can activate by pressing
 `RET' or `mouse-2' above it."
   :group 'gnus-article-buttons)
 
 (defcustom gnus-article-mouse-face 'highlight
-  "*Face used for mouse highlighting in the article buffer.
+  "Face used for mouse highlighting in the article buffer.
 
 Article buttons will be displayed in this face when the cursor is
 above them."
   :group 'gnus-article-buttons)
 
 (defcustom gnus-signature-face 'gnus-signature-face
-  "*Face used for highlighting a signature in the article buffer.
+  "Face used for highlighting a signature in the article buffer.
 Obsolete; use the face `gnus-signature-face' for customizations instead."
   :type 'face
   :group 'gnus-article-highlight
 		;; <sisolak@trans4.neep.wisc.edu>.
 		(gnus-set-global-variables)
 		(setq gnus-have-all-headers
-		      (or all-headers gnus-show-all-headers))
-		(and gnus-use-cache
-		     (vectorp (gnus-summary-article-header article))
-		     (gnus-cache-possibly-enter-article
-		      group article
-		      (gnus-summary-article-header article)
-		      (memq article gnus-newsgroup-marked)
-		      (memq article gnus-newsgroup-dormant)
-		      (memq article gnus-newsgroup-unreads)))))
+		      (or all-headers gnus-show-all-headers))))
 	    (when (or (numberp article)
 		      (stringp article))
 	      ;; Hooks for getting information from the article.
 This means that PGP stuff, signatures, cited text and (some)
 headers will be hidden.
 If given a prefix, show the hidden text instead."
-  (interactive (list current-prefix-arg 'force))
+  (interactive (append (gnus-article-hidden-arg) (list 'force)))
   (gnus-article-hide-headers arg)
   (gnus-article-hide-pgp arg)
   (gnus-article-hide-citation-maybe arg force)
 ;;;
 
 (defcustom gnus-article-edit-mode-hook nil
-  "*Hook run in article edit mode buffers."
+  "Hook run in article edit mode buffers."
   :group 'gnus-article-various
   :type 'hook)
 
 ;;; Internal Variables:
 
 (defcustom gnus-button-url-regexp "\\b\\(s?https?\\|ftp\\|file\\|gopher\\|news\\|telnet\\|wais\\|mailto\\):\\(//[-a-zA-Z0-9_.]+:[0-9]*\\)?\\([-a-zA-Z0-9_=!?#$@~`%&*+|\\/:;.,]\\|\\w\\)+\\([-a-zA-Z0-9_=#$@~`%&*+|\\/]\\|\\w\\)"
-  "*Regular expression that matches URLs."
+  "Regular expression that matches URLs."
   :group 'gnus-article-buttons
   :type 'regexp)
 

File gnus/lisp/gnus-async.el

 		 (integer :tag "some" 0)))
 
 (defcustom gnus-prefetched-article-deletion-strategy '(read exit)
-  "*List of symbols that say when to remove articles from the prefetch buffer.
+  "List of symbols that say when to remove articles from the prefetch buffer.
 Possible values in this list are `read', which means that
 articles are removed as they are read, and `exit', which means
 that all articles belonging to a group are removed on exit
   :type 'boolean)
 
 (defcustom gnus-async-prefetch-article-p 'gnus-async-unread-p
-  "*Function called to say whether an article should be prefetched or not.
+  "Function called to say whether an article should be prefetched or not.
 The function is called with one parameter -- the article data.
 It should return non-nil if the article is to be prefetched."
   :group 'gnus-asynchronous

File gnus/lisp/gnus-cache.el

   :type 'file)
 
 (defcustom gnus-cache-enter-articles '(ticked dormant)
-  "*Classes of articles to enter into the cache."
+  "Classes of articles to enter into the cache."
   :group 'gnus-cache
   :type '(set (const ticked) (const dormant) (const unread) (const read)))
 
 (defcustom gnus-cache-remove-articles '(read)
-  "*Classes of articles to remove from the cache."
+  "Classes of articles to remove from the cache."
   :group 'gnus-cache
   :type '(set (const ticked) (const dormant) (const unread) (const read)))
 

File gnus/lisp/gnus-cite.el

   :type 'string)
 
 (defcustom gnus-cite-always-check nil
-  "*Check article always for citations. Set it t to check all articles."
+  "Check article always for citations. Set it t to check all articles."
   :group 'gnus-cite
   :type '(choice (const :tag "no" nil)
 		  (const :tag "yes" t)))
 
 (defcustom gnus-cited-text-button-line-format "%(%{[...]%}%)\n"
-  "*Format of cited text buttons."
+  "Format of cited text buttons."
   :group 'gnus-cite
   :type 'string)
 
 (defcustom gnus-cited-lines-visible nil
-  "*The number of lines of hidden cited text to remain visible."
+  "The number of lines of hidden cited text to remain visible."
   :group 'gnus-cite
   :type '(choice (const :tag "none" nil)
 		 integer))
 
 (defcustom gnus-cite-parse-max-size 25000
-  "*Maximum article size (in bytes) where parsing citations is allowed.
+  "Maximum article size (in bytes) where parsing citations is allowed.
 Set it to nil to parse all articles."
   :group 'gnus-cite
   :type '(choice (const :tag "all" nil)
 		 integer))
 
 (defcustom gnus-cite-prefix-regexp
-    "^[]>|:}+ ]*[]>|:}+]\\(.*>\\)?\\|^.*>"
+  "^[]>|:}+ ]*[]>|:}+]\\(.*>\\)?\\|^.*>"
   "*Regexp matching the longest possible citation prefix on a line."
   :group 'gnus-cite
   :type 'regexp)
 
 (defcustom gnus-cite-max-prefix 20
-  "*Maximum possible length for a citation prefix."
+  "Maximum possible length for a citation prefix."
   :group 'gnus-cite
   :type 'integer)
 
   :type 'regexp)
 
 (defcustom gnus-supercite-secondary-regexp "^.*\"\\([^\"\n]+\\)\" +=="
-  "*Regexp matching mangled Supercite attribution lines.
+  "Regexp matching mangled Supercite attribution lines.
 The first regexp group should match the Supercite attribution."
   :group 'gnus-cite
   :type 'regexp)
 
 (defcustom gnus-cite-minimum-match-count 2
-  "*Minimum number of identical prefixes before we believe it's a citation."
+  "Minimum number of identical prefixes before we believe it's a citation."
   :group 'gnus-cite
   :type 'integer)
 
 (defcustom gnus-cite-attribution-prefix 
-  "in article\\|in <\\|On \\(Mon\\|Tue\\|Wed\\|Thu\\|Fri\\|Sat\\|Sun\\),"
+  "In article\\|in <\\|On \\(Mon\\|Tue\\|Wed\\|Thu\\|Fri\\|Sat\\|Sun\\),"
   "*Regexp matching the beginning of an attribution line."
   :group 'gnus-cite
   :type 'regexp)
   "Face used for attribution lines.")
 
 (defcustom gnus-cite-attribution-face 'gnus-cite-attribution-face
-  "*Face used for attribution lines.
+  "Face used for attribution lines.
 It is merged with the face for the cited text belonging to the attribution."
   :group 'gnus-cite
   :type 'face)
   :type '(repeat face))
 
 (defcustom gnus-cite-hide-percentage 50
-  "*Only hide excess citation if above this percentage of the body."
+  "Only hide excess citation if above this percentage of the body."
   :group 'gnus-cite
   :type 'number)
 
 (defcustom gnus-cite-hide-absolute 10
-  "*Only hide excess citation if above this number of lines in the body."
+  "Only hide excess citation if above this number of lines in the body."
   :group 'gnus-cite
   :type 'integer)
 
 	       (gnus-article-add-button
 		(point)
 		(progn (eval gnus-cited-text-button-line-format-spec) (point))
-		`gnus-article-toggle-cited-text (cons beg end))
+		`gnus-article-toggle-cited-text
+		;; We use markers for the end-points to facilitate later
+		;; wrapping and mangling of text.
+		(cons (set-marker (make-marker) beg)
+		      (set-marker (make-marker) end)))
 	       (point))
 	     'article-type 'annotation)
 	    (set-marker beg (point)))))))))
 (defun gnus-article-toggle-cited-text (region)
   "Toggle hiding the text in REGION."
   (let (buffer-read-only)
-    (funcall
+    (funcall 
      (if (text-property-any
 	  (car region) (1- (cdr region))
 	  (car gnus-hidden-properties) (cadr gnus-hidden-properties))
 cited text with attributions.  When called interactively, these two
 variables are ignored.
 See also the documentation for `gnus-article-highlight-citation'."
-  (interactive (append (gnus-article-hidden-arg) (list 'force)))
+  (interactive (append (gnus-article-hidden-arg) '(force)))
   (unless (gnus-article-check-hidden-text 'cite arg)
     (save-excursion
       (set-buffer gnus-article-buffer)
 (defun gnus-cite-toggle (prefix)
   (save-excursion
     (set-buffer gnus-article-buffer)
+    (gnus-cite-parse-maybe)
     (let ((buffer-read-only nil)
 	  (numbers (cdr (assoc prefix gnus-cite-prefix-alist)))
 	  (inhibit-point-motion-hooks t)

File gnus/lisp/gnus-demon.el

   :group 'gnus)
 
 (defcustom gnus-demon-handlers nil
-  "*Alist of daemonic handlers to be run at intervals.
+  "Alist of daemonic handlers to be run at intervals.
 Each handler is a list on the form
 
 \(FUNCTION TIME IDLE)

File gnus/lisp/gnus-eform.el

   :group 'gnus)
 
 (defcustom gnus-edit-form-mode-hook nil
-  "*Hook run in `gnus-edit-form-mode' buffers."
+  "Hook run in `gnus-edit-form-mode' buffers."
   :group 'gnus-edit-form
   :type 'hook)
 
 (defcustom gnus-edit-form-menu-hook nil
-  "*Hook run when creating menus in `gnus-edit-form-mode' buffers."
+  "Hook run when creating menus in `gnus-edit-form-mode' buffers."
   :group 'gnus-edit-form
   :type 'hook)
 

File gnus/lisp/gnus-group.el

 (require 'gnus-undo)
 
 (defcustom gnus-group-archive-directory
-  "/ftp@ftp.hpc.uh.edu:/pub/emacs/ding-list/"
+  "*ftp@ftp.hpc.uh.edu:/pub/emacs/ding-list/"
   "*The address of the (ding) archives."
   :group 'gnus-group-foreign
   :type 'directory)
 
 (defcustom gnus-group-recent-archive-directory
-  "/ftp@ftp.hpc.uh.edu:/pub/emacs/ding-list-recent/"
+  "*ftp@ftp.hpc.uh.edu:/pub/emacs/ding-list-recent/"
   "*The address of the most recent (ding) articles."
   :group 'gnus-group-foreign
   :type 'directory)
   :type 'string)
 
 (defcustom gnus-group-mode-hook nil
-  "*Hook for Gnus group mode."
+  "Hook for Gnus group mode."
   :group 'gnus-group-various
   :options '(gnus-topic-mode)
   :type 'hook)
 
 (defcustom gnus-group-menu-hook nil
-  "*Hook run after the creation of the group mode menu."
+  "Hook run after the creation of the group mode menu."
   :group 'gnus-group-various
   :type 'hook)
 
 (defcustom gnus-group-catchup-group-hook nil
-  "*Hook run when catching up a group from the group buffer."
+  "Hook run when catching up a group from the group buffer."
   :group 'gnus-group-various
   :link '(custom-manual "(gnus)Group Data")
   :type 'hook)
 
 (defcustom gnus-group-update-group-hook nil
-  "*Hook called when updating group lines."
+  "Hook called when updating group lines."
   :group 'gnus-group-visual
   :type 'hook)
 
   :type 'function)
 
 (defcustom gnus-group-prepare-hook nil
-  "*Hook called after the group buffer has been generated.
+  "Hook called after the group buffer has been generated.
 If you want to modify the group buffer, you can use this hook."
   :group 'gnus-group-listing
   :type 'hook)
 
 (defcustom gnus-suspend-gnus-hook nil
-  "*Hook called when suspending (not exiting) Gnus."
+  "Hook called when suspending (not exiting) Gnus."
   :group 'gnus-exit
   :type 'hook)
 
 (defcustom gnus-exit-gnus-hook nil
-  "*Hook called when exiting Gnus."
+  "Hook called when exiting Gnus."
   :group 'gnus-exit
   :type 'hook)
 
 (defcustom gnus-after-exiting-gnus-hook nil
-  "*Hook called after exiting Gnus."
+  "Hook called after exiting Gnus."
   :group 'gnus-exit
   :type 'hook)
 
 (defcustom gnus-group-update-hook '(gnus-group-highlight-line)
-  "*Hook called when a group line is changed.
+  "Hook called when a group line is changed.
 The hook will not be called if `gnus-visual' is nil.
 
 The default function `gnus-group-highlight-line' will
   :type 'hook)
 
 (defcustom gnus-useful-groups
-  `(("(ding) mailing list mirrored at sunsite.auc.dk"
+  '(("(ding) mailing list mirrored at sunsite.auc.dk"
      "emacs.ding"
      (nntp "sunsite.auc.dk"
-			(nntp-address "sunsite.auc.dk")))
+	   (nntp-address "sunsite.auc.dk")))
+    ("gnus-bug archive"
+     "gnus-bug"
+     (nndir "/ftp@ftp.ifi.uio.no:/pub/emacs/gnus/gnus-bug/"))
     ("Gnus help group"
      "gnus-help"
      (nndoc "gnus-help"
   :type '(repeat (cons (sexp :tag "Form") face)))
 
 (defcustom gnus-new-mail-mark ?%
-  "*Mark used for groups with new mail."
+  "Mark used for groups with new mail."
   :group 'gnus-group-visual
   :type 'character)
 

File gnus/lisp/gnus-int.el

 (require 'gnus)
 
 (defcustom gnus-open-server-hook nil
-  "*Hook called just before opening connection to the news server."
+  "Hook called just before opening connection to the news server."
   :group 'gnus-start
   :type 'hook)
 

File gnus/lisp/gnus-kill.el

 (require 'gnus-range)
 
 (defcustom gnus-kill-file-mode-hook nil
-  "*Hook for Gnus kill file mode."
+  "Hook for Gnus kill file mode."
   :group 'gnus-score-kill
   :type 'hook)
 
   :type 'boolean)
 
 (defcustom gnus-winconf-kill-file nil
-  "*What does this do, Lars?"
+  "What does this do, Lars?"
   :group 'gnus-score-kill
   :type 'sexp)
 

File gnus/lisp/gnus-picon.el

   :group 'gnus-visual)
 
 (defcustom gnus-picons-display-where 'picons
-  "*Where to display the group and article icons.
+  "Where to display the group and article icons.
 Legal values are `article' and `picons'."
   :type '(choice symbol string)
   :group 'picons)
 
 (defcustom gnus-picons-has-modeline-p t
-  "*Wether the picons window should have a modeline.
+  "*Whether the picons window should have a modeline.
 This is only useful if `gnus-picons-display-where' is `picons'."
   :type 'boolean
   :group 'picons)
   :group 'picons)
 
 (defcustom gnus-picons-x-face-file-name
-  (format "/tmp/picon-xface.%s.xbm" (user-login-name))
+  '(format "/tmp/picon-xface.%s.xbm" (user-login-name))
   "*The name of the file in which to store the converted X-face header."
   :type 'string
   :group 'picons)
 	  ;; wrongly placed.  Move them here
 	  (if (eq gnus-picons-display-where 'article)
 	      (dolist (ext gnus-group-annotations)
-		(set-extent-endpoints ext (point) (point))))
+		(when (extent-live-p ext)
+		  (set-extent-endpoints ext (point) (point)))))
 	  (if (null gnus-picons-piconsearch-url)
 	      (setq gnus-article-annotations
 		    (nconc gnus-article-annotations

File gnus/lisp/gnus-salt.el

   :group 'gnus-summary-pick)
 
 (defcustom gnus-pick-mode-hook nil
-  "*Hook run in summary pick mode buffers."
+  "Hook run in summary pick mode buffers."
   :type 'hook
   :group 'gnus-summary-pick)
 
   :group 'gnus-summary-pick)
 
 (defcustom gnus-pick-elegant-flow t
-  "*If non-nil, gnus-pick-start-reading will run gnus-summary-next-group when no articles have been picked."
+  "If non-nil, gnus-pick-start-reading will run gnus-summary-next-group when no articles have been picked."
   :type 'boolean
   :group 'gnus-summary-pick)
 
 (defcustom gnus-summary-pick-line-format
-  "%-5P %U\%R\%z\%I\%(%[%4L: %-20,20n%]%) %s\n"
+  "-5P %U\%R\%z\%I\%(%[%4L: %-20,20n%]%) %s\n"
   "*The format specification of the lines in pick buffers.
 It accepts the same format specs that `gnus-summary-line-format' does."
   :type 'string
 ;;;
 
 (defcustom gnus-tree-line-format "%(%[%3,3n%]%)"
-  "*Format of tree elements."
+  "Format of tree elements."
   :type 'string
   :group 'gnus-summary-tree)
 
 (defcustom gnus-tree-minimize-window t
-  "*If non-nil, minimize the tree buffer window.
+  "If non-nil, minimize the tree buffer window.
 If a number, never let the tree buffer grow taller than that number of
 lines."
   :type 'boolean

File gnus/lisp/gnus-score.el

 (require 'message)
 
 (defcustom gnus-global-score-files nil
-  "*List of global score files and directories.
+  "List of global score files and directories.
 Set this variable if you want to use people's score files.  One entry
 for each score file or each score file directory.  Gnus will decide
 by itself what score files are applicable to which group.
   :type '(repeat file))
 
 (defcustom gnus-score-file-single-match-alist nil
-  "*Alist mapping regexps to lists of score files.
+  "Alist mapping regexps to lists of score files.
 Each element of this alist should be of the form
 	(\"REGEXP\" [ \"SCORE-FILE-1\" ] [ \"SCORE-FILE-2\" ] ... )
 
   :type '(repeat (cons regexp (repeat file))))
 
 (defcustom gnus-score-file-multiple-match-alist nil
-  "*Alist mapping regexps to lists of score files.
+  "Alist mapping regexps to lists of score files.
 Each element of this alist should be of the form
 	(\"REGEXP\" [ \"SCORE-FILE-1\" ] [ \"SCORE-FILE-2\" ] ... )
 
   :type '(repeat (cons regexp (repeat file))))
 
 (defcustom gnus-score-file-suffix "SCORE"
-  "*Suffix of the score files."
+  "Suffix of the score files."
   :group 'gnus-score-files
   :type 'string)
 
 (defcustom gnus-adaptive-file-suffix "ADAPT"
-  "*Suffix of the adaptive score files."
+  "Suffix of the adaptive score files."
   :group 'gnus-score-files
   :group 'gnus-score-adapt
   :type 'string)
 
 (defcustom gnus-score-find-score-files-function 'gnus-score-find-bnews
-  "*Function used to find score files.
+  "Function used to find score files.
 The function will be called with the group name as the argument, and
 should return a list of score files to apply to that group.  The score
 files do not actually have to exist.
 
 This variable can also be a list of functions to be called.  Each
 function should either return a list of score files, or a list of
-score alists."
+score alists.
+
+If functions other than these pre-defined functions are used,
+the `a' symbolic prefix to the score commands will always use
+\"all.SCORE\"."
   :group 'gnus-score-files
   :type '(radio (function-item gnus-score-find-single)
 		(function-item gnus-score-find-hierarchical)
   :type 'number)
 
 (defcustom gnus-home-score-file nil
-  "*Variable to control where interactive score entries are to go.
+  "Variable to control where interactive score entries are to go.
 It can be:
 
  * A string
 		 (function :value fun)))
 
 (defcustom gnus-home-adapt-file nil
-  "*Variable to control where new adaptive score entries are to go.
+  "Variable to control where new adaptive score entries are to go.
 This variable allows the same syntax as `gnus-home-score-file'."
   :group 'gnus-score-adapt
   :group 'gnus-score-files
 				   (integer :tag "Score"))))))
 
 (defcustom gnus-ignored-adaptive-words nil
-  "*List of words to be ignored when doing adaptive word scoring."
+  "List of words to be ignored when doing adaptive word scoring."
   :group 'gnus-score-adapt
   :type '(repeat string))
 
 		     (integer :tag "Score"))))
 
 (defcustom gnus-adaptive-word-minimum nil
-  "*If a number, this is the minimum score value that can be assigned to a word."
+  "If a number, this is the minimum score value that can be assigned to a word."
   :group 'gnus-score-adapt
   :type '(choice (const nil) integer))
 
   :type '(choice (const nil) integer))
 
 (defcustom gnus-score-uncacheable-files "ADAPT$"
-  "*All score files that match this regexp will not be cached."
+  "All score files that match this regexp will not be cached."
   :group 'gnus-score-adapt
   :group 'gnus-score-files
   :type 'regexp)
 
 (defcustom gnus-score-default-header nil
-  "*Default header when entering new scores.
+  "Default header when entering new scores.
 
 Should be one of the following symbols.
 
 		 (const :tag "ask" nil)))
 
 (defcustom gnus-score-default-type nil
-  "*Default match type when entering new scores.
+  "Default match type when entering new scores.
 
 Should be one of the following symbols.
 
 		 (const :tag "ask" nil)))
 
 (defcustom gnus-score-default-fold nil
-  "*Use case folding for new score file entries iff not nil."
+  "Use case folding for new score file entries iff not nil."
   :group 'gnus-score-default
   :type 'boolean)
 
 (defcustom gnus-score-default-duration nil
-  "*Default duration of effect when entering new scores.
+  "Default duration of effect when entering new scores.
 
 Should be one of the following symbols.
 
 		 (const :tag "ask" nil)))
 
 (defcustom gnus-score-after-write-file-function nil
-  "*Function called with the name of the score file just written to disk."
+  "Function called with the name of the score file just written to disk."
   :group 'gnus-score-files
   :type 'function)
 
 (defcustom gnus-score-thread-simplify nil
-  "*If non-nil, subjects will simplified as in threading."
+  "If non-nil, subjects will simplified as in threading."
   :group 'gnus-score-various
   :type 'boolean) 
 
 				  (or (nth 1 new)
 				      gnus-score-interactive-default-score)))
 	  ;; Nope, we have to add a new elem.
-	  (gnus-score-set header (if old (cons new old) (list new))))
+	  (gnus-score-set header (if old (cons new old) (list new)) nil t))
 	(gnus-score-set 'touched '(t))))
 
     ;; Score the current buffer.
 	     "references" id 's
 	     score (current-time-string))))))))
 
-(defun gnus-score-set (symbol value &optional alist)
+(defun gnus-score-set (symbol value &optional alist warn)
   ;; Set SYMBOL to VALUE in ALIST.
   (let* ((alist
 	  (or alist
 	 (entry (assoc symbol alist)))
     (cond ((gnus-score-get 'read-only alist)
 	   ;; This is a read-only score file, so we do nothing.
-	   )
+	   (when warn
+	     (gnus-message 4 "Note: read-only score file; entry discarded")))
 	  (entry
 	   (setcdr entry value))
 	  ((null alist)
 		  (expand-file-name sfile gnus-kill-files-directory)))
 	       exclude-files))
 	     gnus-scores-exclude-files))
-      (unless local
+      (when local
 	(save-excursion
 	  (set-buffer gnus-summary-buffer)
 	  (while local

File gnus/lisp/gnus-srvr.el

   "Enter the group at the current line."
   (interactive)
   (let ((group (gnus-browse-group-name)))
-    (unless (gnus-group-read-ephemeral-group
-	     group gnus-browse-current-method nil
-	     (cons (current-buffer) 'browse))
-      (error "Couldn't enter %s" group))))
-
+    (if (or (not (gnus-get-info group))
+	    (gnus-ephemeral-group-p group))
+	(unless (gnus-group-read-ephemeral-group
+		 group gnus-browse-current-method nil
+		 (cons (current-buffer) 'browse))
+	  (error "Couldn't enter %s" group))
+      (unless (gnus-group-read-group nil no-article group)
+	(error "Couldn't enter %s" group)))))
+      
 (defun gnus-browse-select-group ()
   "Select the current group."
   (interactive)
       ;; If this group it killed, then we want to subscribe it.
       (when (= (following-char) ?K)
 	(setq sub t))
-      (when (cadr (gnus-gethash (setq group (gnus-browse-group-name))
-			  gnus-newsrc-hashtb))
+      (setq group (gnus-browse-group-name))
+      (when (and sub
+		 (cadr (gnus-gethash group gnus-newsrc-hashtb)))
 	(error "Group already subscribed"))
-      ;; Make sure the group has been properly removed before we
-      ;; subscribe to it.
-      (gnus-kill-ephemeral-group group)
       (delete-char 1)
       (if sub
 	  (progn
+	    ;; Make sure the group has been properly removed before we
+	    ;; subscribe to it.
+	    (gnus-kill-ephemeral-group group)
 	    (gnus-group-change-level
 	     (list t group gnus-level-default-subscribed
 		   nil nil (if (gnus-server-equal

File gnus/lisp/gnus-start.el

 (eval-when-compile (require 'cl))
 
 (defcustom gnus-startup-file (nnheader-concat gnus-home-directory ".newsrc")
-  "*Your `.newsrc' file.
+  "Your `.newsrc' file.
 `.newsrc-SERVER' will be used instead if that exists."
   :group 'gnus-start
   :type 'file)
 
 (defcustom gnus-init-file (nnheader-concat gnus-home-directory ".gnus")
-  "*Your Gnus Emacs-Lisp startup file name.
+  "Your Gnus Emacs-Lisp startup file name.
 If a file with the `.el' or `.elc' suffixes exists, it will be read instead."
   :group 'gnus-start
   :type 'file)
   :type '(choice file (const nil)))
 
 (defcustom gnus-default-subscribed-newsgroups nil
-  "*List of newsgroups to subscribe, when a user runs Gnus the first time.
+  "List of newsgroups to subscribe, when a user runs Gnus the first time.
 The value should be a list of strings.
 If it is t, Gnus will not do anything special the first time it is
 started; it'll just use the normal newsgroups subscription methods."
   :type 'boolean)
 
 (defcustom gnus-auto-subscribed-groups
-  "^nnml\\|^nnfolder\\|^nnmbox\\|^nnmh\\|^nnbabyl"
+  "nnml\\|^nnfolder\\|^nnmbox\\|^nnmh\\|^nnbabyl"
   "*All new groups that match this regexp will be subscribed automatically.
 Note that this variable only deals with new groups.  It has no effect
 whatsoever on old groups.
   :type 'boolean)
 
 (defcustom gnus-check-bogus-groups-hook nil
-  "*A hook run after removing bogus groups."
+  "A hook run after removing bogus groups."
   :group 'gnus-start-server
   :type 'hook)
 
 (defcustom gnus-startup-hook nil
-  "*A hook called at startup.
+  "A hook called at startup.
 This hook is called after Gnus is connected to the NNTP server."
   :group 'gnus-start
   :type 'hook)
 
 (defcustom gnus-before-startup-hook nil
-  "*A hook called at before startup.
+  "A hook called at before startup.
 This hook is called as the first thing when Gnus is started."
   :group 'gnus-start
   :type 'hook)
 
 (defcustom gnus-started-hook nil
-  "*A hook called as the last thing after startup."
+  "A hook called as the last thing after startup."
   :group 'gnus-start
   :type 'hook)
 
 (defcustom gnus-setup-news-hook nil
-  "*A hook after reading the .newsrc file, but before generating the buffer."
+  "A hook after reading the .newsrc file, but before generating the buffer."
   :group 'gnus-start
   :type 'hook)
 
 (defcustom gnus-get-new-news-hook nil
-  "*A hook run just before Gnus checks for new news."
+  "A hook run just before Gnus checks for new news."
   :group 'gnus-group-new
   :type 'hook)
 
   :type 'hook)
 
 (defcustom gnus-save-newsrc-hook nil
-  "*A hook called before saving any of the newsrc files."
+  "A hook called before saving any of the newsrc files."
   :group 'gnus-newsrc
   :type 'hook)
 
 (defcustom gnus-save-quick-newsrc-hook nil
-  "*A hook called just before saving the quick newsrc file.
+  "A hook called just before saving the quick newsrc file.
 Can be used to turn version control on or off."
   :group 'gnus-newsrc
   :type 'hook)
 
 (defcustom gnus-save-standard-newsrc-hook nil
-  "*A hook called just before saving the standard newsrc file.
+  "A hook called just before saving the standard newsrc file.
 Can be used to turn version control on or off."
   :group 'gnus-newsrc
   :type 'hook)
       (insert string "\n")
       (set-window-point (get-buffer-window (current-buffer)) (point-max))
       (bury-buffer gnus-dribble-buffer)
+      (save-excursion
+	(set-buffer gnus-group-buffer)
+	(gnus-group-set-mode-line))
       (set-buffer obuf))))
 
 (defun gnus-dribble-touch ()

File gnus/lisp/gnus-sum.el

 		 (sexp :menu-tag "on" t)))
 
 (defcustom gnus-simplify-subject-functions nil
-  "*List of functions taking a string argument that simplify subjects.
+  "List of functions taking a string argument that simplify subjects.
 The functions are applied recursively."
   :group 'gnus-thread
   :type '(repeat (list function)))
   :type 'boolean)
 
 (defcustom gnus-summary-dummy-line-format
-  "*  %(:                          :%) %S\n"
+  "  %(:                          :%) %S\n"
   "*The format specification for the dummy roots in the summary buffer.
 It works along the same lines as a normal formatting string,
 with some simple extensions.
   :type 'function)
 
 (defcustom gnus-summary-expunge-below nil
-  "*All articles that have a score less than this variable will be expunged.
+  "All articles that have a score less than this variable will be expunged.
 This variable is local to the summary buffers."
   :group 'gnus-score-default
   :type '(choice (const :tag "off" nil)
 		 integer))
 
 (defcustom gnus-thread-expunge-below nil
-  "*All threads that have a total score less than this variable will be expunged.
+  "All threads that have a total score less than this variable will be expunged.
 See `gnus-thread-score-function' for en explanation of what a
 \"thread score\" is.
 
   :type 'hook)
 
 (defcustom gnus-structured-field-decoder 'identity
-  "*Function to decode non-ASCII characters in structured field for summary."
+  "Function to decode non-ASCII characters in structured field for summary."
   :group 'gnus-various
   :type 'function)
 
 (defcustom gnus-unstructured-field-decoder 'identity
-  "*Function to decode non-ASCII characters in unstructured field for summary."
+  "Function to decode non-ASCII characters in unstructured field for summary."
   :group 'gnus-various
   :type 'function)
 
   :type 'hook)
 
 (defcustom gnus-summary-selected-face 'gnus-summary-selected-face
-  "*Face used for highlighting the current article in the summary buffer."
+  "Face used for highlighting the current article in the summary buffer."
   :group 'gnus-summary-visual
   :type 'face)
 
      . gnus-summary-high-unread-face)
     ((and (< score default) (= mark gnus-unread-mark))
      . gnus-summary-low-unread-face)
-    ((memq mark (list gnus-unread-mark gnus-downloadable-mark
-		      gnus-undownloaded-mark))
+    ((= mark gnus-unread-mark)
+     . gnus-summary-normal-unread-face)
+    ((and (> score default) (memq mark (list gnus-downloadable-mark
+					     gnus-undownloaded-mark)))
+     . gnus-summary-high-unread-face)
+    ((and (< score default) (memq mark (list gnus-downloadable-mark
+					     gnus-undownloaded-mark)))
+     . gnus-summary-low-unread-face)
+    ((memq mark (list gnus-downloadable-mark gnus-undownloaded-mark))
      . gnus-summary-normal-unread-face)
     ((> score default)
      . gnus-summary-high-read-face)
 		       face)))
 
 (defcustom gnus-alter-header-function nil
-  "*Function called to allow alteration of article header structures.
+  "Function called to allow alteration of article header structures.
 The function is called with one parameter, the article header vector,
 which it may alter in any way.")
 
 	    ;; Message-ID.
 	    (progn
 	      (goto-char p)
-	      (setq id (if (search-forward "\nmessage-id:" nil t)
-			   (buffer-substring
-			    (1- (or (search-forward "<" nil t) (point)))
-			    (or (search-forward ">" nil t) (point)))
+	      (setq id (if (re-search-forward
+			    "^message-id: *\\(<[^\n\t> ]+>\\)" nil t)
+			   ;; We do it this way to make sure the Message-ID
+			   ;; is (somewhat) syntactically valid.
+			   (buffer-substring (match-beginning 1)
+					     (match-end 1))
 			 ;; If there was no message-id, we just fake one
 			 ;; to make subsequent routines simpler.
 			 (nnheader-generate-fake-message-id))))
 
 (defun gnus-summary-insert-subject (id &optional old-header use-old-header)
   "Find article ID and insert the summary line for that article."
-  (let ((header (if (and old-header use-old-header)
-		    old-header (gnus-read-header id)))
+  (let ((header (cond ((and old-header use-old-header)
+		       old-header)
+		      ((and (numberp id)
+			    (gnus-number-to-header id))
+		       (gnus-number-to-header id))
+		      (t
+		       (gnus-read-header id))))
 	(number (and (numberp id) id))
 	pos d)
     (when header
 	    (delq (setq number (mail-header-number header))
 		  gnus-newsgroup-sparse))
       (setq gnus-newsgroup-ancient (delq number gnus-newsgroup-ancient))
+      (push number gnus-newsgroup-limit)
       (gnus-rebuild-thread (mail-header-id header))
       (gnus-summary-goto-subject number nil t))
     (when (and (numberp number)
   "Exit reading current newsgroup, and then return to group selection mode.
 gnus-exit-group-hook is called with no arguments if that value is non-nil."
   (interactive)
+  (gnus-set-global-variables)
   (gnus-kill-save-kill-buffer)
+  (gnus-async-halt-prefetch)
   (let* ((group gnus-newsgroup-name)
 	 (quit-config (gnus-group-quit-config gnus-newsgroup-name))
 	 (mode major-mode)
     (when gnus-use-trees
       (gnus-tree-close group))
     ;; Remove entries for this group.
-    (nnmail-purge-split-history group)
+    (nnmail-purge-split-history (gnus-group-real-name group))
     ;; Make all changes in this group permanent.
     (unless quit-config
       (gnus-run-hooks 'gnus-exit-group-hook)
     (when (or no-questions
 	      gnus-expert-user
 	      (gnus-y-or-n-p "Discard changes to this group and exit? "))
+      (gnus-async-halt-prefetch)
       ;; If we have several article buffers, we kill them at exit.
       (unless gnus-single-article-buffer
 	(gnus-kill-buffer gnus-article-buffer)
     (when (gnus-visual-p 'page-marker)
       (let ((buffer-read-only nil))
 	(gnus-remove-text-with-property 'gnus-prev)
-	(gnus-remove-text-with-property 'gnus-next)))))
+	(gnus-remove-text-with-property 'gnus-next))
+      (setq gnus-page-broken nil))))
 
 (defun gnus-summary-move-article (&optional n to-newsgroup
 					    select-method action)
   (gnus-summary-move-article n nil nil 'crosspost))
 
 (defcustom gnus-summary-respool-default-method nil
-  "*Default method for respooling an article.
+  "Default method for respooling an article.
 If nil, use to the current newsgroup method."
   :type `(choice (gnus-select-method :value (nnml ""))
 		 (const nil))
 		    (= mark gnus-duplicate-mark))))
        (setq mark gnus-expirable-mark))
   (let* ((mark (or mark gnus-del-mark))
-	 (article (or article (gnus-summary-article-number))))
-    (unless article
-      (error "No article on current line"))
-    (if (not (if (or (= mark gnus-unread-mark)
-		     (= mark gnus-ticked-mark)
-		     (= mark gnus-dormant-mark))
-		 (gnus-mark-article-as-unread article mark)
-	       (gnus-mark-article-as-read article mark)))
+	 (article (or article (gnus-summary-article-number)))
+	 (old-mark (gnus-summary-article-mark article)))
+    (if (eq mark old-mark)
 	t
-      ;; See whether the article is to be put in the cache.
-      (and gnus-use-cache
-	   (not (= mark gnus-canceled-mark))
-	   (vectorp (gnus-summary-article-header article))
-	   (save-excursion
-	     (gnus-cache-possibly-enter-article
-	      gnus-newsgroup-name article
-	      (gnus-summary-article-header article)
-	      (= mark gnus-ticked-mark)
-	      (= mark gnus-dormant-mark) (= mark gnus-unread-mark))))
-
-      (when (gnus-summary-goto-subject article nil t)
-	(let ((buffer-read-only nil))
-	  (gnus-summary-show-thread)
-	  ;; Fix the mark.
-	  (gnus-summary-update-mark mark 'unread)
-	  t)))))
+      (unless article
+	(error "No article on current line"))
+      (if (not (if (or (= mark gnus-unread-mark)
+		       (= mark gnus-ticked-mark)
+		       (= mark gnus-dormant-mark))
+		   (gnus-mark-article-as-unread article mark)
+		 (gnus-mark-article-as-read article mark)))
+	  t
+	;; See whether the article is to be put in the cache.
+	(and gnus-use-cache
+	     (not (= mark gnus-canceled-mark))
+	     (vectorp (gnus-summary-article-header article))
+	     (save-excursion
+	       (gnus-cache-possibly-enter-article
+		gnus-newsgroup-name article
+		(gnus-summary-article-header article)
+		(= mark gnus-ticked-mark)
+		(= mark gnus-dormant-mark) (= mark gnus-unread-mark))))
+
+	(when (gnus-summary-goto-subject article nil t)
+	  (let ((buffer-read-only nil))
+	    (gnus-summary-show-thread)
+	    ;; Fix the mark.
+	    (gnus-summary-update-mark mark 'unread)
+	    t))))))
 
 (defun gnus-summary-update-secondary-mark (article)
   "Update the secondary (read, process, cache) mark."
 			 (gnus-summary-article-header parent-article))))
 	(unless (and message-id (not (equal message-id "")))
 	  (error "No message-id in desired parent"))
-	(gnus-summary-select-article t t nil current-article)
+	;; We don't want the article to be marked as read.
+	(let (gnus-mark-article-hook)
+	  (gnus-summary-select-article t t nil current-article))
 	(set-buffer gnus-original-article-buffer)
 	(let ((buf (format "%s" (buffer-string))))
 	  (nnheader-temp-write nil
       (when buffers
 	(map-y-or-n-p
 	 "Update summary buffer %s? "
-	 (lambda (buf) (switch-to-buffer buf) (gnus-summary-exit))
+	 (lambda (buf)
+	   (switch-to-buffer buf)
+	   (gnus-summary-exit))
 	 buffers)))))
 
 (gnus-ems-redefine)

File gnus/lisp/gnus-topic.el

   "Minor mode for Gnus group buffers.")
 
 (defcustom gnus-topic-mode-hook nil
-  "*Hook run in topic mode buffers."
+  "Hook run in topic mode buffers."
   :type 'hook
   :group 'gnus-topic)
 
 (defcustom gnus-topic-line-format "%i[ %(%{%n%}%) -- %A ]%v\n"
-  "*Format of topic lines.
+  "Format of topic lines.
 It works along the same lines as a normal formatting string,
 with some simple extensions.
 
   "Run when changing levels to enter/remove groups from topics."
   (save-excursion
     (set-buffer gnus-group-buffer)
-    (unless gnus-topic-inhibit-change-level
-      (gnus-group-goto-group (or (car (nth 2 previous)) group))
-      (when (and gnus-topic-mode
-		 gnus-topic-alist
-		 (not gnus-topic-inhibit-change-level))
-	;; Remove the group from the topics.
-	(if (and (< oldlevel gnus-level-zombie)
-		 (>= level gnus-level-zombie))
-	    (let ((alist gnus-topic-alist))
-	      (while (gnus-group-goto-group group)
-		(gnus-delete-line))
-	      (while alist
-		(when (member group (car alist))
-		  (setcdr (car alist) (delete group (cdar alist))))
-		(pop alist)))
-	  ;; If the group is subscribed we enter it into the topics.
-	  (when (and (< level gnus-level-zombie)
-		     (>= oldlevel gnus-level-zombie))
-	    (let* ((prev (gnus-group-group-name))
-		   (gnus-topic-inhibit-change-level t)
-		   (gnus-group-indentation
-		    (make-string
-		     (* gnus-topic-indent-level
-			(or (save-excursion
-			      (gnus-topic-goto-topic (gnus-current-topic))
-			      (gnus-group-topic-level))
-			    0))
-		     ? ))
-		   (yanked (list group))
-		   alist talist end)
-	      ;; Then we enter the yanked groups into the topics they belong
-	      ;; to.
-	      (when (setq alist (assoc (save-excursion
-					 (forward-line -1)
-					 (or
-					  (gnus-current-topic)
-					  (caar gnus-topic-topology)))
-				       gnus-topic-alist))
-		(setq talist alist)
-		(when (stringp yanked)
-		  (setq yanked (list yanked)))
-		(if (not prev)
-		    (nconc alist yanked)
-		  (if (not (cdr alist))
-		      (setcdr alist (nconc yanked (cdr alist)))
-		    (while (and (not end) (cdr alist))
-		      (when (equal (cadr alist) prev)
+    (let ((buffer-read-only nil))
+      (unless gnus-topic-inhibit-change-level
+	(gnus-group-goto-group (or (car (nth 2 previous)) group))
+	(when (and gnus-topic-mode
+		   gnus-topic-alist
+		   (not gnus-topic-inhibit-change-level))
+	  ;; Remove the group from the topics.
+	  (if (and (< oldlevel gnus-level-zombie)
+		   (>= level gnus-level-zombie))
+	      (let ((alist gnus-topic-alist))
+		(while (gnus-group-goto-group group)
+		  (gnus-delete-line))
+		(while alist
+		  (when (member group (car alist))
+		    (setcdr (car alist) (delete group (cdar alist))))
+		  (pop alist)))
+	    ;; If the group is subscribed we enter it into the topics.
+	    (when (and (< level gnus-level-zombie)
+		       (>= oldlevel gnus-level-zombie))
+	      (let* ((prev (gnus-group-group-name))
+		     (gnus-topic-inhibit-change-level t)
+		     (gnus-group-indentation
+		      (make-string
+		       (* gnus-topic-indent-level
+			  (or (save-excursion
+				(gnus-topic-goto-topic (gnus-current-topic))
+				(gnus-group-topic-level))
+			      0))
+		       ? ))
+		     (yanked (list group))
+		     alist talist end)
+		;; Then we enter the yanked groups into the topics they belong
+		;; to.
+		(when (setq alist (assoc (save-excursion
+					   (forward-line -1)
+					   (or
+					    (gnus-current-topic)
+					    (caar gnus-topic-topology)))
+					 gnus-topic-alist))
+		  (setq talist alist)
+		  (when (stringp yanked)
+		    (setq yanked (list yanked)))
+		  (if (not prev)
+		      (nconc alist yanked)
+		    (if (not (cdr alist))
 			(setcdr alist (nconc yanked (cdr alist)))
-			(setq end t))
-		      (setq alist (cdr alist)))
-		    (unless end
-		      (nconc talist yanked))))))
-	    (gnus-topic-update-topic)))))))
+		      (while (and (not end) (cdr alist))
+			(when (equal (cadr alist) prev)
+			  (setcdr alist (nconc yanked (cdr alist)))
+			  (setq end t))
+			(setq alist (cdr alist)))
+		      (unless end
+			(nconc talist yanked))))))
+	      (gnus-topic-update-topic))))))))
 
 (defun gnus-topic-goto-next-group (group props)
   "Go to group or the next group after group."

File gnus/lisp/gnus-util.el

 	    (unless (eobp)
 	      (setq elem (buffer-substring
 			  (point) (progn (forward-sexp 1) (point))))
-	      (if (member elem tokens)
-		  (progn
-		    ;; Tokens that don't have a following value are ignored.
-		    (when (and pair (cdr pair))
-		      (push pair alist))
-		    (setq pair (list elem)))
+	      (cond
+	       ((equal elem "macdef")
+		;; We skip past the macro definition.
+		(widen)
+		(while (and (zerop (forward-line 1))
+			    (looking-at "$")))
+		(narrow-to-region (point) (point)))
+	       ((member elem tokens)
+		;; Tokens that don't have a following value are ignored.
+		(when (and pair (cdr pair))
+		  (push pair alist))
+		(setq pair (list elem)))
+	       (t
 		;; Values that haven't got a preceding token are ignored.
 		(when pair
 		  (setcdr pair elem)
 		  (push pair alist)
-		  (setq pair nil)))))
+		  (setq pair nil))))))
 	  (push alist result)
 	  (setq alist nil
 		pair nil)

File gnus/lisp/gnus-uu.el

   :type '(repeat (group regexp (string :tag "Command"))))
 
 (defcustom gnus-uu-user-view-rules nil
-  "*What actions are to be taken to view a file.
+  "What actions are to be taken to view a file.
 See the documentation on the `gnus-uu-default-view-rules' variable for
 details."
   :group 'gnus-extract-view
   (list "uncompress" "gunzip"))
 
 (defcustom gnus-uu-user-archive-rules nil
-  "*A list that can be set to override the default archive unpacking commands.
+  "A list that can be set to override the default archive unpacking commands.
 To use, for instance, 'untar' to unpack tar files and 'zip -x' to
 unpack zip files, say the following:
   (setq gnus-uu-user-archive-rules
   :type 'boolean)
 
 (defcustom gnus-uu-grabbed-file-functions nil
-  "*Functions run on each file after successful decoding.
+  "Functions run on each file after successful decoding.
 They will be called with the name of the file as the argument.
 Likely functions you can use in this list are `gnus-uu-grab-view'
 and `gnus-uu-grab-move'."
   :type 'boolean)
 
 (defcustom gnus-uu-pre-uudecode-hook nil
-  "*Hook run before sending a message to uudecode."
+  "Hook run before sending a message to uudecode."
   :group 'gnus-extract
   :type 'hook)
 
 ;; and "spiral.jpg", respectively.) The function should return nil if
 ;; the encoding wasn't successful.
 (defcustom gnus-uu-post-encode-method 'gnus-uu-post-encode-uuencode
-  "*Function used for encoding binary files.
+  "Function used for encoding binary files.
 There are three functions supplied with gnus-uu for encoding files:
 `gnus-uu-post-encode-uuencode', which does straight uuencoding;
 `gnus-uu-post-encode-mime', which encodes with base64 and adds MIME
 		(function :tag "Other")))
 
 (defcustom gnus-uu-post-include-before-composing nil
-  "*Non-nil means that gnus-uu will ask for a file to encode before you compose the article.
+  "Non-nil means that gnus-uu will ask for a file to encode before you compose the article.
 If this variable is t, you can either include an encoded file with
 \\[gnus-uu-post-insert-binary-in-article] or have one included for you when you post the article."
   :group 'gnus-extract-post
   :type 'boolean)
 
 (defcustom gnus-uu-post-length 990
-  "*Maximum length of an article.
+  "Maximum length of an article.
 The encoded file will be split into how many articles it takes to
 post the entire file."
   :group 'gnus-extract-post
   :type 'integer)
 
 (defcustom gnus-uu-post-threaded nil
-  "*Non-nil means that gnus-uu will post the encoded file in a thread.
+  "Non-nil means that gnus-uu will post the encoded file in a thread.
 This may not be smart, as no other decoder I have seen are able to
 follow threads when collecting uuencoded articles.  (Well, I have seen
 one package that does that - gnus-uu, but somehow, I don't think that
   :type 'boolean)
 
 (defcustom gnus-uu-post-separate-description t
-  "*Non-nil means that the description will be posted in a separate article.
+  "Non-nil means that the description will be posted in a separate article.
 The first article will typically be numbered (0/x).  If this variable
 is nil, the description the user enters will be included at the
 beginning of the first article, which will be numbered (1/x).  Default

File gnus/lisp/gnus-xmas.el

   :group 'gnus)
 
 (defcustom gnus-xmas-glyph-directory nil
-  "*Directory where Gnus logos and icons are located.
+  "Directory where Gnus logos and icons are located.
 If this variable is nil, Gnus will try to locate the directory
 automatically."
   :type '(choice (const :tag "autodetect" nil)

File gnus/lisp/gnus.el

   :link '(custom-manual "(gnus)Exiting Gnus")
   :group 'gnus)
 
-(defconst gnus-version-number "0.29"
+(defconst gnus-version-number "0.32"
   "Version number for this version of Gnus.")
 
 (defconst gnus-version (format "Quassia Gnus v%s" gnus-version-number)
   "Version string for this version of Gnus.")
 
 (defcustom gnus-inhibit-startup-message nil
-  "*If non-nil, the startup message will not be displayed.
+  "If non-nil, the startup message will not be displayed.
 This variable is used before `.gnus.el' is loaded, so it should
 be set in `.emacs' instead."
   :group 'gnus-start
   :type 'boolean)
 
 (defcustom gnus-play-startup-jingle nil
-  "*If non-nil, play the Gnus jingle at startup."
+  "If non-nil, play the Gnus jingle at startup."
   :group 'gnus-start
   :type 'boolean)
 
 (require 'nnheader)
 
 (defcustom gnus-home-directory "~/"
-  "*Directory variable that specifies the \"home\" directory.
+  "Directory variable that specifies the \"home\" directory.
 All other Gnus path variables are initialized from this variable."
   :group 'gnus-files
   :type 'directory)
 
 (defcustom gnus-directory (or (getenv "SAVEDIR")
-			      (nnheader-concat gnus-home-directory "News/"))
+		      (nnheader-concat gnus-home-directory "News/"))
   "*Directory variable from which all other Gnus file variables are derived."
   :group 'gnus-files
   :type 'directory)
  (setq gnus-select-method '(nntp \"my.nntp.server\" (nntp-port-number 899)))")
 
 (defcustom gnus-nntpserver-file "/etc/nntpserver"
-  "*A file with only the name of the nntp server in it."
+  "A file with only the name of the nntp server in it."
   :group 'gnus-files
   :group 'gnus-server
   :type 'file)
 		 string))
 
 (defcustom gnus-secondary-servers nil
-  "*List of NNTP servers that the user can choose between interactively.
+  "List of NNTP servers that the user can choose between interactively.
 To make Gnus query you for a server, you have to give `gnus' a
 non-numeric prefix - `C-u M-x gnus', in short."
   :group 'gnus-server
 		 string))
 
 (defcustom gnus-secondary-select-methods nil
-  "*A list of secondary methods that will be used for reading news.
+  "A list of secondary methods that will be used for reading news.
 This is a list where each element is a complete select method (see
 `gnus-select-method').
 
 Should be set in paths.el, and shouldn't be touched by the user.")
 
 (defcustom gnus-local-domain nil
-  "*Local domain name without a host name.
+  "Local domain name without a host name.
 The DOMAINNAME environment variable is used instead if it is defined.
 If the `system-name' function returns the full Internet name, there is
 no need to set this variable."
 ;; Customization variables
 
 (defcustom gnus-refer-article-method nil
-  "*Preferred method for fetching an article by Message-ID.
+  "Preferred method for fetching an article by Message-ID.
 If you are reading news from the local spool (with nnspool), fetching
 articles by Message-ID is painfully slow.  By setting this method to an
 nntp method, you might get acceptable results.
   :type 'boolean)
 
 (defcustom gnus-use-demon nil
-  "*If non-nil, Gnus might use some demons."
+  "If non-nil, Gnus might use some demons."
   :group 'gnus-meta
   :type 'boolean)
 
   :type 'boolean)
 
 (defcustom gnus-shell-command-separator ";"
-  "*String used to separate to shell commands."
+  "String used to separate to shell commands."
   :group 'gnus-files
   :type 'string)
 
 				(sexp :tag "Value")))))
 
 (defcustom gnus-updated-mode-lines '(group article summary tree)
-  "*List of buffers that should update their mode lines.
+  "List of buffers that should update their mode lines.
 The list may contain the symbols `group', `article', `tree' and
 `summary'.  If the corresponding symbol is present, Gnus will keep
 that mode line updated with information that may be pertinent.
 		 regexp))
 
 (defcustom gnus-group-uncollapsed-levels 1
-  "*Number of group name elements to leave alone when making a short group name."
+  "Number of group name elements to leave alone when making a short group name."
   :group 'gnus-group-visual
   :type 'integer)
 
 ;; Hooks.
 
 (defcustom gnus-load-hook nil
-  "*A hook run while Gnus is loaded."
+  "A hook run while Gnus is loaded."
   :group 'gnus-start
   :type 'hook)
 
 (defcustom gnus-apply-kill-hook '(gnus-apply-kill-file)
-  "*A hook called to apply kill files to a group.
+  "A hook called to apply kill files to a group.
 This hook is intended to apply a kill file to the selected newsgroup.
 The function `gnus-apply-kill-file' is called by default.
 
   :type 'hook)
 
 (defcustom gnus-group-change-level-function nil
-  "*Function run when a group level is changed.
+  "Function run when a group level is changed.
 It is called with three parameters -- GROUP, LEVEL and OLDLEVEL."
   :group 'gnus-group-level
   :type 'function)
 
 ;; Variable holding the user answers to all method prompts.
 (defvar gnus-method-history nil)
-(defvar gnus-group-history nil)
 
 ;; Variable holding the user answers to all mail method prompts.
 (defvar gnus-mail-method-history nil)
 ;;; gnus-sum.el thingies
 
 
-(defcustom gnus-summary-line-format "%U\%R\%z\%I\%(%[%4L: %-20,20n%]%) %s\n"
+(defcustom gnus-summary-line-format "%U%R%z%I%(%[%4L: %-20,20n%]%) %s\n"
   "*The format specification of the lines in the summary buffer.
 
 It works along the same lines as a normal formatting string,
 	(kill-buffer (current-buffer))))))
 
 (defcustom gnus-kill-file-name "KILL"
-  "*Suffix of the kill files."
+  "Suffix of the kill files."
   :group 'gnus-score-kill
   :group 'gnus-score-files
   :type 'string)

File gnus/lisp/message.el

   :type 'integer)
 
 (defcustom message-send-rename-function nil
-  "*Function called to rename the buffer after sending it."
+  "Function called to rename the buffer after sending it."
   :group 'message-buffers
   :type 'function)
 
   :group 'message-headers)
 
 (defcustom message-syntax-checks nil
-  ;; Guess this one shouldn't be easy to customize...
+  ; Guess this one shouldn't be easy to customize...
   "*Controls what syntax checks should not be performed on outgoing posts.
 To disable checking of long signatures, for instance, add
  `(signature . disabled)' to this list.
   :type '(repeat sexp))
 
 (defcustom message-deletable-headers '(Message-ID Date Lines)
-  "*Headers to be deleted if they already exist and were generated by message previously."
+  "Headers to be deleted if they already exist and were generated by message previously."
   :group 'message-headers
   :type 'sexp)
 
 
 ;;;###autoload
 (defcustom message-signature-separator "^-- *$"
-  "*Regexp matching the signature separator."
+  "Regexp matching the signature separator."
   :type 'regexp
   :group 'message-various)
 
   :group 'message-various)
 
 (defcustom message-interactive nil
-  "*Non-nil means when sending a message wait for and display errors.
+  "Non-nil means when sending a message wait for and display errors.
 nil means let mailer mail back a message to report errors."
   :group 'message-sending
   :group 'message-mail
   :type 'regexp)
 
 (defcustom message-cancel-message "I am canceling my own article."
-  "*Message to be inserted in the cancel message."
+  "Message to be inserted in the cancel message."
   :group 'message-interface
   :type 'string)
 
 ;; Useful to set in site-init.el
 ;;;###autoload
 (defcustom message-send-mail-function 'message-send-mail-with-sendmail
-  "*Function to call to send the current buffer as mail.
+  "Function to call to send the current buffer as mail.
 The headers should be delimited by a line whose contents match the
 variable `mail-header-separator'.
 
   :group 'message-mail)
 
 (defcustom message-send-news-function 'message-send-news
-  "*Function to call to send the current buffer as news.
+  "Function to call to send the current buffer as news.
 The headers should be delimited by a line whose contents match the
 variable `mail-header-separator'."
   :group 'message-sending
   :type 'function)
 
 (defcustom message-reply-to-function nil
-  "*Function that should return a list of headers.
+  "Function that should return a list of headers.
 This function should pick out addresses from the To, Cc, and From headers
 and respond with new To and Cc headers."
   :group 'message-interface
   :type 'function)
 
 (defcustom message-wide-reply-to-function nil
-  "*Function that should return a list of headers.
+  "Function that should return a list of headers.
 This function should pick out addresses from the To, Cc, and From headers
 and respond with new To and Cc headers."
   :group 'message-interface
   :type 'function)
 
 (defcustom message-followup-to-function nil
-  "*Function that should return a list of headers.
+  "Function that should return a list of headers.
 This function should pick out addresses from the To, Cc, and From headers
 and respond with new To and Cc headers."
   :group 'message-interface
 
 ;; qmail-related stuff
 (defcustom message-qmail-inject-program "/var/qmail/bin/qmail-inject"
-  "*Location of the qmail-inject program."
+  "Location of the qmail-inject program."
   :group 'message-sending
   :type 'file)
 
 (defcustom message-qmail-inject-args nil
-  "*Arguments passed to qmail-inject programs.
+  "Arguments passed to qmail-inject programs.
 This should be a list of strings, one string for each argument.
 
 For e.g., if you wish to set the envelope sender address so that bounces
   :type 'boolean)
 
 (defcustom message-setup-hook nil
-  "*Normal hook, run each time a new outgoing message is initialized.
+  "Normal hook, run each time a new outgoing message is initialized.
 The function `message-setup' runs this hook."
   :group 'message-various
   :type 'hook)
 
 (defcustom message-signature-setup-hook nil
-  "*Normal hook, run each time a new outgoing message is initialized.
+  "Normal hook, run each time a new outgoing message is initialized.
 It is run after the headers have been inserted and before
 the signature is inserted."
   :group 'message-various
   :type 'hook)
 
 (defcustom message-mode-hook nil
-  "*Hook run in message mode buffers."
+  "Hook run in message mode buffers."
   :group 'message-various
   :type 'hook)
 
 (defcustom message-header-hook nil